code: plan9front

ref: 75d6267a5f788162d92e7a5ae126cd8b0770aa8a
dir: /sys/src/cmd/aux/olefs.c/

View raw version
#include <u.h>
#include <libc.h>
#include <bio.h>
#include <auth.h>
#include <fcall.h>
#include <thread.h>
#include <9p.h>

/* little endian */
#define SHORT(p)	(((uchar*)(p))[0] | (((uchar*)(p))[1] << 8))
#define LONG(p)	((ulong)SHORT(p) |(((ulong)SHORT((p)+2)) << 16))

typedef struct Ofile	Ofile;
typedef struct Odir	Odir;

enum {
	/* special block map entries */
	Bspecial = 0xFFFFFFFD,
	Bendchain = 0xFFFFFFFE,
	Bunused = 0xFFFFFFFF,

	Blocksize = 0x200,

	Odirsize = 0x80,

	/* Odir types */
	Tstorage = 1,
	Tstream = 2,
	Troot = 5,
};

/*
 * the file consists of chains of blocks of size 0x200.
 * to find what block follows block n, you look at 
 * blockmap[n].  that block follows it unless it is Bspecial
 * or Bendchain.
 * 
 * it's like the MS-DOS file system allocation tables.
 */
struct Ofile {
	Biobuf *b;
	ulong nblock;
	ulong *blockmap;
	ulong rootblock;
	ulong smapblock;
	ulong *smallmap;
};

/* Odir headers are found in directory listings in the Olefile */
/* prev and next form a binary tree of directory entries */
struct Odir {
	Ofile *f;
	Rune name[32+1];
	uchar type;
	uchar isroot;
	ulong left;
	ulong right;
	ulong dir;
	ulong start;
	ulong size;
};

void*
emalloc(ulong sz)
{
	void *v;

	v = malloc(sz);
	assert(v != nil);
	return v;
}

int
convM2OD(Odir *f, void *buf, int nbuf)
{
	int i;
	char *p;
	int len;

	if(nbuf < Odirsize)
		return -1;

	/*
	 * the short at 0x40 is the length of the name.
	 * when zero, it means there is no Odir here.
	 */
	p = buf;
	len = SHORT(p+0x40);
	if(len == 0)
		return 0;

	if(len > 32)	/* shouldn't happen */
		len = 32;

	for(i=0; i<len; i++)
		f->name[i] = SHORT(p+i*2);
	f->name[len] = 0;

	f->type = p[0x42];
	f->left = LONG(p+0x44);
	f->right = LONG(p+0x48);
	f->dir = LONG(p+0x4C);
	f->start = LONG(p+0x74);
	f->size = LONG(p+0x78);

	/* BUG: grab time in ms format from here */

	return 1;
}

int
oreadblock(Ofile *f, int block, ulong off, char *buf, int nbuf)
{
	int n;

	if(block < 0 || block >= f->nblock) {
		werrstr("attempt to read %x/%lux\n", block, f->nblock);
		return -1;
	}

	if(off >= Blocksize){
		print("offset too far into block\n");
		return 0;
	}

	if(off+nbuf > Blocksize)
		nbuf = Blocksize-off;

	/* blocks start numbering at -1 [sic] */
	off += (block+1)*Blocksize;

	if(Bseek(f->b, off, 0) != off){
		print("seek failed\n");
		return -1;
	}

	n = Bread(f->b, buf, nbuf);
	if(n < 0)
		print("Bread failed: %r");
	return n;
}

int
chainlen(Ofile *f, ulong start)
{
	int i;
	for(i=0; start < 0xFFFF0000; i++)
		start = f->blockmap[start];

	return i;
}

/*
 * read nbuf bytes starting at offset off from the 
 * chain whose first block is block.  the chain is linked
 * together via the blockmap as described above,
 * like the MS-DOS file allocation tables.
 */
int
oreadchain(Ofile *f, ulong block, int off, char *buf, int nbuf)
{
	int i;
	int offblock;

	offblock = off/Blocksize;
	for(i=0; i<offblock && block < 0xFFFF0000; i++)
		block = f->blockmap[block];
	return oreadblock(f, block, off%Blocksize, buf, nbuf);
}

int 
oreadfile(Odir *d, int off, char *buf, int nbuf)
{
	/*
	 * if d->size < 0x1000 then d->start refers
	 * to a small depot block, else a big one.
	 * if this is the root entry, it's a big one
	 * no matter what.
	 */

	if(off >= d->size)
		return 0;
	if(off+nbuf > d->size)
		nbuf = d->size-off;

	if(d->size >= 0x1000 
	|| memcmp(d->name, L"Root Entry", 11*sizeof(Rune)) == 0)
		return oreadchain(d->f, d->start, off, buf, nbuf);
	else {	/* small block */
		off += d->start*64;
		return oreadchain(d->f, d->f->smapblock, off, buf, nbuf);
	}
}

