ref: 82b046f36f8084a22bbb5d71edd0edd9179561eb
dir: /appl/lib/styxservers.b/
implement Styxservers;
#
# Copyright © 1999 Vita Nuova Limited. All rights reserved.
# Revisions copyright © 2000-2003 Vita Nuova Holdings Limited. All rights reserved.
#
# Derived from Roger Peppe's Styxlib by Martin C. Atkins, 2001/2002 by
# adding new helper functions, and then removing Dirgenmod and its helpers
#
# Further modified by Roger Peppe to simplify the interface by
# adding the Navigator/Navop channel interface and making other changes,
# including using the Styx module
#
# converted to revised Styx at Vita Nuova
# further revised August/September 2002
#
# TO DO:
# - directory reading interface revision?
#
include "sys.m";
sys: Sys;
include "styx.m";
styx: Styx;
Tmsg, Rmsg: import styx;
include "styxservers.m";
CHANHASHSIZE: con 32;
DIRREADSIZE: con Styx->STATFIXLEN+4*20; # ``reasonable'' chunk for reading directories
debug := 0;
init(styxmod: Styx)
{
sys = load Sys Sys->PATH;
styx = styxmod;
}
traceset(d: int)
{
debug = d;
}
Styxserver.new(fd: ref Sys->FD, t: ref Navigator, rootpath: big): (chan of ref Tmsg, ref Styxserver)
{
tchan := chan of ref Tmsg;
srv := ref Styxserver(fd, array[CHANHASHSIZE] of list of ref Fid, chan[1] of int, t, rootpath, 0, nil);
sync := chan of int;
spawn tmsgreader(fd, srv, tchan, sync);
<-sync;
return (tchan, srv);
}
tmsgreader(fd: ref Sys->FD, srv: ref Styxserver, tchan: chan of ref Tmsg, sync: chan of int)
{
if(debug)
sys->pctl(Sys->NEWFD|Sys->NEWNS, fd.fd :: 2 :: nil);
else
sys->pctl(Sys->NEWFD|Sys->NEWNS, fd.fd :: nil);
sync <-= 1;
fd = sys->fildes(fd.fd);
m: ref Tmsg;
do {
m = Tmsg.read(fd, srv.msize);
if(debug && m != nil)
sys->fprint(sys->fildes(2), "<- %s\n", m.text());
tchan <-= m;
} while(m != nil && tagof(m) != tagof(Tmsg.Readerror));
}
Fid.clone(oc: self ref Fid, c: ref Fid): ref Fid
{
# c.fid not touched, other values copied from c
c.path = oc.path;
c.qtype = oc.qtype;
c.isopen = oc.isopen;
c.mode = oc.mode;
c.doffset = oc.doffset;
c.uname = oc.uname;
c.param = oc.param;
c.data = oc.data;
return c;
}
Fid.walk(c: self ref Fid, qid: Sys->Qid)
{
c.path = qid.path;
c.qtype = qid.qtype;
}
Fid.open(c: self ref Fid, mode: int, qid: Sys->Qid)
{
c.isopen = 1;
c.mode = mode;
c.doffset = (0, 0);
c.path = qid.path;
c.qtype = qid.qtype;
}
Styxserver.error(srv: self ref Styxserver, m: ref Tmsg, msg: string)
{
srv.reply(ref Rmsg.Error(m.tag, msg));
}
Styxserver.reply(srv: self ref Styxserver, m: ref Rmsg): int
{
if(debug)
sys->fprint(sys->fildes(2), "-> %s\n", m.text());
if(srv.replychan != nil){
srv.replychan <-= m;
return 0;
}
return srv.replydirect(m);
}
Styxserver.replydirect(srv: self ref Styxserver, m: ref Rmsg): int
{
if(srv.msize == 0)
m = ref Rmsg.Error(m.tag, "Tversion not seen");
d := m.pack();
if(srv.msize != 0 && len d > srv.msize){
m = ref Rmsg.Error(m.tag, "Styx reply didn't fit");
d = m.pack();
}
return sys->write(srv.fd, d, len d);
}
Styxserver.attach(srv: self ref Styxserver, m: ref Tmsg.Attach): ref Fid
{
(d, err) := srv.t.stat(srv.rootpath);
if(d == nil) {
srv.reply(ref Rmsg.Error(m.tag, err));
return nil;
}
if((d.qid.qtype & Sys->QTDIR) == 0) {
srv.reply(ref Rmsg.Error(m.tag, Enotdir));
return nil;
}
c := srv.newfid(m.fid);
if(c == nil) {
srv.reply(ref Rmsg.Error(m.tag, Einuse));
return nil;
}
c.uname = m.uname;
c.param = m.aname;
c.path = d.qid.path;
c.qtype = d.qid.qtype;
srv.reply(ref Rmsg.Attach(m.tag, d.qid));
return c;
}
walk1(n: ref Navigator, c: ref Fid, name: string): (ref Sys->Dir, string)
{
(d, err) := n.stat(c.path);
if(d == nil)
return (nil, err);
if((d.qid.qtype & Sys->QTDIR) == 0)
return (nil, Enotdir);
if(!openok(c.uname, Styx->OEXEC, d.mode, d.uid, d.gid))
return (nil, Eperm);
(d, err) = n.walk(d.qid.path, name);
if(d == nil)
return (nil, err);
return (d, nil);
}
Styxserver.walk(srv: self ref Styxserver, m: ref Tmsg.Walk): ref Fid
{
c := srv.getfid(m.fid);
if(c == nil) {
srv.reply(ref Rmsg.Error(m.tag, Ebadfid));
return nil;
}
if(c.isopen) {
srv.reply(ref Rmsg.Error(m.tag, Eopen));
return nil;
}
if(m.newfid != m.fid){
nc := srv.newfid(m.newfid);
if(nc == nil){
srv.reply(ref Rmsg.Error(m.tag, Einuse));
return nil;
}
c = c.clone(nc);
}
qids := array[len m.names] of Sys->Qid;
oldpath := c.path;
oldqtype := c.qtype;
for(i := 0; i < len m.names; i++){
(d, err) := walk1(srv.t, c, m.names[i]);
if(d == nil){
c.path = oldpath; # restore c
c.qtype = oldqtype;
if(m.newfid != m.fid)
srv.delfid(c);
if(i == 0)
srv.reply(ref Rmsg.Error(m.tag, err));
else
srv.reply(ref Rmsg.Walk(m.tag, qids[0:i]));
return nil;
}
c.walk(d.qid);
qids[i] = d.qid;
}
srv.reply(ref Rmsg.Walk(m.tag, qids));
return c;
}
Styxserver.canopen(srv: self ref Styxserver, m: ref Tmsg.Open): (ref Fid, int, ref Sys->Dir, string)
{
c := srv.getfid(m.fid);
if(c == nil)
return (nil, 0, nil, Ebadfid);
if(c.isopen)
return (nil, 0, nil, Eopen);
(f, err) := srv.t.stat(c.path);
if(f == nil)
return (nil, 0, nil, err);
mode := openmode(m.mode);
if(mode == -1)
return (nil, 0, nil, Ebadarg);
if(mode != Sys->OREAD && f.qid.qtype & Sys->QTDIR)
return (nil, 0, nil, Eperm);
if(!openok(c.uname, m.mode, f.mode, f.uid, f.gid))
return (nil, 0, nil, Eperm);
if(m.mode & Sys->ORCLOSE) {
(dir, nil) := srv.t.walk(c.path, "..");
if(dir == nil || dir.qid.path == f.qid.path && dir.qid.qtype == f.qid.qtype || # can't remove root directory
!openok(c.uname, Sys->OWRITE, dir.mode, dir.uid, dir.gid))
return (nil, 0, nil, Eperm);
mode |= Sys->ORCLOSE;
}
return (c, mode, f, err);
}
Styxserver.open(srv: self ref Styxserver, m: ref Tmsg.Open): ref Fid
{
(c, mode, f, err) := srv.canopen(m);
if(c == nil){
srv.reply(ref Rmsg.Error(m.tag, err));
return nil;
}
c.open(mode, f.qid);
srv.reply(ref Rmsg.Open(m.tag, f.qid, srv.iounit()));
return c;
}
Styxserver.cancreate(srv: self ref Styxserver, m: ref Tmsg.Create): (ref Fid, int, ref Sys->Dir, string)
{
c := srv.getfid(m.fid);
if(c == nil)
return (nil, 0, nil, Ebadfid);
if(c.isopen)
return (nil, 0, nil, Eopen);
(d, err) := srv.t.stat(c.path);
if(d == nil)
return (nil, 0, nil, err);
if((d.mode & Sys->DMDIR) == 0)
return (nil, 0, nil, Enotdir);
if(m.name == "")
return (nil, 0, nil, Ename);
if(m.name == "." || m.name == "..")
return (nil, 0, nil, Edot);
if(!openok(c.uname, Sys->OWRITE, d.mode, d.uid, d.gid))
return (nil, 0, nil, Eperm);
if(srv.t.walk(d.qid.path, m.name).t0 != nil)
return (nil, 0, nil, Eexists);
if((mode := openmode(m.mode)) == -1)
return (nil, 0, nil, Ebadarg);
mode |= m.mode & Sys->ORCLOSE; # can create, so directory known to be writable
f := ref Sys->zerodir;
if(m.perm & Sys->DMDIR){
f.mode = m.perm & (~8r777 | (d.mode & 8r777));
f.qid.qtype = Sys->QTDIR;
}else{
f.mode = m.perm & (~8r666 | (d.mode & 8r666));
f.qid.qtype = Sys->QTFILE;
}
f.name = m.name;
f.uid = c.uname;
f.muid = c.uname;
f.gid = d.gid;
f.dtype = d.dtype;
f.dev = d.dev;
# caller must supply atime, mtime, qid.path
return (c, mode, f, nil);
}
Styxserver.canread(srv: self ref Styxserver, m: ref Tmsg.Read): (ref Fid, string)
{
c := srv.getfid(m.fid);
if(c == nil)
return (nil, Ebadfid);
if(!c.isopen)
return (nil, Enotopen);
mode := c.mode & 3;
if(mode != Sys->OREAD && mode != Sys->ORDWR) # readable modes
return (nil, Eaccess);
if(m.count < 0 || m.count > srv.msize-Styx->IOHDRSZ)
return (nil, Ecount);
if(m.offset < big 0)
return (nil, Eoffset);
return (c, nil);
}
Styxserver.read(srv: self ref Styxserver, m: ref Tmsg.Read): ref Fid
{
(c, err) := srv.canread(m);
if(c == nil){
srv.reply(ref Rmsg.Error(m.tag, err));
return nil;
}
if((c.qtype & Sys->QTDIR) == 0) {
srv.reply(ref Rmsg.Error(m.tag, Eperm));
return nil;
}
if(m.count <= 0){
srv.reply(ref Rmsg.Read(m.tag, nil));
return c;
}
a := array[m.count] of byte;
(offset, index) := c.doffset;
if(int m.offset != offset){ # rescan from the beginning
offset = 0;
index = 0;
}
p := 0;
Dread:
while((d := srv.t.readdir(c.path, index, (m.count+DIRREADSIZE-1)/DIRREADSIZE)) != nil && (nd := len d) > 0){
for(i := 0; i < nd; i++) {
size := styx->packdirsize(*d[i]);
offset += size;
index++;
if(offset < int m.offset)
continue;
if((m.count -= size) < 0){ # won't fit, save state for next time
offset -= size;
index--;
break Dread;
}
de := styx->packdir(*d[i]);
a[p:] = de;
p += size;
}
}
c.doffset = (offset, index);
srv.reply(ref Rmsg.Read(m.tag, a[0:p]));
return c;
}
Styxserver.canwrite(srv: self ref Styxserver, m: ref Tmsg.Write): (ref Fid, string)
{
c := srv.getfid(m.fid);
if(c == nil)
return (nil, Ebadfid);
if(!c.isopen)
return (nil, Enotopen);
if(c.qtype & Sys->QTDIR)
return (nil, Eperm);
mode := c.mode & 3;
if(mode != Sys->OWRITE && mode != Sys->ORDWR) # writable modes
return (nil, Eaccess);
if(m.offset < big 0)
return (nil, Eoffset);
# could check len m.data > iounit, but since we've got it now, it doesn't matter
return (c, nil);
}
Styxserver.stat(srv: self ref Styxserver, m: ref Tmsg.Stat)
{
c := srv.getfid(m.fid);
if(c == nil) {
srv.reply(ref Rmsg.Error(m.tag, Ebadfid));
return;
}
(d, err) := srv.t.stat(c.path);
if(d == nil) {
srv.reply(ref Rmsg.Error(m.tag, err));
return;
}
srv.reply(ref Rmsg.Stat(m.tag, *d));
}
Styxserver.canremove(srv: self ref Styxserver, m: ref Tmsg.Remove): (ref Fid, big, string)
{
c := srv.getfid(m.fid);
if(c == nil)
return (nil, big 0, Ebadfid);
(dir, nil) := srv.t.walk(c.path, ".."); # this relies on .. working for non-directories
if(dir == nil)
return (nil, big 0, "can't find parent directory");
if(dir.qid.path == c.path && dir.qid.qtype == c.qtype || # can't remove root directory
!openok(c.uname, Sys->OWRITE, dir.mode, dir.uid, dir.gid))
return (nil, big 0, Eperm);
return (c, dir.qid.path, nil);
}
Styxserver.remove(srv: self ref Styxserver, m: ref Tmsg.Remove): ref Fid
{
c := srv.getfid(m.fid);
if(c == nil) {
srv.reply(ref Rmsg.Error(m.tag, Ebadfid));
return nil;
}
srv.delfid(c); # Remove always clunks the fid
srv.reply(ref Rmsg.Error(m.tag, Eperm));
return c;
}
Styxserver.clunk(srv: self ref Styxserver, m: ref Tmsg.Clunk): ref Fid
{
c := srv.getfid(m.fid);
if(c == nil) {
srv.reply(ref Rmsg.Error(m.tag, Ebadfid));
return nil;
}
srv.delfid(c);
srv.reply(ref Rmsg.Clunk(m.tag));
return c;
}
Styxserver.default(srv: self ref Styxserver, gm: ref Tmsg)
{
if(gm == nil) {
srv.t.c <-= nil;
exit;
}
pick m := gm {
Readerror =>
srv.t.c <-= nil;
exit;
Version =>
if(srv.msize <= 0)
srv.msize = Styx->MAXRPC;
(msize, version) := styx->compatible(m, srv.msize, Styx->VERSION);
if(msize < 256){
srv.reply(ref Rmsg.Error(m.tag, "message size too small"));
break;
}
srv.msize = msize;
srv.reply(ref Rmsg.Version(m.tag, msize, version));
Auth =>
srv.reply(ref Rmsg.Error(m.tag, "authentication not required"));
Flush =>
srv.reply(ref Rmsg.Flush(m.tag));
Walk =>
srv.walk(m);
Open =>
srv.open(m);
Create =>
srv.reply(ref Rmsg.Error(m.tag, Eperm));
Read =>
srv.read(m);
Write =>
srv.reply(ref Rmsg.Error(m.tag, Eperm));
Clunk =>
srv.clunk(m);
# to delete on ORCLOSE:
# c := srv.clunk(m);
# if(c != nil && c.mode & Sys->ORCLOSE)
# srv.doremove(c);
Stat =>
srv.stat(m);
Remove =>
srv.remove(m);
Wstat =>
srv.reply(ref Rmsg.Error(m.tag, Eperm));
Attach =>
srv.attach(m);
* =>
sys->fprint(sys->fildes(2), "styxservers: unhandled Tmsg tag %d - should not happen\n", tagof gm);
raise "fail: unhandled case";
}
}
Styxserver.iounit(srv: self ref Styxserver): int
{
n := srv.msize - Styx->IOHDRSZ;
if(n <= 0)
return 0; # unknown
return n;
}
Styxserver.getfid(srv: self ref Styxserver, fid: int): ref Fid
{
# the list is safe to use without locking
for(l := srv.fids[fid & (CHANHASHSIZE-1)]; l != nil; l = tl l)
if((hd l).fid == fid)
return hd l;
return nil;
}
Styxserver.delfid(srv: self ref Styxserver, c: ref Fid)
{
slot := c.fid & (CHANHASHSIZE-1);
nl: list of ref Fid;
srv.fidlock <-= 1;
for(l := srv.fids[slot]; l != nil; l = tl l)
if((hd l).fid != c.fid)
nl = (hd l) :: nl;
srv.fids[slot] = nl;
<-srv.fidlock;
}
Styxserver.allfids(srv: self ref Styxserver): list of ref Fid
{
cl: list of ref Fid;
srv.fidlock <-= 1;
for(i := 0; i < len srv.fids; i++)
for(l := srv.fids[i]; l != nil; l = tl l)
cl = hd l :: cl;
<-srv.fidlock;
return cl;
}
Styxserver.newfid(srv: self ref Styxserver, fid: int): ref Fid
{
srv.fidlock <-= 1;
if((c := srv.getfid(fid)) != nil){
<-srv.fidlock;
return nil; # illegal: fid in use
}
c = ref Fid;
c.path = big -1;
c.qtype = 0;
c.isopen = 0;
c.mode = 0;
c.fid = fid;
c.doffset = (0, 0);
slot := fid & (CHANHASHSIZE-1);
srv.fids[slot] = c :: srv.fids[slot];
<-srv.fidlock;
return c;
}
readstr(m: ref Tmsg.Read, d: string): ref Rmsg.Read
{
return readbytes(m, array of byte d);
}
readbytes(m: ref Tmsg.Read, d: array of byte): ref Rmsg.Read
{
r := ref Rmsg.Read(m.tag, nil);
if(m.offset >= big len d || m.offset < big 0)
return r;
offset := int m.offset;
e := offset + m.count;
if(e > len d)
e = len d;
r.data = d[offset:e];
return r;
}
Navigator.new(c: chan of ref Navop): ref Navigator
{
return ref Navigator(c, chan of (ref Sys->Dir, string));
}
Navigator.stat(t: self ref Navigator, q: big): (ref Sys->Dir, string)
{
t.c <-= ref Navop.Stat(t.reply, q);
return <-t.reply;
}
Navigator.walk(t: self ref Navigator, q: big, name: string): (ref Sys->Dir, string)
{
t.c <-= ref Navop.Walk(t.reply, q, name);
return <-t.reply;
}
Navigator.readdir(t: self ref Navigator, q: big, offset, count: int): array of ref Sys->Dir
{
a := array[count] of ref Sys->Dir;
t.c <-= ref Navop.Readdir(t.reply, q, offset, count);
i := 0;
while((d := (<-t.reply).t0) != nil)
if(i < count)
a[i++] = d;
if(i == 0)
return nil;
return a[0:i];
}
openmode(o: int): int
{
OTRUNC, ORCLOSE, OREAD, ORDWR: import Sys;
o &= ~(OTRUNC|ORCLOSE);
if(o > ORDWR)
return -1;
return o;
}
access := array[] of {8r400, 8r200, 8r600, 8r100};
openok(uname: string, omode: int, perm: int, fuid: string, fgid: string): int
{
t := access[omode & 3];
if(omode & Sys->OTRUNC){
if(perm & Sys->DMDIR)
return 0;
t |= 8r200;
}
if(uname == fuid && (t&perm) == t)
return 1;
if(uname == fgid && (t&(perm<<3)) == t)
return 1;
return (t&(perm<<6)) == t;
}