Fix typo.
[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
48 #include <rpc/types.h>
49 #include <rpc/xdr.h>
50
51 /*
52  * constants specific to the xdr "protocol"
53  */
54 #define XDR_FALSE       ((long) 0)
55 #define XDR_TRUE        ((long) 1)
56 #define LASTUNSIGNED    ((u_int) 0-1)
57
58 /*
59  * for unit alignment
60  */
61 static const char xdr_zero[BYTES_PER_XDR_UNIT] =
62 {0, 0, 0, 0};
63
64 /*
65  * Free a data structure using XDR
66  * Not a filter, but a convenient utility nonetheless
67  */
68 void
69 xdr_free (proc, objp)
70      xdrproc_t proc;
71      char *objp;
72 {
73   XDR x;
74
75   x.x_op = XDR_FREE;
76   (*proc) (&x, objp);
77 }
78
79 /*
80  * XDR nothing
81  */
82 bool_t
83 xdr_void (void)
84 {
85   return TRUE;
86 }
87
88 /*
89  * XDR integers
90  */
91 bool_t
92 xdr_int (xdrs, ip)
93      XDR *xdrs;
94      int *ip;
95 {
96
97 #if INT_MAX < LONG_MAX
98   long l;
99
100   switch (xdrs->x_op)
101     {
102     case XDR_ENCODE:
103       l = (long) *ip;
104       return XDR_PUTLONG (xdrs, &l);
105
106     case XDR_DECODE:
107       if (!XDR_GETLONG (xdrs, &l))
108         {
109           return FALSE;
110         }
111       *ip = (int) l;
112     case XDR_FREE:
113       return TRUE;
114     }
115   return FALSE;
116 #elif INT_MAX == LONG_MAX
117   return xdr_long (xdrs, (long *) ip);
118 #elif INT_MAX == SHRT_MAX
119   return xdr_short (xdrs, (short *) ip);
120 #else
121 #error unexpected integer sizes in_xdr_int()
122 #endif
123 }
124
125 /*
126  * XDR unsigned integers
127  */
128 bool_t
129 xdr_u_int (xdrs, up)
130      XDR *xdrs;
131      u_int *up;
132 {
133 #if UINT_MAX < ULONG_MAX
134   u_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) l;
148     case XDR_FREE:
149       return TRUE;
150     }
151   return FALSE;
152 #elif UINT_MAX == ULONG_MAX
153   return xdr_u_long (xdrs, (u_long *) up);
154 #elif UINT_MAX == USHRT_MAX
155   return xdr_short (xdrs, (short *) up);
156 #else
157 #error unexpected integer sizes in_xdr_u_int()
158 #endif
159 }
160
161 /*
162  * XDR long integers
163  * same as xdr_u_long - open coded to save a proc call!
164  */
165 bool_t
166 xdr_long (xdrs, lp)
167      XDR *xdrs;
168      long *lp;
169 {
170
171   if (xdrs->x_op == XDR_ENCODE)
172     return XDR_PUTLONG (xdrs, lp);
173
174   if (xdrs->x_op == XDR_DECODE)
175     return XDR_GETLONG (xdrs, lp);
176
177   if (xdrs->x_op == XDR_FREE)
178     return TRUE;
179
180   return FALSE;
181 }
182
183 /*
184  * XDR unsigned long integers
185  * same as xdr_long - open coded to save a proc call!
186  */
187 bool_t
188 xdr_u_long (xdrs, ulp)
189      XDR *xdrs;
190      u_long *ulp;
191 {
192   switch (xdrs->x_op)
193     {
194     case XDR_DECODE:
195       return XDR_GETLONG (xdrs, (long *) ulp);
196
197     case XDR_ENCODE:
198       return XDR_PUTLONG (xdrs, (long *) ulp);
199
200     case XDR_FREE:
201       return TRUE;
202     }
203   return FALSE;
204 }
205
206 /*
207  * XDR short integers
208  */
209 bool_t
210 xdr_short (xdrs, sp)
211      XDR *xdrs;
212      short *sp;
213 {
214   long l;
215
216   switch (xdrs->x_op)
217     {
218     case XDR_ENCODE:
219       l = (long) *sp;
220       return XDR_PUTLONG (xdrs, &l);
221
222     case XDR_DECODE:
223       if (!XDR_GETLONG (xdrs, &l))
224         {
225           return FALSE;
226         }
227       *sp = (short) l;
228       return TRUE;
229
230     case XDR_FREE:
231       return TRUE;
232     }
233   return FALSE;
234 }
235
236 /*
237  * XDR unsigned short integers
238  */
239 bool_t
240 xdr_u_short (xdrs, usp)
241      XDR *xdrs;
242      u_short *usp;
243 {
244   u_long l;
245
246   switch (xdrs->x_op)
247     {
248     case XDR_ENCODE:
249       l = (u_long) * usp;
250       return XDR_PUTLONG (xdrs, &l);
251
252     case XDR_DECODE:
253       if (!XDR_GETLONG (xdrs, &l))
254         {
255           return FALSE;
256         }
257       *usp = (u_short) l;
258       return TRUE;
259
260     case XDR_FREE:
261       return TRUE;
262     }
263   return FALSE;
264 }
265
266
267 /*
268  * XDR a char
269  */
270 bool_t
271 xdr_char (xdrs, cp)
272      XDR *xdrs;
273      char *cp;
274 {
275   int i;
276
277   i = (*cp);
278   if (!xdr_int (xdrs, &i))
279     {
280       return FALSE;
281     }
282   *cp = i;
283   return TRUE;
284 }
285
286 /*
287  * XDR an unsigned char
288  */
289 bool_t
290 xdr_u_char (xdrs, cp)
291      XDR *xdrs;
292      u_char *cp;
293 {
294   u_int u;
295
296   u = (*cp);
297   if (!xdr_u_int (xdrs, &u))
298     {
299       return FALSE;
300     }
301   *cp = u;
302   return TRUE;
303 }
304
305 /*
306  * XDR booleans
307  */
308 bool_t
309 xdr_bool (xdrs, bp)
310      XDR *xdrs;
311      bool_t *bp;
312 {
313   long lb;
314
315   switch (xdrs->x_op)
316     {
317     case XDR_ENCODE:
318       lb = *bp ? XDR_TRUE : XDR_FALSE;
319       return XDR_PUTLONG (xdrs, &lb);
320
321     case XDR_DECODE:
322       if (!XDR_GETLONG (xdrs, &lb))
323         {
324           return FALSE;
325         }
326       *bp = (lb == XDR_FALSE) ? FALSE : TRUE;
327       return TRUE;
328
329     case XDR_FREE:
330       return TRUE;
331     }
332   return FALSE;
333 }
334
335 /*
336  * XDR enumerations
337  */
338 bool_t
339 xdr_enum (xdrs, ep)
340      XDR *xdrs;
341      enum_t *ep;
342 {
343   enum sizecheck
344     {
345       SIZEVAL
346     };                          /* used to find the size of an enum */
347
348   /*
349    * enums are treated as ints
350    */
351   if (sizeof (enum sizecheck) == 4)
352     {
353 #if INT_MAX < LONG_MAX
354       long l;
355
356       switch (xdrs->x_op)
357         {
358         case XDR_ENCODE:
359           l = *ep;
360           return XDR_PUTLONG (xdrs, &l);
361
362         case XDR_DECODE:
363           if (!XDR_GETLONG (xdrs, &l))
364             {
365               return FALSE;
366             }
367           *ep = l;
368         case XDR_FREE:
369           return TRUE;
370
371         }
372       return FALSE;
373 #else
374       return xdr_long (xdrs, (long *) ep);
375 #endif
376     }
377   else if (sizeof (enum sizecheck) == sizeof (short))
378     {
379       return xdr_short (xdrs, (short *) ep);
380     }
381   else
382     {
383       return FALSE;
384     }
385 }
386
387 /*
388  * XDR opaque data
389  * Allows the specification of a fixed size sequence of opaque bytes.
390  * cp points to the opaque object and cnt gives the byte length.
391  */
392 bool_t
393 xdr_opaque (xdrs, cp, cnt)
394      XDR *xdrs;
395      caddr_t cp;
396      u_int cnt;
397 {
398   u_int rndup;
399   static char crud[BYTES_PER_XDR_UNIT];
400
401   /*
402    * if no data we are done
403    */
404   if (cnt == 0)
405     return TRUE;
406
407   /*
408    * round byte count to full xdr units
409    */
410   rndup = cnt % BYTES_PER_XDR_UNIT;
411   if (rndup > 0)
412     rndup = BYTES_PER_XDR_UNIT - rndup;
413
414   switch (xdrs->x_op)
415     {
416     case XDR_DECODE:
417       if (!XDR_GETBYTES (xdrs, cp, cnt))
418         {
419           return FALSE;
420         }
421       if (rndup == 0)
422         return TRUE;
423       return XDR_GETBYTES (xdrs, (caddr_t)crud, rndup);
424
425     case XDR_ENCODE:
426       if (!XDR_PUTBYTES (xdrs, cp, cnt))
427         {
428           return FALSE;
429         }
430       if (rndup == 0)
431         return TRUE;
432       return XDR_PUTBYTES (xdrs, xdr_zero, rndup);
433
434     case XDR_FREE:
435       return TRUE;
436     }
437   return FALSE;
438 }
439
440 /*
441  * XDR counted bytes
442  * *cpp is a pointer to the bytes, *sizep is the count.
443  * If *cpp is NULL maxsize bytes are allocated
444  */
445 bool_t
446 xdr_bytes (xdrs, cpp, sizep, maxsize)
447      XDR *xdrs;
448      char **cpp;
449      u_int *sizep;
450      u_int maxsize;
451 {
452   char *sp = *cpp;      /* sp is the actual string pointer */
453   u_int nodesize;
454
455   /*
456    * first deal with the length since xdr bytes are counted
457    */
458   if (!xdr_u_int (xdrs, sizep))
459     {
460       return FALSE;
461     }
462   nodesize = *sizep;
463   if ((nodesize > maxsize) && (xdrs->x_op != XDR_FREE))
464     {
465       return FALSE;
466     }
467
468   /*
469    * now deal with the actual bytes
470    */
471   switch (xdrs->x_op)
472     {
473     case XDR_DECODE:
474       if (nodesize == 0)
475         {
476           return TRUE;
477         }
478       if (sp == NULL)
479         {
480           *cpp = sp = (char *) mem_alloc (nodesize);
481         }
482       if (sp == NULL)
483         {
484           (void) fprintf (stderr, "xdr_bytes: out of memory\n");
485           return FALSE;
486         }
487       /* fall into ... */
488
489     case XDR_ENCODE:
490       return xdr_opaque (xdrs, sp, nodesize);
491
492     case XDR_FREE:
493       if (sp != NULL)
494         {
495           mem_free (sp, nodesize);
496           *cpp = NULL;
497         }
498       return TRUE;
499     }
500   return FALSE;
501 }
502
503 /*
504  * Implemented here due to commonality of the object.
505  */
506 bool_t
507 xdr_netobj (xdrs, np)
508      XDR *xdrs;
509      struct netobj *np;
510 {
511
512   return xdr_bytes (xdrs, &np->n_bytes, &np->n_len, MAX_NETOBJ_SZ);
513 }
514
515 /*
516  * XDR a discriminated union
517  * Support routine for discriminated unions.
518  * You create an array of xdrdiscrim structures, terminated with
519  * an entry with a null procedure pointer.  The routine gets
520  * the discriminant value and then searches the array of xdrdiscrims
521  * looking for that value.  It calls the procedure given in the xdrdiscrim
522  * to handle the discriminant.  If there is no specific routine a default
523  * routine may be called.
524  * If there is no specific or default routine an error is returned.
525  */
526 bool_t
527 xdr_union (xdrs, dscmp, unp, choices, dfault)
528      XDR *xdrs;
529      enum_t *dscmp;             /* enum to decide which arm to work on */
530      char *unp;                 /* the union itself */
531      const struct xdr_discrim *choices; /* [value, xdr proc] for each arm */
532      xdrproc_t dfault;          /* default xdr routine */
533 {
534   enum_t dscm;
535
536   /*
537    * we deal with the discriminator;  it's an enum
538    */
539   if (!xdr_enum (xdrs, dscmp))
540     {
541       return FALSE;
542     }
543   dscm = *dscmp;
544
545   /*
546    * search choices for a value that matches the discriminator.
547    * if we find one, execute the xdr routine for that value.
548    */
549   for (; choices->proc != NULL_xdrproc_t; choices++)
550     {
551       if (choices->value == dscm)
552         return (*(choices->proc)) (xdrs, unp, LASTUNSIGNED);
553     }
554
555   /*
556    * no match - execute the default xdr routine if there is one
557    */
558   return ((dfault == NULL_xdrproc_t) ? FALSE :
559           (*dfault) (xdrs, unp, LASTUNSIGNED));
560 }
561
562
563 /*
564  * Non-portable xdr primitives.
565  * Care should be taken when moving these routines to new architectures.
566  */
567
568
569 /*
570  * XDR null terminated ASCII strings
571  * xdr_string deals with "C strings" - arrays of bytes that are
572  * terminated by a NULL character.  The parameter cpp references a
573  * pointer to storage; If the pointer is null, then the necessary
574  * storage is allocated.  The last parameter is the max allowed length
575  * of the string as specified by a protocol.
576  */
577 bool_t
578 xdr_string (xdrs, cpp, maxsize)
579      XDR *xdrs;
580      char **cpp;
581      u_int maxsize;
582 {
583   char *sp = *cpp;      /* sp is the actual string pointer */
584   u_int size;
585   u_int nodesize;
586
587   /*
588    * first deal with the length since xdr strings are counted-strings
589    */
590   switch (xdrs->x_op)
591     {
592     case XDR_FREE:
593       if (sp == NULL)
594         {
595           return TRUE;          /* already free */
596         }
597       /* fall through... */
598     case XDR_ENCODE:
599       if (sp == NULL)
600         return FALSE;
601       size = strlen (sp);
602       break;
603     case XDR_DECODE:
604       break;
605     }
606   if (!xdr_u_int (xdrs, &size))
607     {
608       return FALSE;
609     }
610   if (size > maxsize)
611     {
612       return FALSE;
613     }
614   nodesize = size + 1;
615
616   /*
617    * now deal with the actual bytes
618    */
619   switch (xdrs->x_op)
620     {
621     case XDR_DECODE:
622       if (nodesize == 0)
623         {
624           return TRUE;
625         }
626       if (sp == NULL)
627         *cpp = sp = (char *) mem_alloc (nodesize);
628       if (sp == NULL)
629         {
630           (void) fprintf (stderr, "xdr_string: out of memory\n");
631           return FALSE;
632         }
633       sp[size] = 0;
634       /* fall into ... */
635
636     case XDR_ENCODE:
637       return xdr_opaque (xdrs, sp, size);
638
639     case XDR_FREE:
640       mem_free (sp, nodesize);
641       *cpp = NULL;
642       return TRUE;
643     }
644   return FALSE;
645 }
646
647 /*
648  * Wrapper for xdr_string that can be called directly from
649  * routines like clnt_call
650  */
651 bool_t
652 xdr_wrapstring (xdrs, cpp)
653      XDR *xdrs;
654      char **cpp;
655 {
656   if (xdr_string (xdrs, cpp, LASTUNSIGNED))
657     {
658       return TRUE;
659     }
660   return FALSE;
661 }