--- /dev/null
+/* Create, modify, and extract from archives.
+ Copyright (C) 2005, 2007 Red Hat, Inc.
+ Written by Ulrich Drepper <drepper@redhat.com>, 2005.
+
+ Red Hat elfutils is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by the
+ Free Software Foundation; version 2 of the License.
+
+ Red Hat elfutils is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with Red Hat elfutils; if not, write to the Free Software Foundation,
+ Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA.
+
+ Red Hat elfutils is an included package of the Open Invention Network.
+ An included package of the Open Invention Network is a package for which
+ Open Invention Network licensees cross-license their patents. No patent
+ license is granted, either expressly or impliedly, by designation as an
+ included package. Should you wish to participate in the Open Invention
+ Network licensing program, please visit www.openinventionnetwork.com
+ <http://www.openinventionnetwork.com>. */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <argp.h>
+#include <assert.h>
+#include <error.h>
+#include <fcntl.h>
+#include <gelf.h>
+#include <libintl.h>
+#include <locale.h>
+#include <mcheck.h>
+#include <search.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdio_ext.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/statfs.h>
+#include <sys/time.h>
+
+#include <system.h>
+
+#include "arlib.h"
+
+
+/* Name and version of program. */
+static void print_version (FILE *stream, struct argp_state *state);
+void (*argp_program_version_hook) (FILE *, struct argp_state *) = print_version;
+/* Prototypes for local functions. */
+static int do_oper_extract (int oper, const char *arfname, char **argv,
+ int argc, long int instance);
+static int do_oper_delete (const char *arfname, char **argv, int argc,
+ long int instance);
+static int do_oper_insert (int oper, const char *arfname, char **argv,
+ int argc, const char *member);
+
+
+/* Bug report address. */
+const char *argp_program_bug_address = PACKAGE_BUGREPORT;
+
+
+/* Definitions of arguments for argp functions. */
+static const struct argp_option options[] =
+{
+ { NULL, 0, NULL, 0, N_("Commands:"), 0 },
+ { NULL, 'd', NULL, 0, N_("Delete files from archive."), 0 },
+ { NULL, 'm', NULL, 0, N_("Move files in archive."), 0 },
+ { NULL, 'p', NULL, 0, N_("Print files in archive."), 0 },
+ { NULL, 'q', NULL, 0, N_("Quick append files to archive."), 0 },
+ { NULL, 'r', NULL, 0,
+ N_("Replace existing or insert new file into archive."), 0 },
+ { NULL, 't', NULL, 0, N_("Display content of archive."), 0 },
+ { NULL, 'x', NULL, 0, N_("Extract files from archive."), 0 },
+
+ { NULL, 0, NULL, 0, N_("Command Modifiers:"), 0 },
+ { NULL, 'o', NULL, 0, N_("Preserve original dates."), 0 },
+ { NULL, 'N', NULL, 0, N_("Use instance [COUNT] of name."), 0 },
+ { NULL, 'C', NULL, 0,
+ N_("Do not replace existing files with extracted files."), 0 },
+ { NULL, 'T', NULL, 0, N_("Allow filename to be truncated if necessary."),
+ 0 },
+ { NULL, 'v', NULL, 0, N_("Provide verbose output."), 0 },
+ { NULL, 's', NULL, 0, N_("Force regeneration of symbol table."), 0 },
+ { NULL, 'a', NULL, 0, N_("Insert file after [MEMBER]."), 0 },
+ { NULL, 'b', NULL, 0, N_("Insert file before [MEMBER]."), 0 },
+ { NULL, 'i', NULL, 0, N_("Same as -b."), 0 },
+ { NULL, 'c', NULL, 0, N_("Suppress message when library has to be created."),
+ 0 },
+ { NULL, 'P', NULL, 0, N_("Use full path for file matching."), 0 },
+ { NULL, 'u', NULL, 0, N_("Update only older files in archive."), 0 },
+
+ { NULL, 0, NULL, 0, NULL, 0 }
+};
+
+/* Short description of program. */
+static const char doc[] = N_("Create, modify, and extract from archives.");
+
+/* Strings for arguments in help texts. */
+static const char args_doc[] = N_("[MEMBER] [COUNT] ARCHIVE [FILE...]");
+
+/* Prototype for option handler. */
+static error_t parse_opt (int key, char *arg, struct argp_state *state);
+
+/* Data structure to communicate with argp functions. */
+static struct argp argp =
+{
+ options, parse_opt, args_doc, doc, NULL, NULL, NULL
+};
+
+
+/* What operation to perform. */
+static enum
+ {
+ oper_none,
+ oper_delete,
+ oper_move,
+ oper_print,
+ oper_qappend,
+ oper_replace,
+ oper_list,
+ oper_extract
+ } operation;
+
+/* Modifiers. */
+static bool verbose;
+static bool preserve_dates;
+static bool instance_specifed;
+static bool dont_replace_existing;
+static bool allow_truncate_fname;
+static bool force_symtab;
+static bool suppress_create_msg;
+static bool full_path;
+static bool update_newer;
+static enum { ipos_none, ipos_before, ipos_after } ipos;
+
+
+int
+main (int argc, char *argv[])
+{
+ /* Make memory leak detection possible. */
+ mtrace ();
+
+ /* We use no threads here which can interfere with handling a stream. */
+ (void) __fsetlocking (stdin, FSETLOCKING_BYCALLER);
+ (void) __fsetlocking (stdout, FSETLOCKING_BYCALLER);
+ (void) __fsetlocking (stderr, FSETLOCKING_BYCALLER);
+
+ /* Set locale. */
+ (void) setlocale (LC_ALL, "");
+
+ /* Make sure the message catalog can be found. */
+ (void) bindtextdomain (PACKAGE, LOCALEDIR);
+
+ /* Initialize the message catalog. */
+ (void) textdomain (PACKAGE);
+
+ /* For historical reasons the options in the first parameter need
+ not be preceded by a dash. Add it now if necessary. */
+ if (argc > 1 && argv[1][0] != '-')
+ {
+ size_t len = strlen (argv[1]) + 1;
+ char *newp = alloca (len + 1);
+ newp[0] = '-';
+ memcpy (&newp[1], argv[1], len);
+ argv[1] = newp;
+ }
+
+ /* Parse and process arguments. */
+ int remaining;
+ (void) argp_parse (&argp, argc, argv, ARGP_IN_ORDER, &remaining, NULL);
+
+ /* Tell the library which version we are expecting. */
+ (void) elf_version (EV_CURRENT);
+
+ /* Handle the [MEMBER] parameter. */
+ const char *member = NULL;
+ if (ipos != ipos_none)
+ {
+ /* Only valid for certain operations. */
+ if (operation == oper_extract && operation == oper_delete)
+ error (1, 0, gettext ("\
+'a', 'b', and 'i' are only allowed with the 'm' and 'r' options"));
+
+ if (remaining == argc)
+ {
+ error (0, 0, gettext ("MEMBER parameter required"));
+ argp_help (&argp, stderr, ARGP_HELP_SEE, AR);
+ exit (EXIT_FAILURE);
+ }
+
+ member = argv[remaining++];
+ }
+
+ /* Handle the [COUNT] parameter. */
+ long int instance = -1;
+ if (instance_specifed)
+ {
+ /* Only valid for certain operations. */
+ if (operation == oper_extract && operation == oper_delete)
+ error (1, 0, gettext ("\
+'N' is only meaningful with the 'x' and 'd' options"));
+
+ if (remaining == argc)
+ {
+ error (0, 0, gettext ("COUNT parameter required"));
+ argp_help (&argp, stderr, ARGP_HELP_SEE, AR);
+ exit (EXIT_FAILURE);
+ }
+
+ char *endp;
+ errno = 0;
+ if (((instance = strtol (argv[remaining], &endp, 10)) == LONG_MAX
+ && errno == ERANGE)
+ || instance <= 0
+ || *endp != '\0')
+ error (1, 0, gettext ("invalid COUNT parameter %s"), argv[remaining]);
+
+ ++remaining;
+ }
+
+ if ((dont_replace_existing || allow_truncate_fname)
+ && unlikely (operation != oper_extract))
+ error (1, 0, gettext ("'%' is only meaningful with the 'x' option"),
+ dont_replace_existing ? 'C' : 'T');
+
+ /* There must at least be one more parameter specifying the archive. */
+ if (remaining == argc)
+ {
+ error (0, 0, gettext ("Archive name required"));
+ argp_help (&argp, stderr, ARGP_HELP_SEE, AR);
+ exit (EXIT_FAILURE);
+ }
+
+ const char *arfname = argv[remaining++];
+ argv += remaining;
+ argc -= remaining;
+
+ int status;
+ switch (operation)
+ {
+ case oper_list:
+ case oper_print:
+ status = do_oper_extract (operation, arfname, argv, argc, -1);
+ break;
+
+ case oper_extract:
+ status = do_oper_extract (operation, arfname, argv, argc, instance);
+ break;
+
+ case oper_delete:
+ status = do_oper_delete (arfname, argv, argc, instance);
+ break;
+
+ case oper_move:
+ case oper_qappend:
+ case oper_replace:
+ status = do_oper_insert (operation, arfname, argv, argc, member);
+ break;
+
+ default:
+ assert (! "should not happen");
+ status = 1;
+ break;
+ }
+
+ return status;
+}
+
+
+/* Print the version information. */
+static void
+print_version (FILE *stream, struct argp_state *state __attribute__ ((unused)))
+{
+ fprintf (stream, "ar (%s) %s\n", PACKAGE_NAME, VERSION);
+ fprintf (stream, gettext ("\
+Copyright (C) %s Red Hat, Inc.\n\
+This is free software; see the source for copying conditions. There is NO\n\
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
+"), "2007");
+ fprintf (stream, gettext ("Written by %s.\n"), "Ulrich Drepper");
+}
+
+
+/* Handle program arguments. */
+static error_t
+parse_opt (int key, char *arg __attribute__ ((unused)),
+ struct argp_state *state __attribute__ ((unused)))
+{
+ switch (key)
+ {
+ case 'd':
+ case 'm':
+ case 'p':
+ case 'q':
+ case 'r':
+ case 't':
+ case 'x':
+ if (operation != oper_none)
+ {
+ error (0, 0, gettext ("More than one operation specified"));
+ argp_help (&argp, stderr, ARGP_HELP_SEE, AR);
+ exit (EXIT_FAILURE);
+ }
+
+ switch (key)
+ {
+ case 'd':
+ operation = oper_delete;
+ break;
+ case 'm':
+ operation = oper_move;
+ break;
+ case 'p':
+ operation = oper_print;
+ break;
+ case 'q':
+ operation = oper_qappend;
+ break;
+ case 'r':
+ operation = oper_replace;
+ break;
+ case 't':
+ operation = oper_list;
+ break;
+ case 'x':
+ operation = oper_extract;
+ break;
+ }
+ break;
+
+ case 'a':
+ ipos = ipos_after;
+ break;
+
+ case 'b':
+ case 'i':
+ ipos = ipos_before;
+ break;
+
+ case 'c':
+ suppress_create_msg = true;
+ break;
+
+ case 'C':
+ dont_replace_existing = true;
+ break;
+
+ case 'N':
+ instance_specifed = true;
+ break;
+
+ case 'o':
+ preserve_dates = true;
+ break;
+
+ case 'P':
+ full_path = true;
+ break;
+
+ case 's':
+ force_symtab = true;
+ break;
+
+ case 'T':
+ allow_truncate_fname = true;
+ break;
+
+ case 'v':
+ verbose = true;
+ break;
+
+ default:
+ return ARGP_ERR_UNKNOWN;
+ }
+ return 0;
+}
+
+
+static int
+open_archive (const char *arfname, int flags, int mode, Elf **elf,
+ struct stat *st, bool miss_allowed)
+{
+ int fd = open (arfname, flags, mode);
+ if (fd == -1)
+ {
+ if (miss_allowed)
+ return -1;
+
+ error (EXIT_FAILURE, errno, gettext ("cannot open archive '%s'"),
+ arfname);
+ }
+
+ if (elf != NULL)
+ {
+ Elf_Cmd cmd = flags == O_RDONLY ? ELF_C_READ_MMAP : ELF_C_RDWR_MMAP;
+
+ *elf = elf_begin (fd, cmd, NULL);
+ if (*elf == NULL)
+ error (EXIT_FAILURE, 0, gettext ("cannot open archive '%s': %s"),
+ arfname, elf_errmsg (-1));
+
+ if (flags == O_RDONLY && elf_kind (*elf) != ELF_K_AR)
+ error (EXIT_FAILURE, 0, gettext ("%s: not an archive file"), arfname);
+ }
+
+ if (st != NULL && fstat (fd, st) != 0)
+ error (EXIT_FAILURE, errno, gettext ("cannot stat archive '%s'"),
+ arfname);
+
+ return fd;
+}
+
+
+static void
+not_found (int argc, char *argv[argc], bool found[argc])
+{
+ for (int i = 0; i < argc; ++i)
+ if (!found[i])
+ printf (gettext ("no entry %s in archive\n"), argv[i]);
+}
+
+
+static int
+copy_content (Elf *elf, int newfd, off_t off, size_t n)
+{
+ size_t len;
+ char *rawfile = elf_rawfile (elf, &len);
+
+ assert (off + n <= len);
+
+ /* Tell the kernel we will read all the pages sequentially. */
+ size_t ps = sysconf (_SC_PAGESIZE);
+ if (n > 2 * ps)
+ posix_madvise (rawfile + (off & ~(ps - 1)), n, POSIX_MADV_SEQUENTIAL);
+
+ return write_retry (newfd, rawfile + off, n) != (ssize_t) n;
+}
+
+
+static int
+do_oper_extract (int oper, const char *arfname, char **argv, int argc,
+ long int instance)
+{
+ bool found[argc];
+ memset (found, '\0', sizeof (found));
+
+ struct statfs f;
+ f.f_namelen = 0;
+
+ off_t index_off = -1;
+ size_t index_size = 0;
+ off_t cur_off = SARMAG;
+
+ int status = 0;
+ Elf *elf;
+ int fd = open_archive (arfname, O_RDONLY, 0, &elf, NULL, false);
+
+ if (hcreate (2 * argc) == 0)
+ error (EXIT_FAILURE, errno, gettext ("cannot create hash table"));
+
+ for (int cnt = 0; cnt < argc; ++cnt)
+ {
+ ENTRY entry = { .key = argv[cnt], .data = &argv[cnt] };
+ if (hsearch (entry, ENTER) == NULL)
+ error (EXIT_FAILURE, errno,
+ gettext ("cannot insert into hash table"));
+ }
+
+ struct arlib_symtab symtab;
+ struct stat st;
+ if (force_symtab)
+ {
+ if (fstat (fd, &st) != 0)
+ {
+ error (0, errno, gettext ("cannot stat '%s'"), arfname);
+ close (fd);
+ return 1;
+ }
+ arlib_init (&symtab);
+ }
+
+ Elf_Cmd cmd = ELF_C_READ_MMAP;
+ Elf *subelf;
+ while ((subelf = elf_begin (fd, cmd, elf)) != NULL)
+ {
+ Elf_Arhdr *arhdr = elf_getarhdr (subelf);
+
+ if (strcmp (arhdr->ar_name, "/") == 0)
+ {
+ index_off = elf_getaroff (subelf);
+ index_size = arhdr->ar_size;
+ goto next;
+ }
+ if (strcmp (arhdr->ar_name, "//") == 0)
+ goto next;
+
+ if (force_symtab)
+ {
+ arlib_add_symbols (elf, arfname, arhdr->ar_name, &symtab, cur_off);
+ cur_off += (((arhdr->ar_size + 1) & ~((off_t) 1))
+ + sizeof (struct ar_hdr));
+ }
+
+ bool do_extract = argc <= 0;
+ if (!do_extract)
+ {
+ ENTRY entry;
+ entry.key = arhdr->ar_name;
+ ENTRY *res = hsearch (entry, FIND);
+ if (res != NULL && (instance < 0 || instance-- == 0)
+ && !found[(char **) res->data - argv])
+ found[(char **) res->data - argv] = do_extract = true;
+ }
+
+ if (do_extract)
+ {
+ if (verbose)
+ {
+ if (oper == oper_print)
+ {
+ printf ("\n<%s>\n\n", arhdr->ar_name);
+
+ /* We have to flush now because now we use the descriptor
+ directly. */
+ fflush (stdout);
+ }
+ else if (oper == oper_list)
+ {
+ char datestr[100];
+ strftime (datestr, sizeof (datestr), "%b %e %H:%M %Y",
+ localtime (&arhdr->ar_date));
+
+ printf ("%c%c%c%c%c%c%c%c%c %u/%u %6ju %s %s\n",
+ (arhdr->ar_mode & S_IRUSR) ? 'r' : '-',
+ (arhdr->ar_mode & S_IWUSR) ? 'w' : '-',
+ (arhdr->ar_mode & S_IXUSR)
+ ? ((arhdr->ar_mode & S_ISUID) ? 's' : 'x')
+ : ((arhdr->ar_mode & S_ISUID) ? 'S' : '-'),
+ (arhdr->ar_mode & S_IRGRP) ? 'r' : '-',
+ (arhdr->ar_mode & S_IWGRP) ? 'w' : '-',
+ (arhdr->ar_mode & S_IXGRP)
+ ? ((arhdr->ar_mode & S_ISGID) ? 's' : 'x')
+ : ((arhdr->ar_mode & S_ISGID) ? 'S' : '-'),
+ (arhdr->ar_mode & S_IROTH) ? 'r' : '-',
+ (arhdr->ar_mode & S_IWOTH) ? 'w' : '-',
+ (arhdr->ar_mode & S_IXOTH)
+ ? ((arhdr->ar_mode & S_ISVTX) ? 't' : 'x')
+ : ((arhdr->ar_mode & S_ISVTX) ? 'T' : '-'),
+ arhdr->ar_uid,
+ arhdr->ar_gid,
+ (uintmax_t) arhdr->ar_size,
+ datestr,
+ arhdr->ar_name);
+ }
+ else
+ printf ("x - %s\n", arhdr->ar_name);
+ }
+
+ if (oper == oper_list)
+ {
+ if (!verbose)
+ puts (arhdr->ar_name);
+
+ goto next;
+ }
+
+ size_t nleft;
+ char *data = elf_rawfile (subelf, &nleft);
+ if (data == NULL)
+ {
+ error (0, 0, gettext ("cannot read content of %s: %s"),
+ arhdr->ar_name, elf_errmsg (-1));
+ status = 1;
+ goto next;
+ }
+
+ int xfd;
+ char tempfname[] = "XXXXXX";
+ bool use_mkstemp = true;
+
+ if (oper == oper_print)
+ xfd = STDOUT_FILENO;
+ else
+ {
+ xfd = mkstemp (tempfname);
+ if (unlikely (xfd == -1))
+ {
+ /* We cannot create a temporary file. Try to overwrite
+ the file or create it if it does not exist. */
+ int flags = O_WRONLY | O_CREAT;
+ if (dont_replace_existing)
+ flags |= O_EXCL;
+ else
+ flags |= O_TRUNC;
+ xfd = open (arhdr->ar_name, flags, 0600);
+ if (unlikely (xfd == -1))
+ {
+ int printlen = INT_MAX;
+
+ if (errno == ENAMETOOLONG && allow_truncate_fname
+ && (f.f_namelen != 0 || statfs (".", &f) == 0))
+ {
+ /* Try to truncate the name. First find out by how
+ much. */
+ printlen = f.f_namelen;
+ char truncfname[f.f_namelen + 1];
+ *((char *) mempcpy (truncfname, arhdr->ar_name,
+ f.f_namelen)) = '\0';
+
+ xfd = open (truncfname, flags, 0600);
+ }
+
+ if (xfd == -1)
+ {
+ error (0, errno, gettext ("cannot open %.*s"),
+ (int) printlen, arhdr->ar_name);
+ status = 1;
+ goto next;
+ }
+ }
+
+ use_mkstemp = false;
+ }
+ }
+
+ ssize_t n;
+ while ((n = TEMP_FAILURE_RETRY (write (xfd, data, nleft))) != -1)
+ {
+ nleft -= n;
+ if (nleft == 0)
+ break;
+ data += n;
+ }
+
+ if (unlikely (n == -1))
+ {
+ error (0, errno, gettext ("failed to write %s"), arhdr->ar_name);
+ status = 1;
+ unlink (tempfname);
+ close (xfd);
+ goto next;
+ }
+
+ if (oper != oper_print)
+ {
+ /* Fix up the mode. */
+ if (unlikely (fchmod (xfd, arhdr->ar_mode) != 0))
+ {
+ error (0, errno, gettext ("cannot change mode of %s"),
+ arhdr->ar_name);
+ status = 0;
+ }
+
+ if (preserve_dates)
+ {
+ struct timeval tv[2];
+ tv[0].tv_sec = arhdr->ar_date;
+ tv[0].tv_usec = 0;
+ tv[1].tv_sec = arhdr->ar_date;
+ tv[1].tv_usec = 0;
+
+ if (unlikely (futimes (xfd, tv) != 0))
+ {
+ error (0, errno,
+ gettext ("cannot change modification time of %s"),
+ arhdr->ar_name);
+ status = 1;
+ }
+ }
+
+ /* If we used a temporary file, move it do the right
+ name now. */
+ if (use_mkstemp)
+ {
+ int r;
+
+ if (dont_replace_existing)
+ {
+ r = link (tempfname, arhdr->ar_name);
+ if (likely (r == 0))
+ unlink (tempfname);
+ }
+ else
+ r = rename (tempfname, arhdr->ar_name);
+
+ if (unlikely (r) != 0)
+ {
+ int printlen = INT_MAX;
+
+ if (errno == ENAMETOOLONG && allow_truncate_fname
+ && (f.f_namelen != 0 || statfs (".", &f) == 0))
+ {
+ /* Try to truncate the name. First find out by how
+ much. */
+ printlen = f.f_namelen;
+ char truncfname[f.f_namelen + 1];
+ *((char *) mempcpy (truncfname, arhdr->ar_name,
+ f.f_namelen)) = '\0';
+
+ if (dont_replace_existing)
+ {
+ r = link (tempfname, truncfname);
+ if (likely (r == 0))
+ unlink (tempfname);
+ }
+ else
+ r = rename (tempfname, truncfname);
+ }
+
+ if (r != 0)
+ {
+ error (0, errno, gettext ("\
+cannot rename temporary file to %.*s"),
+ printlen, arhdr->ar_name);
+ unlink (tempfname);
+ status = 1;
+ }
+ }
+ }
+
+ close (xfd);
+ }
+ }
+
+ next:
+ cmd = elf_next (subelf);
+ if (elf_end (subelf) != 0)
+ error (1, 0, "%s: %s", arfname, elf_errmsg (-1));
+ }
+
+ hdestroy ();
+
+ if (force_symtab)
+ {
+ arlib_finalize (&symtab);
+
+ if (symtab.symsnamelen != 0
+ /* We have to rewrite the file also if it initially had an index
+ but now does not need one anymore. */
+ || (symtab.symsnamelen == 0 && index_size != 0))
+ {
+ char tmpfname[strlen (arfname) + 7];
+ strcpy (stpcpy (tmpfname, arfname), "XXXXXX");
+ int newfd = mkstemp (tmpfname);
+ if (unlikely (newfd == -1))
+ {
+ nonew:
+ error (0, errno, gettext ("cannot create new file"));
+ status = 1;
+ }
+ else
+ {
+ /* Create the header. */
+ if (unlikely (write_retry (newfd, ARMAG, SARMAG) != SARMAG))
+ {
+ // XXX Use /prof/self/fd/%d ???
+ nonew_unlink:
+ unlink (tmpfname);
+ if (newfd != -1)
+ close (newfd);
+ goto nonew;
+ }
+
+ /* Create the new file. There are three parts as far we are
+ concerned: 1. original context before the index, 2. the
+ new index, 3. everything after the new index. */
+ off_t rest_off;
+ if (index_off != -1)
+ rest_off = (index_off + sizeof (struct ar_hdr)
+ + ((index_size + 1) & ~1ul));
+ else
+ rest_off = SARMAG;
+
+ if ((symtab.symsnamelen != 0
+ && ((write_retry (newfd, symtab.symsoff,
+ symtab.symsofflen)
+ != (ssize_t) symtab.symsofflen)
+ || (write_retry (newfd, symtab.symsname,
+ symtab.symsnamelen)
+ != (ssize_t) symtab.symsnamelen)))
+ /* Even if the original file had content before the
+ symbol table, we write it in the correct order. */
+ || (index_off != SARMAG
+ && copy_content (elf, newfd, SARMAG, index_off - SARMAG))
+ || copy_content (elf, newfd, rest_off, st.st_size - rest_off)
+ /* Set the mode of the new file to the same values the
+ original file has. */
+ || fchmod (newfd, st.st_mode & ALLPERMS) != 0
+ /* Never complain about fchown failing. */
+ || (fchown (newfd, st.st_uid, st.st_gid),
+ close (newfd) != 0)
+ || (newfd = -1, rename (tmpfname, arfname) != 0))
+ goto nonew_unlink;
+ }
+ }
+ }
+
+ elf_end (elf);
+
+ close (fd);
+
+ not_found (argc, argv, found);
+
+ return status;
+}
+
+
+struct armem
+{
+ off_t off;
+ off_t old_off;
+ size_t size;
+ long int long_name_off;
+ struct armem *next;
+ void *mem;
+ time_t sec;
+ uid_t uid;
+ gid_t gid;
+ mode_t mode;
+ const char *name;
+ Elf *elf;
+};
+
+
+static int
+write_member (struct armem *memb, off_t *startp, off_t *lenp, Elf *elf,
+ off_t end_off, int newfd)
+{
+ struct ar_hdr arhdr;
+ char tmpbuf[sizeof (arhdr.ar_name) + 1];
+
+ bool changed_header = memb->long_name_off != -1;
+ if (changed_header)
+ {
+ /* In case of a long file name we assume the archive header
+ changed and we write it here. */
+ memcpy (&arhdr, elf_rawfile (elf, NULL) + *startp, sizeof (arhdr));
+
+ snprintf (tmpbuf, sizeof (tmpbuf), "/%-*ld",
+ (int) sizeof (arhdr.ar_name), memb->long_name_off);
+ changed_header = memcmp (arhdr.ar_name, tmpbuf,
+ sizeof (arhdr.ar_name)) != 0;
+ }
+
+ /* If the files are adjacent in the old file extend the range. */
+ if (*startp != -1 && !changed_header && *startp + *lenp == memb->old_off)
+ {
+ /* Extend the current range. */
+ *lenp += (memb->next != NULL
+ ? memb->next->off : end_off) - memb->off;
+ return 0;
+ }
+
+ /* Write out the old range. */
+ if (*startp != -1 && copy_content (elf, newfd, *startp, *lenp))
+ return -1;
+
+ *startp = memb->old_off;
+ *lenp = (memb->next != NULL ? memb->next->off : end_off) - memb->off;
+
+ if (changed_header)
+ {
+ memcpy (arhdr.ar_name, tmpbuf, sizeof (arhdr.ar_name));
+
+ if (unlikely (write_retry (newfd, &arhdr, sizeof (arhdr))
+ != sizeof (arhdr)))
+ return -1;
+
+ *startp += sizeof (struct ar_hdr);
+ assert ((size_t) *lenp >= sizeof (struct ar_hdr));
+ *lenp -= sizeof (struct ar_hdr);
+ }
+
+ return 0;
+}
+
+
+static int
+do_oper_delete (const char *arfname, char **argv, int argc,
+ long int instance)
+{
+ bool *found = alloca (sizeof (bool) * argc);
+ memset (found, '\0', sizeof (found));
+
+ /* List of the files we keep. */
+ struct armem *to_copy = NULL;
+
+ int status = 0;
+ Elf *elf;
+ struct stat st;
+ int fd = open_archive (arfname, O_RDONLY, 0, &elf, &st, false);
+
+ if (hcreate (2 * argc) == 0)
+ error (EXIT_FAILURE, errno, gettext ("cannot create hash table"));
+
+ for (int cnt = 0; cnt < argc; ++cnt)
+ {
+ ENTRY entry = { .key = argv[cnt], .data = &argv[cnt] };
+ if (hsearch (entry, ENTER) == NULL)
+ error (EXIT_FAILURE, errno,
+ gettext ("cannot insert into hash table"));
+ }
+
+ struct arlib_symtab symtab;
+ arlib_init (&symtab);
+
+ off_t cur_off = SARMAG;
+ Elf_Cmd cmd = ELF_C_READ_MMAP;
+ Elf *subelf;
+ while ((subelf = elf_begin (fd, cmd, elf)) != NULL)
+ {
+ Elf_Arhdr *arhdr = elf_getarhdr (subelf);
+
+ /* Ignore the symbol table and the long file name table here. */
+ if (strcmp (arhdr->ar_name, "/") == 0
+ || strcmp (arhdr->ar_name, "//") == 0)
+ goto next;
+
+ bool do_delete = argc <= 0;
+ if (!do_delete)
+ {
+ ENTRY entry;
+ entry.key = arhdr->ar_name;
+ ENTRY *res = hsearch (entry, FIND);
+ if (res != NULL && (instance < 0 || instance-- == 0)
+ && !found[(char **) res->data - argv])
+ found[(char **) res->data - argv] = do_delete = true;
+ }
+
+ if (do_delete)
+ {
+ if (verbose)
+ printf ("d - %s\n", arhdr->ar_name);
+ }
+ else
+ {
+ struct armem *newp = alloca (sizeof (struct armem));
+ newp->old_off = elf_getaroff (subelf);
+ newp->off = cur_off;
+
+ cur_off += (((arhdr->ar_size + 1) & ~((off_t) 1))
+ + sizeof (struct ar_hdr));
+
+ if (to_copy == NULL)
+ to_copy = newp->next = newp;
+ else
+ {
+ newp->next = to_copy->next;
+ to_copy = to_copy->next = newp;
+ }
+
+ /* If we recreate the symbol table read the file's symbol
+ table now. */
+ arlib_add_symbols (subelf, arfname, arhdr->ar_name, &symtab,
+ newp->off);
+
+ /* Remember long file names. */
+ size_t ar_namelen = strlen (arhdr->ar_name);
+ if (ar_namelen > MAX_AR_NAME_LEN)
+ newp->long_name_off = arlib_add_long_name (&symtab,
+ arhdr->ar_name,
+ ar_namelen);
+ else
+ newp->long_name_off = -1l;
+ }
+
+ next:
+ cmd = elf_next (subelf);
+ if (elf_end (subelf) != 0)
+ error (1, 0, "%s: %s", arfname, elf_errmsg (-1));
+ }
+
+ arlib_finalize (&symtab);
+
+ hdestroy ();
+
+ /* Create a new, temporary file in the same directory as the
+ original file. */
+ char tmpfname[strlen (arfname) + 7];
+ strcpy (stpcpy (tmpfname, arfname), "XXXXXX");
+ int newfd = mkstemp (tmpfname);
+ if (unlikely (newfd == -1))
+ goto nonew;
+
+ /* Create the header. */
+ if (unlikely (write_retry (newfd, ARMAG, SARMAG) != SARMAG))
+ {
+ // XXX Use /prof/self/fd/%d ???
+ nonew_unlink:
+ unlink (tmpfname);
+ if (newfd != -1)
+ close (newfd);
+ nonew:
+ error (0, errno, gettext ("cannot create new file"));
+ status = 1;
+ goto errout;
+ }
+
+ /* If the archive is empty that is all we have to do. */
+ if (likely (to_copy != NULL))
+ {
+ /* Write the symbol table or the long file name table or both. */
+ if (symtab.symsnamelen != 0
+ && ((write_retry (newfd, symtab.symsoff, symtab.symsofflen)
+ != (ssize_t) symtab.symsofflen)
+ || (write_retry (newfd, symtab.symsname, symtab.symsnamelen)
+ != (ssize_t) symtab.symsnamelen)))
+ goto nonew_unlink;
+
+ if (symtab.longnameslen > sizeof (struct ar_hdr)
+ && (write_retry (newfd, symtab.longnames, symtab.longnameslen)
+ != (ssize_t) symtab.longnameslen))
+ goto nonew_unlink;
+
+ /* NULL-terminate the list of files to copy. */
+ struct armem *last = to_copy;
+ to_copy = to_copy->next;
+ last->next = NULL;
+
+ off_t start = -1;
+ off_t len = -1;
+
+ do
+ if (write_member (to_copy, &start, &len, elf, cur_off, newfd) != 0)
+ goto nonew_unlink;
+ while ((to_copy = to_copy->next) != NULL);
+
+ /* Write the last part. */
+ if (copy_content (elf, newfd, start, len))
+ goto nonew_unlink;
+ }
+
+ /* Set the mode of the new file to the same values the original file
+ has. */
+ if (fchmod (newfd, st.st_mode & ALLPERMS) != 0
+ /* Never complain about fchown failing. */
+ || (fchown (newfd, st.st_uid, st.st_gid),
+ close (newfd) != 0)
+ || (newfd = -1, rename (tmpfname, arfname) != 0))
+ goto nonew_unlink;
+
+ errout:
+#ifdef DEBUG
+ elf_end (elf);
+
+ arlib_fini (&symtab);
+
+ close (fd);
+#endif
+
+ not_found (argc, argv, found);
+
+ return status;
+}
+
+
+static void
+no0print (bool ofmt, char *buf, int bufsize, long int val)
+{
+ char tmpbuf[bufsize + 1];
+ snprintf (tmpbuf, sizeof (tmpbuf), ofmt ? "%-*lo" : "%-*ld", bufsize, val);
+ memcpy (buf, tmpbuf, bufsize);
+}
+
+
+static int
+do_oper_insert (int oper, const char *arfname, char **argv, int argc,
+ const char *member)
+{
+ int status = 0;
+ Elf *elf;
+ struct stat st;
+ int fd = open_archive (arfname, O_RDONLY, 0, &elf, &st, oper != oper_move);
+
+ /* List of the files we keep. */
+ struct armem *all = NULL;
+ struct armem *after_memberelem = NULL;
+ struct armem **found = alloca (sizeof (*found) * argc);
+ memset (found, '\0', sizeof (*found) * argc);
+
+ struct arlib_symtab symtab;
+ arlib_init (&symtab);
+
+ if (fd == -1)
+ {
+ if (!suppress_create_msg)
+ fprintf (stderr, "%s: creating %s\n", AR, arfname);
+
+ goto no_old;
+ }
+
+ /* Store the names of all files from the command line in a hash
+ table so that we can match it. Note that when no file name is
+ given we are basically doing nothing except recreating the
+ index. */
+ if (oper != oper_qappend)
+ {
+ if (hcreate (2 * argc) == 0)
+ error (EXIT_FAILURE, errno, gettext ("cannot create hash table"));
+
+ for (int cnt = 0; cnt < argc; ++cnt)
+ {
+ ENTRY entry;
+ entry.key = full_path ? argv[cnt] : basename (argv[cnt]);
+ entry.data = &argv[cnt];
+ if (hsearch (entry, ENTER) == NULL)
+ error (EXIT_FAILURE, errno,
+ gettext ("cannot insert into hash table"));
+ }
+ }
+
+ /* While iterating over the current content of the archive we must
+ determine a number of things: which archive members to keep,
+ which are replaced, and where to insert the new members. */
+ off_t cur_off = SARMAG;
+ Elf_Cmd cmd = ELF_C_READ_MMAP;
+ Elf *subelf;
+ while ((subelf = elf_begin (fd, cmd, elf)) != NULL)
+ {
+ Elf_Arhdr *arhdr = elf_getarhdr (subelf);
+
+ /* Ignore the symbol table and the long file name table here. */
+ if (strcmp (arhdr->ar_name, "/") == 0
+ || strcmp (arhdr->ar_name, "//") == 0)
+ goto next;
+
+ struct armem *newp = alloca (sizeof (struct armem));
+ newp->old_off = elf_getaroff (subelf);
+ newp->size = arhdr->ar_size;
+ newp->sec = arhdr->ar_date;
+ newp->mem = NULL;
+
+ /* Remember long file names. */
+ size_t ar_namelen = strlen (arhdr->ar_name);
+ if (ar_namelen > MAX_AR_NAME_LEN)
+ newp->long_name_off = arlib_add_long_name (&symtab, arhdr->ar_name,
+ ar_namelen);
+ else
+ newp->long_name_off = -1l;
+
+ /* Check whether this is a file we are looking for. */
+ if (oper != oper_qappend)
+ {
+ /* Check whether this is the member used as the insert point. */
+ if (member != NULL && strcmp (arhdr->ar_name, member) == 0)
+ {
+ /* Note that all == NULL means insert at the beginning. */
+ if (ipos == ipos_before)
+ after_memberelem = all;
+ else
+ after_memberelem = newp;
+ member = NULL;
+ }
+
+ ENTRY entry;
+ entry.key = arhdr->ar_name;
+ ENTRY *res = hsearch (entry, FIND);
+ if (res != NULL && found[(char **) res->data - argv] == NULL)
+ {
+ found[(char **) res->data - argv] = newp;
+
+ /* If we insert before or after a certain element move
+ all files to a special list. */
+ if (unlikely (ipos != ipos_none || oper == oper_move))
+ {
+ if (after_memberelem == newp)
+ /* Since we remove this element even though we should
+ insert everything after it, we in fact insert
+ everything after the previous element. */
+ after_memberelem = all;
+
+ goto next;
+ }
+ }
+ }
+
+ if (all == NULL)
+ all = newp->next = newp;
+ else
+ {
+ newp->next = all->next;
+ all = all->next = newp;
+ }
+
+ next:
+ cmd = elf_next (subelf);
+ if (elf_end (subelf) != 0)
+ error (EXIT_FAILURE, 0, "%s: %s", arfname, elf_errmsg (-1));
+ }
+
+ if (oper != oper_qappend)
+ hdestroy ();
+
+ no_old:
+ if (member != NULL)
+ error (EXIT_FAILURE, 0, gettext ("position member %s not found"),
+ member);
+
+ if (oper == oper_move)
+ {
+ /* Make sure all requested elements are found in the archive. */
+ for (int cnt = 0; cnt < argc; ++cnt)
+ {
+ if (found[cnt] == NULL)
+ {
+ fprintf (stderr, gettext ("%s: no entry %s in archive!\n"),
+ AR, argv[cnt]);
+ status = 1;
+ }
+
+ if (verbose)
+ printf ("m - %s\n", argv[cnt]);
+ }
+ }
+ else
+ {
+ /* Open all the new files, get their sizes and add all symbols. */
+ for (int cnt = 0; cnt < argc; ++cnt)
+ {
+ const char *bname = basename (argv[cnt]);
+ if (found[cnt] == NULL)
+ {
+ found[cnt] = alloca (sizeof (struct armem));
+ found[cnt]->old_off = -1;
+
+ size_t ar_namelen = strlen (argv[cnt]);
+ if (ar_namelen > MAX_AR_NAME_LEN)
+ found[cnt]->long_name_off = arlib_add_long_name (&symtab,
+ bname,
+ ar_namelen);
+ else
+ found[cnt]->long_name_off = -1l;
+ }
+
+ struct stat newst;
+ Elf *newelf;
+ int newfd = open (argv[cnt], O_RDONLY);
+ if (newfd == -1)
+ {
+ error (0, errno, gettext ("cannot open %s"), argv[cnt]);
+ status = 1;
+ }
+ else if (fstat (newfd, &newst) == -1)
+ {
+ error (0, errno, gettext ("cannot stat %s"), argv[cnt]);
+ close (newfd);
+ status = 1;
+ }
+ else if (!S_ISREG (newst.st_mode))
+ {
+ error (0, errno, gettext ("%s is no regular file"), argv[cnt]);
+ close (newfd);
+ status = 1;
+ }
+ else if (update_newer
+ && found[cnt]->old_off != -1l
+ && found[cnt]->sec > st.st_mtime)
+ /* Do nothing, the file in the archive is younger. */
+ close (newfd);
+ else if ((newelf = elf_begin (newfd, ELF_C_READ_MMAP, NULL))
+ == NULL)
+ {
+ fprintf (stderr,
+ gettext ("cannot get ELF descriptor for %s: %s\n"),
+ argv[cnt], elf_errmsg (-1));
+ status = 1;
+ }
+ else
+ {
+ if (verbose)
+ printf ("%c - %s\n",
+ found[cnt]->old_off == -1l ? 'a' : 'r', argv[cnt]);
+
+#ifdef DEBUG
+ found[cnt]->elf = newelf;
+#endif
+ found[cnt]->sec = newst.st_mtime;
+ found[cnt]->uid = newst.st_uid;
+ found[cnt]->gid = newst.st_gid;
+ found[cnt]->mode = newst.st_mode;
+ found[cnt]->name = basename (argv[cnt]);
+
+ found[cnt]->mem = elf_rawfile (newelf, &found[cnt]->size);
+ if (found[cnt] == NULL || elf_cntl (newelf, ELF_C_FDDONE) != 0)
+ error (EXIT_FAILURE, 0, gettext ("cannot read %s: %s"),
+ argv[cnt], elf_errmsg (-1));
+
+ close (newfd);
+
+ /* Remember long file names. */
+ size_t bnamelen = strlen (bname);
+ if (bnamelen > MAX_AR_NAME_LEN)
+ found[cnt]->long_name_off = arlib_add_long_name (&symtab,
+ bname,
+ bnamelen);
+ else
+ found[cnt]->long_name_off = -1l;
+ }
+ }
+ }
+
+ if (status != 0)
+ {
+#ifdef DEBUG
+ elf_end (elf);
+
+ arlib_fini (&symtab);
+
+ close (fd);
+#endif
+
+ return status;
+ }
+
+ /* If we have no entry point so far add at the end. AFTER_MEMBERELEM
+ being NULL when adding before an entry means add at the beginning. */
+ if (ipos != ipos_before && after_memberelem == NULL)
+ after_memberelem = all;
+
+ /* Convert the circular list into a normal list first. */
+ if (all != NULL)
+ {
+ struct armem *tmp = all;
+ all = all->next;
+ tmp->next = NULL;
+ }
+
+ struct armem *last_added = after_memberelem;
+ for (int cnt = 0; cnt < argc; ++cnt)
+ if (oper != oper_replace || found[cnt]->old_off == -1)
+ {
+ if (last_added == NULL)
+ {
+ found[cnt]->next = all;
+ last_added = all = found[cnt];
+ }
+ else
+ {
+ found[cnt]->next = last_added->next;
+ last_added = last_added->next = found[cnt];
+ }
+ }
+
+ /* Finally compute the offset and add the symbols for the files
+ after the insert point. */
+ if (likely (all != NULL))
+ for (struct armem *memp = all; memp != NULL; memp = memp->next)
+ {
+ memp->off = cur_off;
+
+ if (memp->mem == NULL)
+ {
+ Elf_Arhdr *arhdr;
+ /* Fake initializing arhdr and subelf to keep gcc calm. */
+ asm ("" : "=m" (arhdr), "=m" (subelf));
+ if (elf_rand (elf, memp->old_off) == 0
+ || (subelf = elf_begin (fd, ELF_C_READ_MMAP, elf)) == NULL
+ || (arhdr = elf_getarhdr (subelf)) == NULL)
+ /* This should never happen since we already looked at the
+ archive content. But who knows... */
+ error (EXIT_FAILURE, 0, "%s: %s", arfname, elf_errmsg (-1));
+
+ arlib_add_symbols (subelf, arfname, arhdr->ar_name, &symtab,
+ cur_off);
+
+ elf_end (subelf);
+ }
+ else
+ {
+ arlib_add_symbols (memp->elf, arfname, memp->name, &symtab,
+ cur_off);
+ }
+
+ cur_off += (((memp->size + 1) & ~((off_t) 1))
+ + sizeof (struct ar_hdr));
+ }
+
+ /* Now we have all the information for the symbol table and long
+ file name table. Construct the final layout. */
+ arlib_finalize (&symtab);
+
+ /* Create a new, temporary file in the same directory as the
+ original file. */
+ char tmpfname[strlen (arfname) + 7];
+ strcpy (stpcpy (tmpfname, arfname), "XXXXXX");
+ int newfd;
+ if (fd != -1)
+ newfd = mkstemp (tmpfname);
+ else
+ {
+ newfd = open (arfname, O_RDWR | O_CREAT | O_EXCL, DEFFILEMODE);
+ if (newfd == -1 && errno == EEXIST)
+ /* Bah, first the file did not exist, now it does. Restart. */
+ return do_oper_insert (oper, arfname, argv, argc, member);
+ }
+ if (unlikely (newfd == -1))
+ goto nonew;
+
+ /* Create the header. */
+ if (unlikely (write_retry (newfd, ARMAG, SARMAG) != SARMAG))
+ {
+ nonew_unlink:
+ if (fd != -1)
+ {
+ // XXX Use /prof/self/fd/%d ???
+ unlink (tmpfname);
+ if (newfd != -1)
+ close (newfd);
+ }
+ nonew:
+ error (0, errno, gettext ("cannot create new file"));
+ status = 1;
+ goto errout;
+ }
+
+ /* If the new archive is not empty we actually have something to do. */
+ if (likely (all != NULL))
+ {
+ /* Write the symbol table or the long file name table or both. */
+ if (symtab.symsnamelen != 0
+ && ((write_retry (newfd, symtab.symsoff, symtab.symsofflen)
+ != (ssize_t) symtab.symsofflen)
+ || (write_retry (newfd, symtab.symsname, symtab.symsnamelen)
+ != (ssize_t) symtab.symsnamelen)))
+ goto nonew_unlink;
+
+ if (symtab.longnameslen > sizeof (struct ar_hdr)
+ && (write_retry (newfd, symtab.longnames, symtab.longnameslen)
+ != (ssize_t) symtab.longnameslen))
+ goto nonew_unlink;
+
+ off_t start = -1;
+ off_t len = -1;
+
+ while (all != NULL)
+ {
+ if (all->mem != NULL)
+ {
+ /* This is a new file. If there is anything from the
+ archive left to be written do it now. */
+ if (start != -1 && copy_content (elf, newfd, start, len))
+ goto nonew_unlink;
+
+ start = -1;
+ len = -1;
+
+ /* Create the header. */
+ struct ar_hdr arhdr;
+ char tmpbuf[sizeof (arhdr.ar_name) + 1];
+ if (all->long_name_off == -1)
+ {
+ size_t namelen = strlen (all->name);
+ memset (mempcpy (arhdr.ar_name, all->name, namelen),
+ ' ', sizeof (arhdr.ar_name) - namelen);
+ }
+ else
+ {
+ snprintf (tmpbuf, sizeof (arhdr.ar_name) + 1, "/%-*ld",
+ (int) sizeof (arhdr.ar_name), all->long_name_off);
+ memcpy (arhdr.ar_name, tmpbuf, sizeof (arhdr.ar_name));
+ }
+
+ no0print (false, arhdr.ar_date, sizeof (arhdr.ar_date),
+ all->sec);
+ no0print (false, arhdr.ar_uid, sizeof (arhdr.ar_uid), all->uid);
+ no0print (false, arhdr.ar_gid, sizeof (arhdr.ar_gid), all->gid);
+ no0print (true, arhdr.ar_mode, sizeof (arhdr.ar_mode),
+ all->mode);
+ no0print (false, arhdr.ar_size, sizeof (arhdr.ar_size),
+ all->size);
+ memcpy (arhdr.ar_fmag, ARFMAG, sizeof (arhdr.ar_fmag));
+
+ if (unlikely (write_retry (newfd, &arhdr, sizeof (arhdr))
+ != sizeof (arhdr)))
+ goto nonew_unlink;
+
+ /* Now the file itself. */
+ if (unlikely (write_retry (newfd, all->mem, all->size)
+ != (off_t) all->size))
+ goto nonew_unlink;
+
+ /* Pad the file if its size is odd. */
+ if ((all->size & 1) != 0)
+ write (newfd, "\n", 1);
+ }
+ else
+ {
+ /* This is a member from the archive. */
+ if (write_member (all, &start, &len, elf, cur_off, newfd)
+ != 0)
+ goto nonew_unlink;
+ }
+
+ all = all->next;
+ }
+
+ /* Write the last part. */
+ if (start != -1 && copy_content (elf, newfd, start, len))
+ goto nonew_unlink;
+ }
+
+ /* Set the mode of the new file to the same values the original file
+ has. */
+ if (fd != -1
+ && (fchmod (newfd, st.st_mode & ALLPERMS) != 0
+ /* Never complain about fchown failing. */
+ || (fchown (newfd, st.st_uid, st.st_gid),
+ close (newfd) != 0)
+ || (newfd = -1, rename (tmpfname, arfname) != 0)))
+ goto nonew_unlink;
+
+ errout:
+#ifdef DEBUG
+ elf_end (elf);
+
+ arlib_fini (&symtab);
+
+ close (fd);
+#endif
+
+ return status;
+}
--- /dev/null
+/* Functions to handle creation of Linux archives.
+ Copyright (C) 2007 Red Hat, Inc.
+ Written by Ulrich Drepper <drepper@redhat.com>, 2007.
+
+ Red Hat elfutils is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by the
+ Free Software Foundation; version 2 of the License.
+
+ Red Hat elfutils is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with Red Hat elfutils; if not, write to the Free Software Foundation,
+ Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA.
+
+ Red Hat elfutils is an included package of the Open Invention Network.
+ An included package of the Open Invention Network is a package for which
+ Open Invention Network licensees cross-license their patents. No patent
+ license is granted, either expressly or impliedly, by designation as an
+ included package. Should you wish to participate in the Open Invention
+ Network licensing program, please visit www.openinventionnetwork.com
+ <http://www.openinventionnetwork.com>. */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <assert.h>
+#include <error.h>
+#include <gelf.h>
+#include <libintl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+#include <system.h>
+
+#include "arlib.h"
+
+
+/* Initialize ARLIB_SYMTAB structure. */
+void
+arlib_init (struct arlib_symtab *symtab)
+{
+#define obstack_chunk_alloc xmalloc
+#define obstack_chunk_free free
+ obstack_init (&symtab->symsoffob);
+ obstack_init (&symtab->symsnameob);
+ obstack_init (&symtab->longnamesob);
+
+ /* We add the archive header here as well, that avoids allocating
+ another memory block. */
+ struct ar_hdr ar_hdr;
+ memcpy (ar_hdr.ar_name, "/ ", sizeof (ar_hdr.ar_name));
+ /* Using snprintf here has a problem: the call always wants to add a
+ NUL byte. We could use a trick whereby we specify the target
+ buffer size longer than it is and this would not actually fail,
+ since all the fields are consecutive and we fill them in in
+ sequence (i.e., the NUL byte gets overwritten). But
+ _FORTIFY_SOURCE=2 would not let us play these games. Therefore
+ we play it safe. */
+ char tmpbuf[sizeof (ar_hdr.ar_date) + 1];
+ memcpy (ar_hdr.ar_date, tmpbuf,
+ snprintf (tmpbuf, sizeof (tmpbuf), "%-*lld",
+ (int) sizeof (ar_hdr.ar_date),
+ (long long int) time (NULL)));
+ assert ((sizeof (struct ar_hdr) % sizeof (uint32_t)) == 0);
+
+ /* Note the string for the ar_uid and ar_gid cases is longer than
+ necessary. This does not matter since we copy only as much as
+ necessary but it helps the compiler to use the same string for
+ the ar_mode case. */
+ memcpy (ar_hdr.ar_uid, "0 ", sizeof (ar_hdr.ar_uid));
+ memcpy (ar_hdr.ar_gid, "0 ", sizeof (ar_hdr.ar_gid));
+ memcpy (ar_hdr.ar_mode, "0 ", sizeof (ar_hdr.ar_mode));
+ memcpy (ar_hdr.ar_fmag, ARFMAG, sizeof (ar_hdr.ar_fmag));
+
+ /* Add the archive header to the file content. */
+ obstack_grow (&symtab->symsoffob, &ar_hdr, sizeof (ar_hdr));
+
+ /* The first word in the offset table specifies the size. Create
+ such an entry now. The real value will be filled-in later. For
+ all supported platforms the following is true. */
+ assert (sizeof (uint32_t) == sizeof (int));
+ obstack_int_grow (&symtab->symsoffob, 0);
+
+ /* The long name obstack also gets its archive header. As above,
+ some of the input strings are longer than required but we only
+ copy the necessary part. */
+ memcpy (ar_hdr.ar_name, "// ", sizeof (ar_hdr.ar_name));
+ memcpy (ar_hdr.ar_date, " ", sizeof (ar_hdr.ar_date));
+ memcpy (ar_hdr.ar_uid, " ", sizeof (ar_hdr.ar_uid));
+ memcpy (ar_hdr.ar_gid, " ", sizeof (ar_hdr.ar_gid));
+ memcpy (ar_hdr.ar_mode, " ", sizeof (ar_hdr.ar_mode));
+ /* The ar_size field will be filled in later and ar_fmag is already OK. */
+ obstack_grow (&symtab->longnamesob, &ar_hdr, sizeof (ar_hdr));
+
+ /* All other members are zero. */
+ symtab->symsofflen = 0;
+ symtab->symsoff = NULL;
+ symtab->symsnamelen = 0;
+ symtab->symsname = NULL;
+}
+
+
+/* Finalize ARLIB_SYMTAB content. */
+void
+arlib_finalize (struct arlib_symtab *symtab)
+{
+ char tmpbuf[sizeof (((struct ar_hdr *) NULL)->ar_size) + 1];
+
+ symtab->longnameslen = obstack_object_size (&symtab->longnamesob);
+ if (symtab->longnameslen != sizeof (struct ar_hdr))
+ {
+ symtab->longnames = obstack_finish (&symtab->longnamesob);
+
+ memcpy (&((struct ar_hdr *) symtab->longnames)->ar_size, tmpbuf,
+ snprintf (tmpbuf, sizeof (tmpbuf), "%-*zu",
+ (int) sizeof (((struct ar_hdr *) NULL)->ar_size),
+ symtab->longnameslen - sizeof (struct ar_hdr)));
+ }
+
+ symtab->symsofflen = obstack_object_size (&symtab->symsoffob);
+ assert (symtab->symsofflen % sizeof (uint32_t) == 0);
+ if (symtab->symsofflen != 0)
+ {
+ symtab->symsoff = (uint32_t *) obstack_finish (&symtab->symsoffob);
+
+ /* Fill in the number of offsets now. */
+ symtab->symsoff[AR_HDR_WORDS] = le_bswap_32 ((symtab->symsofflen
+ - sizeof (struct ar_hdr))
+ / sizeof (uint32_t) - 1);
+ }
+
+ symtab->symsnamelen = obstack_object_size (&symtab->symsnameob);
+ if ((symtab->symsnamelen & 1) != 0)
+ {
+ /* Add one more NUL byte to make length even. */
+ obstack_grow (&symtab->symsnameob, "", 1);
+ ++symtab->symsnamelen;
+ }
+ symtab->symsname = obstack_finish (&symtab->symsnameob);
+
+ /* Determine correction for the offsets in the symbol table. */
+ off_t disp = 0;
+ if (symtab->symsnamelen > 0)
+ disp = symtab->symsofflen + symtab->symsnamelen;
+ if (symtab->longnameslen > sizeof (struct ar_hdr))
+ disp += symtab->longnameslen;
+
+ if (disp != 0 && symtab->symsoff != NULL)
+ {
+ uint32_t nsyms = le_bswap_32 (symtab->symsoff[AR_HDR_WORDS]);
+
+ for (uint32_t cnt = 1; cnt <= nsyms; ++cnt)
+ {
+ uint32_t val = le_bswap_32 (symtab->symsoff[AR_HDR_WORDS + cnt]);
+ val += disp;
+ symtab->symsoff[AR_HDR_WORDS + cnt] = le_bswap_32 (val);
+ }
+ }
+
+ /* See comment for ar_date above. */
+ memcpy (&((struct ar_hdr *) symtab->symsoff)->ar_size, tmpbuf,
+ snprintf (tmpbuf, sizeof (tmpbuf), "%-*zu",
+ (int) sizeof (((struct ar_hdr *) NULL)->ar_size),
+ symtab->symsofflen + symtab->symsnamelen
+ - sizeof (struct ar_hdr)));
+}
+
+
+/* Free resources for ARLIB_SYMTAB. */
+void
+arlib_fini (struct arlib_symtab *symtab)
+{
+ obstack_free (&symtab->symsoffob, NULL);
+ obstack_free (&symtab->symsnameob, NULL);
+ obstack_free (&symtab->longnamesob, NULL);
+}
+
+
+/* Add name a file offset of a symbol. */
+void
+arlib_add_symref (struct arlib_symtab *symtab, const char *symname,
+ off_t symoff)
+{
+ /* For all supported platforms the following is true. */
+ assert (sizeof (uint32_t) == sizeof (int));
+ obstack_int_grow (&symtab->symsoffob, (int) le_bswap_32 (symoff));
+
+ size_t symname_len = strlen (symname) + 1;
+ obstack_grow (&symtab->symsnameob, symname, symname_len);
+}
+
+
+/* Add symbols from ELF with value OFFSET to the symbol table SYMTAB. */
+void
+arlib_add_symbols (Elf *elf, const char *arfname, const char *membername,
+ struct arlib_symtab *symtab, off_t off)
+{
+ if (sizeof (off) > sizeof (uint32_t) && off > ~((uint32_t) 0))
+ /* The archive is too big. */
+ error (EXIT_FAILURE, 0, gettext ("the archive '%s' is too large"),
+ arfname);
+
+ /* We only add symbol tables for ELF files. It makes not much sense
+ to add symbols from executables but we do so for compatibility.
+ For DSOs and executables we use the dynamic symbol table, for
+ relocatable files all the DT_SYMTAB tables. */
+ if (elf_kind (elf) != ELF_K_ELF)
+ return;
+
+ GElf_Ehdr ehdr_mem;
+ GElf_Ehdr *ehdr = gelf_getehdr (elf, &ehdr_mem);
+ if (ehdr == NULL)
+ error (EXIT_FAILURE, 0, gettext ("cannot read ELF header of %s(%s): %s"),
+ arfname, membername, elf_errmsg (-1));
+
+ GElf_Word symtype;
+ if (ehdr->e_type == ET_REL)
+ symtype = SHT_SYMTAB;
+ else if (ehdr->e_type == ET_EXEC || ehdr->e_type == ET_DYN)
+ symtype = SHT_DYNSYM;
+ else
+ /* We do not handle that type. */
+ return;
+
+ /* Iterate over all sections. */
+ Elf_Scn *scn = NULL;
+ while ((scn = elf_nextscn (elf, scn)) != NULL)
+ {
+ /* Get the section header. */
+ GElf_Shdr shdr_mem;
+ GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
+ if (shdr == NULL)
+ continue;
+
+ if (shdr->sh_type != symtype)
+ continue;
+
+ Elf_Data *data = elf_getdata (scn, NULL);
+ if (data == NULL)
+ continue;
+
+ int nsyms = shdr->sh_size / shdr->sh_entsize;
+ for (int ndx = shdr->sh_info; ndx < nsyms; ++ndx)
+ {
+ GElf_Sym sym_mem;
+ GElf_Sym *sym = gelf_getsym (data, ndx, &sym_mem);
+ if (sym == NULL)
+ continue;
+
+ /* Ignore undefined symbols. */
+ if (sym->st_shndx == SHN_UNDEF)
+ continue;
+
+ /* Use this symbol. */
+ const char *symname = elf_strptr (elf, shdr->sh_link, sym->st_name);
+ if (symname != NULL)
+ arlib_add_symref (symtab, symname, off);
+ }
+
+ /* Only relocatable files can have more than one symbol table. */
+ if (ehdr->e_type != ET_REL)
+ break;
+ }
+}
#include <ar.h>
#include <argp.h>
#include <assert.h>
-#include <byteswap.h>
-#include <endian.h>
#include <errno.h>
#include <error.h>
#include <fcntl.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdio_ext.h>
-#include <time.h>
#include <unistd.h>
+#include <sys/mman.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <system.h>
-
-#if __BYTE_ORDER == __LITTLE_ENDIAN
-# define le_bswap_32(val) bswap_32 (val)
-#else
-# define le_bswap_32(val) (val)
-#endif
+#include "arlib.h"
/* Prototypes for local functions. */
/* Strings for arguments in help texts. */
static const char args_doc[] = N_("ARCHIVE");
-/* Prototype for option handler. */
-static error_t parse_opt (int key, char *arg, struct argp_state *state);
-
/* Data structure to communicate with argp functions. */
-static struct argp argp =
+static const struct argp argp =
{
- options, parse_opt, args_doc, doc, NULL, NULL, NULL
+ options, NULL, args_doc, doc, NULL, NULL, NULL
};
}
-/* Handle program arguments. */
-static error_t
-parse_opt (int key, char *arg __attribute__ ((unused)),
- struct argp_state *state __attribute__ ((unused)))
-{
- switch (key)
- {
- default:
- return ARGP_ERR_UNKNOWN;
- }
- return 0;
-}
-
-
-static struct obstack offsob;
-size_t offs_len;
-static struct obstack namesob;
-size_t names_len;
-
-
-/* Add all exported, defined symbols from the given section to the table. */
-static void
-add_symbols (Elf *elf, const char *fname, off_t off, Elf_Scn *scn,
- GElf_Shdr *shdr)
-{
- if (sizeof (off) > sizeof (uint32_t) && off > ~((uint32_t) 0))
- /* The archive is too big. */
- error (EXIT_FAILURE, 0, gettext ("the archive '%s' is too large"), fname);
-
- Elf_Data *data = elf_getdata (scn, NULL);
- assert (data->d_size == shdr->sh_size);
-
- /* We can skip the local symbols in the table. */
- for (int cnt = shdr->sh_info; cnt < (int) (shdr->sh_size / shdr->sh_entsize);
- ++cnt)
- {
- GElf_Sym sym_mem;
- GElf_Sym *sym = gelf_getsym (data, cnt, &sym_mem);
- if (sym == NULL)
- /* Should never happen. */
- continue;
-
- /* Ignore undefined symbols. */
- if (sym->st_shndx == SHN_UNDEF)
- continue;
-
- /* For all supported platforms the following is true. */
- assert (sizeof (uint32_t) == sizeof (int));
- obstack_int_grow (&offsob, (int) le_bswap_32 (off));
- offs_len += sizeof (uint32_t);
-
- const char *symname = elf_strptr (elf, shdr->sh_link, sym->st_name);
- size_t symname_len = strlen (symname) + 1;
- obstack_grow (&namesob, symname, symname_len);
- names_len += symname_len;
- }
-}
-
-
-/* Look through ELF file and collect all symbols available for
- linking. If available, we use the dynamic symbol section.
- Otherwise the normal one. Relocatable files are allowed to have
- multiple symbol tables. */
-static void
-handle_elf (Elf *elf, const char *arfname, off_t off)
-{
- GElf_Ehdr ehdr_mem;
- GElf_Ehdr *ehdr = gelf_getehdr (elf, &ehdr_mem);
- assert (ehdr != NULL);
-
- if (ehdr->e_type == ET_REL)
- {
- Elf_Scn *scn = NULL;
- while ((scn = elf_nextscn (elf, scn)) != NULL)
- {
- GElf_Shdr shdr_mem;
- GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
- if (shdr != NULL && shdr->sh_type == SHT_SYMTAB)
- add_symbols (elf, arfname, off, scn, shdr);
- }
- }
- else
- {
- Elf_Scn *symscn = NULL;
- GElf_Shdr *symshdr = NULL;
- Elf_Scn *scn = NULL;
- GElf_Shdr shdr_mem;
- while ((scn = elf_nextscn (elf, scn)) != NULL)
- {
- GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
- symshdr = NULL;
- if (shdr != NULL)
- {
- if (shdr->sh_type == SHT_DYNSYM)
- {
- symscn = scn;
- symshdr = shdr;
- break;
- }
- if (shdr->sh_type == SHT_SYMTAB)
- {
- /* There better be only one symbol table in
- executables in DSOs. */
- assert (symscn == NULL);
- symscn = scn;
- symshdr = shdr;
- }
- }
- }
-
- add_symbols (elf, arfname, off, symscn,
- symshdr ?: gelf_getshdr (scn, &shdr_mem));
- }
-}
-
-
static int
-copy_content (int oldfd, int newfd, off_t off, size_t n)
+copy_content (Elf *elf, int newfd, off_t off, size_t n)
{
- while (n > 0)
- {
- char buf[32768];
+ size_t len;
+ char *rawfile = elf_rawfile (elf, &len);
- ssize_t nread = pread_retry (oldfd, buf, MIN (sizeof (buf), n), off);
- if (unlikely (nread <= 0))
- return 1;
+ assert (off + n <= len);
- if (write_retry (newfd, buf, nread) != nread)
- return 1;
-
- n -= nread;
- off += nread;
- }
+ /* Tell the kernel we will read all the pages sequentially. */
+ size_t ps = sysconf (_SC_PAGESIZE);
+ if (n > 2 * ps)
+ posix_madvise (rawfile + (off & ~(ps - 1)), n, POSIX_MADV_SEQUENTIAL);
- return 0;
+ return write_retry (newfd, rawfile + off, n) != (ssize_t) n;
}
return 1;
}
-#define obstack_chunk_alloc xmalloc
-#define obstack_chunk_free free
- obstack_init (&offsob);
- offs_len = 0;
- obstack_init (&namesob);
- names_len = 0;
-
- /* The first word in the offset table specifies the size. Create
- such an entry now. The real value will be filled-in later. For
- all supported platforms the following is true. */
- assert (sizeof (uint32_t) == sizeof (int));
- obstack_int_grow (&offsob, 0);
- offs_len += sizeof (uint32_t);
+ struct arlib_symtab symtab;
+ arlib_init (&symtab);
/* Iterate over the content of the archive. */
off_t index_off = -1;
size_t index_size = 0;
+ off_t cur_off = SARMAG;
Elf *elf;
Elf_Cmd cmd = ELF_C_READ_MMAP;
while ((elf = elf_begin (fd, cmd, arelf)) != NULL)
{
Elf_Arhdr *arhdr = elf_getarhdr (elf);
assert (arhdr != NULL);
- off_t off = elf_getaroff (elf);
- Elf_Kind kind = elf_kind (elf);
- if (kind == ELF_K_ELF)
- handle_elf (elf, fname, off);
-#if 0
- else if (kind == ELF_K_AR)
- {
- // XXX Should we implement this?
- }
-#endif
/* If this is the index, remember the location. */
- else if (strcmp (arhdr->ar_name, "/") == 0)
+ if (strcmp (arhdr->ar_name, "/") == 0)
{
- index_off = off;
+ index_off = elf_getaroff (elf);
index_size = arhdr->ar_size;
}
+ else
+ {
+ arlib_add_symbols (elf, fname, arhdr->ar_name, &symtab, cur_off);
+ cur_off += (((arhdr->ar_size + 1) & ~((off_t) 1))
+ + sizeof (struct ar_hdr));
+ }
/* Get next archive element. */
cmd = elf_next (elf);
if (elf_end (elf) != 0)
- error (0, 0,
- gettext (" error while freeing sub-ELF descriptor: %s\n"),
+ error (0, 0, gettext ("error while freeing sub-ELF descriptor: %s"),
elf_errmsg (-1));
}
- elf_end (arelf);
- uint32_t *offs_arr = obstack_finish (&offsob);
- assert (offs_len % sizeof (uint32_t) == 0);
- if ((names_len & 1) != 0)
- {
- /* Add one more NUL byte to make length even. */
- obstack_grow (&namesob, "", 1);
- ++names_len;
- }
- const char *names_str = obstack_finish (&namesob);
+ arlib_finalize (&symtab);
/* If the file contains no symbols we need not do anything. */
- if (names_len != 0
+ int status = 0;
+ if (symtab.symsnamelen != 0
/* We have to rewrite the file also if it initially had an index
but now does not need one anymore. */
- || (names_len == 0 && index_off != -1))
+ || (symtab.symsnamelen == 0 && index_size != 0))
{
/* Create a new, temporary file in the same directory as the
original file. */
- char tmpfname[strlen (fname) + 8];
- strcpy (stpcpy (tmpfname, fname), ".XXXXXX");
+ char tmpfname[strlen (fname) + 7];
+ strcpy (stpcpy (tmpfname, fname), "XXXXXX");
int newfd = mkstemp (tmpfname);
- if (newfd == -1)
- nonew:
- error (0, errno, gettext ("cannot create new file"));
+ if (unlikely (newfd == -1))
+ {
+ nonew:
+ error (0, errno, gettext ("cannot create new file"));
+ status = 1;
+ }
else
{
/* Create the header. */
- if (write_retry (newfd, ARMAG, SARMAG) != SARMAG)
+ if (unlikely (write_retry (newfd, ARMAG, SARMAG) != SARMAG))
{
// XXX Use /prof/self/fd/%d ???
nonew_unlink:
goto nonew;
}
- struct ar_hdr ar_hdr;
- memcpy (ar_hdr.ar_name, "/ ", sizeof (ar_hdr.ar_name));
- /* Using snprintf here has a problem: the call always wants
- to add a NUL byte. We could use a trick whereby we
- specify the target buffer size longer than it is and this
- would not actually fail, since all the fields are
- consecutive and we fill them in in sequence (i.e., the
- NUL byte gets overwritten). But _FORTIFY_SOURCE=2 would
- not let us play these games. Therefore we play it
- safe. */
- char tmpbuf[MAX (sizeof (ar_hdr.ar_date), sizeof (ar_hdr.ar_size))
- + 1];
- memcpy (ar_hdr.ar_date, tmpbuf,
- snprintf (tmpbuf, sizeof (tmpbuf), "%-*lld",
- (int) sizeof (ar_hdr.ar_date),
- (long long int) time (NULL)));
-
- /* Note the string for the ar_uid and ar_gid cases is longer
- than necessary. This does not matter since we copy only as
- much as necessary but it helps the compiler to use the same
- string for the ar_mode case. */
- memcpy (ar_hdr.ar_uid, "0 ", sizeof (ar_hdr.ar_uid));
- memcpy (ar_hdr.ar_gid, "0 ", sizeof (ar_hdr.ar_gid));
- memcpy (ar_hdr.ar_mode, "0 ", sizeof (ar_hdr.ar_mode));
-
- /* See comment for ar_date above. */
- memcpy (ar_hdr.ar_size, tmpbuf,
- snprintf (tmpbuf, sizeof (tmpbuf), "%-*zu",
- (int) sizeof (ar_hdr.ar_size),
- offs_len + names_len));
- memcpy (ar_hdr.ar_fmag, ARFMAG, sizeof (ar_hdr.ar_fmag));
-
- /* Fill in the number of offsets now. */
- offs_arr[0] = le_bswap_32 (offs_len / sizeof (uint32_t) - 1);
-
- /* Adjust the offset values for the name index size (if
- necessary). */
- off_t disp = (offs_len + ((names_len + 1) & ~1ul)
- - ((index_size + 1) & ~1ul));
- /* If there was no index so far but one is needed now we
- have to take the archive header into account. */
- if (index_off == -1 && names_len != 0)
- disp += sizeof (struct ar_hdr);
- if (disp != 0)
- for (size_t cnt = 1; cnt < offs_len / sizeof (uint32_t); ++cnt)
- {
- uint32_t val;
- val = le_bswap_32 (offs_arr[cnt]);
-
- if (val > index_off)
- {
- val += disp;
- offs_arr[cnt] = le_bswap_32 (val);
- }
- }
-
/* Create the new file. There are three parts as far we are
concerned: 1. original context before the index, 2. the
new index, 3. everything after the new index. */
else
rest_off = SARMAG;
- if ((index_off > SARMAG
- && copy_content (fd, newfd, SARMAG, index_off - SARMAG))
- || (names_len != 0
- && ((write_retry (newfd, &ar_hdr, sizeof (ar_hdr))
- != sizeof (ar_hdr))
- || (write_retry (newfd, offs_arr, offs_len)
- != (ssize_t) offs_len)
- || (write_retry (newfd, names_str, names_len)
- != (ssize_t) names_len)))
- || copy_content (fd, newfd, rest_off, st.st_size - rest_off)
+ if ((symtab.symsnamelen != 0
+ && ((write_retry (newfd, symtab.symsoff,
+ symtab.symsofflen)
+ != (ssize_t) symtab.symsofflen)
+ || (write_retry (newfd, symtab.symsname,
+ symtab.symsnamelen)
+ != (ssize_t) symtab.symsnamelen)))
+ /* Even if the original file had content before the
+ symbol table, we write it in the correct order. */
+ || (index_off > SARMAG
+ && copy_content (arelf, newfd, SARMAG, index_off - SARMAG))
+ || copy_content (arelf, newfd, rest_off, st.st_size - rest_off)
/* Set the mode of the new file to the same values the
original file has. */
|| fchmod (newfd, st.st_mode & ALLPERMS) != 0
- || fchown (newfd, st.st_uid, st.st_gid) != 0
- || close (newfd) != 0
+ /* Never complain about fchown failing. */
+ || (fchown (newfd, st.st_uid, st.st_gid),
+ close (newfd) != 0)
|| (newfd = -1, rename (tmpfname, fname) != 0))
goto nonew_unlink;
}
}
- obstack_free (&offsob, NULL);
- obstack_free (&namesob, NULL);
+ elf_end (arelf);
+
+ arlib_fini (&symtab);
close (fd);
- return 0;
+ return status;
}