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
xdr_nfs_ftype4(register XDR * xdrs,nfs_ftype4 * objp)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
xdr_nfsstat4(register XDR * xdrs,nfsstat4 * objp)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
xdr_bitmap4(register XDR * xdrs,bitmap4 * objp)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
xdr_offset4(register XDR * xdrs,offset4 * objp)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
xdr_count4(register XDR * xdrs,count4 * objp)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
xdr_length4(register XDR * xdrs,length4 * objp)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
xdr_clientid4(register XDR * xdrs,clientid4 * objp)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
xdr_seqid4(register XDR * xdrs,seqid4 * objp)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
xdr_utf8string(register XDR * xdrs,utf8string * objp)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
xdr_component4(register XDR * xdrs,component4 * objp)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
xdr_pathname4(register XDR * xdrs,pathname4 * objp)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
xdr_nfs_lockid4(register XDR * xdrs,nfs_lockid4 * objp)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
xdr_nfs_cookie4(register XDR * xdrs,nfs_cookie4 * objp)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
xdr_linktext4(register XDR * xdrs,linktext4 * objp)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
xdr_ascii_REQUIRED4(register XDR * xdrs,ascii_REQUIRED4 * objp)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
xdr_sec_oid4(register XDR * xdrs,sec_oid4 * objp)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
xdr_qop4(register XDR * xdrs,qop4 * objp)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
xdr_mode4(register XDR * xdrs,mode4 * objp)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
xdr_changeid4(register XDR * xdrs,changeid4 * objp)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
xdr_verifier4(register XDR * xdrs,verifier4 objp)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
xdr_nfstime4(register XDR * xdrs,nfstime4 * objp)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
xdr_time_how4(register XDR * xdrs,time_how4 * objp)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
xdr_settime4(register XDR * xdrs,settime4 * objp)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
xdr_nfs_fh4(register XDR * xdrs,nfs_fh4 * objp)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
xdr_fsid4(register XDR * xdrs,fsid4 * objp)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
xdr_fs_location4(register XDR * xdrs,fs_location4 * objp)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
xdr_fs_locations4(register XDR * xdrs,fs_locations4 * objp)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
xdr_acetype4(register XDR * xdrs,acetype4 * objp)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
xdr_aceflag4(register XDR * xdrs,aceflag4 * objp)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
xdr_acemask4(register XDR * xdrs,acemask4 * objp)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
xdr_nfsace4(register XDR * xdrs,nfsace4 * objp)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
xdr_specdata4(register XDR * xdrs,specdata4 * objp)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
xdr_fattr4_supported_attrs(register XDR * xdrs,fattr4_supported_attrs * objp)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
xdr_fattr4_type(register XDR * xdrs,fattr4_type * objp)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
xdr_fattr4_fh_expire_type(register XDR * xdrs,fattr4_fh_expire_type * objp)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
xdr_fattr4_change(register XDR * xdrs,fattr4_change * objp)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
xdr_fattr4_size(register XDR * xdrs,fattr4_size * objp)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
xdr_fattr4_link_support(register XDR * xdrs,fattr4_link_support * objp)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
xdr_fattr4_symlink_support(register XDR * xdrs,fattr4_symlink_support * objp)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
xdr_fattr4_named_attr(register XDR * xdrs,fattr4_named_attr * objp)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
xdr_fattr4_fsid(register XDR * xdrs,fattr4_fsid * objp)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
xdr_fattr4_unique_handles(register XDR * xdrs,fattr4_unique_handles * objp)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
xdr_fattr4_lease_time(register XDR * xdrs,fattr4_lease_time * objp)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
xdr_fattr4_rdattr_error(register XDR * xdrs,fattr4_rdattr_error * objp)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
xdr_fattr4_acl(register XDR * xdrs,fattr4_acl * objp)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
xdr_fattr4_aclsupport(register XDR * xdrs,fattr4_aclsupport * objp)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
xdr_fattr4_archive(register XDR * xdrs,fattr4_archive * objp)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
xdr_fattr4_cansettime(register XDR * xdrs,fattr4_cansettime * objp)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
xdr_fattr4_case_insensitive(register XDR * xdrs,fattr4_case_insensitive * objp)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
xdr_fattr4_case_preserving(register XDR * xdrs,fattr4_case_preserving * objp)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
xdr_fattr4_chown_restricted(register XDR * xdrs,fattr4_chown_restricted * objp)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
xdr_fattr4_fileid(register XDR * xdrs,fattr4_fileid * objp)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
xdr_fattr4_files_avail(register XDR * xdrs,fattr4_files_avail * objp)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
xdr_fattr4_filehandle(register XDR * xdrs,fattr4_filehandle * objp)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
xdr_fattr4_files_free(register XDR * xdrs,fattr4_files_free * objp)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
xdr_fattr4_files_total(register XDR * xdrs,fattr4_files_total * objp)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
xdr_fattr4_fs_locations(register XDR * xdrs,fattr4_fs_locations * objp)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
xdr_fattr4_hidden(register XDR * xdrs,fattr4_hidden * objp)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
xdr_fattr4_homogeneous(register XDR * xdrs,fattr4_homogeneous * objp)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
xdr_fattr4_maxfilesize(register XDR * xdrs,fattr4_maxfilesize * objp)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
xdr_fattr4_maxlink(register XDR * xdrs,fattr4_maxlink * objp)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
xdr_fattr4_maxname(register XDR * xdrs,fattr4_maxname * objp)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
xdr_fattr4_maxread(register XDR * xdrs,fattr4_maxread * objp)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
xdr_fattr4_maxwrite(register XDR * xdrs,fattr4_maxwrite * objp)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
xdr_fattr4_mimetype(register XDR * xdrs,fattr4_mimetype * objp)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
xdr_fattr4_mode(register XDR * xdrs,fattr4_mode * objp)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
xdr_fattr4_mounted_on_fileid(register XDR * xdrs,fattr4_mounted_on_fileid * objp)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
xdr_fattr4_no_trunc(register XDR * xdrs,fattr4_no_trunc * objp)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
xdr_fattr4_numlinks(register XDR * xdrs,fattr4_numlinks * objp)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
xdr_fattr4_owner(register XDR * xdrs,fattr4_owner * objp)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
xdr_fattr4_owner_group(register XDR * xdrs,fattr4_owner_group * objp)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
xdr_fattr4_quota_avail_hard(register XDR * xdrs,fattr4_quota_avail_hard * objp)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
xdr_fattr4_quota_avail_soft(register XDR * xdrs,fattr4_quota_avail_soft * objp)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
xdr_fattr4_quota_used(register XDR * xdrs,fattr4_quota_used * objp)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
xdr_fattr4_rawdev(register XDR * xdrs,fattr4_rawdev * objp)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
xdr_fattr4_space_avail(register XDR * xdrs,fattr4_space_avail * objp)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
xdr_fattr4_space_free(register XDR * xdrs,fattr4_space_free * objp)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
xdr_fattr4_space_total(register XDR * xdrs,fattr4_space_total * objp)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
xdr_fattr4_space_used(register XDR * xdrs,fattr4_space_used * objp)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
xdr_fattr4_system(register XDR * xdrs,fattr4_system * objp)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
xdr_fattr4_time_access(register XDR * xdrs,fattr4_time_access * objp)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
xdr_fattr4_time_access_set(register XDR * xdrs,fattr4_time_access_set * objp)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
xdr_fattr4_time_backup(register XDR * xdrs,fattr4_time_backup * objp)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
xdr_fattr4_time_create(register XDR * xdrs,fattr4_time_create * objp)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
xdr_fattr4_time_delta(register XDR * xdrs,fattr4_time_delta * objp)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
xdr_fattr4_time_metadata(register XDR * xdrs,fattr4_time_metadata * objp)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
xdr_fattr4_time_modify(register XDR * xdrs,fattr4_time_modify * objp)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
xdr_fattr4_time_modify_set(register XDR * xdrs,fattr4_time_modify_set * objp)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
xdr_attrlist4(register XDR * xdrs,attrlist4 * objp)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
xdr_fattr4(register XDR * xdrs,fattr4 * objp)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
xdr_change_info4(register XDR * xdrs,change_info4 * objp)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
xdr_clientaddr4(register XDR * xdrs,clientaddr4 * objp)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
xdr_cb_client4(register XDR * xdrs,cb_client4 * objp)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
xdr_stateid4(register XDR * xdrs,stateid4 * objp)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
xdr_nfs_client_id4(register XDR * xdrs,nfs_client_id4 * objp)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
xdr_open_owner4(register XDR * xdrs,open_owner4 * objp)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
xdr_lock_owner4(register XDR * xdrs,lock_owner4 * objp)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
xdr_nfs_lock_type4(register XDR * xdrs,nfs_lock_type4 * objp)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
xdr_ACCESS4args(register XDR * xdrs,ACCESS4args * objp)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
xdr_ACCESS4resok(register XDR * xdrs,ACCESS4resok * objp)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
xdr_ACCESS4res(register XDR * xdrs,ACCESS4res * objp)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
xdr_CLOSE4args(register XDR * xdrs,CLOSE4args * objp)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
xdr_CLOSE4res(register XDR * xdrs,CLOSE4res * objp)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
xdr_COMMIT4args(register XDR * xdrs,COMMIT4args * objp)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
xdr_COMMIT4resok(register XDR * xdrs,COMMIT4resok * objp)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
xdr_COMMIT4res(register XDR * xdrs,COMMIT4res * objp)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
xdr_createtype4(register XDR * xdrs,createtype4 * objp)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
xdr_CREATE4args(register XDR * xdrs,CREATE4args * objp)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
xdr_CREATE4resok(register XDR * xdrs,CREATE4resok * objp)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
xdr_CREATE4res(register XDR * xdrs,CREATE4res * objp)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
xdr_DELEGPURGE4args(register XDR * xdrs,DELEGPURGE4args * objp)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
xdr_DELEGPURGE4res(register XDR * xdrs,DELEGPURGE4res * objp)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
xdr_DELEGRETURN4args(register XDR * xdrs,DELEGRETURN4args * objp)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
xdr_DELEGRETURN4res(register XDR * xdrs,DELEGRETURN4res * objp)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
xdr_GETATTR4args(register XDR * xdrs,GETATTR4args * objp)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
xdr_GETATTR4resok(register XDR * xdrs,GETATTR4resok * objp)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
xdr_GETATTR4res(register XDR * xdrs,GETATTR4res * objp)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
xdr_GETFH4resok(register XDR * xdrs,GETFH4resok * objp)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
xdr_GETFH4res(register XDR * xdrs,GETFH4res * objp)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
xdr_LINK4args(register XDR * xdrs,LINK4args * objp)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
xdr_LINK4resok(register XDR * xdrs,LINK4resok * objp)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
xdr_LINK4res(register XDR * xdrs,LINK4res * objp)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
xdr_open_to_lock_owner4(register XDR * xdrs,open_to_lock_owner4 * objp)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
xdr_exist_lock_owner4(register XDR * xdrs,exist_lock_owner4 * objp)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
xdr_locker4(register XDR * xdrs,locker4 * objp)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
xdr_LOCK4args(register XDR * xdrs,LOCK4args * objp)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
xdr_LOCK4denied(register XDR * xdrs,LOCK4denied * objp)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
xdr_LOCK4resok(register XDR * xdrs,LOCK4resok * objp)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
xdr_LOCK4res(register XDR * xdrs,LOCK4res * objp)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
xdr_LOCKT4args(register XDR * xdrs,LOCKT4args * objp)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
xdr_LOCKT4res(register XDR * xdrs,LOCKT4res * objp)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
xdr_LOCKU4args(register XDR * xdrs,LOCKU4args * objp)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
xdr_LOCKU4res(register XDR * xdrs,LOCKU4res * objp)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
xdr_LOOKUP4args(register XDR * xdrs,LOOKUP4args * objp)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
xdr_LOOKUP4res(register XDR * xdrs,LOOKUP4res * objp)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
xdr_LOOKUPP4res(register XDR * xdrs,LOOKUPP4res * objp)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
xdr_NVERIFY4args(register XDR * xdrs,NVERIFY4args * objp)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
xdr_NVERIFY4res(register XDR * xdrs,NVERIFY4res * objp)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
xdr_createmode4(register XDR * xdrs,createmode4 * objp)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
xdr_createhow4(register XDR * xdrs,createhow4 * objp)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
xdr_opentype4(register XDR * xdrs,opentype4 * objp)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
xdr_openflag4(register XDR * xdrs,openflag4 * objp)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
xdr_limit_by4(register XDR * xdrs,limit_by4 * objp)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
xdr_nfs_modified_limit4(register XDR * xdrs,nfs_modified_limit4 * objp)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
xdr_nfs_space_limit4(register XDR * xdrs,nfs_space_limit4 * objp)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
xdr_open_delegation_type4(register XDR * xdrs,open_delegation_type4 * objp)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
xdr_open_claim_type4(register XDR * xdrs,open_claim_type4 * objp)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
xdr_open_claim_delegate_cur4(register XDR * xdrs,open_claim_delegate_cur4 * objp)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
xdr_open_claim4(register XDR * xdrs,open_claim4 * objp)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
xdr_OPEN4args(register XDR * xdrs,OPEN4args * objp)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
xdr_open_read_delegation4(register XDR * xdrs,open_read_delegation4 * objp)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
xdr_open_write_delegation4(register XDR * xdrs,open_write_delegation4 * objp)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
xdr_open_delegation4(register XDR * xdrs,open_delegation4 * objp)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
xdr_OPEN4resok(register XDR * xdrs,OPEN4resok * objp)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
xdr_OPEN4res(register XDR * xdrs,OPEN4res * objp)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
xdr_OPENATTR4args(register XDR * xdrs,OPENATTR4args * objp)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
xdr_OPENATTR4res(register XDR * xdrs,OPENATTR4res * objp)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
xdr_OPEN_CONFIRM4args(register XDR * xdrs,OPEN_CONFIRM4args * objp)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
xdr_OPEN_CONFIRM4resok(register XDR * xdrs,OPEN_CONFIRM4resok * objp)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
xdr_OPEN_CONFIRM4res(register XDR * xdrs,OPEN_CONFIRM4res * objp)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
xdr_OPEN_DOWNGRADE4args(register XDR * xdrs,OPEN_DOWNGRADE4args * objp)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
xdr_OPEN_DOWNGRADE4resok(register XDR * xdrs,OPEN_DOWNGRADE4resok * objp)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
xdr_OPEN_DOWNGRADE4res(register XDR * xdrs,OPEN_DOWNGRADE4res * objp)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
xdr_PUTFH4args(register XDR * xdrs,PUTFH4args * objp)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
xdr_PUTFH4res(register XDR * xdrs,PUTFH4res * objp)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
xdr_PUTPUBFH4res(register XDR * xdrs,PUTPUBFH4res * objp)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
xdr_PUTROOTFH4res(register XDR * xdrs,PUTROOTFH4res * objp)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
xdr_READ4args(register XDR * xdrs,READ4args * objp)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
xdr_READ4resok(register XDR * xdrs,READ4resok * objp)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
xdr_READ4res(register XDR * xdrs,READ4res * objp)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
xdr_READDIR4args(register XDR * xdrs,READDIR4args * objp)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
xdr_entry4(register XDR * xdrs,entry4 * objp)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 (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
xdr_dirlist4(register XDR * xdrs,dirlist4 * objp)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
xdr_READDIR4resok(register XDR * xdrs,READDIR4resok * objp)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
xdr_READDIR4res(register XDR * xdrs,READDIR4res * objp)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
xdr_READLINK4resok(register XDR * xdrs,READLINK4resok * objp)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
xdr_READLINK4res(register XDR * xdrs,READLINK4res * objp)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
xdr_REMOVE4args(register XDR * xdrs,REMOVE4args * objp)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
xdr_REMOVE4resok(register XDR * xdrs,REMOVE4resok * objp)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
xdr_REMOVE4res(register XDR * xdrs,REMOVE4res * objp)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
xdr_RENAME4args(register XDR * xdrs,RENAME4args * objp)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
xdr_RENAME4resok(register XDR * xdrs,RENAME4resok * objp)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
xdr_RENAME4res(register XDR * xdrs,RENAME4res * objp)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
xdr_RENEW4args(register XDR * xdrs,RENEW4args * objp)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
xdr_RENEW4res(register XDR * xdrs,RENEW4res * objp)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
xdr_RESTOREFH4res(register XDR * xdrs,RESTOREFH4res * objp)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
xdr_SAVEFH4res(register XDR * xdrs,SAVEFH4res * objp)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
xdr_SECINFO4args(register XDR * xdrs,SECINFO4args * objp)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
xdr_rpc_gss_svc_t(register XDR * xdrs,rpc_gss_svc_t * objp)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
xdr_rpcsec_gss_info(register XDR * xdrs,rpcsec_gss_info * objp)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
xdr_secinfo4(register XDR * xdrs,secinfo4 * objp)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
xdr_SECINFO4resok(register XDR * xdrs,SECINFO4resok * objp)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
xdr_SECINFO4res(register XDR * xdrs,SECINFO4res * objp)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
xdr_SETATTR4args(register XDR * xdrs,SETATTR4args * objp)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
xdr_SETATTR4res(register XDR * xdrs,SETATTR4res * objp)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
xdr_SETCLIENTID4args(register XDR * xdrs,SETCLIENTID4args * objp)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
xdr_SETCLIENTID4resok(register XDR * xdrs,SETCLIENTID4resok * objp)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
xdr_SETCLIENTID4res(register XDR * xdrs,SETCLIENTID4res * objp)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
xdr_SETCLIENTID_CONFIRM4args(register XDR * xdrs,SETCLIENTID_CONFIRM4args * objp)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
xdr_SETCLIENTID_CONFIRM4res(register XDR * xdrs,SETCLIENTID_CONFIRM4res * objp)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
xdr_VERIFY4args(register XDR * xdrs,VERIFY4args * objp)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
xdr_VERIFY4res(register XDR * xdrs,VERIFY4res * objp)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
xdr_stable_how4(register XDR * xdrs,stable_how4 * objp)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
xdr_WRITE4args(register XDR * xdrs,WRITE4args * objp)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
xdr_WRITE4resok(register XDR * xdrs,WRITE4resok * objp)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
xdr_WRITE4res(register XDR * xdrs,WRITE4res * objp)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
xdr_RELEASE_LOCKOWNER4args(register XDR * xdrs,RELEASE_LOCKOWNER4args * objp)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
xdr_RELEASE_LOCKOWNER4res(register XDR * xdrs,RELEASE_LOCKOWNER4res * objp)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
xdr_ILLEGAL4res(register XDR * xdrs,ILLEGAL4res * objp)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
xdr_nfs_opnum4(register XDR * xdrs,nfs_opnum4 * objp)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
xdr_nfs_argop4(register XDR * xdrs,nfs_argop4 * objp)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
xdr_nfs_resop4(register XDR * xdrs,nfs_resop4 * objp)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
xdr_COMPOUND4args(register XDR * xdrs,COMPOUND4args * objp)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
xdr_COMPOUND4res(register XDR * xdrs,COMPOUND4res * objp)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
xdr_CB_GETATTR4args(register XDR * xdrs,CB_GETATTR4args * objp)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
xdr_CB_GETATTR4resok(register XDR * xdrs,CB_GETATTR4resok * objp)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
xdr_CB_GETATTR4res(register XDR * xdrs,CB_GETATTR4res * objp)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
xdr_CB_RECALL4args(register XDR * xdrs,CB_RECALL4args * objp)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
xdr_CB_RECALL4res(register XDR * xdrs,CB_RECALL4res * objp)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
xdr_CB_ILLEGAL4res(register XDR * xdrs,CB_ILLEGAL4res * objp)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
xdr_nfs_cb_opnum4(register XDR * xdrs,nfs_cb_opnum4 * objp)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
xdr_nfs_cb_argop4(register XDR * xdrs,nfs_cb_argop4 * objp)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
xdr_nfs_cb_resop4(register XDR * xdrs,nfs_cb_resop4 * objp)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
xdr_CB_COMPOUND4args(register XDR * xdrs,CB_COMPOUND4args * objp)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
xdr_CB_COMPOUND4res(register XDR * xdrs,CB_COMPOUND4res * objp)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 }
2985