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