jvmfwk/source/framework.cxx

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/


// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_jvmfwk.hxx"
#include "boost/scoped_array.hpp"
#include "rtl/ustring.hxx"
#include "rtl/bootstrap.hxx"
#include "osl/thread.hxx"
#include "osl/file.hxx"
#include "osl/module.hxx"
#include "jvmfwk/framework.h"
#include "jvmfwk/vendorplugin.h"
#include <vector>
#include <functional>
#include <algorithm>
#include "framework.hxx"
#include "fwkutil.hxx"
#include "elements.hxx"
#include "fwkbase.hxx"

#ifdef WNT
/** The existence of the file useatjava.txt decides if a Java should be used
    that supports accessibility tools.
 */
#define USE_ACCESSIBILITY_FILE "useatjava.txt"
#endif

#define UNO_JAVA_JFW_JREHOME "UNO_JAVA_JFW_JREHOME"
namespace {
JavaVM * g_pJavaVM = NULL;

bool g_bEnabledSwitchedOn = false;

sal_Bool areEqualJavaInfo(
    JavaInfo const * pInfoA,JavaInfo const * pInfoB)
{
    return jfw_areEqualJavaInfo(pInfoA, pInfoB);
}
}

javaFrameworkError SAL_CALL jfw_findAllJREs(JavaInfo ***pparInfo, sal_Int32 *pSize)
{
    javaFrameworkError retVal = JFW_E_NONE;
    try
    {
		osl::MutexGuard guard(jfw::FwkMutex::get());
		javaFrameworkError errcode = JFW_E_NONE;
		if (pparInfo == NULL || pSize == NULL)
			return JFW_E_INVALID_ARG;

        jfw::VendorSettings aVendorSettings;
		//Get a list of plugins which provide Java information
        std::vector<jfw::PluginLibrary> vecPlugins =
            aVendorSettings.getPluginData();

        //Create a vector that holds the libraries, which will be later
        //dynamically loaded;
        boost::scoped_array<osl::Module> sarModules;
        sarModules.reset(new osl::Module[vecPlugins.size()]);
        osl::Module * arModules = sarModules.get();
		//Add the JavaInfos found by jfw_plugin_getAllJavaInfos to the vector
		//Make sure that the contents are destroyed if this
		//function returns with an error
		std::vector<jfw::CJavaInfo> vecInfo;
		//Add the JavaInfos found by jfw_plugin_getJavaInfoByPath to this vector
		//Make sure that the contents are destroyed if this
		//function returns with an error
		std::vector<jfw::CJavaInfo> vecInfoManual;
		typedef std::vector<jfw::CJavaInfo>::iterator it_info;
		//get the list of paths to jre locations which have been
		//added manually
		const jfw::MergedSettings settings;
		const std::vector<rtl::OUString>& vecJRELocations =
			settings.getJRELocations();
		//Use every plug-in library to get Java installations.
		typedef std::vector<jfw::PluginLibrary>::const_iterator ci_pl;
        int cModule = 0;
 		for (ci_pl i = vecPlugins.begin(); i != vecPlugins.end(); i++, cModule++)
 		{
			const jfw::PluginLibrary & library = *i;
			jfw::VersionInfo versionInfo =
				aVendorSettings.getVersionInformation(library.sVendor);
            arModules[cModule].load(library.sPath);
            osl::Module & pluginLib = arModules[cModule];

			if (pluginLib.is() == sal_False)
			{
				rtl::OString msg = rtl::OUStringToOString(
					library.sPath, osl_getThreadTextEncoding());
				fprintf(stderr,"[jvmfwk] Could not load plugin %s\n" \
						"Modify the javavendors.xml accordingly!\n", msg.getStr());
				return JFW_E_NO_PLUGIN;
			}
			jfw_plugin_getAllJavaInfos_ptr getAllJavaFunc =
				(jfw_plugin_getAllJavaInfos_ptr) pluginLib.getFunctionSymbol(
					rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("jfw_plugin_getAllJavaInfos")));

			OSL_ASSERT(getAllJavaFunc);
			if (getAllJavaFunc == NULL)
				return JFW_E_ERROR;

			//get all installations of one vendor according to minVersion,
			//maxVersion and excludeVersions
			sal_Int32 cInfos = 0;
			JavaInfo** arInfos = NULL;
			javaPluginError plerr  = (*getAllJavaFunc)(
				library.sVendor.pData,
				versionInfo.sMinVersion.pData,
				versionInfo.sMaxVersion.pData,
				versionInfo.getExcludeVersions(),
				versionInfo.getExcludeVersionSize(),
				& arInfos,
				& cInfos);

			if (plerr != JFW_PLUGIN_E_NONE)
				return JFW_E_ERROR;

			for (int j = 0; j < cInfos; j++)
                vecInfo.push_back(jfw::CJavaInfo::createWrapper(arInfos[j]));

			rtl_freeMemory(arInfos);

			//Check if the current plugin can detect JREs at the location
			// of the paths added by jfw_setJRELocations or jfw_addJRELocation
			//get the function from the plugin
			jfw_plugin_getJavaInfoByPath_ptr jfw_plugin_getJavaInfoByPathFunc =
				(jfw_plugin_getJavaInfoByPath_ptr) pluginLib.getFunctionSymbol(
					rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("jfw_plugin_getJavaInfoByPath")));

			OSL_ASSERT(jfw_plugin_getJavaInfoByPathFunc);
			if (jfw_plugin_getJavaInfoByPathFunc == NULL)
				return JFW_E_ERROR;

			typedef std::vector<rtl::OUString>::const_iterator citLoc;
			//Check every manually added location
			for (citLoc ii = vecJRELocations.begin();
				ii != vecJRELocations.end(); ii++)
			{
// 				rtl::OUString sLocation =
// 					rtl::OStringToOUString(*ii, RTL_TEXTENCODING_UTF8);
				jfw::CJavaInfo aInfo;
				plerr = (*jfw_plugin_getJavaInfoByPathFunc)(
					ii->pData,
                    library.sVendor.pData,
					versionInfo.sMinVersion.pData,
					versionInfo.sMaxVersion.pData,
					versionInfo.getExcludeVersions(),
					versionInfo.getExcludeVersionSize(),
					& aInfo.pInfo);
				if (plerr == JFW_PLUGIN_E_NO_JRE)
					continue;
				if (plerr == JFW_PLUGIN_E_FAILED_VERSION)
					continue;
				else if (plerr !=JFW_PLUGIN_E_NONE)
					return JFW_E_ERROR;

				if (aInfo)
				{
					//Was this JRE already added?. Different plugins could detect
					//the same JRE
					it_info it_duplicate =
						std::find_if(vecInfoManual.begin(), vecInfoManual.end(),
								std::bind2nd(std::ptr_fun(areEqualJavaInfo), aInfo));
					if (it_duplicate == vecInfoManual.end())
						vecInfoManual.push_back(aInfo);
				}
			}
		}
		//Make sure vecInfoManual contains only JavaInfos for the vendors for which
		//there is a javaSelection/plugins/library entry in the javavendors.xml
		//To obtain the JavaInfos for the manually added JRE locations the function
		//jfw_getJavaInfoByPath is called which can return a JavaInfo of any vendor.
		std::vector<jfw::CJavaInfo> vecInfoManual2;
		for (it_info ivm = vecInfoManual.begin(); ivm != vecInfoManual.end(); ivm++)
		{
			for (ci_pl ii = vecPlugins.begin(); ii != vecPlugins.end(); ii++)
			{
				if ( ii->sVendor.equals((*ivm)->sVendor))
				{
					vecInfoManual2.push_back(*ivm);
					break;
				}
			}
		}
		//Check which JavaInfo from vector vecInfoManual2 is already
		//contained in vecInfo. If it already exists then remove it from
		//vecInfoManual2
		for (it_info j = vecInfo.begin(); j != vecInfo.end(); j++)
		{
			it_info it_duplicate =
				std::find_if(vecInfoManual2.begin(), vecInfoManual2.end(),
							std::bind2nd(std::ptr_fun(areEqualJavaInfo), *j));
			if (it_duplicate != vecInfoManual2.end())
				vecInfoManual2.erase(it_duplicate);
		}
		//create an fill the array of JavaInfo*
		sal_Int32 nSize = vecInfo.size() + vecInfoManual2.size();
		*pparInfo = (JavaInfo**) rtl_allocateMemory(
			nSize * sizeof(JavaInfo*));
		if (*pparInfo == NULL)
			return JFW_E_ERROR;

		typedef std::vector<jfw::CJavaInfo>::iterator it;
		int index = 0;
		//Add the automatically detected JREs
		for (it k = vecInfo.begin(); k != vecInfo.end(); k++)
			(*pparInfo)[index++] = k->detach();
		//Add the manually detected JREs
		for (it l = vecInfoManual2.begin(); l != vecInfoManual2.end(); l++)
			(*pparInfo)[index++] = l->detach();

		*pSize = nSize;
		return errcode;
    }
    catch (jfw::FrameworkException& e)
    {
        retVal = e.errorCode;
        fprintf(stderr, "%s\n", e.message.getStr());
        OSL_ENSURE(0, e.message.getStr());
    }
    return retVal;
}

