binutils/ar.c

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