libiberty/make-relative-prefix.c

   1 /* Relative (relocatable) prefix support.
   2    Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002, 2006, 2012 Free Software Foundation, Inc.
   4
   5 This file is part of libiberty.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
  20 02110-1301, USA.  */
  21
  22 /*
  23
  24 @deftypefn Extension {const char*} make_relative_prefix (const char *@var{progname}, @
  25   const char *@var{bin_prefix}, const char *@var{prefix})
  26
  27 Given three paths @var{progname}, @var{bin_prefix}, @var{prefix},
  28 return the path that is in the same position relative to
  29 @var{progname}'s directory as @var{prefix} is relative to
  30 @var{bin_prefix}.  That is, a string starting with the directory
  31 portion of @var{progname}, followed by a relative pathname of the
  32 difference between @var{bin_prefix} and @var{prefix}.
  33
  34 If @var{progname} does not contain any directory separators,
  35 @code{make_relative_prefix} will search @env{PATH} to find a program
  36 named @var{progname}.  Also, if @var{progname} is a symbolic link,
  37 the symbolic link will be resolved.
  38
  39 For example, if @var{bin_prefix} is @code{/alpha/beta/gamma/gcc/delta},
  40 @var{prefix} is @code{/alpha/beta/gamma/omega/}, and @var{progname} is
  41 @code{/red/green/blue/gcc}, then this function will return
  42 @code{/red/green/blue/../../omega/}.
  43
  44 The return value is normally allocated via @code{malloc}.  If no
  45 relative prefix can be found, return @code{NULL}.
  46
  47 @end deftypefn
  48
  49 */
  50
  51 #ifdef HAVE_CONFIG_H
  52 #include "config.h"
  53 #endif
  54
  55 #ifdef HAVE_STDLIB_H
  56 #include <stdlib.h>
  57 #endif
  58 #ifdef HAVE_UNISTD_H
  59 #include <unistd.h>
  60 #endif
  61 #ifdef HAVE_SYS_STAT_H
  62 #include <sys/stat.h>
  63 #endif
  64
  65 #include <string.h>
  66
  67 #include "ansidecl.h"
  68 #include "libiberty.h"
  69
  70 #ifndef R_OK
  71 #define R_OK 4
  72 #define W_OK 2
  73 #define X_OK 1
  74 #endif
  75
  76 #ifndef DIR_SEPARATOR
  77 #  define DIR_SEPARATOR '/'
  78 #endif
  79
  80 #if defined (_WIN32) || defined (__MSDOS__) \
  81     || defined (__DJGPP__) || defined (__OS2__)
  82 #  define HAVE_DOS_BASED_FILE_SYSTEM
  83 #  define HAVE_HOST_EXECUTABLE_SUFFIX
  84 #  define HOST_EXECUTABLE_SUFFIX ".exe"
  85 #  ifndef DIR_SEPARATOR_2
  86 #    define DIR_SEPARATOR_2 '\\'
  87 #  endif
  88 #  define PATH_SEPARATOR ';'
  89 #else
  90 #  define PATH_SEPARATOR ':'
  91 #endif
  92
  93 #ifndef DIR_SEPARATOR_2
  94 #  define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
  95 #else
  96 #  define IS_DIR_SEPARATOR(ch) \
  97         (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
  98 #endif
  99
 100 #define DIR_UP ".."
 101
 102 static char *save_string (const char *, int);
 103 static char **split_directories (const char *, int *);
 104 static void free_split_directories (char **);
 105
 106 static char *
 107 save_string (const char *s, int len)
 108 {
 109   char *result = (char *) malloc (len + 1);
 110
 111   memcpy (result, s, len);
 112   result[len] = 0;
 113   return result;
 114 }
 115
 116 /* Split a filename into component directories.  */
 117
 118 static char **
 119 split_directories (const char *name, int *ptr_num_dirs)
 120 {
 121   int num_dirs = 0;
 122   char **dirs;
 123   const char *p, *q;
 124   int ch;
 125
 126   /* Count the number of directories.  Special case MSDOS disk names as part
 127      of the initial directory.  */
 128   p = name;
 129 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
 130   if (name[1] == ':' && IS_DIR_SEPARATOR (name[2]))
 131     {
 132       p += 3;
 133       num_dirs++;
 134     }
 135 #endif /* HAVE_DOS_BASED_FILE_SYSTEM */
 136
 137   while ((ch = *p++) != '\0')
 138     {
 139       if (IS_DIR_SEPARATOR (ch))
 140         {
 141           num_dirs++;
 142           while (IS_DIR_SEPARATOR (*p))
 143             p++;
 144         }
 145     }
 146
 147   dirs = (char **) malloc (sizeof (char *) * (num_dirs + 2));
 148   if (dirs == NULL)
 149     return NULL;
 150
 151   /* Now copy the directory parts.  */
 152   num_dirs = 0;
 153   p = name;
 154 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
 155   if (name[1] == ':' && IS_DIR_SEPARATOR (name[2]))
 156     {
 157       dirs[num_dirs++] = save_string (p, 3);
 158       if (dirs[num_dirs - 1] == NULL)
 159         {
 160           free (dirs);
 161           return NULL;
 162         }
 163       p += 3;
 164     }
 165 #endif /* HAVE_DOS_BASED_FILE_SYSTEM */
 166
 167   q = p;
 168   while ((ch = *p++) != '\0')
 169     {
 170       if (IS_DIR_SEPARATOR (ch))
 171         {
 172           while (IS_DIR_SEPARATOR (*p))
 173             p++;
 174
 175           dirs[num_dirs++] = save_string (q, p - q);
 176           if (dirs[num_dirs - 1] == NULL)
 177             {
 178               dirs[num_dirs] = NULL;
 179               free_split_directories (dirs);
 180               return NULL;
 181             }
 182           q = p;
 183         }
 184     }
 185
 186   if (p - 1 - q > 0)
 187     dirs[num_dirs++] = save_string (q, p - 1 - q);
 188   dirs[num_dirs] = NULL;
 189
 190   if (dirs[num_dirs - 1] == NULL)
 191     {
 192       free_split_directories (dirs);
 193       return NULL;
 194     }
 195
 196   if (ptr_num_dirs)
 197     *ptr_num_dirs = num_dirs;
 198   return dirs;
 199 }
 200
 201 /* Release storage held by split directories.  */
 202
 203 static void
 204 free_split_directories (char **dirs)
 205 {
 206   int i = 0;
 207
 208   if (dirs != NULL)
 209     {
 210       while (dirs[i] != NULL)
 211         free (dirs[i++]);
 212
 213       free ((char *) dirs);
 214     }
 215 }
 216
 217 /* Given three strings PROGNAME, BIN_PREFIX, PREFIX, return a string that gets
 218    to PREFIX starting with the directory portion of PROGNAME and a relative
 219    pathname of the difference between BIN_PREFIX and PREFIX.
 220
 221    For example, if BIN_PREFIX is /alpha/beta/gamma/gcc/delta, PREFIX is
 222    /alpha/beta/gamma/omega/, and PROGNAME is /red/green/blue/gcc, then this
 223    function will return /red/green/blue/../../omega/.
 224
 225    If no relative prefix can be found, return NULL.  */
 226
 227 static char *
 228 make_relative_prefix_1 (const char *progname, const char *bin_prefix,
 229                         const char *prefix, const int resolve_links)
 230 {
 231   char **prog_dirs = NULL, **bin_dirs = NULL, **prefix_dirs = NULL;
 232   int prog_num, bin_num, prefix_num;
 233   int i, n, common;
 234   int needed_len;
 235   char *ret = NULL, *ptr, *full_progname;
 236
 237   if (progname == NULL || bin_prefix == NULL || prefix == NULL)
 238     return NULL;
 239
 240   /* If there is no full pathname, try to find the program by checking in each
 241      of the directories specified in the PATH environment variable.  */
 242   if (lbasename (progname) == progname)
 243     {
 244       char *temp;
 245
 246       temp = getenv ("PATH");
 247       if (temp)
 248         {
 249           char *startp, *endp, *nstore;
 250           size_t prefixlen = strlen (temp) + 1;
 251           if (prefixlen < 2)
 252             prefixlen = 2;
 253
 254           nstore = (char *) alloca (prefixlen + strlen (progname) + 1
 255 #ifdef HAVE_HOST_EXECUTABLE_SUFFIX
 256                                     + strlen (HOST_EXECUTABLE_SUFFIX)
 257 #endif
 258                                     );
 259
 260           startp = endp = temp;
 261           while (1)
 262             {
 263               if (*endp == PATH_SEPARATOR || *endp == 0)
 264                 {
 265                   if (endp == startp)
 266                     {
 267                       nstore[0] = '.';
 268                       nstore[1] = DIR_SEPARATOR;
 269                       nstore[2] = '\0';
 270                     }
 271                   else
 272                     {
 273                       memcpy (nstore, startp, endp - startp);
 274                       if (! IS_DIR_SEPARATOR (endp[-1]))
 275                         {
 276                           nstore[endp - startp] = DIR_SEPARATOR;
 277                           nstore[endp - startp + 1] = 0;
 278                         }
 279                       else
 280                         nstore[endp - startp] = 0;
 281                     }
 282                   strcat (nstore, progname);
 283                   if (! access (nstore, X_OK)
 284 #ifdef HAVE_HOST_EXECUTABLE_SUFFIX
 285                       || ! access (strcat (nstore, HOST_EXECUTABLE_SUFFIX), X_OK)
 286 #endif
 287                       )
 288                     {
 289 #if defined (HAVE_SYS_STAT_H) && defined (S_ISREG)
 290                       struct stat st;
 291                       if (stat (nstore, &st) >= 0 && S_ISREG (st.st_mode))
 292 #endif
 293                         {
 294                           progname = nstore;
 295                           break;
 296                         }
 297                     }
 298
 299                   if (*endp == 0)
 300                     break;
 301                   endp = startp = endp + 1;
 302                 }
 303               else
 304                 endp++;
 305             }
 306         }
 307     }
 308
 309   if (resolve_links)
 310     full_progname = lrealpath (progname);
 311   else
 312     full_progname = strdup (progname);
 313   if (full_progname == NULL)
 314     return NULL;
 315
 316   prog_dirs = split_directories (full_progname, &prog_num);
 317   free (full_progname);
 318   if (prog_dirs == NULL)
 319     return NULL;
 320
 321   bin_dirs = split_directories (bin_prefix, &bin_num);
 322   if (bin_dirs == NULL)
 323     goto bailout;
 324
 325   /* Remove the program name from comparison of directory names.  */
 326   prog_num--;
 327
 328   /* If we are still installed in the standard location, we don't need to
 329      specify relative directories.  Also, if argv[0] still doesn't contain
 330      any directory specifiers after the search above, then there is not much
 331      we can do.  */
 332   if (prog_num == bin_num)
 333     {
 334       for (i = 0; i < bin_num; i++)
 335         {
 336           if (strcmp (prog_dirs[i], bin_dirs[i]) != 0)
 337             break;
 338         }
 339
 340       if (prog_num <= 0 || i == bin_num)
 341         goto bailout;
 342     }
 343
 344   prefix_dirs = split_directories (prefix, &prefix_num);
 345   if (prefix_dirs == NULL)
 346     goto bailout;
 347
 348   /* Find how many directories are in common between bin_prefix & prefix.  */
 349   n = (prefix_num < bin_num) ? prefix_num : bin_num;
 350   for (common = 0; common < n; common++)
 351     {
 352       if (strcmp (bin_dirs[common], prefix_dirs[common]) != 0)
 353         break;
 354     }
 355
 356   /* If there are no common directories, there can be no relative prefix.  */
 357   if (common == 0)
 358     goto bailout;
 359
 360   /* Two passes: first figure out the size of the result string, and
 361      then construct it.  */
 362   needed_len = 0;
 363   for (i = 0; i < prog_num; i++)
 364     needed_len += strlen (prog_dirs[i]);
 365   needed_len += sizeof (DIR_UP) * (bin_num - common);
 366   for (i = common; i < prefix_num; i++)
 367     needed_len += strlen (prefix_dirs[i]);
 368   needed_len += 1; /* Trailing NUL.  */
 369
 370   ret = (char *) malloc (needed_len);
 371   if (ret == NULL)
 372     goto bailout;
 373
 374   /* Build up the pathnames in argv[0].  */
 375   *ret = '\0';
 376   for (i = 0; i < prog_num; i++)
 377     strcat (ret, prog_dirs[i]);
 378
 379   /* Now build up the ..'s.  */
 380   ptr = ret + strlen(ret);
 381   for (i = common; i < bin_num; i++)
 382     {
 383       strcpy (ptr, DIR_UP);
 384       ptr += sizeof (DIR_UP) - 1;
 385       *(ptr++) = DIR_SEPARATOR;
 386     }
 387   *ptr = '\0';
 388
 389   /* Put in directories to move over to prefix.  */
 390   for (i = common; i < prefix_num; i++)
 391     strcat (ret, prefix_dirs[i]);
 392
 393  bailout:
 394   free_split_directories (prog_dirs);
 395   free_split_directories (bin_dirs);
 396   free_split_directories (prefix_dirs);
 397
 398   return ret;
 399 }
 400
 401
 402 /* Do the full job, including symlink resolution.
 403    This path will find files installed in the same place as the
 404    program even when a soft link has been made to the program
 405    from somwhere else. */
 406
 407 char *
 408 make_relative_prefix (const char *progname, const char *bin_prefix,
 409                       const char *prefix)
 410 {
 411   return make_relative_prefix_1 (progname, bin_prefix, prefix, 1);
 412 }
 413
 414 /* Make the relative pathname without attempting to resolve any links.
 415    '..' etc may also be left in the pathname.
 416    This will find the files the user meant the program to find if the
 417    installation is patched together with soft links. */
 418
 419 char *
 420 make_relative_prefix_ignore_links (const char *progname,
 421                                    const char *bin_prefix,
 422                                    const char *prefix)
 423 {
 424   return make_relative_prefix_1 (progname, bin_prefix, prefix, 0);
 425 }
 426