int
oreaddir(Ofile *f, int entry, Odir *d)
{
	char buf[Odirsize];

	if(oreadchain(f, f->rootblock, entry*Odirsize, buf, Odirsize) != Odirsize)
		return -1;

	d->f = f;
	return convM2OD(d, buf, Odirsize);
}

void
dumpdir(Ofile *f, ulong dnum)
{
	Odir d;

	if(oreaddir(f, dnum, &d) != 1) {
		fprint(2, "dumpdir %lux failed\n", dnum);
		return;
	}

	fprint(2, "%.8lux type %d size %lud l %.8lux r %.8lux d %.8lux (%S)\n", dnum, d.type, d.size, d.left, d.right, d.dir, d.name);
	if(d.left != (ulong)-1) 
		dumpdir(f, d.left);
	if(d.right != (ulong)-1)
		dumpdir(f, d.right);
	if(d.dir != (ulong)-1)
		dumpdir(f, d.dir);
}

Ofile*
oleopen(char *fn)
{
	int i, j, k, block;
	int ndepot;
	ulong u;
	Odir rootdir;
	ulong extrablock;
	uchar buf[Blocksize];

	Ofile *f;
	Biobuf *b;
	static char magic[] = {
		0xD0, 0xCF, 0x11, 0xE0,
		0xA1, 0xB1, 0x1A, 0xE1
	};

	b = Bopen(fn, OREAD);
	if(b == nil)
		return nil;

	/* the first bytes are magic */
	if(Bread(b, buf, sizeof magic) != sizeof magic
	|| memcmp(buf, magic, sizeof magic) != 0) {
		Bterm(b);
		werrstr("bad magic: not OLE file");
		return nil;
	}

	f = emalloc(sizeof *f);
	f->b = b;

	/*
	 * the header contains a list of depots, which are
	 * block maps.  we assimilate them into one large map,
	 * kept in main memory.
	 */
	Bseek(b, 0, 0);
	if(Bread(b, buf, Blocksize) != Blocksize) {
		Bterm(b);
		free(f);
		print("short read\n");
		return nil;
	}

	ndepot = LONG(buf+0x2C);
	f->nblock = ndepot*(Blocksize/4);
//	fprint(2, "ndepot = %d f->nblock = %lud\n", ndepot, f->nblock);
	f->rootblock = LONG(buf+0x30);
	f->smapblock = LONG(buf+0x3C);
	f->blockmap = emalloc(sizeof(f->blockmap[0])*f->nblock);
	extrablock = LONG(buf+0x44);

	u = 0;

	/* the big block map fills to the end of the first 512-byte block */
	for(i=0; i<ndepot && i<(0x200-0x4C)/4; i++) {
		if(Bseek(b, 0x4C+4*i, 0) != 0x4C+4*i
		|| Bread(b, buf, 4) != 4) {
			print("bseek %d fail\n", 0x4C+4*i);
			goto Die;
		}
		block = LONG(buf);
		if((ulong)block == Bendchain) {
			ndepot = i;
			f->nblock = ndepot*(Blocksize/4);
			break;
		}

		if(Bseek(b, (block+1)*Blocksize, 0) != (block+1)*Blocksize) {
			print("Xbseek %d fail\n", (block+1)*Blocksize);
			goto Die;
		}
		for(j=0; j<Blocksize/4; j++) {
			if(Bread(b, buf, 4) != 4) {
				print("Bread fail seek block %x, %d i %d ndepot %d\n", block, (block+1)*Blocksize, i, ndepot);
				goto Die;
			}
			f->blockmap[u++] = LONG(buf);
		}
	}
	/*
	 * if the first block can't hold it, it continues in the block at LONG(hdr+0x44).
	 * if that in turn is not big enough, there's a next block number at the end of 
	 * each block.
	 */
	while(i < ndepot) {
		for(k=0; k<(0x200-4)/4 && i<ndepot; i++, k++) {
			if(Bseek(b, 0x200+extrablock*Blocksize+4*i, 0) != 0x200+extrablock*0x200+4*i
			|| Bread(b, buf, 4) != 4) {
				print("bseek %d fail\n", 0x4C+4*i);
				goto Die;
			}
			block = LONG(buf);
			if((ulong)block == Bendchain) {
				ndepot = i;
				f->nblock = ndepot*(Blocksize/4);
				goto Break2;
			}

			if(Bseek(b, (block+1)*Blocksize, 0) != (block+1)*Blocksize) {
				print("Xbseek %d fail\n", (block+1)*Blocksize);
				goto Die;
			}
			for(j=0; j<Blocksize/4; j++) {
				if(Bread(b, buf, 4) != 4) {
					print("Bread fail seek block %x, %d i %d ndepot %d\n", block, (block+1)*Blocksize, i, ndepot);
					goto Die;
				}
				f->blockmap[u++] = LONG(buf);
			}
		}
		if(Bseek(b, 0x200+extrablock*Blocksize+Blocksize-4, 0) != 0x200+extrablock*Blocksize+Blocksize-4
		|| Bread(b, buf, 4) != 4) {
			print("bseek %d fail\n", 0x4C+4*i);
			goto Die;
		}
		extrablock = LONG(buf);
	}
Break2:;

	if(oreaddir(f, 0, &rootdir) <= 0){
		print("oreaddir could not read root\n");
		goto Die;
	}

	f->smapblock = rootdir.start;
	return f;

Die:
	Bterm(b);
	free(f->blockmap);
	free(f);
	return nil;
}

