1 /* $NetBSD: rpc_generic.c,v 1.24 2010/12/08 02:06:38 joerg 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 * Copyright (c) 1986-1991 by Sun Microsystems Inc. 33 */ 34 35 /* #pragma ident "@(#)rpc_generic.c 1.17 94/04/24 SMI" */ 36 37 /* 38 * rpc_generic.c, Miscl routines for RPC. 39 * 40 */ 41 42 #include <sys/cdefs.h> 43 #if defined(LIBC_SCCS) && !defined(lint) 44 __RCSID("$NetBSD: rpc_generic.c,v 1.24 2010/12/08 02:06:38 joerg Exp $"); 45 #endif 46 47 #include "namespace.h" 48 #include "reentrant.h" 49 #include <sys/types.h> 50 #include <sys/param.h> 51 #include <sys/socket.h> 52 #include <sys/un.h> 53 #include <sys/resource.h> 54 #include <netinet/in.h> 55 #include <netinet/tcp.h> 56 #include <arpa/inet.h> 57 #include <rpc/rpc.h> 58 #include <assert.h> 59 #include <ctype.h> 60 #include <stdio.h> 61 #include <netdb.h> 62 #include <netconfig.h> 63 #include <malloc.h> 64 #include <string.h> 65 #include <syslog.h> 66 #include <rpc/nettype.h> 67 #include "rpc_internal.h" 68 69 #ifdef __weak_alias 70 __weak_alias(taddr2uaddr,_taddr2uaddr) 71 __weak_alias(uaddr2taddr,_uaddr2taddr) 72 #endif 73 74 struct handle { 75 NCONF_HANDLE *nhandle; 76 int nflag; /* Whether NETPATH or NETCONFIG */ 77 int nettype; 78 }; 79 80 static const struct _rpcnettype { 81 const char *name; 82 const int type; 83 } _rpctypelist[] = { 84 { "netpath", _RPC_NETPATH }, 85 { "visible", _RPC_VISIBLE }, 86 { "circuit_v", _RPC_CIRCUIT_V }, 87 { "datagram_v", _RPC_DATAGRAM_V }, 88 { "circuit_n", _RPC_CIRCUIT_N }, 89 { "datagram_n", _RPC_DATAGRAM_N }, 90 { "tcp", _RPC_TCP }, 91 { "udp", _RPC_UDP }, 92 { 0, _RPC_NONE } 93 }; 94 95 struct netid_af { 96 const char *netid; 97 int af; 98 int protocol; 99 }; 100 101 static const struct netid_af na_cvt[] = { 102 { "udp", AF_INET, IPPROTO_UDP }, 103 { "tcp", AF_INET, IPPROTO_TCP }, 104 #ifdef INET6 105 { "udp6", AF_INET6, IPPROTO_UDP }, 106 { "tcp6", AF_INET6, IPPROTO_TCP }, 107 #endif 108 { "local", AF_LOCAL, 0 } 109 }; 110 111 #if 0 112 static char *strlocase __P((char *)); 113 #endif 114 static int getnettype __P((const char *)); 115 116 /* 117 * Cache the result of getrlimit(), so we don't have to do an 118 * expensive call every time. 119 */ 120 int 121 __rpc_dtbsize() 122 { 123 static int tbsize; 124 struct rlimit rl; 125 126 if (tbsize) { 127 return (tbsize); 128 } 129 if (getrlimit(RLIMIT_NOFILE, &rl) == 0) { 130 return (tbsize = (int)rl.rlim_max); 131 } 132 /* 133 * Something wrong. I'll try to save face by returning a 134 * pessimistic number. 135 */ 136 return (32); 137 } 138 139 140 /* 141 * Find the appropriate buffer size 142 */ 143 u_int 144 /*ARGSUSED*/ 145 __rpc_get_t_size(af, proto, size) 146 int af, proto; 147 int size; /* Size requested */ 148 { 149 int maxsize, defsize; 150 151 maxsize = 256 * 1024; /* XXX */ 152 switch (proto) { 153 case IPPROTO_TCP: 154 defsize = 64 * 1024; /* XXX */ 155 break; 156 case IPPROTO_UDP: 157 defsize = UDPMSGSIZE; 158 break; 159 default: 160 defsize = RPC_MAXDATASIZE; 161 break; 162 } 163 if (size == 0) 164 return defsize; 165 166 /* Check whether the value is within the upper max limit */ 167 return (size > maxsize ? (u_int)maxsize : (u_int)size); 168 } 169 170 /* 171 * Find the appropriate address buffer size 172 */ 173 u_int 174 __rpc_get_a_size(af) 175 int af; 176 { 177 switch (af) { 178 case AF_INET: 179 return sizeof (struct sockaddr_in); 180 #ifdef INET6 181 case AF_INET6: 182 return sizeof (struct sockaddr_in6); 183 #endif 184 case AF_LOCAL: 185 return sizeof (struct sockaddr_un); 186 default: 187 break; 188 } 189 return ((u_int)RPC_MAXADDRSIZE); 190 } 191 192 #if 0 193 static char * 194 strlocase(p) 195 char *p; 196 { 197 char *t = p; 198 199 _DIAGASSERT(p != NULL); 200 201 for (; *p; p++) 202 if (isupper(*p)) 203 *p = tolower(*p); 204 return (t); 205 } 206 #endif 207 208 /* 209 * Returns the type of the network as defined in <rpc/nettype.h> 210 * If nettype is NULL, it defaults to NETPATH. 211 */ 212 static int 213 getnettype(nettype) 214 const char *nettype; 215 { 216 int i; 217 218 if ((nettype == NULL) || (nettype[0] == 0)) { 219 return (_RPC_NETPATH); /* Default */ 220 } 221 222 #if 0 223 nettype = strlocase(nettype); 224 #endif 225 for (i = 0; _rpctypelist[i].name; i++) 226 if (strcasecmp(nettype, _rpctypelist[i].name) == 0) { 227 return (_rpctypelist[i].type); 228 } 229 return (_rpctypelist[i].type); 230 } 231 232 /* 233 * For the given nettype (tcp or udp only), return the first structure found. 234 * This should be freed by calling freenetconfigent() 235 */ 236 237 #ifdef _REENTRANT 238 static thread_key_t tcp_key, udp_key; 239 static once_t __rpc_getconfigp_once = ONCE_INITIALIZER; 240 241 static void 242 __rpc_getconfigp_setup(void) 243 { 244 245 thr_keycreate(&tcp_key, free); 246 thr_keycreate(&udp_key, free); 247 } 248 #endif 249 250 struct netconfig * 251 __rpc_getconfip(nettype) 252 const char *nettype; 253 { 254 char *netid; 255 char *netid_tcp = NULL; 256 char *netid_udp = NULL; 257 static char *netid_tcp_main; 258 static char *netid_udp_main; 259 struct netconfig *dummy; 260 #ifdef _REENTRANT 261 if (__isthreaded == 0) { 262 netid_udp = netid_udp_main; 263 netid_tcp = netid_tcp_main; 264 } else { 265 thr_once(&__rpc_getconfigp_once, __rpc_getconfigp_setup); 266 netid_tcp = thr_getspecific(tcp_key); 267 netid_udp = thr_getspecific(udp_key); 268 } 269 #else 270 netid_udp = netid_udp_main; 271 netid_tcp = netid_tcp_main; 272 #endif 273 274 _DIAGASSERT(nettype != NULL); 275 276 if (!netid_udp && !netid_tcp) { 277 struct netconfig *nconf; 278 void *confighandle; 279 280 if (!(confighandle = setnetconfig())) { 281 syslog (LOG_ERR, "rpc: failed to open " NETCONFIG); 282 return (NULL); 283 } 284 while ((nconf = getnetconfig(confighandle)) != NULL) { 285 if (strcmp(nconf->nc_protofmly, NC_INET) == 0) { 286 if (strcmp(nconf->nc_proto, NC_TCP) == 0) { 287 netid_tcp = strdup(nconf->nc_netid); 288 if (netid_tcp == NULL) 289 return NULL; 290 #ifdef _REENTRANT 291 if (__isthreaded == 0) 292 netid_tcp_main = netid_tcp; 293 else 294 thr_setspecific(tcp_key, 295 (void *) netid_tcp); 296 #else 297 netid_tcp_main = netid_tcp; 298 #endif 299 } else 300 if (strcmp(nconf->nc_proto, NC_UDP) == 0) { 301 netid_udp = strdup(nconf->nc_netid); 302 if (netid_udp == NULL) 303 return NULL; 304 #ifdef _REENTRANT 305 if (__isthreaded == 0) 306 netid_udp_main = netid_udp; 307 else 308 thr_setspecific(udp_key, 309 (void *) netid_udp); 310 #else 311 netid_udp_main = netid_udp; 312 #endif 313 } 314 } 315 } 316 endnetconfig(confighandle); 317 } 318 if (strcmp(nettype, "udp") == 0) 319 netid = netid_udp; 320 else if (strcmp(nettype, "tcp") == 0) 321 netid = netid_tcp; 322 else { 323 return (NULL); 324 } 325 if ((netid == NULL) || (netid[0] == 0)) { 326 return (NULL); 327 } 328 dummy = getnetconfigent(netid); 329 return (dummy); 330 } 331 332 /* 333 * Returns the type of the nettype, which should then be used with 334 * __rpc_getconf(). 335 */ 336 void * 337 __rpc_setconf(nettype) 338 const char *nettype; 339 { 340 struct handle *handle; 341 342 /* nettype may be NULL; getnettype() supports that */ 343 344 handle = malloc(sizeof(*handle)); 345 if (handle == NULL) { 346 return (NULL); 347 } 348 switch (handle->nettype = getnettype(nettype)) { 349 case _RPC_NETPATH: 350 case _RPC_CIRCUIT_N: 351 case _RPC_DATAGRAM_N: 352 if (!(handle->nhandle = setnetpath())) { 353 free(handle); 354 return (NULL); 355 } 356 handle->nflag = TRUE; 357 break; 358 case _RPC_VISIBLE: 359 case _RPC_CIRCUIT_V: 360 case _RPC_DATAGRAM_V: 361 case _RPC_TCP: 362 case _RPC_UDP: 363 if (!(handle->nhandle = setnetconfig())) { 364 syslog (LOG_ERR, "rpc: failed to open " NETCONFIG); 365 free(handle); 366 return (NULL); 367 } 368 handle->nflag = FALSE; 369 break; 370 default: 371 free(handle); 372 return (NULL); 373 } 374 375 return (handle); 376 } 377 378 /* 379 * Returns the next netconfig struct for the given "net" type. 380 * __rpc_setconf() should have been called previously. 381 */ 382 struct netconfig * 383 __rpc_getconf(vhandle) 384 void *vhandle; 385 { 386 struct handle *handle; 387 struct netconfig *nconf; 388 389 handle = (struct handle *)vhandle; 390 if (handle == NULL) { 391 return (NULL); 392 } 393 for (;;) { 394 if (handle->nflag) 395 nconf = getnetpath(handle->nhandle); 396 else 397 nconf = getnetconfig(handle->nhandle); 398 if (nconf == NULL) 399 break; 400 if ((nconf->nc_semantics != NC_TPI_CLTS) && 401 (nconf->nc_semantics != NC_TPI_COTS) && 402 (nconf->nc_semantics != NC_TPI_COTS_ORD)) 403 continue; 404 switch (handle->nettype) { 405 case _RPC_VISIBLE: 406 if (!(nconf->nc_flag & NC_VISIBLE)) 407 continue; 408 /* FALLTHROUGH */ 409 case _RPC_NETPATH: /* Be happy */ 410 break; 411 case _RPC_CIRCUIT_V: 412 if (!(nconf->nc_flag & NC_VISIBLE)) 413 continue; 414 /* FALLTHROUGH */ 415 case _RPC_CIRCUIT_N: 416 if ((nconf->nc_semantics != NC_TPI_COTS) && 417 (nconf->nc_semantics != NC_TPI_COTS_ORD)) 418 continue; 419 break; 420 case _RPC_DATAGRAM_V: 421 if (!(nconf->nc_flag & NC_VISIBLE)) 422 continue; 423 /* FALLTHROUGH */ 424 case _RPC_DATAGRAM_N: 425 if (nconf->nc_semantics != NC_TPI_CLTS) 426 continue; 427 break; 428 case _RPC_TCP: 429 if (((nconf->nc_semantics != NC_TPI_COTS) && 430 (nconf->nc_semantics != NC_TPI_COTS_ORD)) || 431 (strcmp(nconf->nc_protofmly, NC_INET) 432 #ifdef INET6 433 && strcmp(nconf->nc_protofmly, NC_INET6)) 434 #else 435 ) 436 #endif 437 || 438 strcmp(nconf->nc_proto, NC_TCP)) 439 continue; 440 break; 441 case _RPC_UDP: 442 if ((nconf->nc_semantics != NC_TPI_CLTS) || 443 (strcmp(nconf->nc_protofmly, NC_INET) 444 #ifdef INET6 445 && strcmp(nconf->nc_protofmly, NC_INET6)) 446 #else 447 ) 448 #endif 449 || 450 strcmp(nconf->nc_proto, NC_UDP)) 451 continue; 452 break; 453 } 454 break; 455 } 456 return (nconf); 457 } 458 459 void 460 __rpc_endconf(vhandle) 461 void * vhandle; 462 { 463 struct handle *handle; 464 465 handle = (struct handle *) vhandle; 466 if (handle == NULL) { 467 return; 468 } 469 if (handle->nflag) { 470 endnetpath(handle->nhandle); 471 } else { 472 endnetconfig(handle->nhandle); 473 } 474 free(handle); 475 } 476 477 /* 478 * Used to ping the NULL procedure for clnt handle. 479 * Returns NULL if fails, else a non-NULL pointer. 480 */ 481 void * 482 rpc_nullproc(clnt) 483 CLIENT *clnt; 484 { 485 struct timeval TIMEOUT = {25, 0}; 486 487 if (clnt_call(clnt, NULLPROC, (xdrproc_t) xdr_void, NULL, 488 (xdrproc_t) xdr_void, NULL, TIMEOUT) != RPC_SUCCESS) { 489 return (NULL); 490 } 491 return ((void *) clnt); 492 } 493 494 /* 495 * Try all possible transports until 496 * one succeeds in finding the netconf for the given fd. 497 */ 498 struct netconfig * 499 __rpcgettp(fd) 500 int fd; 501 { 502 const char *netid; 503 struct __rpc_sockinfo si; 504 505 if (!__rpc_fd2sockinfo(fd, &si)) 506 return NULL; 507 508 if (!__rpc_sockinfo2netid(&si, &netid)) 509 return NULL; 510 511 return getnetconfigent(__UNCONST(netid)); 512 } 513 514 int 515 __rpc_fd2sockinfo(int fd, struct __rpc_sockinfo *sip) 516 { 517 socklen_t len; 518 int type, proto; 519 struct sockaddr_storage ss; 520 521 _DIAGASSERT(sip != NULL); 522 523 len = sizeof ss; 524 if (getsockname(fd, (struct sockaddr *)(void *)&ss, &len) < 0) 525 return 0; 526 sip->si_alen = len; 527 528 len = sizeof type; 529 if (getsockopt(fd, SOL_SOCKET, SO_TYPE, &type, &len) < 0) 530 return 0; 531 532 /* XXX */ 533 if (ss.ss_family != AF_LOCAL) { 534 if (type == SOCK_STREAM) 535 proto = IPPROTO_TCP; 536 else if (type == SOCK_DGRAM) 537 proto = IPPROTO_UDP; 538 else 539 return 0; 540 } else 541 proto = 0; 542 543 sip->si_af = ss.ss_family; 544 sip->si_proto = proto; 545 sip->si_socktype = type; 546 547 return 1; 548 } 549 550 /* 551 * Linear search, but the number of entries is small. 552 */ 553 int 554 __rpc_nconf2sockinfo(const struct netconfig *nconf, struct __rpc_sockinfo *sip) 555 { 556 size_t i; 557 558 _DIAGASSERT(nconf != NULL); 559 _DIAGASSERT(sip != NULL); 560 561 for (i = 0; i < (sizeof na_cvt) / (sizeof (struct netid_af)); i++) 562 if (!strcmp(na_cvt[i].netid, nconf->nc_netid)) { 563 sip->si_af = na_cvt[i].af; 564 sip->si_proto = na_cvt[i].protocol; 565 sip->si_socktype = 566 __rpc_seman2socktype((int)nconf->nc_semantics); 567 if (sip->si_socktype == -1) 568 return 0; 569 sip->si_alen = __rpc_get_a_size(sip->si_af); 570 return 1; 571 } 572 573 return 0; 574 } 575 576 int 577 __rpc_nconf2fd(const struct netconfig *nconf) 578 { 579 struct __rpc_sockinfo si; 580 581 _DIAGASSERT(nconf != NULL); 582 583 if (!__rpc_nconf2sockinfo(nconf, &si)) 584 return 0; 585 586 return socket(si.si_af, si.si_socktype, si.si_proto); 587 } 588 589 int 590 __rpc_sockinfo2netid(struct __rpc_sockinfo *sip, const char **netid) 591 { 592 size_t i; 593 594 _DIAGASSERT(sip != NULL); 595 /* netid may be NULL */ 596 597 for (i = 0; i < (sizeof na_cvt) / (sizeof (struct netid_af)); i++) 598 if (na_cvt[i].af == sip->si_af && 599 na_cvt[i].protocol == sip->si_proto) { 600 if (netid) 601 *netid = na_cvt[i].netid; 602 return 1; 603 } 604 605 return 0; 606 } 607 608 char * 609 taddr2uaddr(const struct netconfig *nconf, const struct netbuf *nbuf) 610 { 611 struct __rpc_sockinfo si; 612 613 _DIAGASSERT(nconf != NULL); 614 _DIAGASSERT(nbuf != NULL); 615 616 if (!__rpc_nconf2sockinfo(nconf, &si)) 617 return NULL; 618 return __rpc_taddr2uaddr_af(si.si_af, nbuf); 619 } 620 621 struct netbuf * 622 uaddr2taddr(const struct netconfig *nconf, const char *uaddr) 623 { 624 struct __rpc_sockinfo si; 625 626 _DIAGASSERT(nconf != NULL); 627 _DIAGASSERT(uaddr != NULL); 628 629 if (!__rpc_nconf2sockinfo(nconf, &si)) 630 return NULL; 631 return __rpc_uaddr2taddr_af(si.si_af, uaddr); 632 } 633 634 char * 635 __rpc_taddr2uaddr_af(int af, const struct netbuf *nbuf) 636 { 637 char *ret; 638 struct sockaddr_in *sinp; 639 struct sockaddr_un *sun; 640 char namebuf[INET_ADDRSTRLEN]; 641 #ifdef INET6 642 struct sockaddr_in6 *sin6; 643 char namebuf6[INET6_ADDRSTRLEN]; 644 #endif 645 u_int16_t port; 646 647 _DIAGASSERT(nbuf != NULL); 648 649 switch (af) { 650 case AF_INET: 651 sinp = nbuf->buf; 652 if (inet_ntop(af, &sinp->sin_addr, namebuf, sizeof namebuf) 653 == NULL) 654 return NULL; 655 port = ntohs(sinp->sin_port); 656 if (asprintf(&ret, "%s.%u.%u", namebuf, ((u_int32_t)port) >> 8, 657 port & 0xff) < 0) 658 return NULL; 659 break; 660 #ifdef INET6 661 case AF_INET6: 662 sin6 = nbuf->buf; 663 if (inet_ntop(af, &sin6->sin6_addr, namebuf6, sizeof namebuf6) 664 == NULL) 665 return NULL; 666 port = ntohs(sin6->sin6_port); 667 if (asprintf(&ret, "%s.%u.%u", namebuf6, ((u_int32_t)port) >> 8, 668 port & 0xff) < 0) 669 return NULL; 670 break; 671 #endif 672 case AF_LOCAL: 673 sun = nbuf->buf; 674 sun->sun_path[sizeof(sun->sun_path) - 1] = '\0'; /* safety */ 675 ret = strdup(sun->sun_path); 676 break; 677 default: 678 return NULL; 679 } 680 681 return ret; 682 } 683 684 struct netbuf * 685 __rpc_uaddr2taddr_af(int af, const char *uaddr) 686 { 687 struct netbuf *ret = NULL; 688 char *addrstr, *p; 689 unsigned port, portlo, porthi; 690 struct sockaddr_in *sinp; 691 #ifdef INET6 692 struct sockaddr_in6 *sin6; 693 #endif 694 struct sockaddr_un *sun; 695 696 _DIAGASSERT(uaddr != NULL); 697 698 addrstr = strdup(uaddr); 699 if (addrstr == NULL) 700 return NULL; 701 702 /* 703 * AF_LOCAL addresses are expected to be absolute 704 * pathnames, anything else will be AF_INET or AF_INET6. 705 */ 706 port = 0; 707 if (*addrstr != '/') { 708 p = strrchr(addrstr, '.'); 709 if (p == NULL) 710 goto out; 711 portlo = (unsigned)atoi(p + 1); 712 *p = '\0'; 713 714 p = strrchr(addrstr, '.'); 715 if (p == NULL) 716 goto out; 717 porthi = (unsigned)atoi(p + 1); 718 *p = '\0'; 719 port = (porthi << 8) | portlo; 720 } 721 722 ret = malloc(sizeof(*ret)); 723 if (ret == NULL) 724 goto out; 725 726 switch (af) { 727 case AF_INET: 728 sinp = malloc(sizeof(*sinp)); 729 if (sinp == NULL) 730 goto out; 731 memset(sinp, 0, sizeof *sinp); 732 sinp->sin_family = AF_INET; 733 sinp->sin_port = htons(port); 734 if (inet_pton(AF_INET, addrstr, &sinp->sin_addr) <= 0) { 735 free(sinp); 736 free(ret); 737 ret = NULL; 738 goto out; 739 } 740 sinp->sin_len = ret->maxlen = ret->len = sizeof *sinp; 741 ret->buf = sinp; 742 break; 743 #ifdef INET6 744 case AF_INET6: 745 sin6 = malloc(sizeof(*sin6)); 746 if (sin6 == NULL) 747 goto out; 748 memset(sin6, 0, sizeof *sin6); 749 sin6->sin6_family = AF_INET6; 750 sin6->sin6_port = htons(port); 751 if (inet_pton(AF_INET6, addrstr, &sin6->sin6_addr) <= 0) { 752 free(sin6); 753 free(ret); 754 ret = NULL; 755 goto out; 756 } 757 sin6->sin6_len = ret->maxlen = ret->len = sizeof *sin6; 758 ret->buf = sin6; 759 break; 760 #endif 761 case AF_LOCAL: 762 sun = malloc(sizeof(*sun)); 763 if (sun == NULL) 764 goto out; 765 memset(sun, 0, sizeof *sun); 766 sun->sun_family = AF_LOCAL; 767 strncpy(sun->sun_path, addrstr, sizeof(sun->sun_path) - 1); 768 ret->len = ret->maxlen = sun->sun_len = SUN_LEN(sun); 769 ret->buf = sun; 770 break; 771 default: 772 break; 773 } 774 out: 775 free(addrstr); 776 return ret; 777 } 778 779 int 780 __rpc_seman2socktype(int semantics) 781 { 782 switch (semantics) { 783 case NC_TPI_CLTS: 784 return SOCK_DGRAM; 785 case NC_TPI_COTS_ORD: 786 return SOCK_STREAM; 787 case NC_TPI_RAW: 788 return SOCK_RAW; 789 default: 790 break; 791 } 792 793 return -1; 794 } 795 796 int 797 __rpc_socktype2seman(int socktype) 798 { 799 switch (socktype) { 800 case SOCK_DGRAM: 801 return NC_TPI_CLTS; 802 case SOCK_STREAM: 803 return NC_TPI_COTS_ORD; 804 case SOCK_RAW: 805 return NC_TPI_RAW; 806 default: 807 break; 808 } 809 810 return -1; 811 } 812 813 /* 814 * XXXX - IPv6 scope IDs can't be handled in universal addresses. 815 * Here, we compare the original server address to that of the RPC 816 * service we just received back from a call to rpcbind on the remote 817 * machine. If they are both "link local" or "site local", copy 818 * the scope id of the server address over to the service address. 819 */ 820 /* ARGSUSED */ 821 int 822 __rpc_fixup_addr(struct netbuf *new, const struct netbuf *svc) 823 { 824 #ifdef INET6 825 struct sockaddr *sa_new, *sa_svc; 826 struct sockaddr_in6 *sin6_new, *sin6_svc; 827 828 _DIAGASSERT(new != NULL); 829 _DIAGASSERT(svc != NULL); 830 831 sa_svc = (struct sockaddr *)svc->buf; 832 sa_new = (struct sockaddr *)new->buf; 833 834 if (sa_new->sa_family == sa_svc->sa_family && 835 sa_new->sa_family == AF_INET6) { 836 sin6_new = (struct sockaddr_in6 *)new->buf; 837 sin6_svc = (struct sockaddr_in6 *)svc->buf; 838 839 if ((IN6_IS_ADDR_LINKLOCAL(&sin6_new->sin6_addr) && 840 IN6_IS_ADDR_LINKLOCAL(&sin6_svc->sin6_addr)) || 841 (IN6_IS_ADDR_SITELOCAL(&sin6_new->sin6_addr) && 842 IN6_IS_ADDR_SITELOCAL(&sin6_svc->sin6_addr))) { 843 sin6_new->sin6_scope_id = sin6_svc->sin6_scope_id; 844 } 845 } 846 #endif 847 return 1; 848 } 849 850 int 851 __rpc_sockisbound(int fd) 852 { 853 struct sockaddr_storage ss; 854 socklen_t slen; 855 856 slen = sizeof (struct sockaddr_storage); 857 if (getsockname(fd, (struct sockaddr *)(void *)&ss, &slen) < 0) 858 return 0; 859 860 switch (ss.ss_family) { 861 case AF_INET: 862 return (((struct sockaddr_in *) 863 (void *)&ss)->sin_port != 0); 864 #ifdef INET6 865 case AF_INET6: 866 return (((struct sockaddr_in6 *) 867 (void *)&ss)->sin6_port != 0); 868 #endif 869 case AF_LOCAL: 870 /* XXX check this */ 871 return (((struct sockaddr_un *) 872 (void *)&ss)->sun_path[0] != '\0'); 873 default: 874 break; 875 } 876 877 return 0; 878 } 879 880 /* 881 * For TCP transport, Host Requirements RFCs mandate 882 * Nagle (RFC-896) processing. But for RPC, Nagle 883 * processing adds adds unwanted latency to the last, 884 * partial TCP segment of each RPC message. See: 885 * R. W. Scheifler and J. Gettys, The X Window System, 886 * ACM Transactions on Graphics 16:8 (Aug. 1983), pp. 57-69. 887 * So for TCP transport, disable Nagle via TCP_NODELAY. 888 * XXX: moral equivalent for non-TCP protocols? 889 */ 890 int 891 __rpc_setnodelay(int fd, const struct __rpc_sockinfo *si) 892 { 893 int one = 1; 894 if (si->si_proto != IPPROTO_TCP) 895 return 0; 896 return setsockopt(fd, si->si_proto, TCP_NODELAY, &one, sizeof(one)); 897 } 898