desktop/unx/source/start.c

   1 /*************************************************************************
   2  *
   3  *  OpenOffice.org - a multi-platform office productivity suite
   4  *
   5  *  $RCSfile$
   6  *
   7  *  $Revision: 9695 $
   8  *
   9  *  last change: $Author: jholesovsky $ $Date: 2007-07-03 16:36:09 +0200 (Út, 03 čec 2007) $
  10  *
  11  *  The Contents of this file are made available subject to
  12  *  the terms of GNU Lesser General Public License Version 2.1.
  13  *
  14  *
  15  *    GNU Lesser General Public License Version 2.1
  16  *    =============================================
  17  *    Copyright 2005 by Sun Microsystems, Inc.
  18  *    901 San Antonio Road, Palo Alto, CA 94303, USA
  19  *
  20  *    This library is free software; you can redistribute it and/or
  21  *    modify it under the terms of the GNU Lesser General Public
  22  *    License version 2.1, as published by the Free Software Foundation.
  23  *
  24  *    This library is distributed in the hope that it will be useful,
  25  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  26  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  27  *    Lesser General Public License for more details.
  28  *
  29  *    You should have received a copy of the GNU Lesser General Public
  30  *    License along with this library; if not, write to the Free Software
  31  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  32  *    MA  02111-1307  USA
  33  *
  34  ************************************************************************/
  35
  36 #include <signal.h>
  37 #include <unistd.h>
  38 #include <limits.h>
  39 #include <stdlib.h>
  40 #include <sys/types.h>
  41 #include <sys/stat.h>
  42 #include <sys/socket.h>
  43 #include <arpa/inet.h>
  44 #include <sys/un.h>
  45 #include <sys/poll.h>
  46 #include <fcntl.h>
  47 #include <stdio.h>
  48 #include <libgen.h>
  49
  50 #include <osl/nlsupport.h>
  51 #include <osl/process.h>
  52 #include <osl/thread.h>
  53 #include <rtl/bootstrap.h>
  54 #include <rtl/digest.h>
  55 #include <rtl/ustrbuf.h>
  56 #include <sal/main.h>
  57
  58 #include "splashx.h"
  59 #include <introbmpnames.hxx>
  60
  61 #define PIPEDEFAULTPATH      "/tmp"
  62 #define PIPEALTERNATEPATH    "/var/tmp"
  63
  64 /* Easier conversions: rtl_uString to rtl_String */
  65 static rtl_String *
  66 ustr_to_str( rtl_uString *pStr )
  67 {
  68     rtl_String *pOut = NULL;
  69
  70     rtl_uString2String( &pOut, rtl_uString_getStr( pStr ),
  71             rtl_uString_getLength( pStr ), osl_getThreadTextEncoding(), OUSTRING_TO_OSTRING_CVTFLAGS );
  72
  73     return pOut;
  74 }
  75
  76 /* Easier conversions: char * to rtl_uString */
  77 static rtl_uString *
  78 charp_to_ustr( const char *pStr )
  79 {
  80     rtl_uString *pOut = NULL;
  81
  82     rtl_string2UString( &pOut, pStr, strlen( pStr ), osl_getThreadTextEncoding(), OSTRING_TO_OUSTRING_CVTFLAGS );
  83
  84     return pOut;
  85 }
  86
  87 /* Easier debugging of rtl_uString values. */
  88 #if OSL_DEBUG_LEVEL > 0
  89 static void
  90 ustr_debug( const char *pMessage, rtl_uString *pStr )
  91 {
  92     rtl_String *pOut = ustr_to_str( pStr );
  93
  94     fprintf( stderr, "%s: %s\n", pMessage, rtl_string_getStr( pOut ) );
  95
  96     rtl_string_release( pOut );
  97     return;
  98 }
  99 #else
 100 #define ustr_debug( a, b ) {}
 101 #endif
 102
 103 /* Path of the application. */
 104 static rtl_uString *
 105 get_app_path( const char *pAppExec )
 106 {
 107     char pRealPath[PATH_MAX];
 108     rtl_uString *pResult;
 109
 110     char *pPath = strdup( pAppExec );
 111     pPath = dirname( pPath );
 112
 113     realpath( pPath, pRealPath );
 114     pResult = charp_to_ustr( pRealPath );
 115     free( pPath );
 116
 117     return pResult;
 118 }
 119
 120 /* Compute the OOo md5 hash from 'pText' */
 121 static rtl_uString *
 122 get_md5hash( rtl_uString *pText )
 123 {
 124     rtl_uString *pResult = NULL;
 125     sal_Int32 nCapacity = 100;
 126
 127     if ( !pText )
 128         return NULL;
 129
 130     unsigned char *pData = (unsigned char *)rtl_uString_getStr( pText );
 131     sal_uInt32   nSize = rtl_uString_getLength( pText ) * sizeof( sal_Unicode );
 132     if ( !pData )
 133         return NULL;
 134
 135     rtlDigest digest = rtl_digest_create( rtl_Digest_AlgorithmMD5 );
 136     if ( digest == 0 )
 137         return NULL;
 138
 139     sal_uInt32 md5_key_len = rtl_digest_queryLength( digest );
 140     sal_uInt8 *md5_buf = (sal_uInt8 *)calloc( md5_key_len, sizeof( sal_uInt8 ) );
 141
 142     rtl_digest_init( digest, pData , nSize );
 143     rtl_digest_update( digest, pData, nSize );
 144     rtl_digest_get( digest, md5_buf, md5_key_len );
 145     rtl_digest_destroy( digest );
 146
 147     /* create hex-value string from the MD5 value to keep
 148        the string size minimal */
 149     rtl_uString_new_WithLength( &pResult, nCapacity );
 150     sal_uInt32 i = 0;
 151     for ( ; i < md5_key_len; ++i )
 152     {
 153         char val[3];
 154         snprintf( val, 3, "%x", md5_buf[i] ); /* sic! we ignore some of the 0's */
 155
 156         rtl_uStringbuffer_insert_ascii( &pResult, &nCapacity, rtl_uString_getLength( pResult ),
 157                 val, strlen( val ) );
 158     }
 159
 160     /* cleanup */
 161     free( md5_buf );
 162
 163     return pResult;
 164 }
 165
 166 /* Construct the pipe name */
 167 static rtl_uString *
 168 get_pipe_path( rtl_uString *pAppPath )
 169 {
 170     rtl_uString *pPath = NULL, *pTmp = NULL, *pUserInstallation = NULL;
 171     rtl_uString *pResult = NULL;
 172
 173     /* setup bootstrap filename */
 174     rtl_uString_newFromAscii( &pPath, "file://" );
 175     rtl_uString_newConcat( &pPath, pPath, pAppPath );
 176     rtl_uString_newFromAscii( &pTmp, "/" );
 177     rtl_uString_newConcat( &pPath, pPath, pTmp );
 178     rtl_uString_newFromAscii( &pTmp, SAL_CONFIGFILE( "bootstrap" ) );
 179     rtl_uString_newConcat( &pPath, pPath, pTmp );
 180
 181     ustr_debug( "bootstap", pPath );
 182
 183     /* read userinstallation value */
 184     rtlBootstrapHandle handle = rtl_bootstrap_args_open( pPath );
 185
 186     rtl_uString_newFromAscii( &pTmp, "UserInstallation" );
 187     rtl_bootstrap_get_from_handle( handle, pTmp, &pUserInstallation, NULL );
 188
 189     rtl_bootstrap_args_close( handle );
 190
 191     /* create the pipe name */
 192     ustr_debug( "user installation", pUserInstallation );
 193     rtl_uString *pMd5hash = get_md5hash( pUserInstallation );
 194     if ( !pMd5hash )
 195         rtl_uString_new( &pMd5hash );
 196
 197     if ( access( PIPEDEFAULTPATH, R_OK|W_OK ) == 0 )
 198         rtl_uString_newFromAscii( &pResult, PIPEDEFAULTPATH );
 199     else
 200         rtl_uString_newFromAscii( &pResult, PIPEALTERNATEPATH );
 201
 202     rtl_uString_newFromAscii( &pTmp, "/OSL_PIPE_" );
 203     rtl_uString_newConcat( &pResult, pResult, pTmp );
 204
 205     sal_Unicode pUnicode[RTL_USTR_MAX_VALUEOFINT32];
 206     rtl_ustr_valueOfInt32( pUnicode, (int)getuid(), 10 );
 207     rtl_uString_newFromStr( &pTmp, pUnicode );
 208     rtl_uString_newConcat( &pResult, pResult, pTmp );
 209
 210     rtl_uString_newFromAscii( &pTmp, "_SingleOfficeIPC_" );
 211     rtl_uString_newConcat( &pResult, pResult, pTmp );
 212
 213     rtl_uString_newConcat( &pResult, pResult, pMd5hash );
 214
 215     ustr_debug( "result", pResult );
 216
 217     /* cleanup */
 218     rtl_uString_release( pPath );
 219     rtl_uString_release( pTmp );
 220     rtl_uString_release( pUserInstallation );
 221
 222     return pResult;
 223 }
 224
 225 /* Get fd of the pipe of the already running OOo. */
 226 static int
 227 connect_pipe( rtl_uString *pPipePath )
 228 {
 229     int fd;
 230     size_t len;
 231     struct sockaddr_un addr;
 232
 233     rtl_String *pPipeStr = ustr_to_str( pPipePath );
 234
 235     memset( &addr, 0, sizeof( addr ) );
 236
 237     if ( ( fd = socket( AF_UNIX, SOCK_STREAM, 0 ) ) < 0 )
 238         return fd;
 239
 240     fcntl( fd, F_SETFD, FD_CLOEXEC );
 241
 242     addr.sun_family = AF_UNIX;
 243     strncpy( addr.sun_path, rtl_string_getStr( pPipeStr ), sizeof( addr.sun_path ) );
 244     rtl_string_release( pPipeStr );
 245
 246 /* cut / paste from osl's pipe.c */
 247 #if defined(FREEBSD)
 248     len = SUN_LEN( &addr );
 249 #else
 250     len = sizeof( addr );
 251 #endif
 252
 253     if ( connect( fd, (struct sockaddr *)&addr, len ) < 0 )
 254         return -1;
 255
 256     return fd;
 257 }
 258
 259 /* Escape: "," -> "\\,", "\0" -> "\\0", "\\" -> "\\\\" */
 260 static rtl_uString *
 261 escape_path( rtl_uString *pToEscape )
 262 {
 263     rtl_uString *pBuffer = NULL;
 264     sal_Int32 nCapacity = 1000;
 265
 266     rtl_uString_new_WithLength( &pBuffer, nCapacity );
 267
 268     sal_Int32 i = 0;
 269     sal_Int32 nEscapeLength = rtl_uString_getLength( pToEscape );
 270     for ( ; i < nEscapeLength; ++i )
 271     {
 272         sal_Unicode c = pToEscape->buffer[i];
 273         switch ( c )
 274         {
 275             case (sal_Unicode)'\0':
 276                 rtl_uStringbuffer_insert_ascii( &pBuffer, &nCapacity,
 277                         rtl_uString_getLength( pBuffer ),
 278                         RTL_CONSTASCII_STRINGPARAM( "\\0" ) );
 279                 break;
 280             case (sal_Unicode)',':
 281                 rtl_uStringbuffer_insert_ascii( &pBuffer, &nCapacity,
 282                         rtl_uString_getLength( pBuffer ),
 283                         RTL_CONSTASCII_STRINGPARAM( "\\," ) );
 284                 break;
 285             case (sal_Unicode)'\\':
 286                 rtl_uStringbuffer_insert_ascii( &pBuffer, &nCapacity,
 287                         rtl_uString_getLength( pBuffer ),
 288                         RTL_CONSTASCII_STRINGPARAM( "\\\\" ) );
 289                 break;
 290             default:
 291                 rtl_uStringbuffer_insert( &pBuffer, &nCapacity,
 292                         rtl_uString_getLength( pBuffer ),
 293                         &c, 1 );
 294         }
 295     }
 296
 297     return pBuffer;
 298 }
 299
 300 /* Send args to the OOo instance (using the 'fd' file descriptor) */
 301 static sal_Bool
 302 send_args( int fd, rtl_uString *pCwdPath )
 303 {
 304     rtl_uString *pBuffer = NULL, *pTmp = NULL;
 305     sal_Int32 nCapacity = 1000;
 306     rtl_String *pOut = NULL;
 307     sal_Bool bResult;
 308     size_t nLen;
 309     rtl_uString *pEscapedCwdPath = escape_path( pCwdPath );
 310
 311     rtl_uString_new_WithLength( &pBuffer, nCapacity );
 312     rtl_uString_new( &pTmp );
 313
 314     rtl_uStringbuffer_insert_ascii( &pBuffer, &nCapacity,
 315             rtl_uString_getLength( pBuffer ),
 316             RTL_CONSTASCII_STRINGPARAM( "InternalIPC::Arguments" ) );
 317
 318     if ( rtl_uString_getLength( pEscapedCwdPath ) )
 319     {
 320         rtl_uStringbuffer_insert_ascii( &pBuffer, &nCapacity,
 321                 rtl_uString_getLength( pBuffer ),
 322                 RTL_CONSTASCII_STRINGPARAM( "1" ) );
 323         rtl_uStringbuffer_insert( &pBuffer, &nCapacity,
 324                 rtl_uString_getLength( pBuffer ),
 325                 rtl_uString_getStr( pEscapedCwdPath ),
 326                 rtl_uString_getLength( pEscapedCwdPath ) );
 327     }
 328     else
 329         rtl_uStringbuffer_insert_ascii( &pBuffer, &nCapacity,
 330                 rtl_uString_getLength( pBuffer ),
 331                 RTL_CONSTASCII_STRINGPARAM( "0" ) );
 332
 333     sal_Bool bDontConvertNext = sal_False;
 334     sal_uInt32 nArg;
 335     sal_uInt32 nArgCount = osl_getCommandArgCount();
 336     for ( nArg = 0; nArg < nArgCount; ++nArg )
 337     {
 338         rtl_uStringbuffer_insert_ascii( &pBuffer, &nCapacity,
 339                 rtl_uString_getLength( pBuffer ),
 340                 ",", 1 );
 341
 342         osl_getCommandArg( nArg, &pTmp );
 343
 344         if ( rtl_uString_getLength( pTmp ) == 0 )
 345             continue;
 346
 347         // this is not a param, we have to prepend filenames with file://
 348         // FIXME: improve the check
 349         if ( ( pTmp->buffer[0] != (sal_Unicode)'-' ) &&
 350              ( rtl_ustr_indexOfAscii_WithLength( pTmp->buffer, pTmp->length, "slot:", 5 /* length */ ) ) )
 351         {
 352             sal_Int32 nFirstColon = rtl_ustr_indexOfChar_WithLength( pTmp->buffer, pTmp->length, ':' );
 353             sal_Int32 nFirstSlash = rtl_ustr_indexOfChar_WithLength( pTmp->buffer, pTmp->length, '/' );
 354
 355             // check that pTmp is not an URI yet
 356             if ( nFirstColon < 1 || ( nFirstSlash != nFirstColon + 1 ) )
 357             {
 358                 // some of the switches (currently just -pt) don't want to
 359                 // have the filenames as URIs
 360                 if ( !bDontConvertNext )
 361                     osl_getAbsoluteFileURL( pCwdPath, pTmp, &pTmp );
 362             }
 363         }
 364
 365         // don't convert filenames with some of the switches
 366         // (currently just -pt)
 367         bDontConvertNext = !rtl_ustr_ascii_compareIgnoreAsciiCase( pTmp->buffer, "-pt" );
 368
 369         rtl_uString *pEscapedTmp = escape_path( pTmp );
 370
 371         rtl_uStringbuffer_insert( &pBuffer, &nCapacity,
 372                 rtl_uString_getLength( pBuffer ),
 373                 rtl_uString_getStr( pEscapedTmp ),
 374                 rtl_uString_getLength( pEscapedTmp ) );
 375
 376         rtl_uString_release( pEscapedTmp );
 377     }
 378
 379     ustr_debug( "Pass args", pBuffer );
 380
 381     pOut = ustr_to_str( pBuffer );
 382
 383     nLen = rtl_string_getLength( pOut ) + 1;
 384     bResult = ( write( fd, rtl_string_getStr( pOut ), nLen ) == (ssize_t) nLen );
 385
 386     /* cleanup */
 387     rtl_uString_release( pEscapedCwdPath );
 388     rtl_uString_release( pBuffer );
 389     rtl_uString_release( pTmp );
 390     rtl_string_release( pOut );
 391
 392     return bResult;
 393 }
 394
 395 /* Load the splash bitmap. */
 396 static void
 397 load_splash_image( rtl_uString *pImagePath )
 398 {
 399     rtl_uString *pPath = NULL, *pBitmaps = NULL, *pTmp = NULL;
 400     rtl_uString *pToken = NULL, *pFilename = NULL;
 401
 402     sal_Int32 nIndex = 0;
 403
 404     /* setup values */
 405     rtl_uString_newFromString( &pPath, pImagePath );
 406     rtl_uString_newFromAscii( &pTmp, "/" );
 407     rtl_uString_newConcat( &pPath, pPath, pTmp );
 408
 409     rtl_uString_newFromAscii( &pBitmaps, INTRO_BITMAP_STRINGLIST );
 410     rtl_uString_newFromAscii( &pTmp, ",intro.bmp" );
 411     rtl_uString_newConcat( &pBitmaps, pBitmaps, pTmp );
 412
 413     /* try all the bitmaps from INTRO_BITMAP_STRINGLIST
 414        (and the intro.bmp fallback) */
 415     while ( nIndex >= 0 )
 416     {
 417         nIndex = rtl_uString_getToken( &pToken, pBitmaps, 0, ',', nIndex );
 418         rtl_uString_newConcat( &pFilename, pPath, pToken );
 419
 420         if ( rtl_uString_getLength( pToken ) > 0 )
 421         {
 422             rtl_String *pFilenameStr = ustr_to_str( pFilename );
 423             sal_Bool bLoaded = splash_load_bmp( rtl_string_getStr( pFilenameStr ) );
 424             rtl_string_release( pFilenameStr );
 425
 426             if ( bLoaded )
 427                 break;
 428         }
 429     }
 430
 431     /* cleanup */
 432     rtl_uString_release( pPath );
 433     rtl_uString_release( pBitmaps );
 434     rtl_uString_release( pTmp );
 435     rtl_uString_release( pToken );
 436     rtl_uString_release( pFilename );
 437 }
 438
 439 /* Fill 'array' with values of the key 'name'.
 440    Its value is a comma delimited list of integers */
 441 static void
 442 get_bootstrap_value( int *array, int size, rtlBootstrapHandle handle, const char *name )
 443 {
 444     rtl_uString *pKey = NULL, *pValue = NULL;
 445     sal_Int32 nIndex = 0;
 446     int i = 0;
 447
 448     /* get the value from the ini file */
 449     rtl_uString_newFromAscii( &pKey, name );
 450     rtl_bootstrap_get_from_handle( handle, pKey, &pValue, NULL );
 451
 452     /* the value is several numbers delimited by ',' - parse it */
 453     if ( rtl_uString_getLength( pValue ) > 0 )
 454     {
 455         rtl_uString *pToken = NULL;
 456
 457         for ( ; ( nIndex >= 0 ) && ( i < size ); ++i )
 458         {
 459             nIndex = rtl_uString_getToken( &pToken, pValue, 0, ',', nIndex );
 460             array[i] = rtl_ustr_toInt32( rtl_uString_getStr( pToken ), 10 );
 461         }
 462
 463         rtl_uString_release( pToken );
 464     }
 465
 466     /* cleanup */
 467     rtl_uString_release( pKey );
 468     rtl_uString_release( pValue );
 469 }
 470
 471 /* Load the colors and size of the splash. */
 472 static void
 473 load_splash_defaults( rtl_uString *pAppPath, sal_Bool *pInhibitSplash )
 474 {
 475     rtl_uString *pSettings = NULL, *pTmp = NULL;
 476     rtlBootstrapHandle handle;
 477
 478     /* costruct the sofficerc file location */
 479     rtl_uString_newFromAscii( &pSettings, "file://" );
 480     rtl_uString_newConcat( &pSettings, pSettings, pAppPath );
 481     rtl_uString_newFromAscii( &pTmp, "/" );
 482     rtl_uString_newConcat( &pSettings, pSettings, pTmp );
 483     rtl_uString_newFromAscii( &pTmp, SAL_CONFIGFILE( "soffice" ) );
 484     rtl_uString_newConcat( &pSettings, pSettings, pTmp );
 485
 486     /* use it as the bootstrap file */
 487     handle = rtl_bootstrap_args_open( pSettings );
 488
 489     int logo[1] =  { -1 },
 490         bar[3] =   { -1, -1, -1 },
 491         frame[3] = { -1, -1, -1 },
 492         pos[2] =   { -1, -1 },
 493         size[2] =  { -1, -1 };
 494
 495     /* get the values */
 496     get_bootstrap_value( logo,  1, handle, "Logo" );
 497     get_bootstrap_value( bar,   3, handle, "ProgressBarColor" );
 498     get_bootstrap_value( frame, 3, handle, "ProgressFrameColor" );
 499     get_bootstrap_value( pos,   2, handle, "ProgressPosition" );
 500     get_bootstrap_value( size,  2, handle, "ProgressSize" );
 501
 502     if ( logo[0] == 0 )
 503         *pInhibitSplash = sal_True;
 504
 505     splash_setup( bar, frame, pos[0], pos[1], size[0], size[1] );
 506
 507     /* cleanup */
 508     rtl_bootstrap_args_close( handle );
 509     rtl_uString_release( pSettings );
 510     rtl_uString_release( pTmp );
 511 }
 512
 513 #define BUFFER_LEN 255
 514
 515 /* Read the percent to show in splash. */
 516 static sal_Bool
 517 read_percent( int status_fd, int *pPercent )
 518 {
 519     static char pBuffer[BUFFER_LEN + 1];
 520     static char *pNext = pBuffer;
 521     static ssize_t nRead = 0;
 522
 523     char *pBegin;
 524     char *pIter;
 525
 526     /* from the last call */
 527     int nNotProcessed = nRead - ( pNext - pBuffer );
 528     if ( nNotProcessed >= BUFFER_LEN )
 529         return sal_False;
 530
 531     memmove( pBuffer, pNext, nNotProcessed );
 532
 533     /* read data */
 534     nRead = read( status_fd, pBuffer + nNotProcessed, BUFFER_LEN - nNotProcessed );
 535     if ( nRead < 0 )
 536         return sal_False;
 537
 538     nRead += nNotProcessed;
 539     pBuffer[nRead] = '\0';
 540
 541     /* skip old data */
 542     pBegin = pBuffer;
 543     pNext = pBuffer;
 544     for ( pIter = pBuffer; *pIter; ++pIter )
 545         if ( *pIter == '\n' )
 546         {
 547             pBegin = pNext;
 548             pNext = pIter + 1;
 549         }
 550
 551 #if OSL_DEBUG_LEVEL > 0
 552     fprintf( stderr, "Got status: %s\n", pBegin );
 553 #endif
 554     if ( !strncasecmp( pBegin, "end", 3 ) )
 555         return sal_False;
 556     else if ( sscanf( pBegin, "%d%%", pPercent ) )
 557         return sal_True;
 558
 559     return sal_False;
 560 }
 561
 562 /* Periodically update the splash & the percent acconding to what
 563    status_fd says */
 564 static void
 565 show_splash( int status_fd )
 566 {
 567     int nRetval;
 568     struct pollfd aPfd;
 569
 570     int nPercent = 0;
 571     sal_Bool bFinish = sal_False;
 572
 573     /* we want to watch status_fd */
 574     aPfd.fd = status_fd;
 575     aPfd.events = POLLIN;
 576
 577 #if OSL_DEBUG_LEVEL > 0
 578     fprintf( stderr, "Starting main loop, status fd: %d\n", status_fd );
 579 #endif
 580
 581     /* main loop */
 582     do {
 583         splash_draw_progress( nPercent );
 584
 585         /* read from pipe if data available */
 586         nRetval = poll( &aPfd, 1, 50 );
 587         if ( aPfd.revents & ( POLLERR | POLLHUP | POLLNVAL ) )
 588             bFinish = sal_True;
 589         else if ( nRetval > 0 )
 590             bFinish = !read_percent( status_fd, &nPercent );
 591         else if ( nRetval < 0 )
 592             bFinish = sal_True;
 593     } while ( !bFinish );
 594 }
 595
 596 /* Simple system check. */
 597 static void
 598 system_checks( void )
 599 {
 600 #ifdef LINUX
 601     struct stat buf;
 602
 603     /* check proc is mounted - lots of things fail otherwise */
 604     if ( stat( "/proc/version", &buf ) != 0 )
 605     {
 606         fprintf( stderr, "ERROR: /proc not mounted - OO.o is unlikely to work well if at all" );
 607         exit( 1 );
 608     }
 609 #endif
 610 }
 611
 612 /* Start the OOo application */
 613 static sal_Bool
 614 fork_app( rtl_uString *pAppPath, int *status_fd )
 615 {
 616     rtl_uString *pApp = NULL, *pTmp = NULL, *pArg = NULL;
 617     rtl_uString **ppArgs;
 618     sal_uInt32 nArgs, i;
 619
 620     oslProcess aProcess;
 621     oslProcessError nError;
 622     int status_pipe[2];
 623
 624     system_checks();
 625
 626     /* application name */
 627     rtl_uString_newFromAscii( &pApp, "file://" );
 628     rtl_uString_newConcat( &pApp, pApp, pAppPath );
 629     rtl_uString_newFromAscii( &pTmp, "/soffice.bin" );
 630     rtl_uString_newConcat( &pApp, pApp, pTmp );
 631
 632     rtl_uString_new( &pTmp );
 633
 634     /* copy args */
 635     nArgs = osl_getCommandArgCount();
 636     ppArgs = (rtl_uString **)calloc( nArgs + 1, sizeof( rtl_uString* ) );
 637     for ( i = 0; i < nArgs; ++i )
 638     {
 639         ppArgs[i] = NULL;
 640         osl_getCommandArg( i, &pTmp );
 641
 642         rtl_uString_newFromString( &(ppArgs[i]), pTmp );
 643     }
 644
 645     /* create pipe */
 646     if ( pipe( status_pipe ) < 0 )
 647     {
 648         fprintf( stderr, "ERROR: no file handles\n");
 649         exit( 1 );
 650     }
 651
 652     /* add the pipe arg */
 653     sal_Unicode pUnicode[RTL_USTR_MAX_VALUEOFINT32];
 654     rtl_ustr_valueOfInt32( pUnicode, status_pipe[1], 10 );
 655
 656     rtl_uString_newFromAscii( &pArg, "-splash-pipe=" );
 657     rtl_uString_newFromStr( &pTmp, pUnicode );
 658     rtl_uString_newConcat( &pArg, pArg, pTmp );
 659
 660     ppArgs[nArgs] = NULL;
 661     rtl_uString_newFromString( &(ppArgs[nArgs]), pArg );
 662     ++nArgs;
 663
 664     /* start the OOo process */
 665     nError = osl_executeProcess( pApp, ppArgs, nArgs,
 666             osl_Process_DETACHED | osl_Process_NORMAL,
 667             NULL,
 668             NULL,
 669             NULL, 0,
 670             &aProcess );
 671
 672     *status_fd = status_pipe[0];
 673     close( status_pipe[1] );
 674
 675     if ( nError != osl_Process_E_None )
 676     {
 677         fprintf( stderr, "ERROR %d forking process", nError );
 678         ustr_debug( "", pApp );
 679         return sal_False;
 680     }
 681
 682     return sal_True;
 683 }
 684
 685 /* Check if 'pArg' is -pCmpWith or --pCmpWith */
 686 static sal_Bool
 687 arg_check( rtl_uString *pArg, const char *pCmpWith )
 688 {
 689     sal_Unicode *pUnicode = rtl_uString_getStr( pArg );
 690
 691     if ( pUnicode[0] == (sal_Unicode)'-' )
 692         pUnicode++;
 693     else
 694         return sal_False;
 695
 696     /* tolerate -- prefixes etc. */
 697     if ( pUnicode[0] == (sal_Unicode)'-' )
 698         pUnicode++;
 699
 700     return !rtl_ustr_ascii_compare( pUnicode, pCmpWith );
 701 }
 702
 703 static const char *ppInhibit[] = {
 704     "nologo", "headless", "invisible", "help", "h", "?", "minimized",
 705     NULL };
 706 static const char *ppTwoArgs[] = {
 707     "pt", "display",
 708     NULL };
 709
 710 /* Read command line parameters and return whether we display the splash. */
 711 static sal_Bool
 712 get_inhibit_splash()
 713 {
 714     rtl_uString *pTmp = NULL;
 715     sal_Bool bSkipNextArg = sal_False;
 716     const char **ppIter;
 717
 718     rtl_uString_new( &pTmp );
 719
 720     sal_uInt32 nArg;
 721     sal_uInt32 nArgCount = osl_getCommandArgCount();
 722     for ( nArg = 0; nArg < nArgCount; ++nArg )
 723     {
 724         if ( bSkipNextArg )
 725         {
 726             bSkipNextArg = sal_False;
 727             continue;
 728         }
 729
 730         osl_getCommandArg( nArg, &pTmp );
 731
 732         /* check for inhibit splash params */
 733         for ( ppIter = ppInhibit; *ppIter; ++ppIter )
 734         {
 735             if ( arg_check( pTmp, *ppIter ) )
 736             {
 737                 rtl_uString_release( pTmp );
 738                 return sal_True;
 739             }
 740         }
 741         /* check for 2 arguments params */
 742         for ( ppIter = ppTwoArgs; *ppIter; ++ppIter )
 743         {
 744             if ( arg_check( pTmp, *ppIter ) )
 745             {
 746                 bSkipNextArg = sal_True;
 747                 break;
 748             }
 749         }
 750     }
 751
 752     /* cleanup */
 753     rtl_uString_release( pTmp );
 754
 755     return sal_False;
 756 }
 757
 758 SAL_IMPLEMENT_MAIN_WITH_ARGS( argc, argv )
 759 {
 760     int fd = 0, status_fd = 0;
 761     sal_Bool bInhibitSplash;
 762     sal_Bool bSentArgs = sal_False;
 763     rtl_uString *pAppPath = NULL;
 764     rtl_uString *pPipePath = NULL;
 765
 766     /* turn SIGPIPE into an error */
 767     signal( SIGPIPE, SIG_IGN );
 768
 769     bInhibitSplash = get_inhibit_splash();
 770
 771     pAppPath = get_app_path( argv[0] );
 772     if ( !pAppPath )
 773     {
 774         fprintf( stderr, "ERROR: Can't read app link\n" );
 775         exit( 1 );
 776     }
 777     ustr_debug( "App path", pAppPath );
 778
 779     pPipePath = get_pipe_path( pAppPath );
 780
 781     if ( ( fd = connect_pipe( pPipePath ) ) >= 0 )
 782     {
 783         rtl_uString *pCwdPath = NULL;
 784         osl_getProcessWorkingDir( &pCwdPath );
 785
 786         bSentArgs = send_args( fd, pCwdPath );
 787     }
 788 #if OSL_DEBUG_LEVEL > 0
 789     else
 790         ustr_debug( "Failed to connect to pipe", pPipePath );
 791 #endif
 792
 793     if ( !bSentArgs )
 794     {
 795         if ( !fork_app( pAppPath, &status_fd ) )
 796             return 1;
 797
 798         if ( !bInhibitSplash )
 799         {
 800             load_splash_image( pAppPath );
 801             load_splash_defaults( pAppPath, &bInhibitSplash );
 802         }
 803
 804         if ( !bInhibitSplash && splash_create_window( argc, argv ) )
 805         {
 806             splash_draw_progress( 0 );
 807             show_splash( status_fd );
 808             splash_close_window();
 809         }
 810     }
 811
 812     /* cleanup */
 813     rtl_uString_release( pAppPath );
 814     rtl_uString_release( pPipePath );
 815
 816     close( fd );
 817     close( status_fd );
 818
 819     return 0;
 820 }