1 /* Create and destroy argument vectors (argv's) 2 Copyright (C) 1992-2020 Free Software Foundation, Inc. 3 Written by Fred Fish @ Cygnus Support 4 5 This file is part of the libiberty library. 6 Libiberty is free software; you can redistribute it and/or 7 modify it under the terms of the GNU Library General Public 8 License as published by the Free Software Foundation; either 9 version 2 of the License, or (at your option) any later version. 10 11 Libiberty is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 Library General Public License for more details. 15 16 You should have received a copy of the GNU Library General Public 17 License along with libiberty; see the file COPYING.LIB. If 18 not, write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor, 19 Boston, MA 02110-1301, USA. */ 20 21 22 /* Create and destroy argument vectors. An argument vector is simply an 23 array of string pointers, terminated by a NULL pointer. */ 24 25 #ifdef HAVE_CONFIG_H 26 #include "config.h" 27 #endif 28 #include "ansidecl.h" 29 #include "libiberty.h" 30 #include "safe-ctype.h" 31 32 /* Routines imported from standard C runtime libraries. */ 33 34 #include <stddef.h> 35 #include <string.h> 36 #include <stdlib.h> 37 #include <stdio.h> 38 #include <sys/types.h> 39 #ifdef HAVE_UNISTD_H 40 #include <unistd.h> 41 #endif 42 #if HAVE_SYS_STAT_H 43 #include <sys/stat.h> 44 #endif 45 46 #ifndef NULL 47 #define NULL 0 48 #endif 49 50 #ifndef EOS 51 #define EOS '\0' 52 #endif 53 54 #define INITIAL_MAXARGC 8 /* Number of args + NULL in initial argv */ 55 56 57 /* 58 59 @deftypefn Extension char** dupargv (char * const *@var{vector}) 60 61 Duplicate an argument vector. Simply scans through @var{vector}, 62 duplicating each argument until the terminating @code{NULL} is found. 63 Returns a pointer to the argument vector if successful. Returns 64 @code{NULL} if there is insufficient memory to complete building the 65 argument vector. 66 67 @end deftypefn 68 69 */ 70 71 char ** 72 dupargv (char * const *argv) 73 { 74 int argc; 75 char **copy; 76 77 if (argv == NULL) 78 return NULL; 79 80 /* the vector */ 81 for (argc = 0; argv[argc] != NULL; argc++); 82 copy = (char **) xmalloc ((argc + 1) * sizeof (char *)); 83 84 /* the strings */ 85 for (argc = 0; argv[argc] != NULL; argc++) 86 copy[argc] = xstrdup (argv[argc]); 87 copy[argc] = NULL; 88 return copy; 89 } 90 91 /* 92 93 @deftypefn Extension void freeargv (char **@var{vector}) 94 95 Free an argument vector that was built using @code{buildargv}. Simply 96 scans through @var{vector}, freeing the memory for each argument until 97 the terminating @code{NULL} is found, and then frees @var{vector} 98 itself. 99 100 @end deftypefn 101 102 */ 103 104 void freeargv (char **vector) 105 { 106 register char **scan; 107 108 if (vector != NULL) 109 { 110 for (scan = vector; *scan != NULL; scan++) 111 { 112 free (*scan); 113 } 114 free (vector); 115 } 116 } 117 118 static void 119 consume_whitespace (const char **input) 120 { 121 while (ISSPACE (**input)) 122 { 123 (*input)++; 124 } 125 } 126 127 static int 128 only_whitespace (const char* input) 129 { 130 while (*input != EOS && ISSPACE (*input)) 131 input++; 132 133 return (*input == EOS); 134 } 135 136 /* 137 138 @deftypefn Extension char** buildargv (char *@var{sp}) 139 140 Given a pointer to a string, parse the string extracting fields 141 separated by whitespace and optionally enclosed within either single 142 or double quotes (which are stripped off), and build a vector of 143 pointers to copies of the string for each field. The input string 144 remains unchanged. The last element of the vector is followed by a 145 @code{NULL} element. 146 147 All of the memory for the pointer array and copies of the string 148 is obtained from @code{xmalloc}. All of the memory can be returned to the 149 system with the single function call @code{freeargv}, which takes the 150 returned result of @code{buildargv}, as it's argument. 151 152 Returns a pointer to the argument vector if successful. Returns 153 @code{NULL} if @var{sp} is @code{NULL} or if there is insufficient 154 memory to complete building the argument vector. 155 156 If the input is a null string (as opposed to a @code{NULL} pointer), 157 then buildarg returns an argument vector that has one arg, a null 158 string. 159 160 @end deftypefn 161 162 The memory for the argv array is dynamically expanded as necessary. 163 164 In order to provide a working buffer for extracting arguments into, 165 with appropriate stripping of quotes and translation of backslash 166 sequences, we allocate a working buffer at least as long as the input 167 string. This ensures that we always have enough space in which to 168 work, since the extracted arg is never larger than the input string. 169 170 The argument vector is always kept terminated with a @code{NULL} arg 171 pointer, so it can be passed to @code{freeargv} at any time, or 172 returned, as appropriate. 173 174 */ 175 176 char **buildargv (const char *input) 177 { 178 char *arg; 179 char *copybuf; 180 int squote = 0; 181 int dquote = 0; 182 int bsquote = 0; 183 int argc = 0; 184 int maxargc = 0; 185 char **argv = NULL; 186 char **nargv; 187 188 if (input != NULL) 189 { 190 copybuf = (char *) xmalloc (strlen (input) + 1); 191 /* Is a do{}while to always execute the loop once. Always return an 192 argv, even for null strings. See NOTES above, test case below. */ 193 do 194 { 195 /* Pick off argv[argc] */ 196 consume_whitespace (&input); 197 198 if ((maxargc == 0) || (argc >= (maxargc - 1))) 199 { 200 /* argv needs initialization, or expansion */ 201 if (argv == NULL) 202 { 203 maxargc = INITIAL_MAXARGC; 204 nargv = (char **) xmalloc (maxargc * sizeof (char *)); 205 } 206 else 207 { 208 maxargc *= 2; 209 nargv = (char **) xrealloc (argv, maxargc * sizeof (char *)); 210 } 211 argv = nargv; 212 argv[argc] = NULL; 213 } 214 /* Begin scanning arg */ 215 arg = copybuf; 216 while (*input != EOS) 217 { 218 if (ISSPACE (*input) && !squote && !dquote && !bsquote) 219 { 220 break; 221 } 222 else 223 { 224 if (bsquote) 225 { 226 bsquote = 0; 227 *arg++ = *input; 228 } 229 else if (*input == '\\') 230 { 231 bsquote = 1; 232 } 233 else if (squote) 234 { 235 if (*input == '\'') 236 { 237 squote = 0; 238 } 239 else 240 { 241 *arg++ = *input; 242 } 243 } 244 else if (dquote) 245 { 246 if (*input == '"') 247 { 248 dquote = 0; 249 } 250 else 251 { 252 *arg++ = *input; 253 } 254 } 255 else 256 { 257 if (*input == '\'') 258 { 259 squote = 1; 260 } 261 else if (*input == '"') 262 { 263 dquote = 1; 264 } 265 else 266 { 267 *arg++ = *input; 268 } 269 } 270 input++; 271 } 272 } 273 *arg = EOS; 274 argv[argc] = xstrdup (copybuf); 275 argc++; 276 argv[argc] = NULL; 277 278 consume_whitespace (&input); 279 } 280 while (*input != EOS); 281 282 free (copybuf); 283 } 284 return (argv); 285 } 286 287 /* 288 289 @deftypefn Extension int writeargv (char * const *@var{argv}, FILE *@var{file}) 290 291 Write each member of ARGV, handling all necessary quoting, to the file 292 named by FILE, separated by whitespace. Return 0 on success, non-zero 293 if an error occurred while writing to FILE. 294 295 @end deftypefn 296 297 */ 298 299 int 300 writeargv (char * const *argv, FILE *f) 301 { 302 int status = 0; 303 304 if (f == NULL) 305 return 1; 306 307 while (*argv != NULL) 308 { 309 const char *arg = *argv; 310 311 while (*arg != EOS) 312 { 313 char c = *arg; 314 315 if (ISSPACE(c) || c == '\\' || c == '\'' || c == '"') 316 if (EOF == fputc ('\\', f)) 317 { 318 status = 1; 319 goto done; 320 } 321 322 if (EOF == fputc (c, f)) 323 { 324 status = 1; 325 goto done; 326 } 327 arg++; 328 } 329 330 if (EOF == fputc ('\n', f)) 331 { 332 status = 1; 333 goto done; 334 } 335 argv++; 336 } 337 338 done: 339 return status; 340 } 341 342 /* 343 344 @deftypefn Extension void expandargv (int *@var{argcp}, char ***@var{argvp}) 345 346 The @var{argcp} and @code{argvp} arguments are pointers to the usual 347 @code{argc} and @code{argv} arguments to @code{main}. This function 348 looks for arguments that begin with the character @samp{@@}. Any such 349 arguments are interpreted as ``response files''. The contents of the 350 response file are interpreted as additional command line options. In 351 particular, the file is separated into whitespace-separated strings; 352 each such string is taken as a command-line option. The new options 353 are inserted in place of the option naming the response file, and 354 @code{*argcp} and @code{*argvp} will be updated. If the value of 355 @code{*argvp} is modified by this function, then the new value has 356 been dynamically allocated and can be deallocated by the caller with 357 @code{freeargv}. However, most callers will simply call 358 @code{expandargv} near the beginning of @code{main} and allow the 359 operating system to free the memory when the program exits. 360 361 @end deftypefn 362 363 */ 364 365 void 366 expandargv (int *argcp, char ***argvp) 367 { 368 /* The argument we are currently processing. */ 369 int i = 0; 370 /* To check if ***argvp has been dynamically allocated. */ 371 char ** const original_argv = *argvp; 372 /* Limit the number of response files that we parse in order 373 to prevent infinite recursion. */ 374 unsigned int iteration_limit = 2000; 375 /* Loop over the arguments, handling response files. We always skip 376 ARGVP[0], as that is the name of the program being run. */ 377 while (++i < *argcp) 378 { 379 /* The name of the response file. */ 380 const char *filename; 381 /* The response file. */ 382 FILE *f; 383 /* An upper bound on the number of characters in the response 384 file. */ 385 long pos; 386 /* The number of characters in the response file, when actually 387 read. */ 388 size_t len; 389 /* A dynamically allocated buffer used to hold options read from a 390 response file. */ 391 char *buffer; 392 /* Dynamically allocated storage for the options read from the 393 response file. */ 394 char **file_argv; 395 /* The number of options read from the response file, if any. */ 396 size_t file_argc; 397 #ifdef S_ISDIR 398 struct stat sb; 399 #endif 400 /* We are only interested in options of the form "@file". */ 401 filename = (*argvp)[i]; 402 if (filename[0] != '@') 403 continue; 404 /* If we have iterated too many times then stop. */ 405 if (-- iteration_limit == 0) 406 { 407 fprintf (stderr, "%s: error: too many @-files encountered\n", (*argvp)[0]); 408 xexit (1); 409 } 410 #ifdef S_ISDIR 411 if (stat (filename+1, &sb) < 0) 412 continue; 413 if (S_ISDIR(sb.st_mode)) 414 { 415 fprintf (stderr, "%s: error: @-file refers to a directory\n", (*argvp)[0]); 416 xexit (1); 417 } 418 #endif 419 /* Read the contents of the file. */ 420 f = fopen (++filename, "r"); 421 if (!f) 422 continue; 423 if (fseek (f, 0L, SEEK_END) == -1) 424 goto error; 425 pos = ftell (f); 426 if (pos == -1) 427 goto error; 428 if (fseek (f, 0L, SEEK_SET) == -1) 429 goto error; 430 buffer = (char *) xmalloc (pos * sizeof (char) + 1); 431 len = fread (buffer, sizeof (char), pos, f); 432 if (len != (size_t) pos 433 /* On Windows, fread may return a value smaller than POS, 434 due to CR/LF->CR translation when reading text files. 435 That does not in-and-of itself indicate failure. */ 436 && ferror (f)) 437 goto error; 438 /* Add a NUL terminator. */ 439 buffer[len] = '\0'; 440 /* If the file is empty or contains only whitespace, buildargv would 441 return a single empty argument. In this context we want no arguments, 442 instead. */ 443 if (only_whitespace (buffer)) 444 { 445 file_argv = (char **) xmalloc (sizeof (char *)); 446 file_argv[0] = NULL; 447 } 448 else 449 /* Parse the string. */ 450 file_argv = buildargv (buffer); 451 /* If *ARGVP is not already dynamically allocated, copy it. */ 452 if (*argvp == original_argv) 453 *argvp = dupargv (*argvp); 454 /* Count the number of arguments. */ 455 file_argc = 0; 456 while (file_argv[file_argc]) 457 ++file_argc; 458 /* Free the original option's memory. */ 459 free ((*argvp)[i]); 460 /* Now, insert FILE_ARGV into ARGV. The "+1" below handles the 461 NULL terminator at the end of ARGV. */ 462 *argvp = ((char **) 463 xrealloc (*argvp, 464 (*argcp + file_argc + 1) * sizeof (char *))); 465 memmove (*argvp + i + file_argc, *argvp + i + 1, 466 (*argcp - i) * sizeof (char *)); 467 memcpy (*argvp + i, file_argv, file_argc * sizeof (char *)); 468 /* The original option has been replaced by all the new 469 options. */ 470 *argcp += file_argc - 1; 471 /* Free up memory allocated to process the response file. We do 472 not use freeargv because the individual options in FILE_ARGV 473 are now in the main ARGV. */ 474 free (file_argv); 475 free (buffer); 476 /* Rescan all of the arguments just read to support response 477 files that include other response files. */ 478 --i; 479 error: 480 /* We're all done with the file now. */ 481 fclose (f); 482 } 483 } 484 485 /* 486 487 @deftypefn Extension int countargv (char * const *@var{argv}) 488 489 Return the number of elements in @var{argv}. 490 Returns zero if @var{argv} is NULL. 491 492 @end deftypefn 493 494 */ 495 496 int 497 countargv (char * const *argv) 498 { 499 int argc; 500 501 if (argv == NULL) 502 return 0; 503 for (argc = 0; argv[argc] != NULL; argc++) 504 continue; 505 return argc; 506 } 507 508 #ifdef MAIN 509 510 /* Simple little test driver. */ 511 512 static const char *const tests[] = 513 { 514 "a simple command line", 515 "arg 'foo' is single quoted", 516 "arg \"bar\" is double quoted", 517 "arg \"foo bar\" has embedded whitespace", 518 "arg 'Jack said \\'hi\\'' has single quotes", 519 "arg 'Jack said \\\"hi\\\"' has double quotes", 520 "a b c d e f g h i j k l m n o p q r s t u v w x y z 1 2 3 4 5 6 7 8 9", 521 522 /* This should be expanded into only one argument. */ 523 "trailing-whitespace ", 524 525 "", 526 NULL 527 }; 528 529 int 530 main (void) 531 { 532 char **argv; 533 const char *const *test; 534 char **targs; 535 536 for (test = tests; *test != NULL; test++) 537 { 538 printf ("buildargv(\"%s\")\n", *test); 539 if ((argv = buildargv (*test)) == NULL) 540 { 541 printf ("failed!\n\n"); 542 } 543 else 544 { 545 for (targs = argv; *targs != NULL; targs++) 546 { 547 printf ("\t\"%s\"\n", *targs); 548 } 549 printf ("\n"); 550 } 551 freeargv (argv); 552 } 553 554 return 0; 555 } 556 557 #endif /* MAIN */ 558