1553 lines
32 KiB
C
1553 lines
32 KiB
C
/*
|
|
* tar - `tape archiver', actually usable on any medium.
|
|
* POSIX "ustar" compliant when extracting, and by default when creating.
|
|
* this tar attempts to read and write multiple Tblock-byte blocks
|
|
* at once to and from the filesystem, and does not copy blocks
|
|
* around internally.
|
|
*/
|
|
|
|
#include <u.h>
|
|
#include <libc.h>
|
|
#include <ctype.h>
|
|
#include <fcall.h> /* for %M */
|
|
#include <String.h>
|
|
|
|
/*
|
|
* modified versions of those in libc.h; scans only the first arg for
|
|
* keyletters and options.
|
|
*/
|
|
#define TARGBEGIN {\
|
|
(argv0 || (argv0 = *argv)), argv++, argc--;\
|
|
if (argv[0]) {\
|
|
char *_args, *_argt;\
|
|
Rune _argc;\
|
|
_args = &argv[0][0];\
|
|
_argc = 0;\
|
|
while(*_args && (_args += chartorune(&_argc, _args)))\
|
|
switch(_argc)
|
|
#define TARGEND SET(_argt); USED(_argt);USED(_argc);USED(_args); \
|
|
argc--, argv++; } \
|
|
USED(argv); USED(argc); }
|
|
#define TARGC() (_argc)
|
|
|
|
#define ROUNDUP(a, b) (((a) + (b) - 1)/(b))
|
|
#define BYTES2TBLKS(bytes) ROUNDUP(bytes, Tblock)
|
|
|
|
/* read big-endian binary integers; args must be (uchar *) */
|
|
#define G2BEBYTE(x) (((x)[0]<<8) | (x)[1])
|
|
#define G3BEBYTE(x) (((x)[0]<<16) | ((x)[1]<<8) | (x)[2])
|
|
#define G4BEBYTE(x) (((x)[0]<<24) | ((x)[1]<<16) | ((x)[2]<<8) | (x)[3])
|
|
#define G8BEBYTE(x) (((vlong)G4BEBYTE(x)<<32) | (u32int)G4BEBYTE((x)+4))
|
|
|
|
typedef vlong Off;
|
|
typedef char *(*Refill)(int ar, char *bufs, int justhdr);
|
|
|
|
enum { Stdin, Stdout, Stderr };
|
|
enum { Rd, Wr }; /* pipe fd-array indices */
|
|
enum { Output, Input };
|
|
enum { None, Toc, Xtract, Replace };
|
|
enum { Alldata, Justnxthdr };
|
|
enum {
|
|
Tblock = 512,
|
|
Namsiz = 100,
|
|
Maxpfx = 155, /* from POSIX */
|
|
Maxname = Namsiz + 1 + Maxpfx,
|
|
Maxlongname = 65535,
|
|
Binsize = 0x80, /* flag in size[0], from gnu: positive binary size */
|
|
Binnegsz = 0xff, /* flag in size[0]: negative binary size */
|
|
|
|
Nblock = 40, /* maximum blocksize */
|
|
Dblock = 20, /* default blocksize */
|
|
Debug = 0,
|
|
};
|
|
|
|
/* POSIX link flags */
|
|
enum {
|
|
LF_PLAIN1 = '\0',
|
|
LF_PLAIN2 = '0',
|
|
LF_LINK = '1',
|
|
LF_SYMLINK1 = '2',
|
|
LF_SYMLINK2 = 's', /* 4BSD used this */
|
|
LF_CHR = '3',
|
|
LF_BLK = '4',
|
|
LF_DIR = '5',
|
|
LF_FIFO = '6',
|
|
LF_CONTIG = '7',
|
|
|
|
/* 'A' - 'Z' are reserved for custom implementations */
|
|
|
|
LF_LONGNAME = 'L', /* GNU extenstion */
|
|
LF_LONGLINK = 'K',
|
|
LF_PAXHDR = 'x', /* PAX header */
|
|
LF_PAXGLOBL = 'g',
|
|
};
|
|
|
|
#define islink(lf) (isreallink(lf) || issymlink(lf))
|
|
#define isreallink(lf) ((lf) == LF_LINK)
|
|
#define issymlink(lf) ((lf) == LF_SYMLINK1 || (lf) == LF_SYMLINK2)
|
|
|
|
typedef union {
|
|
uchar data[Tblock];
|
|
struct {
|
|
char name[Namsiz];
|
|
char mode[8];
|
|
char uid[8];
|
|
char gid[8];
|
|
char size[12];
|
|
char mtime[12];
|
|
char chksum[8];
|
|
char linkflag;
|
|
char linkname[Namsiz];
|
|
|
|
/* rest are defined by POSIX's ustar format; see p1003.2b */
|
|
char magic[6]; /* "ustar" */
|
|
char version[2];
|
|
char uname[32];
|
|
char gname[32];
|
|
char devmajor[8];
|
|
char devminor[8];
|
|
char prefix[Maxpfx]; /* if non-null, path= prefix "/" name */
|
|
};
|
|
} Blk;
|
|
|
|
typedef struct {
|
|
char *name;
|
|
char *uid;
|
|
char *gid;
|
|
ulong mode;
|
|
vlong size;
|
|
vlong mtime;
|
|
vlong atime;
|
|
} Hdr;
|
|
|
|
typedef struct {
|
|
char *comp;
|
|
char *decomp;
|
|
char *sfx[4];
|
|
} Compress;
|
|
|
|
static Compress comps[] = {
|
|
"gzip", "gunzip", { ".tar.gz", ".tgz" }, /* default */
|
|
"compress", "uncompress", { ".tar.Z", ".tz" },
|
|
"bzip2", "bunzip2", { ".tar.bz", ".tbz",
|
|
".tar.bz2",".tbz2" },
|
|
};
|
|
|
|
typedef struct {
|
|
int kid;
|
|
int fd; /* original fd */
|
|
int rfd; /* replacement fd */
|
|
int input;
|
|
int open;
|
|
} Pushstate;
|
|
|
|
#define OTHER(rdwr) ((rdwr) == Rd? Wr: Rd)
|
|
|
|
static int fixednblock;
|
|
static int verb;
|
|
static int posix = 1;
|
|
static int docreate;
|
|
static int aruid;
|
|
static int argid;
|
|
static int relative = 1;
|
|
static int settime;
|
|
static int verbose;
|
|
static int docompress;
|
|
static int keepexisting;
|
|
static int ignerrs; /* flag: ignore i/o errors if possible */
|
|
static Off blkoff; /* offset of the current archive block (not Tblock) */
|
|
static Off nexthdr;
|
|
|
|
static int nblock = Dblock;
|
|
static int resync;
|
|
static char *usefile, *arname = "archive";
|
|
static char origdir[Maxlongname+1];
|
|
static Blk *tpblk, *endblk;
|
|
static Blk *curblk;
|
|
static Hdr globlhdr;
|
|
|
|
static void
|
|
usage(void)
|
|
{
|
|
fprint(2, "usage: %s {crtx}[PRTfgikmpsuvz] [archive] [file1 file2...]\n",
|
|
argv0);
|
|
exits("usage");
|
|
}
|
|
|
|
/* I/O, with error retry or exit */
|
|
|
|
static int
|
|
cope(char *name, int fd, void *buf, long len, Off off)
|
|
{
|
|
fprint(2, "%s: %serror reading %s: %r\n", argv0,
|
|
(ignerrs? "ignoring ": ""), name);
|
|
if (!ignerrs)
|
|
exits("read error");
|
|
|
|
/* pretend we read len bytes of zeroes */
|
|
memset(buf, 0, len);
|
|
if (off >= 0) /* seekable? */
|
|
seek(fd, off + len, 0);
|
|
return len;
|
|
}
|
|
|
|
static int
|
|
eread(char *name, int fd, void *buf, long len)
|
|
{
|
|
int rd;
|
|
Off off;
|
|
|
|
off = seek(fd, 0, 1); /* for coping with errors */
|
|
rd = read(fd, buf, len);
|
|
if (rd < 0)
|
|
rd = cope(name, fd, buf, len, off);
|
|
return rd;
|
|
}
|
|
|
|
static int
|
|
ereadn(char *name, int fd, void *buf, long len)
|
|
{
|
|
int rd;
|
|
Off off;
|
|
|
|
off = seek(fd, 0, 1);
|
|
rd = readn(fd, buf, len);
|
|
if (rd < 0)
|
|
rd = cope(name, fd, buf, len, off);
|
|
return rd;
|
|
}
|
|
|
|
static int
|
|
ewrite(char *name, int fd, void *buf, long len)
|
|
{
|
|
int rd;
|
|
|
|
werrstr("");
|
|
rd = write(fd, buf, len);
|
|
if (rd != len)
|
|
sysfatal("error writing %s: %r", name);
|
|
return rd;
|
|
}
|
|
|
|
/* compression */
|
|
|
|
static Compress *
|
|
compmethod(char *name)
|
|
{
|
|
if (name) {
|
|
int i, nmlen, sfxlen;
|
|
Compress *cp;
|
|
|
|
nmlen = strlen(name);
|
|
for (cp = comps; cp < comps + nelem(comps); cp++) {
|
|
for (i = 0; i < nelem(cp->sfx) && cp->sfx[i]; i++) {
|
|
sfxlen = strlen(cp->sfx[i]);
|
|
if (nmlen > sfxlen &&
|
|
strcmp(cp->sfx[i], name + nmlen - sfxlen) == 0)
|
|
return cp;
|
|
}
|
|
}
|
|
}
|
|
return docompress? comps: nil;
|
|
}
|
|
|
|
/*
|
|
* push a filter, cmd, onto fd. if input, it's an input descriptor.
|
|
* returns a descriptor to replace fd, or -1 on error.
|
|
*/
|
|
static int
|
|
push(int fd, char *cmd, int input, Pushstate *ps)
|
|
{
|
|
int nfd, pifds[2];
|
|
String *s;
|
|
|
|
ps->open = 0;
|
|
ps->fd = fd;
|
|
ps->input = input;
|
|
if (fd < 0 || pipe(pifds) < 0)
|
|
return -1;
|
|
ps->kid = fork();
|
|
switch (ps->kid) {
|
|
case -1:
|
|
return -1;
|
|
case 0:
|
|
if (input)
|
|
dup(pifds[Wr], Stdout);
|
|
else
|
|
dup(pifds[Rd], Stdin);
|
|
close(pifds[input? Rd: Wr]);
|
|
dup(fd, (input? Stdin: Stdout));
|
|
s = s_new();
|
|
if (cmd[0] != '/')
|
|
s_append(s, "/bin/");
|
|
s_append(s, cmd);
|
|
execl(s_to_c(s), cmd, nil);
|
|
sysfatal("can't exec %s: %r", cmd);
|
|
default:
|
|
nfd = pifds[input? Rd: Wr];
|
|
close(pifds[input? Wr: Rd]);
|
|
break;
|
|
}
|
|
ps->rfd = nfd;
|
|
ps->open = 1;
|
|
return nfd;
|
|
}
|
|
|
|
static char *
|
|
pushclose(Pushstate *ps)
|
|
{
|
|
Waitmsg *wm;
|
|
|
|
if (ps->fd < 0 || ps->rfd < 0 || !ps->open)
|
|
return "not open";
|
|
close(ps->rfd);
|
|
ps->rfd = -1;
|
|
ps->open = 0;
|
|
while ((wm = wait()) != nil && wm->pid != ps->kid)
|
|
continue;
|
|
return wm? wm->msg: nil;
|
|
}
|
|
|
|
/*
|
|
* block-buffer management
|
|
*/
|
|
|
|
static void
|
|
initblks(void)
|
|
{
|
|
free(tpblk);
|
|
tpblk = malloc(Tblock * nblock);
|
|
assert(tpblk != nil);
|
|
endblk = tpblk + nblock;
|
|
}
|
|
|
|
/*
|
|
* (re)fill block buffers from archive. `justhdr' means we don't care
|
|
* about the data before the next header block.
|
|
*/
|
|
static char *
|
|
refill(int ar, char *bufs, int justhdr)
|
|
{
|
|
int i, n;
|
|
unsigned bytes = Tblock * nblock;
|
|
static int done, first = 1, seekable;
|
|
|
|
if (done)
|
|
return nil;
|
|
|
|
blkoff = seek(ar, 0, 1); /* note position for `tar r' */
|
|
if (first)
|
|
seekable = blkoff >= 0;
|
|
/* try to size non-pipe input at first read */
|
|
if (first && usefile && !fixednblock) {
|
|
n = eread(arname, ar, bufs, bytes);
|
|
if (n == 0)
|
|
sysfatal("EOF reading archive %s: %r", arname);
|
|
i = n;
|
|
if (i % Tblock != 0)
|
|
sysfatal("%s: archive block size (%d) error", arname, i);
|
|
i /= Tblock;
|
|
if (i != nblock) {
|
|
nblock = i;
|
|
fprint(2, "%s: blocking = %d\n", argv0, nblock);
|
|
endblk = (Blk *)bufs + nblock;
|
|
bytes = n;
|
|
}
|
|
} else if (justhdr && seekable && nexthdr - blkoff >= bytes) {
|
|
/* optimisation for huge archive members on seekable media */
|
|
if (seek(ar, bytes, 1) < 0)
|
|
sysfatal("can't seek on archive %s: %r", arname);
|
|
n = bytes;
|
|
} else
|
|
n = ereadn(arname, ar, bufs, bytes);
|
|
first = 0;
|
|
|
|
if (n == 0)
|
|
sysfatal("unexpected EOF reading archive %s", arname);
|
|
if (n % Tblock != 0)
|
|
sysfatal("partial block read from archive %s", arname);
|
|
if (n != bytes) {
|
|
done = 1;
|
|
memset(bufs + n, 0, bytes - n);
|
|
}
|
|
return bufs;
|
|
}
|
|
|
|
static Blk *
|
|
getblk(int ar, Refill rfp, int justhdr)
|
|
{
|
|
if (curblk == nil || curblk >= endblk) { /* input block exhausted? */
|
|
if (rfp != nil && (*rfp)(ar, (char *)tpblk, justhdr) == nil)
|
|
return nil;
|
|
curblk = tpblk;
|
|
}
|
|
return curblk++;
|
|
}
|
|
|
|
static Blk *
|
|
getblkrd(int ar, int justhdr)
|
|
{
|
|
return getblk(ar, refill, justhdr);
|
|
}
|
|
|
|
static Blk *
|
|
getblke(int ar)
|
|
{
|
|
return getblk(ar, nil, Alldata);
|
|
}
|
|
|
|
static Blk *
|
|
getblkz(int ar)
|
|
{
|
|
Blk *bp = getblke(ar);
|
|
|
|
if (bp != nil)
|
|
memset(bp->data, 0, Tblock);
|
|
return bp;
|
|
}
|
|
|
|
/*
|
|
* how many block buffers are available, starting at the address
|
|
* just returned by getblk*?
|
|
*/
|
|
static int
|
|
gothowmany(int max)
|
|
{
|
|
int n = endblk - (curblk - 1);
|
|
|
|
return n > max? max: n;
|
|
}
|
|
|
|
/*
|
|
* indicate that one is done with the last block obtained from getblke
|
|
* and it is now available to be written into the archive.
|
|
*/
|
|
static void
|
|
putlastblk(int ar)
|
|
{
|
|
unsigned bytes = Tblock * nblock;
|
|
|
|
/* if writing end-of-archive, aid compression (good hygiene too) */
|
|
if (curblk < endblk)
|
|
memset(curblk, 0, (char *)endblk - (char *)curblk);
|
|
ewrite(arname, ar, tpblk, bytes);
|
|
}
|
|
|
|
static void
|
|
putblk(int ar)
|
|
{
|
|
if (curblk >= endblk)
|
|
putlastblk(ar);
|
|
}
|
|
|
|
static void
|
|
putbackblk(int ar)
|
|
{
|
|
curblk--;
|
|
USED(ar);
|
|
}
|
|
|
|
static void
|
|
putreadblks(int ar, int blks)
|
|
{
|
|
curblk += blks - 1;
|
|
USED(ar);
|
|
}
|
|
|
|
static void
|
|
putblkmany(int ar, int blks)
|
|
{
|
|
assert(blks > 0);
|
|
curblk += blks - 1;
|
|
putblk(ar);
|
|
}
|
|
|
|
/*
|
|
* common routines
|
|
*/
|
|
|
|
/*
|
|
* modifies hp->chksum but restores it; important for the last block of the
|
|
* old archive when updating with `tar rf archive'
|
|
*/
|
|
static long
|
|
chksum(Blk *bp)
|
|
{
|
|
int n = Tblock;
|
|
long i = 0;
|
|
uchar *cp = bp->data;
|
|
char oldsum[sizeof bp->chksum];
|
|
|
|
memmove(oldsum, bp->chksum, sizeof oldsum);
|
|
memset(bp->chksum, ' ', sizeof bp->chksum);
|
|
while (n-- > 0)
|
|
i += *cp++;
|
|
memmove(bp->chksum, oldsum, sizeof oldsum);
|
|
return i;
|
|
}
|
|
|
|
static int
|
|
isustar(Blk *bp)
|
|
{
|
|
return strcmp(bp->magic, "ustar") == 0;
|
|
}
|
|
|
|
/*
|
|
* s is at most n bytes long, but need not be NUL-terminated.
|
|
* if shorter than n bytes, all bytes after the first NUL must also
|
|
* be NUL.
|
|
*/
|
|
static int
|
|
strnlen(char *s, int n)
|
|
{
|
|
return s[n - 1] != '\0'? n: strlen(s);
|
|
}
|
|
|
|
/* set fullname from header */
|
|
static char *
|
|
parsename(Blk *bp, char *buf, int nbuf)
|
|
{
|
|
int pfxlen, namlen;
|
|
|
|
namlen = strnlen(bp->name, sizeof bp->name);
|
|
if (bp->prefix[0] == '\0' || !isustar(bp)) { /* old-style name? */
|
|
assert(nbuf > namlen);
|
|
memmove(buf, bp->name, namlen);
|
|
buf[namlen] = '\0';
|
|
return buf;
|
|
}
|
|
|
|
/* name is in two pieces */
|
|
pfxlen = strnlen(bp->prefix, sizeof bp->prefix);
|
|
assert(nbuf > pfxlen + 1 + namlen);
|
|
memmove(buf, bp->prefix, pfxlen);
|
|
buf[pfxlen] = '/';
|
|
memmove(buf + pfxlen + 1, bp->name, namlen);
|
|
buf[pfxlen + 1 + namlen] = '\0';
|
|
return buf;
|
|
}
|
|
|
|
static int
|
|
isdir(Blk *bp, char *name)
|
|
{
|
|
/* the mode test is ugly but sometimes necessary */
|
|
return bp->linkflag == LF_DIR ||
|
|
strrchr(name, '\0')[-1] == '/' ||
|
|
(strtoul(bp->mode, nil, 8)&0170000) == 040000;
|
|
}
|
|
|
|
static int
|
|
eotar(Blk *bp)
|
|
{
|
|
char buf[Maxname + 1];
|
|
return parsename(bp, buf, sizeof(buf))[0] == '\0';
|
|
}
|
|
|
|
/*
|
|
static uvlong
|
|
getbe(uchar *src, int size)
|
|
{
|
|
uvlong vl = 0;
|
|
|
|
while (size-- > 0) {
|
|
vl <<= 8;
|
|
vl |= *src++;
|
|
}
|
|
return vl;
|
|
}
|
|
*/
|
|
|
|
static void
|
|
putbe(uchar *dest, uvlong vl, int size)
|
|
{
|
|
for (dest += size; size-- > 0; vl >>= 8)
|
|
*--dest = vl;
|
|
}
|
|
|
|
/*
|
|
* cautious parsing of octal numbers as ascii strings in
|
|
* a tar header block. this is particularly important for
|
|
* trusting the checksum when trying to resync.
|
|
*/
|
|
static uvlong
|
|
hdrotoull(char *st, char *end, uvlong errval, char *name, char *field)
|
|
{
|
|
char *numb;
|
|
|
|
for (numb = st; (*numb == ' ' || *numb == '\0') && numb < end; numb++)
|
|
;
|
|
if (numb < end && isascii(*numb) && isdigit(*numb))
|
|
return strtoull(numb, nil, 8);
|
|
else if (numb >= end)
|
|
fprint(2, "%s: %s: empty %s in header\n", argv0, name, field);
|
|
else
|
|
fprint(2, "%s: %s: %s: non-numeric %s in header\n",
|
|
argv0, name, numb, field);
|
|
return errval;
|
|
}
|
|
|
|
/*
|
|
* return the nominal size from the header block, which is not always the
|
|
* size in the archive (the archive size may be zero for some file types
|
|
* regardless of the nominal size).
|
|
*
|
|
* gnu and freebsd tars are now recording vlongs as big-endian binary
|
|
* with a flag in byte 0 to indicate this, which permits file sizes up to
|
|
* 2^64-1 (actually 2^80-1 but our file sizes are vlongs) rather than 2^33-1.
|
|
*/
|
|
static Off
|
|
hdrsize(Blk *bp)
|
|
{
|
|
uchar *p;
|
|
char buf[Maxname + 1];
|
|
|
|
if((uchar)bp->size[0] == Binnegsz) {
|
|
fprint(2, "%s: %s: negative length, which is insane\n",
|
|
argv0, parsename(bp, buf, sizeof(buf)));
|
|
return 0;
|
|
} else if((uchar)bp->size[0] == Binsize) {
|
|
p = (uchar *)bp->size + sizeof bp->size - 1 -
|
|
sizeof(vlong); /* -1 for terminating space */
|
|
return G8BEBYTE(p);
|
|
}
|
|
|
|
return hdrotoull(bp->size, bp->size + sizeof bp->size, 0,
|
|
parsename(bp, buf, sizeof(buf)), "size");
|
|
}
|
|
|
|
/*
|
|
* return the number of bytes recorded in the archive.
|
|
*/
|
|
static Off
|
|
arsize(Blk *bp, char *fname)
|
|
{
|
|
if(isdir(bp, fname) || islink(bp->linkflag))
|
|
return 0;
|
|
return hdrsize(bp);
|
|
}
|
|
|
|
static long
|
|
parsecksum(char *cksum, char *name)
|
|
{
|
|
Blk *bp;
|
|
|
|
return hdrotoull(cksum, cksum + sizeof bp->chksum, (uvlong)-1LL,
|
|
name, "checksum");
|
|
}
|
|
|
|
static Blk *
|
|
readhdrblk(int ar)
|
|
{
|
|
char buf[Maxname + 1];
|
|
long hdrcksum;
|
|
Blk *bp;
|
|
|
|
bp = getblkrd(ar, Alldata);
|
|
if (bp == nil)
|
|
sysfatal("unexpected EOF instead of archive header in %s",
|
|
arname);
|
|
if (eotar(bp)) /* end-of-archive block? */
|
|
return nil;
|
|
|
|
hdrcksum = parsecksum(bp->chksum, parsename(bp, buf, sizeof(buf)));
|
|
if (hdrcksum == -1 || chksum(bp) != hdrcksum) {
|
|
if (!resync)
|
|
sysfatal("bad archive header checksum in %s: "
|
|
"name %.100s...; expected %#luo got %#luo",
|
|
arname, bp->name, hdrcksum, chksum(bp));
|
|
fprint(2, "%s: skipping past archive header with bad checksum in %s...",
|
|
argv0, arname);
|
|
do {
|
|
bp = getblkrd(ar, Alldata);
|
|
if (bp == nil)
|
|
sysfatal("unexpected EOF looking for archive header in %s",
|
|
arname);
|
|
hdrcksum = parsecksum(bp->chksum, parsename(bp, buf, sizeof(buf)));
|
|
} while (hdrcksum == -1 || chksum(bp) != hdrcksum);
|
|
fprint(2, "found %s\n", parsename(bp, buf, sizeof(buf)));
|
|
}
|
|
nexthdr += Tblock*(1 + BYTES2TBLKS(hdrsize(bp)));
|
|
|
|
return bp;
|
|
}
|
|
|
|
static int
|
|
getname(int ar, Blk *bp, Hdr *hdr)
|
|
{
|
|
char buf[Maxlongname+1];
|
|
ulong blksleft, blksread;
|
|
char *p;
|
|
int n;
|
|
|
|
if (bp->linkflag != LF_LONGNAME){
|
|
/* PAX attributes take precedence */
|
|
if(hdr->name == nil)
|
|
hdr->name = strdup(parsename(bp, buf, sizeof(buf)));
|
|
return 0;
|
|
}
|
|
|
|
p = buf;
|
|
for (blksleft = BYTES2TBLKS(hdrsize(bp)); blksleft > 0; blksleft -= blksread) {
|
|
bp = getblkrd(ar, Alldata);
|
|
if (bp == nil)
|
|
sysfatal("unexpected EOF on archive reading from %s", arname);
|
|
blksread = gothowmany(blksleft);
|
|
n = &buf[Maxlongname] - p;
|
|
if(Tblock*blksread < n)
|
|
n = Tblock*blksread;
|
|
memmove(p, bp->data, n);
|
|
p += n;
|
|
}
|
|
*p = '\0';
|
|
hdr->name = strdup(buf);
|
|
return 1;
|
|
}
|
|
|
|
static char *
|
|
matchattr(char *kvp, char *k)
|
|
{
|
|
if (strncmp(kvp, k, strlen(k)) == 0)
|
|
return kvp + strlen(k);
|
|
return nil;
|
|
}
|
|
|
|
static int
|
|
parsepax(int ar, Blk *bp, Hdr *hdr, int paxtype)
|
|
{
|
|
char *p, *lp, *le, *e, *kvp, *val, lenbuf[16];
|
|
ulong blksleft;
|
|
int n, off, len;
|
|
Blk *b;
|
|
|
|
if (!isustar(bp) || bp->linkflag != paxtype)
|
|
return 0;
|
|
off = 0;
|
|
len = -1;
|
|
kvp = nil;
|
|
lp = lenbuf;
|
|
le = lenbuf + sizeof(lenbuf);
|
|
for (blksleft = BYTES2TBLKS(hdrsize(bp)); blksleft > 0; ) {
|
|
b = getblkrd(ar, Alldata);
|
|
if (b == nil)
|
|
sysfatal("unexpected EOF on archive reading attr for %s from %s", bp->name, arname);
|
|
p = (char *)b->data;
|
|
e = (char *)b->data + sizeof(b->data);
|
|
while(p != e) {
|
|
if(*p == '\0')
|
|
break;
|
|
/*
|
|
* Copy out the length prefix. This may span a block boundary, so be
|
|
* careful about when we get the next block. The length prefix includes
|
|
* both its own length and the trailing newline. We want to trim the
|
|
* length prefix, since we already consumed it.
|
|
*/
|
|
if(len == -1){
|
|
while(p != e && *p >= '0' && *p <= '9'){
|
|
if(lp + 1 == le)
|
|
sysfatal("oversize length prefix in pax header");
|
|
*lp++ = *p++;
|
|
}
|
|
if (p == e && blksleft > 0)
|
|
goto nextblk;
|
|
if (*p++ != ' ')
|
|
sysfatal("invalid delimiter in pax header: %c (%s)\n", *p, p);
|
|
*lp++ = '\0';
|
|
len = atoi(lenbuf) - strlen(lenbuf) - 1;
|
|
}
|
|
|
|
if (kvp == nil && (kvp = malloc(len)) == nil)
|
|
sysfatal("out of memory: %r");
|
|
n = (len - off > e - p) ? e - p : len - off;
|
|
memcpy(kvp + off, p, n);
|
|
kvp[len - 1] = '\0';
|
|
off += n;
|
|
p += n;
|
|
assert(e >= p);
|
|
if (len == off) {
|
|
if ((val = matchattr(kvp, "path=")) != nil) {
|
|
free(hdr->name);
|
|
hdr->name = strdup(val);
|
|
} else if ((val = matchattr(kvp, "linkpath=")) != nil) {
|
|
/* Mostly for better error messages. */
|
|
free(hdr->name);
|
|
hdr->name = strdup(val);
|
|
} else if ((val = matchattr(kvp, "uname=")) != nil) {
|
|
free(hdr->uid);
|
|
hdr->uid = strdup(val);
|
|
} else if ((val = matchattr(kvp, "gname=")) != nil) {
|
|
free(hdr->gid);
|
|
hdr->gid = strdup(val);
|
|
} else if ((val = matchattr(kvp, "atime=")) != nil)
|
|
hdr->atime = strtoll(val, nil, 0);
|
|
else if ((val = matchattr(kvp, "mtime=")) != nil)
|
|
hdr->mtime = strtoll(val, nil, 0);
|
|
else if ((val = matchattr(kvp, "size=")) != nil)
|
|
hdr->size = strtoll(val, nil, 0);
|
|
else
|
|
if (matchattr(kvp, "comment=") == nil && matchattr(kvp, "ctime=") == nil)
|
|
fprint(2, "warning: pax attribute not supported: %s\n", kvp);
|
|
free(kvp);
|
|
kvp = nil;
|
|
lp = lenbuf;
|
|
off = 0;
|
|
len = -1;
|
|
}
|
|
}
|
|
nextblk:
|
|
blksleft--;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
parsehdr(Hdr *hdr, Blk *bp)
|
|
{
|
|
int ustar;
|
|
|
|
ustar = isustar(bp);
|
|
if(hdr->mode == -1)
|
|
hdr->mode = (strtoul(bp->mode, nil, 8) & 0777);
|
|
if(hdr->mode == -1)
|
|
hdr->mode = globlhdr.mode;
|
|
if (isdir(bp, hdr->name))
|
|
hdr->mode |= DMDIR;
|
|
if (hdr->atime == -1)
|
|
hdr->atime = -1;
|
|
if (hdr->atime == -1)
|
|
hdr->atime = globlhdr.atime;
|
|
if (hdr->mtime == -1)
|
|
hdr->mtime = strtol(bp->mtime, nil, 8);
|
|
if (hdr->mtime == -1)
|
|
hdr->mtime = globlhdr.mtime;
|
|
if (hdr->size == -1)
|
|
hdr->size = arsize(bp, hdr->name);
|
|
if (ustar && hdr->uid == nil)
|
|
hdr->uid = strdup(bp->uname);
|
|
if (hdr->uid == nil)
|
|
hdr->uid = (globlhdr.uid != nil) ? strdup(globlhdr.uid) : nil;
|
|
if (ustar && hdr->gid == nil)
|
|
hdr->gid = strdup(bp->uname);
|
|
if (hdr->gid == nil)
|
|
hdr->gid = (globlhdr.gid != nil) ? strdup(globlhdr.gid) : nil;
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
nullhdr(Hdr *hdr)
|
|
{
|
|
hdr->name = nil;
|
|
hdr->uid = nil;
|
|
hdr->gid = nil;
|
|
hdr->mode = -1;
|
|
hdr->mtime = -1;
|
|
hdr->atime = -1;
|
|
hdr->size = -1;
|
|
}
|
|
|
|
static Blk *
|
|
readhdr(int ar, Hdr *hdr)
|
|
{
|
|
Blk *bp;
|
|
|
|
nullhdr(hdr);
|
|
again:
|
|
if ((bp = readhdrblk(ar)) == nil)
|
|
return nil;
|
|
if (parsepax(ar, bp, hdr, LF_PAXHDR))
|
|
goto again;
|
|
if (parsepax(ar, bp, &globlhdr, LF_PAXGLOBL))
|
|
goto again;
|
|
if (getname(ar, bp, hdr))
|
|
goto again;
|
|
if (parsehdr(hdr, bp) == -1)
|
|
sysfatal("could not parse header: %r");
|
|
|
|
return bp;
|
|
}
|
|
|
|
void
|
|
freehdr(Hdr *hdr)
|
|
{
|
|
free(hdr->name);
|
|
free(hdr->uid);
|
|
free(hdr->gid);
|
|
}
|
|
|
|
/*
|
|
* if name is longer than Namsiz bytes, try to split it at a slash and fit the
|
|
* pieces into bp->prefix and bp->name.
|
|
*/
|
|
static int
|
|
putfullname(Blk *bp, char *name)
|
|
{
|
|
int namlen, pfxlen;
|
|
char *sl, *osl;
|
|
String *slname = nil;
|
|
|
|
if (isdir(bp, name)) {
|
|
slname = s_new();
|
|
s_append(slname, name);
|
|
s_append(slname, "/"); /* posix requires this */
|
|
name = s_to_c(slname);
|
|
}
|
|
|
|
namlen = strlen(name);
|
|
if (namlen <= Namsiz) {
|
|
strncpy(bp->name, name, Namsiz);
|
|
bp->prefix[0] = '\0'; /* ustar paranoia */
|
|
return 0;
|
|
}
|
|
|
|
if (!posix || namlen > Maxname) {
|
|
fprint(2, "%s: name too long for tar header: %s\n",
|
|
argv0, name);
|
|
return -1;
|
|
}
|
|
/*
|
|
* try various splits until one results in pieces that fit into the
|
|
* appropriate fields of the header. look for slashes from right
|
|
* to left, in the hopes of putting the largest part of the name into
|
|
* bp->prefix, which is larger than bp->name.
|
|
*/
|
|
sl = strrchr(name, '/');
|
|
while (sl != nil) {
|
|
pfxlen = sl - name;
|
|
if (pfxlen <= sizeof bp->prefix && namlen-1 - pfxlen <= Namsiz)
|
|
break;
|
|
osl = sl;
|
|
*osl = '\0';
|
|
sl = strrchr(name, '/');
|
|
*osl = '/';
|
|
}
|
|
if (sl == nil) {
|
|
fprint(2, "%s: name can't be split to fit tar header: %s\n",
|
|
argv0, name);
|
|
return -1;
|
|
}
|
|
*sl = '\0';
|
|
strncpy(bp->prefix, name, sizeof bp->prefix);
|
|
*sl++ = '/';
|
|
strncpy(bp->name, sl, sizeof bp->name);
|
|
if (slname)
|
|
s_free(slname);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
mkhdr(Blk *bp, Dir *dir, char *file)
|
|
{
|
|
int r;
|
|
|
|
/*
|
|
* some of these fields run together, so we format them left-to-right
|
|
* and don't use snprint.
|
|
*/
|
|
sprint(bp->mode, "%6lo ", dir->mode & 0777);
|
|
sprint(bp->uid, "%6o ", aruid);
|
|
sprint(bp->gid, "%6o ", argid);
|
|
if (dir->length >= (Off)1<<32) {
|
|
static int printed;
|
|
|
|
if (!printed) {
|
|
printed = 1;
|
|
fprint(2, "%s: storing large sizes in \"base 256\"\n", argv0);
|
|
}
|
|
bp->size[0] = Binsize;
|
|
/* emit so-called `base 256' representation of size */
|
|
putbe((uchar *)bp->size+1, dir->length, sizeof bp->size - 2);
|
|
bp->size[sizeof bp->size - 1] = ' ';
|
|
} else
|
|
sprint(bp->size, "%11lluo ", dir->length);
|
|
sprint(bp->mtime, "%11luo ", dir->mtime);
|
|
bp->linkflag = (dir->mode&DMDIR? LF_DIR: LF_PLAIN1);
|
|
r = putfullname(bp, file);
|
|
if (posix) {
|
|
strncpy(bp->magic, "ustar", sizeof bp->magic);
|
|
strncpy(bp->version, "00", sizeof bp->version);
|
|
strncpy(bp->uname, dir->uid, sizeof bp->uname);
|
|
strncpy(bp->gname, dir->gid, sizeof bp->gname);
|
|
}
|
|
sprint(bp->chksum, "%6luo", chksum(bp));
|
|
return r;
|
|
}
|
|
|
|
static void addtoar(int ar, char *file, char *shortf);
|
|
|
|
static void
|
|
addtreetoar(int ar, char *file, char *shortf, int fd)
|
|
{
|
|
int n;
|
|
Dir *dent, *dirents;
|
|
String *name = s_new();
|
|
|
|
n = dirreadall(fd, &dirents);
|
|
if (n < 0)
|
|
fprint(2, "%s: dirreadall %s: %r\n", argv0, file);
|
|
close(fd);
|
|
if (n <= 0)
|
|
return;
|
|
|
|
if (chdir(shortf) < 0)
|
|
sysfatal("chdir %s: %r", file);
|
|
if (Debug)
|
|
fprint(2, "chdir %s\t# %s\n", shortf, file);
|
|
|
|
for (dent = dirents; dent < dirents + n; dent++) {
|
|
s_reset(name);
|
|
s_append(name, file);
|
|
s_append(name, "/");
|
|
s_append(name, dent->name);
|
|
addtoar(ar, s_to_c(name), dent->name);
|
|
}
|
|
s_free(name);
|
|
free(dirents);
|
|
|
|
/*
|
|
* this assumes that shortf is just one component, which is true
|
|
* during directory descent, but not necessarily true of command-line
|
|
* arguments. Our caller (or addtoar's) must reset the working
|
|
* directory if necessary.
|
|
*/
|
|
if (chdir("..") < 0)
|
|
sysfatal("chdir %s/..: %r", file);
|
|
if (Debug)
|
|
fprint(2, "chdir ..\n");
|
|
}
|
|
|
|
static void
|
|
addtoar(int ar, char *file, char *shortf)
|
|
{
|
|
int n, fd, isdir;
|
|
long bytes, blksread;
|
|
ulong blksleft;
|
|
Blk *hbp;
|
|
Dir *dir;
|
|
String *name = nil;
|
|
|
|
if (shortf[0] == '#') {
|
|
name = s_new();
|
|
s_append(name, "./");
|
|
s_append(name, shortf);
|
|
shortf = s_to_c(name);
|
|
}
|
|
|
|
if (Debug)
|
|
fprint(2, "opening %s # %s\n", shortf, file);
|
|
fd = open(shortf, OREAD);
|
|
if (fd < 0) {
|
|
fprint(2, "%s: can't open %s: %r\n", argv0, file);
|
|
if (name)
|
|
s_free(name);
|
|
return;
|
|
}
|
|
dir = dirfstat(fd);
|
|
if (dir == nil)
|
|
sysfatal("can't fstat %s: %r", file);
|
|
|
|
hbp = getblkz(ar);
|
|
isdir = (dir->qid.type & QTDIR) != 0;
|
|
if (mkhdr(hbp, dir, file) < 0) {
|
|
putbackblk(ar);
|
|
free(dir);
|
|
close(fd);
|
|
if (name)
|
|
s_free(name);
|
|
return;
|
|
}
|
|
putblk(ar);
|
|
|
|
blksleft = BYTES2TBLKS(dir->length);
|
|
free(dir);
|
|
|
|
if (isdir)
|
|
addtreetoar(ar, file, shortf, fd);
|
|
else {
|
|
for (; blksleft > 0; blksleft -= blksread) {
|
|
hbp = getblke(ar);
|
|
blksread = gothowmany(blksleft);
|
|
assert(blksread >= 0);
|
|
bytes = blksread * Tblock;
|
|
n = ereadn(file, fd, hbp->data, bytes);
|
|
assert(n >= 0);
|
|
/*
|
|
* ignore EOF. zero any partial block to aid
|
|
* compression and emergency recovery of data.
|
|
*/
|
|
if (n < Tblock)
|
|
memset(hbp->data + n, 0, bytes - n);
|
|
putblkmany(ar, blksread);
|
|
}
|
|
close(fd);
|
|
if (verbose)
|
|
fprint(2, "%s\n", file);
|
|
}
|
|
if (name)
|
|
s_free(name);
|
|
}
|
|
|
|
static char *
|
|
replace(char **argv)
|
|
{
|
|
int i, ar;
|
|
ulong blksleft, blksread;
|
|
Off bytes;
|
|
Blk *bp;
|
|
Compress *comp = nil;
|
|
Pushstate ps;
|
|
|
|
if (usefile && docreate)
|
|
ar = create(usefile, OWRITE, 0666);
|
|
else if (usefile)
|
|
ar = open(usefile, ORDWR);
|
|
else
|
|
ar = Stdout;
|
|
if (docreate && docompress) {
|
|
comp = compmethod(usefile);
|
|
if (comp)
|
|
ar = push(ar, comp->comp, Output, &ps);
|
|
}
|
|
if (ar < 0)
|
|
sysfatal("can't open archive %s: %r", usefile);
|
|
|
|
if (usefile && !docreate) {
|
|
/* skip quickly to the end */
|
|
while ((bp = readhdrblk(ar)) != nil) {
|
|
bytes = hdrsize(bp);
|
|
for (blksleft = BYTES2TBLKS(bytes);
|
|
blksleft > 0 && getblkrd(ar, Justnxthdr) != nil;
|
|
blksleft -= blksread) {
|
|
blksread = gothowmany(blksleft);
|
|
putreadblks(ar, blksread);
|
|
}
|
|
}
|
|
/*
|
|
* we have just read the end-of-archive Tblock.
|
|
* now seek back over the (big) archive block containing it,
|
|
* and back up curblk ptr over end-of-archive Tblock in memory.
|
|
*/
|
|
if (seek(ar, blkoff, 0) < 0)
|
|
sysfatal("can't seek back over end-of-archive in %s: %r",
|
|
arname);
|
|
curblk--;
|
|
}
|
|
|
|
for (i = 0; argv[i] != nil; i++) {
|
|
addtoar(ar, argv[i], argv[i]);
|
|
chdir(origdir); /* for correctness & profiling */
|
|
}
|
|
|
|
/* write end-of-archive marker */
|
|
getblkz(ar);
|
|
putblk(ar);
|
|
getblkz(ar);
|
|
putlastblk(ar);
|
|
|
|
if (comp)
|
|
return pushclose(&ps);
|
|
if (ar > Stderr)
|
|
close(ar);
|
|
return nil;
|
|
}
|
|
|
|
/*
|
|
* tar [xt]
|
|
*/
|
|
|
|
/* is pfx a file-name prefix of name? */
|
|
static int
|
|
prefix(char *name, char *pfx)
|
|
{
|
|
char clpfx[Maxlongname+1];
|
|
int pfxlen = strlen(pfx);
|
|
|
|
clpfx[Maxlongname] = '\0';
|
|
strncpy(clpfx, pfx, Maxlongname);
|
|
cleanname(clpfx);
|
|
return strncmp(clpfx, name, pfxlen) == 0 &&
|
|
(name[pfxlen] == '\0' || name[pfxlen] == '/');
|
|
}
|
|
|
|
static int
|
|
match(char *name, char **argv)
|
|
{
|
|
char clname[Maxlongname+1];
|
|
int i;
|
|
|
|
if (argv[0] == nil)
|
|
return 1;
|
|
clname[Maxlongname] = '\0';
|
|
strncpy(clname, name, Maxlongname);
|
|
cleanname(clname);
|
|
for (i = 0; argv[i] != nil; i++)
|
|
if (prefix(clname, argv[i]))
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
cantcreate(char *s, int mode)
|
|
{
|
|
int len;
|
|
static char *last;
|
|
|
|
/*
|
|
* Always print about files. Only print about directories
|
|
* we haven't printed about. (Assumes archive is ordered
|
|
* nicely.)
|
|
*/
|
|
if(mode&DMDIR){
|
|
if(last){
|
|
/* already printed this directory */
|
|
if(strcmp(s, last) == 0)
|
|
return;
|
|
/* printed a higher directory, so printed this one */
|
|
len = strlen(s);
|
|
if(memcmp(s, last, len) == 0 && last[len] == '/')
|
|
return;
|
|
}
|
|
/* save */
|
|
free(last);
|
|
last = strdup(s);
|
|
}
|
|
fprint(2, "%s: can't create %s: %r\n", argv0, s);
|
|
}
|
|
|
|
static int
|
|
makedir(char *s)
|
|
{
|
|
int f;
|
|
|
|
if (access(s, AEXIST) == 0)
|
|
return -1;
|
|
f = create(s, OREAD, DMDIR | 0777);
|
|
if (f >= 0)
|
|
close(f);
|
|
else
|
|
cantcreate(s, DMDIR);
|
|
return f;
|
|
}
|
|
|
|
static int
|
|
mkpdirs(char *s)
|
|
{
|
|
int err;
|
|
char *p;
|
|
|
|
p = s;
|
|
err = 0;
|
|
while (!err && (p = strchr(p+1, '/')) != nil) {
|
|
*p = '\0';
|
|
err = (access(s, AEXIST) < 0 && makedir(s) < 0);
|
|
*p = '/';
|
|
}
|
|
return -err;
|
|
}
|
|
|
|
/* Call access but preserve the error string. */
|
|
static int
|
|
xaccess(char *name, int mode)
|
|
{
|
|
char err[ERRMAX];
|
|
int rv;
|
|
|
|
err[0] = 0;
|
|
errstr(err, sizeof err);
|
|
rv = access(name, mode);
|
|
errstr(err, sizeof err);
|
|
return rv;
|
|
}
|
|
|
|
static int
|
|
openfname(Blk *bp, char *fname, int mode)
|
|
{
|
|
int fd, dir;
|
|
|
|
fd = -1;
|
|
dir = mode & DMDIR;
|
|
cleanname(fname);
|
|
switch (bp->linkflag) {
|
|
case LF_LINK:
|
|
case LF_SYMLINK1:
|
|
case LF_SYMLINK2:
|
|
case LF_LONGLINK:
|
|
fprint(2, "%s: can't make (sym)link %s\n",
|
|
argv0, fname);
|
|
break;
|
|
case LF_FIFO:
|
|
fprint(2, "%s: can't make fifo %s\n", argv0, fname);
|
|
break;
|
|
default:
|
|
if (!keepexisting || access(fname, AEXIST) < 0) {
|
|
int rw = (dir ? OREAD: OWRITE);
|
|
|
|
fd = create(fname, rw, mode);
|
|
if (fd < 0) {
|
|
mkpdirs(fname);
|
|
fd = create(fname, rw, mode);
|
|
}
|
|
if (fd < 0 && (!dir || xaccess(fname, AEXIST) < 0))
|
|
cantcreate(fname, mode);
|
|
}
|
|
if (fd >= 0 && verbose)
|
|
fprint(2, "%s\n", fname);
|
|
break;
|
|
}
|
|
return fd;
|
|
}
|
|
|
|
/* copy from archive to file system (or nowhere for table-of-contents) */
|
|
static void
|
|
copyfromar(int ar, int fd, char *fname, ulong blksleft, Off bytes)
|
|
{
|
|
int wrbytes;
|
|
ulong blksread;
|
|
Blk *hbp;
|
|
|
|
if (blksleft == 0 || bytes < 0)
|
|
bytes = 0;
|
|
for (; blksleft > 0; blksleft -= blksread) {
|
|
hbp = getblkrd(ar, (fd >= 0? Alldata: Justnxthdr));
|
|
if (hbp == nil)
|
|
sysfatal("unexpected EOF on archive extracting %s from %s",
|
|
fname, arname);
|
|
blksread = gothowmany(blksleft);
|
|
if (blksread <= 0) {
|
|
fprint(2, "%s: got %ld blocks reading %s!\n",
|
|
argv0, blksread, fname);
|
|
blksread = 0;
|
|
}
|
|
wrbytes = Tblock*blksread;
|
|
assert(bytes >= 0);
|
|
if(wrbytes > bytes)
|
|
wrbytes = bytes;
|
|
assert(wrbytes >= 0);
|
|
if (fd >= 0)
|
|
ewrite(fname, fd, hbp->data, wrbytes);
|
|
putreadblks(ar, blksread);
|
|
bytes -= wrbytes;
|
|
assert(bytes >= 0);
|
|
}
|
|
if (bytes > 0)
|
|
fprint(2, "%s: %lld bytes uncopied at EOF on archive %s; "
|
|
"%s not fully extracted\n", argv0, bytes, arname, fname);
|
|
}
|
|
|
|
static void
|
|
wrmeta(int fd, Hdr *hdr) /* update metadata */
|
|
{
|
|
Dir nd;
|
|
|
|
nulldir(&nd);
|
|
nd.mtime = hdr->mtime;
|
|
nd.mode = hdr->mode;
|
|
dirfwstat(fd, &nd);
|
|
if (hdr->gid) {
|
|
nulldir(&nd);
|
|
nd.gid = hdr->gid;
|
|
dirfwstat(fd, &nd);
|
|
}
|
|
if (hdr->uid){
|
|
nulldir(&nd);
|
|
nd.uid = hdr->uid;
|
|
dirfwstat(fd, &nd);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* copy a file from the archive into the filesystem.
|
|
* fname is result of getname(), so has two extra bytes at beginning.
|
|
*/
|
|
static void
|
|
extract1(int ar, Blk *bp, Hdr *hdr)
|
|
{
|
|
int fd = -1;
|
|
Off bytes = hdr->size; /* for printing */
|
|
uvlong blksleft = BYTES2TBLKS(bytes);
|
|
char *path;
|
|
|
|
/* fiddle name, figure out mode and blocks */
|
|
switch (bp->linkflag) {
|
|
case LF_LINK:
|
|
case LF_SYMLINK1:
|
|
case LF_SYMLINK2:
|
|
case LF_FIFO:
|
|
blksleft = 0;
|
|
break;
|
|
}
|
|
if((path = malloc(strlen(hdr->name) + 3)) == nil)
|
|
sysfatal("malloc: %r");
|
|
if (relative && hdr->name[0] == '/')
|
|
strcpy(path, ".");
|
|
else if(relative && hdr->name[0] == '#')
|
|
strcpy(path, "./");
|
|
else
|
|
path[0] = '\0';
|
|
strcat(path, hdr->name);
|
|
|
|
if (verb == Xtract)
|
|
fd = openfname(bp, path, hdr->mode);
|
|
else if (verbose) {
|
|
char *cp = ctime(hdr->mtime);
|
|
|
|
print("%M %8lld %-12.12s %-4.4s %s\n",
|
|
hdr->mode, bytes, cp+4, cp+24, path);
|
|
} else
|
|
print("%s\n", path);
|
|
|
|
copyfromar(ar, fd, path, blksleft, hdr->size);
|
|
|
|
/* touch up meta data and close */
|
|
if (fd >= 0) {
|
|
/*
|
|
* directories should be wstated *after* we're done
|
|
* creating files in them, but we don't do that.
|
|
*/
|
|
if (settime)
|
|
wrmeta(fd, hdr);
|
|
close(fd);
|
|
}
|
|
free(path);
|
|
}
|
|
|
|
static void
|
|
skip(int ar, Blk *bp, Hdr *hdr)
|
|
{
|
|
ulong blksleft, blksread;
|
|
Blk *hbp;
|
|
|
|
for (blksleft = BYTES2TBLKS(arsize(bp, hdr->name)); blksleft > 0;
|
|
blksleft -= blksread) {
|
|
hbp = getblkrd(ar, Justnxthdr);
|
|
if (hbp == nil)
|
|
sysfatal("unexpected EOF on archive extracting %s from %s",
|
|
hdr->name, arname);
|
|
blksread = gothowmany(blksleft);
|
|
putreadblks(ar, blksread);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
extract(char **argv)
|
|
{
|
|
int ar;
|
|
Blk *bp;
|
|
Hdr hdr;
|
|
Compress *comp;
|
|
Pushstate ps;
|
|
|
|
if (usefile)
|
|
ar = open(usefile, OREAD);
|
|
else
|
|
ar = Stdin;
|
|
comp = compmethod(usefile);
|
|
if (comp)
|
|
ar = push(ar, comp->decomp, Input, &ps);
|
|
if (ar < 0)
|
|
sysfatal("can't open archive %s: %r", usefile);
|
|
|
|
while ((bp = readhdr(ar, &hdr)) != nil) {
|
|
if (match(hdr.name, argv))
|
|
extract1(ar, bp, &hdr);
|
|
else
|
|
skip(ar, bp, &hdr);
|
|
freehdr(&hdr);
|
|
}
|
|
|
|
if (comp)
|
|
return pushclose(&ps);
|
|
if (ar > Stderr)
|
|
close(ar);
|
|
return nil;
|
|
}
|
|
|
|
void
|
|
main(int argc, char *argv[])
|
|
{
|
|
int errflg = 0;
|
|
char *ret = nil;
|
|
|
|
fmtinstall('M', dirmodefmt);
|
|
|
|
TARGBEGIN {
|
|
case 'c':
|
|
docreate++;
|
|
verb = Replace;
|
|
break;
|
|
case 'f':
|
|
usefile = arname = EARGF(usage());
|
|
break;
|
|
case 'g':
|
|
argid = strtoul(EARGF(usage()), 0, 0);
|
|
break;
|
|
case 'i':
|
|
ignerrs = 1;
|
|
break;
|
|
case 'k':
|
|
keepexisting++;
|
|
break;
|
|
case 'm': /* compatibility */
|
|
settime = 0;
|
|
break;
|
|
case 'p':
|
|
posix++;
|
|
break;
|
|
case 'P':
|
|
posix = 0;
|
|
break;
|
|
case 'r':
|
|
verb = Replace;
|
|
break;
|
|
case 'R':
|
|
relative = 0;
|
|
break;
|
|
case 's':
|
|
resync++;
|
|
break;
|
|
case 't':
|
|
verb = Toc;
|
|
break;
|
|
case 'T':
|
|
settime++;
|
|
break;
|
|
case 'u':
|
|
aruid = strtoul(EARGF(usage()), 0, 0);
|
|
break;
|
|
case 'v':
|
|
verbose++;
|
|
break;
|
|
case 'x':
|
|
verb = Xtract;
|
|
break;
|
|
case 'z':
|
|
docompress++;
|
|
break;
|
|
case '-':
|
|
break;
|
|
default:
|
|
fprint(2, "tar: unknown letter %C\n", TARGC());
|
|
errflg++;
|
|
break;
|
|
} TARGEND
|
|
|
|
if (argc < 0 || errflg)
|
|
usage();
|
|
|
|
initblks();
|
|
nullhdr(&globlhdr);
|
|
switch (verb) {
|
|
case Toc:
|
|
case Xtract:
|
|
ret = extract(argv);
|
|
break;
|
|
case Replace:
|
|
if (getwd(origdir, sizeof origdir) == nil)
|
|
strcpy(origdir, "/tmp");
|
|
ret = replace(argv);
|
|
break;
|
|
default:
|
|
usage();
|
|
break;
|
|
}
|
|
exits(ret);
|
|
}
|