contrib/amd/libamu/xdr_func.c

   1 /*
   2  * Copyright (c) 1997-2014 Erez Zadok
   3  * Copyright (c) 1990 Jan-Simon Pendry
   4  * Copyright (c) 1990 Imperial College of Science, Technology & Medicine
   5  * Copyright (c) 1990 The Regents of the University of California.
   6  * All rights reserved.
   7  *
   8  * This code is derived from software contributed to Berkeley by
   9  * Jan-Simon Pendry at Imperial College, London.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 3. Neither the name of the University nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  *
  35  *
  36  * File: am-utils/libamu/xdr_func.c
  37  *
  38  */
  39
  40 /*
  41  * Complete list of all possible xdr functions which may be needed.
  42  */
  43 #ifdef HAVE_CONFIG_H
  44 # include <config.h>
  45 #endif /* HAVE_CONFIG_H */
  46 #include <am_defs.h>
  47 #include <amu.h>
  48
  49 #ifdef __RPCSVC_MOUNT_H__
  50 # error IRIX6 should not include rpcsvc/mount.h
  51 #endif /* __RPCSVC_MOUNT_H__ */
  52
  53 /*
  54  * MACROS:
  55  */
  56 #ifdef HAVE_FS_AUTOFS
  57 # ifndef AUTOFS_MAXCOMPONENTLEN
  58 #  define AUTOFS_MAXCOMPONENTLEN 255
  59 # endif /* not AUTOFS_MAXCOMPONENTLEN */
  60 # ifndef AUTOFS_MAXOPTSLEN
  61 #  define AUTOFS_MAXOPTSLEN 255
  62 # endif /* not AUTOFS_MAXOPTSLEN */
  63 # ifndef AUTOFS_MAXPATHLEN
  64 #  define AUTOFS_MAXPATHLEN 1024
  65 # endif /* not AUTOFS_MAXPATHLEN */
  66 #endif /* HAVE_FS_AUTOFS */
  67
  68 /* forward definitions, are they needed? */
  69 extern bool_t xdr_exportnode(XDR *xdrs, exportnode *objp);
  70 extern bool_t xdr_groupnode(XDR *xdrs, groupnode *objp);
  71 extern bool_t xdr_name(XDR *xdrs, name *objp);
  72
  73
  74 #ifndef HAVE_XDR_ATTRSTAT
  75 bool_t
  76 xdr_attrstat(XDR *xdrs, nfsattrstat *objp)
  77 {
  78   if (amuDebug(D_XDRTRACE))
  79     plog(XLOG_DEBUG, "xdr_attrstat:");
  80
  81   if (!xdr_nfsstat(xdrs, &objp->ns_status)) {
  82     return (FALSE);
  83   }
  84   switch (objp->ns_status) {
  85   case NFS_OK:
  86     if (!xdr_fattr(xdrs, &objp->ns_u.ns_attr_u)) {
  87       return (FALSE);
  88     }
  89     break;
  90   default:
  91     break;
  92   }
  93   return (TRUE);
  94 }
  95 #endif /* not HAVE_XDR_ATTRSTAT */
  96
  97
  98 #ifndef HAVE_XDR_CREATEARGS
  99 bool_t
 100 xdr_createargs(XDR *xdrs, nfscreateargs *objp)
 101 {
 102   if (amuDebug(D_XDRTRACE))
 103     plog(XLOG_DEBUG, "xdr_createargs:");
 104
 105   if (!xdr_diropargs(xdrs, &objp->ca_where)) {
 106     return (FALSE);
 107   }
 108   if (!xdr_sattr(xdrs, &objp->ca_attributes)) {
 109     return (FALSE);
 110   }
 111   return (TRUE);
 112 }
 113 #endif /* not HAVE_XDR_CREATEARGS */
 114
 115
 116 #ifndef HAVE_XDR_DIRLIST
 117 bool_t
 118 xdr_dirlist(XDR *xdrs, nfsdirlist *objp)
 119 {
 120   if (amuDebug(D_XDRTRACE))
 121     plog(XLOG_DEBUG, "xdr_dirlist:");
 122
 123   if (!xdr_pointer(xdrs, (char **) &objp->dl_entries, sizeof(nfsentry), (XDRPROC_T_TYPE) xdr_entry)) {
 124     return (FALSE);
 125   }
 126   if (!xdr_bool(xdrs, &objp->dl_eof)) {
 127     return (FALSE);
 128   }
 129   return (TRUE);
 130 }
 131 #endif /* not HAVE_XDR_DIRLIST */
 132
 133
 134 #ifndef HAVE_XDR_DIROPARGS
 135 bool_t
 136 xdr_diropargs(XDR *xdrs, nfsdiropargs *objp)
 137 {
 138   if (amuDebug(D_XDRTRACE))
 139     plog(XLOG_DEBUG, "xdr_diropargs:");
 140
 141   if (!xdr_nfs_fh(xdrs, &objp->da_fhandle)) {
 142     return (FALSE);
 143   }
 144   if (!xdr_filename(xdrs, &objp->da_name)) {
 145     return (FALSE);
 146   }
 147   return (TRUE);
 148 }
 149 #endif /* not HAVE_XDR_DIROPARGS */
 150
 151
 152 #ifndef HAVE_XDR_DIROPOKRES
 153 bool_t
 154 xdr_diropokres(XDR *xdrs, nfsdiropokres *objp)
 155 {
 156   if (amuDebug(D_XDRTRACE))
 157     plog(XLOG_DEBUG, "xdr_diropokres:");
 158
 159   if (!xdr_nfs_fh(xdrs, &objp->drok_fhandle)) {
 160     return (FALSE);
 161   }
 162   if (!xdr_fattr(xdrs, &objp->drok_attributes)) {
 163     return (FALSE);
 164   }
 165   return (TRUE);
 166 }
 167 #endif /* not HAVE_XDR_DIROPOKRES */
 168
 169
 170 #ifndef HAVE_XDR_DIROPRES
 171 bool_t
 172 xdr_diropres(XDR *xdrs, nfsdiropres *objp)
 173 {
 174   if (amuDebug(D_XDRTRACE))
 175     plog(XLOG_DEBUG, "xdr_diropres:");
 176
 177   if (!xdr_nfsstat(xdrs, &objp->dr_status)) {
 178     return (FALSE);
 179   }
 180   switch (objp->dr_status) {
 181   case NFS_OK:
 182     if (!xdr_diropokres(xdrs, &objp->dr_u.dr_drok_u)) {
 183       return (FALSE);
 184     }
 185     break;
 186   default:
 187     break;
 188   }
 189   return (TRUE);
 190 }
 191 #endif /* not HAVE_XDR_DIROPRES */
 192
 193
 194 #ifndef HAVE_XDR_DIRPATH
 195 bool_t
 196 xdr_dirpath(XDR *xdrs, dirpath *objp)
 197 {
 198   if (amuDebug(D_XDRTRACE))
 199     plog(XLOG_DEBUG, "xdr_dirpath:");
 200
 201   if (!xdr_string(xdrs, objp, MNTPATHLEN)) {
 202     return (FALSE);
 203   }
 204   return (TRUE);
 205 }
 206 #endif /* not HAVE_XDR_DIRPATH */
 207
 208
 209 #ifndef HAVE_XDR_ENTRY
 210 bool_t
 211 xdr_entry(XDR *xdrs, nfsentry *objp)
 212 {
 213   if (amuDebug(D_XDRTRACE))
 214     plog(XLOG_DEBUG, "xdr_entry:");
 215
 216   if (!xdr_u_int(xdrs, &objp->ne_fileid)) {
 217     return (FALSE);
 218   }
 219   if (!xdr_filename(xdrs, &objp->ne_name)) {
 220     return (FALSE);
 221   }
 222   if (!xdr_nfscookie(xdrs, objp->ne_cookie)) {
 223     return (FALSE);
 224   }
 225   if (!xdr_pointer(xdrs, (char **) &objp->ne_nextentry, sizeof(nfsentry), (XDRPROC_T_TYPE) xdr_entry)) {
 226     return (FALSE);
 227   }
 228   return (TRUE);
 229 }
 230 #endif /* not HAVE_XDR_ENTRY */
 231
 232
 233 #ifndef HAVE_XDR_EXPORTNODE
 234 bool_t
 235 xdr_exportnode(XDR *xdrs, exportnode *objp)
 236 {
 237   if (amuDebug(D_XDRTRACE))
 238     plog(XLOG_DEBUG, "xdr_exportnode:");
 239
 240   if (!xdr_dirpath(xdrs, &objp->ex_dir)) {
 241     return (FALSE);
 242   }
 243   if (!xdr_groups(xdrs, &objp->ex_groups)) {
 244     return (FALSE);
 245   }
 246   if (!xdr_exports(xdrs, &objp->ex_next)) {
 247     return (FALSE);
 248   }
 249   return (TRUE);
 250 }
 251 #endif /* not HAVE_XDR_EXPORTNODE */
 252
 253
 254 #ifndef HAVE_XDR_EXPORTS
 255 bool_t
 256 xdr_exports(XDR *xdrs, exports *objp)
 257 {
 258   if (amuDebug(D_XDRTRACE))
 259     plog(XLOG_DEBUG, "xdr_exports:");
 260
 261   if (!xdr_pointer(xdrs, (char **) objp, sizeof(exportnode), (XDRPROC_T_TYPE) xdr_exportnode)) {
 262     return (FALSE);
 263   }
 264   return (TRUE);
 265 }
 266 #endif /* not HAVE_XDR_EXPORTS */
 267
 268
 269 #ifndef HAVE_XDR_FATTR
 270 bool_t
 271 xdr_fattr(XDR *xdrs, nfsfattr *objp)
 272 {
 273   if (amuDebug(D_XDRTRACE))
 274     plog(XLOG_DEBUG, "xdr_fattr:");
 275
 276   if (!xdr_ftype(xdrs, &objp->na_type)) {
 277     return (FALSE);
 278   }
 279   if (!xdr_u_int(xdrs, &objp->na_mode)) {
 280     return (FALSE);
 281   }
 282   if (!xdr_u_int(xdrs, &objp->na_nlink)) {
 283     return (FALSE);
 284   }
 285   if (!xdr_u_int(xdrs, &objp->na_uid)) {
 286     return (FALSE);
 287   }
 288   if (!xdr_u_int(xdrs, &objp->na_gid)) {
 289     return (FALSE);
 290   }
 291   if (!xdr_u_int(xdrs, &objp->na_size)) {
 292     return (FALSE);
 293   }
 294   if (!xdr_u_int(xdrs, &objp->na_blocksize)) {
 295     return (FALSE);
 296   }
 297   if (!xdr_u_int(xdrs, &objp->na_rdev)) {
 298     return (FALSE);
 299   }
 300   if (!xdr_u_int(xdrs, &objp->na_blocks)) {
 301     return (FALSE);
 302   }
 303   if (!xdr_u_int(xdrs, &objp->na_fsid)) {
 304     return (FALSE);
 305   }
 306   if (!xdr_u_int(xdrs, &objp->na_fileid)) {
 307     return (FALSE);
 308   }
 309   if (!xdr_nfstime(xdrs, &objp->na_atime)) {
 310     return (FALSE);
 311   }
 312   if (!xdr_nfstime(xdrs, &objp->na_mtime)) {
 313     return (FALSE);
 314   }
 315   if (!xdr_nfstime(xdrs, &objp->na_ctime)) {
 316     return (FALSE);
 317   }
 318   return (TRUE);
 319 }
 320 #endif /* not HAVE_XDR_FATTR */
 321
 322
 323 #ifndef HAVE_XDR_FHANDLE
 324 bool_t
 325 xdr_fhandle(XDR *xdrs, fhandle objp)
 326 {
 327   if (amuDebug(D_XDRTRACE))
 328     plog(XLOG_DEBUG, "xdr_fhandle:");
 329
 330   if (!xdr_opaque(xdrs, objp, NFS_FHSIZE)) {
 331     return (FALSE);
 332   }
 333   return (TRUE);
 334 }
 335 #endif /* not HAVE_XDR_FHANDLE */
 336
 337
 338 #ifndef HAVE_XDR_FHSTATUS
 339 bool_t
 340 xdr_fhstatus(XDR *xdrs, fhstatus *objp)
 341 {
 342   if (amuDebug(D_XDRTRACE))
 343     plog(XLOG_DEBUG, "xdr_fhstatus:");
 344
 345   if (!xdr_u_int(xdrs, &objp->fhs_status)) {
 346     return (FALSE);
 347   }
 348   if (objp->fhs_status == 0 && !xdr_fhandle(xdrs, objp->fhs_fh)) {
 349     return (FALSE);
 350   }
 351   return (TRUE);
 352 }
 353 #endif /* not HAVE_XDR_FHSTATUS */
 354
 355
 356 #ifndef HAVE_XDR_FILENAME
 357 bool_t
 358 xdr_filename(XDR *xdrs, filename *objp)
 359 {
 360   if (amuDebug(D_XDRTRACE))
 361     plog(XLOG_DEBUG, "xdr_filename:");
 362
 363   if (!xdr_string(xdrs, objp, NFS_MAXNAMLEN)) {
 364     return (FALSE);
 365   }
 366   return (TRUE);
 367 }
 368 #endif /* not HAVE_XDR_FILENAME */
 369
 370
 371 #ifndef HAVE_XDR_FTYPE
 372 bool_t
 373 xdr_ftype(XDR *xdrs, nfsftype *objp)
 374 {
 375   enum_t local_obj = *objp;
 376
 377   if (amuDebug(D_XDRTRACE))
 378     plog(XLOG_DEBUG, "xdr_ftype:");
 379
 380   if (!xdr_enum(xdrs, &local_obj)) {
 381     return (FALSE);
 382   }
 383   return (TRUE);
 384 }
 385 #endif /* not HAVE_XDR_FTYPE */
 386
 387
 388 #ifndef HAVE_XDR_GROUPNODE
 389 bool_t
 390 xdr_groupnode(XDR *xdrs, groupnode *objp)
 391 {
 392   if (amuDebug(D_XDRTRACE))
 393     plog(XLOG_DEBUG, "xdr_groupnode:");
 394
 395   if (!xdr_name(xdrs, &objp->gr_name)) {
 396     return (FALSE);
 397   }
 398   if (!xdr_groups(xdrs, &objp->gr_next)) {
 399     return (FALSE);
 400   }
 401   return (TRUE);
 402 }
 403 #endif /* not HAVE_XDR_GROUPNODE */
 404
 405
 406 #ifndef HAVE_XDR_GROUPS
 407 bool_t
 408 xdr_groups(XDR *xdrs, groups *objp)
 409 {
 410   if (amuDebug(D_XDRTRACE))
 411     plog(XLOG_DEBUG, "xdr_groups:");
 412
 413   if (!xdr_pointer(xdrs, (char **) objp, sizeof(groupnode), (XDRPROC_T_TYPE) xdr_groupnode)) {
 414     return (FALSE);
 415   }
 416   return (TRUE);
 417 }
 418 #endif /* not HAVE_XDR_GROUPS */
 419
 420
 421 #ifndef HAVE_XDR_LINKARGS
 422 bool_t
 423 xdr_linkargs(XDR *xdrs, nfslinkargs *objp)
 424 {
 425   if (amuDebug(D_XDRTRACE))
 426     plog(XLOG_DEBUG, "xdr_linkargs:");
 427
 428   if (!xdr_nfs_fh(xdrs, &objp->la_fhandle)) {
 429     return (FALSE);
 430   }
 431   if (!xdr_diropargs(xdrs, &objp->la_to)) {
 432     return (FALSE);
 433   }
 434   return (TRUE);
 435 }
 436 #endif /* not HAVE_XDR_LINKARGS */
 437
 438
 439 #ifndef HAVE_XDR_MOUNTBODY
 440 bool_t
 441 xdr_mountbody(XDR *xdrs, mountbody *objp)
 442 {
 443   if (amuDebug(D_XDRTRACE))
 444     plog(XLOG_DEBUG, "xdr_mountbody:");
 445
 446   if (!xdr_name(xdrs, &objp->ml_hostname)) {
 447     return (FALSE);
 448   }
 449   if (!xdr_dirpath(xdrs, &objp->ml_directory)) {
 450     return (FALSE);
 451   }
 452   if (!xdr_mountlist(xdrs, &objp->ml_next)) {
 453     return (FALSE);
 454   }
 455   return (TRUE);
 456 }
 457 #endif /* not HAVE_XDR_MOUNTBODY */
 458
 459
 460 #ifndef HAVE_XDR_MOUNTLIST
 461 bool_t
 462 xdr_mountlist(XDR *xdrs, mountlist *objp)
 463 {
 464   if (amuDebug(D_XDRTRACE))
 465     plog(XLOG_DEBUG, "xdr_mountlist:");
 466
 467   if (!xdr_pointer(xdrs, (char **) objp, sizeof(mountbody), (XDRPROC_T_TYPE) xdr_mountbody)) {
 468     return (FALSE);
 469   }
 470   return (TRUE);
 471 }
 472 #endif /* not HAVE_XDR_MOUNTLIST */
 473
 474
 475 #ifndef HAVE_XDR_NAME
 476 bool_t
 477 xdr_name(XDR *xdrs, name *objp)
 478 {
 479   if (amuDebug(D_XDRTRACE))
 480     plog(XLOG_DEBUG, "xdr_name:");
 481
 482   if (!xdr_string(xdrs, objp, MNTNAMLEN)) {
 483     return (FALSE);
 484   }
 485   return (TRUE);
 486 }
 487 #endif /* not HAVE_XDR_NAME */
 488
 489
 490 #ifndef HAVE_XDR_NFS_FH
 491 bool_t
 492 xdr_nfs_fh(XDR *xdrs, am_nfs_fh *objp)
 493 {
 494   if (amuDebug(D_XDRTRACE))
 495     plog(XLOG_DEBUG, "xdr_nfs_fh:");
 496
 497   if (!xdr_opaque(xdrs, (caddr_t) objp->fh_data, NFS_FHSIZE)) {
 498     return (FALSE);
 499   }
 500   return (TRUE);
 501 }
 502 #endif /* not HAVE_XDR_NFS_FH */
 503
 504
 505 #ifndef HAVE_XDR_NFSCOOKIE
 506 bool_t
 507 xdr_nfscookie(XDR *xdrs, nfscookie objp)
 508 {
 509   if (amuDebug(D_XDRTRACE))
 510     plog(XLOG_DEBUG, "xdr_nfscookie:");
 511
 512   if (!xdr_opaque(xdrs, objp, NFS_COOKIESIZE)) {
 513     return (FALSE);
 514   }
 515   return (TRUE);
 516 }
 517 #endif /* not HAVE_XDR_NFSCOOKIE */
 518
 519
 520 #ifndef HAVE_XDR_NFSPATH
 521 bool_t
 522 xdr_nfspath(XDR *xdrs, nfspath *objp)
 523 {
 524   if (amuDebug(D_XDRTRACE))
 525     plog(XLOG_DEBUG, "xdr_nfspath:");
 526
 527   if (!xdr_string(xdrs, objp, NFS_MAXPATHLEN)) {
 528     return (FALSE);
 529   }
 530   return (TRUE);
 531 }
 532 #endif /* not HAVE_XDR_NFSPATH */
 533
 534
 535 #ifndef HAVE_XDR_NFSSTAT
 536 bool_t
 537 xdr_nfsstat(XDR *xdrs, nfsstat *objp)
 538 {
 539   enum_t local_obj = *objp;
 540
 541   if (amuDebug(D_XDRTRACE))
 542     plog(XLOG_DEBUG, "xdr_nfsstat:");
 543
 544   if (!xdr_enum(xdrs, &local_obj)) {
 545     return (FALSE);
 546   }
 547   return (TRUE);
 548 }
 549 #endif /* not HAVE_XDR_NFSSTAT */
 550
 551
 552 #ifndef HAVE_XDR_NFSTIME
 553 bool_t
 554 xdr_nfstime(XDR *xdrs, nfstime *objp)
 555 {
 556   if (amuDebug(D_XDRTRACE))
 557     plog(XLOG_DEBUG, "xdr_nfstime:");
 558
 559   if (!xdr_u_int(xdrs, (u_int *) &objp->nt_seconds)) {
 560     return (FALSE);
 561   }
 562   if (!xdr_u_int(xdrs, (u_int *) &objp->nt_useconds)) {
 563     return (FALSE);
 564   }
 565   return (TRUE);
 566 }
 567 #endif /* not HAVE_XDR_NFSTIME */
 568
 569
 570 #ifndef HAVE_XDR_POINTER
 571 bool_t
 572 xdr_pointer(register XDR *xdrs, char **objpp, u_int obj_size, XDRPROC_T_TYPE xdr_obj)
 573 {
 574   if (amuDebug(D_XDRTRACE))
 575     plog(XLOG_DEBUG, "xdr_pointer:");
 576
 577   bool_t more_data;
 578
 579   more_data = (*objpp != NULL);
 580   if (!xdr_bool(xdrs, &more_data)) {
 581     return (FALSE);
 582   }
 583   if (!more_data) {
 584     *objpp = NULL;
 585     return (TRUE);
 586   }
 587
 588   return (xdr_reference(xdrs, objpp, obj_size, xdr_obj));
 589 }
 590 #endif /* not HAVE_XDR_POINTER */
 591
 592
 593 #ifndef HAVE_XDR_READARGS
 594 bool_t
 595 xdr_readargs(XDR *xdrs, nfsreadargs *objp)
 596 {
 597   if (amuDebug(D_XDRTRACE))
 598     plog(XLOG_DEBUG, "xdr_readargs:");
 599
 600   if (!xdr_nfs_fh(xdrs, &objp->ra_fhandle)) {
 601     return (FALSE);
 602   }
 603   if (!xdr_u_int(xdrs, &objp->ra_offset)) {
 604     return (FALSE);
 605   }
 606   if (!xdr_u_int(xdrs, &objp->ra_count)) {
 607     return (FALSE);
 608   }
 609   if (!xdr_u_int(xdrs, &objp->ra_totalcount)) {
 610     return (FALSE);
 611   }
 612   return (TRUE);
 613 }
 614 #endif /* not HAVE_XDR_READARGS */
 615
 616
 617 #ifndef HAVE_XDR_READDIRARGS
 618 bool_t
 619 xdr_readdirargs(XDR *xdrs, nfsreaddirargs *objp)
 620 {
 621   if (amuDebug(D_XDRTRACE))
 622     plog(XLOG_DEBUG, "xdr_readdirargs:");
 623
 624   if (!xdr_nfs_fh(xdrs, &objp->rda_fhandle)) {
 625     return (FALSE);
 626   }
 627   if (!xdr_nfscookie(xdrs, objp->rda_cookie)) {
 628     return (FALSE);
 629   }
 630   if (!xdr_u_int(xdrs, &objp->rda_count)) {
 631     return (FALSE);
 632   }
 633   return (TRUE);
 634 }
 635 #endif /* not HAVE_XDR_READDIRARGS */
 636
 637
 638 #ifndef HAVE_XDR_READDIRRES
 639 bool_t
 640 xdr_readdirres(XDR *xdrs, nfsreaddirres *objp)
 641 {
 642   if (amuDebug(D_XDRTRACE))
 643     plog(XLOG_DEBUG, "xdr_readdirres:");
 644
 645   if (!xdr_nfsstat(xdrs, &objp->rdr_status)) {
 646     return (FALSE);
 647   }
 648   switch (objp->rdr_status) {
 649   case NFS_OK:
 650     if (!xdr_dirlist(xdrs, &objp->rdr_u.rdr_reply_u)) {
 651       return (FALSE);
 652     }
 653     break;
 654   default:
 655     break;
 656   }
 657   return (TRUE);
 658 }
 659 #endif /* not HAVE_XDR_READDIRRES */
 660
 661
 662 #ifndef HAVE_XDR_READLINKRES
 663 bool_t
 664 xdr_readlinkres(XDR *xdrs, nfsreadlinkres *objp)
 665 {
 666   if (amuDebug(D_XDRTRACE))
 667     plog(XLOG_DEBUG, "xdr_readlinkres:");
 668
 669   if (!xdr_nfsstat(xdrs, &objp->rlr_status)) {
 670     return (FALSE);
 671   }
 672   switch (objp->rlr_status) {
 673   case NFS_OK:
 674     if (!xdr_nfspath(xdrs, &objp->rlr_u.rlr_data_u)) {
 675       return (FALSE);
 676     }
 677     break;
 678   default:
 679     break;
 680   }
 681   return (TRUE);
 682 }
 683 #endif /* not HAVE_XDR_READLINKRES */
 684
 685
 686 #ifndef HAVE_XDR_READOKRES
 687 bool_t
 688 xdr_readokres(XDR *xdrs, nfsreadokres *objp)
 689 {
 690   if (amuDebug(D_XDRTRACE))
 691     plog(XLOG_DEBUG, "xdr_readokres:");
 692
 693   if (!xdr_fattr(xdrs, &objp->raok_attributes)) {
 694     return (FALSE);
 695   }
 696   if (!xdr_bytes(xdrs,
 697                  (char **) & objp->raok_u.raok_val_u,
 698                  (u_int *) & objp->raok_u.raok_len_u,
 699                  NFS_MAXDATA)) {
 700     return (FALSE);
 701   }
 702   return (TRUE);
 703 }
 704 #endif /* not HAVE_XDR_READOKRES */
 705
 706
 707 #ifndef HAVE_XDR_READRES
 708 bool_t
 709 xdr_readres(XDR *xdrs, nfsreadres *objp)
 710 {
 711   if (amuDebug(D_XDRTRACE))
 712     plog(XLOG_DEBUG, "xdr_readres:");
 713
 714   if (!xdr_nfsstat(xdrs, &objp->rr_status)) {
 715     return (FALSE);
 716   }
 717   switch (objp->rr_status) {
 718   case NFS_OK:
 719     if (!xdr_readokres(xdrs, &objp->rr_u.rr_reply_u)) {
 720       return (FALSE);
 721     }
 722     break;
 723   default:
 724     break;
 725   }
 726   return (TRUE);
 727 }
 728 #endif /* not HAVE_XDR_READRES */
 729
 730
 731 #ifndef HAVE_XDR_RENAMEARGS
 732 bool_t
 733 xdr_renameargs(XDR *xdrs, nfsrenameargs *objp)
 734 {
 735   if (amuDebug(D_XDRTRACE))
 736     plog(XLOG_DEBUG, "xdr_renameargs:");
 737
 738   if (!xdr_diropargs(xdrs, &objp->rna_from)) {
 739     return (FALSE);
 740   }
 741   if (!xdr_diropargs(xdrs, &objp->rna_to)) {
 742     return (FALSE);
 743   }
 744   return (TRUE);
 745 }
 746 #endif /* not HAVE_XDR_RENAMEARGS */
 747
 748
 749 #ifndef HAVE_XDR_SATTR
 750 bool_t
 751 xdr_sattr(XDR *xdrs, nfssattr *objp)
 752 {
 753   if (amuDebug(D_XDRTRACE))
 754     plog(XLOG_DEBUG, "xdr_sattr:");
 755
 756   if (!xdr_u_int(xdrs, &objp->sa_mode)) {
 757     return (FALSE);
 758   }
 759   if (!xdr_u_int(xdrs, &objp->sa_uid)) {
 760     return (FALSE);
 761   }
 762   if (!xdr_u_int(xdrs, &objp->sa_gid)) {
 763     return (FALSE);
 764   }
 765   if (!xdr_u_int(xdrs, &objp->sa_size)) {
 766     return (FALSE);
 767   }
 768   if (!xdr_nfstime(xdrs, &objp->sa_atime)) {
 769     return (FALSE);
 770   }
 771   if (!xdr_nfstime(xdrs, &objp->sa_mtime)) {
 772     return (FALSE);
 773   }
 774   return (TRUE);
 775 }
 776 #endif /* not HAVE_XDR_SATTR */
 777
 778
 779 #ifndef HAVE_XDR_SATTRARGS
 780 bool_t
 781 xdr_sattrargs(XDR *xdrs, nfssattrargs *objp)
 782 {
 783   if (amuDebug(D_XDRTRACE))
 784     plog(XLOG_DEBUG, "xdr_sattrargs:");
 785
 786   if (!xdr_nfs_fh(xdrs, &objp->sag_fhandle)) {
 787     return (FALSE);
 788   }
 789   if (!xdr_sattr(xdrs, &objp->sag_attributes)) {
 790     return (FALSE);
 791   }
 792   return (TRUE);
 793 }
 794 #endif /* not HAVE_XDR_SATTRARGS */
 795
 796
 797 #ifndef HAVE_XDR_STATFSOKRES
 798 bool_t
 799 xdr_statfsokres(XDR *xdrs, nfsstatfsokres *objp)
 800 {
 801   if (amuDebug(D_XDRTRACE))
 802     plog(XLOG_DEBUG, "xdr_statfsokres:");
 803
 804   if (!xdr_u_int(xdrs, &objp->sfrok_tsize)) {
 805     return (FALSE);
 806   }
 807   if (!xdr_u_int(xdrs, &objp->sfrok_bsize)) {
 808     return (FALSE);
 809   }
 810   if (!xdr_u_int(xdrs, &objp->sfrok_blocks)) {
 811     return (FALSE);
 812   }
 813   if (!xdr_u_int(xdrs, &objp->sfrok_bfree)) {
 814     return (FALSE);
 815   }
 816   if (!xdr_u_int(xdrs, &objp->sfrok_bavail)) {
 817     return (FALSE);
 818   }
 819   return (TRUE);
 820 }
 821 #endif /* not HAVE_XDR_STATFSOKRES */
 822
 823
 824 #ifndef HAVE_XDR_STATFSRES
 825 bool_t
 826 xdr_statfsres(XDR *xdrs, nfsstatfsres *objp)
 827 {
 828   if (amuDebug(D_XDRTRACE))
 829     plog(XLOG_DEBUG, "xdr_statfsres:");
 830
 831   if (!xdr_nfsstat(xdrs, &objp->sfr_status)) {
 832     return (FALSE);
 833   }
 834   switch (objp->sfr_status) {
 835   case NFS_OK:
 836     if (!xdr_statfsokres(xdrs, &objp->sfr_u.sfr_reply_u)) {
 837       return (FALSE);
 838     }
 839     break;
 840   default:
 841     break;
 842   }
 843   return (TRUE);
 844 }
 845 #endif /* not HAVE_XDR_STATFSRES */
 846
 847
 848 #ifndef HAVE_XDR_SYMLINKARGS
 849 bool_t
 850 xdr_symlinkargs(XDR *xdrs, nfssymlinkargs *objp)
 851 {
 852   if (amuDebug(D_XDRTRACE))
 853     plog(XLOG_DEBUG, "xdr_symlinkargs:");
 854
 855   if (!xdr_diropargs(xdrs, &objp->sla_from)) {
 856     return (FALSE);
 857   }
 858   if (!xdr_nfspath(xdrs, &objp->sla_to)) {
 859     return (FALSE);
 860   }
 861   if (!xdr_sattr(xdrs, &objp->sla_attributes)) {
 862     return (FALSE);
 863   }
 864   return (TRUE);
 865 }
 866 #endif /* not HAVE_XDR_SYMLINKARGS */
 867
 868
 869 #ifndef HAVE_XDR_WRITEARGS
 870 bool_t
 871 xdr_writeargs(XDR *xdrs, nfswriteargs *objp)
 872 {
 873   if (amuDebug(D_XDRTRACE))
 874     plog(XLOG_DEBUG, "xdr_writeargs:");
 875
 876   if (!xdr_nfs_fh(xdrs, &objp->wra_fhandle)) {
 877     return (FALSE);
 878   }
 879   if (!xdr_u_int(xdrs, &objp->wra_beginoffset)) {
 880     return (FALSE);
 881   }
 882   if (!xdr_u_int(xdrs, &objp->wra_offset)) {
 883     return (FALSE);
 884   }
 885   if (!xdr_u_int(xdrs, &objp->wra_totalcount)) {
 886     return (FALSE);
 887   }
 888   if (!xdr_bytes(xdrs,
 889                  (char **) & objp->wra_u.wra_val_u,
 890                  (u_int *) & objp->wra_u.wra_len_u,
 891                  NFS_MAXDATA)) {
 892     return (FALSE);
 893   }
 894   return (TRUE);
 895 }
 896 #endif /* not HAVE_XDR_WRITEARGS */
 897
 898
 899 /*
 900  * NFS V3 XDR FUNCTIONS:
 901  */
 902 #ifdef HAVE_FS_NFS3
 903 bool_t
 904 xdr_am_fhandle3(XDR *xdrs, am_fhandle3 *objp)
 905 {
 906   if (amuDebug(D_XDRTRACE))
 907     plog(XLOG_DEBUG, "xdr_am_fhandle3:");
 908
 909   if (!xdr_bytes(xdrs,
 910                  (char **) &objp->fhandle3_val,
 911                  (u_int *) &objp->fhandle3_len,
 912                  AM_FHSIZE3))
 913     return (FALSE);
 914   return (TRUE);
 915 }
 916
 917
 918 bool_t
 919 xdr_am_mountstat3(XDR *xdrs, am_mountstat3 *objp)
 920 {
 921   enum_t local_obj = *objp;
 922
 923   if (amuDebug(D_XDRTRACE))
 924     plog(XLOG_DEBUG, "xdr_am_mountstat3:");
 925
 926   if (!xdr_enum(xdrs, &local_obj))
 927     return (FALSE);
 928   return (TRUE);
 929 }
 930
 931
 932 bool_t
 933 xdr_am_mountres3_ok(XDR *xdrs, am_mountres3_ok *objp)
 934 {
 935   if (amuDebug(D_XDRTRACE))
 936     plog(XLOG_DEBUG, "xdr_am_mountres3_ok:");
 937
 938   if (!xdr_am_fhandle3(xdrs, &objp->fhandle))
 939     return (FALSE);
 940   if (!xdr_array(xdrs,
 941                  (char **) ((voidp) &objp->auth_flavors.auth_flavors_val),
 942                  (u_int *) &objp->auth_flavors.auth_flavors_len,
 943                  ~0,
 944                  sizeof(int),
 945                  (XDRPROC_T_TYPE) xdr_int))
 946     return (FALSE);
 947   return (TRUE);
 948 }
 949
 950 bool_t
 951 xdr_am_mountres3(XDR *xdrs, am_mountres3 *objp)
 952 {
 953   if (amuDebug(D_XDRTRACE))
 954     plog(XLOG_DEBUG, "xdr_am_mountres3:");
 955
 956   if (!xdr_am_mountstat3(xdrs, &objp->fhs_status))
 957     return (FALSE);
 958
 959   if (objp->fhs_status == AM_MNT3_OK) {
 960     if (!xdr_am_mountres3_ok(xdrs, &objp->mountres3_u.mountinfo))
 961       return (FALSE);
 962   }
 963   return (TRUE);
 964 }
 965
 966 bool_t
 967 xdr_am_cookieverf3(XDR *xdrs, am_cookieverf3 objp)
 968 {
 969   if (amuDebug(D_XDRTRACE))
 970     plog(XLOG_DEBUG, "xdr_am_cookieverf3:");
 971
 972   if (!xdr_opaque(xdrs, objp, AM_NFS3_COOKIEVERFSIZE))
 973     return FALSE;
 974   return TRUE;
 975 }
 976
 977 #if 0
 978 /* In FreeBSD xdr_uint64() is defined in ../../../include/rpcsvc/nfs_prot.x */
 979 /*
 980  * Not ideal, xdr_u_int64_t() is not defined in Linux glibc RPC
 981  * but xdr_u_quad_t() is. But in libtirpc xdr_u_quad_t() is not
 982  * defined and xdr_u_int64_t() is. So xdr_u_int64_t() is probably
 983  * an expected standard xdr function so, if it isn't defined use
 984  * an internal xdr_u_int64_t() that uses xdr_u_quad_t().
 985  */
 986 #ifndef HAVE_XDR_U_INT64_T
 987 #define xdr_u_int64_t(xdrs, objp) xdr_u_quad_t(xdrs, objp)
 988 #endif /* HAVE_XDR_U_INT64_T */
 989
 990 bool_t
 991 xdr_uint64(XDR *xdrs, uint64 *objp)
 992 {
 993   if (amuDebug(D_XDRTRACE))
 994     plog(XLOG_DEBUG, "xdr_uint64:");
 995
 996   if (!xdr_u_int64_t(xdrs, objp))
 997     return FALSE;
 998   return TRUE;
 999 }
