#include <lib9.h>
#include <styx.h>
#include "styxserver.h"
#include "styxaux.h"

#define MAXSTAT	512
#define EMSGLEN			256		/* %r */

#define TABSZ	32	/* power of 2 */

static	unsigned long		boottime;
static	char*	eve = "inferno";
static	int		Debug = 0;

char Enomem[] =		"out of memory";
char Eperm[] =			"permission denied";
char Enodev[] =		"no free devices";
char Ehungup[] =		"write to hungup channel";
char	Eexist[] =			"file exists";
char Enonexist[] =		"file does not exist";
char Ebadcmd[] =		"bad command";
char Ebadarg[] =			"bad arg in system call";
char Enofid[] =			"no such fid";
char Enotdir[] =		"not a directory";
char	Eopen[] =			"already open";
char	Ebadfid[] =		"bad fid";

/* client state */
enum{
	CDISC = 01,
	CNREAD = 02,
	CRECV = 04,
};

typedef struct Walkqid Walkqid;

struct Fid
{
	Client 	*client;
	Fid *next;
	short	fid;
	ushort	open;
	ushort	mode;	/* read/write */
	ulong	offset;	/* in file */
	int		dri;		/* dirread index */
	Qid		qid;
};

struct Walkqid
{
	Fid	*clone;
	int	nqid;
	Qid	qid[1];
};

#define ASSERT(A,B) styxassert((int)A,B)

static int hash(Path);
static void deletefids(Client *);

static void
styxfatal(char *fmt, ...)
{
	char buf[1024], *out;
	va_list arg;
	out = seprint(buf, buf+sizeof(buf), "Fatal error: ");
	va_start(arg, fmt);
	out = vseprint(out, buf+sizeof(buf), fmt, arg);
	va_end(arg);
	write(2, buf, out-buf);
	styxexit(1);
}

static void
styxassert(int true, char *reason)
{
	if(!true)
		styxfatal("assertion failed: %s\n", reason);
}

void *
styxmalloc(int bytes)
{
	char *m = malloc(bytes);
	if(m == nil)
		styxfatal(Enomem);
	memset(m, 0, bytes);
	return m;
}

void
styxfree(void *p)
{
	free(p);
}

void
styxdebug()
{
	Debug = 1;
}

static Client *
newclient(Styxserver *server, int fd)
{
	Client *c = (Client *)styxmalloc(sizeof(Client));

	if(Debug)
		fprint(2, "New client at %lux\n", (ulong)c);
	c->server = server;
	c->fd = fd;
	c->nread = 0;
	c->nc = 0;
	c->state = 0;
	c->fids = nil;
	c->uname = strdup(eve);
	c->aname = strdup(eve);
	c->next = server->clients;
	server->clients = c;
	if(server->ops->newclient)
		server->ops->newclient(c);
	return c;
}

static void
freeclient(Client *c)
{
	Client **p;
	Styxserver *server;

	if(Debug)
		fprint(2, "Freeing client at %lux\n", (ulong)c);
	server = c->server;
	if(server->ops->freeclient)
		server->ops->freeclient(c);
	for(p = &server->clients; *p; p = &(*p)->next)
		if(*p == c){
			styxclosesocket(c->fd);
			*p = c->next;
			deletefids(c);
			free(c->uname);
			free(c->aname);
			styxfree(c);
			return;
		}
}

static int
nbread(Client *c, int nr)
{
	int nb;

	if(c->state&CDISC)
		return -1;
	nb = styxrecv(c->server, c->fd, c->msg + c->nread, nr, 0);
	if(nb <= 0){
		c->nread = 0;
		c->state |= CDISC;
		return -1;
	}
	c->nread += nb;
	return 0;
}

