Subversion Repositories planix.SVN

/*

 * File system for tar archives (read-only)

 */

#include <u.h>

#include <libc.h>

#include <auth.h>

#include <fcall.h>

#include "tapefs.h"

/* fundamental constants */

enum {

	Tblock = 512,

	Namsiz = 100,

	Maxpfx = 155,		/* from POSIX */

	Maxname = Namsiz + 1 + Maxpfx,

	Binsize = 0x80,		/* flag in size[0], from gnu: positive binary size */

	Binnegsz = 0xff,	/* flag in size[0]: negative binary size */

};

/* 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 */

};

typedef union {

	char	dummy[Tblock];

	char	tbuf[Maxbuf];

	struct Header {

		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 */

	};

} Hdr;

Hdr dblock;

int tapefile;

int	checksum(void);

static int

isustar(Hdr *hp)

{

	return strcmp(hp->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 *

tarname(Hdr *hp)

{

	int pfxlen, namlen;

	static char fullname[Maxname+1];

	namlen = strnlen(hp->name, sizeof hp->name);

	if (hp->prefix[0] == '\0' || !isustar(hp)) {	/* old-style name? */

		memmove(fullname, hp->name, namlen);

		fullname[namlen] = '\0';

		return fullname;

	}

	/* posix name: name is in two pieces */

	pfxlen = strnlen(hp->prefix, sizeof hp->prefix);

	memmove(fullname, hp->prefix, pfxlen);

	fullname[pfxlen] = '/';

	memmove(fullname + pfxlen + 1, hp->name, namlen);

	fullname[pfxlen + 1 + namlen] = '\0';

	return fullname;

}

void

populate(char *name)

{

	long chksum, linkflg;

	vlong blkno;

	char *fname;

	Fileinf f;

	Hdr *hp;

	tapefile = open(name, OREAD);

	if (tapefile < 0)

		error("Can't open argument file");

	replete = 1;

	hp = &dblock;

	for (blkno = 0; ; blkno++) {

		seek(tapefile, Tblock*blkno, 0);

		if (readn(tapefile, hp->dummy, sizeof hp->dummy) < sizeof hp->dummy)

			break;

		fname = tarname(hp);

		if (fname[0] == '\0')

			break;

		/* crack header */

		f.addr = blkno + 1;

		f.mode = strtoul(hp->mode, 0, 8);

		f.uid  = strtoul(hp->uid, 0, 8);

		f.gid  = strtoul(hp->gid, 0, 8);

		if((uchar)hp->size[0] == 0x80)

			f.size = b8byte(hp->size+3);

		else

			f.size = strtoull(hp->size, 0, 8);

		f.mdate = strtoul(hp->mtime, 0, 8);

		chksum  = strtoul(hp->chksum, 0, 8);

		/* the mode test is ugly but sometimes necessary */

		if (hp->linkflag == LF_DIR || (f.mode&0170000) == 040000 ||

		    strrchr(fname, '\0')[-1] == '/'){

			f.mode |= DMDIR;

			f.size = 0;

		}

		f.mode &= DMDIR | 0777;

		/* make file name safe, canonical and free of . and .. */

		while (fname[0] == '/')		/* don't allow absolute paths */

			++fname;

		cleanname(fname);

		while (strncmp(fname, "../", 3) == 0)

			fname += 3;

		/* reject links */

		linkflg = hp->linkflag == LF_SYMLINK1 ||

			hp->linkflag == LF_SYMLINK2 || hp->linkflag == LF_LINK;

		if (chksum != checksum()){

			fprint(2, "%s: bad checksum on %.28s at offset %lld\n",

				argv0, fname, Tblock*blkno);

			exits("checksum");

		}

		if (linkflg) {

			/*fprint(2, "link %s->%s skipped\n", fname, hp->linkname);*/

			f.size = 0;

		} else {

			/* accept this file */

			f.name = fname;

			if (f.name[0] == '\0')

				fprint(2, "%s: null name skipped\n", argv0);

			else

				poppath(f, 1);

			blkno += (f.size + Tblock - 1)/Tblock;

		}

	}

}

void

dotrunc(Ram *r)

{

	USED(r);

}

void

docreate(Ram *r)

{

	USED(r);

}

char *

doread(Ram *r, vlong off, long cnt)

{

	int n;

	seek(tapefile, Tblock*r->addr + off, 0);

	if (cnt > sizeof dblock.tbuf)

		error("read too big");

	n = readn(tapefile, dblock.tbuf, cnt);

	if (n != cnt)

		memset(dblock.tbuf + n, 0, cnt - n);

	return dblock.tbuf;

}

void

popdir(Ram *r)

{

	USED(r);

}

void

dowrite(Ram *r, char *buf, long off, long cnt)

{

	USED(r); USED(buf); USED(off); USED(cnt);

}

int

dopermw(Ram *r)

{

	USED(r);

	return 0;

}

int

checksum(void)

{

	int i, n;

	uchar *cp;

	memset(dblock.chksum, ' ', sizeof dblock.chksum);

	cp = (uchar *)dblock.dummy;

	i = 0;

	for (n = Tblock; n-- > 0; )

		i += *cp++;

	return i;

}