1 | /* $NetBSD: in_pcb.c,v 1.170 2016/09/29 12:19:47 roy Exp $ */ |
2 | |
3 | /* |
4 | * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project. |
5 | * All rights reserved. |
6 | * |
7 | * Redistribution and use in source and binary forms, with or without |
8 | * modification, are permitted provided that the following conditions |
9 | * are met: |
10 | * 1. Redistributions of source code must retain the above copyright |
11 | * notice, this list of conditions and the following disclaimer. |
12 | * 2. Redistributions in binary form must reproduce the above copyright |
13 | * notice, this list of conditions and the following disclaimer in the |
14 | * documentation and/or other materials provided with the distribution. |
15 | * 3. Neither the name of the project nor the names of its contributors |
16 | * may be used to endorse or promote products derived from this software |
17 | * without specific prior written permission. |
18 | * |
19 | * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND |
20 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
21 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
22 | * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE |
23 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
24 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
25 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
26 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
27 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
28 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
29 | * SUCH DAMAGE. |
30 | */ |
31 | |
32 | /*- |
33 | * Copyright (c) 1998, 2011 The NetBSD Foundation, Inc. |
34 | * All rights reserved. |
35 | * |
36 | * This code is derived from software contributed to The NetBSD Foundation |
37 | * by Coyote Point Systems, Inc. |
38 | * This code is derived from software contributed to The NetBSD Foundation |
39 | * by Public Access Networks Corporation ("Panix"). It was developed under |
40 | * contract to Panix by Eric Haszlakiewicz and Thor Lancelot Simon. |
41 | * |
42 | * Redistribution and use in source and binary forms, with or without |
43 | * modification, are permitted provided that the following conditions |
44 | * are met: |
45 | * 1. Redistributions of source code must retain the above copyright |
46 | * notice, this list of conditions and the following disclaimer. |
47 | * 2. Redistributions in binary form must reproduce the above copyright |
48 | * notice, this list of conditions and the following disclaimer in the |
49 | * documentation and/or other materials provided with the distribution. |
50 | * |
51 | * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS |
52 | * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED |
53 | * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
54 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS |
55 | * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
56 | * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
57 | * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
58 | * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
59 | * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
60 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
61 | * POSSIBILITY OF SUCH DAMAGE. |
62 | */ |
63 | |
64 | /* |
65 | * Copyright (c) 1982, 1986, 1991, 1993, 1995 |
66 | * The Regents of the University of California. All rights reserved. |
67 | * |
68 | * Redistribution and use in source and binary forms, with or without |
69 | * modification, are permitted provided that the following conditions |
70 | * are met: |
71 | * 1. Redistributions of source code must retain the above copyright |
72 | * notice, this list of conditions and the following disclaimer. |
73 | * 2. Redistributions in binary form must reproduce the above copyright |
74 | * notice, this list of conditions and the following disclaimer in the |
75 | * documentation and/or other materials provided with the distribution. |
76 | * 3. Neither the name of the University nor the names of its contributors |
77 | * may be used to endorse or promote products derived from this software |
78 | * without specific prior written permission. |
79 | * |
80 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND |
81 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
82 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
83 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE |
84 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
85 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
86 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
87 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
88 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
89 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
90 | * SUCH DAMAGE. |
91 | * |
92 | * @(#)in_pcb.c 8.4 (Berkeley) 5/24/95 |
93 | */ |
94 | |
95 | #include <sys/cdefs.h> |
96 | __KERNEL_RCSID(0, "$NetBSD: in_pcb.c,v 1.170 2016/09/29 12:19:47 roy Exp $" ); |
97 | |
98 | #ifdef _KERNEL_OPT |
99 | #include "opt_inet.h" |
100 | #include "opt_ipsec.h" |
101 | #endif |
102 | |
103 | #include <sys/param.h> |
104 | #include <sys/systm.h> |
105 | #include <sys/mbuf.h> |
106 | #include <sys/protosw.h> |
107 | #include <sys/socket.h> |
108 | #include <sys/socketvar.h> |
109 | #include <sys/ioctl.h> |
110 | #include <sys/errno.h> |
111 | #include <sys/time.h> |
112 | #include <sys/once.h> |
113 | #include <sys/pool.h> |
114 | #include <sys/proc.h> |
115 | #include <sys/kauth.h> |
116 | #include <sys/uidinfo.h> |
117 | #include <sys/domain.h> |
118 | |
119 | #include <net/if.h> |
120 | #include <net/route.h> |
121 | |
122 | #include <netinet/in.h> |
123 | #include <netinet/in_systm.h> |
124 | #include <netinet/ip.h> |
125 | #include <netinet/in_pcb.h> |
126 | #include <netinet/in_var.h> |
127 | #include <netinet/ip_var.h> |
128 | #include <netinet/portalgo.h> |
129 | |
130 | #ifdef INET6 |
131 | #include <netinet/ip6.h> |
132 | #include <netinet6/ip6_var.h> |
133 | #include <netinet6/in6_pcb.h> |
134 | #endif |
135 | |
136 | #ifdef IPSEC |
137 | #include <netipsec/ipsec.h> |
138 | #include <netipsec/key.h> |
139 | #endif /* IPSEC */ |
140 | |
141 | #include <netinet/tcp_vtw.h> |
142 | |
143 | struct in_addr zeroin_addr; |
144 | |
145 | #define INPCBHASH_PORT(table, lport) \ |
146 | &(table)->inpt_porthashtbl[ntohs(lport) & (table)->inpt_porthash] |
147 | #define INPCBHASH_BIND(table, laddr, lport) \ |
148 | &(table)->inpt_bindhashtbl[ \ |
149 | ((ntohl((laddr).s_addr) + ntohs(lport))) & (table)->inpt_bindhash] |
150 | #define INPCBHASH_CONNECT(table, faddr, fport, laddr, lport) \ |
151 | &(table)->inpt_connecthashtbl[ \ |
152 | ((ntohl((faddr).s_addr) + ntohs(fport)) + \ |
153 | (ntohl((laddr).s_addr) + ntohs(lport))) & (table)->inpt_connecthash] |
154 | |
155 | int anonportmin = IPPORT_ANONMIN; |
156 | int anonportmax = IPPORT_ANONMAX; |
157 | int lowportmin = IPPORT_RESERVEDMIN; |
158 | int lowportmax = IPPORT_RESERVEDMAX; |
159 | |
160 | static struct pool inpcb_pool; |
161 | |
162 | static int |
163 | inpcb_poolinit(void) |
164 | { |
165 | |
166 | pool_init(&inpcb_pool, sizeof(struct inpcb), 0, 0, 0, "inpcbpl" , NULL, |
167 | IPL_NET); |
168 | return 0; |
169 | } |
170 | |
171 | void |
172 | in_pcbinit(struct inpcbtable *table, int bindhashsize, int connecthashsize) |
173 | { |
174 | static ONCE_DECL(control); |
175 | |
176 | TAILQ_INIT(&table->inpt_queue); |
177 | table->inpt_porthashtbl = hashinit(bindhashsize, HASH_LIST, true, |
178 | &table->inpt_porthash); |
179 | table->inpt_bindhashtbl = hashinit(bindhashsize, HASH_LIST, true, |
180 | &table->inpt_bindhash); |
181 | table->inpt_connecthashtbl = hashinit(connecthashsize, HASH_LIST, true, |
182 | &table->inpt_connecthash); |
183 | table->inpt_lastlow = IPPORT_RESERVEDMAX; |
184 | table->inpt_lastport = (u_int16_t)anonportmax; |
185 | |
186 | RUN_ONCE(&control, inpcb_poolinit); |
187 | } |
188 | |
189 | int |
190 | in_pcballoc(struct socket *so, void *v) |
191 | { |
192 | struct inpcbtable *table = v; |
193 | struct inpcb *inp; |
194 | int s; |
195 | |
196 | s = splnet(); |
197 | inp = pool_get(&inpcb_pool, PR_NOWAIT); |
198 | splx(s); |
199 | if (inp == NULL) |
200 | return (ENOBUFS); |
201 | memset(inp, 0, sizeof(*inp)); |
202 | inp->inp_af = AF_INET; |
203 | inp->inp_table = table; |
204 | inp->inp_socket = so; |
205 | inp->inp_errormtu = -1; |
206 | inp->inp_portalgo = PORTALGO_DEFAULT; |
207 | inp->inp_bindportonsend = false; |
208 | #if defined(IPSEC) |
209 | if (ipsec_enabled) { |
210 | int error = ipsec_init_pcbpolicy(so, &inp->inp_sp); |
211 | if (error != 0) { |
212 | s = splnet(); |
213 | pool_put(&inpcb_pool, inp); |
214 | splx(s); |
215 | return error; |
216 | } |
217 | } |
218 | #endif |
219 | so->so_pcb = inp; |
220 | s = splnet(); |
221 | TAILQ_INSERT_HEAD(&table->inpt_queue, &inp->inp_head, inph_queue); |
222 | LIST_INSERT_HEAD(INPCBHASH_PORT(table, inp->inp_lport), &inp->inp_head, |
223 | inph_lhash); |
224 | in_pcbstate(inp, INP_ATTACHED); |
225 | splx(s); |
226 | return (0); |
227 | } |
228 | |
229 | static int |
230 | in_pcbsetport(struct sockaddr_in *sin, struct inpcb *inp, kauth_cred_t cred) |
231 | { |
232 | struct inpcbtable *table = inp->inp_table; |
233 | struct socket *so = inp->inp_socket; |
234 | u_int16_t *lastport; |
235 | u_int16_t lport = 0; |
236 | enum kauth_network_req req; |
237 | int error; |
238 | |
239 | if (inp->inp_flags & INP_LOWPORT) { |
240 | #ifndef IPNOPRIVPORTS |
241 | req = KAUTH_REQ_NETWORK_BIND_PRIVPORT; |
242 | #else |
243 | req = KAUTH_REQ_NETWORK_BIND_PORT; |
244 | #endif |
245 | |
246 | lastport = &table->inpt_lastlow; |
247 | } else { |
248 | req = KAUTH_REQ_NETWORK_BIND_PORT; |
249 | |
250 | lastport = &table->inpt_lastport; |
251 | } |
252 | |
253 | /* XXX-kauth: KAUTH_REQ_NETWORK_BIND_AUTOASSIGN_{,PRIV}PORT */ |
254 | error = kauth_authorize_network(cred, KAUTH_NETWORK_BIND, req, so, sin, |
255 | NULL); |
256 | if (error) |
257 | return (EACCES); |
258 | |
259 | /* |
260 | * Use RFC6056 randomized port selection |
261 | */ |
262 | error = portalgo_randport(&lport, &inp->inp_head, cred); |
263 | if (error) |
264 | return error; |
265 | |
266 | inp->inp_flags |= INP_ANONPORT; |
267 | *lastport = lport; |
268 | lport = htons(lport); |
269 | inp->inp_lport = lport; |
270 | in_pcbstate(inp, INP_BOUND); |
271 | |
272 | return (0); |
273 | } |
274 | |
275 | static int |
276 | in_pcbbind_addr(struct inpcb *inp, struct sockaddr_in *sin, kauth_cred_t cred) |
277 | { |
278 | int error = EADDRNOTAVAIL; |
279 | struct ifaddr *ifa = NULL; |
280 | int s; |
281 | |
282 | if (sin->sin_family != AF_INET) |
283 | return (EAFNOSUPPORT); |
284 | |
285 | s = pserialize_read_enter(); |
286 | if (IN_MULTICAST(sin->sin_addr.s_addr)) { |
287 | /* Always succeed; port reuse handled in in_pcbbind_port(). */ |
288 | } else if (!in_nullhost(sin->sin_addr)) { |
289 | struct in_ifaddr *ia; |
290 | |
291 | ia = in_get_ia(sin->sin_addr); |
292 | /* check for broadcast addresses */ |
293 | if (ia == NULL) { |
294 | ifa = ifa_ifwithaddr(sintosa(sin)); |
295 | if (ifa != NULL) |
296 | ia = ifatoia(ifa); |
297 | } |
298 | if (ia == NULL) |
299 | goto error; |
300 | if (ia->ia4_flags & IN_IFF_DUPLICATED) |
301 | goto error; |
302 | } |
303 | pserialize_read_exit(s); |
304 | |
305 | inp->inp_laddr = sin->sin_addr; |
306 | |
307 | return (0); |
308 | error: |
309 | pserialize_read_exit(s); |
310 | return error; |
311 | } |
312 | |
313 | static int |
314 | in_pcbbind_port(struct inpcb *inp, struct sockaddr_in *sin, kauth_cred_t cred) |
315 | { |
316 | struct inpcbtable *table = inp->inp_table; |
317 | struct socket *so = inp->inp_socket; |
318 | int reuseport = (so->so_options & SO_REUSEPORT); |
319 | int wild = 0, error; |
320 | |
321 | if (IN_MULTICAST(sin->sin_addr.s_addr)) { |
322 | /* |
323 | * Treat SO_REUSEADDR as SO_REUSEPORT for multicast; |
324 | * allow complete duplication of binding if |
325 | * SO_REUSEPORT is set, or if SO_REUSEADDR is set |
326 | * and a multicast address is bound on both |
327 | * new and duplicated sockets. |
328 | */ |
329 | if (so->so_options & (SO_REUSEADDR | SO_REUSEPORT)) |
330 | reuseport = SO_REUSEADDR|SO_REUSEPORT; |
331 | } |
332 | |
333 | if (sin->sin_port == 0) { |
334 | error = in_pcbsetport(sin, inp, cred); |
335 | if (error) |
336 | return (error); |
337 | } else { |
338 | struct inpcb *t; |
339 | vestigial_inpcb_t vestige; |
340 | #ifdef INET6 |
341 | struct in6pcb *t6; |
342 | struct in6_addr mapped; |
343 | #endif |
344 | enum kauth_network_req req; |
345 | |
346 | if ((so->so_options & (SO_REUSEADDR|SO_REUSEPORT)) == 0) |
347 | wild = 1; |
348 | |
349 | #ifndef IPNOPRIVPORTS |
350 | if (ntohs(sin->sin_port) < IPPORT_RESERVED) |
351 | req = KAUTH_REQ_NETWORK_BIND_PRIVPORT; |
352 | else |
353 | #endif /* !IPNOPRIVPORTS */ |
354 | req = KAUTH_REQ_NETWORK_BIND_PORT; |
355 | |
356 | error = kauth_authorize_network(cred, KAUTH_NETWORK_BIND, req, |
357 | so, sin, NULL); |
358 | if (error) |
359 | return (EACCES); |
360 | |
361 | #ifdef INET6 |
362 | in6_in_2_v4mapin6(&sin->sin_addr, &mapped); |
363 | t6 = in6_pcblookup_port(table, &mapped, sin->sin_port, wild, &vestige); |
364 | if (t6 && (reuseport & t6->in6p_socket->so_options) == 0) |
365 | return (EADDRINUSE); |
366 | if (!t6 && vestige.valid) { |
367 | if (!!reuseport != !!vestige.reuse_port) { |
368 | return EADDRINUSE; |
369 | } |
370 | } |
371 | #endif |
372 | |
373 | /* XXX-kauth */ |
374 | if (so->so_uidinfo->ui_uid && !IN_MULTICAST(sin->sin_addr.s_addr)) { |
375 | t = in_pcblookup_port(table, sin->sin_addr, sin->sin_port, 1, &vestige); |
376 | /* |
377 | * XXX: investigate ramifications of loosening this |
378 | * restriction so that as long as both ports have |
379 | * SO_REUSEPORT allow the bind |
380 | */ |
381 | if (t && |
382 | (!in_nullhost(sin->sin_addr) || |
383 | !in_nullhost(t->inp_laddr) || |
384 | (t->inp_socket->so_options & SO_REUSEPORT) == 0) |
385 | && (so->so_uidinfo->ui_uid != t->inp_socket->so_uidinfo->ui_uid)) { |
386 | return (EADDRINUSE); |
387 | } |
388 | if (!t && vestige.valid) { |
389 | if ((!in_nullhost(sin->sin_addr) |
390 | || !in_nullhost(vestige.laddr.v4) |
391 | || !vestige.reuse_port) |
392 | && so->so_uidinfo->ui_uid != vestige.uid) { |
393 | return EADDRINUSE; |
394 | } |
395 | } |
396 | } |
397 | t = in_pcblookup_port(table, sin->sin_addr, sin->sin_port, wild, &vestige); |
398 | if (t && (reuseport & t->inp_socket->so_options) == 0) |
399 | return (EADDRINUSE); |
400 | if (!t |
401 | && vestige.valid |
402 | && !(reuseport && vestige.reuse_port)) |
403 | return EADDRINUSE; |
404 | |
405 | inp->inp_lport = sin->sin_port; |
406 | in_pcbstate(inp, INP_BOUND); |
407 | } |
408 | |
409 | LIST_REMOVE(&inp->inp_head, inph_lhash); |
410 | LIST_INSERT_HEAD(INPCBHASH_PORT(table, inp->inp_lport), &inp->inp_head, |
411 | inph_lhash); |
412 | |
413 | return (0); |
414 | } |
415 | |
416 | int |
417 | in_pcbbind(void *v, struct sockaddr_in *sin, struct lwp *l) |
418 | { |
419 | struct inpcb *inp = v; |
420 | struct sockaddr_in lsin; |
421 | int error; |
422 | |
423 | if (inp->inp_af != AF_INET) |
424 | return (EINVAL); |
425 | |
426 | if (IN_ADDRLIST_READER_EMPTY()) |
427 | return (EADDRNOTAVAIL); |
428 | if (inp->inp_lport || !in_nullhost(inp->inp_laddr)) |
429 | return (EINVAL); |
430 | |
431 | if (NULL != sin) { |
432 | if (sin->sin_len != sizeof(*sin)) |
433 | return (EINVAL); |
434 | } else { |
435 | lsin = *((const struct sockaddr_in *) |
436 | inp->inp_socket->so_proto->pr_domain->dom_sa_any); |
437 | sin = &lsin; |
438 | } |
439 | |
440 | /* Bind address. */ |
441 | error = in_pcbbind_addr(inp, sin, l->l_cred); |
442 | if (error) |
443 | return (error); |
444 | |
445 | /* Bind port. */ |
446 | error = in_pcbbind_port(inp, sin, l->l_cred); |
447 | if (error) { |
448 | inp->inp_laddr.s_addr = INADDR_ANY; |
449 | |
450 | return (error); |
451 | } |
452 | |
453 | return (0); |
454 | } |
455 | |
456 | /* |
457 | * Connect from a socket to a specified address. |
458 | * Both address and port must be specified in argument sin. |
459 | * If don't have a local address for this socket yet, |
460 | * then pick one. |
461 | */ |
462 | int |
463 | in_pcbconnect(void *v, struct sockaddr_in *sin, struct lwp *l) |
464 | { |
465 | struct inpcb *inp = v; |
466 | vestigial_inpcb_t vestige; |
467 | int error; |
468 | struct in_addr laddr; |
469 | |
470 | if (inp->inp_af != AF_INET) |
471 | return (EINVAL); |
472 | |
473 | if (sin->sin_len != sizeof (*sin)) |
474 | return (EINVAL); |
475 | if (sin->sin_family != AF_INET) |
476 | return (EAFNOSUPPORT); |
477 | if (sin->sin_port == 0) |
478 | return (EADDRNOTAVAIL); |
479 | |
480 | if (IN_MULTICAST(sin->sin_addr.s_addr) && |
481 | inp->inp_socket->so_type == SOCK_STREAM) |
482 | return EADDRNOTAVAIL; |
483 | |
484 | if (!IN_ADDRLIST_READER_EMPTY()) { |
485 | /* |
486 | * If the destination address is INADDR_ANY, |
487 | * use any local address (likely loopback). |
488 | * If the supplied address is INADDR_BROADCAST, |
489 | * use the broadcast address of an interface |
490 | * which supports broadcast. (loopback does not) |
491 | */ |
492 | |
493 | if (in_nullhost(sin->sin_addr)) { |
494 | /* XXX racy */ |
495 | sin->sin_addr = |
496 | IN_ADDRLIST_READER_FIRST()->ia_addr.sin_addr; |
497 | } else if (sin->sin_addr.s_addr == INADDR_BROADCAST) { |
498 | struct in_ifaddr *ia; |
499 | int s = pserialize_read_enter(); |
500 | IN_ADDRLIST_READER_FOREACH(ia) { |
501 | if (ia->ia_ifp->if_flags & IFF_BROADCAST) { |
502 | sin->sin_addr = |
503 | ia->ia_broadaddr.sin_addr; |
504 | break; |
505 | } |
506 | } |
507 | pserialize_read_exit(s); |
508 | } |
509 | } |
510 | /* |
511 | * If we haven't bound which network number to use as ours, |
512 | * we will use the number of the outgoing interface. |
513 | * This depends on having done a routing lookup, which |
514 | * we will probably have to do anyway, so we might |
515 | * as well do it now. On the other hand if we are |
516 | * sending to multiple destinations we may have already |
517 | * done the lookup, so see if we can use the route |
518 | * from before. In any case, we only |
519 | * chose a port number once, even if sending to multiple |
520 | * destinations. |
521 | */ |
522 | if (in_nullhost(inp->inp_laddr)) { |
523 | int xerror; |
524 | struct in_ifaddr *ia, *_ia; |
525 | int s; |
526 | struct psref psref; |
527 | int bound; |
528 | |
529 | bound = curlwp_bind(); |
530 | ia = in_selectsrc(sin, &inp->inp_route, |
531 | inp->inp_socket->so_options, inp->inp_moptions, &xerror, |
532 | &psref); |
533 | if (ia == NULL) { |
534 | curlwp_bindx(bound); |
535 | if (xerror == 0) |
536 | xerror = EADDRNOTAVAIL; |
537 | return xerror; |
538 | } |
539 | s = pserialize_read_enter(); |
540 | _ia = in_get_ia(IA_SIN(ia)->sin_addr); |
541 | if (_ia == NULL) { |
542 | pserialize_read_exit(s); |
543 | ia4_release(ia, &psref); |
544 | curlwp_bindx(bound); |
545 | return (EADDRNOTAVAIL); |
546 | } |
547 | pserialize_read_exit(s); |
548 | laddr = IA_SIN(ia)->sin_addr; |
549 | ia4_release(ia, &psref); |
550 | curlwp_bindx(bound); |
551 | } else |
552 | laddr = inp->inp_laddr; |
553 | if (in_pcblookup_connect(inp->inp_table, sin->sin_addr, sin->sin_port, |
554 | laddr, inp->inp_lport, &vestige) != NULL || |
555 | vestige.valid) { |
556 | return (EADDRINUSE); |
557 | } |
558 | if (in_nullhost(inp->inp_laddr)) { |
559 | if (inp->inp_lport == 0) { |
560 | error = in_pcbbind(inp, NULL, l); |
561 | /* |
562 | * This used to ignore the return value |
563 | * completely, but we need to check for |
564 | * ephemeral port shortage. |
565 | * And attempts to request low ports if not root. |
566 | */ |
567 | if (error != 0) |
568 | return (error); |
569 | } |
570 | inp->inp_laddr = laddr; |
571 | } |
572 | inp->inp_faddr = sin->sin_addr; |
573 | inp->inp_fport = sin->sin_port; |
574 | |
575 | /* Late bind, if needed */ |
576 | if (inp->inp_bindportonsend) { |
577 | struct sockaddr_in lsin = *((const struct sockaddr_in *) |
578 | inp->inp_socket->so_proto->pr_domain->dom_sa_any); |
579 | lsin.sin_addr = inp->inp_laddr; |
580 | lsin.sin_port = 0; |
581 | |
582 | if ((error = in_pcbbind_port(inp, &lsin, l->l_cred)) != 0) |
583 | return error; |
584 | } |
585 | |
586 | in_pcbstate(inp, INP_CONNECTED); |
587 | #if defined(IPSEC) |
588 | if (ipsec_enabled && inp->inp_socket->so_type == SOCK_STREAM) |
589 | ipsec_pcbconn(inp->inp_sp); |
590 | #endif |
591 | return (0); |
592 | } |
593 | |
594 | void |
595 | in_pcbdisconnect(void *v) |
596 | { |
597 | struct inpcb *inp = v; |
598 | |
599 | if (inp->inp_af != AF_INET) |
600 | return; |
601 | |
602 | inp->inp_faddr = zeroin_addr; |
603 | inp->inp_fport = 0; |
604 | in_pcbstate(inp, INP_BOUND); |
605 | #if defined(IPSEC) |
606 | if (ipsec_enabled) |
607 | ipsec_pcbdisconn(inp->inp_sp); |
608 | #endif |
609 | if (inp->inp_socket->so_state & SS_NOFDREF) |
610 | in_pcbdetach(inp); |
611 | } |
612 | |
613 | void |
614 | in_pcbdetach(void *v) |
615 | { |
616 | struct inpcb *inp = v; |
617 | struct socket *so = inp->inp_socket; |
618 | int s; |
619 | |
620 | if (inp->inp_af != AF_INET) |
621 | return; |
622 | |
623 | #if defined(IPSEC) |
624 | if (ipsec_enabled) |
625 | ipsec4_delete_pcbpolicy(inp); |
626 | #endif |
627 | so->so_pcb = NULL; |
628 | |
629 | s = splnet(); |
630 | in_pcbstate(inp, INP_ATTACHED); |
631 | LIST_REMOVE(&inp->inp_head, inph_lhash); |
632 | TAILQ_REMOVE(&inp->inp_table->inpt_queue, &inp->inp_head, inph_queue); |
633 | splx(s); |
634 | |
635 | if (inp->inp_options) { |
636 | m_free(inp->inp_options); |
637 | } |
638 | rtcache_free(&inp->inp_route); |
639 | ip_freemoptions(inp->inp_moptions); |
640 | sofree(so); /* drops the socket's lock */ |
641 | |
642 | pool_put(&inpcb_pool, inp); |
643 | mutex_enter(softnet_lock); /* reacquire the softnet_lock */ |
644 | } |
645 | |
646 | void |
647 | in_setsockaddr(struct inpcb *inp, struct sockaddr_in *sin) |
648 | { |
649 | |
650 | if (inp->inp_af != AF_INET) |
651 | return; |
652 | |
653 | sockaddr_in_init(sin, &inp->inp_laddr, inp->inp_lport); |
654 | } |
655 | |
656 | void |
657 | in_setpeeraddr(struct inpcb *inp, struct sockaddr_in *sin) |
658 | { |
659 | |
660 | if (inp->inp_af != AF_INET) |
661 | return; |
662 | |
663 | sockaddr_in_init(sin, &inp->inp_faddr, inp->inp_fport); |
664 | } |
665 | |
666 | /* |
667 | * Pass some notification to all connections of a protocol |
668 | * associated with address dst. The local address and/or port numbers |
669 | * may be specified to limit the search. The "usual action" will be |
670 | * taken, depending on the ctlinput cmd. The caller must filter any |
671 | * cmds that are uninteresting (e.g., no error in the map). |
672 | * Call the protocol specific routine (if any) to report |
673 | * any errors for each matching socket. |
674 | * |
675 | * Must be called at splsoftnet. |
676 | */ |
677 | int |
678 | in_pcbnotify(struct inpcbtable *table, struct in_addr faddr, u_int fport_arg, |
679 | struct in_addr laddr, u_int lport_arg, int errno, |
680 | void (*notify)(struct inpcb *, int)) |
681 | { |
682 | struct inpcbhead *head; |
683 | struct inpcb *inp, *ninp; |
684 | u_int16_t fport = fport_arg, lport = lport_arg; |
685 | int nmatch; |
686 | |
687 | if (in_nullhost(faddr) || notify == 0) |
688 | return (0); |
689 | |
690 | nmatch = 0; |
691 | head = INPCBHASH_CONNECT(table, faddr, fport, laddr, lport); |
692 | for (inp = (struct inpcb *)LIST_FIRST(head); inp != NULL; inp = ninp) { |
693 | ninp = (struct inpcb *)LIST_NEXT(inp, inp_hash); |
694 | if (inp->inp_af != AF_INET) |
695 | continue; |
696 | if (in_hosteq(inp->inp_faddr, faddr) && |
697 | inp->inp_fport == fport && |
698 | inp->inp_lport == lport && |
699 | in_hosteq(inp->inp_laddr, laddr)) { |
700 | (*notify)(inp, errno); |
701 | nmatch++; |
702 | } |
703 | } |
704 | return (nmatch); |
705 | } |
706 | |
707 | void |
708 | in_pcbnotifyall(struct inpcbtable *table, struct in_addr faddr, int errno, |
709 | void (*notify)(struct inpcb *, int)) |
710 | { |
711 | struct inpcb_hdr *inph, *ninph; |
712 | |
713 | if (in_nullhost(faddr) || notify == 0) |
714 | return; |
715 | |
716 | TAILQ_FOREACH_SAFE(inph, &table->inpt_queue, inph_queue, ninph) { |
717 | struct inpcb *inp = (struct inpcb *)inph; |
718 | if (inp->inp_af != AF_INET) |
719 | continue; |
720 | if (in_hosteq(inp->inp_faddr, faddr)) |
721 | (*notify)(inp, errno); |
722 | } |
723 | } |
724 | |
725 | void |
726 | in_purgeifmcast(struct ip_moptions *imo, struct ifnet *ifp) |
727 | { |
728 | int i, gap; |
729 | |
730 | KASSERT(ifp != NULL); |
731 | |
732 | if (imo == NULL) |
733 | return; |
734 | |
735 | /* |
736 | * Unselect the outgoing interface if it is being |
737 | * detached. |
738 | */ |
739 | if (imo->imo_multicast_if_index == ifp->if_index) |
740 | imo->imo_multicast_if_index = 0; |
741 | |
742 | /* |
743 | * Drop multicast group membership if we joined |
744 | * through the interface being detached. |
745 | */ |
746 | for (i = 0, gap = 0; i < imo->imo_num_memberships; i++) { |
747 | if (imo->imo_membership[i]->inm_ifp == ifp) { |
748 | in_delmulti(imo->imo_membership[i]); |
749 | gap++; |
750 | } else if (gap != 0) |
751 | imo->imo_membership[i - gap] = imo->imo_membership[i]; |
752 | } |
753 | imo->imo_num_memberships -= gap; |
754 | } |
755 | |
756 | void |
757 | in_pcbpurgeif0(struct inpcbtable *table, struct ifnet *ifp) |
758 | { |
759 | struct inpcb_hdr *inph, *ninph; |
760 | |
761 | TAILQ_FOREACH_SAFE(inph, &table->inpt_queue, inph_queue, ninph) { |
762 | struct inpcb *inp = (struct inpcb *)inph; |
763 | if (inp->inp_af != AF_INET) |
764 | continue; |
765 | in_purgeifmcast(inp->inp_moptions, ifp); |
766 | } |
767 | } |
768 | |
769 | void |
770 | in_pcbpurgeif(struct inpcbtable *table, struct ifnet *ifp) |
771 | { |
772 | struct rtentry *rt; |
773 | struct inpcb_hdr *inph, *ninph; |
774 | |
775 | TAILQ_FOREACH_SAFE(inph, &table->inpt_queue, inph_queue, ninph) { |
776 | struct inpcb *inp = (struct inpcb *)inph; |
777 | if (inp->inp_af != AF_INET) |
778 | continue; |
779 | if ((rt = rtcache_validate(&inp->inp_route)) != NULL && |
780 | rt->rt_ifp == ifp) |
781 | in_rtchange(inp, 0); |
782 | } |
783 | } |
784 | |
785 | /* |
786 | * Check for alternatives when higher level complains |
787 | * about service problems. For now, invalidate cached |
788 | * routing information. If the route was created dynamically |
789 | * (by a redirect), time to try a default gateway again. |
790 | */ |
791 | void |
792 | in_losing(struct inpcb *inp) |
793 | { |
794 | struct rtentry *rt; |
795 | struct rt_addrinfo info; |
796 | |
797 | if (inp->inp_af != AF_INET) |
798 | return; |
799 | |
800 | if ((rt = rtcache_validate(&inp->inp_route)) == NULL) |
801 | return; |
802 | |
803 | memset(&info, 0, sizeof(info)); |
804 | info.rti_info[RTAX_DST] = rtcache_getdst(&inp->inp_route); |
805 | info.rti_info[RTAX_GATEWAY] = rt->rt_gateway; |
806 | info.rti_info[RTAX_NETMASK] = rt_mask(rt); |
807 | rt_missmsg(RTM_LOSING, &info, rt->rt_flags, 0); |
808 | if (rt->rt_flags & RTF_DYNAMIC) |
809 | (void) rtrequest(RTM_DELETE, rt_getkey(rt), |
810 | rt->rt_gateway, rt_mask(rt), rt->rt_flags, |
811 | NULL); |
812 | /* |
813 | * A new route can be allocated |
814 | * the next time output is attempted. |
815 | */ |
816 | rtcache_free(&inp->inp_route); |
817 | } |
818 | |
819 | /* |
820 | * After a routing change, flush old routing. A new route can be |
821 | * allocated the next time output is attempted. |
822 | */ |
823 | void |
824 | in_rtchange(struct inpcb *inp, int errno) |
825 | { |
826 | |
827 | if (inp->inp_af != AF_INET) |
828 | return; |
829 | |
830 | rtcache_free(&inp->inp_route); |
831 | |
832 | /* XXX SHOULD NOTIFY HIGHER-LEVEL PROTOCOLS */ |
833 | } |
834 | |
835 | struct inpcb * |
836 | in_pcblookup_port(struct inpcbtable *table, struct in_addr laddr, |
837 | u_int lport_arg, int lookup_wildcard, vestigial_inpcb_t *vp) |
838 | { |
839 | struct inpcbhead *head; |
840 | struct inpcb_hdr *inph; |
841 | struct inpcb *match = NULL; |
842 | int matchwild = 3; |
843 | int wildcard; |
844 | u_int16_t lport = lport_arg; |
845 | |
846 | if (vp) |
847 | vp->valid = 0; |
848 | |
849 | head = INPCBHASH_PORT(table, lport); |
850 | LIST_FOREACH(inph, head, inph_lhash) { |
851 | struct inpcb * const inp = (struct inpcb *)inph; |
852 | |
853 | if (inp->inp_af != AF_INET) |
854 | continue; |
855 | if (inp->inp_lport != lport) |
856 | continue; |
857 | /* |
858 | * check if inp's faddr and laddr match with ours. |
859 | * our faddr is considered null. |
860 | * count the number of wildcard matches. (0 - 2) |
861 | * |
862 | * null null match |
863 | * A null wildcard match |
864 | * null B wildcard match |
865 | * A B non match |
866 | * A A match |
867 | */ |
868 | wildcard = 0; |
869 | if (!in_nullhost(inp->inp_faddr)) |
870 | wildcard++; |
871 | if (in_nullhost(inp->inp_laddr)) { |
872 | if (!in_nullhost(laddr)) |
873 | wildcard++; |
874 | } else { |
875 | if (in_nullhost(laddr)) |
876 | wildcard++; |
877 | else { |
878 | if (!in_hosteq(inp->inp_laddr, laddr)) |
879 | continue; |
880 | } |
881 | } |
882 | if (wildcard && !lookup_wildcard) |
883 | continue; |
884 | /* |
885 | * prefer an address with less wildcards. |
886 | */ |
887 | if (wildcard < matchwild) { |
888 | match = inp; |
889 | matchwild = wildcard; |
890 | if (matchwild == 0) |
891 | break; |
892 | } |
893 | } |
894 | if (match && matchwild == 0) |
895 | return match; |
896 | |
897 | if (vp && table->vestige) { |
898 | void *state = (*table->vestige->init_ports4)(laddr, lport_arg, lookup_wildcard); |
899 | vestigial_inpcb_t better; |
900 | |
901 | while (table->vestige |
902 | && (*table->vestige->next_port4)(state, vp)) { |
903 | |
904 | if (vp->lport != lport) |
905 | continue; |
906 | wildcard = 0; |
907 | if (!in_nullhost(vp->faddr.v4)) |
908 | wildcard++; |
909 | if (in_nullhost(vp->laddr.v4)) { |
910 | if (!in_nullhost(laddr)) |
911 | wildcard++; |
912 | } else { |
913 | if (in_nullhost(laddr)) |
914 | wildcard++; |
915 | else { |
916 | if (!in_hosteq(vp->laddr.v4, laddr)) |
917 | continue; |
918 | } |
919 | } |
920 | if (wildcard && !lookup_wildcard) |
921 | continue; |
922 | if (wildcard < matchwild) { |
923 | better = *vp; |
924 | match = (void*)&better; |
925 | |
926 | matchwild = wildcard; |
927 | if (matchwild == 0) |
928 | break; |
929 | } |
930 | } |
931 | |
932 | if (match) { |
933 | if (match != (void*)&better) |
934 | return match; |
935 | else { |
936 | *vp = better; |
937 | return 0; |
938 | } |
939 | } |
940 | } |
941 | |
942 | return (match); |
943 | } |
944 | |
945 | #ifdef DIAGNOSTIC |
946 | int in_pcbnotifymiss = 0; |
947 | #endif |
948 | |
949 | struct inpcb * |
950 | in_pcblookup_connect(struct inpcbtable *table, |
951 | struct in_addr faddr, u_int fport_arg, |
952 | struct in_addr laddr, u_int lport_arg, |
953 | vestigial_inpcb_t *vp) |
954 | { |
955 | struct inpcbhead *head; |
956 | struct inpcb_hdr *inph; |
957 | struct inpcb *inp; |
958 | u_int16_t fport = fport_arg, lport = lport_arg; |
959 | |
960 | if (vp) |
961 | vp->valid = 0; |
962 | |
963 | head = INPCBHASH_CONNECT(table, faddr, fport, laddr, lport); |
964 | LIST_FOREACH(inph, head, inph_hash) { |
965 | inp = (struct inpcb *)inph; |
966 | if (inp->inp_af != AF_INET) |
967 | continue; |
968 | |
969 | if (in_hosteq(inp->inp_faddr, faddr) && |
970 | inp->inp_fport == fport && |
971 | inp->inp_lport == lport && |
972 | in_hosteq(inp->inp_laddr, laddr)) |
973 | goto out; |
974 | } |
975 | if (vp && table->vestige) { |
976 | if ((*table->vestige->lookup4)(faddr, fport_arg, |
977 | laddr, lport_arg, vp)) |
978 | return 0; |
979 | } |
980 | |
981 | #ifdef DIAGNOSTIC |
982 | if (in_pcbnotifymiss) { |
983 | printf("in_pcblookup_connect: faddr=%08x fport=%d laddr=%08x lport=%d\n" , |
984 | ntohl(faddr.s_addr), ntohs(fport), |
985 | ntohl(laddr.s_addr), ntohs(lport)); |
986 | } |
987 | #endif |
988 | return (0); |
989 | |
990 | out: |
991 | /* Move this PCB to the head of hash chain. */ |
992 | inph = &inp->inp_head; |
993 | if (inph != LIST_FIRST(head)) { |
994 | LIST_REMOVE(inph, inph_hash); |
995 | LIST_INSERT_HEAD(head, inph, inph_hash); |
996 | } |
997 | return (inp); |
998 | } |
999 | |
1000 | struct inpcb * |
1001 | in_pcblookup_bind(struct inpcbtable *table, |
1002 | struct in_addr laddr, u_int lport_arg) |
1003 | { |
1004 | struct inpcbhead *head; |
1005 | struct inpcb_hdr *inph; |
1006 | struct inpcb *inp; |
1007 | u_int16_t lport = lport_arg; |
1008 | |
1009 | head = INPCBHASH_BIND(table, laddr, lport); |
1010 | LIST_FOREACH(inph, head, inph_hash) { |
1011 | inp = (struct inpcb *)inph; |
1012 | if (inp->inp_af != AF_INET) |
1013 | continue; |
1014 | |
1015 | if (inp->inp_lport == lport && |
1016 | in_hosteq(inp->inp_laddr, laddr)) |
1017 | goto out; |
1018 | } |
1019 | head = INPCBHASH_BIND(table, zeroin_addr, lport); |
1020 | LIST_FOREACH(inph, head, inph_hash) { |
1021 | inp = (struct inpcb *)inph; |
1022 | if (inp->inp_af != AF_INET) |
1023 | continue; |
1024 | |
1025 | if (inp->inp_lport == lport && |
1026 | in_hosteq(inp->inp_laddr, zeroin_addr)) |
1027 | goto out; |
1028 | } |
1029 | #ifdef DIAGNOSTIC |
1030 | if (in_pcbnotifymiss) { |
1031 | printf("in_pcblookup_bind: laddr=%08x lport=%d\n" , |
1032 | ntohl(laddr.s_addr), ntohs(lport)); |
1033 | } |
1034 | #endif |
1035 | return (0); |
1036 | |
1037 | out: |
1038 | /* Move this PCB to the head of hash chain. */ |
1039 | inph = &inp->inp_head; |
1040 | if (inph != LIST_FIRST(head)) { |
1041 | LIST_REMOVE(inph, inph_hash); |
1042 | LIST_INSERT_HEAD(head, inph, inph_hash); |
1043 | } |
1044 | return (inp); |
1045 | } |
1046 | |
1047 | void |
1048 | in_pcbstate(struct inpcb *inp, int state) |
1049 | { |
1050 | |
1051 | if (inp->inp_af != AF_INET) |
1052 | return; |
1053 | |
1054 | if (inp->inp_state > INP_ATTACHED) |
1055 | LIST_REMOVE(&inp->inp_head, inph_hash); |
1056 | |
1057 | switch (state) { |
1058 | case INP_BOUND: |
1059 | LIST_INSERT_HEAD(INPCBHASH_BIND(inp->inp_table, |
1060 | inp->inp_laddr, inp->inp_lport), &inp->inp_head, |
1061 | inph_hash); |
1062 | break; |
1063 | case INP_CONNECTED: |
1064 | LIST_INSERT_HEAD(INPCBHASH_CONNECT(inp->inp_table, |
1065 | inp->inp_faddr, inp->inp_fport, |
1066 | inp->inp_laddr, inp->inp_lport), &inp->inp_head, |
1067 | inph_hash); |
1068 | break; |
1069 | } |
1070 | |
1071 | inp->inp_state = state; |
1072 | } |
1073 | |
1074 | struct rtentry * |
1075 | in_pcbrtentry(struct inpcb *inp) |
1076 | { |
1077 | struct route *ro; |
1078 | union { |
1079 | struct sockaddr dst; |
1080 | struct sockaddr_in dst4; |
1081 | } u; |
1082 | |
1083 | if (inp->inp_af != AF_INET) |
1084 | return (NULL); |
1085 | |
1086 | ro = &inp->inp_route; |
1087 | |
1088 | sockaddr_in_init(&u.dst4, &inp->inp_faddr, 0); |
1089 | return rtcache_lookup(ro, &u.dst); |
1090 | } |
1091 | |