ref: f12744b5db76e862de58aaa54cbd5ddfc63905b0
dir: /sys/src/cmd/ratfs/proto.c/
#include "ratfs.h"
/*
* 9P protocol interface
*/
enum {
RELOAD = 0, /* commands written to ctl file */
RDEBUG,
RNODEBUG,
RNONE,
};
static void rflush(Fcall*),
rauth(Fcall*), rattach(Fcall*),
rclone(Fcall*), rwalk(Fcall*),
ropen(Fcall*),
rcreate(Fcall*), rread(Fcall*),
rwrite(Fcall*), rclunk(Fcall*),
rremove(Fcall*), rstat(Fcall*),
rwstat(Fcall*), rversion(Fcall*);
static Fid* newfid(int);
static void reply(Fcall*, char*);
static void (*fcalls[])(Fcall*) = {
[Tversion] rversion,
[Tflush] rflush,
[Tauth] rauth,
[Tattach] rattach,
[Twalk] rwalk,
[Topen] ropen,
[Tcreate] rcreate,
[Tread] rread,
[Twrite] rwrite,
[Tclunk] rclunk,
[Tremove] rremove,
[Tstat] rstat,
[Twstat] rwstat,
};
static Keyword cmds[] = {
"reload", RELOAD,
"debug", RDEBUG,
"nodebug", RNODEBUG,
0, RNONE,
};
/*
* Main protocol loop
*/
void
io(void)
{
Fcall rhdr;
int n;
while((n = read9pmsg(srvfd, rbuf, sizeof rbuf-1)) != 0){
if(n < 0)
fatal("mount read: %r");
if(convM2S(rbuf, n, &rhdr) != n){
if(debugfd >= 0)
fprint(2, "%s: malformed message\n", argv0);
fatal("convM2S format error: %r");
}
if(debugfd >= 0)
fprint(debugfd, "<-%F\n", &rhdr);/**/
if(!fcalls[rhdr.type])
reply(&rhdr, "bad fcall type");
else
(*fcalls[rhdr.type])(&rhdr);
}
}
/*
* write a protocol reply to the client
*/
static void
reply(Fcall *r, char *error)
{
int n;
if(error == nil)
r->type++;
else {
r->type = Rerror;
r->ename = error;
}
if(debugfd >= 0)
fprint(debugfd, "->%F\n", r);/**/
n = convS2M(r, rbuf, sizeof rbuf);
if(n == 0)
fatal("convS2M: %r");
if(write(srvfd, rbuf, n) < 0)
fatal("reply: %r");
}
/*
* lookup a fid. if not found, create a new one.
*/
static Fid*
newfid(int fid)
{
Fid *f, *ff;
static Fid *fids;
ff = 0;
for(f = fids; f; f = f->next){
if(f->fid == fid){
if(!f->busy)
f->node = 0;
return f;
} else if(!ff && !f->busy)
ff = f;
}
if(ff == 0){
ff = mallocz(sizeof(*f), 1);
ff->next = fids;
fids = ff;
}
ff->node = 0;
ff->fid = fid;
return ff;
}
static void
rversion(Fcall *f)
{
f->version = "9P2000";
if(f->msize > MAXRPC)
f->msize = MAXRPC;
reply(f, 0);
}
static void
rauth(Fcall *f)
{
reply(f, "ratfs: authentication not required");
}
static void
rflush(Fcall *f)
{
reply(f, 0);
}
static void
rattach(Fcall *f)
{
Fid *fidp;
Dir *d;
if((d=dirstat(conffile)) != nil && d->mtime > lastconftime)
getconf();
free(d);
if((d=dirstat(ctlfile)) != nil && d->mtime > lastctltime)
reload();
free(d);
cleantrusted();
fidp = newfid(f->fid);
fidp->busy = 1;
fidp->node = root;
fidp->name = root->d.name;
fidp->uid = atom(f->uname);
f->qid = root->d.qid;
reply(f,0);
}
static void
rclone(Fcall *f)
{
Fid *fidp, *nf;
fidp = newfid(f->fid);
if(fidp->node && fidp->node->d.type == Dummynode){
reply(f, "can't clone an address");
return;
}
nf = newfid(f->newfid);
nf->busy = 1;
nf->node = fidp->node;
nf->uid = fidp->uid;
nf->name = fidp->name;
if(debugfd >= 0)
printfid(nf);
reply(f,0);
}
static void
rwalk(Fcall *f)
{
int i, j;
Fcall r;
Fid *fidp, *nf;
char *err;
fidp = newfid(f->fid);
if(fidp->node && fidp->node->d.type == Dummynode){
reply(f, "can't walk an address node");
return;
}
if(f->fid == f->newfid)
nf = fidp;
else{
nf = newfid(f->newfid);
nf->busy = 1;
nf->node = fidp->node;
nf->uid = fidp->uid;
nf->name = fidp->name;
if(debugfd >= 0)
printfid(nf);
}
err = nil;
for(i=0; i<f->nwname; i++){
err = walk(f->wname[i], nf);
if(err)
break;
r.wqid[i] = nf->node->d.qid;
}
if(i < f->nwname && f->fid != f->newfid){
nf->busy = 0;
nf->node = 0;
nf->name = 0;
nf->uid = 0;
}
if(i > 0 && i < f->nwname && f->fid == f->newfid){
/*
* try to put things back;
* we never get this sort of call from the kernel
*/
for(j=0; j<i; j++)
walk("..", nf);
}
memmove(f->wqid, r.wqid, sizeof f->wqid);
f->nwqid = i;
if(err && i==0)
reply(f, err);
else
reply(f, 0);
}
/*
* We don't have to do full permission checking because most files
* have restricted semantics:
* The ctl file is only writable
* All others, including directories, are only readable
*/
static void
ropen(Fcall *f)
{
Fid *fidp;
int mode;
fidp = newfid(f->fid);
if(debugfd >= 0)
printfid(fidp);
mode = f->mode&(OREAD|OWRITE|ORDWR);
if(fidp->node->d.type == Ctlfile) {
if(mode != OWRITE) {
reply(f, "permission denied");
return;
}
} else
if (mode != OREAD) {
reply(f, "permission denied or operation not supported");
return;
}
f->qid = fidp->node->d.qid;
fidp->open = 1;
reply(f, 0);
}
static int
permitted(Fid *fp, Node *np, int mask)
{
int mode;
mode = np->d.mode;
return (fp->uid==np->d.uid && (mode&(mask<<6)))
|| (fp->uid==np->d.gid && (mode&(mask<<3)))
|| (mode&mask);
}
/*
* creates are only allowed in the "trusted" subdirectory
* we also assume that the groupid == the uid
*/
static void
rcreate(Fcall *f)
{
Fid *fidp;
Node *np;
Cidraddr ip;
fidp = newfid(f->fid);
np = fidp->node;
if((np->d.mode&DMDIR) == 0){
reply(f, "not a directory");
return;
}
if(!permitted(fidp, np, AWRITE)) {
reply(f, "permission denied");
return;
}
if(cidrparse(&ip, f->name) == -1){
reply(f, "bad cidr in filename");
return;
}
/* Ignore the supplied mode and force it to be non-writable */
np = newnode(np, f->name, Trustedtemp, 0444, trustedqid++);
np->ip = ip;
if(trustedqid >= Qaddrfile) /* wrap QIDs */
trustedqid = Qtrustedfile;
f->qid = np->d.qid;
np->d.uid = fidp->uid;
np->d.gid = np->d.uid;
np->d.muid = np->d.muid;
fidp->node = np;
fidp->open = 1;
reply(f, 0);
return;
}
/*
* only directories can be read. everthing else returns EOF.
*/
static void
rread(Fcall *f)
{
long cnt;
Fid *fidp;
cnt = f->count;
f->count = 0;
fidp = newfid(f->fid);
f->data = (char*)rbuf+IOHDRSZ;
if(fidp->open == 0) {
reply(f, "file not open");
return;
}
if ((fidp->node->d.mode&DMDIR) == 0){
reply(f, 0); /*EOF*/
return;
}
if(cnt > MAXRPC)
cnt = MAXRPC;
if(f->offset == 0)
fidp->dirindex = 0;
switch(fidp->node->d.type) {
case Directory:
case Addrdir:
case Trusted:
f->count = dread(fidp, cnt);
break;
case IPaddr:
case Acctaddr:
f->count = hread(fidp, cnt);
break;
default:
reply(f, "can't read this type of file");
return;
}
reply(f, 0);
}
/*
* only the 'ctl' file in the top level directory is writable
*/
static void
rwrite(Fcall *f)
{
Fid *fidp;
int n;
char *err, *argv[10];
fidp = newfid(f->fid);
if(fidp->node->d.mode & DMDIR){
reply(f, "directories are not writable");
return;
}
if(fidp->open == 0) {
reply(f, "file not open");
return;
}
if (!permitted(fidp, fidp->node, AWRITE)) {
reply(f, "permission denied");
return;
}
f->data[f->count] = 0; /* the extra byte in rbuf leaves room */
n = tokenize(f->data, argv, 10);
err = 0;
switch(findkey(argv[0], cmds)){
case RELOAD:
getconf();
reload();
break;
case RDEBUG:
if(n > 1){
debugfd = create(argv[1], OWRITE, 0666);
if(debugfd < 0)
err = "create failed";
} else
debugfd = 2;
break;
case RNODEBUG:
if(debugfd >= 0)
close(debugfd);
debugfd = -1;
break;
default:
err = "unknown command";
break;
}
reply(f, err);
}
static void
rclunk(Fcall *f)
{
Fid *fidp;
fidp = newfid(f->fid);
fidp->open = 0;
fidp->busy = 0;
fidp->node = 0;
fidp->name = 0;
fidp->uid = 0;
reply(f, 0);
}
/*
* no files or directories are removable; this becomes clunk;
*/
static void
rremove(Fcall *f)
{
Fid *fidp;
Node *dir, *np;
fidp = newfid(f->fid);
/*
* only trusted temporary files can be removed
* and only by their owner.
*/
if(fidp->node->d.type != Trustedtemp){
reply(f, "can't be removed");
return;
}
if(fidp->uid != fidp->node->d.uid){
reply(f, "permission denied");
return;
}
dir = fidp->node->parent;
for(np = dir->children; np; np = np->sibs)
if(np->sibs == fidp->node)
break;
if(np)
np->sibs = fidp->node->sibs;
else
dir->children = fidp->node->sibs;
dir->count--;
free(fidp->node);
fidp->node = 0;
fidp->open = 0;
fidp->busy = 0;
fidp->name = 0;
fidp->uid = 0;
reply(f, 0);
}
static void
rstat(Fcall *f)
{
Fid *fidp;
fidp = newfid(f->fid);
if (fidp->node->d.type == Dummynode)
dummy.d.name = fidp->name;
f->stat = (uchar*)rbuf+4+1+2+2; /* knows about stat(5) */
f->nstat = convD2M(&fidp->node->d, f->stat, MAXRPC);
if(f->nstat <= BIT16SZ)
reply(f, "ratfs: convD2M");
else
reply(f, 0);
return;
}
static void
rwstat(Fcall *f)
{
reply(f, "wstat not implemented");
}