intl/relocatable.c

   1 /* Provide relocatable packages.
   2    Copyright (C) 2003-2006 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 it
   6    under the terms of the GNU Library General Public License as published
   7    by the Free Software Foundation; either version 2, or (at your option)
   8    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 GNU
  13    Library General Public License for more details.
  14
  15    You should have received a copy of the GNU Library General Public
  16    License along with this program; if not, write to the Free Software
  17    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
  18    USA.  */
  19
  20
  21 /* Tell glibc's <stdio.h> to provide a prototype for getline().
  22    This must come before <config.h> because <config.h> may include
  23    <features.h>, and once <features.h> has been included, it's too late.  */
  24 #ifndef _GNU_SOURCE
  25 # define _GNU_SOURCE    1
  26 #endif
  27
  28 #include <config.h>
  29
  30 /* Specification.  */
  31 #include "relocatable.h"
  32
  33 #if ENABLE_RELOCATABLE
  34
  35 #include <stddef.h>
  36 #include <stdio.h>
  37 #include <stdlib.h>
  38 #include <string.h>
  39
  40 #ifdef NO_XMALLOC
  41 # define xmalloc malloc
  42 #else
  43 # include "xalloc.h"
  44 #endif
  45
  46 #if defined _WIN32 || defined __WIN32__ || defined __CYGWIN__
  47 # define WIN32_LEAN_AND_MEAN
  48 # include <windows.h>
  49 #endif
  50
  51 #if DEPENDS_ON_LIBCHARSET
  52 # include <libcharset.h>
  53 #endif
  54 #if DEPENDS_ON_LIBICONV && HAVE_ICONV
  55 # include <iconv.h>
  56 #endif
  57 #if DEPENDS_ON_LIBINTL && ENABLE_NLS
  58 # include <libintl.h>
  59 #endif
  60
  61 /* Faked cheap 'bool'.  */
  62 #undef bool
  63 #undef false
  64 #undef true
  65 #define bool int
  66 #define false 0
  67 #define true 1
  68
  69 /* Pathname support.
  70    ISSLASH(C)           tests whether C is a directory separator character.
  71    IS_PATH_WITH_DIR(P)  tests whether P contains a directory specification.
  72  */
  73 #if defined _WIN32 || defined __WIN32__ || defined __CYGWIN__ || defined __EMX__ || defined __DJGPP__
  74   /* Win32, Cygwin, OS/2, DOS */
  75 # define ISSLASH(C) ((C) == '/' || (C) == '\\')
  76 # define HAS_DEVICE(P) \
  77     ((((P)[0] >= 'A' && (P)[0] <= 'Z') || ((P)[0] >= 'a' && (P)[0] <= 'z')) \
  78      && (P)[1] == ':')
  79 # define IS_PATH_WITH_DIR(P) \
  80     (strchr (P, '/') != NULL || strchr (P, '\\') != NULL || HAS_DEVICE (P))
  81 # define FILE_SYSTEM_PREFIX_LEN(P) (HAS_DEVICE (P) ? 2 : 0)
  82 #else
  83   /* Unix */
  84 # define ISSLASH(C) ((C) == '/')
  85 # define IS_PATH_WITH_DIR(P) (strchr (P, '/') != NULL)
  86 # define FILE_SYSTEM_PREFIX_LEN(P) 0
  87 #endif
  88
  89 /* Original installation prefix.  */
  90 static char *orig_prefix;
  91 static size_t orig_prefix_len;
  92 /* Current installation prefix.  */
  93 static char *curr_prefix;
  94 static size_t curr_prefix_len;
  95 /* These prefixes do not end in a slash.  Anything that will be concatenated
  96    to them must start with a slash.  */
  97
  98 /* Sets the original and the current installation prefix of this module.
  99    Relocation simply replaces a pathname starting with the original prefix
 100    by the corresponding pathname with the current prefix instead.  Both
 101    prefixes should be directory names without trailing slash (i.e. use ""
 102    instead of "/").  */
 103 static void
 104 set_this_relocation_prefix (const char *orig_prefix_arg,
 105                             const char *curr_prefix_arg)
 106 {
 107   if (orig_prefix_arg != NULL && curr_prefix_arg != NULL
 108       /* Optimization: if orig_prefix and curr_prefix are equal, the
 109          relocation is a nop.  */
 110       && strcmp (orig_prefix_arg, curr_prefix_arg) != 0)
 111     {
 112       /* Duplicate the argument strings.  */
 113       char *memory;
 114
 115       orig_prefix_len = strlen (orig_prefix_arg);
 116       curr_prefix_len = strlen (curr_prefix_arg);
 117       memory = (char *) xmalloc (orig_prefix_len + 1 + curr_prefix_len + 1);
 118 #ifdef NO_XMALLOC
 119       if (memory != NULL)
 120 #endif
 121         {
 122           memcpy (memory, orig_prefix_arg, orig_prefix_len + 1);
 123           orig_prefix = memory;
 124           memory += orig_prefix_len + 1;
 125           memcpy (memory, curr_prefix_arg, curr_prefix_len + 1);
 126           curr_prefix = memory;
 127           return;
 128         }
 129     }
 130   orig_prefix = NULL;
 131   curr_prefix = NULL;
 132   /* Don't worry about wasted memory here - this function is usually only
 133      called once.  */
 134 }
 135
 136 /* Sets the original and the current installation prefix of the package.
 137    Relocation simply replaces a pathname starting with the original prefix
 138    by the corresponding pathname with the current prefix instead.  Both
 139    prefixes should be directory names without trailing slash (i.e. use ""
 140    instead of "/").  */
 141 void
 142 set_relocation_prefix (const char *orig_prefix_arg, const char *curr_prefix_arg)
 143 {
 144   set_this_relocation_prefix (orig_prefix_arg, curr_prefix_arg);
 145
 146   /* Now notify all dependent libraries.  */
 147 #if DEPENDS_ON_LIBCHARSET
 148   libcharset_set_relocation_prefix (orig_prefix_arg, curr_prefix_arg);
 149 #endif
 150 #if DEPENDS_ON_LIBICONV && HAVE_ICONV && _LIBICONV_VERSION >= 0x0109
 151   libiconv_set_relocation_prefix (orig_prefix_arg, curr_prefix_arg);
 152 #endif
 153 #if DEPENDS_ON_LIBINTL && ENABLE_NLS && defined libintl_set_relocation_prefix
 154   libintl_set_relocation_prefix (orig_prefix_arg, curr_prefix_arg);
 155 #endif
 156 }
 157
 158 #if !defined IN_LIBRARY || (defined PIC && defined INSTALLDIR)
 159
 160 /* Convenience function:
 161    Computes the current installation prefix, based on the original
 162    installation prefix, the original installation directory of a particular
 163    file, and the current pathname of this file.  Returns NULL upon failure.  */
 164 #ifdef IN_LIBRARY
 165 #define compute_curr_prefix local_compute_curr_prefix
 166 static
 167 #endif
 168 const char *
 169 compute_curr_prefix (const char *orig_installprefix,
 170                      const char *orig_installdir,
 171                      const char *curr_pathname)
 172 {
 173   const char *curr_installdir;
 174   const char *rel_installdir;
 175
 176   if (curr_pathname == NULL)
 177     return NULL;
 178
 179   /* Determine the relative installation directory, relative to the prefix.
 180      This is simply the difference between orig_installprefix and
 181      orig_installdir.  */
 182   if (strncmp (orig_installprefix, orig_installdir, strlen (orig_installprefix))
 183       != 0)
 184     /* Shouldn't happen - nothing should be installed outside $(prefix).  */
 185     return NULL;
 186   rel_installdir = orig_installdir + strlen (orig_installprefix);
 187
 188   /* Determine the current installation directory.  */
 189   {
 190     const char *p_base = curr_pathname + FILE_SYSTEM_PREFIX_LEN (curr_pathname);
 191     const char *p = curr_pathname + strlen (curr_pathname);
 192     char *q;
 193
 194     while (p > p_base)
 195       {
 196         p--;
 197         if (ISSLASH (*p))
 198           break;
 199       }
 200
 201     q = (char *) xmalloc (p - curr_pathname + 1);
 202 #ifdef NO_XMALLOC
 203     if (q == NULL)
 204       return NULL;
 205 #endif
 206     memcpy (q, curr_pathname, p - curr_pathname);
 207     q[p - curr_pathname] = '\0';
 208     curr_installdir = q;
 209   }
 210
 211   /* Compute the current installation prefix by removing the trailing
 212      rel_installdir from it.  */
 213   {
 214     const char *rp = rel_installdir + strlen (rel_installdir);
 215     const char *cp = curr_installdir + strlen (curr_installdir);
 216     const char *cp_base =
 217       curr_installdir + FILE_SYSTEM_PREFIX_LEN (curr_installdir);
 218
 219     while (rp > rel_installdir && cp > cp_base)
 220       {
 221         bool same = false;
 222         const char *rpi = rp;
 223         const char *cpi = cp;
 224
 225         while (rpi > rel_installdir && cpi > cp_base)
 226           {
 227             rpi--;
 228             cpi--;
 229             if (ISSLASH (*rpi) || ISSLASH (*cpi))
 230               {
 231                 if (ISSLASH (*rpi) && ISSLASH (*cpi))
 232                   same = true;
 233                 break;
 234               }
 235             /* Do case-insensitive comparison if the filesystem is always or
 236                often case-insensitive.  It's better to accept the comparison
 237                if the difference is only in case, rather than to fail.  */
 238 #if defined _WIN32 || defined __WIN32__ || defined __CYGWIN__ || defined __EMX__ || defined __DJGPP__
 239             /* Win32, Cygwin, OS/2, DOS - case insignificant filesystem */
 240             if ((*rpi >= 'a' && *rpi <= 'z' ? *rpi - 'a' + 'A' : *rpi)
 241                 != (*cpi >= 'a' && *cpi <= 'z' ? *cpi - 'a' + 'A' : *cpi))
 242               break;
 243 #else
 244             if (*rpi != *cpi)
 245               break;
 246 #endif
 247           }
 248         if (!same)
 249           break;
 250         /* The last pathname component was the same.  opi and cpi now point
 251            to the slash before it.  */
 252         rp = rpi;
 253         cp = cpi;
 254       }
 255
 256     if (rp > rel_installdir)
 257       /* Unexpected: The curr_installdir does not end with rel_installdir.  */
 258       return NULL;
 259
 260     {
 261       size_t curr_prefix_len = cp - curr_installdir;
 262       char *curr_prefix;
 263
 264       curr_prefix = (char *) xmalloc (curr_prefix_len + 1);
 265 #ifdef NO_XMALLOC
 266       if (curr_prefix == NULL)
 267         return NULL;
 268 #endif
 269       memcpy (curr_prefix, curr_installdir, curr_prefix_len);
 270       curr_prefix[curr_prefix_len] = '\0';
 271
 272       return curr_prefix;
 273     }
 274   }
 275 }
 276
 277 #endif /* !IN_LIBRARY || PIC */
 278
 279 #if defined PIC && defined INSTALLDIR
 280
 281 /* Full pathname of shared library, or NULL.  */
 282 static char *shared_library_fullname;
 283
 284 #if defined _WIN32 || defined __WIN32__ || defined __CYGWIN__
 285
 286 /* Determine the full pathname of the shared library when it is loaded.  */
 287
 288 BOOL WINAPI
 289 DllMain (HINSTANCE module_handle, DWORD event, LPVOID reserved)
 290 {
 291   (void) reserved;
 292
 293   if (event == DLL_PROCESS_ATTACH)
 294     {
 295       /* The DLL is being loaded into an application's address range.  */
 296       static char location[MAX_PATH];
 297
 298       if (!GetModuleFileName (module_handle, location, sizeof (location)))
 299         /* Shouldn't happen.  */
 300         return FALSE;
 301
 302       if (!IS_PATH_WITH_DIR (location))
 303         /* Shouldn't happen.  */
 304         return FALSE;
 305
 306       {
 307 #if defined __CYGWIN__
 308         /* On Cygwin, we need to convert paths coming from Win32 system calls
 309            to the Unix-like slashified notation.  */
 310         static char location_as_posix_path[2 * MAX_PATH];
 311         /* There's no error return defined for cygwin_conv_to_posix_path.
 312            See cygwin-api/func-cygwin-conv-to-posix-path.html.
 313            Does it overflow the buffer of expected size MAX_PATH or does it
 314            truncate the path?  I don't know.  Let's catch both.  */
 315         cygwin_conv_to_posix_path (location, location_as_posix_path);
 316         location_as_posix_path[MAX_PATH - 1] = '\0';
 317         if (strlen (location_as_posix_path) >= MAX_PATH - 1)
 318           /* A sign of buffer overflow or path truncation.  */
 319           return FALSE;
 320         shared_library_fullname = strdup (location_as_posix_path);
 321 #else
 322         shared_library_fullname = strdup (location);
 323 #endif
 324       }
 325     }
 326
 327   return TRUE;
 328 }
 329
 330 #else /* Unix except Cygwin */
 331
 332 static void
 333 find_shared_library_fullname ()
 334 {
 335 #if defined __linux__ && __GLIBC__ >= 2
 336   /* Linux has /proc/self/maps. glibc 2 has the getline() function.  */
 337   FILE *fp;
 338
 339   /* Open the current process' maps file.  It describes one VMA per line.  */
 340   fp = fopen ("/proc/self/maps", "r");
 341   if (fp)
 342     {
 343       unsigned long address = (unsigned long) &find_shared_library_fullname;
 344       for (;;)
 345         {
 346           unsigned long start, end;
 347           int c;
 348
 349           if (fscanf (fp, "%lx-%lx", &start, &end) != 2)
 350             break;
 351           if (address >= start && address <= end - 1)
 352             {
 353               /* Found it.  Now see if this line contains a filename.  */
 354               while (c = getc (fp), c != EOF && c != '\n' && c != '/')
 355                 continue;
 356               if (c == '/')
 357                 {
 358                   size_t size;
 359                   int len;
 360
 361                   ungetc (c, fp);
 362                   shared_library_fullname = NULL; size = 0;
 363                   len = getline (&shared_library_fullname, &size, fp);
 364                   if (len >= 0)
 365                     {
 366                       /* Success: filled shared_library_fullname.  */
 367                       if (len > 0 && shared_library_fullname[len - 1] == '\n')
 368                         shared_library_fullname[len - 1] = '\0';
 369                     }
 370                 }
 371               break;
 372             }
 373           while (c = getc (fp), c != EOF && c != '\n')
 374             continue;
 375         }
 376       fclose (fp);
 377     }
 378 #endif
 379 }
 380
 381 #endif /* (WIN32 or Cygwin) / (Unix except Cygwin) */
 382
 383 /* Return the full pathname of the current shared library.
 384    Return NULL if unknown.
 385    Guaranteed to work only on Linux, Cygwin and Woe32.  */
 386 static char *
 387 get_shared_library_fullname ()
 388 {
 389 #if !(defined _WIN32 || defined __WIN32__ || defined __CYGWIN__)
 390   static bool tried_find_shared_library_fullname;
 391   if (!tried_find_shared_library_fullname)
 392     {
 393       find_shared_library_fullname ();
 394       tried_find_shared_library_fullname = true;
 395     }
 396 #endif
 397   return shared_library_fullname;
 398 }
 399
 400 #endif /* PIC */
 401
 402 /* Returns the pathname, relocated according to the current installation
 403    directory.  */
 404 const char *
 405 relocate (const char *pathname)
 406 {
 407 #if defined PIC && defined INSTALLDIR
 408   static int initialized;
 409
 410   /* Initialization code for a shared library.  */
 411   if (!initialized)
 412     {
 413       /* At this point, orig_prefix and curr_prefix likely have already been
 414          set through the main program's set_program_name_and_installdir
 415          function.  This is sufficient in the case that the library has
 416          initially been installed in the same orig_prefix.  But we can do
 417          better, to also cover the cases that 1. it has been installed
 418          in a different prefix before being moved to orig_prefix and (later)
 419          to curr_prefix, 2. unlike the program, it has not moved away from
 420          orig_prefix.  */
 421       const char *orig_installprefix = INSTALLPREFIX;
 422       const char *orig_installdir = INSTALLDIR;
 423       const char *curr_prefix_better;
 424
 425       curr_prefix_better =
 426         compute_curr_prefix (orig_installprefix, orig_installdir,
 427                              get_shared_library_fullname ());
 428       if (curr_prefix_better == NULL)
 429         curr_prefix_better = curr_prefix;
 430
 431       set_relocation_prefix (orig_installprefix, curr_prefix_better);
 432
 433       initialized = 1;
 434     }
 435 #endif
 436
 437   /* Note: It is not necessary to perform case insensitive comparison here,
 438      even for DOS-like filesystems, because the pathname argument was
 439      typically created from the same Makefile variable as orig_prefix came
 440      from.  */
 441   if (orig_prefix != NULL && curr_prefix != NULL
 442       && strncmp (pathname, orig_prefix, orig_prefix_len) == 0)
 443     {
 444       if (pathname[orig_prefix_len] == '\0')
 445         /* pathname equals orig_prefix.  */
 446         return curr_prefix;
 447       if (ISSLASH (pathname[orig_prefix_len]))
 448         {
 449           /* pathname starts with orig_prefix.  */
 450           const char *pathname_tail = &pathname[orig_prefix_len];
 451           char *result =
 452             (char *) xmalloc (curr_prefix_len + strlen (pathname_tail) + 1);
 453
 454 #ifdef NO_XMALLOC
 455           if (result != NULL)
 456 #endif
 457             {
 458               memcpy (result, curr_prefix, curr_prefix_len);
 459               strcpy (result + curr_prefix_len, pathname_tail);
 460               return result;
 461             }
 462         }
 463     }
 464   /* Nothing to relocate.  */
 465   return pathname;
 466 }
 467
 468 #endif