1/* Utility to update paths from internal to external forms.
2   Copyright (C) 1997-2015 Free Software Foundation, Inc.
3
4This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify it under
7the terms of the GNU Library General Public License as published by
8the Free Software Foundation; either version 3 of the License, or (at
9your option) any later version.
10
11GCC is distributed in the hope that it will be useful,
12but WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14Library General Public License for more details.
15
16You should have received a copy of the GNU Library General Public
17License along with GCC; see the file COPYING3.  If not see
18<http://www.gnu.org/licenses/>.  */
19
20/* This file contains routines to update a path, both to canonicalize
21   the directory format and to handle any prefix translation.
22
23   This file must be compiled with -DPREFIX= to specify the "prefix"
24   value used by configure.  If a filename does not begin with this
25   prefix, it will not be affected other than by directory canonicalization.
26
27   Each caller of 'update_path' may specify both a filename and
28   a translation prefix and consist of the name of the package that contains
29   the file ("@GCC", "@BINUTIL", "@GNU", etc).
30
31   If the prefix is not specified, the filename will only undergo
32   directory canonicalization.
33
34   If it is specified, the string given by PREFIX will be replaced
35   by the specified prefix (with a '@' in front unless the prefix begins
36   with a '$') and further translation will be done as follows
37   until none of the two conditions below are met:
38
39   1) If the filename begins with '@', the string between the '@' and
40   the end of the name or the first '/' or directory separator will
41   be considered a "key" and looked up as follows:
42
43   -- If this is a Win32 OS, then the Registry will be examined for
44      an entry of "key" in
45
46      HKEY_LOCAL_MACHINE\SOFTWARE\Free Software Foundation\<KEY>
47
48      if found, that value will be used. <KEY> defaults to GCC version
49      string, but can be overridden at configuration time.
50
51   -- If not found (or not a Win32 OS), the environment variable
52      key_ROOT (the value of "key" concatenated with the constant "_ROOT")
53      is tried.  If that fails, then PREFIX (see above) is used.
54
55   2) If the filename begins with a '$', the rest of the string up
56   to the end or the first '/' or directory separator will be used
57   as an environment variable, whose value will be returned.
58
59   Once all this is done, any '/' will be converted to DIR_SEPARATOR,
60   if they are different.
61
62   NOTE:  using resolve_keyed_path under Win32 requires linking with
63   advapi32.dll.  */
64
65
66#include "config.h"
67#include "system.h"
68#include "coretypes.h"
69#if defined(_WIN32) && defined(ENABLE_WIN32_REGISTRY)
70#include <windows.h>
71#endif
72#include "prefix.h"
73#include "common/common-target.h"
74
75static const char *std_prefix = PREFIX;
76
77static const char *get_key_value (char *);
78static char *translate_name (char *);
79static char *save_string (const char *, int);
80static void tr (char *, int, int);
81
82#if defined(_WIN32) && defined(ENABLE_WIN32_REGISTRY)
83static char *lookup_key (char *);
84static HKEY reg_key = (HKEY) INVALID_HANDLE_VALUE;
85#endif
86
87/* Given KEY, as above, return its value.  */
88
89static const char *
90get_key_value (char *key)
91{
92  const char *prefix = 0;
93  char *temp = 0;
94
95#if defined(_WIN32) && defined(ENABLE_WIN32_REGISTRY)
96  prefix = lookup_key (key);
97#endif
98
99  if (prefix == 0)
100    prefix = getenv (temp = concat (key, "_ROOT", NULL));
101
102  if (prefix == 0)
103    prefix = std_prefix;
104
105  free (temp);
106
107  return prefix;
108}
109
110/* Return a copy of a string that has been placed in the heap.  */
111
112static char *
113save_string (const char *s, int len)
114{
115  char *result = XNEWVEC (char, len + 1);
116
117  memcpy (result, s, len);
118  result[len] = 0;
119  return result;
120}
121
122#if defined(_WIN32) && defined(ENABLE_WIN32_REGISTRY)
123
124#ifndef WIN32_REGISTRY_KEY
125# define WIN32_REGISTRY_KEY BASEVER
126#endif
127
128/* Look up "key" in the registry, as above.  */
129
130static char *
131lookup_key (char *key)
132{
133  char *dst;
134  DWORD size;
135  DWORD type;
136  LONG res;
137
138  if (reg_key == (HKEY) INVALID_HANDLE_VALUE)
139    {
140      res = RegOpenKeyExA (HKEY_LOCAL_MACHINE, "SOFTWARE", 0,
141			   KEY_READ, &reg_key);
142
143      if (res == ERROR_SUCCESS)
144	res = RegOpenKeyExA (reg_key, "Free Software Foundation", 0,
145			     KEY_READ, &reg_key);
146
147      if (res == ERROR_SUCCESS)
148	res = RegOpenKeyExA (reg_key, WIN32_REGISTRY_KEY, 0,
149			     KEY_READ, &reg_key);
150
151      if (res != ERROR_SUCCESS)
152	{
153	  reg_key = (HKEY) INVALID_HANDLE_VALUE;
154	  return 0;
155	}
156    }
157
158  size = 32;
159  dst = XNEWVEC (char, size);
160
161  res = RegQueryValueExA (reg_key, key, 0, &type, (LPBYTE) dst, &size);
162  if (res == ERROR_MORE_DATA && type == REG_SZ)
163    {
164      dst = XRESIZEVEC (char, dst, size);
165      res = RegQueryValueExA (reg_key, key, 0, &type, (LPBYTE) dst, &size);
166    }
167
168  if (type != REG_SZ || res != ERROR_SUCCESS)
169    {
170      free (dst);
171      dst = 0;
172    }
173
174  return dst;
175}
176#endif
177
178/* If NAME, a malloc-ed string, starts with a '@' or '$', apply the
179   translation rules above and return a newly malloc-ed name.
180   Otherwise, return the given name.  */
181
182static char *
183translate_name (char *name)
184{
185  char code;
186  char *key, *old_name;
187  const char *prefix;
188  int keylen;
189
190  for (;;)
191    {
192      code = name[0];
193      if (code != '@' && code != '$')
194	break;
195
196      for (keylen = 0;
197	   (name[keylen + 1] != 0 && !IS_DIR_SEPARATOR (name[keylen + 1]));
198	   keylen++)
199	;
200
201      key = (char *) alloca (keylen + 1);
202      strncpy (key, &name[1], keylen);
203      key[keylen] = 0;
204
205      if (code == '@')
206	{
207	  prefix = get_key_value (key);
208	  if (prefix == 0)
209	    prefix = std_prefix;
210	}
211      else
212	prefix = getenv (key);
213
214      if (prefix == 0)
215	prefix = PREFIX;
216
217      /* We used to strip trailing DIR_SEPARATORs here, but that can
218	 sometimes yield a result with no separator when one was coded
219	 and intended by the user, causing two path components to run
220	 together.  */
221
222      old_name = name;
223      name = concat (prefix, &name[keylen + 1], NULL);
224      free (old_name);
225    }
226
227  return name;
228}
229
230/* In a NUL-terminated STRING, replace character C1 with C2 in-place.  */
231static void
232tr (char *string, int c1, int c2)
233{
234  do
235    {
236      if (*string == c1)
237	*string = c2;
238    }
239  while (*string++);
240}
241
242/* Update PATH using KEY if PATH starts with PREFIX as a directory.
243   The returned string is always malloc-ed, and the caller is
244   responsible for freeing it.  */
245
246char *
247update_path (const char *path, const char *key)
248{
249  char *result, *p;
250  const int len = strlen (std_prefix);
251
252  if (! filename_ncmp (path, std_prefix, len)
253      && (IS_DIR_SEPARATOR (path[len])
254          || path[len] == '\0')
255      && key != 0)
256    {
257      bool free_key = false;
258
259      if (key[0] != '$')
260	{
261	  key = concat ("@", key, NULL);
262	  free_key = true;
263	}
264
265      result = concat (key, &path[len], NULL);
266      if (free_key)
267	free (CONST_CAST (char *, key));
268      result = translate_name (result);
269    }
270  else
271    result = xstrdup (path);
272
273  p = result;
274  while (1)
275    {
276      char *src, *dest;
277
278      p = strchr (p, '.');
279      if (p == NULL)
280	break;
281      /* Look for `/../'  */
282      if (p[1] == '.'
283	  && IS_DIR_SEPARATOR (p[2])
284	  && (p != result && IS_DIR_SEPARATOR (p[-1])))
285	{
286	  *p = 0;
287	  if (!targetm_common.always_strip_dotdot
288	      && access (result, X_OK) == 0)
289	    {
290	      *p = '.';
291	      break;
292	    }
293	  else
294	    {
295	      /* We can't access the dir, so we won't be able to
296		 access dir/.. either.  Strip out `dir/../'.  If `dir'
297		 turns out to be `.', strip one more path component.  */
298	      dest = p;
299	      do
300		{
301		  --dest;
302		  while (dest != result && IS_DIR_SEPARATOR (*dest))
303		    --dest;
304		  while (dest != result && !IS_DIR_SEPARATOR (dest[-1]))
305		    --dest;
306		}
307	      while (dest != result && *dest == '.');
308	      /* If we have something like `./..' or `/..', don't
309		 strip anything more.  */
310	      if (*dest == '.' || IS_DIR_SEPARATOR (*dest))
311		{
312		  *p = '.';
313		  break;
314		}
315	      src = p + 3;
316	      while (IS_DIR_SEPARATOR (*src))
317		++src;
318	      p = dest;
319	      while ((*dest++ = *src++) != 0)
320		;
321	    }
322	}
323      else
324	++p;
325    }
326
327#ifdef UPDATE_PATH_HOST_CANONICALIZE
328  /* Perform host dependent canonicalization when needed.  */
329  UPDATE_PATH_HOST_CANONICALIZE (result);
330#endif
331
332#ifdef DIR_SEPARATOR_2
333  /* Convert DIR_SEPARATOR_2 to DIR_SEPARATOR.  */
334  if (DIR_SEPARATOR_2 != DIR_SEPARATOR)
335    tr (result, DIR_SEPARATOR_2, DIR_SEPARATOR);
336#endif
337
338#if defined (DIR_SEPARATOR) && !defined (DIR_SEPARATOR_2)
339  if (DIR_SEPARATOR != '/')
340    tr (result, '/', DIR_SEPARATOR);
341#endif
342
343  return result;
344}
345
346/* Reset the standard prefix.  */
347void
348set_std_prefix (const char *prefix, int len)
349{
350  std_prefix = save_string (prefix, len);
351}
352