static int
rd(Client *c, Fcall *r)
{
	if(c->nc > 0){	/* last convM2S consumed nc bytes */
		c->nread -= c->nc;
		if(c->nread < 0){
			r->ename = "negative size in rd";
			return -1;
		}
		memmove(c->msg, c->msg+c->nc, c->nread);
		c->nc = 0;
	}
	if(c->state&CRECV){
		if(nbread(c, MSGMAX - c->nread) != 0){
			r->ename = "unexpected EOF";
			return -1;
		}
		c->state &= ~CRECV;
	}
	c->nc = convM2S((uchar*)(c->msg), c->nread, r);
	if(c->nc < 0){
		r->ename = "bad message format";
		return -1;
	}
	if(c->nc == 0 && c->nread > 0){
		c->nread = 0;
		c->state &= ~CNREAD;
		return 0;
	}
	if(c->nread > c->nc)
		c->state |= CNREAD;
	else
		c->state &= ~CNREAD;
	if(c->nc == 0)
		return 0;
	/* fprint(2, "rd: %F\n", r); */
	return 1;
}

static int
wr(Client *c, Fcall *r)
{
	int n;
	char buf[MSGMAX];

	n = convS2M(r, (uchar*)buf, sizeof(buf));
	if(n < 0){
		r->ename = "bad message type in wr";
		return -1;
	}
	/* fprint(2, "wr: %F\n", r); */
	return styxsend(c->server, c->fd, buf, n, 0);
}

static void
sremove(Styxserver *server, Styxfile *f)
{
	Styxfile *s, *next, **p;

	if(f == nil)
		return;
	if(Debug)
		fprint(2, "Remove file %s Qid=%llx\n", f->d.name, f->d.qid.path);
	if(f->d.qid.type&QTDIR)
		for(s = f->child; s != nil; s = next){
			next = s->sibling;
			sremove(server, s);
	}
	for(p = &server->ftab[hash(f->d.qid.path)]; *p; p = &(*p)->next)
		if(*p == f){
			*p = f->next;
			break;
		}
	for(p = &f->parent->child; *p; p = &(*p)->sibling)
		if(*p == f){
			*p = f->sibling;
			break;
		}
	styxfree(f->d.name);
	styxfree(f->d.uid);
	styxfree(f->d.gid);
	styxfree(f);
}

int
styxrmfile(Styxserver *server, Path qid)
{
	Styxfile *f;

	f = styxfindfile(server, qid);
	if(f != nil){
		if(f->parent == nil)
			return -1;
		sremove(server, f);
		return 0;
	}
	return -1;
}

static void
incref(Styxfile *f)
{
	if(f != nil)
		f->ref++;
}

static void
decref(Styxfile *f)
{
	if(f != nil)
		--f->ref;
}

static void
increff(Fid *f)
{
	incref(styxfindfile(f->client->server, f->qid.path));
}

static void
decreff(Fid *f)
{
	decref(styxfindfile(f->client->server, f->qid.path));
}

static void
incopen(Fid *f)
{
	Styxfile *file;

	if(f->open && (file = styxfindfile(f->client->server, f->qid.path)) != nil)
		file->open++;
}

static void
decopen(Fid *f)
{
	Styxfile *file;

	if(f->open && (file = styxfindfile(f->client->server, f->qid.path)) != nil)
		file->open--;
}

int
styxperm(Styxfile *f, char *uid, int mode)
{
	int m, p;

	p = 0;
	switch(mode&3){
	case OREAD:	p = AREAD;	break;
	case OWRITE:	p = AWRITE;	break;
	case ORDWR:	p = AREAD+AWRITE;	break;
	case OEXEC:	p = AEXEC;	break;
	}
	if(mode&OTRUNC)
		p |= AWRITE;
	m = f->d.mode&7;
	if((p&m) == p)
		return 1;
	if(strcmp(f->d.uid, uid) == 0){
		m |= (f->d.mode>>6)&7;
		if((p&m) == p)
			return 1;
	}
	if(strcmp(f->d.gid, uid) == 0){
		m |= (f->d.mode>>3)&7;
		if((p&m) == p)
			return 1;
	}
	return 0;
}

