Home | History | Annotate | Download | only in snoop
      1 /*
      2  * CDDL HEADER START
      3  *
      4  * The contents of this file are subject to the terms of the
      5  * Common Development and Distribution License (the "License").
      6  * You may not use this file except in compliance with the License.
      7  *
      8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
      9  * or http://www.opensolaris.org/os/licensing.
     10  * See the License for the specific language governing permissions
     11  * and limitations under the License.
     12  *
     13  * When distributing Covered Code, include this CDDL HEADER in each
     14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
     15  * If applicable, add the following below this CDDL HEADER, with the
     16  * fields enclosed by brackets "[]" replaced with your own identifying
     17  * information: Portions Copyright [yyyy] [name of copyright owner]
     18  *
     19  * CDDL HEADER END
     20  */
     21 /*
     22  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
     23  * Use is subject to license terms.
     24  */
     25 
     26 #include "nfs4_prot.h"
     27 
     28 #ifndef _KERNEL
     29 #include <stdlib.h>
     30 #endif /* !_KERNEL */
     31 
     32 #ifndef _AUTH_SYS_DEFINE_FOR_NFSv41
     33 #define	_AUTH_SYS_DEFINE_FOR_NFSv41
     34 #include <rpc/auth_sys.h>
     35 typedef struct authsys_parms authsys_parms;
     36 #endif /* _AUTH_SYS_DEFINE_FOR_NFSv41 */
     37 
     38 #define	IGNORE_RDWR_DATA
     39 
     40 extern int nfs4_skip_bytes;
     41 
     42 bool_t
     43 xdr_nfs_ftype4(XDR *xdrs, nfs_ftype4 *objp)
     44 {
     45 
     46 	rpc_inline_t *buf;
     47 
     48 	if (!xdr_enum(xdrs, (enum_t *)objp))
     49 		return (FALSE);
     50 	return (TRUE);
     51 }
     52 
     53 bool_t
     54 xdr_nfsstat4(XDR *xdrs, nfsstat4 *objp)
     55 {
     56 
     57 	rpc_inline_t *buf;
     58 
     59 	if (!xdr_enum(xdrs, (enum_t *)objp))
     60 		return (FALSE);
     61 	return (TRUE);
     62 }
     63 
     64 bool_t
     65 xdr_attrlist4(XDR *xdrs, attrlist4 *objp)
     66 {
     67 
     68 	rpc_inline_t *buf;
     69 
     70 	if (!xdr_bytes(xdrs, (char **)&objp->attrlist4_val,
     71 	    (uint_t *)&objp->attrlist4_len, ~0))
     72 		return (FALSE);
     73 	return (TRUE);
     74 }
     75 
     76 bool_t
     77 xdr_bitmap4(XDR *xdrs, bitmap4 *objp)
     78 {
     79 
     80 	rpc_inline_t *buf;
     81 
     82 	if (!xdr_array(xdrs, (char **)&objp->bitmap4_val,
     83 	    (uint_t *)&objp->bitmap4_len, ~0,
     84 	    sizeof (uint32_t), (xdrproc_t)xdr_uint32_t))
     85 		return (FALSE);
     86 	return (TRUE);
     87 }
     88 
     89 bool_t
     90 xdr_changeid4(XDR *xdrs, changeid4 *objp)
     91 {
     92 
     93 	rpc_inline_t *buf;
     94 
     95 	if (!xdr_uint64_t(xdrs, objp))
     96 		return (FALSE);
     97 	return (TRUE);
     98 }
     99 
    100 bool_t
    101 xdr_clientid4(XDR *xdrs, clientid4 *objp)
    102 {
    103 
    104 	rpc_inline_t *buf;
    105 
    106 	if (!xdr_uint64_t(xdrs, objp))
    107 		return (FALSE);
    108 	return (TRUE);
    109 }
    110 
    111 bool_t
    112 xdr_count4(XDR *xdrs, count4 *objp)
    113 {
    114 
    115 	rpc_inline_t *buf;
    116 
    117 	if (!xdr_uint32_t(xdrs, objp))
    118 		return (FALSE);
    119 	return (TRUE);
    120 }
    121 
    122 bool_t
    123 xdr_length4(XDR *xdrs, length4 *objp)
    124 {
    125 
    126 	rpc_inline_t *buf;
    127 
    128 	if (!xdr_uint64_t(xdrs, objp))
    129 		return (FALSE);
    130 	return (TRUE);
    131 }
    132 
    133 bool_t
    134 xdr_mode4(XDR *xdrs, mode4 *objp)
    135 {
    136 
    137 	rpc_inline_t *buf;
    138 
    139 	if (!xdr_uint32_t(xdrs, objp))
    140 		return (FALSE);
    141 	return (TRUE);
    142 }
    143 
    144 bool_t
    145 xdr_nfs_cookie4(XDR *xdrs, nfs_cookie4 *objp)
    146 {
    147 
    148 	rpc_inline_t *buf;
    149 
    150 	if (!xdr_uint64_t(xdrs, objp))
    151 		return (FALSE);
    152 	return (TRUE);
    153 }
    154 
    155 bool_t
    156 xdr_nfs_fh4(XDR *xdrs, nfs_fh4 *objp)
    157 {
    158 
    159 	rpc_inline_t *buf;
    160 
    161 	if (!xdr_bytes(xdrs, (char **)&objp->nfs_fh4_val,
    162 	    (uint_t *)&objp->nfs_fh4_len, NFS4_FHSIZE))
    163 		return (FALSE);
    164 	return (TRUE);
    165 }
    166 
    167 bool_t
    168 xdr_offset4(XDR *xdrs, offset4 *objp)
    169 {
    170 
    171 	rpc_inline_t *buf;
    172 
    173 	if (!xdr_uint64_t(xdrs, objp))
    174 		return (FALSE);
    175 	return (TRUE);
    176 }
    177 
    178 bool_t
    179 xdr_qop4(XDR *xdrs, qop4 *objp)
    180 {
    181 
    182 	rpc_inline_t *buf;
    183 
    184 	if (!xdr_uint32_t(xdrs, objp))
    185 		return (FALSE);
    186 	return (TRUE);
    187 }
    188 
    189 bool_t
    190 xdr_sec_oid4(XDR *xdrs, sec_oid4 *objp)
    191 {
    192 
    193 	rpc_inline_t *buf;
    194 
    195 	if (!xdr_bytes(xdrs, (char **)&objp->sec_oid4_val,
    196 	    (uint_t *)&objp->sec_oid4_len, ~0))
    197 		return (FALSE);
    198 	return (TRUE);
    199 }
    200 
    201 bool_t
    202 xdr_sequenceid4(XDR *xdrs, sequenceid4 *objp)
    203 {
    204 
    205 	rpc_inline_t *buf;
    206 
    207 	if (!xdr_uint32_t(xdrs, objp))
    208 		return (FALSE);
    209 	return (TRUE);
    210 }
    211 
    212 bool_t
    213 xdr_seqid4(XDR *xdrs, seqid4 *objp)
    214 {
    215 
    216 	rpc_inline_t *buf;
    217 
    218 	if (!xdr_uint32_t(xdrs, objp))
    219 		return (FALSE);
    220 	return (TRUE);
    221 }
    222 
    223 bool_t
    224 xdr_sessionid4(XDR *xdrs, sessionid4 objp)
    225 {
    226 
    227 	rpc_inline_t *buf;
    228 
    229 	if (!xdr_opaque(xdrs, objp, NFS4_SESSIONID_SIZE))
    230 		return (FALSE);
    231 	return (TRUE);
    232 }
    233 
    234 bool_t
    235 xdr_slotid4(XDR *xdrs, slotid4 *objp)
    236 {
    237 
    238 	rpc_inline_t *buf;
    239 
    240 	if (!xdr_uint32_t(xdrs, objp))
    241 		return (FALSE);
    242 	return (TRUE);
    243 }
    244 
    245 bool_t
    246 xdr_utf8string(XDR *xdrs, utf8string *objp)
    247 {
    248 
    249 	rpc_inline_t *buf;
    250 
    251 	if (!xdr_bytes(xdrs, (char **)&objp->utf8string_val,
    252 	    (uint_t *)&objp->utf8string_len, ~0))
    253 		return (FALSE);
    254 	return (TRUE);
    255 }
    256 
    257 bool_t
    258 xdr_utf8str_cis(XDR *xdrs, utf8str_cis *objp)
    259 {
    260 
    261 	rpc_inline_t *buf;
    262 
    263 	if (!xdr_utf8string(xdrs, objp))
    264 		return (FALSE);
    265 	return (TRUE);
    266 }
    267 
    268 bool_t
    269 xdr_utf8str_cs(XDR *xdrs, utf8str_cs *objp)
    270 {
    271 
    272 	rpc_inline_t *buf;
    273 
    274 	if (!xdr_utf8string(xdrs, objp))
    275 		return (FALSE);
    276 	return (TRUE);
    277 }
    278 
    279 bool_t
    280 xdr_utf8str_mixed(XDR *xdrs, utf8str_mixed *objp)
    281 {
    282 
    283 	rpc_inline_t *buf;
    284 
    285 	if (!xdr_utf8string(xdrs, objp))
    286 		return (FALSE);
    287 	return (TRUE);
    288 }
    289 
    290 bool_t
    291 xdr_component4(XDR *xdrs, component4 *objp)
    292 {
    293 
    294 	rpc_inline_t *buf;
    295 
    296 	if (!xdr_utf8str_cs(xdrs, objp))
    297 		return (FALSE);
    298 	return (TRUE);
    299 }
    300 
    301 bool_t
    302 xdr_linktext4(XDR *xdrs, linktext4 *objp)
    303 {
    304 
    305 	rpc_inline_t *buf;
    306 
    307 	if (!xdr_utf8str_cs(xdrs, objp))
    308 		return (FALSE);
    309 	return (TRUE);
    310 }
    311 
    312 bool_t
    313 xdr_pathname4(XDR *xdrs, pathname4 *objp)
    314 {
    315 
    316 	rpc_inline_t *buf;
    317 
    318 	if (!xdr_array(xdrs, (char **)&objp->pathname4_val,
    319 	    (uint_t *)&objp->pathname4_len, ~0,
    320 	    sizeof (component4), (xdrproc_t)xdr_component4))
    321 		return (FALSE);
    322 	return (TRUE);
    323 }
    324 
    325 bool_t
    326 xdr_verifier4(XDR *xdrs, verifier4 objp)
    327 {
    328 
    329 	rpc_inline_t *buf;
    330 
    331 	if (!xdr_opaque(xdrs, objp, NFS4_VERIFIER_SIZE))
    332 		return (FALSE);
    333 	return (TRUE);
    334 }
    335 
    336 bool_t
    337 xdr_nfstime4(XDR *xdrs, nfstime4 *objp)
    338 {
    339 
    340 	rpc_inline_t *buf;
    341 
    342 	if (!xdr_int64_t(xdrs, &objp->seconds))
    343 		return (FALSE);
    344 	if (!xdr_uint32_t(xdrs, &objp->nseconds))
    345 		return (FALSE);
    346 	return (TRUE);
    347 }
    348 
    349 bool_t
    350 xdr_time_how4(XDR *xdrs, time_how4 *objp)
    351 {
    352 
    353 	rpc_inline_t *buf;
    354 
    355 	if (!xdr_enum(xdrs, (enum_t *)objp))
    356 		return (FALSE);
    357 	return (TRUE);
    358 }
    359 
    360 bool_t
    361 xdr_settime4(XDR *xdrs, settime4 *objp)
    362 {
    363 
    364 	rpc_inline_t *buf;
    365 
    366 	if (!xdr_time_how4(xdrs, &objp->set_it))
    367 		return (FALSE);
    368 	switch (objp->set_it) {
    369 	case SET_TO_CLIENT_TIME4:
    370 		if (!xdr_nfstime4(xdrs, &objp->settime4_u.time))
    371 			return (FALSE);
    372 		break;
    373 	}
    374 	return (TRUE);
    375 }
    376 
    377 bool_t
    378 xdr_nfs_lease4(XDR *xdrs, nfs_lease4 *objp)
    379 {
    380 
    381 	rpc_inline_t *buf;
    382 
    383 	if (!xdr_uint32_t(xdrs, objp))
    384 		return (FALSE);
    385 	return (TRUE);
    386 }
    387 
    388 bool_t
    389 xdr_fsid4(XDR *xdrs, fsid4 *objp)
    390 {
    391 
    392 	rpc_inline_t *buf;
    393 
    394 	if (!xdr_uint64_t(xdrs, &objp->major))
    395 		return (FALSE);
    396 	if (!xdr_uint64_t(xdrs, &objp->minor))
    397 		return (FALSE);
    398 	return (TRUE);
    399 }
    400 
    401 bool_t
    402 xdr_change_policy4(XDR *xdrs, change_policy4 *objp)
    403 {
    404 
    405 	rpc_inline_t *buf;
    406 
    407 	if (!xdr_uint64_t(xdrs, &objp->cp_major))
    408 		return (FALSE);
    409 	if (!xdr_uint64_t(xdrs, &objp->cp_minor))
    410 		return (FALSE);
    411 	return (TRUE);
    412 }
    413 
    414 bool_t
    415 xdr_fs_location4(XDR *xdrs, fs_location4 *objp)
    416 {
    417 
    418 	rpc_inline_t *buf;
    419 
    420 	if (!xdr_array(xdrs, (char **)&objp->server.server_val,
    421 	    (uint_t *)&objp->server.server_len, ~0,
    422 	    sizeof (utf8str_cis), (xdrproc_t)xdr_utf8str_cis))
    423 		return (FALSE);
    424 	if (!xdr_pathname4(xdrs, &objp->rootpath))
    425 		return (FALSE);
    426 	return (TRUE);
    427 }
    428 
    429 bool_t
    430 xdr_fs_locations4(XDR *xdrs, fs_locations4 *objp)
    431 {
    432 
    433 	rpc_inline_t *buf;
    434 
    435 	if (!xdr_pathname4(xdrs, &objp->fs_root))
    436 		return (FALSE);
    437 	if (!xdr_array(xdrs, (char **)&objp->locations.locations_val,
    438 	    (uint_t *)&objp->locations.locations_len, ~0,
    439 	    sizeof (fs_location4), (xdrproc_t)xdr_fs_location4))
    440 		return (FALSE);
    441 	return (TRUE);
    442 }
    443 
    444 bool_t
    445 xdr_acetype4(XDR *xdrs, acetype4 *objp)
    446 {
    447 
    448 	rpc_inline_t *buf;
    449 
    450 	if (!xdr_uint32_t(xdrs, objp))
    451 		return (FALSE);
    452 	return (TRUE);
    453 }
    454 
    455 bool_t
    456 xdr_aceflag4(XDR *xdrs, aceflag4 *objp)
    457 {
    458 
    459 	rpc_inline_t *buf;
    460 
    461 	if (!xdr_uint32_t(xdrs, objp))
    462 		return (FALSE);
    463 	return (TRUE);
    464 }
    465 
    466 bool_t
    467 xdr_acemask4(XDR *xdrs, acemask4 *objp)
    468 {
    469 
    470 	rpc_inline_t *buf;
    471 
    472 	if (!xdr_uint32_t(xdrs, objp))
    473 		return (FALSE);
    474 	return (TRUE);
    475 }
    476 
    477 bool_t
    478 xdr_nfsace4(XDR *xdrs, nfsace4 *objp)
    479 {
    480 
    481 	rpc_inline_t *buf;
    482 
    483 	if (!xdr_acetype4(xdrs, &objp->type))
    484 		return (FALSE);
    485 	if (!xdr_aceflag4(xdrs, &objp->flag))
    486 		return (FALSE);
    487 	if (!xdr_acemask4(xdrs, &objp->access_mask))
    488 		return (FALSE);
    489 	if (!xdr_utf8str_mixed(xdrs, &objp->who))
    490 		return (FALSE);
    491 	return (TRUE);
    492 }
    493 
    494 bool_t
    495 xdr_aclflag4(XDR *xdrs, aclflag4 *objp)
    496 {
    497 
    498 	rpc_inline_t *buf;
    499 
    500 	if (!xdr_uint32_t(xdrs, objp))
    501 		return (FALSE);
    502 	return (TRUE);
    503 }
    504 
    505 bool_t
    506 xdr_nfsacl41(XDR *xdrs, nfsacl41 *objp)
    507 {
    508 
    509 	rpc_inline_t *buf;
    510 
    511 	if (!xdr_aclflag4(xdrs, &objp->na41_flag))
    512 		return (FALSE);
    513 	if (!xdr_array(xdrs, (char **)&objp->na41_aces.na41_aces_val,
    514 	    (uint_t *)&objp->na41_aces.na41_aces_len, ~0,
    515 	    sizeof (nfsace4), (xdrproc_t)xdr_nfsace4))
    516 		return (FALSE);
    517 	return (TRUE);
    518 }
    519 
    520 bool_t
    521 xdr_mode_masked4(XDR *xdrs, mode_masked4 *objp)
    522 {
    523 
    524 	rpc_inline_t *buf;
    525 
    526 	if (!xdr_mode4(xdrs, &objp->mm_value_to_set))
    527 		return (FALSE);
    528 	if (!xdr_mode4(xdrs, &objp->mm_mask_bits))
    529 		return (FALSE);
    530 	return (TRUE);
    531 }
    532 
    533 bool_t
    534 xdr_specdata4(XDR *xdrs, specdata4 *objp)
    535 {
    536 
    537 	rpc_inline_t *buf;
    538 
    539 	if (!xdr_uint32_t(xdrs, &objp->specdata1))
    540 		return (FALSE);
    541 	if (!xdr_uint32_t(xdrs, &objp->specdata2))
    542 		return (FALSE);
    543 	return (TRUE);
    544 }
    545 
    546 bool_t
    547 xdr_netaddr4(XDR *xdrs, netaddr4 *objp)
    548 {
    549 
    550 	rpc_inline_t *buf;
    551 
    552 	if (!xdr_string(xdrs, &objp->na_r_netid, ~0))
    553 		return (FALSE);
    554 	if (!xdr_string(xdrs, &objp->na_r_addr, ~0))
    555 		return (FALSE);
    556 	return (TRUE);
    557 }
    558 
    559 bool_t
    560 xdr_nfs_impl_id4(XDR *xdrs, nfs_impl_id4 *objp)
    561 {
    562 
    563 	rpc_inline_t *buf;
    564 
    565 	if (!xdr_utf8str_cis(xdrs, &objp->nii_domain))
    566 		return (FALSE);
    567 	if (!xdr_utf8str_cs(xdrs, &objp->nii_name))
    568 		return (FALSE);
    569 	if (!xdr_nfstime4(xdrs, &objp->nii_date))
    570 		return (FALSE);
    571 	return (TRUE);
    572 }
    573 
    574 bool_t
    575 xdr_stateid4(XDR *xdrs, stateid4 *objp)
    576 {
    577 
    578 	rpc_inline_t *buf;
    579 
    580 	if (!xdr_uint32_t(xdrs, &objp->seqid))
    581 		return (FALSE);
    582 	if (!xdr_opaque(xdrs, objp->other, 12))
    583 		return (FALSE);
    584 	return (TRUE);
    585 }
    586 
    587 bool_t
    588 xdr_layouttype4(XDR *xdrs, layouttype4 *objp)
    589 {
    590 
    591 	rpc_inline_t *buf;
    592 
    593 	if (!xdr_enum(xdrs, (enum_t *)objp))
    594 		return (FALSE);
    595 	return (TRUE);
    596 }
    597 
    598 bool_t
    599 xdr_layout_content4(XDR *xdrs, layout_content4 *objp)
    600 {
    601 
    602 	rpc_inline_t *buf;
    603 
    604 	if (!xdr_layouttype4(xdrs, &objp->loc_type))
    605 		return (FALSE);
    606 	if (!xdr_bytes(xdrs, (char **)&objp->loc_body.loc_body_val,
    607 	    (uint_t *)&objp->loc_body.loc_body_len, ~0))
    608 		return (FALSE);
    609 	return (TRUE);
    610 }
    611 /*
    612  * LAYOUT4_OSD2_OBJECTS loc_body description
    613  * is in a separate .x file
    614  */
    615 
    616 /*
    617  * LAYOUT4_BLOCK_VOLUME loc_body description
    618  * is in a separate .x file
    619  */
    620 
    621 bool_t
    622 xdr_layouthint4(XDR *xdrs, layouthint4 *objp)
    623 {
    624 
    625 	rpc_inline_t *buf;
    626 
    627 	if (!xdr_layouttype4(xdrs, &objp->loh_type))
    628 		return (FALSE);
    629 	if (!xdr_bytes(xdrs, (char **)&objp->loh_body.loh_body_val,
    630 	    (uint_t *)&objp->loh_body.loh_body_len, ~0))
    631 		return (FALSE);
    632 	return (TRUE);
    633 }
    634 
    635 bool_t
    636 xdr_layoutiomode4(XDR *xdrs, layoutiomode4 *objp)
    637 {
    638 
    639 	rpc_inline_t *buf;
    640 
    641 	if (!xdr_enum(xdrs, (enum_t *)objp))
    642 		return (FALSE);
    643 	return (TRUE);
    644 }
    645 
    646 bool_t
    647 xdr_layout4(XDR *xdrs, layout4 *objp)
    648 {
    649 
    650 	rpc_inline_t *buf;
    651 
    652 	if (!xdr_offset4(xdrs, &objp->lo_offset))
    653 		return (FALSE);
    654 	if (!xdr_length4(xdrs, &objp->lo_length))
    655 		return (FALSE);
    656 	if (!xdr_layoutiomode4(xdrs, &objp->lo_iomode))
    657 		return (FALSE);
    658 	if (!xdr_layout_content4(xdrs, &objp->lo_content))
    659 		return (FALSE);
    660 	return (TRUE);
    661 }
    662 
    663 bool_t
    664 xdr_deviceid4(XDR *xdrs, deviceid4 objp)
    665 {
    666 
    667 	rpc_inline_t *buf;
    668 
    669 	if (!xdr_opaque(xdrs, objp, NFS4_DEVICEID4_SIZE))
    670 		return (FALSE);
    671 	return (TRUE);
    672 }
    673 
    674 bool_t
    675 xdr_device_addr4(XDR *xdrs, device_addr4 *objp)
    676 {
    677 
    678 	rpc_inline_t *buf;
    679 
    680 	if (!xdr_layouttype4(xdrs, &objp->da_layout_type))
    681 		return (FALSE);
    682 	if (!xdr_bytes(xdrs, (char **)&objp->da_addr_body.da_addr_body_val,
    683 	    (uint_t *)&objp->da_addr_body.da_addr_body_len, ~0))
    684 		return (FALSE);
    685 	return (TRUE);
    686 }
    687 
    688 bool_t
    689 xdr_layoutupdate4(XDR *xdrs, layoutupdate4 *objp)
    690 {
    691 
    692 	rpc_inline_t *buf;
    693 
    694 	if (!xdr_layouttype4(xdrs, &objp->lou_type))
    695 		return (FALSE);
    696 	if (!xdr_bytes(xdrs, (char **)&objp->lou_body.lou_body_val,
    697 	    (uint_t *)&objp->lou_body.lou_body_len, ~0))
    698 		return (FALSE);
    699 	return (TRUE);
    700 }
    701 
    702 
    703 
    704 bool_t
    705 xdr_layoutreturn_type4(XDR *xdrs, layoutreturn_type4 *objp)
    706 {
    707 
    708 	rpc_inline_t *buf;
    709 
    710 	if (!xdr_enum(xdrs, (enum_t *)objp))
    711 		return (FALSE);
    712 	return (TRUE);
    713 }
    714 /* layouttype4 specific data */
    715 
    716 bool_t
    717 xdr_layoutreturn_file4(XDR *xdrs, layoutreturn_file4 *objp)
    718 {
    719 
    720 	rpc_inline_t *buf;
    721 
    722 	if (!xdr_offset4(xdrs, &objp->lrf_offset))
    723 		return (FALSE);
    724 	if (!xdr_length4(xdrs, &objp->lrf_length))
    725 		return (FALSE);
    726 	if (!xdr_stateid4(xdrs, &objp->lrf_stateid))
    727 		return (FALSE);
    728 	if (!xdr_bytes(xdrs, (char **)&objp->lrf_body.lrf_body_val,
    729 	    (uint_t *)&objp->lrf_body.lrf_body_len, ~0))
    730 		return (FALSE);
    731 	return (TRUE);
    732 }
    733 
    734 bool_t
    735 xdr_layoutreturn4(XDR *xdrs, layoutreturn4 *objp)
    736 {
    737 
    738 	rpc_inline_t *buf;
    739 
    740 	if (!xdr_layoutreturn_type4(xdrs, &objp->lr_returntype))
    741 		return (FALSE);
    742 	switch (objp->lr_returntype) {
    743 	case LAYOUTRETURN4_FILE:
    744 		if (!xdr_layoutreturn_file4(xdrs,
    745 		    &objp->layoutreturn4_u.lr_layout))
    746 			return (FALSE);
    747 		break;
    748 	}
    749 	return (TRUE);
    750 }
    751 
    752 
    753 bool_t
    754 xdr_fs4_status_type(XDR *xdrs, fs4_status_type *objp)
    755 {
    756 
    757 	rpc_inline_t *buf;
    758 
    759 	if (!xdr_enum(xdrs, (enum_t *)objp))
    760 		return (FALSE);
    761 	return (TRUE);
    762 }
    763 
    764 bool_t
    765 xdr_fs4_status(XDR *xdrs, fs4_status *objp)
    766 {
    767 
    768 	rpc_inline_t *buf;
    769 
    770 	if (!xdr_bool(xdrs, &objp->fss_absent))
    771 		return (FALSE);
    772 	if (!xdr_fs4_status_type(xdrs, &objp->fss_type))
    773 		return (FALSE);
    774 	if (!xdr_utf8str_cs(xdrs, &objp->fss_source))
    775 		return (FALSE);
    776 	if (!xdr_utf8str_cs(xdrs, &objp->fss_current))
    777 		return (FALSE);
    778 	if (!xdr_int32_t(xdrs, &objp->fss_age))
    779 		return (FALSE);
    780 	if (!xdr_nfstime4(xdrs, &objp->fss_version))
    781 		return (FALSE);
    782 	return (TRUE);
    783 }
    784 
    785 bool_t
    786 xdr_threshold4_read_size(XDR *xdrs, threshold4_read_size *objp)
    787 {
    788 
    789 	rpc_inline_t *buf;
    790 
    791 	if (!xdr_length4(xdrs, objp))
    792 		return (FALSE);
    793 	return (TRUE);
    794 }
    795 
    796 bool_t
    797 xdr_threshold4_write_size(XDR *xdrs, threshold4_write_size *objp)
    798 {
    799 
    800 	rpc_inline_t *buf;
    801 
    802 	if (!xdr_length4(xdrs, objp))
    803 		return (FALSE);
    804 	return (TRUE);
    805 }
    806 
    807 bool_t
    808 xdr_threshold4_read_iosize(XDR *xdrs, threshold4_read_iosize *objp)
    809 {
    810 
    811 	rpc_inline_t *buf;
    812 
    813 	if (!xdr_length4(xdrs, objp))
    814 		return (FALSE);
    815 	return (TRUE);
    816 }
    817 
    818 bool_t
    819 xdr_threshold4_write_iosize(XDR *xdrs, threshold4_write_iosize *objp)
    820 {
    821 
    822 	rpc_inline_t *buf;
    823 
    824 	if (!xdr_length4(xdrs, objp))
    825 		return (FALSE);
    826 	return (TRUE);
    827 }
    828 
    829 bool_t
    830 xdr_threshold_item4(XDR *xdrs, threshold_item4 *objp)
    831 {
    832 
    833 	rpc_inline_t *buf;
    834 
    835 	if (!xdr_layouttype4(xdrs, &objp->thi_layout_type))
    836 		return (FALSE);
    837 	if (!xdr_bitmap4(xdrs, &objp->thi_hintset))
    838 		return (FALSE);
    839 	if (!xdr_bytes(xdrs, (char **)&objp->thi_hintlist.thi_hintlist_val,
    840 	    (uint_t *)&objp->thi_hintlist.thi_hintlist_len, ~0))
    841 		return (FALSE);
    842 	return (TRUE);
    843 }
    844 
    845 bool_t
    846 xdr_mdsthreshold4(XDR *xdrs, mdsthreshold4 *objp)
    847 {
    848 
    849 	rpc_inline_t *buf;
    850 
    851 	if (!xdr_array(xdrs, (char **)&objp->mth_hints.mth_hints_val,
    852 	    (uint_t *)&objp->mth_hints.mth_hints_len, ~0,
    853 	    sizeof (threshold_item4), (xdrproc_t)xdr_threshold_item4))
    854 		return (FALSE);
    855 	return (TRUE);
    856 }
    857 
    858 bool_t
    859 xdr_retention_get4(XDR *xdrs, retention_get4 *objp)
    860 {
    861 
    862 	rpc_inline_t *buf;
    863 
    864 	if (!xdr_uint64_t(xdrs, &objp->rg_duration))
    865 		return (FALSE);
    866 	if (!xdr_array(xdrs, (char **)&objp->rg_begin_time.rg_begin_time_val,
    867 	    (uint_t *)&objp->rg_begin_time.rg_begin_time_len, 1,
    868 	    sizeof (nfstime4), (xdrproc_t)xdr_nfstime4))
    869 		return (FALSE);
    870 	return (TRUE);
    871 }
    872 
    873 bool_t
    874 xdr_retention_set4(XDR *xdrs, retention_set4 *objp)
    875 {
    876 
    877 	rpc_inline_t *buf;
    878 
    879 	if (!xdr_bool(xdrs, &objp->rs_enable))
    880 		return (FALSE);
    881 	if (!xdr_array(xdrs, (char **)&objp->rs_duration.rs_duration_val,
    882 	    (uint_t *)&objp->rs_duration.rs_duration_len, 1,
    883 	    sizeof (uint64_t), (xdrproc_t)xdr_uint64_t))
    884 		return (FALSE);
    885 	return (TRUE);
    886 }
    887 
    888 bool_t
    889 xdr_fs_charset_cap4(XDR *xdrs, fs_charset_cap4 *objp)
    890 {
    891 
    892 	rpc_inline_t *buf;
    893 
    894 	if (!xdr_uint32_t(xdrs, objp))
    895 		return (FALSE);
    896 	return (TRUE);
    897 }
    898 
    899 bool_t
    900 xdr_fattr4_supported_attrs(XDR *xdrs, fattr4_supported_attrs *objp)
    901 {
    902 
    903 	rpc_inline_t *buf;
    904 
    905 	if (!xdr_bitmap4(xdrs, objp))
    906 		return (FALSE);
    907 	return (TRUE);
    908 }
    909 
    910 bool_t
    911 xdr_fattr4_suppattr_exclcreat(XDR *xdrs, fattr4_suppattr_exclcreat *objp)
    912 {
    913 
    914 	rpc_inline_t *buf;
    915 
    916 	if (!xdr_bitmap4(xdrs, objp))
    917 		return (FALSE);
    918 	return (TRUE);
    919 }
    920 
    921 bool_t
    922 xdr_fattr4_type(XDR *xdrs, fattr4_type *objp)
    923 {
    924 
    925 	rpc_inline_t *buf;
    926 
    927 	if (!xdr_nfs_ftype4(xdrs, objp))
    928 		return (FALSE);
    929 	return (TRUE);
    930 }
    931 
    932 bool_t
    933 xdr_fattr4_fh_expire_type(XDR *xdrs, fattr4_fh_expire_type *objp)
    934 {
    935 
    936 	rpc_inline_t *buf;
    937 
    938 	if (!xdr_uint32_t(xdrs, objp))
    939 		return (FALSE);
    940 	return (TRUE);
    941 }
    942 
    943 bool_t
    944 xdr_fattr4_change(XDR *xdrs, fattr4_change *objp)
    945 {
    946 
    947 	rpc_inline_t *buf;
    948 
    949 	if (!xdr_changeid4(xdrs, objp))
    950 		return (FALSE);
    951 	return (TRUE);
    952 }
    953 
    954 bool_t
    955 xdr_fattr4_size(XDR *xdrs, fattr4_size *objp)
    956 {
    957 
    958 	rpc_inline_t *buf;
    959 
    960 	if (!xdr_uint64_t(xdrs, objp))
    961 		return (FALSE);
    962 	return (TRUE);
    963 }
    964 
    965 bool_t
    966 xdr_fattr4_link_support(XDR *xdrs, fattr4_link_support *objp)
    967 {
    968 
    969 	rpc_inline_t *buf;
    970 
    971 	if (!xdr_bool(xdrs, objp))
    972 		return (FALSE);
    973 	return (TRUE);
    974 }
    975 
    976 bool_t
    977 xdr_fattr4_symlink_support(XDR *xdrs, fattr4_symlink_support *objp)
    978 {
    979 
    980 	rpc_inline_t *buf;
    981 
    982 	if (!xdr_bool(xdrs, objp))
    983 		return (FALSE);
    984 	return (TRUE);
    985 }
    986 
    987 bool_t
    988 xdr_fattr4_named_attr(XDR *xdrs, fattr4_named_attr *objp)
    989 {
    990 
    991 	rpc_inline_t *buf;
    992 
    993 	if (!xdr_bool(xdrs, objp))
    994 		return (FALSE);
    995 	return (TRUE);
    996 }
    997 
    998 bool_t
    999 xdr_fattr4_fsid(XDR *xdrs, fattr4_fsid *objp)
   1000 {
   1001 
   1002 	rpc_inline_t *buf;
   1003 
   1004 	if (!xdr_fsid4(xdrs, objp))
   1005 		return (FALSE);
   1006 	return (TRUE);
   1007 }
   1008 
   1009 bool_t
   1010 xdr_fattr4_unique_handles(XDR *xdrs, fattr4_unique_handles *objp)
   1011 {
   1012 
   1013 	rpc_inline_t *buf;
   1014 
   1015 	if (!xdr_bool(xdrs, objp))
   1016 		return (FALSE);
   1017 	return (TRUE);
   1018 }
   1019 
   1020 bool_t
   1021 xdr_fattr4_lease_time(XDR *xdrs, fattr4_lease_time *objp)
   1022 {
   1023 
   1024 	rpc_inline_t *buf;
   1025 
   1026 	if (!xdr_nfs_lease4(xdrs, objp))
   1027 		return (FALSE);
   1028 	return (TRUE);
   1029 }
   1030 
   1031 bool_t
   1032 xdr_fattr4_rdattr_error(XDR *xdrs, fattr4_rdattr_error *objp)
   1033 {
   1034 
   1035 	rpc_inline_t *buf;
   1036 
   1037 	if (!xdr_nfsstat4(xdrs, objp))
   1038 		return (FALSE);
   1039 	return (TRUE);
   1040 }
   1041 
   1042 bool_t
   1043 xdr_fattr4_acl(XDR *xdrs, fattr4_acl *objp)
   1044 {
   1045 
   1046 	rpc_inline_t *buf;
   1047 
   1048 	if (!xdr_array(xdrs, (char **)&objp->fattr4_acl_val,
   1049 	    (uint_t *)&objp->fattr4_acl_len, ~0,
   1050 	    sizeof (nfsace4), (xdrproc_t)xdr_nfsace4))
   1051 		return (FALSE);
   1052 	return (TRUE);
   1053 }
   1054 
   1055 bool_t
   1056 xdr_fattr4_aclsupport(XDR *xdrs, fattr4_aclsupport *objp)
   1057 {
   1058 
   1059 	rpc_inline_t *buf;
   1060 
   1061 	if (!xdr_uint32_t(xdrs, objp))
   1062 		return (FALSE);
   1063 	return (TRUE);
   1064 }
   1065 
   1066 bool_t
   1067 xdr_fattr4_archive(XDR *xdrs, fattr4_archive *objp)
   1068 {
   1069 
   1070 	rpc_inline_t *buf;
   1071 
   1072 	if (!xdr_bool(xdrs, objp))
   1073 		return (FALSE);
   1074 	return (TRUE);
   1075 }
   1076 
   1077 bool_t
   1078 xdr_fattr4_cansettime(XDR *xdrs, fattr4_cansettime *objp)
   1079 {
   1080 
   1081 	rpc_inline_t *buf;
   1082 
   1083 	if (!xdr_bool(xdrs, objp))
   1084 		return (FALSE);
   1085 	return (TRUE);
   1086 }
   1087 
   1088 bool_t
   1089 xdr_fattr4_case_insensitive(XDR *xdrs, fattr4_case_insensitive *objp)
   1090 {
   1091 
   1092 	rpc_inline_t *buf;
   1093 
   1094 	if (!xdr_bool(xdrs, objp))
   1095 		return (FALSE);
   1096 	return (TRUE);
   1097 }
   1098 
   1099 bool_t
   1100 xdr_fattr4_case_preserving(XDR *xdrs, fattr4_case_preserving *objp)
   1101 {
   1102 
   1103 	rpc_inline_t *buf;
   1104 
   1105 	if (!xdr_bool(xdrs, objp))
   1106 		return (FALSE);
   1107 	return (TRUE);
   1108 }
   1109 
   1110 bool_t
   1111 xdr_fattr4_chown_restricted(XDR *xdrs, fattr4_chown_restricted *objp)
   1112 {
   1113 
   1114 	rpc_inline_t *buf;
   1115 
   1116 	if (!xdr_bool(xdrs, objp))
   1117 		return (FALSE);
   1118 	return (TRUE);
   1119 }
   1120 
   1121 bool_t
   1122 xdr_fattr4_fileid(XDR *xdrs, fattr4_fileid *objp)
   1123 {
   1124 
   1125 	rpc_inline_t *buf;
   1126 
   1127 	if (!xdr_uint64_t(xdrs, objp))
   1128 		return (FALSE);
   1129 	return (TRUE);
   1130 }
   1131 
   1132 bool_t
   1133 xdr_fattr4_files_avail(XDR *xdrs, fattr4_files_avail *objp)
   1134 {
   1135 
   1136 	rpc_inline_t *buf;
   1137 
   1138 	if (!xdr_uint64_t(xdrs, objp))
   1139 		return (FALSE);
   1140 	return (TRUE);
   1141 }
   1142 
   1143 bool_t
   1144 xdr_fattr4_filehandle(XDR *xdrs, fattr4_filehandle *objp)
   1145 {
   1146 
   1147 	rpc_inline_t *buf;
   1148 
   1149 	if (!xdr_nfs_fh4(xdrs, objp))
   1150 		return (FALSE);
   1151 	return (TRUE);
   1152 }
   1153 
   1154 bool_t
   1155 xdr_fattr4_files_free(XDR *xdrs, fattr4_files_free *objp)
   1156 {
   1157 
   1158 	rpc_inline_t *buf;
   1159 
   1160 	if (!xdr_uint64_t(xdrs, objp))
   1161 		return (FALSE);
   1162 	return (TRUE);
   1163 }
   1164 
   1165 bool_t
   1166 xdr_fattr4_files_total(XDR *xdrs, fattr4_files_total *objp)
   1167 {
   1168 
   1169 	rpc_inline_t *buf;
   1170 
   1171 	if (!xdr_uint64_t(xdrs, objp))
   1172 		return (FALSE);
   1173 	return (TRUE);
   1174 }
   1175 
   1176 bool_t
   1177 xdr_fattr4_fs_locations(XDR *xdrs, fattr4_fs_locations *objp)
   1178 {
   1179 
   1180 	rpc_inline_t *buf;
   1181 
   1182 	if (!xdr_fs_locations4(xdrs, objp))
   1183 		return (FALSE);
   1184 	return (TRUE);
   1185 }
   1186 
   1187 bool_t
   1188 xdr_fattr4_hidden(XDR *xdrs, fattr4_hidden *objp)
   1189 {
   1190 
   1191 	rpc_inline_t *buf;
   1192 
   1193 	if (!xdr_bool(xdrs, objp))
   1194 		return (FALSE);
   1195 	return (TRUE);
   1196 }
   1197 
   1198 bool_t
   1199 xdr_fattr4_homogeneous(XDR *xdrs, fattr4_homogeneous *objp)
   1200 {
   1201 
   1202 	rpc_inline_t *buf;
   1203 
   1204 	if (!xdr_bool(xdrs, objp))
   1205 		return (FALSE);
   1206 	return (TRUE);
   1207 }
   1208 
   1209 bool_t
   1210 xdr_fattr4_maxfilesize(XDR *xdrs, fattr4_maxfilesize *objp)
   1211 {
   1212 
   1213 	rpc_inline_t *buf;
   1214 
   1215 	if (!xdr_uint64_t(xdrs, objp))
   1216 		return (FALSE);
   1217 	return (TRUE);
   1218 }
   1219 
   1220 bool_t
   1221 xdr_fattr4_maxlink(XDR *xdrs, fattr4_maxlink *objp)
   1222 {
   1223 
   1224 	rpc_inline_t *buf;
   1225 
   1226 	if (!xdr_uint32_t(xdrs, objp))
   1227 		return (FALSE);
   1228 	return (TRUE);
   1229 }
   1230 
   1231 bool_t
   1232 xdr_fattr4_maxname(XDR *xdrs, fattr4_maxname *objp)
   1233 {
   1234 
   1235 	rpc_inline_t *buf;
   1236 
   1237 	if (!xdr_uint32_t(xdrs, objp))
   1238 		return (FALSE);
   1239 	return (TRUE);
   1240 }
   1241 
   1242 bool_t
   1243 xdr_fattr4_maxread(XDR *xdrs, fattr4_maxread *objp)
   1244 {
   1245 
   1246 	rpc_inline_t *buf;
   1247 
   1248 	if (!xdr_uint64_t(xdrs, objp))
   1249 		return (FALSE);
   1250 	return (TRUE);
   1251 }
   1252 
   1253 bool_t
   1254 xdr_fattr4_maxwrite(XDR *xdrs, fattr4_maxwrite *objp)
   1255 {
   1256 
   1257 	rpc_inline_t *buf;
   1258 
   1259 	if (!xdr_uint64_t(xdrs, objp))
   1260 		return (FALSE);
   1261 	return (TRUE);
   1262 }
   1263 
   1264 bool_t
   1265 xdr_fattr4_mimetype(XDR *xdrs, fattr4_mimetype *objp)
   1266 {
   1267 
   1268 	rpc_inline_t *buf;
   1269 
   1270 	if (!xdr_utf8str_cs(xdrs, objp))
   1271 		return (FALSE);
   1272 	return (TRUE);
   1273 }
   1274 
   1275 bool_t
   1276 xdr_fattr4_mode(XDR *xdrs, fattr4_mode *objp)
   1277 {
   1278 
   1279 	rpc_inline_t *buf;
   1280 
   1281 	if (!xdr_mode4(xdrs, objp))
   1282 		return (FALSE);
   1283 	return (TRUE);
   1284 }
   1285 
   1286 bool_t
   1287 xdr_fattr4_mode_set_masked(XDR *xdrs, fattr4_mode_set_masked *objp)
   1288 {
   1289 
   1290 	rpc_inline_t *buf;
   1291 
   1292 	if (!xdr_mode_masked4(xdrs, objp))
   1293 		return (FALSE);
   1294 	return (TRUE);
   1295 }
   1296 
   1297 bool_t
   1298 xdr_fattr4_mounted_on_fileid(XDR *xdrs, fattr4_mounted_on_fileid *objp)
   1299 {
   1300 
   1301 	rpc_inline_t *buf;
   1302 
   1303 	if (!xdr_uint64_t(xdrs, objp))
   1304 		return (FALSE);
   1305 	return (TRUE);
   1306 }
   1307 
   1308 bool_t
   1309 xdr_fattr4_no_trunc(XDR *xdrs, fattr4_no_trunc *objp)
   1310 {
   1311 
   1312 	rpc_inline_t *buf;
   1313 
   1314 	if (!xdr_bool(xdrs, objp))
   1315 		return (FALSE);
   1316 	return (TRUE);
   1317 }
   1318 
   1319 bool_t
   1320 xdr_fattr4_numlinks(XDR *xdrs, fattr4_numlinks *objp)
   1321 {
   1322 
   1323 	rpc_inline_t *buf;
   1324 
   1325 	if (!xdr_uint32_t(xdrs, objp))
   1326 		return (FALSE);
   1327 	return (TRUE);
   1328 }
   1329 
   1330 bool_t
   1331 xdr_fattr4_owner(XDR *xdrs, fattr4_owner *objp)
   1332 {
   1333 
   1334 	rpc_inline_t *buf;
   1335 
   1336 	if (!xdr_utf8str_mixed(xdrs, objp))
   1337 		return (FALSE);
   1338 	return (TRUE);
   1339 }
   1340 
   1341 bool_t
   1342 xdr_fattr4_owner_group(XDR *xdrs, fattr4_owner_group *objp)
   1343 {
   1344 
   1345 	rpc_inline_t *buf;
   1346 
   1347 	if (!xdr_utf8str_mixed(xdrs, objp))
   1348 		return (FALSE);
   1349 	return (TRUE);
   1350 }
   1351 
   1352 bool_t
   1353 xdr_fattr4_quota_avail_hard(XDR *xdrs, fattr4_quota_avail_hard *objp)
   1354 {
   1355 
   1356 	rpc_inline_t *buf;
   1357 
   1358 	if (!xdr_uint64_t(xdrs, objp))
   1359 		return (FALSE);
   1360 	return (TRUE);
   1361 }
   1362 
   1363 bool_t
   1364 xdr_fattr4_quota_avail_soft(XDR *xdrs, fattr4_quota_avail_soft *objp)
   1365 {
   1366 
   1367 	rpc_inline_t *buf;
   1368 
   1369 	if (!xdr_uint64_t(xdrs, objp))
   1370 		return (FALSE);
   1371 	return (TRUE);
   1372 }
   1373 
   1374 bool_t
   1375 xdr_fattr4_quota_used(XDR *xdrs, fattr4_quota_used *objp)
   1376 {
   1377 
   1378 	rpc_inline_t *buf;
   1379 
   1380 	if (!xdr_uint64_t(xdrs, objp))
   1381 		return (FALSE);
   1382 	return (TRUE);
   1383 }
   1384 
   1385 bool_t
   1386 xdr_fattr4_rawdev(XDR *xdrs, fattr4_rawdev *objp)
   1387 {
   1388 
   1389 	rpc_inline_t *buf;
   1390 
   1391 	if (!xdr_specdata4(xdrs, objp))
   1392 		return (FALSE);
   1393 	return (TRUE);
   1394 }
   1395 
   1396 bool_t
   1397 xdr_fattr4_space_avail(XDR *xdrs, fattr4_space_avail *objp)
   1398 {
   1399 
   1400 	rpc_inline_t *buf;
   1401 
   1402 	if (!xdr_uint64_t(xdrs, objp))
   1403 		return (FALSE);
   1404 	return (TRUE);
   1405 }
   1406 
   1407 bool_t
   1408 xdr_fattr4_space_free(XDR *xdrs, fattr4_space_free *objp)
   1409 {
   1410 
   1411 	rpc_inline_t *buf;
   1412 
   1413 	if (!xdr_uint64_t(xdrs, objp))
   1414 		return (FALSE);
   1415 	return (TRUE);
   1416 }
   1417 
   1418 bool_t
   1419 xdr_fattr4_space_total(XDR *xdrs, fattr4_space_total *objp)
   1420 {
   1421 
   1422 	rpc_inline_t *buf;
   1423 
   1424 	if (!xdr_uint64_t(xdrs, objp))
   1425 		return (FALSE);
   1426 	return (TRUE);
   1427 }
   1428 
   1429 bool_t
   1430 xdr_fattr4_space_used(XDR *xdrs, fattr4_space_used *objp)
   1431 {
   1432 
   1433 	rpc_inline_t *buf;
   1434 
   1435 	if (!xdr_uint64_t(xdrs, objp))
   1436 		return (FALSE);
   1437 	return (TRUE);
   1438 }
   1439 
   1440 bool_t
   1441 xdr_fattr4_system(XDR *xdrs, fattr4_system *objp)
   1442 {
   1443 
   1444 	rpc_inline_t *buf;
   1445 
   1446 	if (!xdr_bool(xdrs, objp))
   1447 		return (FALSE);
   1448 	return (TRUE);
   1449 }
   1450 
   1451 bool_t
   1452 xdr_fattr4_time_access(XDR *xdrs, fattr4_time_access *objp)
   1453 {
   1454 
   1455 	rpc_inline_t *buf;
   1456 
   1457 	if (!xdr_nfstime4(xdrs, objp))
   1458 		return (FALSE);
   1459 	return (TRUE);
   1460 }
   1461 
   1462 bool_t
   1463 xdr_fattr4_time_access_set(XDR *xdrs, fattr4_time_access_set *objp)
   1464 {
   1465 
   1466 	rpc_inline_t *buf;
   1467 
   1468 	if (!xdr_settime4(xdrs, objp))
   1469 		return (FALSE);
   1470 	return (TRUE);
   1471 }
   1472 
   1473 bool_t
   1474 xdr_fattr4_time_backup(XDR *xdrs, fattr4_time_backup *objp)
   1475 {
   1476 
   1477 	rpc_inline_t *buf;
   1478 
   1479 	if (!xdr_nfstime4(xdrs, objp))
   1480 		return (FALSE);
   1481 	return (TRUE);
   1482 }
   1483 
   1484 bool_t
   1485 xdr_fattr4_time_create(XDR *xdrs, fattr4_time_create *objp)
   1486 {
   1487 
   1488 	rpc_inline_t *buf;
   1489 
   1490 	if (!xdr_nfstime4(xdrs, objp))
   1491 		return (FALSE);
   1492 	return (TRUE);
   1493 }
   1494 
   1495 bool_t
   1496 xdr_fattr4_time_delta(XDR *xdrs, fattr4_time_delta *objp)
   1497 {
   1498 
   1499 	rpc_inline_t *buf;
   1500 
   1501 	if (!xdr_nfstime4(xdrs, objp))
   1502 		return (FALSE);
   1503 	return (TRUE);
   1504 }
   1505 
   1506 bool_t
   1507 xdr_fattr4_time_metadata(XDR *xdrs, fattr4_time_metadata *objp)
   1508 {
   1509 
   1510 	rpc_inline_t *buf;
   1511 
   1512 	if (!xdr_nfstime4(xdrs, objp))
   1513 		return (FALSE);
   1514 	return (TRUE);
   1515 }
   1516 
   1517 bool_t
   1518 xdr_fattr4_time_modify(XDR *xdrs, fattr4_time_modify *objp)
   1519 {
   1520 
   1521 	rpc_inline_t *buf;
   1522 
   1523 	if (!xdr_nfstime4(xdrs, objp))
   1524 		return (FALSE);
   1525 	return (TRUE);
   1526 }
   1527 
   1528 bool_t
   1529 xdr_fattr4_time_modify_set(XDR *xdrs, fattr4_time_modify_set *objp)
   1530 {
   1531 
   1532 	rpc_inline_t *buf;
   1533 
   1534 	if (!xdr_settime4(xdrs, objp))
   1535 		return (FALSE);
   1536 	return (TRUE);
   1537 }
   1538 
   1539 bool_t
   1540 xdr_fattr4_dir_notif_delay(XDR *xdrs, fattr4_dir_notif_delay *objp)
   1541 {
   1542 
   1543 	rpc_inline_t *buf;
   1544 
   1545 	if (!xdr_nfstime4(xdrs, objp))
   1546 		return (FALSE);
   1547 	return (TRUE);
   1548 }
   1549 
   1550 bool_t
   1551 xdr_fattr4_dirent_notif_delay(XDR *xdrs, fattr4_dirent_notif_delay *objp)
   1552 {
   1553 
   1554 	rpc_inline_t *buf;
   1555 
   1556 	if (!xdr_nfstime4(xdrs, objp))
   1557 		return (FALSE);
   1558 	return (TRUE);
   1559 }
   1560 
   1561 bool_t
   1562 xdr_fattr4_absent(XDR *xdrs, fattr4_absent *objp)
   1563 {
   1564 
   1565 	rpc_inline_t *buf;
   1566 
   1567 	if (!xdr_bool(xdrs, objp))
   1568 		return (FALSE);
   1569 	return (TRUE);
   1570 }
   1571 
   1572 bool_t
   1573 xdr_fattr4_fs_layout_types(XDR *xdrs, fattr4_fs_layout_types *objp)
   1574 {
   1575 
   1576 	rpc_inline_t *buf;
   1577 
   1578 	if (!xdr_array(xdrs, (char **)&objp->fattr4_fs_layout_types_val,
   1579 	    (uint_t *)&objp->fattr4_fs_layout_types_len, ~0,
   1580 	    sizeof (layouttype4), (xdrproc_t)xdr_layouttype4))
   1581 		return (FALSE);
   1582 	return (TRUE);
   1583 }
   1584 
   1585 bool_t
   1586 xdr_fattr4_fs_status(XDR *xdrs, fattr4_fs_status *objp)
   1587 {
   1588 
   1589 	rpc_inline_t *buf;
   1590 
   1591 	if (!xdr_fs4_status(xdrs, objp))
   1592 		return (FALSE);
   1593 	return (TRUE);
   1594 }
   1595 
   1596 bool_t
   1597 xdr_fattr4_fs_charset_cap4(XDR *xdrs, fattr4_fs_charset_cap4 *objp)
   1598 {
   1599 
   1600 	rpc_inline_t *buf;
   1601 
   1602 	if (!xdr_fs_charset_cap4(xdrs, objp))
   1603 		return (FALSE);
   1604 	return (TRUE);
   1605 }
   1606 
   1607 bool_t
   1608 xdr_fattr4_layout_alignment(XDR *xdrs, fattr4_layout_alignment *objp)
   1609 {
   1610 
   1611 	rpc_inline_t *buf;
   1612 
   1613 	if (!xdr_uint32_t(xdrs, objp))
   1614 		return (FALSE);
   1615 	return (TRUE);
   1616 }
   1617 
   1618 bool_t
   1619 xdr_fattr4_layout_blksize(XDR *xdrs, fattr4_layout_blksize *objp)
   1620 {
   1621 
   1622 	rpc_inline_t *buf;
   1623 
   1624 	if (!xdr_uint32_t(xdrs, objp))
   1625 		return (FALSE);
   1626 	return (TRUE);
   1627 }
   1628 
   1629 bool_t
   1630 xdr_fattr4_layout_hint(XDR *xdrs, fattr4_layout_hint *objp)
   1631 {
   1632 
   1633 	rpc_inline_t *buf;
   1634 
   1635 	if (!xdr_layouthint4(xdrs, objp))
   1636 		return (FALSE);
   1637 	return (TRUE);
   1638 }
   1639 
   1640 bool_t
   1641 xdr_fattr4_layout_types(XDR *xdrs, fattr4_layout_types *objp)
   1642 {
   1643 
   1644 	rpc_inline_t *buf;
   1645 
   1646 	if (!xdr_array(xdrs, (char **)&objp->fattr4_layout_types_val,
   1647 	    (uint_t *)&objp->fattr4_layout_types_len, ~0,
   1648 	    sizeof (layouttype4), (xdrproc_t)xdr_layouttype4))
   1649 		return (FALSE);
   1650 	return (TRUE);
   1651 }
   1652 
   1653 bool_t
   1654 xdr_fattr4_mdsthreshold(XDR *xdrs, fattr4_mdsthreshold *objp)
   1655 {
   1656 
   1657 	rpc_inline_t *buf;
   1658 
   1659 	if (!xdr_mdsthreshold4(xdrs, objp))
   1660 		return (FALSE);
   1661 	return (TRUE);
   1662 }
   1663 
   1664 bool_t
   1665 xdr_fattr4_retention_get(XDR *xdrs, fattr4_retention_get *objp)
   1666 {
   1667 
   1668 	rpc_inline_t *buf;
   1669 
   1670 	if (!xdr_retention_get4(xdrs, objp))
   1671 		return (FALSE);
   1672 	return (TRUE);
   1673 }
   1674 
   1675 bool_t
   1676 xdr_fattr4_retention_set(XDR *xdrs, fattr4_retention_set *objp)
   1677 {
   1678 
   1679 	rpc_inline_t *buf;
   1680 
   1681 	if (!xdr_retention_set4(xdrs, objp))
   1682 		return (FALSE);
   1683 	return (TRUE);
   1684 }
   1685 
   1686 bool_t
   1687 xdr_fattr4_retentevt_get(XDR *xdrs, fattr4_retentevt_get *objp)
   1688 {
   1689 
   1690 	rpc_inline_t *buf;
   1691 
   1692 	if (!xdr_retention_get4(xdrs, objp))
   1693 		return (FALSE);
   1694 	return (TRUE);
   1695 }
   1696 
   1697 bool_t
   1698 xdr_fattr4_retentevt_set(XDR *xdrs, fattr4_retentevt_set *objp)
   1699 {
   1700 
   1701 	rpc_inline_t *buf;
   1702 
   1703 	if (!xdr_retention_set4(xdrs, objp))
   1704 		return (FALSE);
   1705 	return (TRUE);
   1706 }
   1707 
   1708 bool_t
   1709 xdr_fattr4_retention_hold(XDR *xdrs, fattr4_retention_hold *objp)
   1710 {
   1711 
   1712 	rpc_inline_t *buf;
   1713 
   1714 	if (!xdr_uint64_t(xdrs, objp))
   1715 		return (FALSE);
   1716 	return (TRUE);
   1717 }
   1718 
   1719 bool_t
   1720 xdr_fattr4_dacl(XDR *xdrs, fattr4_dacl *objp)
   1721 {
   1722 
   1723 	rpc_inline_t *buf;
   1724 
   1725 	if (!xdr_nfsacl41(xdrs, objp))
   1726 		return (FALSE);
   1727 	return (TRUE);
   1728 }
   1729 
   1730 bool_t
   1731 xdr_fattr4_sacl(XDR *xdrs, fattr4_sacl *objp)
   1732 {
   1733 
   1734 	rpc_inline_t *buf;
   1735 
   1736 	if (!xdr_nfsacl41(xdrs, objp))
   1737 		return (FALSE);
   1738 	return (TRUE);
   1739 }
   1740 
   1741 bool_t
   1742 xdr_fattr4(XDR *xdrs, fattr4 *objp)
   1743 {
   1744 
   1745 	rpc_inline_t *buf;
   1746 
   1747 	if (!xdr_bitmap4(xdrs, &objp->attrmask))
   1748 		return (FALSE);
   1749 	if (!xdr_attrlist4(xdrs, &objp->attr_vals))
   1750 		return (FALSE);
   1751 	return (TRUE);
   1752 }
   1753 
   1754 bool_t
   1755 xdr_change_info4(XDR *xdrs, change_info4 *objp)
   1756 {
   1757 
   1758 	rpc_inline_t *buf;
   1759 
   1760 	if (!xdr_bool(xdrs, &objp->atomic))
   1761 		return (FALSE);
   1762 	if (!xdr_changeid4(xdrs, &objp->before))
   1763 		return (FALSE);
   1764 	if (!xdr_changeid4(xdrs, &objp->after))
   1765 		return (FALSE);
   1766 	return (TRUE);
   1767 }
   1768 
   1769 bool_t
   1770 xdr_clientaddr4(XDR *xdrs, clientaddr4 *objp)
   1771 {
   1772 
   1773 	rpc_inline_t *buf;
   1774 
   1775 	if (!xdr_netaddr4(xdrs, objp))
   1776 		return (FALSE);
   1777 	return (TRUE);
   1778 }
   1779 
   1780 bool_t
   1781 xdr_cb_client4(XDR *xdrs, cb_client4 *objp)
   1782 {
   1783 
   1784 	rpc_inline_t *buf;
   1785 
   1786 	if (!xdr_uint32_t(xdrs, &objp->cb_program))
   1787 		return (FALSE);
   1788 	if (!xdr_netaddr4(xdrs, &objp->cb_location))
   1789 		return (FALSE);
   1790 	return (TRUE);
   1791 }
   1792 
   1793 bool_t
   1794 xdr_nfs_client_id4(XDR *xdrs, nfs_client_id4 *objp)
   1795 {
   1796 
   1797 	rpc_inline_t *buf;
   1798 
   1799 	if (!xdr_verifier4(xdrs, objp->verifier))
   1800 		return (FALSE);
   1801 	if (!xdr_bytes(xdrs, (char **)&objp->id.id_val,
   1802 	    (uint_t *)&objp->id.id_len, NFS4_OPAQUE_LIMIT))
   1803 		return (FALSE);
   1804 	return (TRUE);
   1805 }
   1806 
   1807 bool_t
   1808 xdr_client_owner4(XDR *xdrs, client_owner4 *objp)
   1809 {
   1810 
   1811 	rpc_inline_t *buf;
   1812 
   1813 	if (!xdr_verifier4(xdrs, objp->co_verifier))
   1814 		return (FALSE);
   1815 	if (!xdr_bytes(xdrs, (char **)&objp->co_ownerid.co_ownerid_val,
   1816 	    (uint_t *)&objp->co_ownerid.co_ownerid_len, NFS4_OPAQUE_LIMIT))
   1817 		return (FALSE);
   1818 	return (TRUE);
   1819 }
   1820 
   1821 bool_t
   1822 xdr_server_owner4(XDR *xdrs, server_owner4 *objp)
   1823 {
   1824 
   1825 	rpc_inline_t *buf;
   1826 
   1827 	if (!xdr_uint64_t(xdrs, &objp->so_minor_id))
   1828 		return (FALSE);
   1829 	if (!xdr_bytes(xdrs, (char **)&objp->so_major_id.so_major_id_val,
   1830 	    (uint_t *)&objp->so_major_id.so_major_id_len, NFS4_OPAQUE_LIMIT))
   1831 		return (FALSE);
   1832 	return (TRUE);
   1833 }
   1834 
   1835 bool_t
   1836 xdr_state_owner4(XDR *xdrs, state_owner4 *objp)
   1837 {
   1838 
   1839 	rpc_inline_t *buf;
   1840 
   1841 	if (!xdr_clientid4(xdrs, &objp->clientid))
   1842 		return (FALSE);
   1843 	if (!xdr_bytes(xdrs, (char **)&objp->owner.owner_val,
   1844 	    (uint_t *)&objp->owner.owner_len, NFS4_OPAQUE_LIMIT))
   1845 		return (FALSE);
   1846 	return (TRUE);
   1847 }
   1848 
   1849 bool_t
   1850 xdr_open_owner4(XDR *xdrs, open_owner4 *objp)
   1851 {
   1852 
   1853 	rpc_inline_t *buf;
   1854 
   1855 	if (!xdr_state_owner4(xdrs, objp))
   1856 		return (FALSE);
   1857 	return (TRUE);
   1858 }
   1859 
   1860 bool_t
   1861 xdr_lock_owner4(XDR *xdrs, lock_owner4 *objp)
   1862 {
   1863 
   1864 	rpc_inline_t *buf;
   1865 
   1866 	if (!xdr_state_owner4(xdrs, objp))
   1867 		return (FALSE);
   1868 	return (TRUE);
   1869 }
   1870 
   1871 bool_t
   1872 xdr_nfs_lock_type4(XDR *xdrs, nfs_lock_type4 *objp)
   1873 {
   1874 
   1875 	rpc_inline_t *buf;
   1876 
   1877 	if (!xdr_enum(xdrs, (enum_t *)objp))
   1878 		return (FALSE);
   1879 	return (TRUE);
   1880 }
   1881 
   1882 /* Input for computing subkeys */
   1883 
   1884 bool_t
   1885 xdr_ssv_subkey4(XDR *xdrs, ssv_subkey4 *objp)
   1886 {
   1887 
   1888 	rpc_inline_t *buf;
   1889 
   1890 	if (!xdr_enum(xdrs, (enum_t *)objp))
   1891 		return (FALSE);
   1892 	return (TRUE);
   1893 }
   1894 
   1895 
   1896 /* Input for computing smt_hmac */
   1897 
   1898 bool_t
   1899 xdr_ssv_mic_plain_tkn4(XDR *xdrs, ssv_mic_plain_tkn4 *objp)
   1900 {
   1901 
   1902 	rpc_inline_t *buf;
   1903 
   1904 	if (!xdr_uint32_t(xdrs, &objp->smpt_ssv_seq))
   1905 		return (FALSE);
   1906 	if (!xdr_bytes(xdrs,
   1907 	    (char **)&objp->smpt_orig_plain.smpt_orig_plain_val,
   1908 	    (uint_t *)&objp->smpt_orig_plain.smpt_orig_plain_len, ~0))
   1909 		return (FALSE);
   1910 	return (TRUE);
   1911 }
   1912 
   1913 
   1914 /* SSV GSS PerMsgToken token */
   1915 
   1916 bool_t
   1917 xdr_ssv_mic_tkn4(XDR *xdrs, ssv_mic_tkn4 *objp)
   1918 {
   1919 
   1920 	rpc_inline_t *buf;
   1921 
   1922 	if (!xdr_uint32_t(xdrs, &objp->smt_ssv_seq))
   1923 		return (FALSE);
   1924 	if (!xdr_bytes(xdrs, (char **)&objp->smt_hmac.smt_hmac_val,
   1925 	    (uint_t *)&objp->smt_hmac.smt_hmac_len, ~0))
   1926 		return (FALSE);
   1927 	return (TRUE);
   1928 }
   1929 
   1930 
   1931 /* Input for computing ssct_encr_data and ssct_hmac */
   1932 
   1933 bool_t
   1934 xdr_ssv_seal_plain_tkn4(XDR *xdrs, ssv_seal_plain_tkn4 *objp)
   1935 {
   1936 
   1937 	rpc_inline_t *buf;
   1938 
   1939 	if (!xdr_bytes(xdrs,
   1940 	    (char **)&objp->sspt_confounder.sspt_confounder_val,
   1941 	    (uint_t *)&objp->sspt_confounder.sspt_confounder_len, ~0))
   1942 		return (FALSE);
   1943 	if (!xdr_uint32_t(xdrs, &objp->sspt_ssv_seq))
   1944 		return (FALSE);
   1945 	if (!xdr_bytes(xdrs,
   1946 	    (char **)&objp->sspt_orig_plain.sspt_orig_plain_val,
   1947 	    (uint_t *)&objp->sspt_orig_plain.sspt_orig_plain_len, ~0))
   1948 		return (FALSE);
   1949 	if (!xdr_bytes(xdrs, (char **)&objp->sspt_pad.sspt_pad_val,
   1950 	    (uint_t *)&objp->sspt_pad.sspt_pad_len, ~0))
   1951 		return (FALSE);
   1952 	return (TRUE);
   1953 }
   1954 
   1955 
   1956 /* SSV GSS SealedMessage token */
   1957 
   1958 bool_t
   1959 xdr_ssv_seal_cipher_tkn4(XDR *xdrs, ssv_seal_cipher_tkn4 *objp)
   1960 {
   1961 
   1962 	rpc_inline_t *buf;
   1963 
   1964 	if (!xdr_uint32_t(xdrs, &objp->ssct_ssv_seq))
   1965 		return (FALSE);
   1966 	if (!xdr_bytes(xdrs, (char **)&objp->ssct_iv.ssct_iv_val,
   1967 	    (uint_t *)&objp->ssct_iv.ssct_iv_len, ~0))
   1968 		return (FALSE);
   1969 	if (!xdr_bytes(xdrs,
   1970 	    (char **)&objp->ssct_encr_data.ssct_encr_data_val,
   1971 	    (uint_t *)&objp->ssct_encr_data.ssct_encr_data_len, ~0))
   1972 		return (FALSE);
   1973 	if (!xdr_bytes(xdrs, (char **)&objp->ssct_hmac.ssct_hmac_val,
   1974 	    (uint_t *)&objp->ssct_hmac.ssct_hmac_len, ~0))
   1975 		return (FALSE);
   1976 	return (TRUE);
   1977 }
   1978 
   1979 
   1980 bool_t
   1981 xdr_fs_locations_server4(XDR *xdrs, fs_locations_server4 *objp)
   1982 {
   1983 
   1984 	rpc_inline_t *buf;
   1985 
   1986 	if (!xdr_int32_t(xdrs, &objp->fls_currency))
   1987 		return (FALSE);
   1988 	if (!xdr_bytes(xdrs, (char **)&objp->fls_info.fls_info_val,
   1989 	    (uint_t *)&objp->fls_info.fls_info_len, ~0))
   1990 		return (FALSE);
   1991 	if (!xdr_utf8str_cis(xdrs, &objp->fls_server))
   1992 		return (FALSE);
   1993 	return (TRUE);
   1994 }
   1995 
   1996 bool_t
   1997 xdr_fs_locations_item4(XDR *xdrs, fs_locations_item4 *objp)
   1998 {
   1999 
   2000 	rpc_inline_t *buf;
   2001 
   2002 	if (!xdr_array(xdrs, (char **)&objp->fli_entries.fli_entries_val,
   2003 	    (uint_t *)&objp->fli_entries.fli_entries_len, ~0,
   2004 	    sizeof (fs_locations_server4), (xdrproc_t)xdr_fs_locations_server4))
   2005 		return (FALSE);
   2006 	if (!xdr_pathname4(xdrs, &objp->fli_rootpath))
   2007 		return (FALSE);
   2008 	return (TRUE);
   2009 }
   2010 
   2011 bool_t
   2012 xdr_fs_locations_info4(XDR *xdrs, fs_locations_info4 *objp)
   2013 {
   2014 
   2015 	rpc_inline_t *buf;
   2016 
   2017 	if (!xdr_uint32_t(xdrs, &objp->fli_flags))
   2018 		return (FALSE);
   2019 	if (!xdr_int32_t(xdrs, &objp->fli_valid_for))
   2020 		return (FALSE);
   2021 	if (!xdr_pathname4(xdrs, &objp->fli_fs_root))
   2022 		return (FALSE);
   2023 	if (!xdr_array(xdrs, (char **)&objp->fli_items.fli_items_val,
   2024 	    (uint_t *)&objp->fli_items.fli_items_len, ~0,
   2025 	    sizeof (fs_locations_item4), (xdrproc_t)xdr_fs_locations_item4))
   2026 		return (FALSE);
   2027 	return (TRUE);
   2028 }
   2029 
   2030 bool_t
   2031 xdr_fattr4_fs_locations_info(XDR *xdrs, fattr4_fs_locations_info *objp)
   2032 {
   2033 
   2034 	rpc_inline_t *buf;
   2035 
   2036 	if (!xdr_fs_locations_info4(xdrs, objp))
   2037 		return (FALSE);
   2038 	return (TRUE);
   2039 }
   2040 
   2041 bool_t
   2042 xdr_nfl_util4(XDR *xdrs, nfl_util4 *objp)
   2043 {
   2044 
   2045 	rpc_inline_t *buf;
   2046 
   2047 	if (!xdr_uint32_t(xdrs, objp))
   2048 		return (FALSE);
   2049 	return (TRUE);
   2050 }
   2051 
   2052 
   2053 bool_t
   2054 xdr_filelayout_hint_care4(XDR *xdrs, filelayout_hint_care4 *objp)
   2055 {
   2056 
   2057 	rpc_inline_t *buf;
   2058 
   2059 	if (!xdr_enum(xdrs, (enum_t *)objp))
   2060 		return (FALSE);
   2061 	return (TRUE);
   2062 }
   2063 
   2064 /* Encoded in the loh_body field of type layouthint4: */
   2065 
   2066 
   2067 bool_t
   2068 xdr_nfsv4_1_file_layouthint4(XDR *xdrs, nfsv4_1_file_layouthint4 *objp)
   2069 {
   2070 
   2071 	rpc_inline_t *buf;
   2072 
   2073 	if (!xdr_uint32_t(xdrs, &objp->nflh_care))
   2074 		return (FALSE);
   2075 	if (!xdr_nfl_util4(xdrs, &objp->nflh_util))
   2076 		return (FALSE);
   2077 	if (!xdr_count4(xdrs, &objp->nflh_stripe_count))
   2078 		return (FALSE);
   2079 	return (TRUE);
   2080 }
   2081 
   2082 
   2083 
   2084 bool_t
   2085 xdr_multipath_list4(XDR *xdrs, multipath_list4 *objp)
   2086 {
   2087 
   2088 	rpc_inline_t *buf;
   2089 
   2090 	if (!xdr_array(xdrs, (char **)&objp->multipath_list4_val,
   2091 	    (uint_t *)&objp->multipath_list4_len, ~0,
   2092 	    sizeof (netaddr4), (xdrproc_t)xdr_netaddr4))
   2093 		return (FALSE);
   2094 	return (TRUE);
   2095 }
   2096 
   2097 /* Encoded in the da_addr_body field of type device_addr4: */
   2098 
   2099 bool_t
   2100 xdr_nfsv4_1_file_layout_ds_addr4(XDR *xdrs, nfsv4_1_file_layout_ds_addr4 *objp)
   2101 {
   2102 
   2103 	rpc_inline_t *buf;
   2104 
   2105 	if (!xdr_array(xdrs,
   2106 	    (char **)&objp->nflda_stripe_indices.nflda_stripe_indices_val,
   2107 	    (uint_t *)&objp->nflda_stripe_indices.nflda_stripe_indices_len, ~0,
   2108 	    sizeof (uint32_t), (xdrproc_t)xdr_uint32_t))
   2109 		return (FALSE);
   2110 	if (!xdr_array(xdrs,
   2111 	    (char **)&objp->nflda_multipath_ds_list.
   2112 	    nflda_multipath_ds_list_val,
   2113 	    (uint_t *)&objp->nflda_multipath_ds_list.
   2114 	    nflda_multipath_ds_list_len, ~0,
   2115 	    sizeof (multipath_list4), (xdrproc_t)xdr_multipath_list4))
   2116 		return (FALSE);
   2117 	return (TRUE);
   2118 }
   2119 
   2120 
   2121 /* Encoded in the loc_body field of type layout_content4: */
   2122 
   2123 bool_t
   2124 xdr_nfsv4_1_file_layout4(XDR *xdrs, nfsv4_1_file_layout4 *objp)
   2125 {
   2126 
   2127 	rpc_inline_t *buf;
   2128 
   2129 	if (!xdr_deviceid4(xdrs, objp->nfl_deviceid))
   2130 		return (FALSE);
   2131 	if (!xdr_nfl_util4(xdrs, &objp->nfl_util))
   2132 		return (FALSE);
   2133 	if (!xdr_uint32_t(xdrs, &objp->nfl_first_stripe_index))
   2134 		return (FALSE);
   2135 	if (!xdr_offset4(xdrs, &objp->nfl_pattern_offset))
   2136 		return (FALSE);
   2137 	if (!xdr_array(xdrs, (char **)&objp->nfl_fh_list.nfl_fh_list_val,
   2138 	    (uint_t *)&objp->nfl_fh_list.nfl_fh_list_len, ~0,
   2139 	    sizeof (nfs_fh4), (xdrproc_t)xdr_nfs_fh4))
   2140 		return (FALSE);
   2141 	return (TRUE);
   2142 }
   2143 
   2144 /*
   2145  * Encoded in the lou_body field of type layoutupdate4:
   2146  *      Nothing. lou_body is a zero length array of octets.
   2147  */
   2148 
   2149 
   2150 bool_t
   2151 xdr_ACCESS4args(XDR *xdrs, ACCESS4args *objp)
   2152 {
   2153 
   2154 	rpc_inline_t *buf;
   2155 
   2156 	if (!xdr_uint32_t(xdrs, &objp->access))
   2157 		return (FALSE);
   2158 	return (TRUE);
   2159 }
   2160 
   2161 bool_t
   2162 xdr_ACCESS4resok(XDR *xdrs, ACCESS4resok *objp)
   2163 {
   2164 
   2165 	rpc_inline_t *buf;
   2166 
   2167 	if (!xdr_uint32_t(xdrs, &objp->supported))
   2168 		return (FALSE);
   2169 	if (!xdr_uint32_t(xdrs, &objp->access))
   2170 		return (FALSE);
   2171 	return (TRUE);
   2172 }
   2173 
   2174 bool_t
   2175 xdr_ACCESS4res(XDR *xdrs, ACCESS4res *objp)
   2176 {
   2177 
   2178 	rpc_inline_t *buf;
   2179 
   2180 	if (!xdr_nfsstat4(xdrs, &objp->status))
   2181 		return (FALSE);
   2182 	switch (objp->status) {
   2183 	case NFS4_OK:
   2184 		if (!xdr_ACCESS4resok(xdrs, &objp->ACCESS4res_u.resok4))
   2185 			return (FALSE);
   2186 		break;
   2187 	}
   2188 	return (TRUE);
   2189 }
   2190 
   2191 bool_t
   2192 xdr_CLOSE4args(XDR *xdrs, CLOSE4args *objp)
   2193 {
   2194 
   2195 	rpc_inline_t *buf;
   2196 
   2197 	if (!xdr_seqid4(xdrs, &objp->seqid))
   2198 		return (FALSE);
   2199 	if (!xdr_stateid4(xdrs, &objp->open_stateid))
   2200 		return (FALSE);
   2201 	return (TRUE);
   2202 }
   2203 
   2204 bool_t
   2205 xdr_CLOSE4res(XDR *xdrs, CLOSE4res *objp)
   2206 {
   2207 
   2208 	rpc_inline_t *buf;
   2209 
   2210 	if (!xdr_nfsstat4(xdrs, &objp->status))
   2211 		return (FALSE);
   2212 	switch (objp->status) {
   2213 	case NFS4_OK:
   2214 		if (!xdr_stateid4(xdrs, &objp->CLOSE4res_u.open_stateid))
   2215 			return (FALSE);
   2216 		break;
   2217 	}
   2218 	return (TRUE);
   2219 }
   2220 
   2221 bool_t
   2222 xdr_COMMIT4args(XDR *xdrs, COMMIT4args *objp)
   2223 {
   2224 
   2225 	rpc_inline_t *buf;
   2226 
   2227 	if (!xdr_offset4(xdrs, &objp->offset))
   2228 		return (FALSE);
   2229 	if (!xdr_count4(xdrs, &objp->count))
   2230 		return (FALSE);
   2231 	return (TRUE);
   2232 }
   2233 
   2234 bool_t
   2235 xdr_COMMIT4resok(XDR *xdrs, COMMIT4resok *objp)
   2236 {
   2237 
   2238 	rpc_inline_t *buf;
   2239 
   2240 	if (!xdr_verifier4(xdrs, objp->writeverf))
   2241 		return (FALSE);
   2242 	return (TRUE);
   2243 }
   2244 
   2245 bool_t
   2246 xdr_COMMIT4res(XDR *xdrs, COMMIT4res *objp)
   2247 {
   2248 
   2249 	rpc_inline_t *buf;
   2250 
   2251 	if (!xdr_nfsstat4(xdrs, &objp->status))
   2252 		return (FALSE);
   2253 	switch (objp->status) {
   2254 	case NFS4_OK:
   2255 		if (!xdr_COMMIT4resok(xdrs, &objp->COMMIT4res_u.resok4))
   2256 			return (FALSE);
   2257 		break;
   2258 	}
   2259 	return (TRUE);
   2260 }
   2261 
   2262 bool_t
   2263 xdr_createtype4(XDR *xdrs, createtype4 *objp)
   2264 {
   2265 
   2266 	rpc_inline_t *buf;
   2267 
   2268 	if (!xdr_nfs_ftype4(xdrs, &objp->type))
   2269 		return (FALSE);
   2270 	switch (objp->type) {
   2271 	case NF4LNK:
   2272 		if (!xdr_linktext4(xdrs, &objp->createtype4_u.linkdata))
   2273 			return (FALSE);
   2274 		break;
   2275 	case NF4BLK:
   2276 	case NF4CHR:
   2277 		if (!xdr_specdata4(xdrs, &objp->createtype4_u.devdata))
   2278 			return (FALSE);
   2279 		break;
   2280 	case NF4SOCK:
   2281 	case NF4FIFO:
   2282 	case NF4DIR:
   2283 		break;
   2284 	}
   2285 	return (TRUE);
   2286 }
   2287 
   2288 bool_t
   2289 xdr_CREATE4args(XDR *xdrs, CREATE4args *objp)
   2290 {
   2291 
   2292 	rpc_inline_t *buf;
   2293 
   2294 	if (!xdr_createtype4(xdrs, &objp->objtype))
   2295 		return (FALSE);
   2296 	if (!xdr_component4(xdrs, &objp->objname))
   2297 		return (FALSE);
   2298 	if (!xdr_fattr4(xdrs, &objp->createattrs))
   2299 		return (FALSE);
   2300 	return (TRUE);
   2301 }
   2302 
   2303 bool_t
   2304 xdr_CREATE4resok(XDR *xdrs, CREATE4resok *objp)
   2305 {
   2306 
   2307 	rpc_inline_t *buf;
   2308 
   2309 	if (!xdr_change_info4(xdrs, &objp->cinfo))
   2310 		return (FALSE);
   2311 	if (!xdr_bitmap4(xdrs, &objp->attrset))
   2312 		return (FALSE);
   2313 	return (TRUE);
   2314 }
   2315 
   2316 bool_t
   2317 xdr_CREATE4res(XDR *xdrs, CREATE4res *objp)
   2318 {
   2319 
   2320 	rpc_inline_t *buf;
   2321 
   2322 	if (!xdr_nfsstat4(xdrs, &objp->status))
   2323 		return (FALSE);
   2324 	switch (objp->status) {
   2325 	case NFS4_OK:
   2326 		if (!xdr_CREATE4resok(xdrs, &objp->CREATE4res_u.resok4))
   2327 			return (FALSE);
   2328 		break;
   2329 	}
   2330 	return (TRUE);
   2331 }
   2332 
   2333 bool_t
   2334 xdr_DELEGPURGE4args(XDR *xdrs, DELEGPURGE4args *objp)
   2335 {
   2336 
   2337 	rpc_inline_t *buf;
   2338 
   2339 	if (!xdr_clientid4(xdrs, &objp->clientid))
   2340 		return (FALSE);
   2341 	return (TRUE);
   2342 }
   2343 
   2344 bool_t
   2345 xdr_DELEGPURGE4res(XDR *xdrs, DELEGPURGE4res *objp)
   2346 {
   2347 
   2348 	rpc_inline_t *buf;
   2349 
   2350 	if (!xdr_nfsstat4(xdrs, &objp->status))
   2351 		return (FALSE);
   2352 	return (TRUE);
   2353 }
   2354 
   2355 bool_t
   2356 xdr_DELEGRETURN4args(XDR *xdrs, DELEGRETURN4args *objp)
   2357 {
   2358 
   2359 	rpc_inline_t *buf;
   2360 
   2361 	if (!xdr_stateid4(xdrs, &objp->deleg_stateid))
   2362 		return (FALSE);
   2363 	return (TRUE);
   2364 }
   2365 
   2366 bool_t
   2367 xdr_DELEGRETURN4res(XDR *xdrs, DELEGRETURN4res *objp)
   2368 {
   2369 
   2370 	rpc_inline_t *buf;
   2371 
   2372 	if (!xdr_nfsstat4(xdrs, &objp->status))
   2373 		return (FALSE);
   2374 	return (TRUE);
   2375 }
   2376 
   2377 bool_t
   2378 xdr_GETATTR4args(XDR *xdrs, GETATTR4args *objp)
   2379 {
   2380 
   2381 	rpc_inline_t *buf;
   2382 
   2383 	if (!xdr_bitmap4(xdrs, &objp->attr_request))
   2384 		return (FALSE);
   2385 	return (TRUE);
   2386 }
   2387 
   2388 bool_t
   2389 xdr_GETATTR4resok(XDR *xdrs, GETATTR4resok *objp)
   2390 {
   2391 
   2392 	rpc_inline_t *buf;
   2393 
   2394 	if (!xdr_fattr4(xdrs, &objp->obj_attributes))
   2395 		return (FALSE);
   2396 	return (TRUE);
   2397 }
   2398 
   2399 bool_t
   2400 xdr_GETATTR4res(XDR *xdrs, GETATTR4res *objp)
   2401 {
   2402 
   2403 	rpc_inline_t *buf;
   2404 
   2405 	if (!xdr_nfsstat4(xdrs, &objp->status))
   2406 		return (FALSE);
   2407 	switch (objp->status) {
   2408 	case NFS4_OK:
   2409 		if (!xdr_GETATTR4resok(xdrs, &objp->GETATTR4res_u.resok4))
   2410 			return (FALSE);
   2411 		break;
   2412 	}
   2413 	return (TRUE);
   2414 }
   2415 
   2416 bool_t
   2417 xdr_GETFH4resok(XDR *xdrs, GETFH4resok *objp)
   2418 {
   2419 
   2420 	rpc_inline_t *buf;
   2421 
   2422 	if (!xdr_nfs_fh4(xdrs, &objp->object))
   2423 		return (FALSE);
   2424 	return (TRUE);
   2425 }
   2426 
   2427 bool_t
   2428 xdr_GETFH4res(XDR *xdrs, GETFH4res *objp)
   2429 {
   2430 
   2431 	rpc_inline_t *buf;
   2432 
   2433 	if (!xdr_nfsstat4(xdrs, &objp->status))
   2434 		return (FALSE);
   2435 	switch (objp->status) {
   2436 	case NFS4_OK:
   2437 		if (!xdr_GETFH4resok(xdrs, &objp->GETFH4res_u.resok4))
   2438 			return (FALSE);
   2439 		break;
   2440 	}
   2441 	return (TRUE);
   2442 }
   2443 
   2444 bool_t
   2445 xdr_LINK4args(XDR *xdrs, LINK4args *objp)
   2446 {
   2447 
   2448 	rpc_inline_t *buf;
   2449 
   2450 	if (!xdr_component4(xdrs, &objp->newname))
   2451 		return (FALSE);
   2452 	return (TRUE);
   2453 }
   2454 
   2455 bool_t
   2456 xdr_LINK4resok(XDR *xdrs, LINK4resok *objp)
   2457 {
   2458 
   2459 	rpc_inline_t *buf;
   2460 
   2461 	if (!xdr_change_info4(xdrs, &objp->cinfo))
   2462 		return (FALSE);
   2463 	return (TRUE);
   2464 }
   2465 
   2466 bool_t
   2467 xdr_LINK4res(XDR *xdrs, LINK4res *objp)
   2468 {
   2469 
   2470 	rpc_inline_t *buf;
   2471 
   2472 	if (!xdr_nfsstat4(xdrs, &objp->status))
   2473 		return (FALSE);
   2474 	switch (objp->status) {
   2475 	case NFS4_OK:
   2476 		if (!xdr_LINK4resok(xdrs, &objp->LINK4res_u.resok4))
   2477 			return (FALSE);
   2478 		break;
   2479 	}
   2480 	return (TRUE);
   2481 }
   2482 
   2483 bool_t
   2484 xdr_open_to_lock_owner4(XDR *xdrs, open_to_lock_owner4 *objp)
   2485 {
   2486 
   2487 	rpc_inline_t *buf;
   2488 
   2489 	if (!xdr_seqid4(xdrs, &objp->open_seqid))
   2490 		return (FALSE);
   2491 	if (!xdr_stateid4(xdrs, &objp->open_stateid))
   2492 		return (FALSE);
   2493 	if (!xdr_seqid4(xdrs, &objp->lock_seqid))
   2494 		return (FALSE);
   2495 	if (!xdr_lock_owner4(xdrs, &objp->lock_owner))
   2496 		return (FALSE);
   2497 	return (TRUE);
   2498 }
   2499 
   2500 bool_t
   2501 xdr_exist_lock_owner4(XDR *xdrs, exist_lock_owner4 *objp)
   2502 {
   2503 
   2504 	rpc_inline_t *buf;
   2505 
   2506 	if (!xdr_stateid4(xdrs, &objp->lock_stateid))
   2507 		return (FALSE);
   2508 	if (!xdr_seqid4(xdrs, &objp->lock_seqid))
   2509 		return (FALSE);
   2510 	return (TRUE);
   2511 }
   2512 
   2513 bool_t
   2514 xdr_locker4(XDR *xdrs, locker4 *objp)
   2515 {
   2516 
   2517 	rpc_inline_t *buf;
   2518 
   2519 	if (!xdr_bool(xdrs, &objp->new_lock_owner))
   2520 		return (FALSE);
   2521 	switch (objp->new_lock_owner) {
   2522 	case TRUE:
   2523 		if (!xdr_open_to_lock_owner4(xdrs, &objp->locker4_u.open_owner))
   2524 			return (FALSE);
   2525 		break;
   2526 	case FALSE:
   2527 		if (!xdr_exist_lock_owner4(xdrs, &objp->locker4_u.lock_owner))
   2528 			return (FALSE);
   2529 		break;
   2530 	default:
   2531 		return (FALSE);
   2532 	}
   2533 	return (TRUE);
   2534 }
   2535 
   2536 bool_t
   2537 xdr_LOCK4args(XDR *xdrs, LOCK4args *objp)
   2538 {
   2539 
   2540 	rpc_inline_t *buf;
   2541 
   2542 	if (!xdr_nfs_lock_type4(xdrs, &objp->locktype))
   2543 		return (FALSE);
   2544 	if (!xdr_bool(xdrs, &objp->reclaim))
   2545 		return (FALSE);
   2546 	if (!xdr_offset4(xdrs, &objp->offset))
   2547 		return (FALSE);
   2548 	if (!xdr_length4(xdrs, &objp->length))
   2549 		return (FALSE);
   2550 	if (!xdr_locker4(xdrs, &objp->locker))
   2551 		return (FALSE);
   2552 	return (TRUE);
   2553 }
   2554 
   2555 bool_t
   2556 xdr_LOCK4denied(XDR *xdrs, LOCK4denied *objp)
   2557 {
   2558 
   2559 	rpc_inline_t *buf;
   2560 
   2561 	if (!xdr_offset4(xdrs, &objp->offset))
   2562 		return (FALSE);
   2563 	if (!xdr_length4(xdrs, &objp->length))
   2564 		return (FALSE);
   2565 	if (!xdr_nfs_lock_type4(xdrs, &objp->locktype))
   2566 		return (FALSE);
   2567 	if (!xdr_lock_owner4(xdrs, &objp->owner))
   2568 		return (FALSE);
   2569 	return (TRUE);
   2570 }
   2571 
   2572 bool_t
   2573 xdr_LOCK4resok(XDR *xdrs, LOCK4resok *objp)
   2574 {
   2575 
   2576 	rpc_inline_t *buf;
   2577 
   2578 	if (!xdr_stateid4(xdrs, &objp->lock_stateid))
   2579 		return (FALSE);
   2580 	return (TRUE);
   2581 }
   2582 
   2583 bool_t
   2584 xdr_LOCK4res(XDR *xdrs, LOCK4res *objp)
   2585 {
   2586 
   2587 	rpc_inline_t *buf;
   2588 
   2589 	if (!xdr_nfsstat4(xdrs, &objp->status))
   2590 		return (FALSE);
   2591 	switch (objp->status) {
   2592 	case NFS4_OK:
   2593 		if (!xdr_LOCK4resok(xdrs, &objp->LOCK4res_u.resok4))
   2594 			return (FALSE);
   2595 		break;
   2596 	case NFS4ERR_DENIED:
   2597 		if (!xdr_LOCK4denied(xdrs, &objp->LOCK4res_u.denied))
   2598 			return (FALSE);
   2599 		break;
   2600 	}
   2601 	return (TRUE);
   2602 }
   2603 
   2604 bool_t
   2605 xdr_LOCKT4args(XDR *xdrs, LOCKT4args *objp)
   2606 {
   2607 
   2608 	rpc_inline_t *buf;
   2609 
   2610 	if (!xdr_nfs_lock_type4(xdrs, &objp->locktype))
   2611 		return (FALSE);
   2612 	if (!xdr_offset4(xdrs, &objp->offset))
   2613 		return (FALSE);
   2614 	if (!xdr_length4(xdrs, &objp->length))
   2615 		return (FALSE);
   2616 	if (!xdr_lock_owner4(xdrs, &objp->owner))
   2617 		return (FALSE);
   2618 	return (TRUE);
   2619 }
   2620 
   2621 bool_t
   2622 xdr_LOCKT4res(XDR *xdrs, LOCKT4res *objp)
   2623 {
   2624 
   2625 	rpc_inline_t *buf;
   2626 
   2627 	if (!xdr_nfsstat4(xdrs, &objp->status))
   2628 		return (FALSE);
   2629 	switch (objp->status) {
   2630 	case NFS4ERR_DENIED:
   2631 		if (!xdr_LOCK4denied(xdrs, &objp->LOCKT4res_u.denied))
   2632 			return (FALSE);
   2633 		break;
   2634 	case NFS4_OK:
   2635 		break;
   2636 	}
   2637 	return (TRUE);
   2638 }
   2639 
   2640 bool_t
   2641 xdr_LOCKU4args(XDR *xdrs, LOCKU4args *objp)
   2642 {
   2643 
   2644 	rpc_inline_t *buf;
   2645 
   2646 	if (!xdr_nfs_lock_type4(xdrs, &objp->locktype))
   2647 		return (FALSE);
   2648 	if (!xdr_seqid4(xdrs, &objp->seqid))
   2649 		return (FALSE);
   2650 	if (!xdr_stateid4(xdrs, &objp->lock_stateid))
   2651 		return (FALSE);
   2652 	if (!xdr_offset4(xdrs, &objp->offset))
   2653 		return (FALSE);
   2654 	if (!xdr_length4(xdrs, &objp->length))
   2655 		return (FALSE);
   2656 	return (TRUE);
   2657 }
   2658 
   2659 bool_t
   2660 xdr_LOCKU4res(XDR *xdrs, LOCKU4res *objp)
   2661 {
   2662 
   2663 	rpc_inline_t *buf;
   2664 
   2665 	if (!xdr_nfsstat4(xdrs, &objp->status))
   2666 		return (FALSE);
   2667 	switch (objp->status) {
   2668 	case NFS4_OK:
   2669 		if (!xdr_stateid4(xdrs, &objp->LOCKU4res_u.lock_stateid))
   2670 			return (FALSE);
   2671 		break;
   2672 	}
   2673 	return (TRUE);
   2674 }
   2675 
   2676 bool_t
   2677 xdr_LOOKUP4args(XDR *xdrs, LOOKUP4args *objp)
   2678 {
   2679 
   2680 	rpc_inline_t *buf;
   2681 
   2682 	if (!xdr_component4(xdrs, &objp->objname))
   2683 		return (FALSE);
   2684 	return (TRUE);
   2685 }
   2686 
   2687 bool_t
   2688 xdr_LOOKUP4res(XDR *xdrs, LOOKUP4res *objp)
   2689 {
   2690 
   2691 	rpc_inline_t *buf;
   2692 
   2693 	if (!xdr_nfsstat4(xdrs, &objp->status))
   2694 		return (FALSE);
   2695 	return (TRUE);
   2696 }
   2697 
   2698 bool_t
   2699 xdr_LOOKUPP4res(XDR *xdrs, LOOKUPP4res *objp)
   2700 {
   2701 
   2702 	rpc_inline_t *buf;
   2703 
   2704 	if (!xdr_nfsstat4(xdrs, &objp->status))
   2705 		return (FALSE);
   2706 	return (TRUE);
   2707 }
   2708 
   2709 bool_t
   2710 xdr_NVERIFY4args(XDR *xdrs, NVERIFY4args *objp)
   2711 {
   2712 
   2713 	rpc_inline_t *buf;
   2714 
   2715 	if (!xdr_fattr4(xdrs, &objp->obj_attributes))
   2716 		return (FALSE);
   2717 	return (TRUE);
   2718 }
   2719 
   2720 bool_t
   2721 xdr_NVERIFY4res(XDR *xdrs, NVERIFY4res *objp)
   2722 {
   2723 
   2724 	rpc_inline_t *buf;
   2725 
   2726 	if (!xdr_nfsstat4(xdrs, &objp->status))
   2727 		return (FALSE);
   2728 	return (TRUE);
   2729 }
   2730 
   2731 bool_t
   2732 xdr_createmode4(XDR *xdrs, createmode4 *objp)
   2733 {
   2734 
   2735 	rpc_inline_t *buf;
   2736 
   2737 	if (!xdr_enum(xdrs, (enum_t *)objp))
   2738 		return (FALSE);
   2739 	return (TRUE);
   2740 }
   2741 
   2742 bool_t
   2743 xdr_creatverfattr(XDR *xdrs, creatverfattr *objp)
   2744 {
   2745 
   2746 	rpc_inline_t *buf;
   2747 
   2748 	if (!xdr_verifier4(xdrs, objp->cva_verf))
   2749 		return (FALSE);
   2750 	if (!xdr_fattr4(xdrs, &objp->cva_attrs))
   2751 		return (FALSE);
   2752 	return (TRUE);
   2753 }
   2754 
   2755 bool_t
   2756 xdr_createhow4(XDR *xdrs, createhow4 *objp)
   2757 {
   2758 
   2759 	rpc_inline_t *buf;
   2760 
   2761 	if (!xdr_createmode4(xdrs, &objp->mode))
   2762 		return (FALSE);
   2763 	switch (objp->mode) {
   2764 	case UNCHECKED4:
   2765 	case GUARDED4:
   2766 		if (!xdr_fattr4(xdrs, &objp->createhow4_u.createattrs))
   2767 			return (FALSE);
   2768 		break;
   2769 	case EXCLUSIVE4:
   2770 		if (!xdr_verifier4(xdrs, objp->createhow4_u.createverf))
   2771 			return (FALSE);
   2772 		break;
   2773 	case EXCLUSIVE4_1:
   2774 		if (!xdr_creatverfattr(xdrs, &objp->createhow4_u.ch_createboth))
   2775 			return (FALSE);
   2776 		break;
   2777 	default:
   2778 		return (FALSE);
   2779 	}
   2780 	return (TRUE);
   2781 }
   2782 
   2783 bool_t
   2784 xdr_opentype4(XDR *xdrs, opentype4 *objp)
   2785 {
   2786 
   2787 	rpc_inline_t *buf;
   2788 
   2789 	if (!xdr_enum(xdrs, (enum_t *)objp))
   2790 		return (FALSE);
   2791 	return (TRUE);
   2792 }
   2793 
   2794 bool_t
   2795 xdr_openflag4(XDR *xdrs, openflag4 *objp)
   2796 {
   2797 
   2798 	rpc_inline_t *buf;
   2799 
   2800 	if (!xdr_opentype4(xdrs, &objp->opentype))
   2801 		return (FALSE);
   2802 	switch (objp->opentype) {
   2803 	case OPEN4_CREATE:
   2804 		if (!xdr_createhow4(xdrs, &objp->openflag4_u.how))
   2805 			return (FALSE);
   2806 		break;
   2807 	}
   2808 	return (TRUE);
   2809 }
   2810 
   2811 bool_t
   2812 xdr_limit_by4(XDR *xdrs, limit_by4 *objp)
   2813 {
   2814 
   2815 	rpc_inline_t *buf;
   2816 
   2817 	if (!xdr_enum(xdrs, (enum_t *)objp))
   2818 		return (FALSE);
   2819 	return (TRUE);
   2820 }
   2821 
   2822 bool_t
   2823 xdr_nfs_modified_limit4(XDR *xdrs, nfs_modified_limit4 *objp)
   2824 {
   2825 
   2826 	rpc_inline_t *buf;
   2827 
   2828 	if (!xdr_uint32_t(xdrs, &objp->num_blocks))
   2829 		return (FALSE);
   2830 	if (!xdr_uint32_t(xdrs, &objp->bytes_per_block))
   2831 		return (FALSE);
   2832 	return (TRUE);
   2833 }
   2834 
   2835 bool_t
   2836 xdr_nfs_space_limit4(XDR *xdrs, nfs_space_limit4 *objp)
   2837 {
   2838 
   2839 	rpc_inline_t *buf;
   2840 
   2841 	if (!xdr_limit_by4(xdrs, &objp->limitby))
   2842 		return (FALSE);
   2843 	switch (objp->limitby) {
   2844 	case NFS_LIMIT_SIZE:
   2845 		if (!xdr_uint64_t(xdrs, &objp->nfs_space_limit4_u.filesize))
   2846 			return (FALSE);
   2847 		break;
   2848 	case NFS_LIMIT_BLOCKS:
   2849 		if (!xdr_nfs_modified_limit4(xdrs,
   2850 		    &objp->nfs_space_limit4_u.mod_blocks))
   2851 			return (FALSE);
   2852 		break;
   2853 	default:
   2854 		return (FALSE);
   2855 	}
   2856 	return (TRUE);
   2857 }
   2858 
   2859 bool_t
   2860 xdr_open_delegation_type4(XDR *xdrs, open_delegation_type4 *objp)
   2861 {
   2862 
   2863 	rpc_inline_t *buf;
   2864 
   2865 	if (!xdr_enum(xdrs, (enum_t *)objp))
   2866 		return (FALSE);
   2867 	return (TRUE);
   2868 }
   2869 
   2870 bool_t
   2871 xdr_open_claim_type4(XDR *xdrs, open_claim_type4 *objp)
   2872 {
   2873 
   2874 	rpc_inline_t *buf;
   2875 
   2876 	if (!xdr_enum(xdrs, (enum_t *)objp))
   2877 		return (FALSE);
   2878 	return (TRUE);
   2879 }
   2880 
   2881 bool_t
   2882 xdr_open_claim_delegate_cur4(XDR *xdrs, open_claim_delegate_cur4 *objp)
   2883 {
   2884 
   2885 	rpc_inline_t *buf;
   2886 
   2887 	if (!xdr_stateid4(xdrs, &objp->delegate_stateid))
   2888 		return (FALSE);
   2889 	if (!xdr_component4(xdrs, &objp->file))
   2890 		return (FALSE);
   2891 	return (TRUE);
   2892 }
   2893 
   2894 bool_t
   2895 xdr_open_claim4(XDR *xdrs, open_claim4 *objp)
   2896 {
   2897 
   2898 	rpc_inline_t *buf;
   2899 
   2900 	if (!xdr_open_claim_type4(xdrs, &objp->claim))
   2901 		return (FALSE);
   2902 	switch (objp->claim) {
   2903 	case CLAIM_NULL:
   2904 		if (!xdr_component4(xdrs,
   2905 		    &objp->open_claim4_u.file))
   2906 			return (FALSE);
   2907 		break;
   2908 	case CLAIM_PREVIOUS:
   2909 		if (!xdr_open_delegation_type4(xdrs,
   2910 		    &objp->open_claim4_u.delegate_type))
   2911 			return (FALSE);
   2912 		break;
   2913 	case CLAIM_DELEGATE_CUR:
   2914 		if (!xdr_open_claim_delegate_cur4(xdrs,
   2915 		    &objp->open_claim4_u.delegate_cur_info))
   2916 			return (FALSE);
   2917 		break;
   2918 	case CLAIM_DELEGATE_PREV:
   2919 		if (!xdr_component4(xdrs,
   2920 		    &objp->open_claim4_u.file_delegate_prev))
   2921 			return (FALSE);
   2922 		break;
   2923 	case CLAIM_FH:
   2924 		break;
   2925 	case CLAIM_DELEG_PREV_FH:
   2926 		break;
   2927 	case CLAIM_DELEG_CUR_FH:
   2928 		if (!xdr_stateid4(xdrs,
   2929 		    &objp->open_claim4_u.oc_delegate_stateid))
   2930 			return (FALSE);
   2931 		break;
   2932 	default:
   2933 		return (FALSE);
   2934 	}
   2935 	return (TRUE);
   2936 }
   2937 
   2938 bool_t
   2939 xdr_OPEN4args(XDR *xdrs, OPEN4args *objp)
   2940 {
   2941 
   2942 	rpc_inline_t *buf;
   2943 
   2944 	if (!xdr_seqid4(xdrs, &objp->seqid))
   2945 		return (FALSE);
   2946 	if (!xdr_uint32_t(xdrs, &objp->share_access))
   2947 		return (FALSE);
   2948 	if (!xdr_uint32_t(xdrs, &objp->share_deny))
   2949 		return (FALSE);
   2950 	if (!xdr_open_owner4(xdrs, &objp->owner))
   2951 		return (FALSE);
   2952 	if (!xdr_openflag4(xdrs, &objp->openhow))
   2953 		return (FALSE);
   2954 	if (!xdr_open_claim4(xdrs, &objp->claim))
   2955 		return (FALSE);
   2956 	return (TRUE);
   2957 }
   2958 
   2959 bool_t
   2960 xdr_open_read_delegation4(XDR *xdrs, open_read_delegation4 *objp)
   2961 {
   2962 
   2963 	rpc_inline_t *buf;
   2964 
   2965 	if (!xdr_stateid4(xdrs, &objp->stateid))
   2966 		return (FALSE);
   2967 	if (!xdr_bool(xdrs, &objp->recall))
   2968 		return (FALSE);
   2969 	if (!xdr_nfsace4(xdrs, &objp->permissions))
   2970 		return (FALSE);
   2971 	return (TRUE);
   2972 }
   2973 
   2974 bool_t
   2975 xdr_open_write_delegation4(XDR *xdrs, open_write_delegation4 *objp)
   2976 {
   2977 
   2978 	rpc_inline_t *buf;
   2979 
   2980 	if (!xdr_stateid4(xdrs, &objp->stateid))
   2981 		return (FALSE);
   2982 	if (!xdr_bool(xdrs, &objp->recall))
   2983 		return (FALSE);
   2984 	if (!xdr_nfs_space_limit4(xdrs, &objp->space_limit))
   2985 		return (FALSE);
   2986 	if (!xdr_nfsace4(xdrs, &objp->permissions))
   2987 		return (FALSE);
   2988 	return (TRUE);
   2989 }
   2990 
   2991 bool_t
   2992 xdr_why_no_delegation4(XDR *xdrs, why_no_delegation4 *objp)
   2993 {
   2994 
   2995 	rpc_inline_t *buf;
   2996 
   2997 	if (!xdr_enum(xdrs, (enum_t *)objp))
   2998 		return (FALSE);
   2999 	return (TRUE);
   3000 }
   3001 
   3002 bool_t
   3003 xdr_open_none_delegation4(XDR *xdrs, open_none_delegation4 *objp)
   3004 {
   3005 
   3006 	rpc_inline_t *buf;
   3007 
   3008 	if (!xdr_why_no_delegation4(xdrs, &objp->ond_why))
   3009 		return (FALSE);
   3010 	switch (objp->ond_why) {
   3011 	case WND4_CONTENTION:
   3012 		if (!xdr_bool(xdrs,
   3013 		    &objp->open_none_delegation4_u.ond_server_will_push_deleg))
   3014 			return (FALSE);
   3015 		break;
   3016 	case WND4_RESOURCE:
   3017 		if (!xdr_bool(xdrs,
   3018 		    &objp->open_none_delegation4_u.
   3019 		    ond_server_will_signal_avail))
   3020 			return (FALSE);
   3021 		break;
   3022 	}
   3023 	return (TRUE);
   3024 }
   3025 
   3026 bool_t
   3027 xdr_open_delegation4(XDR *xdrs, open_delegation4 *objp)
   3028 {
   3029 
   3030 	rpc_inline_t *buf;
   3031 
   3032 	if (!xdr_open_delegation_type4(xdrs, &objp->delegation_type))
   3033 		return (FALSE);
   3034 	switch (objp->delegation_type) {
   3035 	case OPEN_DELEGATE_NONE:
   3036 		break;
   3037 	case OPEN_DELEGATE_READ:
   3038 		if (!xdr_open_read_delegation4(xdrs,
   3039 		    &objp->open_delegation4_u.read))
   3040 			return (FALSE);
   3041 		break;
   3042 	case OPEN_DELEGATE_WRITE:
   3043 		if (!xdr_open_write_delegation4(xdrs,
   3044 		    &objp->open_delegation4_u.write))
   3045 			return (FALSE);
   3046 		break;
   3047 	case OPEN_DELEGATE_NONE_EXT:
   3048 		if (!xdr_open_none_delegation4(xdrs,
   3049 		    &objp->open_delegation4_u.od_whynone))
   3050 			return (FALSE);
   3051 		break;
   3052 	default:
   3053 		return (FALSE);
   3054 	}
   3055 	return (TRUE);
   3056 }
   3057 
   3058 bool_t
   3059 xdr_OPEN4resok(XDR *xdrs, OPEN4resok *objp)
   3060 {
   3061 
   3062 	rpc_inline_t *buf;
   3063 
   3064 	if (!xdr_stateid4(xdrs, &objp->stateid))
   3065 		return (FALSE);
   3066 	if (!xdr_change_info4(xdrs, &objp->cinfo))
   3067 		return (FALSE);
   3068 	if (!xdr_uint32_t(xdrs, &objp->rflags))
   3069 		return (FALSE);
   3070 	if (!xdr_bitmap4(xdrs, &objp->attrset))
   3071 		return (FALSE);
   3072 	if (!xdr_open_delegation4(xdrs, &objp->delegation))
   3073 		return (FALSE);
   3074 	return (TRUE);
   3075 }
   3076 
   3077 bool_t
   3078 xdr_OPEN4res(XDR *xdrs, OPEN4res *objp)
   3079 {
   3080 
   3081 	rpc_inline_t *buf;
   3082 
   3083 	if (!xdr_nfsstat4(xdrs, &objp->status))
   3084 		return (FALSE);
   3085 	switch (objp->status) {
   3086 	case NFS4_OK:
   3087 		if (!xdr_OPEN4resok(xdrs, &objp->OPEN4res_u.resok4))
   3088 			return (FALSE);
   3089 		break;
   3090 	}
   3091 	return (TRUE);
   3092 }
   3093 
   3094 bool_t
   3095 xdr_OPENATTR4args(XDR *xdrs, OPENATTR4args *objp)
   3096 {
   3097 
   3098 	rpc_inline_t *buf;
   3099 
   3100 	if (!xdr_bool(xdrs, &objp->createdir))
   3101 		return (FALSE);
   3102 	return (TRUE);
   3103 }
   3104 
   3105 bool_t
   3106 xdr_OPENATTR4res(XDR *xdrs, OPENATTR4res *objp)
   3107 {
   3108 
   3109 	rpc_inline_t *buf;
   3110 
   3111 	if (!xdr_nfsstat4(xdrs, &objp->status))
   3112 		return (FALSE);
   3113 	return (TRUE);
   3114 }
   3115 
   3116 bool_t
   3117 xdr_OPEN_CONFIRM4args(XDR *xdrs, OPEN_CONFIRM4args *objp)
   3118 {
   3119 
   3120 	rpc_inline_t *buf;
   3121 
   3122 	if (!xdr_stateid4(xdrs, &objp->open_stateid))
   3123 		return (FALSE);
   3124 	if (!xdr_seqid4(xdrs, &objp->seqid))
   3125 		return (FALSE);
   3126 	return (TRUE);
   3127 }
   3128 
   3129 bool_t
   3130 xdr_OPEN_CONFIRM4resok(XDR *xdrs, OPEN_CONFIRM4resok *objp)
   3131 {
   3132 
   3133 	rpc_inline_t *buf;
   3134 
   3135 	if (!xdr_stateid4(xdrs, &objp->open_stateid))
   3136 		return (FALSE);
   3137 	return (TRUE);
   3138 }
   3139 
   3140 bool_t
   3141 xdr_OPEN_CONFIRM4res(XDR *xdrs, OPEN_CONFIRM4res *objp)
   3142 {
   3143 
   3144 	rpc_inline_t *buf;
   3145 
   3146 	if (!xdr_nfsstat4(xdrs, &objp->status))
   3147 		return (FALSE);
   3148 	switch (objp->status) {
   3149 	case NFS4_OK:
   3150 		if (!xdr_OPEN_CONFIRM4resok(xdrs,
   3151 		    &objp->OPEN_CONFIRM4res_u.resok4))
   3152 			return (FALSE);
   3153 		break;
   3154 	}
   3155 	return (TRUE);
   3156 }
   3157 
   3158 bool_t
   3159 xdr_OPEN_DOWNGRADE4args(XDR *xdrs, OPEN_DOWNGRADE4args *objp)
   3160 {
   3161 
   3162 	rpc_inline_t *buf;
   3163 
   3164 	if (!xdr_stateid4(xdrs, &objp->open_stateid))
   3165 		return (FALSE);
   3166 	if (!xdr_seqid4(xdrs, &objp->seqid))
   3167 		return (FALSE);
   3168 	if (!xdr_uint32_t(xdrs, &objp->share_access))
   3169 		return (FALSE);
   3170 	if (!xdr_uint32_t(xdrs, &objp->share_deny))
   3171 		return (FALSE);
   3172 	return (TRUE);
   3173 }
   3174 
   3175 bool_t
   3176 xdr_OPEN_DOWNGRADE4resok(XDR *xdrs, OPEN_DOWNGRADE4resok *objp)
   3177 {
   3178 
   3179 	rpc_inline_t *buf;
   3180 
   3181 	if (!xdr_stateid4(xdrs, &objp->open_stateid))
   3182 		return (FALSE);
   3183 	return (TRUE);
   3184 }
   3185 
   3186 bool_t
   3187 xdr_OPEN_DOWNGRADE4res(XDR *xdrs, OPEN_DOWNGRADE4res *objp)
   3188 {
   3189 
   3190 	rpc_inline_t *buf;
   3191 
   3192 	if (!xdr_nfsstat4(xdrs, &objp->status))
   3193 		return (FALSE);
   3194 	switch (objp->status) {
   3195 	case NFS4_OK:
   3196 		if (!xdr_OPEN_DOWNGRADE4resok(xdrs,
   3197 		    &objp->OPEN_DOWNGRADE4res_u.resok4))
   3198 			return (FALSE);
   3199 		break;
   3200 	}
   3201 	return (TRUE);
   3202 }
   3203 
   3204 bool_t
   3205 xdr_PUTFH4args(XDR *xdrs, PUTFH4args *objp)
   3206 {
   3207 
   3208 	rpc_inline_t *buf;
   3209 
   3210 	if (!xdr_nfs_fh4(xdrs, &objp->object))
   3211 		return (FALSE);
   3212 	return (TRUE);
   3213 }
   3214 
   3215 bool_t
   3216 xdr_PUTFH4res(XDR *xdrs, PUTFH4res *objp)
   3217 {
   3218 
   3219 	rpc_inline_t *buf;
   3220 
   3221 	if (!xdr_nfsstat4(xdrs, &objp->status))
   3222 		return (FALSE);
   3223 	return (TRUE);
   3224 }
   3225 
   3226 bool_t
   3227 xdr_PUTPUBFH4res(XDR *xdrs, PUTPUBFH4res *objp)
   3228 {
   3229 
   3230 	rpc_inline_t *buf;
   3231 
   3232 	if (!xdr_nfsstat4(xdrs, &objp->status))
   3233 		return (FALSE);
   3234 	return (TRUE);
   3235 }
   3236 
   3237 bool_t
   3238 xdr_PUTROOTFH4res(XDR *xdrs, PUTROOTFH4res *objp)
   3239 {
   3240 
   3241 	rpc_inline_t *buf;
   3242 
   3243 	if (!xdr_nfsstat4(xdrs, &objp->status))
   3244 		return (FALSE);
   3245 	return (TRUE);
   3246 }
   3247 
   3248 bool_t
   3249 xdr_READ4args(XDR *xdrs, READ4args *objp)
   3250 {
   3251 
   3252 	rpc_inline_t *buf;
   3253 
   3254 	if (!xdr_stateid4(xdrs, &objp->stateid))
   3255 		return (FALSE);
   3256 	if (!xdr_offset4(xdrs, &objp->offset))
   3257 		return (FALSE);
   3258 	if (!xdr_count4(xdrs, &objp->count))
   3259 		return (FALSE);
   3260 	return (TRUE);
   3261 }
   3262 
   3263 bool_t
   3264 xdr_READ4resok(XDR *xdrs, READ4resok *objp)
   3265 {
   3266 
   3267 	rpc_inline_t *buf;
   3268 
   3269 	if (!xdr_bool(xdrs, &objp->eof))
   3270 
   3271 #ifdef  IGNORE_RDWR_DATA
   3272 	/*
   3273 	 * Try to get length of read, and if that
   3274 	 * fails, default to 0.  Don't return FALSE
   3275 	 * because the other read info will not be
   3276 	 * displayed.
   3277 	 */
   3278 	objp->data.data_val = NULL;
   3279 	if (!xdr_u_int(xdrs, &objp->data.data_len))
   3280 		objp->data.data_len = 0;
   3281 		nfs4_skip_bytes = objp->data.data_len;
   3282 #else
   3283 	if (!xdr_bytes(xdrs, (char **)&objp->data.data_val,
   3284 	    (uint_t *)&objp->data.data_len, ~0))
   3285 		return (FALSE);
   3286 #endif
   3287 	return (TRUE);
   3288 }
   3289 
   3290 bool_t
   3291 xdr_READ4res(XDR *xdrs, READ4res *objp)
   3292 {
   3293 
   3294 	rpc_inline_t *buf;
   3295 
   3296 	if (!xdr_nfsstat4(xdrs, &objp->status))
   3297 		return (FALSE);
   3298 	switch (objp->status) {
   3299 	case NFS4_OK:
   3300 		if (!xdr_READ4resok(xdrs, &objp->READ4res_u.resok4))
   3301 			return (FALSE);
   3302 		break;
   3303 	}
   3304 	return (TRUE);
   3305 }
   3306 
   3307 bool_t
   3308 xdr_READDIR4args(XDR *xdrs, READDIR4args *objp)
   3309 {
   3310 
   3311 	rpc_inline_t *buf;
   3312 
   3313 	if (!xdr_nfs_cookie4(xdrs, &objp->cookie))
   3314 		return (FALSE);
   3315 	if (!xdr_verifier4(xdrs, objp->cookieverf))
   3316 		return (FALSE);
   3317 	if (!xdr_count4(xdrs, &objp->dircount))
   3318 		return (FALSE);
   3319 	if (!xdr_count4(xdrs, &objp->maxcount))
   3320 		return (FALSE);
   3321 	if (!xdr_bitmap4(xdrs, &objp->attr_request))
   3322 		return (FALSE);
   3323 	return (TRUE);
   3324 }
   3325 
   3326 bool_t
   3327 xdr_entry4(XDR *xdrs, entry4 *objp)
   3328 {
   3329 
   3330 	rpc_inline_t *buf;
   3331 
   3332 	entry4 *tmp_entry4;
   3333 	bool_t more_data = TRUE;
   3334 	bool_t first_objp = TRUE;
   3335 
   3336 
   3337 	if (xdrs->x_op == XDR_DECODE) {
   3338 
   3339 		while (more_data) {
   3340 
   3341 			void bzero();
   3342 
   3343 			if (!xdr_nfs_cookie4(xdrs, &objp->cookie))
   3344 				return (FALSE);
   3345 			if (!xdr_component4(xdrs, &objp->name))
   3346 				return (FALSE);
   3347 			if (!xdr_fattr4(xdrs, &objp->attrs))
   3348 				return (FALSE);
   3349 			if (!xdr_bool(xdrs, &more_data))
   3350 				return (FALSE);
   3351 
   3352 			if (!more_data) {
   3353 				objp->nextentry = NULL;
   3354 				break;
   3355 			}
   3356 
   3357 			if (objp->nextentry == NULL) {
   3358 				objp->nextentry = (entry4 *)
   3359 				    mem_alloc(sizeof (entry4));
   3360 				if (objp->nextentry == NULL)
   3361 					return (FALSE);
   3362 				bzero(objp->nextentry, sizeof (entry4));
   3363 			}
   3364 			objp = objp->nextentry;
   3365 		}
   3366 
   3367 	} else if (xdrs->x_op == XDR_ENCODE) {
   3368 
   3369 		while (more_data) {
   3370 			if (!xdr_nfs_cookie4(xdrs, &objp->cookie))
   3371 				return (FALSE);
   3372 			if (!xdr_component4(xdrs, &objp->name))
   3373 				return (FALSE);
   3374 			if (!xdr_fattr4(xdrs, &objp->attrs))
   3375 				return (FALSE);
   3376 			objp = objp->nextentry;
   3377 			if (objp == NULL)
   3378 				more_data = FALSE;
   3379 			if (!xdr_bool(xdrs, &more_data))
   3380 				return (FALSE);
   3381 		}
   3382 
   3383 	} else {
   3384 
   3385 		while (more_data) {
   3386 			if (!xdr_nfs_cookie4(xdrs, &objp->cookie))
   3387 				return (FALSE);
   3388 			if (!xdr_component4(xdrs, &objp->name))
   3389 				return (FALSE);
   3390 			if (!xdr_fattr4(xdrs, &objp->attrs))
   3391 				return (FALSE);
   3392 			tmp_entry4 = objp;
   3393 			objp = objp->nextentry;
   3394 			if (objp == NULL)
   3395 				more_data = FALSE;
   3396 			if (!first_objp)
   3397 				mem_free(tmp_entry4, sizeof (entry4));
   3398 			else
   3399 				first_objp = FALSE;
   3400 		}
   3401 
   3402 	}
   3403 	return (TRUE);
   3404 }
   3405 
   3406 bool_t
   3407 xdr_dirlist4(XDR *xdrs, dirlist4 *objp)
   3408 {
   3409 
   3410 	rpc_inline_t *buf;
   3411 
   3412 	if (!xdr_pointer(xdrs, (char **)&objp->entries,
   3413 	    sizeof (entry4), (xdrproc_t)xdr_entry4))
   3414 		return (FALSE);
   3415 	if (!xdr_bool(xdrs, &objp->eof))
   3416 		return (FALSE);
   3417 	return (TRUE);
   3418 }
   3419 
   3420 bool_t
   3421 xdr_READDIR4resok(XDR *xdrs, READDIR4resok *objp)
   3422 {
   3423 
   3424 	rpc_inline_t *buf;
   3425 
   3426 	if (!xdr_verifier4(xdrs, objp->cookieverf))
   3427 		return (FALSE);
   3428 	if (!xdr_dirlist4(xdrs, &objp->reply))
   3429 		return (FALSE);
   3430 	return (TRUE);
   3431 }
   3432 
   3433 bool_t
   3434 xdr_READDIR4res(XDR *xdrs, READDIR4res *objp)
   3435 {
   3436 
   3437 	rpc_inline_t *buf;
   3438 
   3439 	if (!xdr_nfsstat4(xdrs, &objp->status))
   3440 		return (FALSE);
   3441 	switch (objp->status) {
   3442 	case NFS4_OK:
   3443 		if (!xdr_READDIR4resok(xdrs, &objp->READDIR4res_u.resok4))
   3444 			return (FALSE);
   3445 		break;
   3446 	}
   3447 	return (TRUE);
   3448 }
   3449 
   3450 bool_t
   3451 xdr_READLINK4resok(XDR *xdrs, READLINK4resok *objp)
   3452 {
   3453 
   3454 	rpc_inline_t *buf;
   3455 
   3456 	if (!xdr_linktext4(xdrs, &objp->link))
   3457 		return (FALSE);
   3458 	return (TRUE);
   3459 }
   3460 
   3461 bool_t
   3462 xdr_READLINK4res(XDR *xdrs, READLINK4res *objp)
   3463 {
   3464 
   3465 	rpc_inline_t *buf;
   3466 
   3467 	if (!xdr_nfsstat4(xdrs, &objp->status))
   3468 		return (FALSE);
   3469 	switch (objp->status) {
   3470 	case NFS4_OK:
   3471 		if (!xdr_READLINK4resok(xdrs, &objp->READLINK4res_u.resok4))
   3472 			return (FALSE);
   3473 		break;
   3474 	}
   3475 	return (TRUE);
   3476 }
   3477 
   3478 bool_t
   3479 xdr_REMOVE4args(XDR *xdrs, REMOVE4args *objp)
   3480 {
   3481 
   3482 	rpc_inline_t *buf;
   3483 
   3484 	if (!xdr_component4(xdrs, &objp->target))
   3485 		return (FALSE);
   3486 	return (TRUE);
   3487 }
   3488 
   3489 bool_t
   3490 xdr_REMOVE4resok(XDR *xdrs, REMOVE4resok *objp)
   3491 {
   3492 
   3493 	rpc_inline_t *buf;
   3494 
   3495 	if (!xdr_change_info4(xdrs, &objp->cinfo))
   3496 		return (FALSE);
   3497 	return (TRUE);
   3498 }
   3499 
   3500 bool_t
   3501 xdr_REMOVE4res(XDR *xdrs, REMOVE4res *objp)
   3502 {
   3503 
   3504 	rpc_inline_t *buf;
   3505 
   3506 	if (!xdr_nfsstat4(xdrs, &objp->status))
   3507 		return (FALSE);
   3508 	switch (objp->status) {
   3509 	case NFS4_OK:
   3510 		if (!xdr_REMOVE4resok(xdrs, &objp->REMOVE4res_u.resok4))
   3511 			return (FALSE);
   3512 		break;
   3513 	}
   3514 	return (TRUE);
   3515 }
   3516 
   3517 bool_t
   3518 xdr_RENAME4args(XDR *xdrs, RENAME4args *objp)
   3519 {
   3520 
   3521 	rpc_inline_t *buf;
   3522 
   3523 	if (!xdr_component4(xdrs, &objp->oldname))
   3524 		return (FALSE);
   3525 	if (!xdr_component4(xdrs, &objp->newname))
   3526 		return (FALSE);
   3527 	return (TRUE);
   3528 }
   3529 
   3530 bool_t
   3531 xdr_RENAME4resok(XDR *xdrs, RENAME4resok *objp)
   3532 {
   3533 
   3534 	rpc_inline_t *buf;
   3535 
   3536 	if (!xdr_change_info4(xdrs, &objp->source_cinfo))
   3537 		return (FALSE);
   3538 	if (!xdr_change_info4(xdrs, &objp->target_cinfo))
   3539 		return (FALSE);
   3540 	return (TRUE);
   3541 }
   3542 
   3543 bool_t
   3544 xdr_RENAME4res(XDR *xdrs, RENAME4res *objp)
   3545 {
   3546 
   3547 	rpc_inline_t *buf;
   3548 
   3549 	if (!xdr_nfsstat4(xdrs, &objp->status))
   3550 		return (FALSE);
   3551 	switch (objp->status) {
   3552 	case NFS4_OK:
   3553 		if (!xdr_RENAME4resok(xdrs, &objp->RENAME4res_u.resok4))
   3554 			return (FALSE);
   3555 		break;
   3556 	}
   3557 	return (TRUE);
   3558 }
   3559 
   3560 bool_t
   3561 xdr_RENEW4args(XDR *xdrs, RENEW4args *objp)
   3562 {
   3563 
   3564 	rpc_inline_t *buf;
   3565 
   3566 	if (!xdr_clientid4(xdrs, &objp->clientid))
   3567 		return (FALSE);
   3568 	return (TRUE);
   3569 }
   3570 
   3571 bool_t
   3572 xdr_RENEW4res(XDR *xdrs, RENEW4res *objp)
   3573 {
   3574 
   3575 	rpc_inline_t *buf;
   3576 
   3577 	if (!xdr_nfsstat4(xdrs, &objp->status))
   3578 		return (FALSE);
   3579 	return (TRUE);
   3580 }
   3581 
   3582 bool_t
   3583 xdr_RESTOREFH4res(XDR *xdrs, RESTOREFH4res *objp)
   3584 {
   3585 
   3586 	rpc_inline_t *buf;
   3587 
   3588 	if (!xdr_nfsstat4(xdrs, &objp->status))
   3589 		return (FALSE);
   3590 	return (TRUE);
   3591 }
   3592 
   3593 bool_t
   3594 xdr_SAVEFH4res(XDR *xdrs, SAVEFH4res *objp)
   3595 {
   3596 
   3597 	rpc_inline_t *buf;
   3598 
   3599 	if (!xdr_nfsstat4(xdrs, &objp->status))
   3600 		return (FALSE);
   3601 	return (TRUE);
   3602 }
   3603 
   3604 bool_t
   3605 xdr_SECINFO4args(XDR *xdrs, SECINFO4args *objp)
   3606 {
   3607 
   3608 	rpc_inline_t *buf;
   3609 
   3610 	if (!xdr_component4(xdrs, &objp->name))
   3611 		return (FALSE);
   3612 	return (TRUE);
   3613 }
   3614 
   3615 bool_t
   3616 xdr_rpc_gss_svc_t(XDR *xdrs, rpc_gss_svc_t *objp)
   3617 {
   3618 
   3619 	rpc_inline_t *buf;
   3620 
   3621 	if (!xdr_enum(xdrs, (enum_t *)objp))
   3622 		return (FALSE);
   3623 	return (TRUE);
   3624 }
   3625 
   3626 bool_t
   3627 xdr_rpcsec_gss_info(XDR *xdrs, rpcsec_gss_info *objp)
   3628 {
   3629 
   3630 	rpc_inline_t *buf;
   3631 
   3632 	if (!xdr_sec_oid4(xdrs, &objp->oid))
   3633 		return (FALSE);
   3634 	if (!xdr_qop4(xdrs, &objp->qop))
   3635 		return (FALSE);
   3636 	if (!xdr_rpc_gss_svc_t(xdrs, &objp->service))
   3637 		return (FALSE);
   3638 	return (TRUE);
   3639 }
   3640 
   3641 bool_t
   3642 xdr_secinfo4(XDR *xdrs, secinfo4 *objp)
   3643 {
   3644 
   3645 	rpc_inline_t *buf;
   3646 
   3647 	if (!xdr_uint32_t(xdrs, &objp->flavor))
   3648 		return (FALSE);
   3649 	switch (objp->flavor) {
   3650 	case RPCSEC_GSS:
   3651 		if (!xdr_rpcsec_gss_info(xdrs, &objp->secinfo4_u.flavor_info))
   3652 			return (FALSE);
   3653 		break;
   3654 	}
   3655 	return (TRUE);
   3656 }
   3657 
   3658 bool_t
   3659 xdr_SECINFO4resok(XDR *xdrs, SECINFO4resok *objp)
   3660 {
   3661 
   3662 	rpc_inline_t *buf;
   3663 
   3664 	if (!xdr_array(xdrs, (char **)&objp->SECINFO4resok_val,
   3665 	    (uint_t *)&objp->SECINFO4resok_len, ~0,
   3666 	    sizeof (secinfo4), (xdrproc_t)xdr_secinfo4))
   3667 		return (FALSE);
   3668 	return (TRUE);
   3669 }
   3670 
   3671 bool_t
   3672 xdr_SECINFO4res(XDR *xdrs, SECINFO4res *objp)
   3673 {
   3674 
   3675 	rpc_inline_t *buf;
   3676 
   3677 	if (!xdr_nfsstat4(xdrs, &objp->status))
   3678 		return (FALSE);
   3679 	switch (objp->status) {
   3680 	case NFS4_OK:
   3681 		if (!xdr_SECINFO4resok(xdrs, &objp->SECINFO4res_u.resok4))
   3682 			return (FALSE);
   3683 		break;
   3684 	}
   3685 	return (TRUE);
   3686 }
   3687 
   3688 bool_t
   3689 xdr_SETATTR4args(XDR *xdrs, SETATTR4args *objp)
   3690 {
   3691 
   3692 	rpc_inline_t *buf;
   3693 
   3694 	if (!xdr_stateid4(xdrs, &objp->stateid))
   3695 		return (FALSE);
   3696 	if (!xdr_fattr4(xdrs, &objp->obj_attributes))
   3697 		return (FALSE);
   3698 	return (TRUE);
   3699 }
   3700 
   3701 bool_t
   3702 xdr_SETATTR4res(XDR *xdrs, SETATTR4res *objp)
   3703 {
   3704 
   3705 	rpc_inline_t *buf;
   3706 
   3707 	if (!xdr_nfsstat4(xdrs, &objp->status))
   3708 		return (FALSE);
   3709 	if (!xdr_bitmap4(xdrs, &objp->attrsset))
   3710 		return (FALSE);
   3711 	return (TRUE);
   3712 }
   3713 
   3714 bool_t
   3715 xdr_SETCLIENTID4args(XDR *xdrs, SETCLIENTID4args *objp)
   3716 {
   3717 
   3718 	rpc_inline_t *buf;
   3719 
   3720 	if (!xdr_nfs_client_id4(xdrs, &objp->client))
   3721 		return (FALSE);
   3722 	if (!xdr_cb_client4(xdrs, &objp->callback))
   3723 		return (FALSE);
   3724 	if (!xdr_uint32_t(xdrs, &objp->callback_ident))
   3725 		return (FALSE);
   3726 	return (TRUE);
   3727 }
   3728 
   3729 bool_t
   3730 xdr_SETCLIENTID4resok(XDR *xdrs, SETCLIENTID4resok *objp)
   3731 {
   3732 
   3733 	rpc_inline_t *buf;
   3734 
   3735 	if (!xdr_clientid4(xdrs, &objp->clientid))
   3736 		return (FALSE);
   3737 	if (!xdr_verifier4(xdrs, objp->setclientid_confirm))
   3738 		return (FALSE);
   3739 	return (TRUE);
   3740 }
   3741 
   3742 bool_t
   3743 xdr_SETCLIENTID4res(XDR *xdrs, SETCLIENTID4res *objp)
   3744 {
   3745 
   3746 	rpc_inline_t *buf;
   3747 
   3748 	if (!xdr_nfsstat4(xdrs, &objp->status))
   3749 		return (FALSE);
   3750 	switch (objp->status) {
   3751 	case NFS4_OK:
   3752 		if (!xdr_SETCLIENTID4resok(xdrs,
   3753 		    &objp->SETCLIENTID4res_u.resok4))
   3754 			return (FALSE);
   3755 		break;
   3756 	case NFS4ERR_CLID_INUSE:
   3757 		if (!xdr_clientaddr4(xdrs,
   3758 		    &objp->SETCLIENTID4res_u.client_using))
   3759 			return (FALSE);
   3760 		break;
   3761 	}
   3762 	return (TRUE);
   3763 }
   3764 
   3765 bool_t
   3766 xdr_SETCLIENTID_CONFIRM4args(XDR *xdrs, SETCLIENTID_CONFIRM4args *objp)
   3767 {
   3768 
   3769 	rpc_inline_t *buf;
   3770 
   3771 	if (!xdr_clientid4(xdrs, &objp->clientid))
   3772 		return (FALSE);
   3773 	if (!xdr_verifier4(xdrs, objp->setclientid_confirm))
   3774 		return (FALSE);
   3775 	return (TRUE);
   3776 }
   3777 
   3778 bool_t
   3779 xdr_SETCLIENTID_CONFIRM4res(XDR *xdrs, SETCLIENTID_CONFIRM4res *objp)
   3780 {
   3781 
   3782 	rpc_inline_t *buf;
   3783 
   3784 	if (!xdr_nfsstat4(xdrs, &objp->status))
   3785 		return (FALSE);
   3786 	return (TRUE);
   3787 }
   3788 
   3789 bool_t
   3790 xdr_VERIFY4args(XDR *xdrs, VERIFY4args *objp)
   3791 {
   3792 
   3793 	rpc_inline_t *buf;
   3794 
   3795 	if (!xdr_fattr4(xdrs, &objp->obj_attributes))
   3796 		return (FALSE);
   3797 	return (TRUE);
   3798 }
   3799 
   3800 bool_t
   3801 xdr_VERIFY4res(XDR *xdrs, VERIFY4res *objp)
   3802 {
   3803 
   3804 	rpc_inline_t *buf;
   3805 
   3806 	if (!xdr_nfsstat4(xdrs, &objp->status))
   3807 		return (FALSE);
   3808 	return (TRUE);
   3809 }
   3810 
   3811 bool_t
   3812 xdr_stable_how4(XDR *xdrs, stable_how4 *objp)
   3813 {
   3814 
   3815 	rpc_inline_t *buf;
   3816 
   3817 	if (!xdr_enum(xdrs, (enum_t *)objp))
   3818 		return (FALSE);
   3819 	return (TRUE);
   3820 }
   3821 
   3822 bool_t
   3823 xdr_WRITE4args(XDR *xdrs, WRITE4args *objp)
   3824 {
   3825 
   3826 	rpc_inline_t *buf;
   3827 
   3828 	if (!xdr_stateid4(xdrs, &objp->stateid))
   3829 		return (FALSE);
   3830 	if (!xdr_offset4(xdrs, &objp->offset))
   3831 		return (FALSE);
   3832 	if (!xdr_stable_how4(xdrs, &objp->stable))
   3833 
   3834 #ifdef IGNORE_RDWR_DATA
   3835 	/*
   3836 	 * try to get length of write, and if that
   3837 	 * fails, default to 0.  Don't return FALSE
   3838 	 * because the other write info will not be
   3839 	 * displayed (write stateid).
   3840 	 */
   3841 	objp->data.data_val = NULL;
   3842 	if (!xdr_u_int(xdrs, &objp->data.data_len))
   3843 		objp->data.data_len = 0;
   3844 	nfs4_skip_bytes = objp->data.data_len;
   3845 #else
   3846 	if (!xdr_bytes(xdrs, (char **)&objp->data.data_val,
   3847 	    (uint_t *)&objp->data.data_len, ~0))
   3848 		return (FALSE);
   3849 #endif
   3850 	return (TRUE);
   3851 }
   3852 
   3853 bool_t
   3854 xdr_WRITE4resok(XDR *xdrs, WRITE4resok *objp)
   3855 {
   3856 
   3857 	rpc_inline_t *buf;
   3858 
   3859 	if (!xdr_count4(xdrs, &objp->count))
   3860 		return (FALSE);
   3861 	if (!xdr_stable_how4(xdrs, &objp->committed))
   3862 		return (FALSE);
   3863 	if (!xdr_verifier4(xdrs, objp->writeverf))
   3864 		return (FALSE);
   3865 	return (TRUE);
   3866 }
   3867 
   3868 bool_t
   3869 xdr_WRITE4res(XDR *xdrs, WRITE4res *objp)
   3870 {
   3871 
   3872 	rpc_inline_t *buf;
   3873 
   3874 	if (!xdr_nfsstat4(xdrs, &objp->status))
   3875 		return (FALSE);
   3876 	switch (objp->status) {
   3877 	case NFS4_OK:
   3878 		if (!xdr_WRITE4resok(xdrs, &objp->WRITE4res_u.resok4))
   3879 			return (FALSE);
   3880 		break;
   3881 	}
   3882 	return (TRUE);
   3883 }
   3884 
   3885 bool_t
   3886 xdr_RELEASE_LOCKOWNER4args(XDR *xdrs, RELEASE_LOCKOWNER4args *objp)
   3887 {
   3888 
   3889 	rpc_inline_t *buf;
   3890 
   3891 	if (!xdr_lock_owner4(xdrs, &objp->lock_owner))
   3892 		return (FALSE);
   3893 	return (TRUE);
   3894 }
   3895 
   3896 bool_t
   3897 xdr_RELEASE_LOCKOWNER4res(XDR *xdrs, RELEASE_LOCKOWNER4res *objp)
   3898 {
   3899 
   3900 	rpc_inline_t *buf;
   3901 
   3902 	if (!xdr_nfsstat4(xdrs, &objp->status))
   3903 		return (FALSE);
   3904 	return (TRUE);
   3905 }
   3906 
   3907 bool_t
   3908 xdr_ILLEGAL4res(XDR *xdrs, ILLEGAL4res *objp)
   3909 {
   3910 
   3911 	rpc_inline_t *buf;
   3912 
   3913 	if (!xdr_nfsstat4(xdrs, &objp->status))
   3914 		return (FALSE);
   3915 	return (TRUE);
   3916 }
   3917 
   3918 bool_t
   3919 xdr_gsshandle4_t(XDR *xdrs, gsshandle4_t *objp)
   3920 {
   3921 
   3922 	rpc_inline_t *buf;
   3923 
   3924 	if (!xdr_bytes(xdrs, (char **)&objp->gsshandle4_t_val,
   3925 	    (uint_t *)&objp->gsshandle4_t_len, ~0))
   3926 		return (FALSE);
   3927 	return (TRUE);
   3928 }
   3929 
   3930 bool_t
   3931 xdr_gss_cb_handles4(XDR *xdrs, gss_cb_handles4 *objp)
   3932 {
   3933 
   3934 	rpc_inline_t *buf;
   3935 
   3936 	if (!xdr_rpc_gss_svc_t(xdrs, &objp->gcbp_service))
   3937 		return (FALSE);
   3938 	if (!xdr_gsshandle4_t(xdrs, &objp->gcbp_handle_from_server))
   3939 		return (FALSE);
   3940 	if (!xdr_gsshandle4_t(xdrs, &objp->gcbp_handle_from_client))
   3941 		return (FALSE);
   3942 	return (TRUE);
   3943 }
   3944 
   3945 bool_t
   3946 xdr_callback_sec_parms4(XDR *xdrs, callback_sec_parms4 *objp)
   3947 {
   3948 
   3949 	rpc_inline_t *buf;
   3950 
   3951 	if (!xdr_uint32_t(xdrs, &objp->cb_secflavor))
   3952 		return (FALSE);
   3953 	switch (objp->cb_secflavor) {
   3954 	case AUTH_NONE:
   3955 		break;
   3956 	case AUTH_SYS:
   3957 		if (!xdr_authsys_parms(xdrs,
   3958 		    &objp->callback_sec_parms4_u.cbsp_sys_cred))
   3959 			return (FALSE);
   3960 		break;
   3961 	case RPCSEC_GSS:
   3962 		if (!xdr_gss_cb_handles4(xdrs,
   3963 		    &objp->callback_sec_parms4_u.cbsp_gss_handles))
   3964 			return (FALSE);
   3965 		break;
   3966 	default:
   3967 		return (FALSE);
   3968 	}
   3969 	return (TRUE);
   3970 }
   3971 
   3972 bool_t
   3973 xdr_BACKCHANNEL_CTL4args(XDR *xdrs, BACKCHANNEL_CTL4args *objp)
   3974 {
   3975 
   3976 	rpc_inline_t *buf;
   3977 
   3978 	if (!xdr_uint32_t(xdrs, &objp->bca_cb_program))
   3979 		return (FALSE);
   3980 	if (!xdr_array(xdrs, (char **)&objp->bca_sec_parms.bca_sec_parms_val,
   3981 	    (uint_t *)&objp->bca_sec_parms.bca_sec_parms_len, ~0,
   3982 	    sizeof (callback_sec_parms4), (xdrproc_t)