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)