nfs3.c - plan9port - fork of plan9port with libvec, libstr and libsdb

nfs3.c (93582B)
      1 #include <u.h>
      2 #include <libc.h>
      3 #include <thread.h>
      4 #include <sunrpc.h>
      5 #include <nfs3.h>
      6 
      7 char*
      8 nfs3statusstr(Nfs3Status x)
      9 {
     10 	switch(x){
     11 	case Nfs3Ok:
     12 		return "Nfs3Ok";
     13 	case Nfs3ErrNotOwner:
     14 		return "Nfs3ErrNotOwner";
     15 	case Nfs3ErrNoEnt:
     16 		return "Nfs3ErrNoEnt";
     17 	case Nfs3ErrNoMem:
     18 		return "Nfs3ErrNoMem";
     19 	case Nfs3ErrIo:
     20 		return "Nfs3ErrIo";
     21 	case Nfs3ErrNxio:
     22 		return "Nfs3ErrNxio";
     23 	case Nfs3ErrAcces:
     24 		return "Nfs3ErrAcces";
     25 	case Nfs3ErrExist:
     26 		return "Nfs3ErrExist";
     27 	case Nfs3ErrXDev:
     28 		return "Nfs3ErrXDev";
     29 	case Nfs3ErrNoDev:
     30 		return "Nfs3ErrNoDev";
     31 	case Nfs3ErrNotDir:
     32 		return "Nfs3ErrNotDir";
     33 	case Nfs3ErrIsDir:
     34 		return "Nfs3ErrIsDir";
     35 	case Nfs3ErrInval:
     36 		return "Nfs3ErrInval";
     37 	case Nfs3ErrFbig:
     38 		return "Nfs3ErrFbig";
     39 	case Nfs3ErrNoSpc:
     40 		return "Nfs3ErrNoSpc";
     41 	case Nfs3ErrRoFs:
     42 		return "Nfs3ErrRoFs";
     43 	case Nfs3ErrMLink:
     44 		return "Nfs3ErrMLink";
     45 	case Nfs3ErrNameTooLong:
     46 		return "Nfs3ErrNameTooLong";
     47 	case Nfs3ErrNotEmpty:
     48 		return "Nfs3ErrNotEmpty";
     49 	case Nfs3ErrDQuot:
     50 		return "Nfs3ErrDQuot";
     51 	case Nfs3ErrStale:
     52 		return "Nfs3ErrStale";
     53 	case Nfs3ErrRemote:
     54 		return "Nfs3ErrRemote";
     55 	case Nfs3ErrBadHandle:
     56 		return "Nfs3ErrBadHandle";
     57 	case Nfs3ErrNotSync:
     58 		return "Nfs3ErrNotSync";
     59 	case Nfs3ErrBadCookie:
     60 		return "Nfs3ErrBadCookie";
     61 	case Nfs3ErrNotSupp:
     62 		return "Nfs3ErrNotSupp";
     63 	case Nfs3ErrTooSmall:
     64 		return "Nfs3ErrTooSmall";
     65 	case Nfs3ErrServerFault:
     66 		return "Nfs3ErrServerFault";
     67 	case Nfs3ErrBadType:
     68 		return "Nfs3ErrBadType";
     69 	case Nfs3ErrJukebox:
     70 		return "Nfs3ErrJukebox";
     71 	case Nfs3ErrFprintNotFound:
     72 		return "Nfs3ErrFprintNotFound";
     73 	case Nfs3ErrAborted:
     74 		return "Nfs3ErrAborted";
     75 	default:
     76 		return "unknown";
     77 	}
     78 }
     79 
     80 static struct {
     81 	Nfs3Status status;
     82 	char *msg;
     83 } etab[] = {
     84 	Nfs3ErrNotOwner,	"not owner",
     85 	Nfs3ErrNoEnt,		"directory entry not found",
     86 	Nfs3ErrIo,			"i/o error",
     87 	Nfs3ErrNxio,		"no such device",
     88 	Nfs3ErrNoMem,	"out of memory",
     89 	Nfs3ErrAcces,		"access denied",
     90 	Nfs3ErrExist,		"file or directory exists",
     91 	Nfs3ErrXDev,		"cross-device operation",
     92 	Nfs3ErrNoDev,		"no such device",
     93 	Nfs3ErrNotDir,		"not a directory",
     94 	Nfs3ErrIsDir,		"is a directory",
     95 	Nfs3ErrInval,		"invalid arguments",
     96 	Nfs3ErrFbig,		"file too big",
     97 	Nfs3ErrNoSpc,		"no space left on device",
     98 	Nfs3ErrRoFs,		"read-only file system",
     99 	Nfs3ErrMLink,		"too many links",
    100 	Nfs3ErrNameTooLong,	"name too long",
    101 	Nfs3ErrNotEmpty,	"directory not empty",
    102 	Nfs3ErrDQuot,		"dquot",
    103 	Nfs3ErrStale,		"stale handle",
    104 	Nfs3ErrRemote,	"remote error",
    105 	Nfs3ErrBadHandle,	"bad handle",
    106 	Nfs3ErrNotSync,	"out of sync with server",
    107 	Nfs3ErrBadCookie,	"bad cookie",
    108 	Nfs3ErrNotSupp,	"not supported",
    109 	Nfs3ErrTooSmall,	"too small",
    110 	Nfs3ErrServerFault,	"server fault",
    111 	Nfs3ErrBadType,	"bad type",
    112 	Nfs3ErrJukebox,	"jukebox -- try again later",
    113 	Nfs3ErrFprintNotFound,	"fprint not found",
    114 	Nfs3ErrAborted,	"aborted",
    115 };
    116 
    117 void
    118 nfs3errstr(Nfs3Status status)
    119 {
    120 	int i;
    121 
    122 	for(i=0; i<nelem(etab); i++){
    123 		if((int)etab[i].status == (int)status){
    124 			werrstr(etab[i].msg);
    125 			return;
    126 		}
    127 	}
    128 	werrstr("unknown nfs3 error %d", (int)status);
    129 }
    130 
    131 char*
    132 nfs3filetypestr(Nfs3FileType x)
    133 {
    134 	switch(x){
    135 	case Nfs3FileReg:
    136 		return "Nfs3FileReg";
    137 	case Nfs3FileDir:
    138 		return "Nfs3FileDir";
    139 	case Nfs3FileBlock:
    140 		return "Nfs3FileBlock";
    141 	case Nfs3FileChar:
    142 		return "Nfs3FileChar";
    143 	case Nfs3FileSymlink:
    144 		return "Nfs3FileSymlink";
    145 	case Nfs3FileSocket:
    146 		return "Nfs3FileSocket";
    147 	case Nfs3FileFifo:
    148 		return "Nfs3FileFifo";
    149 	default:
    150 		return "unknown";
    151 	}
    152 }
    153 
    154 void
    155 nfs3handleprint(Fmt *fmt, Nfs3Handle *x)
    156 {
    157 	fmtprint(fmt, "%s\n", "Nfs3Handle");
    158 	fmtprint(fmt, "\t%s=", "handle");
    159 	if(x->len > 64)
    160 		fmtprint(fmt, "%.*H... (%d)", 64, x->h, x->len);
    161 	else
    162 		fmtprint(fmt, "%.*H", x->len, x->h);
    163 	fmtprint(fmt, "\n");
    164 }
    165 uint
    166 nfs3handlesize(Nfs3Handle *x)
    167 {
    168 	uint a;
    169 	USED(x);
    170 	a = 0 + sunvaropaquesize(x->len);
    171 	return a;
    172 }
    173 int
    174 nfs3handlepack(uchar *a, uchar *ea, uchar **pa, Nfs3Handle *x)
    175 {
    176 	if(x->len > Nfs3MaxHandleSize || sunuint32pack(a, ea, &a, &x->len) < 0
    177 	|| sunfixedopaquepack(a, ea, &a, x->h, x->len) < 0)
    178 		goto Err;
    179 	*pa = a;
    180 	return 0;
    181 Err:
    182 	*pa = ea;
    183 	return -1;
    184 }
    185 int
    186 nfs3handleunpack(uchar *a, uchar *ea, uchar **pa, Nfs3Handle *x)
    187 {
    188 	uchar *ha;
    189 	u32int n;
    190 
    191 	if(sunuint32unpack(a, ea, &a, &n) < 0 || n > Nfs3MaxHandleSize)
    192 		goto Err;
    193 	ha = a;
    194 	a += (n+3)&~3;
    195 	if(a > ea)
    196 		goto Err;
    197 	memmove(x->h, ha, n);
    198 	x->len = n;
    199 	*pa = a;
    200 	return 0;
    201 Err:
    202 	*pa = ea;
    203 	return -1;
    204 }
    205 void
    206 nfs3timeprint(Fmt *fmt, Nfs3Time *x)
    207 {
    208 	fmtprint(fmt, "%s\n", "Nfs3Time");
    209 	fmtprint(fmt, "\t%s=", "sec");
    210 	fmtprint(fmt, "%ud", x->sec);
    211 	fmtprint(fmt, "\n");
    212 	fmtprint(fmt, "\t%s=", "nsec");
    213 	fmtprint(fmt, "%ud", x->nsec);
    214 	fmtprint(fmt, "\n");
    215 }
    216 uint
    217 nfs3timesize(Nfs3Time *x)
    218 {
    219 	uint a;
    220 	USED(x);
    221 	a = 0 + 4 + 4;
    222 	return a;
    223 }
    224 int
    225 nfs3timepack(uchar *a, uchar *ea, uchar **pa, Nfs3Time *x)
    226 {
    227 	if(sunuint32pack(a, ea, &a, &x->sec) < 0) goto Err;
    228 	if(sunuint32pack(a, ea, &a, &x->nsec) < 0) goto Err;
    229 	*pa = a;
    230 	return 0;
    231 Err:
    232 	*pa = ea;
    233 	return -1;
    234 }
    235 int
    236 nfs3timeunpack(uchar *a, uchar *ea, uchar **pa, Nfs3Time *x)
    237 {
    238 	if(sunuint32unpack(a, ea, &a, &x->sec) < 0) goto Err;
    239 	if(sunuint32unpack(a, ea, &a, &x->nsec) < 0) goto Err;
    240 	*pa = a;
    241 	return 0;
    242 Err:
    243 	*pa = ea;
    244 	return -1;
    245 }
    246 void
    247 nfs3attrprint(Fmt *fmt, Nfs3Attr *x)
    248 {
    249 	fmtprint(fmt, "%s\n", "Nfs3Attr");
    250 	fmtprint(fmt, "\t%s=", "type");
    251 	fmtprint(fmt, "%s", nfs3filetypestr(x->type));
    252 	fmtprint(fmt, "\n");
    253 	fmtprint(fmt, "\t%s=", "mode");
    254 	fmtprint(fmt, "%ud", x->mode);
    255 	fmtprint(fmt, "\n");
    256 	fmtprint(fmt, "\t%s=", "nlink");
    257 	fmtprint(fmt, "%ud", x->nlink);
    258 	fmtprint(fmt, "\n");
    259 	fmtprint(fmt, "\t%s=", "uid");
    260 	fmtprint(fmt, "%ud", x->uid);
    261 	fmtprint(fmt, "\n");
    262 	fmtprint(fmt, "\t%s=", "gid");
    263 	fmtprint(fmt, "%ud", x->gid);
    264 	fmtprint(fmt, "\n");
    265 	fmtprint(fmt, "\t%s=", "size");
    266 	fmtprint(fmt, "%llud", x->size);
    267 	fmtprint(fmt, "\n");
    268 	fmtprint(fmt, "\t%s=", "used");
    269 	fmtprint(fmt, "%llud", x->used);
    270 	fmtprint(fmt, "\n");
    271 	fmtprint(fmt, "\t%s=", "major");
    272 	fmtprint(fmt, "%ud", x->major);
    273 	fmtprint(fmt, "\n");
    274 	fmtprint(fmt, "\t%s=", "minor");
    275 	fmtprint(fmt, "%ud", x->minor);
    276 	fmtprint(fmt, "\n");
    277 	fmtprint(fmt, "\t%s=", "fsid");
    278 	fmtprint(fmt, "%llud", x->fsid);
    279 	fmtprint(fmt, "\n");
    280 	fmtprint(fmt, "\t%s=", "fileid");
    281 	fmtprint(fmt, "%llud", x->fileid);
    282 	fmtprint(fmt, "\n");
    283 	fmtprint(fmt, "\t%s=", "atime");
    284 	nfs3timeprint(fmt, &x->atime);
    285 	fmtprint(fmt, "\n");
    286 	fmtprint(fmt, "\t%s=", "mtime");
    287 	nfs3timeprint(fmt, &x->mtime);
    288 	fmtprint(fmt, "\n");
    289 	fmtprint(fmt, "\t%s=", "ctime");
    290 	nfs3timeprint(fmt, &x->ctime);
    291 	fmtprint(fmt, "\n");
    292 }
    293 uint
    294 nfs3attrsize(Nfs3Attr *x)
    295 {
    296 	uint a;
    297 	USED(x);
    298 	a = 0 + 4 + 4 + 4 + 4 + 4 + 8 + 8 + 4 + 4 + 8 + 8 + nfs3timesize(&x->atime) + nfs3timesize(&x->mtime) + nfs3timesize(&x->ctime);
    299 	return a;
    300 }
    301 int
    302 nfs3attrpack(uchar *a, uchar *ea, uchar **pa, Nfs3Attr *x)
    303 {
    304 	int i;
    305 
    306 	if(i=x->type, sunenumpack(a, ea, &a, &i) < 0) goto Err;
    307 	if(sunuint32pack(a, ea, &a, &x->mode) < 0) goto Err;
    308 	if(sunuint32pack(a, ea, &a, &x->nlink) < 0) goto Err;
    309 	if(sunuint32pack(a, ea, &a, &x->uid) < 0) goto Err;
    310 	if(sunuint32pack(a, ea, &a, &x->gid) < 0) goto Err;
    311 	if(sunuint64pack(a, ea, &a, &x->size) < 0) goto Err;
    312 	if(sunuint64pack(a, ea, &a, &x->used) < 0) goto Err;
    313 	if(sunuint32pack(a, ea, &a, &x->major) < 0) goto Err;
    314 	if(sunuint32pack(a, ea, &a, &x->minor) < 0) goto Err;
    315 	if(sunuint64pack(a, ea, &a, &x->fsid) < 0) goto Err;
    316 	if(sunuint64pack(a, ea, &a, &x->fileid) < 0) goto Err;
    317 	if(nfs3timepack(a, ea, &a, &x->atime) < 0) goto Err;
    318 	if(nfs3timepack(a, ea, &a, &x->mtime) < 0) goto Err;
    319 	if(nfs3timepack(a, ea, &a, &x->ctime) < 0) goto Err;
    320 	*pa = a;
    321 	return 0;
    322 Err:
    323 	*pa = ea;
    324 	return -1;
    325 }
    326 int
    327 nfs3attrunpack(uchar *a, uchar *ea, uchar **pa, Nfs3Attr *x)
    328 {
    329 	int i;
    330 	if(sunenumunpack(a, ea, &a, &i) < 0) goto Err; x->type = i;
    331 	if(sunuint32unpack(a, ea, &a, &x->mode) < 0) goto Err;
    332 	if(sunuint32unpack(a, ea, &a, &x->nlink) < 0) goto Err;
    333 	if(sunuint32unpack(a, ea, &a, &x->uid) < 0) goto Err;
    334 	if(sunuint32unpack(a, ea, &a, &x->gid) < 0) goto Err;
    335 	if(sunuint64unpack(a, ea, &a, &x->size) < 0) goto Err;
    336 	if(sunuint64unpack(a, ea, &a, &x->used) < 0) goto Err;
    337 	if(sunuint32unpack(a, ea, &a, &x->major) < 0) goto Err;
    338 	if(sunuint32unpack(a, ea, &a, &x->minor) < 0) goto Err;
    339 	if(sunuint64unpack(a, ea, &a, &x->fsid) < 0) goto Err;
    340 	if(sunuint64unpack(a, ea, &a, &x->fileid) < 0) goto Err;
    341 	if(nfs3timeunpack(a, ea, &a, &x->atime) < 0) goto Err;
    342 	if(nfs3timeunpack(a, ea, &a, &x->mtime) < 0) goto Err;
    343 	if(nfs3timeunpack(a, ea, &a, &x->ctime) < 0) goto Err;
    344 	*pa = a;
    345 	return 0;
    346 Err:
    347 	*pa = ea;
    348 	return -1;
    349 }
    350 void
    351 nfs3wccattrprint(Fmt *fmt, Nfs3WccAttr *x)
    352 {
    353 	fmtprint(fmt, "%s\n", "Nfs3WccAttr");
    354 	fmtprint(fmt, "\t%s=", "size");
    355 	fmtprint(fmt, "%llud", x->size);
    356 	fmtprint(fmt, "\n");
    357 	fmtprint(fmt, "\t%s=", "mtime");
    358 	nfs3timeprint(fmt, &x->mtime);
    359 	fmtprint(fmt, "\n");
    360 	fmtprint(fmt, "\t%s=", "ctime");
    361 	nfs3timeprint(fmt, &x->ctime);
    362 	fmtprint(fmt, "\n");
    363 }
    364 uint
    365 nfs3wccattrsize(Nfs3WccAttr *x)
    366 {
    367 	uint a;
    368 	USED(x);
    369 	a = 0 + 8 + nfs3timesize(&x->mtime) + nfs3timesize(&x->ctime);
    370 	return a;
    371 }
    372 int
    373 nfs3wccattrpack(uchar *a, uchar *ea, uchar **pa, Nfs3WccAttr *x)
    374 {
    375 	if(sunuint64pack(a, ea, &a, &x->size) < 0) goto Err;
    376 	if(nfs3timepack(a, ea, &a, &x->mtime) < 0) goto Err;
    377 	if(nfs3timepack(a, ea, &a, &x->ctime) < 0) goto Err;
    378 	*pa = a;
    379 	return 0;
    380 Err:
    381 	*pa = ea;
    382 	return -1;
    383 }
    384 int
    385 nfs3wccattrunpack(uchar *a, uchar *ea, uchar **pa, Nfs3WccAttr *x)
    386 {
    387 	if(sunuint64unpack(a, ea, &a, &x->size) < 0) goto Err;
    388 	if(nfs3timeunpack(a, ea, &a, &x->mtime) < 0) goto Err;
    389 	if(nfs3timeunpack(a, ea, &a, &x->ctime) < 0) goto Err;
    390 	*pa = a;
    391 	return 0;
    392 Err:
    393 	*pa = ea;
    394 	return -1;
    395 }
    396 void
    397 nfs3wccprint(Fmt *fmt, Nfs3Wcc *x)
    398 {
    399 	fmtprint(fmt, "%s\n", "Nfs3Wcc");
    400 	fmtprint(fmt, "\t%s=", "haveWccAttr");
    401 	fmtprint(fmt, "%d", x->haveWccAttr);
    402 	fmtprint(fmt, "\n");
    403 	switch(x->haveWccAttr){
    404 	case 1:
    405 		fmtprint(fmt, "\t%s=", "wccAttr");
    406 		nfs3wccattrprint(fmt, &x->wccAttr);
    407 		fmtprint(fmt, "\n");
    408 		break;
    409 	}
    410 	fmtprint(fmt, "\t%s=", "haveAttr");
    411 	fmtprint(fmt, "%d", x->haveAttr);
    412 	fmtprint(fmt, "\n");
    413 	switch(x->haveAttr){
    414 	case 1:
    415 		fmtprint(fmt, "\t%s=", "attr");
    416 		nfs3attrprint(fmt, &x->attr);
    417 		fmtprint(fmt, "\n");
    418 		break;
    419 	}
    420 }
    421 uint
    422 nfs3wccsize(Nfs3Wcc *x)
    423 {
    424 	uint a;
    425 	USED(x);
    426 	a = 0 + 4;
    427 	switch(x->haveWccAttr){
    428 	case 1:
    429 		a = a + nfs3wccattrsize(&x->wccAttr);
    430 		break;
    431 	}
    432 	a = a + 4;
    433 	switch(x->haveAttr){
    434 	case 1:
    435 		a = a + nfs3attrsize(&x->attr);
    436 		break;
    437 	}
    438 	return a;
    439 }
    440 int
    441 nfs3wccpack(uchar *a, uchar *ea, uchar **pa, Nfs3Wcc *x)
    442 {
    443 	if(sunuint1pack(a, ea, &a, &x->haveWccAttr) < 0) goto Err;
    444 	switch(x->haveWccAttr){
    445 	case 1:
    446 		if(nfs3wccattrpack(a, ea, &a, &x->wccAttr) < 0) goto Err;
    447 		break;
    448 	}
    449 	if(sunuint1pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
    450 	switch(x->haveAttr){
    451 	case 1:
    452 		if(nfs3attrpack(a, ea, &a, &x->attr) < 0) goto Err;
    453 		break;
    454 	}
    455 	*pa = a;
    456 	return 0;
    457 Err:
    458 	*pa = ea;
    459 	return -1;
    460 }
    461 int
    462 nfs3wccunpack(uchar *a, uchar *ea, uchar **pa, Nfs3Wcc *x)
    463 {
    464 	if(sunuint1unpack(a, ea, &a, &x->haveWccAttr) < 0) goto Err;
    465 	switch(x->haveWccAttr){
    466 	case 1:
    467 		if(nfs3wccattrunpack(a, ea, &a, &x->wccAttr) < 0) goto Err;
    468 		break;
    469 	}
    470 	if(sunuint1unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
    471 	switch(x->haveAttr){
    472 	case 1:
    473 		if(nfs3attrunpack(a, ea, &a, &x->attr) < 0) goto Err;
    474 		break;
    475 	}
    476 	*pa = a;
    477 	return 0;
    478 Err:
    479 	*pa = ea;
    480 	return -1;
    481 }
    482 char*
    483 nfs3settimestr(Nfs3SetTime x)
    484 {
    485 	switch(x){
    486 	case Nfs3SetTimeDont:
    487 		return "Nfs3SetTimeDont";
    488 	case Nfs3SetTimeServer:
    489 		return "Nfs3SetTimeServer";
    490 	case Nfs3SetTimeClient:
    491 		return "Nfs3SetTimeClient";
    492 	default:
    493 		return "unknown";
    494 	}
    495 }
    496 
    497 void
    498 nfs3setattrprint(Fmt *fmt, Nfs3SetAttr *x)
    499 {
    500 	fmtprint(fmt, "%s\n", "Nfs3SetAttr");
    501 	fmtprint(fmt, "\t%s=", "setMode");
    502 	fmtprint(fmt, "%d", x->setMode);
    503 	fmtprint(fmt, "\n");
    504 	switch(x->setMode){
    505 	case 1:
    506 		fmtprint(fmt, "\t%s=", "mode");
    507 		fmtprint(fmt, "%ud", x->mode);
    508 		fmtprint(fmt, "\n");
    509 		break;
    510 	}
    511 	fmtprint(fmt, "\t%s=", "setUid");
    512 	fmtprint(fmt, "%d", x->setUid);
    513 	fmtprint(fmt, "\n");
    514 	switch(x->setUid){
    515 	case 1:
    516 		fmtprint(fmt, "\t%s=", "uid");
    517 		fmtprint(fmt, "%ud", x->uid);
    518 		fmtprint(fmt, "\n");
    519 		break;
    520 	}
    521 	fmtprint(fmt, "\t%s=", "setGid");
    522 	fmtprint(fmt, "%d", x->setGid);
    523 	fmtprint(fmt, "\n");
    524 	switch(x->setGid){
    525 	case 1:
    526 		fmtprint(fmt, "\t%s=", "gid");
    527 		fmtprint(fmt, "%ud", x->gid);
    528 		fmtprint(fmt, "\n");
    529 		break;
    530 	}
    531 	fmtprint(fmt, "\t%s=", "setSize");
    532 	fmtprint(fmt, "%d", x->setSize);
    533 	fmtprint(fmt, "\n");
    534 	switch(x->setSize){
    535 	case 1:
    536 		fmtprint(fmt, "\t%s=", "size");
    537 		fmtprint(fmt, "%llud", x->size);
    538 		fmtprint(fmt, "\n");
    539 		break;
    540 	}
    541 	fmtprint(fmt, "\t%s=", "setAtime");
    542 	fmtprint(fmt, "%s", nfs3settimestr(x->setAtime));
    543 	fmtprint(fmt, "\n");
    544 	switch(x->setAtime){
    545 	case Nfs3SetTimeClient:
    546 		fmtprint(fmt, "\t%s=", "atime");
    547 		nfs3timeprint(fmt, &x->atime);
    548 		fmtprint(fmt, "\n");
    549 		break;
    550 	}
    551 	fmtprint(fmt, "\t%s=", "setMtime");
    552 	fmtprint(fmt, "%s", nfs3settimestr(x->setMtime));
    553 	fmtprint(fmt, "\n");
    554 	switch(x->setMtime){
    555 	case Nfs3SetTimeClient:
    556 		fmtprint(fmt, "\t%s=", "mtime");
    557 		nfs3timeprint(fmt, &x->mtime);
    558 		fmtprint(fmt, "\n");
    559 		break;
    560 	}
    561 }
    562 uint
    563 nfs3setattrsize(Nfs3SetAttr *x)
    564 {
    565 	uint a;
    566 	USED(x);
    567 	a = 0 + 4;
    568 	switch(x->setMode){
    569 	case 1:
    570 		a = a + 4;
    571 		break;
    572 	}
    573 	a = a + 4;
    574 	switch(x->setUid){
    575 	case 1:
    576 		a = a + 4;
    577 		break;
    578 	}
    579 	a = a + 4;
    580 	switch(x->setGid){
    581 	case 1:
    582 		a = a + 4;
    583 		break;
    584 	}
    585 	a = a + 4;
    586 	switch(x->setSize){
    587 	case 1:
    588 		a = a + 8;
    589 		break;
    590 	}
    591 	a = a + 4;
    592 	switch(x->setAtime){
    593 	case Nfs3SetTimeClient:
    594 		a = a + nfs3timesize(&x->atime);
    595 		break;
    596 	}
    597 	a = a + 4;
    598 	switch(x->setMtime){
    599 	case Nfs3SetTimeClient:
    600 		a = a + nfs3timesize(&x->mtime);
    601 		break;
    602 	}
    603 	return a;
    604 }
    605 int
    606 nfs3setattrpack(uchar *a, uchar *ea, uchar **pa, Nfs3SetAttr *x)
    607 {
    608 	int i;
    609 
    610 	if(sunuint1pack(a, ea, &a, &x->setMode) < 0) goto Err;
    611 	switch(x->setMode){
    612 	case 1:
    613 		if(sunuint32pack(a, ea, &a, &x->mode) < 0) goto Err;
    614 		break;
    615 	}
    616 	if(sunuint1pack(a, ea, &a, &x->setUid) < 0) goto Err;
    617 	switch(x->setUid){
    618 	case 1:
    619 		if(sunuint32pack(a, ea, &a, &x->uid) < 0) goto Err;
    620 		break;
    621 	}
    622 	if(sunuint1pack(a, ea, &a, &x->setGid) < 0) goto Err;
    623 	switch(x->setGid){
    624 	case 1:
    625 		if(sunuint32pack(a, ea, &a, &x->gid) < 0) goto Err;
    626 		break;
    627 	}
    628 	if(sunuint1pack(a, ea, &a, &x->setSize) < 0) goto Err;
    629 	switch(x->setSize){
    630 	case 1:
    631 		if(sunuint64pack(a, ea, &a, &x->size) < 0) goto Err;
    632 		break;
    633 	}
    634 	if(i=x->setAtime, sunenumpack(a, ea, &a, &i) < 0) goto Err;
    635 	switch(x->setAtime){
    636 	case Nfs3SetTimeClient:
    637 		if(nfs3timepack(a, ea, &a, &x->atime) < 0) goto Err;
    638 		break;
    639 	}
    640 	if(i=x->setMtime, sunenumpack(a, ea, &a, &i) < 0) goto Err;
    641 	switch(x->setMtime){
    642 	case Nfs3SetTimeClient:
    643 		if(nfs3timepack(a, ea, &a, &x->mtime) < 0) goto Err;
    644 		break;
    645 	}
    646 	*pa = a;
    647 	return 0;
    648 Err:
    649 	*pa = ea;
    650 	return -1;
    651 }
    652 int
    653 nfs3setattrunpack(uchar *a, uchar *ea, uchar **pa, Nfs3SetAttr *x)
    654 {
    655 	int i;
    656 
    657 	if(sunuint1unpack(a, ea, &a, &x->setMode) < 0) goto Err;
    658 	switch(x->setMode){
    659 	case 1:
    660 		if(sunuint32unpack(a, ea, &a, &x->mode) < 0) goto Err;
    661 		break;
    662 	}
    663 	if(sunuint1unpack(a, ea, &a, &x->setUid) < 0) goto Err;
    664 	switch(x->setUid){
    665 	case 1:
    666 		if(sunuint32unpack(a, ea, &a, &x->uid) < 0) goto Err;
    667 		break;
    668 	}
    669 	if(sunuint1unpack(a, ea, &a, &x->setGid) < 0) goto Err;
    670 	switch(x->setGid){
    671 	case 1:
    672 		if(sunuint32unpack(a, ea, &a, &x->gid) < 0) goto Err;
    673 		break;
    674 	}
    675 	if(sunuint1unpack(a, ea, &a, &x->setSize) < 0) goto Err;
    676 	switch(x->setSize){
    677 	case 1:
    678 		if(sunuint64unpack(a, ea, &a, &x->size) < 0) goto Err;
    679 		break;
    680 	}
    681 	if(sunenumunpack(a, ea, &a, &i) < 0) goto Err; x->setAtime = i;
    682 	switch(x->setAtime){
    683 	case Nfs3SetTimeClient:
    684 		if(nfs3timeunpack(a, ea, &a, &x->atime) < 0) goto Err;
    685 		break;
    686 	}
    687 	if(sunenumunpack(a, ea, &a, &i) < 0) goto Err; x->setMtime = i;
    688 	switch(x->setMtime){
    689 	case Nfs3SetTimeClient:
    690 		if(nfs3timeunpack(a, ea, &a, &x->mtime) < 0) goto Err;
    691 		break;
    692 	}
    693 	*pa = a;
    694 	return 0;
    695 Err:
    696 	*pa = ea;
    697 	return -1;
    698 }
    699 void
    700 nfs3tnullprint(Fmt *fmt, Nfs3TNull *x)
    701 {
    702 	USED(x);
    703 	fmtprint(fmt, "%s\n", "Nfs3TNull");
    704 }
    705 uint
    706 nfs3tnullsize(Nfs3TNull *x)
    707 {
    708 	uint a;
    709 	USED(x);
    710 	a = 0;
    711 	return a;
    712 }
    713 int
    714 nfs3tnullpack(uchar *a, uchar *ea, uchar **pa, Nfs3TNull *x)
    715 {
    716 	USED(x);
    717 	USED(ea);
    718 	*pa = a;
    719 	return 0;
    720 }
    721 int
    722 nfs3tnullunpack(uchar *a, uchar *ea, uchar **pa, Nfs3TNull *x)
    723 {
    724 	USED(x);
    725 	USED(ea);
    726 	*pa = a;
    727 	return 0;
    728 }
    729 void
    730 nfs3rnullprint(Fmt *fmt, Nfs3RNull *x)
    731 {
    732 	USED(x);
    733 	fmtprint(fmt, "%s\n", "Nfs3RNull");
    734 }
    735 uint
    736 nfs3rnullsize(Nfs3RNull *x)
    737 {
    738 	uint a;
    739 	USED(x);
    740 	a = 0;
    741 	return a;
    742 }
    743 int
    744 nfs3rnullpack(uchar *a, uchar *ea, uchar **pa, Nfs3RNull *x)
    745 {
    746 	USED(ea);
    747 	USED(x);
    748 	*pa = a;
    749 	return 0;
    750 }
    751 int
    752 nfs3rnullunpack(uchar *a, uchar *ea, uchar **pa, Nfs3RNull *x)
    753 {
    754 	USED(ea);
    755 	USED(x);
    756 	*pa = a;
    757 	return 0;
    758 }
    759 void
    760 nfs3tgetattrprint(Fmt *fmt, Nfs3TGetattr *x)
    761 {
    762 	fmtprint(fmt, "%s\n", "Nfs3TGetattr");
    763 	fmtprint(fmt, "\t%s=", "handle");
    764 	nfs3handleprint(fmt, &x->handle);
    765 	fmtprint(fmt, "\n");
    766 }
    767 uint
    768 nfs3tgetattrsize(Nfs3TGetattr *x)
    769 {
    770 	uint a;
    771 	USED(x);
    772 	a = 0 + nfs3handlesize(&x->handle);
    773 	return a;
    774 }
    775 int
    776 nfs3tgetattrpack(uchar *a, uchar *ea, uchar **pa, Nfs3TGetattr *x)
    777 {
    778 	if(nfs3handlepack(a, ea, &a, &x->handle) < 0) goto Err;
    779 	*pa = a;
    780 	return 0;
    781 Err:
    782 	*pa = ea;
    783 	return -1;
    784 }
    785 int
    786 nfs3tgetattrunpack(uchar *a, uchar *ea, uchar **pa, Nfs3TGetattr *x)
    787 {
    788 	if(nfs3handleunpack(a, ea, &a, &x->handle) < 0) goto Err;
    789 	*pa = a;
    790 	return 0;
    791 Err:
    792 	*pa = ea;
    793 	return -1;
    794 }
    795 void
    796 nfs3rgetattrprint(Fmt *fmt, Nfs3RGetattr *x)
    797 {
    798 	fmtprint(fmt, "%s\n", "Nfs3RGetattr");
    799 	fmtprint(fmt, "\t%s=", "status");
    800 	fmtprint(fmt, "%s", nfs3statusstr(x->status));
    801 	fmtprint(fmt, "\n");
    802 	switch(x->status){
    803 	case Nfs3Ok:
    804 		fmtprint(fmt, "\t%s=", "attr");
    805 		nfs3attrprint(fmt, &x->attr);
    806 		fmtprint(fmt, "\n");
    807 		break;
    808 	}
    809 }
    810 uint
    811 nfs3rgetattrsize(Nfs3RGetattr *x)
    812 {
    813 	uint a;
    814 	USED(x);
    815 	a = 0 + 4;
    816 	switch(x->status){
    817 	case Nfs3Ok:
    818 		a = a + nfs3attrsize(&x->attr);
    819 		break;
    820 	}
    821 	return a;
    822 }
    823 int
    824 nfs3rgetattrpack(uchar *a, uchar *ea, uchar **pa, Nfs3RGetattr *x)
    825 {
    826 	int i;
    827 
    828 	if(i=x->status, sunenumpack(a, ea, &a, &i) < 0) goto Err;
    829 	switch(x->status){
    830 	case Nfs3Ok:
    831 		if(nfs3attrpack(a, ea, &a, &x->attr) < 0) goto Err;
    832 		break;
    833 	}
    834 	*pa = a;
    835 	return 0;
    836 Err:
    837 	*pa = ea;
    838 	return -1;
    839 }
    840 int
    841 nfs3rgetattrunpack(uchar *a, uchar *ea, uchar **pa, Nfs3RGetattr *x)
    842 {
    843 	int i;
    844 
    845 	if(sunenumunpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
    846 	switch(x->status){
    847 	case Nfs3Ok:
    848 		if(nfs3attrunpack(a, ea, &a, &x->attr) < 0) goto Err;
    849 		break;
    850 	}
    851 	*pa = a;
    852 	return 0;
    853 Err:
    854 	*pa = ea;
    855 	return -1;
    856 }
    857 void
    858 nfs3tsetattrprint(Fmt *fmt, Nfs3TSetattr *x)
    859 {
    860 	fmtprint(fmt, "%s\n", "Nfs3TSetattr");
    861 	fmtprint(fmt, "\t%s=", "handle");
    862 	nfs3handleprint(fmt, &x->handle);
    863 	fmtprint(fmt, "\n");
    864 	fmtprint(fmt, "\t%s=", "attr");
    865 	nfs3setattrprint(fmt, &x->attr);
    866 	fmtprint(fmt, "\n");
    867 	fmtprint(fmt, "\t%s=", "checkCtime");
    868 	fmtprint(fmt, "%d", x->checkCtime);
    869 	fmtprint(fmt, "\n");
    870 	switch(x->checkCtime){
    871 	case 1:
    872 		fmtprint(fmt, "\t%s=", "ctime");
    873 		nfs3timeprint(fmt, &x->ctime);
    874 		fmtprint(fmt, "\n");
    875 		break;
    876 	}
    877 }
    878 uint
    879 nfs3tsetattrsize(Nfs3TSetattr *x)
    880 {
    881 	uint a;
    882 	USED(x);
    883 	a = 0 + nfs3handlesize(&x->handle) + nfs3setattrsize(&x->attr) + 4;
    884 	switch(x->checkCtime){
    885 	case 1:
    886 		a = a + nfs3timesize(&x->ctime);
    887 		break;
    888 	}
    889 	return a;
    890 }
    891 int
    892 nfs3tsetattrpack(uchar *a, uchar *ea, uchar **pa, Nfs3TSetattr *x)
    893 {
    894 	if(nfs3handlepack(a, ea, &a, &x->handle) < 0) goto Err;
    895 	if(nfs3setattrpack(a, ea, &a, &x->attr) < 0) goto Err;
    896 	if(sunuint1pack(a, ea, &a, &x->checkCtime) < 0) goto Err;
    897 	switch(x->checkCtime){
    898 	case 1:
    899 		if(nfs3timepack(a, ea, &a, &x->ctime) < 0) goto Err;
    900 		break;
    901 	}
    902 	*pa = a;
    903 	return 0;
    904 Err:
    905 	*pa = ea;
    906 	return -1;
    907 }
    908 int
    909 nfs3tsetattrunpack(uchar *a, uchar *ea, uchar **pa, Nfs3TSetattr *x)
    910 {
    911 	if(nfs3handleunpack(a, ea, &a, &x->handle) < 0) goto Err;
    912 	if(nfs3setattrunpack(a, ea, &a, &x->attr) < 0) goto Err;
    913 	if(sunuint1unpack(a, ea, &a, &x->checkCtime) < 0) goto Err;
    914 	switch(x->checkCtime){
    915 	case 1:
    916 		if(nfs3timeunpack(a, ea, &a, &x->ctime) < 0) goto Err;
    917 		break;
    918 	}
    919 	*pa = a;
    920 	return 0;
    921 Err:
    922 	*pa = ea;
    923 	return -1;
    924 }
    925 void
    926 nfs3rsetattrprint(Fmt *fmt, Nfs3RSetattr *x)
    927 {
    928 	fmtprint(fmt, "%s\n", "Nfs3RSetattr");
    929 	fmtprint(fmt, "\t%s=", "status");
    930 	fmtprint(fmt, "%s", nfs3statusstr(x->status));
    931 	fmtprint(fmt, "\n");
    932 	fmtprint(fmt, "\t%s=", "wcc");
    933 	nfs3wccprint(fmt, &x->wcc);
    934 	fmtprint(fmt, "\n");
    935 }
    936 uint
    937 nfs3rsetattrsize(Nfs3RSetattr *x)
    938 {
    939 	uint a;
    940 	USED(x);
    941 	a = 0 + 4 + nfs3wccsize(&x->wcc);
    942 	return a;
    943 }
    944 int
    945 nfs3rsetattrpack(uchar *a, uchar *ea, uchar **pa, Nfs3RSetattr *x)
    946 {
    947 	int i;
    948 
    949 	if(i=x->status, sunenumpack(a, ea, &a, &i) < 0) goto Err;
    950 	if(nfs3wccpack(a, ea, &a, &x->wcc) < 0) goto Err;
    951 	*pa = a;
    952 	return 0;
    953 Err:
    954 	*pa = ea;
    955 	return -1;
    956 }
    957 int
    958 nfs3rsetattrunpack(uchar *a, uchar *ea, uchar **pa, Nfs3RSetattr *x)
    959 {
    960 	int i;
    961 
    962 	if(sunenumunpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
    963 	if(nfs3wccunpack(a, ea, &a, &x->wcc) < 0) goto Err;
    964 	*pa = a;
    965 	return 0;
    966 Err:
    967 	*pa = ea;
    968 	return -1;
    969 }
    970 void
    971 nfs3tlookupprint(Fmt *fmt, Nfs3TLookup *x)
    972 {
    973 	fmtprint(fmt, "%s\n", "Nfs3TLookup");
    974 	fmtprint(fmt, "\t%s=", "handle");
    975 	nfs3handleprint(fmt, &x->handle);
    976 	fmtprint(fmt, "\n");
    977 	fmtprint(fmt, "\t%s=", "name");
    978 	fmtprint(fmt, "\"%s\"", x->name);
    979 	fmtprint(fmt, "\n");
    980 }
    981 uint
    982 nfs3tlookupsize(Nfs3TLookup *x)
    983 {
    984 	uint a;
    985 	USED(x);
    986 	a = 0 + nfs3handlesize(&x->handle) + sunstringsize(x->name);
    987 	return a;
    988 }
    989 int
    990 nfs3tlookuppack(uchar *a, uchar *ea, uchar **pa, Nfs3TLookup *x)
    991 {
    992 	if(nfs3handlepack(a, ea, &a, &x->handle) < 0) goto Err;
    993 	if(sunstringpack(a, ea, &a, &x->name, -1) < 0) goto Err;
    994 	*pa = a;
    995 	return 0;
    996 Err:
    997 	*pa = ea;
    998 	return -1;
    999 }
   1000 int
   1001 nfs3tlookupunpack(uchar *a, uchar *ea, uchar **pa, Nfs3TLookup *x)
   1002 {
   1003 	if(nfs3handleunpack(a, ea, &a, &x->handle) < 0) goto Err;
   1004 	if(sunstringunpack(a, ea, &a, &x->name, -1) < 0) goto Err;
   1005 	*pa = a;
   1006 	return 0;
   1007 Err:
   1008 	*pa = ea;
   1009 	return -1;
   1010 }
   1011 void
   1012 nfs3rlookupprint(Fmt *fmt, Nfs3RLookup *x)
   1013 {
   1014 	fmtprint(fmt, "%s\n", "Nfs3RLookup");
   1015 	fmtprint(fmt, "\t%s=", "status");
   1016 	fmtprint(fmt, "%s", nfs3statusstr(x->status));
   1017 	fmtprint(fmt, "\n");
   1018 	switch(x->status){
   1019 	case Nfs3Ok:
   1020 		fmtprint(fmt, "\t%s=", "handle");
   1021 		nfs3handleprint(fmt, &x->handle);
   1022 		fmtprint(fmt, "\n");
   1023 		fmtprint(fmt, "\t%s=", "haveAttr");
   1024 		fmtprint(fmt, "%d", x->haveAttr);
   1025 		fmtprint(fmt, "\n");
   1026 		switch(x->haveAttr){
   1027 		case 1:
   1028 			fmtprint(fmt, "\t%s=", "attr");
   1029 			nfs3attrprint(fmt, &x->attr);
   1030 			fmtprint(fmt, "\n");
   1031 			break;
   1032 		}
   1033 		break;
   1034 	}
   1035 	fmtprint(fmt, "\t%s=", "haveDirAttr");
   1036 	fmtprint(fmt, "%d", x->haveDirAttr);
   1037 	fmtprint(fmt, "\n");
   1038 	switch(x->haveDirAttr){
   1039 	case 1:
   1040 		fmtprint(fmt, "\t%s=", "dirAttr");
   1041 		nfs3attrprint(fmt, &x->dirAttr);
   1042 		fmtprint(fmt, "\n");
   1043 		break;
   1044 	}
   1045 }
   1046 uint
   1047 nfs3rlookupsize(Nfs3RLookup *x)
   1048 {
   1049 	uint a;
   1050 	USED(x);
   1051 	a = 0 + 4;
   1052 	switch(x->status){
   1053 	case Nfs3Ok:
   1054 		a = a + nfs3handlesize(&x->handle) + 4;
   1055 		switch(x->haveAttr){
   1056 		case 1:
   1057 			a = a + nfs3attrsize(&x->attr);
   1058 			break;
   1059 		}
   1060 			break;
   1061 	}
   1062 	a = a + 4;
   1063 	switch(x->haveDirAttr){
   1064 	case 1:
   1065 		a = a + nfs3attrsize(&x->dirAttr);
   1066 		break;
   1067 	}
   1068 	return a;
   1069 }
   1070 int
   1071 nfs3rlookuppack(uchar *a, uchar *ea, uchar **pa, Nfs3RLookup *x)
   1072 {
   1073 	int i;
   1074 
   1075 	if(i=x->status, sunenumpack(a, ea, &a, &i) < 0) goto Err;
   1076 	switch(x->status){
   1077 	case Nfs3Ok:
   1078 		if(nfs3handlepack(a, ea, &a, &x->handle) < 0) goto Err;
   1079 		if(sunuint1pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
   1080 		switch(x->haveAttr){
   1081 		case 1:
   1082 			if(nfs3attrpack(a, ea, &a, &x->attr) < 0) goto Err;
   1083 			break;
   1084 		}
   1085 		break;
   1086 	}
   1087 	if(sunuint1pack(a, ea, &a, &x->haveDirAttr) < 0) goto Err;
   1088 	switch(x->haveDirAttr){
   1089 	case 1:
   1090 		if(nfs3attrpack(a, ea, &a, &x->dirAttr) < 0) goto Err;
   1091 		break;
   1092 	}
   1093 	*pa = a;
   1094 	return 0;
   1095 Err:
   1096 	*pa = ea;
   1097 	return -1;
   1098 }
   1099 int
   1100 nfs3rlookupunpack(uchar *a, uchar *ea, uchar **pa, Nfs3RLookup *x)
   1101 {
   1102 	int i;
   1103 
   1104 	if(sunenumunpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
   1105 	switch(x->status){
   1106 	case Nfs3Ok:
   1107 		if(nfs3handleunpack(a, ea, &a, &x->handle) < 0) goto Err;
   1108 		if(sunuint1unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
   1109 		switch(x->haveAttr){
   1110 		case 1:
   1111 			if(nfs3attrunpack(a, ea, &a, &x->attr) < 0) goto Err;
   1112 			break;
   1113 		}
   1114 		break;
   1115 	}
   1116 	if(sunuint1unpack(a, ea, &a, &x->haveDirAttr) < 0) goto Err;
   1117 	switch(x->haveDirAttr){
   1118 	case 1:
   1119 		if(nfs3attrunpack(a, ea, &a, &x->dirAttr) < 0) goto Err;
   1120 		break;
   1121 	}
   1122 	*pa = a;
   1123 	return 0;
   1124 Err:
   1125 	*pa = ea;
   1126 	return -1;
   1127 }
   1128 void
   1129 nfs3taccessprint(Fmt *fmt, Nfs3TAccess *x)
   1130 {
   1131 	fmtprint(fmt, "%s\n", "Nfs3TAccess");
   1132 	fmtprint(fmt, "\t%s=", "handle");
   1133 	nfs3handleprint(fmt, &x->handle);
   1134 	fmtprint(fmt, "\n");
   1135 	fmtprint(fmt, "\t%s=", "access");
   1136 	fmtprint(fmt, "%ud", x->access);
   1137 	fmtprint(fmt, "\n");
   1138 }
   1139 uint
   1140 nfs3taccesssize(Nfs3TAccess *x)
   1141 {
   1142 	uint a;
   1143 	USED(x);
   1144 	a = 0 + nfs3handlesize(&x->handle) + 4;
   1145 	return a;
   1146 }
   1147 int
   1148 nfs3taccesspack(uchar *a, uchar *ea, uchar **pa, Nfs3TAccess *x)
   1149 {
   1150 	if(nfs3handlepack(a, ea, &a, &x->handle) < 0) goto Err;
   1151 	if(sunuint32pack(a, ea, &a, &x->access) < 0) goto Err;
   1152 	*pa = a;
   1153 	return 0;
   1154 Err:
   1155 	*pa = ea;
   1156 	return -1;
   1157 }
   1158 int
   1159 nfs3taccessunpack(uchar *a, uchar *ea, uchar **pa, Nfs3TAccess *x)
   1160 {
   1161 	if(nfs3handleunpack(a, ea, &a, &x->handle) < 0) goto Err;
   1162 	if(sunuint32unpack(a, ea, &a, &x->access) < 0) goto Err;
   1163 	*pa = a;
   1164 	return 0;
   1165 Err:
   1166 	*pa = ea;
   1167 	return -1;
   1168 }
   1169 void
   1170 nfs3raccessprint(Fmt *fmt, Nfs3RAccess *x)
   1171 {
   1172 	fmtprint(fmt, "%s\n", "Nfs3RAccess");
   1173 	fmtprint(fmt, "\t%s=", "status");
   1174 	fmtprint(fmt, "%s", nfs3statusstr(x->status));
   1175 	fmtprint(fmt, "\n");
   1176 	fmtprint(fmt, "\t%s=", "haveAttr");
   1177 	fmtprint(fmt, "%d", x->haveAttr);
   1178 	fmtprint(fmt, "\n");
   1179 	switch(x->haveAttr){
   1180 	case 1:
   1181 		fmtprint(fmt, "\t%s=", "attr");
   1182 		nfs3attrprint(fmt, &x->attr);
   1183 		fmtprint(fmt, "\n");
   1184 		break;
   1185 	}
   1186 	switch(x->status){
   1187 	case Nfs3Ok:
   1188 		fmtprint(fmt, "\t%s=", "access");
   1189 		fmtprint(fmt, "%ud", x->access);
   1190 		fmtprint(fmt, "\n");
   1191 		break;
   1192 	}
   1193 }
   1194 uint
   1195 nfs3raccesssize(Nfs3RAccess *x)
   1196 {
   1197 	uint a;
   1198 	USED(x);
   1199 	a = 0 + 4 + 4;
   1200 	switch(x->haveAttr){
   1201 	case 1:
   1202 		a = a + nfs3attrsize(&x->attr);
   1203 		break;
   1204 	}
   1205 	switch(x->status){
   1206 	case Nfs3Ok:
   1207 		a = a + 4;
   1208 		break;
   1209 	}
   1210 	return a;
   1211 }
   1212 int
   1213 nfs3raccesspack(uchar *a, uchar *ea, uchar **pa, Nfs3RAccess *x)
   1214 {
   1215 	int i;
   1216 
   1217 	if(i=x->status, sunenumpack(a, ea, &a, &i) < 0) goto Err;
   1218 	if(sunuint1pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
   1219 	switch(x->haveAttr){
   1220 	case 1:
   1221 		if(nfs3attrpack(a, ea, &a, &x->attr) < 0) goto Err;
   1222 		break;
   1223 	}
   1224 	switch(x->status){
   1225 	case Nfs3Ok:
   1226 		if(sunuint32pack(a, ea, &a, &x->access) < 0) goto Err;
   1227 		break;
   1228 	}
   1229 	*pa = a;
   1230 	return 0;
   1231 Err:
   1232 	*pa = ea;
   1233 	return -1;
   1234 }
   1235 int
   1236 nfs3raccessunpack(uchar *a, uchar *ea, uchar **pa, Nfs3RAccess *x)
   1237 {
   1238 	int i;
   1239 
   1240 	if(sunenumunpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
   1241 	if(sunuint1unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
   1242 	switch(x->haveAttr){
   1243 	case 1:
   1244 		if(nfs3attrunpack(a, ea, &a, &x->attr) < 0) goto Err;
   1245 		break;
   1246 	}
   1247 	switch(x->status){
   1248 	case Nfs3Ok:
   1249 		if(sunuint32unpack(a, ea, &a, &x->access) < 0) goto Err;
   1250 		break;
   1251 	}
   1252 	*pa = a;
   1253 	return 0;
   1254 Err:
   1255 	*pa = ea;
   1256 	return -1;
   1257 }
   1258 void
   1259 nfs3treadlinkprint(Fmt *fmt, Nfs3TReadlink *x)
   1260 {
   1261 	fmtprint(fmt, "%s\n", "Nfs3TReadlink");
   1262 	fmtprint(fmt, "\t%s=", "handle");
   1263 	nfs3handleprint(fmt, &x->handle);
   1264 	fmtprint(fmt, "\n");
   1265 }
   1266 uint
   1267 nfs3treadlinksize(Nfs3TReadlink *x)
   1268 {
   1269 	uint a;
   1270 	USED(x);
   1271 	a = 0 + nfs3handlesize(&x->handle);
   1272 	return a;
   1273 }
   1274 int
   1275 nfs3treadlinkpack(uchar *a, uchar *ea, uchar **pa, Nfs3TReadlink *x)
   1276 {
   1277 	if(nfs3handlepack(a, ea, &a, &x->handle) < 0) goto Err;
   1278 	*pa = a;
   1279 	return 0;
   1280 Err:
   1281 	*pa = ea;
   1282 	return -1;
   1283 }
   1284 int
   1285 nfs3treadlinkunpack(uchar *a, uchar *ea, uchar **pa, Nfs3TReadlink *x)
   1286 {
   1287 	if(nfs3handleunpack(a, ea, &a, &x->handle) < 0) goto Err;
   1288 	*pa = a;
   1289 	return 0;
   1290 Err:
   1291 	*pa = ea;
   1292 	return -1;
   1293 }
   1294 void
   1295 nfs3rreadlinkprint(Fmt *fmt, Nfs3RReadlink *x)
   1296 {
   1297 	fmtprint(fmt, "%s\n", "Nfs3RReadlink");
   1298 	fmtprint(fmt, "\t%s=", "status");
   1299 	fmtprint(fmt, "%s", nfs3statusstr(x->status));
   1300 	fmtprint(fmt, "\n");
   1301 	fmtprint(fmt, "\t%s=", "haveAttr");
   1302 	fmtprint(fmt, "%d", x->haveAttr);
   1303 	fmtprint(fmt, "\n");
   1304 	switch(x->haveAttr){
   1305 	case 1:
   1306 		fmtprint(fmt, "\t%s=", "attr");
   1307 		nfs3attrprint(fmt, &x->attr);
   1308 		fmtprint(fmt, "\n");
   1309 		break;
   1310 	}
   1311 	switch(x->status){
   1312 	case Nfs3Ok:
   1313 		fmtprint(fmt, "\t%s=", "data");
   1314 		fmtprint(fmt, "\"%s\"", x->data);
   1315 		fmtprint(fmt, "\n");
   1316 		break;
   1317 	}
   1318 }
   1319 uint
   1320 nfs3rreadlinksize(Nfs3RReadlink *x)
   1321 {
   1322 	uint a;
   1323 	USED(x);
   1324 	a = 0 + 4 + 4;
   1325 	switch(x->haveAttr){
   1326 	case 1:
   1327 		a = a + nfs3attrsize(&x->attr);
   1328 		break;
   1329 	}
   1330 	switch(x->status){
   1331 	case Nfs3Ok:
   1332 		a = a + sunstringsize(x->data);
   1333 		break;
   1334 	}
   1335 	return a;
   1336 }
   1337 int
   1338 nfs3rreadlinkpack(uchar *a, uchar *ea, uchar **pa, Nfs3RReadlink *x)
   1339 {
   1340 	int i;
   1341 
   1342 	if(i=x->status, sunenumpack(a, ea, &a, &i) < 0) goto Err;
   1343 	if(sunuint1pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
   1344 	switch(x->haveAttr){
   1345 	case 1:
   1346 		if(nfs3attrpack(a, ea, &a, &x->attr) < 0) goto Err;
   1347 		break;
   1348 	}
   1349 	switch(x->status){
   1350 	case Nfs3Ok:
   1351 		if(sunstringpack(a, ea, &a, &x->data, -1) < 0) goto Err;
   1352 		break;
   1353 	}
   1354 	*pa = a;
   1355 	return 0;
   1356 Err:
   1357 	*pa = ea;
   1358 	return -1;
   1359 }
   1360 int
   1361 nfs3rreadlinkunpack(uchar *a, uchar *ea, uchar **pa, Nfs3RReadlink *x)
   1362 {
   1363 	int i;
   1364 
   1365 	if(sunenumunpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
   1366 	if(sunuint1unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
   1367 	switch(x->haveAttr){
   1368 	case 1:
   1369 		if(nfs3attrunpack(a, ea, &a, &x->attr) < 0) goto Err;
   1370 		break;
   1371 	}
   1372 	switch(x->status){
   1373 	case Nfs3Ok:
   1374 		if(sunstringunpack(a, ea, &a, &x->data, -1) < 0) goto Err;
   1375 		break;
   1376 	}
   1377 	*pa = a;
   1378 	return 0;
   1379 Err:
   1380 	*pa = ea;
   1381 	return -1;
   1382 }
   1383 void
   1384 nfs3treadprint(Fmt *fmt, Nfs3TRead *x)
   1385 {
   1386 	fmtprint(fmt, "%s\n", "Nfs3TRead");
   1387 	fmtprint(fmt, "\t%s=", "handle");
   1388 	nfs3handleprint(fmt, &x->handle);
   1389 	fmtprint(fmt, "\n");
   1390 	fmtprint(fmt, "\t%s=", "offset");
   1391 	fmtprint(fmt, "%llud", x->offset);
   1392 	fmtprint(fmt, "\n");
   1393 	fmtprint(fmt, "\t%s=", "count");
   1394 	fmtprint(fmt, "%ud", x->count);
   1395 	fmtprint(fmt, "\n");
   1396 }
   1397 uint
   1398 nfs3treadsize(Nfs3TRead *x)
   1399 {
   1400 	uint a;
   1401 	USED(x);
   1402 	a = 0 + nfs3handlesize(&x->handle) + 8 + 4;
   1403 	return a;
   1404 }
   1405 int
   1406 nfs3treadpack(uchar *a, uchar *ea, uchar **pa, Nfs3TRead *x)
   1407 {
   1408 	if(nfs3handlepack(a, ea, &a, &x->handle) < 0) goto Err;
   1409 	if(sunuint64pack(a, ea, &a, &x->offset) < 0) goto Err;
   1410 	if(sunuint32pack(a, ea, &a, &x->count) < 0) goto Err;
   1411 	*pa = a;
   1412 	return 0;
   1413 Err:
   1414 	*pa = ea;
   1415 	return -1;
   1416 }
   1417 int
   1418 nfs3treadunpack(uchar *a, uchar *ea, uchar **pa, Nfs3TRead *x)
   1419 {
   1420 	if(nfs3handleunpack(a, ea, &a, &x->handle) < 0) goto Err;
   1421 	if(sunuint64unpack(a, ea, &a, &x->offset) < 0) goto Err;
   1422 	if(sunuint32unpack(a, ea, &a, &x->count) < 0) goto Err;
   1423 	*pa = a;
   1424 	return 0;
   1425 Err:
   1426 	*pa = ea;
   1427 	return -1;
   1428 }
   1429 void
   1430 nfs3rreadprint(Fmt *fmt, Nfs3RRead *x)
   1431 {
   1432 	fmtprint(fmt, "%s\n", "Nfs3RRead");
   1433 	fmtprint(fmt, "\t%s=", "status");
   1434 	fmtprint(fmt, "%s", nfs3statusstr(x->status));
   1435 	fmtprint(fmt, "\n");
   1436 	fmtprint(fmt, "\t%s=", "haveAttr");
   1437 	fmtprint(fmt, "%d", x->haveAttr);
   1438 	fmtprint(fmt, "\n");
   1439 	switch(x->haveAttr){
   1440 	case 1:
   1441 		fmtprint(fmt, "\t%s=", "attr");
   1442 		nfs3attrprint(fmt, &x->attr);
   1443 		fmtprint(fmt, "\n");
   1444 		break;
   1445 	}
   1446 	switch(x->status){
   1447 	case Nfs3Ok:
   1448 		fmtprint(fmt, "\t%s=", "count");
   1449 		fmtprint(fmt, "%ud", x->count);
   1450 		fmtprint(fmt, "\n");
   1451 		fmtprint(fmt, "\t%s=", "eof");
   1452 		fmtprint(fmt, "%d", x->eof);
   1453 		fmtprint(fmt, "\n");
   1454 		fmtprint(fmt, "\t%s=", "data");
   1455 		if(x->ndata <= 32)
   1456 			fmtprint(fmt, "%.*H", x->ndata, x->data);
   1457 		else
   1458 			fmtprint(fmt, "%.32H...", x->data);
   1459 		fmtprint(fmt, "\n");
   1460 		break;
   1461 	}
   1462 }
   1463 uint
   1464 nfs3rreadsize(Nfs3RRead *x)
   1465 {
   1466 	uint a;
   1467 	USED(x);
   1468 	a = 0 + 4 + 4;
   1469 	switch(x->haveAttr){
   1470 	case 1:
   1471 		a = a + nfs3attrsize(&x->attr);
   1472 		break;
   1473 	}
   1474 	switch(x->status){
   1475 	case Nfs3Ok:
   1476 		a = a + 4 + 4 + sunvaropaquesize(x->ndata);
   1477 		break;
   1478 	}
   1479 	return a;
   1480 }
   1481 int
   1482 nfs3rreadpack(uchar *a, uchar *ea, uchar **pa, Nfs3RRead *x)
   1483 {
   1484 	int i;
   1485 
   1486 	if(i=x->status, sunenumpack(a, ea, &a, &i) < 0) goto Err;
   1487 	if(sunuint1pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
   1488 	switch(x->haveAttr){
   1489 	case 1:
   1490 		if(nfs3attrpack(a, ea, &a, &x->attr) < 0) goto Err;
   1491 		break;
   1492 	}
   1493 	switch(x->status){
   1494 	case Nfs3Ok:
   1495 		if(sunuint32pack(a, ea, &a, &x->count) < 0) goto Err;
   1496 		if(sunuint1pack(a, ea, &a, &x->eof) < 0) goto Err;
   1497 		if(sunvaropaquepack(a, ea, &a, &x->data, &x->ndata, x->count) < 0) goto Err;
   1498 		break;
   1499 	}
   1500 	*pa = a;
   1501 	return 0;
   1502 Err:
   1503 	*pa = ea;
   1504 	return -1;
   1505 }
   1506 int
   1507 nfs3rreadunpack(uchar *a, uchar *ea, uchar **pa, Nfs3RRead *x)
   1508 {
   1509 	int i;
   1510 
   1511 	if(sunenumunpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
   1512 	if(sunuint1unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
   1513 	switch(x->haveAttr){
   1514 	case 1:
   1515 		if(nfs3attrunpack(a, ea, &a, &x->attr) < 0) goto Err;
   1516 		break;
   1517 	}
   1518 	switch(x->status){
   1519 	case Nfs3Ok:
   1520 		if(sunuint32unpack(a, ea, &a, &x->count) < 0) goto Err;
   1521 		if(sunuint1unpack(a, ea, &a, &x->eof) < 0) goto Err;
   1522 		if(sunvaropaqueunpack(a, ea, &a, &x->data, &x->ndata, x->count) < 0) goto Err;
   1523 		break;
   1524 	}
   1525 	*pa = a;
   1526 	return 0;
   1527 Err:
   1528 	*pa = ea;
   1529 	return -1;
   1530 }
   1531 char*
   1532 nfs3syncstr(Nfs3Sync x)
   1533 {
   1534 	switch(x){
   1535 	case Nfs3SyncNone:
   1536 		return "Nfs3SyncNone";
   1537 	case Nfs3SyncData:
   1538 		return "Nfs3SyncData";
   1539 	case Nfs3SyncFile:
   1540 		return "Nfs3SyncFile";
   1541 	default:
   1542 		return "unknown";
   1543 	}
   1544 }
   1545 
   1546 void
   1547 nfs3twriteprint(Fmt *fmt, Nfs3TWrite *x)
   1548 {
   1549 	fmtprint(fmt, "%s\n", "Nfs3TWrite");
   1550 	fmtprint(fmt, "\t%s=", "file");
   1551 	nfs3handleprint(fmt, &x->handle);
   1552 	fmtprint(fmt, "\n");
   1553 	fmtprint(fmt, "\t%s=", "offset");
   1554 	fmtprint(fmt, "%llud", x->offset);
   1555 	fmtprint(fmt, "\n");
   1556 	fmtprint(fmt, "\t%s=", "count");
   1557 	fmtprint(fmt, "%ud", x->count);
   1558 	fmtprint(fmt, "\n");
   1559 	fmtprint(fmt, "\t%s=", "stable");
   1560 	fmtprint(fmt, "%s", nfs3syncstr(x->stable));
   1561 	fmtprint(fmt, "\n");
   1562 	fmtprint(fmt, "\t%s=", "data");
   1563 	if(x->ndata > 32)
   1564 		fmtprint(fmt, "%.32H... (%d)", x->data, x->ndata);
   1565 	else
   1566 		fmtprint(fmt, "%.*H", x->ndata, x->data);
   1567 	fmtprint(fmt, "\n");
   1568 }
   1569 uint
   1570 nfs3twritesize(Nfs3TWrite *x)
   1571 {
   1572 	uint a;
   1573 	USED(x);
   1574 	a = 0 + nfs3handlesize(&x->handle) + 8 + 4 + 4 + sunvaropaquesize(x->ndata);
   1575 	return a;
   1576 }
   1577 int
   1578 nfs3twritepack(uchar *a, uchar *ea, uchar **pa, Nfs3TWrite *x)
   1579 {
   1580 	int i;
   1581 
   1582 	if(nfs3handlepack(a, ea, &a, &x->handle) < 0) goto Err;
   1583 	if(sunuint64pack(a, ea, &a, &x->offset) < 0) goto Err;
   1584 	if(sunuint32pack(a, ea, &a, &x->count) < 0) goto Err;
   1585 	if(i=x->stable, sunenumpack(a, ea, &a, &i) < 0) goto Err;
   1586 	if(sunvaropaquepack(a, ea, &a, &x->data, &x->ndata, x->count) < 0) goto Err;
   1587 	*pa = a;
   1588 	return 0;
   1589 Err:
   1590 	*pa = ea;
   1591 	return -1;
   1592 }
   1593 int
   1594 nfs3twriteunpack(uchar *a, uchar *ea, uchar **pa, Nfs3TWrite *x)
   1595 {
   1596 	int i;
   1597 
   1598 	if(nfs3handleunpack(a, ea, &a, &x->handle) < 0) goto Err;
   1599 	if(sunuint64unpack(a, ea, &a, &x->offset) < 0) goto Err;
   1600 	if(sunuint32unpack(a, ea, &a, &x->count) < 0) goto Err;
   1601 	if(sunenumunpack(a, ea, &a, &i) < 0) goto Err; x->stable = i;
   1602 	if(sunvaropaqueunpack(a, ea, &a, &x->data, &x->ndata, x->count) < 0) goto Err;
   1603 	*pa = a;
   1604 	return 0;
   1605 Err:
   1606 	*pa = ea;
   1607 	return -1;
   1608 }
   1609 void
   1610 nfs3rwriteprint(Fmt *fmt, Nfs3RWrite *x)
   1611 {
   1612 	fmtprint(fmt, "%s\n", "Nfs3RWrite");
   1613 	fmtprint(fmt, "\t%s=", "status");
   1614 	fmtprint(fmt, "%s", nfs3statusstr(x->status));
   1615 	fmtprint(fmt, "\n");
   1616 	fmtprint(fmt, "\t%s=", "wcc");
   1617 	nfs3wccprint(fmt, &x->wcc);
   1618 	fmtprint(fmt, "\n");
   1619 	switch(x->status){
   1620 	case Nfs3Ok:
   1621 		fmtprint(fmt, "\t%s=", "count");
   1622 		fmtprint(fmt, "%ud", x->count);
   1623 		fmtprint(fmt, "\n");
   1624 		fmtprint(fmt, "\t%s=", "committed");
   1625 		fmtprint(fmt, "%s", nfs3syncstr(x->committed));
   1626 		fmtprint(fmt, "\n");
   1627 		fmtprint(fmt, "\t%s=", "verf");
   1628 		fmtprint(fmt, "%.*H", Nfs3WriteVerfSize, x->verf);
   1629 		fmtprint(fmt, "\n");
   1630 		break;
   1631 	}
   1632 }
   1633 uint
   1634 nfs3rwritesize(Nfs3RWrite *x)
   1635 {
   1636 	uint a;
   1637 	USED(x);
   1638 	a = 0 + 4 + nfs3wccsize(&x->wcc);
   1639 	switch(x->status){
   1640 	case Nfs3Ok:
   1641 		a = a + 4 + 4 + Nfs3WriteVerfSize;
   1642 		break;
   1643 	}
   1644 	return a;
   1645 }
   1646 int
   1647 nfs3rwritepack(uchar *a, uchar *ea, uchar **pa, Nfs3RWrite *x)
   1648 {
   1649 	int i;
   1650 
   1651 	if(i=x->status, sunenumpack(a, ea, &a, &i) < 0) goto Err;
   1652 	if(nfs3wccpack(a, ea, &a, &x->wcc) < 0) goto Err;
   1653 	switch(x->status){
   1654 	case Nfs3Ok:
   1655 		if(sunuint32pack(a, ea, &a, &x->count) < 0) goto Err;
   1656 		if(i=x->committed, sunenumpack(a, ea, &a, &i) < 0) goto Err;
   1657 		if(sunfixedopaquepack(a, ea, &a, x->verf, Nfs3WriteVerfSize) < 0) goto Err;
   1658 		break;
   1659 	}
   1660 	*pa = a;
   1661 	return 0;
   1662 Err:
   1663 	*pa = ea;
   1664 	return -1;
   1665 }
   1666 int
   1667 nfs3rwriteunpack(uchar *a, uchar *ea, uchar **pa, Nfs3RWrite *x)
   1668 {
   1669 	int i;
   1670 
   1671 	if(sunenumunpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
   1672 	if(nfs3wccunpack(a, ea, &a, &x->wcc) < 0) goto Err;
   1673 	switch(x->status){
   1674 	case Nfs3Ok:
   1675 		if(sunuint32unpack(a, ea, &a, &x->count) < 0) goto Err;
   1676 		if(sunenumunpack(a, ea, &a, &i) < 0) goto Err; x->committed = i;
   1677 		if(sunfixedopaqueunpack(a, ea, &a, x->verf, Nfs3WriteVerfSize) < 0) goto Err;
   1678 		break;
   1679 	}
   1680 	*pa = a;
   1681 	return 0;
   1682 Err:
   1683 	*pa = ea;
   1684 	return -1;
   1685 }
   1686 char*
   1687 nfs3createstr(Nfs3Create x)
   1688 {
   1689 	switch(x){
   1690 	case Nfs3CreateUnchecked:
   1691 		return "Nfs3CreateUnchecked";
   1692 	case Nfs3CreateGuarded:
   1693 		return "Nfs3CreateGuarded";
   1694 	case Nfs3CreateExclusive:
   1695 		return "Nfs3CreateExclusive";
   1696 	default:
   1697 		return "unknown";
   1698 	}
   1699 }
   1700 
   1701 void
   1702 nfs3tcreateprint(Fmt *fmt, Nfs3TCreate *x)
   1703 {
   1704 	fmtprint(fmt, "%s\n", "Nfs3TCreate");
   1705 	fmtprint(fmt, "\t%s=", "handle");
   1706 	nfs3handleprint(fmt, &x->handle);
   1707 	fmtprint(fmt, "\n");
   1708 	fmtprint(fmt, "\t%s=", "name");
   1709 	fmtprint(fmt, "\"%s\"", x->name);
   1710 	fmtprint(fmt, "\n");
   1711 	fmtprint(fmt, "\t%s=", "mode");
   1712 	fmtprint(fmt, "%s", nfs3createstr(x->mode));
   1713 	fmtprint(fmt, "\n");
   1714 	switch(x->mode){
   1715 	case Nfs3CreateUnchecked:
   1716 	case Nfs3CreateGuarded:
   1717 		fmtprint(fmt, "\t%s=", "attr");
   1718 		nfs3setattrprint(fmt, &x->attr);
   1719 		fmtprint(fmt, "\n");
   1720 		break;
   1721 	case Nfs3CreateExclusive:
   1722 		fmtprint(fmt, "\t%s=", "verf");
   1723 		fmtprint(fmt, "%.*H", Nfs3CreateVerfSize, x->verf);
   1724 		fmtprint(fmt, "\n");
   1725 		break;
   1726 	}
   1727 }
   1728 uint
   1729 nfs3tcreatesize(Nfs3TCreate *x)
   1730 {
   1731 	uint a;
   1732 	USED(x);
   1733 	a = 0 + nfs3handlesize(&x->handle) + sunstringsize(x->name) + 4;
   1734 	switch(x->mode){
   1735 	case Nfs3CreateUnchecked:
   1736 	case Nfs3CreateGuarded:
   1737 		a = a + nfs3setattrsize(&x->attr);
   1738 		break;
   1739 	case Nfs3CreateExclusive:
   1740 		a = a + Nfs3CreateVerfSize;
   1741 		break;
   1742 	}
   1743 	return a;
   1744 }
   1745 int
   1746 nfs3tcreatepack(uchar *a, uchar *ea, uchar **pa, Nfs3TCreate *x)
   1747 {
   1748 	int i;
   1749 
   1750 	if(nfs3handlepack(a, ea, &a, &x->handle) < 0) goto Err;
   1751 	if(sunstringpack(a, ea, &a, &x->name, -1) < 0) goto Err;
   1752 	if(i=x->mode, sunenumpack(a, ea, &a, &i) < 0) goto Err;
   1753 	switch(x->mode){
   1754 	case Nfs3CreateUnchecked:
   1755 	case Nfs3CreateGuarded:
   1756 		if(nfs3setattrpack(a, ea, &a, &x->attr) < 0) goto Err;
   1757 		break;
   1758 	case Nfs3CreateExclusive:
   1759 		if(sunfixedopaquepack(a, ea, &a, x->verf, Nfs3CreateVerfSize) < 0) goto Err;
   1760 		break;
   1761 	}
   1762 	*pa = a;
   1763 	return 0;
   1764 Err:
   1765 	*pa = ea;
   1766 	return -1;
   1767 }
   1768 int
   1769 nfs3tcreateunpack(uchar *a, uchar *ea, uchar **pa, Nfs3TCreate *x)
   1770 {
   1771 	int i;
   1772 
   1773 	if(nfs3handleunpack(a, ea, &a, &x->handle) < 0) goto Err;
   1774 	if(sunstringunpack(a, ea, &a, &x->name, -1) < 0) goto Err;
   1775 	if(sunenumunpack(a, ea, &a, &i) < 0) goto Err; x->mode = i;
   1776 	switch(x->mode){
   1777 	case Nfs3CreateUnchecked:
   1778 	case Nfs3CreateGuarded:
   1779 		if(nfs3setattrunpack(a, ea, &a, &x->attr) < 0) goto Err;
   1780 		break;
   1781 	case Nfs3CreateExclusive:
   1782 		if(sunfixedopaqueunpack(a, ea, &a, x->verf, Nfs3CreateVerfSize) < 0) goto Err;
   1783 		break;
   1784 	}
   1785 	*pa = a;
   1786 	return 0;
   1787 Err:
   1788 	*pa = ea;
   1789 	return -1;
   1790 }
   1791 void
   1792 nfs3rcreateprint(Fmt *fmt, Nfs3RCreate *x)
   1793 {
   1794 	fmtprint(fmt, "%s\n", "Nfs3RCreate");
   1795 	fmtprint(fmt, "\t%s=", "status");
   1796 	fmtprint(fmt, "%s", nfs3statusstr(x->status));
   1797 	fmtprint(fmt, "\n");
   1798 	switch(x->status){
   1799 	case Nfs3Ok:
   1800 		fmtprint(fmt, "\t%s=", "haveHandle");
   1801 		fmtprint(fmt, "%d", x->haveHandle);
   1802 		fmtprint(fmt, "\n");
   1803 		switch(x->haveHandle){
   1804 		case 1:
   1805 			fmtprint(fmt, "\t%s=", "handle");
   1806 			nfs3handleprint(fmt, &x->handle);
   1807 			fmtprint(fmt, "\n");
   1808 			break;
   1809 		}
   1810 		fmtprint(fmt, "\t%s=", "haveAttr");
   1811 		fmtprint(fmt, "%d", x->haveAttr);
   1812 		fmtprint(fmt, "\n");
   1813 		switch(x->haveAttr){
   1814 		case 1:
   1815 			fmtprint(fmt, "\t%s=", "attr");
   1816 			nfs3attrprint(fmt, &x->attr);
   1817 			fmtprint(fmt, "\n");
   1818 			break;
   1819 		}
   1820 		break;
   1821 	}
   1822 	fmtprint(fmt, "\t%s=", "dirWcc");
   1823 	nfs3wccprint(fmt, &x->dirWcc);
   1824 	fmtprint(fmt, "\n");
   1825 }
   1826 uint
   1827 nfs3rcreatesize(Nfs3RCreate *x)
   1828 {
   1829 	uint a;
   1830 	USED(x);
   1831 	a = 0 + 4;
   1832 	switch(x->status){
   1833 	case Nfs3Ok:
   1834 		a = a + 4;
   1835 		switch(x->haveHandle){
   1836 		case 1:
   1837 			a = a + nfs3handlesize(&x->handle);
   1838 			break;
   1839 		}
   1840 		a = a + 4;
   1841 		switch(x->haveAttr){
   1842 		case 1:
   1843 			a = a + nfs3attrsize(&x->attr);
   1844 			break;
   1845 		}
   1846 			break;
   1847 	}
   1848 	a = a + nfs3wccsize(&x->dirWcc);
   1849 	return a;
   1850 }
   1851 int
   1852 nfs3rcreatepack(uchar *a, uchar *ea, uchar **pa, Nfs3RCreate *x)
   1853 {
   1854 	int i;
   1855 
   1856 	if(i=x->status, sunenumpack(a, ea, &a, &i) < 0) goto Err;
   1857 	switch(x->status){
   1858 	case Nfs3Ok:
   1859 		if(sunuint1pack(a, ea, &a, &x->haveHandle) < 0) goto Err;
   1860 		switch(x->haveHandle){
   1861 		case 1:
   1862 			if(nfs3handlepack(a, ea, &a, &x->handle) < 0) goto Err;
   1863 			break;
   1864 		}
   1865 		if(sunuint1pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
   1866 		switch(x->haveAttr){
   1867 		case 1:
   1868 			if(nfs3attrpack(a, ea, &a, &x->attr) < 0) goto Err;
   1869 			break;
   1870 		}
   1871 		break;
   1872 	}
   1873 	if(nfs3wccpack(a, ea, &a, &x->dirWcc) < 0) goto Err;
   1874 	*pa = a;
   1875 	return 0;
   1876 Err:
   1877 	*pa = ea;
   1878 	return -1;
   1879 }
   1880 int
   1881 nfs3rcreateunpack(uchar *a, uchar *ea, uchar **pa, Nfs3RCreate *x)
   1882 {
   1883 	int i;
   1884 
   1885 	if(sunenumunpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
   1886 	switch(x->status){
   1887 	case Nfs3Ok:
   1888 		if(sunuint1unpack(a, ea, &a, &x->haveHandle) < 0) goto Err;
   1889 		switch(x->haveHandle){
   1890 		case 1:
   1891 			if(nfs3handleunpack(a, ea, &a, &x->handle) < 0) goto Err;
   1892 			break;
   1893 		}
   1894 		if(sunuint1unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
   1895 		switch(x->haveAttr){
   1896 		case 1:
   1897 			if(nfs3attrunpack(a, ea, &a, &x->attr) < 0) goto Err;
   1898 			break;
   1899 		}
   1900 		break;
   1901 	}
   1902 	if(nfs3wccunpack(a, ea, &a, &x->dirWcc) < 0) goto Err;
   1903 	*pa = a;
   1904 	return 0;
   1905 Err:
   1906 	*pa = ea;
   1907 	return -1;
   1908 }
   1909 void
   1910 nfs3tmkdirprint(Fmt *fmt, Nfs3TMkdir *x)
   1911 {
   1912 	fmtprint(fmt, "%s\n", "Nfs3TMkdir");
   1913 	fmtprint(fmt, "\t%s=", "handle");
   1914 	nfs3handleprint(fmt, &x->handle);
   1915 	fmtprint(fmt, "\n");
   1916 	fmtprint(fmt, "\t%s=", "name");
   1917 	fmtprint(fmt, "\"%s\"", x->name);
   1918 	fmtprint(fmt, "\n");
   1919 	fmtprint(fmt, "\t%s=", "attr");
   1920 	nfs3setattrprint(fmt, &x->attr);
   1921 	fmtprint(fmt, "\n");
   1922 }
   1923 uint
   1924 nfs3tmkdirsize(Nfs3TMkdir *x)
   1925 {
   1926 	uint a;
   1927 	USED(x);
   1928 	a = 0 + nfs3handlesize(&x->handle) + sunstringsize(x->name) + nfs3setattrsize(&x->attr);
   1929 	return a;
   1930 }
   1931 int
   1932 nfs3tmkdirpack(uchar *a, uchar *ea, uchar **pa, Nfs3TMkdir *x)
   1933 {
   1934 	if(nfs3handlepack(a, ea, &a, &x->handle) < 0) goto Err;
   1935 	if(sunstringpack(a, ea, &a, &x->name, -1) < 0) goto Err;
   1936 	if(nfs3setattrpack(a, ea, &a, &x->attr) < 0) goto Err;
   1937 	*pa = a;
   1938 	return 0;
   1939 Err:
   1940 	*pa = ea;
   1941 	return -1;
   1942 }
   1943 int
   1944 nfs3tmkdirunpack(uchar *a, uchar *ea, uchar **pa, Nfs3TMkdir *x)
   1945 {
   1946 	if(nfs3handleunpack(a, ea, &a, &x->handle) < 0) goto Err;
   1947 	if(sunstringunpack(a, ea, &a, &x->name, -1) < 0) goto Err;
   1948 	if(nfs3setattrunpack(a, ea, &a, &x->attr) < 0) goto Err;
   1949 	*pa = a;
   1950 	return 0;
   1951 Err:
   1952 	*pa = ea;
   1953 	return -1;
   1954 }
   1955 void
   1956 nfs3rmkdirprint(Fmt *fmt, Nfs3RMkdir *x)
   1957 {
   1958 	fmtprint(fmt, "%s\n", "Nfs3RMkdir");
   1959 	fmtprint(fmt, "\t%s=", "status");
   1960 	fmtprint(fmt, "%s", nfs3statusstr(x->status));
   1961 	fmtprint(fmt, "\n");
   1962 	switch(x->status){
   1963 	case Nfs3Ok:
   1964 		fmtprint(fmt, "\t%s=", "haveHandle");
   1965 		fmtprint(fmt, "%d", x->haveHandle);
   1966 		fmtprint(fmt, "\n");
   1967 		switch(x->haveHandle){
   1968 		case 1:
   1969 			fmtprint(fmt, "\t%s=", "handle");
   1970 			nfs3handleprint(fmt, &x->handle);
   1971 			fmtprint(fmt, "\n");
   1972 			break;
   1973 		}
   1974 		fmtprint(fmt, "\t%s=", "haveAttr");
   1975 		fmtprint(fmt, "%d", x->haveAttr);
   1976 		fmtprint(fmt, "\n");
   1977 		switch(x->haveAttr){
   1978 		case 1:
   1979 			fmtprint(fmt, "\t%s=", "attr");
   1980 			nfs3attrprint(fmt, &x->attr);
   1981 			fmtprint(fmt, "\n");
   1982 			break;
   1983 		}
   1984 		break;
   1985 	}
   1986 	fmtprint(fmt, "\t%s=", "dirWcc");
   1987 	nfs3wccprint(fmt, &x->dirWcc);
   1988 	fmtprint(fmt, "\n");
   1989 }
   1990 uint
   1991 nfs3rmkdirsize(Nfs3RMkdir *x)
   1992 {
   1993 	uint a;
   1994 	USED(x);
   1995 	a = 0 + 4;
   1996 	switch(x->status){
   1997 	case Nfs3Ok:
   1998 		a = a + 4;
   1999 		switch(x->haveHandle){
   2000 		case 1:
   2001 			a = a + nfs3handlesize(&x->handle);
   2002 			break;
   2003 		}
   2004 		a = a + 4;
   2005 		switch(x->haveAttr){
   2006 		case 1:
   2007 			a = a + nfs3attrsize(&x->attr);
   2008 			break;
   2009 		}
   2010 			break;
   2011 	}
   2012 	a = a + nfs3wccsize(&x->dirWcc);
   2013 	return a;
   2014 }
   2015 int
   2016 nfs3rmkdirpack(uchar *a, uchar *ea, uchar **pa, Nfs3RMkdir *x)
   2017 {
   2018 	int i;
   2019 
   2020 	if(i=x->status, sunenumpack(a, ea, &a, &i) < 0) goto Err;
   2021 	switch(x->status){
   2022 	case Nfs3Ok:
   2023 		if(sunuint1pack(a, ea, &a, &x->haveHandle) < 0) goto Err;
   2024 		switch(x->haveHandle){
   2025 		case 1:
   2026 			if(nfs3handlepack(a, ea, &a, &x->handle) < 0) goto Err;
   2027 			break;
   2028 		}
   2029 		if(sunuint1pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
   2030 		switch(x->haveAttr){
   2031 		case 1:
   2032 			if(nfs3attrpack(a, ea, &a, &x->attr) < 0) goto Err;
   2033 			break;
   2034 		}
   2035 		break;
   2036 	}
   2037 	if(nfs3wccpack(a, ea, &a, &x->dirWcc) < 0) goto Err;
   2038 	*pa = a;
   2039 	return 0;
   2040 Err:
   2041 	*pa = ea;
   2042 	return -1;
   2043 }
   2044 int
   2045 nfs3rmkdirunpack(uchar *a, uchar *ea, uchar **pa, Nfs3RMkdir *x)
   2046 {
   2047 	int i;
   2048 
   2049 	if(sunenumunpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
   2050 	switch(x->status){
   2051 	case Nfs3Ok:
   2052 		if(sunuint1unpack(a, ea, &a, &x->haveHandle) < 0) goto Err;
   2053 		switch(x->haveHandle){
   2054 		case 1:
   2055 			if(nfs3handleunpack(a, ea, &a, &x->handle) < 0) goto Err;
   2056 			break;
   2057 		}
   2058 		if(sunuint1unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
   2059 		switch(x->haveAttr){
   2060 		case 1:
   2061 			if(nfs3attrunpack(a, ea, &a, &x->attr) < 0) goto Err;
   2062 			break;
   2063 		}
   2064 		break;
   2065 	}
   2066 	if(nfs3wccunpack(a, ea, &a, &x->dirWcc) < 0) goto Err;
   2067 	*pa = a;
   2068 	return 0;
   2069 Err:
   2070 	*pa = ea;
   2071 	return -1;
   2072 }
   2073 void
   2074 nfs3tsymlinkprint(Fmt *fmt, Nfs3TSymlink *x)
   2075 {
   2076 	fmtprint(fmt, "%s\n", "Nfs3TSymlink");
   2077 	fmtprint(fmt, "\t%s=", "handle");
   2078 	nfs3handleprint(fmt, &x->handle);
   2079 	fmtprint(fmt, "\n");
   2080 	fmtprint(fmt, "\t%s=", "name");
   2081 	fmtprint(fmt, "\"%s\"", x->name);
   2082 	fmtprint(fmt, "\n");
   2083 	fmtprint(fmt, "\t%s=", "attr");
   2084 	nfs3setattrprint(fmt, &x->attr);
   2085 	fmtprint(fmt, "\n");
   2086 	fmtprint(fmt, "\t%s=", "data");
   2087 	fmtprint(fmt, "\"%s\"", x->data);
   2088 	fmtprint(fmt, "\n");
   2089 }
   2090 uint
   2091 nfs3tsymlinksize(Nfs3TSymlink *x)
   2092 {
   2093 	uint a;
   2094 	USED(x);
   2095 	a = 0 + nfs3handlesize(&x->handle) + sunstringsize(x->name) + nfs3setattrsize(&x->attr) + sunstringsize(x->data);
   2096 	return a;
   2097 }
   2098 int
   2099 nfs3tsymlinkpack(uchar *a, uchar *ea, uchar **pa, Nfs3TSymlink *x)
   2100 {
   2101 	if(nfs3handlepack(a, ea, &a, &x->handle) < 0) goto Err;
   2102 	if(sunstringpack(a, ea, &a, &x->name, -1) < 0) goto Err;
   2103 	if(nfs3setattrpack(a, ea, &a, &x->attr) < 0) goto Err;
   2104 	if(sunstringpack(a, ea, &a, &x->data, -1) < 0) goto Err;
   2105 	*pa = a;
   2106 	return 0;
   2107 Err:
   2108 	*pa = ea;
   2109 	return -1;
   2110 }
   2111 int
   2112 nfs3tsymlinkunpack(uchar *a, uchar *ea, uchar **pa, Nfs3TSymlink *x)
   2113 {
   2114 	if(nfs3handleunpack(a, ea, &a, &x->handle) < 0) goto Err;
   2115 	if(sunstringunpack(a, ea, &a, &x->name, -1) < 0) goto Err;
   2116 	if(nfs3setattrunpack(a, ea, &a, &x->attr) < 0) goto Err;
   2117 	if(sunstringunpack(a, ea, &a, &x->data, -1) < 0) goto Err;
   2118 	*pa = a;
   2119 	return 0;
   2120 Err:
   2121 	*pa = ea;
   2122 	return -1;
   2123 }
   2124 void
   2125 nfs3rsymlinkprint(Fmt *fmt, Nfs3RSymlink *x)
   2126 {
   2127 	fmtprint(fmt, "%s\n", "Nfs3RSymlink");
   2128 	fmtprint(fmt, "\t%s=", "status");
   2129 	fmtprint(fmt, "%s", nfs3statusstr(x->status));
   2130 	fmtprint(fmt, "\n");
   2131 	switch(x->status){
   2132 	case Nfs3Ok:
   2133 		fmtprint(fmt, "\t%s=", "haveHandle");
   2134 		fmtprint(fmt, "%d", x->haveHandle);
   2135 		fmtprint(fmt, "\n");
   2136 		switch(x->haveHandle){
   2137 		case 1:
   2138 			fmtprint(fmt, "\t%s=", "handle");
   2139 			nfs3handleprint(fmt, &x->handle);
   2140 			fmtprint(fmt, "\n");
   2141 			break;
   2142 		}
   2143 		fmtprint(fmt, "\t%s=", "haveAttr");
   2144 		fmtprint(fmt, "%d", x->haveAttr);
   2145 		fmtprint(fmt, "\n");
   2146 		switch(x->haveAttr){
   2147 		case 1:
   2148 			fmtprint(fmt, "\t%s=", "attr");
   2149 			nfs3attrprint(fmt, &x->attr);
   2150 			fmtprint(fmt, "\n");
   2151 			break;
   2152 		}
   2153 		break;
   2154 	}
   2155 	fmtprint(fmt, "\t%s=", "dirWcc");
   2156 	nfs3wccprint(fmt, &x->dirWcc);
   2157 	fmtprint(fmt, "\n");
   2158 }
   2159 uint
   2160 nfs3rsymlinksize(Nfs3RSymlink *x)
   2161 {
   2162 	uint a;
   2163 	USED(x);
   2164 	a = 0 + 4;
   2165 	switch(x->status){
   2166 	case Nfs3Ok:
   2167 		a = a + 4;
   2168 		switch(x->haveHandle){
   2169 		case 1:
   2170 			a = a + nfs3handlesize(&x->handle);
   2171 			break;
   2172 		}
   2173 		a = a + 4;
   2174 		switch(x->haveAttr){
   2175 		case 1:
   2176 			a = a + nfs3attrsize(&x->attr);
   2177 			break;
   2178 		}
   2179 			break;
   2180 	}
   2181 	a = a + nfs3wccsize(&x->dirWcc);
   2182 	return a;
   2183 }
   2184 int
   2185 nfs3rsymlinkpack(uchar *a, uchar *ea, uchar **pa, Nfs3RSymlink *x)
   2186 {
   2187 	int i;
   2188 
   2189 	if(i=x->status, sunenumpack(a, ea, &a, &i) < 0) goto Err;
   2190 	switch(x->status){
   2191 	case Nfs3Ok:
   2192 		if(sunuint1pack(a, ea, &a, &x->haveHandle) < 0) goto Err;
   2193 		switch(x->haveHandle){
   2194 		case 1:
   2195 			if(nfs3handlepack(a, ea, &a, &x->handle) < 0) goto Err;
   2196 			break;
   2197 		}
   2198 		if(sunuint1pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
   2199 		switch(x->haveAttr){
   2200 		case 1:
   2201 			if(nfs3attrpack(a, ea, &a, &x->attr) < 0) goto Err;
   2202 			break;
   2203 		}
   2204 		break;
   2205 	}
   2206 	if(nfs3wccpack(a, ea, &a, &x->dirWcc) < 0) goto Err;
   2207 	*pa = a;
   2208 	return 0;
   2209 Err:
   2210 	*pa = ea;
   2211 	return -1;
   2212 }
   2213 int
   2214 nfs3rsymlinkunpack(uchar *a, uchar *ea, uchar **pa, Nfs3RSymlink *x)
   2215 {
   2216 	int i;
   2217 
   2218 	if(sunenumunpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
   2219 	switch(x->status){
   2220 	case Nfs3Ok:
   2221 		if(sunuint1unpack(a, ea, &a, &x->haveHandle) < 0) goto Err;
   2222 		switch(x->haveHandle){
   2223 		case 1:
   2224 			if(nfs3handleunpack(a, ea, &a, &x->handle) < 0) goto Err;
   2225 			break;
   2226 		}
   2227 		if(sunuint1unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
   2228 		switch(x->haveAttr){
   2229 		case 1:
   2230 			if(nfs3attrunpack(a, ea, &a, &x->attr) < 0) goto Err;
   2231 			break;
   2232 		}
   2233 		break;
   2234 	}
   2235 	if(nfs3wccunpack(a, ea, &a, &x->dirWcc) < 0) goto Err;
   2236 	*pa = a;
   2237 	return 0;
   2238 Err:
   2239 	*pa = ea;
   2240 	return -1;
   2241 }
   2242 void
   2243 nfs3tmknodprint(Fmt *fmt, Nfs3TMknod *x)
   2244 {
   2245 	fmtprint(fmt, "%s\n", "Nfs3TMknod");
   2246 	fmtprint(fmt, "\t%s=", "handle");
   2247 	nfs3handleprint(fmt, &x->handle);
   2248 	fmtprint(fmt, "\n");
   2249 	fmtprint(fmt, "\t%s=", "name");
   2250 	fmtprint(fmt, "\"%s\"", x->name);
   2251 	fmtprint(fmt, "\n");
   2252 	fmtprint(fmt, "\t%s=", "type");
   2253 	fmtprint(fmt, "%s", nfs3filetypestr(x->type));
   2254 	fmtprint(fmt, "\n");
   2255 	switch(x->type){
   2256 	case Nfs3FileChar:
   2257 	case Nfs3FileBlock:
   2258 		fmtprint(fmt, "\t%s=", "attr");
   2259 		nfs3setattrprint(fmt, &x->attr);
   2260 		fmtprint(fmt, "\n");
   2261 		fmtprint(fmt, "\t%s=", "major");
   2262 		fmtprint(fmt, "%ud", x->major);
   2263 		fmtprint(fmt, "\n");
   2264 		fmtprint(fmt, "\t%s=", "minor");
   2265 		fmtprint(fmt, "%ud", x->minor);
   2266 		fmtprint(fmt, "\n");
   2267 		break;
   2268 	case Nfs3FileSocket:
   2269 	case Nfs3FileFifo:
   2270 		fmtprint(fmt, "\t%s=", "attr");
   2271 		nfs3setattrprint(fmt, &x->attr);
   2272 		fmtprint(fmt, "\n");
   2273 		break;
   2274 	}
   2275 }
   2276 uint
   2277 nfs3tmknodsize(Nfs3TMknod *x)
   2278 {
   2279 	uint a;
   2280 	USED(x);
   2281 	a = 0 + nfs3handlesize(&x->handle) + sunstringsize(x->name) + 4;
   2282 	switch(x->type){
   2283 	case Nfs3FileChar:
   2284 	case Nfs3FileBlock:
   2285 		a = a + nfs3setattrsize(&x->attr) + 4 + 4;
   2286 		break;
   2287 	case Nfs3FileSocket:
   2288 	case Nfs3FileFifo:
   2289 		a = a + nfs3setattrsize(&x->attr);
   2290 		break;
   2291 	}
   2292 	return a;
   2293 }
   2294 int
   2295 nfs3tmknodpack(uchar *a, uchar *ea, uchar **pa, Nfs3TMknod *x)
   2296 {
   2297 	int i;
   2298 
   2299 	if(nfs3handlepack(a, ea, &a, &x->handle) < 0) goto Err;
   2300 	if(sunstringpack(a, ea, &a, &x->name, -1) < 0) goto Err;
   2301 	if(i=x->type, sunenumpack(a, ea, &a, &i) < 0) goto Err;
   2302 	switch(x->type){
   2303 	case Nfs3FileChar:
   2304 	case Nfs3FileBlock:
   2305 		if(nfs3setattrpack(a, ea, &a, &x->attr) < 0) goto Err;
   2306 		if(sunuint32pack(a, ea, &a, &x->major) < 0) goto Err;
   2307 		if(sunuint32pack(a, ea, &a, &x->minor) < 0) goto Err;
   2308 		break;
   2309 	case Nfs3FileSocket:
   2310 	case Nfs3FileFifo:
   2311 		if(nfs3setattrpack(a, ea, &a, &x->attr) < 0) goto Err;
   2312 		break;
   2313 	}
   2314 	*pa = a;
   2315 	return 0;
   2316 Err:
   2317 	*pa = ea;
   2318 	return -1;
   2319 }
   2320 int
   2321 nfs3tmknodunpack(uchar *a, uchar *ea, uchar **pa, Nfs3TMknod *x)
   2322 {
   2323 	int i;
   2324 
   2325 	if(nfs3handleunpack(a, ea, &a, &x->handle) < 0) goto Err;
   2326 	if(sunstringunpack(a, ea, &a, &x->name, -1) < 0) goto Err;
   2327 	if(sunenumunpack(a, ea, &a, &i) < 0) goto Err; x->type = i;
   2328 	switch(x->type){
   2329 	case Nfs3FileChar:
   2330 	case Nfs3FileBlock:
   2331 		if(nfs3setattrunpack(a, ea, &a, &x->attr) < 0) goto Err;
   2332 		if(sunuint32unpack(a, ea, &a, &x->major) < 0) goto Err;
   2333 		if(sunuint32unpack(a, ea, &a, &x->minor) < 0) goto Err;
   2334 		break;
   2335 	case Nfs3FileSocket:
   2336 	case Nfs3FileFifo:
   2337 		if(nfs3setattrunpack(a, ea, &a, &x->attr) < 0) goto Err;
   2338 		break;
   2339 	}
   2340 	*pa = a;
   2341 	return 0;
   2342 Err:
   2343 	*pa = ea;
   2344 	return -1;
   2345 }
   2346 void
   2347 nfs3rmknodprint(Fmt *fmt, Nfs3RMknod *x)
   2348 {
   2349 	fmtprint(fmt, "%s\n", "Nfs3RMknod");
   2350 	fmtprint(fmt, "\t%s=", "status");
   2351 	fmtprint(fmt, "%s", nfs3statusstr(x->status));
   2352 	fmtprint(fmt, "\n");
   2353 	switch(x->status){
   2354 	case Nfs3Ok:
   2355 		fmtprint(fmt, "\t%s=", "haveHandle");
   2356 		fmtprint(fmt, "%d", x->haveHandle);
   2357 		fmtprint(fmt, "\n");
   2358 		switch(x->haveHandle){
   2359 		case 1:
   2360 			fmtprint(fmt, "\t%s=", "handle");
   2361 			nfs3handleprint(fmt, &x->handle);
   2362 			fmtprint(fmt, "\n");
   2363 			break;
   2364 		}
   2365 		fmtprint(fmt, "\t%s=", "haveAttr");
   2366 		fmtprint(fmt, "%d", x->haveAttr);
   2367 		fmtprint(fmt, "\n");
   2368 		switch(x->haveAttr){
   2369 		case 1:
   2370 			fmtprint(fmt, "\t%s=", "attr");
   2371 			nfs3attrprint(fmt, &x->attr);
   2372 			fmtprint(fmt, "\n");
   2373 			break;
   2374 		}
   2375 		break;
   2376 	}
   2377 	fmtprint(fmt, "\t%s=", "dirWcc");
   2378 	nfs3wccprint(fmt, &x->dirWcc);
   2379 	fmtprint(fmt, "\n");
   2380 }
   2381 uint
   2382 nfs3rmknodsize(Nfs3RMknod *x)
   2383 {
   2384 	uint a;
   2385 	USED(x);
   2386 	a = 0 + 4;
   2387 	switch(x->status){
   2388 	case Nfs3Ok:
   2389 		a = a + 4;
   2390 		switch(x->haveHandle){
   2391 		case 1:
   2392 			a = a + nfs3handlesize(&x->handle);
   2393 			break;
   2394 		}
   2395 		a = a + 4;
   2396 		switch(x->haveAttr){
   2397 		case 1:
   2398 			a = a + nfs3attrsize(&x->attr);
   2399 			break;
   2400 		}
   2401 			break;
   2402 	}
   2403 	a = a + nfs3wccsize(&x->dirWcc);
   2404 	return a;
   2405 }
   2406 int
   2407 nfs3rmknodpack(uchar *a, uchar *ea, uchar **pa, Nfs3RMknod *x)
   2408 {
   2409 	int i;
   2410 
   2411 	if(i=x->status, sunenumpack(a, ea, &a, &i) < 0) goto Err;
   2412 	switch(x->status){
   2413 	case Nfs3Ok:
   2414 		if(sunuint1pack(a, ea, &a, &x->haveHandle) < 0) goto Err;
   2415 		switch(x->haveHandle){
   2416 		case 1:
   2417 			if(nfs3handlepack(a, ea, &a, &x->handle) < 0) goto Err;
   2418 			break;
   2419 		}
   2420 		if(sunuint1pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
   2421 		switch(x->haveAttr){
   2422 		case 1:
   2423 			if(nfs3attrpack(a, ea, &a, &x->attr) < 0) goto Err;
   2424 			break;
   2425 		}
   2426 		break;
   2427 	}
   2428 	if(nfs3wccpack(a, ea, &a, &x->dirWcc) < 0) goto Err;
   2429 	*pa = a;
   2430 	return 0;
   2431 Err:
   2432 	*pa = ea;
   2433 	return -1;
   2434 }
   2435 int
   2436 nfs3rmknodunpack(uchar *a, uchar *ea, uchar **pa, Nfs3RMknod *x)
   2437 {
   2438 	int i;
   2439 
   2440 	if(sunenumunpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
   2441 	switch(x->status){
   2442 	case Nfs3Ok:
   2443 		if(sunuint1unpack(a, ea, &a, &x->haveHandle) < 0) goto Err;
   2444 		switch(x->haveHandle){
   2445 		case 1:
   2446 			if(nfs3handleunpack(a, ea, &a, &x->handle) < 0) goto Err;
   2447 			break;
   2448 		}
   2449 		if(sunuint1unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
   2450 		switch(x->haveAttr){
   2451 		case 1:
   2452 			if(nfs3attrunpack(a, ea, &a, &x->attr) < 0) goto Err;
   2453 			break;
   2454 		}
   2455 		break;
   2456 	}
   2457 	if(nfs3wccunpack(a, ea, &a, &x->dirWcc) < 0) goto Err;
   2458 	*pa = a;
   2459 	return 0;
   2460 Err:
   2461 	*pa = ea;
   2462 	return -1;
   2463 }
   2464 void
   2465 nfs3tremoveprint(Fmt *fmt, Nfs3TRemove *x)
   2466 {
   2467 	fmtprint(fmt, "%s\n", "Nfs3TRemove");
   2468 	fmtprint(fmt, "\t%s=", "handle");
   2469 	nfs3handleprint(fmt, &x->handle);
   2470 	fmtprint(fmt, "\n");
   2471 	fmtprint(fmt, "\t%s=", "name");
   2472 	fmtprint(fmt, "\"%s\"", x->name);
   2473 	fmtprint(fmt, "\n");
   2474 }
   2475 uint
   2476 nfs3tremovesize(Nfs3TRemove *x)
   2477 {
   2478 	uint a;
   2479 	USED(x);
   2480 	a = 0 + nfs3handlesize(&x->handle) + sunstringsize(x->name);
   2481 	return a;
   2482 }
   2483 int
   2484 nfs3tremovepack(uchar *a, uchar *ea, uchar **pa, Nfs3TRemove *x)
   2485 {
   2486 	if(nfs3handlepack(a, ea, &a, &x->handle) < 0) goto Err;
   2487 	if(sunstringpack(a, ea, &a, &x->name, -1) < 0) goto Err;
   2488 	*pa = a;
   2489 	return 0;
   2490 Err:
   2491 	*pa = ea;
   2492 	return -1;
   2493 }
   2494 int
   2495 nfs3tremoveunpack(uchar *a, uchar *ea, uchar **pa, Nfs3TRemove *x)
   2496 {
   2497 	if(nfs3handleunpack(a, ea, &a, &x->handle) < 0) goto Err;
   2498 	if(sunstringunpack(a, ea, &a, &x->name, -1) < 0) goto Err;
   2499 	*pa = a;
   2500 	return 0;
   2501 Err:
   2502 	*pa = ea;
   2503 	return -1;
   2504 }
   2505 void
   2506 nfs3rremoveprint(Fmt *fmt, Nfs3RRemove *x)
   2507 {
   2508 	fmtprint(fmt, "%s\n", "Nfs3RRemove");
   2509 	fmtprint(fmt, "\t%s=", "status");
   2510 	fmtprint(fmt, "%s", nfs3statusstr(x->status));
   2511 	fmtprint(fmt, "\n");
   2512 	fmtprint(fmt, "\t%s=", "wcc");
   2513 	nfs3wccprint(fmt, &x->wcc);
   2514 	fmtprint(fmt, "\n");
   2515 }
   2516 uint
   2517 nfs3rremovesize(Nfs3RRemove *x)
   2518 {
   2519 	uint a;
   2520 	USED(x);
   2521 	a = 0 + 4 + nfs3wccsize(&x->wcc);
   2522 	return a;
   2523 }
   2524 int
   2525 nfs3rremovepack(uchar *a, uchar *ea, uchar **pa, Nfs3RRemove *x)
   2526 {
   2527 	int i;
   2528 
   2529 	if(i=x->status, sunenumpack(a, ea, &a, &i) < 0) goto Err;
   2530 	if(nfs3wccpack(a, ea, &a, &x->wcc) < 0) goto Err;
   2531 	*pa = a;
   2532 	return 0;
   2533 Err:
   2534 	*pa = ea;
   2535 	return -1;
   2536 }
   2537 int
   2538 nfs3rremoveunpack(uchar *a, uchar *ea, uchar **pa, Nfs3RRemove *x)
   2539 {
   2540 	int i;
   2541 
   2542 	if(sunenumunpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
   2543 	if(nfs3wccunpack(a, ea, &a, &x->wcc) < 0) goto Err;
   2544 	*pa = a;
   2545 	return 0;
   2546 Err:
   2547 	*pa = ea;
   2548 	return -1;
   2549 }
   2550 void
   2551 nfs3trmdirprint(Fmt *fmt, Nfs3TRmdir *x)
   2552 {
   2553 	fmtprint(fmt, "%s\n", "Nfs3TRmdir");
   2554 	fmtprint(fmt, "\t%s=", "handle");
   2555 	nfs3handleprint(fmt, &x->handle);
   2556 	fmtprint(fmt, "\n");
   2557 	fmtprint(fmt, "\t%s=", "name");
   2558 	fmtprint(fmt, "\"%s\"", x->name);
   2559 	fmtprint(fmt, "\n");
   2560 }
   2561 uint
   2562 nfs3trmdirsize(Nfs3TRmdir *x)
   2563 {
   2564 	uint a;
   2565 	USED(x);
   2566 	a = 0 + nfs3handlesize(&x->handle) + sunstringsize(x->name);
   2567 	return a;
   2568 }
   2569 int
   2570 nfs3trmdirpack(uchar *a, uchar *ea, uchar **pa, Nfs3TRmdir *x)
   2571 {
   2572 	if(nfs3handlepack(a, ea, &a, &x->handle) < 0) goto Err;
   2573 	if(sunstringpack(a, ea, &a, &x->name, -1) < 0) goto Err;
   2574 	*pa = a;
   2575 	return 0;
   2576 Err:
   2577 	*pa = ea;
   2578 	return -1;
   2579 }
   2580 int
   2581 nfs3trmdirunpack(uchar *a, uchar *ea, uchar **pa, Nfs3TRmdir *x)
   2582 {
   2583 	if(nfs3handleunpack(a, ea, &a, &x->handle) < 0) goto Err;
   2584 	if(sunstringunpack(a, ea, &a, &x->name, -1) < 0) goto Err;
   2585 	*pa = a;
   2586 	return 0;
   2587 Err:
   2588 	*pa = ea;
   2589 	return -1;
   2590 }
   2591 void
   2592 nfs3rrmdirprint(Fmt *fmt, Nfs3RRmdir *x)
   2593 {
   2594 	fmtprint(fmt, "%s\n", "Nfs3RRmdir");
   2595 	fmtprint(fmt, "\t%s=", "status");
   2596 	fmtprint(fmt, "%s", nfs3statusstr(x->status));
   2597 	fmtprint(fmt, "\n");
   2598 	fmtprint(fmt, "\t%s=", "wcc");
   2599 	nfs3wccprint(fmt, &x->wcc);
   2600 	fmtprint(fmt, "\n");
   2601 }
   2602 uint
   2603 nfs3rrmdirsize(Nfs3RRmdir *x)
   2604 {
   2605 	uint a;
   2606 	USED(x);
   2607 	a = 0 + 4 + nfs3wccsize(&x->wcc);
   2608 	return a;
   2609 }
   2610 int
   2611 nfs3rrmdirpack(uchar *a, uchar *ea, uchar **pa, Nfs3RRmdir *x)
   2612 {
   2613 	int i;
   2614 
   2615 	if(i=x->status, sunenumpack(a, ea, &a, &i) < 0) goto Err;
   2616 	if(nfs3wccpack(a, ea, &a, &x->wcc) < 0) goto Err;
   2617 	*pa = a;
   2618 	return 0;
   2619 Err:
   2620 	*pa = ea;
   2621 	return -1;
   2622 }
   2623 int
   2624 nfs3rrmdirunpack(uchar *a, uchar *ea, uchar **pa, Nfs3RRmdir *x)
   2625 {
   2626 	int i;
   2627 
   2628 	if(sunenumunpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
   2629 	if(nfs3wccunpack(a, ea, &a, &x->wcc) < 0) goto Err;
   2630 	*pa = a;
   2631 	return 0;
   2632 Err:
   2633 	*pa = ea;
   2634 	return -1;
   2635 }
   2636 void
   2637 nfs3trenameprint(Fmt *fmt, Nfs3TRename *x)
   2638 {
   2639 	fmtprint(fmt, "%s\n", "Nfs3TRename");
   2640 	fmtprint(fmt, "\t%s=", "from");
   2641 	fmtprint(fmt, "{\n");
   2642 	fmtprint(fmt, "\t\t%s=", "handle");
   2643 	nfs3handleprint(fmt, &x->from.handle);
   2644 	fmtprint(fmt, "\n");
   2645 	fmtprint(fmt, "\t\t%s=", "name");
   2646 	fmtprint(fmt, "\"%s\"", x->from.name);
   2647 	fmtprint(fmt, "\n");
   2648 	fmtprint(fmt, "\t}");
   2649 	fmtprint(fmt, "\n");
   2650 	fmtprint(fmt, "\t%s=", "to");
   2651 	fmtprint(fmt, "{\n");
   2652 	fmtprint(fmt, "\t\t%s=", "handle");
   2653 	nfs3handleprint(fmt, &x->to.handle);
   2654 	fmtprint(fmt, "\n");
   2655 	fmtprint(fmt, "\t\t%s=", "name");
   2656 	fmtprint(fmt, "\"%s\"", x->to.name);
   2657 	fmtprint(fmt, "\n");
   2658 	fmtprint(fmt, "\t}");
   2659 	fmtprint(fmt, "\n");
   2660 }
   2661 uint
   2662 nfs3trenamesize(Nfs3TRename *x)
   2663 {
   2664 	uint a;
   2665 	USED(x);
   2666 	a = 0 + nfs3handlesize(&x->from.handle) + sunstringsize(x->from.name) + nfs3handlesize(&x->to.handle) + sunstringsize(x->to.name);
   2667 	return a;
   2668 }
   2669 int
   2670 nfs3trenamepack(uchar *a, uchar *ea, uchar **pa, Nfs3TRename *x)
   2671 {
   2672 	if(nfs3handlepack(a, ea, &a, &x->from.handle) < 0) goto Err;
   2673 	if(sunstringpack(a, ea, &a, &x->from.name, -1) < 0) goto Err;
   2674 	if(nfs3handlepack(a, ea, &a, &x->to.handle) < 0) goto Err;
   2675 	if(sunstringpack(a, ea, &a, &x->to.name, -1) < 0) goto Err;
   2676 	*pa = a;
   2677 	return 0;
   2678 Err:
   2679 	*pa = ea;
   2680 	return -1;
   2681 }
   2682 int
   2683 nfs3trenameunpack(uchar *a, uchar *ea, uchar **pa, Nfs3TRename *x)
   2684 {
   2685 	if(nfs3handleunpack(a, ea, &a, &x->from.handle) < 0) goto Err;
   2686 	if(sunstringunpack(a, ea, &a, &x->from.name, -1) < 0) goto Err;
   2687 	if(nfs3handleunpack(a, ea, &a, &x->to.handle) < 0) goto Err;
   2688 	if(sunstringunpack(a, ea, &a, &x->to.name, -1) < 0) goto Err;
   2689 	*pa = a;
   2690 	return 0;
   2691 Err:
   2692 	*pa = ea;
   2693 	return -1;
   2694 }
   2695 void
   2696 nfs3rrenameprint(Fmt *fmt, Nfs3RRename *x)
   2697 {
   2698 	fmtprint(fmt, "%s\n", "Nfs3RRename");
   2699 	fmtprint(fmt, "\t%s=", "status");
   2700 	fmtprint(fmt, "%s", nfs3statusstr(x->status));
   2701 	fmtprint(fmt, "\n");
   2702 	fmtprint(fmt, "\t%s=", "fromWcc");
   2703 	nfs3wccprint(fmt, &x->fromWcc);
   2704 	fmtprint(fmt, "\n");
   2705 	fmtprint(fmt, "\t%s=", "toWcc");
   2706 	nfs3wccprint(fmt, &x->toWcc);
   2707 	fmtprint(fmt, "\n");
   2708 }
   2709 uint
   2710 nfs3rrenamesize(Nfs3RRename *x)
   2711 {
   2712 	uint a;
   2713 	USED(x);
   2714 	a = 0 + 4 + nfs3wccsize(&x->fromWcc) + nfs3wccsize(&x->toWcc);
   2715 	return a;
   2716 }
   2717 int
   2718 nfs3rrenamepack(uchar *a, uchar *ea, uchar **pa, Nfs3RRename *x)
   2719 {
   2720 	int i;
   2721 
   2722 	if(i=x->status, sunenumpack(a, ea, &a, &i) < 0) goto Err;
   2723 	if(nfs3wccpack(a, ea, &a, &x->fromWcc) < 0) goto Err;
   2724 	if(nfs3wccpack(a, ea, &a, &x->toWcc) < 0) goto Err;
   2725 	*pa = a;
   2726 	return 0;
   2727 Err:
   2728 	*pa = ea;
   2729 	return -1;
   2730 }
   2731 int
   2732 nfs3rrenameunpack(uchar *a, uchar *ea, uchar **pa, Nfs3RRename *x)
   2733 {
   2734 	int i;
   2735 
   2736 	if(sunenumunpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
   2737 	if(nfs3wccunpack(a, ea, &a, &x->fromWcc) < 0) goto Err;
   2738 	if(nfs3wccunpack(a, ea, &a, &x->toWcc) < 0) goto Err;
   2739 	*pa = a;
   2740 	return 0;
   2741 Err:
   2742 	*pa = ea;
   2743 	return -1;
   2744 }
   2745 void
   2746 nfs3tlinkprint(Fmt *fmt, Nfs3TLink *x)
   2747 {
   2748 	fmtprint(fmt, "%s\n", "Nfs3TLink");
   2749 	fmtprint(fmt, "\t%s=", "handle");
   2750 	nfs3handleprint(fmt, &x->handle);
   2751 	fmtprint(fmt, "\n");
   2752 	fmtprint(fmt, "\t%s=", "link");
   2753 	fmtprint(fmt, "{\n");
   2754 	fmtprint(fmt, "\t\t%s=", "handle");
   2755 	nfs3handleprint(fmt, &x->link.handle);
   2756 	fmtprint(fmt, "\n");
   2757 	fmtprint(fmt, "\t\t%s=", "name");
   2758 	fmtprint(fmt, "\"%s\"", x->link.name);
   2759 	fmtprint(fmt, "\n");
   2760 	fmtprint(fmt, "\t}");
   2761 	fmtprint(fmt, "\n");
   2762 }
   2763 uint
   2764 nfs3tlinksize(Nfs3TLink *x)
   2765 {
   2766 	uint a;
   2767 	USED(x);
   2768 	a = 0 + nfs3handlesize(&x->handle) + nfs3handlesize(&x->link.handle) + sunstringsize(x->link.name);
   2769 	return a;
   2770 }
   2771 int
   2772 nfs3tlinkpack(uchar *a, uchar *ea, uchar **pa, Nfs3TLink *x)
   2773 {
   2774 	if(nfs3handlepack(a, ea, &a, &x->handle) < 0) goto Err;
   2775 	if(nfs3handlepack(a, ea, &a, &x->link.handle) < 0) goto Err;
   2776 	if(sunstringpack(a, ea, &a, &x->link.name, -1) < 0) goto Err;
   2777 	*pa = a;
   2778 	return 0;
   2779 Err:
   2780 	*pa = ea;
   2781 	return -1;
   2782 }
   2783 int
   2784 nfs3tlinkunpack(uchar *a, uchar *ea, uchar **pa, Nfs3TLink *x)
   2785 {
   2786 	if(nfs3handleunpack(a, ea, &a, &x->handle) < 0) goto Err;
   2787 	if(nfs3handleunpack(a, ea, &a, &x->link.handle) < 0) goto Err;
   2788 	if(sunstringunpack(a, ea, &a, &x->link.name, -1) < 0) goto Err;
   2789 	*pa = a;
   2790 	return 0;
   2791 Err:
   2792 	*pa = ea;
   2793 	return -1;
   2794 }
   2795 void
   2796 nfs3rlinkprint(Fmt *fmt, Nfs3RLink *x)
   2797 {
   2798 	fmtprint(fmt, "%s\n", "Nfs3RLink");
   2799 	fmtprint(fmt, "\t%s=", "status");
   2800 	fmtprint(fmt, "%s", nfs3statusstr(x->status));
   2801 	fmtprint(fmt, "\n");
   2802 	fmtprint(fmt, "\t%s=", "haveAttr");
   2803 	fmtprint(fmt, "%d", x->haveAttr);
   2804 	fmtprint(fmt, "\n");
   2805 	switch(x->haveAttr){
   2806 	case 1:
   2807 		fmtprint(fmt, "\t%s=", "attr");
   2808 		nfs3attrprint(fmt, &x->attr);
   2809 		fmtprint(fmt, "\n");
   2810 		break;
   2811 	}
   2812 	fmtprint(fmt, "\t%s=", "dirWcc");
   2813 	nfs3wccprint(fmt, &x->dirWcc);
   2814 	fmtprint(fmt, "\n");
   2815 }
   2816 uint
   2817 nfs3rlinksize(Nfs3RLink *x)
   2818 {
   2819 	uint a;
   2820 	USED(x);
   2821 	a = 0 + 4 + 4;
   2822 	switch(x->haveAttr){
   2823 	case 1:
   2824 		a = a + nfs3attrsize(&x->attr);
   2825 		break;
   2826 	}
   2827 	a = a + nfs3wccsize(&x->dirWcc);
   2828 	return a;
   2829 }
   2830 int
   2831 nfs3rlinkpack(uchar *a, uchar *ea, uchar **pa, Nfs3RLink *x)
   2832 {
   2833 	int i;
   2834 
   2835 	if(i=x->status, sunenumpack(a, ea, &a, &i) < 0) goto Err;
   2836 	if(sunuint1pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
   2837 	switch(x->haveAttr){
   2838 	case 1:
   2839 		if(nfs3attrpack(a, ea, &a, &x->attr) < 0) goto Err;
   2840 		break;
   2841 	}
   2842 	if(nfs3wccpack(a, ea, &a, &x->dirWcc) < 0) goto Err;
   2843 	*pa = a;
   2844 	return 0;
   2845 Err:
   2846 	*pa = ea;
   2847 	return -1;
   2848 }
   2849 int
   2850 nfs3rlinkunpack(uchar *a, uchar *ea, uchar **pa, Nfs3RLink *x)
   2851 {
   2852 	int i;
   2853 
   2854 	if(sunenumunpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
   2855 	if(sunuint1unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
   2856 	switch(x->haveAttr){
   2857 	case 1:
   2858 		if(nfs3attrunpack(a, ea, &a, &x->attr) < 0) goto Err;
   2859 		break;
   2860 	}
   2861 	if(nfs3wccunpack(a, ea, &a, &x->dirWcc) < 0) goto Err;
   2862 	*pa = a;
   2863 	return 0;
   2864 Err:
   2865 	*pa = ea;
   2866 	return -1;
   2867 }
   2868 void
   2869 nfs3treaddirprint(Fmt *fmt, Nfs3TReadDir *x)
   2870 {
   2871 	fmtprint(fmt, "%s\n", "Nfs3TReadDir");
   2872 	fmtprint(fmt, "\t%s=", "handle");
   2873 	nfs3handleprint(fmt, &x->handle);
   2874 	fmtprint(fmt, "\n");
   2875 	fmtprint(fmt, "\t%s=", "cookie");
   2876 	fmtprint(fmt, "%llud", x->cookie);
   2877 	fmtprint(fmt, "\n");
   2878 	fmtprint(fmt, "\t%s=", "verf");
   2879 	fmtprint(fmt, "%.*H", Nfs3CookieVerfSize, x->verf);
   2880 	fmtprint(fmt, "\n");
   2881 	fmtprint(fmt, "\t%s=", "count");
   2882 	fmtprint(fmt, "%ud", x->count);
   2883 	fmtprint(fmt, "\n");
   2884 }
   2885 uint
   2886 nfs3treaddirsize(Nfs3TReadDir *x)
   2887 {
   2888 	uint a;
   2889 	USED(x);
   2890 	a = 0 + nfs3handlesize(&x->handle) + 8 + Nfs3CookieVerfSize + 4;
   2891 	return a;
   2892 }
   2893 int
   2894 nfs3treaddirpack(uchar *a, uchar *ea, uchar **pa, Nfs3TReadDir *x)
   2895 {
   2896 	if(nfs3handlepack(a, ea, &a, &x->handle) < 0) goto Err;
   2897 	if(sunuint64pack(a, ea, &a, &x->cookie) < 0) goto Err;
   2898 	if(sunfixedopaquepack(a, ea, &a, x->verf, Nfs3CookieVerfSize) < 0) goto Err;
   2899 	if(sunuint32pack(a, ea, &a, &x->count) < 0) goto Err;
   2900 	*pa = a;
   2901 	return 0;
   2902 Err:
   2903 	*pa = ea;
   2904 	return -1;
   2905 }
   2906 int
   2907 nfs3treaddirunpack(uchar *a, uchar *ea, uchar **pa, Nfs3TReadDir *x)
   2908 {
   2909 	if(nfs3handleunpack(a, ea, &a, &x->handle) < 0) goto Err;
   2910 	if(sunuint64unpack(a, ea, &a, &x->cookie) < 0) goto Err;
   2911 	if(sunfixedopaqueunpack(a, ea, &a, x->verf, Nfs3CookieVerfSize) < 0) goto Err;
   2912 	if(sunuint32unpack(a, ea, &a, &x->count) < 0) goto Err;
   2913 	*pa = a;
   2914 	return 0;
   2915 Err:
   2916 	*pa = ea;
   2917 	return -1;
   2918 }
   2919 void
   2920 nfs3entryprint(Fmt *fmt, Nfs3Entry *x)
   2921 {
   2922 	fmtprint(fmt, "%s\n", "Nfs3Entry");
   2923 	fmtprint(fmt, "\t%s=", "fileid");
   2924 	fmtprint(fmt, "%llud", x->fileid);
   2925 	fmtprint(fmt, "\n");
   2926 	fmtprint(fmt, "\t%s=", "name");
   2927 	fmtprint(fmt, "\"%s\"", x->name);
   2928 	fmtprint(fmt, "\n");
   2929 	fmtprint(fmt, "\t%s=", "cookie");
   2930 	fmtprint(fmt, "%llud", x->cookie);
   2931 	fmtprint(fmt, "\n");
   2932 }
   2933 uint
   2934 nfs3entrysize(Nfs3Entry *x)
   2935 {
   2936 	uint a;
   2937 	USED(x);
   2938 	a = 0 + 4 + 8 + sunstringsize(x->name) + 8;
   2939 	return a;
   2940 }
   2941 static int
   2942 sunstringvpack(uchar *a, uchar *ea, uchar **pa, char **s, u32int n)
   2943 {
   2944 	return sunvaropaquepack(a, ea, pa, (uchar**)(void*)s, &n, -1);
   2945 }
   2946 int
   2947 nfs3entrypack(uchar *a, uchar *ea, uchar **pa, Nfs3Entry *x)
   2948 {
   2949 	u1int one;
   2950 
   2951 	one = 1;
   2952 	if(sunuint1pack(a, ea, &a, &one) < 0) goto Err;
   2953 	if(sunuint64pack(a, ea, &a, &x->fileid) < 0) goto Err;
   2954 	if(sunstringvpack(a, ea, &a, &x->name, x->namelen) < 0) goto Err;
   2955 	if(sunuint64pack(a, ea, &a, &x->cookie) < 0) goto Err;
   2956 	*pa = a;
   2957 	return 0;
   2958 Err:
   2959 	*pa = ea;
   2960 	return -1;
   2961 }
   2962 int
   2963 nfs3entryunpack(uchar *a, uchar *ea, uchar **pa, Nfs3Entry *x)
   2964 {
   2965 	u1int one;
   2966 
   2967 	memset(x, 0, sizeof *x);
   2968 	if(sunuint1unpack(a, ea, &a, &one) < 0 || one != 1) goto Err;
   2969 	if(sunuint64unpack(a, ea, &a, &x->fileid) < 0) goto Err;
   2970 	if(sunstringunpack(a, ea, &a, &x->name, -1) < 0) goto Err;
   2971 	x->namelen = strlen(x->name);
   2972 	if(sunuint64unpack(a, ea, &a, &x->cookie) < 0) goto Err;
   2973 	*pa = a;
   2974 	return 0;
   2975 Err:
   2976 	*pa = ea;
   2977 	return -1;
   2978 }
   2979 void
   2980 nfs3rreaddirprint(Fmt *fmt, Nfs3RReadDir *x)
   2981 {
   2982 	fmtprint(fmt, "%s\n", "Nfs3RReadDir");
   2983 	fmtprint(fmt, "\t%s=", "status");
   2984 	fmtprint(fmt, "%s", nfs3statusstr(x->status));
   2985 	fmtprint(fmt, "\n");
   2986 	fmtprint(fmt, "\t%s=", "haveAttr");
   2987 	fmtprint(fmt, "%d", x->haveAttr);
   2988 	fmtprint(fmt, "\n");
   2989 	switch(x->haveAttr){
   2990 	case 1:
   2991 		fmtprint(fmt, "\t%s=", "attr");
   2992 		nfs3attrprint(fmt, &x->attr);
   2993 		fmtprint(fmt, "\n");
   2994 		break;
   2995 	}
   2996 	switch(x->status){
   2997 	case Nfs3Ok:
   2998 		fmtprint(fmt, "\t%s=", "verf");
   2999 		fmtprint(fmt, "%.*H", Nfs3CookieVerfSize, x->verf);
   3000 		fmtprint(fmt, "\n");
   3001 		fmtprint(fmt, "\t%s=%ud\n", "count", x->count);
   3002 		fmtprint(fmt, "\t%s=", "eof");
   3003 		fmtprint(fmt, "%d", x->eof);
   3004 		fmtprint(fmt, "\n");
   3005 		break;
   3006 	}
   3007 }
   3008 uint
   3009 nfs3rreaddirsize(Nfs3RReadDir *x)
   3010 {
   3011 	uint a;
   3012 	USED(x);
   3013 	a = 0 + 4 + 4;
   3014 	switch(x->haveAttr){
   3015 	case 1:
   3016 		a = a + nfs3attrsize(&x->attr);
   3017 		break;
   3018 	}
   3019 	switch(x->status){
   3020 	case Nfs3Ok:
   3021 		a = a + Nfs3CookieVerfSize;
   3022 		a += x->count;
   3023 		a += 4 + 4;
   3024 		break;
   3025 	}
   3026 	return a;
   3027 }
   3028 int
   3029 nfs3rreaddirpack(uchar *a, uchar *ea, uchar **pa, Nfs3RReadDir *x)
   3030 {
   3031 	int i;
   3032 	u1int zero;
   3033 
   3034 	if(i=x->status, sunenumpack(a, ea, &a, &i) < 0) goto Err;
   3035 	if(sunuint1pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
   3036 	switch(x->haveAttr){
   3037 	case 1:
   3038 		if(nfs3attrpack(a, ea, &a, &x->attr) < 0) goto Err;
   3039 		break;
   3040 	}
   3041 	switch(x->status){
   3042 	case Nfs3Ok:
   3043 		if(sunfixedopaquepack(a, ea, &a, x->verf, Nfs3CookieVerfSize) < 0) goto Err;
   3044 		if(sunfixedopaquepack(a, ea, &a, x->data, x->count) < 0) goto Err;
   3045 		zero = 0;
   3046 		if(sunuint1pack(a, ea, &a, &zero) < 0) goto Err;
   3047 		if(sunuint1pack(a, ea, &a, &x->eof) < 0) goto Err;
   3048 		break;
   3049 	}
   3050 	*pa = a;
   3051 	return 0;
   3052 Err:
   3053 	*pa = ea;
   3054 	return -1;
   3055 }
   3056 static int
   3057 countEntry(uchar *a, uchar *ea, uchar **pa, u32int *n)
   3058 {
   3059 	uchar *oa;
   3060 	u64int u64;
   3061 	u32int u32;
   3062 	u1int u1;
   3063 
   3064 	oa = a;
   3065 	for(;;){
   3066 		if(sunuint1unpack(a, ea, &a, &u1) < 0)
   3067 			return -1;
   3068 		if(u1 == 0)
   3069 			break;
   3070 		if(sunuint64unpack(a, ea, &a, &u64) < 0
   3071 		|| sunuint32unpack(a, ea, &a, &u32) < 0)
   3072 			return -1;
   3073 		a += (u32+3)&~3;
   3074 		if(a >= ea)
   3075 			return -1;
   3076 		if(sunuint64unpack(a, ea, &a, &u64) < 0)
   3077 			return -1;
   3078 	}
   3079 	*n = (a-4) - oa;
   3080 	*pa = a;
   3081 	return 0;
   3082 }
   3083 int
   3084 nfs3rreaddirunpack(uchar *a, uchar *ea, uchar **pa, Nfs3RReadDir *x)
   3085 {
   3086 	int i;
   3087 
   3088 	if(sunenumunpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
   3089 	if(sunuint1unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
   3090 	switch(x->haveAttr){
   3091 	case 1:
   3092 		if(nfs3attrunpack(a, ea, &a, &x->attr) < 0) goto Err;
   3093 		break;
   3094 	}
   3095 	if(x->status == Nfs3Ok){
   3096 		if(sunfixedopaqueunpack(a, ea, &a, x->verf, Nfs3CookieVerfSize) < 0) goto Err;
   3097 		x->data = a;
   3098 		if(countEntry(a, ea, &a, &x->count) < 0) goto Err;
   3099 		if(sunuint1unpack(a, ea, &a, &x->eof) < 0) goto Err;
   3100 	}
   3101 	*pa = a;
   3102 	return 0;
   3103 Err:
   3104 	*pa = ea;
   3105 	return -1;
   3106 }
   3107 void
   3108 nfs3treaddirplusprint(Fmt *fmt, Nfs3TReadDirPlus *x)
   3109 {
   3110 	fmtprint(fmt, "%s\n", "Nfs3TReadDirPlus");
   3111 	fmtprint(fmt, "\t%s=", "handle");
   3112 	nfs3handleprint(fmt, &x->handle);
   3113 	fmtprint(fmt, "\n");
   3114 	fmtprint(fmt, "\t%s=", "cookie");
   3115 	fmtprint(fmt, "%llud", x->cookie);
   3116 	fmtprint(fmt, "\n");
   3117 	fmtprint(fmt, "\t%s=", "verf");
   3118 	fmtprint(fmt, "%.*H", Nfs3CookieVerfSize, x->verf);
   3119 	fmtprint(fmt, "\n");
   3120 	fmtprint(fmt, "\t%s=", "dirCount");
   3121 	fmtprint(fmt, "%ud", x->dirCount);
   3122 	fmtprint(fmt, "\n");
   3123 	fmtprint(fmt, "\t%s=", "maxCount");
   3124 	fmtprint(fmt, "%ud", x->maxCount);
   3125 	fmtprint(fmt, "\n");
   3126 }
   3127 uint
   3128 nfs3treaddirplussize(Nfs3TReadDirPlus *x)
   3129 {
   3130 	uint a;
   3131 	USED(x);
   3132 	a = 0 + nfs3handlesize(&x->handle) + 8 + Nfs3CookieVerfSize + 4 + 4;
   3133 	return a;
   3134 }
   3135 int
   3136 nfs3treaddirpluspack(uchar *a, uchar *ea, uchar **pa, Nfs3TReadDirPlus *x)
   3137 {
   3138 	if(nfs3handlepack(a, ea, &a, &x->handle) < 0) goto Err;
   3139 	if(sunuint64pack(a, ea, &a, &x->cookie) < 0) goto Err;
   3140 	if(sunfixedopaquepack(a, ea, &a, x->verf, Nfs3CookieVerfSize) < 0) goto Err;
   3141 	if(sunuint32pack(a, ea, &a, &x->dirCount) < 0) goto Err;
   3142 	if(sunuint32pack(a, ea, &a, &x->maxCount) < 0) goto Err;
   3143 	*pa = a;
   3144 	return 0;
   3145 Err:
   3146 	*pa = ea;
   3147 	return -1;
   3148 }
   3149 int
   3150 nfs3treaddirplusunpack(uchar *a, uchar *ea, uchar **pa, Nfs3TReadDirPlus *x)
   3151 {
   3152 	if(nfs3handleunpack(a, ea, &a, &x->handle) < 0) goto Err;
   3153 	if(sunuint64unpack(a, ea, &a, &x->cookie) < 0) goto Err;
   3154 	if(sunfixedopaqueunpack(a, ea, &a, x->verf, Nfs3CookieVerfSize) < 0) goto Err;
   3155 	if(sunuint32unpack(a, ea, &a, &x->dirCount) < 0) goto Err;
   3156 	if(sunuint32unpack(a, ea, &a, &x->maxCount) < 0) goto Err;
   3157 	*pa = a;
   3158 	return 0;
   3159 Err:
   3160 	*pa = ea;
   3161 	return -1;
   3162 }
   3163 void
   3164 nfs3entryplusprint(Fmt *fmt, Nfs3Entry *x)
   3165 {
   3166 	fmtprint(fmt, "%s\n", "Nfs3EntryPlus");
   3167 	fmtprint(fmt, "\t%s=", "fileid");
   3168 	fmtprint(fmt, "%llud", x->fileid);
   3169 	fmtprint(fmt, "\n");
   3170 	fmtprint(fmt, "\t%s=", "name");
   3171 	fmtprint(fmt, "\"%s\"", x->name);
   3172 	fmtprint(fmt, "\n");
   3173 	fmtprint(fmt, "\t%s=", "cookie");
   3174 	fmtprint(fmt, "%llud", x->cookie);
   3175 	fmtprint(fmt, "\n");
   3176 	fmtprint(fmt, "\t%s=", "haveAttr");
   3177 	fmtprint(fmt, "%d", x->haveAttr);
   3178 	fmtprint(fmt, "\n");
   3179 	switch(x->haveAttr){
   3180 	case 1:
   3181 		fmtprint(fmt, "\t%s=", "attr");
   3182 		nfs3attrprint(fmt, &x->attr);
   3183 		fmtprint(fmt, "\n");
   3184 		break;
   3185 	}
   3186 	fmtprint(fmt, "\t%s=", "haveHandle");
   3187 	fmtprint(fmt, "%d", x->haveHandle);
   3188 	fmtprint(fmt, "\n");
   3189 	switch(x->haveHandle){
   3190 	case 1:
   3191 		fmtprint(fmt, "\t%s=", "handle");
   3192 		nfs3handleprint(fmt, &x->handle);
   3193 		fmtprint(fmt, "\n");
   3194 		break;
   3195 	}
   3196 }
   3197 uint
   3198 nfs3entryplussize(Nfs3Entry *x)
   3199 {
   3200 	uint a;
   3201 	USED(x);
   3202 	a = 0 + 8 + sunstringsize(x->name) + 8 + 4;
   3203 	switch(x->haveAttr){
   3204 	case 1:
   3205 		a = a + nfs3attrsize(&x->attr);
   3206 		break;
   3207 	}
   3208 	a = a + 4;
   3209 	switch(x->haveHandle){
   3210 	case 1:
   3211 		a = a + nfs3handlesize(&x->handle);
   3212 		break;
   3213 	}
   3214 	return a;
   3215 }
   3216 int
   3217 nfs3entrypluspack(uchar *a, uchar *ea, uchar **pa, Nfs3Entry *x)
   3218 {
   3219 	u1int u1;
   3220 
   3221 	if(sunuint1pack(a, ea, &a, &u1) < 0) goto Err;
   3222 	if(sunuint64pack(a, ea, &a, &x->fileid) < 0) goto Err;
   3223 	if(sunstringpack(a, ea, &a, &x->name, -1) < 0) goto Err;
   3224 	if(sunuint64pack(a, ea, &a, &x->cookie) < 0) goto Err;
   3225 	if(sunuint1pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
   3226 	switch(x->haveAttr){
   3227 	case 1:
   3228 		if(nfs3attrpack(a, ea, &a, &x->attr) < 0) goto Err;
   3229 		break;
   3230 	}
   3231 	if(sunuint1pack(a, ea, &a, &x->haveHandle) < 0) goto Err;
   3232 	switch(x->haveHandle){
   3233 	case 1:
   3234 		if(nfs3handlepack(a, ea, &a, &x->handle) < 0) goto Err;
   3235 		break;
   3236 	}
   3237 	*pa = a;
   3238 	return 0;
   3239 Err:
   3240 	*pa = ea;
   3241 	return -1;
   3242 }
   3243 int
   3244 nfs3entryplusunpack(uchar *a, uchar *ea, uchar **pa, Nfs3Entry *x)
   3245 {
   3246 	u1int u1;
   3247 
   3248 	if(sunuint1unpack(a, ea, &a, &u1) < 0 || u1 != 1) goto Err;
   3249 	if(sunuint64unpack(a, ea, &a, &x->fileid) < 0) goto Err;
   3250 	if(sunstringunpack(a, ea, &a, &x->name, -1) < 0) goto Err;
   3251 	if(sunuint64unpack(a, ea, &a, &x->cookie) < 0) goto Err;
   3252 	if(sunuint1unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
   3253 	switch(x->haveAttr){
   3254 	case 1:
   3255 		if(nfs3attrunpack(a, ea, &a, &x->attr) < 0) goto Err;
   3256 		break;
   3257 	}
   3258 	if(sunuint1unpack(a, ea, &a, &x->haveHandle) < 0) goto Err;
   3259 	switch(x->haveHandle){
   3260 	case 1:
   3261 		if(nfs3handleunpack(a, ea, &a, &x->handle) < 0) goto Err;
   3262 		break;
   3263 	}
   3264 	*pa = a;
   3265 	return 0;
   3266 Err:
   3267 	*pa = ea;
   3268 	return -1;
   3269 }
   3270 void
   3271 nfs3rreaddirplusprint(Fmt *fmt, Nfs3RReadDirPlus *x)
   3272 {
   3273 	fmtprint(fmt, "%s\n", "Nfs3RReadDirPlus");
   3274 	fmtprint(fmt, "\t%s=", "status");
   3275 	fmtprint(fmt, "%s", nfs3statusstr(x->status));
   3276 	fmtprint(fmt, "\n");
   3277 	fmtprint(fmt, "\t%s=", "haveAttr");
   3278 	fmtprint(fmt, "%d", x->haveAttr);
   3279 	fmtprint(fmt, "\n");
   3280 	switch(x->haveAttr){
   3281 	case 1:
   3282 		fmtprint(fmt, "\t%s=", "attr");
   3283 		nfs3attrprint(fmt, &x->attr);
   3284 		fmtprint(fmt, "\n");
   3285 		break;
   3286 	}
   3287 	switch(x->status){
   3288 	case Nfs3Ok:
   3289 		fmtprint(fmt, "\t%s=", "verf");
   3290 		fmtprint(fmt, "%.*H", Nfs3CookieVerfSize, x->verf);
   3291 		fmtprint(fmt, "\n");
   3292 		fmtprint(fmt, "\tcount=%ud\n", x->count);
   3293 		fmtprint(fmt, "\t%s=", "eof");
   3294 		fmtprint(fmt, "%d", x->eof);
   3295 		fmtprint(fmt, "\n");
   3296 		break;
   3297 	}
   3298 }
   3299 uint
   3300 nfs3rreaddirplussize(Nfs3RReadDirPlus *x)
   3301 {
   3302 	uint a;
   3303 	USED(x);
   3304 	a = 0 + 4 + 4;
   3305 	switch(x->haveAttr){
   3306 	case 1:
   3307 		a = a + nfs3attrsize(&x->attr);
   3308 		break;
   3309 	}
   3310 	switch(x->status){
   3311 	case Nfs3Ok:
   3312 		a = a + Nfs3CookieVerfSize;
   3313 		a += x->count;
   3314 		a += 4 + 4;
   3315 		break;
   3316 	}
   3317 	return a;
   3318 }
   3319 int
   3320 nfs3rreaddirpluspack(uchar *a, uchar *ea, uchar **pa, Nfs3RReadDirPlus *x)
   3321 {
   3322 	int i;
   3323 	u1int zero;
   3324 
   3325 	if(i=x->status, sunenumpack(a, ea, &a, &i) < 0) goto Err;
   3326 	if(sunuint1pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
   3327 	switch(x->haveAttr){
   3328 	case 1:
   3329 		if(nfs3attrpack(a, ea, &a, &x->attr) < 0) goto Err;
   3330 		break;
   3331 	}
   3332 	switch(x->status){
   3333 	case Nfs3Ok:
   3334 		if(sunfixedopaquepack(a, ea, &a, x->verf, Nfs3CookieVerfSize) < 0) goto Err;
   3335 		if(sunfixedopaquepack(a, ea, &a, x->data, x->count) < 0) goto Err;
   3336 		zero = 0;
   3337 		if(sunuint1pack(a, ea, &a, &zero) < 0) goto Err;
   3338 		if(sunuint1pack(a, ea, &a, &x->eof) < 0) goto Err;
   3339 		break;
   3340 	}
   3341 	*pa = a;
   3342 	return 0;
   3343 Err:
   3344 	*pa = ea;
   3345 	return -1;
   3346 }
   3347 static int
   3348 countEntryPlus(uchar *a, uchar *ea, uchar **pa, u32int *n)
   3349 {
   3350 	uchar *oa;
   3351 	u64int u64;
   3352 	u32int u32;
   3353 	u1int u1;
   3354 	Nfs3Handle h;
   3355 	Nfs3Attr attr;
   3356 
   3357 	oa = a;
   3358 	for(;;){
   3359 		if(sunuint1unpack(a, ea, &a, &u1) < 0)
   3360 			return -1;
   3361 		if(u1 == 0)
   3362 			break;
   3363 		if(sunuint64unpack(a, ea, &a, &u64) < 0
   3364 		|| sunuint32unpack(a, ea, &a, &u32) < 0)
   3365 			return -1;
   3366 		a += (u32+3)&~3;
   3367 		if(a >= ea)
   3368 			return -1;
   3369 		if(sunuint64unpack(a, ea, &a, &u64) < 0
   3370 		|| sunuint1unpack(a, ea, &a, &u1) < 0
   3371 		|| (u1 && nfs3attrunpack(a, ea, &a, &attr) < 0)
   3372 		|| sunuint1unpack(a, ea, &a, &u1) < 0
   3373 		|| (u1 && nfs3handleunpack(a, ea, &a, &h) < 0))
   3374 			return -1;
   3375 	}
   3376 	*n = (a-4) - oa;
   3377 	*pa = a;
   3378 	return 0;
   3379 }
   3380 
   3381 int
   3382 nfs3rreaddirplusunpack(uchar *a, uchar *ea, uchar **pa, Nfs3RReadDirPlus *x)
   3383 {
   3384 	int i;
   3385 
   3386 	if(sunenumunpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
   3387 	if(sunuint1unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
   3388 	switch(x->haveAttr){
   3389 	case 1:
   3390 		if(nfs3attrunpack(a, ea, &a, &x->attr) < 0) goto Err;
   3391 		break;
   3392 	}
   3393 	if(x->status == Nfs3Ok){
   3394 		if(sunfixedopaqueunpack(a, ea, &a, x->verf, Nfs3CookieVerfSize) < 0) goto Err;
   3395 		x->data = a;
   3396 		if(countEntryPlus(a, ea, &a, &x->count) < 0) goto Err;
   3397 		if(sunuint1unpack(a, ea, &a, &x->eof) < 0) goto Err;
   3398 	}
   3399 	*pa = a;
   3400 	return 0;
   3401 Err:
   3402 	*pa = ea;
   3403 	return -1;
   3404 }
   3405 void
   3406 nfs3tfsstatprint(Fmt *fmt, Nfs3TFsStat *x)
   3407 {
   3408 	fmtprint(fmt, "%s\n", "Nfs3TFsStat");
   3409 	fmtprint(fmt, "\t%s=", "handle");
   3410 	nfs3handleprint(fmt, &x->handle);
   3411 	fmtprint(fmt, "\n");
   3412 }
   3413 uint
   3414 nfs3tfsstatsize(Nfs3TFsStat *x)
   3415 {
   3416 	uint a;
   3417 	USED(x);
   3418 	a = 0 + nfs3handlesize(&x->handle);
   3419 	return a;
   3420 }
   3421 int
   3422 nfs3tfsstatpack(uchar *a, uchar *ea, uchar **pa, Nfs3TFsStat *x)
   3423 {
   3424 	if(nfs3handlepack(a, ea, &a, &x->handle) < 0) goto Err;
   3425 	*pa = a;
   3426 	return 0;
   3427 Err:
   3428 	*pa = ea;
   3429 	return -1;
   3430 }
   3431 int
   3432 nfs3tfsstatunpack(uchar *a, uchar *ea, uchar **pa, Nfs3TFsStat *x)
   3433 {
   3434 	if(nfs3handleunpack(a, ea, &a, &x->handle) < 0) goto Err;
   3435 	*pa = a;
   3436 	return 0;
   3437 Err:
   3438 	*pa = ea;
   3439 	return -1;
   3440 }
   3441 void
   3442 nfs3rfsstatprint(Fmt *fmt, Nfs3RFsStat *x)
   3443 {
   3444 	fmtprint(fmt, "%s\n", "Nfs3RFsStat");
   3445 	fmtprint(fmt, "\t%s=", "status");
   3446 	fmtprint(fmt, "%s", nfs3statusstr(x->status));
   3447 	fmtprint(fmt, "\n");
   3448 	fmtprint(fmt, "\t%s=", "haveAttr");
   3449 	fmtprint(fmt, "%d", x->haveAttr);
   3450 	fmtprint(fmt, "\n");
   3451 	switch(x->haveAttr){
   3452 	case 1:
   3453 		fmtprint(fmt, "\t%s=", "attr");
   3454 		nfs3attrprint(fmt, &x->attr);
   3455 		fmtprint(fmt, "\n");
   3456 		break;
   3457 	}
   3458 	switch(x->status){
   3459 	case Nfs3Ok:
   3460 		fmtprint(fmt, "\t%s=", "totalBytes");
   3461 		fmtprint(fmt, "%llud", x->totalBytes);
   3462 		fmtprint(fmt, "\n");
   3463 		fmtprint(fmt, "\t%s=", "freeBytes");
   3464 		fmtprint(fmt, "%llud", x->freeBytes);
   3465 		fmtprint(fmt, "\n");
   3466 		fmtprint(fmt, "\t%s=", "availBytes");
   3467 		fmtprint(fmt, "%llud", x->availBytes);
   3468 		fmtprint(fmt, "\n");
   3469 		fmtprint(fmt, "\t%s=", "totalFiles");
   3470 		fmtprint(fmt, "%llud", x->totalFiles);
   3471 		fmtprint(fmt, "\n");
   3472 		fmtprint(fmt, "\t%s=", "freeFiles");
   3473 		fmtprint(fmt, "%llud", x->freeFiles);
   3474 		fmtprint(fmt, "\n");
   3475 		fmtprint(fmt, "\t%s=", "availFiles");
   3476 		fmtprint(fmt, "%llud", x->availFiles);
   3477 		fmtprint(fmt, "\n");
   3478 		fmtprint(fmt, "\t%s=", "invarSec");
   3479 		fmtprint(fmt, "%ud", x->invarSec);
   3480 		fmtprint(fmt, "\n");
   3481 		break;
   3482 	}
   3483 }
   3484 uint
   3485 nfs3rfsstatsize(Nfs3RFsStat *x)
   3486 {
   3487 	uint a;
   3488 	USED(x);
   3489 	a = 0 + 4 + 4;
   3490 	switch(x->haveAttr){
   3491 	case 1:
   3492 		a = a + nfs3attrsize(&x->attr);
   3493 		break;
   3494 	}
   3495 	switch(x->status){
   3496 	case Nfs3Ok:
   3497 		a = a + 8 + 8 + 8 + 8 + 8 + 8 + 4;
   3498 		break;
   3499 	}
   3500 	return a;
   3501 }
   3502 int
   3503 nfs3rfsstatpack(uchar *a, uchar *ea, uchar **pa, Nfs3RFsStat *x)
   3504 {
   3505 	int i;
   3506 
   3507 	if(i=x->status, sunenumpack(a, ea, &a, &i) < 0) goto Err;
   3508 	if(sunuint1pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
   3509 	switch(x->haveAttr){
   3510 	case 1:
   3511 		if(nfs3attrpack(a, ea, &a, &x->attr) < 0) goto Err;
   3512 		break;
   3513 	}
   3514 	switch(x->status){
   3515 	case Nfs3Ok:
   3516 		if(sunuint64pack(a, ea, &a, &x->totalBytes) < 0) goto Err;
   3517 		if(sunuint64pack(a, ea, &a, &x->freeBytes) < 0) goto Err;
   3518 		if(sunuint64pack(a, ea, &a, &x->availBytes) < 0) goto Err;
   3519 		if(sunuint64pack(a, ea, &a, &x->totalFiles) < 0) goto Err;
   3520 		if(sunuint64pack(a, ea, &a, &x->freeFiles) < 0) goto Err;
   3521 		if(sunuint64pack(a, ea, &a, &x->availFiles) < 0) goto Err;
   3522 		if(sunuint32pack(a, ea, &a, &x->invarSec) < 0) goto Err;
   3523 		break;
   3524 	}
   3525 	*pa = a;
   3526 	return 0;
   3527 Err:
   3528 	*pa = ea;
   3529 	return -1;
   3530 }
   3531 int
   3532 nfs3rfsstatunpack(uchar *a, uchar *ea, uchar **pa, Nfs3RFsStat *x)
   3533 {
   3534 	int i;
   3535 
   3536 	if(sunenumunpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
   3537 	if(sunuint1unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
   3538 	switch(x->haveAttr){
   3539 	case 1:
   3540 		if(nfs3attrunpack(a, ea, &a, &x->attr) < 0) goto Err;
   3541 		break;
   3542 	}
   3543 	switch(x->status){
   3544 	case Nfs3Ok:
   3545 		if(sunuint64unpack(a, ea, &a, &x->totalBytes) < 0) goto Err;
   3546 		if(sunuint64unpack(a, ea, &a, &x->freeBytes) < 0) goto Err;
   3547 		if(sunuint64unpack(a, ea, &a, &x->availBytes) < 0) goto Err;
   3548 		if(sunuint64unpack(a, ea, &a, &x->totalFiles) < 0) goto Err;
   3549 		if(sunuint64unpack(a, ea, &a, &x->freeFiles) < 0) goto Err;
   3550 		if(sunuint64unpack(a, ea, &a, &x->availFiles) < 0) goto Err;
   3551 		if(sunuint32unpack(a, ea, &a, &x->invarSec) < 0) goto Err;
   3552 		break;
   3553 	}
   3554 	*pa = a;
   3555 	return 0;
   3556 Err:
   3557 	*pa = ea;
   3558 	return -1;
   3559 }
   3560 void
   3561 nfs3tfsinfoprint(Fmt *fmt, Nfs3TFsInfo *x)
   3562 {
   3563 	fmtprint(fmt, "%s\n", "Nfs3TFsInfo");
   3564 	fmtprint(fmt, "\t%s=", "handle");
   3565 	nfs3handleprint(fmt, &x->handle);
   3566 	fmtprint(fmt, "\n");
   3567 }
   3568 uint
   3569 nfs3tfsinfosize(Nfs3TFsInfo *x)
   3570 {
   3571 	uint a;
   3572 	USED(x);
   3573 	a = 0 + nfs3handlesize(&x->handle);
   3574 	return a;
   3575 }
   3576 int
   3577 nfs3tfsinfopack(uchar *a, uchar *ea, uchar **pa, Nfs3TFsInfo *x)
   3578 {
   3579 	if(nfs3handlepack(a, ea, &a, &x->handle) < 0) goto Err;
   3580 	*pa = a;
   3581 	return 0;
   3582 Err:
   3583 	*pa = ea;
   3584 	return -1;
   3585 }
   3586 int
   3587 nfs3tfsinfounpack(uchar *a, uchar *ea, uchar **pa, Nfs3TFsInfo *x)
   3588 {
   3589 	if(nfs3handleunpack(a, ea, &a, &x->handle) < 0) goto Err;
   3590 	*pa = a;
   3591 	return 0;
   3592 Err:
   3593 	*pa = ea;
   3594 	return -1;
   3595 }
   3596 void
   3597 nfs3rfsinfoprint(Fmt *fmt, Nfs3RFsInfo *x)
   3598 {
   3599 	fmtprint(fmt, "%s\n", "Nfs3RFsInfo");
   3600 	fmtprint(fmt, "\t%s=", "status");
   3601 	fmtprint(fmt, "%s", nfs3statusstr(x->status));
   3602 	fmtprint(fmt, "\n");
   3603 	fmtprint(fmt, "\t%s=", "haveAttr");
   3604 	fmtprint(fmt, "%d", x->haveAttr);
   3605 	fmtprint(fmt, "\n");
   3606 	switch(x->haveAttr){
   3607 	case 1:
   3608 		fmtprint(fmt, "\t%s=", "attr");
   3609 		nfs3attrprint(fmt, &x->attr);
   3610 		fmtprint(fmt, "\n");
   3611 		break;
   3612 	}
   3613 	switch(x->status){
   3614 	case Nfs3Ok:
   3615 		fmtprint(fmt, "\t%s=", "readMax");
   3616 		fmtprint(fmt, "%ud", x->readMax);
   3617 		fmtprint(fmt, "\n");
   3618 		fmtprint(fmt, "\t%s=", "readPref");
   3619 		fmtprint(fmt, "%ud", x->readPref);
   3620 		fmtprint(fmt, "\n");
   3621 		fmtprint(fmt, "\t%s=", "readMult");
   3622 		fmtprint(fmt, "%ud", x->readMult);
   3623 		fmtprint(fmt, "\n");
   3624 		fmtprint(fmt, "\t%s=", "writeMax");
   3625 		fmtprint(fmt, "%ud", x->writeMax);
   3626 		fmtprint(fmt, "\n");
   3627 		fmtprint(fmt, "\t%s=", "writePref");
   3628 		fmtprint(fmt, "%ud", x->writePref);
   3629 		fmtprint(fmt, "\n");
   3630 		fmtprint(fmt, "\t%s=", "writeMult");
   3631 		fmtprint(fmt, "%ud", x->writeMult);
   3632 		fmtprint(fmt, "\n");
   3633 		fmtprint(fmt, "\t%s=", "readDirPref");
   3634 		fmtprint(fmt, "%ud", x->readDirPref);
   3635 		fmtprint(fmt, "\n");
   3636 		fmtprint(fmt, "\t%s=", "maxFileSize");
   3637 		fmtprint(fmt, "%llud", x->maxFileSize);
   3638 		fmtprint(fmt, "\n");
   3639 		fmtprint(fmt, "\t%s=", "timePrec");
   3640 		nfs3timeprint(fmt, &x->timePrec);
   3641 		fmtprint(fmt, "\n");
   3642 		fmtprint(fmt, "\t%s=", "flags");
   3643 		fmtprint(fmt, "%ud", x->flags);
   3644 		fmtprint(fmt, "\n");
   3645 		break;
   3646 	}
   3647 }
   3648 uint
   3649 nfs3rfsinfosize(Nfs3RFsInfo *x)
   3650 {
   3651 	uint a;
   3652 	USED(x);
   3653 	a = 0 + 4 + 4;
   3654 	switch(x->haveAttr){
   3655 	case 1:
   3656 		a = a + nfs3attrsize(&x->attr);
   3657 		break;
   3658 	}
   3659 	switch(x->status){
   3660 	case Nfs3Ok:
   3661 		a = a + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 8 + nfs3timesize(&x->timePrec) + 4;
   3662 		break;
   3663 	}
   3664 	return a;
   3665 }
   3666 int
   3667 nfs3rfsinfopack(uchar *a, uchar *ea, uchar **pa, Nfs3RFsInfo *x)
   3668 {
   3669 	int i;
   3670 
   3671 	if(i=x->status, sunenumpack(a, ea, &a, &i) < 0) goto Err;
   3672 	if(sunuint1pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
   3673 	switch(x->haveAttr){
   3674 	case 1:
   3675 		if(nfs3attrpack(a, ea, &a, &x->attr) < 0) goto Err;
   3676 		break;
   3677 	}
   3678 	switch(x->status){
   3679 	case Nfs3Ok:
   3680 		if(sunuint32pack(a, ea, &a, &x->readMax) < 0) goto Err;
   3681 		if(sunuint32pack(a, ea, &a, &x->readPref) < 0) goto Err;
   3682 		if(sunuint32pack(a, ea, &a, &x->readMult) < 0) goto Err;
   3683 		if(sunuint32pack(a, ea, &a, &x->writeMax) < 0) goto Err;
   3684 		if(sunuint32pack(a, ea, &a, &x->writePref) < 0) goto Err;
   3685 		if(sunuint32pack(a, ea, &a, &x->writeMult) < 0) goto Err;
   3686 		if(sunuint32pack(a, ea, &a, &x->readDirPref) < 0) goto Err;
   3687 		if(sunuint64pack(a, ea, &a, &x->maxFileSize) < 0) goto Err;
   3688 		if(nfs3timepack(a, ea, &a, &x->timePrec) < 0) goto Err;
   3689 		if(sunuint32pack(a, ea, &a, &x->flags) < 0) goto Err;
   3690 		break;
   3691 	}
   3692 	*pa = a;
   3693 	return 0;
   3694 Err:
   3695 	*pa = ea;
   3696 	return -1;
   3697 }
   3698 int
   3699 nfs3rfsinfounpack(uchar *a, uchar *ea, uchar **pa, Nfs3RFsInfo *x)
   3700 {
   3701 	int i;
   3702 
   3703 	if(sunenumunpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
   3704 	if(sunuint1unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
   3705 	switch(x->haveAttr){
   3706 	case 1:
   3707 		if(nfs3attrunpack(a, ea, &a, &x->attr) < 0) goto Err;
   3708 		break;
   3709 	}
   3710 	switch(x->status){
   3711 	case Nfs3Ok:
   3712 		if(sunuint32unpack(a, ea, &a, &x->readMax) < 0) goto Err;
   3713 		if(sunuint32unpack(a, ea, &a, &x->readPref) < 0) goto Err;
   3714 		if(sunuint32unpack(a, ea, &a, &x->readMult) < 0) goto Err;
   3715 		if(sunuint32unpack(a, ea, &a, &x->writeMax) < 0) goto Err;
   3716 		if(sunuint32unpack(a, ea, &a, &x->writePref) < 0) goto Err;
   3717 		if(sunuint32unpack(a, ea, &a, &x->writeMult) < 0) goto Err;
   3718 		if(sunuint32unpack(a, ea, &a, &x->readDirPref) < 0) goto Err;
   3719 		if(sunuint64unpack(a, ea, &a, &x->maxFileSize) < 0) goto Err;
   3720 		if(nfs3timeunpack(a, ea, &a, &x->timePrec) < 0) goto Err;
   3721 		if(sunuint32unpack(a, ea, &a, &x->flags) < 0) goto Err;
   3722 		break;
   3723 	}
   3724 	*pa = a;
   3725 	return 0;
   3726 Err:
   3727 	*pa = ea;
   3728 	return -1;
   3729 }
   3730 void
   3731 nfs3tpathconfprint(Fmt *fmt, Nfs3TPathconf *x)
   3732 {
   3733 	fmtprint(fmt, "%s\n", "Nfs3TPathconf");
   3734 	fmtprint(fmt, "\t%s=", "handle");
   3735 	nfs3handleprint(fmt, &x->handle);
   3736 	fmtprint(fmt, "\n");
   3737 }
   3738 uint
   3739 nfs3tpathconfsize(Nfs3TPathconf *x)
   3740 {
   3741 	uint a;
   3742 	USED(x);
   3743 	a = 0 + nfs3handlesize(&x->handle);
   3744 	return a;
   3745 }
   3746 int
   3747 nfs3tpathconfpack(uchar *a, uchar *ea, uchar **pa, Nfs3TPathconf *x)
   3748 {
   3749 	if(nfs3handlepack(a, ea, &a, &x->handle) < 0) goto Err;
   3750 	*pa = a;
   3751 	return 0;
   3752 Err:
   3753 	*pa = ea;
   3754 	return -1;
   3755 }
   3756 int
   3757 nfs3tpathconfunpack(uchar *a, uchar *ea, uchar **pa, Nfs3TPathconf *x)
   3758 {
   3759 	if(nfs3handleunpack(a, ea, &a, &x->handle) < 0) goto Err;
   3760 	*pa = a;
   3761 	return 0;
   3762 Err:
   3763 	*pa = ea;
   3764 	return -1;
   3765 }
   3766 void
   3767 nfs3rpathconfprint(Fmt *fmt, Nfs3RPathconf *x)
   3768 {
   3769 	fmtprint(fmt, "%s\n", "Nfs3RPathconf");
   3770 	fmtprint(fmt, "\t%s=", "status");
   3771 	fmtprint(fmt, "%s", nfs3statusstr(x->status));
   3772 	fmtprint(fmt, "\n");
   3773 	fmtprint(fmt, "\t%s=", "haveAttr");
   3774 	fmtprint(fmt, "%d", x->haveAttr);
   3775 	fmtprint(fmt, "\n");
   3776 	switch(x->haveAttr){
   3777 	case 1:
   3778 		fmtprint(fmt, "\t%s=", "attr");
   3779 		nfs3attrprint(fmt, &x->attr);
   3780 		fmtprint(fmt, "\n");
   3781 		break;
   3782 	}
   3783 	switch(x->status){
   3784 	case Nfs3Ok:
   3785 		fmtprint(fmt, "\t%s=", "maxLink");
   3786 		fmtprint(fmt, "%ud", x->maxLink);
   3787 		fmtprint(fmt, "\n");
   3788 		fmtprint(fmt, "\t%s=", "maxName");
   3789 		fmtprint(fmt, "%ud", x->maxName);
   3790 		fmtprint(fmt, "\n");
   3791 		fmtprint(fmt, "\t%s=", "noTrunc");
   3792 		fmtprint(fmt, "%d", x->noTrunc);
   3793 		fmtprint(fmt, "\n");
   3794 		fmtprint(fmt, "\t%s=", "chownRestricted");
   3795 		fmtprint(fmt, "%d", x->chownRestricted);
   3796 		fmtprint(fmt, "\n");
   3797 		fmtprint(fmt, "\t%s=", "caseInsensitive");
   3798 		fmtprint(fmt, "%d", x->caseInsensitive);
   3799 		fmtprint(fmt, "\n");
   3800 		fmtprint(fmt, "\t%s=", "casePreserving");
   3801 		fmtprint(fmt, "%d", x->casePreserving);
   3802 		fmtprint(fmt, "\n");
   3803 		break;
   3804 	}
   3805 }
   3806 uint
   3807 nfs3rpathconfsize(Nfs3RPathconf *x)
   3808 {
   3809 	uint a;
   3810 	USED(x);
   3811 	a = 0 + 4 + 4;
   3812 	switch(x->haveAttr){
   3813 	case 1:
   3814 		a = a + nfs3attrsize(&x->attr);
   3815 		break;
   3816 	}
   3817 	switch(x->status){
   3818 	case Nfs3Ok:
   3819 		a = a + 4 + 4 + 4 + 4 + 4 + 4;
   3820 		break;
   3821 	}
   3822 	return a;
   3823 }
   3824 int
   3825 nfs3rpathconfpack(uchar *a, uchar *ea, uchar **pa, Nfs3RPathconf *x)
   3826 {
   3827 	int i;
   3828 
   3829 	if(i=x->status, sunenumpack(a, ea, &a, &i) < 0) goto Err;
   3830 	if(sunuint1pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
   3831 	switch(x->haveAttr){
   3832 	case 1:
   3833 		if(nfs3attrpack(a, ea, &a, &x->attr) < 0) goto Err;
   3834 		break;
   3835 	}
   3836 	switch(x->status){
   3837 	case Nfs3Ok:
   3838 		if(sunuint32pack(a, ea, &a, &x->maxLink) < 0) goto Err;
   3839 		if(sunuint32pack(a, ea, &a, &x->maxName) < 0) goto Err;
   3840 		if(sunuint1pack(a, ea, &a, &x->noTrunc) < 0) goto Err;
   3841 		if(sunuint1pack(a, ea, &a, &x->chownRestricted) < 0) goto Err;
   3842 		if(sunuint1pack(a, ea, &a, &x->caseInsensitive) < 0) goto Err;
   3843 		if(sunuint1pack(a, ea, &a, &x->casePreserving) < 0) goto Err;
   3844 		break;
   3845 	}
   3846 	*pa = a;
   3847 	return 0;
   3848 Err:
   3849 	*pa = ea;
   3850 	return -1;
   3851 }
   3852 int
   3853 nfs3rpathconfunpack(uchar *a, uchar *ea, uchar **pa, Nfs3RPathconf *x)
   3854 {
   3855 	int i;
   3856 
   3857 	if(sunenumunpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
   3858 	if(sunuint1unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
   3859 	switch(x->haveAttr){
   3860 	case 1:
   3861 		if(nfs3attrunpack(a, ea, &a, &x->attr) < 0) goto Err;
   3862 		break;
   3863 	}
   3864 	switch(x->status){
   3865 	case Nfs3Ok:
   3866 		if(sunuint32unpack(a, ea, &a, &x->maxLink) < 0) goto Err;
   3867 		if(sunuint32unpack(a, ea, &a, &x->maxName) < 0) goto Err;
   3868 		if(sunuint1unpack(a, ea, &a, &x->noTrunc) < 0) goto Err;
   3869 		if(sunuint1unpack(a, ea, &a, &x->chownRestricted) < 0) goto Err;
   3870 		if(sunuint1unpack(a, ea, &a, &x->caseInsensitive) < 0) goto Err;
   3871 		if(sunuint1unpack(a, ea, &a, &x->casePreserving) < 0) goto Err;
   3872 		break;
   3873 	}
   3874 	*pa = a;
   3875 	return 0;
   3876 Err:
   3877 	*pa = ea;
   3878 	return -1;
   3879 }
   3880 void
   3881 nfs3tcommitprint(Fmt *fmt, Nfs3TCommit *x)
   3882 {
   3883 	fmtprint(fmt, "%s\n", "Nfs3TCommit");
   3884 	fmtprint(fmt, "\t%s=", "handle");
   3885 	nfs3handleprint(fmt, &x->handle);
   3886 	fmtprint(fmt, "\n");
   3887 	fmtprint(fmt, "\t%s=", "offset");
   3888 	fmtprint(fmt, "%llud", x->offset);
   3889 	fmtprint(fmt, "\n");
   3890 	fmtprint(fmt, "\t%s=", "count");
   3891 	fmtprint(fmt, "%ud", x->count);
   3892 	fmtprint(fmt, "\n");
   3893 }
   3894 uint
   3895 nfs3tcommitsize(Nfs3TCommit *x)
   3896 {
   3897 	uint a;
   3898 	USED(x);
   3899 	a = 0 + nfs3handlesize(&x->handle) + 8 + 4;
   3900 	return a;
   3901 }
   3902 int
   3903 nfs3tcommitpack(uchar *a, uchar *ea, uchar **pa, Nfs3TCommit *x)
   3904 {
   3905 	if(nfs3handlepack(a, ea, &a, &x->handle) < 0) goto Err;
   3906 	if(sunuint64pack(a, ea, &a, &x->offset) < 0) goto Err;
   3907 	if(sunuint32pack(a, ea, &a, &x->count) < 0) goto Err;
   3908 	*pa = a;
   3909 	return 0;
   3910 Err:
   3911 	*pa = ea;
   3912 	return -1;
   3913 }
   3914 int
   3915 nfs3tcommitunpack(uchar *a, uchar *ea, uchar **pa, Nfs3TCommit *x)
   3916 {
   3917 	if(nfs3handleunpack(a, ea, &a, &x->handle) < 0) goto Err;
   3918 	if(sunuint64unpack(a, ea, &a, &x->offset) < 0) goto Err;
   3919 	if(sunuint32unpack(a, ea, &a, &x->count) < 0) goto Err;
   3920 	*pa = a;
   3921 	return 0;
   3922 Err:
   3923 	*pa = ea;
   3924 	return -1;
   3925 }
   3926 void
   3927 nfs3rcommitprint(Fmt *fmt, Nfs3RCommit *x)
   3928 {
   3929 	fmtprint(fmt, "%s\n", "Nfs3RCommit");
   3930 	fmtprint(fmt, "\t%s=", "status");
   3931 	fmtprint(fmt, "%s", nfs3statusstr(x->status));
   3932 	fmtprint(fmt, "\n");
   3933 	fmtprint(fmt, "\t%s=", "wcc");
   3934 	nfs3wccprint(fmt, &x->wcc);
   3935 	fmtprint(fmt, "\n");
   3936 	switch(x->status){
   3937 	case Nfs3Ok:
   3938 		fmtprint(fmt, "\t%s=", "verf");
   3939 		fmtprint(fmt, "%.*H", Nfs3WriteVerfSize, x->verf);
   3940 		fmtprint(fmt, "\n");
   3941 		break;
   3942 	}
   3943 }
   3944 uint
   3945 nfs3rcommitsize(Nfs3RCommit *x)
   3946 {
   3947 	uint a;
   3948 	USED(x);
   3949 	a = 0 + 4 + nfs3wccsize(&x->wcc);
   3950 	switch(x->status){
   3951 	case Nfs3Ok:
   3952 		a = a + Nfs3WriteVerfSize;
   3953 		break;
   3954 	}
   3955 	return a;
   3956 }
   3957 int
   3958 nfs3rcommitpack(uchar *a, uchar *ea, uchar **pa, Nfs3RCommit *x)
   3959 {
   3960 	int i;
   3961 
   3962 	if(i=x->status, sunenumpack(a, ea, &a, &i) < 0) goto Err;
   3963 	if(nfs3wccpack(a, ea, &a, &x->wcc) < 0) goto Err;
   3964 	switch(x->status){
   3965 	case Nfs3Ok:
   3966 		if(sunfixedopaquepack(a, ea, &a, x->verf, Nfs3WriteVerfSize) < 0) goto Err;
   3967 		break;
   3968 	}
   3969 	*pa = a;
   3970 	return 0;
   3971 Err:
   3972 	*pa = ea;
   3973 	return -1;
   3974 }
   3975 int
   3976 nfs3rcommitunpack(uchar *a, uchar *ea, uchar **pa, Nfs3RCommit *x)
   3977 {
   3978 	int i;
   3979 
   3980 	if(sunenumunpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
   3981 	if(nfs3wccunpack(a, ea, &a, &x->wcc) < 0) goto Err;
   3982 	switch(x->status){
   3983 	case Nfs3Ok:
   3984 		if(sunfixedopaqueunpack(a, ea, &a, x->verf, Nfs3WriteVerfSize) < 0) goto Err;
   3985 		break;
   3986 	}
   3987 	*pa = a;
   3988 	return 0;
   3989 Err:
   3990 	*pa = ea;
   3991 	return -1;
   3992 }
   3993 
   3994 typedef int (*P)(uchar*, uchar*, uchar**, SunCall*);
   3995 typedef void (*F)(Fmt*, SunCall*);
   3996 typedef uint (*S)(SunCall*);
   3997 
   3998 static SunProc proc[] = {
   3999 	(P)nfs3tnullpack, (P)nfs3tnullunpack, (S)nfs3tnullsize, (F)nfs3tnullprint, sizeof(Nfs3TNull),
   4000 	(P)nfs3rnullpack, (P)nfs3rnullunpack, (S)nfs3rnullsize, (F)nfs3rnullprint, sizeof(Nfs3RNull),
   4001 	(P)nfs3tgetattrpack, (P)nfs3tgetattrunpack, (S)nfs3tgetattrsize, (F)nfs3tgetattrprint, sizeof(Nfs3TGetattr),
   4002 	(P)nfs3rgetattrpack, (P)nfs3rgetattrunpack, (S)nfs3rgetattrsize, (F)nfs3rgetattrprint, sizeof(Nfs3RGetattr),
   4003 	(P)nfs3tsetattrpack, (P)nfs3tsetattrunpack, (S)nfs3tsetattrsize, (F)nfs3tsetattrprint, sizeof(Nfs3TSetattr),
   4004 	(P)nfs3rsetattrpack, (P)nfs3rsetattrunpack, (S)nfs3rsetattrsize, (F)nfs3rsetattrprint, sizeof(Nfs3RSetattr),
   4005 	(P)nfs3tlookuppack, (P)nfs3tlookupunpack, (S)nfs3tlookupsize, (F)nfs3tlookupprint, sizeof(Nfs3TLookup),
   4006 	(P)nfs3rlookuppack, (P)nfs3rlookupunpack, (S)nfs3rlookupsize, (F)nfs3rlookupprint, sizeof(Nfs3RLookup),
   4007 	(P)nfs3taccesspack, (P)nfs3taccessunpack, (S)nfs3taccesssize, (F)nfs3taccessprint, sizeof(Nfs3TAccess),
   4008 	(P)nfs3raccesspack, (P)nfs3raccessunpack, (S)nfs3raccesssize, (F)nfs3raccessprint, sizeof(Nfs3RAccess),
   4009 	(P)nfs3treadlinkpack, (P)nfs3treadlinkunpack, (S)nfs3treadlinksize, (F)nfs3treadlinkprint, sizeof(Nfs3TReadlink),
   4010 	(P)nfs3rreadlinkpack, (P)nfs3rreadlinkunpack, (S)nfs3rreadlinksize, (F)nfs3rreadlinkprint, sizeof(Nfs3RReadlink),
   4011 	(P)nfs3treadpack, (P)nfs3treadunpack, (S)nfs3treadsize, (F)nfs3treadprint, sizeof(Nfs3TRead),
   4012 	(P)nfs3rreadpack, (P)nfs3rreadunpack, (S)nfs3rreadsize, (F)nfs3rreadprint, sizeof(Nfs3RRead),
   4013 	(P)nfs3twritepack, (P)nfs3twriteunpack, (S)nfs3twritesize, (F)nfs3twriteprint, sizeof(Nfs3TWrite),
   4014 	(P)nfs3rwritepack, (P)nfs3rwriteunpack, (S)nfs3rwritesize, (F)nfs3rwriteprint, sizeof(Nfs3RWrite),
   4015 	(P)nfs3tcreatepack, (P)nfs3tcreateunpack, (S)nfs3tcreatesize, (F)nfs3tcreateprint, sizeof(Nfs3TCreate),
   4016 	(P)nfs3rcreatepack, (P)nfs3rcreateunpack, (S)nfs3rcreatesize, (F)nfs3rcreateprint, sizeof(Nfs3RCreate),
   4017 	(P)nfs3tmkdirpack, (P)nfs3tmkdirunpack, (S)nfs3tmkdirsize, (F)nfs3tmkdirprint, sizeof(Nfs3TMkdir),
   4018 	(P)nfs3rmkdirpack, (P)nfs3rmkdirunpack, (S)nfs3rmkdirsize, (F)nfs3rmkdirprint, sizeof(Nfs3RMkdir),
   4019 	(P)nfs3tsymlinkpack, (P)nfs3tsymlinkunpack, (S)nfs3tsymlinksize, (F)nfs3tsymlinkprint, sizeof(Nfs3TSymlink),
   4020 	(P)nfs3rsymlinkpack, (P)nfs3rsymlinkunpack, (S)nfs3rsymlinksize, (F)nfs3rsymlinkprint, sizeof(Nfs3RSymlink),
   4021 	(P)nfs3tmknodpack, (P)nfs3tmknodunpack, (S)nfs3tmknodsize, (F)nfs3tmknodprint, sizeof(Nfs3TMknod),
   4022 	(P)nfs3rmknodpack, (P)nfs3rmknodunpack, (S)nfs3rmknodsize, (F)nfs3rmknodprint, sizeof(Nfs3RMknod),
   4023 	(P)nfs3tremovepack, (P)nfs3tremoveunpack, (S)nfs3tremovesize, (F)nfs3tremoveprint, sizeof(Nfs3TRemove),
   4024 	(P)nfs3rremovepack, (P)nfs3rremoveunpack, (S)nfs3rremovesize, (F)nfs3rremoveprint, sizeof(Nfs3RRemove),
   4025 	(P)nfs3trmdirpack, (P)nfs3trmdirunpack, (S)nfs3trmdirsize, (F)nfs3trmdirprint, sizeof(Nfs3TRmdir),
   4026 	(P)nfs3rrmdirpack, (P)nfs3rrmdirunpack, (S)nfs3rrmdirsize, (F)nfs3rrmdirprint, sizeof(Nfs3RRmdir),
   4027 	(P)nfs3trenamepack, (P)nfs3trenameunpack, (S)nfs3trenamesize, (F)nfs3trenameprint, sizeof(Nfs3TRename),
   4028 	(P)nfs3rrenamepack, (P)nfs3rrenameunpack, (S)nfs3rrenamesize, (F)nfs3rrenameprint, sizeof(Nfs3RRename),
   4029 	(P)nfs3tlinkpack, (P)nfs3tlinkunpack, (S)nfs3tlinksize, (F)nfs3tlinkprint, sizeof(Nfs3TLink),
   4030 	(P)nfs3rlinkpack, (P)nfs3rlinkunpack, (S)nfs3rlinksize, (F)nfs3rlinkprint, sizeof(Nfs3RLink),
   4031 	(P)nfs3treaddirpack, (P)nfs3treaddirunpack, (S)nfs3treaddirsize, (F)nfs3treaddirprint, sizeof(Nfs3TReadDir),
   4032 	(P)nfs3rreaddirpack, (P)nfs3rreaddirunpack, (S)nfs3rreaddirsize, (F)nfs3rreaddirprint, sizeof(Nfs3RReadDir),
   4033 	(P)nfs3treaddirpluspack, (P)nfs3treaddirplusunpack, (S)nfs3treaddirplussize, (F)nfs3treaddirplusprint, sizeof(Nfs3TReadDirPlus),
   4034 	(P)nfs3rreaddirpluspack, (P)nfs3rreaddirplusunpack, (S)nfs3rreaddirplussize, (F)nfs3rreaddirplusprint, sizeof(Nfs3RReadDirPlus),
   4035 	(P)nfs3tfsstatpack, (P)nfs3tfsstatunpack, (S)nfs3tfsstatsize, (F)nfs3tfsstatprint, sizeof(Nfs3TFsStat),
   4036 	(P)nfs3rfsstatpack, (P)nfs3rfsstatunpack, (S)nfs3rfsstatsize, (F)nfs3rfsstatprint, sizeof(Nfs3RFsStat),
   4037 	(P)nfs3tfsinfopack, (P)nfs3tfsinfounpack, (S)nfs3tfsinfosize, (F)nfs3tfsinfoprint, sizeof(Nfs3TFsInfo),
   4038 	(P)nfs3rfsinfopack, (P)nfs3rfsinfounpack, (S)nfs3rfsinfosize, (F)nfs3rfsinfoprint, sizeof(Nfs3RFsInfo),
   4039 	(P)nfs3tpathconfpack, (P)nfs3tpathconfunpack, (S)nfs3tpathconfsize, (F)nfs3tpathconfprint, sizeof(Nfs3TPathconf),
   4040 	(P)nfs3rpathconfpack, (P)nfs3rpathconfunpack, (S)nfs3rpathconfsize, (F)nfs3rpathconfprint, sizeof(Nfs3RPathconf),
   4041 	(P)nfs3tcommitpack, (P)nfs3tcommitunpack, (S)nfs3tcommitsize, (F)nfs3tcommitprint, sizeof(Nfs3TCommit),
   4042 	(P)nfs3rcommitpack, (P)nfs3rcommitunpack, (S)nfs3rcommitsize, (F)nfs3rcommitprint, sizeof(Nfs3RCommit)
   4043 };
   4044 
   4045 SunProg nfs3prog =
   4046 {
   4047 	Nfs3Program,
   4048 	Nfs3Version,
   4049 	proc,
   4050 	nelem(proc),
   4051 };
	plan9port fork of plan9port with libvec, libstr and libsdb
	Log \| Files \| Refs \| README \| LICENSE