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