harvey/sys/src/cmd/nfs.c

/* Copyright © 2003 Russ Cox, MIT; see /sys/src/libsunrpc/COPYING */
#include <u.h>
#include <libc.h>
#include <bio.h>
#include <fcall.h>
#include <thread.h>
#include <9p.h>
#include <sunrpc.h>
#include <nfs3.h>

SunClient *nfscli;
SunClient *mntcli;
char *defaultpath = "/";
Channel *fschan;
char *sys;
int verbose;
int readplus = 0;


typedef struct Auth Auth;
struct Auth
{
	int ref;
	uchar *data;
	int ndata;
};

typedef struct FidAux FidAux;
struct FidAux
{
	Nfs3Handle handle;

	u64int cookie;	/* for continuing directory reads */
	char *name;	/* botch: for remove and rename */
	Nfs3Handle parent;	/* botch: for remove and rename */
	char err[ERRMAX];	/* for walk1 */
	Auth *auth;
};

/*
 * various RPCs.  here is where we'd insert support for NFS v2
 */

void
portCall(SunCall *c, PortCallType type)
{
	c->rpc.prog = PortProgram;
	c->rpc.vers = PortVersion;
	c->rpc.proc = type>>1;
	c->rpc.iscall = !(type&1);
	c->type = type;
}

int
getport(SunClient *client, uint prog, uint vers, uint prot, uint *port)
{
	PortTGetport tx;
	PortRGetport rx;

	memset(&tx, 0, sizeof tx);
	portCall(&tx.call, PortCallTGetport);
	tx.map.prog = prog;
	tx.map.vers = vers;
	tx.map.prot = prot;

	memset(&rx, 0, sizeof rx);
	portCall(&rx.call, PortCallRGetport);

	if(sunClientRpc(client, 0, &tx.call, &rx.call, nil) < 0)
		return -1;
	*port = rx.port;
	return 0;
}

void
mountCall(Auth *a, SunCall *c, NfsMount3CallType type)
{
	c->rpc.iscall = !(type&1);
	c->rpc.proc = type>>1;
	c->rpc.prog = NfsMount3Program;
	c->rpc.vers = NfsMount3Version;
	if(c->rpc.iscall && a){
		c->rpc.cred.flavor = SunAuthSys;
		c->rpc.cred.data = a->data;
		c->rpc.cred.ndata = a->ndata;
	}
	c->type = type;
}

int
mountNull(ulong tag)
{
	NfsMount3TNull tx;
	NfsMount3RNull rx;

	memset(&tx, 0, sizeof tx);
	mountCall(nil, &tx.call, NfsMount3CallTNull);

	memset(&rx, 0, sizeof rx);
	mountCall(nil, &rx.call, NfsMount3CallTNull);

	return sunClientRpc(mntcli, tag, &tx.call, &rx.call, nil);
}

int
mountMnt(Auth *a, ulong tag, char *path, Nfs3Handle *h)
{
	uchar *freeme;
	NfsMount3TMnt tx;
	NfsMount3RMnt rx;

	memset(&tx, 0, sizeof tx);
	mountCall(a, &tx.call, NfsMount3CallTMnt);
	tx.path = path;

	memset(&rx, 0, sizeof rx);
	mountCall(a, &rx.call, NfsMount3CallRMnt);
	if(sunClientRpc(mntcli, tag, &tx.call, &rx.call, &freeme) < 0)
		return -1;
	if(rx.status != Nfs3Ok){
		nfs3Errstr(rx.status);
		return -1;
	}
if(verbose)print("handle %.*H\n", rx.len, rx.handle);
	if(rx.len >= Nfs3MaxHandleSize){
		free(freeme);
		werrstr("server-returned handle too long");
		return -1;
	}
	memmove(h->h, rx.handle, rx.len);
	h->len = rx.len;
	free(freeme);
	return 0;
}

void
nfs3Call(Auth *a, SunCall *c, Nfs3CallType type)
{
	c->rpc.iscall = !(type&1);
	c->rpc.proc = type>>1;
	c->rpc.prog = Nfs3Program;
	c->rpc.vers = Nfs3Version;
	if(c->rpc.iscall && a){
		c->rpc.cred.flavor = SunAuthSys;
		c->rpc.cred.data = a->data;
		c->rpc.cred.ndata = a->ndata;
	}
	c->type = type;
}

int
nfsNull(ulong tag)
{
	Nfs3TNull tx;
	Nfs3RNull rx;

	memset(&tx, 0, sizeof tx);
	nfs3Call(nil, &tx.call, Nfs3CallTNull);

	memset(&rx, 0, sizeof rx);
	nfs3Call(nil, &rx.call, Nfs3CallTNull);

	return sunClientRpc(nfscli, tag, &tx.call, &rx.call, nil);
}

int
nfsGetattr(Auth *a, ulong tag, Nfs3Handle *h, Nfs3Attr *attr)
{
	Nfs3TGetattr tx;
	Nfs3RGetattr rx;

	memset(&tx, 0, sizeof tx);
	nfs3Call(a, &tx.call, Nfs3CallTGetattr);
	tx.handle = *h;	

	memset(&rx, 0, sizeof rx);
	nfs3Call(a, &rx.call, Nfs3CallRGetattr);

	if(sunClientRpc(nfscli, tag, &tx.call, &rx.call, nil) < 0)
		return -1;
	if(rx.status != Nfs3Ok){
		nfs3Errstr(rx.status);
		return -1;
	}

	*attr = rx.attr;
	return 0;
}

