]> git.ipfire.org Git - thirdparty/elfutils.git/commitdiff
Implement ar program.
authorUlrich Drepper <drepper@redhat.com>
Mon, 5 Feb 2007 07:13:52 +0000 (07:13 +0000)
committerUlrich Drepper <drepper@redhat.com>
Mon, 5 Feb 2007 07:13:52 +0000 (07:13 +0000)
Relax elflint in GNU ld mode for latest idiosyncracies.

16 files changed:
NEWS
libelf/ChangeLog
libelf/Makefile.am
libelf/elf_begin.c
src/ChangeLog
src/Makefile.am
src/ar.c [new file with mode: 0644]
src/arlib.c [new file with mode: 0644]
src/arlib.h [new file with mode: 0644]
src/arlib2.c [new file with mode: 0644]
src/elflint.c
src/ranlib.c
tests/ChangeLog
tests/Makefile.am
tests/arls.c [new file with mode: 0644]
tests/run-ranlib-test2.sh

diff --git a/NEWS b/NEWS
index 095bebb3055cd01c530e90602612437a74cc88e9..b1e968567eda5d3053290492cc995d90c3b085dd 100644 (file)
--- a/NEWS
+++ b/NEWS
@@ -1,3 +1,7 @@
+Version 0.126:
+
+new program: ar
+
 Version 0.125:
 
 elflint: Compare DT_GNU_HASH tests.
index 8d1f289d1a9888ab7d88eda6f683d06211e38bf7..14001c7a13113b3fb9d8e8123a0acbfd9a19565a 100644 (file)
@@ -1,3 +1,9 @@
+2007-02-04  Ulrich Drepper  <drepper@redhat.com>
+
+       * Makefile (libelf.so): Build with -z relro.
+
+       * elf_begin.c (read_file): When using ELF_C_READ_MMAP use MAP_PRIVATE.
+
 2007-01-30  Ulrich Drepper  <drepper@redhat.com>
 
        * nlist.c: Close file descriptor before returning.
index f27d4f0bdcab56cf517971c544aaddd50aa93f86..b93f49c63d1231d36f729d2ae8d5c7b1803edc6b 100644 (file)
@@ -1,6 +1,6 @@
 ## Process this file with automake to create Makefile.in
 ##
-## Copyright (C) 1996-2001, 2002, 2003, 2004, 2005, 2006 Red Hat, Inc.
+## Copyright (C) 1996-2006, 2007 Red Hat, Inc.
 ## This file is part of Red Hat elfutils.
 ##
 ## Red Hat elfutils is free software; you can redistribute it and/or modify
@@ -107,7 +107,7 @@ libelf_so_SOURCES =
 libelf.so: libelf_pic.a libelf.map
        $(LINK) -shared -o $@ -Wl,--whole-archive,$<,--no-whole-archive \
                -Wl,--version-script,$(srcdir)/libelf.map,--no-undefined \
-               -Wl,--soname,$@.$(VERSION),-z,-defs
+               -Wl,--soname,$@.$(VERSION),-z,-defs,-z,relro
        if readelf -d $@ | fgrep -q TEXTREL; then exit 1; fi
        ln -fs $@ $@.$(VERSION)
 
index be52f464dceb7de94de34cd9df2e96a6ba83bc63..24bac42b28e334f4ed4fe0a28aadaa60616aace3 100644 (file)
@@ -1,5 +1,5 @@
 /* Create descriptor for processing file.
-   Copyright (C) 1998-2005, 2006 Red Hat, Inc.
+   Copyright (C) 1998-2005, 2006, 2007 Red Hat, Inc.
    This file is part of Red Hat elfutils.
    Written by Ulrich Drepper <drepper@redhat.com>, 1998.
 
@@ -561,6 +561,7 @@ read_file (int fildes, off_t offset, size_t maxsize,
                                              ? PROT_READ
                                              : PROT_READ|PROT_WRITE),
                              cmd == ELF_C_READ_MMAP_PRIVATE
+                             || cmd == ELF_C_READ_MMAP
                              ? MAP_PRIVATE : MAP_SHARED,
                              fildes, offset);
 
@@ -686,7 +687,7 @@ read_long_names (Elf *elf)
          /* NUL-terminate the string.  */
          *runp = '\0';
 
