20110516-2327

1 files changed, 158 insertions, 87 deletions

diff --git a/appl/cmd/vacput.b b/appl/cmd/vacput.b
index e01bdd36..a1a07a48 100644
--- a/appl/cmd/vacput.b
+++ b/appl/cmd/vacput.b
@@ -2,81 +2,113 @@ implement Vacput;
 
 include "sys.m";
 	sys: Sys;
+	sprint: import sys;
 include "draw.m";
+include "arg.m";
 include "daytime.m";
+	dt: Daytime;
 include "bufio.m";
 	bufio: Bufio;
 	Iobuf: import bufio;
-include "arg.m";
+include "dial.m";
+	dial: Dial;
 include "string.m";
+	str: String;
+include "tables.m";
+	tables: Tables;
+	Strhash: import tables;
 include "venti.m";
+	venti: Venti;
+	Root, Entry, Score, Session: import venti;
 include "vac.m";
-
-daytime: Daytime;
-str: String;
-venti: Venti;
-vac: Vac;
-
-print, sprint, fprint, fildes: import sys;
-Score, Session: import venti;
-Roottype, Dirtype, Pointertype0, Datatype: import venti;
-Root, Entry, Direntry, Metablock, Metaentry, Entrysize, File, Sink, MSink: import vac;
+	vac: Vac;
+	Direntry, File, Sink, MSink: import vac;
 
 Vacput: module {
 	init:	fn(nil: ref Draw->Context, args: list of string);
 };
 
-addr := "net!$venti!venti";
-dflag := 0;
-vflag := 0;
+addr := "$venti";
+dflag: int;
+iflag: int;
+vflag: int;
+xflag: int;
 blocksize := vac->Dsize;
+uid: string;
+gid: string;
+
+pathgen: big;
+
+bout: ref Iobuf;
 session: ref Session;
 name := "vac";
