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