int
nfsAccess(Auth *a, ulong tag, Nfs3Handle *h, ulong want, ulong *got, u1int *have, Nfs3Attr *attr)
{
	Nfs3TAccess tx;
	Nfs3RAccess rx;

	memset(&tx, 0, sizeof tx);
	nfs3Call(a, &tx.call, Nfs3CallTAccess);
	tx.handle = *h;
	tx.access = want;

	memset(&rx, 0, sizeof rx);
	nfs3Call(a, &rx.call, Nfs3CallRAccess);

	if(sunClientRpc(nfscli, tag, &tx.call, &rx.call, nil) < 0)
		return -1;
	if(rx.status != Nfs3Ok){
		nfs3Errstr(rx.status);
		return -1;
	}

	*got = rx.access;

	*have = rx.haveAttr;
	if(rx.haveAttr)
		*attr = rx.attr;
	return 0;
}

int
nfsMkdir(Auth *a, ulong tag, Nfs3Handle *h, char *name, Nfs3Handle *nh, ulong mode, uint gid,
	u1int *have, Nfs3Attr *attr)
{
	Nfs3TMkdir tx;
	Nfs3RMkdir rx;

	memset(&tx, 0, sizeof tx);
	nfs3Call(a, &tx.call, Nfs3CallTMkdir);
	tx.handle = *h;
	tx.name = name;
	tx.attr.setMode = 1;
	tx.attr.mode = mode;
	tx.attr.setGid = 1;
	tx.attr.gid = gid;

	memset(&rx, 0, sizeof rx);
	nfs3Call(a, &rx.call, Nfs3CallRMkdir);

	if(sunClientRpc(nfscli, tag, &tx.call, &rx.call, nil) < 0)
		return -1;
	if(rx.status != Nfs3Ok){
		nfs3Errstr(rx.status);
		return -1;
	}

	if(!rx.haveHandle){
		werrstr("nfs mkdir did not return handle");
		return -1;
	}
	*nh = rx.handle;

	*have = rx.haveAttr;
	if(rx.haveAttr)
		*attr = rx.attr;
	return 0;
}

int
nfsCreate(Auth *a, ulong tag, Nfs3Handle *h, char *name, Nfs3Handle *nh, ulong mode, uint gid,
	u1int *have, Nfs3Attr *attr)
{
	Nfs3TCreate tx;
	Nfs3RCreate rx;

	memset(&tx, 0, sizeof tx);
	nfs3Call(a, &tx.call, Nfs3CallTCreate);
	tx.handle = *h;
	tx.name = name;
	tx.attr.setMode = 1;
	tx.attr.mode = mode;
	tx.attr.setGid = 1;
	tx.attr.gid = gid;

	memset(&rx, 0, sizeof rx);
	nfs3Call(a, &rx.call, Nfs3CallRCreate);

	if(sunClientRpc(nfscli, tag, &tx.call, &rx.call, nil) < 0)
		return -1;
	if(rx.status != Nfs3Ok){
		nfs3Errstr(rx.status);
		return -1;
	}

	if(!rx.haveHandle){
		werrstr("nfs create did not return handle");
		return -1;
	}
	*nh = rx.handle;

	*have = rx.haveAttr;
	if(rx.haveAttr)
		*attr = rx.attr;
	return 0;
}

int
nfsRead(Auth *a, ulong tag, Nfs3Handle *h, u32int count, u64int offset,
	uchar **pp, u32int *pcount, uchar **pfreeme)
{
	uchar *freeme;
	Nfs3TRead tx;
	Nfs3RRead rx;

	memset(&tx, 0, sizeof tx);
	nfs3Call(a, &tx.call, Nfs3CallTRead);
	tx.handle = *h;
	tx.count = count;
	tx.offset = offset;

	memset(&rx, 0, sizeof rx);
	nfs3Call(a, &rx.call, Nfs3CallRRead);

	if(sunClientRpc(nfscli, tag, &tx.call, &rx.call, &freeme) < 0)
		return -1;
	if(rx.status != Nfs3Ok){
		nfs3Errstr(rx.status);
		return -1;
	}
	if(rx.count != rx.ndata){
		werrstr("nfs read returned count=%ud ndata=%ud", (uint)rx.count, (uint)rx.ndata);
		free(freeme);
		return -1;
	}
	*pfreeme = freeme;
	*pcount = rx.count;
	*pp = rx.data;
	return 0;
}

int
nfsWrite(Auth *a, ulong tag, Nfs3Handle *h, uchar *data, u32int count, u64int offset, u32int *pcount)
{
	Nfs3TWrite tx;
	Nfs3RWrite rx;

	memset(&tx, 0, sizeof tx);
	nfs3Call(a, &tx.call, Nfs3CallTWrite);
	tx.handle = *h;
	tx.count = count;
	tx.offset = offset;
	tx.data = data;

	memset(&rx, 0, sizeof rx);
	nfs3Call(a, &rx.call, Nfs3CallRWrite);

	if(sunClientRpc(nfscli, tag, &tx.call, &rx.call, nil) < 0)
		return -1;
	if(rx.status != Nfs3Ok){
		nfs3Errstr(rx.status);
		return -1;
	}

	*pcount = rx.count;
	return 0;
}

int
nfsRmdir(Auth *a, ulong tag, Nfs3Handle *h, char *name)
{
	Nfs3TRmdir tx;
	Nfs3RRmdir rx;

	memset(&tx, 0, sizeof tx);
	nfs3Call(a, &tx.call, Nfs3CallTRmdir);
	tx.handle = *h;
	tx.name = name;

	memset(&rx, 0, sizeof rx);
	nfs3Call(a, &rx.call, Nfs3CallRRmdir);

	if(sunClientRpc(nfscli, tag, &tx.call, &rx.call, nil) < 0)
		return -1;
	if(rx.status != Nfs3Ok){
		nfs3Errstr(rx.status);
		return -1;
	}
	return 0;
}

