sys/src/libsunrpc/nfs3.c

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