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 * Copyright 2017-2025 RackTop Systems, Inc. 25 */ 26 27 /* 28 * This file contains the xdr for datatypes and operations that are 29 * specific to NFSv4 minor version 1 (i.e., datatypes that 30 * were either introduced or changed by the NFSv4.1 specification). 31 */ 32 33 /* 34 * INSTRUCTIONS for updating to a new NFSv4.1: 35 * 36 * **DO NOT** simply replace this file with code rpcgen creates 37 * and then remove non-NFS41 code. The file now contains the hand 38 * coded xdr for the NFS4.1 attributes. If you run rpcgen, 39 * then those, and future changes, should be manually integrated. 40 */ 41 #include <sys/statvfs.h> 42 #include <sys/sysmacros.h> 43 #include <sys/sdt.h> 44 #include <nfs/nfs4.h> 45 #include <nfs/nfs4_attr.h> 46 47 #ifndef _KERNEL 48 #include <stdlib.h> 49 #endif /* !_KERNEL */ 50 51 /* modified version */ 52 bool_t 53 xdr_verifier4(XDR *xdrs, verifier4 *objp) 54 { 55 if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)objp)) 56 return (FALSE); 57 return (TRUE); 58 } 59 60 bool_t 61 xdr_sequenceid4(XDR *xdrs, sequenceid4 *objp) 62 { 63 if (!xdr_uint32_t(xdrs, objp)) 64 return (FALSE); 65 return (TRUE); 66 } 67 68 bool_t 69 xdr_sessionid4(XDR *xdrs, sessionid4 objp) 70 { 71 if (!xdr_opaque(xdrs, objp, NFS4_SESSIONID_SIZE)) 72 return (FALSE); 73 return (TRUE); 74 } 75 76 bool_t 77 xdr_slotid4(XDR *xdrs, slotid4 *objp) 78 { 79 80 if (!xdr_uint32_t(xdrs, objp)) 81 return (FALSE); 82 return (TRUE); 83 } 84 85 bool_t 86 xdr_change_policy4(XDR *xdrs, change_policy4 *objp) 87 { 88 if (!xdr_uint64_t(xdrs, &objp->cp_major)) 89 return (FALSE); 90 if (!xdr_uint64_t(xdrs, &objp->cp_minor)) 91 return (FALSE); 92 return (TRUE); 93 } 94 95 bool_t 96 xdr_aclflag4(XDR *xdrs, aclflag4 *objp) 97 { 98 if (!xdr_uint32_t(xdrs, objp)) 99 return (FALSE); 100 return (TRUE); 101 } 102 103 bool_t 104 xdr_nfsacl41(XDR *xdrs, nfsacl41 *objp) 105 { 106 if (!xdr_aclflag4(xdrs, &objp->na41_flag)) 107 return (FALSE); 108 if (!xdr_array(xdrs, (char **)&objp->na41_aces.na41_aces_val, 109 (uint_t *)&objp->na41_aces.na41_aces_len, ~0, sizeof (nfsace4), 110 (xdrproc_t)xdr_nfsace4)) 111 return (FALSE); 112 return (TRUE); 113 } 114 115 bool_t 116 xdr_mode_masked4(XDR *xdrs, mode_masked4 *objp) 117 { 118 if (!xdr_mode4(xdrs, &objp->mm_value_to_set)) 119 return (FALSE); 120 if (!xdr_mode4(xdrs, &objp->mm_mask_bits)) 121 return (FALSE); 122 return (TRUE); 123 } 124 125 bool_t 126 xdr_nfs_impl_id4(XDR *xdrs, nfs_impl_id4 *objp) 127 { 128 if (!xdr_utf8str_cis(xdrs, &objp->nii_domain)) 129 return (FALSE); 130 if (!xdr_utf8str_cs(xdrs, &objp->nii_name)) 131 return (FALSE); 132 if (!xdr_nfstime4(xdrs, &objp->nii_date)) 133 return (FALSE); 134 return (TRUE); 135 } 136 137 bool_t 138 xdr_layouttype4(XDR *xdrs, layouttype4 *objp) 139 { 140 if (!xdr_enum(xdrs, (enum_t *)objp)) 141 return (FALSE); 142 return (TRUE); 143 } 144 145 bool_t 146 xdr_layout_content4(XDR *xdrs, layout_content4 *objp) 147 { 148 if (!xdr_layouttype4(xdrs, &objp->loc_type)) 149 return (FALSE); 150 if (!xdr_bytes(xdrs, (char **)&objp->loc_body.loc_body_val, 151 (uint_t *)&objp->loc_body.loc_body_len, ~0)) 152 return (FALSE); 153 return (TRUE); 154 } 155 156 bool_t 157 xdr_layoutiomode4(XDR *xdrs, layoutiomode4 *objp) 158 { 159 if (!xdr_enum(xdrs, (enum_t *)objp)) 160 return (FALSE); 161 return (TRUE); 162 } 163 164 165 bool_t 166 xdr_layout4(XDR *xdrs, layout4 *objp) 167 { 168 if (!xdr_offset4(xdrs, &objp->lo_offset)) 169 return (FALSE); 170 if (!xdr_length4(xdrs, &objp->lo_length)) 171 return (FALSE); 172 if (!xdr_layoutiomode4(xdrs, &objp->lo_iomode)) 173 return (FALSE); 174 if (!xdr_layout_content4(xdrs, &objp->lo_content)) 175 return (FALSE); 176 return (TRUE); 177 } 178 179 bool_t 180 xdr_deviceid4(XDR *xdrs, deviceid4 objp) 181 { 182 if (!xdr_opaque(xdrs, objp, NFS4_DEVICEID4_SIZE)) 183 return (FALSE); 184 return (TRUE); 185 } 186 187 bool_t 188 xdr_device_addr4(XDR *xdrs, device_addr4 *objp) 189 { 190 if (!xdr_layouttype4(xdrs, &objp->da_layout_type)) 191 return (FALSE); 192 if (!xdr_bytes(xdrs, (char **)&objp->da_addr_body.da_addr_body_val, 193 (uint_t *)&objp->da_addr_body.da_addr_body_len, ~0)) 194 return (FALSE); 195 return (TRUE); 196 } 197 198 bool_t 199 xdr_layoutupdate4(XDR *xdrs, layoutupdate4 *objp) 200 { 201 if (!xdr_layouttype4(xdrs, &objp->lou_type)) 202 return (FALSE); 203 if (!xdr_bytes(xdrs, (char **)&objp->lou_body.lou_body_val, 204 (uint_t *)&objp->lou_body.lou_body_len, ~0)) 205 return (FALSE); 206 return (TRUE); 207 } 208 209 bool_t 210 xdr_layoutreturn_type4(XDR *xdrs, layoutreturn_type4 *objp) 211 { 212 if (!xdr_enum(xdrs, (enum_t *)objp)) 213 return (FALSE); 214 return (TRUE); 215 } 216 /* layouttype4 specific data */ 217 218 bool_t 219 xdr_layoutreturn_file4(XDR *xdrs, layoutreturn_file4 *objp) 220 { 221 if (!xdr_offset4(xdrs, &objp->lrf_offset)) 222 return (FALSE); 223 if (!xdr_length4(xdrs, &objp->lrf_length)) 224 return (FALSE); 225 if (!xdr_stateid4(xdrs, &objp->lrf_stateid)) 226 return (FALSE); 227 if (!xdr_bytes(xdrs, (char **)&objp->lrf_body.lrf_body_val, 228 (uint_t *)&objp->lrf_body.lrf_body_len, ~0)) 229 return (FALSE); 230 return (TRUE); 231 } 232 233 bool_t 234 xdr_layoutreturn4(XDR *xdrs, layoutreturn4 *objp) 235 { 236 if (!xdr_layoutreturn_type4(xdrs, &objp->lr_returntype)) 237 return (FALSE); 238 switch (objp->lr_returntype) { 239 case LAYOUTRETURN4_FILE: 240 if (!xdr_layoutreturn_file4(xdrs, 241 &objp->layoutreturn4_u.lr_layout)) 242 return (FALSE); 243 break; 244 } 245 return (TRUE); 246 } 247 248 249 bool_t 250 xdr_fs4_status_type(XDR *xdrs, fs4_status_type *objp) 251 { 252 if (!xdr_enum(xdrs, (enum_t *)objp)) 253 return (FALSE); 254 return (TRUE); 255 } 256 257 bool_t 258 xdr_fs4_status(XDR *xdrs, fs4_status *objp) 259 { 260 if (!xdr_bool(xdrs, &objp->fss_absent)) 261 return (FALSE); 262 if (!xdr_fs4_status_type(xdrs, &objp->fss_type)) 263 return (FALSE); 264 if (!xdr_utf8str_cs(xdrs, &objp->fss_source)) 265 return (FALSE); 266 if (!xdr_utf8str_cs(xdrs, &objp->fss_current)) 267 return (FALSE); 268 if (!xdr_int32_t(xdrs, &objp->fss_age)) 269 return (FALSE); 270 if (!xdr_nfstime4(xdrs, &objp->fss_version)) 271 return (FALSE); 272 return (TRUE); 273 } 274 275 bool_t 276 xdr_threshold4_read_size(XDR *xdrs, threshold4_read_size *objp) 277 { 278 279 if (!xdr_length4(xdrs, objp)) 280 return (FALSE); 281 return (TRUE); 282 } 283 284 bool_t 285 xdr_threshold4_write_size(XDR *xdrs, threshold4_write_size *objp) 286 { 287 if (!xdr_length4(xdrs, objp)) 288 return (FALSE); 289 return (TRUE); 290 } 291 292 bool_t 293 xdr_threshold4_read_iosize(XDR *xdrs, threshold4_read_iosize *objp) 294 { 295 if (!xdr_length4(xdrs, objp)) 296 return (FALSE); 297 return (TRUE); 298 } 299 300 bool_t 301 xdr_threshold4_write_iosize(XDR *xdrs, threshold4_write_iosize *objp) 302 { 303 if (!xdr_length4(xdrs, objp)) 304 return (FALSE); 305 return (TRUE); 306 } 307 308 bool_t 309 xdr_threshold_item4(XDR *xdrs, threshold_item4 *objp) 310 { 311 if (!xdr_layouttype4(xdrs, &objp->thi_layout_type)) 312 return (FALSE); 313 if (!xdr_bitmap4(xdrs, &objp->thi_hintset)) 314 return (FALSE); 315 if (!xdr_bytes(xdrs, (char **)&objp->thi_hintlist.thi_hintlist_val, 316 (uint_t *)&objp->thi_hintlist.thi_hintlist_len, ~0)) 317 return (FALSE); 318 return (TRUE); 319 } 320 321 bool_t 322 xdr_mdsthreshold4(XDR *xdrs, mdsthreshold4 *objp) 323 { 324 if (!xdr_array(xdrs, (char **)&objp->mth_hints.mth_hints_val, 325 (uint_t *)&objp->mth_hints.mth_hints_len, ~0, 326 sizeof (threshold_item4), (xdrproc_t)xdr_threshold_item4)) 327 return (FALSE); 328 return (TRUE); 329 } 330 331 bool_t 332 xdr_retention_get4(XDR *xdrs, retention_get4 *objp) 333 { 334 if (!xdr_uint64_t(xdrs, &objp->rg_duration)) 335 return (FALSE); 336 if (!xdr_array(xdrs, (char **)&objp->rg_begin_time.rg_begin_time_val, 337 (uint_t *)&objp->rg_begin_time.rg_begin_time_len, 1, 338 sizeof (nfstime4), (xdrproc_t)xdr_nfstime4)) 339 return (FALSE); 340 return (TRUE); 341 } 342 343 bool_t 344 xdr_retention_set4(XDR *xdrs, retention_set4 *objp) 345 { 346 if (!xdr_bool(xdrs, &objp->rs_enable)) 347 return (FALSE); 348 if (!xdr_array(xdrs, (char **)&objp->rs_duration.rs_duration_val, 349 (uint_t *)&objp->rs_duration.rs_duration_len, 1, sizeof (uint64_t), 350 (xdrproc_t)xdr_uint64_t)) 351 return (FALSE); 352 return (TRUE); 353 } 354 355 bool_t 356 xdr_fs_charset_cap4(XDR *xdrs, fs_charset_cap4 *objp) 357 { 358 359 if (!xdr_uint32_t(xdrs, objp)) 360 return (FALSE); 361 return (TRUE); 362 } 363 364 bool_t 365 xdr_netloc_type4(XDR *xdrs, netloc_type4 *objp) 366 { 367 368 if (!xdr_enum(xdrs, (enum_t *)objp)) 369 return (FALSE); 370 return (TRUE); 371 } 372 373 bool_t 374 xdr_netloc4(XDR *xdrs, netloc4 *objp) 375 { 376 377 if (!xdr_netloc_type4(xdrs, &objp->nl_type)) 378 return (FALSE); 379 switch (objp->nl_type) { 380 case NL4_NAME: 381 if (!xdr_utf8str_cis(xdrs, &objp->netloc4_u.nl_name)) 382 return (FALSE); 383 break; 384 case NL4_URL: 385 if (!xdr_utf8str_cis(xdrs, &objp->netloc4_u.nl_url)) 386 return (FALSE); 387 break; 388 case NL4_NETADDR: 389 if (!xdr_netaddr4(xdrs, &objp->netloc4_u.nl_addr)) 390 return (FALSE); 391 break; 392 default: 393 return (FALSE); 394 } 395 return (TRUE); 396 } 397 398 bool_t 399 xdr_change_attr_type4(XDR *xdrs, change_attr_type4 *objp) 400 { 401 402 if (!xdr_enum(xdrs, (enum_t *)objp)) 403 return (FALSE); 404 return (TRUE); 405 } 406 407 /* xdr_labelformat_spec4 */ 408 /* xdr_sec_label4 */ 409 410 bool_t 411 xdr_app_data_block4(XDR *xdrs, app_data_block4 *objp) 412 { 413 414 if (!xdr_offset4(xdrs, &objp->adb_offset)) 415 return (FALSE); 416 if (!xdr_length4(xdrs, &objp->adb_block_size)) 417 return (FALSE); 418 if (!xdr_length4(xdrs, &objp->adb_block_count)) 419 return (FALSE); 420 if (!xdr_length4(xdrs, &objp->adb_reloff_blocknum)) 421 return (FALSE); 422 if (!xdr_count4(xdrs, &objp->adb_block_num)) 423 return (FALSE); 424 if (!xdr_length4(xdrs, &objp->adb_reloff_pattern)) 425 return (FALSE); 426 if (!xdr_bytes(xdrs, (char **)&objp->adb_pattern.adb_pattern_val, 427 (uint_t *) &objp->adb_pattern.adb_pattern_len, ~0)) 428 return (FALSE); 429 return (TRUE); 430 } 431 432 bool_t 433 xdr_data4(XDR *xdrs, data4 *objp) 434 { 435 436 if (!xdr_offset4(xdrs, &objp->d_offset)) 437 return (FALSE); 438 if (!xdr_bytes(xdrs, (char **)&objp->d_data.d_data_val, 439 (uint_t *) &objp->d_data.d_data_len, ~0)) 440 return (FALSE); 441 return (TRUE); 442 } 443 444 bool_t 445 xdr_data_info4(XDR *xdrs, data_info4 *objp) 446 { 447 448 if (!xdr_offset4(xdrs, &objp->di_offset)) 449 return (FALSE); 450 if (!xdr_length4(xdrs, &objp->di_length)) 451 return (FALSE); 452 return (TRUE); 453 } 454 455 bool_t 456 xdr_data_content4(XDR *xdrs, data_content4 *objp) 457 { 458 459 if (!xdr_enum(xdrs, (enum_t *)objp)) 460 return (FALSE); 461 return (TRUE); 462 } 463 464 bool_t 465 xdr_stable_how4(XDR *xdrs, stable_how4 *objp) 466 { 467 468 if (!xdr_enum(xdrs, (enum_t *)objp)) 469 return (FALSE); 470 return (TRUE); 471 } 472 473 bool_t 474 xdr_write_response4(XDR *xdrs, write_response4 *objp) 475 { 476 477 if (!xdr_array(xdrs, (char **)&objp->wr_callback_id.wr_callback_id_val, 478 (uint_t *) &objp->wr_callback_id.wr_callback_id_len, 1, 479 sizeof (stateid4), (xdrproc_t)xdr_stateid4)) 480 return (FALSE); 481 if (!xdr_length4(xdrs, &objp->wr_count)) 482 return (FALSE); 483 if (!xdr_stable_how4(xdrs, &objp->wr_committed)) 484 return (FALSE); 485 if (!xdr_verifier4(xdrs, (verifier4 *)&objp->wr_writeverf)) 486 return (FALSE); 487 return (TRUE); 488 } 489 490 /* xdr_fattr4_supported_attrs */ 491 492 bool_t 493 xdr_fattr4_mode_set_masked(XDR *xdrs, fattr4_mode_set_masked *objp) 494 { 495 if (!xdr_mode_masked4(xdrs, objp)) 496 return (FALSE); 497 return (TRUE); 498 } 499 500 bool_t 501 xdr_fattr4_dir_notif_delay(XDR *xdrs, fattr4_dir_notif_delay *objp) 502 { 503 504 if (!xdr_nfstime4(xdrs, objp)) 505 return (FALSE); 506 return (TRUE); 507 } 508 509 bool_t 510 xdr_fattr4_dirent_notif_delay(XDR *xdrs, fattr4_dirent_notif_delay *objp) 511 { 512 if (!xdr_nfstime4(xdrs, objp)) 513 return (FALSE); 514 return (TRUE); 515 } 516 517 bool_t 518 xdr_fattr4_fs_layout_types(XDR *xdrs, fattr4_fs_layout_types *objp) 519 { 520 if (!xdr_array(xdrs, (char **)&objp->fattr4_fs_layout_types_val, 521 (uint_t *)&objp->fattr4_fs_layout_types_len, ~0, 522 sizeof (layouttype4), (xdrproc_t)xdr_layouttype4)) 523 return (FALSE); 524 return (TRUE); 525 } 526 527 bool_t 528 xdr_fattr4_fs_status(XDR *xdrs, fattr4_fs_status *objp) 529 { 530 if (!xdr_fs4_status(xdrs, objp)) 531 return (FALSE); 532 return (TRUE); 533 } 534 535 bool_t 536 xdr_fattr4_fs_charset_cap4(XDR *xdrs, fattr4_fs_charset_cap *objp) 537 { 538 if (!xdr_fs_charset_cap4(xdrs, objp)) 539 return (FALSE); 540 return (TRUE); 541 } 542 543 bool_t 544 xdr_fattr4_retention_get(XDR *xdrs, fattr4_retention_get *objp) 545 { 546 if (!xdr_retention_get4(xdrs, objp)) 547 return (FALSE); 548 return (TRUE); 549 } 550 551 bool_t 552 xdr_fattr4_retention_set(XDR *xdrs, fattr4_retention_set *objp) 553 { 554 if (!xdr_retention_set4(xdrs, objp)) 555 return (FALSE); 556 return (TRUE); 557 } 558 559 bool_t 560 xdr_fattr4_retentevt_get(XDR *xdrs, fattr4_retentevt_get *objp) 561 { 562 if (!xdr_retention_get4(xdrs, objp)) 563 return (FALSE); 564 return (TRUE); 565 } 566 567 bool_t 568 xdr_fattr4_retentevt_set(XDR *xdrs, fattr4_retentevt_set *objp) 569 { 570 if (!xdr_retention_set4(xdrs, objp)) 571 return (FALSE); 572 return (TRUE); 573 } 574 575 bool_t 576 xdr_fattr4_retention_hold(XDR *xdrs, fattr4_retention_hold *objp) 577 { 578 if (!xdr_uint64_t(xdrs, objp)) 579 return (FALSE); 580 return (TRUE); 581 } 582 583 bool_t 584 xdr_fattr4_dacl(XDR *xdrs, fattr4_dacl *objp) 585 { 586 if (!xdr_nfsacl41(xdrs, objp)) 587 return (FALSE); 588 return (TRUE); 589 } 590 591 bool_t 592 xdr_fattr4_sacl(XDR *xdrs, fattr4_sacl *objp) 593 { 594 if (!xdr_nfsacl41(xdrs, objp)) 595 return (FALSE); 596 return (TRUE); 597 } 598 599 bool_t 600 xdr_client_owner4(XDR *xdrs, client_owner4 *objp) 601 { 602 if (!xdr_verifier4(xdrs, (verifier4 *)&objp->co_verifier)) 603 return (FALSE); 604 if (!xdr_bytes(xdrs, (char **)&objp->co_ownerid.co_ownerid_val, 605 (uint_t *)&objp->co_ownerid.co_ownerid_len, NFS4_OPAQUE_LIMIT)) 606 return (FALSE); 607 return (TRUE); 608 } 609 610 bool_t 611 xdr_server_owner4(XDR *xdrs, server_owner4 *objp) 612 { 613 if (!xdr_uint64_t(xdrs, &objp->so_minor_id)) 614 return (FALSE); 615 if (!xdr_bytes(xdrs, (char **)&objp->so_major_id.so_major_id_val, 616 (uint_t *)&objp->so_major_id.so_major_id_len, NFS4_OPAQUE_LIMIT)) 617 return (FALSE); 618 return (TRUE); 619 } 620 621 bool_t 622 xdr_state_owner4(XDR *xdrs, state_owner4 *objp) 623 { 624 if (!xdr_clientid4(xdrs, &objp->clientid)) 625 return (FALSE); 626 if (!xdr_bytes(xdrs, (char **)&objp->owner.owner_val, 627 (uint_t *)&objp->owner.owner_len, NFS4_OPAQUE_LIMIT)) 628 return (FALSE); 629 return (TRUE); 630 } 631 632 /* Input for computing subkeys */ 633 634 bool_t 635 xdr_ssv_subkey4(XDR *xdrs, ssv_subkey4 *objp) 636 { 637 if (!xdr_enum(xdrs, (enum_t *)objp)) 638 return (FALSE); 639 return (TRUE); 640 } 641 642 643 /* Input for computing smt_hmac */ 644 645 bool_t 646 xdr_ssv_mic_plain_tkn4(XDR *xdrs, ssv_mic_plain_tkn4 *objp) 647 { 648 if (!xdr_uint32_t(xdrs, &objp->smpt_ssv_seq)) 649 return (FALSE); 650 if (!xdr_bytes(xdrs, 651 (char **)&objp->smpt_orig_plain.smpt_orig_plain_val, 652 (uint_t *)&objp->smpt_orig_plain.smpt_orig_plain_len, ~0)) 653 return (FALSE); 654 return (TRUE); 655 } 656 657 658 /* SSV GSS PerMsgToken token */ 659 660 bool_t 661 xdr_ssv_mic_tkn4(XDR *xdrs, ssv_mic_tkn4 *objp) 662 { 663 if (!xdr_uint32_t(xdrs, &objp->smt_ssv_seq)) 664 return (FALSE); 665 if (!xdr_bytes(xdrs, (char **)&objp->smt_hmac.smt_hmac_val, 666 (uint_t *)&objp->smt_hmac.smt_hmac_len, ~0)) 667 return (FALSE); 668 return (TRUE); 669 } 670 671 672 /* Input for computing ssct_encr_data and ssct_hmac */ 673 674 bool_t 675 xdr_ssv_seal_plain_tkn4(XDR *xdrs, ssv_seal_plain_tkn4 *objp) 676 { 677 if (!xdr_bytes(xdrs, 678 (char **)&objp->sspt_confounder.sspt_confounder_val, 679 (uint_t *)&objp->sspt_confounder.sspt_confounder_len, ~0)) 680 return (FALSE); 681 if (!xdr_uint32_t(xdrs, &objp->sspt_ssv_seq)) 682 return (FALSE); 683 if (!xdr_bytes(xdrs, 684 (char **)&objp->sspt_orig_plain.sspt_orig_plain_val, 685 (uint_t *)&objp->sspt_orig_plain.sspt_orig_plain_len, ~0)) 686 return (FALSE); 687 if (!xdr_bytes(xdrs, (char **)&objp->sspt_pad.sspt_pad_val, 688 (uint_t *)&objp->sspt_pad.sspt_pad_len, ~0)) 689 return (FALSE); 690 return (TRUE); 691 } 692 693 694 /* SSV GSS SealedMessage token */ 695 696 bool_t 697 xdr_ssv_seal_cipher_tkn4(XDR *xdrs, ssv_seal_cipher_tkn4 *objp) 698 { 699 if (!xdr_uint32_t(xdrs, &objp->ssct_ssv_seq)) 700 return (FALSE); 701 if (!xdr_bytes(xdrs, (char **)&objp->ssct_iv.ssct_iv_val, 702 (uint_t *)&objp->ssct_iv.ssct_iv_len, ~0)) 703 return (FALSE); 704 if (!xdr_bytes(xdrs, (char **)&objp->ssct_encr_data.ssct_encr_data_val, 705 (uint_t *)&objp->ssct_encr_data.ssct_encr_data_len, ~0)) 706 return (FALSE); 707 if (!xdr_bytes(xdrs, (char **)&objp->ssct_hmac.ssct_hmac_val, 708 (uint_t *)&objp->ssct_hmac.ssct_hmac_len, ~0)) 709 return (FALSE); 710 return (TRUE); 711 } 712 713 714 bool_t 715 xdr_fs_locations_server4(XDR *xdrs, fs_locations_server4 *objp) 716 { 717 if (!xdr_int32_t(xdrs, &objp->fls_currency)) 718 return (FALSE); 719 if (!xdr_bytes(xdrs, (char **)&objp->fls_info.fls_info_val, 720 (uint_t *)&objp->fls_info.fls_info_len, ~0)) 721 return (FALSE); 722 if (!xdr_utf8str_cis(xdrs, &objp->fls_server)) 723 return (FALSE); 724 return (TRUE); 725 } 726 727 bool_t 728 xdr_fs_locations_item4(XDR *xdrs, fs_locations_item4 *objp) 729 { 730 if (!xdr_array(xdrs, (char **)&objp->fli_entries.fli_entries_val, 731 (uint_t *)&objp->fli_entries.fli_entries_len, ~0, 732 sizeof (fs_locations_server4), (xdrproc_t)xdr_fs_locations_server4)) 733 return (FALSE); 734 if (!xdr_pathname4(xdrs, &objp->fli_rootpath)) 735 return (FALSE); 736 return (TRUE); 737 } 738 739 bool_t 740 xdr_fs_locations_info4(XDR *xdrs, fs_locations_info4 *objp) 741 { 742 if (!xdr_uint32_t(xdrs, &objp->fli_flags)) 743 return (FALSE); 744 if (!xdr_int32_t(xdrs, &objp->fli_valid_for)) 745 return (FALSE); 746 if (!xdr_pathname4(xdrs, &objp->fli_fs_root)) 747 return (FALSE); 748 if (!xdr_array(xdrs, (char **)&objp->fli_items.fli_items_val, 749 (uint_t *)&objp->fli_items.fli_items_len, ~0, 750 sizeof (fs_locations_item4), (xdrproc_t)xdr_fs_locations_item4)) 751 return (FALSE); 752 return (TRUE); 753 } 754 755 bool_t 756 xdr_fattr4_fs_locations_info(XDR *xdrs, fattr4_fs_locations_info *objp) 757 { 758 if (!xdr_fs_locations_info4(xdrs, objp)) 759 return (FALSE); 760 return (TRUE); 761 } 762 763 bool_t 764 xdr_nfl_util4(XDR *xdrs, nfl_util4 *objp) 765 { 766 if (!xdr_uint32_t(xdrs, objp)) 767 return (FALSE); 768 return (TRUE); 769 } 770 771 bool_t 772 xdr_filelayout_hint_care4(XDR *xdrs, filelayout_hint_care4 *objp) 773 { 774 if (!xdr_enum(xdrs, (enum_t *)objp)) 775 return (FALSE); 776 return (TRUE); 777 } 778 779 780 bool_t 781 xdr_multipath_list4(XDR *xdrs, multipath_list4 *objp) 782 { 783 if (!xdr_array(xdrs, (char **)&objp->multipath_list4_val, 784 (uint_t *)&objp->multipath_list4_len, ~0, 785 sizeof (netaddr4), (xdrproc_t)xdr_netaddr4)) 786 return (FALSE); 787 return (TRUE); 788 } 789 790 /* Encoded in the da_addr_body field of type device_addr4: */ 791 792 bool_t 793 xdr_nfsv4_1_file_layout_ds_addr4(XDR *xdrs, nfsv4_1_file_layout_ds_addr4 *objp) 794 { 795 if (!xdr_array(xdrs, 796 (char **)&objp->nflda_stripe_indices.nflda_stripe_indices_val, 797 (uint_t *)&objp->nflda_stripe_indices.nflda_stripe_indices_len, ~0, 798 sizeof (uint32_t), (xdrproc_t)xdr_uint32_t)) 799 return (FALSE); 800 if (!xdr_array(xdrs, 801 (char **)&objp->nflda_multipath_ds_list.nflda_multipath_ds_list_val, 802 (uint_t *)&objp->nflda_multipath_ds_list. 803 nflda_multipath_ds_list_len, ~0, sizeof (multipath_list4), 804 (xdrproc_t)xdr_multipath_list4)) 805 return (FALSE); 806 return (TRUE); 807 } 808 809 810 /* Encoded in the loc_body field of type layout_content4: */ 811 812 bool_t 813 xdr_nfsv4_1_file_layout4(XDR *xdrs, nfsv4_1_file_layout4 *objp) 814 { 815 if (!xdr_deviceid4(xdrs, objp->nfl_deviceid)) 816 return (FALSE); 817 if (!xdr_nfl_util4(xdrs, &objp->nfl_util)) 818 return (FALSE); 819 if (!xdr_uint32_t(xdrs, &objp->nfl_first_stripe_index)) 820 return (FALSE); 821 if (!xdr_offset4(xdrs, &objp->nfl_pattern_offset)) 822 return (FALSE); 823 if (!xdr_array(xdrs, (char **)&objp->nfl_fh_list.nfl_fh_list_val, 824 (uint_t *)&objp->nfl_fh_list.nfl_fh_list_len, ~0, 825 sizeof (nfs_fh4), (xdrproc_t)xdr_nfs_fh4)) 826 return (FALSE); 827 return (TRUE); 828 } 829 830 /* 831 * Encoded in the lou_body field of type layoutupdate4: 832 * Nothing. lou_body is a zero length array of octets. 833 */ 834 835 836 bool_t 837 xdr_creatverfattr(XDR *xdrs, creatverfattr *objp) 838 { 839 if (!xdr_verifier4(xdrs, (verifier4 *)&objp->cva_verf)) 840 return (FALSE); 841 if (!xdr_fattr4(xdrs, &objp->cva_attrs)) 842 return (FALSE); 843 return (TRUE); 844 } 845 846 bool_t 847 xdr_open_claim_delegate_cur4(XDR *xdrs, open_claim_delegate_cur4 *objp) 848 { 849 if (!xdr_stateid4(xdrs, &objp->delegate_stateid)) 850 return (FALSE); 851 if (!xdr_component4(xdrs, &objp->file)) 852 return (FALSE); 853 return (TRUE); 854 } 855 856 bool_t 857 xdr_open_claim4(XDR *xdrs, open_claim4 *objp) 858 { 859 if (!xdr_open_claim_type4(xdrs, &objp->claim)) 860 return (FALSE); 861 switch (objp->claim) { 862 case CLAIM_NULL: 863 if (!xdr_component4(xdrs, &objp->open_claim4_u.file)) 864 return (FALSE); 865 break; 866 case CLAIM_PREVIOUS: 867 if (!xdr_open_delegation_type4(xdrs, 868 &objp->open_claim4_u.delegate_type)) 869 return (FALSE); 870 break; 871 case CLAIM_DELEGATE_CUR: 872 if (!xdr_open_claim_delegate_cur4(xdrs, 873 &objp->open_claim4_u.delegate_cur_info)) 874 return (FALSE); 875 break; 876 case CLAIM_DELEGATE_PREV: 877 if (!xdr_component4(xdrs, 878 &objp->open_claim4_u.file_delegate_prev)) 879 return (FALSE); 880 break; 881 case CLAIM_FH: 882 break; 883 case CLAIM_DELEG_PREV_FH: 884 break; 885 case CLAIM_DELEG_CUR_FH: 886 if (!xdr_stateid4(xdrs, 887 &objp->open_claim4_u.oc_delegate_stateid)) 888 return (FALSE); 889 break; 890 default: 891 return (FALSE); 892 } 893 return (TRUE); 894 } 895 896 bool_t 897 xdr_why_no_delegation4(XDR *xdrs, why_no_delegation4 *objp) 898 { 899 if (!xdr_enum(xdrs, (enum_t *)objp)) 900 return (FALSE); 901 return (TRUE); 902 } 903 904 bool_t 905 xdr_open_none_delegation4(XDR *xdrs, open_none_delegation4 *objp) 906 { 907 if (!xdr_why_no_delegation4(xdrs, &objp->ond_why)) 908 return (FALSE); 909 switch (objp->ond_why) { 910 case WND4_CONTENTION: 911 if (!xdr_bool(xdrs, 912 &objp->open_none_delegation4_u.ond_server_will_push_deleg)) 913 return (FALSE); 914 break; 915 case WND4_RESOURCE: 916 if (!xdr_bool(xdrs, &objp->open_none_delegation4_u. 917 ond_server_will_signal_avail)) 918 return (FALSE); 919 break; 920 } 921 return (TRUE); 922 } 923 924 bool_t 925 xdr_open_delegation4(XDR *xdrs, open_delegation4 *objp) 926 { 927 if (!xdr_open_delegation_type4(xdrs, &objp->delegation_type)) 928 return (FALSE); 929 switch (objp->delegation_type) { 930 case OPEN_DELEGATE_NONE: 931 break; 932 case OPEN_DELEGATE_READ: 933 if (!xdr_open_read_delegation4(xdrs, 934 &objp->open_delegation4_u.read)) 935 return (FALSE); 936 break; 937 case OPEN_DELEGATE_WRITE: 938 if (!xdr_open_write_delegation4(xdrs, 939 &objp->open_delegation4_u.write)) 940 return (FALSE); 941 break; 942 case OPEN_DELEGATE_NONE_EXT: 943 if (!xdr_open_none_delegation4(xdrs, 944 &objp->open_delegation4_u.od_whynone)) 945 return (FALSE); 946 break; 947 default: 948 return (FALSE); 949 } 950 return (TRUE); 951 } 952 953 bool_t 954 xdr_gsshandle4_t(XDR *xdrs, gsshandle4_t *objp) 955 { 956 if (!xdr_bytes(xdrs, (char **)&objp->gsshandle4_t_val, 957 (uint_t *)&objp->gsshandle4_t_len, ~0)) 958 return (FALSE); 959 return (TRUE); 960 } 961 962 bool_t 963 xdr_gss_cb_handles4(XDR *xdrs, gss_cb_handles4 *objp) 964 { 965 if (!xdr_rpc_gss_svc_t(xdrs, &objp->gcbp_service)) 966 return (FALSE); 967 if (!xdr_gsshandle4_t(xdrs, &objp->gcbp_handle_from_server)) 968 return (FALSE); 969 if (!xdr_gsshandle4_t(xdrs, &objp->gcbp_handle_from_client)) 970 return (FALSE); 971 return (TRUE); 972 } 973 974 bool_t 975 xdr_callback_sec_parms4(XDR *xdrs, callback_sec_parms4 *objp) 976 { 977 if (!xdr_uint32_t(xdrs, &objp->cb_secflavor)) 978 return (FALSE); 979 switch (objp->cb_secflavor) { 980 case AUTH_NONE: 981 break; 982 case AUTH_SYS: 983 if (!xdr_authsys_parms(xdrs, 984 &objp->callback_sec_parms4_u.cbsp_sys_cred)) 985 return (FALSE); 986 break; 987 case RPCSEC_GSS: 988 if (!xdr_gss_cb_handles4(xdrs, 989 &objp->callback_sec_parms4_u.cbsp_gss_handles)) 990 return (FALSE); 991 break; 992 default: 993 return (FALSE); 994 } 995 return (TRUE); 996 } 997 998 bool_t 999 xdr_BACKCHANNEL_CTL4args(XDR *xdrs, BACKCHANNEL_CTL4args *objp) 1000 { 1001 if (!xdr_uint32_t(xdrs, &objp->bca_cb_program)) 1002 return (FALSE); 1003 if (!xdr_array(xdrs, (char **)&objp->bca_sec_parms.bca_sec_parms_val, 1004 (uint_t *)&objp->bca_sec_parms.bca_sec_parms_len, ~0, 1005 sizeof (callback_sec_parms4), (xdrproc_t)xdr_callback_sec_parms4)) 1006 return (FALSE); 1007 return (TRUE); 1008 } 1009 1010 bool_t 1011 xdr_BACKCHANNEL_CTL4res(XDR *xdrs, BACKCHANNEL_CTL4res *objp) 1012 { 1013 if (!xdr_nfsstat4(xdrs, &objp->bcr_status)) 1014 return (FALSE); 1015 return (TRUE); 1016 } 1017 1018 bool_t 1019 xdr_channel_dir_from_client4(XDR *xdrs, channel_dir_from_client4 *objp) 1020 { 1021 if (!xdr_enum(xdrs, (enum_t *)objp)) 1022 return (FALSE); 1023 return (TRUE); 1024 } 1025 1026 bool_t 1027 xdr_BIND_CONN_TO_SESSION4args(XDR *xdrs, BIND_CONN_TO_SESSION4args *objp) 1028 { 1029 if (!xdr_sessionid4(xdrs, objp->bctsa_sessid)) 1030 return (FALSE); 1031 if (!xdr_channel_dir_from_client4(xdrs, &objp->bctsa_dir)) 1032 return (FALSE); 1033 if (!xdr_bool(xdrs, &objp->bctsa_use_conn_in_rdma_mode)) 1034 return (FALSE); 1035 return (TRUE); 1036 } 1037 1038 bool_t 1039 xdr_channel_dir_from_server4(XDR *xdrs, channel_dir_from_server4 *objp) 1040 { 1041 if (!xdr_enum(xdrs, (enum_t *)objp)) 1042 return (FALSE); 1043 return (TRUE); 1044 } 1045 1046 bool_t 1047 xdr_BIND_CONN_TO_SESSION4resok(XDR *xdrs, BIND_CONN_TO_SESSION4resok *objp) 1048 { 1049 if (!xdr_sessionid4(xdrs, objp->bctsr_sessid)) 1050 return (FALSE); 1051 if (!xdr_channel_dir_from_server4(xdrs, &objp->bctsr_dir)) 1052 return (FALSE); 1053 if (!xdr_bool(xdrs, &objp->bctsr_use_conn_in_rdma_mode)) 1054 return (FALSE); 1055 return (TRUE); 1056 } 1057 1058 bool_t 1059 xdr_BIND_CONN_TO_SESSION4res(XDR *xdrs, BIND_CONN_TO_SESSION4res *objp) 1060 { 1061 if (!xdr_nfsstat4(xdrs, &objp->bctsr_status)) 1062 return (FALSE); 1063 switch (objp->bctsr_status) { 1064 case NFS4_OK: 1065 if (!xdr_BIND_CONN_TO_SESSION4resok(xdrs, 1066 &objp->BIND_CONN_TO_SESSION4res_u.bctsr_resok4)) 1067 return (FALSE); 1068 break; 1069 } 1070 return (TRUE); 1071 } 1072 1073 bool_t 1074 xdr_state_protect_ops4(XDR *xdrs, state_protect_ops4 *objp) 1075 { 1076 if (!xdr_bitmap4(xdrs, &objp->spo_must_enforce)) 1077 return (FALSE); 1078 if (!xdr_bitmap4(xdrs, &objp->spo_must_allow)) 1079 return (FALSE); 1080 return (TRUE); 1081 } 1082 1083 bool_t 1084 xdr_ssv_sp_parms4(XDR *xdrs, ssv_sp_parms4 *objp) 1085 { 1086 if (!xdr_state_protect_ops4(xdrs, &objp->ssp_ops)) 1087 return (FALSE); 1088 if (!xdr_array(xdrs, (char **)&objp->ssp_hash_algs.ssp_hash_algs_val, 1089 (uint_t *)&objp->ssp_hash_algs.ssp_hash_algs_len, ~0, 1090 sizeof (sec_oid4), (xdrproc_t)xdr_sec_oid4)) 1091 return (FALSE); 1092 if (!xdr_array(xdrs, (char **)&objp->ssp_encr_algs.ssp_encr_algs_val, 1093 (uint_t *)&objp->ssp_encr_algs.ssp_encr_algs_len, ~0, 1094 sizeof (sec_oid4), (xdrproc_t)xdr_sec_oid4)) 1095 return (FALSE); 1096 if (!xdr_uint32_t(xdrs, &objp->ssp_window)) 1097 return (FALSE); 1098 if (!xdr_uint32_t(xdrs, &objp->ssp_num_gss_handles)) 1099 return (FALSE); 1100 return (TRUE); 1101 } 1102 1103 bool_t 1104 xdr_state_protect_how4(XDR *xdrs, state_protect_how4 *objp) 1105 { 1106 if (!xdr_enum(xdrs, (enum_t *)objp)) 1107 return (FALSE); 1108 return (TRUE); 1109 } 1110 1111 bool_t 1112 xdr_state_protect4_a(XDR *xdrs, state_protect4_a *objp) 1113 { 1114 if (!xdr_state_protect_how4(xdrs, &objp->spa_how)) 1115 return (FALSE); 1116 switch (objp->spa_how) { 1117 case SP4_NONE: 1118 break; 1119 case SP4_MACH_CRED: 1120 if (!xdr_state_protect_ops4(xdrs, 1121 &objp->state_protect4_a_u.spa_mach_ops)) 1122 return (FALSE); 1123 break; 1124 case SP4_SSV: 1125 if (!xdr_ssv_sp_parms4(xdrs, 1126 &objp->state_protect4_a_u.spa_ssv_parms)) 1127 return (FALSE); 1128 break; 1129 default: 1130 return (FALSE); 1131 } 1132 return (TRUE); 1133 } 1134 1135 bool_t 1136 xdr_EXCHANGE_ID4args(XDR *xdrs, EXCHANGE_ID4args *objp) 1137 { 1138 if (!xdr_client_owner4(xdrs, &objp->eia_clientowner)) 1139 return (FALSE); 1140 if (!xdr_uint32_t(xdrs, &objp->eia_flags)) 1141 return (FALSE); 1142 if (!xdr_state_protect4_a(xdrs, &objp->eia_state_protect)) 1143 return (FALSE); 1144 if (!xdr_array(xdrs, 1145 (char **)&objp->eia_client_impl_id.eia_client_impl_id_val, 1146 (uint_t *)&objp->eia_client_impl_id.eia_client_impl_id_len, 1, 1147 sizeof (nfs_impl_id4), (xdrproc_t)xdr_nfs_impl_id4)) 1148 return (FALSE); 1149 return (TRUE); 1150 } 1151 1152 bool_t 1153 xdr_ssv_prot_info4(XDR *xdrs, ssv_prot_info4 *objp) 1154 { 1155 if (!xdr_state_protect_ops4(xdrs, &objp->spi_ops)) 1156 return (FALSE); 1157 if (!xdr_uint32_t(xdrs, &objp->spi_hash_alg)) 1158 return (FALSE); 1159 if (!xdr_uint32_t(xdrs, &objp->spi_encr_alg)) 1160 return (FALSE); 1161 if (!xdr_uint32_t(xdrs, &objp->spi_ssv_len)) 1162 return (FALSE); 1163 if (!xdr_uint32_t(xdrs, &objp->spi_window)) 1164 return (FALSE); 1165 if (!xdr_array(xdrs, (char **)&objp->spi_handles.spi_handles_val, 1166 (uint_t *)&objp->spi_handles.spi_handles_len, ~0, 1167 sizeof (gsshandle4_t), (xdrproc_t)xdr_gsshandle4_t)) 1168 return (FALSE); 1169 return (TRUE); 1170 } 1171 1172 bool_t 1173 xdr_state_protect4_r(XDR *xdrs, state_protect4_r *objp) 1174 { 1175 if (!xdr_state_protect_how4(xdrs, &objp->spr_how)) 1176 return (FALSE); 1177 switch (objp->spr_how) { 1178 case SP4_NONE: 1179 break; 1180 case SP4_MACH_CRED: 1181 if (!xdr_state_protect_ops4(xdrs, 1182 &objp->state_protect4_r_u.spr_mach_ops)) 1183 return (FALSE); 1184 break; 1185 case SP4_SSV: 1186 if (!xdr_ssv_prot_info4(xdrs, 1187 &objp->state_protect4_r_u.spr_ssv_info)) 1188 return (FALSE); 1189 break; 1190 default: 1191 return (FALSE); 1192 } 1193 return (TRUE); 1194 } 1195 1196 bool_t 1197 xdr_EXCHANGE_ID4resok(XDR *xdrs, EXCHANGE_ID4resok *objp) 1198 { 1199 if (!xdr_clientid4(xdrs, &objp->eir_clientid)) 1200 return (FALSE); 1201 if (!xdr_sequenceid4(xdrs, &objp->eir_sequenceid)) 1202 return (FALSE); 1203 if (!xdr_uint32_t(xdrs, &objp->eir_flags)) 1204 return (FALSE); 1205 if (!xdr_state_protect4_r(xdrs, &objp->eir_state_protect)) 1206 return (FALSE); 1207 if (!xdr_server_owner4(xdrs, &objp->eir_server_owner)) 1208 return (FALSE); 1209 if (!xdr_bytes(xdrs, 1210 (char **)&objp->eir_server_scope.eir_server_scope_val, 1211 (uint_t *)&objp->eir_server_scope.eir_server_scope_len, 1212 NFS4_OPAQUE_LIMIT)) 1213 return (FALSE); 1214 if (!xdr_array(xdrs, 1215 (char **)&objp->eir_server_impl_id.eir_server_impl_id_val, 1216 (uint_t *)&objp->eir_server_impl_id.eir_server_impl_id_len, 1, 1217 sizeof (nfs_impl_id4), (xdrproc_t)xdr_nfs_impl_id4)) 1218 return (FALSE); 1219 return (TRUE); 1220 } 1221 1222 bool_t 1223 xdr_EXCHANGE_ID4res(XDR *xdrs, EXCHANGE_ID4res *objp) 1224 { 1225 if (!xdr_nfsstat4(xdrs, &objp->eir_status)) 1226 return (FALSE); 1227 switch (objp->eir_status) { 1228 case NFS4_OK: 1229 if (!xdr_EXCHANGE_ID4resok(xdrs, 1230 &objp->EXCHANGE_ID4res_u.eir_resok4)) 1231 return (FALSE); 1232 break; 1233 } 1234 return (TRUE); 1235 } 1236 1237 bool_t 1238 xdr_channel_attrs4(XDR *xdrs, channel_attrs4 *objp) 1239 { 1240 if (!xdr_count4(xdrs, &objp->ca_headerpadsize)) 1241 return (FALSE); 1242 if (!xdr_count4(xdrs, &objp->ca_maxrequestsize)) 1243 return (FALSE); 1244 if (!xdr_count4(xdrs, &objp->ca_maxresponsesize)) 1245 return (FALSE); 1246 if (!xdr_count4(xdrs, &objp->ca_maxresponsesize_cached)) 1247 return (FALSE); 1248 if (!xdr_count4(xdrs, &objp->ca_maxoperations)) 1249 return (FALSE); 1250 if (!xdr_count4(xdrs, &objp->ca_maxrequests)) 1251 return (FALSE); 1252 if (!xdr_array(xdrs, (char **)&objp->ca_rdma_ird.ca_rdma_ird_val, 1253 (uint_t *)&objp->ca_rdma_ird.ca_rdma_ird_len, 1, 1254 sizeof (uint32_t), (xdrproc_t)xdr_uint32_t)) 1255 return (FALSE); 1256 return (TRUE); 1257 } 1258 1259 bool_t 1260 xdr_CREATE_SESSION4args(XDR *xdrs, CREATE_SESSION4args *objp) 1261 { 1262 1263 if (!xdr_clientid4(xdrs, &objp->csa_clientid)) 1264 return (FALSE); 1265 if (!xdr_sequenceid4(xdrs, &objp->csa_sequence)) 1266 return (FALSE); 1267 if (!xdr_uint32_t(xdrs, &objp->csa_flags)) 1268 return (FALSE); 1269 if (!xdr_channel_attrs4(xdrs, &objp->csa_fore_chan_attrs)) 1270 return (FALSE); 1271 if (!xdr_channel_attrs4(xdrs, &objp->csa_back_chan_attrs)) 1272 return (FALSE); 1273 if (!xdr_uint32_t(xdrs, &objp->csa_cb_program)) 1274 return (FALSE); 1275 if (!xdr_array(xdrs, (char **)&objp->csa_sec_parms.csa_sec_parms_val, 1276 (uint_t *)&objp->csa_sec_parms.csa_sec_parms_len, ~0, 1277 sizeof (callback_sec_parms4), (xdrproc_t)xdr_callback_sec_parms4)) 1278 return (FALSE); 1279 return (TRUE); 1280 } 1281 1282 bool_t 1283 xdr_CREATE_SESSION4resok(XDR *xdrs, CREATE_SESSION4resok *objp) 1284 { 1285 if (!xdr_sessionid4(xdrs, objp->csr_sessionid)) 1286 return (FALSE); 1287 if (!xdr_sequenceid4(xdrs, &objp->csr_sequence)) 1288 return (FALSE); 1289 if (!xdr_uint32_t(xdrs, &objp->csr_flags)) 1290 return (FALSE); 1291 if (!xdr_channel_attrs4(xdrs, &objp->csr_fore_chan_attrs)) 1292 return (FALSE); 1293 if (!xdr_channel_attrs4(xdrs, &objp->csr_back_chan_attrs)) 1294 return (FALSE); 1295 return (TRUE); 1296 } 1297 1298 bool_t 1299 xdr_CREATE_SESSION4res(XDR *xdrs, CREATE_SESSION4res *objp) 1300 { 1301 if (!xdr_nfsstat4(xdrs, &objp->csr_status)) 1302 return (FALSE); 1303 switch (objp->csr_status) { 1304 case NFS4_OK: 1305 if (!xdr_CREATE_SESSION4resok(xdrs, 1306 &objp->CREATE_SESSION4res_u.csr_resok4)) 1307 return (FALSE); 1308 break; 1309 } 1310 return (TRUE); 1311 } 1312 1313 bool_t 1314 xdr_DESTROY_SESSION4args(XDR *xdrs, DESTROY_SESSION4args *objp) 1315 { 1316 if (!xdr_sessionid4(xdrs, objp->dsa_sessionid)) 1317 return (FALSE); 1318 return (TRUE); 1319 } 1320 1321 bool_t 1322 xdr_DESTROY_SESSION4res(XDR *xdrs, DESTROY_SESSION4res *objp) 1323 { 1324 if (!xdr_nfsstat4(xdrs, &objp->dsr_status)) 1325 return (FALSE); 1326 return (TRUE); 1327 } 1328 1329 bool_t 1330 xdr_FREE_STATEID4args(XDR *xdrs, FREE_STATEID4args *objp) 1331 { 1332 if (!xdr_stateid4(xdrs, &objp->fsa_stateid)) 1333 return (FALSE); 1334 return (TRUE); 1335 } 1336 1337 bool_t 1338 xdr_FREE_STATEID4res(XDR *xdrs, FREE_STATEID4res *objp) 1339 { 1340 if (!xdr_nfsstat4(xdrs, &objp->fsr_status)) 1341 return (FALSE); 1342 return (TRUE); 1343 } 1344 1345 bool_t 1346 xdr_attr_notice4(XDR *xdrs, attr_notice4 *objp) 1347 { 1348 if (!xdr_nfstime4(xdrs, objp)) 1349 return (FALSE); 1350 return (TRUE); 1351 } 1352 1353 bool_t 1354 xdr_GET_DIR_DELEGATION4args(XDR *xdrs, GET_DIR_DELEGATION4args *objp) 1355 { 1356 if (!xdr_bool(xdrs, &objp->gdda_signal_deleg_avail)) 1357 return (FALSE); 1358 if (!xdr_bitmap4(xdrs, &objp->gdda_notification_types)) 1359 return (FALSE); 1360 if (!xdr_attr_notice4(xdrs, &objp->gdda_child_attr_delay)) 1361 return (FALSE); 1362 if (!xdr_attr_notice4(xdrs, &objp->gdda_dir_attr_delay)) 1363 return (FALSE); 1364 if (!xdr_bitmap4(xdrs, &objp->gdda_child_attributes)) 1365 return (FALSE); 1366 if (!xdr_bitmap4(xdrs, &objp->gdda_dir_attributes)) 1367 return (FALSE); 1368 return (TRUE); 1369 } 1370 1371 bool_t 1372 xdr_GET_DIR_DELEGATION4resok(XDR *xdrs, GET_DIR_DELEGATION4resok *objp) 1373 { 1374 if (!xdr_verifier4(xdrs, (verifier4 *)&objp->gddr_cookieverf)) 1375 return (FALSE); 1376 if (!xdr_stateid4(xdrs, &objp->gddr_stateid)) 1377 return (FALSE); 1378 if (!xdr_bitmap4(xdrs, &objp->gddr_notification)) 1379 return (FALSE); 1380 if (!xdr_bitmap4(xdrs, &objp->gddr_child_attributes)) 1381 return (FALSE); 1382 if (!xdr_bitmap4(xdrs, &objp->gddr_dir_attributes)) 1383 return (FALSE); 1384 return (TRUE); 1385 } 1386 1387 bool_t 1388 xdr_gddrnf4_status(XDR *xdrs, gddrnf4_status *objp) 1389 { 1390 if (!xdr_enum(xdrs, (enum_t *)objp)) 1391 return (FALSE); 1392 return (TRUE); 1393 } 1394 1395 bool_t 1396 xdr_GET_DIR_DELEGATION4res_non_fatal(XDR *xdrs, 1397 GET_DIR_DELEGATION4res_non_fatal *objp) 1398 { 1399 if (!xdr_gddrnf4_status(xdrs, &objp->gddrnf_status)) 1400 return (FALSE); 1401 switch (objp->gddrnf_status) { 1402 case GDD4_OK: 1403 if (!xdr_GET_DIR_DELEGATION4resok(xdrs, 1404 &objp->GET_DIR_DELEGATION4res_non_fatal_u.gddrnf_resok4)) 1405 return (FALSE); 1406 break; 1407 case GDD4_UNAVAIL: 1408 if (!xdr_bool(xdrs, &objp->GET_DIR_DELEGATION4res_non_fatal_u. 1409 gddrnf_will_signal_deleg_avail)) 1410 return (FALSE); 1411 break; 1412 default: 1413 return (FALSE); 1414 } 1415 return (TRUE); 1416 } 1417 1418 bool_t 1419 xdr_GET_DIR_DELEGATION4res(XDR *xdrs, GET_DIR_DELEGATION4res *objp) 1420 { 1421 if (!xdr_nfsstat4(xdrs, &objp->gddr_status)) 1422 return (FALSE); 1423 switch (objp->gddr_status) { 1424 case NFS4_OK: 1425 if (!xdr_GET_DIR_DELEGATION4res_non_fatal(xdrs, 1426 &objp->GET_DIR_DELEGATION4res_u.gddr_res_non_fatal4)) 1427 return (FALSE); 1428 break; 1429 } 1430 return (TRUE); 1431 } 1432 1433 /* 1434 * Special xdr function to encode single word bitmaps for 1435 * notification bitmaps which only need a single word. 1436 */ 1437 bool_t 1438 xdr_bitmap4_notify(XDR *xdrs, bitmap4 *objp) 1439 { 1440 int32_t len = 1; 1441 1442 ASSERT(xdrs->x_op == XDR_ENCODE); 1443 if (!XDR_PUTINT32(xdrs, &len)) 1444 return (FALSE); 1445 #if defined(_BIG_ENDIAN) 1446 return (XDR_PUTINT32(xdrs, (int32_t *)objp)); 1447 #elif defined(_LITTLE_ENDIAN) 1448 return (XDR_PUTINT32(xdrs, (int32_t *)objp+1)); 1449 #endif 1450 } 1451 1452 bool_t 1453 xdr_GETDEVICEINFO4args(XDR *xdrs, GETDEVICEINFO4args *objp) 1454 { 1455 if (!xdr_deviceid4(xdrs, objp->gdia_device_id)) 1456 return (FALSE); 1457 if (!xdr_layouttype4(xdrs, &objp->gdia_layout_type)) 1458 return (FALSE); 1459 if (!xdr_count4(xdrs, &objp->gdia_maxcount)) 1460 return (FALSE); 1461 if (xdrs->x_op == XDR_ENCODE) { 1462 if (!xdr_bitmap4_notify(xdrs, &objp->gdia_notify_types)) 1463 return (FALSE); 1464 } else 1465 if (!xdr_bitmap4(xdrs, &objp->gdia_notify_types)) 1466 return (FALSE); 1467 return (TRUE); 1468 } 1469 1470 bool_t 1471 xdr_GETDEVICEINFO4resok(XDR *xdrs, GETDEVICEINFO4resok *objp) 1472 { 1473 if (!xdr_device_addr4(xdrs, &objp->gdir_device_addr)) 1474 return (FALSE); 1475 if (xdrs->x_op == XDR_ENCODE) { 1476 if (!xdr_bitmap4_notify(xdrs, &objp->gdir_notification)) 1477 return (FALSE); 1478 } else 1479 if (!xdr_bitmap4(xdrs, &objp->gdir_notification)) 1480 return (FALSE); 1481 return (TRUE); 1482 } 1483 1484 bool_t 1485 xdr_GETDEVICEINFO4res(XDR *xdrs, GETDEVICEINFO4res *objp) 1486 { 1487 if (!xdr_nfsstat4(xdrs, &objp->gdir_status)) 1488 return (FALSE); 1489 switch (objp->gdir_status) { 1490 case NFS4_OK: 1491 if (!xdr_GETDEVICEINFO4resok(xdrs, 1492 &objp->GETDEVICEINFO4res_u.gdir_resok4)) 1493 return (FALSE); 1494 break; 1495 case NFS4ERR_TOOSMALL: 1496 if (!xdr_count4(xdrs, &objp->GETDEVICEINFO4res_u.gdir_mincount)) 1497 return (FALSE); 1498 break; 1499 } 1500 return (TRUE); 1501 } 1502 1503 bool_t 1504 xdr_GETDEVICELIST4args(XDR *xdrs, GETDEVICELIST4args *objp) 1505 { 1506 if (!xdr_layouttype4(xdrs, &objp->gdla_layout_type)) 1507 return (FALSE); 1508 if (!xdr_count4(xdrs, &objp->gdla_maxdevices)) 1509 return (FALSE); 1510 if (!xdr_nfs_cookie4(xdrs, &objp->gdla_cookie)) 1511 return (FALSE); 1512 if (!xdr_verifier4(xdrs, (verifier4 *)&objp->gdla_cookieverf)) 1513 return (FALSE); 1514 return (TRUE); 1515 } 1516 1517 bool_t 1518 xdr_GETDEVICELIST4resok(XDR *xdrs, GETDEVICELIST4resok *objp) 1519 { 1520 if (!xdr_nfs_cookie4(xdrs, &objp->gdlr_cookie)) 1521 return (FALSE); 1522 if (!xdr_verifier4(xdrs, (verifier4 *)&objp->gdlr_cookieverf)) 1523 return (FALSE); 1524 if (!xdr_array(xdrs, 1525 (char **)&objp->gdlr_deviceid_list.gdlr_deviceid_list_val, 1526 (uint_t *)&objp->gdlr_deviceid_list.gdlr_deviceid_list_len, 1527 ~0, sizeof (deviceid4), (xdrproc_t)xdr_deviceid4)) 1528 return (FALSE); 1529 if (!xdr_bool(xdrs, &objp->gdlr_eof)) 1530 return (FALSE); 1531 return (TRUE); 1532 } 1533 1534 bool_t 1535 xdr_GETDEVICELIST4res(XDR *xdrs, GETDEVICELIST4res *objp) 1536 { 1537 if (!xdr_nfsstat4(xdrs, &objp->gdlr_status)) 1538 return (FALSE); 1539 switch (objp->gdlr_status) { 1540 case NFS4_OK: 1541 if (!xdr_GETDEVICELIST4resok(xdrs, 1542 &objp->GETDEVICELIST4res_u.gdlr_resok4)) 1543 return (FALSE); 1544 break; 1545 default: 1546 break; 1547 } 1548 return (TRUE); 1549 } 1550 1551 bool_t 1552 xdr_newtime4(XDR *xdrs, newtime4 *objp) 1553 { 1554 if (!xdr_bool(xdrs, &objp->nt_timechanged)) 1555 return (FALSE); 1556 switch (objp->nt_timechanged) { 1557 case TRUE: 1558 if (!xdr_nfstime4(xdrs, &objp->newtime4_u.nt_time)) 1559 return (FALSE); 1560 break; 1561 case FALSE: 1562 break; 1563 default: 1564 return (FALSE); 1565 } 1566 return (TRUE); 1567 } 1568 1569 bool_t 1570 xdr_newoffset4(XDR *xdrs, newoffset4 *objp) 1571 { 1572 if (!xdr_bool(xdrs, &objp->no_newoffset)) 1573 return (FALSE); 1574 switch (objp->no_newoffset) { 1575 case TRUE: 1576 if (!xdr_offset4(xdrs, &objp->newoffset4_u.no_offset)) 1577 return (FALSE); 1578 break; 1579 case FALSE: 1580 break; 1581 default: 1582 return (FALSE); 1583 } 1584 return (TRUE); 1585 } 1586 1587 bool_t 1588 xdr_LAYOUTCOMMIT4args(XDR *xdrs, LAYOUTCOMMIT4args *objp) 1589 { 1590 if (!xdr_offset4(xdrs, &objp->loca_offset)) 1591 return (FALSE); 1592 if (!xdr_length4(xdrs, &objp->loca_length)) 1593 return (FALSE); 1594 if (!xdr_bool(xdrs, &objp->loca_reclaim)) 1595 return (FALSE); 1596 if (!xdr_stateid4(xdrs, &objp->loca_stateid)) 1597 return (FALSE); 1598 if (!xdr_newoffset4(xdrs, &objp->loca_last_write_offset)) 1599 return (FALSE); 1600 if (!xdr_newtime4(xdrs, &objp->loca_time_modify)) 1601 return (FALSE); 1602 if (!xdr_layoutupdate4(xdrs, &objp->loca_layoutupdate)) 1603 return (FALSE); 1604 return (TRUE); 1605 } 1606 1607 bool_t 1608 xdr_newsize4(XDR *xdrs, newsize4 *objp) 1609 { 1610 if (!xdr_bool(xdrs, &objp->ns_sizechanged)) 1611 return (FALSE); 1612 switch (objp->ns_sizechanged) { 1613 case TRUE: 1614 if (!xdr_length4(xdrs, &objp->newsize4_u.ns_size)) 1615 return (FALSE); 1616 break; 1617 case FALSE: 1618 break; 1619 default: 1620 return (FALSE); 1621 } 1622 return (TRUE); 1623 } 1624 1625 bool_t 1626 xdr_LAYOUTCOMMIT4resok(XDR *xdrs, LAYOUTCOMMIT4resok *objp) 1627 { 1628 if (!xdr_newsize4(xdrs, &objp->locr_newsize)) 1629 return (FALSE); 1630 return (TRUE); 1631 } 1632 1633 bool_t 1634 xdr_LAYOUTCOMMIT4res(XDR *xdrs, LAYOUTCOMMIT4res *objp) 1635 { 1636 if (!xdr_nfsstat4(xdrs, &objp->locr_status)) 1637 return (FALSE); 1638 switch (objp->locr_status) { 1639 case NFS4_OK: 1640 if (!xdr_LAYOUTCOMMIT4resok(xdrs, 1641 &objp->LAYOUTCOMMIT4res_u.locr_resok4)) 1642 return (FALSE); 1643 break; 1644 } 1645 return (TRUE); 1646 } 1647 1648 bool_t 1649 xdr_LAYOUTGET4args(XDR *xdrs, LAYOUTGET4args *objp) 1650 { 1651 if (!xdr_bool(xdrs, &objp->loga_signal_layout_avail)) 1652 return (FALSE); 1653 if (!xdr_layouttype4(xdrs, &objp->loga_layout_type)) 1654 return (FALSE); 1655 if (!xdr_layoutiomode4(xdrs, &objp->loga_iomode)) 1656 return (FALSE); 1657 if (!xdr_offset4(xdrs, &objp->loga_offset)) 1658 return (FALSE); 1659 if (!xdr_length4(xdrs, &objp->loga_length)) 1660 return (FALSE); 1661 if (!xdr_length4(xdrs, &objp->loga_minlength)) 1662 return (FALSE); 1663 if (!xdr_stateid4(xdrs, &objp->loga_stateid)) 1664 return (FALSE); 1665 if (!xdr_count4(xdrs, &objp->loga_maxcount)) 1666 return (FALSE); 1667 return (TRUE); 1668 } 1669 1670 bool_t 1671 xdr_LAYOUTGET4resok(XDR *xdrs, LAYOUTGET4resok *objp) 1672 { 1673 if (!xdr_bool(xdrs, &objp->logr_return_on_close)) 1674 return (FALSE); 1675 if (!xdr_stateid4(xdrs, &objp->logr_stateid)) 1676 return (FALSE); 1677 if (!xdr_array(xdrs, (char **)&objp->logr_layout.logr_layout_val, 1678 (uint_t *)&objp->logr_layout.logr_layout_len, ~0, 1679 sizeof (layout4), (xdrproc_t)xdr_layout4)) 1680 return (FALSE); 1681 return (TRUE); 1682 } 1683 1684 bool_t 1685 xdr_LAYOUTGET4res(XDR *xdrs, LAYOUTGET4res *objp) 1686 { 1687 if (!xdr_nfsstat4(xdrs, &objp->logr_status)) 1688 return (FALSE); 1689 switch (objp->logr_status) { 1690 case NFS4_OK: 1691 if (!xdr_LAYOUTGET4resok(xdrs, 1692 &objp->LAYOUTGET4res_u.logr_resok4)) 1693 return (FALSE); 1694 break; 1695 case NFS4ERR_LAYOUTTRYLATER: 1696 if (!xdr_bool(xdrs, 1697 &objp->LAYOUTGET4res_u.logr_will_signal_layout_avail)) 1698 return (FALSE); 1699 break; 1700 } 1701 return (TRUE); 1702 } 1703 1704 bool_t 1705 xdr_LAYOUTRETURN4args(XDR *xdrs, LAYOUTRETURN4args *objp) 1706 { 1707 if (!xdr_bool(xdrs, &objp->lora_reclaim)) 1708 return (FALSE); 1709 if (!xdr_layouttype4(xdrs, &objp->lora_layout_type)) 1710 return (FALSE); 1711 if (!xdr_layoutiomode4(xdrs, &objp->lora_iomode)) 1712 return (FALSE); 1713 if (!xdr_layoutreturn4(xdrs, &objp->lora_layoutreturn)) 1714 return (FALSE); 1715 return (TRUE); 1716 } 1717 1718 bool_t 1719 xdr_layoutreturn_stateid(XDR *xdrs, layoutreturn_stateid *objp) 1720 { 1721 if (!xdr_bool(xdrs, &objp->lrs_present)) 1722 return (FALSE); 1723 switch (objp->lrs_present) { 1724 case TRUE: 1725 if (!xdr_stateid4(xdrs, 1726 &objp->layoutreturn_stateid_u.lrs_stateid)) 1727 return (FALSE); 1728 break; 1729 case FALSE: 1730 break; 1731 default: 1732 return (FALSE); 1733 } 1734 return (TRUE); 1735 } 1736 1737 bool_t 1738 xdr_LAYOUTRETURN4res(XDR *xdrs, LAYOUTRETURN4res *objp) 1739 { 1740 if (!xdr_nfsstat4(xdrs, &objp->lorr_status)) 1741 return (FALSE); 1742 switch (objp->lorr_status) { 1743 case NFS4_OK: 1744 if (!xdr_layoutreturn_stateid(xdrs, 1745 &objp->LAYOUTRETURN4res_u.lorr_stateid)) 1746 return (FALSE); 1747 break; 1748 } 1749 return (TRUE); 1750 } 1751 1752 bool_t 1753 xdr_secinfo_style4(XDR *xdrs, secinfo_style4 *objp) 1754 { 1755 if (!xdr_enum(xdrs, (enum_t *)objp)) 1756 return (FALSE); 1757 return (TRUE); 1758 } 1759 1760 bool_t 1761 xdr_SECINFO_NO_NAME4args(XDR *xdrs, SECINFO_NO_NAME4args *objp) 1762 { 1763 if (!xdr_secinfo_style4(xdrs, objp)) 1764 return (FALSE); 1765 return (TRUE); 1766 } 1767 1768 bool_t 1769 xdr_SECINFO_NO_NAME4res(XDR *xdrs, SECINFO_NO_NAME4res *objp) 1770 { 1771 if (!xdr_SECINFO4res(xdrs, objp)) 1772 return (FALSE); 1773 return (TRUE); 1774 } 1775 1776 bool_t 1777 xdr_SEQUENCE4args(XDR *xdrs, SEQUENCE4args *objp) 1778 { 1779 if (!xdr_sessionid4(xdrs, objp->sa_sessionid)) 1780 return (FALSE); 1781 if (!xdr_sequenceid4(xdrs, &objp->sa_sequenceid)) 1782 return (FALSE); 1783 if (!xdr_slotid4(xdrs, &objp->sa_slotid)) 1784 return (FALSE); 1785 if (!xdr_slotid4(xdrs, &objp->sa_highest_slotid)) 1786 return (FALSE); 1787 if (!xdr_bool(xdrs, &objp->sa_cachethis)) 1788 return (FALSE); 1789 return (TRUE); 1790 } 1791 1792 bool_t 1793 xdr_SEQUENCE4resok(XDR *xdrs, SEQUENCE4resok *objp) 1794 { 1795 if (!xdr_sessionid4(xdrs, objp->sr_sessionid)) 1796 return (FALSE); 1797 if (!xdr_sequenceid4(xdrs, &objp->sr_sequenceid)) 1798 return (FALSE); 1799 if (!xdr_slotid4(xdrs, &objp->sr_slotid)) 1800 return (FALSE); 1801 if (!xdr_slotid4(xdrs, &objp->sr_highest_slotid)) 1802 return (FALSE); 1803 if (!xdr_slotid4(xdrs, &objp->sr_target_highest_slotid)) 1804 return (FALSE); 1805 if (!xdr_uint32_t(xdrs, &objp->sr_status_flags)) 1806 return (FALSE); 1807 return (TRUE); 1808 } 1809 1810 bool_t 1811 xdr_SEQUENCE4res(XDR *xdrs, SEQUENCE4res *objp) 1812 { 1813 if (!xdr_nfsstat4(xdrs, &objp->sr_status)) 1814 return (FALSE); 1815 switch (objp->sr_status) { 1816 case NFS4_OK: 1817 if (!xdr_SEQUENCE4resok(xdrs, &objp->SEQUENCE4res_u.sr_resok4)) 1818 return (FALSE); 1819 break; 1820 } 1821 return (TRUE); 1822 } 1823 1824 bool_t 1825 xdr_ssa_digest_input4(XDR *xdrs, ssa_digest_input4 *objp) 1826 { 1827 if (!xdr_SEQUENCE4args(xdrs, &objp->sdi_seqargs)) 1828 return (FALSE); 1829 return (TRUE); 1830 } 1831 1832 bool_t 1833 xdr_SET_SSV4args(XDR *xdrs, SET_SSV4args *objp) 1834 { 1835 if (!xdr_bytes(xdrs, (char **)&objp->ssa_ssv.ssa_ssv_val, 1836 (uint_t *)&objp->ssa_ssv.ssa_ssv_len, ~0)) 1837 return (FALSE); 1838 if (!xdr_bytes(xdrs, (char **)&objp->ssa_digest.ssa_digest_val, 1839 (uint_t *)&objp->ssa_digest.ssa_digest_len, ~0)) 1840 return (FALSE); 1841 return (TRUE); 1842 } 1843 1844 bool_t 1845 xdr_ssr_digest_input4(XDR *xdrs, ssr_digest_input4 *objp) 1846 { 1847 if (!xdr_SEQUENCE4res(xdrs, &objp->sdi_seqres)) 1848 return (FALSE); 1849 return (TRUE); 1850 } 1851 1852 bool_t 1853 xdr_SET_SSV4resok(XDR *xdrs, SET_SSV4resok *objp) 1854 { 1855 if (!xdr_bytes(xdrs, (char **)&objp->ssr_digest.ssr_digest_val, 1856 (uint_t *)&objp->ssr_digest.ssr_digest_len, ~0)) 1857 return (FALSE); 1858 return (TRUE); 1859 } 1860 1861 bool_t 1862 xdr_SET_SSV4res(XDR *xdrs, SET_SSV4res *objp) 1863 { 1864 if (!xdr_nfsstat4(xdrs, &objp->ssr_status)) 1865 return (FALSE); 1866 switch (objp->ssr_status) { 1867 case NFS4_OK: 1868 if (!xdr_SET_SSV4resok(xdrs, &objp->SET_SSV4res_u.ssr_resok4)) 1869 return (FALSE); 1870 break; 1871 } 1872 return (TRUE); 1873 } 1874 1875 bool_t 1876 xdr_TEST_STATEID4args(XDR *xdrs, TEST_STATEID4args *objp) 1877 { 1878 if (!xdr_array(xdrs, (char **)&objp->ts_stateids.ts_stateids_val, 1879 (uint_t *)&objp->ts_stateids.ts_stateids_len, ~0, 1880 sizeof (stateid4), (xdrproc_t)xdr_stateid4)) 1881 return (FALSE); 1882 return (TRUE); 1883 } 1884 1885 bool_t 1886 xdr_TEST_STATEID4resok(XDR *xdrs, TEST_STATEID4resok *objp) 1887 { 1888 if (!xdr_array(xdrs, 1889 (char **)&objp->tsr_status_codes.tsr_status_codes_val, 1890 (uint_t *)&objp->tsr_status_codes.tsr_status_codes_len, ~0, 1891 sizeof (nfsstat4), (xdrproc_t)xdr_nfsstat4)) 1892 return (FALSE); 1893 return (TRUE); 1894 } 1895 1896 bool_t 1897 xdr_TEST_STATEID4res(XDR *xdrs, TEST_STATEID4res *objp) 1898 { 1899 if (!xdr_nfsstat4(xdrs, &objp->tsr_status)) 1900 return (FALSE); 1901 switch (objp->tsr_status) { 1902 case NFS4_OK: 1903 if (!xdr_TEST_STATEID4resok(xdrs, 1904 &objp->TEST_STATEID4res_u.tsr_resok4)) 1905 return (FALSE); 1906 break; 1907 } 1908 return (TRUE); 1909 } 1910 1911 bool_t 1912 xdr_deleg_claim4(XDR *xdrs, deleg_claim4 *objp) 1913 { 1914 if (!xdr_open_claim_type4(xdrs, &objp->dc_claim)) 1915 return (FALSE); 1916 switch (objp->dc_claim) { 1917 case CLAIM_FH: 1918 break; 1919 case CLAIM_DELEG_PREV_FH: 1920 break; 1921 case CLAIM_PREVIOUS: 1922 if (!xdr_open_delegation_type4(xdrs, 1923 &objp->deleg_claim4_u.dc_delegate_type)) 1924 return (FALSE); 1925 break; 1926 default: 1927 return (FALSE); 1928 } 1929 return (TRUE); 1930 } 1931 1932 bool_t 1933 xdr_WANT_DELEGATION4args(XDR *xdrs, WANT_DELEGATION4args *objp) 1934 { 1935 if (!xdr_uint32_t(xdrs, &objp->wda_want)) 1936 return (FALSE); 1937 if (!xdr_deleg_claim4(xdrs, &objp->wda_claim)) 1938 return (FALSE); 1939 return (TRUE); 1940 } 1941 1942 bool_t 1943 xdr_WANT_DELEGATION4res(XDR *xdrs, WANT_DELEGATION4res *objp) 1944 { 1945 if (!xdr_nfsstat4(xdrs, &objp->wdr_status)) 1946 return (FALSE); 1947 switch (objp->wdr_status) { 1948 case NFS4_OK: 1949 if (!xdr_open_delegation4(xdrs, 1950 &objp->WANT_DELEGATION4res_u.wdr_resok4)) 1951 return (FALSE); 1952 break; 1953 } 1954 return (TRUE); 1955 } 1956 1957 bool_t 1958 xdr_DESTROY_CLIENTID4args(XDR *xdrs, DESTROY_CLIENTID4args *objp) 1959 { 1960 if (!xdr_clientid4(xdrs, &objp->dca_clientid)) 1961 return (FALSE); 1962 return (TRUE); 1963 } 1964 1965 bool_t 1966 xdr_DESTROY_CLIENTID4res(XDR *xdrs, DESTROY_CLIENTID4res *objp) 1967 { 1968 1969 if (!xdr_nfsstat4(xdrs, &objp->dcr_status)) 1970 return (FALSE); 1971 return (TRUE); 1972 } 1973 1974 bool_t 1975 xdr_RECLAIM_COMPLETE4args(XDR *xdrs, RECLAIM_COMPLETE4args *objp) 1976 { 1977 if (!xdr_bool(xdrs, &objp->rca_one_fs)) 1978 return (FALSE); 1979 return (TRUE); 1980 } 1981 1982 bool_t 1983 xdr_RECLAIM_COMPLETE4res(XDR *xdrs, RECLAIM_COMPLETE4res *objp) 1984 { 1985 if (!xdr_nfsstat4(xdrs, &objp->rcr_status)) 1986 return (FALSE); 1987 return (TRUE); 1988 } 1989 1990 /* new args, res, etc. for NFSv4.2 */ 1991 1992 bool_t 1993 xdr_nfs_opnum4(XDR *xdrs, nfs_opnum4 *objp) 1994 { 1995 1996 if (!xdr_enum(xdrs, (enum_t *)objp)) 1997 return (FALSE); 1998 return (TRUE); 1999 } 2000 2001 bool_t 2002 xdr_ALLOCATE4args(XDR *xdrs, ALLOCATE4args *objp) 2003 { 2004 2005 if (!xdr_stateid4(xdrs, &objp->aa_stateid)) 2006 return (FALSE); 2007 if (!xdr_offset4(xdrs, &objp->aa_offset)) 2008 return (FALSE); 2009 if (!xdr_length4(xdrs, &objp->aa_length)) 2010 return (FALSE); 2011 return (TRUE); 2012 } 2013 2014 bool_t 2015 xdr_ALLOCATE4res(XDR *xdrs, ALLOCATE4res *objp) 2016 { 2017 2018 if (!xdr_nfsstat4(xdrs, &objp->ar_status)) 2019 return (FALSE); 2020 return (TRUE); 2021 } 2022 2023 bool_t 2024 xdr_COPY4args(XDR *xdrs, COPY4args *objp) 2025 { 2026 2027 if (!xdr_stateid4(xdrs, &objp->ca_src_stateid)) 2028 return (FALSE); 2029 if (!xdr_stateid4(xdrs, &objp->ca_dst_stateid)) 2030 return (FALSE); 2031 if (!xdr_offset4(xdrs, &objp->ca_src_offset)) 2032 return (FALSE); 2033 if (!xdr_offset4(xdrs, &objp->ca_dst_offset)) 2034 return (FALSE); 2035 if (!xdr_length4(xdrs, &objp->ca_count)) 2036 return (FALSE); 2037 if (!xdr_bool(xdrs, &objp->ca_consecutive)) 2038 return (FALSE); 2039 if (!xdr_bool(xdrs, &objp->ca_synchronous)) 2040 return (FALSE); 2041 if (!xdr_array(xdrs, 2042 (char **)&objp->ca_source_server.ca_source_server_val, 2043 (uint_t *) &objp->ca_source_server.ca_source_server_len, ~0, 2044 sizeof (netloc4), (xdrproc_t)xdr_netloc4)) 2045 return (FALSE); 2046 return (TRUE); 2047 } 2048 2049 bool_t 2050 xdr_copy_requirements4(XDR *xdrs, copy_requirements4 *objp) 2051 { 2052 2053 if (!xdr_bool(xdrs, &objp->cr_consecutive)) 2054 return (FALSE); 2055 if (!xdr_bool(xdrs, &objp->cr_synchronous)) 2056 return (FALSE); 2057 return (TRUE); 2058 } 2059 2060 bool_t 2061 xdr_COPY4resok(XDR *xdrs, COPY4resok *objp) 2062 { 2063 2064 if (!xdr_write_response4(xdrs, &objp->cr_response)) 2065 return (FALSE); 2066 if (!xdr_copy_requirements4(xdrs, &objp->cr_requirements)) 2067 return (FALSE); 2068 return (TRUE); 2069 } 2070 2071 bool_t 2072 xdr_COPY4res(XDR *xdrs, COPY4res *objp) 2073 { 2074 2075 if (!xdr_nfsstat4(xdrs, &objp->cr_status)) 2076 return (FALSE); 2077 switch (objp->cr_status) { 2078 case NFS4_OK: 2079 if (!xdr_COPY4resok(xdrs, &objp->COPY4res_u.cr_resok4)) 2080 return (FALSE); 2081 break; 2082 case NFS4ERR_OFFLOAD_NO_REQS: 2083 if (!xdr_copy_requirements4(xdrs, 2084 &objp->COPY4res_u.cr_requirements)) 2085 return (FALSE); 2086 break; 2087 default: 2088 break; 2089 } 2090 return (TRUE); 2091 } 2092 2093 bool_t 2094 xdr_COPY_NOTIFY4args(XDR *xdrs, COPY_NOTIFY4args *objp) 2095 { 2096 2097 if (!xdr_stateid4(xdrs, &objp->cna_src_stateid)) 2098 return (FALSE); 2099 if (!xdr_netloc4(xdrs, &objp->cna_destination_server)) 2100 return (FALSE); 2101 return (TRUE); 2102 } 2103 2104 bool_t 2105 xdr_COPY_NOTIFY4resok(XDR *xdrs, COPY_NOTIFY4resok *objp) 2106 { 2107 2108 if (!xdr_nfstime4(xdrs, &objp->cnr_lease_time)) 2109 return (FALSE); 2110 if (!xdr_stateid4(xdrs, &objp->cnr_stateid)) 2111 return (FALSE); 2112 if (!xdr_array(xdrs, 2113 (char **)&objp->cnr_source_server.cnr_source_server_val, 2114 (uint_t *) &objp->cnr_source_server.cnr_source_server_len, ~0, 2115 sizeof (netloc4), (xdrproc_t)xdr_netloc4)) 2116 return (FALSE); 2117 return (TRUE); 2118 } 2119 2120 bool_t 2121 xdr_COPY_NOTIFY4res(XDR *xdrs, COPY_NOTIFY4res *objp) 2122 { 2123 2124 if (!xdr_nfsstat4(xdrs, &objp->cnr_status)) 2125 return (FALSE); 2126 switch (objp->cnr_status) { 2127 case NFS4_OK: 2128 if (!xdr_COPY_NOTIFY4resok(xdrs, 2129 &objp->COPY_NOTIFY4res_u.resok4)) 2130 return (FALSE); 2131 break; 2132 default: 2133 break; 2134 } 2135 return (TRUE); 2136 } 2137 2138 bool_t 2139 xdr_DEALLOCATE4args(XDR *xdrs, DEALLOCATE4args *objp) 2140 { 2141 2142 if (!xdr_stateid4(xdrs, &objp->da_stateid)) 2143 return (FALSE); 2144 if (!xdr_offset4(xdrs, &objp->da_offset)) 2145 return (FALSE); 2146 if (!xdr_length4(xdrs, &objp->da_length)) 2147 return (FALSE); 2148 return (TRUE); 2149 } 2150 2151 bool_t 2152 xdr_DEALLOCATE4res(XDR *xdrs, DEALLOCATE4res *objp) 2153 { 2154 2155 if (!xdr_nfsstat4(xdrs, &objp->dr_status)) 2156 return (FALSE); 2157 return (TRUE); 2158 } 2159 2160 bool_t 2161 xdr_IO_ADVISE_type4(XDR *xdrs, IO_ADVISE_type4 *objp) 2162 { 2163 2164 if (!xdr_enum(xdrs, (enum_t *)objp)) 2165 return (FALSE); 2166 return (TRUE); 2167 } 2168 2169 bool_t 2170 xdr_IO_ADVISE4args(XDR *xdrs, IO_ADVISE4args *objp) 2171 { 2172 2173 if (!xdr_stateid4(xdrs, &objp->iaa_stateid)) 2174 return (FALSE); 2175 if (!xdr_offset4(xdrs, &objp->iaa_offset)) 2176 return (FALSE); 2177 if (!xdr_length4(xdrs, &objp->iaa_count)) 2178 return (FALSE); 2179 if (!xdr_bitmap4(xdrs, &objp->iaa_hints)) 2180 return (FALSE); 2181 return (TRUE); 2182 } 2183 2184 bool_t 2185 xdr_IO_ADVISE4resok(XDR *xdrs, IO_ADVISE4resok *objp) 2186 { 2187 2188 if (!xdr_bitmap4(xdrs, &objp->ior_hints)) 2189 return (FALSE); 2190 return (TRUE); 2191 } 2192 2193 bool_t 2194 xdr_IO_ADVISE4res(XDR *xdrs, IO_ADVISE4res *objp) 2195 { 2196 2197 if (!xdr_nfsstat4(xdrs, &objp->ior_status)) 2198 return (FALSE); 2199 switch (objp->ior_status) { 2200 case NFS4_OK: 2201 if (!xdr_IO_ADVISE4resok(xdrs, &objp->IO_ADVISE4res_u.resok4)) 2202 return (FALSE); 2203 break; 2204 default: 2205 break; 2206 } 2207 return (TRUE); 2208 } 2209 2210 bool_t 2211 xdr_device_error4(XDR *xdrs, device_error4 *objp) 2212 { 2213 2214 if (!xdr_deviceid4(xdrs, objp->de_deviceid)) 2215 return (FALSE); 2216 if (!xdr_nfsstat4(xdrs, &objp->de_status)) 2217 return (FALSE); 2218 if (!xdr_nfs_opnum4(xdrs, &objp->de_opnum)) 2219 return (FALSE); 2220 return (TRUE); 2221 } 2222 2223 bool_t 2224 xdr_LAYOUTERROR4args(XDR *xdrs, LAYOUTERROR4args *objp) 2225 { 2226 2227 if (!xdr_offset4(xdrs, &objp->lea_offset)) 2228 return (FALSE); 2229 if (!xdr_length4(xdrs, &objp->lea_length)) 2230 return (FALSE); 2231 if (!xdr_stateid4(xdrs, &objp->lea_stateid)) 2232 return (FALSE); 2233 if (!xdr_array(xdrs, (char **)&objp->lea_errors.lea_errors_val, 2234 (uint_t *) &objp->lea_errors.lea_errors_len, ~0, 2235 sizeof (device_error4), (xdrproc_t)xdr_device_error4)) 2236 return (FALSE); 2237 return (TRUE); 2238 } 2239 2240 bool_t 2241 xdr_LAYOUTERROR4res(XDR *xdrs, LAYOUTERROR4res *objp) 2242 { 2243 2244 if (!xdr_nfsstat4(xdrs, &objp->ler_status)) 2245 return (FALSE); 2246 return (TRUE); 2247 } 2248 2249 bool_t 2250 xdr_io_info4(XDR *xdrs, io_info4 *objp) 2251 { 2252 2253 if (!xdr_uint64_t(xdrs, &objp->ii_count)) 2254 return (FALSE); 2255 if (!xdr_uint64_t(xdrs, &objp->ii_bytes)) 2256 return (FALSE); 2257 return (TRUE); 2258 } 2259 2260 bool_t 2261 xdr_LAYOUTSTATS4args(XDR *xdrs, LAYOUTSTATS4args *objp) 2262 { 2263 2264 if (!xdr_offset4(xdrs, &objp->lsa_offset)) 2265 return (FALSE); 2266 if (!xdr_length4(xdrs, &objp->lsa_length)) 2267 return (FALSE); 2268 if (!xdr_stateid4(xdrs, &objp->lsa_stateid)) 2269 return (FALSE); 2270 if (!xdr_io_info4(xdrs, &objp->lsa_read)) 2271 return (FALSE); 2272 if (!xdr_io_info4(xdrs, &objp->lsa_write)) 2273 return (FALSE); 2274 if (!xdr_deviceid4(xdrs, objp->lsa_deviceid)) 2275 return (FALSE); 2276 if (!xdr_layoutupdate4(xdrs, &objp->lsa_layoutupdate)) 2277 return (FALSE); 2278 return (TRUE); 2279 } 2280 2281 bool_t 2282 xdr_LAYOUTSTATS4res(XDR *xdrs, LAYOUTSTATS4res *objp) 2283 { 2284 2285 if (!xdr_nfsstat4(xdrs, &objp->lsr_status)) 2286 return (FALSE); 2287 return (TRUE); 2288 } 2289 2290 bool_t 2291 xdr_OFFLOAD_CANCEL4args(XDR *xdrs, OFFLOAD_CANCEL4args *objp) 2292 { 2293 2294 if (!xdr_stateid4(xdrs, &objp->oca_stateid)) 2295 return (FALSE); 2296 return (TRUE); 2297 } 2298 2299 bool_t 2300 xdr_OFFLOAD_CANCEL4res(XDR *xdrs, OFFLOAD_CANCEL4res *objp) 2301 { 2302 2303 if (!xdr_nfsstat4(xdrs, &objp->ocr_status)) 2304 return (FALSE); 2305 return (TRUE); 2306 } 2307 2308 bool_t 2309 xdr_OFFLOAD_STATUS4args(XDR *xdrs, OFFLOAD_STATUS4args *objp) 2310 { 2311 2312 if (!xdr_stateid4(xdrs, &objp->osa_stateid)) 2313 return (FALSE); 2314 return (TRUE); 2315 } 2316 2317 bool_t 2318 xdr_OFFLOAD_STATUS4resok(XDR *xdrs, OFFLOAD_STATUS4resok *objp) 2319 { 2320 2321 if (!xdr_length4(xdrs, &objp->osr_count)) 2322 return (FALSE); 2323 if (!xdr_array(xdrs, (char **)&objp->osr_complete.osr_complete_val, 2324 (uint_t *) &objp->osr_complete.osr_complete_len, 1, 2325 sizeof (nfsstat4), (xdrproc_t)xdr_nfsstat4)) 2326 return (FALSE); 2327 return (TRUE); 2328 } 2329 2330 bool_t 2331 xdr_OFFLOAD_STATUS4res(XDR *xdrs, OFFLOAD_STATUS4res *objp) 2332 { 2333 2334 if (!xdr_nfsstat4(xdrs, &objp->osr_status)) 2335 return (FALSE); 2336 switch (objp->osr_status) { 2337 case NFS4_OK: 2338 if (!xdr_OFFLOAD_STATUS4resok(xdrs, 2339 &objp->OFFLOAD_STATUS4res_u.osr_resok4)) 2340 return (FALSE); 2341 break; 2342 default: 2343 break; 2344 } 2345 return (TRUE); 2346 } 2347 2348 bool_t 2349 xdr_READ_PLUS4args(XDR *xdrs, READ_PLUS4args *objp) 2350 { 2351 2352 if (!xdr_stateid4(xdrs, &objp->rpa_stateid)) 2353 return (FALSE); 2354 if (!xdr_offset4(xdrs, &objp->rpa_offset)) 2355 return (FALSE); 2356 if (!xdr_count4(xdrs, &objp->rpa_count)) 2357 return (FALSE); 2358 return (TRUE); 2359 } 2360 2361 bool_t 2362 xdr_read_plus_content(XDR *xdrs, read_plus_content *objp) 2363 { 2364 2365 if (!xdr_data_content4(xdrs, &objp->rpc_content)) 2366 return (FALSE); 2367 switch (objp->rpc_content) { 2368 case NFS4_CONTENT_DATA: 2369 if (!xdr_data4(xdrs, &objp->read_plus_content_u.rpc_data)) 2370 return (FALSE); 2371 break; 2372 case NFS4_CONTENT_HOLE: 2373 if (!xdr_data_info4(xdrs, &objp->read_plus_content_u.rpc_hole)) 2374 return (FALSE); 2375 break; 2376 default: 2377 break; 2378 } 2379 return (TRUE); 2380 } 2381 2382 bool_t 2383 xdr_read_plus_res4(XDR *xdrs, read_plus_res4 *objp) 2384 { 2385 2386 if (!xdr_bool(xdrs, &objp->rpr_eof)) 2387 return (FALSE); 2388 if (!xdr_array(xdrs, (char **)&objp->rpr_contents.rpr_contents_val, 2389 (uint_t *) &objp->rpr_contents.rpr_contents_len, ~0, 2390 sizeof (read_plus_content), (xdrproc_t)xdr_read_plus_content)) 2391 return (FALSE); 2392 return (TRUE); 2393 } 2394 2395 bool_t 2396 xdr_READ_PLUS4res(XDR *xdrs, READ_PLUS4res *objp) 2397 { 2398 2399 if (!xdr_nfsstat4(xdrs, &objp->rp_status)) 2400 return (FALSE); 2401 switch (objp->rp_status) { 2402 case NFS4_OK: 2403 if (!xdr_read_plus_res4(xdrs, &objp->READ_PLUS4res_u.rp_resok4)) 2404 return (FALSE); 2405 break; 2406 default: 2407 break; 2408 } 2409 return (TRUE); 2410 } 2411 2412 bool_t 2413 xdr_SEEK4args(XDR *xdrs, SEEK4args *objp) 2414 { 2415 2416 if (!xdr_stateid4(xdrs, &objp->sa_stateid)) 2417 return (FALSE); 2418 if (!xdr_offset4(xdrs, &objp->sa_offset)) 2419 return (FALSE); 2420 if (!xdr_data_content4(xdrs, &objp->sa_what)) 2421 return (FALSE); 2422 return (TRUE); 2423 } 2424 2425 bool_t 2426 xdr_seek_res4(XDR *xdrs, seek_res4 *objp) 2427 { 2428 2429 if (!xdr_bool(xdrs, &objp->sr_eof)) 2430 return (FALSE); 2431 if (!xdr_offset4(xdrs, &objp->sr_offset)) 2432 return (FALSE); 2433 return (TRUE); 2434 } 2435 2436 bool_t 2437 xdr_SEEK4res(XDR *xdrs, SEEK4res *objp) 2438 { 2439 2440 if (!xdr_nfsstat4(xdrs, &objp->sa_status)) 2441 return (FALSE); 2442 switch (objp->sa_status) { 2443 case NFS4_OK: 2444 if (!xdr_seek_res4(xdrs, &objp->SEEK4res_u.resok4)) 2445 return (FALSE); 2446 break; 2447 default: 2448 break; 2449 } 2450 return (TRUE); 2451 } 2452 2453 bool_t 2454 xdr_WRITE_SAME4args(XDR *xdrs, WRITE_SAME4args *objp) 2455 { 2456 2457 if (!xdr_stateid4(xdrs, &objp->wsa_stateid)) 2458 return (FALSE); 2459 if (!xdr_stable_how4(xdrs, &objp->wsa_stable)) 2460 return (FALSE); 2461 if (!xdr_app_data_block4(xdrs, &objp->wsa_adb)) 2462 return (FALSE); 2463 return (TRUE); 2464 } 2465 2466 bool_t 2467 xdr_WRITE_SAME4res(XDR *xdrs, WRITE_SAME4res *objp) 2468 { 2469 2470 if (!xdr_nfsstat4(xdrs, &objp->wsr_status)) 2471 return (FALSE); 2472 switch (objp->wsr_status) { 2473 case NFS4_OK: 2474 if (!xdr_write_response4(xdrs, &objp->WRITE_SAME4res_u.resok4)) 2475 return (FALSE); 2476 break; 2477 default: 2478 break; 2479 } 2480 return (TRUE); 2481 } 2482 2483 bool_t 2484 xdr_CLONE4args(XDR *xdrs, CLONE4args *objp) 2485 { 2486 2487 if (!xdr_stateid4(xdrs, &objp->cl_src_stateid)) 2488 return (FALSE); 2489 if (!xdr_stateid4(xdrs, &objp->cl_dst_stateid)) 2490 return (FALSE); 2491 if (!xdr_offset4(xdrs, &objp->cl_src_offset)) 2492 return (FALSE); 2493 if (!xdr_offset4(xdrs, &objp->cl_dst_offset)) 2494 return (FALSE); 2495 if (!xdr_length4(xdrs, &objp->cl_count)) 2496 return (FALSE); 2497 return (TRUE); 2498 } 2499 2500 bool_t 2501 xdr_CLONE4res(XDR *xdrs, CLONE4res *objp) 2502 { 2503 2504 if (!xdr_nfsstat4(xdrs, &objp->cl_status)) 2505 return (FALSE); 2506 return (TRUE); 2507 } 2508 2509 2510 /* new operations for NFSv4.1 */ 2511 2512 bool_t 2513 xdr_nfs4x_argop4(XDR *xdrs, nfs_argop4 *objp) 2514 { 2515 /* nfs_opnum4 has already been xdr'd */ 2516 switch (objp->argop) { 2517 case OP_BACKCHANNEL_CTL: 2518 if (!xdr_BACKCHANNEL_CTL4args(xdrs, 2519 &objp->nfs_argop4_u.opbackchannel_ctl)) 2520 return (FALSE); 2521 break; 2522 case OP_BIND_CONN_TO_SESSION: 2523 if (!xdr_BIND_CONN_TO_SESSION4args(xdrs, 2524 &objp->nfs_argop4_u.opbind_conn_to_session)) 2525 return (FALSE); 2526 break; 2527 case OP_EXCHANGE_ID: 2528 if (!xdr_EXCHANGE_ID4args(xdrs, 2529 &objp->nfs_argop4_u.opexchange_id)) 2530 return (FALSE); 2531 break; 2532 case OP_CREATE_SESSION: 2533 if (!xdr_CREATE_SESSION4args(xdrs, 2534 &objp->nfs_argop4_u.opcreate_session)) 2535 return (FALSE); 2536 break; 2537 case OP_DESTROY_SESSION: 2538 if (!xdr_DESTROY_SESSION4args(xdrs, 2539 &objp->nfs_argop4_u.opdestroy_session)) 2540 return (FALSE); 2541 break; 2542 case OP_FREE_STATEID: 2543 if (!xdr_FREE_STATEID4args(xdrs, 2544 &objp->nfs_argop4_u.opfree_stateid)) 2545 return (FALSE); 2546 break; 2547 case OP_GET_DIR_DELEGATION: 2548 if (!xdr_GET_DIR_DELEGATION4args(xdrs, 2549 &objp->nfs_argop4_u.opget_dir_delegation)) 2550 return (FALSE); 2551 break; 2552 case OP_GETDEVICEINFO: 2553 if (!xdr_GETDEVICEINFO4args(xdrs, 2554 &objp->nfs_argop4_u.opgetdeviceinfo)) 2555 return (FALSE); 2556 break; 2557 case OP_GETDEVICELIST: 2558 if (!xdr_GETDEVICELIST4args(xdrs, 2559 &objp->nfs_argop4_u.opgetdevicelist)) 2560 return (FALSE); 2561 break; 2562 case OP_LAYOUTCOMMIT: 2563 if (!xdr_LAYOUTCOMMIT4args(xdrs, 2564 &objp->nfs_argop4_u.oplayoutcommit)) 2565 return (FALSE); 2566 break; 2567 case OP_LAYOUTGET: 2568 if (!xdr_LAYOUTGET4args(xdrs, 2569 &objp->nfs_argop4_u.oplayoutget)) 2570 return (FALSE); 2571 break; 2572 case OP_LAYOUTRETURN: 2573 if (!xdr_LAYOUTRETURN4args(xdrs, 2574 &objp->nfs_argop4_u.oplayoutreturn)) 2575 return (FALSE); 2576 break; 2577 case OP_SECINFO_NO_NAME: 2578 if (!xdr_SECINFO_NO_NAME4args(xdrs, 2579 &objp->nfs_argop4_u.opsecinfo_no_name)) 2580 return (FALSE); 2581 break; 2582 case OP_SEQUENCE: 2583 if (!xdr_SEQUENCE4args(xdrs, 2584 &objp->nfs_argop4_u.opsequence)) 2585 return (FALSE); 2586 break; 2587 case OP_SET_SSV: 2588 if (!xdr_SET_SSV4args(xdrs, 2589 &objp->nfs_argop4_u.opset_ssv)) 2590 return (FALSE); 2591 break; 2592 case OP_TEST_STATEID: 2593 if (!xdr_TEST_STATEID4args(xdrs, 2594 &objp->nfs_argop4_u.optest_stateid)) 2595 return (FALSE); 2596 break; 2597 case OP_WANT_DELEGATION: 2598 if (!xdr_WANT_DELEGATION4args(xdrs, 2599 &objp->nfs_argop4_u.opwant_delegation)) 2600 return (FALSE); 2601 break; 2602 case OP_DESTROY_CLIENTID: 2603 if (!xdr_DESTROY_CLIENTID4args(xdrs, 2604 &objp->nfs_argop4_u.opdestroy_clientid)) 2605 return (FALSE); 2606 break; 2607 case OP_RECLAIM_COMPLETE: 2608 if (!xdr_RECLAIM_COMPLETE4args(xdrs, 2609 &objp->nfs_argop4_u.opreclaim_complete)) 2610 return (FALSE); 2611 break; 2612 2613 case OP_ALLOCATE: 2614 if (!xdr_ALLOCATE4args(xdrs, 2615 &objp->nfs_argop4_u.opallocate)) 2616 return (FALSE); 2617 break; 2618 case OP_COPY: 2619 if (!xdr_COPY4args(xdrs, &objp->nfs_argop4_u.opcopy)) 2620 return (FALSE); 2621 break; 2622 case OP_COPY_NOTIFY: 2623 if (!xdr_COPY_NOTIFY4args(xdrs, 2624 &objp->nfs_argop4_u.opoffload_notify)) 2625 return (FALSE); 2626 break; 2627 case OP_DEALLOCATE: 2628 if (!xdr_DEALLOCATE4args(xdrs, 2629 &objp->nfs_argop4_u.opdeallocate)) 2630 return (FALSE); 2631 break; 2632 case OP_IO_ADVISE: 2633 if (!xdr_IO_ADVISE4args(xdrs, 2634 &objp->nfs_argop4_u.opio_advise)) 2635 return (FALSE); 2636 break; 2637 case OP_LAYOUTERROR: 2638 if (!xdr_LAYOUTERROR4args(xdrs, 2639 &objp->nfs_argop4_u.oplayouterror)) 2640 return (FALSE); 2641 break; 2642 case OP_LAYOUTSTATS: 2643 if (!xdr_LAYOUTSTATS4args(xdrs, 2644 &objp->nfs_argop4_u.oplayoutstats)) 2645 return (FALSE); 2646 break; 2647 case OP_OFFLOAD_CANCEL: 2648 if (!xdr_OFFLOAD_CANCEL4args(xdrs, 2649 &objp->nfs_argop4_u.opoffload_cancel)) 2650 return (FALSE); 2651 break; 2652 case OP_OFFLOAD_STATUS: 2653 if (!xdr_OFFLOAD_STATUS4args(xdrs, 2654 &objp->nfs_argop4_u.opoffload_status)) 2655 return (FALSE); 2656 break; 2657 case OP_READ_PLUS: 2658 if (!xdr_READ_PLUS4args(xdrs, 2659 &objp->nfs_argop4_u.opread_plus)) 2660 return (FALSE); 2661 break; 2662 case OP_SEEK: 2663 if (!xdr_SEEK4args(xdrs, &objp->nfs_argop4_u.opseek)) 2664 return (FALSE); 2665 break; 2666 case OP_WRITE_SAME: 2667 if (!xdr_WRITE_SAME4args(xdrs, 2668 &objp->nfs_argop4_u.opwrite_same)) 2669 return (FALSE); 2670 break; 2671 case OP_CLONE: 2672 if (!xdr_CLONE4args(xdrs, &objp->nfs_argop4_u.opclone)) 2673 return (FALSE); 2674 break; 2675 2676 default: 2677 return (FALSE); 2678 } 2679 return (TRUE); 2680 } 2681 2682 bool_t 2683 xdr_nfs4x_resop4(XDR *xdrs, nfs_resop4 *objp) 2684 { 2685 /* nfs_opnum4 has already been xdr's */ 2686 switch (objp->resop) { 2687 case OP_BACKCHANNEL_CTL: 2688 if (!xdr_BACKCHANNEL_CTL4res(xdrs, 2689 &objp->nfs_resop4_u.opbackchannel_ctl)) 2690 return (FALSE); 2691 break; 2692 case OP_BIND_CONN_TO_SESSION: 2693 if (!xdr_BIND_CONN_TO_SESSION4res(xdrs, 2694 &objp->nfs_resop4_u.opbind_conn_to_session)) 2695 return (FALSE); 2696 break; 2697 case OP_EXCHANGE_ID: 2698 if (!xdr_EXCHANGE_ID4res(xdrs, 2699 &objp->nfs_resop4_u.opexchange_id)) 2700 return (FALSE); 2701 break; 2702 case OP_CREATE_SESSION: 2703 if (!xdr_CREATE_SESSION4res(xdrs, 2704 &objp->nfs_resop4_u.opcreate_session)) 2705 return (FALSE); 2706 break; 2707 case OP_DESTROY_SESSION: 2708 if (!xdr_DESTROY_SESSION4res(xdrs, 2709 &objp->nfs_resop4_u.opdestroy_session)) 2710 return (FALSE); 2711 break; 2712 case OP_FREE_STATEID: 2713 if (!xdr_FREE_STATEID4res(xdrs, 2714 &objp->nfs_resop4_u.opfree_stateid)) 2715 return (FALSE); 2716 break; 2717 case OP_GET_DIR_DELEGATION: 2718 if (!xdr_GET_DIR_DELEGATION4res(xdrs, 2719 &objp->nfs_resop4_u.opget_dir_delegation)) 2720 return (FALSE); 2721 break; 2722 case OP_GETDEVICEINFO: 2723 if (!xdr_GETDEVICEINFO4res(xdrs, 2724 &objp->nfs_resop4_u.opgetdeviceinfo)) 2725 return (FALSE); 2726 break; 2727 case OP_GETDEVICELIST: 2728 if (!xdr_GETDEVICELIST4res(xdrs, 2729 &objp->nfs_resop4_u.opgetdevicelist)) 2730 return (FALSE); 2731 break; 2732 case OP_LAYOUTCOMMIT: 2733 if (!xdr_LAYOUTCOMMIT4res(xdrs, 2734 &objp->nfs_resop4_u.oplayoutcommit)) 2735 return (FALSE); 2736 break; 2737 case OP_LAYOUTGET: 2738 if (!xdr_LAYOUTGET4res(xdrs, 2739 &objp->nfs_resop4_u.oplayoutget)) 2740 return (FALSE); 2741 break; 2742 case OP_LAYOUTRETURN: 2743 if (!xdr_LAYOUTRETURN4res(xdrs, 2744 &objp->nfs_resop4_u.oplayoutreturn)) 2745 return (FALSE); 2746 break; 2747 case OP_SECINFO_NO_NAME: 2748 if (!xdr_SECINFO_NO_NAME4res(xdrs, 2749 &objp->nfs_resop4_u.opsecinfo_no_name)) 2750 return (FALSE); 2751 break; 2752 case OP_SEQUENCE: 2753 if (!xdr_SEQUENCE4res(xdrs, 2754 &objp->nfs_resop4_u.opsequence)) 2755 return (FALSE); 2756 break; 2757 case OP_SET_SSV: 2758 if (!xdr_SET_SSV4res(xdrs, 2759 &objp->nfs_resop4_u.opset_ssv)) 2760 return (FALSE); 2761 break; 2762 case OP_TEST_STATEID: 2763 if (!xdr_TEST_STATEID4res(xdrs, 2764 &objp->nfs_resop4_u.optest_stateid)) 2765 return (FALSE); 2766 break; 2767 case OP_WANT_DELEGATION: 2768 if (!xdr_WANT_DELEGATION4res(xdrs, 2769 &objp->nfs_resop4_u.opwant_delegation)) 2770 return (FALSE); 2771 break; 2772 case OP_DESTROY_CLIENTID: 2773 if (!xdr_DESTROY_CLIENTID4res(xdrs, 2774 &objp->nfs_resop4_u.opdestroy_clientid)) 2775 return (FALSE); 2776 break; 2777 case OP_RECLAIM_COMPLETE: 2778 if (!xdr_RECLAIM_COMPLETE4res(xdrs, 2779 &objp->nfs_resop4_u.opreclaim_complete)) 2780 return (FALSE); 2781 break; 2782 2783 case OP_ALLOCATE: 2784 if (!xdr_ALLOCATE4res(xdrs, &objp->nfs_resop4_u.opallocate)) 2785 return (FALSE); 2786 break; 2787 case OP_COPY: 2788 if (!xdr_COPY4res(xdrs, &objp->nfs_resop4_u.opcopy)) 2789 return (FALSE); 2790 break; 2791 case OP_COPY_NOTIFY: 2792 if (!xdr_COPY_NOTIFY4res(xdrs, 2793 &objp->nfs_resop4_u.opcopy_notify)) 2794 return (FALSE); 2795 break; 2796 case OP_DEALLOCATE: 2797 if (!xdr_DEALLOCATE4res(xdrs, &objp->nfs_resop4_u.opdeallocate)) 2798 return (FALSE); 2799 break; 2800 case OP_IO_ADVISE: 2801 if (!xdr_IO_ADVISE4res(xdrs, &objp->nfs_resop4_u.opio_advise)) 2802 return (FALSE); 2803 break; 2804 case OP_LAYOUTERROR: 2805 if (!xdr_LAYOUTERROR4res(xdrs, 2806 &objp->nfs_resop4_u.oplayouterror)) 2807 return (FALSE); 2808 break; 2809 case OP_LAYOUTSTATS: 2810 if (!xdr_LAYOUTSTATS4res(xdrs, 2811 &objp->nfs_resop4_u.oplayoutstats)) 2812 return (FALSE); 2813 break; 2814 case OP_OFFLOAD_CANCEL: 2815 if (!xdr_OFFLOAD_CANCEL4res(xdrs, 2816 &objp->nfs_resop4_u.opoffload_cancel)) 2817 return (FALSE); 2818 break; 2819 case OP_OFFLOAD_STATUS: 2820 if (!xdr_OFFLOAD_STATUS4res(xdrs, 2821 &objp->nfs_resop4_u.opoffload_status)) 2822 return (FALSE); 2823 break; 2824 case OP_READ_PLUS: 2825 if (!xdr_READ_PLUS4res(xdrs, &objp->nfs_resop4_u.opread_plus)) 2826 return (FALSE); 2827 break; 2828 case OP_SEEK: 2829 if (!xdr_SEEK4res(xdrs, &objp->nfs_resop4_u.opseek)) 2830 return (FALSE); 2831 break; 2832 case OP_WRITE_SAME: 2833 if (!xdr_WRITE_SAME4res(xdrs, &objp->nfs_resop4_u.opwrite_same)) 2834 return (FALSE); 2835 break; 2836 case OP_CLONE: 2837 if (!xdr_CLONE4res(xdrs, &objp->nfs_resop4_u.opclone)) 2838 return (FALSE); 2839 break; 2840 2841 default: 2842 return (FALSE); 2843 } 2844 return (TRUE); 2845 } 2846 2847 bool_t 2848 xdr_layoutrecall_type4(XDR *xdrs, layoutrecall_type4 *objp) 2849 { 2850 if (!xdr_enum(xdrs, (enum_t *)objp)) 2851 return (FALSE); 2852 return (TRUE); 2853 } 2854 2855 bool_t 2856 xdr_layoutrecall_file4(XDR *xdrs, layoutrecall_file4 *objp) 2857 { 2858 switch (xdrs->x_op) { 2859 case XDR_ENCODE: 2860 /* TODO: encode nfs4x_fh */ 2861 return (FALSE); 2862 2863 case XDR_DECODE: 2864 if (!xdr_bytes(xdrs, (char **)&objp->lor_fh.nfs_fh4_val, 2865 (uint_t *)&objp->lor_fh.nfs_fh4_len, NFS4_FHSIZE)) 2866 return (FALSE); 2867 break; 2868 2869 case XDR_FREE: 2870 if (objp->lor_fh.nfs_fh4_val != NULL) { 2871 if (!xdr_bytes(xdrs, 2872 (char **)&objp->lor_fh.nfs_fh4_val, 2873 (uint_t *)&objp->lor_fh.nfs_fh4_len, 2874 NFS4_FHSIZE)) 2875 return (FALSE); 2876 } 2877 break; 2878 } 2879 2880 if (!xdr_offset4(xdrs, &objp->lor_offset)) 2881 return (FALSE); 2882 if (!xdr_length4(xdrs, &objp->lor_length)) 2883 return (FALSE); 2884 if (!xdr_stateid4(xdrs, &objp->lor_stateid)) 2885 return (FALSE); 2886 return (TRUE); 2887 } 2888 2889 bool_t 2890 xdr_layoutrecall4(XDR *xdrs, layoutrecall4 *objp) 2891 { 2892 if (!xdr_layoutrecall_type4(xdrs, &objp->lor_recalltype)) 2893 return (FALSE); 2894 switch (objp->lor_recalltype) { 2895 case LAYOUTRECALL4_FILE: 2896 if (!xdr_layoutrecall_file4(xdrs, 2897 &objp->layoutrecall4_u.lor_layout)) 2898 return (FALSE); 2899 break; 2900 case LAYOUTRECALL4_FSID: 2901 if (!xdr_fsid4(xdrs, &objp->layoutrecall4_u.lor_fsid)) 2902 return (FALSE); 2903 break; 2904 case LAYOUTRECALL4_ALL: 2905 break; 2906 default: 2907 return (FALSE); 2908 } 2909 return (TRUE); 2910 } 2911 2912 bool_t 2913 xdr_CB_LAYOUTRECALL4args(XDR *xdrs, CB_LAYOUTRECALL4args *objp) 2914 { 2915 if (!xdr_layouttype4(xdrs, &objp->clora_type)) 2916 return (FALSE); 2917 if (!xdr_layoutiomode4(xdrs, &objp->clora_iomode)) 2918 return (FALSE); 2919 if (!xdr_bool(xdrs, &objp->clora_changed)) 2920 return (FALSE); 2921 if (!xdr_layoutrecall4(xdrs, &objp->clora_recall)) 2922 return (FALSE); 2923 return (TRUE); 2924 } 2925 2926 bool_t 2927 xdr_CB_LAYOUTRECALL4res(XDR *xdrs, CB_LAYOUTRECALL4res *objp) 2928 { 2929 if (!xdr_nfsstat4(xdrs, &objp->clorr_status)) 2930 return (FALSE); 2931 return (TRUE); 2932 } 2933 2934 bool_t 2935 xdr_notify_type4(XDR *xdrs, notify_type4 *objp) 2936 { 2937 if (!xdr_enum(xdrs, (enum_t *)objp)) 2938 return (FALSE); 2939 return (TRUE); 2940 } 2941 2942 bool_t 2943 xdr_notify_entry4(XDR *xdrs, notify_entry4 *objp) 2944 { 2945 if (!xdr_component4(xdrs, &objp->ne_file)) 2946 return (FALSE); 2947 if (!xdr_fattr4(xdrs, &objp->ne_attrs)) 2948 return (FALSE); 2949 return (TRUE); 2950 } 2951 2952 bool_t 2953 xdr_prev_entry4(XDR *xdrs, prev_entry4 *objp) 2954 { 2955 if (!xdr_notify_entry4(xdrs, &objp->pe_prev_entry)) 2956 return (FALSE); 2957 if (!xdr_nfs_cookie4(xdrs, &objp->pe_prev_entry_cookie)) 2958 return (FALSE); 2959 return (TRUE); 2960 } 2961 2962 bool_t 2963 xdr_notify_remove4(XDR *xdrs, notify_remove4 *objp) 2964 { 2965 2966 if (!xdr_notify_entry4(xdrs, &objp->nrm_old_entry)) 2967 return (FALSE); 2968 if (!xdr_nfs_cookie4(xdrs, &objp->nrm_old_entry_cookie)) 2969 return (FALSE); 2970 return (TRUE); 2971 } 2972 2973 bool_t 2974 xdr_notify_add4(XDR *xdrs, notify_add4 *objp) 2975 { 2976 if (!xdr_array(xdrs, (char **)&objp->nad_old_entry.nad_old_entry_val, 2977 (uint_t *)&objp->nad_old_entry.nad_old_entry_len, 1, 2978 sizeof (notify_remove4), (xdrproc_t)xdr_notify_remove4)) 2979 return (FALSE); 2980 if (!xdr_notify_entry4(xdrs, &objp->nad_new_entry)) 2981 return (FALSE); 2982 if (!xdr_array(xdrs, 2983 (char **)&objp->nad_new_entry_cookie.nad_new_entry_cookie_val, 2984 (uint_t *)&objp->nad_new_entry_cookie.nad_new_entry_cookie_len, 1, 2985 sizeof (nfs_cookie4), (xdrproc_t)xdr_nfs_cookie4)) 2986 return (FALSE); 2987 if (!xdr_array(xdrs, (char **)&objp->nad_prev_entry.nad_prev_entry_val, 2988 (uint_t *)&objp->nad_prev_entry.nad_prev_entry_len, 1, 2989 sizeof (prev_entry4), (xdrproc_t)xdr_prev_entry4)) 2990 return (FALSE); 2991 if (!xdr_bool(xdrs, &objp->nad_last_entry)) 2992 return (FALSE); 2993 return (TRUE); 2994 } 2995 2996 bool_t 2997 xdr_notify_attr4(XDR *xdrs, notify_attr4 *objp) 2998 { 2999 if (!xdr_notify_entry4(xdrs, &objp->na_changed_entry)) 3000 return (FALSE); 3001 return (TRUE); 3002 } 3003 3004 bool_t 3005 xdr_notify_rename4(XDR *xdrs, notify_rename4 *objp) 3006 { 3007 if (!xdr_notify_remove4(xdrs, &objp->nrn_old_entry)) 3008 return (FALSE); 3009 if (!xdr_notify_add4(xdrs, &objp->nrn_new_entry)) 3010 return (FALSE); 3011 return (TRUE); 3012 } 3013 3014 bool_t 3015 xdr_notify_verifier4(XDR *xdrs, notify_verifier4 *objp) 3016 { 3017 if (!xdr_verifier4(xdrs, (verifier4 *)&objp->nv_old_cookieverf)) 3018 return (FALSE); 3019 if (!xdr_verifier4(xdrs, (verifier4 *)&objp->nv_new_cookieverf)) 3020 return (FALSE); 3021 return (TRUE); 3022 } 3023 3024 bool_t 3025 xdr_notifylist4(XDR *xdrs, notifylist4 *objp) 3026 { 3027 if (!xdr_bytes(xdrs, (char **)&objp->notifylist4_val, 3028 (uint_t *)&objp->notifylist4_len, ~0)) 3029 return (FALSE); 3030 return (TRUE); 3031 } 3032 3033 bool_t 3034 xdr_notify4(XDR *xdrs, notify4 *objp) 3035 { 3036 if (xdrs->x_op == XDR_ENCODE) { 3037 if (!xdr_bitmap4_notify(xdrs, &objp->notify_mask)) 3038 return (FALSE); 3039 } else 3040 if (!xdr_bitmap4(xdrs, &objp->notify_mask)) 3041 return (FALSE); 3042 if (!xdr_notifylist4(xdrs, &objp->notify_vals)) 3043 return (FALSE); 3044 return (TRUE); 3045 } 3046 3047 bool_t 3048 xdr_CB_NOTIFY4args(XDR *xdrs, CB_NOTIFY4args *objp) 3049 { 3050 if (!xdr_stateid4(xdrs, &objp->cna_stateid)) 3051 return (FALSE); 3052 if (!xdr_nfs_fh4(xdrs, &objp->cna_fh)) 3053 return (FALSE); 3054 if (!xdr_array(xdrs, (char **)&objp->cna_changes.cna_changes_val, 3055 (uint_t *)&objp->cna_changes.cna_changes_len, ~0, 3056 sizeof (notify4), (xdrproc_t)xdr_notify4)) 3057 return (FALSE); 3058 return (TRUE); 3059 } 3060 3061 bool_t 3062 xdr_CB_NOTIFY4res(XDR *xdrs, CB_NOTIFY4res *objp) 3063 { 3064 if (!xdr_nfsstat4(xdrs, &objp->cnr_status)) 3065 return (FALSE); 3066 return (TRUE); 3067 } 3068 3069 bool_t 3070 xdr_CB_PUSH_DELEG4args(XDR *xdrs, CB_PUSH_DELEG4args *objp) 3071 { 3072 if (!xdr_nfs_fh4(xdrs, &objp->cpda_fh)) 3073 return (FALSE); 3074 if (!xdr_open_delegation4(xdrs, &objp->cpda_delegation)) 3075 return (FALSE); 3076 return (TRUE); 3077 } 3078 3079 bool_t 3080 xdr_CB_PUSH_DELEG4res(XDR *xdrs, CB_PUSH_DELEG4res *objp) 3081 { 3082 if (!xdr_nfsstat4(xdrs, &objp->cpdr_status)) 3083 return (FALSE); 3084 return (TRUE); 3085 } 3086 3087 bool_t 3088 xdr_CB_RECALL_ANY4args(XDR *xdrs, CB_RECALL_ANY4args *objp) 3089 { 3090 if (!xdr_uint32_t(xdrs, &objp->craa_objects_to_keep)) 3091 return (FALSE); 3092 if (!xdr_bitmap4(xdrs, &objp->craa_type_mask)) 3093 return (FALSE); 3094 return (TRUE); 3095 } 3096 3097 bool_t 3098 xdr_CB_RECALL_ANY4res(XDR *xdrs, CB_RECALL_ANY4res *objp) 3099 { 3100 if (!xdr_nfsstat4(xdrs, &objp->crar_status)) 3101 return (FALSE); 3102 return (TRUE); 3103 } 3104 3105 bool_t 3106 xdr_CB_RECALLABLE_OBJ_AVAIL4args(XDR *xdrs, CB_RECALLABLE_OBJ_AVAIL4args *objp) 3107 { 3108 if (!xdr_CB_RECALL_ANY4args(xdrs, objp)) 3109 return (FALSE); 3110 return (TRUE); 3111 } 3112 3113 bool_t 3114 xdr_CB_RECALLABLE_OBJ_AVAIL4res(XDR *xdrs, CB_RECALLABLE_OBJ_AVAIL4res *objp) 3115 { 3116 if (!xdr_nfsstat4(xdrs, &objp->croa_status)) 3117 return (FALSE); 3118 return (TRUE); 3119 } 3120 3121 bool_t 3122 xdr_CB_RECALL_SLOT4args(XDR *xdrs, CB_RECALL_SLOT4args *objp) 3123 { 3124 if (!xdr_slotid4(xdrs, &objp->rsa_target_highest_slotid)) 3125 return (FALSE); 3126 return (TRUE); 3127 } 3128 3129 bool_t 3130 xdr_CB_RECALL_SLOT4res(XDR *xdrs, CB_RECALL_SLOT4res *objp) 3131 { 3132 if (!xdr_nfsstat4(xdrs, &objp->rsr_status)) 3133 return (FALSE); 3134 return (TRUE); 3135 } 3136 3137 bool_t 3138 xdr_referring_call4(XDR *xdrs, referring_call4 *objp) 3139 { 3140 if (!xdr_sequenceid4(xdrs, &objp->rc_sequenceid)) 3141 return (FALSE); 3142 if (!xdr_slotid4(xdrs, &objp->rc_slotid)) 3143 return (FALSE); 3144 return (TRUE); 3145 } 3146 3147 bool_t 3148 xdr_referring_call_list4(XDR *xdrs, referring_call_list4 *objp) 3149 { 3150 if (!xdr_sessionid4(xdrs, objp->rcl_sessionid)) 3151 return (FALSE); 3152 if (!xdr_array(xdrs, (char **)&objp->rcl_referring_calls. 3153 rcl_referring_calls_val, 3154 (uint_t *)&objp->rcl_referring_calls.rcl_referring_calls_len, ~0, 3155 sizeof (referring_call4), (xdrproc_t)xdr_referring_call4)) 3156 return (FALSE); 3157 return (TRUE); 3158 } 3159 3160 bool_t 3161 xdr_CB_SEQUENCE4args(XDR *xdrs, CB_SEQUENCE4args *objp) 3162 { 3163 if (!xdr_sessionid4(xdrs, objp->csa_sessionid)) 3164 return (FALSE); 3165 if (!xdr_sequenceid4(xdrs, &objp->csa_sequenceid)) 3166 return (FALSE); 3167 if (!xdr_slotid4(xdrs, &objp->csa_slotid)) 3168 return (FALSE); 3169 if (!xdr_slotid4(xdrs, &objp->csa_highest_slotid)) 3170 return (FALSE); 3171 if (!xdr_bool(xdrs, &objp->csa_cachethis)) 3172 return (FALSE); 3173 if (!xdr_array(xdrs, (char **)&objp->csa_referring_call_lists. 3174 csa_referring_call_lists_val, 3175 (uint_t *)&objp->csa_referring_call_lists. 3176 csa_referring_call_lists_len, ~0, sizeof (referring_call_list4), 3177 (xdrproc_t)xdr_referring_call_list4)) 3178 return (FALSE); 3179 return (TRUE); 3180 } 3181 3182 bool_t 3183 xdr_CB_SEQUENCE4resok(XDR *xdrs, CB_SEQUENCE4resok *objp) 3184 { 3185 if (!xdr_sessionid4(xdrs, objp->csr_sessionid)) 3186 return (FALSE); 3187 if (!xdr_sequenceid4(xdrs, &objp->csr_sequenceid)) 3188 return (FALSE); 3189 if (!xdr_slotid4(xdrs, &objp->csr_slotid)) 3190 return (FALSE); 3191 if (!xdr_slotid4(xdrs, &objp->csr_highest_slotid)) 3192 return (FALSE); 3193 if (!xdr_slotid4(xdrs, &objp->csr_target_highest_slotid)) 3194 return (FALSE); 3195 return (TRUE); 3196 } 3197 3198 bool_t 3199 xdr_CB_SEQUENCE4res(XDR *xdrs, CB_SEQUENCE4res *objp) 3200 { 3201 if (!xdr_nfsstat4(xdrs, &objp->csr_status)) 3202 return (FALSE); 3203 switch (objp->csr_status) { 3204 case NFS4_OK: 3205 if (!xdr_CB_SEQUENCE4resok(xdrs, 3206 &objp->CB_SEQUENCE4res_u.csr_resok4)) 3207 return (FALSE); 3208 break; 3209 } 3210 return (TRUE); 3211 } 3212 3213 bool_t 3214 xdr_CB_WANTS_CANCELLED4args(XDR *xdrs, CB_WANTS_CANCELLED4args *objp) 3215 { 3216 if (!xdr_bool(xdrs, &objp->cwca_contended_wants_cancelled)) 3217 return (FALSE); 3218 if (!xdr_bool(xdrs, &objp->cwca_resourced_wants_cancelled)) 3219 return (FALSE); 3220 return (TRUE); 3221 } 3222 3223 bool_t 3224 xdr_CB_WANTS_CANCELLED4res(XDR *xdrs, CB_WANTS_CANCELLED4res *objp) 3225 { 3226 if (!xdr_nfsstat4(xdrs, &objp->cwcr_status)) 3227 return (FALSE); 3228 return (TRUE); 3229 } 3230 3231 bool_t 3232 xdr_CB_NOTIFY_LOCK4args(XDR *xdrs, CB_NOTIFY_LOCK4args *objp) 3233 { 3234 if (!xdr_nfs_fh4(xdrs, &objp->cnla_fh)) 3235 return (FALSE); 3236 if (!xdr_lock_owner4(xdrs, &objp->cnla_lock_owner)) 3237 return (FALSE); 3238 return (TRUE); 3239 } 3240 3241 bool_t 3242 xdr_CB_NOTIFY_LOCK4res(XDR *xdrs, CB_NOTIFY_LOCK4res *objp) 3243 { 3244 if (!xdr_nfsstat4(xdrs, &objp->cnlr_status)) 3245 return (FALSE); 3246 return (TRUE); 3247 } 3248 3249 bool_t 3250 xdr_notify_deviceid_type4(XDR *xdrs, notify_deviceid_type4 *objp) 3251 { 3252 3253 if (!xdr_enum(xdrs, (enum_t *)objp)) 3254 return (FALSE); 3255 return (TRUE); 3256 } 3257 3258 bool_t 3259 xdr_notify_deviceid_delete4(XDR *xdrs, notify_deviceid_delete4 *objp) 3260 { 3261 if (!xdr_layouttype4(xdrs, &objp->ndd_layouttype)) 3262 return (FALSE); 3263 if (!xdr_deviceid4(xdrs, objp->ndd_deviceid)) 3264 return (FALSE); 3265 return (TRUE); 3266 } 3267 3268 bool_t 3269 xdr_notify_deviceid_change4(XDR *xdrs, notify_deviceid_change4 *objp) 3270 { 3271 3272 if (!xdr_layouttype4(xdrs, &objp->ndc_layouttype)) 3273 return (FALSE); 3274 if (!xdr_deviceid4(xdrs, objp->ndc_deviceid)) 3275 return (FALSE); 3276 if (!xdr_bool(xdrs, &objp->ndc_immediate)) 3277 return (FALSE); 3278 return (TRUE); 3279 } 3280 3281 bool_t 3282 xdr_CB_NOTIFY_DEVICEID4args(XDR *xdrs, CB_NOTIFY_DEVICEID4args *objp) 3283 { 3284 if (!xdr_array(xdrs, (char **)&objp->cnda_changes.cnda_changes_val, 3285 (uint_t *)&objp->cnda_changes.cnda_changes_len, ~0, 3286 sizeof (notify4), (xdrproc_t)xdr_notify4)) 3287 return (FALSE); 3288 return (TRUE); 3289 } 3290 3291 bool_t 3292 xdr_CB_NOTIFY_DEVICEID4res(XDR *xdrs, CB_NOTIFY_DEVICEID4res *objp) 3293 { 3294 if (!xdr_nfsstat4(xdrs, &objp->cndr_status)) 3295 return (FALSE); 3296 return (TRUE); 3297 } 3298 3299 /* Callback operations new to NFSv4.1 */ 3300 3301 bool_t 3302 xdr_nfs_cb_argop4(XDR *xdrs, nfs_cb_argop4 *objp) 3303 { 3304 /* argop has already been xdr'd */ 3305 switch (objp->argop) { 3306 case OP_CB_LAYOUTRECALL: 3307 if (!xdr_CB_LAYOUTRECALL4args(xdrs, 3308 &objp->nfs_cb_argop4_u.opcblayoutrecall)) 3309 return (FALSE); 3310 break; 3311 case OP_CB_NOTIFY: 3312 if (!xdr_CB_NOTIFY4args(xdrs, 3313 &objp->nfs_cb_argop4_u.opcbnotify)) 3314 return (FALSE); 3315 break; 3316 case OP_CB_PUSH_DELEG: 3317 if (!xdr_CB_PUSH_DELEG4args(xdrs, 3318 &objp->nfs_cb_argop4_u.opcbpush_deleg)) 3319 return (FALSE); 3320 break; 3321 case OP_CB_RECALL_ANY: 3322 if (!xdr_CB_RECALL_ANY4args(xdrs, 3323 &objp->nfs_cb_argop4_u.opcbrecall_any)) 3324 return (FALSE); 3325 break; 3326 case OP_CB_RECALLABLE_OBJ_AVAIL: 3327 if (!xdr_CB_RECALLABLE_OBJ_AVAIL4args(xdrs, 3328 &objp->nfs_cb_argop4_u.opcbrecallable_obj_avail)) 3329 return (FALSE); 3330 break; 3331 case OP_CB_RECALL_SLOT: 3332 if (!xdr_CB_RECALL_SLOT4args(xdrs, 3333 &objp->nfs_cb_argop4_u.opcbrecall_slot)) 3334 return (FALSE); 3335 break; 3336 case OP_CB_SEQUENCE: 3337 if (!xdr_CB_SEQUENCE4args(xdrs, 3338 &objp->nfs_cb_argop4_u.opcbsequence)) 3339 return (FALSE); 3340 break; 3341 case OP_CB_WANTS_CANCELLED: 3342 if (!xdr_CB_WANTS_CANCELLED4args(xdrs, 3343 &objp->nfs_cb_argop4_u.opcbwants_cancelled)) 3344 return (FALSE); 3345 break; 3346 case OP_CB_NOTIFY_LOCK: 3347 if (!xdr_CB_NOTIFY_LOCK4args(xdrs, 3348 &objp->nfs_cb_argop4_u.opcbnotify_lock)) 3349 return (FALSE); 3350 break; 3351 case OP_CB_NOTIFY_DEVICEID: 3352 if (!xdr_CB_NOTIFY_DEVICEID4args(xdrs, 3353 &objp->nfs_cb_argop4_u.opcbnotify_deviceid)) 3354 return (FALSE); 3355 break; 3356 default: 3357 return (FALSE); 3358 } 3359 return (TRUE); 3360 } 3361 3362 bool_t 3363 xdr_CB_GETATTR4res(XDR *xdrs, CB_GETATTR4res *objp) 3364 { 3365 if (!xdr_nfsstat4(xdrs, &objp->status)) 3366 return (FALSE); 3367 3368 switch (objp->status) { 3369 case NFS4_OK: 3370 if (!xdr_fattr4(xdrs, &objp->obj_attributes)) 3371 return (FALSE); 3372 break; 3373 } 3374 return (TRUE); 3375 } 3376 3377 bool_t 3378 xdr_CB_RECALL4res(XDR *xdrs, CB_RECALL4res *objp) 3379 { 3380 if (!xdr_nfsstat4(xdrs, &objp->status)) 3381 return (FALSE); 3382 return (TRUE); 3383 } 3384 3385 bool_t 3386 xdr_CB_ILLEGAL4res(XDR *xdrs, CB_ILLEGAL4res *objp) 3387 { 3388 if (!xdr_nfsstat4(xdrs, &objp->status)) 3389 return (FALSE); 3390 return (TRUE); 3391 } 3392 3393 bool_t 3394 xdr_nfs_cb_resop4(XDR *xdrs, nfs_cb_resop4 *objp) 3395 { 3396 if (!xdr_u_int(xdrs, &objp->resop)) 3397 return (FALSE); 3398 3399 switch (objp->resop) { 3400 case OP_CB_GETATTR: 3401 if (!xdr_CB_GETATTR4res(xdrs, 3402 &objp->nfs_cb_resop4_u.opcbgetattr)) 3403 return (FALSE); 3404 break; 3405 case OP_CB_RECALL: 3406 if (!xdr_CB_RECALL4res(xdrs, 3407 &objp->nfs_cb_resop4_u.opcbrecall)) 3408 return (FALSE); 3409 break; 3410 case OP_CB_LAYOUTRECALL: 3411 if (!xdr_CB_LAYOUTRECALL4res(xdrs, 3412 &objp->nfs_cb_resop4_u.opcblayoutrecall)) 3413 return (FALSE); 3414 break; 3415 case OP_CB_NOTIFY: 3416 if (!xdr_CB_NOTIFY4res(xdrs, 3417 &objp->nfs_cb_resop4_u.opcbnotify)) 3418 return (FALSE); 3419 break; 3420 case OP_CB_PUSH_DELEG: 3421 if (!xdr_CB_PUSH_DELEG4res(xdrs, 3422 &objp->nfs_cb_resop4_u.opcbpush_deleg)) 3423 return (FALSE); 3424 break; 3425 case OP_CB_RECALL_ANY: 3426 if (!xdr_CB_RECALL_ANY4res(xdrs, 3427 &objp->nfs_cb_resop4_u.opcbrecall_any)) 3428 return (FALSE); 3429 break; 3430 case OP_CB_RECALLABLE_OBJ_AVAIL: 3431 if (!xdr_CB_RECALLABLE_OBJ_AVAIL4res(xdrs, 3432 &objp->nfs_cb_resop4_u.opcbrecallable_obj_avail)) 3433 return (FALSE); 3434 break; 3435 case OP_CB_RECALL_SLOT: 3436 if (!xdr_CB_RECALL_SLOT4res(xdrs, 3437 &objp->nfs_cb_resop4_u.opcbrecall_slot)) 3438 return (FALSE); 3439 break; 3440 case OP_CB_SEQUENCE: 3441 if (!xdr_CB_SEQUENCE4res(xdrs, 3442 &objp->nfs_cb_resop4_u.opcbsequence)) 3443 return (FALSE); 3444 break; 3445 case OP_CB_WANTS_CANCELLED: 3446 if (!xdr_CB_WANTS_CANCELLED4res(xdrs, 3447 &objp->nfs_cb_resop4_u.opcbwants_cancelled)) 3448 return (FALSE); 3449 break; 3450 case OP_CB_NOTIFY_LOCK: 3451 if (!xdr_CB_NOTIFY_LOCK4res(xdrs, 3452 &objp->nfs_cb_resop4_u.opcbnotify_lock)) 3453 return (FALSE); 3454 break; 3455 case OP_CB_NOTIFY_DEVICEID: 3456 if (!xdr_CB_NOTIFY_DEVICEID4res(xdrs, 3457 &objp->nfs_cb_resop4_u.opcbnotify_deviceid)) 3458 return (FALSE); 3459 break; 3460 case OP_CB_ILLEGAL: 3461 if (!xdr_CB_ILLEGAL4res(xdrs, 3462 &objp->nfs_cb_resop4_u.opcbillegal)) 3463 return (FALSE); 3464 break; 3465 default: 3466 return (FALSE); 3467 } 3468 return (TRUE); 3469 } 3470 3471 /* 3472 * Additional common NFSv4 XDR 3473 */ 3474 3475 bool_t 3476 xdr_clientid4(XDR *xdrs, clientid4 *objp) 3477 { 3478 if (!xdr_uint64_t(xdrs, objp)) 3479 return (FALSE); 3480 return (TRUE); 3481 } 3482 3483 bool_t 3484 xdr_component4(XDR *xdrs, component4 *objp) 3485 { 3486 if (!xdr_utf8string(xdrs, objp)) 3487 return (FALSE); 3488 return (TRUE); 3489 } 3490 3491 bool_t 3492 xdr_count4(XDR *xdrs, count4 *objp) 3493 { 3494 if (!xdr_uint32_t(xdrs, objp)) 3495 return (FALSE); 3496 return (TRUE); 3497 } 3498 3499 bool_t 3500 xdr_fsid4(XDR *xdrs, fsid4 *objp) 3501 { 3502 if (!xdr_uint64_t(xdrs, &objp->major)) 3503 return (FALSE); 3504 if (!xdr_uint64_t(xdrs, &objp->minor)) 3505 return (FALSE); 3506 return (TRUE); 3507 } 3508 3509 bool_t 3510 xdr_length4(XDR *xdrs, length4 *objp) 3511 { 3512 if (!xdr_uint64_t(xdrs, objp)) 3513 return (FALSE); 3514 return (TRUE); 3515 } 3516 3517 bool_t 3518 xdr_limit_by4(XDR *xdrs, limit_by4 *objp) 3519 { 3520 if (!xdr_enum(xdrs, (enum_t *)objp)) 3521 return (FALSE); 3522 return (TRUE); 3523 } 3524 3525 bool_t 3526 xdr_lock_owner4(XDR *xdrs, lock_owner4 *objp) 3527 { 3528 if (!xdr_clientid4(xdrs, &objp->clientid)) 3529 return (FALSE); 3530 if (!xdr_bytes(xdrs, (char **)&objp->owner_val, 3531 (uint_t *)&objp->owner_len, NFS4_OPAQUE_LIMIT)) 3532 return (FALSE); 3533 return (TRUE); 3534 } 3535 3536 bool_t 3537 xdr_mode4(XDR *xdrs, mode4 *objp) 3538 { 3539 if (!xdr_uint32_t(xdrs, objp)) 3540 return (FALSE); 3541 return (TRUE); 3542 } 3543 3544 bool_t 3545 xdr_netaddr4(XDR *xdrs, netaddr4 *objp) 3546 { 3547 if (!xdr_string(xdrs, &objp->na_r_netid, ~0)) 3548 return (FALSE); 3549 if (!xdr_string(xdrs, &objp->na_r_addr, ~0)) 3550 return (FALSE); 3551 return (TRUE); 3552 } 3553 3554 bool_t 3555 xdr_nfs_cookie4(XDR *xdrs, nfs_cookie4 *objp) 3556 { 3557 if (!xdr_uint64_t(xdrs, objp)) 3558 return (FALSE); 3559 return (TRUE); 3560 } 3561 3562 3563 bool_t 3564 xdr_nfs_modified_limit4(XDR *xdrs, nfs_modified_limit4 *objp) 3565 { 3566 if (!xdr_uint32_t(xdrs, &objp->num_blocks)) 3567 return (FALSE); 3568 if (!xdr_uint32_t(xdrs, &objp->bytes_per_block)) 3569 return (FALSE); 3570 return (TRUE); 3571 } 3572 3573 3574 bool_t 3575 xdr_nfs_space_limit4(XDR *xdrs, nfs_space_limit4 *objp) 3576 { 3577 if (!xdr_limit_by4(xdrs, &objp->limitby)) 3578 return (FALSE); 3579 switch (objp->limitby) { 3580 case NFS_LIMIT_SIZE: 3581 if (!xdr_uint64_t(xdrs, &objp->nfs_space_limit4_u.filesize)) 3582 return (FALSE); 3583 break; 3584 case NFS_LIMIT_BLOCKS: 3585 if (!xdr_nfs_modified_limit4(xdrs, 3586 &objp->nfs_space_limit4_u.mod_blocks)) 3587 return (FALSE); 3588 break; 3589 default: 3590 return (FALSE); 3591 } 3592 return (TRUE); 3593 } 3594 3595 bool_t 3596 xdr_nfsstat4(XDR *xdrs, nfsstat4 *objp) 3597 { 3598 if (!xdr_enum(xdrs, (enum_t *)objp)) 3599 return (FALSE); 3600 return (TRUE); 3601 } 3602 3603 bool_t 3604 xdr_offset4(XDR *xdrs, offset4 *objp) 3605 { 3606 if (!xdr_uint64_t(xdrs, objp)) 3607 return (FALSE); 3608 return (TRUE); 3609 } 3610 3611 bool_t 3612 xdr_open_claim_type4(XDR *xdrs, open_claim_type4 *objp) 3613 { 3614 if (!xdr_enum(xdrs, (enum_t *)objp)) 3615 return (FALSE); 3616 return (TRUE); 3617 } 3618 3619 bool_t 3620 xdr_open_delegation_type4(XDR *xdrs, open_delegation_type4 *objp) 3621 { 3622 if (!xdr_enum(xdrs, (enum_t *)objp)) 3623 return (FALSE); 3624 return (TRUE); 3625 } 3626 3627 bool_t 3628 xdr_open_read_delegation4(XDR *xdrs, open_read_delegation4 *objp) 3629 { 3630 if (!xdr_stateid4(xdrs, &objp->stateid)) 3631 return (FALSE); 3632 if (!xdr_bool(xdrs, &objp->recall)) 3633 return (FALSE); 3634 if (!xdr_nfsace4(xdrs, &objp->permissions)) 3635 return (FALSE); 3636 return (TRUE); 3637 } 3638 3639 bool_t 3640 xdr_open_write_delegation4(XDR *xdrs, open_write_delegation4 *objp) 3641 { 3642 if (!xdr_stateid4(xdrs, &objp->stateid)) 3643 return (FALSE); 3644 if (!xdr_bool(xdrs, &objp->recall)) 3645 return (FALSE); 3646 if (!xdr_nfs_space_limit4(xdrs, &objp->space_limit)) 3647 return (FALSE); 3648 if (!xdr_nfsace4(xdrs, &objp->permissions)) 3649 return (FALSE); 3650 return (TRUE); 3651 } 3652 3653 bool_t 3654 xdr_pathname4(XDR *xdrs, pathname4 *objp) 3655 { 3656 if (!xdr_array(xdrs, (char **)&objp->pathname4_val, 3657 (uint_t *)&objp->pathname4_len, ~0, sizeof (component4), 3658 (xdrproc_t)xdr_component4)) 3659 return (FALSE); 3660 return (TRUE); 3661 } 3662 3663 bool_t 3664 xdr_sec_oid4(XDR *xdrs, sec_oid4 *objp) 3665 { 3666 if (!xdr_bytes(xdrs, (char **)&objp->sec_oid4_val, 3667 (uint_t *)&objp->sec_oid4_len, ~0)) 3668 return (FALSE); 3669 return (TRUE); 3670 } 3671 3672 bool_t 3673 xdr_rpc_gss_svc_t(XDR *xdrs, rpc_gss_svc_t *objp) 3674 { 3675 if (!xdr_enum(xdrs, (enum_t *)objp)) 3676 return (FALSE); 3677 return (TRUE); 3678 } 3679 3680 bool_t 3681 xdr_stateid4(XDR *xdrs, stateid4 *objp) 3682 { 3683 if (!xdr_uint32_t(xdrs, &objp->seqid)) 3684 return (FALSE); 3685 if (!xdr_opaque(xdrs, objp->other, 12)) 3686 return (FALSE); 3687 return (TRUE); 3688 } 3689 3690 bool_t 3691 xdr_utf8str_cis(XDR *xdrs, utf8str_cis *objp) 3692 { 3693 if (!xdr_utf8string(xdrs, objp)) 3694 return (FALSE); 3695 return (TRUE); 3696 } 3697 3698 bool_t 3699 xdr_utf8str_cs(XDR *xdrs, utf8str_cs *objp) 3700 { 3701 if (!xdr_utf8string(xdrs, objp)) 3702 return (FALSE); 3703 return (TRUE); 3704 } 3705 3706 /* End of additional common NFSv4 XDR */ 3707