-         /* Skip the NUL bzte and the \012.  */
+         /* Skip the NUL byte and the \012.  */
          runp += 2;
 
          /* A sanity check.  Somebody might have generated invalid
index 8c1b14e7024f1189b89510b1de556997ce9da964..6e619e0db20492fb2466f8e28f9052b31c40014b 100644 (file)
@@ -1,3 +1,18 @@
+2007-02-04  Ulrich Drepper  <drepper@redhat.com>
+
+       * ar.c: New file.
+       * arlib.c: New file.
+       * arlib2.c: New file.
+       * arlib.h: New file.
+       * Makefile (noinst_LIBRARIES): Add libar.
+       (libar_a_SOURCES): Define.
+       (ar_LDADD): Define.
+       (CFLAGS_ar): Define.
+       * ranlib.c: Change to use arlib.
+
+       * elflint.c (check_symtab): Work around GNU ld bug which omits
+       sections but not symbols in those sections.
+
 2007-01-10  Ulrich Drepper  <drepper@redhat.com>
 
        * addr2line.c: Update copyright year.
index 7c9eb8427dafbf832c22ce8d78ce36bc0f1dca4e..230a81780ad749ce6d9b9918ae1416918fbfd875 100644 (file)
@@ -1,6 +1,6 @@
 ## Process this file with automake to create Makefile.in
 ##
-## Copyright (C) 1996-2002, 2003, 2004, 2005, 2006 Red Hat, Inc.
+## Copyright (C) 1996-2002, 2003, 2004, 2005, 2006, 2007 Red Hat, Inc.
 ## This file is part of Red Hat elfutils.
 ##
 ## Red Hat elfutils is free software; you can redistribute it and/or modify
@@ -34,7 +34,7 @@ endif
 AM_CFLAGS += -Wall -Wshadow -std=gnu99 $(native_ld_cflags) \
             $(if $($(*F)_no_Werror),,-Werror) \
             $(if $($(*F)_no_Wunused),,-Wunused -Wextra) \
-            $(if $($(*F)_no_Wformat),,-Wformat=2)
+            $(if $($(*F)_no_Wformat),,-Wformat=2) $(CFLAGS_$(*F))
 
 INCLUDES = -I$(srcdir) -I$(srcdir)/../libelf -I$(srcdir)/../libebl \
           -I$(srcdir)/../libdw -I$(srcdir)/../libdwfl \
@@ -52,15 +52,15 @@ native_ld = @native_ld@
 base_cpu = @base_cpu@
 
 bin_PROGRAMS = readelf nm size strip ld elflint findtextrel addr2line \
-              elfcmp objdump ranlib strings
+              elfcmp objdump ranlib strings ar
 
 
 ld_dsos = libld_elf_i386_pic.a
 if NATIVE_LD
-noinst_LIBRARIES = libld_elf.a
+noinst_LIBRARIES = libld_elf.a libar.a
 native_ld_cflags = -DBASE_ELF_NAME=elf_$(base_cpu)
 else
-noinst_LIBRARIES = libld_elf.a $(ld_dsos)
+noinst_LIBRARIES = libld_elf.a libar.a $(ld_dsos)
 noinst_PROGRAMS = $(ld_dsos:_pic.a=.so)
 endif
 if NEVER
@@ -76,10 +76,12 @@ textrel_check = if readelf -d $@ | fgrep -q TEXTREL; then exit 1; fi
 ld_SOURCES = ld.c ldgeneric.c ldlex.l ldscript.y symbolhash.c sectionhash.c \
             versionhash.c
 
+libar_a_SOURCES = arlib.c arlib2.c
+
 noinst_HEADERS = ld.h symbolhash.h sectionhash.h versionhash.h \
                 ldscript.h xelf.h unaligned.h
 
-EXTRA_DIST = elf32-i386.script libld_elf_i386.map $(ld_modules)
+EXTRA_DIST = elf32-i386.script libld_elf_i386.map $(ld_modules) arlib.h
 ld_modules = i386_ld.c
 
 if MUDFLAP
@@ -117,8 +119,10 @@ findtextrel_LDADD = $(libdw) $(libelf) $(libmudflap)
 addr2line_LDADD = $(libdw) $(libmudflap)
 elfcmp_LDADD = $(libebl) $(libelf) $(libmudflap) -ldl
 objdump_LDADD  = $(libebl) $(libelf) $(libeu) $(libmudflap) -ldl
-ranlib_LDADD = $(libelf) $(libeu) $(libmudflap)
+ranlib_LDADD = libar.a $(libelf) $(libeu) $(libmudflap)
 strings_LDADD = $(libelf) $(libeu) $(libmudflap)
+ar_LDADD = libar.a $(libelf) $(libeu) $(libmudflap)
+CFLAGS_ar = -DAR=\"$(shell echo ar|sed '$(transform)')\"
 
 ldlex.o: ldscript.c
 ldlex_no_Werror = yes
diff --git a/src/ar.c b/src/ar.c
new file mode 100644 (file)
index 0000000..772c49c
--- /dev/null
+++ b/src/ar.c
@@ -0,0 +1,1531 @@
+/* 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;
+}
diff --git a/src/arlib.c b/src/arlib.c
new file mode 100644 (file)
index 0000000..a48afbc
--- /dev/null
@@ -0,0 +1,269 @@
+/* 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;
+    }
+}
diff --git a/src/arlib.h b/src/arlib.h
new file mode 100644 (file)
index 0000000..ab1be0c
--- /dev/null
@@ -0,0 +1,95 @@
+/* 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>.  */
+
+#ifndef _ARLIB_H
+#define _ARLIB_H       1
+
+#include <ar.h>
+#include <byteswap.h>
+#include <endian.h>
+#include <libelf.h>
+#include <obstack.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <sys/types.h>
+
+
+/* Maximum length of a file name that fits directly into the ar header.  */
+#define MAX_AR_NAME_LEN (sizeof (((struct ar_hdr *) NULL)->ar_name))
+
+
+/* Words matching in size to archive header.  */
+#define AR_HDR_WORDS (sizeof (struct ar_hdr) / sizeof (uint32_t))
+
+
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+# define le_bswap_32(val) bswap_32 (val)
+#else
+# define le_bswap_32(val) (val)
+#endif
+
+
+/* Symbol table type.  */
+struct arlib_symtab
+{
+  /* Symbol table handling.  */
+  struct obstack symsoffob;
+  struct obstack symsnameob;
+  size_t symsofflen;
+  uint32_t *symsoff;
+  size_t symsnamelen;
+  char *symsname;
+
+  /* Long filename handling.  */
+  struct obstack longnamesob;
+  size_t longnameslen;
+  char *longnames;
+};
+
+
+/* Initialize ARLIB_SYMTAB structure.  */
+extern void arlib_init (struct arlib_symtab *symtab);
+
+
+/* Finalize ARLIB_SYMTAB content.  */
+extern void arlib_finalize (struct arlib_symtab *symtab);
+
+/* Free resources for ARLIB_SYMTAB.  */
+extern void arlib_fini (struct arlib_symtab *symtab);
+
+/* Add symbols from ELF with value OFFSET to the symbol table SYMTAB.  */
+extern void arlib_add_symbols (Elf *elf, const char *arfname,
+                              const char *membername,
+                              struct arlib_symtab *symtab, off_t off);
+
+/* Add name a file offset of a symbol.  */
+extern void arlib_add_symref (struct arlib_symtab *symtab, const char *symname,
+                             off_t symoff);
+
+/* Add long file name FILENAME of length FILENAMELEN to the symbol table
+   SYMTAB.  Return the offset into the long file name table.  */
+extern long int arlib_add_long_name (struct arlib_symtab *symtab,
+                                    const char *filename, size_t filenamelen);
+
+#endif /* arlib.h */
diff --git a/src/arlib2.c b/src/arlib2.c
new file mode 100644 (file)
index 0000000..cb1e1db
--- /dev/null
@@ -0,0 +1,51 @@
+/* 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 <error.h>
+#include <libintl.h>
+#include <limits.h>
+#include <string.h>
+#include <sys/param.h>
+
+#include "arlib.h"
+
+
+/* Add long file name FILENAME of length FILENAMELEN to the symbol table
+   SYMTAB.  Return the offset into the long file name table.  */
+long int
+arlib_add_long_name (struct arlib_symtab *symtab, const char *filename,
+                    size_t filenamelen)
+{
+  int retval = obstack_object_size (&symtab->longnamesob);
+
+  obstack_grow (&symtab->longnamesob, filename, filenamelen);
+  obstack_grow (&symtab->longnamesob, "/\n", 2);
+
+  return retval;
+}
index f887ac3c3ec09074979ca26882092a107cf84d94..79e52299c527f0ec87b51a9dfaf3a0029e1ccff4 100644 (file)
@@ -731,9 +731,22 @@ section [%2d] '%s': symbol %zu: function in COMMON section is nonsense\n"),
                    {
                      if ((sym->st_value - destshdr->sh_addr)
                          > destshdr->sh_size)
-                       ERROR (gettext ("\
+                       {
+                         /* GNU ld has severe bugs.  When it decides to remove
+                            empty sections it leaves symbols referencing them
+                            behind.  These are symbols in .symtab.  */
+                         if (!gnuld
+                             || strcmp (section_name (ebl, idx), ".symtab")
+                             || (strcmp (name, "__preinit_array_start") != 0
+                                 && strcmp (name, "__preinit_array_end") != 0
+                                 && strcmp (name, "__init_array_start") != 0
+                                 && strcmp (name, "__init_array_end") != 0
+                                 && strcmp (name, "__fini_array_start") != 0
+                                 && strcmp (name, "__fini_array_end") != 0))
+                           ERROR (gettext ("\
 section [%2d] '%s': symbol %zu: st_value out of bounds\n"),
-                              idx, section_name (ebl, idx), cnt);
+                                  idx, section_name (ebl, idx), cnt);
+                       }
                      else if ((sym->st_value - destshdr->sh_addr
                                + sym->st_size) > destshdr->sh_size)
                        ERROR (gettext ("\
index fd4509d78e313f3d457de6f6ea2b015d0d965ee5..0a8667d3f30e98fcc2a3772382fab9b4c8b64333 100644 (file)
@@ -31,8 +31,6 @@
 #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.  */
@@ -83,13 +76,10 @@ static const char doc[] = N_("Generate an index to speed access to archives.");
 /* 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
 };
 
 
@@ -152,141 +142,20 @@ warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
 }
 
 
-/* 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;
 }
 
 
@@ -328,84 +197,64 @@ handle_file (const char *fname)
       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:
@@ -415,62 +264,6 @@ handle_file (const char *fname)
              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.  */
@@ -481,30 +274,34 @@ handle_file (const char *fname)
          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;
 }
index cce03fbe2b614e2cb2564c163c24352adb389c2c..2aaba2faa2fa7fb9c82579a60c16b1d3b249726f 100644 (file)
@@ -1,3 +1,10 @@
+2007-02-04  Ulrich Drepper  <drepper@redhat.com>
+
+       * arls.c: New file.
+       * Makefile (noinst_PROGRAMS): Add arls.
+
+       * run-ranlib-test2.sh: Fix type in comment.
+
 2007-01-10  Ulrich Drepper  <drepper@redhat.com>
 
        * run-elflint-self.sh (runtest): Show which file has the problem.
index 93a2f8e309848a790a9f76cb8ea40717bb22dc2a..bd56f7b7a8efff507e2a938279e781edee8d1422 100644 (file)
@@ -59,7 +59,7 @@ noinst_PROGRAMS = arextract arsymtest newfile saridx scnnames sectiondump \
                  get-aranges allfcts line2addr addrscopes funcscopes \
                  show-abbrev hash newscn ecp dwflmodtest \
                  find-prologues funcretval allregs rdwrmmap \
-                 dwfl-bug-addr-overflow
+                 dwfl-bug-addr-overflow arls
 # get-ciefde
 asm_TESTS = asm-tst1 asm-tst2 asm-tst3 asm-tst4 asm-tst5 \
            asm-tst6 asm-tst7 asm-tst8 asm-tst9
@@ -201,6 +201,7 @@ asm_tst9_LDADD = $(libasm) $(libebl) $(libelf) $(libmudflap) -ldl
 dwflmodtest_LDADD = $(libdw) $(libebl) $(libelf) $(libmudflap) -ldl
 rdwrmmap_LDADD = $(libelf)
 dwfl_bug_addr_overflow_LDADD = $(libdw) $(libebl) $(libelf) $(libmudflap) -ldl
+arls_LDADD = $(libelf) $(libmudflap)
 
 CLEANFILES = xxx *.gcno *.gcda *gconv
 
diff --git a/tests/arls.c b/tests/arls.c
new file mode 100644 (file)
index 0000000..79b867d
--- /dev/null
@@ -0,0 +1,91 @@
+#include <ar.h>
+#include <fcntl.h>
+#include <libelf.h>
+#include <stdio.h>
+#include <unistd.h>
+
+
+static int handle (const char *fname);
+
+
+int
+main (int argc, char *argv[])
+{
+  elf_version (EV_CURRENT);
+
+  int result = 0;
+  if (argc == 1)
+    result = handle ("a.out");
+  else
+    for (int i = 1; i < argc; ++i)
+      result |= handle (argv[1]);
+
+  return result;
+}
+
+
+static int
+handle (const char *fname)
+{
+  int fd = open (fname, O_RDONLY);
+  if (fd == -1)
+    {
+      printf ("cannot open '%s': %m\n", fname);
+      return 1;
+    }
+
+  Elf *elf = elf_begin (fd, ELF_C_READ_MMAP, NULL);
+  if (elf == NULL)
+    {
+      printf ("cannot get ELF handling for '%s': %s\n",
+             fname, elf_errmsg (-1));
+      close (fd);
+      return 1;
+    }
+
+  if (elf_kind (elf) != ELF_K_AR)
+    {
+      printf ("'%s' is no archive\n", fname);
+      elf_end (elf);
+      close (fd);
+      return 1;
+    }
+
+  printf ("%s:\n", fname);
+  Elf *subelf = NULL;
+  Elf_Cmd cmd = ELF_C_READ_MMAP;
+  while ((subelf = elf_begin (fd, cmd, elf)) != NULL)
+    {
+      Elf_Arhdr *arhdr = elf_getarhdr (subelf);
+      if (arhdr == NULL)
+       {
+         printf ("cannot get archive header in '%s': %s\n",
+                 fname, elf_errmsg (-1));
+         elf_end (subelf);
+         elf_end (elf);
+         close (fd);
+         return 1;
+       }
+
+      off_t off = elf_getaroff (subelf);
+
+      printf ("\nOffset    %llu\n"
+             "  Name    %s\n"
+             "  Date    %ld\n"
+             "  UID     %d\n"
+             "  GID     %d\n"
+             "  Mode    %o\n"
+             "  Size    %lld\n",
+             (unsigned long long int) off,
+             arhdr->ar_name, (long int) arhdr->ar_date, (int) arhdr->ar_uid,
+             (int) arhdr->ar_gid,
+             (int) arhdr->ar_mode, (long long int) arhdr->ar_size);
+
+      cmd = elf_next (subelf);
+      elf_end (subelf);
+    }
+
+  close (fd);
+
+  return 0;
+}
index 19b081d6622c1b6cd802e247e8f8a9b17ade0c02..870403765906346d92c9352b396708b3040eb825 100755 (executable)
@@ -34,7 +34,7 @@ testfiles $original $indexed
 testrun ../src/ranlib $original
 
 if test -z "$noindex"; then
-  # The data in the index is different.  The reference file has it blanked
+  # The date in the index is different.  The reference file has it blanked
   # out, we do the same here.
   echo "            " |
   dd of=$original seek=24 bs=1 count=12 conv=notrunc 2>/dev/null