+itab,
+xtab: ref Strhash[string]; # include/exclude paths
 
 init(nil: ref Draw->Context, args: list of string)
 {
 	sys = load Sys Sys->PATH;
-	daytime = load Daytime Daytime->PATH;
+	dt = load Daytime Daytime->PATH;
 	bufio = load Bufio Bufio->PATH;
 	arg := load Arg Arg->PATH;
+	dial = load Dial Dial->PATH;
 	str = load String String->PATH;
+	tables = load Tables Tables->PATH;
 	venti = load Venti Venti->PATH;
 	vac = load Vac Vac->PATH;
 	if(venti == nil || vac == nil)
-		error("loading venti,vac");
+		fail("loading venti,vac");
 	venti->init();
 	vac->init();
 
 	arg->init(args);
-	arg->setusage(sprint("%s [-dtv] [-a addr] [-b blocksize] [-n name] path ...", arg->progname()));
+	arg->setusage(arg->progname()+" [-dv] [-i | -x] [-a addr] [-b blocksize] [-n name] [-u uid] [-g gid] path ...");
 	while((c := arg->opt()) != 0)
 		case c {
 		'a' =>	addr = arg->earg();
 		'b' =>	blocksize = int arg->earg();
 		'n' =>	name = arg->earg();
-		'd' =>	dflag++;
-			vac->dflag++;
+		'd' =>	vac->dflag = dflag++;
+		'i' =>	iflag++;
 		'v' =>	vflag++;
-		* =>	warn(sprint("bad option: -%c", c));
-			arg->usage();
+		'x' =>	xflag++;
+		'g' =>	gid = arg->earg();
+		'u' =>	uid = arg->earg();
+		* =>	arg->usage();
 		}
 	args = arg->argv();
 	if(len args == 0)
 		arg->usage();
+	if(iflag && xflag) {
+		warn("cannot have both -i and -x");
+		arg->usage();
+	}
 
-	(cok, conn) := sys->dial(addr, nil);
-	if(cok < 0)
-		error(sprint("dialing %s: %r", addr));
+	if(vflag)
+		bout = bufio->fopen(sys->fildes(1), bufio->OWRITE);
+
+	if(iflag || xflag) {
+		t := readpaths();
+		if(iflag)
+			itab = t;
+		else
+			xtab = t;
+	}
+
+	addr = dial->netmkaddr(addr, "net", "venti");
+	cc := dial->dial(addr, nil);
+	if(cc == nil)
+		fail(sprint("dialing %s: %r", addr));
 	say("have connection");
 
-	fd := conn.dfd;
+	fd := cc.dfd;
 	session = Session.new(fd);
 	if(session == nil)
-		error(sprint("handshake: %r"));
+		fail(sprint("handshake: %r"));
 	say("have handshake");
 
 	topde: ref Direntry;
-	if(len args == 1 && ((nil, d) := sys->stat(hd args)).t0 == 0 && d.mode&Sys->DMDIR) {
+	if(len args == 1 && ((nil, d) := sys->stat(hd args)).t0 == 0 && (d.mode&Sys->DMDIR)) {
 		topde = Direntry.mk(d);
 		topde.elem = name;
 	} else {
@@ -86,7 +118,12 @@ init(nil: ref Draw->Context, args: list of string)
 		topde.mode = 8r777|Vac->Modedir;
 		topde.mtime = topde.atime = 0;
 	}
-	topde.ctime = daytime->now();
+	topde.qid = pathgen++;
+	if(uid != nil)
+		topde.uid = uid;
+	if(gid != nil)
+		topde.gid = gid;
+	topde.ctime = dt->now();
 
 	s := Sink.new(session, blocksize);
 	ms := MSink.new(session, blocksize);
@@ -94,66 +131,93 @@ init(nil: ref Draw->Context, args: list of string)
 		writepath(hd args, s, ms);
 	say("tree written");
 
+	if(vflag && bout.flush() == bufio->ERROR)
+		fail(sprint("write stdout: %r"));
+
 	e0 := s.finish();
 	if(e0 == nil)
-		error(sprint("writing top entry: %r"));
+		fail(sprint("writing top entry: %r"));
 	e1 := ms.finish();
 	if(e1 == nil)
-		error(sprint("writing top meta entry: %r"));
-	say(sprint("top entries written (%s, %s)", e0.score.text(), e1.score.text()));
+		fail(sprint("writing top meta entry: %r"));
+	topde.qidspace = 1;
+	topde.qidoff = big 0;
+	topde.qidmax = pathgen;
 	s2 := MSink.new(session, blocksize);
 	if(s2.add(topde) < 0)
-		error(sprint("adding direntry for top entries: %r"));
+		fail(sprint("adding direntry for top entries: %r"));
 	e2 := s2.finish();
 	say("top meta entry written, "+e2.score.text());
 
- 	td := array[Entrysize*3] of byte;
- 	td[0*Entrysize:] = e0.pack();
- 	td[1*Entrysize:] = e1.pack();
- 	td[2*Entrysize:] = e2.pack();
-	(tok, tscore) := session.write(Dirtype, td);
+ 	td := array[venti->Entrysize*3] of byte;
+ 	td[0*venti->Entrysize:] = e0.pack();
+ 	td[1*venti->Entrysize:] = e1.pack();
+ 	td[2*venti->Entrysize:] = e2.pack();
+	(tok, tscore) := session.write(venti->Dirtype, td);
 	if(tok < 0)
-		error(sprint("writing top-level entries: %r"));
-	say("top entry written, "+tscore.text());
+		fail(sprint("writing top-level entries: %r"));
 
-	root := Root.new(name, "vac", tscore, blocksize, nil);
+	root := ref Root(venti->Rootversion, name, "vac", tscore, blocksize, nil);
 	rd := root.pack();
 	if(rd == nil)
-		error(sprint("root pack: %r"));
-	(rok, rscore) := session.write(Roottype, rd);
+		fail(sprint("root pack: %r"));
+	(rok, rscore) := session.write(venti->Roottype, rd);
 	if(rok < 0)
-		error(sprint("writing root score: %r"));
-	say("root written, "+rscore.text());
-	print("vac:%s\n", rscore.text());
+		fail(sprint("writing root score: %r"));
+	sys->print("vac:%s\n", rscore.text());
 	if(session.sync() < 0)
-		error(sprint("syncing server: %r"));
+		fail(sprint("syncing server: %r"));
+}
+
+readpaths(): ref Strhash[string]
+{
+	t := Strhash[string].new(199, nil);
+	b := bufio->fopen(sys->fildes(0), bufio->OREAD);
+	if(b == nil)
+		fail(sprint("fopen: %r"));
+	for(;;) {
+		s := b.gets('\n');
+		if(s == nil)
+			break;
+		if(s[len s-1] == '\n')
+			s = s[:len s-1];
+		t.add(s, s);
+	}
+	return t;
+}
+
+usepath(p: string): int
+{
+	if(itab != nil)
+		return itab.find(p) != nil;
+	if(xtab != nil)
+		return xtab.find(p) == nil;
+	return 1;
 }
 
 writepath(path: string, s: ref Sink, ms: ref MSink)
 {
-	if(vflag)
-		print("%s\n", path);
-say("writepath "+path);
+	if(!usepath(path))
+		return;
+
+	if(vflag && bout.puts(path+"\n") == bufio->ERROR)
+		fail(sprint("write stdout: %r"));
+
 	fd := sys->open(path, sys->OREAD);
 	if(fd == nil)
-		error(sprint("opening %s: %r", path));
+		fail(sprint("opening %s: %r", path));
 	(ok, dir) := sys->fstat(fd);
 	if(ok < 0)
-		error(sprint("fstat %s: %r", path));
-say("writepath: file opened");
-	if(dir.mode&sys->DMAUTH) {
-		warn(path+": is auth file, skipping");
-		return;
-	}
-	if(dir.mode&sys->DMTMP) {
-		warn(path+": is temporary file, skipping");
-		return;
-	}
+		fail(sprint("fstat %s: %r", path));
+	if(dir.mode&sys->DMAUTH)
+		return warn(path+": is auth file, skipping");
+	if(dir.mode&sys->DMTMP)
+		return warn(path+": is temporary file, skipping");
 
 	e, me: ref Entry;
 	de: ref Direntry;
+	qid := pathgen++;
 	if(dir.mode & sys->DMDIR) {
-say("writepath: file is dir");
 		ns := Sink.new(session, blocksize);
 		nms := MSink.new(session, blocksize);
 		for(;;) {
@@ -161,7 +225,7 @@ say("writepath: file is dir");
 			if(n == 0)
 				break;
 			if(n < 0)
-				error(sprint("dirread %s: %r", path));
+				fail(sprint("dirread %s: %r", path));
 			for(i := 0; i < len dirs; i++) {
 				d := dirs[i];
 				npath := path+"/"+d.name;
@@ -170,45 +234,49 @@ say("writepath: file is dir");
 		}
 		e = ns.finish();
 		if(e == nil)
-			error(sprint("error flushing dirsink for %s: %r", path));
+			fail(sprint("error flushing dirsink for %s: %r", path));
 		me = nms.finish();
 		if(me == nil)
-			error(sprint("error flushing metasink for %s: %r", path));
+			fail(sprint("error flushing metasink for %s: %r", path));
 	} else {
-say("writepath: file is normale file");
 		e = writefile(path, fd);
 		if(e == nil)
-			error(sprint("error flushing filesink for %s: %r", path));
+			fail(sprint("error flushing filesink for %s: %r", path));
 	}
-say("writepath: wrote path, "+e.score.text());
 
+	case dir.name {
+	"/" =>	dir.name = "root";
+	"." =>	dir.name = "dot";
+	}
 	de = Direntry.mk(dir);
-say("writepath: have direntry");
+	de.qid = qid;
+	if(uid != nil)
+		de.uid = uid;
+	if(gid != nil)
+		de.gid = gid;
 
 	i := s.add(e);
 	if(i < 0)
-		error(sprint("adding entry to sink: %r"));
+		fail(sprint("adding entry to sink: %r"));
 	mi := 0;
 	if(me != nil)
 		mi = s.add(me);
 	if(mi < 0)
-		error(sprint("adding mentry to sink: %r"));
+		fail(sprint("adding mentry to sink: %r"));
 	de.entry = i;
 	de.mentry = mi;
 	i = ms.add(de);
 	if(i < 0)
-		error(sprint("adding direntry to msink: %r"));
-say("writepath done");
+		fail(sprint("adding direntry to msink: %r"));
 }
 
 writefile(path: string, fd: ref Sys->FD): ref Entry
 {
 	bio := bufio->fopen(fd, bufio->OREAD);
 	if(bio == nil)
-		error(sprint("bufio opening %s: %r", path));
-	say(sprint("bufio opened path %s", path));
+		fail(sprint("bufio opening %s: %r", path));
 
-	f := File.new(session, Datatype, blocksize);
+	f := File.new(session, venti->Datatype, blocksize);
 	for(;;) {
 		buf := array[blocksize] of byte;
 		n := 0;
@@ -218,13 +286,12 @@ writefile(path: string, fd: ref Sys->FD): ref Entry
 			if(have == 0)
 				break;
 			if(have < 0)
-				error(sprint("reading %s: %r", path));
+				fail(sprint("reading %s: %r", path));
 			n += have;
 		}
-		say(sprint("have buf, length %d", n));
 
 		if(f.write(buf[:n]) < 0)
-			error(sprint("writing %s: %r", path));
+			fail(sprint("writing %s: %r", path));
 		if(n != len buf)
 			break;
 	}
@@ -234,21 +301,19 @@ writefile(path: string, fd: ref Sys->FD): ref Entry
 
 user(): string
 {
-	if((fd := sys->open("/dev/user", Sys->OREAD)) != nil
-		&& (n := sys->read(fd, d := array[128] of byte, len d)) > 0)
+	fd := sys->open("/dev/user", Sys->OREAD);
+	if(fd != nil)
+	if((n := sys->read(fd, d := array[128] of byte, len d)) > 0)
 		return string d[:n];
 	return "nobody";
 }
 
-error(s: string)
-{
-	warn(s);
-	raise "fail:"+s;
-}
-
+fd2: ref Sys->FD;
 warn(s: string)
 {
-	fprint(fildes(2), "%s\n", s);
+	if(fd2 == nil)
+		fd2 = sys->fildes(2);
+	sys->fprint(fd2, "%s\n", s);
 }
 
 say(s: string)
@@ -256,3 +321,9 @@ say(s: string)
 	if(dflag)
 		warn(s);
 }
+
+fail(s: string)
+{
+	warn(s);
+	raise "fail:"+s;
+}