sys/netinet/ip_input.c

   1 /*-
   2  * Copyright (c) 1982, 1986, 1988, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 4. Neither the name of the University nor the names of its contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  *      @(#)ip_input.c  8.2 (Berkeley) 1/4/94
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __FBSDID("$FreeBSD$");
  34
  35 #include "opt_bootp.h"
  36 #include "opt_ipfw.h"
  37 #include "opt_ipstealth.h"
  38 #include "opt_ipsec.h"
  39 #include "opt_route.h"
  40 #include "opt_rss.h"
  41
  42 #include <sys/param.h>
  43 #include <sys/systm.h>
  44 #include <sys/mbuf.h>
  45 #include <sys/malloc.h>
  46 #include <sys/domain.h>
  47 #include <sys/protosw.h>
  48 #include <sys/socket.h>
  49 #include <sys/time.h>
  50 #include <sys/kernel.h>
  51 #include <sys/lock.h>
  52 #include <sys/rwlock.h>
  53 #include <sys/sdt.h>
  54 #include <sys/syslog.h>
  55 #include <sys/sysctl.h>
  56
  57 #include <net/pfil.h>
  58 #include <net/if.h>
  59 #include <net/if_types.h>
  60 #include <net/if_var.h>
  61 #include <net/if_dl.h>
  62 #include <net/route.h>
  63 #include <net/netisr.h>
  64 #include <net/rss_config.h>
  65 #include <net/vnet.h>
  66
  67 #include <netinet/in.h>
  68 #include <netinet/in_kdtrace.h>
  69 #include <netinet/in_systm.h>
  70 #include <netinet/in_var.h>
  71 #include <netinet/ip.h>
  72 #include <netinet/in_pcb.h>
  73 #include <netinet/ip_var.h>
  74 #include <netinet/ip_fw.h>
  75 #include <netinet/ip_icmp.h>
  76 #include <netinet/ip_options.h>
  77 #include <machine/in_cksum.h>
  78 #include <netinet/ip_carp.h>
  79 #ifdef IPSEC
  80 #include <netinet/ip_ipsec.h>
  81 #endif /* IPSEC */
  82 #include <netinet/in_rss.h>
  83
  84 #include <sys/socketvar.h>
  85
  86 #include <security/mac/mac_framework.h>
  87
  88 #ifdef CTASSERT
  89 CTASSERT(sizeof(struct ip) == 20);
  90 #endif
  91
  92 /* IP reassembly functions are defined in ip_reass.c. */
  93 extern void ipreass_init(void);
  94 extern void ipreass_drain(void);
  95 extern void ipreass_slowtimo(void);
  96 #ifdef VIMAGE
  97 extern void ipreass_destroy(void);
  98 #endif
  99
 100 struct  rwlock in_ifaddr_lock;
 101 RW_SYSINIT(in_ifaddr_lock, &in_ifaddr_lock, "in_ifaddr_lock");
 102
 103 VNET_DEFINE(int, rsvp_on);
 104
 105 VNET_DEFINE(int, ipforwarding);
 106 SYSCTL_INT(_net_inet_ip, IPCTL_FORWARDING, forwarding, CTLFLAG_VNET | CTLFLAG_RW,
 107     &VNET_NAME(ipforwarding), 0,
 108     "Enable IP forwarding between interfaces");
 109
 110 static VNET_DEFINE(int, ipsendredirects) = 1;   /* XXX */
 111 #define V_ipsendredirects       VNET(ipsendredirects)
 112 SYSCTL_INT(_net_inet_ip, IPCTL_SENDREDIRECTS, redirect, CTLFLAG_VNET | CTLFLAG_RW,
 113     &VNET_NAME(ipsendredirects), 0,
 114     "Enable sending IP redirects");
 115
 116 /*
 117  * XXX - Setting ip_checkinterface mostly implements the receive side of
 118  * the Strong ES model described in RFC 1122, but since the routing table
 119  * and transmit implementation do not implement the Strong ES model,
 120  * setting this to 1 results in an odd hybrid.
 121  *
 122  * XXX - ip_checkinterface currently must be disabled if you use ipnat
 123  * to translate the destination address to another local interface.
 124  *
 125  * XXX - ip_checkinterface must be disabled if you add IP aliases
 126  * to the loopback interface instead of the interface where the
 127  * packets for those addresses are received.
 128  */
 129 static VNET_DEFINE(int, ip_checkinterface);
 130 #define V_ip_checkinterface     VNET(ip_checkinterface)
 131 SYSCTL_INT(_net_inet_ip, OID_AUTO, check_interface, CTLFLAG_VNET | CTLFLAG_RW,
 132     &VNET_NAME(ip_checkinterface), 0,
 133     "Verify packet arrives on correct interface");
 134
 135 VNET_DEFINE(struct pfil_head, inet_pfil_hook);  /* Packet filter hooks */
 136
 137 static struct netisr_handler ip_nh = {
 138         .nh_name = "ip",
 139         .nh_handler = ip_input,
 140         .nh_proto = NETISR_IP,
 141 #ifdef  RSS
 142         .nh_m2cpuid = rss_soft_m2cpuid,
 143         .nh_policy = NETISR_POLICY_CPU,
 144         .nh_dispatch = NETISR_DISPATCH_HYBRID,
 145 #else
 146         .nh_policy = NETISR_POLICY_FLOW,
 147 #endif
 148 };
 149
 150 #ifdef  RSS
 151 /*
 152  * Directly dispatched frames are currently assumed
 153  * to have a flowid already calculated.
 154  *
 155  * It should likely have something that assert it
 156  * actually has valid flow details.
 157  */
 158 static struct netisr_handler ip_direct_nh = {
 159         .nh_name = "ip_direct",
 160         .nh_handler = ip_direct_input,
 161         .nh_proto = NETISR_IP_DIRECT,
 162         .nh_m2cpuid = rss_m2cpuid,
 163         .nh_policy = NETISR_POLICY_CPU,
 164         .nh_dispatch = NETISR_DISPATCH_HYBRID,
 165 };
 166 #endif
 167
 168 extern  struct domain inetdomain;
 169 extern  struct protosw inetsw[];
 170 u_char  ip_protox[IPPROTO_MAX];
 171 VNET_DEFINE(struct in_ifaddrhead, in_ifaddrhead);  /* first inet address */
 172 VNET_DEFINE(struct in_ifaddrhashhead *, in_ifaddrhashtbl); /* inet addr hash table  */
 173 VNET_DEFINE(u_long, in_ifaddrhmask);            /* mask for hash table */
 174
 175 #ifdef IPCTL_DEFMTU
 176 SYSCTL_INT(_net_inet_ip, IPCTL_DEFMTU, mtu, CTLFLAG_RW,
 177     &ip_mtu, 0, "Default MTU");
 178 #endif
 179
 180 #ifdef IPSTEALTH
 181 VNET_DEFINE(int, ipstealth);
 182 SYSCTL_INT(_net_inet_ip, OID_AUTO, stealth, CTLFLAG_VNET | CTLFLAG_RW,
 183     &VNET_NAME(ipstealth), 0,
 184     "IP stealth mode, no TTL decrementation on forwarding");
 185 #endif
 186
 187 /*
 188  * IP statistics are stored in the "array" of counter(9)s.
 189  */
 190 VNET_PCPUSTAT_DEFINE(struct ipstat, ipstat);
 191 VNET_PCPUSTAT_SYSINIT(ipstat);
 192 SYSCTL_VNET_PCPUSTAT(_net_inet_ip, IPCTL_STATS, stats, struct ipstat, ipstat,
 193     "IP statistics (struct ipstat, netinet/ip_var.h)");
 194
 195 #ifdef VIMAGE
 196 VNET_PCPUSTAT_SYSUNINIT(ipstat);
 197 #endif /* VIMAGE */
 198
 199 /*
 200  * Kernel module interface for updating ipstat.  The argument is an index
 201  * into ipstat treated as an array.
 202  */
 203 void
 204 kmod_ipstat_inc(int statnum)
 205 {
 206
 207         counter_u64_add(VNET(ipstat)[statnum], 1);
 208 }
 209
 210 void
 211 kmod_ipstat_dec(int statnum)
 212 {
 213
 214         counter_u64_add(VNET(ipstat)[statnum], -1);
 215 }
 216
 217 static int
 218 sysctl_netinet_intr_queue_maxlen(SYSCTL_HANDLER_ARGS)
 219 {
 220         int error, qlimit;
 221
 222         netisr_getqlimit(&ip_nh, &qlimit);
 223         error = sysctl_handle_int(oidp, &qlimit, 0, req);
 224         if (error || !req->newptr)
 225                 return (error);
 226         if (qlimit < 1)
 227                 return (EINVAL);
 228         return (netisr_setqlimit(&ip_nh, qlimit));
 229 }
 230 SYSCTL_PROC(_net_inet_ip, IPCTL_INTRQMAXLEN, intr_queue_maxlen,
 231     CTLTYPE_INT|CTLFLAG_RW, 0, 0, sysctl_netinet_intr_queue_maxlen, "I",
 232     "Maximum size of the IP input queue");
 233
 234 static int
 235 sysctl_netinet_intr_queue_drops(SYSCTL_HANDLER_ARGS)
 236 {
 237         u_int64_t qdrops_long;
 238         int error, qdrops;
 239
 240         netisr_getqdrops(&ip_nh, &qdrops_long);
 241         qdrops = qdrops_long;
 242         error = sysctl_handle_int(oidp, &qdrops, 0, req);
 243         if (error || !req->newptr)
 244                 return (error);
 245         if (qdrops != 0)
 246                 return (EINVAL);
 247         netisr_clearqdrops(&ip_nh);
 248         return (0);
 249 }
 250
 251 SYSCTL_PROC(_net_inet_ip, IPCTL_INTRQDROPS, intr_queue_drops,
 252     CTLTYPE_INT|CTLFLAG_RD, 0, 0, sysctl_netinet_intr_queue_drops, "I",
 253     "Number of packets dropped from the IP input queue");
 254
 255 #ifdef  RSS
 256 static int
 257 sysctl_netinet_intr_direct_queue_maxlen(SYSCTL_HANDLER_ARGS)
 258 {
 259         int error, qlimit;
 260
 261         netisr_getqlimit(&ip_direct_nh, &qlimit);
 262         error = sysctl_handle_int(oidp, &qlimit, 0, req);
 263         if (error || !req->newptr)
 264                 return (error);
 265         if (qlimit < 1)
 266                 return (EINVAL);
 267         return (netisr_setqlimit(&ip_direct_nh, qlimit));
 268 }
 269 SYSCTL_PROC(_net_inet_ip, IPCTL_INTRQMAXLEN, intr_direct_queue_maxlen,
 270     CTLTYPE_INT|CTLFLAG_RW, 0, 0, sysctl_netinet_intr_direct_queue_maxlen, "I",
 271     "Maximum size of the IP direct input queue");
 272
 273 static int
 274 sysctl_netinet_intr_direct_queue_drops(SYSCTL_HANDLER_ARGS)
 275 {
 276         u_int64_t qdrops_long;
 277         int error, qdrops;
 278
 279         netisr_getqdrops(&ip_direct_nh, &qdrops_long);
 280         qdrops = qdrops_long;
 281         error = sysctl_handle_int(oidp, &qdrops, 0, req);
 282         if (error || !req->newptr)
 283                 return (error);
 284         if (qdrops != 0)
 285                 return (EINVAL);
 286         netisr_clearqdrops(&ip_direct_nh);
 287         return (0);
 288 }
 289
 290 SYSCTL_PROC(_net_inet_ip, IPCTL_INTRQDROPS, intr_direct_queue_drops,
 291     CTLTYPE_INT|CTLFLAG_RD, 0, 0, sysctl_netinet_intr_direct_queue_drops, "I",
 292     "Number of packets dropped from the IP direct input queue");
 293 #endif  /* RSS */
 294
 295 /*
 296  * IP initialization: fill in IP protocol switch table.
 297  * All protocols not implemented in kernel go to raw IP protocol handler.
 298  */
 299 void
 300 ip_init(void)
 301 {
 302         struct protosw *pr;
 303         int i;
 304
 305         TAILQ_INIT(&V_in_ifaddrhead);
 306         V_in_ifaddrhashtbl = hashinit(INADDR_NHASH, M_IFADDR, &V_in_ifaddrhmask);
 307
 308         /* Initialize IP reassembly queue. */
 309         ipreass_init();
 310
 311         /* Initialize packet filter hooks. */
 312         V_inet_pfil_hook.ph_type = PFIL_TYPE_AF;
 313         V_inet_pfil_hook.ph_af = AF_INET;
 314         if ((i = pfil_head_register(&V_inet_pfil_hook)) != 0)
 315                 printf("%s: WARNING: unable to register pfil hook, "
 316                         "error %d\n", __func__, i);
 317
 318         /* Skip initialization of globals for non-default instances. */
 319         if (!IS_DEFAULT_VNET(curvnet))
 320                 return;
 321
 322         pr = pffindproto(PF_INET, IPPROTO_RAW, SOCK_RAW);
 323         if (pr == NULL)
 324                 panic("ip_init: PF_INET not found");
 325
 326         /* Initialize the entire ip_protox[] array to IPPROTO_RAW. */
 327         for (i = 0; i < IPPROTO_MAX; i++)
 328                 ip_protox[i] = pr - inetsw;
 329         /*
 330          * Cycle through IP protocols and put them into the appropriate place
 331          * in ip_protox[].
 332          */
 333         for (pr = inetdomain.dom_protosw;
 334             pr < inetdomain.dom_protoswNPROTOSW; pr++)
 335                 if (pr->pr_domain->dom_family == PF_INET &&
 336                     pr->pr_protocol && pr->pr_protocol != IPPROTO_RAW) {
 337                         /* Be careful to only index valid IP protocols. */
 338                         if (pr->pr_protocol < IPPROTO_MAX)
 339                                 ip_protox[pr->pr_protocol] = pr - inetsw;
 340                 }
 341
 342         netisr_register(&ip_nh);
 343 #ifdef  RSS
 344         netisr_register(&ip_direct_nh);
 345 #endif
 346 }
 347
 348 #ifdef VIMAGE
 349 void
 350 ip_destroy(void)
 351 {
 352         int i;
 353
 354         if ((i = pfil_head_unregister(&V_inet_pfil_hook)) != 0)
 355                 printf("%s: WARNING: unable to unregister pfil hook, "
 356                     "error %d\n", __func__, i);
 357
 358         /* Cleanup in_ifaddr hash table; should be empty. */
 359         hashdestroy(V_in_ifaddrhashtbl, M_IFADDR, V_in_ifaddrhmask);
 360
 361         /* Destroy IP reassembly queue. */
 362         ipreass_destroy();
 363 }
 364 #endif
 365
 366 #ifdef  RSS
 367 /*
 368  * IP direct input routine.
 369  *
 370  * This is called when reinjecting completed fragments where
 371  * all of the previous checking and book-keeping has been done.
 372  */
 373 void
 374 ip_direct_input(struct mbuf *m)
 375 {
 376         struct ip *ip;
 377         int hlen;
 378
 379         ip = mtod(m, struct ip *);
 380         hlen = ip->ip_hl << 2;
 381
 382         IPSTAT_INC(ips_delivered);
 383         (*inetsw[ip_protox[ip->ip_p]].pr_input)(&m, &hlen, ip->ip_p);
 384         return;
 385 }
 386 #endif
 387
 388 /*
 389  * Ip input routine.  Checksum and byte swap header.  If fragmented
 390  * try to reassemble.  Process options.  Pass to next level.
 391  */
 392 void
 393 ip_input(struct mbuf *m)
 394 {
 395         struct ip *ip = NULL;
 396         struct in_ifaddr *ia = NULL;
 397         struct ifaddr *ifa;
 398         struct ifnet *ifp;
 399         int    checkif, hlen = 0;
 400         uint16_t sum, ip_len;
 401         int dchg = 0;                           /* dest changed after fw */
 402         struct in_addr odst;                    /* original dst address */
 403
 404         M_ASSERTPKTHDR(m);
 405
 406         if (m->m_flags & M_FASTFWD_OURS) {
 407                 m->m_flags &= ~M_FASTFWD_OURS;
 408                 /* Set up some basics that will be used later. */
 409                 ip = mtod(m, struct ip *);
 410                 hlen = ip->ip_hl << 2;
 411                 ip_len = ntohs(ip->ip_len);
 412                 goto ours;
 413         }
 414
 415         IPSTAT_INC(ips_total);
 416
 417         if (m->m_pkthdr.len < sizeof(struct ip))
 418                 goto tooshort;
 419
 420         if (m->m_len < sizeof (struct ip) &&
 421             (m = m_pullup(m, sizeof (struct ip))) == NULL) {
 422                 IPSTAT_INC(ips_toosmall);
 423                 return;
 424         }
 425         ip = mtod(m, struct ip *);
 426
 427         if (ip->ip_v != IPVERSION) {
 428                 IPSTAT_INC(ips_badvers);
 429                 goto bad;
 430         }
 431
 432         hlen = ip->ip_hl << 2;
 433         if (hlen < sizeof(struct ip)) { /* minimum header length */
 434                 IPSTAT_INC(ips_badhlen);
 435                 goto bad;
 436         }
 437         if (hlen > m->m_len) {
 438                 if ((m = m_pullup(m, hlen)) == NULL) {
 439                         IPSTAT_INC(ips_badhlen);
 440                         return;
 441                 }
 442                 ip = mtod(m, struct ip *);
 443         }
 444
 445         IP_PROBE(receive, NULL, NULL, ip, m->m_pkthdr.rcvif, ip, NULL);
 446
 447         /* 127/8 must not appear on wire - RFC1122 */
 448         ifp = m->m_pkthdr.rcvif;
 449         if ((ntohl(ip->ip_dst.s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET ||
 450             (ntohl(ip->ip_src.s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET) {
 451                 if ((ifp->if_flags & IFF_LOOPBACK) == 0) {
 452                         IPSTAT_INC(ips_badaddr);
 453                         goto bad;
 454                 }
 455         }
 456
 457         if (m->m_pkthdr.csum_flags & CSUM_IP_CHECKED) {
 458                 sum = !(m->m_pkthdr.csum_flags & CSUM_IP_VALID);
 459         } else {
 460                 if (hlen == sizeof(struct ip)) {
 461                         sum = in_cksum_hdr(ip);
 462                 } else {
 463                         sum = in_cksum(m, hlen);
 464                 }
 465         }
 466         if (sum) {
 467                 IPSTAT_INC(ips_badsum);
 468                 goto bad;
 469         }
 470
 471 #ifdef ALTQ
 472         if (altq_input != NULL && (*altq_input)(m, AF_INET) == 0)
 473                 /* packet is dropped by traffic conditioner */
 474                 return;
 475 #endif
 476
 477         ip_len = ntohs(ip->ip_len);
 478         if (ip_len < hlen) {
 479                 IPSTAT_INC(ips_badlen);
 480                 goto bad;
 481         }
 482
 483         /*
 484          * Check that the amount of data in the buffers
 485          * is as at least much as the IP header would have us expect.
 486          * Trim mbufs if longer than we expect.
 487          * Drop packet if shorter than we expect.
 488          */
 489         if (m->m_pkthdr.len < ip_len) {
 490 tooshort:
 491                 IPSTAT_INC(ips_tooshort);
 492                 goto bad;
 493         }
 494         if (m->m_pkthdr.len > ip_len) {
 495                 if (m->m_len == m->m_pkthdr.len) {
 496                         m->m_len = ip_len;
 497                         m->m_pkthdr.len = ip_len;
 498                 } else
 499                         m_adj(m, ip_len - m->m_pkthdr.len);
 500         }
 501
 502 #ifdef IPSEC
 503         /*
 504          * Bypass packet filtering for packets previously handled by IPsec.
 505          */
 506         if (ip_ipsec_filtertunnel(m))
 507                 goto passin;
 508 #endif /* IPSEC */
 509
 510         /*
 511          * Run through list of hooks for input packets.
 512          *
 513          * NB: Beware of the destination address changing (e.g.
 514          *     by NAT rewriting).  When this happens, tell
 515          *     ip_forward to do the right thing.
 516          */
 517
 518         /* Jump over all PFIL processing if hooks are not active. */
 519         if (!PFIL_HOOKED(&V_inet_pfil_hook))
 520                 goto passin;
 521
 522         odst = ip->ip_dst;
 523         if (pfil_run_hooks(&V_inet_pfil_hook, &m, ifp, PFIL_IN, NULL) != 0)
 524                 return;
 525         if (m == NULL)                  /* consumed by filter */
 526                 return;
 527
 528         ip = mtod(m, struct ip *);
 529         dchg = (odst.s_addr != ip->ip_dst.s_addr);
 530         ifp = m->m_pkthdr.rcvif;
 531
 532         if (m->m_flags & M_FASTFWD_OURS) {
 533                 m->m_flags &= ~M_FASTFWD_OURS;
 534                 goto ours;
 535         }
 536         if (m->m_flags & M_IP_NEXTHOP) {
 537                 dchg = (m_tag_find(m, PACKET_TAG_IPFORWARD, NULL) != NULL);
 538                 if (dchg != 0) {
 539                         /*
 540                          * Directly ship the packet on.  This allows
 541                          * forwarding packets originally destined to us
 542                          * to some other directly connected host.
 543                          */
 544                         ip_forward(m, 1);
 545                         return;
 546                 }
 547         }
 548 passin:
 549
 550         /*
 551          * Process options and, if not destined for us,
 552          * ship it on.  ip_dooptions returns 1 when an
 553          * error was detected (causing an icmp message
 554          * to be sent and the original packet to be freed).
 555          */
 556         if (hlen > sizeof (struct ip) && ip_dooptions(m, 0))
 557                 return;
 558
 559         /* greedy RSVP, snatches any PATH packet of the RSVP protocol and no
 560          * matter if it is destined to another node, or whether it is
 561          * a multicast one, RSVP wants it! and prevents it from being forwarded
 562          * anywhere else. Also checks if the rsvp daemon is running before
 563          * grabbing the packet.
 564          */
 565         if (V_rsvp_on && ip->ip_p==IPPROTO_RSVP)
 566                 goto ours;
 567
 568         /*
 569          * Check our list of addresses, to see if the packet is for us.
 570          * If we don't have any addresses, assume any unicast packet
 571          * we receive might be for us (and let the upper layers deal
 572          * with it).
 573          */
 574         if (TAILQ_EMPTY(&V_in_ifaddrhead) &&
 575             (m->m_flags & (M_MCAST|M_BCAST)) == 0)
 576                 goto ours;
 577
 578         /*
 579          * Enable a consistency check between the destination address
 580          * and the arrival interface for a unicast packet (the RFC 1122
 581          * strong ES model) if IP forwarding is disabled and the packet
 582          * is not locally generated and the packet is not subject to
 583          * 'ipfw fwd'.
 584          *
 585          * XXX - Checking also should be disabled if the destination
 586          * address is ipnat'ed to a different interface.
 587          *
 588          * XXX - Checking is incompatible with IP aliases added
 589          * to the loopback interface instead of the interface where
 590          * the packets are received.
 591          *
 592          * XXX - This is the case for carp vhost IPs as well so we
 593          * insert a workaround. If the packet got here, we already
 594          * checked with carp_iamatch() and carp_forus().
 595          */
 596         checkif = V_ip_checkinterface && (V_ipforwarding == 0) &&
 597             ifp != NULL && ((ifp->if_flags & IFF_LOOPBACK) == 0) &&
 598             ifp->if_carp == NULL && (dchg == 0);
 599
 600         /*
 601          * Check for exact addresses in the hash bucket.
 602          */
 603         /* IN_IFADDR_RLOCK(); */
 604         LIST_FOREACH(ia, INADDR_HASH(ip->ip_dst.s_addr), ia_hash) {
 605                 /*
 606                  * If the address matches, verify that the packet
 607                  * arrived via the correct interface if checking is
 608                  * enabled.
 609                  */
 610                 if (IA_SIN(ia)->sin_addr.s_addr == ip->ip_dst.s_addr &&
 611                     (!checkif || ia->ia_ifp == ifp)) {
 612                         counter_u64_add(ia->ia_ifa.ifa_ipackets, 1);
 613                         counter_u64_add(ia->ia_ifa.ifa_ibytes,
 614                             m->m_pkthdr.len);
 615                         /* IN_IFADDR_RUNLOCK(); */
 616                         goto ours;
 617                 }
 618         }
 619         /* IN_IFADDR_RUNLOCK(); */
 620
 621         /*
 622          * Check for broadcast addresses.
 623          *
 624          * Only accept broadcast packets that arrive via the matching
 625          * interface.  Reception of forwarded directed broadcasts would
 626          * be handled via ip_forward() and ether_output() with the loopback
 627          * into the stack for SIMPLEX interfaces handled by ether_output().
 628          */
 629         if (ifp != NULL && ifp->if_flags & IFF_BROADCAST) {
 630                 IF_ADDR_RLOCK(ifp);
 631                 TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
 632                         if (ifa->ifa_addr->sa_family != AF_INET)
 633                                 continue;
 634                         ia = ifatoia(ifa);
 635                         if (satosin(&ia->ia_broadaddr)->sin_addr.s_addr ==
 636                             ip->ip_dst.s_addr) {
 637                                 counter_u64_add(ia->ia_ifa.ifa_ipackets, 1);
 638                                 counter_u64_add(ia->ia_ifa.ifa_ibytes,
 639                                     m->m_pkthdr.len);
 640                                 IF_ADDR_RUNLOCK(ifp);
 641                                 goto ours;
 642                         }
 643 #ifdef BOOTP_COMPAT
 644                         if (IA_SIN(ia)->sin_addr.s_addr == INADDR_ANY) {
 645                                 counter_u64_add(ia->ia_ifa.ifa_ipackets, 1);
 646                                 counter_u64_add(ia->ia_ifa.ifa_ibytes,
 647                                     m->m_pkthdr.len);
 648                                 IF_ADDR_RUNLOCK(ifp);
 649                                 goto ours;
 650                         }
 651 #endif
 652                 }
 653                 IF_ADDR_RUNLOCK(ifp);
 654                 ia = NULL;
 655         }
 656         /* RFC 3927 2.7: Do not forward datagrams for 169.254.0.0/16. */
 657         if (IN_LINKLOCAL(ntohl(ip->ip_dst.s_addr))) {
 658                 IPSTAT_INC(ips_cantforward);
 659                 m_freem(m);
 660                 return;
 661         }
 662         if (IN_MULTICAST(ntohl(ip->ip_dst.s_addr))) {
 663                 if (V_ip_mrouter) {
 664                         /*
 665                          * If we are acting as a multicast router, all
 666                          * incoming multicast packets are passed to the
 667                          * kernel-level multicast forwarding function.
 668                          * The packet is returned (relatively) intact; if
 669                          * ip_mforward() returns a non-zero value, the packet
 670                          * must be discarded, else it may be accepted below.
 671                          */
 672                         if (ip_mforward && ip_mforward(ip, ifp, m, 0) != 0) {
 673                                 IPSTAT_INC(ips_cantforward);
 674                                 m_freem(m);
 675                                 return;
 676                         }
 677
 678                         /*
 679                          * The process-level routing daemon needs to receive
 680                          * all multicast IGMP packets, whether or not this
 681                          * host belongs to their destination groups.
 682                          */
 683                         if (ip->ip_p == IPPROTO_IGMP)
 684                                 goto ours;
 685                         IPSTAT_INC(ips_forward);
 686                 }
 687                 /*
 688                  * Assume the packet is for us, to avoid prematurely taking
 689                  * a lock on the in_multi hash. Protocols must perform
 690                  * their own filtering and update statistics accordingly.
 691                  */
 692                 goto ours;
 693         }
 694         if (ip->ip_dst.s_addr == (u_long)INADDR_BROADCAST)
 695                 goto ours;
 696         if (ip->ip_dst.s_addr == INADDR_ANY)
 697                 goto ours;
 698
 699         /*
 700          * Not for us; forward if possible and desirable.
 701          */
 702         if (V_ipforwarding == 0) {
 703                 IPSTAT_INC(ips_cantforward);
 704                 m_freem(m);
 705         } else {
 706                 ip_forward(m, dchg);
 707         }
 708         return;
 709
 710 ours:
 711 #ifdef IPSTEALTH
 712         /*
 713          * IPSTEALTH: Process non-routing options only
 714          * if the packet is destined for us.
 715          */
 716         if (V_ipstealth && hlen > sizeof (struct ip) && ip_dooptions(m, 1))
 717                 return;
 718 #endif /* IPSTEALTH */
 719
 720         /*
 721          * Attempt reassembly; if it succeeds, proceed.
 722          * ip_reass() will return a different mbuf.
 723          */
 724         if (ip->ip_off & htons(IP_MF | IP_OFFMASK)) {
 725                 /* XXXGL: shouldn't we save & set m_flags? */
 726                 m = ip_reass(m);
 727                 if (m == NULL)
 728                         return;
 729                 ip = mtod(m, struct ip *);
 730                 /* Get the header length of the reassembled packet */
 731                 hlen = ip->ip_hl << 2;
 732         }
 733
 734 #ifdef IPSEC
 735         /*
 736          * enforce IPsec policy checking if we are seeing last header.
 737          * note that we do not visit this with protocols with pcb layer
 738          * code - like udp/tcp/raw ip.
 739          */
 740         if (ip_ipsec_input(m, ip->ip_p) != 0)
 741                 goto bad;
 742 #endif /* IPSEC */
 743
 744         /*
 745          * Switch out to protocol's input routine.
 746          */
 747         IPSTAT_INC(ips_delivered);
 748
 749         (*inetsw[ip_protox[ip->ip_p]].pr_input)(&m, &hlen, ip->ip_p);
 750         return;
 751 bad:
 752         m_freem(m);
 753 }
 754
 755 /*
 756  * IP timer processing;
 757  * if a timer expires on a reassembly
 758  * queue, discard it.
 759  */
 760 void
 761 ip_slowtimo(void)
 762 {
 763         VNET_ITERATOR_DECL(vnet_iter);
 764
 765         VNET_LIST_RLOCK_NOSLEEP();
 766         VNET_FOREACH(vnet_iter) {
 767                 CURVNET_SET(vnet_iter);
 768                 ipreass_slowtimo();
 769                 CURVNET_RESTORE();
 770         }
 771         VNET_LIST_RUNLOCK_NOSLEEP();
 772 }
 773
 774 void
 775 ip_drain(void)
 776 {
 777         VNET_ITERATOR_DECL(vnet_iter);
 778
 779         VNET_LIST_RLOCK_NOSLEEP();
 780         VNET_FOREACH(vnet_iter) {
 781                 CURVNET_SET(vnet_iter);
 782                 ipreass_drain();
 783                 CURVNET_RESTORE();
 784         }
 785         VNET_LIST_RUNLOCK_NOSLEEP();
 786 }
 787
 788 /*
 789  * The protocol to be inserted into ip_protox[] must be already registered
 790  * in inetsw[], either statically or through pf_proto_register().
 791  */
 792 int
 793 ipproto_register(short ipproto)
 794 {
 795         struct protosw *pr;
 796
 797         /* Sanity checks. */
 798         if (ipproto <= 0 || ipproto >= IPPROTO_MAX)
 799                 return (EPROTONOSUPPORT);
 800
 801         /*
 802          * The protocol slot must not be occupied by another protocol
 803          * already.  An index pointing to IPPROTO_RAW is unused.
 804          */
 805         pr = pffindproto(PF_INET, IPPROTO_RAW, SOCK_RAW);
 806         if (pr == NULL)
 807                 return (EPFNOSUPPORT);
 808         if (ip_protox[ipproto] != pr - inetsw)  /* IPPROTO_RAW */
 809                 return (EEXIST);
 810
 811         /* Find the protocol position in inetsw[] and set the index. */
 812         for (pr = inetdomain.dom_protosw;
 813              pr < inetdomain.dom_protoswNPROTOSW; pr++) {
 814                 if (pr->pr_domain->dom_family == PF_INET &&
 815                     pr->pr_protocol && pr->pr_protocol == ipproto) {
 816                         ip_protox[pr->pr_protocol] = pr - inetsw;
 817                         return (0);
 818                 }
 819         }
 820         return (EPROTONOSUPPORT);
 821 }
 822
 823 int
 824 ipproto_unregister(short ipproto)
 825 {
 826         struct protosw *pr;
 827
 828         /* Sanity checks. */
 829         if (ipproto <= 0 || ipproto >= IPPROTO_MAX)
 830                 return (EPROTONOSUPPORT);
 831
 832         /* Check if the protocol was indeed registered. */
 833         pr = pffindproto(PF_INET, IPPROTO_RAW, SOCK_RAW);
 834         if (pr == NULL)
 835                 return (EPFNOSUPPORT);
 836         if (ip_protox[ipproto] == pr - inetsw)  /* IPPROTO_RAW */
 837                 return (ENOENT);
 838
 839         /* Reset the protocol slot to IPPROTO_RAW. */
 840         ip_protox[ipproto] = pr - inetsw;
 841         return (0);
 842 }
 843
 844 /*
 845  * Given address of next destination (final or next hop), return (referenced)
 846  * internet address info of interface to be used to get there.
 847  */
 848 struct in_ifaddr *
 849 ip_rtaddr(struct in_addr dst, u_int fibnum)
 850 {
 851         struct route sro;
 852         struct sockaddr_in *sin;
 853         struct in_ifaddr *ia;
 854
 855         bzero(&sro, sizeof(sro));
 856         sin = (struct sockaddr_in *)&sro.ro_dst;
 857         sin->sin_family = AF_INET;
 858         sin->sin_len = sizeof(*sin);
 859         sin->sin_addr = dst;
 860         in_rtalloc_ign(&sro, 0, fibnum);
 861
 862         if (sro.ro_rt == NULL)
 863                 return (NULL);
 864
 865         ia = ifatoia(sro.ro_rt->rt_ifa);
 866         ifa_ref(&ia->ia_ifa);
 867         RTFREE(sro.ro_rt);
 868         return (ia);
 869 }
 870
 871 u_char inetctlerrmap[PRC_NCMDS] = {
 872         0,              0,              0,              0,
 873         0,              EMSGSIZE,       EHOSTDOWN,      EHOSTUNREACH,
 874         EHOSTUNREACH,   EHOSTUNREACH,   ECONNREFUSED,   ECONNREFUSED,
 875         EMSGSIZE,       EHOSTUNREACH,   0,              0,
 876         0,              0,              EHOSTUNREACH,   0,
 877         ENOPROTOOPT,    ECONNREFUSED
 878 };
 879
 880 /*
 881  * Forward a packet.  If some error occurs return the sender
 882  * an icmp packet.  Note we can't always generate a meaningful
 883  * icmp message because icmp doesn't have a large enough repertoire
 884  * of codes and types.
 885  *
 886  * If not forwarding, just drop the packet.  This could be confusing
 887  * if ipforwarding was zero but some routing protocol was advancing
 888  * us as a gateway to somewhere.  However, we must let the routing
 889  * protocol deal with that.
 890  *
 891  * The srcrt parameter indicates whether the packet is being forwarded
 892  * via a source route.
 893  */
 894 void
 895 ip_forward(struct mbuf *m, int srcrt)
 896 {
 897         struct ip *ip = mtod(m, struct ip *);
 898         struct in_ifaddr *ia;
 899         struct mbuf *mcopy;
 900         struct sockaddr_in *sin;
 901         struct in_addr dest;
 902         struct route ro;
 903         int error, type = 0, code = 0, mtu = 0;
 904
 905         if (m->m_flags & (M_BCAST|M_MCAST) || in_canforward(ip->ip_dst) == 0) {
 906                 IPSTAT_INC(ips_cantforward);
 907                 m_freem(m);
 908                 return;
 909         }
 910 #ifdef IPSEC
 911         if (ip_ipsec_fwd(m) != 0) {
 912                 IPSTAT_INC(ips_cantforward);
 913                 m_freem(m);
 914                 return;
 915         }
 916 #endif /* IPSEC */
 917 #ifdef IPSTEALTH
 918         if (!V_ipstealth) {
 919 #endif
 920                 if (ip->ip_ttl <= IPTTLDEC) {
 921                         icmp_error(m, ICMP_TIMXCEED, ICMP_TIMXCEED_INTRANS,
 922                             0, 0);
 923                         return;
 924                 }
 925 #ifdef IPSTEALTH
 926         }
 927 #endif
 928
 929         bzero(&ro, sizeof(ro));
 930         sin = (struct sockaddr_in *)&ro.ro_dst;
 931         sin->sin_family = AF_INET;
 932         sin->sin_len = sizeof(*sin);
 933         sin->sin_addr = ip->ip_dst;
 934 #ifdef RADIX_MPATH
 935         rtalloc_mpath_fib(&ro,
 936             ntohl(ip->ip_src.s_addr ^ ip->ip_dst.s_addr),
 937             M_GETFIB(m));
 938 #else
 939         in_rtalloc_ign(&ro, 0, M_GETFIB(m));
 940 #endif
 941         if (ro.ro_rt != NULL) {
 942                 ia = ifatoia(ro.ro_rt->rt_ifa);
 943                 ifa_ref(&ia->ia_ifa);
 944         } else
 945                 ia = NULL;
 946 #ifndef IPSEC
 947         /*
 948          * 'ia' may be NULL if there is no route for this destination.
 949          * In case of IPsec, Don't discard it just yet, but pass it to
 950          * ip_output in case of outgoing IPsec policy.
 951          */
 952         if (!srcrt && ia == NULL) {
 953                 icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_HOST, 0, 0);
 954                 RO_RTFREE(&ro);
 955                 return;
 956         }
 957 #endif
 958
 959         /*
 960          * Save the IP header and at most 8 bytes of the payload,
 961          * in case we need to generate an ICMP message to the src.
 962          *
 963          * XXX this can be optimized a lot by saving the data in a local
 964          * buffer on the stack (72 bytes at most), and only allocating the
 965          * mbuf if really necessary. The vast majority of the packets
 966          * are forwarded without having to send an ICMP back (either
 967          * because unnecessary, or because rate limited), so we are
 968          * really we are wasting a lot of work here.
 969          *
 970          * We don't use m_copy() because it might return a reference
 971          * to a shared cluster. Both this function and ip_output()
 972          * assume exclusive access to the IP header in `m', so any
 973          * data in a cluster may change before we reach icmp_error().
 974          */
 975         mcopy = m_gethdr(M_NOWAIT, m->m_type);
 976         if (mcopy != NULL && !m_dup_pkthdr(mcopy, m, M_NOWAIT)) {
 977                 /*
 978                  * It's probably ok if the pkthdr dup fails (because
 979                  * the deep copy of the tag chain failed), but for now
 980                  * be conservative and just discard the copy since
 981                  * code below may some day want the tags.
 982                  */
 983                 m_free(mcopy);
 984                 mcopy = NULL;
 985         }
 986         if (mcopy != NULL) {
 987                 mcopy->m_len = min(ntohs(ip->ip_len), M_TRAILINGSPACE(mcopy));
 988                 mcopy->m_pkthdr.len = mcopy->m_len;
 989                 m_copydata(m, 0, mcopy->m_len, mtod(mcopy, caddr_t));
 990         }
 991
 992 #ifdef IPSTEALTH
 993         if (!V_ipstealth) {
 994 #endif
 995                 ip->ip_ttl -= IPTTLDEC;
 996 #ifdef IPSTEALTH
 997         }
 998 #endif
 999
1000         /*
1001          * If forwarding packet using same interface that it came in on,
1002          * perhaps should send a redirect to sender to shortcut a hop.
1003          * Only send redirect if source is sending directly to us,
1004          * and if packet was not source routed (or has any options).
1005          * Also, don't send redirect if forwarding using a default route
1006          * or a route modified by a redirect.
1007          */
1008         dest.s_addr = 0;
1009         if (!srcrt && V_ipsendredirects &&
1010             ia != NULL && ia->ia_ifp == m->m_pkthdr.rcvif) {
1011                 struct rtentry *rt;
1012
1013                 rt = ro.ro_rt;
1014
1015                 if (rt && (rt->rt_flags & (RTF_DYNAMIC|RTF_MODIFIED)) == 0 &&
1016                     satosin(rt_key(rt))->sin_addr.s_addr != 0) {
1017 #define RTA(rt) ((struct in_ifaddr *)(rt->rt_ifa))
1018                         u_long src = ntohl(ip->ip_src.s_addr);
1019
1020                         if (RTA(rt) &&
1021                             (src & RTA(rt)->ia_subnetmask) == RTA(rt)->ia_subnet) {
1022                                 if (rt->rt_flags & RTF_GATEWAY)
1023                                         dest.s_addr = satosin(rt->rt_gateway)->sin_addr.s_addr;
1024                                 else
1025                                         dest.s_addr = ip->ip_dst.s_addr;
1026                                 /* Router requirements says to only send host redirects */
1027                                 type = ICMP_REDIRECT;
1028                                 code = ICMP_REDIRECT_HOST;
1029                         }
1030                 }
1031         }
1032
1033         error = ip_output(m, NULL, &ro, IP_FORWARDING, NULL, NULL);
1034
1035         if (error == EMSGSIZE && ro.ro_rt)
1036                 mtu = ro.ro_rt->rt_mtu;
1037         RO_RTFREE(&ro);
1038
1039         if (error)
1040                 IPSTAT_INC(ips_cantforward);
1041         else {
1042                 IPSTAT_INC(ips_forward);
1043                 if (type)
1044                         IPSTAT_INC(ips_redirectsent);
1045                 else {
1046                         if (mcopy)
1047                                 m_freem(mcopy);
1048                         if (ia != NULL)
1049                                 ifa_free(&ia->ia_ifa);
1050                         return;
1051                 }
1052         }
1053         if (mcopy == NULL) {
1054                 if (ia != NULL)
1055                         ifa_free(&ia->ia_ifa);
1056                 return;
1057         }
1058
1059         switch (error) {
1060
1061         case 0:                         /* forwarded, but need redirect */
1062                 /* type, code set above */
1063                 break;
1064
1065         case ENETUNREACH:
1066         case EHOSTUNREACH:
1067         case ENETDOWN:
1068         case EHOSTDOWN:
1069         default:
1070                 type = ICMP_UNREACH;
1071                 code = ICMP_UNREACH_HOST;
1072                 break;
1073
1074         case EMSGSIZE:
1075                 type = ICMP_UNREACH;
1076                 code = ICMP_UNREACH_NEEDFRAG;
1077
1078 #ifdef IPSEC
1079                 /*
1080                  * If IPsec is configured for this path,
1081                  * override any possibly mtu value set by ip_output.
1082                  */
1083                 mtu = ip_ipsec_mtu(mcopy, mtu);
1084 #endif /* IPSEC */
1085                 /*
1086                  * If the MTU was set before make sure we are below the
1087                  * interface MTU.
1088                  * If the MTU wasn't set before use the interface mtu or
1089                  * fall back to the next smaller mtu step compared to the
1090                  * current packet size.
1091                  */
1092                 if (mtu != 0) {
1093                         if (ia != NULL)
1094                                 mtu = min(mtu, ia->ia_ifp->if_mtu);
1095                 } else {
1096                         if (ia != NULL)
1097                                 mtu = ia->ia_ifp->if_mtu;
1098                         else
1099                                 mtu = ip_next_mtu(ntohs(ip->ip_len), 0);
1100                 }
1101                 IPSTAT_INC(ips_cantfrag);
1102                 break;
1103
1104         case ENOBUFS:
1105         case EACCES:                    /* ipfw denied packet */
1106                 m_freem(mcopy);
1107                 if (ia != NULL)
1108                         ifa_free(&ia->ia_ifa);
1109                 return;
1110         }
1111         if (ia != NULL)
1112                 ifa_free(&ia->ia_ifa);
1113         icmp_error(mcopy, type, code, dest.s_addr, mtu);
1114 }
1115
1116 void
1117 ip_savecontrol(struct inpcb *inp, struct mbuf **mp, struct ip *ip,
1118     struct mbuf *m)
1119 {
1120
1121         if (inp->inp_socket->so_options & (SO_BINTIME | SO_TIMESTAMP)) {
1122                 struct bintime bt;
1123
1124                 bintime(&bt);
1125                 if (inp->inp_socket->so_options & SO_BINTIME) {
1126                         *mp = sbcreatecontrol((caddr_t)&bt, sizeof(bt),
1127                             SCM_BINTIME, SOL_SOCKET);
1128                         if (*mp)
1129                                 mp = &(*mp)->m_next;
1130                 }
1131                 if (inp->inp_socket->so_options & SO_TIMESTAMP) {
1132                         struct timeval tv;
1133
1134                         bintime2timeval(&bt, &tv);
1135                         *mp = sbcreatecontrol((caddr_t)&tv, sizeof(tv),
1136                             SCM_TIMESTAMP, SOL_SOCKET);
1137                         if (*mp)
1138                                 mp = &(*mp)->m_next;
1139                 }
1140         }
1141         if (inp->inp_flags & INP_RECVDSTADDR) {
1142                 *mp = sbcreatecontrol((caddr_t)&ip->ip_dst,
1143                     sizeof(struct in_addr), IP_RECVDSTADDR, IPPROTO_IP);
1144                 if (*mp)
1145                         mp = &(*mp)->m_next;
1146         }
1147         if (inp->inp_flags & INP_RECVTTL) {
1148                 *mp = sbcreatecontrol((caddr_t)&ip->ip_ttl,
1149                     sizeof(u_char), IP_RECVTTL, IPPROTO_IP);
1150                 if (*mp)
1151                         mp = &(*mp)->m_next;
1152         }
1153 #ifdef notyet
1154         /* XXX
1155          * Moving these out of udp_input() made them even more broken
1156          * than they already were.
1157          */
1158         /* options were tossed already */
1159         if (inp->inp_flags & INP_RECVOPTS) {
1160                 *mp = sbcreatecontrol((caddr_t)opts_deleted_above,
1161                     sizeof(struct in_addr), IP_RECVOPTS, IPPROTO_IP);
1162                 if (*mp)
1163                         mp = &(*mp)->m_next;
1164         }
1165         /* ip_srcroute doesn't do what we want here, need to fix */
1166         if (inp->inp_flags & INP_RECVRETOPTS) {
1167                 *mp = sbcreatecontrol((caddr_t)ip_srcroute(m),
1168                     sizeof(struct in_addr), IP_RECVRETOPTS, IPPROTO_IP);
1169                 if (*mp)
1170                         mp = &(*mp)->m_next;
1171         }
1172 #endif
1173         if (inp->inp_flags & INP_RECVIF) {
1174                 struct ifnet *ifp;
1175                 struct sdlbuf {
1176                         struct sockaddr_dl sdl;
1177                         u_char  pad[32];
1178                 } sdlbuf;
1179                 struct sockaddr_dl *sdp;
1180                 struct sockaddr_dl *sdl2 = &sdlbuf.sdl;
1181
1182                 if ((ifp = m->m_pkthdr.rcvif) &&
1183                     ifp->if_index && ifp->if_index <= V_if_index) {
1184                         sdp = (struct sockaddr_dl *)ifp->if_addr->ifa_addr;
1185                         /*
1186                          * Change our mind and don't try copy.
1187                          */
1188                         if (sdp->sdl_family != AF_LINK ||
1189                             sdp->sdl_len > sizeof(sdlbuf)) {
1190                                 goto makedummy;
1191                         }
1192                         bcopy(sdp, sdl2, sdp->sdl_len);
1193                 } else {
1194 makedummy:
1195                         sdl2->sdl_len =
1196                             offsetof(struct sockaddr_dl, sdl_data[0]);
1197                         sdl2->sdl_family = AF_LINK;
1198                         sdl2->sdl_index = 0;
1199                         sdl2->sdl_nlen = sdl2->sdl_alen = sdl2->sdl_slen = 0;
1200                 }
1201                 *mp = sbcreatecontrol((caddr_t)sdl2, sdl2->sdl_len,
1202                     IP_RECVIF, IPPROTO_IP);
1203                 if (*mp)
1204                         mp = &(*mp)->m_next;
1205         }
1206         if (inp->inp_flags & INP_RECVTOS) {
1207                 *mp = sbcreatecontrol((caddr_t)&ip->ip_tos,
1208                     sizeof(u_char), IP_RECVTOS, IPPROTO_IP);
1209                 if (*mp)
1210                         mp = &(*mp)->m_next;
1211         }
1212
1213         if (inp->inp_flags2 & INP_RECVFLOWID) {
1214                 uint32_t flowid, flow_type;
1215
1216                 flowid = m->m_pkthdr.flowid;
1217                 flow_type = M_HASHTYPE_GET(m);
1218
1219                 /*
1220                  * XXX should handle the failure of one or the
1221                  * other - don't populate both?
1222                  */
1223                 *mp = sbcreatecontrol((caddr_t) &flowid,
1224                     sizeof(uint32_t), IP_FLOWID, IPPROTO_IP);
1225                 if (*mp)
1226                         mp = &(*mp)->m_next;
1227                 *mp = sbcreatecontrol((caddr_t) &flow_type,
1228                     sizeof(uint32_t), IP_FLOWTYPE, IPPROTO_IP);
1229                 if (*mp)
1230                         mp = &(*mp)->m_next;
1231         }
1232
1233 #ifdef  RSS
1234         if (inp->inp_flags2 & INP_RECVRSSBUCKETID) {
1235                 uint32_t flowid, flow_type;
1236                 uint32_t rss_bucketid;
1237
1238                 flowid = m->m_pkthdr.flowid;
1239                 flow_type = M_HASHTYPE_GET(m);
1240
1241                 if (rss_hash2bucket(flowid, flow_type, &rss_bucketid) == 0) {
1242                         *mp = sbcreatecontrol((caddr_t) &rss_bucketid,
1243                            sizeof(uint32_t), IP_RSSBUCKETID, IPPROTO_IP);
1244                         if (*mp)
1245                                 mp = &(*mp)->m_next;
1246                 }
1247         }
1248 #endif
1249 }
1250
1251 /*
1252  * XXXRW: Multicast routing code in ip_mroute.c is generally MPSAFE, but the
1253  * ip_rsvp and ip_rsvp_on variables need to be interlocked with rsvp_on
1254  * locking.  This code remains in ip_input.c as ip_mroute.c is optionally
1255  * compiled.
1256  */
1257 static VNET_DEFINE(int, ip_rsvp_on);
1258 VNET_DEFINE(struct socket *, ip_rsvpd);
1259
1260 #define V_ip_rsvp_on            VNET(ip_rsvp_on)
1261
1262 int
1263 ip_rsvp_init(struct socket *so)
1264 {
1265
1266         if (so->so_type != SOCK_RAW ||
1267             so->so_proto->pr_protocol != IPPROTO_RSVP)
1268                 return EOPNOTSUPP;
1269
1270         if (V_ip_rsvpd != NULL)
1271                 return EADDRINUSE;
1272
1273         V_ip_rsvpd = so;
1274         /*
1275          * This may seem silly, but we need to be sure we don't over-increment
1276          * the RSVP counter, in case something slips up.
1277          */
1278         if (!V_ip_rsvp_on) {
1279                 V_ip_rsvp_on = 1;
1280                 V_rsvp_on++;
1281         }
1282
1283         return 0;
1284 }
1285
1286 int
1287 ip_rsvp_done(void)
1288 {
1289
1290         V_ip_rsvpd = NULL;
1291         /*
1292          * This may seem silly, but we need to be sure we don't over-decrement
1293          * the RSVP counter, in case something slips up.
1294          */
1295         if (V_ip_rsvp_on) {
1296                 V_ip_rsvp_on = 0;
1297                 V_rsvp_on--;
1298         }
1299         return 0;
1300 }
1301
1302 int
1303 rsvp_input(struct mbuf **mp, int *offp, int proto)
1304 {
1305         struct mbuf *m;
1306
1307         m = *mp;
1308         *mp = NULL;
1309
1310         if (rsvp_input_p) { /* call the real one if loaded */
1311                 *mp = m;
1312                 rsvp_input_p(mp, offp, proto);
1313                 return (IPPROTO_DONE);
1314         }
1315
1316         /* Can still get packets with rsvp_on = 0 if there is a local member
1317          * of the group to which the RSVP packet is addressed.  But in this
1318          * case we want to throw the packet away.
1319          */
1320
1321         if (!V_rsvp_on) {
1322                 m_freem(m);
1323                 return (IPPROTO_DONE);
1324         }
1325
1326         if (V_ip_rsvpd != NULL) {
1327                 *mp = m;
1328                 rip_input(mp, offp, proto);
1329                 return (IPPROTO_DONE);
1330         }
1331         /* Drop the packet */
1332         m_freem(m);
1333         return (IPPROTO_DONE);
1334 }