Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/netinet/in_pcb.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
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.23.2.5 1999/09/05 08:18:19 peter Exp $ 35 */ 36 37 #include <sys/param.h> 38 #include <sys/queue.h> 39 #include <sys/systm.h> 40 #include <sys/malloc.h> 41 #include <sys/mbuf.h> 42 #include <sys/protosw.h> 43 #include <sys/socket.h> 44 #include <sys/socketvar.h> 45 #include <sys/ioctl.h> 46 #include <sys/errno.h> 47 #include <sys/time.h> 48 #include <sys/proc.h> 49 #include <sys/kernel.h> 50 #include <sys/sysctl.h> 51 52 #include <net/if.h> 53 #include <net/route.h> 54 55 #include <netinet/in.h> 56 #include <netinet/in_systm.h> 57 #include <netinet/ip.h> 58 #include <netinet/in_pcb.h> 59 #include <netinet/in_var.h> 60 #include <netinet/ip_var.h> 61 62 struct in_addr zeroin_addr; 63 64 static void in_pcbinshash __P((struct inpcb *)); 65 static void in_rtchange __P((struct inpcb *, int)); 66 67 /* 68 * These configure the range of local port addresses assigned to 69 * "unspecified" outgoing connections/packets/whatever. 70 */ 71 static int ipport_lowfirstauto = IPPORT_RESERVED - 1; /* 1023 */ 72 static int ipport_lowlastauto = IPPORT_RESERVEDSTART; /* 600 */ 73 static int ipport_firstauto = IPPORT_RESERVED; /* 1024 */ 74 static int ipport_lastauto = IPPORT_USERRESERVED; /* 5000 */ 75 static int ipport_hifirstauto = IPPORT_HIFIRSTAUTO; /* 40000 */ 76 static int ipport_hilastauto = IPPORT_HILASTAUTO; /* 44999 */ 77 78 #define RANGECHK(var, min, max) \ 79 if ((var) < (min)) { (var) = (min); } \ 80 else if ((var) > (max)) { (var) = (max); } 81 82 static int 83 sysctl_net_ipport_check SYSCTL_HANDLER_ARGS 84 { 85 int error = sysctl_handle_int(oidp, 86 oidp->oid_arg1, oidp->oid_arg2, req); 87 if (!error) { 88 RANGECHK(ipport_lowfirstauto, 1, IPPORT_RESERVED - 1); 89 RANGECHK(ipport_lowlastauto, 1, IPPORT_RESERVED - 1); 90 RANGECHK(ipport_firstauto, IPPORT_RESERVED, USHRT_MAX); 91 RANGECHK(ipport_lastauto, IPPORT_RESERVED, USHRT_MAX); 92 RANGECHK(ipport_hifirstauto, IPPORT_RESERVED, USHRT_MAX); 93 RANGECHK(ipport_hilastauto, IPPORT_RESERVED, USHRT_MAX); 94 } 95 return error; 96 } 97 98 #undef RANGECHK 99 100 SYSCTL_NODE(_net_inet_ip, IPPROTO_IP, portrange, CTLFLAG_RW, 0, "IP Ports"); 101 102 SYSCTL_PROC(_net_inet_ip_portrange, OID_AUTO, lowfirst, CTLTYPE_INT|CTLFLAG_RW, 103 &ipport_lowfirstauto, 0, &sysctl_net_ipport_check, "I", ""); 104 SYSCTL_PROC(_net_inet_ip_portrange, OID_AUTO, lowlast, CTLTYPE_INT|CTLFLAG_RW, 105 &ipport_lowlastauto, 0, &sysctl_net_ipport_check, "I", ""); 106 SYSCTL_PROC(_net_inet_ip_portrange, OID_AUTO, first, CTLTYPE_INT|CTLFLAG_RW, 107 &ipport_firstauto, 0, &sysctl_net_ipport_check, "I", ""); 108 SYSCTL_PROC(_net_inet_ip_portrange, OID_AUTO, last, CTLTYPE_INT|CTLFLAG_RW, 109 &ipport_lastauto, 0, &sysctl_net_ipport_check, "I", ""); 110 SYSCTL_PROC(_net_inet_ip_portrange, OID_AUTO, hifirst, CTLTYPE_INT|CTLFLAG_RW, 111 &ipport_hifirstauto, 0, &sysctl_net_ipport_check, "I", ""); 112 SYSCTL_PROC(_net_inet_ip_portrange, OID_AUTO, hilast, CTLTYPE_INT|CTLFLAG_RW, 113 &ipport_hilastauto, 0, &sysctl_net_ipport_check, "I", ""); 114 115 int 116 in_pcballoc(so, pcbinfo) 117 struct socket *so; 118 struct inpcbinfo *pcbinfo; 119 { 120 register struct inpcb *inp; 121 int s; 122 123 MALLOC(inp, struct inpcb *, sizeof(*inp), M_PCB, M_NOWAIT); 124 if (inp == NULL) 125 return (ENOBUFS); 126 bzero((caddr_t)inp, sizeof(*inp)); 127 inp->inp_pcbinfo = pcbinfo; 128 inp->inp_socket = so; 129 s = splnet(); 130 LIST_INSERT_HEAD(pcbinfo->listhead, inp, inp_list); 131 in_pcbinshash(inp); 132 splx(s); 133 so->so_pcb = (caddr_t)inp; 134 return (0); 135 } 136 137 int 138 in_pcbbind(inp, nam) 139 register struct inpcb *inp; 140 struct mbuf *nam; 141 { 142 register struct socket *so = inp->inp_socket; 143 unsigned short *lastport; 144 struct sockaddr_in *sin; 145 struct proc *p = curproc; /* XXX */ 146 u_short lport = 0; 147 int wild = 0, reuseport = (so->so_options & SO_REUSEPORT); 148 int error; 149 150 if (in_ifaddr == 0) 151 return (EADDRNOTAVAIL); 152 if (inp->inp_lport || inp->inp_laddr.s_addr != INADDR_ANY) 153 return (EINVAL); 154 if ((so->so_options & (SO_REUSEADDR|SO_REUSEPORT)) == 0 && 155 ((so->so_proto->pr_flags & PR_CONNREQUIRED) == 0 || 156 (so->so_options & SO_ACCEPTCONN) == 0)) 157 wild = 1; 158 if (nam) { 159 sin = mtod(nam, struct sockaddr_in *); 160 if (nam->m_len != sizeof (*sin)) 161 return (EINVAL); 162 #ifdef notdef 163 /* 164 * We should check the family, but old programs 165 * incorrectly fail to initialize it. 166 */ 167 if (sin->sin_family != AF_INET) 168 return (EAFNOSUPPORT); 169 #endif 170 lport = sin->sin_port; 171 if (IN_MULTICAST(ntohl(sin->sin_addr.s_addr))) { 172 /* 173 * Treat SO_REUSEADDR as SO_REUSEPORT for multicast; 174 * allow complete duplication of binding if 175 * SO_REUSEPORT is set, or if SO_REUSEADDR is set 176 * and a multicast address is bound on both 177 * new and duplicated sockets. 178 */ 179 if (so->so_options & SO_REUSEADDR) 180 reuseport = SO_REUSEADDR|SO_REUSEPORT; 181 } else if (sin->sin_addr.s_addr != INADDR_ANY) { 182 sin->sin_port = 0; /* yech... */ 183 if (ifa_ifwithaddr((struct sockaddr *)sin) == 0) 184 return (EADDRNOTAVAIL); 185 } 186 if (lport) { 187 struct inpcb *t; 188 189 /* GROSS */ 190 if (ntohs(lport) < IPPORT_RESERVED && 191 (error = suser(p->p_ucred, &p->p_acflag))) 192 return (EACCES); 193 if (so->so_uid && 194 !IN_MULTICAST(ntohl(sin->sin_addr.s_addr))) { 195 t = in_pcblookup(inp->inp_pcbinfo, zeroin_addr, 196 0, sin->sin_addr, lport, 197 INPLOOKUP_WILDCARD); 198 if (t && 199 (ntohl(sin->sin_addr.s_addr) != INADDR_ANY || 200 ntohl(t->inp_laddr.s_addr) != INADDR_ANY || 201 (t->inp_socket->so_options & 202 SO_REUSEPORT) == 0) && 203 (so->so_uid != t->inp_socket->so_uid)) 204 return (EADDRINUSE); 205 } 206 t = in_pcblookup(inp->inp_pcbinfo, zeroin_addr, 0, 207 sin->sin_addr, lport, wild); 208 if (t && (reuseport & t->inp_socket->so_options) == 0) 209 return (EADDRINUSE); 210 } 211 inp->inp_laddr = sin->sin_addr; 212 } 213 if (lport == 0) { 214 ushort first, last; 215 int count; 216 217 inp->inp_flags |= INP_ANONPORT; 218 219 if (inp->inp_flags & INP_HIGHPORT) { 220 first = ipport_hifirstauto; /* sysctl */ 221 last = ipport_hilastauto; 222 lastport = &inp->inp_pcbinfo->lasthi; 223 } else if (inp->inp_flags & INP_LOWPORT) { 224 if (error = suser(p->p_ucred, &p->p_acflag)) 225 return (EACCES); 226 first = ipport_lowfirstauto; /* 1023 */ 227 last = ipport_lowlastauto; /* 600 */ 228 lastport = &inp->inp_pcbinfo->lastlow; 229 } else { 230 first = ipport_firstauto; /* sysctl */ 231 last = ipport_lastauto; 232 lastport = &inp->inp_pcbinfo->lastport; 233 } 234 /* 235 * Simple check to ensure all ports are not used up causing 236 * a deadlock here. 237 * 238 * We split the two cases (up and down) so that the direction 239 * is not being tested on each round of the loop. 240 */ 241 if (first > last) { 242 /* 243 * counting down 244 */ 245 count = first - last; 246 247 do { 248 if (count-- <= 0) /* completely used? */ 249 return (EADDRNOTAVAIL); 250 --*lastport; 251 if (*lastport > first || *lastport < last) 252 *lastport = first; 253 lport = htons(*lastport); 254 } while (in_pcblookup(inp->inp_pcbinfo, 255 zeroin_addr, 0, inp->inp_laddr, lport, wild)); 256 } else { 257 /* 258 * counting up 259 */ 260 count = last - first; 261 262 do { 263 if (count-- <= 0) /* completely used? */ 264 return (EADDRNOTAVAIL); 265 ++*lastport; 266 if (*lastport < first || *lastport > last) 267 *lastport = first; 268 lport = htons(*lastport); 269 } while (in_pcblookup(inp->inp_pcbinfo, 270 zeroin_addr, 0, inp->inp_laddr, lport, wild)); 271 } 272 } 273 inp->inp_lport = lport; 274 in_pcbrehash(inp); 275 return (0); 276 } 277 278 /* 279 * Transform old in_pcbconnect() into an inner subroutine for new 280 * in_pcbconnect(): Do some validity-checking on the remote 281 * address (in mbuf 'nam') and then determine local host address 282 * (i.e., which interface) to use to access that remote host. 283 * 284 * This preserves definition of in_pcbconnect(), while supporting a 285 * slightly different version for T/TCP. (This is more than 286 * a bit of a kludge, but cleaning up the internal interfaces would 287 * have forced minor changes in every protocol). 288 */ 289 290 int 291 in_pcbladdr(inp, nam, plocal_sin) 292 register struct inpcb *inp; 293 struct mbuf *nam; 294 struct sockaddr_in **plocal_sin; 295 { 296 struct in_ifaddr *ia; 297 register struct sockaddr_in *sin = mtod(nam, struct sockaddr_in *); 298 299 if (nam->m_len != sizeof (*sin)) 300 return (EINVAL); 301 if (sin->sin_family != AF_INET) 302 return (EAFNOSUPPORT); 303 if (sin->sin_port == 0) 304 return (EADDRNOTAVAIL); 305 if (in_ifaddr) { 306 /* 307 * If the destination address is INADDR_ANY, 308 * use the primary local address. 309 * If the supplied address is INADDR_BROADCAST, 310 * and the primary interface supports broadcast, 311 * choose the broadcast address for that interface. 312 */ 313 #define satosin(sa) ((struct sockaddr_in *)(sa)) 314 #define sintosa(sin) ((struct sockaddr *)(sin)) 315 #define ifatoia(ifa) ((struct in_ifaddr *)(ifa)) 316 if (sin->sin_addr.s_addr == INADDR_ANY) 317 sin->sin_addr = IA_SIN(in_ifaddr)->sin_addr; 318 else if (sin->sin_addr.s_addr == (u_long)INADDR_BROADCAST && 319 (in_ifaddr->ia_ifp->if_flags & IFF_BROADCAST)) 320 sin->sin_addr = satosin(&in_ifaddr->ia_broadaddr)->sin_addr; 321 } 322 if (inp->inp_laddr.s_addr == INADDR_ANY) { 323 register struct route *ro; 324 325 ia = (struct in_ifaddr *)0; 326 /* 327 * If route is known or can be allocated now, 328 * our src addr is taken from the i/f, else punt. 329 */ 330 ro = &inp->inp_route; 331 if (ro->ro_rt && 332 (satosin(&ro->ro_dst)->sin_addr.s_addr != 333 sin->sin_addr.s_addr || 334 inp->inp_socket->so_options & SO_DONTROUTE)) { 335 RTFREE(ro->ro_rt); 336 ro->ro_rt = (struct rtentry *)0; 337 } 338 if ((inp->inp_socket->so_options & SO_DONTROUTE) == 0 && /*XXX*/ 339 (ro->ro_rt == (struct rtentry *)0 || 340 ro->ro_rt->rt_ifp == (struct ifnet *)0)) { 341 /* No route yet, so try to acquire one */ 342 ro->ro_dst.sa_family = AF_INET; 343 ro->ro_dst.sa_len = sizeof(struct sockaddr_in); 344 ((struct sockaddr_in *) &ro->ro_dst)->sin_addr = 345 sin->sin_addr; 346 rtalloc(ro); 347 } 348 /* 349 * If we found a route, use the address 350 * corresponding to the outgoing interface 351 * unless it is the loopback (in case a route 352 * to our address on another net goes to loopback). 353 */ 354 if (ro->ro_rt && !(ro->ro_rt->rt_ifp->if_flags & IFF_LOOPBACK)) 355 ia = ifatoia(ro->ro_rt->rt_ifa); 356 if (ia == 0) { 357 u_short fport = sin->sin_port; 358 359 sin->sin_port = 0; 360 ia = ifatoia(ifa_ifwithdstaddr(sintosa(sin))); 361 if (ia == 0) 362 ia = ifatoia(ifa_ifwithnet(sintosa(sin))); 363 sin->sin_port = fport; 364 if (ia == 0) 365 ia = in_ifaddr; 366 if (ia == 0) 367 return (EADDRNOTAVAIL); 368 } 369 /* 370 * If the destination address is multicast and an outgoing 371 * interface has been set as a multicast option, use the 372 * address of that interface as our source address. 373 */ 374 if (IN_MULTICAST(ntohl(sin->sin_addr.s_addr)) && 375 inp->inp_moptions != NULL) { 376 struct ip_moptions *imo; 377 struct ifnet *ifp; 378 379 imo = inp->inp_moptions; 380 if (imo->imo_multicast_ifp != NULL) { 381 ifp = imo->imo_multicast_ifp; 382 for (ia = in_ifaddr; ia; ia = ia->ia_next) 383 if (ia->ia_ifp == ifp) 384 break; 385 if (ia == 0) 386 return (EADDRNOTAVAIL); 387 } 388 } 389 /* 390 * Don't do pcblookup call here; return interface in plocal_sin 391 * and exit to caller, that will do the lookup. 392 */ 393 *plocal_sin = &ia->ia_addr; 394 395 } 396 return(0); 397 } 398 399 /* 400 * Outer subroutine: 401 * Connect from a socket to a specified address. 402 * Both address and port must be specified in argument sin. 403 * If don't have a local address for this socket yet, 404 * then pick one. 405 */ 406 int 407 in_pcbconnect(inp, nam) 408 register struct inpcb *inp; 409 struct mbuf *nam; 410 { 411 struct sockaddr_in *ifaddr; 412 register struct sockaddr_in *sin = mtod(nam, struct sockaddr_in *); 413 int error; 414 415 /* 416 * Call inner routine, to assign local interface address. 417 */ 418 if (error = in_pcbladdr(inp, nam, &ifaddr)) 419 return(error); 420 421 if (in_pcblookuphash(inp->inp_pcbinfo, sin->sin_addr, sin->sin_port, 422 inp->inp_laddr.s_addr ? inp->inp_laddr : ifaddr->sin_addr, 423 inp->inp_lport, 0) != NULL) 424 return (EADDRINUSE); 425 if (inp->inp_laddr.s_addr == INADDR_ANY) { 426 if (inp->inp_lport == 0) 427 (void)in_pcbbind(inp, (struct mbuf *)0); 428 inp->inp_laddr = ifaddr->sin_addr; 429 } 430 inp->inp_faddr = sin->sin_addr; 431 inp->inp_fport = sin->sin_port; 432 in_pcbrehash(inp); 433 return (0); 434 } 435 436 void 437 in_pcbdisconnect(inp) 438 struct inpcb *inp; 439 { 440 441 inp->inp_faddr.s_addr = INADDR_ANY; 442 inp->inp_fport = 0; 443 in_pcbrehash(inp); 444 if (inp->inp_socket->so_state & SS_NOFDREF) 445 in_pcbdetach(inp); 446 } 447 448 void 449 in_pcbdetach(inp) 450 struct inpcb *inp; 451 { 452 struct socket *so = inp->inp_socket; 453 int s; 454 455 so->so_pcb = 0; 456 sofree(so); 457 if (inp->inp_options) 458 (void)m_free(inp->inp_options); 459 if (inp->inp_route.ro_rt) 460 rtfree(inp->inp_route.ro_rt); 461 ip_freemoptions(inp->inp_moptions); 462 s = splnet(); 463 LIST_REMOVE(inp, inp_hash); 464 LIST_REMOVE(inp, inp_list); 465 splx(s); 466 FREE(inp, M_PCB); 467 } 468 469 void 470 in_setsockaddr(inp, nam) 471 register struct inpcb *inp; 472 struct mbuf *nam; 473 { 474 register struct sockaddr_in *sin; 475 476 nam->m_len = sizeof (*sin); 477 sin = mtod(nam, struct sockaddr_in *); 478 bzero((caddr_t)sin, sizeof (*sin)); 479 sin->sin_family = AF_INET; 480 sin->sin_len = sizeof(*sin); 481 sin->sin_port = inp->inp_lport; 482 sin->sin_addr = inp->inp_laddr; 483 } 484 485 void 486 in_setpeeraddr(inp, nam) 487 struct inpcb *inp; 488 struct mbuf *nam; 489 { 490 register struct sockaddr_in *sin; 491 492 nam->m_len = sizeof (*sin); 493 sin = mtod(nam, struct sockaddr_in *); 494 bzero((caddr_t)sin, sizeof (*sin)); 495 sin->sin_family = AF_INET; 496 sin->sin_len = sizeof(*sin); 497 sin->sin_port = inp->inp_fport; 498 sin->sin_addr = inp->inp_faddr; 499 } 500 501 /* 502 * Pass some notification to all connections of a protocol 503 * associated with address dst. The local address and/or port numbers 504 * may be specified to limit the search. The "usual action" will be 505 * taken, depending on the ctlinput cmd. The caller must filter any 506 * cmds that are uninteresting (e.g., no error in the map). 507 * Call the protocol specific routine (if any) to report 508 * any errors for each matching socket. 509 * 510 * Must be called at splnet. 511 */ 512 void 513 in_pcbnotify(head, dst, fport_arg, laddr, lport_arg, cmd, notify) 514 struct inpcbhead *head; 515 struct sockaddr *dst; 516 u_int fport_arg, lport_arg; 517 struct in_addr laddr; 518 int cmd; 519 void (*notify) __P((struct inpcb *, int)); 520 { 521 register struct inpcb *inp, *oinp; 522 struct in_addr faddr; 523 u_short fport = fport_arg, lport = lport_arg; 524 int errno, s; 525 526 if ((unsigned)cmd > PRC_NCMDS || dst->sa_family != AF_INET) 527 return; 528 faddr = ((struct sockaddr_in *)dst)->sin_addr; 529 if (faddr.s_addr == INADDR_ANY) 530 return; 531 532 /* 533 * Redirects go to all references to the destination, 534 * and use in_rtchange to invalidate the route cache. 535 * Dead host indications: notify all references to the destination. 536 * Otherwise, if we have knowledge of the local port and address, 537 * deliver only to that socket. 538 */ 539 if (PRC_IS_REDIRECT(cmd) || cmd == PRC_HOSTDEAD) { 540 fport = 0; 541 lport = 0; 542 laddr.s_addr = 0; 543 if (cmd != PRC_HOSTDEAD) 544 notify = in_rtchange; 545 } 546 errno = inetctlerrmap[cmd]; 547 s = splnet(); 548 for (inp = head->lh_first; inp != NULL;) { 549 if (inp->inp_faddr.s_addr != faddr.s_addr || 550 inp->inp_socket == 0 || 551 (lport && inp->inp_lport != lport) || 552 (laddr.s_addr && inp->inp_laddr.s_addr != laddr.s_addr) || 553 (fport && inp->inp_fport != fport)) { 554 inp = inp->inp_list.le_next; 555 continue; 556 } 557 oinp = inp; 558 inp = inp->inp_list.le_next; 559 if (notify) 560 (*notify)(oinp, errno); 561 } 562 splx(s); 563 } 564 565 /* 566 * Check for alternatives when higher level complains 567 * about service problems. For now, invalidate cached 568 * routing information. If the route was created dynamically 569 * (by a redirect), time to try a default gateway again. 570 */ 571 void 572 in_losing(inp) 573 struct inpcb *inp; 574 { 575 register struct rtentry *rt; 576 struct rt_addrinfo info; 577 578 if ((rt = inp->inp_route.ro_rt)) { 579 inp->inp_route.ro_rt = 0; 580 bzero((caddr_t)&info, sizeof(info)); 581 info.rti_info[RTAX_DST] = 582 (struct sockaddr *)&inp->inp_route.ro_dst; 583 info.rti_info[RTAX_GATEWAY] = rt->rt_gateway; 584 info.rti_info[RTAX_NETMASK] = rt_mask(rt); 585 rt_missmsg(RTM_LOSING, &info, rt->rt_flags, 0); 586 if (rt->rt_flags & RTF_DYNAMIC) 587 (void) rtrequest(RTM_DELETE, rt_key(rt), 588 rt->rt_gateway, rt_mask(rt), rt->rt_flags, 589 (struct rtentry **)0); 590 else 591 /* 592 * A new route can be allocated 593 * the next time output is attempted. 594 */ 595 rtfree(rt); 596 } 597 } 598 599 /* 600 * After a routing change, flush old routing 601 * and allocate a (hopefully) better one. 602 */ 603 static void 604 in_rtchange(inp, errno) 605 register struct inpcb *inp; 606 int errno; 607 { 608 if (inp->inp_route.ro_rt) { 609 rtfree(inp->inp_route.ro_rt); 610 inp->inp_route.ro_rt = 0; 611 /* 612 * A new route can be allocated the next time 613 * output is attempted. 614 */ 615 } 616 } 617 618 struct inpcb * 619 in_pcblookup(pcbinfo, faddr, fport_arg, laddr, lport_arg, wild_okay) 620 struct inpcbinfo *pcbinfo; 621 struct in_addr faddr, laddr; 622 u_int fport_arg, lport_arg; 623 int wild_okay; 624 { 625 register struct inpcb *inp, *match = NULL; 626 int matchwild = 3, wildcard; 627 u_short fport = fport_arg, lport = lport_arg; 628 int s; 629 630 s = splnet(); 631 632 for (inp = pcbinfo->listhead->lh_first; inp != NULL; inp = inp->inp_list.le_next) { 633 if (inp->inp_lport != lport) 634 continue; 635 wildcard = 0; 636 if (inp->inp_faddr.s_addr != INADDR_ANY) { 637 if (faddr.s_addr == INADDR_ANY) 638 wildcard++; 639 else if (inp->inp_faddr.s_addr != faddr.s_addr || 640 inp->inp_fport != fport) 641 continue; 642 } else { 643 if (faddr.s_addr != INADDR_ANY) 644 wildcard++; 645 } 646 if (inp->inp_laddr.s_addr != INADDR_ANY) { 647 if (laddr.s_addr == INADDR_ANY) 648 wildcard++; 649 else if (inp->inp_laddr.s_addr != laddr.s_addr) 650 continue; 651 } else { 652 if (laddr.s_addr != INADDR_ANY) 653 wildcard++; 654 } 655 if (wildcard && wild_okay == 0) 656 continue; 657 if (wildcard < matchwild) { 658 match = inp; 659 matchwild = wildcard; 660 if (matchwild == 0) { 661 break; 662 } 663 } 664 } 665 splx(s); 666 return (match); 667 } 668 669 /* 670 * Lookup PCB in hash list. 671 */ 672 struct inpcb * 673 in_pcblookuphash(pcbinfo, faddr, fport_arg, laddr, lport_arg, wildcard) 674 struct inpcbinfo *pcbinfo; 675 struct in_addr faddr, laddr; 676 u_int fport_arg, lport_arg; 677 int wildcard; 678 { 679 struct inpcbhead *head; 680 register struct inpcb *inp; 681 u_short fport = fport_arg, lport = lport_arg; 682 int s; 683 684 s = splnet(); 685 /* 686 * First look for an exact match. 687 */ 688 head = &pcbinfo->hashbase[INP_PCBHASH(faddr.s_addr, lport, fport, pcbinfo->hashmask)]; 689 for (inp = head->lh_first; inp != NULL; inp = inp->inp_hash.le_next) { 690 if (inp->inp_faddr.s_addr == faddr.s_addr && 691 inp->inp_laddr.s_addr == laddr.s_addr && 692 inp->inp_fport == fport && 693 inp->inp_lport == lport) 694 goto found; 695 } 696 if (wildcard) { 697 struct inpcb *local_wild = NULL; 698 699 head = &pcbinfo->hashbase[INP_PCBHASH(INADDR_ANY, lport, 0, pcbinfo->hashmask)]; 700 for (inp = head->lh_first; inp != NULL; inp = inp->inp_hash.le_next) { 701 if (inp->inp_faddr.s_addr == INADDR_ANY && 702 inp->inp_fport == 0 && inp->inp_lport == lport) { 703 if (inp->inp_laddr.s_addr == laddr.s_addr) 704 goto found; 705 else if (inp->inp_laddr.s_addr == INADDR_ANY) 706 local_wild = inp; 707 } 708 } 709 if (local_wild != NULL) { 710 inp = local_wild; 711 goto found; 712 } 713 } 714 splx(s); 715 return (NULL); 716 717 found: 718 /* 719 * Move PCB to head of this hash chain so that it can be 720 * found more quickly in the future. 721 * XXX - this is a pessimization on machines with few 722 * concurrent connections. 723 */ 724 if (inp != head->lh_first) { 725 LIST_REMOVE(inp, inp_hash); 726 LIST_INSERT_HEAD(head, inp, inp_hash); 727 } 728 splx(s); 729 return (inp); 730 } 731 732 /* 733 * Insert PCB into hash chain. Must be called at splnet. 734 */ 735 static void 736 in_pcbinshash(inp) 737 struct inpcb *inp; 738 { 739 struct inpcbhead *head; 740 741 head = &inp->inp_pcbinfo->hashbase[INP_PCBHASH(inp->inp_faddr.s_addr, 742 inp->inp_lport, inp->inp_fport, inp->inp_pcbinfo->hashmask)]; 743 744 LIST_INSERT_HEAD(head, inp, inp_hash); 745 } 746 747 void 748 in_pcbrehash(inp) 749 struct inpcb *inp; 750 { 751 struct inpcbhead *head; 752 int s; 753 754 s = splnet(); 755 LIST_REMOVE(inp, inp_hash); 756 757 head = &inp->inp_pcbinfo->hashbase[INP_PCBHASH(inp->inp_faddr.s_addr, 758 inp->inp_lport, inp->inp_fport, inp->inp_pcbinfo->hashmask)]; 759 760 LIST_INSERT_HEAD(head, inp, inp_hash); 761 splx(s); 762 }
Cache object: 83707877ddb8510b2a1a461dccc30e38
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]