javaFrameworkError SAL_CALL jfw_startVM(JavaVMOption *arOptions, sal_Int32 cOptions,
                                 JavaVM **ppVM, JNIEnv **ppEnv)
{
#ifndef SOLAR_JAVA
    return JFW_E_ERROR;
#else
    javaFrameworkError errcode = JFW_E_NONE;
    if (cOptions > 0 && arOptions == NULL)
        return JFW_E_INVALID_ARG;

    try
    {
		osl::MutexGuard guard(jfw::FwkMutex::get());

		//We keep this pointer so we can determine if a VM has already
		//been created.
		if (g_pJavaVM != NULL)
			return JFW_E_RUNNING_JVM;

		if (ppVM == NULL)
			return JFW_E_INVALID_ARG;

        std::vector<rtl::OString> vmParams;
        rtl::OString sUserClassPath;
		jfw::CJavaInfo aInfo;
		jfw::JFW_MODE mode = jfw::getMode();
		if (mode == jfw::JFW_MODE_APPLICATION)
		{
            const jfw::MergedSettings settings;
            if (sal_False == settings.getEnabled())
                return JFW_E_JAVA_DISABLED;
            aInfo.attach(settings.createJavaInfo());
            //check if a Java has ever been selected
			if (aInfo == NULL)
				return JFW_E_NO_SELECT;

#ifdef WNT
			//Because on Windows there is no system setting that we can use to determine
			//if Assistive Technology Tool support is needed, we ship a .reg file that the
			//user can use to create a registry setting. When the user forgets to set
			//the key before he starts the office then a JRE may be selected without access bridge.
			//When he later sets the key then we select a JRE with accessibility support but
			//only if the user has not manually changed the selected JRE in the options dialog.
			if (jfw::isAccessibilitySupportDesired())
			{
				// If no JRE has been selected then we do not select one. This function shall then
				//return JFW_E_NO_SELECT
				if (aInfo != NULL &&
					(aInfo->nFeatures & JFW_FEATURE_ACCESSBRIDGE) == 0)
				{
					//has the user manually selected a JRE?
					if (settings.getJavaInfoAttrAutoSelect() == true)
					{
                        // if not then the automatism has previously selected a JRE
                        //without accessibility support. We return JFW_E_NO_SELECT
                        //to cause that we search for another JRE. The search code will
                        //then prefer a JRE with accessibility support.
                        return JFW_E_NO_SELECT;
					}
				}
			}
#endif
			//check if the javavendors.xml has changed after a Java was selected
			rtl::OString sVendorUpdate = jfw::getElementUpdated();

			if (sVendorUpdate != settings.getJavaInfoAttrVendorUpdate())
				return JFW_E_INVALID_SETTINGS;

			//check if JAVA is disabled
			//If Java is enabled, but it was disabled when this process was started
			// then no preparational work, such as setting the LD_LIBRARY_PATH, was
			//done. Therefore if a JRE needs it it must not be started.
			if (g_bEnabledSwitchedOn &&
					(aInfo->nRequirements & JFW_REQUIRE_NEEDRESTART))
				return JFW_E_NEED_RESTART;

			//Check if the selected Java was set in this process. If so it
			//must not have the requirments flag JFW_REQUIRE_NEEDRESTART
			if ((aInfo->nRequirements & JFW_REQUIRE_NEEDRESTART)
				&&
				(jfw::wasJavaSelectedInSameProcess() == true))
				return JFW_E_NEED_RESTART;

            vmParams = settings.getVmParametersUtf8();
            sUserClassPath = jfw::makeClassPathOption(settings.getUserClassPath());
		} // end mode FWK_MODE_OFFICE
		else if (mode == jfw::JFW_MODE_DIRECT)
		{
            errcode = jfw_getSelectedJRE(&aInfo.pInfo);
            if (errcode != JFW_E_NONE)
                return errcode;
            //In direct mode the options are specified by bootstrap variables
            //of the form UNO_JAVA_JFW_PARAMETER_1 .. UNO_JAVA_JFW_PARAMETER_n
            vmParams = jfw::BootParams::getVMParameters();
            sUserClassPath =
                "-Djava.class.path=" + jfw::BootParams::getClasspath();
		}
		else
            OSL_ASSERT(0);

		//get the function jfw_plugin_startJavaVirtualMachine
        jfw::VendorSettings aVendorSettings;
		rtl::OUString sLibPath = aVendorSettings.getPluginLibrary(aInfo.getVendor());

		osl::Module modulePlugin(sLibPath);
		if ( ! modulePlugin)
			return JFW_E_NO_PLUGIN;

		rtl::OUString sFunctionName(
			RTL_CONSTASCII_USTRINGPARAM("jfw_plugin_startJavaVirtualMachine"));
		jfw_plugin_startJavaVirtualMachine_ptr pFunc =
			(jfw_plugin_startJavaVirtualMachine_ptr)
			osl_getFunctionSymbol(modulePlugin, sFunctionName.pData);
		if (pFunc == NULL)
			return JFW_E_ERROR;

		// create JavaVMOptions array that is passed to the plugin
		// it contains the classpath and all options set in the
		//options dialog
		boost::scoped_array<JavaVMOption> sarJOptions(
            new JavaVMOption[cOptions + 2 + vmParams.size()]);
		JavaVMOption * arOpt = sarJOptions.get();
		if (! arOpt)
			return JFW_E_ERROR;

		//The first argument is the classpath
		arOpt[0].optionString= (char*) sUserClassPath.getStr();
		arOpt[0].extraInfo = NULL;
		// Set a flag that this JVM has been created via the JNI Invocation API
		// (used, for example, by UNO remote bridges to share a common thread pool
		// factory among Java and native bridge implementations):
		arOpt[1].optionString = (char *) "-Dorg.openoffice.native=";
		arOpt[1].extraInfo = 0;

        //add the options set by options dialog
        int index = 2;
        typedef std::vector<rtl::OString>::const_iterator cit;
        for (cit i = vmParams.begin(); i != vmParams.end(); i ++)
        {
            arOpt[index].optionString = const_cast<sal_Char*>(i->getStr());
            arOpt[index].extraInfo = 0;
            index ++;
        }
        //add all options of the arOptions argument
        for (int ii = 0; ii < cOptions; ii++)
        {
            arOpt[index].optionString = arOptions[ii].optionString;
            arOpt[index].extraInfo = arOptions[ii].extraInfo;
            index++;
        }

		//start Java
		JavaVM *pVm = NULL;
		javaPluginError plerr = (*pFunc)(aInfo, arOpt, index, & pVm, ppEnv);
		if (plerr == JFW_PLUGIN_E_VM_CREATION_FAILED)
		{
			errcode = JFW_E_VM_CREATION_FAILED;
		}
		else if (plerr != JFW_PLUGIN_E_NONE )
		{
			errcode = JFW_E_ERROR;
		}
		else
		{
			g_pJavaVM = pVm;
			*ppVM = pVm;
		}
		OSL_ASSERT(plerr != JFW_PLUGIN_E_WRONG_VENDOR);
    }
    catch (jfw::FrameworkException& e)
    {
        errcode = e.errorCode;
        fprintf(stderr, "%s\n", e.message.getStr());
        OSL_ENSURE(0, e.message.getStr());
    }

    return errcode;
#endif
}

