20060303a

1 files changed, 453 insertions, 0 deletions

diff --git a/appl/lib/styxlib.b b/appl/lib/styxlib.b
new file mode 100644
index 00000000..700eb8bb
--- /dev/null
+++ b/appl/lib/styxlib.b
@@ -0,0 +1,453 @@
+implement Styxlib;
+
+#
+# Copyright © 1999 Vita Nuova Limited.  All rights reserved.
+# Revisions copyright © 2002 Vita Nuova Holdings Limited.  All rights reserved.
+#
+
+include "sys.m";
+	sys: Sys;
+include "styx.m";
+	styx: Styx;
+	Tmsg, Rmsg: import styx;
+
+include "styxlib.m";
+
+CHANHASHSIZE: con 32;
+starttime: int;
+timefd: ref Sys->FD;
+
+DEBUG: con 0;
+
+init(s: Styx): string
+{
+	sys = load Sys Sys->PATH;
+	styx = s;	# our caller inits
+	return nil;
+}
+
+Styxserver.new(fd: ref Sys->FD): (chan of ref Tmsg, ref Styxserver)
+{
+	starttime = now();
+	srv := ref Styxserver(fd, array[CHANHASHSIZE] of list of ref Chan, getuname(), 0);
+	if(fd == nil)
+		return (nil, srv);
+	tchan := chan of ref Tmsg;
+	sync := chan of int;
+	spawn tmsgreader(fd, srv, tchan, sync);
+	<-sync;
+	return (tchan, srv);
+}
+
+now(): int
+{
+	if(timefd == nil){
+		timefd = sys->open("/dev/time", sys->OREAD);
+		if(timefd == nil)
+			return 0;
+	}
+	buf := array[64] of byte;
+	sys->seek(timefd, big 0, 0);
+	n := sys->read(timefd, buf, len buf);
+	if(n < 0)
+		return 0;
+
+	t := (big string buf[0:n]) / big 1000000;
+	return int t;
+}
+
+
+getuname(): string
+{
+	if ((fd := sys->open("/dev/user", Sys->OREAD)) == nil)
+		return "unknown";
+	buf := array[Sys->NAMEMAX] of byte;
+	n := sys->read(fd, buf, len buf);
+	if (n <= 0)
+		return "unknown";
+	return string buf[0:n];
+}
+
+tmsgreader(fd: ref Sys->FD, srv: ref Styxserver, tchan: chan of ref Tmsg, sync: chan of int)
+{
+	sys->pctl(Sys->NEWFD|Sys->NEWNS, fd.fd :: nil);
+	sync <-= 1;
+	fd = sys->fildes(fd.fd);
+	while((m := Tmsg.read(fd, srv.msize)) != nil && tagof m != tagof Tmsg.Readerror){
+		tchan <-= m;
+		m = nil;
+	}
+	tchan <-= m;
+}
+
+Styxserver.reply(srv: self ref Styxserver, m: ref Rmsg): int
+{
+	if (DEBUG) 
+		sys->fprint(sys->fildes(2), "%s\n", m.text());
+	a := m.pack();
+	if(a == nil)
+		return -1;
+	return sys->write(srv.fd, a, len a);
+}
+
+Styxserver.devversion(srv: self ref Styxserver, m: ref Tmsg.Version): int
+{
+	if(srv.msize <= 0)
+		srv.msize = Styx->MAXRPC;
+	(msize, version) := styx->compatible(m, srv.msize, Styx->VERSION);
+	if(msize < 128){
+		srv.reply(ref Rmsg.Error(m.tag, "unusable message size"));
+		return -1;
+	}
+	srv.msize = msize;
+	srv.reply(ref Rmsg.Version(m.tag, msize, version));
+	return 0;
+}
+
+Styxserver.devauth(srv: self ref Styxserver, m: ref Tmsg.Auth)
+{
+	srv.reply(ref Rmsg.Error(m.tag, "authentication not required"));
+}
+
+Styxserver.devattach(srv: self ref Styxserver, m: ref Tmsg.Attach): ref Chan
+{
+	c := srv.newchan(m.fid);
+	if (c == nil) {
+		srv.reply(ref Rmsg.Error(m.tag, Einuse));
+		return nil;
+	}
+	c.uname = m.uname;
+	c.qid.qtype = Sys->QTDIR;
+	c.qid.path = big 0;
+	c.path = "dev";
+	srv.reply(ref Rmsg.Attach(m.tag, c.qid));
+	return c;
+}
+
+Styxserver.clone(srv: self ref Styxserver, oc: ref Chan, newfid: int): ref Chan
+{
+	c := srv.newchan(newfid);
+	if (c == nil) 
+		return nil;
+	c.qid = oc.qid;
+	c.uname  = oc.uname;
+	c.open = oc.open;
+	c.mode = oc.mode;
+	c.path = oc.path;
+	c.data = oc.data;
+	return c;
+}
+
+Styxserver.devflush(srv: self ref Styxserver, m: ref Tmsg.Flush)
+{
+	srv.reply(ref Rmsg.Flush(m.tag));
+}
+
+Styxserver.devwalk(srv: self ref Styxserver, m: ref Tmsg.Walk,
+							gen: Dirgenmod, tab: array of Dirtab): ref Chan
+{
+	c := srv.fidtochan(m.fid);
+	if (c == nil) {
+		srv.reply(ref Rmsg.Error(m.tag, Ebadfid));
+		return nil;
+	}
+	if (c.open) {
+		srv.reply(ref Rmsg.Error(m.tag, Eopen));
+		return nil;
+	}
+	if (!c.isdir()) {
+		srv.reply(ref Rmsg.Error(m.tag, Enotdir));
+		return nil;
+	}
+	# should check permissions here?
+	qids: array of Sys->Qid;
+	cc := ref *c;	# walk a temporary copy
+	if(len m.names > 0){
+		qids = array[len m.names] of Sys->Qid;
+		for(i := 0; i < len m.names; i++){
+			for(k := 0;; k++){
+				(ok, d) := gen->dirgen(srv, cc, tab, k);
+				if(ok < 0){
+					if(i == 0)
+						srv.reply(ref Rmsg.Error(m.tag, Enotfound));
+					else
+						srv.reply(ref Rmsg.Walk(m.tag, qids[0:i]));
+					return nil;
+				}
+				if (d.name == m.names[i]) {
+					cc.qid = d.qid;
+					cc.path = d.name;
+					qids[i] = cc.qid;
+					break;
+				}
+			}
+		}
+	}
+	# successful walk
+	if(m.newfid != m.fid){
+		# clone/walk
+		nc := srv.clone(cc, m.newfid);
+		if(nc == nil){
+			srv.reply(ref Rmsg.Error(m.tag, Einuse));
+			return nil;
+		}
+		c = nc;
+	}else{
+		# walk c itself
+		c.qid = cc.qid;
+		c.path = cc.path;
+	}
+	srv.reply(ref Rmsg.Walk(m.tag, qids));
+	return c;
+}
+
+Styxserver.devclunk(srv: self ref Styxserver, m: ref Tmsg.Clunk): ref Chan
+{
+	c := srv.fidtochan(m.fid);
+	if (c == nil) {
+		srv.reply(ref Rmsg.Error(m.tag, Ebadfid));
+		return nil;
+	}
+	srv.chanfree(c);
+	srv.reply(ref Rmsg.Clunk(m.tag));
+	return c;
+}
+
+Styxserver.devstat(srv: self ref Styxserver, m: ref Tmsg.Stat,
+							gen: Dirgenmod, tab: array of Dirtab)
+{
+	c := srv.fidtochan(m.fid);
+	if (c == nil) {
+		srv.reply(ref Rmsg.Error(m.tag, Ebadfid));
+		return;
+	}
+	i := 0;
+	(ok, d) := gen->dirgen(srv, c, tab, i++);
+	while (ok >= 0) {
+		if (ok > 0 && c.qid.path == d.qid.path) {
+			srv.reply(ref Rmsg.Stat(m.tag, d));
+			return;
+		}
+		(ok, d) = gen->dirgen(srv, c, tab, i++);
+	}
+	# auto-generate entry for directory if not found.
+	# XXX this is asking for trouble, as the permissions given
+	# on stat() of a directory can be different from those given
+	# when reading the directory's entry in its parent dir.
+	if (c.qid.qtype & Sys->QTDIR)
+		srv.reply(ref Rmsg.Stat(m.tag, devdir(c, c.qid, c.path, big 0, srv.uname, Sys->DMDIR|8r555)));
+	else
+		srv.reply(ref Rmsg.Error(m.tag, Enotfound));
+}
+
+Styxserver.devdirread(srv: self ref Styxserver, m: ref Tmsg.Read,
+							gen: Dirgenmod, tab: array of Dirtab)
+{
+	c := srv.fidtochan(m.fid);
+	if (c == nil) {
+		srv.reply(ref Rmsg.Error(m.tag, Ebadfid));
+		return;
+	}
+	offset := int m.offset;
+	data := array[m.count] of byte;
+	start := 0;
+	n := 0;
+	for (k := 0;; k++) {
+		(ok, d) := gen->dirgen(srv, c, tab, k);
+		if(ok < 0){
+			srv.reply(ref Rmsg.Read(m.tag, data[0:n]));
+			return;
+		}
+		size := styx->packdirsize(d);
+		if(start < offset){
+			start += size;
+			continue;
+		}
+		if(n+size > m.count)
+			break;
+		data[n:] = styx->packdir(d);
+		n += size;
+	}
+	srv.reply(ref Rmsg.Read(m.tag, data[0:n]));
+}
+
+Styxserver.devopen(srv: self ref Styxserver, m: ref Tmsg.Open,
+							gen: Dirgenmod, tab: array of Dirtab): ref Chan
+{
+	c := srv.fidtochan(m.fid);
+	if (c == nil) {
+		srv.reply(ref Rmsg.Error(m.tag, Ebadfid));
+		return nil;
+	}
+	omode := m.mode;
+	i := 0;
+	(ok, d) := gen->dirgen(srv, c, tab, i++);
+	while (ok >= 0) {
+		# XXX dev.c checks vers as well... is that desirable?
+		if (ok > 0 && c.qid.path == d.qid.path) {
+			if (openok(omode, d.mode, c.uname, d.uid, d.gid)) {
+				c.qid.vers = d.qid.vers;
+				break;
+			}
+			srv.reply(ref Rmsg.Error(m.tag, Eperm));
+			return nil;
+		}
+		(ok, d) = gen->dirgen(srv, c, tab, i++);
+	}
+	if ((c.qid.qtype & Sys->QTDIR) && omode != Sys->OREAD) {
+		srv.reply(ref Rmsg.Error(m.tag, Eperm));
+		return nil;
+	}
+	if ((c.mode = openmode(omode)) == -1) {
+		srv.reply(ref Rmsg.Error(m.tag, Ebadarg));
+		return nil;
+	}
+	c.open = 1;
+	c.mode = omode;
+	srv.reply(ref Rmsg.Open(m.tag, c.qid, Styx->MAXFDATA));
+	return c;
+}
+
+Styxserver.devremove(srv: self ref Styxserver, m: ref Tmsg.Remove): ref Chan
+{
+	c := srv.fidtochan(m.fid);
+	if (c == nil) {
+		srv.reply(ref Rmsg.Error(m.tag, Ebadfid));
+		return nil;
+	}
+	srv.chanfree(c);
+	srv.reply(ref Rmsg.Error(m.tag, Eperm));
+	return c;
+}
+
+Styxserver.fidtochan(srv: self ref Styxserver, fid: int): ref Chan
+{
+	for (l := srv.chans[fid & (CHANHASHSIZE-1)]; l != nil; l = tl l)
+		if ((hd l).fid == fid)
+			return hd l;
+	return nil;
+}
+
+Styxserver.chanfree(srv: self ref Styxserver, c: ref Chan)
+{
+	slot := c.fid & (CHANHASHSIZE-1);
+	nl: list of ref Chan;
+	for (l := srv.chans[slot]; l != nil; l = tl l)
+		if ((hd l).fid != c.fid)
+			nl = (hd l) :: nl;
+	srv.chans[slot] = nl;
+}
+
+Styxserver.chanlist(srv: self ref Styxserver): list of ref Chan
+{
+	cl: list of ref Chan;
+	for (i := 0; i < len srv.chans; i++)
+		for (l := srv.chans[i]; l != nil; l = tl l)
+			cl = hd l :: cl;
+	return cl;
+}
+
+Styxserver.newchan(srv: self ref Styxserver, fid: int): ref Chan
+{
+	# fid already in use
+	if ((c := srv.fidtochan(fid)) != nil)
+		return nil;
+	c = ref Chan;
+	c.qid = Sys->Qid(big 0, 0, Sys->QTFILE);
+	c.open = 0;
+	c.mode = 0;
+	c.fid = fid;
+	slot := fid & (CHANHASHSIZE-1);
+	srv.chans[slot] = c :: srv.chans[slot];
+	return c;
+}
+
+devdir(nil: ref Chan, qid: Sys->Qid, name: string, length: big,
+				user: string, perm: int): Sys->Dir
+{
+	d: Sys->Dir;
+	d.name = name;
+	d.qid = qid;
+	d.dtype = 'X';
+	d.dev = 0;		# XXX what should this be?
+	d.mode = perm;
+	if (qid.qtype & Sys->QTDIR)
+		d.mode |= Sys->DMDIR;
+	d.atime = starttime;	# XXX should be better than this.
+	d.mtime = starttime;
+	d.length = length;
+	d.uid = user;
+	d.gid = user;
+	return d;
+}
+
+readbytes(m: ref Tmsg.Read, d: array of byte): ref Rmsg.Read
+{
+	r := ref Rmsg.Read(m.tag, nil);
+	offset := int m.offset;
+	if (offset >= len d)
+		return r;
+	e := offset + m.count;
+	if (e > len d)
+		e = len d;
+	r.data = d[offset:e];
+	return r;
+}
+
+readnum(m: ref Tmsg.Read, val, size: int): ref Rmsg.Read
+{
+	return readbytes(m, sys->aprint("%-*d", size, val));
+}
+
+readstr(m: ref Tmsg.Read, d: string): ref Rmsg.Read
+{
+	return readbytes(m, array of byte d);
+}
+
+dirgenmodule(): Dirgenmod
+{
+	return load Dirgenmod "$self";
+}
+
+dirgen(srv: ref Styxserver, c: ref Styxlib->Chan,
+				tab: array of Dirtab, i: int): (int, Sys->Dir)
+{
+	d: Sys->Dir;
+	if (tab == nil || i >= len tab)
+		return (-1, d);
+	return (1, devdir(c, tab[i].qid, tab[i].name, tab[i].length, srv.uname, tab[i].perm));
+}
+
+openmode(o: int): int
+{
+	OTRUNC, ORCLOSE, OREAD, ORDWR: import Sys;
+	if(o >= (OTRUNC|ORCLOSE|ORDWR))
+		return -1;
+	o &= ~(OTRUNC|ORCLOSE);
+	if(o > ORDWR)
+		return -1;
+	return o;
+}
+
+access := array[] of {8r400, 8r200, 8r600, 8r100};
+openok(omode, perm: int, uname, funame, nil: string): int
+{
+	# XXX what should we do about groups?
+	# this is inadequate anyway:
+	# OTRUNC
+	# user should be allowed to open it if permission
+	# is allowed to others.
+	mode: int;
+	if (uname == funame)
+		mode = perm;
+	else
+		mode = perm << 6;
+
+	t := access[omode & 3];
+	return ((t & mode) == t);
+}	
+
+Chan.isdir(c: self ref Chan): int
+{
+	return (c.qid.qtype & Sys->QTDIR) != 0;
+}