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