/** We do not use here jfw_findAllJREs and then check if a JavaInfo
    meets the requirements, because that means using all plug-ins, which
    may take quite a while. The implementation uses one plug-in and if
    it already finds a suitable JRE then it is done and does not need to
    load another plug-in
 */
javaFrameworkError SAL_CALL jfw_findAndSelectJRE(JavaInfo **pInfo)
{
    javaFrameworkError errcode = JFW_E_NONE;
    try
    {
        osl::MutexGuard guard(jfw::FwkMutex::get());
        if (jfw::getMode() == jfw::JFW_MODE_DIRECT)
            return JFW_E_DIRECT_MODE;
		sal_uInt64 nFeatureFlags = 0;
		jfw::CJavaInfo aCurrentInfo;
//Determine if accessibility support is needed
		bool bSupportAccessibility = jfw::isAccessibilitySupportDesired();
		nFeatureFlags = bSupportAccessibility ?
			JFW_FEATURE_ACCESSBRIDGE : 0L;

		//Get a list of services which provide Java information
        jfw::VendorSettings aVendorSettings;
        std::vector<jfw::PluginLibrary> vecPlugins =
 			aVendorSettings.getPluginData();
        //Create a vector that holds the libraries, which will be later
        //dynamically loaded;
        boost::scoped_array<osl::Module> sarModules;
        sarModules.reset(new osl::Module[vecPlugins.size()]);
        osl::Module * arModules = sarModules.get();

		//Use every plug-in library to get Java installations. At the first usable
		//Java the loop will break
		typedef std::vector<jfw::PluginLibrary>::const_iterator ci_pl;
        int cModule = 0;
		for (ci_pl i = vecPlugins.begin(); i != vecPlugins.end(); i++, cModule++)
		{
			const jfw::PluginLibrary & library = *i;
			jfw::VersionInfo versionInfo =
				aVendorSettings.getVersionInformation(library.sVendor);

            arModules[cModule].load(library.sPath);
            osl::Module & pluginLib = arModules[cModule];
			if (pluginLib.is() == sal_False)
				return JFW_E_NO_PLUGIN;

			jfw_plugin_getAllJavaInfos_ptr getAllJavaFunc =
				(jfw_plugin_getAllJavaInfos_ptr) pluginLib.getFunctionSymbol(
					rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("jfw_plugin_getAllJavaInfos")));

			OSL_ASSERT(getAllJavaFunc);
			if (getAllJavaFunc == NULL)
				continue;

			//get all installations of one vendor according to minVersion,
			//maxVersion and excludeVersions
			sal_Int32 cInfos = 0;
			JavaInfo** arInfos = NULL;
			javaPluginError plerr  = (*getAllJavaFunc)(
				library.sVendor.pData,
				versionInfo.sMinVersion.pData,
				versionInfo.sMaxVersion.pData,
				versionInfo.getExcludeVersions(),
				versionInfo.getExcludeVersionSize(),
				& arInfos,
				& cInfos);

			if (plerr != JFW_PLUGIN_E_NONE)
				continue;
			//iterate over all installations to find the best which has
			//all features
			if (cInfos == 0)
			{
				rtl_freeMemory(arInfos);
				continue;
			}
			bool bInfoFound = false;
			for (int ii = 0; ii < cInfos; ii++)
			{
				JavaInfo* pJInfo = arInfos[ii];

				//We remember the very first installation in aCurrentInfo
				if (aCurrentInfo.getLocation().getLength() == 0)
						aCurrentInfo = pJInfo;
				// compare features
				// If the user does not require any features (nFeatureFlags = 0)
				// then the first installation is used
				if ((pJInfo->nFeatures & nFeatureFlags) == nFeatureFlags)
				{
					//the just found Java implements all required features
					//currently there is only accessibility!!!
					aCurrentInfo = pJInfo;
					bInfoFound = true;
					break;
				}
			}
			//The array returned by jfw_plugin_getAllJavaInfos must be freed as well as
			//its contents
			for (int j = 0; j < cInfos; j++)
				jfw_freeJavaInfo(arInfos[j]);
			rtl_freeMemory(arInfos);

			if (bInfoFound == true)
				break;
			//All Java installations found by the current plug-in lib
			//do not provide the required features. Try the next plug-in
		}
		if ((JavaInfo*) aCurrentInfo == NULL)
		{//The plug-ins did not find a suitable Java. Now try the paths which have been
		//added manually.
			//get the list of paths to jre locations which have been added manually
			const jfw::MergedSettings settings;
			//node.loadFromSettings();
			const std::vector<rtl::OUString> & vecJRELocations =
				settings.getJRELocations();
			//use every plug-in to determine the JavaInfo objects
			bool bInfoFound = false;
			for (ci_pl i = vecPlugins.begin(); i != vecPlugins.end(); i++)
			{
				const jfw::PluginLibrary & library = *i;
				jfw::VersionInfo versionInfo =
					aVendorSettings.getVersionInformation(library.sVendor);

				osl::Module pluginLib(library.sPath);
				if (pluginLib.is() == sal_False)
					return JFW_E_NO_PLUGIN;
				//Check if the current plugin can detect JREs at the location
				// of the paths added by jfw_setJRELocations or jfw_addJRELocation
				//get the function from the plugin
				jfw_plugin_getJavaInfoByPath_ptr jfw_plugin_getJavaInfoByPathFunc =
					(jfw_plugin_getJavaInfoByPath_ptr) pluginLib.getFunctionSymbol(
						rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("jfw_plugin_getJavaInfoByPath")));

				OSL_ASSERT(jfw_plugin_getJavaInfoByPathFunc);
				if (jfw_plugin_getJavaInfoByPathFunc == NULL)
					return JFW_E_ERROR;

				typedef std::vector<rtl::OUString>::const_iterator citLoc;
				for (citLoc it = vecJRELocations.begin();
					it != vecJRELocations.end(); it++)
				{
					jfw::CJavaInfo aInfo;
					javaPluginError err = (*jfw_plugin_getJavaInfoByPathFunc)(
						it->pData,
                        library.sVendor.pData,
						versionInfo.sMinVersion.pData,
						versionInfo.sMaxVersion.pData,
						versionInfo.getExcludeVersions(),
						versionInfo.getExcludeVersionSize(),
						& aInfo.pInfo);
					if (err == JFW_PLUGIN_E_NO_JRE)
						continue;
					if (err == JFW_PLUGIN_E_FAILED_VERSION)
						continue;
					else if (err !=JFW_PLUGIN_E_NONE)
						return JFW_E_ERROR;

					if (aInfo)
					{
						//We remember the very first installation in aCurrentInfo
						if (aCurrentInfo.getLocation().getLength() == 0)
							aCurrentInfo = aInfo;
						// compare features
						// If the user does not require any features (nFeatureFlags = 0)
						// then the first installation is used
						if ((aInfo.getFeatures() & nFeatureFlags) == nFeatureFlags)
						{
							//the just found Java implements all required features
							//currently there is only accessibility!!!
							aCurrentInfo = aInfo;
							bInfoFound = true;
							break;
						}
					}
				}//end iterate over paths
				if (bInfoFound == true)
					break;
			}// end iterate plug-ins
		}
		if ((JavaInfo*) aCurrentInfo)
		{
			jfw::NodeJava javaNode;
			javaNode.setJavaInfo(aCurrentInfo,true);
			javaNode.write();

			if (pInfo !=NULL)
			{
				//copy to out param
				*pInfo = aCurrentInfo.cloneJavaInfo();
				//remember that this JRE was selected in this process
				jfw::setJavaSelected();
			}
		}
		else
		{
			errcode = JFW_E_NO_JAVA_FOUND;
		}
    }
    catch (jfw::FrameworkException& e)
    {
        errcode = e.errorCode;
        fprintf(stderr, "%s\n", e.message.getStr());
        OSL_ENSURE(0, e.message.getStr());
    }

    return errcode;
}
sal_Bool SAL_CALL jfw_areEqualJavaInfo(
    JavaInfo const * pInfoA,JavaInfo const * pInfoB)
{
    if (pInfoA == pInfoB)
        return sal_True;
    if (pInfoA == NULL || pInfoB == NULL)
        return sal_False;
    rtl::OUString sVendor(pInfoA->sVendor);
    rtl::OUString sLocation(pInfoA->sLocation);
    rtl::OUString sVersion(pInfoA->sVersion);
    rtl::ByteSequence sData(pInfoA->arVendorData);
    if (sVendor.equals(pInfoB->sVendor) == sal_True
        && sLocation.equals(pInfoB->sLocation) == sal_True
        && sVersion.equals(pInfoB->sVersion) == sal_True
        && pInfoA->nFeatures == pInfoB->nFeatures
        && pInfoA->nRequirements == pInfoB->nRequirements
        && sData == pInfoB->arVendorData)
    {
        return sal_True;
    }
    return sal_False;
}


