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 RackTop Systems. 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_fattr4_mode_set_masked(XDR *xdrs, fattr4_mode_set_masked *objp) 366 { 367 if (!xdr_mode_masked4(xdrs, objp)) 368 return (FALSE); 369 return (TRUE); 370 } 371 372 bool_t 373 xdr_fattr4_dir_notif_delay(XDR *xdrs, fattr4_dir_notif_delay *objp) 374 { 375 376 if (!xdr_nfstime4(xdrs, objp)) 377 return (FALSE); 378 return (TRUE); 379 } 380 381 bool_t 382 xdr_fattr4_dirent_notif_delay(XDR *xdrs, fattr4_dirent_notif_delay *objp) 383 { 384 if (!xdr_nfstime4(xdrs, objp)) 385 return (FALSE); 386 return (TRUE); 387 } 388 389 bool_t 390 xdr_fattr4_fs_layout_types(XDR *xdrs, fattr4_fs_layout_types *objp) 391 { 392 if (!xdr_array(xdrs, (char **)&objp->fattr4_fs_layout_types_val, 393 (uint_t *)&objp->fattr4_fs_layout_types_len, ~0, 394 sizeof (layouttype4), (xdrproc_t)xdr_layouttype4)) 395 return (FALSE); 396 return (TRUE); 397 } 398 399 bool_t 400 xdr_fattr4_fs_status(XDR *xdrs, fattr4_fs_status *objp) 401 { 402 if (!xdr_fs4_status(xdrs, objp)) 403 return (FALSE); 404 return (TRUE); 405 } 406 407 bool_t 408 xdr_fattr4_fs_charset_cap4(XDR *xdrs, fattr4_fs_charset_cap *objp) 409 { 410 if (!xdr_fs_charset_cap4(xdrs, objp)) 411 return (FALSE); 412 return (TRUE); 413 } 414 415 bool_t 416 xdr_fattr4_retention_get(XDR *xdrs, fattr4_retention_get *objp) 417 { 418 if (!xdr_retention_get4(xdrs, objp)) 419 return (FALSE); 420 return (TRUE); 421 } 422 423 bool_t 424 xdr_fattr4_retention_set(XDR *xdrs, fattr4_retention_set *objp) 425 { 426 if (!xdr_retention_set4(xdrs, objp)) 427 return (FALSE); 428 return (TRUE); 429 } 430 431 bool_t 432 xdr_fattr4_retentevt_get(XDR *xdrs, fattr4_retentevt_get *objp) 433 { 434 if (!xdr_retention_get4(xdrs, objp)) 435 return (FALSE); 436 return (TRUE); 437 } 438 439 bool_t 440 xdr_fattr4_retentevt_set(XDR *xdrs, fattr4_retentevt_set *objp) 441 { 442 if (!xdr_retention_set4(xdrs, objp)) 443 return (FALSE); 444 return (TRUE); 445 } 446 447 bool_t 448 xdr_fattr4_retention_hold(XDR *xdrs, fattr4_retention_hold *objp) 449 { 450 if (!xdr_uint64_t(xdrs, objp)) 451 return (FALSE); 452 return (TRUE); 453 } 454 455 bool_t 456 xdr_fattr4_dacl(XDR *xdrs, fattr4_dacl *objp) 457 { 458 if (!xdr_nfsacl41(xdrs, objp)) 459 return (FALSE); 460 return (TRUE); 461 } 462 463 bool_t 464 xdr_fattr4_sacl(XDR *xdrs, fattr4_sacl *objp) 465 { 466 if (!xdr_nfsacl41(xdrs, objp)) 467 return (FALSE); 468 return (TRUE); 469 } 470 471 bool_t 472 xdr_client_owner4(XDR *xdrs, client_owner4 *objp) 473 { 474 if (!xdr_verifier4(xdrs, (verifier4 *)&objp->co_verifier)) 475 return (FALSE); 476 if (!xdr_bytes(xdrs, (char **)&objp->co_ownerid.co_ownerid_val, 477 (uint_t *)&objp->co_ownerid.co_ownerid_len, NFS4_OPAQUE_LIMIT)) 478 return (FALSE); 479 return (TRUE); 480 } 481 482 bool_t 483 xdr_server_owner4(XDR *xdrs, server_owner4 *objp) 484 { 485 if (!xdr_uint64_t(xdrs, &objp->so_minor_id)) 486 return (FALSE); 487 if (!xdr_bytes(xdrs, (char **)&objp->so_major_id.so_major_id_val, 488 (uint_t *)&objp->so_major_id.so_major_id_len, NFS4_OPAQUE_LIMIT)) 489 return (FALSE); 490 return (TRUE); 491 } 492 493 bool_t 494 xdr_state_owner4(XDR *xdrs, state_owner4 *objp) 495 { 496 if (!xdr_clientid4(xdrs, &objp->clientid)) 497 return (FALSE); 498 if (!xdr_bytes(xdrs, (char **)&objp->owner.owner_val, 499 (uint_t *)&objp->owner.owner_len, NFS4_OPAQUE_LIMIT)) 500 return (FALSE); 501 return (TRUE); 502 } 503 504 /* Input for computing subkeys */ 505 506 bool_t 507 xdr_ssv_subkey4(XDR *xdrs, ssv_subkey4 *objp) 508 { 509 if (!xdr_enum(xdrs, (enum_t *)objp)) 510 return (FALSE); 511 return (TRUE); 512 } 513 514 515 /* Input for computing smt_hmac */ 516 517 bool_t 518 xdr_ssv_mic_plain_tkn4(XDR *xdrs, ssv_mic_plain_tkn4 *objp) 519 { 520 if (!xdr_uint32_t(xdrs, &objp->smpt_ssv_seq)) 521 return (FALSE); 522 if (!xdr_bytes(xdrs, 523 (char **)&objp->smpt_orig_plain.smpt_orig_plain_val, 524 (uint_t *)&objp->smpt_orig_plain.smpt_orig_plain_len, ~0)) 525 return (FALSE); 526 return (TRUE); 527 } 528 529 530 /* SSV GSS PerMsgToken token */ 531 532 bool_t 533 xdr_ssv_mic_tkn4(XDR *xdrs, ssv_mic_tkn4 *objp) 534 { 535 if (!xdr_uint32_t(xdrs, &objp->smt_ssv_seq)) 536 return (FALSE); 537 if (!xdr_bytes(xdrs, (char **)&objp->smt_hmac.smt_hmac_val, 538 (uint_t *)&objp->smt_hmac.smt_hmac_len, ~0)) 539 return (FALSE); 540 return (TRUE); 541 } 542 543 544 /* Input for computing ssct_encr_data and ssct_hmac */ 545 546 bool_t 547 xdr_ssv_seal_plain_tkn4(XDR *xdrs, ssv_seal_plain_tkn4 *objp) 548 { 549 if (!xdr_bytes(xdrs, 550 (char **)&objp->sspt_confounder.sspt_confounder_val, 551 (uint_t *)&objp->sspt_confounder.sspt_confounder_len, ~0)) 552 return (FALSE); 553 if (!xdr_uint32_t(xdrs, &objp->sspt_ssv_seq)) 554 return (FALSE); 555 if (!xdr_bytes(xdrs, 556 (char **)&objp->sspt_orig_plain.sspt_orig_plain_val, 557 (uint_t *)&objp->sspt_orig_plain.sspt_orig_plain_len, ~0)) 558 return (FALSE); 559 if (!xdr_bytes(xdrs, (char **)&objp->sspt_pad.sspt_pad_val, 560 (uint_t *)&objp->sspt_pad.sspt_pad_len, ~0)) 561 return (FALSE); 562 return (TRUE); 563 } 564 565 566 /* SSV GSS SealedMessage token */ 567 568 bool_t 569 xdr_ssv_seal_cipher_tkn4(XDR *xdrs, ssv_seal_cipher_tkn4 *objp) 570 { 571 if (!xdr_uint32_t(xdrs, &objp->ssct_ssv_seq)) 572 return (FALSE); 573 if (!xdr_bytes(xdrs, (char **)&objp->ssct_iv.ssct_iv_val, 574 (uint_t *)&objp->ssct_iv.ssct_iv_len, ~0)) 575 return (FALSE); 576 if (!xdr_bytes(xdrs, (char **)&objp->ssct_encr_data.ssct_encr_data_val, 577 (uint_t *)&objp->ssct_encr_data.ssct_encr_data_len, ~0)) 578 return (FALSE); 579 if (!xdr_bytes(xdrs, (char **)&objp->ssct_hmac.ssct_hmac_val, 580 (uint_t *)&objp->ssct_hmac.ssct_hmac_len, ~0)) 581 return (FALSE); 582 return (TRUE); 583 } 584 585 586 bool_t 587 xdr_fs_locations_server4(XDR *xdrs, fs_locations_server4 *objp) 588 { 589 if (!xdr_int32_t(xdrs, &objp->fls_currency)) 590 return (FALSE); 591 if (!xdr_bytes(xdrs, (char **)&objp->fls_info.fls_info_val, 592 (uint_t *)&objp->fls_info.fls_info_len, ~0)) 593 return (FALSE); 594 if (!xdr_utf8str_cis(xdrs, &objp->fls_server)) 595 return (FALSE); 596 return (TRUE); 597 } 598 599 bool_t 600 xdr_fs_locations_item4(XDR *xdrs, fs_locations_item4 *objp) 601 { 602 if (!xdr_array(xdrs, (char **)&objp->fli_entries.fli_entries_val, 603 (uint_t *)&objp->fli_entries.fli_entries_len, ~0, 604 sizeof (fs_locations_server4), (xdrproc_t)xdr_fs_locations_server4)) 605 return (FALSE); 606 if (!xdr_pathname4(xdrs, &objp->fli_rootpath)) 607 return (FALSE); 608 return (TRUE); 609 } 610 611 bool_t 612 xdr_fs_locations_info4(XDR *xdrs, fs_locations_info4 *objp) 613 { 614 if (!xdr_uint32_t(xdrs, &objp->fli_flags)) 615 return (FALSE); 616 if (!xdr_int32_t(xdrs, &objp->fli_valid_for)) 617 return (FALSE); 618 if (!xdr_pathname4(xdrs, &objp->fli_fs_root)) 619 return (FALSE); 620 if (!xdr_array(xdrs, (char **)&objp->fli_items.fli_items_val, 621 (uint_t *)&objp->fli_items.fli_items_len, ~0, 622 sizeof (fs_locations_item4), (xdrproc_t)xdr_fs_locations_item4)) 623 return (FALSE); 624 return (TRUE); 625 } 626 627 bool_t 628 xdr_fattr4_fs_locations_info(XDR *xdrs, fattr4_fs_locations_info *objp) 629 { 630 if (!xdr_fs_locations_info4(xdrs, objp)) 631 return (FALSE); 632 return (TRUE); 633 } 634 635 bool_t 636 xdr_nfl_util4(XDR *xdrs, nfl_util4 *objp) 637 { 638 if (!xdr_uint32_t(xdrs, objp)) 639 return (FALSE); 640 return (TRUE); 641 } 642 643 bool_t 644 xdr_filelayout_hint_care4(XDR *xdrs, filelayout_hint_care4 *objp) 645 { 646 if (!xdr_enum(xdrs, (enum_t *)objp)) 647 return (FALSE); 648 return (TRUE); 649 } 650 651 652 bool_t 653 xdr_multipath_list4(XDR *xdrs, multipath_list4 *objp) 654 { 655 if (!xdr_array(xdrs, (char **)&objp->multipath_list4_val, 656 (uint_t *)&objp->multipath_list4_len, ~0, 657 sizeof (netaddr4), (xdrproc_t)xdr_netaddr4)) 658 return (FALSE); 659 return (TRUE); 660 } 661 662 /* Encoded in the da_addr_body field of type device_addr4: */ 663 664 bool_t 665 xdr_nfsv4_1_file_layout_ds_addr4(XDR *xdrs, nfsv4_1_file_layout_ds_addr4 *objp) 666 { 667 if (!xdr_array(xdrs, 668 (char **)&objp->nflda_stripe_indices.nflda_stripe_indices_val, 669 (uint_t *)&objp->nflda_stripe_indices.nflda_stripe_indices_len, ~0, 670 sizeof (uint32_t), (xdrproc_t)xdr_uint32_t)) 671 return (FALSE); 672 if (!xdr_array(xdrs, 673 (char **)&objp->nflda_multipath_ds_list.nflda_multipath_ds_list_val, 674 (uint_t *)&objp->nflda_multipath_ds_list. 675 nflda_multipath_ds_list_len, ~0, sizeof (multipath_list4), 676 (xdrproc_t)xdr_multipath_list4)) 677 return (FALSE); 678 return (TRUE); 679 } 680 681 682 /* Encoded in the loc_body field of type layout_content4: */ 683 684 bool_t 685 xdr_nfsv4_1_file_layout4(XDR *xdrs, nfsv4_1_file_layout4 *objp) 686 { 687 if (!xdr_deviceid4(xdrs, objp->nfl_deviceid)) 688 return (FALSE); 689 if (!xdr_nfl_util4(xdrs, &objp->nfl_util)) 690 return (FALSE); 691 if (!xdr_uint32_t(xdrs, &objp->nfl_first_stripe_index)) 692 return (FALSE); 693 if (!xdr_offset4(xdrs, &objp->nfl_pattern_offset)) 694 return (FALSE); 695 if (!xdr_array(xdrs, (char **)&objp->nfl_fh_list.nfl_fh_list_val, 696 (uint_t *)&objp->nfl_fh_list.nfl_fh_list_len, ~0, 697 sizeof (nfs_fh4), (xdrproc_t)xdr_nfs_fh4)) 698 return (FALSE); 699 return (TRUE); 700 } 701 702 /* 703 * Encoded in the lou_body field of type layoutupdate4: 704 * Nothing. lou_body is a zero length array of octets. 705 */ 706 707 708 bool_t 709 xdr_creatverfattr(XDR *xdrs, creatverfattr *objp) 710 { 711 if (!xdr_verifier4(xdrs, (verifier4 *)&objp->cva_verf)) 712 return (FALSE); 713 if (!xdr_fattr4(xdrs, &objp->cva_attrs)) 714 return (FALSE); 715 return (TRUE); 716 } 717 718 bool_t 719 xdr_open_claim_delegate_cur4(XDR *xdrs, open_claim_delegate_cur4 *objp) 720 { 721 if (!xdr_stateid4(xdrs, &objp->delegate_stateid)) 722 return (FALSE); 723 if (!xdr_component4(xdrs, &objp->file)) 724 return (FALSE); 725 return (TRUE); 726 } 727 728 bool_t 729 xdr_open_claim4(XDR *xdrs, open_claim4 *objp) 730 { 731 if (!xdr_open_claim_type4(xdrs, &objp->claim)) 732 return (FALSE); 733 switch (objp->claim) { 734 case CLAIM_NULL: 735 if (!xdr_component4(xdrs, &objp->open_claim4_u.file)) 736 return (FALSE); 737 break; 738 case CLAIM_PREVIOUS: 739 if (!xdr_open_delegation_type4(xdrs, 740 &objp->open_claim4_u.delegate_type)) 741 return (FALSE); 742 break; 743 case CLAIM_DELEGATE_CUR: 744 if (!xdr_open_claim_delegate_cur4(xdrs, 745 &objp->open_claim4_u.delegate_cur_info)) 746 return (FALSE); 747 break; 748 case CLAIM_DELEGATE_PREV: 749 if (!xdr_component4(xdrs, 750 &objp->open_claim4_u.file_delegate_prev)) 751 return (FALSE); 752 break; 753 case CLAIM_FH: 754 break; 755 case CLAIM_DELEG_PREV_FH: 756 break; 757 case CLAIM_DELEG_CUR_FH: 758 if (!xdr_stateid4(xdrs, 759 &objp->open_claim4_u.oc_delegate_stateid)) 760 return (FALSE); 761 break; 762 default: 763 return (FALSE); 764 } 765 return (TRUE); 766 } 767 768 bool_t 769 xdr_why_no_delegation4(XDR *xdrs, why_no_delegation4 *objp) 770 { 771 if (!xdr_enum(xdrs, (enum_t *)objp)) 772 return (FALSE); 773 return (TRUE); 774 } 775 776 bool_t 777 xdr_open_none_delegation4(XDR *xdrs, open_none_delegation4 *objp) 778 { 779 if (!xdr_why_no_delegation4(xdrs, &objp->ond_why)) 780 return (FALSE); 781 switch (objp->ond_why) { 782 case WND4_CONTENTION: 783 if (!xdr_bool(xdrs, 784 &objp->open_none_delegation4_u.ond_server_will_push_deleg)) 785 return (FALSE); 786 break; 787 case WND4_RESOURCE: 788 if (!xdr_bool(xdrs, &objp->open_none_delegation4_u. 789 ond_server_will_signal_avail)) 790 return (FALSE); 791 break; 792 } 793 return (TRUE); 794 } 795 796 bool_t 797 xdr_open_delegation4(XDR *xdrs, open_delegation4 *objp) 798 { 799 if (!xdr_open_delegation_type4(xdrs, &objp->delegation_type)) 800 return (FALSE); 801 switch (objp->delegation_type) { 802 case OPEN_DELEGATE_NONE: 803 break; 804 case OPEN_DELEGATE_READ: 805 if (!xdr_open_read_delegation4(xdrs, 806 &objp->open_delegation4_u.read)) 807 return (FALSE); 808 break; 809 case OPEN_DELEGATE_WRITE: 810 if (!xdr_open_write_delegation4(xdrs, 811 &objp->open_delegation4_u.write)) 812 return (FALSE); 813 break; 814 case OPEN_DELEGATE_NONE_EXT: 815 if (!xdr_open_none_delegation4(xdrs, 816 &objp->open_delegation4_u.od_whynone)) 817 return (FALSE); 818 break; 819 default: 820 return (FALSE); 821 } 822 return (TRUE); 823 } 824 825 bool_t 826 xdr_gsshandle4_t(XDR *xdrs, gsshandle4_t *objp) 827 { 828 if (!xdr_bytes(xdrs, (char **)&objp->gsshandle4_t_val, 829 (uint_t *)&objp->gsshandle4_t_len, ~0)) 830 return (FALSE); 831 return (TRUE); 832 } 833 834 bool_t 835 xdr_gss_cb_handles4(XDR *xdrs, gss_cb_handles4 *objp) 836 { 837 if (!xdr_rpc_gss_svc_t(xdrs, &objp->gcbp_service)) 838 return (FALSE); 839 if (!xdr_gsshandle4_t(xdrs, &objp->gcbp_handle_from_server)) 840 return (FALSE); 841 if (!xdr_gsshandle4_t(xdrs, &objp->gcbp_handle_from_client)) 842 return (FALSE); 843 return (TRUE); 844 } 845 846 bool_t 847 xdr_callback_sec_parms4(XDR *xdrs, callback_sec_parms4 *objp) 848 { 849 if (!xdr_uint32_t(xdrs, &objp->cb_secflavor)) 850 return (FALSE); 851 switch (objp->cb_secflavor) { 852 case AUTH_NONE: 853 break; 854 case AUTH_SYS: 855 if (!xdr_authsys_parms(xdrs, 856 &objp->callback_sec_parms4_u.cbsp_sys_cred)) 857 return (FALSE); 858 break; 859 case RPCSEC_GSS: 860 if (!xdr_gss_cb_handles4(xdrs, 861 &objp->callback_sec_parms4_u.cbsp_gss_handles)) 862 return (FALSE); 863 break; 864 default: 865 return (FALSE); 866 } 867 return (TRUE); 868 } 869 870 bool_t 871 xdr_BACKCHANNEL_CTL4args(XDR *xdrs, BACKCHANNEL_CTL4args *objp) 872 { 873 if (!xdr_uint32_t(xdrs, &objp->bca_cb_program)) 874 return (FALSE); 875 if (!xdr_array(xdrs, (char **)&objp->bca_sec_parms.bca_sec_parms_val, 876 (uint_t *)&objp->bca_sec_parms.bca_sec_parms_len, ~0, 877 sizeof (callback_sec_parms4), (xdrproc_t)xdr_callback_sec_parms4)) 878 return (FALSE); 879 return (TRUE); 880 } 881 882 bool_t 883 xdr_BACKCHANNEL_CTL4res(XDR *xdrs, BACKCHANNEL_CTL4res *objp) 884 { 885 if (!xdr_nfsstat4(xdrs, &objp->bcr_status)) 886 return (FALSE); 887 return (TRUE); 888 } 889 890 bool_t 891 xdr_channel_dir_from_client4(XDR *xdrs, channel_dir_from_client4 *objp) 892 { 893 if (!xdr_enum(xdrs, (enum_t *)objp)) 894 return (FALSE); 895 return (TRUE); 896 } 897 898 bool_t 899 xdr_BIND_CONN_TO_SESSION4args(XDR *xdrs, BIND_CONN_TO_SESSION4args *objp) 900 { 901 if (!xdr_sessionid4(xdrs, objp->bctsa_sessid)) 902 return (FALSE); 903 if (!xdr_channel_dir_from_client4(xdrs, &objp->bctsa_dir)) 904 return (FALSE); 905 if (!xdr_bool(xdrs, &objp->bctsa_use_conn_in_rdma_mode)) 906 return (FALSE); 907 return (TRUE); 908 } 909 910 bool_t 911 xdr_channel_dir_from_server4(XDR *xdrs, channel_dir_from_server4 *objp) 912 { 913 if (!xdr_enum(xdrs, (enum_t *)objp)) 914 return (FALSE); 915 return (TRUE); 916 } 917 918 bool_t 919 xdr_BIND_CONN_TO_SESSION4resok(XDR *xdrs, BIND_CONN_TO_SESSION4resok *objp) 920 { 921 if (!xdr_sessionid4(xdrs, objp->bctsr_sessid)) 922 return (FALSE); 923 if (!xdr_channel_dir_from_server4(xdrs, &objp->bctsr_dir)) 924 return (FALSE); 925 if (!xdr_bool(xdrs, &objp->bctsr_use_conn_in_rdma_mode)) 926 return (FALSE); 927 return (TRUE); 928 } 929 930 bool_t 931 xdr_BIND_CONN_TO_SESSION4res(XDR *xdrs, BIND_CONN_TO_SESSION4res *objp) 932 { 933 if (!xdr_nfsstat4(xdrs, &objp->bctsr_status)) 934 return (FALSE); 935 switch (objp->bctsr_status) { 936 case NFS4_OK: 937 if (!xdr_BIND_CONN_TO_SESSION4resok(xdrs, 938 &objp->BIND_CONN_TO_SESSION4res_u.bctsr_resok4)) 939 return (FALSE); 940 break; 941 } 942 return (TRUE); 943 } 944 945 bool_t 946 xdr_state_protect_ops4(XDR *xdrs, state_protect_ops4 *objp) 947 { 948 if (!xdr_bitmap4(xdrs, &objp->spo_must_enforce)) 949 return (FALSE); 950 if (!xdr_bitmap4(xdrs, &objp->spo_must_allow)) 951 return (FALSE); 952 return (TRUE); 953 } 954 955 bool_t 956 xdr_ssv_sp_parms4(XDR *xdrs, ssv_sp_parms4 *objp) 957 { 958 if (!xdr_state_protect_ops4(xdrs, &objp->ssp_ops)) 959 return (FALSE); 960 if (!xdr_array(xdrs, (char **)&objp->ssp_hash_algs.ssp_hash_algs_val, 961 (uint_t *)&objp->ssp_hash_algs.ssp_hash_algs_len, ~0, 962 sizeof (sec_oid4), (xdrproc_t)xdr_sec_oid4)) 963 return (FALSE); 964 if (!xdr_array(xdrs, (char **)&objp->ssp_encr_algs.ssp_encr_algs_val, 965 (uint_t *)&objp->ssp_encr_algs.ssp_encr_algs_len, ~0, 966 sizeof (sec_oid4), (xdrproc_t)xdr_sec_oid4)) 967 return (FALSE); 968 if (!xdr_uint32_t(xdrs, &objp->ssp_window)) 969 return (FALSE); 970 if (!xdr_uint32_t(xdrs, &objp->ssp_num_gss_handles)) 971 return (FALSE); 972 return (TRUE); 973 } 974 975 bool_t 976 xdr_state_protect_how4(XDR *xdrs, state_protect_how4 *objp) 977 { 978 if (!xdr_enum(xdrs, (enum_t *)objp)) 979 return (FALSE); 980 return (TRUE); 981 } 982 983 bool_t 984 xdr_state_protect4_a(XDR *xdrs, state_protect4_a *objp) 985 { 986 if (!xdr_state_protect_how4(xdrs, &objp->spa_how)) 987 return (FALSE); 988 switch (objp->spa_how) { 989 case SP4_NONE: 990 break; 991 case SP4_MACH_CRED: 992 if (!xdr_state_protect_ops4(xdrs, 993 &objp->state_protect4_a_u.spa_mach_ops)) 994 return (FALSE); 995 break; 996 case SP4_SSV: 997 if (!xdr_ssv_sp_parms4(xdrs, 998 &objp->state_protect4_a_u.spa_ssv_parms)) 999 return (FALSE); 1000 break; 1001 default: 1002 return (FALSE); 1003 } 1004 return (TRUE); 1005 } 1006 1007 bool_t 1008 xdr_EXCHANGE_ID4args(XDR *xdrs, EXCHANGE_ID4args *objp) 1009 { 1010 if (!xdr_client_owner4(xdrs, &objp->eia_clientowner)) 1011 return (FALSE); 1012 if (!xdr_uint32_t(xdrs, &objp->eia_flags)) 1013 return (FALSE); 1014 if (!xdr_state_protect4_a(xdrs, &objp->eia_state_protect)) 1015 return (FALSE); 1016 if (!xdr_array(xdrs, 1017 (char **)&objp->eia_client_impl_id.eia_client_impl_id_val, 1018 (uint_t *)&objp->eia_client_impl_id.eia_client_impl_id_len, 1, 1019 sizeof (nfs_impl_id4), (xdrproc_t)xdr_nfs_impl_id4)) 1020 return (FALSE); 1021 return (TRUE); 1022 } 1023 1024 bool_t 1025 xdr_ssv_prot_info4(XDR *xdrs, ssv_prot_info4 *objp) 1026 { 1027 if (!xdr_state_protect_ops4(xdrs, &objp->spi_ops)) 1028 return (FALSE); 1029 if (!xdr_uint32_t(xdrs, &objp->spi_hash_alg)) 1030 return (FALSE); 1031 if (!xdr_uint32_t(xdrs, &objp->spi_encr_alg)) 1032 return (FALSE); 1033 if (!xdr_uint32_t(xdrs, &objp->spi_ssv_len)) 1034 return (FALSE); 1035 if (!xdr_uint32_t(xdrs, &objp->spi_window)) 1036 return (FALSE); 1037 if (!xdr_array(xdrs, (char **)&objp->spi_handles.spi_handles_val, 1038 (uint_t *)&objp->spi_handles.spi_handles_len, ~0, 1039 sizeof (gsshandle4_t), (xdrproc_t)xdr_gsshandle4_t)) 1040 return (FALSE); 1041 return (TRUE); 1042 } 1043 1044 bool_t 1045 xdr_state_protect4_r(XDR *xdrs, state_protect4_r *objp) 1046 { 1047 if (!xdr_state_protect_how4(xdrs, &objp->spr_how)) 1048 return (FALSE); 1049 switch (objp->spr_how) { 1050 case SP4_NONE: 1051 break; 1052 case SP4_MACH_CRED: 1053 if (!xdr_state_protect_ops4(xdrs, 1054 &objp->state_protect4_r_u.spr_mach_ops)) 1055 return (FALSE); 1056 break; 1057 case SP4_SSV: 1058 if (!xdr_ssv_prot_info4(xdrs, 1059 &objp->state_protect4_r_u.spr_ssv_info)) 1060 return (FALSE); 1061 break; 1062 default: 1063 return (FALSE); 1064 } 1065 return (TRUE); 1066 } 1067 1068 bool_t 1069 xdr_EXCHANGE_ID4resok(XDR *xdrs, EXCHANGE_ID4resok *objp) 1070 { 1071 if (!xdr_clientid4(xdrs, &objp->eir_clientid)) 1072 return (FALSE); 1073 if (!xdr_sequenceid4(xdrs, &objp->eir_sequenceid)) 1074 return (FALSE); 1075 if (!xdr_uint32_t(xdrs, &objp->eir_flags)) 1076 return (FALSE); 1077 if (!xdr_state_protect4_r(xdrs, &objp->eir_state_protect)) 1078 return (FALSE); 1079 if (!xdr_server_owner4(xdrs, &objp->eir_server_owner)) 1080 return (FALSE); 1081 if (!xdr_bytes(xdrs, 1082 (char **)&objp->eir_server_scope.eir_server_scope_val, 1083 (uint_t *)&objp->eir_server_scope.eir_server_scope_len, 1084 NFS4_OPAQUE_LIMIT)) 1085 return (FALSE); 1086 if (!xdr_array(xdrs, 1087 (char **)&objp->eir_server_impl_id.eir_server_impl_id_val, 1088 (uint_t *)&objp->eir_server_impl_id.eir_server_impl_id_len, 1, 1089 sizeof (nfs_impl_id4), (xdrproc_t)xdr_nfs_impl_id4)) 1090 return (FALSE); 1091 return (TRUE); 1092 } 1093 1094 bool_t 1095 xdr_EXCHANGE_ID4res(XDR *xdrs, EXCHANGE_ID4res *objp) 1096 { 1097 if (!xdr_nfsstat4(xdrs, &objp->eir_status)) 1098 return (FALSE); 1099 switch (objp->eir_status) { 1100 case NFS4_OK: 1101 if (!xdr_EXCHANGE_ID4resok(xdrs, 1102 &objp->EXCHANGE_ID4res_u.eir_resok4)) 1103 return (FALSE); 1104 break; 1105 } 1106 return (TRUE); 1107 } 1108 1109 bool_t 1110 xdr_channel_attrs4(XDR *xdrs, channel_attrs4 *objp) 1111 { 1112 if (!xdr_count4(xdrs, &objp->ca_headerpadsize)) 1113 return (FALSE); 1114 if (!xdr_count4(xdrs, &objp->ca_maxrequestsize)) 1115 return (FALSE); 1116 if (!xdr_count4(xdrs, &objp->ca_maxresponsesize)) 1117 return (FALSE); 1118 if (!xdr_count4(xdrs, &objp->ca_maxresponsesize_cached)) 1119 return (FALSE); 1120 if (!xdr_count4(xdrs, &objp->ca_maxoperations)) 1121 return (FALSE); 1122 if (!xdr_count4(xdrs, &objp->ca_maxrequests)) 1123 return (FALSE); 1124 if (!xdr_array(xdrs, (char **)&objp->ca_rdma_ird.ca_rdma_ird_val, 1125 (uint_t *)&objp->ca_rdma_ird.ca_rdma_ird_len, 1, 1126 sizeof (uint32_t), (xdrproc_t)xdr_uint32_t)) 1127 return (FALSE); 1128 return (TRUE); 1129 } 1130 1131 bool_t 1132 xdr_CREATE_SESSION4args(XDR *xdrs, CREATE_SESSION4args *objp) 1133 { 1134 1135 if (!xdr_clientid4(xdrs, &objp->csa_clientid)) 1136 return (FALSE); 1137 if (!xdr_sequenceid4(xdrs, &objp->csa_sequence)) 1138 return (FALSE); 1139 if (!xdr_uint32_t(xdrs, &objp->csa_flags)) 1140 return (FALSE); 1141 if (!xdr_channel_attrs4(xdrs, &objp->csa_fore_chan_attrs)) 1142 return (FALSE); 1143 if (!xdr_channel_attrs4(xdrs, &objp->csa_back_chan_attrs)) 1144 return (FALSE); 1145 if (!xdr_uint32_t(xdrs, &objp->csa_cb_program)) 1146 return (FALSE); 1147 if (!xdr_array(xdrs, (char **)&objp->csa_sec_parms.csa_sec_parms_val, 1148 (uint_t *)&objp->csa_sec_parms.csa_sec_parms_len, ~0, 1149 sizeof (callback_sec_parms4), (xdrproc_t)xdr_callback_sec_parms4)) 1150 return (FALSE); 1151 return (TRUE); 1152 } 1153 1154 bool_t 1155 xdr_CREATE_SESSION4resok(XDR *xdrs, CREATE_SESSION4resok *objp) 1156 { 1157 if (!xdr_sessionid4(xdrs, objp->csr_sessionid)) 1158 return (FALSE); 1159 if (!xdr_sequenceid4(xdrs, &objp->csr_sequence)) 1160 return (FALSE); 1161 if (!xdr_uint32_t(xdrs, &objp->csr_flags)) 1162 return (FALSE); 1163 if (!xdr_channel_attrs4(xdrs, &objp->csr_fore_chan_attrs)) 1164 return (FALSE); 1165 if (!xdr_channel_attrs4(xdrs, &objp->csr_back_chan_attrs)) 1166 return (FALSE); 1167 return (TRUE); 1168 } 1169 1170 bool_t 1171 xdr_CREATE_SESSION4res(XDR *xdrs, CREATE_SESSION4res *objp) 1172 { 1173 if (!xdr_nfsstat4(xdrs, &objp->csr_status)) 1174 return (FALSE); 1175 switch (objp->csr_status) { 1176 case NFS4_OK: 1177 if (!xdr_CREATE_SESSION4resok(xdrs, 1178 &objp->CREATE_SESSION4res_u.csr_resok4)) 1179 return (FALSE); 1180 break; 1181 } 1182 return (TRUE); 1183 } 1184 1185 bool_t 1186 xdr_DESTROY_SESSION4args(XDR *xdrs, DESTROY_SESSION4args *objp) 1187 { 1188 if (!xdr_sessionid4(xdrs, objp->dsa_sessionid)) 1189 return (FALSE); 1190 return (TRUE); 1191 } 1192 1193 bool_t 1194 xdr_DESTROY_SESSION4res(XDR *xdrs, DESTROY_SESSION4res *objp) 1195 { 1196 if (!xdr_nfsstat4(xdrs, &objp->dsr_status)) 1197 return (FALSE); 1198 return (TRUE); 1199 } 1200 1201 bool_t 1202 xdr_FREE_STATEID4args(XDR *xdrs, FREE_STATEID4args *objp) 1203 { 1204 if (!xdr_stateid4(xdrs, &objp->fsa_stateid)) 1205 return (FALSE); 1206 return (TRUE); 1207 } 1208 1209 bool_t 1210 xdr_FREE_STATEID4res(XDR *xdrs, FREE_STATEID4res *objp) 1211 { 1212 if (!xdr_nfsstat4(xdrs, &objp->fsr_status)) 1213 return (FALSE); 1214 return (TRUE); 1215 } 1216 1217 bool_t 1218 xdr_attr_notice4(XDR *xdrs, attr_notice4 *objp) 1219 { 1220 if (!xdr_nfstime4(xdrs, objp)) 1221 return (FALSE); 1222 return (TRUE); 1223 } 1224 1225 bool_t 1226 xdr_GET_DIR_DELEGATION4args(XDR *xdrs, GET_DIR_DELEGATION4args *objp) 1227 { 1228 if (!xdr_bool(xdrs, &objp->gdda_signal_deleg_avail)) 1229 return (FALSE); 1230 if (!xdr_bitmap4(xdrs, &objp->gdda_notification_types)) 1231 return (FALSE); 1232 if (!xdr_attr_notice4(xdrs, &objp->gdda_child_attr_delay)) 1233 return (FALSE); 1234 if (!xdr_attr_notice4(xdrs, &objp->gdda_dir_attr_delay)) 1235 return (FALSE); 1236 if (!xdr_bitmap4(xdrs, &objp->gdda_child_attributes)) 1237 return (FALSE); 1238 if (!xdr_bitmap4(xdrs, &objp->gdda_dir_attributes)) 1239 return (FALSE); 1240 return (TRUE); 1241 } 1242 1243 bool_t 1244 xdr_GET_DIR_DELEGATION4resok(XDR *xdrs, GET_DIR_DELEGATION4resok *objp) 1245 { 1246 if (!xdr_verifier4(xdrs, (verifier4 *)&objp->gddr_cookieverf)) 1247 return (FALSE); 1248 if (!xdr_stateid4(xdrs, &objp->gddr_stateid)) 1249 return (FALSE); 1250 if (!xdr_bitmap4(xdrs, &objp->gddr_notification)) 1251 return (FALSE); 1252 if (!xdr_bitmap4(xdrs, &objp->gddr_child_attributes)) 1253 return (FALSE); 1254 if (!xdr_bitmap4(xdrs, &objp->gddr_dir_attributes)) 1255 return (FALSE); 1256 return (TRUE); 1257 } 1258 1259 bool_t 1260 xdr_gddrnf4_status(XDR *xdrs, gddrnf4_status *objp) 1261 { 1262 if (!xdr_enum(xdrs, (enum_t *)objp)) 1263 return (FALSE); 1264 return (TRUE); 1265 } 1266 1267 bool_t 1268 xdr_GET_DIR_DELEGATION4res_non_fatal(XDR *xdrs, 1269 GET_DIR_DELEGATION4res_non_fatal *objp) 1270 { 1271 if (!xdr_gddrnf4_status(xdrs, &objp->gddrnf_status)) 1272 return (FALSE); 1273 switch (objp->gddrnf_status) { 1274 case GDD4_OK: 1275 if (!xdr_GET_DIR_DELEGATION4resok(xdrs, 1276 &objp->GET_DIR_DELEGATION4res_non_fatal_u.gddrnf_resok4)) 1277 return (FALSE); 1278 break; 1279 case GDD4_UNAVAIL: 1280 if (!xdr_bool(xdrs, &objp->GET_DIR_DELEGATION4res_non_fatal_u. 1281 gddrnf_will_signal_deleg_avail)) 1282 return (FALSE); 1283 break; 1284 default: 1285 return (FALSE); 1286 } 1287 return (TRUE); 1288 } 1289 1290 bool_t 1291 xdr_GET_DIR_DELEGATION4res(XDR *xdrs, GET_DIR_DELEGATION4res *objp) 1292 { 1293 if (!xdr_nfsstat4(xdrs, &objp->gddr_status)) 1294 return (FALSE); 1295 switch (objp->gddr_status) { 1296 case NFS4_OK: 1297 if (!xdr_GET_DIR_DELEGATION4res_non_fatal(xdrs, 1298 &objp->GET_DIR_DELEGATION4res_u.gddr_res_non_fatal4)) 1299 return (FALSE); 1300 break; 1301 } 1302 return (TRUE); 1303 } 1304 1305 /* 1306 * Special xdr function to encode single word bitmaps for 1307 * notification bitmaps which only need a single word. 1308 */ 1309 bool_t 1310 xdr_bitmap4_notify(XDR *xdrs, bitmap4 *objp) 1311 { 1312 int32_t len = 1; 1313 1314 ASSERT(xdrs->x_op == XDR_ENCODE); 1315 if (!XDR_PUTINT32(xdrs, &len)) 1316 return (FALSE); 1317 #if defined(_BIG_ENDIAN) 1318 return (XDR_PUTINT32(xdrs, (int32_t *)objp)); 1319 #elif defined(_LITTLE_ENDIAN) 1320 return (XDR_PUTINT32(xdrs, (int32_t *)objp+1)); 1321 #endif 1322 } 1323 1324 bool_t 1325 xdr_GETDEVICEINFO4args(XDR *xdrs, GETDEVICEINFO4args *objp) 1326 { 1327 if (!xdr_deviceid4(xdrs, objp->gdia_device_id)) 1328 return (FALSE); 1329 if (!xdr_layouttype4(xdrs, &objp->gdia_layout_type)) 1330 return (FALSE); 1331 if (!xdr_count4(xdrs, &objp->gdia_maxcount)) 1332 return (FALSE); 1333 if (xdrs->x_op == XDR_ENCODE) { 1334 if (!xdr_bitmap4_notify(xdrs, &objp->gdia_notify_types)) 1335 return (FALSE); 1336 } else 1337 if (!xdr_bitmap4(xdrs, &objp->gdia_notify_types)) 1338 return (FALSE); 1339 return (TRUE); 1340 } 1341 1342 bool_t 1343 xdr_GETDEVICEINFO4resok(XDR *xdrs, GETDEVICEINFO4resok *objp) 1344 { 1345 if (!xdr_device_addr4(xdrs, &objp->gdir_device_addr)) 1346 return (FALSE); 1347 if (xdrs->x_op == XDR_ENCODE) { 1348 if (!xdr_bitmap4_notify(xdrs, &objp->gdir_notification)) 1349 return (FALSE); 1350 } else 1351 if (!xdr_bitmap4(xdrs, &objp->gdir_notification)) 1352 return (FALSE); 1353 return (TRUE); 1354 } 1355 1356 bool_t 1357 xdr_GETDEVICEINFO4res(XDR *xdrs, GETDEVICEINFO4res *objp) 1358 { 1359 if (!xdr_nfsstat4(xdrs, &objp->gdir_status)) 1360 return (FALSE); 1361 switch (objp->gdir_status) { 1362 case NFS4_OK: 1363 if (!xdr_GETDEVICEINFO4resok(xdrs, 1364 &objp->GETDEVICEINFO4res_u.gdir_resok4)) 1365 return (FALSE); 1366 break; 1367 case NFS4ERR_TOOSMALL: 1368 if (!xdr_count4(xdrs, &objp->GETDEVICEINFO4res_u.gdir_mincount)) 1369 return (FALSE); 1370 break; 1371 } 1372 return (TRUE); 1373 } 1374 1375 bool_t 1376 xdr_GETDEVICELIST4args(XDR *xdrs, GETDEVICELIST4args *objp) 1377 { 1378 if (!xdr_layouttype4(xdrs, &objp->gdla_layout_type)) 1379 return (FALSE); 1380 if (!xdr_count4(xdrs, &objp->gdla_maxdevices)) 1381 return (FALSE); 1382 if (!xdr_nfs_cookie4(xdrs, &objp->gdla_cookie)) 1383 return (FALSE); 1384 if (!xdr_verifier4(xdrs, (verifier4 *)&objp->gdla_cookieverf)) 1385 return (FALSE); 1386 return (TRUE); 1387 } 1388 1389 bool_t 1390 xdr_GETDEVICELIST4resok(XDR *xdrs, GETDEVICELIST4resok *objp) 1391 { 1392 if (!xdr_nfs_cookie4(xdrs, &objp->gdlr_cookie)) 1393 return (FALSE); 1394 if (!xdr_verifier4(xdrs, (verifier4 *)&objp->gdlr_cookieverf)) 1395 return (FALSE); 1396 if (!xdr_array(xdrs, 1397 (char **)&objp->gdlr_deviceid_list.gdlr_deviceid_list_val, 1398 (uint_t *)&objp->gdlr_deviceid_list.gdlr_deviceid_list_len, 1399 ~0, sizeof (deviceid4), (xdrproc_t)xdr_deviceid4)) 1400 return (FALSE); 1401 if (!xdr_bool(xdrs, &objp->gdlr_eof)) 1402 return (FALSE); 1403 return (TRUE); 1404 } 1405 1406 bool_t 1407 xdr_GETDEVICELIST4res(XDR *xdrs, GETDEVICELIST4res *objp) 1408 { 1409 if (!xdr_nfsstat4(xdrs, &objp->gdlr_status)) 1410 return (FALSE); 1411 switch (objp->gdlr_status) { 1412 case NFS4_OK: 1413 if (!xdr_GETDEVICELIST4resok(xdrs, 1414 &objp->GETDEVICELIST4res_u.gdlr_resok4)) 1415 return (FALSE); 1416 break; 1417 default: 1418 break; 1419 } 1420 return (TRUE); 1421 } 1422 1423 bool_t 1424 xdr_newtime4(XDR *xdrs, newtime4 *objp) 1425 { 1426 if (!xdr_bool(xdrs, &objp->nt_timechanged)) 1427 return (FALSE); 1428 switch (objp->nt_timechanged) { 1429 case TRUE: 1430 if (!xdr_nfstime4(xdrs, &objp->newtime4_u.nt_time)) 1431 return (FALSE); 1432 break; 1433 case FALSE: 1434 break; 1435 default: 1436 return (FALSE); 1437 } 1438 return (TRUE); 1439 } 1440 1441 bool_t 1442 xdr_newoffset4(XDR *xdrs, newoffset4 *objp) 1443 { 1444 if (!xdr_bool(xdrs, &objp->no_newoffset)) 1445 return (FALSE); 1446 switch (objp->no_newoffset) { 1447 case TRUE: 1448 if (!xdr_offset4(xdrs, &objp->newoffset4_u.no_offset)) 1449 return (FALSE); 1450 break; 1451 case FALSE: 1452 break; 1453 default: 1454 return (FALSE); 1455 } 1456 return (TRUE); 1457 } 1458 1459 bool_t 1460 xdr_LAYOUTCOMMIT4args(XDR *xdrs, LAYOUTCOMMIT4args *objp) 1461 { 1462 if (!xdr_offset4(xdrs, &objp->loca_offset)) 1463 return (FALSE); 1464 if (!xdr_length4(xdrs, &objp->loca_length)) 1465 return (FALSE); 1466 if (!xdr_bool(xdrs, &objp->loca_reclaim)) 1467 return (FALSE); 1468 if (!xdr_stateid4(xdrs, &objp->loca_stateid)) 1469 return (FALSE); 1470 if (!xdr_newoffset4(xdrs, &objp->loca_last_write_offset)) 1471 return (FALSE); 1472 if (!xdr_newtime4(xdrs, &objp->loca_time_modify)) 1473 return (FALSE); 1474 if (!xdr_layoutupdate4(xdrs, &objp->loca_layoutupdate)) 1475 return (FALSE); 1476 return (TRUE); 1477 } 1478 1479 bool_t 1480 xdr_newsize4(XDR *xdrs, newsize4 *objp) 1481 { 1482 if (!xdr_bool(xdrs, &objp->ns_sizechanged)) 1483 return (FALSE); 1484 switch (objp->ns_sizechanged) { 1485 case TRUE: 1486 if (!xdr_length4(xdrs, &objp->newsize4_u.ns_size)) 1487 return (FALSE); 1488 break; 1489 case FALSE: 1490 break; 1491 default: 1492 return (FALSE); 1493 } 1494 return (TRUE); 1495 } 1496 1497 bool_t 1498 xdr_LAYOUTCOMMIT4resok(XDR *xdrs, LAYOUTCOMMIT4resok *objp) 1499 { 1500 if (!xdr_newsize4(xdrs, &objp->locr_newsize)) 1501 return (FALSE); 1502 return (TRUE); 1503 } 1504 1505 bool_t 1506 xdr_LAYOUTCOMMIT4res(XDR *xdrs, LAYOUTCOMMIT4res *objp) 1507 { 1508 if (!xdr_nfsstat4(xdrs, &objp->locr_status)) 1509 return (FALSE); 1510 switch (objp->locr_status) { 1511 case NFS4_OK: 1512 if (!xdr_LAYOUTCOMMIT4resok(xdrs, 1513 &objp->LAYOUTCOMMIT4res_u.locr_resok4)) 1514 return (FALSE); 1515 break; 1516 } 1517 return (TRUE); 1518 } 1519 1520 bool_t 1521 xdr_LAYOUTGET4args(XDR *xdrs, LAYOUTGET4args *objp) 1522 { 1523 if (!xdr_bool(xdrs, &objp->loga_signal_layout_avail)) 1524 return (FALSE); 1525 if (!xdr_layouttype4(xdrs, &objp->loga_layout_type)) 1526 return (FALSE); 1527 if (!xdr_layoutiomode4(xdrs, &objp->loga_iomode)) 1528 return (FALSE); 1529 if (!xdr_offset4(xdrs, &objp->loga_offset)) 1530 return (FALSE); 1531 if (!xdr_length4(xdrs, &objp->loga_length)) 1532 return (FALSE); 1533 if (!xdr_length4(xdrs, &objp->loga_minlength)) 1534 return (FALSE); 1535 if (!xdr_stateid4(xdrs, &objp->loga_stateid)) 1536 return (FALSE); 1537 if (!xdr_count4(xdrs, &objp->loga_maxcount)) 1538 return (FALSE); 1539 return (TRUE); 1540 } 1541 1542 bool_t 1543 xdr_LAYOUTGET4resok(XDR *xdrs, LAYOUTGET4resok *objp) 1544 { 1545 if (!xdr_bool(xdrs, &objp->logr_return_on_close)) 1546 return (FALSE); 1547 if (!xdr_stateid4(xdrs, &objp->logr_stateid)) 1548 return (FALSE); 1549 if (!xdr_array(xdrs, (char **)&objp->logr_layout.logr_layout_val, 1550 (uint_t *)&objp->logr_layout.logr_layout_len, ~0, 1551 sizeof (layout4), (xdrproc_t)xdr_layout4)) 1552 return (FALSE); 1553 return (TRUE); 1554 } 1555 1556 bool_t 1557 xdr_LAYOUTGET4res(XDR *xdrs, LAYOUTGET4res *objp) 1558 { 1559 if (!xdr_nfsstat4(xdrs, &objp->logr_status)) 1560 return (FALSE); 1561 switch (objp->logr_status) { 1562 case NFS4_OK: 1563 if (!xdr_LAYOUTGET4resok(xdrs, 1564 &objp->LAYOUTGET4res_u.logr_resok4)) 1565 return (FALSE); 1566 break; 1567 case NFS4ERR_LAYOUTTRYLATER: 1568 if (!xdr_bool(xdrs, 1569 &objp->LAYOUTGET4res_u.logr_will_signal_layout_avail)) 1570 return (FALSE); 1571 break; 1572 } 1573 return (TRUE); 1574 } 1575 1576 bool_t 1577 xdr_LAYOUTRETURN4args(XDR *xdrs, LAYOUTRETURN4args *objp) 1578 { 1579 if (!xdr_bool(xdrs, &objp->lora_reclaim)) 1580 return (FALSE); 1581 if (!xdr_layouttype4(xdrs, &objp->lora_layout_type)) 1582 return (FALSE); 1583 if (!xdr_layoutiomode4(xdrs, &objp->lora_iomode)) 1584 return (FALSE); 1585 if (!xdr_layoutreturn4(xdrs, &objp->lora_layoutreturn)) 1586 return (FALSE); 1587 return (TRUE); 1588 } 1589 1590 bool_t 1591 xdr_layoutreturn_stateid(XDR *xdrs, layoutreturn_stateid *objp) 1592 { 1593 if (!xdr_bool(xdrs, &objp->lrs_present)) 1594 return (FALSE); 1595 switch (objp->lrs_present) { 1596 case TRUE: 1597 if (!xdr_stateid4(xdrs, 1598 &objp->layoutreturn_stateid_u.lrs_stateid)) 1599 return (FALSE); 1600 break; 1601 case FALSE: 1602 break; 1603 default: 1604 return (FALSE); 1605 } 1606 return (TRUE); 1607 } 1608 1609 bool_t 1610 xdr_LAYOUTRETURN4res(XDR *xdrs, LAYOUTRETURN4res *objp) 1611 { 1612 if (!xdr_nfsstat4(xdrs, &objp->lorr_status)) 1613 return (FALSE); 1614 switch (objp->lorr_status) { 1615 case NFS4_OK: 1616 if (!xdr_layoutreturn_stateid(xdrs, 1617 &objp->LAYOUTRETURN4res_u.lorr_stateid)) 1618 return (FALSE); 1619 break; 1620 } 1621 return (TRUE); 1622 } 1623 1624 bool_t 1625 xdr_secinfo_style4(XDR *xdrs, secinfo_style4 *objp) 1626 { 1627 if (!xdr_enum(xdrs, (enum_t *)objp)) 1628 return (FALSE); 1629 return (TRUE); 1630 } 1631 1632 bool_t 1633 xdr_SECINFO_NO_NAME4args(XDR *xdrs, SECINFO_NO_NAME4args *objp) 1634 { 1635 if (!xdr_secinfo_style4(xdrs, objp)) 1636 return (FALSE); 1637 return (TRUE); 1638 } 1639 1640 bool_t 1641 xdr_SECINFO_NO_NAME4res(XDR *xdrs, SECINFO_NO_NAME4res *objp) 1642 { 1643 if (!xdr_SECINFO4res(xdrs, objp)) 1644 return (FALSE); 1645 return (TRUE); 1646 } 1647 1648 bool_t 1649 xdr_SEQUENCE4args(XDR *xdrs, SEQUENCE4args *objp) 1650 { 1651 if (!xdr_sessionid4(xdrs, objp->sa_sessionid)) 1652 return (FALSE); 1653 if (!xdr_sequenceid4(xdrs, &objp->sa_sequenceid)) 1654 return (FALSE); 1655 if (!xdr_slotid4(xdrs, &objp->sa_slotid)) 1656 return (FALSE); 1657 if (!xdr_slotid4(xdrs, &objp->sa_highest_slotid)) 1658 return (FALSE); 1659 if (!xdr_bool(xdrs, &objp->sa_cachethis)) 1660 return (FALSE); 1661 return (TRUE); 1662 } 1663 1664 bool_t 1665 xdr_SEQUENCE4resok(XDR *xdrs, SEQUENCE4resok *objp) 1666 { 1667 if (!xdr_sessionid4(xdrs, objp->sr_sessionid)) 1668 return (FALSE); 1669 if (!xdr_sequenceid4(xdrs, &objp->sr_sequenceid)) 1670 return (FALSE); 1671 if (!xdr_slotid4(xdrs, &objp->sr_slotid)) 1672 return (FALSE); 1673 if (!xdr_slotid4(xdrs, &objp->sr_highest_slotid)) 1674 return (FALSE); 1675 if (!xdr_slotid4(xdrs, &objp->sr_target_highest_slotid)) 1676 return (FALSE); 1677 if (!xdr_uint32_t(xdrs, &objp->sr_status_flags)) 1678 return (FALSE); 1679 return (TRUE); 1680 } 1681 1682 bool_t 1683 xdr_SEQUENCE4res(XDR *xdrs, SEQUENCE4res *objp) 1684 { 1685 if (!xdr_nfsstat4(xdrs, &objp->sr_status)) 1686 return (FALSE); 1687 switch (objp->sr_status) { 1688 case NFS4_OK: 1689 if (!xdr_SEQUENCE4resok(xdrs, &objp->SEQUENCE4res_u.sr_resok4)) 1690 return (FALSE); 1691 break; 1692 } 1693 return (TRUE); 1694 } 1695 1696 bool_t 1697 xdr_ssa_digest_input4(XDR *xdrs, ssa_digest_input4 *objp) 1698 { 1699 if (!xdr_SEQUENCE4args(xdrs, &objp->sdi_seqargs)) 1700 return (FALSE); 1701 return (TRUE); 1702 } 1703 1704 bool_t 1705 xdr_SET_SSV4args(XDR *xdrs, SET_SSV4args *objp) 1706 { 1707 if (!xdr_bytes(xdrs, (char **)&objp->ssa_ssv.ssa_ssv_val, 1708 (uint_t *)&objp->ssa_ssv.ssa_ssv_len, ~0)) 1709 return (FALSE); 1710 if (!xdr_bytes(xdrs, (char **)&objp->ssa_digest.ssa_digest_val, 1711 (uint_t *)&objp->ssa_digest.ssa_digest_len, ~0)) 1712 return (FALSE); 1713 return (TRUE); 1714 } 1715 1716 bool_t 1717 xdr_ssr_digest_input4(XDR *xdrs, ssr_digest_input4 *objp) 1718 { 1719 if (!xdr_SEQUENCE4res(xdrs, &objp->sdi_seqres)) 1720 return (FALSE); 1721 return (TRUE); 1722 } 1723 1724 bool_t 1725 xdr_SET_SSV4resok(XDR *xdrs, SET_SSV4resok *objp) 1726 { 1727 if (!xdr_bytes(xdrs, (char **)&objp->ssr_digest.ssr_digest_val, 1728 (uint_t *)&objp->ssr_digest.ssr_digest_len, ~0)) 1729 return (FALSE); 1730 return (TRUE); 1731 } 1732 1733 bool_t 1734 xdr_SET_SSV4res(XDR *xdrs, SET_SSV4res *objp) 1735 { 1736 if (!xdr_nfsstat4(xdrs, &objp->ssr_status)) 1737 return (FALSE); 1738 switch (objp->ssr_status) { 1739 case NFS4_OK: 1740 if (!xdr_SET_SSV4resok(xdrs, &objp->SET_SSV4res_u.ssr_resok4)) 1741 return (FALSE); 1742 break; 1743 } 1744 return (TRUE); 1745 } 1746 1747 bool_t 1748 xdr_TEST_STATEID4args(XDR *xdrs, TEST_STATEID4args *objp) 1749 { 1750 if (!xdr_array(xdrs, (char **)&objp->ts_stateids.ts_stateids_val, 1751 (uint_t *)&objp->ts_stateids.ts_stateids_len, ~0, 1752 sizeof (stateid4), (xdrproc_t)xdr_stateid4)) 1753 return (FALSE); 1754 return (TRUE); 1755 } 1756 1757 bool_t 1758 xdr_TEST_STATEID4resok(XDR *xdrs, TEST_STATEID4resok *objp) 1759 { 1760 if (!xdr_array(xdrs, 1761 (char **)&objp->tsr_status_codes.tsr_status_codes_val, 1762 (uint_t *)&objp->tsr_status_codes.tsr_status_codes_len, ~0, 1763 sizeof (nfsstat4), (xdrproc_t)xdr_nfsstat4)) 1764 return (FALSE); 1765 return (TRUE); 1766 } 1767 1768 bool_t 1769 xdr_TEST_STATEID4res(XDR *xdrs, TEST_STATEID4res *objp) 1770 { 1771 if (!xdr_nfsstat4(xdrs, &objp->tsr_status)) 1772 return (FALSE); 1773 switch (objp->tsr_status) { 1774 case NFS4_OK: 1775 if (!xdr_TEST_STATEID4resok(xdrs, 1776 &objp->TEST_STATEID4res_u.tsr_resok4)) 1777 return (FALSE); 1778 break; 1779 } 1780 return (TRUE); 1781 } 1782 1783 bool_t 1784 xdr_deleg_claim4(XDR *xdrs, deleg_claim4 *objp) 1785 { 1786 if (!xdr_open_claim_type4(xdrs, &objp->dc_claim)) 1787 return (FALSE); 1788 switch (objp->dc_claim) { 1789 case CLAIM_FH: 1790 break; 1791 case CLAIM_DELEG_PREV_FH: 1792 break; 1793 case CLAIM_PREVIOUS: 1794 if (!xdr_open_delegation_type4(xdrs, 1795 &objp->deleg_claim4_u.dc_delegate_type)) 1796 return (FALSE); 1797 break; 1798 default: 1799 return (FALSE); 1800 } 1801 return (TRUE); 1802 } 1803 1804 bool_t 1805 xdr_WANT_DELEGATION4args(XDR *xdrs, WANT_DELEGATION4args *objp) 1806 { 1807 if (!xdr_uint32_t(xdrs, &objp->wda_want)) 1808 return (FALSE); 1809 if (!xdr_deleg_claim4(xdrs, &objp->wda_claim)) 1810 return (FALSE); 1811 return (TRUE); 1812 } 1813 1814 bool_t 1815 xdr_WANT_DELEGATION4res(XDR *xdrs, WANT_DELEGATION4res *objp) 1816 { 1817 if (!xdr_nfsstat4(xdrs, &objp->wdr_status)) 1818 return (FALSE); 1819 switch (objp->wdr_status) { 1820 case NFS4_OK: 1821 if (!xdr_open_delegation4(xdrs, 1822 &objp->WANT_DELEGATION4res_u.wdr_resok4)) 1823 return (FALSE); 1824 break; 1825 } 1826 return (TRUE); 1827 } 1828 1829 bool_t 1830 xdr_DESTROY_CLIENTID4args(XDR *xdrs, DESTROY_CLIENTID4args *objp) 1831 { 1832 if (!xdr_clientid4(xdrs, &objp->dca_clientid)) 1833 return (FALSE); 1834 return (TRUE); 1835 } 1836 1837 bool_t 1838 xdr_DESTROY_CLIENTID4res(XDR *xdrs, DESTROY_CLIENTID4res *objp) 1839 { 1840 1841 if (!xdr_nfsstat4(xdrs, &objp->dcr_status)) 1842 return (FALSE); 1843 return (TRUE); 1844 } 1845 1846 bool_t 1847 xdr_RECLAIM_COMPLETE4args(XDR *xdrs, RECLAIM_COMPLETE4args *objp) 1848 { 1849 if (!xdr_bool(xdrs, &objp->rca_one_fs)) 1850 return (FALSE); 1851 return (TRUE); 1852 } 1853 1854 bool_t 1855 xdr_RECLAIM_COMPLETE4res(XDR *xdrs, RECLAIM_COMPLETE4res *objp) 1856 { 1857 if (!xdr_nfsstat4(xdrs, &objp->rcr_status)) 1858 return (FALSE); 1859 return (TRUE); 1860 } 1861 1862 /* new operations for NFSv4.1 */ 1863 1864 bool_t 1865 xdr_nfs4x_argop4(XDR *xdrs, nfs_argop4 *objp) 1866 { 1867 /* nfs_opnum4 has already been xdr'd */ 1868 switch (objp->argop) { 1869 case OP_BACKCHANNEL_CTL: 1870 if (!xdr_BACKCHANNEL_CTL4args(xdrs, 1871 &objp->nfs_argop4_u.opbackchannel_ctl)) 1872 return (FALSE); 1873 break; 1874 case OP_BIND_CONN_TO_SESSION: 1875 if (!xdr_BIND_CONN_TO_SESSION4args(xdrs, 1876 &objp->nfs_argop4_u.opbind_conn_to_session)) 1877 return (FALSE); 1878 break; 1879 case OP_EXCHANGE_ID: 1880 if (!xdr_EXCHANGE_ID4args(xdrs, 1881 &objp->nfs_argop4_u.opexchange_id)) 1882 return (FALSE); 1883 break; 1884 case OP_CREATE_SESSION: 1885 if (!xdr_CREATE_SESSION4args(xdrs, 1886 &objp->nfs_argop4_u.opcreate_session)) 1887 return (FALSE); 1888 break; 1889 case OP_DESTROY_SESSION: 1890 if (!xdr_DESTROY_SESSION4args(xdrs, 1891 &objp->nfs_argop4_u.opdestroy_session)) 1892 return (FALSE); 1893 break; 1894 case OP_FREE_STATEID: 1895 if (!xdr_FREE_STATEID4args(xdrs, 1896 &objp->nfs_argop4_u.opfree_stateid)) 1897 return (FALSE); 1898 break; 1899 case OP_GET_DIR_DELEGATION: 1900 if (!xdr_GET_DIR_DELEGATION4args(xdrs, 1901 &objp->nfs_argop4_u.opget_dir_delegation)) 1902 return (FALSE); 1903 break; 1904 case OP_GETDEVICEINFO: 1905 if (!xdr_GETDEVICEINFO4args(xdrs, 1906 &objp->nfs_argop4_u.opgetdeviceinfo)) 1907 return (FALSE); 1908 break; 1909 case OP_GETDEVICELIST: 1910 if (!xdr_GETDEVICELIST4args(xdrs, 1911 &objp->nfs_argop4_u.opgetdevicelist)) 1912 return (FALSE); 1913 break; 1914 case OP_LAYOUTCOMMIT: 1915 if (!xdr_LAYOUTCOMMIT4args(xdrs, 1916 &objp->nfs_argop4_u.oplayoutcommit)) 1917 return (FALSE); 1918 break; 1919 case OP_LAYOUTGET: 1920 if (!xdr_LAYOUTGET4args(xdrs, 1921 &objp->nfs_argop4_u.oplayoutget)) 1922 return (FALSE); 1923 break; 1924 case OP_LAYOUTRETURN: 1925 if (!xdr_LAYOUTRETURN4args(xdrs, 1926 &objp->nfs_argop4_u.oplayoutreturn)) 1927 return (FALSE); 1928 break; 1929 case OP_SECINFO_NO_NAME: 1930 if (!xdr_SECINFO_NO_NAME4args(xdrs, 1931 &objp->nfs_argop4_u.opsecinfo_no_name)) 1932 return (FALSE); 1933 break; 1934 case OP_SEQUENCE: 1935 if (!xdr_SEQUENCE4args(xdrs, 1936 &objp->nfs_argop4_u.opsequence)) 1937 return (FALSE); 1938 break; 1939 case OP_SET_SSV: 1940 if (!xdr_SET_SSV4args(xdrs, 1941 &objp->nfs_argop4_u.opset_ssv)) 1942 return (FALSE); 1943 break; 1944 case OP_TEST_STATEID: 1945 if (!xdr_TEST_STATEID4args(xdrs, 1946 &objp->nfs_argop4_u.optest_stateid)) 1947 return (FALSE); 1948 break; 1949 case OP_WANT_DELEGATION: 1950 if (!xdr_WANT_DELEGATION4args(xdrs, 1951 &objp->nfs_argop4_u.opwant_delegation)) 1952 return (FALSE); 1953 break; 1954 case OP_DESTROY_CLIENTID: 1955 if (!xdr_DESTROY_CLIENTID4args(xdrs, 1956 &objp->nfs_argop4_u.opdestroy_clientid)) 1957 return (FALSE); 1958 break; 1959 case OP_RECLAIM_COMPLETE: 1960 if (!xdr_RECLAIM_COMPLETE4args(xdrs, 1961 &objp->nfs_argop4_u.opreclaim_complete)) 1962 return (FALSE); 1963 break; 1964 default: 1965 return (FALSE); 1966 } 1967 return (TRUE); 1968 } 1969 1970 bool_t 1971 xdr_nfs4x_resop4(XDR *xdrs, nfs_resop4 *objp) 1972 { 1973 /* nfs_opnum4 has already been xdr's */ 1974 switch (objp->resop) { 1975 case OP_BACKCHANNEL_CTL: 1976 if (!xdr_BACKCHANNEL_CTL4res(xdrs, 1977 &objp->nfs_resop4_u.opbackchannel_ctl)) 1978 return (FALSE); 1979 break; 1980 case OP_BIND_CONN_TO_SESSION: 1981 if (!xdr_BIND_CONN_TO_SESSION4res(xdrs, 1982 &objp->nfs_resop4_u.opbind_conn_to_session)) 1983 return (FALSE); 1984 break; 1985 case OP_EXCHANGE_ID: 1986 if (!xdr_EXCHANGE_ID4res(xdrs, 1987 &objp->nfs_resop4_u.opexchange_id)) 1988 return (FALSE); 1989 break; 1990 case OP_CREATE_SESSION: 1991 if (!xdr_CREATE_SESSION4res(xdrs, 1992 &objp->nfs_resop4_u.opcreate_session)) 1993 return (FALSE); 1994 break; 1995 case OP_DESTROY_SESSION: 1996 if (!xdr_DESTROY_SESSION4res(xdrs, 1997 &objp->nfs_resop4_u.opdestroy_session)) 1998 return (FALSE); 1999 break; 2000 case OP_FREE_STATEID: 2001 if (!xdr_FREE_STATEID4res(xdrs, 2002 &objp->nfs_resop4_u.opfree_stateid)) 2003 return (FALSE); 2004 break; 2005 case OP_GET_DIR_DELEGATION: 2006 if (!xdr_GET_DIR_DELEGATION4res(xdrs, 2007 &objp->nfs_resop4_u.opget_dir_delegation)) 2008 return (FALSE); 2009 break; 2010 case OP_GETDEVICEINFO: 2011 if (!xdr_GETDEVICEINFO4res(xdrs, 2012 &objp->nfs_resop4_u.opgetdeviceinfo)) 2013 return (FALSE); 2014 break; 2015 case OP_GETDEVICELIST: 2016 if (!xdr_GETDEVICELIST4res(xdrs, 2017 &objp->nfs_resop4_u.opgetdevicelist)) 2018 return (FALSE); 2019 break; 2020 case OP_LAYOUTCOMMIT: 2021 if (!xdr_LAYOUTCOMMIT4res(xdrs, 2022 &objp->nfs_resop4_u.oplayoutcommit)) 2023 return (FALSE); 2024 break; 2025 case OP_LAYOUTGET: 2026 if (!xdr_LAYOUTGET4res(xdrs, 2027 &objp->nfs_resop4_u.oplayoutget)) 2028 return (FALSE); 2029 break; 2030 case OP_LAYOUTRETURN: 2031 if (!xdr_LAYOUTRETURN4res(xdrs, 2032 &objp->nfs_resop4_u.oplayoutreturn)) 2033 return (FALSE); 2034 break; 2035 case OP_SECINFO_NO_NAME: 2036 if (!xdr_SECINFO_NO_NAME4res(xdrs, 2037 &objp->nfs_resop4_u.opsecinfo_no_name)) 2038 return (FALSE); 2039 break; 2040 case OP_SEQUENCE: 2041 if (!xdr_SEQUENCE4res(xdrs, 2042 &objp->nfs_resop4_u.opsequence)) 2043 return (FALSE); 2044 break; 2045 case OP_SET_SSV: 2046 if (!xdr_SET_SSV4res(xdrs, 2047 &objp->nfs_resop4_u.opset_ssv)) 2048 return (FALSE); 2049 break; 2050 case OP_TEST_STATEID: 2051 if (!xdr_TEST_STATEID4res(xdrs, 2052 &objp->nfs_resop4_u.optest_stateid)) 2053 return (FALSE); 2054 break; 2055 case OP_WANT_DELEGATION: 2056 if (!xdr_WANT_DELEGATION4res(xdrs, 2057 &objp->nfs_resop4_u.opwant_delegation)) 2058 return (FALSE); 2059 break; 2060 case OP_DESTROY_CLIENTID: 2061 if (!xdr_DESTROY_CLIENTID4res(xdrs, 2062 &objp->nfs_resop4_u.opdestroy_clientid)) 2063 return (FALSE); 2064 break; 2065 case OP_RECLAIM_COMPLETE: 2066 if (!xdr_RECLAIM_COMPLETE4res(xdrs, 2067 &objp->nfs_resop4_u.opreclaim_complete)) 2068 return (FALSE); 2069 break; 2070 default: 2071 return (FALSE); 2072 } 2073 return (TRUE); 2074 } 2075 2076 bool_t 2077 xdr_layoutrecall_type4(XDR *xdrs, layoutrecall_type4 *objp) 2078 { 2079 if (!xdr_enum(xdrs, (enum_t *)objp)) 2080 return (FALSE); 2081 return (TRUE); 2082 } 2083 2084 bool_t 2085 xdr_layoutrecall_file4(XDR *xdrs, layoutrecall_file4 *objp) 2086 { 2087 switch (xdrs->x_op) { 2088 case XDR_ENCODE: 2089 /* TODO: encode nfs4x_fh */ 2090 return (FALSE); 2091 2092 case XDR_DECODE: 2093 if (!xdr_bytes(xdrs, (char **)&objp->lor_fh.nfs_fh4_val, 2094 (uint_t *)&objp->lor_fh.nfs_fh4_len, NFS4_FHSIZE)) 2095 return (FALSE); 2096 break; 2097 2098 case XDR_FREE: 2099 if (objp->lor_fh.nfs_fh4_val != NULL) { 2100 if (!xdr_bytes(xdrs, 2101 (char **)&objp->lor_fh.nfs_fh4_val, 2102 (uint_t *)&objp->lor_fh.nfs_fh4_len, 2103 NFS4_FHSIZE)) 2104 return (FALSE); 2105 } 2106 break; 2107 } 2108 2109 if (!xdr_offset4(xdrs, &objp->lor_offset)) 2110 return (FALSE); 2111 if (!xdr_length4(xdrs, &objp->lor_length)) 2112 return (FALSE); 2113 if (!xdr_stateid4(xdrs, &objp->lor_stateid)) 2114 return (FALSE); 2115 return (TRUE); 2116 } 2117 2118 bool_t 2119 xdr_layoutrecall4(XDR *xdrs, layoutrecall4 *objp) 2120 { 2121 if (!xdr_layoutrecall_type4(xdrs, &objp->lor_recalltype)) 2122 return (FALSE); 2123 switch (objp->lor_recalltype) { 2124 case LAYOUTRECALL4_FILE: 2125 if (!xdr_layoutrecall_file4(xdrs, 2126 &objp->layoutrecall4_u.lor_layout)) 2127 return (FALSE); 2128 break; 2129 case LAYOUTRECALL4_FSID: 2130 if (!xdr_fsid4(xdrs, &objp->layoutrecall4_u.lor_fsid)) 2131 return (FALSE); 2132 break; 2133 case LAYOUTRECALL4_ALL: 2134 break; 2135 default: 2136 return (FALSE); 2137 } 2138 return (TRUE); 2139 } 2140 2141 bool_t 2142 xdr_CB_LAYOUTRECALL4args(XDR *xdrs, CB_LAYOUTRECALL4args *objp) 2143 { 2144 if (!xdr_layouttype4(xdrs, &objp->clora_type)) 2145 return (FALSE); 2146 if (!xdr_layoutiomode4(xdrs, &objp->clora_iomode)) 2147 return (FALSE); 2148 if (!xdr_bool(xdrs, &objp->clora_changed)) 2149 return (FALSE); 2150 if (!xdr_layoutrecall4(xdrs, &objp->clora_recall)) 2151 return (FALSE); 2152 return (TRUE); 2153 } 2154 2155 bool_t 2156 xdr_CB_LAYOUTRECALL4res(XDR *xdrs, CB_LAYOUTRECALL4res *objp) 2157 { 2158 if (!xdr_nfsstat4(xdrs, &objp->clorr_status)) 2159 return (FALSE); 2160 return (TRUE); 2161 } 2162 2163 bool_t 2164 xdr_notify_type4(XDR *xdrs, notify_type4 *objp) 2165 { 2166 if (!xdr_enum(xdrs, (enum_t *)objp)) 2167 return (FALSE); 2168 return (TRUE); 2169 } 2170 2171 bool_t 2172 xdr_notify_entry4(XDR *xdrs, notify_entry4 *objp) 2173 { 2174 if (!xdr_component4(xdrs, &objp->ne_file)) 2175 return (FALSE); 2176 if (!xdr_fattr4(xdrs, &objp->ne_attrs)) 2177 return (FALSE); 2178 return (TRUE); 2179 } 2180 2181 bool_t 2182 xdr_prev_entry4(XDR *xdrs, prev_entry4 *objp) 2183 { 2184 if (!xdr_notify_entry4(xdrs, &objp->pe_prev_entry)) 2185 return (FALSE); 2186 if (!xdr_nfs_cookie4(xdrs, &objp->pe_prev_entry_cookie)) 2187 return (FALSE); 2188 return (TRUE); 2189 } 2190 2191 bool_t 2192 xdr_notify_remove4(XDR *xdrs, notify_remove4 *objp) 2193 { 2194 2195 if (!xdr_notify_entry4(xdrs, &objp->nrm_old_entry)) 2196 return (FALSE); 2197 if (!xdr_nfs_cookie4(xdrs, &objp->nrm_old_entry_cookie)) 2198 return (FALSE); 2199 return (TRUE); 2200 } 2201 2202 bool_t 2203 xdr_notify_add4(XDR *xdrs, notify_add4 *objp) 2204 { 2205 if (!xdr_array(xdrs, (char **)&objp->nad_old_entry.nad_old_entry_val, 2206 (uint_t *)&objp->nad_old_entry.nad_old_entry_len, 1, 2207 sizeof (notify_remove4), (xdrproc_t)xdr_notify_remove4)) 2208 return (FALSE); 2209 if (!xdr_notify_entry4(xdrs, &objp->nad_new_entry)) 2210 return (FALSE); 2211 if (!xdr_array(xdrs, 2212 (char **)&objp->nad_new_entry_cookie.nad_new_entry_cookie_val, 2213 (uint_t *)&objp->nad_new_entry_cookie.nad_new_entry_cookie_len, 1, 2214 sizeof (nfs_cookie4), (xdrproc_t)xdr_nfs_cookie4)) 2215 return (FALSE); 2216 if (!xdr_array(xdrs, (char **)&objp->nad_prev_entry.nad_prev_entry_val, 2217 (uint_t *)&objp->nad_prev_entry.nad_prev_entry_len, 1, 2218 sizeof (prev_entry4), (xdrproc_t)xdr_prev_entry4)) 2219 return (FALSE); 2220 if (!xdr_bool(xdrs, &objp->nad_last_entry)) 2221 return (FALSE); 2222 return (TRUE); 2223 } 2224 2225 bool_t 2226 xdr_notify_attr4(XDR *xdrs, notify_attr4 *objp) 2227 { 2228 if (!xdr_notify_entry4(xdrs, &objp->na_changed_entry)) 2229 return (FALSE); 2230 return (TRUE); 2231 } 2232 2233 bool_t 2234 xdr_notify_rename4(XDR *xdrs, notify_rename4 *objp) 2235 { 2236 if (!xdr_notify_remove4(xdrs, &objp->nrn_old_entry)) 2237 return (FALSE); 2238 if (!xdr_notify_add4(xdrs, &objp->nrn_new_entry)) 2239 return (FALSE); 2240 return (TRUE); 2241 } 2242 2243 bool_t 2244 xdr_notify_verifier4(XDR *xdrs, notify_verifier4 *objp) 2245 { 2246 if (!xdr_verifier4(xdrs, (verifier4 *)&objp->nv_old_cookieverf)) 2247 return (FALSE); 2248 if (!xdr_verifier4(xdrs, (verifier4 *)&objp->nv_new_cookieverf)) 2249 return (FALSE); 2250 return (TRUE); 2251 } 2252 2253 bool_t 2254 xdr_notifylist4(XDR *xdrs, notifylist4 *objp) 2255 { 2256 if (!xdr_bytes(xdrs, (char **)&objp->notifylist4_val, 2257 (uint_t *)&objp->notifylist4_len, ~0)) 2258 return (FALSE); 2259 return (TRUE); 2260 } 2261 2262 bool_t 2263 xdr_notify4(XDR *xdrs, notify4 *objp) 2264 { 2265 if (xdrs->x_op == XDR_ENCODE) { 2266 if (!xdr_bitmap4_notify(xdrs, &objp->notify_mask)) 2267 return (FALSE); 2268 } else 2269 if (!xdr_bitmap4(xdrs, &objp->notify_mask)) 2270 return (FALSE); 2271 if (!xdr_notifylist4(xdrs, &objp->notify_vals)) 2272 return (FALSE); 2273 return (TRUE); 2274 } 2275 2276 bool_t 2277 xdr_CB_NOTIFY4args(XDR *xdrs, CB_NOTIFY4args *objp) 2278 { 2279 if (!xdr_stateid4(xdrs, &objp->cna_stateid)) 2280 return (FALSE); 2281 if (!xdr_nfs_fh4(xdrs, &objp->cna_fh)) 2282 return (FALSE); 2283 if (!xdr_array(xdrs, (char **)&objp->cna_changes.cna_changes_val, 2284 (uint_t *)&objp->cna_changes.cna_changes_len, ~0, 2285 sizeof (notify4), (xdrproc_t)xdr_notify4)) 2286 return (FALSE); 2287 return (TRUE); 2288 } 2289 2290 bool_t 2291 xdr_CB_NOTIFY4res(XDR *xdrs, CB_NOTIFY4res *objp) 2292 { 2293 if (!xdr_nfsstat4(xdrs, &objp->cnr_status)) 2294 return (FALSE); 2295 return (TRUE); 2296 } 2297 2298 bool_t 2299 xdr_CB_PUSH_DELEG4args(XDR *xdrs, CB_PUSH_DELEG4args *objp) 2300 { 2301 if (!xdr_nfs_fh4(xdrs, &objp->cpda_fh)) 2302 return (FALSE); 2303 if (!xdr_open_delegation4(xdrs, &objp->cpda_delegation)) 2304 return (FALSE); 2305 return (TRUE); 2306 } 2307 2308 bool_t 2309 xdr_CB_PUSH_DELEG4res(XDR *xdrs, CB_PUSH_DELEG4res *objp) 2310 { 2311 if (!xdr_nfsstat4(xdrs, &objp->cpdr_status)) 2312 return (FALSE); 2313 return (TRUE); 2314 } 2315 2316 bool_t 2317 xdr_CB_RECALL_ANY4args(XDR *xdrs, CB_RECALL_ANY4args *objp) 2318 { 2319 if (!xdr_uint32_t(xdrs, &objp->craa_objects_to_keep)) 2320 return (FALSE); 2321 if (!xdr_bitmap4(xdrs, &objp->craa_type_mask)) 2322 return (FALSE); 2323 return (TRUE); 2324 } 2325 2326 bool_t 2327 xdr_CB_RECALL_ANY4res(XDR *xdrs, CB_RECALL_ANY4res *objp) 2328 { 2329 if (!xdr_nfsstat4(xdrs, &objp->crar_status)) 2330 return (FALSE); 2331 return (TRUE); 2332 } 2333 2334 bool_t 2335 xdr_CB_RECALLABLE_OBJ_AVAIL4args(XDR *xdrs, CB_RECALLABLE_OBJ_AVAIL4args *objp) 2336 { 2337 if (!xdr_CB_RECALL_ANY4args(xdrs, objp)) 2338 return (FALSE); 2339 return (TRUE); 2340 } 2341 2342 bool_t 2343 xdr_CB_RECALLABLE_OBJ_AVAIL4res(XDR *xdrs, CB_RECALLABLE_OBJ_AVAIL4res *objp) 2344 { 2345 if (!xdr_nfsstat4(xdrs, &objp->croa_status)) 2346 return (FALSE); 2347 return (TRUE); 2348 } 2349 2350 bool_t 2351 xdr_CB_RECALL_SLOT4args(XDR *xdrs, CB_RECALL_SLOT4args *objp) 2352 { 2353 if (!xdr_slotid4(xdrs, &objp->rsa_target_highest_slotid)) 2354 return (FALSE); 2355 return (TRUE); 2356 } 2357 2358 bool_t 2359 xdr_CB_RECALL_SLOT4res(XDR *xdrs, CB_RECALL_SLOT4res *objp) 2360 { 2361 if (!xdr_nfsstat4(xdrs, &objp->rsr_status)) 2362 return (FALSE); 2363 return (TRUE); 2364 } 2365 2366 bool_t 2367 xdr_referring_call4(XDR *xdrs, referring_call4 *objp) 2368 { 2369 if (!xdr_sequenceid4(xdrs, &objp->rc_sequenceid)) 2370 return (FALSE); 2371 if (!xdr_slotid4(xdrs, &objp->rc_slotid)) 2372 return (FALSE); 2373 return (TRUE); 2374 } 2375 2376 bool_t 2377 xdr_referring_call_list4(XDR *xdrs, referring_call_list4 *objp) 2378 { 2379 if (!xdr_sessionid4(xdrs, objp->rcl_sessionid)) 2380 return (FALSE); 2381 if (!xdr_array(xdrs, (char **)&objp->rcl_referring_calls. 2382 rcl_referring_calls_val, 2383 (uint_t *)&objp->rcl_referring_calls.rcl_referring_calls_len, ~0, 2384 sizeof (referring_call4), (xdrproc_t)xdr_referring_call4)) 2385 return (FALSE); 2386 return (TRUE); 2387 } 2388 2389 bool_t 2390 xdr_CB_SEQUENCE4args(XDR *xdrs, CB_SEQUENCE4args *objp) 2391 { 2392 if (!xdr_sessionid4(xdrs, objp->csa_sessionid)) 2393 return (FALSE); 2394 if (!xdr_sequenceid4(xdrs, &objp->csa_sequenceid)) 2395 return (FALSE); 2396 if (!xdr_slotid4(xdrs, &objp->csa_slotid)) 2397 return (FALSE); 2398 if (!xdr_slotid4(xdrs, &objp->csa_highest_slotid)) 2399 return (FALSE); 2400 if (!xdr_bool(xdrs, &objp->csa_cachethis)) 2401 return (FALSE); 2402 if (!xdr_array(xdrs, (char **)&objp->csa_referring_call_lists. 2403 csa_referring_call_lists_val, 2404 (uint_t *)&objp->csa_referring_call_lists. 2405 csa_referring_call_lists_len, ~0, sizeof (referring_call_list4), 2406 (xdrproc_t)xdr_referring_call_list4)) 2407 return (FALSE); 2408 return (TRUE); 2409 } 2410 2411 bool_t 2412 xdr_CB_SEQUENCE4resok(XDR *xdrs, CB_SEQUENCE4resok *objp) 2413 { 2414 if (!xdr_sessionid4(xdrs, objp->csr_sessionid)) 2415 return (FALSE); 2416 if (!xdr_sequenceid4(xdrs, &objp->csr_sequenceid)) 2417 return (FALSE); 2418 if (!xdr_slotid4(xdrs, &objp->csr_slotid)) 2419 return (FALSE); 2420 if (!xdr_slotid4(xdrs, &objp->csr_highest_slotid)) 2421 return (FALSE); 2422 if (!xdr_slotid4(xdrs, &objp->csr_target_highest_slotid)) 2423 return (FALSE); 2424 return (TRUE); 2425 } 2426 2427 bool_t 2428 xdr_CB_SEQUENCE4res(XDR *xdrs, CB_SEQUENCE4res *objp) 2429 { 2430 if (!xdr_nfsstat4(xdrs, &objp->csr_status)) 2431 return (FALSE); 2432 switch (objp->csr_status) { 2433 case NFS4_OK: 2434 if (!xdr_CB_SEQUENCE4resok(xdrs, 2435 &objp->CB_SEQUENCE4res_u.csr_resok4)) 2436 return (FALSE); 2437 break; 2438 } 2439 return (TRUE); 2440 } 2441 2442 bool_t 2443 xdr_CB_WANTS_CANCELLED4args(XDR *xdrs, CB_WANTS_CANCELLED4args *objp) 2444 { 2445 if (!xdr_bool(xdrs, &objp->cwca_contended_wants_cancelled)) 2446 return (FALSE); 2447 if (!xdr_bool(xdrs, &objp->cwca_resourced_wants_cancelled)) 2448 return (FALSE); 2449 return (TRUE); 2450 } 2451 2452 bool_t 2453 xdr_CB_WANTS_CANCELLED4res(XDR *xdrs, CB_WANTS_CANCELLED4res *objp) 2454 { 2455 if (!xdr_nfsstat4(xdrs, &objp->cwcr_status)) 2456 return (FALSE); 2457 return (TRUE); 2458 } 2459 2460 bool_t 2461 xdr_CB_NOTIFY_LOCK4args(XDR *xdrs, CB_NOTIFY_LOCK4args *objp) 2462 { 2463 if (!xdr_nfs_fh4(xdrs, &objp->cnla_fh)) 2464 return (FALSE); 2465 if (!xdr_lock_owner4(xdrs, &objp->cnla_lock_owner)) 2466 return (FALSE); 2467 return (TRUE); 2468 } 2469 2470 bool_t 2471 xdr_CB_NOTIFY_LOCK4res(XDR *xdrs, CB_NOTIFY_LOCK4res *objp) 2472 { 2473 if (!xdr_nfsstat4(xdrs, &objp->cnlr_status)) 2474 return (FALSE); 2475 return (TRUE); 2476 } 2477 2478 bool_t 2479 xdr_notify_deviceid_type4(XDR *xdrs, notify_deviceid_type4 *objp) 2480 { 2481 2482 if (!xdr_enum(xdrs, (enum_t *)objp)) 2483 return (FALSE); 2484 return (TRUE); 2485 } 2486 2487 bool_t 2488 xdr_notify_deviceid_delete4(XDR *xdrs, notify_deviceid_delete4 *objp) 2489 { 2490 if (!xdr_layouttype4(xdrs, &objp->ndd_layouttype)) 2491 return (FALSE); 2492 if (!xdr_deviceid4(xdrs, objp->ndd_deviceid)) 2493 return (FALSE); 2494 return (TRUE); 2495 } 2496 2497 bool_t 2498 xdr_notify_deviceid_change4(XDR *xdrs, notify_deviceid_change4 *objp) 2499 { 2500 2501 if (!xdr_layouttype4(xdrs, &objp->ndc_layouttype)) 2502 return (FALSE); 2503 if (!xdr_deviceid4(xdrs, objp->ndc_deviceid)) 2504 return (FALSE); 2505 if (!xdr_bool(xdrs, &objp->ndc_immediate)) 2506 return (FALSE); 2507 return (TRUE); 2508 } 2509 2510 bool_t 2511 xdr_CB_NOTIFY_DEVICEID4args(XDR *xdrs, CB_NOTIFY_DEVICEID4args *objp) 2512 { 2513 if (!xdr_array(xdrs, (char **)&objp->cnda_changes.cnda_changes_val, 2514 (uint_t *)&objp->cnda_changes.cnda_changes_len, ~0, 2515 sizeof (notify4), (xdrproc_t)xdr_notify4)) 2516 return (FALSE); 2517 return (TRUE); 2518 } 2519 2520 bool_t 2521 xdr_CB_NOTIFY_DEVICEID4res(XDR *xdrs, CB_NOTIFY_DEVICEID4res *objp) 2522 { 2523 if (!xdr_nfsstat4(xdrs, &objp->cndr_status)) 2524 return (FALSE); 2525 return (TRUE); 2526 } 2527 2528 /* Callback operations new to NFSv4.1 */ 2529 2530 bool_t 2531 xdr_nfs_cb_argop4(XDR *xdrs, nfs_cb_argop4 *objp) 2532 { 2533 /* argop has already been xdr'd */ 2534 switch (objp->argop) { 2535 case OP_CB_LAYOUTRECALL: 2536 if (!xdr_CB_LAYOUTRECALL4args(xdrs, 2537 &objp->nfs_cb_argop4_u.opcblayoutrecall)) 2538 return (FALSE); 2539 break; 2540 case OP_CB_NOTIFY: 2541 if (!xdr_CB_NOTIFY4args(xdrs, 2542 &objp->nfs_cb_argop4_u.opcbnotify)) 2543 return (FALSE); 2544 break; 2545 case OP_CB_PUSH_DELEG: 2546 if (!xdr_CB_PUSH_DELEG4args(xdrs, 2547 &objp->nfs_cb_argop4_u.opcbpush_deleg)) 2548 return (FALSE); 2549 break; 2550 case OP_CB_RECALL_ANY: 2551 if (!xdr_CB_RECALL_ANY4args(xdrs, 2552 &objp->nfs_cb_argop4_u.opcbrecall_any)) 2553 return (FALSE); 2554 break; 2555 case OP_CB_RECALLABLE_OBJ_AVAIL: 2556 if (!xdr_CB_RECALLABLE_OBJ_AVAIL4args(xdrs, 2557 &objp->nfs_cb_argop4_u.opcbrecallable_obj_avail)) 2558 return (FALSE); 2559 break; 2560 case OP_CB_RECALL_SLOT: 2561 if (!xdr_CB_RECALL_SLOT4args(xdrs, 2562 &objp->nfs_cb_argop4_u.opcbrecall_slot)) 2563 return (FALSE); 2564 break; 2565 case OP_CB_SEQUENCE: 2566 if (!xdr_CB_SEQUENCE4args(xdrs, 2567 &objp->nfs_cb_argop4_u.opcbsequence)) 2568 return (FALSE); 2569 break; 2570 case OP_CB_WANTS_CANCELLED: 2571 if (!xdr_CB_WANTS_CANCELLED4args(xdrs, 2572 &objp->nfs_cb_argop4_u.opcbwants_cancelled)) 2573 return (FALSE); 2574 break; 2575 case OP_CB_NOTIFY_LOCK: 2576 if (!xdr_CB_NOTIFY_LOCK4args(xdrs, 2577 &objp->nfs_cb_argop4_u.opcbnotify_lock)) 2578 return (FALSE); 2579 break; 2580 case OP_CB_NOTIFY_DEVICEID: 2581 if (!xdr_CB_NOTIFY_DEVICEID4args(xdrs, 2582 &objp->nfs_cb_argop4_u.opcbnotify_deviceid)) 2583 return (FALSE); 2584 break; 2585 default: 2586 return (FALSE); 2587 } 2588 return (TRUE); 2589 } 2590 2591 bool_t 2592 xdr_CB_GETATTR4res(XDR *xdrs, CB_GETATTR4res *objp) 2593 { 2594 if (!xdr_nfsstat4(xdrs, &objp->status)) 2595 return (FALSE); 2596 2597 switch (objp->status) { 2598 case NFS4_OK: 2599 if (!xdr_fattr4(xdrs, &objp->obj_attributes)) 2600 return (FALSE); 2601 break; 2602 } 2603 return (TRUE); 2604 } 2605 2606 bool_t 2607 xdr_CB_RECALL4res(XDR *xdrs, CB_RECALL4res *objp) 2608 { 2609 if (!xdr_nfsstat4(xdrs, &objp->status)) 2610 return (FALSE); 2611 return (TRUE); 2612 } 2613 2614 bool_t 2615 xdr_CB_ILLEGAL4res(XDR *xdrs, CB_ILLEGAL4res *objp) 2616 { 2617 if (!xdr_nfsstat4(xdrs, &objp->status)) 2618 return (FALSE); 2619 return (TRUE); 2620 } 2621 2622 bool_t 2623 xdr_nfs_cb_resop4(XDR *xdrs, nfs_cb_resop4 *objp) 2624 { 2625 if (!xdr_u_int(xdrs, &objp->resop)) 2626 return (FALSE); 2627 2628 switch (objp->resop) { 2629 case OP_CB_GETATTR: 2630 if (!xdr_CB_GETATTR4res(xdrs, 2631 &objp->nfs_cb_resop4_u.opcbgetattr)) 2632 return (FALSE); 2633 break; 2634 case OP_CB_RECALL: 2635 if (!xdr_CB_RECALL4res(xdrs, 2636 &objp->nfs_cb_resop4_u.opcbrecall)) 2637 return (FALSE); 2638 break; 2639 case OP_CB_LAYOUTRECALL: 2640 if (!xdr_CB_LAYOUTRECALL4res(xdrs, 2641 &objp->nfs_cb_resop4_u.opcblayoutrecall)) 2642 return (FALSE); 2643 break; 2644 case OP_CB_NOTIFY: 2645 if (!xdr_CB_NOTIFY4res(xdrs, 2646 &objp->nfs_cb_resop4_u.opcbnotify)) 2647 return (FALSE); 2648 break; 2649 case OP_CB_PUSH_DELEG: 2650 if (!xdr_CB_PUSH_DELEG4res(xdrs, 2651 &objp->nfs_cb_resop4_u.opcbpush_deleg)) 2652 return (FALSE); 2653 break; 2654 case OP_CB_RECALL_ANY: 2655 if (!xdr_CB_RECALL_ANY4res(xdrs, 2656 &objp->nfs_cb_resop4_u.opcbrecall_any)) 2657 return (FALSE); 2658 break; 2659 case OP_CB_RECALLABLE_OBJ_AVAIL: 2660 if (!xdr_CB_RECALLABLE_OBJ_AVAIL4res(xdrs, 2661 &objp->nfs_cb_resop4_u.opcbrecallable_obj_avail)) 2662 return (FALSE); 2663 break; 2664 case OP_CB_RECALL_SLOT: 2665 if (!xdr_CB_RECALL_SLOT4res(xdrs, 2666 &objp->nfs_cb_resop4_u.opcbrecall_slot)) 2667 return (FALSE); 2668 break; 2669 case OP_CB_SEQUENCE: 2670 if (!xdr_CB_SEQUENCE4res(xdrs, 2671 &objp->nfs_cb_resop4_u.opcbsequence)) 2672 return (FALSE); 2673 break; 2674 case OP_CB_WANTS_CANCELLED: 2675 if (!xdr_CB_WANTS_CANCELLED4res(xdrs, 2676 &objp->nfs_cb_resop4_u.opcbwants_cancelled)) 2677 return (FALSE); 2678 break; 2679 case OP_CB_NOTIFY_LOCK: 2680 if (!xdr_CB_NOTIFY_LOCK4res(xdrs, 2681 &objp->nfs_cb_resop4_u.opcbnotify_lock)) 2682 return (FALSE); 2683 break; 2684 case OP_CB_NOTIFY_DEVICEID: 2685 if (!xdr_CB_NOTIFY_DEVICEID4res(xdrs, 2686 &objp->nfs_cb_resop4_u.opcbnotify_deviceid)) 2687 return (FALSE); 2688 break; 2689 case OP_CB_ILLEGAL: 2690 if (!xdr_CB_ILLEGAL4res(xdrs, 2691 &objp->nfs_cb_resop4_u.opcbillegal)) 2692 return (FALSE); 2693 break; 2694 default: 2695 return (FALSE); 2696 } 2697 return (TRUE); 2698 } 2699 2700 /* 2701 * Additional common NFSv4 XDR 2702 */ 2703 2704 bool_t 2705 xdr_clientid4(XDR *xdrs, clientid4 *objp) 2706 { 2707 if (!xdr_uint64_t(xdrs, objp)) 2708 return (FALSE); 2709 return (TRUE); 2710 } 2711 2712 bool_t 2713 xdr_component4(XDR *xdrs, component4 *objp) 2714 { 2715 if (!xdr_utf8string(xdrs, objp)) 2716 return (FALSE); 2717 return (TRUE); 2718 } 2719 2720 bool_t 2721 xdr_count4(XDR *xdrs, count4 *objp) 2722 { 2723 if (!xdr_uint32_t(xdrs, objp)) 2724 return (FALSE); 2725 return (TRUE); 2726 } 2727 2728 bool_t 2729 xdr_fsid4(XDR *xdrs, fsid4 *objp) 2730 { 2731 if (!xdr_uint64_t(xdrs, &objp->major)) 2732 return (FALSE); 2733 if (!xdr_uint64_t(xdrs, &objp->minor)) 2734 return (FALSE); 2735 return (TRUE); 2736 } 2737 2738 bool_t 2739 xdr_length4(XDR *xdrs, length4 *objp) 2740 { 2741 if (!xdr_uint64_t(xdrs, objp)) 2742 return (FALSE); 2743 return (TRUE); 2744 } 2745 2746 bool_t 2747 xdr_limit_by4(XDR *xdrs, limit_by4 *objp) 2748 { 2749 if (!xdr_enum(xdrs, (enum_t *)objp)) 2750 return (FALSE); 2751 return (TRUE); 2752 } 2753 2754 bool_t 2755 xdr_lock_owner4(XDR *xdrs, lock_owner4 *objp) 2756 { 2757 if (!xdr_clientid4(xdrs, &objp->clientid)) 2758 return (FALSE); 2759 if (!xdr_bytes(xdrs, (char **)&objp->owner_val, 2760 (uint_t *)&objp->owner_len, NFS4_OPAQUE_LIMIT)) 2761 return (FALSE); 2762 return (TRUE); 2763 } 2764 2765 bool_t 2766 xdr_mode4(XDR *xdrs, mode4 *objp) 2767 { 2768 if (!xdr_uint32_t(xdrs, objp)) 2769 return (FALSE); 2770 return (TRUE); 2771 } 2772 2773 bool_t 2774 xdr_netaddr4(XDR *xdrs, netaddr4 *objp) 2775 { 2776 if (!xdr_string(xdrs, &objp->na_r_netid, ~0)) 2777 return (FALSE); 2778 if (!xdr_string(xdrs, &objp->na_r_addr, ~0)) 2779 return (FALSE); 2780 return (TRUE); 2781 } 2782 2783 bool_t 2784 xdr_nfs_cookie4(XDR *xdrs, nfs_cookie4 *objp) 2785 { 2786 if (!xdr_uint64_t(xdrs, objp)) 2787 return (FALSE); 2788 return (TRUE); 2789 } 2790 2791 2792 bool_t 2793 xdr_nfs_modified_limit4(XDR *xdrs, nfs_modified_limit4 *objp) 2794 { 2795 if (!xdr_uint32_t(xdrs, &objp->num_blocks)) 2796 return (FALSE); 2797 if (!xdr_uint32_t(xdrs, &objp->bytes_per_block)) 2798 return (FALSE); 2799 return (TRUE); 2800 } 2801 2802 2803 bool_t 2804 xdr_nfs_space_limit4(XDR *xdrs, nfs_space_limit4 *objp) 2805 { 2806 if (!xdr_limit_by4(xdrs, &objp->limitby)) 2807 return (FALSE); 2808 switch (objp->limitby) { 2809 case NFS_LIMIT_SIZE: 2810 if (!xdr_uint64_t(xdrs, &objp->nfs_space_limit4_u.filesize)) 2811 return (FALSE); 2812 break; 2813 case NFS_LIMIT_BLOCKS: 2814 if (!xdr_nfs_modified_limit4(xdrs, 2815 &objp->nfs_space_limit4_u.mod_blocks)) 2816 return (FALSE); 2817 break; 2818 default: 2819 return (FALSE); 2820 } 2821 return (TRUE); 2822 } 2823 2824 bool_t 2825 xdr_nfsstat4(XDR *xdrs, nfsstat4 *objp) 2826 { 2827 if (!xdr_enum(xdrs, (enum_t *)objp)) 2828 return (FALSE); 2829 return (TRUE); 2830 } 2831 2832 bool_t 2833 xdr_offset4(XDR *xdrs, offset4 *objp) 2834 { 2835 if (!xdr_uint64_t(xdrs, objp)) 2836 return (FALSE); 2837 return (TRUE); 2838 } 2839 2840 bool_t 2841 xdr_open_claim_type4(XDR *xdrs, open_claim_type4 *objp) 2842 { 2843 if (!xdr_enum(xdrs, (enum_t *)objp)) 2844 return (FALSE); 2845 return (TRUE); 2846 } 2847 2848 bool_t 2849 xdr_open_delegation_type4(XDR *xdrs, open_delegation_type4 *objp) 2850 { 2851 if (!xdr_enum(xdrs, (enum_t *)objp)) 2852 return (FALSE); 2853 return (TRUE); 2854 } 2855 2856 bool_t 2857 xdr_open_read_delegation4(XDR *xdrs, open_read_delegation4 *objp) 2858 { 2859 if (!xdr_stateid4(xdrs, &objp->stateid)) 2860 return (FALSE); 2861 if (!xdr_bool(xdrs, &objp->recall)) 2862 return (FALSE); 2863 if (!xdr_nfsace4(xdrs, &objp->permissions)) 2864 return (FALSE); 2865 return (TRUE); 2866 } 2867 2868 bool_t 2869 xdr_open_write_delegation4(XDR *xdrs, open_write_delegation4 *objp) 2870 { 2871 if (!xdr_stateid4(xdrs, &objp->stateid)) 2872 return (FALSE); 2873 if (!xdr_bool(xdrs, &objp->recall)) 2874 return (FALSE); 2875 if (!xdr_nfs_space_limit4(xdrs, &objp->space_limit)) 2876 return (FALSE); 2877 if (!xdr_nfsace4(xdrs, &objp->permissions)) 2878 return (FALSE); 2879 return (TRUE); 2880 } 2881 2882 bool_t 2883 xdr_pathname4(XDR *xdrs, pathname4 *objp) 2884 { 2885 if (!xdr_array(xdrs, (char **)&objp->pathname4_val, 2886 (uint_t *)&objp->pathname4_len, ~0, sizeof (component4), 2887 (xdrproc_t)xdr_component4)) 2888 return (FALSE); 2889 return (TRUE); 2890 } 2891 2892 bool_t 2893 xdr_sec_oid4(XDR *xdrs, sec_oid4 *objp) 2894 { 2895 if (!xdr_bytes(xdrs, (char **)&objp->sec_oid4_val, 2896 (uint_t *)&objp->sec_oid4_len, ~0)) 2897 return (FALSE); 2898 return (TRUE); 2899 } 2900 2901 bool_t 2902 xdr_rpc_gss_svc_t(XDR *xdrs, rpc_gss_svc_t *objp) 2903 { 2904 if (!xdr_enum(xdrs, (enum_t *)objp)) 2905 return (FALSE); 2906 return (TRUE); 2907 } 2908 2909 bool_t 2910 xdr_stateid4(XDR *xdrs, stateid4 *objp) 2911 { 2912 if (!xdr_uint32_t(xdrs, &objp->seqid)) 2913 return (FALSE); 2914 if (!xdr_opaque(xdrs, objp->other, 12)) 2915 return (FALSE); 2916 return (TRUE); 2917 } 2918 2919 bool_t 2920 xdr_utf8str_cis(XDR *xdrs, utf8str_cis *objp) 2921 { 2922 if (!xdr_utf8string(xdrs, objp)) 2923 return (FALSE); 2924 return (TRUE); 2925 } 2926 2927 bool_t 2928 xdr_utf8str_cs(XDR *xdrs, utf8str_cs *objp) 2929 { 2930 if (!xdr_utf8string(xdrs, objp)) 2931 return (FALSE); 2932 return (TRUE); 2933 } 2934 2935 /* End of additional common NFSv4 XDR */ 2936