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