diff options
Diffstat (limited to 'toys/posix/tar.c')
| -rw-r--r-- | toys/posix/tar.c | 814 |
1 files changed, 814 insertions, 0 deletions
diff --git a/toys/posix/tar.c b/toys/posix/tar.c new file mode 100644 index 00000000..cfeedcba --- /dev/null +++ b/toys/posix/tar.c @@ -0,0 +1,814 @@ +/* tar.c - create/extract archives + * + * Copyright 2014 Ashwini Kumar <ak.ashwini81@gmail.com> + * + * For the command, see + * http://pubs.opengroup.org/onlinepubs/007908799/xcu/tar.html + * For the modern file format, see + * http://pubs.opengroup.org/onlinepubs/9699919799/utilities/pax.html#tag_20_92_13_06 + * https://en.wikipedia.org/wiki/Tar_(computing)#File_format + * https://www.gnu.org/software/tar/manual/html_node/Tar-Internals.html + * + * For writing to external program + * http://www.gnu.org/software/tar/manual/html_node/Writing-to-an-External-Program.html + * + * Toybox will never implement the "pax" command as a matter of policy. + * + * Why --exclude pattern but no --include? tar cvzf a.tgz dir --include '*.txt' + * Extract into dir same as filename, --restrict? "Tarball is splodey" + * + +USE_TAR(NEWTOY(tar, "&(restrict)(full-time)(no-recursion)(numeric-owner)(no-same-permissions)(overwrite)(exclude)*(mtime):(group):(owner):(to-command):o(no-same-owner)p(same-permissions)k(keep-old)c(create)|h(dereference)x(extract)|t(list)|v(verbose)J(xz)j(bzip2)z(gzip)O(to-stdout)m(touch)X(exclude-from)*T(files-from)*C(directory):f(file):a[!txc][!jzJa]", TOYFLAG_USR|TOYFLAG_BIN)) + +config TAR + bool "tar" + default y + help + usage: tar [-cxtfvohmjkO] [-XT FILE] [-f TARFILE] [-C DIR] + + Create, extract, or list files in a .tar (or compressed t?z) file. + + Options: + c Create x Extract t Test + f Name of TARFILE C Change to DIR first v Verbose: show filenames + o Ignore owner h Follow symlinks m Ignore mtime + j bzip2 compression z gzip compression + O Extract to stdout X exclude names in FILE T include names in FILE + --exclude=FILE File pattern(s) to exclude + --restrict All archive contents must extract under a single subdirctory. +*/ + +#define FOR_tar +#include "toys.h" + +GLOBALS( + char *f, *C; + struct arg_list *T, *X; + char *to_command, *owner, *group, *mtime; + struct arg_list *exclude; + + struct double_list *incl, *excl, *seen; + struct string_list *dirs; + char *cwd; + int fd, ouid, ggid, hlc, warn, adev, aino; + time_t mtt; + + // hardlinks seen so far (hlc many) + struct { + char *arg; + ino_t ino; + dev_t dev; + } *hlx; + + // Parsed information about a tar header. + struct tar_header { + char *name, *link_target, *uname, *gname; + long long size; + uid_t uid; + gid_t gid; + mode_t mode; + time_t mtime; + dev_t device; + } hdr; +) + +struct tar_hdr { + char name[100], mode[8], uid[8], gid[8],size[12], mtime[12], chksum[8], + type, link[100], magic[8], uname[32], gname[32], major[8], minor[8], + prefix[155], padd[12]; +}; + +// convert from int to octal (or base-256) +static void itoo(char *str, int len, unsigned long long val) +{ + // Do we need binary encoding? + if (!(val>>(3*(len-1)))) sprintf(str, "%0*llo", len-1, val); + else { + *str = 128; + while (--len) *++str = val>>(3*len); + } +} +#define ITOO(x, y) itoo(x, sizeof(x), y) + +// convert octal (or base-256) to int +static unsigned long long otoi(char *str, unsigned len) +{ + unsigned long long val = 0; + + // When tar value too big or octal, use binary encoding with high bit set + if (128&*str) while (--len) val = (val<<8)+*++str; + else { + while (len && *str>='0' && *str<='7') val = val*8+*str++-'0', len--; + if (len && *str && *str != ' ') error_exit("bad header"); + } + + return val; +} +#define OTOI(x) otoi(x, sizeof(x)) + +// Calculate packet checksum, with cksum field treated as 8 spaces +static unsigned cksum(void *data) +{ + unsigned i, cksum = 8*' '; + + for (i = 0; i<500; i += (i==147) ? 9 : 1) cksum += ((char *)data)[i]; + + return cksum; +} + +static void write_longname(char *name, char type) +{ + struct tar_hdr tmp; + int sz = strlen(name) +1; + + memset(&tmp, 0, sizeof(tmp)); + strcpy(tmp.name, "././@LongLink"); + ITOO(tmp.uid, 0); + ITOO(tmp.gid, 0); + ITOO(tmp.size, sz); + ITOO(tmp.mtime, 0); + tmp.type = type; + strcpy(tmp.magic, "ustar "); + + // Historical nonsense to match other implementations. Never used. + ITOO(tmp.mode, 0644); + strcpy(tmp.uname, "root"); + strcpy(tmp.gname, "root"); + + // Calculate checksum. Since 512*255 = 0377000 in octal, this can never + // use more than 6 digits. The last byte is ' ' or historical reasons. + itoo(tmp.chksum, sizeof(tmp.chksum)-1, cksum(&tmp)); + tmp.chksum[7] = ' '; + + // write header and name, padded with NUL to block size + xwrite(TT.fd, &tmp, 512); + xwrite(TT.fd, name, sz); + if (sz%512) xwrite(TT.fd, toybuf, 512-(sz%512)); +} + +static struct double_list *filter(struct double_list *lst, char *name) +{ + struct double_list *end = lst; + + if (lst) + // constant is FNM_LEADING_DIR + do if (!fnmatch(lst->data, name, 1<<3)) return lst; + while (end != (lst = lst->next)); + + return 0; +} + +static void skippy(long long len) +{ + if (lskip(TT.fd, len)) perror_exit("EOF"); +} + +// allocate and read data from TT.fd +static void alloread(void *buf, int len) +{ + // actually void **, but automatic typecasting doesn't work with void ** :( + void **b = buf; + + free(*b); + *b = xmalloc(len+1); + xreadall(TT.fd, *b, len); + b[len] = 0; +} + +// callback from dirtree to create archive +static int add_to_tar(struct dirtree *node) +{ + struct stat *st = &(node->st); + struct tar_hdr hdr; + struct passwd *pw = pw; + struct group *gr = gr; + int i, fd =-1; + char *c, *p, *name, *lnk = lnk, *hname; + + if (!dirtree_notdotdot(node)) return 0; + if (TT.adev == st->st_dev && TT.aino == st->st_ino) { + error_msg("'%s' file is the archive; not dumped", node->name); + return 0; + } + + i = 1; + name = dirtree_path(node, &i); + + // exclusion defaults to --no-anchored and --wildcards-match-slash + for (p = name; *p;) { + if (filter(TT.excl, p)) goto done; + while (*p && *p!='/') p++; + while (*p=='/') p++; + } + + // Consume the 1 extra byte alocated in dirtree_path() + if (S_ISDIR(st->st_mode) && name[i-1] != '/') strcat(name, "/"); + + // remove leading / and any .. entries from saved name + for (hname = name; *hname == '/'; hname++); + for (c = hname;;) { + if (!(c = strstr(c, ".."))) break; + if (c == hname || c[-1] == '/') { + if (!c[2]) goto done; + if (c[2]=='/') c = hname = c+3; + } else c+= 2; + } + if (!*hname) goto done; + + if (TT.warn && hname != name) { + fprintf(stderr, "removing leading '%.*s' from member names\n", + (int)(hname-name), name); + TT.warn = 0; + } + + if (TT.owner) st->st_uid = TT.ouid; + if (TT.group) st->st_gid = TT.ggid; + if (TT.mtime) st->st_mtime = TT.mtt; + + memset(&hdr, 0, sizeof(hdr)); + strncpy(hdr.name, hname, sizeof(hdr.name)); + ITOO(hdr.mode, st->st_mode &07777); + ITOO(hdr.uid, st->st_uid); + ITOO(hdr.gid, st->st_gid); + ITOO(hdr.size, 0); //set size later + ITOO(hdr.mtime, st->st_mtime); + strcpy(hdr.magic, "ustar "); + + // Hard link or symlink? i=0 neither, i=1 hardlink, i=2 symlink + + // Are there hardlinks to a non-directory entry? + if (st->st_nlink>1 && !S_ISDIR(st->st_mode)) { + // Have we seen this dev&ino before? + for (i = 0; i<TT.hlc; i++) { + if (st->st_ino == TT.hlx[i].ino && st->st_dev == TT.hlx[i].dev) + break; + } + if (i != TT.hlc) { + lnk = TT.hlx[i].arg; + i = 1; + } else { + // first time we've seen it. Store as normal file, but remember it. + if (!(TT.hlc&255)) TT.hlx = xrealloc(TT.hlx, TT.hlc+256); + TT.hlx[TT.hlc].arg = xstrdup(hname); + TT.hlx[TT.hlc].ino = st->st_ino; + TT.hlx[TT.hlc].dev = st->st_dev; + TT.hlc++; + i = 0; + } + } else i = 0; + + // !i because hardlink to a symlink is a thing. + if (!i && S_ISLNK(st->st_mode)) { + i = 2; + lnk = xreadlink(name); + } + + // Handle file types + if (i) { + hdr.type = '0'+i; + if (i==2 && !(lnk = xreadlink(name))) { + perror_msg("readlink"); + goto done; + } + if (strlen(lnk) > sizeof(hdr.link)) write_longname(lnk, 'K'); + strncpy(hdr.link, lnk, sizeof(hdr.link)); + if (i) free(lnk); + } else if (S_ISREG(st->st_mode)) { + hdr.type = '0'; + ITOO(hdr.size, st->st_size); + } else if (S_ISDIR(st->st_mode)) hdr.type = '5'; + else if (S_ISFIFO(st->st_mode)) hdr.type = '6'; + else if (S_ISBLK(st->st_mode) || S_ISCHR(st->st_mode)) { + hdr.type = (S_ISCHR(st->st_mode))?'3':'4'; + ITOO(hdr.major, dev_major(st->st_rdev)); + ITOO(hdr.minor, dev_minor(st->st_rdev)); + } else { + error_msg("unknown file type '%o'", st->st_mode & S_IFMT); + goto done; + } + + if (strlen(hname) > sizeof(hdr.name)) write_longname(hname, 'L'); + + if (!FLAG(numeric_owner)) { + if (TT.owner || (pw = bufgetpwuid(st->st_uid))) + strncpy(hdr.uname, TT.owner ? TT.owner : pw->pw_name, sizeof(hdr.uname)); + if (TT.group || (gr = bufgetgrgid(st->st_gid))) + strncpy(hdr.gname, TT.group ? TT.group : gr->gr_name, sizeof(hdr.gname)); + } + + itoo(hdr.chksum, sizeof(hdr.chksum)-1, cksum(&hdr)); + hdr.chksum[7] = ' '; + + if (FLAG(v)) printf("%s\n", hname); + + // Write header and data to archive + xwrite(TT.fd, &hdr, 512); + if (hdr.type == '0') { + if ((fd = open(name, O_RDONLY)) < 0) perror_msg("can't open '%s'", name); + else { + xsendfile_pad(fd, TT.fd, st->st_size); + if (st->st_size%512) writeall(TT.fd, toybuf, (512-(st->st_size%512))); + close(fd); + } + } +done: + free(name); + + return (DIRTREE_RECURSE|(FLAG(h)?DIRTREE_SYMFOLLOW:0))*!FLAG(no_recursion); +} + +static void wsettime(char *s, long long sec) +{ + struct timespec times[2] = {{sec, 0},{sec, 0}}; + + if (utimensat(AT_FDCWD, s, times, AT_SYMLINK_NOFOLLOW)) + perror_msg("settime %lld %s", sec, s); +} + +// Do pending directory utimes(), NULL to flush all. +static int dirflush(char *name) +{ + char *s = 0, *ss; + + // Barf if name not in TT.cwd + if (name) { + ss = s = xabspath(name, -1); + if (TT.cwd[1] && (!strstart(&ss, TT.cwd) || *ss!='/')) { + error_msg("'%s' not under '%s'", name, TT.cwd); + free(s); + + return 1; + } + + if (FLAG(restrict)) { + free(TT.cwd); + TT.cwd = strdup(s); + toys.optflags ^= FLAG_restrict; + } + } + + // Set deferred utimes() for directories this file isn't under. + // (Files must be depth-first ordered in tarball for this to matter.) + while (TT.dirs) { + + // If next file is under (or equal to) this dir, keep waiting + if (name && strstart(&ss, ss = s) && (!*ss || *ss=='/')) break; + + wsettime(TT.dirs->str+sizeof(long long), *(long long *)TT.dirs->str); + free(llist_pop(&TT.dirs)); + } + free(s); + + // name was under TT.cwd + return 0; +} + +static void extract_to_disk(void) +{ + char *name = TT.hdr.name; + int ala = TT.hdr.mode; + + if (dirflush(name)) { + if (S_ISREG(ala) && !TT.hdr.link_target) skippy(TT.hdr.size); + + return; + } + + // create path before file if necessary + if (strrchr(name, '/') && mkpath(name) && errno !=EEXIST) + return perror_msg(":%s: can't mkdir", name); + + // remove old file, if exists + if (!FLAG(k) && !S_ISDIR(ala) && unlink(name) && errno!=ENOENT) + return perror_msg("can't remove: %s", name); + + if (S_ISREG(ala)) { + // hardlink? + if (TT.hdr.link_target) { + if (link(TT.hdr.link_target, name)) + return perror_msg("can't link '%s' -> '%s'", name, TT.hdr.link_target); + // write contents + } else { + int fd = xcreate(name, O_WRONLY|O_CREAT|(FLAG(overwrite)?O_TRUNC:O_EXCL), + WARN_ONLY|(ala & 07777)); + if (fd != -1) { + xsendfile_len(TT.fd, fd, TT.hdr.size); + close(fd); + } + } + } else if (S_ISDIR(ala)) { + if ((mkdir(name, 0700) == -1) && errno != EEXIST) + return perror_msg("%s: can't create", TT.hdr.name); + } else if (S_ISLNK(ala)) { + if (symlink(TT.hdr.link_target, TT.hdr.name)) + return perror_msg("can't link '%s' -> '%s'", name, TT.hdr.link_target); + } else if (mknod(name, ala, TT.hdr.device)) + return perror_msg("can't create '%s'", name); + + // Set ownership + if (!FLAG(o) && !geteuid()) { + int u = TT.hdr.uid, g = TT.hdr.gid; + + if (TT.owner) TT.hdr.uid = TT.ouid; + else if (!FLAG(numeric_owner) && *TT.hdr.uname) { + struct passwd *pw = getpwnam(TT.hdr.uname); + if (pw && (TT.owner || !FLAG(numeric_owner))) TT.hdr.uid = pw->pw_uid; + } + + if (TT.group) TT.hdr.gid = TT.ggid; + else if (!FLAG(numeric_owner) && *TT.hdr.uname) { + struct group *gr = getgrnam(TT.hdr.gname); + if (gr) TT.hdr.gid = gr->gr_gid; + } + + if (lchown(name, u, g)) perror_msg("chown %d:%d '%s'", u, g, name);; + } + + if (!S_ISLNK(ala)) chmod(TT.hdr.name, FLAG(p) ? ala : ala&0777); + + // Apply mtime. + if (!FLAG(m)) { + if (S_ISDIR(ala)) { + struct string_list *sl; + + // Writing files into a directory changes directory timestamps, so + // defer mtime updates until contents written. + + sl = xmalloc(sizeof(struct string_list)+sizeof(long long)+strlen(name)+1); + *(long long *)sl->str = TT.hdr.mtime; + strcpy(sl->str+sizeof(long long), name); + sl->next = TT.dirs; + TT.dirs = sl; + } else wsettime(TT.hdr.name, TT.hdr.mtime); + } +} + +static void unpack_tar(struct tar_hdr *first) +{ + struct double_list *walk, *delete; + struct tar_hdr tar; + int i, and = 0; + unsigned maj, min; + char *s; + + for (;;) { + if (first) { + memcpy(&tar, first, i = 512); + first = 0; + } else { + // align to next block and read it + if (TT.hdr.size%512) skippy(512-TT.hdr.size%512); + i = readall(TT.fd, &tar, 512); + } + + if (i && i!=512) error_exit("short header"); + + // Two consecutive empty headers ends tar even if there's more data + if (!i || !*tar.name) { + if (!i || and++) return; + TT.hdr.size = 0; + continue; + } + // ensure null temination even of pathological packets + tar.padd[0] = and = 0; + + // Is this a valid Unix Standard TAR header? + if (memcmp(tar.magic, "ustar", 5)) error_exit("bad header"); + if (cksum(&tar) != OTOI(tar.chksum)) error_exit("bad cksum"); + TT.hdr.size = OTOI(tar.size); + + // If this header isn't writing something to the filesystem + if (tar.type<'0' || tar.type>'7') { + + // Long name extension header? + if (tar.type == 'K') alloread(&TT.hdr.link_target, TT.hdr.size); + else if (tar.type == 'L') alloread(&TT.hdr.name, TT.hdr.size); + else if (tar.type == 'x') { + char *p, *buf = 0; + int i, len, n; + + // Posix extended record "LEN NAME=VALUE\n" format + alloread(&buf, TT.hdr.size); + for (p = buf; (p-buf)<TT.hdr.size; p += len) { + i = sscanf(p, "%u path=%n", &len, &n); + if (i<1 || len<4 || len>TT.hdr.size) { + error_msg("bad header"); + break; + } + p[len-1] = 0; + if (i == 2) { + TT.hdr.name = xstrdup(p+n); + break; + } + } + free(buf); + + // Ignore everything else. + } else skippy(TT.hdr.size); + + continue; + } + + // At this point, we have something to output. Convert metadata. + TT.hdr.mode = OTOI(tar.mode); + TT.hdr.mode |= (char []){8,8,10,2,6,4,1,8}[tar.type-'0']<<12; + TT.hdr.uid = OTOI(tar.uid); + TT.hdr.gid = OTOI(tar.gid); + TT.hdr.mtime = OTOI(tar.mtime); + maj = OTOI(tar.major); + min = OTOI(tar.minor); + TT.hdr.device = dev_makedev(maj, min); + + TT.hdr.uname = xstrndup(TT.owner ? TT.owner : tar.uname, sizeof(tar.uname)); + TT.hdr.gname = xstrndup(TT.group ? TT.group : tar.gname, sizeof(tar.gname)); + + if (TT.owner) TT.hdr.uid = TT.ouid; + else if (!FLAG(numeric_owner)) { + struct passwd *pw = getpwnam(TT.hdr.uname); + if (pw && (TT.owner || !FLAG(numeric_owner))) TT.hdr.uid = pw->pw_uid; + } + + if (TT.group) TT.hdr.gid = TT.ggid; + else if (!FLAG(numeric_owner)) { + struct group *gr = getgrnam(TT.hdr.gname); + if (gr) TT.hdr.gid = gr->gr_gid; + } + + if (!TT.hdr.link_target && *tar.link) + TT.hdr.link_target = xstrndup(tar.link, sizeof(tar.link)); + if (!TT.hdr.name) { + // Glue prefix and name fields together with / if necessary + i = strnlen(tar.prefix, sizeof(tar.prefix)); + TT.hdr.name = xmprintf("%.*s%s%.*s", i, tar.prefix, + (i && tar.prefix[i-1] != '/') ? "/" : "", + (int)sizeof(tar.name), tar.name); + } + + // Old broken tar recorded dir as "file with trailing slash" + if (S_ISREG(TT.hdr.mode) && (s = strend(TT.hdr.name, "/"))) { + *s = 0; + TT.hdr.mode = (TT.hdr.mode & ~S_IFMT) | S_IFDIR; + } + + // Non-regular files don't have contents stored in archive. + if ((TT.hdr.link_target && *TT.hdr.link_target) || !S_ISREG(TT.hdr.mode)) + TT.hdr.size = 0; + + // Files are seen even if excluded, so check them here. + // TT.seen points to first seen entry in TT.incl, or NULL if none yet. + + if ((delete = filter(TT.incl, TT.hdr.name)) && TT.incl != TT.seen) { + if (!TT.seen) TT.seen = delete; + + // Move seen entry to end of list. + if (TT.incl == delete) TT.incl = TT.incl->next; + else for (walk = TT.incl; walk != TT.seen; walk = walk->next) { + if (walk == delete) { + dlist_pop(&walk); + dlist_add_nomalloc(&TT.incl, delete); + } + } + } + + // Skip excluded files + if (filter(TT.excl, TT.hdr.name) || (TT.incl && !delete)) + skippy(TT.hdr.size); + else if (FLAG(t)) { + if (FLAG(v)) { + struct tm *lc = localtime(TT.mtime ? &TT.mtt : &TT.hdr.mtime); + char perm[12], gname[12]; + + mode_to_string(TT.hdr.mode, perm); + printf("%s", perm); + sprintf(perm, "%u", TT.hdr.uid); + sprintf(gname, "%u", TT.hdr.gid); + printf(" %s/%s ", *TT.hdr.uname ? TT.hdr.uname : perm, + *TT.hdr.gname ? TT.hdr.gname : gname); + if (tar.type=='3' || tar.type=='4') printf("%u,%u", maj, min); + else printf("%9lld", (long long)TT.hdr.size); + sprintf(perm, ":%02d", lc->tm_sec); + printf(" %d-%02d-%02d %02d:%02d%s ", 1900+lc->tm_year, 1+lc->tm_mon, + lc->tm_mday, lc->tm_hour, lc->tm_min, FLAG(full_time) ? perm : ""); + } + printf("%s", TT.hdr.name); + if (TT.hdr.link_target) printf(" -> %s", TT.hdr.link_target); + xputc('\n'); + skippy(TT.hdr.size); + } else { + if (FLAG(v)) printf("%s\n", TT.hdr.name); + if (FLAG(O)) xsendfile_len(TT.fd, 1, TT.hdr.size); + else if (FLAG(to_command)) { + if (S_ISREG(TT.hdr.mode)) { + int fd, pid; + + xsetenv("TAR_FILETYPE", "f"); + xsetenv(xmprintf("TAR_MODE=%o", TT.hdr.mode), 0); + xsetenv(xmprintf("TAR_SIZE=%lld", TT.hdr.size), 0); + xsetenv("TAR_FILENAME", TT.hdr.name); + xsetenv("TAR_UNAME", TT.hdr.uname); + xsetenv("TAR_GNAME", TT.hdr.gname); + xsetenv(xmprintf("TAR_MTIME=%llo", (long long)TT.hdr.mtime), 0); + xsetenv(xmprintf("TAR_UID=%o", TT.hdr.uid), 0); + xsetenv(xmprintf("TAR_GID=%o", TT.hdr.gid), 0); + + pid = xpopen((char *[]){"sh", "-c", TT.to_command, NULL}, &fd, 0); + // todo: short write exits tar here, other skips data. + xsendfile_len(TT.fd, fd, TT.hdr.size); + fd = xpclose(pid, fd); + if (fd) error_msg("%d: Child returned %d", pid, fd); + } + } else extract_to_disk(); + } + + free(TT.hdr.name); + free(TT.hdr.link_target); + free(TT.hdr.uname); + free(TT.hdr.gname); + TT.hdr.name = TT.hdr.link_target = 0; + } +} + +// Add copy of filename (minus trailing \n and /) to dlist ** +static void trim2list(void *list, char *pline) +{ + char *n = xstrdup(pline); + int i = strlen(n); + + dlist_add(list, n); + if (i && n[i-1]=='\n') i--; + while (i && n[i-1] == '/') i--; + n[i] = 0; +} + +// do_lines callback, selects TT.incl or TT.excl based on call order +static void do_XT(char **pline, long len) +{ + if (pline) trim2list(TT.X ? &TT.excl : &TT.incl, *pline); +} + +void tar_main(void) +{ + char *s, **args = toys.optargs; + int len = 0; + + // Needed when extracting to command + signal(SIGPIPE, SIG_IGN); + + // Get possible early errors out of the way + if (!geteuid()) toys.optflags |= FLAG_p; + if (TT.owner) TT.ouid = xgetuid(TT.owner); + if (TT.group) TT.ggid = xgetgid(TT.group); + if (TT.mtime) xparsedate(TT.mtime, &TT.mtt, (void *)&s, 1); + + // Collect file list. + for (; TT.exclude; TT.exclude = TT.exclude->next) + trim2list(&TT.excl, TT.exclude->arg); + for (;TT.X; TT.X = TT.X->next) do_lines(xopenro(TT.X->arg), '\n', do_XT); + for (args = toys.optargs; *args; args++) trim2list(&TT.incl, *args); + for (;TT.T; TT.T = TT.T->next) do_lines(xopenro(TT.T->arg), '\n', do_XT); + + // If include file list empty, don't create empty archive + if (FLAG(c)) { + if (!TT.incl) error_exit("empty archive"); + TT.fd = 1; + } + + // nommu reentry for nonseekable input skips this, parent did it for us + if (toys.stacktop) { + if (TT.f && strcmp(TT.f, "-")) + TT.fd = xcreate(TT.f, TT.fd*(O_WRONLY|O_CREAT|O_TRUNC), 0666); + // Get destination directory + if (TT.C) xchdir(TT.C); + } + + // Get destination directory + TT.cwd = xabspath(s = xgetcwd(), 1); + free(s); + + // Remember archive inode + { + struct stat st; + + if (!fstat(TT.fd, &st)) { + TT.aino = st.st_ino; + TT.adev = st.st_dev; + } + } + + // Are we reading? + if (FLAG(x)||FLAG(t)) { + struct tar_hdr *hdr = 0; + + // autodetect compression type when not specified + if (!(FLAG(j)||FLAG(z)||FLAG(J))) { + len = xread(TT.fd, hdr = (void *)(toybuf+sizeof(toybuf)-512), 512); + if (len!=512 || strncmp("ustar", hdr->magic, 5)) { + // detect gzip and bzip signatures + if (SWAP_BE16(*(short *)hdr)==0x1f8b) toys.optflags |= FLAG_z; + else if (!memcmp(hdr->name, "BZh", 3)) toys.optflags |= FLAG_j; + else if (peek_be(hdr->name, 7) == 0xfd377a585a0000) + toys.optflags |= FLAG_J; + else error_exit("Not tar"); + + // if we can seek back we don't need to loop and copy data + if (!lseek(TT.fd, -len, SEEK_CUR)) hdr = 0; + } + } + + if (FLAG(j)||FLAG(z)||FLAG(J)) { + int pipefd[2] = {hdr ? -1 : TT.fd, -1}, i, pid; + char *cmd[] = {"bzcat", 0}; + + if (FLAG(J)) cmd[0] = "xzcat"; + else if FLAG(z) cmd[0]++; + xpopen_both(cmd, pipefd); + + if (!hdr) { + // If we could seek, child gzip inherited fd and we read its output + close(TT.fd); + TT.fd = pipefd[1]; + + } else { + + // If we autodetected type but then couldn't lseek to put the data back + // we have to loop reading data from TT.fd and pass it to gzip ourselves + // (starting with the block of data we read to autodetect). + + // dirty trick: move gzip input pipe to stdin so child closes spare copy + dup2(pipefd[0], 0); + if (pipefd[0]) close(pipefd[0]); + + // Fork a copy of ourselves to handle extraction (reads from zip output + // pipe, writes to stdout). + pipefd[0] = pipefd[1]; + pipefd[1] = 1; + pid = xpopen_both(0, pipefd); + close(pipefd[1]); + + // loop writing collated data to zip proc + xwrite(0, hdr, len); + for (;;) { + if ((i = read(TT.fd, toybuf, sizeof(toybuf)))<1) { + close(0); + xwaitpid(pid); + return; + } + xwrite(0, toybuf, i); + } + } + } + + unpack_tar(hdr); + dirflush(0); + + // Each time a TT.incl entry is seen it's moved to the end of the list, + // with TT.seen pointing to first seen list entry. Anything between + // TT.incl and TT.seen wasn't encountered in archive.. + if (TT.seen != TT.incl) { + if (!TT.seen) TT.seen = TT.incl; + while (TT.incl != TT.seen) { + error_msg("'%s' not in archive", TT.incl->data); + TT.incl = TT.incl->next; + } + } + + // are we writing? (Don't have to test flag here, one of 3 must be set) + } else { + struct double_list *dl = TT.incl; + + // autodetect compression type based on -f name. (Use > to avoid.) + if (TT.f && !FLAG(j) && !FLAG(z)) { + char *tbz[] = {".tbz", ".tbz2", ".tar.bz", ".tar.bz2"}; + if (strend(TT.f, ".tgz") || strend(TT.f, ".tar.gz")) + toys.optflags |= FLAG_z; + if (strend(TT.f, ".txz") || strend(TT.f, ".tar.xz")) + toys.optflags |= FLAG_J; + else for (len = 0; len<ARRAY_LEN(tbz); len++) + if (strend(TT.f, tbz[len])) toys.optflags |= FLAG_j; + } + + if (FLAG(j)||FLAG(z)||FLAG(J)) { + int pipefd[2] = {-1, TT.fd}; + + xpopen_both((char *[]){FLAG(z)?"gzip":FLAG(J)?"xz":"bzip2", "-f", NULL}, + pipefd); + close(TT.fd); + TT.fd = pipefd[0]; + } + do { + TT.warn = 1; + dirtree_flagread(dl->data, FLAG(h)?DIRTREE_SYMFOLLOW:0, add_to_tar); + } while (TT.incl != (dl = dl->next)); + + writeall(TT.fd, toybuf, 1024); + } + + if (CFG_TOYBOX_FREE) { + llist_traverse(TT.excl, llist_free_double); + llist_traverse(TT.incl, llist_free_double); + while(TT.hlc) free(TT.hlx[--TT.hlc].arg); + free(TT.hlx); + free(TT.cwd); + close(TT.fd); + } +} |