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
5This file is part of libiberty.
6
7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 2, or (at your option) any later
10version.
11
12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15for more details.
16
17You should have received a copy of the GNU General Public License
18along with GCC; see the file COPYING.  If not, write to the Free
19Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
2002110-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
26Given three paths @var{progname}, @var{bin_prefix}, @var{prefix},
27return 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
30portion of @var{progname}, followed by a relative pathname of the
31difference between @var{bin_prefix} and @var{prefix}.
32
33If @var{progname} does not contain any directory separators,
34@code{make_relative_prefix} will search @env{PATH} to find a program
35named @var{progname}.  Also, if @var{progname} is a symbolic link,
36the symbolic link will be resolved.
37
38For 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
43The return value is normally allocated via @code{malloc}.  If no
44relative 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
98static char *save_string (const char *, int);
99static char **split_directories	(const char *, int *);
100static void free_split_directories (char **);
101
102static char *
103save_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
114static char **
115split_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
199static void
200free_split_directories (char **dirs)
201{
202  int i = 0;
203
204  if (dirs != NULL)
205    {
206      while (dirs[i] != NULL)
207	free (dirs[i++]);
208
209      free ((char *) dirs);
210    }
211}
212
213/* Given three strings PROGNAME, BIN_PREFIX, PREFIX, return a string that gets
214   to PREFIX starting with the directory portion of PROGNAME and a relative
215   pathname of the difference between BIN_PREFIX and PREFIX.
216
217   For example, if BIN_PREFIX is /alpha/beta/gamma/gcc/delta, PREFIX is
218   /alpha/beta/gamma/omega/, and PROGNAME is /red/green/blue/gcc, then this
219   function will return /red/green/blue/../../omega/.
220
221   If no relative prefix can be found, return NULL.  */
222
223static char *
224make_relative_prefix_1 (const char *progname, const char *bin_prefix,
225			const char *prefix, const int resolve_links)
226{
227  char **prog_dirs = NULL, **bin_dirs = NULL, **prefix_dirs = NULL;
228  int prog_num, bin_num, prefix_num;
229  int i, n, common;
230  int needed_len;
231  char *ret = NULL, *ptr, *full_progname;
232
233  if (progname == NULL || bin_prefix == NULL || prefix == NULL)
234    return NULL;
235
236  /* If there is no full pathname, try to find the program by checking in each
237     of the directories specified in the PATH environment variable.  */
238  if (lbasename (progname) == progname)
239    {
240      char *temp;
241
242      temp = getenv ("PATH");
243      if (temp)
244	{
245	  char *startp, *endp, *nstore;
246	  size_t prefixlen = strlen (temp) + 1;
247	  if (prefixlen < 2)
248	    prefixlen = 2;
249
250	  nstore = (char *) alloca (prefixlen + strlen (progname) + 1);
251
252	  startp = endp = temp;
253	  while (1)
254	    {
255	      if (*endp == PATH_SEPARATOR || *endp == 0)
256		{
257		  if (endp == startp)
258		    {
259		      nstore[0] = '.';
260		      nstore[1] = DIR_SEPARATOR;
261		      nstore[2] = '\0';
262		    }
263		  else
264		    {
265		      strncpy (nstore, startp, endp - startp);
266		      if (! IS_DIR_SEPARATOR (endp[-1]))
267			{
268			  nstore[endp - startp] = DIR_SEPARATOR;
269			  nstore[endp - startp + 1] = 0;
270			}
271		      else
272			nstore[endp - startp] = 0;
273		    }
274		  strcat (nstore, progname);
275		  if (! access (nstore, X_OK)
276#ifdef HAVE_HOST_EXECUTABLE_SUFFIX
277                      || ! access (strcat (nstore, HOST_EXECUTABLE_SUFFIX), X_OK)
278#endif
279		      )
280		    {
281		      progname = nstore;
282		      break;
283		    }
284
285		  if (*endp == 0)
286		    break;
287		  endp = startp = endp + 1;
288		}
289	      else
290		endp++;
291	    }
292	}
293    }
294
295  if ( resolve_links )
296    {
297      full_progname = lrealpath (progname);
298      if (full_progname == NULL)
299	return NULL;
300    }
301  else
302    full_progname = strdup(progname);
303
304  prog_dirs = split_directories (full_progname, &prog_num);
305  free (full_progname);
306  if (prog_dirs == NULL)
307    return NULL;
308
309  bin_dirs = split_directories (bin_prefix, &bin_num);
310  if (bin_dirs == NULL)
311    goto bailout;
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	goto bailout;
330    }
331
332  prefix_dirs = split_directories (prefix, &prefix_num);
333  if (prefix_dirs == NULL)
334    goto bailout;
335
336  /* Find how many directories are in common between bin_prefix & prefix.  */
337  n = (prefix_num < bin_num) ? prefix_num : bin_num;
338  for (common = 0; common < n; common++)
339    {
340      if (strcmp (bin_dirs[common], prefix_dirs[common]) != 0)
341	break;
342    }
343
344  /* If there are no common directories, there can be no relative prefix.  */
345  if (common == 0)
346    goto bailout;
347
348  /* Two passes: first figure out the size of the result string, and
349     then construct it.  */
350  needed_len = 0;
351  for (i = 0; i < prog_num; i++)
352    needed_len += strlen (prog_dirs[i]);
353  needed_len += sizeof (DIR_UP) * (bin_num - common);
354  for (i = common; i < prefix_num; i++)
355    needed_len += strlen (prefix_dirs[i]);
356  needed_len += 1; /* Trailing NUL.  */
357
358  ret = (char *) malloc (needed_len);
359  if (ret == NULL)
360    goto bailout;
361
362  /* Build up the pathnames in argv[0].  */
363  *ret = '\0';
364  for (i = 0; i < prog_num; i++)
365    strcat (ret, prog_dirs[i]);
366
367  /* Now build up the ..'s.  */
368  ptr = ret + strlen(ret);
369  for (i = common; i < bin_num; i++)
370    {
371      strcpy (ptr, DIR_UP);
372      ptr += sizeof (DIR_UP) - 1;
373      *(ptr++) = DIR_SEPARATOR;
374    }
375  *ptr = '\0';
376
377  /* Put in directories to move over to prefix.  */
378  for (i = common; i < prefix_num; i++)
379    strcat (ret, prefix_dirs[i]);
380
381 bailout:
382  free_split_directories (prog_dirs);
383  free_split_directories (bin_dirs);
384  free_split_directories (prefix_dirs);
385
386  return ret;
387}
388
389
390/* Do the full job, including symlink resolution.
391   This path will find files installed in the same place as the
392   program even when a soft link has been made to the program
393   from somwhere else. */
394
395char *
396make_relative_prefix (const char *progname, const char *bin_prefix,
397		      const char *prefix)
398{
399  return make_relative_prefix_1 (progname, bin_prefix, prefix, 1);
400}
401
402/* Make the relative pathname without attempting to resolve any links.
403   '..' etc may also be left in the pathname.
404   This will find the files the user meant the program to find if the
405   installation is patched together with soft links. */
406
407char *
408make_relative_prefix_ignore_links (const char *progname,
409				   const char *bin_prefix,
410				   const char *prefix)
411{
412  return make_relative_prefix_1 (progname, bin_prefix, prefix, 0);
413}
414
415