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