archival/cpio.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * Mini cpio implementation for busybox
   4  *
   5  * Copyright (C) 2001 by Glenn McGrath
   6  *
   7  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
   8  *
   9  * Limitations:
  10  * Doesn't check CRC's
  11  * Only supports new ASCII and CRC formats
  12  */
  13 //config:config CPIO
  14 //config:       bool "cpio (14 kb)"
  15 //config:       default y
  16 //config:       help
  17 //config:       cpio is an archival utility program used to create, modify, and
  18 //config:       extract contents from archives.
  19 //config:       cpio has 110 bytes of overheads for every stored file.
  20 //config:
  21 //config:       This implementation of cpio can extract cpio archives created in the
  22 //config:       "newc" or "crc" format.
  23 //config:
  24 //config:       Unless you have a specific application which requires cpio, you
  25 //config:       should probably say N here.
  26 //config:
  27 //config:config FEATURE_CPIO_O
  28 //config:       bool "Support archive creation"
  29 //config:       default y
  30 //config:       depends on CPIO
  31 //config:       help
  32 //config:       This implementation of cpio can create cpio archives in the "newc"
  33 //config:       format only.
  34 //config:
  35 //config:config FEATURE_CPIO_P
  36 //config:       bool "Support passthrough mode"
  37 //config:       default y
  38 //config:       depends on FEATURE_CPIO_O
  39 //config:       help
  40 //config:       Passthrough mode. Rarely used.
  41
  42 //applet:IF_CPIO(APPLET(cpio, BB_DIR_BIN, BB_SUID_DROP))
  43
  44 //kbuild:lib-$(CONFIG_CPIO) += cpio.o
  45
  46 //usage:#define cpio_trivial_usage
  47 //usage:       "[-dmvu] [-F FILE] [-R USER[:GRP]]" IF_FEATURE_CPIO_O(" [-H newc]")
  48 //usage:       " [-ti"IF_FEATURE_CPIO_O("o")"]" IF_FEATURE_CPIO_P(" [-p DIR]")
  49 //usage:       " [EXTR_FILE]..."
  50 //usage:#define cpio_full_usage "\n\n"
  51 //usage:       "Extract (-i) or list (-t) files from a cpio archive"
  52 //usage:        IF_FEATURE_CPIO_O(", or"
  53 //usage:     "\ntake file list from stdin and create an archive (-o)"
  54 //usage:                IF_FEATURE_CPIO_P(" or copy files (-p)")
  55 //usage:        )
  56 //usage:     "\n"
  57 //usage:     "\nMain operation mode:"
  58 //usage:     "\n        -t      List"
  59 //usage:     "\n        -i      Extract EXTR_FILEs (or all)"
  60 //usage:        IF_FEATURE_CPIO_O(
  61 //usage:     "\n        -o      Create (requires -H newc)"
  62 //usage:        )
  63 //usage:        IF_FEATURE_CPIO_P(
  64 //usage:     "\n        -p DIR  Copy files to DIR"
  65 //usage:        )
  66 //usage:     "\nOptions:"
  67 //usage:     "\n        -d      Make leading directories"
  68 //usage:     "\n        -m      Preserve mtime"
  69 //usage:     "\n        -v      Verbose"
  70 //usage:     "\n        -u      Overwrite"
  71 //usage:     "\n        -F FILE Input (-t,-i,-p) or output (-o) file"
  72 //usage:     "\n        -R USER[:GRP]   Set owner of created files"
  73 //usage:        IF_FEATURE_CPIO_O(
  74 //usage:     "\n        -H newc Archive format"
  75 //usage:        )
  76
  77 /* GNU cpio 2.9 --help (abridged):
  78
  79  Modes:
  80   -t, --list                 List the archive
  81   -i, --extract              Extract files from an archive
  82   -o, --create               Create the archive
  83   -p, --pass-through         Copy-pass mode
  84
  85  Options valid in any mode:
  86       --block-size=SIZE      I/O block size = SIZE * 512 bytes
  87   -B                         I/O block size = 5120 bytes
  88   -c                         Use the old portable (ASCII) archive format
  89   -C, --io-size=NUMBER       I/O block size in bytes
  90   -f, --nonmatching          Only copy files that do not match given pattern
  91   -F, --file=FILE            Use FILE instead of standard input or output
  92   -H, --format=FORMAT        Use given archive FORMAT
  93   -M, --message=STRING       Print STRING when the end of a volume of the
  94                              backup media is reached
  95   -n, --numeric-uid-gid      If -v, show numeric UID and GID
  96       --quiet                Do not print the number of blocks copied
  97       --rsh-command=COMMAND  Use remote COMMAND instead of rsh
  98   -v, --verbose              Verbosely list the files processed
  99   -V, --dot                  Print a "." for each file processed
 100   -W, --warning=FLAG         Control warning display: 'none','truncate','all';
 101                              multiple options accumulate
 102
 103  Options valid only in --extract mode:
 104   -b, --swap                 Swap both halfwords of words and bytes of
 105                              halfwords in the data (equivalent to -sS)
 106   -r, --rename               Interactively rename files
 107   -s, --swap-bytes           Swap the bytes of each halfword in the files
 108   -S, --swap-halfwords       Swap the halfwords of each word (4 bytes)
 109       --to-stdout            Extract files to standard output
 110   -E, --pattern-file=FILE    Read additional patterns specifying filenames to
 111                              extract or list from FILE
 112       --only-verify-crc      Verify CRC's, don't actually extract the files
 113
 114  Options valid only in --create mode:
 115   -A, --append               Append to an existing archive
 116   -O FILE                    File to use instead of standard output
 117
 118  Options valid only in --pass-through mode:
 119   -l, --link                 Link files instead of copying them, when possible
 120
 121  Options valid in --extract and --create modes:
 122       --absolute-filenames   Do not strip file system prefix components from
 123                              the file names
 124       --no-absolute-filenames Create all files relative to the current dir
 125
 126  Options valid in --create and --pass-through modes:
 127   -0, --null                 A list of filenames is terminated by a NUL
 128   -a, --reset-access-time    Reset the access times of files after reading them
 129   -I FILE                    File to use instead of standard input
 130   -L, --dereference          Dereference symbolic links (copy the files
 131                              that they point to instead of copying the links)
 132   -R, --owner=[USER][:.][GRP] Set owner of created files
 133
 134  Options valid in --extract and --pass-through modes:
 135   -d, --make-directories     Create leading directories where needed
 136   -m, --preserve-modification-time  Retain mtime when creating files
 137       --no-preserve-owner    Do not change the ownership of the files
 138       --sparse               Write files with blocks of zeros as sparse files
 139   -u, --unconditional        Replace all files unconditionally
 140  */
 141
 142 #include "libbb.h"
 143 #include "common_bufsiz.h"
 144 #include "bb_archive.h"
 145
 146 enum {
 147         OPT_EXTRACT            = (1 << 0),
 148         OPT_TEST               = (1 << 1),
 149         OPT_NUL_TERMINATED     = (1 << 2),
 150         OPT_UNCONDITIONAL      = (1 << 3),
 151         OPT_VERBOSE            = (1 << 4),
 152         OPT_CREATE_LEADING_DIR = (1 << 5),
 153         OPT_PRESERVE_MTIME     = (1 << 6),
 154         OPT_DEREF              = (1 << 7),
 155         OPT_FILE               = (1 << 8),
 156         OPT_OWNER              = (1 << 9),
 157         OPTBIT_OWNER = 9,
 158         IF_FEATURE_CPIO_O(OPTBIT_CREATE     ,)
 159         IF_FEATURE_CPIO_O(OPTBIT_FORMAT     ,)
 160         IF_FEATURE_CPIO_P(OPTBIT_PASSTHROUGH,)
 161         IF_LONG_OPTS(     OPTBIT_QUIET      ,)
 162         IF_LONG_OPTS(     OPTBIT_2STDOUT    ,)
 163         OPT_CREATE             = IF_FEATURE_CPIO_O((1 << OPTBIT_CREATE     )) + 0,
 164         OPT_FORMAT             = IF_FEATURE_CPIO_O((1 << OPTBIT_FORMAT     )) + 0,
 165         OPT_PASSTHROUGH        = IF_FEATURE_CPIO_P((1 << OPTBIT_PASSTHROUGH)) + 0,
 166         OPT_QUIET              = IF_LONG_OPTS(     (1 << OPTBIT_QUIET      )) + 0,
 167         OPT_2STDOUT            = IF_LONG_OPTS(     (1 << OPTBIT_2STDOUT    )) + 0,
 168 };
 169
 170 #define OPTION_STR "it0uvdmLF:R:"
 171
 172 struct globals {
 173         struct bb_uidgid_t owner_ugid;
 174 } FIX_ALIASING;
 175 #define G (*(struct globals*)bb_common_bufsiz1)
 176 void BUG_cpio_globals_too_big(void);
 177 #define INIT_G() do { \
 178         setup_common_bufsiz(); \
 179         G.owner_ugid.uid = -1L; \
 180         G.owner_ugid.gid = -1L; \
 181 } while (0)
 182
 183 #if ENABLE_FEATURE_CPIO_O
 184 static off_t cpio_pad4(off_t size)
 185 {
 186         int i;
 187
 188         i = (- size) & 3;
 189         size += i;
 190         while (--i >= 0)
 191                 bb_putchar('\0');
 192         return size;
 193 }
 194
 195 /* Return value will become exit code.
 196  * It's ok to exit instead of return. */
 197 static NOINLINE int cpio_o(void)
 198 {
 199         struct name_s {
 200                 struct name_s *next;
 201                 char name[1];
 202         };
 203         struct inodes_s {
 204                 struct inodes_s *next;
 205                 struct name_s *names;
 206                 struct stat st;
 207         };
 208
 209         struct inodes_s *links = NULL;
 210         off_t bytes = 0; /* output bytes count */
 211
 212         while (1) {
 213                 const char *name;
 214                 char *line;
 215                 struct stat st;
 216
 217                 line = (option_mask32 & OPT_NUL_TERMINATED)
 218                                 ? bb_get_chunk_from_file(stdin, NULL)
 219                                 : xmalloc_fgetline(stdin);
 220
 221                 if (line) {
 222                         /* Strip leading "./[./]..." from the filename */
 223                         name = line;
 224                         while (name[0] == '.' && name[1] == '/') {
 225                                 while (*++name == '/')
 226                                         continue;
 227                         }
 228                         if (!*name) { /* line is empty */
 229                                 free(line);
 230                                 continue;
 231                         }
 232                         if ((option_mask32 & OPT_DEREF)
 233                                         ? stat(name, &st)
 234                                         : lstat(name, &st)
 235                         ) {
 236  abort_cpio_o:
 237                                 bb_simple_perror_msg_and_die(name);
 238                         }
 239
 240                         if (G.owner_ugid.uid != (uid_t)-1L)
 241                                 st.st_uid = G.owner_ugid.uid;
 242                         if (G.owner_ugid.gid != (gid_t)-1L)
 243                                 st.st_gid = G.owner_ugid.gid;
 244
 245                         if (!(S_ISLNK(st.st_mode) || S_ISREG(st.st_mode)))
 246                                 st.st_size = 0; /* paranoia */
 247
 248                         /* Store hardlinks for later processing, dont output them */
 249                         if (!S_ISDIR(st.st_mode) && st.st_nlink > 1) {
 250                                 struct name_s *n;
 251                                 struct inodes_s *l;
 252
 253                                 /* Do we have this hardlink remembered? */
 254                                 l = links;
 255                                 while (1) {
 256                                         if (l == NULL) {
 257                                                 /* Not found: add new item to "links" list */
 258                                                 l = xzalloc(sizeof(*l));
 259                                                 l->st = st;
 260                                                 l->next = links;
 261                                                 links = l;
 262                                                 break;
 263                                         }
 264                                         if (l->st.st_ino == st.st_ino) {
 265                                                 /* found */
 266                                                 break;
 267                                         }
 268                                         l = l->next;
 269                                 }
 270                                 /* Add new name to "l->names" list */
 271                                 n = xmalloc(sizeof(*n) + strlen(name));
 272                                 strcpy(n->name, name);
 273                                 n->next = l->names;
 274                                 l->names = n;
 275
 276                                 free(line);
 277                                 continue;
 278                         }
 279                 } else { /* line == NULL: EOF */
 280  next_link:
 281                         if (links) {
 282                                 /* Output hardlink's data */
 283                                 st = links->st;
 284                                 name = links->names->name;
 285                                 links->names = links->names->next;
 286                                 /* GNU cpio is reported to emit file data
 287                                  * only for the last instance. Mimic that. */
 288                                 if (links->names == NULL)
 289                                         links = links->next;
 290                                 else
 291                                         st.st_size = 0;
 292                                 /* NB: we leak links->names and/or links,
 293                                  * this is intended (we exit soon anyway) */
 294                         } else {
 295                                 /* If no (more) hardlinks to output,
 296                                  * output "trailer" entry */
 297                                 name = cpio_TRAILER;
 298                                 /* st.st_size == 0 is a must, but for uniformity
 299                                  * in the output, we zero out everything */
 300                                 memset(&st, 0, sizeof(st));
 301                                 /* st.st_nlink = 1; - GNU cpio does this */
 302                         }
 303                 }
 304
 305                 bytes += printf("070701"
 306                                 "%08X%08X%08X%08X%08X%08X%08X"
 307                                 "%08X%08X%08X%08X" /* GNU cpio uses uppercase hex */
 308                                 /* strlen+1: */ "%08X"
 309                                 /* chksum: */   "00000000" /* (only for "070702" files) */
 310                                 /* name,NUL: */ "%s%c",
 311                                 (unsigned)(uint32_t) st.st_ino,
 312                                 (unsigned)(uint32_t) st.st_mode,
 313                                 (unsigned)(uint32_t) st.st_uid,
 314                                 (unsigned)(uint32_t) st.st_gid,
 315                                 (unsigned)(uint32_t) st.st_nlink,
 316                                 (unsigned)(uint32_t) st.st_mtime,
 317                                 (unsigned)(uint32_t) st.st_size,
 318                                 (unsigned)(uint32_t) major(st.st_dev),
 319                                 (unsigned)(uint32_t) minor(st.st_dev),
 320                                 (unsigned)(uint32_t) major(st.st_rdev),
 321                                 (unsigned)(uint32_t) minor(st.st_rdev),
 322                                 (unsigned)(strlen(name) + 1),
 323                                 name, '\0');
 324                 bytes = cpio_pad4(bytes);
 325
 326                 if (st.st_size) {
 327                         if (S_ISLNK(st.st_mode)) {
 328                                 char *lpath = xmalloc_readlink_or_warn(name);
 329                                 if (!lpath)
 330                                         goto abort_cpio_o;
 331                                 bytes += printf("%s", lpath);
 332                                 free(lpath);
 333                         } else { /* S_ISREG */
 334                                 int fd = xopen(name, O_RDONLY);
 335                                 fflush_all();
 336                                 /* We must abort if file got shorter too! */
 337                                 bb_copyfd_exact_size(fd, STDOUT_FILENO, st.st_size);
 338                                 bytes += st.st_size;
 339                                 close(fd);
 340                         }
 341                         bytes = cpio_pad4(bytes);
 342                 }
 343
 344                 if (!line) {
 345                         if (name != cpio_TRAILER)
 346                                 goto next_link;
 347                         /* TODO: GNU cpio pads trailer to 512 bytes, do we want that? */
 348                         return EXIT_SUCCESS;
 349                 }
 350
 351                 free(line);
 352         } /* end of "while (1)" */
 353 }
 354 #endif
 355
 356 int cpio_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 357 int cpio_main(int argc UNUSED_PARAM, char **argv)
 358 {
 359         archive_handle_t *archive_handle;
 360         char *cpio_filename;
 361         char *cpio_owner;
 362         IF_FEATURE_CPIO_O(const char *cpio_fmt = "";)
 363         unsigned opt;
 364 #if ENABLE_LONG_OPTS
 365         const char *long_opts =
 366                 "extract\0"      No_argument       "i"
 367                 "list\0"         No_argument       "t"
 368 #if ENABLE_FEATURE_CPIO_O
 369                 "create\0"       No_argument       "o"
 370                 "format\0"       Required_argument "H"
 371 #if ENABLE_FEATURE_CPIO_P
 372                 "pass-through\0" No_argument       "p"
 373 #endif
 374 #endif
 375                 "owner\0"        Required_argument "R"
 376                 "verbose\0"      No_argument       "v"
 377                 "quiet\0"        No_argument       "\xff"
 378                 "to-stdout\0"    No_argument       "\xfe"
 379                 ;
 380 #endif
 381
 382         INIT_G();
 383         archive_handle = init_handle();
 384         /* archive_handle->src_fd = STDIN_FILENO; - done by init_handle */
 385         archive_handle->ah_flags = ARCHIVE_EXTRACT_NEWER;
 386
 387         /* As of now we do not enforce this: */
 388         /* -i,-t,-o,-p are mutually exclusive */
 389         /* -u,-d,-m make sense only with -i or -p */
 390         /* -L makes sense only with -o or -p */
 391
 392 #if !ENABLE_FEATURE_CPIO_O
 393         opt = getopt32long(argv, OPTION_STR, long_opts, &cpio_filename, &cpio_owner);
 394 #else
 395         opt = getopt32long(argv, OPTION_STR "oH:" IF_FEATURE_CPIO_P("p"), long_opts,
 396                        &cpio_filename, &cpio_owner, &cpio_fmt);
 397 #endif
 398         argv += optind;
 399         if (opt & OPT_OWNER) { /* -R */
 400                 parse_chown_usergroup_or_die(&G.owner_ugid, cpio_owner);
 401                 archive_handle->cpio__owner = G.owner_ugid;
 402         }
 403 #if !ENABLE_FEATURE_CPIO_O
 404         if (opt & OPT_FILE) { /* -F */
 405                 xmove_fd(xopen(cpio_filename, O_RDONLY), STDIN_FILENO);
 406         }
 407 #else
 408         if ((opt & (OPT_FILE|OPT_CREATE)) == OPT_FILE) { /* -F without -o */
 409                 xmove_fd(xopen(cpio_filename, O_RDONLY), STDIN_FILENO);
 410         }
 411         if (opt & OPT_PASSTHROUGH) {
 412                 pid_t pid;
 413                 struct fd_pair pp;
 414
 415                 if (argv[0] == NULL)
 416                         bb_show_usage();
 417                 if (opt & OPT_CREATE_LEADING_DIR)
 418                         mkdir(argv[0], 0777);
 419                 /* Crude existence check:
 420                  * close(xopen(argv[0], O_RDONLY | O_DIRECTORY));
 421                  * We can also xopen, fstat, IS_DIR, later fchdir.
 422                  * This would check for existence earlier and cleaner.
 423                  * As it stands now, if we fail xchdir later,
 424                  * child dies on EPIPE, unless it caught
 425                  * a diffrerent problem earlier.
 426                  * This is good enough for now.
 427                  */
 428 #if !BB_MMU
 429                 pp.rd = 3;
 430                 pp.wr = 4;
 431                 if (!re_execed) {
 432                         close(3);
 433                         close(4);
 434                         xpiped_pair(pp);
 435                 }
 436 #else
 437                 xpiped_pair(pp);
 438 #endif
 439                 pid = fork_or_rexec(argv - optind);
 440                 if (pid == 0) { /* child */
 441                         close(pp.rd);
 442                         xmove_fd(pp.wr, STDOUT_FILENO);
 443                         goto dump;
 444                 }
 445                 /* parent */
 446                 USE_FOR_NOMMU(argv[-optind][0] &= 0x7f); /* undo fork_or_rexec() damage */
 447                 xchdir(*argv++);
 448                 close(pp.wr);
 449                 xmove_fd(pp.rd, STDIN_FILENO);
 450                 //opt &= ~OPT_PASSTHROUGH;
 451                 opt |= OPT_EXTRACT;
 452                 goto skip;
 453         }
 454         /* -o */
 455         if (opt & OPT_CREATE) {
 456                 if (cpio_fmt[0] != 'n') /* we _require_ "-H newc" */
 457                         bb_show_usage();
 458                 if (opt & OPT_FILE) {
 459                         xmove_fd(xopen(cpio_filename, O_WRONLY | O_CREAT | O_TRUNC), STDOUT_FILENO);
 460                 }
 461  dump:
 462                 return cpio_o();
 463         }
 464  skip:
 465 #endif
 466
 467         /* One of either extract or test options must be given */
 468         if ((opt & (OPT_TEST | OPT_EXTRACT)) == 0) {
 469                 bb_show_usage();
 470         }
 471
 472         if (opt & OPT_TEST) {
 473                 /* if both extract and test options are given, ignore extract option */
 474                 opt &= ~OPT_EXTRACT;
 475                 archive_handle->action_header = header_list;
 476         }
 477         if (opt & OPT_EXTRACT) {
 478                 archive_handle->action_data = data_extract_all;
 479                 if (opt & OPT_2STDOUT)
 480                         archive_handle->action_data = data_extract_to_stdout;
 481         }
 482         if (opt & OPT_UNCONDITIONAL) {
 483                 archive_handle->ah_flags |= ARCHIVE_UNLINK_OLD;
 484                 archive_handle->ah_flags &= ~ARCHIVE_EXTRACT_NEWER;
 485         }
 486         if (opt & OPT_VERBOSE) {
 487                 if (archive_handle->action_header == header_list) {
 488                         archive_handle->action_header = header_verbose_list;
 489                 } else {
 490                         archive_handle->action_header = header_list;
 491                 }
 492         }
 493         if (opt & OPT_CREATE_LEADING_DIR) {
 494                 archive_handle->ah_flags |= ARCHIVE_CREATE_LEADING_DIRS;
 495         }
 496         if (opt & OPT_PRESERVE_MTIME) {
 497                 archive_handle->ah_flags |= ARCHIVE_RESTORE_DATE;
 498         }
 499
 500         while (*argv) {
 501                 archive_handle->filter = filter_accept_list;
 502                 llist_add_to(&archive_handle->accept, *argv);
 503                 argv++;
 504         }
 505
 506         /* see get_header_cpio */
 507         archive_handle->cpio__blocks = (off_t)-1;
 508         while (get_header_cpio(archive_handle) == EXIT_SUCCESS)
 509                 continue;
 510
 511         if (archive_handle->cpio__blocks != (off_t)-1
 512          && !(opt & OPT_QUIET)
 513         ) {
 514                 fprintf(stderr, "%"OFF_FMT"u blocks\n", archive_handle->cpio__blocks);
 515         }
 516
 517         return EXIT_SUCCESS;
 518 }