vcl/unx/source/app/sm.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: sm.cxx,v $
  10  * $Revision: 1.33.90.1 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_vcl.hxx"
  33 #include <string.h>
  34 #include <unistd.h>
  35 #include <sys/poll.h>
  36 #include <fcntl.h>
  37
  38 #include <stdio.h>
  39
  40 #include <osl/process.h>
  41 #include <osl/security.h>
  42
  43 #include <tools/prex.h>
  44 #include <X11/Xatom.h>
  45 #include <tools/postx.h>
  46 #include <sm.hxx>
  47 #include <saldata.hxx>
  48 #include <saldisp.hxx>
  49 #include <salframe.h>
  50 #include <vcl/svapp.hxx>
  51 #include <vcl/window.hxx>
  52 #include <salinst.h>
  53
  54 #include <osl/conditn.h>
  55
  56 #define USE_SM_EXTENSION
  57
  58 #if OSL_DEBUG_LEVEL > 1
  59 #include <cstdarg>
  60 static bool bFirstAssert = true;
  61 #endif
  62
  63 #if OSL_DEBUG_LEVEL > 1
  64 inline void SMprintf( const char* pFormat, ... )
  65 #else
  66 inline void SMprintf( const char*, ... )
  67 #endif
  68 {
  69 #if OSL_DEBUG_LEVEL > 1
  70     FILE* fp = fopen( "/tmp/sessionlog.txt", bFirstAssert ? "w" : "a" );
  71     if(!fp) return;
  72     bFirstAssert = false;
  73     std::va_list ap;
  74     va_start( ap, pFormat );
  75     vfprintf( fp, pFormat, ap );
  76     fclose( fp );
  77     va_end( ap );
  78 #endif
  79 };
  80
  81 static IceSalSession* pOneInstance = NULL;
  82
  83 SalSession* X11SalInstance::CreateSalSession()
  84 {
  85     if( ! pOneInstance )
  86         pOneInstance = new IceSalSession();
  87     return pOneInstance;
  88 }
  89
  90 /*
  91  *  class IceSalSession
  92  */
  93
  94 static X11SalFrame* pOldStyleSaveFrame = NULL;
  95
  96 IceSalSession::IceSalSession()
  97 {
  98 }
  99
 100 IceSalSession::~IceSalSession()
 101 {
 102     if( pOneInstance == this )
 103         pOneInstance = NULL;
 104 }
 105
 106 void IceSalSession::queryInteraction()
 107 {
 108     if( ! SessionManagerClient::queryInteraction() )
 109     {
 110         SalSessionInteractionEvent aEvent( false );
 111         CallCallback( &aEvent );
 112     }
 113 }
 114
 115 void IceSalSession::interactionDone( bool bCancelShutdown )
 116 {
 117     SessionManagerClient::interactionDone( bCancelShutdown );
 118 }
 119
 120 void IceSalSession::saveDone()
 121 {
 122     SessionManagerClient::saveDone();
 123     if( pOldStyleSaveFrame )
 124     {
 125         // note: does nothing if not running in generic plugin
 126         X11SalFrame::SaveYourselfDone( pOldStyleSaveFrame );
 127     }
 128 }
 129
 130 void IceSalSession::handleOldX11SaveYourself( SalFrame* pFrame )
 131 {
 132     // do this only once
 133     if( ! pOldStyleSaveFrame )
 134     {
 135         pOldStyleSaveFrame = static_cast<X11SalFrame*>(pFrame);
 136         if( pOneInstance )
 137         {
 138             SalSessionSaveRequestEvent aEvent( true, false );
 139             pOneInstance->CallCallback( &aEvent );
 140         }
 141     }
 142 }
 143
 144 extern "C" void SAL_CALL ICEConnectionWorker( void* );
 145
 146 class ICEConnectionObserver
 147 {
 148     friend void SAL_CALL ICEConnectionWorker(void*);
 149     static BOOL bIsWatching;
 150     static void ICEWatchProc( IceConn connection, IcePointer client_data,
 151                               Bool opening, IcePointer* watch_data );
 152
 153     static struct pollfd* pFilehandles;
 154     static IceConn* pConnections;
 155     static int nConnections;
 156     static int nWakeupFiles[2];
 157     static oslMutex ICEMutex;
 158     static oslThread ICEThread;
 159 public:
 160
 161     static void activate();
 162     static void deactivate();
 163     static void lock();
 164     static void unlock();
 165     static void wakeup();
 166 };
 167
 168
 169 SmcConn                         SessionManagerClient::aSmcConnection                    = NULL;
 170 ByteString                      SessionManagerClient::aClientID;
 171 BOOL                            ICEConnectionObserver::bIsWatching                              = FALSE;
 172 struct pollfd*  ICEConnectionObserver::pFilehandles                             = NULL;
 173 IceConn*                        ICEConnectionObserver::pConnections                             = NULL;
 174 int                                     ICEConnectionObserver::nConnections                             = 0;
 175 oslMutex                        ICEConnectionObserver::ICEMutex                                 = NULL;
 176 oslThread                       ICEConnectionObserver::ICEThread                                = NULL;
 177 int                                     ICEConnectionObserver::nWakeupFiles[2]                  = { 0, 0 };
 178
 179 // HACK
 180 bool SessionManagerClient::bDocSaveDone = false;
 181
 182 bool SessionManagerClient::bSaveDoneSent = false;
 183
 184 static SmProp*  pSmProps = NULL;
 185 static SmProp** ppSmProps = NULL;
 186 static int              nSmProps = 0;
 187 static unsigned char   *pSmRestartHint = NULL;
 188
 189
 190 static void BuildSmPropertyList()
 191 {
 192     if( ! pSmProps )
 193     {
 194         ByteString aExec( SessionManagerClient::getExecName(), osl_getThreadTextEncoding() );
 195
 196         nSmProps = 5;
 197         pSmProps = new SmProp[ nSmProps ];
 198
 199         pSmProps[ 0 ].name              = const_cast<char*>(SmCloneCommand);
 200         pSmProps[ 0 ].type              = const_cast<char*>(SmLISTofARRAY8);
 201         pSmProps[ 0 ].num_vals  = 1;
 202         pSmProps[ 0 ].vals              = new SmPropValue;
 203         pSmProps[ 0 ].vals->length      = aExec.Len()+1;
 204         pSmProps[ 0 ].vals->value       = strdup( aExec.GetBuffer() );
 205
 206         pSmProps[ 1 ].name              = const_cast<char*>(SmProgram);
 207         pSmProps[ 1 ].type              = const_cast<char*>(SmARRAY8);
 208         pSmProps[ 1 ].num_vals  = 1;
 209         pSmProps[ 1 ].vals              = new SmPropValue;
 210         pSmProps[ 1 ].vals->length      = aExec.Len()+1;
 211         pSmProps[ 1 ].vals->value       = strdup( aExec.GetBuffer() );
 212
 213         pSmProps[ 2 ].name              = const_cast<char*>(SmRestartCommand);
 214         pSmProps[ 2 ].type              = const_cast<char*>(SmLISTofARRAY8);
 215         pSmProps[ 2 ].num_vals  = 3;
 216         pSmProps[ 2 ].vals              = new SmPropValue[3];
 217         pSmProps[ 2 ].vals[0].length    = aExec.Len()+1;
 218         pSmProps[ 2 ].vals[0].value     = strdup( aExec.GetBuffer() );
 219             ByteString aRestartOption( "-session=" );
 220         aRestartOption.Append( SessionManagerClient::getSessionID() );
 221         pSmProps[ 2 ].vals[1].length    = aRestartOption.Len()+1;
 222         pSmProps[ 2 ].vals[1].value     = strdup( aRestartOption.GetBuffer() );
 223             ByteString aRestartOptionNoLogo( "-nologo" );
 224         pSmProps[ 2 ].vals[2].length    = aRestartOptionNoLogo.Len()+1;
 225         pSmProps[ 2 ].vals[2].value     = strdup( aRestartOptionNoLogo.GetBuffer() );
 226
 227         rtl::OUString aUserName;
 228         rtl::OString aUser;
 229         oslSecurity aSec = osl_getCurrentSecurity();
 230         if( aSec )
 231         {
 232             osl_getUserName( aSec, &aUserName.pData );
 233             aUser = rtl::OUStringToOString( aUserName, osl_getThreadTextEncoding() );
 234             osl_freeSecurityHandle( aSec );
 235         }
 236
 237         pSmProps[ 3 ].name              = const_cast<char*>(SmUserID);
 238         pSmProps[ 3 ].type              = const_cast<char*>(SmARRAY8);
 239         pSmProps[ 3 ].num_vals  = 1;
 240         pSmProps[ 3 ].vals              = new SmPropValue;
 241         pSmProps[ 3 ].vals->value       = strdup( aUser.getStr() );
 242         pSmProps[ 3 ].vals->length      = strlen( (char *)pSmProps[ 3 ].vals->value )+1;
 243
 244         pSmProps[ 4 ].name              = const_cast<char*>(SmRestartStyleHint);
 245         pSmProps[ 4 ].type              = const_cast<char*>(SmCARD8);
 246         pSmProps[ 4 ].num_vals  = 1;
 247         pSmProps[ 4 ].vals              = new SmPropValue;
 248         pSmProps[ 4 ].vals->value       = malloc(1);
 249         pSmRestartHint = (unsigned char *)pSmProps[ 4 ].vals->value;
 250         *pSmRestartHint = SmRestartIfRunning;
 251         pSmProps[ 4 ].vals->length      = 1;
 252
 253         ppSmProps = new SmProp*[ nSmProps ];
 254         for( int i = 0; i < nSmProps; i++ )
 255             ppSmProps[ i ] = &pSmProps[i];
 256     }
 257 }
 258
 259 bool SessionManagerClient::checkDocumentsSaved()
 260 {
 261     return bDocSaveDone;
 262 }
 263
 264 struct SaveYourselfArgs {
 265         bool bShutdown;
 266         bool bFast;
 267         int nInteractionStyle;
 268 } aSaveYourselfArg;
 269
 270 IMPL_STATIC_LINK( SessionManagerClient, SaveYourselfHdl, void*, EMPTYARG )
 271 {
 272     SMprintf( "posting save documents event shutdown = %s\n", (pThis!=0) ? "true" : "false" );
 273
 274     static bool bFirstShutdown=true;
 275     if (pThis != 0 && bFirstShutdown) //first shutdown request
 276     {
 277         bFirstShutdown = false;
 278         /*
 279           If we have no actual frames open, e.g. we launched a quickstarter,
 280           and then shutdown all our frames leaving just a quickstarter running,
 281           then we don't want to launch an empty toplevel frame on the next
 282           start. (The job of scheduling the restart of the quick-starter is a
 283           task of the quick-starter)
 284         */
 285         *pSmRestartHint = SmRestartNever;
 286         const std::list< SalFrame* >& rFrames = GetX11SalData()->GetDisplay()->getFrames();
 287         for( std::list< SalFrame* >::const_iterator it = rFrames.begin(); it != rFrames.end(); ++it )
 288         {
 289             Window *pWindow = (*it)->GetWindow();
 290             if (pWindow && pWindow->IsVisible())
 291             {
 292                 *pSmRestartHint = SmRestartIfRunning;
 293                 break;
 294             }
 295         }
 296     }
 297
 298     if( pOneInstance )
 299     {
 300         SalSessionSaveRequestEvent aEvent( aSaveYourselfArg.bShutdown, aSaveYourselfArg.nInteractionStyle == SmInteractStyleAny && !aSaveYourselfArg.bFast );
 301         pOneInstance->CallCallback( &aEvent );
 302     }
 303     else
 304         saveDone();
 305
 306     return 0;
 307 }
 308
 309 IMPL_STATIC_LINK_NOINSTANCE( SessionManagerClient, InteractionHdl, void*, EMPTYARG )
 310 {
 311     SMprintf( "interaction link\n" );
 312
 313         if( pOneInstance )
 314     {
 315         SalSessionInteractionEvent aEvent( true );
 316         pOneInstance->CallCallback( &aEvent );
 317     }
 318
 319     return 0;
 320 }
 321
 322 IMPL_STATIC_LINK_NOINSTANCE( SessionManagerClient, ShutDownCancelHdl, void*, EMPTYARG )
 323 {
 324     SMprintf( "shutdown cancel\n" );
 325     if( pOneInstance )
 326     {
 327         SalSessionShutdownCancelEvent aEvent;
 328         pOneInstance->CallCallback( &aEvent );
 329     }
 330
 331         if( !bSaveDoneSent )
 332                 saveDone( false );
 333
 334     return 0;
 335 }
 336
 337 void SessionManagerClient::SaveYourselfProc(
 338     SmcConn,
 339     SmPointer,
 340     int save_type,
 341     Bool shutdown,
 342     int interact_style,
 343         Bool fast
 344     )
 345 {
 346     SMprintf( "Session: save yourself, save_type = %s, shutdown = %s, interact_style = %s, fast = %s\n",
 347               save_type == SmSaveLocal ? "SmcSaveLocal" :
 348               ( save_type == SmSaveGlobal ? "SmcSaveGlobal" :
 349                 ( save_type == SmSaveBoth ? "SmcSaveBoth" : "<unknown>" ) ),
 350               shutdown ? "true" : "false",
 351               interact_style == SmInteractStyleNone ? "SmInteractStyleNone" :
 352               ( interact_style == SmInteractStyleErrors ? "SmInteractStyleErrors" :
 353                 ( interact_style == SmInteractStyleAny ? "SmInteractStyleAny" : "<unknown>" ) ),
 354               fast ? "true" : "false"
 355               );
 356         bSaveDoneSent = false;
 357     BuildSmPropertyList();
 358 #ifdef USE_SM_EXTENSION
 359     bDocSaveDone = false;
 360     /* #i49875# some session managers send a "die" message if the
 361      * saveDone does not come early enough for their convenience
 362      * this can occasionally happen on startup, especially the first
 363      * startup. So shortcut the "not shutting down" case since the
 364      * upper layers are currently not interested in that event anyway.
 365      */
 366     if( ! shutdown )
 367     {
 368         SessionManagerClient::saveDone();
 369         return;
 370     }
 371
 372         aSaveYourselfArg.bShutdown = shutdown;
 373         aSaveYourselfArg.nInteractionStyle = interact_style;
 374         aSaveYourselfArg.bFast = fast;
 375         Application::PostUserEvent( STATIC_LINK( NULL, SessionManagerClient, SaveYourselfHdl ) );
 376
 377     SMprintf( "waiting for save yourself event to be processed\n" );
 378 #endif
 379 }
 380
 381 IMPL_STATIC_LINK_NOINSTANCE( SessionManagerClient, ShutDownHdl, void*, EMPTYARG )
 382 {
 383     const std::list< SalFrame* >& rFrames = GetX11SalData()->GetDisplay()->getFrames();
 384     SMprintf( rFrames.begin() != rFrames.end() ? "shutdown on first frame\n" : "shutdown event but no frame\n" );
 385     if( rFrames.begin() != rFrames.end() )
 386         rFrames.front()->CallCallback( SALEVENT_SHUTDOWN, 0 );
 387     return 0;
 388 }
 389
 390 void SessionManagerClient::DieProc(
 391     SmcConn connection,
 392     SmPointer
 393     )
 394 {
 395     SMprintf( "Session: die\n" );
 396     if( connection == aSmcConnection )
 397     {
 398         Application::PostUserEvent( STATIC_LINK( NULL, SessionManagerClient, ShutDownHdl ) );
 399         SMprintf( "waiting for shutdown event to be processed\n" );
 400     }
 401 }
 402
 403 void SessionManagerClient::SaveCompleteProc(
 404     SmcConn,
 405     SmPointer
 406     )
 407 {
 408     SMprintf( "Session: save complete\n" );
 409 }
 410
 411 void SessionManagerClient::ShutdownCanceledProc(
 412     SmcConn connection,
 413     SmPointer )
 414 {
 415     SMprintf( "Session: shutdown canceled\n" );
 416     if( connection == aSmcConnection )
 417         Application::PostUserEvent( STATIC_LINK( NULL, SessionManagerClient, ShutDownCancelHdl ) );
 418 }
 419
 420 void SessionManagerClient::InteractProc(
 421                                         SmcConn connection,
 422                                         SmPointer )
 423 {
 424     SMprintf( "Session: interaction request completed\n" );
 425     if( connection == aSmcConnection )
 426         Application::PostUserEvent( STATIC_LINK( NULL, SessionManagerClient, InteractionHdl ) );
 427 }
 428
 429 void SessionManagerClient::saveDone( bool bSuccess )
 430 {
 431     if( aSmcConnection )
 432     {
 433         ICEConnectionObserver::lock();
 434         if( bSuccess )
 435             SmcSetProperties( aSmcConnection, nSmProps, ppSmProps );
 436         SmcSaveYourselfDone( aSmcConnection, bSuccess );
 437         SMprintf( "sent SaveYourselfDone SmRestartHint of %d\n", *pSmRestartHint );
 438         bDocSaveDone = bSuccess;
 439         bSaveDoneSent = true;
 440         ICEConnectionObserver::unlock();
 441     }
 442 }
 443
 444
 445 void SessionManagerClient::open()
 446 {
 447     static SmcCallbacks aCallbacks;
 448
 449 #ifdef USE_SM_EXTENSION
 450     // this is the way Xt does it, so we can too
 451     if( ! aSmcConnection && getenv( "SESSION_MANAGER" ) )
 452     {
 453         char aErrBuf[1024];
 454         ICEConnectionObserver::activate();
 455         ICEConnectionObserver::lock();
 456
 457         char* pClientID = NULL;
 458         const ByteString& rPrevId( getPreviousSessionID() );
 459
 460         aCallbacks.save_yourself.callback                       = SaveYourselfProc;
 461         aCallbacks.save_yourself.client_data            = NULL;
 462         aCallbacks.die.callback                                         = DieProc;
 463         aCallbacks.die.client_data                                      = NULL;
 464         aCallbacks.save_complete.callback                       = SaveCompleteProc;
 465         aCallbacks.save_complete.client_data            = NULL;
 466         aCallbacks.shutdown_cancelled.callback          = ShutdownCanceledProc;
 467         aCallbacks.shutdown_cancelled.client_data       = NULL;
 468         aSmcConnection = SmcOpenConnection( NULL,
 469                                             NULL,
 470                                             SmProtoMajor,
 471                                             SmProtoMinor,
 472                                             SmcSaveYourselfProcMask                     |
 473                                             SmcDieProcMask                                      |
 474                                             SmcSaveCompleteProcMask                     |
 475                                             SmcShutdownCancelledProcMask        ,
 476                                             &aCallbacks,
 477                                             rPrevId.Len() ? const_cast<char*>(rPrevId.GetBuffer()) : NULL,
 478                                             &pClientID,
 479                                             sizeof( aErrBuf ),
 480                                             aErrBuf );
 481         if( ! aSmcConnection )
 482             SMprintf( "SmcOpenConnection failed: %s\n", aErrBuf );
 483         else
 484             SMprintf( "SmcOpenConnection succeeded, client ID is \"%s\"\n", pClientID );
 485         aClientID = ByteString( pClientID );
 486         free( pClientID );
 487         pClientID = NULL;
 488         ICEConnectionObserver::unlock();
 489
 490         SalDisplay* pDisp = GetX11SalData()->GetDisplay();
 491         if( pDisp->GetDrawable( pDisp->GetDefaultScreenNumber() ) && aClientID.Len() )
 492         {
 493             XChangeProperty( pDisp->GetDisplay(),
 494                              pDisp->GetDrawable( pDisp->GetDefaultScreenNumber() ),
 495                              XInternAtom( pDisp->GetDisplay(), "SM_CLIENT_ID", False ),
 496                              XA_STRING,
 497                              8,
 498                              PropModeReplace,
 499                              (unsigned char*)aClientID.GetBuffer(),
 500                              aClientID.Len()
 501                              );
 502         }
 503     }
 504     else if( ! aSmcConnection )
 505         SMprintf( "no SESSION_MANAGER\n" );
 506 #endif
 507 }
 508
 509 const ByteString& SessionManagerClient::getSessionID()
 510 {
 511     return aClientID;
 512 }
 513
 514 void SessionManagerClient::close()
 515 {
 516     if( aSmcConnection )
 517     {
 518 #ifdef USE_SM_EXTENSION
 519         ICEConnectionObserver::lock();
 520         SMprintf( "attempting SmcCloseConnection\n" );
 521         SmcCloseConnection( aSmcConnection, 0, NULL );
 522         SMprintf( "SmcConnection closed\n" );
 523         ICEConnectionObserver::unlock();
 524         ICEConnectionObserver::deactivate();
 525 #endif
 526         aSmcConnection = NULL;
 527     }
 528 }
 529
 530 bool SessionManagerClient::queryInteraction()
 531 {
 532     bool bRet = false;
 533     if( aSmcConnection )
 534     {
 535         ICEConnectionObserver::lock();
 536         if( SmcInteractRequest( aSmcConnection, SmDialogNormal, InteractProc, NULL ) )
 537             bRet = true;
 538         ICEConnectionObserver::unlock();
 539     }
 540     return bRet;
 541 }
 542
 543 void SessionManagerClient::interactionDone( bool bCancelShutdown )
 544 {
 545     if( aSmcConnection )
 546     {
 547         ICEConnectionObserver::lock();
 548         SmcInteractDone( aSmcConnection, bCancelShutdown );
 549         ICEConnectionObserver::unlock();
 550     }
 551 }
 552
 553
 554 String SessionManagerClient::getExecName()
 555 {
 556     rtl::OUString aExec, aSysExec;
 557     osl_getExecutableFile( &aExec.pData );
 558     osl_getSystemPathFromFileURL( aExec.pData, &aSysExec.pData );
 559
 560     int nPos = aSysExec.indexOf( rtl::OUString::createFromAscii( ".bin" ) );
 561     if( nPos != -1 )
 562         aSysExec = aSysExec.copy( 0, nPos );
 563     return aSysExec;
 564 }
 565
 566
 567 const ByteString& SessionManagerClient::getPreviousSessionID()
 568 {
 569     static ByteString aPrevId;
 570
 571     int nCommands = osl_getCommandArgCount();
 572     for( int i = 0; i < nCommands; i++ )
 573     {
 574         ::rtl::OUString aArg;
 575         osl_getCommandArg( i, &aArg.pData );
 576         if( aArg.compareToAscii( "-session=", 9 ) == 0 )
 577         {
 578             aPrevId = ByteString( ::rtl::OUStringToOString( aArg.copy( 9 ), osl_getThreadTextEncoding() ) );
 579             break;
 580         }
 581     }
 582     SMprintf( "previous ID = \"%s\"\n", aPrevId.GetBuffer() );
 583     return aPrevId;
 584 }
 585
 586 void ICEConnectionObserver::lock()
 587 {
 588     osl_acquireMutex( ICEMutex );
 589 }
 590
 591 void ICEConnectionObserver::unlock()
 592 {
 593     osl_releaseMutex( ICEMutex );
 594 }
 595
 596 void ICEConnectionObserver::activate()
 597 {
 598     if( ! bIsWatching )
 599     {
 600         nWakeupFiles[0] = nWakeupFiles[1] = 0;
 601         ICEMutex = osl_createMutex();
 602         bIsWatching = TRUE;
 603 #ifdef USE_SM_EXTENSION
 604         IceAddConnectionWatch( ICEWatchProc, NULL );
 605 #endif
 606     }
 607 }
 608
 609 void ICEConnectionObserver::deactivate()
 610 {
 611     if( bIsWatching )
 612     {
 613         lock();
 614         bIsWatching = FALSE;
 615 #ifdef USE_SM_EXTENSION
 616         IceRemoveConnectionWatch( ICEWatchProc, NULL );
 617 #endif
 618         nConnections = 0;
 619         if( ICEThread )
 620         {
 621             osl_terminateThread( ICEThread );
 622             wakeup();
 623         }
 624         unlock();
 625         if( ICEThread )
 626         {
 627             osl_joinWithThread( ICEThread );
 628             osl_destroyThread( ICEThread );
 629             close( nWakeupFiles[1] );
 630             close( nWakeupFiles[0] );
 631             ICEThread = NULL;
 632         }
 633         osl_destroyMutex( ICEMutex );
 634         ICEMutex = NULL;
 635     }
 636 }
 637
 638 void ICEConnectionObserver::wakeup()
 639 {
 640     char cChar = 'w';
 641     write( nWakeupFiles[1], &cChar, 1 );
 642 }
 643
 644 void ICEConnectionWorker( void* )
 645 {
 646 #ifdef USE_SM_EXTENSION
 647     while( osl_scheduleThread(ICEConnectionObserver::ICEThread) && ICEConnectionObserver::nConnections )
 648     {
 649         ICEConnectionObserver::lock();
 650         int nConnectionsBefore = ICEConnectionObserver::nConnections;
 651         int nBytes = sizeof( struct pollfd )*(nConnectionsBefore+1);
 652         struct pollfd* pLocalFD = (struct pollfd*)rtl_allocateMemory( nBytes );
 653         rtl_copyMemory( pLocalFD, ICEConnectionObserver::pFilehandles, nBytes );
 654         ICEConnectionObserver::unlock();
 655
 656         int nRet = poll( pLocalFD,nConnectionsBefore+1,-1 );
 657         bool bWakeup = (pLocalFD[0].revents & POLLIN);
 658         rtl_freeMemory( pLocalFD );
 659
 660         if( nRet < 1 )
 661             continue;
 662
 663         // clear wakeup pipe
 664         if( bWakeup )
 665         {
 666             char buf[4];
 667             while( read( ICEConnectionObserver::nWakeupFiles[0], buf, sizeof( buf ) ) > 0 )
 668                 ;
 669             SMprintf( "file handles active in wakeup: %d\n", nRet );
 670             if( nRet == 1 )
 671                 continue;
 672         }
 673
 674         // check fd's after we obtained the lock
 675         ICEConnectionObserver::lock();
 676         if( ICEConnectionObserver::nConnections > 0 && ICEConnectionObserver::nConnections == nConnectionsBefore )
 677         {
 678             nRet = poll( ICEConnectionObserver::pFilehandles+1, ICEConnectionObserver::nConnections, 0 );
 679             if( nRet > 0 )
 680             {
 681                 SMprintf( "IceProcessMessages\n" );
 682                 Bool bReply;
 683                 for( int i = 0; i < ICEConnectionObserver::nConnections; i++ )
 684                     if( ICEConnectionObserver::pFilehandles[i+1].revents & POLLIN )
 685                         IceProcessMessages( ICEConnectionObserver::pConnections[i], NULL, &bReply );
 686             }
 687         }
 688         ICEConnectionObserver::unlock();
 689     }
 690 #endif
 691     SMprintf( "shutting donw ICE dispatch thread\n" );
 692 }
 693
 694 void ICEConnectionObserver::ICEWatchProc(
 695     IceConn connection,
 696     IcePointer,
 697     Bool opening,
 698     IcePointer*
 699     )
 700 {
 701     // note: this is a callback function for ICE
 702     // this implicitly means that a call into ICE lib is calling this
 703     // so the ICEMutex MUST already be locked by the caller
 704
 705 #ifdef USE_SM_EXTENSION
 706     if( opening )
 707     {
 708         int fd = IceConnectionNumber( connection );
 709         nConnections++;
 710         pConnections = (IceConn*)rtl_reallocateMemory( pConnections, sizeof( IceConn )*nConnections );
 711         pFilehandles = (struct pollfd*)rtl_reallocateMemory( pFilehandles, sizeof( struct pollfd )*(nConnections+1) );
 712         pConnections[ nConnections-1 ]          = connection;
 713         pFilehandles[ nConnections ].fd         = fd;
 714         pFilehandles[ nConnections ].events     = POLLIN;
 715         if( nConnections == 1 )
 716         {
 717             if( ! pipe( nWakeupFiles ) )
 718             {
 719                 int flags;
 720                 pFilehandles[0].fd              = nWakeupFiles[0];
 721                 pFilehandles[0].events  = POLLIN;
 722                 // set close-on-exec and nonblock descriptor flag.
 723                 if ((flags = fcntl (nWakeupFiles[0], F_GETFD)) != -1)
 724                 {
 725                     flags |= FD_CLOEXEC;
 726                     fcntl (nWakeupFiles[0], F_SETFD, flags);
 727                 }
 728                 if ((flags = fcntl (nWakeupFiles[0], F_GETFL)) != -1)
 729                 {
 730                     flags |= O_NONBLOCK;
 731                     fcntl (nWakeupFiles[0], F_SETFL, flags);
 732                 }
 733                 // set close-on-exec and nonblock descriptor flag.
 734                 if ((flags = fcntl (nWakeupFiles[1], F_GETFD)) != -1)
 735                 {
 736                     flags |= FD_CLOEXEC;
 737                     fcntl (nWakeupFiles[1], F_SETFD, flags);
 738                 }
 739                 if ((flags = fcntl (nWakeupFiles[1], F_GETFL)) != -1)
 740                 {
 741                     flags |= O_NONBLOCK;
 742                     fcntl (nWakeupFiles[1], F_SETFL, flags);
 743                 }
 744                 ICEThread = osl_createSuspendedThread( ICEConnectionWorker, NULL );
 745                 osl_resumeThread( ICEThread );
 746             }
 747         }
 748     }
 749     else
 750     {
 751         for( int i = 0; i < nConnections; i++ )
 752         {
 753             if( pConnections[i] == connection )
 754             {
 755                 if( i < nConnections-1 )
 756                 {
 757                     rtl_moveMemory( pConnections+i, pConnections+i+1, sizeof( IceConn )*(nConnections-i-1) );
 758                     rtl_moveMemory( pFilehandles+i+1, pFilehandles+i+2, sizeof( struct pollfd )*(nConnections-i-1) );
 759                 }
 760                 nConnections--;
 761                 pConnections = (IceConn*)rtl_reallocateMemory( pConnections, sizeof( IceConn )*nConnections );
 762                 pFilehandles = (struct pollfd*)rtl_reallocateMemory( pFilehandles, sizeof( struct pollfd )*(nConnections+1) );
 763                 break;
 764             }
 765         }
 766         if( nConnections == 0 && ICEThread )
 767         {
 768             SMprintf( "terminating ICEThread\n" );
 769             osl_terminateThread( ICEThread );
 770             wakeup();
 771             // must release the mutex here
 772             osl_releaseMutex( ICEMutex );
 773             osl_joinWithThread( ICEThread );
 774             osl_destroyThread( ICEThread );
 775             close( nWakeupFiles[1] );
 776             close( nWakeupFiles[0] );
 777             ICEThread = NULL;
 778         }
 779     }
 780     SMprintf( "ICE connection on %d %s\n",
 781               IceConnectionNumber( connection ),
 782               opening ? "inserted" : "removed" );
 783     SMprintf( "Display connection is %d\n", ConnectionNumber( GetX11SalData()->GetDisplay()->GetDisplay() ) );
 784 #endif
 785 }