int
nfsRemove(Auth *a, ulong tag, Nfs3Handle *h, char *name)
{
	Nfs3TRemove tx;
	Nfs3RRemove rx;

	memset(&tx, 0, sizeof tx);
	nfs3Call(a, &tx.call, Nfs3CallTRemove);
	tx.handle = *h;
	tx.name = name;

	memset(&rx, 0, sizeof rx);
	nfs3Call(a, &rx.call, Nfs3CallRRemove);

	if(sunClientRpc(nfscli, tag, &tx.call, &rx.call, nil) < 0)
		return -1;
	if(rx.status != Nfs3Ok){
		nfs3Errstr(rx.status);
		return -1;
	}
	return 0;
}

int
nfsRename(Auth *a, ulong tag, Nfs3Handle *h, char *name, Nfs3Handle *th, char *tname)
{
	Nfs3TRename tx;
	Nfs3RRename rx;

	memset(&tx, 0, sizeof tx);
	nfs3Call(a, &tx.call, Nfs3CallTRename);
	tx.from.handle = *h;
	tx.from.name = name;
	tx.to.handle = *th;
	tx.to.name = tname;

	memset(&rx, 0, sizeof rx);
	nfs3Call(a, &rx.call, Nfs3CallRRename);

	if(sunClientRpc(nfscli, tag, &tx.call, &rx.call, nil) < 0)
		return -1;
	if(rx.status != Nfs3Ok){
		nfs3Errstr(rx.status);
		return -1;
	}
	return 0;
}

int
nfsSetattr(Auth *a, ulong tag, Nfs3Handle *h, Nfs3SetAttr *attr)
{
	Nfs3TSetattr tx;
	Nfs3RSetattr rx;

	memset(&tx, 0, sizeof tx);
	nfs3Call(a, &tx.call, Nfs3CallTSetattr);
	tx.handle = *h;
	tx.attr = *attr;

	memset(&rx, 0, sizeof rx);
	nfs3Call(a, &rx.call, Nfs3CallRSetattr);

	if(sunClientRpc(nfscli, tag, &tx.call, &rx.call, nil) < 0)
		return -1;
	if(rx.status != Nfs3Ok){
		nfs3Errstr(rx.status);
		return -1;
	}
	return 0;
}

int
nfsCommit(Auth *a, ulong tag, Nfs3Handle *h)
{
	Nfs3TCommit tx;
	Nfs3RCommit rx;

	memset(&tx, 0, sizeof tx);
	nfs3Call(a, &tx.call, Nfs3CallTCommit);
	tx.handle = *h;

	memset(&rx, 0, sizeof rx);
	nfs3Call(a, &rx.call, Nfs3CallRCommit);

	if(sunClientRpc(nfscli, tag, &tx.call, &rx.call, nil) < 0)
		return -1;

	if(rx.status != Nfs3Ok){
		nfs3Errstr(rx.status);
		return -1;
	}
	return 0;
}

int
nfsLookup(Auth *a, ulong tag, Nfs3Handle *h, char *name, Nfs3Handle *nh, u1int *have, Nfs3Attr *attr)
{
	Nfs3TLookup tx;
	Nfs3RLookup rx;

	memset(&tx, 0, sizeof tx);
	nfs3Call(a, &tx.call, Nfs3CallTLookup);
	tx.handle = *h;
	tx.name = name;

	memset(&rx, 0, sizeof rx);
	nfs3Call(a, &rx.call, Nfs3CallRLookup);

	if(sunClientRpc(nfscli, tag, &tx.call, &rx.call, nil) < 0)
		return -1;

	if(rx.status != Nfs3Ok){
		nfs3Errstr(rx.status);
		return -1;
	}
	*nh = rx.handle;
	*have = rx.haveAttr;
	if(rx.haveAttr)
		*attr = rx.attr;
	return 0;
}

int
nfsReadDirPlus(Auth *a, ulong tag, Nfs3Handle *h, u32int count, u64int cookie, uchar **pp,
	u32int *pcount, int (**unpack)(uchar*, uchar*, uchar**, Nfs3Entry*), uchar **pfreeme)
{
	Nfs3TReadDirPlus tx;
	Nfs3RReadDirPlus rx;

	memset(&tx, 0, sizeof tx);
	nfs3Call(a, &tx.call, Nfs3CallTReadDirPlus);
	tx.handle = *h;
	tx.maxCount = count;
	tx.dirCount = 1000;
	tx.cookie = cookie;

	memset(&rx, 0, sizeof rx);
	nfs3Call(a, &rx.call, Nfs3CallRReadDirPlus);

	if(sunClientRpc(nfscli, tag, &tx.call, &rx.call, pfreeme) < 0)
		return -1;
	if(rx.status != Nfs3Ok){
		free(*pfreeme);
		*pfreeme = 0;
		nfs3Errstr(rx.status);
		return -1;
	}

	*unpack = nfs3EntryPlusUnpack;
	*pcount = rx.count;
	*pp = rx.data;
	return 0;
}

