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