static int
hash(Path path)
{
	return path&(TABSZ-1);
}

Styxfile *
styxfindfile(Styxserver *server, Path path)
{
	Styxfile *f;

	for(f = server->ftab[hash(path)]; f != nil; f = f->next){
		if(f->d.qid.path == path)
			return f;
	}
	return nil;
}

static Fid *
findfid(Client *c, short fid)
{
	Fid *f;
	for(f = c->fids; f && f->fid != fid; f = f->next)
		;
	return f;
}

static void
deletefid(Client *c, Fid *d)
{
	/* TODO: end any outstanding reads on this fid */
	Fid **f;

	for(f = &c->fids; *f; f = &(*f)->next)
		if(*f == d){
			decreff(d);
			decopen(d);
			*f = d->next;
			styxfree(d);
			return;
		}
}

static void
deletefids(Client *c)
{
	Fid *f, *g;

	for(f = c->fids; f; f = g){
		decreff(f);
		decopen(f);
		g = f->next;
		styxfree(f);
	}
}

Fid *
newfid(Client *c, short fid, Qid qid){
	Fid *f;

	f = styxmalloc(sizeof(Fid));
	ASSERT(f, "newfid");
	f->client = c;
	f->fid = fid;
	f->open = 0;
	f->dri = 0;
	f->qid = qid;
	f->next = c->fids;
	c->fids = f;
	increff(f);
	return f;
}

static void
flushtag(int oldtag)
{
	USED(oldtag);
}

int
eqqid(Qid a, Qid b)
{
	return a.path == b.path && a.vers == b.vers;
}

static Fid *
fidclone(Fid *old, short fid)
{
	Fid *new;

	new = newfid(old->client, fid, old->qid);
	return new;
}

static Walkqid*
devwalk(Client *c, Styxfile *file, Fid *fp, Fid *nfp, char **name, int nname, char **err)
{
	Styxserver *server;
	long j;
	Walkqid *wq;
	char *n;
	Styxfile *p, *f;
	Styxops *ops;
	Qid qid;

	*err = nil;
	server = c->server;
	ops = server->ops;

	wq = styxmalloc(sizeof(Walkqid)+(nname-1)*sizeof(Qid));
	wq->nqid = 0;

	p = file;
	qid = p != nil ? p->d.qid : fp->qid;
	for(j = 0; j < nname; j++){
		if(!(qid.type&QTDIR)){
			if(j == 0)
				styxfatal("devwalk error");
			*err = Enotdir;
			goto Done;
		}
		if(p != nil && !styxperm(p, c->uname, OEXEC)){
			*err = Eperm;
			goto Done;
		}
		n = name[j];
		if(strcmp(n, ".") == 0){
    Accept:
			wq->qid[wq->nqid++] = nfp->qid;
			continue;
		}
		if(p != nil && strcmp(n, "..") == 0 && p->parent){
			decref(p);
			nfp->qid.path = p->parent->d.qid.path;
			nfp->qid.type = p->parent->d.qid.type;
			nfp->qid.vers = 0;
			incref(p->parent);
			p = p->parent;
			qid = p->d.qid;
			goto Accept;
		}
		
		if(ops->walk != nil){
			char *e;

			e = ops->walk(&qid, n);
			if(e == nil){
				decreff(nfp);
				nfp->qid = qid;
				increff(nfp);
				p = styxfindfile(server, qid.path);
				if(server->needfile && p == nil)
					goto Done;
				qid = p != nil ? p->d.qid : nfp->qid;
				goto Accept;
			}
		}

		if(p != nil)
		for(f = p->child; f != nil; f = f->sibling){
			if(strcmp(n, f->d.name) == 0){
				decref(p);
				nfp->qid.path = f->d.qid.path;
				nfp->qid.type = f->d.qid.type;
				nfp->qid.vers = 0;
				incref(f);
				p = f;
				qid = p->d.qid;
				goto Accept;
			}
		}
		if(j == 0 && *err == nil)
			*err = Enonexist;
		goto Done;
	}
Done:
	if(*err != nil){
		styxfree(wq);
		return nil;
	}
	return wq;
}

