| /************************************************************** | |
| * | |
| * 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. | |
| * | |
| *************************************************************/ | |
| #include <stdio.h> | |
| #include <vector> | |
| #include "sal/main.h" | |
| #include <osl/diagnose.h> | |
| #include <osl/mutex.hxx> | |
| #include <osl/conditn.hxx> | |
| #include <osl/module.h> | |
| #include <rtl/process.h> | |
| #include <rtl/string.h> | |
| #include <rtl/strbuf.hxx> | |
| #include <rtl/ustrbuf.hxx> | |
| #include <uno/environment.h> | |
| #include <uno/mapping.hxx> | |
| #include <cppuhelper/factory.hxx> | |
| #include <cppuhelper/bootstrap.hxx> | |
| #include <cppuhelper/servicefactory.hxx> | |
| #include <cppuhelper/shlib.hxx> | |
| #include <cppuhelper/implbase1.hxx> | |
| #include <com/sun/star/lang/XMain.hpp> | |
| #include <com/sun/star/lang/XInitialization.hpp> | |
| #include <com/sun/star/lang/XComponent.hpp> | |
| #include <com/sun/star/lang/XSingleServiceFactory.hpp> | |
| #include <com/sun/star/lang/XMultiServiceFactory.hpp> | |
| #include <com/sun/star/lang/XEventListener.hpp> | |
| #include <com/sun/star/container/XSet.hpp> | |
| #include <com/sun/star/loader/XImplementationLoader.hpp> | |
| #include <com/sun/star/registry/XSimpleRegistry.hpp> | |
| #include <com/sun/star/registry/XRegistryKey.hpp> | |
| #include <com/sun/star/connection/XAcceptor.hpp> | |
| #include <com/sun/star/connection/XConnection.hpp> | |
| #include <com/sun/star/bridge/XBridgeFactory.hpp> | |
| #include <com/sun/star/bridge/XBridge.hpp> | |
| #include <osl/process.h> | |
| #include <osl/thread.h> | |
| #include <osl/file.hxx> | |
| #ifdef SAL_UNX | |
| #define SEPARATOR '/' | |
| #else | |
| #define SEPARATOR '\\' | |
| #endif | |
| using namespace std; | |
| using namespace rtl; | |
| using namespace osl; | |
| using namespace cppu; | |
| using namespace com::sun::star::uno; | |
| using namespace com::sun::star::lang; | |
| using namespace com::sun::star::loader; | |
| using namespace com::sun::star::registry; | |
| using namespace com::sun::star::connection; | |
| using namespace com::sun::star::bridge; | |
| using namespace com::sun::star::container; | |
| namespace unoexe | |
| { | |
| static sal_Bool isFileUrl(const OUString& fileName) | |
| { | |
| if (fileName.indexOf(OUString::createFromAscii("file://")) == 0 ) | |
| return sal_True; | |
| return sal_False; | |
| } | |
| static OUString convertToFileUrl(const OUString& fileName) | |
| { | |
| if ( isFileUrl(fileName) ) | |
| { | |
| return fileName; | |
| } | |
| OUString uUrlFileName; | |
| if ( fileName.indexOf('.') == 0 || fileName.indexOf(SEPARATOR) < 0 ) | |
| { | |
| OUString uWorkingDir; | |
| if (osl_getProcessWorkingDir(&uWorkingDir.pData) != osl_Process_E_None) { | |
| OSL_ASSERT(false); | |
| } | |
| if (FileBase::getAbsoluteFileURL(uWorkingDir, fileName, uUrlFileName) | |
| != FileBase::E_None) | |
| { | |
| OSL_ASSERT(false); | |
| } | |
| } else | |
| { | |
| if (FileBase::getFileURLFromSystemPath(fileName, uUrlFileName) | |
| != FileBase::E_None) | |
| { | |
| OSL_ASSERT(false); | |
| } | |
| } | |
| return uUrlFileName; | |
| } | |
| static sal_Bool s_quiet = false; | |
| //-------------------------------------------------------------------------------------------------- | |
| static inline void out( const sal_Char * pText ) | |
| { | |
| if (! s_quiet) | |
| fprintf( stderr, "%s", pText ); | |
| } | |
| //-------------------------------------------------------------------------------------------------- | |
| static inline void out( const OUString & rText ) | |
| { | |
| if (! s_quiet) | |
| { | |
| OString aText( OUStringToOString( rText, RTL_TEXTENCODING_ASCII_US ) ); | |
| fprintf( stderr, "%s", aText.getStr() ); | |
| } | |
| } | |
| //-------------------------------------------------------------------------------------------------- | |
| static const char arUsingText[] = | |
| "\nusing:\n\n" | |
| "uno [-c ComponentImplementationName -l LocationUrl | -s ServiceName]\n" | |
| " [-ro ReadOnlyRegistry1] [-ro ReadOnlyRegistry2] ... [-rw ReadWriteRegistry]\n" | |
| " [-u uno:(socket[,host=HostName][,port=nnn]|pipe[,name=PipeName]);<protocol>;Name\n" | |
| " [--singleaccept] [--singleinstance]]\n" | |
| " [--quiet]\n" | |
| " [-- Argument1 Argument2 ...]\n"; | |
| //-------------------------------------------------------------------------------------------------- | |
| static sal_Bool readOption( OUString * pValue, const sal_Char * pOpt, | |
| sal_Int32 * pnIndex, const OUString & aArg) | |
| { | |
| const OUString dash = OUString(RTL_CONSTASCII_USTRINGPARAM("-")); | |
| if(aArg.indexOf(dash) != 0) | |
| return sal_False; | |
| OUString aOpt = OUString::createFromAscii( pOpt ); | |
| if (aArg.getLength() < aOpt.getLength()) | |
| return sal_False; | |
| if (aOpt.equalsIgnoreAsciiCase( aArg.copy(1) )) | |
| { | |
| // take next argument | |
| ++(*pnIndex); | |
| rtl_getAppCommandArg(*pnIndex, &pValue->pData); | |
| if (*pnIndex >= (sal_Int32)rtl_getAppCommandArgCount() || pValue->copy(1).equals(dash)) | |
| { | |
| OUStringBuffer buf( 32 ); | |
| buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("incomplete option \"-") ); | |
| buf.appendAscii( pOpt ); | |
| buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("\" given!") ); | |
| throw RuntimeException( buf.makeStringAndClear(), Reference< XInterface >() ); | |
| } | |
| else | |
| { | |
| #if OSL_DEBUG_LEVEL > 1 | |
| out( "\n> identified option -" ); | |
| out( pOpt ); | |
| out( " = " ); | |
| OString tmp = OUStringToOString(aArg, RTL_TEXTENCODING_ASCII_US); | |
| out( tmp.getStr() ); | |
| #endif | |
| ++(*pnIndex); | |
| return sal_True; | |
| } | |
| } | |
| else if (aArg.indexOf(aOpt) == 1) | |
| { | |
| *pValue = aArg.copy(1 + aOpt.getLength()); | |
| #if OSL_DEBUG_LEVEL > 1 | |
| out( "\n> identified option -" ); | |
| out( pOpt ); | |
| out( " = " ); | |
| OString tmp = OUStringToOString(aArg.copy(aOpt.getLength()), RTL_TEXTENCODING_ASCII_US); | |
| out( tmp.getStr() ); | |
| #endif | |
| ++(*pnIndex); | |
| return sal_True; | |
| } | |
| return sal_False; | |
| } | |
| //-------------------------------------------------------------------------------------------------- | |
| static sal_Bool readOption( sal_Bool * pbOpt, const sal_Char * pOpt, | |
| sal_Int32 * pnIndex, const OUString & aArg) | |
| { | |
| const OUString dashdash(RTL_CONSTASCII_USTRINGPARAM("--")); | |
| OUString aOpt = OUString::createFromAscii(pOpt); | |
| if(aArg.indexOf(dashdash) == 0 && aOpt.equals(aArg.copy(2))) | |
| { | |
| ++(*pnIndex); | |
| *pbOpt = sal_True; | |
| #if OSL_DEBUG_LEVEL > 1 | |
| out( "\n> identified option --" ); | |
| out( pOpt ); | |
| #endif | |
| return sal_True; | |
| } | |
| return sal_False; | |
| } | |
| //################################################################################################## | |
| //################################################################################################## | |
| //################################################################################################## | |
| //-------------------------------------------------------------------------------------------------- | |
| template< class T > | |
| void createInstance( | |
| Reference< T > & rxOut, | |
| const Reference< XComponentContext > & xContext, | |
| const OUString & rServiceName ) | |
| { | |
| Reference< XMultiComponentFactory > xMgr( xContext->getServiceManager() ); | |
| Reference< XInterface > x( xMgr->createInstanceWithContext( rServiceName, xContext ) ); | |
| if (! x.is()) | |
| { | |
| static sal_Bool s_bSet = sal_False; | |
| if (! s_bSet) | |
| { | |
| MutexGuard aGuard( Mutex::getGlobalMutex() ); | |
| if (! s_bSet) | |
| { | |
| Reference< XSet > xSet( xMgr, UNO_QUERY ); | |
| if (xSet.is()) | |
| { | |
| Reference< XMultiServiceFactory > xSF( xMgr, UNO_QUERY ); | |
| // acceptor | |
| xSet->insert( makeAny( loadSharedLibComponentFactory( | |
| OUString( RTL_CONSTASCII_USTRINGPARAM( | |
| "acceptor.uno" SAL_DLLEXTENSION) ), | |
| OUString(), | |
| OUString( RTL_CONSTASCII_USTRINGPARAM( | |
| "com.sun.star.comp.io.Acceptor") ), | |
| xSF, Reference< XRegistryKey >() ) ) ); | |
| // connector | |
| xSet->insert( makeAny( loadSharedLibComponentFactory( | |
| OUString( RTL_CONSTASCII_USTRINGPARAM( | |
| "connector.uno" SAL_DLLEXTENSION) ), | |
| OUString(), | |
| OUString( RTL_CONSTASCII_USTRINGPARAM( | |
| "com.sun.star.comp.io.Connector") ), | |
| xSF, Reference< XRegistryKey >() ) ) ); | |
| // bridge factory | |
| xSet->insert( makeAny( loadSharedLibComponentFactory( | |
| OUString( RTL_CONSTASCII_USTRINGPARAM( | |
| "binaryurp.uno" SAL_DLLEXTENSION) ), | |
| OUString(), | |
| OUString( | |
| RTL_CONSTASCII_USTRINGPARAM( | |
| "com.sun.star.comp.bridge.BridgeFactory") ), | |
| xSF, Reference< XRegistryKey >() ) ) ); | |
| } | |
| s_bSet = sal_True; | |
| } | |
| } | |
| x = xMgr->createInstanceWithContext( rServiceName, xContext ); | |
| } | |
| if (! x.is()) | |
| { | |
| OUStringBuffer buf( 64 ); | |
| buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("cannot get service instance \"") ); | |
| buf.append( rServiceName ); | |
| buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("\"!") ); | |
| throw RuntimeException( buf.makeStringAndClear(), Reference< XInterface >() ); | |
| } | |
| rxOut = Reference< T >::query( x ); | |
| if (! rxOut.is()) | |
| { | |
| OUStringBuffer buf( 64 ); | |
| buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("service instance \"") ); | |
| buf.append( rServiceName ); | |
| buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("\" does not support demanded interface \"") ); | |
| const Type & rType = ::getCppuType( (const Reference< T > *)0 ); | |
| buf.append( rType.getTypeName() ); | |
| buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("\"!") ); | |
| throw RuntimeException( buf.makeStringAndClear(), Reference< XInterface >() ); | |
| } | |
| } | |
| //-------------------------------------------------------------------------------------------------- | |
| static Reference< XSimpleRegistry > nestRegistries( | |
| const Reference< XSimpleRegistry > & xReadWrite, | |
| const Reference< XSimpleRegistry > & xReadOnly ) | |
| { | |
| Reference< XSimpleRegistry > xReg( createNestedRegistry() ); | |
| if (! xReg.is()) | |
| { | |
| throw RuntimeException( | |
| OUString( RTL_CONSTASCII_USTRINGPARAM("no nested registry service!" ) ), | |
| Reference< XInterface >() ); | |
| } | |
| Reference< XInitialization > xInit( xReg, UNO_QUERY ); | |
| if (! xInit.is()) | |
| throw RuntimeException( OUString( RTL_CONSTASCII_USTRINGPARAM("nested registry does not export interface \"com.sun.star.lang.XInitialization\"!" ) ), Reference< XInterface >() ); | |
| Sequence< Any > aArgs( 2 ); | |
| aArgs[0] <<= xReadWrite; | |
| aArgs[1] <<= xReadOnly; | |
| xInit->initialize( aArgs ); | |
| return xReg; | |
| } | |
| //-------------------------------------------------------------------------------------------------- | |
| static Reference< XSimpleRegistry > openRegistry( | |
| const OUString & rURL, | |
| sal_Bool bReadOnly, sal_Bool bCreate ) | |
| { | |
| Reference< XSimpleRegistry > xNewReg( createSimpleRegistry() ); | |
| if (! xNewReg.is()) | |
| { | |
| throw RuntimeException( | |
| OUString( RTL_CONSTASCII_USTRINGPARAM("no simple registry service!" ) ), | |
| Reference< XInterface >() ); | |
| } | |
| try | |
| { | |
| xNewReg->open( convertToFileUrl(rURL), bReadOnly, bCreate ); | |
| if (xNewReg->isValid()) | |
| return xNewReg; | |
| else | |
| xNewReg->close(); | |
| } | |
| catch (Exception &) | |
| { | |
| } | |
| out( "\n> warning: cannot open registry \"" ); | |
| out( rURL ); | |
| if (bReadOnly) | |
| out( "\" for reading, ignoring!" ); | |
| else | |
| out( "\" for reading and writing, ignoring!" ); | |
| return Reference< XSimpleRegistry >(); | |
| } | |
| //-------------------------------------------------------------------------------------------------- | |
| static Reference< XInterface > loadComponent( | |
| const Reference< XComponentContext > & xContext, | |
| const OUString & rImplName, const OUString & rLocation ) | |
| { | |
| // determine loader to be used | |
| sal_Int32 nDot = rLocation.lastIndexOf( '.' ); | |
| if (nDot > 0 && nDot < rLocation.getLength()) | |
| { | |
| Reference< XImplementationLoader > xLoader; | |
| OUString aExt( rLocation.copy( nDot +1 ) ); | |
| if (aExt.compareToAscii( "dll" ) == 0 || | |
| aExt.compareToAscii( "exe" ) == 0 || | |
| aExt.compareToAscii( "dylib" ) == 0 || | |
| aExt.compareToAscii( "so" ) == 0) | |
| { | |
| createInstance( | |
| xLoader, xContext, OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.loader.SharedLibrary") ) ); | |
| } | |
| else if (aExt.compareToAscii( "jar" ) == 0 || | |
| aExt.compareToAscii( "class" ) == 0) | |
| { | |
| createInstance( | |
| xLoader, xContext, OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.loader.Java") ) ); | |
| } | |
| else | |
| { | |
| OUStringBuffer buf( 64 ); | |
| buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("unknown extension of \"") ); | |
| buf.append( rLocation ); | |
| buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("\"! No loader available!") ); | |
| throw RuntimeException( buf.makeStringAndClear(), Reference< XInterface >() ); | |
| } | |
| Reference< XInterface > xInstance; | |
| // activate | |
| Reference< XInterface > xFactory( xLoader->activate( | |
| rImplName, OUString(), rLocation, Reference< XRegistryKey >() ) ); | |
| if (xFactory.is()) | |
| { | |
| Reference< XSingleComponentFactory > xCFac( xFactory, UNO_QUERY ); | |
| if (xCFac.is()) | |
| { | |
| xInstance = xCFac->createInstanceWithContext( xContext ); | |
| } | |
| else | |
| { | |
| Reference< XSingleServiceFactory > xSFac( xFactory, UNO_QUERY ); | |
| if (xSFac.is()) | |
| { | |
| out( "\n> warning: ignoring context for implementation \"" ); | |
| out( rImplName ); | |
| out( "\"!" ); | |
| xInstance = xSFac->createInstance(); | |
| } | |
| } | |
| } | |
| if (! xInstance.is()) | |
| { | |
| OUStringBuffer buf( 64 ); | |
| buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("activating component \"") ); | |
| buf.append( rImplName ); | |
| buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("\" from location \"") ); | |
| buf.append( rLocation ); | |
| buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("\" failed!") ); | |
| throw RuntimeException( buf.makeStringAndClear(), Reference< XInterface >() ); | |
| } | |
| return xInstance; | |
| } | |
| else | |
| { | |
| OUStringBuffer buf( 64 ); | |
| buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("location \"") ); | |
| buf.append( rLocation ); | |
| buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("\" has no extension! Cannot determine loader to be used!") ); | |
| throw RuntimeException( buf.makeStringAndClear(), Reference< XInterface >() ); | |
| } | |
| } | |
| //################################################################################################## | |
| //################################################################################################## | |
| //################################################################################################## | |
| //================================================================================================== | |
| class OInstanceProvider | |
| : public WeakImplHelper1< XInstanceProvider > | |
| { | |
| Reference< XComponentContext > _xContext; | |
| Mutex _aSingleInstanceMutex; | |
| Reference< XInterface > _xSingleInstance; | |
| sal_Bool _bSingleInstance; | |
| OUString _aImplName; | |
| OUString _aLocation; | |
| OUString _aServiceName; | |
| Sequence< Any > _aInitParams; | |
| OUString _aInstanceName; | |
| inline Reference< XInterface > createInstance(); | |
| public: | |
| OInstanceProvider( const Reference< XComponentContext > & xContext, | |
| const OUString & rImplName, const OUString & rLocation, | |
| const OUString & rServiceName, const Sequence< Any > & rInitParams, | |
| sal_Bool bSingleInstance, const OUString & rInstanceName ) | |
| : _xContext( xContext ) | |
| , _bSingleInstance( bSingleInstance ) | |
| , _aImplName( rImplName ) | |
| , _aLocation( rLocation ) | |
| , _aServiceName( rServiceName ) | |
| , _aInitParams( rInitParams ) | |
| , _aInstanceName( rInstanceName ) | |
| {} | |
| // XInstanceProvider | |
| virtual Reference< XInterface > SAL_CALL getInstance( const OUString & rName ); | |
| }; | |
| //__________________________________________________________________________________________________ | |
| inline Reference< XInterface > OInstanceProvider::createInstance() | |
| { | |
| Reference< XInterface > xRet; | |
| if (_aImplName.getLength()) // manually via loader | |
| xRet = loadComponent( _xContext, _aImplName, _aLocation ); | |
| else // via service manager | |
| unoexe::createInstance( xRet, _xContext, _aServiceName ); | |
| // opt XInit | |
| Reference< XInitialization > xInit( xRet, UNO_QUERY ); | |
| if (xInit.is()) | |
| xInit->initialize( _aInitParams ); | |
| return xRet; | |
| } | |
| //__________________________________________________________________________________________________ | |
| Reference< XInterface > OInstanceProvider::getInstance( const OUString & rName ) | |
| { | |
| try | |
| { | |
| if (_aInstanceName == rName) | |
| { | |
| Reference< XInterface > xRet; | |
| if (_aImplName.getLength() == 0 && _aServiceName.getLength() == 0) | |
| { | |
| OSL_ASSERT( | |
| rName.equalsAsciiL( | |
| RTL_CONSTASCII_STRINGPARAM("uno.ComponentContext") ) ); | |
| xRet = _xContext; | |
| } | |
| else if (_bSingleInstance) | |
| { | |
| if (! _xSingleInstance.is()) | |
| { | |
| MutexGuard aGuard( _aSingleInstanceMutex ); | |
| if (! _xSingleInstance.is()) | |
| { | |
| _xSingleInstance = createInstance(); | |
| } | |
| } | |
| xRet = _xSingleInstance; | |
| } | |
| else | |
| { | |
| xRet = createInstance(); | |
| } | |
| return xRet; | |
| } | |
| } | |
| catch (Exception & rExc) | |
| { | |
| out( "\n> error: " ); | |
| out( rExc.Message ); | |
| } | |
| OUStringBuffer buf( 64 ); | |
| buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("no such element \"") ); | |
| buf.append( rName ); | |
| buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("\"!") ); | |
| throw NoSuchElementException( buf.makeStringAndClear(), Reference< XInterface >() ); | |
| } | |
| //================================================================================================== | |
| struct ODisposingListener : public WeakImplHelper1< XEventListener > | |
| { | |
| Condition cDisposed; | |
| // XEventListener | |
| virtual void SAL_CALL disposing( const EventObject & rEvt ); | |
| //---------------------------------------------------------------------------------------------- | |
| static void waitFor( const Reference< XComponent > & xComp ); | |
| }; | |
| //__________________________________________________________________________________________________ | |
| void ODisposingListener::disposing( const EventObject & ) | |
| { | |
| cDisposed.set(); | |
| } | |
| //-------------------------------------------------------------------------------------------------- | |
| void ODisposingListener::waitFor( const Reference< XComponent > & xComp ) | |
| { | |
| ODisposingListener * pListener = new ODisposingListener(); | |
| Reference< XEventListener > xListener( pListener ); | |
| xComp->addEventListener( xListener ); | |
| pListener->cDisposed.wait(); | |
| } | |
| //################################################################################################## | |
| //################################################################################################## | |
| //################################################################################################## | |
| //################################################################################################## | |
| } // namespace unoexe | |
| using namespace unoexe; | |
| SAL_IMPLEMENT_MAIN_WITH_ARGS(argc,) | |
| { | |
| if (argc <= 1) | |
| { | |
| out( arUsingText ); | |
| return 0; | |
| } | |
| sal_Int32 nRet = 0; | |
| Reference< XComponentContext > xContext; | |
| try | |
| { | |
| OUString aImplName, aLocation, aServiceName, aUnoUrl; | |
| vector< OUString > aReadOnlyRegistries; | |
| Sequence< OUString > aParams; | |
| sal_Bool bSingleAccept = sal_False; | |
| sal_Bool bSingleInstance = sal_False; | |
| //#### read command line arguments ######################################################### | |
| bool bOldRegistryMimic = false; | |
| bool bNewRegistryMimic = false; | |
| OUString aReadWriteRegistry; | |
| sal_Int32 nPos = 0; | |
| sal_Int32 nCount = (sal_Int32)rtl_getAppCommandArgCount(); | |
| // read up to arguments | |
| while (nPos < nCount) | |
| { | |
| OUString arg; | |
| rtl_getAppCommandArg(nPos, &arg.pData); | |
| const OUString dashdash = OUString(RTL_CONSTASCII_USTRINGPARAM("--")); | |
| if (dashdash == arg) | |
| { | |
| ++nPos; | |
| break; | |
| } | |
| if (readOption( &aImplName, "c", &nPos, arg) || | |
| readOption( &aLocation, "l", &nPos, arg) || | |
| readOption( &aServiceName, "s", &nPos, arg) || | |
| readOption( &aUnoUrl, "u", &nPos, arg) || | |
| readOption( &s_quiet, "quiet", &nPos, arg) || | |
| readOption( &bSingleAccept, "singleaccept", &nPos, arg) || | |
| readOption( &bSingleInstance, "singleinstance", &nPos, arg)) | |
| { | |
| continue; | |
| } | |
| OUString aRegistry; | |
| if (readOption( &aRegistry, "ro", &nPos, arg)) | |
| { | |
| aReadOnlyRegistries.push_back( aRegistry ); | |
| bNewRegistryMimic = true; | |
| continue; | |
| } | |
| if (readOption( &aReadWriteRegistry, "rw", &nPos, arg)) | |
| { | |
| bNewRegistryMimic = true; | |
| continue; | |
| } | |
| if (readOption( &aRegistry, "r", &nPos, arg)) | |
| { | |
| aReadOnlyRegistries.push_back( aRegistry ); | |
| aReadWriteRegistry = aRegistry; | |
| out( "\n> warning: DEPRECATED use of option -r, use -ro or -rw!" ); | |
| bOldRegistryMimic = true; | |
| continue; | |
| } | |
| // else illegal argument | |
| OUStringBuffer buf( 64 ); | |
| buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("unexpected parameter \"") ); | |
| buf.append(arg); | |
| buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("\"!") ); | |
| throw RuntimeException( buf.makeStringAndClear(), Reference< XInterface >() ); | |
| } | |
| if (bOldRegistryMimic) // last one was set to be read-write | |
| { | |
| aReadOnlyRegistries.pop_back(); | |
| if (bOldRegistryMimic && bNewRegistryMimic) | |
| { | |
| throw RuntimeException( | |
| OUString( RTL_CONSTASCII_USTRINGPARAM("mixing with DEPRECATED registry options!") ), | |
| Reference< XInterface >() ); | |
| } | |
| } | |
| if ((aImplName.getLength() != 0) && (aServiceName.getLength() != 0)) | |
| throw RuntimeException( OUString( RTL_CONSTASCII_USTRINGPARAM("give component exOR service name!" ) ), Reference< XInterface >() ); | |
| if (aImplName.getLength() == 0 && aServiceName.getLength() == 0) | |
| { | |
| if (! aUnoUrl.endsWithIgnoreAsciiCaseAsciiL( | |
| RTL_CONSTASCII_STRINGPARAM(";uno.ComponentContext") )) | |
| throw RuntimeException( | |
| OUString( RTL_CONSTASCII_USTRINGPARAM( | |
| "expected UNO-URL with instance name " | |
| "uno.ComponentContext!") ), | |
| Reference<XInterface>() ); | |
| if (bSingleInstance) | |
| throw RuntimeException( | |
| OUString( RTL_CONSTASCII_USTRINGPARAM( | |
| "unexpected option --singleinstance!") ), | |
| Reference<XInterface>() ); | |
| } | |
| if (aImplName.getLength() && !aLocation.getLength()) | |
| throw RuntimeException( OUString( RTL_CONSTASCII_USTRINGPARAM("give component location!" ) ), Reference< XInterface >() ); | |
| if (aServiceName.getLength() && aLocation.getLength()) | |
| out( "\n> warning: service name given, will ignore location!" ); | |
| // read component params | |
| aParams.realloc( nCount - nPos ); | |
| OUString * pParams = aParams.getArray(); | |
| sal_Int32 nOffset = nPos; | |
| for ( ; nPos < nCount; ++nPos ) | |
| { | |
| if (rtl_getAppCommandArg( nPos, &pParams[nPos -nOffset].pData ) | |
| != osl_Process_E_None) | |
| { | |
| OSL_ASSERT(false); | |
| } | |
| } | |
| if (aReadOnlyRegistries.size() > 0 || | |
| aReadWriteRegistry.getLength() > 0) | |
| { | |
| //#### create registry ############################################# | |
| Reference< XSimpleRegistry > xRegistry; | |
| // ReadOnly registries | |
| for ( size_t nReg = 0; nReg < aReadOnlyRegistries.size(); ++nReg ) | |
| { | |
| #if OSL_DEBUG_LEVEL > 1 | |
| out( "\n> trying to open ro registry: " ); | |
| out( OUStringToOString( | |
| aReadOnlyRegistries[ nReg ], | |
| RTL_TEXTENCODING_ASCII_US ).getStr() ); | |
| #endif | |
| Reference< XSimpleRegistry > xNewReg( | |
| openRegistry( | |
| aReadOnlyRegistries[ nReg ], sal_True, sal_False ) ); | |
| if (xNewReg.is()) | |
| xRegistry = (xRegistry.is() ? nestRegistries( | |
| xNewReg, xRegistry ) : xNewReg); | |
| } | |
| if (aReadWriteRegistry.getLength()) | |
| { | |
| #if OSL_DEBUG_LEVEL > 1 | |
| out( "\n> trying to open rw registry: " ); | |
| out( OUStringToOString( | |
| aReadWriteRegistry, | |
| RTL_TEXTENCODING_ASCII_US ).getStr() ); | |
| #endif | |
| // ReadWrite registry | |
| Reference< XSimpleRegistry > xNewReg( | |
| openRegistry( aReadWriteRegistry, sal_False, sal_True ) ); | |
| if (xNewReg.is()) | |
| xRegistry = (xRegistry.is() | |
| ? nestRegistries( xNewReg, xRegistry ) | |
| : xNewReg); | |
| } | |
| OSL_ASSERT( xRegistry.is() ); | |
| xContext = bootstrap_InitialComponentContext( xRegistry ); | |
| } | |
| else // defaulting | |
| { | |
| xContext = defaultBootstrap_InitialComponentContext(); | |
| } | |
| //#### accept, instantiate, etc. ########################################################### | |
| if (aUnoUrl.getLength()) // accepting connections | |
| { | |
| sal_Int32 nIndex = 0, nTokens = 0; | |
| do { aUnoUrl.getToken( 0, ';', nIndex ); nTokens++; } while( nIndex != -1 ); | |
| if (nTokens != 3 || aUnoUrl.getLength() < 10 || | |
| !aUnoUrl.copy( 0, 4 ).equalsIgnoreAsciiCase( OUString( RTL_CONSTASCII_USTRINGPARAM("uno:") ) )) | |
| { | |
| throw RuntimeException( OUString( RTL_CONSTASCII_USTRINGPARAM("illegal uno url given!" ) ), Reference< XInterface >() ); | |
| } | |
| nIndex = 0; | |
| OUString aConnectDescr( aUnoUrl.getToken( 0, ';', nIndex ).copy( 4 ) ); // uno:CONNECTDESCR;iiop;InstanceName | |
| OUString aInstanceName( aUnoUrl.getToken( 1, ';', nIndex ) ); | |
| Reference< XAcceptor > xAcceptor; | |
| createInstance( | |
| xAcceptor, xContext, | |
| OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.connection.Acceptor") ) ); | |
| // init params | |
| Sequence< Any > aInitParams( aParams.getLength() ); | |
| const OUString * p = aParams.getConstArray(); | |
| Any * pInitParams = aInitParams.getArray(); | |
| for ( sal_Int32 i = aParams.getLength(); i--; ) | |
| { | |
| pInitParams[i] = makeAny( p[i] ); | |
| } | |
| // instance provider | |
| Reference< XInstanceProvider > xInstanceProvider( new OInstanceProvider( | |
| xContext, aImplName, aLocation, aServiceName, aInitParams, | |
| bSingleInstance, aInstanceName ) ); | |
| nIndex = 0; | |
| OUString aUnoUrlToken( aUnoUrl.getToken( 1, ';', nIndex ) ); | |
| for (;;) | |
| { | |
| // accepting | |
| out( "\n> accepting " ); | |
| out( aConnectDescr ); | |
| out( "..." ); | |
| Reference< XConnection > xConnection( xAcceptor->accept( aConnectDescr ) ); | |
| out( "connection established." ); | |
| Reference< XBridgeFactory > xBridgeFactory; | |
| createInstance( | |
| xBridgeFactory, xContext, | |
| OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.bridge.BridgeFactory") ) ); | |
| // bridge | |
| Reference< XBridge > xBridge( xBridgeFactory->createBridge( | |
| OUString(), aUnoUrlToken, | |
| xConnection, xInstanceProvider ) ); | |
| if (bSingleAccept) | |
| { | |
| Reference< XComponent > xComp( xBridge, UNO_QUERY ); | |
| if (! xComp.is()) | |
| throw RuntimeException( OUString( RTL_CONSTASCII_USTRINGPARAM("bridge factory does not export interface \"com.sun.star.lang.XComponent\"!" ) ), Reference< XInterface >() ); | |
| ODisposingListener::waitFor( xComp ); | |
| break; | |
| } | |
| } | |
| } | |
| else // no uno url | |
| { | |
| Reference< XInterface > xInstance; | |
| if (aImplName.getLength()) // manually via loader | |
| xInstance = loadComponent( xContext, aImplName, aLocation ); | |
| else // via service manager | |
| createInstance( xInstance, xContext, aServiceName ); | |
| // execution | |
| Reference< XMain > xMain( xInstance, UNO_QUERY ); | |
| if (xMain.is()) | |
| { | |
| nRet = xMain->run( aParams ); | |
| } | |
| else | |
| { | |
| Reference< XComponent > xComp( xInstance, UNO_QUERY ); | |
| if (xComp.is()) | |
| xComp->dispose(); | |
| throw RuntimeException( OUString( RTL_CONSTASCII_USTRINGPARAM("component does not export interface interface \"com.sun.star.lang.XMain\"!" ) ), Reference< XInterface >() ); | |
| } | |
| } | |
| } | |
| catch (Exception & rExc) | |
| { | |
| out( "\n> error: " ); | |
| out( rExc.Message ); | |
| out( "\n> dying..." ); | |
| nRet = 1; | |
| } | |
| // cleanup | |
| Reference< XComponent > xComp( xContext, UNO_QUERY ); | |
| if (xComp.is()) | |
| xComp->dispose(); | |
| out( "\n" ); | |
| return nRet; | |
| } |