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 * 3. All advertising materials mentioning features or use of this software 14 * must display the following acknowledgement: 15 * This product includes software developed by the University of 16 * California, Berkeley and its contributors. 17 * 4. Neither the name of the University nor the names of its contributors 18 * may be used to endorse or promote products derived from this software 19 * without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 * 33 * @(#)in_pcb.c 8.4 (Berkeley) 5/24/95 34 * $FreeBSD: src/sys/netinet/in_pcb.c,v 1.59.2.26 2003/01/24 05:11:33 sam Exp $ 35 * $DragonFly: src/sys/netinet/in_pcb.c,v 1.8 2003/08/23 11:18:00 rob Exp $ 36 */ 37 38 #include "opt_ipsec.h" 39 #include "opt_inet6.h" 40 41 #include <sys/param.h> 42 #include <sys/systm.h> 43 #include <sys/malloc.h> 44 #include <sys/mbuf.h> 45 #include <sys/domain.h> 46 #include <sys/protosw.h> 47 #include <sys/socket.h> 48 #include <sys/socketvar.h> 49 #include <sys/proc.h> 50 #include <sys/jail.h> 51 #include <sys/kernel.h> 52 #include <sys/sysctl.h> 53 54 #include <machine/limits.h> 55 56 #include <vm/vm_zone.h> 57 58 #include <net/if.h> 59 #include <net/if_types.h> 60 #include <net/route.h> 61 62 #include <netinet/in.h> 63 #include <netinet/in_pcb.h> 64 #include <netinet/in_var.h> 65 #include <netinet/ip_var.h> 66 #ifdef INET6 67 #include <netinet/ip6.h> 68 #include <netinet6/ip6_var.h> 69 #endif /* INET6 */ 70 71 #ifdef IPSEC 72 #include <netinet6/ipsec.h> 73 #include <netproto/key/key.h> 74 #endif /* IPSEC */ 75 76 #ifdef FAST_IPSEC 77 #if defined(IPSEC) || defined(IPSEC_ESP) 78 #error "Bad idea: don't compile with both IPSEC and FAST_IPSEC!" 79 #endif 80 81 #include <netipsec/ipsec.h> 82 #include <netipsec/key.h> 83 #define IPSEC 84 #endif /* FAST_IPSEC */ 85 86 struct in_addr zeroin_addr; 87 88 /* 89 * These configure the range of local port addresses assigned to 90 * "unspecified" outgoing connections/packets/whatever. 91 */ 92 int ipport_lowfirstauto = IPPORT_RESERVED - 1; /* 1023 */ 93 int ipport_lowlastauto = IPPORT_RESERVEDSTART; /* 600 */ 94 int ipport_firstauto = IPPORT_RESERVED; /* 1024 */ 95 int ipport_lastauto = IPPORT_USERRESERVED; /* 5000 */ 96 int ipport_hifirstauto = IPPORT_HIFIRSTAUTO; /* 49152 */ 97 int ipport_hilastauto = IPPORT_HILASTAUTO; /* 65535 */ 98 99 #define RANGECHK(var, min, max) \ 100 if ((var) < (min)) { (var) = (min); } \ 101 else if ((var) > (max)) { (var) = (max); } 102 103 static int 104 sysctl_net_ipport_check(SYSCTL_HANDLER_ARGS) 105 { 106 int error = sysctl_handle_int(oidp, 107 oidp->oid_arg1, oidp->oid_arg2, req); 108 if (!error) { 109 RANGECHK(ipport_lowfirstauto, 1, IPPORT_RESERVED - 1); 110 RANGECHK(ipport_lowlastauto, 1, IPPORT_RESERVED - 1); 111 RANGECHK(ipport_firstauto, IPPORT_RESERVED, USHRT_MAX); 112 RANGECHK(ipport_lastauto, IPPORT_RESERVED, USHRT_MAX); 113 RANGECHK(ipport_hifirstauto, IPPORT_RESERVED, USHRT_MAX); 114 RANGECHK(ipport_hilastauto, IPPORT_RESERVED, USHRT_MAX); 115 } 116 return error; 117 } 118 119 #undef RANGECHK 120 121 SYSCTL_NODE(_net_inet_ip, IPPROTO_IP, portrange, CTLFLAG_RW, 0, "IP Ports"); 122 123 SYSCTL_PROC(_net_inet_ip_portrange, OID_AUTO, lowfirst, CTLTYPE_INT|CTLFLAG_RW, 124 &ipport_lowfirstauto, 0, &sysctl_net_ipport_check, "I", ""); 125 SYSCTL_PROC(_net_inet_ip_portrange, OID_AUTO, lowlast, CTLTYPE_INT|CTLFLAG_RW, 126 &ipport_lowlastauto, 0, &sysctl_net_ipport_check, "I", ""); 127 SYSCTL_PROC(_net_inet_ip_portrange, OID_AUTO, first, CTLTYPE_INT|CTLFLAG_RW, 128 &ipport_firstauto, 0, &sysctl_net_ipport_check, "I", ""); 129 SYSCTL_PROC(_net_inet_ip_portrange, OID_AUTO, last, CTLTYPE_INT|CTLFLAG_RW, 130 &ipport_lastauto, 0, &sysctl_net_ipport_check, "I", ""); 131 SYSCTL_PROC(_net_inet_ip_portrange, OID_AUTO, hifirst, CTLTYPE_INT|CTLFLAG_RW, 132 &ipport_hifirstauto, 0, &sysctl_net_ipport_check, "I", ""); 133 SYSCTL_PROC(_net_inet_ip_portrange, OID_AUTO, hilast, CTLTYPE_INT|CTLFLAG_RW, 134 &ipport_hilastauto, 0, &sysctl_net_ipport_check, "I", ""); 135 136 /* 137 * in_pcb.c: manage the Protocol Control Blocks. 138 * 139 * NOTE: It is assumed that most of these functions will be called at 140 * splnet(). XXX - There are, unfortunately, a few exceptions to this 141 * rule that should be fixed. 142 */ 143 144 /* 145 * Allocate a PCB and associate it with the socket. 146 */ 147 int 148 in_pcballoc(struct socket *so, struct inpcbinfo *pcbinfo, struct thread *td) 149 { 150 struct inpcb *inp; 151 #ifdef IPSEC 152 int error; 153 #endif 154 155 inp = zalloc(pcbinfo->ipi_zone); 156 if (inp == NULL) 157 return (ENOBUFS); 158 bzero((caddr_t)inp, sizeof(*inp)); 159 inp->inp_gencnt = ++pcbinfo->ipi_gencnt; 160 inp->inp_pcbinfo = pcbinfo; 161 inp->inp_socket = so; 162 #ifdef IPSEC 163 error = ipsec_init_policy(so, &inp->inp_sp); 164 if (error != 0) { 165 zfree(pcbinfo->ipi_zone, inp); 166 return error; 167 } 168 #endif /*IPSEC*/ 169 #if defined(INET6) 170 if (INP_SOCKAF(so) == AF_INET6 && ip6_v6only) 171 inp->inp_flags |= IN6P_IPV6_V6ONLY; 172 #endif 173 LIST_INSERT_HEAD(pcbinfo->listhead, inp, inp_list); 174 pcbinfo->ipi_count++; 175 so->so_pcb = (caddr_t)inp; 176 #ifdef INET6 177 if (ip6_auto_flowlabel) 178 inp->inp_flags |= IN6P_AUTOFLOWLABEL; 179 #endif 180 return (0); 181 } 182 183 int 184 in_pcbbind(struct inpcb *inp, struct sockaddr *nam, struct thread *td) 185 { 186 struct socket *so = inp->inp_socket; 187 struct proc *p = td->td_proc; 188 unsigned short *lastport; 189 struct sockaddr_in *sin; 190 struct inpcbinfo *pcbinfo = inp->inp_pcbinfo; 191 u_short lport = 0; 192 int wild = 0, reuseport = (so->so_options & SO_REUSEPORT); 193 int error, prison = 0; 194 195 KKASSERT(p); 196 197 if (TAILQ_EMPTY(&in_ifaddrhead)) /* XXX broken! */ 198 return (EADDRNOTAVAIL); 199 if (inp->inp_lport || inp->inp_laddr.s_addr != INADDR_ANY) 200 return (EINVAL); 201 if ((so->so_options & (SO_REUSEADDR|SO_REUSEPORT)) == 0) 202 wild = 1; 203 if (nam) { 204 sin = (struct sockaddr_in *)nam; 205 if (nam->sa_len != sizeof (*sin)) 206 return (EINVAL); 207 #ifdef notdef 208 /* 209 * We should check the family, but old programs 210 * incorrectly fail to initialize it. 211 */ 212 if (sin->sin_family != AF_INET) 213 return (EAFNOSUPPORT); 214 #endif 215 if (sin->sin_addr.s_addr != INADDR_ANY) 216 if (prison_ip(td, 0, &sin->sin_addr.s_addr)) 217 return(EINVAL); 218 lport = sin->sin_port; 219 if (IN_MULTICAST(ntohl(sin->sin_addr.s_addr))) { 220 /* 221 * Treat SO_REUSEADDR as SO_REUSEPORT for multicast; 222 * allow complete duplication of binding if 223 * SO_REUSEPORT is set, or if SO_REUSEADDR is set 224 * and a multicast address is bound on both 225 * new and duplicated sockets. 226 */ 227 if (so->so_options & SO_REUSEADDR) 228 reuseport = SO_REUSEADDR|SO_REUSEPORT; 229 } else if (sin->sin_addr.s_addr != INADDR_ANY) { 230 sin->sin_port = 0; /* yech... */ 231 bzero(&sin->sin_zero, sizeof(sin->sin_zero)); 232 if (ifa_ifwithaddr((struct sockaddr *)sin) == 0) 233 return (EADDRNOTAVAIL); 234 } 235 if (lport) { 236 struct inpcb *t; 237 238 /* GROSS */ 239 if (ntohs(lport) < IPPORT_RESERVED && p && 240 suser_cred(p->p_ucred, PRISON_ROOT)) 241 return (EACCES); 242 if (p && p->p_ucred->cr_prison) 243 prison = 1; 244 if (so->so_cred->cr_uid != 0 && 245 !IN_MULTICAST(ntohl(sin->sin_addr.s_addr))) { 246 t = in_pcblookup_local(inp->inp_pcbinfo, 247 sin->sin_addr, lport, 248 prison ? 0 : INPLOOKUP_WILDCARD); 249 if (t && 250 (ntohl(sin->sin_addr.s_addr) != INADDR_ANY || 251 ntohl(t->inp_laddr.s_addr) != INADDR_ANY || 252 (t->inp_socket->so_options & 253 SO_REUSEPORT) == 0) && 254 (so->so_cred->cr_uid != 255 t->inp_socket->so_cred->cr_uid)) { 256 #if defined(INET6) 257 if (ntohl(sin->sin_addr.s_addr) != 258 INADDR_ANY || 259 ntohl(t->inp_laddr.s_addr) != 260 INADDR_ANY || 261 INP_SOCKAF(so) == 262 INP_SOCKAF(t->inp_socket)) 263 #endif /* defined(INET6) */ 264 return (EADDRINUSE); 265 } 266 } 267 if (prison && 268 prison_ip(td, 0, &sin->sin_addr.s_addr)) 269 return (EADDRNOTAVAIL); 270 t = in_pcblookup_local(pcbinfo, sin->sin_addr, 271 lport, prison ? 0 : wild); 272 if (t && 273 (reuseport & t->inp_socket->so_options) == 0) { 274 #if defined(INET6) 275 if (ntohl(sin->sin_addr.s_addr) != 276 INADDR_ANY || 277 ntohl(t->inp_laddr.s_addr) != 278 INADDR_ANY || 279 INP_SOCKAF(so) == 280 INP_SOCKAF(t->inp_socket)) 281 #endif /* defined(INET6) */ 282 return (EADDRINUSE); 283 } 284 } 285 inp->inp_laddr = sin->sin_addr; 286 } 287 if (lport == 0) { 288 ushort first, last; 289 int count; 290 291 if (inp->inp_laddr.s_addr != INADDR_ANY) 292 if (prison_ip(td, 0, &inp->inp_laddr.s_addr )) { 293 inp->inp_laddr.s_addr = INADDR_ANY; 294 return (EINVAL); 295 } 296 inp->inp_flags |= INP_ANONPORT; 297 298 if (inp->inp_flags & INP_HIGHPORT) { 299 first = ipport_hifirstauto; /* sysctl */ 300 last = ipport_hilastauto; 301 lastport = &pcbinfo->lasthi; 302 } else if (inp->inp_flags & INP_LOWPORT) { 303 if (p && (error = suser_cred(p->p_ucred, PRISON_ROOT))) { 304 inp->inp_laddr.s_addr = INADDR_ANY; 305 return error; 306 } 307 first = ipport_lowfirstauto; /* 1023 */ 308 last = ipport_lowlastauto; /* 600 */ 309 lastport = &pcbinfo->lastlow; 310 } else { 311 first = ipport_firstauto; /* sysctl */ 312 last = ipport_lastauto; 313 lastport = &pcbinfo->lastport; 314 } 315 /* 316 * Simple check to ensure all ports are not used up causing 317 * a deadlock here. 318 * 319 * We split the two cases (up and down) so that the direction 320 * is not being tested on each round of the loop. 321 */ 322 if (first > last) { 323 /* 324 * counting down 325 */ 326 count = first - last; 327 328 do { 329 if (count-- < 0) { /* completely used? */ 330 inp->inp_laddr.s_addr = INADDR_ANY; 331 return (EADDRNOTAVAIL); 332 } 333 --*lastport; 334 if (*lastport > first || *lastport < last) 335 *lastport = first; 336 lport = htons(*lastport); 337 } while (in_pcblookup_local(pcbinfo, 338 inp->inp_laddr, lport, wild)); 339 } else { 340 /* 341 * counting up 342 */ 343 count = last - first; 344 345 do { 346 if (count-- < 0) { /* completely used? */ 347 inp->inp_laddr.s_addr = INADDR_ANY; 348 return (EADDRNOTAVAIL); 349 } 350 ++*lastport; 351 if (*lastport < first || *lastport > last) 352 *lastport = first; 353 lport = htons(*lastport); 354 } while (in_pcblookup_local(pcbinfo, 355 inp->inp_laddr, lport, wild)); 356 } 357 } 358 inp->inp_lport = lport; 359 if (prison_ip(td, 0, &inp->inp_laddr.s_addr)) { 360 inp->inp_laddr.s_addr = INADDR_ANY; 361 inp->inp_lport = 0; 362 return (EINVAL); 363 } 364 if (in_pcbinshash(inp) != 0) { 365 inp->inp_laddr.s_addr = INADDR_ANY; 366 inp->inp_lport = 0; 367 return (EAGAIN); 368 } 369 return (0); 370 } 371 372 /* 373 * Transform old in_pcbconnect() into an inner subroutine for new 374 * in_pcbconnect(): Do some validity-checking on the remote 375 * address (in mbuf 'nam') and then determine local host address 376 * (i.e., which interface) to use to access that remote host. 377 * 378 * This preserves definition of in_pcbconnect(), while supporting a 379 * slightly different version for T/TCP. (This is more than 380 * a bit of a kludge, but cleaning up the internal interfaces would 381 * have forced minor changes in every protocol). 382 */ 383 384 int 385 in_pcbladdr(inp, nam, plocal_sin) 386 struct inpcb *inp; 387 struct sockaddr *nam; 388 struct sockaddr_in **plocal_sin; 389 { 390 struct in_ifaddr *ia; 391 struct sockaddr_in *sin = (struct sockaddr_in *)nam; 392 393 if (nam->sa_len != sizeof (*sin)) 394 return (EINVAL); 395 if (sin->sin_family != AF_INET) 396 return (EAFNOSUPPORT); 397 if (sin->sin_port == 0) 398 return (EADDRNOTAVAIL); 399 if (!TAILQ_EMPTY(&in_ifaddrhead)) { 400 /* 401 * If the destination address is INADDR_ANY, 402 * use the primary local address. 403 * If the supplied address is INADDR_BROADCAST, 404 * and the primary interface supports broadcast, 405 * choose the broadcast address for that interface. 406 */ 407 if (sin->sin_addr.s_addr == INADDR_ANY) 408 sin->sin_addr = IA_SIN(TAILQ_FIRST(&in_ifaddrhead))->sin_addr; 409 else if (sin->sin_addr.s_addr == (u_long)INADDR_BROADCAST && 410 (TAILQ_FIRST(&in_ifaddrhead)->ia_ifp->if_flags & IFF_BROADCAST)) 411 sin->sin_addr = satosin(&TAILQ_FIRST(&in_ifaddrhead)->ia_broadaddr)->sin_addr; 412 } 413 if (inp->inp_laddr.s_addr == INADDR_ANY) { 414 struct route *ro; 415 416 ia = (struct in_ifaddr *)0; 417 /* 418 * If route is known or can be allocated now, 419 * our src addr is taken from the i/f, else punt. 420 * Note that we should check the address family of the cached 421 * destination, in case of sharing the cache with IPv6. 422 */ 423 ro = &inp->inp_route; 424 if (ro->ro_rt && 425 (ro->ro_dst.sa_family != AF_INET || 426 satosin(&ro->ro_dst)->sin_addr.s_addr != 427 sin->sin_addr.s_addr || 428 inp->inp_socket->so_options & SO_DONTROUTE)) { 429 RTFREE(ro->ro_rt); 430 ro->ro_rt = (struct rtentry *)0; 431 } 432 if ((inp->inp_socket->so_options & SO_DONTROUTE) == 0 && /*XXX*/ 433 (ro->ro_rt == (struct rtentry *)0 || 434 ro->ro_rt->rt_ifp == (struct ifnet *)0)) { 435 /* No route yet, so try to acquire one */ 436 bzero(&ro->ro_dst, sizeof(struct sockaddr_in)); 437 ro->ro_dst.sa_family = AF_INET; 438 ro->ro_dst.sa_len = sizeof(struct sockaddr_in); 439 ((struct sockaddr_in *) &ro->ro_dst)->sin_addr = 440 sin->sin_addr; 441 rtalloc(ro); 442 } 443 /* 444 * If we found a route, use the address 445 * corresponding to the outgoing interface 446 * unless it is the loopback (in case a route 447 * to our address on another net goes to loopback). 448 */ 449 if (ro->ro_rt && !(ro->ro_rt->rt_ifp->if_flags & IFF_LOOPBACK)) 450 ia = ifatoia(ro->ro_rt->rt_ifa); 451 if (ia == 0) { 452 u_short fport = sin->sin_port; 453 454 sin->sin_port = 0; 455 ia = ifatoia(ifa_ifwithdstaddr(sintosa(sin))); 456 if (ia == 0) 457 ia = ifatoia(ifa_ifwithnet(sintosa(sin))); 458 sin->sin_port = fport; 459 if (ia == 0) 460 ia = TAILQ_FIRST(&in_ifaddrhead); 461 if (ia == 0) 462 return (EADDRNOTAVAIL); 463 } 464 /* 465 * If the destination address is multicast and an outgoing 466 * interface has been set as a multicast option, use the 467 * address of that interface as our source address. 468 */ 469 if (IN_MULTICAST(ntohl(sin->sin_addr.s_addr)) && 470 inp->inp_moptions != NULL) { 471 struct ip_moptions *imo; 472 struct ifnet *ifp; 473 474 imo = inp->inp_moptions; 475 if (imo->imo_multicast_ifp != NULL) { 476 ifp = imo->imo_multicast_ifp; 477 TAILQ_FOREACH(ia, &in_ifaddrhead, ia_link) 478 if (ia->ia_ifp == ifp) 479 break; 480 if (ia == 0) 481 return (EADDRNOTAVAIL); 482 } 483 } 484 /* 485 * Don't do pcblookup call here; return interface in plocal_sin 486 * and exit to caller, that will do the lookup. 487 */ 488 *plocal_sin = &ia->ia_addr; 489 490 } 491 return(0); 492 } 493 494 /* 495 * Outer subroutine: 496 * Connect from a socket to a specified address. 497 * Both address and port must be specified in argument sin. 498 * If don't have a local address for this socket yet, 499 * then pick one. 500 */ 501 int 502 in_pcbconnect(struct inpcb *inp, struct sockaddr *nam, struct thread *td) 503 { 504 struct sockaddr_in *ifaddr; 505 struct sockaddr_in *sin = (struct sockaddr_in *)nam; 506 struct sockaddr_in sa; 507 struct ucred *cr = td->td_proc ? td->td_proc->p_ucred : NULL; 508 int error; 509 510 if (inp->inp_laddr.s_addr == INADDR_ANY && cr && cr->cr_prison != NULL) { 511 bzero(&sa, sizeof (sa)); 512 sa.sin_addr.s_addr = htonl(cr->cr_prison->pr_ip); 513 sa.sin_len=sizeof (sa); 514 sa.sin_family = AF_INET; 515 error = in_pcbbind(inp, (struct sockaddr *)&sa, td); 516 if (error) 517 return (error); 518 } 519 /* 520 * Call inner routine, to assign local interface address. 521 */ 522 if ((error = in_pcbladdr(inp, nam, &ifaddr)) != 0) 523 return(error); 524 525 if (in_pcblookup_hash(inp->inp_pcbinfo, sin->sin_addr, sin->sin_port, 526 inp->inp_laddr.s_addr ? inp->inp_laddr : ifaddr->sin_addr, 527 inp->inp_lport, 0, NULL) != NULL) { 528 return (EADDRINUSE); 529 } 530 if (inp->inp_laddr.s_addr == INADDR_ANY) { 531 if (inp->inp_lport == 0) { 532 error = in_pcbbind(inp, (struct sockaddr *)0, td); 533 if (error) 534 return (error); 535 } 536 inp->inp_laddr = ifaddr->sin_addr; 537 } 538 inp->inp_faddr = sin->sin_addr; 539 inp->inp_fport = sin->sin_port; 540 in_pcbrehash(inp); 541 return (0); 542 } 543 544 void 545 in_pcbdisconnect(inp) 546 struct inpcb *inp; 547 { 548 549 inp->inp_faddr.s_addr = INADDR_ANY; 550 inp->inp_fport = 0; 551 in_pcbrehash(inp); 552 if (inp->inp_socket->so_state & SS_NOFDREF) 553 in_pcbdetach(inp); 554 } 555 556 void 557 in_pcbdetach(inp) 558 struct inpcb *inp; 559 { 560 struct socket *so = inp->inp_socket; 561 struct inpcbinfo *ipi = inp->inp_pcbinfo; 562 563 #ifdef IPSEC 564 ipsec4_delete_pcbpolicy(inp); 565 #endif /*IPSEC*/ 566 inp->inp_gencnt = ++ipi->ipi_gencnt; 567 in_pcbremlists(inp); 568 so->so_pcb = 0; 569 sofree(so); 570 if (inp->inp_options) 571 (void)m_free(inp->inp_options); 572 if (inp->inp_route.ro_rt) 573 rtfree(inp->inp_route.ro_rt); 574 ip_freemoptions(inp->inp_moptions); 575 inp->inp_vflag = 0; 576 zfree(ipi->ipi_zone, inp); 577 } 578 579 /* 580 * The calling convention of in_setsockaddr() and in_setpeeraddr() was 581 * modified to match the pru_sockaddr() and pru_peeraddr() entry points 582 * in struct pr_usrreqs, so that protocols can just reference then directly 583 * without the need for a wrapper function. The socket must have a valid 584 * (i.e., non-nil) PCB, but it should be impossible to get an invalid one 585 * except through a kernel programming error, so it is acceptable to panic 586 * (or in this case trap) if the PCB is invalid. (Actually, we don't trap 587 * because there actually /is/ a programming error somewhere... XXX) 588 */ 589 int 590 in_setsockaddr(so, nam) 591 struct socket *so; 592 struct sockaddr **nam; 593 { 594 int s; 595 struct inpcb *inp; 596 struct sockaddr_in *sin; 597 598 /* 599 * Do the malloc first in case it blocks. 600 */ 601 MALLOC(sin, struct sockaddr_in *, sizeof *sin, M_SONAME, 602 M_WAITOK | M_ZERO); 603 sin->sin_family = AF_INET; 604 sin->sin_len = sizeof(*sin); 605 606 s = splnet(); 607 inp = sotoinpcb(so); 608 if (!inp) { 609 splx(s); 610 free(sin, M_SONAME); 611 return ECONNRESET; 612 } 613 sin->sin_port = inp->inp_lport; 614 sin->sin_addr = inp->inp_laddr; 615 splx(s); 616 617 *nam = (struct sockaddr *)sin; 618 return 0; 619 } 620 621 int 622 in_setpeeraddr(so, nam) 623 struct socket *so; 624 struct sockaddr **nam; 625 { 626 int s; 627 struct inpcb *inp; 628 struct sockaddr_in *sin; 629 630 /* 631 * Do the malloc first in case it blocks. 632 */ 633 MALLOC(sin, struct sockaddr_in *, sizeof *sin, M_SONAME, 634 M_WAITOK | M_ZERO); 635 sin->sin_family = AF_INET; 636 sin->sin_len = sizeof(*sin); 637 638 s = splnet(); 639 inp = sotoinpcb(so); 640 if (!inp) { 641 splx(s); 642 free(sin, M_SONAME); 643 return ECONNRESET; 644 } 645 sin->sin_port = inp->inp_fport; 646 sin->sin_addr = inp->inp_faddr; 647 splx(s); 648 649 *nam = (struct sockaddr *)sin; 650 return 0; 651 } 652 653 void 654 in_pcbnotifyall(head, faddr, errno, notify) 655 struct inpcbhead *head; 656 struct in_addr faddr; 657 void (*notify) (struct inpcb *, int); 658 { 659 struct inpcb *inp, *ninp; 660 int s; 661 662 s = splnet(); 663 for (inp = LIST_FIRST(head); inp != NULL; inp = ninp) { 664 ninp = LIST_NEXT(inp, inp_list); 665 #ifdef INET6 666 if ((inp->inp_vflag & INP_IPV4) == 0) 667 continue; 668 #endif 669 if (inp->inp_faddr.s_addr != faddr.s_addr || 670 inp->inp_socket == NULL) 671 continue; 672 (*notify)(inp, errno); 673 } 674 splx(s); 675 } 676 677 void 678 in_pcbpurgeif0(head, ifp) 679 struct inpcb *head; 680 struct ifnet *ifp; 681 { 682 struct inpcb *inp; 683 struct ip_moptions *imo; 684 int i, gap; 685 686 for (inp = head; inp != NULL; inp = LIST_NEXT(inp, inp_list)) { 687 imo = inp->inp_moptions; 688 if ((inp->inp_vflag & INP_IPV4) && 689 imo != NULL) { 690 /* 691 * Unselect the outgoing interface if it is being 692 * detached. 693 */ 694 if (imo->imo_multicast_ifp == ifp) 695 imo->imo_multicast_ifp = NULL; 696 697 /* 698 * Drop multicast group membership if we joined 699 * through the interface being detached. 700 */ 701 for (i = 0, gap = 0; i < imo->imo_num_memberships; 702 i++) { 703 if (imo->imo_membership[i]->inm_ifp == ifp) { 704 in_delmulti(imo->imo_membership[i]); 705 gap++; 706 } else if (gap != 0) 707 imo->imo_membership[i - gap] = 708 imo->imo_membership[i]; 709 } 710 imo->imo_num_memberships -= gap; 711 } 712 } 713 } 714 715 /* 716 * Check for alternatives when higher level complains 717 * about service problems. For now, invalidate cached 718 * routing information. If the route was created dynamically 719 * (by a redirect), time to try a default gateway again. 720 */ 721 void 722 in_losing(inp) 723 struct inpcb *inp; 724 { 725 struct rtentry *rt; 726 struct rt_addrinfo info; 727 728 if ((rt = inp->inp_route.ro_rt)) { 729 bzero((caddr_t)&info, sizeof(info)); 730 info.rti_flags = rt->rt_flags; 731 info.rti_info[RTAX_DST] = rt_key(rt); 732 info.rti_info[RTAX_GATEWAY] = rt->rt_gateway; 733 info.rti_info[RTAX_NETMASK] = rt_mask(rt); 734 rt_missmsg(RTM_LOSING, &info, rt->rt_flags, 0); 735 if (rt->rt_flags & RTF_DYNAMIC) 736 (void) rtrequest1(RTM_DELETE, &info, NULL); 737 inp->inp_route.ro_rt = NULL; 738 rtfree(rt); 739 /* 740 * A new route can be allocated 741 * the next time output is attempted. 742 */ 743 } 744 } 745 746 /* 747 * After a routing change, flush old routing 748 * and allocate a (hopefully) better one. 749 */ 750 void 751 in_rtchange(inp, errno) 752 struct inpcb *inp; 753 int errno; 754 { 755 if (inp->inp_route.ro_rt) { 756 rtfree(inp->inp_route.ro_rt); 757 inp->inp_route.ro_rt = 0; 758 /* 759 * A new route can be allocated the next time 760 * output is attempted. 761 */ 762 } 763 } 764 765 /* 766 * Lookup a PCB based on the local address and port. 767 */ 768 struct inpcb * 769 in_pcblookup_local(pcbinfo, laddr, lport_arg, wild_okay) 770 struct inpcbinfo *pcbinfo; 771 struct in_addr laddr; 772 u_int lport_arg; 773 int wild_okay; 774 { 775 struct inpcb *inp; 776 int matchwild = 3, wildcard; 777 u_short lport = lport_arg; 778 779 if (!wild_okay) { 780 struct inpcbhead *head; 781 /* 782 * Look for an unconnected (wildcard foreign addr) PCB that 783 * matches the local address and port we're looking for. 784 */ 785 head = &pcbinfo->hashbase[INP_PCBHASH(INADDR_ANY, lport, 0, pcbinfo->hashmask)]; 786 LIST_FOREACH(inp, head, inp_hash) { 787 #ifdef INET6 788 if ((inp->inp_vflag & INP_IPV4) == 0) 789 continue; 790 #endif 791 if (inp->inp_faddr.s_addr == INADDR_ANY && 792 inp->inp_laddr.s_addr == laddr.s_addr && 793 inp->inp_lport == lport) { 794 /* 795 * Found. 796 */ 797 return (inp); 798 } 799 } 800 /* 801 * Not found. 802 */ 803 return (NULL); 804 } else { 805 struct inpcbporthead *porthash; 806 struct inpcbport *phd; 807 struct inpcb *match = NULL; 808 /* 809 * Best fit PCB lookup. 810 * 811 * First see if this local port is in use by looking on the 812 * port hash list. 813 */ 814 porthash = &pcbinfo->porthashbase[INP_PCBPORTHASH(lport, 815 pcbinfo->porthashmask)]; 816 LIST_FOREACH(phd, porthash, phd_hash) { 817 if (phd->phd_port == lport) 818 break; 819 } 820 if (phd != NULL) { 821 /* 822 * Port is in use by one or more PCBs. Look for best 823 * fit. 824 */ 825 LIST_FOREACH(inp, &phd->phd_pcblist, inp_portlist) { 826 wildcard = 0; 827 #ifdef INET6 828 if ((inp->inp_vflag & INP_IPV4) == 0) 829 continue; 830 #endif 831 if (inp->inp_faddr.s_addr != INADDR_ANY) 832 wildcard++; 833 if (inp->inp_laddr.s_addr != INADDR_ANY) { 834 if (laddr.s_addr == INADDR_ANY) 835 wildcard++; 836 else if (inp->inp_laddr.s_addr != laddr.s_addr) 837 continue; 838 } else { 839 if (laddr.s_addr != INADDR_ANY) 840 wildcard++; 841 } 842 if (wildcard < matchwild) { 843 match = inp; 844 matchwild = wildcard; 845 if (matchwild == 0) { 846 break; 847 } 848 } 849 } 850 } 851 return (match); 852 } 853 } 854 855 /* 856 * Lookup PCB in hash list. 857 */ 858 struct inpcb * 859 in_pcblookup_hash(pcbinfo, faddr, fport_arg, laddr, lport_arg, wildcard, 860 ifp) 861 struct inpcbinfo *pcbinfo; 862 struct in_addr faddr, laddr; 863 u_int fport_arg, lport_arg; 864 int wildcard; 865 struct ifnet *ifp; 866 { 867 struct inpcbhead *head; 868 struct inpcb *inp; 869 u_short fport = fport_arg, lport = lport_arg; 870 871 /* 872 * First look for an exact match. 873 */ 874 head = &pcbinfo->hashbase[INP_PCBHASH(faddr.s_addr, lport, fport, pcbinfo->hashmask)]; 875 LIST_FOREACH(inp, head, inp_hash) { 876 #ifdef INET6 877 if ((inp->inp_vflag & INP_IPV4) == 0) 878 continue; 879 #endif 880 if (inp->inp_faddr.s_addr == faddr.s_addr && 881 inp->inp_laddr.s_addr == laddr.s_addr && 882 inp->inp_fport == fport && 883 inp->inp_lport == lport) { 884 /* 885 * Found. 886 */ 887 return (inp); 888 } 889 } 890 if (wildcard) { 891 struct inpcb *local_wild = NULL; 892 #if defined(INET6) 893 struct inpcb *local_wild_mapped = NULL; 894 #endif /* defined(INET6) */ 895 896 head = &pcbinfo->hashbase[INP_PCBHASH(INADDR_ANY, lport, 0, pcbinfo->hashmask)]; 897 LIST_FOREACH(inp, head, inp_hash) { 898 #ifdef INET6 899 if ((inp->inp_vflag & INP_IPV4) == 0) 900 continue; 901 #endif 902 if (inp->inp_faddr.s_addr == INADDR_ANY && 903 inp->inp_lport == lport) { 904 if (ifp && ifp->if_type == IFT_FAITH && 905 (inp->inp_flags & INP_FAITH) == 0) 906 continue; 907 if (inp->inp_laddr.s_addr == laddr.s_addr) 908 return (inp); 909 else if (inp->inp_laddr.s_addr == INADDR_ANY) { 910 #if defined(INET6) 911 if (INP_CHECK_SOCKAF(inp->inp_socket, 912 AF_INET6)) 913 local_wild_mapped = inp; 914 else 915 #endif /* defined(INET6) */ 916 local_wild = inp; 917 } 918 } 919 } 920 #if defined(INET6) 921 if (local_wild == NULL) 922 return (local_wild_mapped); 923 #endif /* defined(INET6) */ 924 return (local_wild); 925 } 926 927 /* 928 * Not found. 929 */ 930 return (NULL); 931 } 932 933 /* 934 * Insert PCB onto various hash lists. 935 */ 936 int 937 in_pcbinshash(inp) 938 struct inpcb *inp; 939 { 940 struct inpcbhead *pcbhash; 941 struct inpcbporthead *pcbporthash; 942 struct inpcbinfo *pcbinfo = inp->inp_pcbinfo; 943 struct inpcbport *phd; 944 u_int32_t hashkey_faddr; 945 946 #ifdef INET6 947 if (inp->inp_vflag & INP_IPV6) 948 hashkey_faddr = inp->in6p_faddr.s6_addr32[3] /* XXX */; 949 else 950 #endif /* INET6 */ 951 hashkey_faddr = inp->inp_faddr.s_addr; 952 953 pcbhash = &pcbinfo->hashbase[INP_PCBHASH(hashkey_faddr, 954 inp->inp_lport, inp->inp_fport, pcbinfo->hashmask)]; 955 956 pcbporthash = &pcbinfo->porthashbase[INP_PCBPORTHASH(inp->inp_lport, 957 pcbinfo->porthashmask)]; 958 959 /* 960 * Go through port list and look for a head for this lport. 961 */ 962 LIST_FOREACH(phd, pcbporthash, phd_hash) { 963 if (phd->phd_port == inp->inp_lport) 964 break; 965 } 966 /* 967 * If none exists, malloc one and tack it on. 968 */ 969 if (phd == NULL) { 970 MALLOC(phd, struct inpcbport *, sizeof(struct inpcbport), M_PCB, M_NOWAIT); 971 if (phd == NULL) { 972 return (ENOBUFS); /* XXX */ 973 } 974 phd->phd_port = inp->inp_lport; 975 LIST_INIT(&phd->phd_pcblist); 976 LIST_INSERT_HEAD(pcbporthash, phd, phd_hash); 977 } 978 inp->inp_phd = phd; 979 LIST_INSERT_HEAD(&phd->phd_pcblist, inp, inp_portlist); 980 LIST_INSERT_HEAD(pcbhash, inp, inp_hash); 981 return (0); 982 } 983 984 /* 985 * Move PCB to the proper hash bucket when { faddr, fport } have been 986 * changed. NOTE: This does not handle the case of the lport changing (the 987 * hashed port list would have to be updated as well), so the lport must 988 * not change after in_pcbinshash() has been called. 989 */ 990 void 991 in_pcbrehash(inp) 992 struct inpcb *inp; 993 { 994 struct inpcbhead *head; 995 u_int32_t hashkey_faddr; 996 997 #ifdef INET6 998 if (inp->inp_vflag & INP_IPV6) 999 hashkey_faddr = inp->in6p_faddr.s6_addr32[3] /* XXX */; 1000 else 1001 #endif /* INET6 */ 1002 hashkey_faddr = inp->inp_faddr.s_addr; 1003 1004 head = &inp->inp_pcbinfo->hashbase[INP_PCBHASH(hashkey_faddr, 1005 inp->inp_lport, inp->inp_fport, inp->inp_pcbinfo->hashmask)]; 1006 1007 LIST_REMOVE(inp, inp_hash); 1008 LIST_INSERT_HEAD(head, inp, inp_hash); 1009 } 1010 1011 /* 1012 * Remove PCB from various lists. 1013 */ 1014 void 1015 in_pcbremlists(inp) 1016 struct inpcb *inp; 1017 { 1018 inp->inp_gencnt = ++inp->inp_pcbinfo->ipi_gencnt; 1019 if (inp->inp_lport) { 1020 struct inpcbport *phd = inp->inp_phd; 1021 1022 LIST_REMOVE(inp, inp_hash); 1023 LIST_REMOVE(inp, inp_portlist); 1024 if (LIST_FIRST(&phd->phd_pcblist) == NULL) { 1025 LIST_REMOVE(phd, phd_hash); 1026 free(phd, M_PCB); 1027 } 1028 } 1029 LIST_REMOVE(inp, inp_list); 1030 inp->inp_pcbinfo->ipi_count--; 1031 } 1032 1033 int 1034 prison_xinpcb(struct thread *td, struct inpcb *inp) 1035 { 1036 struct ucred *cr; 1037 1038 if (td->td_proc == NULL) 1039 return (0); 1040 cr = td->td_proc->p_ucred; 1041 if (cr->cr_prison == NULL) 1042 return (0); 1043 if (ntohl(inp->inp_laddr.s_addr) == cr->cr_prison->pr_ip) 1044 return (0); 1045 return (1); 1046 } 1047 1048