plan9-archive/inferno-java

CHANGES+2−0

@@ -1,3 +1,5 @@
		1	20090521
		2	module/vac.m appl/cmd/vacfs.b appl/lib/vac.b [issue 152] (Mecchiel)
1	20090505	3	20090505
2	add -h/-t header/trailer options to man2html	4	add -h/-t header/trailer options to man2html
3	20090430	5	20090430

appl/cmd/vacfs.b+10−3

 	if(ne == nil) {
 		nqid := childput(ed.qid, de.qid);
 		ne = Elem.new(nqid, ed.vd, de, ed.qid);
+		if(ne == nil)
+			return (nil, sprint("%r"));
 		set(ne);
 	}
 	return (ne, nil);
 	styx = load Styx Styx->PATH;
 	styxservers = load Styxservers Styxservers->PATH;
 	vac = load Vac Vac->PATH;
-	if(venti == nil || vac == nil)
-		error("loading venti,vac");
-	sys->pctl(sys->NEWPGRP, nil);
 	venti->init();
 	vac->init();
 	styx->init();
 	styxservers->init(styx);
+	sys->pctl(sys->NEWPGRP, nil);
+	if(venti == nil || vac == nil)
+		error("loading venti,vac");
 	arg->init(args);
 	arg->setusage(arg->progname()+" [-Ddp] [-a addr] [[tag:]score]");
 	while((ch := arg->opt()) != 0)
 				if(ne == nil) {
 					nqid := childput(ed.qid, de.qid);
 					ne = Elem.new(nqid, ed.vd, de, ed.qid);
+					if(ne == nil) {
+						n.reply <-= (nil, sprint("%r"));
+						continue loop;
+					}
 				}
 				d := ne.stat();
 				ed.prev[ed.nprev++] = d;

