binutils/ar.c

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