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
xdr_verifier4(XDR * xdrs,verifier4 * objp)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
xdr_sequenceid4(XDR * xdrs,sequenceid4 * objp)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
xdr_sessionid4(XDR * xdrs,sessionid4 objp)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
xdr_slotid4(XDR * xdrs,slotid4 * objp)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
xdr_change_policy4(XDR * xdrs,change_policy4 * objp)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
xdr_aclflag4(XDR * xdrs,aclflag4 * objp)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
xdr_nfsacl41(XDR * xdrs,nfsacl41 * objp)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
xdr_mode_masked4(XDR * xdrs,mode_masked4 * objp)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
xdr_nfs_impl_id4(XDR * xdrs,nfs_impl_id4 * objp)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
xdr_layouttype4(XDR * xdrs,layouttype4 * objp)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
xdr_layout_content4(XDR * xdrs,layout_content4 * objp)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
xdr_layoutiomode4(XDR * xdrs,layoutiomode4 * objp)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
xdr_layout4(XDR * xdrs,layout4 * objp)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
xdr_deviceid4(XDR * xdrs,deviceid4 objp)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
xdr_device_addr4(XDR * xdrs,device_addr4 * objp)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
xdr_layoutupdate4(XDR * xdrs,layoutupdate4 * objp)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
xdr_layoutreturn_type4(XDR * xdrs,layoutreturn_type4 * objp)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
xdr_layoutreturn_file4(XDR * xdrs,layoutreturn_file4 * objp)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
xdr_layoutreturn4(XDR * xdrs,layoutreturn4 * objp)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
xdr_fs4_status_type(XDR * xdrs,fs4_status_type * objp)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
xdr_fs4_status(XDR * xdrs,fs4_status * objp)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
xdr_threshold4_read_size(XDR * xdrs,threshold4_read_size * objp)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
xdr_threshold4_write_size(XDR * xdrs,threshold4_write_size * objp)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
xdr_threshold4_read_iosize(XDR * xdrs,threshold4_read_iosize * objp)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
xdr_threshold4_write_iosize(XDR * xdrs,threshold4_write_iosize * objp)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
xdr_threshold_item4(XDR * xdrs,threshold_item4 * objp)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
xdr_mdsthreshold4(XDR * xdrs,mdsthreshold4 * objp)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
xdr_retention_get4(XDR * xdrs,retention_get4 * objp)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
xdr_retention_set4(XDR * xdrs,retention_set4 * objp)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
xdr_fs_charset_cap4(XDR * xdrs,fs_charset_cap4 * objp)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
xdr_netloc_type4(XDR * xdrs,netloc_type4 * objp)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
xdr_netloc4(XDR * xdrs,netloc4 * objp)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
xdr_change_attr_type4(XDR * xdrs,change_attr_type4 * objp)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
xdr_app_data_block4(XDR * xdrs,app_data_block4 * objp)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
xdr_data4(XDR * xdrs,data4 * objp)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
xdr_data_info4(XDR * xdrs,data_info4 * objp)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
xdr_data_content4(XDR * xdrs,data_content4 * objp)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
xdr_stable_how4(XDR * xdrs,stable_how4 * objp)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
xdr_write_response4(XDR * xdrs,write_response4 * objp)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
xdr_fattr4_mode_set_masked(XDR * xdrs,fattr4_mode_set_masked * objp)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
xdr_fattr4_dir_notif_delay(XDR * xdrs,fattr4_dir_notif_delay * objp)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
xdr_fattr4_dirent_notif_delay(XDR * xdrs,fattr4_dirent_notif_delay * objp)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
xdr_fattr4_fs_layout_types(XDR * xdrs,fattr4_fs_layout_types * objp)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
xdr_fattr4_fs_status(XDR * xdrs,fattr4_fs_status * objp)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
xdr_fattr4_fs_charset_cap4(XDR * xdrs,fattr4_fs_charset_cap * objp)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
xdr_fattr4_retention_get(XDR * xdrs,fattr4_retention_get * objp)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
xdr_fattr4_retention_set(XDR * xdrs,fattr4_retention_set * objp)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
xdr_fattr4_retentevt_get(XDR * xdrs,fattr4_retentevt_get * objp)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
xdr_fattr4_retentevt_set(XDR * xdrs,fattr4_retentevt_set * objp)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
xdr_fattr4_retention_hold(XDR * xdrs,fattr4_retention_hold * objp)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
xdr_fattr4_dacl(XDR * xdrs,fattr4_dacl * objp)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
xdr_fattr4_sacl(XDR * xdrs,fattr4_sacl * objp)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
xdr_client_owner4(XDR * xdrs,client_owner4 * objp)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
xdr_server_owner4(XDR * xdrs,server_owner4 * objp)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
xdr_state_owner4(XDR * xdrs,state_owner4 * objp)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
xdr_ssv_subkey4(XDR * xdrs,ssv_subkey4 * objp)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
xdr_ssv_mic_plain_tkn4(XDR * xdrs,ssv_mic_plain_tkn4 * objp)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
xdr_ssv_mic_tkn4(XDR * xdrs,ssv_mic_tkn4 * objp)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
xdr_ssv_seal_plain_tkn4(XDR * xdrs,ssv_seal_plain_tkn4 * objp)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
xdr_ssv_seal_cipher_tkn4(XDR * xdrs,ssv_seal_cipher_tkn4 * objp)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
xdr_fs_locations_server4(XDR * xdrs,fs_locations_server4 * objp)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
xdr_fs_locations_item4(XDR * xdrs,fs_locations_item4 * objp)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
xdr_fs_locations_info4(XDR * xdrs,fs_locations_info4 * objp)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
xdr_fattr4_fs_locations_info(XDR * xdrs,fattr4_fs_locations_info * objp)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
xdr_nfl_util4(XDR * xdrs,nfl_util4 * objp)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
xdr_filelayout_hint_care4(XDR * xdrs,filelayout_hint_care4 * objp)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
xdr_multipath_list4(XDR * xdrs,multipath_list4 * objp)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
xdr_nfsv4_1_file_layout_ds_addr4(XDR * xdrs,nfsv4_1_file_layout_ds_addr4 * objp)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
xdr_nfsv4_1_file_layout4(XDR * xdrs,nfsv4_1_file_layout4 * objp)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
xdr_creatverfattr(XDR * xdrs,creatverfattr * objp)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
xdr_open_claim_delegate_cur4(XDR * xdrs,open_claim_delegate_cur4 * objp)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
xdr_open_claim4(XDR * xdrs,open_claim4 * objp)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
xdr_why_no_delegation4(XDR * xdrs,why_no_delegation4 * objp)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
xdr_open_none_delegation4(XDR * xdrs,open_none_delegation4 * objp)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
xdr_open_delegation4(XDR * xdrs,open_delegation4 * objp)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
xdr_gsshandle4_t(XDR * xdrs,gsshandle4_t * objp)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
xdr_gss_cb_handles4(XDR * xdrs,gss_cb_handles4 * objp)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
xdr_callback_sec_parms4(XDR * xdrs,callback_sec_parms4 * objp)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
xdr_BACKCHANNEL_CTL4args(XDR * xdrs,BACKCHANNEL_CTL4args * objp)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
xdr_BACKCHANNEL_CTL4res(XDR * xdrs,BACKCHANNEL_CTL4res * objp)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
xdr_channel_dir_from_client4(XDR * xdrs,channel_dir_from_client4 * objp)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
xdr_BIND_CONN_TO_SESSION4args(XDR * xdrs,BIND_CONN_TO_SESSION4args * objp)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
xdr_channel_dir_from_server4(XDR * xdrs,channel_dir_from_server4 * objp)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
xdr_BIND_CONN_TO_SESSION4resok(XDR * xdrs,BIND_CONN_TO_SESSION4resok * objp)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
xdr_BIND_CONN_TO_SESSION4res(XDR * xdrs,BIND_CONN_TO_SESSION4res * objp)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
xdr_state_protect_ops4(XDR * xdrs,state_protect_ops4 * objp)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
xdr_ssv_sp_parms4(XDR * xdrs,ssv_sp_parms4 * objp)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
xdr_state_protect_how4(XDR * xdrs,state_protect_how4 * objp)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
xdr_state_protect4_a(XDR * xdrs,state_protect4_a * objp)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
xdr_EXCHANGE_ID4args(XDR * xdrs,EXCHANGE_ID4args * objp)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
xdr_ssv_prot_info4(XDR * xdrs,ssv_prot_info4 * objp)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
xdr_state_protect4_r(XDR * xdrs,state_protect4_r * objp)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
xdr_EXCHANGE_ID4resok(XDR * xdrs,EXCHANGE_ID4resok * objp)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
xdr_EXCHANGE_ID4res(XDR * xdrs,EXCHANGE_ID4res * objp)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
xdr_channel_attrs4(XDR * xdrs,channel_attrs4 * objp)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
xdr_CREATE_SESSION4args(XDR * xdrs,CREATE_SESSION4args * objp)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
xdr_CREATE_SESSION4resok(XDR * xdrs,CREATE_SESSION4resok * objp)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
xdr_CREATE_SESSION4res(XDR * xdrs,CREATE_SESSION4res * objp)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
xdr_DESTROY_SESSION4args(XDR * xdrs,DESTROY_SESSION4args * objp)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
xdr_DESTROY_SESSION4res(XDR * xdrs,DESTROY_SESSION4res * objp)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
xdr_FREE_STATEID4args(XDR * xdrs,FREE_STATEID4args * objp)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
xdr_FREE_STATEID4res(XDR * xdrs,FREE_STATEID4res * objp)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
xdr_attr_notice4(XDR * xdrs,attr_notice4 * objp)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
xdr_GET_DIR_DELEGATION4args(XDR * xdrs,GET_DIR_DELEGATION4args * objp)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
xdr_GET_DIR_DELEGATION4resok(XDR * xdrs,GET_DIR_DELEGATION4resok * objp)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
xdr_gddrnf4_status(XDR * xdrs,gddrnf4_status * objp)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
xdr_GET_DIR_DELEGATION4res_non_fatal(XDR * xdrs,GET_DIR_DELEGATION4res_non_fatal * objp)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
xdr_GET_DIR_DELEGATION4res(XDR * xdrs,GET_DIR_DELEGATION4res * objp)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
xdr_bitmap4_notify(XDR * xdrs,bitmap4 * objp)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
xdr_GETDEVICEINFO4args(XDR * xdrs,GETDEVICEINFO4args * objp)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
xdr_GETDEVICEINFO4resok(XDR * xdrs,GETDEVICEINFO4resok * objp)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
xdr_GETDEVICEINFO4res(XDR * xdrs,GETDEVICEINFO4res * objp)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
xdr_GETDEVICELIST4args(XDR * xdrs,GETDEVICELIST4args * objp)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
xdr_GETDEVICELIST4resok(XDR * xdrs,GETDEVICELIST4resok * objp)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
xdr_GETDEVICELIST4res(XDR * xdrs,GETDEVICELIST4res * objp)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
xdr_newtime4(XDR * xdrs,newtime4 * objp)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
xdr_newoffset4(XDR * xdrs,newoffset4 * objp)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
xdr_LAYOUTCOMMIT4args(XDR * xdrs,LAYOUTCOMMIT4args * objp)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
xdr_newsize4(XDR * xdrs,newsize4 * objp)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
xdr_LAYOUTCOMMIT4resok(XDR * xdrs,LAYOUTCOMMIT4resok * objp)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
xdr_LAYOUTCOMMIT4res(XDR * xdrs,LAYOUTCOMMIT4res * objp)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
xdr_LAYOUTGET4args(XDR * xdrs,LAYOUTGET4args * objp)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
xdr_LAYOUTGET4resok(XDR * xdrs,LAYOUTGET4resok * objp)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
xdr_LAYOUTGET4res(XDR * xdrs,LAYOUTGET4res * objp)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
xdr_LAYOUTRETURN4args(XDR * xdrs,LAYOUTRETURN4args * objp)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
xdr_layoutreturn_stateid(XDR * xdrs,layoutreturn_stateid * objp)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
xdr_LAYOUTRETURN4res(XDR * xdrs,LAYOUTRETURN4res * objp)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
xdr_secinfo_style4(XDR * xdrs,secinfo_style4 * objp)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
xdr_SECINFO_NO_NAME4args(XDR * xdrs,SECINFO_NO_NAME4args * objp)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
xdr_SECINFO_NO_NAME4res(XDR * xdrs,SECINFO_NO_NAME4res * objp)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
xdr_SEQUENCE4args(XDR * xdrs,SEQUENCE4args * objp)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
xdr_SEQUENCE4resok(XDR * xdrs,SEQUENCE4resok * objp)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
xdr_SEQUENCE4res(XDR * xdrs,SEQUENCE4res * objp)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
xdr_ssa_digest_input4(XDR * xdrs,ssa_digest_input4 * objp)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
xdr_SET_SSV4args(XDR * xdrs,SET_SSV4args * objp)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
xdr_ssr_digest_input4(XDR * xdrs,ssr_digest_input4 * objp)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
xdr_SET_SSV4resok(XDR * xdrs,SET_SSV4resok * objp)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
xdr_SET_SSV4res(XDR * xdrs,SET_SSV4res * objp)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
xdr_TEST_STATEID4args(XDR * xdrs,TEST_STATEID4args * objp)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
xdr_TEST_STATEID4resok(XDR * xdrs,TEST_STATEID4resok * objp)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
xdr_TEST_STATEID4res(XDR * xdrs,TEST_STATEID4res * objp)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
xdr_deleg_claim4(XDR * xdrs,deleg_claim4 * objp)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
xdr_WANT_DELEGATION4args(XDR * xdrs,WANT_DELEGATION4args * objp)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
xdr_WANT_DELEGATION4res(XDR * xdrs,WANT_DELEGATION4res * objp)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
xdr_DESTROY_CLIENTID4args(XDR * xdrs,DESTROY_CLIENTID4args * objp)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
xdr_DESTROY_CLIENTID4res(XDR * xdrs,DESTROY_CLIENTID4res * objp)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
xdr_RECLAIM_COMPLETE4args(XDR * xdrs,RECLAIM_COMPLETE4args * objp)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
xdr_RECLAIM_COMPLETE4res(XDR * xdrs,RECLAIM_COMPLETE4res * objp)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
xdr_nfs_opnum4(XDR * xdrs,nfs_opnum4 * objp)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
xdr_ALLOCATE4args(XDR * xdrs,ALLOCATE4args * objp)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
xdr_ALLOCATE4res(XDR * xdrs,ALLOCATE4res * objp)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
xdr_COPY4args(XDR * xdrs,COPY4args * objp)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
xdr_copy_requirements4(XDR * xdrs,copy_requirements4 * objp)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
xdr_COPY4resok(XDR * xdrs,COPY4resok * objp)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
xdr_COPY4res(XDR * xdrs,COPY4res * objp)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
xdr_COPY_NOTIFY4args(XDR * xdrs,COPY_NOTIFY4args * objp)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
xdr_COPY_NOTIFY4resok(XDR * xdrs,COPY_NOTIFY4resok * objp)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
xdr_COPY_NOTIFY4res(XDR * xdrs,COPY_NOTIFY4res * objp)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
xdr_DEALLOCATE4args(XDR * xdrs,DEALLOCATE4args * objp)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
xdr_DEALLOCATE4res(XDR * xdrs,DEALLOCATE4res * objp)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
xdr_IO_ADVISE_type4(XDR * xdrs,IO_ADVISE_type4 * objp)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
xdr_IO_ADVISE4args(XDR * xdrs,IO_ADVISE4args * objp)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
xdr_IO_ADVISE4resok(XDR * xdrs,IO_ADVISE4resok * objp)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
xdr_IO_ADVISE4res(XDR * xdrs,IO_ADVISE4res * objp)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
xdr_device_error4(XDR * xdrs,device_error4 * objp)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
xdr_LAYOUTERROR4args(XDR * xdrs,LAYOUTERROR4args * objp)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
xdr_LAYOUTERROR4res(XDR * xdrs,LAYOUTERROR4res * objp)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
xdr_io_info4(XDR * xdrs,io_info4 * objp)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
xdr_LAYOUTSTATS4args(XDR * xdrs,LAYOUTSTATS4args * objp)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
xdr_LAYOUTSTATS4res(XDR * xdrs,LAYOUTSTATS4res * objp)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
xdr_OFFLOAD_CANCEL4args(XDR * xdrs,OFFLOAD_CANCEL4args * objp)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
xdr_OFFLOAD_CANCEL4res(XDR * xdrs,OFFLOAD_CANCEL4res * objp)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
xdr_OFFLOAD_STATUS4args(XDR * xdrs,OFFLOAD_STATUS4args * objp)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
xdr_OFFLOAD_STATUS4resok(XDR * xdrs,OFFLOAD_STATUS4resok * objp)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
xdr_OFFLOAD_STATUS4res(XDR * xdrs,OFFLOAD_STATUS4res * objp)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
xdr_READ_PLUS4args(XDR * xdrs,READ_PLUS4args * objp)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
xdr_read_plus_content(XDR * xdrs,read_plus_content * objp)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
xdr_read_plus_res4(XDR * xdrs,read_plus_res4 * objp)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
xdr_READ_PLUS4res(XDR * xdrs,READ_PLUS4res * objp)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
xdr_SEEK4args(XDR * xdrs,SEEK4args * objp)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
xdr_seek_res4(XDR * xdrs,seek_res4 * objp)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
xdr_SEEK4res(XDR * xdrs,SEEK4res * objp)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
xdr_WRITE_SAME4args(XDR * xdrs,WRITE_SAME4args * objp)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
xdr_WRITE_SAME4res(XDR * xdrs,WRITE_SAME4res * objp)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
xdr_CLONE4args(XDR * xdrs,CLONE4args * objp)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
xdr_CLONE4res(XDR * xdrs,CLONE4res * objp)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
xdr_nfs4x_argop4(XDR * xdrs,nfs_argop4 * objp)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
xdr_nfs4x_resop4(XDR * xdrs,nfs_resop4 * objp)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
xdr_layoutrecall_type4(XDR * xdrs,layoutrecall_type4 * objp)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
xdr_layoutrecall_file4(XDR * xdrs,layoutrecall_file4 * objp)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
xdr_layoutrecall4(XDR * xdrs,layoutrecall4 * objp)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
xdr_CB_LAYOUTRECALL4args(XDR * xdrs,CB_LAYOUTRECALL4args * objp)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
xdr_CB_LAYOUTRECALL4res(XDR * xdrs,CB_LAYOUTRECALL4res * objp)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
xdr_notify_type4(XDR * xdrs,notify_type4 * objp)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
xdr_notify_entry4(XDR * xdrs,notify_entry4 * objp)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
xdr_prev_entry4(XDR * xdrs,prev_entry4 * objp)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
xdr_notify_remove4(XDR * xdrs,notify_remove4 * objp)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
xdr_notify_add4(XDR * xdrs,notify_add4 * objp)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
xdr_notify_attr4(XDR * xdrs,notify_attr4 * objp)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
xdr_notify_rename4(XDR * xdrs,notify_rename4 * objp)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
xdr_notify_verifier4(XDR * xdrs,notify_verifier4 * objp)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
xdr_notifylist4(XDR * xdrs,notifylist4 * objp)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
xdr_notify4(XDR * xdrs,notify4 * objp)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
xdr_CB_NOTIFY4args(XDR * xdrs,CB_NOTIFY4args * objp)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
xdr_CB_NOTIFY4res(XDR * xdrs,CB_NOTIFY4res * objp)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
xdr_CB_PUSH_DELEG4args(XDR * xdrs,CB_PUSH_DELEG4args * objp)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
xdr_CB_PUSH_DELEG4res(XDR * xdrs,CB_PUSH_DELEG4res * objp)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
xdr_CB_RECALL_ANY4args(XDR * xdrs,CB_RECALL_ANY4args * objp)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
xdr_CB_RECALL_ANY4res(XDR * xdrs,CB_RECALL_ANY4res * objp)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
xdr_CB_RECALLABLE_OBJ_AVAIL4args(XDR * xdrs,CB_RECALLABLE_OBJ_AVAIL4args * objp)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
xdr_CB_RECALLABLE_OBJ_AVAIL4res(XDR * xdrs,CB_RECALLABLE_OBJ_AVAIL4res * objp)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
xdr_CB_RECALL_SLOT4args(XDR * xdrs,CB_RECALL_SLOT4args * objp)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
xdr_CB_RECALL_SLOT4res(XDR * xdrs,CB_RECALL_SLOT4res * objp)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
xdr_referring_call4(XDR * xdrs,referring_call4 * objp)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
xdr_referring_call_list4(XDR * xdrs,referring_call_list4 * objp)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
xdr_CB_SEQUENCE4args(XDR * xdrs,CB_SEQUENCE4args * objp)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
xdr_CB_SEQUENCE4resok(XDR * xdrs,CB_SEQUENCE4resok * objp)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
xdr_CB_SEQUENCE4res(XDR * xdrs,CB_SEQUENCE4res * objp)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
xdr_CB_WANTS_CANCELLED4args(XDR * xdrs,CB_WANTS_CANCELLED4args * objp)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
xdr_CB_WANTS_CANCELLED4res(XDR * xdrs,CB_WANTS_CANCELLED4res * objp)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
xdr_CB_NOTIFY_LOCK4args(XDR * xdrs,CB_NOTIFY_LOCK4args * objp)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
xdr_CB_NOTIFY_LOCK4res(XDR * xdrs,CB_NOTIFY_LOCK4res * objp)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
xdr_notify_deviceid_type4(XDR * xdrs,notify_deviceid_type4 * objp)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
xdr_notify_deviceid_delete4(XDR * xdrs,notify_deviceid_delete4 * objp)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
xdr_notify_deviceid_change4(XDR * xdrs,notify_deviceid_change4 * objp)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
xdr_CB_NOTIFY_DEVICEID4args(XDR * xdrs,CB_NOTIFY_DEVICEID4args * objp)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
xdr_CB_NOTIFY_DEVICEID4res(XDR * xdrs,CB_NOTIFY_DEVICEID4res * objp)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
xdr_nfs_cb_argop4(XDR * xdrs,nfs_cb_argop4 * objp)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
xdr_CB_GETATTR4res(XDR * xdrs,CB_GETATTR4res * objp)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
xdr_CB_RECALL4res(XDR * xdrs,CB_RECALL4res * objp)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
xdr_CB_ILLEGAL4res(XDR * xdrs,CB_ILLEGAL4res * objp)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
xdr_nfs_cb_resop4(XDR * xdrs,nfs_cb_resop4 * objp)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
xdr_clientid4(XDR * xdrs,clientid4 * objp)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
xdr_component4(XDR * xdrs,component4 * objp)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
xdr_count4(XDR * xdrs,count4 * objp)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
xdr_fsid4(XDR * xdrs,fsid4 * objp)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
xdr_length4(XDR * xdrs,length4 * objp)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
xdr_limit_by4(XDR * xdrs,limit_by4 * objp)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
xdr_lock_owner4(XDR * xdrs,lock_owner4 * objp)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
xdr_mode4(XDR * xdrs,mode4 * objp)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
xdr_netaddr4(XDR * xdrs,netaddr4 * objp)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
xdr_nfs_cookie4(XDR * xdrs,nfs_cookie4 * objp)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
xdr_nfs_modified_limit4(XDR * xdrs,nfs_modified_limit4 * objp)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
xdr_nfs_space_limit4(XDR * xdrs,nfs_space_limit4 * objp)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
xdr_nfsstat4(XDR * xdrs,nfsstat4 * objp)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
xdr_offset4(XDR * xdrs,offset4 * objp)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
xdr_open_claim_type4(XDR * xdrs,open_claim_type4 * objp)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
xdr_open_delegation_type4(XDR * xdrs,open_delegation_type4 * objp)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
xdr_open_read_delegation4(XDR * xdrs,open_read_delegation4 * objp)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
xdr_open_write_delegation4(XDR * xdrs,open_write_delegation4 * objp)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
xdr_pathname4(XDR * xdrs,pathname4 * objp)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
xdr_sec_oid4(XDR * xdrs,sec_oid4 * objp)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
xdr_rpc_gss_svc_t(XDR * xdrs,rpc_gss_svc_t * objp)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
xdr_stateid4(XDR * xdrs,stateid4 * objp)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
xdr_utf8str_cis(XDR * xdrs,utf8str_cis * objp)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
xdr_utf8str_cs(XDR * xdrs,utf8str_cs * objp)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