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. */ 50static void print_version (FILE *stream, struct argp_state *state); 51ARGP_PROGRAM_VERSION_HOOK_DEF = print_version; 52 53/* Prototypes for local functions. */ 54static int do_oper_extract (int oper, const char *arfname, char **argv, 55 int argc, long int instance); 56static int do_oper_delete (const char *arfname, char **argv, int argc, 57 long int instance); 58static int do_oper_insert (int oper, const char *arfname, char **argv, 59 int argc, const char *member); 60 61 62/* Bug report address. */ 63ARGP_PROGRAM_BUG_ADDRESS_DEF = PACKAGE_BUGREPORT; 64 65 66/* Definitions of arguments for argp functions. */ 67static 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. */ 100static const char doc[] = N_("Create, modify, and extract from archives."); 101 102/* Strings for arguments in help texts. */ 103static const char args_doc[] = N_("[MEMBER] [COUNT] ARCHIVE [FILE...]"); 104 105/* Prototype for option handler. */ 106static error_t parse_opt (int key, char *arg, struct argp_state *state); 107 108/* Data structure to communicate with argp functions. */ 109static struct argp argp = 110{ 111 options, parse_opt, args_doc, doc, arlib_argp_children, NULL, NULL 112}; 113 114 115/* What operation to perform. */ 116static 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. */ 129static bool verbose; 130static bool preserve_dates; 131static bool instance_specifed; 132static bool dont_replace_existing; 133static bool allow_truncate_fname; 134static bool force_symtab; 135static bool suppress_create_msg; 136static bool full_path; 137static bool update_newer; 138static enum { ipos_none, ipos_before, ipos_after } ipos; 139 140 141int 142main (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 ("\ 191MEMBER 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. */ 285static void 286print_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 ("\ 290Copyright (C) %s Red Hat, Inc.\n\ 291This is free software; see the source for copying conditions. There is NO\n\ 292warranty; 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. */ 299static error_t 300parse_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 398static int 399open_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 433static void 434not_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 442static int 443copy_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 459static int 460do_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 ("\ 742cannot 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 838struct 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 855static int 856write_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. */ 909static void 910remember_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 917static int 918do_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 1088static void 1089no0print (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 1097static int 1098do_oper_insert (int oper, const char *arfname, char **argv, int argc, 1099 const char *member) 1100{ 1101 int status = 0; 1102 Elf *elf; 1103 struct stat st; 1104 int fd = open_archive (arfname, O_RDONLY, 0, &elf, &st, oper != oper_move); 1105 1106 /* List of the files we keep. */ 1107 struct armem *all = NULL; 1108 struct armem *after_memberelem = NULL; 1109 struct armem **found = alloca (sizeof (*found) * argc); 1110 memset (found, '\0', sizeof (*found) * argc); 1111 1112 arlib_init (); 1113 1114 /* Initialize early for no_old case. */ 1115 off_t cur_off = SARMAG; 1116 1117 if (fd == -1) 1118 { 1119 if (!suppress_create_msg) 1120 fprintf (stderr, "%s: creating %s\n", 1121 program_invocation_short_name, arfname); 1122 1123 goto no_old; 1124 } 1125 1126 /* Store the names of all files from the command line in a hash 1127 table so that we can match it. Note that when no file name is 1128 given we are basically doing nothing except recreating the 1129 index. */ 1130 if (oper != oper_qappend) 1131 { 1132 if (hcreate (2 * argc) == 0) 1133 error (EXIT_FAILURE, errno, gettext ("cannot create hash table")); 1134 1135 for (int cnt = 0; cnt < argc; ++cnt) 1136 { 1137 ENTRY entry; 1138 entry.key = full_path ? argv[cnt] : basename (argv[cnt]); 1139 entry.data = &argv[cnt]; 1140 if (hsearch (entry, ENTER) == NULL) 1141 error (EXIT_FAILURE, errno, 1142 gettext ("cannot insert into hash table")); 1143 } 1144 } 1145 1146 /* While iterating over the current content of the archive we must 1147 determine a number of things: which archive members to keep, 1148 which are replaced, and where to insert the new members. */ 1149 Elf_Cmd cmd = ELF_C_READ_MMAP; 1150 Elf *subelf; 1151 while ((subelf = elf_begin (fd, cmd, elf)) != NULL) 1152 { 1153 Elf_Arhdr *arhdr = elf_getarhdr (subelf); 1154 1155 /* Ignore the symbol table and the long file name table here. */ 1156 if (strcmp (arhdr->ar_name, "/") == 0 1157 || strcmp (arhdr->ar_name, "//") == 0) 1158 goto next; 1159 1160 struct armem *newp = alloca (sizeof (struct armem)); 1161 newp->old_off = elf_getaroff (subelf); 1162 newp->size = arhdr->ar_size; 1163 newp->sec = arhdr->ar_date; 1164 newp->mem = NULL; 1165 1166 /* Remember long file names. */ 1167 remember_long_name (newp, arhdr->ar_name, strlen (arhdr->ar_name)); 1168 1169 /* Check whether this is a file we are looking for. */ 1170 if (oper != oper_qappend) 1171 { 1172 /* Check whether this is the member used as the insert point. */ 1173 if (member != NULL && strcmp (arhdr->ar_name, member) == 0) 1174 { 1175 /* Note that all == NULL means insert at the beginning. */ 1176 if (ipos == ipos_before) 1177 after_memberelem = all; 1178 else 1179 after_memberelem = newp; 1180 member = NULL; 1181 } 1182 1183 ENTRY entry; 1184 entry.key = arhdr->ar_name; 1185 ENTRY *res = hsearch (entry, FIND); 1186 if (res != NULL && found[(char **) res->data - argv] == NULL) 1187 { 1188 found[(char **) res->data - argv] = newp; 1189 1190 /* If we insert before or after a certain element move 1191 all files to a special list. */ 1192 if (unlikely (ipos != ipos_none || oper == oper_move)) 1193 { 1194 if (after_memberelem == newp) 1195 /* Since we remove this element even though we should 1196 insert everything after it, we in fact insert 1197 everything after the previous element. */ 1198 after_memberelem = all; 1199 1200 goto next; 1201 } 1202 } 1203 } 1204 1205 if (all == NULL) 1206 all = newp->next = newp; 1207 else 1208 { 1209 newp->next = all->next; 1210 all = all->next = newp; 1211 } 1212 1213 next: 1214 cmd = elf_next (subelf); 1215 if (elf_end (subelf) != 0) 1216 error (EXIT_FAILURE, 0, "%s: %s", arfname, elf_errmsg (-1)); 1217 } 1218 1219 if (oper != oper_qappend) 1220 hdestroy (); 1221 1222 no_old: 1223 if (member != NULL) 1224 error (EXIT_FAILURE, 0, gettext ("position member %s not found"), 1225 member); 1226 1227 if (oper == oper_move) 1228 { 1229 /* Make sure all requested elements are found in the archive. */ 1230 for (int cnt = 0; cnt < argc; ++cnt) 1231 { 1232 if (found[cnt] == NULL) 1233 { 1234 fprintf (stderr, gettext ("%s: no entry %s in archive!\n"), 1235 program_invocation_short_name, argv[cnt]); 1236 status = 1; 1237 } 1238 1239 if (verbose) 1240 printf ("m - %s\n", argv[cnt]); 1241 } 1242 } 1243 else 1244 { 1245 /* Open all the new files, get their sizes and add all symbols. */ 1246 for (int cnt = 0; cnt < argc; ++cnt) 1247 { 1248 const char *bname = basename (argv[cnt]); 1249 size_t bnamelen = strlen (bname); 1250 if (found[cnt] == NULL) 1251 { 1252 found[cnt] = alloca (sizeof (struct armem)); 1253 found[cnt]->old_off = -1; 1254 1255 remember_long_name (found[cnt], bname, bnamelen); 1256 } 1257 1258 struct stat newst; 1259 Elf *newelf; 1260 int newfd = open (argv[cnt], O_RDONLY); 1261 if (newfd == -1) 1262 { 1263 error (0, errno, gettext ("cannot open %s"), argv[cnt]); 1264 status = 1; 1265 } 1266 else if (fstat (newfd, &newst) == -1) 1267 { 1268 error (0, errno, gettext ("cannot stat %s"), argv[cnt]); 1269 close (newfd); 1270 status = 1; 1271 } 1272 else if (!S_ISREG (newst.st_mode)) 1273 { 1274 error (0, errno, gettext ("%s is no regular file"), argv[cnt]); 1275 close (newfd); 1276 status = 1; 1277 } 1278 else if (update_newer 1279 && found[cnt]->old_off != -1l 1280 && found[cnt]->sec > st.st_mtime) 1281 /* Do nothing, the file in the archive is younger. */ 1282 close (newfd); 1283 else if ((newelf = elf_begin (newfd, ELF_C_READ_MMAP, NULL)) 1284 == NULL) 1285 { 1286 fprintf (stderr, 1287 gettext ("cannot get ELF descriptor for %s: %s\n"), 1288 argv[cnt], elf_errmsg (-1)); 1289 status = 1; 1290 } 1291 else 1292 { 1293 if (verbose) 1294 printf ("%c - %s\n", 1295 found[cnt]->old_off == -1l ? 'a' : 'r', argv[cnt]); 1296 1297 found[cnt]->elf = newelf; 1298 found[cnt]->sec = arlib_deterministic_output ? 0 : newst.st_mtime; 1299 found[cnt]->uid = arlib_deterministic_output ? 0 : newst.st_uid; 1300 found[cnt]->gid = arlib_deterministic_output ? 0 : newst.st_gid; 1301 found[cnt]->mode = newst.st_mode; 1302 found[cnt]->name = bname; 1303 1304 found[cnt]->mem = elf_rawfile (newelf, &found[cnt]->size); 1305 if (found[cnt]->mem == NULL 1306 || elf_cntl (newelf, ELF_C_FDDONE) != 0) 1307 error (EXIT_FAILURE, 0, gettext ("cannot read %s: %s"), 1308 argv[cnt], elf_errmsg (-1)); 1309 1310 close (newfd); 1311 1312 if (found[cnt]->old_off != -1l) 1313 /* Remember long file names. */ 1314 remember_long_name (found[cnt], bname, bnamelen); 1315 } 1316 } 1317 } 1318 1319 if (status != 0) 1320 { 1321#ifdef DEBUG 1322 elf_end (elf); 1323 1324 arlib_fini (); 1325 1326 close (fd); 1327#endif 1328 1329 return status; 1330 } 1331 1332 /* If we have no entry point so far add at the end. AFTER_MEMBERELEM 1333 being NULL when adding before an entry means add at the beginning. */ 1334 if (ipos != ipos_before && after_memberelem == NULL) 1335 after_memberelem = all; 1336 1337 /* Convert the circular list into a normal list first. */ 1338 if (all != NULL) 1339 { 1340 struct armem *tmp = all; 1341 all = all->next; 1342 tmp->next = NULL; 1343 } 1344 1345 struct armem *last_added = after_memberelem; 1346 for (int cnt = 0; cnt < argc; ++cnt) 1347 if (oper != oper_replace || found[cnt]->old_off == -1) 1348 { 1349 if (last_added == NULL) 1350 { 1351 found[cnt]->next = all; 1352 last_added = all = found[cnt]; 1353 } 1354 else 1355 { 1356 found[cnt]->next = last_added->next; 1357 last_added = last_added->next = found[cnt]; 1358 } 1359 } 1360 1361 /* Finally compute the offset and add the symbols for the files 1362 after the insert point. */ 1363 if (likely (all != NULL)) 1364 for (struct armem *memp = all; memp != NULL; memp = memp->next) 1365 { 1366 memp->off = cur_off; 1367 1368 if (memp->mem == NULL) 1369 { 1370 Elf_Arhdr *arhdr; 1371 /* Fake initializing arhdr and subelf to keep gcc calm. */ 1372 asm ("" : "=m" (arhdr), "=m" (subelf)); 1373 if (elf_rand (elf, memp->old_off) == 0 1374 || (subelf = elf_begin (fd, ELF_C_READ_MMAP, elf)) == NULL 1375 || (arhdr = elf_getarhdr (subelf)) == NULL) 1376 /* This should never happen since we already looked at the 1377 archive content. But who knows... */ 1378 error (EXIT_FAILURE, 0, "%s: %s", arfname, elf_errmsg (-1)); 1379 1380 arlib_add_symbols (subelf, arfname, arhdr->ar_name, cur_off); 1381 1382 elf_end (subelf); 1383 } 1384 else 1385 arlib_add_symbols (memp->elf, arfname, memp->name, cur_off); 1386 1387 cur_off += (((memp->size + 1) & ~((off_t) 1)) 1388 + sizeof (struct ar_hdr)); 1389 } 1390 1391 /* Now we have all the information for the symbol table and long 1392 file name table. Construct the final layout. */ 1393 arlib_finalize (); 1394 1395 /* Create a new, temporary file in the same directory as the 1396 original file. */ 1397 char tmpfname[strlen (arfname) + 7]; 1398 strcpy (stpcpy (tmpfname, arfname), "XXXXXX"); 1399 int newfd; 1400 if (fd != -1) 1401 newfd = mkstemp (tmpfname); 1402 else 1403 { 1404 newfd = open (arfname, O_RDWR | O_CREAT | O_EXCL, DEFFILEMODE); 1405 if (newfd == -1 && errno == EEXIST) 1406 /* Bah, first the file did not exist, now it does. Restart. */ 1407 return do_oper_insert (oper, arfname, argv, argc, member); 1408 } 1409 if (unlikely (newfd == -1)) 1410 goto nonew; 1411 1412 /* Create the header. */ 1413 if (unlikely (write_retry (newfd, ARMAG, SARMAG) != SARMAG)) 1414 { 1415 nonew_unlink: 1416 if (fd != -1) 1417 { 1418 // XXX Use /prof/self/fd/%d ??? 1419 unlink (tmpfname); 1420 if (newfd != -1) 1421 close (newfd); 1422 } 1423 nonew: 1424 error (0, errno, gettext ("cannot create new file")); 1425 status = 1; 1426 goto errout; 1427 } 1428 1429 /* If the new archive is not empty we actually have something to do. */ 1430 if (likely (all != NULL)) 1431 { 1432 /* Write the symbol table or the long file name table or both. */ 1433 if (symtab.symsnamelen != 0 1434 && ((write_retry (newfd, symtab.symsoff, symtab.symsofflen) 1435 != (ssize_t) symtab.symsofflen) 1436 || (write_retry (newfd, symtab.symsname, symtab.symsnamelen) 1437 != (ssize_t) symtab.symsnamelen))) 1438 goto nonew_unlink; 1439 1440 if (symtab.longnameslen > sizeof (struct ar_hdr) 1441 && (write_retry (newfd, symtab.longnames, symtab.longnameslen) 1442 != (ssize_t) symtab.longnameslen)) 1443 goto nonew_unlink; 1444 1445 off_t start = -1; 1446 off_t len = -1; 1447 1448 while (all != NULL) 1449 { 1450 if (all->mem != NULL) 1451 { 1452 /* This is a new file. If there is anything from the 1453 archive left to be written do it now. */ 1454 if (start != -1 && copy_content (elf, newfd, start, len)) 1455 goto nonew_unlink; 1456 1457 start = -1; 1458 len = -1; 1459 1460 /* Create the header. */ 1461 struct ar_hdr arhdr; 1462 char tmpbuf[sizeof (arhdr.ar_name) + 1]; 1463 if (all->long_name_off == -1) 1464 { 1465 size_t namelen = strlen (all->name); 1466 char *p = mempcpy (arhdr.ar_name, all->name, namelen); 1467 *p++ = '/'; 1468 memset (p, ' ', sizeof (arhdr.ar_name) - namelen - 1); 1469 } 1470 else 1471 { 1472 snprintf (tmpbuf, sizeof (arhdr.ar_name) + 1, "/%-*ld", 1473 (int) sizeof (arhdr.ar_name), all->long_name_off); 1474 memcpy (arhdr.ar_name, tmpbuf, sizeof (arhdr.ar_name)); 1475 } 1476 1477 no0print (false, arhdr.ar_date, sizeof (arhdr.ar_date), 1478 all->sec); 1479 no0print (false, arhdr.ar_uid, sizeof (arhdr.ar_uid), all->uid); 1480 no0print (false, arhdr.ar_gid, sizeof (arhdr.ar_gid), all->gid); 1481 no0print (true, arhdr.ar_mode, sizeof (arhdr.ar_mode), 1482 all->mode); 1483 no0print (false, arhdr.ar_size, sizeof (arhdr.ar_size), 1484 all->size); 1485 memcpy (arhdr.ar_fmag, ARFMAG, sizeof (arhdr.ar_fmag)); 1486 1487 if (unlikely (write_retry (newfd, &arhdr, sizeof (arhdr)) 1488 != sizeof (arhdr))) 1489 goto nonew_unlink; 1490 1491 /* Now the file itself. */ 1492 if (unlikely (write_retry (newfd, all->mem, all->size) 1493 != (off_t) all->size)) 1494 goto nonew_unlink; 1495 1496 /* Pad the file if its size is odd. */ 1497 if ((all->size & 1) != 0) 1498 if (unlikely (write_retry (newfd, "\n", 1) != 1)) 1499 goto nonew_unlink; 1500 } 1501 else 1502 { 1503 /* This is a member from the archive. */ 1504 if (write_member (all, &start, &len, elf, cur_off, newfd) 1505 != 0) 1506 goto nonew_unlink; 1507 } 1508 1509 all = all->next; 1510 } 1511 1512 /* Write the last part. */ 1513 if (start != -1 && copy_content (elf, newfd, start, len)) 1514 goto nonew_unlink; 1515 } 1516 1517 /* Set the mode of the new file to the same values the original file 1518 has. */ 1519 if (fd != -1 1520 && (fchmod (newfd, st.st_mode & ALLPERMS) != 0 1521 /* Never complain about fchown failing. */ 1522 || (({asm ("" :: "r" (fchown (newfd, st.st_uid, st.st_gid))); }), 1523 close (newfd) != 0) 1524 || (newfd = -1, rename (tmpfname, arfname) != 0))) 1525 goto nonew_unlink; 1526 1527 errout: 1528#ifdef DEBUG 1529 elf_end (elf); 1530 1531 arlib_fini (); 1532 1533 close (fd); 1534#endif 1535 1536 return status; 1537} 1538 1539 1540#include "debugpred.h" 1541