xref: /freebsd/lib/libc/xdr/xdr.c (revision 8fc257994d0ce2396196d7a06d50d20c8015f4b7)
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)
33 static char *sccsid2 = "@(#)xdr.c 1.35 87/08/12";
34 static char *sccsid = "@(#)xdr.c	2.1 88/07/29 4.0 RPCSRC";
35 #endif
36 #include <sys/cdefs.h>
37 __FBSDID("$FreeBSD$");
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 "namespace.h"
50 #include <err.h>
51 #include <stdio.h>
52 #include <stdlib.h>
53 #include <string.h>
54 
55 #include <rpc/types.h>
56 #include <rpc/xdr.h>
57 #include "un-namespace.h"
58 
59 typedef quad_t          longlong_t;     /* ANSI long long type */
60 typedef 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 #define LASTUNSIGNED	((u_int) 0-1)
68 
69 /*
70  * for unit alignment
71  */
72 static const char xdr_zero[BYTES_PER_XDR_UNIT] = { 0, 0, 0, 0 };
73 
74 /*
75  * Free a data structure using XDR
76  * Not a filter, but a convenient utility nonetheless
77  */
78 void
79 xdr_free(proc, objp)
80 	xdrproc_t proc;
81 	void *objp;
82 {
83 	XDR x;
84 
85 	x.x_op = XDR_FREE;
86 	(*proc)(&x, objp);
87 }
88 
89 /*
90  * XDR nothing
91  */
92 bool_t
93 xdr_void(void)
94 {
95 
96 	return (TRUE);
97 }
98 
99 
100 /*
101  * XDR integers
102  */
103 bool_t
104 xdr_int(xdrs, ip)
105 	XDR *xdrs;
106 	int *ip;
107 {
108 	long l;
109 
110 	switch (xdrs->x_op) {
111 
112 	case XDR_ENCODE:
113 		l = (long) *ip;
114 		return (XDR_PUTLONG(xdrs, &l));
115 
116 	case XDR_DECODE:
117 		if (!XDR_GETLONG(xdrs, &l)) {
118 			return (FALSE);
119 		}
120 		*ip = (int) l;
121 		return (TRUE);
122 
123 	case XDR_FREE:
124 		return (TRUE);
125 	}
126 	/* NOTREACHED */
127 	return (FALSE);
128 }
129 
130 /*
131  * XDR unsigned integers
132  */
133 bool_t
134 xdr_u_int(xdrs, up)
135 	XDR *xdrs;
136 	u_int *up;
137 {
138 	u_long l;
139 
140 	switch (xdrs->x_op) {
141 
142 	case XDR_ENCODE:
143 		l = (u_long) *up;
144 		return (XDR_PUTLONG(xdrs, (long *)&l));
145 
146 	case XDR_DECODE:
147 		if (!XDR_GETLONG(xdrs, (long *)&l)) {
148 			return (FALSE);
149 		}
150 		*up = (u_int) l;
151 		return (TRUE);
152 
153 	case XDR_FREE:
154 		return (TRUE);
155 	}
156 	/* NOTREACHED */
157 	return (FALSE);
158 }
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 	switch (xdrs->x_op) {
171 	case XDR_ENCODE:
172 		return (XDR_PUTLONG(xdrs, lp));
173 	case XDR_DECODE:
174 		return (XDR_GETLONG(xdrs, lp));
175 	case XDR_FREE:
176 		return (TRUE);
177 	}
178 	/* NOTREACHED */
179 	return (FALSE);
180 }
181 
182 /*
183  * XDR unsigned long integers
184  * same as xdr_long - open coded to save a proc call!
185  */
186 bool_t
187 xdr_u_long(xdrs, ulp)
188 	XDR *xdrs;
189 	u_long *ulp;
190 {
191 	switch (xdrs->x_op) {
192 	case XDR_ENCODE:
193 		return (XDR_PUTLONG(xdrs, (long *)ulp));
194 	case XDR_DECODE:
195 		return (XDR_GETLONG(xdrs, (long *)ulp));
196 	case XDR_FREE:
197 		return (TRUE);
198 	}
199 	/* NOTREACHED */
200 	return (FALSE);
201 }
202 
203 
204 /*
205  * XDR 32-bit integers
206  * same as xdr_u_int32_t - open coded to save a proc call!
207  */
208 bool_t
209 xdr_int32_t(xdrs, int32_p)
210 	XDR *xdrs;
211 	int32_t *int32_p;
212 {
213 	long l;
214 
215 	switch (xdrs->x_op) {
216 
217 	case XDR_ENCODE:
218 		l = (long) *int32_p;
219 		return (XDR_PUTLONG(xdrs, &l));
220 
221 	case XDR_DECODE:
222 		if (!XDR_GETLONG(xdrs, &l)) {
223 			return (FALSE);
224 		}
225 		*int32_p = (int32_t) l;
226 		return (TRUE);
227 
228 	case XDR_FREE:
229 		return (TRUE);
230 	}
231 	/* NOTREACHED */
232 	return (FALSE);
233 }
234 
235 /*
236  * XDR unsigned 32-bit integers
237  * same as xdr_int32_t - open coded to save a proc call!
238  */
239 bool_t
240 xdr_u_int32_t(xdrs, u_int32_p)
241 	XDR *xdrs;
242 	u_int32_t *u_int32_p;
243 {
244 	u_long l;
245 
246 	switch (xdrs->x_op) {
247 
248 	case XDR_ENCODE:
249 		l = (u_long) *u_int32_p;
250 		return (XDR_PUTLONG(xdrs, (long *)&l));
251 
252 	case XDR_DECODE:
253 		if (!XDR_GETLONG(xdrs, (long *)&l)) {
254 			return (FALSE);
255 		}
256 		*u_int32_p = (u_int32_t) l;
257 		return (TRUE);
258 
259 	case XDR_FREE:
260 		return (TRUE);
261 	}
262 	/* NOTREACHED */
263 	return (FALSE);
264 }
265 
266 /*
267  * XDR unsigned 32-bit integers
268  * same as xdr_int32_t - open coded to save a proc call!
269  */
270 bool_t
271 xdr_uint32_t(xdrs, u_int32_p)
272 	XDR *xdrs;
273 	uint32_t *u_int32_p;
274 {
275 	u_long l;
276 
277 	switch (xdrs->x_op) {
278 
279 	case XDR_ENCODE:
280 		l = (u_long) *u_int32_p;
281 		return (XDR_PUTLONG(xdrs, (long *)&l));
282 
283 	case XDR_DECODE:
284 		if (!XDR_GETLONG(xdrs, (long *)&l)) {
285 			return (FALSE);
286 		}
287 		*u_int32_p = (u_int32_t) l;
288 		return (TRUE);
289 
290 	case XDR_FREE:
291 		return (TRUE);
292 	}
293 	/* NOTREACHED */
294 	return (FALSE);
295 }
296 
297 /*
298  * XDR short integers
299  */
300 bool_t
301 xdr_short(xdrs, sp)
302 	XDR *xdrs;
303 	short *sp;
304 {
305 	long l;
306 
307 	switch (xdrs->x_op) {
308 
309 	case XDR_ENCODE:
310 		l = (long) *sp;
311 		return (XDR_PUTLONG(xdrs, &l));
312 
313 	case XDR_DECODE:
314 		if (!XDR_GETLONG(xdrs, &l)) {
315 			return (FALSE);
316 		}
317 		*sp = (short) l;
318 		return (TRUE);
319 
320 	case XDR_FREE:
321 		return (TRUE);
322 	}
323 	/* NOTREACHED */
324 	return (FALSE);
325 }
326 
327 /*
328  * XDR unsigned short integers
329  */
330 bool_t
331 xdr_u_short(xdrs, usp)
332 	XDR *xdrs;
333 	u_short *usp;
334 {
335 	u_long l;
336 
337 	switch (xdrs->x_op) {
338 
339 	case XDR_ENCODE:
340 		l = (u_long) *usp;
341 		return (XDR_PUTLONG(xdrs, (long *)&l));
342 
343 	case XDR_DECODE:
344 		if (!XDR_GETLONG(xdrs, (long *)&l)) {
345 			return (FALSE);
346 		}
347 		*usp = (u_short) l;
348 		return (TRUE);
349 
350 	case XDR_FREE:
351 		return (TRUE);
352 	}
353 	/* NOTREACHED */
354 	return (FALSE);
355 }
356 
357 
358 /*
359  * XDR 16-bit integers
360  */
361 bool_t
362 xdr_int16_t(xdrs, int16_p)
363 	XDR *xdrs;
364 	int16_t *int16_p;
365 {
366 	long l;
367 
368 	switch (xdrs->x_op) {
369 
370 	case XDR_ENCODE:
371 		l = (long) *int16_p;
372 		return (XDR_PUTLONG(xdrs, &l));
373 
374 	case XDR_DECODE:
375 		if (!XDR_GETLONG(xdrs, &l)) {
376 			return (FALSE);
377 		}
378 		*int16_p = (int16_t) l;
379 		return (TRUE);
380 
381 	case XDR_FREE:
382 		return (TRUE);
383 	}
384 	/* NOTREACHED */
385 	return (FALSE);
386 }
387 
388 /*
389  * XDR unsigned 16-bit integers
390  */
391 bool_t
392 xdr_u_int16_t(xdrs, u_int16_p)
393 	XDR *xdrs;
394 	u_int16_t *u_int16_p;
395 {
396 	u_long l;
397 
398 	switch (xdrs->x_op) {
399 
400 	case XDR_ENCODE:
401 		l = (u_long) *u_int16_p;
402 		return (XDR_PUTLONG(xdrs, (long *)&l));
403 
404 	case XDR_DECODE:
405 		if (!XDR_GETLONG(xdrs, (long *)&l)) {
406 			return (FALSE);
407 		}
408 		*u_int16_p = (u_int16_t) l;
409 		return (TRUE);
410 
411 	case XDR_FREE:
412 		return (TRUE);
413 	}
414 	/* NOTREACHED */
415 	return (FALSE);
416 }
417 
418 /*
419  * XDR unsigned 16-bit integers
420  */
421 bool_t
422 xdr_uint16_t(xdrs, u_int16_p)
423 	XDR *xdrs;
424 	uint16_t *u_int16_p;
425 {
426 	u_long l;
427 
428 	switch (xdrs->x_op) {
429 
430 	case XDR_ENCODE:
431 		l = (u_long) *u_int16_p;
432 		return (XDR_PUTLONG(xdrs, (long *)&l));
433 
434 	case XDR_DECODE:
435 		if (!XDR_GETLONG(xdrs, (long *)&l)) {
436 			return (FALSE);
437 		}
438 		*u_int16_p = (u_int16_t) l;
439 		return (TRUE);
440 
441 	case XDR_FREE:
442 		return (TRUE);
443 	}
444 	/* NOTREACHED */
445 	return (FALSE);
446 }
447 
448 
449 /*
450  * XDR a char
451  */
452 bool_t
453 xdr_char(xdrs, cp)
454 	XDR *xdrs;
455 	char *cp;
456 {
457 	int i;
458 
459 	i = (*cp);
460 	if (!xdr_int(xdrs, &i)) {
461 		return (FALSE);
462 	}
463 	*cp = i;
464 	return (TRUE);
465 }
466 
467 /*
468  * XDR an unsigned char
469  */
470 bool_t
471 xdr_u_char(xdrs, cp)
472 	XDR *xdrs;
473 	u_char *cp;
474 {
475 	u_int u;
476 
477 	u = (*cp);
478 	if (!xdr_u_int(xdrs, &u)) {
479 		return (FALSE);
480 	}
481 	*cp = u;
482 	return (TRUE);
483 }
484 
485 /*
486  * XDR booleans
487  */
488 bool_t
489 xdr_bool(xdrs, bp)
490 	XDR *xdrs;
491 	bool_t *bp;
492 {
493 	long lb;
494 
495 	switch (xdrs->x_op) {
496 
497 	case XDR_ENCODE:
498 		lb = *bp ? XDR_TRUE : XDR_FALSE;
499 		return (XDR_PUTLONG(xdrs, &lb));
500 
501 	case XDR_DECODE:
502 		if (!XDR_GETLONG(xdrs, &lb)) {
503 			return (FALSE);
504 		}
505 		*bp = (lb == XDR_FALSE) ? FALSE : TRUE;
506 		return (TRUE);
507 
508 	case XDR_FREE:
509 		return (TRUE);
510 	}
511 	/* NOTREACHED */
512 	return (FALSE);
513 }
514 
515 /*
516  * XDR enumerations
517  */
518 bool_t
519 xdr_enum(xdrs, ep)
520 	XDR *xdrs;
521 	enum_t *ep;
522 {
523 	enum sizecheck { SIZEVAL };	/* used to find the size of an enum */
524 
525 	/*
526 	 * enums are treated as ints
527 	 */
528 	/* LINTED */ if (sizeof (enum sizecheck) == sizeof (long)) {
529 		return (xdr_long(xdrs, (long *)(void *)ep));
530 	} else /* LINTED */ if (sizeof (enum sizecheck) == sizeof (int)) {
531 		return (xdr_int(xdrs, (int *)(void *)ep));
532 	} else /* LINTED */ if (sizeof (enum sizecheck) == sizeof (short)) {
533 		return (xdr_short(xdrs, (short *)(void *)ep));
534 	} else {
535 		return (FALSE);
536 	}
537 }
538 
539 /*
540  * XDR opaque data
541  * Allows the specification of a fixed size sequence of opaque bytes.
542  * cp points to the opaque object and cnt gives the byte length.
543  */
544 bool_t
545 xdr_opaque(xdrs, cp, cnt)
546 	XDR *xdrs;
547 	caddr_t cp;
548 	u_int cnt;
549 {
550 	u_int rndup;
551 	static int crud[BYTES_PER_XDR_UNIT];
552 
553 	/*
554 	 * if no data we are done
555 	 */
556 	if (cnt == 0)
557 		return (TRUE);
558 
559 	/*
560 	 * round byte count to full xdr units
561 	 */
562 	rndup = cnt % BYTES_PER_XDR_UNIT;
563 	if (rndup > 0)
564 		rndup = BYTES_PER_XDR_UNIT - rndup;
565 
566 	if (xdrs->x_op == XDR_DECODE) {
567 		if (!XDR_GETBYTES(xdrs, cp, cnt)) {
568 			return (FALSE);
569 		}
570 		if (rndup == 0)
571 			return (TRUE);
572 		return (XDR_GETBYTES(xdrs, (caddr_t)(void *)crud, rndup));
573 	}
574 
575 	if (xdrs->x_op == XDR_ENCODE) {
576 		if (!XDR_PUTBYTES(xdrs, cp, cnt)) {
577 			return (FALSE);
578 		}
579 		if (rndup == 0)
580 			return (TRUE);
581 		return (XDR_PUTBYTES(xdrs, xdr_zero, rndup));
582 	}
583 
584 	if (xdrs->x_op == XDR_FREE) {
585 		return (TRUE);
586 	}
587 
588 	return (FALSE);
589 }
590 
591 /*
592  * XDR counted bytes
593  * *cpp is a pointer to the bytes, *sizep is the count.
594  * If *cpp is NULL maxsize bytes are allocated
595  */
596 bool_t
597 xdr_bytes(xdrs, cpp, sizep, maxsize)
598 	XDR *xdrs;
599 	char **cpp;
600 	u_int *sizep;
601 	u_int maxsize;
602 {
603 	char *sp = *cpp;  /* sp is the actual string pointer */
604 	u_int nodesize;
605 
606 	/*
607 	 * first deal with the length since xdr bytes are counted
608 	 */
609 	if (! xdr_u_int(xdrs, sizep)) {
610 		return (FALSE);
611 	}
612 	nodesize = *sizep;
613 	if ((nodesize > maxsize) && (xdrs->x_op != XDR_FREE)) {
614 		return (FALSE);
615 	}
616 
617 	/*
618 	 * now deal with the actual bytes
619 	 */
620 	switch (xdrs->x_op) {
621 
622 	case XDR_DECODE:
623 		if (nodesize == 0) {
624 			return (TRUE);
625 		}
626 		if (sp == NULL) {
627 			*cpp = sp = mem_alloc(nodesize);
628 		}
629 		if (sp == NULL) {
630 			warnx("xdr_bytes: out of memory");
631 			return (FALSE);
632 		}
633 		/* FALLTHROUGH */
634 
635 	case XDR_ENCODE:
636 		return (xdr_opaque(xdrs, sp, nodesize));
637 
638 	case XDR_FREE:
639 		if (sp != NULL) {
640 			mem_free(sp, nodesize);
641 			*cpp = NULL;
642 		}
643 		return (TRUE);
644 	}
645 	/* NOTREACHED */
646 	return (FALSE);
647 }
648 
649 /*
650  * Implemented here due to commonality of the object.
651  */
652 bool_t
653 xdr_netobj(xdrs, np)
654 	XDR *xdrs;
655 	struct netobj *np;
656 {
657 
658 	return (xdr_bytes(xdrs, &np->n_bytes, &np->n_len, MAX_NETOBJ_SZ));
659 }
660 
661 /*
662  * XDR a descriminated union
663  * Support routine for discriminated unions.
664  * You create an array of xdrdiscrim structures, terminated with
665  * an entry with a null procedure pointer.  The routine gets
666  * the discriminant value and then searches the array of xdrdiscrims
667  * looking for that value.  It calls the procedure given in the xdrdiscrim
668  * to handle the discriminant.  If there is no specific routine a default
669  * routine may be called.
670  * If there is no specific or default routine an error is returned.
671  */
672 bool_t
673 xdr_union(xdrs, dscmp, unp, choices, dfault)
674 	XDR *xdrs;
675 	enum_t *dscmp;		/* enum to decide which arm to work on */
676 	char *unp;		/* the union itself */
677 	const struct xdr_discrim *choices;	/* [value, xdr proc] for each arm */
678 	xdrproc_t dfault;	/* default xdr routine */
679 {
680 	enum_t dscm;
681 
682 	/*
683 	 * we deal with the discriminator;  it's an enum
684 	 */
685 	if (! xdr_enum(xdrs, dscmp)) {
686 		return (FALSE);
687 	}
688 	dscm = *dscmp;
689 
690 	/*
691 	 * search choices for a value that matches the discriminator.
692 	 * if we find one, execute the xdr routine for that value.
693 	 */
694 	for (; choices->proc != NULL_xdrproc_t; choices++) {
695 		if (choices->value == dscm)
696 			return ((*(choices->proc))(xdrs, unp));
697 	}
698 
699 	/*
700 	 * no match - execute the default xdr routine if there is one
701 	 */
702 	return ((dfault == NULL_xdrproc_t) ? FALSE :
703 	    (*dfault)(xdrs, unp));
704 }
705 
706 
707 /*
708  * Non-portable xdr primitives.
709  * Care should be taken when moving these routines to new architectures.
710  */
711 
712 
713 /*
714  * XDR null terminated ASCII strings
715  * xdr_string deals with "C strings" - arrays of bytes that are
716  * terminated by a NULL character.  The parameter cpp references a
717  * pointer to storage; If the pointer is null, then the necessary
718  * storage is allocated.  The last parameter is the max allowed length
719  * of the string as specified by a protocol.
720  */
721 bool_t
722 xdr_string(xdrs, cpp, maxsize)
723 	XDR *xdrs;
724 	char **cpp;
725 	u_int maxsize;
726 {
727 	char *sp = *cpp;  /* sp is the actual string pointer */
728 	u_int size;
729 	u_int nodesize;
730 
731 	/*
732 	 * first deal with the length since xdr strings are counted-strings
733 	 */
734 	switch (xdrs->x_op) {
735 	case XDR_FREE:
736 		if (sp == NULL) {
737 			return(TRUE);	/* already free */
738 		}
739 		/* FALLTHROUGH */
740 	case XDR_ENCODE:
741 		size = strlen(sp);
742 		break;
743 	case XDR_DECODE:
744 		break;
745 	}
746 	if (! xdr_u_int(xdrs, &size)) {
747 		return (FALSE);
748 	}
749 	if (size > maxsize) {
750 		return (FALSE);
751 	}
752 	nodesize = size + 1;
753 
754 	/*
755 	 * now deal with the actual bytes
756 	 */
757 	switch (xdrs->x_op) {
758 
759 	case XDR_DECODE:
760 		if (nodesize == 0) {
761 			return (TRUE);
762 		}
763 		if (sp == NULL)
764 			*cpp = sp = mem_alloc(nodesize);
765 		if (sp == NULL) {
766 			warnx("xdr_string: out of memory");
767 			return (FALSE);
768 		}
769 		sp[size] = 0;
770 		/* FALLTHROUGH */
771 
772 	case XDR_ENCODE:
773 		return (xdr_opaque(xdrs, sp, size));
774 
775 	case XDR_FREE:
776 		mem_free(sp, nodesize);
777 		*cpp = NULL;
778 		return (TRUE);
779 	}
780 	/* NOTREACHED */
781 	return (FALSE);
782 }
783 
784 /*
785  * Wrapper for xdr_string that can be called directly from
786  * routines like clnt_call
787  */
788 bool_t
789 xdr_wrapstring(xdrs, cpp)
790 	XDR *xdrs;
791 	char **cpp;
792 {
793 	return xdr_string(xdrs, cpp, LASTUNSIGNED);
794 }
795 
796 /*
797  * NOTE: xdr_hyper(), xdr_u_hyper(), xdr_longlong_t(), and xdr_u_longlong_t()
798  * are in the "non-portable" section because they require that a `long long'
799  * be a 64-bit type.
800  *
801  *	--thorpej@netbsd.org, November 30, 1999
802  */
803 
804 /*
805  * XDR 64-bit integers
806  */
807 bool_t
808 xdr_int64_t(xdrs, llp)
809 	XDR *xdrs;
810 	int64_t *llp;
811 {
812 	u_long ul[2];
813 
814 	switch (xdrs->x_op) {
815 	case XDR_ENCODE:
816 		ul[0] = (u_long)((u_int64_t)*llp >> 32) & 0xffffffff;
817 		ul[1] = (u_long)((u_int64_t)*llp) & 0xffffffff;
818 		if (XDR_PUTLONG(xdrs, (long *)&ul[0]) == FALSE)
819 			return (FALSE);
820 		return (XDR_PUTLONG(xdrs, (long *)&ul[1]));
821 	case XDR_DECODE:
822 		if (XDR_GETLONG(xdrs, (long *)&ul[0]) == FALSE)
823 			return (FALSE);
824 		if (XDR_GETLONG(xdrs, (long *)&ul[1]) == FALSE)
825 			return (FALSE);
826 		*llp = (int64_t)
827 		    (((u_int64_t)ul[0] << 32) | ((u_int64_t)ul[1]));
828 		return (TRUE);
829 	case XDR_FREE:
830 		return (TRUE);
831 	}
832 	/* NOTREACHED */
833 	return (FALSE);
834 }
835 
836 
837 /*
838  * XDR unsigned 64-bit integers
839  */
840 bool_t
841 xdr_u_int64_t(xdrs, ullp)
842 	XDR *xdrs;
843 	u_int64_t *ullp;
844 {
845 	u_long ul[2];
846 
847 	switch (xdrs->x_op) {
848 	case XDR_ENCODE:
849 		ul[0] = (u_long)(*ullp >> 32) & 0xffffffff;
850 		ul[1] = (u_long)(*ullp) & 0xffffffff;
851 		if (XDR_PUTLONG(xdrs, (long *)&ul[0]) == FALSE)
852 			return (FALSE);
853 		return (XDR_PUTLONG(xdrs, (long *)&ul[1]));
854 	case XDR_DECODE:
855 		if (XDR_GETLONG(xdrs, (long *)&ul[0]) == FALSE)
856 			return (FALSE);
857 		if (XDR_GETLONG(xdrs, (long *)&ul[1]) == FALSE)
858 			return (FALSE);
859 		*ullp = (u_int64_t)
860 		    (((u_int64_t)ul[0] << 32) | ((u_int64_t)ul[1]));
861 		return (TRUE);
862 	case XDR_FREE:
863 		return (TRUE);
864 	}
865 	/* NOTREACHED */
866 	return (FALSE);
867 }
868 
869 /*
870  * XDR unsigned 64-bit integers
871  */
872 bool_t
873 xdr_uint64_t(xdrs, ullp)
874 	XDR *xdrs;
875 	uint64_t *ullp;
876 {
877 	u_long ul[2];
878 
879 	switch (xdrs->x_op) {
880 	case XDR_ENCODE:
881 		ul[0] = (u_long)(*ullp >> 32) & 0xffffffff;
882 		ul[1] = (u_long)(*ullp) & 0xffffffff;
883 		if (XDR_PUTLONG(xdrs, (long *)&ul[0]) == FALSE)
884 			return (FALSE);
885 		return (XDR_PUTLONG(xdrs, (long *)&ul[1]));
886 	case XDR_DECODE:
887 		if (XDR_GETLONG(xdrs, (long *)&ul[0]) == FALSE)
888 			return (FALSE);
889 		if (XDR_GETLONG(xdrs, (long *)&ul[1]) == FALSE)
890 			return (FALSE);
891 		*ullp = (u_int64_t)
892 		    (((u_int64_t)ul[0] << 32) | ((u_int64_t)ul[1]));
893 		return (TRUE);
894 	case XDR_FREE:
895 		return (TRUE);
896 	}
897 	/* NOTREACHED */
898 	return (FALSE);
899 }
900 
901 
902 /*
903  * XDR hypers
904  */
905 bool_t
906 xdr_hyper(xdrs, llp)
907 	XDR *xdrs;
908 	longlong_t *llp;
909 {
910 
911 	/*
912 	 * Don't bother open-coding this; it's a fair amount of code.  Just
913 	 * call xdr_int64_t().
914 	 */
915 	return (xdr_int64_t(xdrs, (int64_t *)llp));
916 }
917 
918 
919 /*
920  * XDR unsigned hypers
921  */
922 bool_t
923 xdr_u_hyper(xdrs, ullp)
924 	XDR *xdrs;
925 	u_longlong_t *ullp;
926 {
927 
928 	/*
929 	 * Don't bother open-coding this; it's a fair amount of code.  Just
930 	 * call xdr_u_int64_t().
931 	 */
932 	return (xdr_u_int64_t(xdrs, (u_int64_t *)ullp));
933 }
934 
935 
936 /*
937  * XDR longlong_t's
938  */
939 bool_t
940 xdr_longlong_t(xdrs, llp)
941 	XDR *xdrs;
942 	longlong_t *llp;
943 {
944 
945 	/*
946 	 * Don't bother open-coding this; it's a fair amount of code.  Just
947 	 * call xdr_int64_t().
948 	 */
949 	return (xdr_int64_t(xdrs, (int64_t *)llp));
950 }
951 
952 
953 /*
954  * XDR u_longlong_t's
955  */
956 bool_t
957 xdr_u_longlong_t(xdrs, ullp)
958 	XDR *xdrs;
959 	u_longlong_t *ullp;
960 {
961 
962 	/*
963 	 * Don't bother open-coding this; it's a fair amount of code.  Just
964 	 * call xdr_u_int64_t().
965 	 */
966 	return (xdr_u_int64_t(xdrs, (u_int64_t *)ullp));
967 }
968