text: /* cpio.c - a basic cpio
   *
   * Copyright 2013 Isaac Dunham <ibid.ag@gmail.com>
   * Copyright 2015 Frontier Silicon Ltd.
   *
   * see https://www.kernel.org/doc/Documentation/early-userspace/buffer-format.txt
   * and http://refspecs.linuxfoundation.org/LSB_4.1.0/LSB-Core-generic/LSB-Core-generic/cpio.html
   * and http://pubs.opengroup.org/onlinepubs/7908799/xcu/cpio.html
   *
   * Yes, that's SUSv2, newer versions removed it, but RPM and initramfs use
   * this archive format. We implement (only) the modern "-H newc" variant which
   * expanded headers to 110 bytes (first field 6 bytes, rest are 8).
   * In order: magic ino mode uid gid nlink mtime filesize devmajor devminor
   * rdevmajor rdevminor namesize check
   * This is the equivalent of mode -H newc in other implementations.
   *
   * todo: export/import linux file list text format ala gen_initramfs_list.sh
  
  USE_CPIO(NEWTOY(cpio, "(quiet)(no-preserve-owner)md(make-directories)uH:p|i|t|F:v(verbose)o|[!pio][!pot][!pF]", TOYFLAG_BIN))
  
  config CPIO
    bool "cpio"
    default y
    help
      usage: cpio -{o|t|i|p DEST} [-v] [--verbose] [-F FILE] [--no-preserve-owner]
             [ignored: -m -H newc]
  
      Copy files into and out of a "newc" format cpio archive.
  
      -F FILE	Use archive FILE instead of stdin/stdout
      -p DEST	Copy-pass mode, copy stdin file list to directory DEST
      -i	Extract from archive into file system (stdin=archive)
      -o	Create archive (stdin=list of files, stdout=archive)
      -t	Test files (list only, stdin=archive, stdout=list of files)
      -d	Create directories if needed
      -u	unlink existing files when extracting
      -v	Verbose
      --no-preserve-owner (don't set ownership during extract)
  */
  
  #define FOR_cpio
  #include "toys.h"
  
  GLOBALS(
    char *F, *H;
  )
  
  // Read strings, tail padded to 4 byte alignment. Argument "align" is amount
  // by which start of string isn't aligned (usually 0, but header is 110 bytes
  // which is 2 bytes off because the first field wasn't expanded from 6 to 8).
  static char *strpad(int fd, unsigned len, unsigned align)
  {
    char *str;
  
    align = (align + len) & 3;
    if (align) len += (4-align);
    xreadall(fd, str = xmalloc(len+1), len);
    str[len]=0; // redundant, in case archive is bad
  
    return str;
  }
  
  //convert hex to uint; mostly to allow using bits of non-terminated strings
  static unsigned x8u(char *hex)
  {
    unsigned val, inpos = 8, outpos;
    char pattern[6];
  
    while (*hex == '0') {
      hex++;
      if (!--inpos) return 0;
    }
    // Because scanf gratuitously treats %*X differently than printf does.
    sprintf(pattern, "%%%dX%%n", inpos);
    sscanf(hex, pattern, &val, &outpos);
    if (inpos != outpos) error_exit("bad hex");
  
    return val;
  }
  
  void cpio_main(void)
  {
    // Subtle bit: FLAG_o is 1 so we can just use it to select stdin/stdout.
    int pipe, afd = FLAG(o), empty = 1;
    pid_t pid = 0;
  
    // In passthrough mode, parent stays in original dir and generates archive
    // to pipe, child does chdir to new dir and reads archive from stdin (pipe).
    if (FLAG(p)) {
      if (FLAG(d)) {
        if (!*toys.optargs) error_exit("need directory for -p");
        if (mkdir(*toys.optargs, 0700) == -1 && errno != EEXIST)
          perror_exit("mkdir %s", *toys.optargs);
      }
      if (toys.stacktop) {
        // xpopen() doesn't return from child due to vfork(), instead restarts
        // with !toys.stacktop
        pid = xpopen(0, &pipe, 0);
        afd = pipe;
      } else {
        // child
        toys.optflags |= FLAG_i;
        xchdir(*toys.optargs);
      }
    }
  
    if (TT.F) {
      int perm = FLAG(o) ? O_CREAT|O_WRONLY|O_TRUNC : O_RDONLY;
  
      afd = xcreate(TT.F, perm, 0644);
    }
  
    // read cpio archive
  
    if (FLAG(i) || FLAG(t)) for (;; empty = 0) {
      char *name, *tofree, *data;
      unsigned mode, uid, gid, timestamp;
      int test = FLAG(t), err = 0, size = 0, len;
  
      // read header, skipping arbitrary leading NUL bytes (concatenated archives)
      for (;;) {
        if (1>(len = readall(afd, toybuf+size, 110-size))) break;
        if (size || *toybuf) {
          size += len;
          break;
        }
        for (size = 0; size<len; size++) if (toybuf[size]) break;
        memmove(toybuf, toybuf+size, len-size);
        size = len-size;
      }
      if (!size) {
        if (empty) error_exit("empty archive");
        else break;
      }
      if (size != 110 || memcmp(toybuf, "070701", 6)) error_exit("bad header");
      tofree = name = strpad(afd, x8u(toybuf+94), 110);
      if (!strcmp("TRAILER!!!", name)) {
        free(tofree);
        continue;
      }
  
      // If you want to extract absolute paths, "cd /" and run cpio.
      while (*name == '/') name++;
      // TODO: remove .. entries
  
      size = x8u(toybuf+54);
      mode = x8u(toybuf+14);
      uid = x8u(toybuf+22);
      gid = x8u(toybuf+30);
      timestamp = x8u(toybuf+46); // unsigned 32 bit, so year 2100 problem
  
      // (This output is unaffected by --quiet.)
      if (FLAG(t) || FLAG(v)) puts(name);
  
      if (FLAG(u) && !test) if (unlink(name) && errno == EISDIR) rmdir(name);
  
      if (!test && FLAG(d) && strrchr(name, '/') && mkpath(name)) {
        perror_msg("mkpath '%s'", name);
        test++;
      }
  
      // Consume entire record even if it couldn't create file, so we're
      // properly aligned with next file.
  
      if (S_ISDIR(mode)) {
        if (!test) err = mkdir(name, mode) && !FLAG(u);
      } else if (S_ISLNK(mode)) {
        data = strpad(afd, size, 0);
        if (!test) {
          err = symlink(data, name);
          // Can't get a filehandle to a symlink, so do special chown
          if (!err && !geteuid() && !FLAG(no_preserve_owner))
            err = lchown(name, uid, gid);
        }
        free(data);
      } else if (S_ISREG(mode)) {
        int fd = test ? 0 : open(name, O_CREAT|O_WRONLY|O_EXCL|O_NOFOLLOW, mode);
  
        // If write fails, we still need to read/discard data to continue with
        // archive. Since doing so overwrites errno, report error now
        if (fd < 0) {
          perror_msg("create %s", name);
          test++;
        }
  
        data = toybuf;
        while (size) {
          if (size < sizeof(toybuf)) data = strpad(afd, size, 0);
          else xreadall(afd, toybuf, sizeof(toybuf));
          if (!test) xwrite(fd, data, data == toybuf ? sizeof(toybuf) : size);
          if (data != toybuf) {
            free(data);
            break;
          }
          size -= sizeof(toybuf);
        }
  
        if (!test) {
          // set owner, restore dropped suid bit
          if (!geteuid() && !FLAG(no_preserve_owner)) {
            err = fchown(fd, uid, gid);
            if (!err) err = fchmod(fd, mode);
          }
          close(fd);
        }
      } else if (!test)
        err = mknod(name, mode, dev_makedev(x8u(toybuf+78), x8u(toybuf+86)));
  
      // Set ownership and timestamp.
      if (!test && !err) {
        // Creading dir/dev doesn't give us a filehandle, we have to refer to it
        // by name to chown/utime, but how do we know it's the same item?
        // Check that we at least have the right type of entity open, and do
        // NOT restore dropped suid bit in this case.
        if (!S_ISREG(mode) && !S_ISLNK(mode) && !geteuid()
            && !FLAG(no_preserve_owner))
        {
          int fd = open(name, O_RDONLY|O_NOFOLLOW);
          struct stat st;
  
          if (fd != -1 && !fstat(fd, &st) && (st.st_mode&S_IFMT) == (mode&S_IFMT))
            err = fchown(fd, uid, gid);
          else err = 1;
  
          close(fd);
        }
  
        // set timestamp
        if (!err) {
          struct timespec times[2];
  
          memset(times, 0, sizeof(struct timespec)*2);
          times[0].tv_sec = times[1].tv_sec = timestamp;
          err = utimensat(AT_FDCWD, name, times, AT_SYMLINK_NOFOLLOW);
        }
      }
  
      if (err) perror_msg_raw(name);
      free(tofree);
  
    // Output cpio archive
  
    } else {
      char *name = 0;
      size_t size = 0;
  
      for (;;) {
        struct stat st;
        unsigned nlen, error = 0, zero = 0;
        int len, fd = -1;
        char *link = 0;
        ssize_t llen;
  
        len = getline(&name, &size, stdin);
        if (len<1) break;
        if (name[len-1] == '\n') name[--len] = 0;
        nlen = len+1;
        if (lstat(name, &st) || (S_ISREG(st.st_mode)
            && st.st_size && (fd = open(name, O_RDONLY))<0)
            || (S_ISLNK(st.st_mode) && !(link = xreadlink(name))))
        {
          perror_msg_raw(name);
          continue;
        }
        // encrypted filesystems can stat the wrong link size
        if (link) st.st_size = strlen(link);
  
        if (FLAG(no_preserve_owner)) st.st_uid = st.st_gid = 0;
        if (!S_ISREG(st.st_mode) && !S_ISLNK(st.st_mode)) st.st_size = 0;
        if (st.st_size >> 32) perror_msg("skipping >2G file '%s'", name);
        else {
          llen = sprintf(toybuf,
            "070701%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X",
            (int)st.st_ino, st.st_mode, st.st_uid, st.st_gid, (int)st.st_nlink,
            (int)st.st_mtime, (int)st.st_size, dev_major(st.st_dev),
            dev_minor(st.st_dev), dev_major(st.st_rdev), dev_minor(st.st_rdev),
            nlen, 0);
          xwrite(afd, toybuf, llen);
          xwrite(afd, name, nlen);
  
          // NUL Pad header up to 4 multiple bytes.
          llen = (llen + nlen) & 3;
          if (llen) xwrite(afd, &zero, 4-llen);
  
          // Write out body for symlink or regular file
          if (link) xwrite(afd, link, st.st_size);
          else for (llen = st.st_size; llen; llen -= nlen) {
            nlen = llen > sizeof(toybuf) ? sizeof(toybuf) : llen;
            // If read fails, write anyway (already wrote size in header)
            if (nlen != readall(fd, toybuf, nlen))
              if (!error++) perror_msg("bad read from file '%s'", name);
            xwrite(afd, toybuf, nlen);
          }
          llen = st.st_size & 3;
          if (llen) xwrite(afd, &zero, 4-llen);
        }
        free(link);
        xclose(fd);
      }
      if (CFG_TOYBOX_FREE) free(name);
  
      // nlink=1, namesize=11, with padding
      dprintf(afd, "070701%040X%056X%08XTRAILER!!!%c%c%c%c", 1, 11, 0, 0, 0, 0,0);
    }
    if (TT.F) xclose(afd);
  
    if (FLAG(p) && pid) toys.exitval |= xpclose(pid, pipe);
  }
  