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 } 927