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 "app.hxx" 28 #include "officeipcthread.hxx" 29 #include "cmdlineargs.hxx" 30 #include "dispatchwatcher.hxx" 31 #include <memory> 32 #include <stdio.h> 33 #include <vos/process.hxx> 34 #include <unotools/bootstrap.hxx> 35 #include <vcl/svapp.hxx> 36 #include <vcl/help.hxx> 37 #include <unotools/configmgr.hxx> 38 #include <osl/thread.hxx> 39 #include <rtl/digest.h> 40 #include <rtl/ustrbuf.hxx> 41 #include <rtl/instance.hxx> 42 #include <osl/conditn.hxx> 43 #include <unotools/moduleoptions.hxx> 44 #include <rtl/bootstrap.hxx> 45 #include <rtl/strbuf.hxx> 46 #include <comphelper/processfactory.hxx> 47 #include "osl/file.hxx" 48 #include "rtl/process.h" 49 #include "tools/getprocessworkingdir.hxx" 50 51 using namespace vos; 52 using namespace rtl; 53 using namespace desktop; 54 using namespace ::com::sun::star::uno; 55 using namespace ::com::sun::star::lang; 56 using namespace ::com::sun::star::frame; 57 58 const char *OfficeIPCThread::sc_aTerminationSequence = "InternalIPC::TerminateThread"; 59 const int OfficeIPCThread::sc_nTSeqLength = 28; 60 const char *OfficeIPCThread::sc_aShowSequence = "-tofront"; 61 const int OfficeIPCThread::sc_nShSeqLength = 5; 62 const char *OfficeIPCThread::sc_aConfirmationSequence = "InternalIPC::ProcessingDone"; 63 const int OfficeIPCThread::sc_nCSeqLength = 27; 64 65 namespace { static char const ARGUMENT_PREFIX[] = "InternalIPC::Arguments"; } 66 67 // Type of pipe we use 68 enum PipeMode 69 { 70 PIPEMODE_DONTKNOW, 71 PIPEMODE_CREATED, 72 PIPEMODE_CONNECTED 73 }; 74 75 namespace desktop 76 { 77 78 namespace { 79 80 class Parser: public CommandLineArgs::Supplier { 81 public: 82 explicit Parser(rtl::OString const & input): m_input(input) { 83 if (!m_input.match(ARGUMENT_PREFIX) || 84 m_input.getLength() == RTL_CONSTASCII_LENGTH(ARGUMENT_PREFIX)) 85 { 86 throw CommandLineArgs::Supplier::Exception(); 87 } 88 m_index = RTL_CONSTASCII_LENGTH(ARGUMENT_PREFIX); 89 switch (m_input[m_index++]) { 90 case '0': 91 break; 92 case '1': 93 { 94 rtl::OUString url; 95 if (!next(&url, false)) { 96 throw CommandLineArgs::Supplier::Exception(); 97 } 98 m_cwdUrl.reset(url); 99 break; 100 } 101 case '2': 102 { 103 rtl::OUString path; 104 if (!next(&path, false)) { 105 throw CommandLineArgs::Supplier::Exception(); 106 } 107 rtl::OUString url; 108 if (osl::FileBase::getFileURLFromSystemPath(path, url) == 109 osl::FileBase::E_None) 110 { 111 m_cwdUrl.reset(url); 112 } 113 break; 114 } 115 default: 116 throw CommandLineArgs::Supplier::Exception(); 117 } 118 } 119 120 virtual ~Parser() {} 121 122 virtual boost::optional< rtl::OUString > getCwdUrl() { return m_cwdUrl; } 123 124 virtual bool next(rtl::OUString * argument) { return next(argument, true); } 125 126 private: 127 virtual bool next(rtl::OUString * argument, bool prefix) { 128 OSL_ASSERT(argument != NULL); 129 if (m_index < m_input.getLength()) { 130 if (prefix) { 131 if (m_input[m_index] != ',') { 132 throw CommandLineArgs::Supplier::Exception(); 133 } 134 ++m_index; 135 } 136 rtl::OStringBuffer b; 137 while (m_index < m_input.getLength()) { 138 char c = m_input[m_index]; 139 if (c == ',') { 140 break; 141 } 142 ++m_index; 143 if (c == '\\') { 144 if (m_index < m_input.getLength()) { 145 c = m_input[m_index++]; 146 switch (c) { 147 case '0': 148 c = '\0'; 149 break; 150 case ',': 151 case '\\': 152 break; 153 default: 154 throw CommandLineArgs::Supplier::Exception(); 155 } 156 } else { 157 throw CommandLineArgs::Supplier::Exception(); 158 } 159 } 160 b.append(c); 161 } 162 rtl::OString b2(b.makeStringAndClear()); 163 if (!rtl_convertStringToUString( 164 &argument->pData, b2.getStr(), b2.getLength(), 165 RTL_TEXTENCODING_UTF8, 166 (RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_ERROR | 167 RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_ERROR | 168 RTL_TEXTTOUNICODE_FLAGS_INVALID_ERROR))) 169 { 170 throw CommandLineArgs::Supplier::Exception(); 171 } 172 return true; 173 } else { 174 return false; 175 } 176 } 177 178 boost::optional< rtl::OUString > m_cwdUrl; 179 rtl::OString m_input; 180 sal_Int32 m_index; 181 }; 182 183 bool addArgument( 184 ByteString * arguments, char prefix, rtl::OUString const & argument) 185 { 186 rtl::OString utf8; 187 if (!argument.convertToString( 188 &utf8, RTL_TEXTENCODING_UTF8, 189 (RTL_UNICODETOTEXT_FLAGS_UNDEFINED_ERROR | 190 RTL_UNICODETOTEXT_FLAGS_INVALID_ERROR))) 191 { 192 return false; 193 } 194 *arguments += prefix; 195 for (sal_Int32 i = 0; i < utf8.getLength(); ++i) { 196 char c = utf8[i]; 197 switch (c) { 198 case '\0': 199 *arguments += "\\0"; 200 break; 201 case ',': 202 *arguments += "\\,"; 203 break; 204 case '\\': 205 *arguments += "\\\\"; 206 break; 207 default: 208 *arguments += c; 209 break; 210 } 211 } 212 return true; 213 } 214 215 } 216 217 OfficeIPCThread* OfficeIPCThread::pGlobalOfficeIPCThread = 0; 218 namespace { struct Security : public rtl::Static<OSecurity, Security> {}; } 219 ::osl::Mutex* OfficeIPCThread::pOfficeIPCThreadMutex = 0; 220 221 222 String CreateMD5FromString( const OUString& aMsg ) 223 { 224 // PRE: aStr "file" 225 // BACK: Str "ababab....0f" Hexcode String 226 227 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD5 ); 228 if ( handle > 0 ) 229 { 230 const sal_uInt8* pData = (const sal_uInt8*)aMsg.getStr(); 231 sal_uInt32 nSize = ( aMsg.getLength() * sizeof( sal_Unicode )); 232 sal_uInt32 nMD5KeyLen = rtl_digest_queryLength( handle ); 233 sal_uInt8* pMD5KeyBuffer = new sal_uInt8[ nMD5KeyLen ]; 234 235 rtl_digest_init( handle, pData, nSize ); 236 rtl_digest_update( handle, pData, nSize ); 237 rtl_digest_get( handle, pMD5KeyBuffer, nMD5KeyLen ); 238 rtl_digest_destroy( handle ); 239 240 // Create hex-value string from the MD5 value to keep the string size minimal 241 OUStringBuffer aBuffer( nMD5KeyLen * 2 + 1 ); 242 for ( sal_uInt32 i = 0; i < nMD5KeyLen; i++ ) 243 aBuffer.append( (sal_Int32)pMD5KeyBuffer[i], 16 ); 244 245 delete [] pMD5KeyBuffer; 246 return aBuffer.makeStringAndClear(); 247 } 248 249 return String(); 250 } 251 252 class ProcessEventsClass_Impl 253 { 254 public: 255 DECL_STATIC_LINK( ProcessEventsClass_Impl, CallEvent, void* pEvent ); 256 DECL_STATIC_LINK( ProcessEventsClass_Impl, ProcessDocumentsEvent, void* pEvent ); 257 }; 258 259 IMPL_STATIC_LINK_NOINSTANCE( ProcessEventsClass_Impl, CallEvent, void*, pEvent ) 260 { 261 // Application events are processed by the Desktop::HandleAppEvent implementation. 262 Desktop::HandleAppEvent( *((ApplicationEvent*)pEvent) ); 263 delete (ApplicationEvent*)pEvent; 264 return 0; 265 } 266 267 IMPL_STATIC_LINK_NOINSTANCE( ProcessEventsClass_Impl, ProcessDocumentsEvent, void*, pEvent ) 268 { 269 // Documents requests are processed by the OfficeIPCThread implementation 270 ProcessDocumentsRequest* pDocsRequest = (ProcessDocumentsRequest*)pEvent; 271 272 if ( pDocsRequest ) 273 { 274 OfficeIPCThread::ExecuteCmdLineRequests( *pDocsRequest ); 275 delete pDocsRequest; 276 } 277 return 0; 278 } 279 280 void ImplPostForeignAppEvent( ApplicationEvent* pEvent ) 281 { 282 Application::PostUserEvent( STATIC_LINK( NULL, ProcessEventsClass_Impl, CallEvent ), pEvent ); 283 } 284 285 void ImplPostProcessDocumentsEvent( ProcessDocumentsRequest* pEvent ) 286 { 287 Application::PostUserEvent( STATIC_LINK( NULL, ProcessEventsClass_Impl, ProcessDocumentsEvent ), pEvent ); 288 } 289 290 OSignalHandler::TSignalAction SAL_CALL SalMainPipeExchangeSignalHandler::signal(TSignalInfo *pInfo) 291 { 292 if( pInfo->Signal == osl_Signal_Terminate ) 293 OfficeIPCThread::DisableOfficeIPCThread(); 294 return (TAction_CallNextHandler); 295 } 296 297 // ---------------------------------------------------------------------------- 298 299 // The OfficeIPCThreadController implementation is a bookkeeper for all pending requests 300 // that were created by the OfficeIPCThread. The requests are waiting to be processed by 301 // our framework loadComponentFromURL function (e.g. open/print request). 302 // During shutdown the framework is asking OfficeIPCThreadController about pending requests. 303 // If there are pending requests framework has to stop the shutdown process. It is waiting 304 // for these requests because framework is not able to handle shutdown and open a document 305 // concurrently. 306 307 308 // XServiceInfo 309 OUString SAL_CALL OfficeIPCThreadController::getImplementationName() 310 throw ( RuntimeException ) 311 { 312 return OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.OfficeIPCThreadController" )); 313 } 314 315 sal_Bool SAL_CALL OfficeIPCThreadController::supportsService( const OUString& ) 316 throw ( RuntimeException ) 317 { 318 return sal_False; 319 } 320 321 Sequence< OUString > SAL_CALL OfficeIPCThreadController::getSupportedServiceNames() 322 throw ( RuntimeException ) 323 { 324 Sequence< OUString > aSeq( 0 ); 325 return aSeq; 326 } 327 328 // XEventListener 329 void SAL_CALL OfficeIPCThreadController::disposing( const EventObject& ) 330 throw( RuntimeException ) 331 { 332 } 333 334 // XTerminateListener 335 void SAL_CALL OfficeIPCThreadController::queryTermination( const EventObject& ) 336 throw( TerminationVetoException, RuntimeException ) 337 { 338 // Desktop ask about pending request through our office ipc pipe. We have to 339 // be sure that no pending request is waiting because framework is not able to 340 // handle shutdown and open a document concurrently. 341 342 if ( OfficeIPCThread::AreRequestsPending() ) 343 throw TerminationVetoException(); 344 else 345 OfficeIPCThread::SetDowning(); 346 } 347 348 void SAL_CALL OfficeIPCThreadController::notifyTermination( const EventObject& ) 349 throw( RuntimeException ) 350 { 351 } 352 353 // ---------------------------------------------------------------------------- 354 355 ::osl::Mutex& OfficeIPCThread::GetMutex() 356 { 357 // Get or create our mutex for thread-saftey 358 if ( !pOfficeIPCThreadMutex ) 359 { 360 ::osl::MutexGuard aGuard( osl::Mutex::getGlobalMutex() ); 361 if ( !pOfficeIPCThreadMutex ) 362 pOfficeIPCThreadMutex = new osl::Mutex; 363 } 364 365 return *pOfficeIPCThreadMutex; 366 } 367 368 void OfficeIPCThread::SetDowning() 369 { 370 // We have the order to block all incoming requests. Framework 371 // wants to shutdown and we have to make sure that no loading/printing 372 // requests are executed anymore. 373 ::osl::MutexGuard aGuard( GetMutex() ); 374 375 if ( pGlobalOfficeIPCThread ) 376 pGlobalOfficeIPCThread->mbDowning = true; 377 } 378 379 static bool s_bInEnableRequests = false; 380 381 void OfficeIPCThread::EnableRequests( bool i_bEnable ) 382 { 383 // switch between just queueing the requests and executing them 384 ::osl::MutexGuard aGuard( GetMutex() ); 385 386 if ( pGlobalOfficeIPCThread ) 387 { 388 s_bInEnableRequests = true; 389 pGlobalOfficeIPCThread->mbRequestsEnabled = i_bEnable; 390 if( i_bEnable ) 391 { 392 // hit the compiler over the head 393 ProcessDocumentsRequest aEmptyReq = ProcessDocumentsRequest( boost::optional< rtl::OUString >() ); 394 // trigger already queued requests 395 OfficeIPCThread::ExecuteCmdLineRequests( aEmptyReq ); 396 } 397 s_bInEnableRequests = false; 398 } 399 } 400 401 sal_Bool OfficeIPCThread::AreRequestsPending() 402 { 403 // Give info about pending requests 404 ::osl::MutexGuard aGuard( GetMutex() ); 405 if ( pGlobalOfficeIPCThread ) 406 return ( pGlobalOfficeIPCThread->mnPendingRequests > 0 ); 407 else 408 return sal_False; 409 } 410 411 void OfficeIPCThread::RequestsCompleted( int nCount ) 412 { 413 // Remove nCount pending requests from our internal counter 414 ::osl::MutexGuard aGuard( GetMutex() ); 415 if ( pGlobalOfficeIPCThread ) 416 { 417 if ( pGlobalOfficeIPCThread->mnPendingRequests > 0 ) 418 pGlobalOfficeIPCThread->mnPendingRequests -= nCount; 419 } 420 } 421 422 OfficeIPCThread::Status OfficeIPCThread::EnableOfficeIPCThread() 423 { 424 ::osl::MutexGuard aGuard( GetMutex() ); 425 426 if( pGlobalOfficeIPCThread ) 427 return IPC_STATUS_OK; 428 429 ::rtl::OUString aUserInstallPath; 430 ::rtl::OUString aDummy; 431 432 ::vos::OStartupInfo aInfo; 433 OfficeIPCThread* pThread = new OfficeIPCThread; 434 435 pThread->maPipeIdent = OUString( RTL_CONSTASCII_USTRINGPARAM( "SingleOfficeIPC_" ) ); 436 437 // The name of the named pipe is created with the hashcode of the user installation directory (without /user). We have to retrieve 438 // this information from a unotools implementation. 439 ::utl::Bootstrap::PathStatus aLocateResult = ::utl::Bootstrap::locateUserInstallation( aUserInstallPath ); 440 if ( aLocateResult == ::utl::Bootstrap::PATH_EXISTS || aLocateResult == ::utl::Bootstrap::PATH_VALID) 441 aDummy = aUserInstallPath; 442 else 443 { 444 delete pThread; 445 return IPC_STATUS_BOOTSTRAP_ERROR; 446 } 447 448 // Try to determine if we are the first office or not! This should prevent multiple 449 // access to the user directory ! 450 // First we try to create our pipe if this fails we try to connect. We have to do this 451 // in a loop because the the other office can crash or shutdown between createPipe 452 // and connectPipe!! 453 454 OUString aIniName; 455 456 aInfo.getExecutableFile( aIniName ); 457 sal_uInt32 lastIndex = aIniName.lastIndexOf('/'); 458 if ( lastIndex > 0 ) 459 { 460 aIniName = aIniName.copy( 0, lastIndex+1 ); 461 aIniName += OUString( RTL_CONSTASCII_USTRINGPARAM( "perftune" )); 462 #if defined(WNT) || defined(OS2) 463 aIniName += OUString( RTL_CONSTASCII_USTRINGPARAM( ".ini" )); 464 #else 465 aIniName += OUString( RTL_CONSTASCII_USTRINGPARAM( "rc" )); 466 #endif 467 } 468 469 ::rtl::Bootstrap aPerfTuneIniFile( aIniName ); 470 471 OUString aDefault( RTL_CONSTASCII_USTRINGPARAM( "0" )); 472 OUString aPreloadData; 473 474 aPerfTuneIniFile.getFrom( OUString( RTL_CONSTASCII_USTRINGPARAM( "FastPipeCommunication" )), aPreloadData, aDefault ); 475 476 477 OUString aUserInstallPathHashCode; 478 479 if ( aPreloadData.equalsAscii( "1" )) 480 { 481 sal_Char szBuffer[32]; 482 sprintf( szBuffer, "%d", SUPD ); 483 aUserInstallPathHashCode = OUString( szBuffer, strlen(szBuffer), osl_getThreadTextEncoding() ); 484 } 485 else 486 aUserInstallPathHashCode = CreateMD5FromString( aDummy ); 487 488 489 // Check result to create a hash code from the user install path 490 if ( aUserInstallPathHashCode.getLength() == 0 ) 491 return IPC_STATUS_BOOTSTRAP_ERROR; // Something completely broken, we cannot create a valid hash code! 492 493 pThread->maPipeIdent = pThread->maPipeIdent + aUserInstallPathHashCode; 494 495 PipeMode nPipeMode = PIPEMODE_DONTKNOW; 496 do 497 { 498 OSecurity &rSecurity = Security::get(); 499 // #119950# Try to connect pipe first. If connected, means another instance already launched. 500 if( pThread->maPipe.create( pThread->maPipeIdent.getStr(), OPipe::TOption_Open, rSecurity )) 501 { 502 // #119950# Test if launched in a new terminal session for same user. On Windows platform, normally a user is restricted 503 // to have only one terminal session. But if mutiple terminal session for one user is allowed, crash will happen if launched 504 // OpenOffice from more than one terminal session. So need to detect and prevent this happen. 505 506 // Will try to create a same name pipe. If creation is successfully, means current instance is launched in a new session. 507 vos::OPipe maSessionPipe; 508 if ( maSessionPipe.create( pThread->maPipeIdent.getStr(), OPipe::TOption_Create, rSecurity )) { 509 // Can create a pipe with same name. This can only happen in multiple terminal session environment on Windows platform. 510 // Will display a warning dialog and exit. 511 return IPC_STATUS_MULTI_TS_ERROR; 512 } else { 513 // Pipe connected to first office 514 nPipeMode = PIPEMODE_CONNECTED; 515 } 516 517 } 518 else if ( pThread->maPipe.create( pThread->maPipeIdent.getStr(), OPipe::TOption_Create, rSecurity )) // Connection not successful, now we try to create 519 { 520 // Pipe created 521 nPipeMode = PIPEMODE_CREATED; 522 } 523 else 524 { 525 OPipe::TPipeError eReason = pThread->maPipe.getError(); 526 if ((eReason == OPipe::E_ConnectionRefused) || (eReason == OPipe::E_invalidError)) 527 return IPC_STATUS_BOOTSTRAP_ERROR; 528 529 // Wait for second office to be ready 530 TimeValue aTimeValue; 531 aTimeValue.Seconds = 0; 532 aTimeValue.Nanosec = 10000000; // 10ms 533 osl::Thread::wait( aTimeValue ); 534 } 535 536 } while ( nPipeMode == PIPEMODE_DONTKNOW ); 537 538 if ( nPipeMode == PIPEMODE_CREATED ) 539 { 540 // Seems we are the one and only, so start listening thread 541 pGlobalOfficeIPCThread = pThread; 542 pThread->create(); // starts thread 543 } 544 else 545 { 546 // Seems another office is running. Pipe arguments to it and self terminate 547 pThread->maStreamPipe = pThread->maPipe; 548 549 sal_Bool bWaitBeforeClose = sal_False; 550 ByteString aArguments(RTL_CONSTASCII_STRINGPARAM(ARGUMENT_PREFIX)); 551 rtl::OUString cwdUrl; 552 if (!(tools::getProcessWorkingDir(&cwdUrl) && 553 addArgument(&aArguments, '1', cwdUrl))) 554 { 555 aArguments += '0'; 556 } 557 sal_uInt32 nCount = rtl_getAppCommandArgCount(); 558 for( sal_uInt32 i=0; i < nCount; i++ ) 559 { 560 rtl_getAppCommandArg( i, &aDummy.pData ); 561 if( aDummy.indexOf('-',0) != 0 ) 562 { 563 bWaitBeforeClose = sal_True; 564 } 565 if (!addArgument(&aArguments, ',', aDummy)) { 566 return IPC_STATUS_BOOTSTRAP_ERROR; 567 } 568 } 569 // finally, write the string onto the pipe 570 pThread->maStreamPipe.write( aArguments.GetBuffer(), aArguments.Len() ); 571 pThread->maStreamPipe.write( "\0", 1 ); 572 573 // wait for confirmation #95361# #95425# 574 ByteString aToken(sc_aConfirmationSequence); 575 char *aReceiveBuffer = new char[aToken.Len()+1]; 576 int n = pThread->maStreamPipe.read( aReceiveBuffer, aToken.Len() ); 577 aReceiveBuffer[n]='\0'; 578 579 delete pThread; 580 if (aToken.CompareTo(aReceiveBuffer)!= COMPARE_EQUAL) { 581 // something went wrong 582 delete[] aReceiveBuffer; 583 return IPC_STATUS_BOOTSTRAP_ERROR; 584 } else { 585 delete[] aReceiveBuffer; 586 return IPC_STATUS_2ND_OFFICE; 587 } 588 } 589 590 return IPC_STATUS_OK; 591 } 592 593 void OfficeIPCThread::DisableOfficeIPCThread() 594 { 595 osl::ClearableMutexGuard aMutex( GetMutex() ); 596 597 if( pGlobalOfficeIPCThread ) 598 { 599 OfficeIPCThread *pOfficeIPCThread = pGlobalOfficeIPCThread; 600 pGlobalOfficeIPCThread = 0; 601 602 // send thread a termination message 603 // this is done so the subsequent join will not hang 604 // because the thread hangs in accept of pipe 605 OPipe Pipe( pOfficeIPCThread->maPipeIdent, OPipe::TOption_Open, Security::get() ); 606 //Pipe.send( TERMINATION_SEQUENCE, TERMINATION_LENGTH ); 607 if (Pipe.isValid()) 608 { 609 Pipe.send( sc_aTerminationSequence, sc_nTSeqLength+1 ); // also send 0-byte 610 611 // close the pipe so that the streampipe on the other 612 // side produces EOF 613 Pipe.close(); 614 } 615 616 // release mutex to avoid deadlocks 617 aMutex.clear(); 618 619 OfficeIPCThread::SetReady(pOfficeIPCThread); 620 621 // exit gracefully and join 622 pOfficeIPCThread->join(); 623 delete pOfficeIPCThread; 624 625 626 } 627 } 628 629 OfficeIPCThread::OfficeIPCThread() : 630 mbDowning( false ), 631 mbRequestsEnabled( false ), 632 mnPendingRequests( 0 ), 633 mpDispatchWatcher( 0 ) 634 { 635 } 636 637 OfficeIPCThread::~OfficeIPCThread() 638 { 639 ::osl::ClearableMutexGuard aGuard( GetMutex() ); 640 641 if ( mpDispatchWatcher ) 642 mpDispatchWatcher->release(); 643 maPipe.close(); 644 maStreamPipe.close(); 645 pGlobalOfficeIPCThread = 0; 646 } 647 648 static void AddURLToStringList( const rtl::OUString& aURL, rtl::OUString& aStringList ) 649 { 650 if ( aStringList.getLength() ) 651 aStringList += ::rtl::OUString::valueOf( (sal_Unicode)APPEVENT_PARAM_DELIMITER ); 652 aStringList += aURL; 653 } 654 655 void OfficeIPCThread::SetReady(OfficeIPCThread* pThread) 656 { 657 if (pThread == NULL) pThread = pGlobalOfficeIPCThread; 658 if (pThread != NULL) 659 { 660 pThread->cReady.set(); 661 } 662 } 663 664 void SAL_CALL OfficeIPCThread::run() 665 { 666 do 667 { 668 OPipe::TPipeError 669 nError = maPipe.accept( maStreamPipe ); 670 671 672 if( nError == OStreamPipe::E_None ) 673 { 674 675 // #111143# and others: 676 // if we receive a request while the office is displaying some dialog or error during 677 // bootstrap, that dialogs event loop might get events that are dispatched by this thread 678 // we have to wait for cReady to be set by the real main loop. 679 // only reqests that don't dispatch events may be processed before cReady is set. 680 cReady.wait(); 681 682 // we might have decided to shutdown while we were sleeping 683 if (!pGlobalOfficeIPCThread) return; 684 685 // only lock the mutex when processing starts, othewise we deadlock when the office goes 686 // down during wait 687 osl::ClearableMutexGuard aGuard( GetMutex() ); 688 689 ByteString aArguments; 690 // test byte by byte 691 const int nBufSz = 2048; 692 char pBuf[nBufSz]; 693 int nBytes = 0; 694 int nResult = 0; 695 // read into pBuf until '\0' is read or read-error 696 while ((nResult=maStreamPipe.recv( pBuf+nBytes, nBufSz-nBytes))>0) { 697 nBytes += nResult; 698 if (pBuf[nBytes-1]=='\0') { 699 aArguments += pBuf; 700 break; 701 } 702 } 703 // don't close pipe ... 704 705 // #90717# Is this a lookup message from another application? if so, ignore 706 if ( aArguments.Len() == 0 ) 707 continue; 708 709 // is this a termination message ? if so, terminate 710 if(( aArguments.CompareTo( sc_aTerminationSequence, sc_nTSeqLength ) == COMPARE_EQUAL ) || 711 mbDowning ) return; 712 String aEmpty; 713 std::auto_ptr< CommandLineArgs > aCmdLineArgs; 714 try 715 { 716 Parser p( aArguments ); 717 aCmdLineArgs.reset( new CommandLineArgs( p ) ); 718 } 719 catch ( CommandLineArgs::Supplier::Exception & ) 720 { 721 #if (OSL_DEBUG_LEVEL > 1) || defined DBG_UTIL 722 fprintf( stderr, "Error in received command line arguments\n" ); 723 #endif 724 continue; 725 } 726 CommandLineArgs *pCurrentCmdLineArgs = Desktop::GetCommandLineArgs(); 727 728 if ( aCmdLineArgs->IsQuickstart() ) 729 { 730 // we have to use application event, because we have to start quickstart service in main thread!! 731 ApplicationEvent* pAppEvent = 732 new ApplicationEvent( aEmpty, aEmpty, 733 "QUICKSTART", aEmpty ); 734 ImplPostForeignAppEvent( pAppEvent ); 735 } 736 737 // handle request for acceptor 738 sal_Bool bAcceptorRequest = sal_False; 739 OUString aAcceptString; 740 if ( aCmdLineArgs->GetAcceptString(aAcceptString) && Desktop::CheckOEM()) { 741 ApplicationEvent* pAppEvent = 742 new ApplicationEvent( aEmpty, aEmpty, 743 "ACCEPT", aAcceptString ); 744 ImplPostForeignAppEvent( pAppEvent ); 745 bAcceptorRequest = sal_True; 746 } 747 // handle acceptor removal 748 OUString aUnAcceptString; 749 if ( aCmdLineArgs->GetUnAcceptString(aUnAcceptString) ) { 750 ApplicationEvent* pAppEvent = 751 new ApplicationEvent( aEmpty, aEmpty, 752 "UNACCEPT", aUnAcceptString ); 753 ImplPostForeignAppEvent( pAppEvent ); 754 bAcceptorRequest = sal_True; 755 } 756 757 #ifndef UNX 758 // only in non-unix version, we need to handle a -help request 759 // in a running instance in order to display the command line help 760 if ( aCmdLineArgs->IsHelp() ) { 761 ApplicationEvent* pAppEvent = 762 new ApplicationEvent( aEmpty, aEmpty, "HELP", aEmpty ); 763 ImplPostForeignAppEvent( pAppEvent ); 764 } 765 #endif 766 767 sal_Bool bDocRequestSent = sal_False; 768 ProcessDocumentsRequest* pRequest = new ProcessDocumentsRequest( 769 aCmdLineArgs->getCwdUrl()); 770 cProcessed.reset(); 771 pRequest->pcProcessed = &cProcessed; 772 773 // Print requests are not dependent on the -invisible cmdline argument as they are 774 // loaded with the "hidden" flag! So they are always checked. 775 bDocRequestSent |= aCmdLineArgs->GetPrintList( pRequest->aPrintList ); 776 bDocRequestSent |= ( aCmdLineArgs->GetPrintToList( pRequest->aPrintToList ) && 777 aCmdLineArgs->GetPrinterName( pRequest->aPrinterName ) ); 778 779 if ( !pCurrentCmdLineArgs->IsInvisible() ) 780 { 781 // Read cmdline args that can open/create documents. As they would open a window 782 // they are only allowed if the "-invisible" is currently not used! 783 bDocRequestSent |= aCmdLineArgs->GetOpenList( pRequest->aOpenList ); 784 bDocRequestSent |= aCmdLineArgs->GetViewList( pRequest->aViewList ); 785 bDocRequestSent |= aCmdLineArgs->GetStartList( pRequest->aStartList ); 786 bDocRequestSent |= aCmdLineArgs->GetForceOpenList( pRequest->aForceOpenList ); 787 bDocRequestSent |= aCmdLineArgs->GetForceNewList( pRequest->aForceNewList ); 788 789 // Special command line args to create an empty document for a given module 790 791 // #i18338# (lo) 792 // we only do this if no document was specified on the command line, 793 // since this would be inconsistent with the the behaviour of 794 // the first process, see OpenClients() (call to OpenDefault()) in app.cxx 795 if ( aCmdLineArgs->HasModuleParam() && Desktop::CheckOEM() && (!bDocRequestSent)) 796 { 797 SvtModuleOptions aOpt; 798 SvtModuleOptions::EFactory eFactory = SvtModuleOptions::E_WRITER; 799 if ( aCmdLineArgs->IsWriter() ) 800 eFactory = SvtModuleOptions::E_WRITER; 801 else if ( aCmdLineArgs->IsCalc() ) 802 eFactory = SvtModuleOptions::E_CALC; 803 else if ( aCmdLineArgs->IsDraw() ) 804 eFactory = SvtModuleOptions::E_DRAW; 805 else if ( aCmdLineArgs->IsImpress() ) 806 eFactory = SvtModuleOptions::E_IMPRESS; 807 else if ( aCmdLineArgs->IsBase() ) 808 eFactory = SvtModuleOptions::E_DATABASE; 809 else if ( aCmdLineArgs->IsMath() ) 810 eFactory = SvtModuleOptions::E_MATH; 811 else if ( aCmdLineArgs->IsGlobal() ) 812 eFactory = SvtModuleOptions::E_WRITERGLOBAL; 813 else if ( aCmdLineArgs->IsWeb() ) 814 eFactory = SvtModuleOptions::E_WRITERWEB; 815 816 if ( pRequest->aOpenList.getLength() ) 817 pRequest->aModule = aOpt.GetFactoryName( eFactory ); 818 else 819 AddURLToStringList( aOpt.GetFactoryEmptyDocumentURL( eFactory ), pRequest->aOpenList ); 820 bDocRequestSent = sal_True; 821 } 822 } 823 824 if (!aCmdLineArgs->IsQuickstart() && Desktop::CheckOEM()) { 825 sal_Bool bShowHelp = sal_False; 826 rtl::OUStringBuffer aHelpURLBuffer; 827 if (aCmdLineArgs->IsHelpWriter()) { 828 bShowHelp = sal_True; 829 aHelpURLBuffer.appendAscii("vnd.sun.star.help://swriter/start"); 830 } else if (aCmdLineArgs->IsHelpCalc()) { 831 bShowHelp = sal_True; 832 aHelpURLBuffer.appendAscii("vnd.sun.star.help://scalc/start"); 833 } else if (aCmdLineArgs->IsHelpDraw()) { 834 bShowHelp = sal_True; 835 aHelpURLBuffer.appendAscii("vnd.sun.star.help://sdraw/start"); 836 } else if (aCmdLineArgs->IsHelpImpress()) { 837 bShowHelp = sal_True; 838 aHelpURLBuffer.appendAscii("vnd.sun.star.help://simpress/start"); 839 } else if (aCmdLineArgs->IsHelpBase()) { 840 bShowHelp = sal_True; 841 aHelpURLBuffer.appendAscii("vnd.sun.star.help://sdatabase/start"); 842 } else if (aCmdLineArgs->IsHelpBasic()) { 843 bShowHelp = sal_True; 844 aHelpURLBuffer.appendAscii("vnd.sun.star.help://sbasic/start"); 845 } else if (aCmdLineArgs->IsHelpMath()) { 846 bShowHelp = sal_True; 847 aHelpURLBuffer.appendAscii("vnd.sun.star.help://smath/start"); 848 } 849 if (bShowHelp) { 850 Any aRet = ::utl::ConfigManager::GetDirectConfigProperty( ::utl::ConfigManager::LOCALE ); 851 rtl::OUString aTmp; 852 aRet >>= aTmp; 853 aHelpURLBuffer.appendAscii("?Language="); 854 aHelpURLBuffer.append(aTmp); 855 #if defined UNX 856 aHelpURLBuffer.appendAscii("&System=UNX"); 857 #elif defined WNT 858 aHelpURLBuffer.appendAscii("&System=WIN"); 859 #elif defined OS2 860 aHelpURLBuffer.appendAscii("&System=OS2"); 861 #endif 862 ApplicationEvent* pAppEvent = 863 new ApplicationEvent( aEmpty, aEmpty, 864 "OPENHELPURL", aHelpURLBuffer.makeStringAndClear()); 865 ImplPostForeignAppEvent( pAppEvent ); 866 } 867 } 868 869 if ( bDocRequestSent && Desktop::CheckOEM()) 870 { 871 // Send requests to dispatch watcher if we have at least one. The receiver 872 // is responsible to delete the request after processing it. 873 if ( aCmdLineArgs->HasModuleParam() ) 874 { 875 SvtModuleOptions aOpt; 876 877 // Support command line parameters to start a module (as preselection) 878 if ( aCmdLineArgs->IsWriter() && aOpt.IsModuleInstalled( SvtModuleOptions::E_SWRITER ) ) 879 pRequest->aModule = aOpt.GetFactoryName( SvtModuleOptions::E_WRITER ); 880 else if ( aCmdLineArgs->IsCalc() && aOpt.IsModuleInstalled( SvtModuleOptions::E_SCALC ) ) 881 pRequest->aModule = aOpt.GetFactoryName( SvtModuleOptions::E_CALC ); 882 else if ( aCmdLineArgs->IsImpress() && aOpt.IsModuleInstalled( SvtModuleOptions::E_SIMPRESS ) ) 883 pRequest->aModule= aOpt.GetFactoryName( SvtModuleOptions::E_IMPRESS ); 884 else if ( aCmdLineArgs->IsDraw() && aOpt.IsModuleInstalled( SvtModuleOptions::E_SDRAW ) ) 885 pRequest->aModule= aOpt.GetFactoryName( SvtModuleOptions::E_DRAW ); 886 } 887 888 889 ImplPostProcessDocumentsEvent( pRequest ); 890 } 891 else 892 { 893 // delete not used request again 894 delete pRequest; 895 pRequest = NULL; 896 } 897 if (( aArguments.CompareTo( sc_aShowSequence, sc_nShSeqLength ) == COMPARE_EQUAL ) || 898 aCmdLineArgs->IsEmpty() ) 899 { 900 // no document was sent, just bring Office to front 901 ApplicationEvent* pAppEvent = 902 new ApplicationEvent( aEmpty, aEmpty, "APPEAR", aEmpty ); 903 ImplPostForeignAppEvent( pAppEvent ); 904 } 905 906 // we don't need the mutex any longer... 907 aGuard.clear(); 908 // wait for processing to finish 909 if (bDocRequestSent) 910 cProcessed.wait(); 911 // processing finished, inform the requesting end 912 nBytes = 0; 913 while ( 914 (nResult = maStreamPipe.send(sc_aConfirmationSequence+nBytes, sc_nCSeqLength-nBytes))>0 && 915 ((nBytes += nResult) < sc_nCSeqLength) ) ; 916 // now we can close, don't we? 917 // maStreamPipe.close(); 918 919 } 920 else 921 { 922 #if (OSL_DEBUG_LEVEL > 1) || defined DBG_UTIL 923 fprintf( stderr, "Error on accept: %d\n", (int)nError ); 924 #endif 925 TimeValue tval; 926 tval.Seconds = 1; 927 tval.Nanosec = 0; 928 sleep( tval ); 929 } 930 } while( schedule() ); 931 } 932 933 static void AddToDispatchList( 934 DispatchWatcher::DispatchList& rDispatchList, 935 boost::optional< rtl::OUString > const & cwdUrl, 936 const OUString& aRequestList, 937 DispatchWatcher::RequestType nType, 938 const OUString& aParam, 939 const OUString& aFactory ) 940 { 941 if ( aRequestList.getLength() > 0 ) 942 { 943 sal_Int32 nIndex = 0; 944 do 945 { 946 OUString aToken = aRequestList.getToken( 0, APPEVENT_PARAM_DELIMITER, nIndex ); 947 if ( aToken.getLength() > 0 ) 948 rDispatchList.push_back( 949 DispatchWatcher::DispatchRequest( nType, aToken, cwdUrl, aParam, aFactory )); 950 } 951 while ( nIndex >= 0 ); 952 } 953 } 954 955 sal_Bool OfficeIPCThread::ExecuteCmdLineRequests( ProcessDocumentsRequest& aRequest ) 956 { 957 // protect the dispatch list 958 osl::ClearableMutexGuard aGuard( GetMutex() ); 959 960 static DispatchWatcher::DispatchList aDispatchList; 961 962 rtl::OUString aEmpty; 963 // Create dispatch list for dispatch watcher 964 AddToDispatchList( aDispatchList, aRequest.aCwdUrl, aRequest.aOpenList, DispatchWatcher::REQUEST_OPEN, aEmpty, aRequest.aModule ); 965 AddToDispatchList( aDispatchList, aRequest.aCwdUrl, aRequest.aViewList, DispatchWatcher::REQUEST_VIEW, aEmpty, aRequest.aModule ); 966 AddToDispatchList( aDispatchList, aRequest.aCwdUrl, aRequest.aStartList, DispatchWatcher::REQUEST_START, aEmpty, aRequest.aModule ); 967 AddToDispatchList( aDispatchList, aRequest.aCwdUrl, aRequest.aPrintList, DispatchWatcher::REQUEST_PRINT, aEmpty, aRequest.aModule ); 968 AddToDispatchList( aDispatchList, aRequest.aCwdUrl, aRequest.aPrintToList, DispatchWatcher::REQUEST_PRINTTO, aRequest.aPrinterName, aRequest.aModule ); 969 AddToDispatchList( aDispatchList, aRequest.aCwdUrl, aRequest.aForceOpenList, DispatchWatcher::REQUEST_FORCEOPEN, aEmpty, aRequest.aModule ); 970 AddToDispatchList( aDispatchList, aRequest.aCwdUrl, aRequest.aForceNewList, DispatchWatcher::REQUEST_FORCENEW, aEmpty, aRequest.aModule ); 971 972 sal_Bool bShutdown( sal_False ); 973 974 if ( pGlobalOfficeIPCThread ) 975 { 976 if( ! pGlobalOfficeIPCThread->AreRequestsEnabled() ) 977 return bShutdown; 978 979 pGlobalOfficeIPCThread->mnPendingRequests += aDispatchList.size(); 980 if ( !pGlobalOfficeIPCThread->mpDispatchWatcher ) 981 { 982 pGlobalOfficeIPCThread->mpDispatchWatcher = DispatchWatcher::GetDispatchWatcher(); 983 pGlobalOfficeIPCThread->mpDispatchWatcher->acquire(); 984 } 985 986 // copy for execute 987 DispatchWatcher::DispatchList aTempList( aDispatchList ); 988 aDispatchList.clear(); 989 990 aGuard.clear(); 991 992 // Execute dispatch requests 993 bShutdown = pGlobalOfficeIPCThread->mpDispatchWatcher->executeDispatchRequests( aTempList, s_bInEnableRequests ); 994 995 // set processed flag 996 if (aRequest.pcProcessed != NULL) 997 aRequest.pcProcessed->set(); 998 } 999 1000 return bShutdown; 1001 } 1002 1003 } 1004