int
nfsReadDir(Auth *a, ulong tag, Nfs3Handle *h, u32int count, u64int cookie, uchar **pp,
	u32int *pcount, int (**unpack)(uchar*, uchar*, uchar**, Nfs3Entry*), uchar **pfreeme)
{
	/* BUG: try readdirplus */
	char e[ERRMAX];
	Nfs3TReadDir tx;
	Nfs3RReadDir rx;

	if(readplus!=-1){
		if(nfsReadDirPlus(a, tag, h, count, cookie, pp, pcount, unpack, pfreeme) == 0){
			readplus = 1;
			return 0;
		}
fprint(2, "readdirplus: %r\n");
		if(readplus == 0){
			rerrstr(e, sizeof e);
			if(strstr(e, "procedure unavailable"))
				readplus = -1;
		}
	}
	if(readplus == 1)
		return -1;

	memset(&tx, 0, sizeof tx);
	nfs3Call(a, &tx.call, Nfs3CallTReadDir);
	tx.handle = *h;
	tx.count = count;
	tx.cookie = cookie;

	memset(&rx, 0, sizeof rx);
	nfs3Call(a, &rx.call, Nfs3CallRReadDir);

	if(sunClientRpc(nfscli, tag, &tx.call, &rx.call, pfreeme) < 0)
		return -1;
	if(rx.status != Nfs3Ok){
		free(*pfreeme);
		*pfreeme = 0;
		nfs3Errstr(rx.status);
		return -1;
	}

	/* readplus failed but read succeeded */
	readplus = -1;

	*unpack = nfs3EntryUnpack;
	*pcount = rx.count;
	*pp = rx.data;
	return 0;
}

/*
 * name <-> int translation
 */
typedef struct Map Map;
typedef struct User User;
typedef struct Group Group;

Map *map;
Map emptymap;

struct User
{
	char *name;
	uint uid;
	uint gid;
	uint g[16];
	uint ng;
	uchar *auth;
	int nauth;
};

struct Group
{
	char *name;	/* same pos as in User struct */
	uint gid;	/* same pos as in User struct */
};

struct Map
{
	int nuser;
	int ngroup;
	User *user;
	User **ubyname;
	User **ubyid;
	Group *group;
	Group **gbyname;
	Group **gbyid;
};

User*
finduser(User **u, int nu, char *s)
{
	int lo, hi, mid, n;

	hi = nu;
	lo = 0;
	while(hi > lo){
		mid = (lo+hi)/2;
		n = strcmp(u[mid]->name, s);
		if(n == 0)
			return u[mid];
		if(n < 0)
			lo = mid+1;
		else
			hi = mid;
	}
	return nil;
}

int
strtoid(User **u, int nu, char *s, u32int *id)
{
	u32int x;
	char *p;
	User *uu;

	x = strtoul(s, &p, 10);
	if(*s != 0 && *p == 0){
		*id = x;
		return 0;
	}

	uu = finduser(u, nu, s);
	if(uu == nil)
		return -1;
	*id = uu->uid;
	return 0;
}

char*
idtostr(User **u, int nu, u32int id)
{
	char buf[32];
	int lo, hi, mid;

	hi = nu;
	lo = 0;
	while(hi > lo){
		mid = (lo+hi)/2;
		if(u[mid]->uid == id)
			return estrdup9p(u[mid]->name);
		if(u[mid]->uid < id)
			lo = mid+1;
		else
			hi = mid;
	}
	snprint(buf, sizeof buf, "%ud", id);	
	return estrdup9p(buf);
}		
char*
uidtostr(u32int uid)
{
	return idtostr(map->ubyid, map->nuser, uid);
}

char*
gidtostr(u32int gid)
{
	return idtostr((User**)map->gbyid, map->ngroup, gid);
}

int
strtouid(char *s, u32int *id)
{
	return strtoid(map->ubyname, map->nuser, s, id);
}

int
strtogid(char *s, u32int *id)
{
	return strtoid((User**)map->gbyid, map->ngroup, s, id);
}


int
idcmp(const void *va, const void *vb)
{
	User **a, **b;

	a = (User**)va;
	b = (User**)vb;
	return (*a)->uid - (*b)->uid;
}

int
namecmp(const void *va, const void *vb)
{
	User **a, **b;

	a = (User**)va;
	b = (User**)vb;
	return strcmp((*a)->name, (*b)->name);
}

void
closemap(Map *m)
{
	int i;

	for(i=0; i<m->nuser; i++){
		free(m->user[i].name);
		free(m->user[i].auth);
	}
	for(i=0; i<m->ngroup; i++)
		free(m->group[i].name);
	free(m->user);
	free(m->group);
	free(m->ubyid);
	free(m->ubyname);
	free(m->gbyid);
	free(m->gbyname);
	free(m);
}

