| /************************************************************** | |
| * | |
| * 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_cppuhelper.hxx" | |
| #include <vector> | |
| #include "rtl/string.hxx" | |
| #include "rtl/bootstrap.hxx" | |
| #include "osl/diagnose.h" | |
| #include "osl/file.h" | |
| #include "osl/module.h" | |
| #include "osl/process.h" | |
| #include "cppuhelper/shlib.hxx" | |
| #include "cppuhelper/factory.hxx" | |
| #include "cppuhelper/component_context.hxx" | |
| #include "cppuhelper/servicefactory.hxx" | |
| #include "cppuhelper/bootstrap.hxx" | |
| #include "com/sun/star/uno/DeploymentException.hpp" | |
| #include "com/sun/star/uno/XComponentContext.hpp" | |
| #include "com/sun/star/lang/XInitialization.hpp" | |
| #include "com/sun/star/lang/XSingleServiceFactory.hpp" | |
| #include "com/sun/star/lang/XSingleComponentFactory.hpp" | |
| #include "com/sun/star/beans/XPropertySet.hpp" | |
| #include "com/sun/star/container/XSet.hpp" | |
| #include "com/sun/star/container/XHierarchicalNameAccess.hpp" | |
| #include "com/sun/star/registry/XSimpleRegistry.hpp" | |
| #include "com/sun/star/registry/XImplementationRegistration.hpp" | |
| #include "com/sun/star/security/XAccessController.hpp" | |
| #define OUSTR(x) ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(x) ) | |
| using namespace ::rtl; | |
| using namespace ::osl; | |
| using namespace ::com::sun::star; | |
| using namespace ::com::sun::star::uno; | |
| namespace css = com::sun::star; | |
| namespace cppu | |
| { | |
| // private forward decl | |
| void addFactories( | |
| char const * const * ppNames /* lib, implname, ..., 0 */, | |
| OUString const & bootstrapPath, | |
| Reference< lang::XMultiComponentFactory > const & xMgr, | |
| Reference< registry::XRegistryKey > const & xKey ); | |
| Reference< security::XAccessController > | |
| createDefaultAccessController() SAL_THROW( () ); | |
| Reference< lang::XSingleComponentFactory > | |
| create_boostrap_macro_expander_factory() SAL_THROW( () ); | |
| OUString const & get_this_libpath(); | |
| static Reference< XInterface > SAL_CALL createInstance( | |
| Reference< XInterface > const & xFactory, | |
| Reference< XComponentContext > const & xContext = | |
| Reference< XComponentContext >() ) | |
| { | |
| Reference< lang::XSingleComponentFactory > xFac( xFactory, UNO_QUERY ); | |
| if (xFac.is()) | |
| { | |
| return xFac->createInstanceWithContext( xContext ); | |
| } | |
| else | |
| { | |
| Reference< lang::XSingleServiceFactory > xFac2( xFactory, UNO_QUERY ); | |
| if (xFac2.is()) | |
| { | |
| OSL_ENSURE( !xContext.is(), "### ignoring context!" ); | |
| return xFac2->createInstance(); | |
| } | |
| } | |
| throw RuntimeException( | |
| OUSTR("no factory object given!"), | |
| Reference< XInterface >() ); | |
| } | |
| Reference< registry::XSimpleRegistry > SAL_CALL createSimpleRegistry( | |
| OUString const & rBootstrapPath ) | |
| SAL_THROW( () ) | |
| { | |
| try | |
| { | |
| return Reference< registry::XSimpleRegistry >( | |
| createInstance( | |
| loadSharedLibComponentFactory( | |
| OUSTR("bootstrap.uno" SAL_DLLEXTENSION), | |
| 0 == rBootstrapPath.getLength() | |
| ? get_this_libpath() : rBootstrapPath, | |
| OUSTR("com.sun.star.comp.stoc.SimpleRegistry"), | |
| Reference< lang::XMultiServiceFactory >(), | |
| Reference< registry::XRegistryKey >() ) ), | |
| UNO_QUERY ); | |
| } | |
| catch (Exception & exc) | |
| { | |
| #if OSL_DEBUG_LEVEL > 0 | |
| OString cstr_msg( | |
| OUStringToOString( exc.Message, RTL_TEXTENCODING_ASCII_US ) ); | |
| OSL_ENSURE( !"### exception occurred:", cstr_msg.getStr() ); | |
| #else | |
| (void) exc; // avoid warning about unused variable | |
| #endif | |
| } | |
| return Reference< registry::XSimpleRegistry >(); | |
| } | |
| Reference< registry::XSimpleRegistry > SAL_CALL createNestedRegistry( | |
| OUString const & rBootstrapPath ) | |
| SAL_THROW( () ) | |
| { | |
| try | |
| { | |
| return Reference< registry::XSimpleRegistry >( | |
| createInstance( | |
| loadSharedLibComponentFactory( | |
| OUSTR("bootstrap.uno" SAL_DLLEXTENSION), | |
| 0 == rBootstrapPath.getLength() | |
| ? get_this_libpath() : rBootstrapPath, | |
| OUSTR("com.sun.star.comp.stoc.NestedRegistry"), | |
| Reference< lang::XMultiServiceFactory >(), | |
| Reference< registry::XRegistryKey >() ) ), | |
| UNO_QUERY ); | |
| } | |
| catch (Exception & exc) | |
| { | |
| #if OSL_DEBUG_LEVEL > 0 | |
| OString cstr_msg( | |
| OUStringToOString( exc.Message, RTL_TEXTENCODING_ASCII_US ) ); | |
| OSL_ENSURE( !"### exception occurred:", cstr_msg.getStr() ); | |
| #else | |
| (void) exc; // avoid warning about unused variable | |
| #endif | |
| } | |
| return Reference< registry::XSimpleRegistry >(); | |
| } | |
| /** bootstrap variables: | |
| UNO_AC=<mode> [mandatory] | |
| -- mode := { on, off, dynamic-only, single-user, single-default-user } | |
| UNO_AC_SERVICE=<service_name> [optional] | |
| -- override ac singleton service name | |
| UNO_AC_SINGLEUSER=<user-id|nothing> [optional] | |
| -- run with this user id or with default user policy (<nothing>) | |
| set UNO_AC=single-[default-]user | |
| UNO_AC_USERCACHE_SIZE=<cache_size> | |
| -- number of user permission sets to be cached | |
| UNO_AC_POLICYSERVICE=<service_name> [optional] | |
| -- override policy singleton service name | |
| UNO_AC_POLICYFILE=<file_url> [optional] | |
| -- read policy out of simple text file | |
| */ | |
| static void add_access_control_entries( | |
| ::std::vector< ContextEntry_Init > * values, | |
| Bootstrap const & bootstrap ) | |
| { | |
| ContextEntry_Init entry; | |
| ::std::vector< ContextEntry_Init > & context_values = *values; | |
| OUString ac_policy; | |
| if (bootstrap.getFrom( OUSTR("UNO_AC_POLICYSERVICE"), ac_policy )) | |
| { | |
| // overridden service name | |
| // - policy singleton | |
| entry.bLateInitService = true; | |
| entry.name = OUSTR("/singletons/com.sun.star.security.thePolicy"); | |
| entry.value <<= ac_policy; | |
| context_values.push_back( entry ); | |
| } | |
| else if (bootstrap.getFrom( OUSTR("UNO_AC_POLICYFILE"), ac_policy )) | |
| { | |
| // check for file policy | |
| // - file policy prop: file-name | |
| if (0 != ac_policy.compareToAscii( | |
| RTL_CONSTASCII_STRINGPARAM("file:///") )) | |
| { | |
| // no file url | |
| OUString baseDir; | |
| if ( ::osl_getProcessWorkingDir( &baseDir.pData ) | |
| != osl_Process_E_None ) | |
| { | |
| OSL_ASSERT( false ); | |
| } | |
| OUString fileURL; | |
| if ( ::osl_getAbsoluteFileURL( | |
| baseDir.pData, ac_policy.pData, &fileURL.pData ) | |
| != osl_File_E_None ) | |
| { | |
| OSL_ASSERT( false ); | |
| } | |
| ac_policy = fileURL; | |
| } | |
| entry.bLateInitService = false; | |
| entry.name = | |
| OUSTR("/implementations/com.sun.star.security.comp.stoc.FilePolicy/" | |
| "file-name"); | |
| entry.value <<= ac_policy; | |
| context_values.push_back( entry ); | |
| // - policy singleton | |
| entry.bLateInitService = true; | |
| entry.name = OUSTR("/singletons/com.sun.star.security.thePolicy"); | |
| entry.value <<= OUSTR("com.sun.star.security.comp.stoc.FilePolicy"); | |
| context_values.push_back( entry ); | |
| } // else policy singleton comes from storage | |
| OUString ac_mode; | |
| if (! bootstrap.getFrom( OUSTR("UNO_AC"), ac_mode )) | |
| { | |
| ac_mode = OUSTR("off"); // default | |
| } | |
| OUString ac_user; | |
| if (bootstrap.getFrom( OUSTR("UNO_AC_SINGLEUSER"), ac_user )) | |
| { | |
| // ac in single-user mode | |
| if (ac_user.getLength()) | |
| { | |
| // - ac prop: single-user-id | |
| entry.bLateInitService = false; | |
| entry.name = | |
| OUSTR("/services/com.sun.star.security.AccessController/" | |
| "single-user-id"); | |
| entry.value <<= ac_user; | |
| context_values.push_back( entry ); | |
| if (! ac_mode.equalsAsciiL( | |
| RTL_CONSTASCII_STRINGPARAM("single-user") )) | |
| { | |
| throw SecurityException( | |
| OUSTR("set UNO_AC=single-user " | |
| "if you set UNO_AC_SINGLEUSER=<user-id>!"), | |
| Reference< XInterface >() ); | |
| } | |
| } | |
| else | |
| { | |
| if (! ac_mode.equalsAsciiL( | |
| RTL_CONSTASCII_STRINGPARAM("single-default-user") )) | |
| { | |
| throw SecurityException( | |
| OUSTR("set UNO_AC=single-default-user " | |
| "if you set UNO_AC_SINGLEUSER=<nothing>!"), | |
| Reference< XInterface >() ); | |
| } | |
| } | |
| } | |
| OUString ac_service; | |
| if (! bootstrap.getFrom( OUSTR("UNO_AC_SERVICE"), ac_service )) | |
| { | |
| // override service name | |
| ac_service = OUSTR("com.sun.star.security.AccessController"); // default | |
| // ac = OUSTR("com.sun.star.security.comp.stoc.AccessController"); | |
| } | |
| // - ac prop: user-cache-size | |
| OUString ac_cache; | |
| if (bootstrap.getFrom( OUSTR("UNO_AC_USERCACHE_SIZE"), ac_cache )) | |
| { | |
| // ac cache size | |
| sal_Int32 n = ac_cache.toInt32(); | |
| if (0 < n) | |
| { | |
| entry.bLateInitService = false; | |
| entry.name = | |
| OUSTR("/services/com.sun.star.security.AccessController/" | |
| "user-cache-size"); | |
| entry.value <<= n; | |
| context_values.push_back( entry ); | |
| } | |
| } | |
| // - ac prop: mode | |
| // { "off", "on", "dynamic-only", "single-user", "single-default-user" } | |
| entry.bLateInitService = false; | |
| entry.name = OUSTR("/services/com.sun.star.security.AccessController/mode"); | |
| entry.value <<= ac_mode; | |
| context_values.push_back( entry ); | |
| // - ac singleton | |
| entry.bLateInitService = true; | |
| entry.name = OUSTR("/singletons/com.sun.star.security.theAccessController"); | |
| entry.value <<= ac_service; | |
| context_values.push_back( entry ); | |
| } | |
| SAL_DLLPUBLIC_EXPORT | |
| Reference< lang::XMultiComponentFactory > bootstrapInitialSF( | |
| OUString const & rBootstrapPath ) | |
| { | |
| OUString const & bootstrap_path = | |
| 0 == rBootstrapPath.getLength() ? get_this_libpath() : rBootstrapPath; | |
| Reference< lang::XMultiComponentFactory > xMgr( | |
| createInstance( | |
| loadSharedLibComponentFactory( | |
| OUSTR("bootstrap.uno" SAL_DLLEXTENSION), bootstrap_path, | |
| OUSTR("com.sun.star.comp.stoc.ORegistryServiceManager"), | |
| Reference< lang::XMultiServiceFactory >(), | |
| Reference< registry::XRegistryKey >() ) ), | |
| UNO_QUERY ); | |
| // add initial bootstrap services | |
| static char const * ar[] = { | |
| "bootstrap.uno" SAL_DLLEXTENSION, | |
| "com.sun.star.comp.stoc.OServiceManagerWrapper", | |
| "bootstrap.uno" SAL_DLLEXTENSION, | |
| "com.sun.star.comp.stoc.DLLComponentLoader", | |
| "bootstrap.uno" SAL_DLLEXTENSION, | |
| "com.sun.star.comp.stoc.SimpleRegistry", | |
| "bootstrap.uno" SAL_DLLEXTENSION, | |
| "com.sun.star.comp.stoc.NestedRegistry", | |
| "bootstrap.uno" SAL_DLLEXTENSION, | |
| "com.sun.star.comp.stoc.TypeDescriptionManager", | |
| "bootstrap.uno" SAL_DLLEXTENSION, | |
| "com.sun.star.comp.stoc.ImplementationRegistration", | |
| "bootstrap.uno" SAL_DLLEXTENSION, | |
| "com.sun.star.security.comp.stoc.AccessController", | |
| "bootstrap.uno" SAL_DLLEXTENSION, | |
| "com.sun.star.security.comp.stoc.FilePolicy", | |
| 0 | |
| }; | |
| addFactories( | |
| ar, bootstrap_path, | |
| xMgr, Reference< registry::XRegistryKey >() ); | |
| return xMgr; | |
| } | |
| // returns context with UNinitialized smgr | |
| Reference< XComponentContext > bootstrapInitialContext( | |
| Reference< lang::XMultiComponentFactory > const & xSF, | |
| Reference< registry::XSimpleRegistry > const & types_xRegistry, | |
| Reference< registry::XSimpleRegistry > const & services_xRegistry, | |
| OUString const & rBootstrapPath, Bootstrap const & bootstrap ) | |
| { | |
| Reference< lang::XInitialization > xSFInit( xSF, UNO_QUERY ); | |
| if (! xSFInit.is()) | |
| { | |
| throw RuntimeException( | |
| OUSTR("servicemanager does not support XInitialization!"), | |
| Reference< XInterface >() ); | |
| } | |
| // basic context values | |
| ContextEntry_Init entry; | |
| ::std::vector< ContextEntry_Init > context_values; | |
| context_values.reserve( 14 ); | |
| // macro expander singleton for loader | |
| entry.bLateInitService = true; | |
| entry.name = OUSTR("/singletons/com.sun.star.util.theMacroExpander"); | |
| entry.value <<= create_boostrap_macro_expander_factory(); | |
| context_values.push_back( entry ); | |
| // tdmgr singleton | |
| entry.bLateInitService = true; | |
| entry.name = | |
| OUSTR("/singletons/com.sun.star.reflection.theTypeDescriptionManager"); | |
| entry.value <<= OUSTR("com.sun.star.comp.stoc.TypeDescriptionManager"); | |
| context_values.push_back( entry ); | |
| // read out singleton infos from registry | |
| if (services_xRegistry.is()) | |
| { | |
| Reference< registry::XRegistryKey > xKey( | |
| services_xRegistry->getRootKey() ); | |
| if (xKey.is()) | |
| { | |
| xKey = xKey->openKey( OUSTR("/SINGLETONS") ); | |
| if (xKey.is()) | |
| { | |
| entry.bLateInitService = true; | |
| Sequence< Reference< registry::XRegistryKey > > keys( | |
| xKey->openKeys() ); | |
| Reference< registry::XRegistryKey > const * pKeys = | |
| keys.getConstArray(); | |
| for ( sal_Int32 nPos = keys.getLength(); nPos--; ) | |
| { | |
| css::uno::Sequence< rtl::OUString > impls( | |
| css::uno::Reference< css::registry::XRegistryKey >( | |
| pKeys[nPos]->openKey( | |
| rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM( | |
| "REGISTERED_BY"))), | |
| css::uno::UNO_SET_THROW)->getAsciiListValue()); | |
| switch (impls.getLength()) { | |
| case 0: | |
| throw css::uno::DeploymentException( | |
| (pKeys[nPos]->getKeyName() + | |
| rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM( | |
| "/REGISTERED_BY is empty"))), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| case 1: | |
| break; | |
| default: | |
| OSL_TRACE( | |
| ("arbitrarily chosing \"%s\" among multiple" | |
| " implementations for \"%s\""), | |
| rtl::OUStringToOString( | |
| impls[0], RTL_TEXTENCODING_UTF8).getStr(), | |
| rtl::OUStringToOString( | |
| pKeys[nPos]->getKeyName(), | |
| RTL_TEXTENCODING_UTF8).getStr()); | |
| break; | |
| } | |
| context_values.push_back( | |
| ContextEntry_Init( | |
| (rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM("/singletons/")) + | |
| pKeys[nPos]->getKeyName().copy( | |
| RTL_CONSTASCII_LENGTH("/SINGLETONS/"))), | |
| css::uno::makeAny(impls[0]), | |
| true)); | |
| } | |
| } | |
| } | |
| } | |
| // ac, policy: | |
| add_access_control_entries( &context_values, bootstrap ); | |
| // smgr singleton | |
| entry.bLateInitService = false; | |
| entry.name = OUSTR("/singletons/com.sun.star.lang.theServiceManager"); | |
| entry.value <<= xSF; | |
| context_values.push_back( entry ); | |
| Reference< XComponentContext > xContext( | |
| createComponentContext( | |
| &context_values[ 0 ], context_values.size(), | |
| Reference< XComponentContext >() ) ); | |
| // set default context | |
| Reference< beans::XPropertySet > xProps( xSF, UNO_QUERY ); | |
| OSL_ASSERT( xProps.is() ); | |
| if (xProps.is()) | |
| { | |
| xProps->setPropertyValue( | |
| OUSTR("DefaultContext"), makeAny( xContext ) ); | |
| } | |
| Reference< container::XHierarchicalNameAccess > xTDMgr; | |
| // get tdmgr singleton | |
| if (xContext->getValueByName( | |
| OUSTR("/singletons/" | |
| "com.sun.star.reflection.theTypeDescriptionManager") ) | |
| >>= xTDMgr) | |
| { | |
| if (types_xRegistry.is()) // insert rdb provider? | |
| { | |
| // add registry td provider factory to smgr and instance to tdmgr | |
| Reference< lang::XSingleComponentFactory > xFac( | |
| loadSharedLibComponentFactory( | |
| OUSTR("bootstrap.uno" SAL_DLLEXTENSION), | |
| 0 == rBootstrapPath.getLength() | |
| ? get_this_libpath() : rBootstrapPath, | |
| OUSTR("com.sun.star.comp.stoc.RegistryTypeDescriptionProvider"), | |
| Reference< lang::XMultiServiceFactory >( xSF, UNO_QUERY ), | |
| Reference< registry::XRegistryKey >() ), UNO_QUERY ); | |
| OSL_ASSERT( xFac.is() ); | |
| // smgr | |
| Reference< container::XSet > xSet( xSF, UNO_QUERY ); | |
| xSet->insert( makeAny( xFac ) ); | |
| OSL_ENSURE( | |
| xSet->has( makeAny( xFac ) ), | |
| "### failed registering registry td provider at smgr!" ); | |
| // tdmgr | |
| xSet.set( xTDMgr, UNO_QUERY ); | |
| OSL_ASSERT( xSet.is() ); | |
| Any types_RDB( makeAny( types_xRegistry ) ); | |
| Any rdbtdp( makeAny( xFac->createInstanceWithArgumentsAndContext( | |
| Sequence< Any >( &types_RDB, 1 ), xContext ) ) ); | |
| xSet->insert( rdbtdp ); | |
| OSL_ENSURE( | |
| xSet->has( rdbtdp ), | |
| "### failed inserting registry td provider to tdmgr!" ); | |
| } | |
| // install callback | |
| installTypeDescriptionManager( xTDMgr ); | |
| } | |
| return xContext; | |
| } | |
| static Reference< lang::XMultiComponentFactory > createImplServiceFactory( | |
| const OUString & rWriteRegistry, | |
| const OUString & rReadRegistry, | |
| sal_Bool bReadOnly, | |
| const OUString & rBootstrapPath ) | |
| { | |
| Reference< lang::XMultiComponentFactory > xSF( | |
| bootstrapInitialSF( rBootstrapPath ) ); | |
| Reference< registry::XSimpleRegistry > xRegistry; | |
| // open a registry | |
| sal_Bool bRegistryShouldBeValid = sal_False; | |
| if (rWriteRegistry.getLength() && !rReadRegistry.getLength()) | |
| { | |
| bRegistryShouldBeValid = sal_True; | |
| xRegistry.set( createSimpleRegistry( rBootstrapPath ) ); | |
| if (xRegistry.is()) | |
| { | |
| if (bReadOnly) | |
| { | |
| xRegistry->open( rWriteRegistry, sal_True, sal_False ); | |
| } | |
| else | |
| { | |
| xRegistry->open( rWriteRegistry, sal_False, sal_True ); | |
| } | |
| } | |
| } | |
| else if (rWriteRegistry.getLength() && rReadRegistry.getLength()) | |
| { | |
| // default registry | |
| bRegistryShouldBeValid = sal_True; | |
| xRegistry.set( createNestedRegistry( rBootstrapPath ) ); | |
| Reference< registry::XSimpleRegistry > xWriteReg( | |
| createSimpleRegistry( rBootstrapPath ) ); | |
| if (xWriteReg.is()) | |
| { | |
| if (bReadOnly) | |
| { | |
| try | |
| { | |
| xWriteReg->open( rWriteRegistry, sal_True, sal_False ); | |
| } | |
| catch (registry::InvalidRegistryException &) | |
| { | |
| } | |
| if (! xWriteReg->isValid()) | |
| { | |
| throw RuntimeException( | |
| OUSTR("specified first registry " | |
| "could not be open readonly!"), | |
| Reference< XInterface >() ); | |
| } | |
| } | |
| else | |
| { | |
| xWriteReg->open( rWriteRegistry, sal_False, sal_True ); | |
| } | |
| } | |
| Reference< registry::XSimpleRegistry > xReadReg( | |
| createSimpleRegistry( rBootstrapPath ) ); | |
| if (xReadReg.is()) | |
| { | |
| xReadReg->open( rReadRegistry, sal_True, sal_False ); | |
| } | |
| Reference< lang::XInitialization > xInit( xRegistry, UNO_QUERY ); | |
| Sequence< Any > aInitSeq( 2 ); | |
| aInitSeq[ 0 ] <<= xWriteReg; | |
| aInitSeq[ 1 ] <<= xReadReg; | |
| xInit->initialize( aInitSeq ); | |
| } | |
| if (bRegistryShouldBeValid && (!xRegistry.is() || !xRegistry->isValid())) | |
| { | |
| throw RuntimeException( | |
| OUSTR("specified registry could not be initialized"), | |
| Reference< XInterface >() ); | |
| } | |
| Bootstrap bootstrap; | |
| Reference< XComponentContext > xContext( | |
| bootstrapInitialContext( | |
| xSF, xRegistry, xRegistry, rBootstrapPath, bootstrap ) ); | |
| // initialize sf | |
| Reference< lang::XInitialization > xInit( xSF, UNO_QUERY ); | |
| OSL_ASSERT( xInit.is() ); | |
| Sequence< Any > aSFInit( 1 ); | |
| aSFInit[ 0 ] <<= xRegistry; | |
| xInit->initialize( aSFInit ); | |
| return xSF; | |
| } | |
| Reference< lang::XMultiServiceFactory > SAL_CALL createRegistryServiceFactory( | |
| const OUString & rWriteRegistry, | |
| const OUString & rReadRegistry, | |
| sal_Bool bReadOnly, | |
| const OUString & rBootstrapPath ) | |
| { | |
| return Reference< lang::XMultiServiceFactory >( createImplServiceFactory( | |
| rWriteRegistry, rReadRegistry, bReadOnly, rBootstrapPath ), UNO_QUERY ); | |
| } | |
| Reference< XComponentContext > SAL_CALL bootstrap_InitialComponentContext( | |
| Reference< registry::XSimpleRegistry > const & xRegistry, | |
| OUString const & rBootstrapPath ) | |
| { | |
| Bootstrap bootstrap; | |
| Reference< lang::XMultiComponentFactory > xSF( | |
| bootstrapInitialSF( rBootstrapPath ) ); | |
| Reference< XComponentContext > xContext( | |
| bootstrapInitialContext( | |
| xSF, xRegistry, xRegistry, rBootstrapPath, bootstrap ) ); | |
| // initialize sf | |
| Reference< lang::XInitialization > xInit( xSF, UNO_QUERY ); | |
| OSL_ASSERT( xInit.is() ); | |
| Sequence< Any > aSFInit( 2 ); | |
| aSFInit[ 0 ] <<= xRegistry; | |
| aSFInit[ 1 ] <<= xContext; // default context | |
| xInit->initialize( aSFInit ); | |
| return xContext; | |
| } | |
| } |