1 /*-
2 * Copyright (c) 2009, Sun Microsystems, Inc.
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 * - Redistributions of source code must retain the above copyright notice,
8 * this list of conditions and the following disclaimer.
9 * - Redistributions in binary form must reproduce the above copyright notice,
10 * this list of conditions and the following disclaimer in the documentation
11 * and/or other materials provided with the distribution.
12 * - Neither the name of Sun Microsystems, Inc. nor the names of its
13 * contributors may be used to endorse or promote products derived
14 * from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
20 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26 * POSSIBILITY OF SUCH DAMAGE.
27 *
28 * @(#)rpc_generic.c 1.17 94/04/24 SMI
29 * $NetBSD: rpc_generic.c,v 1.4 2000/09/28 09:07:04 kleink Exp $
30 * $FreeBSD: src/lib/libc/rpc/rpc_generic.c,v 1.14 2007/09/20 22:35:24 matteo Exp $
31 */
32 /*
33 * Copyright (c) 1986-1991 by Sun Microsystems Inc.
34 */
35
36 /*
37 * rpc_generic.c, Misc routines for RPC.
38 *
39 */
40
41 #include "namespace.h"
42 #include "reentrant.h"
43 #include <sys/types.h>
44 #include <sys/param.h>
45 #include <sys/socket.h>
46 #include <sys/time.h>
47 #include <sys/un.h>
48 #include <sys/resource.h>
49 #include <netinet/in.h>
50 #include <arpa/inet.h>
51 #include <rpc/rpc.h>
52 #include <ctype.h>
53 #include <stddef.h>
54 #include <stdio.h>
55 #include <netdb.h>
56 #include <netconfig.h>
57 #include <stdlib.h>
58 #include <string.h>
59 #include <syslog.h>
60 #include <rpc/nettype.h>
61 #include "un-namespace.h"
62 #include "rpc_com.h"
63 #include "mt_misc.h"
64
65 struct handle {
66 NCONF_HANDLE *nhandle;
67 int nflag; /* Whether NETPATH or NETCONFIG */
68 int nettype;
69 };
70
71 static const struct _rpcnettype {
72 const char *name;
73 const int type;
74 } _rpctypelist[] = {
75 { "netpath", _RPC_NETPATH },
76 { "visible", _RPC_VISIBLE },
77 { "circuit_v", _RPC_CIRCUIT_V },
78 { "datagram_v", _RPC_DATAGRAM_V },
79 { "circuit_n", _RPC_CIRCUIT_N },
80 { "datagram_n", _RPC_DATAGRAM_N },
81 { "tcp", _RPC_TCP },
82 { "udp", _RPC_UDP },
83 { 0, _RPC_NONE }
84 };
85
86 struct netid_af {
87 const char *netid;
88 int af;
89 int protocol;
90 };
91
92 static const struct netid_af na_cvt[] = {
93 { "udp", AF_INET, IPPROTO_UDP },
94 { "tcp", AF_INET, IPPROTO_TCP },
95 #ifdef INET6
96 { "udp6", AF_INET6, IPPROTO_UDP },
97 { "tcp6", AF_INET6, IPPROTO_TCP },
98 #endif
99 { "local", AF_LOCAL, 0 }
100 };
101
102 #if 0
103 static char *strlocase(char *);
104 #endif
105 static int getnettype(const char *);
106
107 /*
108 * Cache the result of getrlimit(), so we don't have to do an
109 * expensive call every time.
110 */
111 int
__rpc_dtbsize(void)112 __rpc_dtbsize(void)
113 {
114 static int tbsize;
115 struct rlimit rl;
116
117 if (tbsize) {
118 return (tbsize);
119 }
120 if (getrlimit(RLIMIT_NOFILE, &rl) == 0) {
121 return (tbsize = (int)rl.rlim_max);
122 }
123 /*
124 * Something wrong. I'll try to save face by returning a
125 * pessimistic number.
126 */
127 return (32);
128 }
129
130
131 /*
132 * Find the appropriate buffer size
133 */
134 u_int
135 /*ARGSUSED*/
__rpc_get_t_size(int af __unused,int proto,int size)136 __rpc_get_t_size(int af __unused, int proto,
137 int size) /* Size requested */
138 {
139 int maxsize, defsize;
140
141 maxsize = 256 * 1024; /* XXX */
142 switch (proto) {
143 case IPPROTO_TCP:
144 defsize = 64 * 1024; /* XXX */
145 break;
146 case IPPROTO_UDP:
147 defsize = UDPMSGSIZE;
148 break;
149 default:
150 defsize = RPC_MAXDATASIZE;
151 break;
152 }
153 if (size == 0)
154 return defsize;
155
156 /* Check whether the value is within the upper max limit */
157 return (size > maxsize ? (u_int)maxsize : (u_int)size);
158 }
159
160 /*
161 * Find the appropriate address buffer size
162 */
163 u_int
__rpc_get_a_size(int af)164 __rpc_get_a_size(int af)
165 {
166 switch (af) {
167 case AF_INET:
168 return sizeof (struct sockaddr_in);
169 #ifdef INET6
170 case AF_INET6:
171 return sizeof (struct sockaddr_in6);
172 #endif
173 case AF_LOCAL:
174 return sizeof (struct sockaddr_un);
175 default:
176 break;
177 }
178 return ((u_int)RPC_MAXADDRSIZE);
179 }
180
181 #if 0
182 static char *
183 strlocase(char *p)
184 {
185 char *t = p;
186
187 for (; *p; p++)
188 if (isupper(*p))
189 *p = tolower(*p);
190 return (t);
191 }
192 #endif
193
194 /*
195 * Returns the type of the network as defined in <rpc/nettype.h>
196 * If nettype is NULL, it defaults to NETPATH.
197 */
198 static int
getnettype(const char * nettype)199 getnettype(const char *nettype)
200 {
201 int i;
202
203 if ((nettype == NULL) || (nettype[0] == 0)) {
204 return (_RPC_NETPATH); /* Default */
205 }
206
207 #if 0
208 nettype = strlocase(nettype);
209 #endif
210 for (i = 0; _rpctypelist[i].name; i++)
211 if (strcasecmp(nettype, _rpctypelist[i].name) == 0) {
212 return (_rpctypelist[i].type);
213 }
214 return (_rpctypelist[i].type);
215 }
216
217 /*
218 * For the given nettype (tcp or udp only), return the first structure found.
219 * This should be freed by calling freenetconfigent()
220 */
221 struct netconfig *
__rpc_getconfip(const char * nettype)222 __rpc_getconfip(const char *nettype)
223 {
224 char *netid;
225 char *netid_tcp = NULL;
226 char *netid_udp = NULL;
227 static char *netid_tcp_main;
228 static char *netid_udp_main;
229 struct netconfig *dummy;
230 int main_thread;
231 static thread_key_t tcp_key, udp_key;
232
233 if ((main_thread = thr_main())) {
234 netid_udp = netid_udp_main;
235 netid_tcp = netid_tcp_main;
236 } else {
237 if (tcp_key == 0) {
238 mutex_lock(&tsd_lock);
239 if (tcp_key == 0)
240 thr_keycreate(&tcp_key, free);
241 mutex_unlock(&tsd_lock);
242 }
243 netid_tcp = (char *)thr_getspecific(tcp_key);
244 if (udp_key == 0) {
245 mutex_lock(&tsd_lock);
246 if (udp_key == 0)
247 thr_keycreate(&udp_key, free);
248 mutex_unlock(&tsd_lock);
249 }
250 netid_udp = (char *)thr_getspecific(udp_key);
251 }
252 if (!netid_udp && !netid_tcp) {
253 struct netconfig *nconf;
254 void *confighandle;
255
256 if (!(confighandle = setnetconfig())) {
257 syslog (LOG_ERR, "rpc: failed to open " NETCONFIG);
258 return (NULL);
259 }
260 while ((nconf = getnetconfig(confighandle)) != NULL) {
261 if (strcmp(nconf->nc_protofmly, NC_INET) == 0) {
262 if (strcmp(nconf->nc_proto, NC_TCP) == 0) {
263 netid_tcp = strdup(nconf->nc_netid);
264 if (main_thread)
265 netid_tcp_main = netid_tcp;
266 else
267 thr_setspecific(tcp_key,
268 (void *) netid_tcp);
269 } else
270 if (strcmp(nconf->nc_proto, NC_UDP) == 0) {
271 netid_udp = strdup(nconf->nc_netid);
272 if (main_thread)
273 netid_udp_main = netid_udp;
274 else
275 thr_setspecific(udp_key,
276 (void *) netid_udp);
277 }
278 }
279 }
280 endnetconfig(confighandle);
281 }
282 if (strcmp(nettype, "udp") == 0)
283 netid = netid_udp;
284 else if (strcmp(nettype, "tcp") == 0)
285 netid = netid_tcp;
286 else {
287 return (NULL);
288 }
289 if ((netid == NULL) || (netid[0] == 0)) {
290 return (NULL);
291 }
292 dummy = getnetconfigent(netid);
293 return (dummy);
294 }
295
296 /*
297 * Returns the type of the nettype, which should then be used with
298 * __rpc_getconf().
299 */
300 void *
__rpc_setconf(const char * nettype)301 __rpc_setconf(const char *nettype)
302 {
303 struct handle *handle;
304
305 handle = (struct handle *) malloc(sizeof (struct handle));
306 if (handle == NULL) {
307 return (NULL);
308 }
309 switch (handle->nettype = getnettype(nettype)) {
310 case _RPC_NETPATH:
311 case _RPC_CIRCUIT_N:
312 case _RPC_DATAGRAM_N:
313 if (!(handle->nhandle = setnetpath()))
314 goto failed;
315 handle->nflag = TRUE;
316 break;
317 case _RPC_VISIBLE:
318 case _RPC_CIRCUIT_V:
319 case _RPC_DATAGRAM_V:
320 case _RPC_TCP:
321 case _RPC_UDP:
322 if (!(handle->nhandle = setnetconfig())) {
323 syslog (LOG_ERR, "rpc: failed to open " NETCONFIG);
324 goto failed;
325 }
326 handle->nflag = FALSE;
327 break;
328 default:
329 goto failed;
330 }
331
332 return (handle);
333
334 failed:
335 free(handle);
336 return (NULL);
337 }
338
339 /*
340 * Returns the next netconfig struct for the given "net" type.
341 * __rpc_setconf() should have been called previously.
342 */
343 struct netconfig *
__rpc_getconf(void * vhandle)344 __rpc_getconf(void *vhandle)
345 {
346 struct handle *handle;
347 struct netconfig *nconf;
348
349 handle = (struct handle *)vhandle;
350 if (handle == NULL) {
351 return (NULL);
352 }
353 for (;;) {
354 if (handle->nflag)
355 nconf = getnetpath(handle->nhandle);
356 else
357 nconf = getnetconfig(handle->nhandle);
358 if (nconf == NULL)
359 break;
360 if ((nconf->nc_semantics != NC_TPI_CLTS) &&
361 (nconf->nc_semantics != NC_TPI_COTS) &&
362 (nconf->nc_semantics != NC_TPI_COTS_ORD))
363 continue;
364 switch (handle->nettype) {
365 case _RPC_VISIBLE:
366 if (!(nconf->nc_flag & NC_VISIBLE))
367 continue;
368 /* FALLTHROUGH */
369 case _RPC_NETPATH: /* Be happy */
370 break;
371 case _RPC_CIRCUIT_V:
372 if (!(nconf->nc_flag & NC_VISIBLE))
373 continue;
374 /* FALLTHROUGH */
375 case _RPC_CIRCUIT_N:
376 if ((nconf->nc_semantics != NC_TPI_COTS) &&
377 (nconf->nc_semantics != NC_TPI_COTS_ORD))
378 continue;
379 break;
380 case _RPC_DATAGRAM_V:
381 if (!(nconf->nc_flag & NC_VISIBLE))
382 continue;
383 /* FALLTHROUGH */
384 case _RPC_DATAGRAM_N:
385 if (nconf->nc_semantics != NC_TPI_CLTS)
386 continue;
387 break;
388 case _RPC_TCP:
389 if (((nconf->nc_semantics != NC_TPI_COTS) &&
390 (nconf->nc_semantics != NC_TPI_COTS_ORD)) ||
391 (strcmp(nconf->nc_protofmly, NC_INET)
392 #ifdef INET6
393 && strcmp(nconf->nc_protofmly, NC_INET6))
394 #else
395 )
396 #endif
397 ||
398 strcmp(nconf->nc_proto, NC_TCP))
399 continue;
400 break;
401 case _RPC_UDP:
402 if ((nconf->nc_semantics != NC_TPI_CLTS) ||
403 (strcmp(nconf->nc_protofmly, NC_INET)
404 #ifdef INET6
405 && strcmp(nconf->nc_protofmly, NC_INET6))
406 #else
407 )
408 #endif
409 ||
410 strcmp(nconf->nc_proto, NC_UDP))
411 continue;
412 break;
413 }
414 break;
415 }
416 return (nconf);
417 }
418
419 void
__rpc_endconf(void * vhandle)420 __rpc_endconf(void *vhandle)
421 {
422 struct handle *handle;
423
424 handle = (struct handle *) vhandle;
425 if (handle == NULL) {
426 return;
427 }
428 if (handle->nflag) {
429 endnetpath(handle->nhandle);
430 } else {
431 endnetconfig(handle->nhandle);
432 }
433 free(handle);
434 }
435
436 /*
437 * Used to ping the NULL procedure for clnt handle.
438 * Returns NULL if fails, else a non-NULL pointer.
439 */
440 void *
rpc_nullproc(CLIENT * clnt)441 rpc_nullproc(CLIENT *clnt)
442 {
443 struct timeval TIMEOUT = {25, 0};
444
445 if (clnt_call(clnt, NULLPROC, (xdrproc_t) xdr_void, NULL,
446 (xdrproc_t) xdr_void, NULL, TIMEOUT) != RPC_SUCCESS) {
447 return (NULL);
448 }
449 return ((void *) clnt);
450 }
451
452 /*
453 * Try all possible transports until
454 * one succeeds in finding the netconf for the given fd.
455 */
456 struct netconfig *
__rpcgettp(int fd)457 __rpcgettp(int fd)
458 {
459 const char *netid;
460 struct __rpc_sockinfo si;
461
462 if (!__rpc_fd2sockinfo(fd, &si))
463 return NULL;
464
465 if (!__rpc_sockinfo2netid(&si, &netid))
466 return NULL;
467
468 /*LINTED const castaway*/
469 return getnetconfigent((char *)netid);
470 }
471
472 int
__rpc_fd2sockinfo(int fd,struct __rpc_sockinfo * sip)473 __rpc_fd2sockinfo(int fd, struct __rpc_sockinfo *sip)
474 {
475 socklen_t len;
476 int type, proto;
477 struct sockaddr_storage ss;
478
479 len = sizeof ss;
480 if (_getsockname(fd, (struct sockaddr *)(void *)&ss, &len) < 0)
481 return 0;
482 sip->si_alen = len;
483
484 len = sizeof type;
485 if (_getsockopt(fd, SOL_SOCKET, SO_TYPE, &type, &len) < 0)
486 return 0;
487
488 /* XXX */
489 if (ss.ss_family != AF_LOCAL) {
490 if (type == SOCK_STREAM)
491 proto = IPPROTO_TCP;
492 else if (type == SOCK_DGRAM)
493 proto = IPPROTO_UDP;
494 else
495 return 0;
496 } else
497 proto = 0;
498
499 sip->si_af = ss.ss_family;
500 sip->si_proto = proto;
501 sip->si_socktype = type;
502
503 return 1;
504 }
505
506 /*
507 * Linear search, but the number of entries is small.
508 */
509 int
__rpc_nconf2sockinfo(const struct netconfig * nconf,struct __rpc_sockinfo * sip)510 __rpc_nconf2sockinfo(const struct netconfig *nconf, struct __rpc_sockinfo *sip)
511 {
512 int i;
513
514 for (i = 0; i < (sizeof na_cvt) / (sizeof (struct netid_af)); i++)
515 if (strcmp(na_cvt[i].netid, nconf->nc_netid) == 0 || (
516 strcmp(nconf->nc_netid, "unix") == 0 &&
517 strcmp(na_cvt[i].netid, "local") == 0)) {
518 sip->si_af = na_cvt[i].af;
519 sip->si_proto = na_cvt[i].protocol;
520 sip->si_socktype =
521 __rpc_seman2socktype((int)nconf->nc_semantics);
522 if (sip->si_socktype == -1)
523 return 0;
524 sip->si_alen = __rpc_get_a_size(sip->si_af);
525 return 1;
526 }
527
528 return 0;
529 }
530
531 int
__rpc_nconf2fd(const struct netconfig * nconf)532 __rpc_nconf2fd(const struct netconfig *nconf)
533 {
534 struct __rpc_sockinfo si;
535
536 if (!__rpc_nconf2sockinfo(nconf, &si))
537 return 0;
538
539 return _socket(si.si_af, si.si_socktype, si.si_proto);
540 }
541
542 int
__rpc_sockinfo2netid(struct __rpc_sockinfo * sip,const char ** netid)543 __rpc_sockinfo2netid(struct __rpc_sockinfo *sip, const char **netid)
544 {
545 int i;
546 struct netconfig *nconf;
547
548 nconf = getnetconfigent("local");
549
550 for (i = 0; i < (sizeof na_cvt) / (sizeof (struct netid_af)); i++) {
551 if (na_cvt[i].af == sip->si_af &&
552 na_cvt[i].protocol == sip->si_proto) {
553 if (strcmp(na_cvt[i].netid, "local") == 0 && nconf == NULL) {
554 if (netid)
555 *netid = "unix";
556 } else {
557 if (netid)
558 *netid = na_cvt[i].netid;
559 }
560 if (nconf != NULL)
561 freenetconfigent(nconf);
562 return 1;
563 }
564 }
565 if (nconf != NULL)
566 freenetconfigent(nconf);
567
568 return 0;
569 }
570
571 char *
taddr2uaddr(const struct netconfig * nconf,const struct netbuf * nbuf)572 taddr2uaddr(const struct netconfig *nconf, const struct netbuf *nbuf)
573 {
574 struct __rpc_sockinfo si;
575
576 if (!__rpc_nconf2sockinfo(nconf, &si))
577 return NULL;
578 return __rpc_taddr2uaddr_af(si.si_af, nbuf);
579 }
580
581 struct netbuf *
uaddr2taddr(const struct netconfig * nconf,const char * uaddr)582 uaddr2taddr(const struct netconfig *nconf, const char *uaddr)
583 {
584 struct __rpc_sockinfo si;
585
586 if (!__rpc_nconf2sockinfo(nconf, &si))
587 return NULL;
588 return __rpc_uaddr2taddr_af(si.si_af, uaddr);
589 }
590
591 char *
__rpc_taddr2uaddr_af(int af,const struct netbuf * nbuf)592 __rpc_taddr2uaddr_af(int af, const struct netbuf *nbuf)
593 {
594 char *ret;
595 struct sockaddr_in *sin;
596 struct sockaddr_un *sun;
597 char namebuf[INET_ADDRSTRLEN];
598 #ifdef INET6
599 struct sockaddr_in6 *sin6;
600 char namebuf6[INET6_ADDRSTRLEN];
601 #endif
602 u_int16_t port;
603
604 switch (af) {
605 case AF_INET:
606 sin = nbuf->buf;
607 if (inet_ntop(af, &sin->sin_addr, namebuf, sizeof namebuf)
608 == NULL)
609 return NULL;
610 port = ntohs(sin->sin_port);
611 if (asprintf(&ret, "%s.%u.%u", namebuf, ((u_int32_t)port) >> 8,
612 port & 0xff) < 0)
613 return NULL;
614 break;
615 #ifdef INET6
616 case AF_INET6:
617 sin6 = nbuf->buf;
618 if (inet_ntop(af, &sin6->sin6_addr, namebuf6, sizeof namebuf6)
619 == NULL)
620 return NULL;
621 port = ntohs(sin6->sin6_port);
622 if (asprintf(&ret, "%s.%u.%u", namebuf6, ((u_int32_t)port) >> 8,
623 port & 0xff) < 0)
624 return NULL;
625 break;
626 #endif
627 case AF_LOCAL:
628 sun = nbuf->buf;
629 if (asprintf(&ret, "%.*s", (int)(sun->sun_len -
630 offsetof(struct sockaddr_un, sun_path)),
631 sun->sun_path) < 0)
632 return (NULL);
633 break;
634 default:
635 return NULL;
636 }
637
638 return ret;
639 }
640
641 struct netbuf *
__rpc_uaddr2taddr_af(int af,const char * uaddr)642 __rpc_uaddr2taddr_af(int af, const char *uaddr)
643 {
644 struct netbuf *ret = NULL;
645 char *addrstr, *p;
646 unsigned port, portlo, porthi;
647 struct sockaddr_in *sin;
648 #ifdef INET6
649 struct sockaddr_in6 *sin6;
650 #endif
651 struct sockaddr_un *sun;
652
653 port = 0;
654 sin = NULL;
655 addrstr = strdup(uaddr);
656 if (addrstr == NULL)
657 return NULL;
658
659 /*
660 * AF_LOCAL addresses are expected to be absolute
661 * pathnames, anything else will be AF_INET or AF_INET6.
662 */
663 if (*addrstr != '/') {
664 p = strrchr(addrstr, '.');
665 if (p == NULL)
666 goto out;
667 portlo = (unsigned)atoi(p + 1);
668 *p = '\0';
669
670 p = strrchr(addrstr, '.');
671 if (p == NULL)
672 goto out;
673 porthi = (unsigned)atoi(p + 1);
674 *p = '\0';
675 port = (porthi << 8) | portlo;
676 }
677
678 ret = (struct netbuf *)malloc(sizeof *ret);
679 if (ret == NULL)
680 goto out;
681
682 switch (af) {
683 case AF_INET:
684 sin = (struct sockaddr_in *)malloc(sizeof *sin);
685 if (sin == NULL)
686 goto out;
687 memset(sin, 0, sizeof *sin);
688 sin->sin_family = AF_INET;
689 sin->sin_port = htons(port);
690 if (inet_pton(AF_INET, addrstr, &sin->sin_addr) <= 0) {
691 free(sin);
692 free(ret);
693 ret = NULL;
694 goto out;
695 }
696 sin->sin_len = ret->maxlen = ret->len = sizeof *sin;
697 ret->buf = sin;
698 break;
699 #ifdef INET6
700 case AF_INET6:
701 sin6 = (struct sockaddr_in6 *)malloc(sizeof *sin6);
702 if (sin6 == NULL)
703 goto out;
704 memset(sin6, 0, sizeof *sin6);
705 sin6->sin6_family = AF_INET6;
706 sin6->sin6_port = htons(port);
707 if (inet_pton(AF_INET6, addrstr, &sin6->sin6_addr) <= 0) {
708 free(sin6);
709 free(ret);
710 ret = NULL;
711 goto out;
712 }
713 sin6->sin6_len = ret->maxlen = ret->len = sizeof *sin6;
714 ret->buf = sin6;
715 break;
716 #endif
717 case AF_LOCAL:
718 sun = (struct sockaddr_un *)malloc(sizeof *sun);
719 if (sun == NULL)
720 goto out;
721 memset(sun, 0, sizeof *sun);
722 sun->sun_family = AF_LOCAL;
723 strncpy(sun->sun_path, addrstr, sizeof(sun->sun_path) - 1);
724 ret->len = ret->maxlen = sun->sun_len = SUN_LEN(sun);
725 ret->buf = sun;
726 break;
727 default:
728 break;
729 }
730 out:
731 free(addrstr);
732 return ret;
733 }
734
735 int
__rpc_seman2socktype(int semantics)736 __rpc_seman2socktype(int semantics)
737 {
738 switch (semantics) {
739 case NC_TPI_CLTS:
740 return SOCK_DGRAM;
741 case NC_TPI_COTS_ORD:
742 return SOCK_STREAM;
743 case NC_TPI_RAW:
744 return SOCK_RAW;
745 default:
746 break;
747 }
748
749 return -1;
750 }
751
752 int
__rpc_socktype2seman(int socktype)753 __rpc_socktype2seman(int socktype)
754 {
755 switch (socktype) {
756 case SOCK_DGRAM:
757 return NC_TPI_CLTS;
758 case SOCK_STREAM:
759 return NC_TPI_COTS_ORD;
760 case SOCK_RAW:
761 return NC_TPI_RAW;
762 default:
763 break;
764 }
765
766 return -1;
767 }
768
769 /*
770 * XXXX - IPv6 scope IDs can't be handled in universal addresses.
771 * Here, we compare the original server address to that of the RPC
772 * service we just received back from a call to rpcbind on the remote
773 * machine. If they are both "link local" or "site local", copy
774 * the scope id of the server address over to the service address.
775 */
776 int
__rpc_fixup_addr(struct netbuf * new,const struct netbuf * svc)777 __rpc_fixup_addr(struct netbuf *new, const struct netbuf *svc)
778 {
779 #ifdef INET6
780 struct sockaddr *sa_new, *sa_svc;
781 struct sockaddr_in6 *sin6_new, *sin6_svc;
782
783 sa_svc = (struct sockaddr *)svc->buf;
784 sa_new = (struct sockaddr *)new->buf;
785
786 if (sa_new->sa_family == sa_svc->sa_family &&
787 sa_new->sa_family == AF_INET6) {
788 sin6_new = (struct sockaddr_in6 *)new->buf;
789 sin6_svc = (struct sockaddr_in6 *)svc->buf;
790
791 if ((IN6_IS_ADDR_LINKLOCAL(&sin6_new->sin6_addr) &&
792 IN6_IS_ADDR_LINKLOCAL(&sin6_svc->sin6_addr)) ||
793 (IN6_IS_ADDR_SITELOCAL(&sin6_new->sin6_addr) &&
794 IN6_IS_ADDR_SITELOCAL(&sin6_svc->sin6_addr))) {
795 sin6_new->sin6_scope_id = sin6_svc->sin6_scope_id;
796 }
797 }
798 #endif
799 return 1;
800 }
801
802 int
__rpc_sockisbound(int fd)803 __rpc_sockisbound(int fd)
804 {
805 struct sockaddr_storage ss;
806 socklen_t slen;
807
808 slen = sizeof (struct sockaddr_storage);
809 if (_getsockname(fd, (struct sockaddr *)(void *)&ss, &slen) < 0)
810 return 0;
811
812 switch (ss.ss_family) {
813 case AF_INET:
814 return (((struct sockaddr_in *)
815 (void *)&ss)->sin_port != 0);
816 #ifdef INET6
817 case AF_INET6:
818 return (((struct sockaddr_in6 *)
819 (void *)&ss)->sin6_port != 0);
820 #endif
821 case AF_LOCAL:
822 /* XXX check this */
823 return (((struct sockaddr_un *)
824 (void *)&ss)->sun_path[0] != '\0');
825 default:
826 break;
827 }
828
829 return 0;
830 }
831