desktop/source/app/officeipcthread.cxx

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