TBBT/trace_play/sfs_3_xdr.c

   1 #ifndef lint
   2 static char sfs_3_xdrSid[] = "@(#)sfs_3_xdr.c 2.1     97/10/23";
   3 #endif
   4
   5 /*
   6  *   Copyright (c) 1992-1997,2001 by Standard Performance Evaluation Corporation
   7  *      All rights reserved.
   8  *              Standard Performance Evaluation Corporation (SPEC)
   9  *              6585 Merchant Place, Suite 100
  10  *              Warrenton, VA 20187
  11  *
  12  *      This product contains benchmarks acquired from several sources who
  13  *      understand and agree with SPEC's goal of creating fair and objective
  14  *      benchmarks to measure computer performance.
  15  *
  16  *      This copyright notice is placed here only to protect SPEC in the
  17  *      event the source is misused in any manner that is contrary to the
  18  *      spirit, the goals and the intent of SPEC.
  19  *
  20  *      The source code is provided to the user or company under the license
  21  *      agreement for the SPEC Benchmark Suite for this product.
  22  */
  23
  24 /*
  25  * -------------------------- sfs_3_xdr.c --------------------------
  26  *
  27  *      XDR routines for the nfs protocol.
  28  *
  29  *.Exported_routines
  30  *      xdr_GETATTR3args(XDR *, GETATTR3args *)
  31  *      xdr_GETATTR3res(XDR *, GETATTR3res *)
  32  *      xdr_SETATTR3args(XDR *, SETATTR3args *)
  33  *      xdr_SETATTR3res(XDR *, SETATTR3res *)
  34  *      xdr_LOOKUP3args(XDR *, LOOKUP3args *)
  35  *      xdr_LOOKUP3res(XDR *, LOOKUP3res *)
  36  *      xdr_ACCESS3args(XDR *, ACCESS3args *)
  37  *      xdr_ACCESS3res(XDR *, ACCESS3res *)
  38  *      xdr_READLINK3args(XDR *, READLINK3args *)
  39  *      xdr_READLINK3res(XDR *, READLINK3res *)
  40  *      xdr_READ3args(XDR *, READ3args *)
  41  *      xdr_READ3res(XDR *, READ3res *)
  42  *      xdr_WRITE3args(XDR *, WRITE3args *)
  43  *      xdr_WRITE3res(XDR *, WRITE3res *)
  44  *      xdr_CREATE3args(XDR *, CREATE3args *)
  45  *      xdr_CREATE3res(XDR *, CREATE3res *)
  46  *      xdr_MKDIR3args(XDR *, MKDIR3args *)
  47  *      xdr_MKDIR3res(XDR *, MKDIR3res *)
  48  *      xdr_SYMLINK3args(XDR *, SYMLINK3args *)
  49  *      xdr_SYMLINK3res(XDR *, SYMLINK3res *)
  50  *      xdr_MKNOD3args(XDR *, MKNOD3args *)
  51  *      xdr_MKNOD3res(XDR *, MKNOD3res *)
  52  *      xdr_REMOVE3args(XDR *, REMOVE3args *)
  53  *      xdr_REMOVE3res(XDR *, REMOVE3res *)
  54  *      xdr_RMDIR3args(XDR *, RMDIR3args *)
  55  *      xdr_RMDIR3res(XDR *, RMDIR3res *)
  56  *      xdr_RENAME3args(XDR *, RENAME3args *)
  57  *      xdr_RENAME3res(XDR *, RENAME3res *)
  58  *      xdr_LINK3args(XDR *, LINK3args *)
  59  *      xdr_LINK3res(XDR *, LINK3res *)
  60  *      xdr_READDIR3args(XDR *, READDIR3args *)
  61  *      xdr_READDIR3res(XDR *, READDIR3res *)
  62  *      xdr_READDIRPLUS3args(XDR *, READDIRPLUS3args *)
  63  *      xdr_READDIRPLUS3res(XDR *, READDIRPLUS3res *)
  64  *      xdr_FSSTAT3args(XDR *, FSSTAT3args *)
  65  *      xdr_FSSTAT3res(XDR *, FSSTAT3res *)
  66  *      xdr_FSINFO3args(XDR *, FSINFO3args *)
  67  *      xdr_FSINFO3res(XDR *, FSINFO3res *)
  68  *      xdr_PATHCONF3args(XDR *, PATHCONF3args *)
  69  *      xdr_PATHCONF3res(XDR *, PATHCONF3res *)
  70  *      xdr_COMMIT3args(XDR *, COMMIT3args *)
  71  *      xdr_COMMIT3res(XDR *, COMMIT3res *)
  72  *      xdr_mntres3(XDR *, mountres3 *)
  73  *
  74  *.Local_routines
  75  *      xdr_string3(XDR *, char **, unsigned int)
  76  *      xdr_filename3(XDR *, filename3 *)
  77  *      xdr_nfspath3(XDR *, nfspath3 *)
  78  *      xdr_nfs_uint64_t(XDR *, nfs_uint64_t *)
  79  *      xdr_cookieverf3(XDR *, cookieverf3)
  80  *      xdr_createverf3(XDR *, createverf3)
  81  *      xdr_writeverf3(XDR *, writeverf3)
  82  *      xdr_nfs_fh3(XDR *, nfs_fh3 *)
  83  *      xdr_diropargs3(XDR *, diropargs3 *)
  84  *      xdr_nfstime3(XDR *, nfstime3 *)
  85  *      xdr_specdata3(XDR *, specdata3 *)
  86  *      xdr_nfsstat3(XDR *, nfsstat3 *)
  87  *      xdr_ftype3(XDR *, ftype3 *)
  88  *      xdr_fattr3(XDR *, fattr3 *)
  89  *      xdr_post_op_attr(XDR *, post_op_attr *)
  90  *      xdr_wcc_attr(XDR *, wcc_attr *)
  91  *      xdr_pre_op_attr(XDR *, pre_op_attr *)
  92  *      xdr_wcc_data(XDR *, wcc_data *)
  93  *      xdr_post_op_fh3(XDR *, post_op_fh3 *)
  94  *      xdr_time_how(XDR *, time_how *)
  95  *      xdr_set_mode3(XDR *, set_mode3 *)
  96  *      xdr_set_uid3(XDR *, set_uid3 *)
  97  *      xdr_set_gid3(XDR *, set_gid3 *)
  98  *      xdr_set_size3(XDR *, set_size3 *)
  99  *      xdr_set_atime(XDR *, set_atime *)
 100  *      xdr_set_mtime(XDR *, set_mtime *)
 101  *      xdr_sattr3(XDR *, sattr3 *)
 102  *      xdr_GETATTR3resok(XDR *, GETATTR3resok *)
 103  *      xdr_sattrguard3(XDR *, sattrguard3 *)
 104  *      xdr_SETATTR3resok(XDR *, SETATTR3resok *)
 105  *      xdr_SETATTR3resfail(XDR *, SETATTR3resfail *)
 106  *      xdr_LOOKUP3resok(XDR *, LOOKUP3resok *)
 107  *      xdr_LOOKUP3resfail(XDR *, LOOKUP3resfail *)
 108  *      xdr_ACCESS3resok(XDR *, ACCESS3resok *)
 109  *      xdr_ACCESS3resfail(XDR *, ACCESS3resfail *)
 110  *      xdr_READLINK3resok(XDR *, READLINK3resok *)
 111  *      xdr_READLINK3resfail(XDR *, READLINK3resfail *)
 112  *      xdr_READ3resok(XDR *, READ3resok *)
 113  *      xdr_READ3resfail(XDR *, READ3resfail *)
 114  *      xdr_stable_how(XDR *, stable_how *)
 115  *      xdr_WRITE3resok(XDR *, WRITE3resok *)
 116  *      xdr_WRITE3resfail(XDR *, WRITE3resfail *)
 117  *      xdr_createmode3(XDR *, createmode3 *)
 118  *      xdr_createhow3(XDR *, createhow3 *)
 119  *      xdr_CREATE3resok(XDR *, CREATE3resok *)
 120  *      xdr_CREATE3resfail(XDR *, CREATE3resfail *)
 121  *      xdr_MKDIR3resok(XDR *, MKDIR3resok *)
 122  *      xdr_MKDIR3resfail(XDR *, MKDIR3resfail *)
 123  *      xdr_symlinkdata3(XDR *, symlinkdata3 *)
 124  *      xdr_SYMLINK3resok(XDR *, SYMLINK3resok *)
 125  *      xdr_SYMLINK3resfail(XDR *, SYMLINK3resfail *)
 126  *      xdr_devicedata3(XDR *, devicedata3 *)
 127  *      xdr_mknoddata3(XDR *, mknoddata3 *)
 128  *      xdr_MKNOD3resok(XDR *, MKNOD3resok *)
 129  *      xdr_MKNOD3resfail(XDR *, MKNOD3resfail *)
 130  *      xdr_REMOVE3resok(XDR *, REMOVE3resok *)
 131  *      xdr_REMOVE3resfail(XDR *, REMOVE3resfail *)
 132  *      xdr_RMDIR3resok(XDR *, RMDIR3resok *)
 133  *      xdr_RMDIR3resfail(XDR *, RMDIR3resfail *)
 134  *      xdr_RENAME3resok(XDR *, RENAME3resok *)
 135  *      xdr_RENAME3resfail(XDR *, RENAME3resfail *)
 136  *      xdr_LINK3resok(XDR *, LINK3resok *)
 137  *      xdr_LINK3resfail(XDR *, LINK3resfail *)
 138  *      xdr_getdirlist(XDR *, READDIR3resok *)
 139  *      xdr_READDIR3resok(XDR *, READDIR3resok *)
 140  *      xdr_READDIR3resfail(XDR *, READDIR3resfail *)
 141  *      xdr_getdirpluslist(XDR *, READDIRPLUS3resok *)
 142  *      xdr_READDIRPLUS3resok(XDR *, READDIRPLUS3resok *)
 143  *      xdr_READDIRPLUS3resfail(XDR *, READDIRPLUS3resfail *)
 144  *      xdr_FSSTAT3resok(XDR *, FSSTAT3resok *)
 145  *      xdr_FSSTAT3resfail(XDR *, FSSTAT3resfail *)
 146  *      xdr_FSINFO3resok(XDR *, FSINFO3resok *)
 147  *      xdr_FSINFO3resfail(XDR *, FSINFO3resfail *)
 148  *      xdr_PATHCONF3resok(XDR *, PATHCONF3resok *)
 149  *      xdr_PATHCONF3resfail(XDR *, PATHCONF3resfail *)
 150  *      xdr_COMMIT3resok(XDR *, COMMIT3resok *)
 151  *      xdr_COMMIT3resfail(XDR *, COMMIT3resfail *)
 152  *
 153  *.Revision_History
 154  *      28-Jun-94       ChakChung Ng    Created.
 155  */
 156
 157
 158 /*
 159  * -------------------------  Include Files  -------------------------
 160  */
 161
 162 /*
 163  * ANSI C headers
 164  */
 165 #include <stdio.h>
 166 #include <stdlib.h>
 167 #include <string.h>
 168 #include <errno.h>
 169
 170 #include <sys/types.h>
 171 #include <sys/stat.h>
 172
 173 #include "sfs_c_def.h"
 174
 175 /*
 176  * -----------------------  SFS XDR Routines  -------------------------
 177  */
 178
 179 /*
 180  * xdr_string3 deals with "C strings" - arrays of bytes that are terminated by
 181  * a NULL character.  The parameter cpp references a pointer to storage. If the
 182  * pointer is null, then necessary storage is allocated.  The last parameter is
 183  * the max allowed length of the string as allowed by the system.  The NFS
 184  * Version 3 protocol does not place limits on strings, but the implementation
 185  * needs to place a reasonable limit to avoid problems.
 186  */
 187
 188 static bool_t
 189 xdr_string3(
 190     XDR *               xdrs,
 191     char **             cpp,
 192     unsigned int        maxsize)
 193 {
 194         char *sp;
 195         unsigned int size, nodesize;
 196
 197         /*
 198          * first deal with the length since xdr strings are counted-strings
 199          */
 200         sp = *cpp;
 201         switch (xdrs->x_op) {
 202         case XDR_FREE:
 203                 if (sp == NULL || sp == nfs3nametoolong)
 204                         return(TRUE);  /* already free */
 205                 /* FALLTHROUGH */
 206         case XDR_ENCODE:
 207                 size = strlen(sp);
 208                 break;
 209         }
 210
 211         if (!xdr_u_int(xdrs, &size))
 212                 return(FALSE);
 213
 214         /*
 215          * now deal with the actual bytes
 216          */
 217         switch (xdrs->x_op) {
 218         case XDR_DECODE:
 219                 if (size > maxsize) {
 220                         int xskp = (((((int)size) + 3) / 4) * 4);
 221
 222                         *cpp = nfs3nametoolong;
 223                         if ((xdrs->x_handy -= xskp) < 0)
 224                                 return(FALSE);
 225                         xdrs->x_private += xskp;
 226                         return(TRUE);
 227                 }
 228                 nodesize = size + 1;
 229                 if (nodesize == 0)
 230                         return(TRUE);
 231                 if (sp == NULL) {
 232                         sp = (char *)malloc(nodesize);
 233                         *cpp = sp;
 234                         if (sp == NULL)
 235                                 return(FALSE);
 236                 }
 237                 sp[size] = 0;   /* 0 through size-1 are original string */
 238                 /* FALLTHROUGH */
 239         case XDR_ENCODE:
 240                 return(xdr_opaque(xdrs, sp, size));
 241         case XDR_FREE:
 242                 nodesize = size + 1;
 243                 mem_free((caddr_t)sp, nodesize);
 244                 *cpp = NULL;
 245                 return(TRUE);
 246         }
 247
 248         return(FALSE);
 249 }
 250
 251 static bool_t
 252 xdr_filename3(
 253     XDR *               xdrs,
 254     filename3 *         objp)
 255 {
 256
 257         return(xdr_string3(xdrs, objp, NFS_MAXNAMLEN));
 258 }
 259
 260 static bool_t
 261 xdr_nfspath3(
 262     XDR *               xdrs,
 263     nfspath3 *          objp)
 264 {
 265
 266         return(xdr_string3(xdrs, objp, NFS_MAXPATHLEN));
 267 }
 268
 269 static bool_t
 270 xdr_nfs_uint64_t(
 271     XDR                 *xdrs,
 272     nfs_uint64_t *      objp)
 273 {
 274         return(xdr_int(xdrs, (int *)&objp->_p._u) &&
 275                                         xdr_int(xdrs, (int *)&objp->_p._l));
 276 }
 277
 278 static bool_t
 279 xdr_cookieverf3(
 280     XDR *               xdrs,
 281     cookieverf3         objp)
 282 {
 283         return(xdr_opaque(xdrs, objp, NFS3_COOKIEVERFSIZE));
 284 }
 285
 286 static bool_t
 287 xdr_createverf3(
 288     XDR *               xdrs,
 289     createverf3         objp)
 290 {
 291         return(xdr_opaque(xdrs, objp, NFS3_CREATEVERFSIZE));
 292 }
 293
 294 static bool_t
 295 xdr_writeverf3(
 296     XDR *               xdrs,
 297     writeverf3          objp)
 298 {
 299         return(xdr_opaque(xdrs, objp, NFS3_WRITEVERFSIZE));
 300 }
 301
 302 static bool_t
 303 xdr_nfs_fh3(
 304     XDR *               xdrs,
 305     nfs_fh3 *           objp)
 306 {
 307         if (!xdr_u_int(xdrs, &objp->fh3_length))
 308                 return(FALSE);
 309
 310         if (objp->fh3_length > NFS3_FHSIZE)
 311                 return(FALSE);
 312         if (xdrs->x_op == XDR_DECODE || xdrs->x_op == XDR_ENCODE)
 313                 return(xdr_opaque(xdrs, objp->fh3_u.data, objp->fh3_length));
 314
 315         if (xdrs->x_op == XDR_FREE)
 316                 return(TRUE);
 317
 318         return(FALSE);
 319 }
 320
 321 static bool_t
 322 xdr_diropargs3(
 323     XDR *               xdrs,
 324     diropargs3 *        objp)
 325 {
 326         if (xdr_nfs_fh3(xdrs, &objp->dir))
 327                 return(xdr_filename3(xdrs, &objp->name));
 328         return(FALSE);
 329 }
 330
 331 static bool_t
 332 xdr_nfstime3(
 333     XDR *               xdrs,
 334     nfstime3 *          objp)
 335 {
 336         if (xdr_uint32_t(xdrs, &objp->seconds))
 337                 return(xdr_uint32_t(xdrs, &objp->nseconds));
 338         return(FALSE);
 339 }
 340
 341 static bool_t
 342 xdr_specdata3(
 343     XDR *               xdrs,
 344     specdata3 *         objp)
 345 {
 346         if (xdr_uint32_t(xdrs, &objp->specdata1))
 347                 return(xdr_uint32_t(xdrs, &objp->specdata2));
 348         return(FALSE);
 349 }
 350
 351 static bool_t
 352 xdr_nfsstat3(
 353     XDR *               xdrs,
 354     nfsstat3 *          objp)
 355 {
 356         return(xdr_enum(xdrs, (enum_t *)objp));
 357 }
 358
 359 static bool_t
 360 xdr_ftype3(
 361     XDR *               xdrs,
 362     ftype3 *            objp)
 363 {
 364         return(xdr_enum(xdrs, (enum_t *)objp));
 365 }
 366
 367 static bool_t
 368 xdr_fattr3(
 369     XDR *               xdrs,
 370     fattr3 *            objp)
 371 {
 372         if (!xdr_ftype3(xdrs, &objp->type))
 373                 return(FALSE);
 374         if (!xdr_uint32_t(xdrs, &objp->mode))
 375                 return(FALSE);
 376         if (!xdr_uint32_t(xdrs, &objp->nlink))
 377                 return(FALSE);
 378         if (!xdr_uint32_t(xdrs, &objp->uid))
 379                 return(FALSE);
 380         if (!xdr_uint32_t(xdrs, &objp->gid))
 381                 return(FALSE);
 382         if (!xdr_nfs_uint64_t(xdrs, &objp->size))
 383                 return(FALSE);
 384         if (!xdr_nfs_uint64_t(xdrs, &objp->used))
 385                 return(FALSE);
 386         if (!xdr_specdata3(xdrs, &objp->rdev))
 387                 return(FALSE);
 388         if (!xdr_nfs_uint64_t(xdrs, &objp->fsid))
 389                 return(FALSE);
 390         if (!xdr_nfs_uint64_t(xdrs, &objp->fileid))
 391                 return(FALSE);
 392         if (!xdr_nfstime3(xdrs, &objp->atime))
 393                 return(FALSE);
 394         if (!xdr_nfstime3(xdrs, &objp->mtime))
 395                 return(FALSE);
 396         if (!xdr_nfstime3(xdrs, &objp->ctime))
 397                 return(FALSE);
 398         return(TRUE);
 399 }
 400
 401 static bool_t
 402 xdr_post_op_attr(
 403     XDR *               xdrs,
 404     post_op_attr *      objp)
 405 {
 406         if (!xdr_bool(xdrs, &objp->attributes))
 407                 return(FALSE);
 408         switch (objp->attributes) {
 409         case TRUE:      return(xdr_fattr3(xdrs, &objp->attr));
 410         case FALSE:     return(TRUE);
 411         default:        return(FALSE);
 412         }
 413 }
 414
 415 static bool_t
 416 xdr_wcc_attr(
 417     XDR *               xdrs,
 418     wcc_attr *          objp)
 419 {
 420         if (xdr_nfs_uint64_t(xdrs, &objp->size) &&
 421                                         xdr_nfstime3(xdrs, &objp->mtime))
 422                 return(xdr_nfstime3(xdrs, &objp->ctime));
 423         return(FALSE);
 424 }
 425
 426 static bool_t
 427 xdr_pre_op_attr(
 428     XDR *               xdrs,
 429     pre_op_attr *       objp)
 430 {
 431         if (!xdr_bool(xdrs, &objp->attributes))
 432                 return(FALSE);
 433         switch (objp->attributes) {
 434         case TRUE:      return(xdr_wcc_attr(xdrs, &objp->attr));
 435         case FALSE:     return(TRUE);
 436         default:        return(FALSE);
 437         }
 438 }
 439
 440 static bool_t
 441 xdr_wcc_data(
 442     XDR *               xdrs,
 443     wcc_data *          objp)
 444 {
 445         if (xdr_pre_op_attr(xdrs, &objp->before))
 446                 return(xdr_post_op_attr(xdrs, &objp->after));
 447         return(FALSE);
 448 }
 449
 450 static bool_t
 451 xdr_post_op_fh3(
 452     XDR *               xdrs,
 453     post_op_fh3 *       objp)
 454 {
 455         if (!xdr_bool(xdrs, &objp->handle_follows))
 456                 return(FALSE);
 457         switch (objp->handle_follows) {
 458         case TRUE:      return(xdr_nfs_fh3(xdrs, &objp->handle));
 459         case FALSE:     return(TRUE);
 460         default:        return(FALSE);
 461         }
 462 }
 463
 464 static bool_t
 465 xdr_time_how(
 466     XDR *               xdrs,
 467     time_how *          objp)
 468 {
 469         return(xdr_enum(xdrs, (enum_t *)objp));
 470 }
 471
 472 static bool_t
 473 xdr_set_mode3(
 474     XDR *               xdrs,
 475     set_mode3 *         objp)
 476 {
 477         if (!xdr_bool(xdrs, &objp->set_it))
 478                 return(FALSE);
 479         if (objp->set_it == TRUE)
 480                 return(xdr_uint32_t(xdrs, &objp->mode));
 481         return(TRUE);
 482 }
 483
 484 static bool_t
 485 xdr_set_uid3(
 486     XDR *               xdrs,
 487     set_uid3 *          objp)
 488 {
 489         if (!xdr_bool(xdrs, &objp->set_it))
 490                 return(FALSE);
 491         if (objp->set_it == TRUE)
 492                 return(xdr_uint32_t(xdrs, &objp->uid));
 493         return(TRUE);
 494 }
 495
 496 static bool_t
 497 xdr_set_gid3(
 498     XDR *               xdrs,
 499     set_gid3 *          objp)
 500 {
 501         if (!xdr_bool(xdrs, &objp->set_it))
 502                 return(FALSE);
 503         if (objp->set_it == TRUE)
 504                 return(xdr_uint32_t(xdrs, &objp->gid));
 505         return(TRUE);
 506 }
 507
 508 static bool_t
 509 xdr_set_size3(
 510     XDR *               xdrs,
 511     set_size3 *         objp)
 512 {
 513         if (!xdr_bool(xdrs, &objp->set_it))
 514                 return(FALSE);
 515         if (objp->set_it == TRUE)
 516                 return(xdr_nfs_uint64_t(xdrs, &objp->size));
 517         return(TRUE);
 518 }
 519
 520 static bool_t
 521 xdr_set_atime(
 522     XDR *               xdrs,
 523     set_atime *         objp)
 524 {
 525         if (!xdr_time_how(xdrs, &objp->set_it))
 526                 return(FALSE);
 527         if (objp->set_it == SET_TO_CLIENT_TIME)
 528                 return(xdr_nfstime3(xdrs, &objp->atime));
 529         return(TRUE);
 530 }
 531
 532 static bool_t
 533 xdr_set_mtime(
 534     XDR *               xdrs,
 535     set_mtime *         objp)
 536 {
 537         if (!xdr_time_how(xdrs, &objp->set_it))
 538                 return(FALSE);
 539         if (objp->set_it == SET_TO_CLIENT_TIME)
 540                 return(xdr_nfstime3(xdrs, &objp->mtime));
 541         return(TRUE);
 542 }
 543
 544 static bool_t
 545 xdr_sattr3(
 546     XDR *               xdrs,
 547     sattr3 *            objp)
 548 {
 549         if (xdr_set_mode3(xdrs, &objp->mode) &&
 550                                         xdr_set_uid3(xdrs, &objp->uid) &&
 551                                         xdr_set_gid3(xdrs, &objp->gid) &&
 552                                         xdr_set_size3(xdrs, &objp->size) &&
 553                                         xdr_set_atime(xdrs, &objp->atime))
 554                 return(xdr_set_mtime(xdrs, &objp->mtime));
 555         return(FALSE);
 556 }
 557
 558
 559 bool_t
 560 xdr_GETATTR3args(
 561     XDR *               xdrs,
 562     GETATTR3args *      objp)
 563 {
 564         return(xdr_nfs_fh3(xdrs, &objp->object));
 565 }
 566
 567 static bool_t
 568 xdr_GETATTR3resok(
 569     XDR *               xdrs,
 570     GETATTR3resok *     objp)
 571 {
 572         return(xdr_fattr3(xdrs, &objp->obj_attributes));
 573 }
 574
 575 bool_t
 576 xdr_GETATTR3res(
 577     XDR *               xdrs,
 578     GETATTR3res *       objp)
 579 {
 580         if (!xdr_nfsstat3(xdrs, &objp->status))
 581                 return(FALSE);
 582         if (objp->status == NFS3_OK)
 583                 return(xdr_GETATTR3resok(xdrs, &objp->resok));
 584         return(TRUE);
 585 }
 586
 587
 588 static bool_t
 589 xdr_sattrguard3(
 590     XDR *               xdrs,
 591     sattrguard3 *       objp)
 592 {
 593         if (!xdr_bool(xdrs, &objp->check))
 594                 return(FALSE);
 595         switch (objp->check) {
 596         case TRUE:      return(xdr_nfstime3(xdrs, &objp->obj_ctime));
 597         case FALSE:     return(TRUE);
 598         default:        return(FALSE);
 599         }
 600 }
 601
 602 bool_t
 603 xdr_SETATTR3args(
 604     XDR *               xdrs,
 605     SETATTR3args *      objp)
 606 {
 607         if (xdr_nfs_fh3(xdrs, &objp->object) &&
 608                                 xdr_sattr3(xdrs, &objp->new_attributes))
 609                 return(xdr_sattrguard3(xdrs, &objp->guard));
 610         return(FALSE);
 611 }
 612
 613 static bool_t
 614 xdr_SETATTR3resok(
 615     XDR *               xdrs,
 616     SETATTR3resok *     objp)
 617 {
 618         return(xdr_wcc_data(xdrs, &objp->obj_wcc));
 619 }
 620
 621 static bool_t
 622 xdr_SETATTR3resfail(
 623     XDR *               xdrs,
 624     SETATTR3resfail *   objp)
 625 {
 626         return(xdr_wcc_data(xdrs, &objp->obj_wcc));
 627 }
 628
 629 bool_t
 630 xdr_SETATTR3res(
 631     XDR *               xdrs,
 632     SETATTR3res *       objp)
 633 {
 634         if (!xdr_nfsstat3(xdrs, &objp->status))
 635                 return(FALSE);
 636         if (objp->status == NFS3_OK)
 637                 return(xdr_SETATTR3resok(xdrs, &objp->resok));
 638         return(xdr_SETATTR3resfail(xdrs, &objp->resfail));
 639 }
 640
 641
 642 bool_t
 643 xdr_LOOKUP3args(
 644     XDR *               xdrs,
 645     LOOKUP3args *       objp)
 646 {
 647         return(xdr_diropargs3(xdrs, &objp->what));
 648 }
 649
 650 static bool_t
 651 xdr_LOOKUP3resok(
 652     XDR *               xdrs,
 653     LOOKUP3resok *      objp)
 654 {
 655         if (xdr_nfs_fh3(xdrs, &objp->object) &&
 656                                 xdr_post_op_attr(xdrs, &objp->obj_attributes))
 657                 return(xdr_post_op_attr(xdrs, &objp->dir_attributes));
 658         return(FALSE);
 659 }
 660
 661 static bool_t
 662 xdr_LOOKUP3resfail(
 663     XDR *               xdrs,
 664     LOOKUP3resfail *    objp)
 665 {
 666         return(xdr_post_op_attr(xdrs, &objp->dir_attributes));
 667 }
 668
 669 bool_t
 670 xdr_LOOKUP3res(
 671     XDR *               xdrs,
 672     LOOKUP3res *        objp)
 673 {
 674         if (!xdr_nfsstat3(xdrs, &objp->status))
 675                 return(FALSE);
 676         if (objp->status == NFS3_OK)
 677                 return(xdr_LOOKUP3resok(xdrs, &objp->resok));
 678         return(xdr_LOOKUP3resfail(xdrs, &objp->resfail));
 679 }
 680
 681
 682 bool_t
 683 xdr_ACCESS3args(
 684     XDR *               xdrs,
 685     ACCESS3args *       objp)
 686 {
 687         if (xdr_nfs_fh3(xdrs, &objp->object))
 688                 return(xdr_uint32_t(xdrs, &objp->access));
 689         return(FALSE);
 690 }
 691
 692 static bool_t
 693 xdr_ACCESS3resok(
 694     XDR *               xdrs,
 695     ACCESS3resok *      objp)
 696 {
 697         if (xdr_post_op_attr(xdrs, &objp->obj_attributes))
 698                 return(xdr_uint32_t(xdrs, &objp->access));
 699         return(FALSE);
 700 }
 701
 702 static bool_t
 703 xdr_ACCESS3resfail(
 704     XDR *               xdrs,
 705     ACCESS3resfail *    objp)
 706 {
 707         return(xdr_post_op_attr(xdrs, &objp->obj_attributes));
 708 }
 709
 710 bool_t
 711 xdr_ACCESS3res(
 712     XDR *               xdrs,
 713     ACCESS3res *        objp)
 714 {
 715         if (!xdr_nfsstat3(xdrs, &objp->status))
 716                 return(FALSE);
 717         if (objp->status == NFS3_OK)
 718                 return(xdr_ACCESS3resok(xdrs, &objp->resok));
 719         return(xdr_ACCESS3resfail(xdrs, &objp->resfail));
 720 }
 721
 722
 723 bool_t
 724 xdr_READLINK3args(
 725     XDR *               xdrs,
 726     READLINK3args *     objp)
 727 {
 728         return(xdr_nfs_fh3(xdrs, &objp->symlink));
 729 }
 730
 731 static bool_t
 732 xdr_READLINK3resok(
 733     XDR *               xdrs,
 734     READLINK3resok *    objp)
 735 {
 736         if (xdr_post_op_attr(xdrs, &objp->symlink_attributes))
 737                 return(xdr_nfspath3(xdrs, &objp->data));
 738         return(FALSE);
 739 }
 740
 741 static bool_t
 742 xdr_READLINK3resfail(
 743     XDR *               xdrs,
 744     READLINK3resfail *  objp)
 745 {
 746         return(xdr_post_op_attr(xdrs, &objp->symlink_attributes));
 747 }
 748
 749 bool_t
 750 xdr_READLINK3res(
 751     XDR *               xdrs,
 752     READLINK3res *      objp)
 753 {
 754         if (!xdr_nfsstat3(xdrs, &objp->status))
 755                 return(FALSE);
 756         if (objp->status == NFS3_OK)
 757                 return(xdr_READLINK3resok(xdrs, &objp->resok));
 758         return(xdr_READLINK3resfail(xdrs, &objp->resfail));
 759 }
 760
 761
 762 bool_t
 763 xdr_READ3args(
 764     XDR *               xdrs,
 765     READ3args *         objp)
 766 {
 767
 768         if (xdr_nfs_fh3(xdrs, &objp->file) &&
 769                                         xdr_nfs_uint64_t(xdrs, &objp->offset))
 770                 return(xdr_uint32_t(xdrs, &objp->count));
 771         return(FALSE);
 772 }
 773
 774 static bool_t
 775 xdr_READ3resok(
 776     XDR *               xdrs,
 777     READ3resok *        objp)
 778 {
 779         if (xdr_post_op_attr(xdrs, &objp->file_attributes) &&
 780                                         xdr_uint32_t(xdrs, &objp->count) &&
 781                                         xdr_bool(xdrs, &objp->eof))
 782                 return(xdr_bytes(xdrs, (char **)&objp->data.data_val,
 783                                         (unsigned int *)&objp->data.data_len,
 784                                         ~0));
 785         return(FALSE);
 786 }
 787
 788 static bool_t
 789 xdr_READ3resfail(
 790     XDR *               xdrs,
 791     READ3resfail *      objp)
 792 {
 793         return(xdr_post_op_attr(xdrs, &objp->file_attributes));
 794 }
 795
 796 bool_t
 797 xdr_READ3res(
 798     XDR *               xdrs,
 799     READ3res *          objp)
 800 {
 801         if (!xdr_nfsstat3(xdrs, &objp->status))
 802                 return(FALSE);
 803         if (objp->status == NFS3_OK)
 804                 return(xdr_READ3resok(xdrs, &objp->resok));
 805         return(xdr_READ3resfail(xdrs, &objp->resfail));
 806 }
 807
 808
 809 static bool_t
 810 xdr_stable_how(
 811     XDR *               xdrs,
 812     stable_how *        objp)
 813 {
 814         return(xdr_enum(xdrs, (enum_t *)objp));
 815 }
 816
 817 bool_t
 818 xdr_WRITE3args(
 819     XDR *               xdrs,
 820     WRITE3args *        objp)
 821 {
 822         if (xdr_nfs_fh3(xdrs, &objp->file) &&
 823                                         xdr_nfs_uint64_t(xdrs, &objp->offset) &&
 824                                         xdr_uint32_t(xdrs, &objp->count) &&
 825                                         xdr_stable_how(xdrs, &objp->stable))
 826                 return(xdr_bytes(xdrs, (char **)&objp->data.data_val,
 827                                         (unsigned int *)&objp->data.data_len,
 828                                         ~0));
 829         return(FALSE);
 830 }
 831
 832 static bool_t
 833 xdr_WRITE3resok(
 834     XDR *               xdrs,
 835     WRITE3resok *       objp)
 836 {
 837         if (xdr_wcc_data(xdrs, &objp->file_wcc) &&
 838                                         xdr_uint32_t(xdrs, &objp->count) &&
 839                                         xdr_stable_how(xdrs, &objp->committed))
 840                 return(xdr_writeverf3(xdrs, objp->verf));
 841         return(FALSE);
 842 }
 843
 844 static bool_t
 845 xdr_WRITE3resfail(
 846     XDR *               xdrs,
 847     WRITE3resfail *     objp)
 848 {
 849         return(xdr_wcc_data(xdrs, &objp->file_wcc));
 850 }
 851
 852 bool_t
 853 xdr_WRITE3res(
 854     XDR *               xdrs,
 855     WRITE3res *         objp)
 856 {
 857         if (!xdr_nfsstat3(xdrs, &objp->status))
 858                 return(FALSE);
 859         if (objp->status == NFS3_OK)
 860                 return(xdr_WRITE3resok(xdrs, &objp->resok));
 861         return(xdr_WRITE3resfail(xdrs, &objp->resfail));
 862 }
 863
 864
 865 static bool_t
 866 xdr_createmode3(
 867     XDR *               xdrs,
 868     createmode3 *       objp)
 869 {
 870         return(xdr_enum(xdrs, (enum_t *)objp));
 871 }
 872
 873 static bool_t
 874 xdr_createhow3(
 875     XDR *               xdrs,
 876     createhow3 *        objp)
 877 {
 878         if (!xdr_createmode3(xdrs, &objp->mode))
 879                 return(FALSE);
 880         switch (objp->mode) {
 881         case UNCHECKED:
 882         case GUARDED:
 883                 return(xdr_sattr3(xdrs, &objp->createhow3_u.obj_attributes));
 884         case EXCLUSIVE:
 885                 return(xdr_createverf3(xdrs, objp->createhow3_u.verf));
 886         default:
 887                 return(FALSE);
 888         }
 889 }
 890
 891 bool_t
 892 xdr_CREATE3args(
 893     XDR *               xdrs,
 894     CREATE3args *       objp)
 895 {
 896         if (xdr_diropargs3(xdrs, &objp->where))
 897                 return(xdr_createhow3(xdrs, &objp->how));
 898         return(FALSE);
 899 }
 900
 901 static bool_t
 902 xdr_CREATE3resok(
 903     XDR *               xdrs,
 904     CREATE3resok *      objp)
 905 {
 906         if (xdr_post_op_fh3(xdrs, &objp->obj) &&
 907                                 xdr_post_op_attr(xdrs, &objp->obj_attributes))
 908                 return(xdr_wcc_data(xdrs, &objp->dir_wcc));
 909         return(FALSE);
 910 }
 911
 912 static bool_t
 913 xdr_CREATE3resfail(
 914     XDR *               xdrs,
 915     CREATE3resfail *    objp)
 916 {
 917         return(xdr_wcc_data(xdrs, &objp->dir_wcc));
 918 }
 919
 920 bool_t
 921 xdr_CREATE3res(
 922     XDR *               xdrs,
 923     CREATE3res *        objp)
 924 {
 925         if (!xdr_nfsstat3(xdrs, &objp->status))
 926                 return(FALSE);
 927         if (objp->status == NFS3_OK)
 928                 return(xdr_CREATE3resok(xdrs, &objp->resok));
 929         return(xdr_CREATE3resfail(xdrs, &objp->resfail));
 930 }
 931
 932
 933 bool_t
 934 xdr_MKDIR3args(
 935     XDR *               xdrs,
 936     MKDIR3args *        objp)
 937 {
 938         if (xdr_diropargs3(xdrs, &objp->where))
 939                 return(xdr_sattr3(xdrs, &objp->attributes));
 940         return(FALSE);
 941 }
 942
 943 static bool_t
 944 xdr_MKDIR3resok(
 945     XDR *               xdrs,
 946     MKDIR3resok *       objp)
 947 {
 948         if (xdr_post_op_fh3(xdrs, &objp->obj) &&
 949                                 xdr_post_op_attr(xdrs, &objp->obj_attributes))
 950                 return(xdr_wcc_data(xdrs, &objp->dir_wcc));
 951         return(FALSE);
 952 }
 953
 954 static bool_t
 955 xdr_MKDIR3resfail(
 956     XDR *               xdrs,
 957     MKDIR3resfail *     objp)
 958 {
 959         return(xdr_wcc_data(xdrs, &objp->dir_wcc));
 960 }
 961
 962 bool_t
 963 xdr_MKDIR3res(
 964     XDR *               xdrs,
 965     MKDIR3res *         objp)
 966 {
 967         if (!xdr_nfsstat3(xdrs, &objp->status))
 968                 return(FALSE);
 969         if (objp->status == NFS3_OK)
 970                 return(xdr_MKDIR3resok(xdrs, &objp->resok));
 971         return(xdr_MKDIR3resfail(xdrs, &objp->resfail));
 972 }
 973
 974
 975 static bool_t
 976 xdr_symlinkdata3(
 977     XDR *               xdrs,
 978     symlinkdata3 *      objp)
 979 {
 980         if (xdr_sattr3(xdrs, &objp->symlink_attributes))
 981                 return(xdr_nfspath3(xdrs, &objp->symlink_data));
 982         return(FALSE);
 983 }
 984
 985 bool_t
 986 xdr_SYMLINK3args(
 987     XDR *               xdrs,
 988     SYMLINK3args *      objp)
 989 {
 990         if (xdr_diropargs3(xdrs, &objp->where))
 991                 return(xdr_symlinkdata3(xdrs, &objp->symlink));
 992         return(FALSE);
 993 }
 994
 995 static bool_t
 996 xdr_SYMLINK3resok(
 997     XDR *               xdrs,
 998     SYMLINK3resok *     objp)
 999 {
1000         if (xdr_post_op_fh3(xdrs, &objp->obj) &&
1001                                 xdr_post_op_attr(xdrs, &objp->obj_attributes))
1002                 return(xdr_wcc_data(xdrs, &objp->dir_wcc));
1003         return(FALSE);
1004 }
1005
1006 static bool_t
1007 xdr_SYMLINK3resfail(
1008     XDR *               xdrs,
1009     SYMLINK3resfail *   objp)
1010 {
1011         return(xdr_wcc_data(xdrs, &objp->dir_wcc));
1012 }
1013
1014 bool_t
1015 xdr_SYMLINK3res(
1016     XDR *               xdrs,
1017     SYMLINK3res *       objp)
1018 {
1019         if (!xdr_nfsstat3(xdrs, &objp->status))
1020                 return(FALSE);
1021         if (objp->status == NFS3_OK)
1022                 return(xdr_SYMLINK3resok(xdrs, &objp->resok));
1023         return(xdr_SYMLINK3resfail(xdrs, &objp->resfail));
1024 }
1025
1026
1027 static bool_t
1028 xdr_devicedata3(
1029     XDR *               xdrs,
1030     devicedata3 *       objp)
1031 {
1032         if (xdr_sattr3(xdrs, &objp->dev_attributes))
1033                 return(xdr_specdata3(xdrs, &objp->spec));
1034         return(FALSE);
1035 }
1036
1037 static bool_t
1038 xdr_mknoddata3(
1039     XDR *               xdrs,
1040     mknoddata3 *        objp)
1041 {
1042         if (!xdr_ftype3(xdrs, &objp->type))
1043                 return(FALSE);
1044         switch (objp->type) {
1045         case NF3CHR:
1046         case NF3BLK:
1047                 if (!xdr_devicedata3(xdrs, &objp->mknoddata3_u.device))
1048                         return(FALSE);
1049                 break;
1050         case NF3SOCK:
1051         case NF3FIFO:
1052                 if (!xdr_sattr3(xdrs, &objp->mknoddata3_u.pipe_attributes))
1053                         return(FALSE);
1054                 break;
1055         }
1056         return(TRUE);
1057 }
1058
1059 bool_t
1060 xdr_MKNOD3args(
1061     XDR *               xdrs,
1062     MKNOD3args *        objp)
1063 {
1064         if (xdr_diropargs3(xdrs, &objp->where))
1065                 return(xdr_mknoddata3(xdrs, &objp->what));
1066         return(FALSE);
1067 }
1068
1069 static bool_t
1070 xdr_MKNOD3resok(
1071     XDR *               xdrs,
1072     MKNOD3resok *       objp)
1073 {
1074         if (xdr_post_op_fh3(xdrs, &objp->obj) &&
1075                                 xdr_post_op_attr(xdrs, &objp->obj_attributes))
1076                 return(xdr_wcc_data(xdrs, &objp->dir_wcc));
1077         return(FALSE);
1078 }
1079
1080 static bool_t
1081 xdr_MKNOD3resfail(
1082     XDR *               xdrs,
1083     MKNOD3resfail *     objp)
1084 {
1085         return(xdr_wcc_data(xdrs, &objp->dir_wcc));
1086 }
1087
1088 bool_t
1089 xdr_MKNOD3res(
1090     XDR *               xdrs,
1091     MKNOD3res *         objp)
1092 {
1093         if (!xdr_nfsstat3(xdrs, &objp->status))
1094                 return(FALSE);
1095         if (objp->status == NFS3_OK)
1096                 return(xdr_MKNOD3resok(xdrs, &objp->resok));
1097         return(xdr_MKNOD3resfail(xdrs, &objp->resfail));
1098 }
1099
1100
1101 bool_t
1102 xdr_REMOVE3args(
1103     XDR *               xdrs,
1104     REMOVE3args *       objp)
1105 {
1106         return(xdr_diropargs3(xdrs, &objp->object));
1107 }
1108
1109 static bool_t
1110 xdr_REMOVE3resok(
1111     XDR *               xdrs,
1112     REMOVE3resok *      objp)
1113 {
1114         return(xdr_wcc_data(xdrs, &objp->dir_wcc));
1115 }
1116
1117 static bool_t
1118 xdr_REMOVE3resfail(
1119     XDR *               xdrs,
1120     REMOVE3resfail *    objp)
1121 {
1122         return(xdr_wcc_data(xdrs, &objp->dir_wcc));
1123 }
1124
1125 bool_t
1126 xdr_REMOVE3res(
1127     XDR *               xdrs,
1128     REMOVE3res *        objp)
1129 {
1130         if (!xdr_nfsstat3(xdrs, &objp->status))
1131                 return(FALSE);
1132         if (objp->status == NFS3_OK)
1133                 return(xdr_REMOVE3resok(xdrs, &objp->resok));
1134         return(xdr_REMOVE3resfail(xdrs, &objp->resfail));
1135 }
1136
1137
1138 bool_t
1139 xdr_RMDIR3args(
1140     XDR *               xdrs,
1141     RMDIR3args *        objp)
1142 {
1143         return(xdr_diropargs3(xdrs, &objp->object));
1144 }
1145
1146 static bool_t
1147 xdr_RMDIR3resok(
1148     XDR *               xdrs,
1149     RMDIR3resok *       objp)
1150 {
1151         return(xdr_wcc_data(xdrs, &objp->dir_wcc));
1152 }
1153
1154 static bool_t
1155 xdr_RMDIR3resfail(
1156     XDR *               xdrs,
1157     RMDIR3resfail *     objp)
1158 {
1159         return(xdr_wcc_data(xdrs, &objp->dir_wcc));
1160 }
1161
1162 bool_t
1163 xdr_RMDIR3res(
1164     XDR *               xdrs,
1165     RMDIR3res *         objp)
1166 {
1167         if (!xdr_nfsstat3(xdrs, &objp->status))
1168                 return(FALSE);
1169         if (objp->status == NFS3_OK)
1170                 return(xdr_RMDIR3resok(xdrs, &objp->resok));
1171         return(xdr_RMDIR3resfail(xdrs, &objp->resfail));
1172 }
1173
1174
1175 bool_t
1176 xdr_RENAME3args(
1177     XDR *               xdrs,
1178     RENAME3args *       objp)
1179 {
1180         if (xdr_diropargs3(xdrs, &objp->from))
1181                 return(xdr_diropargs3(xdrs, &objp->to));
1182         return(FALSE);
1183 }
1184
1185 static bool_t
1186 xdr_RENAME3resok(
1187     XDR *               xdrs,
1188     RENAME3resok *      objp)
1189 {
1190         if (xdr_wcc_data(xdrs, &objp->fromdir_wcc))
1191                 return(xdr_wcc_data(xdrs, &objp->todir_wcc));
1192         return(FALSE);
1193 }
1194
1195 static bool_t
1196 xdr_RENAME3resfail(
1197     XDR *               xdrs,
1198     RENAME3resfail *    objp)
1199 {
1200         if (xdr_wcc_data(xdrs, &objp->fromdir_wcc))
1201                 return(xdr_wcc_data(xdrs, &objp->todir_wcc));
1202         return(FALSE);
1203 }
1204
1205 bool_t
1206 xdr_RENAME3res(
1207     XDR *               xdrs,
1208     RENAME3res *        objp)
1209 {
1210         if (!xdr_nfsstat3(xdrs, &objp->status))
1211                 return(FALSE);
1212         if (objp->status == NFS3_OK)
1213                 return(xdr_RENAME3resok(xdrs, &objp->resok));
1214         return(xdr_RENAME3resfail(xdrs, &objp->resfail));
1215 }
1216
1217
1218 bool_t
1219 xdr_LINK3args(
1220     XDR *               xdrs,
1221     LINK3args *         objp)
1222 {
1223         if (xdr_nfs_fh3(xdrs, &objp->file))
1224                 return(xdr_diropargs3(xdrs, &objp->link));
1225         return(FALSE);
1226 }
1227
1228 static bool_t
1229 xdr_LINK3resok(
1230     XDR *               xdrs,
1231     LINK3resok *        objp)
1232 {
1233         if (xdr_post_op_attr(xdrs, &objp->file_attributes))
1234                 return(xdr_wcc_data(xdrs, &objp->linkdir_wcc));
1235         return(FALSE);
1236 }
1237
1238 static bool_t
1239 xdr_LINK3resfail(
1240     XDR *               xdrs,
1241     LINK3resfail *      objp)
1242 {
1243         if (xdr_post_op_attr(xdrs, &objp->file_attributes))
1244                 return(xdr_wcc_data(xdrs, &objp->linkdir_wcc));
1245         return(FALSE);
1246 }
1247
1248 bool_t
1249 xdr_LINK3res(
1250     XDR *               xdrs,
1251     LINK3res *          objp)
1252 {
1253         if (!xdr_nfsstat3(xdrs, &objp->status))
1254                 return(FALSE);
1255         if (objp->status == NFS3_OK)
1256                 return(xdr_LINK3resok(xdrs, &objp->resok));
1257         return(xdr_LINK3resfail(xdrs, &objp->resfail));
1258 }
1259
1260
1261 bool_t
1262 xdr_READDIR3args(
1263     XDR *               xdrs,
1264     READDIR3args *      objp)
1265 {
1266         if (xdr_nfs_fh3(xdrs, &objp->dir) &&
1267                                         xdr_nfs_uint64_t(xdrs, &objp->cookie) &&
1268                                         xdr_cookieverf3(xdrs, objp->cookieverf))
1269                 return(xdr_uint32_t(xdrs, &objp->count));
1270         return(FALSE);
1271 }
1272
1273 #define roundtoint(x)   (((x) + sizeof (int) - 1) & ~(sizeof (int) - 1))
1274
1275 /*
1276  * DECODE ONLY
1277  */
1278 static bool_t
1279 xdr_getdirlist(
1280     XDR *               xdrs,
1281     READDIR3resok *     objp)
1282 {
1283         register int    i;
1284         bool_t          valid;
1285         unsigned int    namlen;
1286         char            name[SFS_MAXNAMLEN];
1287         nfs_uint64_t    fileid, cookie;
1288         entry3          *dp;
1289
1290         i = 0;
1291         dp = objp->reply.entries;
1292         for (;;) {
1293                 if (!xdr_bool(xdrs, &valid))
1294                         return(FALSE);
1295                 if (!valid)
1296                         break;
1297                 if (!xdr_nfs_uint64_t(xdrs, &fileid) ||
1298                                                 !xdr_u_int(xdrs, &namlen))
1299                         return(FALSE);
1300                 if (namlen >= SFS_MAXNAMLEN)
1301                         namlen = SFS_MAXNAMLEN - 1;
1302                 if (!xdr_opaque(xdrs, name, namlen) ||
1303                                         !xdr_nfs_uint64_t(xdrs, &cookie))
1304                         return(FALSE);
1305                 name[namlen] = '\0';
1306                 if (i < SFS_MAXDIRENTS) {
1307                     dp[i].fileid = fileid;
1308                     (void)memmove(dp[i].name, name, (namlen+1));
1309                     dp[i].cookie = cookie;
1310                     i++;
1311                 }
1312         }
1313         objp->count = i;
1314         if (!xdr_bool(xdrs, &objp->reply.eof))
1315                 return(FALSE);
1316         return(TRUE);
1317 }
1318
1319 static bool_t
1320 xdr_READDIR3resok(
1321     XDR *               xdrs,
1322     READDIR3resok *     objp)
1323 {
1324         if (!xdr_post_op_attr(xdrs, &objp->dir_attributes))
1325                 return(FALSE);
1326         if (!xdr_cookieverf3(xdrs, objp->cookieverf))
1327                 return(FALSE);
1328         if (xdrs->x_op == XDR_DECODE)
1329                 return(xdr_getdirlist(xdrs, objp));
1330         return(TRUE);
1331 }
1332
1333 static bool_t
1334 xdr_READDIR3resfail(
1335     XDR *               xdrs,
1336     READDIR3resfail *   objp)
1337 {
1338         return(xdr_post_op_attr(xdrs, &objp->dir_attributes));
1339 }
1340
1341 bool_t
1342 xdr_READDIR3res(
1343     XDR *               xdrs,
1344     READDIR3res *       objp)
1345 {
1346         if (!xdr_nfsstat3(xdrs, &objp->status))
1347                 return(FALSE);
1348         if (objp->status == NFS3_OK)
1349                 return(xdr_READDIR3resok(xdrs, &objp->resok));
1350         return(xdr_READDIR3resfail(xdrs, &objp->resfail));
1351 }
1352
1353 bool_t
1354 xdr_READDIRPLUS3args(
1355     XDR *               xdrs,
1356     READDIRPLUS3args *  objp)
1357 {
1358         if (xdr_nfs_fh3(xdrs, &objp->dir) &&
1359                                 xdr_nfs_uint64_t(xdrs, &objp->cookie) &&
1360                                 xdr_cookieverf3(xdrs, objp->cookieverf) &&
1361                                 xdr_uint32_t(xdrs, &objp->dircount))
1362                 return(xdr_uint32_t(xdrs, &objp->maxcount));
1363         return(FALSE);
1364 }
1365
1366 /*
1367  * copy post_op_attr from s2 to s1
1368  */
1369 static void
1370 copy_post_op_attr(post_op_attr *s1, post_op_attr *s2)
1371 {
1372         s1->attributes = s2->attributes;
1373         (void) memmove((void *) &s1->attr, (void *) &s2->attr,
1374                        sizeof (fattr3));
1375 }
1376
1377 /*
1378  * copy post_op_fh3 from s2 to s1
1379  */
1380 static void
1381 copy_post_op_fh3(post_op_fh3 *s1, post_op_fh3 *s2)
1382 {
1383         s1->handle_follows = s2->handle_follows;
1384         (void) memmove((void *) &s1->handle, (void *) &s2->handle,
1385                        sizeof (nfs_fh3));
1386 }
1387
1388 /*
1389  * DECODE ONLY
1390  */
1391 static bool_t
1392 xdr_getdirpluslist(
1393     XDR *               xdrs,
1394     READDIRPLUS3resok * objp)
1395 {
1396         register int    i;
1397         bool_t          valid;
1398         unsigned int    namlen;
1399         char            name[SFS_MAXNAMLEN];
1400         nfs_uint64_t    fileid, cookie;
1401         entryplus3      *dp;
1402         post_op_attr    at;
1403         post_op_fh3     fh;
1404
1405         i = 0;
1406         dp = objp->reply.entries;
1407         for (;;) {
1408                 if (!xdr_bool(xdrs, &valid))
1409                         return(FALSE);
1410                 if (!valid)
1411                         break;
1412                 if (!xdr_nfs_uint64_t(xdrs, &fileid) ||
1413                                         !xdr_u_int(xdrs, &namlen))
1414                         return(FALSE);
1415                 if (namlen >= SFS_MAXNAMLEN)
1416                         namlen = SFS_MAXNAMLEN - 1;
1417                 if (!xdr_opaque(xdrs, name, namlen) ||
1418                                         !xdr_nfs_uint64_t(xdrs, &cookie))
1419                         return(FALSE);
1420                 name[namlen] = '\0';
1421                 if (!xdr_post_op_attr(xdrs, &at))
1422                         return(FALSE);
1423                 if (!xdr_post_op_fh3(xdrs, &fh))
1424                         return(FALSE);
1425                 if (i < SFS_MAXDIRENTS) {
1426                     dp[i].fileid = fileid;
1427                     (void)memmove(dp[i].name, name, (namlen+1));
1428                     dp[i].cookie = cookie;
1429                     copy_post_op_attr(&dp[i].name_attributes, &at);
1430                     copy_post_op_fh3(&dp[i].name_handle, &fh);
1431                     i++;
1432                 }
1433         }
1434
1435         objp->count = i;
1436         if (!xdr_bool(xdrs, &objp->reply.eof))
1437                 return(FALSE);
1438         return(TRUE);
1439 }
1440
1441 static bool_t
1442 xdr_READDIRPLUS3resok(
1443     XDR *               xdrs,
1444     READDIRPLUS3resok * objp)
1445 {
1446
1447         if (!xdr_post_op_attr(xdrs, &objp->dir_attributes))
1448                 return(FALSE);
1449         if (!xdr_cookieverf3(xdrs, objp->cookieverf))
1450                 return(FALSE);
1451         if (xdrs->x_op == XDR_DECODE)
1452                 return(xdr_getdirpluslist(xdrs, objp));
1453         return(TRUE);
1454 }
1455
1456 static bool_t
1457 xdr_READDIRPLUS3resfail(
1458     XDR *                       xdrs,
1459     READDIRPLUS3resfail *       objp)
1460 {
1461         return(xdr_post_op_attr(xdrs, &objp->dir_attributes));
1462 }
1463
1464 bool_t
1465 xdr_READDIRPLUS3res(
1466     XDR *               xdrs,
1467     READDIRPLUS3res *   objp)
1468 {
1469         if (!xdr_nfsstat3(xdrs, &objp->status))
1470                 return(FALSE);
1471         if (objp->status == NFS3_OK)
1472                 return(xdr_READDIRPLUS3resok(xdrs, &objp->resok));
1473         return(xdr_READDIRPLUS3resfail(xdrs, &objp->resfail));
1474 }
1475
1476 bool_t
1477 xdr_FSSTAT3args(
1478     XDR *               xdrs,
1479     FSSTAT3args *       objp)
1480 {
1481         return(xdr_nfs_fh3(xdrs, &objp->fsroot));
1482 }
1483
1484 static bool_t
1485 xdr_FSSTAT3resok(
1486     XDR *               xdrs,
1487     FSSTAT3resok *      objp)
1488 {
1489         if (!xdr_post_op_attr(xdrs, &objp->obj_attributes))
1490                 return(FALSE);
1491         if (!xdr_nfs_uint64_t(xdrs, &objp->tbytes))
1492                 return(FALSE);
1493         if (!xdr_nfs_uint64_t(xdrs, &objp->fbytes))
1494                 return(FALSE);
1495         if (!xdr_nfs_uint64_t(xdrs, &objp->abytes))
1496                 return(FALSE);
1497         if (!xdr_nfs_uint64_t(xdrs, &objp->tfiles))
1498                 return(FALSE);
1499         if (!xdr_nfs_uint64_t(xdrs, &objp->ffiles))
1500                 return(FALSE);
1501         if (!xdr_nfs_uint64_t(xdrs, &objp->afiles))
1502                 return(FALSE);
1503         if (!xdr_uint32_t(xdrs, &objp->invarsec))
1504                 return(FALSE);
1505         return(TRUE);
1506 }
1507
1508 static bool_t
1509 xdr_FSSTAT3resfail(
1510     XDR *               xdrs,
1511     FSSTAT3resfail *    objp)
1512 {
1513         return(xdr_post_op_attr(xdrs, &objp->obj_attributes));
1514 }
1515
1516 bool_t
1517 xdr_FSSTAT3res(
1518     XDR *               xdrs,
1519     FSSTAT3res *        objp)
1520 {
1521         if (!xdr_nfsstat3(xdrs, &objp->status))
1522                 return(FALSE);
1523         if (objp->status == NFS3_OK)
1524                 return(xdr_FSSTAT3resok(xdrs, &objp->resok));
1525         return(xdr_FSSTAT3resfail(xdrs, &objp->resfail));
1526 }
1527
1528 bool_t
1529 xdr_FSINFO3args(
1530     XDR *               xdrs,
1531     FSINFO3args *       objp)
1532 {
1533         return(xdr_nfs_fh3(xdrs, &objp->fsroot));
1534 }
1535
1536 static bool_t
1537 xdr_FSINFO3resok(
1538     XDR *               xdrs,
1539     FSINFO3resok *      objp)
1540 {
1541         if (!xdr_post_op_attr(xdrs, &objp->obj_attributes))
1542                 return(FALSE);
1543         if (!xdr_uint32_t(xdrs, &objp->rtmax))
1544                 return(FALSE);
1545         if (!xdr_uint32_t(xdrs, &objp->rtpref))
1546                 return(FALSE);
1547         if (!xdr_uint32_t(xdrs, &objp->rtmult))
1548                 return(FALSE);
1549         if (!xdr_uint32_t(xdrs, &objp->wtmax))
1550                 return(FALSE);
1551         if (!xdr_uint32_t(xdrs, &objp->wtpref))
1552                 return(FALSE);
1553         if (!xdr_uint32_t(xdrs, &objp->wtmult))
1554                 return(FALSE);
1555         if (!xdr_uint32_t(xdrs, &objp->dtpref))
1556                 return(FALSE);
1557         if (!xdr_nfs_uint64_t(xdrs, &objp->maxfilesize))
1558                 return(FALSE);
1559         if (!xdr_nfstime3(xdrs, &objp->time_delta))
1560                 return(FALSE);
1561         if (!xdr_uint32_t(xdrs, &objp->properties))
1562                 return(FALSE);
1563         return(TRUE);
1564 }
1565
1566 static bool_t
1567 xdr_FSINFO3resfail(
1568     XDR *               xdrs,
1569     FSINFO3resfail *    objp)
1570 {
1571         return(xdr_post_op_attr(xdrs, &objp->obj_attributes));
1572 }
1573
1574 bool_t
1575 xdr_FSINFO3res(
1576     XDR *               xdrs,
1577     FSINFO3res *        objp)
1578 {
1579         if (!xdr_nfsstat3(xdrs, &objp->status))
1580                 return(FALSE);
1581         if (objp->status == NFS3_OK)
1582                 return(xdr_FSINFO3resok(xdrs, &objp->resok));
1583         return(xdr_FSINFO3resfail(xdrs, &objp->resfail));
1584 }
1585
1586 bool_t
1587 xdr_PATHCONF3args(
1588     XDR *               xdrs,
1589     PATHCONF3args *     objp)
1590 {
1591         return(xdr_nfs_fh3(xdrs, &objp->object));
1592 }
1593
1594 static bool_t
1595 xdr_PATHCONF3resok(
1596     XDR *               xdrs,
1597     PATHCONF3resok *    objp)
1598 {
1599         if (!xdr_post_op_attr(xdrs, &objp->obj_attributes))
1600                 return(FALSE);
1601         if (!xdr_uint32_t(xdrs, &objp->link_max))
1602                 return(FALSE);
1603         if (!xdr_uint32_t(xdrs, &objp->name_max))
1604                 return(FALSE);
1605         if (!xdr_bool(xdrs, &objp->no_trunc))
1606                 return(FALSE);
1607         if (!xdr_bool(xdrs, &objp->chown_restricted))
1608                 return(FALSE);
1609         if (!xdr_bool(xdrs, &objp->case_insensitive))
1610                 return(FALSE);
1611         if (!xdr_bool(xdrs, &objp->case_preserving))
1612                 return(FALSE);
1613         return(TRUE);
1614 }
1615
1616 static bool_t
1617 xdr_PATHCONF3resfail(
1618     XDR *               xdrs,
1619     PATHCONF3resfail *  objp)
1620 {
1621         return(xdr_post_op_attr(xdrs, &objp->obj_attributes));
1622 }
1623
1624 bool_t
1625 xdr_PATHCONF3res(
1626     XDR *               xdrs,
1627     PATHCONF3res *      objp)
1628 {
1629         if (!xdr_nfsstat3(xdrs, &objp->status))
1630                 return(FALSE);
1631         if (objp->status == NFS3_OK)
1632                 return(xdr_PATHCONF3resok(xdrs, &objp->resok));
1633         return(xdr_PATHCONF3resfail(xdrs, &objp->resfail));
1634 }
1635
1636 bool_t
1637 xdr_COMMIT3args(
1638     XDR *               xdrs,
1639     COMMIT3args *       objp)
1640 {
1641         if (xdr_nfs_fh3(xdrs, &objp->file) &&
1642                                         xdr_nfs_uint64_t(xdrs, &objp->offset))
1643                 return(xdr_uint32_t(xdrs, &objp->count));
1644         return(FALSE);
1645 }
1646
1647 static bool_t
1648 xdr_COMMIT3resok(
1649     XDR *               xdrs,
1650     COMMIT3resok *      objp)
1651 {
1652         if (xdr_wcc_data(xdrs, &objp->file_wcc))
1653                 return(xdr_writeverf3(xdrs, objp->verf));
1654         return(FALSE);
1655 }
1656
1657 static bool_t
1658 xdr_COMMIT3resfail(
1659     XDR *               xdrs,
1660     COMMIT3resfail *    objp)
1661 {
1662         return(xdr_wcc_data(xdrs, &objp->file_wcc));
1663 }
1664
1665 bool_t
1666 xdr_COMMIT3res(
1667     XDR *               xdrs,
1668     COMMIT3res *        objp)
1669 {
1670         if (!xdr_nfsstat3(xdrs, &objp->status))
1671                 return(FALSE);
1672         if (objp->status == NFS3_OK)
1673                 return(xdr_COMMIT3resok(xdrs, &objp->resok));
1674         return(xdr_COMMIT3resfail(xdrs, &objp->resfail));
1675 }
1676
1677
1678 bool_t
1679 xdr_dirpath(
1680     XDR *               xdrs,
1681     dirpath *           objp)
1682 {
1683         return(xdr_string(xdrs, objp, MNTPATHLEN));
1684 }
1685
1686 static bool_t
1687 xdr_fhandle3(
1688     XDR *               xdrs,
1689     fhandle3 *          objp)
1690 {
1691         return(xdr_bytes(xdrs, (char **) &objp->fhandle3_val,
1692                                 (unsigned int *) &objp->fhandle3_len, NFS3_FHSIZE));
1693 }
1694
1695 static bool_t
1696 xdr_mntres3_ok(
1697     XDR *               xdrs,
1698     mntres3_ok *        objp)
1699 {
1700         if (xdr_fhandle3(xdrs, &objp->fhandle)) {
1701                 return(xdr_array(xdrs,
1702                         (void **) &objp->auth_flavors.auth_flavors_val,
1703                         (unsigned int *) &objp->auth_flavors.auth_flavors_len,
1704                         ~0, sizeof (int), (xdrproc_t) xdr_int));
1705         }
1706         return(FALSE);
1707 }
1708
1709 bool_t
1710 xdr_mntres3(
1711     XDR *               xdrs,
1712     mountres3 *         objp)
1713 {
1714         if (!xdr_enum(xdrs, (enum_t *) &objp->fhs_status))
1715                 return(FALSE);
1716         if (objp->fhs_status == MNT_OK)
1717                 return(xdr_mntres3_ok(xdrs, &objp->mntres3_u.mntinfo));
1718         return(TRUE);
1719 }
1720 /* sfs_3_xdr.c */