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