source: rtems-libbsd/freebsd/lib/libc/xdr/xdr.c @ f41a394

5-freebsd-12freebsd-9.3
Last change on this file since f41a394 was f41a394, checked in by Sebastian Huber <sebastian.huber@…>, on Jun 9, 2016 at 9:46:09 AM

XDR(3): Import from FreeBSD

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