lib/progreloc.c

   1 /* Provide relocatable programs.
   2    Copyright (C) 2003-2008 Free Software Foundation, Inc.
   3    Written by Bruno Haible <bruno@clisp.org>, 2003.
   4
   5    This program is free software: you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 3 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  17
  18
  19 #include <config.h>
  20
  21 /* Specification.  */
  22 #include "progname.h"
  23
  24 #include <stdbool.h>
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <fcntl.h>
  29 #include <unistd.h>
  30 #include <sys/stat.h>
  31
  32 /* Get declaration of _NSGetExecutablePath on MacOS X 10.2 or newer.  */
  33 #if HAVE_MACH_O_DYLD_H
  34 # include <mach-o/dyld.h>
  35 #endif
  36
  37 #if defined _WIN32 || defined __WIN32__
  38 # define WIN32_NATIVE
  39 #endif
  40
  41 #if defined WIN32_NATIVE || defined __CYGWIN__
  42 # define WIN32_LEAN_AND_MEAN
  43 # include <windows.h>
  44 #endif
  45
  46 #include "canonicalize.h"
  47 #include "relocatable.h"
  48
  49 #ifdef NO_XMALLOC
  50 # include "areadlink.h"
  51 # define xreadlink areadlink
  52 #else
  53 # include "xreadlink.h"
  54 #endif
  55
  56 #ifdef NO_XMALLOC
  57 # define xmalloc malloc
  58 # define xstrdup strdup
  59 #else
  60 # include "xalloc.h"
  61 #endif
  62
  63 /* Pathname support.
  64    ISSLASH(C)           tests whether C is a directory separator character.
  65    IS_PATH_WITH_DIR(P)  tests whether P contains a directory specification.
  66  */
  67 #if defined _WIN32 || defined __WIN32__ || defined __CYGWIN__ || defined __EMX__ || defined __DJGPP__
  68   /* Win32, Cygwin, OS/2, DOS */
  69 # define ISSLASH(C) ((C) == '/' || (C) == '\\')
  70 # define HAS_DEVICE(P) \
  71     ((((P)[0] >= 'A' && (P)[0] <= 'Z') || ((P)[0] >= 'a' && (P)[0] <= 'z')) \
  72      && (P)[1] == ':')
  73 # define IS_PATH_WITH_DIR(P) \
  74     (strchr (P, '/') != NULL || strchr (P, '\\') != NULL || HAS_DEVICE (P))
  75 # define FILE_SYSTEM_PREFIX_LEN(P) (HAS_DEVICE (P) ? 2 : 0)
  76 #else
  77   /* Unix */
  78 # define ISSLASH(C) ((C) == '/')
  79 # define IS_PATH_WITH_DIR(P) (strchr (P, '/') != NULL)
  80 # define FILE_SYSTEM_PREFIX_LEN(P) 0
  81 #endif
  82
  83 /* The results of open() in this file are not used with fchdir,
  84    therefore save some unnecessary work in fchdir.c.  */
  85 #undef open
  86 #undef close
  87
  88 #undef set_program_name
  89
  90
  91 #if ENABLE_RELOCATABLE
  92
  93 #ifdef __linux__
  94 /* File descriptor of the executable.
  95    (Only used to verify that we find the correct executable.)  */
  96 static int executable_fd = -1;
  97 #endif
  98
  99 /* Tests whether a given pathname may belong to the executable.  */
 100 static bool
 101 maybe_executable (const char *filename)
 102 {
 103   /* Woe32 lacks the access() function, but Cygwin doesn't.  */
 104 #if !(defined WIN32_NATIVE && !defined __CYGWIN__)
 105   if (access (filename, X_OK) < 0)
 106     return false;
 107
 108 #ifdef __linux__
 109   if (executable_fd >= 0)
 110     {
 111       /* If we already have an executable_fd, check that filename points to
 112          the same inode.  */
 113       struct stat statexe;
 114       struct stat statfile;
 115
 116       if (fstat (executable_fd, &statexe) >= 0)
 117         {
 118           if (stat (filename, &statfile) < 0)
 119             return false;
 120           if (!(statfile.st_dev
 121                 && statfile.st_dev == statexe.st_dev
 122                 && statfile.st_ino == statexe.st_ino))
 123             return false;
 124         }
 125     }
 126 #endif
 127 #endif
 128
 129   return true;
 130 }
 131
 132 /* Determine the full pathname of the current executable, freshly allocated.
 133    Return NULL if unknown.
 134    Guaranteed to work on Linux and Woe32.  Likely to work on the other
 135    Unixes (maybe except BeOS), under most conditions.  */
 136 static char *
 137 find_executable (const char *argv0)
 138 {
 139 #if defined WIN32_NATIVE || defined __CYGWIN__
 140   char location[MAX_PATH];
 141   int length = GetModuleFileName (NULL, location, sizeof (location));
 142   if (length < 0)
 143     return NULL;
 144   if (!IS_PATH_WITH_DIR (location))
 145     /* Shouldn't happen.  */
 146     return NULL;
 147   {
 148 #if defined __CYGWIN__
 149     /* cygwin-1.5.13 (2005-03-01) or newer would also allow a Linux-like
 150        implementation: readlink of "/proc/self/exe".  But using the
 151        result of the Win32 system call is simpler and is consistent with the
 152        code in relocatable.c.  */
 153     /* On Cygwin, we need to convert paths coming from Win32 system calls
 154        to the Unix-like slashified notation.  */
 155     static char location_as_posix_path[2 * MAX_PATH];
 156     /* There's no error return defined for cygwin_conv_to_posix_path.
 157        See cygwin-api/func-cygwin-conv-to-posix-path.html.
 158        Does it overflow the buffer of expected size MAX_PATH or does it
 159        truncate the path?  I don't know.  Let's catch both.  */
 160     cygwin_conv_to_posix_path (location, location_as_posix_path);
 161     location_as_posix_path[MAX_PATH - 1] = '\0';
 162     if (strlen (location_as_posix_path) >= MAX_PATH - 1)
 163       /* A sign of buffer overflow or path truncation.  */
 164       return NULL;
 165     /* Call canonicalize_file_name, because Cygwin supports symbolic links.  */
 166     return canonicalize_file_name (location_as_posix_path);
 167 #else
 168     return xstrdup (location);
 169 #endif
 170   }
 171 #else /* Unix && !Cygwin */
 172 #ifdef __linux__
 173   /* The executable is accessible as /proc/<pid>/exe.  In newer Linux
 174      versions, also as /proc/self/exe.  Linux >= 2.1 provides a symlink
 175      to the true pathname; older Linux versions give only device and ino,
 176      enclosed in brackets, which we cannot use here.  */
 177   {
 178     char *link;
 179
 180     link = xreadlink ("/proc/self/exe");
 181     if (link != NULL && link[0] != '[')
 182       return link;
 183     if (executable_fd < 0)
 184       executable_fd = open ("/proc/self/exe", O_RDONLY, 0);
 185
 186     {
 187       char buf[6+10+5];
 188       sprintf (buf, "/proc/%d/exe", getpid ());
 189       link = xreadlink (buf);
 190       if (link != NULL && link[0] != '[')
 191         return link;
 192       if (executable_fd < 0)
 193         executable_fd = open (buf, O_RDONLY, 0);
 194     }
 195   }
 196 #endif
 197 #if HAVE_MACH_O_DYLD_H && HAVE__NSGETEXECUTABLEPATH
 198   /* On MacOS X 10.2 or newer, the function
 199        int _NSGetExecutablePath (char *buf, unsigned long *bufsize);
 200      can be used to retrieve the executable's full path.  */
 201   char location[4096];
 202   unsigned long length = sizeof (location);
 203   if (_NSGetExecutablePath (location, &length) == 0
 204       && location[0] == '/')
 205     return canonicalize_file_name (location);
 206 #endif
 207   /* Guess the executable's full path.  We assume the executable has been
 208      called via execlp() or execvp() with properly set up argv[0].  The
 209      login(1) convention to add a '-' prefix to argv[0] is not supported.  */
 210   {
 211     bool has_slash = false;
 212     {
 213       const char *p;
 214       for (p = argv0; *p; p++)
 215         if (*p == '/')
 216           {
 217             has_slash = true;
 218             break;
 219           }
 220     }
 221     if (!has_slash)
 222       {
 223         /* exec searches paths without slashes in the directory list given
 224            by $PATH.  */
 225         const char *path = getenv ("PATH");
 226
 227         if (path != NULL)
 228           {
 229             const char *p;
 230             const char *p_next;
 231
 232             for (p = path; *p; p = p_next)
 233               {
 234                 const char *q;
 235                 size_t p_len;
 236                 char *concat_name;
 237
 238                 for (q = p; *q; q++)
 239                   if (*q == ':')
 240                     break;
 241                 p_len = q - p;
 242                 p_next = (*q == '\0' ? q : q + 1);
 243
 244                 /* We have a path item at p, of length p_len.
 245                    Now concatenate the path item and argv0.  */
 246                 concat_name = (char *) xmalloc (p_len + strlen (argv0) + 2);
 247 #ifdef NO_XMALLOC
 248                 if (concat_name == NULL)
 249                   return NULL;
 250 #endif
 251                 if (p_len == 0)
 252                   /* An empty PATH element designates the current directory.  */
 253                   strcpy (concat_name, argv0);
 254                 else
 255                   {
 256                     memcpy (concat_name, p, p_len);
 257                     concat_name[p_len] = '/';
 258                     strcpy (concat_name + p_len + 1, argv0);
 259                   }
 260                 if (maybe_executable (concat_name))
 261                   return canonicalize_file_name (concat_name);
 262                 free (concat_name);
 263               }
 264           }
 265         /* Not found in the PATH, assume the current directory.  */
 266       }
 267     /* exec treats paths containing slashes as relative to the current
 268        directory.  */
 269     if (maybe_executable (argv0))
 270       return canonicalize_file_name (argv0);
 271   }
 272   /* No way to find the executable.  */
 273   return NULL;
 274 #endif
 275 }
 276
 277 /* Full pathname of executable, or NULL.  */
 278 static char *executable_fullname;
 279
 280 static void
 281 prepare_relocate (const char *orig_installprefix, const char *orig_installdir,
 282                   const char *argv0)
 283 {
 284   char *curr_prefix;
 285
 286   /* Determine the full pathname of the current executable.  */
 287   executable_fullname = find_executable (argv0);
 288
 289   /* Determine the current installation prefix from it.  */
 290   curr_prefix = compute_curr_prefix (orig_installprefix, orig_installdir,
 291                                      executable_fullname);
 292   if (curr_prefix != NULL)
 293     {
 294       /* Now pass this prefix to all copies of the relocate.c source file.  */
 295       set_relocation_prefix (orig_installprefix, curr_prefix);
 296
 297       free (curr_prefix);
 298     }
 299 }
 300
 301 /* Set program_name, based on argv[0], and original installation prefix and
 302    directory, for relocatability.  */
 303 void
 304 set_program_name_and_installdir (const char *argv0,
 305                                  const char *orig_installprefix,
 306                                  const char *orig_installdir)
 307 {
 308   const char *argv0_stripped = argv0;
 309
 310   /* Relocatable programs are renamed to .bin by install-reloc.  Or, more
 311      generally, their suffix is changed from $exeext to .bin$exeext.
 312      Remove the ".bin" here.  */
 313   {
 314     size_t argv0_len = strlen (argv0);
 315     const size_t exeext_len = sizeof (EXEEXT) - sizeof ("");
 316     if (argv0_len > 4 + exeext_len)
 317       if (memcmp (argv0 + argv0_len - exeext_len - 4, ".bin", 4) == 0)
 318         {
 319           if (sizeof (EXEEXT) > sizeof (""))
 320             {
 321               /* Compare using an inlined copy of c_strncasecmp(), because
 322                  the filenames may have undergone a case conversion since
 323                  they were packaged.  In other words, EXEEXT may be ".exe"
 324                  on one system and ".EXE" on another.  */
 325               static const char exeext[] = EXEEXT;
 326               const char *s1 = argv0 + argv0_len - exeext_len;
 327               const char *s2 = exeext;
 328               for (; *s1 != '\0'; s1++, s2++)
 329                 {
 330                   unsigned char c1 = *s1;
 331                   unsigned char c2 = *s2;
 332                   if ((c1 >= 'A' && c1 <= 'Z' ? c1 - 'A' + 'a' : c1)
 333                       != (c2 >= 'A' && c2 <= 'Z' ? c2 - 'A' + 'a' : c2))
 334                     goto done_stripping;
 335                 }
 336             }
 337           /* Remove ".bin" before EXEEXT or its equivalent.  */
 338           {
 339             char *shorter = (char *) xmalloc (argv0_len - 4 + 1);
 340 #ifdef NO_XMALLOC
 341             if (shorter != NULL)
 342 #endif
 343               {
 344                 memcpy (shorter, argv0, argv0_len - exeext_len - 4);
 345                 if (sizeof (EXEEXT) > sizeof (""))
 346                   memcpy (shorter + argv0_len - exeext_len - 4,
 347                           argv0 + argv0_len - exeext_len - 4,
 348                           exeext_len);
 349                 shorter[argv0_len - 4] = '\0';
 350                 argv0_stripped = shorter;
 351               }
 352           }
 353          done_stripping: ;
 354       }
 355   }
 356
 357   set_program_name (argv0_stripped);
 358
 359   prepare_relocate (orig_installprefix, orig_installdir, argv0);
 360 }
 361
 362 /* Return the full pathname of the current executable, based on the earlier
 363    call to set_program_name_and_installdir.  Return NULL if unknown.  */
 364 char *
 365 get_full_program_name (void)
 366 {
 367   return executable_fullname;
 368 }
 369
 370 #endif