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