static long
devdirread(Fid *fp, Styxfile *file, char *d, long n)
{
	long dsz, m;
	Styxfile *f;
	int i;

	struct{
		Dir d;
		char slop[100];	/* TO DO */
	}dir;

	f = file->child;
	for(i = 0; i < fp->dri; i++)
		if(f == 0)
			return 0;
		else
			f = f->sibling;
	for(m = 0; m < n; fp->dri++){
		if(f == nil)
			break;
		dir.d = f->d;
		dsz = convD2M(&dir.d, (uchar*)d, n-m);
		m += dsz;
		d += dsz;
		f = f->sibling;
	}

	return m;
}

static char*
nilconv(char *s)
{
	if(s != nil && s[0] == '\0')
		return nil;
	return s;
}

static Styxfile *
newfile(Styxserver *server, Styxfile *parent, int isdir, Path qid, char *name, int mode, char *owner)
{
	Styxfile *file;
	Dir d;
	int h;

	if(qid == -1)
		qid = server->qidgen++;
	file = styxfindfile(server, qid);
	if(file != nil)
		return nil;
	if(parent != nil){
		for(file = parent->child; file != nil; file = file->sibling)
			if(strcmp(name, file->d.name) == 0)
				return nil;
	}
	file = (Styxfile *)styxmalloc(sizeof(Styxfile));
	file->parent = parent;
	file->child = nil;
	h = hash(qid);
	file->next = server->ftab[h];
	server->ftab[h] = file;
	if(parent){
		file->sibling = parent->child;
		parent->child = file;
	}else
		file->sibling = nil;

	d.type = 'X';
	d.dev = 'x';
	d.qid.path = qid;
	d.qid.type = 0;
	d.qid.vers = 0;
	d.mode = mode;
	d.atime = time(0);
	d.mtime = boottime;
	d.length = 0;
	d.name = strdup(name);
	d.uid = strdup(owner);
	d.gid = strdup(eve);
	d.muid = "";

	if(isdir){
		d.qid.type |= QTDIR;
		d.mode |= DMDIR;
	}
	else{
		d.qid.type &= ~QTDIR;
		d.mode &= ~DMDIR;
	}

	file->d = d;
	file->ref = 0;
	file->open = 0;
	if(Debug)
		fprint(2, "New file %s Qid=%llx\n", name, qid);
	return file;
}

