#include "ratfs.h"

/*
 *	9P protocol interface
 */

enum {
	RELOAD = 0,		/* commands written to ctl file */
	RDEBUG,
	RNODEBUG,
	RNONE,
};

static void	rflush(Fcall*),		rnop(Fcall*),
		rauth(Fcall*),	rattach(Fcall*),
		rclone(Fcall*),		rwalk(Fcall*),
		rclwalk(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;
	
	for(;;){
		n = read9pmsg(srvfd, rbuf, sizeof rbuf-1);
		if(n <= 0)
			fatal("mount read");
		if(convM2S(rbuf, n, &rhdr) == 0){
			if(debugfd >= 0)
				fprint(2, "%s: malformed message\n", argv0);
			continue;
		}
		
		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)
		sysfatal("convS2M: %r");
	if(write(srvfd, rbuf, n) < 0)
		sysfatal("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;

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

	/* Ignore the supplied mode and force it to be non-writable */

	np = newnode(np, f->name, Trustedtemp, 0444, trustedqid++);
	if(trustedqid >= Qaddrfile)			/* wrap QIDs */
		trustedqid = Qtrustedfile;
	cidrparse(&np->ip, f->name);
	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");
}