odk/source/unoapploader/unx/unoapploader.c

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