![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to in_pcb.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / netinet|
Return to in_pcb.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / netinet |
1.1 ! root 1: /* ! 2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights ! 7: * Reserved. This file contains Original Code and/or Modifications of ! 8: * Original Code as defined in and that are subject to the Apple Public ! 9: * Source License Version 1.1 (the "License"). You may not use this file ! 10: * except in compliance with the License. Please obtain a copy of the ! 11: * License at http://www.apple.com/publicsource and read it before using ! 12: * this file. ! 13: * ! 14: * The Original Code and all software distributed under the License are ! 15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 19: * License for the specific language governing rights and limitations ! 20: * under the License. ! 21: * ! 22: * @APPLE_LICENSE_HEADER_END@ ! 23: */ ! 24: ! 25: /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */ ! 26: /* ! 27: * Copyright (c) 1982, 1986, 1991, 1993, 1995 ! 28: * The Regents of the University of California. All rights reserved. ! 29: * ! 30: * Redistribution and use in source and binary forms, with or without ! 31: * modification, are permitted provided that the following conditions ! 32: * are met: ! 33: * 1. Redistributions of source code must retain the above copyright ! 34: * notice, this list of conditions and the following disclaimer. ! 35: * 2. Redistributions in binary form must reproduce the above copyright ! 36: * notice, this list of conditions and the following disclaimer in the ! 37: * documentation and/or other materials provided with the distribution. ! 38: * 3. All advertising materials mentioning features or use of this software ! 39: * must display the following acknowledgement: ! 40: * This product includes software developed by the University of ! 41: * California, Berkeley and its contributors. ! 42: * 4. Neither the name of the University nor the names of its contributors ! 43: * may be used to endorse or promote products derived from this software ! 44: * without specific prior written permission. ! 45: * ! 46: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 47: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 48: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 49: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 50: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 51: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 52: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 53: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 54: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 55: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 56: * SUCH DAMAGE. ! 57: * ! 58: * @(#)in_pcb.c 8.4 (Berkeley) 5/24/95 ! 59: */ ! 60: ! 61: #include <sys/param.h> ! 62: #include <sys/systm.h> ! 63: #include <sys/malloc.h> ! 64: #include <sys/mbuf.h> ! 65: #include <sys/protosw.h> ! 66: #include <sys/socket.h> ! 67: #include <sys/socketvar.h> ! 68: #include <sys/ioctl.h> ! 69: #include <sys/errno.h> ! 70: #include <sys/time.h> ! 71: #include <sys/proc.h> ! 72: ! 73: #include <net/if.h> ! 74: #include <net/route.h> ! 75: ! 76: #include <netinet/in.h> ! 77: #include <netinet/in_systm.h> ! 78: #include <netinet/ip.h> ! 79: #include <netinet/in_pcb.h> ! 80: #include <netinet/in_var.h> ! 81: #include <netinet/ip_var.h> ! 82: ! 83: #include <kern/kdebug.h> ! 84: ! 85: ! 86: #if KDEBUG ! 87: ! 88: #define DBG_FNC_PCB_LOOKUP NETDBG_CODE(DBG_NETTCP, (6 << 8)) ! 89: #define DBG_FNC_PCB_HLOOKUP NETDBG_CODE(DBG_NETTCP, ((6 << 8) | 1)) ! 90: ! 91: #endif ! 92: ! 93: ! 94: struct zone *inpcb_zone; ! 95: struct in_addr zeroin_addr; ! 96: ! 97: ! 98: ! 99: ! 100: void ! 101: lport_hash_remove(inp) ! 102: register struct inpcb *inp; ! 103: { ! 104: if ((*inp->lport_hash_str->hash_array)[inp->lport_hash_element] == inp) ! 105: (*inp->lport_hash_str->hash_array)[inp->lport_hash_element] = inp->lport_hash_next; ! 106: ! 107: if (inp->lport_hash_prev) ! 108: inp->lport_hash_prev->lport_hash_next = inp->lport_hash_next; ! 109: ! 110: if (inp->lport_hash_next) ! 111: inp->lport_hash_next->lport_hash_prev = inp->lport_hash_prev; ! 112: ! 113: inp->lport_hash_next = 0; ! 114: inp->lport_hash_prev = 0; ! 115: inp->lport_hash_element = -1; ! 116: } ! 117: ! 118: ! 119: ! 120: ! 121: void ! 122: lport_hash_insert(inp) ! 123: register struct inpcb *inp; ! 124: ! 125: { ! 126: register u_long h_idx; ! 127: ! 128: if (inp->lport_hash_element != -1) ! 129: return; ! 130: ! 131: h_idx = inp->inp_lport & inp->lport_hash_str->hash_mask; ! 132: ! 133: if ((*inp->lport_hash_str->hash_array)[h_idx]) { ! 134: (*inp->lport_hash_str->hash_array)[h_idx]->lport_hash_prev = inp; ! 135: inp->lport_hash_next = (*inp->lport_hash_str->hash_array)[h_idx]; ! 136: inp->lport_hash_prev = 0; ! 137: (*inp->lport_hash_str->hash_array)[h_idx] = inp; ! 138: } else { ! 139: (*inp->lport_hash_str->hash_array)[h_idx] = inp; ! 140: inp->lport_hash_next = 0; ! 141: inp->lport_hash_prev = 0; ! 142: } ! 143: ! 144: inp->lport_hash_element = h_idx; ! 145: } ! 146: ! 147: ! 148: ! 149: ! 150: void ! 151: hash_remove(inp) ! 152: register struct inpcb *inp; ! 153: { ! 154: if ((*inp->hash_str->hash_array)[inp->hash_element] == inp) ! 155: (*inp->hash_str->hash_array)[inp->hash_element] = inp->hash_next; ! 156: ! 157: if (inp->hash_prev) ! 158: inp->hash_prev->hash_next = inp->hash_next; ! 159: ! 160: if (inp->hash_next) ! 161: inp->hash_next->hash_prev = inp->hash_prev; ! 162: ! 163: inp->hash_next = 0; ! 164: inp->hash_prev = 0; ! 165: inp->hash_element = -1; ! 166: } ! 167: ! 168: ! 169: ! 170: void ! 171: hash_insert(inp) ! 172: register struct inpcb *inp; ! 173: { ! 174: register u_long h_idx; ! 175: ! 176: if (inp->hash_element != -1) ! 177: return; ! 178: ! 179: h_idx = (inp->inp_lport + inp->inp_fport + inp->inp_faddr.s_addr) & inp->hash_str->hash_mask; ! 180: ! 181: if ((*inp->hash_str->hash_array)[h_idx]) { ! 182: (*inp->hash_str->hash_array)[h_idx]->hash_prev = inp; ! 183: inp->hash_next = (*inp->hash_str->hash_array)[h_idx]; ! 184: inp->hash_prev = 0; ! 185: (*inp->hash_str->hash_array)[h_idx] = inp; ! 186: } else { ! 187: (*inp->hash_str->hash_array)[h_idx] = inp; ! 188: inp->hash_next = 0; ! 189: inp->hash_prev = 0; ! 190: } ! 191: inp->hash_element = h_idx; ! 192: } ! 193: ! 194: ! 195: struct inpcb *inet_hash1(hash_str, l_addr, l_port, f_addr, f_port) ! 196: struct inpcb_hash_str *hash_str; ! 197: u_long l_addr; ! 198: u_short l_port; ! 199: u_long f_addr; ! 200: u_short f_port; ! 201: { ! 202: return ((*hash_str->hash_array)[(l_port + f_port + f_addr) & hash_str->hash_mask]); ! 203: } ! 204: ! 205: ! 206: struct inpcb *inet_lport_hash1(lport_hash_str, l_port) ! 207: struct inpcb_hash_str *lport_hash_str; ! 208: u_short l_port; ! 209: ! 210: { ! 211: return ((*lport_hash_str->hash_array)[l_port & lport_hash_str->hash_mask]); ! 212: } ! 213: ! 214: ! 215: ! 216: int ! 217: in_pcballoc(so, head, hash_str, lport_hash_str) ! 218: struct socket *so; ! 219: struct inpcb *head; ! 220: struct inpcb_hash_str *hash_str; ! 221: struct inpcb_hash_str *lport_hash_str; ! 222: { ! 223: register struct inpcb *inp; ! 224: caddr_t temp; ! 225: ! 226: if (so->cached_in_sock_layer == 0) { ! 227: #if TEMPDEBUG ! 228: printf("PCBALLOC calling zalloc for socket %x\n", so); ! 229: #endif ! 230: inp = zalloc(inpcb_zone); ! 231: if (inp == NULL) ! 232: return (ENOBUFS); ! 233: bzero((caddr_t)inp, sizeof(*inp)); ! 234: } ! 235: else { ! 236: #if TEMPDEBUG ! 237: printf("PCBALLOC reusing PCB for socket %x\n", so); ! 238: #endif ! 239: inp = so->so_saved_pcb; ! 240: temp = inp->inp_saved_ppcb; ! 241: bzero((caddr_t) inp, sizeof(*inp)); ! 242: inp->inp_saved_ppcb = temp; ! 243: } ! 244: ! 245: inp->hash_element = -1; ! 246: inp->lport_hash_element = -1; ! 247: inp->inp_head = head; ! 248: inp->hash_str = hash_str; ! 249: inp->lport_hash_str = lport_hash_str; ! 250: inp->inp_socket = so; ! 251: if (head) ! 252: insque(inp, head); ! 253: so->so_pcb = (caddr_t)inp; ! 254: return (0); ! 255: } ! 256: ! 257: int ! 258: in_pcbbind(inp, nam) ! 259: register struct inpcb *inp; ! 260: struct mbuf *nam; ! 261: { ! 262: register struct socket *so = inp->inp_socket; ! 263: register struct inpcb *head = inp->inp_head; ! 264: register struct sockaddr_in *sin; ! 265: struct proc *p = current_proc(); /* XXX */ ! 266: u_short lport = 0; ! 267: int wild = 0, reuseport = (so->so_options & SO_REUSEPORT); ! 268: int error; ! 269: register int loop_count = 0; ! 270: struct inpcb *hash_head; ! 271: ! 272: ! 273: if (in_ifaddr == 0) ! 274: return (EADDRNOTAVAIL); ! 275: if (inp->inp_lport || inp->inp_laddr.s_addr != INADDR_ANY) ! 276: return (EINVAL); ! 277: if ((so->so_options & (SO_REUSEADDR|SO_REUSEPORT)) == 0 && ! 278: ((so->so_proto->pr_flags & PR_CONNREQUIRED) == 0 || ! 279: (so->so_options & SO_ACCEPTCONN) == 0)) ! 280: wild = INPLOOKUP_WILDCARD; ! 281: if (nam) { ! 282: sin = mtod(nam, struct sockaddr_in *); ! 283: if (nam->m_len != sizeof (*sin)) ! 284: return (EINVAL); ! 285: #ifdef notdef ! 286: /* ! 287: * We should check the family, but old programs ! 288: * incorrectly fail to initialize it. ! 289: */ ! 290: if (sin->sin_family != AF_INET) ! 291: return (EAFNOSUPPORT); ! 292: #endif ! 293: lport = sin->sin_port; ! 294: if (IN_MULTICAST(ntohl(sin->sin_addr.s_addr))) { ! 295: /* ! 296: * Treat SO_REUSEADDR as SO_REUSEPORT for multicast; ! 297: * allow complete duplication of binding if ! 298: * SO_REUSEPORT is set, or if SO_REUSEADDR is set ! 299: * and a multicast address is bound on both ! 300: * new and duplicated sockets. ! 301: */ ! 302: if (so->so_options & SO_REUSEADDR) ! 303: reuseport = SO_REUSEADDR|SO_REUSEPORT; ! 304: } else if (sin->sin_addr.s_addr != INADDR_ANY) { ! 305: sin->sin_port = 0; /* yech... */ ! 306: if (ifa_ifwithaddr((struct sockaddr *)sin) == 0) ! 307: return (EADDRNOTAVAIL); ! 308: } ! 309: if (lport) { ! 310: struct inpcb *t; ! 311: ! 312: /* GROSS */ ! 313: if (ntohs(lport) < IPPORT_RESERVED && ! 314: (error = suser(p->p_ucred, &p->p_acflag))) ! 315: return (EACCES); ! 316: ! 317: hash_head = inet_lport_hash1(inp->lport_hash_str, lport); ! 318: t = lport_hash_in_pcbwild(hash_head, ! 319: zeroin_addr, 0, sin->sin_addr, ! 320: lport, wild); ! 321: ! 322: if (t && (reuseport & t->inp_socket->so_options) == 0) ! 323: return (EADDRINUSE); ! 324: } ! 325: inp->inp_laddr = sin->sin_addr; ! 326: } ! 327: if (lport == 0) { ! 328: for (;;) { ! 329: if (++loop_count >= (IPPORT_USERRESERVED - IPPORT_RESERVED)) ! 330: return EADDRINUSE; ! 331: ! 332: if (head->inp_lport++ < IPPORT_RESERVED || ! 333: head->inp_lport > IPPORT_USERRESERVED) ! 334: head->inp_lport = IPPORT_RESERVED; ! 335: ! 336: lport = htons(head->inp_lport); ! 337: ! 338: hash_head = inet_lport_hash1(inp->lport_hash_str, lport); ! 339: if (lport_hash_in_pcbwild(hash_head, ! 340: zeroin_addr, 0, inp->inp_laddr, lport, wild)) ! 341: continue; ! 342: ! 343: break; ! 344: } ! 345: } ! 346: ! 347: inp->inp_lport = lport; ! 348: lport_hash_insert(inp); ! 349: ! 350: return (0); ! 351: } ! 352: ! 353: /* ! 354: * Connect from a socket to a specified address. ! 355: * Both address and port must be specified in argument sin. ! 356: * If don't have a local address for this socket yet, ! 357: * then pick one. ! 358: */ ! 359: int ! 360: in_pcbconnect(inp, nam) ! 361: register struct inpcb *inp; ! 362: struct mbuf *nam; ! 363: { ! 364: struct inpcb *hash_head; ! 365: struct in_ifaddr *ia; ! 366: struct sockaddr_in *ifaddr; ! 367: register struct sockaddr_in *sin = mtod(nam, struct sockaddr_in *); ! 368: ! 369: if (nam->m_len != sizeof (*sin)) ! 370: return (EINVAL); ! 371: if (sin->sin_family != AF_INET) ! 372: return (EAFNOSUPPORT); ! 373: if (sin->sin_port == 0) ! 374: return (EADDRNOTAVAIL); ! 375: if (in_ifaddr) { ! 376: /* ! 377: * If the destination address is INADDR_ANY, ! 378: * use the primary local address. ! 379: * If the supplied address is INADDR_BROADCAST, ! 380: * and the primary interface supports broadcast, ! 381: * choose the broadcast address for that interface. ! 382: */ ! 383: #define satosin(sa) ((struct sockaddr_in *)(sa)) ! 384: #define sintosa(sin) ((struct sockaddr *)(sin)) ! 385: #define ifatoia(ifa) ((struct in_ifaddr *)(ifa)) ! 386: if (sin->sin_addr.s_addr == INADDR_ANY) ! 387: sin->sin_addr = IA_SIN(in_ifaddr)->sin_addr; ! 388: else if (sin->sin_addr.s_addr == (u_long)INADDR_BROADCAST && ! 389: (in_ifaddr->ia_ifp->if_flags & IFF_BROADCAST)) ! 390: sin->sin_addr = satosin(&in_ifaddr->ia_broadaddr)->sin_addr; ! 391: } ! 392: if (inp->inp_laddr.s_addr == INADDR_ANY) { ! 393: register struct route *ro; ! 394: ! 395: ia = (struct in_ifaddr *)0; ! 396: /* ! 397: * If route is known or can be allocated now, ! 398: * our src addr is taken from the i/f, else punt. ! 399: */ ! 400: ro = &inp->inp_route; ! 401: if (ro->ro_rt && ! 402: (satosin(&ro->ro_dst)->sin_addr.s_addr != ! 403: sin->sin_addr.s_addr || ! 404: inp->inp_socket->so_options & SO_DONTROUTE)) { ! 405: RTFREE(ro->ro_rt); ! 406: ro->ro_rt = (struct rtentry *)0; ! 407: } ! 408: if ((inp->inp_socket->so_options & SO_DONTROUTE) == 0 && /*XXX*/ ! 409: (ro->ro_rt == (struct rtentry *)0 || ! 410: ro->ro_rt->rt_ifp == (struct ifnet *)0)) { ! 411: /* No route yet, so try to acquire one */ ! 412: ro->ro_dst.sa_family = AF_INET; ! 413: ro->ro_dst.sa_len = sizeof(struct sockaddr_in); ! 414: ((struct sockaddr_in *) &ro->ro_dst)->sin_addr = ! 415: sin->sin_addr; ! 416: rtalloc(ro); ! 417: } ! 418: /* ! 419: * If we found a route, use the address ! 420: * corresponding to the outgoing interface ! 421: * unless it is the loopback (in case a route ! 422: * to our address on another net goes to loopback). ! 423: */ ! 424: if (ro->ro_rt && !(ro->ro_rt->rt_ifp->if_flags & IFF_LOOPBACK)) ! 425: ia = ifatoia(ro->ro_rt->rt_ifa); ! 426: if (ia == 0) { ! 427: u_short fport = sin->sin_port; ! 428: ! 429: sin->sin_port = 0; ! 430: ia = ifatoia(ifa_ifwithdstaddr(sintosa(sin))); ! 431: if (ia == 0) ! 432: ia = ifatoia(ifa_ifwithnet(sintosa(sin))); ! 433: sin->sin_port = fport; ! 434: if (ia == 0) ! 435: ia = in_ifaddr; ! 436: if (ia == 0) ! 437: return (EADDRNOTAVAIL); ! 438: } ! 439: /* ! 440: * If the destination address is multicast and an outgoing ! 441: * interface has been set as a multicast option, use the ! 442: * address of that interface as our source address. ! 443: */ ! 444: if (IN_MULTICAST(ntohl(sin->sin_addr.s_addr)) && ! 445: inp->inp_moptions != NULL) { ! 446: struct ip_moptions *imo; ! 447: struct ifnet *ifp; ! 448: ! 449: imo = inp->inp_moptions; ! 450: if (imo->imo_multicast_ifp != NULL) { ! 451: ifp = imo->imo_multicast_ifp; ! 452: for (ia = in_ifaddr; ia; ia = ia->ia_next) ! 453: if (ia->ia_ifp == ifp) ! 454: break; ! 455: if (ia == 0) ! 456: return (EADDRNOTAVAIL); ! 457: } ! 458: } ! 459: ifaddr = (struct sockaddr_in *)&ia->ia_addr; ! 460: } ! 461: ! 462: if ( !(inp->inp_flags & INP_NOLOOKUP)) { ! 463: hash_head = inet_hash1(inp->hash_str, ! 464: inp->inp_laddr.s_addr ? inp->inp_laddr.s_addr : ifaddr->sin_addr.s_addr, ! 465: inp->inp_lport, ! 466: sin->sin_addr.s_addr, ! 467: sin->sin_port); ! 468: ! 469: if (hash_in_pcblookup(hash_head, ! 470: sin->sin_addr, ! 471: sin->sin_port, ! 472: inp->inp_laddr.s_addr ? inp->inp_laddr : ifaddr->sin_addr, ! 473: inp->inp_lport)) ! 474: return (EADDRINUSE); ! 475: } ! 476: ! 477: ! 478: if (inp->inp_laddr.s_addr == INADDR_ANY) { ! 479: if (inp->inp_lport == 0) ! 480: (void)in_pcbbind(inp, (struct mbuf *)0); ! 481: inp->inp_laddr = ifaddr->sin_addr; ! 482: } ! 483: inp->inp_faddr = sin->sin_addr; ! 484: inp->inp_fport = sin->sin_port; ! 485: hash_insert(inp); ! 486: return (0); ! 487: } ! 488: ! 489: int ! 490: in_pcbdisconnect(inp) ! 491: struct inpcb *inp; ! 492: { ! 493: ! 494: inp->inp_faddr.s_addr = INADDR_ANY; ! 495: inp->inp_fport = 0; ! 496: ! 497: if (inp->inp_socket->so_state & SS_NOFDREF) ! 498: in_pcbdetach(inp); ! 499: else { ! 500: if (inp->hash_element >= 0) ! 501: hash_remove(inp); ! 502: } ! 503: } ! 504: ! 505: int ! 506: in_pcbdetach(inp) ! 507: struct inpcb *inp; ! 508: { ! 509: struct socket *so = inp->inp_socket; ! 510: ! 511: if (inp->hash_element >= 0) ! 512: hash_remove(inp); ! 513: ! 514: if (inp->lport_hash_element >= 0) ! 515: lport_hash_remove(inp); ! 516: #if TEMPDEBUG ! 517: if (so->cached_in_sock_layer) ! 518: printf("PCB_DETACH for cached socket %x\n", so); ! 519: else ! 520: printf("PCB_DETACH for allocated socket %x\n", so); ! 521: #endif ! 522: so->so_pcb = 0; ! 523: ! 524: if (inp->inp_options) ! 525: (void)m_free(inp->inp_options); ! 526: if (inp->inp_route.ro_rt) ! 527: rtfree(inp->inp_route.ro_rt); ! 528: ip_freemoptions(inp->inp_moptions); ! 529: if ((inp->inp_next) && (inp->inp_prev)) ! 530: remque(inp); ! 531: ! 532: if (so->cached_in_sock_layer) ! 533: so->so_saved_pcb = inp; ! 534: else ! 535: zfree(inpcb_zone, (vm_offset_t) inp); ! 536: sofree(so); ! 537: } ! 538: ! 539: int ! 540: in_setsockaddr(inp, nam) ! 541: register struct inpcb *inp; ! 542: struct mbuf *nam; ! 543: { ! 544: register struct sockaddr_in *sin; ! 545: ! 546: nam->m_len = sizeof (*sin); ! 547: sin = mtod(nam, struct sockaddr_in *); ! 548: bzero((caddr_t)sin, sizeof (*sin)); ! 549: sin->sin_family = AF_INET; ! 550: sin->sin_len = sizeof(*sin); ! 551: sin->sin_port = inp->inp_lport; ! 552: sin->sin_addr = inp->inp_laddr; ! 553: } ! 554: ! 555: int ! 556: in_setpeeraddr(inp, nam) ! 557: struct inpcb *inp; ! 558: struct mbuf *nam; ! 559: { ! 560: register struct sockaddr_in *sin; ! 561: ! 562: nam->m_len = sizeof (*sin); ! 563: sin = mtod(nam, struct sockaddr_in *); ! 564: bzero((caddr_t)sin, sizeof (*sin)); ! 565: sin->sin_family = AF_INET; ! 566: sin->sin_len = sizeof(*sin); ! 567: sin->sin_port = inp->inp_fport; ! 568: sin->sin_addr = inp->inp_faddr; ! 569: } ! 570: ! 571: /* ! 572: * Pass some notification to all connections of a protocol ! 573: * associated with address dst. The local address and/or port numbers ! 574: * may be specified to limit the search. The "usual action" will be ! 575: * taken, depending on the ctlinput cmd. The caller must filter any ! 576: * cmds that are uninteresting (e.g., no error in the map). ! 577: * Call the protocol specific routine (if any) to report ! 578: * any errors for each matching socket. ! 579: * ! 580: * Must be called at splnet. ! 581: */ ! 582: int ! 583: in_pcbnotify(head, dst, fport_arg, laddr, lport_arg, cmd, notify) ! 584: struct inpcb *head; ! 585: struct sockaddr *dst; ! 586: u_int fport_arg, lport_arg; ! 587: struct in_addr laddr; ! 588: int cmd; ! 589: void (*notify) __P((struct inpcb *, int)); ! 590: { ! 591: extern u_char inetctlerrmap[]; ! 592: register struct inpcb *inp, *oinp; ! 593: struct in_addr faddr; ! 594: u_short fport = fport_arg, lport = lport_arg; ! 595: int errno; ! 596: ! 597: if ((unsigned)cmd > PRC_NCMDS || dst->sa_family != AF_INET) ! 598: return; ! 599: faddr = ((struct sockaddr_in *)dst)->sin_addr; ! 600: if (faddr.s_addr == INADDR_ANY) ! 601: return; ! 602: ! 603: /* ! 604: * Redirects go to all references to the destination, ! 605: * and use in_rtchange to invalidate the route cache. ! 606: * Dead host indications: notify all references to the destination. ! 607: * Otherwise, if we have knowledge of the local port and address, ! 608: * deliver only to that socket. ! 609: */ ! 610: if (PRC_IS_REDIRECT(cmd) || cmd == PRC_HOSTDEAD) { ! 611: fport = 0; ! 612: lport = 0; ! 613: laddr.s_addr = 0; ! 614: if (cmd != PRC_HOSTDEAD) ! 615: notify = in_rtchange; ! 616: } ! 617: errno = inetctlerrmap[cmd]; ! 618: for (inp = head->inp_next; inp != head;) { ! 619: if (inp->inp_faddr.s_addr != faddr.s_addr || ! 620: inp->inp_socket == 0 || ! 621: (lport && inp->inp_lport != lport) || ! 622: (laddr.s_addr && inp->inp_laddr.s_addr != laddr.s_addr) || ! 623: (fport && inp->inp_fport != fport)) { ! 624: inp = inp->inp_next; ! 625: continue; ! 626: } ! 627: oinp = inp; ! 628: inp = inp->inp_next; ! 629: if (notify) ! 630: (*notify)(oinp, errno); ! 631: } ! 632: } ! 633: ! 634: /* ! 635: * Check for alternatives when higher level complains ! 636: * about service problems. For now, invalidate cached ! 637: * routing information. If the route was created dynamically ! 638: * (by a redirect), time to try a default gateway again. ! 639: */ ! 640: int ! 641: in_losing(inp) ! 642: struct inpcb *inp; ! 643: { ! 644: register struct rtentry *rt; ! 645: struct rt_addrinfo info; ! 646: ! 647: if ((rt = inp->inp_route.ro_rt)) { ! 648: inp->inp_route.ro_rt = 0; ! 649: bzero((caddr_t)&info, sizeof(info)); ! 650: info.rti_info[RTAX_DST] = ! 651: (struct sockaddr *)&inp->inp_route.ro_dst; ! 652: info.rti_info[RTAX_GATEWAY] = rt->rt_gateway; ! 653: info.rti_info[RTAX_NETMASK] = rt_mask(rt); ! 654: rt_missmsg(RTM_LOSING, &info, rt->rt_flags, 0); ! 655: if (rt->rt_flags & RTF_DYNAMIC) ! 656: (void) rtrequest(RTM_DELETE, rt_key(rt), ! 657: rt->rt_gateway, rt_mask(rt), rt->rt_flags, ! 658: (struct rtentry **)0); ! 659: else ! 660: /* ! 661: * A new route can be allocated ! 662: * the next time output is attempted. ! 663: */ ! 664: rtfree(rt); ! 665: } ! 666: } ! 667: ! 668: /* ! 669: * After a routing change, flush old routing ! 670: * and allocate a (hopefully) better one. ! 671: */ ! 672: void ! 673: in_rtchange(inp, errno) ! 674: register struct inpcb *inp; ! 675: int errno; ! 676: { ! 677: if (inp->inp_route.ro_rt) { ! 678: rtfree(inp->inp_route.ro_rt); ! 679: inp->inp_route.ro_rt = 0; ! 680: /* ! 681: * A new route can be allocated the next time ! 682: * output is attempted. ! 683: */ ! 684: } ! 685: } ! 686: ! 687: struct inpcb * ! 688: in_pcblookup(head, faddr, fport_arg, laddr, lport_arg, flags) ! 689: struct inpcb *head; ! 690: struct in_addr faddr, laddr; ! 691: u_int fport_arg, lport_arg; ! 692: int flags; ! 693: { ! 694: register struct inpcb *inp, *match = 0; ! 695: int matchwild = 3, wildcard; ! 696: u_short fport = fport_arg, lport = lport_arg; ! 697: #if KDEBUG ! 698: register int checked = 0; ! 699: #endif ! 700: KERNEL_DEBUG(DBG_FNC_PCB_LOOKUP | DBG_FUNC_START, 0,0,0,0,0); ! 701: ! 702: for (inp = head->inp_next; inp != head; inp = inp->inp_next) { ! 703: #if KDEBUG ! 704: checked++; ! 705: #endif ! 706: if (inp->inp_lport != lport) ! 707: continue; ! 708: wildcard = 0; ! 709: if (inp->inp_laddr.s_addr != INADDR_ANY) { ! 710: if (laddr.s_addr == INADDR_ANY) ! 711: wildcard++; ! 712: else if (inp->inp_laddr.s_addr != laddr.s_addr) ! 713: continue; ! 714: } else { ! 715: if (laddr.s_addr != INADDR_ANY) ! 716: wildcard++; ! 717: } ! 718: if (inp->inp_faddr.s_addr != INADDR_ANY) { ! 719: if (faddr.s_addr == INADDR_ANY) ! 720: wildcard++; ! 721: else if (inp->inp_faddr.s_addr != faddr.s_addr || ! 722: inp->inp_fport != fport) ! 723: continue; ! 724: } else { ! 725: if (faddr.s_addr != INADDR_ANY) ! 726: wildcard++; ! 727: } ! 728: if (wildcard && (flags & INPLOOKUP_WILDCARD) == 0) ! 729: continue; ! 730: if (wildcard < matchwild) { ! 731: match = inp; ! 732: matchwild = wildcard; ! 733: if (matchwild == 0) ! 734: break; ! 735: } ! 736: } ! 737: #if KDEBUG ! 738: KERNEL_DEBUG(DBG_FNC_PCB_LOOKUP | DBG_FUNC_END, checked,match,0,0,0); ! 739: #endif ! 740: return (match); ! 741: } ! 742: ! 743: ! 744: ! 745: struct inpcb * ! 746: hash_in_pcbwild(head, faddr, fport_arg, laddr, lport_arg, flags) ! 747: struct inpcb *head; ! 748: struct in_addr faddr, laddr; ! 749: u_int fport_arg, lport_arg; ! 750: int flags; ! 751: { ! 752: register struct inpcb *inp, *match = 0; ! 753: int matchwild = 3, wildcard; ! 754: u_short fport = fport_arg, lport = lport_arg; ! 755: #if KDEBUG ! 756: register int checked = 0; ! 757: #endif ! 758: ! 759: KERNEL_DEBUG(DBG_FNC_PCB_LOOKUP | DBG_FUNC_START, 0,0,0,0,-1); ! 760: ! 761: for (inp = head; inp != 0; inp = inp->hash_next) { ! 762: #if KDEBUG ! 763: checked++; ! 764: #endif ! 765: if (inp->inp_lport != lport) ! 766: continue; ! 767: wildcard = 0; ! 768: if (inp->inp_laddr.s_addr != INADDR_ANY) { ! 769: if (laddr.s_addr == INADDR_ANY) ! 770: wildcard++; ! 771: else if (inp->inp_laddr.s_addr != laddr.s_addr) ! 772: continue; ! 773: } else { ! 774: if (laddr.s_addr != INADDR_ANY) ! 775: wildcard++; ! 776: } ! 777: if (inp->inp_faddr.s_addr != INADDR_ANY) { ! 778: if (faddr.s_addr == INADDR_ANY) ! 779: wildcard++; ! 780: else if (inp->inp_faddr.s_addr != faddr.s_addr || ! 781: inp->inp_fport != fport) ! 782: continue; ! 783: } else { ! 784: if (faddr.s_addr != INADDR_ANY) ! 785: wildcard++; ! 786: } ! 787: if (wildcard && (flags & INPLOOKUP_WILDCARD) == 0) ! 788: continue; ! 789: if (wildcard < matchwild) { ! 790: match = inp; ! 791: matchwild = wildcard; ! 792: if (matchwild == 0) ! 793: break; ! 794: } ! 795: } ! 796: #if KDEBUG ! 797: KERNEL_DEBUG(DBG_FNC_PCB_LOOKUP | DBG_FUNC_END, checked,match,0,0,-1); ! 798: #endif ! 799: return (match); ! 800: } ! 801: ! 802: ! 803: ! 804: struct inpcb * ! 805: lport_hash_in_pcbwild(head, faddr, fport_arg, laddr, lport_arg, flags) ! 806: struct inpcb *head; ! 807: struct in_addr faddr, laddr; ! 808: u_int fport_arg, lport_arg; ! 809: int flags; ! 810: { ! 811: register struct inpcb *inp, *match = 0; ! 812: int matchwild = 3, wildcard; ! 813: u_short fport = fport_arg, lport = lport_arg; ! 814: #if KDEBUG ! 815: register int checked = 0; ! 816: #endif ! 817: ! 818: KERNEL_DEBUG(DBG_FNC_PCB_LOOKUP | DBG_FUNC_START, 0,0,0,0,-1); ! 819: ! 820: for (inp = head; inp != 0; inp = inp->lport_hash_next) { ! 821: #if KDEBUG ! 822: checked++; ! 823: #endif ! 824: if (inp->inp_lport != lport) ! 825: continue; ! 826: wildcard = 0; ! 827: if (inp->inp_laddr.s_addr != INADDR_ANY) { ! 828: if (laddr.s_addr == INADDR_ANY) ! 829: wildcard++; ! 830: else if (inp->inp_laddr.s_addr != laddr.s_addr) ! 831: continue; ! 832: } else { ! 833: if (laddr.s_addr != INADDR_ANY) ! 834: wildcard++; ! 835: } ! 836: if (inp->inp_faddr.s_addr != INADDR_ANY) { ! 837: if (faddr.s_addr == INADDR_ANY) ! 838: wildcard++; ! 839: else if (inp->inp_faddr.s_addr != faddr.s_addr || ! 840: inp->inp_fport != fport) ! 841: continue; ! 842: } else { ! 843: if (faddr.s_addr != INADDR_ANY) ! 844: wildcard++; ! 845: } ! 846: if (wildcard && (flags & INPLOOKUP_WILDCARD) == 0) ! 847: continue; ! 848: if (wildcard < matchwild) { ! 849: match = inp; ! 850: matchwild = wildcard; ! 851: if (matchwild == 0) ! 852: break; ! 853: } ! 854: } ! 855: #if KDEBUG ! 856: KERNEL_DEBUG(DBG_FNC_PCB_LOOKUP | DBG_FUNC_END, checked,match,0,0,-1); ! 857: #endif ! 858: return (match); ! 859: } ! 860: ! 861: ! 862: ! 863: ! 864: ! 865: struct inpcb * ! 866: hash_in_pcblookup(head, faddr, fport_arg, laddr, lport_arg) ! 867: struct inpcb *head; ! 868: struct in_addr faddr, laddr; ! 869: u_int fport_arg, lport_arg; ! 870: { ! 871: register struct inpcb *inp; ! 872: u_short fport = fport_arg, lport = lport_arg; ! 873: #if KDEBUG ! 874: register int checked = 0; ! 875: #endif ! 876: KERNEL_DEBUG(DBG_FNC_PCB_HLOOKUP | DBG_FUNC_START, 0,0,0,0,0); ! 877: ! 878: for (inp = head; inp != 0; inp = inp->hash_next) { ! 879: #if KDEBUG ! 880: checked++; ! 881: #endif ! 882: if (inp->inp_lport == lport && inp->inp_laddr.s_addr == laddr.s_addr && ! 883: inp->inp_faddr.s_addr == faddr.s_addr && inp->inp_fport == fport) ! 884: break; ! 885: } ! 886: #if KDEBUG ! 887: KERNEL_DEBUG(DBG_FNC_PCB_HLOOKUP | DBG_FUNC_END, checked,inp,0,0,0); ! 888: #endif ! 889: return (inp); ! 890: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.