contrib/binutils-2.22/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
   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 = 0;
 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   fprintf (s, _("  [D]          - use zero for timestamps and uids/gids\n"));
 280   fprintf (s, _("  [N]          - use instance [count] of name\n"));
 281   fprintf (s, _("  [f]          - truncate inserted file names\n"));
 282   fprintf (s, _("  [P]          - use full path names when matching\n"));
 283   fprintf (s, _("  [o]          - preserve original dates\n"));
 284   fprintf (s, _("  [u]          - only replace files that are newer than current archive contents\n"));
 285   fprintf (s, _(" generic modifiers:\n"));
 286   fprintf (s, _("  [c]          - do not warn if the library had to be created\n"));
 287   fprintf (s, _("  [s]          - create an archive index (cf. ranlib)\n"));
 288   fprintf (s, _("  [S]          - do not build a symbol table\n"));
 289   fprintf (s, _("  [T]          - make a thin archive\n"));
 290   fprintf (s, _("  [v]          - be verbose\n"));
 291   fprintf (s, _("  [V]          - display the version number\n"));
 292   fprintf (s, _("  @<file>      - read options from <file>\n"));
 293   fprintf (s, _("  --target=BFDNAME - specify the target object format as BFDNAME\n"));
 294 #if BFD_SUPPORTS_PLUGINS
 295   fprintf (s, _(" optional:\n"));
 296   fprintf (s, _("  --plugin <p> - load the specified plugin\n"));
 297 #endif
 298
 299   ar_emul_usage (s);
 300
 301   list_supported_targets (program_name, s);
 302
 303   if (REPORT_BUGS_TO[0] && help)
 304     fprintf (s, _("Report bugs to %s\n"), REPORT_BUGS_TO);
 305
 306   xexit (help ? 0 : 1);
 307 }
 308
 309 static void
 310 ranlib_usage (int help)
 311 {
 312   FILE *s;
 313
 314   s = help ? stdout : stderr;
 315
 316   /* xgettext:c-format */
 317   fprintf (s, _("Usage: %s [options] archive\n"), program_name);
 318   fprintf (s, _(" Generate an index to speed access to archives\n"));
 319   fprintf (s, _(" The options are:\n\
 320   @<file>                      Read options from <file>\n"));
 321 #if BFD_SUPPORTS_PLUGINS
 322   fprintf (s, _("\
 323   --plugin <name>              Load the specified plugin\n"));
 324 #endif
 325   fprintf (s, _("\
 326   -t                           Update the archive's symbol map timestamp\n\
 327   -h --help                    Print this help message\n\
 328   -v --version                 Print version information\n"));
 329
 330   list_supported_targets (program_name, s);
 331
 332   if (REPORT_BUGS_TO[0] && help)
 333     fprintf (s, _("Report bugs to %s\n"), REPORT_BUGS_TO);
 334
 335   xexit (help ? 0 : 1);
 336 }
 337
 338 /* Normalize a file name specified on the command line into a file
 339    name which we will use in an archive.  */
 340
 341 static const char *
 342 normalize (const char *file, bfd *abfd)
 343 {
 344   const char *filename;
 345
 346   if (full_pathname)
 347     return file;
 348
 349   filename = lbasename (file);
 350
 351   if (ar_truncate
 352       && abfd != NULL
 353       && strlen (filename) > abfd->xvec->ar_max_namelen)
 354     {
 355       char *s;
 356
 357       /* Space leak.  */
 358       s = (char *) xmalloc (abfd->xvec->ar_max_namelen + 1);
 359       memcpy (s, filename, abfd->xvec->ar_max_namelen);
 360       s[abfd->xvec->ar_max_namelen] = '\0';
 361       filename = s;
 362     }
 363
 364   return filename;
 365 }
 366
 367 /* Remove any output file.  This is only called via xatexit.  */
 368
 369 static const char *output_filename = NULL;
 370 static FILE *output_file = NULL;
 371 static bfd *output_bfd = NULL;
 372
 373 static void
 374 remove_output (void)
 375 {
 376   if (output_filename != NULL)
 377     {
 378       if (output_bfd != NULL)
 379         bfd_cache_close (output_bfd);
 380       if (output_file != NULL)
 381         fclose (output_file);
 382       unlink_if_ordinary (output_filename);
 383     }
 384 }
 385
 386 static char **
 387 decode_options (int argc, char **argv)
 388 {
 389   int c;
 390
 391   /* Convert old-style tar call by exploding option element and rearranging
 392      options accordingly.  */
 393
 394   if (argc > 1 && argv[1][0] != '-')
 395     {
 396       int new_argc;             /* argc value for rearranged arguments */
 397       char **new_argv;          /* argv value for rearranged arguments */
 398       char *const *in;          /* cursor into original argv */
 399       char **out;               /* cursor into rearranged argv */
 400       const char *letter;       /* cursor into old option letters */
 401       char buffer[3];           /* constructed option buffer */
 402
 403       /* Initialize a constructed option.  */
 404
 405       buffer[0] = '-';
 406       buffer[2] = '\0';
 407
 408       /* Allocate a new argument array, and copy program name in it.  */
 409
 410       new_argc = argc - 1 + strlen (argv[1]);
 411       new_argv = xmalloc ((new_argc + 1) * sizeof (*argv));
 412       in = argv;
 413       out = new_argv;
 414       *out++ = *in++;
 415
 416       /* Copy each old letter option as a separate option.  */
 417
 418       for (letter = *in++; *letter; letter++)
 419         {
 420           buffer[1] = *letter;
 421           *out++ = xstrdup (buffer);
 422         }
 423
 424       /* Copy all remaining options.  */
 425
 426       while (in < argv + argc)
 427         *out++ = *in++;
 428       *out = NULL;
 429
 430       /* Replace the old option list by the new one.  */
 431
 432       argc = new_argc;
 433       argv = new_argv;
 434     }
 435
 436   while ((c = getopt_long (argc, argv, "hdmpqrtxlcoVsSuvabiMNfPTD",
 437                            long_options, NULL)) != EOF)
 438     {
 439       switch (c)
 440         {
 441         case 'd':
 442         case 'm':
 443         case 'p':
 444         case 'q':
 445         case 'r':
 446         case 't':
 447         case 'x':
 448           if (operation != none)
 449             fatal (_("two different operation options specified"));
 450           break;
 451         }
 452
 453       switch (c)
 454         {
 455         case 'h':
 456           show_help = 1;
 457           break;
 458         case 'd':
 459           operation = del;
 460           operation_alters_arch = TRUE;
 461           break;
 462         case 'm':
 463           operation = move;
 464           operation_alters_arch = TRUE;
 465           break;
 466         case 'p':
 467           operation = print_files;
 468           break;
 469         case 'q':
 470           operation = quick_append;
 471           operation_alters_arch = TRUE;
 472           break;
 473         case 'r':
 474           operation = replace;
 475           operation_alters_arch = TRUE;
 476           break;
 477         case 't':
 478           operation = print_table;
 479           break;
 480         case 'x':
 481           operation = extract;
 482           break;
 483         case 'l':
 484           break;
 485         case 'c':
 486           silent_create = 1;
 487           break;
 488         case 'o':
 489           preserve_dates = 1;
 490           break;
 491         case 'V':
 492           show_version = TRUE;
 493           break;
 494         case 's':
 495           write_armap = 1;
 496           break;
 497         case 'S':
 498           write_armap = -1;
 499           break;
 500         case 'u':
 501           newer_only = 1;
 502           break;
 503         case 'v':
 504           verbose = 1;
 505           break;
 506         case 'a':
 507           postype = pos_after;
 508           break;
 509         case 'b':
 510           postype = pos_before;
 511           break;
 512         case 'i':
 513           postype = pos_before;
 514           break;
 515         case 'M':
 516           mri_mode = 1;
 517           break;
 518         case 'N':
 519           counted_name_mode = TRUE;
 520           break;
 521         case 'f':
 522           ar_truncate = TRUE;
 523           break;
 524         case 'P':
 525           full_pathname = TRUE;
 526           break;
 527         case 'T':
 528           make_thin_archive = TRUE;
 529           break;
 530         case 'D':
 531           deterministic = TRUE;
 532           break;
 533         case OPTION_PLUGIN:
 534 #if BFD_SUPPORTS_PLUGINS
 535           plugin_target = "plugin";
 536           bfd_plugin_set_plugin (optarg);
 537 #else
 538           fprintf (stderr, _("sorry - this program has been built without plugin support\n"));
 539           xexit (1);
 540 #endif
 541           break;
 542         case OPTION_TARGET:
 543           target = optarg;
 544           break;
 545         case 0:         /* A long option that just sets a flag.  */
 546           break;
 547         default:
 548           usage (0);
 549         }
 550     }
 551
 552   return &argv[optind];
 553 }
 554
 555 static void
 556 ranlib_main (int argc, char **argv)
 557 {
 558   int arg_index, status = 0;
 559   bfd_boolean touch = FALSE;
 560   int c;
 561
 562   while ((c = getopt_long (argc, argv, "hHvVt", long_options, NULL)) != EOF)
 563     {
 564       switch (c)
 565         {
 566         case 'h':
 567         case 'H':
 568           show_help = 1;
 569           break;
 570         case 't':
 571           touch = TRUE;
 572           break;
 573         case 'v':
 574         case 'V':
 575           show_version = 1;
 576           break;
 577         }
 578     }
 579
 580   if (argc < 2)
 581     ranlib_usage (0);
 582
 583   if (show_help)
 584     usage (1);
 585
 586   if (show_version)
 587     print_version ("ranlib");
 588
 589   arg_index = optind;
 590
 591   while (arg_index < argc)
 592     {
 593       if (! touch)
 594         status |= ranlib_only (argv[arg_index]);
 595       else
 596         status |= ranlib_touch (argv[arg_index]);
 597       ++arg_index;
 598     }
 599
 600   xexit (status);
 601 }
 602
 603 int main (int, char **);
 604
 605 int
 606 main (int argc, char **argv)
 607 {
 608   int arg_index;
 609   char **files;
 610   int file_count;
 611   char *inarch_filename;
 612   int i;
 613
 614 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
 615   setlocale (LC_MESSAGES, "");
 616 #endif
 617 #if defined (HAVE_SETLOCALE)
 618   setlocale (LC_CTYPE, "");
 619 #endif
 620   bindtextdomain (PACKAGE, LOCALEDIR);
 621   textdomain (PACKAGE);
 622
 623   program_name = argv[0];
 624   xmalloc_set_program_name (program_name);
 625 #if BFD_SUPPORTS_PLUGINS
 626   bfd_plugin_set_program_name (program_name);
 627 #endif
 628
 629   expandargv (&argc, &argv);
 630
 631   if (is_ranlib < 0)
 632     {
 633       const char *temp = lbasename (program_name);
 634
 635       if (strlen (temp) >= 6
 636           && FILENAME_CMP (temp + strlen (temp) - 6, "ranlib") == 0)
 637         is_ranlib = 1;
 638       else
 639         is_ranlib = 0;
 640     }
 641
 642   START_PROGRESS (program_name, 0);
 643
 644   bfd_init ();
 645   set_default_bfd_target ();
 646
 647   xatexit (remove_output);
 648
 649   for (i = 1; i < argc; i++)
 650     if (! ar_emul_parse_arg (argv[i]))
 651       break;
 652   argv += (i - 1);
 653   argc -= (i - 1);
 654
 655   if (is_ranlib)
 656     ranlib_main (argc, argv);
 657
 658   if (argc < 2)
 659     usage (0);
 660
 661   argv = decode_options (argc, argv);
 662
 663   if (show_help)
 664     usage (1);
 665
 666   if (show_version)
 667     print_version ("ar");
 668
 669   arg_index = 0;
 670
 671   if (mri_mode)
 672     {
 673       mri_emul ();
 674     }
 675   else
 676     {
 677       bfd *arch;
 678
 679       /* We don't use do_quick_append any more.  Too many systems
 680          expect ar to always rebuild the symbol table even when q is
 681          used.  */
 682
 683       /* We can't write an armap when using ar q, so just do ar r
 684          instead.  */
 685       if (operation == quick_append && write_armap)
 686         operation = replace;
 687
 688       if ((operation == none || operation == print_table)
 689           && write_armap == 1)
 690         xexit (ranlib_only (argv[arg_index]));
 691
 692       if (operation == none)
 693         fatal (_("no operation specified"));
 694
 695       if (newer_only && operation != replace)
 696         fatal (_("`u' is only meaningful with the `r' option."));
 697
 698       if (newer_only && deterministic)
 699         fatal (_("`u' is not meaningful with the `D' option."));
 700
 701       if (postype != pos_default)
 702         posname = argv[arg_index++];
 703
 704       if (counted_name_mode)
 705         {
 706           if (operation != extract && operation != del)
 707             fatal (_("`N' is only meaningful with the `x' and `d' options."));
 708           counted_name_counter = atoi (argv[arg_index++]);
 709           if (counted_name_counter <= 0)
 710             fatal (_("Value for `N' must be positive."));
 711         }
 712
 713       inarch_filename = argv[arg_index++];
 714
 715       for (file_count = 0; argv[arg_index + file_count] != NULL; file_count++)
 716         continue;
 717
 718       files = (file_count > 0) ? argv + arg_index : NULL;
 719
 720       arch = open_inarch (inarch_filename,
 721                           files == NULL ? (char *) NULL : files[0]);
 722
 723       if (operation == extract && bfd_is_thin_archive (arch))
 724         fatal (_("`x' cannot be used on thin archives."));
 725
 726       switch (operation)
 727         {
 728         case print_table:
 729           map_over_members (arch, print_descr, files, file_count);
 730           break;
 731
 732         case print_files:
 733           map_over_members (arch, print_contents, files, file_count);
 734           break;
 735
 736         case extract:
 737           map_over_members (arch, extract_file, files, file_count);
 738           break;
 739
 740         case del:
 741           if (files != NULL)
 742             delete_members (arch, files);
 743           else
 744             output_filename = NULL;
 745           break;
 746
 747         case move:
 748           /* PR 12558: Creating and moving at the same time does
 749              not make sense.  Just create the archive instead.  */
 750           if (! silent_create)
 751             {
 752               if (files != NULL)
 753                 move_members (arch, files);
 754               else
 755                 output_filename = NULL;
 756               break;
 757             }
 758           /* Fall through.  */
 759
 760         case replace:
 761         case quick_append:
 762           if (files != NULL || write_armap > 0)
 763             replace_members (arch, files, operation == quick_append);
 764           else
 765             output_filename = NULL;
 766           break;
 767
 768           /* Shouldn't happen! */
 769         default:
 770           /* xgettext:c-format */
 771           fatal (_("internal error -- this option not implemented"));
 772         }
 773     }
 774
 775   END_PROGRESS (program_name);
 776
 777   xexit (0);
 778   return 0;
 779 }
 780
 781 bfd *
 782 open_inarch (const char *archive_filename, const char *file)
 783 {
 784   bfd **last_one;
 785   bfd *next_one;
 786   struct stat sbuf;
 787   bfd *arch;
 788   char **matching;
 789
 790   bfd_set_error (bfd_error_no_error);
 791
 792   if (target == NULL)
 793     target = plugin_target;
 794
 795   if (stat (archive_filename, &sbuf) != 0)
 796     {
 797 #if !defined(__GO32__) || defined(__DJGPP__)
 798
 799       /* FIXME: I don't understand why this fragment was ifndef'ed
 800          away for __GO32__; perhaps it was in the days of DJGPP v1.x.
 801          stat() works just fine in v2.x, so I think this should be
 802          removed.  For now, I enable it for DJGPP v2. -- EZ.  */
 803
 804       /* KLUDGE ALERT! Temporary fix until I figger why
 805          stat() is wrong ... think it's buried in GO32's IDT - Jax */
 806       if (errno != ENOENT)
 807         bfd_fatal (archive_filename);
 808 #endif
 809
 810       if (!operation_alters_arch)
 811         {
 812           fprintf (stderr, "%s: ", program_name);
 813           perror (archive_filename);
 814           maybequit ();
 815           return NULL;
 816         }
 817
 818       /* If the target isn't set, try to figure out the target to use
 819          for the archive from the first object on the list.  */
 820       if (target == NULL && file != NULL)
 821         {
 822           bfd *obj;
 823
 824           obj = bfd_openr (file, target);
 825           if (obj != NULL)
 826             {
 827               if (bfd_check_format (obj, bfd_object))
 828                 target = bfd_get_target (obj);
 829               (void) bfd_close (obj);
 830             }
 831         }
 832
 833       /* Create an empty archive.  */
 834       arch = bfd_openw (archive_filename, target);
 835       if (arch == NULL
 836           || ! bfd_set_format (arch, bfd_archive)
 837           || ! bfd_close (arch))
 838         bfd_fatal (archive_filename);
 839       else if (!silent_create)
 840         non_fatal (_("creating %s"), archive_filename);
 841
 842       /* If we die creating a new archive, don't leave it around.  */
 843       output_filename = archive_filename;
 844     }
 845
 846   arch = bfd_openr (archive_filename, target);
 847   if (arch == NULL)
 848     {
 849     bloser:
 850       bfd_fatal (archive_filename);
 851     }
 852
 853   if (! bfd_check_format_matches (arch, bfd_archive, &matching))
 854     {
 855       bfd_nonfatal (archive_filename);
 856       if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
 857         {
 858           list_matching_formats (matching);
 859           free (matching);
 860         }
 861       xexit (1);
 862     }
 863
 864   last_one = &(arch->archive_next);
 865   /* Read all the contents right away, regardless.  */
 866   for (next_one = bfd_openr_next_archived_file (arch, NULL);
 867        next_one;
 868        next_one = bfd_openr_next_archived_file (arch, next_one))
 869     {
 870       PROGRESS (1);
 871       *last_one = next_one;
 872       last_one = &next_one->archive_next;
 873     }
 874   *last_one = (bfd *) NULL;
 875   if (bfd_get_error () != bfd_error_no_more_archived_files)
 876     goto bloser;
 877   return arch;
 878 }
 879
 880 static void
 881 print_contents (bfd *abfd)
 882 {
 883   size_t ncopied = 0;
 884   char *cbuf = (char *) xmalloc (BUFSIZE);
 885   struct stat buf;
 886   size_t size;
 887   if (bfd_stat_arch_elt (abfd, &buf) != 0)
 888     /* xgettext:c-format */
 889     fatal (_("internal stat error on %s"), bfd_get_filename (abfd));
 890
 891   if (verbose)
 892     printf ("\n<%s>\n\n", bfd_get_filename (abfd));
 893
 894   bfd_seek (abfd, (file_ptr) 0, SEEK_SET);
 895
 896   size = buf.st_size;
 897   while (ncopied < size)
 898     {
 899
 900       size_t nread;
 901       size_t tocopy = size - ncopied;
 902       if (tocopy > BUFSIZE)
 903         tocopy = BUFSIZE;
 904
 905       nread = bfd_bread (cbuf, (bfd_size_type) tocopy, abfd);
 906       if (nread != tocopy)
 907         /* xgettext:c-format */
 908         fatal (_("%s is not a valid archive"),
 909                bfd_get_filename (bfd_my_archive (abfd)));
 910
 911       /* fwrite in mingw32 may return int instead of size_t. Cast the
 912          return value to size_t to avoid comparison between signed and
 913          unsigned values.  */
 914       if ((size_t) fwrite (cbuf, 1, nread, stdout) != nread)
 915         fatal ("stdout: %s", strerror (errno));
 916       ncopied += tocopy;
 917     }
 918   free (cbuf);
 919 }
 920
 921 /* Extract a member of the archive into its own file.
 922
 923    We defer opening the new file until after we have read a BUFSIZ chunk of the
 924    old one, since we know we have just read the archive header for the old
 925    one.  Since most members are shorter than BUFSIZ, this means we will read
 926    the old header, read the old data, write a new inode for the new file, and
 927    write the new data, and be done. This 'optimization' is what comes from
 928    sitting next to a bare disk and hearing it every time it seeks.  -- Gnu
 929    Gilmore  */
 930
 931 void
 932 extract_file (bfd *abfd)
 933 {
 934   FILE *ostream;
 935   char *cbuf = (char *) xmalloc (BUFSIZE);
 936   size_t nread, tocopy;
 937   size_t ncopied = 0;
 938   size_t size;
 939   struct stat buf;
 940
 941   if (bfd_stat_arch_elt (abfd, &buf) != 0)
 942     /* xgettext:c-format */
 943     fatal (_("internal stat error on %s"), bfd_get_filename (abfd));
 944   size = buf.st_size;
 945
 946   if (verbose)
 947     printf ("x - %s\n", bfd_get_filename (abfd));
 948
 949   bfd_seek (abfd, (file_ptr) 0, SEEK_SET);
 950
 951   ostream = NULL;
 952   if (size == 0)
 953     {
 954       /* Seems like an abstraction violation, eh?  Well it's OK! */
 955       output_filename = bfd_get_filename (abfd);
 956
 957       ostream = fopen (bfd_get_filename (abfd), FOPEN_WB);
 958       if (ostream == NULL)
 959         {
 960           perror (bfd_get_filename (abfd));
 961           xexit (1);
 962         }
 963
 964       output_file = ostream;
 965     }
 966   else
 967     while (ncopied < size)
 968       {
 969         tocopy = size - ncopied;
 970         if (tocopy > BUFSIZE)
 971           tocopy = BUFSIZE;
 972
 973         nread = bfd_bread (cbuf, (bfd_size_type) tocopy, abfd);
 974         if (nread != tocopy)
 975           /* xgettext:c-format */
 976           fatal (_("%s is not a valid archive"),
 977                  bfd_get_filename (bfd_my_archive (abfd)));
 978
 979         /* See comment above; this saves disk arm motion */
 980         if (ostream == NULL)
 981           {
 982             /* Seems like an abstraction violation, eh?  Well it's OK! */
 983             output_filename = bfd_get_filename (abfd);
 984
 985             ostream = fopen (bfd_get_filename (abfd), FOPEN_WB);
 986             if (ostream == NULL)
 987               {
 988                 perror (bfd_get_filename (abfd));
 989                 xexit (1);
 990               }
 991
 992             output_file = ostream;
 993           }
 994
 995         /* fwrite in mingw32 may return int instead of size_t. Cast
 996            the return value to size_t to avoid comparison between
 997            signed and unsigned values.  */
 998         if ((size_t) fwrite (cbuf, 1, nread, ostream) != nread)
 999           fatal ("%s: %s", output_filename, strerror (errno));
1000         ncopied += tocopy;
1001       }
1002
1003   if (ostream != NULL)
1004     fclose (ostream);
1005
1006   output_file = NULL;
1007   output_filename = NULL;
1008
1009   chmod (bfd_get_filename (abfd), buf.st_mode);
1010
1011   if (preserve_dates)
1012     {
1013       /* Set access time to modification time.  Only st_mtime is
1014          initialized by bfd_stat_arch_elt.  */
1015       buf.st_atime = buf.st_mtime;
1016       set_times (bfd_get_filename (abfd), &buf);
1017     }
1018
1019   free (cbuf);
1020 }
1021
1022 static void
1023 write_archive (bfd *iarch)
1024 {
1025   bfd *obfd;
1026   char *old_name, *new_name;
1027   bfd *contents_head = iarch->archive_next;
1028
1029   old_name = (char *) xmalloc (strlen (bfd_get_filename (iarch)) + 1);
1030   strcpy (old_name, bfd_get_filename (iarch));
1031   new_name = make_tempname (old_name);
1032
1033   if (new_name == NULL)
1034     bfd_fatal ("could not create temporary file whilst writing archive");
1035
1036   output_filename = new_name;
1037
1038   obfd = bfd_openw (new_name, bfd_get_target (iarch));
1039
1040   if (obfd == NULL)
1041     bfd_fatal (old_name);
1042
1043   output_bfd = obfd;
1044
1045   bfd_set_format (obfd, bfd_archive);
1046
1047   /* Request writing the archive symbol table unless we've
1048      been explicitly requested not to.  */
1049   obfd->has_armap = write_armap >= 0;
1050
1051   if (ar_truncate)
1052     {
1053       /* This should really use bfd_set_file_flags, but that rejects
1054          archives.  */
1055       obfd->flags |= BFD_TRADITIONAL_FORMAT;
1056     }
1057
1058   if (deterministic)
1059     obfd->flags |= BFD_DETERMINISTIC_OUTPUT;
1060
1061   if (make_thin_archive || bfd_is_thin_archive (iarch))
1062     bfd_is_thin_archive (obfd) = 1;
1063
1064   if (!bfd_set_archive_head (obfd, contents_head))
1065     bfd_fatal (old_name);
1066
1067   if (!bfd_close (obfd))
1068     bfd_fatal (old_name);
1069
1070   output_bfd = NULL;
1071   output_filename = NULL;
1072
1073   /* We don't care if this fails; we might be creating the archive.  */
1074   bfd_close (iarch);
1075
1076   if (smart_rename (new_name, old_name, 0) != 0)
1077     xexit (1);
1078   free (old_name);
1079 }
1080
1081 /* Return a pointer to the pointer to the entry which should be rplacd'd
1082    into when altering.  DEFAULT_POS should be how to interpret pos_default,
1083    and should be a pos value.  */
1084
1085 static bfd **
1086 get_pos_bfd (bfd **contents, enum pos default_pos, const char *default_posname)
1087 {
1088   bfd **after_bfd = contents;
1089   enum pos realpos;
1090   const char *realposname;
1091
1092   if (postype == pos_default)
1093     {
1094       realpos = default_pos;
1095       realposname = default_posname;
1096     }
1097   else
1098     {
1099       realpos = postype;
1100       realposname = posname;
1101     }
1102
1103   if (realpos == pos_end)
1104     {
1105       while (*after_bfd)
1106         after_bfd = &((*after_bfd)->archive_next);
1107     }
1108   else
1109     {
1110       for (; *after_bfd; after_bfd = &(*after_bfd)->archive_next)
1111         if (FILENAME_CMP ((*after_bfd)->filename, realposname) == 0)
1112           {
1113             if (realpos == pos_after)
1114               after_bfd = &(*after_bfd)->archive_next;
1115             break;
1116           }
1117     }
1118   return after_bfd;
1119 }
1120
1121 static void
1122 delete_members (bfd *arch, char **files_to_delete)
1123 {
1124   bfd **current_ptr_ptr;
1125   bfd_boolean found;
1126   bfd_boolean something_changed = FALSE;
1127   int match_count;
1128
1129   for (; *files_to_delete != NULL; ++files_to_delete)
1130     {
1131       /* In a.out systems, the armap is optional.  It's also called
1132          __.SYMDEF.  So if the user asked to delete it, we should remember
1133          that fact. This isn't quite right for COFF systems (where
1134          __.SYMDEF might be regular member), but it's very unlikely
1135          to be a problem.  FIXME */
1136
1137       if (!strcmp (*files_to_delete, "__.SYMDEF"))
1138         {
1139           arch->has_armap = FALSE;
1140           write_armap = -1;
1141           continue;
1142         }
1143
1144       found = FALSE;
1145       match_count = 0;
1146       current_ptr_ptr = &(arch->archive_next);
1147       while (*current_ptr_ptr)
1148         {
1149           if (FILENAME_CMP (normalize (*files_to_delete, arch),
1150                             (*current_ptr_ptr)->filename) == 0)
1151             {
1152               ++match_count;
1153               if (counted_name_mode
1154                   && match_count != counted_name_counter)
1155                 {
1156                   /* Counting, and didn't match on count; go on to the
1157                      next one.  */
1158                 }
1159               else
1160                 {
1161                   found = TRUE;
1162                   something_changed = TRUE;
1163                   if (verbose)
1164                     printf ("d - %s\n",
1165                             *files_to_delete);
1166                   *current_ptr_ptr = ((*current_ptr_ptr)->archive_next);
1167                   goto next_file;
1168                 }
1169             }
1170
1171           current_ptr_ptr = &((*current_ptr_ptr)->archive_next);
1172         }
1173
1174       if (verbose && !found)
1175         {
1176           /* xgettext:c-format */
1177           printf (_("No member named `%s'\n"), *files_to_delete);
1178         }
1179     next_file:
1180       ;
1181     }
1182
1183   if (something_changed)
1184     write_archive (arch);
1185   else
1186     output_filename = NULL;
1187 }
1188
1189
1190 /* Reposition existing members within an archive */
1191
1192 static void
1193 move_members (bfd *arch, char **files_to_move)
1194 {
1195   bfd **after_bfd;              /* New entries go after this one */
1196   bfd **current_ptr_ptr;        /* cdr pointer into contents */
1197
1198   for (; *files_to_move; ++files_to_move)
1199     {
1200       current_ptr_ptr = &(arch->archive_next);
1201       while (*current_ptr_ptr)
1202         {
1203           bfd *current_ptr = *current_ptr_ptr;
1204           if (FILENAME_CMP (normalize (*files_to_move, arch),
1205                             current_ptr->filename) == 0)
1206             {
1207               /* Move this file to the end of the list - first cut from
1208                  where it is.  */
1209               bfd *link_bfd;
1210               *current_ptr_ptr = current_ptr->archive_next;
1211
1212               /* Now glue to end */
1213               after_bfd = get_pos_bfd (&arch->archive_next, pos_end, NULL);
1214               link_bfd = *after_bfd;
1215               *after_bfd = current_ptr;
1216               current_ptr->archive_next = link_bfd;
1217
1218               if (verbose)
1219                 printf ("m - %s\n", *files_to_move);
1220
1221               goto next_file;
1222             }
1223
1224           current_ptr_ptr = &((*current_ptr_ptr)->archive_next);
1225         }
1226       /* xgettext:c-format */
1227       fatal (_("no entry %s in archive %s!"), *files_to_move, arch->filename);
1228
1229     next_file:;
1230     }
1231
1232   write_archive (arch);
1233 }
1234
1235 /* Ought to default to replacing in place, but this is existing practice!  */
1236
1237 static void
1238 replace_members (bfd *arch, char **files_to_move, bfd_boolean quick)
1239 {
1240   bfd_boolean changed = FALSE;
1241   bfd **after_bfd;              /* New entries go after this one.  */
1242   bfd *current;
1243   bfd **current_ptr;
1244
1245   while (files_to_move && *files_to_move)
1246     {
1247       if (! quick)
1248         {
1249           current_ptr = &arch->archive_next;
1250           while (*current_ptr)
1251             {
1252               current = *current_ptr;
1253
1254               /* For compatibility with existing ar programs, we
1255                  permit the same file to be added multiple times.  */
1256               if (FILENAME_CMP (normalize (*files_to_move, arch),
1257                                 normalize (current->filename, arch)) == 0
1258                   && current->arelt_data != NULL)
1259                 {
1260                   if (newer_only)
1261                     {
1262                       struct stat fsbuf, asbuf;
1263
1264                       if (stat (*files_to_move, &fsbuf) != 0)
1265                         {
1266                           if (errno != ENOENT)
1267                             bfd_fatal (*files_to_move);
1268                           goto next_file;
1269                         }
1270                       if (bfd_stat_arch_elt (current, &asbuf) != 0)
1271                         /* xgettext:c-format */
1272                         fatal (_("internal stat error on %s"),
1273                                current->filename);
1274
1275                       if (fsbuf.st_mtime <= asbuf.st_mtime)
1276                         goto next_file;
1277                     }
1278
1279                   after_bfd = get_pos_bfd (&arch->archive_next, pos_after,
1280                                            current->filename);
1281                   if (ar_emul_replace (after_bfd, *files_to_move,
1282                                        target, verbose))
1283                     {
1284                       /* Snip out this entry from the chain.  */
1285                       *current_ptr = (*current_ptr)->archive_next;
1286                       changed = TRUE;
1287                     }
1288
1289                   goto next_file;
1290                 }
1291               current_ptr = &(current->archive_next);
1292             }
1293         }
1294
1295       /* Add to the end of the archive.  */
1296       after_bfd = get_pos_bfd (&arch->archive_next, pos_end, NULL);
1297
1298       if (ar_emul_append (after_bfd, *files_to_move, target,
1299                           verbose, make_thin_archive))
1300         changed = TRUE;
1301
1302     next_file:;
1303
1304       files_to_move++;
1305     }
1306
1307   if (changed)
1308     write_archive (arch);
1309   else
1310     output_filename = NULL;
1311 }
1312
1313 static int
1314 ranlib_only (const char *archname)
1315 {
1316   bfd *arch;
1317
1318   if (get_file_size (archname) < 1)
1319     return 1;
1320   write_armap = 1;
1321   arch = open_inarch (archname, (char *) NULL);
1322   if (arch == NULL)
1323     xexit (1);
1324   write_archive (arch);
1325   return 0;
1326 }
1327
1328 /* Update the timestamp of the symbol map of an archive.  */
1329
1330 static int
1331 ranlib_touch (const char *archname)
1332 {
1333 #ifdef __GO32__
1334   /* I don't think updating works on go32.  */
1335   ranlib_only (archname);
1336 #else
1337   int f;
1338   bfd *arch;
1339   char **matching;
1340
1341   if (get_file_size (archname) < 1)
1342     return 1;
1343   f = open (archname, O_RDWR | O_BINARY, 0);
1344   if (f < 0)
1345     {
1346       bfd_set_error (bfd_error_system_call);
1347       bfd_fatal (archname);
1348     }
1349
1350   arch = bfd_fdopenr (archname, (const char *) NULL, f);
1351   if (arch == NULL)
1352     bfd_fatal (archname);
1353   if (! bfd_check_format_matches (arch, bfd_archive, &matching))
1354     {
1355       bfd_nonfatal (archname);
1356       if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1357         {
1358           list_matching_formats (matching);
1359           free (matching);
1360         }
1361       xexit (1);
1362     }
1363
1364   if (! bfd_has_map (arch))
1365     /* xgettext:c-format */
1366     fatal (_("%s: no archive map to update"), archname);
1367
1368   bfd_update_armap_timestamp (arch);
1369
1370   if (! bfd_close (arch))
1371     bfd_fatal (archname);
1372 #endif
1373   return 0;
1374 }
1375
1376 /* Things which are interesting to map over all or some of the files: */
1377
1378 static void
1379 print_descr (bfd *abfd)
1380 {
1381   print_arelt_descr (stdout, abfd, verbose);
1382 }