FreeBSD/Linux Kernel Cross Reference
sys/netinet/in_pcb.c
1 /*-
2 * Copyright (c) 1982, 1986, 1991, 1993, 1995
3 * The Regents of the University of California. 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
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 4. Neither the name of the University nor the names of its contributors
14 * may be used to endorse or promote products derived from this software
15 * without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 *
29 * @(#)in_pcb.c 8.4 (Berkeley) 5/24/95
30 * $FreeBSD: releng/5.4/sys/netinet/in_pcb.c 145335 2005-04-20 19:11:07Z cvs2svn $
31 */
32
33 #include "opt_ipsec.h"
34 #include "opt_inet6.h"
35 #include "opt_mac.h"
36
37 #include <sys/param.h>
38 #include <sys/systm.h>
39 #include <sys/mac.h>
40 #include <sys/malloc.h>
41 #include <sys/mbuf.h>
42 #include <sys/domain.h>
43 #include <sys/protosw.h>
44 #include <sys/socket.h>
45 #include <sys/socketvar.h>
46 #include <sys/proc.h>
47 #include <sys/jail.h>
48 #include <sys/kernel.h>
49 #include <sys/sysctl.h>
50
51 #include <vm/uma.h>
52
53 #include <net/if.h>
54 #include <net/if_types.h>
55 #include <net/route.h>
56
57 #include <netinet/in.h>
58 #include <netinet/in_pcb.h>
59 #include <netinet/in_var.h>
60 #include <netinet/ip_var.h>
61 #include <netinet/tcp_var.h>
62 #include <netinet/udp.h>
63 #include <netinet/udp_var.h>
64 #ifdef INET6
65 #include <netinet/ip6.h>
66 #include <netinet6/ip6_var.h>
67 #endif /* INET6 */
68
69 #ifdef IPSEC
70 #include <netinet6/ipsec.h>
71 #include <netkey/key.h>
72 #endif /* IPSEC */
73
74 #ifdef FAST_IPSEC
75 #if defined(IPSEC) || defined(IPSEC_ESP)
76 #error "Bad idea: don't compile with both IPSEC and FAST_IPSEC!"
77 #endif
78
79 #include <netipsec/ipsec.h>
80 #include <netipsec/key.h>
81 #endif /* FAST_IPSEC */
82
83 /*
84 * These configure the range of local port addresses assigned to
85 * "unspecified" outgoing connections/packets/whatever.
86 */
87 int ipport_lowfirstauto = IPPORT_RESERVED - 1; /* 1023 */
88 int ipport_lowlastauto = IPPORT_RESERVEDSTART; /* 600 */
89 int ipport_firstauto = IPPORT_HIFIRSTAUTO; /* 49152 */
90 int ipport_lastauto = IPPORT_HILASTAUTO; /* 65535 */
91 int ipport_hifirstauto = IPPORT_HIFIRSTAUTO; /* 49152 */
92 int ipport_hilastauto = IPPORT_HILASTAUTO; /* 65535 */
93
94 /*
95 * Reserved ports accessible only to root. There are significant
96 * security considerations that must be accounted for when changing these,
97 * but the security benefits can be great. Please be careful.
98 */
99 int ipport_reservedhigh = IPPORT_RESERVED - 1; /* 1023 */
100 int ipport_reservedlow = 0;
101
102 /* Variables dealing with random ephemeral port allocation. */
103 int ipport_randomized = 1; /* user controlled via sysctl */
104 int ipport_randomcps = 10; /* user controlled via sysctl */
105 int ipport_randomtime = 45; /* user controlled via sysctl */
106 int ipport_stoprandom = 0; /* toggled by ipport_tick */
107 int ipport_tcpallocs;
108 int ipport_tcplastcount;
109
110 #define RANGECHK(var, min, max) \
111 if ((var) < (min)) { (var) = (min); } \
112 else if ((var) > (max)) { (var) = (max); }
113
114 static int
115 sysctl_net_ipport_check(SYSCTL_HANDLER_ARGS)
116 {
117 int error;
118
119 error = sysctl_handle_int(oidp, oidp->oid_arg1, oidp->oid_arg2, req);
120 if (error == 0) {
121 RANGECHK(ipport_lowfirstauto, 1, IPPORT_RESERVED - 1);
122 RANGECHK(ipport_lowlastauto, 1, IPPORT_RESERVED - 1);
123 RANGECHK(ipport_firstauto, IPPORT_RESERVED, IPPORT_MAX);
124 RANGECHK(ipport_lastauto, IPPORT_RESERVED, IPPORT_MAX);
125 RANGECHK(ipport_hifirstauto, IPPORT_RESERVED, IPPORT_MAX);
126 RANGECHK(ipport_hilastauto, IPPORT_RESERVED, IPPORT_MAX);
127 }
128 return (error);
129 }
130
131 #undef RANGECHK
132
133 SYSCTL_NODE(_net_inet_ip, IPPROTO_IP, portrange, CTLFLAG_RW, 0, "IP Ports");
134
135 SYSCTL_PROC(_net_inet_ip_portrange, OID_AUTO, lowfirst, CTLTYPE_INT|CTLFLAG_RW,
136 &ipport_lowfirstauto, 0, &sysctl_net_ipport_check, "I", "");
137 SYSCTL_PROC(_net_inet_ip_portrange, OID_AUTO, lowlast, CTLTYPE_INT|CTLFLAG_RW,
138 &ipport_lowlastauto, 0, &sysctl_net_ipport_check, "I", "");
139 SYSCTL_PROC(_net_inet_ip_portrange, OID_AUTO, first, CTLTYPE_INT|CTLFLAG_RW,
140 &ipport_firstauto, 0, &sysctl_net_ipport_check, "I", "");
141 SYSCTL_PROC(_net_inet_ip_portrange, OID_AUTO, last, CTLTYPE_INT|CTLFLAG_RW,
142 &ipport_lastauto, 0, &sysctl_net_ipport_check, "I", "");
143 SYSCTL_PROC(_net_inet_ip_portrange, OID_AUTO, hifirst, CTLTYPE_INT|CTLFLAG_RW,
144 &ipport_hifirstauto, 0, &sysctl_net_ipport_check, "I", "");
145 SYSCTL_PROC(_net_inet_ip_portrange, OID_AUTO, hilast, CTLTYPE_INT|CTLFLAG_RW,
146 &ipport_hilastauto, 0, &sysctl_net_ipport_check, "I", "");
147 SYSCTL_INT(_net_inet_ip_portrange, OID_AUTO, reservedhigh,
148 CTLFLAG_RW|CTLFLAG_SECURE, &ipport_reservedhigh, 0, "");
149 SYSCTL_INT(_net_inet_ip_portrange, OID_AUTO, reservedlow,
150 CTLFLAG_RW|CTLFLAG_SECURE, &ipport_reservedlow, 0, "");
151 SYSCTL_INT(_net_inet_ip_portrange, OID_AUTO, randomized, CTLFLAG_RW,
152 &ipport_randomized, 0, "Enable random port allocation");
153 SYSCTL_INT(_net_inet_ip_portrange, OID_AUTO, randomcps, CTLFLAG_RW,
154 &ipport_randomcps, 0, "Maximum number of random port "
155 "allocations before switching to a sequental one");
156 SYSCTL_INT(_net_inet_ip_portrange, OID_AUTO, randomtime, CTLFLAG_RW,
157 &ipport_randomtime, 0, "Minimum time to keep sequental port "
158 "allocation before switching to a random one");
159
160 /*
161 * in_pcb.c: manage the Protocol Control Blocks.
162 *
163 * NOTE: It is assumed that most of these functions will be called at
164 * splnet(). XXX - There are, unfortunately, a few exceptions to this
165 * rule that should be fixed.
166 */
167
168 /*
169 * Allocate a PCB and associate it with the socket.
170 */
171 int
172 in_pcballoc(so, pcbinfo, type)
173 struct socket *so;
174 struct inpcbinfo *pcbinfo;
175 const char *type;
176 {
177 register struct inpcb *inp;
178 int error;
179
180 INP_INFO_WLOCK_ASSERT(pcbinfo);
181 error = 0;
182 inp = uma_zalloc(pcbinfo->ipi_zone, M_NOWAIT | M_ZERO);
183 if (inp == NULL)
184 return (ENOBUFS);
185 inp->inp_gencnt = ++pcbinfo->ipi_gencnt;
186 inp->inp_pcbinfo = pcbinfo;
187 inp->inp_socket = so;
188 #ifdef MAC
189 error = mac_init_inpcb(inp, M_NOWAIT);
190 if (error != 0)
191 goto out;
192 SOCK_LOCK(so);
193 mac_create_inpcb_from_socket(so, inp);
194 SOCK_UNLOCK(so);
195 #endif
196 #if defined(IPSEC) || defined(FAST_IPSEC)
197 #ifdef FAST_IPSEC
198 error = ipsec_init_policy(so, &inp->inp_sp);
199 #else
200 error = ipsec_init_pcbpolicy(so, &inp->inp_sp);
201 #endif
202 if (error != 0)
203 goto out;
204 #endif /*IPSEC*/
205 #if defined(INET6)
206 if (INP_SOCKAF(so) == AF_INET6) {
207 inp->inp_vflag |= INP_IPV6PROTO;
208 if (ip6_v6only)
209 inp->inp_flags |= IN6P_IPV6_V6ONLY;
210 }
211 #endif
212 LIST_INSERT_HEAD(pcbinfo->listhead, inp, inp_list);
213 pcbinfo->ipi_count++;
214 so->so_pcb = (caddr_t)inp;
215 INP_LOCK_INIT(inp, "inp", type);
216 #ifdef INET6
217 if (ip6_auto_flowlabel)
218 inp->inp_flags |= IN6P_AUTOFLOWLABEL;
219 #endif
220 #if defined(IPSEC) || defined(FAST_IPSEC) || defined(MAC)
221 out:
222 if (error != 0)
223 uma_zfree(pcbinfo->ipi_zone, inp);
224 #endif
225 return (error);
226 }
227
228 int
229 in_pcbbind(inp, nam, cred)
230 register struct inpcb *inp;
231 struct sockaddr *nam;
232 struct ucred *cred;
233 {
234 int anonport, error;
235
236 INP_INFO_WLOCK_ASSERT(inp->inp_pcbinfo);
237 INP_LOCK_ASSERT(inp);
238
239 if (inp->inp_lport != 0 || inp->inp_laddr.s_addr != INADDR_ANY)
240 return (EINVAL);
241 anonport = inp->inp_lport == 0 && (nam == NULL ||
242 ((struct sockaddr_in *)nam)->sin_port == 0);
243 error = in_pcbbind_setup(inp, nam, &inp->inp_laddr.s_addr,
244 &inp->inp_lport, cred);
245 if (error)
246 return (error);
247 if (in_pcbinshash(inp) != 0) {
248 inp->inp_laddr.s_addr = INADDR_ANY;
249 inp->inp_lport = 0;
250 return (EAGAIN);
251 }
252 if (anonport)
253 inp->inp_flags |= INP_ANONPORT;
254 return (0);
255 }
256
257 /*
258 * Set up a bind operation on a PCB, performing port allocation
259 * as required, but do not actually modify the PCB. Callers can
260 * either complete the bind by setting inp_laddr/inp_lport and
261 * calling in_pcbinshash(), or they can just use the resulting
262 * port and address to authorise the sending of a once-off packet.
263 *
264 * On error, the values of *laddrp and *lportp are not changed.
265 */
266 int
267 in_pcbbind_setup(inp, nam, laddrp, lportp, cred)
268 struct inpcb *inp;
269 struct sockaddr *nam;
270 in_addr_t *laddrp;
271 u_short *lportp;
272 struct ucred *cred;
273 {
274 struct socket *so = inp->inp_socket;
275 unsigned short *lastport;
276 struct sockaddr_in *sin;
277 struct inpcbinfo *pcbinfo = inp->inp_pcbinfo;
278 struct in_addr laddr;
279 u_short lport = 0;
280 int wild = 0, reuseport = (so->so_options & SO_REUSEPORT);
281 int error, prison = 0;
282 int dorandom;
283
284 INP_INFO_WLOCK_ASSERT(pcbinfo);
285 INP_LOCK_ASSERT(inp);
286
287 if (TAILQ_EMPTY(&in_ifaddrhead)) /* XXX broken! */
288 return (EADDRNOTAVAIL);
289 laddr.s_addr = *laddrp;
290 if (nam != NULL && laddr.s_addr != INADDR_ANY)
291 return (EINVAL);
292 if ((so->so_options & (SO_REUSEADDR|SO_REUSEPORT)) == 0)
293 wild = 1;
294 if (nam) {
295 sin = (struct sockaddr_in *)nam;
296 if (nam->sa_len != sizeof (*sin))
297 return (EINVAL);
298 #ifdef notdef
299 /*
300 * We should check the family, but old programs
301 * incorrectly fail to initialize it.
302 */
303 if (sin->sin_family != AF_INET)
304 return (EAFNOSUPPORT);
305 #endif
306 if (sin->sin_addr.s_addr != INADDR_ANY)
307 if (prison_ip(cred, 0, &sin->sin_addr.s_addr))
308 return(EINVAL);
309 if (sin->sin_port != *lportp) {
310 /* Don't allow the port to change. */
311 if (*lportp != 0)
312 return (EINVAL);
313 lport = sin->sin_port;
314 }
315 /* NB: lport is left as 0 if the port isn't being changed. */
316 if (IN_MULTICAST(ntohl(sin->sin_addr.s_addr))) {
317 /*
318 * Treat SO_REUSEADDR as SO_REUSEPORT for multicast;
319 * allow complete duplication of binding if
320 * SO_REUSEPORT is set, or if SO_REUSEADDR is set
321 * and a multicast address is bound on both
322 * new and duplicated sockets.
323 */
324 if (so->so_options & SO_REUSEADDR)
325 reuseport = SO_REUSEADDR|SO_REUSEPORT;
326 } else if (sin->sin_addr.s_addr != INADDR_ANY) {
327 sin->sin_port = 0; /* yech... */
328 bzero(&sin->sin_zero, sizeof(sin->sin_zero));
329 if (ifa_ifwithaddr((struct sockaddr *)sin) == 0)
330 return (EADDRNOTAVAIL);
331 }
332 laddr = sin->sin_addr;
333 if (lport) {
334 struct inpcb *t;
335 /* GROSS */
336 if (ntohs(lport) <= ipport_reservedhigh &&
337 ntohs(lport) >= ipport_reservedlow &&
338 suser_cred(cred, SUSER_ALLOWJAIL))
339 return (EACCES);
340 if (jailed(cred))
341 prison = 1;
342 if (so->so_cred->cr_uid != 0 &&
343 !IN_MULTICAST(ntohl(sin->sin_addr.s_addr))) {
344 t = in_pcblookup_local(inp->inp_pcbinfo,
345 sin->sin_addr, lport,
346 prison ? 0 : INPLOOKUP_WILDCARD);
347 /*
348 * XXX
349 * This entire block sorely needs a rewrite.
350 */
351 if (t &&
352 ((t->inp_vflag & INP_TIMEWAIT) == 0) &&
353 (so->so_type != SOCK_STREAM ||
354 ntohl(t->inp_faddr.s_addr) == INADDR_ANY) &&
355 (ntohl(sin->sin_addr.s_addr) != INADDR_ANY ||
356 ntohl(t->inp_laddr.s_addr) != INADDR_ANY ||
357 (t->inp_socket->so_options &
358 SO_REUSEPORT) == 0) &&
359 (so->so_cred->cr_uid !=
360 t->inp_socket->so_cred->cr_uid))
361 return (EADDRINUSE);
362 }
363 if (prison && prison_ip(cred, 0, &sin->sin_addr.s_addr))
364 return (EADDRNOTAVAIL);
365 t = in_pcblookup_local(pcbinfo, sin->sin_addr,
366 lport, prison ? 0 : wild);
367 if (t && (t->inp_vflag & INP_TIMEWAIT)) {
368 if ((reuseport & intotw(t)->tw_so_options) == 0)
369 return (EADDRINUSE);
370 } else
371 if (t &&
372 (reuseport & t->inp_socket->so_options) == 0) {
373 #if defined(INET6)
374 if (ntohl(sin->sin_addr.s_addr) !=
375 INADDR_ANY ||
376 ntohl(t->inp_laddr.s_addr) !=
377 INADDR_ANY ||
378 INP_SOCKAF(so) ==
379 INP_SOCKAF(t->inp_socket))
380 #endif /* defined(INET6) */
381 return (EADDRINUSE);
382 }
383 }
384 }
385 if (*lportp != 0)
386 lport = *lportp;
387 if (lport == 0) {
388 u_short first, last;
389 int count;
390
391 if (laddr.s_addr != INADDR_ANY)
392 if (prison_ip(cred, 0, &laddr.s_addr))
393 return (EINVAL);
394
395 if (inp->inp_flags & INP_HIGHPORT) {
396 first = ipport_hifirstauto; /* sysctl */
397 last = ipport_hilastauto;
398 lastport = &pcbinfo->lasthi;
399 } else if (inp->inp_flags & INP_LOWPORT) {
400 if ((error = suser_cred(cred, SUSER_ALLOWJAIL)) != 0)
401 return error;
402 first = ipport_lowfirstauto; /* 1023 */
403 last = ipport_lowlastauto; /* 600 */
404 lastport = &pcbinfo->lastlow;
405 } else {
406 first = ipport_firstauto; /* sysctl */
407 last = ipport_lastauto;
408 lastport = &pcbinfo->lastport;
409 }
410 /*
411 * For UDP, use random port allocation as long as the user
412 * allows it. For TCP (and as of yet unknown) connections,
413 * use random port allocation only if the user allows it AND
414 * ipport_tick allows it.
415 */
416 if (ipport_randomized &&
417 (!ipport_stoprandom || pcbinfo == &udbinfo))
418 dorandom = 1;
419 else
420 dorandom = 0;
421 /* Make sure to not include UDP packets in the count. */
422 if (pcbinfo != &udbinfo)
423 ipport_tcpallocs++;
424 /*
425 * Simple check to ensure all ports are not used up causing
426 * a deadlock here.
427 *
428 * We split the two cases (up and down) so that the direction
429 * is not being tested on each round of the loop.
430 */
431 if (first > last) {
432 /*
433 * counting down
434 */
435 if (dorandom)
436 *lastport = first -
437 (arc4random() % (first - last));
438 count = first - last;
439
440 do {
441 if (count-- < 0) /* completely used? */
442 return (EADDRNOTAVAIL);
443 --*lastport;
444 if (*lastport > first || *lastport < last)
445 *lastport = first;
446 lport = htons(*lastport);
447 } while (in_pcblookup_local(pcbinfo, laddr, lport,
448 wild));
449 } else {
450 /*
451 * counting up
452 */
453 if (dorandom)
454 *lastport = first +
455 (arc4random() % (last - first));
456 count = last - first;
457
458 do {
459 if (count-- < 0) /* completely used? */
460 return (EADDRNOTAVAIL);
461 ++*lastport;
462 if (*lastport < first || *lastport > last)
463 *lastport = first;
464 lport = htons(*lastport);
465 } while (in_pcblookup_local(pcbinfo, laddr, lport,
466 wild));
467 }
468 }
469 if (prison_ip(cred, 0, &laddr.s_addr))
470 return (EINVAL);
471 *laddrp = laddr.s_addr;
472 *lportp = lport;
473 return (0);
474 }
475
476 /*
477 * Connect from a socket to a specified address.
478 * Both address and port must be specified in argument sin.
479 * If don't have a local address for this socket yet,
480 * then pick one.
481 */
482 int
483 in_pcbconnect(inp, nam, cred)
484 register struct inpcb *inp;
485 struct sockaddr *nam;
486 struct ucred *cred;
487 {
488 u_short lport, fport;
489 in_addr_t laddr, faddr;
490 int anonport, error;
491
492 INP_INFO_WLOCK_ASSERT(inp->inp_pcbinfo);
493 INP_LOCK_ASSERT(inp);
494
495 lport = inp->inp_lport;
496 laddr = inp->inp_laddr.s_addr;
497 anonport = (lport == 0);
498 error = in_pcbconnect_setup(inp, nam, &laddr, &lport, &faddr, &fport,
499 NULL, cred);
500 if (error)
501 return (error);
502
503 /* Do the initial binding of the local address if required. */
504 if (inp->inp_laddr.s_addr == INADDR_ANY && inp->inp_lport == 0) {
505 inp->inp_lport = lport;
506 inp->inp_laddr.s_addr = laddr;
507 if (in_pcbinshash(inp) != 0) {
508 inp->inp_laddr.s_addr = INADDR_ANY;
509 inp->inp_lport = 0;
510 return (EAGAIN);
511 }
512 }
513
514 /* Commit the remaining changes. */
515 inp->inp_lport = lport;
516 inp->inp_laddr.s_addr = laddr;
517 inp->inp_faddr.s_addr = faddr;
518 inp->inp_fport = fport;
519 in_pcbrehash(inp);
520 #ifdef IPSEC
521 if (inp->inp_socket->so_type == SOCK_STREAM)
522 ipsec_pcbconn(inp->inp_sp);
523 #endif
524 if (anonport)
525 inp->inp_flags |= INP_ANONPORT;
526 return (0);
527 }
528
529 /*
530 * Set up for a connect from a socket to the specified address.
531 * On entry, *laddrp and *lportp should contain the current local
532 * address and port for the PCB; these are updated to the values
533 * that should be placed in inp_laddr and inp_lport to complete
534 * the connect.
535 *
536 * On success, *faddrp and *fportp will be set to the remote address
537 * and port. These are not updated in the error case.
538 *
539 * If the operation fails because the connection already exists,
540 * *oinpp will be set to the PCB of that connection so that the
541 * caller can decide to override it. In all other cases, *oinpp
542 * is set to NULL.
543 */
544 int
545 in_pcbconnect_setup(inp, nam, laddrp, lportp, faddrp, fportp, oinpp, cred)
546 register struct inpcb *inp;
547 struct sockaddr *nam;
548 in_addr_t *laddrp;
549 u_short *lportp;
550 in_addr_t *faddrp;
551 u_short *fportp;
552 struct inpcb **oinpp;
553 struct ucred *cred;
554 {
555 struct sockaddr_in *sin = (struct sockaddr_in *)nam;
556 struct in_ifaddr *ia;
557 struct sockaddr_in sa;
558 struct ucred *socred;
559 struct inpcb *oinp;
560 struct in_addr laddr, faddr;
561 u_short lport, fport;
562 int error;
563
564 INP_INFO_WLOCK_ASSERT(inp->inp_pcbinfo);
565 INP_LOCK_ASSERT(inp);
566
567 if (oinpp != NULL)
568 *oinpp = NULL;
569 if (nam->sa_len != sizeof (*sin))
570 return (EINVAL);
571 if (sin->sin_family != AF_INET)
572 return (EAFNOSUPPORT);
573 if (sin->sin_port == 0)
574 return (EADDRNOTAVAIL);
575 laddr.s_addr = *laddrp;
576 lport = *lportp;
577 faddr = sin->sin_addr;
578 fport = sin->sin_port;
579 socred = inp->inp_socket->so_cred;
580 if (laddr.s_addr == INADDR_ANY && jailed(socred)) {
581 bzero(&sa, sizeof(sa));
582 sa.sin_addr.s_addr = htonl(prison_getip(socred));
583 sa.sin_len = sizeof(sa);
584 sa.sin_family = AF_INET;
585 error = in_pcbbind_setup(inp, (struct sockaddr *)&sa,
586 &laddr.s_addr, &lport, cred);
587 if (error)
588 return (error);
589 }
590 if (!TAILQ_EMPTY(&in_ifaddrhead)) {
591 /*
592 * If the destination address is INADDR_ANY,
593 * use the primary local address.
594 * If the supplied address is INADDR_BROADCAST,
595 * and the primary interface supports broadcast,
596 * choose the broadcast address for that interface.
597 */
598 if (faddr.s_addr == INADDR_ANY)
599 faddr = IA_SIN(TAILQ_FIRST(&in_ifaddrhead))->sin_addr;
600 else if (faddr.s_addr == (u_long)INADDR_BROADCAST &&
601 (TAILQ_FIRST(&in_ifaddrhead)->ia_ifp->if_flags &
602 IFF_BROADCAST))
603 faddr = satosin(&TAILQ_FIRST(
604 &in_ifaddrhead)->ia_broadaddr)->sin_addr;
605 }
606 if (laddr.s_addr == INADDR_ANY) {
607 struct route sro;
608
609 bzero(&sro, sizeof(sro));
610 ia = (struct in_ifaddr *)0;
611 /*
612 * If route is known our src addr is taken from the i/f,
613 * else punt.
614 */
615 if ((inp->inp_socket->so_options & SO_DONTROUTE) == 0) {
616 /* Find out route to destination */
617 sro.ro_dst.sa_family = AF_INET;
618 sro.ro_dst.sa_len = sizeof(struct sockaddr_in);
619 ((struct sockaddr_in *)&sro.ro_dst)->sin_addr = faddr;
620 rtalloc_ign(&sro, RTF_CLONING);
621 }
622 /*
623 * If we found a route, use the address
624 * corresponding to the outgoing interface.
625 */
626 if (sro.ro_rt) {
627 ia = ifatoia(sro.ro_rt->rt_ifa);
628 RTFREE(sro.ro_rt);
629 }
630 if (ia == 0) {
631 bzero(&sa, sizeof(sa));
632 sa.sin_addr = faddr;
633 sa.sin_len = sizeof(sa);
634 sa.sin_family = AF_INET;
635
636 ia = ifatoia(ifa_ifwithdstaddr(sintosa(&sa)));
637 if (ia == 0)
638 ia = ifatoia(ifa_ifwithnet(sintosa(&sa)));
639 if (ia == 0)
640 return (ENETUNREACH);
641 }
642 /*
643 * If the destination address is multicast and an outgoing
644 * interface has been set as a multicast option, use the
645 * address of that interface as our source address.
646 */
647 if (IN_MULTICAST(ntohl(faddr.s_addr)) &&
648 inp->inp_moptions != NULL) {
649 struct ip_moptions *imo;
650 struct ifnet *ifp;
651
652 imo = inp->inp_moptions;
653 if (imo->imo_multicast_ifp != NULL) {
654 ifp = imo->imo_multicast_ifp;
655 TAILQ_FOREACH(ia, &in_ifaddrhead, ia_link)
656 if (ia->ia_ifp == ifp)
657 break;
658 if (ia == 0)
659 return (EADDRNOTAVAIL);
660 }
661 }
662 laddr = ia->ia_addr.sin_addr;
663 }
664
665 oinp = in_pcblookup_hash(inp->inp_pcbinfo, faddr, fport, laddr, lport,
666 0, NULL);
667 if (oinp != NULL) {
668 if (oinpp != NULL)
669 *oinpp = oinp;
670 return (EADDRINUSE);
671 }
672 if (lport == 0) {
673 error = in_pcbbind_setup(inp, NULL, &laddr.s_addr, &lport,
674 cred);
675 if (error)
676 return (error);
677 }
678 *laddrp = laddr.s_addr;
679 *lportp = lport;
680 *faddrp = faddr.s_addr;
681 *fportp = fport;
682 return (0);
683 }
684
685 void
686 in_pcbdisconnect(inp)
687 struct inpcb *inp;
688 {
689 INP_LOCK_ASSERT(inp);
690
691 inp->inp_faddr.s_addr = INADDR_ANY;
692 inp->inp_fport = 0;
693 in_pcbrehash(inp);
694 #ifdef IPSEC
695 ipsec_pcbdisconn(inp->inp_sp);
696 #endif
697 if (inp->inp_socket->so_state & SS_NOFDREF)
698 in_pcbdetach(inp);
699 }
700
701 void
702 in_pcbdetach(inp)
703 struct inpcb *inp;
704 {
705 struct socket *so = inp->inp_socket;
706 struct inpcbinfo *ipi = inp->inp_pcbinfo;
707
708 INP_LOCK_ASSERT(inp);
709
710 #if defined(IPSEC) || defined(FAST_IPSEC)
711 ipsec4_delete_pcbpolicy(inp);
712 #endif /*IPSEC*/
713 inp->inp_gencnt = ++ipi->ipi_gencnt;
714 in_pcbremlists(inp);
715 if (so) {
716 ACCEPT_LOCK();
717 SOCK_LOCK(so);
718 so->so_pcb = NULL;
719 sotryfree(so);
720 }
721 if (inp->inp_options)
722 (void)m_free(inp->inp_options);
723 ip_freemoptions(inp->inp_moptions);
724 inp->inp_vflag = 0;
725 INP_LOCK_DESTROY(inp);
726 #ifdef MAC
727 mac_destroy_inpcb(inp);
728 #endif
729 uma_zfree(ipi->ipi_zone, inp);
730 }
731
732 struct sockaddr *
733 in_sockaddr(port, addr_p)
734 in_port_t port;
735 struct in_addr *addr_p;
736 {
737 struct sockaddr_in *sin;
738
739 MALLOC(sin, struct sockaddr_in *, sizeof *sin, M_SONAME,
740 M_WAITOK | M_ZERO);
741 sin->sin_family = AF_INET;
742 sin->sin_len = sizeof(*sin);
743 sin->sin_addr = *addr_p;
744 sin->sin_port = port;
745
746 return (struct sockaddr *)sin;
747 }
748
749 /*
750 * The wrapper function will pass down the pcbinfo for this function to lock.
751 * The socket must have a valid
752 * (i.e., non-nil) PCB, but it should be impossible to get an invalid one
753 * except through a kernel programming error, so it is acceptable to panic
754 * (or in this case trap) if the PCB is invalid. (Actually, we don't trap
755 * because there actually /is/ a programming error somewhere... XXX)
756 */
757 int
758 in_setsockaddr(so, nam, pcbinfo)
759 struct socket *so;
760 struct sockaddr **nam;
761 struct inpcbinfo *pcbinfo;
762 {
763 int s;
764 register struct inpcb *inp;
765 struct in_addr addr;
766 in_port_t port;
767
768 s = splnet();
769 INP_INFO_RLOCK(pcbinfo);
770 inp = sotoinpcb(so);
771 if (!inp) {
772 INP_INFO_RUNLOCK(pcbinfo);
773 splx(s);
774 return ECONNRESET;
775 }
776 INP_LOCK(inp);
777 port = inp->inp_lport;
778 addr = inp->inp_laddr;
779 INP_UNLOCK(inp);
780 INP_INFO_RUNLOCK(pcbinfo);
781 splx(s);
782
783 *nam = in_sockaddr(port, &addr);
784 return 0;
785 }
786
787 /*
788 * The wrapper function will pass down the pcbinfo for this function to lock.
789 */
790 int
791 in_setpeeraddr(so, nam, pcbinfo)
792 struct socket *so;
793 struct sockaddr **nam;
794 struct inpcbinfo *pcbinfo;
795 {
796 int s;
797 register struct inpcb *inp;
798 struct in_addr addr;
799 in_port_t port;
800
801 s = splnet();
802 INP_INFO_RLOCK(pcbinfo);
803 inp = sotoinpcb(so);
804 if (!inp) {
805 INP_INFO_RUNLOCK(pcbinfo);
806 splx(s);
807 return ECONNRESET;
808 }
809 INP_LOCK(inp);
810 port = inp->inp_fport;
811 addr = inp->inp_faddr;
812 INP_UNLOCK(inp);
813 INP_INFO_RUNLOCK(pcbinfo);
814 splx(s);
815
816 *nam = in_sockaddr(port, &addr);
817 return 0;
818 }
819
820 void
821 in_pcbnotifyall(pcbinfo, faddr, errno, notify)
822 struct inpcbinfo *pcbinfo;
823 struct in_addr faddr;
824 int errno;
825 struct inpcb *(*notify)(struct inpcb *, int);
826 {
827 struct inpcb *inp, *ninp;
828 struct inpcbhead *head;
829 int s;
830
831 s = splnet();
832 INP_INFO_WLOCK(pcbinfo);
833 head = pcbinfo->listhead;
834 for (inp = LIST_FIRST(head); inp != NULL; inp = ninp) {
835 INP_LOCK(inp);
836 ninp = LIST_NEXT(inp, inp_list);
837 #ifdef INET6
838 if ((inp->inp_vflag & INP_IPV4) == 0) {
839 INP_UNLOCK(inp);
840 continue;
841 }
842 #endif
843 if (inp->inp_faddr.s_addr != faddr.s_addr ||
844 inp->inp_socket == NULL) {
845 INP_UNLOCK(inp);
846 continue;
847 }
848 if ((*notify)(inp, errno))
849 INP_UNLOCK(inp);
850 }
851 INP_INFO_WUNLOCK(pcbinfo);
852 splx(s);
853 }
854
855 void
856 in_pcbpurgeif0(pcbinfo, ifp)
857 struct inpcbinfo *pcbinfo;
858 struct ifnet *ifp;
859 {
860 struct inpcb *inp;
861 struct ip_moptions *imo;
862 int i, gap;
863
864 /* why no splnet here? XXX */
865 INP_INFO_RLOCK(pcbinfo);
866 LIST_FOREACH(inp, pcbinfo->listhead, inp_list) {
867 INP_LOCK(inp);
868 imo = inp->inp_moptions;
869 if ((inp->inp_vflag & INP_IPV4) &&
870 imo != NULL) {
871 /*
872 * Unselect the outgoing interface if it is being
873 * detached.
874 */
875 if (imo->imo_multicast_ifp == ifp)
876 imo->imo_multicast_ifp = NULL;
877
878 /*
879 * Drop multicast group membership if we joined
880 * through the interface being detached.
881 */
882 for (i = 0, gap = 0; i < imo->imo_num_memberships;
883 i++) {
884 if (imo->imo_membership[i]->inm_ifp == ifp) {
885 in_delmulti(imo->imo_membership[i]);
886 gap++;
887 } else if (gap != 0)
888 imo->imo_membership[i - gap] =
889 imo->imo_membership[i];
890 }
891 imo->imo_num_memberships -= gap;
892 }
893 INP_UNLOCK(inp);
894 }
895 INP_INFO_RUNLOCK(pcbinfo);
896 }
897
898 /*
899 * Lookup a PCB based on the local address and port.
900 */
901 struct inpcb *
902 in_pcblookup_local(pcbinfo, laddr, lport_arg, wild_okay)
903 struct inpcbinfo *pcbinfo;
904 struct in_addr laddr;
905 u_int lport_arg;
906 int wild_okay;
907 {
908 register struct inpcb *inp;
909 int matchwild = 3, wildcard;
910 u_short lport = lport_arg;
911
912 INP_INFO_WLOCK_ASSERT(pcbinfo);
913
914 if (!wild_okay) {
915 struct inpcbhead *head;
916 /*
917 * Look for an unconnected (wildcard foreign addr) PCB that
918 * matches the local address and port we're looking for.
919 */
920 head = &pcbinfo->hashbase[INP_PCBHASH(INADDR_ANY, lport, 0, pcbinfo->hashmask)];
921 LIST_FOREACH(inp, head, inp_hash) {
922 #ifdef INET6
923 if ((inp->inp_vflag & INP_IPV4) == 0)
924 continue;
925 #endif
926 if (inp->inp_faddr.s_addr == INADDR_ANY &&
927 inp->inp_laddr.s_addr == laddr.s_addr &&
928 inp->inp_lport == lport) {
929 /*
930 * Found.
931 */
932 return (inp);
933 }
934 }
935 /*
936 * Not found.
937 */
938 return (NULL);
939 } else {
940 struct inpcbporthead *porthash;
941 struct inpcbport *phd;
942 struct inpcb *match = NULL;
943 /*
944 * Best fit PCB lookup.
945 *
946 * First see if this local port is in use by looking on the
947 * port hash list.
948 */
949 retrylookup:
950 porthash = &pcbinfo->porthashbase[INP_PCBPORTHASH(lport,
951 pcbinfo->porthashmask)];
952 LIST_FOREACH(phd, porthash, phd_hash) {
953 if (phd->phd_port == lport)
954 break;
955 }
956 if (phd != NULL) {
957 /*
958 * Port is in use by one or more PCBs. Look for best
959 * fit.
960 */
961 LIST_FOREACH(inp, &phd->phd_pcblist, inp_portlist) {
962 wildcard = 0;
963 #ifdef INET6
964 if ((inp->inp_vflag & INP_IPV4) == 0)
965 continue;
966 #endif
967 /*
968 * Clean out old time_wait sockets if they
969 * are clogging up needed local ports.
970 */
971 if ((inp->inp_vflag & INP_TIMEWAIT) != 0) {
972 if (tcp_twrecycleable((struct tcptw *)inp->inp_ppcb)) {
973 INP_LOCK(inp);
974 tcp_twclose((struct tcptw *)inp->inp_ppcb, 0);
975 match = NULL;
976 goto retrylookup;
977 }
978 }
979 if (inp->inp_faddr.s_addr != INADDR_ANY)
980 wildcard++;
981 if (inp->inp_laddr.s_addr != INADDR_ANY) {
982 if (laddr.s_addr == INADDR_ANY)
983 wildcard++;
984 else if (inp->inp_laddr.s_addr != laddr.s_addr)
985 continue;
986 } else {
987 if (laddr.s_addr != INADDR_ANY)
988 wildcard++;
989 }
990 if (wildcard < matchwild) {
991 match = inp;
992 matchwild = wildcard;
993 if (matchwild == 0) {
994 break;
995 }
996 }
997 }
998 }
999 return (match);
1000 }
1001 }
1002
1003 /*
1004 * Lookup PCB in hash list.
1005 */
1006 struct inpcb *
1007 in_pcblookup_hash(pcbinfo, faddr, fport_arg, laddr, lport_arg, wildcard,
1008 ifp)
1009 struct inpcbinfo *pcbinfo;
1010 struct in_addr faddr, laddr;
1011 u_int fport_arg, lport_arg;
1012 int wildcard;
1013 struct ifnet *ifp;
1014 {
1015 struct inpcbhead *head;
1016 register struct inpcb *inp;
1017 u_short fport = fport_arg, lport = lport_arg;
1018
1019 INP_INFO_RLOCK_ASSERT(pcbinfo);
1020 /*
1021 * First look for an exact match.
1022 */
1023 head = &pcbinfo->hashbase[INP_PCBHASH(faddr.s_addr, lport, fport, pcbinfo->hashmask)];
1024 LIST_FOREACH(inp, head, inp_hash) {
1025 #ifdef INET6
1026 if ((inp->inp_vflag & INP_IPV4) == 0)
1027 continue;
1028 #endif
1029 if (inp->inp_faddr.s_addr == faddr.s_addr &&
1030 inp->inp_laddr.s_addr == laddr.s_addr &&
1031 inp->inp_fport == fport &&
1032 inp->inp_lport == lport) {
1033 /*
1034 * Found.
1035 */
1036 return (inp);
1037 }
1038 }
1039 if (wildcard) {
1040 struct inpcb *local_wild = NULL;
1041 #if defined(INET6)
1042 struct inpcb *local_wild_mapped = NULL;
1043 #endif /* defined(INET6) */
1044
1045 head = &pcbinfo->hashbase[INP_PCBHASH(INADDR_ANY, lport, 0, pcbinfo->hashmask)];
1046 LIST_FOREACH(inp, head, inp_hash) {
1047 #ifdef INET6
1048 if ((inp->inp_vflag & INP_IPV4) == 0)
1049 continue;
1050 #endif
1051 if (inp->inp_faddr.s_addr == INADDR_ANY &&
1052 inp->inp_lport == lport) {
1053 if (ifp && ifp->if_type == IFT_FAITH &&
1054 (inp->inp_flags & INP_FAITH) == 0)
1055 continue;
1056 if (inp->inp_laddr.s_addr == laddr.s_addr)
1057 return (inp);
1058 else if (inp->inp_laddr.s_addr == INADDR_ANY) {
1059 #if defined(INET6)
1060 if (INP_CHECK_SOCKAF(inp->inp_socket,
1061 AF_INET6))
1062 local_wild_mapped = inp;
1063 else
1064 #endif /* defined(INET6) */
1065 local_wild = inp;
1066 }
1067 }
1068 }
1069 #if defined(INET6)
1070 if (local_wild == NULL)
1071 return (local_wild_mapped);
1072 #endif /* defined(INET6) */
1073 return (local_wild);
1074 }
1075
1076 /*
1077 * Not found.
1078 */
1079 return (NULL);
1080 }
1081
1082 /*
1083 * Insert PCB onto various hash lists.
1084 */
1085 int
1086 in_pcbinshash(inp)
1087 struct inpcb *inp;
1088 {
1089 struct inpcbhead *pcbhash;
1090 struct inpcbporthead *pcbporthash;
1091 struct inpcbinfo *pcbinfo = inp->inp_pcbinfo;
1092 struct inpcbport *phd;
1093 u_int32_t hashkey_faddr;
1094
1095 INP_INFO_WLOCK_ASSERT(pcbinfo);
1096 #ifdef INET6
1097 if (inp->inp_vflag & INP_IPV6)
1098 hashkey_faddr = inp->in6p_faddr.s6_addr32[3] /* XXX */;
1099 else
1100 #endif /* INET6 */
1101 hashkey_faddr = inp->inp_faddr.s_addr;
1102
1103 pcbhash = &pcbinfo->hashbase[INP_PCBHASH(hashkey_faddr,
1104 inp->inp_lport, inp->inp_fport, pcbinfo->hashmask)];
1105
1106 pcbporthash = &pcbinfo->porthashbase[INP_PCBPORTHASH(inp->inp_lport,
1107 pcbinfo->porthashmask)];
1108
1109 /*
1110 * Go through port list and look for a head for this lport.
1111 */
1112 LIST_FOREACH(phd, pcbporthash, phd_hash) {
1113 if (phd->phd_port == inp->inp_lport)
1114 break;
1115 }
1116 /*
1117 * If none exists, malloc one and tack it on.
1118 */
1119 if (phd == NULL) {
1120 MALLOC(phd, struct inpcbport *, sizeof(struct inpcbport), M_PCB, M_NOWAIT);
1121 if (phd == NULL) {
1122 return (ENOBUFS); /* XXX */
1123 }
1124 phd->phd_port = inp->inp_lport;
1125 LIST_INIT(&phd->phd_pcblist);
1126 LIST_INSERT_HEAD(pcbporthash, phd, phd_hash);
1127 }
1128 inp->inp_phd = phd;
1129 LIST_INSERT_HEAD(&phd->phd_pcblist, inp, inp_portlist);
1130 LIST_INSERT_HEAD(pcbhash, inp, inp_hash);
1131 return (0);
1132 }
1133
1134 /*
1135 * Move PCB to the proper hash bucket when { faddr, fport } have been
1136 * changed. NOTE: This does not handle the case of the lport changing (the
1137 * hashed port list would have to be updated as well), so the lport must
1138 * not change after in_pcbinshash() has been called.
1139 */
1140 void
1141 in_pcbrehash(inp)
1142 struct inpcb *inp;
1143 {
1144 struct inpcbinfo *pcbinfo = inp->inp_pcbinfo;
1145 struct inpcbhead *head;
1146 u_int32_t hashkey_faddr;
1147
1148 INP_INFO_WLOCK_ASSERT(pcbinfo);
1149 INP_LOCK_ASSERT(inp);
1150 #ifdef INET6
1151 if (inp->inp_vflag & INP_IPV6)
1152 hashkey_faddr = inp->in6p_faddr.s6_addr32[3] /* XXX */;
1153 else
1154 #endif /* INET6 */
1155 hashkey_faddr = inp->inp_faddr.s_addr;
1156
1157 head = &pcbinfo->hashbase[INP_PCBHASH(hashkey_faddr,
1158 inp->inp_lport, inp->inp_fport, pcbinfo->hashmask)];
1159
1160 LIST_REMOVE(inp, inp_hash);
1161 LIST_INSERT_HEAD(head, inp, inp_hash);
1162 }
1163
1164 /*
1165 * Remove PCB from various lists.
1166 */
1167 void
1168 in_pcbremlists(inp)
1169 struct inpcb *inp;
1170 {
1171 struct inpcbinfo *pcbinfo = inp->inp_pcbinfo;
1172
1173 INP_INFO_WLOCK_ASSERT(pcbinfo);
1174 INP_LOCK_ASSERT(inp);
1175
1176 inp->inp_gencnt = ++pcbinfo->ipi_gencnt;
1177 if (inp->inp_lport) {
1178 struct inpcbport *phd = inp->inp_phd;
1179
1180 LIST_REMOVE(inp, inp_hash);
1181 LIST_REMOVE(inp, inp_portlist);
1182 if (LIST_FIRST(&phd->phd_pcblist) == NULL) {
1183 LIST_REMOVE(phd, phd_hash);
1184 free(phd, M_PCB);
1185 }
1186 }
1187 LIST_REMOVE(inp, inp_list);
1188 pcbinfo->ipi_count--;
1189 }
1190
1191 /*
1192 * A set label operation has occurred at the socket layer, propagate the
1193 * label change into the in_pcb for the socket.
1194 */
1195 void
1196 in_pcbsosetlabel(so)
1197 struct socket *so;
1198 {
1199 #ifdef MAC
1200 struct inpcb *inp;
1201
1202 inp = (struct inpcb *)so->so_pcb;
1203 INP_LOCK(inp);
1204 SOCK_LOCK(so);
1205 mac_inpcb_sosetlabel(so, inp);
1206 SOCK_UNLOCK(so);
1207 INP_UNLOCK(inp);
1208 #endif
1209 }
1210
1211 /*
1212 * ipport_tick runs once per second, determining if random port
1213 * allocation should be continued. If more than ipport_randomcps
1214 * ports have been allocated in the last second, then we return to
1215 * sequential port allocation. We return to random allocation only
1216 * once we drop below ipport_randomcps for at least ipport_randomtime
1217 * seconds.
1218 */
1219
1220 void
1221 ipport_tick(xtp)
1222 void *xtp;
1223 {
1224 if (ipport_tcpallocs > ipport_tcplastcount + ipport_randomcps) {
1225 ipport_stoprandom = ipport_randomtime;
1226 } else {
1227 if (ipport_stoprandom > 0)
1228 ipport_stoprandom--;
1229 }
1230 ipport_tcplastcount = ipport_tcpallocs;
1231 callout_reset(&ipport_tick_callout, hz, ipport_tick, NULL);
1232 }
Cache object: f7e26c5ebb4591d9ee154f1f5cf80b85
|