LCOV - code coverage report
Current view: top level - odk/source/unoapploader/unx - unoapploader.c (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 109 0.0 %
Date: 2014-04-14 Functions: 0 3 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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 <stdlib.h>
      21             : #include <unistd.h>
      22             : #include <stdio.h>
      23             : #include <string.h>
      24             : #include <sys/stat.h>
      25             : 
      26             : #ifdef LINUX
      27             : #define __USE_GNU
      28             : #endif
      29             : #include <dlfcn.h>
      30             : 
      31             : #include "cppuhelper/findsofficepath.h"
      32             : #include "rtl/string.h"
      33             : #include "sal/types.h"
      34             : 
      35             : char const* getPath();
      36             : char* createCommandName( char* argv0 );
      37             : 
      38             : const int SEPARATOR = '/';
      39             : const char* PATHSEPARATOR = ":";
      40             : 
      41             : 
      42             : /*
      43             :  * The main function implements a loader for applications which use UNO.
      44             :  *
      45             :  * <p>This code runs on the Unix/Linux platforms only.</p>
      46             :  *
      47             :  * <p>The main function detects a UNO installation on the system and adds the
      48             :  * relevant directories of the installation to the LD_LIBRARY_PATH environment
      49             :  * variable. After that, the application process is loaded and started, whereby
      50             :  * the new process inherits the environment of the calling process, including
      51             :  * the modified LD_LIBRARY_PATH environment variable. The application's
      52             :  * executable name must be the same as the name of this executable, prefixed
      53             :  * by '_'.</p>
      54             :  * <p>On MACOSX DYLD_LIBRARY_PATH is used instead of LD_LIBRARY_PATH!<p>
      55             :  *
      56             :  * <p>A UNO installation can be specified by the user by setting the UNO_PATH
      57             :  * environment variable to the program directory of the UNO installation.
      58             :  * If no installation is specified by the user, the default installation on
      59             :  * the system will be taken. The default installation is found from the
      60             :  * PATH environment variable. This requires that the 'soffice' executable or
      61             :  * a symbolic link is in one of the directories listed in the PATH environment
      62             :  * variable.</p>
      63             :  */
      64           0 : int main( int argc, char *argv[] )
      65             : {
      66             :     char const* path;
      67             :     char* cmdname;
      68             : 
      69             :     (void) argc; /* avoid warning about unused parameter */
      70             : 
      71             :     /* get the path of the UNO installation */
      72           0 :     path = getPath();
      73             : 
      74           0 :     if ( path != NULL )
      75             :     {
      76             : #if defined(MACOSX)
      77             :         static const char* ENVVARNAME = "DYLD_LIBRARY_PATH";
      78             : #elif defined(AIX)
      79             :         static const char* ENVVARNAME = "LIBPATH";
      80             : #else
      81             :         static const char* ENVVARNAME = "LD_LIBRARY_PATH";
      82             : #endif
      83             :         char * libpath;
      84             :         int freeLibpath;
      85             : 
      86             :         char* value;
      87             :         char* envstr;
      88             :         int size;
      89             : 
      90           0 :         size_t pathlen = strlen(path);
      91             :         struct stat stats;
      92             :         int ret;
      93             : 
      94             :         static char const unoinfoSuffix[] = "/unoinfo";
      95           0 :         char * unoinfo = malloc(
      96           0 :             pathlen + RTL_CONSTASCII_LENGTH(unoinfoSuffix) + 1);
      97             :             /*TODO: overflow */
      98           0 :         if (unoinfo == NULL) {
      99           0 :             fprintf(stderr, "Error: out of memory!\n");
     100           0 :             exit(EXIT_FAILURE);
     101             :         }
     102           0 :         strcpy(unoinfo, path);
     103           0 :         strcpy(
     104             :             unoinfo + pathlen,
     105           0 :             unoinfoSuffix + (pathlen == 0 || path[pathlen - 1] != '/' ? 0 : 1));
     106           0 :         ret = lstat(unoinfo, &stats);
     107           0 :         free(unoinfo);
     108             : 
     109           0 :         if (ret == 0) {
     110           0 :             char * cmd = malloc(
     111           0 :                 2 * pathlen + RTL_CONSTASCII_LENGTH("/unoinfo c++") + 1);
     112             :                 /*TODO: overflow */
     113             :             char const * p;
     114             :             char * q;
     115             :             FILE * f;
     116           0 :             size_t n = 1000;
     117           0 :             size_t old = 0;
     118           0 :             if (cmd == NULL) {
     119           0 :                 fprintf(stderr, "Error: out of memory!\n");
     120           0 :                 exit(EXIT_FAILURE);
     121             :             }
     122           0 :             p = path;
     123           0 :             q = cmd;
     124           0 :             while (*p != '\0') {
     125           0 :                 *q++ = '\\';
     126           0 :                 *q++ = *p++;
     127             :             }
     128           0 :             if (p == path || p[-1] != '/') {
     129           0 :                 *q++ = '/';
     130             :             }
     131           0 :             strcpy(q, "unoinfo c++");
     132           0 :             f = popen(cmd, "r");
     133           0 :             free(cmd);
     134           0 :             if (f == NULL)
     135             :             {
     136           0 :                 fprintf(stderr, "Error: calling unoinfo failed!\n");
     137           0 :                 exit(EXIT_FAILURE);
     138             :             }
     139           0 :             libpath = NULL;
     140             :             for (;;) {
     141             :                 size_t m;
     142           0 :                 libpath = realloc(libpath, n);
     143           0 :                 if (libpath == NULL) {
     144           0 :                     fprintf(
     145             :                         stderr,
     146             :                         "Error: out of memory reading unoinfo output!\n");
     147           0 :                     exit(EXIT_FAILURE);
     148             :                 }
     149           0 :                 m = fread(libpath + old, 1, n - old - 1, f);
     150           0 :                 if (m != n - old - 1) {
     151           0 :                     if (ferror(f)) {
     152           0 :                         fprintf(stderr, "Error: cannot read unoinfo output!\n");
     153           0 :                         exit(EXIT_FAILURE);
     154             :                     }
     155           0 :                     libpath[old + m] = '\0';
     156           0 :                     break;
     157             :                 }
     158           0 :                 if (n >= SAL_MAX_SIZE / 2) {
     159           0 :                     fprintf(
     160             :                         stderr,
     161             :                         "Error: out of memory reading unoinfo output!\n");
     162           0 :                     exit(EXIT_FAILURE);
     163             :                 }
     164           0 :                 old = n - 1;
     165           0 :                 n *= 2;
     166           0 :             }
     167           0 :             if (pclose(f) != 0) {
     168           0 :                 fprintf(stderr, "Error: executing unoinfo failed!\n");
     169           0 :                 exit(EXIT_FAILURE);
     170             :             }
     171           0 :             freeLibpath = 1;
     172             :         }
     173             :         else
     174             :         {
     175             :             /* Assume an old OOo 2.x installation without unoinfo: */
     176           0 :             libpath = (char *) path;
     177           0 :             freeLibpath = 0;
     178             :         }
     179             : 
     180           0 :         value = getenv( ENVVARNAME );
     181             : 
     182             :         // workaround for finding wrong libsqlite3.dylib in the office installation
     183             :         // For MacOS > 10.6 nss uses the system lib -> unresolved symbol _sqlite3_wal_checkpoint
     184             : #ifdef MACOSX
     185             :         size = strlen( ENVVARNAME ) + strlen( "=/usr/lib:" ) + strlen( libpath ) + 1;
     186             : #else
     187           0 :         size = strlen( ENVVARNAME ) + strlen( "=" ) + strlen( libpath ) + 1;
     188             : #endif
     189           0 :         if ( value != NULL )
     190           0 :             size += strlen( PATHSEPARATOR ) + strlen( value );
     191           0 :         envstr = (char*) malloc( size );
     192           0 :         strcpy( envstr, ENVVARNAME );
     193             : #ifdef MACOSX
     194             :         strcat( envstr, "=/usr/lib:" );
     195             : #else
     196           0 :         strcat( envstr, "=" );
     197             : #endif
     198           0 :         strcat( envstr, libpath );
     199           0 :         if ( freeLibpath != 0 )
     200             :         {
     201           0 :             free( libpath );
     202             :         }
     203           0 :         if ( value != NULL )
     204             :         {
     205           0 :             strcat( envstr, PATHSEPARATOR );
     206           0 :             strcat( envstr, value );
     207             :         }
     208           0 :         putenv( envstr );
     209             :     }
     210             :     else
     211             :     {
     212           0 :         fprintf( stderr, "Warning: no office installation found!\n" );
     213           0 :         fflush( stderr );
     214             :     }
     215             : 
     216             :     /* set the executable name for the application process */
     217           0 :     cmdname = createCommandName( argv[0] );
     218           0 :     argv[0] = cmdname;
     219             : 
     220             :     /*
     221             :      * create the application process;
     222             :      * if successful, execvp doesn't return to the calling process
     223             :      */
     224           0 :     execvp( cmdname, argv );
     225           0 :     fprintf( stderr, "Error: execvp failed!\n" );
     226           0 :     fflush( stderr );
     227             : 
     228           0 :     return 0;
     229             : }
     230             : 
     231             : /*
     232             :  * Gets the path of a UNO installation.
     233             :  *
     234             :  * @return the installation path or NULL, if no installation was specified or
     235             :  *         found, or if an error occurred
     236             :  */
     237           0 : char const* getPath()
     238             : {
     239           0 :     char const* path = cppuhelper_detail_findSofficePath();
     240             : 
     241           0 :     if ( path == NULL )
     242             :     {
     243           0 :         fprintf( stderr, "Warning: getting path from PATH environment "
     244             :                  "variable failed!\n" );
     245           0 :         fflush( stderr );
     246             :     }
     247             : 
     248           0 :     return path;
     249             : }
     250             : 
     251             : /*
     252             :  * Creates the application's executable file name.
     253             :  *
     254             :  * <p>The application's executable file name is the name of this executable
     255             :  * prefixed by '_'.</p>
     256             :  *
     257             :  * @param argv0 specifies the argv[0] parameter of the main function
     258             :  *
     259             :  * @return the application's executable file name or NULL, if an error occurred
     260             :  */
     261           0 : char* createCommandName( char* argv0 )
     262             : {
     263           0 :     const char* CMDPREFIX = "_";
     264           0 :     const char* prgname = NULL;
     265             : 
     266           0 :     char* cmdname = NULL;
     267           0 :     char* sep = NULL;
     268             : #ifndef AIX
     269             :     Dl_info dl_info;
     270             : #endif
     271             : 
     272             :     /* get the executable file name from argv0 */
     273           0 :     prgname = argv0;
     274             : 
     275             : #ifndef AIX
     276             :     /*
     277             :      * if argv0 doesn't contain an absolute path name, try to get the absolute
     278             :      * path name from dladdr; note that this only works for Solaris, not for
     279             :      * Linux
     280             :      */
     281           0 :     if ( argv0 != NULL && *argv0 != SEPARATOR &&
     282           0 :          dladdr( (void*) &createCommandName, &dl_info ) &&
     283           0 :          dl_info.dli_fname != NULL && *dl_info.dli_fname == SEPARATOR )
     284             :     {
     285           0 :         prgname = dl_info.dli_fname;
     286             :     }
     287             : #endif
     288             : 
     289             :     /* prefix the executable file name by '_' */
     290           0 :     if ( prgname != NULL )
     291             :     {
     292           0 :         cmdname = (char*) malloc( strlen( prgname ) + strlen( CMDPREFIX ) + 1 );
     293           0 :         sep = strrchr( prgname, SEPARATOR );
     294           0 :         if ( sep != NULL )
     295             :         {
     296           0 :             int pos = ++sep - prgname;
     297           0 :             strncpy( cmdname, prgname, pos );
     298           0 :             cmdname[ pos ] = '\0';
     299           0 :             strcat( cmdname, CMDPREFIX );
     300           0 :             strcat( cmdname, sep );
     301             :         }
     302             :         else
     303             :         {
     304           0 :             strcpy( cmdname, CMDPREFIX );
     305           0 :             strcat( cmdname, prgname );
     306             :         }
     307             :     }
     308             : 
     309           0 :     return cmdname;
     310             : }
     311             : 
     312             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10