extensions/source/plugin/unx/npwrap.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: npwrap.cxx,v $
  10  * $Revision: 1.16.90.5 $
  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_extensions.hxx"
  33 #include <errno.h>
  34 #include <dlfcn.h>
  35 #include <unistd.h>
  36 #include <sys/poll.h>
  37 #include <fcntl.h>
  38 #include <signal.h>
  39
  40 #include <plugin/unx/plugcon.hxx>
  41
  42 #include <osl/file.h>
  43 #include <osl/module.h>
  44
  45 PluginConnector* pConnector = NULL;
  46
  47 int                     nAppArguments = 0;
  48 char**          pAppArguments = NULL;
  49 Display*        pAppDisplay = NULL;
  50 Display*    pXtAppDisplay = NULL;
  51
  52 extern oslModule pPluginLib;
  53 extern NPError (*pNP_Shutdown)();
  54
  55 void LoadAdditionalLibs(const char*);
  56
  57 XtAppContext app_context;
  58 Widget topLevel = NULL, topBox = NULL;
  59 int wakeup_fd[2] = { 0, 0 };
  60 static bool bPluginAppQuit = false;
  61
  62 static long GlobalConnectionLostHdl( void* /*pInst*/, void* /*pArg*/ )
  63 {
  64     medDebug( 1, "pluginapp exiting due to connection lost\n" );
  65
  66     write( wakeup_fd[1], "xxxx", 4 );
  67     return 0;
  68 }
  69
  70 extern "C"
  71 {
  72     static int plugin_x_error_handler( Display*, XErrorEvent* )
  73     {
  74         return 0;
  75     }
  76
  77     #ifndef ENABLE_GTK
  78     static void ThreadEventHandler( XtPointer /*client_data*/, int* /*source*/, XtInputId* id )
  79     {
  80         char buf[256];
  81         // clear pipe
  82         int len, nLast = -1;
  83
  84         while( (len = read( wakeup_fd[0], buf, sizeof( buf ) ) ) > 0 )
  85             nLast = len-1;
  86         if( ! bPluginAppQuit )
  87         {
  88             if( ( nLast == -1  || buf[nLast] != 'x' ) && pConnector )
  89                 pConnector->CallWorkHandler();
  90             else
  91             {
  92                 // it seems you can use XtRemoveInput only
  93                 // safely from within the callback
  94                 // why is that ?
  95                 medDebug( 1, "removing wakeup pipe\n" );
  96                 XtRemoveInput( *id );
  97                 XtAppSetExitFlag( app_context );
  98                 bPluginAppQuit = true;
  99
 100                 delete pConnector;
 101                 pConnector = NULL;
 102             }
 103         }
 104     }
 105     #endif
 106 }
 107
 108
 109 IMPL_LINK( PluginConnector, NewMessageHdl, Mediator*, /*pMediator*/ )
 110 {
 111     medDebug( 1, "new message handler\n" );
 112     write( wakeup_fd[1], "cccc", 4 );
 113     return 0;
 114
 115 }
 116
 117 Widget createSubWidget( char* /*pPluginText*/, Widget shell, XLIB_Window aParentWindow )
 118 {
 119     Widget newWidget = XtVaCreateManagedWidget(
 120 #if defined USE_MOTIF
 121           "drawingArea",
 122         xmDrawingAreaWidgetClass,
 123 #else
 124         "",
 125 #  if defined DISABLE_XAW
 126         compositeWidgetClass,
 127 #  else
 128         labelWidgetClass,
 129 #  endif
 130 #endif
 131           shell,
 132         XtNwidth, 200,
 133         XtNheight, 200,
 134           (char *)NULL );
 135     XtRealizeWidget( shell );
 136     XtRealizeWidget( newWidget );
 137
 138     medDebug( 1, "Reparenting new widget %x to %x\n", XtWindow( newWidget ), aParentWindow );
 139     XReparentWindow( pXtAppDisplay,
 140                      XtWindow( shell ),
 141                      aParentWindow,
 142                      0, 0 );
 143     XtMapWidget( shell );
 144     XtMapWidget( newWidget );
 145     XRaiseWindow( pXtAppDisplay, XtWindow( shell ) );
 146     XSync( pXtAppDisplay, False );
 147
 148     return newWidget;
 149 }
 150
 151 void* CreateNewShell( void** pShellReturn, XLIB_Window aParentWindow )
 152 {
 153     XLIB_String n, c;
 154     XtGetApplicationNameAndClass(pXtAppDisplay, &n, &c);
 155
 156     Widget newShell =
 157         XtVaAppCreateShell( "pane", c,
 158                             topLevelShellWidgetClass,
 159                             pXtAppDisplay,
 160                             XtNwidth, 200,
 161                             XtNheight, 200,
 162                             XtNoverrideRedirect, True,
 163                             (char *)NULL );
 164     *pShellReturn = newShell;
 165
 166     char pText[1024];
 167     sprintf( pText, "starting plugin %s ...", pAppArguments[2] );
 168
 169     Widget newWidget = createSubWidget( pText, newShell, aParentWindow );
 170
 171     return newWidget;
 172 }
 173
 174 static oslModule LoadModule( const char* pPath )
 175 {
 176     ::rtl::OUString sSystemPath( ::rtl::OUString::createFromAscii( pPath ) );
 177     ::rtl::OUString sFileURL;
 178     osl_getFileURLFromSystemPath( sSystemPath.pData, &sFileURL.pData );
 179
 180     oslModule pLib = osl_loadModule( sFileURL.pData, SAL_LOADMODULE_LAZY );
 181     if( ! pLib )
 182     {
 183         medDebug( 1, "could not open %s: %s\n", pPath, dlerror() );
 184     }
 185     return pLib;
 186 }
 187
 188 // Unix specific implementation
 189 static void CheckPlugin( const char* pPath )
 190 {
 191     oslModule pLib = LoadModule( pPath );
 192
 193     char*(*pNP_GetMIMEDescription)() = (char*(*)())
 194         osl_getAsciiFunctionSymbol( pLib, "NP_GetMIMEDescription" );
 195     if( pNP_GetMIMEDescription )
 196         printf( "%s\n", pNP_GetMIMEDescription() );
 197     else
 198         medDebug( 1, "could not get symbol NP_GetMIMEDescription %s\n", dlerror() );
 199
 200     osl_unloadModule( pLib );
 201 }
 202
 203 #if OSL_DEBUG_LEVEL > 1 && defined LINUX
 204 #include <execinfo.h>
 205 #endif
 206
 207 extern "C" {
 208
 209 static void signal_handler( int nSig )
 210 {
 211 #if OSL_DEBUG_LEVEL > 1
 212     fprintf( stderr, "caught signal %d, exiting\n", nSig );
 213 #ifdef LINUX
 214     void* pStack[64];
 215     int nStackLevels = backtrace( pStack, sizeof(pStack)/sizeof(pStack[0]) );
 216     backtrace_symbols_fd( pStack, nStackLevels, STDERR_FILENO );
 217 #endif
 218 #endif
 219     if( pConnector )
 220     {
 221         // ensure that a read on the other side will wakeup
 222         delete pConnector;
 223         pConnector = NULL;
 224     }
 225
 226     _exit(nSig);
 227 }
 228
 229 #ifdef ENABLE_GTK
 230
 231 static gboolean noClosure( gpointer )
 232 {
 233     return TRUE;
 234 }
 235
 236 // Xt events
 237 static gboolean prepareXtEvent( GSource*, gint* )
 238 {
 239     int nMask = XtAppPending( app_context );
 240     return (nMask & XtIMAll) != 0;
 241 }
 242
 243 static gboolean checkXtEvent( GSource* )
 244 {
 245     int nMask = XtAppPending( app_context );
 246     return (nMask & XtIMAll) != 0;
 247 }
 248
 249 static gboolean dispatchXtEvent( GSource*, GSourceFunc, gpointer )
 250 {
 251     XtAppProcessEvent( app_context, XtIMAll );
 252     return TRUE;
 253 }
 254
 255 static GSourceFuncs aXtEventFuncs =
 256 {
 257   prepareXtEvent,
 258   checkXtEvent,
 259   dispatchXtEvent,
 260   NULL,
 261   noClosure,
 262   NULL
 263 };
 264
 265 static gboolean pollXtTimerCallback(gpointer)
 266 {
 267     for(int i = 0; i < 5; i++)
 268     {
 269         if( (XtAppPending(app_context) & (XtIMAll & ~XtIMXEvent)) == 0 )
 270             break;
 271         XtAppProcessEvent(app_context, XtIMAll & ~XtIMXEvent);
 272     }
 273     return TRUE;
 274 }
 275
 276 static gboolean prepareWakeupEvent( GSource*, gint* )
 277 {
 278     struct pollfd aPoll = { wakeup_fd[0], POLLIN, 0 };
 279     poll( &aPoll, 1, 0 );
 280     return (aPoll.revents & POLLIN ) != 0;
 281 }
 282
 283 static gboolean checkWakeupEvent( GSource* pSource )
 284 {
 285     gint nDum = 0;
 286     return prepareWakeupEvent( pSource, &nDum );
 287 }
 288
 289 static gboolean dispatchWakeupEvent( GSource*, GSourceFunc, gpointer )
 290 {
 291     char buf[256];
 292     // clear pipe
 293     int len, nLast = -1;
 294
 295     while( (len = read( wakeup_fd[0], buf, sizeof( buf ) ) ) > 0 )
 296         nLast = len-1;
 297     if( ( nLast == -1  || buf[nLast] != 'x' ) && pConnector )
 298         pConnector->CallWorkHandler();
 299     else
 300     {
 301         XtAppSetExitFlag( app_context );
 302         bPluginAppQuit = true;
 303
 304         delete pConnector;
 305         pConnector = NULL;
 306     }
 307
 308     return TRUE;
 309 }
 310
 311 static GSourceFuncs aWakeupEventFuncs = {
 312   prepareWakeupEvent,
 313   checkWakeupEvent,
 314   dispatchWakeupEvent,
 315   NULL,
 316   noClosure,
 317   NULL
 318 };
 319
 320 #endif // GTK
 321
 322 }
 323
 324 int main( int argc, char **argv)
 325 {
 326     struct sigaction aSigAction;
 327     aSigAction.sa_handler = signal_handler;
 328     sigemptyset( &aSigAction.sa_mask );
 329     aSigAction.sa_flags = SA_NOCLDSTOP;
 330     sigaction( SIGSEGV, &aSigAction, NULL );
 331     sigaction( SIGBUS, &aSigAction, NULL );
 332     sigaction( SIGABRT, &aSigAction, NULL );
 333     sigaction( SIGTERM, &aSigAction, NULL );
 334     sigaction( SIGILL, &aSigAction, NULL );
 335
 336     int nArg = (argc < 3) ? 1 : 2;
 337     char* pBaseName = argv[nArg] + strlen(argv[nArg]);
 338     while( pBaseName > argv[nArg] && pBaseName[-1] != '/' )
 339         pBaseName--;
 340     LoadAdditionalLibs( pBaseName );
 341
 342     if( argc == 2 )
 343     {
 344         CheckPlugin(argv[1]);
 345         exit(0);
 346     }
 347     nAppArguments = argc;
 348     pAppArguments = argv;
 349
 350     XSetErrorHandler( plugin_x_error_handler );
 351
 352     if( pipe( wakeup_fd ) )
 353     {
 354         medDebug( 1, "could not pipe()\n" );
 355         return 1;
 356     }
 357     // initialize 'wakeup' pipe.
 358     int flags;
 359
 360     // set close-on-exec descriptor flag.
 361     if ((flags = fcntl (wakeup_fd[0], F_GETFD)) != -1)
 362     {
 363         flags |= FD_CLOEXEC;
 364         fcntl (wakeup_fd[0], F_SETFD, flags);
 365     }
 366     if ((flags = fcntl (wakeup_fd[1], F_GETFD)) != -1)
 367     {
 368         flags |= FD_CLOEXEC;
 369         fcntl (wakeup_fd[1], F_SETFD, flags);
 370     }
 371
 372     // set non-blocking I/O flag.
 373     if ((flags = fcntl (wakeup_fd[0], F_GETFL)) != -1)
 374     {
 375         flags |= O_NONBLOCK;
 376         fcntl (wakeup_fd[0], F_SETFL, flags);
 377     }
 378     if ((flags = fcntl (wakeup_fd[1], F_GETFL)) != -1)
 379     {
 380         flags |= O_NONBLOCK;
 381         fcntl (wakeup_fd[1], F_SETFL, flags);
 382     }
 383
 384     pPluginLib = LoadModule( argv[2] );
 385     if( ! pPluginLib )
 386     {
 387         exit(255);
 388     }
 389     int nSocket = atol( argv[1] );
 390
 391     #ifdef ENABLE_GTK
 392     g_thread_init(NULL);
 393     gtk_init(&argc, &argv);
 394     #endif
 395
 396      pConnector = new PluginConnector( nSocket );
 397      pConnector->SetConnectionLostHdl( Link( NULL, GlobalConnectionLostHdl ) );
 398
 399     XtSetLanguageProc( NULL, NULL, NULL );
 400
 401     XtToolkitInitialize();
 402     app_context = XtCreateApplicationContext();
 403     pXtAppDisplay = XtOpenDisplay( app_context, NULL, "SOPlugin", "SOPlugin", NULL, 0, &argc, argv );
 404
 405
 406     #ifdef ENABLE_GTK
 407     // integrate Xt events into GTK event loop
 408     GPollFD aXtPollDesc, aWakeupPollDesc;
 409
 410     GSource* pXTSource = g_source_new( &aXtEventFuncs, sizeof(GSource) );
 411     if( !pXTSource )
 412     {
 413         medDebug( 1, "could not get Xt GSource" );
 414         return 1;
 415     }
 416
 417     g_source_set_priority( pXTSource, GDK_PRIORITY_EVENTS );
 418     g_source_set_can_recurse( pXTSource, TRUE );
 419     g_source_attach( pXTSource, NULL );
 420     aXtPollDesc.fd = ConnectionNumber( pXtAppDisplay );
 421     aXtPollDesc.events = G_IO_IN;
 422     aXtPollDesc.revents = 0;
 423     g_source_add_poll( pXTSource, &aXtPollDesc );
 424
 425     gint xt_polling_timer_id = g_timeout_add( 25, pollXtTimerCallback, NULL);
 426     // Initialize wakeup events listener
 427     GSource *pWakeupSource = g_source_new( &aWakeupEventFuncs, sizeof(GSource) );
 428     if ( pWakeupSource == NULL )
 429     {
 430         medDebug( 1, "could not get wakeup source" );
 431         return 1;
 432     }
 433     g_source_set_priority( pWakeupSource, GDK_PRIORITY_EVENTS);
 434     g_source_attach( pWakeupSource, NULL );
 435     aWakeupPollDesc.fd = wakeup_fd[0];
 436     aWakeupPollDesc.events = G_IO_IN;
 437     aWakeupPollDesc.revents = 0;
 438     g_source_add_poll( pWakeupSource, &aWakeupPollDesc );
 439
 440     pAppDisplay = gdk_x11_display_get_xdisplay( gdk_display_get_default() );
 441     #else
 442     pAppDisplay = pXtAppDisplay;
 443     XtAppAddInput( app_context,
 444                    wakeup_fd[0],
 445                    (XtPointer)XtInputReadMask,
 446                    ThreadEventHandler, NULL );
 447     #endif
 448
 449      // send that we are ready to go
 450     MediatorMessage* pMessage =
 451         pConnector->Transact( "init req", 8,
 452                               NULL );
 453     delete pMessage;
 454
 455 #if OSL_DEBUG_LEVEL > 3
 456     int nPID = getpid();
 457     int nChild = fork();
 458     if( nChild == 0 )
 459     {
 460         char pidbuf[16];
 461         char* pArgs[] = { "xterm", "-sl", "2000", "-sb", "-e", "gdb", "pluginapp.bin", pidbuf, NULL };
 462         sprintf( pidbuf, "%d", nPID );
 463         execvp( pArgs[0], pArgs );
 464         _exit(255);
 465     }
 466     else
 467         sleep( 10 );
 468 #endif
 469
 470     /*
 471      *  Loop for events.
 472      */
 473     // for some reason XtAppSetExitFlag won't quit the application
 474     // in ThreadEventHandler most of times; Xt will hang in select
 475     // (hat is in XtAppNextEvent). Have our own mainloop instead
 476     // of XtAppMainLoop
 477     do
 478     {
 479         #ifdef ENABLE_GTK
 480         g_main_context_iteration( NULL, TRUE );
 481         #else
 482         XtAppProcessEvent( app_context, XtIMAll );
 483         #endif
 484     } while( ! XtAppGetExitFlag( app_context ) && ! bPluginAppQuit );
 485
 486     medDebug( 1, "left plugin app main loop\n" );
 487
 488     g_source_remove(xt_polling_timer_id);
 489
 490     pNP_Shutdown();
 491     medDebug( 1, "NP_Shutdown done\n" );
 492     osl_unloadModule( pPluginLib );
 493     medDebug( 1, "plugin close\n" );
 494
 495     close( wakeup_fd[0] );
 496     close( wakeup_fd[1] );
 497
 498     return 0;
 499 }
 500
 501 #ifdef GCC
 502 extern "C" {
 503     void __pure_virtual()
 504     {}
 505
 506     void* __builtin_new( int nBytes )
 507     { return malloc(nBytes); }
 508     void* __builtin_vec_new( int nBytes )
 509     { return malloc(nBytes); }
 510     void __builtin_delete( char* pMem )
 511     { free(pMem); }
 512     void __builtin_vec_delete( char* pMem )
 513     { free(pMem); }
 514 }
 515 #endif
 516