binutils/ar.c

   1 /* ar.c - Archive modify and extract.
   2    Copyright (C) 1991-2017 Free Software Foundation, Inc.
   3
   4    This file is part of GNU Binutils.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program 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
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  19    MA 02110-1301, USA.  */
  20 \f
  21 /*
  22    Bugs: GNU ar used to check file against filesystem in quick_update and
  23    replace operations (would check mtime). Doesn't warn when name truncated.
  24    No way to specify pos_end. Error messages should be more consistent.  */
  25
  26 #include "sysdep.h"
  27 #include "bfd.h"
  28 #include "libiberty.h"
  29 #include "progress.h"
  30 #include "getopt.h"
  31 #include "aout/ar.h"
  32 #include "bucomm.h"
  33 #include "arsup.h"
  34 #include "filenames.h"
  35 #include "binemul.h"
  36 #include "plugin-api.h"
  37 #include "plugin.h"
  38
  39 #ifdef __GO32___
  40 #define EXT_NAME_LEN 3          /* Bufflen of addition to name if it's MS-DOS.  */
  41 #else
  42 #define EXT_NAME_LEN 6          /* Ditto for *NIX.  */
  43 #endif
  44
  45 /* Static declarations.  */
  46
  47 static void mri_emul (void);
  48 static const char *normalize (const char *, bfd *);
  49 static void remove_output (void);
  50 static void map_over_members (bfd *, void (*)(bfd *), char **, int);
  51 static void print_contents (bfd * member);
  52 static void delete_members (bfd *, char **files_to_delete);
  53
  54 static void move_members (bfd *, char **files_to_move);
  55 static void replace_members
  56   (bfd *, char **files_to_replace, bfd_boolean quick);
  57 static void print_descr (bfd * abfd);
  58 static void write_archive (bfd *);
  59 static int  ranlib_only (const char *archname);
  60 static int  ranlib_touch (const char *archname);
  61 static void usage (int);
  62 \f
  63 /** Globals and flags.  */
  64
  65 static int mri_mode;
  66
  67 /* This flag distinguishes between ar and ranlib:
  68    1 means this is 'ranlib'; 0 means this is 'ar'.
  69    -1 means if we should use argv[0] to decide.  */
  70 extern int is_ranlib;
  71
  72 /* Nonzero means don't warn about creating the archive file if necessary.  */
  73 int silent_create = 0;
  74
  75 /* Nonzero means describe each action performed.  */
  76 int verbose = 0;
  77
  78 /* Nonzero means preserve dates of members when extracting them.  */
  79 int preserve_dates = 0;
  80
  81 /* Nonzero means don't replace existing members whose dates are more recent
  82    than the corresponding files.  */
  83 int newer_only = 0;
  84
  85 /* Controls the writing of an archive symbol table (in BSD: a __.SYMDEF
  86    member).  -1 means we've been explicitly asked to not write a symbol table;
  87    +1 means we've been explicitly asked to write it;
  88    0 is the default.
  89    Traditionally, the default in BSD has been to not write the table.
  90    However, for POSIX.2 compliance the default is now to write a symbol table
  91    if any of the members are object files.  */
  92 int write_armap = 0;
  93
  94 /* Operate in deterministic mode: write zero for timestamps, uids,
  95    and gids for archive members and the archive symbol table, and write
  96    consistent file modes.  */
  97 int deterministic = -1;                 /* Determinism indeterminate.  */
  98
  99 /* Nonzero means it's the name of an existing member; position new or moved
 100    files with respect to this one.  */
 101 char *posname = NULL;
 102
 103 /* Sez how to use `posname': pos_before means position before that member.
 104    pos_after means position after that member. pos_end means always at end.
 105    pos_default means default appropriately. For the latter two, `posname'
 106    should also be zero.  */
 107 enum pos
 108   {
 109     pos_default, pos_before, pos_after, pos_end
 110   } postype = pos_default;
 111
 112 enum operations
 113   {
 114     none = 0, del, replace, print_table,
 115     print_files, extract, move, quick_append
 116   } operation = none;
 117
 118 static bfd **
 119 get_pos_bfd (bfd **, enum pos, const char *);
 120
 121 /* For extract/delete only.  If COUNTED_NAME_MODE is TRUE, we only
 122    extract the COUNTED_NAME_COUNTER instance of that name.  */
 123 static bfd_boolean counted_name_mode = 0;
 124 static int counted_name_counter = 0;
 125
 126 /* Whether to truncate names of files stored in the archive.  */
 127 static bfd_boolean ar_truncate = FALSE;
 128
 129 /* Whether to use a full file name match when searching an archive.
 130    This is convenient for archives created by the Microsoft lib
 131    program.  */
 132 static bfd_boolean full_pathname = FALSE;
 133
 134 /* Whether to create a "thin" archive (symbol index only -- no files).  */
 135 static bfd_boolean make_thin_archive = FALSE;
 136
 137 static int show_version = 0;
 138
 139 static int show_help = 0;
 140
 141 #if BFD_SUPPORTS_PLUGINS
 142 static const char *plugin_target = "plugin";
 143 #else
 144 static const char *plugin_target = NULL;
 145 #endif
 146
 147 static const char *target = NULL;
 148
 149 #define OPTION_PLUGIN 201
 150 #define OPTION_TARGET 202
 151
 152 static struct option long_options[] =
 153 {
 154   {"help", no_argument, &show_help, 1},
 155   {"plugin", required_argument, NULL, OPTION_PLUGIN},
 156   {"target", required_argument, NULL, OPTION_TARGET},
 157   {"version", no_argument, &show_version, 1},
 158   {NULL, no_argument, NULL, 0}
 159 };
 160
 161 int interactive = 0;
 162
 163 static void
 164 mri_emul (void)
 165 {
 166   interactive = isatty (fileno (stdin));
 167   yyparse ();
 168 }
 169
 170 /* If COUNT is 0, then FUNCTION is called once on each entry.  If nonzero,
 171    COUNT is the length of the FILES chain; FUNCTION is called on each entry
 172    whose name matches one in FILES.  */
 173
 174 static void
 175 map_over_members (bfd *arch, void (*function)(bfd *), char **files, int count)
 176 {
 177   bfd *head;
 178   int match_count;
 179
 180   if (count == 0)
 181     {
 182       for (head = arch->archive_next; head; head = head->archive_next)
 183         {
 184           PROGRESS (1);
 185           function (head);
 186         }
 187       return;
 188     }
 189
 190   /* This may appear to be a baroque way of accomplishing what we want.
 191      However we have to iterate over the filenames in order to notice where
 192      a filename is requested but does not exist in the archive.  Ditto
 193      mapping over each file each time -- we want to hack multiple
 194      references.  */
 195
 196   for (head = arch->archive_next; head; head = head->archive_next)
 197     head->archive_pass = 0;
 198
 199   for (; count > 0; files++, count--)
 200     {
 201       bfd_boolean found = FALSE;
 202
 203       match_count = 0;
 204       for (head = arch->archive_next; head; head = head->archive_next)
 205         {
 206           const char * filename;
 207
 208           PROGRESS (1);
 209           /* PR binutils/15796: Once an archive element has been matched
 210              do not match it again.  If the user provides multiple same-named
 211              parameters on the command line their intent is to match multiple
 212              same-named entries in the archive, not the same entry multiple
 213              times.  */
 214           if (head->archive_pass)
 215             continue;
 216
 217           filename = head->filename;
 218           if (filename == NULL)
 219             {
 220               /* Some archive formats don't get the filenames filled in
 221                  until the elements are opened.  */
 222               struct stat buf;
 223               bfd_stat_arch_elt (head, &buf);
 224             }
 225           else if (bfd_is_thin_archive (arch))
 226             {
 227               /* Thin archives store full pathnames.  Need to normalize.  */
 228               filename = normalize (filename, arch);
 229             }
 230
 231           if (filename != NULL
 232               && !FILENAME_CMP (normalize (*files, arch), filename))
 233             {
 234               ++match_count;
 235               if (counted_name_mode
 236                   && match_count != counted_name_counter)
 237                 {
 238                   /* Counting, and didn't match on count; go on to the
 239                      next one.  */
 240                   continue;
 241                 }
 242
 243               found = TRUE;
 244               function (head);
 245               head->archive_pass = 1;
 246               /* PR binutils/15796: Once a file has been matched, do not
 247                  match any more same-named files in the archive.  If the
 248                  user does want to match multiple same-name files in an
 249                  archive they should provide multiple same-name parameters
 250                  to the ar command.  */
 251               break;
 252             }
 253         }
 254
 255       if (!found)
 256         /* xgettext:c-format */
 257         fprintf (stderr, _("no entry %s in archive\n"), *files);
 258     }
 259 }
 260 \f
 261 bfd_boolean operation_alters_arch = FALSE;
 262
 263 static void
 264 usage (int help)
 265 {
 266   FILE *s;
 267
 268 #if BFD_SUPPORTS_PLUGINS
 269   /* xgettext:c-format */
 270   const char *command_line
 271     = _("Usage: %s [emulation options] [-]{dmpqrstx}[abcDfilMNoPsSTuvV]"
 272         " [--plugin <name>] [member-name] [count] archive-file file...\n");
 273
 274 #else
 275   /* xgettext:c-format */
 276   const char *command_line
 277     = _("Usage: %s [emulation options] [-]{dmpqrstx}[abcDfilMNoPsSTuvV]"
 278         " [member-name] [count] archive-file file...\n");
 279 #endif
 280   s = help ? stdout : stderr;
 281
 282   fprintf (s, command_line, program_name);
 283
 284   /* xgettext:c-format */
 285   fprintf (s, _("       %s -M [<mri-script]\n"), program_name);
 286   fprintf (s, _(" commands:\n"));
 287   fprintf (s, _("  d            - delete file(s) from the archive\n"));
 288   fprintf (s, _("  m[ab]        - move file(s) in the archive\n"));
 289   fprintf (s, _("  p            - print file(s) found in the archive\n"));
 290   fprintf (s, _("  q[f]         - quick append file(s) to the archive\n"));
 291   fprintf (s, _("  r[ab][f][u]  - replace existing or insert new file(s) into the archive\n"));
 292   fprintf (s, _("  s            - act as ranlib\n"));
 293   fprintf (s, _("  t            - display contents of archive\n"));
 294   fprintf (s, _("  x[o]         - extract file(s) from the archive\n"));
 295   fprintf (s, _(" command specific modifiers:\n"));
 296   fprintf (s, _("  [a]          - put file(s) after [member-name]\n"));
 297   fprintf (s, _("  [b]          - put file(s) before [member-name] (same as [i])\n"));
 298   if (DEFAULT_AR_DETERMINISTIC)
 299     {
 300       fprintf (s, _("\
 301   [D]          - use zero for timestamps and uids/gids (default)\n"));
 302       fprintf (s, _("\
 303   [U]          - use actual timestamps and uids/gids\n"));
 304     }
 305   else
 306     {
 307       fprintf (s, _("\
 308   [D]          - use zero for timestamps and uids/gids\n"));
 309       fprintf (s, _("\
 310   [U]          - use actual timestamps and uids/gids (default)\n"));
 311     }
 312   fprintf (s, _("  [N]          - use instance [count] of name\n"));
 313   fprintf (s, _("  [f]          - truncate inserted file names\n"));
 314   fprintf (s, _("  [P]          - use full path names when matching\n"));
 315   fprintf (s, _("  [o]          - preserve original dates\n"));
 316   fprintf (s, _("  [u]          - only replace files that are newer than current archive contents\n"));
 317   fprintf (s, _(" generic modifiers:\n"));
 318   fprintf (s, _("  [c]          - do not warn if the library had to be created\n"));
 319   fprintf (s, _("  [s]          - create an archive index (cf. ranlib)\n"));
 320   fprintf (s, _("  [S]          - do not build a symbol table\n"));
 321   fprintf (s, _("  [T]          - make a thin archive\n"));
 322   fprintf (s, _("  [v]          - be verbose\n"));
 323   fprintf (s, _("  [V]          - display the version number\n"));
 324   fprintf (s, _("  @<file>      - read options from <file>\n"));
 325   fprintf (s, _("  --target=BFDNAME - specify the target object format as BFDNAME\n"));
 326 #if BFD_SUPPORTS_PLUGINS
 327   fprintf (s, _(" optional:\n"));
 328   fprintf (s, _("  --plugin <p> - load the specified plugin\n"));
 329 #endif
 330
 331   ar_emul_usage (s);
 332
 333   list_supported_targets (program_name, s);
 334
 335   if (REPORT_BUGS_TO[0] && help)
 336     fprintf (s, _("Report bugs to %s\n"), REPORT_BUGS_TO);
 337
 338   xexit (help ? 0 : 1);
 339 }
 340
 341 static void
 342 ranlib_usage (int help)
 343 {
 344   FILE *s;
 345
 346   s = help ? stdout : stderr;
 347
 348   /* xgettext:c-format */
 349   fprintf (s, _("Usage: %s [options] archive\n"), program_name);
 350   fprintf (s, _(" Generate an index to speed access to archives\n"));
 351   fprintf (s, _(" The options are:\n\
 352   @<file>                      Read options from <file>\n"));
 353 #if BFD_SUPPORTS_PLUGINS
 354   fprintf (s, _("\
 355   --plugin <name>              Load the specified plugin\n"));
 356 #endif
 357   if (DEFAULT_AR_DETERMINISTIC)
 358     fprintf (s, _("\
 359   -D                           Use zero for symbol map timestamp (default)\n\
 360   -U                           Use an actual symbol map timestamp\n"));
 361   else
 362     fprintf (s, _("\
 363   -D                           Use zero for symbol map timestamp\n\
 364   -U                           Use actual symbol map timestamp (default)\n"));
 365   fprintf (s, _("\
 366   -t                           Update the archive's symbol map timestamp\n\
 367   -h --help                    Print this help message\n\
 368   -v --version                 Print version information\n"));
 369
 370   list_supported_targets (program_name, s);
 371
 372   if (REPORT_BUGS_TO[0] && help)
 373     fprintf (s, _("Report bugs to %s\n"), REPORT_BUGS_TO);
 374
 375   xexit (help ? 0 : 1);
 376 }
 377
 378 /* Normalize a file name specified on the command line into a file
 379    name which we will use in an archive.  */
 380
 381 static const char *
 382 normalize (const char *file, bfd *abfd)
 383 {
 384   const char *filename;
 385
 386   if (full_pathname)
 387     return file;
 388
 389   filename = lbasename (file);
 390
 391   if (ar_truncate
 392       && abfd != NULL
 393       && strlen (filename) > abfd->xvec->ar_max_namelen)
 394     {
 395       char *s;
 396
 397       /* Space leak.  */
 398       s = (char *) xmalloc (abfd->xvec->ar_max_namelen + 1);
 399       memcpy (s, filename, abfd->xvec->ar_max_namelen);
 400       s[abfd->xvec->ar_max_namelen] = '\0';
 401       filename = s;
 402     }
 403
 404   return filename;
 405 }
 406
 407 /* Remove any output file.  This is only called via xatexit.  */
 408
 409 static const char *output_filename = NULL;
 410 static FILE *output_file = NULL;
 411 static bfd *output_bfd = NULL;
 412
 413 static void
 414 remove_output (void)
 415 {
 416   if (output_filename != NULL)
 417     {
 418       if (output_bfd != NULL)
 419         bfd_cache_close (output_bfd);
 420       if (output_file != NULL)
 421         fclose (output_file);
 422       unlink_if_ordinary (output_filename);
 423     }
 424 }
 425
 426 static char **
 427 decode_options (int argc, char **argv)
 428 {
 429   int c;
 430
 431   /* Convert old-style tar call by exploding option element and rearranging
 432      options accordingly.  */
 433
 434   if (argc > 1 && argv[1][0] != '-')
 435     {
 436       int new_argc;             /* argc value for rearranged arguments */
 437       char **new_argv;          /* argv value for rearranged arguments */
 438       char *const *in;          /* cursor into original argv */
 439       char **out;               /* cursor into rearranged argv */
 440       const char *letter;       /* cursor into old option letters */
 441       char buffer[3];           /* constructed option buffer */
 442
 443       /* Initialize a constructed option.  */
 444
 445       buffer[0] = '-';
 446       buffer[2] = '\0';
 447
 448       /* Allocate a new argument array, and copy program name in it.  */
 449
 450       new_argc = argc - 1 + strlen (argv[1]);
 451       new_argv = xmalloc ((new_argc + 1) * sizeof (*argv));
 452       in = argv;
 453       out = new_argv;
 454       *out++ = *in++;
 455
 456       /* Copy each old letter option as a separate option.  */
 457
 458       for (letter = *in++; *letter; letter++)
 459         {
 460           buffer[1] = *letter;
 461           *out++ = xstrdup (buffer);
 462         }
 463
 464       /* Copy all remaining options.  */
 465
 466       while (in < argv + argc)
 467         *out++ = *in++;
 468       *out = NULL;
 469
 470       /* Replace the old option list by the new one.  */
 471
 472       argc = new_argc;
 473       argv = new_argv;
 474     }
 475
 476   while ((c = getopt_long (argc, argv, "hdmpqrtxlcoVsSuvabiMNfPTDU",
 477                            long_options, NULL)) != EOF)
 478     {
 479       switch (c)
 480         {
 481         case 'd':
 482         case 'm':
 483         case 'p':
 484         case 'q':
 485         case 'r':
 486         case 't':
 487         case 'x':
 488           if (operation != none)
 489             fatal (_("two different operation options specified"));
 490           break;
 491         }
 492
 493       switch (c)
 494         {
 495         case 'h':
 496           show_help = 1;
 497           break;
 498         case 'd':
 499           operation = del;
 500           operation_alters_arch = TRUE;
 501           break;
 502         case 'm':
 503           operation = move;
 504           operation_alters_arch = TRUE;
 505           break;
 506         case 'p':
 507           operation = print_files;
 508           break;
 509         case 'q':
 510           operation = quick_append;
 511           operation_alters_arch = TRUE;
 512           break;
 513         case 'r':
 514           operation = replace;
 515           operation_alters_arch = TRUE;
 516           break;
 517         case 't':
 518           operation = print_table;
 519           break;
 520         case 'x':
 521           operation = extract;
 522           break;
 523         case 'l':
 524           break;
 525         case 'c':
 526           silent_create = 1;
 527           break;
 528         case 'o':
 529           preserve_dates = 1;
 530           break;
 531         case 'V':
 532           show_version = TRUE;
 533           break;
 534         case 's':
 535           write_armap = 1;
 536           break;
 537         case 'S':
 538           write_armap = -1;
 539           break;
 540         case 'u':
 541           newer_only = 1;
 542           break;
 543         case 'v':
 544           verbose = 1;
 545           break;
 546         case 'a':
 547           postype = pos_after;
 548           break;
 549         case 'b':
 550           postype = pos_before;
 551           break;
 552         case 'i':
 553           postype = pos_before;
 554           break;
 555         case 'M':
 556           mri_mode = 1;
 557           break;
 558         case 'N':
 559           counted_name_mode = TRUE;
 560           break;
 561         case 'f':
 562           ar_truncate = TRUE;
 563           break;
 564         case 'P':
 565           full_pathname = TRUE;
 566           break;
 567         case 'T':
 568           make_thin_archive = TRUE;
 569           break;
 570         case 'D':
 571           deterministic = TRUE;
 572           break;
 573         case 'U':
 574           deterministic = FALSE;
 575           break;
 576         case OPTION_PLUGIN:
 577 #if BFD_SUPPORTS_PLUGINS
 578           bfd_plugin_set_plugin (optarg);
 579 #else
 580           fprintf (stderr, _("sorry - this program has been built without plugin support\n"));
 581           xexit (1);
 582 #endif
 583           break;
 584         case OPTION_TARGET:
 585           target = optarg;
 586           break;
 587         case 0:         /* A long option that just sets a flag.  */
 588           break;
 589         default:
 590           usage (0);
 591         }
 592     }
 593
 594   return &argv[optind];
 595 }
 596
 597 /* If neither -D nor -U was specified explicitly,
 598    then use the configured default.  */
 599 static void
 600 default_deterministic (void)
 601 {
 602   if (deterministic < 0)
 603     deterministic = DEFAULT_AR_DETERMINISTIC;
 604 }
 605
 606 static void
 607 ranlib_main (int argc, char **argv)
 608 {
 609   int arg_index, status = 0;
 610   bfd_boolean touch = FALSE;
 611   int c;
 612
 613   while ((c = getopt_long (argc, argv, "DhHUvVt", long_options, NULL)) != EOF)
 614     {
 615       switch (c)
 616         {
 617         case 'D':
 618           deterministic = TRUE;
 619           break;
 620         case 'U':
 621           deterministic = FALSE;
 622           break;
 623         case 'h':
 624         case 'H':
 625           show_help = 1;
 626           break;
 627         case 't':
 628           touch = TRUE;
 629           break;
 630         case 'v':
 631         case 'V':
 632           show_version = 1;
 633           break;
 634
 635           /* PR binutils/13493: Support plugins.  */
 636         case OPTION_PLUGIN:
 637 #if BFD_SUPPORTS_PLUGINS
 638           bfd_plugin_set_plugin (optarg);
 639 #else
 640           fprintf (stderr, _("sorry - this program has been built without plugin support\n"));
 641           xexit (1);
 642 #endif
 643           break;
 644         }
 645     }
 646
 647   if (argc < 2)
 648     ranlib_usage (0);
 649
 650   if (show_help)
 651     ranlib_usage (1);
 652
 653   if (show_version)
 654     print_version ("ranlib");
 655
 656   default_deterministic ();
 657
 658   arg_index = optind;
 659
 660   while (arg_index < argc)
 661     {
 662       if (! touch)
 663         status |= ranlib_only (argv[arg_index]);
 664       else
 665         status |= ranlib_touch (argv[arg_index]);
 666       ++arg_index;
 667     }
 668
 669   xexit (status);
 670 }
 671
 672 int main (int, char **);
 673
 674 int
 675 main (int argc, char **argv)
 676 {
 677   int arg_index;
 678   char **files;
 679   int file_count;
 680   char *inarch_filename;
 681   int i;
 682
 683 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
 684   setlocale (LC_MESSAGES, "");
 685 #endif
 686 #if defined (HAVE_SETLOCALE)
 687   setlocale (LC_CTYPE, "");
 688 #endif
 689   bindtextdomain (PACKAGE, LOCALEDIR);
 690   textdomain (PACKAGE);
 691
 692   program_name = argv[0];
 693   xmalloc_set_program_name (program_name);
 694   bfd_set_error_program_name (program_name);
 695 #if BFD_SUPPORTS_PLUGINS
 696   bfd_plugin_set_program_name (program_name);
 697 #endif
 698
 699   expandargv (&argc, &argv);
 700
 701   if (is_ranlib < 0)
 702     {
 703       const char *temp = lbasename (program_name);
 704
 705       if (strlen (temp) >= 6
 706           && FILENAME_CMP (temp + strlen (temp) - 6, "ranlib") == 0)
 707         is_ranlib = 1;
 708       else
 709         is_ranlib = 0;
 710     }
 711
 712   START_PROGRESS (program_name, 0);
 713
 714   bfd_init ();
 715   set_default_bfd_target ();
 716
 717   xatexit (remove_output);
 718
 719   for (i = 1; i < argc; i++)
 720     if (! ar_emul_parse_arg (argv[i]))
 721       break;
 722   argv += (i - 1);
 723   argc -= (i - 1);
 724
 725   if (is_ranlib)
 726     ranlib_main (argc, argv);
 727
 728   if (argc < 2)
 729     usage (0);
 730
 731   argv = decode_options (argc, argv);
 732
 733   if (show_help)
 734     usage (1);
 735
 736   if (show_version)
 737     print_version ("ar");
 738
 739   arg_index = 0;
 740
 741   if (mri_mode)
 742     {
 743       default_deterministic ();
 744       mri_emul ();
 745     }
 746   else
 747     {
 748       bfd *arch;
 749
 750       /* Fail if no files are specified on the command line.
 751          (But not for MRI mode which allows for reading arguments
 752          and filenames from stdin).  */
 753       if (argv[arg_index] == NULL)
 754         usage (0);
 755
 756       /* We don't use do_quick_append any more.  Too many systems
 757          expect ar to always rebuild the symbol table even when q is
 758          used.  */
 759
 760       /* We can't write an armap when using ar q, so just do ar r
 761          instead.  */
 762       if (operation == quick_append && write_armap)
 763         operation = replace;
 764
 765       if ((operation == none || operation == print_table)
 766           && write_armap == 1)
 767         xexit (ranlib_only (argv[arg_index]));
 768
 769       if (operation == none)
 770         fatal (_("no operation specified"));
 771
 772       if (newer_only && operation != replace)
 773         fatal (_("`u' is only meaningful with the `r' option."));
 774
 775       if (newer_only && deterministic > 0)
 776         fatal (_("`u' is not meaningful with the `D' option."));
 777
 778       if (newer_only && deterministic < 0 && DEFAULT_AR_DETERMINISTIC)
 779         non_fatal (_("\
 780 `u' modifier ignored since `D' is the default (see `U')"));
 781
 782       default_deterministic ();
 783
 784       if (postype != pos_default)
 785         {
 786           posname = argv[arg_index++];
 787           if (posname == NULL)
 788             fatal (_("missing position arg."));
 789         }
 790
 791       if (counted_name_mode)
 792         {
 793           if (operation != extract && operation != del)
 794             fatal (_("`N' is only meaningful with the `x' and `d' options."));
 795           if (argv[arg_index] == NULL)
 796             fatal (_("`N' missing value."));
 797           counted_name_counter = atoi (argv[arg_index++]);
 798           if (counted_name_counter <= 0)
 799             fatal (_("Value for `N' must be positive."));
 800         }
 801
 802       inarch_filename = argv[arg_index++];
 803       if (inarch_filename == NULL)
 804         usage (0);
 805
 806       for (file_count = 0; argv[arg_index + file_count] != NULL; file_count++)
 807         continue;
 808
 809       files = (file_count > 0) ? argv + arg_index : NULL;
 810
 811       arch = open_inarch (inarch_filename,
 812                           files == NULL ? (char *) NULL : files[0]);
 813
 814       if (operation == extract && bfd_is_thin_archive (arch))
 815         fatal (_("`x' cannot be used on thin archives."));
 816
 817       switch (operation)
 818         {
 819         case print_table:
 820           map_over_members (arch, print_descr, files, file_count);
 821           break;
 822
 823         case print_files:
 824           map_over_members (arch, print_contents, files, file_count);
 825           break;
 826
 827         case extract:
 828           map_over_members (arch, extract_file, files, file_count);
 829           break;
 830
 831         case del:
 832           if (files != NULL)
 833             delete_members (arch, files);
 834           else
 835             output_filename = NULL;
 836           break;
 837
 838         case move:
 839           /* PR 12558: Creating and moving at the same time does
 840              not make sense.  Just create the archive instead.  */
 841           if (! silent_create)
 842             {
 843               if (files != NULL)
 844                 move_members (arch, files);
 845               else
 846                 output_filename = NULL;
 847               break;
 848             }
 849           /* Fall through.  */
 850
 851         case replace:
 852         case quick_append:
 853           if (files != NULL || write_armap > 0)
 854             replace_members (arch, files, operation == quick_append);
 855           else
 856             output_filename = NULL;
 857           break;
 858
 859           /* Shouldn't happen! */
 860         default:
 861           /* xgettext:c-format */
 862           fatal (_("internal error -- this option not implemented"));
 863         }
 864     }
 865
 866   END_PROGRESS (program_name);
 867
 868   xexit (0);
 869   return 0;
 870 }
 871
 872 bfd *
 873 open_inarch (const char *archive_filename, const char *file)
 874 {
 875   bfd **last_one;
 876   bfd *next_one;
 877   struct stat sbuf;
 878   bfd *arch;
 879   char **matching;
 880
 881   bfd_set_error (bfd_error_no_error);
 882
 883   if (target == NULL)
 884     target = plugin_target;
 885
 886   if (stat (archive_filename, &sbuf) != 0)
 887     {
 888 #if !defined(__GO32__) || defined(__DJGPP__)
 889
 890       /* FIXME: I don't understand why this fragment was ifndef'ed
 891          away for __GO32__; perhaps it was in the days of DJGPP v1.x.
 892          stat() works just fine in v2.x, so I think this should be
 893          removed.  For now, I enable it for DJGPP v2. -- EZ.  */
 894
 895       /* KLUDGE ALERT! Temporary fix until I figger why
 896          stat() is wrong ... think it's buried in GO32's IDT - Jax */
 897       if (errno != ENOENT)
 898         bfd_fatal (archive_filename);
 899 #endif
 900
 901       if (!operation_alters_arch)
 902         {
 903           fprintf (stderr, "%s: ", program_name);
 904           perror (archive_filename);
 905           maybequit ();
 906           return NULL;
 907         }
 908
 909       /* If the target isn't set, try to figure out the target to use
 910          for the archive from the first object on the list.  */
 911       if (target == NULL && file != NULL)
 912         {
 913           bfd *obj;
 914
 915           obj = bfd_openr (file, target);
 916           if (obj != NULL)
 917             {
 918               if (bfd_check_format (obj, bfd_object))
 919                 target = bfd_get_target (obj);
 920               (void) bfd_close (obj);
 921             }
 922         }
 923
 924       /* Create an empty archive.  */
 925       arch = bfd_openw (archive_filename, target);
 926       if (arch == NULL
 927           || ! bfd_set_format (arch, bfd_archive)
 928           || ! bfd_close (arch))
 929         bfd_fatal (archive_filename);
 930       else if (!silent_create)
 931         non_fatal (_("creating %s"), archive_filename);
 932
 933       /* If we die creating a new archive, don't leave it around.  */
 934       output_filename = archive_filename;
 935     }
 936
 937   arch = bfd_openr (archive_filename, target);
 938   if (arch == NULL)
 939     {
 940     bloser:
 941       bfd_fatal (archive_filename);
 942     }
 943
 944   if (! bfd_check_format_matches (arch, bfd_archive, &matching))
 945     {
 946       bfd_nonfatal (archive_filename);
 947       if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
 948         {
 949           list_matching_formats (matching);
 950           free (matching);
 951         }
 952       xexit (1);
 953     }
 954
 955   if ((operation == replace || operation == quick_append)
 956       && bfd_openr_next_archived_file (arch, NULL) != NULL)
 957     {
 958       /* PR 15140: Catch attempts to convert a normal
 959          archive into a thin archive or vice versa.  */
 960       if (make_thin_archive && ! bfd_is_thin_archive (arch))
 961         {
 962           fatal (_("Cannot convert existing library %s to thin format"),
 963                  bfd_get_filename (arch));
 964           goto bloser;
 965         }
 966       else if (! make_thin_archive && bfd_is_thin_archive (arch))
 967         {
 968           fatal (_("Cannot convert existing thin library %s to normal format"),
 969                  bfd_get_filename (arch));
 970           goto bloser;
 971         }
 972     }
 973
 974   last_one = &(arch->archive_next);
 975   /* Read all the contents right away, regardless.  */
 976   for (next_one = bfd_openr_next_archived_file (arch, NULL);
 977        next_one;
 978        next_one = bfd_openr_next_archived_file (arch, next_one))
 979     {
 980       PROGRESS (1);
 981       *last_one = next_one;
 982       last_one = &next_one->archive_next;
 983     }
 984   *last_one = (bfd *) NULL;
 985   if (bfd_get_error () != bfd_error_no_more_archived_files)
 986     goto bloser;
 987   return arch;
 988 }
 989
 990 static void
 991 print_contents (bfd *abfd)
 992 {
 993   bfd_size_type ncopied = 0;
 994   bfd_size_type size;
 995   char *cbuf = (char *) xmalloc (BUFSIZE);
 996   struct stat buf;
 997
 998   if (bfd_stat_arch_elt (abfd, &buf) != 0)
 999     /* xgettext:c-format */
1000     fatal (_("internal stat error on %s"), bfd_get_filename (abfd));
1001
1002   if (verbose)
1003     printf ("\n<%s>\n\n", bfd_get_filename (abfd));
1004
1005   bfd_seek (abfd, (file_ptr) 0, SEEK_SET);
1006
1007   size = buf.st_size;
1008   while (ncopied < size)
1009     {
1010       bfd_size_type nread;
1011       bfd_size_type tocopy = size - ncopied;
1012
1013       if (tocopy > BUFSIZE)
1014         tocopy = BUFSIZE;
1015
1016       nread = bfd_bread (cbuf, tocopy, abfd);
1017       if (nread != tocopy)
1018         /* xgettext:c-format */
1019         fatal (_("%s is not a valid archive"),
1020                bfd_get_filename (abfd->my_archive));
1021
1022       /* fwrite in mingw32 may return int instead of bfd_size_type. Cast the
1023          return value to bfd_size_type to avoid comparison between signed and
1024          unsigned values.  */
1025       if ((bfd_size_type) fwrite (cbuf, 1, nread, stdout) != nread)
1026         fatal ("stdout: %s", strerror (errno));
1027       ncopied += tocopy;
1028     }
1029   free (cbuf);
1030 }
1031
1032 /* Extract a member of the archive into its own file.
1033
1034    We defer opening the new file until after we have read a BUFSIZ chunk of the
1035    old one, since we know we have just read the archive header for the old
1036    one.  Since most members are shorter than BUFSIZ, this means we will read
1037    the old header, read the old data, write a new inode for the new file, and
1038    write the new data, and be done. This 'optimization' is what comes from
1039    sitting next to a bare disk and hearing it every time it seeks.  -- Gnu
1040    Gilmore  */
1041
1042 void
1043 extract_file (bfd *abfd)
1044 {
1045   FILE *ostream;
1046   char *cbuf = (char *) xmalloc (BUFSIZE);
1047   bfd_size_type nread, tocopy;
1048   bfd_size_type ncopied = 0;
1049   bfd_size_type size;
1050   struct stat buf;
1051
1052   /* PR binutils/17533: Do not allow directory traversal
1053      outside of the current directory tree.  */
1054   if (! is_valid_archive_path (bfd_get_filename (abfd)))
1055     {
1056       non_fatal (_("illegal pathname found in archive member: %s"),
1057                  bfd_get_filename (abfd));
1058       free (cbuf);
1059       return;
1060     }
1061
1062   if (bfd_stat_arch_elt (abfd, &buf) != 0)
1063     /* xgettext:c-format */
1064     fatal (_("internal stat error on %s"), bfd_get_filename (abfd));
1065   size = buf.st_size;
1066
1067   if (verbose)
1068     printf ("x - %s\n", bfd_get_filename (abfd));
1069
1070   bfd_seek (abfd, (file_ptr) 0, SEEK_SET);
1071
1072   ostream = NULL;
1073   if (size == 0)
1074     {
1075       /* Seems like an abstraction violation, eh?  Well it's OK! */
1076       output_filename = bfd_get_filename (abfd);
1077
1078       ostream = fopen (bfd_get_filename (abfd), FOPEN_WB);
1079       if (ostream == NULL)
1080         {
1081           perror (bfd_get_filename (abfd));
1082           xexit (1);
1083         }
1084
1085       output_file = ostream;
1086     }
1087   else
1088     while (ncopied < size)
1089       {
1090         tocopy = size - ncopied;
1091         if (tocopy > BUFSIZE)
1092           tocopy = BUFSIZE;
1093
1094         nread = bfd_bread (cbuf, tocopy, abfd);
1095         if (nread != tocopy)
1096           /* xgettext:c-format */
1097           fatal (_("%s is not a valid archive"),
1098                  bfd_get_filename (abfd->my_archive));
1099
1100         /* See comment above; this saves disk arm motion */
1101         if (ostream == NULL)
1102           {
1103             /* Seems like an abstraction violation, eh?  Well it's OK! */
1104             output_filename = bfd_get_filename (abfd);
1105
1106             ostream = fopen (bfd_get_filename (abfd), FOPEN_WB);
1107             if (ostream == NULL)
1108               {
1109                 perror (bfd_get_filename (abfd));
1110                 xexit (1);
1111               }
1112
1113             output_file = ostream;
1114           }
1115
1116         /* fwrite in mingw32 may return int instead of bfd_size_type. Cast
1117            the return value to bfd_size_type to avoid comparison between
1118            signed and unsigned values.  */
1119         if ((bfd_size_type) fwrite (cbuf, 1, nread, ostream) != nread)
1120           fatal ("%s: %s", output_filename, strerror (errno));
1121         ncopied += tocopy;
1122       }
1123
1124   if (ostream != NULL)
1125     fclose (ostream);
1126
1127   output_file = NULL;
1128   output_filename = NULL;
1129
1130   chmod (bfd_get_filename (abfd), buf.st_mode);
1131
1132   if (preserve_dates)
1133     {
1134       /* Set access time to modification time.  Only st_mtime is
1135          initialized by bfd_stat_arch_elt.  */
1136       buf.st_atime = buf.st_mtime;
1137       set_times (bfd_get_filename (abfd), &buf);
1138     }
1139
1140   free (cbuf);
1141 }
1142
1143 static void
1144 write_archive (bfd *iarch)
1145 {
1146   bfd *obfd;
1147   char *old_name, *new_name;
1148   bfd *contents_head = iarch->archive_next;
1149
1150   old_name = (char *) xmalloc (strlen (bfd_get_filename (iarch)) + 1);
1151   strcpy (old_name, bfd_get_filename (iarch));
1152   new_name = make_tempname (old_name);
1153
1154   if (new_name == NULL)
1155     bfd_fatal (_("could not create temporary file whilst writing archive"));
1156
1157   output_filename = new_name;
1158
1159   obfd = bfd_openw (new_name, bfd_get_target (iarch));
1160
1161   if (obfd == NULL)
1162     bfd_fatal (old_name);
1163
1164   output_bfd = obfd;
1165
1166   bfd_set_format (obfd, bfd_archive);
1167
1168   /* Request writing the archive symbol table unless we've
1169      been explicitly requested not to.  */
1170   obfd->has_armap = write_armap >= 0;
1171
1172   if (ar_truncate)
1173     {
1174       /* This should really use bfd_set_file_flags, but that rejects
1175          archives.  */
1176       obfd->flags |= BFD_TRADITIONAL_FORMAT;
1177     }
1178
1179   if (deterministic)
1180     obfd->flags |= BFD_DETERMINISTIC_OUTPUT;
1181
1182   if (make_thin_archive || bfd_is_thin_archive (iarch))
1183     bfd_is_thin_archive (obfd) = 1;
1184
1185   if (!bfd_set_archive_head (obfd, contents_head))
1186     bfd_fatal (old_name);
1187
1188   if (!bfd_close (obfd))
1189     bfd_fatal (old_name);
1190
1191   output_bfd = NULL;
1192   output_filename = NULL;
1193
1194   /* We don't care if this fails; we might be creating the archive.  */
1195   bfd_close (iarch);
1196
1197   if (smart_rename (new_name, old_name, 0) != 0)
1198     xexit (1);
1199   free (old_name);
1200   free (new_name);
1201 }
1202
1203 /* Return a pointer to the pointer to the entry which should be rplacd'd
1204    into when altering.  DEFAULT_POS should be how to interpret pos_default,
1205    and should be a pos value.  */
1206
1207 static bfd **
1208 get_pos_bfd (bfd **contents, enum pos default_pos, const char *default_posname)
1209 {
1210   bfd **after_bfd = contents;
1211   enum pos realpos;
1212   const char *realposname;
1213
1214   if (postype == pos_default)
1215     {
1216       realpos = default_pos;
1217       realposname = default_posname;
1218     }
1219   else
1220     {
1221       realpos = postype;
1222       realposname = posname;
1223     }
1224
1225   if (realpos == pos_end)
1226     {
1227       while (*after_bfd)
1228         after_bfd = &((*after_bfd)->archive_next);
1229     }
1230   else
1231     {
1232       for (; *after_bfd; after_bfd = &(*after_bfd)->archive_next)
1233         if (FILENAME_CMP ((*after_bfd)->filename, realposname) == 0)
1234           {
1235             if (realpos == pos_after)
1236               after_bfd = &(*after_bfd)->archive_next;
1237             break;
1238           }
1239     }
1240   return after_bfd;
1241 }
1242
1243 static void
1244 delete_members (bfd *arch, char **files_to_delete)
1245 {
1246   bfd **current_ptr_ptr;
1247   bfd_boolean found;
1248   bfd_boolean something_changed = FALSE;
1249   int match_count;
1250
1251   for (; *files_to_delete != NULL; ++files_to_delete)
1252     {
1253       /* In a.out systems, the armap is optional.  It's also called
1254          __.SYMDEF.  So if the user asked to delete it, we should remember
1255          that fact. This isn't quite right for COFF systems (where
1256          __.SYMDEF might be regular member), but it's very unlikely
1257          to be a problem.  FIXME */
1258
1259       if (!strcmp (*files_to_delete, "__.SYMDEF"))
1260         {
1261           arch->has_armap = FALSE;
1262           write_armap = -1;
1263           continue;
1264         }
1265
1266       found = FALSE;
1267       match_count = 0;
1268       current_ptr_ptr = &(arch->archive_next);
1269       while (*current_ptr_ptr)
1270         {
1271           if (FILENAME_CMP (normalize (*files_to_delete, arch),
1272                             (*current_ptr_ptr)->filename) == 0)
1273             {
1274               ++match_count;
1275               if (counted_name_mode
1276                   && match_count != counted_name_counter)
1277                 {
1278                   /* Counting, and didn't match on count; go on to the
1279                      next one.  */
1280                 }
1281               else
1282                 {
1283                   found = TRUE;
1284                   something_changed = TRUE;
1285                   if (verbose)
1286                     printf ("d - %s\n",
1287                             *files_to_delete);
1288                   *current_ptr_ptr = ((*current_ptr_ptr)->archive_next);
1289                   goto next_file;
1290                 }
1291             }
1292
1293           current_ptr_ptr = &((*current_ptr_ptr)->archive_next);
1294         }
1295
1296       if (verbose && !found)
1297         {
1298           /* xgettext:c-format */
1299           printf (_("No member named `%s'\n"), *files_to_delete);
1300         }
1301     next_file:
1302       ;
1303     }
1304
1305   if (something_changed)
1306     write_archive (arch);
1307   else
1308     output_filename = NULL;
1309 }
1310
1311
1312 /* Reposition existing members within an archive */
1313
1314 static void
1315 move_members (bfd *arch, char **files_to_move)
1316 {
1317   bfd **after_bfd;              /* New entries go after this one */
1318   bfd **current_ptr_ptr;        /* cdr pointer into contents */
1319
1320   for (; *files_to_move; ++files_to_move)
1321     {
1322       current_ptr_ptr = &(arch->archive_next);
1323       while (*current_ptr_ptr)
1324         {
1325           bfd *current_ptr = *current_ptr_ptr;
1326           if (FILENAME_CMP (normalize (*files_to_move, arch),
1327                             current_ptr->filename) == 0)
1328             {
1329               /* Move this file to the end of the list - first cut from
1330                  where it is.  */
1331               bfd *link_bfd;
1332               *current_ptr_ptr = current_ptr->archive_next;
1333
1334               /* Now glue to end */
1335               after_bfd = get_pos_bfd (&arch->archive_next, pos_end, NULL);
1336               link_bfd = *after_bfd;
1337               *after_bfd = current_ptr;
1338               current_ptr->archive_next = link_bfd;
1339
1340               if (verbose)
1341                 printf ("m - %s\n", *files_to_move);
1342
1343               goto next_file;
1344             }
1345
1346           current_ptr_ptr = &((*current_ptr_ptr)->archive_next);
1347         }
1348       /* xgettext:c-format */
1349       fatal (_("no entry %s in archive %s!"), *files_to_move, arch->filename);
1350
1351     next_file:;
1352     }
1353
1354   write_archive (arch);
1355 }
1356
1357 /* Ought to default to replacing in place, but this is existing practice!  */
1358
1359 static void
1360 replace_members (bfd *arch, char **files_to_move, bfd_boolean quick)
1361 {
1362   bfd_boolean changed = FALSE;
1363   bfd **after_bfd;              /* New entries go after this one.  */
1364   bfd *current;
1365   bfd **current_ptr;
1366
1367   while (files_to_move && *files_to_move)
1368     {
1369       if (! quick)
1370         {
1371           current_ptr = &arch->archive_next;
1372           while (*current_ptr)
1373             {
1374               current = *current_ptr;
1375
1376               /* For compatibility with existing ar programs, we
1377                  permit the same file to be added multiple times.  */
1378               if (FILENAME_CMP (normalize (*files_to_move, arch),
1379                                 normalize (current->filename, arch)) == 0
1380                   && current->arelt_data != NULL)
1381                 {
1382                   if (newer_only)
1383                     {
1384                       struct stat fsbuf, asbuf;
1385
1386                       if (stat (*files_to_move, &fsbuf) != 0)
1387                         {
1388                           if (errno != ENOENT)
1389                             bfd_fatal (*files_to_move);
1390                           goto next_file;
1391                         }
1392                       if (bfd_stat_arch_elt (current, &asbuf) != 0)
1393                         /* xgettext:c-format */
1394                         fatal (_("internal stat error on %s"),
1395                                current->filename);
1396
1397                       if (fsbuf.st_mtime <= asbuf.st_mtime)
1398                         goto next_file;
1399                     }
1400
1401                   after_bfd = get_pos_bfd (&arch->archive_next, pos_after,
1402                                            current->filename);
1403                   if (ar_emul_replace (after_bfd, *files_to_move,
1404                                        target, verbose))
1405                     {
1406                       /* Snip out this entry from the chain.  */
1407                       *current_ptr = (*current_ptr)->archive_next;
1408                       changed = TRUE;
1409                     }
1410
1411                   goto next_file;
1412                 }
1413               current_ptr = &(current->archive_next);
1414             }
1415         }
1416
1417       /* Add to the end of the archive.  */
1418       after_bfd = get_pos_bfd (&arch->archive_next, pos_end, NULL);
1419
1420       if (ar_emul_append (after_bfd, *files_to_move, target,
1421                           verbose, make_thin_archive))
1422         changed = TRUE;
1423
1424     next_file:;
1425
1426       files_to_move++;
1427     }
1428
1429   if (changed)
1430     write_archive (arch);
1431   else
1432     output_filename = NULL;
1433 }
1434
1435 static int
1436 ranlib_only (const char *archname)
1437 {
1438   bfd *arch;
1439
1440   if (get_file_size (archname) < 1)
1441     return 1;
1442   write_armap = 1;
1443   arch = open_inarch (archname, (char *) NULL);
1444   if (arch == NULL)
1445     xexit (1);
1446   write_archive (arch);
1447   return 0;
1448 }
1449
1450 /* Update the timestamp of the symbol map of an archive.  */
1451
1452 static int
1453 ranlib_touch (const char *archname)
1454 {
1455 #ifdef __GO32__
1456   /* I don't think updating works on go32.  */
1457   ranlib_only (archname);
1458 #else
1459   int f;
1460   bfd *arch;
1461   char **matching;
1462
1463   if (get_file_size (archname) < 1)
1464     return 1;
1465   f = open (archname, O_RDWR | O_BINARY, 0);
1466   if (f < 0)
1467     {
1468       bfd_set_error (bfd_error_system_call);
1469       bfd_fatal (archname);
1470     }
1471
1472   arch = bfd_fdopenr (archname, (const char *) NULL, f);
1473   if (arch == NULL)
1474     bfd_fatal (archname);
1475   if (! bfd_check_format_matches (arch, bfd_archive, &matching))
1476     {
1477       bfd_nonfatal (archname);
1478       if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1479         {
1480           list_matching_formats (matching);
1481           free (matching);
1482         }
1483       xexit (1);
1484     }
1485
1486   if (! bfd_has_map (arch))
1487     /* xgettext:c-format */
1488     fatal (_("%s: no archive map to update"), archname);
1489
1490   if (deterministic)
1491     arch->flags |= BFD_DETERMINISTIC_OUTPUT;
1492
1493   bfd_update_armap_timestamp (arch);
1494
1495   if (! bfd_close (arch))
1496     bfd_fatal (archname);
1497 #endif
1498   return 0;
1499 }
1500
1501 /* Things which are interesting to map over all or some of the files: */
1502
1503 static void
1504 print_descr (bfd *abfd)
1505 {
1506   print_arelt_descr (stdout, abfd, verbose);
1507 }