Map*
readmap(char *passwd, char *group)
{
	char *s, *f[10], *p, *nextp, *name;
	uchar *q, *eq;
	int i, n, nf, line, uid, gid;
	Biobuf *b;
	Map *m;
	User *u;
	Group *g;
	SunAuthUnix au;

	m = emalloc(sizeof(Map));

	if((b = Bopen(passwd, OREAD)) == nil){
		free(m);
		return nil;
	}
	line = 0;
	for(; (s = Brdstr(b, '\n', 1)) != nil; free(s)){
		line++;
		if(s[0] == '#')
			continue;
		nf = getfields(s, f, nelem(f), 0, ":");
		if(nf < 4)
			continue;
		name = f[0];
		uid = strtol(f[2], &p, 10);
		if(f[2][0] == 0 || *p != 0){
			fprint(2, "%s:%d: non-numeric id in third field\n", passwd, line);
			continue;
		}
		gid = strtol(f[3], &p, 10);
		if(f[3][0] == 0 || *p != 0){
			fprint(2, "%s:%d: non-numeric id in fourth field\n", passwd, line);
			continue;
		}
		if(m->nuser%32 == 0)
			m->user = erealloc(m->user, (m->nuser+32)*sizeof(m->user[0]));
		u = &m->user[m->nuser++];
		u->name = estrdup9p(name);
		u->uid = uid;
		u->gid = gid;
		u->ng = 0;
		u->auth = 0;
		u->nauth = 0;
	}
	Bterm(b);
	m->ubyname = emalloc(m->nuser*sizeof(User*));
	m->ubyid = emalloc(m->nuser*sizeof(User*));
	for(i=0; i<m->nuser; i++){
		m->ubyname[i] = &m->user[i];
		m->ubyid[i] = &m->user[i];
	}
	qsort(m->ubyname, m->nuser, sizeof(m->ubyname[0]), namecmp);
	qsort(m->ubyid, m->nuser, sizeof(m->ubyid[0]), idcmp);

	if((b = Bopen(group, OREAD)) == nil){
		closemap(m);
		return nil;
	}
	line = 0;
	for(; (s = Brdstr(b, '\n', 1)) != nil; free(s)){
		line++;
		if(s[0] == '#')
			continue;
		nf = getfields(s, f, nelem(f), 0, ":");
		if(nf < 4)
			continue;
		name = f[0];
		gid = strtol(f[2], &p, 10);
		if(f[2][0] == 0 || *p != 0){
			fprint(2, "%s:%d: non-numeric id in third field\n", group, line);
			continue;
		}
		if(m->ngroup%32 == 0)
			m->group = erealloc(m->group, (m->ngroup+32)*sizeof(m->group[0]));
		g = &m->group[m->ngroup++];
		g->name = estrdup9p(name);
		g->gid = gid;

		for(p=f[3]; *p; p=nextp){
			if((nextp = strchr(p, ',')) != nil)
				*nextp++ = 0;
			else
				nextp = p+strlen(p);
			u = finduser(m->ubyname, m->nuser, p);
			if(u == nil){
				if(verbose)
					fprint(2, "%s:%d: unknown user %s\n", group, line, p);
				continue;
			}
			if(u->ng >= nelem(u->g)){
				fprint(2, "%s:%d: user %s is in too many groups; ignoring %s\n", group, line, p, name);
				continue;
			}
			u->g[u->ng++] = gid;
		}
	}
	Bterm(b);
	m->gbyname = emalloc(m->ngroup*sizeof(Group*));
	m->gbyid = emalloc(m->ngroup*sizeof(Group*));
	for(i=0; i<m->ngroup; i++){
		m->gbyname[i] = &m->group[i];
		m->gbyid[i] = &m->group[i];
	}
	qsort(m->gbyname, m->ngroup, sizeof(m->gbyname[0]), namecmp);
	qsort(m->gbyid, m->ngroup, sizeof(m->gbyid[0]), idcmp);

	for(i=0; i<m->nuser; i++){
		au.stamp = 0;
		au.sysname = sys;
		au.uid = m->user[i].uid;
		au.gid = m->user[i].gid;
		memmove(au.g, m->user[i].g, sizeof au.g);
		au.ng = m->user[i].ng;
		n = sunAuthUnixSize(&au);
		q = emalloc(n);
		eq = q+n;
		m->user[i].auth = q;
		m->user[i].nauth = n;
		if(sunAuthUnixPack(q, eq, &q, &au) < 0 || q != eq){
			fprint(2, "sunAuthUnixPack failed for %s\n", m->user[i].name);
			free(m->user[i].auth);
			m->user[i].auth = 0;
			m->user[i].nauth = 0;
		}
	}

	return m;
}

Auth*
mkauth(char *user)
{
	Auth *a;
	uchar *p;
	int n;
	SunAuthUnix au;
	User *u;

	u = finduser(map->ubyname, map->nuser, user);
	if(u == nil || u->nauth == 0){
		/* nobody */
		au.stamp = 0;
		au.uid = -1;
		au.gid = -1;
		au.ng = 0;
		au.sysname = sys;
		n = sunAuthUnixSize(&au);
		a = emalloc(sizeof(Auth)+n);
		a->data = (uchar*)&a[1];
		a->ndata = n;
		if(sunAuthUnixPack(a->data, a->data+a->ndata, &p, &au) < 0
		|| p != a->data+a->ndata){
			free(a);
			return nil;
		}
		a->ref = 1;
if(verbose)print("creds for %s: %.*H\n", user, a->ndata, a->data);
		return a;
	}

	a = emalloc(sizeof(Auth)+u->nauth);
	a->data = (uchar*)&a[1];
	a->ndata = u->nauth;
	memmove(a->data, u->auth, a->ndata);
	a->ref = 1;
if(verbose)print("creds for %s: %.*H\n", user, a->ndata, a->data);
	return a;
}

void
freeauth(Auth *a)
{
	if(--a->ref > 0)
		return;
	free(a);
}

/*
 * 9P server
 */
void
responderrstr(Req *r)
{
	char e[ERRMAX];

	rerrstr(e, sizeof e);
	respond(r, e);
}

void
fsdestroyfid(Fid *fid)
{
	FidAux *aux;

	aux = fid->aux;
	if(aux == nil)
		return;
	freeauth(aux->auth);
	free(aux->name);
	free(aux);
}

void
attrToQid(Nfs3Attr *attr, Qid *qid)
{
	qid->path = attr->fileid;
	qid->vers = attr->mtime.sec;
	qid->type = 0;
	if(attr->type == Nfs3FileDir)
		qid->type |= QTDIR;
}

void
attrToDir(Nfs3Attr *attr, Dir *d)
{
	d->mode = attr->mode & 0777;
	if(attr->type == Nfs3FileDir)
		d->mode |= DMDIR;
	d->uid = uidtostr(attr->uid);
	d->gid = gidtostr(attr->gid);
	d->length = attr->size;
	attrToQid(attr, &d->qid);
	d->mtime = attr->mtime.sec;
	d->atime = attr->atime.sec;
	d->muid = nil;
}

