sys/xdr/xdr.c

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