#include	"u.h"#include	"../port/lib.h"#include	"mem.h"#include	"dat.h"#include	"fns.h"#include	"../port/error.h"  typedef struct Srv Srv;struct Srv{	char	*name;	char	*owner;	ulong	perm;	Chan	*chan;	Srv	*link;	ulong	path;}; static QLock	srvlk;static Srv	*srv;static int	qidpath; static Srv*srvlookup(char *name, ulong qidpath){	Srv *sp; 	for(sp = srv; sp != nil; sp = sp->link) {		if(sp->path == qidpath || (name != nil && strcmp(sp->name, name) == 0))			return sp;	}	return nil;} static intsrvgen(Chan *c, char *name, Dirtab*, int, int s, Dir *dp){	Srv *sp;	Qid q; 	if(s == DEVDOTDOT){		devdir(c, c->qid, "#s", 0, eve, 0555, dp);		return 1;	} 	qlock(&srvlk);	if(name != nil)		sp = srvlookup(name, -1);	else {		for(sp = srv; sp != nil && s > 0; sp = sp->link)			s--;	}	if(sp == nil || (name != nil && (strlen(sp->name) >= sizeof(up->genbuf)))) {		qunlock(&srvlk);		return -1;	}	mkqid(&q, sp->path, 0, QTFILE);	/* make sure name string continues to exist after we release lock */	kstrcpy(up->genbuf, sp->name, sizeof up->genbuf);	devdir(c, q, up->genbuf, 0, sp->owner, sp->perm, dp);	qunlock(&srvlk);	return 1;} static voidsrvinit(void){	qidpath = 1;} static Chan*srvattach(char *spec){	return devattach('s', spec);} static Walkqid*srvwalk(Chan *c, Chan *nc, char **name, int nname){	return devwalk(c, nc, name, nname, 0, 0, srvgen);} static intsrvstat(Chan *c, uchar *db, int n){	return devstat(c, db, n, 0, 0, srvgen);} char*srvname(Chan *c){	Srv *sp;	char *s; 	s = nil;	qlock(&srvlk);	for(sp = srv; sp != nil; sp = sp->link) {		if(sp->chan == c){			s = malloc(3+strlen(sp->name)+1);			if(s != nil)				sprint(s, "#s/%s", sp->name);			break;		}	}	qunlock(&srvlk);	return s;} static Chan*srvopen(Chan *c, int omode){	Srv *sp;	Chan *nc; 	if(c->qid.type == QTDIR){		if(omode & ORCLOSE)			error(Eperm);		if(omode != OREAD)			error(Eisdir);		c->mode = omode;		c->flag |= COPEN;		c->offset = 0;		return c;	}	qlock(&srvlk);	if(waserror()){		qunlock(&srvlk);		nexterror();	} 	sp = srvlookup(nil, c->qid.path);	if(sp == nil || sp->chan == nil)		error(Eshutdown); 	if(omode&OTRUNC)		error(Eexist);	if(openmode(omode)!=sp->chan->mode && sp->chan->mode!=ORDWR)		error(Eperm);	devpermcheck(sp->owner, sp->perm, omode); 	nc = sp->chan;	incref(nc); 	qunlock(&srvlk);	poperror(); 	cclose(c);	return nc;} static Chan*srvcreate(Chan *c, char *name, int omode, ulong perm){	Srv *sp; 	if(openmode(omode) != OWRITE)		error(Eperm); 	if(strlen(name) >= sizeof(up->genbuf))		error(Etoolong); 	sp = smalloc(sizeof *sp);	kstrdup(&sp->name, name);	kstrdup(&sp->owner, up->user); 	qlock(&srvlk);	if(waserror()){		qunlock(&srvlk);		free(sp->owner);		free(sp->name);		free(sp);		nexterror();	}	if(srvlookup(name, -1) != nil)		error(Eexist); 	sp->perm = perm&0777;	sp->path = qidpath++; 	c->qid.path = sp->path;	c->qid.type = QTFILE; 	sp->link = srv;	srv = sp; 	qunlock(&srvlk);	poperror(); 	c->flag |= COPEN;	c->mode = OWRITE; 	return c;} static voidsrvremove(Chan *c){	Srv *sp, **l; 	if(c->qid.type == QTDIR)		error(Eperm); 	qlock(&srvlk);	if(waserror()){		qunlock(&srvlk);		nexterror();	}	l = &srv;	for(sp = *l; sp != nil; sp = *l) {		if(sp->path == c->qid.path)			break;		l = &sp->link;	}	if(sp == nil)		error(Enonexist); 	/*	 * Only eve can remove system services.	 */	if(strcmp(sp->owner, eve) == 0 && !iseve())		error(Eperm); 	/*	 * No removing personal services.	 */	if((sp->perm&7) != 7 && strcmp(sp->owner, up->user) && !iseve())		error(Eperm); 	*l = sp->link;	sp->link = nil; 	qunlock(&srvlk);	poperror(); 	if(sp->chan != nil)		cclose(sp->chan);	free(sp->owner);	free(sp->name);	free(sp);} static intsrvwstat(Chan *c, uchar *dp, int n){	char *strs;	Srv *sp;	Dir d; 	if(c->qid.type & QTDIR)		error(Eperm); 	strs = smalloc(n);	if(waserror()){		free(strs);		nexterror();	}	n = convM2D(dp, n, &d, strs);	if(n == 0)		error(Eshortstat); 	qlock(&srvlk);	if(waserror()){		qunlock(&srvlk);		nexterror();	} 	sp = srvlookup(nil, c->qid.path);	if(sp == nil)		error(Enonexist); 	if(strcmp(sp->owner, up->user) != 0 && !iseve())		error(Eperm); 	if(d.name != nil && *d.name && strcmp(sp->name, d.name) != 0) {		if(strchr(d.name, '/') != nil)			error(Ebadchar);		if(strlen(d.name) >= sizeof(up->genbuf))			error(Etoolong);		kstrdup(&sp->name, d.name);	}	if(d.uid != nil && *d.uid)		kstrdup(&sp->owner, d.uid);	if(d.mode != ~0UL)		sp->perm = d.mode & 0777; 	qunlock(&srvlk);	poperror(); 	free(strs);	poperror(); 	return n;} static voidsrvclose(Chan *c){	/*	 * in theory we need to override any changes in removability	 * since open, but since all that's checked is the owner,	 * which is immutable, all is well.	 */	if(c->flag & CRCLOSE){		if(waserror())			return;		srvremove(c);		poperror();	}} static longsrvread(Chan *c, void *va, long n, vlong){	isdir(c);	return devdirread(c, va, n, 0, 0, srvgen);} static longsrvwrite(Chan *c, void *va, long n, vlong){	Srv *sp;	Chan *c1;	int fd;	char buf[32]; 	if(n >= sizeof buf)		error(Etoobig);	memmove(buf, va, n);	/* so we can NUL-terminate */	buf[n] = 0;	fd = strtoul(buf, 0, 0); 	c1 = fdtochan(fd, -1, 0, 1);	/* error check and inc ref */ 	qlock(&srvlk);	if(waserror()) {		qunlock(&srvlk);		cclose(c1);		nexterror();	}	if(c1->flag & (CCEXEC|CRCLOSE))		error("posted fd has remove-on-close or close-on-exec");	if(c1->qid.type & QTAUTH)		error("cannot post auth file in srv");	sp = srvlookup(nil, c->qid.path);	if(sp == nil)		error(Enonexist); 	if(sp->chan != nil)		error(Ebadusefd); 	sp->chan = c1; 	qunlock(&srvlk);	poperror();	return n;} Dev srvdevtab = {	's',	"srv", 	devreset,	srvinit,		devshutdown,	srvattach,	srvwalk,	srvstat,	srvopen,	srvcreate,	srvclose,	srvread,	devbread,	srvwrite,	devbwrite,	srvremove,	srvwstat,}; voidsrvrenameuser(char *old, char *new){	Srv *sp; 	qlock(&srvlk);	for(sp = srv; sp != nil; sp = sp->link) {		if(sp->owner != nil && strcmp(old, sp->owner) == 0)			kstrdup(&sp->owner, new);	}	qunlock(&srvlk);}