lib/libc/xdr/xdr.c

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