fdwalk should return 0 on an empty directory
[kopensolaris-gnu/glibc.git] / sunrpc / xdr.c
1 /* @(#)xdr.c    2.1 88/07/29 4.0 RPCSRC */
2 /*
3  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
4  * unrestricted use provided that this legend is included on all tape
5  * media and as a part of the software program in whole or part.  Users
6  * may copy or modify Sun RPC without charge, but are not authorized
7  * to license or distribute it to anyone else except as part of a product or
8  * program developed by the user.
9  *
10  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
11  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
12  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
13  *
14  * Sun RPC is provided with no support and without any obligation on the
15  * part of Sun Microsystems, Inc. to assist in its use, correction,
16  * modification or enhancement.
17  *
18  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
19  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
20  * OR ANY PART THEREOF.
21  *
22  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
23  * or profits or other special, indirect and consequential damages, even if
24  * Sun has been advised of the possibility of such damages.
25  *
26  * Sun Microsystems, Inc.
27  * 2550 Garcia Avenue
28  * Mountain View, California  94043
29  */
30 #if !defined(lint) && defined(SCCSIDS)
31 static char sccsid[] = "@(#)xdr.c 1.35 87/08/12";
32 #endif
33
34 /*
35  * xdr.c, Generic XDR routines implementation.
36  *
37  * Copyright (C) 1986, Sun Microsystems, Inc.
38  *
39  * These are the "generic" xdr routines used to serialize and de-serialize
40  * most common data items.  See xdr.h for more info on the interface to
41  * xdr.
42  */
43
44 #include <stdio.h>
45 #include <limits.h>
46 #include <string.h>
47 #include <libintl.h>
48
49 #include <rpc/types.h>
50 #include <rpc/xdr.h>
51
52 #ifdef USE_IN_LIBIO
53 # include <wchar.h>
54 #endif
55
56 /*
57  * constants specific to the xdr "protocol"
58  */
59 #define XDR_FALSE       ((long) 0)
60 #define XDR_TRUE        ((long) 1)
61 #define LASTUNSIGNED    ((u_int) 0-1)
62
63 /*
64  * for unit alignment
65  */
66 static const char xdr_zero[BYTES_PER_XDR_UNIT] = {0, 0, 0, 0};
67
68 /*
69  * Free a data structure using XDR
70  * Not a filter, but a convenient utility nonetheless
71  */
72 void
73 xdr_free (xdrproc_t proc, char *objp)
74 {
75   XDR x;
76
77   x.x_op = XDR_FREE;
78   (*proc) (&x, objp);
79 }
80
81 /*
82  * XDR nothing
83  */
84 bool_t
85 xdr_void (void)
86 {
87   return TRUE;
88 }
89 INTDEF(xdr_void)
90
91 /*
92  * XDR integers
93  */
94 bool_t
95 xdr_int (XDR *xdrs, int *ip)
96 {
97
98 #if INT_MAX < LONG_MAX
99   long l;
100
101   switch (xdrs->x_op)
102     {
103     case XDR_ENCODE:
104       l = (long) *ip;
105       return XDR_PUTLONG (xdrs, &l);
106
107     case XDR_DECODE:
108       if (!XDR_GETLONG (xdrs, &l))
109         {
110           return FALSE;
111         }
112       *ip = (int) l;
113     case XDR_FREE:
114       return TRUE;
115     }
116   return FALSE;
117 #elif INT_MAX == LONG_MAX
118   return INTUSE(xdr_long) (xdrs, (long *) ip);
119 #elif INT_MAX == SHRT_MAX
120   return INTUSE(xdr_short) (xdrs, (short *) ip);
121 #else
122 #error unexpected integer sizes in_xdr_int()
123 #endif
124 }
125 INTDEF(xdr_int)
126
127 /*
128  * XDR unsigned integers
129  */
130 bool_t
131 xdr_u_int (XDR *xdrs, u_int *up)
132 {
133 #if UINT_MAX < ULONG_MAX
134   long l;
135
136   switch (xdrs->x_op)
137     {
138     case XDR_ENCODE:
139       l = (u_long) * up;
140       return XDR_PUTLONG (xdrs, &l);
141
142     case XDR_DECODE:
143       if (!XDR_GETLONG (xdrs, &l))
144         {
145           return FALSE;
146         }
147       *up = (u_int) (u_long) l;
148     case XDR_FREE:
149       return TRUE;
150     }
151   return FALSE;
152 #elif UINT_MAX == ULONG_MAX
153   return INTUSE(xdr_u_long) (xdrs, (u_long *) up);
154 #elif UINT_MAX == USHRT_MAX
155   return INTUSE(xdr_short) (xdrs, (short *) up);
156 #else
157 #error unexpected integer sizes in_xdr_u_int()
158 #endif
159 }
160 INTDEF(xdr_u_int)
161
162 /*
163  * XDR long integers
164  * The definition of xdr_long() is kept for backward
165  * compatibility. Instead xdr_int() should be used.
166  */
167 bool_t
168 xdr_long (XDR *xdrs, long *lp)
169 {
170
171   if (xdrs->x_op == XDR_ENCODE
172       && (sizeof (int32_t) == sizeof (long)
173           || (int32_t) *lp == *lp))
174     return XDR_PUTLONG (xdrs, lp);
175
176   if (xdrs->x_op == XDR_DECODE)
177     return XDR_GETLONG (xdrs, lp);
178
179   if (xdrs->x_op == XDR_FREE)
180     return TRUE;
181
182   return FALSE;
183 }
184 INTDEF(xdr_long)
185
186 /*
187  * XDR unsigned long integers
188  * The definition of xdr_u_long() is kept for backward
189  * compatibility. Instead xdr_u_int() should be used.
190  */
191 bool_t
192 xdr_u_long (XDR *xdrs, u_long *ulp)
193 {
194   switch (xdrs->x_op)
195     {
196     case XDR_DECODE:
197       {
198         long int tmp;
199
200         if (XDR_GETLONG (xdrs, &tmp) == FALSE)
201           return FALSE;
202
203         *ulp = (uint32_t) tmp;
204         return TRUE;
205       }
206
207     case XDR_ENCODE:
208       if (sizeof (uint32_t) != sizeof (u_long)
209           && (uint32_t) *ulp != *ulp)
210         return FALSE;
211
212       return XDR_PUTLONG (xdrs, (long *) ulp);
213
214     case XDR_FREE:
215       return TRUE;
216     }
217   return FALSE;
218 }
219 INTDEF(xdr_u_long)
220
221 /*
222  * XDR hyper integers
223  * same as xdr_u_hyper - open coded to save a proc call!
224  */
225 bool_t
226 xdr_hyper (XDR *xdrs, quad_t *llp)
227 {
228   long int t1, t2;
229
230   if (xdrs->x_op == XDR_ENCODE)
231     {
232       t1 = (long) ((*llp) >> 32);
233       t2 = (long) (*llp);
234       return (XDR_PUTLONG(xdrs, &t1) && XDR_PUTLONG(xdrs, &t2));
235     }
236
237   if (xdrs->x_op == XDR_DECODE)
238     {
239       if (!XDR_GETLONG(xdrs, &t1) || !XDR_GETLONG(xdrs, &t2))
240         return FALSE;
241       *llp = ((quad_t) t1) << 32;
242       *llp |= (uint32_t) t2;
243       return TRUE;
244     }
245
246   if (xdrs->x_op == XDR_FREE)
247     return TRUE;
248
249   return FALSE;
250 }
251 INTDEF(xdr_hyper)
252
253
254 /*
255  * XDR hyper integers
256  * same as xdr_hyper - open coded to save a proc call!
257  */
258 bool_t
259 xdr_u_hyper (XDR *xdrs, u_quad_t *ullp)
260 {
261   long int t1, t2;
262
263   if (xdrs->x_op == XDR_ENCODE)
264     {
265       t1 = (unsigned long) ((*ullp) >> 32);
266       t2 = (unsigned long) (*ullp);
267       return (XDR_PUTLONG(xdrs, &t1) && XDR_PUTLONG(xdrs, &t2));
268     }
269
270   if (xdrs->x_op == XDR_DECODE)
271     {
272       if (!XDR_GETLONG(xdrs, &t1) || !XDR_GETLONG(xdrs, &t2))
273         return FALSE;
274       *ullp = ((u_quad_t) t1) << 32;
275       *ullp |= (uint32_t) t2;
276       return TRUE;
277     }
278
279   if (xdrs->x_op == XDR_FREE)
280     return TRUE;
281
282   return FALSE;
283 }
284 INTDEF(xdr_u_hyper)
285
286 bool_t
287 xdr_longlong_t (XDR *xdrs, quad_t *llp)
288 {
289   return INTUSE(xdr_hyper) (xdrs, llp);
290 }
291
292 bool_t
293 xdr_u_longlong_t (XDR *xdrs, u_quad_t *ullp)
294 {
295   return INTUSE(xdr_u_hyper) (xdrs, ullp);
296 }
297
298 /*
299  * XDR short integers
300  */
301 bool_t
302 xdr_short (XDR *xdrs, short *sp)
303 {
304   long l;
305
306   switch (xdrs->x_op)
307     {
308     case XDR_ENCODE:
309       l = (long) *sp;
310       return XDR_PUTLONG (xdrs, &l);
311
312     case XDR_DECODE:
313       if (!XDR_GETLONG (xdrs, &l))
314         {
315           return FALSE;
316         }
317       *sp = (short) l;
318       return TRUE;
319
320     case XDR_FREE:
321       return TRUE;
322     }
323   return FALSE;
324 }
325 INTDEF(xdr_short)
326
327 /*
328  * XDR unsigned short integers
329  */
330 bool_t
331 xdr_u_short (XDR *xdrs, u_short *usp)
332 {
333   long l;
334
335   switch (xdrs->x_op)
336     {
337     case XDR_ENCODE:
338       l = (u_long) * usp;
339       return XDR_PUTLONG (xdrs, &l);
340
341     case XDR_DECODE:
342       if (!XDR_GETLONG (xdrs, &l))
343         {
344           return FALSE;
345         }
346       *usp = (u_short) (u_long) l;
347       return TRUE;
348
349     case XDR_FREE:
350       return TRUE;
351     }
352   return FALSE;
353 }
354 INTDEF(xdr_u_short)
355
356
357 /*
358  * XDR a char
359  */
360 bool_t
361 xdr_char (XDR *xdrs, char *cp)
362 {
363   int i;
364
365   i = (*cp);
366   if (!INTUSE(xdr_int) (xdrs, &i))
367     {
368       return FALSE;
369     }
370   *cp = i;
371   return TRUE;
372 }
373
374 /*
375  * XDR an unsigned char
376  */
377 bool_t
378 xdr_u_char (XDR *xdrs, u_char *cp)
379 {
380   u_int u;
381
382   u = (*cp);
383   if (!INTUSE(xdr_u_int) (xdrs, &u))
384     {
385       return FALSE;
386     }
387   *cp = u;
388   return TRUE;
389 }
390
391 /*
392  * XDR booleans
393  */
394 bool_t
395 xdr_bool (XDR *xdrs, bool_t *bp)
396 {
397   long lb;
398
399   switch (xdrs->x_op)
400     {
401     case XDR_ENCODE:
402       lb = *bp ? XDR_TRUE : XDR_FALSE;
403       return XDR_PUTLONG (xdrs, &lb);
404
405     case XDR_DECODE:
406       if (!XDR_GETLONG (xdrs, &lb))
407         {
408           return FALSE;
409         }
410       *bp = (lb == XDR_FALSE) ? FALSE : TRUE;
411       return TRUE;
412
413     case XDR_FREE:
414       return TRUE;
415     }
416   return FALSE;
417 }
418 INTDEF(xdr_bool)
419
420 /*
421  * XDR enumerations
422  */
423 bool_t
424 xdr_enum (XDR *xdrs, enum_t *ep)
425 {
426   enum sizecheck
427     {
428       SIZEVAL
429     };                          /* used to find the size of an enum */
430
431   /*
432    * enums are treated as ints
433    */
434   if (sizeof (enum sizecheck) == 4)
435     {
436 #if INT_MAX < LONG_MAX
437       long l;
438
439       switch (xdrs->x_op)
440         {
441         case XDR_ENCODE:
442           l = *ep;
443           return XDR_PUTLONG (xdrs, &l);
444
445         case XDR_DECODE:
446           if (!XDR_GETLONG (xdrs, &l))
447             {
448               return FALSE;
449             }
450           *ep = l;
451         case XDR_FREE:
452           return TRUE;
453
454         }
455       return FALSE;
456 #else
457       return INTUSE(xdr_long) (xdrs, (long *) ep);
458 #endif
459     }
460   else if (sizeof (enum sizecheck) == sizeof (short))
461     {
462       return INTUSE(xdr_short) (xdrs, (short *) ep);
463     }
464   else
465     {
466       return FALSE;
467     }
468 }
469 INTDEF(xdr_enum)
470
471 /*
472  * XDR opaque data
473  * Allows the specification of a fixed size sequence of opaque bytes.
474  * cp points to the opaque object and cnt gives the byte length.
475  */
476 bool_t
477 xdr_opaque (XDR *xdrs, caddr_t cp, u_int cnt)
478 {
479   u_int rndup;
480   static char crud[BYTES_PER_XDR_UNIT];
481
482   /*
483    * if no data we are done
484    */
485   if (cnt == 0)
486     return TRUE;
487
488   /*
489    * round byte count to full xdr units
490    */
491   rndup = cnt % BYTES_PER_XDR_UNIT;
492   if (rndup > 0)
493     rndup = BYTES_PER_XDR_UNIT - rndup;
494
495   switch (xdrs->x_op)
496     {
497     case XDR_DECODE:
498       if (!XDR_GETBYTES (xdrs, cp, cnt))
499         {
500           return FALSE;
501         }
502       if (rndup == 0)
503         return TRUE;
504       return XDR_GETBYTES (xdrs, (caddr_t)crud, rndup);
505
506     case XDR_ENCODE:
507       if (!XDR_PUTBYTES (xdrs, cp, cnt))
508         {
509           return FALSE;
510         }
511       if (rndup == 0)
512         return TRUE;
513       return XDR_PUTBYTES (xdrs, xdr_zero, rndup);
514
515     case XDR_FREE:
516       return TRUE;
517     }
518   return FALSE;
519 }
520 INTDEF(xdr_opaque)
521
522 /*
523  * XDR counted bytes
524  * *cpp is a pointer to the bytes, *sizep is the count.
525  * If *cpp is NULL maxsize bytes are allocated
526  */
527 bool_t
528 xdr_bytes (xdrs, cpp, sizep, maxsize)
529      XDR *xdrs;
530      char **cpp;
531      u_int *sizep;
532      u_int maxsize;
533 {
534   char *sp = *cpp;      /* sp is the actual string pointer */
535   u_int nodesize;
536
537   /*
538    * first deal with the length since xdr bytes are counted
539    */
540   if (!INTUSE(xdr_u_int) (xdrs, sizep))
541     {
542       return FALSE;
543     }
544   nodesize = *sizep;
545   if ((nodesize > maxsize) && (xdrs->x_op != XDR_FREE))
546     {
547       return FALSE;
548     }
549
550   /*
551    * now deal with the actual bytes
552    */
553   switch (xdrs->x_op)
554     {
555     case XDR_DECODE:
556       if (nodesize == 0)
557         {
558           return TRUE;
559         }
560       if (sp == NULL)
561         {
562           *cpp = sp = (char *) mem_alloc (nodesize);
563         }
564       if (sp == NULL)
565         {
566           (void) __fxprintf (NULL, "%s", _("xdr_bytes: out of memory\n"));
567           return FALSE;
568         }
569       /* fall into ... */
570
571     case XDR_ENCODE:
572       return INTUSE(xdr_opaque) (xdrs, sp, nodesize);
573
574     case XDR_FREE:
575       if (sp != NULL)
576         {
577           mem_free (sp, nodesize);
578           *cpp = NULL;
579         }
580       return TRUE;
581     }
582   return FALSE;
583 }
584 INTDEF(xdr_bytes)
585
586 /*
587  * Implemented here due to commonality of the object.
588  */
589 bool_t
590 xdr_netobj (xdrs, np)
591      XDR *xdrs;
592      struct netobj *np;
593 {
594
595   return INTUSE(xdr_bytes) (xdrs, &np->n_bytes, &np->n_len, MAX_NETOBJ_SZ);
596 }
597 INTDEF(xdr_netobj)
598
599 /*
600  * XDR a discriminated union
601  * Support routine for discriminated unions.
602  * You create an array of xdrdiscrim structures, terminated with
603  * an entry with a null procedure pointer.  The routine gets
604  * the discriminant value and then searches the array of xdrdiscrims
605  * looking for that value.  It calls the procedure given in the xdrdiscrim
606  * to handle the discriminant.  If there is no specific routine a default
607  * routine may be called.
608  * If there is no specific or default routine an error is returned.
609  */
610 bool_t
611 xdr_union (xdrs, dscmp, unp, choices, dfault)
612      XDR *xdrs;
613      enum_t *dscmp;             /* enum to decide which arm to work on */
614      char *unp;                 /* the union itself */
615      const struct xdr_discrim *choices; /* [value, xdr proc] for each arm */
616      xdrproc_t dfault;          /* default xdr routine */
617 {
618   enum_t dscm;
619
620   /*
621    * we deal with the discriminator;  it's an enum
622    */
623   if (!INTUSE(xdr_enum) (xdrs, dscmp))
624     {
625       return FALSE;
626     }
627   dscm = *dscmp;
628
629   /*
630    * search choices for a value that matches the discriminator.
631    * if we find one, execute the xdr routine for that value.
632    */
633   for (; choices->proc != NULL_xdrproc_t; choices++)
634     {
635       if (choices->value == dscm)
636         return (*(choices->proc)) (xdrs, unp, LASTUNSIGNED);
637     }
638
639   /*
640    * no match - execute the default xdr routine if there is one
641    */
642   return ((dfault == NULL_xdrproc_t) ? FALSE :
643           (*dfault) (xdrs, unp, LASTUNSIGNED));
644 }
645 INTDEF(xdr_union)
646
647
648 /*
649  * Non-portable xdr primitives.
650  * Care should be taken when moving these routines to new architectures.
651  */
652
653
654 /*
655  * XDR null terminated ASCII strings
656  * xdr_string deals with "C strings" - arrays of bytes that are
657  * terminated by a NULL character.  The parameter cpp references a
658  * pointer to storage; If the pointer is null, then the necessary
659  * storage is allocated.  The last parameter is the max allowed length
660  * of the string as specified by a protocol.
661  */
662 bool_t
663 xdr_string (xdrs, cpp, maxsize)
664      XDR *xdrs;
665      char **cpp;
666      u_int maxsize;
667 {
668   char *sp = *cpp;      /* sp is the actual string pointer */
669   u_int size;
670   u_int nodesize;
671
672   /*
673    * first deal with the length since xdr strings are counted-strings
674    */
675   switch (xdrs->x_op)
676     {
677     case XDR_FREE:
678       if (sp == NULL)
679         {
680           return TRUE;          /* already free */
681         }
682       /* fall through... */
683     case XDR_ENCODE:
684       if (sp == NULL)
685         return FALSE;
686       size = strlen (sp);
687       break;
688     case XDR_DECODE:
689       break;
690     }
691   if (!INTUSE(xdr_u_int) (xdrs, &size))
692     {
693       return FALSE;
694     }
695   if (size > maxsize)
696     {
697       return FALSE;
698     }
699   nodesize = size + 1;
700   if (nodesize == 0)
701     {
702       /* This means an overflow.  It a bug in the caller which
703          provided a too large maxsize but nevertheless catch it
704          here.  */
705       return FALSE;
706     }
707
708   /*
709    * now deal with the actual bytes
710    */
711   switch (xdrs->x_op)
712     {
713     case XDR_DECODE:
714       if (sp == NULL)
715         *cpp = sp = (char *) mem_alloc (nodesize);
716       if (sp == NULL)
717         {
718           (void) __fxprintf (NULL, "%s", _("xdr_string: out of memory\n"));
719           return FALSE;
720         }
721       sp[size] = 0;
722       /* fall into ... */
723
724     case XDR_ENCODE:
725       return INTUSE(xdr_opaque) (xdrs, sp, size);
726
727     case XDR_FREE:
728       mem_free (sp, nodesize);
729       *cpp = NULL;
730       return TRUE;
731     }
732   return FALSE;
733 }
734 INTDEF(xdr_string)
735
736 /*
737  * Wrapper for xdr_string that can be called directly from
738  * routines like clnt_call
739  */
740 bool_t
741 xdr_wrapstring (xdrs, cpp)
742      XDR *xdrs;
743      char **cpp;
744 {
745   if (INTUSE(xdr_string) (xdrs, cpp, LASTUNSIGNED))
746     {
747       return TRUE;
748     }
749   return FALSE;
750 }