xdr.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    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 #include <sys/module.h>
   54 
   55 #include <rpc/rpc.h>
   56 #include <rpc/rpc_com.h>
   57 #include <rpc/types.h>
   58 #include <rpc/xdr.h>
   59 
   60 typedef quad_t          longlong_t;     /* ANSI long long type */
   61 typedef u_quad_t        u_longlong_t;   /* ANSI unsigned long long type */
   62 
   63 /*
   64  * constants specific to the xdr "protocol"
   65  */
   66 #define XDR_FALSE       ((long) 0)
   67 #define XDR_TRUE        ((long) 1)
   68 
   69 MALLOC_DEFINE(M_RPC, "rpc", "Remote Procedure Call");
   70 
   71 /*
   72  * for unit alignment
   73  */
   74 static 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  */
   80 void
   81 xdr_free(xdrproc_t proc, 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  * XDR integers
  101  */
  102 bool_t
  103 xdr_int(XDR *xdrs, int *ip)
  104 {
  105         long l;
  106 
  107         switch (xdrs->x_op) {
  108         case XDR_ENCODE:
  109                 l = (long) *ip;
  110                 return (XDR_PUTLONG(xdrs, &l));
  111 
  112         case XDR_DECODE:
  113                 if (!XDR_GETLONG(xdrs, &l)) {
  114                         return (FALSE);
  115                 }
  116                 *ip = (int) l;
  117                 return (TRUE);
  118 
  119         case XDR_FREE:
  120                 return (TRUE);
  121         }
  122         /* NOTREACHED */
  123         return (FALSE);
  124 }
  125 
  126 /*
  127  * XDR unsigned integers
  128  */
  129 bool_t
  130 xdr_u_int(XDR *xdrs, u_int *up)
  131 {
  132         u_long l;
  133 
  134         switch (xdrs->x_op) {
  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  * XDR long integers
  155  * same as xdr_u_long - open coded to save a proc call!
  156  */
  157 bool_t
  158 xdr_long(XDR *xdrs, long *lp)
  159 {
  160         switch (xdrs->x_op) {
  161         case XDR_ENCODE:
  162                 return (XDR_PUTLONG(xdrs, lp));
  163         case XDR_DECODE:
  164                 return (XDR_GETLONG(xdrs, lp));
  165         case XDR_FREE:
  166                 return (TRUE);
  167         }
  168         /* NOTREACHED */
  169         return (FALSE);
  170 }
  171 
  172 /*
  173  * XDR unsigned long integers
  174  * same as xdr_long - open coded to save a proc call!
  175  */
  176 bool_t
  177 xdr_u_long(XDR *xdrs, u_long *ulp)
  178 {
  179         switch (xdrs->x_op) {
  180         case XDR_ENCODE:
  181                 return (XDR_PUTLONG(xdrs, (long *)ulp));
  182         case XDR_DECODE:
  183                 return (XDR_GETLONG(xdrs, (long *)ulp));
  184         case XDR_FREE:
  185                 return (TRUE);
  186         }
  187         /* NOTREACHED */
  188         return (FALSE);
  189 }
  190 
  191 /*
  192  * XDR 32-bit integers
  193  * same as xdr_uint32_t - open coded to save a proc call!
  194  */
  195 bool_t
  196 xdr_int32_t(XDR *xdrs, int32_t *int32_p)
  197 {
  198         long l;
  199 
  200         switch (xdrs->x_op) {
  201         case XDR_ENCODE:
  202                 l = (long) *int32_p;
  203                 return (XDR_PUTLONG(xdrs, &l));
  204 
  205         case XDR_DECODE:
  206                 if (!XDR_GETLONG(xdrs, &l)) {
  207                         return (FALSE);
  208                 }
  209                 *int32_p = (int32_t) l;
  210                 return (TRUE);
  211 
  212         case XDR_FREE:
  213                 return (TRUE);
  214         }
  215         /* NOTREACHED */
  216         return (FALSE);
  217 }
  218 
  219 /*
  220  * XDR unsigned 32-bit integers
  221  * same as xdr_int32_t - open coded to save a proc call!
  222  */
  223 bool_t
  224 xdr_uint32_t(XDR *xdrs, uint32_t *uint32_p)
  225 {
  226         u_long l;
  227 
  228         switch (xdrs->x_op) {
  229         case XDR_ENCODE:
  230                 l = (u_long) *uint32_p;
  231                 return (XDR_PUTLONG(xdrs, (long *)&l));
  232 
  233         case XDR_DECODE:
  234                 if (!XDR_GETLONG(xdrs, (long *)&l)) {
  235                         return (FALSE);
  236                 }
  237                 *uint32_p = (uint32_t) l;
  238                 return (TRUE);
  239 
  240         case XDR_FREE:
  241                 return (TRUE);
  242         }
  243         /* NOTREACHED */
  244         return (FALSE);
  245 }
  246 
  247 /*
  248  * XDR short integers
  249  */
  250 bool_t
  251 xdr_short(XDR *xdrs, short *sp)
  252 {
  253         long l;
  254 
  255         switch (xdrs->x_op) {
  256         case XDR_ENCODE:
  257                 l = (long) *sp;
  258                 return (XDR_PUTLONG(xdrs, &l));
  259 
  260         case XDR_DECODE:
  261                 if (!XDR_GETLONG(xdrs, &l)) {
  262                         return (FALSE);
  263                 }
  264                 *sp = (short) l;
  265                 return (TRUE);
  266 
  267         case XDR_FREE:
  268                 return (TRUE);
  269         }
  270         /* NOTREACHED */
  271         return (FALSE);
  272 }
  273 
  274 /*
  275  * XDR unsigned short integers
  276  */
  277 bool_t
  278 xdr_u_short(XDR *xdrs, u_short *usp)
  279 {
  280         u_long l;
  281 
  282         switch (xdrs->x_op) {
  283         case XDR_ENCODE:
  284                 l = (u_long) *usp;
  285                 return (XDR_PUTLONG(xdrs, (long *)&l));
  286 
  287         case XDR_DECODE:
  288                 if (!XDR_GETLONG(xdrs, (long *)&l)) {
  289                         return (FALSE);
  290                 }
  291                 *usp = (u_short) l;
  292                 return (TRUE);
  293 
  294         case XDR_FREE:
  295                 return (TRUE);
  296         }
  297         /* NOTREACHED */
  298         return (FALSE);
  299 }
  300 
  301 /*
  302  * XDR 16-bit integers
  303  */
  304 bool_t
  305 xdr_int16_t(XDR *xdrs, int16_t *int16_p)
  306 {
  307         long l;
  308 
  309         switch (xdrs->x_op) {
  310         case XDR_ENCODE:
  311                 l = (long) *int16_p;
  312                 return (XDR_PUTLONG(xdrs, &l));
  313 
  314         case XDR_DECODE:
  315                 if (!XDR_GETLONG(xdrs, &l)) {
  316                         return (FALSE);
  317                 }
  318                 *int16_p = (int16_t) l;
  319                 return (TRUE);
  320 
  321         case XDR_FREE:
  322                 return (TRUE);
  323         }
  324         /* NOTREACHED */
  325         return (FALSE);
  326 }
  327 
  328 /*
  329  * XDR unsigned 16-bit integers
  330  */
  331 bool_t
  332 xdr_uint16_t(XDR *xdrs, uint16_t *uint16_p)
  333 {
  334         u_long l;
  335 
  336         switch (xdrs->x_op) {
  337         case XDR_ENCODE:
  338                 l = (u_long) *uint16_p;
  339                 return (XDR_PUTLONG(xdrs, (long *)&l));
  340 
  341         case XDR_DECODE:
  342                 if (!XDR_GETLONG(xdrs, (long *)&l)) {
  343                         return (FALSE);
  344                 }
  345                 *uint16_p = (uint16_t) l;
  346                 return (TRUE);
  347 
  348         case XDR_FREE:
  349                 return (TRUE);
  350         }
  351         /* NOTREACHED */
  352         return (FALSE);
  353 }
  354 
  355 /*
  356  * XDR a char
  357  */
  358 bool_t
  359 xdr_char(XDR *xdrs, char *cp)
  360 {
  361         int i;
  362 
  363         i = (*cp);
  364         if (!xdr_int(xdrs, &i)) {
  365                 return (FALSE);
  366         }
  367         *cp = i;
  368         return (TRUE);
  369 }
  370 
  371 /*
  372  * XDR an unsigned char
  373  */
  374 bool_t
  375 xdr_u_char(XDR *xdrs, u_char *cp)
  376 {
  377         u_int u;
  378 
  379         u = (*cp);
  380         if (!xdr_u_int(xdrs, &u)) {
  381                 return (FALSE);
  382         }
  383         *cp = u;
  384         return (TRUE);
  385 }
  386 
  387 /*
  388  * XDR booleans
  389  */
  390 bool_t
  391 xdr_bool(XDR *xdrs, bool_t *bp)
  392 {
  393         long lb;
  394 
  395         switch (xdrs->x_op) {
  396         case XDR_ENCODE:
  397                 lb = *bp ? XDR_TRUE : XDR_FALSE;
  398                 return (XDR_PUTLONG(xdrs, &lb));
  399 
  400         case XDR_DECODE:
  401                 if (!XDR_GETLONG(xdrs, &lb)) {
  402                         return (FALSE);
  403                 }
  404                 *bp = (lb == XDR_FALSE) ? FALSE : TRUE;
  405                 return (TRUE);
  406 
  407         case XDR_FREE:
  408                 return (TRUE);
  409         }
  410         /* NOTREACHED */
  411         return (FALSE);
  412 }
  413 
  414 /*
  415  * XDR enumerations
  416  */
  417 bool_t
  418 xdr_enum(XDR *xdrs, enum_t *ep)
  419 {
  420         enum sizecheck { SIZEVAL };     /* used to find the size of an enum */
  421 
  422         /*
  423          * enums are treated as ints
  424          */
  425         /* LINTED */ if (sizeof (enum sizecheck) == sizeof (long)) {
  426                 return (xdr_long(xdrs, (long *)(void *)ep));
  427         } else /* LINTED */ if (sizeof (enum sizecheck) == sizeof (int)) {
  428                 return (xdr_int(xdrs, (int *)(void *)ep));
  429         } else /* LINTED */ if (sizeof (enum sizecheck) == sizeof (short)) {
  430                 return (xdr_short(xdrs, (short *)(void *)ep));
  431         } else {
  432                 return (FALSE);
  433         }
  434 }
  435 
  436 /*
  437  * XDR opaque data
  438  * Allows the specification of a fixed size sequence of opaque bytes.
  439  * cp points to the opaque object and cnt gives the byte length.
  440  */
  441 bool_t
  442 xdr_opaque(XDR *xdrs, caddr_t cp, u_int cnt)
  443 {
  444         u_int rndup;
  445         static int crud[BYTES_PER_XDR_UNIT];
  446 
  447         /*
  448          * if no data we are done
  449          */
  450         if (cnt == 0)
  451                 return (TRUE);
  452 
  453         /*
  454          * round byte count to full xdr units
  455          */
  456         rndup = cnt % BYTES_PER_XDR_UNIT;
  457         if (rndup > 0)
  458                 rndup = BYTES_PER_XDR_UNIT - rndup;
  459 
  460         if (xdrs->x_op == XDR_DECODE) {
  461                 if (!XDR_GETBYTES(xdrs, cp, cnt)) {
  462                         return (FALSE);
  463                 }
  464                 if (rndup == 0)
  465                         return (TRUE);
  466                 return (XDR_GETBYTES(xdrs, (caddr_t)(void *)crud, rndup));
  467         }
  468 
  469         if (xdrs->x_op == XDR_ENCODE) {
  470                 if (!XDR_PUTBYTES(xdrs, cp, cnt)) {
  471                         return (FALSE);
  472                 }
  473                 if (rndup == 0)
  474                         return (TRUE);
  475                 return (XDR_PUTBYTES(xdrs, xdr_zero, rndup));
  476         }
  477 
  478         if (xdrs->x_op == XDR_FREE) {
  479                 return (TRUE);
  480         }
  481 
  482         return (FALSE);
  483 }
  484 
  485 /*
  486  * XDR counted bytes
  487  * *cpp is a pointer to the bytes, *sizep is the count.
  488  * If *cpp is NULL maxsize bytes are allocated
  489  */
  490 bool_t
  491 xdr_bytes(XDR *xdrs, char **cpp, u_int *sizep, u_int maxsize)
  492 {
  493         char *sp = *cpp;  /* sp is the actual string pointer */
  494         u_int nodesize;
  495         bool_t ret, allocated = FALSE;
  496 
  497         /*
  498          * first deal with the length since xdr bytes are counted
  499          */
  500         if (! xdr_u_int(xdrs, sizep)) {
  501                 return (FALSE);
  502         }
  503         nodesize = *sizep;
  504         if ((nodesize > maxsize) && (xdrs->x_op != XDR_FREE)) {
  505                 return (FALSE);
  506         }
  507 
  508         /*
  509          * now deal with the actual bytes
  510          */
  511         switch (xdrs->x_op) {
  512         case XDR_DECODE:
  513                 if (nodesize == 0) {
  514                         return (TRUE);
  515                 }
  516                 if (sp == NULL) {
  517                         *cpp = sp = mem_alloc(nodesize);
  518                         allocated = TRUE;
  519                 }
  520                 if (sp == NULL) {
  521                         printf("xdr_bytes: out of memory");
  522                         return (FALSE);
  523                 }
  524                 /* FALLTHROUGH */
  525 
  526         case XDR_ENCODE:
  527                 ret = xdr_opaque(xdrs, sp, nodesize);
  528                 if ((xdrs->x_op == XDR_DECODE) && (ret == FALSE)) {
  529                         if (allocated == TRUE) {
  530                                 mem_free(sp, nodesize);
  531                                 *cpp = NULL;
  532                         }
  533                 }
  534                 return (ret);
  535 
  536         case XDR_FREE:
  537                 if (sp != NULL) {
  538                         mem_free(sp, nodesize);
  539                         *cpp = NULL;
  540                 }
  541                 return (TRUE);
  542         }
  543         /* NOTREACHED */
  544         return (FALSE);
  545 }
  546 
  547 /*
  548  * Implemented here due to commonality of the object.
  549  */
  550 bool_t
  551 xdr_netobj(XDR *xdrs, struct netobj *np)
  552 {
  553 
  554         return (xdr_bytes(xdrs, &np->n_bytes, &np->n_len, MAX_NETOBJ_SZ));
  555 }
  556 
  557 /*
  558  * XDR a descriminated union
  559  * Support routine for discriminated unions.
  560  * You create an array of xdrdiscrim structures, terminated with
  561  * an entry with a null procedure pointer.  The routine gets
  562  * the discriminant value and then searches the array of xdrdiscrims
  563  * looking for that value.  It calls the procedure given in the xdrdiscrim
  564  * to handle the discriminant.  If there is no specific routine a default
  565  * routine may be called.
  566  * If there is no specific or default routine an error is returned.
  567  */
  568 bool_t
  569 xdr_union(XDR *xdrs,
  570     enum_t *dscmp,              /* enum to decide which arm to work on */
  571     char *unp,                          /* the union itself */
  572     const struct xdr_discrim *choices,  /* [value, xdr proc] for each arm */
  573     xdrproc_t dfault)                   /* default xdr routine */
  574 {
  575         enum_t dscm;
  576 
  577         /*
  578          * we deal with the discriminator;  it's an enum
  579          */
  580         if (! xdr_enum(xdrs, dscmp)) {
  581                 return (FALSE);
  582         }
  583         dscm = *dscmp;
  584 
  585         /*
  586          * search choices for a value that matches the discriminator.
  587          * if we find one, execute the xdr routine for that value.
  588          */
  589         for (; choices->proc != NULL_xdrproc_t; choices++) {
  590                 if (choices->value == dscm)
  591                         return ((*(choices->proc))(xdrs, unp));
  592         }
  593 
  594         /*
  595          * no match - execute the default xdr routine if there is one
  596          */
  597         return ((dfault == NULL_xdrproc_t) ? FALSE :
  598             (*dfault)(xdrs, unp));
  599 }
  600 
  601 /*
  602  * Non-portable xdr primitives.
  603  * Care should be taken when moving these routines to new architectures.
  604  */
  605 
  606 /*
  607  * XDR null terminated ASCII strings
  608  * xdr_string deals with "C strings" - arrays of bytes that are
  609  * terminated by a NULL character.  The parameter cpp references a
  610  * pointer to storage; If the pointer is null, then the necessary
  611  * storage is allocated.  The last parameter is the max allowed length
  612  * of the string as specified by a protocol.
  613  */
  614 bool_t
  615 xdr_string(XDR *xdrs, char **cpp, u_int maxsize)
  616 {
  617         char *sp = *cpp;  /* sp is the actual string pointer */
  618         u_int size;
  619         u_int nodesize;
  620         bool_t ret, allocated = FALSE;
  621 
  622         /*
  623          * first deal with the length since xdr strings are counted-strings
  624          */
  625         switch (xdrs->x_op) {
  626         case XDR_FREE:
  627                 if (sp == NULL) {
  628                         return(TRUE);   /* already free */
  629                 }
  630                 /* FALLTHROUGH */
  631         case XDR_ENCODE:
  632                 size = strlen(sp);
  633                 break;
  634         case XDR_DECODE:
  635                 break;
  636         }
  637         if (! xdr_u_int(xdrs, &size)) {
  638                 return (FALSE);
  639         }
  640         if (size > maxsize) {
  641                 return (FALSE);
  642         }
  643         nodesize = size + 1;
  644 
  645         /*
  646          * now deal with the actual bytes
  647          */
  648         switch (xdrs->x_op) {
  649         case XDR_DECODE:
  650                 if (nodesize == 0) {
  651                         return (TRUE);
  652                 }
  653                 if (sp == NULL) {
  654                         *cpp = sp = mem_alloc(nodesize);
  655                         allocated = TRUE;
  656                 }
  657                 if (sp == NULL) {
  658                         printf("xdr_string: out of memory");
  659                         return (FALSE);
  660                 }
  661                 sp[size] = 0;
  662                 /* FALLTHROUGH */
  663 
  664         case XDR_ENCODE:
  665                 ret = xdr_opaque(xdrs, sp, size);
  666                 if ((xdrs->x_op == XDR_DECODE) && (ret == FALSE)) {
  667                         if (allocated == TRUE) {
  668                                 mem_free(sp, nodesize);
  669                                 *cpp = NULL;
  670                         }
  671                 }
  672                 return (ret);
  673 
  674         case XDR_FREE:
  675                 mem_free(sp, nodesize);
  676                 *cpp = NULL;
  677                 return (TRUE);
  678         }
  679         /* NOTREACHED */
  680         return (FALSE);
  681 }
  682 
  683 /* 
  684  * Wrapper for xdr_string that can be called directly from 
  685  * routines like clnt_call
  686  */
  687 bool_t
  688 xdr_wrapstring(XDR *xdrs, char **cpp)
  689 {
  690         return xdr_string(xdrs, cpp, RPC_MAXDATASIZE);
  691 }
  692 
  693 /*
  694  * NOTE: xdr_hyper(), xdr_u_hyper(), xdr_longlong_t(), and xdr_u_longlong_t()
  695  * are in the "non-portable" section because they require that a `long long'
  696  * be a 64-bit type.
  697  *
  698  *      --thorpej@netbsd.org, November 30, 1999
  699  */
  700 
  701 /*
  702  * XDR 64-bit integers
  703  */
  704 bool_t
  705 xdr_int64_t(XDR *xdrs, int64_t *llp)
  706 {
  707         u_long ul[2];
  708 
  709         switch (xdrs->x_op) {
  710         case XDR_ENCODE:
  711                 ul[0] = (u_long)((uint64_t)*llp >> 32) & 0xffffffff;
  712                 ul[1] = (u_long)((uint64_t)*llp) & 0xffffffff;
  713                 if (XDR_PUTLONG(xdrs, (long *)&ul[0]) == FALSE)
  714                         return (FALSE);
  715                 return (XDR_PUTLONG(xdrs, (long *)&ul[1]));
  716         case XDR_DECODE:
  717                 if (XDR_GETLONG(xdrs, (long *)&ul[0]) == FALSE)
  718                         return (FALSE);
  719                 if (XDR_GETLONG(xdrs, (long *)&ul[1]) == FALSE)
  720                         return (FALSE);
  721                 *llp = (int64_t)
  722                     (((uint64_t)ul[0] << 32) | ((uint64_t)ul[1]));
  723                 return (TRUE);
  724         case XDR_FREE:
  725                 return (TRUE);
  726         }
  727         /* NOTREACHED */
  728         return (FALSE);
  729 }
  730 
  731 /*
  732  * XDR unsigned 64-bit integers
  733  */
  734 bool_t
  735 xdr_uint64_t(XDR *xdrs, uint64_t *ullp)
  736 {
  737         u_long ul[2];
  738 
  739         switch (xdrs->x_op) {
  740         case XDR_ENCODE:
  741                 ul[0] = (u_long)(*ullp >> 32) & 0xffffffff;
  742                 ul[1] = (u_long)(*ullp) & 0xffffffff;
  743                 if (XDR_PUTLONG(xdrs, (long *)&ul[0]) == FALSE)
  744                         return (FALSE);
  745                 return (XDR_PUTLONG(xdrs, (long *)&ul[1]));
  746         case XDR_DECODE:
  747                 if (XDR_GETLONG(xdrs, (long *)&ul[0]) == FALSE)
  748                         return (FALSE);
  749                 if (XDR_GETLONG(xdrs, (long *)&ul[1]) == FALSE)
  750                         return (FALSE);
  751                 *ullp = (uint64_t)
  752                     (((uint64_t)ul[0] << 32) | ((uint64_t)ul[1]));
  753                 return (TRUE);
  754         case XDR_FREE:
  755                 return (TRUE);
  756         }
  757         /* NOTREACHED */
  758         return (FALSE);
  759 }
  760 
  761 /*
  762  * XDR hypers
  763  */
  764 bool_t
  765 xdr_hyper(XDR *xdrs, longlong_t *llp)
  766 {
  767 
  768         /*
  769          * Don't bother open-coding this; it's a fair amount of code.  Just
  770          * call xdr_int64_t().
  771          */
  772         return (xdr_int64_t(xdrs, (int64_t *)llp));
  773 }
  774 
  775 /*
  776  * XDR unsigned hypers
  777  */
  778 bool_t
  779 xdr_u_hyper(XDR *xdrs, u_longlong_t *ullp)
  780 {
  781 
  782         /*
  783          * Don't bother open-coding this; it's a fair amount of code.  Just
  784          * call xdr_uint64_t().
  785          */
  786         return (xdr_uint64_t(xdrs, (uint64_t *)ullp));
  787 }
  788 
  789 /*
  790  * XDR longlong_t's
  791  */
  792 bool_t
  793 xdr_longlong_t(XDR *xdrs, longlong_t *llp)
  794 {
  795 
  796         /*
  797          * Don't bother open-coding this; it's a fair amount of code.  Just
  798          * call xdr_int64_t().
  799          */
  800         return (xdr_int64_t(xdrs, (int64_t *)llp));
  801 }
  802 
  803 /*
  804  * XDR u_longlong_t's
  805  */
  806 bool_t
  807 xdr_u_longlong_t(XDR *xdrs, u_longlong_t *ullp)
  808 {
  809 
  810         /*
  811          * Don't bother open-coding this; it's a fair amount of code.  Just
  812          * call xdr_uint64_t().
  813          */
  814         return (xdr_uint64_t(xdrs, (uint64_t *)ullp));
  815 }
  816 
  817 /*
  818  * Kernel module glue
  819  */
  820 static int
  821 xdr_modevent(module_t mod, int type, void *data)
  822 {
  823 
  824         return (0);
  825 }
  826 static moduledata_t xdr_mod = {
  827         "xdr",
  828         xdr_modevent,
  829         NULL,
  830 };
  831 DECLARE_MODULE(xdr, xdr_mod, SI_SUB_VFS, SI_ORDER_ANY);
  832 MODULE_VERSION(xdr, 1);
Cache object: c2e7c796273bbafe9a0cb3bc52531599
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/xdr/xdr.c

FreeBSD/Linux Kernel Cross Reference
sys/xdr/xdr.c