1000 #endif
1001
1002 bool_t
1003 xdr_am_cookie3(XDR *xdrs, am_cookie3 *objp)
1004 {
1005   if (amuDebug(D_XDRTRACE))
1006     plog(XLOG_DEBUG, "xdr_am_cookie3:");
1007
1008   if (!xdr_uint64(xdrs, objp))
1009     return FALSE;
1010   return TRUE;
1011 }
1012
1013 bool_t
1014 xdr_am_nfs_fh3(XDR *xdrs, am_nfs_fh3 *objp)
1015 {
1016   if (amuDebug(D_XDRTRACE))
1017     plog(XLOG_DEBUG, "xdr_am_nfs_fh3:");
1018
1019   if (!xdr_u_int(xdrs, &objp->am_fh3_length))
1020     return (FALSE);
1021   if (objp->am_fh3_length > AM_FHSIZE3)
1022     return (FALSE);
1023   if (!xdr_opaque(xdrs, objp->am_fh3_data, objp->am_fh3_length))
1024     return (FALSE);
1025   return (TRUE);
1026 }
1027
1028 bool_t
1029 xdr_am_nfsstat3(XDR *xdrs, am_nfsstat3 *objp)
1030 {
1031   if (amuDebug(D_XDRTRACE))
1032     plog(XLOG_DEBUG, "xdr_am_nfsstat3:");
1033
1034   if (!xdr_enum(xdrs, (enum_t *)objp))
1035     return (FALSE);
1036   return (TRUE);
1037 }
1038
1039 bool_t
1040 xdr_am_diropargs3(XDR *xdrs, am_diropargs3 *objp)
1041 {
1042   if (amuDebug(D_XDRTRACE))
1043     plog(XLOG_DEBUG, "xdr_am_diropargs3:");
1044
1045   if (!xdr_am_nfs_fh3(xdrs, &objp->dir))
1046     return (FALSE);
1047   if (!xdr_am_filename3(xdrs, &objp->name))
1048     return (FALSE);
1049   return (TRUE);
1050 }
1051
1052 bool_t
1053 xdr_am_filename3(XDR *xdrs, am_filename3 *objp)
1054 {
1055   if (amuDebug(D_XDRTRACE))
1056     plog(XLOG_DEBUG, "xdr_am_filename3:");
1057
1058   if (!xdr_string(xdrs, objp, ~0))
1059     return (FALSE);
1060   return (TRUE);
1061 }
1062
1063 bool_t
1064 xdr_am_ftype3(XDR *xdrs, am_ftype3 *objp)
1065 {
1066   if (amuDebug(D_XDRTRACE))
1067     plog(XLOG_DEBUG, "xdr_am_ftype3:");
1068
1069   if (!xdr_enum(xdrs, (enum_t *) objp))
1070     return FALSE;
1071   return TRUE;
1072 }
1073
1074 bool_t
1075 xdr_am_mode3(XDR *xdrs, am_mode3 *objp)
1076 {
1077   if (amuDebug(D_XDRTRACE))
1078     plog(XLOG_DEBUG, "xdr_am_mode3:");
1079
1080   if (!xdr_u_int(xdrs, objp))
1081     return FALSE;
1082   return TRUE;
1083 }
1084
1085 bool_t
1086 xdr_am_uid3(XDR *xdrs, am_uid3 *objp)
1087 {
1088   if (amuDebug(D_XDRTRACE))
1089     plog(XLOG_DEBUG, "xdr_am_uid3:");
1090
1091   if (!xdr_u_int(xdrs, objp))
1092     return FALSE;
1093   return TRUE;
1094 }
1095
1096 bool_t
1097 xdr_am_gid3(XDR *xdrs, am_gid3 *objp)
1098 {
1099   if (amuDebug(D_XDRTRACE))
1100     plog(XLOG_DEBUG, "xdr_am_gid3:");
1101
1102   if (!xdr_u_int(xdrs, objp))
1103     return FALSE;
1104   return TRUE;
1105 }
1106
1107 bool_t
1108 xdr_am_size3(XDR *xdrs, am_size3 *objp)
1109 {
1110   if (amuDebug(D_XDRTRACE))
1111     plog(XLOG_DEBUG, "xdr_am_size3:");
1112
1113   if (!xdr_uint64(xdrs, objp))
1114     return FALSE;
1115   return TRUE;
1116 }
1117
1118 bool_t
1119 xdr_am_fileid3(XDR *xdrs, am_fileid3 *objp)
1120 {
1121   if (amuDebug(D_XDRTRACE))
1122     plog(XLOG_DEBUG, "xdr_am_fileid3:");
1123
1124   if (!xdr_uint64(xdrs, objp))
1125     return FALSE;
1126   return TRUE;
1127 }
1128
1129 bool_t
1130 xdr_am_specdata3(XDR *xdrs, am_specdata3 *objp)
1131 {
1132   if (amuDebug(D_XDRTRACE))
1133     plog(XLOG_DEBUG, "xdr_am_specdata3:");
1134
1135   if (!xdr_u_int(xdrs, &objp->specdata1))
1136     return FALSE;
1137   if (!xdr_u_int(xdrs, &objp->specdata2))
1138     return FALSE;
1139   return TRUE;
1140 }
1141
1142 bool_t
1143 xdr_am_nfstime3(XDR *xdrs, am_nfstime3 *objp)
1144 {
1145   if (amuDebug(D_XDRTRACE))
1146     plog(XLOG_DEBUG, "xdr_am_nfstime3:");
1147
1148   if (!xdr_u_int(xdrs, &objp->seconds))
1149     return FALSE;
1150   if (!xdr_u_int(xdrs, &objp->nseconds))
1151     return FALSE;
1152   return TRUE;
1153 }
1154
1155 bool_t
1156 xdr_am_fattr3(XDR *xdrs, am_fattr3 *objp)
1157 {
1158   if (amuDebug(D_XDRTRACE))
1159     plog(XLOG_DEBUG, "xdr_am_fattr3:");
1160
1161   if (!xdr_am_ftype3(xdrs, &objp->type))
1162     return FALSE;
1163   if (!xdr_am_mode3(xdrs, &objp->mode))
1164     return FALSE;
1165   if (!xdr_u_int(xdrs, &objp->nlink))
1166     return FALSE;
1167   if (!xdr_am_uid3(xdrs, &objp->uid))
1168     return FALSE;
1169   if (!xdr_am_gid3(xdrs, &objp->gid))
1170     return FALSE;
1171   if (!xdr_am_size3(xdrs, &objp->size))
1172     return FALSE;
1173   if (!xdr_am_size3(xdrs, &objp->used))
1174     return FALSE;
1175   if (!xdr_am_specdata3(xdrs, &objp->rdev))
1176     return FALSE;
1177   if (!xdr_uint64(xdrs, &objp->fsid))
1178     return FALSE;
1179   if (!xdr_am_fileid3(xdrs, &objp->fileid))
1180     return FALSE;
1181   if (!xdr_am_nfstime3(xdrs, &objp->atime))
1182     return FALSE;
1183   if (!xdr_am_nfstime3(xdrs, &objp->mtime))
1184     return FALSE;
1185   if (!xdr_am_nfstime3(xdrs, &objp->ctime))
1186     return FALSE;
1187   return TRUE;
1188 }
1189
1190 bool_t
1191 xdr_am_post_op_attr(XDR *xdrs, am_post_op_attr *objp)
1192 {
1193   if (amuDebug(D_XDRTRACE))
1194     plog(XLOG_DEBUG, "xdr_am_post_op_attr:");
1195
1196   if (!xdr_bool(xdrs, &objp->attributes_follow))
1197     return FALSE;
1198   switch (objp->attributes_follow) {
1199   case TRUE:
1200     if (!xdr_am_fattr3(xdrs, &objp->am_post_op_attr_u.attributes))
1201       return FALSE;
1202     break;
1203   case FALSE:
1204     break;
1205   default:
1206     return FALSE;
1207   }
1208   return TRUE;
1209 }
1210
1211 bool_t
1212 xdr_am_stable_how(XDR *xdrs, am_stable_how *objp)
1213 {
1214   if (amuDebug(D_XDRTRACE))
1215     plog(XLOG_DEBUG, "xdr_am_stable_how:");
1216
1217   if (!xdr_enum(xdrs, (enum_t *) objp))
1218     return FALSE;
1219   return TRUE;
1220 }
1221
1222 bool_t
1223 xdr_am_offset3(XDR *xdrs, am_offset3 *objp)
1224 {
1225   if (amuDebug(D_XDRTRACE))
1226     plog(XLOG_DEBUG, "xdr_am_offset3:");
1227
1228   if (!xdr_uint64(xdrs, objp))
1229     return FALSE;
1230   return TRUE;
1231 }
1232
1233 bool_t
1234 xdr_am_count3(XDR *xdrs, am_count3 *objp)
1235 {
1236   if (amuDebug(D_XDRTRACE))
1237     plog(XLOG_DEBUG, "xdr_am_count3:");
1238
1239   if (!xdr_u_int(xdrs, objp))
1240     return FALSE;
1241   return TRUE;
1242 }
1243
1244 bool_t
1245 xdr_am_wcc_attr(XDR *xdrs, am_wcc_attr *objp)
1246 {
1247   if (amuDebug(D_XDRTRACE))
1248     plog(XLOG_DEBUG, "xdr_am_wcc_attr:");
1249
1250   if (!xdr_am_size3(xdrs, &objp->size))
1251     return FALSE;
1252   if (!xdr_am_nfstime3(xdrs, &objp->mtime))
1253     return FALSE;
1254   if (!xdr_am_nfstime3(xdrs, &objp->ctime))
1255     return FALSE;
1256   return TRUE;
1257 }
1258
1259 bool_t
1260 xdr_am_pre_op_attr(XDR *xdrs, am_pre_op_attr *objp)
1261 {
1262   if (amuDebug(D_XDRTRACE))
1263     plog(XLOG_DEBUG, ":xdr_am_pre_op_attr");
1264
1265   if (!xdr_bool(xdrs, &objp->attributes_follow))
1266     return FALSE;
1267   switch (objp->attributes_follow) {
1268   case TRUE:
1269     if (!xdr_am_wcc_attr(xdrs, &objp->am_pre_op_attr_u.attributes))
1270       return FALSE;
1271     break;
1272   case FALSE:
1273     break;
1274   default:
1275     return FALSE;
1276   }
1277   return TRUE;
1278 }
1279
1280 bool_t
1281 xdr_am_wcc_data(XDR *xdrs, am_wcc_data *objp)
1282 {
1283   if (amuDebug(D_XDRTRACE))
1284     plog(XLOG_DEBUG, "xdr_am_wcc_data:");
1285
1286   if (!xdr_am_pre_op_attr(xdrs, &objp->before))
1287     return FALSE;
1288   if (!xdr_am_post_op_attr(xdrs, &objp->after))
1289     return FALSE;
1290   return TRUE;
1291 }
1292
1293 bool_t
1294 xdr_am_WRITE3args(XDR *xdrs, am_WRITE3args *objp)
1295 {
1296   if (amuDebug(D_XDRTRACE))
1297     plog(XLOG_DEBUG, "xdr_am_WRITE3args:");
1298
1299   if (!xdr_am_nfs_fh3(xdrs, &objp->file))
1300     return FALSE;
1301   if (!xdr_am_offset3(xdrs, &objp->offset))
1302     return FALSE;
1303   if (!xdr_am_count3(xdrs, &objp->count))
1304     return FALSE;
1305   if (!xdr_am_stable_how(xdrs, &objp->stable))
1306     return FALSE;
1307   if (!xdr_bytes(xdrs, (char **)&objp->data.data_val,
1308                 (u_int *) &objp->data.data_len, ~0))
1309     return FALSE;
1310   return TRUE;
1311 }
1312
1313 bool_t
1314 xdr_am_writeverf3(XDR *xdrs, am_writeverf3 objp)
1315 {
1316   if (amuDebug(D_XDRTRACE))
1317     plog(XLOG_DEBUG, "xdr_am_writeverf3:");
1318
1319   if (!xdr_opaque(xdrs, objp, AM_NFS3_WRITEVERFSIZE))
1320     return FALSE;
1321   return TRUE;
1322 }
1323
1324 bool_t
1325 xdr_am_WRITE3resok(XDR *xdrs, am_WRITE3resok *objp)
1326 {
1327   if (amuDebug(D_XDRTRACE))
1328     plog(XLOG_DEBUG, "xdr_am_WRITE3resok:");
1329
1330   if (!xdr_am_wcc_data(xdrs, &objp->file_wcc))
1331     return FALSE;
1332   if (!xdr_am_count3(xdrs, &objp->count))
1333     return FALSE;
1334   if (!xdr_am_stable_how(xdrs, &objp->committed))
1335     return FALSE;
1336   if (!xdr_am_writeverf3(xdrs, objp->verf))
1337     return FALSE;
1338   return TRUE;
1339 }
1340
1341 bool_t
1342 xdr_am_WRITE3resfail(XDR *xdrs, am_WRITE3resfail *objp)
1343 {
1344   if (amuDebug(D_XDRTRACE))
1345     plog(XLOG_DEBUG, "xdr_am_WRITE3resfail:");
1346
1347   if (!xdr_am_wcc_data(xdrs, &objp->file_wcc))
1348     return FALSE;
1349   return TRUE;
1350 }
1351
1352 bool_t
1353 xdr_am_WRITE3res(XDR *xdrs, am_WRITE3res *objp)
1354 {
1355   if (amuDebug(D_XDRTRACE))
1356     plog(XLOG_DEBUG, "xdr_am_WRITE3res:");
1357
1358   if (!xdr_am_nfsstat3(xdrs, &objp->status))
1359     return FALSE;
1360   switch (objp->status) {
1361   case AM_NFS3_OK:
1362     if (!xdr_am_WRITE3resok(xdrs, &objp->res_u.ok))
1363       return FALSE;
1364     break;
1365   default:
1366     if (!xdr_am_WRITE3resfail(xdrs, &objp->res_u.fail))
1367       return FALSE;
1368     break;
1369   }
1370   return TRUE;
1371 }
1372
1373 bool_t
1374 xdr_am_LOOKUP3args(XDR *xdrs, am_LOOKUP3args *objp)
1375 {
1376   if (amuDebug(D_XDRTRACE))
1377     plog(XLOG_DEBUG, "xdr_am_LOOKUP3args:");
1378
1379   if (!xdr_am_diropargs3(xdrs, &objp->what))
1380     return (FALSE);
1381   return (TRUE);
1382 }
1383
1384 bool_t
1385 xdr_am_LOOKUP3res(XDR *xdrs, am_LOOKUP3res *objp)
1386 {
1387   if (amuDebug(D_XDRTRACE))
1388     plog(XLOG_DEBUG, "xdr_am_LOOKUP3res:");
1389
1390   if (!xdr_am_nfsstat3(xdrs, &objp->status))
1391     return (FALSE);
1392   switch (objp->status) {
1393   case AM_NFS3_OK:
1394     if (!xdr_am_LOOKUP3resok(xdrs, &objp->res_u.ok))
1395       return (FALSE);
1396     break;
1397   default:
1398     if (!xdr_am_LOOKUP3resfail(xdrs, &objp->res_u.fail))
1399       return (FALSE);
1400     break;
1401   }
1402   return (TRUE);
1403 }
1404
1405 bool_t
1406 xdr_am_LOOKUP3resfail(XDR *xdrs, am_LOOKUP3resfail *objp)
1407 {
1408   if (amuDebug(D_XDRTRACE))
1409     plog(XLOG_DEBUG, "xdr_am_LOOKUP3resfail:");
1410
1411   if (!xdr_am_post_op_attr(xdrs, &objp->dir_attributes))
1412     return (FALSE);
1413   return (TRUE);
1414 }
1415
1416 bool_t
1417 xdr_am_LOOKUP3resok(XDR *xdrs, am_LOOKUP3resok *objp)
1418 {
1419   if (amuDebug(D_XDRTRACE))
1420     plog(XLOG_DEBUG, "xdr_am_LOOKUP3resok:");
1421
1422   if (!xdr_am_nfs_fh3(xdrs, &objp->object))
1423     return (FALSE);
1424   if (!xdr_am_post_op_attr(xdrs, &objp->obj_attributes))
1425     return (FALSE);
1426   if (!xdr_am_post_op_attr(xdrs, &objp->dir_attributes))
1427     return (FALSE);
1428   return (TRUE);
1429 }
1430
1431 bool_t
1432 xdr_am_COMMIT3args(XDR *xdrs, am_COMMIT3args *objp)
1433 {
1434   if (amuDebug(D_XDRTRACE))
1435     plog(XLOG_DEBUG, "xdr_am_COMMIT3args:");
1436
1437   if (!xdr_am_nfs_fh3(xdrs, &objp->file))
1438     return FALSE;
1439   if (!xdr_am_offset3(xdrs, &objp->offset))
1440     return FALSE;
1441   if (!xdr_am_count3(xdrs, &objp->count))
1442     return FALSE;
1443   return TRUE;
1444 }
1445
1446 bool_t
1447 xdr_am_COMMIT3resok(XDR *xdrs, am_COMMIT3resok *objp)
1448 {
1449   if (amuDebug(D_XDRTRACE))
1450     plog(XLOG_DEBUG, "xdr_am_COMMIT3resok:");
1451
1452   if (!xdr_am_wcc_data(xdrs, &objp->file_wcc))
1453     return FALSE;
1454   if (!xdr_am_writeverf3(xdrs, objp->verf))
1455     return FALSE;
1456   return TRUE;
1457 }
1458
1459 bool_t
1460 xdr_am_COMMIT3resfail(XDR *xdrs, am_COMMIT3resfail *objp)
1461 {
1462   if (amuDebug(D_XDRTRACE))
1463     plog(XLOG_DEBUG, "xdr_am_COMMIT3resfail:");
1464
1465   if (!xdr_am_wcc_data(xdrs, &objp->file_wcc))
1466     return FALSE;
1467   return TRUE;
1468 }
1469
1470 bool_t
1471 xdr_am_COMMIT3res(XDR *xdrs, am_COMMIT3res *objp)
1472 {
1473   if (amuDebug(D_XDRTRACE))
1474     plog(XLOG_DEBUG, "xdr_am_COMMIT3res:");
1475
1476   if (!xdr_am_nfsstat3(xdrs, &objp->status))
1477     return FALSE;
1478   switch (objp->status) {
1479   case AM_NFS3_OK:
1480     if (!xdr_am_COMMIT3resok(xdrs, &objp->res_u.ok))
1481       return FALSE;
1482     break;
1483   default:
1484     if (!xdr_am_COMMIT3resfail(xdrs, &objp->res_u.fail))
1485       return FALSE;
1486     break;
1487   }
1488   return TRUE;
1489 }
1490
1491 bool_t
1492 xdr_am_ACCESS3args(XDR *xdrs, am_ACCESS3args *objp)
1493 {
1494   if (amuDebug(D_XDRTRACE))
1495     plog(XLOG_DEBUG, "xdr_am_ACCESS3args:");
1496
1497   if (!xdr_am_nfs_fh3(xdrs, &objp->object))
1498     return FALSE;
1499   if (!xdr_u_int(xdrs, &objp->access))
1500     return FALSE;
1501   return TRUE;
1502 }
1503
1504 bool_t
1505 xdr_am_ACCESS3resok(XDR *xdrs, am_ACCESS3resok *objp)
1506 {
1507   if (amuDebug(D_XDRTRACE))
1508     plog(XLOG_DEBUG, "xdr_am_ACCESS3resok:");
1509
1510   if (!xdr_am_post_op_attr(xdrs, &objp->obj_attributes))
1511     return FALSE;
1512   if (!xdr_u_int(xdrs, &objp->access))
1513     return FALSE;
1514   return TRUE;
1515 }
1516
1517 bool_t
1518 xdr_am_ACCESS3resfail(XDR *xdrs, am_ACCESS3resfail *objp)
1519 {
1520   if (amuDebug(D_XDRTRACE))
1521     plog(XLOG_DEBUG, "xdr_am_ACCESS3resfail:");
1522
1523   if (!xdr_am_post_op_attr(xdrs, &objp->obj_attributes))
1524     return FALSE;
1525   return TRUE;
1526 }
1527
1528 bool_t
1529 xdr_am_ACCESS3res(XDR *xdrs, am_ACCESS3res *objp)
1530 {
1531   if (amuDebug(D_XDRTRACE))
1532     plog(XLOG_DEBUG, "xdr_am_ACCESS3res:");
1533
1534   if (!xdr_am_nfsstat3(xdrs, &objp->status))
1535     return FALSE;
1536   switch (objp->status) {
1537   case AM_NFS3_OK:
1538     if (!xdr_am_ACCESS3resok(xdrs, &objp->res_u.ok))
1539       return FALSE;
1540     break;
1541   default:
1542     if (!xdr_am_ACCESS3resfail(xdrs, &objp->res_u.fail))
1543       return FALSE;
1544     break;
1545   }
1546   return TRUE;
1547 }
1548
1549 bool_t
1550 xdr_am_GETATTR3args(XDR *xdrs, am_GETATTR3args *objp)
1551 {
1552   if (amuDebug(D_XDRTRACE))
1553     plog(XLOG_DEBUG, "xdr_am_GETATTR3args:");
1554
1555   if (!xdr_am_nfs_fh3(xdrs, &objp->object))
1556     return FALSE;
1557   return TRUE;
1558 }
1559
1560 bool_t
1561 xdr_am_GETATTR3resok(XDR *xdrs, am_GETATTR3resok *objp)
1562 {
1563   if (amuDebug(D_XDRTRACE))
1564     plog(XLOG_DEBUG, "xdr_am_GETATTR3resok:");
1565
1566   if (!xdr_am_fattr3(xdrs, &objp->obj_attributes))
1567     return FALSE;
1568   return TRUE;
1569 }
1570
1571 bool_t
1572 xdr_am_GETATTR3res(XDR *xdrs, am_GETATTR3res *objp)
1573 {
1574   if (amuDebug(D_XDRTRACE))
1575     plog(XLOG_DEBUG, "xdr_am_GETATTR3res:");
1576
1577   if (!xdr_am_nfsstat3(xdrs, &objp->status))
1578     return FALSE;
1579   switch (objp->status) {
1580   case AM_NFS3_OK:
1581     if (!xdr_am_GETATTR3resok(xdrs, &objp->res_u.ok))
1582       return FALSE;
1583     break;
1584   default:
1585     break;
1586   }
1587   return TRUE;
1588 }
1589
1590 bool_t
1591 xdr_am_time_how(XDR *xdrs, am_time_how *objp)
1592 {
1593   if (amuDebug(D_XDRTRACE))
1594     plog(XLOG_DEBUG, "xdr_am_time_how:");
1595
1596   if (!xdr_enum(xdrs, (enum_t *) objp))
1597     return FALSE;
1598   return TRUE;
1599 }
1600
1601 bool_t
1602 xdr_am_set_mode3(XDR *xdrs, am_set_mode3 *objp)
1603 {
1604   if (amuDebug(D_XDRTRACE))
1605     plog(XLOG_DEBUG, "xdr_am_set_mode3:");
1606
1607   if (!xdr_bool(xdrs, &objp->set_it))
1608     return FALSE;
1609   switch (objp->set_it) {
1610   case TRUE:
1611     if (!xdr_am_mode3(xdrs, &objp->am_set_mode3_u.mode))
1612       return FALSE;
1613     break;
1614   default:
1615     break;
1616   }
1617   return TRUE;
1618 }
1619
1620 bool_t
1621 xdr_am_set_uid3(XDR *xdrs, am_set_uid3 *objp)
1622 {
1623   if (amuDebug(D_XDRTRACE))
1624     plog(XLOG_DEBUG, "xdr_am_set_uid3:");
1625
1626   if (!xdr_bool(xdrs, &objp->set_it))
1627     return FALSE;
1628   switch (objp->set_it) {
1629   case TRUE:
1630     if (!xdr_am_uid3(xdrs, &objp->am_set_uid3_u.uid))
1631       return FALSE;
1632     break;
1633   default:
1634     break;
1635   }
1636   return TRUE;
1637 }
1638
1639 bool_t
1640 xdr_am_set_gid3(XDR *xdrs, am_set_gid3 *objp)
1641 {
1642   if (amuDebug(D_XDRTRACE))
1643     plog(XLOG_DEBUG, "xdr_am_set_gid3:");
1644
1645   if (!xdr_bool(xdrs, &objp->set_it))
1646     return FALSE;
1647   switch (objp->set_it) {
1648   case TRUE:
1649     if (!xdr_am_gid3(xdrs, &objp->am_set_gid3_u.gid))
1650       return FALSE;
1651     break;
1652   default:
1653     break;
1654   }
1655   return TRUE;
1656 }
1657
1658 bool_t
1659 xdr_am_set_size3(XDR *xdrs, am_set_size3 *objp)
1660 {
1661   if (amuDebug(D_XDRTRACE))
1662     plog(XLOG_DEBUG, "xdr_am_set_size3:");
1663
1664   if (!xdr_bool(xdrs, &objp->set_it))
1665     return FALSE;
1666   switch (objp->set_it) {
1667   case TRUE:
1668     if (!xdr_am_size3(xdrs, &objp->am_set_size3_u.size))
1669       return FALSE;
1670     break;
1671   default:
1672     break;
1673   }
1674   return TRUE;
1675 }
1676
1677 bool_t
1678 xdr_am_set_atime(XDR *xdrs, am_set_atime *objp)
1679 {
1680   if (amuDebug(D_XDRTRACE))
1681     plog(XLOG_DEBUG, "xdr_am_set_atime:");
1682
1683   if (!xdr_am_time_how(xdrs, &objp->set_it))
1684     return FALSE;
1685   switch (objp->set_it) {
1686   case AM_SET_TO_CLIENT_TIME:
1687     if (!xdr_am_nfstime3(xdrs, &objp->am_set_atime_u.atime))
1688       return FALSE;
1689     break;
1690   default:
1691     break;
1692   }
1693   return TRUE;
1694 }
1695
1696 bool_t
1697 xdr_am_set_mtime(XDR *xdrs, am_set_mtime *objp)
1698 {
1699   if (amuDebug(D_XDRTRACE))
1700     plog(XLOG_DEBUG, "xdr_am_set_mtime:");
1701
1702   if (!xdr_am_time_how(xdrs, &objp->set_it))
1703     return FALSE;
1704   switch (objp->set_it) {
1705   case AM_SET_TO_CLIENT_TIME:
1706     if (!xdr_am_nfstime3(xdrs, &objp->am_set_mtime_u.mtime))
1707       return FALSE;
1708     break;
1709   default:
1710     break;
1711   }
1712   return TRUE;
1713 }
1714
1715 bool_t
1716 xdr_am_sattr3(XDR *xdrs, am_sattr3 *objp)
1717 {
1718   if (amuDebug(D_XDRTRACE))
1719     plog(XLOG_DEBUG, "xdr_am_sattr3:");
1720
1721   if (!xdr_am_set_mode3(xdrs, &objp->mode))
1722     return FALSE;
1723   if (!xdr_am_set_uid3(xdrs, &objp->uid))
1724     return FALSE;
1725   if (!xdr_am_set_gid3(xdrs, &objp->gid))
1726     return FALSE;
1727   if (!xdr_am_set_size3(xdrs, &objp->size))
1728      return FALSE;
1729   if (!xdr_am_set_atime(xdrs, &objp->atime))
1730     return FALSE;
1731   if (!xdr_am_set_mtime(xdrs, &objp->mtime))
1732     return FALSE;
1733   return TRUE;
1734 }
1735
1736 bool_t
1737 xdr_am_createmode3(XDR *xdrs, am_createmode3 *objp)
1738 {
1739   if (amuDebug(D_XDRTRACE))
1740     plog(XLOG_DEBUG, "xdr_am_createmode3:");
1741
1742   if (!xdr_enum(xdrs, (enum_t *) objp))
1743     return FALSE;
1744   return TRUE;
1745 }
1746
1747 bool_t
1748 xdr_am_createverf3(XDR *xdrs, am_createverf3 objp)
1749 {
1750   if (amuDebug(D_XDRTRACE))
1751     plog(XLOG_DEBUG, "xdr_am_createverf3:");
1752
1753   if (!xdr_opaque(xdrs, objp, AM_NFS3_CREATEVERFSIZE))
1754     return FALSE;
1755   return TRUE;
1756 }
1757
1758 bool_t
1759 xdr_am_createhow3(XDR *xdrs, am_createhow3 *objp)
1760 {
1761   if (amuDebug(D_XDRTRACE))
1762     plog(XLOG_DEBUG, "xdr_am_createhow3:");
1763
1764    if (!xdr_am_createmode3(xdrs, &objp->mode))
1765      return FALSE;
1766   switch (objp->mode) {
1767   case AM_UNCHECKED:
1768     if (!xdr_am_sattr3(xdrs, &objp->am_createhow3_u.obj_attributes))
1769       return FALSE;
1770     break;
1771   case AM_GUARDED:
1772     if (!xdr_am_sattr3(xdrs, &objp->am_createhow3_u.g_obj_attributes))
1773       return FALSE;
1774     break;
1775   case AM_EXCLUSIVE:
1776     if (!xdr_am_createverf3(xdrs, objp->am_createhow3_u.verf))
1777       return FALSE;
1778     break;
1779   default:
1780     return FALSE;
1781   }
1782   return TRUE;
1783 }
1784
1785 bool_t
1786 xdr_am_CREATE3args(XDR *xdrs, am_CREATE3args *objp)
1787 {
1788   if (amuDebug(D_XDRTRACE))
1789     plog(XLOG_DEBUG, "xdr_am_CREATE3args:");
1790
1791   if (!xdr_am_diropargs3(xdrs, &objp->where))
1792     return FALSE;
1793   if (!xdr_am_createhow3(xdrs, &objp->how))
1794     return FALSE;
1795   return TRUE;
1796 }
1797
1798 bool_t
1799 xdr_am_post_op_fh3(XDR *xdrs, am_post_op_fh3 *objp)
1800 {
1801   if (amuDebug(D_XDRTRACE))
1802     plog(XLOG_DEBUG, "xdr_am_post_op_fh3:");
1803
1804   if (!xdr_bool(xdrs, &objp->handle_follows))
1805     return FALSE;
1806   switch (objp->handle_follows) {
1807   case TRUE:
1808     if (!xdr_am_nfs_fh3(xdrs, &objp->am_post_op_fh3_u.handle))
1809       return FALSE;
1810     break;
1811   case FALSE:
1812     break;
1813   default:
1814     return FALSE;
1815   }
1816   return TRUE;
1817 }
1818
1819 bool_t
1820 xdr_am_CREATE3resok(XDR *xdrs, am_CREATE3resok *objp)
1821 {
1822   if (amuDebug(D_XDRTRACE))
1823     plog(XLOG_DEBUG, "xdr_am_CREATE3resok:");
1824
1825   if (!xdr_am_post_op_fh3(xdrs, &objp->obj))
1826     return FALSE;
1827   if (!xdr_am_post_op_attr(xdrs, &objp->obj_attributes))
1828     return FALSE;
1829   if (!xdr_am_wcc_data(xdrs, &objp->dir_wcc))
1830     return FALSE;
1831   return TRUE;
1832 }
1833
1834 bool_t
1835 xdr_am_CREATE3resfail(XDR *xdrs, am_CREATE3resfail *objp)
1836 {
1837   if (amuDebug(D_XDRTRACE))
1838     plog(XLOG_DEBUG, "xdr_am_CREATE3resfail:");
1839
1840   if (!xdr_am_wcc_data(xdrs, &objp->dir_wcc))
1841     return FALSE;
1842   return TRUE;
1843 }
1844
1845 bool_t
1846 xdr_am_CREATE3res(XDR *xdrs, am_CREATE3res *objp)
1847 {
1848   if (amuDebug(D_XDRTRACE))
1849     plog(XLOG_DEBUG, "xdr_am_CREATE3res:");
1850
1851   if (!xdr_am_nfsstat3(xdrs, &objp->status))
1852     return FALSE;
1853   switch (objp->status) {
1854   case AM_NFS3_OK:
1855     if (!xdr_am_CREATE3resok(xdrs, &objp->res_u.ok))
1856       return FALSE;
1857     break;
1858   default:
1859     if (!xdr_am_CREATE3resfail(xdrs, &objp->res_u.fail))
1860       return FALSE;
1861     break;
1862   }
1863   return TRUE;
1864 }
1865
1866 bool_t
1867 xdr_am_REMOVE3args(XDR *xdrs, am_REMOVE3args *objp)
1868 {
1869   if (amuDebug(D_XDRTRACE))
1870     plog(XLOG_DEBUG, "xdr_am_REMOVE3args:");
1871
1872   if (!xdr_am_diropargs3(xdrs, &objp->object))
1873     return FALSE;
1874   return TRUE;
1875 }
1876
1877 bool_t
1878 xdr_am_REMOVE3resok(XDR *xdrs, am_REMOVE3resok *objp)
1879 {
1880   if (amuDebug(D_XDRTRACE))
1881     plog(XLOG_DEBUG, "xdr_am_REMOVE3resok:");
1882
1883   if (!xdr_am_wcc_data(xdrs, &objp->dir_wcc))
1884     return FALSE;
1885   return TRUE;
1886 }
1887
1888 bool_t
1889 xdr_am_REMOVE3resfail(XDR *xdrs, am_REMOVE3resfail *objp)
1890 {
1891   if (amuDebug(D_XDRTRACE))
1892     plog(XLOG_DEBUG, "xdr_am_REMOVE3resfail:");
1893
1894   if (!xdr_am_wcc_data(xdrs, &objp->dir_wcc))
1895     return FALSE;
1896   return TRUE;
1897 }
1898
1899 bool_t
1900 xdr_am_REMOVE3res(XDR *xdrs, am_REMOVE3res *objp)
1901 {
1902   if (amuDebug(D_XDRTRACE))
1903     plog(XLOG_DEBUG, "xdr_am_REMOVE3res:");
1904
1905   if (!xdr_am_nfsstat3(xdrs, &objp->status))
1906     return FALSE;
1907   switch (objp->status) {
1908   case AM_NFS3_OK:
1909     if (!xdr_am_REMOVE3resok(xdrs, &objp->res_u.ok))
1910       return FALSE;
1911     break;
1912   default:
1913     if (!xdr_am_REMOVE3resfail(xdrs, &objp->res_u.fail))
1914       return FALSE;
1915     break;
1916   }
1917   return TRUE;
1918 }
1919
1920 bool_t
1921 xdr_am_READ3args(XDR *xdrs, am_READ3args *objp)
1922 {
1923   if (amuDebug(D_XDRTRACE))
1924     plog(XLOG_DEBUG, "xdr_am_READ3args:");
1925
1926   if (!xdr_am_nfs_fh3(xdrs, &objp->file))
1927     return FALSE;
1928   if (!xdr_am_offset3(xdrs, &objp->offset))
1929     return FALSE;
1930   if (!xdr_am_count3(xdrs, &objp->count))
1931     return FALSE;
1932   return TRUE;
1933 }
1934
1935 bool_t
1936 xdr_am_READ3resok(XDR *xdrs, am_READ3resok *objp)
1937 {
1938   if (amuDebug(D_XDRTRACE))
1939     plog(XLOG_DEBUG, "xdr_am_READ3resok:");
1940
1941   if (!xdr_am_post_op_attr(xdrs, &objp->file_attributes))
1942     return FALSE;
1943   if (!xdr_am_count3(xdrs, &objp->count))
1944     return FALSE;
1945   if (!xdr_bool(xdrs, &objp->eof))
1946     return FALSE;
1947   if (!xdr_bytes(xdrs, (char **)&objp->data.data_val, (u_int *) &objp->data.data_len, ~0))
1948     return FALSE;
1949   return TRUE;
1950 }
1951
1952 bool_t
1953 xdr_am_READ3resfail(XDR *xdrs, am_READ3resfail *objp)
1954 {
1955   if (amuDebug(D_XDRTRACE))
1956     plog(XLOG_DEBUG, "xdr_am_READ3resfail:");
1957
1958   if (!xdr_am_post_op_attr(xdrs, &objp->file_attributes))
1959     return FALSE;
1960   return TRUE;
1961 }
1962
1963 bool_t
1964 xdr_am_READ3res(XDR *xdrs, am_READ3res *objp)
1965 {
1966   if (amuDebug(D_XDRTRACE))
1967     plog(XLOG_DEBUG, "xdr_am_READ3res:");
1968
1969   if (!xdr_am_nfsstat3(xdrs, &objp->status))
1970     return FALSE;
1971   switch (objp->status) {
1972   case AM_NFS3_OK:
1973     if (!xdr_am_READ3resok(xdrs, &objp->res_u.ok))
1974       return FALSE;
1975     break;
1976   default:
1977     if (!xdr_am_READ3resfail(xdrs, &objp->res_u.fail))
1978       return FALSE;
1979     break;
1980   }
1981   return TRUE;
1982 }
1983
1984 bool_t
1985 xdr_am_FSINFO3args(XDR *xdrs, am_FSINFO3args *objp)
1986 {
1987   if (amuDebug(D_XDRTRACE))
1988     plog(XLOG_DEBUG, "xdr_am_FSINFO3args:");
1989
1990   if (!xdr_am_nfs_fh3(xdrs, &objp->fsroot))
1991     return FALSE;
1992   return TRUE;
1993 }
1994
1995 bool_t
1996 xdr_am_FSINFO3resok(XDR *xdrs, am_FSINFO3resok *objp)
1997 {
1998   register int32_t *buf;
1999
2000   if (amuDebug(D_XDRTRACE))
2001     plog(XLOG_DEBUG, "xdr_am_FSINFO3resok:");
2002
2003   if (xdrs->x_op == XDR_ENCODE) {
2004     if (!xdr_am_post_op_attr(xdrs, &objp->obj_attributes))
2005       return FALSE;
2006     buf = XDR_INLINE(xdrs, 7 * BYTES_PER_XDR_UNIT);
2007     if (buf == NULL) {
2008       if (!xdr_u_int(xdrs, &objp->rtmax))
2009         return FALSE;
2010       if (!xdr_u_int(xdrs, &objp->rtpref))
2011         return FALSE;
2012       if (!xdr_u_int(xdrs, &objp->rtmult))
2013         return FALSE;
2014       if (!xdr_u_int(xdrs, &objp->wtmax))
2015         return FALSE;
2016       if (!xdr_u_int(xdrs, &objp->wtpref))
2017         return FALSE;
2018       if (!xdr_u_int(xdrs, &objp->wtmult))
2019         return FALSE;
2020       if (!xdr_u_int(xdrs, &objp->dtpref))
2021         return FALSE;
2022     } else {
2023       IXDR_PUT_U_LONG(buf, objp->rtmax);
2024       IXDR_PUT_U_LONG(buf, objp->rtpref);
2025       IXDR_PUT_U_LONG(buf, objp->rtmult);
2026       IXDR_PUT_U_LONG(buf, objp->wtmax);
2027       IXDR_PUT_U_LONG(buf, objp->wtpref);
2028       IXDR_PUT_U_LONG(buf, objp->wtmult);
2029       IXDR_PUT_U_LONG(buf, objp->dtpref);
2030     }
2031     if (!xdr_am_size3(xdrs, &objp->maxfilesize))
2032       return FALSE;
2033     if (!xdr_am_nfstime3(xdrs, &objp->time_delta))
2034       return FALSE;
2035     if (!xdr_u_int(xdrs, &objp->properties))
2036       return FALSE;
2037     return TRUE;
2038   } else if (xdrs->x_op == XDR_DECODE) {
2039     if (!xdr_am_post_op_attr(xdrs, &objp->obj_attributes))
2040       return FALSE;
2041     buf = XDR_INLINE(xdrs, 7 * BYTES_PER_XDR_UNIT);
2042     if (buf == NULL) {
2043       if (!xdr_u_int (xdrs, &objp->rtmax))
2044         return FALSE;
2045       if (!xdr_u_int (xdrs, &objp->rtpref))
2046         return FALSE;
2047       if (!xdr_u_int (xdrs, &objp->rtmult))
2048         return FALSE;
2049       if (!xdr_u_int (xdrs, &objp->wtmax))
2050         return FALSE;
2051       if (!xdr_u_int(xdrs, &objp->wtpref))
2052         return FALSE;
2053       if (!xdr_u_int(xdrs, &objp->wtmult))
2054         return FALSE;
2055       if (!xdr_u_int(xdrs, &objp->dtpref))
2056         return FALSE;
2057     } else {
2058       objp->rtmax = IXDR_GET_U_LONG(buf);
2059       objp->rtpref = IXDR_GET_U_LONG(buf);
2060       objp->rtmult = IXDR_GET_U_LONG(buf);
2061       objp->wtmax = IXDR_GET_U_LONG(buf);
2062       objp->wtpref = IXDR_GET_U_LONG(buf);
2063       objp->wtmult = IXDR_GET_U_LONG(buf);
2064       objp->dtpref = IXDR_GET_U_LONG(buf);
2065     }
2066     if (!xdr_am_size3(xdrs, &objp->maxfilesize))
2067       return FALSE;
2068     if (!xdr_am_nfstime3(xdrs, &objp->time_delta))
2069       return FALSE;
2070     if (!xdr_u_int(xdrs, &objp->properties))
2071       return FALSE;
2072     return TRUE;
2073   }
2074
2075   if (!xdr_am_post_op_attr(xdrs, &objp->obj_attributes))
2076     return FALSE;
2077   if (!xdr_u_int(xdrs, &objp->rtmax))
2078     return FALSE;
2079   if (!xdr_u_int(xdrs, &objp->rtpref))
2080     return FALSE;
2081   if (!xdr_u_int(xdrs, &objp->rtmult))
2082     return FALSE;
2083   if (!xdr_u_int(xdrs, &objp->wtmax))
2084     return FALSE;
2085   if (!xdr_u_int(xdrs, &objp->wtpref))
2086     return FALSE;
2087   if (!xdr_u_int(xdrs, &objp->wtmult))
2088     return FALSE;
2089   if (!xdr_u_int(xdrs, &objp->dtpref))
2090    return FALSE;
2091   if (!xdr_am_size3(xdrs, &objp->maxfilesize))
2092     return FALSE;
2093   if (!xdr_am_nfstime3(xdrs, &objp->time_delta))
2094     return FALSE;
2095   if (!xdr_u_int(xdrs, &objp->properties))
2096     return FALSE;
2097   return TRUE;
2098 }
2099
2100 bool_t
2101 xdr_am_FSINFO3resfail(XDR *xdrs, am_FSINFO3resfail *objp)
2102 {
2103   if (amuDebug(D_XDRTRACE))
2104     plog(XLOG_DEBUG, "xdr_am_FSINFO3resfail:");
2105
2106   if (!xdr_am_post_op_attr(xdrs, &objp->obj_attributes))
2107     return FALSE;
2108   return TRUE;
2109 }
2110
2111 bool_t
2112 xdr_am_FSINFO3res(XDR *xdrs, am_FSINFO3res *objp)
2113 {
2114   if (amuDebug(D_XDRTRACE))
2115     plog(XLOG_DEBUG, "xdr_am_FSINFO3res:");
2116
2117   if (!xdr_am_nfsstat3(xdrs, &objp->status))
2118     return FALSE;
2119   switch (objp->status) {
2120   case AM_NFS3_OK:
2121     if (!xdr_am_FSINFO3resok(xdrs, &objp->res_u.ok))
2122       return FALSE;
2123     break;
2124   default:
2125     if (!xdr_am_FSINFO3resfail(xdrs, &objp->res_u.fail))
2126       return FALSE;
2127     break;
2128   }
2129   return TRUE;
2130 }
2131
2132 bool_t
2133 xdr_am_FSSTAT3args(XDR *xdrs, am_FSSTAT3args *objp)
2134 {
2135   if (amuDebug(D_XDRTRACE))
2136     plog(XLOG_DEBUG, "xdr_am_FSSTAT3args:");
2137
2138   if (!xdr_am_nfs_fh3(xdrs, &objp->fsroot))
2139     return FALSE;
2140   return TRUE;
2141 }
2142
2143 bool_t
2144 xdr_am_FSSTAT3resok(XDR *xdrs, am_FSSTAT3resok *objp)
2145 {
2146   if (amuDebug(D_XDRTRACE))
2147     plog(XLOG_DEBUG, "xdr_am_FSSTAT3resok:");
2148
2149   if (!xdr_am_post_op_attr(xdrs, &objp->obj_attributes))
2150     return FALSE;
2151   if (!xdr_am_size3(xdrs, &objp->tbytes))
2152     return FALSE;
2153   if (!xdr_am_size3(xdrs, &objp->fbytes))
2154     return FALSE;
2155   if (!xdr_am_size3(xdrs, &objp->abytes))
2156     return FALSE;
2157   if (!xdr_am_size3(xdrs, &objp->tfiles))
2158     return FALSE;
2159   if (!xdr_am_size3(xdrs, &objp->ffiles))
2160     return FALSE;
2161   if (!xdr_am_size3(xdrs, &objp->afiles))
2162     return FALSE;
2163   if (!xdr_u_int(xdrs, &objp->invarsec))
2164     return FALSE;
2165   return TRUE;
2166 }
2167
2168 bool_t
2169 xdr_am_FSSTAT3resfail(XDR *xdrs, am_FSSTAT3resfail *objp)
2170 {
2171   if (amuDebug(D_XDRTRACE))
2172     plog(XLOG_DEBUG, "xdr_am_FSSTAT3resfail:");
2173
2174   if (!xdr_am_post_op_attr(xdrs, &objp->obj_attributes))
2175     return FALSE;
2176   return TRUE;
2177 }
2178
2179 bool_t
2180 xdr_am_FSSTAT3res(XDR *xdrs, am_FSSTAT3res *objp)
2181 {
2182   if (amuDebug(D_XDRTRACE))
2183     plog(XLOG_DEBUG, "xdr_am_FSSTAT3res:");
2184
2185   if (!xdr_am_nfsstat3(xdrs, &objp->status))
2186     return FALSE;
2187   switch (objp->status) {
2188   case AM_NFS3_OK:
2189     if (!xdr_am_FSSTAT3resok(xdrs, &objp->res_u.ok))
2190       return FALSE;
2191     break;
2192   default:
2193     if (!xdr_am_FSSTAT3resfail(xdrs, &objp->res_u.fail))
2194       return FALSE;
2195     break;
2196   }
2197   return TRUE;
2198 }
2199
2200 bool_t
2201 xdr_am_PATHCONF3args(XDR *xdrs, am_PATHCONF3args *objp)
2202 {
2203   if (amuDebug(D_XDRTRACE))
2204     plog(XLOG_DEBUG, "xdr_am_PATHCONF3args:");
2205
2206   if (!xdr_am_nfs_fh3(xdrs, &objp->object))
2207     return FALSE;
2208   return TRUE;
2209 }
2210
2211 bool_t
2212 xdr_am_PATHCONF3resok(XDR *xdrs, am_PATHCONF3resok *objp)
2213 {
2214   register int32_t *buf;
2215
2216   if (amuDebug(D_XDRTRACE))
2217     plog(XLOG_DEBUG, "xdr_am_PATHCONF3resok:");
2218
2219   if (xdrs->x_op == XDR_ENCODE) {
2220     if (!xdr_am_post_op_attr(xdrs, &objp->obj_attributes))
2221       return FALSE;
2222     buf = XDR_INLINE(xdrs, 6 * BYTES_PER_XDR_UNIT);
2223     if (buf == NULL) {
2224       if (!xdr_u_int(xdrs, &objp->linkmax))
2225         return FALSE;
2226       if (!xdr_u_int(xdrs, &objp->name_max))
2227         return FALSE;
2228       if (!xdr_bool(xdrs, &objp->no_trunc))
2229         return FALSE;
2230       if (!xdr_bool(xdrs, &objp->chown_restricted))
2231         return FALSE;
2232       if (!xdr_bool(xdrs, &objp->case_insensitive))
2233         return FALSE;
2234       if (!xdr_bool(xdrs, &objp->case_preserving))
2235         return FALSE;
2236     } else {
2237       IXDR_PUT_U_LONG(buf, objp->linkmax);
2238       IXDR_PUT_U_LONG(buf, objp->name_max);
2239       IXDR_PUT_BOOL(buf, objp->no_trunc);
2240       IXDR_PUT_BOOL(buf, objp->chown_restricted);
2241       IXDR_PUT_BOOL(buf, objp->case_insensitive);
2242       IXDR_PUT_BOOL(buf, objp->case_preserving);
2243     }
2244     return TRUE;
2245   } else if (xdrs->x_op == XDR_DECODE) {
2246     if (!xdr_am_post_op_attr(xdrs, &objp->obj_attributes))
2247       return FALSE;
2248     buf = XDR_INLINE(xdrs, 6 * BYTES_PER_XDR_UNIT);
2249     if (buf == NULL) {
2250       if (!xdr_u_int(xdrs, &objp->linkmax))
2251         return FALSE;
2252       if (!xdr_u_int(xdrs, &objp->name_max))
2253         return FALSE;
2254       if (!xdr_bool(xdrs, &objp->no_trunc))
2255         return FALSE;
2256       if (!xdr_bool(xdrs, &objp->chown_restricted))
2257         return FALSE;
2258       if (!xdr_bool(xdrs, &objp->case_insensitive))
2259         return FALSE;
2260       if (!xdr_bool(xdrs, &objp->case_preserving))
2261         return FALSE;
2262     } else {
2263       objp->linkmax = IXDR_GET_U_LONG(buf);
2264       objp->name_max = IXDR_GET_U_LONG(buf);
2265       objp->no_trunc = IXDR_GET_BOOL(buf);
2266       objp->chown_restricted = IXDR_GET_BOOL(buf);
2267       objp->case_insensitive = IXDR_GET_BOOL(buf);
2268       objp->case_preserving = IXDR_GET_BOOL(buf);
2269     }
2270     return TRUE;
2271   }
2272
2273   if (!xdr_am_post_op_attr(xdrs, &objp->obj_attributes))
2274     return FALSE;
2275   if (!xdr_u_int(xdrs, &objp->linkmax))
2276     return FALSE;
2277   if (!xdr_u_int(xdrs, &objp->name_max))
2278     return FALSE;
2279   if (!xdr_bool(xdrs, &objp->no_trunc))
2280     return FALSE;
2281   if (!xdr_bool(xdrs, &objp->chown_restricted))
2282     return FALSE;
2283   if (!xdr_bool(xdrs, &objp->case_insensitive))
2284     return FALSE;
2285   if (!xdr_bool(xdrs, &objp->case_preserving))
2286     return FALSE;
2287   return TRUE;
2288 }
2289
2290 bool_t
2291 xdr_am_PATHCONF3resfail(XDR *xdrs, am_PATHCONF3resfail *objp)
2292 {
2293   if (amuDebug(D_XDRTRACE))
2294     plog(XLOG_DEBUG, "xdr_am_PATHCONF3resfail:");
2295
2296   if (!xdr_am_post_op_attr(xdrs, &objp->obj_attributes))
2297     return FALSE;
2298   return TRUE;
2299 }
2300
2301 bool_t
2302 xdr_am_PATHCONF3res(XDR *xdrs, am_PATHCONF3res *objp)
2303 {
2304   if (amuDebug(D_XDRTRACE))
2305     plog(XLOG_DEBUG, "xdr_am_PATHCONF3res:");
2306
2307   if (!xdr_am_nfsstat3(xdrs, &objp->status))
2308     return FALSE;
2309   switch (objp->status) {
2310   case AM_NFS3_OK:
2311     if (!xdr_am_PATHCONF3resok(xdrs, &objp->res_u.ok))
2312       return FALSE;
2313     break;
2314   default:
2315     if (!xdr_am_PATHCONF3resfail(xdrs, &objp->res_u.fail))
2316       return FALSE;
2317     break;
2318   }
2319   return TRUE;
2320 }
2321
2322 bool_t
2323 xdr_am_nfspath3(XDR *xdrs, am_nfspath3 *objp)
2324 {
2325   if (amuDebug(D_XDRTRACE))
2326     plog(XLOG_DEBUG, "xdr_am_nfspath3:");
2327
2328   if (!xdr_string(xdrs, objp, ~0))
2329     return FALSE;
2330   return TRUE;
2331 }
2332
2333 bool_t
2334 xdr_am_symlinkdata3(XDR *xdrs, am_symlinkdata3 *objp)
2335 {
2336   if (amuDebug(D_XDRTRACE))
2337     plog(XLOG_DEBUG, "xdr_am_symlinkdata3:");
2338
2339   if (!xdr_am_sattr3(xdrs, &objp->symlink_attributes))
2340     return FALSE;
2341   if (!xdr_am_nfspath3(xdrs, &objp->symlink_data))
2342     return FALSE;
2343   return TRUE;
2344 }
2345
2346 bool_t
2347 xdr_am_SYMLINK3args(XDR *xdrs, am_SYMLINK3args *objp)
2348 {
2349   if (amuDebug(D_XDRTRACE))
2350     plog(XLOG_DEBUG, "xdr_am_SYMLINK3args:");
2351
2352   if (!xdr_am_diropargs3(xdrs, &objp->where))
2353     return FALSE;
2354   if (!xdr_am_symlinkdata3(xdrs, &objp->symlink))
2355     return FALSE;
2356   return TRUE;
2357 }
2358
2359 bool_t
2360 xdr_am_SYMLINK3resok(XDR *xdrs, am_SYMLINK3resok *objp)
2361 {
2362   if (amuDebug(D_XDRTRACE))
2363     plog(XLOG_DEBUG, "xdr_am_SYMLINK3resok:");
2364
2365   if (!xdr_am_post_op_fh3(xdrs, &objp->obj))
2366     return FALSE;
2367   if (!xdr_am_post_op_attr(xdrs, &objp->obj_attributes))
2368     return FALSE;
2369   if (!xdr_am_wcc_data(xdrs, &objp->dir_wcc))
2370     return FALSE;
2371   return TRUE;
2372 }
2373
2374 bool_t
2375 xdr_am_SYMLINK3resfail(XDR *xdrs, am_SYMLINK3resfail *objp)
2376 {
2377   if (amuDebug(D_XDRTRACE))
2378     plog(XLOG_DEBUG, "xdr_am_SYMLINK3resfail:");
2379
2380   if (!xdr_am_wcc_data(xdrs, &objp->dir_wcc))
2381     return FALSE;
2382   return TRUE;
2383 }
2384
2385 bool_t
2386 xdr_am_SYMLINK3res(XDR *xdrs, am_SYMLINK3res *objp)
2387 {
2388   if (amuDebug(D_XDRTRACE))
2389     plog(XLOG_DEBUG, "xdr_am_SYMLINK3res:");
2390
2391   if (!xdr_am_nfsstat3(xdrs, &objp->status))
2392     return FALSE;
2393   switch (objp->status) {
2394   case AM_NFS3_OK:
2395     if (!xdr_am_SYMLINK3resok(xdrs, &objp->res_u.ok))
2396       return FALSE;
2397     break;
2398   default:
2399     if (!xdr_am_SYMLINK3resfail(xdrs, &objp->res_u.fail))
2400       return FALSE;
2401     break;
2402   }
2403   return TRUE;
2404 }
2405
2406 bool_t
2407 xdr_am_READLINK3args(XDR *xdrs, am_READLINK3args *objp)
2408 {
2409   if (amuDebug(D_XDRTRACE))
2410     plog(XLOG_DEBUG, "xdr_am_READLINK3args:");
2411
2412   if (!xdr_am_nfs_fh3(xdrs, &objp->symlink))
2413     return FALSE;
2414   return TRUE;
2415 }
2416
2417 bool_t
2418 xdr_am_READLINK3resok(XDR *xdrs, am_READLINK3resok *objp)
2419 {
2420   if (amuDebug(D_XDRTRACE))
2421     plog(XLOG_DEBUG, "xdr_am_READLINK3resok:");
2422
2423   if (!xdr_am_post_op_attr(xdrs, &objp->symlink_attributes))
2424     return FALSE;
2425   if (!xdr_am_nfspath3(xdrs, &objp->data))
2426     return FALSE;
2427   return TRUE;
2428 }
2429
2430 bool_t
2431 xdr_am_READLINK3resfail(XDR *xdrs, am_READLINK3resfail *objp)
2432 {
2433   if (amuDebug(D_XDRTRACE))
2434     plog(XLOG_DEBUG, "xdr_am_READLINK3resfail:");
2435
2436   if (!xdr_am_post_op_attr(xdrs, &objp->symlink_attributes))
2437     return FALSE;
2438   return TRUE;
2439 }
2440
2441 bool_t
2442 xdr_am_READLINK3res(XDR *xdrs, am_READLINK3res *objp)
2443 {
2444   if (amuDebug(D_XDRTRACE))
2445     plog(XLOG_DEBUG, "xdr_am_READLINK3res:");
2446
2447   if (!xdr_am_nfsstat3(xdrs, &objp->status))
2448     return FALSE;
2449   switch (objp->status) {
2450   case AM_NFS3_OK:
2451     if (!xdr_am_READLINK3resok(xdrs, &objp->res_u.ok))
2452       return FALSE;
2453     break;
2454   default:
2455     if (!xdr_am_READLINK3resfail(xdrs, &objp->res_u.fail))
2456       return FALSE;
2457     break;
2458   }
2459   return TRUE;
2460 }
2461
2462 bool_t
2463 xdr_am_devicedata3(XDR *xdrs, am_devicedata3 *objp)
2464 {
2465   if (amuDebug(D_XDRTRACE))
2466     plog(XLOG_DEBUG, "xdr_am_devicedata3:");
2467
2468   if (!xdr_am_sattr3(xdrs, &objp->dev_attributes))
2469     return FALSE;
2470   if (!xdr_am_specdata3(xdrs, &objp->spec))
2471     return FALSE;
2472   return TRUE;
2473 }
2474
2475 bool_t
2476 xdr_am_mknoddata3(XDR *xdrs, am_mknoddata3 *objp)
2477 {
2478   if (amuDebug(D_XDRTRACE))
2479     plog(XLOG_DEBUG, "xdr_am_mknoddata3:");
2480
2481   if (!xdr_am_ftype3(xdrs, &objp->type))
2482     return FALSE;
2483   switch (objp->type) {
2484   case AM_NF3CHR:
2485     if (!xdr_am_devicedata3(xdrs, &objp->am_mknoddata3_u.chr_device))
2486       return FALSE;
2487     break;
2488   case AM_NF3BLK:
2489     if (!xdr_am_devicedata3(xdrs, &objp->am_mknoddata3_u.blk_device))
2490       return FALSE;
2491     break;
2492   case AM_NF3SOCK:
2493     if (!xdr_am_sattr3(xdrs, &objp->am_mknoddata3_u.sock_attributes))
2494       return FALSE;
2495     break;
2496   case AM_NF3FIFO:
2497     if (!xdr_am_sattr3(xdrs, &objp->am_mknoddata3_u.pipe_attributes))
2498       return FALSE;
2499     break;
2500   default:
2501     break;
2502   }
2503   return TRUE;
2504 }
2505
2506 bool_t
2507 xdr_am_MKNOD3args(XDR *xdrs, am_MKNOD3args *objp)
2508 {
2509   if (amuDebug(D_XDRTRACE))
2510     plog(XLOG_DEBUG, "xdr_am_MKNOD3args:");
2511
2512   if (!xdr_am_diropargs3(xdrs, &objp->where))
2513     return FALSE;
2514   if (!xdr_am_mknoddata3(xdrs, &objp->what))
2515     return FALSE;
2516   return TRUE;
2517 }
2518
2519 bool_t
2520 xdr_am_MKNOD3resok(XDR *xdrs, am_MKNOD3resok *objp)
2521 {
2522   if (amuDebug(D_XDRTRACE))
2523     plog(XLOG_DEBUG, "xdr_am_MKNOD3resok:");
2524
2525   if (!xdr_am_post_op_fh3(xdrs, &objp->obj))
2526     return FALSE;
2527   if (!xdr_am_post_op_attr(xdrs, &objp->obj_attributes))
2528     return FALSE;
2529   if (!xdr_am_wcc_data(xdrs, &objp->dir_wcc))
2530     return FALSE;
2531   return TRUE;
2532 }
2533
2534 bool_t
2535 xdr_am_MKNOD3resfail(XDR *xdrs, am_MKNOD3resfail *objp)
2536 {
2537   if (amuDebug(D_XDRTRACE))
2538     plog(XLOG_DEBUG, "xdr_am_MKNOD3resfail:");
2539
2540   if (!xdr_am_wcc_data(xdrs, &objp->dir_wcc))
2541     return FALSE;
2542   return TRUE;
2543 }
2544
2545 bool_t
2546 xdr_am_MKNOD3res(XDR *xdrs, am_MKNOD3res *objp)
2547 {
2548   if (amuDebug(D_XDRTRACE))
2549     plog(XLOG_DEBUG, ":");
2550
2551   if (!xdr_am_nfsstat3(xdrs, &objp->status))
2552     return FALSE;
2553   switch (objp->status) {
2554   case AM_NFS3_OK:
2555     if (!xdr_am_MKNOD3resok(xdrs, &objp->res_u.ok))
2556       return FALSE;
2557     break;
2558   default:
2559     if (!xdr_am_MKNOD3resfail(xdrs, &objp->res_u.fail))
2560       return FALSE;
2561     break;
2562   }
2563   return TRUE;
2564 }
2565
2566 bool_t
2567 xdr_am_MKDIR3args(XDR *xdrs, am_MKDIR3args *objp)
2568 {
2569   if (amuDebug(D_XDRTRACE))
2570     plog(XLOG_DEBUG, ":");
2571
2572   if (!xdr_am_diropargs3(xdrs, &objp->where))
2573     return FALSE;
2574   if (!xdr_am_sattr3(xdrs, &objp->attributes))
2575     return FALSE;
2576   return TRUE;
2577 }
2578
2579 bool_t
2580 xdr_am_MKDIR3resok(XDR *xdrs, am_MKDIR3resok *objp)
2581 {
2582   if (amuDebug(D_XDRTRACE))
2583     plog(XLOG_DEBUG, "xdr_am_MKDIR3resok:");
2584
2585   if (!xdr_am_post_op_fh3(xdrs, &objp->obj))
2586     return FALSE;
2587   if (!xdr_am_post_op_attr(xdrs, &objp->obj_attributes))
2588     return FALSE;
2589   if (!xdr_am_wcc_data(xdrs, &objp->dir_wcc))
2590     return FALSE;
2591   return TRUE;
2592 }
2593
2594 bool_t
2595 xdr_am_MKDIR3resfail(XDR *xdrs, am_MKDIR3resfail *objp)
2596 {
2597   if (amuDebug(D_XDRTRACE))
2598     plog(XLOG_DEBUG, "xdr_am_MKDIR3resfail:");
2599
2600   if (!xdr_am_wcc_data(xdrs, &objp->dir_wcc))
2601     return FALSE;
2602   return TRUE;
2603 }
2604
2605 bool_t
2606 xdr_am_MKDIR3res(XDR *xdrs, am_MKDIR3res *objp)
2607 {
2608   if (amuDebug(D_XDRTRACE))
2609     plog(XLOG_DEBUG, "xdr_am_MKDIR3res:");
2610
2611   if (!xdr_am_nfsstat3(xdrs, &objp->status))
2612     return FALSE;
2613   switch (objp->status) {
2614   case AM_NFS3_OK:
2615     if (!xdr_am_MKDIR3resok(xdrs, &objp->res_u.ok))
2616       return FALSE;
2617     break;
2618   default:
2619     if (!xdr_am_MKDIR3resfail(xdrs, &objp->res_u.fail))
2620       return FALSE;
2621     break;
2622   }
2623   return TRUE;
2624 }
2625
2626 bool_t
2627 xdr_am_RMDIR3args(XDR *xdrs, am_RMDIR3args *objp)
2628 {
2629   if (amuDebug(D_XDRTRACE))
2630     plog(XLOG_DEBUG, "xdr_am_RMDIR3args:");
2631
2632   if (!xdr_am_diropargs3(xdrs, &objp->object))
2633     return FALSE;
2634   return TRUE;
2635 }
2636
2637 bool_t
2638 xdr_am_RMDIR3resok(XDR *xdrs, am_RMDIR3resok *objp)
2639 {
2640   if (amuDebug(D_XDRTRACE))
2641     plog(XLOG_DEBUG, "xdr_am_RMDIR3resok:");
2642
2643   if (!xdr_am_wcc_data(xdrs, &objp->dir_wcc))
2644     return FALSE;
2645   return TRUE;
2646 }
2647
2648 bool_t
2649 xdr_am_RMDIR3resfail(XDR *xdrs, am_RMDIR3resfail *objp)
2650 {
2651   if (amuDebug(D_XDRTRACE))
2652     plog(XLOG_DEBUG, "xdr_am_RMDIR3resfail:");
2653
2654   if (!xdr_am_wcc_data(xdrs, &objp->dir_wcc))
2655     return FALSE;
2656   return TRUE;
2657 }
2658
2659 bool_t
2660 xdr_am_RMDIR3res(XDR *xdrs, am_RMDIR3res *objp)
2661 {
2662   if (amuDebug(D_XDRTRACE))
2663     plog(XLOG_DEBUG, "xdr_am_RMDIR3res:");
2664
2665   if (!xdr_am_nfsstat3(xdrs, &objp->status))
2666     return FALSE;
2667   switch (objp->status) {
2668   case AM_NFS3_OK:
2669     if (!xdr_am_RMDIR3resok(xdrs, &objp->res_u.ok))
2670       return FALSE;
2671     break;
2672   default:
2673     if (!xdr_am_RMDIR3resfail(xdrs, &objp->res_u.fail))
2674       return FALSE;
2675     break;
2676   }
2677   return TRUE;
2678 }
2679
2680 bool_t
2681 xdr_am_RENAME3args(XDR *xdrs, am_RENAME3args *objp)
2682 {
2683   if (amuDebug(D_XDRTRACE))
2684     plog(XLOG_DEBUG, "xdr_am_RENAME3args:");
2685
2686   if (!xdr_am_diropargs3(xdrs, &objp->from))
2687     return FALSE;
2688   if (!xdr_am_diropargs3(xdrs, &objp->to))
2689     return FALSE;
2690   return TRUE;
2691 }
2692
2693 bool_t
2694 xdr_am_RENAME3resok(XDR *xdrs, am_RENAME3resok *objp)
2695 {
2696   if (amuDebug(D_XDRTRACE))
2697     plog(XLOG_DEBUG, "xdr_am_RENAME3resok:");
2698
2699   if (!xdr_am_wcc_data(xdrs, &objp->fromdir_wcc))
2700     return FALSE;
2701   if (!xdr_am_wcc_data(xdrs, &objp->todir_wcc))
2702     return FALSE;
2703   return TRUE;
2704 }
2705
2706 bool_t
2707 xdr_am_RENAME3resfail(XDR *xdrs, am_RENAME3resfail *objp)
2708 {
2709   if (amuDebug(D_XDRTRACE))
2710     plog(XLOG_DEBUG, "xdr_am_RENAME3resfail:");
2711
2712   if (!xdr_am_wcc_data(xdrs, &objp->fromdir_wcc))
2713     return FALSE;
2714   if (!xdr_am_wcc_data(xdrs, &objp->todir_wcc))
2715     return FALSE;
2716   return TRUE;
2717 }
2718
2719 bool_t
2720 xdr_am_RENAME3res(XDR *xdrs, am_RENAME3res *objp)
2721 {
2722   if (amuDebug(D_XDRTRACE))
2723     plog(XLOG_DEBUG, "xdr_am_RENAME3res:");
2724
2725   if (!xdr_am_nfsstat3(xdrs, &objp->status))
2726     return FALSE;
2727   switch (objp->status) {
2728   case AM_NFS3_OK:
2729     if (!xdr_am_RENAME3resok(xdrs, &objp->res_u.ok))
2730       return FALSE;
2731     break;
2732   default:
2733     if (!xdr_am_RENAME3resfail(xdrs, &objp->res_u.fail))
2734       return FALSE;
2735     break;
2736   }
2737   return TRUE;
2738 }
2739
2740 bool_t
2741 xdr_am_READDIRPLUS3args(XDR *xdrs, am_READDIRPLUS3args *objp)
2742 {
2743   if (amuDebug(D_XDRTRACE))
2744     plog(XLOG_DEBUG, "xdr_am_READDIRPLUS3args:");
2745
2746   if (!xdr_am_nfs_fh3(xdrs, &objp->dir))
2747     return FALSE;
2748   if (!xdr_am_cookie3(xdrs, &objp->cookie))
2749     return FALSE;
2750   if (!xdr_am_cookieverf3(xdrs, objp->cookieverf))
2751     return FALSE;
2752   if (!xdr_am_count3(xdrs, &objp->dircount))
2753     return FALSE;
2754   if (!xdr_am_count3(xdrs, &objp->maxcount))
2755     return FALSE;
2756   return TRUE;
2757 }
2758
2759 bool_t
2760 xdr_am_entryplus3(XDR *xdrs, am_entryplus3 *objp)
2761 {
2762   if (amuDebug(D_XDRTRACE))
2763     plog(XLOG_DEBUG, "xdr_am_entryplus3:");
2764
2765    if (!xdr_am_fileid3(xdrs, &objp->fileid))
2766      return FALSE;
2767    if (!xdr_am_filename3(xdrs, &objp->name))
2768      return FALSE;
2769    if (!xdr_am_cookie3(xdrs, &objp->cookie))
2770      return FALSE;
2771    if (!xdr_am_post_op_attr(xdrs, &objp->name_attributes))
2772      return FALSE;
2773    if (!xdr_am_post_op_fh3(xdrs, &objp->name_handle))
2774      return FALSE;
2775    if (!xdr_pointer(xdrs, (char **)&objp->nextentry,
2776                    sizeof(am_entryplus3), (xdrproc_t) xdr_am_entryplus3))
2777      return FALSE;
2778   return TRUE;
2779 }
2780
2781 bool_t
2782 xdr_am_dirlistplus3(XDR *xdrs, am_dirlistplus3 *objp)
2783 {
2784   if (amuDebug(D_XDRTRACE))
2785     plog(XLOG_DEBUG, "xdr_am_dirlistplus3:");
2786
2787   if (!xdr_pointer(xdrs, (char **)&objp->entries,
2788                    sizeof(am_entryplus3), (xdrproc_t) xdr_am_entryplus3))
2789     return FALSE;
2790   if (!xdr_bool(xdrs, &objp->eof))
2791     return FALSE;
2792   return TRUE;
2793 }
2794
2795 bool_t
2796 xdr_am_READDIRPLUS3resok(XDR *xdrs, am_READDIRPLUS3resok *objp)
2797 {
2798   if (amuDebug(D_XDRTRACE))
2799     plog(XLOG_DEBUG, "xdr_am_READDIRPLUS3resok:");
2800
2801   if (!xdr_am_post_op_attr(xdrs, &objp->dir_attributes))
2802     return FALSE;
2803   if (!xdr_am_cookieverf3(xdrs, objp->cookieverf))
2804     return FALSE;
2805   if (!xdr_am_dirlistplus3(xdrs, &objp->reply))
2806     return FALSE;
2807   return TRUE;
2808 }
2809
2810 bool_t
2811 xdr_am_READDIRPLUS3resfail(XDR *xdrs, am_READDIRPLUS3resfail *objp)
2812 {
2813   if (amuDebug(D_XDRTRACE))
2814     plog(XLOG_DEBUG, "xdr_am_READDIRPLUS3resfail:");
2815
2816   if (!xdr_am_post_op_attr(xdrs, &objp->dir_attributes))
2817     return FALSE;
2818   return TRUE;
2819 }
2820
2821 bool_t
2822 xdr_am_READDIRPLUS3res(XDR *xdrs, am_READDIRPLUS3res *objp)
2823 {
2824   if (amuDebug(D_XDRTRACE))
2825     plog(XLOG_DEBUG, "xdr_am_READDIRPLUS3res:");
2826
2827   if (!xdr_am_nfsstat3(xdrs, &objp->status))
2828     return FALSE;
2829   switch (objp->status) {
2830   case AM_NFS3_OK:
2831     if (!xdr_am_READDIRPLUS3resok(xdrs, &objp->res_u.ok))
2832       return FALSE;
2833     break;
2834   default:
2835     if (!xdr_am_READDIRPLUS3resfail(xdrs, &objp->res_u.fail))
2836       return FALSE;
2837     break;
2838   }
2839   return TRUE;
2840 }
2841
2842 bool_t
2843 xdr_am_READDIR3args(XDR *xdrs, am_READDIR3args *objp)
2844 {
2845   if (amuDebug(D_XDRTRACE))
2846     plog(XLOG_DEBUG, "xdr_am_READDIR3args:");
2847
2848   if (!xdr_am_nfs_fh3(xdrs, &objp->dir))
2849     return FALSE;
2850   if (!xdr_am_cookie3(xdrs, &objp->cookie))
2851     return FALSE;
2852   if (!xdr_am_cookieverf3(xdrs, objp->cookieverf))
2853     return FALSE;
2854   if (!xdr_am_count3(xdrs, &objp->count))
2855     return FALSE;
2856   return TRUE;
2857 }
2858
2859 bool_t
2860 xdr_am_entry3(XDR *xdrs, am_entry3 *objp)
2861 {
2862   if (amuDebug(D_XDRTRACE))
2863     plog(XLOG_DEBUG, "xdr_am_entry3:");
2864
2865   if (!xdr_am_fileid3(xdrs, &objp->fileid))
2866     return FALSE;
2867   if (!xdr_am_filename3(xdrs, &objp->name))
2868     return FALSE;
2869   if (!xdr_am_cookie3(xdrs, &objp->cookie))
2870     return FALSE;
2871   if (!xdr_pointer(xdrs, (char **)&objp->nextentry,
2872                    sizeof(am_entry3), (xdrproc_t) xdr_am_entry3))
2873     return FALSE;
2874   return TRUE;
2875 }
2876
2877 bool_t
2878 xdr_am_dirlist3(XDR *xdrs, am_dirlist3 *objp)
2879 {
2880   if (amuDebug(D_XDRTRACE))
2881     plog(XLOG_DEBUG, "xdr_am_dirlist3:");
2882
2883   if (!xdr_pointer(xdrs, (char **)&objp->entries,
2884                    sizeof(am_entry3), (xdrproc_t) xdr_am_entry3))
2885     return FALSE;
2886   if (!xdr_bool (xdrs, &objp->eof))
2887     return FALSE;
2888   return TRUE;
2889 }
2890
2891 bool_t
2892 xdr_am_READDIR3resok(XDR *xdrs, am_READDIR3resok *objp)
2893 {
2894   if (amuDebug(D_XDRTRACE))
2895     plog(XLOG_DEBUG, "xdr_am_READDIR3resok:");
2896
2897   if (!xdr_am_post_op_attr(xdrs, &objp->dir_attributes))
2898     return FALSE;
2899   if (!xdr_am_cookieverf3(xdrs, objp->cookieverf))
2900     return FALSE;
2901   if (!xdr_am_dirlist3(xdrs, &objp->reply))
2902     return FALSE;
2903   return TRUE;
2904 }
2905
2906 bool_t
2907 xdr_am_READDIR3resfail(XDR *xdrs, am_READDIR3resfail *objp)
2908 {
2909   if (amuDebug(D_XDRTRACE))
2910     plog(XLOG_DEBUG, "xdr_am_READDIR3resfail:");
2911
2912   if (!xdr_am_post_op_attr(xdrs, &objp->dir_attributes))
2913     return FALSE;
2914   return TRUE;
2915 }
2916
2917 bool_t
2918 xdr_am_READDIR3res(XDR *xdrs, am_READDIR3res *objp)
2919 {
2920   if (amuDebug(D_XDRTRACE))
2921     plog(XLOG_DEBUG, "xdr_am_READDIR3res:");
2922
2923   if (!xdr_am_nfsstat3(xdrs, &objp->status))
2924     return FALSE;
2925   switch (objp->status) {
2926   case AM_NFS3_OK:
2927     if (!xdr_am_READDIR3resok(xdrs, &objp->res_u.ok))
2928       return FALSE;
2929     break;
2930   default:
2931     if (!xdr_am_READDIR3resfail(xdrs, &objp->res_u.fail))
2932       return FALSE;
2933     break;
2934   }
2935   return TRUE;
2936 }
2937
2938 bool_t
2939 xdr_am_LINK3args(XDR *xdrs, am_LINK3args *objp)
2940 {
2941   if (amuDebug(D_XDRTRACE))
2942     plog(XLOG_DEBUG, "xdr_am_LINK3args:");
2943
2944   if (!xdr_am_nfs_fh3(xdrs, &objp->file))
2945     return FALSE;
2946   if (!xdr_am_diropargs3(xdrs, &objp->link))
2947     return FALSE;
2948   return TRUE;
2949 }
2950
2951 bool_t
2952 xdr_am_LINK3resok(XDR *xdrs, am_LINK3resok *objp)
2953 {
2954   if (amuDebug(D_XDRTRACE))
2955     plog(XLOG_DEBUG, "xdr_am_LINK3resok:");
2956
2957   if (!xdr_am_post_op_attr(xdrs, &objp->file_attributes))
2958     return FALSE;
2959   if (!xdr_am_wcc_data(xdrs, &objp->linkdir_wcc))
2960     return FALSE;
2961   return TRUE;
2962 }
2963
2964 bool_t
2965 xdr_am_LINK3resfail(XDR *xdrs, am_LINK3resfail *objp)
2966 {
2967   if (amuDebug(D_XDRTRACE))
2968     plog(XLOG_DEBUG, "xdr_am_LINK3resfail:");
2969
2970   if (!xdr_am_post_op_attr(xdrs, &objp->file_attributes))
2971     return FALSE;
2972   if (!xdr_am_wcc_data(xdrs, &objp->linkdir_wcc))
2973     return FALSE;
2974   return TRUE;
2975 }
2976
2977 bool_t
2978 xdr_am_LINK3res(XDR *xdrs, am_LINK3res *objp)
2979 {
2980   if (amuDebug(D_XDRTRACE))
2981     plog(XLOG_DEBUG, "xdr_am_LINK3res:");
2982
2983   if (!xdr_am_nfsstat3(xdrs, &objp->status))
2984     return FALSE;
2985   switch (objp->status) {
2986   case AM_NFS3_OK:
2987     if (!xdr_am_LINK3resok(xdrs, &objp->res_u.ok))
2988       return FALSE;
2989     break;
2990   default:
2991     if (!xdr_am_LINK3resfail(xdrs, &objp->res_u.fail))
2992       return FALSE;
2993     break;
2994   }
2995   return TRUE;
2996 }
2997
2998 bool_t
2999 xdr_am_sattrguard3(XDR *xdrs, am_sattrguard3 *objp)
3000 {
3001   if (amuDebug(D_XDRTRACE))
3002     plog(XLOG_DEBUG, "xdr_am_sattrguard3:");
3003
3004   if (!xdr_bool(xdrs, &objp->check))
3005     return FALSE;
3006   switch (objp->check) {
3007   case TRUE:
3008     if (!xdr_am_nfstime3(xdrs, &objp->am_sattrguard3_u.obj_ctime))
3009       return FALSE;
3010     break;
3011   case FALSE:
3012     break;
3013   default:
3014     return FALSE;
3015   }
3016   return TRUE;
3017 }
3018
3019 bool_t
3020 xdr_am_SETATTR3args(XDR *xdrs, am_SETATTR3args *objp)
3021 {
3022   if (amuDebug(D_XDRTRACE))
3023     plog(XLOG_DEBUG, "xdr_am_SETATTR3args:");
3024
3025   if (!xdr_am_nfs_fh3(xdrs, &objp->object))
3026     return FALSE;
3027   if (!xdr_am_sattr3(xdrs, &objp->new_attributes))
3028     return FALSE;
3029   if (!xdr_am_sattrguard3(xdrs, &objp->guard))
3030     return FALSE;
3031   return TRUE;
3032 }
3033
3034 bool_t
3035 xdr_am_SETATTR3resok(XDR *xdrs, am_SETATTR3resok *objp)
3036 {
3037   if (amuDebug(D_XDRTRACE))
3038     plog(XLOG_DEBUG, "xdr_am_SETATTR3resok:");
3039
3040   if (!xdr_am_wcc_data(xdrs, &objp->obj_wcc))
3041     return FALSE;
3042   return TRUE;
3043 }
3044
3045 bool_t
3046 xdr_am_SETATTR3resfail(XDR *xdrs, am_SETATTR3resfail *objp)
3047 {
3048   if (amuDebug(D_XDRTRACE))
3049     plog(XLOG_DEBUG, "xdr_am_SETATTR3resfail:");
3050
3051   if (!xdr_am_wcc_data(xdrs, &objp->obj_wcc))
3052     return FALSE;
3053   return TRUE;
3054 }
3055
3056 bool_t
3057 xdr_am_SETATTR3res(XDR *xdrs, am_SETATTR3res *objp)
3058 {
3059   if (amuDebug(D_XDRTRACE))
3060     plog(XLOG_DEBUG, "xdr_am_SETATTR3res:");
3061
3062   if (!xdr_am_nfsstat3(xdrs, &objp->status))
3063     return FALSE;
3064   switch (objp->status) {
3065   case AM_NFS3_OK:
3066     if (!xdr_am_SETATTR3resok(xdrs, &objp->res_u.ok))
3067       return FALSE;
3068     break;
3069   default:
3070     if (!xdr_am_SETATTR3resfail(xdrs, &objp->res_u.fail))
3071       return FALSE;
3072     break;
3073   }
3074   return TRUE;
3075 }
3076 #endif /* HAVE_FS_NFS3 */