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 	SunStatus 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(SunStatus status)
119 {
120 	int i;
121 
122 	for(i=0; i<nelem(etab); i++){
123 		if(etab[i].status == 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 int
2942 nfs3entrypack(uchar *a, uchar *ea, uchar **pa, Nfs3Entry *x)
2943 {
2944 	u1int one;
2945 
2946 	one = 1;
2947 	if(sunuint1pack(a, ea, &a, &one) < 0) goto Err;
2948 	if(sunuint64pack(a, ea, &a, &x->fileid) < 0) goto Err;
2949 	if(sunstringpack(a, ea, &a, &x->name, -1) < 0) goto Err;
2950 	if(sunuint64pack(a, ea, &a, &x->cookie) < 0) goto Err;
2951 	*pa = a;
2952 	return 0;
2953 Err:
2954 	*pa = ea;
2955 	return -1;
2956 }
2957 int
2958 nfs3entryunpack(uchar *a, uchar *ea, uchar **pa, Nfs3Entry *x)
2959 {
2960 	u1int one;
2961 
2962 	memset(x, 0, sizeof *x);
2963 	if(sunuint1unpack(a, ea, &a, &one) < 0 || one != 1) goto Err;
2964 	if(sunuint64unpack(a, ea, &a, &x->fileid) < 0) goto Err;
2965 	if(sunstringunpack(a, ea, &a, &x->name, -1) < 0) goto Err;
2966 	if(sunuint64unpack(a, ea, &a, &x->cookie) < 0) goto Err;
2967 	*pa = a;
2968 	return 0;
2969 Err:
2970 	*pa = ea;
2971 	return -1;
2972 }
2973 void
2974 nfs3rreaddirprint(Fmt *fmt, Nfs3RReadDir *x)
2975 {
2976 	fmtprint(fmt, "%s\n", "Nfs3RReadDir");
2977 	fmtprint(fmt, "\t%s=", "status");
2978 	fmtprint(fmt, "%s", nfs3statusstr(x->status));
2979 	fmtprint(fmt, "\n");
2980 	fmtprint(fmt, "\t%s=", "haveAttr");
2981 	fmtprint(fmt, "%d", x->haveAttr);
2982 	fmtprint(fmt, "\n");
2983 	switch(x->haveAttr){
2984 	case 1:
2985 		fmtprint(fmt, "\t%s=", "attr");
2986 		nfs3attrprint(fmt, &x->attr);
2987 		fmtprint(fmt, "\n");
2988 		break;
2989 	}
2990 	switch(x->status){
2991 	case Nfs3Ok:
2992 		fmtprint(fmt, "\t%s=", "verf");
2993 		fmtprint(fmt, "%.*H", Nfs3CookieVerfSize, x->verf);
2994 		fmtprint(fmt, "\n");
2995 		fmtprint(fmt, "\t%s=%ud\n", "count", x->count);
2996 		fmtprint(fmt, "\t%s=", "eof");
2997 		fmtprint(fmt, "%d", x->eof);
2998 		fmtprint(fmt, "\n");
2999 		break;
3000 	}
3001 }
3002 uint
3003 nfs3rreaddirsize(Nfs3RReadDir *x)
3004 {
3005 	uint a;
3006 	USED(x);
3007 	a = 0 + 4 + 4;
3008 	switch(x->haveAttr){
3009 	case 1:
3010 		a = a + nfs3attrsize(&x->attr);
3011 		break;
3012 	}
3013 	switch(x->status){
3014 	case Nfs3Ok:
3015 		a = a + Nfs3CookieVerfSize;
3016 		a += x->count;
3017 		a += 4 + 4;
3018 		break;
3019 	}
3020 	return a;
3021 }
3022 int
3023 nfs3rreaddirpack(uchar *a, uchar *ea, uchar **pa, Nfs3RReadDir *x)
3024 {
3025 	int i;
3026 	u1int zero;
3027 
3028 	if(i=x->status, sunenumpack(a, ea, &a, &i) < 0) goto Err;
3029 	if(sunuint1pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
3030 	switch(x->haveAttr){
3031 	case 1:
3032 		if(nfs3attrpack(a, ea, &a, &x->attr) < 0) goto Err;
3033 		break;
3034 	}
3035 	switch(x->status){
3036 	case Nfs3Ok:
3037 		if(sunfixedopaquepack(a, ea, &a, x->verf, Nfs3CookieVerfSize) < 0) goto Err;
3038 		if(sunfixedopaquepack(a, ea, &a, x->data, x->count) < 0) goto Err;
3039 		zero = 0;
3040 		if(sunuint1pack(a, ea, &a, &zero) < 0) goto Err;
3041 		if(sunuint1pack(a, ea, &a, &x->eof) < 0) goto Err;
3042 		break;
3043 	}
3044 	*pa = a;
3045 	return 0;
3046 Err:
3047 	*pa = ea;
3048 	return -1;
3049 }
3050 static int
3051 countEntry(uchar *a, uchar *ea, uchar **pa, u32int *n)
3052 {
3053 	uchar *oa;
3054 	u64int u64;
3055 	u32int u32;
3056 	u1int u1;
3057 
3058 	oa = a;
3059 	for(;;){
3060 		if(sunuint1unpack(a, ea, &a, &u1) < 0)
3061 			return -1;
3062 		if(u1 == 0)
3063 			break;
3064 		if(sunuint64unpack(a, ea, &a, &u64) < 0
3065 		|| sunuint32unpack(a, ea, &a, &u32) < 0)
3066 			return -1;
3067 		a += (u32+3)&~3;
3068 		if(a >= ea)
3069 			return -1;
3070 		if(sunuint64unpack(a, ea, &a, &u64) < 0)
3071 			return -1;
3072 	}
3073 	*n = (a-4) - oa;
3074 	*pa = a;
3075 	return 0;
3076 }
3077 int
3078 nfs3rreaddirunpack(uchar *a, uchar *ea, uchar **pa, Nfs3RReadDir *x)
3079 {
3080 	int i;
3081 
3082 	if(sunenumunpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
3083 	if(sunuint1unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
3084 	switch(x->haveAttr){
3085 	case 1:
3086 		if(nfs3attrunpack(a, ea, &a, &x->attr) < 0) goto Err;
3087 		break;
3088 	}
3089 	if(x->status == Nfs3Ok){
3090 		if(sunfixedopaqueunpack(a, ea, &a, x->verf, Nfs3CookieVerfSize) < 0) goto Err;
3091 		x->data = a;
3092 		if(countEntry(a, ea, &a, &x->count) < 0) goto Err;
3093 		if(sunuint1unpack(a, ea, &a, &x->eof) < 0) goto Err;
3094 	}
3095 	*pa = a;
3096 	return 0;
3097 Err:
3098 	*pa = ea;
3099 	return -1;
3100 }
3101 void
3102 nfs3treaddirplusprint(Fmt *fmt, Nfs3TReadDirPlus *x)
3103 {
3104 	fmtprint(fmt, "%s\n", "Nfs3TReadDirPlus");
3105 	fmtprint(fmt, "\t%s=", "handle");
3106 	nfs3handleprint(fmt, &x->handle);
3107 	fmtprint(fmt, "\n");
3108 	fmtprint(fmt, "\t%s=", "cookie");
3109 	fmtprint(fmt, "%llud", x->cookie);
3110 	fmtprint(fmt, "\n");
3111 	fmtprint(fmt, "\t%s=", "verf");
3112 	fmtprint(fmt, "%.*H", Nfs3CookieVerfSize, x->verf);
3113 	fmtprint(fmt, "\n");
3114 	fmtprint(fmt, "\t%s=", "dirCount");
3115 	fmtprint(fmt, "%ud", x->dirCount);
3116 	fmtprint(fmt, "\n");
3117 	fmtprint(fmt, "\t%s=", "maxCount");
3118 	fmtprint(fmt, "%ud", x->maxCount);
3119 	fmtprint(fmt, "\n");
3120 }
3121 uint
3122 nfs3treaddirplussize(Nfs3TReadDirPlus *x)
3123 {
3124 	uint a;
3125 	USED(x);
3126 	a = 0 + nfs3handlesize(&x->handle) + 8 + Nfs3CookieVerfSize + 4 + 4;
3127 	return a;
3128 }
3129 int
3130 nfs3treaddirpluspack(uchar *a, uchar *ea, uchar **pa, Nfs3TReadDirPlus *x)
3131 {
3132 	if(nfs3handlepack(a, ea, &a, &x->handle) < 0) goto Err;
3133 	if(sunuint64pack(a, ea, &a, &x->cookie) < 0) goto Err;
3134 	if(sunfixedopaquepack(a, ea, &a, x->verf, Nfs3CookieVerfSize) < 0) goto Err;
3135 	if(sunuint32pack(a, ea, &a, &x->dirCount) < 0) goto Err;
3136 	if(sunuint32pack(a, ea, &a, &x->maxCount) < 0) goto Err;
3137 	*pa = a;
3138 	return 0;
3139 Err:
3140 	*pa = ea;
3141 	return -1;
3142 }
3143 int
3144 nfs3treaddirplusunpack(uchar *a, uchar *ea, uchar **pa, Nfs3TReadDirPlus *x)
3145 {
3146 	if(nfs3handleunpack(a, ea, &a, &x->handle) < 0) goto Err;
3147 	if(sunuint64unpack(a, ea, &a, &x->cookie) < 0) goto Err;
3148 	if(sunfixedopaqueunpack(a, ea, &a, x->verf, Nfs3CookieVerfSize) < 0) goto Err;
3149 	if(sunuint32unpack(a, ea, &a, &x->dirCount) < 0) goto Err;
3150 	if(sunuint32unpack(a, ea, &a, &x->maxCount) < 0) goto Err;
3151 	*pa = a;
3152 	return 0;
3153 Err:
3154 	*pa = ea;
3155 	return -1;
3156 }
3157 void
3158 nfs3entryplusprint(Fmt *fmt, Nfs3Entry *x)
3159 {
3160 	fmtprint(fmt, "%s\n", "Nfs3EntryPlus");
3161 	fmtprint(fmt, "\t%s=", "fileid");
3162 	fmtprint(fmt, "%llud", x->fileid);
3163 	fmtprint(fmt, "\n");
3164 	fmtprint(fmt, "\t%s=", "name");
3165 	fmtprint(fmt, "\"%s\"", x->name);
3166 	fmtprint(fmt, "\n");
3167 	fmtprint(fmt, "\t%s=", "cookie");
3168 	fmtprint(fmt, "%llud", x->cookie);
3169 	fmtprint(fmt, "\n");
3170 	fmtprint(fmt, "\t%s=", "haveAttr");
3171 	fmtprint(fmt, "%d", x->haveAttr);
3172 	fmtprint(fmt, "\n");
3173 	switch(x->haveAttr){
3174 	case 1:
3175 		fmtprint(fmt, "\t%s=", "attr");
3176 		nfs3attrprint(fmt, &x->attr);
3177 		fmtprint(fmt, "\n");
3178 		break;
3179 	}
3180 	fmtprint(fmt, "\t%s=", "haveHandle");
3181 	fmtprint(fmt, "%d", x->haveHandle);
3182 	fmtprint(fmt, "\n");
3183 	switch(x->haveHandle){
3184 	case 1:
3185 		fmtprint(fmt, "\t%s=", "handle");
3186 		nfs3handleprint(fmt, &x->handle);
3187 		fmtprint(fmt, "\n");
3188 		break;
3189 	}
3190 }
3191 uint
3192 nfs3entryplussize(Nfs3Entry *x)
3193 {
3194 	uint a;
3195 	USED(x);
3196 	a = 0 + 8 + sunstringsize(x->name) + 8 + 4;
3197 	switch(x->haveAttr){
3198 	case 1:
3199 		a = a + nfs3attrsize(&x->attr);
3200 		break;
3201 	}
3202 	a = a + 4;
3203 	switch(x->haveHandle){
3204 	case 1:
3205 		a = a + nfs3handlesize(&x->handle);
3206 		break;
3207 	}
3208 	return a;
3209 }
3210 int
3211 nfs3entrypluspack(uchar *a, uchar *ea, uchar **pa, Nfs3Entry *x)
3212 {
3213 	u1int u1;
3214 
3215 	if(sunuint1pack(a, ea, &a, &u1) < 0) goto Err;
3216 	if(sunuint64pack(a, ea, &a, &x->fileid) < 0) goto Err;
3217 	if(sunstringpack(a, ea, &a, &x->name, -1) < 0) goto Err;
3218 	if(sunuint64pack(a, ea, &a, &x->cookie) < 0) goto Err;
3219 	if(sunuint1pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
3220 	switch(x->haveAttr){
3221 	case 1:
3222 		if(nfs3attrpack(a, ea, &a, &x->attr) < 0) goto Err;
3223 		break;
3224 	}
3225 	if(sunuint1pack(a, ea, &a, &x->haveHandle) < 0) goto Err;
3226 	switch(x->haveHandle){
3227 	case 1:
3228 		if(nfs3handlepack(a, ea, &a, &x->handle) < 0) goto Err;
3229 		break;
3230 	}
3231 	*pa = a;
3232 	return 0;
3233 Err:
3234 	*pa = ea;
3235 	return -1;
3236 }
3237 int
3238 nfs3entryplusunpack(uchar *a, uchar *ea, uchar **pa, Nfs3Entry *x)
3239 {
3240 	u1int u1;
3241 
3242 	if(sunuint1unpack(a, ea, &a, &u1) < 0 || u1 != 1) goto Err;
3243 	if(sunuint64unpack(a, ea, &a, &x->fileid) < 0) goto Err;
3244 	if(sunstringunpack(a, ea, &a, &x->name, -1) < 0) goto Err;
3245 	if(sunuint64unpack(a, ea, &a, &x->cookie) < 0) goto Err;
3246 	if(sunuint1unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
3247 	switch(x->haveAttr){
3248 	case 1:
3249 		if(nfs3attrunpack(a, ea, &a, &x->attr) < 0) goto Err;
3250 		break;
3251 	}
3252 	if(sunuint1unpack(a, ea, &a, &x->haveHandle) < 0) goto Err;
3253 	switch(x->haveHandle){
3254 	case 1:
3255 		if(nfs3handleunpack(a, ea, &a, &x->handle) < 0) goto Err;
3256 		break;
3257 	}
3258 	*pa = a;
3259 	return 0;
3260 Err:
3261 	*pa = ea;
3262 	return -1;
3263 }
3264 void
3265 nfs3rreaddirplusprint(Fmt *fmt, Nfs3RReadDirPlus *x)
3266 {
3267 	fmtprint(fmt, "%s\n", "Nfs3RReadDirPlus");
3268 	fmtprint(fmt, "\t%s=", "status");
3269 	fmtprint(fmt, "%s", nfs3statusstr(x->status));
3270 	fmtprint(fmt, "\n");
3271 	fmtprint(fmt, "\t%s=", "haveAttr");
3272 	fmtprint(fmt, "%d", x->haveAttr);
3273 	fmtprint(fmt, "\n");
3274 	switch(x->haveAttr){
3275 	case 1:
3276 		fmtprint(fmt, "\t%s=", "attr");
3277 		nfs3attrprint(fmt, &x->attr);
3278 		fmtprint(fmt, "\n");
3279 		break;
3280 	}
3281 	switch(x->status){
3282 	case Nfs3Ok:
3283 		fmtprint(fmt, "\t%s=", "verf");
3284 		fmtprint(fmt, "%.*H", Nfs3CookieVerfSize, x->verf);
3285 		fmtprint(fmt, "\n");
3286 		fmtprint(fmt, "\tcount=%ud\n", x->count);
3287 		fmtprint(fmt, "\t%s=", "eof");
3288 		fmtprint(fmt, "%d", x->eof);
3289 		fmtprint(fmt, "\n");
3290 		break;
3291 	}
3292 }
3293 uint
3294 nfs3rreaddirplussize(Nfs3RReadDirPlus *x)
3295 {
3296 	uint a;
3297 	USED(x);
3298 	a = 0 + 4 + 4;
3299 	switch(x->haveAttr){
3300 	case 1:
3301 		a = a + nfs3attrsize(&x->attr);
3302 		break;
3303 	}
3304 	switch(x->status){
3305 	case Nfs3Ok:
3306 		a = a + Nfs3CookieVerfSize;
3307 		a += x->count;
3308 		a += 4 + 4;
3309 		break;
3310 	}
3311 	return a;
3312 }
3313 int
3314 nfs3rreaddirpluspack(uchar *a, uchar *ea, uchar **pa, Nfs3RReadDirPlus *x)
3315 {
3316 	int i;
3317 	u1int zero;
3318 
3319 	if(i=x->status, sunenumpack(a, ea, &a, &i) < 0) goto Err;
3320 	if(sunuint1pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
3321 	switch(x->haveAttr){
3322 	case 1:
3323 		if(nfs3attrpack(a, ea, &a, &x->attr) < 0) goto Err;
3324 		break;
3325 	}
3326 	switch(x->status){
3327 	case Nfs3Ok:
3328 		if(sunfixedopaquepack(a, ea, &a, x->verf, Nfs3CookieVerfSize) < 0) goto Err;
3329 		if(sunfixedopaquepack(a, ea, &a, x->data, x->count) < 0) goto Err;
3330 		zero = 0;
3331 		if(sunuint1pack(a, ea, &a, &zero) < 0) goto Err;
3332 		if(sunuint1pack(a, ea, &a, &x->eof) < 0) goto Err;
3333 		break;
3334 	}
3335 	*pa = a;
3336 	return 0;
3337 Err:
3338 	*pa = ea;
3339 	return -1;
3340 }
3341 static int
3342 countEntryPlus(uchar *a, uchar *ea, uchar **pa, u32int *n)
3343 {
3344 	uchar *oa;
3345 	u64int u64;
3346 	u32int u32;
3347 	u1int u1;
3348 	Nfs3Handle h;
3349 	Nfs3Attr attr;
3350 
3351 	oa = a;
3352 	for(;;){
3353 		if(sunuint1unpack(a, ea, &a, &u1) < 0)
3354 			return -1;
3355 		if(u1 == 0)
3356 			break;
3357 		if(sunuint64unpack(a, ea, &a, &u64) < 0
3358 		|| sunuint32unpack(a, ea, &a, &u32) < 0)
3359 			return -1;
3360 		a += (u32+3)&~3;
3361 		if(a >= ea)
3362 			return -1;
3363 		if(sunuint64unpack(a, ea, &a, &u64) < 0
3364 		|| sunuint1unpack(a, ea, &a, &u1) < 0
3365 		|| (u1 && nfs3attrunpack(a, ea, &a, &attr) < 0)
3366 		|| sunuint1unpack(a, ea, &a, &u1) < 0
3367 		|| (u1 && nfs3handleunpack(a, ea, &a, &h) < 0))
3368 			return -1;
3369 	}
3370 	*n = (a-4) - oa;
3371 	*pa = a;
3372 	return 0;
3373 }
3374 		
3375 int
3376 nfs3rreaddirplusunpack(uchar *a, uchar *ea, uchar **pa, Nfs3RReadDirPlus *x)
3377 {
3378 	int i;
3379 
3380 	if(sunenumunpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
3381 	if(sunuint1unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
3382 	switch(x->haveAttr){
3383 	case 1:
3384 		if(nfs3attrunpack(a, ea, &a, &x->attr) < 0) goto Err;
3385 		break;
3386 	}
3387 	if(x->status == Nfs3Ok){
3388 		if(sunfixedopaqueunpack(a, ea, &a, x->verf, Nfs3CookieVerfSize) < 0) goto Err;
3389 		x->data = a;
3390 		if(countEntryPlus(a, ea, &a, &x->count) < 0) goto Err;
3391 		if(sunuint1unpack(a, ea, &a, &x->eof) < 0) goto Err;
3392 	}
3393 	*pa = a;
3394 	return 0;
3395 Err:
3396 	*pa = ea;
3397 	return -1;
3398 }
3399 void
3400 nfs3tfsstatprint(Fmt *fmt, Nfs3TFsStat *x)
3401 {
3402 	fmtprint(fmt, "%s\n", "Nfs3TFsStat");
3403 	fmtprint(fmt, "\t%s=", "handle");
3404 	nfs3handleprint(fmt, &x->handle);
3405 	fmtprint(fmt, "\n");
3406 }
3407 uint
3408 nfs3tfsstatsize(Nfs3TFsStat *x)
3409 {
3410 	uint a;
3411 	USED(x);
3412 	a = 0 + nfs3handlesize(&x->handle);
3413 	return a;
3414 }
3415 int
3416 nfs3tfsstatpack(uchar *a, uchar *ea, uchar **pa, Nfs3TFsStat *x)
3417 {
3418 	if(nfs3handlepack(a, ea, &a, &x->handle) < 0) goto Err;
3419 	*pa = a;
3420 	return 0;
3421 Err:
3422 	*pa = ea;
3423 	return -1;
3424 }
3425 int
3426 nfs3tfsstatunpack(uchar *a, uchar *ea, uchar **pa, Nfs3TFsStat *x)
3427 {
3428 	if(nfs3handleunpack(a, ea, &a, &x->handle) < 0) goto Err;
3429 	*pa = a;
3430 	return 0;
3431 Err:
3432 	*pa = ea;
3433 	return -1;
3434 }
3435 void
3436 nfs3rfsstatprint(Fmt *fmt, Nfs3RFsStat *x)
3437 {
3438 	fmtprint(fmt, "%s\n", "Nfs3RFsStat");
3439 	fmtprint(fmt, "\t%s=", "status");
3440 	fmtprint(fmt, "%s", nfs3statusstr(x->status));
3441 	fmtprint(fmt, "\n");
3442 	fmtprint(fmt, "\t%s=", "haveAttr");
3443 	fmtprint(fmt, "%d", x->haveAttr);
3444 	fmtprint(fmt, "\n");
3445 	switch(x->haveAttr){
3446 	case 1:
3447 		fmtprint(fmt, "\t%s=", "attr");
3448 		nfs3attrprint(fmt, &x->attr);
3449 		fmtprint(fmt, "\n");
3450 		break;
3451 	}
3452 	switch(x->status){
3453 	case Nfs3Ok:
3454 		fmtprint(fmt, "\t%s=", "totalBytes");
3455 		fmtprint(fmt, "%llud", x->totalBytes);
3456 		fmtprint(fmt, "\n");
3457 		fmtprint(fmt, "\t%s=", "freeBytes");
3458 		fmtprint(fmt, "%llud", x->freeBytes);
3459 		fmtprint(fmt, "\n");
3460 		fmtprint(fmt, "\t%s=", "availBytes");
3461 		fmtprint(fmt, "%llud", x->availBytes);
3462 		fmtprint(fmt, "\n");
3463 		fmtprint(fmt, "\t%s=", "totalFiles");
3464 		fmtprint(fmt, "%llud", x->totalFiles);
3465 		fmtprint(fmt, "\n");
3466 		fmtprint(fmt, "\t%s=", "freeFiles");
3467 		fmtprint(fmt, "%llud", x->freeFiles);
3468 		fmtprint(fmt, "\n");
3469 		fmtprint(fmt, "\t%s=", "availFiles");
3470 		fmtprint(fmt, "%llud", x->availFiles);
3471 		fmtprint(fmt, "\n");
3472 		fmtprint(fmt, "\t%s=", "invarSec");
3473 		fmtprint(fmt, "%ud", x->invarSec);
3474 		fmtprint(fmt, "\n");
3475 		break;
3476 	}
3477 }
3478 uint
3479 nfs3rfsstatsize(Nfs3RFsStat *x)
3480 {
3481 	uint a;
3482 	USED(x);
3483 	a = 0 + 4 + 4;
3484 	switch(x->haveAttr){
3485 	case 1:
3486 		a = a + nfs3attrsize(&x->attr);
3487 		break;
3488 	}
3489 	switch(x->status){
3490 	case Nfs3Ok:
3491 		a = a + 8 + 8 + 8 + 8 + 8 + 8 + 4;
3492 		break;
3493 	}
3494 	return a;
3495 }
3496 int
3497 nfs3rfsstatpack(uchar *a, uchar *ea, uchar **pa, Nfs3RFsStat *x)
3498 {
3499 	int i;
3500 
3501 	if(i=x->status, sunenumpack(a, ea, &a, &i) < 0) goto Err;
3502 	if(sunuint1pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
3503 	switch(x->haveAttr){
3504 	case 1:
3505 		if(nfs3attrpack(a, ea, &a, &x->attr) < 0) goto Err;
3506 		break;
3507 	}
3508 	switch(x->status){
3509 	case Nfs3Ok:
3510 		if(sunuint64pack(a, ea, &a, &x->totalBytes) < 0) goto Err;
3511 		if(sunuint64pack(a, ea, &a, &x->freeBytes) < 0) goto Err;
3512 		if(sunuint64pack(a, ea, &a, &x->availBytes) < 0) goto Err;
3513 		if(sunuint64pack(a, ea, &a, &x->totalFiles) < 0) goto Err;
3514 		if(sunuint64pack(a, ea, &a, &x->freeFiles) < 0) goto Err;
3515 		if(sunuint64pack(a, ea, &a, &x->availFiles) < 0) goto Err;
3516 		if(sunuint32pack(a, ea, &a, &x->invarSec) < 0) goto Err;
3517 		break;
3518 	}
3519 	*pa = a;
3520 	return 0;
3521 Err:
3522 	*pa = ea;
3523 	return -1;
3524 }
3525 int
3526 nfs3rfsstatunpack(uchar *a, uchar *ea, uchar **pa, Nfs3RFsStat *x)
3527 {
3528 	int i;
3529 
3530 	if(sunenumunpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
3531 	if(sunuint1unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
3532 	switch(x->haveAttr){
3533 	case 1:
3534 		if(nfs3attrunpack(a, ea, &a, &x->attr) < 0) goto Err;
3535 		break;
3536 	}
3537 	switch(x->status){
3538 	case Nfs3Ok:
3539 		if(sunuint64unpack(a, ea, &a, &x->totalBytes) < 0) goto Err;
3540 		if(sunuint64unpack(a, ea, &a, &x->freeBytes) < 0) goto Err;
3541 		if(sunuint64unpack(a, ea, &a, &x->availBytes) < 0) goto Err;
3542 		if(sunuint64unpack(a, ea, &a, &x->totalFiles) < 0) goto Err;
3543 		if(sunuint64unpack(a, ea, &a, &x->freeFiles) < 0) goto Err;
3544 		if(sunuint64unpack(a, ea, &a, &x->availFiles) < 0) goto Err;
3545 		if(sunuint32unpack(a, ea, &a, &x->invarSec) < 0) goto Err;
3546 		break;
3547 	}
3548 	*pa = a;
3549 	return 0;
3550 Err:
3551 	*pa = ea;
3552 	return -1;
3553 }
3554 void
3555 nfs3tfsinfoprint(Fmt *fmt, Nfs3TFsInfo *x)
3556 {
3557 	fmtprint(fmt, "%s\n", "Nfs3TFsInfo");
3558 	fmtprint(fmt, "\t%s=", "handle");
3559 	nfs3handleprint(fmt, &x->handle);
3560 	fmtprint(fmt, "\n");
3561 }
3562 uint
3563 nfs3tfsinfosize(Nfs3TFsInfo *x)
3564 {
3565 	uint a;
3566 	USED(x);
3567 	a = 0 + nfs3handlesize(&x->handle);
3568 	return a;
3569 }
3570 int
3571 nfs3tfsinfopack(uchar *a, uchar *ea, uchar **pa, Nfs3TFsInfo *x)
3572 {
3573 	if(nfs3handlepack(a, ea, &a, &x->handle) < 0) goto Err;
3574 	*pa = a;
3575 	return 0;
3576 Err:
3577 	*pa = ea;
3578 	return -1;
3579 }
3580 int
3581 nfs3tfsinfounpack(uchar *a, uchar *ea, uchar **pa, Nfs3TFsInfo *x)
3582 {
3583 	if(nfs3handleunpack(a, ea, &a, &x->handle) < 0) goto Err;
3584 	*pa = a;
3585 	return 0;
3586 Err:
3587 	*pa = ea;
3588 	return -1;
3589 }
3590 void
3591 nfs3rfsinfoprint(Fmt *fmt, Nfs3RFsInfo *x)
3592 {
3593 	fmtprint(fmt, "%s\n", "Nfs3RFsInfo");
3594 	fmtprint(fmt, "\t%s=", "status");
3595 	fmtprint(fmt, "%s", nfs3statusstr(x->status));
3596 	fmtprint(fmt, "\n");
3597 	fmtprint(fmt, "\t%s=", "haveAttr");
3598 	fmtprint(fmt, "%d", x->haveAttr);
3599 	fmtprint(fmt, "\n");
3600 	switch(x->haveAttr){
3601 	case 1:
3602 		fmtprint(fmt, "\t%s=", "attr");
3603 		nfs3attrprint(fmt, &x->attr);
3604 		fmtprint(fmt, "\n");
3605 		break;
3606 	}
3607 	switch(x->status){
3608 	case Nfs3Ok:
3609 		fmtprint(fmt, "\t%s=", "readMax");
3610 		fmtprint(fmt, "%ud", x->readMax);
3611 		fmtprint(fmt, "\n");
3612 		fmtprint(fmt, "\t%s=", "readPref");
3613 		fmtprint(fmt, "%ud", x->readPref);
3614 		fmtprint(fmt, "\n");
3615 		fmtprint(fmt, "\t%s=", "readMult");
3616 		fmtprint(fmt, "%ud", x->readMult);
3617 		fmtprint(fmt, "\n");
3618 		fmtprint(fmt, "\t%s=", "writeMax");
3619 		fmtprint(fmt, "%ud", x->writeMax);
3620 		fmtprint(fmt, "\n");
3621 		fmtprint(fmt, "\t%s=", "writePref");
3622 		fmtprint(fmt, "%ud", x->writePref);
3623 		fmtprint(fmt, "\n");
3624 		fmtprint(fmt, "\t%s=", "writeMult");
3625 		fmtprint(fmt, "%ud", x->writeMult);
3626 		fmtprint(fmt, "\n");
3627 		fmtprint(fmt, "\t%s=", "readDirPref");
3628 		fmtprint(fmt, "%ud", x->readDirPref);
3629 		fmtprint(fmt, "\n");
3630 		fmtprint(fmt, "\t%s=", "maxFileSize");
3631 		fmtprint(fmt, "%llud", x->maxFileSize);
3632 		fmtprint(fmt, "\n");
3633 		fmtprint(fmt, "\t%s=", "timePrec");
3634 		nfs3timeprint(fmt, &x->timePrec);
3635 		fmtprint(fmt, "\n");
3636 		fmtprint(fmt, "\t%s=", "flags");
3637 		fmtprint(fmt, "%ud", x->flags);
3638 		fmtprint(fmt, "\n");
3639 		break;
3640 	}
3641 }
3642 uint
3643 nfs3rfsinfosize(Nfs3RFsInfo *x)
3644 {
3645 	uint a;
3646 	USED(x);
3647 	a = 0 + 4 + 4;
3648 	switch(x->haveAttr){
3649 	case 1:
3650 		a = a + nfs3attrsize(&x->attr);
3651 		break;
3652 	}
3653 	switch(x->status){
3654 	case Nfs3Ok:
3655 		a = a + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 8 + nfs3timesize(&x->timePrec) + 4;
3656 		break;
3657 	}
3658 	return a;
3659 }
3660 int
3661 nfs3rfsinfopack(uchar *a, uchar *ea, uchar **pa, Nfs3RFsInfo *x)
3662 {
3663 	int i;
3664 
3665 	if(i=x->status, sunenumpack(a, ea, &a, &i) < 0) goto Err;
3666 	if(sunuint1pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
3667 	switch(x->haveAttr){
3668 	case 1:
3669 		if(nfs3attrpack(a, ea, &a, &x->attr) < 0) goto Err;
3670 		break;
3671 	}
3672 	switch(x->status){
3673 	case Nfs3Ok:
3674 		if(sunuint32pack(a, ea, &a, &x->readMax) < 0) goto Err;
3675 		if(sunuint32pack(a, ea, &a, &x->readPref) < 0) goto Err;
3676 		if(sunuint32pack(a, ea, &a, &x->readMult) < 0) goto Err;
3677 		if(sunuint32pack(a, ea, &a, &x->writeMax) < 0) goto Err;
3678 		if(sunuint32pack(a, ea, &a, &x->writePref) < 0) goto Err;
3679 		if(sunuint32pack(a, ea, &a, &x->writeMult) < 0) goto Err;
3680 		if(sunuint32pack(a, ea, &a, &x->readDirPref) < 0) goto Err;
3681 		if(sunuint64pack(a, ea, &a, &x->maxFileSize) < 0) goto Err;
3682 		if(nfs3timepack(a, ea, &a, &x->timePrec) < 0) goto Err;
3683 		if(sunuint32pack(a, ea, &a, &x->flags) < 0) goto Err;
3684 		break;
3685 	}
3686 	*pa = a;
3687 	return 0;
3688 Err:
3689 	*pa = ea;
3690 	return -1;
3691 }
3692 int
3693 nfs3rfsinfounpack(uchar *a, uchar *ea, uchar **pa, Nfs3RFsInfo *x)
3694 {
3695 	int i;
3696 
3697 	if(sunenumunpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
3698 	if(sunuint1unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
3699 	switch(x->haveAttr){
3700 	case 1:
3701 		if(nfs3attrunpack(a, ea, &a, &x->attr) < 0) goto Err;
3702 		break;
3703 	}
3704 	switch(x->status){
3705 	case Nfs3Ok:
3706 		if(sunuint32unpack(a, ea, &a, &x->readMax) < 0) goto Err;
3707 		if(sunuint32unpack(a, ea, &a, &x->readPref) < 0) goto Err;
3708 		if(sunuint32unpack(a, ea, &a, &x->readMult) < 0) goto Err;
3709 		if(sunuint32unpack(a, ea, &a, &x->writeMax) < 0) goto Err;
3710 		if(sunuint32unpack(a, ea, &a, &x->writePref) < 0) goto Err;
3711 		if(sunuint32unpack(a, ea, &a, &x->writeMult) < 0) goto Err;
3712 		if(sunuint32unpack(a, ea, &a, &x->readDirPref) < 0) goto Err;
3713 		if(sunuint64unpack(a, ea, &a, &x->maxFileSize) < 0) goto Err;
3714 		if(nfs3timeunpack(a, ea, &a, &x->timePrec) < 0) goto Err;
3715 		if(sunuint32unpack(a, ea, &a, &x->flags) < 0) goto Err;
3716 		break;
3717 	}
3718 	*pa = a;
3719 	return 0;
3720 Err:
3721 	*pa = ea;
3722 	return -1;
3723 }
3724 void
3725 nfs3tpathconfprint(Fmt *fmt, Nfs3TPathconf *x)
3726 {
3727 	fmtprint(fmt, "%s\n", "Nfs3TPathconf");
3728 	fmtprint(fmt, "\t%s=", "handle");
3729 	nfs3handleprint(fmt, &x->handle);
3730 	fmtprint(fmt, "\n");
3731 }
3732 uint
3733 nfs3tpathconfsize(Nfs3TPathconf *x)
3734 {
3735 	uint a;
3736 	USED(x);
3737 	a = 0 + nfs3handlesize(&x->handle);
3738 	return a;
3739 }
3740 int
3741 nfs3tpathconfpack(uchar *a, uchar *ea, uchar **pa, Nfs3TPathconf *x)
3742 {
3743 	if(nfs3handlepack(a, ea, &a, &x->handle) < 0) goto Err;
3744 	*pa = a;
3745 	return 0;
3746 Err:
3747 	*pa = ea;
3748 	return -1;
3749 }
3750 int
3751 nfs3tpathconfunpack(uchar *a, uchar *ea, uchar **pa, Nfs3TPathconf *x)
3752 {
3753 	if(nfs3handleunpack(a, ea, &a, &x->handle) < 0) goto Err;
3754 	*pa = a;
3755 	return 0;
3756 Err:
3757 	*pa = ea;
3758 	return -1;
3759 }
3760 void
3761 nfs3rpathconfprint(Fmt *fmt, Nfs3RPathconf *x)
3762 {
3763 	fmtprint(fmt, "%s\n", "Nfs3RPathconf");
3764 	fmtprint(fmt, "\t%s=", "status");
3765 	fmtprint(fmt, "%s", nfs3statusstr(x->status));
3766 	fmtprint(fmt, "\n");
3767 	fmtprint(fmt, "\t%s=", "haveAttr");
3768 	fmtprint(fmt, "%d", x->haveAttr);
3769 	fmtprint(fmt, "\n");
3770 	switch(x->haveAttr){
3771 	case 1:
3772 		fmtprint(fmt, "\t%s=", "attr");
3773 		nfs3attrprint(fmt, &x->attr);
3774 		fmtprint(fmt, "\n");
3775 		break;
3776 	}
3777 	switch(x->status){
3778 	case Nfs3Ok:
3779 		fmtprint(fmt, "\t%s=", "maxLink");
3780 		fmtprint(fmt, "%ud", x->maxLink);
3781 		fmtprint(fmt, "\n");
3782 		fmtprint(fmt, "\t%s=", "maxName");
3783 		fmtprint(fmt, "%ud", x->maxName);
3784 		fmtprint(fmt, "\n");
3785 		fmtprint(fmt, "\t%s=", "noTrunc");
3786 		fmtprint(fmt, "%d", x->noTrunc);
3787 		fmtprint(fmt, "\n");
3788 		fmtprint(fmt, "\t%s=", "chownRestricted");
3789 		fmtprint(fmt, "%d", x->chownRestricted);
3790 		fmtprint(fmt, "\n");
3791 		fmtprint(fmt, "\t%s=", "caseInsensitive");
3792 		fmtprint(fmt, "%d", x->caseInsensitive);
3793 		fmtprint(fmt, "\n");
3794 		fmtprint(fmt, "\t%s=", "casePreserving");
3795 		fmtprint(fmt, "%d", x->casePreserving);
3796 		fmtprint(fmt, "\n");
3797 		break;
3798 	}
3799 }
3800 uint
3801 nfs3rpathconfsize(Nfs3RPathconf *x)
3802 {
3803 	uint a;
3804 	USED(x);
3805 	a = 0 + 4 + 4;
3806 	switch(x->haveAttr){
3807 	case 1:
3808 		a = a + nfs3attrsize(&x->attr);
3809 		break;
3810 	}
3811 	switch(x->status){
3812 	case Nfs3Ok:
3813 		a = a + 4 + 4 + 4 + 4 + 4 + 4;
3814 		break;
3815 	}
3816 	return a;
3817 }
3818 int
3819 nfs3rpathconfpack(uchar *a, uchar *ea, uchar **pa, Nfs3RPathconf *x)
3820 {
3821 	int i;
3822 
3823 	if(i=x->status, sunenumpack(a, ea, &a, &i) < 0) goto Err;
3824 	if(sunuint1pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
3825 	switch(x->haveAttr){
3826 	case 1:
3827 		if(nfs3attrpack(a, ea, &a, &x->attr) < 0) goto Err;
3828 		break;
3829 	}
3830 	switch(x->status){
3831 	case Nfs3Ok:
3832 		if(sunuint32pack(a, ea, &a, &x->maxLink) < 0) goto Err;
3833 		if(sunuint32pack(a, ea, &a, &x->maxName) < 0) goto Err;
3834 		if(sunuint1pack(a, ea, &a, &x->noTrunc) < 0) goto Err;
3835 		if(sunuint1pack(a, ea, &a, &x->chownRestricted) < 0) goto Err;
3836 		if(sunuint1pack(a, ea, &a, &x->caseInsensitive) < 0) goto Err;
3837 		if(sunuint1pack(a, ea, &a, &x->casePreserving) < 0) goto Err;
3838 		break;
3839 	}
3840 	*pa = a;
3841 	return 0;
3842 Err:
3843 	*pa = ea;
3844 	return -1;
3845 }
3846 int
3847 nfs3rpathconfunpack(uchar *a, uchar *ea, uchar **pa, Nfs3RPathconf *x)
3848 {
3849 	int i;
3850 
3851 	if(sunenumunpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
3852 	if(sunuint1unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
3853 	switch(x->haveAttr){
3854 	case 1:
3855 		if(nfs3attrunpack(a, ea, &a, &x->attr) < 0) goto Err;
3856 		break;
3857 	}
3858 	switch(x->status){
3859 	case Nfs3Ok:
3860 		if(sunuint32unpack(a, ea, &a, &x->maxLink) < 0) goto Err;
3861 		if(sunuint32unpack(a, ea, &a, &x->maxName) < 0) goto Err;
3862 		if(sunuint1unpack(a, ea, &a, &x->noTrunc) < 0) goto Err;
3863 		if(sunuint1unpack(a, ea, &a, &x->chownRestricted) < 0) goto Err;
3864 		if(sunuint1unpack(a, ea, &a, &x->caseInsensitive) < 0) goto Err;
3865 		if(sunuint1unpack(a, ea, &a, &x->casePreserving) < 0) goto Err;
3866 		break;
3867 	}
3868 	*pa = a;
3869 	return 0;
3870 Err:
3871 	*pa = ea;
3872 	return -1;
3873 }
3874 void
3875 nfs3tcommitprint(Fmt *fmt, Nfs3TCommit *x)
3876 {
3877 	fmtprint(fmt, "%s\n", "Nfs3TCommit");
3878 	fmtprint(fmt, "\t%s=", "handle");
3879 	nfs3handleprint(fmt, &x->handle);
3880 	fmtprint(fmt, "\n");
3881 	fmtprint(fmt, "\t%s=", "offset");
3882 	fmtprint(fmt, "%llud", x->offset);
3883 	fmtprint(fmt, "\n");
3884 	fmtprint(fmt, "\t%s=", "count");
3885 	fmtprint(fmt, "%ud", x->count);
3886 	fmtprint(fmt, "\n");
3887 }
3888 uint
3889 nfs3tcommitsize(Nfs3TCommit *x)
3890 {
3891 	uint a;
3892 	USED(x);
3893 	a = 0 + nfs3handlesize(&x->handle) + 8 + 4;
3894 	return a;
3895 }
3896 int
3897 nfs3tcommitpack(uchar *a, uchar *ea, uchar **pa, Nfs3TCommit *x)
3898 {
3899 	if(nfs3handlepack(a, ea, &a, &x->handle) < 0) goto Err;
3900 	if(sunuint64pack(a, ea, &a, &x->offset) < 0) goto Err;
3901 	if(sunuint32pack(a, ea, &a, &x->count) < 0) goto Err;
3902 	*pa = a;
3903 	return 0;
3904 Err:
3905 	*pa = ea;
3906 	return -1;
3907 }
3908 int
3909 nfs3tcommitunpack(uchar *a, uchar *ea, uchar **pa, Nfs3TCommit *x)
3910 {
3911 	if(nfs3handleunpack(a, ea, &a, &x->handle) < 0) goto Err;
3912 	if(sunuint64unpack(a, ea, &a, &x->offset) < 0) goto Err;
3913 	if(sunuint32unpack(a, ea, &a, &x->count) < 0) goto Err;
3914 	*pa = a;
3915 	return 0;
3916 Err:
3917 	*pa = ea;
3918 	return -1;
3919 }
3920 void
3921 nfs3rcommitprint(Fmt *fmt, Nfs3RCommit *x)
3922 {
3923 	fmtprint(fmt, "%s\n", "Nfs3RCommit");
3924 	fmtprint(fmt, "\t%s=", "status");
3925 	fmtprint(fmt, "%s", nfs3statusstr(x->status));
3926 	fmtprint(fmt, "\n");
3927 	fmtprint(fmt, "\t%s=", "wcc");
3928 	nfs3wccprint(fmt, &x->wcc);
3929 	fmtprint(fmt, "\n");
3930 	switch(x->status){
3931 	case Nfs3Ok:
3932 		fmtprint(fmt, "\t%s=", "verf");
3933 		fmtprint(fmt, "%.*H", Nfs3WriteVerfSize, x->verf);
3934 		fmtprint(fmt, "\n");
3935 		break;
3936 	}
3937 }
3938 uint
3939 nfs3rcommitsize(Nfs3RCommit *x)
3940 {
3941 	uint a;
3942 	USED(x);
3943 	a = 0 + 4 + nfs3wccsize(&x->wcc);
3944 	switch(x->status){
3945 	case Nfs3Ok:
3946 		a = a + Nfs3WriteVerfSize;
3947 		break;
3948 	}
3949 	return a;
3950 }
3951 int
3952 nfs3rcommitpack(uchar *a, uchar *ea, uchar **pa, Nfs3RCommit *x)
3953 {
3954 	int i;
3955 
3956 	if(i=x->status, sunenumpack(a, ea, &a, &i) < 0) goto Err;
3957 	if(nfs3wccpack(a, ea, &a, &x->wcc) < 0) goto Err;
3958 	switch(x->status){
3959 	case Nfs3Ok:
3960 		if(sunfixedopaquepack(a, ea, &a, x->verf, Nfs3WriteVerfSize) < 0) goto Err;
3961 		break;
3962 	}
3963 	*pa = a;
3964 	return 0;
3965 Err:
3966 	*pa = ea;
3967 	return -1;
3968 }
3969 int
3970 nfs3rcommitunpack(uchar *a, uchar *ea, uchar **pa, Nfs3RCommit *x)
3971 {
3972 	int i;
3973 
3974 	if(sunenumunpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
3975 	if(nfs3wccunpack(a, ea, &a, &x->wcc) < 0) goto Err;
3976 	switch(x->status){
3977 	case Nfs3Ok:
3978 		if(sunfixedopaqueunpack(a, ea, &a, x->verf, Nfs3WriteVerfSize) < 0) goto Err;
3979 		break;
3980 	}
3981 	*pa = a;
3982 	return 0;
3983 Err:
3984 	*pa = ea;
3985 	return -1;
3986 }
3987 
3988 typedef int (*P)(uchar*, uchar*, uchar**, SunCall*);
3989 typedef void (*F)(Fmt*, SunCall*);
3990 typedef uint (*S)(SunCall*);
3991 
3992 static SunProc proc[] = {
3993 	(P)nfs3tnullpack, (P)nfs3tnullunpack, (S)nfs3tnullsize, (F)nfs3tnullprint, sizeof(Nfs3TNull),
3994 	(P)nfs3rnullpack, (P)nfs3rnullunpack, (S)nfs3rnullsize, (F)nfs3rnullprint, sizeof(Nfs3RNull),
3995 	(P)nfs3tgetattrpack, (P)nfs3tgetattrunpack, (S)nfs3tgetattrsize, (F)nfs3tgetattrprint, sizeof(Nfs3TGetattr),
3996 	(P)nfs3rgetattrpack, (P)nfs3rgetattrunpack, (S)nfs3rgetattrsize, (F)nfs3rgetattrprint, sizeof(Nfs3RGetattr),
3997 	(P)nfs3tsetattrpack, (P)nfs3tsetattrunpack, (S)nfs3tsetattrsize, (F)nfs3tsetattrprint, sizeof(Nfs3TSetattr),
3998 	(P)nfs3rsetattrpack, (P)nfs3rsetattrunpack, (S)nfs3rsetattrsize, (F)nfs3rsetattrprint, sizeof(Nfs3RSetattr),
3999 	(P)nfs3tlookuppack, (P)nfs3tlookupunpack, (S)nfs3tlookupsize, (F)nfs3tlookupprint, sizeof(Nfs3TLookup),
4000 	(P)nfs3rlookuppack, (P)nfs3rlookupunpack, (S)nfs3rlookupsize, (F)nfs3rlookupprint, sizeof(Nfs3RLookup),
4001 	(P)nfs3taccesspack, (P)nfs3taccessunpack, (S)nfs3taccesssize, (F)nfs3taccessprint, sizeof(Nfs3TAccess),
4002 	(P)nfs3raccesspack, (P)nfs3raccessunpack, (S)nfs3raccesssize, (F)nfs3raccessprint, sizeof(Nfs3RAccess),
4003 	(P)nfs3treadlinkpack, (P)nfs3treadlinkunpack, (S)nfs3treadlinksize, (F)nfs3treadlinkprint, sizeof(Nfs3TReadlink),
4004 	(P)nfs3rreadlinkpack, (P)nfs3rreadlinkunpack, (S)nfs3rreadlinksize, (F)nfs3rreadlinkprint, sizeof(Nfs3RReadlink),
4005 	(P)nfs3treadpack, (P)nfs3treadunpack, (S)nfs3treadsize, (F)nfs3treadprint, sizeof(Nfs3TRead),
4006 	(P)nfs3rreadpack, (P)nfs3rreadunpack, (S)nfs3rreadsize, (F)nfs3rreadprint, sizeof(Nfs3RRead),
4007 	(P)nfs3twritepack, (P)nfs3twriteunpack, (S)nfs3twritesize, (F)nfs3twriteprint, sizeof(Nfs3TWrite),
4008 	(P)nfs3rwritepack, (P)nfs3rwriteunpack, (S)nfs3rwritesize, (F)nfs3rwriteprint, sizeof(Nfs3RWrite),
4009 	(P)nfs3tcreatepack, (P)nfs3tcreateunpack, (S)nfs3tcreatesize, (F)nfs3tcreateprint, sizeof(Nfs3TCreate),
4010 	(P)nfs3rcreatepack, (P)nfs3rcreateunpack, (S)nfs3rcreatesize, (F)nfs3rcreateprint, sizeof(Nfs3RCreate),
4011 	(P)nfs3tmkdirpack, (P)nfs3tmkdirunpack, (S)nfs3tmkdirsize, (F)nfs3tmkdirprint, sizeof(Nfs3TMkdir),
4012 	(P)nfs3rmkdirpack, (P)nfs3rmkdirunpack, (S)nfs3rmkdirsize, (F)nfs3rmkdirprint, sizeof(Nfs3RMkdir),
4013 	(P)nfs3tsymlinkpack, (P)nfs3tsymlinkunpack, (S)nfs3tsymlinksize, (F)nfs3tsymlinkprint, sizeof(Nfs3TSymlink),
4014 	(P)nfs3rsymlinkpack, (P)nfs3rsymlinkunpack, (S)nfs3rsymlinksize, (F)nfs3rsymlinkprint, sizeof(Nfs3RSymlink),
4015 	(P)nfs3tmknodpack, (P)nfs3tmknodunpack, (S)nfs3tmknodsize, (F)nfs3tmknodprint, sizeof(Nfs3TMknod),
4016 	(P)nfs3rmknodpack, (P)nfs3rmknodunpack, (S)nfs3rmknodsize, (F)nfs3rmknodprint, sizeof(Nfs3RMknod),
4017 	(P)nfs3tremovepack, (P)nfs3tremoveunpack, (S)nfs3tremovesize, (F)nfs3tremoveprint, sizeof(Nfs3TRemove),
4018 	(P)nfs3rremovepack, (P)nfs3rremoveunpack, (S)nfs3rremovesize, (F)nfs3rremoveprint, sizeof(Nfs3RRemove),
4019 	(P)nfs3trmdirpack, (P)nfs3trmdirunpack, (S)nfs3trmdirsize, (F)nfs3trmdirprint, sizeof(Nfs3TRmdir),
4020 	(P)nfs3rrmdirpack, (P)nfs3rrmdirunpack, (S)nfs3rrmdirsize, (F)nfs3rrmdirprint, sizeof(Nfs3RRmdir),
4021 	(P)nfs3trenamepack, (P)nfs3trenameunpack, (S)nfs3trenamesize, (F)nfs3trenameprint, sizeof(Nfs3TRename),
4022 	(P)nfs3rrenamepack, (P)nfs3rrenameunpack, (S)nfs3rrenamesize, (F)nfs3rrenameprint, sizeof(Nfs3RRename),
4023 	(P)nfs3tlinkpack, (P)nfs3tlinkunpack, (S)nfs3tlinksize, (F)nfs3tlinkprint, sizeof(Nfs3TLink),
4024 	(P)nfs3rlinkpack, (P)nfs3rlinkunpack, (S)nfs3rlinksize, (F)nfs3rlinkprint, sizeof(Nfs3RLink),
4025 	(P)nfs3treaddirpack, (P)nfs3treaddirunpack, (S)nfs3treaddirsize, (F)nfs3treaddirprint, sizeof(Nfs3TReadDir),
4026 	(P)nfs3rreaddirpack, (P)nfs3rreaddirunpack, (S)nfs3rreaddirsize, (F)nfs3rreaddirprint, sizeof(Nfs3RReadDir),
4027 	(P)nfs3treaddirpluspack, (P)nfs3treaddirplusunpack, (S)nfs3treaddirplussize, (F)nfs3treaddirplusprint, sizeof(Nfs3TReadDirPlus),
4028 	(P)nfs3rreaddirpluspack, (P)nfs3rreaddirplusunpack, (S)nfs3rreaddirplussize, (F)nfs3rreaddirplusprint, sizeof(Nfs3RReadDirPlus),
4029 	(P)nfs3tfsstatpack, (P)nfs3tfsstatunpack, (S)nfs3tfsstatsize, (F)nfs3tfsstatprint, sizeof(Nfs3TFsStat),
4030 	(P)nfs3rfsstatpack, (P)nfs3rfsstatunpack, (S)nfs3rfsstatsize, (F)nfs3rfsstatprint, sizeof(Nfs3RFsStat),
4031 	(P)nfs3tfsinfopack, (P)nfs3tfsinfounpack, (S)nfs3tfsinfosize, (F)nfs3tfsinfoprint, sizeof(Nfs3TFsInfo),
4032 	(P)nfs3rfsinfopack, (P)nfs3rfsinfounpack, (S)nfs3rfsinfosize, (F)nfs3rfsinfoprint, sizeof(Nfs3RFsInfo),
4033 	(P)nfs3tpathconfpack, (P)nfs3tpathconfunpack, (S)nfs3tpathconfsize, (F)nfs3tpathconfprint, sizeof(Nfs3TPathconf),
4034 	(P)nfs3rpathconfpack, (P)nfs3rpathconfunpack, (S)nfs3rpathconfsize, (F)nfs3rpathconfprint, sizeof(Nfs3RPathconf),
4035 	(P)nfs3tcommitpack, (P)nfs3tcommitunpack, (S)nfs3tcommitsize, (F)nfs3tcommitprint, sizeof(Nfs3TCommit),
4036 	(P)nfs3rcommitpack, (P)nfs3rcommitunpack, (S)nfs3rcommitsize, (F)nfs3rcommitprint, sizeof(Nfs3RCommit)
4037 };
4038 
4039 SunProg nfs3prog = 
4040 {
4041 	Nfs3Program,
4042 	Nfs3Version,
4043 	proc,
4044 	nelem(proc),
4045 };