1 #include <u.h>
2 #include <libc.h>
3 #include <thread.h>
4 #include <sunrpc.h>
5 #include <nfs3.h>
6
7 char*
nfs3StatusStr(Nfs3Status x)8 nfs3StatusStr(Nfs3Status x)
9 {
10 switch(x){
11 case Nfs3Ok:
12 return "Nfs3Ok";
13 case Nfs3ErrNotOwner:
14 return "Nfs3ErrNotOwner";
15 case Nfs3ErrNoEnt:
16 return "Nfs3ErrNoEnt";
17 case Nfs3ErrNoMem:
18 return "Nfs3ErrNoMem";
19 case Nfs3ErrIo:
20 return "Nfs3ErrIo";
21 case Nfs3ErrNxio:
22 return "Nfs3ErrNxio";
23 case Nfs3ErrAcces:
24 return "Nfs3ErrAcces";
25 case Nfs3ErrExist:
26 return "Nfs3ErrExist";
27 case Nfs3ErrXDev:
28 return "Nfs3ErrXDev";
29 case Nfs3ErrNoDev:
30 return "Nfs3ErrNoDev";
31 case Nfs3ErrNotDir:
32 return "Nfs3ErrNotDir";
33 case Nfs3ErrIsDir:
34 return "Nfs3ErrIsDir";
35 case Nfs3ErrInval:
36 return "Nfs3ErrInval";
37 case Nfs3ErrFbig:
38 return "Nfs3ErrFbig";
39 case Nfs3ErrNoSpc:
40 return "Nfs3ErrNoSpc";
41 case Nfs3ErrRoFs:
42 return "Nfs3ErrRoFs";
43 case Nfs3ErrMLink:
44 return "Nfs3ErrMLink";
45 case Nfs3ErrNameTooLong:
46 return "Nfs3ErrNameTooLong";
47 case Nfs3ErrNotEmpty:
48 return "Nfs3ErrNotEmpty";
49 case Nfs3ErrDQuot:
50 return "Nfs3ErrDQuot";
51 case Nfs3ErrStale:
52 return "Nfs3ErrStale";
53 case Nfs3ErrRemote:
54 return "Nfs3ErrRemote";
55 case Nfs3ErrBadHandle:
56 return "Nfs3ErrBadHandle";
57 case Nfs3ErrNotSync:
58 return "Nfs3ErrNotSync";
59 case Nfs3ErrBadCookie:
60 return "Nfs3ErrBadCookie";
61 case Nfs3ErrNotSupp:
62 return "Nfs3ErrNotSupp";
63 case Nfs3ErrTooSmall:
64 return "Nfs3ErrTooSmall";
65 case Nfs3ErrServerFault:
66 return "Nfs3ErrServerFault";
67 case Nfs3ErrBadType:
68 return "Nfs3ErrBadType";
69 case Nfs3ErrJukebox:
70 return "Nfs3ErrJukebox";
71 case Nfs3ErrFprintNotFound:
72 return "Nfs3ErrFprintNotFound";
73 case Nfs3ErrAborted:
74 return "Nfs3ErrAborted";
75 default:
76 return "unknown";
77 }
78 }
79
80 static struct {
81 SunStatus status;
82 char *msg;
83 } etab[] = {
84 Nfs3ErrNotOwner, "not owner",
85 Nfs3ErrNoEnt, "directory entry not found",
86 Nfs3ErrIo, "i/o error",
87 Nfs3ErrNxio, "no such device",
88 Nfs3ErrNoMem, "out of memory",
89 Nfs3ErrAcces, "access denied",
90 Nfs3ErrExist, "file or directory exists",
91 Nfs3ErrXDev, "cross-device operation",
92 Nfs3ErrNoDev, "no such device",
93 Nfs3ErrNotDir, "not a directory",
94 Nfs3ErrIsDir, "is a directory",
95 Nfs3ErrInval, "invalid arguments",
96 Nfs3ErrFbig, "file too big",
97 Nfs3ErrNoSpc, "no space left on device",
98 Nfs3ErrRoFs, "read-only file system",
99 Nfs3ErrMLink, "too many links",
100 Nfs3ErrNameTooLong, "name too long",
101 Nfs3ErrNotEmpty, "directory not empty",
102 Nfs3ErrDQuot, "dquot",
103 Nfs3ErrStale, "stale handle",
104 Nfs3ErrRemote, "remote error",
105 Nfs3ErrBadHandle, "bad handle",
106 Nfs3ErrNotSync, "out of sync with server",
107 Nfs3ErrBadCookie, "bad cookie",
108 Nfs3ErrNotSupp, "not supported",
109 Nfs3ErrTooSmall, "too small",
110 Nfs3ErrServerFault, "server fault",
111 Nfs3ErrBadType, "bad type",
112 Nfs3ErrJukebox, "jukebox -- try again later",
113 Nfs3ErrFprintNotFound, "fprint not found",
114 Nfs3ErrAborted, "aborted",
115 };
116
117 void
nfs3Errstr(SunStatus status)118 nfs3Errstr(SunStatus status)
119 {
120 int i;
121
122 for(i=0; i<nelem(etab); i++){
123 if(etab[i].status == status){
124 werrstr(etab[i].msg);
125 return;
126 }
127 }
128 werrstr("unknown nfs3 error %d", (int)status);
129 }
130
131 char*
nfs3FileTypeStr(Nfs3FileType x)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
nfs3HandlePrint(Fmt * fmt,Nfs3Handle * x)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
nfs3HandleSize(Nfs3Handle * x)166 nfs3HandleSize(Nfs3Handle *x)
167 {
168 uint a;
169 USED(x);
170 a = 0 + sunVarOpaqueSize(x->len);
171 return a;
172 }
173 int
nfs3HandlePack(uchar * a,uchar * ea,uchar ** pa,Nfs3Handle * x)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
nfs3HandleUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3Handle * x)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
nfs3TimePrint(Fmt * fmt,Nfs3Time * x)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
nfs3TimeSize(Nfs3Time * x)217 nfs3TimeSize(Nfs3Time *x)
218 {
219 uint a;
220 USED(x);
221 a = 0 + 4 + 4;
222 return a;
223 }
224 int
nfs3TimePack(uchar * a,uchar * ea,uchar ** pa,Nfs3Time * x)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
nfs3TimeUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3Time * x)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
nfs3AttrPrint(Fmt * fmt,Nfs3Attr * x)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
nfs3AttrSize(Nfs3Attr * x)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
nfs3AttrPack(uchar * a,uchar * ea,uchar ** pa,Nfs3Attr * x)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
nfs3AttrUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3Attr * x)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
nfs3WccAttrPrint(Fmt * fmt,Nfs3WccAttr * x)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
nfs3WccAttrSize(Nfs3WccAttr * x)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
nfs3WccAttrPack(uchar * a,uchar * ea,uchar ** pa,Nfs3WccAttr * x)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
nfs3WccAttrUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3WccAttr * x)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
nfs3WccPrint(Fmt * fmt,Nfs3Wcc * x)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
nfs3WccSize(Nfs3Wcc * x)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
nfs3WccPack(uchar * a,uchar * ea,uchar ** pa,Nfs3Wcc * x)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
nfs3WccUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3Wcc * x)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*
nfs3SetTimeStr(Nfs3SetTime x)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
nfs3SetAttrPrint(Fmt * fmt,Nfs3SetAttr * x)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
nfs3SetAttrSize(Nfs3SetAttr * x)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
nfs3SetAttrPack(uchar * a,uchar * ea,uchar ** pa,Nfs3SetAttr * x)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
nfs3SetAttrUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3SetAttr * x)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
nfs3TNullPrint(Fmt * fmt,Nfs3TNull * x)700 nfs3TNullPrint(Fmt *fmt, Nfs3TNull *x)
701 {
702 USED(x);
703 fmtprint(fmt, "%s\n", "Nfs3TNull");
704 }
705 uint
nfs3TNullSize(Nfs3TNull * x)706 nfs3TNullSize(Nfs3TNull *x)
707 {
708 uint a;
709 USED(x);
710 a = 0;
711 return a;
712 }
713 int
nfs3TNullPack(uchar * a,uchar * ea,uchar ** pa,Nfs3TNull * x)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
nfs3TNullUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3TNull * x)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
nfs3RNullPrint(Fmt * fmt,Nfs3RNull * x)730 nfs3RNullPrint(Fmt *fmt, Nfs3RNull *x)
731 {
732 USED(x);
733 fmtprint(fmt, "%s\n", "Nfs3RNull");
734 }
735 uint
nfs3RNullSize(Nfs3RNull * x)736 nfs3RNullSize(Nfs3RNull *x)
737 {
738 uint a;
739 USED(x);
740 a = 0;
741 return a;
742 }
743 int
nfs3RNullPack(uchar * a,uchar * ea,uchar ** pa,Nfs3RNull * x)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
nfs3RNullUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3RNull * x)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
nfs3TGetattrPrint(Fmt * fmt,Nfs3TGetattr * x)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
nfs3TGetattrSize(Nfs3TGetattr * x)768 nfs3TGetattrSize(Nfs3TGetattr *x)
769 {
770 uint a;
771 USED(x);
772 a = 0 + nfs3HandleSize(&x->handle);
773 return a;
774 }
775 int
nfs3TGetattrPack(uchar * a,uchar * ea,uchar ** pa,Nfs3TGetattr * x)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
nfs3TGetattrUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3TGetattr * x)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
nfs3RGetattrPrint(Fmt * fmt,Nfs3RGetattr * x)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
nfs3RGetattrSize(Nfs3RGetattr * x)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
nfs3RGetattrPack(uchar * a,uchar * ea,uchar ** pa,Nfs3RGetattr * x)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
nfs3RGetattrUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3RGetattr * x)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
nfs3TSetattrPrint(Fmt * fmt,Nfs3TSetattr * x)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
nfs3TSetattrSize(Nfs3TSetattr * x)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
nfs3TSetattrPack(uchar * a,uchar * ea,uchar ** pa,Nfs3TSetattr * x)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
nfs3TSetattrUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3TSetattr * x)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
nfs3RSetattrPrint(Fmt * fmt,Nfs3RSetattr * x)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
nfs3RSetattrSize(Nfs3RSetattr * x)937 nfs3RSetattrSize(Nfs3RSetattr *x)
938 {
939 uint a;
940 USED(x);
941 a = 0 + 4 + nfs3WccSize(&x->wcc);
942 return a;
943 }
944 int
nfs3RSetattrPack(uchar * a,uchar * ea,uchar ** pa,Nfs3RSetattr * x)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
nfs3RSetattrUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3RSetattr * x)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
nfs3TLookupPrint(Fmt * fmt,Nfs3TLookup * x)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
nfs3TLookupSize(Nfs3TLookup * x)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
nfs3TLookupPack(uchar * a,uchar * ea,uchar ** pa,Nfs3TLookup * x)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
nfs3TLookupUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3TLookup * x)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
nfs3RLookupPrint(Fmt * fmt,Nfs3RLookup * x)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
nfs3RLookupSize(Nfs3RLookup * x)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
nfs3RLookupPack(uchar * a,uchar * ea,uchar ** pa,Nfs3RLookup * x)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
nfs3RLookupUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3RLookup * x)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
nfs3TAccessPrint(Fmt * fmt,Nfs3TAccess * x)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
nfs3TAccessSize(Nfs3TAccess * x)1140 nfs3TAccessSize(Nfs3TAccess *x)
1141 {
1142 uint a;
1143 USED(x);
1144 a = 0 + nfs3HandleSize(&x->handle) + 4;
1145 return a;
1146 }
1147 int
nfs3TAccessPack(uchar * a,uchar * ea,uchar ** pa,Nfs3TAccess * x)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
nfs3TAccessUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3TAccess * x)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
nfs3RAccessPrint(Fmt * fmt,Nfs3RAccess * x)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
nfs3RAccessSize(Nfs3RAccess * x)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
nfs3RAccessPack(uchar * a,uchar * ea,uchar ** pa,Nfs3RAccess * x)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
nfs3RAccessUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3RAccess * x)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
nfs3TReadlinkPrint(Fmt * fmt,Nfs3TReadlink * x)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
nfs3TReadlinkSize(Nfs3TReadlink * x)1267 nfs3TReadlinkSize(Nfs3TReadlink *x)
1268 {
1269 uint a;
1270 USED(x);
1271 a = 0 + nfs3HandleSize(&x->handle);
1272 return a;
1273 }
1274 int
nfs3TReadlinkPack(uchar * a,uchar * ea,uchar ** pa,Nfs3TReadlink * x)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
nfs3TReadlinkUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3TReadlink * x)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
nfs3RReadlinkPrint(Fmt * fmt,Nfs3RReadlink * x)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
nfs3RReadlinkSize(Nfs3RReadlink * x)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
nfs3RReadlinkPack(uchar * a,uchar * ea,uchar ** pa,Nfs3RReadlink * x)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
nfs3RReadlinkUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3RReadlink * x)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
nfs3TReadPrint(Fmt * fmt,Nfs3TRead * x)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
nfs3TReadSize(Nfs3TRead * x)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
nfs3TReadPack(uchar * a,uchar * ea,uchar ** pa,Nfs3TRead * x)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
nfs3TReadUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3TRead * x)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
nfs3RReadPrint(Fmt * fmt,Nfs3RRead * x)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
nfs3RReadSize(Nfs3RRead * x)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
nfs3RReadPack(uchar * a,uchar * ea,uchar ** pa,Nfs3RRead * x)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
nfs3RReadUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3RRead * x)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*
nfs3SyncStr(Nfs3Sync x)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
nfs3TWritePrint(Fmt * fmt,Nfs3TWrite * x)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
nfs3TWriteSize(Nfs3TWrite * x)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
nfs3TWritePack(uchar * a,uchar * ea,uchar ** pa,Nfs3TWrite * x)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
nfs3TWriteUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3TWrite * x)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
nfs3RWritePrint(Fmt * fmt,Nfs3RWrite * x)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
nfs3RWriteSize(Nfs3RWrite * x)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
nfs3RWritePack(uchar * a,uchar * ea,uchar ** pa,Nfs3RWrite * x)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
nfs3RWriteUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3RWrite * x)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*
nfs3CreateStr(Nfs3Create x)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
nfs3TCreatePrint(Fmt * fmt,Nfs3TCreate * x)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
nfs3TCreateSize(Nfs3TCreate * x)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
nfs3TCreatePack(uchar * a,uchar * ea,uchar ** pa,Nfs3TCreate * x)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
nfs3TCreateUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3TCreate * x)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
nfs3RCreatePrint(Fmt * fmt,Nfs3RCreate * x)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
nfs3RCreateSize(Nfs3RCreate * x)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
nfs3RCreatePack(uchar * a,uchar * ea,uchar ** pa,Nfs3RCreate * x)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
nfs3RCreateUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3RCreate * x)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
nfs3TMkdirPrint(Fmt * fmt,Nfs3TMkdir * x)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
nfs3TMkdirSize(Nfs3TMkdir * x)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
nfs3TMkdirPack(uchar * a,uchar * ea,uchar ** pa,Nfs3TMkdir * x)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
nfs3TMkdirUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3TMkdir * x)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
nfs3RMkdirPrint(Fmt * fmt,Nfs3RMkdir * x)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
nfs3RMkdirSize(Nfs3RMkdir * x)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
nfs3RMkdirPack(uchar * a,uchar * ea,uchar ** pa,Nfs3RMkdir * x)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
nfs3RMkdirUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3RMkdir * x)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
nfs3TSymlinkPrint(Fmt * fmt,Nfs3TSymlink * x)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
nfs3TSymlinkSize(Nfs3TSymlink * x)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
nfs3TSymlinkPack(uchar * a,uchar * ea,uchar ** pa,Nfs3TSymlink * x)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
nfs3TSymlinkUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3TSymlink * x)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
nfs3RSymlinkPrint(Fmt * fmt,Nfs3RSymlink * x)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
nfs3RSymlinkSize(Nfs3RSymlink * x)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
nfs3RSymlinkPack(uchar * a,uchar * ea,uchar ** pa,Nfs3RSymlink * x)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
nfs3RSymlinkUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3RSymlink * x)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
nfs3TMknodPrint(Fmt * fmt,Nfs3TMknod * x)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
nfs3TMknodSize(Nfs3TMknod * x)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
nfs3TMknodPack(uchar * a,uchar * ea,uchar ** pa,Nfs3TMknod * x)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
nfs3TMknodUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3TMknod * x)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
nfs3RMknodPrint(Fmt * fmt,Nfs3RMknod * x)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
nfs3RMknodSize(Nfs3RMknod * x)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
nfs3RMknodPack(uchar * a,uchar * ea,uchar ** pa,Nfs3RMknod * x)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
nfs3RMknodUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3RMknod * x)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
nfs3TRemovePrint(Fmt * fmt,Nfs3TRemove * x)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
nfs3TRemoveSize(Nfs3TRemove * x)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
nfs3TRemovePack(uchar * a,uchar * ea,uchar ** pa,Nfs3TRemove * x)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
nfs3TRemoveUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3TRemove * x)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
nfs3RRemovePrint(Fmt * fmt,Nfs3RRemove * x)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
nfs3RRemoveSize(Nfs3RRemove * x)2517 nfs3RRemoveSize(Nfs3RRemove *x)
2518 {
2519 uint a;
2520 USED(x);
2521 a = 0 + 4 + nfs3WccSize(&x->wcc);
2522 return a;
2523 }
2524 int
nfs3RRemovePack(uchar * a,uchar * ea,uchar ** pa,Nfs3RRemove * x)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
nfs3RRemoveUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3RRemove * x)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
nfs3TRmdirPrint(Fmt * fmt,Nfs3TRmdir * x)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
nfs3TRmdirSize(Nfs3TRmdir * x)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
nfs3TRmdirPack(uchar * a,uchar * ea,uchar ** pa,Nfs3TRmdir * x)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
nfs3TRmdirUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3TRmdir * x)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
nfs3RRmdirPrint(Fmt * fmt,Nfs3RRmdir * x)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
nfs3RRmdirSize(Nfs3RRmdir * x)2603 nfs3RRmdirSize(Nfs3RRmdir *x)
2604 {
2605 uint a;
2606 USED(x);
2607 a = 0 + 4 + nfs3WccSize(&x->wcc);
2608 return a;
2609 }
2610 int
nfs3RRmdirPack(uchar * a,uchar * ea,uchar ** pa,Nfs3RRmdir * x)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
nfs3RRmdirUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3RRmdir * x)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
nfs3TRenamePrint(Fmt * fmt,Nfs3TRename * x)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
nfs3TRenameSize(Nfs3TRename * x)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
nfs3TRenamePack(uchar * a,uchar * ea,uchar ** pa,Nfs3TRename * x)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
nfs3TRenameUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3TRename * x)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
nfs3RRenamePrint(Fmt * fmt,Nfs3RRename * x)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
nfs3RRenameSize(Nfs3RRename * x)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
nfs3RRenamePack(uchar * a,uchar * ea,uchar ** pa,Nfs3RRename * x)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
nfs3RRenameUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3RRename * x)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
nfs3TLinkPrint(Fmt * fmt,Nfs3TLink * x)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
nfs3TLinkSize(Nfs3TLink * x)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
nfs3TLinkPack(uchar * a,uchar * ea,uchar ** pa,Nfs3TLink * x)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
nfs3TLinkUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3TLink * x)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
nfs3RLinkPrint(Fmt * fmt,Nfs3RLink * x)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
nfs3RLinkSize(Nfs3RLink * x)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
nfs3RLinkPack(uchar * a,uchar * ea,uchar ** pa,Nfs3RLink * x)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
nfs3RLinkUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3RLink * x)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
nfs3TReadDirPrint(Fmt * fmt,Nfs3TReadDir * x)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
nfs3TReadDirSize(Nfs3TReadDir * x)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
nfs3TReadDirPack(uchar * a,uchar * ea,uchar ** pa,Nfs3TReadDir * x)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
nfs3TReadDirUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3TReadDir * x)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
nfs3EntryPrint(Fmt * fmt,Nfs3Entry * x)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
nfs3EntrySize(Nfs3Entry * x)2934 nfs3EntrySize(Nfs3Entry *x)
2935 {
2936 uint a;
2937 USED(x);
2938 a = 0 + 4 + 8 + sunStringSize(x->name) + 8;
2939 return a;
2940 }
2941 int
nfs3EntryPack(uchar * a,uchar * ea,uchar ** pa,Nfs3Entry * x)2942 nfs3EntryPack(uchar *a, uchar *ea, uchar **pa, Nfs3Entry *x)
2943 {
2944 u1int one;
2945
2946 one = 1;
2947 if(sunUint1Pack(a, ea, &a, &one) < 0) goto Err;
2948 if(sunUint64Pack(a, ea, &a, &x->fileid) < 0) goto Err;
2949 if(sunStringPack(a, ea, &a, &x->name, -1) < 0) goto Err;
2950 if(sunUint64Pack(a, ea, &a, &x->cookie) < 0) goto Err;
2951 *pa = a;
2952 return 0;
2953 Err:
2954 *pa = ea;
2955 return -1;
2956 }
2957 int
nfs3EntryUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3Entry * x)2958 nfs3EntryUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3Entry *x)
2959 {
2960 u1int one;
2961
2962 memset(x, 0, sizeof *x);
2963 if(sunUint1Unpack(a, ea, &a, &one) < 0 || one != 1) goto Err;
2964 if(sunUint64Unpack(a, ea, &a, &x->fileid) < 0) goto Err;
2965 if(sunStringUnpack(a, ea, &a, &x->name, -1) < 0) goto Err;
2966 if(sunUint64Unpack(a, ea, &a, &x->cookie) < 0) goto Err;
2967 *pa = a;
2968 return 0;
2969 Err:
2970 *pa = ea;
2971 return -1;
2972 }
2973 void
nfs3RReadDirPrint(Fmt * fmt,Nfs3RReadDir * x)2974 nfs3RReadDirPrint(Fmt *fmt, Nfs3RReadDir *x)
2975 {
2976 fmtprint(fmt, "%s\n", "Nfs3RReadDir");
2977 fmtprint(fmt, "\t%s=", "status");
2978 fmtprint(fmt, "%s", nfs3StatusStr(x->status));
2979 fmtprint(fmt, "\n");
2980 fmtprint(fmt, "\t%s=", "haveAttr");
2981 fmtprint(fmt, "%d", x->haveAttr);
2982 fmtprint(fmt, "\n");
2983 switch(x->haveAttr){
2984 case 1:
2985 fmtprint(fmt, "\t%s=", "attr");
2986 nfs3AttrPrint(fmt, &x->attr);
2987 fmtprint(fmt, "\n");
2988 break;
2989 }
2990 switch(x->status){
2991 case Nfs3Ok:
2992 fmtprint(fmt, "\t%s=", "verf");
2993 fmtprint(fmt, "%.*H", Nfs3CookieVerfSize, x->verf);
2994 fmtprint(fmt, "\n");
2995 fmtprint(fmt, "\t%s=%ud\n", "count", x->count);
2996 fmtprint(fmt, "\t%s=", "eof");
2997 fmtprint(fmt, "%d", x->eof);
2998 fmtprint(fmt, "\n");
2999 break;
3000 }
3001 }
3002 uint
nfs3RReadDirSize(Nfs3RReadDir * x)3003 nfs3RReadDirSize(Nfs3RReadDir *x)
3004 {
3005 uint a;
3006 USED(x);
3007 a = 0 + 4 + 4;
3008 switch(x->haveAttr){
3009 case 1:
3010 a = a + nfs3AttrSize(&x->attr);
3011 break;
3012 }
3013 switch(x->status){
3014 case Nfs3Ok:
3015 a = a + Nfs3CookieVerfSize;
3016 a += x->count;
3017 a += 4 + 4;
3018 break;
3019 }
3020 return a;
3021 }
3022 int
nfs3RReadDirPack(uchar * a,uchar * ea,uchar ** pa,Nfs3RReadDir * x)3023 nfs3RReadDirPack(uchar *a, uchar *ea, uchar **pa, Nfs3RReadDir *x)
3024 {
3025 int i;
3026 u1int zero;
3027
3028 if(i=x->status, sunEnumPack(a, ea, &a, &i) < 0) goto Err;
3029 if(sunUint1Pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
3030 switch(x->haveAttr){
3031 case 1:
3032 if(nfs3AttrPack(a, ea, &a, &x->attr) < 0) goto Err;
3033 break;
3034 }
3035 switch(x->status){
3036 case Nfs3Ok:
3037 if(sunFixedOpaquePack(a, ea, &a, x->verf, Nfs3CookieVerfSize) < 0) goto Err;
3038 if(sunFixedOpaquePack(a, ea, &a, x->data, x->count) < 0) goto Err;
3039 zero = 0;
3040 if(sunUint1Pack(a, ea, &a, &zero) < 0) goto Err;
3041 if(sunUint1Pack(a, ea, &a, &x->eof) < 0) goto Err;
3042 break;
3043 }
3044 *pa = a;
3045 return 0;
3046 Err:
3047 *pa = ea;
3048 return -1;
3049 }
3050 static int
countEntry(uchar * a,uchar * ea,uchar ** pa,u32int * n)3051 countEntry(uchar *a, uchar *ea, uchar **pa, u32int *n)
3052 {
3053 uchar *oa;
3054 u64int u64;
3055 u32int u32;
3056 u1int u1;
3057
3058 oa = a;
3059 for(;;){
3060 if(sunUint1Unpack(a, ea, &a, &u1) < 0)
3061 return -1;
3062 if(u1 == 0)
3063 break;
3064 if(sunUint64Unpack(a, ea, &a, &u64) < 0
3065 || sunUint32Unpack(a, ea, &a, &u32) < 0)
3066 return -1;
3067 a += (u32+3)&~3;
3068 if(a >= ea)
3069 return -1;
3070 if(sunUint64Unpack(a, ea, &a, &u64) < 0)
3071 return -1;
3072 }
3073 *n = (a-4) - oa;
3074 *pa = a;
3075 return 0;
3076 }
3077 int
nfs3RReadDirUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3RReadDir * x)3078 nfs3RReadDirUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3RReadDir *x)
3079 {
3080 int i;
3081
3082 if(sunEnumUnpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
3083 if(sunUint1Unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
3084 switch(x->haveAttr){
3085 case 1:
3086 if(nfs3AttrUnpack(a, ea, &a, &x->attr) < 0) goto Err;
3087 break;
3088 }
3089 if(x->status == Nfs3Ok){
3090 if(sunFixedOpaqueUnpack(a, ea, &a, x->verf, Nfs3CookieVerfSize) < 0) goto Err;
3091 x->data = a;
3092 if(countEntry(a, ea, &a, &x->count) < 0) goto Err;
3093 if(sunUint1Unpack(a, ea, &a, &x->eof) < 0) goto Err;
3094 }
3095 *pa = a;
3096 return 0;
3097 Err:
3098 *pa = ea;
3099 return -1;
3100 }
3101 void
nfs3TReadDirPlusPrint(Fmt * fmt,Nfs3TReadDirPlus * x)3102 nfs3TReadDirPlusPrint(Fmt *fmt, Nfs3TReadDirPlus *x)
3103 {
3104 fmtprint(fmt, "%s\n", "Nfs3TReadDirPlus");
3105 fmtprint(fmt, "\t%s=", "handle");
3106 nfs3HandlePrint(fmt, &x->handle);
3107 fmtprint(fmt, "\n");
3108 fmtprint(fmt, "\t%s=", "cookie");
3109 fmtprint(fmt, "%llud", x->cookie);
3110 fmtprint(fmt, "\n");
3111 fmtprint(fmt, "\t%s=", "verf");
3112 fmtprint(fmt, "%.*H", Nfs3CookieVerfSize, x->verf);
3113 fmtprint(fmt, "\n");
3114 fmtprint(fmt, "\t%s=", "dirCount");
3115 fmtprint(fmt, "%ud", x->dirCount);
3116 fmtprint(fmt, "\n");
3117 fmtprint(fmt, "\t%s=", "maxCount");
3118 fmtprint(fmt, "%ud", x->maxCount);
3119 fmtprint(fmt, "\n");
3120 }
3121 uint
nfs3TReadDirPlusSize(Nfs3TReadDirPlus * x)3122 nfs3TReadDirPlusSize(Nfs3TReadDirPlus *x)
3123 {
3124 uint a;
3125 USED(x);
3126 a = 0 + nfs3HandleSize(&x->handle) + 8 + Nfs3CookieVerfSize + 4 + 4;
3127 return a;
3128 }
3129 int
nfs3TReadDirPlusPack(uchar * a,uchar * ea,uchar ** pa,Nfs3TReadDirPlus * x)3130 nfs3TReadDirPlusPack(uchar *a, uchar *ea, uchar **pa, Nfs3TReadDirPlus *x)
3131 {
3132 if(nfs3HandlePack(a, ea, &a, &x->handle) < 0) goto Err;
3133 if(sunUint64Pack(a, ea, &a, &x->cookie) < 0) goto Err;
3134 if(sunFixedOpaquePack(a, ea, &a, x->verf, Nfs3CookieVerfSize) < 0) goto Err;
3135 if(sunUint32Pack(a, ea, &a, &x->dirCount) < 0) goto Err;
3136 if(sunUint32Pack(a, ea, &a, &x->maxCount) < 0) goto Err;
3137 *pa = a;
3138 return 0;
3139 Err:
3140 *pa = ea;
3141 return -1;
3142 }
3143 int
nfs3TReadDirPlusUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3TReadDirPlus * x)3144 nfs3TReadDirPlusUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3TReadDirPlus *x)
3145 {
3146 if(nfs3HandleUnpack(a, ea, &a, &x->handle) < 0) goto Err;
3147 if(sunUint64Unpack(a, ea, &a, &x->cookie) < 0) goto Err;
3148 if(sunFixedOpaqueUnpack(a, ea, &a, x->verf, Nfs3CookieVerfSize) < 0) goto Err;
3149 if(sunUint32Unpack(a, ea, &a, &x->dirCount) < 0) goto Err;
3150 if(sunUint32Unpack(a, ea, &a, &x->maxCount) < 0) goto Err;
3151 *pa = a;
3152 return 0;
3153 Err:
3154 *pa = ea;
3155 return -1;
3156 }
3157 void
nfs3EntryPlusPrint(Fmt * fmt,Nfs3Entry * x)3158 nfs3EntryPlusPrint(Fmt *fmt, Nfs3Entry *x)
3159 {
3160 fmtprint(fmt, "%s\n", "Nfs3EntryPlus");
3161 fmtprint(fmt, "\t%s=", "fileid");
3162 fmtprint(fmt, "%llud", x->fileid);
3163 fmtprint(fmt, "\n");
3164 fmtprint(fmt, "\t%s=", "name");
3165 fmtprint(fmt, "\"%s\"", x->name);
3166 fmtprint(fmt, "\n");
3167 fmtprint(fmt, "\t%s=", "cookie");
3168 fmtprint(fmt, "%llud", x->cookie);
3169 fmtprint(fmt, "\n");
3170 fmtprint(fmt, "\t%s=", "haveAttr");
3171 fmtprint(fmt, "%d", x->haveAttr);
3172 fmtprint(fmt, "\n");
3173 switch(x->haveAttr){
3174 case 1:
3175 fmtprint(fmt, "\t%s=", "attr");
3176 nfs3AttrPrint(fmt, &x->attr);
3177 fmtprint(fmt, "\n");
3178 break;
3179 }
3180 fmtprint(fmt, "\t%s=", "haveHandle");
3181 fmtprint(fmt, "%d", x->haveHandle);
3182 fmtprint(fmt, "\n");
3183 switch(x->haveHandle){
3184 case 1:
3185 fmtprint(fmt, "\t%s=", "handle");
3186 nfs3HandlePrint(fmt, &x->handle);
3187 fmtprint(fmt, "\n");
3188 break;
3189 }
3190 }
3191 uint
nfs3EntryPlusSize(Nfs3Entry * x)3192 nfs3EntryPlusSize(Nfs3Entry *x)
3193 {
3194 uint a;
3195 USED(x);
3196 a = 0 + 8 + sunStringSize(x->name) + 8 + 4;
3197 switch(x->haveAttr){
3198 case 1:
3199 a = a + nfs3AttrSize(&x->attr);
3200 break;
3201 }
3202 a = a + 4;
3203 switch(x->haveHandle){
3204 case 1:
3205 a = a + nfs3HandleSize(&x->handle);
3206 break;
3207 }
3208 return a;
3209 }
3210 int
nfs3EntryPlusPack(uchar * a,uchar * ea,uchar ** pa,Nfs3Entry * x)3211 nfs3EntryPlusPack(uchar *a, uchar *ea, uchar **pa, Nfs3Entry *x)
3212 {
3213 u1int u1;
3214
3215 if(sunUint1Pack(a, ea, &a, &u1) < 0) goto Err;
3216 if(sunUint64Pack(a, ea, &a, &x->fileid) < 0) goto Err;
3217 if(sunStringPack(a, ea, &a, &x->name, -1) < 0) goto Err;
3218 if(sunUint64Pack(a, ea, &a, &x->cookie) < 0) goto Err;
3219 if(sunUint1Pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
3220 switch(x->haveAttr){
3221 case 1:
3222 if(nfs3AttrPack(a, ea, &a, &x->attr) < 0) goto Err;
3223 break;
3224 }
3225 if(sunUint1Pack(a, ea, &a, &x->haveHandle) < 0) goto Err;
3226 switch(x->haveHandle){
3227 case 1:
3228 if(nfs3HandlePack(a, ea, &a, &x->handle) < 0) goto Err;
3229 break;
3230 }
3231 *pa = a;
3232 return 0;
3233 Err:
3234 *pa = ea;
3235 return -1;
3236 }
3237 int
nfs3EntryPlusUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3Entry * x)3238 nfs3EntryPlusUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3Entry *x)
3239 {
3240 u1int u1;
3241
3242 if(sunUint1Unpack(a, ea, &a, &u1) < 0 || u1 != 1) goto Err;
3243 if(sunUint64Unpack(a, ea, &a, &x->fileid) < 0) goto Err;
3244 if(sunStringUnpack(a, ea, &a, &x->name, -1) < 0) goto Err;
3245 if(sunUint64Unpack(a, ea, &a, &x->cookie) < 0) goto Err;
3246 if(sunUint1Unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
3247 switch(x->haveAttr){
3248 case 1:
3249 if(nfs3AttrUnpack(a, ea, &a, &x->attr) < 0) goto Err;
3250 break;
3251 }
3252 if(sunUint1Unpack(a, ea, &a, &x->haveHandle) < 0) goto Err;
3253 switch(x->haveHandle){
3254 case 1:
3255 if(nfs3HandleUnpack(a, ea, &a, &x->handle) < 0) goto Err;
3256 break;
3257 }
3258 *pa = a;
3259 return 0;
3260 Err:
3261 *pa = ea;
3262 return -1;
3263 }
3264 void
nfs3RReadDirPlusPrint(Fmt * fmt,Nfs3RReadDirPlus * x)3265 nfs3RReadDirPlusPrint(Fmt *fmt, Nfs3RReadDirPlus *x)
3266 {
3267 fmtprint(fmt, "%s\n", "Nfs3RReadDirPlus");
3268 fmtprint(fmt, "\t%s=", "status");
3269 fmtprint(fmt, "%s", nfs3StatusStr(x->status));
3270 fmtprint(fmt, "\n");
3271 fmtprint(fmt, "\t%s=", "haveAttr");
3272 fmtprint(fmt, "%d", x->haveAttr);
3273 fmtprint(fmt, "\n");
3274 switch(x->haveAttr){
3275 case 1:
3276 fmtprint(fmt, "\t%s=", "attr");
3277 nfs3AttrPrint(fmt, &x->attr);
3278 fmtprint(fmt, "\n");
3279 break;
3280 }
3281 switch(x->status){
3282 case Nfs3Ok:
3283 fmtprint(fmt, "\t%s=", "verf");
3284 fmtprint(fmt, "%.*H", Nfs3CookieVerfSize, x->verf);
3285 fmtprint(fmt, "\n");
3286 fmtprint(fmt, "\tcount=%ud\n", x->count);
3287 fmtprint(fmt, "\t%s=", "eof");
3288 fmtprint(fmt, "%d", x->eof);
3289 fmtprint(fmt, "\n");
3290 break;
3291 }
3292 }
3293 uint
nfs3RReadDirPlusSize(Nfs3RReadDirPlus * x)3294 nfs3RReadDirPlusSize(Nfs3RReadDirPlus *x)
3295 {
3296 uint a;
3297 USED(x);
3298 a = 0 + 4 + 4;
3299 switch(x->haveAttr){
3300 case 1:
3301 a = a + nfs3AttrSize(&x->attr);
3302 break;
3303 }
3304 switch(x->status){
3305 case Nfs3Ok:
3306 a = a + Nfs3CookieVerfSize;
3307 a += x->count;
3308 a += 4 + 4;
3309 break;
3310 }
3311 return a;
3312 }
3313 int
nfs3RReadDirPlusPack(uchar * a,uchar * ea,uchar ** pa,Nfs3RReadDirPlus * x)3314 nfs3RReadDirPlusPack(uchar *a, uchar *ea, uchar **pa, Nfs3RReadDirPlus *x)
3315 {
3316 int i;
3317 u1int zero;
3318
3319 if(i=x->status, sunEnumPack(a, ea, &a, &i) < 0) goto Err;
3320 if(sunUint1Pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
3321 switch(x->haveAttr){
3322 case 1:
3323 if(nfs3AttrPack(a, ea, &a, &x->attr) < 0) goto Err;
3324 break;
3325 }
3326 switch(x->status){
3327 case Nfs3Ok:
3328 if(sunFixedOpaquePack(a, ea, &a, x->verf, Nfs3CookieVerfSize) < 0) goto Err;
3329 if(sunFixedOpaquePack(a, ea, &a, x->data, x->count) < 0) goto Err;
3330 zero = 0;
3331 if(sunUint1Pack(a, ea, &a, &zero) < 0) goto Err;
3332 if(sunUint1Pack(a, ea, &a, &x->eof) < 0) goto Err;
3333 break;
3334 }
3335 *pa = a;
3336 return 0;
3337 Err:
3338 *pa = ea;
3339 return -1;
3340 }
3341 static int
countEntryPlus(uchar * a,uchar * ea,uchar ** pa,u32int * n)3342 countEntryPlus(uchar *a, uchar *ea, uchar **pa, u32int *n)
3343 {
3344 uchar *oa;
3345 u64int u64;
3346 u32int u32;
3347 u1int u1;
3348 Nfs3Handle h;
3349 Nfs3Attr attr;
3350
3351 oa = a;
3352 for(;;){
3353 if(sunUint1Unpack(a, ea, &a, &u1) < 0)
3354 return -1;
3355 if(u1 == 0)
3356 break;
3357 if(sunUint64Unpack(a, ea, &a, &u64) < 0
3358 || sunUint32Unpack(a, ea, &a, &u32) < 0)
3359 return -1;
3360 a += (u32+3)&~3;
3361 if(a >= ea)
3362 return -1;
3363 if(sunUint64Unpack(a, ea, &a, &u64) < 0
3364 || sunUint1Unpack(a, ea, &a, &u1) < 0
3365 || (u1 && nfs3AttrUnpack(a, ea, &a, &attr) < 0)
3366 || sunUint1Unpack(a, ea, &a, &u1) < 0
3367 || (u1 && nfs3HandleUnpack(a, ea, &a, &h) < 0))
3368 return -1;
3369 }
3370 *n = (a-4) - oa;
3371 *pa = a;
3372 return 0;
3373 }
3374
3375 int
nfs3RReadDirPlusUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3RReadDirPlus * x)3376 nfs3RReadDirPlusUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3RReadDirPlus *x)
3377 {
3378 int i;
3379
3380 if(sunEnumUnpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
3381 if(sunUint1Unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
3382 switch(x->haveAttr){
3383 case 1:
3384 if(nfs3AttrUnpack(a, ea, &a, &x->attr) < 0) goto Err;
3385 break;
3386 }
3387 if(x->status == Nfs3Ok){
3388 if(sunFixedOpaqueUnpack(a, ea, &a, x->verf, Nfs3CookieVerfSize) < 0) goto Err;
3389 x->data = a;
3390 if(countEntryPlus(a, ea, &a, &x->count) < 0) goto Err;
3391 if(sunUint1Unpack(a, ea, &a, &x->eof) < 0) goto Err;
3392 }
3393 *pa = a;
3394 return 0;
3395 Err:
3396 *pa = ea;
3397 return -1;
3398 }
3399 void
nfs3TFsStatPrint(Fmt * fmt,Nfs3TFsStat * x)3400 nfs3TFsStatPrint(Fmt *fmt, Nfs3TFsStat *x)
3401 {
3402 fmtprint(fmt, "%s\n", "Nfs3TFsStat");
3403 fmtprint(fmt, "\t%s=", "handle");
3404 nfs3HandlePrint(fmt, &x->handle);
3405 fmtprint(fmt, "\n");
3406 }
3407 uint
nfs3TFsStatSize(Nfs3TFsStat * x)3408 nfs3TFsStatSize(Nfs3TFsStat *x)
3409 {
3410 uint a;
3411 USED(x);
3412 a = 0 + nfs3HandleSize(&x->handle);
3413 return a;
3414 }
3415 int
nfs3TFsStatPack(uchar * a,uchar * ea,uchar ** pa,Nfs3TFsStat * x)3416 nfs3TFsStatPack(uchar *a, uchar *ea, uchar **pa, Nfs3TFsStat *x)
3417 {
3418 if(nfs3HandlePack(a, ea, &a, &x->handle) < 0) goto Err;
3419 *pa = a;
3420 return 0;
3421 Err:
3422 *pa = ea;
3423 return -1;
3424 }
3425 int
nfs3TFsStatUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3TFsStat * x)3426 nfs3TFsStatUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3TFsStat *x)
3427 {
3428 if(nfs3HandleUnpack(a, ea, &a, &x->handle) < 0) goto Err;
3429 *pa = a;
3430 return 0;
3431 Err:
3432 *pa = ea;
3433 return -1;
3434 }
3435 void
nfs3RFsStatPrint(Fmt * fmt,Nfs3RFsStat * x)3436 nfs3RFsStatPrint(Fmt *fmt, Nfs3RFsStat *x)
3437 {
3438 fmtprint(fmt, "%s\n", "Nfs3RFsStat");
3439 fmtprint(fmt, "\t%s=", "status");
3440 fmtprint(fmt, "%s", nfs3StatusStr(x->status));
3441 fmtprint(fmt, "\n");
3442 fmtprint(fmt, "\t%s=", "haveAttr");
3443 fmtprint(fmt, "%d", x->haveAttr);
3444 fmtprint(fmt, "\n");
3445 switch(x->haveAttr){
3446 case 1:
3447 fmtprint(fmt, "\t%s=", "attr");
3448 nfs3AttrPrint(fmt, &x->attr);
3449 fmtprint(fmt, "\n");
3450 break;
3451 }
3452 switch(x->status){
3453 case Nfs3Ok:
3454 fmtprint(fmt, "\t%s=", "totalBytes");
3455 fmtprint(fmt, "%llud", x->totalBytes);
3456 fmtprint(fmt, "\n");
3457 fmtprint(fmt, "\t%s=", "freeBytes");
3458 fmtprint(fmt, "%llud", x->freeBytes);
3459 fmtprint(fmt, "\n");
3460 fmtprint(fmt, "\t%s=", "availBytes");
3461 fmtprint(fmt, "%llud", x->availBytes);
3462 fmtprint(fmt, "\n");
3463 fmtprint(fmt, "\t%s=", "totalFiles");
3464 fmtprint(fmt, "%llud", x->totalFiles);
3465 fmtprint(fmt, "\n");
3466 fmtprint(fmt, "\t%s=", "freeFiles");
3467 fmtprint(fmt, "%llud", x->freeFiles);
3468 fmtprint(fmt, "\n");
3469 fmtprint(fmt, "\t%s=", "availFiles");
3470 fmtprint(fmt, "%llud", x->availFiles);
3471 fmtprint(fmt, "\n");
3472 fmtprint(fmt, "\t%s=", "invarSec");
3473 fmtprint(fmt, "%ud", x->invarSec);
3474 fmtprint(fmt, "\n");
3475 break;
3476 }
3477 }
3478 uint
nfs3RFsStatSize(Nfs3RFsStat * x)3479 nfs3RFsStatSize(Nfs3RFsStat *x)
3480 {
3481 uint a;
3482 USED(x);
3483 a = 0 + 4 + 4;
3484 switch(x->haveAttr){
3485 case 1:
3486 a = a + nfs3AttrSize(&x->attr);
3487 break;
3488 }
3489 switch(x->status){
3490 case Nfs3Ok:
3491 a = a + 8 + 8 + 8 + 8 + 8 + 8 + 4;
3492 break;
3493 }
3494 return a;
3495 }
3496 int
nfs3RFsStatPack(uchar * a,uchar * ea,uchar ** pa,Nfs3RFsStat * x)3497 nfs3RFsStatPack(uchar *a, uchar *ea, uchar **pa, Nfs3RFsStat *x)
3498 {
3499 int i;
3500
3501 if(i=x->status, sunEnumPack(a, ea, &a, &i) < 0) goto Err;
3502 if(sunUint1Pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
3503 switch(x->haveAttr){
3504 case 1:
3505 if(nfs3AttrPack(a, ea, &a, &x->attr) < 0) goto Err;
3506 break;
3507 }
3508 switch(x->status){
3509 case Nfs3Ok:
3510 if(sunUint64Pack(a, ea, &a, &x->totalBytes) < 0) goto Err;
3511 if(sunUint64Pack(a, ea, &a, &x->freeBytes) < 0) goto Err;
3512 if(sunUint64Pack(a, ea, &a, &x->availBytes) < 0) goto Err;
3513 if(sunUint64Pack(a, ea, &a, &x->totalFiles) < 0) goto Err;
3514 if(sunUint64Pack(a, ea, &a, &x->freeFiles) < 0) goto Err;
3515 if(sunUint64Pack(a, ea, &a, &x->availFiles) < 0) goto Err;
3516 if(sunUint32Pack(a, ea, &a, &x->invarSec) < 0) goto Err;
3517 break;
3518 }
3519 *pa = a;
3520 return 0;
3521 Err:
3522 *pa = ea;
3523 return -1;
3524 }
3525 int
nfs3RFsStatUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3RFsStat * x)3526 nfs3RFsStatUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3RFsStat *x)
3527 {
3528 int i;
3529
3530 if(sunEnumUnpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
3531 if(sunUint1Unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
3532 switch(x->haveAttr){
3533 case 1:
3534 if(nfs3AttrUnpack(a, ea, &a, &x->attr) < 0) goto Err;
3535 break;
3536 }
3537 switch(x->status){
3538 case Nfs3Ok:
3539 if(sunUint64Unpack(a, ea, &a, &x->totalBytes) < 0) goto Err;
3540 if(sunUint64Unpack(a, ea, &a, &x->freeBytes) < 0) goto Err;
3541 if(sunUint64Unpack(a, ea, &a, &x->availBytes) < 0) goto Err;
3542 if(sunUint64Unpack(a, ea, &a, &x->totalFiles) < 0) goto Err;
3543 if(sunUint64Unpack(a, ea, &a, &x->freeFiles) < 0) goto Err;
3544 if(sunUint64Unpack(a, ea, &a, &x->availFiles) < 0) goto Err;
3545 if(sunUint32Unpack(a, ea, &a, &x->invarSec) < 0) goto Err;
3546 break;
3547 }
3548 *pa = a;
3549 return 0;
3550 Err:
3551 *pa = ea;
3552 return -1;
3553 }
3554 void
nfs3TFsInfoPrint(Fmt * fmt,Nfs3TFsInfo * x)3555 nfs3TFsInfoPrint(Fmt *fmt, Nfs3TFsInfo *x)
3556 {
3557 fmtprint(fmt, "%s\n", "Nfs3TFsInfo");
3558 fmtprint(fmt, "\t%s=", "handle");
3559 nfs3HandlePrint(fmt, &x->handle);
3560 fmtprint(fmt, "\n");
3561 }
3562 uint
nfs3TFsInfoSize(Nfs3TFsInfo * x)3563 nfs3TFsInfoSize(Nfs3TFsInfo *x)
3564 {
3565 uint a;
3566 USED(x);
3567 a = 0 + nfs3HandleSize(&x->handle);
3568 return a;
3569 }
3570 int
nfs3TFsInfoPack(uchar * a,uchar * ea,uchar ** pa,Nfs3TFsInfo * x)3571 nfs3TFsInfoPack(uchar *a, uchar *ea, uchar **pa, Nfs3TFsInfo *x)
3572 {
3573 if(nfs3HandlePack(a, ea, &a, &x->handle) < 0) goto Err;
3574 *pa = a;
3575 return 0;
3576 Err:
3577 *pa = ea;
3578 return -1;
3579 }
3580 int
nfs3TFsInfoUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3TFsInfo * x)3581 nfs3TFsInfoUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3TFsInfo *x)
3582 {
3583 if(nfs3HandleUnpack(a, ea, &a, &x->handle) < 0) goto Err;
3584 *pa = a;
3585 return 0;
3586 Err:
3587 *pa = ea;
3588 return -1;
3589 }
3590 void
nfs3RFsInfoPrint(Fmt * fmt,Nfs3RFsInfo * x)3591 nfs3RFsInfoPrint(Fmt *fmt, Nfs3RFsInfo *x)
3592 {
3593 fmtprint(fmt, "%s\n", "Nfs3RFsInfo");
3594 fmtprint(fmt, "\t%s=", "status");
3595 fmtprint(fmt, "%s", nfs3StatusStr(x->status));
3596 fmtprint(fmt, "\n");
3597 fmtprint(fmt, "\t%s=", "haveAttr");
3598 fmtprint(fmt, "%d", x->haveAttr);
3599 fmtprint(fmt, "\n");
3600 switch(x->haveAttr){
3601 case 1:
3602 fmtprint(fmt, "\t%s=", "attr");
3603 nfs3AttrPrint(fmt, &x->attr);
3604 fmtprint(fmt, "\n");
3605 break;
3606 }
3607 switch(x->status){
3608 case Nfs3Ok:
3609 fmtprint(fmt, "\t%s=", "readMax");
3610 fmtprint(fmt, "%ud", x->readMax);
3611 fmtprint(fmt, "\n");
3612 fmtprint(fmt, "\t%s=", "readPref");
3613 fmtprint(fmt, "%ud", x->readPref);
3614 fmtprint(fmt, "\n");
3615 fmtprint(fmt, "\t%s=", "readMult");
3616 fmtprint(fmt, "%ud", x->readMult);
3617 fmtprint(fmt, "\n");
3618 fmtprint(fmt, "\t%s=", "writeMax");
3619 fmtprint(fmt, "%ud", x->writeMax);
3620 fmtprint(fmt, "\n");
3621 fmtprint(fmt, "\t%s=", "writePref");
3622 fmtprint(fmt, "%ud", x->writePref);
3623 fmtprint(fmt, "\n");
3624 fmtprint(fmt, "\t%s=", "writeMult");
3625 fmtprint(fmt, "%ud", x->writeMult);
3626 fmtprint(fmt, "\n");
3627 fmtprint(fmt, "\t%s=", "readDirPref");
3628 fmtprint(fmt, "%ud", x->readDirPref);
3629 fmtprint(fmt, "\n");
3630 fmtprint(fmt, "\t%s=", "maxFileSize");
3631 fmtprint(fmt, "%llud", x->maxFileSize);
3632 fmtprint(fmt, "\n");
3633 fmtprint(fmt, "\t%s=", "timePrec");
3634 nfs3TimePrint(fmt, &x->timePrec);
3635 fmtprint(fmt, "\n");
3636 fmtprint(fmt, "\t%s=", "flags");
3637 fmtprint(fmt, "%ud", x->flags);
3638 fmtprint(fmt, "\n");
3639 break;
3640 }
3641 }
3642 uint
nfs3RFsInfoSize(Nfs3RFsInfo * x)3643 nfs3RFsInfoSize(Nfs3RFsInfo *x)
3644 {
3645 uint a;
3646 USED(x);
3647 a = 0 + 4 + 4;
3648 switch(x->haveAttr){
3649 case 1:
3650 a = a + nfs3AttrSize(&x->attr);
3651 break;
3652 }
3653 switch(x->status){
3654 case Nfs3Ok:
3655 a = a + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 8 + nfs3TimeSize(&x->timePrec) + 4;
3656 break;
3657 }
3658 return a;
3659 }
3660 int
nfs3RFsInfoPack(uchar * a,uchar * ea,uchar ** pa,Nfs3RFsInfo * x)3661 nfs3RFsInfoPack(uchar *a, uchar *ea, uchar **pa, Nfs3RFsInfo *x)
3662 {
3663 int i;
3664
3665 if(i=x->status, sunEnumPack(a, ea, &a, &i) < 0) goto Err;
3666 if(sunUint1Pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
3667 switch(x->haveAttr){
3668 case 1:
3669 if(nfs3AttrPack(a, ea, &a, &x->attr) < 0) goto Err;
3670 break;
3671 }
3672 switch(x->status){
3673 case Nfs3Ok:
3674 if(sunUint32Pack(a, ea, &a, &x->readMax) < 0) goto Err;
3675 if(sunUint32Pack(a, ea, &a, &x->readPref) < 0) goto Err;
3676 if(sunUint32Pack(a, ea, &a, &x->readMult) < 0) goto Err;
3677 if(sunUint32Pack(a, ea, &a, &x->writeMax) < 0) goto Err;
3678 if(sunUint32Pack(a, ea, &a, &x->writePref) < 0) goto Err;
3679 if(sunUint32Pack(a, ea, &a, &x->writeMult) < 0) goto Err;
3680 if(sunUint32Pack(a, ea, &a, &x->readDirPref) < 0) goto Err;
3681 if(sunUint64Pack(a, ea, &a, &x->maxFileSize) < 0) goto Err;
3682 if(nfs3TimePack(a, ea, &a, &x->timePrec) < 0) goto Err;
3683 if(sunUint32Pack(a, ea, &a, &x->flags) < 0) goto Err;
3684 break;
3685 }
3686 *pa = a;
3687 return 0;
3688 Err:
3689 *pa = ea;
3690 return -1;
3691 }
3692 int
nfs3RFsInfoUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3RFsInfo * x)3693 nfs3RFsInfoUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3RFsInfo *x)
3694 {
3695 int i;
3696
3697 if(sunEnumUnpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
3698 if(sunUint1Unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
3699 switch(x->haveAttr){
3700 case 1:
3701 if(nfs3AttrUnpack(a, ea, &a, &x->attr) < 0) goto Err;
3702 break;
3703 }
3704 switch(x->status){
3705 case Nfs3Ok:
3706 if(sunUint32Unpack(a, ea, &a, &x->readMax) < 0) goto Err;
3707 if(sunUint32Unpack(a, ea, &a, &x->readPref) < 0) goto Err;
3708 if(sunUint32Unpack(a, ea, &a, &x->readMult) < 0) goto Err;
3709 if(sunUint32Unpack(a, ea, &a, &x->writeMax) < 0) goto Err;
3710 if(sunUint32Unpack(a, ea, &a, &x->writePref) < 0) goto Err;
3711 if(sunUint32Unpack(a, ea, &a, &x->writeMult) < 0) goto Err;
3712 if(sunUint32Unpack(a, ea, &a, &x->readDirPref) < 0) goto Err;
3713 if(sunUint64Unpack(a, ea, &a, &x->maxFileSize) < 0) goto Err;
3714 if(nfs3TimeUnpack(a, ea, &a, &x->timePrec) < 0) goto Err;
3715 if(sunUint32Unpack(a, ea, &a, &x->flags) < 0) goto Err;
3716 break;
3717 }
3718 *pa = a;
3719 return 0;
3720 Err:
3721 *pa = ea;
3722 return -1;
3723 }
3724 void
nfs3TPathconfPrint(Fmt * fmt,Nfs3TPathconf * x)3725 nfs3TPathconfPrint(Fmt *fmt, Nfs3TPathconf *x)
3726 {
3727 fmtprint(fmt, "%s\n", "Nfs3TPathconf");
3728 fmtprint(fmt, "\t%s=", "handle");
3729 nfs3HandlePrint(fmt, &x->handle);
3730 fmtprint(fmt, "\n");
3731 }
3732 uint
nfs3TPathconfSize(Nfs3TPathconf * x)3733 nfs3TPathconfSize(Nfs3TPathconf *x)
3734 {
3735 uint a;
3736 USED(x);
3737 a = 0 + nfs3HandleSize(&x->handle);
3738 return a;
3739 }
3740 int
nfs3TPathconfPack(uchar * a,uchar * ea,uchar ** pa,Nfs3TPathconf * x)3741 nfs3TPathconfPack(uchar *a, uchar *ea, uchar **pa, Nfs3TPathconf *x)
3742 {
3743 if(nfs3HandlePack(a, ea, &a, &x->handle) < 0) goto Err;
3744 *pa = a;
3745 return 0;
3746 Err:
3747 *pa = ea;
3748 return -1;
3749 }
3750 int
nfs3TPathconfUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3TPathconf * x)3751 nfs3TPathconfUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3TPathconf *x)
3752 {
3753 if(nfs3HandleUnpack(a, ea, &a, &x->handle) < 0) goto Err;
3754 *pa = a;
3755 return 0;
3756 Err:
3757 *pa = ea;
3758 return -1;
3759 }
3760 void
nfs3RPathconfPrint(Fmt * fmt,Nfs3RPathconf * x)3761 nfs3RPathconfPrint(Fmt *fmt, Nfs3RPathconf *x)
3762 {
3763 fmtprint(fmt, "%s\n", "Nfs3RPathconf");
3764 fmtprint(fmt, "\t%s=", "status");
3765 fmtprint(fmt, "%s", nfs3StatusStr(x->status));
3766 fmtprint(fmt, "\n");
3767 fmtprint(fmt, "\t%s=", "haveAttr");
3768 fmtprint(fmt, "%d", x->haveAttr);
3769 fmtprint(fmt, "\n");
3770 switch(x->haveAttr){
3771 case 1:
3772 fmtprint(fmt, "\t%s=", "attr");
3773 nfs3AttrPrint(fmt, &x->attr);
3774 fmtprint(fmt, "\n");
3775 break;
3776 }
3777 switch(x->status){
3778 case Nfs3Ok:
3779 fmtprint(fmt, "\t%s=", "maxLink");
3780 fmtprint(fmt, "%ud", x->maxLink);
3781 fmtprint(fmt, "\n");
3782 fmtprint(fmt, "\t%s=", "maxName");
3783 fmtprint(fmt, "%ud", x->maxName);
3784 fmtprint(fmt, "\n");
3785 fmtprint(fmt, "\t%s=", "noTrunc");
3786 fmtprint(fmt, "%d", x->noTrunc);
3787 fmtprint(fmt, "\n");
3788 fmtprint(fmt, "\t%s=", "chownRestricted");
3789 fmtprint(fmt, "%d", x->chownRestricted);
3790 fmtprint(fmt, "\n");
3791 fmtprint(fmt, "\t%s=", "caseInsensitive");
3792 fmtprint(fmt, "%d", x->caseInsensitive);
3793 fmtprint(fmt, "\n");
3794 fmtprint(fmt, "\t%s=", "casePreserving");
3795 fmtprint(fmt, "%d", x->casePreserving);
3796 fmtprint(fmt, "\n");
3797 break;
3798 }
3799 }
3800 uint
nfs3RPathconfSize(Nfs3RPathconf * x)3801 nfs3RPathconfSize(Nfs3RPathconf *x)
3802 {
3803 uint a;
3804 USED(x);
3805 a = 0 + 4 + 4;
3806 switch(x->haveAttr){
3807 case 1:
3808 a = a + nfs3AttrSize(&x->attr);
3809 break;
3810 }
3811 switch(x->status){
3812 case Nfs3Ok:
3813 a = a + 4 + 4 + 4 + 4 + 4 + 4;
3814 break;
3815 }
3816 return a;
3817 }
3818 int
nfs3RPathconfPack(uchar * a,uchar * ea,uchar ** pa,Nfs3RPathconf * x)3819 nfs3RPathconfPack(uchar *a, uchar *ea, uchar **pa, Nfs3RPathconf *x)
3820 {
3821 int i;
3822
3823 if(i=x->status, sunEnumPack(a, ea, &a, &i) < 0) goto Err;
3824 if(sunUint1Pack(a, ea, &a, &x->haveAttr) < 0) goto Err;
3825 switch(x->haveAttr){
3826 case 1:
3827 if(nfs3AttrPack(a, ea, &a, &x->attr) < 0) goto Err;
3828 break;
3829 }
3830 switch(x->status){
3831 case Nfs3Ok:
3832 if(sunUint32Pack(a, ea, &a, &x->maxLink) < 0) goto Err;
3833 if(sunUint32Pack(a, ea, &a, &x->maxName) < 0) goto Err;
3834 if(sunUint1Pack(a, ea, &a, &x->noTrunc) < 0) goto Err;
3835 if(sunUint1Pack(a, ea, &a, &x->chownRestricted) < 0) goto Err;
3836 if(sunUint1Pack(a, ea, &a, &x->caseInsensitive) < 0) goto Err;
3837 if(sunUint1Pack(a, ea, &a, &x->casePreserving) < 0) goto Err;
3838 break;
3839 }
3840 *pa = a;
3841 return 0;
3842 Err:
3843 *pa = ea;
3844 return -1;
3845 }
3846 int
nfs3RPathconfUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3RPathconf * x)3847 nfs3RPathconfUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3RPathconf *x)
3848 {
3849 int i;
3850
3851 if(sunEnumUnpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
3852 if(sunUint1Unpack(a, ea, &a, &x->haveAttr) < 0) goto Err;
3853 switch(x->haveAttr){
3854 case 1:
3855 if(nfs3AttrUnpack(a, ea, &a, &x->attr) < 0) goto Err;
3856 break;
3857 }
3858 switch(x->status){
3859 case Nfs3Ok:
3860 if(sunUint32Unpack(a, ea, &a, &x->maxLink) < 0) goto Err;
3861 if(sunUint32Unpack(a, ea, &a, &x->maxName) < 0) goto Err;
3862 if(sunUint1Unpack(a, ea, &a, &x->noTrunc) < 0) goto Err;
3863 if(sunUint1Unpack(a, ea, &a, &x->chownRestricted) < 0) goto Err;
3864 if(sunUint1Unpack(a, ea, &a, &x->caseInsensitive) < 0) goto Err;
3865 if(sunUint1Unpack(a, ea, &a, &x->casePreserving) < 0) goto Err;
3866 break;
3867 }
3868 *pa = a;
3869 return 0;
3870 Err:
3871 *pa = ea;
3872 return -1;
3873 }
3874 void
nfs3TCommitPrint(Fmt * fmt,Nfs3TCommit * x)3875 nfs3TCommitPrint(Fmt *fmt, Nfs3TCommit *x)
3876 {
3877 fmtprint(fmt, "%s\n", "Nfs3TCommit");
3878 fmtprint(fmt, "\t%s=", "handle");
3879 nfs3HandlePrint(fmt, &x->handle);
3880 fmtprint(fmt, "\n");
3881 fmtprint(fmt, "\t%s=", "offset");
3882 fmtprint(fmt, "%llud", x->offset);
3883 fmtprint(fmt, "\n");
3884 fmtprint(fmt, "\t%s=", "count");
3885 fmtprint(fmt, "%ud", x->count);
3886 fmtprint(fmt, "\n");
3887 }
3888 uint
nfs3TCommitSize(Nfs3TCommit * x)3889 nfs3TCommitSize(Nfs3TCommit *x)
3890 {
3891 uint a;
3892 USED(x);
3893 a = 0 + nfs3HandleSize(&x->handle) + 8 + 4;
3894 return a;
3895 }
3896 int
nfs3TCommitPack(uchar * a,uchar * ea,uchar ** pa,Nfs3TCommit * x)3897 nfs3TCommitPack(uchar *a, uchar *ea, uchar **pa, Nfs3TCommit *x)
3898 {
3899 if(nfs3HandlePack(a, ea, &a, &x->handle) < 0) goto Err;
3900 if(sunUint64Pack(a, ea, &a, &x->offset) < 0) goto Err;
3901 if(sunUint32Pack(a, ea, &a, &x->count) < 0) goto Err;
3902 *pa = a;
3903 return 0;
3904 Err:
3905 *pa = ea;
3906 return -1;
3907 }
3908 int
nfs3TCommitUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3TCommit * x)3909 nfs3TCommitUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3TCommit *x)
3910 {
3911 if(nfs3HandleUnpack(a, ea, &a, &x->handle) < 0) goto Err;
3912 if(sunUint64Unpack(a, ea, &a, &x->offset) < 0) goto Err;
3913 if(sunUint32Unpack(a, ea, &a, &x->count) < 0) goto Err;
3914 *pa = a;
3915 return 0;
3916 Err:
3917 *pa = ea;
3918 return -1;
3919 }
3920 void
nfs3RCommitPrint(Fmt * fmt,Nfs3RCommit * x)3921 nfs3RCommitPrint(Fmt *fmt, Nfs3RCommit *x)
3922 {
3923 fmtprint(fmt, "%s\n", "Nfs3RCommit");
3924 fmtprint(fmt, "\t%s=", "status");
3925 fmtprint(fmt, "%s", nfs3StatusStr(x->status));
3926 fmtprint(fmt, "\n");
3927 fmtprint(fmt, "\t%s=", "wcc");
3928 nfs3WccPrint(fmt, &x->wcc);
3929 fmtprint(fmt, "\n");
3930 switch(x->status){
3931 case Nfs3Ok:
3932 fmtprint(fmt, "\t%s=", "verf");
3933 fmtprint(fmt, "%.*H", Nfs3WriteVerfSize, x->verf);
3934 fmtprint(fmt, "\n");
3935 break;
3936 }
3937 }
3938 uint
nfs3RCommitSize(Nfs3RCommit * x)3939 nfs3RCommitSize(Nfs3RCommit *x)
3940 {
3941 uint a;
3942 USED(x);
3943 a = 0 + 4 + nfs3WccSize(&x->wcc);
3944 switch(x->status){
3945 case Nfs3Ok:
3946 a = a + Nfs3WriteVerfSize;
3947 break;
3948 }
3949 return a;
3950 }
3951 int
nfs3RCommitPack(uchar * a,uchar * ea,uchar ** pa,Nfs3RCommit * x)3952 nfs3RCommitPack(uchar *a, uchar *ea, uchar **pa, Nfs3RCommit *x)
3953 {
3954 int i;
3955
3956 if(i=x->status, sunEnumPack(a, ea, &a, &i) < 0) goto Err;
3957 if(nfs3WccPack(a, ea, &a, &x->wcc) < 0) goto Err;
3958 switch(x->status){
3959 case Nfs3Ok:
3960 if(sunFixedOpaquePack(a, ea, &a, x->verf, Nfs3WriteVerfSize) < 0) goto Err;
3961 break;
3962 }
3963 *pa = a;
3964 return 0;
3965 Err:
3966 *pa = ea;
3967 return -1;
3968 }
3969 int
nfs3RCommitUnpack(uchar * a,uchar * ea,uchar ** pa,Nfs3RCommit * x)3970 nfs3RCommitUnpack(uchar *a, uchar *ea, uchar **pa, Nfs3RCommit *x)
3971 {
3972 int i;
3973
3974 if(sunEnumUnpack(a, ea, &a, &i) < 0) goto Err; x->status = i;
3975 if(nfs3WccUnpack(a, ea, &a, &x->wcc) < 0) goto Err;
3976 switch(x->status){
3977 case Nfs3Ok:
3978 if(sunFixedOpaqueUnpack(a, ea, &a, x->verf, Nfs3WriteVerfSize) < 0) goto Err;
3979 break;
3980 }
3981 *pa = a;
3982 return 0;
3983 Err:
3984 *pa = ea;
3985 return -1;
3986 }
3987
3988 typedef int (*P)(uchar*, uchar*, uchar**, SunCall*);
3989 typedef void (*F)(Fmt*, SunCall*);
3990 typedef uint (*S)(SunCall*);
3991
3992 static SunProc proc[] = {
3993 (P)nfs3TNullPack, (P)nfs3TNullUnpack, (S)nfs3TNullSize, (F)nfs3TNullPrint, sizeof(Nfs3TNull),
3994 (P)nfs3RNullPack, (P)nfs3RNullUnpack, (S)nfs3RNullSize, (F)nfs3RNullPrint, sizeof(Nfs3RNull),
3995 (P)nfs3TGetattrPack, (P)nfs3TGetattrUnpack, (S)nfs3TGetattrSize, (F)nfs3TGetattrPrint, sizeof(Nfs3TGetattr),
3996 (P)nfs3RGetattrPack, (P)nfs3RGetattrUnpack, (S)nfs3RGetattrSize, (F)nfs3RGetattrPrint, sizeof(Nfs3RGetattr),
3997 (P)nfs3TSetattrPack, (P)nfs3TSetattrUnpack, (S)nfs3TSetattrSize, (F)nfs3TSetattrPrint, sizeof(Nfs3TSetattr),
3998 (P)nfs3RSetattrPack, (P)nfs3RSetattrUnpack, (S)nfs3RSetattrSize, (F)nfs3RSetattrPrint, sizeof(Nfs3RSetattr),
3999 (P)nfs3TLookupPack, (P)nfs3TLookupUnpack, (S)nfs3TLookupSize, (F)nfs3TLookupPrint, sizeof(Nfs3TLookup),
4000 (P)nfs3RLookupPack, (P)nfs3RLookupUnpack, (S)nfs3RLookupSize, (F)nfs3RLookupPrint, sizeof(Nfs3RLookup),
4001 (P)nfs3TAccessPack, (P)nfs3TAccessUnpack, (S)nfs3TAccessSize, (F)nfs3TAccessPrint, sizeof(Nfs3TAccess),
4002 (P)nfs3RAccessPack, (P)nfs3RAccessUnpack, (S)nfs3RAccessSize, (F)nfs3RAccessPrint, sizeof(Nfs3RAccess),
4003 (P)nfs3TReadlinkPack, (P)nfs3TReadlinkUnpack, (S)nfs3TReadlinkSize, (F)nfs3TReadlinkPrint, sizeof(Nfs3TReadlink),
4004 (P)nfs3RReadlinkPack, (P)nfs3RReadlinkUnpack, (S)nfs3RReadlinkSize, (F)nfs3RReadlinkPrint, sizeof(Nfs3RReadlink),
4005 (P)nfs3TReadPack, (P)nfs3TReadUnpack, (S)nfs3TReadSize, (F)nfs3TReadPrint, sizeof(Nfs3TRead),
4006 (P)nfs3RReadPack, (P)nfs3RReadUnpack, (S)nfs3RReadSize, (F)nfs3RReadPrint, sizeof(Nfs3RRead),
4007 (P)nfs3TWritePack, (P)nfs3TWriteUnpack, (S)nfs3TWriteSize, (F)nfs3TWritePrint, sizeof(Nfs3TWrite),
4008 (P)nfs3RWritePack, (P)nfs3RWriteUnpack, (S)nfs3RWriteSize, (F)nfs3RWritePrint, sizeof(Nfs3RWrite),
4009 (P)nfs3TCreatePack, (P)nfs3TCreateUnpack, (S)nfs3TCreateSize, (F)nfs3TCreatePrint, sizeof(Nfs3TCreate),
4010 (P)nfs3RCreatePack, (P)nfs3RCreateUnpack, (S)nfs3RCreateSize, (F)nfs3RCreatePrint, sizeof(Nfs3RCreate),
4011 (P)nfs3TMkdirPack, (P)nfs3TMkdirUnpack, (S)nfs3TMkdirSize, (F)nfs3TMkdirPrint, sizeof(Nfs3TMkdir),
4012 (P)nfs3RMkdirPack, (P)nfs3RMkdirUnpack, (S)nfs3RMkdirSize, (F)nfs3RMkdirPrint, sizeof(Nfs3RMkdir),
4013 (P)nfs3TSymlinkPack, (P)nfs3TSymlinkUnpack, (S)nfs3TSymlinkSize, (F)nfs3TSymlinkPrint, sizeof(Nfs3TSymlink),
4014 (P)nfs3RSymlinkPack, (P)nfs3RSymlinkUnpack, (S)nfs3RSymlinkSize, (F)nfs3RSymlinkPrint, sizeof(Nfs3RSymlink),
4015 (P)nfs3TMknodPack, (P)nfs3TMknodUnpack, (S)nfs3TMknodSize, (F)nfs3TMknodPrint, sizeof(Nfs3TMknod),
4016 (P)nfs3RMknodPack, (P)nfs3RMknodUnpack, (S)nfs3RMknodSize, (F)nfs3RMknodPrint, sizeof(Nfs3RMknod),
4017 (P)nfs3TRemovePack, (P)nfs3TRemoveUnpack, (S)nfs3TRemoveSize, (F)nfs3TRemovePrint, sizeof(Nfs3TRemove),
4018 (P)nfs3RRemovePack, (P)nfs3RRemoveUnpack, (S)nfs3RRemoveSize, (F)nfs3RRemovePrint, sizeof(Nfs3RRemove),
4019 (P)nfs3TRmdirPack, (P)nfs3TRmdirUnpack, (S)nfs3TRmdirSize, (F)nfs3TRmdirPrint, sizeof(Nfs3TRmdir),
4020 (P)nfs3RRmdirPack, (P)nfs3RRmdirUnpack, (S)nfs3RRmdirSize, (F)nfs3RRmdirPrint, sizeof(Nfs3RRmdir),
4021 (P)nfs3TRenamePack, (P)nfs3TRenameUnpack, (S)nfs3TRenameSize, (F)nfs3TRenamePrint, sizeof(Nfs3TRename),
4022 (P)nfs3RRenamePack, (P)nfs3RRenameUnpack, (S)nfs3RRenameSize, (F)nfs3RRenamePrint, sizeof(Nfs3RRename),
4023 (P)nfs3TLinkPack, (P)nfs3TLinkUnpack, (S)nfs3TLinkSize, (F)nfs3TLinkPrint, sizeof(Nfs3TLink),
4024 (P)nfs3RLinkPack, (P)nfs3RLinkUnpack, (S)nfs3RLinkSize, (F)nfs3RLinkPrint, sizeof(Nfs3RLink),
4025 (P)nfs3TReadDirPack, (P)nfs3TReadDirUnpack, (S)nfs3TReadDirSize, (F)nfs3TReadDirPrint, sizeof(Nfs3TReadDir),
4026 (P)nfs3RReadDirPack, (P)nfs3RReadDirUnpack, (S)nfs3RReadDirSize, (F)nfs3RReadDirPrint, sizeof(Nfs3RReadDir),
4027 (P)nfs3TReadDirPlusPack, (P)nfs3TReadDirPlusUnpack, (S)nfs3TReadDirPlusSize, (F)nfs3TReadDirPlusPrint, sizeof(Nfs3TReadDirPlus),
4028 (P)nfs3RReadDirPlusPack, (P)nfs3RReadDirPlusUnpack, (S)nfs3RReadDirPlusSize, (F)nfs3RReadDirPlusPrint, sizeof(Nfs3RReadDirPlus),
4029 (P)nfs3TFsStatPack, (P)nfs3TFsStatUnpack, (S)nfs3TFsStatSize, (F)nfs3TFsStatPrint, sizeof(Nfs3TFsStat),
4030 (P)nfs3RFsStatPack, (P)nfs3RFsStatUnpack, (S)nfs3RFsStatSize, (F)nfs3RFsStatPrint, sizeof(Nfs3RFsStat),
4031 (P)nfs3TFsInfoPack, (P)nfs3TFsInfoUnpack, (S)nfs3TFsInfoSize, (F)nfs3TFsInfoPrint, sizeof(Nfs3TFsInfo),
4032 (P)nfs3RFsInfoPack, (P)nfs3RFsInfoUnpack, (S)nfs3RFsInfoSize, (F)nfs3RFsInfoPrint, sizeof(Nfs3RFsInfo),
4033 (P)nfs3TPathconfPack, (P)nfs3TPathconfUnpack, (S)nfs3TPathconfSize, (F)nfs3TPathconfPrint, sizeof(Nfs3TPathconf),
4034 (P)nfs3RPathconfPack, (P)nfs3RPathconfUnpack, (S)nfs3RPathconfSize, (F)nfs3RPathconfPrint, sizeof(Nfs3RPathconf),
4035 (P)nfs3TCommitPack, (P)nfs3TCommitUnpack, (S)nfs3TCommitSize, (F)nfs3TCommitPrint, sizeof(Nfs3TCommit),
4036 (P)nfs3RCommitPack, (P)nfs3RCommitUnpack, (S)nfs3RCommitSize, (F)nfs3RCommitPrint, sizeof(Nfs3RCommit)
4037 };
4038
4039 SunProg nfs3Prog =
4040 {
4041 Nfs3Program,
4042 Nfs3Version,
4043 proc,
4044 nelem(proc),
4045 };
4046