1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_desktop.hxx"
26
27 #include "acceptor.hxx"
28 #include <unotools/bootstrap.hxx>
29 #include <vos/process.hxx>
30 #include <tools/urlobj.hxx>
31 #include <tools/stream.hxx>
32 #include <vcl/svapp.hxx>
33 #include <com/sun/star/beans/XPropertySet.hpp>
34 #ifndef _COM_SUN_STAR_UNO_XNAMEINGSERVICE_HPP_
35 #include <com/sun/star/uno/XNamingService.hpp>
36 #endif
37
38 #include <cppuhelper/factory.hxx>
39
40 namespace desktop
41 {
42
workerfunc(void * acc)43 extern "C" void workerfunc (void * acc)
44 {
45 ((Acceptor*)acc)->run();
46 }
47
getComponentContext(const Reference<XMultiServiceFactory> & rFactory)48 static Reference<XInterface> getComponentContext( const Reference<XMultiServiceFactory>& rFactory)
49 {
50 Reference<XInterface> rContext;
51 Reference< XPropertySet > rPropSet( rFactory, UNO_QUERY );
52 Any a = rPropSet->getPropertyValue(
53 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "DefaultContext" ) ) );
54 a >>= rContext;
55 return rContext;
56 }
57
58 Mutex Acceptor::m_aMutex;
59
Acceptor(const Reference<XMultiServiceFactory> & rFactory)60 Acceptor::Acceptor( const Reference< XMultiServiceFactory >& rFactory )
61 : m_thread(NULL)
62 , m_aAcceptString()
63 , m_aConnectString()
64 , m_aProtocol()
65 , m_bInit(sal_False)
66 , m_bDying(false)
67 {
68 m_rSMgr = rFactory;
69 m_rAcceptor = Reference< XAcceptor > (m_rSMgr->createInstance(
70 rtl::OUString::createFromAscii( "com.sun.star.connection.Acceptor" )),
71 UNO_QUERY );
72 m_rBridgeFactory = Reference < XBridgeFactory > (m_rSMgr->createInstance(
73 rtl::OUString::createFromAscii( "com.sun.star.bridge.BridgeFactory" )),
74 UNO_QUERY );
75 // get component context
76 m_rContext = getComponentContext(m_rSMgr);
77 }
78
79
~Acceptor()80 Acceptor::~Acceptor()
81 {
82 m_rAcceptor->stopAccepting();
83 oslThread t;
84 {
85 osl::MutexGuard g(m_aMutex);
86 t = m_thread;
87 }
88 //prevent locking if the thread is still waiting
89 m_bDying = true;
90 m_cEnable.set();
91 osl_joinWithThread(t);
92 // osl_destroyThread(t);
93 {
94 // Make the final state of m_bridges visible to this thread (since
95 // m_thread is joined, the code that follows is the only one left
96 // accessing m_bridges):
97 osl::MutexGuard g(m_aMutex);
98 }
99 for (;;) {
100 com::sun::star::uno::Reference< com::sun::star::bridge::XBridge > b(
101 m_bridges.remove());
102 if (!b.is()) {
103 break;
104 }
105 com::sun::star::uno::Reference< com::sun::star::lang::XComponent >(
106 b, com::sun::star::uno::UNO_QUERY_THROW)->dispose();
107 }
108 }
109
run()110 void SAL_CALL Acceptor::run()
111 {
112 while ( m_rAcceptor.is() && m_rBridgeFactory.is() )
113 {
114 RTL_LOGFILE_CONTEXT( aLog, "desktop (lo119109) Acceptor::run" );
115 try
116 {
117 // wait until we get enabled
118 RTL_LOGFILE_CONTEXT_TRACE( aLog, "desktop (lo119109)"\
119 "Acceptor::run waiting for office to come up");
120 m_cEnable.wait();
121 if (m_bDying) //see destructor
122 break;
123 RTL_LOGFILE_CONTEXT_TRACE( aLog, "desktop (lo119109)"\
124 "Acceptor::run now enabled and continuing");
125
126 // accept connection
127 Reference< XConnection > rConnection = m_rAcceptor->accept( m_aConnectString );
128 // if we return without a valid connection we must assume that the acceptor
129 // is destructed so we break out of the run method terminating the thread
130 if (! rConnection.is()) break;
131 OUString aDescription = rConnection->getDescription();
132 RTL_LOGFILE_CONTEXT_TRACE1( aLog, "desktop (lo119109) Acceptor::run connection %s",
133 OUStringToOString(aDescription, RTL_TEXTENCODING_ASCII_US).getStr());
134
135 // create instanceprovider for this connection
136 Reference< XInstanceProvider > rInstanceProvider(
137 (XInstanceProvider*)new AccInstanceProvider(m_rSMgr, rConnection));
138 // create the bridge. The remote end will have a reference to this bridge
139 // thus preventing the bridge from being disposed. When the remote end releases
140 // the bridge, it will be destructed.
141 Reference< XBridge > rBridge = m_rBridgeFactory->createBridge(
142 rtl::OUString() ,m_aProtocol ,rConnection ,rInstanceProvider );
143 osl::MutexGuard g(m_aMutex);
144 m_bridges.add(rBridge);
145 } catch (Exception&) {
146 // connection failed...
147 // something went wrong during connection setup.
148 // just wait for a new connection to accept
149 }
150 }
151 }
152
153 // XInitialize
initialize(const Sequence<Any> & aArguments)154 void SAL_CALL Acceptor::initialize( const Sequence<Any>& aArguments )
155 throw( Exception )
156 {
157 // prevent multiple initialization
158 ClearableMutexGuard aGuard( m_aMutex );
159 RTL_LOGFILE_CONTEXT( aLog, "destop (lo119109) Acceptor::initialize()" );
160
161 sal_Bool bOk = sal_False;
162
163 // arg count
164 int nArgs = aArguments.getLength();
165
166 // not yet initialized and acceptstring
167 if (!m_bInit && nArgs > 0 && (aArguments[0] >>= m_aAcceptString))
168 {
169 RTL_LOGFILE_CONTEXT_TRACE1( aLog, "desktop (lo119109) Acceptor::initialize string=%s",
170 OUStringToOString(m_aAcceptString, RTL_TEXTENCODING_ASCII_US).getStr());
171
172 // get connect string and protocol from accept string
173 // "<connectString>;<protocol>"
174 sal_Int32 nIndex1 = m_aAcceptString.indexOf( (sal_Unicode) ';' );
175 if (nIndex1 < 0) throw IllegalArgumentException(
176 OUString::createFromAscii("Invalid accept-string format"), m_rContext, 1);
177 m_aConnectString = m_aAcceptString.copy( 0 , nIndex1 ).trim();
178 nIndex1++;
179 sal_Int32 nIndex2 = m_aAcceptString.indexOf( (sal_Unicode) ';' , nIndex1 );
180 if (nIndex2 < 0) nIndex2 = m_aAcceptString.getLength();
181 m_aProtocol = m_aAcceptString.copy( nIndex1, nIndex2 - nIndex1 );
182
183 // start accepting in new thread...
184 m_thread = osl_createThread(workerfunc, this);
185 m_bInit = sal_True;
186 bOk = sal_True;
187 }
188
189 // do we want to enable accepting?
190 sal_Bool bEnable = sal_False;
191 if (((nArgs == 1 && (aArguments[0] >>= bEnable)) ||
192 (nArgs == 2 && (aArguments[1] >>= bEnable))) &&
193 bEnable )
194 {
195 m_cEnable.set();
196 bOk = sal_True;
197 }
198
199 if (!bOk)
200 {
201 throw IllegalArgumentException(
202 OUString::createFromAscii("invalid initialization"), m_rContext, 1);
203 }
204 }
205
206 // XServiceInfo
207 const sal_Char *Acceptor::serviceName = "com.sun.star.office.Acceptor";
208 const sal_Char *Acceptor::implementationName = "com.sun.star.office.comp.Acceptor";
209 const sal_Char *Acceptor::supportedServiceNames[] = {"com.sun.star.office.Acceptor", NULL};
impl_getImplementationName()210 OUString Acceptor::impl_getImplementationName()
211 {
212 return OUString::createFromAscii( implementationName );
213 }
getImplementationName()214 OUString SAL_CALL Acceptor::getImplementationName()
215 throw (RuntimeException)
216 {
217 return Acceptor::impl_getImplementationName();
218 }
impl_getSupportedServiceNames()219 Sequence<OUString> Acceptor::impl_getSupportedServiceNames()
220 {
221 Sequence<OUString> aSequence;
222 for (int i=0; supportedServiceNames[i]!=NULL; i++) {
223 aSequence.realloc(i+1);
224 aSequence[i]=(OUString::createFromAscii(supportedServiceNames[i]));
225 }
226 return aSequence;
227 }
getSupportedServiceNames()228 Sequence<OUString> SAL_CALL Acceptor::getSupportedServiceNames()
229 throw (RuntimeException)
230 {
231 return Acceptor::impl_getSupportedServiceNames();
232 }
supportsService(const OUString &)233 sal_Bool SAL_CALL Acceptor::supportsService( const OUString&)
234 throw (RuntimeException)
235 {
236 return sal_False;
237 }
238
239 // Factory
impl_getInstance(const Reference<XMultiServiceFactory> & aFactory)240 Reference< XInterface > Acceptor::impl_getInstance( const Reference< XMultiServiceFactory >& aFactory )
241 {
242 try {
243 return (XComponent*) new Acceptor( aFactory );
244 } catch ( Exception& ) {
245 return (XComponent*) NULL;
246 }
247 }
248
249 // InstanceProvider
AccInstanceProvider(const Reference<XMultiServiceFactory> & aFactory,const Reference<XConnection> & rConnection)250 AccInstanceProvider::AccInstanceProvider(const Reference<XMultiServiceFactory>& aFactory, const Reference<XConnection>& rConnection)
251 {
252 m_rSMgr = aFactory;
253 m_rConnection = rConnection;
254 }
255
~AccInstanceProvider()256 AccInstanceProvider::~AccInstanceProvider()
257 {
258 }
259
getInstance(const OUString & aName)260 Reference<XInterface> SAL_CALL AccInstanceProvider::getInstance (const OUString& aName )
261 throw ( NoSuchElementException )
262 {
263
264 Reference<XInterface> rInstance;
265
266 if ( aName.compareToAscii( "StarOffice.ServiceManager" ) == 0)
267 {
268 rInstance = Reference< XInterface >( m_rSMgr );
269 }
270 else if(aName.compareToAscii( "StarOffice.ComponentContext" ) == 0 )
271 {
272 rInstance = getComponentContext( m_rSMgr );
273 }
274 else if ( aName.compareToAscii("StarOffice.NamingService" ) == 0 )
275 {
276 Reference< XNamingService > rNamingService(
277 m_rSMgr->createInstance( OUString::createFromAscii( "com.sun.star.uno.NamingService" )),
278 UNO_QUERY );
279 if ( rNamingService.is() )
280 {
281 rNamingService->registerObject(
282 OUString::createFromAscii( "StarOffice.ServiceManager" ), m_rSMgr );
283 rNamingService->registerObject(
284 OUString::createFromAscii( "StarOffice.ComponentContext" ), getComponentContext( m_rSMgr ));
285 rInstance = rNamingService;
286 }
287 }
288 /*
289 else if ( aName.compareToAscii("com.sun.star.ucb.RemoteContentProviderAcceptor" ))
290 {
291 Reference< XMultiServiceFactory > rSMgr = ::comphelper::getProcessServiceFactory();
292 if ( rSMgr.is() ) {
293 try {
294 rInstance = rSMgr->createInstance( sObjectName );
295 }
296 catch (Exception const &) {}
297 }
298 }
299 */
300 return rInstance;
301 }
302
303 }
304
305 // component management stuff...
306 // ----------------------------------------------------------------------------
307 extern "C"
308 {
309 using namespace desktop;
310
311 void SAL_CALL
component_getImplementationEnvironment(const sal_Char ** ppEnvironmentTypeName,uno_Environment **)312 component_getImplementationEnvironment(const sal_Char **ppEnvironmentTypeName, uno_Environment **)
313 {
314 *ppEnvironmentTypeName = CPPU_CURRENT_LANGUAGE_BINDING_NAME ;
315 }
316
317 void * SAL_CALL
component_getFactory(const sal_Char * pImplementationName,void * pServiceManager,void *)318 component_getFactory(const sal_Char *pImplementationName, void *pServiceManager, void *)
319 {
320 void* pReturn = NULL ;
321 if ( pImplementationName && pServiceManager )
322 {
323 // Define variables which are used in following macros.
324 Reference< XSingleServiceFactory > xFactory;
325 Reference< XMultiServiceFactory > xServiceManager(
326 reinterpret_cast< XMultiServiceFactory* >(pServiceManager));
327
328 if (Acceptor::impl_getImplementationName().compareToAscii( pImplementationName ) == COMPARE_EQUAL )
329 {
330 xFactory = Reference< XSingleServiceFactory >( cppu::createSingleFactory(
331 xServiceManager, Acceptor::impl_getImplementationName(),
332 Acceptor::impl_getInstance, Acceptor::impl_getSupportedServiceNames()) );
333 }
334
335 // Factory is valid - service was found.
336 if ( xFactory.is() )
337 {
338 xFactory->acquire();
339 pReturn = xFactory.get();
340 }
341 }
342
343 // Return with result of this operation.
344 return pReturn ;
345 }
346
347 } // extern "C"
348