diff options
| -rw-r--r-- | toys/pending/tar.c | 808 |
1 files changed, 808 insertions, 0 deletions
diff --git a/toys/pending/tar.c b/toys/pending/tar.c new file mode 100644 index 00000000..12ee7af5 --- /dev/null +++ b/toys/pending/tar.c @@ -0,0 +1,808 @@ +/* tar.c - create/extract archives + * + * Copyright 2014 Ashwini Kumar <ak.ashwini81@gmail.com> + * + * USTAR interchange format is of interest in + * See http://http://pubs.opengroup.org/onlinepubs/9699919799/utilities/pax.html + * For writing to external program + * http://www.gnu.org/software/tar/manual/html_node/Writing-to-an-External-Program.html + +USE_TAR(NEWTOY(tar, "&(no-recursion)(numeric-owner)(no-same-permissions)(overwrite)(exclude)*(to-command):o(no-same-owner)p(same-permissions)k(keep-old)c(create)|h(dereference)x(extract)|t(list)|v(verbose)z(gzip)O(to-stdout)m(touch)X(exclude-from)*T(files-from)*C(directory):f(file):[!txc]", TOYFLAG_USR|TOYFLAG_BIN)) + +config TAR + bool "tar" + default n + help + usage: tar -[cxtzhmvO] [-X FILE] [-T FILE] [-f TARFILE] [-C DIR] + + Create, extract, or list files from a tar file + + Operation: + c Create + f Name of TARFILE ('-' for stdin/out) + h Follow symlinks + m Don't restore mtime + t List + v Verbose + x Extract + z (De)compress using gzip + C Change to DIR before operation + O Extract to stdout + exclude=FILE File to exclude + X File with names to exclude + T File with names to include +*/ +#define FOR_tar +#include "toys.h" + +GLOBALS( + char *fname; + char *dir; + struct arg_list *inc_file; + struct arg_list *exc_file; + char *tocmd; + struct arg_list *exc; + + struct arg_list *inc, *pass; + void *inodes, *handle; +) + +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]; +}; + +struct file_header { + char *name, *link_target, *uname, *gname; + off_t size; + uid_t uid; + gid_t gid; + mode_t mode; + time_t mtime; + dev_t device; +}; + +struct archive_handler { + int src_fd; + struct file_header file_hdr; + off_t offset; + void (*extract_handler)(struct archive_handler*); +}; + +struct inode_list { + struct inode_list *next; + char *arg; + ino_t ino; + dev_t dev; +}; + +static void copy_in_out(int src, int dst, off_t size) +{ + int i, rd, rem = size%512, cnt; + + cnt = size/512 + (rem?1:0); + + for (i = 0; i < cnt; i++) { + rd = (((i == cnt-1) && rem)? rem:512); + if (readall(src, toybuf, rd) != rd) error_exit("short read"); + writeall(dst, toybuf, rd); + } +} + +//convert to octal +static void itoo(char *str, int len, off_t val) +{ + char *t, tmp[sizeof(off_t)*3+1]; //1 for NUL termination + int cnt = sprintf(tmp, "%0*llo", len, val); + + t = tmp; + t += (cnt - len); + if (*t == '0') t++; + memcpy(str, t, len); +} + +static struct inode_list *seen_inode(void **list, struct stat *st, char *name) +{ + if (!st) llist_traverse(*list, llist_free_arg); + else if (!S_ISDIR(st->st_mode) && st->st_nlink > 1) { + struct inode_list *new; + + for (new = *list; new; new = new->next) + if(new->ino == st->st_ino && new->dev == st->st_dev) + return new; + + new = xzalloc(sizeof(*new)); + new->ino = st->st_ino; + new->dev = st->st_dev; + new->arg = xstrdup(name); + new->next = *list; + *list = new; + } + return 0; +} + +static void write_longname(struct archive_handler *tar, char *name, char type) +{ + struct tar_hdr tmp; + unsigned int sum = 0; + int i, sz = strlen(name) +1; + char buf[512] = {0,}; + + memset(&tmp, 0, sizeof(tmp)); + strcpy(tmp.name, "././@LongLink"); + sprintf(tmp.mode, "%0*d", sizeof(tmp.mode)-1, 0); + sprintf(tmp.uid, "%0*d", sizeof(tmp.uid)-1, 0); + sprintf(tmp.gid, "%0*d", sizeof(tmp.gid)-1, 0); + sprintf(tmp.size, "%0*d", sizeof(tmp.size)-1, 0); + sprintf(tmp.mtime, "%0*d", sizeof(tmp.mtime)-1, 0); + itoo(tmp.size, sizeof(tmp.size), sz); + tmp.type = type; + memset(tmp.chksum, ' ', 8); + strcpy(tmp.magic, "ustar "); + for (i= 0; i < 512; i++) sum += (unsigned int)((char*)&tmp)[i]; + itoo(tmp.chksum, sizeof(tmp.chksum)-1, sum); + + writeall(tar->src_fd, (void*) &tmp, sizeof(tmp)); + //write name to archive + writeall(tar->src_fd, name, sz); + if (sz%512) writeall(tar->src_fd, buf, (512-(sz%512))); +} + +static int filter(struct arg_list *lst, char *name) +{ + struct arg_list *cur; + + for (cur = lst; cur; cur = cur->next) + if (!fnmatch(cur->arg, name, 1<<3)) return 1; + return 0; +} + +static void add_file(struct archive_handler *tar, char **nam, struct stat *st) +{ + struct tar_hdr hdr; + struct passwd *pw; + struct group *gr; + struct inode_list *node; + int i, fd =-1; + char *c, *p, *name = *nam, *lnk, *hname, buf[512] = {0,}; + unsigned int sum = 0; + static int warn = 1; + + for (p = name; *p; p++) + if ((p == name || p[-1] == '/') && *p != '/' + && filter(TT.exc, p)) return; + + if (S_ISDIR(st->st_mode) && name[strlen(name)-1] != '/') { + lnk = xmprintf("%s/",name); + free(name); + *nam = name = lnk; + } + hname = name; + //remove leading '/' or relative path '../' component + if (*hname == '/') hname++; + if (!*hname) return; + while ((c = strstr(hname, "../"))) hname = c + 3; + if (warn && hname != name) { + printf("removing leading '%.*s' " + "from member names\n",hname-name, name); + warn = 0; + } + + memset(&hdr, 0, sizeof(hdr)); + strncpy(hdr.name, hname, sizeof(hdr.name)); + itoo(hdr.mode, sizeof(hdr.mode), st->st_mode &07777); + itoo(hdr.uid, sizeof(hdr.uid), st->st_uid); + itoo(hdr.gid, sizeof(hdr.gid), st->st_gid); + itoo(hdr.size, sizeof(hdr.size), 0); //set size later + itoo(hdr.mtime, sizeof(hdr.mtime), st->st_mtime); + for (i=0; i<sizeof(hdr.chksum); i++) hdr.chksum[i] = ' '; + + if ((node = seen_inode(&TT.inodes, st, hname))) { + //this is a hard link + hdr.type = '1'; + if (strlen(node->arg) > sizeof(hdr.link)) + write_longname(tar, hname, 'K'); //write longname LINK + strncpy(hdr.link, node->arg, sizeof(hdr.link)); + } else if (S_ISREG(st->st_mode)) { + hdr.type = '0'; + if (st->st_size <= (off_t)0777777777777LL) + itoo(hdr.size, sizeof(hdr.size), st->st_size); + else { + error_msg("can't store file '%s' of size '%d'\n", hname, st->st_size); + return; + } + } else if (S_ISLNK(st->st_mode)) { + hdr.type = '2'; //'K' long link + if (!(lnk = xreadlink(name))) { + perror_msg("readlink"); + return; + } + if (strlen(lnk) > sizeof(hdr.link)) + write_longname(tar, hname, 'K'); //write longname LINK + strncpy(hdr.link, lnk, sizeof(hdr.link)); + free(lnk); + } + 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, sizeof(hdr.major), major(st->st_rdev)); + itoo(hdr.minor, sizeof(hdr.minor), minor(st->st_rdev)); + } else { + error_msg("unknown file type '%s'"); + return; + } + if (strlen(hname) > sizeof(hdr.name)) + write_longname(tar, hname, 'L'); //write longname NAME + strcpy(hdr.magic, "ustar "); + if ((pw = getpwuid(st->st_uid))) + snprintf(hdr.uname, sizeof(hdr.uname), "%s", pw->pw_name); + else snprintf(hdr.uname, sizeof(hdr.uname), "%d", st->st_uid); + + if ((gr = getgrgid(st->st_gid))) + snprintf(hdr.gname, sizeof(hdr.gname), "%s", gr->gr_name); + else snprintf(hdr.gname, sizeof(hdr.gname), "%d", st->st_gid); + + //calculate chksum. + for (i= 0; i < 512; i++) sum += (unsigned int)((char*)&hdr)[i]; + itoo(hdr.chksum, sizeof(hdr.chksum)-1, sum); + if (toys.optflags & FLAG_v) printf("%s\n",hname); + writeall(tar->src_fd, (void*)&hdr, 512); + + //write actual data to archive + if (hdr.type != '0') return; //nothing to write + if ((fd = open(name, O_RDONLY)) < 0) { + perror_msg("can't open '%s'", name); + return; + } + copy_in_out(fd, tar->src_fd, st->st_size); + if (st->st_size%512) writeall(tar->src_fd, buf, (512-(st->st_size%512))); + close(fd); +} + +static int add_to_tar(struct dirtree *node) +{ + struct stat st; + char *path; + struct archive_handler *hdl = (struct archive_handler*)TT.handle; + + if (!fstat(hdl->src_fd, &st) && st.st_dev == node->st.st_dev + && st.st_ino == node->st.st_ino) { + error_msg("'%s' file is the archive; not dumped", TT.fname); + return ((DIRTREE_RECURSE | ((toys.optflags & FLAG_h)?DIRTREE_SYMFOLLOW:0))); + } + + if (node->parent && !dirtree_notdotdot(node)) return 0; + path = dirtree_path(node, 0); + add_file(hdl, &path, &(node->st)); //path may be modified + free(path); + if (toys.optflags & FLAG_no_recursion) return 0; + return ((DIRTREE_RECURSE | ((toys.optflags & FLAG_h)?DIRTREE_SYMFOLLOW:0))); +} + +static void compress_stream(struct archive_handler *tar_hdl) +{ + int pipefd[2]; + pid_t cpid; + + if (pipe(pipefd) == -1) error_exit("pipe"); + + signal(SIGPIPE, SIG_IGN); + cpid = fork(); + if (cpid == -1) perror_exit("fork"); + + if (!cpid) { /* Child reads from pipe */ + char *argv[] = {"gzip", "-f", NULL}; + xclose(pipefd[1]); /* Close unused write*/ + dup2(pipefd[0], 0); + dup2(tar_hdl->src_fd, 1); //write to tar fd + xexec(argv); + } else { + xclose(pipefd[0]); /* Close unused read end */ + dup2(pipefd[1], tar_hdl->src_fd); //write to pipe + } +} + +static void extract_to_stdout(struct archive_handler *tar) +{ + struct file_header *file_hdr = &tar->file_hdr; + + copy_in_out(tar->src_fd, 0, file_hdr->size); + tar->offset += file_hdr->size; +} + +static void extract_to_command(struct archive_handler *tar) +{ + int pipefd[2], status = 0; + pid_t cpid; + struct file_header *file_hdr = &tar->file_hdr; + + if (pipe(pipefd) == -1) error_exit("pipe"); + if (!S_ISREG(file_hdr->mode)) return; //only regular files are supported. + + cpid = fork(); + if (cpid == -1) perror_exit("fork"); + + if (!cpid) { // Child reads from pipe + char buf[64], *argv[4] = {"sh", "-c", TT.tocmd, NULL}; + + setenv("TAR_FILETYPE", "f", 1); + sprintf(buf, "%0o", file_hdr->mode); + setenv("TAR_MODE", buf, 1); + sprintf(buf, "%ld", (long)file_hdr->size); + setenv("TAR_SIZE", buf, 1); + setenv("TAR_FILENAME", file_hdr->name, 1); + setenv("TAR_UNAME", file_hdr->uname, 1); + setenv("TAR_GNAME", file_hdr->gname, 1); + sprintf(buf, "%0o", (int)file_hdr->mtime); + setenv("TAR_MTIME", buf, 1); + sprintf(buf, "%0o", file_hdr->uid); + setenv("TAR_UID", buf, 1); + sprintf(buf, "%0o", file_hdr->gid); + setenv("TAR_GID", buf, 1); + + xclose(pipefd[1]); // Close unused write + dup2(pipefd[0], 0); + signal(SIGPIPE, SIG_DFL); + xexec(argv); + } else { + xclose(pipefd[0]); // Close unused read end + copy_in_out(tar->src_fd, pipefd[1], file_hdr->size); + tar->offset += file_hdr->size; + xclose(pipefd[1]); + waitpid(cpid, &status, 0); + if (WIFSIGNALED(status)) + xprintf("tar : %d: child returned %d\n", cpid, WTERMSIG(status)); + } +} + +static void extract_to_disk(struct archive_handler *tar) +{ + int flags, dst_fd = -1; + char *s; + struct stat ex; + struct file_header *file_hdr = &tar->file_hdr; + + if (file_hdr->name[strlen(file_hdr->name)-1] == '/') + file_hdr->name[strlen(file_hdr->name)-1] = 0; + //Regular file with preceding path + if ((s = strrchr(file_hdr->name, '/'))) { + if (mkpathat(AT_FDCWD, file_hdr->name, 00, 2) && errno !=EEXIST) { + error_msg(":%s: not created", file_hdr->name); + return; + } + } + + //remove old file, if exists + if (!(toys.optflags & FLAG_k) && !S_ISDIR(file_hdr->mode) + && !lstat( file_hdr->name, &ex)) { + if (unlink(file_hdr->name)) { + perror_msg("can't remove: %s",file_hdr->name); + } + } + + //hard link + if (S_ISREG(file_hdr->mode) && file_hdr->link_target) { + if (link(file_hdr->link_target, file_hdr->name)) + perror_msg("can't link '%s' -> '%s'",file_hdr->name, file_hdr->link_target); + goto COPY; + } + + switch (file_hdr->mode & S_IFMT) { + case S_IFREG: + flags = O_WRONLY|O_CREAT|O_EXCL; + if (toys.optflags & FLAG_overwrite) flags = O_WRONLY|O_CREAT|O_TRUNC; + dst_fd = open(file_hdr->name, flags, file_hdr->mode & 07777); + if (dst_fd == -1) perror_msg("%s: can't open", file_hdr->name); + break; + case S_IFDIR: + if ((mkdir(file_hdr->name, file_hdr->mode) == -1) && errno != EEXIST) + perror_msg("%s: can't create", file_hdr->name); + break; + case S_IFLNK: + if (symlink(file_hdr->link_target, file_hdr->name)) + perror_msg("can't link '%s' -> '%s'",file_hdr->name, file_hdr->link_target); + break; + case S_IFBLK: + case S_IFCHR: + case S_IFIFO: + if (mknod(file_hdr->name, file_hdr->mode, file_hdr->device)) + perror_msg("can't create '%s'", file_hdr->name); + break; + default: + printf("type not yet supported\n"); + break; + } + + //copy file.... +COPY: + copy_in_out(tar->src_fd, dst_fd, file_hdr->size); + tar->offset += file_hdr->size; + close(dst_fd); + + if (S_ISLNK(file_hdr->mode)) return; + if (!(toys.optflags & FLAG_o)) { + //set ownership..., --no-same-owner, --numeric-owner + uid_t u = file_hdr->uid; + gid_t g = file_hdr->gid; + + if (!(toys.optflags & FLAG_numeric_owner)) { + struct group *gr = getgrnam(file_hdr->gname); + struct passwd *pw = getpwnam(file_hdr->uname); + if (pw) u = pw->pw_uid; + if (gr) g = gr->gr_gid; + } + chown(file_hdr->name, u, g); + } + + if (toys.optflags & FLAG_p) // || !(toys.optflags & FLAG_no_same_permissions)) + chmod(file_hdr->name, file_hdr->mode); + + //apply mtime + if (!(toys.optflags & FLAG_m)) { + struct timeval times[2] = {{file_hdr->mtime, 0},{file_hdr->mtime, 0}}; + utimes(file_hdr->name, times); + } +} + +static void add_to_list(struct arg_list **llist, char *name) +{ + struct arg_list **list = llist; + + while (*list) list=&((*list)->next); + *list = xzalloc(sizeof(struct arg_list)); + (*list)->arg = name; + if ((name[strlen(name)-1] == '/') && strlen(name) != 1) + name[strlen(name)-1] = '\0'; +} + +static void add_from_file(struct arg_list **llist, struct arg_list *flist) +{ + char *line = NULL; + + while (flist) { + int fd = 0; + + if (strcmp((char *)flist->arg, "-")) + fd = xopen((char *)flist->arg, O_RDONLY); + + while ((line = get_line(fd))) { + add_to_list(llist, line); + } + if (fd) close(fd); + flist = flist->next; + } +} + +static struct archive_handler *init_handler() +{ + struct archive_handler *tar_hdl = xzalloc(sizeof(struct archive_handler)); + tar_hdl->extract_handler = extract_to_disk; + return tar_hdl; +} + +//convert octal to int +static int otoi(char *str, int len) +{ + long val; + char *endp, inp[len+1]; //1 for NUL termination + + memcpy(inp, str, len); + inp[len] = '\0'; //nul-termination made sure + val = strtol(inp, &endp, 8); + if (*endp && *endp != ' ') error_exit("invalid param"); + return (int)val; +} + +static void extract_stream(struct archive_handler *tar_hdl) +{ + int pipefd[2]; + pid_t cpid; + + if (pipe(pipefd) == -1) error_exit("pipe"); + + cpid = fork(); + if (cpid == -1) perror_exit("fork"); + + if (!cpid) { /* Child reads from pipe */ + char *argv[] = {"gunzip", "-cf", "-", NULL}; + xclose(pipefd[0]); /* Close unused read*/ + dup2(tar_hdl->src_fd, 0); + dup2(pipefd[1], 1); //write to pipe + xexec(argv); + } else { + xclose(pipefd[1]); /* Close unused read end */ + dup2(pipefd[0], tar_hdl->src_fd); //read from pipe + } +} + +static char *process_extended_hdr(struct archive_handler *tar, int size) +{ + char *value = NULL, *p, *buf = xzalloc(size+1); + + if (readall(tar->src_fd, buf, size) != size) error_exit("short read"); + buf[size] = 0; + tar->offset += size; + p = buf; + + while (size) { + char *key; + int len, n; + + // extended records are of the format: "LEN NAME=VALUE\n" + sscanf(p, "%d %n", &len, &n); + key = p + n; + p += len; + size -= len; + p[-1] = 0; + if (size < 0) { + error_msg("corrupted extended header"); + break; + } + + len = strlen("path="); + if (!strncmp(key, "path=", len)) { + value = key + strlen("path="); + break; + } + } + return ((value)?xstrdup(value) : NULL); +} + +static void tar_skip(struct archive_handler *tar, int sz) +{ + int x; + + while ((x = lskip(tar->src_fd, sz))) { + tar->offset += sz - x; + sz = x; + } + tar->offset += sz; +} + +static void unpack_tar(struct archive_handler *tar_hdl) +{ + struct tar_hdr tar; + struct file_header *file_hdr; + int i, j, maj, min, sz, e = 0; + unsigned int cksum; + unsigned char *gzMagic; + char *longname = NULL, *longlink = NULL; + + while (1) { + cksum = 0; + if (tar_hdl->offset % 512) { + sz = 512 - tar_hdl->offset % 512; + tar_skip(tar_hdl, sz); + } + i = readall(tar_hdl->src_fd, &tar, 512); + tar_hdl->offset += i; + if (i != 512) { + if (i >= 2) goto CHECK_MAGIC; //may be a small (<512 byte)zipped file + error_exit("read error"); + } + + if (!tar.name[0]) { + if (e) return; //end of tar 2 empty blocks + e = 1;//empty jump to next block + continue; + } + if (strncmp(tar.magic, "ustar", 5)) { + //try detecting by reading magic +CHECK_MAGIC: + gzMagic = (unsigned char*)&tar; + if ((gzMagic[0] == 0x1f) && (gzMagic[1] == 0x8b) + && !lseek(tar_hdl->src_fd, -i, SEEK_CUR)) { + tar_hdl->offset -= i; + extract_stream(tar_hdl); + continue; + } + error_exit("invalid tar format"); + } + + for (j = 0; j<148; j++) cksum += (unsigned int)((char*)&tar)[j]; + for (j = 156; j<500; j++) cksum += (unsigned int)((char*)&tar)[j]; + //cksum field itself treated as ' ' + for ( j= 0; j<8; j++) cksum += (unsigned int)' '; + + if (cksum != otoi(tar.chksum, sizeof(tar.chksum))) error_exit("wrong cksum"); + + file_hdr = &tar_hdl->file_hdr; + memset(file_hdr, 0, sizeof(struct file_header)); + file_hdr->mode = otoi(tar.mode, sizeof(tar.mode)); + file_hdr->uid = otoi(tar.uid, sizeof(tar.uid)); + file_hdr->gid = otoi(tar.gid, sizeof(tar.gid)); + file_hdr->size = otoi(tar.size, sizeof(tar.size)); + file_hdr->mtime = otoi(tar.mtime, sizeof(tar.mtime)); + file_hdr->uname = xstrdup(tar.uname); + file_hdr->gname = xstrdup(tar.gname); + maj = otoi(tar.major, sizeof(tar.major)); + min = otoi(tar.minor, sizeof(tar.minor)); + file_hdr->device = makedev(maj, min); + + if (tar.type <= '7') { + if (tar.link[0]) { + sz = sizeof(tar.link); + file_hdr->link_target = xmalloc(sz + 1); + memcpy(file_hdr->link_target, tar.link, sz); + file_hdr->link_target[sz] = '\0'; + } + + file_hdr->name = xzalloc(256);// pathname supported size + if (tar.prefix[0]) { + memcpy(file_hdr->name, tar.prefix, sizeof(tar.prefix)); + sz = strlen(file_hdr->name); + if (file_hdr->name[sz-1] != '/') file_hdr->name[sz] = '/'; + } + sz = strlen(file_hdr->name); + memcpy(file_hdr->name + sz, tar.name, sizeof(tar.name)); + if (file_hdr->name[255]) error_exit("filename too long"); + } + + switch (tar.type) { + // case '\0': + case '0': + case '7': + case '1': //Hard Link + file_hdr->mode |= S_IFREG; + break; + case '2': + file_hdr->mode |= S_IFLNK; + break; + case '3': + file_hdr->mode |= S_IFCHR; + break; + case '4': + file_hdr->mode |= S_IFBLK; + break; + case '5': + file_hdr->mode |= S_IFDIR; + break; + case '6': + file_hdr->mode |= S_IFIFO; + break; + case 'K': + longlink = xzalloc(file_hdr->size +1); + xread(tar_hdl->src_fd, longlink, file_hdr->size); + tar_hdl->offset += file_hdr->size; + continue; + case 'L': + free(longname); + longname = xzalloc(file_hdr->size +1); + xread(tar_hdl->src_fd, longname, file_hdr->size); + tar_hdl->offset += file_hdr->size; + continue; + case 'D': + case 'M': + case 'N': + case 'S': + case 'V': + case 'g': // pax global header + tar_skip(tar_hdl, file_hdr->size); + continue; + case 'x': // pax extended header + free(longname); + longname = process_extended_hdr(tar_hdl, file_hdr->size); + continue; + default: break; + } + + if (longname) { + free(file_hdr->name); + file_hdr->name = longname; + longname = NULL; + } + if (longlink) { + free(file_hdr->link_target); + file_hdr->link_target = longlink; + longlink = NULL; + } + + if ((file_hdr->mode & S_IFREG) && + file_hdr->name[strlen(file_hdr->name)-1] == '/') { + file_hdr->name[strlen(file_hdr->name)-1] = '\0'; + file_hdr->mode &= ~S_IFREG; + file_hdr->mode |= S_IFDIR; + } + + if ((file_hdr->link_target && *(file_hdr->link_target)) + || S_ISLNK(file_hdr->mode) || S_ISDIR(file_hdr->mode)) + file_hdr->size = 0; + + if (filter(TT.exc, file_hdr->name) || + (TT.inc && !filter(TT.inc, file_hdr->name))) goto SKIP; + add_to_list(&TT.pass, xstrdup(file_hdr->name)); + + if (toys.optflags & FLAG_t) { + if (toys.optflags & FLAG_v) { + char perm[11]; + struct tm *lc = localtime((const time_t*)&(file_hdr->mtime)); + + mode_to_string(file_hdr->mode, perm); + printf("%s %s/%s %9ld %d-%02d-%02d %02d:%02d:%02d ",perm,file_hdr->uname, + file_hdr->gname, (long)file_hdr->size, 1900+lc->tm_year, + 1+lc->tm_mon, lc->tm_mday, lc->tm_hour, lc->tm_min, lc->tm_sec); + } + printf("%s",file_hdr->name); + if (file_hdr->link_target) printf(" -> %s",file_hdr->link_target); + xputc('\n'); +SKIP: + tar_skip(tar_hdl, file_hdr->size); + } else { + if (toys.optflags & FLAG_v) printf("%s\n",file_hdr->name); + tar_hdl->extract_handler(tar_hdl); + } + free(file_hdr->name); + free(file_hdr->link_target); + free(file_hdr->uname); + free(file_hdr->gname); + } +} + +void tar_main(void) +{ + struct archive_handler *tar_hdl; + int fd = 0, flags = O_RDONLY; + struct arg_list *tmp; + char **args = toys.optargs; + + if (!toys.argv[1]) { + toys.exithelp++; + error_exit(NULL); + } + + if (!geteuid()) toys.optflags |= FLAG_p; + + for (tmp = TT.exc; tmp; tmp = tmp->next) + tmp->arg = xstrdup(tmp->arg); //freeing at the end fails otherwise + + while(*args) add_to_list(&TT.inc, xstrdup(*args++)); + if (toys.optflags & FLAG_X) add_from_file(&TT.exc, TT.exc_file); + if (toys.optflags & FLAG_T) add_from_file(&TT.inc, TT.inc_file); + + if (toys.optflags & FLAG_c) { + if (!TT.inc) error_exit("empty archive"); + fd = 1, flags = O_WRONLY|O_CREAT|O_TRUNC; + } + if ((toys.optflags & FLAG_f) && strcmp(TT.fname, "-")) + fd = xcreate(TT.fname, flags, 0666); + if (toys.optflags & FLAG_C) xchdir(TT.dir); + + tar_hdl = init_handler(); + tar_hdl->src_fd = fd; + + if (toys.optflags & FLAG_x || toys.optflags & FLAG_t) { + if (toys.optflags & FLAG_O) tar_hdl->extract_handler = extract_to_stdout; + if (toys.optflags & FLAG_to_command) { + signal(SIGPIPE, SIG_IGN); //will be using pipe between child & parent + tar_hdl->extract_handler = extract_to_command; + } + if (toys.optflags & FLAG_z) extract_stream(tar_hdl); + unpack_tar(tar_hdl); + for (tmp = TT.inc; tmp; tmp = tmp->next) + if (!filter(TT.exc, tmp->arg) && !filter(TT.pass, tmp->arg)) + error_msg("'%s' not in archive", tmp->arg); + } else if (toys.optflags & FLAG_c) { + //create the tar here. + if (toys.optflags & FLAG_z) compress_stream(tar_hdl); + for (tmp = TT.inc; tmp; tmp = tmp->next) { + TT.handle = tar_hdl; + //recurse thru dir and add files to archive + struct dirtree *root = dirtree_add_node(0,tmp->arg,toys.optflags & FLAG_h); + + if (root) dirtree_handle_callback(root, add_to_tar); + } + memset(toybuf, 0, 1024); + writeall(tar_hdl->src_fd, toybuf, 1024); + seen_inode(&TT.inodes, 0, 0); + } + + if (CFG_TOYBOX_FREE) { + close(tar_hdl->src_fd); + free(tar_hdl); + llist_traverse(TT.exc, llist_free_arg); + llist_traverse(TT.inc, llist_free_arg); + llist_traverse(TT.pass, llist_free_arg); + } +} |