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