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