appl/lib/vac.b+33−22

 			return (0, nil);
 		if(last && f.p[i].o == Scoresize) {
 			flags := Entryactive;
-			if(f.dtype & Dirtype)
+			if(f.dtype == Dirtype)
 				flags |= Entrydir;
 			flags |= i<<Entrydepthshift;
 			score := Score(f.p[i].data());
 MSink.new(s: ref Venti->Session, dsize: int): ref MSink
 {
-	return ref MSink(File.new(s, Dirtype, dsize), array[dsize] of byte, 0, nil);
+	return ref MSink(File.new(s, Datatype, dsize), array[dsize] of byte, 0, nil);
 }
 l2a[T](l: list of T): array of T
 Source.new(s: ref Session, e: ref Entry): ref Source
 {
-	return ref Source(s, e);
+	dsize := e.dsize;
+	if(e.flags&Entrydir)
+		dsize = Entrysize*(dsize/Entrysize);
+	return ref Source(s, e, dsize);
 }
 power(b, e: int): big
 Source.get(s: self ref Source, i: big, d: array of byte): int
 {
-	npages := (s.e.size+big (s.e.dsize-1))/big s.e.dsize;
+	npages := (s.e.size+big (s.dsize-1))/big s.dsize;
-	if(i*big s.e.dsize >= s.e.size)
+	if(i*big s.dsize >= s.e.size)
 		return 0;
-	want := s.e.dsize;
+	want := s.dsize;
 	if(i == npages-big 1)
-		want = int (s.e.size - i*big s.e.dsize);
+		want = int (s.e.size - i*big s.dsize);
 	last := s.e.score;
 	bsize := blocksize(s.e);
 	buf: array of byte;
 Vacfile.pread(v: self ref Vacfile, d: array of byte, n: int, offset: big): int
 {
-	dsize := v.s.e.dsize;
+	dsize := v.s.dsize;
+say(sprint("vf.preadn, len d %d, n %d, offset %bd", len d, n, offset));
 	have := v.s.get(big (offset/big dsize), buf := array[dsize] of byte);
 	if(have <= 0)
 		return have;
-say(sprint("vacfile.read: have=%d dsize=%d", have, dsize));
+say(sprint("vacfile.pread: have=%d dsize=%d", have, dsize));
 	o := int (offset % big dsize);
 	have -= o;
 	if(have > n)
 		if(c == 0)
 			break;
         }
-	de := readdirentry(d, left);
+	de := readdirentry(d, left, 0);
 	if(de != nil && de.elem == elem)
 		return (1, de);
 	return (0, nil);
 	if(n < 0)
 		return nil;
 	if(n != len ebuf) {
-		werrstr(sprint("bad archive, entry=%d not present", entry));
+		werrstr(sprint("bad archive, entry=%d not present (read %d, wanted %d)", entry, n, len ebuf));
 		return nil;
 	}
 	e := Entry.unpack(ebuf);
 		werrstr("entry not active");
 		return nil;
 	}
-	if(e.flags&Entrylocal) {
+	# p9p writes archives with Entrylocal set?
+	if(0 && e.flags&Entrylocal) {
 		werrstr("entry is local");
 		return nil;
 	}
 	return (e, me);
 }
-readdirentry(buf: array of byte, i: int): ref Direntry
+readdirentry(buf: array of byte, i: int, allowroot: int): ref Direntry
 {
 	me := Metaentry.unpack(buf, i);
 	if(me == nil)
 		return nil;
 	o := me.offset;
 	de := Direntry.unpack(buf[o:o+me.size]);
-	if(badelem(de.elem)) {
+	if(badelem(de.elem) && !(allowroot && de.elem == "/")) {
 		werrstr(sprint("bad direntry: %s", de.elem));
 		return nil;
 	}
 	return elem == "" || elem == "." || elem == ".." || has('/', elem) || has(0, elem);
 }
-Vacdir.readdir(vd: self ref Vacdir): (int, ref Direntry)
+vdreaddir(vd: ref Vacdir, allowroot: int): (int, ref Direntry)
 {
-say(sprint("vacdir.readdir: ms.e.size=%bd vd.p=%bd vd.i=%d", vd.ms.e.size, vd.p, vd.i));
+say(sprint("vdreaddir: ms.e.size=%bd vd.p=%bd vd.i=%d", vd.ms.e.size, vd.p, vd.i));
-	dsize := vd.ms.e.dsize;
+	dsize := vd.ms.dsize;
 	n := vd.ms.get(vd.p, buf := array[dsize] of byte);
 	if(n <= 0)
 		return (n, nil);
-say(sprint("vacdir.readdir: have buf, length=%d e.size=%bd", n, vd.ms.e.size));
+say(sprint("vdreaddir: have buf, length=%d e.size=%bd", n, vd.ms.e.size));
 	mb := Metablock.unpack(buf);
 	if(mb == nil)
 		return (-1, nil);
-	de := readdirentry(buf, vd.i);
+	de := readdirentry(buf, vd.i, allowroot);
 	if(de == nil)
 		return (-1, nil);
 	vd.i++;
 		vd.p++;
 		vd.i = 0;
 	}
-say("vacdir.readdir: have entry");
+say("vdreaddir: have entry");
 	return (1, de);
 }
+Vacdir.readdir(vd: self ref Vacdir): (int, ref Direntry)
+{
+	return vdreaddir(vd, 0);
+}
 Vacdir.rewind(vd: self ref Vacdir)
 {
 	vd.p = big 0;
 	}
 	say("top entries unpacked");
-	mroot := Vacdir.new(session, nil, e[2]);
+	mroot := Vacdir.mk(nil, Source.new(session, e[2]));
-	(ok, de) := mroot.readdir();
+	(ok, de) := vdreaddir(mroot, 1);
 	if(ok <= 0)
 		return (nil, nil, sprint("reading root meta entry: %r"));

dis/lib/vac.dis+0−0

Binary file not shown.

dis/vacfs.dis+0−0

Binary file not shown.

include/version.h+1−1

@@ -1 +1 @@
1	#define VERSION "Fourth Edition (20090505)"	1	#define VERSION "Fourth Edition (20090521)"

module/vac.m+1−0

@@ -152,6 +152,7 @@ Vac: module { · 151 unmodified lines
152	Source: adt {	152	Source: adt {
153	session: ref Venti->Session;	153	session: ref Venti->Session;
154	e: ref Entry;	154	e: ref Entry;
		155	dsize: int; # real dsize
155		156
156	new: fn(s: ref Venti->Session, e: ref Entry): ref Source;	157	new: fn(s: ref Venti->Session, e: ref Entry): ref Source;
157	get: fn(s: self ref Source, i: big, d: array of byte): int;	158	get: fn(s: self ref Source, i: big, d: array of byte): int;