ref: 36af8405521be371605e4658ec8f4b133f3c7d6f
dir: /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; tx.ndata = count; 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; } if(readplus == 0){ rerrstr(e, sizeof e); if(strstr(e, "procedure unavailable") || strstr(e, "not supported")) readplus = -1; } if(readplus == 0) fprint(2, "readdirplus: %r\n"); } 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; Nfs3SetAttr sa; u1int have; ulong a, b; aux = r->fid->aux; a = 0; switch(r->ifcall.mode&OMASK){ case OREAD: a = 0x0001; break; case OWRITE: a = 0x0004; break; case ORDWR: a = 0x0001|0x0004; break; case OEXEC: a = 0x20; break; } if(r->ifcall.mode&OTRUNC) a |= 0x0004; if(nfsAccess(aux->auth, r->tag, &aux->handle, a, &b, &have, &attr) < 0 || (!have && nfsGetattr(aux->auth, r->tag, &aux->handle, &attr) < 0)){ Error: responderrstr(r); return; } if(a != b){ respond(r, "permission denied"); return; } if(r->ifcall.mode&OTRUNC){ memset(&sa, 0, sizeof sa); sa.setSize = 1; if(nfsSetattr(aux->auth, r->tag, &aux->handle, &sa) < 0) goto Error; } 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; char *s; 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; for(s=e.name; (uchar)*s >= ' '; s++) ; if(*s != 0) /* bad character in name */ 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; memset(&attr, 0, sizeof 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; op = 1; sync = 0; } if(~r->d.mtime){ attr.setMtime = Nfs3SetTimeClient; attr.mtime.sec = r->d.mtime; op = 1; sync = 0; } if(~r->d.atime){ attr.setAtime = Nfs3SetTimeClient; attr.atime.sec = r->d.atime; op = 1; sync = 0; } /* 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); }