shithub: 9pro

Download patch

ref: 68b32a741895fd7e36462788a144698737a6f1dc
parent: ad1ecd543465375dc5914a34d2ef66dfa59fad76
parent: c19685c19ee0eb9c9bcfe8d89ab1fea5231216ea
author: Sigrid Haflínudóttir <ftrvxmtrx@gmail.com>
date: Sun Dec 22 10:37:19 EST 2019

Merge commit 'c19685c19ee0eb9c9bcfe8d89ab1fea5231216ea' as 'c9'

diff: cannot open b/c9//null: file does not exist: 'b/c9//null'
--- /dev/null
+++ b/c9/LICENSE
@@ -1,0 +1,1 @@
+Public domain.
--- /dev/null
+++ b/c9/README.md
@@ -1,0 +1,8 @@
+# c9
+
+Low level 9p client and server.
+
+## Examples
+
+Until I have time to write a minimal example you could take a look at 
+https://github.com/ftrvxmtrx/dawfs/blob/master/c9net.c
--- /dev/null
+++ b/c9/c9.c
@@ -1,0 +1,1159 @@
+/*
+ * This is 9p client and server implementation which aims to be
+ * correct, small and secure. It's the lowest level implementation.
+ * It doesn't have much comments, mostly because it doesn't make
+ * any sense to copy-paste protocol documentation, which
+ * you can read at http://man.cat-v.org/plan_9/5/, see 'intro'.
+ */
+#include <string.h>
+#include <stdint.h>
+#include "c9.h"
+
+enum
+{
+	Svver = 1<<0,
+};
+
+#define safestrlen(s) (s == NULL ? 0 : (uint32_t)strlen(s))
+#define maxread(c) (c->msize-4-4-1-2)
+#define maxwrite(c) maxread(c)
+
+static void
+w08(uint8_t **p, uint8_t x)
+{
+	(*p)[0] = x;
+	*p += 1;
+}
+
+static void
+w16(uint8_t **p, uint16_t x)
+{
+	(*p)[0] = x;
+	(*p)[1] = x>>8;
+	*p += 2;
+}
+
+static void
+w32(uint8_t **p, uint32_t x)
+{
+	(*p)[0] = x;
+	(*p)[1] = x>>8;
+	(*p)[2] = x>>16;
+	(*p)[3] = x>>24;
+	*p += 4;
+}
+
+static void
+w64(uint8_t **p, uint64_t x)
+{
+	(*p)[0] = x;
+	(*p)[1] = x>>8;
+	(*p)[2] = x>>16;
+	(*p)[3] = x>>24;
+	(*p)[4] = x>>32;
+	(*p)[5] = x>>40;
+	(*p)[6] = x>>48;
+	(*p)[7] = x>>56;
+	*p += 8;
+}
+
+static void
+wcs(uint8_t **p, const char *s, int len)
+{
+	w16(p, len);
+	if(s != NULL){
+		memmove(*p, s, len);
+		*p += len;
+	}
+}
+
+static uint8_t
+r08(uint8_t **p)
+{
+	*p += 1;
+	return (*p)[-1];
+}
+
+static uint16_t
+r16(uint8_t **p)
+{
+	*p += 2;
+	return (uint16_t)(*p)[-2]<<0 | (uint16_t)(*p)[-1]<<8;
+}
+
+static uint32_t
+r32(uint8_t **p)
+{
+	return r16(p) | (uint32_t)r16(p)<<16;
+}
+
+static uint64_t
+r64(uint8_t **p)
+{
+	return r32(p) | (uint64_t)r32(p)<<32;
+}
+
+static C9error
+newtag(C9ctx *c, C9ttype type, C9tag *tag)
+{
+	uint32_t i;
+
+	if(type == Tversion){
+		*tag = 0xffff;
+		return 0;
+	}
+
+	if(c->lowfreetag < C9maxtags){
+		uint32_t d = c->lowfreetag / C9tagsbits, m = c->lowfreetag % C9tagsbits;
+		if((c->tags[d] & 1<<m) != 0){
+			c->tags[d] &= ~(1<<m);
+			*tag = c->lowfreetag++;
+			return 0;
+		}
+	}
+
+	for(i = 0; i < (int)sizeof(c->tags)/sizeof(c->tags[0]); i++){
+		uint32_t x, j;
+		if((x = c->tags[i]) == 0)
+			continue;
+		for(j = 0; j < C9tagsbits; j++){
+			if((x & (1<<j)) != 0){
+				c->tags[i] &= ~(1<<j);
+				*tag = i*C9tagsbits + j;
+				c->lowfreetag = *tag + 1;
+				return 0;
+			}
+		}
+	}
+
+	c->error("newtag: no free tags");
+	return C9Etag;
+}
+
+static int
+freetag(C9ctx *c, C9tag tag)
+{
+	if(tag != 0xffff){
+		uint32_t d = tag / C9tagsbits, m = tag % C9tagsbits;
+		if(tag >= C9maxtags){
+			c->error("freetag: invalid tag");
+			return -1;
+		}
+		if((c->tags[d] & 1<<m) != 0){
+			c->error("freetag: double free");
+			return -1;
+		}
+		if(c->lowfreetag > tag)
+			c->lowfreetag = tag;
+		c->tags[d] |= 1<<m;
+	}
+	return 0;
+}
+
+static uint8_t *
+T(C9ctx *c, uint32_t size, C9ttype type, C9tag *tag, C9error *err)
+{
+	uint8_t *p = NULL;
+
+	if(size > c->msize-4-1-2){
+		c->error("T: invalid size");
+		*err = C9Esize;
+	}else if((*err = newtag(c, type, tag)) == 0){
+		size += 4+1+2;
+		if((p = c->begin(c, size)) == NULL){
+			c->error("T: no buffer");
+			freetag(c, *tag);
+			*err = C9Ebuf;
+		}else{
+			*err = 0;
+			w32(&p, size);
+			w08(&p, type);
+			w16(&p, *tag);
+		}
+	}
+	return p;
+}
+
+static uint8_t *
+R(C9ctx *c, uint32_t size, C9rtype type, C9tag tag, C9error *err)
+{
+	uint8_t *p = NULL;
+
+	if(size > c->msize-4-1-2){
+		c->error("R: invalid size");
+		*err = C9Esize;
+	}else{
+		size += 4+1+2;
+		if((p = c->begin(c, size)) == NULL){
+			c->error("R: no buffer");
+			*err = C9Ebuf;
+		}else{
+			*err = 0;
+			w32(&p, size);
+			w08(&p, type);
+			w16(&p, tag);
+		}
+	}
+	return p;
+}
+
+C9error
+c9parsedir(C9ctx *c, C9stat *stat, uint8_t **t, uint32_t *size)
+{
+	uint8_t *b;
+	uint32_t cnt, sz;
+
+	if(*size < 49 || (sz = r16(t)) < 47 || *size < 2+sz)
+		goto error;
+	*size -= 2+sz;
+	*t += 6; /* skip type(2) and dev(4) */
+	stat->qid.type = r08(t);
+	stat->qid.version = r32(t);
+	stat->qid.path = r64(t);
+	stat->mode = r32(t);
+	stat->atime = r32(t);
+	stat->mtime = r32(t);
+	stat->size = r64(t);
+	sz -= 39;
+	if((cnt = r16(t)) > sz-2)
+		goto error;
+	stat->name = (char*)*t; b = *t = *t+cnt; sz -= 2+cnt;
+	if(sz < 2 || (cnt = r16(t)) > sz-2)
+		goto error;
+	stat->uid = (char*)*t; *b = 0; b = *t = *t+cnt; sz -= 2+cnt;
+	if(sz < 2 || (cnt = r16(t)) > sz-2)
+		goto error;
+	stat->gid = (char*)*t; *b = 0; b = *t = *t+cnt; sz -= 2+cnt;
+	if(sz < 2 || (cnt = r16(t)) > sz-2)
+		goto error;
+	stat->muid = memmove(*t-1, *t, cnt); *b = stat->muid[cnt] = 0; *t = *t+cnt; sz -= 2+cnt;
+	*t += sz;
+	return 0;
+error:
+	c->error("c9parsedir: invalid size");
+	return C9Epkt;
+}
+
+C9error
+c9version(C9ctx *c, C9tag *tag, uint32_t msize)
+{
+	uint8_t *b;
+	C9error err;
+
+	if(msize < C9minmsize){
+		c->error("c9version: msize too small");
+		return C9Einit;
+	}
+	memset(c->tags, 0xff, sizeof(c->tags));
+	memset(c->flush, 0xff, sizeof(c->flush));
+	c->lowfreetag = 0;
+	c->msize = msize;
+
+	if((b = T(c, 4+2+6, Tversion, tag, &err)) != NULL){
+		w32(&b, msize);
+		wcs(&b, "9P2000", 6);
+		err = c->end(c);
+	}
+	return err;
+}
+
+C9error
+c9auth(C9ctx *c, C9tag *tag, C9fid afid, const char *uname, const char *aname)
+{
+	uint8_t *b;
+	uint32_t ulen = safestrlen(uname), alen = safestrlen(aname);
+	C9error err;
+
+	if(ulen > C9maxstr || alen > C9maxstr){
+		c->error("c9auth: string too long");
+		return C9Estr;
+	}
+	if((b = T(c, 4+2+ulen+2+alen, Tauth, tag, &err)) != NULL){
+		w32(&b, afid);
+		wcs(&b, uname, ulen);
+		wcs(&b, aname, alen);
+		err = c->end(c);
+	}
+	return err;
+}
+
+C9error
+c9flush(C9ctx *c, C9tag *tag, C9tag oldtag)
+{
+	uint8_t *b;
+	C9error err;
+	int i;
+
+	for(i = 0; i < C9maxflush && c->flush[i] != (uint32_t)~0; i++);
+	if(i == C9maxflush){
+		c->error("c9flush: no free flush slots");
+		return C9Eflush;
+	}
+	if((b = T(c, 2, Tflush, tag, &err)) != NULL){
+		w16(&b, oldtag);
+		err = c->end(c);
+		if(err == 0)
+			c->flush[i] = (uint32_t)oldtag<<16 | *tag;
+	}
+	return err;
+}
+
+C9error
+c9attach(C9ctx *c, C9tag *tag, C9fid fid, C9fid afid, const char *uname, const char *aname)
+{
+	uint32_t ulen = safestrlen(uname), alen = safestrlen(aname);
+	uint8_t *b;
+	C9error err;
+
+	if(ulen > C9maxstr || alen > C9maxstr){
+		c->error("c9attach: string too long");
+		return C9Estr;
+	}
+	if((b = T(c, 4+4+2+ulen+2+alen, Tattach, tag, &err)) != NULL){
+		w32(&b, fid);
+		w32(&b, afid);
+		wcs(&b, uname, ulen);
+		wcs(&b, aname, alen);
+		err = c->end(c);
+	}
+	return err;
+}
+
+C9error
+c9walk(C9ctx *c, C9tag *tag, C9fid fid, C9fid newfid, const char *path[])
+{
+	uint32_t i, j, sz;
+	uint32_t len[C9maxpathel];
+	uint8_t *b;
+	C9error err;
+
+	for(sz = i = 0; i < (int)sizeof(len)/sizeof(len[0]) && path[i] != NULL; i++){
+		len[i] = safestrlen(path[i]);
+		if(len[i] == 0 || len[i] > C9maxstr){
+			c->error("c9walk: path element too long");
+			return C9Epath;
+		}
+		sz += 2 + len[i];
+	}
+	if(path[i] != NULL || i == 0){
+		c->error("c9walk: invalid elements !(0 < %d <= %d)", i, C9maxpathel);
+		return C9Epath;
+	}
+
+	if((b = T(c, 4+4+2+sz, Twalk, tag, &err)) != NULL){
+		w32(&b, fid);
+		w32(&b, newfid);
+		w16(&b, i);
+		for(j = 0; j < i; j++)
+			wcs(&b, path[j], len[j]);
+		err = c->end(c);
+	}
+	return err;
+}
+
+C9error
+c9open(C9ctx *c, C9tag *tag, C9fid fid, C9mode mode)
+{
+	uint8_t *b;
+	C9error err;
+
+	if((b = T(c, 4+1, Topen, tag, &err)) != NULL){
+		w32(&b, fid);
+		w08(&b, mode);
+		err = c->end(c);
+	}
+	return err;
+}
+
+C9error
+c9create(C9ctx *c, C9tag *tag, C9fid fid, const char *name, uint32_t perm, C9mode mode)
+{
+	uint32_t nlen = strlen(name);
+	uint8_t *b;
+	C9error err;
+
+	if(nlen == 0 || nlen > C9maxstr){
+		c->error("c9create: invalid name");
+		return C9Epath;
+	}
+	if((b = T(c, 4+2+nlen+4+1, Tcreate, tag, &err)) != NULL){
+		w32(&b, fid);
+		wcs(&b, name, nlen);
+		w32(&b, perm);
+		w08(&b, mode);
+		err = c->end(c);
+	}
+	return err;
+}
+
+C9error
+c9read(C9ctx *c, C9tag *tag, C9fid fid, uint64_t offset, uint32_t count)
+{
+	uint8_t *b;
+	C9error err;
+
+	if((b = T(c, 4+8+4, Tread, tag, &err)) != NULL){
+		w32(&b, fid);
+		w64(&b, offset);
+		w32(&b, count);
+		err = c->end(c);
+	}
+	return err;
+}
+
+C9error
+c9write(C9ctx *c, C9tag *tag, C9fid fid, uint64_t offset, const void *in, uint32_t count)
+{
+	uint8_t *b;
+	C9error err;
+
+	if((b = T(c, 4+8+4+count, Twrite, tag, &err)) != NULL){
+		w32(&b, fid);
+		w64(&b, offset);
+		w32(&b, count);
+		memmove(b, in, count);
+		err = c->end(c);
+	}
+	return err;
+}
+
+C9error
+c9wrstr(C9ctx *c, C9tag *tag, C9fid fid, const char *s)
+{
+	return c9write(c, tag, fid, 0, s, strlen(s));
+}
+
+C9error
+c9clunk(C9ctx *c, C9tag *tag, C9fid fid)
+{
+	uint8_t *b;
+	C9error err;
+
+	if((b = T(c, 4, Tclunk, tag, &err)) != NULL){
+		w32(&b, fid);
+		err = c->end(c);
+	}
+	return err;
+}
+
+C9error
+c9remove(C9ctx *c, C9tag *tag, C9fid fid)
+{
+	uint8_t *b;
+	C9error err;
+
+	if((b = T(c, 4, Tremove, tag, &err)) != NULL){
+		w32(&b, fid);
+		err = c->end(c);
+	}
+	return err;
+}
+
+C9error
+c9stat(C9ctx *c, C9tag *tag, C9fid fid)
+{
+	uint8_t *b;
+	C9error err;
+
+	if((b = T(c, 4, Tstat, tag, &err)) != NULL){
+		w32(&b, fid);
+		err = c->end(c);
+	}
+	return err;
+}
+
+C9error
+c9wstat(C9ctx *c, C9tag *tag, C9fid fid, const C9stat *s)
+{
+	uint32_t nlen = safestrlen(s->name), ulen = safestrlen(s->uid), glen = safestrlen(s->gid);
+	uint32_t unusedsz = 2+4+13, statsz = unusedsz+4+4+4+8+2+nlen+2+ulen+2+glen+2;
+	uint8_t *b;
+	C9error err;
+
+	if(nlen == 0 || nlen > C9maxstr){
+		c->error("c9wstat: invalid name");
+		return C9Epath;
+	}
+	if(ulen > C9maxstr || glen > C9maxstr){
+		c->error("c9wstat: string too long");
+		return C9Estr;
+	}
+	if((b = T(c, 4+2+2+statsz, Twstat, tag, &err)) != NULL){
+		w32(&b, fid);
+		w16(&b, statsz+2);
+		w16(&b, statsz);
+		memset(b, 0xff, unusedsz); /* leave type(2), dev(4) and qid(13) unchanged */
+		b += unusedsz;
+		w32(&b, s->mode);
+		w32(&b, s->atime);
+		w32(&b, s->mtime);
+		w64(&b, s->size);
+		wcs(&b, s->name, nlen);
+		wcs(&b, s->uid, ulen);
+		wcs(&b, s->gid, glen);
+		wcs(&b, NULL, 0); /* muid unchanged */
+		err = c->end(c);
+	}
+	return err;
+}
+
+C9error
+c9proc(C9ctx *c)
+{
+	uint32_t i, sz, cnt, msize;
+	uint8_t *b;
+	int err;
+	C9r r;
+
+	err = -1;
+	if((b = c->read(c, 4, &err)) == NULL){
+		if(err != 0)
+			c->error("c9proc: short read");
+		return err == 0 ? 0 : C9Epkt;
+	}
+
+	sz = r32(&b);
+	if(sz < 7 || sz > c->msize){
+		c->error("c9proc: invalid packet size !(7 <= %u <= %u)", sz, c->msize);
+		return C9Epkt;
+	}
+	sz -= 4;
+	err = -1;
+	if((b = c->read(c, sz, &err)) == NULL){
+		if(err != 0)
+			c->error("c9proc: short read");
+		return err == 0 ? 0 : C9Epkt;
+	}
+
+	r.type = r08(&b);
+	r.tag = r16(&b);
+	if(r.type != Rversion){
+		if(r.tag >= C9maxtags){
+			c->error("c9proc: invalid tag 0x%x", r.tag);
+			return C9Epkt;
+		}
+		if(freetag(c, r.tag) != 0)
+			return C9Etag;
+	}
+	sz -= 3;
+	r.numqid = 0;
+
+	switch(r.type){
+	case Rread:
+		if(sz < 4 || (cnt = r32(&b)) > sz-4)
+			goto error;
+		r.read.data = b;
+		r.read.size = cnt;
+		c->r(c, &r);
+		break;
+
+	case Rwrite:
+		if(sz < 4 || (cnt = r32(&b)) > c->msize)
+			goto error;
+		r.write.size = cnt;
+		c->r(c, &r);
+		break;
+
+	case Rwalk:
+		if(sz < 2+13 || (cnt = r16(&b))*13 > sz-2)
+			goto error;
+		if(cnt > C9maxpathel){
+			c->error("c9proc: Rwalk !(%d <= %d)", cnt, C9maxpathel);
+			return C9Epath;
+		}
+		for(i = 0; i < cnt; i++){
+			r.qid[i].type = r08(&b);
+			r.qid[i].version = r32(&b);
+			r.qid[i].path = r64(&b);
+		}
+		r.numqid = cnt;
+		c->r(c, &r);
+		break;
+
+	case Rstat:
+		b += 2; sz -= 2;
+		if((err = c9parsedir(c, &r.stat, &b, &sz)) != 0){
+			c->error("c9proc");
+			return err;
+		}
+		r.numqid = 1;
+		c->r(c, &r);
+		break;
+
+	case Rflush:
+		for(i = 0; i < C9maxflush; i++){
+			if((c->flush[i] & 0xffff) == r.tag){
+				freetag(c, c->flush[i]>>16);
+				c->flush[i] = 0xffffffff;
+				break;
+			}
+		}
+		/* fallthrough */
+	case Rclunk:
+	case Rremove:
+	case Rwstat:
+		c->r(c, &r);
+		break;
+
+	case Ropen:
+	case Rcreate:
+		if(sz < 17)
+			goto error;
+		r.qid[0].type = r08(&b);
+		r.qid[0].version = r32(&b);
+		r.qid[0].path = r64(&b);
+		r.iounit = r32(&b);
+		r.numqid = 1;
+		c->r(c, &r);
+		break;
+
+	case Rerror:
+		if(sz < 2 || (cnt = r16(&b)) > sz-2)
+			goto error;
+		r.error = memmove(b-1, b, cnt);
+		r.error[cnt] = 0;
+		c->r(c, &r);
+		break;
+
+	case Rauth:
+	case Rattach:
+		if(sz < 13)
+			goto error;
+		r.qid[0].type = r08(&b);
+		r.qid[0].version = r32(&b);
+		r.qid[0].path = r64(&b);
+		r.numqid = 1;
+		c->r(c, &r);
+		break;
+
+	case Rversion:
+		if(sz < 4+2 || (msize = r32(&b)) < C9minmsize || (cnt = r16(&b)) > sz-4-2)
+			goto error;
+		if(cnt < 6 || memcmp(b, "9P2000", 6) != 0){
+			c->error("invalid version");
+			return C9Ever;
+		}
+		if(msize < c->msize)
+			c->msize = msize;
+		c->r(c, &r);
+		break;
+
+	default:
+		goto error;
+	}
+	return 0;
+error:
+	c->error("c9proc: invalid packet (type=%d)", r.type);
+	return C9Epkt;
+}
+
+C9error
+s9version(C9ctx *c)
+{
+	uint8_t *b;
+	C9error err;
+
+	if((b = R(c, 4+2+6, Rversion, 0xffff, &err)) != NULL){
+		w32(&b, c->msize);
+		wcs(&b, "9P2000", 6);
+		err = c->end(c);
+	};
+	return err;
+}
+
+C9error
+s9auth(C9ctx *c, C9tag tag, const C9qid *aqid)
+{
+	uint8_t *b;
+	C9error err;
+
+	if((b = R(c, 13, Rauth, tag, &err)) != NULL){
+		w08(&b, aqid->type);
+		w32(&b, aqid->version);
+		w64(&b, aqid->path);
+		err = c->end(c);
+	}
+	return err;
+}
+
+C9error
+s9error(C9ctx *c, C9tag tag, const char *ename)
+{
+	uint32_t len = safestrlen(ename);
+	uint8_t *b;
+	C9error err;
+
+	if(len > C9maxstr){
+		c->error("s9error: invalid ename");
+		return C9Estr;
+	}
+	if((b = R(c, 2+len, Rerror, tag, &err)) != NULL){
+		wcs(&b, ename, len);
+		err = c->end(c);
+	}
+	return err;
+}
+
+C9error
+s9attach(C9ctx *c, C9tag tag, const C9qid *qid)
+{
+	uint8_t *b;
+	C9error err;
+
+	if((b = R(c, 13, Rattach, tag, &err)) != NULL){
+		w08(&b, qid->type);
+		w32(&b, qid->version);
+		w64(&b, qid->path);
+		err = c->end(c);
+	}
+	return err;
+}
+
+C9error
+s9flush(C9ctx *c, C9tag tag)
+{
+	uint8_t *b;
+	C9error err;
+
+	if((b = R(c, 0, Rflush, tag, &err)) != NULL)
+		err = c->end(c);
+	return err;
+}
+
+C9error
+s9walk(C9ctx *c, C9tag tag, C9qid *qids[])
+{
+	uint32_t i, n;
+	uint8_t *b;
+	C9error err;
+
+	for(n = 0; n < C9maxpathel && qids[n] != NULL; n++);
+	if(n > C9maxpathel){
+		c->error("s9walk: invalid elements !(0 <= %d <= %d)", n, C9maxpathel);
+		return C9Epath;
+	}
+
+	if((b = R(c, 2+n*13, Rwalk, tag, &err)) != NULL){
+		w16(&b, n);
+		for(i = 0; i < n; i++){
+			w08(&b, qids[i]->type);
+			w32(&b, qids[i]->version);
+			w64(&b, qids[i]->path);
+		}
+		err = c->end(c);
+	}
+	return err;
+}
+
+C9error
+s9open(C9ctx *c, C9tag tag, const C9qid *qid, uint32_t iounit)
+{
+	uint8_t *b;
+	C9error err;
+
+	if((b = R(c, 13+4, Ropen, tag, &err)) != NULL){
+		w08(&b, qid->type);
+		w32(&b, qid->version);
+		w64(&b, qid->path);
+		w32(&b, iounit);
+		err = c->end(c);
+	}
+	return err;
+}
+
+C9error
+s9create(C9ctx *c, C9tag tag, const C9qid *qid, uint32_t iounit)
+{
+	uint8_t *b;
+	C9error err;
+
+	if((b = R(c, 13+4, Rcreate, tag, &err)) != NULL){
+		w08(&b, qid->type);
+		w32(&b, qid->version);
+		w64(&b, qid->path);
+		w32(&b, iounit);
+		err = c->end(c);
+	}
+	return err;
+}
+
+C9error
+s9read(C9ctx *c, C9tag tag, const void *data, uint32_t size)
+{
+	uint8_t *b;
+	C9error err;
+
+	if((b = R(c, 4+size, Rread, tag, &err)) != NULL){
+		w32(&b, size);
+		memmove(b, data, size);
+		err = c->end(c);
+	}
+	return err;
+}
+
+C9error
+s9write(C9ctx *c, C9tag tag, uint32_t size)
+{
+	uint8_t *b;
+	C9error err;
+
+	if((b = R(c, 4, Rwrite, tag, &err)) != NULL){
+		w32(&b, size);
+		err = c->end(c);
+	}
+	return err;
+}
+
+C9error
+s9readdir(C9ctx *c, C9tag tag, C9stat *st[], int *num, uint64_t *offset, uint32_t size)
+{
+	uint8_t *b;
+	const C9stat *s;
+	uint32_t nlen, ulen, glen, mulen, m, n;
+	C9error err;
+	int i;
+
+	if(size > c->msize-4-1-2)
+		size = c->msize-4-1-2;
+
+	m = 0;
+	for(i = 0; i < *num; i++){
+		s = st[i];
+		nlen = safestrlen(s->name);
+		ulen = safestrlen(s->uid);
+		glen = safestrlen(s->gid);
+		mulen = safestrlen(s->muid);
+
+		if(nlen == 0 || nlen > C9maxstr){
+			c->error("s9readdir: invalid name");
+			return C9Epath;
+		}
+		if(ulen > C9maxstr || glen > C9maxstr || mulen > C9maxstr){
+			c->error("s9readdir: string too long");
+			return C9Estr;
+		}
+
+		n = 2 + 2+4+13+4+4+4+8+2+nlen+2+ulen+2+glen+2+mulen;
+		if(4+m+n > size)
+			break;
+		m += n;
+	}
+
+	if((b = R(c, 4+m, Rread, tag, &err)) != NULL){
+		*num = i;
+		w32(&b, m);
+		for(i = 0; i < *num; i++){
+			s = st[i];
+			nlen = safestrlen(s->name);
+			ulen = safestrlen(s->uid);
+			glen = safestrlen(s->gid);
+			mulen = safestrlen(s->muid);
+			w16(&b, 2+4+13+4+4+4+8+2+nlen+2+ulen+2+glen+2+mulen);
+			w16(&b, 0xffff); /* type */
+			w32(&b, 0xffffffff); /* dev */
+			w08(&b, s->qid.type);
+			w32(&b, s->qid.version);
+			w64(&b, s->qid.path);
+			w32(&b, s->mode);
+			w32(&b, s->atime);
+			w32(&b, s->mtime);
+			w64(&b, s->size);
+			wcs(&b, s->name, nlen);
+			wcs(&b, s->uid, ulen);
+			wcs(&b, s->gid, glen);
+			wcs(&b, s->muid, mulen);
+		}
+		err = c->end(c);
+		if(err == 0)
+			*offset += m;
+	}
+	return err;
+}
+
+C9error
+s9clunk(C9ctx *c, C9tag tag)
+{
+	uint8_t *b;
+	C9error err;
+
+	if((b = R(c, 0, Rclunk, tag, &err)) != NULL)
+		err = c->end(c);
+	return err;
+}
+
+C9error
+s9remove(C9ctx *c, C9tag tag)
+{
+	uint8_t *b;
+	C9error err;
+
+	if((b = R(c, 0, Rremove, tag, &err)) != NULL)
+		err = c->end(c);
+	return err;
+}
+
+C9error
+s9stat(C9ctx *c, C9tag tag, const C9stat *s)
+{
+	uint32_t nlen = safestrlen(s->name), ulen = safestrlen(s->uid);
+	uint32_t glen = safestrlen(s->gid), mulen = safestrlen(s->name);
+	uint32_t statsz = 2+4+13+4+4+4+8+2+nlen+2+ulen+2+glen+2+mulen;
+	uint8_t *b;
+	C9error err;
+
+	if(nlen == 0 || nlen > C9maxstr){
+		c->error("s9stat: invalid name");
+		return C9Epath;
+	}
+	if(ulen > C9maxstr || glen > C9maxstr || mulen > C9maxstr){
+		c->error("s9stat: string too long");
+		return C9Estr;
+	}
+
+	if((b = R(c, 2+2+statsz, Rstat, tag, &err)) != NULL){
+		w16(&b, statsz+2);
+		w16(&b, statsz);
+		w16(&b, 0xffff); /* type */
+		w32(&b, 0xffffffff); /* dev */
+		w08(&b, s->qid.type);
+		w32(&b, s->qid.version);
+		w64(&b, s->qid.path);
+		w32(&b, s->mode);
+		w32(&b, s->atime);
+		w32(&b, s->mtime);
+		w64(&b, s->size);
+		wcs(&b, s->name, nlen);
+		wcs(&b, s->uid, ulen);
+		wcs(&b, s->gid, glen);
+		wcs(&b, s->muid, mulen);
+		err = c->end(c);
+	}
+	return err;
+}
+
+C9error
+s9wstat(C9ctx *c, C9tag tag)
+{
+	uint8_t *b;
+	C9error err;
+
+	if((b = R(c, 0, Rwstat, tag, &err)) != NULL)
+		err = c->end(c);
+	return err;
+}
+
+C9error
+s9proc(C9ctx *c)
+{
+	uint32_t i, sz, cnt, n, msize;
+	int readerr;
+	uint8_t *b;
+	C9error err;
+	C9t t;
+
+	readerr = -1;
+	if((b = c->read(c, 4, &readerr)) == NULL){
+		if(readerr != 0)
+			c->error("s9proc: short read");
+		return readerr == 0 ? 0 : C9Epkt;
+	}
+
+	sz = r32(&b);
+	if(sz < 7 || sz > c->msize){
+		c->error("s9proc: invalid packet size !(7 <= %u <= %u)", sz, c->msize);
+		return C9Epkt;
+	}
+	sz -= 4;
+	readerr = -1;
+	if((b = c->read(c, sz, &readerr)) == NULL){
+		if(readerr != 0)
+			c->error("s9proc: short read");
+		return readerr == 0 ? 0 : C9Epkt;
+	}
+
+	t.type = r08(&b);
+	t.tag = r16(&b);
+	sz -= 3;
+
+	if((c->svflags & Svver) == 0 && t.type != Tversion){
+		c->error("s9proc: expected Tversion, got %d", t.type);
+		return C9Epkt;
+	}
+
+	switch(t.type){
+	case Tread:
+		if(sz < 4+8+4)
+			goto error;
+		t.fid = r32(&b);
+		t.read.offset = r64(&b);
+		t.read.size = r32(&b);
+		if(t.read.size > maxread(c))
+		  t.read.size = maxread(c);
+		c->t(c, &t);
+		break;
+
+	case Twrite:
+		if(sz < 4+8+4)
+			goto error;
+		t.fid = r32(&b);
+		t.write.offset = r64(&b);
+		if((t.write.size = r32(&b)) < sz-4-8-4)
+			goto error;
+		if(t.write.size > maxwrite(c))
+		  t.write.size = maxwrite(c);
+		t.write.data = b;
+		c->t(c, &t);
+		break;
+
+	case Tclunk:
+	case Tstat:
+	case Tremove:
+		if(sz < 4)
+			goto error;
+		t.fid = r32(&b);
+		c->t(c, &t);
+		break;
+
+	case Twalk:
+		if(sz < 4+4+2)
+			goto error;
+		t.fid = r32(&b);
+		t.walk.newfid = r32(&b);
+		if((n = r16(&b)) > 16){
+			c->error("s9proc: Twalk !(%d <= 16)", n);
+			return C9Epath;
+		}
+		sz -= 4+4+2;
+		if(n > 0){
+			for(i = 0; i < n; i++){
+				if(sz < 2 || (cnt = r16(&b)) > sz-2)
+					goto error;
+				if(cnt < 1){
+					c->error("s9proc: Twalk invalid element [%d]", i);
+					return C9Epath;
+				}
+				b[-2] = 0;
+				t.walk.wname[i] = (char*)b;
+				b += cnt;
+				sz -= 2 + cnt;
+			}
+			memmove(t.walk.wname[i-1]-1, t.walk.wname[i-1], (char*)b - t.walk.wname[i-1]);
+			t.walk.wname[i-1]--;
+			b[-1] = 0;
+		}else
+			i = 0;
+		t.walk.wname[i] = NULL;
+		c->t(c, &t);
+		break;
+
+	case Topen:
+		if(sz < 4+1)
+			goto error;
+		t.fid = r32(&b);
+		t.open.mode = r08(&b);
+		c->t(c, &t);
+		break;
+
+	case Twstat:
+		if(sz < 4+2)
+			goto error;
+		t.fid = r32(&b);
+		if((cnt = r16(&b)) > sz-4)
+			goto error;
+		if((err = c9parsedir(c, &t.wstat, &b, &cnt)) != 0){
+			c->error("s9proc");
+			return err;
+		}
+		c->t(c, &t);
+		break;
+
+	case Tcreate:
+		if(sz < 4+2+4+1)
+			goto error;
+		t.fid = r32(&b);
+		if((cnt = r16(&b)) < 1 || cnt > sz-4-2-4-1)
+			goto error;
+		t.create.name = (char*)b;
+		b += cnt;
+		t.create.perm = r32(&b);
+		t.create.mode = r08(&b);
+		t.create.name[cnt] = 0;
+		c->t(c, &t);
+		break;
+
+	case Tflush:
+		if(sz < 2)
+			goto error;
+		t.flush.oldtag = r16(&b);
+		c->t(c, &t);
+		break;
+
+	case Tversion:
+		if(sz < 4+2 || (msize = r32(&b)) < C9minmsize || (cnt = r16(&b)) > sz-4-2)
+			goto error;
+		if(cnt < 6 || memcmp(b, "9P2000", 6) != 0){
+			if((b = R(c, 4+2+7, Rversion, 0xffff, &err)) != NULL){
+				w32(&b, 0);
+				wcs(&b, "unknown", 7);
+				err = c->end(c);
+				c->error("s9proc: invalid version");
+			}
+			return C9Ever;
+		}
+		if(msize < c->msize)
+			c->msize = msize;
+		c->svflags |= Svver;
+		c->t(c, &t);
+		break;
+
+	case Tattach:
+		if(sz < 4+4+2+2)
+			goto error;
+		t.fid = r32(&b);
+		t.attach.afid = r32(&b);
+		cnt = r16(&b);
+		sz -= 4+4+2;
+		if(cnt+2 > sz)
+			goto error;
+		t.attach.uname = (char*)b;
+		b += cnt;
+		cnt = r16(&b);
+		b[-2] = 0;
+		sz -= cnt+2;
+		if(cnt > sz)
+			goto error;
+		memmove(b-1, b, cnt);
+		t.attach.aname = (char*)b-1;
+		t.attach.aname[cnt] = 0;
+		c->t(c, &t);
+		break;
+
+	case Tauth:
+		if(sz < 4+2+2)
+			goto error;
+		t.auth.afid = r32(&b);
+		cnt = r16(&b);
+		sz -= 4+2;
+		if(cnt+2 > sz)
+			goto error;
+		t.auth.uname = (char*)b;
+		b += cnt;
+		cnt = r16(&b);
+		b[-2] = 0;
+		sz -= cnt+2;
+		if(cnt > sz)
+			goto error;
+		memmove(b-1, b, cnt);
+		t.auth.aname = (char*)b-1;
+		t.auth.aname[cnt] = 0;
+		c->t(c, &t);
+		break;
+
+	default:
+		goto error;
+	}
+	return 0;
+error:
+	c->error("s9proc: invalid packet (type=%d)", t.type);
+	return C9Epkt;
+}
--- /dev/null
+++ b/c9/c9.h
@@ -1,0 +1,350 @@
+struct C9aux;
+
+typedef struct C9r C9r;
+typedef struct C9t C9t;
+typedef struct C9stat C9stat;
+typedef struct C9ctx C9ctx;
+typedef struct C9qid C9qid;
+typedef enum C9error C9error;
+typedef enum C9mode C9mode;
+typedef enum C9rtype C9rtype;
+typedef enum C9ttype C9ttype;
+typedef enum C9qt C9qt;
+typedef uint32_t C9fid;
+typedef uint16_t C9tag;
+
+/* Stat field is not changed if it's set to this value when calling c9wstat. */
+#define C9nochange (~0)
+
+/* Special fid used with auth/attach to basically avoid authentication. */
+#define C9nofid ((C9fid)~0)
+
+/* C9modes for opening a file. */
+enum C9mode
+{
+	C9read = 0,
+	C9write = 1,
+	C9rdwr = 2,
+	C9exec = 3,
+	C9trunc = 0x10,
+	C9rclose = 0x40,
+};
+
+enum C9perm
+{
+	/* User/owner. */
+	C9permur = 1<<8, /* Readable. */
+	C9permuw = 1<<7, /* Writable. */
+	C9permux = 1<<6, /* Executable. */
+
+	/* Group. */
+	C9permgr = 1<<5,
+	C9permgw = 1<<4,
+	C9permgx = 1<<3,
+
+	/* Other. */
+	C9permor = 1<<2,
+	C9permow = 1<<1,
+	C9permox = 1<<0,
+};
+
+/* Directory. */
+#define C9permdir 0x80000000
+
+/* Bitmask of stat.mode. */
+#define C9stdir 0x80000000
+#define C9stappend 0x40000000
+#define C9stexcl 0x20000000
+#define C9sttmp 0x04000000
+
+/* Limits. */
+enum
+{
+	C9maxtags = 64,    /* Maximal number of outstanding requests. [1-65535] */
+	C9maxflush = 8,    /* Maximal number of outstanding flushes. [1-65535] */
+	C9maxstr = 0xffff, /* Maximal string length. [1-65535] */
+	C9minmsize = 4096, /* Minimal sane msize. [4096-...] */
+	C9maxpathel = 16,  /* Maximal number of elements in a path. Do not change. */
+};
+
+/* Errors. */
+enum C9error
+{
+	C9Einit = -1,  /* Initialization failed. */
+	C9Ever = -2,   /* Protocol version doesn't match. */
+	C9Epkt = -3,   /* Incoming packet error. */
+	C9Etag = -4,   /* No free tags or bad tag. */
+	C9Ebuf = -5,   /* No buffer space enough for a message. */
+	C9Epath = -6,  /* Path is too long or just invalid. */
+	C9Eflush = -7, /* Limit of outstanding flushes reached. */
+	C9Esize = -8,  /* Can't fit data in one message. */
+	C9Estr = -9    /* Bad string. */
+};
+
+/* Request types. */
+enum C9ttype
+{
+	Tversion = 100,
+	Tauth = 102,
+	Tattach = 104,
+	Tflush = 108,
+	Twalk = 110,
+	Topen = 112,
+	Tcreate = 114,
+	Tread = 116,
+	Twrite = 118,
+	Tclunk = 120,
+	Tremove = 122,
+	Tstat = 124,
+	Twstat = 126
+};
+
+/* Response types. */
+enum C9rtype
+{
+	Rversion = 101,
+	Rauth = 103,
+	Rattach = 105,
+	Rerror = 107,
+	Rflush = 109,
+	Rwalk = 111,
+	Ropen = 113,
+	Rcreate = 115,
+	Rread = 117,
+	Rwrite = 119,
+	Rclunk = 121,
+	Rremove = 123,
+	Rstat = 125,
+	Rwstat = 127
+};
+
+/* Unique file id type. */
+enum C9qt
+{
+	C9qtdir = 1<<7,
+	C9qtappend = 1<<6,
+	C9qtexcl = 1<<5,
+	C9qtauth = 1<<3,
+	C9qttmp = 1<<2,
+	C9qtfile = 0
+};
+
+/* Unique file id. */
+struct C9qid
+{
+	uint64_t path;
+	uint32_t version;
+	C9qt type;
+};
+
+/*
+ * File stats. Version and muid are ignored on wstat. Dmdir bit
+ * change in mode won't work on wstat. Set any integer field to
+ * C9nochange to keep it unchanged on wstat. Set any string to NULL to
+ * keep it unchanged. Strings can be empty (""), but never NULL after
+ * stat call.
+ */
+struct C9stat
+{
+	uint64_t size; /* Size of the file (in bytes). */
+	char *name;  /* Name of the file. */
+	char *uid;   /* Owner of the file. */
+	char *gid;   /* Group of the file. */
+	char *muid;  /* The user who modified the file last. */
+	C9qid qid;   /* Same as qid[0]. */
+	uint32_t mode;   /* Permissions. See C9st* and C9perm. */
+	uint32_t atime;  /* Last access time. */
+	uint32_t mtime;  /* Last modification time. */
+};
+
+/* Response data. */
+struct C9r
+{
+	union
+	{
+		char *error;
+
+		struct
+		{
+			uint8_t *data;
+			uint32_t size;
+		}read;
+
+		struct
+		{
+			uint32_t size;
+		}write;
+
+		/* File stats (only valid if type is Rstat). */
+		C9stat stat;
+
+		/*
+		 * Qid(s). qid[0] is valid for auth/attach/create/stat/open.
+		 * More ids may be a result of a walk, see numqid.
+		 */
+		C9qid qid[C9maxpathel];
+	};
+	C9rtype type; /* Response type. */
+
+	/*
+	 * If not zero, is the maximum number of bytes that are guaranteed
+	 * to be read or written atomically, without breaking into multiple
+	 * messages.
+	 */
+	uint32_t iounit;
+
+	int numqid; /* Number of valid unique ids in qid array. */
+	C9tag tag;  /* Tag number. */
+};
+
+/* Request data. */
+struct C9t
+{
+	C9ttype type;
+	C9tag tag;
+	union
+	{
+		struct
+		{
+			char *uname;
+			char *aname;
+			C9fid afid;
+		}attach;
+
+		struct
+		{
+			char *uname;
+			char *aname;
+			C9fid afid;
+		}auth;
+
+		struct
+		{
+			char *name;
+			uint32_t perm;
+			C9mode mode;
+		}create;
+
+		struct
+		{
+			C9tag oldtag;
+		}flush;
+
+		struct
+		{
+			C9mode mode;
+		}open;
+
+		struct
+		{
+			uint64_t offset;
+			uint32_t size;
+		}read;
+
+		struct
+		{
+			char *wname[C9maxpathel+1]; /* wname[16] is always NULL */
+			C9fid newfid;
+		}walk;
+
+		struct
+		{
+			uint64_t offset;
+			uint8_t *data;
+			uint32_t size;
+		}write;
+
+		C9stat wstat;
+	};
+	C9fid fid;
+};
+
+enum
+{
+	C9tagsbits = sizeof(uint32_t) * 8,
+};
+
+struct C9ctx
+{
+	/*
+	 * Should return a pointer to the data (exactly 'size' bytes) read.
+	 * Set 'err' to non-zero and return NULL in case of error.
+	 * 'err' set to zero (no error) should be used to return from c9process
+	 * early (timeout on read to do non-blocking operations, for example).
+	 */
+	uint8_t *(*read)(C9ctx *ctx, uint32_t size, int *err) __attribute__((nonnull(1, 3)));
+
+	/* Should return a buffer to store 'size' bytes. Nil means no memory. */
+	uint8_t *(*begin)(C9ctx *ctx, uint32_t size) __attribute__((nonnull(1)));
+
+	/*
+	 * Marks the end of a message. Callback may decide if any accumulated
+	 * messages should be sent to the server/client.
+	 */
+	int (*end)(C9ctx *ctx) __attribute__((nonnull(1)));
+
+	/* Callback called every time a new R-message is received. */
+	void (*r)(C9ctx *ctx, C9r *r) __attribute__((nonnull(1, 2)));
+
+	/* Callback called every time a new T-message is received. */
+	void (*t)(C9ctx *ctx, C9t *t) __attribute__((nonnull(1, 2)));
+
+	/* Callback for error messages. */
+	void (*error)(const char *fmt, ...) __attribute__((nonnull(1)));
+
+	/* Auxiliary data, can be used by any of above callbacks. */
+	struct C9aux *aux;
+
+	/* private stuff */
+	uint32_t msize;
+	uint32_t flush[C9maxflush];
+	uint32_t tags[C9maxtags/C9tagsbits];
+	union
+	{
+		C9tag lowfreetag;
+		uint16_t svflags;
+	};
+};
+
+/* Parse one directory entry. */
+extern C9error c9parsedir(C9ctx *c, C9stat *stat, uint8_t **data, uint32_t *size) __attribute__((nonnull(1, 2, 3)));
+
+extern C9error c9version(C9ctx *c, C9tag *tag, uint32_t msize) __attribute__((nonnull(1, 2)));
+extern C9error c9auth(C9ctx *c, C9tag *tag, C9fid afid, const char *uname, const char *aname) __attribute__((nonnull(1, 2)));
+extern C9error c9flush(C9ctx *c, C9tag *tag, C9tag oldtag) __attribute__((nonnull(1, 2)));
+extern C9error c9attach(C9ctx *c, C9tag *tag, C9fid fid, C9fid afid, const char *uname, const char *aname) __attribute__((nonnull(1, 2)));
+extern C9error c9walk(C9ctx *c, C9tag *tag, C9fid fid, C9fid newfid, const char *path[]) __attribute__((nonnull(1, 2, 5)));
+extern C9error c9open(C9ctx *c, C9tag *tag, C9fid fid, C9mode mode) __attribute__((nonnull(1, 2)));
+extern C9error c9create(C9ctx *c, C9tag *tag, C9fid fid, const char *name, uint32_t perm, C9mode mode) __attribute__((nonnull(1, 2, 4)));
+extern C9error c9read(C9ctx *c, C9tag *tag, C9fid fid, uint64_t offset, uint32_t count) __attribute__((nonnull(1, 2)));
+extern C9error c9write(C9ctx *c, C9tag *tag, C9fid fid, uint64_t offset, const void *in, uint32_t count) __attribute__((nonnull(1, 2, 5)));
+extern C9error c9wrstr(C9ctx *c, C9tag *tag, C9fid fid, const char *s) __attribute__((nonnull(1, 2, 4)));
+extern C9error c9clunk(C9ctx *c, C9tag *tag, C9fid fid) __attribute__((nonnull(1, 2)));
+extern C9error c9remove(C9ctx *c, C9tag *tag, C9fid fid) __attribute__((nonnull(1, 2)));
+extern C9error c9stat(C9ctx *c, C9tag *tag, C9fid fid) __attribute__((nonnull(1, 2)));
+extern C9error c9wstat(C9ctx *c, C9tag *tag, C9fid fid, const C9stat *s) __attribute__((nonnull(1, 2, 4)));
+
+/*
+ * Wait until a response comes and process it. If the function returns
+ * any error, context must be treated as 'broken' and no subsequent calls
+ * should be made without reinitialization (c9version).
+ */
+extern C9error c9proc(C9ctx *c) __attribute__((nonnull(1)));
+
+extern C9error s9version(C9ctx *c) __attribute__((nonnull(1)));
+extern C9error s9auth(C9ctx *c, C9tag tag, const C9qid *aqid) __attribute__((nonnull(1, 3)));
+extern C9error s9error(C9ctx *c, C9tag tag, const char *err) __attribute__((nonnull(1)));
+extern C9error s9attach(C9ctx *c, C9tag tag, const C9qid *qid) __attribute__((nonnull(1, 3)));
+extern C9error s9flush(C9ctx *c, C9tag tag) __attribute__((nonnull(1)));
+extern C9error s9walk(C9ctx *c, C9tag tag, C9qid *qids[]) __attribute__((nonnull(1, 3)));
+extern C9error s9open(C9ctx *c, C9tag tag, const C9qid *qid, uint32_t iounit) __attribute__((nonnull(1, 3)));
+extern C9error s9create(C9ctx *c, C9tag tag, const C9qid *qid, uint32_t iounit) __attribute__((nonnull(1, 3)));
+extern C9error s9read(C9ctx *c, C9tag tag, const void *data, uint32_t size) __attribute__((nonnull(1, 3)));
+extern C9error s9readdir(C9ctx *c, C9tag tag, C9stat *st[], int *num, uint64_t *offset, uint32_t size) __attribute__((nonnull(1, 3, 4)));
+extern C9error s9write(C9ctx *c, C9tag tag, uint32_t size) __attribute__((nonnull(1)));
+extern C9error s9clunk(C9ctx *c, C9tag tag) __attribute__((nonnull(1)));
+extern C9error s9remove(C9ctx *c, C9tag tag) __attribute__((nonnull(1)));
+extern C9error s9stat(C9ctx *c, C9tag tag, const C9stat *s) __attribute__((nonnull(1, 3)));
+extern C9error s9wstat(C9ctx *c, C9tag tag) __attribute__((nonnull(1)));
+
+extern C9error s9proc(C9ctx *c) __attribute__((nonnull(1)));