static void
run(Client *c)
{
	Fcall f;
	Fid *fp, *nfp;
	int i, open, mode;
	char ebuf[EMSGLEN];
	Walkqid *wq;
	Styxfile *file;
	Dir dir;
	Qid qid;
	Styxops *ops;
	char strs[128];

	ebuf[0] = 0;
	if(rd(c, &f) <= 0)
		return;
	if(f.type == Tflush){
		flushtag(f.oldtag);
		f.type = Rflush;
		wr(c, &f);
		return;
	}
	ops = c->server->ops;
	file = nil;
	fp = findfid(c, f.fid);
	if(f.type != Tversion && f.type != Tauth && f.type != Tattach){
		if(fp == nil){
			f.type = Rerror;
			f.ename = Enofid;
			wr(c, &f);
			return;
		}
		else{
			file = styxfindfile(c->server, fp->qid.path);
			if(c->server->needfile && file == nil){
				f.type = Rerror;
				f.ename = Enonexist;
				wr(c, &f);
				return;
			}
		}
	}
	/* if(fp == nil) fprint(2, "fid not found for %d\n", f.fid); */
	switch(f.type){
	case	Twalk:
		if(Debug){
			fprint(2, "Twalk %d %d", f.fid, f.newfid);
			for(i = 0; i < f.nwname; i++)
				fprint(2, " %s", f.wname[i]);
			fprint(2, "\n");
		}
		nfp = findfid(c, f.newfid);
		f.type = Rerror;
		if(nfp){
			deletefid(c, nfp);
			nfp = nil;
		}
		if(nfp){
			f.ename = "fid in use";
			if(Debug) fprint(2, "walk: %s\n", f.ename);
			wr(c, &f);
			break;
		}else if(fp->open){
			f.ename = "can't clone";
			wr(c, &f);
			break;
		}
		if(f.newfid != f.fid)
			nfp = fidclone(fp, f.newfid);
		else
			nfp = fp;
		if((wq = devwalk(c, file, fp, nfp, f.wname, f.nwname, &f.ename)) == nil){
			if(nfp != fp)
				deletefid(c, nfp);
			f.type = Rerror;
		}else{
			if(nfp != fp){
				if(wq->nqid != f.nwname)
					deletefid(c, nfp);
			}
			f.type = Rwalk;
			f.nwqid = wq->nqid;
			for(i = 0; i < wq->nqid; i++)
				f.wqid[i] = wq->qid[i];
			styxfree(wq);
		}
		wr(c, &f);
		break;
	case	Topen:
		if(Debug)
			fprint(2, "Topen %d\n", f.fid);
		f.ename = nil;
		if(fp->open)
			f.ename = Eopen;
		else if((fp->qid.type&QTDIR) && (f.mode&(OWRITE|OTRUNC|ORCLOSE)))
			f.ename = Eperm;
		else if(file != nil && !styxperm(file, c->uname, f.mode))
			f.ename = Eperm;
		else if((f.mode&ORCLOSE) && file != nil && file->parent != nil && !styxperm(file->parent, c->uname, OWRITE))
			f.ename = Eperm;
		if(f.ename != nil){
			f.type = Rerror;
			wr(c, &f);
			break;
		}
		f.ename = Enonexist;
		decreff(fp);
		if(ops->open == nil || (f.ename = ops->open(&fp->qid, f.mode)) == nil){
			f.type = Ropen;
			f.qid = fp->qid;
			fp->mode = f.mode;
			fp->open = 1;
			fp->offset = 0;
			incopen(fp);
		}
		else
			f.type = Rerror;
		increff(fp);
		wr(c, &f);
		break;
	case	Tcreate:
		if(Debug)
			fprint(2, "Tcreate %d %s\n", f.fid, f.name);
		f.ename = nil;
		if(fp->open)
			f.ename = Eopen;
		else if(!(fp->qid.type&QTDIR))
			f.ename = Enotdir;
		else if((f.perm&DMDIR) && (f.mode&(OWRITE|OTRUNC|ORCLOSE)))
			f.ename = Eperm;
		else if(file != nil && !styxperm(file, c->uname, OWRITE))
			f.ename = Eperm;
		if(f.ename != nil){
			f.type = Rerror;
			wr(c, &f);
			break;
		}
		f.ename = Eperm;
		decreff(fp);
		if(file != nil){
			if(f.perm&DMDIR)
				f.perm = (f.perm&~0777) | (file->d.mode&f.perm&0777) | DMDIR;
			else
				f.perm = (f.perm&(~0777|0111)) | (file->d.mode&f.perm&0666);
		}
		if(ops->create && (f.ename = ops->create(&fp->qid, f.name, f.perm, f.mode)) == nil){
			f.type = Rcreate;
			f.qid = fp->qid;
			fp->mode = f.mode;
			fp->open = 1;
			fp->offset = 0;
			incopen(fp);
		}
		else
			f.type = Rerror;
		increff(fp);
		wr(c, &f);
		break;
	case	Tread:
		if(Debug)
			fprint(2, "Tread %d\n", f.fid);
		if(!fp->open){
			f.type = Rerror;
			f.ename = Ebadfid;
			wr(c, &f);
			break;
		}
		if(fp->qid.type&QTDIR || (file != nil && file->d.qid.type&QTDIR)){
			f.type = Rread;
			if(file == nil){
				f.ename = Eperm;
				if(ops->read && (f.ename = ops->read(fp->qid, c->data, (ulong*)(&f.count), fp->dri)) == nil){
					f.data = c->data;
				}
				else
					f.type = Rerror;
			}
			else{
				f.count = devdirread(fp, file, c->data, f.count);
				f.data = c->data;
			}		
		}else{
			f.ename = Eperm;
			f.type = Rerror;
			if(ops->read && (f.ename = ops->read(fp->qid, c->data, (ulong*)(&f.count), f.offset)) == nil){
				f.type = Rread;
				f.data = c->data;			
			}
		}
		wr(c, &f);
		break;
	case	Twrite:
		if(Debug)
			fprint(2, "Twrite %d\n", f.fid);
		if(!fp->open){
			f.type = Rerror;
			f.ename = Ebadfid;
			wr(c, &f);
			break;
		}
		f.ename = Eperm;
		f.type = Rerror;
		if(ops->write && (f.ename = ops->write(fp->qid, f.data, (ulong*)(&f.count), f.offset)) == nil){
			f.type = Rwrite;
		}
		wr(c, &f);
		break;
	case	Tclunk:
		if(Debug)
			fprint(2, "Tclunk %d\n", f.fid);
		open = fp->open;
		mode = fp->mode;
		qid = fp->qid;
		deletefid(c, fp);
		f.type = Rclunk;
		if(open && ops->close && (f.ename = ops->close(qid, mode)) != nil)
			f.type = Rerror;
		wr(c, &f);
		break;
	case	Tremove:
		if(Debug)
			fprint(2, "Tremove %d\n", f.fid);
		if(file != nil && file->parent != nil && !styxperm(file->parent, c->uname, OWRITE)){
			f.type = Rerror;
			f.ename = Eperm;
			deletefid(c, fp);
			wr(c, &f);
			break;
		}
		f.ename = Eperm;
		if(ops->remove && (f.ename = ops->remove(fp->qid)) == nil) 
			f.type = Rremove;
		else
			f.type = Rerror;
		deletefid(c, fp);
		wr(c, &f);
		break;
	case	Tstat:
		if(Debug)
			fprint(2, "Tstat %d qid=%llx\n", f.fid, fp->qid.path);
		f.stat = styxmalloc(MAXSTAT);
		f.ename = "stat error";
		if(ops->stat == nil && file != nil){
			f.type = Rstat;
			f.nstat = convD2M(&file->d, f.stat, MAXSTAT);
		}
		else if(ops->stat && (f.ename = ops->stat(fp->qid, &dir)) == nil){
			f.type = Rstat;
			f.nstat = convD2M(&dir, f.stat, MAXSTAT);
		}
		else
			f.type = Rerror;
		wr(c, &f);
		styxfree(f.stat);
		break;
	case	Twstat:
		if(Debug)
			fprint(2, "Twstat %d\n", f.fid);
		f.ename = Eperm;
		convM2D(f.stat, f.nstat, &dir, strs);
		dir.name = nilconv(dir.name);
		dir.uid = nilconv(dir.uid);
		dir.gid = nilconv(dir.gid);
		dir.muid = nilconv(dir.muid);
		if(ops->wstat && (f.ename = ops->wstat(fp->qid, &dir)) == nil)
			f.type = Rwstat;
		else
			f.type = Rerror;
		wr(c, &f);
		break;
	case	Tversion:
		if(Debug)
			fprint(2, "Tversion\n");
		f.type = Rversion;
		f.tag = NOTAG;
		wr(c, &f);
		break;
	case Tauth:
		if(Debug)
			fprint(2, "Tauth\n");
		f.type = Rauth;
		wr(c, &f);
		break;
	case	Tattach:
		if(Debug)
			fprint(2, "Tattach %d %s\n", f.fid, f.uname[0] ? f.uname : c->uname);
		if(fp){
			f.type = Rerror;
			f.ename = "fid in use";
		}else{
			Qid q;

			if(f.uname[0]){
				free(c->uname);
				c->uname = strdup(f.uname);
			}
			if(f.aname[0]){
				free(c->aname);
				c->aname = strdup(f.aname);
			}
			q.path = Qroot;
			q.type = QTDIR;
			q.vers = 0;
			fp = newfid(c, f.fid, q);
			f.type = Rattach;
			f.fid = fp->fid;
			f.qid = q;
			if(ops->attach && (f.ename = ops->attach(c->uname, c->aname)) != nil)
				f.type = Rerror;
		}
		wr(c, &f);
		break;
	}
}

