sys/netinet/in_pcb.c

   1 /*-
   2  * Copyright (c) 1982, 1986, 1991, 1993, 1995
   3  *      The Regents of the University of California.
   4  * Copyright (c) 2007-2009 Robert N. M. Watson
   5  * Copyright (c) 2010-2011 Juniper Networks, Inc.
   6  * All rights reserved.
   7  *
   8  * Portions of this software were developed by Robert N. M. Watson under
   9  * contract to Juniper Networks, Inc.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 4. Neither the name of the University nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  *
  35  *      @(#)in_pcb.c    8.4 (Berkeley) 5/24/95
  36  */
  37
  38 #include <sys/cdefs.h>
  39 __FBSDID("$FreeBSD$");
  40
  41 #include "opt_ddb.h"
  42 #include "opt_ipsec.h"
  43 #include "opt_inet.h"
  44 #include "opt_inet6.h"
  45 #include "opt_pcbgroup.h"
  46 #include "opt_rss.h"
  47
  48 #include <sys/param.h>
  49 #include <sys/systm.h>
  50 #include <sys/malloc.h>
  51 #include <sys/mbuf.h>
  52 #include <sys/callout.h>
  53 #include <sys/domain.h>
  54 #include <sys/protosw.h>
  55 #include <sys/socket.h>
  56 #include <sys/socketvar.h>
  57 #include <sys/priv.h>
  58 #include <sys/proc.h>
  59 #include <sys/refcount.h>
  60 #include <sys/jail.h>
  61 #include <sys/kernel.h>
  62 #include <sys/sysctl.h>
  63
  64 #ifdef DDB
  65 #include <ddb/ddb.h>
  66 #endif
  67
  68 #include <vm/uma.h>
  69
  70 #include <net/if.h>
  71 #include <net/if_var.h>
  72 #include <net/if_types.h>
  73 #include <net/route.h>
  74 #include <net/vnet.h>
  75
  76 #if defined(INET) || defined(INET6)
  77 #include <netinet/in.h>
  78 #include <netinet/in_pcb.h>
  79 #include <netinet/in_rss.h>
  80 #include <netinet/ip_var.h>
  81 #include <netinet/tcp_var.h>
  82 #include <netinet/udp.h>
  83 #include <netinet/udp_var.h>
  84 #endif
  85 #ifdef INET
  86 #include <netinet/in_var.h>
  87 #endif
  88 #ifdef INET6
  89 #include <netinet/ip6.h>
  90 #include <netinet6/in6_pcb.h>
  91 #include <netinet6/in6_var.h>
  92 #include <netinet6/ip6_var.h>
  93 #endif /* INET6 */
  94
  95
  96 #ifdef IPSEC
  97 #include <netipsec/ipsec.h>
  98 #include <netipsec/key.h>
  99 #endif /* IPSEC */
 100
 101 #include <security/mac/mac_framework.h>
 102
 103 static struct callout   ipport_tick_callout;
 104
 105 /*
 106  * These configure the range of local port addresses assigned to
 107  * "unspecified" outgoing connections/packets/whatever.
 108  */
 109 VNET_DEFINE(int, ipport_lowfirstauto) = IPPORT_RESERVED - 1;    /* 1023 */
 110 VNET_DEFINE(int, ipport_lowlastauto) = IPPORT_RESERVEDSTART;    /* 600 */
 111 VNET_DEFINE(int, ipport_firstauto) = IPPORT_EPHEMERALFIRST;     /* 10000 */
 112 VNET_DEFINE(int, ipport_lastauto) = IPPORT_EPHEMERALLAST;       /* 65535 */
 113 VNET_DEFINE(int, ipport_hifirstauto) = IPPORT_HIFIRSTAUTO;      /* 49152 */
 114 VNET_DEFINE(int, ipport_hilastauto) = IPPORT_HILASTAUTO;        /* 65535 */
 115
 116 /*
 117  * Reserved ports accessible only to root. There are significant
 118  * security considerations that must be accounted for when changing these,
 119  * but the security benefits can be great. Please be careful.
 120  */
 121 VNET_DEFINE(int, ipport_reservedhigh) = IPPORT_RESERVED - 1;    /* 1023 */
 122 VNET_DEFINE(int, ipport_reservedlow);
 123
 124 /* Variables dealing with random ephemeral port allocation. */
 125 VNET_DEFINE(int, ipport_randomized) = 1;        /* user controlled via sysctl */
 126 VNET_DEFINE(int, ipport_randomcps) = 10;        /* user controlled via sysctl */
 127 VNET_DEFINE(int, ipport_randomtime) = 45;       /* user controlled via sysctl */
 128 VNET_DEFINE(int, ipport_stoprandom);            /* toggled by ipport_tick */
 129 VNET_DEFINE(int, ipport_tcpallocs);
 130 static VNET_DEFINE(int, ipport_tcplastcount);
 131
 132 #define V_ipport_tcplastcount           VNET(ipport_tcplastcount)
 133
 134 static void     in_pcbremlists(struct inpcb *inp);
 135 #ifdef INET
 136 static struct inpcb     *in_pcblookup_hash_locked(struct inpcbinfo *pcbinfo,
 137                             struct in_addr faddr, u_int fport_arg,
 138                             struct in_addr laddr, u_int lport_arg,
 139                             int lookupflags, struct ifnet *ifp);
 140
 141 #define RANGECHK(var, min, max) \
 142         if ((var) < (min)) { (var) = (min); } \
 143         else if ((var) > (max)) { (var) = (max); }
 144
 145 static int
 146 sysctl_net_ipport_check(SYSCTL_HANDLER_ARGS)
 147 {
 148         int error;
 149
 150         error = sysctl_handle_int(oidp, arg1, arg2, req);
 151         if (error == 0) {
 152                 RANGECHK(V_ipport_lowfirstauto, 1, IPPORT_RESERVED - 1);
 153                 RANGECHK(V_ipport_lowlastauto, 1, IPPORT_RESERVED - 1);
 154                 RANGECHK(V_ipport_firstauto, IPPORT_RESERVED, IPPORT_MAX);
 155                 RANGECHK(V_ipport_lastauto, IPPORT_RESERVED, IPPORT_MAX);
 156                 RANGECHK(V_ipport_hifirstauto, IPPORT_RESERVED, IPPORT_MAX);
 157                 RANGECHK(V_ipport_hilastauto, IPPORT_RESERVED, IPPORT_MAX);
 158         }
 159         return (error);
 160 }
 161
 162 #undef RANGECHK
 163
 164 static SYSCTL_NODE(_net_inet_ip, IPPROTO_IP, portrange, CTLFLAG_RW, 0,
 165     "IP Ports");
 166
 167 SYSCTL_VNET_PROC(_net_inet_ip_portrange, OID_AUTO, lowfirst,
 168         CTLTYPE_INT|CTLFLAG_RW, &VNET_NAME(ipport_lowfirstauto), 0,
 169         &sysctl_net_ipport_check, "I", "");
 170 SYSCTL_VNET_PROC(_net_inet_ip_portrange, OID_AUTO, lowlast,
 171         CTLTYPE_INT|CTLFLAG_RW, &VNET_NAME(ipport_lowlastauto), 0,
 172         &sysctl_net_ipport_check, "I", "");
 173 SYSCTL_VNET_PROC(_net_inet_ip_portrange, OID_AUTO, first,
 174         CTLTYPE_INT|CTLFLAG_RW, &VNET_NAME(ipport_firstauto), 0,
 175         &sysctl_net_ipport_check, "I", "");
 176 SYSCTL_VNET_PROC(_net_inet_ip_portrange, OID_AUTO, last,
 177         CTLTYPE_INT|CTLFLAG_RW, &VNET_NAME(ipport_lastauto), 0,
 178         &sysctl_net_ipport_check, "I", "");
 179 SYSCTL_VNET_PROC(_net_inet_ip_portrange, OID_AUTO, hifirst,
 180         CTLTYPE_INT|CTLFLAG_RW, &VNET_NAME(ipport_hifirstauto), 0,
 181         &sysctl_net_ipport_check, "I", "");
 182 SYSCTL_VNET_PROC(_net_inet_ip_portrange, OID_AUTO, hilast,
 183         CTLTYPE_INT|CTLFLAG_RW, &VNET_NAME(ipport_hilastauto), 0,
 184         &sysctl_net_ipport_check, "I", "");
 185 SYSCTL_VNET_INT(_net_inet_ip_portrange, OID_AUTO, reservedhigh,
 186         CTLFLAG_RW|CTLFLAG_SECURE, &VNET_NAME(ipport_reservedhigh), 0, "");
 187 SYSCTL_VNET_INT(_net_inet_ip_portrange, OID_AUTO, reservedlow,
 188         CTLFLAG_RW|CTLFLAG_SECURE, &VNET_NAME(ipport_reservedlow), 0, "");
 189 SYSCTL_VNET_INT(_net_inet_ip_portrange, OID_AUTO, randomized, CTLFLAG_RW,
 190         &VNET_NAME(ipport_randomized), 0, "Enable random port allocation");
 191 SYSCTL_VNET_INT(_net_inet_ip_portrange, OID_AUTO, randomcps, CTLFLAG_RW,
 192         &VNET_NAME(ipport_randomcps), 0, "Maximum number of random port "
 193         "allocations before switching to a sequental one");
 194 SYSCTL_VNET_INT(_net_inet_ip_portrange, OID_AUTO, randomtime, CTLFLAG_RW,
 195         &VNET_NAME(ipport_randomtime), 0,
 196         "Minimum time to keep sequental port "
 197         "allocation before switching to a random one");
 198 #endif /* INET */
 199
 200 /*
 201  * in_pcb.c: manage the Protocol Control Blocks.
 202  *
 203  * NOTE: It is assumed that most of these functions will be called with
 204  * the pcbinfo lock held, and often, the inpcb lock held, as these utility
 205  * functions often modify hash chains or addresses in pcbs.
 206  */
 207
 208 /*
 209  * Initialize an inpcbinfo -- we should be able to reduce the number of
 210  * arguments in time.
 211  */
 212 void
 213 in_pcbinfo_init(struct inpcbinfo *pcbinfo, const char *name,
 214     struct inpcbhead *listhead, int hash_nelements, int porthash_nelements,
 215     char *inpcbzone_name, uma_init inpcbzone_init, uma_fini inpcbzone_fini,
 216     uint32_t inpcbzone_flags, u_int hashfields)
 217 {
 218
 219         INP_INFO_LOCK_INIT(pcbinfo, name);
 220         INP_HASH_LOCK_INIT(pcbinfo, "pcbinfohash");     /* XXXRW: argument? */
 221 #ifdef VIMAGE
 222         pcbinfo->ipi_vnet = curvnet;
 223 #endif
 224         pcbinfo->ipi_listhead = listhead;
 225         LIST_INIT(pcbinfo->ipi_listhead);
 226         pcbinfo->ipi_count = 0;
 227         pcbinfo->ipi_hashbase = hashinit(hash_nelements, M_PCB,
 228             &pcbinfo->ipi_hashmask);
 229         pcbinfo->ipi_porthashbase = hashinit(porthash_nelements, M_PCB,
 230             &pcbinfo->ipi_porthashmask);
 231 #ifdef PCBGROUP
 232         in_pcbgroup_init(pcbinfo, hashfields, hash_nelements);
 233 #endif
 234         pcbinfo->ipi_zone = uma_zcreate(inpcbzone_name, sizeof(struct inpcb),
 235             NULL, NULL, inpcbzone_init, inpcbzone_fini, UMA_ALIGN_PTR,
 236             inpcbzone_flags);
 237         uma_zone_set_max(pcbinfo->ipi_zone, maxsockets);
 238         uma_zone_set_warning(pcbinfo->ipi_zone,
 239             "kern.ipc.maxsockets limit reached");
 240 }
 241
 242 /*
 243  * Destroy an inpcbinfo.
 244  */
 245 void
 246 in_pcbinfo_destroy(struct inpcbinfo *pcbinfo)
 247 {
 248
 249         KASSERT(pcbinfo->ipi_count == 0,
 250             ("%s: ipi_count = %u", __func__, pcbinfo->ipi_count));
 251
 252         hashdestroy(pcbinfo->ipi_hashbase, M_PCB, pcbinfo->ipi_hashmask);
 253         hashdestroy(pcbinfo->ipi_porthashbase, M_PCB,
 254             pcbinfo->ipi_porthashmask);
 255 #ifdef PCBGROUP
 256         in_pcbgroup_destroy(pcbinfo);
 257 #endif
 258         uma_zdestroy(pcbinfo->ipi_zone);
 259         INP_HASH_LOCK_DESTROY(pcbinfo);
 260         INP_INFO_LOCK_DESTROY(pcbinfo);
 261 }
 262
 263 /*
 264  * Allocate a PCB and associate it with the socket.
 265  * On success return with the PCB locked.
 266  */
 267 int
 268 in_pcballoc(struct socket *so, struct inpcbinfo *pcbinfo)
 269 {
 270         struct inpcb *inp;
 271         int error;
 272
 273         INP_INFO_WLOCK_ASSERT(pcbinfo);
 274         error = 0;
 275         inp = uma_zalloc(pcbinfo->ipi_zone, M_NOWAIT);
 276         if (inp == NULL)
 277                 return (ENOBUFS);
 278         bzero(inp, inp_zero_size);
 279         inp->inp_pcbinfo = pcbinfo;
 280         inp->inp_socket = so;
 281         inp->inp_cred = crhold(so->so_cred);
 282         inp->inp_inc.inc_fibnum = so->so_fibnum;
 283 #ifdef MAC
 284         error = mac_inpcb_init(inp, M_NOWAIT);
 285         if (error != 0)
 286                 goto out;
 287         mac_inpcb_create(so, inp);
 288 #endif
 289 #ifdef IPSEC
 290         error = ipsec_init_policy(so, &inp->inp_sp);
 291         if (error != 0) {
 292 #ifdef MAC
 293                 mac_inpcb_destroy(inp);
 294 #endif
 295                 goto out;
 296         }
 297 #endif /*IPSEC*/
 298 #ifdef INET6
 299         if (INP_SOCKAF(so) == AF_INET6) {
 300                 inp->inp_vflag |= INP_IPV6PROTO;
 301                 if (V_ip6_v6only)
 302                         inp->inp_flags |= IN6P_IPV6_V6ONLY;
 303         }
 304 #endif
 305         LIST_INSERT_HEAD(pcbinfo->ipi_listhead, inp, inp_list);
 306         pcbinfo->ipi_count++;
 307         so->so_pcb = (caddr_t)inp;
 308 #ifdef INET6
 309         if (V_ip6_auto_flowlabel)
 310                 inp->inp_flags |= IN6P_AUTOFLOWLABEL;
 311 #endif
 312         INP_WLOCK(inp);
 313         inp->inp_gencnt = ++pcbinfo->ipi_gencnt;
 314         refcount_init(&inp->inp_refcount, 1);   /* Reference from inpcbinfo */
 315 #if defined(IPSEC) || defined(MAC)
 316 out:
 317         if (error != 0) {
 318                 crfree(inp->inp_cred);
 319                 uma_zfree(pcbinfo->ipi_zone, inp);
 320         }
 321 #endif
 322         return (error);
 323 }
 324
 325 #ifdef INET
 326 int
 327 in_pcbbind(struct inpcb *inp, struct sockaddr *nam, struct ucred *cred)
 328 {
 329         int anonport, error;
 330
 331         INP_WLOCK_ASSERT(inp);
 332         INP_HASH_WLOCK_ASSERT(inp->inp_pcbinfo);
 333
 334         if (inp->inp_lport != 0 || inp->inp_laddr.s_addr != INADDR_ANY)
 335                 return (EINVAL);
 336         anonport = nam == NULL || ((struct sockaddr_in *)nam)->sin_port == 0;
 337         error = in_pcbbind_setup(inp, nam, &inp->inp_laddr.s_addr,
 338             &inp->inp_lport, cred);
 339         if (error)
 340                 return (error);
 341         if (in_pcbinshash(inp) != 0) {
 342                 inp->inp_laddr.s_addr = INADDR_ANY;
 343                 inp->inp_lport = 0;
 344                 return (EAGAIN);
 345         }
 346         if (anonport)
 347                 inp->inp_flags |= INP_ANONPORT;
 348         return (0);
 349 }
 350 #endif
 351
 352 /*
 353  * Select a local port (number) to use.
 354  */
 355 #if defined(INET) || defined(INET6)
 356 int
 357 in_pcb_lport(struct inpcb *inp, struct in_addr *laddrp, u_short *lportp,
 358     struct ucred *cred, int lookupflags)
 359 {
 360         struct inpcbinfo *pcbinfo;
 361         struct inpcb *tmpinp;
 362         unsigned short *lastport;
 363         int count, dorandom, error;
 364         u_short aux, first, last, lport;
 365 #ifdef INET
 366         struct in_addr laddr;
 367 #endif
 368
 369         pcbinfo = inp->inp_pcbinfo;
 370
 371         /*
 372          * Because no actual state changes occur here, a global write lock on
 373          * the pcbinfo isn't required.
 374          */
 375         INP_LOCK_ASSERT(inp);
 376         INP_HASH_LOCK_ASSERT(pcbinfo);
 377
 378         if (inp->inp_flags & INP_HIGHPORT) {
 379                 first = V_ipport_hifirstauto;   /* sysctl */
 380                 last  = V_ipport_hilastauto;
 381                 lastport = &pcbinfo->ipi_lasthi;
 382         } else if (inp->inp_flags & INP_LOWPORT) {
 383                 error = priv_check_cred(cred, PRIV_NETINET_RESERVEDPORT, 0);
 384                 if (error)
 385                         return (error);
 386                 first = V_ipport_lowfirstauto;  /* 1023 */
 387                 last  = V_ipport_lowlastauto;   /* 600 */
 388                 lastport = &pcbinfo->ipi_lastlow;
 389         } else {
 390                 first = V_ipport_firstauto;     /* sysctl */
 391                 last  = V_ipport_lastauto;
 392                 lastport = &pcbinfo->ipi_lastport;
 393         }
 394         /*
 395          * For UDP(-Lite), use random port allocation as long as the user
 396          * allows it.  For TCP (and as of yet unknown) connections,
 397          * use random port allocation only if the user allows it AND
 398          * ipport_tick() allows it.
 399          */
 400         if (V_ipport_randomized &&
 401                 (!V_ipport_stoprandom || pcbinfo == &V_udbinfo ||
 402                 pcbinfo == &V_ulitecbinfo))
 403                 dorandom = 1;
 404         else
 405                 dorandom = 0;
 406         /*
 407          * It makes no sense to do random port allocation if
 408          * we have the only port available.
 409          */
 410         if (first == last)
 411                 dorandom = 0;
 412         /* Make sure to not include UDP(-Lite) packets in the count. */
 413         if (pcbinfo != &V_udbinfo || pcbinfo != &V_ulitecbinfo)
 414                 V_ipport_tcpallocs++;
 415         /*
 416          * Instead of having two loops further down counting up or down
 417          * make sure that first is always <= last and go with only one
 418          * code path implementing all logic.
 419          */
 420         if (first > last) {
 421                 aux = first;
 422                 first = last;
 423                 last = aux;
 424         }
 425
 426 #ifdef INET
 427         /* Make the compiler happy. */
 428         laddr.s_addr = 0;
 429         if ((inp->inp_vflag & (INP_IPV4|INP_IPV6)) == INP_IPV4) {
 430                 KASSERT(laddrp != NULL, ("%s: laddrp NULL for v4 inp %p",
 431                     __func__, inp));
 432                 laddr = *laddrp;
 433         }
 434 #endif
 435         tmpinp = NULL;  /* Make compiler happy. */
 436         lport = *lportp;
 437
 438         if (dorandom)
 439                 *lastport = first + (arc4random() % (last - first));
 440
 441         count = last - first;
 442
 443         do {
 444                 if (count-- < 0)        /* completely used? */
 445                         return (EADDRNOTAVAIL);
 446                 ++*lastport;
 447                 if (*lastport < first || *lastport > last)
 448                         *lastport = first;
 449                 lport = htons(*lastport);
 450
 451 #ifdef INET6
 452                 if ((inp->inp_vflag & INP_IPV6) != 0)
 453                         tmpinp = in6_pcblookup_local(pcbinfo,
 454                             &inp->in6p_laddr, lport, lookupflags, cred);
 455 #endif
 456 #if defined(INET) && defined(INET6)
 457                 else
 458 #endif
 459 #ifdef INET
 460                         tmpinp = in_pcblookup_local(pcbinfo, laddr,
 461                             lport, lookupflags, cred);
 462 #endif
 463         } while (tmpinp != NULL);
 464
 465 #ifdef INET
 466         if ((inp->inp_vflag & (INP_IPV4|INP_IPV6)) == INP_IPV4)
 467                 laddrp->s_addr = laddr.s_addr;
 468 #endif
 469         *lportp = lport;
 470
 471         return (0);
 472 }
 473
 474 /*
 475  * Return cached socket options.
 476  */
 477 short
 478 inp_so_options(const struct inpcb *inp)
 479 {
 480    short so_options;
 481
 482    so_options = 0;
 483
 484    if ((inp->inp_flags2 & INP_REUSEPORT) != 0)
 485            so_options |= SO_REUSEPORT;
 486    if ((inp->inp_flags2 & INP_REUSEADDR) != 0)
 487            so_options |= SO_REUSEADDR;
 488    return (so_options);
 489 }
 490 #endif /* INET || INET6 */
 491
 492 /*
 493  * Check if a new BINDMULTI socket is allowed to be created.
 494  *
 495  * ni points to the new inp.
 496  * oi points to the exisitng inp.
 497  *
 498  * This checks whether the existing inp also has BINDMULTI and
 499  * whether the credentials match.
 500  */
 501 int
 502 in_pcbbind_check_bindmulti(const struct inpcb *ni, const struct inpcb *oi)
 503 {
 504         /* Check permissions match */
 505         if ((ni->inp_flags2 & INP_BINDMULTI) &&
 506             (ni->inp_cred->cr_uid !=
 507             oi->inp_cred->cr_uid))
 508                 return (0);
 509
 510         /* Check the existing inp has BINDMULTI set */
 511         if ((ni->inp_flags2 & INP_BINDMULTI) &&
 512             ((oi->inp_flags2 & INP_BINDMULTI) == 0))
 513                 return (0);
 514
 515         /*
 516          * We're okay - either INP_BINDMULTI isn't set on ni, or
 517          * it is and it matches the checks.
 518          */
 519         return (1);
 520 }
 521
 522 #ifdef INET
 523 /*
 524  * Set up a bind operation on a PCB, performing port allocation
 525  * as required, but do not actually modify the PCB. Callers can
 526  * either complete the bind by setting inp_laddr/inp_lport and
 527  * calling in_pcbinshash(), or they can just use the resulting
 528  * port and address to authorise the sending of a once-off packet.
 529  *
 530  * On error, the values of *laddrp and *lportp are not changed.
 531  */
 532 int
 533 in_pcbbind_setup(struct inpcb *inp, struct sockaddr *nam, in_addr_t *laddrp,
 534     u_short *lportp, struct ucred *cred)
 535 {
 536         struct socket *so = inp->inp_socket;
 537         struct sockaddr_in *sin;
 538         struct inpcbinfo *pcbinfo = inp->inp_pcbinfo;
 539         struct in_addr laddr;
 540         u_short lport = 0;
 541         int lookupflags = 0, reuseport = (so->so_options & SO_REUSEPORT);
 542         int error;
 543
 544         /*
 545          * No state changes, so read locks are sufficient here.
 546          */
 547         INP_LOCK_ASSERT(inp);
 548         INP_HASH_LOCK_ASSERT(pcbinfo);
 549
 550         if (TAILQ_EMPTY(&V_in_ifaddrhead)) /* XXX broken! */
 551                 return (EADDRNOTAVAIL);
 552         laddr.s_addr = *laddrp;
 553         if (nam != NULL && laddr.s_addr != INADDR_ANY)
 554                 return (EINVAL);
 555         if ((so->so_options & (SO_REUSEADDR|SO_REUSEPORT)) == 0)
 556                 lookupflags = INPLOOKUP_WILDCARD;
 557         if (nam == NULL) {
 558                 if ((error = prison_local_ip4(cred, &laddr)) != 0)
 559                         return (error);
 560         } else {
 561                 sin = (struct sockaddr_in *)nam;
 562                 if (nam->sa_len != sizeof (*sin))
 563                         return (EINVAL);
 564 #ifdef notdef
 565                 /*
 566                  * We should check the family, but old programs
 567                  * incorrectly fail to initialize it.
 568                  */
 569                 if (sin->sin_family != AF_INET)
 570                         return (EAFNOSUPPORT);
 571 #endif
 572                 error = prison_local_ip4(cred, &sin->sin_addr);
 573                 if (error)
 574                         return (error);
 575                 if (sin->sin_port != *lportp) {
 576                         /* Don't allow the port to change. */
 577                         if (*lportp != 0)
 578                                 return (EINVAL);
 579                         lport = sin->sin_port;
 580                 }
 581                 /* NB: lport is left as 0 if the port isn't being changed. */
 582                 if (IN_MULTICAST(ntohl(sin->sin_addr.s_addr))) {
 583                         /*
 584                          * Treat SO_REUSEADDR as SO_REUSEPORT for multicast;
 585                          * allow complete duplication of binding if
 586                          * SO_REUSEPORT is set, or if SO_REUSEADDR is set
 587                          * and a multicast address is bound on both
 588                          * new and duplicated sockets.
 589                          */
 590                         if ((so->so_options & (SO_REUSEADDR|SO_REUSEPORT)) != 0)
 591                                 reuseport = SO_REUSEADDR|SO_REUSEPORT;
 592                 } else if (sin->sin_addr.s_addr != INADDR_ANY) {
 593                         sin->sin_port = 0;              /* yech... */
 594                         bzero(&sin->sin_zero, sizeof(sin->sin_zero));
 595                         /*
 596                          * Is the address a local IP address?
 597                          * If INP_BINDANY is set, then the socket may be bound
 598                          * to any endpoint address, local or not.
 599                          */
 600                         if ((inp->inp_flags & INP_BINDANY) == 0 &&
 601                             ifa_ifwithaddr_check((struct sockaddr *)sin) == 0)
 602                                 return (EADDRNOTAVAIL);
 603                 }
 604                 laddr = sin->sin_addr;
 605                 if (lport) {
 606                         struct inpcb *t;
 607                         struct tcptw *tw;
 608
 609                         /* GROSS */
 610                         if (ntohs(lport) <= V_ipport_reservedhigh &&
 611                             ntohs(lport) >= V_ipport_reservedlow &&
 612                             priv_check_cred(cred, PRIV_NETINET_RESERVEDPORT,
 613                             0))
 614                                 return (EACCES);
 615                         if (!IN_MULTICAST(ntohl(sin->sin_addr.s_addr)) &&
 616                             priv_check_cred(inp->inp_cred,
 617                             PRIV_NETINET_REUSEPORT, 0) != 0) {
 618                                 t = in_pcblookup_local(pcbinfo, sin->sin_addr,
 619                                     lport, INPLOOKUP_WILDCARD, cred);
 620         /*
 621          * XXX
 622          * This entire block sorely needs a rewrite.
 623          */
 624                                 if (t &&
 625                                     ((inp->inp_flags2 & INP_BINDMULTI) == 0) &&
 626                                     ((t->inp_flags & INP_TIMEWAIT) == 0) &&
 627                                     (so->so_type != SOCK_STREAM ||
 628                                      ntohl(t->inp_faddr.s_addr) == INADDR_ANY) &&
 629                                     (ntohl(sin->sin_addr.s_addr) != INADDR_ANY ||
 630                                      ntohl(t->inp_laddr.s_addr) != INADDR_ANY ||
 631                                      (t->inp_flags2 & INP_REUSEPORT) == 0) &&
 632                                     (inp->inp_cred->cr_uid !=
 633                                      t->inp_cred->cr_uid))
 634                                         return (EADDRINUSE);
 635
 636                                 /*
 637                                  * If the socket is a BINDMULTI socket, then
 638                                  * the credentials need to match and the
 639                                  * original socket also has to have been bound
 640                                  * with BINDMULTI.
 641                                  */
 642                                 if (t && (! in_pcbbind_check_bindmulti(inp, t)))
 643                                         return (EADDRINUSE);
 644                         }
 645                         t = in_pcblookup_local(pcbinfo, sin->sin_addr,
 646                             lport, lookupflags, cred);
 647                         if (t && (t->inp_flags & INP_TIMEWAIT)) {
 648                                 /*
 649                                  * XXXRW: If an incpb has had its timewait
 650                                  * state recycled, we treat the address as
 651                                  * being in use (for now).  This is better
 652                                  * than a panic, but not desirable.
 653                                  */
 654                                 tw = intotw(t);
 655                                 if (tw == NULL ||
 656                                     (reuseport & tw->tw_so_options) == 0)
 657                                         return (EADDRINUSE);
 658                         } else if (t &&
 659                             ((inp->inp_flags2 & INP_BINDMULTI) == 0) &&
 660                             (reuseport & inp_so_options(t)) == 0) {
 661 #ifdef INET6
 662                                 if (ntohl(sin->sin_addr.s_addr) !=
 663                                     INADDR_ANY ||
 664                                     ntohl(t->inp_laddr.s_addr) !=
 665                                     INADDR_ANY ||
 666                                     (inp->inp_vflag & INP_IPV6PROTO) == 0 ||
 667                                     (t->inp_vflag & INP_IPV6PROTO) == 0)
 668 #endif
 669                                 return (EADDRINUSE);
 670                                 if (t && (! in_pcbbind_check_bindmulti(inp, t)))
 671                                         return (EADDRINUSE);
 672                         }
 673                 }
 674         }
 675         if (*lportp != 0)
 676                 lport = *lportp;
 677         if (lport == 0) {
 678                 error = in_pcb_lport(inp, &laddr, &lport, cred, lookupflags);
 679                 if (error != 0)
 680                         return (error);
 681
 682         }
 683         *laddrp = laddr.s_addr;
 684         *lportp = lport;
 685         return (0);
 686 }
 687
 688 /*
 689  * Connect from a socket to a specified address.
 690  * Both address and port must be specified in argument sin.
 691  * If don't have a local address for this socket yet,
 692  * then pick one.
 693  */
 694 int
 695 in_pcbconnect_mbuf(struct inpcb *inp, struct sockaddr *nam,
 696     struct ucred *cred, struct mbuf *m)
 697 {
 698         u_short lport, fport;
 699         in_addr_t laddr, faddr;
 700         int anonport, error;
 701
 702         INP_WLOCK_ASSERT(inp);
 703         INP_HASH_WLOCK_ASSERT(inp->inp_pcbinfo);
 704
 705         lport = inp->inp_lport;
 706         laddr = inp->inp_laddr.s_addr;
 707         anonport = (lport == 0);
 708         error = in_pcbconnect_setup(inp, nam, &laddr, &lport, &faddr, &fport,
 709             NULL, cred);
 710         if (error)
 711                 return (error);
 712
 713         /* Do the initial binding of the local address if required. */
 714         if (inp->inp_laddr.s_addr == INADDR_ANY && inp->inp_lport == 0) {
 715                 inp->inp_lport = lport;
 716                 inp->inp_laddr.s_addr = laddr;
 717                 if (in_pcbinshash(inp) != 0) {
 718                         inp->inp_laddr.s_addr = INADDR_ANY;
 719                         inp->inp_lport = 0;
 720                         return (EAGAIN);
 721                 }
 722         }
 723
 724         /* Commit the remaining changes. */
 725         inp->inp_lport = lport;
 726         inp->inp_laddr.s_addr = laddr;
 727         inp->inp_faddr.s_addr = faddr;
 728         inp->inp_fport = fport;
 729         in_pcbrehash_mbuf(inp, m);
 730
 731         if (anonport)
 732                 inp->inp_flags |= INP_ANONPORT;
 733         return (0);
 734 }
 735
 736 int
 737 in_pcbconnect(struct inpcb *inp, struct sockaddr *nam, struct ucred *cred)
 738 {
 739
 740         return (in_pcbconnect_mbuf(inp, nam, cred, NULL));
 741 }
 742
 743 /*
 744  * Do proper source address selection on an unbound socket in case
 745  * of connect. Take jails into account as well.
 746  */
 747 int
 748 in_pcbladdr(struct inpcb *inp, struct in_addr *faddr, struct in_addr *laddr,
 749     struct ucred *cred)
 750 {
 751         struct ifaddr *ifa;
 752         struct sockaddr *sa;
 753         struct sockaddr_in *sin;
 754         struct route sro;
 755         int error;
 756
 757         KASSERT(laddr != NULL, ("%s: laddr NULL", __func__));
 758
 759         /*
 760          * Bypass source address selection and use the primary jail IP
 761          * if requested.
 762          */
 763         if (cred != NULL && !prison_saddrsel_ip4(cred, laddr))
 764                 return (0);
 765
 766         error = 0;
 767         bzero(&sro, sizeof(sro));
 768
 769         sin = (struct sockaddr_in *)&sro.ro_dst;
 770         sin->sin_family = AF_INET;
 771         sin->sin_len = sizeof(struct sockaddr_in);
 772         sin->sin_addr.s_addr = faddr->s_addr;
 773
 774         /*
 775          * If route is known our src addr is taken from the i/f,
 776          * else punt.
 777          *
 778          * Find out route to destination.
 779          */
 780         if ((inp->inp_socket->so_options & SO_DONTROUTE) == 0)
 781                 in_rtalloc_ign(&sro, 0, inp->inp_inc.inc_fibnum);
 782
 783         /*
 784          * If we found a route, use the address corresponding to
 785          * the outgoing interface.
 786          *
 787          * Otherwise assume faddr is reachable on a directly connected
 788          * network and try to find a corresponding interface to take
 789          * the source address from.
 790          */
 791         if (sro.ro_rt == NULL || sro.ro_rt->rt_ifp == NULL) {
 792                 struct in_ifaddr *ia;
 793                 struct ifnet *ifp;
 794
 795                 ia = ifatoia(ifa_ifwithdstaddr((struct sockaddr *)sin,
 796                                         inp->inp_socket->so_fibnum));
 797                 if (ia == NULL)
 798                         ia = ifatoia(ifa_ifwithnet((struct sockaddr *)sin, 0,
 799                                                 inp->inp_socket->so_fibnum));
 800                 if (ia == NULL) {
 801                         error = ENETUNREACH;
 802                         goto done;
 803                 }
 804
 805                 if (cred == NULL || !prison_flag(cred, PR_IP4)) {
 806                         laddr->s_addr = ia->ia_addr.sin_addr.s_addr;
 807                         ifa_free(&ia->ia_ifa);
 808                         goto done;
 809                 }
 810
 811                 ifp = ia->ia_ifp;
 812                 ifa_free(&ia->ia_ifa);
 813                 ia = NULL;
 814                 IF_ADDR_RLOCK(ifp);
 815                 TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
 816
 817                         sa = ifa->ifa_addr;
 818                         if (sa->sa_family != AF_INET)
 819                                 continue;
 820                         sin = (struct sockaddr_in *)sa;
 821                         if (prison_check_ip4(cred, &sin->sin_addr) == 0) {
 822                                 ia = (struct in_ifaddr *)ifa;
 823                                 break;
 824                         }
 825                 }
 826                 if (ia != NULL) {
 827                         laddr->s_addr = ia->ia_addr.sin_addr.s_addr;
 828                         IF_ADDR_RUNLOCK(ifp);
 829                         goto done;
 830                 }
 831                 IF_ADDR_RUNLOCK(ifp);
 832
 833                 /* 3. As a last resort return the 'default' jail address. */
 834                 error = prison_get_ip4(cred, laddr);
 835                 goto done;
 836         }
 837
 838         /*
 839          * If the outgoing interface on the route found is not
 840          * a loopback interface, use the address from that interface.
 841          * In case of jails do those three steps:
 842          * 1. check if the interface address belongs to the jail. If so use it.
 843          * 2. check if we have any address on the outgoing interface
 844          *    belonging to this jail. If so use it.
 845          * 3. as a last resort return the 'default' jail address.
 846          */
 847         if ((sro.ro_rt->rt_ifp->if_flags & IFF_LOOPBACK) == 0) {
 848                 struct in_ifaddr *ia;
 849                 struct ifnet *ifp;
 850
 851                 /* If not jailed, use the default returned. */
 852                 if (cred == NULL || !prison_flag(cred, PR_IP4)) {
 853                         ia = (struct in_ifaddr *)sro.ro_rt->rt_ifa;
 854                         laddr->s_addr = ia->ia_addr.sin_addr.s_addr;
 855                         goto done;
 856                 }
 857
 858                 /* Jailed. */
 859                 /* 1. Check if the iface address belongs to the jail. */
 860                 sin = (struct sockaddr_in *)sro.ro_rt->rt_ifa->ifa_addr;
 861                 if (prison_check_ip4(cred, &sin->sin_addr) == 0) {
 862                         ia = (struct in_ifaddr *)sro.ro_rt->rt_ifa;
 863                         laddr->s_addr = ia->ia_addr.sin_addr.s_addr;
 864                         goto done;
 865                 }
 866
 867                 /*
 868                  * 2. Check if we have any address on the outgoing interface
 869                  *    belonging to this jail.
 870                  */
 871                 ia = NULL;
 872                 ifp = sro.ro_rt->rt_ifp;
 873                 IF_ADDR_RLOCK(ifp);
 874                 TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
 875                         sa = ifa->ifa_addr;
 876                         if (sa->sa_family != AF_INET)
 877                                 continue;
 878                         sin = (struct sockaddr_in *)sa;
 879                         if (prison_check_ip4(cred, &sin->sin_addr) == 0) {
 880                                 ia = (struct in_ifaddr *)ifa;
 881                                 break;
 882                         }
 883                 }
 884                 if (ia != NULL) {
 885                         laddr->s_addr = ia->ia_addr.sin_addr.s_addr;
 886                         IF_ADDR_RUNLOCK(ifp);
 887                         goto done;
 888                 }
 889                 IF_ADDR_RUNLOCK(ifp);
 890
 891                 /* 3. As a last resort return the 'default' jail address. */
 892                 error = prison_get_ip4(cred, laddr);
 893                 goto done;
 894         }
 895
 896         /*
 897          * The outgoing interface is marked with 'loopback net', so a route
 898          * to ourselves is here.
 899          * Try to find the interface of the destination address and then
 900          * take the address from there. That interface is not necessarily
 901          * a loopback interface.
 902          * In case of jails, check that it is an address of the jail
 903          * and if we cannot find, fall back to the 'default' jail address.
 904          */
 905         if ((sro.ro_rt->rt_ifp->if_flags & IFF_LOOPBACK) != 0) {
 906                 struct sockaddr_in sain;
 907                 struct in_ifaddr *ia;
 908
 909                 bzero(&sain, sizeof(struct sockaddr_in));
 910                 sain.sin_family = AF_INET;
 911                 sain.sin_len = sizeof(struct sockaddr_in);
 912                 sain.sin_addr.s_addr = faddr->s_addr;
 913
 914                 ia = ifatoia(ifa_ifwithdstaddr(sintosa(&sain),
 915                                         inp->inp_socket->so_fibnum));
 916                 if (ia == NULL)
 917                         ia = ifatoia(ifa_ifwithnet(sintosa(&sain), 0,
 918                                                 inp->inp_socket->so_fibnum));
 919                 if (ia == NULL)
 920                         ia = ifatoia(ifa_ifwithaddr(sintosa(&sain)));
 921
 922                 if (cred == NULL || !prison_flag(cred, PR_IP4)) {
 923                         if (ia == NULL) {
 924                                 error = ENETUNREACH;
 925                                 goto done;
 926                         }
 927                         laddr->s_addr = ia->ia_addr.sin_addr.s_addr;
 928                         ifa_free(&ia->ia_ifa);
 929                         goto done;
 930                 }
 931
 932                 /* Jailed. */
 933                 if (ia != NULL) {
 934                         struct ifnet *ifp;
 935
 936                         ifp = ia->ia_ifp;
 937                         ifa_free(&ia->ia_ifa);
 938                         ia = NULL;
 939                         IF_ADDR_RLOCK(ifp);
 940                         TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
 941
 942                                 sa = ifa->ifa_addr;
 943                                 if (sa->sa_family != AF_INET)
 944                                         continue;
 945                                 sin = (struct sockaddr_in *)sa;
 946                                 if (prison_check_ip4(cred,
 947                                     &sin->sin_addr) == 0) {
 948                                         ia = (struct in_ifaddr *)ifa;
 949                                         break;
 950                                 }
 951                         }
 952                         if (ia != NULL) {
 953                                 laddr->s_addr = ia->ia_addr.sin_addr.s_addr;
 954                                 IF_ADDR_RUNLOCK(ifp);
 955                                 goto done;
 956                         }
 957                         IF_ADDR_RUNLOCK(ifp);
 958                 }
 959
 960                 /* 3. As a last resort return the 'default' jail address. */
 961                 error = prison_get_ip4(cred, laddr);
 962                 goto done;
 963         }
 964
 965 done:
 966         if (sro.ro_rt != NULL)
 967                 RTFREE(sro.ro_rt);
 968         return (error);
 969 }
 970
 971 /*
 972  * Set up for a connect from a socket to the specified address.
 973  * On entry, *laddrp and *lportp should contain the current local
 974  * address and port for the PCB; these are updated to the values
 975  * that should be placed in inp_laddr and inp_lport to complete
 976  * the connect.
 977  *
 978  * On success, *faddrp and *fportp will be set to the remote address
 979  * and port. These are not updated in the error case.
 980  *
 981  * If the operation fails because the connection already exists,
 982  * *oinpp will be set to the PCB of that connection so that the
 983  * caller can decide to override it. In all other cases, *oinpp
 984  * is set to NULL.
 985  */
 986 int
 987 in_pcbconnect_setup(struct inpcb *inp, struct sockaddr *nam,
 988     in_addr_t *laddrp, u_short *lportp, in_addr_t *faddrp, u_short *fportp,
 989     struct inpcb **oinpp, struct ucred *cred)
 990 {
 991         struct sockaddr_in *sin = (struct sockaddr_in *)nam;
 992         struct in_ifaddr *ia;
 993         struct inpcb *oinp;
 994         struct in_addr laddr, faddr;
 995         u_short lport, fport;
 996         int error;
 997
 998         /*
 999          * Because a global state change doesn't actually occur here, a read
1000          * lock is sufficient.
1001          */
1002         INP_LOCK_ASSERT(inp);
1003         INP_HASH_LOCK_ASSERT(inp->inp_pcbinfo);
1004
1005         if (oinpp != NULL)
1006                 *oinpp = NULL;
1007         if (nam->sa_len != sizeof (*sin))
1008                 return (EINVAL);
1009         if (sin->sin_family != AF_INET)
1010                 return (EAFNOSUPPORT);
1011         if (sin->sin_port == 0)
1012                 return (EADDRNOTAVAIL);
1013         laddr.s_addr = *laddrp;
1014         lport = *lportp;
1015         faddr = sin->sin_addr;
1016         fport = sin->sin_port;
1017
1018         if (!TAILQ_EMPTY(&V_in_ifaddrhead)) {
1019                 /*
1020                  * If the destination address is INADDR_ANY,
1021                  * use the primary local address.
1022                  * If the supplied address is INADDR_BROADCAST,
1023                  * and the primary interface supports broadcast,
1024                  * choose the broadcast address for that interface.
1025                  */
1026                 if (faddr.s_addr == INADDR_ANY) {
1027                         IN_IFADDR_RLOCK();
1028                         faddr =
1029                             IA_SIN(TAILQ_FIRST(&V_in_ifaddrhead))->sin_addr;
1030                         IN_IFADDR_RUNLOCK();
1031                         if (cred != NULL &&
1032                             (error = prison_get_ip4(cred, &faddr)) != 0)
1033                                 return (error);
1034                 } else if (faddr.s_addr == (u_long)INADDR_BROADCAST) {
1035                         IN_IFADDR_RLOCK();
1036                         if (TAILQ_FIRST(&V_in_ifaddrhead)->ia_ifp->if_flags &
1037                             IFF_BROADCAST)
1038                                 faddr = satosin(&TAILQ_FIRST(
1039                                     &V_in_ifaddrhead)->ia_broadaddr)->sin_addr;
1040                         IN_IFADDR_RUNLOCK();
1041                 }
1042         }
1043         if (laddr.s_addr == INADDR_ANY) {
1044                 error = in_pcbladdr(inp, &faddr, &laddr, cred);
1045                 /*
1046                  * If the destination address is multicast and an outgoing
1047                  * interface has been set as a multicast option, prefer the
1048                  * address of that interface as our source address.
1049                  */
1050                 if (IN_MULTICAST(ntohl(faddr.s_addr)) &&
1051                     inp->inp_moptions != NULL) {
1052                         struct ip_moptions *imo;
1053                         struct ifnet *ifp;
1054
1055                         imo = inp->inp_moptions;
1056                         if (imo->imo_multicast_ifp != NULL) {
1057                                 ifp = imo->imo_multicast_ifp;
1058                                 IN_IFADDR_RLOCK();
1059                                 TAILQ_FOREACH(ia, &V_in_ifaddrhead, ia_link) {
1060                                         if ((ia->ia_ifp == ifp) &&
1061                                             (cred == NULL ||
1062                                             prison_check_ip4(cred,
1063                                             &ia->ia_addr.sin_addr) == 0))
1064                                                 break;
1065                                 }
1066                                 if (ia == NULL)
1067                                         error = EADDRNOTAVAIL;
1068                                 else {
1069                                         laddr = ia->ia_addr.sin_addr;
1070                                         error = 0;
1071                                 }
1072                                 IN_IFADDR_RUNLOCK();
1073                         }
1074                 }
1075                 if (error)
1076                         return (error);
1077         }
1078         oinp = in_pcblookup_hash_locked(inp->inp_pcbinfo, faddr, fport,
1079             laddr, lport, 0, NULL);
1080         if (oinp != NULL) {
1081                 if (oinpp != NULL)
1082                         *oinpp = oinp;
1083                 return (EADDRINUSE);
1084         }
1085         if (lport == 0) {
1086                 error = in_pcbbind_setup(inp, NULL, &laddr.s_addr, &lport,
1087                     cred);
1088                 if (error)
1089                         return (error);
1090         }
1091         *laddrp = laddr.s_addr;
1092         *lportp = lport;
1093         *faddrp = faddr.s_addr;
1094         *fportp = fport;
1095         return (0);
1096 }
1097
1098 void
1099 in_pcbdisconnect(struct inpcb *inp)
1100 {
1101
1102         INP_WLOCK_ASSERT(inp);
1103         INP_HASH_WLOCK_ASSERT(inp->inp_pcbinfo);
1104
1105         inp->inp_faddr.s_addr = INADDR_ANY;
1106         inp->inp_fport = 0;
1107         in_pcbrehash(inp);
1108 }
1109 #endif /* INET */
1110
1111 /*
1112  * in_pcbdetach() is responsibe for disassociating a socket from an inpcb.
1113  * For most protocols, this will be invoked immediately prior to calling
1114  * in_pcbfree().  However, with TCP the inpcb may significantly outlive the
1115  * socket, in which case in_pcbfree() is deferred.
1116  */
1117 void
1118 in_pcbdetach(struct inpcb *inp)
1119 {
1120
1121         KASSERT(inp->inp_socket != NULL, ("%s: inp_socket == NULL", __func__));
1122
1123         inp->inp_socket->so_pcb = NULL;
1124         inp->inp_socket = NULL;
1125 }
1126
1127 /*
1128  * in_pcbref() bumps the reference count on an inpcb in order to maintain
1129  * stability of an inpcb pointer despite the inpcb lock being released.  This
1130  * is used in TCP when the inpcbinfo lock needs to be acquired or upgraded,
1131  * but where the inpcb lock may already held, or when acquiring a reference
1132  * via a pcbgroup.
1133  *
1134  * in_pcbref() should be used only to provide brief memory stability, and
1135  * must always be followed by a call to INP_WLOCK() and in_pcbrele() to
1136  * garbage collect the inpcb if it has been in_pcbfree()'d from another
1137  * context.  Until in_pcbrele() has returned that the inpcb is still valid,
1138  * lock and rele are the *only* safe operations that may be performed on the
1139  * inpcb.
1140  *
1141  * While the inpcb will not be freed, releasing the inpcb lock means that the
1142  * connection's state may change, so the caller should be careful to
1143  * revalidate any cached state on reacquiring the lock.  Drop the reference
1144  * using in_pcbrele().
1145  */
1146 void
1147 in_pcbref(struct inpcb *inp)
1148 {
1149
1150         KASSERT(inp->inp_refcount > 0, ("%s: refcount 0", __func__));
1151
1152         refcount_acquire(&inp->inp_refcount);
1153 }
1154
1155 /*
1156  * Drop a refcount on an inpcb elevated using in_pcbref(); because a call to
1157  * in_pcbfree() may have been made between in_pcbref() and in_pcbrele(), we
1158  * return a flag indicating whether or not the inpcb remains valid.  If it is
1159  * valid, we return with the inpcb lock held.
1160  *
1161  * Notice that, unlike in_pcbref(), the inpcb lock must be held to drop a
1162  * reference on an inpcb.  Historically more work was done here (actually, in
1163  * in_pcbfree_internal()) but has been moved to in_pcbfree() to avoid the
1164  * need for the pcbinfo lock in in_pcbrele().  Deferring the free is entirely
1165  * about memory stability (and continued use of the write lock).
1166  */
1167 int
1168 in_pcbrele_rlocked(struct inpcb *inp)
1169 {
1170         struct inpcbinfo *pcbinfo;
1171
1172         KASSERT(inp->inp_refcount > 0, ("%s: refcount 0", __func__));
1173
1174         INP_RLOCK_ASSERT(inp);
1175
1176         if (refcount_release(&inp->inp_refcount) == 0) {
1177                 /*
1178                  * If the inpcb has been freed, let the caller know, even if
1179                  * this isn't the last reference.
1180                  */
1181                 if (inp->inp_flags2 & INP_FREED) {
1182                         INP_RUNLOCK(inp);
1183                         return (1);
1184                 }
1185                 return (0);
1186         }
1187
1188         KASSERT(inp->inp_socket == NULL, ("%s: inp_socket != NULL", __func__));
1189
1190         INP_RUNLOCK(inp);
1191         pcbinfo = inp->inp_pcbinfo;
1192         uma_zfree(pcbinfo->ipi_zone, inp);
1193         return (1);
1194 }
1195
1196 int
1197 in_pcbrele_wlocked(struct inpcb *inp)
1198 {
1199         struct inpcbinfo *pcbinfo;
1200
1201         KASSERT(inp->inp_refcount > 0, ("%s: refcount 0", __func__));
1202
1203         INP_WLOCK_ASSERT(inp);
1204
1205         if (refcount_release(&inp->inp_refcount) == 0)
1206                 return (0);
1207
1208         KASSERT(inp->inp_socket == NULL, ("%s: inp_socket != NULL", __func__));
1209
1210         INP_WUNLOCK(inp);
1211         pcbinfo = inp->inp_pcbinfo;
1212         uma_zfree(pcbinfo->ipi_zone, inp);
1213         return (1);
1214 }
1215
1216 /*
1217  * Temporary wrapper.
1218  */
1219 int
1220 in_pcbrele(struct inpcb *inp)
1221 {
1222
1223         return (in_pcbrele_wlocked(inp));
1224 }
1225
1226 /*
1227  * Unconditionally schedule an inpcb to be freed by decrementing its
1228  * reference count, which should occur only after the inpcb has been detached
1229  * from its socket.  If another thread holds a temporary reference (acquired
1230  * using in_pcbref()) then the free is deferred until that reference is
1231  * released using in_pcbrele(), but the inpcb is still unlocked.  Almost all
1232  * work, including removal from global lists, is done in this context, where
1233  * the pcbinfo lock is held.
1234  */
1235 void
1236 in_pcbfree(struct inpcb *inp)
1237 {
1238         struct inpcbinfo *pcbinfo = inp->inp_pcbinfo;
1239
1240         KASSERT(inp->inp_socket == NULL, ("%s: inp_socket != NULL", __func__));
1241
1242         INP_INFO_WLOCK_ASSERT(pcbinfo);
1243         INP_WLOCK_ASSERT(inp);
1244
1245         /* XXXRW: Do as much as possible here. */
1246 #ifdef IPSEC
1247         if (inp->inp_sp != NULL)
1248                 ipsec_delete_pcbpolicy(inp);
1249 #endif
1250         inp->inp_gencnt = ++pcbinfo->ipi_gencnt;
1251         in_pcbremlists(inp);
1252 #ifdef INET6
1253         if (inp->inp_vflag & INP_IPV6PROTO) {
1254                 ip6_freepcbopts(inp->in6p_outputopts);
1255                 if (inp->in6p_moptions != NULL)
1256                         ip6_freemoptions(inp->in6p_moptions);
1257         }
1258 #endif
1259         if (inp->inp_options)
1260                 (void)m_free(inp->inp_options);
1261 #ifdef INET
1262         if (inp->inp_moptions != NULL)
1263                 inp_freemoptions(inp->inp_moptions);
1264 #endif
1265         inp->inp_vflag = 0;
1266         inp->inp_flags2 |= INP_FREED;
1267         crfree(inp->inp_cred);
1268 #ifdef MAC
1269         mac_inpcb_destroy(inp);
1270 #endif
1271         if (!in_pcbrele_wlocked(inp))
1272                 INP_WUNLOCK(inp);
1273 }
1274
1275 /*
1276  * in_pcbdrop() removes an inpcb from hashed lists, releasing its address and
1277  * port reservation, and preventing it from being returned by inpcb lookups.
1278  *
1279  * It is used by TCP to mark an inpcb as unused and avoid future packet
1280  * delivery or event notification when a socket remains open but TCP has
1281  * closed.  This might occur as a result of a shutdown()-initiated TCP close
1282  * or a RST on the wire, and allows the port binding to be reused while still
1283  * maintaining the invariant that so_pcb always points to a valid inpcb until
1284  * in_pcbdetach().
1285  *
1286  * XXXRW: Possibly in_pcbdrop() should also prevent future notifications by
1287  * in_pcbnotifyall() and in_pcbpurgeif0()?
1288  */
1289 void
1290 in_pcbdrop(struct inpcb *inp)
1291 {
1292
1293         INP_WLOCK_ASSERT(inp);
1294
1295         /*
1296          * XXXRW: Possibly we should protect the setting of INP_DROPPED with
1297          * the hash lock...?
1298          */
1299         inp->inp_flags |= INP_DROPPED;
1300         if (inp->inp_flags & INP_INHASHLIST) {
1301                 struct inpcbport *phd = inp->inp_phd;
1302
1303                 INP_HASH_WLOCK(inp->inp_pcbinfo);
1304                 LIST_REMOVE(inp, inp_hash);
1305                 LIST_REMOVE(inp, inp_portlist);
1306                 if (LIST_FIRST(&phd->phd_pcblist) == NULL) {
1307                         LIST_REMOVE(phd, phd_hash);
1308                         free(phd, M_PCB);
1309                 }
1310                 INP_HASH_WUNLOCK(inp->inp_pcbinfo);
1311                 inp->inp_flags &= ~INP_INHASHLIST;
1312 #ifdef PCBGROUP
1313                 in_pcbgroup_remove(inp);
1314 #endif
1315         }
1316 }
1317
1318 #ifdef INET
1319 /*
1320  * Common routines to return the socket addresses associated with inpcbs.
1321  */
1322 struct sockaddr *
1323 in_sockaddr(in_port_t port, struct in_addr *addr_p)
1324 {
1325         struct sockaddr_in *sin;
1326
1327         sin = malloc(sizeof *sin, M_SONAME,
1328                 M_WAITOK | M_ZERO);
1329         sin->sin_family = AF_INET;
1330         sin->sin_len = sizeof(*sin);
1331         sin->sin_addr = *addr_p;
1332         sin->sin_port = port;
1333
1334         return (struct sockaddr *)sin;
1335 }
1336
1337 int
1338 in_getsockaddr(struct socket *so, struct sockaddr **nam)
1339 {
1340         struct inpcb *inp;
1341         struct in_addr addr;
1342         in_port_t port;
1343
1344         inp = sotoinpcb(so);
1345         KASSERT(inp != NULL, ("in_getsockaddr: inp == NULL"));
1346
1347         INP_RLOCK(inp);
1348         port = inp->inp_lport;
1349         addr = inp->inp_laddr;
1350         INP_RUNLOCK(inp);
1351
1352         *nam = in_sockaddr(port, &addr);
1353         return 0;
1354 }
1355
1356 int
1357 in_getpeeraddr(struct socket *so, struct sockaddr **nam)
1358 {
1359         struct inpcb *inp;
1360         struct in_addr addr;
1361         in_port_t port;
1362
1363         inp = sotoinpcb(so);
1364         KASSERT(inp != NULL, ("in_getpeeraddr: inp == NULL"));
1365
1366         INP_RLOCK(inp);
1367         port = inp->inp_fport;
1368         addr = inp->inp_faddr;
1369         INP_RUNLOCK(inp);
1370
1371         *nam = in_sockaddr(port, &addr);
1372         return 0;
1373 }
1374
1375 void
1376 in_pcbnotifyall(struct inpcbinfo *pcbinfo, struct in_addr faddr, int errno,
1377     struct inpcb *(*notify)(struct inpcb *, int))
1378 {
1379         struct inpcb *inp, *inp_temp;
1380
1381         INP_INFO_WLOCK(pcbinfo);
1382         LIST_FOREACH_SAFE(inp, pcbinfo->ipi_listhead, inp_list, inp_temp) {
1383                 INP_WLOCK(inp);
1384 #ifdef INET6
1385                 if ((inp->inp_vflag & INP_IPV4) == 0) {
1386                         INP_WUNLOCK(inp);
1387                         continue;
1388                 }
1389 #endif
1390                 if (inp->inp_faddr.s_addr != faddr.s_addr ||
1391                     inp->inp_socket == NULL) {
1392                         INP_WUNLOCK(inp);
1393                         continue;
1394                 }
1395                 if ((*notify)(inp, errno))
1396                         INP_WUNLOCK(inp);
1397         }
1398         INP_INFO_WUNLOCK(pcbinfo);
1399 }
1400
1401 void
1402 in_pcbpurgeif0(struct inpcbinfo *pcbinfo, struct ifnet *ifp)
1403 {
1404         struct inpcb *inp;
1405         struct ip_moptions *imo;
1406         int i, gap;
1407
1408         INP_INFO_RLOCK(pcbinfo);
1409         LIST_FOREACH(inp, pcbinfo->ipi_listhead, inp_list) {
1410                 INP_WLOCK(inp);
1411                 imo = inp->inp_moptions;
1412                 if ((inp->inp_vflag & INP_IPV4) &&
1413                     imo != NULL) {
1414                         /*
1415                          * Unselect the outgoing interface if it is being
1416                          * detached.
1417                          */
1418                         if (imo->imo_multicast_ifp == ifp)
1419                                 imo->imo_multicast_ifp = NULL;
1420
1421                         /*
1422                          * Drop multicast group membership if we joined
1423                          * through the interface being detached.
1424                          */
1425                         for (i = 0, gap = 0; i < imo->imo_num_memberships;
1426                             i++) {
1427                                 if (imo->imo_membership[i]->inm_ifp == ifp) {
1428                                         in_delmulti(imo->imo_membership[i]);
1429                                         gap++;
1430                                 } else if (gap != 0)
1431                                         imo->imo_membership[i - gap] =
1432                                             imo->imo_membership[i];
1433                         }
1434                         imo->imo_num_memberships -= gap;
1435                 }
1436                 INP_WUNLOCK(inp);
1437         }
1438         INP_INFO_RUNLOCK(pcbinfo);
1439 }
1440
1441 /*
1442  * Lookup a PCB based on the local address and port.  Caller must hold the
1443  * hash lock.  No inpcb locks or references are acquired.
1444  */
1445 #define INP_LOOKUP_MAPPED_PCB_COST      3
1446 struct inpcb *
1447 in_pcblookup_local(struct inpcbinfo *pcbinfo, struct in_addr laddr,
1448     u_short lport, int lookupflags, struct ucred *cred)
1449 {
1450         struct inpcb *inp;
1451 #ifdef INET6
1452         int matchwild = 3 + INP_LOOKUP_MAPPED_PCB_COST;
1453 #else
1454         int matchwild = 3;
1455 #endif
1456         int wildcard;
1457
1458         KASSERT((lookupflags & ~(INPLOOKUP_WILDCARD)) == 0,
1459             ("%s: invalid lookup flags %d", __func__, lookupflags));
1460
1461         INP_HASH_LOCK_ASSERT(pcbinfo);
1462
1463         if ((lookupflags & INPLOOKUP_WILDCARD) == 0) {
1464                 struct inpcbhead *head;
1465                 /*
1466                  * Look for an unconnected (wildcard foreign addr) PCB that
1467                  * matches the local address and port we're looking for.
1468                  */
1469                 head = &pcbinfo->ipi_hashbase[INP_PCBHASH(INADDR_ANY, lport,
1470                     0, pcbinfo->ipi_hashmask)];
1471                 LIST_FOREACH(inp, head, inp_hash) {
1472 #ifdef INET6
1473                         /* XXX inp locking */
1474                         if ((inp->inp_vflag & INP_IPV4) == 0)
1475                                 continue;
1476 #endif
1477                         if (inp->inp_faddr.s_addr == INADDR_ANY &&
1478                             inp->inp_laddr.s_addr == laddr.s_addr &&
1479                             inp->inp_lport == lport) {
1480                                 /*
1481                                  * Found?
1482                                  */
1483                                 if (cred == NULL ||
1484                                     prison_equal_ip4(cred->cr_prison,
1485                                         inp->inp_cred->cr_prison))
1486                                         return (inp);
1487                         }
1488                 }
1489                 /*
1490                  * Not found.
1491                  */
1492                 return (NULL);
1493         } else {
1494                 struct inpcbporthead *porthash;
1495                 struct inpcbport *phd;
1496                 struct inpcb *match = NULL;
1497                 /*
1498                  * Best fit PCB lookup.
1499                  *
1500                  * First see if this local port is in use by looking on the
1501                  * port hash list.
1502                  */
1503                 porthash = &pcbinfo->ipi_porthashbase[INP_PCBPORTHASH(lport,
1504                     pcbinfo->ipi_porthashmask)];
1505                 LIST_FOREACH(phd, porthash, phd_hash) {
1506                         if (phd->phd_port == lport)
1507                                 break;
1508                 }
1509                 if (phd != NULL) {
1510                         /*
1511                          * Port is in use by one or more PCBs. Look for best
1512                          * fit.
1513                          */
1514                         LIST_FOREACH(inp, &phd->phd_pcblist, inp_portlist) {
1515                                 wildcard = 0;
1516                                 if (cred != NULL &&
1517                                     !prison_equal_ip4(inp->inp_cred->cr_prison,
1518                                         cred->cr_prison))
1519                                         continue;
1520 #ifdef INET6
1521                                 /* XXX inp locking */
1522                                 if ((inp->inp_vflag & INP_IPV4) == 0)
1523                                         continue;
1524                                 /*
1525                                  * We never select the PCB that has
1526                                  * INP_IPV6 flag and is bound to :: if
1527                                  * we have another PCB which is bound
1528                                  * to 0.0.0.0.  If a PCB has the
1529                                  * INP_IPV6 flag, then we set its cost
1530                                  * higher than IPv4 only PCBs.
1531                                  *
1532                                  * Note that the case only happens
1533                                  * when a socket is bound to ::, under
1534                                  * the condition that the use of the
1535                                  * mapped address is allowed.
1536                                  */
1537                                 if ((inp->inp_vflag & INP_IPV6) != 0)
1538                                         wildcard += INP_LOOKUP_MAPPED_PCB_COST;
1539 #endif
1540                                 if (inp->inp_faddr.s_addr != INADDR_ANY)
1541                                         wildcard++;
1542                                 if (inp->inp_laddr.s_addr != INADDR_ANY) {
1543                                         if (laddr.s_addr == INADDR_ANY)
1544                                                 wildcard++;
1545                                         else if (inp->inp_laddr.s_addr != laddr.s_addr)
1546                                                 continue;
1547                                 } else {
1548                                         if (laddr.s_addr != INADDR_ANY)
1549                                                 wildcard++;
1550                                 }
1551                                 if (wildcard < matchwild) {
1552                                         match = inp;
1553                                         matchwild = wildcard;
1554                                         if (matchwild == 0)
1555                                                 break;
1556                                 }
1557                         }
1558                 }
1559                 return (match);
1560         }
1561 }
1562 #undef INP_LOOKUP_MAPPED_PCB_COST
1563
1564 #ifdef PCBGROUP
1565 /*
1566  * Lookup PCB in hash list, using pcbgroup tables.
1567  */
1568 static struct inpcb *
1569 in_pcblookup_group(struct inpcbinfo *pcbinfo, struct inpcbgroup *pcbgroup,
1570     struct in_addr faddr, u_int fport_arg, struct in_addr laddr,
1571     u_int lport_arg, int lookupflags, struct ifnet *ifp)
1572 {
1573         struct inpcbhead *head;
1574         struct inpcb *inp, *tmpinp;
1575         u_short fport = fport_arg, lport = lport_arg;
1576
1577         /*
1578          * First look for an exact match.
1579          */
1580         tmpinp = NULL;
1581         INP_GROUP_LOCK(pcbgroup);
1582         head = &pcbgroup->ipg_hashbase[INP_PCBHASH(faddr.s_addr, lport, fport,
1583             pcbgroup->ipg_hashmask)];
1584         LIST_FOREACH(inp, head, inp_pcbgrouphash) {
1585 #ifdef INET6
1586                 /* XXX inp locking */
1587                 if ((inp->inp_vflag & INP_IPV4) == 0)
1588                         continue;
1589 #endif
1590                 if (inp->inp_faddr.s_addr == faddr.s_addr &&
1591                     inp->inp_laddr.s_addr == laddr.s_addr &&
1592                     inp->inp_fport == fport &&
1593                     inp->inp_lport == lport) {
1594                         /*
1595                          * XXX We should be able to directly return
1596                          * the inp here, without any checks.
1597                          * Well unless both bound with SO_REUSEPORT?
1598                          */
1599                         if (prison_flag(inp->inp_cred, PR_IP4))
1600                                 goto found;
1601                         if (tmpinp == NULL)
1602                                 tmpinp = inp;
1603                 }
1604         }
1605         if (tmpinp != NULL) {
1606                 inp = tmpinp;
1607                 goto found;
1608         }
1609
1610 #ifdef  RSS
1611         /*
1612          * For incoming connections, we may wish to do a wildcard
1613          * match for an RSS-local socket.
1614          */
1615         if ((lookupflags & INPLOOKUP_WILDCARD) != 0) {
1616                 struct inpcb *local_wild = NULL, *local_exact = NULL;
1617 #ifdef INET6
1618                 struct inpcb *local_wild_mapped = NULL;
1619 #endif
1620                 struct inpcb *jail_wild = NULL;
1621                 struct inpcbhead *head;
1622                 int injail;
1623
1624                 /*
1625                  * Order of socket selection - we always prefer jails.
1626                  *      1. jailed, non-wild.
1627                  *      2. jailed, wild.
1628                  *      3. non-jailed, non-wild.
1629                  *      4. non-jailed, wild.
1630                  */
1631
1632                 head = &pcbgroup->ipg_hashbase[INP_PCBHASH(INADDR_ANY,
1633                     lport, 0, pcbgroup->ipg_hashmask)];
1634                 LIST_FOREACH(inp, head, inp_pcbgrouphash) {
1635 #ifdef INET6
1636                         /* XXX inp locking */
1637                         if ((inp->inp_vflag & INP_IPV4) == 0)
1638                                 continue;
1639 #endif
1640                         if (inp->inp_faddr.s_addr != INADDR_ANY ||
1641                             inp->inp_lport != lport)
1642                                 continue;
1643
1644                         /* XXX inp locking */
1645                         if (ifp && ifp->if_type == IFT_FAITH &&
1646                             (inp->inp_flags & INP_FAITH) == 0)
1647                                 continue;
1648
1649                         injail = prison_flag(inp->inp_cred, PR_IP4);
1650                         if (injail) {
1651                                 if (prison_check_ip4(inp->inp_cred,
1652                                     &laddr) != 0)
1653                                         continue;
1654                         } else {
1655                                 if (local_exact != NULL)
1656                                         continue;
1657                         }
1658
1659                         if (inp->inp_laddr.s_addr == laddr.s_addr) {
1660                                 if (injail)
1661                                         goto found;
1662                                 else
1663                                         local_exact = inp;
1664                         } else if (inp->inp_laddr.s_addr == INADDR_ANY) {
1665 #ifdef INET6
1666                                 /* XXX inp locking, NULL check */
1667                                 if (inp->inp_vflag & INP_IPV6PROTO)
1668                                         local_wild_mapped = inp;
1669                                 else
1670 #endif
1671                                         if (injail)
1672                                                 jail_wild = inp;
1673                                         else
1674                                                 local_wild = inp;
1675                         }
1676                 } /* LIST_FOREACH */
1677
1678                 inp = jail_wild;
1679                 if (inp == NULL)
1680                         inp = local_exact;
1681                 if (inp == NULL)
1682                         inp = local_wild;
1683 #ifdef INET6
1684                 if (inp == NULL)
1685                         inp = local_wild_mapped;
1686 #endif
1687                 if (inp != NULL)
1688                         goto found;
1689         }
1690 #endif
1691
1692         /*
1693          * Then look for a wildcard match, if requested.
1694          */
1695         if ((lookupflags & INPLOOKUP_WILDCARD) != 0) {
1696                 struct inpcb *local_wild = NULL, *local_exact = NULL;
1697 #ifdef INET6
1698                 struct inpcb *local_wild_mapped = NULL;
1699 #endif
1700                 struct inpcb *jail_wild = NULL;
1701                 struct inpcbhead *head;
1702                 int injail;
1703
1704                 /*
1705                  * Order of socket selection - we always prefer jails.
1706                  *      1. jailed, non-wild.
1707                  *      2. jailed, wild.
1708                  *      3. non-jailed, non-wild.
1709                  *      4. non-jailed, wild.
1710                  */
1711                 head = &pcbinfo->ipi_wildbase[INP_PCBHASH(INADDR_ANY, lport,
1712                     0, pcbinfo->ipi_wildmask)];
1713                 LIST_FOREACH(inp, head, inp_pcbgroup_wild) {
1714 #ifdef INET6
1715                         /* XXX inp locking */
1716                         if ((inp->inp_vflag & INP_IPV4) == 0)
1717                                 continue;
1718 #endif
1719                         if (inp->inp_faddr.s_addr != INADDR_ANY ||
1720                             inp->inp_lport != lport)
1721                                 continue;
1722
1723                         /* XXX inp locking */
1724                         if (ifp && ifp->if_type == IFT_FAITH &&
1725                             (inp->inp_flags & INP_FAITH) == 0)
1726                                 continue;
1727
1728                         injail = prison_flag(inp->inp_cred, PR_IP4);
1729                         if (injail) {
1730                                 if (prison_check_ip4(inp->inp_cred,
1731                                     &laddr) != 0)
1732                                         continue;
1733                         } else {
1734                                 if (local_exact != NULL)
1735                                         continue;
1736                         }
1737
1738                         if (inp->inp_laddr.s_addr == laddr.s_addr) {
1739                                 if (injail)
1740                                         goto found;
1741                                 else
1742                                         local_exact = inp;
1743                         } else if (inp->inp_laddr.s_addr == INADDR_ANY) {
1744 #ifdef INET6
1745                                 /* XXX inp locking, NULL check */
1746                                 if (inp->inp_vflag & INP_IPV6PROTO)
1747                                         local_wild_mapped = inp;
1748                                 else
1749 #endif
1750                                         if (injail)
1751                                                 jail_wild = inp;
1752                                         else
1753                                                 local_wild = inp;
1754                         }
1755                 } /* LIST_FOREACH */
1756                 inp = jail_wild;
1757                 if (inp == NULL)
1758                         inp = local_exact;
1759                 if (inp == NULL)
1760                         inp = local_wild;
1761 #ifdef INET6
1762                 if (inp == NULL)
1763                         inp = local_wild_mapped;
1764 #endif
1765                 if (inp != NULL)
1766                         goto found;
1767         } /* if (lookupflags & INPLOOKUP_WILDCARD) */
1768         INP_GROUP_UNLOCK(pcbgroup);
1769         return (NULL);
1770
1771 found:
1772         in_pcbref(inp);
1773         INP_GROUP_UNLOCK(pcbgroup);
1774         if (lookupflags & INPLOOKUP_WLOCKPCB) {
1775                 INP_WLOCK(inp);
1776                 if (in_pcbrele_wlocked(inp))
1777                         return (NULL);
1778         } else if (lookupflags & INPLOOKUP_RLOCKPCB) {
1779                 INP_RLOCK(inp);
1780                 if (in_pcbrele_rlocked(inp))
1781                         return (NULL);
1782         } else
1783                 panic("%s: locking bug", __func__);
1784         return (inp);
1785 }
1786 #endif /* PCBGROUP */
1787
1788 /*
1789  * Lookup PCB in hash list, using pcbinfo tables.  This variation assumes
1790  * that the caller has locked the hash list, and will not perform any further
1791  * locking or reference operations on either the hash list or the connection.
1792  */
1793 static struct inpcb *
1794 in_pcblookup_hash_locked(struct inpcbinfo *pcbinfo, struct in_addr faddr,
1795     u_int fport_arg, struct in_addr laddr, u_int lport_arg, int lookupflags,
1796     struct ifnet *ifp)
1797 {
1798         struct inpcbhead *head;
1799         struct inpcb *inp, *tmpinp;
1800         u_short fport = fport_arg, lport = lport_arg;
1801
1802         KASSERT((lookupflags & ~(INPLOOKUP_WILDCARD)) == 0,
1803             ("%s: invalid lookup flags %d", __func__, lookupflags));
1804
1805         INP_HASH_LOCK_ASSERT(pcbinfo);
1806
1807         /*
1808          * First look for an exact match.
1809          */
1810         tmpinp = NULL;
1811         head = &pcbinfo->ipi_hashbase[INP_PCBHASH(faddr.s_addr, lport, fport,
1812             pcbinfo->ipi_hashmask)];
1813         LIST_FOREACH(inp, head, inp_hash) {
1814 #ifdef INET6
1815                 /* XXX inp locking */
1816                 if ((inp->inp_vflag & INP_IPV4) == 0)
1817                         continue;
1818 #endif
1819                 if (inp->inp_faddr.s_addr == faddr.s_addr &&
1820                     inp->inp_laddr.s_addr == laddr.s_addr &&
1821                     inp->inp_fport == fport &&
1822                     inp->inp_lport == lport) {
1823                         /*
1824                          * XXX We should be able to directly return
1825                          * the inp here, without any checks.
1826                          * Well unless both bound with SO_REUSEPORT?
1827                          */
1828                         if (prison_flag(inp->inp_cred, PR_IP4))
1829                                 return (inp);
1830                         if (tmpinp == NULL)
1831                                 tmpinp = inp;
1832                 }
1833         }
1834         if (tmpinp != NULL)
1835                 return (tmpinp);
1836
1837         /*
1838          * Then look for a wildcard match, if requested.
1839          */
1840         if ((lookupflags & INPLOOKUP_WILDCARD) != 0) {
1841                 struct inpcb *local_wild = NULL, *local_exact = NULL;
1842 #ifdef INET6
1843                 struct inpcb *local_wild_mapped = NULL;
1844 #endif
1845                 struct inpcb *jail_wild = NULL;
1846                 int injail;
1847
1848                 /*
1849                  * Order of socket selection - we always prefer jails.
1850                  *      1. jailed, non-wild.
1851                  *      2. jailed, wild.
1852                  *      3. non-jailed, non-wild.
1853                  *      4. non-jailed, wild.
1854                  */
1855
1856                 head = &pcbinfo->ipi_hashbase[INP_PCBHASH(INADDR_ANY, lport,
1857                     0, pcbinfo->ipi_hashmask)];
1858                 LIST_FOREACH(inp, head, inp_hash) {
1859 #ifdef INET6
1860                         /* XXX inp locking */
1861                         if ((inp->inp_vflag & INP_IPV4) == 0)
1862                                 continue;
1863 #endif
1864                         if (inp->inp_faddr.s_addr != INADDR_ANY ||
1865                             inp->inp_lport != lport)
1866                                 continue;
1867
1868                         /* XXX inp locking */
1869                         if (ifp && ifp->if_type == IFT_FAITH &&
1870                             (inp->inp_flags & INP_FAITH) == 0)
1871                                 continue;
1872
1873                         injail = prison_flag(inp->inp_cred, PR_IP4);
1874                         if (injail) {
1875                                 if (prison_check_ip4(inp->inp_cred,
1876                                     &laddr) != 0)
1877                                         continue;
1878                         } else {
1879                                 if (local_exact != NULL)
1880                                         continue;
1881                         }
1882
1883                         if (inp->inp_laddr.s_addr == laddr.s_addr) {
1884                                 if (injail)
1885                                         return (inp);
1886                                 else
1887                                         local_exact = inp;
1888                         } else if (inp->inp_laddr.s_addr == INADDR_ANY) {
1889 #ifdef INET6
1890                                 /* XXX inp locking, NULL check */
1891                                 if (inp->inp_vflag & INP_IPV6PROTO)
1892                                         local_wild_mapped = inp;
1893                                 else
1894 #endif
1895                                         if (injail)
1896                                                 jail_wild = inp;
1897                                         else
1898                                                 local_wild = inp;
1899                         }
1900                 } /* LIST_FOREACH */
1901                 if (jail_wild != NULL)
1902                         return (jail_wild);
1903                 if (local_exact != NULL)
1904                         return (local_exact);
1905                 if (local_wild != NULL)
1906                         return (local_wild);
1907 #ifdef INET6
1908                 if (local_wild_mapped != NULL)
1909                         return (local_wild_mapped);
1910 #endif
1911         } /* if ((lookupflags & INPLOOKUP_WILDCARD) != 0) */
1912
1913         return (NULL);
1914 }
1915
1916 /*
1917  * Lookup PCB in hash list, using pcbinfo tables.  This variation locks the
1918  * hash list lock, and will return the inpcb locked (i.e., requires
1919  * INPLOOKUP_LOCKPCB).
1920  */
1921 static struct inpcb *
1922 in_pcblookup_hash(struct inpcbinfo *pcbinfo, struct in_addr faddr,
1923     u_int fport, struct in_addr laddr, u_int lport, int lookupflags,
1924     struct ifnet *ifp)
1925 {
1926         struct inpcb *inp;
1927
1928         INP_HASH_RLOCK(pcbinfo);
1929         inp = in_pcblookup_hash_locked(pcbinfo, faddr, fport, laddr, lport,
1930             (lookupflags & ~(INPLOOKUP_RLOCKPCB | INPLOOKUP_WLOCKPCB)), ifp);
1931         if (inp != NULL) {
1932                 in_pcbref(inp);
1933                 INP_HASH_RUNLOCK(pcbinfo);
1934                 if (lookupflags & INPLOOKUP_WLOCKPCB) {
1935                         INP_WLOCK(inp);
1936                         if (in_pcbrele_wlocked(inp))
1937                                 return (NULL);
1938                 } else if (lookupflags & INPLOOKUP_RLOCKPCB) {
1939                         INP_RLOCK(inp);
1940                         if (in_pcbrele_rlocked(inp))
1941                                 return (NULL);
1942                 } else
1943                         panic("%s: locking bug", __func__);
1944         } else
1945                 INP_HASH_RUNLOCK(pcbinfo);
1946         return (inp);
1947 }
1948
1949 /*
1950  * Public inpcb lookup routines, accepting a 4-tuple, and optionally, an mbuf
1951  * from which a pre-calculated hash value may be extracted.
1952  *
1953  * Possibly more of this logic should be in in_pcbgroup.c.
1954  */
1955 struct inpcb *
1956 in_pcblookup(struct inpcbinfo *pcbinfo, struct in_addr faddr, u_int fport,
1957     struct in_addr laddr, u_int lport, int lookupflags, struct ifnet *ifp)
1958 {
1959 #if defined(PCBGROUP) && !defined(RSS)
1960         struct inpcbgroup *pcbgroup;
1961 #endif
1962
1963         KASSERT((lookupflags & ~INPLOOKUP_MASK) == 0,
1964             ("%s: invalid lookup flags %d", __func__, lookupflags));
1965         KASSERT((lookupflags & (INPLOOKUP_RLOCKPCB | INPLOOKUP_WLOCKPCB)) != 0,
1966             ("%s: LOCKPCB not set", __func__));
1967
1968         /*
1969          * When not using RSS, use connection groups in preference to the
1970          * reservation table when looking up 4-tuples.  When using RSS, just
1971          * use the reservation table, due to the cost of the Toeplitz hash
1972          * in software.
1973          *
1974          * XXXRW: This policy belongs in the pcbgroup code, as in principle
1975          * we could be doing RSS with a non-Toeplitz hash that is affordable
1976          * in software.
1977          */
1978 #if defined(PCBGROUP) && !defined(RSS)
1979         if (in_pcbgroup_enabled(pcbinfo)) {
1980                 pcbgroup = in_pcbgroup_bytuple(pcbinfo, laddr, lport, faddr,
1981                     fport);
1982                 return (in_pcblookup_group(pcbinfo, pcbgroup, faddr, fport,
1983                     laddr, lport, lookupflags, ifp));
1984         }
1985 #endif
1986         return (in_pcblookup_hash(pcbinfo, faddr, fport, laddr, lport,
1987             lookupflags, ifp));
1988 }
1989
1990 struct inpcb *
1991 in_pcblookup_mbuf(struct inpcbinfo *pcbinfo, struct in_addr faddr,
1992     u_int fport, struct in_addr laddr, u_int lport, int lookupflags,
1993     struct ifnet *ifp, struct mbuf *m)
1994 {
1995 #ifdef PCBGROUP
1996         struct inpcbgroup *pcbgroup;
1997 #endif
1998
1999         KASSERT((lookupflags & ~INPLOOKUP_MASK) == 0,
2000             ("%s: invalid lookup flags %d", __func__, lookupflags));
2001         KASSERT((lookupflags & (INPLOOKUP_RLOCKPCB | INPLOOKUP_WLOCKPCB)) != 0,
2002             ("%s: LOCKPCB not set", __func__));
2003
2004 #ifdef PCBGROUP
2005         /*
2006          * If we can use a hardware-generated hash to look up the connection
2007          * group, use that connection group to find the inpcb.  Otherwise
2008          * fall back on a software hash -- or the reservation table if we're
2009          * using RSS.
2010          *
2011          * XXXRW: As above, that policy belongs in the pcbgroup code.
2012          */
2013         if (in_pcbgroup_enabled(pcbinfo) &&
2014             !(M_HASHTYPE_TEST(m, M_HASHTYPE_NONE))) {
2015                 pcbgroup = in_pcbgroup_byhash(pcbinfo, M_HASHTYPE_GET(m),
2016                     m->m_pkthdr.flowid);
2017                 if (pcbgroup != NULL)
2018                         return (in_pcblookup_group(pcbinfo, pcbgroup, faddr,
2019                             fport, laddr, lport, lookupflags, ifp));
2020 #ifndef RSS
2021                 pcbgroup = in_pcbgroup_bytuple(pcbinfo, laddr, lport, faddr,
2022                     fport);
2023                 return (in_pcblookup_group(pcbinfo, pcbgroup, faddr, fport,
2024                     laddr, lport, lookupflags, ifp));
2025 #endif
2026         }
2027 #endif
2028         return (in_pcblookup_hash(pcbinfo, faddr, fport, laddr, lport,
2029             lookupflags, ifp));
2030 }
2031 #endif /* INET */
2032
2033 /*
2034  * Insert PCB onto various hash lists.
2035  */
2036 static int
2037 in_pcbinshash_internal(struct inpcb *inp, int do_pcbgroup_update)
2038 {
2039         struct inpcbhead *pcbhash;
2040         struct inpcbporthead *pcbporthash;
2041         struct inpcbinfo *pcbinfo = inp->inp_pcbinfo;
2042         struct inpcbport *phd;
2043         u_int32_t hashkey_faddr;
2044
2045         INP_WLOCK_ASSERT(inp);
2046         INP_HASH_WLOCK_ASSERT(pcbinfo);
2047
2048         KASSERT((inp->inp_flags & INP_INHASHLIST) == 0,
2049             ("in_pcbinshash: INP_INHASHLIST"));
2050
2051 #ifdef INET6
2052         if (inp->inp_vflag & INP_IPV6)
2053                 hashkey_faddr = INP6_PCBHASHKEY(&inp->in6p_faddr);
2054         else
2055 #endif
2056         hashkey_faddr = inp->inp_faddr.s_addr;
2057
2058         pcbhash = &pcbinfo->ipi_hashbase[INP_PCBHASH(hashkey_faddr,
2059                  inp->inp_lport, inp->inp_fport, pcbinfo->ipi_hashmask)];
2060
2061         pcbporthash = &pcbinfo->ipi_porthashbase[
2062             INP_PCBPORTHASH(inp->inp_lport, pcbinfo->ipi_porthashmask)];
2063
2064         /*
2065          * Go through port list and look for a head for this lport.
2066          */
2067         LIST_FOREACH(phd, pcbporthash, phd_hash) {
2068                 if (phd->phd_port == inp->inp_lport)
2069                         break;
2070         }
2071         /*
2072          * If none exists, malloc one and tack it on.
2073          */
2074         if (phd == NULL) {
2075                 phd = malloc(sizeof(struct inpcbport), M_PCB, M_NOWAIT);
2076                 if (phd == NULL) {
2077                         return (ENOBUFS); /* XXX */
2078                 }
2079                 phd->phd_port = inp->inp_lport;
2080                 LIST_INIT(&phd->phd_pcblist);
2081                 LIST_INSERT_HEAD(pcbporthash, phd, phd_hash);
2082         }
2083         inp->inp_phd = phd;
2084         LIST_INSERT_HEAD(&phd->phd_pcblist, inp, inp_portlist);
2085         LIST_INSERT_HEAD(pcbhash, inp, inp_hash);
2086         inp->inp_flags |= INP_INHASHLIST;
2087 #ifdef PCBGROUP
2088         if (do_pcbgroup_update)
2089                 in_pcbgroup_update(inp);
2090 #endif
2091         return (0);
2092 }
2093
2094 /*
2095  * For now, there are two public interfaces to insert an inpcb into the hash
2096  * lists -- one that does update pcbgroups, and one that doesn't.  The latter
2097  * is used only in the TCP syncache, where in_pcbinshash is called before the
2098  * full 4-tuple is set for the inpcb, and we don't want to install in the
2099  * pcbgroup until later.
2100  *
2101  * XXXRW: This seems like a misfeature.  in_pcbinshash should always update
2102  * connection groups, and partially initialised inpcbs should not be exposed
2103  * to either reservation hash tables or pcbgroups.
2104  */
2105 int
2106 in_pcbinshash(struct inpcb *inp)
2107 {
2108
2109         return (in_pcbinshash_internal(inp, 1));
2110 }
2111
2112 int
2113 in_pcbinshash_nopcbgroup(struct inpcb *inp)
2114 {
2115
2116         return (in_pcbinshash_internal(inp, 0));
2117 }
2118
2119 /*
2120  * Move PCB to the proper hash bucket when { faddr, fport } have  been
2121  * changed. NOTE: This does not handle the case of the lport changing (the
2122  * hashed port list would have to be updated as well), so the lport must
2123  * not change after in_pcbinshash() has been called.
2124  */
2125 void
2126 in_pcbrehash_mbuf(struct inpcb *inp, struct mbuf *m)
2127 {
2128         struct inpcbinfo *pcbinfo = inp->inp_pcbinfo;
2129         struct inpcbhead *head;
2130         u_int32_t hashkey_faddr;
2131
2132         INP_WLOCK_ASSERT(inp);
2133         INP_HASH_WLOCK_ASSERT(pcbinfo);
2134
2135         KASSERT(inp->inp_flags & INP_INHASHLIST,
2136             ("in_pcbrehash: !INP_INHASHLIST"));
2137
2138 #ifdef INET6
2139         if (inp->inp_vflag & INP_IPV6)
2140                 hashkey_faddr = INP6_PCBHASHKEY(&inp->in6p_faddr);
2141         else
2142 #endif
2143         hashkey_faddr = inp->inp_faddr.s_addr;
2144
2145         head = &pcbinfo->ipi_hashbase[INP_PCBHASH(hashkey_faddr,
2146                 inp->inp_lport, inp->inp_fport, pcbinfo->ipi_hashmask)];
2147
2148         LIST_REMOVE(inp, inp_hash);
2149         LIST_INSERT_HEAD(head, inp, inp_hash);
2150
2151 #ifdef PCBGROUP
2152         if (m != NULL)
2153                 in_pcbgroup_update_mbuf(inp, m);
2154         else
2155                 in_pcbgroup_update(inp);
2156 #endif
2157 }
2158
2159 void
2160 in_pcbrehash(struct inpcb *inp)
2161 {
2162
2163         in_pcbrehash_mbuf(inp, NULL);
2164 }
2165
2166 /*
2167  * Remove PCB from various lists.
2168  */
2169 static void
2170 in_pcbremlists(struct inpcb *inp)
2171 {
2172         struct inpcbinfo *pcbinfo = inp->inp_pcbinfo;
2173
2174         INP_INFO_WLOCK_ASSERT(pcbinfo);
2175         INP_WLOCK_ASSERT(inp);
2176
2177         inp->inp_gencnt = ++pcbinfo->ipi_gencnt;
2178         if (inp->inp_flags & INP_INHASHLIST) {
2179                 struct inpcbport *phd = inp->inp_phd;
2180
2181                 INP_HASH_WLOCK(pcbinfo);
2182                 LIST_REMOVE(inp, inp_hash);
2183                 LIST_REMOVE(inp, inp_portlist);
2184                 if (LIST_FIRST(&phd->phd_pcblist) == NULL) {
2185                         LIST_REMOVE(phd, phd_hash);
2186                         free(phd, M_PCB);
2187                 }
2188                 INP_HASH_WUNLOCK(pcbinfo);
2189                 inp->inp_flags &= ~INP_INHASHLIST;
2190         }
2191         LIST_REMOVE(inp, inp_list);
2192         pcbinfo->ipi_count--;
2193 #ifdef PCBGROUP
2194         in_pcbgroup_remove(inp);
2195 #endif
2196 }
2197
2198 /*
2199  * A set label operation has occurred at the socket layer, propagate the
2200  * label change into the in_pcb for the socket.
2201  */
2202 void
2203 in_pcbsosetlabel(struct socket *so)
2204 {
2205 #ifdef MAC
2206         struct inpcb *inp;
2207
2208         inp = sotoinpcb(so);
2209         KASSERT(inp != NULL, ("in_pcbsosetlabel: so->so_pcb == NULL"));
2210
2211         INP_WLOCK(inp);
2212         SOCK_LOCK(so);
2213         mac_inpcb_sosetlabel(so, inp);
2214         SOCK_UNLOCK(so);
2215         INP_WUNLOCK(inp);
2216 #endif
2217 }
2218
2219 /*
2220  * ipport_tick runs once per second, determining if random port allocation
2221  * should be continued.  If more than ipport_randomcps ports have been
2222  * allocated in the last second, then we return to sequential port
2223  * allocation. We return to random allocation only once we drop below
2224  * ipport_randomcps for at least ipport_randomtime seconds.
2225  */
2226 static void
2227 ipport_tick(void *xtp)
2228 {
2229         VNET_ITERATOR_DECL(vnet_iter);
2230
2231         VNET_LIST_RLOCK_NOSLEEP();
2232         VNET_FOREACH(vnet_iter) {
2233                 CURVNET_SET(vnet_iter); /* XXX appease INVARIANTS here */
2234                 if (V_ipport_tcpallocs <=
2235                     V_ipport_tcplastcount + V_ipport_randomcps) {
2236                         if (V_ipport_stoprandom > 0)
2237                                 V_ipport_stoprandom--;
2238                 } else
2239                         V_ipport_stoprandom = V_ipport_randomtime;
2240                 V_ipport_tcplastcount = V_ipport_tcpallocs;
2241                 CURVNET_RESTORE();
2242         }
2243         VNET_LIST_RUNLOCK_NOSLEEP();
2244         callout_reset(&ipport_tick_callout, hz, ipport_tick, NULL);
2245 }
2246
2247 static void
2248 ip_fini(void *xtp)
2249 {
2250
2251         callout_stop(&ipport_tick_callout);
2252 }
2253
2254 /*
2255  * The ipport_callout should start running at about the time we attach the
2256  * inet or inet6 domains.
2257  */
2258 static void
2259 ipport_tick_init(const void *unused __unused)
2260 {
2261
2262         /* Start ipport_tick. */
2263         callout_init(&ipport_tick_callout, CALLOUT_MPSAFE);
2264         callout_reset(&ipport_tick_callout, 1, ipport_tick, NULL);
2265         EVENTHANDLER_REGISTER(shutdown_pre_sync, ip_fini, NULL,
2266                 SHUTDOWN_PRI_DEFAULT);
2267 }
2268 SYSINIT(ipport_tick_init, SI_SUB_PROTO_DOMAIN, SI_ORDER_MIDDLE,
2269     ipport_tick_init, NULL);
2270
2271 void
2272 inp_wlock(struct inpcb *inp)
2273 {
2274
2275         INP_WLOCK(inp);
2276 }
2277
2278 void
2279 inp_wunlock(struct inpcb *inp)
2280 {
2281
2282         INP_WUNLOCK(inp);
2283 }
2284
2285 void
2286 inp_rlock(struct inpcb *inp)
2287 {
2288
2289         INP_RLOCK(inp);
2290 }
2291
2292 void
2293 inp_runlock(struct inpcb *inp)
2294 {
2295
2296         INP_RUNLOCK(inp);
2297 }
2298
2299 #ifdef INVARIANTS
2300 void
2301 inp_lock_assert(struct inpcb *inp)
2302 {
2303
2304         INP_WLOCK_ASSERT(inp);
2305 }
2306
2307 void
2308 inp_unlock_assert(struct inpcb *inp)
2309 {
2310
2311         INP_UNLOCK_ASSERT(inp);
2312 }
2313 #endif
2314
2315 void
2316 inp_apply_all(void (*func)(struct inpcb *, void *), void *arg)
2317 {
2318         struct inpcb *inp;
2319
2320         INP_INFO_RLOCK(&V_tcbinfo);
2321         LIST_FOREACH(inp, V_tcbinfo.ipi_listhead, inp_list) {
2322                 INP_WLOCK(inp);
2323                 func(inp, arg);
2324                 INP_WUNLOCK(inp);
2325         }
2326         INP_INFO_RUNLOCK(&V_tcbinfo);
2327 }
2328
2329 struct socket *
2330 inp_inpcbtosocket(struct inpcb *inp)
2331 {
2332
2333         INP_WLOCK_ASSERT(inp);
2334         return (inp->inp_socket);
2335 }
2336
2337 struct tcpcb *
2338 inp_inpcbtotcpcb(struct inpcb *inp)
2339 {
2340
2341         INP_WLOCK_ASSERT(inp);
2342         return ((struct tcpcb *)inp->inp_ppcb);
2343 }
2344
2345 int
2346 inp_ip_tos_get(const struct inpcb *inp)
2347 {
2348
2349         return (inp->inp_ip_tos);
2350 }
2351
2352 void
2353 inp_ip_tos_set(struct inpcb *inp, int val)
2354 {
2355
2356         inp->inp_ip_tos = val;
2357 }
2358
2359 void
2360 inp_4tuple_get(struct inpcb *inp, uint32_t *laddr, uint16_t *lp,
2361     uint32_t *faddr, uint16_t *fp)
2362 {
2363
2364         INP_LOCK_ASSERT(inp);
2365         *laddr = inp->inp_laddr.s_addr;
2366         *faddr = inp->inp_faddr.s_addr;
2367         *lp = inp->inp_lport;
2368         *fp = inp->inp_fport;
2369 }
2370
2371 struct inpcb *
2372 so_sotoinpcb(struct socket *so)
2373 {
2374
2375         return (sotoinpcb(so));
2376 }
2377
2378 struct tcpcb *
2379 so_sototcpcb(struct socket *so)
2380 {
2381
2382         return (sototcpcb(so));
2383 }
2384
2385 #ifdef DDB
2386 static void
2387 db_print_indent(int indent)
2388 {
2389         int i;
2390
2391         for (i = 0; i < indent; i++)
2392                 db_printf(" ");
2393 }
2394
2395 static void
2396 db_print_inconninfo(struct in_conninfo *inc, const char *name, int indent)
2397 {
2398         char faddr_str[48], laddr_str[48];
2399
2400         db_print_indent(indent);
2401         db_printf("%s at %p\n", name, inc);
2402
2403         indent += 2;
2404
2405 #ifdef INET6
2406         if (inc->inc_flags & INC_ISIPV6) {
2407                 /* IPv6. */
2408                 ip6_sprintf(laddr_str, &inc->inc6_laddr);
2409                 ip6_sprintf(faddr_str, &inc->inc6_faddr);
2410         } else
2411 #endif
2412         {
2413                 /* IPv4. */
2414                 inet_ntoa_r(inc->inc_laddr, laddr_str);
2415                 inet_ntoa_r(inc->inc_faddr, faddr_str);
2416         }
2417         db_print_indent(indent);
2418         db_printf("inc_laddr %s   inc_lport %u\n", laddr_str,
2419             ntohs(inc->inc_lport));
2420         db_print_indent(indent);
2421         db_printf("inc_faddr %s   inc_fport %u\n", faddr_str,
2422             ntohs(inc->inc_fport));
2423 }
2424
2425 static void
2426 db_print_inpflags(int inp_flags)
2427 {
2428         int comma;
2429
2430         comma = 0;
2431         if (inp_flags & INP_RECVOPTS) {
2432                 db_printf("%sINP_RECVOPTS", comma ? ", " : "");
2433                 comma = 1;
2434         }
2435         if (inp_flags & INP_RECVRETOPTS) {
2436                 db_printf("%sINP_RECVRETOPTS", comma ? ", " : "");
2437                 comma = 1;
2438         }
2439         if (inp_flags & INP_RECVDSTADDR) {
2440                 db_printf("%sINP_RECVDSTADDR", comma ? ", " : "");
2441                 comma = 1;
2442         }
2443         if (inp_flags & INP_HDRINCL) {
2444                 db_printf("%sINP_HDRINCL", comma ? ", " : "");
2445                 comma = 1;
2446         }
2447         if (inp_flags & INP_HIGHPORT) {
2448                 db_printf("%sINP_HIGHPORT", comma ? ", " : "");
2449                 comma = 1;
2450         }
2451         if (inp_flags & INP_LOWPORT) {
2452                 db_printf("%sINP_LOWPORT", comma ? ", " : "");
2453                 comma = 1;
2454         }
2455         if (inp_flags & INP_ANONPORT) {
2456                 db_printf("%sINP_ANONPORT", comma ? ", " : "");
2457                 comma = 1;
2458         }
2459         if (inp_flags & INP_RECVIF) {
2460                 db_printf("%sINP_RECVIF", comma ? ", " : "");
2461                 comma = 1;
2462         }
2463         if (inp_flags & INP_MTUDISC) {
2464                 db_printf("%sINP_MTUDISC", comma ? ", " : "");
2465                 comma = 1;
2466         }
2467         if (inp_flags & INP_FAITH) {
2468                 db_printf("%sINP_FAITH", comma ? ", " : "");
2469                 comma = 1;
2470         }
2471         if (inp_flags & INP_RECVTTL) {
2472                 db_printf("%sINP_RECVTTL", comma ? ", " : "");
2473                 comma = 1;
2474         }
2475         if (inp_flags & INP_DONTFRAG) {
2476                 db_printf("%sINP_DONTFRAG", comma ? ", " : "");
2477                 comma = 1;
2478         }
2479         if (inp_flags & INP_RECVTOS) {
2480                 db_printf("%sINP_RECVTOS", comma ? ", " : "");
2481                 comma = 1;
2482         }
2483         if (inp_flags & IN6P_IPV6_V6ONLY) {
2484                 db_printf("%sIN6P_IPV6_V6ONLY", comma ? ", " : "");
2485                 comma = 1;
2486         }
2487         if (inp_flags & IN6P_PKTINFO) {
2488                 db_printf("%sIN6P_PKTINFO", comma ? ", " : "");
2489                 comma = 1;
2490         }
2491         if (inp_flags & IN6P_HOPLIMIT) {
2492                 db_printf("%sIN6P_HOPLIMIT", comma ? ", " : "");
2493                 comma = 1;
2494         }
2495         if (inp_flags & IN6P_HOPOPTS) {
2496                 db_printf("%sIN6P_HOPOPTS", comma ? ", " : "");
2497                 comma = 1;
2498         }
2499         if (inp_flags & IN6P_DSTOPTS) {
2500                 db_printf("%sIN6P_DSTOPTS", comma ? ", " : "");
2501                 comma = 1;
2502         }
2503         if (inp_flags & IN6P_RTHDR) {
2504                 db_printf("%sIN6P_RTHDR", comma ? ", " : "");
2505                 comma = 1;
2506         }
2507         if (inp_flags & IN6P_RTHDRDSTOPTS) {
2508                 db_printf("%sIN6P_RTHDRDSTOPTS", comma ? ", " : "");
2509                 comma = 1;
2510         }
2511         if (inp_flags & IN6P_TCLASS) {
2512                 db_printf("%sIN6P_TCLASS", comma ? ", " : "");
2513                 comma = 1;
2514         }
2515         if (inp_flags & IN6P_AUTOFLOWLABEL) {
2516                 db_printf("%sIN6P_AUTOFLOWLABEL", comma ? ", " : "");
2517                 comma = 1;
2518         }
2519         if (inp_flags & INP_TIMEWAIT) {
2520                 db_printf("%sINP_TIMEWAIT", comma ? ", " : "");
2521                 comma  = 1;
2522         }
2523         if (inp_flags & INP_ONESBCAST) {
2524                 db_printf("%sINP_ONESBCAST", comma ? ", " : "");
2525                 comma  = 1;
2526         }
2527         if (inp_flags & INP_DROPPED) {
2528                 db_printf("%sINP_DROPPED", comma ? ", " : "");
2529                 comma  = 1;
2530         }
2531         if (inp_flags & INP_SOCKREF) {
2532                 db_printf("%sINP_SOCKREF", comma ? ", " : "");
2533                 comma  = 1;
2534         }
2535         if (inp_flags & IN6P_RFC2292) {
2536                 db_printf("%sIN6P_RFC2292", comma ? ", " : "");
2537                 comma = 1;
2538         }
2539         if (inp_flags & IN6P_MTU) {
2540                 db_printf("IN6P_MTU%s", comma ? ", " : "");
2541                 comma = 1;
2542         }
2543 }
2544
2545 static void
2546 db_print_inpvflag(u_char inp_vflag)
2547 {
2548         int comma;
2549
2550         comma = 0;
2551         if (inp_vflag & INP_IPV4) {
2552                 db_printf("%sINP_IPV4", comma ? ", " : "");
2553                 comma  = 1;
2554         }
2555         if (inp_vflag & INP_IPV6) {
2556                 db_printf("%sINP_IPV6", comma ? ", " : "");
2557                 comma  = 1;
2558         }
2559         if (inp_vflag & INP_IPV6PROTO) {
2560                 db_printf("%sINP_IPV6PROTO", comma ? ", " : "");
2561                 comma  = 1;
2562         }
2563 }
2564
2565 static void
2566 db_print_inpcb(struct inpcb *inp, const char *name, int indent)
2567 {
2568
2569         db_print_indent(indent);
2570         db_printf("%s at %p\n", name, inp);
2571
2572         indent += 2;
2573
2574         db_print_indent(indent);
2575         db_printf("inp_flow: 0x%x\n", inp->inp_flow);
2576
2577         db_print_inconninfo(&inp->inp_inc, "inp_conninfo", indent);
2578
2579         db_print_indent(indent);
2580         db_printf("inp_ppcb: %p   inp_pcbinfo: %p   inp_socket: %p\n",
2581             inp->inp_ppcb, inp->inp_pcbinfo, inp->inp_socket);
2582
2583         db_print_indent(indent);
2584         db_printf("inp_label: %p   inp_flags: 0x%x (",
2585            inp->inp_label, inp->inp_flags);
2586         db_print_inpflags(inp->inp_flags);
2587         db_printf(")\n");
2588
2589         db_print_indent(indent);
2590         db_printf("inp_sp: %p   inp_vflag: 0x%x (", inp->inp_sp,
2591             inp->inp_vflag);
2592         db_print_inpvflag(inp->inp_vflag);
2593         db_printf(")\n");
2594
2595         db_print_indent(indent);
2596         db_printf("inp_ip_ttl: %d   inp_ip_p: %d   inp_ip_minttl: %d\n",
2597             inp->inp_ip_ttl, inp->inp_ip_p, inp->inp_ip_minttl);
2598
2599         db_print_indent(indent);
2600 #ifdef INET6
2601         if (inp->inp_vflag & INP_IPV6) {
2602                 db_printf("in6p_options: %p   in6p_outputopts: %p   "
2603                     "in6p_moptions: %p\n", inp->in6p_options,
2604                     inp->in6p_outputopts, inp->in6p_moptions);
2605                 db_printf("in6p_icmp6filt: %p   in6p_cksum %d   "
2606                     "in6p_hops %u\n", inp->in6p_icmp6filt, inp->in6p_cksum,
2607                     inp->in6p_hops);
2608         } else
2609 #endif
2610         {
2611                 db_printf("inp_ip_tos: %d   inp_ip_options: %p   "
2612                     "inp_ip_moptions: %p\n", inp->inp_ip_tos,
2613                     inp->inp_options, inp->inp_moptions);
2614         }
2615
2616         db_print_indent(indent);
2617         db_printf("inp_phd: %p   inp_gencnt: %ju\n", inp->inp_phd,
2618             (uintmax_t)inp->inp_gencnt);
2619 }
2620
2621 DB_SHOW_COMMAND(inpcb, db_show_inpcb)
2622 {
2623         struct inpcb *inp;
2624
2625         if (!have_addr) {
2626                 db_printf("usage: show inpcb <addr>\n");
2627                 return;
2628         }
2629         inp = (struct inpcb *)addr;
2630
2631         db_print_inpcb(inp, "inpcb", 0);
2632 }
2633 #endif /* DDB */