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