libelf: Rename to sensible elfutils
[termux-packages] / packages / elfutils / ar.c.patch
CommitLineData
cf310881
FF
1diff -u -r ../elfutils-0.166/src/ar.c ./src/ar.c
2--- ../elfutils-0.166/src/ar.c 2015-11-27 08:36:29.000000000 -0500
3+++ ./src/ar.c 2016-05-04 14:29:53.035376083 -0400
4@@ -1,1536 +1 @@
5-/* Create, modify, and extract from archives.
6- Copyright (C) 2005-2012 Red Hat, Inc.
7- This file is part of elfutils.
8- Written by Ulrich Drepper <drepper@redhat.com>, 2005.
9-
10- This file is free software; you can redistribute it and/or modify
11- it under the terms of the GNU General Public License as published by
12- the Free Software Foundation; either version 3 of the License, or
13- (at your option) any later version.
14-
15- elfutils is distributed in the hope that it will be useful, but
16- WITHOUT ANY WARRANTY; without even the implied warranty of
17- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18- GNU General Public License for more details.
19-
20- You should have received a copy of the GNU General Public License
21- along with this program. If not, see <http://www.gnu.org/licenses/>. */
22-
23-#ifdef HAVE_CONFIG_H
24-# include <config.h>
25-#endif
26-
27-#include <argp.h>
28-#include <assert.h>
29-#include <error.h>
30-#include <fcntl.h>
31-#include <gelf.h>
32-#include <libintl.h>
33-#include <limits.h>
34-#include <locale.h>
35-#include <search.h>
36-#include <stdbool.h>
37-#include <stdlib.h>
38-#include <stdio.h>
39-#include <stdio_ext.h>
40-#include <string.h>
41-#include <time.h>
42-#include <unistd.h>
43-#include <sys/mman.h>
44-#include <sys/stat.h>
45-#include <sys/time.h>
46-
47-#include <system.h>
48-
49-#include "arlib.h"
50-
51-
52-/* Name and version of program. */
53-static void print_version (FILE *stream, struct argp_state *state);
54-ARGP_PROGRAM_VERSION_HOOK_DEF = print_version;
55-
56-/* Prototypes for local functions. */
57-static int do_oper_extract (int oper, const char *arfname, char **argv,
58- int argc, long int instance);
59-static int do_oper_delete (const char *arfname, char **argv, int argc,
60- long int instance);
61-static int do_oper_insert (int oper, const char *arfname, char **argv,
62- int argc, const char *member);
63-
64-
65-/* Bug report address. */
66-ARGP_PROGRAM_BUG_ADDRESS_DEF = PACKAGE_BUGREPORT;
67-
68-
69-/* Definitions of arguments for argp functions. */
70-static const struct argp_option options[] =
71-{
72- { NULL, 0, NULL, 0, N_("Commands:"), 1 },
73- { NULL, 'd', NULL, 0, N_("Delete files from archive."), 0 },
74- { NULL, 'm', NULL, 0, N_("Move files in archive."), 0 },
75- { NULL, 'p', NULL, 0, N_("Print files in archive."), 0 },
76- { NULL, 'q', NULL, 0, N_("Quick append files to archive."), 0 },
77- { NULL, 'r', NULL, 0,
78- N_("Replace existing or insert new file into archive."), 0 },
79- { NULL, 't', NULL, 0, N_("Display content of archive."), 0 },
80- { NULL, 'x', NULL, 0, N_("Extract files from archive."), 0 },
81-
82- { NULL, 0, NULL, 0, N_("Command Modifiers:"), 2 },
83- { NULL, 'o', NULL, 0, N_("Preserve original dates."), 0 },
84- { NULL, 'N', NULL, 0, N_("Use instance [COUNT] of name."), 0 },
85- { NULL, 'C', NULL, 0,
86- N_("Do not replace existing files with extracted files."), 0 },
87- { NULL, 'T', NULL, 0, N_("Allow filename to be truncated if necessary."),
88- 0 },
89- { NULL, 'v', NULL, 0, N_("Provide verbose output."), 0 },
90- { NULL, 's', NULL, 0, N_("Force regeneration of symbol table."), 0 },
91- { NULL, 'a', NULL, 0, N_("Insert file after [MEMBER]."), 0 },
92- { NULL, 'b', NULL, 0, N_("Insert file before [MEMBER]."), 0 },
93- { NULL, 'i', NULL, 0, N_("Same as -b."), 0 },
94- { NULL, 'c', NULL, 0, N_("Suppress message when library has to be created."),
95- 0 },
96- { NULL, 'P', NULL, 0, N_("Use full path for file matching."), 0 },
97- { NULL, 'u', NULL, 0, N_("Update only older files in archive."), 0 },
98-
99- { NULL, 0, NULL, 0, NULL, 0 }
100-};
101-
102-/* Short description of program. */
103-static const char doc[] = N_("Create, modify, and extract from archives.");
104-
105-/* Strings for arguments in help texts. */
106-static const char args_doc[] = N_("[MEMBER] [COUNT] ARCHIVE [FILE...]");
107-
108-/* Prototype for option handler. */
109-static error_t parse_opt (int key, char *arg, struct argp_state *state);
110-
111-/* Data structure to communicate with argp functions. */
112-static struct argp argp =
113-{
114- options, parse_opt, args_doc, doc, arlib_argp_children, NULL, NULL
115-};
116-
117-
118-/* What operation to perform. */
119-static enum
120- {
121- oper_none,
122- oper_delete,
123- oper_move,
124- oper_print,
125- oper_qappend,
126- oper_replace,
127- oper_list,
128- oper_extract
129- } operation;
130-
131-/* Modifiers. */
132-static bool verbose;
133-static bool preserve_dates;
134-static bool instance_specifed;
135-static bool dont_replace_existing;
136-static bool allow_truncate_fname;
137-static bool force_symtab;
138-static bool suppress_create_msg;
139-static bool full_path;
140-static bool update_newer;
141-static enum { ipos_none, ipos_before, ipos_after } ipos;
142-
143-
144-int
145-main (int argc, char *argv[])
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
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
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
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
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
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
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 timespec tv[2];
687- tv[0].tv_sec = arhdr->ar_date;
688- tv[0].tv_nsec = 0;
689- tv[1].tv_sec = arhdr->ar_date;
690- tv[1].tv_nsec = 0;
691-
692- if (unlikely (futimens (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
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
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
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
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
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+int main() { return 0; }