void SAL_CALL jfw_freeJavaInfo(JavaInfo *pInfo)
{
    if (pInfo == NULL)
        return;
    rtl_uString_release(pInfo->sVendor);
    rtl_uString_release(pInfo->sLocation);
    rtl_uString_release(pInfo->sVersion);
    rtl_byte_sequence_release(pInfo->arVendorData);
    rtl_freeMemory(pInfo);
}

javaFrameworkError SAL_CALL jfw_getSelectedJRE(JavaInfo **ppInfo)
{
    javaFrameworkError errcode = JFW_E_NONE;
    try
    {
		osl::MutexGuard guard(jfw::FwkMutex::get());
		if (ppInfo == NULL)
			return JFW_E_INVALID_ARG;

        if (jfw::getMode() == jfw::JFW_MODE_DIRECT)
        {
            rtl::OUString sJRE = jfw::BootParams::getJREHome();

            jfw::CJavaInfo aInfo;
            if ((errcode = jfw_getJavaInfoByPath(sJRE.pData, & aInfo.pInfo))
                != JFW_E_NONE)
                throw jfw::FrameworkException(
                    JFW_E_CONFIGURATION,
                    rtl::OString(
                        "[Java framework] The JRE specified by the bootstrap "
                        "variable UNO_JAVA_JFW_JREHOME  or  UNO_JAVA_JFW_ENV_JREHOME "
                        " could not be recognized. Check the values and make sure that you "
                        "use a plug-in library that can recognize that JRE."));

            *ppInfo = aInfo.detach();
            return JFW_E_NONE;
        }

		const jfw::MergedSettings settings;
		jfw::CJavaInfo aInfo;
		aInfo.attach(settings.createJavaInfo());
		if (! aInfo)
		{
			*ppInfo = NULL;
			return JFW_E_NONE;
		}
		//If the javavendors.xml has changed, then the current selected
		//Java is not valid anymore
		// /java/javaInfo/@vendorUpdate != javaSelection/updated (javavendors.xml)
		rtl::OString sUpdated = jfw::getElementUpdated();

		if (sUpdated.equals(settings.getJavaInfoAttrVendorUpdate()) == sal_False)
			return JFW_E_INVALID_SETTINGS;
		*ppInfo = aInfo.detach();
    }
    catch (jfw::FrameworkException& e)
    {
        errcode = e.errorCode;
        fprintf(stderr, "%s\n", e.message.getStr());
        OSL_ENSURE(0, e.message.getStr());
    }
    return errcode;
}

