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, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #pragma ident "%Z%%M% %I% %E% SMI"
28
29 /*
30 * This file was initially generated using rpcgen. The rpcgen-erated
31 * code used tail recursion to implement linked lists which resulted
32 * in various crashes due to blown stacks. If the NFS4 protocol changes
33 * be sure to either use the NFS4-friendly rpcgen (doesn't use tail
34 * recursion) or do the xdr by hand.
35 *
36 * CAUTION: This file is kept in sync with it's uts counterpart:
37 *
38 * usr/src/uts/common/fs/nfs/nfs4_xdr.c
39 *
40 * However, it is not an exact copy. NEVER copy uts's nfs4_xdr.c
41 * directly over this file. Changes from the uts version must be
42 * integrated by hand into this file.
43 */
44
45 #include <rpcsvc/nfs4_prot.h>
46 #include <nfs/nfs4.h>
47 #include <malloc.h>
48
49 #define IGNORE_RDWR_DATA
50
51 extern int nfs4_skip_bytes;
52
53 bool_t
xdr_nfs_ftype4(register XDR * xdrs,nfs_ftype4 * objp)54 xdr_nfs_ftype4(register XDR *xdrs, nfs_ftype4 *objp)
55 {
56
57 if (!xdr_enum(xdrs, (enum_t *)objp))
58 return (FALSE);
59 return (TRUE);
60 }
61
62 bool_t
xdr_nfsstat4(register XDR * xdrs,nfsstat4 * objp)63 xdr_nfsstat4(register XDR *xdrs, nfsstat4 *objp)
64 {
65
66 if (!xdr_enum(xdrs, (enum_t *)objp))
67 return (FALSE);
68 return (TRUE);
69 }
70
71 bool_t
xdr_bitmap4(register XDR * xdrs,bitmap4 * objp)72 xdr_bitmap4(register XDR *xdrs, bitmap4 *objp)
73 {
74
75 if (!xdr_array(xdrs, (char **)&objp->bitmap4_val,
76 (uint_t *)&objp->bitmap4_len, ~0,
77 sizeof (uint32_t), (xdrproc_t)xdr_uint32_t))
78 return (FALSE);
79 return (TRUE);
80 }
81
82 bool_t
xdr_offset4(register XDR * xdrs,offset4 * objp)83 xdr_offset4(register XDR *xdrs, offset4 *objp)
84 {
85
86 if (!xdr_uint64_t(xdrs, objp))
87 return (FALSE);
88 return (TRUE);
89 }
90
91 bool_t
xdr_count4(register XDR * xdrs,count4 * objp)92 xdr_count4(register XDR *xdrs, count4 *objp)
93 {
94
95 if (!xdr_uint32_t(xdrs, objp))
96 return (FALSE);
97 return (TRUE);
98 }
99
100 bool_t
xdr_length4(register XDR * xdrs,length4 * objp)101 xdr_length4(register XDR *xdrs, length4 *objp)
102 {
103
104 if (!xdr_uint64_t(xdrs, objp))
105 return (FALSE);
106 return (TRUE);
107 }
108
109 bool_t
xdr_clientid4(register XDR * xdrs,clientid4 * objp)110 xdr_clientid4(register XDR *xdrs, clientid4 *objp)
111 {
112
113 if (!xdr_uint64_t(xdrs, objp))
114 return (FALSE);
115 return (TRUE);
116 }
117
118 bool_t
xdr_seqid4(register XDR * xdrs,seqid4 * objp)119 xdr_seqid4(register XDR *xdrs, seqid4 *objp)
120 {
121
122 if (!xdr_uint32_t(xdrs, objp))
123 return (FALSE);
124 return (TRUE);
125 }
126
127 bool_t
xdr_utf8string(register XDR * xdrs,utf8string * objp)128 xdr_utf8string(register XDR *xdrs, utf8string *objp)
129 {
130
131 if (!xdr_bytes(xdrs, (char **)&objp->utf8string_val,
132 (uint_t *)&objp->utf8string_len, NFS4_MAX_UTF8STRING))
133 return (FALSE);
134 return (TRUE);
135 }
136
137 bool_t
xdr_component4(register XDR * xdrs,component4 * objp)138 xdr_component4(register XDR *xdrs, component4 *objp)
139 {
140
141 if (!xdr_utf8string(xdrs, objp))
142 return (FALSE);
143 return (TRUE);
144 }
145
146 bool_t
xdr_pathname4(register XDR * xdrs,pathname4 * objp)147 xdr_pathname4(register XDR *xdrs, pathname4 *objp)
148 {
149
150 if (!xdr_array(xdrs, (char **)&objp->pathname4_val,
151 (uint_t *)&objp->pathname4_len, NFS4_MAX_PATHNAME4,
152 sizeof (component4), (xdrproc_t)xdr_component4))
153 return (FALSE);
154 return (TRUE);
155 }
156
157 bool_t
xdr_nfs_lockid4(register XDR * xdrs,nfs_lockid4 * objp)158 xdr_nfs_lockid4(register XDR *xdrs, nfs_lockid4 *objp)
159 {
160
161 if (!xdr_uint64_t(xdrs, objp))
162 return (FALSE);
163 return (TRUE);
164 }
165
166 bool_t
xdr_nfs_cookie4(register XDR * xdrs,nfs_cookie4 * objp)167 xdr_nfs_cookie4(register XDR *xdrs, nfs_cookie4 *objp)
168 {
169
170 if (!xdr_uint64_t(xdrs, objp))
171 return (FALSE);
172 return (TRUE);
173 }
174
175 bool_t
xdr_linktext4(register XDR * xdrs,linktext4 * objp)176 xdr_linktext4(register XDR *xdrs, linktext4 *objp)
177 {
178
179 if (!xdr_utf8string(xdrs, objp))
180 return (FALSE);
181 return (TRUE);
182 }
183
184 bool_t
xdr_sec_oid4(register XDR * xdrs,sec_oid4 * objp)185 xdr_sec_oid4(register XDR *xdrs, sec_oid4 *objp)
186 {
187
188 if (!xdr_bytes(xdrs, (char **)&objp->sec_oid4_val,
189 (uint_t *)&objp->sec_oid4_len, NFS4_MAX_SECOID4))
190 return (FALSE);
191 return (TRUE);
192 }
193
194 bool_t
xdr_qop4(register XDR * xdrs,qop4 * objp)195 xdr_qop4(register XDR *xdrs, qop4 *objp)
196 {
197
198 if (!xdr_uint32_t(xdrs, objp))
199 return (FALSE);
200 return (TRUE);
201 }
202
203 bool_t
xdr_mode4(register XDR * xdrs,mode4 * objp)204 xdr_mode4(register XDR *xdrs, mode4 *objp)
205 {
206
207 if (!xdr_uint32_t(xdrs, objp))
208 return (FALSE);
209 return (TRUE);
210 }
211
212 bool_t
xdr_changeid4(register XDR * xdrs,changeid4 * objp)213 xdr_changeid4(register XDR *xdrs, changeid4 *objp)
214 {
215
216 if (!xdr_uint64_t(xdrs, objp))
217 return (FALSE);
218 return (TRUE);
219 }
220
221 bool_t
xdr_verifier4(register XDR * xdrs,verifier4 objp)222 xdr_verifier4(register XDR *xdrs, verifier4 objp)
223 {
224
225 if (!xdr_opaque(xdrs, objp, NFS4_VERIFIER_SIZE))
226 return (FALSE);
227 return (TRUE);
228 }
229
230 bool_t
xdr_nfstime4(register XDR * xdrs,nfstime4 * objp)231 xdr_nfstime4(register XDR *xdrs, nfstime4 *objp)
232 {
233
234 if (!xdr_int64_t(xdrs, &objp->seconds))
235 return (FALSE);
236 if (!xdr_uint32_t(xdrs, &objp->nseconds))
237 return (FALSE);
238 return (TRUE);
239 }
240
241 bool_t
xdr_time_how4(register XDR * xdrs,time_how4 * objp)242 xdr_time_how4(register XDR *xdrs, time_how4 *objp)
243 {
244
245 if (!xdr_enum(xdrs, (enum_t *)objp))
246 return (FALSE);
247 return (TRUE);
248 }
249
250 bool_t
xdr_settime4(register XDR * xdrs,settime4 * objp)251 xdr_settime4(register XDR *xdrs, settime4 *objp)
252 {
253
254 if (!xdr_time_how4(xdrs, &objp->set_it))
255 return (FALSE);
256 switch (objp->set_it) {
257 case SET_TO_CLIENT_TIME4:
258 if (!xdr_nfstime4(xdrs, &objp->settime4_u.time))
259 return (FALSE);
260 break;
261 }
262 return (TRUE);
263 }
264
265 bool_t
xdr_nfs_fh4(register XDR * xdrs,nfs_fh4 * objp)266 xdr_nfs_fh4(register XDR *xdrs, nfs_fh4 *objp)
267 {
268
269 if (!xdr_bytes(xdrs, (char **)&objp->nfs_fh4_val,
270 (uint_t *)&objp->nfs_fh4_len, NFS4_FHSIZE))
271 return (FALSE);
272 return (TRUE);
273 }
274
275 bool_t
xdr_fsid4(register XDR * xdrs,fsid4 * objp)276 xdr_fsid4(register XDR *xdrs, fsid4 *objp)
277 {
278
279 if (!xdr_uint64_t(xdrs, &objp->major))
280 return (FALSE);
281 if (!xdr_uint64_t(xdrs, &objp->minor))
282 return (FALSE);
283 return (TRUE);
284 }
285
286 bool_t
xdr_fs_location4(register XDR * xdrs,fs_location4 * objp)287 xdr_fs_location4(register XDR *xdrs, fs_location4 *objp)
288 {
289
290 if (!xdr_array(xdrs, (char **)&objp->server.server_val,
291 (uint_t *)&objp->server.server_len, ~0,
292 sizeof (utf8string), (xdrproc_t)xdr_utf8string))
293 return (FALSE);
294 if (!xdr_pathname4(xdrs, &objp->rootpath))
295 return (FALSE);
296 return (TRUE);
297 }
298
299 bool_t
xdr_fs_locations4(register XDR * xdrs,fs_locations4 * objp)300 xdr_fs_locations4(register XDR *xdrs, fs_locations4 *objp)
301 {
302
303 if (!xdr_pathname4(xdrs, &objp->fs_root))
304 return (FALSE);
305 if (!xdr_array(xdrs, (char **)&objp->locations.locations_val,
306 (uint_t *)&objp->locations.locations_len, ~0,
307 sizeof (fs_location4), (xdrproc_t)xdr_fs_location4))
308 return (FALSE);
309 return (TRUE);
310 }
311
312 bool_t
xdr_acetype4(register XDR * xdrs,acetype4 * objp)313 xdr_acetype4(register XDR *xdrs, acetype4 *objp)
314 {
315
316 if (!xdr_u_int(xdrs, objp))
317 return (FALSE);
318 return (TRUE);
319 }
320
321 bool_t
xdr_aceflag4(register XDR * xdrs,aceflag4 * objp)322 xdr_aceflag4(register XDR *xdrs, aceflag4 *objp)
323 {
324
325 if (!xdr_u_int(xdrs, objp))
326 return (FALSE);
327 return (TRUE);
328 }
329
330 bool_t
xdr_acemask4(register XDR * xdrs,acemask4 * objp)331 xdr_acemask4(register XDR *xdrs, acemask4 *objp)
332 {
333
334 if (!xdr_u_int(xdrs, objp))
335 return (FALSE);
336 return (TRUE);
337 }
338
339 bool_t
xdr_nfsace4(register XDR * xdrs,nfsace4 * objp)340 xdr_nfsace4(register XDR *xdrs, nfsace4 *objp)
341 {
342 if (!xdr_acetype4(xdrs, &objp->type))
343 return (FALSE);
344 if (!xdr_aceflag4(xdrs, &objp->flag))
345 return (FALSE);
346 if (!xdr_acemask4(xdrs, &objp->access_mask))
347 return (FALSE);
348 if (xdrs->x_op == XDR_DECODE) {
349 objp->who.utf8string_val = NULL;
350 objp->who.utf8string_len = 0;
351 }
352 return (xdr_bytes(xdrs, (char **)&objp->who.utf8string_val,
353 (uint_t *)&objp->who.utf8string_len,
354 NFS4_MAX_UTF8STRING));
355 }
356
357 bool_t
xdr_specdata4(register XDR * xdrs,specdata4 * objp)358 xdr_specdata4(register XDR *xdrs, specdata4 *objp)
359 {
360
361 if (!xdr_uint32_t(xdrs, &objp->specdata1))
362 return (FALSE);
363 if (!xdr_uint32_t(xdrs, &objp->specdata2))
364 return (FALSE);
365 return (TRUE);
366 }
367
368 bool_t
xdr_fattr4_supported_attrs(register XDR * xdrs,fattr4_supported_attrs * objp)369 xdr_fattr4_supported_attrs(register XDR *xdrs, fattr4_supported_attrs *objp)
370 {
371
372 if (!xdr_bitmap4(xdrs, objp))
373 return (FALSE);
374 return (TRUE);
375 }
376
377 bool_t
xdr_fattr4_type(register XDR * xdrs,fattr4_type * objp)378 xdr_fattr4_type(register XDR *xdrs, fattr4_type *objp)
379 {
380
381 if (!xdr_nfs_ftype4(xdrs, objp))
382 return (FALSE);
383 return (TRUE);
384 }
385
386 bool_t
xdr_fattr4_fh_expire_type(register XDR * xdrs,fattr4_fh_expire_type * objp)387 xdr_fattr4_fh_expire_type(register XDR *xdrs, fattr4_fh_expire_type *objp)
388 {
389
390 if (!xdr_uint32_t(xdrs, objp))
391 return (FALSE);
392 return (TRUE);
393 }
394
395 bool_t
xdr_fattr4_change(register XDR * xdrs,fattr4_change * objp)396 xdr_fattr4_change(register XDR *xdrs, fattr4_change *objp)
397 {
398
399 if (!xdr_changeid4(xdrs, objp))
400 return (FALSE);
401 return (TRUE);
402 }
403
404 bool_t
xdr_fattr4_size(register XDR * xdrs,fattr4_size * objp)405 xdr_fattr4_size(register XDR *xdrs, fattr4_size *objp)
406 {
407
408 if (!xdr_uint64_t(xdrs, objp))
409 return (FALSE);
410 return (TRUE);
411 }
412
413 bool_t
xdr_fattr4_link_support(register XDR * xdrs,fattr4_link_support * objp)414 xdr_fattr4_link_support(register XDR *xdrs, fattr4_link_support *objp)
415 {
416
417 if (!xdr_bool(xdrs, objp))
418 return (FALSE);
419 return (TRUE);
420 }
421
422 bool_t
xdr_fattr4_symlink_support(register XDR * xdrs,fattr4_symlink_support * objp)423 xdr_fattr4_symlink_support(register XDR *xdrs, fattr4_symlink_support *objp)
424 {
425
426 if (!xdr_bool(xdrs, objp))
427 return (FALSE);
428 return (TRUE);
429 }
430
431 bool_t
xdr_fattr4_named_attr(register XDR * xdrs,fattr4_named_attr * objp)432 xdr_fattr4_named_attr(register XDR *xdrs, fattr4_named_attr *objp)
433 {
434
435 if (!xdr_bool(xdrs, objp))
436 return (FALSE);
437 return (TRUE);
438 }
439
440 bool_t
xdr_fattr4_fsid(register XDR * xdrs,fattr4_fsid * objp)441 xdr_fattr4_fsid(register XDR *xdrs, fattr4_fsid *objp)
442 {
443
444 if (!xdr_fsid4(xdrs, objp))
445 return (FALSE);
446 return (TRUE);
447 }
448
449 bool_t
xdr_fattr4_unique_handles(register XDR * xdrs,fattr4_unique_handles * objp)450 xdr_fattr4_unique_handles(register XDR *xdrs, fattr4_unique_handles *objp)
451 {
452
453 if (!xdr_bool(xdrs, objp))
454 return (FALSE);
455 return (TRUE);
456 }
457
458 bool_t
xdr_fattr4_lease_time(register XDR * xdrs,fattr4_lease_time * objp)459 xdr_fattr4_lease_time(register XDR *xdrs, fattr4_lease_time *objp)
460 {
461
462 if (!xdr_uint32_t(xdrs, objp))
463 return (FALSE);
464 return (TRUE);
465 }
466
467 bool_t
xdr_fattr4_rdattr_error(register XDR * xdrs,fattr4_rdattr_error * objp)468 xdr_fattr4_rdattr_error(register XDR *xdrs, fattr4_rdattr_error *objp)
469 {
470
471 if (!xdr_nfsstat4(xdrs, objp))
472 return (FALSE);
473 return (TRUE);
474 }
475
476 bool_t
xdr_fattr4_acl(register XDR * xdrs,fattr4_acl * objp)477 xdr_fattr4_acl(register XDR *xdrs, fattr4_acl *objp)
478 {
479
480 if (!xdr_array(xdrs, (char **)&objp->fattr4_acl_val,
481 (uint_t *)&objp->fattr4_acl_len, ~0,
482 sizeof (nfsace4), (xdrproc_t)xdr_nfsace4))
483 return (FALSE);
484 return (TRUE);
485 }
486
487 bool_t
xdr_fattr4_aclsupport(register XDR * xdrs,fattr4_aclsupport * objp)488 xdr_fattr4_aclsupport(register XDR *xdrs, fattr4_aclsupport *objp)
489 {
490
491 if (!xdr_uint32_t(xdrs, objp))
492 return (FALSE);
493 return (TRUE);
494 }
495
496 bool_t
xdr_fattr4_archive(register XDR * xdrs,fattr4_archive * objp)497 xdr_fattr4_archive(register XDR *xdrs, fattr4_archive *objp)
498 {
499
500 if (!xdr_bool(xdrs, objp))
501 return (FALSE);
502 return (TRUE);
503 }
504
505 bool_t
xdr_fattr4_cansettime(register XDR * xdrs,fattr4_cansettime * objp)506 xdr_fattr4_cansettime(register XDR *xdrs, fattr4_cansettime *objp)
507 {
508
509 if (!xdr_bool(xdrs, objp))
510 return (FALSE);
511 return (TRUE);
512 }
513
514 bool_t
xdr_fattr4_case_insensitive(register XDR * xdrs,fattr4_case_insensitive * objp)515 xdr_fattr4_case_insensitive(register XDR *xdrs, fattr4_case_insensitive *objp)
516 {
517
518 if (!xdr_bool(xdrs, objp))
519 return (FALSE);
520 return (TRUE);
521 }
522
523 bool_t
xdr_fattr4_case_preserving(register XDR * xdrs,fattr4_case_preserving * objp)524 xdr_fattr4_case_preserving(register XDR *xdrs, fattr4_case_preserving *objp)
525 {
526
527 if (!xdr_bool(xdrs, objp))
528 return (FALSE);
529 return (TRUE);
530 }
531
532 bool_t
xdr_fattr4_chown_restricted(register XDR * xdrs,fattr4_chown_restricted * objp)533 xdr_fattr4_chown_restricted(register XDR *xdrs, fattr4_chown_restricted *objp)
534 {
535
536 if (!xdr_bool(xdrs, objp))
537 return (FALSE);
538 return (TRUE);
539 }
540
541 bool_t
xdr_fattr4_fileid(register XDR * xdrs,fattr4_fileid * objp)542 xdr_fattr4_fileid(register XDR *xdrs, fattr4_fileid *objp)
543 {
544
545 if (!xdr_uint64_t(xdrs, objp))
546 return (FALSE);
547 return (TRUE);
548 }
549
550 bool_t
xdr_fattr4_files_avail(register XDR * xdrs,fattr4_files_avail * objp)551 xdr_fattr4_files_avail(register XDR *xdrs, fattr4_files_avail *objp)
552 {
553
554 if (!xdr_uint64_t(xdrs, objp))
555 return (FALSE);
556 return (TRUE);
557 }
558
559 bool_t
xdr_fattr4_filehandle(register XDR * xdrs,fattr4_filehandle * objp)560 xdr_fattr4_filehandle(register XDR *xdrs, fattr4_filehandle *objp)
561 {
562
563 if (!xdr_nfs_fh4(xdrs, objp))
564 return (FALSE);
565 return (TRUE);
566 }
567
568 bool_t
xdr_fattr4_files_free(register XDR * xdrs,fattr4_files_free * objp)569 xdr_fattr4_files_free(register XDR *xdrs, fattr4_files_free *objp)
570 {
571
572 if (!xdr_uint64_t(xdrs, objp))
573 return (FALSE);
574 return (TRUE);
575 }
576
577 bool_t
xdr_fattr4_files_total(register XDR * xdrs,fattr4_files_total * objp)578 xdr_fattr4_files_total(register XDR *xdrs, fattr4_files_total *objp)
579 {
580
581 if (!xdr_uint64_t(xdrs, objp))
582 return (FALSE);
583 return (TRUE);
584 }
585
586 bool_t
xdr_fattr4_fs_locations(register XDR * xdrs,fattr4_fs_locations * objp)587 xdr_fattr4_fs_locations(register XDR *xdrs, fattr4_fs_locations *objp)
588 {
589
590 if (!xdr_fs_locations4(xdrs, objp))
591 return (FALSE);
592 return (TRUE);
593 }
594
595 bool_t
xdr_fattr4_hidden(register XDR * xdrs,fattr4_hidden * objp)596 xdr_fattr4_hidden(register XDR *xdrs, fattr4_hidden *objp)
597 {
598
599 if (!xdr_bool(xdrs, objp))
600 return (FALSE);
601 return (TRUE);
602 }
603
604 bool_t
xdr_fattr4_homogeneous(register XDR * xdrs,fattr4_homogeneous * objp)605 xdr_fattr4_homogeneous(register XDR *xdrs, fattr4_homogeneous *objp)
606 {
607
608 if (!xdr_bool(xdrs, objp))
609 return (FALSE);
610 return (TRUE);
611 }
612
613 bool_t
xdr_fattr4_maxfilesize(register XDR * xdrs,fattr4_maxfilesize * objp)614 xdr_fattr4_maxfilesize(register XDR *xdrs, fattr4_maxfilesize *objp)
615 {
616
617 if (!xdr_uint64_t(xdrs, objp))
618 return (FALSE);
619 return (TRUE);
620 }
621
622 bool_t
xdr_fattr4_maxlink(register XDR * xdrs,fattr4_maxlink * objp)623 xdr_fattr4_maxlink(register XDR *xdrs, fattr4_maxlink *objp)
624 {
625
626 if (!xdr_uint32_t(xdrs, objp))
627 return (FALSE);
628 return (TRUE);
629 }
630
631 bool_t
xdr_fattr4_maxname(register XDR * xdrs,fattr4_maxname * objp)632 xdr_fattr4_maxname(register XDR *xdrs, fattr4_maxname *objp)
633 {
634
635 if (!xdr_uint32_t(xdrs, objp))
636 return (FALSE);
637 return (TRUE);
638 }
639
640 bool_t
xdr_fattr4_maxread(register XDR * xdrs,fattr4_maxread * objp)641 xdr_fattr4_maxread(register XDR *xdrs, fattr4_maxread *objp)
642 {
643
644 if (!xdr_uint64_t(xdrs, objp))
645 return (FALSE);
646 return (TRUE);
647 }
648
649 bool_t
xdr_fattr4_maxwrite(register XDR * xdrs,fattr4_maxwrite * objp)650 xdr_fattr4_maxwrite(register XDR *xdrs, fattr4_maxwrite *objp)
651 {
652
653 if (!xdr_uint64_t(xdrs, objp))
654 return (FALSE);
655 return (TRUE);
656 }
657
658 bool_t
xdr_fattr4_mimetype(register XDR * xdrs,fattr4_mimetype * objp)659 xdr_fattr4_mimetype(register XDR *xdrs, fattr4_mimetype *objp)
660 {
661
662 if (!xdr_utf8string(xdrs, objp))
663 return (FALSE);
664 return (TRUE);
665 }
666
667 bool_t
xdr_fattr4_mode(register XDR * xdrs,fattr4_mode * objp)668 xdr_fattr4_mode(register XDR *xdrs, fattr4_mode *objp)
669 {
670
671 if (!xdr_mode4(xdrs, objp))
672 return (FALSE);
673 return (TRUE);
674 }
675
676 bool_t
xdr_fattr4_mounted_on_fileid(register XDR * xdrs,fattr4_mounted_on_fileid * objp)677 xdr_fattr4_mounted_on_fileid(register XDR *xdrs, fattr4_mounted_on_fileid *objp)
678 {
679
680 if (!xdr_uint64_t(xdrs, objp))
681 return (FALSE);
682 return (TRUE);
683 }
684
685 bool_t
xdr_fattr4_no_trunc(register XDR * xdrs,fattr4_no_trunc * objp)686 xdr_fattr4_no_trunc(register XDR *xdrs, fattr4_no_trunc *objp)
687 {
688
689 if (!xdr_bool(xdrs, objp))
690 return (FALSE);
691 return (TRUE);
692 }
693
694 bool_t
xdr_fattr4_numlinks(register XDR * xdrs,fattr4_numlinks * objp)695 xdr_fattr4_numlinks(register XDR *xdrs, fattr4_numlinks *objp)
696 {
697
698 if (!xdr_uint32_t(xdrs, objp))
699 return (FALSE);
700 return (TRUE);
701 }
702
703 bool_t
xdr_fattr4_owner(register XDR * xdrs,fattr4_owner * objp)704 xdr_fattr4_owner(register XDR *xdrs, fattr4_owner *objp)
705 {
706
707 if (!xdr_utf8string(xdrs, objp))
708 return (FALSE);
709 return (TRUE);
710 }
711
712 bool_t
xdr_fattr4_owner_group(register XDR * xdrs,fattr4_owner_group * objp)713 xdr_fattr4_owner_group(register XDR *xdrs, fattr4_owner_group *objp)
714 {
715
716 if (!xdr_utf8string(xdrs, objp))
717 return (FALSE);
718 return (TRUE);
719 }
720
721 bool_t
xdr_fattr4_quota_avail_hard(register XDR * xdrs,fattr4_quota_avail_hard * objp)722 xdr_fattr4_quota_avail_hard(register XDR *xdrs, fattr4_quota_avail_hard *objp)
723 {
724
725 if (!xdr_uint64_t(xdrs, objp))
726 return (FALSE);
727 return (TRUE);
728 }
729
730 bool_t
xdr_fattr4_quota_avail_soft(register XDR * xdrs,fattr4_quota_avail_soft * objp)731 xdr_fattr4_quota_avail_soft(register XDR *xdrs, fattr4_quota_avail_soft *objp)
732 {
733
734 if (!xdr_uint64_t(xdrs, objp))
735 return (FALSE);
736 return (TRUE);
737 }
738
739 bool_t
xdr_fattr4_quota_used(register XDR * xdrs,fattr4_quota_used * objp)740 xdr_fattr4_quota_used(register XDR *xdrs, fattr4_quota_used *objp)
741 {
742
743 if (!xdr_uint64_t(xdrs, objp))
744 return (FALSE);
745 return (TRUE);
746 }
747
748 bool_t
xdr_fattr4_rawdev(register XDR * xdrs,fattr4_rawdev * objp)749 xdr_fattr4_rawdev(register XDR *xdrs, fattr4_rawdev *objp)
750 {
751
752 if (!xdr_specdata4(xdrs, objp))
753 return (FALSE);
754 return (TRUE);
755 }
756
757 bool_t
xdr_fattr4_space_avail(register XDR * xdrs,fattr4_space_avail * objp)758 xdr_fattr4_space_avail(register XDR *xdrs, fattr4_space_avail *objp)
759 {
760
761 if (!xdr_uint64_t(xdrs, objp))
762 return (FALSE);
763 return (TRUE);
764 }
765
766 bool_t
xdr_fattr4_space_free(register XDR * xdrs,fattr4_space_free * objp)767 xdr_fattr4_space_free(register XDR *xdrs, fattr4_space_free *objp)
768 {
769
770 if (!xdr_uint64_t(xdrs, objp))
771 return (FALSE);
772 return (TRUE);
773 }
774
775 bool_t
xdr_fattr4_space_total(register XDR * xdrs,fattr4_space_total * objp)776 xdr_fattr4_space_total(register XDR *xdrs, fattr4_space_total *objp)
777 {
778
779 if (!xdr_uint64_t(xdrs, objp))
780 return (FALSE);
781 return (TRUE);
782 }
783
784 bool_t
xdr_fattr4_space_used(register XDR * xdrs,fattr4_space_used * objp)785 xdr_fattr4_space_used(register XDR *xdrs, fattr4_space_used *objp)
786 {
787
788 if (!xdr_uint64_t(xdrs, objp))
789 return (FALSE);
790 return (TRUE);
791 }
792
793 bool_t
xdr_fattr4_system(register XDR * xdrs,fattr4_system * objp)794 xdr_fattr4_system(register XDR *xdrs, fattr4_system *objp)
795 {
796
797 if (!xdr_bool(xdrs, objp))
798 return (FALSE);
799 return (TRUE);
800 }
801
802 bool_t
xdr_fattr4_time_access(register XDR * xdrs,fattr4_time_access * objp)803 xdr_fattr4_time_access(register XDR *xdrs, fattr4_time_access *objp)
804 {
805
806 if (!xdr_nfstime4(xdrs, objp))
807 return (FALSE);
808 return (TRUE);
809 }
810
811 bool_t
xdr_fattr4_time_access_set(register XDR * xdrs,fattr4_time_access_set * objp)812 xdr_fattr4_time_access_set(register XDR *xdrs, fattr4_time_access_set *objp)
813 {
814
815 if (!xdr_settime4(xdrs, objp))
816 return (FALSE);
817 return (TRUE);
818 }
819
820 bool_t
xdr_fattr4_time_backup(register XDR * xdrs,fattr4_time_backup * objp)821 xdr_fattr4_time_backup(register XDR *xdrs, fattr4_time_backup *objp)
822 {
823
824 if (!xdr_nfstime4(xdrs, objp))
825 return (FALSE);
826 return (TRUE);
827 }
828
829 bool_t
xdr_fattr4_time_create(register XDR * xdrs,fattr4_time_create * objp)830 xdr_fattr4_time_create(register XDR *xdrs, fattr4_time_create *objp)
831 {
832
833 if (!xdr_nfstime4(xdrs, objp))
834 return (FALSE);
835 return (TRUE);
836 }
837
838 bool_t
xdr_fattr4_time_delta(register XDR * xdrs,fattr4_time_delta * objp)839 xdr_fattr4_time_delta(register XDR *xdrs, fattr4_time_delta *objp)
840 {
841
842 if (!xdr_nfstime4(xdrs, objp))
843 return (FALSE);
844 return (TRUE);
845 }
846
847 bool_t
xdr_fattr4_time_metadata(register XDR * xdrs,fattr4_time_metadata * objp)848 xdr_fattr4_time_metadata(register XDR *xdrs, fattr4_time_metadata *objp)
849 {
850
851 if (!xdr_nfstime4(xdrs, objp))
852 return (FALSE);
853 return (TRUE);
854 }
855
856 bool_t
xdr_fattr4_time_modify(register XDR * xdrs,fattr4_time_modify * objp)857 xdr_fattr4_time_modify(register XDR *xdrs, fattr4_time_modify *objp)
858 {
859
860 if (!xdr_nfstime4(xdrs, objp))
861 return (FALSE);
862 return (TRUE);
863 }
864
865 bool_t
xdr_fattr4_time_modify_set(register XDR * xdrs,fattr4_time_modify_set * objp)866 xdr_fattr4_time_modify_set(register XDR *xdrs, fattr4_time_modify_set *objp)
867 {
868
869 if (!xdr_settime4(xdrs, objp))
870 return (FALSE);
871 return (TRUE);
872 }
873
874 bool_t
xdr_attrlist4(register XDR * xdrs,attrlist4 * objp)875 xdr_attrlist4(register XDR *xdrs, attrlist4 *objp)
876 {
877
878 if (!xdr_bytes(xdrs, (char **)&objp->attrlist4_val,
879 (uint_t *)&objp->attrlist4_len, ~0))
880 return (FALSE);
881 return (TRUE);
882 }
883
884 bool_t
xdr_fattr4(register XDR * xdrs,fattr4 * objp)885 xdr_fattr4(register XDR *xdrs, fattr4 *objp)
886 {
887
888 if (!xdr_bitmap4(xdrs, &objp->attrmask))
889 return (FALSE);
890 if (!xdr_attrlist4(xdrs, &objp->attr_vals))
891 return (FALSE);
892 return (TRUE);
893 }
894
895 bool_t
xdr_change_info4(register XDR * xdrs,change_info4 * objp)896 xdr_change_info4(register XDR *xdrs, change_info4 *objp)
897 {
898
899 if (!xdr_bool(xdrs, &objp->atomic))
900 return (FALSE);
901 if (!xdr_changeid4(xdrs, &objp->before))
902 return (FALSE);
903 if (!xdr_changeid4(xdrs, &objp->after))
904 return (FALSE);
905 return (TRUE);
906 }
907
908 bool_t
xdr_clientaddr4(register XDR * xdrs,clientaddr4 * objp)909 xdr_clientaddr4(register XDR *xdrs, clientaddr4 *objp)
910 {
911
912 if (!xdr_string(xdrs, &objp->r_netid, ~0))
913 return (FALSE);
914 if (!xdr_string(xdrs, &objp->r_addr, ~0))
915 return (FALSE);
916 return (TRUE);
917 }
918
919 bool_t
xdr_cb_client4(register XDR * xdrs,cb_client4 * objp)920 xdr_cb_client4(register XDR *xdrs, cb_client4 *objp)
921 {
922
923 if (!xdr_uint32_t(xdrs, &objp->cb_program))
924 return (FALSE);
925 if (!xdr_clientaddr4(xdrs, &objp->cb_location))
926 return (FALSE);
927 return (TRUE);
928 }
929
930 bool_t
xdr_stateid4(register XDR * xdrs,stateid4 * objp)931 xdr_stateid4(register XDR *xdrs, stateid4 *objp)
932 {
933
934 if (!xdr_uint32_t(xdrs, &objp->seqid))
935 return (FALSE);
936 if (!xdr_opaque(xdrs, objp->other, 12))
937 return (FALSE);
938 return (TRUE);
939 }
940
941 bool_t
xdr_nfs_client_id4(register XDR * xdrs,nfs_client_id4 * objp)942 xdr_nfs_client_id4(register XDR *xdrs, nfs_client_id4 *objp)
943 {
944
945 if (!xdr_verifier4(xdrs, objp->verifier))
946 return (FALSE);
947 if (!xdr_bytes(xdrs, (char **)&objp->id.id_val,
948 (uint_t *)&objp->id.id_len, NFS4_OPAQUE_LIMIT))
949 return (FALSE);
950 return (TRUE);
951 }
952
953 bool_t
xdr_open_owner4(register XDR * xdrs,open_owner4 * objp)954 xdr_open_owner4(register XDR *xdrs, open_owner4 *objp)
955 {
956
957 if (!xdr_clientid4(xdrs, &objp->clientid))
958 return (FALSE);
959 if (!xdr_bytes(xdrs, (char **)&objp->owner.owner_val,
960 (uint_t *)&objp->owner.owner_len, NFS4_OPAQUE_LIMIT))
961 return (FALSE);
962 return (TRUE);
963 }
964
965 bool_t
xdr_lock_owner4(register XDR * xdrs,lock_owner4 * objp)966 xdr_lock_owner4(register XDR *xdrs, lock_owner4 *objp)
967 {
968
969 if (!xdr_clientid4(xdrs, &objp->clientid))
970 return (FALSE);
971 if (!xdr_bytes(xdrs, (char **)&objp->owner.owner_val,
972 (uint_t *)&objp->owner.owner_len, NFS4_OPAQUE_LIMIT))
973 return (FALSE);
974 return (TRUE);
975 }
976
977 bool_t
xdr_nfs_lock_type4(register XDR * xdrs,nfs_lock_type4 * objp)978 xdr_nfs_lock_type4(register XDR *xdrs, nfs_lock_type4 *objp)
979 {
980
981 if (!xdr_enum(xdrs, (enum_t *)objp))
982 return (FALSE);
983 return (TRUE);
984 }
985
986 bool_t
xdr_ACCESS4args(register XDR * xdrs,ACCESS4args * objp)987 xdr_ACCESS4args(register XDR *xdrs, ACCESS4args *objp)
988 {
989
990 if (!xdr_uint32_t(xdrs, &objp->access))
991 return (FALSE);
992 return (TRUE);
993 }
994
995 bool_t
xdr_ACCESS4resok(register XDR * xdrs,ACCESS4resok * objp)996 xdr_ACCESS4resok(register XDR *xdrs, ACCESS4resok *objp)
997 {
998
999 if (!xdr_uint32_t(xdrs, &objp->supported))
1000 return (FALSE);
1001 if (!xdr_uint32_t(xdrs, &objp->access))
1002 return (FALSE);
1003 return (TRUE);
1004 }
1005
1006 bool_t
xdr_ACCESS4res(register XDR * xdrs,ACCESS4res * objp)1007 xdr_ACCESS4res(register XDR *xdrs, ACCESS4res *objp)
1008 {
1009
1010 if (!xdr_nfsstat4(xdrs, &objp->status))
1011 return (FALSE);
1012 switch (objp->status) {
1013 case NFS4_OK:
1014 if (!xdr_ACCESS4resok(xdrs, &objp->ACCESS4res_u.resok4))
1015 return (FALSE);
1016 break;
1017 }
1018 return (TRUE);
1019 }
1020
1021 bool_t
xdr_CLOSE4args(register XDR * xdrs,CLOSE4args * objp)1022 xdr_CLOSE4args(register XDR *xdrs, CLOSE4args *objp)
1023 {
1024
1025 if (!xdr_seqid4(xdrs, &objp->seqid))
1026 return (FALSE);
1027 if (!xdr_stateid4(xdrs, &objp->open_stateid))
1028 return (FALSE);
1029 return (TRUE);
1030 }
1031
1032 bool_t
xdr_CLOSE4res(register XDR * xdrs,CLOSE4res * objp)1033 xdr_CLOSE4res(register XDR *xdrs, CLOSE4res *objp)
1034 {
1035
1036 if (!xdr_nfsstat4(xdrs, &objp->status))
1037 return (FALSE);
1038 switch (objp->status) {
1039 case NFS4_OK:
1040 if (!xdr_stateid4(xdrs, &objp->CLOSE4res_u.open_stateid))
1041 return (FALSE);
1042 break;
1043 }
1044 return (TRUE);
1045 }
1046
1047 bool_t
xdr_COMMIT4args(register XDR * xdrs,COMMIT4args * objp)1048 xdr_COMMIT4args(register XDR *xdrs, COMMIT4args *objp)
1049 {
1050
1051 if (!xdr_offset4(xdrs, &objp->offset))
1052 return (FALSE);
1053 if (!xdr_count4(xdrs, &objp->count))
1054 return (FALSE);
1055 return (TRUE);
1056 }
1057
1058 bool_t
xdr_COMMIT4resok(register XDR * xdrs,COMMIT4resok * objp)1059 xdr_COMMIT4resok(register XDR *xdrs, COMMIT4resok *objp)
1060 {
1061
1062 if (!xdr_verifier4(xdrs, objp->writeverf))
1063 return (FALSE);
1064 return (TRUE);
1065 }
1066
1067 bool_t
xdr_COMMIT4res(register XDR * xdrs,COMMIT4res * objp)1068 xdr_COMMIT4res(register XDR *xdrs, COMMIT4res *objp)
1069 {
1070
1071 if (!xdr_nfsstat4(xdrs, &objp->status))
1072 return (FALSE);
1073 switch (objp->status) {
1074 case NFS4_OK:
1075 if (!xdr_COMMIT4resok(xdrs, &objp->COMMIT4res_u.resok4))
1076 return (FALSE);
1077 break;
1078 }
1079 return (TRUE);
1080 }
1081
1082 bool_t
xdr_createtype4(register XDR * xdrs,createtype4 * objp)1083 xdr_createtype4(register XDR *xdrs, createtype4 *objp)
1084 {
1085
1086 if (!xdr_nfs_ftype4(xdrs, &objp->type))
1087 return (FALSE);
1088 switch (objp->type) {
1089 case NF4LNK:
1090 if (!xdr_linktext4(xdrs, &objp->createtype4_u.linkdata))
1091 return (FALSE);
1092 break;
1093 case NF4BLK:
1094 case NF4CHR:
1095 if (!xdr_specdata4(xdrs, &objp->createtype4_u.devdata))
1096 return (FALSE);
1097 break;
1098 case NF4SOCK:
1099 case NF4FIFO:
1100 case NF4DIR:
1101 break;
1102 }
1103 return (TRUE);
1104 }
1105
1106 bool_t
xdr_CREATE4args(register XDR * xdrs,CREATE4args * objp)1107 xdr_CREATE4args(register XDR *xdrs, CREATE4args *objp)
1108 {
1109
1110 if (!xdr_createtype4(xdrs, &objp->objtype))
1111 return (FALSE);
1112 if (!xdr_component4(xdrs, &objp->objname))
1113 return (FALSE);
1114 if (!xdr_fattr4(xdrs, &objp->createattrs))
1115 return (FALSE);
1116 return (TRUE);
1117 }
1118
1119 bool_t
xdr_CREATE4resok(register XDR * xdrs,CREATE4resok * objp)1120 xdr_CREATE4resok(register XDR *xdrs, CREATE4resok *objp)
1121 {
1122
1123 if (!xdr_change_info4(xdrs, &objp->cinfo))
1124 return (FALSE);
1125 if (!xdr_bitmap4(xdrs, &objp->attrset))
1126 return (FALSE);
1127 return (TRUE);
1128 }
1129
1130 bool_t
xdr_CREATE4res(register XDR * xdrs,CREATE4res * objp)1131 xdr_CREATE4res(register XDR *xdrs, CREATE4res *objp)
1132 {
1133
1134 if (!xdr_nfsstat4(xdrs, &objp->status))
1135 return (FALSE);
1136 switch (objp->status) {
1137 case NFS4_OK:
1138 if (!xdr_CREATE4resok(xdrs, &objp->CREATE4res_u.resok4))
1139 return (FALSE);
1140 break;
1141 }
1142 return (TRUE);
1143 }
1144
1145 bool_t
xdr_DELEGPURGE4args(register XDR * xdrs,DELEGPURGE4args * objp)1146 xdr_DELEGPURGE4args(register XDR *xdrs, DELEGPURGE4args *objp)
1147 {
1148
1149 if (!xdr_clientid4(xdrs, &objp->clientid))
1150 return (FALSE);
1151 return (TRUE);
1152 }
1153
1154 bool_t
xdr_DELEGPURGE4res(register XDR * xdrs,DELEGPURGE4res * objp)1155 xdr_DELEGPURGE4res(register XDR *xdrs, DELEGPURGE4res *objp)
1156 {
1157
1158 if (!xdr_nfsstat4(xdrs, &objp->status))
1159 return (FALSE);
1160 return (TRUE);
1161 }
1162
1163 bool_t
xdr_DELEGRETURN4args(register XDR * xdrs,DELEGRETURN4args * objp)1164 xdr_DELEGRETURN4args(register XDR *xdrs, DELEGRETURN4args *objp)
1165 {
1166
1167 if (!xdr_stateid4(xdrs, &objp->deleg_stateid))
1168 return (FALSE);
1169 return (TRUE);
1170 }
1171
1172 bool_t
xdr_DELEGRETURN4res(register XDR * xdrs,DELEGRETURN4res * objp)1173 xdr_DELEGRETURN4res(register XDR *xdrs, DELEGRETURN4res *objp)
1174 {
1175
1176 if (!xdr_nfsstat4(xdrs, &objp->status))
1177 return (FALSE);
1178 return (TRUE);
1179 }
1180
1181 bool_t
xdr_GETATTR4args(register XDR * xdrs,GETATTR4args * objp)1182 xdr_GETATTR4args(register XDR *xdrs, GETATTR4args *objp)
1183 {
1184
1185 if (!xdr_bitmap4(xdrs, &objp->attr_request))
1186 return (FALSE);
1187 return (TRUE);
1188 }
1189
1190 bool_t
xdr_GETATTR4resok(register XDR * xdrs,GETATTR4resok * objp)1191 xdr_GETATTR4resok(register XDR *xdrs, GETATTR4resok *objp)
1192 {
1193
1194 if (!xdr_fattr4(xdrs, &objp->obj_attributes))
1195 return (FALSE);
1196 return (TRUE);
1197 }
1198
1199 bool_t
xdr_GETATTR4res(register XDR * xdrs,GETATTR4res * objp)1200 xdr_GETATTR4res(register XDR *xdrs, GETATTR4res *objp)
1201 {
1202
1203 if (!xdr_nfsstat4(xdrs, &objp->status))
1204 return (FALSE);
1205 switch (objp->status) {
1206 case NFS4_OK:
1207 if (!xdr_GETATTR4resok(xdrs, &objp->GETATTR4res_u.resok4))
1208 return (FALSE);
1209 break;
1210 }
1211 return (TRUE);
1212 }
1213
1214 bool_t
xdr_GETFH4resok(register XDR * xdrs,GETFH4resok * objp)1215 xdr_GETFH4resok(register XDR *xdrs, GETFH4resok *objp)
1216 {
1217
1218 if (!xdr_nfs_fh4(xdrs, &objp->object))
1219 return (FALSE);
1220 return (TRUE);
1221 }
1222
1223 bool_t
xdr_GETFH4res(register XDR * xdrs,GETFH4res * objp)1224 xdr_GETFH4res(register XDR *xdrs, GETFH4res *objp)
1225 {
1226
1227 if (!xdr_nfsstat4(xdrs, &objp->status))
1228 return (FALSE);
1229 switch (objp->status) {
1230 case NFS4_OK:
1231 if (!xdr_GETFH4resok(xdrs, &objp->GETFH4res_u.resok4))
1232 return (FALSE);
1233 break;
1234 }
1235 return (TRUE);
1236 }
1237
1238 bool_t
xdr_LINK4args(register XDR * xdrs,LINK4args * objp)1239 xdr_LINK4args(register XDR *xdrs, LINK4args *objp)
1240 {
1241
1242 if (!xdr_component4(xdrs, &objp->newname))
1243 return (FALSE);
1244 return (TRUE);
1245 }
1246
1247 bool_t
xdr_LINK4resok(register XDR * xdrs,LINK4resok * objp)1248 xdr_LINK4resok(register XDR *xdrs, LINK4resok *objp)
1249 {
1250
1251 if (!xdr_change_info4(xdrs, &objp->cinfo))
1252 return (FALSE);
1253 return (TRUE);
1254 }
1255
1256 bool_t
xdr_LINK4res(register XDR * xdrs,LINK4res * objp)1257 xdr_LINK4res(register XDR *xdrs, LINK4res *objp)
1258 {
1259
1260 if (!xdr_nfsstat4(xdrs, &objp->status))
1261 return (FALSE);
1262 switch (objp->status) {
1263 case NFS4_OK:
1264 if (!xdr_LINK4resok(xdrs, &objp->LINK4res_u.resok4))
1265 return (FALSE);
1266 break;
1267 }
1268 return (TRUE);
1269 }
1270
1271 bool_t
xdr_open_to_lock_owner4(register XDR * xdrs,open_to_lock_owner4 * objp)1272 xdr_open_to_lock_owner4(register XDR *xdrs, open_to_lock_owner4 *objp)
1273 {
1274
1275 if (!xdr_seqid4(xdrs, &objp->open_seqid))
1276 return (FALSE);
1277 if (!xdr_stateid4(xdrs, &objp->open_stateid))
1278 return (FALSE);
1279 if (!xdr_seqid4(xdrs, &objp->lock_seqid))
1280 return (FALSE);
1281 if (!xdr_lock_owner4(xdrs, &objp->lock_owner))
1282 return (FALSE);
1283 return (TRUE);
1284 }
1285
1286 bool_t
xdr_exist_lock_owner4(register XDR * xdrs,exist_lock_owner4 * objp)1287 xdr_exist_lock_owner4(register XDR *xdrs, exist_lock_owner4 *objp)
1288 {
1289
1290 if (!xdr_stateid4(xdrs, &objp->lock_stateid))
1291 return (FALSE);
1292 if (!xdr_seqid4(xdrs, &objp->lock_seqid))
1293 return (FALSE);
1294 return (TRUE);
1295 }
1296
1297 bool_t
xdr_locker4(register XDR * xdrs,locker4 * objp)1298 xdr_locker4(register XDR *xdrs, locker4 *objp)
1299 {
1300
1301 if (!xdr_bool(xdrs, &objp->new_lock_owner))
1302 return (FALSE);
1303 switch (objp->new_lock_owner) {
1304 case TRUE:
1305 if (!xdr_open_to_lock_owner4(xdrs, &objp->locker4_u.open_owner))
1306 return (FALSE);
1307 break;
1308 case FALSE:
1309 if (!xdr_exist_lock_owner4(xdrs, &objp->locker4_u.lock_owner))
1310 return (FALSE);
1311 break;
1312 default:
1313 return (FALSE);
1314 }
1315 return (TRUE);
1316 }
1317
1318 bool_t
xdr_LOCK4args(register XDR * xdrs,LOCK4args * objp)1319 xdr_LOCK4args(register XDR *xdrs, LOCK4args *objp)
1320 {
1321
1322 if (!xdr_nfs_lock_type4(xdrs, &objp->locktype))
1323 return (FALSE);
1324 if (!xdr_bool(xdrs, &objp->reclaim))
1325 return (FALSE);
1326 if (!xdr_offset4(xdrs, &objp->offset))
1327 return (FALSE);
1328 if (!xdr_length4(xdrs, &objp->length))
1329 return (FALSE);
1330 if (!xdr_locker4(xdrs, &objp->locker))
1331 return (FALSE);
1332 return (TRUE);
1333 }
1334
1335 bool_t
xdr_LOCK4denied(register XDR * xdrs,LOCK4denied * objp)1336 xdr_LOCK4denied(register XDR *xdrs, LOCK4denied *objp)
1337 {
1338
1339 if (!xdr_offset4(xdrs, &objp->offset))
1340 return (FALSE);
1341 if (!xdr_length4(xdrs, &objp->length))
1342 return (FALSE);
1343 if (!xdr_nfs_lock_type4(xdrs, &objp->locktype))
1344 return (FALSE);
1345 if (!xdr_lock_owner4(xdrs, &objp->owner))
1346 return (FALSE);
1347 return (TRUE);
1348 }
1349
1350 bool_t
xdr_LOCK4resok(register XDR * xdrs,LOCK4resok * objp)1351 xdr_LOCK4resok(register XDR *xdrs, LOCK4resok *objp)
1352 {
1353
1354 if (!xdr_stateid4(xdrs, &objp->lock_stateid))
1355 return (FALSE);
1356 return (TRUE);
1357 }
1358
1359 bool_t
xdr_LOCK4res(register XDR * xdrs,LOCK4res * objp)1360 xdr_LOCK4res(register XDR *xdrs, LOCK4res *objp)
1361 {
1362
1363 if (!xdr_nfsstat4(xdrs, &objp->status))
1364 return (FALSE);
1365 switch (objp->status) {
1366 case NFS4_OK:
1367 if (!xdr_LOCK4resok(xdrs, &objp->LOCK4res_u.resok4))
1368 return (FALSE);
1369 break;
1370 case NFS4ERR_DENIED:
1371 if (!xdr_LOCK4denied(xdrs, &objp->LOCK4res_u.denied))
1372 return (FALSE);
1373 break;
1374 }
1375 return (TRUE);
1376 }
1377
1378 bool_t
xdr_LOCKT4args(register XDR * xdrs,LOCKT4args * objp)1379 xdr_LOCKT4args(register XDR *xdrs, LOCKT4args *objp)
1380 {
1381
1382 if (!xdr_nfs_lock_type4(xdrs, &objp->locktype))
1383 return (FALSE);
1384 if (!xdr_offset4(xdrs, &objp->offset))
1385 return (FALSE);
1386 if (!xdr_length4(xdrs, &objp->length))
1387 return (FALSE);
1388 if (!xdr_lock_owner4(xdrs, &objp->owner))
1389 return (FALSE);
1390 return (TRUE);
1391 }
1392
1393 bool_t
xdr_LOCKT4res(register XDR * xdrs,LOCKT4res * objp)1394 xdr_LOCKT4res(register XDR *xdrs, LOCKT4res *objp)
1395 {
1396
1397 if (!xdr_nfsstat4(xdrs, &objp->status))
1398 return (FALSE);
1399 switch (objp->status) {
1400 case NFS4ERR_DENIED:
1401 if (!xdr_LOCK4denied(xdrs, &objp->LOCKT4res_u.denied))
1402 return (FALSE);
1403 break;
1404 case NFS4_OK:
1405 break;
1406 }
1407 return (TRUE);
1408 }
1409
1410 bool_t
xdr_LOCKU4args(register XDR * xdrs,LOCKU4args * objp)1411 xdr_LOCKU4args(register XDR *xdrs, LOCKU4args *objp)
1412 {
1413
1414 if (!xdr_nfs_lock_type4(xdrs, &objp->locktype))
1415 return (FALSE);
1416 if (!xdr_seqid4(xdrs, &objp->seqid))
1417 return (FALSE);
1418 if (!xdr_stateid4(xdrs, &objp->lock_stateid))
1419 return (FALSE);
1420 if (!xdr_offset4(xdrs, &objp->offset))
1421 return (FALSE);
1422 if (!xdr_length4(xdrs, &objp->length))
1423 return (FALSE);
1424 return (TRUE);
1425 }
1426
1427 bool_t
xdr_LOCKU4res(register XDR * xdrs,LOCKU4res * objp)1428 xdr_LOCKU4res(register XDR *xdrs, LOCKU4res *objp)
1429 {
1430
1431 if (!xdr_nfsstat4(xdrs, &objp->status))
1432 return (FALSE);
1433 switch (objp->status) {
1434 case NFS4_OK:
1435 if (!xdr_stateid4(xdrs, &objp->LOCKU4res_u.lock_stateid))
1436 return (FALSE);
1437 break;
1438 }
1439 return (TRUE);
1440 }
1441
1442 bool_t
xdr_LOOKUP4args(register XDR * xdrs,LOOKUP4args * objp)1443 xdr_LOOKUP4args(register XDR *xdrs, LOOKUP4args *objp)
1444 {
1445
1446 if (!xdr_component4(xdrs, &objp->objname))
1447 return (FALSE);
1448 return (TRUE);
1449 }
1450
1451 bool_t
xdr_LOOKUP4res(register XDR * xdrs,LOOKUP4res * objp)1452 xdr_LOOKUP4res(register XDR *xdrs, LOOKUP4res *objp)
1453 {
1454
1455 if (!xdr_nfsstat4(xdrs, &objp->status))
1456 return (FALSE);
1457 return (TRUE);
1458 }
1459
1460 bool_t
xdr_LOOKUPP4res(register XDR * xdrs,LOOKUPP4res * objp)1461 xdr_LOOKUPP4res(register XDR *xdrs, LOOKUPP4res *objp)
1462 {
1463
1464 if (!xdr_nfsstat4(xdrs, &objp->status))
1465 return (FALSE);
1466 return (TRUE);
1467 }
1468
1469 bool_t
xdr_NVERIFY4args(register XDR * xdrs,NVERIFY4args * objp)1470 xdr_NVERIFY4args(register XDR *xdrs, NVERIFY4args *objp)
1471 {
1472
1473 if (!xdr_fattr4(xdrs, &objp->obj_attributes))
1474 return (FALSE);
1475 return (TRUE);
1476 }
1477
1478 bool_t
xdr_NVERIFY4res(register XDR * xdrs,NVERIFY4res * objp)1479 xdr_NVERIFY4res(register XDR *xdrs, NVERIFY4res *objp)
1480 {
1481
1482 if (!xdr_nfsstat4(xdrs, &objp->status))
1483 return (FALSE);
1484 return (TRUE);
1485 }
1486
1487 bool_t
xdr_createmode4(register XDR * xdrs,createmode4 * objp)1488 xdr_createmode4(register XDR *xdrs, createmode4 *objp)
1489 {
1490
1491 if (!xdr_enum(xdrs, (enum_t *)objp))
1492 return (FALSE);
1493 return (TRUE);
1494 }
1495
1496 bool_t
xdr_createhow4(register XDR * xdrs,createhow4 * objp)1497 xdr_createhow4(register XDR *xdrs, createhow4 *objp)
1498 {
1499
1500 if (!xdr_createmode4(xdrs, &objp->mode))
1501 return (FALSE);
1502 switch (objp->mode) {
1503 case UNCHECKED4:
1504 case GUARDED4:
1505 if (!xdr_fattr4(xdrs, &objp->createhow4_u.createattrs))
1506 return (FALSE);
1507 break;
1508 case EXCLUSIVE4:
1509 if (!xdr_verifier4(xdrs, objp->createhow4_u.createverf))
1510 return (FALSE);
1511 break;
1512 default:
1513 return (FALSE);
1514 }
1515 return (TRUE);
1516 }
1517
1518 bool_t
xdr_opentype4(register XDR * xdrs,opentype4 * objp)1519 xdr_opentype4(register XDR *xdrs, opentype4 *objp)
1520 {
1521
1522 if (!xdr_enum(xdrs, (enum_t *)objp))
1523 return (FALSE);
1524 return (TRUE);
1525 }
1526
1527 bool_t
xdr_openflag4(register XDR * xdrs,openflag4 * objp)1528 xdr_openflag4(register XDR *xdrs, openflag4 *objp)
1529 {
1530
1531 if (!xdr_opentype4(xdrs, &objp->opentype))
1532 return (FALSE);
1533 switch (objp->opentype) {
1534 case OPEN4_CREATE:
1535 if (!xdr_createhow4(xdrs, &objp->openflag4_u.how))
1536 return (FALSE);
1537 break;
1538 }
1539 return (TRUE);
1540 }
1541
1542 bool_t
xdr_limit_by4(register XDR * xdrs,limit_by4 * objp)1543 xdr_limit_by4(register XDR *xdrs, limit_by4 *objp)
1544 {
1545
1546 if (!xdr_enum(xdrs, (enum_t *)objp))
1547 return (FALSE);
1548 return (TRUE);
1549 }
1550
1551 bool_t
xdr_nfs_modified_limit4(register XDR * xdrs,nfs_modified_limit4 * objp)1552 xdr_nfs_modified_limit4(register XDR *xdrs, nfs_modified_limit4 *objp)
1553 {
1554
1555 if (!xdr_uint32_t(xdrs, &objp->num_blocks))
1556 return (FALSE);
1557 if (!xdr_uint32_t(xdrs, &objp->bytes_per_block))
1558 return (FALSE);
1559 return (TRUE);
1560 }
1561
1562 bool_t
xdr_nfs_space_limit4(register XDR * xdrs,nfs_space_limit4 * objp)1563 xdr_nfs_space_limit4(register XDR *xdrs, nfs_space_limit4 *objp)
1564 {
1565
1566 if (!xdr_limit_by4(xdrs, &objp->limitby))
1567 return (FALSE);
1568 switch (objp->limitby) {
1569 case NFS_LIMIT_SIZE:
1570 if (!xdr_uint64_t(xdrs, &objp->nfs_space_limit4_u.filesize))
1571 return (FALSE);
1572 break;
1573 case NFS_LIMIT_BLOCKS:
1574 if (!xdr_nfs_modified_limit4(xdrs, &objp->nfs_space_limit4_u.
1575 mod_blocks))
1576 return (FALSE);
1577 break;
1578 default:
1579 return (FALSE);
1580 }
1581 return (TRUE);
1582 }
1583
1584 bool_t
xdr_open_delegation_type4(register XDR * xdrs,open_delegation_type4 * objp)1585 xdr_open_delegation_type4(register XDR *xdrs, open_delegation_type4 *objp)
1586 {
1587
1588 if (!xdr_enum(xdrs, (enum_t *)objp))
1589 return (FALSE);
1590 return (TRUE);
1591 }
1592
1593 bool_t
xdr_open_claim_type4(register XDR * xdrs,open_claim_type4 * objp)1594 xdr_open_claim_type4(register XDR *xdrs, open_claim_type4 *objp)
1595 {
1596
1597 if (!xdr_enum(xdrs, (enum_t *)objp))
1598 return (FALSE);
1599 return (TRUE);
1600 }
1601
1602 bool_t
xdr_open_claim_delegate_cur4(register XDR * xdrs,open_claim_delegate_cur4 * objp)1603 xdr_open_claim_delegate_cur4(register XDR *xdrs, open_claim_delegate_cur4 *objp)
1604 {
1605
1606 if (!xdr_stateid4(xdrs, &objp->delegate_stateid))
1607 return (FALSE);
1608 if (!xdr_component4(xdrs, &objp->file))
1609 return (FALSE);
1610 return (TRUE);
1611 }
1612
1613 bool_t
xdr_open_claim4(register XDR * xdrs,open_claim4 * objp)1614 xdr_open_claim4(register XDR *xdrs, open_claim4 *objp)
1615 {
1616
1617 if (!xdr_open_claim_type4(xdrs, &objp->claim))
1618 return (FALSE);
1619 switch (objp->claim) {
1620 case CLAIM_NULL:
1621 if (!xdr_component4(xdrs, &objp->open_claim4_u.file))
1622 return (FALSE);
1623 break;
1624 case CLAIM_PREVIOUS:
1625 if (!xdr_open_delegation_type4(xdrs, &objp->open_claim4_u.
1626 delegate_type))
1627 return (FALSE);
1628 break;
1629 case CLAIM_DELEGATE_CUR:
1630 if (!xdr_open_claim_delegate_cur4(xdrs, &objp->open_claim4_u.
1631 delegate_cur_info))
1632 return (FALSE);
1633 break;
1634 case CLAIM_DELEGATE_PREV:
1635 if (!xdr_component4(xdrs, &objp->open_claim4_u.
1636 file_delegate_prev))
1637 return (FALSE);
1638 break;
1639 default:
1640 return (FALSE);
1641 }
1642 return (TRUE);
1643 }
1644
1645 bool_t
xdr_OPEN4args(register XDR * xdrs,OPEN4args * objp)1646 xdr_OPEN4args(register XDR *xdrs, OPEN4args *objp)
1647 {
1648
1649 if (!xdr_seqid4(xdrs, &objp->seqid))
1650 return (FALSE);
1651 if (!xdr_uint32_t(xdrs, &objp->share_access))
1652 return (FALSE);
1653 if (!xdr_uint32_t(xdrs, &objp->share_deny))
1654 return (FALSE);
1655 if (!xdr_open_owner4(xdrs, &objp->owner))
1656 return (FALSE);
1657 if (!xdr_openflag4(xdrs, &objp->openhow))
1658 return (FALSE);
1659 if (!xdr_open_claim4(xdrs, &objp->claim))
1660 return (FALSE);
1661 return (TRUE);
1662 }
1663
1664 bool_t
xdr_open_read_delegation4(register XDR * xdrs,open_read_delegation4 * objp)1665 xdr_open_read_delegation4(register XDR *xdrs, open_read_delegation4 *objp)
1666 {
1667
1668 if (!xdr_stateid4(xdrs, &objp->stateid))
1669 return (FALSE);
1670 if (!xdr_bool(xdrs, &objp->recall))
1671 return (FALSE);
1672 if (!xdr_nfsace4(xdrs, &objp->permissions))
1673 return (FALSE);
1674 return (TRUE);
1675 }
1676
1677 bool_t
xdr_open_write_delegation4(register XDR * xdrs,open_write_delegation4 * objp)1678 xdr_open_write_delegation4(register XDR *xdrs, open_write_delegation4 *objp)
1679 {
1680
1681 if (!xdr_stateid4(xdrs, &objp->stateid))
1682 return (FALSE);
1683 if (!xdr_bool(xdrs, &objp->recall))
1684 return (FALSE);
1685 if (!xdr_nfs_space_limit4(xdrs, &objp->space_limit))
1686 return (FALSE);
1687 if (!xdr_nfsace4(xdrs, &objp->permissions))
1688 return (FALSE);
1689 return (TRUE);
1690 }
1691
1692 bool_t
xdr_open_delegation4(register XDR * xdrs,open_delegation4 * objp)1693 xdr_open_delegation4(register XDR *xdrs, open_delegation4 *objp)
1694 {
1695
1696 if (!xdr_open_delegation_type4(xdrs, &objp->delegation_type))
1697 return (FALSE);
1698 switch (objp->delegation_type) {
1699 case OPEN_DELEGATE_NONE:
1700 break;
1701 case OPEN_DELEGATE_READ:
1702 if (!xdr_open_read_delegation4(xdrs, &objp->open_delegation4_u.
1703 read))
1704 return (FALSE);
1705 break;
1706 case OPEN_DELEGATE_WRITE:
1707 if (!xdr_open_write_delegation4(xdrs, &objp->open_delegation4_u.
1708 write))
1709 return (FALSE);
1710 break;
1711 default:
1712 return (FALSE);
1713 }
1714 return (TRUE);
1715 }
1716
1717 bool_t
xdr_OPEN4resok(register XDR * xdrs,OPEN4resok * objp)1718 xdr_OPEN4resok(register XDR *xdrs, OPEN4resok *objp)
1719 {
1720
1721 if (!xdr_stateid4(xdrs, &objp->stateid))
1722 return (FALSE);
1723 if (!xdr_change_info4(xdrs, &objp->cinfo))
1724 return (FALSE);
1725 if (!xdr_uint32_t(xdrs, &objp->rflags))
1726 return (FALSE);
1727 if (!xdr_bitmap4(xdrs, &objp->attrset))
1728 return (FALSE);
1729 if (!xdr_open_delegation4(xdrs, &objp->delegation))
1730 return (FALSE);
1731 return (TRUE);
1732 }
1733
1734 bool_t
xdr_OPEN4res(register XDR * xdrs,OPEN4res * objp)1735 xdr_OPEN4res(register XDR *xdrs, OPEN4res *objp)
1736 {
1737
1738 if (!xdr_nfsstat4(xdrs, &objp->status))
1739 return (FALSE);
1740 switch (objp->status) {
1741 case NFS4_OK:
1742 if (!xdr_OPEN4resok(xdrs, &objp->OPEN4res_u.resok4))
1743 return (FALSE);
1744 break;
1745 }
1746 return (TRUE);
1747 }
1748
1749 bool_t
xdr_OPENATTR4args(register XDR * xdrs,OPENATTR4args * objp)1750 xdr_OPENATTR4args(register XDR *xdrs, OPENATTR4args *objp)
1751 {
1752
1753 if (!xdr_bool(xdrs, &objp->createdir))
1754 return (FALSE);
1755 return (TRUE);
1756 }
1757
1758 bool_t
xdr_OPENATTR4res(register XDR * xdrs,OPENATTR4res * objp)1759 xdr_OPENATTR4res(register XDR *xdrs, OPENATTR4res *objp)
1760 {
1761
1762 if (!xdr_nfsstat4(xdrs, &objp->status))
1763 return (FALSE);
1764 return (TRUE);
1765 }
1766
1767 bool_t
xdr_OPEN_CONFIRM4args(register XDR * xdrs,OPEN_CONFIRM4args * objp)1768 xdr_OPEN_CONFIRM4args(register XDR *xdrs, OPEN_CONFIRM4args *objp)
1769 {
1770
1771 if (!xdr_stateid4(xdrs, &objp->open_stateid))
1772 return (FALSE);
1773 if (!xdr_seqid4(xdrs, &objp->seqid))
1774 return (FALSE);
1775 return (TRUE);
1776 }
1777
1778 bool_t
xdr_OPEN_CONFIRM4resok(register XDR * xdrs,OPEN_CONFIRM4resok * objp)1779 xdr_OPEN_CONFIRM4resok(register XDR *xdrs, OPEN_CONFIRM4resok *objp)
1780 {
1781
1782 if (!xdr_stateid4(xdrs, &objp->open_stateid))
1783 return (FALSE);
1784 return (TRUE);
1785 }
1786
1787 bool_t
xdr_OPEN_CONFIRM4res(register XDR * xdrs,OPEN_CONFIRM4res * objp)1788 xdr_OPEN_CONFIRM4res(register XDR *xdrs, OPEN_CONFIRM4res *objp)
1789 {
1790
1791 if (!xdr_nfsstat4(xdrs, &objp->status))
1792 return (FALSE);
1793 switch (objp->status) {
1794 case NFS4_OK:
1795 if (!xdr_OPEN_CONFIRM4resok(xdrs, &objp->OPEN_CONFIRM4res_u.
1796 resok4))
1797 return (FALSE);
1798 break;
1799 }
1800 return (TRUE);
1801 }
1802
1803 bool_t
xdr_OPEN_DOWNGRADE4args(register XDR * xdrs,OPEN_DOWNGRADE4args * objp)1804 xdr_OPEN_DOWNGRADE4args(register XDR *xdrs, OPEN_DOWNGRADE4args *objp)
1805 {
1806
1807 if (!xdr_stateid4(xdrs, &objp->open_stateid))
1808 return (FALSE);
1809 if (!xdr_seqid4(xdrs, &objp->seqid))
1810 return (FALSE);
1811 if (!xdr_uint32_t(xdrs, &objp->share_access))
1812 return (FALSE);
1813 if (!xdr_uint32_t(xdrs, &objp->share_deny))
1814 return (FALSE);
1815 return (TRUE);
1816 }
1817
1818 bool_t
xdr_OPEN_DOWNGRADE4resok(register XDR * xdrs,OPEN_DOWNGRADE4resok * objp)1819 xdr_OPEN_DOWNGRADE4resok(register XDR *xdrs, OPEN_DOWNGRADE4resok *objp)
1820 {
1821
1822 if (!xdr_stateid4(xdrs, &objp->open_stateid))
1823 return (FALSE);
1824 return (TRUE);
1825 }
1826
1827 bool_t
xdr_OPEN_DOWNGRADE4res(register XDR * xdrs,OPEN_DOWNGRADE4res * objp)1828 xdr_OPEN_DOWNGRADE4res(register XDR *xdrs, OPEN_DOWNGRADE4res *objp)
1829 {
1830
1831 if (!xdr_nfsstat4(xdrs, &objp->status))
1832 return (FALSE);
1833 switch (objp->status) {
1834 case NFS4_OK:
1835 if (!xdr_OPEN_DOWNGRADE4resok(xdrs, &objp->OPEN_DOWNGRADE4res_u.
1836 resok4))
1837 return (FALSE);
1838 break;
1839 }
1840 return (TRUE);
1841 }
1842
1843 bool_t
xdr_PUTFH4args(register XDR * xdrs,PUTFH4args * objp)1844 xdr_PUTFH4args(register XDR *xdrs, PUTFH4args *objp)
1845 {
1846
1847 if (!xdr_nfs_fh4(xdrs, &objp->object))
1848 return (FALSE);
1849 return (TRUE);
1850 }
1851
1852 bool_t
xdr_PUTFH4res(register XDR * xdrs,PUTFH4res * objp)1853 xdr_PUTFH4res(register XDR *xdrs, PUTFH4res *objp)
1854 {
1855
1856 if (!xdr_nfsstat4(xdrs, &objp->status))
1857 return (FALSE);
1858 return (TRUE);
1859 }
1860
1861 bool_t
xdr_PUTPUBFH4res(register XDR * xdrs,PUTPUBFH4res * objp)1862 xdr_PUTPUBFH4res(register XDR *xdrs, PUTPUBFH4res *objp)
1863 {
1864
1865 if (!xdr_nfsstat4(xdrs, &objp->status))
1866 return (FALSE);
1867 return (TRUE);
1868 }
1869
1870 bool_t
xdr_PUTROOTFH4res(register XDR * xdrs,PUTROOTFH4res * objp)1871 xdr_PUTROOTFH4res(register XDR *xdrs, PUTROOTFH4res *objp)
1872 {
1873
1874 if (!xdr_nfsstat4(xdrs, &objp->status))
1875 return (FALSE);
1876 return (TRUE);
1877 }
1878
1879 bool_t
xdr_READ4args(register XDR * xdrs,READ4args * objp)1880 xdr_READ4args(register XDR *xdrs, READ4args *objp)
1881 {
1882
1883 if (!xdr_stateid4(xdrs, &objp->stateid))
1884 return (FALSE);
1885 if (!xdr_offset4(xdrs, &objp->offset))
1886 return (FALSE);
1887 if (!xdr_count4(xdrs, &objp->count))
1888 return (FALSE);
1889 return (TRUE);
1890 }
1891
1892 bool_t
xdr_READ4resok(register XDR * xdrs,READ4resok * objp)1893 xdr_READ4resok(register XDR *xdrs, READ4resok *objp)
1894 {
1895
1896 if (!xdr_bool(xdrs, &objp->eof))
1897 return (FALSE);
1898
1899 #ifdef IGNORE_RDWR_DATA
1900 /*
1901 * Try to get length of read, and if that
1902 * fails, default to 0. Don't return FALSE
1903 * because the other read info will not be
1904 * displayed.
1905 */
1906 objp->data.data_val = NULL;
1907 if (!xdr_u_int(xdrs, &objp->data.data_len))
1908 objp->data.data_len = 0;
1909 nfs4_skip_bytes = objp->data.data_len;
1910 #else
1911 if (!xdr_bytes(xdrs, (char **)&objp->data.data_val,
1912 (uint_t *)&objp->data.data_len, ~0))
1913 return (FALSE);
1914 #endif
1915 return (TRUE);
1916 }
1917
1918 bool_t
xdr_READ4res(register XDR * xdrs,READ4res * objp)1919 xdr_READ4res(register XDR *xdrs, READ4res *objp)
1920 {
1921
1922 if (!xdr_nfsstat4(xdrs, &objp->status))
1923 return (FALSE);
1924 switch (objp->status) {
1925 case NFS4_OK:
1926 if (!xdr_READ4resok(xdrs, &objp->READ4res_u.resok4))
1927 return (FALSE);
1928 break;
1929 }
1930 return (TRUE);
1931 }
1932
1933 bool_t
xdr_READDIR4args(register XDR * xdrs,READDIR4args * objp)1934 xdr_READDIR4args(register XDR *xdrs, READDIR4args *objp)
1935 {
1936
1937 if (!xdr_nfs_cookie4(xdrs, &objp->cookie))
1938 return (FALSE);
1939 if (!xdr_verifier4(xdrs, objp->cookieverf))
1940 return (FALSE);
1941 if (!xdr_count4(xdrs, &objp->dircount))
1942 return (FALSE);
1943 if (!xdr_count4(xdrs, &objp->maxcount))
1944 return (FALSE);
1945 if (!xdr_bitmap4(xdrs, &objp->attr_request))
1946 return (FALSE);
1947 return (TRUE);
1948 }
1949
1950 bool_t
xdr_entry4(register XDR * xdrs,entry4 * objp)1951 xdr_entry4(register XDR *xdrs, entry4 *objp)
1952 {
1953
1954 entry4 *tmp_entry4;
1955 bool_t more_data = TRUE;
1956 bool_t first_objp = TRUE;
1957
1958 while (more_data) {
1959
1960 if (!xdr_nfs_cookie4(xdrs, &objp->cookie))
1961 return (FALSE);
1962 if (!xdr_component4(xdrs, &objp->name))
1963 return (FALSE);
1964 if (!xdr_fattr4(xdrs, &objp->attrs))
1965 return (FALSE);
1966
1967 if (xdrs->x_op == XDR_DECODE) {
1968
1969 void bzero();
1970
1971 if (!xdr_bool(xdrs, &more_data))
1972 return (FALSE);
1973
1974 if (!more_data) {
1975 objp->nextentry = NULL;
1976 break;
1977 }
1978
1979 objp->nextentry = (entry4 *)
1980 mem_alloc(sizeof (entry4));
1981 if (objp->nextentry == NULL)
1982 return (NULL);
1983 bzero(objp->nextentry, sizeof (entry4));
1984 objp = objp->nextentry;
1985
1986 } else if (xdrs->x_op == XDR_ENCODE) {
1987 objp = objp->nextentry;
1988 if (!objp)
1989 more_data = FALSE;
1990
1991 if (!xdr_bool(xdrs, &more_data))
1992 return (FALSE);
1993 } else {
1994 tmp_entry4 = objp;
1995 objp = objp->nextentry;
1996 if (!objp)
1997 more_data = FALSE;
1998 if (!xdr_bool(xdrs, &more_data))
1999 return (FALSE);
2000 if (!first_objp)
2001 mem_free(tmp_entry4, sizeof (entry4));
2002 else
2003 first_objp = FALSE;
2004 }
2005 }
2006 return (TRUE);
2007 }
2008
2009 bool_t
xdr_dirlist4(register XDR * xdrs,dirlist4 * objp)2010 xdr_dirlist4(register XDR *xdrs, dirlist4 *objp)
2011 {
2012
2013 if (!xdr_pointer(xdrs, (char **)&objp->entries, sizeof (entry4),
2014 (xdrproc_t)xdr_entry4))
2015 return (FALSE);
2016 if (!xdr_bool(xdrs, &objp->eof))
2017 return (FALSE);
2018 return (TRUE);
2019 }
2020
2021 bool_t
xdr_READDIR4resok(register XDR * xdrs,READDIR4resok * objp)2022 xdr_READDIR4resok(register XDR *xdrs, READDIR4resok *objp)
2023 {
2024
2025 if (!xdr_verifier4(xdrs, objp->cookieverf))
2026 return (FALSE);
2027 if (!xdr_dirlist4(xdrs, &objp->reply))
2028 return (FALSE);
2029 return (TRUE);
2030 }
2031
2032 bool_t
xdr_READDIR4res(register XDR * xdrs,READDIR4res * objp)2033 xdr_READDIR4res(register XDR *xdrs, READDIR4res *objp)
2034 {
2035
2036 if (!xdr_nfsstat4(xdrs, &objp->status))
2037 return (FALSE);
2038 switch (objp->status) {
2039 case NFS4_OK:
2040 if (!xdr_READDIR4resok(xdrs, &objp->READDIR4res_u.resok4))
2041 return (FALSE);
2042 break;
2043 }
2044 return (TRUE);
2045 }
2046
2047 bool_t
xdr_READLINK4resok(register XDR * xdrs,READLINK4resok * objp)2048 xdr_READLINK4resok(register XDR *xdrs, READLINK4resok *objp)
2049 {
2050
2051 if (!xdr_linktext4(xdrs, &objp->link))
2052 return (FALSE);
2053 return (TRUE);
2054 }
2055
2056 bool_t
xdr_READLINK4res(register XDR * xdrs,READLINK4res * objp)2057 xdr_READLINK4res(register XDR *xdrs, READLINK4res *objp)
2058 {
2059
2060 if (!xdr_nfsstat4(xdrs, &objp->status))
2061 return (FALSE);
2062 switch (objp->status) {
2063 case NFS4_OK:
2064 if (!xdr_READLINK4resok(xdrs, &objp->READLINK4res_u.resok4))
2065 return (FALSE);
2066 break;
2067 }
2068 return (TRUE);
2069 }
2070
2071 bool_t
xdr_REMOVE4args(register XDR * xdrs,REMOVE4args * objp)2072 xdr_REMOVE4args(register XDR *xdrs, REMOVE4args *objp)
2073 {
2074
2075 if (!xdr_component4(xdrs, &objp->target))
2076 return (FALSE);
2077 return (TRUE);
2078 }
2079
2080 bool_t
xdr_REMOVE4resok(register XDR * xdrs,REMOVE4resok * objp)2081 xdr_REMOVE4resok(register XDR *xdrs, REMOVE4resok *objp)
2082 {
2083
2084 if (!xdr_change_info4(xdrs, &objp->cinfo))
2085 return (FALSE);
2086 return (TRUE);
2087 }
2088
2089 bool_t
xdr_REMOVE4res(register XDR * xdrs,REMOVE4res * objp)2090 xdr_REMOVE4res(register XDR *xdrs, REMOVE4res *objp)
2091 {
2092
2093 if (!xdr_nfsstat4(xdrs, &objp->status))
2094 return (FALSE);
2095 switch (objp->status) {
2096 case NFS4_OK:
2097 if (!xdr_REMOVE4resok(xdrs, &objp->REMOVE4res_u.resok4))
2098 return (FALSE);
2099 break;
2100 }
2101 return (TRUE);
2102 }
2103
2104 bool_t
xdr_RENAME4args(register XDR * xdrs,RENAME4args * objp)2105 xdr_RENAME4args(register XDR *xdrs, RENAME4args *objp)
2106 {
2107
2108 if (!xdr_component4(xdrs, &objp->oldname))
2109 return (FALSE);
2110 if (!xdr_component4(xdrs, &objp->newname))
2111 return (FALSE);
2112 return (TRUE);
2113 }
2114
2115 bool_t
xdr_RENAME4resok(register XDR * xdrs,RENAME4resok * objp)2116 xdr_RENAME4resok(register XDR *xdrs, RENAME4resok *objp)
2117 {
2118
2119 if (!xdr_change_info4(xdrs, &objp->source_cinfo))
2120 return (FALSE);
2121 if (!xdr_change_info4(xdrs, &objp->target_cinfo))
2122 return (FALSE);
2123 return (TRUE);
2124 }
2125
2126 bool_t
xdr_RENAME4res(register XDR * xdrs,RENAME4res * objp)2127 xdr_RENAME4res(register XDR *xdrs, RENAME4res *objp)
2128 {
2129
2130 if (!xdr_nfsstat4(xdrs, &objp->status))
2131 return (FALSE);
2132 switch (objp->status) {
2133 case NFS4_OK:
2134 if (!xdr_RENAME4resok(xdrs, &objp->RENAME4res_u.resok4))
2135 return (FALSE);
2136 break;
2137 }
2138 return (TRUE);
2139 }
2140
2141 bool_t
xdr_RENEW4args(register XDR * xdrs,RENEW4args * objp)2142 xdr_RENEW4args(register XDR *xdrs, RENEW4args *objp)
2143 {
2144
2145 if (!xdr_clientid4(xdrs, &objp->clientid))
2146 return (FALSE);
2147 return (TRUE);
2148 }
2149
2150 bool_t
xdr_RENEW4res(register XDR * xdrs,RENEW4res * objp)2151 xdr_RENEW4res(register XDR *xdrs, RENEW4res *objp)
2152 {
2153
2154 if (!xdr_nfsstat4(xdrs, &objp->status))
2155 return (FALSE);
2156 return (TRUE);
2157 }
2158
2159 bool_t
xdr_RESTOREFH4res(register XDR * xdrs,RESTOREFH4res * objp)2160 xdr_RESTOREFH4res(register XDR *xdrs, RESTOREFH4res *objp)
2161 {
2162
2163 if (!xdr_nfsstat4(xdrs, &objp->status))
2164 return (FALSE);
2165 return (TRUE);
2166 }
2167
2168 bool_t
xdr_SAVEFH4res(register XDR * xdrs,SAVEFH4res * objp)2169 xdr_SAVEFH4res(register XDR *xdrs, SAVEFH4res *objp)
2170 {
2171
2172 if (!xdr_nfsstat4(xdrs, &objp->status))
2173 return (FALSE);
2174 return (TRUE);
2175 }
2176
2177 bool_t
xdr_SECINFO4args(register XDR * xdrs,SECINFO4args * objp)2178 xdr_SECINFO4args(register XDR *xdrs, SECINFO4args *objp)
2179 {
2180
2181 if (!xdr_component4(xdrs, &objp->name))
2182 return (FALSE);
2183 return (TRUE);
2184 }
2185
2186 bool_t
xdr_rpc_gss_svc_t(register XDR * xdrs,rpc_gss_svc_t * objp)2187 xdr_rpc_gss_svc_t(register XDR *xdrs, rpc_gss_svc_t *objp)
2188 {
2189
2190 if (!xdr_enum(xdrs, (enum_t *)objp))
2191 return (FALSE);
2192 return (TRUE);
2193 }
2194
2195 bool_t
xdr_rpcsec_gss_info(register XDR * xdrs,rpcsec_gss_info * objp)2196 xdr_rpcsec_gss_info(register XDR *xdrs, rpcsec_gss_info *objp)
2197 {
2198
2199 if (!xdr_sec_oid4(xdrs, &objp->oid))
2200 return (FALSE);
2201 if (!xdr_qop4(xdrs, &objp->qop))
2202 return (FALSE);
2203 if (!xdr_rpc_gss_svc_t(xdrs, &objp->service))
2204 return (FALSE);
2205 return (TRUE);
2206 }
2207
2208 bool_t
xdr_secinfo4(register XDR * xdrs,secinfo4 * objp)2209 xdr_secinfo4(register XDR *xdrs, secinfo4 *objp)
2210 {
2211
2212 if (!xdr_uint32_t(xdrs, &objp->flavor))
2213 return (FALSE);
2214 switch (objp->flavor) {
2215 case RPCSEC_GSS:
2216 if (!xdr_rpcsec_gss_info(xdrs, &objp->secinfo4_u.flavor_info))
2217 return (FALSE);
2218 break;
2219 }
2220 return (TRUE);
2221 }
2222
2223 bool_t
xdr_SECINFO4resok(register XDR * xdrs,SECINFO4resok * objp)2224 xdr_SECINFO4resok(register XDR *xdrs, SECINFO4resok *objp)
2225 {
2226
2227 if (!xdr_array(xdrs, (char **)&objp->SECINFO4resok_val,
2228 (uint_t *)&objp->SECINFO4resok_len, ~0,
2229 sizeof (secinfo4), (xdrproc_t)xdr_secinfo4))
2230 return (FALSE);
2231 return (TRUE);
2232 }
2233
2234 bool_t
xdr_SECINFO4res(register XDR * xdrs,SECINFO4res * objp)2235 xdr_SECINFO4res(register XDR *xdrs, SECINFO4res *objp)
2236 {
2237
2238 if (!xdr_nfsstat4(xdrs, &objp->status))
2239 return (FALSE);
2240 switch (objp->status) {
2241 case NFS4_OK:
2242 if (!xdr_SECINFO4resok(xdrs, &objp->SECINFO4res_u.resok4))
2243 return (FALSE);
2244 break;
2245 }
2246 return (TRUE);
2247 }
2248
2249 bool_t
xdr_SETATTR4args(register XDR * xdrs,SETATTR4args * objp)2250 xdr_SETATTR4args(register XDR *xdrs, SETATTR4args *objp)
2251 {
2252
2253 if (!xdr_stateid4(xdrs, &objp->stateid))
2254 return (FALSE);
2255 if (!xdr_fattr4(xdrs, &objp->obj_attributes))
2256 return (FALSE);
2257 return (TRUE);
2258 }
2259
2260 bool_t
xdr_SETATTR4res(register XDR * xdrs,SETATTR4res * objp)2261 xdr_SETATTR4res(register XDR *xdrs, SETATTR4res *objp)
2262 {
2263
2264 if (!xdr_nfsstat4(xdrs, &objp->status))
2265 return (FALSE);
2266 if (!xdr_bitmap4(xdrs, &objp->attrsset))
2267 return (FALSE);
2268 return (TRUE);
2269 }
2270
2271 bool_t
xdr_SETCLIENTID4args(register XDR * xdrs,SETCLIENTID4args * objp)2272 xdr_SETCLIENTID4args(register XDR *xdrs, SETCLIENTID4args *objp)
2273 {
2274
2275 if (!xdr_nfs_client_id4(xdrs, &objp->client))
2276 return (FALSE);
2277 if (!xdr_cb_client4(xdrs, &objp->callback))
2278 return (FALSE);
2279 if (!xdr_uint32_t(xdrs, &objp->callback_ident))
2280 return (FALSE);
2281 return (TRUE);
2282 }
2283
2284 bool_t
xdr_SETCLIENTID4resok(register XDR * xdrs,SETCLIENTID4resok * objp)2285 xdr_SETCLIENTID4resok(register XDR *xdrs, SETCLIENTID4resok *objp)
2286 {
2287
2288 if (!xdr_clientid4(xdrs, &objp->clientid))
2289 return (FALSE);
2290 if (!xdr_verifier4(xdrs, objp->setclientid_confirm))
2291 return (FALSE);
2292 return (TRUE);
2293 }
2294
2295 bool_t
xdr_SETCLIENTID4res(register XDR * xdrs,SETCLIENTID4res * objp)2296 xdr_SETCLIENTID4res(register XDR *xdrs, SETCLIENTID4res *objp)
2297 {
2298
2299 if (!xdr_nfsstat4(xdrs, &objp->status))
2300 return (FALSE);
2301 switch (objp->status) {
2302 case NFS4_OK:
2303 if (!xdr_SETCLIENTID4resok(xdrs, &objp->SETCLIENTID4res_u.
2304 resok4))
2305 return (FALSE);
2306 break;
2307 case NFS4ERR_CLID_INUSE:
2308 if (!xdr_clientaddr4(xdrs, &objp->SETCLIENTID4res_u.
2309 client_using))
2310 return (FALSE);
2311 break;
2312 }
2313 return (TRUE);
2314 }
2315
2316 bool_t
xdr_SETCLIENTID_CONFIRM4args(register XDR * xdrs,SETCLIENTID_CONFIRM4args * objp)2317 xdr_SETCLIENTID_CONFIRM4args(register XDR *xdrs, SETCLIENTID_CONFIRM4args *objp)
2318 {
2319
2320 if (!xdr_clientid4(xdrs, &objp->clientid))
2321 return (FALSE);
2322 if (!xdr_verifier4(xdrs, objp->setclientid_confirm))
2323 return (FALSE);
2324 return (TRUE);
2325 }
2326
2327 bool_t
xdr_SETCLIENTID_CONFIRM4res(register XDR * xdrs,SETCLIENTID_CONFIRM4res * objp)2328 xdr_SETCLIENTID_CONFIRM4res(register XDR *xdrs, SETCLIENTID_CONFIRM4res *objp)
2329 {
2330
2331 if (!xdr_nfsstat4(xdrs, &objp->status))
2332 return (FALSE);
2333 return (TRUE);
2334 }
2335
2336 bool_t
xdr_VERIFY4args(register XDR * xdrs,VERIFY4args * objp)2337 xdr_VERIFY4args(register XDR *xdrs, VERIFY4args *objp)
2338 {
2339
2340 if (!xdr_fattr4(xdrs, &objp->obj_attributes))
2341 return (FALSE);
2342 return (TRUE);
2343 }
2344
2345 bool_t
xdr_VERIFY4res(register XDR * xdrs,VERIFY4res * objp)2346 xdr_VERIFY4res(register XDR *xdrs, VERIFY4res *objp)
2347 {
2348
2349 if (!xdr_nfsstat4(xdrs, &objp->status))
2350 return (FALSE);
2351 return (TRUE);
2352 }
2353
2354 bool_t
xdr_stable_how4(register XDR * xdrs,stable_how4 * objp)2355 xdr_stable_how4(register XDR *xdrs, stable_how4 *objp)
2356 {
2357
2358 if (!xdr_enum(xdrs, (enum_t *)objp))
2359 return (FALSE);
2360 return (TRUE);
2361 }
2362
2363 bool_t
xdr_WRITE4args(register XDR * xdrs,WRITE4args * objp)2364 xdr_WRITE4args(register XDR *xdrs, WRITE4args *objp)
2365 {
2366
2367 if (!xdr_stateid4(xdrs, &objp->stateid))
2368 return (FALSE);
2369 if (!xdr_offset4(xdrs, &objp->offset))
2370 return (FALSE);
2371 if (!xdr_stable_how4(xdrs, &objp->stable))
2372 return (FALSE);
2373
2374 #ifdef IGNORE_RDWR_DATA
2375 /*
2376 * try to get length of write, and if that
2377 * fails, default to 0. Don't return FALSE
2378 * because the other write info will not be
2379 * displayed (write stateid).
2380 */
2381 objp->data.data_val = NULL;
2382 if (!xdr_u_int(xdrs, &objp->data.data_len))
2383 objp->data.data_len = 0;
2384 nfs4_skip_bytes = objp->data.data_len;
2385 #else
2386 if (!xdr_bytes(xdrs, (char **)&objp->data.data_val,
2387 (uint_t *)&objp->data.data_len, ~0))
2388 return (FALSE);
2389 #endif
2390 return (TRUE);
2391 }
2392
2393 bool_t
xdr_WRITE4resok(register XDR * xdrs,WRITE4resok * objp)2394 xdr_WRITE4resok(register XDR *xdrs, WRITE4resok *objp)
2395 {
2396
2397 if (!xdr_count4(xdrs, &objp->count))
2398 return (FALSE);
2399 if (!xdr_stable_how4(xdrs, &objp->committed))
2400 return (FALSE);
2401 if (!xdr_verifier4(xdrs, objp->writeverf))
2402 return (FALSE);
2403 return (TRUE);
2404 }
2405
2406 bool_t
xdr_WRITE4res(register XDR * xdrs,WRITE4res * objp)2407 xdr_WRITE4res(register XDR *xdrs, WRITE4res *objp)
2408 {
2409
2410 if (!xdr_nfsstat4(xdrs, &objp->status))
2411 return (FALSE);
2412 switch (objp->status) {
2413 case NFS4_OK:
2414 if (!xdr_WRITE4resok(xdrs, &objp->WRITE4res_u.resok4))
2415 return (FALSE);
2416 break;
2417 }
2418 return (TRUE);
2419 }
2420
2421 bool_t
xdr_RELEASE_LOCKOWNER4args(register XDR * xdrs,RELEASE_LOCKOWNER4args * objp)2422 xdr_RELEASE_LOCKOWNER4args(register XDR *xdrs, RELEASE_LOCKOWNER4args *objp)
2423 {
2424
2425 if (!xdr_lock_owner4(xdrs, &objp->lock_owner))
2426 return (FALSE);
2427 return (TRUE);
2428 }
2429
2430 bool_t
xdr_RELEASE_LOCKOWNER4res(register XDR * xdrs,RELEASE_LOCKOWNER4res * objp)2431 xdr_RELEASE_LOCKOWNER4res(register XDR *xdrs, RELEASE_LOCKOWNER4res *objp)
2432 {
2433
2434 if (!xdr_nfsstat4(xdrs, &objp->status))
2435 return (FALSE);
2436 return (TRUE);
2437 }
2438
2439 bool_t
xdr_ILLEGAL4res(register XDR * xdrs,ILLEGAL4res * objp)2440 xdr_ILLEGAL4res(register XDR *xdrs, ILLEGAL4res *objp)
2441 {
2442
2443 if (!xdr_nfsstat4(xdrs, &objp->status))
2444 return (FALSE);
2445 return (TRUE);
2446 }
2447
2448 bool_t
xdr_nfs_opnum4(register XDR * xdrs,nfs_opnum4 * objp)2449 xdr_nfs_opnum4(register XDR *xdrs, nfs_opnum4 *objp)
2450 {
2451
2452 if (!xdr_enum(xdrs, (enum_t *)objp))
2453 return (FALSE);
2454 return (TRUE);
2455 }
2456
2457 bool_t
xdr_nfs_argop4(register XDR * xdrs,nfs_argop4 * objp)2458 xdr_nfs_argop4(register XDR *xdrs, nfs_argop4 *objp)
2459 {
2460 nfs4_skip_bytes = 0;
2461 if (!xdr_nfs_opnum4(xdrs, &objp->argop))
2462 return (FALSE);
2463 switch (objp->argop) {
2464 case OP_ACCESS:
2465 if (!xdr_ACCESS4args(xdrs, &objp->nfs_argop4_u.opaccess))
2466 return (FALSE);
2467 break;
2468 case OP_CLOSE:
2469 if (!xdr_CLOSE4args(xdrs, &objp->nfs_argop4_u.opclose))
2470 return (FALSE);
2471 break;
2472 case OP_COMMIT:
2473 if (!xdr_COMMIT4args(xdrs, &objp->nfs_argop4_u.opcommit))
2474 return (FALSE);
2475 break;
2476 case OP_CREATE:
2477 if (!xdr_CREATE4args(xdrs, &objp->nfs_argop4_u.opcreate))
2478 return (FALSE);
2479 break;
2480 case OP_DELEGPURGE:
2481 if (!xdr_DELEGPURGE4args(xdrs, &objp->nfs_argop4_u.
2482 opdelegpurge))
2483 return (FALSE);
2484 break;
2485 case OP_DELEGRETURN:
2486 if (!xdr_DELEGRETURN4args(xdrs, &objp->nfs_argop4_u.
2487 opdelegreturn))
2488 return (FALSE);
2489 break;
2490 case OP_GETATTR:
2491 if (!xdr_GETATTR4args(xdrs, &objp->nfs_argop4_u.
2492 opgetattr))
2493 return (FALSE);
2494 break;
2495 case OP_GETFH:
2496 break;
2497 case OP_LINK:
2498 if (!xdr_LINK4args(xdrs, &objp->nfs_argop4_u.oplink))
2499 return (FALSE);
2500 break;
2501 case OP_LOCK:
2502 if (!xdr_LOCK4args(xdrs, &objp->nfs_argop4_u.oplock))
2503 return (FALSE);
2504 break;
2505 case OP_LOCKT:
2506 if (!xdr_LOCKT4args(xdrs, &objp->nfs_argop4_u.oplockt))
2507 return (FALSE);
2508 break;
2509 case OP_LOCKU:
2510 if (!xdr_LOCKU4args(xdrs, &objp->nfs_argop4_u.oplocku))
2511 return (FALSE);
2512 break;
2513 case OP_LOOKUP:
2514 if (!xdr_LOOKUP4args(xdrs, &objp->nfs_argop4_u.oplookup))
2515 return (FALSE);
2516 break;
2517 case OP_LOOKUPP:
2518 break;
2519 case OP_NVERIFY:
2520 if (!xdr_NVERIFY4args(xdrs, &objp->nfs_argop4_u.opnverify))
2521 return (FALSE);
2522 break;
2523 case OP_OPEN:
2524 if (!xdr_OPEN4args(xdrs, &objp->nfs_argop4_u.opopen))
2525 return (FALSE);
2526 break;
2527 case OP_OPENATTR:
2528 if (!xdr_OPENATTR4args(xdrs, &objp->nfs_argop4_u.opopenattr))
2529 return (FALSE);
2530 break;
2531 case OP_OPEN_CONFIRM:
2532 if (!xdr_OPEN_CONFIRM4args(xdrs, &objp->nfs_argop4_u.
2533 opopen_confirm))
2534 return (FALSE);
2535 break;
2536 case OP_OPEN_DOWNGRADE:
2537 if (!xdr_OPEN_DOWNGRADE4args(xdrs, &objp->nfs_argop4_u.
2538 opopen_downgrade))
2539 return (FALSE);
2540 break;
2541 case OP_PUTFH:
2542 if (!xdr_PUTFH4args(xdrs, &objp->nfs_argop4_u.opputfh))
2543 return (FALSE);
2544 break;
2545 case OP_PUTPUBFH:
2546 break;
2547 case OP_PUTROOTFH:
2548 break;
2549 case OP_READ:
2550 if (!xdr_READ4args(xdrs, &objp->nfs_argop4_u.opread))
2551 return (FALSE);
2552 break;
2553 case OP_READDIR:
2554 if (!xdr_READDIR4args(xdrs, &objp->nfs_argop4_u.opreaddir))
2555 return (FALSE);
2556 break;
2557 case OP_READLINK:
2558 break;
2559 case OP_REMOVE:
2560 if (!xdr_REMOVE4args(xdrs, &objp->nfs_argop4_u.opremove))
2561 return (FALSE);
2562 break;
2563 case OP_RENAME:
2564 if (!xdr_RENAME4args(xdrs, &objp->nfs_argop4_u.oprename))
2565 return (FALSE);
2566 break;
2567 case OP_RENEW:
2568 if (!xdr_RENEW4args(xdrs, &objp->nfs_argop4_u.oprenew))
2569 return (FALSE);
2570 break;
2571 case OP_RESTOREFH:
2572 break;
2573 case OP_SAVEFH:
2574 break;
2575 case OP_SECINFO:
2576 if (!xdr_SECINFO4args(xdrs, &objp->nfs_argop4_u.opsecinfo))
2577 return (FALSE);
2578 break;
2579 case OP_SETATTR:
2580 if (!xdr_SETATTR4args(xdrs, &objp->nfs_argop4_u.opsetattr))
2581 return (FALSE);
2582 break;
2583 case OP_SETCLIENTID:
2584 if (!xdr_SETCLIENTID4args(xdrs, &objp->nfs_argop4_u.
2585 opsetclientid))
2586 return (FALSE);
2587 break;
2588 case OP_SETCLIENTID_CONFIRM:
2589 if (!xdr_SETCLIENTID_CONFIRM4args(xdrs, &objp->nfs_argop4_u.
2590 opsetclientid_confirm))
2591 return (FALSE);
2592 break;
2593 case OP_VERIFY:
2594 if (!xdr_VERIFY4args(xdrs, &objp->nfs_argop4_u.opverify))
2595 return (FALSE);
2596 break;
2597 case OP_WRITE:
2598 if (!xdr_WRITE4args(xdrs, &objp->nfs_argop4_u.opwrite))
2599 return (FALSE);
2600 break;
2601 case OP_RELEASE_LOCKOWNER:
2602 if (!xdr_RELEASE_LOCKOWNER4args(xdrs,
2603 &objp->nfs_argop4_u.oprelease_lockowner))
2604 return (FALSE);
2605 break;
2606 case OP_ILLEGAL:
2607 break;
2608 default:
2609 return (FALSE);
2610 }
2611 return (TRUE);
2612 }
2613
2614 bool_t
xdr_nfs_resop4(register XDR * xdrs,nfs_resop4 * objp)2615 xdr_nfs_resop4(register XDR *xdrs, nfs_resop4 *objp)
2616 {
2617 nfs4_skip_bytes = 0;
2618 if (!xdr_nfs_opnum4(xdrs, &objp->resop))
2619 return (FALSE);
2620 switch (objp->resop) {
2621 case OP_ACCESS:
2622 if (!xdr_ACCESS4res(xdrs, &objp->nfs_resop4_u.opaccess))
2623 return (FALSE);
2624 break;
2625 case OP_CLOSE:
2626 if (!xdr_CLOSE4res(xdrs, &objp->nfs_resop4_u.opclose))
2627 return (FALSE);
2628 break;
2629 case OP_COMMIT:
2630 if (!xdr_COMMIT4res(xdrs, &objp->nfs_resop4_u.opcommit))
2631 return (FALSE);
2632 break;
2633 case OP_CREATE:
2634 if (!xdr_CREATE4res(xdrs, &objp->nfs_resop4_u.opcreate))
2635 return (FALSE);
2636 break;
2637 case OP_DELEGPURGE:
2638 if (!xdr_DELEGPURGE4res(xdrs, &objp->nfs_resop4_u.opdelegpurge))
2639 return (FALSE);
2640 break;
2641 case OP_DELEGRETURN:
2642 if (!xdr_DELEGRETURN4res(xdrs, &objp->nfs_resop4_u.
2643 opdelegreturn))
2644 return (FALSE);
2645 break;
2646 case OP_GETATTR:
2647 if (!xdr_GETATTR4res(xdrs, &objp->nfs_resop4_u.opgetattr))
2648 return (FALSE);
2649 break;
2650 case OP_GETFH:
2651 if (!xdr_GETFH4res(xdrs, &objp->nfs_resop4_u.opgetfh))
2652 return (FALSE);
2653 break;
2654 case OP_LINK:
2655 if (!xdr_LINK4res(xdrs, &objp->nfs_resop4_u.oplink))
2656 return (FALSE);
2657 break;
2658 case OP_LOCK:
2659 if (!xdr_LOCK4res(xdrs, &objp->nfs_resop4_u.oplock))
2660 return (FALSE);
2661 break;
2662 case OP_LOCKT:
2663 if (!xdr_LOCKT4res(xdrs, &objp->nfs_resop4_u.oplockt))
2664 return (FALSE);
2665 break;
2666 case OP_LOCKU:
2667 if (!xdr_LOCKU4res(xdrs, &objp->nfs_resop4_u.oplocku))
2668 return (FALSE);
2669 break;
2670 case OP_LOOKUP:
2671 if (!xdr_LOOKUP4res(xdrs, &objp->nfs_resop4_u.oplookup))
2672 return (FALSE);
2673 break;
2674 case OP_LOOKUPP:
2675 if (!xdr_LOOKUPP4res(xdrs, &objp->nfs_resop4_u.oplookupp))
2676 return (FALSE);
2677 break;
2678 case OP_NVERIFY:
2679 if (!xdr_NVERIFY4res(xdrs, &objp->nfs_resop4_u.opnverify))
2680 return (FALSE);
2681 break;
2682 case OP_OPEN:
2683 if (!xdr_OPEN4res(xdrs, &objp->nfs_resop4_u.opopen))
2684 return (FALSE);
2685 break;
2686 case OP_OPENATTR:
2687 if (!xdr_OPENATTR4res(xdrs, &objp->nfs_resop4_u.opopenattr))
2688 return (FALSE);
2689 break;
2690 case OP_OPEN_CONFIRM:
2691 if (!xdr_OPEN_CONFIRM4res(xdrs, &objp->nfs_resop4_u.
2692 opopen_confirm))
2693 return (FALSE);
2694 break;
2695 case OP_OPEN_DOWNGRADE:
2696 if (!xdr_OPEN_DOWNGRADE4res(xdrs, &objp->nfs_resop4_u.
2697 opopen_downgrade))
2698 return (FALSE);
2699 break;
2700 case OP_PUTFH:
2701 if (!xdr_PUTFH4res(xdrs, &objp->nfs_resop4_u.opputfh))
2702 return (FALSE);
2703 break;
2704 case OP_PUTPUBFH:
2705 if (!xdr_PUTPUBFH4res(xdrs, &objp->nfs_resop4_u.opputpubfh))
2706 return (FALSE);
2707 break;
2708 case OP_PUTROOTFH:
2709 if (!xdr_PUTROOTFH4res(xdrs, &objp->nfs_resop4_u.opputrootfh))
2710 return (FALSE);
2711 break;
2712 case OP_READ:
2713 if (!xdr_READ4res(xdrs, &objp->nfs_resop4_u.opread))
2714 return (FALSE);
2715 break;
2716 case OP_READDIR:
2717 if (!xdr_READDIR4res(xdrs, &objp->nfs_resop4_u.opreaddir))
2718 return (FALSE);
2719 break;
2720 case OP_READLINK:
2721 if (!xdr_READLINK4res(xdrs, &objp->nfs_resop4_u.opreadlink))
2722 return (FALSE);
2723 break;
2724 case OP_REMOVE:
2725 if (!xdr_REMOVE4res(xdrs, &objp->nfs_resop4_u.opremove))
2726 return (FALSE);
2727 break;
2728 case OP_RENAME:
2729 if (!xdr_RENAME4res(xdrs, &objp->nfs_resop4_u.oprename))
2730 return (FALSE);
2731 break;
2732 case OP_RENEW:
2733 if (!xdr_RENEW4res(xdrs, &objp->nfs_resop4_u.oprenew))
2734 return (FALSE);
2735 break;
2736 case OP_RESTOREFH:
2737 if (!xdr_RESTOREFH4res(xdrs, &objp->nfs_resop4_u.oprestorefh))
2738 return (FALSE);
2739 break;
2740 case OP_SAVEFH:
2741 if (!xdr_SAVEFH4res(xdrs, &objp->nfs_resop4_u.opsavefh))
2742 return (FALSE);
2743 break;
2744 case OP_SECINFO:
2745 if (!xdr_SECINFO4res(xdrs, &objp->nfs_resop4_u.opsecinfo))
2746 return (FALSE);
2747 break;
2748 case OP_SETATTR:
2749 if (!xdr_SETATTR4res(xdrs, &objp->nfs_resop4_u.opsetattr))
2750 return (FALSE);
2751 break;
2752 case OP_SETCLIENTID:
2753 if (!xdr_SETCLIENTID4res(xdrs, &objp->nfs_resop4_u.
2754 opsetclientid))
2755 return (FALSE);
2756 break;
2757 case OP_SETCLIENTID_CONFIRM:
2758 if (!xdr_SETCLIENTID_CONFIRM4res(xdrs, &objp->nfs_resop4_u.
2759 opsetclientid_confirm))
2760 return (FALSE);
2761 break;
2762 case OP_VERIFY:
2763 if (!xdr_VERIFY4res(xdrs, &objp->nfs_resop4_u.opverify))
2764 return (FALSE);
2765 break;
2766 case OP_WRITE:
2767 if (!xdr_WRITE4res(xdrs, &objp->nfs_resop4_u.opwrite))
2768 return (FALSE);
2769 break;
2770 case OP_RELEASE_LOCKOWNER:
2771 if (!xdr_RELEASE_LOCKOWNER4res(xdrs,
2772 &objp->nfs_resop4_u.oprelease_lockowner))
2773 return (FALSE);
2774 break;
2775 case OP_ILLEGAL:
2776 if (!xdr_ILLEGAL4res(xdrs, &objp->nfs_resop4_u.opillegal))
2777 return (FALSE);
2778 break;
2779 default:
2780 return (FALSE);
2781 }
2782 return (TRUE);
2783 }
2784
2785 bool_t
xdr_COMPOUND4args(register XDR * xdrs,COMPOUND4args * objp)2786 xdr_COMPOUND4args(register XDR *xdrs, COMPOUND4args *objp)
2787 {
2788
2789 if (!xdr_utf8string(xdrs, &objp->tag))
2790 return (FALSE);
2791 if (!xdr_uint32_t(xdrs, &objp->minorversion))
2792 return (FALSE);
2793 if (!xdr_array(xdrs, (char **)&objp->argarray.argarray_val,
2794 (uint_t *)&objp->argarray.argarray_len, ~0,
2795 sizeof (nfs_argop4), (xdrproc_t)xdr_nfs_argop4))
2796 return (FALSE);
2797 return (TRUE);
2798 }
2799
2800 bool_t
xdr_COMPOUND4res(register XDR * xdrs,COMPOUND4res * objp)2801 xdr_COMPOUND4res(register XDR *xdrs, COMPOUND4res *objp)
2802 {
2803
2804 if (!xdr_nfsstat4(xdrs, &objp->status))
2805 return (FALSE);
2806 if (!xdr_utf8string(xdrs, &objp->tag))
2807 return (FALSE);
2808 if (!xdr_array(xdrs, (char **)&objp->resarray.resarray_val,
2809 (uint_t *)&objp->resarray.resarray_len, ~0,
2810 sizeof (nfs_resop4), (xdrproc_t)xdr_nfs_resop4))
2811 return (FALSE);
2812 return (TRUE);
2813 }
2814
2815 bool_t
xdr_CB_GETATTR4args(register XDR * xdrs,CB_GETATTR4args * objp)2816 xdr_CB_GETATTR4args(register XDR *xdrs, CB_GETATTR4args *objp)
2817 {
2818
2819 if (!xdr_nfs_fh4(xdrs, &objp->fh))
2820 return (FALSE);
2821 if (!xdr_bitmap4(xdrs, &objp->attr_request))
2822 return (FALSE);
2823 return (TRUE);
2824 }
2825
2826 bool_t
xdr_CB_GETATTR4resok(register XDR * xdrs,CB_GETATTR4resok * objp)2827 xdr_CB_GETATTR4resok(register XDR *xdrs, CB_GETATTR4resok *objp)
2828 {
2829
2830 if (!xdr_fattr4(xdrs, &objp->obj_attributes))
2831 return (FALSE);
2832 return (TRUE);
2833 }
2834
2835 bool_t
xdr_CB_GETATTR4res(register XDR * xdrs,CB_GETATTR4res * objp)2836 xdr_CB_GETATTR4res(register XDR *xdrs, CB_GETATTR4res *objp)
2837 {
2838
2839 if (!xdr_nfsstat4(xdrs, &objp->status))
2840 return (FALSE);
2841 switch (objp->status) {
2842 case NFS4_OK:
2843 if (!xdr_CB_GETATTR4resok(xdrs, &objp->CB_GETATTR4res_u.resok4))
2844 return (FALSE);
2845 break;
2846 }
2847 return (TRUE);
2848 }
2849
2850 bool_t
xdr_CB_RECALL4args(register XDR * xdrs,CB_RECALL4args * objp)2851 xdr_CB_RECALL4args(register XDR *xdrs, CB_RECALL4args *objp)
2852 {
2853
2854 if (!xdr_stateid4(xdrs, &objp->stateid))
2855 return (FALSE);
2856 if (!xdr_bool(xdrs, &objp->truncate))
2857 return (FALSE);
2858 if (!xdr_nfs_fh4(xdrs, &objp->fh))
2859 return (FALSE);
2860 return (TRUE);
2861 }
2862
2863 bool_t
xdr_CB_RECALL4res(register XDR * xdrs,CB_RECALL4res * objp)2864 xdr_CB_RECALL4res(register XDR *xdrs, CB_RECALL4res *objp)
2865 {
2866
2867 if (!xdr_nfsstat4(xdrs, &objp->status))
2868 return (FALSE);
2869 return (TRUE);
2870 }
2871
2872 bool_t
xdr_CB_ILLEGAL4res(register XDR * xdrs,CB_ILLEGAL4res * objp)2873 xdr_CB_ILLEGAL4res(register XDR *xdrs, CB_ILLEGAL4res *objp)
2874 {
2875
2876 if (!xdr_nfsstat4(xdrs, &objp->status))
2877 return (FALSE);
2878 return (TRUE);
2879 }
2880
2881 bool_t
xdr_nfs_cb_opnum4(register XDR * xdrs,nfs_cb_opnum4 * objp)2882 xdr_nfs_cb_opnum4(register XDR *xdrs, nfs_cb_opnum4 *objp)
2883 {
2884
2885 if (!xdr_enum(xdrs, (enum_t *)objp))
2886 return (FALSE);
2887 return (TRUE);
2888 }
2889
2890 bool_t
xdr_nfs_cb_argop4(register XDR * xdrs,nfs_cb_argop4 * objp)2891 xdr_nfs_cb_argop4(register XDR *xdrs, nfs_cb_argop4 *objp)
2892 {
2893
2894 if (!xdr_u_int(xdrs, &objp->argop))
2895 return (FALSE);
2896 switch (objp->argop) {
2897 case OP_CB_GETATTR:
2898 if (!xdr_CB_GETATTR4args(xdrs, &objp->nfs_cb_argop4_u.
2899 opcbgetattr))
2900 return (FALSE);
2901 break;
2902 case OP_CB_RECALL:
2903 if (!xdr_CB_RECALL4args(xdrs, &objp->nfs_cb_argop4_u.
2904 opcbrecall))
2905 return (FALSE);
2906 break;
2907 case OP_CB_ILLEGAL:
2908 break;
2909 default:
2910 return (FALSE);
2911 }
2912 return (TRUE);
2913 }
2914
2915 bool_t
xdr_nfs_cb_resop4(register XDR * xdrs,nfs_cb_resop4 * objp)2916 xdr_nfs_cb_resop4(register XDR *xdrs, nfs_cb_resop4 *objp)
2917 {
2918
2919 if (!xdr_u_int(xdrs, &objp->resop))
2920 return (FALSE);
2921 switch (objp->resop) {
2922 case OP_CB_GETATTR:
2923 if (!xdr_CB_GETATTR4res(xdrs, &objp->nfs_cb_resop4_u.
2924 opcbgetattr))
2925 return (FALSE);
2926 break;
2927 case OP_CB_RECALL:
2928 if (!xdr_CB_RECALL4res(xdrs, &objp->nfs_cb_resop4_u.opcbrecall))
2929 return (FALSE);
2930 break;
2931 case OP_CB_ILLEGAL:
2932 if (!xdr_CB_ILLEGAL4res(xdrs,
2933 &objp->nfs_cb_resop4_u.opcbillegal))
2934 return (FALSE);
2935 break;
2936 default:
2937 return (FALSE);
2938 }
2939 return (TRUE);
2940 }
2941
2942 bool_t
xdr_CB_COMPOUND4args(register XDR * xdrs,CB_COMPOUND4args * objp)2943 xdr_CB_COMPOUND4args(register XDR *xdrs, CB_COMPOUND4args *objp)
2944 {
2945
2946 if (!xdr_utf8string(xdrs, &objp->tag))
2947 return (FALSE);
2948 if (!xdr_uint32_t(xdrs, &objp->minorversion))
2949 return (FALSE);
2950 if (!xdr_uint32_t(xdrs, &objp->callback_ident))
2951 return (FALSE);
2952 if (!xdr_array(xdrs, (char **)&objp->argarray.argarray_val,
2953 (uint_t *)&objp->argarray.argarray_len, ~0,
2954 sizeof (nfs_cb_argop4), (xdrproc_t)xdr_nfs_cb_argop4))
2955 return (FALSE);
2956 return (TRUE);
2957 }
2958
2959 bool_t
xdr_CB_COMPOUND4res(register XDR * xdrs,CB_COMPOUND4res * objp)2960 xdr_CB_COMPOUND4res(register XDR *xdrs, CB_COMPOUND4res *objp)
2961 {
2962
2963 if (!xdr_nfsstat4(xdrs, &objp->status))
2964 return (FALSE);
2965 if (!xdr_utf8string(xdrs, &objp->tag))
2966 return (FALSE);
2967 if (!xdr_array(xdrs, (char **)&objp->resarray.resarray_val,
2968 (uint_t *)&objp->resarray.resarray_len, ~0,
2969 sizeof (nfs_cb_resop4), (xdrproc_t)xdr_nfs_cb_resop4))
2970 return (FALSE);
2971 return (TRUE);
2972 }
2973