char *
styxinit(Styxserver *server, Styxops *ops, char *port, int perm, int needfile)
{
	int i;

	if(Debug)
		fprint(2, "Initialising Styx server on port %s\n", port);
	if(perm == -1)
		perm = 0555;
	server->ops = ops;
	server->clients = nil;
	server->root = nil;
	server->ftab = (Styxfile**)malloc(TABSZ*sizeof(Styxfile*));
	for(i = 0; i < TABSZ; i++)
		server->ftab[i] = nil;
	server->qidgen = Qroot+1;
	if(styxinitsocket() < 0)
		return "styxinitsocket failed";
	server->connfd = styxannounce(server, port);
	if(server->connfd < 0)
		return "can't announce on network port";
	styxinitwait(server);
	server->root = newfile(server, nil, 1, Qroot, "/", perm|DMDIR, eve);
	server->needfile = needfile;
	return nil;
}

char*
styxend(Styxserver *server)
{
	USED(server);
	styxendsocket();
	return nil;
}

char *
styxwait(Styxserver *server)
{
	return styxwaitmsg(server);
}

char *
styxprocess(Styxserver *server)
{
	Client *c;
	int s;

	if(styxnewcall(server)){
		s = styxaccept(server);
		if(s >= 0){
			newclient(server, s);
			styxnewclient(server, s);
		}
	}
	for(c = server->clients; c != nil; ){
		Client *next = c->next;

		server->curc = c;
		if(c->fd >= 0 && styxnewmsg(server, c->fd))
			c->state |= CRECV;
		if(c->state&(CNREAD|CRECV)){
			if(c->state&CDISC){
				styxfreeclient(server, c->fd);
				freeclient(c);
			}else
				do
					run(c);
				while(c->state&CNREAD);
		}
		c = next;
	}
	
	return nil;
}

