xref: /freebsd/sys/xdr/xdr.c (revision c697fb7f) 
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 <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 
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 
68 /*
69  * for unit alignment
70  */
71 static 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  */
77 void
78 xdr_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  */
89 bool_t
90 xdr_void(void)
91 {
92 
93 	return (TRUE);
94 }
95 
96 
97 /*
98  * XDR integers
99  */
100 bool_t
101 xdr_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  */
128 bool_t
129 xdr_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  */
158 bool_t
159 xdr_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  */
177 bool_t
178 xdr_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  */
197 bool_t
198 xdr_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  */
226 bool_t
227 xdr_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  */
255 bool_t
256 xdr_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  */
283 bool_t
284 xdr_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  */
312 bool_t
313 xdr_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  */
340 bool_t
341 xdr_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  */
369 bool_t
370 xdr_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  */
385 bool_t
386 xdr_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  */
401 bool_t
402 xdr_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  */
429 bool_t
430 xdr_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  */
453 bool_t
454 xdr_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  */
502 bool_t
503 xdr_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  */
563 bool_t
564 xdr_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  */
581 bool_t
582 xdr_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  */
629 bool_t
630 xdr_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  */
703 bool_t
704 xdr_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  */
720 bool_t
721 xdr_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  */
751 bool_t
752 xdr_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  */
782 bool_t
783 xdr_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  */
797 bool_t
798 xdr_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  */
812 bool_t
813 xdr_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  */
827 bool_t
828 xdr_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