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