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  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
220static char *
221make_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  bin_dirs = split_directories (bin_prefix, &bin_num);
303  free (full_progname);
304  if (bin_dirs == NULL || prog_dirs == NULL)
305    return NULL;
306
307  /* Remove the program name from comparison of directory names.  */
308  prog_num--;
309
310  /* If we are still installed in the standard location, we don't need to
311     specify relative directories.  Also, if argv[0] still doesn't contain
312     any directory specifiers after the search above, then there is not much
313     we can do.  */
314  if (prog_num == bin_num)
315    {
316      for (i = 0; i < bin_num; i++)
317	{
318	  if (strcmp (prog_dirs[i], bin_dirs[i]) != 0)
319	    break;
320	}
321
322      if (prog_num <= 0 || i == bin_num)
323	{
324	  free_split_directories (prog_dirs);
325	  free_split_directories (bin_dirs);
326	  prog_dirs = bin_dirs = (char **) 0;
327	  return NULL;
328	}
329    }
330
331  prefix_dirs = split_directories (prefix, &prefix_num);
332  if (prefix_dirs == NULL)
333    {
334      free_split_directories (prog_dirs);
335      free_split_directories (bin_dirs);
336      return NULL;
337    }
338
339  /* Find how many directories are in common between bin_prefix & prefix.  */
340  n = (prefix_num < bin_num) ? prefix_num : bin_num;
341  for (common = 0; common < n; common++)
342    {
343      if (strcmp (bin_dirs[common], prefix_dirs[common]) != 0)
344	break;
345    }
346
347  /* If there are no common directories, there can be no relative prefix.  */
348  if (common == 0)
349    {
350      free_split_directories (prog_dirs);
351      free_split_directories (bin_dirs);
352      free_split_directories (prefix_dirs);
353      return NULL;
354    }
355
356  /* Two passes: first figure out the size of the result string, and
357     then construct it.  */
358  needed_len = 0;
359  for (i = 0; i < prog_num; i++)
360    needed_len += strlen (prog_dirs[i]);
361  needed_len += sizeof (DIR_UP) * (bin_num - common);
362  for (i = common; i < prefix_num; i++)
363    needed_len += strlen (prefix_dirs[i]);
364  needed_len += 1; /* Trailing NUL.  */
365
366  ret = (char *) malloc (needed_len);
367  if (ret == NULL)
368    return NULL;
369
370  /* Build up the pathnames in argv[0].  */
371  *ret = '\0';
372  for (i = 0; i < prog_num; i++)
373    strcat (ret, prog_dirs[i]);
374
375  /* Now build up the ..'s.  */
376  ptr = ret + strlen(ret);
377  for (i = common; i < bin_num; i++)
378    {
379      strcpy (ptr, DIR_UP);
380      ptr += sizeof (DIR_UP) - 1;
381      *(ptr++) = DIR_SEPARATOR;
382    }
383  *ptr = '\0';
384
385  /* Put in directories to move over to prefix.  */
386  for (i = common; i < prefix_num; i++)
387    strcat (ret, prefix_dirs[i]);
388
389  free_split_directories (prog_dirs);
390  free_split_directories (bin_dirs);
391  free_split_directories (prefix_dirs);
392
393  return ret;
394}
395
396
397/* Do the full job, including symlink resolution.
398   This path will find files installed in the same place as the
399   program even when a soft link has been made to the program
400   from somwhere else. */
401
402char *
403make_relative_prefix (const char *progname, const char *bin_prefix,
404		      const char *prefix)
405{
406  return make_relative_prefix_1 (progname, bin_prefix, prefix, 1);
407}
408
409/* Make the relative pathname without attempting to resolve any links.
410   '..' etc may also be left in the pathname.
411   This will find the files the user meant the program to find if the
412   installation is patched together with soft links. */
413
414char *
415make_relative_prefix_ignore_links (const char *progname,
416				   const char *bin_prefix,
417				   const char *prefix)
418{
419  return make_relative_prefix_1 (progname, bin_prefix, prefix, 0);
420}
421
422