diff options
Diffstat (limited to 'jvmfwk/plugins/sunmajor/pluginlib/util.cxx')
| -rw-r--r-- | jvmfwk/plugins/sunmajor/pluginlib/util.cxx | 1267 |
1 files changed, 1267 insertions, 0 deletions
diff --git a/jvmfwk/plugins/sunmajor/pluginlib/util.cxx b/jvmfwk/plugins/sunmajor/pluginlib/util.cxx new file mode 100644 index 000000000000..bd49956c8baf --- /dev/null +++ b/jvmfwk/plugins/sunmajor/pluginlib/util.cxx @@ -0,0 +1,1267 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_jvmfwk.hxx" + +#include "util.hxx" + +#include "osl/process.h" +#include "osl/security.hxx" +#include "osl/thread.hxx" +#include "osl/file.hxx" +#include "osl/module.hxx" +#include "rtl/byteseq.hxx" +#include "rtl/ustrbuf.hxx" +#include "rtl/instance.hxx" +#include "boost/scoped_array.hpp" +#include "com/sun/star/uno/Sequence.hxx" +#include <utility> +#include <algorithm> +#include <map> + +#if defined WNT +#if defined _MSC_VER +#pragma warning(push, 1) +#endif +#include <windows.h> +#if defined _MSC_VER +#pragma warning(pop) +#endif +#endif +#include <string.h> + +#include "sunjre.hxx" +#include "vendorlist.hxx" +#include "diagnostics.h" +using namespace rtl; +using namespace osl; +using namespace std; + +#define CHAR_POINTER(oustr) ::rtl::OUStringToOString(oustr,RTL_TEXTENCODING_UTF8).pData->buffer +#define OUSTR(x) ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(x) ) +#ifdef WNT +#define HKEY_SUN_JRE L"Software\\JavaSoft\\Java Runtime Environment" +#define HKEY_SUN_SDK L"Software\\JavaSoft\\Java Development Kit" +#endif + +#ifdef UNX +namespace { +char const *g_arJavaNames[] = { + "", + "j2re", + "j2se", + "j2sdk", + "jdk", + "jre", + "java", + "Home", + "IBMJava2-ppc-142" +}; +/* These are directory names which could contain multiple java installations. + */ +char const *g_arCollectDirs[] = { + "", + "j2re/", + "j2se/", + "j2sdk/", + "jdk/", + "jre/", + "java/", + "jvm/" +}; + +/* These are directories in which a java installation is + looked for. +*/ +char const *g_arSearchPaths[] = { +#ifdef MACOSX + "", + "System/Library/Frameworks/JavaVM.framework/Versions/1.4.2/" +#else + "", + "usr/", + "usr/local/", + "usr/local/IBMJava2-ppc-142", + "usr/local/j2sdk1.3.1", +#ifdef X86_64 + "usr/lib64/", +#endif + "usr/lib/", + "usr/bin/" +#endif +}; +} +#endif // UNX + +namespace jfw_plugin +{ +extern VendorSupportMapEntry gVendorMap[]; + +bool getSDKInfoFromRegistry(vector<OUString> & vecHome); +bool getJREInfoFromRegistry(vector<OUString>& vecJavaHome); +bool decodeOutput(const rtl::OString& s, rtl::OUString* out); + + + +namespace +{ + rtl::OUString getLibraryLocation() + { + rtl::OUString libraryFileUrl; + OSL_VERIFY(osl::Module::getUrlFromAddress((void *)(sal_IntPtr)getLibraryLocation, libraryFileUrl)); + return getDirFromFile(libraryFileUrl); + } + + struct InitBootstrap + { + rtl::Bootstrap * operator()(const OUString& sIni) + { + static rtl::Bootstrap aInstance(sIni); + return & aInstance; + + } + }; + + struct InitBootstrapData + { + OUString const & operator()() + { + // osl::Guard<osl::Mutex> g(osl::GetGlobalMutex()); + static OUString sIni; + rtl::OUStringBuffer buf( 255); + buf.append( getLibraryLocation()); + buf.appendAscii( SAL_CONFIGFILE("/sunjavaplugin") ); + sIni = buf.makeStringAndClear(); + JFW_TRACE2(OUSTR("[Java framework] sunjavaplugin: " + "Using configuration file \n") + sIni); + return sIni; + } + }; +} + +rtl::Bootstrap * getBootstrap() +{ + return rtl_Instance< rtl::Bootstrap, InitBootstrap, + ::osl::MutexGuard, ::osl::GetGlobalMutex, + OUString, InitBootstrapData >::create( + InitBootstrap(), ::osl::GetGlobalMutex(), InitBootstrapData()); +} + + + + +class FileHandleGuard +{ +public: + inline FileHandleGuard(oslFileHandle & rHandle) SAL_THROW(()): + m_rHandle(rHandle) {} + + inline ~FileHandleGuard() SAL_THROW(()); + + inline oslFileHandle & getHandle() SAL_THROW(()) { return m_rHandle; } + +private: + oslFileHandle & m_rHandle; + + FileHandleGuard(FileHandleGuard &); // not implemented + void operator =(FileHandleGuard); // not implemented +}; + +inline FileHandleGuard::~FileHandleGuard() SAL_THROW(()) +{ + if (m_rHandle != 0) + { + if (osl_closeFile(m_rHandle) != osl_File_E_None) + { + OSL_ENSURE(false, "unexpected situation"); + } + } +} + + +class FileHandleReader +{ +public: + enum Result + { + RESULT_OK, + RESULT_EOF, + RESULT_ERROR + }; + + inline FileHandleReader(oslFileHandle & rHandle) SAL_THROW(()): + m_aGuard(rHandle), m_nSize(0), m_nIndex(0), m_bLf(false) {} + + Result readLine(rtl::OString * pLine) SAL_THROW(()); + +private: + enum { BUFFER_SIZE = 1024 }; + + sal_Char m_aBuffer[BUFFER_SIZE]; + FileHandleGuard m_aGuard; + int m_nSize; + int m_nIndex; + bool m_bLf; +}; + +FileHandleReader::Result +FileHandleReader::readLine(rtl::OString * pLine) + SAL_THROW(()) +{ + OSL_ENSURE(pLine, "specification violation"); + + for (bool bEof = true;; bEof = false) + { + if (m_nIndex == m_nSize) + { + sal_uInt64 nRead = 0; + switch (osl_readFile( + m_aGuard.getHandle(), m_aBuffer, sizeof(m_aBuffer), &nRead)) + { + case osl_File_E_PIPE: //HACK! for windows + nRead = 0; + case osl_File_E_None: + if (nRead == 0) + { + m_bLf = false; + return bEof ? RESULT_EOF : RESULT_OK; + } + m_nIndex = 0; + m_nSize = static_cast< int >(nRead); + break; + case osl_File_E_INTR: + continue; + + default: + return RESULT_ERROR; + } + } + + if (m_bLf && m_aBuffer[m_nIndex] == 0x0A) + ++m_nIndex; + m_bLf = false; + + int nStart = m_nIndex; + while (m_nIndex != m_nSize) + switch (m_aBuffer[m_nIndex++]) + { + case 0x0D: + m_bLf = true; + case 0x0A: + *pLine += rtl::OString(m_aBuffer + nStart, + m_nIndex - 1 - nStart); + //TODO! check for overflow, and not very efficient + return RESULT_OK; + } + + *pLine += rtl::OString(m_aBuffer + nStart, m_nIndex - nStart); + //TODO! check for overflow, and not very efficient + } +} + +class AsynchReader: public Thread +{ + size_t m_nDataSize; + boost::scoped_array<sal_Char> m_arData; + + bool m_bError; + bool m_bDone; + FileHandleGuard m_aGuard; + + void SAL_CALL run(); +public: + + AsynchReader(oslFileHandle & rHandle); +#if OSL_DEBUG_LEVEL >= 2 + /** only call this function after this thread has finished. + + That is, call join on this instance and then call getData. + + */ + OString getData(); +#endif +}; + +AsynchReader::AsynchReader(oslFileHandle & rHandle): + m_nDataSize(0), m_bError(false), m_bDone(false), m_aGuard(rHandle) +{ +} + +#if OSL_DEBUG_LEVEL >= 2 +OString AsynchReader::getData() +{ + OSL_ASSERT(isRunning() == sal_False ); + return OString(m_arData.get(), m_nDataSize); +} +#endif + +void AsynchReader::run() +{ + const sal_uInt64 BUFFER_SIZE = 4096; + sal_Char aBuffer[BUFFER_SIZE]; + while (true) + { + sal_uInt64 nRead; + //the function blocks until something could be read or the pipe closed. + switch (osl_readFile( + m_aGuard.getHandle(), aBuffer, BUFFER_SIZE, &nRead)) + { + case osl_File_E_PIPE: //HACK! for windows + nRead = 0; + case osl_File_E_None: + break; + default: + m_bError = true; + return; + } + + if (nRead == 0) + { + m_bDone = true; + break; + } + else if (nRead <= BUFFER_SIZE) + { + //Save the data we have in m_arData into a temporary array + boost::scoped_array<sal_Char> arTmp( new sal_Char[m_nDataSize]); + memcpy(arTmp.get(), m_arData.get(), m_nDataSize); + //Enlarge m_arData to hold the newly read data + m_arData.reset(new sal_Char[(size_t)(m_nDataSize + nRead)]); + //Copy back the data that was already in m_arData + memcpy(m_arData.get(), arTmp.get(), m_nDataSize); + //Add the newly read data to m_arData + memcpy(m_arData.get() + m_nDataSize, aBuffer, (size_t) nRead); + m_nDataSize += (size_t) nRead; + } + } +} + + +bool getJavaProps(const OUString & exePath, + std::vector<std::pair<rtl::OUString, rtl::OUString> >& props, + bool * bProcessRun) +{ + bool ret = false; + + OSL_ASSERT( exePath.getLength() > 0); + OUString usStartDir; + //We need to set the CLASSPATH in case the office is started from + //a different directory. The JREProperties.class is expected to reside + //next to the plugin. + rtl::OUString sThisLib; + if (osl_getModuleURLFromAddress((void *) (sal_IntPtr)& getJavaProps, + & sThisLib.pData) == sal_False) + return false; + sThisLib = getDirFromFile(sThisLib); + OUString sClassPath; + if (osl_getSystemPathFromFileURL(sThisLib.pData, & sClassPath.pData) + != osl_File_E_None) + return false; + + //check if we shall examine a Java for accessibility support + //If the bootstrap variable is "1" then we pass the argument + //"noaccessibility" to JREProperties.class. This will prevent + //that it calls java.awt.Toolkit.getDefaultToolkit(); + OUString sValue; + getBootstrap()->getFrom(OUSTR("JFW_PLUGIN_DO_NOT_CHECK_ACCESSIBILITY"), sValue); + + //prepare the arguments + sal_Int32 cArgs = 3; + OUString arg1 = OUString(RTL_CONSTASCII_USTRINGPARAM("-classpath"));// + sClassPath; + OUString arg2 = sClassPath; + OUString arg3(RTL_CONSTASCII_USTRINGPARAM("JREProperties")); + OUString arg4 = OUSTR("noaccessibility"); + rtl_uString *args[4] = {arg1.pData, arg2.pData, arg3.pData}; + + // Only add the fourth param if the bootstrap parameter is set. + if (sValue.equals(OUString::valueOf((sal_Int32) 1))) + { + args[3] = arg4.pData; + cArgs = 4; + } + + oslProcess javaProcess= 0; + oslFileHandle fileOut= 0; + oslFileHandle fileErr= 0; + + FileHandleReader stdoutReader(fileOut); + AsynchReader stderrReader(fileErr); + + JFW_TRACE2(OUSTR("\n[Java framework] Executing: ") + exePath + OUSTR(".\n")); + oslProcessError procErr = + osl_executeProcess_WithRedirectedIO( exePath.pData,//usExe.pData, + args, + cArgs, //sal_uInt32 nArguments, + osl_Process_HIDDEN, //oslProcessOption Options, + NULL, //oslSecurity Security, + usStartDir.pData,//usStartDir.pData,//usWorkDir.pData, //rtl_uString *strWorkDir, + NULL, //rtl_uString *strEnvironment[], + 0, // sal_uInt32 nEnvironmentVars, + &javaProcess, //oslProcess *pProcess, + NULL,//oslFileHandle *pChildInputWrite, + &fileOut,//oslFileHandle *pChildOutputRead, + &fileErr);//oslFileHandle *pChildErrorRead); + + if( procErr != osl_Process_E_None) + { + JFW_TRACE2("[Java framework] Execution failed. \n"); + *bProcessRun = false; + return ret; + } + else + { + JFW_TRACE2("[Java framework] Java executed successfully.\n"); + *bProcessRun = true; + } + + //Start asynchronous reading (different thread) of error stream + stderrReader.create(); + + //Use this thread to read output stream + FileHandleReader::Result rs = FileHandleReader::RESULT_OK; + while (1) + { + OString aLine; + rs = stdoutReader.readLine( & aLine); + if (rs != FileHandleReader::RESULT_OK) + break; + JFW_TRACE2(OString("[Java framework] line:\" ") + + aLine + OString(" \".\n")); + OUString sLine; + if (!decodeOutput(aLine, &sLine)) + continue; + JFW_TRACE2(OString("[Java framework] line:\" ") + + OString( CHAR_POINTER(sLine)) + OString(" \".\n")); + sLine = sLine.trim(); + if (sLine.getLength() == 0) + continue; + //The JREProperties class writes key value pairs, separated by '=' + sal_Int32 index = sLine.indexOf('=', 0); + OSL_ASSERT(index != -1); + OUString sKey = sLine.copy(0, index); + OUString sVal = sLine.copy(index + 1); + + props.push_back(std::make_pair(sKey, sVal)); + } + + if (rs != FileHandleReader::RESULT_ERROR && props.size()>0) + ret = true; + + //process error stream data + stderrReader.join(); + JFW_TRACE2(OString("[Java framework] Java wrote to stderr:\" ") + + stderrReader.getData() + OString(" \".\n")); + + TimeValue waitMax= {5 ,0}; + procErr = osl_joinProcessWithTimeout(javaProcess, &waitMax); + OSL_ASSERT(procErr == osl_Process_E_None); + osl_freeProcessHandle(javaProcess); + return ret; +} + +/* converts the properties printed by JREProperties.class into + readable strings. The strings are encoded as integer values separated + by spaces. + */ +bool decodeOutput(const rtl::OString& s, rtl::OUString* out) +{ + OSL_ASSERT(out != 0); + OUStringBuffer buff(512); + sal_Int32 nIndex = 0; + do + { + OString aToken = s.getToken( 0, ' ', nIndex ); + if (aToken.getLength()) + { + for (sal_Int32 i = 0; i < aToken.getLength(); ++i) + { + if (aToken[i] < '0' || aToken[i] > '9') + return false; + } + sal_Unicode value = (sal_Unicode)(aToken.toInt32()); + buff.append(value); + } + } while (nIndex >= 0); + + *out = buff.makeStringAndClear(); + JFW_TRACE2(*out); + return true; +} + + +#if defined WNT +void createJavaInfoFromWinReg(std::vector<rtl::Reference<VendorBase> > & vecInfos) +{ + // Get Java s from registry + std::vector<OUString> vecJavaHome; + if(getSDKInfoFromRegistry(vecJavaHome)) + { + // create impl objects + typedef std::vector<OUString>::iterator ItHome; + for(ItHome it_home= vecJavaHome.begin(); it_home != vecJavaHome.end(); + it_home++) + { + getJREInfoByPath(*it_home, vecInfos); + } + } + + vecJavaHome.clear(); + if(getJREInfoFromRegistry(vecJavaHome)) + { + typedef std::vector<OUString>::iterator ItHome; + for(ItHome it_home= vecJavaHome.begin(); it_home != vecJavaHome.end(); + it_home++) + { + getJREInfoByPath(*it_home, vecInfos); + } + } +} + + +bool getJavaInfoFromRegistry(const wchar_t* szRegKey, + vector<OUString>& vecJavaHome) +{ + HKEY hRoot; + if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, szRegKey, 0, KEY_ENUMERATE_SUB_KEYS, &hRoot) + == ERROR_SUCCESS) + { + DWORD dwIndex = 0; + const DWORD BUFFSIZE = 1024; + wchar_t bufVersion[BUFFSIZE]; +// char bufVersion[BUFFSIZE]; + DWORD nNameLen = BUFFSIZE; + FILETIME fileTime; + nNameLen = sizeof(bufVersion); + + // Iterate over all subkeys of HKEY_LOCAL_MACHINE\Software\JavaSoft\Java Runtime Environment + while (RegEnumKeyExW(hRoot, dwIndex, bufVersion, &nNameLen, NULL, NULL, NULL, &fileTime) != ERROR_NO_MORE_ITEMS) + { + HKEY hKey; + // Open a Java Runtime Environment sub key, e.g. "1.4.0" + if (RegOpenKeyExW(hRoot, bufVersion, 0, KEY_QUERY_VALUE, &hKey) == ERROR_SUCCESS) + { + DWORD dwType; + DWORD dwTmpPathLen= 0; + // Get the path to the JavaHome every JRE entry + // Find out how long the string for JavaHome is and allocate memory to hold the path + if( RegQueryValueExW(hKey, L"JavaHome", 0, &dwType, NULL, &dwTmpPathLen)== ERROR_SUCCESS) + { + char* szTmpPath= (char *) malloc( dwTmpPathLen); + // Get the path for the runtime lib + if(RegQueryValueExW(hKey, L"JavaHome", 0, &dwType, (unsigned char*) szTmpPath, &dwTmpPathLen) == ERROR_SUCCESS) + { + // There can be several version entries refering with the same JavaHome,e.g 1.4 and 1.4.1 + OUString usHome((sal_Unicode*) szTmpPath); + // check if there is already an entry with the same JavaHomeruntime lib + // if so, we use the one with the more accurate version + bool bAppend= true; + OUString usHomeUrl; + if (osl_getFileURLFromSystemPath(usHome.pData, & usHomeUrl.pData) == + osl_File_E_None) + { + //iterate over the vector with java home strings + typedef vector<OUString>::iterator ItHome; + for(ItHome itHome= vecJavaHome.begin(); + itHome != vecJavaHome.end(); itHome++) + { + if(usHomeUrl.equals(*itHome)) + { + bAppend= false; + break; + } + } + // Save the home dir + if(bAppend) + { + vecJavaHome.push_back(usHomeUrl); + } + } + } + free( szTmpPath); + RegCloseKey(hKey); + } + } + dwIndex ++; + nNameLen = BUFFSIZE; + } + RegCloseKey(hRoot); + } + return true; +} + + + +bool getSDKInfoFromRegistry(vector<OUString> & vecHome) +{ + return getJavaInfoFromRegistry(HKEY_SUN_SDK, vecHome); +} + +bool getJREInfoFromRegistry(vector<OUString>& vecJavaHome) +{ + return getJavaInfoFromRegistry(HKEY_SUN_JRE, vecJavaHome); +} + +#endif // WNT + +void bubbleSortVersion(vector<rtl::Reference<VendorBase> >& vec) +{ + if(vec.size() == 0) + return; + int size= vec.size() - 1; + int cIter= 0; + // sort for version + for(int i= 0; i < size; i++) + { + for(int j= size; j > 0 + cIter; j--) + { + rtl::Reference<VendorBase>& cur= vec.at(j); + rtl::Reference<VendorBase>& next= vec.at(j-1); + + int nCmp = 0; + // comparing invalid SunVersion s is possible, they will be less than a + // valid version + + //check if version of current is recognized, by comparing it with itself + try + { + cur->compareVersions(cur->getVersion()); + } + catch (MalformedVersionException &) + { + nCmp = -1; // current < next + } + //The version of cur is valid, now compare with the second version + if (nCmp == 0) + { + try + { + nCmp = cur->compareVersions(next->getVersion()); + } + catch (MalformedVersionException & ) + { + //The second version is invalid, therefor it is regardes less. + nCmp = 1; + } + } + if(nCmp == 1) // cur > next + { + rtl::Reference<VendorBase> less = next; + vec.at(j-1)= cur; + vec.at(j)= less; + } + } + cIter++; + } +} + + +bool getJREInfoFromBinPath( + const rtl::OUString& path, vector<rtl::Reference<VendorBase> > & vecInfos) +{ + // file:///c:/jre/bin + //map: jre/bin/java.exe + bool ret = false; + vector<pair<OUString, OUString> > props; + + for ( sal_Int32 pos = 0; + gVendorMap[pos].sVendorName != NULL; ++pos ) + { + vector<OUString> vecPaths; + getJavaExePaths_func pFunc = gVendorMap[pos].getJavaFunc; + + int size = 0; + char const* const* arExePaths = (*pFunc)(&size); + vecPaths = getVectorFromCharArray(arExePaths, size); + + //make sure argument path does not end with '/' + OUString sBinPath = path; + if (path.lastIndexOf('/') == (path.getLength() - 1)) + sBinPath = path.copy(0, path.getLength() - 1); + + typedef vector<OUString>::const_iterator c_it; + for (c_it i = vecPaths.begin(); i != vecPaths.end(); i++) + { + //the map contains e.g. jre/bin/java.exe + //get the directory where the executable is contained + OUString sHome; + sal_Int32 index = i->lastIndexOf('/'); + if (index == -1) + { + //map contained only : "java.exe, then the argument + //path is already the home directory + sHome = sBinPath; + } + else + { + // jre/bin/jre -> jre/bin + OUString sMapPath(i->getStr(), index); + index = sBinPath.lastIndexOf(sMapPath); + if (index != -1 + && (index + sMapPath.getLength() == sBinPath.getLength()) + && sBinPath[index - 1] == '/') + { + sHome = OUString(sBinPath.getStr(), index - 1); + } + } + if (sHome.getLength() > 0) + { + ret = getJREInfoByPath(sHome, vecInfos); + if (ret) + break; + } + } + if (ret) + break; + } + return ret; +} + +vector<Reference<VendorBase> > getAllJREInfos() +{ + vector<Reference<VendorBase> > vecInfos; + +#if defined WNT + // Get Javas from the registry + createJavaInfoFromWinReg(vecInfos); +#endif // WNT + + createJavaInfoFromJavaHome(vecInfos); + //this function should be called after createJavaInfoDirScan. + //Otherwise in SDKs Java may be started twice + createJavaInfoFromPath(vecInfos); + +#ifdef UNX + createJavaInfoDirScan(vecInfos); +#endif + + bubbleSortVersion(vecInfos); + return vecInfos; +} + + +vector<OUString> getVectorFromCharArray(char const * const * ar, int size) +{ + vector<OUString> vec; + for( int i = 0; i < size; i++) + { + OUString s(ar[i], strlen(ar[i]), RTL_TEXTENCODING_UTF8); + vec.push_back(s); + } + return vec; +} +bool getJREInfoByPath(const rtl::OUString& path, + std::vector<rtl::Reference<VendorBase> > & vecInfos) +{ + bool ret = false; + + rtl::Reference<VendorBase> aInfo = getJREInfoByPath(path); + if (aInfo.is()) + { + ret = true; + vector<rtl::Reference<VendorBase> >::const_iterator it_impl= std::find_if( + vecInfos.begin(),vecInfos.end(), InfoFindSame(aInfo->getHome())); + if(it_impl == vecInfos.end()) + { + vecInfos.push_back(aInfo); + } + } + return ret; +} + +/** Checks if the path is a directory. Links are resolved. + In case of an error the returned string has the length 0. + Otherwise the returned string is the "resolved" file URL. + */ +OUString resolveDirPath(const OUString & path) +{ + OUString ret; + OUString sResolved; + //getAbsoluteFileURL also resolves links + if (File::getAbsoluteFileURL( + OUSTR("file:///"), path, sResolved) != File::E_None) + return OUString(); + + //check if this is a valid path and if it is a directory + DirectoryItem item; + if (DirectoryItem::get(sResolved, item) == File::E_None) + { + FileStatus status(FileStatusMask_Type | + FileStatusMask_LinkTargetURL | + FileStatusMask_FileURL); + + if (item.getFileStatus(status) == File::E_None + && status.getFileType() == FileStatus::Directory) + { + ret = sResolved; + } + } + else + return OUString(); + return ret; +} +/** Checks if the path is a file. If it is a link to a file than + it is resolved. + */ +OUString resolveFilePath(const OUString & path) +{ + OUString ret; + OUString sResolved; + + if (File::getAbsoluteFileURL( + OUSTR("file:///"), path, sResolved) != File::E_None) + return OUString(); + + //check if this is a valid path to a file or and if it is a link + DirectoryItem item; + if (DirectoryItem::get(sResolved, item) == File::E_None) + { + FileStatus status(FileStatusMask_Type | + FileStatusMask_LinkTargetURL | + FileStatusMask_FileURL); + if (item.getFileStatus(status) == File::E_None + && status.getFileType() == FileStatus::Regular) + { + ret = sResolved; + } + } + else + return OUString(); + + return ret; +} + +rtl::Reference<VendorBase> getJREInfoByPath( + const OUString& path) +{ + rtl::Reference<VendorBase> ret; + static vector<OUString> vecBadPaths; + + static map<OUString, rtl::Reference<VendorBase> > mapJREs; + typedef map<OUString, rtl::Reference<VendorBase> >::const_iterator MapIt; + typedef map<OUString, rtl::Reference<VendorBase> > MAPJRE; + OUString sFilePath; + typedef vector<OUString>::const_iterator cit_path; + vector<pair<OUString, OUString> > props; + + OUString sResolvedDir = resolveDirPath(path); + // If this path is invalid then there is no chance to find a JRE here + if (sResolvedDir.getLength() == 0) + return 0; + + //check if the directory path is good, that is a JRE was already recognized. + //Then we need not detect it again + //For example, a sun JKD contains <jdk>/bin/java and <jdk>/jre/bin/java. + //When <jdk>/bin/java has been found then we need not find <jdk>/jre/bin/java. + //Otherwise we would execute java two times for evers JDK found. + MapIt entry2 = find_if(mapJREs.begin(), mapJREs.end(), + SameOrSubDirJREMap(sResolvedDir)); + if (entry2 != mapJREs.end()) + { + JFW_TRACE2(OUSTR("[Java framework] sunjavaplugin"SAL_DLLEXTENSION ": ") + + OUSTR("JRE found again (detected before): ") + sResolvedDir + + OUSTR(".\n")); + return entry2->second; + } + + for ( sal_Int32 pos = 0; + gVendorMap[pos].sVendorName != NULL; ++pos ) + { + vector<OUString> vecPaths; + getJavaExePaths_func pFunc = gVendorMap[pos].getJavaFunc; + + int size = 0; + char const* const* arExePaths = (*pFunc)(&size); + vecPaths = getVectorFromCharArray(arExePaths, size); + + bool bBreak = false; + typedef vector<OUString>::const_iterator c_it; + for (c_it i = vecPaths.begin(); i != vecPaths.end(); i++) + { + //if the path is a link, then resolve it + //check if the executable exists at all + + //path can be only "file:///". Then do not append a '/' + //sizeof counts the terminating 0 + OUString sFullPath; + if (path.getLength() == sizeof("file:///") - 1) + sFullPath = sResolvedDir + (*i); + else + sFullPath = sResolvedDir + + OUString(RTL_CONSTASCII_USTRINGPARAM("/")) + (*i); + + + sFilePath = resolveFilePath(sFullPath); + + if (sFilePath.getLength() == 0) + { + //The file path (to java exe) is not valid + cit_path ifull = find(vecBadPaths.begin(), vecBadPaths.end(), sFullPath); + if (ifull == vecBadPaths.end()) + vecBadPaths.push_back(sFullPath); + continue; + } + + cit_path ifile = find(vecBadPaths.begin(), vecBadPaths.end(), sFilePath); + if (ifile != vecBadPaths.end()) + continue; + + MapIt entry = mapJREs.find(sFilePath); + if (entry != mapJREs.end()) + { + JFW_TRACE2(OUSTR("[Java framework] sunjavaplugin"SAL_DLLEXTENSION ": ") + + OUSTR("JRE found again (detected before): ") + sFilePath + + OUSTR(".\n")); + + return entry->second; + } + + bool bProcessRun= false; + if (getJavaProps(sFilePath, props, & bProcessRun) == false) + { + //The java executable could not be run or the system properties + //could not be retrieved. We can assume that this java is corrupt. + vecBadPaths.push_back(sFilePath); + //If there was a java executable, that could be run but we did not get + //the system properties, then we also assume that the whole Java installation + //does not work. In a jdk there are two executables. One in jdk/bin and the other + //in jdk/jre/bin. We do not search any further, because we assume that if one java + //does not work then the other does not work as well. This saves us to run java + //again which is quite costly. + if (bProcessRun == true) + { + // 1.3.1 special treatment: jdk/bin/java and /jdk/jre/bin/java are links to + //a script, named .java_wrapper. The script starts jdk/bin/sparc/native_threads/java + //or jdk/jre/bin/sparc/native_threads/java. The script uses the name with which it was + //invoked to build the path to the executable. It we start the script directy as .java_wrapper + //then it tries to start a jdk/.../native_threads/.java_wrapper. Therefore the link, which + //is named java, must be used to start the script. + getJavaProps(sFullPath, props, & bProcessRun); + // Either we found a working 1.3.1 + //Or the java is broken. In both cases we stop searchin under this "root" directory + bBreak = true; + break; + } + //sFilePath is no working java executable. We continue with another possible + //path. + else + { + continue; + } + } + //sFilePath is a java and we could get the system properties. We proceed with this + //java. + else + { + bBreak = true; + break; + } + } + if (bBreak) + break; + } + + if (props.size() == 0) + return rtl::Reference<VendorBase>(); + + //find java.vendor property + typedef vector<pair<OUString, OUString> >::const_iterator c_ip; + OUString sVendor(RTL_CONSTASCII_USTRINGPARAM("java.vendor")); + OUString sVendorName; + + for (c_ip i = props.begin(); i != props.end(); i++) + { + if (sVendor.equals(i->first)) + { + sVendorName = i->second; + break; + } + } + + if (sVendorName.getLength() > 0) + { + //find the creator func for the respective vendor name + for ( sal_Int32 c = 0; + gVendorMap[c].sVendorName != NULL; ++c ) + { + OUString sNameMap(gVendorMap[c].sVendorName, strlen(gVendorMap[c].sVendorName), + RTL_TEXTENCODING_ASCII_US); + if (sNameMap.equals(sVendorName)) + { + ret = createInstance(gVendorMap[c].createFunc, props); + break; + } + } + } + if (ret.is() == false) + vecBadPaths.push_back(sFilePath); + else + { + JFW_TRACE2(OUSTR("[Java framework] sunjavaplugin"SAL_DLLEXTENSION ": ") + + OUSTR("Found JRE: ") + sResolvedDir + + OUSTR(" \n at: ") + path + OUSTR(".\n")); + + mapJREs.insert(MAPJRE::value_type(sResolvedDir, ret)); + mapJREs.insert(MAPJRE::value_type(sFilePath, ret)); + } + + return ret; +} + +Reference<VendorBase> createInstance(createInstance_func pFunc, + vector<pair<OUString, OUString> > properties) +{ + + Reference<VendorBase> aBase = (*pFunc)(); + if (aBase.is()) + { + if (aBase->initialize(properties) == false) + aBase = 0; + } + return aBase; +} + +inline OUString getDirFromFile(const OUString& usFilePath) +{ + sal_Int32 index= usFilePath.lastIndexOf('/'); + return OUString(usFilePath.getStr(), index); +} + +void createJavaInfoFromPath(vector<rtl::Reference<VendorBase> >& vecInfos) +{ +// Get Java from PATH environment variable + static OUString sCurDir(RTL_CONSTASCII_USTRINGPARAM(".")); + static OUString sParentDir(RTL_CONSTASCII_USTRINGPARAM("..")); + char *szPath= getenv("PATH"); + if(szPath) + { + OUString usAllPath(szPath, strlen(szPath), osl_getThreadTextEncoding()); + sal_Int32 nIndex = 0; + do + { + OUString usToken = usAllPath.getToken( 0, SAL_PATHSEPARATOR, nIndex ); + OUString usTokenUrl; + if(File::getFileURLFromSystemPath(usToken, usTokenUrl) == File::E_None) + { + if(usTokenUrl.getLength()) + { + OUString usBin; + // "." + if(usTokenUrl.equals(sCurDir)) + { + OUString usWorkDirUrl; + if(osl_Process_E_None == osl_getProcessWorkingDir(&usWorkDirUrl.pData)) + usBin= usWorkDirUrl; + } + // ".." + else if(usTokenUrl.equals(sParentDir)) + { + OUString usWorkDir; + if(osl_Process_E_None == osl_getProcessWorkingDir(&usWorkDir.pData)) + usBin= getDirFromFile(usWorkDir); + } + else + { + usBin = usTokenUrl; + } + if(usBin.getLength()) + { + getJREInfoFromBinPath(usBin, vecInfos); + } + } + } + } + while ( nIndex >= 0 ); + } +} + +void createJavaInfoFromJavaHome(vector<rtl::Reference<VendorBase> >& vecInfos) +{ + // Get Java from JAVA_HOME environment + char *szJavaHome= getenv("JAVA_HOME"); + if(szJavaHome) + { + OUString sHome(szJavaHome,strlen(szJavaHome),osl_getThreadTextEncoding()); + OUString sHomeUrl; + if(File::getFileURLFromSystemPath(sHome, sHomeUrl) == File::E_None) + { + getJREInfoByPath(sHomeUrl, vecInfos); + } + } +} + +bool makeDriveLetterSame(OUString * fileURL) +{ + bool ret = false; + DirectoryItem item; + if (DirectoryItem::get(*fileURL, item) == File::E_None) + { + FileStatus status(FileStatusMask_FileURL); + if (item.getFileStatus(status) == File::E_None) + { + *fileURL = status.getFileURL(); + ret = true; + } + } + return ret; +} + +#ifdef UNX +#ifdef SOLARIS + +void createJavaInfoDirScan(vector<rtl::Reference<VendorBase> >& vecInfos) +{ + JFW_TRACE2(OUSTR("\n[Java framework] Checking \"/usr/jdk/latest\"\n")); + getJREInfoByPath(OUSTR("file:////usr/jdk/latest"), vecInfos); +} + +#else +void createJavaInfoDirScan(vector<rtl::Reference<VendorBase> >& vecInfos) +{ + OUString excMessage = OUSTR("[Java framework] sunjavaplugin: " + "Error in function createJavaInfoDirScan in util.cxx."); + int cJavaNames= sizeof(g_arJavaNames) / sizeof(char*); + boost::scoped_array<OUString> sarJavaNames(new OUString[cJavaNames]); + OUString *arNames = sarJavaNames.get(); + for(int i= 0; i < cJavaNames; i++) + arNames[i] = OUString(g_arJavaNames[i], strlen(g_arJavaNames[i]), + RTL_TEXTENCODING_UTF8); + + int cSearchPaths= sizeof(g_arSearchPaths) / sizeof(char*); + boost::scoped_array<OUString> sarPathNames(new OUString[cSearchPaths]); + OUString *arPaths = sarPathNames.get(); + for(int c = 0; c < cSearchPaths; c++) + arPaths[c] = OUString(g_arSearchPaths[c], strlen(g_arSearchPaths[c]), + RTL_TEXTENCODING_UTF8); + + int cCollectDirs = sizeof(g_arCollectDirs) / sizeof(char*); + boost::scoped_array<OUString> sarCollectDirs(new OUString[cCollectDirs]); + OUString *arCollectDirs = sarCollectDirs.get(); + for(int d = 0; d < cCollectDirs; d++) + arCollectDirs[d] = OUString(g_arCollectDirs[d], strlen(g_arCollectDirs[d]), + RTL_TEXTENCODING_UTF8); + + + + OUString usFile(RTL_CONSTASCII_USTRINGPARAM("file:///")); + for( int ii = 0; ii < cSearchPaths; ii ++) + { + OUString usDir1(usFile + arPaths[ii]); + DirectoryItem item; + if(DirectoryItem::get(usDir1, item) == File::E_None) + { + for(int j= 0; j < cCollectDirs; j++) + { + OUString usDir2(usDir1 + arCollectDirs[j]); + // prevent that we scan the whole /usr, /usr/lib, etc directories + if (arCollectDirs[j] != OUString()) + { + //usr/java/xxx + //Examin every subdirectory + Directory aCollectionDir(usDir2); + + Directory::RC openErr = aCollectionDir.open(); + switch (openErr) + { + case File::E_None: + break; + case File::E_NOENT: + case File::E_NOTDIR: + continue; + case File::E_ACCES: + JFW_TRACE2(OUSTR("[Java framework] sunjavaplugin: " + "Could not read directory ") + usDir2 + + OUSTR(" because of missing access rights.")); + continue; + default: + JFW_TRACE2(OUSTR("[Java framework] sunjavaplugin: " + "Could not read directory ") + + usDir2 + OUSTR(". Osl file error: ") + + OUString::valueOf((sal_Int32) openErr)); + continue; + } + + DirectoryItem curIt; + File::RC errNext = File::E_None; + while( (errNext = aCollectionDir.getNextItem(curIt)) == File::E_None) + { + FileStatus aStatus(FileStatusMask_FileURL); + File::RC errStatus = File::E_None; + if ((errStatus = curIt.getFileStatus(aStatus)) != File::E_None) + { + JFW_TRACE2(excMessage + OUSTR("getFileStatus failed with error ") + + OUString::valueOf((sal_Int32) errStatus)); + continue; + } + JFW_TRACE2(OUSTR("[Java framework] sunjavaplugin: " + "Checking if directory: ") + aStatus.getFileURL() + + OUSTR(" is a Java. \n")); + + getJREInfoByPath(aStatus.getFileURL(),vecInfos); + } + + JFW_ENSURE(errNext == File::E_None || errNext == File::E_NOENT, + OUSTR("[Java framework] sunjavaplugin: " + "Error while iterating over contens of ") + + usDir2 + OUSTR(". Osl file error: ") + + OUString::valueOf((sal_Int32) openErr)); + } + else + { + //usr/java + //When we look directly into a dir like /usr, /usr/lib, etc. then we only + //look for certain java directories, such as jre, jdk, etc. Whe do not want + //to examine the whole directory because of performance reasons. + DirectoryItem item2; + if(DirectoryItem::get(usDir2, item2) == File::E_None) + { + for( int k= 0; k < cJavaNames; k++) + { + // /usr/java/j2re1.4.0 + OUString usDir3(usDir2 + arNames[k]); + + DirectoryItem item3; + if(DirectoryItem::get(usDir3, item) == File::E_None) + { + //remove trailing '/' + sal_Int32 islash = usDir3.lastIndexOf('/'); + if (islash == usDir3.getLength() - 1 + && (islash + > RTL_CONSTASCII_LENGTH("file://"))) + usDir3 = usDir3.copy(0, islash); + getJREInfoByPath(usDir3,vecInfos); + } + } + } + } + } + } + } +} +#endif // ifdef SOLARIS +#endif // ifdef UNX +} |