1 /*- 2 * Copyright (c) 2003-2007 Tim Kientzle 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer 10 * in this position and unchanged. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR 16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 18 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, 19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 */ 26 27 28 #include "cpio_platform.h" 29 __FBSDID("$FreeBSD: src/usr.bin/cpio/cpio.c,v 1.15 2008/12/06 07:30:40 kientzle Exp $"); 30 31 #include <sys/types.h> 32 #include <archive.h> 33 #include <archive_entry.h> 34 35 #ifdef HAVE_SYS_MKDEV_H 36 #include <sys/mkdev.h> 37 #endif 38 #ifdef HAVE_SYS_STAT_H 39 #include <sys/stat.h> 40 #endif 41 #ifdef HAVE_SYS_TIME_H 42 #include <sys/time.h> 43 #endif 44 #ifdef HAVE_ERRNO_H 45 #include <errno.h> 46 #endif 47 #ifdef HAVE_FCNTL_H 48 #include <fcntl.h> 49 #endif 50 #ifdef HAVE_GRP_H 51 #include <grp.h> 52 #endif 53 #ifdef HAVE_PWD_H 54 #include <pwd.h> 55 #endif 56 #ifdef HAVE_STDARG_H 57 #include <stdarg.h> 58 #endif 59 #include <stdio.h> 60 #ifdef HAVE_STDLIB_H 61 #include <stdlib.h> 62 #endif 63 #ifdef HAVE_STRING_H 64 #include <string.h> 65 #endif 66 #ifdef HAVE_UNISTD_H 67 #include <unistd.h> 68 #endif 69 #ifdef HAVE_SYS_TIME_H 70 #include <sys/time.h> 71 #endif 72 #ifdef HAVE_TIME_H 73 #include <time.h> 74 #endif 75 76 #include "cpio.h" 77 #include "matching.h" 78 79 /* Fixed size of uname/gname caches. */ 80 #define name_cache_size 101 81 82 struct name_cache { 83 int probes; 84 int hits; 85 size_t size; 86 struct { 87 id_t id; 88 char *name; 89 } cache[name_cache_size]; 90 }; 91 92 static int copy_data(struct archive *, struct archive *); 93 static const char *cpio_rename(const char *name); 94 static int entry_to_archive(struct cpio *, struct archive_entry *); 95 static int file_to_archive(struct cpio *, const char *); 96 static void free_cache(struct name_cache *cache); 97 static void list_item_verbose(struct cpio *, struct archive_entry *); 98 static void long_help(void); 99 static const char *lookup_gname(struct cpio *, gid_t gid); 100 static int lookup_gname_helper(struct cpio *, 101 const char **name, id_t gid); 102 static const char *lookup_uname(struct cpio *, uid_t uid); 103 static int lookup_uname_helper(struct cpio *, 104 const char **name, id_t uid); 105 static void mode_in(struct cpio *); 106 static void mode_list(struct cpio *); 107 static void mode_out(struct cpio *); 108 static void mode_pass(struct cpio *, const char *); 109 static int restore_time(struct cpio *, struct archive_entry *, 110 const char *, int fd); 111 static void usage(void); 112 static void version(void); 113 114 int 115 main(int argc, char *argv[]) 116 { 117 static char buff[16384]; 118 struct cpio _cpio; /* Allocated on stack. */ 119 struct cpio *cpio; 120 int uid, gid; 121 int opt; 122 123 cpio = &_cpio; 124 memset(cpio, 0, sizeof(*cpio)); 125 cpio->buff = buff; 126 cpio->buff_size = sizeof(buff); 127 #if defined(_WIN32) && !defined(__CYGWIN__) 128 /* Make sure open() function will be used with a binary mode. */ 129 /* on cygwin, we need something similar, but instead link against */ 130 /* a special startup object, binmode.o */ 131 _set_fmode(_O_BINARY); 132 #endif 133 134 /* Need cpio_progname before calling cpio_warnc. */ 135 if (*argv == NULL) 136 cpio_progname = "bsdcpio"; 137 else { 138 #if defined(_WIN32) && !defined(__CYGWIN__) 139 cpio_progname = strrchr(*argv, '\\'); 140 #else 141 cpio_progname = strrchr(*argv, '/'); 142 #endif 143 if (cpio_progname != NULL) 144 cpio_progname++; 145 else 146 cpio_progname = *argv; 147 } 148 149 cpio->uid_override = -1; 150 cpio->gid_override = -1; 151 cpio->argv = argv; 152 cpio->argc = argc; 153 cpio->line_separator = '\n'; 154 cpio->mode = '\0'; 155 cpio->verbose = 0; 156 cpio->compress = '\0'; 157 cpio->extract_flags = ARCHIVE_EXTRACT_NO_AUTODIR; 158 cpio->extract_flags |= ARCHIVE_EXTRACT_NO_OVERWRITE_NEWER; 159 cpio->extract_flags |= ARCHIVE_EXTRACT_SECURE_SYMLINKS; 160 cpio->extract_flags |= ARCHIVE_EXTRACT_SECURE_NODOTDOT; 161 cpio->extract_flags |= ARCHIVE_EXTRACT_PERM; 162 cpio->extract_flags |= ARCHIVE_EXTRACT_FFLAGS; 163 cpio->extract_flags |= ARCHIVE_EXTRACT_ACL; 164 #if defined(_WIN32) || defined(__CYGWIN__) 165 if (bsdcpio_is_privileged()) 166 #else 167 if (geteuid() == 0) 168 #endif 169 cpio->extract_flags |= ARCHIVE_EXTRACT_OWNER; 170 cpio->bytes_per_block = 512; 171 cpio->filename = NULL; 172 173 while ((opt = cpio_getopt(cpio)) != -1) { 174 switch (opt) { 175 case '0': /* GNU convention: --null, -0 */ 176 cpio->line_separator = '\0'; 177 break; 178 case 'A': /* NetBSD/OpenBSD */ 179 cpio->option_append = 1; 180 break; 181 case 'a': /* POSIX 1997 */ 182 cpio->option_atime_restore = 1; 183 break; 184 case 'B': /* POSIX 1997 */ 185 cpio->bytes_per_block = 5120; 186 break; 187 case 'C': /* NetBSD/OpenBSD */ 188 cpio->bytes_per_block = atoi(cpio->optarg); 189 if (cpio->bytes_per_block <= 0) 190 cpio_errc(1, 0, "Invalid blocksize %s", cpio->optarg); 191 break; 192 case 'c': /* POSIX 1997 */ 193 cpio->format = "odc"; 194 break; 195 case 'd': /* POSIX 1997 */ 196 cpio->extract_flags &= ~ARCHIVE_EXTRACT_NO_AUTODIR; 197 break; 198 case 'E': /* NetBSD/OpenBSD */ 199 include_from_file(cpio, cpio->optarg); 200 break; 201 case 'F': /* NetBSD/OpenBSD/GNU cpio */ 202 cpio->filename = cpio->optarg; 203 break; 204 case 'f': /* POSIX 1997 */ 205 exclude(cpio, cpio->optarg); 206 break; 207 case 'H': /* GNU cpio (also --format) */ 208 cpio->format = cpio->optarg; 209 break; 210 case 'h': 211 long_help(); 212 break; 213 case 'I': /* NetBSD/OpenBSD */ 214 cpio->filename = cpio->optarg; 215 break; 216 case 'i': /* POSIX 1997 */ 217 if (cpio->mode != '\0') 218 cpio_errc(1, 0, 219 "Cannot use both -i and -%c", cpio->mode); 220 cpio->mode = opt; 221 break; 222 case OPTION_INSECURE: 223 cpio->extract_flags &= ~ARCHIVE_EXTRACT_SECURE_SYMLINKS; 224 cpio->extract_flags &= ~ARCHIVE_EXTRACT_SECURE_NODOTDOT; 225 break; 226 case 'L': /* GNU cpio */ 227 cpio->option_follow_links = 1; 228 break; 229 case 'l': /* POSIX 1997 */ 230 cpio->option_link = 1; 231 break; 232 case 'm': /* POSIX 1997 */ 233 cpio->extract_flags |= ARCHIVE_EXTRACT_TIME; 234 break; 235 case 'n': /* GNU cpio */ 236 cpio->option_numeric_uid_gid = 1; 237 break; 238 case OPTION_NO_PRESERVE_OWNER: /* GNU cpio */ 239 cpio->extract_flags &= ~ARCHIVE_EXTRACT_OWNER; 240 break; 241 case 'O': /* GNU cpio */ 242 cpio->filename = cpio->optarg; 243 break; 244 case 'o': /* POSIX 1997 */ 245 if (cpio->mode != '\0') 246 cpio_errc(1, 0, 247 "Cannot use both -o and -%c", cpio->mode); 248 cpio->mode = opt; 249 break; 250 case 'p': /* POSIX 1997 */ 251 if (cpio->mode != '\0') 252 cpio_errc(1, 0, 253 "Cannot use both -p and -%c", cpio->mode); 254 cpio->mode = opt; 255 cpio->extract_flags &= ~ARCHIVE_EXTRACT_SECURE_NODOTDOT; 256 break; 257 case OPTION_QUIET: /* GNU cpio */ 258 cpio->quiet = 1; 259 break; 260 case 'R': /* GNU cpio, also --owner */ 261 if (owner_parse(cpio->optarg, &uid, &gid)) 262 usage(); 263 if (uid != -1) 264 cpio->uid_override = uid; 265 if (gid != -1) 266 cpio->gid_override = gid; 267 break; 268 case 'r': /* POSIX 1997 */ 269 cpio->option_rename = 1; 270 break; 271 case 't': /* POSIX 1997 */ 272 cpio->option_list = 1; 273 break; 274 case 'u': /* POSIX 1997 */ 275 cpio->extract_flags 276 &= ~ARCHIVE_EXTRACT_NO_OVERWRITE_NEWER; 277 break; 278 case 'v': /* POSIX 1997 */ 279 cpio->verbose++; 280 break; 281 case OPTION_VERSION: /* GNU convention */ 282 version(); 283 break; 284 #if 0 285 /* 286 * cpio_getopt() handles -W specially, so it's not 287 * available here. 288 */ 289 case 'W': /* Obscure, but useful GNU convention. */ 290 break; 291 #endif 292 case 'y': /* tar convention */ 293 #if HAVE_LIBBZ2 294 cpio->compress = opt; 295 #else 296 cpio_warnc(0, "bzip2 compression not supported by " 297 "this version of bsdcpio"); 298 #endif 299 break; 300 case 'Z': /* tar convention */ 301 cpio->compress = opt; 302 break; 303 case 'z': /* tar convention */ 304 #if HAVE_LIBZ 305 cpio->compress = opt; 306 #else 307 cpio_warnc(0, "gzip compression not supported by " 308 "this version of bsdcpio"); 309 #endif 310 break; 311 default: 312 usage(); 313 } 314 } 315 316 /* 317 * Sanity-check args, error out on nonsensical combinations. 318 */ 319 /* -t implies -i if no mode was specified. */ 320 if (cpio->option_list && cpio->mode == '\0') 321 cpio->mode = 'i'; 322 /* -t requires -i */ 323 if (cpio->option_list && cpio->mode != 'i') 324 cpio_errc(1, 0, "Option -t requires -i", cpio->mode); 325 /* -n requires -it */ 326 if (cpio->option_numeric_uid_gid && !cpio->option_list) 327 cpio_errc(1, 0, "Option -n requires -it"); 328 /* Can only specify format when writing */ 329 if (cpio->format != NULL && cpio->mode != 'o') 330 cpio_errc(1, 0, "Option --format requires -o"); 331 /* -l requires -p */ 332 if (cpio->option_link && cpio->mode != 'p') 333 cpio_errc(1, 0, "Option -l requires -p"); 334 /* TODO: Flag other nonsensical combinations. */ 335 336 switch (cpio->mode) { 337 case 'o': 338 /* TODO: Implement old binary format in libarchive, 339 use that here. */ 340 if (cpio->format == NULL) 341 cpio->format = "odc"; /* Default format */ 342 343 mode_out(cpio); 344 break; 345 case 'i': 346 while (*cpio->argv != NULL) { 347 include(cpio, *cpio->argv); 348 --cpio->argc; 349 ++cpio->argv; 350 } 351 if (cpio->option_list) 352 mode_list(cpio); 353 else 354 mode_in(cpio); 355 break; 356 case 'p': 357 if (*cpio->argv == NULL || **cpio->argv == '\0') 358 cpio_errc(1, 0, 359 "-p mode requires a target directory"); 360 mode_pass(cpio, *cpio->argv); 361 break; 362 default: 363 cpio_errc(1, 0, 364 "Must specify at least one of -i, -o, or -p"); 365 } 366 367 free_cache(cpio->gname_cache); 368 free_cache(cpio->uname_cache); 369 return (0); 370 } 371 372 void 373 usage(void) 374 { 375 const char *p; 376 377 p = cpio_progname; 378 379 fprintf(stderr, "Brief Usage:\n"); 380 fprintf(stderr, " List: %s -it < archive\n", p); 381 fprintf(stderr, " Extract: %s -i < archive\n", p); 382 fprintf(stderr, " Create: %s -o < filenames > archive\n", p); 383 fprintf(stderr, " Help: %s --help\n", p); 384 exit(1); 385 } 386 387 static const char *long_help_msg = 388 "First option must be a mode specifier:\n" 389 " -i Input -o Output -p Pass\n" 390 "Common Options:\n" 391 " -v Verbose\n" 392 "Create: %p -o [options] < [list of files] > [archive]\n" 393 #ifdef HAVE_BZLIB_H 394 " -y Compress archive with bzip2\n" 395 #endif 396 #ifdef HAVE_ZLIB_H 397 " -z Compress archive with gzip\n" 398 #endif 399 " --format {odc|newc|ustar} Select archive format\n" 400 "List: %p -it < [archive]\n" 401 "Extract: %p -i [options] < [archive]\n"; 402 403 404 /* 405 * Note that the word 'bsdcpio' will always appear in the first line 406 * of output. 407 * 408 * In particular, /bin/sh scripts that need to test for the presence 409 * of bsdcpio can use the following template: 410 * 411 * if (cpio --help 2>&1 | grep bsdcpio >/dev/null 2>&1 ) then \ 412 * echo bsdcpio; else echo not bsdcpio; fi 413 */ 414 static void 415 long_help(void) 416 { 417 const char *prog; 418 const char *p; 419 420 prog = cpio_progname; 421 422 fflush(stderr); 423 424 p = (strcmp(prog,"bsdcpio") != 0) ? "(bsdcpio)" : ""; 425 printf("%s%s: manipulate archive files\n", prog, p); 426 427 for (p = long_help_msg; *p != '\0'; p++) { 428 if (*p == '%') { 429 if (p[1] == 'p') { 430 fputs(prog, stdout); 431 p++; 432 } else 433 putchar('%'); 434 } else 435 putchar(*p); 436 } 437 version(); 438 } 439 440 static void 441 version(void) 442 { 443 fprintf(stdout,"bsdcpio %s -- %s\n", 444 BSDCPIO_VERSION_STRING, 445 archive_version()); 446 exit(0); 447 } 448 449 static void 450 mode_out(struct cpio *cpio) 451 { 452 unsigned long blocks; 453 struct archive_entry *entry, *spare; 454 struct line_reader *lr; 455 const char *p; 456 int r; 457 458 if (cpio->option_append) 459 cpio_errc(1, 0, "Append mode not yet supported."); 460 cpio->archive = archive_write_new(); 461 if (cpio->archive == NULL) 462 cpio_errc(1, 0, "Failed to allocate archive object"); 463 switch (cpio->compress) { 464 #ifdef HAVE_BZLIB_H 465 case 'j': case 'y': 466 archive_write_set_compression_bzip2(cpio->archive); 467 break; 468 #endif 469 #ifdef HAVE_ZLIB_H 470 case 'z': 471 archive_write_set_compression_gzip(cpio->archive); 472 break; 473 #endif 474 case 'Z': 475 archive_write_set_compression_compress(cpio->archive); 476 break; 477 default: 478 archive_write_set_compression_none(cpio->archive); 479 break; 480 } 481 r = archive_write_set_format_by_name(cpio->archive, cpio->format); 482 if (r != ARCHIVE_OK) 483 cpio_errc(1, 0, archive_error_string(cpio->archive)); 484 archive_write_set_bytes_per_block(cpio->archive, cpio->bytes_per_block); 485 cpio->linkresolver = archive_entry_linkresolver_new(); 486 archive_entry_linkresolver_set_strategy(cpio->linkresolver, 487 archive_format(cpio->archive)); 488 489 r = archive_write_open_file(cpio->archive, cpio->filename); 490 if (r != ARCHIVE_OK) 491 cpio_errc(1, 0, archive_error_string(cpio->archive)); 492 lr = process_lines_init("-", cpio->line_separator); 493 while ((p = process_lines_next(lr)) != NULL) 494 file_to_archive(cpio, p); 495 process_lines_free(lr); 496 497 /* 498 * The hardlink detection may have queued up a couple of entries 499 * that can now be flushed. 500 */ 501 entry = NULL; 502 archive_entry_linkify(cpio->linkresolver, &entry, &spare); 503 while (entry != NULL) { 504 entry_to_archive(cpio, entry); 505 archive_entry_free(entry); 506 entry = NULL; 507 archive_entry_linkify(cpio->linkresolver, &entry, &spare); 508 } 509 510 r = archive_write_close(cpio->archive); 511 if (r != ARCHIVE_OK) 512 cpio_errc(1, 0, archive_error_string(cpio->archive)); 513 514 if (!cpio->quiet) { 515 blocks = (archive_position_uncompressed(cpio->archive) + 511) 516 / 512; 517 fprintf(stderr, "%lu %s\n", blocks, 518 blocks == 1 ? "block" : "blocks"); 519 } 520 archive_write_finish(cpio->archive); 521 } 522 523 /* 524 * This is used by both out mode (to copy objects from disk into 525 * an archive) and pass mode (to copy objects from disk to 526 * an archive_write_disk "archive"). 527 */ 528 static int 529 file_to_archive(struct cpio *cpio, const char *srcpath) 530 { 531 struct stat st; 532 const char *destpath; 533 struct archive_entry *entry, *spare; 534 size_t len; 535 const char *p; 536 #if !defined(_WIN32) || defined(__CYGWIN__) 537 int lnklen; 538 #endif 539 int r; 540 541 /* 542 * Create an archive_entry describing the source file. 543 * 544 * XXX TODO: rework to use archive_read_disk_entry_from_file() 545 */ 546 entry = archive_entry_new(); 547 if (entry == NULL) 548 cpio_errc(1, 0, "Couldn't allocate entry"); 549 archive_entry_copy_sourcepath(entry, srcpath); 550 551 /* Get stat information. */ 552 if (cpio->option_follow_links) 553 r = stat(srcpath, &st); 554 else 555 r = lstat(srcpath, &st); 556 if (r != 0) { 557 cpio_warnc(errno, "Couldn't stat \"%s\"", srcpath); 558 archive_entry_free(entry); 559 return (0); 560 } 561 562 if (cpio->uid_override >= 0) 563 st.st_uid = cpio->uid_override; 564 if (cpio->gid_override >= 0) 565 st.st_gid = cpio->uid_override; 566 archive_entry_copy_stat(entry, &st); 567 568 #if !defined(_WIN32) || defined(__CYGWIN__) 569 /* If its a symlink, pull the target. */ 570 if (S_ISLNK(st.st_mode)) { 571 lnklen = readlink(srcpath, cpio->buff, cpio->buff_size); 572 if (lnklen < 0) { 573 cpio_warnc(errno, 574 "%s: Couldn't read symbolic link", srcpath); 575 archive_entry_free(entry); 576 return (0); 577 } 578 cpio->buff[lnklen] = 0; 579 archive_entry_set_symlink(entry, cpio->buff); 580 } 581 #endif 582 583 /* 584 * Generate a destination path for this entry. 585 * "destination path" is the name to which it will be copied in 586 * pass mode or the name that will go into the archive in 587 * output mode. 588 */ 589 destpath = srcpath; 590 if (cpio->destdir) { 591 len = strlen(cpio->destdir) + strlen(srcpath) + 8; 592 if (len >= cpio->pass_destpath_alloc) { 593 while (len >= cpio->pass_destpath_alloc) { 594 cpio->pass_destpath_alloc += 512; 595 cpio->pass_destpath_alloc *= 2; 596 } 597 free(cpio->pass_destpath); 598 cpio->pass_destpath = malloc(cpio->pass_destpath_alloc); 599 if (cpio->pass_destpath == NULL) 600 cpio_errc(1, ENOMEM, 601 "Can't allocate path buffer"); 602 } 603 strcpy(cpio->pass_destpath, cpio->destdir); 604 p = srcpath; 605 while (p[0] == '/') 606 ++p; 607 strcat(cpio->pass_destpath, p); 608 destpath = cpio->pass_destpath; 609 } 610 if (cpio->option_rename) 611 destpath = cpio_rename(destpath); 612 if (destpath == NULL) 613 return (0); 614 archive_entry_copy_pathname(entry, destpath); 615 616 /* 617 * If we're trying to preserve hardlinks, match them here. 618 */ 619 spare = NULL; 620 if (cpio->linkresolver != NULL 621 && !S_ISDIR(st.st_mode)) { 622 archive_entry_linkify(cpio->linkresolver, &entry, &spare); 623 } 624 625 if (entry != NULL) { 626 r = entry_to_archive(cpio, entry); 627 archive_entry_free(entry); 628 } 629 if (spare != NULL) { 630 if (r == 0) 631 r = entry_to_archive(cpio, spare); 632 archive_entry_free(spare); 633 } 634 return (r); 635 } 636 637 static int 638 entry_to_archive(struct cpio *cpio, struct archive_entry *entry) 639 { 640 const char *destpath = archive_entry_pathname(entry); 641 const char *srcpath = archive_entry_sourcepath(entry); 642 int fd = -1; 643 ssize_t bytes_read; 644 int r; 645 646 /* Print out the destination name to the user. */ 647 if (cpio->verbose) 648 fprintf(stderr,"%s", destpath); 649 650 /* 651 * Option_link only makes sense in pass mode and for 652 * regular files. Also note: if a link operation fails 653 * because of cross-device restrictions, we'll fall back 654 * to copy mode for that entry. 655 * 656 * TODO: Test other cpio implementations to see if they 657 * hard-link anything other than regular files here. 658 */ 659 if (cpio->option_link 660 && archive_entry_filetype(entry) == AE_IFREG) 661 { 662 struct archive_entry *t; 663 /* Save the original entry in case we need it later. */ 664 t = archive_entry_clone(entry); 665 if (t == NULL) 666 cpio_errc(1, ENOMEM, "Can't create link"); 667 /* Note: link(2) doesn't create parent directories, 668 * so we use archive_write_header() instead as a 669 * convenience. */ 670 archive_entry_set_hardlink(t, srcpath); 671 /* This is a straight link that carries no data. */ 672 archive_entry_set_size(t, 0); 673 r = archive_write_header(cpio->archive, t); 674 archive_entry_free(t); 675 if (r != ARCHIVE_OK) 676 cpio_warnc(archive_errno(cpio->archive), 677 archive_error_string(cpio->archive)); 678 if (r == ARCHIVE_FATAL) 679 exit(1); 680 #ifdef EXDEV 681 if (r != ARCHIVE_OK && archive_errno(cpio->archive) == EXDEV) { 682 /* Cross-device link: Just fall through and use 683 * the original entry to copy the file over. */ 684 cpio_warnc(0, "Copying file instead"); 685 } else 686 #endif 687 return (0); 688 } 689 690 /* 691 * Make sure we can open the file (if necessary) before 692 * trying to write the header. 693 */ 694 if (archive_entry_filetype(entry) == AE_IFREG) { 695 if (archive_entry_size(entry) > 0) { 696 fd = open(srcpath, O_RDONLY); 697 if (fd < 0) { 698 cpio_warnc(errno, 699 "%s: could not open file", srcpath); 700 goto cleanup; 701 } 702 } 703 } else { 704 archive_entry_set_size(entry, 0); 705 } 706 707 r = archive_write_header(cpio->archive, entry); 708 709 if (r != ARCHIVE_OK) 710 cpio_warnc(archive_errno(cpio->archive), 711 "%s: %s", 712 srcpath, 713 archive_error_string(cpio->archive)); 714 715 if (r == ARCHIVE_FATAL) 716 exit(1); 717 718 if (r >= ARCHIVE_WARN && fd >= 0) { 719 bytes_read = read(fd, cpio->buff, cpio->buff_size); 720 while (bytes_read > 0) { 721 r = archive_write_data(cpio->archive, 722 cpio->buff, bytes_read); 723 if (r < 0) 724 cpio_errc(1, archive_errno(cpio->archive), 725 archive_error_string(cpio->archive)); 726 if (r < bytes_read) { 727 cpio_warnc(0, 728 "Truncated write; file may have grown while being archived."); 729 } 730 bytes_read = read(fd, cpio->buff, cpio->buff_size); 731 } 732 } 733 734 fd = restore_time(cpio, entry, srcpath, fd); 735 736 cleanup: 737 if (cpio->verbose) 738 fprintf(stderr,"\n"); 739 if (fd >= 0) 740 close(fd); 741 return (0); 742 } 743 744 static int 745 restore_time(struct cpio *cpio, struct archive_entry *entry, 746 const char *name, int fd) 747 { 748 #ifndef HAVE_UTIMES 749 static int warned = 0; 750 751 (void)cpio; /* UNUSED */ 752 (void)entry; /* UNUSED */ 753 (void)name; /* UNUSED */ 754 755 if (!warned) 756 cpio_warnc(0, "Can't restore access times on this platform"); 757 warned = 1; 758 return (fd); 759 #else 760 #if defined(_WIN32) && !defined(__CYGWIN__) 761 struct __timeval times[2]; 762 #else 763 struct timeval times[2]; 764 #endif 765 766 if (!cpio->option_atime_restore) 767 return (fd); 768 769 times[1].tv_sec = archive_entry_mtime(entry); 770 times[1].tv_usec = archive_entry_mtime_nsec(entry) / 1000; 771 772 times[0].tv_sec = archive_entry_atime(entry); 773 times[0].tv_usec = archive_entry_atime_nsec(entry) / 1000; 774 775 #ifdef HAVE_FUTIMES 776 if (fd >= 0 && futimes(fd, times) == 0) 777 return (fd); 778 #endif 779 /* 780 * Some platform cannot restore access times if the file descriptor 781 * is still opened. 782 */ 783 if (fd >= 0) { 784 close(fd); 785 fd = -1; 786 } 787 788 #ifdef HAVE_LUTIMES 789 if (lutimes(name, times) != 0) 790 #else 791 if (!S_ISLNK(archive_entry_mode(entry)) && utimes(name, times) != 0) 792 #endif 793 cpio_warnc(errno, "Can't update time for %s", name); 794 #endif 795 return (fd); 796 } 797 798 799 static void 800 mode_in(struct cpio *cpio) 801 { 802 struct archive *a; 803 struct archive_entry *entry; 804 struct archive *ext; 805 const char *destpath; 806 unsigned long blocks; 807 int r; 808 809 ext = archive_write_disk_new(); 810 if (ext == NULL) 811 cpio_errc(1, 0, "Couldn't allocate restore object"); 812 r = archive_write_disk_set_options(ext, cpio->extract_flags); 813 if (r != ARCHIVE_OK) 814 cpio_errc(1, 0, archive_error_string(ext)); 815 a = archive_read_new(); 816 if (a == NULL) 817 cpio_errc(1, 0, "Couldn't allocate archive object"); 818 archive_read_support_compression_all(a); 819 archive_read_support_format_all(a); 820 821 if (archive_read_open_file(a, cpio->filename, cpio->bytes_per_block)) 822 cpio_errc(1, archive_errno(a), 823 archive_error_string(a)); 824 for (;;) { 825 r = archive_read_next_header(a, &entry); 826 if (r == ARCHIVE_EOF) 827 break; 828 if (r != ARCHIVE_OK) { 829 cpio_errc(1, archive_errno(a), 830 archive_error_string(a)); 831 } 832 if (excluded(cpio, archive_entry_pathname(entry))) 833 continue; 834 if (cpio->option_rename) { 835 destpath = cpio_rename(archive_entry_pathname(entry)); 836 archive_entry_set_pathname(entry, destpath); 837 } else 838 destpath = archive_entry_pathname(entry); 839 if (destpath == NULL) 840 continue; 841 if (cpio->verbose) 842 fprintf(stdout, "%s\n", destpath); 843 if (cpio->uid_override >= 0) 844 archive_entry_set_uid(entry, cpio->uid_override); 845 if (cpio->gid_override >= 0) 846 archive_entry_set_gid(entry, cpio->gid_override); 847 r = archive_write_header(ext, entry); 848 if (r != ARCHIVE_OK) { 849 fprintf(stderr, "%s: %s\n", 850 archive_entry_pathname(entry), 851 archive_error_string(ext)); 852 } else if (archive_entry_size(entry) > 0) { 853 r = copy_data(a, ext); 854 } 855 } 856 r = archive_read_close(a); 857 if (r != ARCHIVE_OK) 858 cpio_errc(1, 0, archive_error_string(a)); 859 r = archive_write_close(ext); 860 if (r != ARCHIVE_OK) 861 cpio_errc(1, 0, archive_error_string(ext)); 862 if (!cpio->quiet) { 863 blocks = (archive_position_uncompressed(a) + 511) 864 / 512; 865 fprintf(stderr, "%lu %s\n", blocks, 866 blocks == 1 ? "block" : "blocks"); 867 } 868 archive_read_finish(a); 869 archive_write_finish(ext); 870 exit(0); 871 } 872 873 static int 874 copy_data(struct archive *ar, struct archive *aw) 875 { 876 int r; 877 size_t size; 878 const void *block; 879 off_t offset; 880 881 for (;;) { 882 r = archive_read_data_block(ar, &block, &size, &offset); 883 if (r == ARCHIVE_EOF) 884 return (ARCHIVE_OK); 885 if (r != ARCHIVE_OK) { 886 cpio_warnc(archive_errno(ar), 887 "%s", archive_error_string(ar)); 888 return (r); 889 } 890 r = archive_write_data_block(aw, block, size, offset); 891 if (r != ARCHIVE_OK) { 892 cpio_warnc(archive_errno(aw), 893 archive_error_string(aw)); 894 return (r); 895 } 896 } 897 } 898 899 static void 900 mode_list(struct cpio *cpio) 901 { 902 struct archive *a; 903 struct archive_entry *entry; 904 unsigned long blocks; 905 int r; 906 907 a = archive_read_new(); 908 if (a == NULL) 909 cpio_errc(1, 0, "Couldn't allocate archive object"); 910 archive_read_support_compression_all(a); 911 archive_read_support_format_all(a); 912 913 if (archive_read_open_file(a, cpio->filename, cpio->bytes_per_block)) 914 cpio_errc(1, archive_errno(a), 915 archive_error_string(a)); 916 for (;;) { 917 r = archive_read_next_header(a, &entry); 918 if (r == ARCHIVE_EOF) 919 break; 920 if (r != ARCHIVE_OK) { 921 cpio_errc(1, archive_errno(a), 922 archive_error_string(a)); 923 } 924 if (excluded(cpio, archive_entry_pathname(entry))) 925 continue; 926 if (cpio->verbose) 927 list_item_verbose(cpio, entry); 928 else 929 fprintf(stdout, "%s\n", archive_entry_pathname(entry)); 930 } 931 r = archive_read_close(a); 932 if (r != ARCHIVE_OK) 933 cpio_errc(1, 0, archive_error_string(a)); 934 if (!cpio->quiet) { 935 blocks = (archive_position_uncompressed(a) + 511) 936 / 512; 937 fprintf(stderr, "%lu %s\n", blocks, 938 blocks == 1 ? "block" : "blocks"); 939 } 940 archive_read_finish(a); 941 exit(0); 942 } 943 944 /* 945 * Display information about the current file. 946 * 947 * The format here roughly duplicates the output of 'ls -l'. 948 * This is based on SUSv2, where 'tar tv' is documented as 949 * listing additional information in an "unspecified format," 950 * and 'pax -l' is documented as using the same format as 'ls -l'. 951 */ 952 static void 953 list_item_verbose(struct cpio *cpio, struct archive_entry *entry) 954 { 955 char size[32]; 956 char date[32]; 957 char uids[16], gids[16]; 958 const char *uname, *gname; 959 FILE *out = stdout; 960 const struct stat *st; 961 const char *fmt; 962 time_t tim; 963 static time_t now; 964 965 st = archive_entry_stat(entry); 966 967 if (!now) 968 time(&now); 969 970 if (cpio->option_numeric_uid_gid) { 971 /* Format numeric uid/gid for display. */ 972 snprintf(uids, sizeof(uids), "%jd", 973 (intmax_t)archive_entry_uid(entry)); 974 uname = uids; 975 snprintf(gids, sizeof(gids), "%jd", 976 (intmax_t)archive_entry_gid(entry)); 977 gname = gids; 978 } else { 979 /* Use uname if it's present, else lookup name from uid. */ 980 uname = archive_entry_uname(entry); 981 if (uname == NULL) 982 uname = lookup_uname(cpio, archive_entry_uid(entry)); 983 /* Use gname if it's present, else lookup name from gid. */ 984 gname = archive_entry_gname(entry); 985 if (gname == NULL) 986 gname = lookup_gname(cpio, archive_entry_gid(entry)); 987 } 988 989 /* Print device number or file size. */ 990 if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode)) { 991 snprintf(size, sizeof(size), "%lu,%lu", 992 (unsigned long)major(st->st_rdev), 993 (unsigned long)minor(st->st_rdev)); /* ls(1) also casts here. */ 994 } else { 995 snprintf(size, sizeof(size), CPIO_FILESIZE_PRINTF, 996 (CPIO_FILESIZE_TYPE)st->st_size); 997 } 998 999 /* Format the time using 'ls -l' conventions. */ 1000 tim = (time_t)st->st_mtime; 1001 #if defined(_WIN32) && !defined(__CYGWIN__) 1002 /* Windows' strftime function does not support %e format. */ 1003 if (abs(tim - now) > (365/2)*86400) 1004 fmt = cpio->day_first ? "%d %b %Y" : "%b %d %Y"; 1005 else 1006 fmt = cpio->day_first ? "%d %b %H:%M" : "%b %d %H:%M"; 1007 #else 1008 if (abs(tim - now) > (365/2)*86400) 1009 fmt = cpio->day_first ? "%e %b %Y" : "%b %e %Y"; 1010 else 1011 fmt = cpio->day_first ? "%e %b %H:%M" : "%b %e %H:%M"; 1012 #endif 1013 strftime(date, sizeof(date), fmt, localtime(&tim)); 1014 1015 fprintf(out, "%s%3d %-8s %-8s %8s %12s %s", 1016 archive_entry_strmode(entry), 1017 archive_entry_nlink(entry), 1018 uname, gname, size, date, 1019 archive_entry_pathname(entry)); 1020 1021 /* Extra information for links. */ 1022 if (archive_entry_hardlink(entry)) /* Hard link */ 1023 fprintf(out, " link to %s", archive_entry_hardlink(entry)); 1024 else if (archive_entry_symlink(entry)) /* Symbolic link */ 1025 fprintf(out, " -> %s", archive_entry_symlink(entry)); 1026 fprintf(out, "\n"); 1027 } 1028 1029 static void 1030 mode_pass(struct cpio *cpio, const char *destdir) 1031 { 1032 unsigned long blocks; 1033 struct line_reader *lr; 1034 const char *p; 1035 int r; 1036 1037 /* Ensure target dir has a trailing '/' to simplify path surgery. */ 1038 cpio->destdir = malloc(strlen(destdir) + 8); 1039 strcpy(cpio->destdir, destdir); 1040 if (destdir[strlen(destdir) - 1] != '/') 1041 strcat(cpio->destdir, "/"); 1042 1043 cpio->archive = archive_write_disk_new(); 1044 if (cpio->archive == NULL) 1045 cpio_errc(1, 0, "Failed to allocate archive object"); 1046 r = archive_write_disk_set_options(cpio->archive, cpio->extract_flags); 1047 if (r != ARCHIVE_OK) 1048 cpio_errc(1, 0, archive_error_string(cpio->archive)); 1049 cpio->linkresolver = archive_entry_linkresolver_new(); 1050 archive_write_disk_set_standard_lookup(cpio->archive); 1051 lr = process_lines_init("-", cpio->line_separator); 1052 while ((p = process_lines_next(lr)) != NULL) 1053 file_to_archive(cpio, p); 1054 process_lines_free(lr); 1055 1056 archive_entry_linkresolver_free(cpio->linkresolver); 1057 r = archive_write_close(cpio->archive); 1058 if (r != ARCHIVE_OK) 1059 cpio_errc(1, 0, archive_error_string(cpio->archive)); 1060 1061 if (!cpio->quiet) { 1062 blocks = (archive_position_uncompressed(cpio->archive) + 511) 1063 / 512; 1064 fprintf(stderr, "%lu %s\n", blocks, 1065 blocks == 1 ? "block" : "blocks"); 1066 } 1067 1068 archive_write_finish(cpio->archive); 1069 } 1070 1071 /* 1072 * Prompt for a new name for this entry. Returns a pointer to the 1073 * new name or NULL if the entry should not be copied. This 1074 * implements the semantics defined in POSIX.1-1996, which specifies 1075 * that an input of '.' means the name should be unchanged. GNU cpio 1076 * treats '.' as a literal new name. 1077 */ 1078 static const char * 1079 cpio_rename(const char *name) 1080 { 1081 static char buff[1024]; 1082 FILE *t; 1083 char *p, *ret; 1084 1085 t = fopen("/dev/tty", "r+"); 1086 if (t == NULL) 1087 return (name); 1088 fprintf(t, "%s (Enter/./(new name))? ", name); 1089 fflush(t); 1090 1091 p = fgets(buff, sizeof(buff), t); 1092 fclose(t); 1093 if (p == NULL) 1094 /* End-of-file is a blank line. */ 1095 return (NULL); 1096 1097 while (*p == ' ' || *p == '\t') 1098 ++p; 1099 if (*p == '\n' || *p == '\0') 1100 /* Empty line. */ 1101 return (NULL); 1102 if (*p == '.' && p[1] == '\n') 1103 /* Single period preserves original name. */ 1104 return (name); 1105 ret = p; 1106 /* Trim the final newline. */ 1107 while (*p != '\0' && *p != '\n') 1108 ++p; 1109 /* Overwrite the final \n with a null character. */ 1110 *p = '\0'; 1111 return (ret); 1112 } 1113 1114 1115 /* 1116 * Read lines from file and do something with each one. If option_null 1117 * is set, lines are terminated with zero bytes; otherwise, they're 1118 * terminated with newlines. 1119 * 1120 * This uses a self-sizing buffer to handle arbitrarily-long lines. 1121 */ 1122 struct line_reader { 1123 FILE *f; 1124 char *buff, *buff_end, *line_start, *line_end, *p; 1125 char *pathname; 1126 size_t buff_length; 1127 int separator; 1128 int ret; 1129 }; 1130 1131 struct line_reader * 1132 process_lines_init(const char *pathname, char separator) 1133 { 1134 struct line_reader *lr; 1135 1136 lr = calloc(1, sizeof(*lr)); 1137 if (lr == NULL) 1138 cpio_errc(1, ENOMEM, "Can't open %s", pathname); 1139 1140 lr->separator = separator; 1141 lr->pathname = strdup(pathname); 1142 1143 if (strcmp(pathname, "-") == 0) 1144 lr->f = stdin; 1145 else 1146 lr->f = fopen(pathname, "r"); 1147 if (lr->f == NULL) 1148 cpio_errc(1, errno, "Couldn't open %s", pathname); 1149 lr->buff_length = 8192; 1150 lr->buff = malloc(lr->buff_length); 1151 if (lr->buff == NULL) 1152 cpio_errc(1, ENOMEM, "Can't read %s", pathname); 1153 lr->line_start = lr->line_end = lr->buff_end = lr->buff; 1154 1155 return (lr); 1156 } 1157 1158 const char * 1159 process_lines_next(struct line_reader *lr) 1160 { 1161 size_t bytes_wanted, bytes_read, new_buff_size; 1162 char *line_start, *p; 1163 1164 for (;;) { 1165 /* If there's a line in the buffer, return it immediately. */ 1166 while (lr->line_end < lr->buff_end) { 1167 if (*lr->line_end == lr->separator) { 1168 *lr->line_end = '\0'; 1169 line_start = lr->line_start; 1170 lr->line_start = lr->line_end + 1; 1171 lr->line_end = lr->line_start; 1172 return (line_start); 1173 } else 1174 lr->line_end++; 1175 } 1176 1177 /* If we're at end-of-file, process the final data. */ 1178 if (lr->f == NULL) { 1179 /* If there's more text, return one last line. */ 1180 if (lr->line_end > lr->line_start) { 1181 *lr->line_end = '\0'; 1182 line_start = lr->line_start; 1183 lr->line_start = lr->line_end + 1; 1184 lr->line_end = lr->line_start; 1185 return (line_start); 1186 } 1187 /* Otherwise, we're done. */ 1188 return (NULL); 1189 } 1190 1191 /* Buffer only has part of a line. */ 1192 if (lr->line_start > lr->buff) { 1193 /* Move a leftover fractional line to the beginning. */ 1194 memmove(lr->buff, lr->line_start, 1195 lr->buff_end - lr->line_start); 1196 lr->buff_end -= lr->line_start - lr->buff; 1197 lr->line_end -= lr->line_start - lr->buff; 1198 lr->line_start = lr->buff; 1199 } else { 1200 /* Line is too big; enlarge the buffer. */ 1201 new_buff_size = lr->buff_length * 2; 1202 if (new_buff_size <= lr->buff_length) 1203 cpio_errc(1, ENOMEM, 1204 "Line too long in %s", lr->pathname); 1205 lr->buff_length = new_buff_size; 1206 p = realloc(lr->buff, new_buff_size); 1207 if (p == NULL) 1208 cpio_errc(1, ENOMEM, 1209 "Line too long in %s", lr->pathname); 1210 lr->buff_end = p + (lr->buff_end - lr->buff); 1211 lr->line_end = p + (lr->line_end - lr->buff); 1212 lr->line_start = lr->buff = p; 1213 } 1214 1215 /* Get some more data into the buffer. */ 1216 bytes_wanted = lr->buff + lr->buff_length - lr->buff_end; 1217 bytes_read = fread(lr->buff_end, 1, bytes_wanted, lr->f); 1218 lr->buff_end += bytes_read; 1219 1220 if (ferror(lr->f)) 1221 cpio_errc(1, errno, "Can't read %s", lr->pathname); 1222 if (feof(lr->f)) { 1223 if (lr->f != stdin) 1224 fclose(lr->f); 1225 lr->f = NULL; 1226 } 1227 } 1228 } 1229 1230 void 1231 process_lines_free(struct line_reader *lr) 1232 { 1233 free(lr->buff); 1234 free(lr->pathname); 1235 free(lr); 1236 } 1237 1238 static void 1239 free_cache(struct name_cache *cache) 1240 { 1241 size_t i; 1242 1243 if (cache != NULL) { 1244 for (i = 0; i < cache->size; i++) 1245 free(cache->cache[i].name); 1246 free(cache); 1247 } 1248 } 1249 1250 /* 1251 * Lookup uname/gname from uid/gid, return NULL if no match. 1252 */ 1253 static const char * 1254 lookup_name(struct cpio *cpio, struct name_cache **name_cache_variable, 1255 int (*lookup_fn)(struct cpio *, const char **, id_t), id_t id) 1256 { 1257 char asnum[16]; 1258 struct name_cache *cache; 1259 const char *name; 1260 int slot; 1261 1262 1263 if (*name_cache_variable == NULL) { 1264 *name_cache_variable = malloc(sizeof(struct name_cache)); 1265 if (*name_cache_variable == NULL) 1266 cpio_errc(1, ENOMEM, "No more memory"); 1267 memset(*name_cache_variable, 0, sizeof(struct name_cache)); 1268 (*name_cache_variable)->size = name_cache_size; 1269 } 1270 1271 cache = *name_cache_variable; 1272 cache->probes++; 1273 1274 slot = id % cache->size; 1275 if (cache->cache[slot].name != NULL) { 1276 if (cache->cache[slot].id == id) { 1277 cache->hits++; 1278 return (cache->cache[slot].name); 1279 } 1280 free(cache->cache[slot].name); 1281 cache->cache[slot].name = NULL; 1282 } 1283 1284 if (lookup_fn(cpio, &name, id) == 0) { 1285 if (name == NULL || name[0] == '\0') { 1286 /* If lookup failed, format it as a number. */ 1287 snprintf(asnum, sizeof(asnum), "%u", (unsigned)id); 1288 name = asnum; 1289 } 1290 cache->cache[slot].name = strdup(name); 1291 if (cache->cache[slot].name != NULL) { 1292 cache->cache[slot].id = id; 1293 return (cache->cache[slot].name); 1294 } 1295 /* 1296 * Conveniently, NULL marks an empty slot, so 1297 * if the strdup() fails, we've just failed to 1298 * cache it. No recovery necessary. 1299 */ 1300 } 1301 return (NULL); 1302 } 1303 1304 static const char * 1305 lookup_uname(struct cpio *cpio, uid_t uid) 1306 { 1307 return (lookup_name(cpio, &cpio->uname_cache, 1308 &lookup_uname_helper, (id_t)uid)); 1309 } 1310 1311 static int 1312 lookup_uname_helper(struct cpio *cpio, const char **name, id_t id) 1313 { 1314 struct passwd *pwent; 1315 1316 (void)cpio; /* UNUSED */ 1317 1318 errno = 0; 1319 pwent = getpwuid((uid_t)id); 1320 if (pwent == NULL) { 1321 *name = NULL; 1322 if (errno != 0) 1323 cpio_warnc(errno, "getpwuid(%d) failed", id); 1324 return (errno); 1325 } 1326 1327 *name = pwent->pw_name; 1328 return (0); 1329 } 1330 1331 static const char * 1332 lookup_gname(struct cpio *cpio, gid_t gid) 1333 { 1334 return (lookup_name(cpio, &cpio->gname_cache, 1335 &lookup_gname_helper, (id_t)gid)); 1336 } 1337 1338 static int 1339 lookup_gname_helper(struct cpio *cpio, const char **name, id_t id) 1340 { 1341 struct group *grent; 1342 1343 (void)cpio; /* UNUSED */ 1344 1345 errno = 0; 1346 grent = getgrgid((gid_t)id); 1347 if (grent == NULL) { 1348 *name = NULL; 1349 if (errno != 0) 1350 cpio_warnc(errno, "getgrgid(%d) failed", id); 1351 return (errno); 1352 } 1353 1354 *name = grent->gr_name; 1355 return (0); 1356 } 1357