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