Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <config_features.h>
21 :
22 : #include "app.hxx"
23 : #include "officeipcthread.hxx"
24 : #include "cmdlineargs.hxx"
25 : #include "dispatchwatcher.hxx"
26 : #include <boost/scoped_ptr.hpp>
27 : #include <stdio.h>
28 : #include <osl/process.h>
29 : #include <unotools/bootstrap.hxx>
30 : #include <vcl/svapp.hxx>
31 : #include <vcl/help.hxx>
32 : #include <unotools/configmgr.hxx>
33 : #include <osl/thread.hxx>
34 : #include <rtl/digest.h>
35 : #include <rtl/ustrbuf.hxx>
36 : #include <rtl/instance.hxx>
37 : #include <osl/conditn.hxx>
38 : #include <unotools/moduleoptions.hxx>
39 : #include <rtl/bootstrap.hxx>
40 : #include <rtl/strbuf.hxx>
41 : #include <comphelper/processfactory.hxx>
42 : #include <cppuhelper/supportsservice.hxx>
43 : #include <osl/file.hxx>
44 : #include <rtl/process.h>
45 : #include "tools/getprocessworkingdir.hxx"
46 : #include <boost/scoped_array.hpp>
47 :
48 : using namespace desktop;
49 : using namespace ::com::sun::star::uno;
50 : using namespace ::com::sun::star::lang;
51 : using namespace ::com::sun::star::frame;
52 :
53 :
54 : const char *OfficeIPCThread::sc_aShowSequence = "-tofront";
55 : const int OfficeIPCThread::sc_nShSeqLength = 5;
56 :
57 : namespace {
58 :
59 : #if HAVE_FEATURE_DESKTOP
60 :
61 : static char const ARGUMENT_PREFIX[] = "InternalIPC::Arguments";
62 : static char const SEND_ARGUMENTS[] = "InternalIPC::SendArguments";
63 : static char const PROCESSING_DONE[] = "InternalIPC::ProcessingDone";
64 :
65 : // Receives packets from the pipe until a packet ends in a NUL character (that
66 : // will not be included in the returned string) or it cannot read anything (due
67 : // to error or closed pipe, in which case an empty string will be returned to
68 : // signal failure):
69 0 : OString readStringFromPipe(osl::StreamPipe & pipe) {
70 0 : for (OStringBuffer str;;) {
71 : char buf[1024];
72 0 : sal_Int32 n = pipe.recv(buf, SAL_N_ELEMENTS(buf));
73 0 : if (n <= 0) {
74 0 : return "";
75 : }
76 0 : bool end = false;
77 0 : if (buf[n - 1] == '\0') {
78 0 : end = true;
79 0 : --n;
80 : }
81 0 : str.append(buf, n);
82 : //TODO: how does OStringBuffer.append handle overflow?
83 0 : if (end) {
84 0 : return str.makeStringAndClear();
85 : }
86 0 : }
87 : }
88 :
89 : #endif
90 :
91 : }
92 :
93 : // Type of pipe we use
94 : enum PipeMode
95 : {
96 : PIPEMODE_DONTKNOW,
97 : PIPEMODE_CREATED,
98 : PIPEMODE_CONNECTED
99 : };
100 :
101 : namespace desktop
102 : {
103 :
104 : namespace {
105 :
106 : #if HAVE_FEATURE_DESKTOP
107 :
108 : class Parser: public CommandLineArgs::Supplier {
109 : public:
110 0 : explicit Parser(OString const & input): m_input(input) {
111 0 : if (!m_input.match(ARGUMENT_PREFIX) ||
112 0 : m_input.getLength() == RTL_CONSTASCII_LENGTH(ARGUMENT_PREFIX))
113 : {
114 0 : throw CommandLineArgs::Supplier::Exception();
115 : }
116 0 : m_index = RTL_CONSTASCII_LENGTH(ARGUMENT_PREFIX);
117 0 : switch (m_input[m_index++]) {
118 : case '0':
119 0 : break;
120 : case '1':
121 : {
122 0 : OUString url;
123 0 : if (!next(&url, false)) {
124 0 : throw CommandLineArgs::Supplier::Exception();
125 : }
126 0 : m_cwdUrl.reset(url);
127 0 : break;
128 : }
129 : case '2':
130 : {
131 0 : OUString path;
132 0 : if (!next(&path, false)) {
133 0 : throw CommandLineArgs::Supplier::Exception();
134 : }
135 0 : OUString url;
136 0 : if (osl::FileBase::getFileURLFromSystemPath(path, url) ==
137 : osl::FileBase::E_None)
138 : {
139 0 : m_cwdUrl.reset(url);
140 : }
141 0 : break;
142 : }
143 : default:
144 0 : throw CommandLineArgs::Supplier::Exception();
145 : }
146 0 : }
147 :
148 0 : virtual ~Parser() {}
149 :
150 0 : virtual boost::optional< OUString > getCwdUrl() SAL_OVERRIDE { return m_cwdUrl; }
151 :
152 0 : virtual bool next(OUString * argument) SAL_OVERRIDE { return next(argument, true); }
153 :
154 : private:
155 0 : virtual bool next(OUString * argument, bool prefix) {
156 : OSL_ASSERT(argument != NULL);
157 0 : if (m_index < m_input.getLength()) {
158 0 : if (prefix) {
159 0 : if (m_input[m_index] != ',') {
160 0 : throw CommandLineArgs::Supplier::Exception();
161 : }
162 0 : ++m_index;
163 : }
164 0 : OStringBuffer b;
165 0 : while (m_index < m_input.getLength()) {
166 0 : char c = m_input[m_index];
167 0 : if (c == ',') {
168 0 : break;
169 : }
170 0 : ++m_index;
171 0 : if (c == '\\') {
172 0 : if (m_index < m_input.getLength()) {
173 0 : c = m_input[m_index++];
174 0 : switch (c) {
175 : case '0':
176 0 : c = '\0';
177 0 : break;
178 : case ',':
179 : case '\\':
180 0 : break;
181 : default:
182 0 : throw CommandLineArgs::Supplier::Exception();
183 : }
184 : } else {
185 0 : throw CommandLineArgs::Supplier::Exception();
186 : }
187 : }
188 0 : b.append(c);
189 : }
190 0 : OString b2(b.makeStringAndClear());
191 0 : if (!rtl_convertStringToUString(
192 : &argument->pData, b2.getStr(), b2.getLength(),
193 : RTL_TEXTENCODING_UTF8,
194 : (RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_ERROR |
195 : RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_ERROR |
196 0 : RTL_TEXTTOUNICODE_FLAGS_INVALID_ERROR)))
197 : {
198 0 : throw CommandLineArgs::Supplier::Exception();
199 : }
200 0 : return true;
201 : } else {
202 0 : return false;
203 : }
204 : }
205 :
206 : boost::optional< OUString > m_cwdUrl;
207 : OString m_input;
208 : sal_Int32 m_index;
209 : };
210 :
211 0 : bool addArgument(OStringBuffer &rArguments, char prefix,
212 : const OUString &rArgument)
213 : {
214 0 : OString utf8;
215 0 : if (!rArgument.convertToString(
216 : &utf8, RTL_TEXTENCODING_UTF8,
217 : (RTL_UNICODETOTEXT_FLAGS_UNDEFINED_ERROR |
218 0 : RTL_UNICODETOTEXT_FLAGS_INVALID_ERROR)))
219 : {
220 0 : return false;
221 : }
222 0 : rArguments.append(prefix);
223 0 : for (sal_Int32 i = 0; i < utf8.getLength(); ++i) {
224 0 : char c = utf8[i];
225 0 : switch (c) {
226 : case '\0':
227 0 : rArguments.append("\\0");
228 0 : break;
229 : case ',':
230 0 : rArguments.append("\\,");
231 0 : break;
232 : case '\\':
233 0 : rArguments.append("\\\\");
234 0 : break;
235 : default:
236 0 : rArguments.append(c);
237 0 : break;
238 : }
239 : }
240 0 : return true;
241 : }
242 :
243 : #endif
244 :
245 : }
246 :
247 80 : rtl::Reference< OfficeIPCThread > OfficeIPCThread::pGlobalOfficeIPCThread;
248 : namespace { struct Security : public rtl::Static<osl::Security, Security> {}; }
249 :
250 : // Turns a string in aMsg such as file:///home/foo/.libreoffice/3
251 : // Into a hex string of well known length ff132a86...
252 80 : OUString CreateMD5FromString( const OUString& aMsg )
253 : {
254 : #if (OSL_DEBUG_LEVEL > 2)
255 : fprintf( stderr, "create md5 from '%s'\n",
256 : OUStringToOString (aMsg, RTL_TEXTENCODING_UTF8).getStr() );
257 : #endif
258 :
259 80 : rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD5 );
260 80 : if ( handle )
261 : {
262 80 : const sal_uInt8* pData = (const sal_uInt8*)aMsg.getStr();
263 80 : sal_uInt32 nSize = ( aMsg.getLength() * sizeof( sal_Unicode ));
264 80 : sal_uInt32 nMD5KeyLen = rtl_digest_queryLength( handle );
265 80 : boost::scoped_array<sal_uInt8> pMD5KeyBuffer(new sal_uInt8[ nMD5KeyLen ]);
266 :
267 80 : rtl_digest_init( handle, pData, nSize );
268 80 : rtl_digest_update( handle, pData, nSize );
269 80 : rtl_digest_get( handle, pMD5KeyBuffer.get(), nMD5KeyLen );
270 80 : rtl_digest_destroy( handle );
271 :
272 : // Create hex-value string from the MD5 value to keep the string size minimal
273 160 : OUStringBuffer aBuffer( nMD5KeyLen * 2 + 1 );
274 1360 : for ( sal_uInt32 i = 0; i < nMD5KeyLen; i++ )
275 1280 : aBuffer.append( (sal_Int32)pMD5KeyBuffer[i], 16 );
276 :
277 160 : return aBuffer.makeStringAndClear();
278 : }
279 :
280 0 : return OUString();
281 : }
282 :
283 : class ProcessEventsClass_Impl
284 : {
285 : public:
286 : DECL_STATIC_LINK( ProcessEventsClass_Impl, CallEvent, void* pEvent );
287 : DECL_STATIC_LINK( ProcessEventsClass_Impl, ProcessDocumentsEvent, void* pEvent );
288 : };
289 :
290 0 : IMPL_STATIC_LINK_NOINSTANCE( ProcessEventsClass_Impl, CallEvent, void*, pEvent )
291 : {
292 : // Application events are processed by the Desktop::HandleAppEvent implementation.
293 0 : Desktop::HandleAppEvent( *((ApplicationEvent*)pEvent) );
294 0 : delete (ApplicationEvent*)pEvent;
295 0 : return 0;
296 : }
297 :
298 0 : IMPL_STATIC_LINK_NOINSTANCE( ProcessEventsClass_Impl, ProcessDocumentsEvent, void*, pEvent )
299 : {
300 : // Documents requests are processed by the OfficeIPCThread implementation
301 0 : ProcessDocumentsRequest* pDocsRequest = (ProcessDocumentsRequest*)pEvent;
302 :
303 0 : if ( pDocsRequest )
304 : {
305 0 : OfficeIPCThread::ExecuteCmdLineRequests( *pDocsRequest );
306 0 : delete pDocsRequest;
307 : }
308 0 : return 0;
309 : }
310 :
311 0 : void ImplPostForeignAppEvent( ApplicationEvent* pEvent )
312 : {
313 0 : Application::PostUserEvent( STATIC_LINK( NULL, ProcessEventsClass_Impl, CallEvent ), pEvent );
314 0 : }
315 :
316 0 : void ImplPostProcessDocumentsEvent( ProcessDocumentsRequest* pEvent )
317 : {
318 0 : Application::PostUserEvent( STATIC_LINK( NULL, ProcessEventsClass_Impl, ProcessDocumentsEvent ), pEvent );
319 0 : }
320 :
321 0 : oslSignalAction SAL_CALL SalMainPipeExchangeSignal_impl(void* /*pData*/, oslSignalInfo* pInfo)
322 : {
323 0 : if( pInfo->Signal == osl_Signal_Terminate )
324 0 : OfficeIPCThread::DisableOfficeIPCThread(false);
325 0 : return osl_Signal_ActCallNextHdl;
326 : }
327 :
328 :
329 :
330 : // The OfficeIPCThreadController implementation is a bookkeeper for all pending requests
331 : // that were created by the OfficeIPCThread. The requests are waiting to be processed by
332 : // our framework loadComponentFromURL function (e.g. open/print request).
333 : // During shutdown the framework is asking OfficeIPCThreadController about pending requests.
334 : // If there are pending requests framework has to stop the shutdown process. It is waiting
335 : // for these requests because framework is not able to handle shutdown and open a document
336 : // concurrently.
337 :
338 :
339 : // XServiceInfo
340 48 : OUString SAL_CALL OfficeIPCThreadController::getImplementationName()
341 : throw ( RuntimeException, std::exception )
342 : {
343 48 : return OUString( "com.sun.star.comp.OfficeIPCThreadController" );
344 : }
345 :
346 0 : sal_Bool OfficeIPCThreadController::supportsService(
347 : OUString const & ServiceName) throw (css::uno::RuntimeException, std::exception)
348 : {
349 0 : return cppu::supportsService(this, ServiceName);
350 : }
351 :
352 0 : Sequence< OUString > SAL_CALL OfficeIPCThreadController::getSupportedServiceNames()
353 : throw ( RuntimeException, std::exception )
354 : {
355 0 : Sequence< OUString > aSeq( 0 );
356 0 : return aSeq;
357 : }
358 :
359 : // XEventListener
360 0 : void SAL_CALL OfficeIPCThreadController::disposing( const EventObject& )
361 : throw( RuntimeException, std::exception )
362 : {
363 0 : }
364 :
365 : // XTerminateListener
366 48 : void SAL_CALL OfficeIPCThreadController::queryTermination( const EventObject& )
367 : throw( TerminationVetoException, RuntimeException, std::exception )
368 : {
369 : // Desktop ask about pending request through our office ipc pipe. We have to
370 : // be sure that no pending request is waiting because framework is not able to
371 : // handle shutdown and open a document concurrently.
372 :
373 48 : if ( OfficeIPCThread::AreRequestsPending() )
374 0 : throw TerminationVetoException();
375 : else
376 48 : OfficeIPCThread::SetDowning();
377 48 : }
378 :
379 48 : void SAL_CALL OfficeIPCThreadController::notifyTermination( const EventObject& )
380 : throw( RuntimeException, std::exception )
381 : {
382 48 : }
383 :
384 : namespace
385 : {
386 : class theOfficeIPCThreadMutex
387 : : public rtl::Static<osl::Mutex, theOfficeIPCThreadMutex> {};
388 : }
389 :
390 432 : ::osl::Mutex& OfficeIPCThread::GetMutex()
391 : {
392 432 : return theOfficeIPCThreadMutex::get();
393 : }
394 :
395 48 : void OfficeIPCThread::SetDowning()
396 : {
397 : // We have the order to block all incoming requests. Framework
398 : // wants to shutdown and we have to make sure that no loading/printing
399 : // requests are executed anymore.
400 48 : ::osl::MutexGuard aGuard( GetMutex() );
401 :
402 48 : if ( pGlobalOfficeIPCThread.is() )
403 48 : pGlobalOfficeIPCThread->mbDowning = true;
404 48 : }
405 :
406 : static bool s_bInEnableRequests = false;
407 :
408 48 : void OfficeIPCThread::EnableRequests( bool i_bEnable )
409 : {
410 : // switch between just queueing the requests and executing them
411 48 : ::osl::MutexGuard aGuard( GetMutex() );
412 :
413 48 : if ( pGlobalOfficeIPCThread.is() )
414 : {
415 48 : s_bInEnableRequests = true;
416 48 : pGlobalOfficeIPCThread->mbRequestsEnabled = i_bEnable;
417 48 : if( i_bEnable )
418 : {
419 : // hit the compiler over the head
420 48 : ProcessDocumentsRequest aEmptyReq = ProcessDocumentsRequest( boost::optional< OUString >() );
421 : // trigger already queued requests
422 48 : OfficeIPCThread::ExecuteCmdLineRequests( aEmptyReq );
423 : }
424 48 : s_bInEnableRequests = false;
425 48 : }
426 48 : }
427 :
428 48 : sal_Bool OfficeIPCThread::AreRequestsPending()
429 : {
430 : // Give info about pending requests
431 48 : ::osl::MutexGuard aGuard( GetMutex() );
432 48 : if ( pGlobalOfficeIPCThread.is() )
433 48 : return ( pGlobalOfficeIPCThread->mnPendingRequests > 0 );
434 : else
435 0 : return sal_False;
436 : }
437 :
438 0 : void OfficeIPCThread::RequestsCompleted( int nCount )
439 : {
440 : // Remove nCount pending requests from our internal counter
441 0 : ::osl::MutexGuard aGuard( GetMutex() );
442 0 : if ( pGlobalOfficeIPCThread.is() )
443 : {
444 0 : if ( pGlobalOfficeIPCThread->mnPendingRequests > 0 )
445 0 : pGlobalOfficeIPCThread->mnPendingRequests -= nCount;
446 0 : }
447 0 : }
448 :
449 80 : OfficeIPCThread::Status OfficeIPCThread::EnableOfficeIPCThread()
450 : {
451 : #if HAVE_FEATURE_DESKTOP
452 80 : ::osl::MutexGuard aGuard( GetMutex() );
453 :
454 80 : if( pGlobalOfficeIPCThread.is() )
455 0 : return IPC_STATUS_OK;
456 :
457 160 : OUString aUserInstallPath;
458 160 : OUString aDummy;
459 :
460 160 : rtl::Reference< OfficeIPCThread > pThread(new OfficeIPCThread);
461 :
462 : // The name of the named pipe is created with the hashcode of the user installation directory (without /user). We have to retrieve
463 : // this information from a unotools implementation.
464 80 : ::utl::Bootstrap::PathStatus aLocateResult = ::utl::Bootstrap::locateUserInstallation( aUserInstallPath );
465 80 : if ( aLocateResult == ::utl::Bootstrap::PATH_EXISTS || aLocateResult == ::utl::Bootstrap::PATH_VALID)
466 80 : aDummy = aUserInstallPath;
467 : else
468 : {
469 0 : return IPC_STATUS_BOOTSTRAP_ERROR;
470 : }
471 :
472 : // Try to determine if we are the first office or not! This should prevent multiple
473 : // access to the user directory !
474 : // First we try to create our pipe if this fails we try to connect. We have to do this
475 : // in a loop because the other office can crash or shutdown between createPipe
476 : // and connectPipe!!
477 :
478 160 : OUString aIniName;
479 :
480 80 : osl_getExecutableFile( &aIniName.pData );
481 :
482 80 : sal_uInt32 lastIndex = aIniName.lastIndexOf('/');
483 80 : if ( lastIndex > 0 )
484 : {
485 80 : aIniName = aIniName.copy( 0, lastIndex+1 );
486 80 : aIniName += "perftune";
487 : #if defined(WNT)
488 : aIniName += ".ini";
489 : #else
490 80 : aIniName += "rc";
491 : #endif
492 : }
493 :
494 160 : ::rtl::Bootstrap aPerfTuneIniFile( aIniName );
495 :
496 160 : OUString aDefault( "0" );
497 160 : OUString aPreloadData;
498 :
499 80 : aPerfTuneIniFile.getFrom( OUString( "FastPipeCommunication" ), aPreloadData, aDefault );
500 :
501 :
502 160 : OUString aUserInstallPathHashCode;
503 :
504 80 : if ( aPreloadData == "1" )
505 : {
506 : sal_Char szBuffer[32];
507 0 : sprintf( szBuffer, "%d", SUPD );
508 0 : aUserInstallPathHashCode = OUString( szBuffer, strlen(szBuffer), osl_getThreadTextEncoding() );
509 : }
510 : else
511 80 : aUserInstallPathHashCode = CreateMD5FromString( aDummy );
512 :
513 :
514 : // Check result to create a hash code from the user install path
515 80 : if ( aUserInstallPathHashCode.isEmpty() )
516 0 : return IPC_STATUS_BOOTSTRAP_ERROR; // Something completely broken, we cannot create a valid hash code!
517 :
518 160 : OUString aPipeIdent( "SingleOfficeIPC_" + aUserInstallPathHashCode );
519 :
520 80 : PipeMode nPipeMode = PIPEMODE_DONTKNOW;
521 80 : do
522 : {
523 80 : osl::Security &rSecurity = Security::get();
524 :
525 : // Try to create pipe
526 80 : if ( pThread->maPipe.create( aPipeIdent.getStr(), osl_Pipe_CREATE, rSecurity ))
527 : {
528 : // Pipe created
529 80 : nPipeMode = PIPEMODE_CREATED;
530 : }
531 0 : else if( pThread->maPipe.create( aPipeIdent.getStr(), osl_Pipe_OPEN, rSecurity )) // Creation not successful, now we try to connect
532 : {
533 0 : osl::StreamPipe aStreamPipe(pThread->maPipe.getHandle());
534 0 : if (readStringFromPipe(aStreamPipe) == SEND_ARGUMENTS)
535 : {
536 : // Pipe connected to first office
537 0 : nPipeMode = PIPEMODE_CONNECTED;
538 : }
539 : else
540 : {
541 : // Pipe connection failed (other office exited or crashed)
542 : TimeValue tval;
543 0 : tval.Seconds = 0;
544 0 : tval.Nanosec = 500000000;
545 0 : salhelper::Thread::wait( tval );
546 0 : }
547 : }
548 : else
549 : {
550 0 : oslPipeError eReason = pThread->maPipe.getError();
551 0 : if ((eReason == osl_Pipe_E_ConnectionRefused) || (eReason == osl_Pipe_E_invalidError))
552 0 : return IPC_STATUS_PIPE_ERROR;
553 :
554 : // Wait for second office to be ready
555 : TimeValue aTimeValue;
556 0 : aTimeValue.Seconds = 0;
557 0 : aTimeValue.Nanosec = 10000000; // 10ms
558 0 : salhelper::Thread::wait( aTimeValue );
559 : }
560 :
561 : } while ( nPipeMode == PIPEMODE_DONTKNOW );
562 :
563 80 : if ( nPipeMode == PIPEMODE_CREATED )
564 : {
565 : // Seems we are the one and only, so start listening thread
566 80 : pGlobalOfficeIPCThread = pThread;
567 80 : pThread->launch();
568 : }
569 : else
570 : {
571 : // Seems another office is running. Pipe arguments to it and self terminate
572 0 : osl::StreamPipe aStreamPipe(pThread->maPipe.getHandle());
573 :
574 0 : OStringBuffer aArguments(ARGUMENT_PREFIX);
575 0 : OUString cwdUrl;
576 0 : if (!(tools::getProcessWorkingDir(cwdUrl) &&
577 0 : addArgument(aArguments, '1', cwdUrl)))
578 : {
579 0 : aArguments.append('0');
580 : }
581 0 : sal_uInt32 nCount = rtl_getAppCommandArgCount();
582 0 : for( sal_uInt32 i=0; i < nCount; i++ )
583 : {
584 0 : rtl_getAppCommandArg( i, &aDummy.pData );
585 0 : if (!addArgument(aArguments, ',', aDummy)) {
586 0 : return IPC_STATUS_BOOTSTRAP_ERROR;
587 : }
588 : }
589 0 : aArguments.append('\0');
590 : // finally, write the string onto the pipe
591 : sal_Int32 n = aStreamPipe.write(
592 0 : aArguments.getStr(), aArguments.getLength());
593 0 : if (n != aArguments.getLength()) {
594 : SAL_INFO("desktop", "short write: " << n);
595 0 : return IPC_STATUS_BOOTSTRAP_ERROR;
596 : }
597 :
598 0 : if (readStringFromPipe(aStreamPipe) != PROCESSING_DONE)
599 : {
600 : // something went wrong
601 0 : return IPC_STATUS_BOOTSTRAP_ERROR;
602 : }
603 :
604 0 : return IPC_STATUS_2ND_OFFICE;
605 : }
606 : #else
607 : pGlobalOfficeIPCThread = rtl::Reference< OfficeIPCThread >(new OfficeIPCThread);
608 : #endif
609 160 : return IPC_STATUS_OK;
610 : }
611 :
612 80 : void OfficeIPCThread::DisableOfficeIPCThread(bool join)
613 : {
614 : #if HAVE_FEATURE_DESKTOP
615 80 : osl::ClearableMutexGuard aMutex( GetMutex() );
616 :
617 80 : if( pGlobalOfficeIPCThread.is() )
618 : {
619 : rtl::Reference< OfficeIPCThread > pOfficeIPCThread(
620 80 : pGlobalOfficeIPCThread);
621 80 : pGlobalOfficeIPCThread.clear();
622 :
623 80 : pOfficeIPCThread->mbDowning = true;
624 80 : pOfficeIPCThread->maPipe.close();
625 :
626 : // release mutex to avoid deadlocks
627 80 : aMutex.clear();
628 :
629 80 : OfficeIPCThread::SetReady(pOfficeIPCThread);
630 :
631 : // exit gracefully and join
632 80 : if (join)
633 : {
634 80 : pOfficeIPCThread->join();
635 80 : }
636 80 : }
637 : #else
638 : (void) join;
639 : #endif
640 80 : }
641 :
642 80 : OfficeIPCThread::OfficeIPCThread() :
643 : Thread( "OfficeIPCThread" ),
644 : mbDowning( false ),
645 : mbRequestsEnabled( false ),
646 : mnPendingRequests( 0 ),
647 80 : mpDispatchWatcher( 0 )
648 : {
649 80 : }
650 :
651 240 : OfficeIPCThread::~OfficeIPCThread()
652 : {
653 80 : ::osl::ClearableMutexGuard aGuard( GetMutex() );
654 :
655 80 : if ( mpDispatchWatcher )
656 48 : mpDispatchWatcher->release();
657 80 : maPipe.close();
658 80 : pGlobalOfficeIPCThread.clear();
659 160 : }
660 :
661 128 : void OfficeIPCThread::SetReady(
662 : rtl::Reference< OfficeIPCThread > const & pThread)
663 : {
664 : rtl::Reference< OfficeIPCThread > const & t(
665 128 : pThread.is() ? pThread : pGlobalOfficeIPCThread);
666 128 : if (t.is())
667 : {
668 128 : t->cReady.set();
669 : }
670 128 : }
671 :
672 80 : void OfficeIPCThread::execute()
673 : {
674 : #if HAVE_FEATURE_DESKTOP
675 0 : do
676 : {
677 80 : osl::StreamPipe aStreamPipe;
678 80 : oslPipeError nError = maPipe.accept( aStreamPipe );
679 :
680 :
681 80 : if( nError == osl_Pipe_E_None )
682 : {
683 : // if we receive a request while the office is displaying some dialog or error during
684 : // bootstrap, that dialogs event loop might get events that are dispatched by this thread
685 : // we have to wait for cReady to be set by the real main loop.
686 : // only reqests that dont dispatch events may be processed before cReady is set.
687 80 : cReady.wait();
688 :
689 : // we might have decided to shutdown while we were sleeping
690 160 : if (!pGlobalOfficeIPCThread.is()) return;
691 :
692 : // only lock the mutex when processing starts, othewise we deadlock when the office goes
693 : // down during wait
694 0 : osl::ClearableMutexGuard aGuard( GetMutex() );
695 :
696 0 : if ( mbDowning )
697 : {
698 0 : break;
699 : }
700 :
701 : // notify client we're ready to process its args:
702 : sal_Int32 n = aStreamPipe.write(
703 0 : SEND_ARGUMENTS, SAL_N_ELEMENTS(SEND_ARGUMENTS));
704 : // incl. terminating NUL
705 0 : if (n != SAL_N_ELEMENTS(SEND_ARGUMENTS)) {
706 : SAL_WARN("desktop", "short write: " << n);
707 0 : continue;
708 : }
709 :
710 0 : OString aArguments = readStringFromPipe(aStreamPipe);
711 :
712 : // Is this a lookup message from another application? if so, ignore
713 0 : if (aArguments.isEmpty())
714 0 : continue;
715 :
716 0 : boost::scoped_ptr< CommandLineArgs > aCmdLineArgs;
717 : try
718 : {
719 0 : Parser p(aArguments);
720 0 : aCmdLineArgs.reset( new CommandLineArgs( p ) );
721 : }
722 0 : catch ( const CommandLineArgs::Supplier::Exception & )
723 : {
724 : #if (OSL_DEBUG_LEVEL > 1) || defined DBG_UTIL
725 : fprintf( stderr, "Error in received command line arguments\n" );
726 : #endif
727 0 : continue;
728 : }
729 :
730 0 : bool bDocRequestSent = false;
731 :
732 0 : OUString aUnknown( aCmdLineArgs->GetUnknown() );
733 0 : if ( !aUnknown.isEmpty() || aCmdLineArgs->IsHelp() )
734 : {
735 : ApplicationEvent* pAppEvent =
736 0 : new ApplicationEvent(ApplicationEvent::TYPE_HELP, aUnknown);
737 0 : ImplPostForeignAppEvent( pAppEvent );
738 : }
739 0 : else if ( aCmdLineArgs->IsVersion() )
740 : {
741 : ApplicationEvent* pAppEvent =
742 0 : new ApplicationEvent(ApplicationEvent::TYPE_VERSION);
743 0 : ImplPostForeignAppEvent( pAppEvent );
744 : }
745 : else
746 : {
747 0 : const CommandLineArgs &rCurrentCmdLineArgs = Desktop::GetCommandLineArgs();
748 :
749 0 : if ( aCmdLineArgs->IsQuickstart() )
750 : {
751 : // we have to use application event, because we have to start quickstart service in main thread!!
752 : ApplicationEvent* pAppEvent =
753 0 : new ApplicationEvent(ApplicationEvent::TYPE_QUICKSTART);
754 0 : ImplPostForeignAppEvent( pAppEvent );
755 : }
756 :
757 : // handle request for acceptor
758 : std::vector< OUString > const & accept = aCmdLineArgs->
759 0 : GetAccept();
760 0 : for (std::vector< OUString >::const_iterator i(accept.begin());
761 0 : i != accept.end(); ++i)
762 : {
763 : ApplicationEvent* pAppEvent = new ApplicationEvent(
764 0 : ApplicationEvent::TYPE_ACCEPT, *i);
765 0 : ImplPostForeignAppEvent( pAppEvent );
766 : }
767 : // handle acceptor removal
768 : std::vector< OUString > const & unaccept = aCmdLineArgs->
769 0 : GetUnaccept();
770 0 : for (std::vector< OUString >::const_iterator i(
771 0 : unaccept.begin());
772 0 : i != unaccept.end(); ++i)
773 : {
774 : ApplicationEvent* pAppEvent = new ApplicationEvent(
775 0 : ApplicationEvent::TYPE_UNACCEPT, *i);
776 0 : ImplPostForeignAppEvent( pAppEvent );
777 : }
778 :
779 : ProcessDocumentsRequest* pRequest = new ProcessDocumentsRequest(
780 0 : aCmdLineArgs->getCwdUrl());
781 0 : cProcessed.reset();
782 0 : pRequest->pcProcessed = &cProcessed;
783 :
784 : // Print requests are not dependent on the --invisible cmdline argument as they are
785 : // loaded with the "hidden" flag! So they are always checked.
786 0 : pRequest->aPrintList = aCmdLineArgs->GetPrintList();
787 0 : bDocRequestSent |= !pRequest->aPrintList.empty();
788 0 : pRequest->aPrintToList = aCmdLineArgs->GetPrintToList();
789 0 : pRequest->aPrinterName = aCmdLineArgs->GetPrinterName();
790 0 : bDocRequestSent |= !( pRequest->aPrintToList.empty() || pRequest->aPrinterName.isEmpty() );
791 :
792 0 : if ( !rCurrentCmdLineArgs.IsInvisible() )
793 : {
794 : // Read cmdline args that can open/create documents. As they would open a window
795 : // they are only allowed if the "--invisible" is currently not used!
796 0 : pRequest->aOpenList = aCmdLineArgs->GetOpenList();
797 0 : bDocRequestSent |= !pRequest->aOpenList.empty();
798 0 : pRequest->aViewList = aCmdLineArgs->GetViewList();
799 0 : bDocRequestSent |= !pRequest->aViewList.empty();
800 0 : pRequest->aStartList = aCmdLineArgs->GetStartList();
801 0 : bDocRequestSent |= !pRequest->aStartList.empty();
802 0 : pRequest->aForceOpenList = aCmdLineArgs->GetForceOpenList();
803 0 : bDocRequestSent |= !pRequest->aForceOpenList.empty();
804 0 : pRequest->aForceNewList = aCmdLineArgs->GetForceNewList();
805 0 : bDocRequestSent |= !pRequest->aForceNewList.empty();
806 :
807 : // Special command line args to create an empty document for a given module
808 :
809 : // #i18338# (lo)
810 : // we only do this if no document was specified on the command line,
811 : // since this would be inconsistent with the behaviour of
812 : // the first process, see OpenClients() (call to OpenDefault()) in app.cxx
813 0 : if ( aCmdLineArgs->HasModuleParam() && !bDocRequestSent )
814 : {
815 0 : SvtModuleOptions aOpt;
816 0 : SvtModuleOptions::EFactory eFactory = SvtModuleOptions::E_WRITER;
817 0 : if ( aCmdLineArgs->IsWriter() )
818 0 : eFactory = SvtModuleOptions::E_WRITER;
819 0 : else if ( aCmdLineArgs->IsCalc() )
820 0 : eFactory = SvtModuleOptions::E_CALC;
821 0 : else if ( aCmdLineArgs->IsDraw() )
822 0 : eFactory = SvtModuleOptions::E_DRAW;
823 0 : else if ( aCmdLineArgs->IsImpress() )
824 0 : eFactory = SvtModuleOptions::E_IMPRESS;
825 0 : else if ( aCmdLineArgs->IsBase() )
826 0 : eFactory = SvtModuleOptions::E_DATABASE;
827 0 : else if ( aCmdLineArgs->IsMath() )
828 0 : eFactory = SvtModuleOptions::E_MATH;
829 0 : else if ( aCmdLineArgs->IsGlobal() )
830 0 : eFactory = SvtModuleOptions::E_WRITERGLOBAL;
831 0 : else if ( aCmdLineArgs->IsWeb() )
832 0 : eFactory = SvtModuleOptions::E_WRITERWEB;
833 :
834 0 : if ( !pRequest->aOpenList.empty() )
835 0 : pRequest->aModule = aOpt.GetFactoryName( eFactory );
836 : else
837 0 : pRequest->aOpenList.push_back( aOpt.GetFactoryEmptyDocumentURL( eFactory ) );
838 0 : bDocRequestSent = true;
839 : }
840 : }
841 :
842 0 : if ( !aCmdLineArgs->IsQuickstart() ) {
843 0 : sal_Bool bShowHelp = sal_False;
844 0 : OUStringBuffer aHelpURLBuffer;
845 0 : if (aCmdLineArgs->IsHelpWriter()) {
846 0 : bShowHelp = sal_True;
847 0 : aHelpURLBuffer.appendAscii("vnd.sun.star.help://swriter/start");
848 0 : } else if (aCmdLineArgs->IsHelpCalc()) {
849 0 : bShowHelp = sal_True;
850 0 : aHelpURLBuffer.appendAscii("vnd.sun.star.help://scalc/start");
851 0 : } else if (aCmdLineArgs->IsHelpDraw()) {
852 0 : bShowHelp = sal_True;
853 0 : aHelpURLBuffer.appendAscii("vnd.sun.star.help://sdraw/start");
854 0 : } else if (aCmdLineArgs->IsHelpImpress()) {
855 0 : bShowHelp = sal_True;
856 0 : aHelpURLBuffer.appendAscii("vnd.sun.star.help://simpress/start");
857 0 : } else if (aCmdLineArgs->IsHelpBase()) {
858 0 : bShowHelp = sal_True;
859 0 : aHelpURLBuffer.appendAscii("vnd.sun.star.help://sdatabase/start");
860 0 : } else if (aCmdLineArgs->IsHelpBasic()) {
861 0 : bShowHelp = sal_True;
862 0 : aHelpURLBuffer.appendAscii("vnd.sun.star.help://sbasic/start");
863 0 : } else if (aCmdLineArgs->IsHelpMath()) {
864 0 : bShowHelp = sal_True;
865 0 : aHelpURLBuffer.appendAscii("vnd.sun.star.help://smath/start");
866 : }
867 0 : if (bShowHelp) {
868 0 : aHelpURLBuffer.appendAscii("?Language=");
869 0 : aHelpURLBuffer.append(utl::ConfigManager::getLocale());
870 : #if defined UNX
871 0 : aHelpURLBuffer.appendAscii("&System=UNX");
872 : #elif defined WNT
873 : aHelpURLBuffer.appendAscii("&System=WIN");
874 : #endif
875 : ApplicationEvent* pAppEvent = new ApplicationEvent(
876 : ApplicationEvent::TYPE_OPENHELPURL,
877 0 : aHelpURLBuffer.makeStringAndClear());
878 0 : ImplPostForeignAppEvent( pAppEvent );
879 0 : }
880 : }
881 :
882 0 : if ( bDocRequestSent )
883 : {
884 : // Send requests to dispatch watcher if we have at least one. The receiver
885 : // is responsible to delete the request after processing it.
886 0 : if ( aCmdLineArgs->HasModuleParam() )
887 : {
888 0 : SvtModuleOptions aOpt;
889 :
890 : // Support command line parameters to start a module (as preselection)
891 0 : if ( aCmdLineArgs->IsWriter() && aOpt.IsModuleInstalled( SvtModuleOptions::E_SWRITER ) )
892 0 : pRequest->aModule = aOpt.GetFactoryName( SvtModuleOptions::E_WRITER );
893 0 : else if ( aCmdLineArgs->IsCalc() && aOpt.IsModuleInstalled( SvtModuleOptions::E_SCALC ) )
894 0 : pRequest->aModule = aOpt.GetFactoryName( SvtModuleOptions::E_CALC );
895 0 : else if ( aCmdLineArgs->IsImpress() && aOpt.IsModuleInstalled( SvtModuleOptions::E_SIMPRESS ) )
896 0 : pRequest->aModule= aOpt.GetFactoryName( SvtModuleOptions::E_IMPRESS );
897 0 : else if ( aCmdLineArgs->IsDraw() && aOpt.IsModuleInstalled( SvtModuleOptions::E_SDRAW ) )
898 0 : pRequest->aModule= aOpt.GetFactoryName( SvtModuleOptions::E_DRAW );
899 : }
900 :
901 0 : ImplPostProcessDocumentsEvent( pRequest );
902 : }
903 : else
904 : {
905 : // delete not used request again
906 0 : delete pRequest;
907 0 : pRequest = NULL;
908 : }
909 0 : if (aArguments.equalsL(sc_aShowSequence, sc_nShSeqLength) ||
910 0 : aCmdLineArgs->IsEmpty())
911 : {
912 : // no document was sent, just bring Office to front
913 : ApplicationEvent* pAppEvent =
914 0 : new ApplicationEvent(ApplicationEvent::TYPE_APPEAR);
915 0 : ImplPostForeignAppEvent( pAppEvent );
916 : }
917 : }
918 :
919 : // we don't need the mutex any longer...
920 0 : aGuard.clear();
921 : // wait for processing to finish
922 0 : if (bDocRequestSent)
923 0 : cProcessed.wait();
924 : // processing finished, inform the requesting end:
925 : n = aStreamPipe.write(
926 0 : PROCESSING_DONE, SAL_N_ELEMENTS(PROCESSING_DONE));
927 : // incl. terminating NUL
928 0 : if (n != SAL_N_ELEMENTS(PROCESSING_DONE)) {
929 : SAL_WARN("desktop", "short write: " << n);
930 0 : continue;
931 0 : }
932 : }
933 : else
934 : {
935 : {
936 0 : osl::MutexGuard aGuard( GetMutex() );
937 0 : if ( mbDowning )
938 : {
939 0 : break;
940 0 : }
941 : }
942 :
943 : #if (OSL_DEBUG_LEVEL > 1) || defined DBG_UTIL
944 : fprintf( stderr, "Error on accept: %d\n", (int)nError );
945 : #endif
946 : TimeValue tval;
947 0 : tval.Seconds = 1;
948 0 : tval.Nanosec = 0;
949 0 : salhelper::Thread::wait( tval );
950 0 : }
951 0 : } while( schedule() );
952 : #endif
953 : }
954 :
955 384 : static void AddToDispatchList(
956 : DispatchWatcher::DispatchList& rDispatchList,
957 : boost::optional< OUString > const & cwdUrl,
958 : std::vector< OUString > const & aRequestList,
959 : DispatchWatcher::RequestType nType,
960 : const OUString& aParam,
961 : const OUString& aFactory )
962 : {
963 1152 : for (std::vector< OUString >::const_iterator i(aRequestList.begin());
964 768 : i != aRequestList.end(); ++i)
965 : {
966 : rDispatchList.push_back(
967 0 : DispatchWatcher::DispatchRequest( nType, *i, cwdUrl, aParam, aFactory ));
968 : }
969 384 : }
970 :
971 48 : static void AddConversionsToDispatchList(
972 : DispatchWatcher::DispatchList& rDispatchList,
973 : boost::optional< OUString > const & cwdUrl,
974 : std::vector< OUString > const & rRequestList,
975 : const OUString& rParam,
976 : const OUString& rPrinterName,
977 : const OUString& rFactory,
978 : const OUString& rParamOut )
979 : {
980 : DispatchWatcher::RequestType nType;
981 48 : OUString aParam( rParam );
982 :
983 48 : if( !rParam.isEmpty() )
984 : {
985 0 : nType = DispatchWatcher::REQUEST_CONVERSION;
986 0 : aParam = rParam;
987 : }
988 : else
989 : {
990 48 : nType = DispatchWatcher::REQUEST_BATCHPRINT;
991 48 : aParam = rPrinterName;
992 : }
993 :
994 96 : OUString aOutDir( rParamOut.trim() );
995 96 : OUString aPWD;
996 48 : ::tools::getProcessWorkingDir( aPWD );
997 :
998 48 : if( !::osl::FileBase::getAbsoluteFileURL( aPWD, rParamOut, aOutDir ) )
999 0 : ::osl::FileBase::getSystemPathFromFileURL( aOutDir, aOutDir );
1000 :
1001 48 : if( !rParamOut.trim().isEmpty() )
1002 : {
1003 0 : aParam += ";";
1004 0 : aParam += aOutDir;
1005 : }
1006 : else
1007 : {
1008 48 : ::osl::FileBase::getSystemPathFromFileURL( aPWD, aPWD );
1009 48 : aParam += ";" + aPWD;
1010 : }
1011 :
1012 144 : for (std::vector< OUString >::const_iterator i(rRequestList.begin());
1013 96 : i != rRequestList.end(); ++i)
1014 : {
1015 : rDispatchList.push_back(
1016 0 : DispatchWatcher::DispatchRequest( nType, *i, cwdUrl, aParam, rFactory ));
1017 48 : }
1018 48 : }
1019 :
1020 :
1021 48 : sal_Bool OfficeIPCThread::ExecuteCmdLineRequests( ProcessDocumentsRequest& aRequest )
1022 : {
1023 : // protect the dispatch list
1024 48 : osl::ClearableMutexGuard aGuard( GetMutex() );
1025 :
1026 48 : static DispatchWatcher::DispatchList aDispatchList;
1027 :
1028 96 : OUString aEmpty;
1029 : // Create dispatch list for dispatch watcher
1030 48 : AddToDispatchList( aDispatchList, aRequest.aCwdUrl, aRequest.aInFilter, DispatchWatcher::REQUEST_INFILTER, aEmpty, aRequest.aModule );
1031 48 : AddToDispatchList( aDispatchList, aRequest.aCwdUrl, aRequest.aOpenList, DispatchWatcher::REQUEST_OPEN, aEmpty, aRequest.aModule );
1032 48 : AddToDispatchList( aDispatchList, aRequest.aCwdUrl, aRequest.aViewList, DispatchWatcher::REQUEST_VIEW, aEmpty, aRequest.aModule );
1033 48 : AddToDispatchList( aDispatchList, aRequest.aCwdUrl, aRequest.aStartList, DispatchWatcher::REQUEST_START, aEmpty, aRequest.aModule );
1034 48 : AddToDispatchList( aDispatchList, aRequest.aCwdUrl, aRequest.aPrintList, DispatchWatcher::REQUEST_PRINT, aEmpty, aRequest.aModule );
1035 48 : AddToDispatchList( aDispatchList, aRequest.aCwdUrl, aRequest.aPrintToList, DispatchWatcher::REQUEST_PRINTTO, aRequest.aPrinterName, aRequest.aModule );
1036 48 : AddToDispatchList( aDispatchList, aRequest.aCwdUrl, aRequest.aForceOpenList, DispatchWatcher::REQUEST_FORCEOPEN, aEmpty, aRequest.aModule );
1037 48 : AddToDispatchList( aDispatchList, aRequest.aCwdUrl, aRequest.aForceNewList, DispatchWatcher::REQUEST_FORCENEW, aEmpty, aRequest.aModule );
1038 48 : AddConversionsToDispatchList( aDispatchList, aRequest.aCwdUrl, aRequest.aConversionList, aRequest.aConversionParams, aRequest.aPrinterName, aRequest.aModule, aRequest.aConversionOut );
1039 48 : sal_Bool bShutdown( sal_False );
1040 :
1041 48 : if ( pGlobalOfficeIPCThread.is() )
1042 : {
1043 48 : if( ! pGlobalOfficeIPCThread->AreRequestsEnabled() )
1044 0 : return bShutdown;
1045 :
1046 48 : pGlobalOfficeIPCThread->mnPendingRequests += aDispatchList.size();
1047 48 : if ( !pGlobalOfficeIPCThread->mpDispatchWatcher )
1048 : {
1049 48 : pGlobalOfficeIPCThread->mpDispatchWatcher = DispatchWatcher::GetDispatchWatcher();
1050 48 : pGlobalOfficeIPCThread->mpDispatchWatcher->acquire();
1051 : }
1052 :
1053 : // copy for execute
1054 48 : DispatchWatcher::DispatchList aTempList( aDispatchList );
1055 48 : aDispatchList.clear();
1056 :
1057 48 : aGuard.clear();
1058 :
1059 : // Execute dispatch requests
1060 48 : bShutdown = pGlobalOfficeIPCThread->mpDispatchWatcher->executeDispatchRequests( aTempList, s_bInEnableRequests );
1061 :
1062 : // set processed flag
1063 48 : if (aRequest.pcProcessed != NULL)
1064 0 : aRequest.pcProcessed->set();
1065 : }
1066 :
1067 96 : return bShutdown;
1068 : }
1069 :
1070 240 : }
1071 :
1072 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
