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