From e5888a1ffdae813d7575f5fb02275c6bb07e5199 Mon Sep 17 00:00:00 2001
From: Taru Karttunen <taruti@taruti.net>
Date: Wed, 30 Mar 2011 15:46:40 +0300
Subject: Import sources from 2011-03-30 iso image

---
 sys/src/libsunrpc/nfs3.c | 4045 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 4045 insertions(+)
 create mode 100755 sys/src/libsunrpc/nfs3.c

(limited to 'sys/src/libsunrpc/nfs3.c')

diff --git a/sys/src/libsunrpc/nfs3.c b/sys/src/libsunrpc/nfs3.c
new file mode 100755
index 000000000..eb722f1ff
--- /dev/null
+++ b/sys/src/libsunrpc/nfs3.c
@@ -0,0 +1,4045 @@
+#include <u.h>
+#include <libc.h>
+#include <thread.h>
+#include <sunrpc.h>
+#include <nfs3.h>
+
+char*
+nfs3StatusStr(Nfs3Status x)
+{
+	switch(x){
+	case Nfs3Ok:
+		return "Nfs3Ok";
+	case Nfs3ErrNotOwner:
+		return "Nfs3ErrNotOwner";
+	case Nfs3ErrNoEnt:
+		return "Nfs3ErrNoEnt";
+	case Nfs3ErrNoMem:
+		return "Nfs3ErrNoMem";
+	case Nfs3ErrIo:
+		return "Nfs3ErrIo";
+	case Nfs3ErrNxio:
+		return "Nfs3ErrNxio";
+	case Nfs3ErrAcces:
+		return "Nfs3ErrAcces";
+	case Nfs3ErrExist:
+		return "Nfs3ErrExist";
+	case Nfs3ErrXDev:
+		return "Nfs3ErrXDev";
+	case Nfs3ErrNoDev:
+		return "Nfs3ErrNoDev";
+	case Nfs3ErrNotDir:
+		return "Nfs3ErrNotDir";
+	case Nfs3ErrIsDir:
+		return "Nfs3ErrIsDir";
+	case Nfs3ErrInval:
+		return "Nfs3ErrInval";
+	case Nfs3ErrFbig:
+		return "Nfs3ErrFbig";
+	case Nfs3ErrNoSpc:
+		return "Nfs3ErrNoSpc";
+	case Nfs3ErrRoFs:
+		return "Nfs3ErrRoFs";
+	case Nfs3ErrMLink:
+		return "Nfs3ErrMLink";
+	case Nfs3ErrNameTooLong:
+		return "Nfs3ErrNameTooLong";
+	case Nfs3ErrNotEmpty:
+		return "Nfs3ErrNotEmpty";
+	case Nfs3ErrDQuot:
+		return "Nfs3ErrDQuot";
+	case Nfs3ErrStale:
+		return "Nfs3ErrStale";
+	case Nfs3ErrRemote:
+		return "Nfs3ErrRemote";
+	case Nfs3ErrBadHandle:
+		return "Nfs3ErrBadHandle";
+	case Nfs3ErrNotSync:
+		return "Nfs3ErrNotSync";
+	case Nfs3ErrBadCookie:
+		return "Nfs3ErrBadCookie";
+	case Nfs3ErrNotSupp:
+		return "Nfs3ErrNotSupp";
+	case Nfs3ErrTooSmall:
+		return "Nfs3ErrTooSmall";
+	case Nfs3ErrServerFault:
+		return "Nfs3ErrServerFault";
+	case Nfs3ErrBadType:
+		return "Nfs3ErrBadType";
+	case Nfs3ErrJukebox:
+		return "Nfs3ErrJukebox";
+	case Nfs3ErrFprintNotFound:
+		return "Nfs3ErrFprintNotFound";
+	case Nfs3ErrAborted:
+		return "Nfs3ErrAborted";
+	default:
+		return "unknown";
+	}
+}
+
+static struct {
+	SunStatus status;
+	char *msg;
+} etab[] = {
+	Nfs3ErrNotOwner,	"not owner",
+	Nfs3ErrNoEnt,		"directory entry not found",
+	Nfs3ErrIo,			"i/o error",
+	Nfs3ErrNxio,		"no such device",
+	Nfs3ErrNoMem,	"out of memory",
+	Nfs3ErrAcces,		"access denied",
+	Nfs3ErrExist,		"file or directory exists",
+	Nfs3ErrXDev,		"cross-device operation",
+	Nfs3ErrNoDev,		"no such device",
+	Nfs3ErrNotDir,		"not a directory",
+	Nfs3ErrIsDir,		"is a directory",
+	Nfs3ErrInval,		"invalid arguments",
+	Nfs3ErrFbig,		"file too big",
+	Nfs3ErrNoSpc,		"no space left on device",
+	Nfs3ErrRoFs,		"read-only file system",
+	Nfs3ErrMLink,		"too many links",
+	Nfs3ErrNameTooLong,	"name too long",
+	Nfs3ErrNotEmpty,	"directory not empty",
+	Nfs3ErrDQuot,		"dquot",
+	Nfs3ErrStale,		"stale handle",
+	Nfs3ErrRemote,	"remote error",
+	Nfs3ErrBadHandle,	"bad handle",
+	Nfs3ErrNotSync,	"out of sync with server",
+	Nfs3ErrBadCookie,	"bad cookie",
+	Nfs3ErrNotSupp,	"not supported",
+	Nfs3ErrTooSmall,	"too small",
+	Nfs3ErrServerFault,	"server fault",
+	Nfs3ErrBadType,	"bad type",
+	Nfs3ErrJukebox,	"jukebox -- try again later",
+	Nfs3ErrFprintNotFound,	"fprint not found",
+	Nfs3ErrAborted,	"aborted",
+};
+
+void
+nfs3Errstr(SunStatus status)
+{
+	int i;
+
+	for(i=0; i<nelem(etab); i++){
+		if(etab[i].status == status){
+			werrstr(etab[i].msg);
+			return;
+		}
+	}
+	werrstr("unknown nfs3 error %d", (int)status);
+}
+
+char*
+nfs3FileTypeStr(Nfs3FileType x)
+{
+	switch(x){
+	case Nfs3FileReg:
+		return "Nfs3FileReg";
+	case Nfs3FileDir:
+		return "Nfs3FileDir";
+	case Nfs3FileBlock:
+		return "Nfs3FileBlock";
+	case Nfs3FileChar:
+		return "Nfs3FileChar";
+	case Nfs3FileSymlink:
+		return "Nfs3FileSymlink";
+	case Nfs3FileSocket:
+		return "Nfs3FileSocket";
+	case Nfs3FileFifo:
+		return "Nfs3FileFifo";
+	default:
+		return "unknown";
+	}
+}
+
+void
+nfs3HandlePrint(Fmt *fmt, Nfs3Handle *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3Handle");
+	fmtprint(fmt, "\t%s=", "handle");
+	if(x->len > 64)
+		fmtprint(fmt, "%.*H... (%d)", 64, x->h, x->len);
+	else
+		fmtprint(fmt, "%.*H", x->len, x->h);
+	fmtprint(fmt, "\n");
+}
+uint
+nfs3HandleSize(Nfs3Handle *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + sunVarOpaqueSize(x->len);
+	return a;
+}
+int
+nfs3HandlePack(uchar *a, uchar *ea, uchar **pa, Nfs3Handle *x)
+{
+	if(x->len > Nfs3MaxHandleSize || sunUint32Pack(a, ea, &a, &x->len) < 0
+	|| sunFixedOpaquePack(a, ea, &a, x->h, x->len) < 0)
+		goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3HandleUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3Handle *x)
+{
+	uchar *ha;
+	u32int n;
+
+	if(sunUint32Unpack(a, ea, &a, &n) < 0 || n > Nfs3MaxHandleSize)
+		goto Err;
+	ha = a;
+	a += (n+3)&~3;
+	if(a > ea)
+		goto Err;
+	memmove(x->h, ha, n);
+	x->len = n;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3TimePrint(Fmt *fmt, Nfs3Time *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3Time");
+	fmtprint(fmt, "\t%s=", "sec");
+	fmtprint(fmt, "%ud", x->sec);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "nsec");
+	fmtprint(fmt, "%ud", x->nsec);
+	fmtprint(fmt, "\n");
+}
+uint
+nfs3TimeSize(Nfs3Time *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + 4 + 4;
+	return a;
+}
+int
+nfs3TimePack(uchar *a, uchar *ea, uchar **pa, Nfs3Time *x)
+{
+	if(sunUint32Pack(a, ea, &a, &x->sec) < 0) goto Err;
+	if(sunUint32Pack(a, ea, &a, &x->nsec) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3TimeUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3Time *x)
+{
+	if(sunUint32Unpack(a, ea, &a, &x->sec) < 0) goto Err;
+	if(sunUint32Unpack(a, ea, &a, &x->nsec) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3AttrPrint(Fmt *fmt, Nfs3Attr *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3Attr");
+	fmtprint(fmt, "\t%s=", "type");
+	fmtprint(fmt, "%s", nfs3FileTypeStr(x->type));
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "mode");
+	fmtprint(fmt, "%ud", x->mode);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "nlink");
+	fmtprint(fmt, "%ud", x->nlink);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "uid");
+	fmtprint(fmt, "%ud", x->uid);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "gid");
+	fmtprint(fmt, "%ud", x->gid);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "size");
+	fmtprint(fmt, "%llud", x->size);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "used");
+	fmtprint(fmt, "%llud", x->used);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "major");
+	fmtprint(fmt, "%ud", x->major);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "minor");
+	fmtprint(fmt, "%ud", x->minor);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "fsid");
+	fmtprint(fmt, "%llud", x->fsid);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "fileid");
+	fmtprint(fmt, "%llud", x->fileid);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "atime");
+	nfs3TimePrint(fmt, &x->atime);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "mtime");
+	nfs3TimePrint(fmt, &x->mtime);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "ctime");
+	nfs3TimePrint(fmt, &x->ctime);
+	fmtprint(fmt, "\n");
+}
+uint
+nfs3AttrSize(Nfs3Attr *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + 4 + 4 + 4 + 4 + 4 + 8 + 8 + 4 + 4 + 8 + 8 + nfs3TimeSize(&x->atime) + nfs3TimeSize(&x->mtime) + nfs3TimeSize(&x->ctime);
+	return a;
+}
+int
+nfs3AttrPack(uchar *a, uchar *ea, uchar **pa, Nfs3Attr *x)
+{
+	int i;
+
+	if(i=x->type, sunEnumPack(a, ea, &a, &i) < 0) goto Err;
+	if(sunUint32Pack(a, ea, &a, &x->mode) < 0) goto Err;
+	if(sunUint32Pack(a, ea, &a, &x->nlink) < 0) goto Err;
+	if(sunUint32Pack(a, ea, &a, &x->uid) < 0) goto Err;
+	if(sunUint32Pack(a, ea, &a, &x->gid) < 0) goto Err;
+	if(sunUint64Pack(a, ea, &a, &x->size) < 0) goto Err;
+	if(sunUint64Pack(a, ea, &a, &x->used) < 0) goto Err;
+	if(sunUint32Pack(a, ea, &a, &x->major) < 0) goto Err;
+	if(sunUint32Pack(a, ea, &a, &x->minor) < 0) goto Err;
+	if(sunUint64Pack(a, ea, &a, &x->fsid) < 0) goto Err;
+	if(sunUint64Pack(a, ea, &a, &x->fileid) < 0) goto Err;
+	if(nfs3TimePack(a, ea, &a, &x->atime) < 0) goto Err;
+	if(nfs3TimePack(a, ea, &a, &x->mtime) < 0) goto Err;
+	if(nfs3TimePack(a, ea, &a, &x->ctime) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3AttrUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3Attr *x)
+{
+	int i;
+	if(sunEnumUnpack(a, ea, &a, &i) < 0) goto Err; x->type = i;
+	if(sunUint32Unpack(a, ea, &a, &x->mode) < 0) goto Err;
+	if(sunUint32Unpack(a, ea, &a, &x->nlink) < 0) goto Err;
+	if(sunUint32Unpack(a, ea, &a, &x->uid) < 0) goto Err;
+	if(sunUint32Unpack(a, ea, &a, &x->gid) < 0) goto Err;
+	if(sunUint64Unpack(a, ea, &a, &x->size) < 0) goto Err;
+	if(sunUint64Unpack(a, ea, &a, &x->used) < 0) goto Err;
+	if(sunUint32Unpack(a, ea, &a, &x->major) < 0) goto Err;
+	if(sunUint32Unpack(a, ea, &a, &x->minor) < 0) goto Err;
+	if(sunUint64Unpack(a, ea, &a, &x->fsid) < 0) goto Err;
+	if(sunUint64Unpack(a, ea, &a, &x->fileid) < 0) goto Err;
+	if(nfs3TimeUnpack(a, ea, &a, &x->atime) < 0) goto Err;
+	if(nfs3TimeUnpack(a, ea, &a, &x->mtime) < 0) goto Err;
+	if(nfs3TimeUnpack(a, ea, &a, &x->ctime) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3WccAttrPrint(Fmt *fmt, Nfs3WccAttr *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3WccAttr");
+	fmtprint(fmt, "\t%s=", "size");
+	fmtprint(fmt, "%llud", x->size);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "mtime");
+	nfs3TimePrint(fmt, &x->mtime);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "ctime");
+	nfs3TimePrint(fmt, &x->ctime);
+	fmtprint(fmt, "\n");
+}
+uint
+nfs3WccAttrSize(Nfs3WccAttr *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + 8 + nfs3TimeSize(&x->mtime) + nfs3TimeSize(&x->ctime);
+	return a;
+}
+int
+nfs3WccAttrPack(uchar *a, uchar *ea, uchar **pa, Nfs3WccAttr *x)
+{
+	if(sunUint64Pack(a, ea, &a, &x->size) < 0) goto Err;
+	if(nfs3TimePack(a, ea, &a, &x->mtime) < 0) goto Err;
+	if(nfs3TimePack(a, ea, &a, &x->ctime) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3WccAttrUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3WccAttr *x)
+{
+	if(sunUint64Unpack(a, ea, &a, &x->size) < 0) goto Err;
+	if(nfs3TimeUnpack(a, ea, &a, &x->mtime) < 0) goto Err;
+	if(nfs3TimeUnpack(a, ea, &a, &x->ctime) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3WccPrint(Fmt *fmt, Nfs3Wcc *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3Wcc");
+	fmtprint(fmt, "\t%s=", "haveWccAttr");
+	fmtprint(fmt, "%d", x->haveWccAttr);
+	fmtprint(fmt, "\n");
+	switch(x->haveWccAttr){
+	case 1:
+		fmtprint(fmt, "\t%s=", "wccAttr");
+		nfs3WccAttrPrint(fmt, &x->wccAttr);
+		fmtprint(fmt, "\n");
+		break;
+	}
+	fmtprint(fmt, "\t%s=", "haveAttr");
+	fmtprint(fmt, "%d", x->haveAttr);
+	fmtprint(fmt, "\n");
+	switch(x->haveAttr){
+	case 1:
+		fmtprint(fmt, "\t%s=", "attr");
+		nfs3AttrPrint(fmt, &x->attr);
+		fmtprint(fmt, "\n");
+		break;
+	}
+}
+uint
+nfs3WccSize(Nfs3Wcc *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + 4;
+	switch(x->haveWccAttr){
+	case 1:
+		a = a + nfs3WccAttrSize(&x->wccAttr);
+		break;
+	}
+	a = a + 4;
+	switch(x->haveAttr){
+	case 1:
+		a = a + nfs3AttrSize(&x->attr);
+		break;
+	}
+	return a;
+}
+int
+nfs3WccPack(uchar *a, uchar *ea, uchar **pa, Nfs3Wcc *x)
+{
+	if(sunUint1Pack(a, ea, &a, &x->haveWccAttr) < 0) goto Err;
+	switch(x->haveWccAttr){
+	case 1:
+		if(nfs3WccAttrPack(a, ea, &a, &x->wccAttr) < 0) goto Err;
+		break;
+	}
+	if(sunUint1Pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
+	switch(x->haveAttr){
+	case 1:
+		if(nfs3AttrPack(a, ea, &a, &x->attr) < 0) goto Err;
+		break;
+	}
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3WccUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3Wcc *x)
+{
+	if(sunUint1Unpack(a, ea, &a, &x->haveWccAttr) < 0) goto Err;
+	switch(x->haveWccAttr){
+	case 1:
+		if(nfs3WccAttrUnpack(a, ea, &a, &x->wccAttr) < 0) goto Err;
+		break;
+	}
+	if(sunUint1Unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
+	switch(x->haveAttr){
+	case 1:
+		if(nfs3AttrUnpack(a, ea, &a, &x->attr) < 0) goto Err;
+		break;
+	}
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+char*
+nfs3SetTimeStr(Nfs3SetTime x)
+{
+	switch(x){
+	case Nfs3SetTimeDont:
+		return "Nfs3SetTimeDont";
+	case Nfs3SetTimeServer:
+		return "Nfs3SetTimeServer";
+	case Nfs3SetTimeClient:
+		return "Nfs3SetTimeClient";
+	default:
+		return "unknown";
+	}
+}
+
+void
+nfs3SetAttrPrint(Fmt *fmt, Nfs3SetAttr *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3SetAttr");
+	fmtprint(fmt, "\t%s=", "setMode");
+	fmtprint(fmt, "%d", x->setMode);
+	fmtprint(fmt, "\n");
+	switch(x->setMode){
+	case 1:
+		fmtprint(fmt, "\t%s=", "mode");
+		fmtprint(fmt, "%ud", x->mode);
+		fmtprint(fmt, "\n");
+		break;
+	}
+	fmtprint(fmt, "\t%s=", "setUid");
+	fmtprint(fmt, "%d", x->setUid);
+	fmtprint(fmt, "\n");
+	switch(x->setUid){
+	case 1:
+		fmtprint(fmt, "\t%s=", "uid");
+		fmtprint(fmt, "%ud", x->uid);
+		fmtprint(fmt, "\n");
+		break;
+	}
+	fmtprint(fmt, "\t%s=", "setGid");
+	fmtprint(fmt, "%d", x->setGid);
+	fmtprint(fmt, "\n");
+	switch(x->setGid){
+	case 1:
+		fmtprint(fmt, "\t%s=", "gid");
+		fmtprint(fmt, "%ud", x->gid);
+		fmtprint(fmt, "\n");
+		break;
+	}
+	fmtprint(fmt, "\t%s=", "setSize");
+	fmtprint(fmt, "%d", x->setSize);
+	fmtprint(fmt, "\n");
+	switch(x->setSize){
+	case 1:
+		fmtprint(fmt, "\t%s=", "size");
+		fmtprint(fmt, "%llud", x->size);
+		fmtprint(fmt, "\n");
+		break;
+	}
+	fmtprint(fmt, "\t%s=", "setAtime");
+	fmtprint(fmt, "%s", nfs3SetTimeStr(x->setAtime));
+	fmtprint(fmt, "\n");
+	switch(x->setAtime){
+	case Nfs3SetTimeClient:
+		fmtprint(fmt, "\t%s=", "atime");
+		nfs3TimePrint(fmt, &x->atime);
+		fmtprint(fmt, "\n");
+		break;
+	}
+	fmtprint(fmt, "\t%s=", "setMtime");
+	fmtprint(fmt, "%s", nfs3SetTimeStr(x->setMtime));
+	fmtprint(fmt, "\n");
+	switch(x->setMtime){
+	case Nfs3SetTimeClient:
+		fmtprint(fmt, "\t%s=", "mtime");
+		nfs3TimePrint(fmt, &x->mtime);
+		fmtprint(fmt, "\n");
+		break;
+	}
+}
+uint
+nfs3SetAttrSize(Nfs3SetAttr *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + 4;
+	switch(x->setMode){
+	case 1:
+		a = a + 4;
+		break;
+	}
+	a = a + 4;
+	switch(x->setUid){
+	case 1:
+		a = a + 4;
+		break;
+	}
+	a = a + 4;
+	switch(x->setGid){
+	case 1:
+		a = a + 4;
+		break;
+	}
+	a = a + 4;
+	switch(x->setSize){
+	case 1:
+		a = a + 8;
+		break;
+	}
+	a = a + 4;
+	switch(x->setAtime){
+	case Nfs3SetTimeClient:
+		a = a + nfs3TimeSize(&x->atime);
+		break;
+	}
+	a = a + 4;
+	switch(x->setMtime){
+	case Nfs3SetTimeClient:
+		a = a + nfs3TimeSize(&x->mtime);
+		break;
+	}
+	return a;
+}
+int
+nfs3SetAttrPack(uchar *a, uchar *ea, uchar **pa, Nfs3SetAttr *x)
+{
+	int i;
+
+	if(sunUint1Pack(a, ea, &a, &x->setMode) < 0) goto Err;
+	switch(x->setMode){
+	case 1:
+		if(sunUint32Pack(a, ea, &a, &x->mode) < 0) goto Err;
+		break;
+	}
+	if(sunUint1Pack(a, ea, &a, &x->setUid) < 0) goto Err;
+	switch(x->setUid){
+	case 1:
+		if(sunUint32Pack(a, ea, &a, &x->uid) < 0) goto Err;
+		break;
+	}
+	if(sunUint1Pack(a, ea, &a, &x->setGid) < 0) goto Err;
+	switch(x->setGid){
+	case 1:
+		if(sunUint32Pack(a, ea, &a, &x->gid) < 0) goto Err;
+		break;
+	}
+	if(sunUint1Pack(a, ea, &a, &x->setSize) < 0) goto Err;
+	switch(x->setSize){
+	case 1:
+		if(sunUint64Pack(a, ea, &a, &x->size) < 0) goto Err;
+		break;
+	}
+	if(i=x->setAtime, sunEnumPack(a, ea, &a, &i) < 0) goto Err;
+	switch(x->setAtime){
+	case Nfs3SetTimeClient:
+		if(nfs3TimePack(a, ea, &a, &x->atime) < 0) goto Err;
+		break;
+	}
+	if(i=x->setMtime, sunEnumPack(a, ea, &a, &i) < 0) goto Err;
+	switch(x->setMtime){
+	case Nfs3SetTimeClient:
+		if(nfs3TimePack(a, ea, &a, &x->mtime) < 0) goto Err;
+		break;
+	}
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3SetAttrUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3SetAttr *x)
+{
+	int i;
+
+	if(sunUint1Unpack(a, ea, &a, &x->setMode) < 0) goto Err;
+	switch(x->setMode){
+	case 1:
+		if(sunUint32Unpack(a, ea, &a, &x->mode) < 0) goto Err;
+		break;
+	}
+	if(sunUint1Unpack(a, ea, &a, &x->setUid) < 0) goto Err;
+	switch(x->setUid){
+	case 1:
+		if(sunUint32Unpack(a, ea, &a, &x->uid) < 0) goto Err;
+		break;
+	}
+	if(sunUint1Unpack(a, ea, &a, &x->setGid) < 0) goto Err;
+	switch(x->setGid){
+	case 1:
+		if(sunUint32Unpack(a, ea, &a, &x->gid) < 0) goto Err;
+		break;
+	}
+	if(sunUint1Unpack(a, ea, &a, &x->setSize) < 0) goto Err;
+	switch(x->setSize){
+	case 1:
+		if(sunUint64Unpack(a, ea, &a, &x->size) < 0) goto Err;
+		break;
+	}
+	if(sunEnumUnpack(a, ea, &a, &i) < 0) goto Err; x->setAtime = i;
+	switch(x->setAtime){
+	case Nfs3SetTimeClient:
+		if(nfs3TimeUnpack(a, ea, &a, &x->atime) < 0) goto Err;
+		break;
+	}
+	if(sunEnumUnpack(a, ea, &a, &i) < 0) goto Err; x->setMtime = i;
+	switch(x->setMtime){
+	case Nfs3SetTimeClient:
+		if(nfs3TimeUnpack(a, ea, &a, &x->mtime) < 0) goto Err;
+		break;
+	}
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3TNullPrint(Fmt *fmt, Nfs3TNull *x)
+{
+	USED(x);
+	fmtprint(fmt, "%s\n", "Nfs3TNull");
+}
+uint
+nfs3TNullSize(Nfs3TNull *x)
+{
+	uint a;
+	USED(x);
+	a = 0;
+	return a;
+}
+int
+nfs3TNullPack(uchar *a, uchar *ea, uchar **pa, Nfs3TNull *x)
+{
+	USED(x);
+	USED(ea);
+	*pa = a;
+	return 0;
+}
+int
+nfs3TNullUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3TNull *x)
+{
+	USED(x);
+	USED(ea);
+	*pa = a;
+	return 0;
+}
+void
+nfs3RNullPrint(Fmt *fmt, Nfs3RNull *x)
+{
+	USED(x);
+	fmtprint(fmt, "%s\n", "Nfs3RNull");
+}
+uint
+nfs3RNullSize(Nfs3RNull *x)
+{
+	uint a;
+	USED(x);
+	a = 0;
+	return a;
+}
+int
+nfs3RNullPack(uchar *a, uchar *ea, uchar **pa, Nfs3RNull *x)
+{
+	USED(ea);
+	USED(x);
+	*pa = a;
+	return 0;
+}
+int
+nfs3RNullUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3RNull *x)
+{
+	USED(ea);
+	USED(x);
+	*pa = a;
+	return 0;
+}
+void
+nfs3TGetattrPrint(Fmt *fmt, Nfs3TGetattr *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3TGetattr");
+	fmtprint(fmt, "\t%s=", "handle");
+	nfs3HandlePrint(fmt, &x->handle);
+	fmtprint(fmt, "\n");
+}
+uint
+nfs3TGetattrSize(Nfs3TGetattr *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + nfs3HandleSize(&x->handle);
+	return a;
+}
+int
+nfs3TGetattrPack(uchar *a, uchar *ea, uchar **pa, Nfs3TGetattr *x)
+{
+	if(nfs3HandlePack(a, ea, &a, &x->handle) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3TGetattrUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3TGetattr *x)
+{
+	if(nfs3HandleUnpack(a, ea, &a, &x->handle) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3RGetattrPrint(Fmt *fmt, Nfs3RGetattr *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3RGetattr");
+	fmtprint(fmt, "\t%s=", "status");
+	fmtprint(fmt, "%s", nfs3StatusStr(x->status));
+	fmtprint(fmt, "\n");
+	switch(x->status){
+	case Nfs3Ok:
+		fmtprint(fmt, "\t%s=", "attr");
+		nfs3AttrPrint(fmt, &x->attr);
+		fmtprint(fmt, "\n");
+		break;
+	}
+}
+uint
+nfs3RGetattrSize(Nfs3RGetattr *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + 4;
+	switch(x->status){
+	case Nfs3Ok:
+		a = a + nfs3AttrSize(&x->attr);
+		break;
+	}
+	return a;
+}
+int
+nfs3RGetattrPack(uchar *a, uchar *ea, uchar **pa, Nfs3RGetattr *x)
+{
+	int i;
+
+	if(i=x->status, sunEnumPack(a, ea, &a, &i) < 0) goto Err;
+	switch(x->status){
+	case Nfs3Ok:
+		if(nfs3AttrPack(a, ea, &a, &x->attr) < 0) goto Err;
+		break;
+	}
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3RGetattrUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3RGetattr *x)
+{
+	int i;
+
+	if(sunEnumUnpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
+	switch(x->status){
+	case Nfs3Ok:
+		if(nfs3AttrUnpack(a, ea, &a, &x->attr) < 0) goto Err;
+		break;
+	}
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3TSetattrPrint(Fmt *fmt, Nfs3TSetattr *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3TSetattr");
+	fmtprint(fmt, "\t%s=", "handle");
+	nfs3HandlePrint(fmt, &x->handle);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "attr");
+	nfs3SetAttrPrint(fmt, &x->attr);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "checkCtime");
+	fmtprint(fmt, "%d", x->checkCtime);
+	fmtprint(fmt, "\n");
+	switch(x->checkCtime){
+	case 1:
+		fmtprint(fmt, "\t%s=", "ctime");
+		nfs3TimePrint(fmt, &x->ctime);
+		fmtprint(fmt, "\n");
+		break;
+	}
+}
+uint
+nfs3TSetattrSize(Nfs3TSetattr *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + nfs3HandleSize(&x->handle) + nfs3SetAttrSize(&x->attr) + 4;
+	switch(x->checkCtime){
+	case 1:
+		a = a + nfs3TimeSize(&x->ctime);
+		break;
+	}
+	return a;
+}
+int
+nfs3TSetattrPack(uchar *a, uchar *ea, uchar **pa, Nfs3TSetattr *x)
+{
+	if(nfs3HandlePack(a, ea, &a, &x->handle) < 0) goto Err;
+	if(nfs3SetAttrPack(a, ea, &a, &x->attr) < 0) goto Err;
+	if(sunUint1Pack(a, ea, &a, &x->checkCtime) < 0) goto Err;
+	switch(x->checkCtime){
+	case 1:
+		if(nfs3TimePack(a, ea, &a, &x->ctime) < 0) goto Err;
+		break;
+	}
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3TSetattrUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3TSetattr *x)
+{
+	if(nfs3HandleUnpack(a, ea, &a, &x->handle) < 0) goto Err;
+	if(nfs3SetAttrUnpack(a, ea, &a, &x->attr) < 0) goto Err;
+	if(sunUint1Unpack(a, ea, &a, &x->checkCtime) < 0) goto Err;
+	switch(x->checkCtime){
+	case 1:
+		if(nfs3TimeUnpack(a, ea, &a, &x->ctime) < 0) goto Err;
+		break;
+	}
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3RSetattrPrint(Fmt *fmt, Nfs3RSetattr *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3RSetattr");
+	fmtprint(fmt, "\t%s=", "status");
+	fmtprint(fmt, "%s", nfs3StatusStr(x->status));
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "wcc");
+	nfs3WccPrint(fmt, &x->wcc);
+	fmtprint(fmt, "\n");
+}
+uint
+nfs3RSetattrSize(Nfs3RSetattr *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + 4 + nfs3WccSize(&x->wcc);
+	return a;
+}
+int
+nfs3RSetattrPack(uchar *a, uchar *ea, uchar **pa, Nfs3RSetattr *x)
+{
+	int i;
+
+	if(i=x->status, sunEnumPack(a, ea, &a, &i) < 0) goto Err;
+	if(nfs3WccPack(a, ea, &a, &x->wcc) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3RSetattrUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3RSetattr *x)
+{
+	int i;
+
+	if(sunEnumUnpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
+	if(nfs3WccUnpack(a, ea, &a, &x->wcc) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3TLookupPrint(Fmt *fmt, Nfs3TLookup *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3TLookup");
+	fmtprint(fmt, "\t%s=", "handle");
+	nfs3HandlePrint(fmt, &x->handle);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "name");
+	fmtprint(fmt, "\"%s\"", x->name);
+	fmtprint(fmt, "\n");
+}
+uint
+nfs3TLookupSize(Nfs3TLookup *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + nfs3HandleSize(&x->handle) + sunStringSize(x->name);
+	return a;
+}
+int
+nfs3TLookupPack(uchar *a, uchar *ea, uchar **pa, Nfs3TLookup *x)
+{
+	if(nfs3HandlePack(a, ea, &a, &x->handle) < 0) goto Err;
+	if(sunStringPack(a, ea, &a, &x->name, -1) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3TLookupUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3TLookup *x)
+{
+	if(nfs3HandleUnpack(a, ea, &a, &x->handle) < 0) goto Err;
+	if(sunStringUnpack(a, ea, &a, &x->name, -1) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3RLookupPrint(Fmt *fmt, Nfs3RLookup *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3RLookup");
+	fmtprint(fmt, "\t%s=", "status");
+	fmtprint(fmt, "%s", nfs3StatusStr(x->status));
+	fmtprint(fmt, "\n");
+	switch(x->status){
+	case Nfs3Ok:
+		fmtprint(fmt, "\t%s=", "handle");
+		nfs3HandlePrint(fmt, &x->handle);
+		fmtprint(fmt, "\n");
+		fmtprint(fmt, "\t%s=", "haveAttr");
+		fmtprint(fmt, "%d", x->haveAttr);
+		fmtprint(fmt, "\n");
+		switch(x->haveAttr){
+		case 1:
+			fmtprint(fmt, "\t%s=", "attr");
+			nfs3AttrPrint(fmt, &x->attr);
+			fmtprint(fmt, "\n");
+			break;
+		}
+		break;
+	}
+	fmtprint(fmt, "\t%s=", "haveDirAttr");
+	fmtprint(fmt, "%d", x->haveDirAttr);
+	fmtprint(fmt, "\n");
+	switch(x->haveDirAttr){
+	case 1:
+		fmtprint(fmt, "\t%s=", "dirAttr");
+		nfs3AttrPrint(fmt, &x->dirAttr);
+		fmtprint(fmt, "\n");
+		break;
+	}
+}
+uint
+nfs3RLookupSize(Nfs3RLookup *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + 4;
+	switch(x->status){
+	case Nfs3Ok:
+		a = a + nfs3HandleSize(&x->handle) + 4;
+		switch(x->haveAttr){
+		case 1:
+			a = a + nfs3AttrSize(&x->attr);
+			break;
+		}
+			break;
+	}
+	a = a + 4;
+	switch(x->haveDirAttr){
+	case 1:
+		a = a + nfs3AttrSize(&x->dirAttr);
+		break;
+	}
+	return a;
+}
+int
+nfs3RLookupPack(uchar *a, uchar *ea, uchar **pa, Nfs3RLookup *x)
+{
+	int i;
+
+	if(i=x->status, sunEnumPack(a, ea, &a, &i) < 0) goto Err;
+	switch(x->status){
+	case Nfs3Ok:
+		if(nfs3HandlePack(a, ea, &a, &x->handle) < 0) goto Err;
+		if(sunUint1Pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
+		switch(x->haveAttr){
+		case 1:
+			if(nfs3AttrPack(a, ea, &a, &x->attr) < 0) goto Err;
+			break;
+		}
+		break;
+	}
+	if(sunUint1Pack(a, ea, &a, &x->haveDirAttr) < 0) goto Err;
+	switch(x->haveDirAttr){
+	case 1:
+		if(nfs3AttrPack(a, ea, &a, &x->dirAttr) < 0) goto Err;
+		break;
+	}
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3RLookupUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3RLookup *x)
+{
+	int i;
+
+	if(sunEnumUnpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
+	switch(x->status){
+	case Nfs3Ok:
+		if(nfs3HandleUnpack(a, ea, &a, &x->handle) < 0) goto Err;
+		if(sunUint1Unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
+		switch(x->haveAttr){
+		case 1:
+			if(nfs3AttrUnpack(a, ea, &a, &x->attr) < 0) goto Err;
+			break;
+		}
+		break;
+	}
+	if(sunUint1Unpack(a, ea, &a, &x->haveDirAttr) < 0) goto Err;
+	switch(x->haveDirAttr){
+	case 1:
+		if(nfs3AttrUnpack(a, ea, &a, &x->dirAttr) < 0) goto Err;
+		break;
+	}
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3TAccessPrint(Fmt *fmt, Nfs3TAccess *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3TAccess");
+	fmtprint(fmt, "\t%s=", "handle");
+	nfs3HandlePrint(fmt, &x->handle);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "access");
+	fmtprint(fmt, "%ud", x->access);
+	fmtprint(fmt, "\n");
+}
+uint
+nfs3TAccessSize(Nfs3TAccess *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + nfs3HandleSize(&x->handle) + 4;
+	return a;
+}
+int
+nfs3TAccessPack(uchar *a, uchar *ea, uchar **pa, Nfs3TAccess *x)
+{
+	if(nfs3HandlePack(a, ea, &a, &x->handle) < 0) goto Err;
+	if(sunUint32Pack(a, ea, &a, &x->access) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3TAccessUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3TAccess *x)
+{
+	if(nfs3HandleUnpack(a, ea, &a, &x->handle) < 0) goto Err;
+	if(sunUint32Unpack(a, ea, &a, &x->access) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3RAccessPrint(Fmt *fmt, Nfs3RAccess *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3RAccess");
+	fmtprint(fmt, "\t%s=", "status");
+	fmtprint(fmt, "%s", nfs3StatusStr(x->status));
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "haveAttr");
+	fmtprint(fmt, "%d", x->haveAttr);
+	fmtprint(fmt, "\n");
+	switch(x->haveAttr){
+	case 1:
+		fmtprint(fmt, "\t%s=", "attr");
+		nfs3AttrPrint(fmt, &x->attr);
+		fmtprint(fmt, "\n");
+		break;
+	}
+	switch(x->status){
+	case Nfs3Ok:
+		fmtprint(fmt, "\t%s=", "access");
+		fmtprint(fmt, "%ud", x->access);
+		fmtprint(fmt, "\n");
+		break;
+	}
+}
+uint
+nfs3RAccessSize(Nfs3RAccess *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + 4 + 4;
+	switch(x->haveAttr){
+	case 1:
+		a = a + nfs3AttrSize(&x->attr);
+		break;
+	}
+	switch(x->status){
+	case Nfs3Ok:
+		a = a + 4;
+		break;
+	}
+	return a;
+}
+int
+nfs3RAccessPack(uchar *a, uchar *ea, uchar **pa, Nfs3RAccess *x)
+{
+	int i;
+
+	if(i=x->status, sunEnumPack(a, ea, &a, &i) < 0) goto Err;
+	if(sunUint1Pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
+	switch(x->haveAttr){
+	case 1:
+		if(nfs3AttrPack(a, ea, &a, &x->attr) < 0) goto Err;
+		break;
+	}
+	switch(x->status){
+	case Nfs3Ok:
+		if(sunUint32Pack(a, ea, &a, &x->access) < 0) goto Err;
+		break;
+	}
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3RAccessUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3RAccess *x)
+{
+	int i;
+
+	if(sunEnumUnpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
+	if(sunUint1Unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
+	switch(x->haveAttr){
+	case 1:
+		if(nfs3AttrUnpack(a, ea, &a, &x->attr) < 0) goto Err;
+		break;
+	}
+	switch(x->status){
+	case Nfs3Ok:
+		if(sunUint32Unpack(a, ea, &a, &x->access) < 0) goto Err;
+		break;
+	}
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3TReadlinkPrint(Fmt *fmt, Nfs3TReadlink *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3TReadlink");
+	fmtprint(fmt, "\t%s=", "handle");
+	nfs3HandlePrint(fmt, &x->handle);
+	fmtprint(fmt, "\n");
+}
+uint
+nfs3TReadlinkSize(Nfs3TReadlink *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + nfs3HandleSize(&x->handle);
+	return a;
+}
+int
+nfs3TReadlinkPack(uchar *a, uchar *ea, uchar **pa, Nfs3TReadlink *x)
+{
+	if(nfs3HandlePack(a, ea, &a, &x->handle) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3TReadlinkUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3TReadlink *x)
+{
+	if(nfs3HandleUnpack(a, ea, &a, &x->handle) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3RReadlinkPrint(Fmt *fmt, Nfs3RReadlink *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3RReadlink");
+	fmtprint(fmt, "\t%s=", "status");
+	fmtprint(fmt, "%s", nfs3StatusStr(x->status));
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "haveAttr");
+	fmtprint(fmt, "%d", x->haveAttr);
+	fmtprint(fmt, "\n");
+	switch(x->haveAttr){
+	case 1:
+		fmtprint(fmt, "\t%s=", "attr");
+		nfs3AttrPrint(fmt, &x->attr);
+		fmtprint(fmt, "\n");
+		break;
+	}
+	switch(x->status){
+	case Nfs3Ok:
+		fmtprint(fmt, "\t%s=", "data");
+		fmtprint(fmt, "\"%s\"", x->data);
+		fmtprint(fmt, "\n");
+		break;
+	}
+}
+uint
+nfs3RReadlinkSize(Nfs3RReadlink *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + 4 + 4;
+	switch(x->haveAttr){
+	case 1:
+		a = a + nfs3AttrSize(&x->attr);
+		break;
+	}
+	switch(x->status){
+	case Nfs3Ok:
+		a = a + sunStringSize(x->data);
+		break;
+	}
+	return a;
+}
+int
+nfs3RReadlinkPack(uchar *a, uchar *ea, uchar **pa, Nfs3RReadlink *x)
+{
+	int i;
+
+	if(i=x->status, sunEnumPack(a, ea, &a, &i) < 0) goto Err;
+	if(sunUint1Pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
+	switch(x->haveAttr){
+	case 1:
+		if(nfs3AttrPack(a, ea, &a, &x->attr) < 0) goto Err;
+		break;
+	}
+	switch(x->status){
+	case Nfs3Ok:
+		if(sunStringPack(a, ea, &a, &x->data, -1) < 0) goto Err;
+		break;
+	}
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3RReadlinkUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3RReadlink *x)
+{
+	int i;
+
+	if(sunEnumUnpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
+	if(sunUint1Unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
+	switch(x->haveAttr){
+	case 1:
+		if(nfs3AttrUnpack(a, ea, &a, &x->attr) < 0) goto Err;
+		break;
+	}
+	switch(x->status){
+	case Nfs3Ok:
+		if(sunStringUnpack(a, ea, &a, &x->data, -1) < 0) goto Err;
+		break;
+	}
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3TReadPrint(Fmt *fmt, Nfs3TRead *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3TRead");
+	fmtprint(fmt, "\t%s=", "handle");
+	nfs3HandlePrint(fmt, &x->handle);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "offset");
+	fmtprint(fmt, "%llud", x->offset);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "count");
+	fmtprint(fmt, "%ud", x->count);
+	fmtprint(fmt, "\n");
+}
+uint
+nfs3TReadSize(Nfs3TRead *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + nfs3HandleSize(&x->handle) + 8 + 4;
+	return a;
+}
+int
+nfs3TReadPack(uchar *a, uchar *ea, uchar **pa, Nfs3TRead *x)
+{
+	if(nfs3HandlePack(a, ea, &a, &x->handle) < 0) goto Err;
+	if(sunUint64Pack(a, ea, &a, &x->offset) < 0) goto Err;
+	if(sunUint32Pack(a, ea, &a, &x->count) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3TReadUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3TRead *x)
+{
+	if(nfs3HandleUnpack(a, ea, &a, &x->handle) < 0) goto Err;
+	if(sunUint64Unpack(a, ea, &a, &x->offset) < 0) goto Err;
+	if(sunUint32Unpack(a, ea, &a, &x->count) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3RReadPrint(Fmt *fmt, Nfs3RRead *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3RRead");
+	fmtprint(fmt, "\t%s=", "status");
+	fmtprint(fmt, "%s", nfs3StatusStr(x->status));
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "haveAttr");
+	fmtprint(fmt, "%d", x->haveAttr);
+	fmtprint(fmt, "\n");
+	switch(x->haveAttr){
+	case 1:
+		fmtprint(fmt, "\t%s=", "attr");
+		nfs3AttrPrint(fmt, &x->attr);
+		fmtprint(fmt, "\n");
+		break;
+	}
+	switch(x->status){
+	case Nfs3Ok:
+		fmtprint(fmt, "\t%s=", "count");
+		fmtprint(fmt, "%ud", x->count);
+		fmtprint(fmt, "\n");
+		fmtprint(fmt, "\t%s=", "eof");
+		fmtprint(fmt, "%d", x->eof);
+		fmtprint(fmt, "\n");
+		fmtprint(fmt, "\t%s=", "data");
+		if(x->ndata <= 32)
+			fmtprint(fmt, "%.*H", x->ndata, x->data);
+		else
+			fmtprint(fmt, "%.32H...", x->data);
+		fmtprint(fmt, "\n");
+		break;
+	}
+}
+uint
+nfs3RReadSize(Nfs3RRead *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + 4 + 4;
+	switch(x->haveAttr){
+	case 1:
+		a = a + nfs3AttrSize(&x->attr);
+		break;
+	}
+	switch(x->status){
+	case Nfs3Ok:
+		a = a + 4 + 4 + sunVarOpaqueSize(x->ndata);
+		break;
+	}
+	return a;
+}
+int
+nfs3RReadPack(uchar *a, uchar *ea, uchar **pa, Nfs3RRead *x)
+{
+	int i;
+
+	if(i=x->status, sunEnumPack(a, ea, &a, &i) < 0) goto Err;
+	if(sunUint1Pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
+	switch(x->haveAttr){
+	case 1:
+		if(nfs3AttrPack(a, ea, &a, &x->attr) < 0) goto Err;
+		break;
+	}
+	switch(x->status){
+	case Nfs3Ok:
+		if(sunUint32Pack(a, ea, &a, &x->count) < 0) goto Err;
+		if(sunUint1Pack(a, ea, &a, &x->eof) < 0) goto Err;
+		if(sunVarOpaquePack(a, ea, &a, &x->data, &x->ndata, x->count) < 0) goto Err;
+		break;
+	}
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3RReadUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3RRead *x)
+{
+	int i;
+
+	if(sunEnumUnpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
+	if(sunUint1Unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
+	switch(x->haveAttr){
+	case 1:
+		if(nfs3AttrUnpack(a, ea, &a, &x->attr) < 0) goto Err;
+		break;
+	}
+	switch(x->status){
+	case Nfs3Ok:
+		if(sunUint32Unpack(a, ea, &a, &x->count) < 0) goto Err;
+		if(sunUint1Unpack(a, ea, &a, &x->eof) < 0) goto Err;
+		if(sunVarOpaqueUnpack(a, ea, &a, &x->data, &x->ndata, x->count) < 0) goto Err;
+		break;
+	}
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+char*
+nfs3SyncStr(Nfs3Sync x)
+{
+	switch(x){
+	case Nfs3SyncNone:
+		return "Nfs3SyncNone";
+	case Nfs3SyncData:
+		return "Nfs3SyncData";
+	case Nfs3SyncFile:
+		return "Nfs3SyncFile";
+	default:
+		return "unknown";
+	}
+}
+
+void
+nfs3TWritePrint(Fmt *fmt, Nfs3TWrite *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3TWrite");
+	fmtprint(fmt, "\t%s=", "file");
+	nfs3HandlePrint(fmt, &x->handle);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "offset");
+	fmtprint(fmt, "%llud", x->offset);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "count");
+	fmtprint(fmt, "%ud", x->count);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "stable");
+	fmtprint(fmt, "%s", nfs3SyncStr(x->stable));
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "data");
+	if(x->ndata > 32)
+		fmtprint(fmt, "%.32H... (%d)", x->data, x->ndata);
+	else
+		fmtprint(fmt, "%.*H", x->ndata, x->data);
+	fmtprint(fmt, "\n");
+}
+uint
+nfs3TWriteSize(Nfs3TWrite *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + nfs3HandleSize(&x->handle) + 8 + 4 + 4 + sunVarOpaqueSize(x->ndata);
+	return a;
+}
+int
+nfs3TWritePack(uchar *a, uchar *ea, uchar **pa, Nfs3TWrite *x)
+{
+	int i;
+
+	if(nfs3HandlePack(a, ea, &a, &x->handle) < 0) goto Err;
+	if(sunUint64Pack(a, ea, &a, &x->offset) < 0) goto Err;
+	if(sunUint32Pack(a, ea, &a, &x->count) < 0) goto Err;
+	if(i=x->stable, sunEnumPack(a, ea, &a, &i) < 0) goto Err;
+	if(sunVarOpaquePack(a, ea, &a, &x->data, &x->ndata, x->count) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3TWriteUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3TWrite *x)
+{
+	int i;
+
+	if(nfs3HandleUnpack(a, ea, &a, &x->handle) < 0) goto Err;
+	if(sunUint64Unpack(a, ea, &a, &x->offset) < 0) goto Err;
+	if(sunUint32Unpack(a, ea, &a, &x->count) < 0) goto Err;
+	if(sunEnumUnpack(a, ea, &a, &i) < 0) goto Err; x->stable = i;
+	if(sunVarOpaqueUnpack(a, ea, &a, &x->data, &x->ndata, x->count) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3RWritePrint(Fmt *fmt, Nfs3RWrite *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3RWrite");
+	fmtprint(fmt, "\t%s=", "status");
+	fmtprint(fmt, "%s", nfs3StatusStr(x->status));
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "wcc");
+	nfs3WccPrint(fmt, &x->wcc);
+	fmtprint(fmt, "\n");
+	switch(x->status){
+	case Nfs3Ok:
+		fmtprint(fmt, "\t%s=", "count");
+		fmtprint(fmt, "%ud", x->count);
+		fmtprint(fmt, "\n");
+		fmtprint(fmt, "\t%s=", "committed");
+		fmtprint(fmt, "%s", nfs3SyncStr(x->committed));
+		fmtprint(fmt, "\n");
+		fmtprint(fmt, "\t%s=", "verf");
+		fmtprint(fmt, "%.*H", Nfs3WriteVerfSize, x->verf);
+		fmtprint(fmt, "\n");
+		break;
+	}
+}
+uint
+nfs3RWriteSize(Nfs3RWrite *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + 4 + nfs3WccSize(&x->wcc);
+	switch(x->status){
+	case Nfs3Ok:
+		a = a + 4 + 4 + Nfs3WriteVerfSize;
+		break;
+	}
+	return a;
+}
+int
+nfs3RWritePack(uchar *a, uchar *ea, uchar **pa, Nfs3RWrite *x)
+{
+	int i;
+
+	if(i=x->status, sunEnumPack(a, ea, &a, &i) < 0) goto Err;
+	if(nfs3WccPack(a, ea, &a, &x->wcc) < 0) goto Err;
+	switch(x->status){
+	case Nfs3Ok:
+		if(sunUint32Pack(a, ea, &a, &x->count) < 0) goto Err;
+		if(i=x->committed, sunEnumPack(a, ea, &a, &i) < 0) goto Err;
+		if(sunFixedOpaquePack(a, ea, &a, x->verf, Nfs3WriteVerfSize) < 0) goto Err;
+		break;
+	}
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3RWriteUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3RWrite *x)
+{
+	int i;
+
+	if(sunEnumUnpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
+	if(nfs3WccUnpack(a, ea, &a, &x->wcc) < 0) goto Err;
+	switch(x->status){
+	case Nfs3Ok:
+		if(sunUint32Unpack(a, ea, &a, &x->count) < 0) goto Err;
+		if(sunEnumUnpack(a, ea, &a, &i) < 0) goto Err; x->committed = i;
+		if(sunFixedOpaqueUnpack(a, ea, &a, x->verf, Nfs3WriteVerfSize) < 0) goto Err;
+		break;
+	}
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+char*
+nfs3CreateStr(Nfs3Create x)
+{
+	switch(x){
+	case Nfs3CreateUnchecked:
+		return "Nfs3CreateUnchecked";
+	case Nfs3CreateGuarded:
+		return "Nfs3CreateGuarded";
+	case Nfs3CreateExclusive:
+		return "Nfs3CreateExclusive";
+	default:
+		return "unknown";
+	}
+}
+
+void
+nfs3TCreatePrint(Fmt *fmt, Nfs3TCreate *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3TCreate");
+	fmtprint(fmt, "\t%s=", "handle");
+	nfs3HandlePrint(fmt, &x->handle);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "name");
+	fmtprint(fmt, "\"%s\"", x->name);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "mode");
+	fmtprint(fmt, "%s", nfs3CreateStr(x->mode));
+	fmtprint(fmt, "\n");
+	switch(x->mode){
+	case Nfs3CreateUnchecked:
+	case Nfs3CreateGuarded:
+		fmtprint(fmt, "\t%s=", "attr");
+		nfs3SetAttrPrint(fmt, &x->attr);
+		fmtprint(fmt, "\n");
+		break;
+	case Nfs3CreateExclusive:
+		fmtprint(fmt, "\t%s=", "verf");
+		fmtprint(fmt, "%.*H", Nfs3CreateVerfSize, x->verf);
+		fmtprint(fmt, "\n");
+		break;
+	}
+}
+uint
+nfs3TCreateSize(Nfs3TCreate *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + nfs3HandleSize(&x->handle) + sunStringSize(x->name) + 4;
+	switch(x->mode){
+	case Nfs3CreateUnchecked:
+	case Nfs3CreateGuarded:
+		a = a + nfs3SetAttrSize(&x->attr);
+		break;
+	case Nfs3CreateExclusive:
+		a = a + Nfs3CreateVerfSize;
+		break;
+	}
+	return a;
+}
+int
+nfs3TCreatePack(uchar *a, uchar *ea, uchar **pa, Nfs3TCreate *x)
+{
+	int i;
+
+	if(nfs3HandlePack(a, ea, &a, &x->handle) < 0) goto Err;
+	if(sunStringPack(a, ea, &a, &x->name, -1) < 0) goto Err;
+	if(i=x->mode, sunEnumPack(a, ea, &a, &i) < 0) goto Err;
+	switch(x->mode){
+	case Nfs3CreateUnchecked:
+	case Nfs3CreateGuarded:
+		if(nfs3SetAttrPack(a, ea, &a, &x->attr) < 0) goto Err;
+		break;
+	case Nfs3CreateExclusive:
+		if(sunFixedOpaquePack(a, ea, &a, x->verf, Nfs3CreateVerfSize) < 0) goto Err;
+		break;
+	}
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3TCreateUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3TCreate *x)
+{
+	int i;
+
+	if(nfs3HandleUnpack(a, ea, &a, &x->handle) < 0) goto Err;
+	if(sunStringUnpack(a, ea, &a, &x->name, -1) < 0) goto Err;
+	if(sunEnumUnpack(a, ea, &a, &i) < 0) goto Err; x->mode = i;
+	switch(x->mode){
+	case Nfs3CreateUnchecked:
+	case Nfs3CreateGuarded:
+		if(nfs3SetAttrUnpack(a, ea, &a, &x->attr) < 0) goto Err;
+		break;
+	case Nfs3CreateExclusive:
+		if(sunFixedOpaqueUnpack(a, ea, &a, x->verf, Nfs3CreateVerfSize) < 0) goto Err;
+		break;
+	}
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3RCreatePrint(Fmt *fmt, Nfs3RCreate *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3RCreate");
+	fmtprint(fmt, "\t%s=", "status");
+	fmtprint(fmt, "%s", nfs3StatusStr(x->status));
+	fmtprint(fmt, "\n");
+	switch(x->status){
+	case Nfs3Ok:
+		fmtprint(fmt, "\t%s=", "haveHandle");
+		fmtprint(fmt, "%d", x->haveHandle);
+		fmtprint(fmt, "\n");
+		switch(x->haveHandle){
+		case 1:
+			fmtprint(fmt, "\t%s=", "handle");
+			nfs3HandlePrint(fmt, &x->handle);
+			fmtprint(fmt, "\n");
+			break;
+		}
+		fmtprint(fmt, "\t%s=", "haveAttr");
+		fmtprint(fmt, "%d", x->haveAttr);
+		fmtprint(fmt, "\n");
+		switch(x->haveAttr){
+		case 1:
+			fmtprint(fmt, "\t%s=", "attr");
+			nfs3AttrPrint(fmt, &x->attr);
+			fmtprint(fmt, "\n");
+			break;
+		}
+		break;
+	}
+	fmtprint(fmt, "\t%s=", "dirWcc");
+	nfs3WccPrint(fmt, &x->dirWcc);
+	fmtprint(fmt, "\n");
+}
+uint
+nfs3RCreateSize(Nfs3RCreate *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + 4;
+	switch(x->status){
+	case Nfs3Ok:
+		a = a + 4;
+		switch(x->haveHandle){
+		case 1:
+			a = a + nfs3HandleSize(&x->handle);
+			break;
+		}
+		a = a + 4;
+		switch(x->haveAttr){
+		case 1:
+			a = a + nfs3AttrSize(&x->attr);
+			break;
+		}
+			break;
+	}
+	a = a + nfs3WccSize(&x->dirWcc);
+	return a;
+}
+int
+nfs3RCreatePack(uchar *a, uchar *ea, uchar **pa, Nfs3RCreate *x)
+{
+	int i;
+
+	if(i=x->status, sunEnumPack(a, ea, &a, &i) < 0) goto Err;
+	switch(x->status){
+	case Nfs3Ok:
+		if(sunUint1Pack(a, ea, &a, &x->haveHandle) < 0) goto Err;
+		switch(x->haveHandle){
+		case 1:
+			if(nfs3HandlePack(a, ea, &a, &x->handle) < 0) goto Err;
+			break;
+		}
+		if(sunUint1Pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
+		switch(x->haveAttr){
+		case 1:
+			if(nfs3AttrPack(a, ea, &a, &x->attr) < 0) goto Err;
+			break;
+		}
+		break;
+	}
+	if(nfs3WccPack(a, ea, &a, &x->dirWcc) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3RCreateUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3RCreate *x)
+{
+	int i;
+
+	if(sunEnumUnpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
+	switch(x->status){
+	case Nfs3Ok:
+		if(sunUint1Unpack(a, ea, &a, &x->haveHandle) < 0) goto Err;
+		switch(x->haveHandle){
+		case 1:
+			if(nfs3HandleUnpack(a, ea, &a, &x->handle) < 0) goto Err;
+			break;
+		}
+		if(sunUint1Unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
+		switch(x->haveAttr){
+		case 1:
+			if(nfs3AttrUnpack(a, ea, &a, &x->attr) < 0) goto Err;
+			break;
+		}
+		break;
+	}
+	if(nfs3WccUnpack(a, ea, &a, &x->dirWcc) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3TMkdirPrint(Fmt *fmt, Nfs3TMkdir *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3TMkdir");
+	fmtprint(fmt, "\t%s=", "handle");
+	nfs3HandlePrint(fmt, &x->handle);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "name");
+	fmtprint(fmt, "\"%s\"", x->name);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "attr");
+	nfs3SetAttrPrint(fmt, &x->attr);
+	fmtprint(fmt, "\n");
+}
+uint
+nfs3TMkdirSize(Nfs3TMkdir *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + nfs3HandleSize(&x->handle) + sunStringSize(x->name) + nfs3SetAttrSize(&x->attr);
+	return a;
+}
+int
+nfs3TMkdirPack(uchar *a, uchar *ea, uchar **pa, Nfs3TMkdir *x)
+{
+	if(nfs3HandlePack(a, ea, &a, &x->handle) < 0) goto Err;
+	if(sunStringPack(a, ea, &a, &x->name, -1) < 0) goto Err;
+	if(nfs3SetAttrPack(a, ea, &a, &x->attr) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3TMkdirUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3TMkdir *x)
+{
+	if(nfs3HandleUnpack(a, ea, &a, &x->handle) < 0) goto Err;
+	if(sunStringUnpack(a, ea, &a, &x->name, -1) < 0) goto Err;
+	if(nfs3SetAttrUnpack(a, ea, &a, &x->attr) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3RMkdirPrint(Fmt *fmt, Nfs3RMkdir *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3RMkdir");
+	fmtprint(fmt, "\t%s=", "status");
+	fmtprint(fmt, "%s", nfs3StatusStr(x->status));
+	fmtprint(fmt, "\n");
+	switch(x->status){
+	case Nfs3Ok:
+		fmtprint(fmt, "\t%s=", "haveHandle");
+		fmtprint(fmt, "%d", x->haveHandle);
+		fmtprint(fmt, "\n");
+		switch(x->haveHandle){
+		case 1:
+			fmtprint(fmt, "\t%s=", "handle");
+			nfs3HandlePrint(fmt, &x->handle);
+			fmtprint(fmt, "\n");
+			break;
+		}
+		fmtprint(fmt, "\t%s=", "haveAttr");
+		fmtprint(fmt, "%d", x->haveAttr);
+		fmtprint(fmt, "\n");
+		switch(x->haveAttr){
+		case 1:
+			fmtprint(fmt, "\t%s=", "attr");
+			nfs3AttrPrint(fmt, &x->attr);
+			fmtprint(fmt, "\n");
+			break;
+		}
+		break;
+	}
+	fmtprint(fmt, "\t%s=", "dirWcc");
+	nfs3WccPrint(fmt, &x->dirWcc);
+	fmtprint(fmt, "\n");
+}
+uint
+nfs3RMkdirSize(Nfs3RMkdir *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + 4;
+	switch(x->status){
+	case Nfs3Ok:
+		a = a + 4;
+		switch(x->haveHandle){
+		case 1:
+			a = a + nfs3HandleSize(&x->handle);
+			break;
+		}
+		a = a + 4;
+		switch(x->haveAttr){
+		case 1:
+			a = a + nfs3AttrSize(&x->attr);
+			break;
+		}
+			break;
+	}
+	a = a + nfs3WccSize(&x->dirWcc);
+	return a;
+}
+int
+nfs3RMkdirPack(uchar *a, uchar *ea, uchar **pa, Nfs3RMkdir *x)
+{
+	int i;
+
+	if(i=x->status, sunEnumPack(a, ea, &a, &i) < 0) goto Err;
+	switch(x->status){
+	case Nfs3Ok:
+		if(sunUint1Pack(a, ea, &a, &x->haveHandle) < 0) goto Err;
+		switch(x->haveHandle){
+		case 1:
+			if(nfs3HandlePack(a, ea, &a, &x->handle) < 0) goto Err;
+			break;
+		}
+		if(sunUint1Pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
+		switch(x->haveAttr){
+		case 1:
+			if(nfs3AttrPack(a, ea, &a, &x->attr) < 0) goto Err;
+			break;
+		}
+		break;
+	}
+	if(nfs3WccPack(a, ea, &a, &x->dirWcc) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3RMkdirUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3RMkdir *x)
+{
+	int i;
+
+	if(sunEnumUnpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
+	switch(x->status){
+	case Nfs3Ok:
+		if(sunUint1Unpack(a, ea, &a, &x->haveHandle) < 0) goto Err;
+		switch(x->haveHandle){
+		case 1:
+			if(nfs3HandleUnpack(a, ea, &a, &x->handle) < 0) goto Err;
+			break;
+		}
+		if(sunUint1Unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
+		switch(x->haveAttr){
+		case 1:
+			if(nfs3AttrUnpack(a, ea, &a, &x->attr) < 0) goto Err;
+			break;
+		}
+		break;
+	}
+	if(nfs3WccUnpack(a, ea, &a, &x->dirWcc) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3TSymlinkPrint(Fmt *fmt, Nfs3TSymlink *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3TSymlink");
+	fmtprint(fmt, "\t%s=", "handle");
+	nfs3HandlePrint(fmt, &x->handle);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "name");
+	fmtprint(fmt, "\"%s\"", x->name);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "attr");
+	nfs3SetAttrPrint(fmt, &x->attr);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "data");
+	fmtprint(fmt, "\"%s\"", x->data);
+	fmtprint(fmt, "\n");
+}
+uint
+nfs3TSymlinkSize(Nfs3TSymlink *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + nfs3HandleSize(&x->handle) + sunStringSize(x->name) + nfs3SetAttrSize(&x->attr) + sunStringSize(x->data);
+	return a;
+}
+int
+nfs3TSymlinkPack(uchar *a, uchar *ea, uchar **pa, Nfs3TSymlink *x)
+{
+	if(nfs3HandlePack(a, ea, &a, &x->handle) < 0) goto Err;
+	if(sunStringPack(a, ea, &a, &x->name, -1) < 0) goto Err;
+	if(nfs3SetAttrPack(a, ea, &a, &x->attr) < 0) goto Err;
+	if(sunStringPack(a, ea, &a, &x->data, -1) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3TSymlinkUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3TSymlink *x)
+{
+	if(nfs3HandleUnpack(a, ea, &a, &x->handle) < 0) goto Err;
+	if(sunStringUnpack(a, ea, &a, &x->name, -1) < 0) goto Err;
+	if(nfs3SetAttrUnpack(a, ea, &a, &x->attr) < 0) goto Err;
+	if(sunStringUnpack(a, ea, &a, &x->data, -1) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3RSymlinkPrint(Fmt *fmt, Nfs3RSymlink *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3RSymlink");
+	fmtprint(fmt, "\t%s=", "status");
+	fmtprint(fmt, "%s", nfs3StatusStr(x->status));
+	fmtprint(fmt, "\n");
+	switch(x->status){
+	case Nfs3Ok:
+		fmtprint(fmt, "\t%s=", "haveHandle");
+		fmtprint(fmt, "%d", x->haveHandle);
+		fmtprint(fmt, "\n");
+		switch(x->haveHandle){
+		case 1:
+			fmtprint(fmt, "\t%s=", "handle");
+			nfs3HandlePrint(fmt, &x->handle);
+			fmtprint(fmt, "\n");
+			break;
+		}
+		fmtprint(fmt, "\t%s=", "haveAttr");
+		fmtprint(fmt, "%d", x->haveAttr);
+		fmtprint(fmt, "\n");
+		switch(x->haveAttr){
+		case 1:
+			fmtprint(fmt, "\t%s=", "attr");
+			nfs3AttrPrint(fmt, &x->attr);
+			fmtprint(fmt, "\n");
+			break;
+		}
+		break;
+	}
+	fmtprint(fmt, "\t%s=", "dirWcc");
+	nfs3WccPrint(fmt, &x->dirWcc);
+	fmtprint(fmt, "\n");
+}
+uint
+nfs3RSymlinkSize(Nfs3RSymlink *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + 4;
+	switch(x->status){
+	case Nfs3Ok:
+		a = a + 4;
+		switch(x->haveHandle){
+		case 1:
+			a = a + nfs3HandleSize(&x->handle);
+			break;
+		}
+		a = a + 4;
+		switch(x->haveAttr){
+		case 1:
+			a = a + nfs3AttrSize(&x->attr);
+			break;
+		}
+			break;
+	}
+	a = a + nfs3WccSize(&x->dirWcc);
+	return a;
+}
+int
+nfs3RSymlinkPack(uchar *a, uchar *ea, uchar **pa, Nfs3RSymlink *x)
+{
+	int i;
+
+	if(i=x->status, sunEnumPack(a, ea, &a, &i) < 0) goto Err;
+	switch(x->status){
+	case Nfs3Ok:
+		if(sunUint1Pack(a, ea, &a, &x->haveHandle) < 0) goto Err;
+		switch(x->haveHandle){
+		case 1:
+			if(nfs3HandlePack(a, ea, &a, &x->handle) < 0) goto Err;
+			break;
+		}
+		if(sunUint1Pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
+		switch(x->haveAttr){
+		case 1:
+			if(nfs3AttrPack(a, ea, &a, &x->attr) < 0) goto Err;
+			break;
+		}
+		break;
+	}
+	if(nfs3WccPack(a, ea, &a, &x->dirWcc) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3RSymlinkUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3RSymlink *x)
+{
+	int i;
+
+	if(sunEnumUnpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
+	switch(x->status){
+	case Nfs3Ok:
+		if(sunUint1Unpack(a, ea, &a, &x->haveHandle) < 0) goto Err;
+		switch(x->haveHandle){
+		case 1:
+			if(nfs3HandleUnpack(a, ea, &a, &x->handle) < 0) goto Err;
+			break;
+		}
+		if(sunUint1Unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
+		switch(x->haveAttr){
+		case 1:
+			if(nfs3AttrUnpack(a, ea, &a, &x->attr) < 0) goto Err;
+			break;
+		}
+		break;
+	}
+	if(nfs3WccUnpack(a, ea, &a, &x->dirWcc) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3TMknodPrint(Fmt *fmt, Nfs3TMknod *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3TMknod");
+	fmtprint(fmt, "\t%s=", "handle");
+	nfs3HandlePrint(fmt, &x->handle);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "name");
+	fmtprint(fmt, "\"%s\"", x->name);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "type");
+	fmtprint(fmt, "%s", nfs3FileTypeStr(x->type));
+	fmtprint(fmt, "\n");
+	switch(x->type){
+	case Nfs3FileChar:
+	case Nfs3FileBlock:
+		fmtprint(fmt, "\t%s=", "attr");
+		nfs3SetAttrPrint(fmt, &x->attr);
+		fmtprint(fmt, "\n");
+		fmtprint(fmt, "\t%s=", "major");
+		fmtprint(fmt, "%ud", x->major);
+		fmtprint(fmt, "\n");
+		fmtprint(fmt, "\t%s=", "minor");
+		fmtprint(fmt, "%ud", x->minor);
+		fmtprint(fmt, "\n");
+		break;
+	case Nfs3FileSocket:
+	case Nfs3FileFifo:
+		fmtprint(fmt, "\t%s=", "attr");
+		nfs3SetAttrPrint(fmt, &x->attr);
+		fmtprint(fmt, "\n");
+		break;
+	}
+}
+uint
+nfs3TMknodSize(Nfs3TMknod *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + nfs3HandleSize(&x->handle) + sunStringSize(x->name) + 4;
+	switch(x->type){
+	case Nfs3FileChar:
+	case Nfs3FileBlock:
+		a = a + nfs3SetAttrSize(&x->attr) + 4 + 4;
+		break;
+	case Nfs3FileSocket:
+	case Nfs3FileFifo:
+		a = a + nfs3SetAttrSize(&x->attr);
+		break;
+	}
+	return a;
+}
+int
+nfs3TMknodPack(uchar *a, uchar *ea, uchar **pa, Nfs3TMknod *x)
+{
+	int i;
+
+	if(nfs3HandlePack(a, ea, &a, &x->handle) < 0) goto Err;
+	if(sunStringPack(a, ea, &a, &x->name, -1) < 0) goto Err;
+	if(i=x->type, sunEnumPack(a, ea, &a, &i) < 0) goto Err;
+	switch(x->type){
+	case Nfs3FileChar:
+	case Nfs3FileBlock:
+		if(nfs3SetAttrPack(a, ea, &a, &x->attr) < 0) goto Err;
+		if(sunUint32Pack(a, ea, &a, &x->major) < 0) goto Err;
+		if(sunUint32Pack(a, ea, &a, &x->minor) < 0) goto Err;
+		break;
+	case Nfs3FileSocket:
+	case Nfs3FileFifo:
+		if(nfs3SetAttrPack(a, ea, &a, &x->attr) < 0) goto Err;
+		break;
+	}
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3TMknodUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3TMknod *x)
+{
+	int i;
+
+	if(nfs3HandleUnpack(a, ea, &a, &x->handle) < 0) goto Err;
+	if(sunStringUnpack(a, ea, &a, &x->name, -1) < 0) goto Err;
+	if(sunEnumUnpack(a, ea, &a, &i) < 0) goto Err; x->type = i;
+	switch(x->type){
+	case Nfs3FileChar:
+	case Nfs3FileBlock:
+		if(nfs3SetAttrUnpack(a, ea, &a, &x->attr) < 0) goto Err;
+		if(sunUint32Unpack(a, ea, &a, &x->major) < 0) goto Err;
+		if(sunUint32Unpack(a, ea, &a, &x->minor) < 0) goto Err;
+		break;
+	case Nfs3FileSocket:
+	case Nfs3FileFifo:
+		if(nfs3SetAttrUnpack(a, ea, &a, &x->attr) < 0) goto Err;
+		break;
+	}
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3RMknodPrint(Fmt *fmt, Nfs3RMknod *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3RMknod");
+	fmtprint(fmt, "\t%s=", "status");
+	fmtprint(fmt, "%s", nfs3StatusStr(x->status));
+	fmtprint(fmt, "\n");
+	switch(x->status){
+	case Nfs3Ok:
+		fmtprint(fmt, "\t%s=", "haveHandle");
+		fmtprint(fmt, "%d", x->haveHandle);
+		fmtprint(fmt, "\n");
+		switch(x->haveHandle){
+		case 1:
+			fmtprint(fmt, "\t%s=", "handle");
+			nfs3HandlePrint(fmt, &x->handle);
+			fmtprint(fmt, "\n");
+			break;
+		}
+		fmtprint(fmt, "\t%s=", "haveAttr");
+		fmtprint(fmt, "%d", x->haveAttr);
+		fmtprint(fmt, "\n");
+		switch(x->haveAttr){
+		case 1:
+			fmtprint(fmt, "\t%s=", "attr");
+			nfs3AttrPrint(fmt, &x->attr);
+			fmtprint(fmt, "\n");
+			break;
+		}
+		break;
+	}
+	fmtprint(fmt, "\t%s=", "dirWcc");
+	nfs3WccPrint(fmt, &x->dirWcc);
+	fmtprint(fmt, "\n");
+}
+uint
+nfs3RMknodSize(Nfs3RMknod *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + 4;
+	switch(x->status){
+	case Nfs3Ok:
+		a = a + 4;
+		switch(x->haveHandle){
+		case 1:
+			a = a + nfs3HandleSize(&x->handle);
+			break;
+		}
+		a = a + 4;
+		switch(x->haveAttr){
+		case 1:
+			a = a + nfs3AttrSize(&x->attr);
+			break;
+		}
+			break;
+	}
+	a = a + nfs3WccSize(&x->dirWcc);
+	return a;
+}
+int
+nfs3RMknodPack(uchar *a, uchar *ea, uchar **pa, Nfs3RMknod *x)
+{
+	int i;
+
+	if(i=x->status, sunEnumPack(a, ea, &a, &i) < 0) goto Err;
+	switch(x->status){
+	case Nfs3Ok:
+		if(sunUint1Pack(a, ea, &a, &x->haveHandle) < 0) goto Err;
+		switch(x->haveHandle){
+		case 1:
+			if(nfs3HandlePack(a, ea, &a, &x->handle) < 0) goto Err;
+			break;
+		}
+		if(sunUint1Pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
+		switch(x->haveAttr){
+		case 1:
+			if(nfs3AttrPack(a, ea, &a, &x->attr) < 0) goto Err;
+			break;
+		}
+		break;
+	}
+	if(nfs3WccPack(a, ea, &a, &x->dirWcc) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3RMknodUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3RMknod *x)
+{
+	int i;
+
+	if(sunEnumUnpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
+	switch(x->status){
+	case Nfs3Ok:
+		if(sunUint1Unpack(a, ea, &a, &x->haveHandle) < 0) goto Err;
+		switch(x->haveHandle){
+		case 1:
+			if(nfs3HandleUnpack(a, ea, &a, &x->handle) < 0) goto Err;
+			break;
+		}
+		if(sunUint1Unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
+		switch(x->haveAttr){
+		case 1:
+			if(nfs3AttrUnpack(a, ea, &a, &x->attr) < 0) goto Err;
+			break;
+		}
+		break;
+	}
+	if(nfs3WccUnpack(a, ea, &a, &x->dirWcc) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3TRemovePrint(Fmt *fmt, Nfs3TRemove *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3TRemove");
+	fmtprint(fmt, "\t%s=", "handle");
+	nfs3HandlePrint(fmt, &x->handle);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "name");
+	fmtprint(fmt, "\"%s\"", x->name);
+	fmtprint(fmt, "\n");
+}
+uint
+nfs3TRemoveSize(Nfs3TRemove *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + nfs3HandleSize(&x->handle) + sunStringSize(x->name);
+	return a;
+}
+int
+nfs3TRemovePack(uchar *a, uchar *ea, uchar **pa, Nfs3TRemove *x)
+{
+	if(nfs3HandlePack(a, ea, &a, &x->handle) < 0) goto Err;
+	if(sunStringPack(a, ea, &a, &x->name, -1) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3TRemoveUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3TRemove *x)
+{
+	if(nfs3HandleUnpack(a, ea, &a, &x->handle) < 0) goto Err;
+	if(sunStringUnpack(a, ea, &a, &x->name, -1) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3RRemovePrint(Fmt *fmt, Nfs3RRemove *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3RRemove");
+	fmtprint(fmt, "\t%s=", "status");
+	fmtprint(fmt, "%s", nfs3StatusStr(x->status));
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "wcc");
+	nfs3WccPrint(fmt, &x->wcc);
+	fmtprint(fmt, "\n");
+}
+uint
+nfs3RRemoveSize(Nfs3RRemove *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + 4 + nfs3WccSize(&x->wcc);
+	return a;
+}
+int
+nfs3RRemovePack(uchar *a, uchar *ea, uchar **pa, Nfs3RRemove *x)
+{
+	int i;
+
+	if(i=x->status, sunEnumPack(a, ea, &a, &i) < 0) goto Err;
+	if(nfs3WccPack(a, ea, &a, &x->wcc) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3RRemoveUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3RRemove *x)
+{
+	int i;
+
+	if(sunEnumUnpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
+	if(nfs3WccUnpack(a, ea, &a, &x->wcc) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3TRmdirPrint(Fmt *fmt, Nfs3TRmdir *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3TRmdir");
+	fmtprint(fmt, "\t%s=", "handle");
+	nfs3HandlePrint(fmt, &x->handle);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "name");
+	fmtprint(fmt, "\"%s\"", x->name);
+	fmtprint(fmt, "\n");
+}
+uint
+nfs3TRmdirSize(Nfs3TRmdir *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + nfs3HandleSize(&x->handle) + sunStringSize(x->name);
+	return a;
+}
+int
+nfs3TRmdirPack(uchar *a, uchar *ea, uchar **pa, Nfs3TRmdir *x)
+{
+	if(nfs3HandlePack(a, ea, &a, &x->handle) < 0) goto Err;
+	if(sunStringPack(a, ea, &a, &x->name, -1) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3TRmdirUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3TRmdir *x)
+{
+	if(nfs3HandleUnpack(a, ea, &a, &x->handle) < 0) goto Err;
+	if(sunStringUnpack(a, ea, &a, &x->name, -1) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3RRmdirPrint(Fmt *fmt, Nfs3RRmdir *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3RRmdir");
+	fmtprint(fmt, "\t%s=", "status");
+	fmtprint(fmt, "%s", nfs3StatusStr(x->status));
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "wcc");
+	nfs3WccPrint(fmt, &x->wcc);
+	fmtprint(fmt, "\n");
+}
+uint
+nfs3RRmdirSize(Nfs3RRmdir *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + 4 + nfs3WccSize(&x->wcc);
+	return a;
+}
+int
+nfs3RRmdirPack(uchar *a, uchar *ea, uchar **pa, Nfs3RRmdir *x)
+{
+	int i;
+
+	if(i=x->status, sunEnumPack(a, ea, &a, &i) < 0) goto Err;
+	if(nfs3WccPack(a, ea, &a, &x->wcc) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3RRmdirUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3RRmdir *x)
+{
+	int i;
+
+	if(sunEnumUnpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
+	if(nfs3WccUnpack(a, ea, &a, &x->wcc) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3TRenamePrint(Fmt *fmt, Nfs3TRename *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3TRename");
+	fmtprint(fmt, "\t%s=", "from");
+	fmtprint(fmt, "{\n");
+	fmtprint(fmt, "\t\t%s=", "handle");
+	nfs3HandlePrint(fmt, &x->from.handle);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t\t%s=", "name");
+	fmtprint(fmt, "\"%s\"", x->from.name);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t}");
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "to");
+	fmtprint(fmt, "{\n");
+	fmtprint(fmt, "\t\t%s=", "handle");
+	nfs3HandlePrint(fmt, &x->to.handle);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t\t%s=", "name");
+	fmtprint(fmt, "\"%s\"", x->to.name);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t}");
+	fmtprint(fmt, "\n");
+}
+uint
+nfs3TRenameSize(Nfs3TRename *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + nfs3HandleSize(&x->from.handle) + sunStringSize(x->from.name) + nfs3HandleSize(&x->to.handle) + sunStringSize(x->to.name);
+	return a;
+}
+int
+nfs3TRenamePack(uchar *a, uchar *ea, uchar **pa, Nfs3TRename *x)
+{
+	if(nfs3HandlePack(a, ea, &a, &x->from.handle) < 0) goto Err;
+	if(sunStringPack(a, ea, &a, &x->from.name, -1) < 0) goto Err;
+	if(nfs3HandlePack(a, ea, &a, &x->to.handle) < 0) goto Err;
+	if(sunStringPack(a, ea, &a, &x->to.name, -1) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3TRenameUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3TRename *x)
+{
+	if(nfs3HandleUnpack(a, ea, &a, &x->from.handle) < 0) goto Err;
+	if(sunStringUnpack(a, ea, &a, &x->from.name, -1) < 0) goto Err;
+	if(nfs3HandleUnpack(a, ea, &a, &x->to.handle) < 0) goto Err;
+	if(sunStringUnpack(a, ea, &a, &x->to.name, -1) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3RRenamePrint(Fmt *fmt, Nfs3RRename *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3RRename");
+	fmtprint(fmt, "\t%s=", "status");
+	fmtprint(fmt, "%s", nfs3StatusStr(x->status));
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "fromWcc");
+	nfs3WccPrint(fmt, &x->fromWcc);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "toWcc");
+	nfs3WccPrint(fmt, &x->toWcc);
+	fmtprint(fmt, "\n");
+}
+uint
+nfs3RRenameSize(Nfs3RRename *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + 4 + nfs3WccSize(&x->fromWcc) + nfs3WccSize(&x->toWcc);
+	return a;
+}
+int
+nfs3RRenamePack(uchar *a, uchar *ea, uchar **pa, Nfs3RRename *x)
+{
+	int i;
+
+	if(i=x->status, sunEnumPack(a, ea, &a, &i) < 0) goto Err;
+	if(nfs3WccPack(a, ea, &a, &x->fromWcc) < 0) goto Err;
+	if(nfs3WccPack(a, ea, &a, &x->toWcc) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3RRenameUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3RRename *x)
+{
+	int i;
+
+	if(sunEnumUnpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
+	if(nfs3WccUnpack(a, ea, &a, &x->fromWcc) < 0) goto Err;
+	if(nfs3WccUnpack(a, ea, &a, &x->toWcc) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3TLinkPrint(Fmt *fmt, Nfs3TLink *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3TLink");
+	fmtprint(fmt, "\t%s=", "handle");
+	nfs3HandlePrint(fmt, &x->handle);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "link");
+	fmtprint(fmt, "{\n");
+	fmtprint(fmt, "\t\t%s=", "handle");
+	nfs3HandlePrint(fmt, &x->link.handle);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t\t%s=", "name");
+	fmtprint(fmt, "\"%s\"", x->link.name);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t}");
+	fmtprint(fmt, "\n");
+}
+uint
+nfs3TLinkSize(Nfs3TLink *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + nfs3HandleSize(&x->handle) + nfs3HandleSize(&x->link.handle) + sunStringSize(x->link.name);
+	return a;
+}
+int
+nfs3TLinkPack(uchar *a, uchar *ea, uchar **pa, Nfs3TLink *x)
+{
+	if(nfs3HandlePack(a, ea, &a, &x->handle) < 0) goto Err;
+	if(nfs3HandlePack(a, ea, &a, &x->link.handle) < 0) goto Err;
+	if(sunStringPack(a, ea, &a, &x->link.name, -1) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3TLinkUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3TLink *x)
+{
+	if(nfs3HandleUnpack(a, ea, &a, &x->handle) < 0) goto Err;
+	if(nfs3HandleUnpack(a, ea, &a, &x->link.handle) < 0) goto Err;
+	if(sunStringUnpack(a, ea, &a, &x->link.name, -1) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3RLinkPrint(Fmt *fmt, Nfs3RLink *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3RLink");
+	fmtprint(fmt, "\t%s=", "status");
+	fmtprint(fmt, "%s", nfs3StatusStr(x->status));
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "haveAttr");
+	fmtprint(fmt, "%d", x->haveAttr);
+	fmtprint(fmt, "\n");
+	switch(x->haveAttr){
+	case 1:
+		fmtprint(fmt, "\t%s=", "attr");
+		nfs3AttrPrint(fmt, &x->attr);
+		fmtprint(fmt, "\n");
+		break;
+	}
+	fmtprint(fmt, "\t%s=", "dirWcc");
+	nfs3WccPrint(fmt, &x->dirWcc);
+	fmtprint(fmt, "\n");
+}
+uint
+nfs3RLinkSize(Nfs3RLink *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + 4 + 4;
+	switch(x->haveAttr){
+	case 1:
+		a = a + nfs3AttrSize(&x->attr);
+		break;
+	}
+	a = a + nfs3WccSize(&x->dirWcc);
+	return a;
+}
+int
+nfs3RLinkPack(uchar *a, uchar *ea, uchar **pa, Nfs3RLink *x)
+{
+	int i;
+
+	if(i=x->status, sunEnumPack(a, ea, &a, &i) < 0) goto Err;
+	if(sunUint1Pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
+	switch(x->haveAttr){
+	case 1:
+		if(nfs3AttrPack(a, ea, &a, &x->attr) < 0) goto Err;
+		break;
+	}
+	if(nfs3WccPack(a, ea, &a, &x->dirWcc) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3RLinkUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3RLink *x)
+{
+	int i;
+
+	if(sunEnumUnpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
+	if(sunUint1Unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
+	switch(x->haveAttr){
+	case 1:
+		if(nfs3AttrUnpack(a, ea, &a, &x->attr) < 0) goto Err;
+		break;
+	}
+	if(nfs3WccUnpack(a, ea, &a, &x->dirWcc) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3TReadDirPrint(Fmt *fmt, Nfs3TReadDir *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3TReadDir");
+	fmtprint(fmt, "\t%s=", "handle");
+	nfs3HandlePrint(fmt, &x->handle);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "cookie");
+	fmtprint(fmt, "%llud", x->cookie);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "verf");
+	fmtprint(fmt, "%.*H", Nfs3CookieVerfSize, x->verf);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "count");
+	fmtprint(fmt, "%ud", x->count);
+	fmtprint(fmt, "\n");
+}
+uint
+nfs3TReadDirSize(Nfs3TReadDir *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + nfs3HandleSize(&x->handle) + 8 + Nfs3CookieVerfSize + 4;
+	return a;
+}
+int
+nfs3TReadDirPack(uchar *a, uchar *ea, uchar **pa, Nfs3TReadDir *x)
+{
+	if(nfs3HandlePack(a, ea, &a, &x->handle) < 0) goto Err;
+	if(sunUint64Pack(a, ea, &a, &x->cookie) < 0) goto Err;
+	if(sunFixedOpaquePack(a, ea, &a, x->verf, Nfs3CookieVerfSize) < 0) goto Err;
+	if(sunUint32Pack(a, ea, &a, &x->count) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3TReadDirUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3TReadDir *x)
+{
+	if(nfs3HandleUnpack(a, ea, &a, &x->handle) < 0) goto Err;
+	if(sunUint64Unpack(a, ea, &a, &x->cookie) < 0) goto Err;
+	if(sunFixedOpaqueUnpack(a, ea, &a, x->verf, Nfs3CookieVerfSize) < 0) goto Err;
+	if(sunUint32Unpack(a, ea, &a, &x->count) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3EntryPrint(Fmt *fmt, Nfs3Entry *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3Entry");
+	fmtprint(fmt, "\t%s=", "fileid");
+	fmtprint(fmt, "%llud", x->fileid);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "name");
+	fmtprint(fmt, "\"%s\"", x->name);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "cookie");
+	fmtprint(fmt, "%llud", x->cookie);
+	fmtprint(fmt, "\n");
+}
+uint
+nfs3EntrySize(Nfs3Entry *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + 4 + 8 + sunStringSize(x->name) + 8;
+	return a;
+}
+int
+nfs3EntryPack(uchar *a, uchar *ea, uchar **pa, Nfs3Entry *x)
+{
+	u1int one;
+
+	one = 1;
+	if(sunUint1Pack(a, ea, &a, &one) < 0) goto Err;
+	if(sunUint64Pack(a, ea, &a, &x->fileid) < 0) goto Err;
+	if(sunStringPack(a, ea, &a, &x->name, -1) < 0) goto Err;
+	if(sunUint64Pack(a, ea, &a, &x->cookie) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3EntryUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3Entry *x)
+{
+	u1int one;
+
+	memset(x, 0, sizeof *x);
+	if(sunUint1Unpack(a, ea, &a, &one) < 0 || one != 1) goto Err;
+	if(sunUint64Unpack(a, ea, &a, &x->fileid) < 0) goto Err;
+	if(sunStringUnpack(a, ea, &a, &x->name, -1) < 0) goto Err;
+	if(sunUint64Unpack(a, ea, &a, &x->cookie) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3RReadDirPrint(Fmt *fmt, Nfs3RReadDir *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3RReadDir");
+	fmtprint(fmt, "\t%s=", "status");
+	fmtprint(fmt, "%s", nfs3StatusStr(x->status));
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "haveAttr");
+	fmtprint(fmt, "%d", x->haveAttr);
+	fmtprint(fmt, "\n");
+	switch(x->haveAttr){
+	case 1:
+		fmtprint(fmt, "\t%s=", "attr");
+		nfs3AttrPrint(fmt, &x->attr);
+		fmtprint(fmt, "\n");
+		break;
+	}
+	switch(x->status){
+	case Nfs3Ok:
+		fmtprint(fmt, "\t%s=", "verf");
+		fmtprint(fmt, "%.*H", Nfs3CookieVerfSize, x->verf);
+		fmtprint(fmt, "\n");
+		fmtprint(fmt, "\t%s=%ud\n", "count", x->count);
+		fmtprint(fmt, "\t%s=", "eof");
+		fmtprint(fmt, "%d", x->eof);
+		fmtprint(fmt, "\n");
+		break;
+	}
+}
+uint
+nfs3RReadDirSize(Nfs3RReadDir *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + 4 + 4;
+	switch(x->haveAttr){
+	case 1:
+		a = a + nfs3AttrSize(&x->attr);
+		break;
+	}
+	switch(x->status){
+	case Nfs3Ok:
+		a = a + Nfs3CookieVerfSize;
+		a += x->count;
+		a += 4 + 4;
+		break;
+	}
+	return a;
+}
+int
+nfs3RReadDirPack(uchar *a, uchar *ea, uchar **pa, Nfs3RReadDir *x)
+{
+	int i;
+	u1int zero;
+
+	if(i=x->status, sunEnumPack(a, ea, &a, &i) < 0) goto Err;
+	if(sunUint1Pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
+	switch(x->haveAttr){
+	case 1:
+		if(nfs3AttrPack(a, ea, &a, &x->attr) < 0) goto Err;
+		break;
+	}
+	switch(x->status){
+	case Nfs3Ok:
+		if(sunFixedOpaquePack(a, ea, &a, x->verf, Nfs3CookieVerfSize) < 0) goto Err;
+		if(sunFixedOpaquePack(a, ea, &a, x->data, x->count) < 0) goto Err;
+		zero = 0;
+		if(sunUint1Pack(a, ea, &a, &zero) < 0) goto Err;
+		if(sunUint1Pack(a, ea, &a, &x->eof) < 0) goto Err;
+		break;
+	}
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+static int
+countEntry(uchar *a, uchar *ea, uchar **pa, u32int *n)
+{
+	uchar *oa;
+	u64int u64;
+	u32int u32;
+	u1int u1;
+
+	oa = a;
+	for(;;){
+		if(sunUint1Unpack(a, ea, &a, &u1) < 0)
+			return -1;
+		if(u1 == 0)
+			break;
+		if(sunUint64Unpack(a, ea, &a, &u64) < 0
+		|| sunUint32Unpack(a, ea, &a, &u32) < 0)
+			return -1;
+		a += (u32+3)&~3;
+		if(a >= ea)
+			return -1;
+		if(sunUint64Unpack(a, ea, &a, &u64) < 0)
+			return -1;
+	}
+	*n = (a-4) - oa;
+	*pa = a;
+	return 0;
+}
+int
+nfs3RReadDirUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3RReadDir *x)
+{
+	int i;
+
+	if(sunEnumUnpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
+	if(sunUint1Unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
+	switch(x->haveAttr){
+	case 1:
+		if(nfs3AttrUnpack(a, ea, &a, &x->attr) < 0) goto Err;
+		break;
+	}
+	if(x->status == Nfs3Ok){
+		if(sunFixedOpaqueUnpack(a, ea, &a, x->verf, Nfs3CookieVerfSize) < 0) goto Err;
+		x->data = a;
+		if(countEntry(a, ea, &a, &x->count) < 0) goto Err;
+		if(sunUint1Unpack(a, ea, &a, &x->eof) < 0) goto Err;
+	}
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3TReadDirPlusPrint(Fmt *fmt, Nfs3TReadDirPlus *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3TReadDirPlus");
+	fmtprint(fmt, "\t%s=", "handle");
+	nfs3HandlePrint(fmt, &x->handle);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "cookie");
+	fmtprint(fmt, "%llud", x->cookie);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "verf");
+	fmtprint(fmt, "%.*H", Nfs3CookieVerfSize, x->verf);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "dirCount");
+	fmtprint(fmt, "%ud", x->dirCount);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "maxCount");
+	fmtprint(fmt, "%ud", x->maxCount);
+	fmtprint(fmt, "\n");
+}
+uint
+nfs3TReadDirPlusSize(Nfs3TReadDirPlus *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + nfs3HandleSize(&x->handle) + 8 + Nfs3CookieVerfSize + 4 + 4;
+	return a;
+}
+int
+nfs3TReadDirPlusPack(uchar *a, uchar *ea, uchar **pa, Nfs3TReadDirPlus *x)
+{
+	if(nfs3HandlePack(a, ea, &a, &x->handle) < 0) goto Err;
+	if(sunUint64Pack(a, ea, &a, &x->cookie) < 0) goto Err;
+	if(sunFixedOpaquePack(a, ea, &a, x->verf, Nfs3CookieVerfSize) < 0) goto Err;
+	if(sunUint32Pack(a, ea, &a, &x->dirCount) < 0) goto Err;
+	if(sunUint32Pack(a, ea, &a, &x->maxCount) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3TReadDirPlusUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3TReadDirPlus *x)
+{
+	if(nfs3HandleUnpack(a, ea, &a, &x->handle) < 0) goto Err;
+	if(sunUint64Unpack(a, ea, &a, &x->cookie) < 0) goto Err;
+	if(sunFixedOpaqueUnpack(a, ea, &a, x->verf, Nfs3CookieVerfSize) < 0) goto Err;
+	if(sunUint32Unpack(a, ea, &a, &x->dirCount) < 0) goto Err;
+	if(sunUint32Unpack(a, ea, &a, &x->maxCount) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3EntryPlusPrint(Fmt *fmt, Nfs3Entry *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3EntryPlus");
+	fmtprint(fmt, "\t%s=", "fileid");
+	fmtprint(fmt, "%llud", x->fileid);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "name");
+	fmtprint(fmt, "\"%s\"", x->name);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "cookie");
+	fmtprint(fmt, "%llud", x->cookie);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "haveAttr");
+	fmtprint(fmt, "%d", x->haveAttr);
+	fmtprint(fmt, "\n");
+	switch(x->haveAttr){
+	case 1:
+		fmtprint(fmt, "\t%s=", "attr");
+		nfs3AttrPrint(fmt, &x->attr);
+		fmtprint(fmt, "\n");
+		break;
+	}
+	fmtprint(fmt, "\t%s=", "haveHandle");
+	fmtprint(fmt, "%d", x->haveHandle);
+	fmtprint(fmt, "\n");
+	switch(x->haveHandle){
+	case 1:
+		fmtprint(fmt, "\t%s=", "handle");
+		nfs3HandlePrint(fmt, &x->handle);
+		fmtprint(fmt, "\n");
+		break;
+	}
+}
+uint
+nfs3EntryPlusSize(Nfs3Entry *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + 8 + sunStringSize(x->name) + 8 + 4;
+	switch(x->haveAttr){
+	case 1:
+		a = a + nfs3AttrSize(&x->attr);
+		break;
+	}
+	a = a + 4;
+	switch(x->haveHandle){
+	case 1:
+		a = a + nfs3HandleSize(&x->handle);
+		break;
+	}
+	return a;
+}
+int
+nfs3EntryPlusPack(uchar *a, uchar *ea, uchar **pa, Nfs3Entry *x)
+{
+	u1int u1;
+
+	if(sunUint1Pack(a, ea, &a, &u1) < 0) goto Err;
+	if(sunUint64Pack(a, ea, &a, &x->fileid) < 0) goto Err;
+	if(sunStringPack(a, ea, &a, &x->name, -1) < 0) goto Err;
+	if(sunUint64Pack(a, ea, &a, &x->cookie) < 0) goto Err;
+	if(sunUint1Pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
+	switch(x->haveAttr){
+	case 1:
+		if(nfs3AttrPack(a, ea, &a, &x->attr) < 0) goto Err;
+		break;
+	}
+	if(sunUint1Pack(a, ea, &a, &x->haveHandle) < 0) goto Err;
+	switch(x->haveHandle){
+	case 1:
+		if(nfs3HandlePack(a, ea, &a, &x->handle) < 0) goto Err;
+		break;
+	}
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3EntryPlusUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3Entry *x)
+{
+	u1int u1;
+
+	if(sunUint1Unpack(a, ea, &a, &u1) < 0 || u1 != 1) goto Err;
+	if(sunUint64Unpack(a, ea, &a, &x->fileid) < 0) goto Err;
+	if(sunStringUnpack(a, ea, &a, &x->name, -1) < 0) goto Err;
+	if(sunUint64Unpack(a, ea, &a, &x->cookie) < 0) goto Err;
+	if(sunUint1Unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
+	switch(x->haveAttr){
+	case 1:
+		if(nfs3AttrUnpack(a, ea, &a, &x->attr) < 0) goto Err;
+		break;
+	}
+	if(sunUint1Unpack(a, ea, &a, &x->haveHandle) < 0) goto Err;
+	switch(x->haveHandle){
+	case 1:
+		if(nfs3HandleUnpack(a, ea, &a, &x->handle) < 0) goto Err;
+		break;
+	}
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3RReadDirPlusPrint(Fmt *fmt, Nfs3RReadDirPlus *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3RReadDirPlus");
+	fmtprint(fmt, "\t%s=", "status");
+	fmtprint(fmt, "%s", nfs3StatusStr(x->status));
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "haveAttr");
+	fmtprint(fmt, "%d", x->haveAttr);
+	fmtprint(fmt, "\n");
+	switch(x->haveAttr){
+	case 1:
+		fmtprint(fmt, "\t%s=", "attr");
+		nfs3AttrPrint(fmt, &x->attr);
+		fmtprint(fmt, "\n");
+		break;
+	}
+	switch(x->status){
+	case Nfs3Ok:
+		fmtprint(fmt, "\t%s=", "verf");
+		fmtprint(fmt, "%.*H", Nfs3CookieVerfSize, x->verf);
+		fmtprint(fmt, "\n");
+		fmtprint(fmt, "\tcount=%ud\n", x->count);
+		fmtprint(fmt, "\t%s=", "eof");
+		fmtprint(fmt, "%d", x->eof);
+		fmtprint(fmt, "\n");
+		break;
+	}
+}
+uint
+nfs3RReadDirPlusSize(Nfs3RReadDirPlus *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + 4 + 4;
+	switch(x->haveAttr){
+	case 1:
+		a = a + nfs3AttrSize(&x->attr);
+		break;
+	}
+	switch(x->status){
+	case Nfs3Ok:
+		a = a + Nfs3CookieVerfSize;
+		a += x->count;
+		a += 4 + 4;
+		break;
+	}
+	return a;
+}
+int
+nfs3RReadDirPlusPack(uchar *a, uchar *ea, uchar **pa, Nfs3RReadDirPlus *x)
+{
+	int i;
+	u1int zero;
+
+	if(i=x->status, sunEnumPack(a, ea, &a, &i) < 0) goto Err;
+	if(sunUint1Pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
+	switch(x->haveAttr){
+	case 1:
+		if(nfs3AttrPack(a, ea, &a, &x->attr) < 0) goto Err;
+		break;
+	}
+	switch(x->status){
+	case Nfs3Ok:
+		if(sunFixedOpaquePack(a, ea, &a, x->verf, Nfs3CookieVerfSize) < 0) goto Err;
+		if(sunFixedOpaquePack(a, ea, &a, x->data, x->count) < 0) goto Err;
+		zero = 0;
+		if(sunUint1Pack(a, ea, &a, &zero) < 0) goto Err;
+		if(sunUint1Pack(a, ea, &a, &x->eof) < 0) goto Err;
+		break;
+	}
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+static int
+countEntryPlus(uchar *a, uchar *ea, uchar **pa, u32int *n)
+{
+	uchar *oa;
+	u64int u64;
+	u32int u32;
+	u1int u1;
+	Nfs3Handle h;
+	Nfs3Attr attr;
+
+	oa = a;
+	for(;;){
+		if(sunUint1Unpack(a, ea, &a, &u1) < 0)
+			return -1;
+		if(u1 == 0)
+			break;
+		if(sunUint64Unpack(a, ea, &a, &u64) < 0
+		|| sunUint32Unpack(a, ea, &a, &u32) < 0)
+			return -1;
+		a += (u32+3)&~3;
+		if(a >= ea)
+			return -1;
+		if(sunUint64Unpack(a, ea, &a, &u64) < 0
+		|| sunUint1Unpack(a, ea, &a, &u1) < 0
+		|| (u1 && nfs3AttrUnpack(a, ea, &a, &attr) < 0)
+		|| sunUint1Unpack(a, ea, &a, &u1) < 0
+		|| (u1 && nfs3HandleUnpack(a, ea, &a, &h) < 0))
+			return -1;
+	}
+	*n = (a-4) - oa;
+	*pa = a;
+	return 0;
+}
+		
+int
+nfs3RReadDirPlusUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3RReadDirPlus *x)
+{
+	int i;
+
+	if(sunEnumUnpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
+	if(sunUint1Unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
+	switch(x->haveAttr){
+	case 1:
+		if(nfs3AttrUnpack(a, ea, &a, &x->attr) < 0) goto Err;
+		break;
+	}
+	if(x->status == Nfs3Ok){
+		if(sunFixedOpaqueUnpack(a, ea, &a, x->verf, Nfs3CookieVerfSize) < 0) goto Err;
+		x->data = a;
+		if(countEntryPlus(a, ea, &a, &x->count) < 0) goto Err;
+		if(sunUint1Unpack(a, ea, &a, &x->eof) < 0) goto Err;
+	}
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3TFsStatPrint(Fmt *fmt, Nfs3TFsStat *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3TFsStat");
+	fmtprint(fmt, "\t%s=", "handle");
+	nfs3HandlePrint(fmt, &x->handle);
+	fmtprint(fmt, "\n");
+}
+uint
+nfs3TFsStatSize(Nfs3TFsStat *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + nfs3HandleSize(&x->handle);
+	return a;
+}
+int
+nfs3TFsStatPack(uchar *a, uchar *ea, uchar **pa, Nfs3TFsStat *x)
+{
+	if(nfs3HandlePack(a, ea, &a, &x->handle) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3TFsStatUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3TFsStat *x)
+{
+	if(nfs3HandleUnpack(a, ea, &a, &x->handle) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3RFsStatPrint(Fmt *fmt, Nfs3RFsStat *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3RFsStat");
+	fmtprint(fmt, "\t%s=", "status");
+	fmtprint(fmt, "%s", nfs3StatusStr(x->status));
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "haveAttr");
+	fmtprint(fmt, "%d", x->haveAttr);
+	fmtprint(fmt, "\n");
+	switch(x->haveAttr){
+	case 1:
+		fmtprint(fmt, "\t%s=", "attr");
+		nfs3AttrPrint(fmt, &x->attr);
+		fmtprint(fmt, "\n");
+		break;
+	}
+	switch(x->status){
+	case Nfs3Ok:
+		fmtprint(fmt, "\t%s=", "totalBytes");
+		fmtprint(fmt, "%llud", x->totalBytes);
+		fmtprint(fmt, "\n");
+		fmtprint(fmt, "\t%s=", "freeBytes");
+		fmtprint(fmt, "%llud", x->freeBytes);
+		fmtprint(fmt, "\n");
+		fmtprint(fmt, "\t%s=", "availBytes");
+		fmtprint(fmt, "%llud", x->availBytes);
+		fmtprint(fmt, "\n");
+		fmtprint(fmt, "\t%s=", "totalFiles");
+		fmtprint(fmt, "%llud", x->totalFiles);
+		fmtprint(fmt, "\n");
+		fmtprint(fmt, "\t%s=", "freeFiles");
+		fmtprint(fmt, "%llud", x->freeFiles);
+		fmtprint(fmt, "\n");
+		fmtprint(fmt, "\t%s=", "availFiles");
+		fmtprint(fmt, "%llud", x->availFiles);
+		fmtprint(fmt, "\n");
+		fmtprint(fmt, "\t%s=", "invarSec");
+		fmtprint(fmt, "%ud", x->invarSec);
+		fmtprint(fmt, "\n");
+		break;
+	}
+}
+uint
+nfs3RFsStatSize(Nfs3RFsStat *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + 4 + 4;
+	switch(x->haveAttr){
+	case 1:
+		a = a + nfs3AttrSize(&x->attr);
+		break;
+	}
+	switch(x->status){
+	case Nfs3Ok:
+		a = a + 8 + 8 + 8 + 8 + 8 + 8 + 4;
+		break;
+	}
+	return a;
+}
+int
+nfs3RFsStatPack(uchar *a, uchar *ea, uchar **pa, Nfs3RFsStat *x)
+{
+	int i;
+
+	if(i=x->status, sunEnumPack(a, ea, &a, &i) < 0) goto Err;
+	if(sunUint1Pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
+	switch(x->haveAttr){
+	case 1:
+		if(nfs3AttrPack(a, ea, &a, &x->attr) < 0) goto Err;
+		break;
+	}
+	switch(x->status){
+	case Nfs3Ok:
+		if(sunUint64Pack(a, ea, &a, &x->totalBytes) < 0) goto Err;
+		if(sunUint64Pack(a, ea, &a, &x->freeBytes) < 0) goto Err;
+		if(sunUint64Pack(a, ea, &a, &x->availBytes) < 0) goto Err;
+		if(sunUint64Pack(a, ea, &a, &x->totalFiles) < 0) goto Err;
+		if(sunUint64Pack(a, ea, &a, &x->freeFiles) < 0) goto Err;
+		if(sunUint64Pack(a, ea, &a, &x->availFiles) < 0) goto Err;
+		if(sunUint32Pack(a, ea, &a, &x->invarSec) < 0) goto Err;
+		break;
+	}
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3RFsStatUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3RFsStat *x)
+{
+	int i;
+
+	if(sunEnumUnpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
+	if(sunUint1Unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
+	switch(x->haveAttr){
+	case 1:
+		if(nfs3AttrUnpack(a, ea, &a, &x->attr) < 0) goto Err;
+		break;
+	}
+	switch(x->status){
+	case Nfs3Ok:
+		if(sunUint64Unpack(a, ea, &a, &x->totalBytes) < 0) goto Err;
+		if(sunUint64Unpack(a, ea, &a, &x->freeBytes) < 0) goto Err;
+		if(sunUint64Unpack(a, ea, &a, &x->availBytes) < 0) goto Err;
+		if(sunUint64Unpack(a, ea, &a, &x->totalFiles) < 0) goto Err;
+		if(sunUint64Unpack(a, ea, &a, &x->freeFiles) < 0) goto Err;
+		if(sunUint64Unpack(a, ea, &a, &x->availFiles) < 0) goto Err;
+		if(sunUint32Unpack(a, ea, &a, &x->invarSec) < 0) goto Err;
+		break;
+	}
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3TFsInfoPrint(Fmt *fmt, Nfs3TFsInfo *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3TFsInfo");
+	fmtprint(fmt, "\t%s=", "handle");
+	nfs3HandlePrint(fmt, &x->handle);
+	fmtprint(fmt, "\n");
+}
+uint
+nfs3TFsInfoSize(Nfs3TFsInfo *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + nfs3HandleSize(&x->handle);
+	return a;
+}
+int
+nfs3TFsInfoPack(uchar *a, uchar *ea, uchar **pa, Nfs3TFsInfo *x)
+{
+	if(nfs3HandlePack(a, ea, &a, &x->handle) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3TFsInfoUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3TFsInfo *x)
+{
+	if(nfs3HandleUnpack(a, ea, &a, &x->handle) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3RFsInfoPrint(Fmt *fmt, Nfs3RFsInfo *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3RFsInfo");
+	fmtprint(fmt, "\t%s=", "status");
+	fmtprint(fmt, "%s", nfs3StatusStr(x->status));
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "haveAttr");
+	fmtprint(fmt, "%d", x->haveAttr);
+	fmtprint(fmt, "\n");
+	switch(x->haveAttr){
+	case 1:
+		fmtprint(fmt, "\t%s=", "attr");
+		nfs3AttrPrint(fmt, &x->attr);
+		fmtprint(fmt, "\n");
+		break;
+	}
+	switch(x->status){
+	case Nfs3Ok:
+		fmtprint(fmt, "\t%s=", "readMax");
+		fmtprint(fmt, "%ud", x->readMax);
+		fmtprint(fmt, "\n");
+		fmtprint(fmt, "\t%s=", "readPref");
+		fmtprint(fmt, "%ud", x->readPref);
+		fmtprint(fmt, "\n");
+		fmtprint(fmt, "\t%s=", "readMult");
+		fmtprint(fmt, "%ud", x->readMult);
+		fmtprint(fmt, "\n");
+		fmtprint(fmt, "\t%s=", "writeMax");
+		fmtprint(fmt, "%ud", x->writeMax);
+		fmtprint(fmt, "\n");
+		fmtprint(fmt, "\t%s=", "writePref");
+		fmtprint(fmt, "%ud", x->writePref);
+		fmtprint(fmt, "\n");
+		fmtprint(fmt, "\t%s=", "writeMult");
+		fmtprint(fmt, "%ud", x->writeMult);
+		fmtprint(fmt, "\n");
+		fmtprint(fmt, "\t%s=", "readDirPref");
+		fmtprint(fmt, "%ud", x->readDirPref);
+		fmtprint(fmt, "\n");
+		fmtprint(fmt, "\t%s=", "maxFileSize");
+		fmtprint(fmt, "%llud", x->maxFileSize);
+		fmtprint(fmt, "\n");
+		fmtprint(fmt, "\t%s=", "timePrec");
+		nfs3TimePrint(fmt, &x->timePrec);
+		fmtprint(fmt, "\n");
+		fmtprint(fmt, "\t%s=", "flags");
+		fmtprint(fmt, "%ud", x->flags);
+		fmtprint(fmt, "\n");
+		break;
+	}
+}
+uint
+nfs3RFsInfoSize(Nfs3RFsInfo *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + 4 + 4;
+	switch(x->haveAttr){
+	case 1:
+		a = a + nfs3AttrSize(&x->attr);
+		break;
+	}
+	switch(x->status){
+	case Nfs3Ok:
+		a = a + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 8 + nfs3TimeSize(&x->timePrec) + 4;
+		break;
+	}
+	return a;
+}
+int
+nfs3RFsInfoPack(uchar *a, uchar *ea, uchar **pa, Nfs3RFsInfo *x)
+{
+	int i;
+
+	if(i=x->status, sunEnumPack(a, ea, &a, &i) < 0) goto Err;
+	if(sunUint1Pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
+	switch(x->haveAttr){
+	case 1:
+		if(nfs3AttrPack(a, ea, &a, &x->attr) < 0) goto Err;
+		break;
+	}
+	switch(x->status){
+	case Nfs3Ok:
+		if(sunUint32Pack(a, ea, &a, &x->readMax) < 0) goto Err;
+		if(sunUint32Pack(a, ea, &a, &x->readPref) < 0) goto Err;
+		if(sunUint32Pack(a, ea, &a, &x->readMult) < 0) goto Err;
+		if(sunUint32Pack(a, ea, &a, &x->writeMax) < 0) goto Err;
+		if(sunUint32Pack(a, ea, &a, &x->writePref) < 0) goto Err;
+		if(sunUint32Pack(a, ea, &a, &x->writeMult) < 0) goto Err;
+		if(sunUint32Pack(a, ea, &a, &x->readDirPref) < 0) goto Err;
+		if(sunUint64Pack(a, ea, &a, &x->maxFileSize) < 0) goto Err;
+		if(nfs3TimePack(a, ea, &a, &x->timePrec) < 0) goto Err;
+		if(sunUint32Pack(a, ea, &a, &x->flags) < 0) goto Err;
+		break;
+	}
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3RFsInfoUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3RFsInfo *x)
+{
+	int i;
+
+	if(sunEnumUnpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
+	if(sunUint1Unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
+	switch(x->haveAttr){
+	case 1:
+		if(nfs3AttrUnpack(a, ea, &a, &x->attr) < 0) goto Err;
+		break;
+	}
+	switch(x->status){
+	case Nfs3Ok:
+		if(sunUint32Unpack(a, ea, &a, &x->readMax) < 0) goto Err;
+		if(sunUint32Unpack(a, ea, &a, &x->readPref) < 0) goto Err;
+		if(sunUint32Unpack(a, ea, &a, &x->readMult) < 0) goto Err;
+		if(sunUint32Unpack(a, ea, &a, &x->writeMax) < 0) goto Err;
+		if(sunUint32Unpack(a, ea, &a, &x->writePref) < 0) goto Err;
+		if(sunUint32Unpack(a, ea, &a, &x->writeMult) < 0) goto Err;
+		if(sunUint32Unpack(a, ea, &a, &x->readDirPref) < 0) goto Err;
+		if(sunUint64Unpack(a, ea, &a, &x->maxFileSize) < 0) goto Err;
+		if(nfs3TimeUnpack(a, ea, &a, &x->timePrec) < 0) goto Err;
+		if(sunUint32Unpack(a, ea, &a, &x->flags) < 0) goto Err;
+		break;
+	}
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3TPathconfPrint(Fmt *fmt, Nfs3TPathconf *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3TPathconf");
+	fmtprint(fmt, "\t%s=", "handle");
+	nfs3HandlePrint(fmt, &x->handle);
+	fmtprint(fmt, "\n");
+}
+uint
+nfs3TPathconfSize(Nfs3TPathconf *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + nfs3HandleSize(&x->handle);
+	return a;
+}
+int
+nfs3TPathconfPack(uchar *a, uchar *ea, uchar **pa, Nfs3TPathconf *x)
+{
+	if(nfs3HandlePack(a, ea, &a, &x->handle) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3TPathconfUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3TPathconf *x)
+{
+	if(nfs3HandleUnpack(a, ea, &a, &x->handle) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3RPathconfPrint(Fmt *fmt, Nfs3RPathconf *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3RPathconf");
+	fmtprint(fmt, "\t%s=", "status");
+	fmtprint(fmt, "%s", nfs3StatusStr(x->status));
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "haveAttr");
+	fmtprint(fmt, "%d", x->haveAttr);
+	fmtprint(fmt, "\n");
+	switch(x->haveAttr){
+	case 1:
+		fmtprint(fmt, "\t%s=", "attr");
+		nfs3AttrPrint(fmt, &x->attr);
+		fmtprint(fmt, "\n");
+		break;
+	}
+	switch(x->status){
+	case Nfs3Ok:
+		fmtprint(fmt, "\t%s=", "maxLink");
+		fmtprint(fmt, "%ud", x->maxLink);
+		fmtprint(fmt, "\n");
+		fmtprint(fmt, "\t%s=", "maxName");
+		fmtprint(fmt, "%ud", x->maxName);
+		fmtprint(fmt, "\n");
+		fmtprint(fmt, "\t%s=", "noTrunc");
+		fmtprint(fmt, "%d", x->noTrunc);
+		fmtprint(fmt, "\n");
+		fmtprint(fmt, "\t%s=", "chownRestricted");
+		fmtprint(fmt, "%d", x->chownRestricted);
+		fmtprint(fmt, "\n");
+		fmtprint(fmt, "\t%s=", "caseInsensitive");
+		fmtprint(fmt, "%d", x->caseInsensitive);
+		fmtprint(fmt, "\n");
+		fmtprint(fmt, "\t%s=", "casePreserving");
+		fmtprint(fmt, "%d", x->casePreserving);
+		fmtprint(fmt, "\n");
+		break;
+	}
+}
+uint
+nfs3RPathconfSize(Nfs3RPathconf *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + 4 + 4;
+	switch(x->haveAttr){
+	case 1:
+		a = a + nfs3AttrSize(&x->attr);
+		break;
+	}
+	switch(x->status){
+	case Nfs3Ok:
+		a = a + 4 + 4 + 4 + 4 + 4 + 4;
+		break;
+	}
+	return a;
+}
+int
+nfs3RPathconfPack(uchar *a, uchar *ea, uchar **pa, Nfs3RPathconf *x)
+{
+	int i;
+
+	if(i=x->status, sunEnumPack(a, ea, &a, &i) < 0) goto Err;
+	if(sunUint1Pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
+	switch(x->haveAttr){
+	case 1:
+		if(nfs3AttrPack(a, ea, &a, &x->attr) < 0) goto Err;
+		break;
+	}
+	switch(x->status){
+	case Nfs3Ok:
+		if(sunUint32Pack(a, ea, &a, &x->maxLink) < 0) goto Err;
+		if(sunUint32Pack(a, ea, &a, &x->maxName) < 0) goto Err;
+		if(sunUint1Pack(a, ea, &a, &x->noTrunc) < 0) goto Err;
+		if(sunUint1Pack(a, ea, &a, &x->chownRestricted) < 0) goto Err;
+		if(sunUint1Pack(a, ea, &a, &x->caseInsensitive) < 0) goto Err;
+		if(sunUint1Pack(a, ea, &a, &x->casePreserving) < 0) goto Err;
+		break;
+	}
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3RPathconfUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3RPathconf *x)
+{
+	int i;
+
+	if(sunEnumUnpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
+	if(sunUint1Unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
+	switch(x->haveAttr){
+	case 1:
+		if(nfs3AttrUnpack(a, ea, &a, &x->attr) < 0) goto Err;
+		break;
+	}
+	switch(x->status){
+	case Nfs3Ok:
+		if(sunUint32Unpack(a, ea, &a, &x->maxLink) < 0) goto Err;
+		if(sunUint32Unpack(a, ea, &a, &x->maxName) < 0) goto Err;
+		if(sunUint1Unpack(a, ea, &a, &x->noTrunc) < 0) goto Err;
+		if(sunUint1Unpack(a, ea, &a, &x->chownRestricted) < 0) goto Err;
+		if(sunUint1Unpack(a, ea, &a, &x->caseInsensitive) < 0) goto Err;
+		if(sunUint1Unpack(a, ea, &a, &x->casePreserving) < 0) goto Err;
+		break;
+	}
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3TCommitPrint(Fmt *fmt, Nfs3TCommit *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3TCommit");
+	fmtprint(fmt, "\t%s=", "handle");
+	nfs3HandlePrint(fmt, &x->handle);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "offset");
+	fmtprint(fmt, "%llud", x->offset);
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "count");
+	fmtprint(fmt, "%ud", x->count);
+	fmtprint(fmt, "\n");
+}
+uint
+nfs3TCommitSize(Nfs3TCommit *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + nfs3HandleSize(&x->handle) + 8 + 4;
+	return a;
+}
+int
+nfs3TCommitPack(uchar *a, uchar *ea, uchar **pa, Nfs3TCommit *x)
+{
+	if(nfs3HandlePack(a, ea, &a, &x->handle) < 0) goto Err;
+	if(sunUint64Pack(a, ea, &a, &x->offset) < 0) goto Err;
+	if(sunUint32Pack(a, ea, &a, &x->count) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3TCommitUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3TCommit *x)
+{
+	if(nfs3HandleUnpack(a, ea, &a, &x->handle) < 0) goto Err;
+	if(sunUint64Unpack(a, ea, &a, &x->offset) < 0) goto Err;
+	if(sunUint32Unpack(a, ea, &a, &x->count) < 0) goto Err;
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+void
+nfs3RCommitPrint(Fmt *fmt, Nfs3RCommit *x)
+{
+	fmtprint(fmt, "%s\n", "Nfs3RCommit");
+	fmtprint(fmt, "\t%s=", "status");
+	fmtprint(fmt, "%s", nfs3StatusStr(x->status));
+	fmtprint(fmt, "\n");
+	fmtprint(fmt, "\t%s=", "wcc");
+	nfs3WccPrint(fmt, &x->wcc);
+	fmtprint(fmt, "\n");
+	switch(x->status){
+	case Nfs3Ok:
+		fmtprint(fmt, "\t%s=", "verf");
+		fmtprint(fmt, "%.*H", Nfs3WriteVerfSize, x->verf);
+		fmtprint(fmt, "\n");
+		break;
+	}
+}
+uint
+nfs3RCommitSize(Nfs3RCommit *x)
+{
+	uint a;
+	USED(x);
+	a = 0 + 4 + nfs3WccSize(&x->wcc);
+	switch(x->status){
+	case Nfs3Ok:
+		a = a + Nfs3WriteVerfSize;
+		break;
+	}
+	return a;
+}
+int
+nfs3RCommitPack(uchar *a, uchar *ea, uchar **pa, Nfs3RCommit *x)
+{
+	int i;
+
+	if(i=x->status, sunEnumPack(a, ea, &a, &i) < 0) goto Err;
+	if(nfs3WccPack(a, ea, &a, &x->wcc) < 0) goto Err;
+	switch(x->status){
+	case Nfs3Ok:
+		if(sunFixedOpaquePack(a, ea, &a, x->verf, Nfs3WriteVerfSize) < 0) goto Err;
+		break;
+	}
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+int
+nfs3RCommitUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3RCommit *x)
+{
+	int i;
+
+	if(sunEnumUnpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
+	if(nfs3WccUnpack(a, ea, &a, &x->wcc) < 0) goto Err;
+	switch(x->status){
+	case Nfs3Ok:
+		if(sunFixedOpaqueUnpack(a, ea, &a, x->verf, Nfs3WriteVerfSize) < 0) goto Err;
+		break;
+	}
+	*pa = a;
+	return 0;
+Err:
+	*pa = ea;
+	return -1;
+}
+
+typedef int (*P)(uchar*, uchar*, uchar**, SunCall*);
+typedef void (*F)(Fmt*, SunCall*);
+typedef uint (*S)(SunCall*);
+
+static SunProc proc[] = {
+	(P)nfs3TNullPack, (P)nfs3TNullUnpack, (S)nfs3TNullSize, (F)nfs3TNullPrint, sizeof(Nfs3TNull),
+	(P)nfs3RNullPack, (P)nfs3RNullUnpack, (S)nfs3RNullSize, (F)nfs3RNullPrint, sizeof(Nfs3RNull),
+	(P)nfs3TGetattrPack, (P)nfs3TGetattrUnpack, (S)nfs3TGetattrSize, (F)nfs3TGetattrPrint, sizeof(Nfs3TGetattr),
+	(P)nfs3RGetattrPack, (P)nfs3RGetattrUnpack, (S)nfs3RGetattrSize, (F)nfs3RGetattrPrint, sizeof(Nfs3RGetattr),
+	(P)nfs3TSetattrPack, (P)nfs3TSetattrUnpack, (S)nfs3TSetattrSize, (F)nfs3TSetattrPrint, sizeof(Nfs3TSetattr),
+	(P)nfs3RSetattrPack, (P)nfs3RSetattrUnpack, (S)nfs3RSetattrSize, (F)nfs3RSetattrPrint, sizeof(Nfs3RSetattr),
+	(P)nfs3TLookupPack, (P)nfs3TLookupUnpack, (S)nfs3TLookupSize, (F)nfs3TLookupPrint, sizeof(Nfs3TLookup),
+	(P)nfs3RLookupPack, (P)nfs3RLookupUnpack, (S)nfs3RLookupSize, (F)nfs3RLookupPrint, sizeof(Nfs3RLookup),
+	(P)nfs3TAccessPack, (P)nfs3TAccessUnpack, (S)nfs3TAccessSize, (F)nfs3TAccessPrint, sizeof(Nfs3TAccess),
+	(P)nfs3RAccessPack, (P)nfs3RAccessUnpack, (S)nfs3RAccessSize, (F)nfs3RAccessPrint, sizeof(Nfs3RAccess),
+	(P)nfs3TReadlinkPack, (P)nfs3TReadlinkUnpack, (S)nfs3TReadlinkSize, (F)nfs3TReadlinkPrint, sizeof(Nfs3TReadlink),
+	(P)nfs3RReadlinkPack, (P)nfs3RReadlinkUnpack, (S)nfs3RReadlinkSize, (F)nfs3RReadlinkPrint, sizeof(Nfs3RReadlink),
+	(P)nfs3TReadPack, (P)nfs3TReadUnpack, (S)nfs3TReadSize, (F)nfs3TReadPrint, sizeof(Nfs3TRead),
+	(P)nfs3RReadPack, (P)nfs3RReadUnpack, (S)nfs3RReadSize, (F)nfs3RReadPrint, sizeof(Nfs3RRead),
+	(P)nfs3TWritePack, (P)nfs3TWriteUnpack, (S)nfs3TWriteSize, (F)nfs3TWritePrint, sizeof(Nfs3TWrite),
+	(P)nfs3RWritePack, (P)nfs3RWriteUnpack, (S)nfs3RWriteSize, (F)nfs3RWritePrint, sizeof(Nfs3RWrite),
+	(P)nfs3TCreatePack, (P)nfs3TCreateUnpack, (S)nfs3TCreateSize, (F)nfs3TCreatePrint, sizeof(Nfs3TCreate),
+	(P)nfs3RCreatePack, (P)nfs3RCreateUnpack, (S)nfs3RCreateSize, (F)nfs3RCreatePrint, sizeof(Nfs3RCreate),
+	(P)nfs3TMkdirPack, (P)nfs3TMkdirUnpack, (S)nfs3TMkdirSize, (F)nfs3TMkdirPrint, sizeof(Nfs3TMkdir),
+	(P)nfs3RMkdirPack, (P)nfs3RMkdirUnpack, (S)nfs3RMkdirSize, (F)nfs3RMkdirPrint, sizeof(Nfs3RMkdir),
+	(P)nfs3TSymlinkPack, (P)nfs3TSymlinkUnpack, (S)nfs3TSymlinkSize, (F)nfs3TSymlinkPrint, sizeof(Nfs3TSymlink),
+	(P)nfs3RSymlinkPack, (P)nfs3RSymlinkUnpack, (S)nfs3RSymlinkSize, (F)nfs3RSymlinkPrint, sizeof(Nfs3RSymlink),
+	(P)nfs3TMknodPack, (P)nfs3TMknodUnpack, (S)nfs3TMknodSize, (F)nfs3TMknodPrint, sizeof(Nfs3TMknod),
+	(P)nfs3RMknodPack, (P)nfs3RMknodUnpack, (S)nfs3RMknodSize, (F)nfs3RMknodPrint, sizeof(Nfs3RMknod),
+	(P)nfs3TRemovePack, (P)nfs3TRemoveUnpack, (S)nfs3TRemoveSize, (F)nfs3TRemovePrint, sizeof(Nfs3TRemove),
+	(P)nfs3RRemovePack, (P)nfs3RRemoveUnpack, (S)nfs3RRemoveSize, (F)nfs3RRemovePrint, sizeof(Nfs3RRemove),
+	(P)nfs3TRmdirPack, (P)nfs3TRmdirUnpack, (S)nfs3TRmdirSize, (F)nfs3TRmdirPrint, sizeof(Nfs3TRmdir),
+	(P)nfs3RRmdirPack, (P)nfs3RRmdirUnpack, (S)nfs3RRmdirSize, (F)nfs3RRmdirPrint, sizeof(Nfs3RRmdir),
+	(P)nfs3TRenamePack, (P)nfs3TRenameUnpack, (S)nfs3TRenameSize, (F)nfs3TRenamePrint, sizeof(Nfs3TRename),
+	(P)nfs3RRenamePack, (P)nfs3RRenameUnpack, (S)nfs3RRenameSize, (F)nfs3RRenamePrint, sizeof(Nfs3RRename),
+	(P)nfs3TLinkPack, (P)nfs3TLinkUnpack, (S)nfs3TLinkSize, (F)nfs3TLinkPrint, sizeof(Nfs3TLink),
+	(P)nfs3RLinkPack, (P)nfs3RLinkUnpack, (S)nfs3RLinkSize, (F)nfs3RLinkPrint, sizeof(Nfs3RLink),
+	(P)nfs3TReadDirPack, (P)nfs3TReadDirUnpack, (S)nfs3TReadDirSize, (F)nfs3TReadDirPrint, sizeof(Nfs3TReadDir),
+	(P)nfs3RReadDirPack, (P)nfs3RReadDirUnpack, (S)nfs3RReadDirSize, (F)nfs3RReadDirPrint, sizeof(Nfs3RReadDir),
+	(P)nfs3TReadDirPlusPack, (P)nfs3TReadDirPlusUnpack, (S)nfs3TReadDirPlusSize, (F)nfs3TReadDirPlusPrint, sizeof(Nfs3TReadDirPlus),
+	(P)nfs3RReadDirPlusPack, (P)nfs3RReadDirPlusUnpack, (S)nfs3RReadDirPlusSize, (F)nfs3RReadDirPlusPrint, sizeof(Nfs3RReadDirPlus),
+	(P)nfs3TFsStatPack, (P)nfs3TFsStatUnpack, (S)nfs3TFsStatSize, (F)nfs3TFsStatPrint, sizeof(Nfs3TFsStat),
+	(P)nfs3RFsStatPack, (P)nfs3RFsStatUnpack, (S)nfs3RFsStatSize, (F)nfs3RFsStatPrint, sizeof(Nfs3RFsStat),
+	(P)nfs3TFsInfoPack, (P)nfs3TFsInfoUnpack, (S)nfs3TFsInfoSize, (F)nfs3TFsInfoPrint, sizeof(Nfs3TFsInfo),
+	(P)nfs3RFsInfoPack, (P)nfs3RFsInfoUnpack, (S)nfs3RFsInfoSize, (F)nfs3RFsInfoPrint, sizeof(Nfs3RFsInfo),
+	(P)nfs3TPathconfPack, (P)nfs3TPathconfUnpack, (S)nfs3TPathconfSize, (F)nfs3TPathconfPrint, sizeof(Nfs3TPathconf),
+	(P)nfs3RPathconfPack, (P)nfs3RPathconfUnpack, (S)nfs3RPathconfSize, (F)nfs3RPathconfPrint, sizeof(Nfs3RPathconf),
+	(P)nfs3TCommitPack, (P)nfs3TCommitUnpack, (S)nfs3TCommitSize, (F)nfs3TCommitPrint, sizeof(Nfs3TCommit),
+	(P)nfs3RCommitPack, (P)nfs3RCommitUnpack, (S)nfs3RCommitSize, (F)nfs3RCommitPrint, sizeof(Nfs3RCommit)
+};
+
+SunProg nfs3Prog = 
+{
+	Nfs3Program,
+	Nfs3Version,
+	proc,
+	nelem(proc),
+};
-- 
cgit v1.2.3