contrib/libarchive/cpio/cpio.c

   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 }