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