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