1 /* Relative (relocatable) prefix support. 2 Copyright (C) 1987-2024 Free Software Foundation, Inc. 3 4 This file is part of libiberty. 5 6 GCC is free software; you can redistribute it and/or modify it under 7 the terms of the GNU General Public License as published by the Free 8 Software Foundation; either version 2, or (at your option) any later 9 version. 10 11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 12 WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with GCC; see the file COPYING. If not, write to the Free 18 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 19 02110-1301, USA. */ 20 21 /* 22 23 @deftypefn Extension {const char*} make_relative_prefix (const char *@var{progname}, @ 24 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 if (!*name) 126 return NULL; 127 128 /* Count the number of directories. Special case MSDOS disk names as part 129 of the initial directory. */ 130 p = name; 131 #ifdef HAVE_DOS_BASED_FILE_SYSTEM 132 if (name[1] == ':' && IS_DIR_SEPARATOR (name[2])) 133 { 134 p += 3; 135 num_dirs++; 136 } 137 #endif /* HAVE_DOS_BASED_FILE_SYSTEM */ 138 139 while ((ch = *p++) != '\0') 140 { 141 if (IS_DIR_SEPARATOR (ch)) 142 { 143 num_dirs++; 144 while (IS_DIR_SEPARATOR (*p)) 145 p++; 146 } 147 } 148 149 dirs = (char **) malloc (sizeof (char *) * (num_dirs + 2)); 150 if (dirs == NULL) 151 return NULL; 152 153 /* Now copy the directory parts. */ 154 num_dirs = 0; 155 p = name; 156 #ifdef HAVE_DOS_BASED_FILE_SYSTEM 157 if (name[1] == ':' && IS_DIR_SEPARATOR (name[2])) 158 { 159 dirs[num_dirs++] = save_string (p, 3); 160 if (dirs[num_dirs - 1] == NULL) 161 { 162 free (dirs); 163 return NULL; 164 } 165 p += 3; 166 } 167 #endif /* HAVE_DOS_BASED_FILE_SYSTEM */ 168 169 q = p; 170 while ((ch = *p++) != '\0') 171 { 172 if (IS_DIR_SEPARATOR (ch)) 173 { 174 while (IS_DIR_SEPARATOR (*p)) 175 p++; 176 177 dirs[num_dirs++] = save_string (q, p - q); 178 if (dirs[num_dirs - 1] == NULL) 179 { 180 dirs[num_dirs] = NULL; 181 free_split_directories (dirs); 182 return NULL; 183 } 184 q = p; 185 } 186 } 187 188 if (p - 1 - q > 0) 189 dirs[num_dirs++] = save_string (q, p - 1 - q); 190 dirs[num_dirs] = NULL; 191 192 if (dirs[num_dirs - 1] == NULL) 193 { 194 free_split_directories (dirs); 195 return NULL; 196 } 197 198 if (ptr_num_dirs) 199 *ptr_num_dirs = num_dirs; 200 return dirs; 201 } 202 203 /* Release storage held by split directories. */ 204 205 static void 206 free_split_directories (char **dirs) 207 { 208 int i = 0; 209 210 if (dirs != NULL) 211 { 212 while (dirs[i] != NULL) 213 free (dirs[i++]); 214 215 free ((char *) dirs); 216 } 217 } 218 219 /* Given three strings PROGNAME, BIN_PREFIX, PREFIX, return a string that gets 220 to PREFIX starting with the directory portion of PROGNAME and a relative 221 pathname of the difference between BIN_PREFIX and PREFIX. 222 223 For example, if BIN_PREFIX is /alpha/beta/gamma/gcc/delta, PREFIX is 224 /alpha/beta/gamma/omega/, and PROGNAME is /red/green/blue/gcc, then this 225 function will return /red/green/blue/../../omega/. 226 227 If no relative prefix can be found, return NULL. */ 228 229 static char * 230 make_relative_prefix_1 (const char *progname, const char *bin_prefix, 231 const char *prefix, const int resolve_links) 232 { 233 char **prog_dirs = NULL, **bin_dirs = NULL, **prefix_dirs = NULL; 234 int prog_num, bin_num, prefix_num; 235 int i, n, common; 236 int needed_len; 237 char *ret = NULL, *ptr, *full_progname; 238 char *alloc_ptr = NULL; 239 240 if (progname == NULL || bin_prefix == NULL || prefix == NULL) 241 return NULL; 242 243 /* If there is no full pathname, try to find the program by checking in each 244 of the directories specified in the PATH environment variable. */ 245 if (lbasename (progname) == progname) 246 { 247 char *temp; 248 249 temp = getenv ("PATH"); 250 if (temp) 251 { 252 char *startp, *endp, *nstore; 253 size_t prefixlen = strlen (temp) + 1; 254 size_t len; 255 if (prefixlen < 2) 256 prefixlen = 2; 257 258 len = prefixlen + strlen (progname) + 1; 259 #ifdef HAVE_HOST_EXECUTABLE_SUFFIX 260 len += strlen (HOST_EXECUTABLE_SUFFIX); 261 #endif 262 if (len < MAX_ALLOCA_SIZE) 263 nstore = (char *) alloca (len); 264 else 265 alloc_ptr = nstore = (char *) malloc (len); 266 267 startp = endp = temp; 268 while (1) 269 { 270 if (*endp == PATH_SEPARATOR || *endp == 0) 271 { 272 if (endp == startp) 273 { 274 nstore[0] = '.'; 275 nstore[1] = DIR_SEPARATOR; 276 nstore[2] = '\0'; 277 } 278 else 279 { 280 memcpy (nstore, startp, endp - startp); 281 if (! IS_DIR_SEPARATOR (endp[-1])) 282 { 283 nstore[endp - startp] = DIR_SEPARATOR; 284 nstore[endp - startp + 1] = 0; 285 } 286 else 287 nstore[endp - startp] = 0; 288 } 289 strcat (nstore, progname); 290 if (! access (nstore, X_OK) 291 #ifdef HAVE_HOST_EXECUTABLE_SUFFIX 292 || ! access (strcat (nstore, HOST_EXECUTABLE_SUFFIX), X_OK) 293 #endif 294 ) 295 { 296 #if defined (HAVE_SYS_STAT_H) && defined (S_ISREG) 297 struct stat st; 298 if (stat (nstore, &st) >= 0 && S_ISREG (st.st_mode)) 299 #endif 300 { 301 progname = nstore; 302 break; 303 } 304 } 305 306 if (*endp == 0) 307 break; 308 endp = startp = endp + 1; 309 } 310 else 311 endp++; 312 } 313 } 314 } 315 316 if (resolve_links) 317 full_progname = lrealpath (progname); 318 else 319 full_progname = strdup (progname); 320 if (full_progname == NULL) 321 goto bailout; 322 323 prog_dirs = split_directories (full_progname, &prog_num); 324 free (full_progname); 325 if (prog_dirs == NULL) 326 goto bailout; 327 328 bin_dirs = split_directories (bin_prefix, &bin_num); 329 if (bin_dirs == NULL) 330 goto bailout; 331 332 /* Remove the program name from comparison of directory names. */ 333 prog_num--; 334 335 /* If we are still installed in the standard location, we don't need to 336 specify relative directories. Also, if argv[0] still doesn't contain 337 any directory specifiers after the search above, then there is not much 338 we can do. */ 339 if (prog_num == bin_num) 340 { 341 for (i = 0; i < bin_num; i++) 342 { 343 if (strcmp (prog_dirs[i], bin_dirs[i]) != 0) 344 break; 345 } 346 347 if (prog_num <= 0 || i == bin_num) 348 goto bailout; 349 } 350 351 prefix_dirs = split_directories (prefix, &prefix_num); 352 if (prefix_dirs == NULL) 353 goto bailout; 354 355 /* Find how many directories are in common between bin_prefix & prefix. */ 356 n = (prefix_num < bin_num) ? prefix_num : bin_num; 357 for (common = 0; common < n; common++) 358 { 359 if (strcmp (bin_dirs[common], prefix_dirs[common]) != 0) 360 break; 361 } 362 363 /* If there are no common directories, there can be no relative prefix. */ 364 if (common == 0) 365 goto bailout; 366 367 /* Two passes: first figure out the size of the result string, and 368 then construct it. */ 369 needed_len = 0; 370 for (i = 0; i < prog_num; i++) 371 needed_len += strlen (prog_dirs[i]); 372 needed_len += sizeof (DIR_UP) * (bin_num - common); 373 for (i = common; i < prefix_num; i++) 374 needed_len += strlen (prefix_dirs[i]); 375 needed_len += 1; /* Trailing NUL. */ 376 377 ret = (char *) malloc (needed_len); 378 if (ret == NULL) 379 goto bailout; 380 381 /* Build up the pathnames in argv[0]. */ 382 *ret = '\0'; 383 for (i = 0; i < prog_num; i++) 384 strcat (ret, prog_dirs[i]); 385 386 /* Now build up the ..'s. */ 387 ptr = ret + strlen(ret); 388 for (i = common; i < bin_num; i++) 389 { 390 strcpy (ptr, DIR_UP); 391 ptr += sizeof (DIR_UP) - 1; 392 *(ptr++) = DIR_SEPARATOR; 393 } 394 *ptr = '\0'; 395 396 /* Put in directories to move over to prefix. */ 397 for (i = common; i < prefix_num; i++) 398 strcat (ret, prefix_dirs[i]); 399 400 bailout: 401 free_split_directories (prog_dirs); 402 free_split_directories (bin_dirs); 403 free_split_directories (prefix_dirs); 404 free (alloc_ptr); 405 406 return ret; 407 } 408 409 410 /* Do the full job, including symlink resolution. 411 This path will find files installed in the same place as the 412 program even when a soft link has been made to the program 413 from somwhere else. */ 414 415 char * 416 make_relative_prefix (const char *progname, const char *bin_prefix, 417 const char *prefix) 418 { 419 return make_relative_prefix_1 (progname, bin_prefix, prefix, 1); 420 } 421 422 /* Make the relative pathname without attempting to resolve any links. 423 '..' etc may also be left in the pathname. 424 This will find the files the user meant the program to find if the 425 installation is patched together with soft links. */ 426 427 char * 428 make_relative_prefix_ignore_links (const char *progname, 429 const char *bin_prefix, 430 const char *prefix) 431 { 432 return make_relative_prefix_1 (progname, bin_prefix, prefix, 0); 433 } 434 435
Indexes created Sat Feb 28 05:31:39 UTC 2026