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;
}