commit - e97ceade5e1bba5787e39429384336fa37797906
commit + d3df308747ee4d1fcc063a348dcf1146b390bda7
blob - /dev/null
blob + 219b2774a5a98dbd58e8e9b4ee871215fec510fa (mode 644)
--- /dev/null
+++ include/fs.h
+#ifndef _FS_H_
+#define _FS_H_ 1
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Simple user-level 9P client.
+ */
+
+typedef struct Fsys Fsys;
+typedef struct Fid Fid;
+
+Fsys *fsinit(int);
+Fsys *fsmount(int);
+
+int fsversion(Fsys*, int, char*, int);
+Fid *fsauth(Fsys*, char*);
+Fid *fsattach(Fsys*, Fid*, char*, char*);
+Fid *fsopen(Fsys*, char*, int);
+int fsopenfd(Fsys*, char*, int);
+long fsread(Fid*, void*, long);
+long fsreadn(Fid*, void*, long);
+long fswrite(Fid*, void*, long);
+void fsclose(Fid*);
+void fsunmount(Fsys*);
+int fsrpc(Fsys*, Fcall*, Fcall*, void**);
+Fid *fswalk(Fid*, char*);
+struct Dir; /* in case there's no lib9.h */
+long fsdirread(Fid*, struct Dir**);
+long fsdirreadall(Fid*, struct Dir**);
+struct Dir *fsdirstat(Fsys*, char*);
+struct Dir *fsdirfstat(Fid*);
+int fsdirwstat(Fsys*, char*, struct Dir*);
+int fsdirfwstat(Fid*, struct Dir*);
+Fid *fsroot(Fsys*);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
blob - /dev/null
blob + c43ce797a7cf70932f07e59d547e60dd37d6b299 (mode 644)
--- /dev/null
+++ include/mux.h
+typedef struct Mux Mux;
+typedef struct Muxrpc Muxrpc;
+typedef struct Muxqueue Muxqueue;
+
+struct Muxrpc
+{
+ Muxrpc *next;
+ Muxrpc *prev;
+ Rendez r;
+ uint tag;
+ void *p;
+};
+
+struct Mux
+{
+ uint mintag; /* to be filled by client */
+ uint maxtag;
+ int (*send)(Mux*, void*);
+ void *(*recv)(Mux*);
+ int (*gettag)(Mux*, void*);
+ int (*settag)(Mux*, void*, uint);
+ void *aux; /* for private use by client */
+
+/* private */
+ QLock lk;
+ QLock inlk;
+ QLock outlk;
+ Rendez tagrend;
+ Rendez rpcfork;
+ Muxqueue *readq;
+ Muxqueue *writeq;
+ uint nwait;
+ uint mwait;
+ uint freetag;
+ Muxrpc **wait;
+ uint muxer;
+ Muxrpc sleep;
+};
+
+void muxinit(Mux*);
+void* muxrpc(Mux*, void*);
+void muxthreads(Mux*);
+
+/* private */
+int _muxsend(Mux*, void*);
+void* _muxrecv(Mux*);
+void _muxsendproc(void*);
+void _muxrecvproc(void*);
+Muxqueue *_muxqalloc(void);
+int _muxqsend(Muxqueue*, void*);
+void *_muxqrecv(Muxqueue*);
+void _muxqhangup(Muxqueue*);
+void *_muxnbqrecv(Muxqueue*);
+
blob - /dev/null
blob + 7c018c34b542cbfe666ab884688d000234dd6040 (mode 644)
--- /dev/null
+++ src/cmd/9p.c
+#include <u.h>
+#include <libc.h>
+#include <fcall.h>
+#include <fs.h>
+
+char *addr;
+
+void
+usage(void)
+{
+ fprint(2, "usage: 9p [-a address] cmd args...\n");
+ fprint(2, "possible cmds:\n");
+ fprint(2, " read name\n");
+ fprint(2, " write name\n");
+ fprint(2, " stat name\n");
+// fprint(2, " ls name\n");
+ fprint(2, "without -a, name elem/path means /path on server unix!$ns/elem\n");
+ exits("usage");
+}
+
+void xread(int, char**);
+void xwrite(int, char**);
+void xstat(int, char**);
+void xls(int, char**);
+
+struct {
+ char *s;
+ void (*f)(int, char**);
+} cmds[] = {
+ "read", xread,
+ "write", xwrite,
+ "stat", xstat,
+// "ls", xls,
+};
+
+void
+main(int argc, char **argv)
+{
+ char *cmd;
+ int i;
+
+ ARGBEGIN{
+ case 'a':
+ addr = EARGF(usage());
+ break;
+ default:
+ usage();
+ }ARGEND
+
+ if(argc < 1)
+ usage();
+
+ cmd = argv[0];
+ for(i=0; i<nelem(cmds); i++){
+ if(strcmp(cmds[i].s, cmd) == 0){
+ cmds[i].f(argc, argv);
+ exits(0);
+ }
+ }
+ usage();
+}
+
+Fsys*
+xparse(char *name, char **path)
+{
+ int fd;
+ char *ns;
+ char *p;
+ Fsys *fs;
+
+ if(addr == nil){
+ p = strchr(name, '/');
+ if(p == nil)
+ p = name+strlen(name);
+ else
+ *p++ = 0;
+ *path = p;
+ if(*name == 0)
+ usage();
+ ns = getenv("ns");
+ if(ns == nil)
+ sysfatal("ns not set");
+ addr = smprint("unix!%s/%s", ns, name);
+ if(addr == nil)
+ sysfatal("out of memory");
+ }else
+ *path = name;
+
+ fprint(2, "dial %s...", addr);
+ if((fd = dial(addr, nil, nil, nil)) < 0)
+ sysfatal("dial: %r");
+ if((fs = fsmount(fd)) == nil)
+ sysfatal("fsmount: %r");
+ return fs;
+}
+
+Fid*
+xwalk(char *name)
+{
+ Fid *fid;
+ Fsys *fs;
+
+ fs = xparse(name, &name);
+ fid = fswalk(fsroot(fs), name);
+ if(fid == nil)
+ sysfatal("fswalk %s: %r", name);
+ return fid;
+}
+
+Fid*
+xopen(char *name, int mode)
+{
+ Fid *fid;
+ Fsys *fs;
+
+ fs = xparse(name, &name);
+ fid = fsopen(fs, name, mode);
+ if(fid == nil)
+ sysfatal("fsopen %s: %r", name);
+ return fid;
+}
+
+void
+xread(int argc, char **argv)
+{
+ char buf[1024];
+ int n;
+ Fid *fid;
+
+ ARGBEGIN{
+ default:
+ usage();
+ }ARGEND
+
+ if(argc != 1)
+ usage();
+
+ fid = xopen(argv[0], OREAD);
+ while((n = fsread(fid, buf, sizeof buf)) > 0)
+ write(1, buf, n);
+ if(n < 0)
+ sysfatal("read error: %r");
+ exits(0);
+}
+
+void
+xwrite(int argc, char **argv)
+{
+ char buf[1024];
+ int n;
+ Fid *fid;
+
+ ARGBEGIN{
+ default:
+ usage();
+ }ARGEND
+
+ if(argc != 1)
+ usage();
+
+ fid = xopen(argv[0], OWRITE|OTRUNC);
+ while((n = read(0, buf, sizeof buf)) > 0)
+ if(fswrite(fid, buf, n) != n)
+ sysfatal("write error: %r");
+ if(n < 0)
+ sysfatal("read error: %r");
+ exits(0);
+}
+
+void
+xstat(int argc, char **argv)
+{
+ Dir *d;
+ Fid *fid;
+
+ ARGBEGIN{
+ default:
+ usage();
+ }ARGEND
+
+ if(argc != 1)
+ usage();
+
+ fid = xwalk(argv[0]);
+ if((d = fsdirfstat(fid)) < 0)
+ sysfatal("dirfstat: %r");
+ fmtinstall('D', dirfmt);
+ fmtinstall('M', dirmodefmt);
+ print("%D\n", d);
+ exits(0);
+}
blob - /dev/null
blob + 40db17e52f8d9338317ec8f96b283f1ab0809947 (mode 644)
--- /dev/null
+++ src/cmd/9pserve.c
+#include <u.h>
+#include <libc.h>
+#include <fcall.h>
+#include <thread.h>
+
+enum
+{
+ STACK = 32768,
+ NHASH = 31,
+ MAXMSG = 64, /* per connection */
+};
+
+typedef struct Hash Hash;
+typedef struct Fid Fid;
+typedef struct Msg Msg;
+typedef struct Conn Conn;
+typedef struct Queue Queue;
+
+struct Hash
+{
+ Hash *next;
+ uint n;
+ void *v;
+};
+
+struct Fid
+{
+ int fid;
+ int ref;
+ int cfid;
+ Fid *next;
+};
+
+struct Msg
+{
+ Conn *c;
+ int internal;
+ int ref;
+ int ctag;
+ int tag;
+ Fcall tx;
+ Fcall rx;
+ Fid *fid;
+ Fid *newfid;
+ Fid *afid;
+ Msg *oldm;
+ Msg *next;
+ uchar *tpkt;
+ uchar *rpkt;
+};
+
+struct Conn
+{
+ int fd;
+ int nmsg;
+ int nfid;
+ Channel *inc;
+ Channel *internal;
+ int inputstalled;
+ char dir[40];
+ Hash *tag[NHASH];
+ Hash *fid[NHASH];
+ Queue *outq;
+ Queue *inq;
+};
+
+char *addr;
+int afd;
+char adir[40];
+int isunix;
+Queue *outq;
+Queue *inq;
+
+void *gethash(Hash**, uint);
+int puthash(Hash**, uint, void*);
+int delhash(Hash**, uint, void*);
+Msg *mread9p(int);
+int mwrite9p(int, Msg*);
+uchar *read9ppkt(int);
+int write9ppkt(int, uchar*);
+Msg *msgnew(void);
+void msgput(Msg*);
+Msg *msgget(int);
+Fid *fidnew(int);
+void fidput(Fid*);
+void *emalloc(int);
+void *erealloc(void*, int);
+int sendq(Queue*, void*);
+void *recvq(Queue*);
+void selectthread(void*);
+void connthread(void*);
+void listenthread(void*);
+void rewritehdr(Fcall*, uchar*);
+int tlisten(char*, char*);
+int taccept(int, char*);
+
+void
+usage(void)
+{
+ fprint(2, "usage: 9pserve [-u] address\n");
+ fprint(2, "\treads/writes 9P messages on stdin/stdout\n");
+ exits("usage");
+}
+
+void
+threadmain(int argc, char **argv)
+{
+ ARGBEGIN{
+ default:
+ usage();
+ case 'u':
+ isunix = 1;
+ break;
+ }ARGEND
+
+ if(argc != 1)
+ usage();
+
+ if((afd = announce(addr, adir)) < 0)
+ sysfatal("announce %s: %r", addr);
+
+ threadcreateidle(selectthread, nil, STACK);
+}
+
+void
+listenthread(void *arg)
+{
+ Conn *c;
+
+ USED(arg);
+ for(;;){
+ c = malloc(sizeof(Conn));
+ if(c == nil){
+ fprint(2, "out of memory\n");
+ sleep(60*1000);
+ continue;
+ }
+ c->fd = tlisten(adir, c->dir);
+ if(c->fd < 0){
+ fprint(2, "listen: %r\n");
+ close(afd);
+ free(c);
+ return;
+ }
+ threadcreate(connthread, c, STACK);
+ }
+}
+
+void
+err(Msg *m, char *ename)
+{
+ int n, nn;
+
+ m->rx.type = Rerror;
+ m->rx.ename = ename;
+ m->rx.tag = m->ctag;
+ n = sizeS2M(&m->rx);
+ m->rpkt = emalloc(n);
+ nn = convS2M(&m->rx, m->rpkt, n);
+ if(nn != n)
+ sysfatal("sizeS2M + convS2M disagree");
+ sendq(m->c->outq, m);
+}
+
+void
+connthread(void *arg)
+{
+ int i, fd;
+ Conn *c;
+ Hash *h;
+ Msg *m, *om;
+ Fid *f;
+
+ c = arg;
+ fd = taccept(c->fd, c->dir);
+ if(fd < 0){
+ fprint(2, "accept %s: %r\n", c->dir);
+ goto out;
+ }
+ close(c->fd);
+ c->fd = fd;
+ while((m = mread9p(c->fd)) != nil){
+ m->c = c;
+ c->nmsg++;
+ if(puthash(c->tag, m->tx.tag, m) < 0){
+ err(m, "duplicate tag");
+ continue;
+ }
+ switch(m->tx.type){
+ case Tflush:
+ if((m->oldm = gethash(c->tag, m->tx.oldtag)) == nil){
+ m->rx.tag = Rflush;
+ sendq(c->outq, m);
+ continue;
+ }
+ break;
+ case Tattach:
+ m->fid = fidnew(m->tx.fid);
+ if(puthash(c->fid, m->tx.fid, m->fid) < 0){
+ err(m, "duplicate fid");
+ continue;
+ }
+ m->fid->ref++;
+ break;
+ case Twalk:
+ if((m->fid = gethash(c->fid, m->tx.fid)) == nil){
+ err(m, "unknown fid");
+ continue;
+ }
+ if(m->tx.newfid == m->tx.fid){
+ m->fid->ref++;
+ m->newfid = m->fid;
+ }else{
+ m->newfid = fidnew(m->tx.newfid);
+ if(puthash(c->fid, m->tx.newfid, m->newfid) < 0){
+ err(m, "duplicate fid");
+ continue;
+ }
+ m->newfid->ref++;
+ }
+ break;
+ case Tauth:
+ if((m->afid = gethash(c->fid, m->tx.afid)) == nil){
+ err(m, "unknown fid");
+ continue;
+ }
+ m->fid = fidnew(m->tx.fid);
+ if(puthash(c->fid, m->tx.fid, m->fid) < 0){
+ err(m, "duplicate fid");
+ continue;
+ }
+ m->fid->ref++;
+ break;
+ case Topen:
+ case Tclunk:
+ case Tread:
+ case Twrite:
+ case Tstat:
+ case Twstat:
+ if((m->fid = gethash(c->fid, m->tx.fid)) == nil){
+ err(m, "unknown fid");
+ continue;
+ }
+ m->fid->ref++;
+ break;
+ }
+
+ /* have everything - translate and send */
+ m->c = c;
+ m->ctag = m->tx.tag;
+ m->tx.tag = m->tag;
+ if(m->fid)
+ m->tx.fid = m->fid->fid;
+ if(m->newfid)
+ m->tx.newfid = m->newfid->fid;
+ if(m->afid)
+ m->tx.afid = m->afid->fid;
+ if(m->oldm)
+ m->tx.oldtag = m->oldm->tag;
+ rewritehdr(&m->tx, m->tpkt);
+ sendq(outq, m);
+ while(c->nmsg >= MAXMSG){
+ c->inputstalled = 1;
+ recvp(c->inc);
+ }
+ }
+
+ /* flush all outstanding messages */
+ for(i=0; i<NHASH; i++){
+ for(h=c->tag[i]; h; h=h->next){
+ om = h->v;
+ m = msgnew();
+ m->internal = 1;
+ m->c = c;
+ m->tx.type = Tflush;
+ m->tx.tag = m->tag;
+ m->tx.oldtag = om->tag;
+ m->oldm = om;
+ om->ref++;
+ sendq(outq, m);
+ recvp(c->internal);
+ }
+ }
+
+ /* clunk all outstanding fids */
+ for(i=0; i<NHASH; i++){
+ for(h=c->fid[i]; h; h=h->next){
+ f = h->v;
+ m = msgnew();
+ m->internal = 1;
+ m->c = c;
+ m->tx.type = Tclunk;
+ m->tx.tag = m->tag;
+ m->tx.fid = f->fid;
+ m->fid = f;
+ f->ref++;
+ sendq(outq, m);
+ recvp(c->internal);
+ }
+ }
+
+out:
+ assert(c->nmsg == 0);
+ assert(c->nfid == 0);
+ close(c->fd);
+ free(c);
+}
+
+void
+connoutthread(void *arg)
+{
+ int err;
+ Conn *c;
+ Msg *m, *om;
+
+ c = arg;
+ while((m = recvq(c->outq)) != nil){
+ err = m->tx.type+1 != m->rx.type;
+ switch(m->tx.type){
+ case Tflush:
+ om = m->oldm;
+ if(delhash(om->c->tag, om->ctag, om) == 0)
+ msgput(om);
+ break;
+ case Tclunk:
+ if(delhash(m->c->fid, m->fid->cfid, m->fid) == 0)
+ fidput(m->fid);
+ break;
+ case Tauth:
+ if(err)
+ if(delhash(m->c->fid, m->afid->cfid, m->fid) == 0)
+ fidput(m->fid);
+ case Tattach:
+ if(err)
+ if(delhash(m->c->fid, m->fid->cfid, m->fid) == 0)
+ fidput(m->fid);
+ break;
+ case Twalk:
+ if(err && m->tx.fid != m->tx.newfid)
+ if(delhash(m->c->fid, m->newfid->cfid, m->newfid) == 0)
+ fidput(m->newfid);
+ break;
+ }
+ if(mwrite9p(c->fd, m) < 0)
+ fprint(2, "write error: %r\n");
+ if(delhash(m->c->tag, m->ctag, m) == 0)
+ msgput(m);
+ msgput(m);
+ if(c->inputstalled && c->nmsg < MAXMSG)
+ nbsendp(c->inc, 0);
+ }
+}
+
+void
+outputthread(void *arg)
+{
+ Msg *m;
+
+ USED(arg);
+
+ while((m = recvq(outq)) != nil){
+ if(mwrite9p(1, m) < 0)
+ sysfatal("output error: %r");
+ msgput(m);
+ }
+}
+
+void
+inputthread(void *arg)
+{
+ uchar *pkt;
+ int n, nn, tag;
+ Msg *m;
+
+ while((pkt = read9ppkt(0)) != nil){
+ n = GBIT32(pkt);
+ if(n < 7){
+ fprint(2, "short 9P packet\n");
+ free(pkt);
+ continue;
+ }
+ tag = GBIT16(pkt+5);
+ if((m = msgget(tag)) == nil){
+ fprint(2, "unexpected 9P response tag %d\n", tag);
+ free(pkt);
+ msgput(m);
+ continue;
+ }
+ if((nn = convM2S(pkt, n, &m->rx)) != n){
+ fprint(2, "bad packet - convM2S %d but %d\n", nn, n);
+ free(pkt);
+ msgput(m);
+ continue;
+ }
+ m->rpkt = pkt;
+ m->rx.tag = m->ctag;
+ rewritehdr(&m->rx, m->rpkt);
+ sendq(m->c->outq, m);
+ }
+}
+
+void*
+gethash(Hash **ht, uint n)
+{
+ Hash *h;
+
+ for(h=ht[n%NHASH]; h; h=h->next)
+ if(h->n == n)
+ return h->v;
+ return nil;
+}
+
+int
+delhash(Hash **ht, uint n, void *v)
+{
+ Hash *h, **l;
+
+ for(l=&ht[n%NHASH]; h=*l; l=&h->next)
+ if(h->n == n){
+ if(h->v != v)
+ fprint(2, "hash error\n");
+ *l = h->next;
+ free(h);
+ return 0;
+ }
+ return -1;
+}
+
+int
+puthash(Hash **ht, uint n, void *v)
+{
+ Hash *h;
+
+ if(gethash(ht, n))
+ return -1;
+ h = emalloc(sizeof(Hash));
+ h->next = ht[n%NHASH];
+ h->n = n;
+ h->v = v;
+ ht[n%NHASH] = h;
+ return 0;
+}
+
+Fid **fidtab;
+int nfidtab;
+Fid *freefid;
+
+Fid*
+fidnew(int cfid)
+{
+ Fid *f;
+
+ if(freefid == nil){
+ fidtab = erealloc(fidtab, nfidtab*sizeof(fidtab[0]));
+ fidtab[nfidtab] = emalloc(sizeof(Fid));
+ freefid = fidtab[nfidtab++];
+ }
+ f = freefid;
+ freefid = f->next;
+ f->cfid = f->cfid;
+ f->ref = 1;
+ return f;
+}
+
+void
+fidput(Fid *f)
+{
+ assert(f->ref > 0);
+ if(--f->ref > 0)
+ return;
+ f->next = freefid;
+ f->cfid = -1;
+ freefid = f;
+}
+
+Msg **msgtab;
+int nmsgtab;
+Msg *freemsg;
+
+Msg*
+msgnew(void)
+{
+ Msg *m;
+
+ if(freemsg == nil){
+ msgtab = erealloc(msgtab, nmsgtab*sizeof(msgtab[0]));
+ msgtab[nmsgtab] = emalloc(sizeof(Msg));
+ freemsg = msgtab[nmsgtab++];
+ }
+ m = freemsg;
+ freemsg = m->next;
+ m->ref = 1;
+ return m;
+}
+
+void
+msgput(Msg *m)
+{
+ assert(m->ref > 0);
+ if(--m->ref > 0)
+ return;
+ m->next = freemsg;
+ freemsg = m;
+}
+
+void*
+emalloc(int n)
+{
+ void *v;
+
+ v = mallocz(n, 1);
+ if(v == nil)
+ sysfatal("out of memory");
+ return v;
+}
+
+void*
+erealloc(void *v, int n)
+{
+ v = realloc(v, n);
+ if(v == nil)
+ sysfatal("out of memory");
+ return v;
+}
+
+typedef struct Qel Qel;
+struct Qel
+{
+ Qel *next;
+ void *p;
+};
+
+struct Queue
+{
+ int hungup;
+ QLock lk;
+ Rendez r;
+ Qel *head;
+ Qel *tail;
+};
+
+Queue*
+qalloc(void)
+{
+ Queue *q;
+
+ q = mallocz(sizeof(Queue), 1);
+ if(q == nil)
+ return nil;
+ q->r.l = &q->lk;
+ return q;
+}
+
+int
+sendq(Queue *q, void *p)
+{
+ Qel *e;
+
+ e = emalloc(sizeof(Qel));
+ qlock(&q->lk);
+ if(q->hungup){
+ werrstr("hungup queue");
+ qunlock(&q->lk);
+ return -1;
+ }
+ e->p = p;
+ e->next = nil;
+ if(q->head == nil)
+ q->head = e;
+ else
+ q->tail->next = e;
+ q->tail = e;
+ rwakeup(&q->r);
+ qunlock(&q->lk);
+ return 0;
+}
+
+void*
+recvq(Queue *q)
+{
+ void *p;
+ Qel *e;
+
+ qlock(&q->lk);
+ while(q->head == nil && !q->hungup)
+ rsleep(&q->r);
+ if(q->hungup){
+ qunlock(&q->lk);
+ return nil;
+ }
+ e = q->head;
+ q->head = e->next;
+ qunlock(&q->lk);
+ p = e->p;
+ free(e);
+ return p;
+}
blob - /dev/null
blob + 5acee7e5c19f947dbab2084fd43532f6d613a9b3 (mode 644)
--- /dev/null
+++ src/lib9/convD2M.c
+#include <u.h>
+#include <libc.h>
+#include <fcall.h>
+
+uint
+sizeD2M(Dir *d)
+{
+ char *sv[4];
+ int i, ns;
+
+ sv[0] = d->name;
+ sv[1] = d->uid;
+ sv[2] = d->gid;
+ sv[3] = d->muid;
+
+ ns = 0;
+ for(i = 0; i < 4; i++)
+ if(sv[i])
+ ns += strlen(sv[i]);
+
+ return STATFIXLEN + ns;
+}
+
+uint
+convD2M(Dir *d, uchar *buf, uint nbuf)
+{
+ uchar *p, *ebuf;
+ char *sv[4];
+ int i, ns, nsv[4], ss;
+
+ if(nbuf < BIT16SZ)
+ return 0;
+
+ p = buf;
+ ebuf = buf + nbuf;
+
+ sv[0] = d->name;
+ sv[1] = d->uid;
+ sv[2] = d->gid;
+ sv[3] = d->muid;
+
+ ns = 0;
+ for(i = 0; i < 4; i++){
+ if(sv[i])
+ nsv[i] = strlen(sv[i]);
+ else
+ nsv[i] = 0;
+ ns += nsv[i];
+ }
+
+ ss = STATFIXLEN + ns;
+
+ /* set size befor erroring, so user can know how much is needed */
+ /* note that length excludes count field itself */
+ PBIT16(p, ss-BIT16SZ);
+ p += BIT16SZ;
+
+ if(ss > nbuf)
+ return BIT16SZ;
+
+ PBIT16(p, d->type);
+ p += BIT16SZ;
+ PBIT32(p, d->dev);
+ p += BIT32SZ;
+ PBIT8(p, d->qid.type);
+ p += BIT8SZ;
+ PBIT32(p, d->qid.vers);
+ p += BIT32SZ;
+ PBIT64(p, d->qid.path);
+ p += BIT64SZ;
+ PBIT32(p, d->mode);
+ p += BIT32SZ;
+ PBIT32(p, d->atime);
+ p += BIT32SZ;
+ PBIT32(p, d->mtime);
+ p += BIT32SZ;
+ PBIT64(p, d->length);
+ p += BIT64SZ;
+
+ for(i = 0; i < 4; i++){
+ ns = nsv[i];
+ if(p + ns + BIT16SZ > ebuf)
+ return 0;
+ PBIT16(p, ns);
+ p += BIT16SZ;
+ if(ns)
+ memmove(p, sv[i], ns);
+ p += ns;
+ }
+
+ if(ss != p - buf)
+ return 0;
+
+ return p - buf;
+}
blob - /dev/null
blob + 6f4b4bd935bef68910883fe15680609ff24489f0 (mode 644)
--- /dev/null
+++ src/lib9/convM2D.c
+#include <u.h>
+#include <libc.h>
+#include <fcall.h>
+
+int
+statcheck(uchar *buf, uint nbuf)
+{
+ uchar *ebuf;
+ int i;
+
+ ebuf = buf + nbuf;
+
+ if(nbuf < STATFIXLEN || nbuf != BIT16SZ + GBIT16(buf))
+ return -1;
+
+ buf += STATFIXLEN - 4 * BIT16SZ;
+
+ for(i = 0; i < 4; i++){
+ if(buf + BIT16SZ > ebuf)
+ return -1;
+ buf += BIT16SZ + GBIT16(buf);
+ }
+
+ if(buf != ebuf)
+ return -1;
+
+ return 0;
+}
+
+static char nullstring[] = "";
+
+uint
+convM2D(uchar *buf, uint nbuf, Dir *d, char *strs)
+{
+ uchar *p, *ebuf;
+ char *sv[4];
+ int i, ns;
+
+ if(nbuf < STATFIXLEN)
+ return 0;
+
+ p = buf;
+ ebuf = buf + nbuf;
+
+ p += BIT16SZ; /* ignore size */
+ d->type = GBIT16(p);
+ p += BIT16SZ;
+ d->dev = GBIT32(p);
+ p += BIT32SZ;
+ d->qid.type = GBIT8(p);
+ p += BIT8SZ;
+ d->qid.vers = GBIT32(p);
+ p += BIT32SZ;
+ d->qid.path = GBIT64(p);
+ p += BIT64SZ;
+ d->mode = GBIT32(p);
+ p += BIT32SZ;
+ d->atime = GBIT32(p);
+ p += BIT32SZ;
+ d->mtime = GBIT32(p);
+ p += BIT32SZ;
+ d->length = GBIT64(p);
+ p += BIT64SZ;
+
+ for(i = 0; i < 4; i++){
+ if(p + BIT16SZ > ebuf)
+ return 0;
+ ns = GBIT16(p);
+ p += BIT16SZ;
+ if(p + ns > ebuf)
+ return 0;
+ if(strs){
+ sv[i] = strs;
+ memmove(strs, p, ns);
+ strs += ns;
+ *strs++ = '\0';
+ }
+ p += ns;
+ }
+
+ if(strs){
+ d->name = sv[0];
+ d->uid = sv[1];
+ d->gid = sv[2];
+ d->muid = sv[3];
+ }else{
+ d->name = nullstring;
+ d->uid = nullstring;
+ d->gid = nullstring;
+ d->muid = nullstring;
+ }
+
+ return p - buf;
+}
blob - /dev/null
blob + fcdcd42d60f6f0d533747aab47b01af7651cf926 (mode 644)
--- /dev/null
+++ src/lib9/convM2S.c
+#include <u.h>
+#include <libc.h>
+#include <fcall.h>
+
+static
+uchar*
+gstring(uchar *p, uchar *ep, char **s)
+{
+ uint n;
+
+ if(p+BIT16SZ > ep)
+ return nil;
+ n = GBIT16(p);
+ p += BIT16SZ - 1;
+ if(p+n+1 > ep)
+ return nil;
+ /* move it down, on top of count, to make room for '\0' */
+ memmove(p, p + 1, n);
+ p[n] = '\0';
+ *s = (char*)p;
+ p += n+1;
+ return p;
+}
+
+static
+uchar*
+gqid(uchar *p, uchar *ep, Qid *q)
+{
+ if(p+QIDSZ > ep)
+ return nil;
+ q->type = GBIT8(p);
+ p += BIT8SZ;
+ q->vers = GBIT32(p);
+ p += BIT32SZ;
+ q->path = GBIT64(p);
+ p += BIT64SZ;
+ return p;
+}
+
+/*
+ * no syntactic checks.
+ * three causes for error:
+ * 1. message size field is incorrect
+ * 2. input buffer too short for its own data (counts too long, etc.)
+ * 3. too many names or qids
+ * gqid() and gstring() return nil if they would reach beyond buffer.
+ * main switch statement checks range and also can fall through
+ * to test at end of routine.
+ */
+uint
+convM2S(uchar *ap, uint nap, Fcall *f)
+{
+ uchar *p, *ep;
+ uint i, size;
+
+ p = ap;
+ ep = p + nap;
+
+ if(p+BIT32SZ+BIT8SZ+BIT16SZ > ep)
+ return 0;
+ size = GBIT32(p);
+ p += BIT32SZ;
+
+ if(size < BIT32SZ+BIT8SZ+BIT16SZ)
+ return 0;
+
+ f->type = GBIT8(p);
+ p += BIT8SZ;
+ f->tag = GBIT16(p);
+ p += BIT16SZ;
+
+ switch(f->type)
+ {
+ default:
+ return 0;
+
+ case Tversion:
+ if(p+BIT32SZ > ep)
+ return 0;
+ f->msize = GBIT32(p);
+ p += BIT32SZ;
+ p = gstring(p, ep, &f->version);
+ break;
+
+ case Tflush:
+ if(p+BIT16SZ > ep)
+ return 0;
+ f->oldtag = GBIT16(p);
+ p += BIT16SZ;
+ break;
+
+ case Tauth:
+ if(p+BIT32SZ > ep)
+ return 0;
+ f->afid = GBIT32(p);
+ p += BIT32SZ;
+ p = gstring(p, ep, &f->uname);
+ if(p == nil)
+ break;
+ p = gstring(p, ep, &f->aname);
+ if(p == nil)
+ break;
+ break;
+
+ case Tattach:
+ if(p+BIT32SZ > ep)
+ return 0;
+ f->fid = GBIT32(p);
+ p += BIT32SZ;
+ if(p+BIT32SZ > ep)
+ return 0;
+ f->afid = GBIT32(p);
+ p += BIT32SZ;
+ p = gstring(p, ep, &f->uname);
+ if(p == nil)
+ break;
+ p = gstring(p, ep, &f->aname);
+ if(p == nil)
+ break;
+ break;
+
+ case Twalk:
+ if(p+BIT32SZ+BIT32SZ+BIT16SZ > ep)
+ return 0;
+ f->fid = GBIT32(p);
+ p += BIT32SZ;
+ f->newfid = GBIT32(p);
+ p += BIT32SZ;
+ f->nwname = GBIT16(p);
+ p += BIT16SZ;
+ if(f->nwname > MAXWELEM)
+ return 0;
+ for(i=0; i<f->nwname; i++){
+ p = gstring(p, ep, &f->wname[i]);
+ if(p == nil)
+ break;
+ }
+ break;
+
+ case Topen:
+ if(p+BIT32SZ+BIT8SZ > ep)
+ return 0;
+ f->fid = GBIT32(p);
+ p += BIT32SZ;
+ f->mode = GBIT8(p);
+ p += BIT8SZ;
+ break;
+
+ case Tcreate:
+ if(p+BIT32SZ > ep)
+ return 0;
+ f->fid = GBIT32(p);
+ p += BIT32SZ;
+ p = gstring(p, ep, &f->name);
+ if(p == nil)
+ break;
+ if(p+BIT32SZ+BIT8SZ > ep)
+ return 0;
+ f->perm = GBIT32(p);
+ p += BIT32SZ;
+ f->mode = GBIT8(p);
+ p += BIT8SZ;
+ break;
+
+ case Tread:
+ if(p+BIT32SZ+BIT64SZ+BIT32SZ > ep)
+ return 0;
+ f->fid = GBIT32(p);
+ p += BIT32SZ;
+ f->offset = GBIT64(p);
+ p += BIT64SZ;
+ f->count = GBIT32(p);
+ p += BIT32SZ;
+ break;
+
+ case Twrite:
+ if(p+BIT32SZ+BIT64SZ+BIT32SZ > ep)
+ return 0;
+ f->fid = GBIT32(p);
+ p += BIT32SZ;
+ f->offset = GBIT64(p);
+ p += BIT64SZ;
+ f->count = GBIT32(p);
+ p += BIT32SZ;
+ if(p+f->count > ep)
+ return 0;
+ f->data = (char*)p;
+ p += f->count;
+ break;
+
+ case Tclunk:
+ case Tremove:
+ if(p+BIT32SZ > ep)
+ return 0;
+ f->fid = GBIT32(p);
+ p += BIT32SZ;
+ break;
+
+ case Tstat:
+ if(p+BIT32SZ > ep)
+ return 0;
+ f->fid = GBIT32(p);
+ p += BIT32SZ;
+ break;
+
+ case Twstat:
+ if(p+BIT32SZ+BIT16SZ > ep)
+ return 0;
+ f->fid = GBIT32(p);
+ p += BIT32SZ;
+ f->nstat = GBIT16(p);
+ p += BIT16SZ;
+ if(p+f->nstat > ep)
+ return 0;
+ f->stat = p;
+ p += f->nstat;
+ break;
+
+/*
+ */
+ case Rversion:
+ if(p+BIT32SZ > ep)
+ return 0;
+ f->msize = GBIT32(p);
+ p += BIT32SZ;
+ p = gstring(p, ep, &f->version);
+ break;
+
+ case Rerror:
+ p = gstring(p, ep, &f->ename);
+ break;
+
+ case Rflush:
+ break;
+
+ case Rauth:
+ p = gqid(p, ep, &f->aqid);
+ if(p == nil)
+ break;
+ break;
+
+ case Rattach:
+ p = gqid(p, ep, &f->qid);
+ if(p == nil)
+ break;
+ break;
+
+ case Rwalk:
+ if(p+BIT16SZ > ep)
+ return 0;
+ f->nwqid = GBIT16(p);
+ p += BIT16SZ;
+ if(f->nwqid > MAXWELEM)
+ return 0;
+ for(i=0; i<f->nwqid; i++){
+ p = gqid(p, ep, &f->wqid[i]);
+ if(p == nil)
+ break;
+ }
+ break;
+
+ case Ropen:
+ case Rcreate:
+ p = gqid(p, ep, &f->qid);
+ if(p == nil)
+ break;
+ if(p+BIT32SZ > ep)
+ return 0;
+ f->iounit = GBIT32(p);
+ p += BIT32SZ;
+ break;
+
+ case Rread:
+ if(p+BIT32SZ > ep)
+ return 0;
+ f->count = GBIT32(p);
+ p += BIT32SZ;
+ if(p+f->count > ep)
+ return 0;
+ f->data = (char*)p;
+ p += f->count;
+ break;
+
+ case Rwrite:
+ if(p+BIT32SZ > ep)
+ return 0;
+ f->count = GBIT32(p);
+ p += BIT32SZ;
+ break;
+
+ case Rclunk:
+ case Rremove:
+ break;
+
+ case Rstat:
+ if(p+BIT16SZ > ep)
+ return 0;
+ f->nstat = GBIT16(p);
+ p += BIT16SZ;
+ if(p+f->nstat > ep)
+ return 0;
+ f->stat = p;
+ p += f->nstat;
+ break;
+
+ case Rwstat:
+ break;
+ }
+
+ if(p==nil || p>ep)
+ return 0;
+ if(ap+size == p)
+ return size;
+ return 0;
+}
blob - /dev/null
blob + 9acdcfa567fbb744c66980c00bea5397ad895f98 (mode 644)
--- /dev/null
+++ src/lib9/convS2M.c
+#include <u.h>
+#include <libc.h>
+#include <fcall.h>
+
+static
+uchar*
+pstring(uchar *p, char *s)
+{
+ uint n;
+
+ if(s == nil){
+ PBIT16(p, 0);
+ p += BIT16SZ;
+ return p;
+ }
+
+ n = strlen(s);
+ PBIT16(p, n);
+ p += BIT16SZ;
+ memmove(p, s, n);
+ p += n;
+ return p;
+}
+
+static
+uchar*
+pqid(uchar *p, Qid *q)
+{
+ PBIT8(p, q->type);
+ p += BIT8SZ;
+ PBIT32(p, q->vers);
+ p += BIT32SZ;
+ PBIT64(p, q->path);
+ p += BIT64SZ;
+ return p;
+}
+
+static
+uint
+stringsz(char *s)
+{
+ if(s == nil)
+ return BIT16SZ;
+
+ return BIT16SZ+strlen(s);
+}
+
+uint
+sizeS2M(Fcall *f)
+{
+ uint n;
+ int i;
+
+ n = 0;
+ n += BIT32SZ; /* size */
+ n += BIT8SZ; /* type */
+ n += BIT16SZ; /* tag */
+
+ switch(f->type)
+ {
+ default:
+ return 0;
+
+ case Tversion:
+ n += BIT32SZ;
+ n += stringsz(f->version);
+ break;
+
+ case Tflush:
+ n += BIT16SZ;
+ break;
+
+ case Tauth:
+ n += BIT32SZ;
+ n += stringsz(f->uname);
+ n += stringsz(f->aname);
+ break;
+
+ case Tattach:
+ n += BIT32SZ;
+ n += BIT32SZ;
+ n += stringsz(f->uname);
+ n += stringsz(f->aname);
+ break;
+
+ case Twalk:
+ n += BIT32SZ;
+ n += BIT32SZ;
+ n += BIT16SZ;
+ for(i=0; i<f->nwname; i++)
+ n += stringsz(f->wname[i]);
+ break;
+
+ case Topen:
+ n += BIT32SZ;
+ n += BIT8SZ;
+ break;
+
+ case Tcreate:
+ n += BIT32SZ;
+ n += stringsz(f->name);
+ n += BIT32SZ;
+ n += BIT8SZ;
+ break;
+
+ case Tread:
+ n += BIT32SZ;
+ n += BIT64SZ;
+ n += BIT32SZ;
+ break;
+
+ case Twrite:
+ n += BIT32SZ;
+ n += BIT64SZ;
+ n += BIT32SZ;
+ n += f->count;
+ break;
+
+ case Tclunk:
+ case Tremove:
+ n += BIT32SZ;
+ break;
+
+ case Tstat:
+ n += BIT32SZ;
+ break;
+
+ case Twstat:
+ n += BIT32SZ;
+ n += BIT16SZ;
+ n += f->nstat;
+ break;
+/*
+ */
+
+ case Rversion:
+ n += BIT32SZ;
+ n += stringsz(f->version);
+ break;
+
+ case Rerror:
+ n += stringsz(f->ename);
+ break;
+
+ case Rflush:
+ break;
+
+ case Rauth:
+ n += QIDSZ;
+ break;
+
+ case Rattach:
+ n += QIDSZ;
+ break;
+
+ case Rwalk:
+ n += BIT16SZ;
+ n += f->nwqid*QIDSZ;
+ break;
+
+ case Ropen:
+ case Rcreate:
+ n += QIDSZ;
+ n += BIT32SZ;
+ break;
+
+ case Rread:
+ n += BIT32SZ;
+ n += f->count;
+ break;
+
+ case Rwrite:
+ n += BIT32SZ;
+ break;
+
+ case Rclunk:
+ break;
+
+ case Rremove:
+ break;
+
+ case Rstat:
+ n += BIT16SZ;
+ n += f->nstat;
+ break;
+
+ case Rwstat:
+ break;
+ }
+ return n;
+}
+
+uint
+convS2M(Fcall *f, uchar *ap, uint nap)
+{
+ uchar *p;
+ uint i, size;
+
+ size = sizeS2M(f);
+ if(size == 0)
+ return 0;
+ if(size > nap)
+ return 0;
+
+ p = (uchar*)ap;
+
+ PBIT32(p, size);
+ p += BIT32SZ;
+ PBIT8(p, f->type);
+ p += BIT8SZ;
+ PBIT16(p, f->tag);
+ p += BIT16SZ;
+
+ switch(f->type)
+ {
+ default:
+ return 0;
+
+ case Tversion:
+ PBIT32(p, f->msize);
+ p += BIT32SZ;
+ p = pstring(p, f->version);
+ break;
+
+ case Tflush:
+ PBIT16(p, f->oldtag);
+ p += BIT16SZ;
+ break;
+
+ case Tauth:
+ PBIT32(p, f->afid);
+ p += BIT32SZ;
+ p = pstring(p, f->uname);
+ p = pstring(p, f->aname);
+ break;
+
+ case Tattach:
+ PBIT32(p, f->fid);
+ p += BIT32SZ;
+ PBIT32(p, f->afid);
+ p += BIT32SZ;
+ p = pstring(p, f->uname);
+ p = pstring(p, f->aname);
+ break;
+
+ case Twalk:
+ PBIT32(p, f->fid);
+ p += BIT32SZ;
+ PBIT32(p, f->newfid);
+ p += BIT32SZ;
+ PBIT16(p, f->nwname);
+ p += BIT16SZ;
+ if(f->nwname > MAXWELEM)
+ return 0;
+ for(i=0; i<f->nwname; i++)
+ p = pstring(p, f->wname[i]);
+ break;
+
+ case Topen:
+ PBIT32(p, f->fid);
+ p += BIT32SZ;
+ PBIT8(p, f->mode);
+ p += BIT8SZ;
+ break;
+
+ case Tcreate:
+ PBIT32(p, f->fid);
+ p += BIT32SZ;
+ p = pstring(p, f->name);
+ PBIT32(p, f->perm);
+ p += BIT32SZ;
+ PBIT8(p, f->mode);
+ p += BIT8SZ;
+ break;
+
+ case Tread:
+ PBIT32(p, f->fid);
+ p += BIT32SZ;
+ PBIT64(p, f->offset);
+ p += BIT64SZ;
+ PBIT32(p, f->count);
+ p += BIT32SZ;
+ break;
+
+ case Twrite:
+ PBIT32(p, f->fid);
+ p += BIT32SZ;
+ PBIT64(p, f->offset);
+ p += BIT64SZ;
+ PBIT32(p, f->count);
+ p += BIT32SZ;
+ memmove(p, f->data, f->count);
+ p += f->count;
+ break;
+
+ case Tclunk:
+ case Tremove:
+ PBIT32(p, f->fid);
+ p += BIT32SZ;
+ break;
+
+ case Tstat:
+ PBIT32(p, f->fid);
+ p += BIT32SZ;
+ break;
+
+ case Twstat:
+ PBIT32(p, f->fid);
+ p += BIT32SZ;
+ PBIT16(p, f->nstat);
+ p += BIT16SZ;
+ memmove(p, f->stat, f->nstat);
+ p += f->nstat;
+ break;
+/*
+ */
+
+ case Rversion:
+ PBIT32(p, f->msize);
+ p += BIT32SZ;
+ p = pstring(p, f->version);
+ break;
+
+ case Rerror:
+ p = pstring(p, f->ename);
+ break;
+
+ case Rflush:
+ break;
+
+ case Rauth:
+ p = pqid(p, &f->aqid);
+ break;
+
+ case Rattach:
+ p = pqid(p, &f->qid);
+ break;
+
+ case Rwalk:
+ PBIT16(p, f->nwqid);
+ p += BIT16SZ;
+ if(f->nwqid > MAXWELEM)
+ return 0;
+ for(i=0; i<f->nwqid; i++)
+ p = pqid(p, &f->wqid[i]);
+ break;
+
+ case Ropen:
+ case Rcreate:
+ p = pqid(p, &f->qid);
+ PBIT32(p, f->iounit);
+ p += BIT32SZ;
+ break;
+
+ case Rread:
+ PBIT32(p, f->count);
+ p += BIT32SZ;
+ memmove(p, f->data, f->count);
+ p += f->count;
+ break;
+
+ case Rwrite:
+ PBIT32(p, f->count);
+ p += BIT32SZ;
+ break;
+
+ case Rclunk:
+ break;
+
+ case Rremove:
+ break;
+
+ case Rstat:
+ PBIT16(p, f->nstat);
+ p += BIT16SZ;
+ memmove(p, f->stat, f->nstat);
+ p += f->nstat;
+ break;
+
+ case Rwstat:
+ break;
+ }
+ if(size != p-ap)
+ return 0;
+ return size;
+}
blob - /dev/null
blob + 4eef88dece82b5c102c1a4deb66119bfaff3e2a3 (mode 644)
--- /dev/null
+++ src/lib9/fcallfmt.c
+#include <u.h>
+#include <libc.h>
+#include <fcall.h>
+
+static uint dumpsome(char*, char*, char*, long);
+static void fdirconv(char*, char*, Dir*);
+static char *qidtype(char*, uchar);
+
+#define QIDFMT "(%.16llux %lud %s)"
+
+int
+fcallfmt(Fmt *fmt)
+{
+ Fcall *f;
+ int fid, type, tag, i;
+ char buf[512], tmp[200];
+ char *p, *e;
+ Dir *d;
+ Qid *q;
+
+ e = buf+sizeof(buf);
+ f = va_arg(fmt->args, Fcall*);
+ type = f->type;
+ fid = f->fid;
+ tag = f->tag;
+ switch(type){
+ case Tversion: /* 100 */
+ seprint(buf, e, "Tversion tag %ud msize %ud version '%s'", tag, f->msize, f->version);
+ break;
+ case Rversion:
+ seprint(buf, e, "Rversion tag %ud msize %ud version '%s'", tag, f->msize, f->version);
+ break;
+ case Tauth: /* 102 */
+ seprint(buf, e, "Tauth tag %ud afid %d uname %s aname %s", tag,
+ f->afid, f->uname, f->aname);
+ break;
+ case Rauth:
+ seprint(buf, e, "Rauth tag %ud qid " QIDFMT, tag,
+ f->aqid.path, f->aqid.vers, qidtype(tmp, f->aqid.type));
+ break;
+ case Tattach: /* 104 */
+ seprint(buf, e, "Tattach tag %ud fid %d afid %d uname %s aname %s", tag,
+ fid, f->afid, f->uname, f->aname);
+ break;
+ case Rattach:
+ seprint(buf, e, "Rattach tag %ud qid " QIDFMT, tag,
+ f->qid.path, f->qid.vers, qidtype(tmp, f->qid.type));
+ break;
+ case Rerror: /* 107; 106 (Terror) illegal */
+ seprint(buf, e, "Rerror tag %ud ename %s", tag, f->ename);
+ break;
+ case Tflush: /* 108 */
+ seprint(buf, e, "Tflush tag %ud oldtag %ud", tag, f->oldtag);
+ break;
+ case Rflush:
+ seprint(buf, e, "Rflush tag %ud", tag);
+ break;
+ case Twalk: /* 110 */
+ p = seprint(buf, e, "Twalk tag %ud fid %d newfid %d nwname %d ", tag, fid, f->newfid, f->nwname);
+ if(f->nwname <= MAXWELEM)
+ for(i=0; i<f->nwname; i++)
+ p = seprint(p, e, "%d:%s ", i, f->wname[i]);
+ break;
+ case Rwalk:
+ p = seprint(buf, e, "Rwalk tag %ud nwqid %ud ", tag, f->nwqid);
+ if(f->nwqid <= MAXWELEM)
+ for(i=0; i<f->nwqid; i++){
+ q = &f->wqid[i];
+ p = seprint(p, e, "%d:" QIDFMT " ", i,
+ q->path, q->vers, qidtype(tmp, q->type));
+ }
+ break;
+ case Topen: /* 112 */
+ seprint(buf, e, "Topen tag %ud fid %ud mode %d", tag, fid, f->mode);
+ break;
+ case Ropen:
+ seprint(buf, e, "Ropen tag %ud qid " QIDFMT " iounit %ud ", tag,
+ f->qid.path, f->qid.vers, qidtype(tmp, f->qid.type), f->iounit);
+ break;
+ case Tcreate: /* 114 */
+ seprint(buf, e, "Tcreate tag %ud fid %ud name %s perm %M mode %d", tag, fid, f->name, (ulong)f->perm, f->mode);
+ break;
+ case Rcreate:
+ seprint(buf, e, "Rcreate tag %ud qid " QIDFMT " iounit %ud ", tag,
+ f->qid.path, f->qid.vers, qidtype(tmp, f->qid.type), f->iounit);
+ break;
+ case Tread: /* 116 */
+ seprint(buf, e, "Tread tag %ud fid %d offset %lld count %ud",
+ tag, fid, f->offset, f->count);
+ break;
+ case Rread:
+ p = seprint(buf, e, "Rread tag %ud count %ud ", tag, f->count);
+ dumpsome(p, e, f->data, f->count);
+ break;
+ case Twrite: /* 118 */
+ p = seprint(buf, e, "Twrite tag %ud fid %d offset %lld count %ud ",
+ tag, fid, f->offset, f->count);
+ dumpsome(p, e, f->data, f->count);
+ break;
+ case Rwrite:
+ seprint(buf, e, "Rwrite tag %ud count %ud", tag, f->count);
+ break;
+ case Tclunk: /* 120 */
+ seprint(buf, e, "Tclunk tag %ud fid %ud", tag, fid);
+ break;
+ case Rclunk:
+ seprint(buf, e, "Rclunk tag %ud", tag);
+ break;
+ case Tremove: /* 122 */
+ seprint(buf, e, "Tremove tag %ud fid %ud", tag, fid);
+ break;
+ case Rremove:
+ seprint(buf, e, "Rremove tag %ud", tag);
+ break;
+ case Tstat: /* 124 */
+ seprint(buf, e, "Tstat tag %ud fid %ud", tag, fid);
+ break;
+ case Rstat:
+ p = seprint(buf, e, "Rstat tag %ud ", tag);
+ if(f->nstat > sizeof tmp)
+ seprint(p, e, " stat(%d bytes)", f->nstat);
+ else{
+ d = (Dir*)tmp;
+ convM2D(f->stat, f->nstat, d, (char*)(d+1));
+ seprint(p, e, " stat ");
+ fdirconv(p+6, e, d);
+ }
+ break;
+ case Twstat: /* 126 */
+ p = seprint(buf, e, "Twstat tag %ud fid %ud", tag, fid);
+ if(f->nstat > sizeof tmp)
+ seprint(p, e, " stat(%d bytes)", f->nstat);
+ else{
+ d = (Dir*)tmp;
+ convM2D(f->stat, f->nstat, d, (char*)(d+1));
+ seprint(p, e, " stat ");
+ fdirconv(p+6, e, d);
+ }
+ break;
+ case Rwstat:
+ seprint(buf, e, "Rwstat tag %ud", tag);
+ break;
+ default:
+ seprint(buf, e, "unknown type %d", type);
+ }
+ return fmtstrcpy(fmt, buf);
+}
+
+static char*
+qidtype(char *s, uchar t)
+{
+ char *p;
+
+ p = s;
+ if(t & QTDIR)
+ *p++ = 'd';
+ if(t & QTAPPEND)
+ *p++ = 'a';
+ if(t & QTEXCL)
+ *p++ = 'l';
+ if(t & QTAUTH)
+ *p++ = 'A';
+ *p = '\0';
+ return s;
+}
+
+int
+dirfmt(Fmt *fmt)
+{
+ char buf[160];
+
+ fdirconv(buf, buf+sizeof buf, va_arg(fmt->args, Dir*));
+ return fmtstrcpy(fmt, buf);
+}
+
+static void
+fdirconv(char *buf, char *e, Dir *d)
+{
+ char tmp[16];
+
+ seprint(buf, e, "'%s' '%s' '%s' '%s' "
+ "q " QIDFMT " m %#luo "
+ "at %ld mt %ld l %lld "
+ "t %d d %d",
+ d->name, d->uid, d->gid, d->muid,
+ d->qid.path, d->qid.vers, qidtype(tmp, d->qid.type), d->mode,
+ d->atime, d->mtime, d->length,
+ d->type, d->dev);
+}
+
+/*
+ * dump out count (or DUMPL, if count is bigger) bytes from
+ * buf to ans, as a string if they are all printable,
+ * else as a series of hex bytes
+ */
+#define DUMPL 64
+
+static uint
+dumpsome(char *ans, char *e, char *buf, long count)
+{
+ int i, printable;
+ char *p;
+
+ if(buf == nil){
+ seprint(ans, e, "<no data>");
+ return strlen(ans);
+ }
+ printable = 1;
+ if(count > DUMPL)
+ count = DUMPL;
+ for(i=0; i<count && printable; i++)
+ if((buf[i]<32 && buf[i] !='\n' && buf[i] !='\t') || (uchar)buf[i]>127)
+ printable = 0;
+ p = ans;
+ *p++ = '\'';
+ if(printable){
+ if(count > e-p-2)
+ count = e-p-2;
+ memmove(p, buf, count);
+ p += count;
+ }else{
+ if(2*count > e-p-2)
+ count = (e-p-2)/2;
+ for(i=0; i<count; i++){
+ if(i>0 && i%4==0)
+ *p++ = ' ';
+ sprint(p, "%2.2ux", buf[i]);
+ p += 2;
+ }
+ }
+ *p++ = '\'';
+ *p = 0;
+ return p - ans;
+}
blob - /dev/null
blob + 9e90ec5d6c668675519d2dd4f000580839be8066 (mode 644)
--- /dev/null
+++ src/lib9/read9pmsg.c
+#include <u.h>
+#include <libc.h>
+#include <fcall.h>
+
+int
+read9pmsg(int fd, void *abuf, uint n)
+{
+ int m, len;
+ uchar *buf;
+
+ buf = abuf;
+
+ /* read count */
+ m = readn(fd, buf, BIT32SZ);
+ if(m != BIT32SZ){
+ if(m < 0)
+ return -1;
+ return 0;
+ }
+
+ len = GBIT32(buf);
+ if(len <= BIT32SZ || len > n){
+ werrstr("bad length in 9P2000 message header");
+ return -1;
+ }
+ len -= BIT32SZ;
+ m = readn(fd, buf+BIT32SZ, len);
+ if(m < len)
+ return 0;
+ return BIT32SZ+m;
+}
blob - /dev/null
blob + de348d126b2bed47cefa2f493e03f8f1e23c5b19 (mode 644)
--- /dev/null
+++ src/libfs/COPYRIGHT
+
+This software was developed as part of a project at MIT:
+ /sys/src/libfs/* except dirread.c
+ /sys/include/fs.h
+
+Copyright (c) 2003 Russ Cox,
+ Massachusetts Institute of Technology
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
blob - /dev/null
blob + 23388ae3e74836774f8d27b8309836abb03e0ce2 (mode 644)
--- /dev/null
+++ src/libfs/close.c
+/* Copyright (C) 2003 Russ Cox, Massachusetts Institute of Technology */
+/* See COPYRIGHT */
+
+#include <u.h>
+#include <libc.h>
+#include <fcall.h>
+#include <fs.h>
+#include "fsimpl.h"
+
+static void
+fidclunk(Fid *fid)
+{
+ Fcall tx, rx;
+
+ tx.type = Tclunk;
+ tx.fid = fid->fid;
+ fsrpc(fid->fs, &tx, &rx, 0);
+ _fsputfid(fid);
+}
+
+void
+fsclose(Fid *fid)
+{
+ /* maybe someday there will be a ref count */
+ fidclunk(fid);
+}
blob - /dev/null
blob + ef52a2a8ca4bee13d65e028f533b22591ff30c65 (mode 644)
--- /dev/null
+++ src/libfs/create.c
+#include <u.h>
+#include <libc.h>
+#include <fcall.h>
+#include <fs.h>
+#include "fsimpl.h"
+
+Fid*
+fscreate(Fsys *fs, char *name, int mode, ulong perm)
+{
+ Fid *fid;
+ Fcall tx, rx;
+
+ if((fid = fswalk(fs->root, name)) == nil)
+ return nil;
+ tx.type = Tcreate;
+ tx.fid = fid->fid;
+ tx.mode = mode;
+ tx.perm = perm;
+ if(fsrpc(fs, &tx, &rx, 0) < 0){
+ fsclose(fid);
+ return nil;
+ }
+ fid->mode = mode;
+ return fid;
+}
blob - /dev/null
blob + 0ca4064542ef8c8f41aa98d736f11e005eb87d80 (mode 644)
--- /dev/null
+++ src/libfs/dirread.c
+/* Mostly copied from Plan 9's libc. */
+
+#include <u.h>
+#include <libc.h>
+#include <fcall.h>
+#include <fs.h>
+
+static
+long
+dirpackage(uchar *buf, long ts, Dir **d)
+{
+ char *s;
+ long ss, i, n, nn, m;
+
+ *d = nil;
+ if(ts <= 0)
+ return 0;
+
+ /*
+ * first find number of all stats, check they look like stats, & size all associated strings
+ */
+ ss = 0;
+ n = 0;
+ for(i = 0; i < ts; i += m){
+ m = BIT16SZ + GBIT16(&buf[i]);
+ if(statcheck(&buf[i], m) < 0)
+ break;
+ ss += m;
+ n++;
+ }
+
+ if(i != ts)
+ return -1;
+
+ *d = malloc(n * sizeof(Dir) + ss);
+ if(*d == nil)
+ return -1;
+
+ /*
+ * then convert all buffers
+ */
+ s = (char*)*d + n * sizeof(Dir);
+ nn = 0;
+ for(i = 0; i < ts; i += m){
+ m = BIT16SZ + GBIT16((uchar*)&buf[i]);
+ if(nn >= n || convM2D(&buf[i], m, *d + nn, s) != m){
+ free(*d);
+ *d = nil;
+ return -1;
+ }
+ nn++;
+ s += m;
+ }
+
+ return nn;
+}
+
+long
+fsdirread(Fid *fid, Dir **d)
+{
+ uchar *buf;
+ long ts;
+
+ buf = malloc(DIRMAX);
+ if(buf == nil)
+ return -1;
+ ts = fsread(fid, buf, DIRMAX);
+ if(ts >= 0)
+ ts = dirpackage(buf, ts, d);
+ free(buf);
+ return ts;
+}
+
+long
+fsdirreadall(Fid *fid, Dir **d)
+{
+ uchar *buf, *nbuf;
+ long n, ts;
+
+ buf = nil;
+ ts = 0;
+ for(;;){
+ nbuf = realloc(buf, ts+DIRMAX);
+ if(nbuf == nil){
+ free(buf);
+ return -1;
+ }
+ buf = nbuf;
+ n = fsread(fid, buf+ts, DIRMAX);
+ if(n <= 0)
+ break;
+ ts += n;
+ }
+ if(ts >= 0)
+ ts = dirpackage(buf, ts, d);
+ free(buf);
+ if(ts == 0 && n < 0)
+ return -1;
+ return ts;
+}
blob - /dev/null
blob + 985071c1c69ce4a6f45e996f624889f647ffea85 (mode 644)
--- /dev/null
+++ src/libfs/fs.c
+/* Copyright (C) 2003 Russ Cox, Massachusetts Institute of Technology */
+/* See COPYRIGHT */
+
+#include <u.h>
+#include <libc.h>
+#include <fcall.h>
+#include <fs.h>
+#include "fsimpl.h"
+
+static int _fssend(Mux*, void*);
+static void *_fsrecv(Mux*);
+static int _fsgettag(Mux*, void*);
+static int _fssettag(Mux*, void*, uint);
+
+enum
+{
+ Fidchunk = 32
+};
+
+Fsys*
+fsinit(int fd)
+{
+ Fsys *fs;
+
+ fs = mallocz(sizeof(Fsys), 1);
+ if(fs == nil)
+ return nil;
+ fs->fd = fd;
+ fs->ref = 1;
+ fs->mux.aux = fs;
+ fs->mux.mintag = 0;
+ fs->mux.maxtag = 256;
+ fs->mux.send = _fssend;
+ fs->mux.recv = _fsrecv;
+ fs->mux.gettag = _fsgettag;
+ fs->mux.settag = _fssettag;
+ muxinit(&fs->mux);
+ return fs;
+}
+
+Fid*
+fsroot(Fsys *fs)
+{
+ /* N.B. no incref */
+ return fs->root;
+}
+
+Fsys*
+fsmount(int fd)
+{
+ int n;
+ char *user;
+ Fsys *fs;
+
+ fs = fsinit(fd);
+ if(fs == nil)
+ return nil;
+ strcpy(fs->version, "9P2000");
+ if((n = fsversion(fs, 8192, fs->version, sizeof fs->version)) < 0){
+ Error:
+ fsunmount(fs);
+ return nil;
+ }
+ fs->msize = n;
+
+ user = getuser();
+ if((fs->root = fsattach(fs, nil, getuser(), "")) == nil)
+ goto Error;
+ return fs;
+}
+
+void
+fsunmount(Fsys *fs)
+{
+ _fsdecref(fs);
+}
+
+void
+_fsdecref(Fsys *fs)
+{
+ Fid *f, *next;
+
+ qlock(&fs->lk);
+ if(--fs->ref == 0){
+ close(fs->fd);
+ for(f=fs->freefid; f; f=next){
+ next = f->next;
+ if(f->fid%Fidchunk == 0)
+ free(f);
+ }
+ free(fs);
+ }
+ qunlock(&fs->lk);
+}
+
+int
+fsversion(Fsys *fs, int msize, char *version, int nversion)
+{
+ void *freep;
+ Fcall tx, rx;
+
+ tx.type = Tversion;
+ tx.version = version;
+ tx.msize = msize;
+
+ if(fsrpc(fs, &tx, &rx, &freep) < 0)
+ return -1;
+ strecpy(version, version+nversion, rx.version);
+ free(freep);
+ return rx.msize;
+}
+
+Fid*
+fsattach(Fsys *fs, Fid *afid, char *user, char *aname)
+{
+ Fcall tx, rx;
+ Fid *fid;
+
+ if((fid = _fsgetfid(fs)) == nil)
+ return nil;
+
+ tx.type = Tattach;
+ tx.afid = afid ? afid->fid : NOFID;
+ tx.fid = fid->fid;
+ tx.uname = user;
+ tx.aname = aname;
+
+ if(fsrpc(fs, &tx, &rx, 0) < 0){
+ _fsputfid(fid);
+ return nil;
+ }
+ fid->qid = rx.qid;
+ return fid;
+}
+
+int
+fsrpc(Fsys *fs, Fcall *tx, Fcall *rx, void **freep)
+{
+ int n, nn;
+ void *tpkt, *rpkt;
+
+ n = sizeS2M(tx);
+ tpkt = malloc(n);
+ if(tpkt == nil)
+ return -1;
+ nn = convS2M(tx, tpkt, n);
+ if(nn != n){
+ free(tpkt);
+ werrstr("libfs: sizeS2M convS2M mismatch");
+ fprint(2, "%r\n");
+ return -1;
+ }
+ rpkt = muxrpc(&fs->mux, tpkt);
+ free(tpkt);
+ if(rpkt == nil)
+ return -1;
+ n = GBIT32((uchar*)rpkt);
+ nn = convM2S(rpkt, n, rx);
+ if(nn != n){
+ free(rpkt);
+ werrstr("libfs: convM2S packet size mismatch");
+ fprint(2, "%r\n");
+ return -1;
+ }
+ if(rx->type == Rerror){
+ werrstr("%s", rx->ename);
+ free(rpkt);
+ return -1;
+ }
+ if(rx->type != tx->type+1){
+ werrstr("packet type mismatch -- tx %d rx %d",
+ tx->type, rx->type);
+ free(rpkt);
+ return -1;
+ }
+ if(freep)
+ *freep = rpkt;
+ else
+ free(rpkt);
+ return 0;
+}
+
+Fid*
+_fsgetfid(Fsys *fs)
+{
+ int i;
+ Fid *f;
+
+ qlock(&fs->lk);
+ if(fs->freefid == nil){
+ f = malloc(sizeof(Fid)*Fidchunk);
+ if(f == nil){
+ qunlock(&fs->lk);
+ return nil;
+ }
+ for(i=0; i<Fidchunk; i++){
+ f[i].fid = fs->nextfid++;
+ f[i].next = &f[i+1];
+ f[i].fs = fs;
+ fs->ref++;
+ }
+ f[i-1].next = nil;
+ fs->freefid = f;
+ }
+ f = fs->freefid;
+ fs->freefid = f->next;
+ qunlock(&fs->lk);
+ return f;
+}
+
+void
+_fsputfid(Fid *f)
+{
+ Fsys *fs;
+
+ fs = f->fs;
+ qlock(&fs->lk);
+ f->next = fs->freefid;
+ fs->freefid = f;
+ qunlock(&fs->lk);
+ _fsdecref(fs);
+}
+
+static int
+_fsgettag(Mux *mux, void *pkt)
+{
+ return GBIT16((uchar*)pkt+5);
+}
+
+static int
+_fssettag(Mux *mux, void *pkt, uint tag)
+{
+ PBIT16((uchar*)pkt+5, tag);
+ return 0;
+}
+
+static int
+_fssend(Mux *mux, void *pkt)
+{
+ Fsys *fs;
+
+ fs = mux->aux;
+ return write(fs->fd, pkt, GBIT32((uchar*)pkt));
+}
+
+static void*
+_fsrecv(Mux *mux)
+{
+ uchar *pkt;
+ uchar buf[4];
+ int n;
+ Fsys *fs;
+
+ fs = mux->aux;
+ n = readn(fs->fd, buf, 4);
+ if(n != 4)
+ return nil;
+ n = GBIT32(buf);
+ pkt = malloc(n+4);
+ if(pkt == nil){
+ fprint(2, "libfs out of memory reading 9p packet; here comes trouble\n");
+ return nil;
+ }
+ PBIT32(buf, n);
+ if(readn(fs->fd, pkt+4, n-4) != n-4){
+ free(pkt);
+ return nil;
+ }
+#if 0
+ if(pkt[4] == Ropenfd){
+ /* do unix socket crap */
+ sysfatal("no socket crap implemented");
+ }
+#endif
+ return pkt;
+}
blob - /dev/null
blob + fbcc37771b5ea281353c117d6b0ab37c36184f5b (mode 644)
--- /dev/null
+++ src/libfs/fsimpl.h
+/* Copyright (C) 2003 Russ Cox, Massachusetts Institute of Technology */
+/* See COPYRIGHT */
+
+typedef struct Queue Queue;
+Queue *_fsqalloc(void);
+int _fsqsend(Queue*, void*);
+void *_fsqrecv(Queue*);
+void _fsqhangup(Queue*);
+void *_fsnbqrecv(Queue*);
+
+#include <mux.h>
+struct Fsys
+{
+ char version[20];
+ int msize;
+ QLock lk;
+ int fd;
+ int ref;
+ Mux mux;
+ Fid *root;
+ Queue *txq;
+ Queue *rxq;
+ Fid *freefid;
+ int nextfid;
+};
+
+struct Fid
+{
+ int fid;
+ int mode;
+ Fid *next;
+ QLock lk;
+ Fsys *fs;
+ Qid qid;
+ vlong offset;
+};
+
+void _fsdecref(Fsys*);
+void _fsputfid(Fid*);
+Fid *_fsgetfid(Fsys*);
+
blob - /dev/null
blob + acfb0ae5990ba8fdbdfb4eba69913ff94ec5c756 (mode 644)
--- /dev/null
+++ src/libfs/mkfile
+PLAN9=../..
+<$PLAN9/src/mkhdr
+
+LIB=libfs.a
+
+OFILES=\
+ close.$O\
+ create.$O\
+ dirread.$O\
+ fs.$O\
+ open.$O\
+ read.$O\
+ stat.$O\
+ walk.$O\
+ write.$O\
+ wstat.$O\
+
+HFILES=\
+ $PLAN9/include/fs.h\
+ $PLAN9/include/mux.h\
+
+<$PLAN9/src/mksyslib
blob - /dev/null
blob + 458c5dac3dc0fbb80a934984540cea2d8b402e0b (mode 644)
--- /dev/null
+++ src/libfs/open.c
+#include <u.h>
+#include <libc.h>
+#include <fcall.h>
+#include <fs.h>
+#include "fsimpl.h"
+
+Fid*
+fsopen(Fsys *fs, char *name, int mode)
+{
+ Fid *fid;
+ Fcall tx, rx;
+
+ if((fid = fswalk(fs->root, name)) == nil)
+ return nil;
+ tx.type = Topen;
+ tx.fid = fid->fid;
+ tx.mode = mode;
+ if(fsrpc(fs, &tx, &rx, 0) < 0){
+ fsclose(fid);
+ return nil;
+ }
+ fid->mode = mode;
+ return fid;
+}
blob - /dev/null
blob + ca6c628c4e909244c6f163b03aa208b6fe4c8d3a (mode 644)
--- /dev/null
+++ src/libfs/read.c
+/* Copyright (C) 2003 Russ Cox, Massachusetts Institute of Technology */
+/* See COPYRIGHT */
+
+#include <u.h>
+#include <libc.h>
+#include <fcall.h>
+#include <fs.h>
+#include "fsimpl.h"
+
+long
+fspread(Fid *fid, void *buf, long n, vlong offset)
+{
+ Fcall tx, rx;
+ void *freep;
+
+ tx.type = Tread;
+ if(offset == -1){
+ qlock(&fid->lk);
+ tx.offset = fid->offset;
+ qunlock(&fid->lk);
+ }else
+ tx.offset = offset;
+ tx.count = n;
+
+ fsrpc(fid->fs, &tx, &rx, &freep);
+ if(rx.type == Rerror){
+ werrstr("%s", rx.ename);
+ free(freep);
+ return -1;
+ }
+ if(rx.count){
+ memmove(buf, rx.data, rx.count);
+ if(offset == -1){
+ qlock(&fid->lk);
+ tx.offset += n;
+ qunlock(&fid->lk);
+ }
+ }
+ free(freep);
+
+ return rx.count;
+}
+
+long
+fsread(Fid *fid, void *buf, long n)
+{
+ return fspread(fid, buf, n, -1);
+}
blob - /dev/null
blob + e55e0b126e72c18fa18d454d43c55aaa3ec3f1b7 (mode 644)
--- /dev/null
+++ src/libfs/stat.c
+/* Copyright (C) 2003 Russ Cox, Massachusetts Institute of Technology */
+/* See COPYRIGHT */
+
+#include <u.h>
+#include <libc.h>
+#include <fcall.h>
+#include <fs.h>
+#include "fsimpl.h"
+
+Dir*
+fsdirstat(Fsys *fs, char *name)
+{
+ Dir *d;
+ Fid *fid;
+
+ if((fid = fswalk(fs->root, name)) == nil)
+ return nil;
+
+ d = fsdirfstat(fid);
+ fsclose(fid);
+ return d;
+}
+
+Dir*
+fsdirfstat(Fid *fid)
+{
+ Dir *d;
+ Fsys *fs;
+ Fcall tx, rx;
+ void *freep;
+ int n;
+
+ fs = fid->fs;
+ tx.type = Tstat;
+ tx.fid = fid->fid;
+
+ if(fsrpc(fs, &tx, &rx, &freep) < 0)
+ return nil;
+
+ d = malloc(sizeof(Dir)+rx.nstat);
+ if(d == nil){
+ free(freep);
+ return nil;
+ }
+ n = convM2D(rx.stat, rx.nstat, d, (char*)&d[1]);
+ free(freep);
+ if(n != rx.nstat){
+ free(d);
+ werrstr("rx.nstat and convM2D disagree about dir length");
+ return nil;
+ }
+ return d;
+}
+
blob - /dev/null
blob + ad4eddc7727dea7d76696c008fe64467e72685c3 (mode 644)
--- /dev/null
+++ src/libfs/walk.c
+/* Copyright (C) 2003 Russ Cox, Massachusetts Institute of Technology */
+/* See COPYRIGHT */
+
+#include <u.h>
+#include <libc.h>
+#include <fcall.h>
+#include <fs.h>
+#include "fsimpl.h"
+
+Fid*
+fswalk(Fid *fid, char *oname)
+{
+ char *freep, *name;
+ int i, nwalk;
+ char *p;
+ Fid *wfid;
+ Fcall tx, rx;
+
+ freep = nil;
+ name = oname;
+ if(name){
+ freep = malloc(strlen(name)+1);
+ if(freep == nil)
+ return nil;
+ strcpy(freep, name);
+ name = freep;
+ }
+
+ if((wfid = _fsgetfid(fid->fs)) == nil){
+ free(freep);
+ return nil;
+ }
+
+ nwalk = 0;
+ do{
+ /* collect names */
+ for(i=0; name && *name && i < MAXWELEM; ){
+ p = name;
+ name = strchr(name, '/');
+ if(name)
+ *name++ = 0;
+ if(*p == 0)
+ continue;
+ tx.wname[i++] = p;
+ }
+
+ /* do a walk */
+ tx.type = Twalk;
+ tx.fid = nwalk ? wfid->fid : fid->fid;
+ tx.newfid = wfid->fid;
+ tx.nwname = i;
+ if(fsrpc(fid->fs, &tx, &rx, 0) < 0){
+ Error:
+ free(freep);
+ if(nwalk)
+ fsclose(wfid);
+ else
+ _fsputfid(wfid);
+ return nil;
+ }
+ if(rx.nwqid != tx.nwname){
+ /* XXX lame error */
+ werrstr("file '%s' not found", oname);
+ goto Error;
+ }
+ if(rx.nwqid == 0)
+ wfid->qid = fid->qid;
+ else
+ wfid->qid = rx.wqid[rx.nwqid-1];
+ nwalk++;
+ }while(name && *name);
+ return wfid;
+}
blob - /dev/null
blob + 96ecfa864653941be06444505860c82f6041545d (mode 644)
--- /dev/null
+++ src/libfs/write.c
+/* Copyright (C) 2003 Russ Cox, Massachusetts Institute of Technology */
+/* See COPYRIGHT */
+
+#include <u.h>
+#include <libc.h>
+#include <fcall.h>
+#include <fs.h>
+#include "fsimpl.h"
+
+long
+fspwrite(Fid *fd, void *buf, long n, vlong offset)
+{
+ Fcall tx, rx;
+ void *freep;
+
+ tx.type = Tread;
+ if(offset == -1){
+ qlock(&fd->lk);
+ tx.offset = fd->offset;
+ fd->offset += n;
+ qunlock(&fd->lk);
+ }else
+ tx.offset = offset;
+ tx.count = n;
+ tx.data = buf;
+
+ fsrpc(fd->fs, &tx, &rx, &freep);
+ if(rx.type == Rerror){
+ if(offset == -1){
+ qlock(&fd->lk);
+ fd->offset -= n;
+ qunlock(&fd->lk);
+ }
+ werrstr("%s", rx.ename);
+ free(freep);
+ return -1;
+ }
+ free(freep);
+ return rx.count;
+}
+
+long
+fswrite(Fid *fd, void *buf, long n)
+{
+ return fspwrite(fd, buf, n, -1);
+}
blob - /dev/null
blob + 90ae0e0fce7250880e3d1e0307e37d71ed3a307f (mode 644)
--- /dev/null
+++ src/libfs/wstat.c
+/* Copyright (C) 2003 Russ Cox, Massachusetts Institute of Technology */
+/* See COPYRIGHT */
+
+#include <u.h>
+#include <libc.h>
+#include <fcall.h>
+#include <fs.h>
+#include "fsimpl.h"
+
+int
+fsdirwstat(Fsys *fs, char *name, Dir *d)
+{
+ int n;
+ Fid *fid;
+
+ if((fid = fswalk(fs->root, name)) == nil)
+ return -1;
+
+ n = fsdirfwstat(fid, d);
+ fsclose(fid);
+ return n;
+}
+
+int
+fsdirfwstat(Fid *fid, Dir *d)
+{
+ char *a;
+ int n, nn;
+ Fcall tx, rx;
+
+ n = sizeD2M(d);
+ a = malloc(n);
+ if(a == nil)
+ return -1;
+ nn = convD2M(d, a, n);
+ if(n != nn){
+ werrstr("convD2M and sizeD2M disagree");
+ free(a);
+ return -1;
+ }
+
+ tx.type = Twstat;
+ tx.fid = fid->fid;
+ tx.stat = a;
+ tx.nstat = n;
+ n = fsrpc(fid->fs, &tx, &rx, 0);
+ free(a);
+ return n;
+}
blob - /dev/null
blob + d9679c3ae2ec4630c535f35b4efb85129d1e2065 (mode 644)
--- /dev/null
+++ src/libmux/COPYRIGHT
+
+This software was developed as part of a project at MIT:
+ /sys/src/libmux/*
+ /sys/include/mux.h
+
+Copyright (c) 2003 Russ Cox,
+ Massachusetts Institute of Technology
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
blob - /dev/null
blob + 3d932b1a1f4925bd0c79192b237ef990309bb667 (mode 644)
--- /dev/null
+++ src/libmux/io.c
+/* Copyright (C) 2003 Russ Cox, Massachusetts Institute of Technology */
+/* See COPYRIGHT */
+
+#include <u.h>
+#include <libc.h>
+#include <mux.h>
+
+/*
+ * If you fork off two procs running muxrecvproc and muxsendproc,
+ * then muxrecv/muxsend (and thus muxrpc) will never block except on
+ * rendevouses, which is nice when it's running in one thread of many.
+ */
+void
+_muxrecvproc(void *v)
+{
+ void *p;
+ Mux *mux;
+ Muxqueue *q;
+
+ mux = v;
+ q = _muxqalloc();
+
+ qlock(&mux->lk);
+ mux->readq = q;
+ qlock(&mux->inlk);
+ rwakeup(&mux->rpcfork);
+ qunlock(&mux->lk);
+
+ while((p = mux->recv(mux)) != nil)
+ if(_muxqsend(q, p) < 0){
+ free(p);
+ break;
+ }
+ qunlock(&mux->inlk);
+ qlock(&mux->lk);
+ _muxqhangup(q);
+ while((p = _muxnbqrecv(q)) != nil)
+ free(p);
+ free(q);
+ mux->readq = nil;
+ rwakeup(&mux->rpcfork);
+ qunlock(&mux->lk);
+}
+
+void
+_muxsendproc(void *v)
+{
+ Muxqueue *q;
+ void *p;
+ Mux *mux;
+
+ mux = v;
+ q = _muxqalloc();
+
+ qlock(&mux->lk);
+ mux->writeq = q;
+ qlock(&mux->outlk);
+ rwakeup(&mux->rpcfork);
+ qunlock(&mux->lk);
+
+ while((p = _muxqrecv(q)) != nil)
+ if(mux->send(mux, p) < 0)
+ break;
+ qunlock(&mux->outlk);
+ qlock(&mux->lk);
+ _muxqhangup(q);
+ while((p = _muxnbqrecv(q)) != nil)
+ free(p);
+ free(q);
+ mux->writeq = nil;
+ rwakeup(&mux->rpcfork);
+ qunlock(&mux->lk);
+ return;
+}
+
+void*
+_muxrecv(Mux *mux)
+{
+ void *p;
+
+ qlock(&mux->lk);
+/*
+ if(mux->state != VtStateConnected){
+ werrstr("not connected");
+ qunlock(&mux->lk);
+ return nil;
+ }
+*/
+ if(mux->readq){
+ qunlock(&mux->lk);
+ return _muxqrecv(mux->readq);
+ }
+
+ qlock(&mux->inlk);
+ qunlock(&mux->lk);
+ p = mux->recv(mux);
+ qunlock(&mux->inlk);
+/*
+ if(!p)
+ vthangup(mux);
+*/
+ return p;
+}
+
+int
+_muxsend(Mux *mux, void *p)
+{
+ qlock(&mux->lk);
+/*
+ if(mux->state != VtStateConnected){
+ packetfree(p);
+ werrstr("not connected");
+ qunlock(&mux->lk);
+ return -1;
+ }
+*/
+ if(mux->writeq){
+ qunlock(&mux->lk);
+ if(_muxqsend(mux->writeq, p) < 0){
+ free(p);
+ return -1;
+ }
+ return 0;
+ }
+
+ qlock(&mux->outlk);
+ qunlock(&mux->lk);
+ if(mux->send(mux, p) < 0){
+ qunlock(&mux->outlk);
+ /* vthangup(mux); */
+ return -1;
+ }
+ qunlock(&mux->outlk);
+ return 0;
+}
+
blob - /dev/null
blob + 71d62a433c5a346bcc007203d4f6fc61a5e16cde (mode 644)
--- /dev/null
+++ src/libmux/mkfile
+PLAN9=../..
+<$PLAN9/src/mkhdr
+
+LIB=libmux.a
+
+OFILES=\
+ io.$O\
+ mux.$O\
+ queue.$O\
+ thread.$O\
+
+HFILES=\
+ $PLAN9/include/mux.h\
+
+<$PLAN9/src/mksyslib
+
blob - /dev/null
blob + 0d33498e31dc9ac1db29f93a84f454c103204ca3 (mode 644)
--- /dev/null
+++ src/libmux/mux.c
+/* Copyright (C) 2003 Russ Cox, Massachusetts Institute of Technology */
+/* See COPYRIGHT */
+
+/*
+ * Generic RPC packet multiplexor. Inspired by but not derived from
+ * Plan 9 kernel. Originally developed as part of Tra, later used in
+ * libnventi, and then finally split out into a generic library.
+ */
+
+#include <u.h>
+#include <libc.h>
+#include <mux.h>
+
+static int gettag(Mux*, Muxrpc*);
+static void puttag(Mux*, Muxrpc*);
+static void enqueue(Mux*, Muxrpc*);
+static void dequeue(Mux*, Muxrpc*);
+
+void
+muxinit(Mux *mux)
+{
+ mux->tagrend.l = &mux->lk;
+ mux->sleep.next = &mux->sleep;
+ mux->sleep.prev = &mux->sleep;
+}
+
+void*
+muxrpc(Mux *mux, void *tx)
+{
+ uint tag;
+ Muxrpc *r, *r2;
+ void *p;
+
+ /* must malloc because stack could be private */
+ r = mallocz(sizeof(Muxrpc), 1);
+ if(r == nil)
+ return nil;
+ r->r.l = &mux->lk;
+
+ /* assign the tag */
+ tag = gettag(mux, r);
+ if(mux->settag(mux, tx, tag) < 0){
+ puttag(mux, r);
+ free(r);
+ return nil;
+ }
+
+ /* send the packet */
+ if(_muxsend(mux, tx) < 0){
+ puttag(mux, r);
+ free(r);
+ return nil;
+ }
+
+ /* add ourselves to sleep queue */
+ qlock(&mux->lk);
+ enqueue(mux, r);
+
+ /* wait for our packet */
+ while(mux->muxer && !r->p)
+ rsleep(&r->r);
+
+ /* if not done, there's no muxer: start muxing */
+ if(!r->p){
+ if(mux->muxer)
+ abort();
+ mux->muxer = 1;
+ while(!r->p){
+ qunlock(&mux->lk);
+ p = _muxrecv(mux);
+ if(p)
+ tag = mux->gettag(mux, p);
+ else
+ tag = ~0;
+ qlock(&mux->lk);
+ if(p == nil){ /* eof -- just give up and pass the buck */
+ dequeue(mux, r);
+ break;
+ }
+ /* hand packet to correct sleeper */
+ if(tag < 0 || tag >= mux->mwait){
+ fprint(2, "%s: bad rpc tag %ux\n", argv0, tag);
+ /* must leak packet! don't know how to free it! */
+ continue;
+ }
+ r2 = mux->wait[tag];
+ r2->p = p;
+ rwakeup(&r2->r);
+ }
+ mux->muxer = 0;
+
+ /* if there is anyone else sleeping, wake them to mux */
+ if(mux->sleep.next != &mux->sleep)
+ rwakeup(&mux->sleep.next->r);
+ }
+ p = r->p;
+ puttag(mux, r);
+ free(r);
+ qunlock(&mux->lk);
+ return p;
+}
+
+static void
+enqueue(Mux *mux, Muxrpc *r)
+{
+ r->next = mux->sleep.next;
+ r->prev = &mux->sleep;
+ r->next->prev = r;
+ r->prev->next = r;
+}
+
+static void
+dequeue(Mux *mux, Muxrpc *r)
+{
+ r->next->prev = r->prev;
+ r->prev->next = r->next;
+ r->prev = nil;
+ r->next = nil;
+}
+
+static int
+gettag(Mux *mux, Muxrpc *r)
+{
+ int i;
+
+Again:
+ while(mux->nwait == mux->mwait)
+ rsleep(&mux->tagrend);
+ i=mux->freetag;
+ if(mux->wait[i] == 0)
+ goto Found;
+ for(i=0; i<mux->mwait; i++)
+ if(mux->wait[i] == 0){
+ Found:
+ mux->nwait++;
+ mux->wait[i] = r;
+ r->tag = i;
+ return i;
+ }
+ fprint(2, "libfs: nwait botch\n");
+ goto Again;
+}
+
+static void
+puttag(Mux *mux, Muxrpc *r)
+{
+ assert(mux->wait[r->tag] == r);
+ mux->wait[r->tag] = nil;
+ mux->nwait--;
+ mux->freetag = r->tag;
+ rwakeup(&mux->tagrend);
+}
blob - /dev/null
blob + 072f18609bb6ddf7273258b184174834b7c0dfff (mode 644)
--- /dev/null
+++ src/libmux/queue.c
+/* Copyright (C) 2003 Russ Cox, Massachusetts Institute of Technology */
+/* See COPYRIGHT */
+
+#include <u.h>
+#include <libc.h>
+#include <mux.h>
+
+typedef struct Qel Qel;
+struct Qel
+{
+ Qel *next;
+ void *p;
+};
+
+struct Muxqueue
+{
+ int hungup;
+ QLock lk;
+ Rendez r;
+ Qel *head;
+ Qel *tail;
+};
+
+Muxqueue*
+_muxqalloc(void)
+{
+ Muxqueue *q;
+
+ q = mallocz(sizeof(Muxqueue), 1);
+ if(q == nil)
+ return nil;
+ q->r.l = &q->lk;
+ return q;
+}
+
+int
+_muxqsend(Muxqueue *q, void *p)
+{
+ Qel *e;
+
+ e = malloc(sizeof(Qel));
+ if(e == nil)
+ return -1;
+ qlock(&q->lk);
+ if(q->hungup){
+ werrstr("hungup queue");
+ qunlock(&q->lk);
+ return -1;
+ }
+ e->p = p;
+ e->next = nil;
+ if(q->head == nil)
+ q->head = e;
+ else
+ q->tail->next = e;
+ q->tail = e;
+ rwakeup(&q->r);
+ qunlock(&q->lk);
+ return 0;
+}
+
+void*
+_muxqrecv(Muxqueue *q)
+{
+ void *p;
+ Qel *e;
+
+ qlock(&q->lk);
+ while(q->head == nil && !q->hungup)
+ rsleep(&q->r);
+ if(q->hungup){
+ qunlock(&q->lk);
+ return nil;
+ }
+ e = q->head;
+ q->head = e->next;
+ qunlock(&q->lk);
+ p = e->p;
+ free(e);
+ return p;
+}
+
+void*
+_muxnbqrecv(Muxqueue *q)
+{
+ void *p;
+ Qel *e;
+
+ qlock(&q->lk);
+ if(q->head == nil){
+ qunlock(&q->lk);
+ return nil;
+ }
+ e = q->head;
+ q->head = e->next;
+ qunlock(&q->lk);
+ p = e->p;
+ free(e);
+ return p;
+}
+
+void
+_muxqhangup(Muxqueue *q)
+{
+ qlock(&q->lk);
+ q->hungup = 1;
+ rwakeupall(&q->r);
+ qunlock(&q->lk);
+}
blob - /dev/null
blob + 1c643e06df7b6c94cd18d9b10dc112971f19b072 (mode 644)
--- /dev/null
+++ src/libmux/thread.c
+/* Copyright (C) 2003 Russ Cox, Massachusetts Institute of Technology */
+/* See COPYRIGHT */
+
+#include <u.h>
+#include <libc.h>
+#include <thread.h>
+#include <mux.h>
+
+enum
+{
+ STACK = 32768
+};
+
+void
+muxthreads(Mux *mux)
+{
+ proccreate(_muxrecvproc, mux, STACK);
+ qlock(&mux->lk);
+ while(!mux->writeq)
+ rsleep(&mux->rpcfork);
+ qunlock(&mux->lk);
+ proccreate(_muxsendproc, mux, STACK);
+ qlock(&mux->lk);
+ while(!mux->writeq)
+ rsleep(&mux->rpcfork);
+ qunlock(&mux->lk);
+}
