commit - d10a7ed9a899c17d142021298dd45b4ea9ae6b84
commit + 74dd0321756f968c595487f694fbe74ad00f0624
blob - a72d460c41b079bc83078cb5c04dc8a87b4af7fa
blob + 57caac28f5fbc7b9abbe8f29e31505b5bd268a3c
--- include/9p.h
+++ include/9p.h
int nopipe;
int srvfd;
int leavefdsopen; /* magic for acme win */
- int dotu;
int foreground; /* run in foreground */
int fake;
blob - 1e32b339cb59b81e481a4ea9722eea740fa7ed33
blob + cee9b883b5fc317378e8b2cc1e3f8da9aa07243e
--- include/fcall.h
+++ include/fcall.h
uint convD2M(Dir*, uchar*, uint);
uint sizeD2M(Dir*);
-uint convM2Su(uchar*, uint, Fcall*, int);
-uint convS2Mu(Fcall*, uchar*, uint, int);
-uint sizeS2Mu(Fcall*, int);
-
-int statchecku(uchar *abuf, uint nbuf, int);
-uint convM2Du(uchar*, uint, Dir*, char*, int);
-uint convD2Mu(Dir*, uchar*, uint, int);
-uint sizeD2Mu(Dir*, int);
-
int fcallfmt(Fmt*);
int dirfmt(Fmt*);
int dirmodefmt(Fmt*);
blob - 32b984becdf6bd18a91ad5f6da19693c19f1a2cd
blob + 077715d6cc5ee004ea1dd70642ae10a4b5a6e53f
--- src/cmd/9pserve.c
+++ src/cmd/9pserve.c
Queue *outq;
Queue *inq;
Channel *outqdead;
- int dotu;
};
char *xaname;
u32int xafid = NOFID;
int attached;
int versioned;
-int dotu;
int noauth;
void *gethash(Hash**, uint);
int puthash(Hash**, uint, void*);
int delhash(Hash**, uint, void*);
-Msg *mread9p(Ioproc*, int, int);
+Msg *mread9p(Ioproc*, int);
int mwrite9p(Ioproc*, int, uchar*);
uchar *read9ppkt(Ioproc*, int);
int write9ppkt(int, uchar*);
void outputthread(void*);
void inputthread(void*);
void rewritehdr(Fcall*, uchar*);
-void repack(Fcall*, uchar**, int);
+void repack(Fcall*, uchar**);
int tlisten(char*, char*);
int taccept(int, char*);
int iolisten(Ioproc*, char*, char*);
int ignorepipe(void*, char*);
int timefmt(Fmt*);
void dorootstat(void);
-int stripudirread(Msg*);
-int cvtustat(Fcall*, uchar**, int);
void
usage(void)
if(!versioned){
f.type = Tversion;
- f.version = "9P2000.u";
+ f.version = "9P2000";
f.msize = msize;
f.tag = NOTAG;
n = convS2M(&f, vbuf, sizeof vbuf);
if(f.msize < msize)
msize = f.msize;
if(verbose > 1) fprint(2, "%T * -> %F\n", &f);
- dotu = strncmp(f.version, "9P2000.u", 8) == 0;
}
threadcreate(inputthread, nil, STACK);
{
int n, nn;
- n = sizeS2Mu(&m->rx, m->c->dotu);
+ n = sizeS2M(&m->rx);
m->rpkt = emalloc(n);
- nn = convS2Mu(&m->rx, m->rpkt, n, m->c->dotu);
+ nn = convS2M(&m->rx, m->rpkt, n);
if(nn <= BIT16SZ)
- sysfatal("convS2Mu conversion error");
+ sysfatal("convS2M conversion error");
if(nn != n)
- sysfatal("sizeS2Mu and convS2Mu disagree");
+ sysfatal("sizeS2M and convS2M disagree");
sendq(m->c->outq, m);
}
{
int n, nn;
- n = sizeS2Mu(&m->tx, m->c->dotu);
+ n = sizeS2M(&m->tx);
m->tpkt = emalloc(n);
- nn = convS2Mu(&m->tx, m->tpkt, n, m->c->dotu);
+ nn = convS2M(&m->tx, m->tpkt, n);
if(nn <= BIT16SZ)
- sysfatal("convS2Mu conversion error");
+ sysfatal("convS2M conversion error");
if(nn != n)
- sysfatal("sizeS2Mu and convS2Mu disagree");
+ sysfatal("sizeS2M and convS2M disagree");
sendq(outq, m);
}
close(c->fd);
c->fd = fd;
threadcreate(connoutthread, c, STACK);
- while((m = mread9p(io, c->fd, c->dotu)) != nil){
+ while((m = mread9p(io, c->fd)) != nil){
if(verbose > 1) fprint(2, "%T fd#%d -> %F\n", c->fd, &m->tx);
m->c = c;
m->ctag = m->tx.tag;
if(m->rx.msize > msize)
m->rx.msize = msize;
m->rx.version = "9P2000";
- c->dotu = 0;
- if(dotu && strncmp(m->tx.version, "9P2000.u", 8) == 0){
- m->rx.version = "9P2000.u";
- c->dotu = 1;
- }
m->rx.type = Rversion;
send9pmsg(m);
continue;
m->tx.afid = xafid;
m->tx.aname = xaname;
m->tx.uname = getuser(); /* what srv.c used */
- repack(&m->tx, &m->tpkt, c->dotu);
+ repack(&m->tx, &m->tpkt);
}
break;
case Twalk:
m->afid->ref++;
break;
case Tcreate:
- if(dotu && !c->dotu && (m->tx.perm&(DMSYMLINK|DMDEVICE|DMNAMEDPIPE|DMSOCKET))){
+ if(m->tx.perm&(DMSYMLINK|DMDEVICE|DMNAMEDPIPE|DMSOCKET)){
err(m, "unsupported file type");
continue;
}
continue;
}
m->fid->ref++;
- if(m->tx.type==Twstat && dotu && !c->dotu){
- if(cvtustat(&m->tx, &m->tpkt, 1) < 0){
- err(m, "cannot convert stat buffer");
- continue;
- }
- }
- if(m->tx.type==Tread && m->fid->isdir && dotu && !c->dotu){
- if(m->tx.offset = m->fid->coffset)
- m->tx.offset = m->fid->offset;
- else
- m->fid->offset = m->fid->coffset;
- }
break;
}
void
connoutthread(void *arg)
{
- char *ename;
int err;
Conn *c;
Msg *m, *om;
fidput(m->newfid);
break;
case Tread:
- if(!err && m->fid->isdir && dotu && !m->c->dotu){
- m->fid->offset += m->rx.count;
- stripudirread(m);
- m->fid->coffset += m->rx.count;
- }
break;
case Tstat:
- if(!err && dotu && !m->c->dotu)
- cvtustat(&m->rx, &m->rpkt, 0);
break;
case Topen:
case Tcreate:
m->fid->isdir = (m->rx.qid.type & QTDIR);
break;
}
- if(m->rx.type==Rerror && dotu && !c->dotu){
- ename = estrdup(m->rx.ename);
- m->rx.ename = ename;
- repack(&m->rx, &m->rpkt, c->dotu);
- free(ename);
- m->rx.ename = "XXX";
- }
if(delhash(m->c->tag, m->ctag, m) == 0)
msgput(m);
if(verbose > 1) fprint(2, "%T fd#%d <- %F\n", c->fd, &m->rx);
free(pkt);
continue;
}
- if((nn = convM2Su(pkt, n, &m->rx, dotu)) != n){
+ if((nn = convM2S(pkt, n, &m->rx)) != n){
fprint(2, "%T bad packet - convM2S %d but %d\n", nn, n);
free(pkt);
msgput(m);
}
Msg*
-mread9p(Ioproc *io, int fd, int dotu)
+mread9p(Ioproc *io, int fd)
{
int n, nn;
uchar *pkt;
m = msgnew(0);
m->tpkt = pkt;
n = GBIT32(pkt);
- nn = convM2Su(pkt, n, &m->tx, dotu);
+ nn = convM2S(pkt, n, &m->tx);
if(nn != n){
fprint(2, "%T read bad packet from %d\n", fd);
return nil;
}
void
-repack(Fcall *f, uchar **ppkt, int dotu)
+repack(Fcall *f, uchar **ppkt)
{
uint n, nn;
uchar *pkt;
pkt = *ppkt;
n = GBIT32(pkt);
- nn = sizeS2Mu(f, dotu);
+ nn = sizeS2M(f);
if(nn > n){
free(pkt);
pkt = emalloc(nn);
*ppkt = pkt;
}
- n = convS2Mu(f, pkt, nn, dotu);
+ n = convS2M(f, pkt, nn);
if(n <= BIT16SZ)
sysfatal("convS2M conversion error");
if(n != nn)
- sysfatal("convS2Mu and sizeS2Mu disagree");
+ sysfatal("convS2M and sizeS2M disagree");
}
void
return fmtprint(fmt, "%s %2d %02d:%02d:%02d.%03d",
mon[tm.mon], tm.mday, tm.hour, tm.min, tm.sec,
(int)(ns%1000000000)/1000000);
-}
-
-int
-cvtustat(Fcall *f, uchar **fpkt, int tounix)
-{
- int n;
- uchar *buf;
- char *str;
- Dir dir;
-
- str = emalloc(f->nstat);
- n = convM2Du(f->stat, f->nstat, &dir, str, !tounix);
- if(n <= BIT16SZ){
- free(str);
- return -1;
- }
-
- n = sizeD2Mu(&dir, tounix);
- buf = emalloc(n);
- if(convD2Mu(&dir, buf, n, tounix) != n)
- sysfatal("convD2Mu conversion error");
- f->nstat = n;
- f->stat = buf;
-
- repack(f, fpkt, dotu);
- free(buf);
- f->stat = nil; /* is this okay ??? */
- free(str);
-
- return 0;
}
-
-int
-stripudirread(Msg* msg)
-{
- char *str;
- int i, m, n, nn;
- uchar *buf;
- Dir d;
- Fcall* rx;
-
- buf = nil;
- str = nil;
- rx = &msg->rx;
- n = 0;
- nn = 0;
- for(i = 0; i < rx->count; i += m){
- m = BIT16SZ + GBIT16(&rx->data[i]);
- if(statchecku((uchar*)&rx->data[i], m, 1) < 0)
- return -1;
- if(nn < m)
- nn = m;
- n++;
- }
-
- str = emalloc(nn);
- buf = emalloc(rx->count);
-
- nn = 0;
- for(i = 0; i < rx->count; i += m){
- m = BIT16SZ + GBIT16(&rx->data[i]);
- if(convM2Du((uchar*)&rx->data[i], m, &d, str, 1) != m){
- free(buf);
- free(str);
- return -1;
- }
-
- n = convD2M(&d, &buf[nn], rx->count - nn);
- if(n <= BIT16SZ){
- free(buf);
- free(str);
- return -1;
- }
-
- nn += n;
- }
-
- rx->count = nn;
- rx->data = (char*)buf;
-
- repack(&msg->rx, &msg->rpkt, 0);
- free(str);
- free(buf);
- rx->data = nil; /* is this okay ??? */
-
- return 0;
-}
-
blob - 3edb63bd2cc71cd43235dbf0a580d214284d2142
blob + 231c4164e8f49b58735cfca73e2d4d385639a56b
--- src/cmd/vac/vacfs.c
+++ src/cmd/vac/vacfs.c
#include <fcall.h>
#include "vac.h"
-#ifndef PLAN9PORT
-#define convM2Su(a, b, c, d) convM2S(a, b, c)
-#define convS2Mu(a, b, c, d) convS2M(a, b, c)
-#define convM2Du(a, b, c, d) convM2D(a, b, c)
-#define convD2Mu(a, b, c, d) convD2M(a, b, c)
-#endif
-
typedef struct Fid Fid;
enum
VacFs *fs;
VtConn *conn;
int noperm;
-int dotu;
char *defmnt;
Fid * newfid(int);
if(strncmp(rhdr.version, "9P2000", 6) != 0)
return vtstrdup("unrecognized 9P version");
thdr.version = "9P2000";
- if(strncmp(rhdr.version, "9P2000.u", 8) == 0){
- dotu = 1;
- thdr.version = "9P2000.u";
- }
return nil;
}
dir.gidnum = atoi(vd->gid);
#endif
- ret = convD2Mu(&dir, p, np, dotu);
+ ret = convD2M(&dir, p, np);
#ifdef PLAN9PORT
free(ext);
#endif
n = read9pmsg(mfd[0], mdata, sizeof mdata);
if(n <= 0)
break;
- if(convM2Su(mdata, n, &rhdr, dotu) != n)
+ if(convM2S(mdata, n, &rhdr) != n)
sysfatal("convM2S conversion error");
if(dflag)
thdr.tag = rhdr.tag;
if(dflag)
fprint(2, "vacfs:->%F\n", &thdr);
- n = convS2Mu(&thdr, mdata, messagesize, dotu);
+ n = convS2M(&thdr, mdata, messagesize);
if(n <= BIT16SZ)
- sysfatal("convS2Mu conversion error");
+ sysfatal("convS2M conversion error");
if(err)
vtfree(err);
blob - bd8a30b63b8dd0e4298cae5a8532ef84ed5e45f8
blob + 30c0d496145a15003b4ba6db8e002c67b4b4b7d5
--- src/lib9/convD2M.c
+++ src/lib9/convD2M.c
#include <fcall.h>
uint
-sizeD2Mu(Dir *d, int dotu)
+sizeD2M(Dir *d)
{
char *sv[5];
int i, ns, nstr, fixlen;
fixlen = STATFIXLEN;
nstr = 4;
- if(dotu){
- fixlen = STATFIXLENU;
- sv[4] = d->ext;
- nstr = 5;
- }
ns = 0;
for(i = 0; i < nstr; i++)
}
uint
-sizeD2M(Dir *d)
+convD2M(Dir *d, uchar *buf, uint nbuf)
{
- return sizeD2Mu(d, 0);
-}
-
-uint
-convD2Mu(Dir *d, uchar *buf, uint nbuf, int dotu)
-{
uchar *p, *ebuf;
char *sv[5];
int i, ns, nsv[5], ss, nstr, fixlen;
fixlen = STATFIXLEN;
nstr = 4;
- if(dotu){
- fixlen = STATFIXLENU;
- sv[4] = d->ext;
- nstr = 5;
- }
ns = 0;
for(i = 0; i < nstr; i++){
p += ns;
}
- if(dotu){
- PBIT32(p, d->uidnum);
- p += BIT32SZ;
- PBIT32(p, d->gidnum);
- p += BIT32SZ;
- PBIT32(p, d->muidnum);
- p += BIT32SZ;
- }
-
if(ss != p - buf)
return 0;
return p - buf;
}
-
-uint
-convD2M(Dir *d, uchar *buf, uint nbuf)
-{
- return convD2Mu(d, buf, nbuf, 0);
-}
blob - 52d7fad5a594bc57190070fccdcb4742612bad04
blob + 504110b2ded3912946f8a22870ec14a5cda01d73
--- src/lib9/convM2D.c
+++ src/lib9/convM2D.c
#include <fcall.h>
int
-statchecku(uchar *buf, uint nbuf, int dotu)
+statcheck(uchar *buf, uint nbuf)
{
uchar *ebuf;
int i, nstr;
buf += STATFIXLEN - 4 * BIT16SZ;
nstr = 4;
- if(dotu)
- nstr = 5;
for(i = 0; i < nstr; i++){
if(buf + BIT16SZ > ebuf)
return -1;
buf += BIT16SZ + GBIT16(buf);
}
- if(dotu)
- buf += 3*BIT32SZ;
-
if(buf != ebuf)
return -1;
return 0;
}
-int
-statcheck(uchar *buf, uint nbuf)
-{
- return statchecku(buf, nbuf, 0);
-}
-
static char nullstring[] = "";
uint
-convM2Du(uchar *buf, uint nbuf, Dir *d, char *strs, int dotu)
+convM2D(uchar *buf, uint nbuf, Dir *d, char *strs)
{
uchar *p, *ebuf;
char *sv[5];
p += BIT64SZ;
nstr = 4;
- if(dotu)
- nstr = 5;
for(i = 0; i < nstr; i++){
if(p + BIT16SZ > ebuf)
return 0;
p += ns;
}
- if(dotu){
- if(p + BIT32SZ*3 > ebuf)
- return 0;
- d->uidnum = GBIT32(p);
- p += BIT32SZ;
- d->gidnum = GBIT32(p);
- p += BIT32SZ;
- d->muidnum = GBIT32(p);
- p += BIT32SZ;
- }
-
if(strs){
d->name = sv[0];
d->uid = sv[1];
d->gid = sv[2];
d->muid = sv[3];
d->ext = nullstring;
- if(dotu)
- d->ext = sv[4];
}else{
d->name = nullstring;
d->uid = nullstring;
return p - buf;
}
-
-uint
-convM2D(uchar *buf, uint nbuf, Dir *d, char *strs)
-{
- return convM2Du(buf, nbuf, d, strs, 0);
-}
blob - 6a8805c4d6ac83dd5b9a3efb3aa3c6818212433b
blob + a9c9205d96dffe4cd9ba0451c36b52cfb1090bde
--- src/lib9/convM2S.c
+++ src/lib9/convM2S.c
* to test at end of routine.
*/
uint
-convM2Su(uchar *ap, uint nap, Fcall *f, int dotu)
+convM2S(uchar *ap, uint nap, Fcall *f)
{
uchar *p, *ep;
uint i, size;
if(p == nil)
break;
f->uidnum = NOUID;
- if(dotu){
- if(p+BIT32SZ > ep)
- return 0;
- f->uidnum = GBIT32(p);
- p += BIT32SZ;
- }
break;
case Tattach:
if(p == nil)
break;
f->uidnum = NOUID;
- if(dotu){
- if(p+BIT32SZ > ep)
- return 0;
- f->uidnum = GBIT32(p);
- p += BIT32SZ;
- }
break;
case Twalk:
p += BIT32SZ;
f->mode = GBIT8(p);
p += BIT8SZ;
- if(dotu)
- p = gstring(p, ep, &f->extension);
break;
case Tread:
case Rerror:
p = gstring(p, ep, &f->ename);
f->errornum = 0;
- if(dotu){
- if(p+BIT32SZ > ep)
- return 0;
- f->errornum = GBIT32(p);
- p += BIT32SZ;
- }
break;
case Rflush:
return size;
return 0;
}
-
-uint
-convM2S(uchar *ap, uint nap, Fcall *f)
-{
- return convM2Su(ap, nap, f, 0);
-}
blob - 02923bd4efb06d6726645b95623d5dd679e19a66
blob + 6e9d2719270832bb2d985b0475197eacc8939290
--- src/lib9/convS2M.c
+++ src/lib9/convS2M.c
}
uint
-sizeS2Mu(Fcall *f, int dotu)
+sizeS2M(Fcall *f)
{
uint n;
int i;
n += BIT32SZ;
n += stringsz(f->uname);
n += stringsz(f->aname);
- if(dotu)
- n += BIT32SZ;
break;
case Tattach:
n += BIT32SZ;
n += stringsz(f->uname);
n += stringsz(f->aname);
- if(dotu)
- n += BIT32SZ;
break;
case Twalk:
n += stringsz(f->name);
n += BIT32SZ;
n += BIT8SZ;
- if(dotu)
- n += stringsz(f->extension);
break;
case Tread:
case Rerror:
n += stringsz(f->ename);
- if(dotu)
- n += BIT32SZ;
break;
case Rflush:
}
uint
-sizeS2M(Fcall *f)
+convS2M(Fcall *f, uchar *ap, uint nap)
{
- return sizeS2Mu(f, 0);
-}
-
-uint
-convS2Mu(Fcall *f, uchar *ap, uint nap, int dotu)
-{
uchar *p;
uint i, size;
- size = sizeS2Mu(f, dotu);
+ size = sizeS2M(f);
if(size == 0)
return 0;
if(size > nap)
p += BIT32SZ;
p = pstring(p, f->uname);
p = pstring(p, f->aname);
- if(dotu){
- f->uidnum = NOUID;
- PBIT32(p, f->uidnum);
- p += BIT32SZ;
- }
break;
case Tattach:
p += BIT32SZ;
p = pstring(p, f->uname);
p = pstring(p, f->aname);
- if(dotu){
- f->uidnum = NOUID;
- PBIT32(p, f->uidnum);
- p += BIT32SZ;
- }
break;
case Twalk:
p += BIT32SZ;
PBIT8(p, f->mode);
p += BIT8SZ;
- if(dotu)
- p = pstring(p, f->extension);
break;
case Tread:
case Rerror:
p = pstring(p, f->ename);
- if(dotu){
- PBIT32(p, f->errornum);
- p += BIT32SZ;
- }
break;
case Rflush:
return 0;
return size;
}
-
-uint
-convS2M(Fcall *f, uchar *ap, uint nap)
-{
- return convS2Mu(f, ap, nap, 0);
-}
blob - 52fdb73147f705282a13145588c774b516b814ba
blob + aaaa141a1a30ce1318312d6fc3d5f358520e88ee
--- src/lib9p/dirread.c
+++ src/lib9p/dirread.c
memset(&d, 0, sizeof d);
if((*gen)(start, &d, aux) < 0)
break;
- rv = convD2Mu(&d, p, ep-p, r->srv->dotu);
+ rv = convD2M(&d, p, ep-p);
free(d.name);
free(d.muid);
free(d.uid);
blob - ece35940352f850c6077846acd73f8e9dcc37d8e
blob + a857375c57574b5683dcf020e479b14cda73a60a
--- src/lib9p/srv.c
+++ src/lib9p/srv.c
memmove(buf, s->rbuf, n);
qunlock(&s->rlock);
- if(convM2Su(buf, n, &f, s->dotu) != n){
+ if(convM2S(buf, n, &f) != n){
free(buf);
return nil;
}
{
USED(srv);
- if(strncmp(r->ifcall.version, "9P", 2) != 0){
+ if(strncmp(r->ifcall.version, "9P2000", 6) != 0){
r->ofcall.version = "unknown";
respond(r, nil);
return;
}
-
- if(strncmp(r->ifcall.version, "9P2000.u", 8) == 0){
- r->ofcall.version = "9P2000.u";
- srv->dotu = 1;
- }else{
- r->ofcall.version = "9P2000";
- srv->dotu = 0;
- }
+ r->ofcall.version = "9P2000";
r->ofcall.msize = r->ifcall.msize;
respond(r, nil);
}
+
static void
rversion(Req *r, char *error)
{
respond(r, e);
}
}
+
static void
rauth(Req *r, char *error)
{
respond(r, nil);
return;
}
+
static void
rattach(Req *r, char *error)
{
else
respond(r, nil);
}
+
static int
rflush(Req *r, char *error)
{
else
respond(r, nil);
}
+
static void
ropen(Req *r, char *error)
{
else
respond(r, Enocreate);
}
+
static void
rcreate(Req *r, char *error)
{
else
respond(r, "no srv->read");
}
+
static void
rread(Req *r, char *error)
{
if(error)
return;
- if(convD2Mu(&r->d, tmp, BIT16SZ, r->srv->dotu) != BIT16SZ){
- r->error = "convD2Mu(_,_,BIT16SZ,_) did not return BIT16SZ";
+ if(convD2M(&r->d, tmp, BIT16SZ) != BIT16SZ){
+ r->error = "convD2M(_,_,BIT16SZ) did not return BIT16SZ";
return;
}
n = GBIT16(tmp)+BIT16SZ;
r->error = "out of memory";
return;
}
- r->ofcall.nstat = convD2Mu(&r->d, statbuf, n, r->srv->dotu);
+ r->ofcall.nstat = convD2M(&r->d, statbuf, n);
r->ofcall.stat = statbuf; /* freed in closereq */
if(r->ofcall.nstat <= BIT16SZ){
- r->error = "convD2Mu fails";
+ r->error = "convD2M fails";
free(statbuf);
return;
}
respond(r, Enowstat);
return;
}
- if(convM2Du(r->ifcall.stat, r->ifcall.nstat, &r->d, (char*)r->ifcall.stat, srv->dotu) != r->ifcall.nstat){
+ if(convM2D(r->ifcall.stat, r->ifcall.nstat, &r->d, (char*)r->ifcall.stat) != r->ifcall.nstat){
respond(r, Ebaddir);
return;
}
}
srv->wstat(r);
}
+
static void
rwstat(Req *r, char *msg)
{
fprint(2, "-%d-> %F\n", srv->outfd, &r->ofcall);
qlock(&srv->wlock);
- n = convS2Mu(&r->ofcall, srv->wbuf, srv->msize, srv->dotu);
+ n = convS2M(&r->ofcall, srv->wbuf, srv->msize);
if(n <= 0){
fprint(2, "n = %d %F\n", n, &r->ofcall);
abort();
blob - c2b13882fec774a9d715bd9631c40bb6b07e219e
blob + 32c5978340d46ada1dc2cba3b6b61504c9016b90
--- src/lib9pclient/dirread.c
+++ src/lib9pclient/dirread.c
#include "fsimpl.h"
static long
-dirpackage(uchar *buf, long ts, Dir **d, int dotu)
+dirpackage(uchar *buf, long ts, Dir **d)
{
char *s;
long ss, i, n, nn, m;
n = 0;
for(i = 0; i < ts; i += m){
m = BIT16SZ + GBIT16(&buf[i]);
- if(statchecku(&buf[i], m, dotu) < 0)
+ if(statcheck(&buf[i], m) < 0)
break;
ss += m;
n++;
nn = 0;
for(i = 0; i < ts; i += m){
m = BIT16SZ + GBIT16((uchar*)&buf[i]);
- if(nn >= n || convM2Du(&buf[i], m, *d + nn, s, dotu) != m){
+ if(nn >= n || convM2D(&buf[i], m, *d + nn, s) != m){
free(*d);
*d = nil;
return -1;
return -1;
ts = fsread(fid, buf, DIRMAX);
if(ts >= 0)
- ts = dirpackage(buf, ts, d, fid->fs->dotu);
+ ts = dirpackage(buf, ts, d);
free(buf);
return ts;
}
ts += n;
}
if(ts >= 0){
- ts = dirpackage(buf, ts, d, fid->fs->dotu);
+ ts = dirpackage(buf, ts, d);
if(ts < 0)
- werrstr("malformed directory contents [dotu=%d]", fid->fs->dotu);
+ werrstr("malformed directory contents");
}
free(buf);
if(ts == 0 && n < 0)
blob - 169f12069f7f0a711ed28278ce2e31258001d97c
blob + c6b1c3e92b016ce44aefa50b19848bf2e98879bf
--- src/lib9pclient/fs.c
+++ src/lib9pclient/fs.c
fs->iosend = ioproc();
muxinit(&fs->mux);
- strcpy(fs->version, "9P2000.u");
+ strcpy(fs->version, "9P2000");
if((n = fsversion(fs, 8192, fs->version, sizeof fs->version)) < 0){
werrstr("fsversion: %r");
_fsunmount(fs);
return nil;
}
- if(strcmp(fs->version, "9P2000.u") == 0)
- fs->dotu = 1;
fs->msize = n;
return fs;
}
int n, nn;
void *tpkt, *rpkt;
- n = sizeS2Mu(tx, fs->dotu);
+ n = sizeS2M(tx);
tpkt = malloc(n);
if(freep)
*freep = nil;
tx->tag = 0;
if(chatty9pclient)
fprint(2, "<- %F\n", tx);
- nn = convS2Mu(tx, tpkt, n, fs->dotu);
+ nn = convS2M(tx, tpkt, n);
if(nn != n){
free(tpkt);
werrstr("lib9pclient: sizeS2M convS2M mismatch");
return -1;
}
n = GBIT32((uchar*)rpkt);
- nn = convM2Su(rpkt, n, rx, fs->dotu);
+ nn = convM2S(rpkt, n, rx);
if(nn != n){
free(rpkt);
werrstr("lib9pclient: convM2S packet size mismatch %d %d", n, nn);
blob - d609dde8ba1c6372173dc95dc5e2bd7a663fcfa5
blob + 9c5c555355fd58ca2e3b7d397de11475ee8981fd
--- src/lib9pclient/fsimpl.h
+++ src/lib9pclient/fsimpl.h
struct CFsys
{
char version[20];
- int dotu;
int msize;
QLock lk;
int fd;
blob - 594f8be152a434d45e279eb0fed9676f64748475
blob + 9c69446aa74e2705649db85b7a7d0cffc508c062
--- src/lib9pclient/stat.c
+++ src/lib9pclient/stat.c
free(freep);
return nil;
}
- n = convM2Du(rx.stat, rx.nstat, d, (char*)&d[1], fs->dotu);
+ n = convM2D(rx.stat, rx.nstat, d, (char*)&d[1]);
free(freep);
if(n != rx.nstat){
free(d);
blob - cc193d257f201c9a837d8f7bc5891a2839ce02a2
blob + 26e44f8e86cdb3926b4149378640caccba8a9774
--- src/lib9pclient/wstat.c
+++ src/lib9pclient/wstat.c
int n, nn;
Fcall tx, rx;
- n = sizeD2Mu(d, fid->fs->dotu);
+ n = sizeD2M(d);
a = malloc(n);
if(a == nil)
return -1;
- nn = convD2Mu(d, a, n, fid->fs->dotu);
+ nn = convD2M(d, a, n);
if(n != nn){
werrstr("convD2M and sizeD2M disagree");
free(a);