Client*
styxclient(Styxserver *server)
{
	return server->curc;
}

Styxfile*
styxaddfile(Styxserver *server, Path pqid, Path qid, char *name, int mode, char *owner)
{
	Styxfile *f, *parent;

	parent = styxfindfile(server, pqid);
	if(parent == nil || (parent->d.qid.type&QTDIR) == 0)
		return nil;
	f = newfile(server, parent, 0, qid, name, mode, owner);
	return f;
}

Styxfile*
styxadddir(Styxserver *server, Path pqid, Path qid, char *name, int mode, char *owner)
{
	Styxfile *f, *parent;

	parent = styxfindfile(server, pqid);
	if(parent == nil || (parent->d.qid.type&QTDIR) == 0)
		return nil;
	f = newfile(server, parent, 1, qid, name, mode|DMDIR, owner);
	return f;
}

long
styxreadstr(ulong off, char *buf, ulong n, char *str)
{
	int size;

	size = strlen(str);
	if(off >= size)
		return 0;
	if(off+n > size)
		n = size-off;
	memmove(buf, str+off, n);
	return n;
}

Qid
styxqid(int path, int isdir)
{
	Qid q;

	q.path = path;
	q.vers = 0;
	if(isdir)
		q.type = QTDIR;
	else
		q.type = 0;
	return q;
}