void
oleread(Req *r)
{
	Odir *d;
	char *p;
	int e, n;
	long c;
	vlong o;

	o = r->ifcall.offset;
	d = r->fid->file->aux;
	if(d == nil) {
		respond(r, "cannot happen");
		return;
	}

	c = r->ifcall.count;

	if(o >= d->size) {
		r->ofcall.count = 0;
		respond(r, nil);
		return;
	}

	if(o+c > d->size)
		c = d->size-o;

	/*
	 * oreadfile returns so little data, it will
	 * help to read as much as we can.
	 */
	e = c+o;
	n = 0;
	for(p=r->ofcall.data; o<e; o+=n, p+=n) {
		n = oreadfile(d, o, p, e-o);
		if(n <= 0)
			break;
	}

	if(n == -1 && o == r->ifcall.offset)
		respond(r, "error reading word file");
	else {
		r->ofcall.count = o - r->ifcall.offset;
		respond(r, nil);
	}
}

Odir*
copydir(Odir *d)
{
	Odir *e;

	e = emalloc(sizeof(*d));
	*e = *d;
	return e;
}
		
void
filldir(File *t, Ofile *f, int dnum, int nrecur)
{
	Odir d;
	int i;
	Rune rbuf[40];
	char buf[UTFmax*nelem(rbuf)];
	File *nt;

	if(dnum == 0xFFFFFFFF || oreaddir(f, dnum, &d) != 1)
		return;

	/*
	 * i hope there are no broken files with
	 * circular trees.  i hate infinite loops.
	 */
	if(nrecur > 100)
		sysfatal("tree too large in office file: probably circular");

	filldir(t, f, d.left, nrecur+1);

	/* add current tree entry */
	runestrecpy(rbuf, rbuf+sizeof rbuf, d.name);
	for(i=0; rbuf[i]; i++)
		if(rbuf[i] == L' ')
			rbuf[i] = L'␣';
		else if(rbuf[i] <= 0x20 || rbuf[i] == L'/' 
			|| (0x80 <= rbuf[i] && rbuf[i] <= 0x9F))
				rbuf[i] = ':';
	
	snprint(buf, sizeof buf, "%S", rbuf);

	if(d.dir == 0xFFFFFFFF) {
		/* make file */
		nt = createfile(t, buf, nil, 0444, nil);
		if(nt == nil)
			sysfatal("nt nil: create %s: %r", buf);
		nt->aux = copydir(&d);
		nt->length = d.size;
	} else /* make directory */
		nt = createfile(t, buf, nil, DMDIR|0777, nil);

	filldir(t, f, d.right, nrecur+1);

	if(d.dir != 0xFFFFFFFF)
		filldir(nt, f, d.dir, nrecur+1);

	closefile(nt);
}

Srv olesrv = {
	.read=	oleread,
};

void
main(int argc, char **argv)
{
	char *mtpt;
	Ofile *f;
	Odir d;

	mtpt = "/mnt/doc";
	ARGBEGIN{
	case 'm':
		mtpt = ARGF();
		break;
	
	default:
		goto Usage;
	}ARGEND

	if(argc != 1) {
	Usage:
		fprint(2, "usage: olefs file\n");
		exits("usage");
	}

	f = oleopen(argv[0]);
	if(f == nil) {
		print("error opening %s: %r\n", argv[0]);
		exits("open");
	}

//	dumpdir(f, 0);

	if(oreaddir(f, 0, &d) != 1) {
		fprint(2, "oreaddir error: %r\n");
		exits("oreaddir");
	}

	olesrv.tree = alloctree(nil, nil, DMDIR|0777, nil);
	filldir(olesrv.tree->root, f, d.dir, 0);
	postmountsrv(&olesrv, nil, mtpt, MREPL);
	exits(0);
}