javaFrameworkError SAL_CALL jfw_isVMRunning(sal_Bool *bRunning)
{
    osl::MutexGuard guard(jfw::FwkMutex::get());
    if (bRunning == NULL)
        return JFW_E_INVALID_ARG;
    if (g_pJavaVM == NULL)
        *bRunning = sal_False;
    else
        *bRunning = sal_True;
    return JFW_E_NONE;
}

javaFrameworkError SAL_CALL jfw_getJavaInfoByPath(
    rtl_uString *pPath, JavaInfo **ppInfo)
{
    javaFrameworkError errcode = JFW_E_NONE;
    try
    {
		osl::MutexGuard guard(jfw::FwkMutex::get());
		if (pPath == NULL || ppInfo == NULL)
			return JFW_E_INVALID_ARG;

        jfw::VendorSettings aVendorSettings;
		//Get a list of plugins which provide Java information
		std::vector<jfw::PluginLibrary> vecPlugins =
			aVendorSettings.getPluginData();
        //Create a vector that holds the libraries, which will be later
        //dynamically loaded;
        boost::scoped_array<osl::Module> sarModules;
        sarModules.reset(new osl::Module[vecPlugins.size()]);
        osl::Module * arModules = sarModules.get();

		typedef std::vector<rtl::OUString>::const_iterator CIT_VENDOR;
		std::vector<rtl::OUString> vecVendors =
			aVendorSettings.getSupportedVendors();

		//Use every plug-in library to determine if the path represents a
		//JRE. If a plugin recognized it then the loop will break
		typedef std::vector<jfw::PluginLibrary>::const_iterator ci_pl;
        int cModule = 0;
        for (ci_pl i = vecPlugins.begin(); i != vecPlugins.end();
             i++, cModule++)
		{
			const jfw::PluginLibrary & library = *i;
			jfw::VersionInfo versionInfo =
				aVendorSettings.getVersionInformation(library.sVendor);
	        arModules[cModule].load(library.sPath);
            osl::Module & pluginLib = arModules[cModule];
			if (pluginLib.is() == sal_False)
			{
				rtl::OString msg = rtl::OUStringToOString(
					library.sPath, osl_getThreadTextEncoding());
				fprintf(stderr,"[jvmfwk] Could not load plugin %s\n" \
						"Modify the javavendors.xml accordingly!\n", msg.getStr());
				return JFW_E_NO_PLUGIN;
			}

			jfw_plugin_getJavaInfoByPath_ptr jfw_plugin_getJavaInfoByPathFunc =
				(jfw_plugin_getJavaInfoByPath_ptr) pluginLib.getFunctionSymbol(
					rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("jfw_plugin_getJavaInfoByPath")));

			OSL_ASSERT(jfw_plugin_getJavaInfoByPathFunc);
			if (jfw_plugin_getJavaInfoByPathFunc == NULL)
				continue;

			//ask the plugin if this is a JRE.
			//If so check if it meets the version requirements.
			//Only if it does return a JavaInfo
			JavaInfo* pInfo = NULL;
			javaPluginError plerr = (*jfw_plugin_getJavaInfoByPathFunc)(
				pPath,
                library.sVendor.pData,
				versionInfo.sMinVersion.pData,
				versionInfo.sMaxVersion.pData,
				versionInfo.getExcludeVersions(),
				versionInfo.getExcludeVersionSize(),
				& pInfo);

			if (plerr == JFW_PLUGIN_E_NONE)
			{
				//check if the vendor of the found JRE is supported
                if (vecVendors.size() == 0)
                {
                    //vendor does not matter
                    *ppInfo = pInfo;
					break;
                }
                else
                {
                    rtl::OUString sVendor(pInfo->sVendor);
                    CIT_VENDOR ivendor = std::find(vecVendors.begin(), vecVendors.end(),
                                                   sVendor);
                    if (ivendor != vecVendors.end())
                    {
                        *ppInfo = pInfo;
                    }
                    else
                    {
                        *ppInfo = NULL;
                        errcode = JFW_E_NOT_RECOGNIZED;
                    }
                    break;
                }
			}
			else if(plerr == JFW_PLUGIN_E_FAILED_VERSION)
			{//found JRE but it has the wrong version
				*ppInfo = NULL;
				errcode = JFW_E_FAILED_VERSION;
				break;
			}
			else if (plerr == JFW_PLUGIN_E_NO_JRE)
			{// plugin does not recognize this path as belonging to JRE
				continue;
			}
			OSL_ASSERT(0);
		}
		if (*ppInfo == NULL && errcode != JFW_E_FAILED_VERSION)
			errcode = JFW_E_NOT_RECOGNIZED;
    }
    catch (jfw::FrameworkException& e)
    {
        errcode = e.errorCode;
        fprintf(stderr, "%s\n", e.message.getStr());
        OSL_ENSURE(0, e.message.getStr());
    }

    return errcode;
}


