Merge branch 'vendor/GCC50'
[dragonfly.git] / contrib / amd / libamu / xdr_func.c
1 /*
2  * Copyright (c) 1997-1999 Erez Zadok
3  * Copyright (c) 1990 Jan-Simon Pendry
4  * Copyright (c) 1990 Imperial College of Science, Technology & Medicine
5  * Copyright (c) 1990 The Regents of the University of California.
6  * All rights reserved.
7  *
8  * This code is derived from software contributed to Berkeley by
9  * Jan-Simon Pendry at Imperial College, London.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in the
18  *    documentation and/or other materials provided with the distribution.
19  * 3. All advertising materials mentioning features or use of this software
20  *    must display the following acknowledgment:
21  *      This product includes software developed by the University of
22  *      California, Berkeley and its contributors.
23  * 4. Neither the name of the University nor the names of its contributors
24  *    may be used to endorse or promote products derived from this software
25  *    without specific prior written permission.
26  *
27  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
28  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
31  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
32  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
33  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
34  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
35  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
36  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
37  * SUCH DAMAGE.
38  *
39  *      %W% (Berkeley) %G%
40  *
41  * $Id: xdr_func.c,v 1.2 1999/01/10 21:54:39 ezk Exp $
42  *
43  */
44
45 /*
46  * Complete list of all possible xdr functions which may be needed.
47  */
48 #ifdef HAVE_CONFIG_H
49 # include <config.h>
50 #endif /* HAVE_CONFIG_H */
51 #include <am_defs.h>
52 #include <amu.h>
53
54 /*
55  * MACROS:
56  */
57 #ifdef HAVE_FS_AUTOFS
58 # ifndef A_MAXNAME
59 #  define A_MAXNAME 255
60 # endif /* not A_MAXNAME */
61 # ifndef A_MAXOPTS
62 #  define A_MAXOPTS 255
63 # endif /* not A_MAXOPTS */
64 # ifndef A_MAXPATH
65 #  define A_MAXPATH 1024
66 # endif /* not A_MAXPATH */
67 #endif /* HAVE_FS_AUTOFS */
68
69 /* forward definitions, are they needed? */
70 extern bool_t xdr_exportnode(XDR *xdrs, exportnode *objp);
71 extern bool_t xdr_groupnode(XDR *xdrs, groupnode *objp);
72 extern bool_t xdr_name(XDR *xdrs, name *objp);
73
74
75 #ifndef HAVE_XDR_ATTRSTAT
76 bool_t
77 xdr_attrstat(XDR *xdrs, nfsattrstat *objp)
78 {
79 #ifdef DEBUG
80   amuDebug(D_TRACE)
81     plog(XLOG_DEBUG, "xdr_attrstat:");
82 #endif /* DEBUG */
83
84   if (!xdr_nfsstat(xdrs, &objp->ns_status)) {
85     return (FALSE);
86   }
87   switch (objp->ns_status) {
88   case NFS_OK:
89     if (!xdr_fattr(xdrs, &objp->ns_u.ns_attr_u)) {
90       return (FALSE);
91     }
92     break;
93   default:
94     break;
95   }
96   return (TRUE);
97 }
98 #endif /* not HAVE_XDR_ATTRSTAT */
99
100
101 #ifndef HAVE_XDR_CREATEARGS
102 bool_t
103 xdr_createargs(XDR *xdrs, nfscreateargs *objp)
104 {
105 #ifdef DEBUG
106   amuDebug(D_TRACE)
107     plog(XLOG_DEBUG, "xdr_createargs:");
108 #endif /* DEBUG */
109
110   if (!xdr_diropargs(xdrs, &objp->ca_where)) {
111     return (FALSE);
112   }
113   if (!xdr_sattr(xdrs, &objp->ca_attributes)) {
114     return (FALSE);
115   }
116   return (TRUE);
117 }
118 #endif /* not HAVE_XDR_CREATEARGS */
119
120
121 #ifndef HAVE_XDR_DIRLIST
122 bool_t
123 xdr_dirlist(XDR *xdrs, nfsdirlist *objp)
124 {
125 #ifdef DEBUG
126   amuDebug(D_TRACE)
127     plog(XLOG_DEBUG, "xdr_dirlist:");
128 #endif /* DEBUG */
129
130   if (!xdr_pointer(xdrs, (char **) &objp->dl_entries, sizeof(nfsentry), (XDRPROC_T_TYPE) xdr_entry)) {
131     return (FALSE);
132   }
133   if (!xdr_bool(xdrs, &objp->dl_eof)) {
134     return (FALSE);
135   }
136   return (TRUE);
137 }
138 #endif /* not HAVE_XDR_DIRLIST */
139
140
141 #ifndef HAVE_XDR_DIROPARGS
142 bool_t
143 xdr_diropargs(XDR *xdrs, nfsdiropargs *objp)
144 {
145 #ifdef DEBUG
146   amuDebug(D_TRACE)
147     plog(XLOG_DEBUG, "xdr_diropargs:");
148 #endif /* DEBUG */
149
150   if (!xdr_nfs_fh(xdrs, &objp->da_fhandle)) {
151     return (FALSE);
152   }
153   if (!xdr_filename(xdrs, &objp->da_name)) {
154     return (FALSE);
155   }
156   return (TRUE);
157 }
158 #endif /* not HAVE_XDR_DIROPARGS */
159
160
161 #ifndef HAVE_XDR_DIROPOKRES
162 bool_t
163 xdr_diropokres(XDR *xdrs, nfsdiropokres *objp)
164 {
165 #ifdef DEBUG
166   amuDebug(D_TRACE)
167     plog(XLOG_DEBUG, "xdr_diropokres:");
168 #endif /* DEBUG */
169
170   if (!xdr_nfs_fh(xdrs, &objp->drok_fhandle)) {
171     return (FALSE);
172   }
173   if (!xdr_fattr(xdrs, &objp->drok_attributes)) {
174     return (FALSE);
175   }
176   return (TRUE);
177 }
178 #endif /* not HAVE_XDR_DIROPOKRES */
179
180
181 #ifndef HAVE_XDR_DIROPRES
182 bool_t
183 xdr_diropres(XDR *xdrs, nfsdiropres *objp)
184 {
185 #ifdef DEBUG
186   amuDebug(D_TRACE)
187     plog(XLOG_DEBUG, "xdr_diropres:");
188 #endif /* DEBUG */
189
190   if (!xdr_nfsstat(xdrs, &objp->dr_status)) {
191     return (FALSE);
192   }
193   switch (objp->dr_status) {
194   case NFS_OK:
195     if (!xdr_diropokres(xdrs, &objp->dr_u.dr_drok_u)) {
196       return (FALSE);
197     }
198     break;
199   default:
200     break;
201   }
202   return (TRUE);
203 }
204 #endif /* not HAVE_XDR_DIROPRES */
205
206
207 #ifndef HAVE_XDR_DIRPATH
208 bool_t
209 xdr_dirpath(XDR *xdrs, dirpath *objp)
210 {
211 #ifdef DEBUG
212   amuDebug(D_TRACE)
213     plog(XLOG_DEBUG, "xdr_dirpath:");
214 #endif /* DEBUG */
215
216   if (!xdr_string(xdrs, objp, MNTPATHLEN)) {
217     return (FALSE);
218   }
219   return (TRUE);
220 }
221 #endif /* not HAVE_XDR_DIRPATH */
222
223
224 #ifndef HAVE_XDR_ENTRY
225 bool_t
226 xdr_entry(XDR *xdrs, nfsentry *objp)
227 {
228 #ifdef DEBUG
229   amuDebug(D_TRACE)
230     plog(XLOG_DEBUG, "xdr_entry:");
231 #endif /* DEBUG */
232
233   if (!xdr_u_int(xdrs, &objp->ne_fileid)) {
234     return (FALSE);
235   }
236   if (!xdr_filename(xdrs, &objp->ne_name)) {
237     return (FALSE);
238   }
239   if (!xdr_nfscookie(xdrs, objp->ne_cookie)) {
240     return (FALSE);
241   }
242   if (!xdr_pointer(xdrs, (char **) &objp->ne_nextentry, sizeof(nfsentry), (XDRPROC_T_TYPE) xdr_entry)) {
243     return (FALSE);
244   }
245   return (TRUE);
246 }
247 #endif /* not HAVE_XDR_ENTRY */
248
249
250 #ifndef HAVE_XDR_EXPORTNODE
251 bool_t
252 xdr_exportnode(XDR *xdrs, exportnode *objp)
253 {
254 #ifdef DEBUG
255   amuDebug(D_TRACE)
256     plog(XLOG_DEBUG, "xdr_exportnode:");
257 #endif /* DEBUG */
258
259   if (!xdr_dirpath(xdrs, &objp->ex_dir)) {
260     return (FALSE);
261   }
262   /*
263    * This cast to (groups) is needed for Irix6.  If you change it, it
264    * may produce a warning/error on other systems.
265    */
266   if (!xdr_groups(xdrs, (groups) &objp->ex_groups)) {
267     return (FALSE);
268   }
269   if (!xdr_exports(xdrs, &objp->ex_next)) {
270     return (FALSE);
271   }
272   return (TRUE);
273 }
274 #endif /* not HAVE_XDR_EXPORTNODE */
275
276
277 #ifndef HAVE_XDR_EXPORTS
278 bool_t
279 xdr_exports(XDR *xdrs, exports *objp)
280 {
281 #ifdef DEBUG
282   amuDebug(D_TRACE)
283     plog(XLOG_DEBUG, "xdr_exports:");
284 #endif /* DEBUG */
285
286   if (!xdr_pointer(xdrs, (char **) objp, sizeof(exportnode), (XDRPROC_T_TYPE) xdr_exportnode)) {
287     return (FALSE);
288   }
289   return (TRUE);
290 }
291 #endif /* not HAVE_XDR_EXPORTS */
292
293
294 #ifndef HAVE_XDR_FATTR
295 bool_t
296 xdr_fattr(XDR *xdrs, nfsfattr *objp)
297 {
298 #ifdef DEBUG
299   amuDebug(D_TRACE)
300     plog(XLOG_DEBUG, "xdr_fattr:");
301 #endif /* DEBUG */
302
303   if (!xdr_ftype(xdrs, &objp->na_type)) {
304     return (FALSE);
305   }
306   if (!xdr_u_int(xdrs, &objp->na_mode)) {
307     return (FALSE);
308   }
309   if (!xdr_u_int(xdrs, &objp->na_nlink)) {
310     return (FALSE);
311   }
312   if (!xdr_u_int(xdrs, &objp->na_uid)) {
313     return (FALSE);
314   }
315   if (!xdr_u_int(xdrs, &objp->na_gid)) {
316     return (FALSE);
317   }
318   if (!xdr_u_int(xdrs, &objp->na_size)) {
319     return (FALSE);
320   }
321   if (!xdr_u_int(xdrs, &objp->na_blocksize)) {
322     return (FALSE);
323   }
324   if (!xdr_u_int(xdrs, &objp->na_rdev)) {
325     return (FALSE);
326   }
327   if (!xdr_u_int(xdrs, &objp->na_blocks)) {
328     return (FALSE);
329   }
330   if (!xdr_u_int(xdrs, &objp->na_fsid)) {
331     return (FALSE);
332   }
333   if (!xdr_u_int(xdrs, &objp->na_fileid)) {
334     return (FALSE);
335   }
336   if (!xdr_nfstime(xdrs, &objp->na_atime)) {
337     return (FALSE);
338   }
339   if (!xdr_nfstime(xdrs, &objp->na_mtime)) {
340     return (FALSE);
341   }
342   if (!xdr_nfstime(xdrs, &objp->na_ctime)) {
343     return (FALSE);
344   }
345   return (TRUE);
346 }
347 #endif /* not HAVE_XDR_FATTR */
348
349
350 #ifndef HAVE_XDR_FHANDLE
351 bool_t
352 xdr_fhandle(XDR *xdrs, fhandle objp)
353 {
354 #ifdef DEBUG
355   amuDebug(D_TRACE)
356     plog(XLOG_DEBUG, "xdr_fhandle:");
357 #endif /* DEBUG */
358
359   if (!xdr_opaque(xdrs, objp, NFS_FHSIZE)) {
360     return (FALSE);
361   }
362   return (TRUE);
363 }
364 #endif /* not HAVE_XDR_FHANDLE */
365
366
367 #ifndef HAVE_XDR_FHSTATUS
368 bool_t
369 xdr_fhstatus(XDR *xdrs, fhstatus *objp)
370 {
371 #ifdef DEBUG
372   amuDebug(D_TRACE)
373     plog(XLOG_DEBUG, "xdr_fhstatus:");
374 #endif /* DEBUG */
375
376   if (!xdr_u_int(xdrs, &objp->fhs_status)) {
377     return (FALSE);
378   }
379   if (objp->fhs_status == 0 && !xdr_fhandle(xdrs, objp->fhs_fh)) {
380     return (FALSE);
381   }
382   return (TRUE);
383 }
384 #endif /* not HAVE_XDR_FHSTATUS */
385
386
387 #ifndef HAVE_XDR_FILENAME
388 bool_t
389 xdr_filename(XDR *xdrs, filename *objp)
390 {
391 #ifdef DEBUG
392   amuDebug(D_TRACE)
393     plog(XLOG_DEBUG, "xdr_filename:");
394 #endif /* DEBUG */
395
396   if (!xdr_string(xdrs, objp, NFS_MAXNAMLEN)) {
397     return (FALSE);
398   }
399   return (TRUE);
400 }
401 #endif /* not HAVE_XDR_FILENAME */
402
403
404 #ifndef HAVE_XDR_FTYPE
405 bool_t
406 xdr_ftype(XDR *xdrs, nfsftype *objp)
407 {
408 #ifdef DEBUG
409   amuDebug(D_TRACE)
410     plog(XLOG_DEBUG, "xdr_ftype:");
411 #endif /* DEBUG */
412
413   if (!xdr_enum(xdrs, (enum_t *) objp)) {
414     return (FALSE);
415   }
416   return (TRUE);
417 }
418 #endif /* not HAVE_XDR_FTYPE */
419
420
421 #ifndef HAVE_XDR_GROUPNODE
422 bool_t
423 xdr_groupnode(XDR *xdrs, groupnode *objp)
424 {
425 #ifdef DEBUG
426   amuDebug(D_TRACE)
427     plog(XLOG_DEBUG, "xdr_groupnode:");
428 #endif /* DEBUG */
429
430   if (!xdr_name(xdrs, &objp->gr_name)) {
431     return (FALSE);
432   }
433   /*
434    * This cast to (groups) is needed for Irix6.  If you change it, it
435    * may produce a warning/error on other systems.
436    */
437   if (!xdr_groups(xdrs, (groups) &objp->gr_next)) {
438     return (FALSE);
439   }
440   return (TRUE);
441 }
442 #endif /* not HAVE_XDR_GROUPNODE */
443
444
445 #ifndef HAVE_XDR_GROUPS
446 bool_t
447 xdr_groups(XDR *xdrs, groups objp)
448 {
449 #ifdef DEBUG
450   amuDebug(D_TRACE)
451     plog(XLOG_DEBUG, "xdr_groups:");
452 #endif /* DEBUG */
453
454   if (!xdr_pointer(xdrs, (char **) objp, sizeof(groupnode), (XDRPROC_T_TYPE) xdr_groupnode)) {
455     return (FALSE);
456   }
457   return (TRUE);
458 }
459 #endif /* not HAVE_XDR_GROUPS */
460
461
462 #ifndef HAVE_XDR_LINKARGS
463 bool_t
464 xdr_linkargs(XDR *xdrs, nfslinkargs *objp)
465 {
466 #ifdef DEBUG
467   amuDebug(D_TRACE)
468     plog(XLOG_DEBUG, "xdr_linkargs:");
469 #endif /* DEBUG */
470
471   if (!xdr_nfs_fh(xdrs, &objp->la_fhandle)) {
472     return (FALSE);
473   }
474   if (!xdr_diropargs(xdrs, &objp->la_to)) {
475     return (FALSE);
476   }
477   return (TRUE);
478 }
479 #endif /* not HAVE_XDR_LINKARGS */
480
481
482 #ifndef HAVE_XDR_MOUNTBODY
483 bool_t
484 xdr_mountbody(XDR *xdrs, mountbody *objp)
485 {
486 #ifdef DEBUG
487   amuDebug(D_TRACE)
488     plog(XLOG_DEBUG, "xdr_mountbody:");
489 #endif /* DEBUG */
490
491   if (!xdr_name(xdrs, &objp->ml_hostname)) {
492     return (FALSE);
493   }
494   if (!xdr_dirpath(xdrs, &objp->ml_directory)) {
495     return (FALSE);
496   }
497   if (!xdr_mountlist(xdrs, &objp->ml_next)) {
498     return (FALSE);
499   }
500   return (TRUE);
501 }
502 #endif /* not HAVE_XDR_MOUNTBODY */
503
504
505 #ifndef HAVE_XDR_MOUNTLIST
506 bool_t
507 xdr_mountlist(XDR *xdrs, mountlist *objp)
508 {
509 #ifdef DEBUG
510   amuDebug(D_TRACE)
511     plog(XLOG_DEBUG, "xdr_mountlist:");
512 #endif /* DEBUG */
513
514   if (!xdr_pointer(xdrs, (char **) objp, sizeof(mountbody), (XDRPROC_T_TYPE) xdr_mountbody)) {
515     return (FALSE);
516   }
517   return (TRUE);
518 }
519 #endif /* not HAVE_XDR_MOUNTLIST */
520
521
522 #if defined(HAVE_FS_NFS3) && !defined(HAVE_XDR_MOUNTRES3)
523 /*
524  * This ifdef is a hack: this whole file needs to be compiled
525  * only if the system has NFS V3 and does not have the xdr_mountres3
526  * function.  Autoconf should pick this source file to compile only
527  * if these two conditions apply.
528  */
529
530 bool_t
531 xdr_fhandle3(XDR *xdrs, fhandle3 *objp)
532 {
533 #ifdef DEBUG
534   amuDebug(D_TRACE)
535     plog(XLOG_DEBUG, "xdr_fhandle3:");
536 #endif /* DEBUG */
537
538   if (!xdr_bytes(xdrs,
539                  (char **) &objp->fhandle3_val,
540                  (u_int *) &objp->fhandle3_len,
541                  FHSIZE3))
542     return (FALSE);
543   return (TRUE);
544 }
545
546
547 bool_t
548 xdr_mountstat3(XDR *xdrs, mountstat3 *objp)
549 {
550 #ifdef DEBUG
551   amuDebug(D_TRACE)
552     plog(XLOG_DEBUG, "xdr_mountstat3:");
553 #endif /* DEBUG */
554
555   if (!xdr_enum(xdrs, (enum_t *)objp))
556     return (FALSE);
557   return (TRUE);
558 }
559
560
561 bool_t
562 xdr_mountres3_ok(XDR *xdrs, mountres3_ok *objp)
563 {
564 #ifdef DEBUG
565   amuDebug(D_TRACE)
566     plog(XLOG_DEBUG, "xdr_mountres3_ok:");
567 #endif /* DEBUG */
568
569   if (!xdr_fhandle3(xdrs, &objp->fhandle))
570     return (FALSE);
571   if (!xdr_array(xdrs,
572                  (char **)&objp->auth_flavors.auth_flavors_val,
573                  (u_int *) &objp->auth_flavors.auth_flavors_len,
574                  ~0,
575                  sizeof (int),
576                  (xdrproc_t) xdr_int))
577     return (FALSE);
578   return (TRUE);
579 }
580
581
582 bool_t
583 xdr_mountres3(XDR *xdrs, mountres3 *objp)
584 {
585 #ifdef DEBUG
586   amuDebug(D_TRACE)
587     plog(XLOG_DEBUG, "xdr_mountres3:");
588 #endif /* DEBUG */
589
590   if (!xdr_mountstat3(xdrs, &objp->fhs_status))
591     return (FALSE);
592
593   if (objp->fhs_status == 0) {  /* 0 == MNT_OK or MNT3_OK */
594     if (!xdr_mountres3_ok(xdrs, &objp->mountres3_u.mountinfo))
595       return (FALSE);
596   }
597   return (TRUE);
598 }
599 #endif /* defined(HAVE_FS_NFS3) && !defined(HAVE_XDR_MOUNTRES3) */
600
601
602 #ifndef HAVE_XDR_NAME
603 bool_t
604 xdr_name(XDR *xdrs, name *objp)
605 {
606 #ifdef DEBUG
607   amuDebug(D_TRACE)
608     plog(XLOG_DEBUG, "xdr_name:");
609 #endif /* DEBUG */
610
611   if (!xdr_string(xdrs, objp, MNTNAMLEN)) {
612     return (FALSE);
613   }
614   return (TRUE);
615 }
616 #endif /* not HAVE_XDR_NAME */
617
618
619 #ifndef HAVE_XDR_NFS_FH
620 bool_t
621 xdr_nfs_fh(XDR *xdrs, am_nfs_fh *objp)
622 {
623 #ifdef DEBUG
624   amuDebug(D_TRACE)
625     plog(XLOG_DEBUG, "xdr_nfs_fh:");
626 #endif /* DEBUG */
627
628   if (!xdr_opaque(xdrs, (caddr_t) objp->fh_data, NFS_FHSIZE)) {
629     return (FALSE);
630   }
631   return (TRUE);
632 }
633 #endif /* not HAVE_XDR_NFS_FH */
634
635
636 #ifndef HAVE_XDR_NFSCOOKIE
637 bool_t
638 xdr_nfscookie(XDR *xdrs, nfscookie objp)
639 {
640 #ifdef DEBUG
641   amuDebug(D_TRACE)
642     plog(XLOG_DEBUG, "xdr_nfscookie:");
643 #endif /* DEBUG */
644
645   if (!xdr_opaque(xdrs, objp, NFS_COOKIESIZE)) {
646     return (FALSE);
647   }
648   return (TRUE);
649 }
650 #endif /* not HAVE_XDR_NFSCOOKIE */
651
652
653 #ifndef HAVE_XDR_NFSPATH
654 bool_t
655 xdr_nfspath(XDR *xdrs, nfspath *objp)
656 {
657 #ifdef DEBUG
658   amuDebug(D_TRACE)
659     plog(XLOG_DEBUG, "xdr_nfspath:");
660 #endif /* DEBUG */
661
662   if (!xdr_string(xdrs, objp, NFS_MAXPATHLEN)) {
663     return (FALSE);
664   }
665   return (TRUE);
666 }
667 #endif /* not HAVE_XDR_NFSPATH */
668
669
670 #ifndef HAVE_XDR_NFSSTAT
671 bool_t
672 xdr_nfsstat(XDR *xdrs, nfsstat *objp)
673 {
674 #ifdef DEBUG
675   amuDebug(D_TRACE)
676     plog(XLOG_DEBUG, "xdr_nfsstat:");
677 #endif /* DEBUG */
678
679   if (!xdr_enum(xdrs, (enum_t *) objp)) {
680     return (FALSE);
681   }
682   return (TRUE);
683 }
684 #endif /* not HAVE_XDR_NFSSTAT */
685
686
687 #ifndef HAVE_XDR_NFSTIME
688 bool_t
689 xdr_nfstime(XDR *xdrs, nfstime *objp)
690 {
691 #ifdef DEBUG
692   amuDebug(D_TRACE)
693     plog(XLOG_DEBUG, "xdr_nfstime:");
694 #endif /* DEBUG */
695
696   if (!xdr_u_int(xdrs, (u_int *) &objp->nt_seconds)) {
697     return (FALSE);
698   }
699   if (!xdr_u_int(xdrs, (u_int *) &objp->nt_useconds)) {
700     return (FALSE);
701   }
702   return (TRUE);
703 }
704 #endif /* not HAVE_XDR_NFSTIME */
705
706
707 #ifndef HAVE_XDR_POINTER
708 bool_t
709 xdr_pointer(register XDR *xdrs, char **objpp, u_int obj_size, XDRPROC_T_TYPE xdr_obj)
710 {
711 #ifdef DEBUG
712   amuDebug(D_TRACE)
713     plog(XLOG_DEBUG, "xdr_pointer:");
714 #endif /* DEBUG */
715
716
717   bool_t more_data;
718
719   more_data = (*objpp != NULL);
720   if (!xdr_bool(xdrs, &more_data)) {
721     return (FALSE);
722   }
723   if (!more_data) {
724     *objpp = NULL;
725     return (TRUE);
726   }
727
728   return (xdr_reference(xdrs, objpp, obj_size, xdr_obj));
729 }
730 #endif /* not HAVE_XDR_POINTER */
731
732
733 #ifndef HAVE_XDR_READARGS
734 bool_t
735 xdr_readargs(XDR *xdrs, nfsreadargs *objp)
736 {
737 #ifdef DEBUG
738   amuDebug(D_TRACE)
739     plog(XLOG_DEBUG, "xdr_readargs:");
740 #endif /* DEBUG */
741
742   if (!xdr_nfs_fh(xdrs, &objp->ra_fhandle)) {
743     return (FALSE);
744   }
745   if (!xdr_u_int(xdrs, &objp->ra_offset)) {
746     return (FALSE);
747   }
748   if (!xdr_u_int(xdrs, &objp->ra_count)) {
749     return (FALSE);
750   }
751   if (!xdr_u_int(xdrs, &objp->ra_totalcount)) {
752     return (FALSE);
753   }
754   return (TRUE);
755 }
756 #endif /* not HAVE_XDR_READARGS */
757
758
759 #ifndef HAVE_XDR_READDIRARGS
760 bool_t
761 xdr_readdirargs(XDR *xdrs, nfsreaddirargs *objp)
762 {
763 #ifdef DEBUG
764   amuDebug(D_TRACE)
765     plog(XLOG_DEBUG, "xdr_readdirargs:");
766 #endif /* DEBUG */
767
768   if (!xdr_nfs_fh(xdrs, &objp->rda_fhandle)) {
769     return (FALSE);
770   }
771   if (!xdr_nfscookie(xdrs, objp->rda_cookie)) {
772     return (FALSE);
773   }
774   if (!xdr_u_int(xdrs, &objp->rda_count)) {
775     return (FALSE);
776   }
777   return (TRUE);
778 }
779 #endif /* not HAVE_XDR_READDIRARGS */
780
781
782 #ifndef HAVE_XDR_READDIRRES
783 bool_t
784 xdr_readdirres(XDR *xdrs, nfsreaddirres *objp)
785 {
786 #ifdef DEBUG
787   amuDebug(D_TRACE)
788     plog(XLOG_DEBUG, "xdr_readdirres:");
789 #endif /* DEBUG */
790
791   if (!xdr_nfsstat(xdrs, &objp->rdr_status)) {
792     return (FALSE);
793   }
794   switch (objp->rdr_status) {
795   case NFS_OK:
796     if (!xdr_dirlist(xdrs, &objp->rdr_u.rdr_reply_u)) {
797       return (FALSE);
798     }
799     break;
800   default:
801     break;
802   }
803   return (TRUE);
804 }
805 #endif /* not HAVE_XDR_READDIRRES */
806
807
808 #ifndef HAVE_XDR_READLINKRES
809 bool_t
810 xdr_readlinkres(XDR *xdrs, nfsreadlinkres *objp)
811 {
812 #ifdef DEBUG
813   amuDebug(D_TRACE)
814     plog(XLOG_DEBUG, "xdr_readlinkres:");
815 #endif /* DEBUG */
816
817   if (!xdr_nfsstat(xdrs, &objp->rlr_status)) {
818     return (FALSE);
819   }
820   switch (objp->rlr_status) {
821   case NFS_OK:
822     if (!xdr_nfspath(xdrs, &objp->rlr_u.rlr_data_u)) {
823       return (FALSE);
824     }
825     break;
826   default:
827     break;
828   }
829   return (TRUE);
830 }
831 #endif /* not HAVE_XDR_READLINKRES */
832
833
834 #ifndef HAVE_XDR_READOKRES
835 bool_t
836 xdr_readokres(XDR *xdrs, nfsreadokres *objp)
837 {
838 #ifdef DEBUG
839   amuDebug(D_TRACE)
840     plog(XLOG_DEBUG, "xdr_readokres:");
841 #endif /* DEBUG */
842
843   if (!xdr_fattr(xdrs, &objp->raok_attributes)) {
844     return (FALSE);
845   }
846   if (!xdr_bytes(xdrs,
847                  (char **) & objp->raok_u.raok_val_u,
848                  (u_int *) & objp->raok_u.raok_len_u,
849                  NFS_MAXDATA)) {
850     return (FALSE);
851   }
852   return (TRUE);
853 }
854 #endif /* not HAVE_XDR_READOKRES */
855
856
857 #ifndef HAVE_XDR_READRES
858 bool_t
859 xdr_readres(XDR *xdrs, nfsreadres *objp)
860 {
861 #ifdef DEBUG
862   amuDebug(D_TRACE)
863     plog(XLOG_DEBUG, "xdr_readres:");
864 #endif /* DEBUG */
865
866   if (!xdr_nfsstat(xdrs, &objp->rr_status)) {
867     return (FALSE);
868   }
869   switch (objp->rr_status) {
870   case NFS_OK:
871     if (!xdr_readokres(xdrs, &objp->rr_u.rr_reply_u)) {
872       return (FALSE);
873     }
874     break;
875   default:
876     break;
877   }
878   return (TRUE);
879 }
880 #endif /* not HAVE_XDR_READRES */
881
882
883 #ifndef HAVE_XDR_RENAMEARGS
884 bool_t
885 xdr_renameargs(XDR *xdrs, nfsrenameargs *objp)
886 {
887 #ifdef DEBUG
888   amuDebug(D_TRACE)
889     plog(XLOG_DEBUG, "xdr_renameargs:");
890 #endif /* DEBUG */
891
892   if (!xdr_diropargs(xdrs, &objp->rna_from)) {
893     return (FALSE);
894   }
895   if (!xdr_diropargs(xdrs, &objp->rna_to)) {
896     return (FALSE);
897   }
898   return (TRUE);
899 }
900 #endif /* not HAVE_XDR_RENAMEARGS */
901
902
903 #ifndef HAVE_XDR_SATTR
904 bool_t
905 xdr_sattr(XDR *xdrs, nfssattr *objp)
906 {
907 #ifdef DEBUG
908   amuDebug(D_TRACE)
909     plog(XLOG_DEBUG, "xdr_sattr:");
910 #endif /* DEBUG */
911
912   if (!xdr_u_int(xdrs, &objp->sa_mode)) {
913     return (FALSE);
914   }
915   if (!xdr_u_int(xdrs, &objp->sa_uid)) {
916     return (FALSE);
917   }
918   if (!xdr_u_int(xdrs, &objp->sa_gid)) {
919     return (FALSE);
920   }
921   if (!xdr_u_int(xdrs, &objp->sa_size)) {
922     return (FALSE);
923   }
924   if (!xdr_nfstime(xdrs, &objp->sa_atime)) {
925     return (FALSE);
926   }
927   if (!xdr_nfstime(xdrs, &objp->sa_mtime)) {
928     return (FALSE);
929   }
930   return (TRUE);
931 }
932 #endif /* not HAVE_XDR_SATTR */
933
934
935 #ifndef HAVE_XDR_SATTRARGS
936 bool_t
937 xdr_sattrargs(XDR *xdrs, nfssattrargs *objp)
938 {
939 #ifdef DEBUG
940   amuDebug(D_TRACE)
941     plog(XLOG_DEBUG, "xdr_sattrargs:");
942 #endif /* DEBUG */
943
944   if (!xdr_nfs_fh(xdrs, &objp->sag_fhandle)) {
945     return (FALSE);
946   }
947   if (!xdr_sattr(xdrs, &objp->sag_attributes)) {
948     return (FALSE);
949   }
950   return (TRUE);
951 }
952 #endif /* not HAVE_XDR_SATTRARGS */
953
954
955 #ifndef HAVE_XDR_STATFSOKRES
956 bool_t
957 xdr_statfsokres(XDR *xdrs, nfsstatfsokres *objp)
958 {
959 #ifdef DEBUG
960   amuDebug(D_TRACE)
961     plog(XLOG_DEBUG, "xdr_statfsokres:");
962 #endif /* DEBUG */
963
964   if (!xdr_u_int(xdrs, &objp->sfrok_tsize)) {
965     return (FALSE);
966   }
967   if (!xdr_u_int(xdrs, &objp->sfrok_bsize)) {
968     return (FALSE);
969   }
970   if (!xdr_u_int(xdrs, &objp->sfrok_blocks)) {
971     return (FALSE);
972   }
973   if (!xdr_u_int(xdrs, &objp->sfrok_bfree)) {
974     return (FALSE);
975   }
976   if (!xdr_u_int(xdrs, &objp->sfrok_bavail)) {
977     return (FALSE);
978   }
979   return (TRUE);
980 }
981 #endif /* not HAVE_XDR_STATFSOKRES */
982
983
984 #ifndef HAVE_XDR_STATFSRES
985 bool_t
986 xdr_statfsres(XDR *xdrs, nfsstatfsres *objp)
987 {
988 #ifdef DEBUG
989   amuDebug(D_TRACE)
990     plog(XLOG_DEBUG, "xdr_statfsres:");
991 #endif /* DEBUG */
992
993   if (!xdr_nfsstat(xdrs, &objp->sfr_status)) {
994     return (FALSE);
995   }
996   switch (objp->sfr_status) {
997   case NFS_OK:
998     if (!xdr_statfsokres(xdrs, &objp->sfr_u.sfr_reply_u)) {
999       return (FALSE);
1000     }
1001     break;
1002   default:
1003     break;
1004   }
1005   return (TRUE);
1006 }
1007 #endif /* not HAVE_XDR_STATFSRES */
1008
1009
1010 #ifndef HAVE_XDR_SYMLINKARGS
1011 bool_t
1012 xdr_symlinkargs(XDR *xdrs, nfssymlinkargs *objp)
1013 {
1014 #ifdef DEBUG
1015   amuDebug(D_TRACE)
1016     plog(XLOG_DEBUG, "xdr_symlinkargs:");
1017 #endif /* DEBUG */
1018
1019   if (!xdr_diropargs(xdrs, &objp->sla_from)) {
1020     return (FALSE);
1021   }
1022   if (!xdr_nfspath(xdrs, &objp->sla_to)) {
1023     return (FALSE);
1024   }
1025   if (!xdr_sattr(xdrs, &objp->sla_attributes)) {
1026     return (FALSE);
1027   }
1028   return (TRUE);
1029 }
1030 #endif /* not HAVE_XDR_SYMLINKARGS */
1031
1032
1033 #ifndef HAVE_XDR_WRITEARGS
1034 bool_t
1035 xdr_writeargs(XDR *xdrs, nfswriteargs *objp)
1036 {
1037 #ifdef DEBUG
1038   amuDebug(D_TRACE)
1039     plog(XLOG_DEBUG, "xdr_writeargs:");
1040 #endif /* DEBUG */
1041
1042   if (!xdr_nfs_fh(xdrs, &objp->wra_fhandle)) {
1043     return (FALSE);
1044   }
1045   if (!xdr_u_int(xdrs, &objp->wra_beginoffset)) {
1046     return (FALSE);
1047   }
1048   if (!xdr_u_int(xdrs, &objp->wra_offset)) {
1049     return (FALSE);
1050   }
1051   if (!xdr_u_int(xdrs, &objp->wra_totalcount)) {
1052     return (FALSE);
1053   }
1054   if (!xdr_bytes(xdrs,
1055                  (char **) & objp->wra_u.wra_val_u,
1056                  (u_int *) & objp->wra_u.wra_len_u,
1057                  NFS_MAXDATA)) {
1058     return (FALSE);
1059   }
1060   return (TRUE);
1061 }
1062 #endif /* not HAVE_XDR_WRITEARGS */
1063
1064
1065 /*
1066  * AUTOFS XDR FUNCTIONS:
1067  */
1068 #ifdef HAVE_FS_AUTOFS
1069 # ifndef HAVE_XDR_MNTREQUEST
1070 bool_t
1071 xdr_mntrequest(XDR *xdrs, mntrequest *objp)
1072 {
1073 #ifdef DEBUG
1074   amuDebug(D_TRACE)
1075     plog(XLOG_DEBUG, "xdr_mntrequest:");
1076 #endif /* DEBUG */
1077
1078   if (!xdr_string(xdrs, &objp->name, A_MAXNAME))
1079     return (FALSE);
1080
1081   if (!xdr_string(xdrs, &objp->map, A_MAXNAME))
1082     return (FALSE);
1083
1084   if (!xdr_string(xdrs, &objp->opts, A_MAXOPTS))
1085     return (FALSE);
1086
1087   if (!xdr_string(xdrs, &objp->path, A_MAXPATH))
1088     return (FALSE);
1089
1090   return (TRUE);
1091 }
1092 # endif /* not HAVE_XDR_MNTREQUEST */
1093
1094
1095 # ifndef HAVE_XDR_MNTRES
1096 bool_t
1097 xdr_mntres(XDR *xdrs, mntres *objp)
1098 {
1099 #ifdef DEBUG
1100   amuDebug(D_TRACE)
1101     plog(XLOG_DEBUG, "xdr_mntres:");
1102 #endif /* DEBUG */
1103
1104   if (!xdr_int(xdrs, &objp->status))
1105     return (FALSE);
1106
1107   return (TRUE);
1108 }
1109 # endif /* not HAVE_XDR_MNTRES */
1110
1111
1112 # ifndef HAVE_XDR_UMNTREQUEST
1113 bool_t
1114 xdr_umntrequest(XDR *xdrs, umntrequest *objp)
1115 {
1116 #ifdef DEBUG
1117   amuDebug(D_TRACE)
1118     plog(XLOG_DEBUG, "xdr_umntrequest:");
1119 #endif /* DEBUG */
1120
1121   if (!xdr_int(xdrs, &objp->isdirect))
1122     return (FALSE);
1123
1124   if (!xdr_u_int(xdrs, (u_int *) &objp->devid))
1125     return (FALSE);
1126
1127 #ifdef HAVE_FIELD_UMNTREQUEST_RDEVID
1128   if (!xdr_u_long(xdrs, &objp->rdevid))
1129     return (FALSE);
1130 #endif /* HAVE_FIELD_UMNTREQUEST_RDEVID */
1131
1132   if (!xdr_pointer(xdrs, (char **) &objp->next, sizeof(umntrequest), (XDRPROC_T_TYPE) xdr_umntrequest))
1133     return (FALSE);
1134
1135   return (TRUE);
1136 }
1137 # endif /* not HAVE_XDR_UMNTREQUEST */
1138
1139
1140 # ifndef HAVE_XDR_UMNTRES
1141 bool_t
1142 xdr_umntres(XDR *xdrs, umntres *objp)
1143 {
1144 #ifdef DEBUG
1145   amuDebug(D_TRACE)
1146     plog(XLOG_DEBUG, "xdr_mntres:");
1147 #endif /* DEBUG */
1148
1149   if (!xdr_int(xdrs, &objp->status))
1150     return (FALSE);
1151
1152   return (TRUE);
1153 }
1154 # endif /* not HAVE_XDR_UMNTRES */
1155 #endif /* HAVE_FS_AUTOFS */