void
fsattach(Req *r)
{
	char *path;
	Auth *auth;
	FidAux *aux;
	Nfs3Attr attr;
	Nfs3Handle h;

	path = r->ifcall.aname;
	if(path==nil || path[0]==0)
		path = defaultpath;

	auth = mkauth(r->ifcall.uname);

	if(mountMnt(auth, r->tag, path, &h) < 0
	|| nfsGetattr(auth, r->tag, &h, &attr) < 0){
		freeauth(auth);
		responderrstr(r);
		return;
	}

	aux = emalloc(sizeof(FidAux));
	aux->auth = auth;
	aux->handle = h;
	aux->cookie = 0;
	aux->name = nil;
	memset(&aux->parent, 0, sizeof aux->parent);
	r->fid->aux = aux;
	attrToQid(&attr, &r->fid->qid);
	r->ofcall.qid = r->fid->qid;
	respond(r, nil);
}

void
fsopen(Req *r)
{
	FidAux *aux;
	Nfs3Attr attr;
	u1int have;
	ulong a, b;

	aux = r->fid->aux;
	a = 0;
	switch(r->ifcall.mode&OMASK){
	case OREAD:
		a = 1;
		break;
	case OWRITE:
		a = 2;
		break;
	case ORDWR:
		a = 3;
		break;
	case OEXEC:
		a = 0x20;
		break;
	}
	if(r->ifcall.mode&OTRUNC)
		a = 0x10;

	if(nfsAccess(aux->auth, r->tag, &aux->handle, a, &b, &have, &attr) < 0
	|| (!have && nfsGetattr(aux->auth, r->tag, &aux->handle, &attr) < 0)){
		responderrstr(r);
		return;
	}
	attrToQid(&attr, &r->fid->qid);
	r->ofcall.qid = r->fid->qid;
	respond(r, nil);
}

void
fscreate(Req *r)
{
	FidAux *aux;
	u1int have;
	Nfs3Attr attr;
	Nfs3Handle h;
	ulong mode;
	uint gid;
	int (*mk)(Auth*, ulong, Nfs3Handle*, char*, Nfs3Handle*, ulong, uint, u1int*, Nfs3Attr*);

	aux = r->fid->aux;

	/*
	 * Plan 9 has no umask, so let's use the
	 * parent directory bits like Plan 9 does.
	 * What the heck, let's inherit the group too.
	 * (Unix will let us set the group to anything
	 * since we're the owner!)
	 */
	if(nfsGetattr(aux->auth, r->tag, &aux->handle, &attr) < 0){
		responderrstr(r);
		return;
	}
	mode = r->ifcall.perm&0777;
	if(r->ifcall.perm&DMDIR)
		mode &= (attr.mode&0666) | ~0666;
	else
		mode &= (attr.mode&0777) | ~0777;
	gid = attr.gid;

	if(r->ifcall.perm&DMDIR)
		mk = nfsMkdir;
	else
		mk = nfsCreate;

	if((*mk)(aux->auth, r->tag, &aux->handle, r->ifcall.name, &h, mode, gid, &have, &attr) < 0
	|| (!have && nfsGetattr(aux->auth, r->tag, &h, &attr) < 0)){
		responderrstr(r);
		return;
	}
	attrToQid(&attr, &r->fid->qid);
	aux->parent = aux->handle;
	aux->handle = h;
	free(aux->name);
	aux->name = estrdup9p(r->ifcall.name);
	r->ofcall.qid = r->fid->qid;
	respond(r, nil);
}

void
fsreaddir(Req *r)
{
	FidAux *aux;
	uchar *p, *freeme, *ep, *p9, *ep9;
	uint count;
	int n, (*unpack)(uchar*, uchar*, uchar**, Nfs3Entry*);
	Nfs3Entry e;
	u64int cookie;
	Dir d;

	aux = r->fid->aux;
	/*
	 * r->ifcall.count seems a reasonable estimate to
	 * how much NFS entry data we want.  is it?
	 */
	if(r->ifcall.offset)
		cookie = aux->cookie;
	else
		cookie = 0;
	if(nfsReadDir(aux->auth, r->tag, &aux->handle, r->ifcall.count, cookie,
		&p, &count, &unpack, &freeme) < 0){
		responderrstr(r);
		return;
	}
	ep = p+count;

	p9 = (uchar*)r->ofcall.data;
	ep9 = p9+r->ifcall.count;

	/*
	 * BUG: Issue all of the stat requests in parallel.
	 */
	while(p < ep && p9 < ep9){
		if((*unpack)(p, ep, &p, &e) < 0)
			break;
		aux->cookie = e.cookie;
		if(strcmp(e.name, ".") == 0 || strcmp(e.name, "..") == 0)
			continue;
		if(!e.haveAttr && !e.haveHandle)
			if(nfsLookup(aux->auth, r->tag, &aux->handle, e.name, &e.handle, &e.haveAttr, &e.attr) < 0)
				continue;
		if(!e.haveAttr)
			if(nfsGetattr(aux->auth, r->tag, &e.handle, &e.attr) < 0)
				continue;
		memset(&d, 0, sizeof d);
		attrToDir(&e.attr, &d);
		d.name = e.name;
		if((n = convD2M(&d, p9, ep9-p9)) <= BIT16SZ)
			break;
		p9 += n;
	}
	free(freeme);
	r->ofcall.count = p9 - (uchar*)r->ofcall.data;
	respond(r, nil);
}
	
void
fsread(Req *r)
{
	uchar *p, *freeme;
	uint count;
	FidAux *aux;

	if(r->fid->qid.type&QTDIR){
		fsreaddir(r);
		return;
	}

	aux = r->fid->aux;
	if(nfsRead(aux->auth, r->tag, &aux->handle, r->ifcall.count, r->ifcall.offset, &p, &count, &freeme) < 0){
		responderrstr(r);
		return;
	}
	r->ofcall.data = (char*)p;
	r->ofcall.count = count;
	respond(r, nil);
	free(freeme);
}