javaFrameworkError SAL_CALL jfw_setSelectedJRE(JavaInfo const *pInfo)
{
    javaFrameworkError errcode = JFW_E_NONE;
    try
    {
		osl::MutexGuard guard(jfw::FwkMutex::get());
        if (jfw::getMode() == jfw::JFW_MODE_DIRECT)
            return JFW_E_DIRECT_MODE;
		//check if pInfo is the selected JRE
		JavaInfo *currentInfo = NULL;
		errcode = jfw_getSelectedJRE( & currentInfo);
		if (errcode != JFW_E_NONE && errcode != JFW_E_INVALID_SETTINGS)
			return errcode;

		if (jfw_areEqualJavaInfo(currentInfo, pInfo) == sal_False)
		{
			jfw::NodeJava node;
			node.setJavaInfo(pInfo, false);
			node.write();
			//remember that the JRE was selected in this process
			jfw::setJavaSelected();
		}
    }
    catch (jfw::FrameworkException& e)
    {
        errcode = e.errorCode;
        fprintf(stderr, "%s\n", e.message.getStr());
        OSL_ENSURE(0, e.message.getStr());
    }
    return errcode;
}
javaFrameworkError SAL_CALL jfw_setEnabled(sal_Bool bEnabled)
{
    javaFrameworkError errcode = JFW_E_NONE;
    try
    {
		osl::MutexGuard guard(jfw::FwkMutex::get());
        if (jfw::getMode() == jfw::JFW_MODE_DIRECT)
            return JFW_E_DIRECT_MODE;

		if (g_bEnabledSwitchedOn == false && bEnabled == sal_True)
		{
			//When the process started then Enabled was false.
			//This is first time enabled is set to true.
			//That means, no preparational work has been done, such as setting the
			//LD_LIBRARY_PATH, etc.

			//check if Enabled is false;
            const jfw::MergedSettings settings;
			if (settings.getEnabled() == sal_False)
				g_bEnabledSwitchedOn = true;
		}
		jfw::NodeJava node;
		node.setEnabled(bEnabled);
		node.write();
    }
    catch (jfw::FrameworkException& e)
    {
        errcode = e.errorCode;
        fprintf(stderr, "%s\n", e.message.getStr());
        OSL_ENSURE(0, e.message.getStr());
    }
    return errcode;
}

