1 /* $NetBSD: rpc_generic.c,v 1.4 2000/09/28 09:07:04 kleink Exp $ */ 2 3 /*- 4 * SPDX-License-Identifier: BSD-3-Clause 5 * 6 * Copyright (c) 2009, Sun Microsystems, Inc. 7 * All rights reserved. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions are met: 11 * - Redistributions of source code must retain the above copyright notice, 12 * this list of conditions and the following disclaimer. 13 * - Redistributions in binary form must reproduce the above copyright notice, 14 * this list of conditions and the following disclaimer in the documentation 15 * and/or other materials provided with the distribution. 16 * - Neither the name of Sun Microsystems, 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 "AS IS" 21 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE 24 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 30 * POSSIBILITY OF SUCH DAMAGE. 31 */ 32 /* 33 * Copyright (c) 1986-1991 by Sun Microsystems Inc. 34 */ 35 36 /* #pragma ident "@(#)rpc_generic.c 1.17 94/04/24 SMI" */ 37 #include <sys/cdefs.h> 38 __FBSDID("$FreeBSD$"); 39 40 /* 41 * rpc_generic.c, Miscl routines for RPC. 42 * 43 */ 44 45 #include "opt_inet6.h" 46 47 #include <sys/param.h> 48 #include <sys/kernel.h> 49 #include <sys/malloc.h> 50 #include <sys/mbuf.h> 51 #include <sys/module.h> 52 #include <sys/proc.h> 53 #include <sys/protosw.h> 54 #include <sys/sbuf.h> 55 #include <sys/systm.h> 56 #include <sys/socket.h> 57 #include <sys/socketvar.h> 58 #include <sys/syslog.h> 59 60 #include <net/vnet.h> 61 62 #include <rpc/rpc.h> 63 #include <rpc/nettype.h> 64 #include <rpc/rpcsec_gss.h> 65 66 #include <rpc/rpc_com.h> 67 68 extern u_long sb_max_adj; /* not defined in socketvar.h */ 69 70 /* Provide an entry point hook for the rpcsec_gss module. */ 71 struct rpc_gss_entries rpc_gss_entries; 72 73 struct handle { 74 NCONF_HANDLE *nhandle; 75 int nflag; /* Whether NETPATH or NETCONFIG */ 76 int nettype; 77 }; 78 79 static const struct _rpcnettype { 80 const char *name; 81 const int type; 82 } _rpctypelist[] = { 83 { "netpath", _RPC_NETPATH }, 84 { "visible", _RPC_VISIBLE }, 85 { "circuit_v", _RPC_CIRCUIT_V }, 86 { "datagram_v", _RPC_DATAGRAM_V }, 87 { "circuit_n", _RPC_CIRCUIT_N }, 88 { "datagram_n", _RPC_DATAGRAM_N }, 89 { "tcp", _RPC_TCP }, 90 { "udp", _RPC_UDP }, 91 { 0, _RPC_NONE } 92 }; 93 94 struct netid_af { 95 const char *netid; 96 int af; 97 int protocol; 98 }; 99 100 static const struct netid_af na_cvt[] = { 101 { "udp", AF_INET, IPPROTO_UDP }, 102 { "tcp", AF_INET, IPPROTO_TCP }, 103 #ifdef INET6 104 { "udp6", AF_INET6, IPPROTO_UDP }, 105 { "tcp6", AF_INET6, IPPROTO_TCP }, 106 #endif 107 { "local", AF_LOCAL, 0 } 108 }; 109 110 struct rpc_createerr rpc_createerr; 111 112 /* 113 * Find the appropriate buffer size 114 */ 115 u_int 116 /*ARGSUSED*/ 117 __rpc_get_t_size(int af, int proto, int size) 118 { 119 int defsize; 120 121 switch (proto) { 122 case IPPROTO_TCP: 123 defsize = 64 * 1024; /* XXX */ 124 break; 125 case IPPROTO_UDP: 126 defsize = UDPMSGSIZE; 127 break; 128 default: 129 defsize = RPC_MAXDATASIZE; 130 break; 131 } 132 if (size == 0) 133 return defsize; 134 135 /* Check whether the value is within the upper max limit */ 136 return (size > sb_max_adj ? (u_int)sb_max_adj : (u_int)size); 137 } 138 139 /* 140 * Find the appropriate address buffer size 141 */ 142 u_int 143 __rpc_get_a_size(af) 144 int af; 145 { 146 switch (af) { 147 case AF_INET: 148 return sizeof (struct sockaddr_in); 149 #ifdef INET6 150 case AF_INET6: 151 return sizeof (struct sockaddr_in6); 152 #endif 153 case AF_LOCAL: 154 return sizeof (struct sockaddr_un); 155 default: 156 break; 157 } 158 return ((u_int)RPC_MAXADDRSIZE); 159 } 160 161 #if 0 162 163 /* 164 * Used to ping the NULL procedure for clnt handle. 165 * Returns NULL if fails, else a non-NULL pointer. 166 */ 167 void * 168 rpc_nullproc(clnt) 169 CLIENT *clnt; 170 { 171 struct timeval TIMEOUT = {25, 0}; 172 173 if (clnt_call(clnt, NULLPROC, (xdrproc_t) xdr_void, NULL, 174 (xdrproc_t) xdr_void, NULL, TIMEOUT) != RPC_SUCCESS) { 175 return (NULL); 176 } 177 return ((void *) clnt); 178 } 179 180 #endif 181 182 int 183 __rpc_socket2sockinfo(struct socket *so, struct __rpc_sockinfo *sip) 184 { 185 int type, proto; 186 struct sockaddr *sa; 187 sa_family_t family; 188 struct sockopt opt; 189 int error; 190 191 CURVNET_SET(so->so_vnet); 192 error = so->so_proto->pr_usrreqs->pru_sockaddr(so, &sa); 193 CURVNET_RESTORE(); 194 if (error) 195 return 0; 196 197 sip->si_alen = sa->sa_len; 198 family = sa->sa_family; 199 free(sa, M_SONAME); 200 201 opt.sopt_dir = SOPT_GET; 202 opt.sopt_level = SOL_SOCKET; 203 opt.sopt_name = SO_TYPE; 204 opt.sopt_val = &type; 205 opt.sopt_valsize = sizeof type; 206 opt.sopt_td = NULL; 207 error = sogetopt(so, &opt); 208 if (error) 209 return 0; 210 211 /* XXX */ 212 if (family != AF_LOCAL) { 213 if (type == SOCK_STREAM) 214 proto = IPPROTO_TCP; 215 else if (type == SOCK_DGRAM) 216 proto = IPPROTO_UDP; 217 else 218 return 0; 219 } else 220 proto = 0; 221 222 sip->si_af = family; 223 sip->si_proto = proto; 224 sip->si_socktype = type; 225 226 return 1; 227 } 228 229 /* 230 * Linear search, but the number of entries is small. 231 */ 232 int 233 __rpc_nconf2sockinfo(const struct netconfig *nconf, struct __rpc_sockinfo *sip) 234 { 235 int i; 236 237 for (i = 0; i < (sizeof na_cvt) / (sizeof (struct netid_af)); i++) 238 if (strcmp(na_cvt[i].netid, nconf->nc_netid) == 0 || ( 239 strcmp(nconf->nc_netid, "unix") == 0 && 240 strcmp(na_cvt[i].netid, "local") == 0)) { 241 sip->si_af = na_cvt[i].af; 242 sip->si_proto = na_cvt[i].protocol; 243 sip->si_socktype = 244 __rpc_seman2socktype((int)nconf->nc_semantics); 245 if (sip->si_socktype == -1) 246 return 0; 247 sip->si_alen = __rpc_get_a_size(sip->si_af); 248 return 1; 249 } 250 251 return 0; 252 } 253 254 struct socket * 255 __rpc_nconf2socket(const struct netconfig *nconf) 256 { 257 struct __rpc_sockinfo si; 258 struct socket *so; 259 int error; 260 261 if (!__rpc_nconf2sockinfo(nconf, &si)) 262 return 0; 263 264 so = NULL; 265 error = socreate(si.si_af, &so, si.si_socktype, si.si_proto, 266 curthread->td_ucred, curthread); 267 268 if (error) 269 return NULL; 270 else 271 return so; 272 } 273 274 char * 275 taddr2uaddr(const struct netconfig *nconf, const struct netbuf *nbuf) 276 { 277 struct __rpc_sockinfo si; 278 279 if (!__rpc_nconf2sockinfo(nconf, &si)) 280 return NULL; 281 return __rpc_taddr2uaddr_af(si.si_af, nbuf); 282 } 283 284 struct netbuf * 285 uaddr2taddr(const struct netconfig *nconf, const char *uaddr) 286 { 287 struct __rpc_sockinfo si; 288 289 if (!__rpc_nconf2sockinfo(nconf, &si)) 290 return NULL; 291 return __rpc_uaddr2taddr_af(si.si_af, uaddr); 292 } 293 294 char * 295 __rpc_taddr2uaddr_af(int af, const struct netbuf *nbuf) 296 { 297 char *ret; 298 struct sbuf sb; 299 struct sockaddr_in *sin; 300 struct sockaddr_un *sun; 301 char namebuf[INET_ADDRSTRLEN]; 302 #ifdef INET6 303 struct sockaddr_in6 *sin6; 304 char namebuf6[INET6_ADDRSTRLEN]; 305 #endif 306 u_int16_t port; 307 308 sbuf_new(&sb, NULL, 0, SBUF_AUTOEXTEND); 309 310 switch (af) { 311 case AF_INET: 312 if (nbuf->len < sizeof(*sin)) 313 return NULL; 314 sin = nbuf->buf; 315 if (inet_ntop(af, &sin->sin_addr, namebuf, sizeof namebuf) 316 == NULL) 317 return NULL; 318 port = ntohs(sin->sin_port); 319 if (sbuf_printf(&sb, "%s.%u.%u", namebuf, 320 ((uint32_t)port) >> 8, 321 port & 0xff) < 0) 322 return NULL; 323 break; 324 #ifdef INET6 325 case AF_INET6: 326 if (nbuf->len < sizeof(*sin6)) 327 return NULL; 328 sin6 = nbuf->buf; 329 if (inet_ntop(af, &sin6->sin6_addr, namebuf6, sizeof namebuf6) 330 == NULL) 331 return NULL; 332 port = ntohs(sin6->sin6_port); 333 if (sbuf_printf(&sb, "%s.%u.%u", namebuf6, 334 ((uint32_t)port) >> 8, 335 port & 0xff) < 0) 336 return NULL; 337 break; 338 #endif 339 case AF_LOCAL: 340 sun = nbuf->buf; 341 if (sbuf_printf(&sb, "%.*s", (int)(sun->sun_len - 342 offsetof(struct sockaddr_un, sun_path)), 343 sun->sun_path) < 0) 344 return (NULL); 345 break; 346 default: 347 return NULL; 348 } 349 350 sbuf_finish(&sb); 351 ret = strdup(sbuf_data(&sb), M_RPC); 352 sbuf_delete(&sb); 353 354 return ret; 355 } 356 357 struct netbuf * 358 __rpc_uaddr2taddr_af(int af, const char *uaddr) 359 { 360 struct netbuf *ret = NULL; 361 char *addrstr, *p; 362 unsigned port, portlo, porthi; 363 struct sockaddr_in *sin; 364 #ifdef INET6 365 struct sockaddr_in6 *sin6; 366 #endif 367 struct sockaddr_un *sun; 368 369 port = 0; 370 sin = NULL; 371 372 if (uaddr == NULL) 373 return NULL; 374 375 addrstr = strdup(uaddr, M_RPC); 376 if (addrstr == NULL) 377 return NULL; 378 379 /* 380 * AF_LOCAL addresses are expected to be absolute 381 * pathnames, anything else will be AF_INET or AF_INET6. 382 */ 383 if (*addrstr != '/') { 384 p = strrchr(addrstr, '.'); 385 if (p == NULL) 386 goto out; 387 portlo = (unsigned)strtol(p + 1, NULL, 10); 388 *p = '\0'; 389 390 p = strrchr(addrstr, '.'); 391 if (p == NULL) 392 goto out; 393 porthi = (unsigned)strtol(p + 1, NULL, 10); 394 *p = '\0'; 395 port = (porthi << 8) | portlo; 396 } 397 398 ret = (struct netbuf *)malloc(sizeof *ret, M_RPC, M_WAITOK); 399 400 switch (af) { 401 case AF_INET: 402 sin = (struct sockaddr_in *)malloc(sizeof *sin, M_RPC, 403 M_WAITOK); 404 memset(sin, 0, sizeof *sin); 405 sin->sin_family = AF_INET; 406 sin->sin_port = htons(port); 407 if (inet_pton(AF_INET, addrstr, &sin->sin_addr) <= 0) { 408 free(sin, M_RPC); 409 free(ret, M_RPC); 410 ret = NULL; 411 goto out; 412 } 413 sin->sin_len = ret->maxlen = ret->len = sizeof *sin; 414 ret->buf = sin; 415 break; 416 #ifdef INET6 417 case AF_INET6: 418 sin6 = (struct sockaddr_in6 *)malloc(sizeof *sin6, M_RPC, 419 M_WAITOK); 420 memset(sin6, 0, sizeof *sin6); 421 sin6->sin6_family = AF_INET6; 422 sin6->sin6_port = htons(port); 423 if (inet_pton(AF_INET6, addrstr, &sin6->sin6_addr) <= 0) { 424 free(sin6, M_RPC); 425 free(ret, M_RPC); 426 ret = NULL; 427 goto out; 428 } 429 sin6->sin6_len = ret->maxlen = ret->len = sizeof *sin6; 430 ret->buf = sin6; 431 break; 432 #endif 433 case AF_LOCAL: 434 sun = (struct sockaddr_un *)malloc(sizeof *sun, M_RPC, 435 M_WAITOK); 436 memset(sun, 0, sizeof *sun); 437 sun->sun_family = AF_LOCAL; 438 strncpy(sun->sun_path, addrstr, sizeof(sun->sun_path) - 1); 439 ret->len = ret->maxlen = sun->sun_len = SUN_LEN(sun); 440 ret->buf = sun; 441 break; 442 default: 443 break; 444 } 445 out: 446 free(addrstr, M_RPC); 447 return ret; 448 } 449 450 int 451 __rpc_seman2socktype(int semantics) 452 { 453 switch (semantics) { 454 case NC_TPI_CLTS: 455 return SOCK_DGRAM; 456 case NC_TPI_COTS_ORD: 457 return SOCK_STREAM; 458 case NC_TPI_RAW: 459 return SOCK_RAW; 460 default: 461 break; 462 } 463 464 return -1; 465 } 466 467 int 468 __rpc_socktype2seman(int socktype) 469 { 470 switch (socktype) { 471 case SOCK_DGRAM: 472 return NC_TPI_CLTS; 473 case SOCK_STREAM: 474 return NC_TPI_COTS_ORD; 475 case SOCK_RAW: 476 return NC_TPI_RAW; 477 default: 478 break; 479 } 480 481 return -1; 482 } 483 484 /* 485 * Returns the type of the network as defined in <rpc/nettype.h> 486 * If nettype is NULL, it defaults to NETPATH. 487 */ 488 static int 489 getnettype(const char *nettype) 490 { 491 int i; 492 493 if ((nettype == NULL) || (nettype[0] == 0)) { 494 return (_RPC_NETPATH); /* Default */ 495 } 496 497 #if 0 498 nettype = strlocase(nettype); 499 #endif 500 for (i = 0; _rpctypelist[i].name; i++) 501 if (strcasecmp(nettype, _rpctypelist[i].name) == 0) { 502 return (_rpctypelist[i].type); 503 } 504 return (_rpctypelist[i].type); 505 } 506 507 /* 508 * For the given nettype (tcp or udp only), return the first structure found. 509 * This should be freed by calling freenetconfigent() 510 */ 511 struct netconfig * 512 __rpc_getconfip(const char *nettype) 513 { 514 char *netid; 515 static char *netid_tcp = (char *) NULL; 516 static char *netid_udp = (char *) NULL; 517 struct netconfig *dummy; 518 519 if (!netid_udp && !netid_tcp) { 520 struct netconfig *nconf; 521 void *confighandle; 522 523 if (!(confighandle = setnetconfig())) { 524 log(LOG_ERR, "rpc: failed to open " NETCONFIG); 525 return (NULL); 526 } 527 while ((nconf = getnetconfig(confighandle)) != NULL) { 528 if (strcmp(nconf->nc_protofmly, NC_INET) == 0) { 529 if (strcmp(nconf->nc_proto, NC_TCP) == 0) { 530 netid_tcp = strdup(nconf->nc_netid, 531 M_RPC); 532 } else 533 if (strcmp(nconf->nc_proto, NC_UDP) == 0) { 534 netid_udp = strdup(nconf->nc_netid, 535 M_RPC); 536 } 537 } 538 } 539 endnetconfig(confighandle); 540 } 541 if (strcmp(nettype, "udp") == 0) 542 netid = netid_udp; 543 else if (strcmp(nettype, "tcp") == 0) 544 netid = netid_tcp; 545 else { 546 return (NULL); 547 } 548 if ((netid == NULL) || (netid[0] == 0)) { 549 return (NULL); 550 } 551 dummy = getnetconfigent(netid); 552 return (dummy); 553 } 554 555 /* 556 * Returns the type of the nettype, which should then be used with 557 * __rpc_getconf(). 558 * 559 * For simplicity in the kernel, we don't support the NETPATH 560 * environment variable. We behave as userland would then NETPATH is 561 * unset, i.e. iterate over all visible entries in netconfig. 562 */ 563 void * 564 __rpc_setconf(nettype) 565 const char *nettype; 566 { 567 struct handle *handle; 568 569 handle = (struct handle *) malloc(sizeof (struct handle), 570 M_RPC, M_WAITOK); 571 switch (handle->nettype = getnettype(nettype)) { 572 case _RPC_NETPATH: 573 case _RPC_CIRCUIT_N: 574 case _RPC_DATAGRAM_N: 575 if (!(handle->nhandle = setnetconfig())) 576 goto failed; 577 handle->nflag = TRUE; 578 break; 579 case _RPC_VISIBLE: 580 case _RPC_CIRCUIT_V: 581 case _RPC_DATAGRAM_V: 582 case _RPC_TCP: 583 case _RPC_UDP: 584 if (!(handle->nhandle = setnetconfig())) { 585 log(LOG_ERR, "rpc: failed to open " NETCONFIG); 586 goto failed; 587 } 588 handle->nflag = FALSE; 589 break; 590 default: 591 goto failed; 592 } 593 594 return (handle); 595 596 failed: 597 free(handle, M_RPC); 598 return (NULL); 599 } 600 601 /* 602 * Returns the next netconfig struct for the given "net" type. 603 * __rpc_setconf() should have been called previously. 604 */ 605 struct netconfig * 606 __rpc_getconf(void *vhandle) 607 { 608 struct handle *handle; 609 struct netconfig *nconf; 610 611 handle = (struct handle *)vhandle; 612 if (handle == NULL) { 613 return (NULL); 614 } 615 for (;;) { 616 if (handle->nflag) { 617 nconf = getnetconfig(handle->nhandle); 618 if (nconf && !(nconf->nc_flag & NC_VISIBLE)) 619 continue; 620 } else { 621 nconf = getnetconfig(handle->nhandle); 622 } 623 if (nconf == NULL) 624 break; 625 if ((nconf->nc_semantics != NC_TPI_CLTS) && 626 (nconf->nc_semantics != NC_TPI_COTS) && 627 (nconf->nc_semantics != NC_TPI_COTS_ORD)) 628 continue; 629 switch (handle->nettype) { 630 case _RPC_VISIBLE: 631 if (!(nconf->nc_flag & NC_VISIBLE)) 632 continue; 633 /* FALLTHROUGH */ 634 case _RPC_NETPATH: /* Be happy */ 635 break; 636 case _RPC_CIRCUIT_V: 637 if (!(nconf->nc_flag & NC_VISIBLE)) 638 continue; 639 /* FALLTHROUGH */ 640 case _RPC_CIRCUIT_N: 641 if ((nconf->nc_semantics != NC_TPI_COTS) && 642 (nconf->nc_semantics != NC_TPI_COTS_ORD)) 643 continue; 644 break; 645 case _RPC_DATAGRAM_V: 646 if (!(nconf->nc_flag & NC_VISIBLE)) 647 continue; 648 /* FALLTHROUGH */ 649 case _RPC_DATAGRAM_N: 650 if (nconf->nc_semantics != NC_TPI_CLTS) 651 continue; 652 break; 653 case _RPC_TCP: 654 if (((nconf->nc_semantics != NC_TPI_COTS) && 655 (nconf->nc_semantics != NC_TPI_COTS_ORD)) || 656 (strcmp(nconf->nc_protofmly, NC_INET) 657 #ifdef INET6 658 && strcmp(nconf->nc_protofmly, NC_INET6)) 659 #else 660 ) 661 #endif 662 || 663 strcmp(nconf->nc_proto, NC_TCP)) 664 continue; 665 break; 666 case _RPC_UDP: 667 if ((nconf->nc_semantics != NC_TPI_CLTS) || 668 (strcmp(nconf->nc_protofmly, NC_INET) 669 #ifdef INET6 670 && strcmp(nconf->nc_protofmly, NC_INET6)) 671 #else 672 ) 673 #endif 674 || 675 strcmp(nconf->nc_proto, NC_UDP)) 676 continue; 677 break; 678 } 679 break; 680 } 681 return (nconf); 682 } 683 684 void 685 __rpc_endconf(vhandle) 686 void * vhandle; 687 { 688 struct handle *handle; 689 690 handle = (struct handle *) vhandle; 691 if (handle == NULL) { 692 return; 693 } 694 endnetconfig(handle->nhandle); 695 free(handle, M_RPC); 696 } 697 698 int 699 __rpc_sockisbound(struct socket *so) 700 { 701 struct sockaddr *sa; 702 int error, bound; 703 704 CURVNET_SET(so->so_vnet); 705 error = so->so_proto->pr_usrreqs->pru_sockaddr(so, &sa); 706 CURVNET_RESTORE(); 707 if (error) 708 return (0); 709 710 switch (sa->sa_family) { 711 case AF_INET: 712 bound = (((struct sockaddr_in *) sa)->sin_port != 0); 713 break; 714 #ifdef INET6 715 case AF_INET6: 716 bound = (((struct sockaddr_in6 *) sa)->sin6_port != 0); 717 break; 718 #endif 719 case AF_LOCAL: 720 /* XXX check this */ 721 bound = (((struct sockaddr_un *) sa)->sun_path[0] != '\0'); 722 break; 723 default: 724 bound = FALSE; 725 break; 726 } 727 728 free(sa, M_SONAME); 729 730 return bound; 731 } 732 733 /* 734 * Implement XDR-style API for RPC call. 735 */ 736 enum clnt_stat 737 clnt_call_private( 738 CLIENT *cl, /* client handle */ 739 struct rpc_callextra *ext, /* call metadata */ 740 rpcproc_t proc, /* procedure number */ 741 xdrproc_t xargs, /* xdr routine for args */ 742 void *argsp, /* pointer to args */ 743 xdrproc_t xresults, /* xdr routine for results */ 744 void *resultsp, /* pointer to results */ 745 struct timeval utimeout) /* seconds to wait before giving up */ 746 { 747 XDR xdrs; 748 struct mbuf *mreq; 749 struct mbuf *mrep; 750 enum clnt_stat stat; 751 752 mreq = m_getcl(M_WAITOK, MT_DATA, 0); 753 754 xdrmbuf_create(&xdrs, mreq, XDR_ENCODE); 755 if (!xargs(&xdrs, argsp)) { 756 m_freem(mreq); 757 return (RPC_CANTENCODEARGS); 758 } 759 XDR_DESTROY(&xdrs); 760 761 stat = CLNT_CALL_MBUF(cl, ext, proc, mreq, &mrep, utimeout); 762 m_freem(mreq); 763 764 if (stat == RPC_SUCCESS) { 765 xdrmbuf_create(&xdrs, mrep, XDR_DECODE); 766 if (!xresults(&xdrs, resultsp)) { 767 XDR_DESTROY(&xdrs); 768 return (RPC_CANTDECODERES); 769 } 770 XDR_DESTROY(&xdrs); 771 } 772 773 return (stat); 774 } 775 776 /* 777 * Bind a socket to a privileged IP port 778 */ 779 int 780 bindresvport(struct socket *so, struct sockaddr *sa) 781 { 782 int old, error, af; 783 bool_t freesa = FALSE; 784 struct sockaddr_in *sin; 785 #ifdef INET6 786 struct sockaddr_in6 *sin6; 787 #endif 788 struct sockopt opt; 789 int proto, portrange, portlow; 790 u_int16_t *portp; 791 socklen_t salen; 792 793 if (sa == NULL) { 794 CURVNET_SET(so->so_vnet); 795 error = so->so_proto->pr_usrreqs->pru_sockaddr(so, &sa); 796 CURVNET_RESTORE(); 797 if (error) 798 return (error); 799 freesa = TRUE; 800 af = sa->sa_family; 801 salen = sa->sa_len; 802 memset(sa, 0, sa->sa_len); 803 } else { 804 af = sa->sa_family; 805 salen = sa->sa_len; 806 } 807 808 switch (af) { 809 case AF_INET: 810 proto = IPPROTO_IP; 811 portrange = IP_PORTRANGE; 812 portlow = IP_PORTRANGE_LOW; 813 sin = (struct sockaddr_in *)sa; 814 portp = &sin->sin_port; 815 break; 816 #ifdef INET6 817 case AF_INET6: 818 proto = IPPROTO_IPV6; 819 portrange = IPV6_PORTRANGE; 820 portlow = IPV6_PORTRANGE_LOW; 821 sin6 = (struct sockaddr_in6 *)sa; 822 portp = &sin6->sin6_port; 823 break; 824 #endif 825 default: 826 return (EPFNOSUPPORT); 827 } 828 829 sa->sa_family = af; 830 sa->sa_len = salen; 831 832 if (*portp == 0) { 833 bzero(&opt, sizeof(opt)); 834 opt.sopt_dir = SOPT_GET; 835 opt.sopt_level = proto; 836 opt.sopt_name = portrange; 837 opt.sopt_val = &old; 838 opt.sopt_valsize = sizeof(old); 839 error = sogetopt(so, &opt); 840 if (error) { 841 goto out; 842 } 843 844 opt.sopt_dir = SOPT_SET; 845 opt.sopt_val = &portlow; 846 error = sosetopt(so, &opt); 847 if (error) 848 goto out; 849 } 850 851 error = sobind(so, sa, curthread); 852 853 if (*portp == 0) { 854 if (error) { 855 opt.sopt_dir = SOPT_SET; 856 opt.sopt_val = &old; 857 sosetopt(so, &opt); 858 } 859 } 860 out: 861 if (freesa) 862 free(sa, M_SONAME); 863 864 return (error); 865 } 866 867 /* 868 * Kernel module glue 869 */ 870 static int 871 krpc_modevent(module_t mod, int type, void *data) 872 { 873 874 return (0); 875 } 876 static moduledata_t krpc_mod = { 877 "krpc", 878 krpc_modevent, 879 NULL, 880 }; 881 DECLARE_MODULE(krpc, krpc_mod, SI_SUB_VFS, SI_ORDER_ANY); 882 883 /* So that loader and kldload(2) can find us, wherever we are.. */ 884 MODULE_VERSION(krpc, 1); 885