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