1 /* 2 * Sun RPC is a product of Sun Microsystems, Inc. and is provided for 3 * unrestricted use provided that this legend is included on all tape 4 * media and as a part of the software program in whole or part. Users 5 * may copy or modify Sun RPC without charge, but are not authorized 6 * to license or distribute it to anyone else except as part of a product or 7 * program developed by the user. 8 * 9 * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE 10 * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR 11 * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE. 12 * 13 * Sun RPC is provided with no support and without any obligation on the 14 * part of Sun Microsystems, Inc. to assist in its use, correction, 15 * modification or enhancement. 16 * 17 * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE 18 * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC 19 * OR ANY PART THEREOF. 20 * 21 * In no event will Sun Microsystems, Inc. be liable for any lost revenue 22 * or profits or other special, indirect and consequential damages, even if 23 * Sun has been advised of the possibility of such damages. 24 * 25 * Sun Microsystems, Inc. 26 * 2550 Garcia Avenue 27 * Mountain View, California 94043 28 * 29 * @(#)xdr.c 1.35 87/08/12 30 * @(#)xdr.c 2.1 88/07/29 4.0 RPCSRC 31 * $NetBSD: xdr.c,v 1.22 2000/07/06 03:10:35 christos Exp $ 32 * $FreeBSD: src/lib/libc/xdr/xdr.c,v 1.14 2004/10/16 06:32:43 obrien Exp $ 33 * $DragonFly: src/lib/libc/xdr/xdr.c,v 1.4 2005/12/05 00:47:57 swildner Exp $ 34 */ 35 36 /* 37 * xdr.c, Generic XDR routines implementation. 38 * 39 * Copyright (C) 1986, Sun Microsystems, Inc. 40 * 41 * These are the "generic" xdr routines used to serialize and de-serialize 42 * most common data items. See xdr.h for more info on the interface to 43 * xdr. 44 */ 45 46 #include "namespace.h" 47 #include <err.h> 48 #include <stdio.h> 49 #include <stdlib.h> 50 #include <string.h> 51 52 #include <rpc/types.h> 53 #include <rpc/xdr.h> 54 #include "un-namespace.h" 55 56 typedef quad_t longlong_t; /* ANSI long long type */ 57 typedef u_quad_t u_longlong_t; /* ANSI unsigned long long type */ 58 59 /* 60 * constants specific to the xdr "protocol" 61 */ 62 #define XDR_FALSE ((long) 0) 63 #define XDR_TRUE ((long) 1) 64 #define LASTUNSIGNED ((u_int) 0-1) 65 66 /* 67 * for unit alignment 68 */ 69 static const char xdr_zero[BYTES_PER_XDR_UNIT] = { 0, 0, 0, 0 }; 70 71 /* 72 * Free a data structure using XDR 73 * Not a filter, but a convenient utility nonetheless 74 */ 75 void 76 xdr_free(xdrproc_t proc, void *objp) 77 { 78 XDR x; 79 80 x.x_op = XDR_FREE; 81 (*proc)(&x, objp); 82 } 83 84 /* 85 * XDR nothing 86 */ 87 bool_t 88 xdr_void(void) 89 { 90 91 return (TRUE); 92 } 93 94 95 /* 96 * XDR integers 97 */ 98 bool_t 99 xdr_int(XDR *xdrs, int *ip) 100 { 101 long l; 102 103 switch (xdrs->x_op) { 104 105 case XDR_ENCODE: 106 l = (long) *ip; 107 return (XDR_PUTLONG(xdrs, &l)); 108 109 case XDR_DECODE: 110 if (!XDR_GETLONG(xdrs, &l)) { 111 return (FALSE); 112 } 113 *ip = (int) l; 114 return (TRUE); 115 116 case XDR_FREE: 117 return (TRUE); 118 } 119 /* NOTREACHED */ 120 return (FALSE); 121 } 122 123 /* 124 * XDR unsigned integers 125 */ 126 bool_t 127 xdr_u_int(XDR *xdrs, u_int *up) 128 { 129 u_long l; 130 131 switch (xdrs->x_op) { 132 133 case XDR_ENCODE: 134 l = (u_long) *up; 135 return (XDR_PUTLONG(xdrs, (long *)&l)); 136 137 case XDR_DECODE: 138 if (!XDR_GETLONG(xdrs, (long *)&l)) { 139 return (FALSE); 140 } 141 *up = (u_int) l; 142 return (TRUE); 143 144 case XDR_FREE: 145 return (TRUE); 146 } 147 /* NOTREACHED */ 148 return (FALSE); 149 } 150 151 152 /* 153 * XDR long integers 154 * same as xdr_u_long - open coded to save a proc call! 155 */ 156 bool_t 157 xdr_long(XDR *xdrs, long *lp) 158 { 159 switch (xdrs->x_op) { 160 case XDR_ENCODE: 161 return (XDR_PUTLONG(xdrs, lp)); 162 case XDR_DECODE: 163 return (XDR_GETLONG(xdrs, lp)); 164 case XDR_FREE: 165 return (TRUE); 166 } 167 /* NOTREACHED */ 168 return (FALSE); 169 } 170 171 /* 172 * XDR unsigned long integers 173 * same as xdr_long - open coded to save a proc call! 174 */ 175 bool_t 176 xdr_u_long(XDR *xdrs, u_long *ulp) 177 { 178 switch (xdrs->x_op) { 179 case XDR_ENCODE: 180 return (XDR_PUTLONG(xdrs, (long *)ulp)); 181 case XDR_DECODE: 182 return (XDR_GETLONG(xdrs, (long *)ulp)); 183 case XDR_FREE: 184 return (TRUE); 185 } 186 /* NOTREACHED */ 187 return (FALSE); 188 } 189 190 191 /* 192 * XDR 32-bit integers 193 * same as xdr_u_int32_t - open coded to save a proc call! 194 */ 195 bool_t 196 xdr_int32_t(XDR *xdrs, int32_t *int32_p) 197 { 198 long l; 199 200 switch (xdrs->x_op) { 201 202 case XDR_ENCODE: 203 l = (long) *int32_p; 204 return (XDR_PUTLONG(xdrs, &l)); 205 206 case XDR_DECODE: 207 if (!XDR_GETLONG(xdrs, &l)) { 208 return (FALSE); 209 } 210 *int32_p = (int32_t) l; 211 return (TRUE); 212 213 case XDR_FREE: 214 return (TRUE); 215 } 216 /* NOTREACHED */ 217 return (FALSE); 218 } 219 220 /* 221 * XDR unsigned 32-bit integers 222 * same as xdr_int32_t - open coded to save a proc call! 223 */ 224 bool_t 225 xdr_u_int32_t(XDR *xdrs, u_int32_t *u_int32_p) 226 { 227 u_long l; 228 229 switch (xdrs->x_op) { 230 231 case XDR_ENCODE: 232 l = (u_long) *u_int32_p; 233 return (XDR_PUTLONG(xdrs, (long *)&l)); 234 235 case XDR_DECODE: 236 if (!XDR_GETLONG(xdrs, (long *)&l)) { 237 return (FALSE); 238 } 239 *u_int32_p = (u_int32_t) l; 240 return (TRUE); 241 242 case XDR_FREE: 243 return (TRUE); 244 } 245 /* NOTREACHED */ 246 return (FALSE); 247 } 248 249 250 /* 251 * XDR short integers 252 */ 253 bool_t 254 xdr_short(XDR *xdrs, short *sp) 255 { 256 long l; 257 258 switch (xdrs->x_op) { 259 260 case XDR_ENCODE: 261 l = (long) *sp; 262 return (XDR_PUTLONG(xdrs, &l)); 263 264 case XDR_DECODE: 265 if (!XDR_GETLONG(xdrs, &l)) { 266 return (FALSE); 267 } 268 *sp = (short) l; 269 return (TRUE); 270 271 case XDR_FREE: 272 return (TRUE); 273 } 274 /* NOTREACHED */ 275 return (FALSE); 276 } 277 278 /* 279 * XDR unsigned short integers 280 */ 281 bool_t 282 xdr_u_short(XDR *xdrs, u_short *usp) 283 { 284 u_long l; 285 286 switch (xdrs->x_op) { 287 288 case XDR_ENCODE: 289 l = (u_long) *usp; 290 return (XDR_PUTLONG(xdrs, (long *)&l)); 291 292 case XDR_DECODE: 293 if (!XDR_GETLONG(xdrs, (long *)&l)) { 294 return (FALSE); 295 } 296 *usp = (u_short) l; 297 return (TRUE); 298 299 case XDR_FREE: 300 return (TRUE); 301 } 302 /* NOTREACHED */ 303 return (FALSE); 304 } 305 306 307 /* 308 * XDR 16-bit integers 309 */ 310 bool_t 311 xdr_int16_t(XDR *xdrs, int16_t *int16_p) 312 { 313 long l; 314 315 switch (xdrs->x_op) { 316 317 case XDR_ENCODE: 318 l = (long) *int16_p; 319 return (XDR_PUTLONG(xdrs, &l)); 320 321 case XDR_DECODE: 322 if (!XDR_GETLONG(xdrs, &l)) { 323 return (FALSE); 324 } 325 *int16_p = (int16_t) l; 326 return (TRUE); 327 328 case XDR_FREE: 329 return (TRUE); 330 } 331 /* NOTREACHED */ 332 return (FALSE); 333 } 334 335 /* 336 * XDR unsigned 16-bit integers 337 */ 338 bool_t 339 xdr_u_int16_t(XDR *xdrs, u_int16_t *u_int16_p) 340 { 341 u_long l; 342 343 switch (xdrs->x_op) { 344 345 case XDR_ENCODE: 346 l = (u_long) *u_int16_p; 347 return (XDR_PUTLONG(xdrs, (long *)&l)); 348 349 case XDR_DECODE: 350 if (!XDR_GETLONG(xdrs, (long *)&l)) { 351 return (FALSE); 352 } 353 *u_int16_p = (u_int16_t) l; 354 return (TRUE); 355 356 case XDR_FREE: 357 return (TRUE); 358 } 359 /* NOTREACHED */ 360 return (FALSE); 361 } 362 363 364 /* 365 * XDR a char 366 */ 367 bool_t 368 xdr_char(XDR *xdrs, char *cp) 369 { 370 int i; 371 372 i = (*cp); 373 if (!xdr_int(xdrs, &i)) { 374 return (FALSE); 375 } 376 *cp = i; 377 return (TRUE); 378 } 379 380 /* 381 * XDR an unsigned char 382 */ 383 bool_t 384 xdr_u_char(XDR *xdrs, u_char *cp) 385 { 386 u_int u; 387 388 u = (*cp); 389 if (!xdr_u_int(xdrs, &u)) { 390 return (FALSE); 391 } 392 *cp = u; 393 return (TRUE); 394 } 395 396 /* 397 * XDR booleans 398 */ 399 bool_t 400 xdr_bool(XDR *xdrs, bool_t *bp) 401 { 402 long lb; 403 404 switch (xdrs->x_op) { 405 406 case XDR_ENCODE: 407 lb = *bp ? XDR_TRUE : XDR_FALSE; 408 return (XDR_PUTLONG(xdrs, &lb)); 409 410 case XDR_DECODE: 411 if (!XDR_GETLONG(xdrs, &lb)) { 412 return (FALSE); 413 } 414 *bp = (lb == XDR_FALSE) ? FALSE : TRUE; 415 return (TRUE); 416 417 case XDR_FREE: 418 return (TRUE); 419 } 420 /* NOTREACHED */ 421 return (FALSE); 422 } 423 424 /* 425 * XDR enumerations 426 */ 427 bool_t 428 xdr_enum(XDR *xdrs, enum_t *ep) 429 { 430 enum sizecheck { SIZEVAL }; /* used to find the size of an enum */ 431 432 /* 433 * enums are treated as ints 434 */ 435 /* LINTED */ if (sizeof (enum sizecheck) == sizeof (long)) { 436 return (xdr_long(xdrs, (long *)(void *)ep)); 437 } else /* LINTED */ if (sizeof (enum sizecheck) == sizeof (int)) { 438 return (xdr_int(xdrs, (int *)(void *)ep)); 439 } else /* LINTED */ if (sizeof (enum sizecheck) == sizeof (short)) { 440 return (xdr_short(xdrs, (short *)(void *)ep)); 441 } else { 442 return (FALSE); 443 } 444 } 445 446 /* 447 * XDR opaque data 448 * Allows the specification of a fixed size sequence of opaque bytes. 449 * cp points to the opaque object and cnt gives the byte length. 450 */ 451 bool_t 452 xdr_opaque(XDR *xdrs, caddr_t cp, u_int cnt) 453 { 454 u_int rndup; 455 static int crud[BYTES_PER_XDR_UNIT]; 456 457 /* 458 * if no data we are done 459 */ 460 if (cnt == 0) 461 return (TRUE); 462 463 /* 464 * round byte count to full xdr units 465 */ 466 rndup = cnt % BYTES_PER_XDR_UNIT; 467 if (rndup > 0) 468 rndup = BYTES_PER_XDR_UNIT - rndup; 469 470 if (xdrs->x_op == XDR_DECODE) { 471 if (!XDR_GETBYTES(xdrs, cp, cnt)) { 472 return (FALSE); 473 } 474 if (rndup == 0) 475 return (TRUE); 476 return (XDR_GETBYTES(xdrs, (caddr_t)(void *)crud, rndup)); 477 } 478 479 if (xdrs->x_op == XDR_ENCODE) { 480 if (!XDR_PUTBYTES(xdrs, cp, cnt)) { 481 return (FALSE); 482 } 483 if (rndup == 0) 484 return (TRUE); 485 return (XDR_PUTBYTES(xdrs, xdr_zero, rndup)); 486 } 487 488 if (xdrs->x_op == XDR_FREE) { 489 return (TRUE); 490 } 491 492 return (FALSE); 493 } 494 495 /* 496 * XDR counted bytes 497 * *cpp is a pointer to the bytes, *sizep is the count. 498 * If *cpp is NULL maxsize bytes are allocated 499 */ 500 bool_t 501 xdr_bytes(XDR *xdrs, char **cpp, u_int *sizep, u_int maxsize) 502 { 503 char *sp = *cpp; /* sp is the actual string pointer */ 504 u_int nodesize; 505 506 /* 507 * first deal with the length since xdr bytes are counted 508 */ 509 if (! xdr_u_int(xdrs, sizep)) { 510 return (FALSE); 511 } 512 nodesize = *sizep; 513 if ((nodesize > maxsize) && (xdrs->x_op != XDR_FREE)) { 514 return (FALSE); 515 } 516 517 /* 518 * now deal with the actual bytes 519 */ 520 switch (xdrs->x_op) { 521 522 case XDR_DECODE: 523 if (nodesize == 0) { 524 return (TRUE); 525 } 526 if (sp == NULL) { 527 *cpp = sp = mem_alloc(nodesize); 528 } 529 if (sp == NULL) { 530 warnx("xdr_bytes: out of memory"); 531 return (FALSE); 532 } 533 /* FALLTHROUGH */ 534 535 case XDR_ENCODE: 536 return (xdr_opaque(xdrs, sp, nodesize)); 537 538 case XDR_FREE: 539 if (sp != NULL) { 540 mem_free(sp, nodesize); 541 *cpp = NULL; 542 } 543 return (TRUE); 544 } 545 /* NOTREACHED */ 546 return (FALSE); 547 } 548 549 /* 550 * Implemented here due to commonality of the object. 551 */ 552 bool_t 553 xdr_netobj(XDR *xdrs, struct netobj *np) 554 { 555 return (xdr_bytes(xdrs, &np->n_bytes, &np->n_len, MAX_NETOBJ_SZ)); 556 } 557 558 /* 559 * XDR a descriminated union 560 * Support routine for discriminated unions. 561 * You create an array of xdrdiscrim structures, terminated with 562 * an entry with a null procedure pointer. The routine gets 563 * the discriminant value and then searches the array of xdrdiscrims 564 * looking for that value. It calls the procedure given in the xdrdiscrim 565 * to handle the discriminant. If there is no specific routine a default 566 * routine may be called. 567 * If there is no specific or default routine an error is returned. 568 * 569 * Parameters: 570 * dscmp: enum to decide which ar to work on 571 * unp: the union itself 572 * choices: [value, xdr proc] for each arm 573 * dfault: default xdr routine 574 */ 575 bool_t 576 xdr_union(XDR *xdrs, enum_t *dscmp, char *unp, 577 const struct xdr_discrim *choices, xdrproc_t dfault) 578 { 579 enum_t dscm; 580 581 /* 582 * we deal with the discriminator; it's an enum 583 */ 584 if (! xdr_enum(xdrs, dscmp)) { 585 return (FALSE); 586 } 587 dscm = *dscmp; 588 589 /* 590 * search choices for a value that matches the discriminator. 591 * if we find one, execute the xdr routine for that value. 592 */ 593 for (; choices->proc != NULL_xdrproc_t; choices++) { 594 if (choices->value == dscm) 595 return ((*(choices->proc))(xdrs, unp)); 596 } 597 598 /* 599 * no match - execute the default xdr routine if there is one 600 */ 601 return ((dfault == NULL_xdrproc_t) ? FALSE : 602 (*dfault)(xdrs, unp)); 603 } 604 605 606 /* 607 * Non-portable xdr primitives. 608 * Care should be taken when moving these routines to new architectures. 609 */ 610 611 612 /* 613 * XDR null terminated ASCII strings 614 * xdr_string deals with "C strings" - arrays of bytes that are 615 * terminated by a NULL character. The parameter cpp references a 616 * pointer to storage; If the pointer is null, then the necessary 617 * storage is allocated. The last parameter is the max allowed length 618 * of the string as specified by a protocol. 619 */ 620 bool_t 621 xdr_string(XDR *xdrs, char **cpp, u_int maxsize) 622 { 623 char *sp = *cpp; /* sp is the actual string pointer */ 624 u_int size; 625 u_int nodesize; 626 627 /* 628 * first deal with the length since xdr strings are counted-strings 629 */ 630 switch (xdrs->x_op) { 631 case XDR_FREE: 632 if (sp == NULL) { 633 return(TRUE); /* already free */ 634 } 635 /* FALLTHROUGH */ 636 case XDR_ENCODE: 637 size = strlen(sp); 638 break; 639 case XDR_DECODE: 640 break; 641 } 642 if (! xdr_u_int(xdrs, &size)) { 643 return (FALSE); 644 } 645 if (size > maxsize) { 646 return (FALSE); 647 } 648 nodesize = size + 1; 649 650 /* 651 * now deal with the actual bytes 652 */ 653 switch (xdrs->x_op) { 654 655 case XDR_DECODE: 656 if (nodesize == 0) { 657 return (TRUE); 658 } 659 if (sp == NULL) 660 *cpp = sp = mem_alloc(nodesize); 661 if (sp == NULL) { 662 warnx("xdr_string: out of memory"); 663 return (FALSE); 664 } 665 sp[size] = 0; 666 /* FALLTHROUGH */ 667 668 case XDR_ENCODE: 669 return (xdr_opaque(xdrs, sp, size)); 670 671 case XDR_FREE: 672 mem_free(sp, nodesize); 673 *cpp = NULL; 674 return (TRUE); 675 } 676 /* NOTREACHED */ 677 return (FALSE); 678 } 679 680 /* 681 * Wrapper for xdr_string that can be called directly from 682 * routines like clnt_call 683 */ 684 bool_t 685 xdr_wrapstring(XDR *xdrs, char **cpp) 686 { 687 return xdr_string(xdrs, cpp, LASTUNSIGNED); 688 } 689 690 /* 691 * NOTE: xdr_hyper(), xdr_u_hyper(), xdr_longlong_t(), and xdr_u_longlong_t() 692 * are in the "non-portable" section because they require that a `long long' 693 * be a 64-bit type. 694 * 695 * --thorpej@netbsd.org, November 30, 1999 696 */ 697 698 /* 699 * XDR 64-bit integers 700 */ 701 bool_t 702 xdr_int64_t(XDR *xdrs, int64_t *llp) 703 { 704 u_long ul[2]; 705 706 switch (xdrs->x_op) { 707 case XDR_ENCODE: 708 ul[0] = (u_long)((u_int64_t)*llp >> 32) & 0xffffffff; 709 ul[1] = (u_long)((u_int64_t)*llp) & 0xffffffff; 710 if (XDR_PUTLONG(xdrs, (long *)&ul[0]) == FALSE) 711 return (FALSE); 712 return (XDR_PUTLONG(xdrs, (long *)&ul[1])); 713 case XDR_DECODE: 714 if (XDR_GETLONG(xdrs, (long *)&ul[0]) == FALSE) 715 return (FALSE); 716 if (XDR_GETLONG(xdrs, (long *)&ul[1]) == FALSE) 717 return (FALSE); 718 *llp = (int64_t) 719 (((u_int64_t)ul[0] << 32) | ((u_int64_t)ul[1])); 720 return (TRUE); 721 case XDR_FREE: 722 return (TRUE); 723 } 724 /* NOTREACHED */ 725 return (FALSE); 726 } 727 728 729 /* 730 * XDR unsigned 64-bit integers 731 */ 732 bool_t 733 xdr_u_int64_t(XDR *xdrs, u_int64_t *ullp) 734 { 735 u_long ul[2]; 736 737 switch (xdrs->x_op) { 738 case XDR_ENCODE: 739 ul[0] = (u_long)(*ullp >> 32) & 0xffffffff; 740 ul[1] = (u_long)(*ullp) & 0xffffffff; 741 if (XDR_PUTLONG(xdrs, (long *)&ul[0]) == FALSE) 742 return (FALSE); 743 return (XDR_PUTLONG(xdrs, (long *)&ul[1])); 744 case XDR_DECODE: 745 if (XDR_GETLONG(xdrs, (long *)&ul[0]) == FALSE) 746 return (FALSE); 747 if (XDR_GETLONG(xdrs, (long *)&ul[1]) == FALSE) 748 return (FALSE); 749 *ullp = (u_int64_t) 750 (((u_int64_t)ul[0] << 32) | ((u_int64_t)ul[1])); 751 return (TRUE); 752 case XDR_FREE: 753 return (TRUE); 754 } 755 /* NOTREACHED */ 756 return (FALSE); 757 } 758 759 760 /* 761 * XDR hypers 762 */ 763 bool_t 764 xdr_hyper(XDR *xdrs, longlong_t *llp) 765 { 766 767 /* 768 * Don't bother open-coding this; it's a fair amount of code. Just 769 * call xdr_int64_t(). 770 */ 771 return (xdr_int64_t(xdrs, (int64_t *)llp)); 772 } 773 774 775 /* 776 * XDR unsigned hypers 777 */ 778 bool_t 779 xdr_u_hyper(XDR *xdrs, u_longlong_t *ullp) 780 { 781 782 /* 783 * Don't bother open-coding this; it's a fair amount of code. Just 784 * call xdr_u_int64_t(). 785 */ 786 return (xdr_u_int64_t(xdrs, (u_int64_t *)ullp)); 787 } 788 789 790 /* 791 * XDR longlong_t's 792 */ 793 bool_t 794 xdr_longlong_t(XDR *xdrs, longlong_t *llp) 795 { 796 797 /* 798 * Don't bother open-coding this; it's a fair amount of code. Just 799 * call xdr_int64_t(). 800 */ 801 return (xdr_int64_t(xdrs, (int64_t *)llp)); 802 } 803 804 805 /* 806 * XDR u_longlong_t's 807 */ 808 bool_t 809 xdr_u_longlong_t(XDR *xdrs, u_longlong_t *ullp) 810 { 811 812 /* 813 * Don't bother open-coding this; it's a fair amount of code. Just 814 * call xdr_u_int64_t(). 815 */ 816 return (xdr_u_int64_t(xdrs, (u_int64_t *)ullp)); 817 } 818