src/ar.c

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