lib/progreloc.c

   1 /* Provide relocatable programs.
   2    Copyright (C) 2003-2021 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 <https://www.gnu.org/licenses/>.  */
  17
  18
  19 #define _GL_USE_STDLIB_ALLOC 1
  20 #include <config.h>
  21
  22 /* Specification.  */
  23 #include "progname.h"
  24
  25 #include <errno.h>
  26 #include <stdbool.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <fcntl.h>
  31 #include <unistd.h>
  32 #include <sys/stat.h>
  33
  34 /* Get declaration of _NSGetExecutablePath on Mac OS X 10.2 or newer.  */
  35 #if HAVE_MACH_O_DYLD_H
  36 # include <mach-o/dyld.h>
  37 #endif
  38
  39 #if defined _WIN32 && !defined __CYGWIN__
  40 # define WINDOWS_NATIVE
  41 #endif
  42
  43 #ifdef WINDOWS_NATIVE
  44 # define WIN32_LEAN_AND_MEAN
  45 # include <windows.h>
  46 #endif
  47
  48 #ifdef __EMX__
  49 # define INCL_DOS
  50 # include <os2.h>
  51 #endif
  52
  53 #include "relocatable.h"
  54
  55 #ifdef NO_XMALLOC
  56 # include "areadlink.h"
  57 # define xreadlink areadlink
  58 #else
  59 # include "xreadlink.h"
  60 #endif
  61
  62 #ifdef NO_XMALLOC
  63 # define xmalloc malloc
  64 # define xstrdup strdup
  65 #else
  66 # include "xalloc.h"
  67 #endif
  68
  69 #ifndef O_EXEC
  70 # define O_EXEC O_RDONLY /* This is often close enough in older systems.  */
  71 #endif
  72
  73 #if defined IN_RELOCWRAPPER && (!defined O_CLOEXEC || GNULIB_defined_O_CLOEXEC)
  74 # undef O_CLOEXEC
  75 # define O_CLOEXEC 0
  76 #endif
  77
  78 /* Declare canonicalize_file_name.
  79    The <stdlib.h> included above may be the system's one, not the gnulib
  80    one.  */
  81 extern char * canonicalize_file_name (const char *name);
  82
  83 #if defined WINDOWS_NATIVE
  84 /* Don't assume that UNICODE is not defined.  */
  85 # undef GetModuleFileName
  86 # define GetModuleFileName GetModuleFileNameA
  87 #endif
  88
  89 /* Pathname support.
  90    ISSLASH(C)                tests whether C is a directory separator character.
  91    IS_FILE_NAME_WITH_DIR(P)  tests whether P contains a directory specification.
  92  */
  93 #if (defined _WIN32 && !defined __CYGWIN__) || defined __EMX__ || defined __DJGPP__
  94   /* Native Windows, OS/2, DOS */
  95 # define ISSLASH(C) ((C) == '/' || (C) == '\\')
  96 # define HAS_DEVICE(P) \
  97     ((((P)[0] >= 'A' && (P)[0] <= 'Z') || ((P)[0] >= 'a' && (P)[0] <= 'z')) \
  98      && (P)[1] == ':')
  99 # define IS_FILE_NAME_WITH_DIR(P) \
 100     (strchr (P, '/') != NULL || strchr (P, '\\') != NULL || HAS_DEVICE (P))
 101 # define FILE_SYSTEM_PREFIX_LEN(P) (HAS_DEVICE (P) ? 2 : 0)
 102 #else
 103   /* Unix */
 104 # define ISSLASH(C) ((C) == '/')
 105 # define IS_FILE_NAME_WITH_DIR(P) (strchr (P, '/') != NULL)
 106 # define FILE_SYSTEM_PREFIX_LEN(P) 0
 107 #endif
 108
 109 /* Use the system functions, not the gnulib overrides in this file.  */
 110 #undef sprintf
 111
 112 #undef set_program_name
 113
 114
 115 #if ENABLE_RELOCATABLE
 116
 117 #ifdef __sun
 118
 119 /* Helper function, from gnulib module 'safe-read'.  */
 120 static size_t
 121 safe_read (int fd, void *buf, size_t count)
 122 {
 123   for (;;)
 124     {
 125       ssize_t result = read (fd, buf, count);
 126
 127       if (0 <= result || errno != EINTR)
 128         return result;
 129     }
 130 }
 131
 132 /* Helper function, from gnulib module 'full-read'.  */
 133 static size_t
 134 full_read (int fd, void *buf, size_t count)
 135 {
 136   size_t total = 0;
 137   const char *ptr = (const char *) buf;
 138
 139   while (count > 0)
 140     {
 141       size_t n = safe_read (fd, ptr, count);
 142       if (n == (size_t) -1)
 143         break;
 144       if (n == 0)
 145         {
 146           errno = 0;
 147           break;
 148         }
 149       total += n;
 150       ptr += n;
 151       count -= n;
 152     }
 153
 154   return total;
 155 }
 156
 157 #endif
 158
 159 #if defined __linux__ || defined __CYGWIN__
 160 /* File descriptor of the executable.
 161    (Only used to verify that we find the correct executable.)  */
 162 static int executable_fd = -1;
 163 #endif
 164
 165 /* Define this function only when it's needed.  */
 166 #if !(defined WINDOWS_NATIVE || defined __EMX__)
 167
 168 /* Tests whether a given filename may belong to the executable.  */
 169 static bool
 170 maybe_executable (const char *filename)
 171 {
 172   /* The native Windows API lacks the access() function.  */
 173 # if !defined WINDOWS_NATIVE
 174   if (access (filename, X_OK) < 0)
 175     return false;
 176 # endif
 177
 178 # if defined __linux__ || defined __CYGWIN__
 179   if (executable_fd >= 0)
 180     {
 181       /* If we already have an executable_fd, check that filename points to
 182          the same inode.  */
 183       struct stat statexe;
 184       struct stat statfile;
 185
 186       if (fstat (executable_fd, &statexe) >= 0)
 187         return (stat (filename, &statfile) >= 0
 188                 && statfile.st_dev
 189                 && statfile.st_dev == statexe.st_dev
 190                 && statfile.st_ino == statexe.st_ino);
 191     }
 192 # endif
 193
 194   /* Check that the filename does not point to a directory.  */
 195   {
 196     struct stat statfile;
 197
 198     return (stat (filename, &statfile) >= 0
 199             && ! S_ISDIR (statfile.st_mode));
 200   }
 201 }
 202
 203 #endif
 204
 205 /* Determine the full pathname of the current executable, freshly allocated.
 206    Return NULL if unknown.
 207    Guaranteed to work on Linux and native Windows.  Likely to work on the
 208    other Unixes (maybe except BeOS), under most conditions.  */
 209 static char *
 210 find_executable (const char *argv0)
 211 {
 212 #if defined WINDOWS_NATIVE
 213   /* Native Windows only.
 214      On Cygwin, it is better to use the Cygwin provided /proc interface, than
 215      to use native Windows API and cygwin_conv_to_posix_path, because it
 216      supports longer file names
 217      (see <https://cygwin.com/ml/cygwin/2011-01/msg00410.html>).  */
 218   char location[MAX_PATH];
 219   int length = GetModuleFileName (NULL, location, sizeof (location));
 220   if (length < 0)
 221     return NULL;
 222   if (!IS_FILE_NAME_WITH_DIR (location))
 223     /* Shouldn't happen.  */
 224     return NULL;
 225   return xstrdup (location);
 226 #elif defined __EMX__
 227   PPIB ppib;
 228   char location[CCHMAXPATH];
 229
 230   /* See http://cyberkinetica.homeunix.net/os2tk45/cp1/619_L2H_DosGetInfoBlocksSynt.html
 231      for specification of DosGetInfoBlocks().  */
 232   if (DosGetInfoBlocks (NULL, &ppib))
 233     return NULL;
 234
 235   /* See http://cyberkinetica.homeunix.net/os2tk45/cp1/1247_L2H_DosQueryModuleNameSy.html
 236      for specification of DosQueryModuleName().  */
 237   if (DosQueryModuleName (ppib->pib_hmte, sizeof (location), location))
 238     return NULL;
 239
 240   _fnslashify (location);
 241
 242   return xstrdup (location);
 243 #else /* Unix */
 244 # if defined __linux__
 245   /* The executable is accessible as /proc/<pid>/exe.  In newer Linux
 246      versions, also as /proc/self/exe.  Linux >= 2.1 provides a symlink
 247      to the true pathname; older Linux versions give only device and ino,
 248      enclosed in brackets, which we cannot use here.  */
 249   {
 250     char *link;
 251
 252     link = xreadlink ("/proc/self/exe");
 253     if (link != NULL && link[0] != '[')
 254       return link;
 255     if (executable_fd < 0)
 256       executable_fd = open ("/proc/self/exe", O_EXEC | O_CLOEXEC, 0);
 257
 258     {
 259       char buf[6+10+5];
 260       sprintf (buf, "/proc/%d/exe", getpid ());
 261       link = xreadlink (buf);
 262       if (link != NULL && link[0] != '[')
 263         return link;
 264       if (executable_fd < 0)
 265         executable_fd = open (buf, O_EXEC | O_CLOEXEC, 0);
 266     }
 267   }
 268 # endif
 269 # if defined __ANDROID__ || defined __FreeBSD_kernel__
 270   /* On Android and GNU/kFreeBSD, the executable is accessible as
 271      /proc/<pid>/exe and /proc/self/exe.  */
 272   {
 273     char *link;
 274
 275     link = xreadlink ("/proc/self/exe");
 276     if (link != NULL)
 277       return link;
 278   }
 279 # endif
 280 # if defined __FreeBSD__ || defined __DragonFly__
 281   /* In FreeBSD >= 5.0, the executable is accessible as /proc/<pid>/file and
 282      /proc/curproc/file.  */
 283   {
 284     char *link;
 285
 286     link = xreadlink ("/proc/curproc/file");
 287     if (link != NULL)
 288       {
 289         if (strcmp (link, "unknown") != 0)
 290           return link;
 291         free (link);
 292       }
 293   }
 294 # endif
 295 # if defined __NetBSD__
 296   /* In NetBSD >= 4.0, the executable is accessible as /proc/<pid>/exe and
 297      /proc/curproc/exe.  */
 298   {
 299     char *link;
 300
 301     link = xreadlink ("/proc/curproc/exe");
 302     if (link != NULL)
 303       return link;
 304   }
 305 # endif
 306 # if defined __sun
 307   /* On Solaris >= 11.4, /proc/<pid>/execname and /proc/self/execname contains
 308      the name of the executable, either as an absolute file name or relative to
 309      the current directory.  */
 310   {
 311     char namebuf[4096];
 312     int fd = open ("/proc/self/execname", O_RDONLY | O_CLOEXEC, 0);
 313     if (fd >= 0)
 314       {
 315         size_t len = full_read (fd, namebuf, sizeof (namebuf));
 316         close (fd);
 317         if (len > 0 && len < sizeof (namebuf))
 318           {
 319             namebuf[len] = '\0';
 320             return canonicalize_file_name (namebuf);
 321           }
 322       }
 323   }
 324 # endif
 325 # if defined __CYGWIN__
 326   /* The executable is accessible as /proc/<pid>/exe, at least in
 327      Cygwin >= 1.5.  */
 328   {
 329     char *link;
 330
 331     link = xreadlink ("/proc/self/exe");
 332     if (link != NULL)
 333       return link;
 334     if (executable_fd < 0)
 335       executable_fd = open ("/proc/self/exe", O_EXEC | O_CLOEXEC, 0);
 336   }
 337 # endif
 338 # if HAVE_MACH_O_DYLD_H && HAVE__NSGETEXECUTABLEPATH
 339   /* On Mac OS X 10.2 or newer, the function
 340        int _NSGetExecutablePath (char *buf, uint32_t *bufsize);
 341      can be used to retrieve the executable's full path.  */
 342   char location[4096];
 343   unsigned int length = sizeof (location);
 344   if (_NSGetExecutablePath (location, &length) == 0
 345       && location[0] == '/')
 346     return canonicalize_file_name (location);
 347 # endif
 348   /* Guess the executable's full path.  We assume the executable has been
 349      called via execlp() or execvp() with properly set up argv[0].  The
 350      login(1) convention to add a '-' prefix to argv[0] is not supported.  */
 351   {
 352     bool has_slash = false;
 353     {
 354       const char *p;
 355       for (p = argv0; *p; p++)
 356         if (*p == '/')
 357           {
 358             has_slash = true;
 359             break;
 360           }
 361     }
 362     if (!has_slash)
 363       {
 364         /* exec searches paths without slashes in the directory list given
 365            by $PATH.  */
 366         const char *path = getenv ("PATH");
 367
 368         if (path != NULL)
 369           {
 370             const char *p;
 371             const char *p_next;
 372
 373             for (p = path; *p; p = p_next)
 374               {
 375                 const char *q;
 376                 size_t p_len;
 377                 char *concat_name;
 378
 379                 for (q = p; *q; q++)
 380                   if (*q == ':')
 381                     break;
 382                 p_len = q - p;
 383                 p_next = (*q == '\0' ? q : q + 1);
 384
 385                 /* We have a path item at p, of length p_len.
 386                    Now concatenate the path item and argv0.  */
 387                 concat_name = (char *) xmalloc (p_len + strlen (argv0) + 2);
 388 # ifdef NO_XMALLOC
 389                 if (concat_name == NULL)
 390                   return NULL;
 391 # endif
 392                 if (p_len == 0)
 393                   /* An empty PATH element designates the current directory.  */
 394                   strcpy (concat_name, argv0);
 395                 else
 396                   {
 397                     memcpy (concat_name, p, p_len);
 398                     concat_name[p_len] = '/';
 399                     strcpy (concat_name + p_len + 1, argv0);
 400                   }
 401                 if (maybe_executable (concat_name))
 402                   return canonicalize_file_name (concat_name);
 403                 free (concat_name);
 404               }
 405           }
 406         /* Not found in the PATH, assume the current directory.  */
 407       }
 408     /* exec treats paths containing slashes as relative to the current
 409        directory.  */
 410     if (maybe_executable (argv0))
 411       return canonicalize_file_name (argv0);
 412   }
 413   /* No way to find the executable.  */
 414   return NULL;
 415 #endif
 416 }
 417
 418 /* Full pathname of executable, or NULL.  */
 419 static char *executable_fullname;
 420
 421 static void
 422 prepare_relocate (const char *orig_installprefix, const char *orig_installdir,
 423                   const char *argv0)
 424 {
 425   char *curr_prefix;
 426
 427   /* Determine the full pathname of the current executable.  */
 428   executable_fullname = find_executable (argv0);
 429
 430   /* Determine the current installation prefix from it.  */
 431   curr_prefix = compute_curr_prefix (orig_installprefix, orig_installdir,
 432                                      executable_fullname);
 433   if (curr_prefix != NULL)
 434     {
 435       /* Now pass this prefix to all copies of the relocate.c source file.  */
 436       set_relocation_prefix (orig_installprefix, curr_prefix);
 437
 438       free (curr_prefix);
 439     }
 440 }
 441
 442 /* Set program_name, based on argv[0], and original installation prefix and
 443    directory, for relocatability.  */
 444 void
 445 set_program_name_and_installdir (const char *argv0,
 446                                  const char *orig_installprefix,
 447                                  const char *orig_installdir)
 448 {
 449   const char *argv0_stripped = argv0;
 450
 451   /* Relocatable programs are renamed to .bin by install-reloc.  Or, more
 452      generally, their suffix is changed from $exeext to .bin$exeext.
 453      Remove the ".bin" here.  */
 454   {
 455     size_t argv0_len = strlen (argv0);
 456     const size_t exeext_len = sizeof (EXEEXT) - sizeof ("");
 457     if (argv0_len > 4 + exeext_len)
 458       if (memcmp (argv0 + argv0_len - exeext_len - 4, ".bin", 4) == 0)
 459         {
 460           if (sizeof (EXEEXT) > sizeof (""))
 461             {
 462               /* Compare using an inlined copy of c_strncasecmp(), because
 463                  the filenames may have undergone a case conversion since
 464                  they were packaged.  In other words, EXEEXT may be ".exe"
 465                  on one system and ".EXE" on another.  */
 466               static const char exeext[] = EXEEXT;
 467               const char *s1 = argv0 + argv0_len - exeext_len;
 468               const char *s2 = exeext;
 469               for (; *s1 != '\0'; s1++, s2++)
 470                 {
 471                   unsigned char c1 = *s1;
 472                   unsigned char c2 = *s2;
 473                   if ((c1 >= 'A' && c1 <= 'Z' ? c1 - 'A' + 'a' : c1)
 474                       != (c2 >= 'A' && c2 <= 'Z' ? c2 - 'A' + 'a' : c2))
 475                     goto done_stripping;
 476                 }
 477             }
 478           /* Remove ".bin" before EXEEXT or its equivalent.  */
 479           {
 480             char *shorter = (char *) xmalloc (argv0_len - 4 + 1);
 481 #ifdef NO_XMALLOC
 482             if (shorter != NULL)
 483 #endif
 484               {
 485                 memcpy (shorter, argv0, argv0_len - exeext_len - 4);
 486                 if (sizeof (EXEEXT) > sizeof (""))
 487                   memcpy (shorter + argv0_len - exeext_len - 4,
 488                           argv0 + argv0_len - exeext_len - 4,
 489                           exeext_len);
 490                 shorter[argv0_len - 4] = '\0';
 491                 argv0_stripped = shorter;
 492               }
 493           }
 494          done_stripping: ;
 495       }
 496   }
 497
 498   set_program_name (argv0_stripped);
 499
 500   prepare_relocate (orig_installprefix, orig_installdir, argv0);
 501 }
 502
 503 /* Return the full pathname of the current executable, based on the earlier
 504    call to set_program_name_and_installdir.  Return NULL if unknown.  */
 505 char *
 506 get_full_program_name (void)
 507 {
 508   return executable_fullname;
 509 }
 510
 511 #endif