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

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

XDR(3): Port to RTEMS

  • Property mode set to 100644
File size: 17.0 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        /*
526         * enums are treated as ints
527         */
528        /* LINTED */ if (sizeof (enum_t) == sizeof (long)) {
529                return (xdr_long(xdrs, (long *)(void *)ep));
530        } else /* LINTED */ if (sizeof (enum_t) == sizeof (int)) {
531                return (xdr_int(xdrs, (int *)(void *)ep));
532        } else /* LINTED */ if (sizeof (enum_t) == 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 */
544bool_t
545xdr_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 */
596bool_t
597xdr_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 */
652bool_t
653xdr_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 */
672bool_t
673xdr_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 */
721bool_t
722xdr_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 */
788bool_t
789xdr_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 */
807bool_t
808xdr_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 */
840bool_t
841xdr_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 */
872bool_t
873xdr_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 */
905bool_t
906xdr_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 */
922bool_t
923xdr_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 */
939bool_t
940xdr_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 */
956bool_t
957xdr_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}
Note: See TracBrowser for help on using the repository browser.