1 /* Create, modify, and extract from archives.
2 Copyright (C) 2005-2012 Red Hat, Inc.
3 This file is part of elfutils.
4 Written by Ulrich Drepper <drepper@redhat.com>, 2005.
5
6 This file 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 elfutils is distributed in the hope that it will be useful, but
12 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, see <http://www.gnu.org/licenses/>. */
18
19 #ifdef HAVE_CONFIG_H
20 # include <config.h>
21 #endif
22
23 #include <argp.h>
24 #include <assert.h>
25 #include <error.h>
26 #include <fcntl.h>
27 #include <gelf.h>
28 #include <libintl.h>
29 #include <limits.h>
30 #include <locale.h>
31 #include <search.h>
32 #include <stdbool.h>
33 #include <stdlib.h>
34 #include <stdio.h>
35 #include <stdio_ext.h>
36 #include <string.h>
37 #include <time.h>
38 #include <unistd.h>
39 #include <sys/mman.h>
40 #include <sys/stat.h>
41 #include <sys/time.h>
42
43 #include <system.h>
44
45 #include "arlib.h"
46
47
48 /* Name and version of program. */
49 static void print_version (FILE *stream, struct argp_state *state);
50 ARGP_PROGRAM_VERSION_HOOK_DEF = print_version;
51
52 /* Prototypes for local functions. */
53 static int do_oper_extract (int oper, const char *arfname, char **argv,
54 int argc, long int instance);
55 static int do_oper_delete (const char *arfname, char **argv, int argc,
56 long int instance);
57 static int do_oper_insert (int oper, const char *arfname, char **argv,
58 int argc, const char *member);
59
60
61 /* Bug report address. */
62 ARGP_PROGRAM_BUG_ADDRESS_DEF = PACKAGE_BUGREPORT;
63
64
65 /* Definitions of arguments for argp functions. */
66 static const struct argp_option options[] =
67 {
68 { NULL, 0, NULL, 0, N_("Commands:"), 1 },
69 { NULL, 'd', NULL, 0, N_("Delete files from archive."), 0 },
70 { NULL, 'm', NULL, 0, N_("Move files in archive."), 0 },
71 { NULL, 'p', NULL, 0, N_("Print files in archive."), 0 },
72 { NULL, 'q', NULL, 0, N_("Quick append files to archive."), 0 },
73 { NULL, 'r', NULL, 0,
74 N_("Replace existing or insert new file into archive."), 0 },
75 { NULL, 't', NULL, 0, N_("Display content of archive."), 0 },
76 { NULL, 'x', NULL, 0, N_("Extract files from archive."), 0 },
77
78 { NULL, 0, NULL, 0, N_("Command Modifiers:"), 2 },
79 { NULL, 'o', NULL, 0, N_("Preserve original dates."), 0 },
80 { NULL, 'N', NULL, 0, N_("Use instance [COUNT] of name."), 0 },
81 { NULL, 'C', NULL, 0,
82 N_("Do not replace existing files with extracted files."), 0 },
83 { NULL, 'T', NULL, 0, N_("Allow filename to be truncated if necessary."),
84 0 },
85 { NULL, 'v', NULL, 0, N_("Provide verbose output."), 0 },
86 { NULL, 's', NULL, 0, N_("Force regeneration of symbol table."), 0 },
87 { NULL, 'a', NULL, 0, N_("Insert file after [MEMBER]."), 0 },
88 { NULL, 'b', NULL, 0, N_("Insert file before [MEMBER]."), 0 },
89 { NULL, 'i', NULL, 0, N_("Same as -b."), 0 },
90 { NULL, 'c', NULL, 0, N_("Suppress message when library has to be created."),
91 0 },
92 { NULL, 'P', NULL, 0, N_("Use full path for file matching."), 0 },
93 { NULL, 'u', NULL, 0, N_("Update only older files in archive."), 0 },
94
95 { NULL, 0, NULL, 0, NULL, 0 }
96 };
97
98 /* Short description of program. */
99 static const char doc[] = N_("Create, modify, and extract from archives.");
100
101 /* Strings for arguments in help texts. */
102 static const char args_doc[] = N_("[MEMBER] [COUNT] ARCHIVE [FILE...]");
103
104 /* Prototype for option handler. */
105 static error_t parse_opt (int key, char *arg, struct argp_state *state);
106
107 /* Data structure to communicate with argp functions. */
108 static struct argp argp =
109 {
110 options, parse_opt, args_doc, doc, arlib_argp_children, NULL, NULL
111 };
112
113
114 /* What operation to perform. */
115 static enum
116 {
117 oper_none,
118 oper_delete,
119 oper_move,
120 oper_print,
121 oper_qappend,
122 oper_replace,
123 oper_list,
124 oper_extract
125 } operation;
126
127 /* Modifiers. */
128 static bool verbose;
129 static bool preserve_dates;
130 static bool instance_specifed;
131 static bool dont_replace_existing;
132 static bool allow_truncate_fname;
133 static bool force_symtab;
134 static bool suppress_create_msg;
135 static bool full_path;
136 static bool update_newer;
137 static enum { ipos_none, ipos_before, ipos_after } ipos;
138
139
140 int
main(int argc,char * argv[])141 main (int argc, char *argv[])
142 {
143 /* We use no threads here which can interfere with handling a stream. */
144 (void) __fsetlocking (stdin, FSETLOCKING_BYCALLER);
145 (void) __fsetlocking (stdout, FSETLOCKING_BYCALLER);
146 (void) __fsetlocking (stderr, FSETLOCKING_BYCALLER);
147
148 /* Set locale. */
149 (void) setlocale (LC_ALL, "");
150
151 /* Make sure the message catalog can be found. */
152 (void) bindtextdomain (PACKAGE_TARNAME, LOCALEDIR);
153
154 /* Initialize the message catalog. */
155 (void) textdomain (PACKAGE_TARNAME);
156
157 /* For historical reasons the options in the first parameter need
158 not be preceded by a dash. Add it now if necessary. */
159 if (argc > 1 && argv[1][0] != '-')
160 {
161 size_t len = strlen (argv[1]) + 1;
162 char *newp = alloca (len + 1);
163 newp[0] = '-';
164 memcpy (&newp[1], argv[1], len);
165 argv[1] = newp;
166 }
167
168 /* Parse and process arguments. */
169 int remaining;
170 (void) argp_parse (&argp, argc, argv, ARGP_IN_ORDER, &remaining, NULL);
171
172 /* Tell the library which version we are expecting. */
173 (void) elf_version (EV_CURRENT);
174
175 /* Handle the [MEMBER] parameter. */
176 const char *member = NULL;
177 if (ipos != ipos_none)
178 {
179 /* Only valid for certain operations. */
180 if (operation != oper_move && operation != oper_replace)
181 error (1, 0, gettext ("\
182 'a', 'b', and 'i' are only allowed with the 'm' and 'r' options"));
183
184 if (remaining == argc)
185 {
186 error (0, 0, gettext ("\
187 MEMBER parameter required for 'a', 'b', and 'i' modifiers"));
188 argp_help (&argp, stderr, ARGP_HELP_USAGE | ARGP_HELP_SEE,
189 program_invocation_short_name);
190 exit (EXIT_FAILURE);
191 }
192
193 member = argv[remaining++];
194 }
195
196 /* Handle the [COUNT] parameter. */
197 long int instance = -1;
198 if (instance_specifed)
199 {
200 /* Only valid for certain operations. */
201 if (operation != oper_extract && operation != oper_delete)
202 error (1, 0, gettext ("\
203 'N' is only meaningful with the 'x' and 'd' options"));
204
205 if (remaining == argc)
206 {
207 error (0, 0, gettext ("COUNT parameter required"));
208 argp_help (&argp, stderr, ARGP_HELP_SEE,
209 program_invocation_short_name);
210 exit (EXIT_FAILURE);
211 }
212
213 char *endp;
214 errno = 0;
215 if (((instance = strtol (argv[remaining], &endp, 10)) == LONG_MAX
216 && errno == ERANGE)
217 || instance <= 0
218 || *endp != '\0')
219 error (1, 0, gettext ("invalid COUNT parameter %s"), argv[remaining]);
220
221 ++remaining;
222 }
223
224 if ((dont_replace_existing || allow_truncate_fname)
225 && unlikely (operation != oper_extract))
226 error (1, 0, gettext ("'%c' is only meaningful with the 'x' option"),
227 dont_replace_existing ? 'C' : 'T');
228
229 /* There must at least be one more parameter specifying the archive. */
230 if (remaining == argc)
231 {
232 error (0, 0, gettext ("archive name required"));
233 argp_help (&argp, stderr, ARGP_HELP_SEE, program_invocation_short_name);
234 exit (EXIT_FAILURE);
235 }
236
237 const char *arfname = argv[remaining++];
238 argv += remaining;
239 argc -= remaining;
240
241 int status;
242 switch (operation)
243 {
244 case oper_none:
245 error (0, 0, gettext ("command option required"));
246 argp_help (&argp, stderr, ARGP_HELP_STD_ERR,
247 program_invocation_short_name);
248 status = 1;
249 break;
250
251 case oper_list:
252 case oper_print:
253 status = do_oper_extract (operation, arfname, argv, argc, -1);
254 break;
255
256 case oper_extract:
257 status = do_oper_extract (operation, arfname, argv, argc, instance);
258 break;
259
260 case oper_delete:
261 status = do_oper_delete (arfname, argv, argc, instance);
262 break;
263
264 case oper_move:
265 case oper_qappend:
266 case oper_replace:
267 status = do_oper_insert (operation, arfname, argv, argc, member);
268 break;
269
270 default:
271 assert (! "should not happen");
272 status = 1;
273 break;
274 }
275
276 return status;
277 }
278
279
280 /* Print the version information. */
281 static void
print_version(FILE * stream,struct argp_state * state)282 print_version (FILE *stream, struct argp_state *state __attribute__ ((unused)))
283 {
284 fprintf (stream, "ar (%s) %s\n", PACKAGE_NAME, PACKAGE_VERSION);
285 fprintf (stream, gettext ("\
286 Copyright (C) %s Red Hat, Inc.\n\
287 This is free software; see the source for copying conditions. There is NO\n\
288 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
289 "), "2012");
290 fprintf (stream, gettext ("Written by %s.\n"), "Ulrich Drepper");
291 }
292
293
294 /* Handle program arguments. */
295 static error_t
parse_opt(int key,char * arg,struct argp_state * state)296 parse_opt (int key, char *arg __attribute__ ((unused)),
297 struct argp_state *state __attribute__ ((unused)))
298 {
299 switch (key)
300 {
301 case 'd':
302 case 'm':
303 case 'p':
304 case 'q':
305 case 'r':
306 case 't':
307 case 'x':
308 if (operation != oper_none)
309 {
310 error (0, 0, gettext ("More than one operation specified"));
311 argp_help (&argp, stderr, ARGP_HELP_SEE,
312 program_invocation_short_name);
313 exit (EXIT_FAILURE);
314 }
315
316 switch (key)
317 {
318 case 'd':
319 operation = oper_delete;
320 break;
321 case 'm':
322 operation = oper_move;
323 break;
324 case 'p':
325 operation = oper_print;
326 break;
327 case 'q':
328 operation = oper_qappend;
329 break;
330 case 'r':
331 operation = oper_replace;
332 break;
333 case 't':
334 operation = oper_list;
335 break;
336 case 'x':
337 operation = oper_extract;
338 break;
339 }
340 break;
341
342 case 'a':
343 ipos = ipos_after;
344 break;
345
346 case 'b':
347 case 'i':
348 ipos = ipos_before;
349 break;
350
351 case 'c':
352 suppress_create_msg = true;
353 break;
354
355 case 'C':
356 dont_replace_existing = true;
357 break;
358
359 case 'N':
360 instance_specifed = true;
361 break;
362
363 case 'o':
364 preserve_dates = true;
365 break;
366
367 case 'P':
368 full_path = true;
369 break;
370
371 case 's':
372 force_symtab = true;
373 break;
374
375 case 'T':
376 allow_truncate_fname = true;
377 break;
378
379 case 'u':
380 update_newer = true;
381 break;
382
383 case 'v':
384 verbose = true;
385 break;
386
387 default:
388 return ARGP_ERR_UNKNOWN;
389 }
390 return 0;
391 }
392
393
394 static int
open_archive(const char * arfname,int flags,int mode,Elf ** elf,struct stat * st,bool miss_allowed)395 open_archive (const char *arfname, int flags, int mode, Elf **elf,
396 struct stat *st, bool miss_allowed)
397 {
398 int fd = open (arfname, flags, mode);
399 if (fd == -1)
400 {
401 if (miss_allowed)
402 return -1;
403
404 error (EXIT_FAILURE, errno, gettext ("cannot open archive '%s'"),
405 arfname);
406 }
407
408 if (elf != NULL)
409 {
410 Elf_Cmd cmd = flags == O_RDONLY ? ELF_C_READ_MMAP : ELF_C_RDWR_MMAP;
411
412 *elf = elf_begin (fd, cmd, NULL);
413 if (*elf == NULL)
414 error (EXIT_FAILURE, 0, gettext ("cannot open archive '%s': %s"),
415 arfname, elf_errmsg (-1));
416
417 if (flags == O_RDONLY && elf_kind (*elf) != ELF_K_AR)
418 error (EXIT_FAILURE, 0, gettext ("%s: not an archive file"), arfname);
419 }
420
421 if (st != NULL && fstat (fd, st) != 0)
422 error (EXIT_FAILURE, errno, gettext ("cannot stat archive '%s'"),
423 arfname);
424
425 return fd;
426 }
427
428
429 static void
not_found(int argc,char * argv[argc],bool found[argc])430 not_found (int argc, char *argv[argc], bool found[argc])
431 {
432 for (int i = 0; i < argc; ++i)
433 if (!found[i])
434 printf (gettext ("no entry %s in archive\n"), argv[i]);
435 }
436
437
438 static int
copy_content(Elf * elf,int newfd,off_t off,size_t n)439 copy_content (Elf *elf, int newfd, off_t off, size_t n)
440 {
441 size_t len;
442 char *rawfile = elf_rawfile (elf, &len);
443
444 assert (off + n <= len);
445
446 /* Tell the kernel we will read all the pages sequentially. */
447 size_t ps = sysconf (_SC_PAGESIZE);
448 if (n > 2 * ps)
449 posix_madvise (rawfile + (off & ~(ps - 1)), n, POSIX_MADV_SEQUENTIAL);
450
451 return write_retry (newfd, rawfile + off, n) != (ssize_t) n;
452 }
453
454
455 static int
do_oper_extract(int oper,const char * arfname,char ** argv,int argc,long int instance)456 do_oper_extract (int oper, const char *arfname, char **argv, int argc,
457 long int instance)
458 {
459 bool found[argc];
460 memset (found, '\0', sizeof (found));
461
462 size_t name_max = 0;
463 inline bool should_truncate_fname (void)
464 {
465 if (errno == ENAMETOOLONG && allow_truncate_fname)
466 {
467 if (name_max == 0)
468 {
469 long int len = pathconf (".", _PC_NAME_MAX);
470 if (len > 0)
471 name_max = len;
472 }
473 return name_max != 0;
474 }
475 return false;
476 }
477
478 off_t index_off = -1;
479 size_t index_size = 0;
480 off_t cur_off = SARMAG;
481
482 int status = 0;
483 Elf *elf;
484 int fd = open_archive (arfname, O_RDONLY, 0, &elf, NULL, false);
485
486 if (hcreate (2 * argc) == 0)
487 error (EXIT_FAILURE, errno, gettext ("cannot create hash table"));
488
489 for (int cnt = 0; cnt < argc; ++cnt)
490 {
491 ENTRY entry = { .key = argv[cnt], .data = &argv[cnt] };
492 if (hsearch (entry, ENTER) == NULL)
493 error (EXIT_FAILURE, errno,
494 gettext ("cannot insert into hash table"));
495 }
496
497 struct stat st;
498 if (force_symtab)
499 {
500 if (fstat (fd, &st) != 0)
501 {
502 error (0, errno, gettext ("cannot stat '%s'"), arfname);
503 close (fd);
504 return 1;
505 }
506 arlib_init ();
507 }
508
509 Elf_Cmd cmd = ELF_C_READ_MMAP;
510 Elf *subelf;
511 while ((subelf = elf_begin (fd, cmd, elf)) != NULL)
512 {
513 Elf_Arhdr *arhdr = elf_getarhdr (subelf);
514
515 if (strcmp (arhdr->ar_name, "/") == 0)
516 {
517 index_off = elf_getaroff (subelf);
518 index_size = arhdr->ar_size;
519 goto next;
520 }
521 if (strcmp (arhdr->ar_name, "//") == 0)
522 goto next;
523
524 if (force_symtab)
525 {
526 arlib_add_symbols (elf, arfname, arhdr->ar_name, cur_off);
527 cur_off += (((arhdr->ar_size + 1) & ~((off_t) 1))
528 + sizeof (struct ar_hdr));
529 }
530
531 bool do_extract = argc <= 0;
532 if (!do_extract)
533 {
534 ENTRY entry;
535 entry.key = arhdr->ar_name;
536 ENTRY *res = hsearch (entry, FIND);
537 if (res != NULL && (instance < 0 || instance-- == 0)
538 && !found[(char **) res->data - argv])
539 found[(char **) res->data - argv] = do_extract = true;
540 }
541
542 if (do_extract)
543 {
544 if (verbose)
545 {
546 if (oper == oper_print)
547 {
548 printf ("\n<%s>\n\n", arhdr->ar_name);
549
550 /* We have to flush now because now we use the descriptor
551 directly. */
552 fflush (stdout);
553 }
554 else if (oper == oper_list)
555 {
556 char datestr[100];
557 strftime (datestr, sizeof (datestr), "%b %e %H:%M %Y",
558 localtime (&arhdr->ar_date));
559
560 printf ("%c%c%c%c%c%c%c%c%c %u/%u %6ju %s %s\n",
561 (arhdr->ar_mode & S_IRUSR) ? 'r' : '-',
562 (arhdr->ar_mode & S_IWUSR) ? 'w' : '-',
563 (arhdr->ar_mode & S_IXUSR)
564 ? ((arhdr->ar_mode & S_ISUID) ? 's' : 'x')
565 : ((arhdr->ar_mode & S_ISUID) ? 'S' : '-'),
566 (arhdr->ar_mode & S_IRGRP) ? 'r' : '-',
567 (arhdr->ar_mode & S_IWGRP) ? 'w' : '-',
568 (arhdr->ar_mode & S_IXGRP)
569 ? ((arhdr->ar_mode & S_ISGID) ? 's' : 'x')
570 : ((arhdr->ar_mode & S_ISGID) ? 'S' : '-'),
571 (arhdr->ar_mode & S_IROTH) ? 'r' : '-',
572 (arhdr->ar_mode & S_IWOTH) ? 'w' : '-',
573 (arhdr->ar_mode & S_IXOTH)
574 ? ((arhdr->ar_mode & S_ISVTX) ? 't' : 'x')
575 : ((arhdr->ar_mode & S_ISVTX) ? 'T' : '-'),
576 arhdr->ar_uid,
577 arhdr->ar_gid,
578 (uintmax_t) arhdr->ar_size,
579 datestr,
580 arhdr->ar_name);
581 }
582 else
583 printf ("x - %s\n", arhdr->ar_name);
584 }
585
586 if (oper == oper_list)
587 {
588 if (!verbose)
589 puts (arhdr->ar_name);
590
591 goto next;
592 }
593
594 size_t nleft;
595 char *data = elf_rawfile (subelf, &nleft);
596 if (data == NULL)
597 {
598 error (0, 0, gettext ("cannot read content of %s: %s"),
599 arhdr->ar_name, elf_errmsg (-1));
600 status = 1;
601 goto next;
602 }
603
604 int xfd;
605 char tempfname[] = "XXXXXX";
606 bool use_mkstemp = true;
607
608 if (oper == oper_print)
609 xfd = STDOUT_FILENO;
610 else
611 {
612 xfd = mkstemp (tempfname);
613 if (unlikely (xfd == -1))
614 {
615 /* We cannot create a temporary file. Try to overwrite
616 the file or create it if it does not exist. */
617 int flags = O_WRONLY | O_CREAT;
618 if (dont_replace_existing)
619 flags |= O_EXCL;
620 else
621 flags |= O_TRUNC;
622 xfd = open (arhdr->ar_name, flags, 0600);
623 if (unlikely (xfd == -1))
624 {
625 int printlen = INT_MAX;
626
627 if (should_truncate_fname ())
628 {
629 /* Try to truncate the name. First find out by how
630 much. */
631 printlen = name_max;
632 char truncfname[name_max + 1];
633 *((char *) mempcpy (truncfname, arhdr->ar_name,
634 name_max)) = '\0';
635
636 xfd = open (truncfname, flags, 0600);
637 }
638
639 if (xfd == -1)
640 {
641 error (0, errno, gettext ("cannot open %.*s"),
642 (int) printlen, arhdr->ar_name);
643 status = 1;
644 goto next;
645 }
646 }
647
648 use_mkstemp = false;
649 }
650 }
651
652 ssize_t n;
653 while ((n = TEMP_FAILURE_RETRY (write (xfd, data, nleft))) != -1)
654 {
655 nleft -= n;
656 if (nleft == 0)
657 break;
658 data += n;
659 }
660
661 if (unlikely (n == -1))
662 {
663 error (0, errno, gettext ("failed to write %s"), arhdr->ar_name);
664 status = 1;
665 unlink (tempfname);
666 close (xfd);
667 goto next;
668 }
669
670 if (oper != oper_print)
671 {
672 /* Fix up the mode. */
673 if (unlikely (fchmod (xfd, arhdr->ar_mode) != 0))
674 {
675 error (0, errno, gettext ("cannot change mode of %s"),
676 arhdr->ar_name);
677 status = 0;
678 }
679
680 if (preserve_dates)
681 {
682 struct timespec tv[2];
683 tv[0].tv_sec = arhdr->ar_date;
684 tv[0].tv_nsec = 0;
685 tv[1].tv_sec = arhdr->ar_date;
686 tv[1].tv_nsec = 0;
687
688 if (unlikely (futimens (xfd, tv) != 0))
689 {
690 error (0, errno,
691 gettext ("cannot change modification time of %s"),
692 arhdr->ar_name);
693 status = 1;
694 }
695 }
696
697 /* If we used a temporary file, move it do the right
698 name now. */
699 if (use_mkstemp)
700 {
701 int r;
702
703 if (dont_replace_existing)
704 {
705 r = link (tempfname, arhdr->ar_name);
706 if (likely (r == 0))
707 unlink (tempfname);
708 }
709 else
710 r = rename (tempfname, arhdr->ar_name);
711
712 if (unlikely (r) != 0)
713 {
714 int printlen = INT_MAX;
715
716 if (should_truncate_fname ())
717 {
718 /* Try to truncate the name. First find out by how
719 much. */
720 printlen = name_max;
721 char truncfname[name_max + 1];
722 *((char *) mempcpy (truncfname, arhdr->ar_name,
723 name_max)) = '\0';
724
725 if (dont_replace_existing)
726 {
727 r = link (tempfname, truncfname);
728 if (likely (r == 0))
729 unlink (tempfname);
730 }
731 else
732 r = rename (tempfname, truncfname);
733 }
734
735 if (r != 0)
736 {
737 error (0, errno, gettext ("\
738 cannot rename temporary file to %.*s"),
739 printlen, arhdr->ar_name);
740 unlink (tempfname);
741 status = 1;
742 }
743 }
744 }
745
746 close (xfd);
747 }
748 }
749
750 next:
751 cmd = elf_next (subelf);
752 if (elf_end (subelf) != 0)
753 error (1, 0, "%s: %s", arfname, elf_errmsg (-1));
754 }
755
756 hdestroy ();
757
758 if (force_symtab)
759 {
760 arlib_finalize ();
761
762 if (symtab.symsnamelen != 0
763 /* We have to rewrite the file also if it initially had an index
764 but now does not need one anymore. */
765 || (symtab.symsnamelen == 0 && index_size != 0))
766 {
767 char tmpfname[strlen (arfname) + 7];
768 strcpy (stpcpy (tmpfname, arfname), "XXXXXX");
769 int newfd = mkstemp (tmpfname);
770 if (unlikely (newfd == -1))
771 {
772 nonew:
773 error (0, errno, gettext ("cannot create new file"));
774 status = 1;
775 }
776 else
777 {
778 /* Create the header. */
779 if (unlikely (write_retry (newfd, ARMAG, SARMAG) != SARMAG))
780 {
781 // XXX Use /prof/self/fd/%d ???
782 nonew_unlink:
783 unlink (tmpfname);
784 if (newfd != -1)
785 close (newfd);
786 goto nonew;
787 }
788
789 /* Create the new file. There are three parts as far we are
790 concerned: 1. original context before the index, 2. the
791 new index, 3. everything after the new index. */
792 off_t rest_off;
793 if (index_off != -1)
794 rest_off = (index_off + sizeof (struct ar_hdr)
795 + ((index_size + 1) & ~1ul));
796 else
797 rest_off = SARMAG;
798
799 if ((symtab.symsnamelen != 0
800 && ((write_retry (newfd, symtab.symsoff,
801 symtab.symsofflen)
802 != (ssize_t) symtab.symsofflen)
803 || (write_retry (newfd, symtab.symsname,
804 symtab.symsnamelen)
805 != (ssize_t) symtab.symsnamelen)))
806 /* Even if the original file had content before the
807 symbol table, we write it in the correct order. */
808 || (index_off != SARMAG
809 && copy_content (elf, newfd, SARMAG, index_off - SARMAG))
810 || copy_content (elf, newfd, rest_off, st.st_size - rest_off)
811 /* Set the mode of the new file to the same values the
812 original file has. */
813 || fchmod (newfd, st.st_mode & ALLPERMS) != 0
814 /* Never complain about fchown failing. */
815 || (({asm ("" :: "r" (fchown (newfd, st.st_uid,
816 st.st_gid))); }),
817 close (newfd) != 0)
818 || (newfd = -1, rename (tmpfname, arfname) != 0))
819 goto nonew_unlink;
820 }
821 }
822 }
823
824 elf_end (elf);
825
826 close (fd);
827
828 not_found (argc, argv, found);
829
830 return status;
831 }
832
833
834 struct armem
835 {
836 off_t off;
837 off_t old_off;
838 size_t size;
839 long int long_name_off;
840 struct armem *next;
841 void *mem;
842 time_t sec;
843 uid_t uid;
844 gid_t gid;
845 mode_t mode;
846 const char *name;
847 Elf *elf;
848 };
849
850
851 static int
write_member(struct armem * memb,off_t * startp,off_t * lenp,Elf * elf,off_t end_off,int newfd)852 write_member (struct armem *memb, off_t *startp, off_t *lenp, Elf *elf,
853 off_t end_off, int newfd)
854 {
855 struct ar_hdr arhdr;
856 char tmpbuf[sizeof (arhdr.ar_name) + 1];
857
858 bool changed_header = memb->long_name_off != -1;
859 if (changed_header)
860 {
861 /* In case of a long file name we assume the archive header
862 changed and we write it here. */
863 memcpy (&arhdr, elf_rawfile (elf, NULL) + *startp, sizeof (arhdr));
864
865 snprintf (tmpbuf, sizeof (tmpbuf), "/%-*ld",
866 (int) sizeof (arhdr.ar_name), memb->long_name_off);
867 changed_header = memcmp (arhdr.ar_name, tmpbuf,
868 sizeof (arhdr.ar_name)) != 0;
869 }
870
871 /* If the files are adjacent in the old file extend the range. */
872 if (*startp != -1 && !changed_header && *startp + *lenp == memb->old_off)
873 {
874 /* Extend the current range. */
875 *lenp += (memb->next != NULL
876 ? memb->next->off : end_off) - memb->off;
877 return 0;
878 }
879
880 /* Write out the old range. */
881 if (*startp != -1 && copy_content (elf, newfd, *startp, *lenp))
882 return -1;
883
884 *startp = memb->old_off;
885 *lenp = (memb->next != NULL ? memb->next->off : end_off) - memb->off;
886
887 if (changed_header)
888 {
889 memcpy (arhdr.ar_name, tmpbuf, sizeof (arhdr.ar_name));
890
891 if (unlikely (write_retry (newfd, &arhdr, sizeof (arhdr))
892 != sizeof (arhdr)))
893 return -1;
894
895 *startp += sizeof (struct ar_hdr);
896 assert ((size_t) *lenp >= sizeof (struct ar_hdr));
897 *lenp -= sizeof (struct ar_hdr);
898 }
899
900 return 0;
901 }
902
903 /* Store the name in the long name table if necessary.
904 Record its offset or -1 if we did not need to use the table. */
905 static void
remember_long_name(struct armem * mem,const char * name,size_t namelen)906 remember_long_name (struct armem *mem, const char *name, size_t namelen)
907 {
908 mem->long_name_off = (namelen > MAX_AR_NAME_LEN
909 ? arlib_add_long_name (name, namelen)
910 : -1l);
911 }
912
913 static int
do_oper_delete(const char * arfname,char ** argv,int argc,long int instance)914 do_oper_delete (const char *arfname, char **argv, int argc,
915 long int instance)
916 {
917 bool *found = alloca (sizeof (bool) * argc);
918 memset (found, '\0', sizeof (bool) * argc);
919
920 /* List of the files we keep. */
921 struct armem *to_copy = NULL;
922
923 int status = 0;
924 Elf *elf;
925 struct stat st;
926 int fd = open_archive (arfname, O_RDONLY, 0, &elf, &st, false);
927
928 if (hcreate (2 * argc) == 0)
929 error (EXIT_FAILURE, errno, gettext ("cannot create hash table"));
930
931 for (int cnt = 0; cnt < argc; ++cnt)
932 {
933 ENTRY entry = { .key = argv[cnt], .data = &argv[cnt] };
934 if (hsearch (entry, ENTER) == NULL)
935 error (EXIT_FAILURE, errno,
936 gettext ("cannot insert into hash table"));
937 }
938
939 arlib_init ();
940
941 off_t cur_off = SARMAG;
942 Elf_Cmd cmd = ELF_C_READ_MMAP;
943 Elf *subelf;
944 while ((subelf = elf_begin (fd, cmd, elf)) != NULL)
945 {
946 Elf_Arhdr *arhdr = elf_getarhdr (subelf);
947
948 /* Ignore the symbol table and the long file name table here. */
949 if (strcmp (arhdr->ar_name, "/") == 0
950 || strcmp (arhdr->ar_name, "//") == 0)
951 goto next;
952
953 bool do_delete = argc <= 0;
954 if (!do_delete)
955 {
956 ENTRY entry;
957 entry.key = arhdr->ar_name;
958 ENTRY *res = hsearch (entry, FIND);
959 if (res != NULL && (instance < 0 || instance-- == 0)
960 && !found[(char **) res->data - argv])
961 found[(char **) res->data - argv] = do_delete = true;
962 }
963
964 if (do_delete)
965 {
966 if (verbose)
967 printf ("d - %s\n", arhdr->ar_name);
968 }
969 else
970 {
971 struct armem *newp = alloca (sizeof (struct armem));
972 newp->old_off = elf_getaroff (subelf);
973 newp->off = cur_off;
974
975 cur_off += (((arhdr->ar_size + 1) & ~((off_t) 1))
976 + sizeof (struct ar_hdr));
977
978 if (to_copy == NULL)
979 to_copy = newp->next = newp;
980 else
981 {
982 newp->next = to_copy->next;
983 to_copy = to_copy->next = newp;
984 }
985
986 /* If we recreate the symbol table read the file's symbol
987 table now. */
988 arlib_add_symbols (subelf, arfname, arhdr->ar_name, newp->off);
989
990 /* Remember long file names. */
991 remember_long_name (newp, arhdr->ar_name, strlen (arhdr->ar_name));
992 }
993
994 next:
995 cmd = elf_next (subelf);
996 if (elf_end (subelf) != 0)
997 error (1, 0, "%s: %s", arfname, elf_errmsg (-1));
998 }
999
1000 arlib_finalize ();
1001
1002 hdestroy ();
1003
1004 /* Create a new, temporary file in the same directory as the
1005 original file. */
1006 char tmpfname[strlen (arfname) + 7];
1007 strcpy (stpcpy (tmpfname, arfname), "XXXXXX");
1008 int newfd = mkstemp (tmpfname);
1009 if (unlikely (newfd == -1))
1010 goto nonew;
1011
1012 /* Create the header. */
1013 if (unlikely (write_retry (newfd, ARMAG, SARMAG) != SARMAG))
1014 {
1015 // XXX Use /prof/self/fd/%d ???
1016 nonew_unlink:
1017 unlink (tmpfname);
1018 if (newfd != -1)
1019 close (newfd);
1020 nonew:
1021 error (0, errno, gettext ("cannot create new file"));
1022 status = 1;
1023 goto errout;
1024 }
1025
1026 /* If the archive is empty that is all we have to do. */
1027 if (likely (to_copy != NULL))
1028 {
1029 /* Write the symbol table or the long file name table or both. */
1030 if (symtab.symsnamelen != 0
1031 && ((write_retry (newfd, symtab.symsoff, symtab.symsofflen)
1032 != (ssize_t) symtab.symsofflen)
1033 || (write_retry (newfd, symtab.symsname, symtab.symsnamelen)
1034 != (ssize_t) symtab.symsnamelen)))
1035 goto nonew_unlink;
1036
1037 if (symtab.longnameslen > sizeof (struct ar_hdr)
1038 && (write_retry (newfd, symtab.longnames, symtab.longnameslen)
1039 != (ssize_t) symtab.longnameslen))
1040 goto nonew_unlink;
1041
1042 /* NULL-terminate the list of files to copy. */
1043 struct armem *last = to_copy;
1044 to_copy = to_copy->next;
1045 last->next = NULL;
1046
1047 off_t start = -1;
1048 off_t len = -1;
1049
1050 do
1051 if (write_member (to_copy, &start, &len, elf, cur_off, newfd) != 0)
1052 goto nonew_unlink;
1053 while ((to_copy = to_copy->next) != NULL);
1054
1055 /* Write the last part. */
1056 if (copy_content (elf, newfd, start, len))
1057 goto nonew_unlink;
1058 }
1059
1060 /* Set the mode of the new file to the same values the original file
1061 has. */
1062 if (fchmod (newfd, st.st_mode & ALLPERMS) != 0
1063 /* Never complain about fchown failing. */
1064 || (({asm ("" :: "r" (fchown (newfd, st.st_uid, st.st_gid))); }),
1065 close (newfd) != 0)
1066 || (newfd = -1, rename (tmpfname, arfname) != 0))
1067 goto nonew_unlink;
1068
1069 errout:
1070 #ifdef DEBUG
1071 elf_end (elf);
1072
1073 arlib_fini ();
1074
1075 close (fd);
1076 #endif
1077
1078 not_found (argc, argv, found);
1079
1080 return status;
1081 }
1082
1083
1084 static void
no0print(bool ofmt,char * buf,int bufsize,long int val)1085 no0print (bool ofmt, char *buf, int bufsize, long int val)
1086 {
1087 char tmpbuf[bufsize + 1];
1088 snprintf (tmpbuf, sizeof (tmpbuf), ofmt ? "%-*lo" : "%-*ld", bufsize, val);
1089 memcpy (buf, tmpbuf, bufsize);
1090 }
1091
1092
1093 static int
do_oper_insert(int oper,const char * arfname,char ** argv,int argc,const char * member)1094 do_oper_insert (int oper, const char *arfname, char **argv, int argc,
1095 const char *member)
1096 {
1097 int status = 0;
1098 Elf *elf;
1099 struct stat st;
1100 int fd = open_archive (arfname, O_RDONLY, 0, &elf, &st, oper != oper_move);
1101
1102 /* List of the files we keep. */
1103 struct armem *all = NULL;
1104 struct armem *after_memberelem = NULL;
1105 struct armem **found = alloca (sizeof (*found) * argc);
1106 memset (found, '\0', sizeof (*found) * argc);
1107
1108 arlib_init ();
1109
1110 /* Initialize early for no_old case. */
1111 off_t cur_off = SARMAG;
1112
1113 if (fd == -1)
1114 {
1115 if (!suppress_create_msg)
1116 fprintf (stderr, "%s: creating %s\n",
1117 program_invocation_short_name, arfname);
1118
1119 goto no_old;
1120 }
1121
1122 /* Store the names of all files from the command line in a hash
1123 table so that we can match it. Note that when no file name is
1124 given we are basically doing nothing except recreating the
1125 index. */
1126 if (oper != oper_qappend)
1127 {
1128 if (hcreate (2 * argc) == 0)
1129 error (EXIT_FAILURE, errno, gettext ("cannot create hash table"));
1130
1131 for (int cnt = 0; cnt < argc; ++cnt)
1132 {
1133 ENTRY entry;
1134 entry.key = full_path ? argv[cnt] : basename (argv[cnt]);
1135 entry.data = &argv[cnt];
1136 if (hsearch (entry, ENTER) == NULL)
1137 error (EXIT_FAILURE, errno,
1138 gettext ("cannot insert into hash table"));
1139 }
1140 }
1141
1142 /* While iterating over the current content of the archive we must
1143 determine a number of things: which archive members to keep,
1144 which are replaced, and where to insert the new members. */
1145 Elf_Cmd cmd = ELF_C_READ_MMAP;
1146 Elf *subelf;
1147 while ((subelf = elf_begin (fd, cmd, elf)) != NULL)
1148 {
1149 Elf_Arhdr *arhdr = elf_getarhdr (subelf);
1150
1151 /* Ignore the symbol table and the long file name table here. */
1152 if (strcmp (arhdr->ar_name, "/") == 0
1153 || strcmp (arhdr->ar_name, "//") == 0)
1154 goto next;
1155
1156 struct armem *newp = alloca (sizeof (struct armem));
1157 newp->old_off = elf_getaroff (subelf);
1158 newp->size = arhdr->ar_size;
1159 newp->sec = arhdr->ar_date;
1160 newp->mem = NULL;
1161
1162 /* Remember long file names. */
1163 remember_long_name (newp, arhdr->ar_name, strlen (arhdr->ar_name));
1164
1165 /* Check whether this is a file we are looking for. */
1166 if (oper != oper_qappend)
1167 {
1168 /* Check whether this is the member used as the insert point. */
1169 if (member != NULL && strcmp (arhdr->ar_name, member) == 0)
1170 {
1171 /* Note that all == NULL means insert at the beginning. */
1172 if (ipos == ipos_before)
1173 after_memberelem = all;
1174 else
1175 after_memberelem = newp;
1176 member = NULL;
1177 }
1178
1179 ENTRY entry;
1180 entry.key = arhdr->ar_name;
1181 ENTRY *res = hsearch (entry, FIND);
1182 if (res != NULL && found[(char **) res->data - argv] == NULL)
1183 {
1184 found[(char **) res->data - argv] = newp;
1185
1186 /* If we insert before or after a certain element move
1187 all files to a special list. */
1188 if (unlikely (ipos != ipos_none || oper == oper_move))
1189 {
1190 if (after_memberelem == newp)
1191 /* Since we remove this element even though we should
1192 insert everything after it, we in fact insert
1193 everything after the previous element. */
1194 after_memberelem = all;
1195
1196 goto next;
1197 }
1198 }
1199 }
1200
1201 if (all == NULL)
1202 all = newp->next = newp;
1203 else
1204 {
1205 newp->next = all->next;
1206 all = all->next = newp;
1207 }
1208
1209 next:
1210 cmd = elf_next (subelf);
1211 if (elf_end (subelf) != 0)
1212 error (EXIT_FAILURE, 0, "%s: %s", arfname, elf_errmsg (-1));
1213 }
1214
1215 if (oper != oper_qappend)
1216 hdestroy ();
1217
1218 no_old:
1219 if (member != NULL)
1220 error (EXIT_FAILURE, 0, gettext ("position member %s not found"),
1221 member);
1222
1223 if (oper == oper_move)
1224 {
1225 /* Make sure all requested elements are found in the archive. */
1226 for (int cnt = 0; cnt < argc; ++cnt)
1227 {
1228 if (found[cnt] == NULL)
1229 {
1230 fprintf (stderr, gettext ("%s: no entry %s in archive!\n"),
1231 program_invocation_short_name, argv[cnt]);
1232 status = 1;
1233 }
1234
1235 if (verbose)
1236 printf ("m - %s\n", argv[cnt]);
1237 }
1238 }
1239 else
1240 {
1241 /* Open all the new files, get their sizes and add all symbols. */
1242 for (int cnt = 0; cnt < argc; ++cnt)
1243 {
1244 const char *bname = basename (argv[cnt]);
1245 size_t bnamelen = strlen (bname);
1246 if (found[cnt] == NULL)
1247 {
1248 found[cnt] = alloca (sizeof (struct armem));
1249 found[cnt]->old_off = -1;
1250
1251 remember_long_name (found[cnt], bname, bnamelen);
1252 }
1253
1254 struct stat newst;
1255 Elf *newelf;
1256 int newfd = open (argv[cnt], O_RDONLY);
1257 if (newfd == -1)
1258 {
1259 error (0, errno, gettext ("cannot open %s"), argv[cnt]);
1260 status = 1;
1261 }
1262 else if (fstat (newfd, &newst) == -1)
1263 {
1264 error (0, errno, gettext ("cannot stat %s"), argv[cnt]);
1265 close (newfd);
1266 status = 1;
1267 }
1268 else if (!S_ISREG (newst.st_mode))
1269 {
1270 error (0, errno, gettext ("%s is no regular file"), argv[cnt]);
1271 close (newfd);
1272 status = 1;
1273 }
1274 else if (update_newer
1275 && found[cnt]->old_off != -1l
1276 && found[cnt]->sec > st.st_mtime)
1277 /* Do nothing, the file in the archive is younger. */
1278 close (newfd);
1279 else if ((newelf = elf_begin (newfd, ELF_C_READ_MMAP, NULL))
1280 == NULL)
1281 {
1282 fprintf (stderr,
1283 gettext ("cannot get ELF descriptor for %s: %s\n"),
1284 argv[cnt], elf_errmsg (-1));
1285 status = 1;
1286 }
1287 else
1288 {
1289 if (verbose)
1290 printf ("%c - %s\n",
1291 found[cnt]->old_off == -1l ? 'a' : 'r', argv[cnt]);
1292
1293 found[cnt]->elf = newelf;
1294 found[cnt]->sec = arlib_deterministic_output ? 0 : newst.st_mtime;
1295 found[cnt]->uid = arlib_deterministic_output ? 0 : newst.st_uid;
1296 found[cnt]->gid = arlib_deterministic_output ? 0 : newst.st_gid;
1297 found[cnt]->mode = newst.st_mode;
1298 found[cnt]->name = bname;
1299
1300 found[cnt]->mem = elf_rawfile (newelf, &found[cnt]->size);
1301 if (found[cnt]->mem == NULL
1302 || elf_cntl (newelf, ELF_C_FDDONE) != 0)
1303 error (EXIT_FAILURE, 0, gettext ("cannot read %s: %s"),
1304 argv[cnt], elf_errmsg (-1));
1305
1306 close (newfd);
1307
1308 if (found[cnt]->old_off != -1l)
1309 /* Remember long file names. */
1310 remember_long_name (found[cnt], bname, bnamelen);
1311 }
1312 }
1313 }
1314
1315 if (status != 0)
1316 {
1317 #ifdef DEBUG
1318 elf_end (elf);
1319
1320 arlib_fini ();
1321
1322 close (fd);
1323 #endif
1324
1325 return status;
1326 }
1327
1328 /* If we have no entry point so far add at the end. AFTER_MEMBERELEM
1329 being NULL when adding before an entry means add at the beginning. */
1330 if (ipos != ipos_before && after_memberelem == NULL)
1331 after_memberelem = all;
1332
1333 /* Convert the circular list into a normal list first. */
1334 if (all != NULL)
1335 {
1336 struct armem *tmp = all;
1337 all = all->next;
1338 tmp->next = NULL;
1339 }
1340
1341 struct armem *last_added = after_memberelem;
1342 for (int cnt = 0; cnt < argc; ++cnt)
1343 if (oper != oper_replace || found[cnt]->old_off == -1)
1344 {
1345 if (last_added == NULL)
1346 {
1347 found[cnt]->next = all;
1348 last_added = all = found[cnt];
1349 }
1350 else
1351 {
1352 found[cnt]->next = last_added->next;
1353 last_added = last_added->next = found[cnt];
1354 }
1355 }
1356
1357 /* Finally compute the offset and add the symbols for the files
1358 after the insert point. */
1359 if (likely (all != NULL))
1360 for (struct armem *memp = all; memp != NULL; memp = memp->next)
1361 {
1362 memp->off = cur_off;
1363
1364 if (memp->mem == NULL)
1365 {
1366 Elf_Arhdr *arhdr;
1367 /* Fake initializing arhdr and subelf to keep gcc calm. */
1368 asm ("" : "=m" (arhdr), "=m" (subelf));
1369 if (elf_rand (elf, memp->old_off) == 0
1370 || (subelf = elf_begin (fd, ELF_C_READ_MMAP, elf)) == NULL
1371 || (arhdr = elf_getarhdr (subelf)) == NULL)
1372 /* This should never happen since we already looked at the
1373 archive content. But who knows... */
1374 error (EXIT_FAILURE, 0, "%s: %s", arfname, elf_errmsg (-1));
1375
1376 arlib_add_symbols (subelf, arfname, arhdr->ar_name, cur_off);
1377
1378 elf_end (subelf);
1379 }
1380 else
1381 arlib_add_symbols (memp->elf, arfname, memp->name, cur_off);
1382
1383 cur_off += (((memp->size + 1) & ~((off_t) 1))
1384 + sizeof (struct ar_hdr));
1385 }
1386
1387 /* Now we have all the information for the symbol table and long
1388 file name table. Construct the final layout. */
1389 arlib_finalize ();
1390
1391 /* Create a new, temporary file in the same directory as the
1392 original file. */
1393 char tmpfname[strlen (arfname) + 7];
1394 strcpy (stpcpy (tmpfname, arfname), "XXXXXX");
1395 int newfd;
1396 if (fd != -1)
1397 newfd = mkstemp (tmpfname);
1398 else
1399 {
1400 newfd = open (arfname, O_RDWR | O_CREAT | O_EXCL, DEFFILEMODE);
1401 if (newfd == -1 && errno == EEXIST)
1402 /* Bah, first the file did not exist, now it does. Restart. */
1403 return do_oper_insert (oper, arfname, argv, argc, member);
1404 }
1405 if (unlikely (newfd == -1))
1406 goto nonew;
1407
1408 /* Create the header. */
1409 if (unlikely (write_retry (newfd, ARMAG, SARMAG) != SARMAG))
1410 {
1411 nonew_unlink:
1412 if (fd != -1)
1413 {
1414 // XXX Use /prof/self/fd/%d ???
1415 unlink (tmpfname);
1416 if (newfd != -1)
1417 close (newfd);
1418 }
1419 nonew:
1420 error (0, errno, gettext ("cannot create new file"));
1421 status = 1;
1422 goto errout;
1423 }
1424
1425 /* If the new archive is not empty we actually have something to do. */
1426 if (likely (all != NULL))
1427 {
1428 /* Write the symbol table or the long file name table or both. */
1429 if (symtab.symsnamelen != 0
1430 && ((write_retry (newfd, symtab.symsoff, symtab.symsofflen)
1431 != (ssize_t) symtab.symsofflen)
1432 || (write_retry (newfd, symtab.symsname, symtab.symsnamelen)
1433 != (ssize_t) symtab.symsnamelen)))
1434 goto nonew_unlink;
1435
1436 if (symtab.longnameslen > sizeof (struct ar_hdr)
1437 && (write_retry (newfd, symtab.longnames, symtab.longnameslen)
1438 != (ssize_t) symtab.longnameslen))
1439 goto nonew_unlink;
1440
1441 off_t start = -1;
1442 off_t len = -1;
1443
1444 while (all != NULL)
1445 {
1446 if (all->mem != NULL)
1447 {
1448 /* This is a new file. If there is anything from the
1449 archive left to be written do it now. */
1450 if (start != -1 && copy_content (elf, newfd, start, len))
1451 goto nonew_unlink;
1452
1453 start = -1;
1454 len = -1;
1455
1456 /* Create the header. */
1457 struct ar_hdr arhdr;
1458 char tmpbuf[sizeof (arhdr.ar_name) + 1];
1459 if (all->long_name_off == -1)
1460 {
1461 size_t namelen = strlen (all->name);
1462 char *p = mempcpy (arhdr.ar_name, all->name, namelen);
1463 *p++ = '/';
1464 memset (p, ' ', sizeof (arhdr.ar_name) - namelen - 1);
1465 }
1466 else
1467 {
1468 snprintf (tmpbuf, sizeof (arhdr.ar_name) + 1, "/%-*ld",
1469 (int) sizeof (arhdr.ar_name), all->long_name_off);
1470 memcpy (arhdr.ar_name, tmpbuf, sizeof (arhdr.ar_name));
1471 }
1472
1473 no0print (false, arhdr.ar_date, sizeof (arhdr.ar_date),
1474 all->sec);
1475 no0print (false, arhdr.ar_uid, sizeof (arhdr.ar_uid), all->uid);
1476 no0print (false, arhdr.ar_gid, sizeof (arhdr.ar_gid), all->gid);
1477 no0print (true, arhdr.ar_mode, sizeof (arhdr.ar_mode),
1478 all->mode);
1479 no0print (false, arhdr.ar_size, sizeof (arhdr.ar_size),
1480 all->size);
1481 memcpy (arhdr.ar_fmag, ARFMAG, sizeof (arhdr.ar_fmag));
1482
1483 if (unlikely (write_retry (newfd, &arhdr, sizeof (arhdr))
1484 != sizeof (arhdr)))
1485 goto nonew_unlink;
1486
1487 /* Now the file itself. */
1488 if (unlikely (write_retry (newfd, all->mem, all->size)
1489 != (off_t) all->size))
1490 goto nonew_unlink;
1491
1492 /* Pad the file if its size is odd. */
1493 if ((all->size & 1) != 0)
1494 if (unlikely (write_retry (newfd, "\n", 1) != 1))
1495 goto nonew_unlink;
1496 }
1497 else
1498 {
1499 /* This is a member from the archive. */
1500 if (write_member (all, &start, &len, elf, cur_off, newfd)
1501 != 0)
1502 goto nonew_unlink;
1503 }
1504
1505 all = all->next;
1506 }
1507
1508 /* Write the last part. */
1509 if (start != -1 && copy_content (elf, newfd, start, len))
1510 goto nonew_unlink;
1511 }
1512
1513 /* Set the mode of the new file to the same values the original file
1514 has. */
1515 if (fd != -1
1516 && (fchmod (newfd, st.st_mode & ALLPERMS) != 0
1517 /* Never complain about fchown failing. */
1518 || (({asm ("" :: "r" (fchown (newfd, st.st_uid, st.st_gid))); }),
1519 close (newfd) != 0)
1520 || (newfd = -1, rename (tmpfname, arfname) != 0)))
1521 goto nonew_unlink;
1522
1523 errout:
1524 #ifdef DEBUG
1525 elf_end (elf);
1526
1527 arlib_fini ();
1528
1529 close (fd);
1530 #endif
1531
1532 return status;
1533 }
1534
1535
1536 #include "debugpred.h"
1537