Subversion Repositories planix.SVN

Rev

Rev 2 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2 - 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 
};