Annotation of sys/netinet/in_pcb.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: in_pcb.c,v 1.89 2007/04/10 17:47:55 miod Exp $ */
! 2: /* $NetBSD: in_pcb.c,v 1.25 1996/02/13 23:41:53 christos Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1982, 1986, 1991, 1993
! 6: * The Regents of the University of California. All rights reserved.
! 7: *
! 8: * Redistribution and use in source and binary forms, with or without
! 9: * modification, are permitted provided that the following conditions
! 10: * are met:
! 11: * 1. Redistributions of source code must retain the above copyright
! 12: * notice, this list of conditions and the following disclaimer.
! 13: * 2. Redistributions in binary form must reproduce the above copyright
! 14: * notice, this list of conditions and the following disclaimer in the
! 15: * documentation and/or other materials provided with the distribution.
! 16: * 3. Neither the name of the University nor the names of its contributors
! 17: * may be used to endorse or promote products derived from this software
! 18: * without specific prior written permission.
! 19: *
! 20: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 21: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 22: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 23: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 24: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 25: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 26: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 27: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 28: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 29: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 30: * SUCH DAMAGE.
! 31: *
! 32: * @(#)COPYRIGHT 1.1 (NRL) 17 January 1995
! 33: *
! 34: * NRL grants permission for redistribution and use in source and binary
! 35: * forms, with or without modification, of the software and documentation
! 36: * created at NRL provided that the following conditions are met:
! 37: *
! 38: * 1. Redistributions of source code must retain the above copyright
! 39: * notice, this list of conditions and the following disclaimer.
! 40: * 2. Redistributions in binary form must reproduce the above copyright
! 41: * notice, this list of conditions and the following disclaimer in the
! 42: * documentation and/or other materials provided with the distribution.
! 43: * 3. All advertising materials mentioning features or use of this software
! 44: * must display the following acknowledgements:
! 45: * This product includes software developed by the University of
! 46: * California, Berkeley and its contributors.
! 47: * This product includes software developed at the Information
! 48: * Technology Division, US Naval Research Laboratory.
! 49: * 4. Neither the name of the NRL nor the names of its contributors
! 50: * may be used to endorse or promote products derived from this software
! 51: * without specific prior written permission.
! 52: *
! 53: * THE SOFTWARE PROVIDED BY NRL IS PROVIDED BY NRL AND CONTRIBUTORS ``AS
! 54: * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
! 55: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
! 56: * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NRL OR
! 57: * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
! 58: * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
! 59: * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
! 60: * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
! 61: * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
! 62: * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
! 63: * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 64: *
! 65: * The views and conclusions contained in the software and documentation
! 66: * are those of the authors and should not be interpreted as representing
! 67: * official policies, either expressed or implied, of the US Naval
! 68: * Research Laboratory (NRL).
! 69: */
! 70:
! 71: #include <sys/param.h>
! 72: #include <sys/systm.h>
! 73: #include <sys/mbuf.h>
! 74: #include <sys/protosw.h>
! 75: #include <sys/socket.h>
! 76: #include <sys/socketvar.h>
! 77: #include <sys/proc.h>
! 78: #include <sys/domain.h>
! 79:
! 80: #include <net/if.h>
! 81: #include <net/route.h>
! 82:
! 83: #include <netinet/in.h>
! 84: #include <netinet/in_systm.h>
! 85: #include <netinet/ip.h>
! 86: #include <netinet/in_pcb.h>
! 87: #include <netinet/in_var.h>
! 88: #include <netinet/ip_var.h>
! 89: #include <dev/rndvar.h>
! 90:
! 91: #include <sys/mount.h>
! 92: #include <nfs/nfsproto.h>
! 93:
! 94: #ifdef INET6
! 95: #include <netinet6/ip6_var.h>
! 96: #endif /* INET6 */
! 97: #ifdef IPSEC
! 98: #include <netinet/ip_esp.h>
! 99: #endif /* IPSEC */
! 100:
! 101: struct in_addr zeroin_addr;
! 102:
! 103: extern int ipsec_auth_default_level;
! 104: extern int ipsec_esp_trans_default_level;
! 105: extern int ipsec_esp_network_default_level;
! 106: extern int ipsec_ipcomp_default_level;
! 107:
! 108: /*
! 109: * These configure the range of local port addresses assigned to
! 110: * "unspecified" outgoing connections/packets/whatever.
! 111: */
! 112: int ipport_firstauto = IPPORT_RESERVED;
! 113: int ipport_lastauto = IPPORT_USERRESERVED;
! 114: int ipport_hifirstauto = IPPORT_HIFIRSTAUTO;
! 115: int ipport_hilastauto = IPPORT_HILASTAUTO;
! 116:
! 117: struct pool inpcb_pool;
! 118: int inpcb_pool_initalized = 0;
! 119:
! 120: #define INPCBHASH(table, faddr, fport, laddr, lport) \
! 121: &(table)->inpt_hashtbl[(ntohl((faddr)->s_addr) + \
! 122: ntohs((fport)) + ntohs((lport))) & (table->inpt_hash)]
! 123:
! 124: #define IN6PCBHASH(table, faddr, fport, laddr, lport) \
! 125: &(table)->inpt_hashtbl[(ntohl((faddr)->s6_addr32[0] ^ \
! 126: (faddr)->s6_addr32[3]) + ntohs((fport)) + ntohs((lport))) & \
! 127: (table->inpt_hash)]
! 128:
! 129: #define INPCBLHASH(table, lport) \
! 130: &(table)->inpt_lhashtbl[lport & table->inpt_lhash]
! 131:
! 132: void
! 133: in_pcbinit(table, hashsize)
! 134: struct inpcbtable *table;
! 135: int hashsize;
! 136: {
! 137:
! 138: CIRCLEQ_INIT(&table->inpt_queue);
! 139: table->inpt_hashtbl = hashinit(hashsize, M_PCB, M_NOWAIT,
! 140: &table->inpt_hash);
! 141: if (table->inpt_hashtbl == NULL)
! 142: panic("in_pcbinit: hashinit failed");
! 143: table->inpt_lhashtbl = hashinit(hashsize, M_PCB, M_NOWAIT,
! 144: &table->inpt_lhash);
! 145: if (table->inpt_lhashtbl == NULL)
! 146: panic("in_pcbinit: hashinit failed for lport");
! 147: table->inpt_lastport = 0;
! 148: }
! 149:
! 150: struct baddynamicports baddynamicports;
! 151:
! 152: /*
! 153: * Check if the specified port is invalid for dynamic allocation.
! 154: */
! 155: int
! 156: in_baddynamic(port, proto)
! 157: u_int16_t port;
! 158: u_int16_t proto;
! 159: {
! 160:
! 161:
! 162: switch (proto) {
! 163: case IPPROTO_TCP:
! 164: if (port == NFS_PORT)
! 165: return (1);
! 166: if (port < IPPORT_RESERVED/2 || port >= IPPORT_RESERVED)
! 167: return (0);
! 168: return (DP_ISSET(baddynamicports.tcp, port));
! 169: case IPPROTO_UDP:
! 170: #ifdef IPSEC
! 171: if (port == udpencap_port)
! 172: return (1);
! 173: #endif
! 174: if (port == NFS_PORT)
! 175: return (1);
! 176: if (port < IPPORT_RESERVED/2 || port >= IPPORT_RESERVED)
! 177: return (0);
! 178: return (DP_ISSET(baddynamicports.udp, port));
! 179: default:
! 180: return (0);
! 181: }
! 182: }
! 183:
! 184: int
! 185: in_pcballoc(so, v)
! 186: struct socket *so;
! 187: void *v;
! 188: {
! 189: struct inpcbtable *table = v;
! 190: struct inpcb *inp;
! 191: int s;
! 192:
! 193: if (inpcb_pool_initalized == 0) {
! 194: pool_init(&inpcb_pool, sizeof(struct inpcb), 0, 0, 0,
! 195: "inpcbpl", NULL);
! 196: inpcb_pool_initalized = 1;
! 197: }
! 198: inp = pool_get(&inpcb_pool, PR_NOWAIT);
! 199: if (inp == NULL)
! 200: return (ENOBUFS);
! 201: bzero((caddr_t)inp, sizeof(*inp));
! 202: inp->inp_table = table;
! 203: inp->inp_socket = so;
! 204: inp->inp_seclevel[SL_AUTH] = ipsec_auth_default_level;
! 205: inp->inp_seclevel[SL_ESP_TRANS] = ipsec_esp_trans_default_level;
! 206: inp->inp_seclevel[SL_ESP_NETWORK] = ipsec_esp_network_default_level;
! 207: inp->inp_seclevel[SL_IPCOMP] = ipsec_ipcomp_default_level;
! 208: s = splnet();
! 209: CIRCLEQ_INSERT_HEAD(&table->inpt_queue, inp, inp_queue);
! 210: LIST_INSERT_HEAD(INPCBLHASH(table, inp->inp_lport), inp, inp_lhash);
! 211: LIST_INSERT_HEAD(INPCBHASH(table, &inp->inp_faddr, inp->inp_fport,
! 212: &inp->inp_laddr, inp->inp_lport), inp, inp_hash);
! 213: splx(s);
! 214: so->so_pcb = inp;
! 215: inp->inp_hops = -1;
! 216:
! 217: #ifdef INET6
! 218: /*
! 219: * Small change in this function to set the INP_IPV6 flag so routines
! 220: * outside pcb-specific routines don't need to use sotopf(), and all
! 221: * of its pointer chasing, later.
! 222: */
! 223: if (sotopf(so) == PF_INET6)
! 224: inp->inp_flags = INP_IPV6;
! 225: inp->in6p_cksum = -1;
! 226: #endif /* INET6 */
! 227: return (0);
! 228: }
! 229:
! 230: int
! 231: in_pcbbind(v, nam)
! 232: void *v;
! 233: struct mbuf *nam;
! 234: {
! 235: struct inpcb *inp = v;
! 236: struct socket *so = inp->inp_socket;
! 237: struct inpcbtable *table = inp->inp_table;
! 238: u_int16_t *lastport = &inp->inp_table->inpt_lastport;
! 239: struct sockaddr_in *sin;
! 240: struct proc *p = curproc; /* XXX */
! 241: u_int16_t lport = 0;
! 242: int wild = 0, reuseport = (so->so_options & SO_REUSEPORT);
! 243: int error;
! 244:
! 245: #ifdef INET6
! 246: if (sotopf(so) == PF_INET6)
! 247: return in6_pcbbind(inp, nam);
! 248: #endif /* INET6 */
! 249:
! 250: if (TAILQ_EMPTY(&in_ifaddr))
! 251: return (EADDRNOTAVAIL);
! 252: if (inp->inp_lport || inp->inp_laddr.s_addr != INADDR_ANY)
! 253: return (EINVAL);
! 254: if ((so->so_options & (SO_REUSEADDR|SO_REUSEPORT)) == 0 &&
! 255: ((so->so_proto->pr_flags & PR_CONNREQUIRED) == 0 ||
! 256: (so->so_options & SO_ACCEPTCONN) == 0))
! 257: wild = INPLOOKUP_WILDCARD;
! 258: if (nam) {
! 259: sin = mtod(nam, struct sockaddr_in *);
! 260: if (nam->m_len != sizeof (*sin))
! 261: return (EINVAL);
! 262: #ifdef notdef
! 263: /*
! 264: * We should check the family, but old programs
! 265: * incorrectly fail to initialize it.
! 266: */
! 267: if (sin->sin_family != AF_INET)
! 268: return (EAFNOSUPPORT);
! 269: #endif
! 270: lport = sin->sin_port;
! 271: if (IN_MULTICAST(sin->sin_addr.s_addr)) {
! 272: /*
! 273: * Treat SO_REUSEADDR as SO_REUSEPORT for multicast;
! 274: * allow complete duplication of binding if
! 275: * SO_REUSEPORT is set, or if SO_REUSEADDR is set
! 276: * and a multicast address is bound on both
! 277: * new and duplicated sockets.
! 278: */
! 279: if (so->so_options & SO_REUSEADDR)
! 280: reuseport = SO_REUSEADDR|SO_REUSEPORT;
! 281: } else if (sin->sin_addr.s_addr != INADDR_ANY) {
! 282: sin->sin_port = 0; /* yech... */
! 283: if (in_iawithaddr(sin->sin_addr, NULL) == 0)
! 284: return (EADDRNOTAVAIL);
! 285: }
! 286: if (lport) {
! 287: struct inpcb *t;
! 288:
! 289: /* GROSS */
! 290: if (ntohs(lport) < IPPORT_RESERVED &&
! 291: (error = suser(p, 0)))
! 292: return (EACCES);
! 293: if (so->so_euid) {
! 294: t = in_pcblookup(table, &zeroin_addr, 0,
! 295: &sin->sin_addr, lport, INPLOOKUP_WILDCARD);
! 296: if (t && (so->so_euid != t->inp_socket->so_euid))
! 297: return (EADDRINUSE);
! 298: }
! 299: t = in_pcblookup(table, &zeroin_addr, 0,
! 300: &sin->sin_addr, lport, wild);
! 301: if (t && (reuseport & t->inp_socket->so_options) == 0)
! 302: return (EADDRINUSE);
! 303: }
! 304: inp->inp_laddr = sin->sin_addr;
! 305: }
! 306: if (lport == 0) {
! 307: u_int16_t first, last;
! 308: int count;
! 309:
! 310: if (inp->inp_flags & INP_HIGHPORT) {
! 311: first = ipport_hifirstauto; /* sysctl */
! 312: last = ipport_hilastauto;
! 313: } else if (inp->inp_flags & INP_LOWPORT) {
! 314: if ((error = suser(p, 0)))
! 315: return (EACCES);
! 316: first = IPPORT_RESERVED-1; /* 1023 */
! 317: last = 600; /* not IPPORT_RESERVED/2 */
! 318: } else {
! 319: first = ipport_firstauto; /* sysctl */
! 320: last = ipport_lastauto;
! 321: }
! 322:
! 323: /*
! 324: * Simple check to ensure all ports are not used up causing
! 325: * a deadlock here.
! 326: *
! 327: * We split the two cases (up and down) so that the direction
! 328: * is not being tested on each round of the loop.
! 329: */
! 330:
! 331: if (first > last) {
! 332: /*
! 333: * counting down
! 334: */
! 335: count = first - last;
! 336: if (count)
! 337: *lastport = first - (arc4random() % count);
! 338:
! 339: do {
! 340: if (count-- < 0) /* completely used? */
! 341: return (EADDRNOTAVAIL);
! 342: --*lastport;
! 343: if (*lastport > first || *lastport < last)
! 344: *lastport = first;
! 345: lport = htons(*lastport);
! 346: } while (in_baddynamic(*lastport, so->so_proto->pr_protocol) ||
! 347: in_pcblookup(table, &zeroin_addr, 0,
! 348: &inp->inp_laddr, lport, wild));
! 349: } else {
! 350: /*
! 351: * counting up
! 352: */
! 353: count = last - first;
! 354: if (count)
! 355: *lastport = first + (arc4random() % count);
! 356:
! 357: do {
! 358: if (count-- < 0) /* completely used? */
! 359: return (EADDRNOTAVAIL);
! 360: ++*lastport;
! 361: if (*lastport < first || *lastport > last)
! 362: *lastport = first;
! 363: lport = htons(*lastport);
! 364: } while (in_baddynamic(*lastport, so->so_proto->pr_protocol) ||
! 365: in_pcblookup(table, &zeroin_addr, 0,
! 366: &inp->inp_laddr, lport, wild));
! 367: }
! 368: }
! 369: inp->inp_lport = lport;
! 370: in_pcbrehash(inp);
! 371: return (0);
! 372: }
! 373:
! 374: /*
! 375: * Connect from a socket to a specified address.
! 376: * Both address and port must be specified in argument sin.
! 377: * If don't have a local address for this socket yet,
! 378: * then pick one.
! 379: */
! 380: int
! 381: in_pcbconnect(v, nam)
! 382: void *v;
! 383: struct mbuf *nam;
! 384: {
! 385: struct inpcb *inp = v;
! 386: struct sockaddr_in *ifaddr = NULL;
! 387: struct sockaddr_in *sin = mtod(nam, struct sockaddr_in *);
! 388:
! 389: #ifdef INET6
! 390: if (sotopf(inp->inp_socket) == PF_INET6)
! 391: return (in6_pcbconnect(inp, nam));
! 392: if ((inp->inp_flags & INP_IPV6) != 0)
! 393: panic("IPv6 pcb passed into in_pcbconnect");
! 394: #endif /* INET6 */
! 395:
! 396: if (nam->m_len != sizeof (*sin))
! 397: return (EINVAL);
! 398: if (sin->sin_family != AF_INET)
! 399: return (EAFNOSUPPORT);
! 400: if (sin->sin_port == 0)
! 401: return (EADDRNOTAVAIL);
! 402: if (!TAILQ_EMPTY(&in_ifaddr)) {
! 403: /*
! 404: * If the destination address is INADDR_ANY,
! 405: * use the primary local address.
! 406: * If the supplied address is INADDR_BROADCAST,
! 407: * and the primary interface supports broadcast,
! 408: * choose the broadcast address for that interface.
! 409: */
! 410: if (sin->sin_addr.s_addr == INADDR_ANY)
! 411: sin->sin_addr = TAILQ_FIRST(&in_ifaddr)->ia_addr.sin_addr;
! 412: else if (sin->sin_addr.s_addr == INADDR_BROADCAST &&
! 413: (TAILQ_FIRST(&in_ifaddr)->ia_ifp->if_flags & IFF_BROADCAST))
! 414: sin->sin_addr = TAILQ_FIRST(&in_ifaddr)->ia_broadaddr.sin_addr;
! 415: }
! 416: if (inp->inp_laddr.s_addr == INADDR_ANY) {
! 417: int error;
! 418: ifaddr = in_selectsrc(sin, &inp->inp_route,
! 419: inp->inp_socket->so_options, inp->inp_moptions, &error);
! 420: if (ifaddr == NULL) {
! 421: if (error == 0)
! 422: error = EADDRNOTAVAIL;
! 423: return error;
! 424: }
! 425: }
! 426: if (in_pcbhashlookup(inp->inp_table, sin->sin_addr, sin->sin_port,
! 427: inp->inp_laddr.s_addr ? inp->inp_laddr : ifaddr->sin_addr,
! 428: inp->inp_lport) != 0)
! 429: return (EADDRINUSE);
! 430: if (inp->inp_laddr.s_addr == INADDR_ANY) {
! 431: if (inp->inp_lport == 0 &&
! 432: in_pcbbind(inp, (struct mbuf *)0) == EADDRNOTAVAIL)
! 433: return (EADDRNOTAVAIL);
! 434: inp->inp_laddr = ifaddr->sin_addr;
! 435: }
! 436: inp->inp_faddr = sin->sin_addr;
! 437: inp->inp_fport = sin->sin_port;
! 438: in_pcbrehash(inp);
! 439: #ifdef IPSEC
! 440: {
! 441: int error; /* This is just ignored */
! 442:
! 443: /* Cause an IPsec SA to be established. */
! 444: ipsp_spd_inp(NULL, AF_INET, 0, &error, IPSP_DIRECTION_OUT,
! 445: NULL, inp, NULL);
! 446: }
! 447: #endif
! 448: return (0);
! 449: }
! 450:
! 451: void
! 452: in_pcbdisconnect(v)
! 453: void *v;
! 454: {
! 455: struct inpcb *inp = v;
! 456:
! 457: switch (sotopf(inp->inp_socket)) {
! 458: #ifdef INET6
! 459: case PF_INET6:
! 460: inp->inp_faddr6 = in6addr_any;
! 461: break;
! 462: #endif
! 463: case PF_INET:
! 464: inp->inp_faddr.s_addr = INADDR_ANY;
! 465: break;
! 466: }
! 467:
! 468: inp->inp_fport = 0;
! 469: in_pcbrehash(inp);
! 470: if (inp->inp_socket->so_state & SS_NOFDREF)
! 471: in_pcbdetach(inp);
! 472: }
! 473:
! 474: void
! 475: in_pcbdetach(v)
! 476: void *v;
! 477: {
! 478: struct inpcb *inp = v;
! 479: struct socket *so = inp->inp_socket;
! 480: int s;
! 481:
! 482: so->so_pcb = 0;
! 483: sofree(so);
! 484: if (inp->inp_options)
! 485: (void)m_freem(inp->inp_options);
! 486: if (inp->inp_route.ro_rt)
! 487: rtfree(inp->inp_route.ro_rt);
! 488: #ifdef INET6
! 489: if (inp->inp_flags & INP_IPV6)
! 490: ip6_freemoptions(inp->inp_moptions6);
! 491: else
! 492: #endif
! 493: ip_freemoptions(inp->inp_moptions);
! 494: #ifdef IPSEC
! 495: /* IPsec cleanup here */
! 496: s = spltdb();
! 497: if (inp->inp_tdb_in)
! 498: TAILQ_REMOVE(&inp->inp_tdb_in->tdb_inp_in,
! 499: inp, inp_tdb_in_next);
! 500: if (inp->inp_tdb_out)
! 501: TAILQ_REMOVE(&inp->inp_tdb_out->tdb_inp_out, inp,
! 502: inp_tdb_out_next);
! 503: if (inp->inp_ipsec_remotecred)
! 504: ipsp_reffree(inp->inp_ipsec_remotecred);
! 505: if (inp->inp_ipsec_remoteauth)
! 506: ipsp_reffree(inp->inp_ipsec_remoteauth);
! 507: if (inp->inp_ipo)
! 508: ipsec_delete_policy(inp->inp_ipo);
! 509: splx(s);
! 510: #endif
! 511: s = splnet();
! 512: LIST_REMOVE(inp, inp_lhash);
! 513: LIST_REMOVE(inp, inp_hash);
! 514: CIRCLEQ_REMOVE(&inp->inp_table->inpt_queue, inp, inp_queue);
! 515: splx(s);
! 516: pool_put(&inpcb_pool, inp);
! 517: }
! 518:
! 519: void
! 520: in_setsockaddr(inp, nam)
! 521: struct inpcb *inp;
! 522: struct mbuf *nam;
! 523: {
! 524: struct sockaddr_in *sin;
! 525:
! 526: nam->m_len = sizeof (*sin);
! 527: sin = mtod(nam, struct sockaddr_in *);
! 528: bzero((caddr_t)sin, sizeof (*sin));
! 529: sin->sin_family = AF_INET;
! 530: sin->sin_len = sizeof(*sin);
! 531: sin->sin_port = inp->inp_lport;
! 532: sin->sin_addr = inp->inp_laddr;
! 533: }
! 534:
! 535: void
! 536: in_setpeeraddr(inp, nam)
! 537: struct inpcb *inp;
! 538: struct mbuf *nam;
! 539: {
! 540: struct sockaddr_in *sin;
! 541:
! 542: #ifdef INET6
! 543: if (sotopf(inp->inp_socket) == PF_INET6) {
! 544: in6_setpeeraddr(inp, nam);
! 545: return;
! 546: }
! 547: #endif /* INET6 */
! 548:
! 549: nam->m_len = sizeof (*sin);
! 550: sin = mtod(nam, struct sockaddr_in *);
! 551: bzero((caddr_t)sin, sizeof (*sin));
! 552: sin->sin_family = AF_INET;
! 553: sin->sin_len = sizeof(*sin);
! 554: sin->sin_port = inp->inp_fport;
! 555: sin->sin_addr = inp->inp_faddr;
! 556: }
! 557:
! 558: /*
! 559: * Pass some notification to all connections of a protocol
! 560: * associated with address dst. The "usual action" will be
! 561: * taken, depending on the ctlinput cmd. The caller must filter any
! 562: * cmds that are uninteresting (e.g., no error in the map).
! 563: * Call the protocol specific routine (if any) to report
! 564: * any errors for each matching socket.
! 565: *
! 566: * Must be called at splsoftnet.
! 567: */
! 568: void
! 569: in_pcbnotifyall(table, dst, errno, notify)
! 570: struct inpcbtable *table;
! 571: struct sockaddr *dst;
! 572: int errno;
! 573: void (*notify)(struct inpcb *, int);
! 574: {
! 575: struct inpcb *inp, *oinp;
! 576: struct in_addr faddr;
! 577:
! 578: splassert(IPL_SOFTNET);
! 579:
! 580: #ifdef INET6
! 581: /*
! 582: * See in6_pcbnotify() for IPv6 codepath. By the time this
! 583: * gets called, the addresses passed are either definitely IPv4 or
! 584: * IPv6; *_pcbnotify() never gets called with v4-mapped v6 addresses.
! 585: */
! 586: #endif /* INET6 */
! 587:
! 588: if (dst->sa_family != AF_INET)
! 589: return;
! 590: faddr = satosin(dst)->sin_addr;
! 591: if (faddr.s_addr == INADDR_ANY)
! 592: return;
! 593:
! 594: for (inp = CIRCLEQ_FIRST(&table->inpt_queue);
! 595: inp != CIRCLEQ_END(&table->inpt_queue);) {
! 596: #ifdef INET6
! 597: if (inp->inp_flags & INP_IPV6) {
! 598: inp = CIRCLEQ_NEXT(inp, inp_queue);
! 599: continue;
! 600: }
! 601: #endif
! 602: if (inp->inp_faddr.s_addr != faddr.s_addr ||
! 603: inp->inp_socket == 0) {
! 604: inp = CIRCLEQ_NEXT(inp, inp_queue);
! 605: continue;
! 606: }
! 607: oinp = inp;
! 608: inp = CIRCLEQ_NEXT(inp, inp_queue);
! 609: if (notify)
! 610: (*notify)(oinp, errno);
! 611: }
! 612: }
! 613:
! 614: /*
! 615: * Check for alternatives when higher level complains
! 616: * about service problems. For now, invalidate cached
! 617: * routing information. If the route was created dynamically
! 618: * (by a redirect), time to try a default gateway again.
! 619: */
! 620: void
! 621: in_losing(inp)
! 622: struct inpcb *inp;
! 623: {
! 624: struct rtentry *rt;
! 625: struct rt_addrinfo info;
! 626:
! 627: if ((rt = inp->inp_route.ro_rt)) {
! 628: inp->inp_route.ro_rt = 0;
! 629: bzero((caddr_t)&info, sizeof(info));
! 630: info.rti_info[RTAX_DST] = &inp->inp_route.ro_dst;
! 631: info.rti_info[RTAX_GATEWAY] = rt->rt_gateway;
! 632: info.rti_info[RTAX_NETMASK] = rt_mask(rt);
! 633: rt_missmsg(RTM_LOSING, &info, rt->rt_flags, rt->rt_ifp, 0, 0);
! 634: if (rt->rt_flags & RTF_DYNAMIC)
! 635: (void) rtrequest(RTM_DELETE, rt_key(rt),
! 636: rt->rt_gateway, rt_mask(rt), rt->rt_flags,
! 637: (struct rtentry **)0, 0);
! 638: /*
! 639: * A new route can be allocated
! 640: * the next time output is attempted.
! 641: * rtfree() needs to be called in anycase because the inp
! 642: * is still holding a reference to rt.
! 643: */
! 644: rtfree(rt);
! 645: }
! 646: }
! 647:
! 648: /*
! 649: * After a routing change, flush old routing
! 650: * and allocate a (hopefully) better one.
! 651: */
! 652: void
! 653: in_rtchange(inp, errno)
! 654: struct inpcb *inp;
! 655: int errno;
! 656: {
! 657: if (inp->inp_route.ro_rt) {
! 658: rtfree(inp->inp_route.ro_rt);
! 659: inp->inp_route.ro_rt = 0;
! 660: /*
! 661: * A new route can be allocated the next time
! 662: * output is attempted.
! 663: */
! 664: }
! 665: }
! 666:
! 667: struct inpcb *
! 668: in_pcblookup(table, faddrp, fport_arg, laddrp, lport_arg, flags)
! 669: struct inpcbtable *table;
! 670: void *faddrp, *laddrp;
! 671: u_int fport_arg, lport_arg;
! 672: int flags;
! 673: {
! 674: struct inpcb *inp, *match = 0;
! 675: int matchwild = 3, wildcard;
! 676: u_int16_t fport = fport_arg, lport = lport_arg;
! 677: struct in_addr faddr = *(struct in_addr *)faddrp;
! 678: struct in_addr laddr = *(struct in_addr *)laddrp;
! 679:
! 680: for (inp = LIST_FIRST(INPCBLHASH(table, lport)); inp;
! 681: inp = LIST_NEXT(inp, inp_lhash)) {
! 682: if (inp->inp_lport != lport)
! 683: continue;
! 684: wildcard = 0;
! 685: #ifdef INET6
! 686: if (flags & INPLOOKUP_IPV6) {
! 687: struct in6_addr *laddr6 = (struct in6_addr *)laddrp;
! 688: struct in6_addr *faddr6 = (struct in6_addr *)faddrp;
! 689:
! 690: if (!(inp->inp_flags & INP_IPV6))
! 691: continue;
! 692:
! 693: if (!IN6_IS_ADDR_UNSPECIFIED(&inp->inp_laddr6)) {
! 694: if (IN6_IS_ADDR_UNSPECIFIED(laddr6))
! 695: wildcard++;
! 696: else if (!IN6_ARE_ADDR_EQUAL(&inp->inp_laddr6, laddr6))
! 697: continue;
! 698: } else {
! 699: if (!IN6_IS_ADDR_UNSPECIFIED(laddr6))
! 700: wildcard++;
! 701: }
! 702:
! 703: if (!IN6_IS_ADDR_UNSPECIFIED(&inp->inp_faddr6)) {
! 704: if (IN6_IS_ADDR_UNSPECIFIED(faddr6))
! 705: wildcard++;
! 706: else if (!IN6_ARE_ADDR_EQUAL(&inp->inp_faddr6,
! 707: faddr6) || inp->inp_fport != fport)
! 708: continue;
! 709: } else {
! 710: if (!IN6_IS_ADDR_UNSPECIFIED(faddr6))
! 711: wildcard++;
! 712: }
! 713: } else
! 714: #endif /* INET6 */
! 715: {
! 716: #ifdef INET6
! 717: if (inp->inp_flags & INP_IPV6)
! 718: continue;
! 719: #endif /* INET6 */
! 720:
! 721: if (inp->inp_faddr.s_addr != INADDR_ANY) {
! 722: if (faddr.s_addr == INADDR_ANY)
! 723: wildcard++;
! 724: else if (inp->inp_faddr.s_addr != faddr.s_addr ||
! 725: inp->inp_fport != fport)
! 726: continue;
! 727: } else {
! 728: if (faddr.s_addr != INADDR_ANY)
! 729: wildcard++;
! 730: }
! 731: if (inp->inp_laddr.s_addr != INADDR_ANY) {
! 732: if (laddr.s_addr == INADDR_ANY)
! 733: wildcard++;
! 734: else if (inp->inp_laddr.s_addr != laddr.s_addr)
! 735: continue;
! 736: } else {
! 737: if (laddr.s_addr != INADDR_ANY)
! 738: wildcard++;
! 739: }
! 740: }
! 741: if ((!wildcard || (flags & INPLOOKUP_WILDCARD)) &&
! 742: wildcard < matchwild) {
! 743: match = inp;
! 744: if ((matchwild = wildcard) == 0)
! 745: break;
! 746: }
! 747: }
! 748: return (match);
! 749: }
! 750:
! 751: struct rtentry *
! 752: in_pcbrtentry(inp)
! 753: struct inpcb *inp;
! 754: {
! 755: struct route *ro;
! 756:
! 757: ro = &inp->inp_route;
! 758:
! 759: /*
! 760: * No route yet, so try to acquire one.
! 761: */
! 762: if (ro->ro_rt == NULL) {
! 763: #ifdef INET6
! 764: bzero(ro, sizeof(struct route_in6));
! 765: #else
! 766: bzero(ro, sizeof(struct route));
! 767: #endif
! 768:
! 769: switch(sotopf(inp->inp_socket)) {
! 770: #ifdef INET6
! 771: case PF_INET6:
! 772: if (IN6_IS_ADDR_UNSPECIFIED(&inp->inp_faddr6))
! 773: break;
! 774: ro->ro_dst.sa_family = AF_INET6;
! 775: ro->ro_dst.sa_len = sizeof(struct sockaddr_in6);
! 776: ((struct sockaddr_in6 *) &ro->ro_dst)->sin6_addr =
! 777: inp->inp_faddr6;
! 778: rtalloc_mpath(ro, &inp->inp_laddr6.s6_addr32[0], 0);
! 779: break;
! 780: #endif /* INET6 */
! 781: case PF_INET:
! 782: if (inp->inp_faddr.s_addr == INADDR_ANY)
! 783: break;
! 784: ro->ro_dst.sa_family = AF_INET;
! 785: ro->ro_dst.sa_len = sizeof(ro->ro_dst);
! 786: satosin(&ro->ro_dst)->sin_addr = inp->inp_faddr;
! 787: rtalloc_mpath(ro, &inp->inp_laddr.s_addr, 0);
! 788: break;
! 789: }
! 790: }
! 791: return (ro->ro_rt);
! 792: }
! 793:
! 794: struct sockaddr_in *
! 795: in_selectsrc(sin, ro, soopts, mopts, errorp)
! 796: struct sockaddr_in *sin;
! 797: struct route *ro;
! 798: int soopts;
! 799: struct ip_moptions *mopts;
! 800: int *errorp;
! 801: {
! 802: struct sockaddr_in *sin2;
! 803: struct in_ifaddr *ia;
! 804:
! 805: ia = (struct in_ifaddr *)0;
! 806: /*
! 807: * If route is known or can be allocated now,
! 808: * our src addr is taken from the i/f, else punt.
! 809: */
! 810: if (ro->ro_rt &&
! 811: (satosin(&ro->ro_dst)->sin_addr.s_addr !=
! 812: sin->sin_addr.s_addr ||
! 813: soopts & SO_DONTROUTE)) {
! 814: RTFREE(ro->ro_rt);
! 815: ro->ro_rt = (struct rtentry *)0;
! 816: }
! 817: if ((soopts & SO_DONTROUTE) == 0 && /*XXX*/
! 818: (ro->ro_rt == (struct rtentry *)0 ||
! 819: ro->ro_rt->rt_ifp == (struct ifnet *)0)) {
! 820: /* No route yet, so try to acquire one */
! 821: ro->ro_dst.sa_family = AF_INET;
! 822: ro->ro_dst.sa_len = sizeof(struct sockaddr_in);
! 823: satosin(&ro->ro_dst)->sin_addr = sin->sin_addr;
! 824: rtalloc_mpath(ro, NULL, 0);
! 825:
! 826: /*
! 827: * It is important to bzero out the rest of the
! 828: * struct sockaddr_in when mixing v6 & v4!
! 829: */
! 830: sin2 = (struct sockaddr_in *)&ro->ro_dst;
! 831: bzero(sin2->sin_zero, sizeof(sin2->sin_zero));
! 832: }
! 833: /*
! 834: * If we found a route, use the address
! 835: * corresponding to the outgoing interface
! 836: * unless it is the loopback (in case a route
! 837: * to our address on another net goes to loopback).
! 838: */
! 839: if (ro->ro_rt && !(ro->ro_rt->rt_ifp->if_flags & IFF_LOOPBACK))
! 840: ia = ifatoia(ro->ro_rt->rt_ifa);
! 841: if (ia == 0) {
! 842: u_int16_t fport = sin->sin_port;
! 843:
! 844: sin->sin_port = 0;
! 845: ia = ifatoia(ifa_ifwithdstaddr(sintosa(sin)));
! 846: if (ia == 0)
! 847: ia = ifatoia(ifa_ifwithnet(sintosa(sin)));
! 848: sin->sin_port = fport;
! 849: if (ia == 0)
! 850: ia = TAILQ_FIRST(&in_ifaddr);
! 851: if (ia == 0) {
! 852: *errorp = EADDRNOTAVAIL;
! 853: return NULL;
! 854: }
! 855: }
! 856: /*
! 857: * If the destination address is multicast and an outgoing
! 858: * interface has been set as a multicast option, use the
! 859: * address of that interface as our source address.
! 860: */
! 861: if (IN_MULTICAST(sin->sin_addr.s_addr) && mopts != NULL) {
! 862: struct ip_moptions *imo;
! 863: struct ifnet *ifp;
! 864:
! 865: imo = mopts;
! 866: if (imo->imo_multicast_ifp != NULL) {
! 867: ifp = imo->imo_multicast_ifp;
! 868: TAILQ_FOREACH(ia, &in_ifaddr, ia_list)
! 869: if (ia->ia_ifp == ifp)
! 870: break;
! 871: if (ia == 0) {
! 872: *errorp = EADDRNOTAVAIL;
! 873: return NULL;
! 874: }
! 875: }
! 876: }
! 877: return satosin(&ia->ia_addr);
! 878: }
! 879:
! 880: void
! 881: in_pcbrehash(inp)
! 882: struct inpcb *inp;
! 883: {
! 884: struct inpcbtable *table = inp->inp_table;
! 885: int s;
! 886:
! 887: s = splnet();
! 888: LIST_REMOVE(inp, inp_lhash);
! 889: LIST_INSERT_HEAD(INPCBLHASH(table, inp->inp_lport), inp, inp_lhash);
! 890: LIST_REMOVE(inp, inp_hash);
! 891: #ifdef INET6
! 892: if (inp->inp_flags & INP_IPV6) {
! 893: LIST_INSERT_HEAD(IN6PCBHASH(table, &inp->inp_faddr6,
! 894: inp->inp_fport, &inp->inp_laddr6, inp->inp_lport),
! 895: inp, inp_hash);
! 896: } else {
! 897: #endif /* INET6 */
! 898: LIST_INSERT_HEAD(INPCBHASH(table, &inp->inp_faddr,
! 899: inp->inp_fport, &inp->inp_laddr, inp->inp_lport),
! 900: inp, inp_hash);
! 901: #ifdef INET6
! 902: }
! 903: #endif /* INET6 */
! 904: splx(s);
! 905: }
! 906:
! 907: #ifdef DIAGNOSTIC
! 908: int in_pcbnotifymiss = 0;
! 909: #endif
! 910:
! 911: /*
! 912: * The in(6)_pcbhashlookup functions are used to locate connected sockets
! 913: * quickly:
! 914: * faddr.fport <-> laddr.lport
! 915: * No wildcard matching is done so that listening sockets are not found.
! 916: * If the functions return NULL in(6)_pcblookup_listen can be used to
! 917: * find a listening/bound socket that may accept the connection.
! 918: * After those two lookups no other are necessary.
! 919: */
! 920: struct inpcb *
! 921: in_pcbhashlookup(table, faddr, fport_arg, laddr, lport_arg)
! 922: struct inpcbtable *table;
! 923: struct in_addr faddr, laddr;
! 924: u_int fport_arg, lport_arg;
! 925: {
! 926: struct inpcbhead *head;
! 927: struct inpcb *inp;
! 928: u_int16_t fport = fport_arg, lport = lport_arg;
! 929:
! 930: head = INPCBHASH(table, &faddr, fport, &laddr, lport);
! 931: LIST_FOREACH(inp, head, inp_hash) {
! 932: #ifdef INET6
! 933: if (inp->inp_flags & INP_IPV6)
! 934: continue; /*XXX*/
! 935: #endif
! 936: if (inp->inp_faddr.s_addr == faddr.s_addr &&
! 937: inp->inp_fport == fport &&
! 938: inp->inp_lport == lport &&
! 939: inp->inp_laddr.s_addr == laddr.s_addr) {
! 940: /*
! 941: * Move this PCB to the head of hash chain so that
! 942: * repeated accesses are quicker. This is analogous to
! 943: * the historic single-entry PCB cache.
! 944: */
! 945: if (inp != LIST_FIRST(head)) {
! 946: LIST_REMOVE(inp, inp_hash);
! 947: LIST_INSERT_HEAD(head, inp, inp_hash);
! 948: }
! 949: break;
! 950: }
! 951: }
! 952: #ifdef DIAGNOSTIC
! 953: if (inp == NULL && in_pcbnotifymiss) {
! 954: printf("in_pcbhashlookup: faddr=%08x fport=%d laddr=%08x lport=%d\n",
! 955: ntohl(faddr.s_addr), ntohs(fport),
! 956: ntohl(laddr.s_addr), ntohs(lport));
! 957: }
! 958: #endif
! 959: return (inp);
! 960: }
! 961:
! 962: #ifdef INET6
! 963: struct inpcb *
! 964: in6_pcbhashlookup(table, faddr, fport_arg, laddr, lport_arg)
! 965: struct inpcbtable *table;
! 966: struct in6_addr *faddr, *laddr;
! 967: u_int fport_arg, lport_arg;
! 968: {
! 969: struct inpcbhead *head;
! 970: struct inpcb *inp;
! 971: u_int16_t fport = fport_arg, lport = lport_arg;
! 972:
! 973: head = IN6PCBHASH(table, faddr, fport, laddr, lport);
! 974: LIST_FOREACH(inp, head, inp_hash) {
! 975: if (!(inp->inp_flags & INP_IPV6))
! 976: continue;
! 977: if (IN6_ARE_ADDR_EQUAL(&inp->inp_faddr6, faddr) &&
! 978: inp->inp_fport == fport && inp->inp_lport == lport &&
! 979: IN6_ARE_ADDR_EQUAL(&inp->inp_laddr6, laddr)) {
! 980: /*
! 981: * Move this PCB to the head of hash chain so that
! 982: * repeated accesses are quicker. This is analogous to
! 983: * the historic single-entry PCB cache.
! 984: */
! 985: if (inp != LIST_FIRST(head)) {
! 986: LIST_REMOVE(inp, inp_hash);
! 987: LIST_INSERT_HEAD(head, inp, inp_hash);
! 988: }
! 989: break;
! 990: }
! 991: }
! 992: #ifdef DIAGNOSTIC
! 993: if (inp == NULL && in_pcbnotifymiss) {
! 994: printf("in6_pcbhashlookup: faddr=");
! 995: printf(" fport=%d laddr=", ntohs(fport));
! 996: printf(" lport=%d\n", ntohs(lport));
! 997: }
! 998: #endif
! 999: return (inp);
! 1000: }
! 1001: #endif /* INET6 */
! 1002:
! 1003: /*
! 1004: * The in(6)_pcblookup_listen functions are used to locate listening
! 1005: * sockets quickly. This are sockets with unspecified foreign address
! 1006: * and port:
! 1007: * *.* <-> laddr.lport
! 1008: * *.* <-> *.lport
! 1009: */
! 1010: struct inpcb *
! 1011: in_pcblookup_listen(table, laddr, lport_arg, reverse)
! 1012: struct inpcbtable *table;
! 1013: struct in_addr laddr;
! 1014: u_int lport_arg;
! 1015: int reverse;
! 1016: {
! 1017: struct inpcbhead *head;
! 1018: struct in_addr *key1, *key2;
! 1019: struct inpcb *inp;
! 1020: u_int16_t lport = lport_arg;
! 1021:
! 1022: if (reverse) {
! 1023: key1 = &zeroin_addr;
! 1024: key2 = &laddr;
! 1025: } else {
! 1026: key1 = &laddr;
! 1027: key2 = &zeroin_addr;
! 1028: }
! 1029:
! 1030: head = INPCBHASH(table, &zeroin_addr, 0, key1, lport);
! 1031: LIST_FOREACH(inp, head, inp_hash) {
! 1032: #ifdef INET6
! 1033: if (inp->inp_flags & INP_IPV6)
! 1034: continue; /*XXX*/
! 1035: #endif
! 1036: if (inp->inp_lport == lport && inp->inp_fport == 0 &&
! 1037: inp->inp_laddr.s_addr == key1->s_addr &&
! 1038: inp->inp_faddr.s_addr == INADDR_ANY)
! 1039: break;
! 1040: }
! 1041: if (inp == NULL && key1->s_addr != key2->s_addr) {
! 1042: head = INPCBHASH(table, &zeroin_addr, 0, key2, lport);
! 1043: LIST_FOREACH(inp, head, inp_hash) {
! 1044: #ifdef INET6
! 1045: if (inp->inp_flags & INP_IPV6)
! 1046: continue; /*XXX*/
! 1047: #endif
! 1048: if (inp->inp_lport == lport && inp->inp_fport == 0 &&
! 1049: inp->inp_laddr.s_addr == key2->s_addr &&
! 1050: inp->inp_faddr.s_addr == INADDR_ANY)
! 1051: break;
! 1052: }
! 1053: }
! 1054: #ifdef DIAGNOSTIC
! 1055: if (inp == NULL && in_pcbnotifymiss) {
! 1056: printf("in_pcblookup_listen: laddr=%08x lport=%d\n",
! 1057: ntohl(laddr.s_addr), ntohs(lport));
! 1058: }
! 1059: #endif
! 1060: /*
! 1061: * Move this PCB to the head of hash chain so that
! 1062: * repeated accesses are quicker. This is analogous to
! 1063: * the historic single-entry PCB cache.
! 1064: */
! 1065: if (inp != NULL && inp != LIST_FIRST(head)) {
! 1066: LIST_REMOVE(inp, inp_hash);
! 1067: LIST_INSERT_HEAD(head, inp, inp_hash);
! 1068: }
! 1069: return (inp);
! 1070: }
! 1071:
! 1072: #ifdef INET6
! 1073: struct inpcb *
! 1074: in6_pcblookup_listen(table, laddr, lport_arg, reverse)
! 1075: struct inpcbtable *table;
! 1076: struct in6_addr *laddr;
! 1077: u_int lport_arg;
! 1078: int reverse;
! 1079: {
! 1080: struct inpcbhead *head;
! 1081: struct in6_addr *key1, *key2;
! 1082: struct inpcb *inp;
! 1083: u_int16_t lport = lport_arg;
! 1084:
! 1085: if (reverse) {
! 1086: key1 = &zeroin6_addr;
! 1087: key2 = laddr;
! 1088: } else {
! 1089: key1 = laddr;
! 1090: key2 = &zeroin6_addr;
! 1091: }
! 1092:
! 1093: head = IN6PCBHASH(table, &zeroin6_addr, 0, key1, lport);
! 1094: LIST_FOREACH(inp, head, inp_hash) {
! 1095: if (!(inp->inp_flags & INP_IPV6))
! 1096: continue;
! 1097: if (inp->inp_lport == lport && inp->inp_fport == 0 &&
! 1098: IN6_ARE_ADDR_EQUAL(&inp->inp_laddr6, key1) &&
! 1099: IN6_IS_ADDR_UNSPECIFIED(&inp->inp_faddr6))
! 1100: break;
! 1101: }
! 1102: if (inp == NULL && ! IN6_ARE_ADDR_EQUAL(key1, key2)) {
! 1103: head = IN6PCBHASH(table, &zeroin6_addr, 0, key2, lport);
! 1104: LIST_FOREACH(inp, head, inp_hash) {
! 1105: if (!(inp->inp_flags & INP_IPV6))
! 1106: continue;
! 1107: if (inp->inp_lport == lport && inp->inp_fport == 0 &&
! 1108: IN6_ARE_ADDR_EQUAL(&inp->inp_laddr6, key2) &&
! 1109: IN6_IS_ADDR_UNSPECIFIED(&inp->inp_faddr6))
! 1110: break;
! 1111: }
! 1112: }
! 1113: #ifdef DIAGNOSTIC
! 1114: if (inp == NULL && in_pcbnotifymiss) {
! 1115: printf("in6_pcblookup_listen: laddr= lport=%d\n",
! 1116: ntohs(lport));
! 1117: }
! 1118: #endif
! 1119: /*
! 1120: * Move this PCB to the head of hash chain so that
! 1121: * repeated accesses are quicker. This is analogous to
! 1122: * the historic single-entry PCB cache.
! 1123: */
! 1124: if (inp != NULL && inp != LIST_FIRST(head)) {
! 1125: LIST_REMOVE(inp, inp_hash);
! 1126: LIST_INSERT_HEAD(head, inp, inp_hash);
! 1127: }
! 1128: return (inp);
! 1129: }
! 1130: #endif /* INET6 */
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to in_pcb.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / netinet