javaFrameworkError SAL_CALL jfw_getEnabled(sal_Bool *pbEnabled)
{
    javaFrameworkError errcode = JFW_E_NONE;
    try
    {
        if (jfw::getMode() == jfw::JFW_MODE_DIRECT)
            return JFW_E_DIRECT_MODE;
        osl::MutexGuard guard(jfw::FwkMutex::get());
		if (pbEnabled == NULL)
			return JFW_E_INVALID_ARG;
		jfw::MergedSettings settings;
		*pbEnabled = settings.getEnabled();
    }
    catch (jfw::FrameworkException& e)
    {
        errcode = e.errorCode;
        fprintf(stderr, "%s\n", e.message.getStr());
        OSL_ENSURE(0, e.message.getStr());
    }
    return errcode;
}


javaFrameworkError SAL_CALL jfw_setVMParameters(
    rtl_uString * * arOptions, sal_Int32 nLen)
{
    javaFrameworkError errcode = JFW_E_NONE;
    try
    {
		osl::MutexGuard guard(jfw::FwkMutex::get());
        if (jfw::getMode() == jfw::JFW_MODE_DIRECT)
            return JFW_E_DIRECT_MODE;
        jfw::NodeJava node;
		if (arOptions == NULL && nLen != 0)
			return JFW_E_INVALID_ARG;
		node.setVmParameters(arOptions, nLen);
		node.write();
    }
    catch (jfw::FrameworkException& e)
    {
        errcode = e.errorCode;
        fprintf(stderr, "%s\n", e.message.getStr());
        OSL_ENSURE(0, e.message.getStr());
    }

    return errcode;
}

javaFrameworkError SAL_CALL jfw_getVMParameters(
    rtl_uString *** parOptions, sal_Int32 * pLen)
{
    javaFrameworkError errcode = JFW_E_NONE;
    try
    {
		osl::MutexGuard guard(jfw::FwkMutex::get());
        if (jfw::getMode() == jfw::JFW_MODE_DIRECT)
            return JFW_E_DIRECT_MODE;

		if (parOptions == NULL || pLen == NULL)
			return JFW_E_INVALID_ARG;
		const jfw::MergedSettings settings;
		settings.getVmParametersArray(parOptions, pLen);
    }
    catch (jfw::FrameworkException& e)
    {
        errcode = e.errorCode;
        fprintf(stderr, "%s\n", e.message.getStr());
        OSL_ENSURE(0, e.message.getStr());
    }
    return errcode;
}

javaFrameworkError SAL_CALL jfw_setUserClassPath(rtl_uString * pCp)
{
    javaFrameworkError errcode = JFW_E_NONE;
    try
    {
		osl::MutexGuard guard(jfw::FwkMutex::get());
        if (jfw::getMode() == jfw::JFW_MODE_DIRECT)
            return JFW_E_DIRECT_MODE;
		jfw::NodeJava node;
		if (pCp == NULL)
			return JFW_E_INVALID_ARG;
		node.setUserClassPath(pCp);
		node.write();
    }
    catch (jfw::FrameworkException& e)
    {
        errcode = e.errorCode;
        fprintf(stderr, "%s\n", e.message.getStr());
        OSL_ENSURE(0, e.message.getStr());
    }
    return errcode;
}

javaFrameworkError SAL_CALL jfw_getUserClassPath(rtl_uString ** ppCP)
{
    javaFrameworkError errcode = JFW_E_NONE;
    try
    {
		osl::MutexGuard guard(jfw::FwkMutex::get());
        if (jfw::getMode() == jfw::JFW_MODE_DIRECT)
            return JFW_E_DIRECT_MODE;
		if (ppCP == NULL)
			return JFW_E_INVALID_ARG;
		const jfw::MergedSettings settings;
		*ppCP = settings.getUserClassPath().pData;
		rtl_uString_acquire(*ppCP);
    }
    catch (jfw::FrameworkException& e)
    {
        errcode = e.errorCode;
        fprintf(stderr, "%s\n", e.message.getStr());
        OSL_ENSURE(0, e.message.getStr());
    }
    return errcode;
}

javaFrameworkError SAL_CALL jfw_addJRELocation(rtl_uString * sLocation)
{
    javaFrameworkError errcode = JFW_E_NONE;
    try
    {
		osl::MutexGuard guard(jfw::FwkMutex::get());
        if (jfw::getMode() == jfw::JFW_MODE_DIRECT)
            return JFW_E_DIRECT_MODE;
        jfw::NodeJava node;
		if (sLocation == NULL)
			return JFW_E_INVALID_ARG;
		node.load();
		node.addJRELocation(sLocation);
		node.write();
    }
    catch (jfw::FrameworkException& e)
    {
        errcode = e.errorCode;
        fprintf(stderr, "%s\n", e.message.getStr());
        OSL_ENSURE(0, e.message.getStr());
    }

    return errcode;

}

javaFrameworkError SAL_CALL jfw_setJRELocations(
    rtl_uString ** arLocations, sal_Int32 nLen)
{
    javaFrameworkError errcode = JFW_E_NONE;
    try
    {
		osl::MutexGuard guard(jfw::FwkMutex::get());
        if (jfw::getMode() == jfw::JFW_MODE_DIRECT)
            return JFW_E_DIRECT_MODE;
		jfw::NodeJava node;
		if (arLocations == NULL && nLen != 0)
			return JFW_E_INVALID_ARG;
		node.setJRELocations(arLocations, nLen);
		node.write();
    }
    catch (jfw::FrameworkException& e)
    {
        errcode = e.errorCode;
        fprintf(stderr, "%s\n", e.message.getStr());
        OSL_ENSURE(0, e.message.getStr());
    }
    return errcode;

}

