| /************************************************************** | |
| * | |
| * 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_stoc.hxx" | |
| #include <stdlib.h> | |
| #include <string.h> | |
| #include <list> | |
| #include <unistd.h> | |
| #include <cppuhelper/queryinterface.hxx> | |
| #include <cppuhelper/factory.hxx> | |
| #include <cppuhelper/weak.hxx> | |
| #include <cppuhelper/servicefactory.hxx> | |
| #ifndef _CPPUHELPER_IMPLBASE3_HXX | |
| #include <cppuhelper/implbase3.hxx> | |
| #endif | |
| #ifndef _CPPUHELPER_IMPLEMENTATIONENTRY_HXX_ | |
| #include <cppuhelper/implementationentry.hxx> | |
| #endif | |
| #include <uno/mapping.hxx> | |
| #include <osl/thread.h> | |
| #include <rtl/ustring.hxx> | |
| #include <rtl/ustrbuf.hxx> | |
| #include <rtl/strbuf.hxx> | |
| #include <osl/process.h> | |
| #include <com/sun/star/lang/XServiceInfo.hpp> | |
| #include <com/sun/star/lang/XInitialization.hpp> | |
| #include <com/sun/star/loader/XImplementationLoader.hpp> | |
| #include <com/sun/star/registry/XImplementationRegistration2.hpp> | |
| #include <com/sun/star/container/XHierarchicalNameAccess.hpp> | |
| #include <com/sun/star/reflection/XServiceTypeDescription.hpp> | |
| #include <com/sun/star/beans/XPropertySet.hpp> | |
| #include "com/sun/star/uno/RuntimeException.hpp" | |
| #include "mergekeys.hxx" | |
| #if defined(SAL_W32) || defined(SAL_OS2) | |
| #include <io.h> | |
| #endif | |
| #define OUSTR(x) ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(x) ) | |
| using namespace com::sun::star; | |
| using namespace com::sun::star::uno; | |
| using namespace com::sun::star::loader; | |
| using namespace com::sun::star::beans; | |
| using namespace com::sun::star::lang; | |
| using namespace com::sun::star::registry; | |
| using namespace cppu; | |
| using namespace rtl; | |
| using namespace osl; | |
| #define IMPLNAME "com.sun.star.comp.stoc.ImplementationRegistration" | |
| #define SERVICENAME "com.sun.star.registry.ImplementationRegistration" | |
| namespace stoc_impreg | |
| { | |
| struct StringPool | |
| { | |
| OUString sImplementationName; | |
| OUString sServiceName; | |
| OUString TMP; | |
| OUString TEMP; | |
| OUString slash_UNO_slash_REGISTRY_LINKS; | |
| OUString slash_IMPLEMENTATIONS; | |
| OUString slash_UNO; | |
| OUString slash_UNO_slash_SERVICES; | |
| OUString slash_UNO_slash_SINGLETONS; | |
| OUString slash_SERVICES; | |
| OUString slash_UNO_slash_LOCATION; | |
| OUString slash_UNO_slash_ACTIVATOR; | |
| OUString colon_old; | |
| OUString com_sun_star_registry_SimpleRegistry; | |
| OUString Registry; | |
| StringPool() | |
| : sImplementationName( RTL_CONSTASCII_USTRINGPARAM( IMPLNAME ) ) | |
| , sServiceName( RTL_CONSTASCII_USTRINGPARAM( SERVICENAME ) ) | |
| , TMP( RTL_CONSTASCII_USTRINGPARAM( "TMP" ) ) | |
| , TEMP( RTL_CONSTASCII_USTRINGPARAM( "TEMP" ) ) | |
| , slash_UNO_slash_REGISTRY_LINKS( RTL_CONSTASCII_USTRINGPARAM("/UNO/REGISTRY_LINKS")) | |
| , slash_IMPLEMENTATIONS( RTL_CONSTASCII_USTRINGPARAM( "/IMPLEMENTATIONS" ) ) | |
| , slash_UNO( RTL_CONSTASCII_USTRINGPARAM("/UNO")) | |
| , slash_UNO_slash_SERVICES( RTL_CONSTASCII_USTRINGPARAM("/UNO/SERVICES")) | |
| , slash_UNO_slash_SINGLETONS( RTL_CONSTASCII_USTRINGPARAM("/UNO/SINGLETONS")) | |
| , slash_SERVICES( RTL_CONSTASCII_USTRINGPARAM("/SERVICES/") ) | |
| , slash_UNO_slash_LOCATION( RTL_CONSTASCII_USTRINGPARAM("/UNO/LOCATION") ) | |
| , slash_UNO_slash_ACTIVATOR( RTL_CONSTASCII_USTRINGPARAM("/UNO/ACTIVATOR") ) | |
| , colon_old( RTL_CONSTASCII_USTRINGPARAM(":old")) | |
| , com_sun_star_registry_SimpleRegistry(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.registry.SimpleRegistry") ) | |
| , Registry( RTL_CONSTASCII_USTRINGPARAM("Registry") ) | |
| {} | |
| private: | |
| StringPool( const StringPool & ); | |
| }; | |
| const StringPool &spool() | |
| { | |
| static StringPool *pPool = 0; | |
| if( ! pPool ) | |
| { | |
| MutexGuard guard( Mutex::getGlobalMutex() ); | |
| if( ! pPool ) | |
| { | |
| static StringPool pool; | |
| pPool = &pool; | |
| } | |
| } | |
| return *pPool; | |
| } | |
| } | |
| extern rtl_StandardModuleCount g_moduleCount; | |
| namespace stoc_bootstrap | |
| { | |
| Sequence< OUString > impreg_getSupportedServiceNames() | |
| { | |
| static Sequence < OUString > *pNames = 0; | |
| if( ! pNames ) | |
| { | |
| MutexGuard guard( Mutex::getGlobalMutex() ); | |
| if( !pNames ) | |
| { | |
| static Sequence< OUString > seqNames(1); | |
| seqNames.getArray()[0] = stoc_impreg::spool().sServiceName; | |
| pNames = &seqNames; | |
| } | |
| } | |
| return *pNames; | |
| } | |
| OUString impreg_getImplementationName() | |
| { | |
| return stoc_impreg::spool().sImplementationName; | |
| } | |
| } | |
| namespace stoc_impreg | |
| { | |
| //************************************************************************* | |
| // static deleteAllLinkReferences() | |
| // | |
| static void deleteAllLinkReferences(const Reference < XSimpleRegistry >& xReg, | |
| const Reference < XRegistryKey >& xSource) | |
| // throw ( InvalidRegistryException, RuntimeException ) | |
| { | |
| Reference < XRegistryKey > xKey = xSource->openKey( | |
| spool().slash_UNO_slash_REGISTRY_LINKS ); | |
| if (xKey.is() && (xKey->getValueType() == RegistryValueType_ASCIILIST)) | |
| { | |
| Sequence<OUString> linkNames = xKey->getAsciiListValue(); | |
| if (linkNames.getLength()) | |
| { | |
| const OUString* pLinkNames = linkNames.getConstArray(); | |
| OUString aLinkName; | |
| OUString aLinkParent; | |
| Reference < XRegistryKey > xLinkParent; | |
| const sal_Unicode* pTmpName = NULL; | |
| const sal_Unicode* pShortName = NULL; | |
| sal_Int32 sEnd = 0; | |
| for (sal_Int32 i = 0; i < linkNames.getLength(); i++) | |
| { | |
| aLinkName = pLinkNames[i]; | |
| pTmpName = aLinkName.getStr(); | |
| if (pTmpName[0] != L'/') | |
| continue; | |
| sal_Int32 nIndex = rtl_ustr_indexOfChar( pTmpName, '%' ); | |
| if ( nIndex == -1 ) | |
| pShortName = 0; | |
| else | |
| pShortName = pTmpName+nIndex; | |
| while (pShortName && pShortName[1] == L'%') | |
| { | |
| nIndex = rtl_ustr_indexOfChar( pShortName+2, '%' ); | |
| if ( nIndex == -1 ) | |
| pShortName = 0; | |
| else | |
| pShortName += nIndex+2; | |
| } | |
| if (pShortName) | |
| { | |
| aLinkName = aLinkName.copy(0, pShortName - pTmpName); | |
| } | |
| xReg->getRootKey()->deleteLink(aLinkName); | |
| sEnd = rtl_ustr_lastIndexOfChar( aLinkName.getStr(), '/' ); | |
| aLinkParent = aLinkName.copy(0, sEnd); | |
| while(aLinkParent.getLength()) | |
| { | |
| xLinkParent = xReg->getRootKey()->openKey(aLinkParent); | |
| if (xLinkParent.is() && (xLinkParent->getKeyNames().getLength() == 0)) | |
| { | |
| aLinkName = aLinkParent; | |
| xReg->getRootKey()->deleteKey(aLinkParent); | |
| sEnd = rtl_ustr_lastIndexOfChar( aLinkName.getStr(), '/' ); | |
| aLinkParent = aLinkName.copy(0, sEnd); | |
| } else | |
| { | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| //************************************************************************* | |
| // static prepareLink | |
| // | |
| static void prepareLink( const Reference < XSimpleRegistry > & xDest, | |
| const Reference < XRegistryKey > & xSource, | |
| const OUString& link) | |
| // throw ( InvalidRegistryException, RuntimeException ) | |
| { | |
| OUString linkRefName = xSource->getKeyName(); | |
| OUString linkName(link); | |
| sal_Bool isRelativ = sal_False; | |
| const sal_Unicode* pTmpName = link.getStr(); | |
| const sal_Unicode* pShortName; | |
| sal_Int32 nIndex = rtl_ustr_indexOfChar( pTmpName, '%' ); | |
| if ( nIndex == -1 ) | |
| pShortName = 0; | |
| else | |
| pShortName = pTmpName+nIndex; | |
| if (pTmpName[0] != L'/') | |
| isRelativ = sal_True; | |
| while (pShortName && pShortName[1] == L'%') | |
| { | |
| nIndex = rtl_ustr_indexOfChar( pShortName+2, '%' ); | |
| if ( nIndex == -1 ) | |
| pShortName = 0; | |
| else | |
| pShortName += nIndex+2; | |
| } | |
| if (pShortName) | |
| { | |
| linkRefName = linkRefName + link.copy(pShortName - pTmpName + 1); | |
| linkName = link.copy(0, pShortName - pTmpName); | |
| } | |
| if (isRelativ) | |
| xSource->createLink(linkName, linkRefName); | |
| else | |
| xDest->getRootKey()->createLink(linkName, linkRefName); | |
| } | |
| //************************************************************************* | |
| // static searchImplForLink | |
| // | |
| static OUString searchImplForLink( | |
| const Reference < XRegistryKey > & xRootKey, | |
| const OUString& linkName, | |
| const OUString& implName ) | |
| // throw ( InvalidRegistryException, RuntimeException ) | |
| { | |
| const StringPool & pool = spool(); | |
| Reference < XRegistryKey > xKey = xRootKey->openKey( pool.slash_IMPLEMENTATIONS ); | |
| if (xKey.is()) | |
| { | |
| Sequence< Reference < XRegistryKey > > subKeys( xKey->openKeys() ); | |
| const Reference < XRegistryKey > * pSubKeys = subKeys.getConstArray(); | |
| OUString key_name( pool.slash_UNO + linkName ); | |
| for (sal_Int32 i = 0; i < subKeys.getLength(); i++) | |
| { | |
| try | |
| { | |
| Reference < XRegistryKey > xImplKey( pSubKeys[i] ); | |
| if (xImplKey->getKeyType( key_name ) == RegistryKeyType_LINK) | |
| { | |
| OUString oldImplName = xImplKey->getKeyName().copy(strlen("/IMPLEMENTATIONS/")); | |
| if (implName != oldImplName) | |
| { | |
| return oldImplName; | |
| } | |
| } | |
| } | |
| catch(InvalidRegistryException&) | |
| { | |
| } | |
| } | |
| } | |
| return OUString(); | |
| } | |
| //************************************************************************* | |
| // static searchLinkTargetForImpl | |
| // | |
| static OUString searchLinkTargetForImpl(const Reference < XRegistryKey >& xRootKey, | |
| const OUString& linkName, | |
| const OUString& implName) | |
| // throw ( InvalidRegistryException, RuntimeException ) | |
| { | |
| OUString ret; | |
| // try | |
| // { | |
| const StringPool & pool = spool(); | |
| Reference < XRegistryKey > xKey = xRootKey->openKey( pool.slash_IMPLEMENTATIONS ); | |
| if (xKey.is()) | |
| { | |
| Sequence< Reference < XRegistryKey > > subKeys = xKey->openKeys(); | |
| const Reference < XRegistryKey >* pSubKeys = subKeys.getConstArray(); | |
| Reference < XRegistryKey > xImplKey; | |
| for (sal_Int32 i = 0; i < subKeys.getLength(); i++) | |
| { | |
| xImplKey = pSubKeys[i]; | |
| OUString tmpImplName = xImplKey->getKeyName().copy(strlen("/IMPLEMENTATIONS/")); | |
| OUString qualifiedLinkName( pool.slash_UNO ); | |
| qualifiedLinkName += linkName; | |
| if (tmpImplName == implName && | |
| xImplKey->getKeyType( qualifiedLinkName ) == RegistryKeyType_LINK) | |
| { | |
| return xImplKey->getLinkTarget( qualifiedLinkName ); | |
| } | |
| } | |
| } | |
| // } | |
| // catch(InvalidRegistryException&) | |
| // { | |
| // } | |
| return ret; | |
| } | |
| //************************************************************************* | |
| // static createUniqueSubEntry | |
| // | |
| static void createUniqueSubEntry(const Reference < XRegistryKey > & xSuperKey, | |
| const OUString& value) | |
| // throw ( InvalidRegistryException, RuntimeException ) | |
| { | |
| if (xSuperKey.is()) | |
| { | |
| // try | |
| // { | |
| if (xSuperKey->getValueType() == RegistryValueType_ASCIILIST) | |
| { | |
| sal_Int32 length = 0; | |
| sal_Bool bReady = sal_False; | |
| Sequence<OUString> implEntries = xSuperKey->getAsciiListValue(); | |
| length = implEntries.getLength(); | |
| for (sal_Int32 i = 0; !bReady && (i < length); i++) | |
| { | |
| bReady = (implEntries.getConstArray()[i] == value); | |
| } | |
| if (bReady) | |
| { | |
| Sequence<OUString> implEntriesNew(length); | |
| implEntriesNew.getArray()[0] = value; | |
| for (sal_Int32 i=0, j=1; i < length; i++) | |
| { | |
| if (implEntries.getConstArray()[i] != value) | |
| implEntriesNew.getArray()[j++] = implEntries.getConstArray()[i]; | |
| } | |
| xSuperKey->setAsciiListValue(implEntriesNew); | |
| } else | |
| { | |
| Sequence<OUString> implEntriesNew(length+1); | |
| implEntriesNew.getArray()[0] = value; | |
| for (sal_Int32 i = 0; i < length; i++) | |
| { | |
| implEntriesNew.getArray()[i+1] = implEntries.getConstArray()[i]; | |
| } | |
| xSuperKey->setAsciiListValue(implEntriesNew); | |
| } | |
| } else | |
| { | |
| Sequence<OUString> implEntriesNew(1); | |
| implEntriesNew.getArray()[0] = value; | |
| xSuperKey->setAsciiListValue(implEntriesNew); | |
| } | |
| // } | |
| // catch(InvalidRegistryException&) | |
| // { | |
| // } | |
| } | |
| } | |
| //************************************************************************* | |
| // static deleteSubEntry | |
| // | |
| static sal_Bool deleteSubEntry(const Reference < XRegistryKey >& xSuperKey, const OUString& value) | |
| // throw ( InvalidRegistryException, RuntimeException ) | |
| { | |
| if (xSuperKey->getValueType() == RegistryValueType_ASCIILIST) | |
| { | |
| Sequence<OUString> implEntries = xSuperKey->getAsciiListValue(); | |
| sal_Int32 length = implEntries.getLength(); | |
| sal_Int32 equals = 0; | |
| sal_Bool hasNoImplementations = sal_False; | |
| for (sal_Int32 i = 0; i < length; i++) | |
| { | |
| if (implEntries.getConstArray()[i] == value) | |
| equals++; | |
| } | |
| if (equals == length) | |
| { | |
| hasNoImplementations = sal_True; | |
| } else | |
| { | |
| Sequence<OUString> implEntriesNew(length - equals); | |
| sal_Int32 j = 0; | |
| for (sal_Int32 i = 0; i < length; i++) | |
| { | |
| if (implEntries.getConstArray()[i] != value) | |
| { | |
| implEntriesNew.getArray()[j++] = implEntries.getConstArray()[i]; | |
| } | |
| } | |
| xSuperKey->setAsciiListValue(implEntriesNew); | |
| } | |
| if (hasNoImplementations) | |
| { | |
| return sal_True; | |
| } | |
| } | |
| return sal_False; | |
| } | |
| //************************************************************************* | |
| // static prepareUserLink | |
| // | |
| static void prepareUserLink(const Reference < XSimpleRegistry >& xDest, | |
| const OUString& linkName, | |
| const OUString& linkTarget, | |
| const OUString& implName) | |
| // throw ( InvalidRegistryException, RuntimeException ) | |
| { | |
| sal_Bool ret = sal_False; | |
| Reference < XRegistryKey > xRootKey; | |
| // try | |
| // { | |
| xRootKey = xDest->getRootKey(); | |
| if (xRootKey->getKeyType(linkName) == RegistryKeyType_LINK) | |
| { | |
| OUString oldImplName(searchImplForLink(xRootKey, linkName, implName)); | |
| if (oldImplName.getLength()) | |
| { | |
| createUniqueSubEntry(xDest->getRootKey()->createKey( | |
| linkName + spool().colon_old ), oldImplName); | |
| } | |
| } | |
| // } | |
| // catch (InvalidRegistryException&) | |
| // { | |
| // } | |
| // try | |
| // { | |
| if (xRootKey->isValid()) | |
| { | |
| ret = xRootKey->createLink(linkName, linkTarget); | |
| } | |
| // } | |
| // catch(InvalidRegistryException&) | |
| // { | |
| // } | |
| // return ret; | |
| } | |
| //************************************************************************* | |
| // static deleteUserLink | |
| // | |
| static void deletePathIfPossible(const Reference < XRegistryKey >& xRootKey, | |
| const OUString& path) | |
| { | |
| try | |
| { | |
| Sequence<OUString> keyNames(xRootKey->openKey(path)->getKeyNames()); | |
| if (keyNames.getLength() == 0 && | |
| xRootKey->openKey(path)->getValueType() == RegistryValueType_NOT_DEFINED) | |
| { | |
| xRootKey->deleteKey(path); | |
| OUString tmpPath(path); | |
| OUString newPath = tmpPath.copy(0, tmpPath.lastIndexOf('/')); | |
| if (newPath.getLength() > 1) | |
| deletePathIfPossible(xRootKey, newPath); | |
| } | |
| } | |
| catch(InvalidRegistryException&) | |
| { | |
| } | |
| } | |
| //************************************************************************* | |
| // static deleteUserLink | |
| // | |
| static void deleteUserLink(const Reference < XRegistryKey >& xRootKey, | |
| const OUString& linkName, | |
| const OUString& linkTarget, | |
| const OUString& implName) | |
| // throw ( InvalidRegistryException, RuntimeException ) | |
| { | |
| sal_Bool bClean = sal_False; | |
| if (xRootKey->getKeyType(linkName) == RegistryKeyType_LINK) | |
| { | |
| OUString tmpTarget = xRootKey->getLinkTarget(linkName); | |
| if (tmpTarget == linkTarget) | |
| { | |
| xRootKey->deleteLink(linkName); | |
| } | |
| } | |
| Reference < XRegistryKey > xOldKey = xRootKey->openKey( | |
| linkName + spool().colon_old ); | |
| if (xOldKey.is()) | |
| { | |
| sal_Bool hasNoImplementations = sal_False; | |
| if (xOldKey->getValueType() == RegistryValueType_ASCIILIST) | |
| { | |
| Sequence<OUString> implEntries = xOldKey->getAsciiListValue(); | |
| sal_Int32 length = implEntries.getLength(); | |
| sal_Int32 equals = 0; | |
| for (sal_Int32 i = 0; i < length; i++) | |
| { | |
| if (implEntries.getConstArray()[i] == implName) | |
| equals++; | |
| } | |
| if (equals == length) | |
| { | |
| hasNoImplementations = sal_True; | |
| } else | |
| { | |
| OUString oldImpl; | |
| if (length > equals + 1) | |
| { | |
| Sequence<OUString> implEntriesNew(length - equals - 1); | |
| sal_Int32 j = 0; | |
| sal_Bool first = sal_True; | |
| for (sal_Int32 i = 0; i < length; i++) | |
| { | |
| if (implEntries.getConstArray()[i] != implName) | |
| { | |
| if (first) | |
| { | |
| oldImpl = implEntries.getConstArray()[i]; | |
| first = sal_False; | |
| } else | |
| { | |
| implEntriesNew.getArray()[j++] = implEntries.getConstArray()[i]; | |
| } | |
| } | |
| } | |
| xOldKey->setAsciiListValue(implEntriesNew); | |
| } else | |
| { | |
| oldImpl = implEntries.getConstArray()[0]; | |
| rtl::OUString path(xOldKey->getKeyName()); | |
| xOldKey->closeKey(); | |
| xRootKey->deleteKey(path); | |
| } | |
| OUString oldTarget = searchLinkTargetForImpl(xRootKey, linkName, oldImpl); | |
| if (oldTarget.getLength()) | |
| { | |
| xRootKey->createLink(linkName, oldTarget); | |
| } | |
| } | |
| if (hasNoImplementations) | |
| { | |
| bClean = sal_True; | |
| hasNoImplementations = sal_False; | |
| rtl::OUString path(xOldKey->getKeyName()); | |
| xOldKey->closeKey(); | |
| xRootKey->deleteKey(path); | |
| } | |
| } | |
| } else | |
| { | |
| bClean = sal_True; | |
| } | |
| if (bClean) | |
| { | |
| OUString tmpName(linkName); | |
| OUString path = tmpName.copy(0, tmpName.lastIndexOf('/')); | |
| deletePathIfPossible(xRootKey, path); | |
| } | |
| } | |
| //************************************************************************* | |
| // static prepareUserKeys | |
| // | |
| static void prepareUserKeys(const Reference < XSimpleRegistry >& xDest, | |
| const Reference < XRegistryKey >& xUnoKey, | |
| const Reference < XRegistryKey >& xKey, | |
| const OUString& implName, | |
| sal_Bool bRegister) | |
| // throw ( InvalidRegistryException, RuntimeException ) | |
| { | |
| sal_Bool hasSubKeys = sal_False; | |
| Sequence<OUString> keyNames = xKey->getKeyNames(); | |
| OUString relativKey; | |
| if (keyNames.getLength()) | |
| relativKey = keyNames.getConstArray()[0].copy(xKey->getKeyName().getLength()+1); | |
| if (keyNames.getLength() == 1 && | |
| xKey->getKeyType(relativKey) == RegistryKeyType_LINK) | |
| { | |
| hasSubKeys = sal_True; | |
| OUString linkTarget = xKey->getLinkTarget(relativKey); | |
| OUString linkName(xKey->getKeyName().copy(xUnoKey->getKeyName().getLength())); | |
| linkName = linkName + OUString( RTL_CONSTASCII_USTRINGPARAM("/") ) + relativKey; | |
| if (bRegister) | |
| { | |
| prepareUserLink(xDest, linkName, linkTarget, implName); | |
| } else | |
| { | |
| deleteUserLink(xDest->getRootKey(), linkName, linkTarget, implName); | |
| } | |
| } else | |
| { | |
| Sequence< Reference < XRegistryKey> > subKeys = xKey->openKeys(); | |
| if (subKeys.getLength()) | |
| { | |
| hasSubKeys = sal_True; | |
| const Reference < XRegistryKey > * pSubKeys = subKeys.getConstArray(); | |
| for (sal_Int32 i = 0; i < subKeys.getLength(); i++) | |
| { | |
| prepareUserKeys(xDest, xUnoKey, pSubKeys[i], implName, bRegister); | |
| } | |
| } | |
| } | |
| if (! hasSubKeys) | |
| { | |
| OUString keyName(xKey->getKeyName().copy(xUnoKey->getKeyName().getLength())); | |
| Reference < XRegistryKey > xRootKey = xDest->getRootKey(); | |
| if (bRegister) | |
| { | |
| createUniqueSubEntry(xRootKey->createKey(keyName), implName); | |
| } | |
| else | |
| { | |
| Reference< XRegistryKey > rKey = xRootKey->openKey(keyName); | |
| if( rKey.is() ) | |
| { | |
| deleteSubEntry(rKey, implName); | |
| xRootKey->deleteKey(keyName); | |
| } | |
| OUString path = keyName.copy(0, keyName.lastIndexOf('/')); | |
| if( path.getLength() ) | |
| { | |
| deletePathIfPossible(xRootKey, path); | |
| } | |
| } | |
| } | |
| return; | |
| } | |
| //************************************************************************* | |
| // static deleteAllImplementations | |
| // | |
| static void deleteAllImplementations( const Reference < XSimpleRegistry >& xReg, | |
| const Reference < XRegistryKey >& xSource, | |
| const OUString& locationUrl, | |
| std::list<OUString> & implNames) | |
| // throw (InvalidRegistryException, RuntimeException) | |
| { | |
| Sequence < Reference < XRegistryKey > > subKeys = xSource->openKeys(); | |
| if (subKeys.getLength() > 0) | |
| { | |
| const Reference < XRegistryKey> * pSubKeys = subKeys.getConstArray(); | |
| Reference < XRegistryKey > xImplKey; | |
| sal_Bool hasLocationUrl = sal_False; | |
| const StringPool &pool = spool(); | |
| for (sal_Int32 i = 0; i < subKeys.getLength(); i++) | |
| { | |
| xImplKey = pSubKeys[i]; | |
| Reference < XRegistryKey > xKey = xImplKey->openKey( | |
| pool.slash_UNO_slash_LOCATION ); | |
| if (xKey.is() && (xKey->getValueType() == RegistryValueType_ASCII)) | |
| { | |
| if (xKey->getAsciiValue() == locationUrl) | |
| { | |
| hasLocationUrl = sal_True; | |
| OUString implName(xImplKey->getKeyName().getStr() + 1); | |
| sal_Int32 firstDot = implName.indexOf('/'); | |
| if (firstDot >= 0) | |
| implName = implName.copy(firstDot + 1); | |
| implNames.push_back(implName); | |
| deleteAllLinkReferences(xReg, xImplKey); | |
| xKey = xImplKey->openKey( pool.slash_UNO ); | |
| if (xKey.is()) | |
| { | |
| Sequence< Reference < XRegistryKey > > subKeys2 = xKey->openKeys(); | |
| if (subKeys2.getLength()) | |
| { | |
| const Reference < XRegistryKey > * pSubKeys2 = subKeys2.getConstArray(); | |
| for (sal_Int32 j = 0; j < subKeys2.getLength(); j++) | |
| { | |
| if (pSubKeys2[j]->getKeyName() != (xImplKey->getKeyName() + pool.slash_UNO_slash_SERVICES ) && | |
| pSubKeys2[j]->getKeyName() != (xImplKey->getKeyName() + pool.slash_UNO_slash_REGISTRY_LINKS ) && | |
| pSubKeys2[j]->getKeyName() != (xImplKey->getKeyName() + pool.slash_UNO_slash_ACTIVATOR ) && | |
| pSubKeys2[j]->getKeyName() != (xImplKey->getKeyName() + pool.slash_UNO_slash_SINGLETONS ) && | |
| pSubKeys2[j]->getKeyName() != (xImplKey->getKeyName() + pool.slash_UNO_slash_LOCATION) ) | |
| { | |
| prepareUserKeys(xReg, xKey, pSubKeys2[j], implName, sal_False); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| if (hasLocationUrl) | |
| { | |
| hasLocationUrl = sal_False; | |
| rtl::OUString path(xImplKey->getKeyName()); | |
| xImplKey->closeKey(); | |
| xReg->getRootKey()->deleteKey(path); | |
| } | |
| } | |
| subKeys = xSource->openKeys(); | |
| if (subKeys.getLength() == 0) | |
| { | |
| rtl::OUString path(xSource->getKeyName()); | |
| xSource->closeKey(); | |
| xReg->getRootKey()->deleteKey(path); | |
| } | |
| } else | |
| { | |
| rtl::OUString path(xSource->getKeyName()); | |
| xSource->closeKey(); | |
| xReg->getRootKey()->deleteKey(path); | |
| } | |
| } | |
| //================================================================================================== | |
| static void delete_all_singleton_entries( | |
| Reference < registry::XRegistryKey > const & xSingletons_section, | |
| ::std::list< OUString > const & impl_names ) | |
| // throw (InvalidRegistryException, RuntimeException) | |
| { | |
| Sequence< Reference< registry::XRegistryKey > > singletons( xSingletons_section->openKeys() ); | |
| Reference< registry::XRegistryKey > const * subkeys = singletons.getConstArray(); | |
| for ( sal_Int32 nPos = singletons.getLength(); nPos--; ) | |
| { | |
| Reference< registry::XRegistryKey > const & xSingleton = subkeys[ nPos ]; | |
| Reference< registry::XRegistryKey > xRegisteredImplNames( | |
| xSingleton->openKey( OUSTR("REGISTERED_BY") ) ); | |
| if (xRegisteredImplNames.is() && xRegisteredImplNames->isValid()) | |
| { | |
| Sequence< OUString > registered_implnames; | |
| try | |
| { | |
| registered_implnames = xRegisteredImplNames->getAsciiListValue(); | |
| } | |
| catch (registry::InvalidValueException &) | |
| { | |
| } | |
| OUString const * p = registered_implnames.getConstArray(); | |
| sal_Int32 nOrigRegLength = registered_implnames.getLength(); | |
| sal_Int32 nNewLength = nOrigRegLength; | |
| for ( sal_Int32 n = nOrigRegLength; n--; ) | |
| { | |
| OUString const & registered_implname = p[ n ]; | |
| ::std::list< OUString >::const_iterator iPos( impl_names.begin() ); | |
| ::std::list< OUString >::const_iterator const iEnd( impl_names.end() ); | |
| for ( ; iPos != iEnd; ++iPos ) | |
| { | |
| if (iPos->equals( registered_implname )) | |
| { | |
| registered_implnames[ n ] = p[ nNewLength -1 ]; | |
| --nNewLength; | |
| } | |
| } | |
| } | |
| if (nNewLength != nOrigRegLength) | |
| { | |
| if (0 == nNewLength) | |
| { | |
| // remove whole entry | |
| xRegisteredImplNames->closeKey(); | |
| xSingleton->deleteKey( OUSTR("REGISTERED_BY") ); | |
| // registry key cannot provide its relative name, only absolute :( | |
| OUString abs( xSingleton->getKeyName() ); | |
| xSingletons_section->deleteKey( abs.copy( abs.lastIndexOf( '/' ) +1 ) ); | |
| } | |
| else | |
| { | |
| registered_implnames.realloc( nNewLength ); | |
| xRegisteredImplNames->setAsciiListValue( registered_implnames ); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| //************************************************************************* | |
| // static deleteAllServiceEntries | |
| // | |
| static void deleteAllServiceEntries( const Reference < XSimpleRegistry >& xReg, | |
| const Reference < XRegistryKey >& xSource, | |
| const OUString& implName) | |
| // throw ( InvalidRegistryException, RuntimeException ) | |
| { | |
| Sequence< Reference < XRegistryKey > > subKeys = xSource->openKeys(); | |
| if (subKeys.getLength() > 0) | |
| { | |
| const Reference < XRegistryKey > * pSubKeys = subKeys.getConstArray(); | |
| Reference < XRegistryKey > xServiceKey; | |
| sal_Bool hasNoImplementations = sal_False; | |
| for (sal_Int32 i = 0; i < subKeys.getLength(); i++) | |
| { | |
| xServiceKey = pSubKeys[i]; | |
| if (xServiceKey->getValueType() == RegistryValueType_ASCIILIST) | |
| { | |
| Sequence<OUString> implEntries = xServiceKey->getAsciiListValue(); | |
| sal_Int32 length = implEntries.getLength(); | |
| sal_Int32 equals = 0; | |
| for (sal_Int32 j = 0; j < length; j++) | |
| { | |
| if (implEntries.getConstArray()[j] == implName) | |
| equals++; | |
| } | |
| if (equals == length) | |
| { | |
| hasNoImplementations = sal_True; | |
| } else | |
| { | |
| if (equals > 0) | |
| { | |
| Sequence<OUString> implEntriesNew(length-equals); | |
| sal_Int32 j = 0; | |
| for (sal_Int32 k = 0; k < length; k++) | |
| { | |
| if (implEntries.getConstArray()[k] != implName) | |
| { | |
| implEntriesNew.getArray()[j++] = implEntries.getConstArray()[k]; | |
| } | |
| } | |
| xServiceKey->setAsciiListValue(implEntriesNew); | |
| } | |
| } | |
| } | |
| if (hasNoImplementations) | |
| { | |
| hasNoImplementations = sal_False; | |
| rtl::OUString path(xServiceKey->getKeyName()); | |
| xServiceKey->closeKey(); | |
| xReg->getRootKey()->deleteKey(path); | |
| } | |
| } | |
| subKeys = xSource->openKeys(); | |
| if (subKeys.getLength() == 0) | |
| { | |
| rtl::OUString path(xSource->getKeyName()); | |
| xSource->closeKey(); | |
| xReg->getRootKey()->deleteKey(path); | |
| } | |
| } else | |
| { | |
| rtl::OUString path(xSource->getKeyName()); | |
| xSource->closeKey(); | |
| xReg->getRootKey()->deleteKey(path); | |
| } | |
| } | |
| //-------------------------------------------------------------------------------------------------- | |
| static bool is_supported_service( | |
| OUString const & service_name, | |
| Reference< reflection::XServiceTypeDescription > const & xService_td ) | |
| { | |
| if (xService_td->getName().equals( service_name )) | |
| return true; | |
| Sequence< Reference< reflection::XServiceTypeDescription > > seq( | |
| xService_td->getMandatoryServices() ); | |
| Reference< reflection::XServiceTypeDescription > const * p = seq.getConstArray(); | |
| for ( sal_Int32 nPos = seq.getLength(); nPos--; ) | |
| { | |
| if (is_supported_service( service_name, p[ nPos ] )) | |
| return true; | |
| } | |
| return false; | |
| } | |
| //-------------------------------------------------------------------------------------------------- | |
| static void insert_singletons( | |
| Reference< registry::XSimpleRegistry > const & xDest, | |
| Reference< registry::XRegistryKey > const & xImplKey, | |
| Reference< XComponentContext > const & xContext ) | |
| // throw( registry::InvalidRegistryException, registry::CannotRegisterImplementationException, RuntimeException ) | |
| { | |
| // singletons | |
| Reference< registry::XRegistryKey > xKey( xImplKey->openKey( OUSTR("UNO/SINGLETONS") ) ); | |
| if (xKey.is() && xKey->isValid()) | |
| { | |
| OUString implname( xImplKey->getKeyName().copy( sizeof ("/IMPLEMENTATIONS/") -1 ) ); | |
| // singleton entries | |
| Sequence< Reference< registry::XRegistryKey > > xSingletons_section( xKey->openKeys() ); | |
| Reference< registry::XRegistryKey > const * p = xSingletons_section.getConstArray(); | |
| for ( sal_Int32 nPos = xSingletons_section.getLength(); nPos--; ) | |
| { | |
| Reference< registry::XRegistryKey > const & xSingleton = p[ nPos ]; | |
| OUString singleton_name( | |
| xSingleton->getKeyName().copy( | |
| implname.getLength() + sizeof ("/IMPLEMENTATIONS//UNO/SINGLETONS/") -1 ) ); | |
| OUString service_name( xSingleton->getStringValue() ); | |
| OUString keyname( OUSTR("/SINGLETONS/") + singleton_name ); | |
| Reference< registry::XRegistryKey > xKey2( xDest->getRootKey()->openKey( keyname ) ); | |
| if (xKey2.is() && xKey2->isValid()) | |
| { | |
| try | |
| { | |
| OUString existing_name( xKey2->getStringValue() ); | |
| if (! existing_name.equals( service_name )) | |
| { | |
| Reference< container::XHierarchicalNameAccess > xTDMgr; | |
| OUString the_tdmgr = | |
| OUSTR("/singletons/com.sun.star.reflection.theTypeDescriptionManager"); | |
| xContext->getValueByName( the_tdmgr ) >>= xTDMgr; | |
| if (! xTDMgr.is()) | |
| { | |
| throw RuntimeException( | |
| OUSTR("cannot get singleton ") + the_tdmgr, | |
| Reference< XInterface >() ); | |
| } | |
| try | |
| { | |
| Reference< reflection::XServiceTypeDescription > xExistingService_td; | |
| xTDMgr->getByHierarchicalName( existing_name ) >>= xExistingService_td; | |
| if (! xExistingService_td.is()) | |
| { | |
| throw RuntimeException( | |
| OUSTR("cannot get service type description: ") + existing_name, | |
| Reference< XInterface >() ); | |
| } | |
| // everything's fine if existing service entry supports the one | |
| // to be registered | |
| if (! is_supported_service( service_name, xExistingService_td )) | |
| { | |
| OUStringBuffer buf( 64 ); | |
| buf.appendAscii( | |
| RTL_CONSTASCII_STRINGPARAM("existing singleton service (") ); | |
| buf.append( singleton_name ); | |
| buf.append( (sal_Unicode)'=' ); | |
| buf.append( existing_name ); | |
| buf.appendAscii( | |
| RTL_CONSTASCII_STRINGPARAM(") does not support given one: ") ); | |
| buf.append( service_name ); | |
| throw registry::CannotRegisterImplementationException( | |
| buf.makeStringAndClear(), Reference< XInterface >() ); | |
| } | |
| } | |
| catch (container::NoSuchElementException & exc) | |
| { | |
| throw RuntimeException( | |
| OUSTR("cannot get service type description: ") + exc.Message, | |
| Reference< XInterface >() ); | |
| } | |
| } | |
| } | |
| catch (registry::InvalidValueException &) | |
| { | |
| // repair | |
| xKey2->setStringValue( service_name ); | |
| } | |
| } | |
| else | |
| { | |
| // insert singleton entry | |
| xKey2 = xDest->getRootKey()->createKey( keyname ); | |
| xKey2->setStringValue( service_name ); | |
| } | |
| Reference< registry::XRegistryKey > xRegisteredImplNames( | |
| xKey2->openKey( OUSTR("REGISTERED_BY") ) ); | |
| if (!xRegisteredImplNames.is() || !xRegisteredImplNames->isValid()) | |
| { | |
| // create | |
| xRegisteredImplNames = xKey2->createKey( OUSTR("REGISTERED_BY") ); | |
| } | |
| Sequence< OUString > implnames; | |
| try | |
| { | |
| implnames = xRegisteredImplNames->getAsciiListValue(); | |
| } | |
| catch (registry::InvalidValueException &) | |
| { | |
| } | |
| // check implname is already in | |
| sal_Int32 nPos_implnames = implnames.getLength(); | |
| OUString const * pImplnames = implnames.getConstArray(); | |
| while (nPos_implnames--) | |
| { | |
| if (implname.equals( pImplnames[ nPos_implnames ] )) | |
| break; | |
| } | |
| if (nPos_implnames < 0) | |
| { | |
| // append and write back | |
| implnames.realloc( implnames.getLength() +1 ); | |
| implnames[ implnames.getLength() -1 ] = implname; | |
| xRegisteredImplNames->setAsciiListValue( implnames ); | |
| } | |
| } | |
| } | |
| } | |
| //************************************************************************* | |
| // static prepareRegistry | |
| // | |
| static void prepareRegistry( | |
| const Reference < XSimpleRegistry >& xDest, | |
| const Reference < XRegistryKey >& xSource, | |
| const OUString& implementationLoaderUrl, | |
| const OUString& locationUrl, | |
| Reference< XComponentContext > const & xContext ) | |
| // throw ( InvalidRegistryException, CannotRegisterImplementationException, RuntimeException ) | |
| { | |
| Sequence< Reference < XRegistryKey > > subKeys = xSource->openKeys(); | |
| if (!subKeys.getLength()) | |
| { | |
| throw InvalidRegistryException( | |
| OUString( RTL_CONSTASCII_USTRINGPARAM( "prepareRegistry(): source registry is empty" ) ), | |
| Reference< XInterface > () ); | |
| } | |
| const StringPool & pool = spool(); | |
| const Reference < XRegistryKey >* pSubKeys = subKeys.getConstArray(); | |
| Reference < XRegistryKey > xImplKey; | |
| for (sal_Int32 i = 0; i < subKeys.getLength(); i++) | |
| { | |
| xImplKey = pSubKeys[i]; | |
| Reference < XRegistryKey > xKey = xImplKey->openKey( | |
| pool.slash_UNO_slash_SERVICES ); | |
| if (xKey.is()) | |
| { | |
| // update entries in SERVICES section | |
| Sequence< Reference < XRegistryKey > > serviceKeys = xKey->openKeys(); | |
| const Reference < XRegistryKey > * pServiceKeys = serviceKeys.getConstArray(); | |
| OUString implName = OUString(xImplKey->getKeyName().getStr() + 1); | |
| sal_Int32 firstDot = implName.indexOf('/'); | |
| if (firstDot >= 0) | |
| implName = implName.copy(firstDot + 1); | |
| sal_Int32 offset = xKey->getKeyName().getLength() + 1; | |
| for (sal_Int32 j = 0; j < serviceKeys.getLength(); j++) | |
| { | |
| OUString serviceName = pServiceKeys[j]->getKeyName().copy(offset); | |
| createUniqueSubEntry( | |
| xDest->getRootKey()->createKey( | |
| pool.slash_SERVICES + serviceName ), | |
| implName); | |
| } | |
| xKey = xImplKey->openKey( pool.slash_UNO ); | |
| if (xKey.is()) | |
| { | |
| Sequence< Reference < XRegistryKey > > subKeys2 = xKey->openKeys(); | |
| if (subKeys2.getLength()) | |
| { | |
| const Reference < XRegistryKey > * pSubKeys2 = subKeys2.getConstArray(); | |
| for (sal_Int32 j = 0; j < subKeys2.getLength(); j++) | |
| { | |
| if (pSubKeys2[j]->getKeyName() != (xImplKey->getKeyName() + pool.slash_UNO_slash_SERVICES) && | |
| pSubKeys2[j]->getKeyName() != (xImplKey->getKeyName() + pool.slash_UNO_slash_REGISTRY_LINKS ) && | |
| pSubKeys2[j]->getKeyName() != (xImplKey->getKeyName() + pool.slash_UNO_slash_SINGLETONS )) | |
| { | |
| prepareUserKeys(xDest, xKey, pSubKeys2[j], implName, sal_True); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| // update LOCATION entry | |
| xKey = xImplKey->createKey( pool.slash_UNO_slash_LOCATION ); | |
| if (xKey.is()) | |
| { | |
| xKey->setAsciiValue(locationUrl); | |
| } | |
| // update ACTIVATOR entry | |
| xKey = xImplKey->createKey( pool.slash_UNO_slash_ACTIVATOR ); | |
| if (xKey.is()) | |
| { | |
| xKey->setAsciiValue(implementationLoaderUrl); | |
| } | |
| xKey = xImplKey->openKey( pool.slash_UNO_slash_SERVICES ); | |
| if (xKey.is() && (xKey->getValueType() == RegistryValueType_ASCIILIST)) | |
| { | |
| // update link entries in REGISTRY_LINKS section | |
| Sequence<OUString> linkNames = xKey->getAsciiListValue(); | |
| if (linkNames.getLength()) | |
| { | |
| const OUString* pLinkNames = linkNames.getConstArray(); | |
| for (sal_Int32 j = 0; j < linkNames.getLength(); j++) | |
| { | |
| prepareLink(xDest, xImplKey, pLinkNames[j]); | |
| } | |
| } | |
| } | |
| insert_singletons( xDest, xImplKey, xContext ); | |
| } | |
| } | |
| static void findImplementations( const Reference < XRegistryKey > & xSource, | |
| std::list <OUString>& implNames) | |
| { | |
| sal_Bool isImplKey = sal_False; | |
| try | |
| { | |
| Reference < XRegistryKey > xKey = xSource->openKey( | |
| spool().slash_UNO_slash_SERVICES ); | |
| if (xKey.is() && (xKey->getKeyNames().getLength() > 0)) | |
| { | |
| isImplKey = sal_True; | |
| OUString implName = OUString(xSource->getKeyName().getStr() + 1).replace('/', '.').getStr(); | |
| sal_Int32 firstDot = implName.indexOf('.'); | |
| if (firstDot >= 0) | |
| implName = implName.copy(firstDot + 1); | |
| implNames.push_back(implName); | |
| } | |
| } | |
| catch(InvalidRegistryException&) | |
| { | |
| } | |
| if (isImplKey) return; | |
| try | |
| { | |
| Sequence< Reference < XRegistryKey > > subKeys = xSource->openKeys(); | |
| if (subKeys.getLength() > 0) | |
| { | |
| const Reference < XRegistryKey >* pSubKeys = subKeys.getConstArray(); | |
| for (sal_Int32 i = 0; i < subKeys.getLength(); i++) | |
| { | |
| findImplementations(pSubKeys[i], implNames); | |
| } | |
| } | |
| } | |
| catch(InvalidRegistryException&) | |
| { | |
| } | |
| } | |
| class ImplementationRegistration | |
| : public WeakImplHelper3< XImplementationRegistration2, XServiceInfo, XInitialization > | |
| { | |
| public: | |
| ImplementationRegistration( const Reference < XComponentContext > & rSMgr ); | |
| ~ImplementationRegistration(); | |
| // XServiceInfo | |
| OUString SAL_CALL getImplementationName(); | |
| sal_Bool SAL_CALL supportsService(const OUString& ServiceName); | |
| Sequence< OUString > SAL_CALL getSupportedServiceNames(void); | |
| // XImplementationRegistration | |
| virtual void SAL_CALL registerImplementation( | |
| const OUString& implementationLoader, | |
| const OUString& location, | |
| const Reference < XSimpleRegistry > & xReg); | |
| virtual sal_Bool SAL_CALL revokeImplementation( | |
| const OUString& location, | |
| const Reference < XSimpleRegistry >& xReg); | |
| virtual Sequence< OUString > SAL_CALL getImplementations( | |
| const OUString& implementationLoader, | |
| const OUString& location); | |
| virtual Sequence< OUString > SAL_CALL checkInstantiation( | |
| const OUString& implementationName); | |
| // XImplementationRegistration2 | |
| virtual void SAL_CALL registerImplementationWithLocation( | |
| const OUString& implementationLoader, | |
| const OUString& location, | |
| const OUString& registeredLocation, | |
| const Reference < XSimpleRegistry > & xReg); | |
| // XInitialization | |
| virtual void SAL_CALL initialize( | |
| const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any >& aArguments ); | |
| private: // helper methods | |
| void prepareRegister( | |
| const OUString& implementationLoader, | |
| const OUString& location, | |
| const OUString& registeredLocation, | |
| const Reference < XSimpleRegistry > & xReg); | |
| // throw( CannotRegisterImplementationException, RuntimeException ) | |
| static void doRegister( const Reference < XMultiComponentFactory >& xSMgr, | |
| const Reference < XComponentContext > &xCtx, | |
| const Reference < XImplementationLoader >& xAct, | |
| const Reference < XSimpleRegistry >& xDest, | |
| const OUString& implementationLoaderUrl, | |
| const OUString& locationUrl, | |
| const OUString& registeredLocationUrl); | |
| /* throw ( InvalidRegistryException, | |
| MergeConflictException, | |
| CannotRegisterImplementationException, RuntimeException ) */ | |
| static void doRevoke( const Reference < XSimpleRegistry >& xDest, | |
| const OUString& locationUrl ); | |
| // throw( InvalidRegistryException, RuntimeException ) | |
| Reference< XSimpleRegistry > getRegistryFromServiceManager(); | |
| static Reference< XSimpleRegistry > createTemporarySimpleRegistry( | |
| const Reference< XMultiComponentFactory > &rSMgr, | |
| const Reference < XComponentContext > & rCtx ); | |
| private: // members | |
| Reference < XMultiComponentFactory > m_xSMgr; | |
| Reference < XComponentContext > m_xCtx; | |
| }; | |
| //************************************************************************* | |
| // ImplementationRegistration() | |
| // | |
| ImplementationRegistration::ImplementationRegistration( const Reference < XComponentContext > & xCtx ) | |
| : m_xSMgr( xCtx->getServiceManager() ) | |
| , m_xCtx( xCtx ) | |
| { | |
| g_moduleCount.modCnt.acquire( &g_moduleCount.modCnt ); | |
| } | |
| //************************************************************************* | |
| // ~ImplementationRegistration() | |
| // | |
| ImplementationRegistration::~ImplementationRegistration() | |
| { | |
| g_moduleCount.modCnt.release( &g_moduleCount.modCnt ); | |
| } | |
| // XServiceInfo | |
| OUString ImplementationRegistration::getImplementationName() | |
| { | |
| return stoc_bootstrap::impreg_getImplementationName(); | |
| } | |
| // XServiceInfo | |
| sal_Bool ImplementationRegistration::supportsService(const OUString& ServiceName) | |
| { | |
| Sequence< OUString > aSNL = getSupportedServiceNames(); | |
| const OUString * pArray = aSNL.getConstArray(); | |
| for( sal_Int32 i = 0; i < aSNL.getLength(); i++ ) | |
| if( pArray[i] == ServiceName ) | |
| return sal_True; | |
| return sal_False; | |
| } | |
| // XServiceInfo | |
| Sequence< OUString > ImplementationRegistration::getSupportedServiceNames(void) | |
| { | |
| return stoc_bootstrap::impreg_getSupportedServiceNames(); | |
| } | |
| Reference< XSimpleRegistry > ImplementationRegistration::getRegistryFromServiceManager() | |
| { | |
| Reference < XPropertySet > xPropSet( m_xSMgr, UNO_QUERY ); | |
| Reference < XSimpleRegistry > xRegistry; | |
| if( xPropSet.is() ) { | |
| try { // the implementation does not support XIntrospectionAccess ! | |
| Any aAny = xPropSet->getPropertyValue( spool().Registry ); | |
| if( aAny.getValueType().getTypeClass() == TypeClass_INTERFACE ) { | |
| aAny >>= xRegistry; | |
| } | |
| } | |
| catch( UnknownPropertyException & ) { | |
| // empty reference is error signal ! | |
| } | |
| } | |
| return xRegistry; | |
| } | |
| //************************************************************************ | |
| // XInitialization | |
| // | |
| void ImplementationRegistration::initialize( | |
| const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any >& aArgs ) | |
| { | |
| if( aArgs.getLength() != 4 ) { | |
| OUStringBuffer buf; | |
| buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( | |
| "ImplementationRegistration::initialize() expects 4 parameters, got ")); | |
| buf.append( (sal_Int32) aArgs.getLength() ); | |
| throw IllegalArgumentException( buf.makeStringAndClear(), | |
| Reference<XInterface > (), | |
| 0 ); | |
| } | |
| Reference< XImplementationLoader > rLoader; | |
| OUString loaderServiceName; | |
| OUString locationUrl; | |
| Reference< XSimpleRegistry > rReg; | |
| // 1st argument : An instance of an implementation loader | |
| if( aArgs.getConstArray()[0].getValueType().getTypeClass() == TypeClass_INTERFACE ) { | |
| aArgs.getConstArray()[0] >>= rLoader; | |
| } | |
| if( !rLoader.is()) { | |
| OUStringBuffer buf; | |
| buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( | |
| "ImplementationRegistration::initialize() invalid first parameter," | |
| "expected " ) ); | |
| buf.append( getCppuType( &rLoader ).getTypeName() ); | |
| buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( ", got " ) ); | |
| buf.append( aArgs.getConstArray()[0].getValueTypeName() ); | |
| throw IllegalArgumentException( buf.makeStringAndClear(), | |
| Reference< XInterface > (), | |
| 0 ); | |
| } | |
| // 2nd argument : The service name of the loader. This name is written into the registry | |
| if( aArgs.getConstArray()[1].getValueType().getTypeClass() == TypeClass_STRING ) { | |
| aArgs.getConstArray()[1] >>= loaderServiceName; | |
| } | |
| if( ! loaderServiceName.getLength() ) { | |
| OUStringBuffer buf; | |
| buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( | |
| "ImplementationRegistration::initialize() invalid second parameter," | |
| "expected string, got " ) ); | |
| buf.append( aArgs.getConstArray()[1].getValueTypeName() ); | |
| throw IllegalArgumentException( buf.makeStringAndClear(), | |
| Reference< XInterface > (), | |
| 0 ); | |
| } | |
| // 3rd argument : The file name of the dll, that contains the loader | |
| if( aArgs.getConstArray()[2].getValueType().getTypeClass() == TypeClass_STRING ) { | |
| aArgs.getConstArray()[2] >>= locationUrl; | |
| } | |
| if( ! locationUrl.getLength() ) { | |
| OUStringBuffer buf; | |
| buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( | |
| "ImplementationRegistration::initialize() invalid third parameter," | |
| "expected string, got " ) ); | |
| buf.append( aArgs.getConstArray()[2].getValueTypeName() ); | |
| throw IllegalArgumentException( buf.makeStringAndClear(), | |
| Reference< XInterface > (), | |
| 0 ); | |
| } | |
| // 4th argument : The registry, the service should be written to | |
| if( aArgs.getConstArray()[3].getValueType().getTypeClass() == TypeClass_INTERFACE ) { | |
| aArgs.getConstArray()[3] >>= rReg; | |
| } | |
| if( !rReg.is() ) { | |
| rReg = getRegistryFromServiceManager(); | |
| if( !rReg.is() ) { | |
| OUStringBuffer buf; | |
| buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( | |
| "ImplementationRegistration::initialize() invalid fourth parameter," | |
| "expected " )); | |
| buf.append( getCppuType( &rReg ).getTypeName() ); | |
| buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(", got " ) ); | |
| buf.append( aArgs.getConstArray()[3].getValueTypeName() ); | |
| throw IllegalArgumentException( buf.makeStringAndClear(), | |
| Reference< XInterface > (), | |
| 0 ); | |
| } | |
| } | |
| doRegister(m_xSMgr, m_xCtx, rLoader , rReg, loaderServiceName , locationUrl, locationUrl); | |
| } | |
| //************************************************************************* | |
| // virtual function registerImplementationWithLocation of XImplementationRegistration2 | |
| // | |
| void ImplementationRegistration::registerImplementationWithLocation( | |
| const OUString& implementationLoaderUrl, | |
| const OUString& locationUrl, | |
| const OUString& registeredLocationUrl, | |
| const Reference < XSimpleRegistry > & xReg) | |
| { | |
| prepareRegister( | |
| implementationLoaderUrl, locationUrl, registeredLocationUrl, xReg); | |
| } | |
| // helper function | |
| void ImplementationRegistration::prepareRegister( | |
| const OUString& implementationLoaderUrl, | |
| const OUString& locationUrl, | |
| const OUString& registeredLocationUrl, | |
| const Reference < XSimpleRegistry > & xReg) | |
| // throw( CannotRegisterImplementationException, RuntimeException ) | |
| { | |
| OUString implLoaderUrl(implementationLoaderUrl); | |
| OUString activatorName; | |
| if (implementationLoaderUrl.getLength() > 0) | |
| { | |
| OUString tmpActivator(implementationLoaderUrl); | |
| sal_Int32 nIndex = 0; | |
| activatorName = tmpActivator.getToken(0, ':', nIndex ); | |
| } else | |
| { | |
| // check locationUrl to find out what kind of loader is needed | |
| // set iimplLoaderUrl | |
| } | |
| if( m_xSMgr.is() ) { | |
| try | |
| { | |
| Reference < XImplementationLoader > xAct( | |
| m_xSMgr->createInstanceWithContext(activatorName, m_xCtx) , UNO_QUERY ); | |
| if (xAct.is()) | |
| { | |
| Reference < XSimpleRegistry > xRegistry; | |
| if (xReg.is()) | |
| { | |
| // registry supplied by user | |
| xRegistry = xReg; | |
| } | |
| else | |
| { | |
| xRegistry = getRegistryFromServiceManager(); | |
| } | |
| if ( xRegistry.is()) | |
| { | |
| doRegister(m_xSMgr, m_xCtx, xAct, xRegistry, implLoaderUrl, | |
| locationUrl, registeredLocationUrl); | |
| } | |
| } | |
| else | |
| { | |
| OUStringBuffer buf( 128 ); | |
| buf.appendAscii( "ImplementationRegistration::registerImplementation() - The service " ); | |
| buf.append( activatorName ); | |
| buf.appendAscii( " cannot be instantiated\n" ); | |
| throw CannotRegisterImplementationException( | |
| buf.makeStringAndClear(), Reference< XInterface > () ); | |
| } | |
| } | |
| catch( CannotRegisterImplementationException & ) | |
| { | |
| throw; | |
| } | |
| catch( InvalidRegistryException & e ) | |
| { | |
| OUStringBuffer buf; | |
| buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( | |
| "ImplementationRegistration::registerImplementation() " | |
| "InvalidRegistryException during registration (" )); | |
| buf.append( e.Message ); | |
| buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( ")" ) ); | |
| throw CannotRegisterImplementationException( | |
| buf.makeStringAndClear(), Reference< XInterface > () ); | |
| } | |
| catch( MergeConflictException & e ) | |
| { | |
| OUStringBuffer buf; | |
| buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( | |
| "ImplementationRegistration::registerImplementation() " | |
| "MergeConflictException during registration (" )); | |
| buf.append( e.Message ); | |
| buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( ")" ) ); | |
| throw CannotRegisterImplementationException( | |
| buf.makeStringAndClear(), Reference< XInterface > () ); | |
| } | |
| } | |
| else | |
| { | |
| throw CannotRegisterImplementationException( | |
| OUString(RTL_CONSTASCII_USTRINGPARAM( | |
| "ImplementationRegistration::registerImplementation() " | |
| "no componentcontext available to instantiate loader")), | |
| Reference< XInterface > () ); | |
| } | |
| } | |
| //************************************************************************* | |
| // virtual function registerImplementation of XImplementationRegistration | |
| // | |
| void ImplementationRegistration::registerImplementation( | |
| const OUString& implementationLoaderUrl, | |
| const OUString& locationUrl, | |
| const Reference < XSimpleRegistry > & xReg) | |
| { | |
| prepareRegister(implementationLoaderUrl, locationUrl, locationUrl, xReg); | |
| } | |
| //************************************************************************* | |
| // virtual function revokeImplementation of XImplementationRegistration | |
| // | |
| sal_Bool ImplementationRegistration::revokeImplementation(const OUString& location, | |
| const Reference < XSimpleRegistry >& xReg) | |
| { | |
| sal_Bool ret = sal_False; | |
| Reference < XSimpleRegistry > xRegistry; | |
| if (xReg.is()) { | |
| xRegistry = xReg; | |
| } | |
| else { | |
| Reference < XPropertySet > xPropSet = Reference< XPropertySet >::query( m_xSMgr ); | |
| if( xPropSet.is() ) { | |
| try { | |
| Any aAny = xPropSet->getPropertyValue( spool().Registry ); | |
| if( aAny.getValueType().getTypeClass() == TypeClass_INTERFACE ) | |
| { | |
| aAny >>= xRegistry; | |
| } | |
| } | |
| catch ( UnknownPropertyException & ) { | |
| } | |
| } | |
| } | |
| if (xRegistry.is()) | |
| { | |
| try | |
| { | |
| doRevoke(xRegistry, location); | |
| ret = sal_True; | |
| } | |
| catch( InvalidRegistryException & ) | |
| { | |
| // no way to transport the error, as no exception is specified and a runtime | |
| // exception is not appropriate. | |
| OSL_ENSURE( 0 , "InvalidRegistryException during revokeImplementation" ); | |
| } | |
| } | |
| return ret; | |
| } | |
| //************************************************************************* | |
| // virtual function getImplementations of XImplementationRegistration | |
| // | |
| Sequence< OUString > ImplementationRegistration::getImplementations( | |
| const OUString & implementationLoaderUrl, | |
| const OUString & locationUrl) | |
| { | |
| OUString implLoaderUrl(implementationLoaderUrl); | |
| OUString activatorName; | |
| if (implementationLoaderUrl.getLength() > 0) | |
| { | |
| OUString tmpActivator(implementationLoaderUrl); | |
| sal_Int32 nIndex = 0; | |
| activatorName = tmpActivator.getToken(0, ':', nIndex ); | |
| } else | |
| { | |
| // check locationUrl to find out what kind of loader is needed | |
| // set implLoaderUrl | |
| } | |
| if( m_xSMgr.is() ) { | |
| Reference < XImplementationLoader > xAct( | |
| m_xSMgr->createInstanceWithContext( activatorName, m_xCtx ), UNO_QUERY ); | |
| if (xAct.is()) | |
| { | |
| Reference < XSimpleRegistry > xReg = | |
| createTemporarySimpleRegistry( m_xSMgr, m_xCtx); | |
| if (xReg.is()) | |
| { | |
| try | |
| { | |
| xReg->open(OUString() /* in mem */, sal_False, sal_True); | |
| Reference < XRegistryKey > xImpl; | |
| { // only necessary for deleting the temporary variable of rootkey | |
| xImpl = xReg->getRootKey()->createKey( spool().slash_IMPLEMENTATIONS ); | |
| } | |
| if (xAct->writeRegistryInfo(xImpl, implementationLoaderUrl, locationUrl)) | |
| { | |
| std::list <OUString> implNames; | |
| findImplementations(xImpl, implNames); | |
| if (!implNames.empty()) | |
| { | |
| std::list<OUString>::const_iterator iter = implNames.begin(); | |
| Sequence<OUString> seqImpl(implNames.size()); | |
| OUString *pImplNames = seqImpl.getArray(); | |
| sal_Int32 index = 0; | |
| while (iter != implNames.end()) | |
| { | |
| pImplNames[index] = *iter; | |
| index++; | |
| ++iter; | |
| } | |
| xImpl->closeKey(); | |
| return seqImpl; | |
| } | |
| } | |
| xImpl->closeKey(); | |
| } | |
| catch(MergeConflictException&) | |
| { | |
| } | |
| catch(InvalidRegistryException&) | |
| { | |
| } | |
| } | |
| } | |
| } | |
| return Sequence<OUString>(); | |
| } | |
| //************************************************************************* | |
| // virtual function checkInstantiation of XImplementationRegistration | |
| // | |
| Sequence< OUString > ImplementationRegistration::checkInstantiation(const OUString&) | |
| { | |
| OSL_ENSURE( sal_False, "ImplementationRegistration::checkInstantiation not implemented" ); | |
| return Sequence<OUString>(); | |
| } | |
| //************************************************************************* | |
| // helper function doRegistration | |
| // | |
| void ImplementationRegistration::doRevoke( | |
| const Reference < XSimpleRegistry >& xDest, | |
| const OUString& locationUrl) | |
| // throw ( InvalidRegistryException, RuntimeException ) | |
| { | |
| if( xDest.is() ) | |
| { | |
| std::list<OUString> aNames; | |
| const StringPool &pool = spool(); | |
| Reference < XRegistryKey > xRootKey( xDest->getRootKey() ); | |
| Reference < XRegistryKey > xKey = | |
| xRootKey->openKey( pool.slash_IMPLEMENTATIONS ); | |
| if (xKey.is() && xKey->isValid()) | |
| { | |
| deleteAllImplementations(xDest, xKey, locationUrl, aNames); | |
| } | |
| xKey = xRootKey->openKey( pool.slash_SERVICES ); | |
| if (xKey.is()) | |
| { | |
| std::list<OUString>::const_iterator iter = aNames.begin(); | |
| while (iter != aNames.end()) | |
| { | |
| deleteAllServiceEntries(xDest, xKey, *iter); | |
| ++iter; | |
| } | |
| } | |
| xKey = xRootKey->openKey( OUSTR("/SINGLETONS") ); | |
| if (xKey.is() && xKey->isValid()) | |
| { | |
| delete_all_singleton_entries( xKey, aNames ); | |
| } | |
| if (xRootKey.is()) | |
| xRootKey->closeKey(); | |
| if (xKey.is() && xKey->isValid() ) | |
| xKey->closeKey(); | |
| } | |
| } | |
| void ImplementationRegistration::doRegister( | |
| const Reference< XMultiComponentFactory > & xSMgr, | |
| const Reference< XComponentContext > &xCtx, | |
| const Reference < XImplementationLoader > & xAct, | |
| const Reference < XSimpleRegistry >& xDest, | |
| const OUString& implementationLoaderUrl, | |
| const OUString& locationUrl, | |
| const OUString& registeredLocationUrl) | |
| /* throw ( InvalidRegistryException, | |
| MergeConflictException, | |
| CannotRegisterImplementationException, RuntimeException ) */ | |
| { | |
| Reference < XSimpleRegistry > xReg = | |
| createTemporarySimpleRegistry( xSMgr, xCtx ); | |
| Reference < XRegistryKey > xSourceKey; | |
| if (xAct.is() && xReg.is() && xDest.is()) | |
| { | |
| try | |
| { | |
| xReg->open(OUString() /* in mem */, sal_False, sal_True); | |
| { // only necessary for deleting the temporary variable of rootkey | |
| xSourceKey = xReg->getRootKey()->createKey( spool().slash_IMPLEMENTATIONS ); | |
| } | |
| sal_Bool bSuccess = | |
| xAct->writeRegistryInfo(xSourceKey, implementationLoaderUrl, locationUrl); | |
| if ( bSuccess ) | |
| { | |
| prepareRegistry(xDest, xSourceKey, implementationLoaderUrl, registeredLocationUrl, xCtx); | |
| xSourceKey->closeKey(); | |
| xSourceKey = xReg->getRootKey(); | |
| Reference < XRegistryKey > xDestKey = xDest->getRootKey(); | |
| mergeKeys( xDestKey, xSourceKey ); | |
| xDestKey->closeKey(); | |
| xSourceKey->closeKey(); | |
| } | |
| else | |
| { | |
| throw CannotRegisterImplementationException( | |
| OUString( RTL_CONSTASCII_USTRINGPARAM( "ImplementationRegistration::doRegistration() component registration signaled failure" ) ), | |
| Reference< XInterface > () ); | |
| } | |
| // Cleanup Source registry. | |
| if ( xSourceKey->isValid() ) | |
| xSourceKey->closeKey(); | |
| } | |
| catch(CannotRegisterImplementationException&) | |
| { | |
| if ( xSourceKey->isValid() ) | |
| xSourceKey->closeKey(); | |
| // and throw again | |
| throw; | |
| } | |
| } | |
| } | |
| Reference< XSimpleRegistry > ImplementationRegistration::createTemporarySimpleRegistry( | |
| const Reference< XMultiComponentFactory > &rSMgr, | |
| const Reference < XComponentContext > & xCtx) | |
| { | |
| Reference < XSimpleRegistry > xReg( | |
| rSMgr->createInstanceWithContext( | |
| spool().com_sun_star_registry_SimpleRegistry, xCtx ), | |
| UNO_QUERY); | |
| OSL_ASSERT( xReg.is() ); | |
| return xReg; | |
| } | |
| } | |
| namespace stoc_bootstrap | |
| { | |
| //************************************************************************* | |
| Reference<XInterface> SAL_CALL ImplementationRegistration_CreateInstance( | |
| const Reference<XComponentContext> & xCtx ) // throw(Exception) | |
| { | |
| return (XImplementationRegistration *)new stoc_impreg::ImplementationRegistration(xCtx); | |
| } | |
| } |