1/* $NetBSD: xdr.c,v 1.22 2000/07/06 03:10:35 christos Exp $ */ 2 3/*- 4 * Copyright (c) 2010, Oracle America, Inc. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions are 8 * met: 9 * 10 * * Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * * Redistributions in binary form must reproduce the above 13 * copyright notice, this list of conditions and the following 14 * disclaimer in the documentation and/or other materials 15 * provided with the distribution. 16 * * Neither the name of the "Oracle America, Inc." nor the names of its 17 * contributors may be used to endorse or promote products derived 18 * from this software without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 23 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 24 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 25 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE 27 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 29 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 30 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 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 * 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 "namespace.h" 50#include <err.h> 51#include <stdio.h> 52#include <stdlib.h> 53#include <string.h> 54 55#include <rpc/types.h> 56#include <rpc/xdr.h> 57#include "un-namespace.h" 58 59typedef quad_t longlong_t; /* ANSI long long type */ 60typedef u_quad_t u_longlong_t; /* ANSI unsigned long long type */ 61 62/* 63 * constants specific to the xdr "protocol" 64 */ 65#define XDR_FALSE ((long) 0) 66#define XDR_TRUE ((long) 1) 67#define LASTUNSIGNED ((u_int) 0-1) 68 69/* 70 * for unit alignment 71 */ 72static 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 */ 78void 79xdr_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 */ 90bool_t 91xdr_void(void) 92{ 93 94 return (TRUE); 95} 96 97 98/* 99 * XDR integers 100 */ 101bool_t 102xdr_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 */ 129bool_t 130xdr_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 */ 159bool_t 160xdr_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 */ 178bool_t 179xdr_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 */ 198bool_t 199xdr_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 */ 227bool_t 228xdr_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 */ 256bool_t 257xdr_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 */ 284bool_t 285xdr_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 */ 312bool_t 313xdr_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 */ 341bool_t 342xdr_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 */ 369bool_t 370xdr_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 */ 397bool_t 398xdr_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 */ 426bool_t 427xdr_char(XDR *xdrs, char *cp) 428{ 429 int i; 430 431 i = (*cp); 432 if (!xdr_int(xdrs, &i)) { 433 return (FALSE); 434 } 435 *cp = i; 436 return (TRUE); 437} 438 439/* 440 * XDR an unsigned char 441 */ 442bool_t 443xdr_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 */ 458bool_t 459xdr_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 */ 486bool_t 487xdr_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 */ 510bool_t 511xdr_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 */ 559bool_t 560xdr_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 565 /* 566 * first deal with the length since xdr bytes are counted 567 */ 568 if (! xdr_u_int(xdrs, sizep)) { 569 return (FALSE); 570 } 571 nodesize = *sizep; 572 if ((nodesize > maxsize) && (xdrs->x_op != XDR_FREE)) { 573 return (FALSE); 574 } 575 576 /* 577 * now deal with the actual bytes 578 */ 579 switch (xdrs->x_op) { 580 581 case XDR_DECODE: 582 if (nodesize == 0) { 583 return (TRUE); 584 } 585 if (sp == NULL) { 586 *cpp = sp = mem_alloc(nodesize); 587 } 588 if (sp == NULL) { 589 warnx("xdr_bytes: out of memory"); 590 return (FALSE); 591 } 592 /* FALLTHROUGH */ 593 594 case XDR_ENCODE: 595 return (xdr_opaque(xdrs, sp, nodesize)); 596 597 case XDR_FREE: 598 if (sp != NULL) { 599 mem_free(sp, nodesize); 600 *cpp = NULL; 601 } 602 return (TRUE); 603 } 604 /* NOTREACHED */ 605 return (FALSE); 606} 607 608/* 609 * Implemented here due to commonality of the object. 610 */ 611bool_t 612xdr_netobj(XDR *xdrs, struct netobj *np) 613{ 614 615 return (xdr_bytes(xdrs, &np->n_bytes, &np->n_len, MAX_NETOBJ_SZ)); 616} 617 618/* 619 * XDR a descriminated union 620 * Support routine for discriminated unions. 621 * You create an array of xdrdiscrim structures, terminated with 622 * an entry with a null procedure pointer. The routine gets 623 * the discriminant value and then searches the array of xdrdiscrims 624 * looking for that value. It calls the procedure given in the xdrdiscrim 625 * to handle the discriminant. If there is no specific routine a default 626 * routine may be called. 627 * If there is no specific or default routine an error is returned. 628 */ 629bool_t 630xdr_union(XDR *xdrs, enum_t *dscmp, char *unp, const struct xdr_discrim *choices, xdrproc_t dfault) 631/* 632 * XDR *xdrs; 633 * enum_t *dscmp; // enum to decide which arm to work on 634 * char *unp; // the union itself 635 * const struct xdr_discrim *choices; // [value, xdr proc] for each arm 636 * xdrproc_t dfault; // default xdr routine 637 */ 638{ 639 enum_t dscm; 640 641 /* 642 * we deal with the discriminator; it's an enum 643 */ 644 if (! xdr_enum(xdrs, dscmp)) { 645 return (FALSE); 646 } 647 dscm = *dscmp; 648 649 /* 650 * search choices for a value that matches the discriminator. 651 * if we find one, execute the xdr routine for that value. 652 */ 653 for (; choices->proc != NULL_xdrproc_t; choices++) { 654 if (choices->value == dscm) 655 return ((*(choices->proc))(xdrs, unp)); 656 } 657 658 /* 659 * no match - execute the default xdr routine if there is one 660 */ 661 return ((dfault == NULL_xdrproc_t) ? FALSE : 662 (*dfault)(xdrs, unp)); 663} 664 665 666/* 667 * Non-portable xdr primitives. 668 * Care should be taken when moving these routines to new architectures. 669 */ 670 671 672/* 673 * XDR null terminated ASCII strings 674 * xdr_string deals with "C strings" - arrays of bytes that are 675 * terminated by a NULL character. The parameter cpp references a 676 * pointer to storage; If the pointer is null, then the necessary 677 * storage is allocated. The last parameter is the max allowed length 678 * of the string as specified by a protocol. 679 */ 680bool_t 681xdr_string(XDR *xdrs, char **cpp, u_int maxsize) 682{ 683 char *sp = *cpp; /* sp is the actual string pointer */ 684 u_int size; 685 u_int nodesize; 686 687 /* 688 * first deal with the length since xdr strings are counted-strings 689 */ 690 switch (xdrs->x_op) { 691 case XDR_FREE: 692 if (sp == NULL) { 693 return(TRUE); /* already free */ 694 } 695 /* FALLTHROUGH */ 696 case XDR_ENCODE: 697 size = strlen(sp); 698 break; 699 case XDR_DECODE: 700 break; 701 } 702 if (! xdr_u_int(xdrs, &size)) { 703 return (FALSE); 704 } 705 if (size > maxsize) { 706 return (FALSE); 707 } 708 nodesize = size + 1; 709 710 /* 711 * now deal with the actual bytes 712 */ 713 switch (xdrs->x_op) { 714 715 case XDR_DECODE: 716 if (nodesize == 0) { 717 return (TRUE); 718 } 719 if (sp == NULL) 720 *cpp = sp = mem_alloc(nodesize); 721 if (sp == NULL) { 722 warnx("xdr_string: out of memory"); 723 return (FALSE); 724 } 725 sp[size] = 0; 726 /* FALLTHROUGH */ 727 728 case XDR_ENCODE: 729 return (xdr_opaque(xdrs, sp, size)); 730 731 case XDR_FREE: 732 mem_free(sp, nodesize); 733 *cpp = NULL; 734 return (TRUE); 735 } 736 /* NOTREACHED */ 737 return (FALSE); 738} 739 740/* 741 * Wrapper for xdr_string that can be called directly from 742 * routines like clnt_call 743 */ 744bool_t 745xdr_wrapstring(XDR *xdrs, char **cpp) 746{ 747 return xdr_string(xdrs, cpp, LASTUNSIGNED); 748} 749 750/* 751 * NOTE: xdr_hyper(), xdr_u_hyper(), xdr_longlong_t(), and xdr_u_longlong_t() 752 * are in the "non-portable" section because they require that a `long long' 753 * be a 64-bit type. 754 * 755 * --thorpej@netbsd.org, November 30, 1999 756 */ 757 758/* 759 * XDR 64-bit integers 760 */ 761bool_t 762xdr_int64_t(XDR *xdrs, int64_t *llp) 763{ 764 u_long ul[2]; 765 766 switch (xdrs->x_op) { 767 case XDR_ENCODE: 768 ul[0] = (u_long)((u_int64_t)*llp >> 32) & 0xffffffff; 769 ul[1] = (u_long)((u_int64_t)*llp) & 0xffffffff; 770 if (XDR_PUTLONG(xdrs, (long *)&ul[0]) == FALSE) 771 return (FALSE); 772 return (XDR_PUTLONG(xdrs, (long *)&ul[1])); 773 case XDR_DECODE: 774 if (XDR_GETLONG(xdrs, (long *)&ul[0]) == FALSE) 775 return (FALSE); 776 if (XDR_GETLONG(xdrs, (long *)&ul[1]) == FALSE) 777 return (FALSE); 778 *llp = (int64_t) 779 (((u_int64_t)ul[0] << 32) | ((u_int64_t)ul[1])); 780 return (TRUE); 781 case XDR_FREE: 782 return (TRUE); 783 } 784 /* NOTREACHED */ 785 return (FALSE); 786} 787 788 789/* 790 * XDR unsigned 64-bit integers 791 */ 792bool_t 793xdr_u_int64_t(XDR *xdrs, u_int64_t *ullp) 794{ 795 u_long ul[2]; 796 797 switch (xdrs->x_op) { 798 case XDR_ENCODE: 799 ul[0] = (u_long)(*ullp >> 32) & 0xffffffff; 800 ul[1] = (u_long)(*ullp) & 0xffffffff; 801 if (XDR_PUTLONG(xdrs, (long *)&ul[0]) == FALSE) 802 return (FALSE); 803 return (XDR_PUTLONG(xdrs, (long *)&ul[1])); 804 case XDR_DECODE: 805 if (XDR_GETLONG(xdrs, (long *)&ul[0]) == FALSE) 806 return (FALSE); 807 if (XDR_GETLONG(xdrs, (long *)&ul[1]) == FALSE) 808 return (FALSE); 809 *ullp = (u_int64_t) 810 (((u_int64_t)ul[0] << 32) | ((u_int64_t)ul[1])); 811 return (TRUE); 812 case XDR_FREE: 813 return (TRUE); 814 } 815 /* NOTREACHED */ 816 return (FALSE); 817} 818 819/* 820 * XDR unsigned 64-bit integers 821 */ 822bool_t 823xdr_uint64_t(XDR *xdrs, uint64_t *ullp) 824{ 825 u_long ul[2]; 826 827 switch (xdrs->x_op) { 828 case XDR_ENCODE: 829 ul[0] = (u_long)(*ullp >> 32) & 0xffffffff; 830 ul[1] = (u_long)(*ullp) & 0xffffffff; 831 if (XDR_PUTLONG(xdrs, (long *)&ul[0]) == FALSE) 832 return (FALSE); 833 return (XDR_PUTLONG(xdrs, (long *)&ul[1])); 834 case XDR_DECODE: 835 if (XDR_GETLONG(xdrs, (long *)&ul[0]) == FALSE) 836 return (FALSE); 837 if (XDR_GETLONG(xdrs, (long *)&ul[1]) == FALSE) 838 return (FALSE); 839 *ullp = (u_int64_t) 840 (((u_int64_t)ul[0] << 32) | ((u_int64_t)ul[1])); 841 return (TRUE); 842 case XDR_FREE: 843 return (TRUE); 844 } 845 /* NOTREACHED */ 846 return (FALSE); 847} 848 849 850/* 851 * XDR hypers 852 */ 853bool_t 854xdr_hyper(XDR *xdrs, longlong_t *llp) 855{ 856 857 /* 858 * Don't bother open-coding this; it's a fair amount of code. Just 859 * call xdr_int64_t(). 860 */ 861 return (xdr_int64_t(xdrs, (int64_t *)llp)); 862} 863 864 865/* 866 * XDR unsigned hypers 867 */ 868bool_t 869xdr_u_hyper(XDR *xdrs, u_longlong_t *ullp) 870{ 871 872 /* 873 * Don't bother open-coding this; it's a fair amount of code. Just 874 * call xdr_u_int64_t(). 875 */ 876 return (xdr_u_int64_t(xdrs, (u_int64_t *)ullp)); 877} 878 879 880/* 881 * XDR longlong_t's 882 */ 883bool_t 884xdr_longlong_t(XDR *xdrs, longlong_t *llp) 885{ 886 887 /* 888 * Don't bother open-coding this; it's a fair amount of code. Just 889 * call xdr_int64_t(). 890 */ 891 return (xdr_int64_t(xdrs, (int64_t *)llp)); 892} 893 894 895/* 896 * XDR u_longlong_t's 897 */ 898bool_t 899xdr_u_longlong_t(XDR *xdrs, u_longlong_t *ullp) 900{ 901 902 /* 903 * Don't bother open-coding this; it's a fair amount of code. Just 904 * call xdr_u_int64_t(). 905 */ 906 return (xdr_u_int64_t(xdrs, (u_int64_t *)ullp)); 907} 908