javaFrameworkError SAL_CALL jfw_getJRELocations(
    rtl_uString *** parLocations, sal_Int32 *pLen)
{
    javaFrameworkError errcode = JFW_E_NONE;
    try
    {
		osl::MutexGuard guard(jfw::FwkMutex::get());
        if (jfw::getMode() == jfw::JFW_MODE_DIRECT)
            return JFW_E_DIRECT_MODE;

		if (parLocations == NULL || pLen == NULL)
			return JFW_E_INVALID_ARG;
		const jfw::MergedSettings settings;
		settings.getJRELocations(parLocations, pLen);
    }
    catch (jfw::FrameworkException& e)
    {
        errcode = e.errorCode;
        fprintf(stderr, "%s\n", e.message.getStr());
        OSL_ENSURE(0, e.message.getStr());
    }

    return errcode;
}


javaFrameworkError jfw_existJRE(const JavaInfo *pInfo, sal_Bool *exist)
{
    //get the function jfw_plugin_existJRE
    jfw::VendorSettings aVendorSettings;
    jfw::CJavaInfo aInfo;
    aInfo = (const ::JavaInfo*) pInfo; //makes a copy of pInfo
    rtl::OUString sLibPath = aVendorSettings.getPluginLibrary(aInfo.getVendor());
    osl::Module modulePlugin(sLibPath);
    if ( ! modulePlugin)
        return JFW_E_NO_PLUGIN;
    rtl::OUString sFunctionName(
        RTL_CONSTASCII_USTRINGPARAM("jfw_plugin_existJRE"));
    jfw_plugin_existJRE_ptr pFunc =
        (jfw_plugin_existJRE_ptr)
        osl_getFunctionSymbol(modulePlugin, sFunctionName.pData);
    if (pFunc == NULL)
        return JFW_E_ERROR;

    javaPluginError plerr = (*pFunc)(pInfo, exist);

    javaFrameworkError ret = JFW_E_NONE;
    switch (plerr)
    {
    case JFW_PLUGIN_E_NONE:
        ret = JFW_E_NONE;
        break;
    case JFW_PLUGIN_E_INVALID_ARG:
        ret = JFW_E_INVALID_ARG;
        break;
    case JFW_PLUGIN_E_ERROR:
        ret = JFW_E_ERROR;
        break;
    default:
        ret = JFW_E_ERROR;
    }
    return ret;
}

void SAL_CALL jfw_lock()
{
    jfw::FwkMutex::get().acquire();
}

void SAL_CALL jfw_unlock()
{
    jfw::FwkMutex::get().release();
}


namespace jfw
{
CJavaInfo::CJavaInfo(): pInfo(0)
{
}

CJavaInfo::CJavaInfo(const CJavaInfo & info)
{
    pInfo = copyJavaInfo(info.pInfo);
}

CJavaInfo::CJavaInfo(::JavaInfo * info, _transfer_ownership)
{
    pInfo = info;
}
CJavaInfo CJavaInfo::createWrapper(::JavaInfo* info)
{
    return CJavaInfo(info, TRANSFER);
}
void CJavaInfo::attach(::JavaInfo * info)
{
    jfw_freeJavaInfo(pInfo);
    pInfo = info;
}
::JavaInfo * CJavaInfo::detach()
{
    JavaInfo * tmp = pInfo;
    pInfo = NULL;
    return tmp;
}

CJavaInfo::~CJavaInfo()
{
    jfw_freeJavaInfo(pInfo);
}

CJavaInfo::operator ::JavaInfo* ()
{
    return pInfo;
}

JavaInfo * CJavaInfo::copyJavaInfo(const JavaInfo * pInfo)
{
	if (pInfo == NULL)
		return NULL;
    JavaInfo* newInfo =
          (JavaInfo*) rtl_allocateMemory(sizeof(JavaInfo));
    if (newInfo)
    {
        rtl_copyMemory(newInfo, pInfo, sizeof(JavaInfo));
        rtl_uString_acquire(pInfo->sVendor);
        rtl_uString_acquire(pInfo->sLocation);
        rtl_uString_acquire(pInfo->sVersion);
        rtl_byte_sequence_acquire(pInfo->arVendorData);
    }
    return newInfo;
}


JavaInfo* CJavaInfo::cloneJavaInfo() const
{
    if (pInfo == NULL)
        return NULL;
    return copyJavaInfo(pInfo);
}

CJavaInfo & CJavaInfo::operator = (const CJavaInfo& info)
{
    if (&info == this)
        return *this;

    jfw_freeJavaInfo(pInfo);
    pInfo = copyJavaInfo(info.pInfo);
    return *this;
}
CJavaInfo & CJavaInfo::operator = (const ::JavaInfo* info)
{
    if (info == pInfo)
        return *this;

    jfw_freeJavaInfo(pInfo);
    pInfo = copyJavaInfo(info);
    return *this;
}

const ::JavaInfo* CJavaInfo::operator ->() const
{
    return pInfo;
}

CJavaInfo::operator JavaInfo const * () const
{
    return pInfo;
}
// ::JavaInfo** CJavaInfo::operator & ()
// {
//     return & pInfo;
// }

rtl::OUString CJavaInfo::getVendor() const
{
    if (pInfo)
        return rtl::OUString(pInfo->sVendor);
    else
        return rtl::OUString();
}

rtl::OUString CJavaInfo::getLocation() const
{
    if (pInfo)
        return rtl::OUString(pInfo->sLocation);
    else
        return rtl::OUString();
}

sal_uInt64 CJavaInfo::getFeatures() const
{
    if (pInfo)
        return pInfo->nFeatures;
    else
        return 0l;
}

}