void
fswrite(Req *r)
{
	uint count;
	FidAux *aux;

	aux = r->fid->aux;
	if(nfsWrite(aux->auth, r->tag, &aux->handle, (uchar*)r->ifcall.data, r->ifcall.count, r->ifcall.offset, &count) < 0){
		responderrstr(r);
		return;
	}
	r->ofcall.count = count;
	respond(r, nil);
}

void
fsremove(Req *r)
{
	int n;
	FidAux *aux;

	aux = r->fid->aux;
	if(aux->name == nil){
		respond(r, "nfs3client botch -- don't know parent handle in remove");
		return;
	}
	if(r->fid->qid.type&QTDIR)
		n = nfsRmdir(aux->auth, r->tag, &aux->parent, aux->name);
	else
		n = nfsRemove(aux->auth, r->tag, &aux->parent, aux->name);
	if(n < 0){
		responderrstr(r);
		return;
	}
	respond(r, nil);
}

void
fsstat(Req *r)
{
	FidAux *aux;
	Nfs3Attr attr;

	aux = r->fid->aux;
	if(nfsGetattr(aux->auth, r->tag, &aux->handle, &attr) < 0){
		responderrstr(r);
		return;
	}
	memset(&r->d, 0, sizeof r->d);
	attrToDir(&attr, &r->d);
	r->d.name = estrdup9p(aux->name ? aux->name : "???");
	respond(r, nil);
}

void
fswstat(Req *r)
{
	int op, sync;
	FidAux *aux;
	Nfs3SetAttr attr;

	aux = r->fid->aux;

	/* Fill out stat first to catch errors */
	op = 0;
	sync = 1;
	if(~r->d.mode){
		if(r->d.mode&(DMAPPEND|DMEXCL)){
			respond(r, "wstat -- DMAPPEND and DMEXCL bits not supported");
			return;
		}
		op = 1;
		sync = 0;
		attr.setMode = 1;
		attr.mode = r->d.mode & 0777;
	}
	if(r->d.uid && r->d.uid[0]){
		attr.setUid = 1;
		if(strtouid(r->d.uid, &attr.uid) < 0){
			respond(r, "wstat -- unknown uid");
			return;
		}
		op = 1;
		sync = 0;
	}
	if(r->d.gid && r->d.gid[0]){
		attr.setGid = 1;
		if(strtogid(r->d.gid, &attr.gid) < 0){
			respond(r, "wstat -- unknown gid");
			return;
		}
		op = 1;
		sync = 0;
	}
	if(~r->d.length){
		attr.setSize = 1;
		attr.size = r->d.length;
	}
	if(~r->d.mtime){
		attr.setMtime = 1;
		attr.mtime.sec = r->d.mtime;
	}

	/* Try rename first because it's more likely to fail (?) */
	if(r->d.name && r->d.name[0]){
		if(aux->name == nil){
			respond(r, "nfsclient botch -- don't know parent handle in rename");
			return;
		}
		if(nfsRename(aux->auth, r->tag, &aux->parent, aux->name, &aux->parent, r->d.name) < 0){
			responderrstr(r);
			return;
		}
		free(aux->name);
		aux->name = estrdup9p(r->d.name);
		sync = 0;
	}

	/*
	 * Now we have a problem.  The rename succeeded
	 * but the setattr could fail.  Sic transit atomicity.
	 */
	if(op){
		if(nfsSetattr(aux->auth, r->tag, &aux->handle, &attr) < 0){
			responderrstr(r);
			return;
		}
	}

	if(sync){
		/* NFS commit */
		if(nfsCommit(aux->auth, r->tag, &aux->handle) < 0){
			responderrstr(r);
			return;
		}
	}

	respond(r, nil);
}

char*
fswalk1(Fid *fid, char *name, void *v)
{
	u1int have;
	ulong tag;
	FidAux *aux;
	Nfs3Attr attr;
	Nfs3Handle h;

	tag = *(ulong*)v;
	aux = fid->aux;

	if(nfsLookup(aux->auth, tag, &aux->handle, name, &h, &have, &attr) < 0
	|| (!have && nfsGetattr(aux->auth, tag, &h, &attr) < 0)){
		rerrstr(aux->err, sizeof aux->err);
		return aux->err;
	}

	aux->parent = aux->handle;
	aux->handle = h;
	free(aux->name);
	if(strcmp(name, "..") == 0)
		aux->name = nil;
	else
		aux->name = estrdup9p(name);
	attrToQid(&attr, &fid->qid);
	return nil;
}

char*
fsclone(Fid *fid, Fid *newfid, void*)
{
	FidAux *a, *na;

	a = fid->aux;
	na = emalloc9p(sizeof(FidAux));
	*na = *a;
	if(na->name)
		na->name = estrdup9p(na->name);
	newfid->aux = na;
	if(na->auth)
		na->auth->ref++;
	return nil;
}

void
fswalk(Req *r)
{
	walkandclone(r, fswalk1, fsclone, &r->tag);
}

void
fsflush(Req *r)
{
	Req *or;

	/*
	 * Send on the flush channel(s).
	 * The library will make sure the response
	 * is delayed as necessary.
	 */
	or = r->oldreq;
	if(nfscli)
		sendul(nfscli->flushchan, (ulong)or->tag);
	if(mntcli)
		sendul(mntcli->flushchan, (ulong)or->tag);
	respond(r, nil);
}

void
fsdispatch(void *v)
{
	Req *r;

	r = v;
	switch(r->ifcall.type){
	default:	respond(r, "unknown type");	break;
	case Tattach:	fsattach(r);	break;
	case Topen:	fsopen(r);	break;
	case Tcreate:	fscreate(r);	break;
	case Tread:	fsread(r);	break;
	case Twrite:	fswrite(r);	break;
	case Tremove:	fsremove(r);	break;
	case Tflush:	fsflush(r);	break;
	case Tstat:	fsstat(r);	break;
	case Twstat:	fswstat(r);	break;
	case Twalk:	fswalk(r);	break;
	}
}

