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