void
fsthread(void*)
{
	Req *r;

	while((r = recvp(fschan)) != nil)
		threadcreate(fsdispatch, r, SunStackSize);
}

void
fssend(Req *r)
{
	sendp(fschan, r);
}

void
fsdie(Srv*)
{
	threadexitsall(nil);
}

Srv fs =
{
.destroyfid =	fsdestroyfid,
.attach=		fssend,
.open=		fssend,
.create=		fssend,
.read=		fssend,
.write=		fssend,
.remove=		fssend,
.flush=		fssend,
.stat=		fssend,
.wstat=		fssend,
.walk=		fssend,
.end=		fsdie
};

void
usage(void)
{
	fprint(2, "usage: nfs [-DRv] [-p perm] [-s srvname] [-u passwd group] addr [addr]\n");
	fprint(2, "\taddr - address of portmapper server\n");
	fprint(2, "\taddr addr - addresses of mount server and nfs server\n");
	exits("usage");
}

char*
netchangeport(char *addr, uint port, char *buf, uint nbuf)
{
	char *r;

	strecpy(buf, buf+nbuf, addr);
	r = strrchr(buf, '!');
	if(r == nil)
		return nil;
	r++;
	seprint(r, buf+nbuf, "%ud", port);
	return buf;
}

char mbuf[256], nbuf[256];
char *mountaddr, *nfsaddr;
Channel *csync;
int chattyrpc;
void dialproc(void*);

void
threadmain(int argc, char **argv)
{
	char *srvname, *passwd, *group, *addr, *p;
	SunClient *cli;
	int proto;
	uint mport, nport;
	ulong perm;
	Dir d;

	perm = 0600;
	passwd = nil;
	group = nil;
	srvname = nil;
	sys = sysname();
	if(sys == nil)
		sys = "plan9";
	ARGBEGIN{
	default:
		usage();
	case 'D':
		chatty9p++;
		break;
	case 'R':
		chattyrpc++;
		break;
	case 'p':
		perm = strtol(EARGF(usage()), &p, 8);
		if(perm==0 || *p != 0)
			usage();
		break;
	case 's':
		srvname = EARGF(usage());
		break;
	case 'u':
		passwd = EARGF(usage());
		group = EARGF(usage());
		break;
	case 'v':
		verbose++;
		break;
	}ARGEND

	if(argc != 1 && argc != 2)
		usage();

	if(srvname == nil)
		srvname = argv[0];

	fmtinstall('B', sunRpcFmt);
	fmtinstall('C', sunCallFmt);
	fmtinstall('H', encodefmt);
	sunFmtInstall(&portProg);
	sunFmtInstall(&nfs3Prog);
	sunFmtInstall(&nfsMount3Prog);

	if(passwd && (map = readmap(passwd, group)) == nil)
		fprint(2, "warning: reading %s and %s: %r\n", passwd, group);

	if(map == nil)
		map = &emptymap;

	if(argc == 1){
		addr = netmkaddr(argv[0], "udp", "portmap");
		if((cli = sunDial(addr)) == nil)
			sysfatal("dial %s: %r", addr);
		cli->chatty = chattyrpc;
		sunClientProg(cli, &portProg);
		if(strstr(addr, "udp!"))
			proto = PortProtoUdp;
		else
			proto = PortProtoTcp;
		if(getport(cli, NfsMount3Program, NfsMount3Version, proto, &mport) < 0)
			sysfatal("lookup mount program port: %r");
		if(getport(cli, Nfs3Program, Nfs3Version, proto, &nport) < 0)
			sysfatal("lookup nfs program port: %r");
		sunClientClose(cli);
		mountaddr = netchangeport(addr, mport, mbuf, sizeof mbuf);
		nfsaddr = netchangeport(addr, nport, nbuf, sizeof nbuf);
		strcat(mountaddr, "!r");
		strcat(nfsaddr, "!r");
		if(verbose)
			fprint(2, "nfs %s %s\n", mountaddr, nfsaddr);
	}else{
		mountaddr = argv[0];
		nfsaddr = argv[1];
	}

	/* have to dial in another proc because it creates threads */
	csync = chancreate(sizeof(void*), 0);
	proccreate(dialproc, nil, SunStackSize);
	recvp(csync);

	threadpostmountsrv(&fs, srvname, nil, 0);
	if(perm != 0600){
		p = smprint("/srv/%s", srvname);
		if(p){
			nulldir(&d);
			d.mode = perm;
			dirwstat(p, &d);
		}
	}
	threadexits(nil);
}

void
dialproc(void*)
{
	rfork(RFNAMEG);
	rfork(RFNOTEG);
	if((mntcli = sunDial(mountaddr)) == nil)
		sysfatal("dial mount program at %s: %r", mountaddr);
	mntcli->chatty = chattyrpc;
	sunClientProg(mntcli, &nfsMount3Prog);
	if(mountNull(0) < 0)
		sysfatal("execute nop with mnt server at %s: %r", mountaddr);
	
	if((nfscli = sunDial(nfsaddr)) == nil)
		sysfatal("dial nfs program at %s: %r", nfsaddr);
	nfscli->chatty = chattyrpc;
	sunClientProg(nfscli, &nfs3Prog);
	if(nfsNull(0) < 0)
		sysfatal("execute nop with nfs server at %s: %r", nfsaddr);

	fschan = chancreate(sizeof(Req*), 0);
	threadcreate(fsthread, nil, SunStackSize);
	sendp(csync, 0);
}