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  * $FreeBSD$
  31  */
  32
  33 #include "opt_bootp.h"
  34 #include "opt_ipfw.h"
  35 #include "opt_ipstealth.h"
  36 #include "opt_ipsec.h"
  37 #include "opt_mac.h"
  38 #include "opt_carp.h"
  39
  40 #include <sys/param.h>
  41 #include <sys/systm.h>
  42 #include <sys/callout.h>
  43 #include <sys/mbuf.h>
  44 #include <sys/malloc.h>
  45 #include <sys/domain.h>
  46 #include <sys/protosw.h>
  47 #include <sys/socket.h>
  48 #include <sys/time.h>
  49 #include <sys/kernel.h>
  50 #include <sys/syslog.h>
  51 #include <sys/sysctl.h>
  52
  53 #include <net/pfil.h>
  54 #include <net/if.h>
  55 #include <net/if_types.h>
  56 #include <net/if_var.h>
  57 #include <net/if_dl.h>
  58 #include <net/route.h>
  59 #include <net/netisr.h>
  60
  61 #include <netinet/in.h>
  62 #include <netinet/in_systm.h>
  63 #include <netinet/in_var.h>
  64 #include <netinet/ip.h>
  65 #include <netinet/in_pcb.h>
  66 #include <netinet/ip_var.h>
  67 #include <netinet/ip_icmp.h>
  68 #include <netinet/ip_options.h>
  69 #include <machine/in_cksum.h>
  70 #ifdef DEV_CARP
  71 #include <netinet/ip_carp.h>
  72 #endif
  73 #if defined(IPSEC) || defined(FAST_IPSEC)
  74 #include <netinet/ip_ipsec.h>
  75 #endif /* IPSEC */
  76
  77 #include <sys/socketvar.h>
  78
  79 /* XXX: Temporary until ipfw_ether and ipfw_bridge are converted. */
  80 #include <netinet/ip_fw.h>
  81 #include <netinet/ip_dummynet.h>
  82
  83 #include <security/mac/mac_framework.h>
  84
  85 int rsvp_on = 0;
  86
  87 int     ipforwarding = 0;
  88 SYSCTL_INT(_net_inet_ip, IPCTL_FORWARDING, forwarding, CTLFLAG_RW,
  89     &ipforwarding, 0, "Enable IP forwarding between interfaces");
  90
  91 static int      ipsendredirects = 1; /* XXX */
  92 SYSCTL_INT(_net_inet_ip, IPCTL_SENDREDIRECTS, redirect, CTLFLAG_RW,
  93     &ipsendredirects, 0, "Enable sending IP redirects");
  94
  95 int     ip_defttl = IPDEFTTL;
  96 SYSCTL_INT(_net_inet_ip, IPCTL_DEFTTL, ttl, CTLFLAG_RW,
  97     &ip_defttl, 0, "Maximum TTL on IP packets");
  98
  99 static int      ip_keepfaith = 0;
 100 SYSCTL_INT(_net_inet_ip, IPCTL_KEEPFAITH, keepfaith, CTLFLAG_RW,
 101     &ip_keepfaith,      0,
 102     "Enable packet capture for FAITH IPv4->IPv6 translater daemon");
 103
 104 static int      ip_sendsourcequench = 0;
 105 SYSCTL_INT(_net_inet_ip, OID_AUTO, sendsourcequench, CTLFLAG_RW,
 106     &ip_sendsourcequench, 0,
 107     "Enable the transmission of source quench packets");
 108
 109 int     ip_do_randomid = 0;
 110 SYSCTL_INT(_net_inet_ip, OID_AUTO, random_id, CTLFLAG_RW,
 111     &ip_do_randomid, 0,
 112     "Assign random ip_id values");
 113
 114 /*
 115  * XXX - Setting ip_checkinterface mostly implements the receive side of
 116  * the Strong ES model described in RFC 1122, but since the routing table
 117  * and transmit implementation do not implement the Strong ES model,
 118  * setting this to 1 results in an odd hybrid.
 119  *
 120  * XXX - ip_checkinterface currently must be disabled if you use ipnat
 121  * to translate the destination address to another local interface.
 122  *
 123  * XXX - ip_checkinterface must be disabled if you add IP aliases
 124  * to the loopback interface instead of the interface where the
 125  * packets for those addresses are received.
 126  */
 127 static int      ip_checkinterface = 0;
 128 SYSCTL_INT(_net_inet_ip, OID_AUTO, check_interface, CTLFLAG_RW,
 129     &ip_checkinterface, 0, "Verify packet arrives on correct interface");
 130
 131 struct pfil_head inet_pfil_hook;        /* Packet filter hooks */
 132
 133 static struct   ifqueue ipintrq;
 134 static int      ipqmaxlen = IFQ_MAXLEN;
 135
 136 extern  struct domain inetdomain;
 137 extern  struct protosw inetsw[];
 138 u_char  ip_protox[IPPROTO_MAX];
 139 struct  in_ifaddrhead in_ifaddrhead;            /* first inet address */
 140 struct  in_ifaddrhashhead *in_ifaddrhashtbl;    /* inet addr hash table  */
 141 u_long  in_ifaddrhmask;                         /* mask for hash table */
 142
 143 SYSCTL_INT(_net_inet_ip, IPCTL_INTRQMAXLEN, intr_queue_maxlen, CTLFLAG_RW,
 144     &ipintrq.ifq_maxlen, 0, "Maximum size of the IP input queue");
 145 SYSCTL_INT(_net_inet_ip, IPCTL_INTRQDROPS, intr_queue_drops, CTLFLAG_RD,
 146     &ipintrq.ifq_drops, 0,
 147     "Number of packets dropped from the IP input queue");
 148
 149 struct ipstat ipstat;
 150 SYSCTL_STRUCT(_net_inet_ip, IPCTL_STATS, stats, CTLFLAG_RW,
 151     &ipstat, ipstat, "IP statistics (struct ipstat, netinet/ip_var.h)");
 152
 153 /*
 154  * IP datagram reassembly.
 155  */
 156 #define IPREASS_NHASH_LOG2      6
 157 #define IPREASS_NHASH           (1 << IPREASS_NHASH_LOG2)
 158 #define IPREASS_HMASK           (IPREASS_NHASH - 1)
 159 #define IPREASS_HASH(x,y) \
 160         (((((x) & 0xF) | ((((x) >> 8) & 0xF) << 4)) ^ (y)) & IPREASS_HMASK)
 161
 162 static uma_zone_t ipq_zone;
 163 static TAILQ_HEAD(ipqhead, ipq) ipq[IPREASS_NHASH];
 164 static struct mtx ipqlock;
 165
 166 #define IPQ_LOCK()      mtx_lock(&ipqlock)
 167 #define IPQ_UNLOCK()    mtx_unlock(&ipqlock)
 168 #define IPQ_LOCK_INIT() mtx_init(&ipqlock, "ipqlock", NULL, MTX_DEF)
 169 #define IPQ_LOCK_ASSERT()       mtx_assert(&ipqlock, MA_OWNED)
 170
 171 static void     maxnipq_update(void);
 172 static void     ipq_zone_change(void *);
 173
 174 static int      maxnipq;        /* Administrative limit on # reass queues. */
 175 static int      nipq = 0;       /* Total # of reass queues */
 176 SYSCTL_INT(_net_inet_ip, OID_AUTO, fragpackets, CTLFLAG_RD,
 177     &nipq, 0, "Current number of IPv4 fragment reassembly queue entries");
 178
 179 static int      maxfragsperpacket;
 180 SYSCTL_INT(_net_inet_ip, OID_AUTO, maxfragsperpacket, CTLFLAG_RW,
 181     &maxfragsperpacket, 0,
 182     "Maximum number of IPv4 fragments allowed per packet");
 183
 184 struct callout  ipport_tick_callout;
 185
 186 #ifdef IPCTL_DEFMTU
 187 SYSCTL_INT(_net_inet_ip, IPCTL_DEFMTU, mtu, CTLFLAG_RW,
 188     &ip_mtu, 0, "Default MTU");
 189 #endif
 190
 191 #ifdef IPSTEALTH
 192 int     ipstealth = 0;
 193 SYSCTL_INT(_net_inet_ip, OID_AUTO, stealth, CTLFLAG_RW,
 194     &ipstealth, 0, "IP stealth mode, no TTL decrementation on forwarding");
 195 #endif
 196
 197 /*
 198  * ipfw_ether and ipfw_bridge hooks.
 199  * XXX: Temporary until those are converted to pfil_hooks as well.
 200  */
 201 ip_fw_chk_t *ip_fw_chk_ptr = NULL;
 202 ip_dn_io_t *ip_dn_io_ptr = NULL;
 203 int fw_one_pass = 1;
 204
 205 static void     ip_freef(struct ipqhead *, struct ipq *);
 206
 207 /*
 208  * IP initialization: fill in IP protocol switch table.
 209  * All protocols not implemented in kernel go to raw IP protocol handler.
 210  */
 211 void
 212 ip_init()
 213 {
 214         register struct protosw *pr;
 215         register int i;
 216
 217         TAILQ_INIT(&in_ifaddrhead);
 218         in_ifaddrhashtbl = hashinit(INADDR_NHASH, M_IFADDR, &in_ifaddrhmask);
 219         pr = pffindproto(PF_INET, IPPROTO_RAW, SOCK_RAW);
 220         if (pr == NULL)
 221                 panic("ip_init: PF_INET not found");
 222
 223         /* Initialize the entire ip_protox[] array to IPPROTO_RAW. */
 224         for (i = 0; i < IPPROTO_MAX; i++)
 225                 ip_protox[i] = pr - inetsw;
 226         /*
 227          * Cycle through IP protocols and put them into the appropriate place
 228          * in ip_protox[].
 229          */
 230         for (pr = inetdomain.dom_protosw;
 231             pr < inetdomain.dom_protoswNPROTOSW; pr++)
 232                 if (pr->pr_domain->dom_family == PF_INET &&
 233                     pr->pr_protocol && pr->pr_protocol != IPPROTO_RAW) {
 234                         /* Be careful to only index valid IP protocols. */
 235                         if (pr->pr_protocol < IPPROTO_MAX)
 236                                 ip_protox[pr->pr_protocol] = pr - inetsw;
 237                 }
 238
 239         /* Initialize packet filter hooks. */
 240         inet_pfil_hook.ph_type = PFIL_TYPE_AF;
 241         inet_pfil_hook.ph_af = AF_INET;
 242         if ((i = pfil_head_register(&inet_pfil_hook)) != 0)
 243                 printf("%s: WARNING: unable to register pfil hook, "
 244                         "error %d\n", __func__, i);
 245
 246         /* Initialize IP reassembly queue. */
 247         IPQ_LOCK_INIT();
 248         for (i = 0; i < IPREASS_NHASH; i++)
 249             TAILQ_INIT(&ipq[i]);
 250         maxnipq = nmbclusters / 32;
 251         maxfragsperpacket = 16;
 252         ipq_zone = uma_zcreate("ipq", sizeof(struct ipq), NULL, NULL, NULL,
 253             NULL, UMA_ALIGN_PTR, 0);
 254         maxnipq_update();
 255
 256         /* Start ipport_tick. */
 257         callout_init(&ipport_tick_callout, CALLOUT_MPSAFE);
 258         ipport_tick(NULL);
 259         EVENTHANDLER_REGISTER(shutdown_pre_sync, ip_fini, NULL,
 260                 SHUTDOWN_PRI_DEFAULT);
 261         EVENTHANDLER_REGISTER(nmbclusters_change, ipq_zone_change,
 262                 NULL, EVENTHANDLER_PRI_ANY);
 263
 264         /* Initialize various other remaining things. */
 265         ip_id = time_second & 0xffff;
 266         ipintrq.ifq_maxlen = ipqmaxlen;
 267         mtx_init(&ipintrq.ifq_mtx, "ip_inq", NULL, MTX_DEF);
 268         netisr_register(NETISR_IP, ip_input, &ipintrq, NETISR_MPSAFE);
 269 }
 270
 271 void ip_fini(xtp)
 272         void *xtp;
 273 {
 274         callout_stop(&ipport_tick_callout);
 275 }
 276
 277 /*
 278  * Ip input routine.  Checksum and byte swap header.  If fragmented
 279  * try to reassemble.  Process options.  Pass to next level.
 280  */
 281 void
 282 ip_input(struct mbuf *m)
 283 {
 284         struct ip *ip = NULL;
 285         struct in_ifaddr *ia = NULL;
 286         struct ifaddr *ifa;
 287         int    checkif, hlen = 0;
 288         u_short sum;
 289         int dchg = 0;                           /* dest changed after fw */
 290         struct in_addr odst;                    /* original dst address */
 291
 292         M_ASSERTPKTHDR(m);
 293
 294         if (m->m_flags & M_FASTFWD_OURS) {
 295                 /*
 296                  * Firewall or NAT changed destination to local.
 297                  * We expect ip_len and ip_off to be in host byte order.
 298                  */
 299                 m->m_flags &= ~M_FASTFWD_OURS;
 300                 /* Set up some basics that will be used later. */
 301                 ip = mtod(m, struct ip *);
 302                 hlen = ip->ip_hl << 2;
 303                 goto ours;
 304         }
 305
 306         ipstat.ips_total++;
 307
 308         if (m->m_pkthdr.len < sizeof(struct ip))
 309                 goto tooshort;
 310
 311         if (m->m_len < sizeof (struct ip) &&
 312             (m = m_pullup(m, sizeof (struct ip))) == NULL) {
 313                 ipstat.ips_toosmall++;
 314                 return;
 315         }
 316         ip = mtod(m, struct ip *);
 317
 318         if (ip->ip_v != IPVERSION) {
 319                 ipstat.ips_badvers++;
 320                 goto bad;
 321         }
 322
 323         hlen = ip->ip_hl << 2;
 324         if (hlen < sizeof(struct ip)) { /* minimum header length */
 325                 ipstat.ips_badhlen++;
 326                 goto bad;
 327         }
 328         if (hlen > m->m_len) {
 329                 if ((m = m_pullup(m, hlen)) == NULL) {
 330                         ipstat.ips_badhlen++;
 331                         return;
 332                 }
 333                 ip = mtod(m, struct ip *);
 334         }
 335
 336         /* 127/8 must not appear on wire - RFC1122 */
 337         if ((ntohl(ip->ip_dst.s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET ||
 338             (ntohl(ip->ip_src.s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET) {
 339                 if ((m->m_pkthdr.rcvif->if_flags & IFF_LOOPBACK) == 0) {
 340                         ipstat.ips_badaddr++;
 341                         goto bad;
 342                 }
 343         }
 344
 345         if (m->m_pkthdr.csum_flags & CSUM_IP_CHECKED) {
 346                 sum = !(m->m_pkthdr.csum_flags & CSUM_IP_VALID);
 347         } else {
 348                 if (hlen == sizeof(struct ip)) {
 349                         sum = in_cksum_hdr(ip);
 350                 } else {
 351                         sum = in_cksum(m, hlen);
 352                 }
 353         }
 354         if (sum) {
 355                 ipstat.ips_badsum++;
 356                 goto bad;
 357         }
 358
 359 #ifdef ALTQ
 360         if (altq_input != NULL && (*altq_input)(m, AF_INET) == 0)
 361                 /* packet is dropped by traffic conditioner */
 362                 return;
 363 #endif
 364
 365         /*
 366          * Convert fields to host representation.
 367          */
 368         ip->ip_len = ntohs(ip->ip_len);
 369         if (ip->ip_len < hlen) {
 370                 ipstat.ips_badlen++;
 371                 goto bad;
 372         }
 373         ip->ip_off = ntohs(ip->ip_off);
 374
 375         /*
 376          * Check that the amount of data in the buffers
 377          * is as at least much as the IP header would have us expect.
 378          * Trim mbufs if longer than we expect.
 379          * Drop packet if shorter than we expect.
 380          */
 381         if (m->m_pkthdr.len < ip->ip_len) {
 382 tooshort:
 383                 ipstat.ips_tooshort++;
 384                 goto bad;
 385         }
 386         if (m->m_pkthdr.len > ip->ip_len) {
 387                 if (m->m_len == m->m_pkthdr.len) {
 388                         m->m_len = ip->ip_len;
 389                         m->m_pkthdr.len = ip->ip_len;
 390                 } else
 391                         m_adj(m, ip->ip_len - m->m_pkthdr.len);
 392         }
 393 #if defined(IPSEC) || defined(FAST_IPSEC)
 394         /*
 395          * Bypass packet filtering for packets from a tunnel (gif).
 396          */
 397         if (ip_ipsec_filtergif(m))
 398                 goto passin;
 399 #endif /* IPSEC */
 400
 401         /*
 402          * Run through list of hooks for input packets.
 403          *
 404          * NB: Beware of the destination address changing (e.g.
 405          *     by NAT rewriting).  When this happens, tell
 406          *     ip_forward to do the right thing.
 407          */
 408
 409         /* Jump over all PFIL processing if hooks are not active. */
 410         if (!PFIL_HOOKED(&inet_pfil_hook))
 411                 goto passin;
 412
 413         odst = ip->ip_dst;
 414         if (pfil_run_hooks(&inet_pfil_hook, &m, m->m_pkthdr.rcvif,
 415             PFIL_IN, NULL) != 0)
 416                 return;
 417         if (m == NULL)                  /* consumed by filter */
 418                 return;
 419
 420         ip = mtod(m, struct ip *);
 421         dchg = (odst.s_addr != ip->ip_dst.s_addr);
 422
 423 #ifdef IPFIREWALL_FORWARD
 424         if (m->m_flags & M_FASTFWD_OURS) {
 425                 m->m_flags &= ~M_FASTFWD_OURS;
 426                 goto ours;
 427         }
 428         if ((dchg = (m_tag_find(m, PACKET_TAG_IPFORWARD, NULL) != NULL)) != 0) {
 429                 /*
 430                  * Directly ship on the packet.  This allows to forward packets
 431                  * that were destined for us to some other directly connected
 432                  * host.
 433                  */
 434                 ip_forward(m, dchg);
 435                 return;
 436         }
 437 #endif /* IPFIREWALL_FORWARD */
 438
 439 passin:
 440         /*
 441          * Process options and, if not destined for us,
 442          * ship it on.  ip_dooptions returns 1 when an
 443          * error was detected (causing an icmp message
 444          * to be sent and the original packet to be freed).
 445          */
 446         if (hlen > sizeof (struct ip) && ip_dooptions(m, 0))
 447                 return;
 448
 449         /* greedy RSVP, snatches any PATH packet of the RSVP protocol and no
 450          * matter if it is destined to another node, or whether it is
 451          * a multicast one, RSVP wants it! and prevents it from being forwarded
 452          * anywhere else. Also checks if the rsvp daemon is running before
 453          * grabbing the packet.
 454          */
 455         if (rsvp_on && ip->ip_p==IPPROTO_RSVP)
 456                 goto ours;
 457
 458         /*
 459          * Check our list of addresses, to see if the packet is for us.
 460          * If we don't have any addresses, assume any unicast packet
 461          * we receive might be for us (and let the upper layers deal
 462          * with it).
 463          */
 464         if (TAILQ_EMPTY(&in_ifaddrhead) &&
 465             (m->m_flags & (M_MCAST|M_BCAST)) == 0)
 466                 goto ours;
 467
 468         /*
 469          * Enable a consistency check between the destination address
 470          * and the arrival interface for a unicast packet (the RFC 1122
 471          * strong ES model) if IP forwarding is disabled and the packet
 472          * is not locally generated and the packet is not subject to
 473          * 'ipfw fwd'.
 474          *
 475          * XXX - Checking also should be disabled if the destination
 476          * address is ipnat'ed to a different interface.
 477          *
 478          * XXX - Checking is incompatible with IP aliases added
 479          * to the loopback interface instead of the interface where
 480          * the packets are received.
 481          *
 482          * XXX - This is the case for carp vhost IPs as well so we
 483          * insert a workaround. If the packet got here, we already
 484          * checked with carp_iamatch() and carp_forus().
 485          */
 486         checkif = ip_checkinterface && (ipforwarding == 0) &&
 487             m->m_pkthdr.rcvif != NULL &&
 488             ((m->m_pkthdr.rcvif->if_flags & IFF_LOOPBACK) == 0) &&
 489 #ifdef DEV_CARP
 490             !m->m_pkthdr.rcvif->if_carp &&
 491 #endif
 492             (dchg == 0);
 493
 494         /*
 495          * Check for exact addresses in the hash bucket.
 496          */
 497         LIST_FOREACH(ia, INADDR_HASH(ip->ip_dst.s_addr), ia_hash) {
 498                 /*
 499                  * If the address matches, verify that the packet
 500                  * arrived via the correct interface if checking is
 501                  * enabled.
 502                  */
 503                 if (IA_SIN(ia)->sin_addr.s_addr == ip->ip_dst.s_addr &&
 504                     (!checkif || ia->ia_ifp == m->m_pkthdr.rcvif))
 505                         goto ours;
 506         }
 507         /*
 508          * Check for broadcast addresses.
 509          *
 510          * Only accept broadcast packets that arrive via the matching
 511          * interface.  Reception of forwarded directed broadcasts would
 512          * be handled via ip_forward() and ether_output() with the loopback
 513          * into the stack for SIMPLEX interfaces handled by ether_output().
 514          */
 515         if (m->m_pkthdr.rcvif != NULL &&
 516             m->m_pkthdr.rcvif->if_flags & IFF_BROADCAST) {
 517                 TAILQ_FOREACH(ifa, &m->m_pkthdr.rcvif->if_addrhead, ifa_link) {
 518                         if (ifa->ifa_addr->sa_family != AF_INET)
 519                                 continue;
 520                         ia = ifatoia(ifa);
 521                         if (satosin(&ia->ia_broadaddr)->sin_addr.s_addr ==
 522                             ip->ip_dst.s_addr)
 523                                 goto ours;
 524                         if (ia->ia_netbroadcast.s_addr == ip->ip_dst.s_addr)
 525                                 goto ours;
 526 #ifdef BOOTP_COMPAT
 527                         if (IA_SIN(ia)->sin_addr.s_addr == INADDR_ANY)
 528                                 goto ours;
 529 #endif
 530                 }
 531         }
 532         /* RFC 3927 2.7: Do not forward datagrams for 169.254.0.0/16. */
 533         if (IN_LINKLOCAL(ntohl(ip->ip_dst.s_addr))) {
 534                 ipstat.ips_cantforward++;
 535                 m_freem(m);
 536                 return;
 537         }
 538         if (IN_MULTICAST(ntohl(ip->ip_dst.s_addr))) {
 539                 struct in_multi *inm;
 540                 if (ip_mrouter) {
 541                         /*
 542                          * If we are acting as a multicast router, all
 543                          * incoming multicast packets are passed to the
 544                          * kernel-level multicast forwarding function.
 545                          * The packet is returned (relatively) intact; if
 546                          * ip_mforward() returns a non-zero value, the packet
 547                          * must be discarded, else it may be accepted below.
 548                          */
 549                         if (ip_mforward &&
 550                             ip_mforward(ip, m->m_pkthdr.rcvif, m, 0) != 0) {
 551                                 ipstat.ips_cantforward++;
 552                                 m_freem(m);
 553                                 return;
 554                         }
 555
 556                         /*
 557                          * The process-level routing daemon needs to receive
 558                          * all multicast IGMP packets, whether or not this
 559                          * host belongs to their destination groups.
 560                          */
 561                         if (ip->ip_p == IPPROTO_IGMP)
 562                                 goto ours;
 563                         ipstat.ips_forward++;
 564                 }
 565                 /*
 566                  * See if we belong to the destination multicast group on the
 567                  * arrival interface.
 568                  */
 569                 IN_MULTI_LOCK();
 570                 IN_LOOKUP_MULTI(ip->ip_dst, m->m_pkthdr.rcvif, inm);
 571                 IN_MULTI_UNLOCK();
 572                 if (inm == NULL) {
 573                         ipstat.ips_notmember++;
 574                         m_freem(m);
 575                         return;
 576                 }
 577                 goto ours;
 578         }
 579         if (ip->ip_dst.s_addr == (u_long)INADDR_BROADCAST)
 580                 goto ours;
 581         if (ip->ip_dst.s_addr == INADDR_ANY)
 582                 goto ours;
 583
 584         /*
 585          * FAITH(Firewall Aided Internet Translator)
 586          */
 587         if (m->m_pkthdr.rcvif && m->m_pkthdr.rcvif->if_type == IFT_FAITH) {
 588                 if (ip_keepfaith) {
 589                         if (ip->ip_p == IPPROTO_TCP || ip->ip_p == IPPROTO_ICMP)
 590                                 goto ours;
 591                 }
 592                 m_freem(m);
 593                 return;
 594         }
 595
 596         /*
 597          * Not for us; forward if possible and desirable.
 598          */
 599         if (ipforwarding == 0) {
 600                 ipstat.ips_cantforward++;
 601                 m_freem(m);
 602         } else {
 603 #if defined(IPSEC) || defined(FAST_IPSEC)
 604                 if (ip_ipsec_fwd(m))
 605                         goto bad;
 606 #endif /* IPSEC */
 607                 ip_forward(m, dchg);
 608         }
 609         return;
 610
 611 ours:
 612 #ifdef IPSTEALTH
 613         /*
 614          * IPSTEALTH: Process non-routing options only
 615          * if the packet is destined for us.
 616          */
 617         if (ipstealth && hlen > sizeof (struct ip) &&
 618             ip_dooptions(m, 1))
 619                 return;
 620 #endif /* IPSTEALTH */
 621
 622         /* Count the packet in the ip address stats */
 623         if (ia != NULL) {
 624                 ia->ia_ifa.if_ipackets++;
 625                 ia->ia_ifa.if_ibytes += m->m_pkthdr.len;
 626         }
 627
 628         /*
 629          * Attempt reassembly; if it succeeds, proceed.
 630          * ip_reass() will return a different mbuf.
 631          */
 632         if (ip->ip_off & (IP_MF | IP_OFFMASK)) {
 633                 m = ip_reass(m);
 634                 if (m == NULL)
 635                         return;
 636                 ip = mtod(m, struct ip *);
 637                 /* Get the header length of the reassembled packet */
 638                 hlen = ip->ip_hl << 2;
 639         }
 640
 641         /*
 642          * Further protocols expect the packet length to be w/o the
 643          * IP header.
 644          */
 645         ip->ip_len -= hlen;
 646
 647 #if defined(IPSEC) || defined(FAST_IPSEC)
 648         /*
 649          * enforce IPsec policy checking if we are seeing last header.
 650          * note that we do not visit this with protocols with pcb layer
 651          * code - like udp/tcp/raw ip.
 652          */
 653         if (ip_ipsec_input(m))
 654                 goto bad;
 655 #endif /* IPSEC */
 656
 657         /*
 658          * Switch out to protocol's input routine.
 659          */
 660         ipstat.ips_delivered++;
 661
 662         (*inetsw[ip_protox[ip->ip_p]].pr_input)(m, hlen);
 663         return;
 664 bad:
 665         m_freem(m);
 666 }
 667
 668 /*
 669  * After maxnipq has been updated, propagate the change to UMA.  The UMA zone
 670  * max has slightly different semantics than the sysctl, for historical
 671  * reasons.
 672  */
 673 static void
 674 maxnipq_update(void)
 675 {
 676
 677         /*
 678          * -1 for unlimited allocation.
 679          */
 680         if (maxnipq < 0)
 681                 uma_zone_set_max(ipq_zone, 0);
 682         /*
 683          * Positive number for specific bound.
 684          */
 685         if (maxnipq > 0)
 686                 uma_zone_set_max(ipq_zone, maxnipq);
 687         /*
 688          * Zero specifies no further fragment queue allocation -- set the
 689          * bound very low, but rely on implementation elsewhere to actually
 690          * prevent allocation and reclaim current queues.
 691          */
 692         if (maxnipq == 0)
 693                 uma_zone_set_max(ipq_zone, 1);
 694 }
 695
 696 static void
 697 ipq_zone_change(void *tag)
 698 {
 699
 700         if (maxnipq > 0 && maxnipq < (nmbclusters / 32)) {
 701                 maxnipq = nmbclusters / 32;
 702                 maxnipq_update();
 703         }
 704 }
 705
 706 static int
 707 sysctl_maxnipq(SYSCTL_HANDLER_ARGS)
 708 {
 709         int error, i;
 710
 711         i = maxnipq;
 712         error = sysctl_handle_int(oidp, &i, 0, req);
 713         if (error || !req->newptr)
 714                 return (error);
 715
 716         /*
 717          * XXXRW: Might be a good idea to sanity check the argument and place
 718          * an extreme upper bound.
 719          */
 720         if (i < -1)
 721                 return (EINVAL);
 722         maxnipq = i;
 723         maxnipq_update();
 724         return (0);
 725 }
 726
 727 SYSCTL_PROC(_net_inet_ip, OID_AUTO, maxfragpackets, CTLTYPE_INT|CTLFLAG_RW,
 728     NULL, 0, sysctl_maxnipq, "I",
 729     "Maximum number of IPv4 fragment reassembly queue entries");
 730
 731 /*
 732  * Take incoming datagram fragment and try to reassemble it into
 733  * whole datagram.  If the argument is the first fragment or one
 734  * in between the function will return NULL and store the mbuf
 735  * in the fragment chain.  If the argument is the last fragment
 736  * the packet will be reassembled and the pointer to the new
 737  * mbuf returned for further processing.  Only m_tags attached
 738  * to the first packet/fragment are preserved.
 739  * The IP header is *NOT* adjusted out of iplen.
 740  */
 741
 742 struct mbuf *
 743 ip_reass(struct mbuf *m)
 744 {
 745         struct ip *ip;
 746         struct mbuf *p, *q, *nq, *t;
 747         struct ipq *fp = NULL;
 748         struct ipqhead *head;
 749         int i, hlen, next;
 750         u_int8_t ecn, ecn0;
 751         u_short hash;
 752
 753         /* If maxnipq or maxfragsperpacket are 0, never accept fragments. */
 754         if (maxnipq == 0 || maxfragsperpacket == 0) {
 755                 ipstat.ips_fragments++;
 756                 ipstat.ips_fragdropped++;
 757                 m_freem(m);
 758                 return (NULL);
 759         }
 760
 761         ip = mtod(m, struct ip *);
 762         hlen = ip->ip_hl << 2;
 763
 764         hash = IPREASS_HASH(ip->ip_src.s_addr, ip->ip_id);
 765         head = &ipq[hash];
 766         IPQ_LOCK();
 767
 768         /*
 769          * Look for queue of fragments
 770          * of this datagram.
 771          */
 772         TAILQ_FOREACH(fp, head, ipq_list)
 773                 if (ip->ip_id == fp->ipq_id &&
 774                     ip->ip_src.s_addr == fp->ipq_src.s_addr &&
 775                     ip->ip_dst.s_addr == fp->ipq_dst.s_addr &&
 776 #ifdef MAC
 777                     mac_fragment_match(m, fp) &&
 778 #endif
 779                     ip->ip_p == fp->ipq_p)
 780                         goto found;
 781
 782         fp = NULL;
 783
 784         /*
 785          * Attempt to trim the number of allocated fragment queues if it
 786          * exceeds the administrative limit.
 787          */
 788         if ((nipq > maxnipq) && (maxnipq > 0)) {
 789                 /*
 790                  * drop something from the tail of the current queue
 791                  * before proceeding further
 792                  */
 793                 struct ipq *q = TAILQ_LAST(head, ipqhead);
 794                 if (q == NULL) {   /* gak */
 795                         for (i = 0; i < IPREASS_NHASH; i++) {
 796                                 struct ipq *r = TAILQ_LAST(&ipq[i], ipqhead);
 797                                 if (r) {
 798                                         ipstat.ips_fragtimeout += r->ipq_nfrags;
 799                                         ip_freef(&ipq[i], r);
 800                                         break;
 801                                 }
 802                         }
 803                 } else {
 804                         ipstat.ips_fragtimeout += q->ipq_nfrags;
 805                         ip_freef(head, q);
 806                 }
 807         }
 808
 809 found:
 810         /*
 811          * Adjust ip_len to not reflect header,
 812          * convert offset of this to bytes.
 813          */
 814         ip->ip_len -= hlen;
 815         if (ip->ip_off & IP_MF) {
 816                 /*
 817                  * Make sure that fragments have a data length
 818                  * that's a non-zero multiple of 8 bytes.
 819                  */
 820                 if (ip->ip_len == 0 || (ip->ip_len & 0x7) != 0) {
 821                         ipstat.ips_toosmall++; /* XXX */
 822                         goto dropfrag;
 823                 }
 824                 m->m_flags |= M_FRAG;
 825         } else
 826                 m->m_flags &= ~M_FRAG;
 827         ip->ip_off <<= 3;
 828
 829
 830         /*
 831          * Attempt reassembly; if it succeeds, proceed.
 832          * ip_reass() will return a different mbuf.
 833          */
 834         ipstat.ips_fragments++;
 835         m->m_pkthdr.header = ip;
 836
 837         /* Previous ip_reass() started here. */
 838         /*
 839          * Presence of header sizes in mbufs
 840          * would confuse code below.
 841          */
 842         m->m_data += hlen;
 843         m->m_len -= hlen;
 844
 845         /*
 846          * If first fragment to arrive, create a reassembly queue.
 847          */
 848         if (fp == NULL) {
 849                 fp = uma_zalloc(ipq_zone, M_NOWAIT);
 850                 if (fp == NULL)
 851                         goto dropfrag;
 852 #ifdef MAC
 853                 if (mac_init_ipq(fp, M_NOWAIT) != 0) {
 854                         uma_zfree(ipq_zone, fp);
 855                         fp = NULL;
 856                         goto dropfrag;
 857                 }
 858                 mac_create_ipq(m, fp);
 859 #endif
 860                 TAILQ_INSERT_HEAD(head, fp, ipq_list);
 861                 nipq++;
 862                 fp->ipq_nfrags = 1;
 863                 fp->ipq_ttl = IPFRAGTTL;
 864                 fp->ipq_p = ip->ip_p;
 865                 fp->ipq_id = ip->ip_id;
 866                 fp->ipq_src = ip->ip_src;
 867                 fp->ipq_dst = ip->ip_dst;
 868                 fp->ipq_frags = m;
 869                 m->m_nextpkt = NULL;
 870                 goto done;
 871         } else {
 872                 fp->ipq_nfrags++;
 873 #ifdef MAC
 874                 mac_update_ipq(m, fp);
 875 #endif
 876         }
 877
 878 #define GETIP(m)        ((struct ip*)((m)->m_pkthdr.header))
 879
 880         /*
 881          * Handle ECN by comparing this segment with the first one;
 882          * if CE is set, do not lose CE.
 883          * drop if CE and not-ECT are mixed for the same packet.
 884          */
 885         ecn = ip->ip_tos & IPTOS_ECN_MASK;
 886         ecn0 = GETIP(fp->ipq_frags)->ip_tos & IPTOS_ECN_MASK;
 887         if (ecn == IPTOS_ECN_CE) {
 888                 if (ecn0 == IPTOS_ECN_NOTECT)
 889                         goto dropfrag;
 890                 if (ecn0 != IPTOS_ECN_CE)
 891                         GETIP(fp->ipq_frags)->ip_tos |= IPTOS_ECN_CE;
 892         }
 893         if (ecn == IPTOS_ECN_NOTECT && ecn0 != IPTOS_ECN_NOTECT)
 894                 goto dropfrag;
 895
 896         /*
 897          * Find a segment which begins after this one does.
 898          */
 899         for (p = NULL, q = fp->ipq_frags; q; p = q, q = q->m_nextpkt)
 900                 if (GETIP(q)->ip_off > ip->ip_off)
 901                         break;
 902
 903         /*
 904          * If there is a preceding segment, it may provide some of
 905          * our data already.  If so, drop the data from the incoming
 906          * segment.  If it provides all of our data, drop us, otherwise
 907          * stick new segment in the proper place.
 908          *
 909          * If some of the data is dropped from the the preceding
 910          * segment, then it's checksum is invalidated.
 911          */
 912         if (p) {
 913                 i = GETIP(p)->ip_off + GETIP(p)->ip_len - ip->ip_off;
 914                 if (i > 0) {
 915                         if (i >= ip->ip_len)
 916                                 goto dropfrag;
 917                         m_adj(m, i);
 918                         m->m_pkthdr.csum_flags = 0;
 919                         ip->ip_off += i;
 920                         ip->ip_len -= i;
 921                 }
 922                 m->m_nextpkt = p->m_nextpkt;
 923                 p->m_nextpkt = m;
 924         } else {
 925                 m->m_nextpkt = fp->ipq_frags;
 926                 fp->ipq_frags = m;
 927         }
 928
 929         /*
 930          * While we overlap succeeding segments trim them or,
 931          * if they are completely covered, dequeue them.
 932          */
 933         for (; q != NULL && ip->ip_off + ip->ip_len > GETIP(q)->ip_off;
 934              q = nq) {
 935                 i = (ip->ip_off + ip->ip_len) - GETIP(q)->ip_off;
 936                 if (i < GETIP(q)->ip_len) {
 937                         GETIP(q)->ip_len -= i;
 938                         GETIP(q)->ip_off += i;
 939                         m_adj(q, i);
 940                         q->m_pkthdr.csum_flags = 0;
 941                         break;
 942                 }
 943                 nq = q->m_nextpkt;
 944                 m->m_nextpkt = nq;
 945                 ipstat.ips_fragdropped++;
 946                 fp->ipq_nfrags--;
 947                 m_freem(q);
 948         }
 949
 950         /*
 951          * Check for complete reassembly and perform frag per packet
 952          * limiting.
 953          *
 954          * Frag limiting is performed here so that the nth frag has
 955          * a chance to complete the packet before we drop the packet.
 956          * As a result, n+1 frags are actually allowed per packet, but
 957          * only n will ever be stored. (n = maxfragsperpacket.)
 958          *
 959          */
 960         next = 0;
 961         for (p = NULL, q = fp->ipq_frags; q; p = q, q = q->m_nextpkt) {
 962                 if (GETIP(q)->ip_off != next) {
 963                         if (fp->ipq_nfrags > maxfragsperpacket) {
 964                                 ipstat.ips_fragdropped += fp->ipq_nfrags;
 965                                 ip_freef(head, fp);
 966                         }
 967                         goto done;
 968                 }
 969                 next += GETIP(q)->ip_len;
 970         }
 971         /* Make sure the last packet didn't have the IP_MF flag */
 972         if (p->m_flags & M_FRAG) {
 973                 if (fp->ipq_nfrags > maxfragsperpacket) {
 974                         ipstat.ips_fragdropped += fp->ipq_nfrags;
 975                         ip_freef(head, fp);
 976                 }
 977                 goto done;
 978         }
 979
 980         /*
 981          * Reassembly is complete.  Make sure the packet is a sane size.
 982          */
 983         q = fp->ipq_frags;
 984         ip = GETIP(q);
 985         if (next + (ip->ip_hl << 2) > IP_MAXPACKET) {
 986                 ipstat.ips_toolong++;
 987                 ipstat.ips_fragdropped += fp->ipq_nfrags;
 988                 ip_freef(head, fp);
 989                 goto done;
 990         }
 991
 992         /*
 993          * Concatenate fragments.
 994          */
 995         m = q;
 996         t = m->m_next;
 997         m->m_next = NULL;
 998         m_cat(m, t);
 999         nq = q->m_nextpkt;
1000         q->m_nextpkt = NULL;
1001         for (q = nq; q != NULL; q = nq) {
1002                 nq = q->m_nextpkt;
1003                 q->m_nextpkt = NULL;
1004                 m->m_pkthdr.csum_flags &= q->m_pkthdr.csum_flags;
1005                 m->m_pkthdr.csum_data += q->m_pkthdr.csum_data;
1006                 m_cat(m, q);
1007         }
1008         /*
1009          * In order to do checksumming faster we do 'end-around carry' here
1010          * (and not in for{} loop), though it implies we are not going to
1011          * reassemble more than 64k fragments.
1012          */
1013         m->m_pkthdr.csum_data =
1014             (m->m_pkthdr.csum_data & 0xffff) + (m->m_pkthdr.csum_data >> 16);
1015 #ifdef MAC
1016         mac_create_datagram_from_ipq(fp, m);
1017         mac_destroy_ipq(fp);
1018 #endif
1019
1020         /*
1021          * Create header for new ip packet by modifying header of first
1022          * packet;  dequeue and discard fragment reassembly header.
1023          * Make header visible.
1024          */
1025         ip->ip_len = (ip->ip_hl << 2) + next;
1026         ip->ip_src = fp->ipq_src;
1027         ip->ip_dst = fp->ipq_dst;
1028         TAILQ_REMOVE(head, fp, ipq_list);
1029         nipq--;
1030         uma_zfree(ipq_zone, fp);
1031         m->m_len += (ip->ip_hl << 2);
1032         m->m_data -= (ip->ip_hl << 2);
1033         /* some debugging cruft by sklower, below, will go away soon */
1034         if (m->m_flags & M_PKTHDR)      /* XXX this should be done elsewhere */
1035                 m_fixhdr(m);
1036         ipstat.ips_reassembled++;
1037         IPQ_UNLOCK();
1038         return (m);
1039
1040 dropfrag:
1041         ipstat.ips_fragdropped++;
1042         if (fp != NULL)
1043                 fp->ipq_nfrags--;
1044         m_freem(m);
1045 done:
1046         IPQ_UNLOCK();
1047         return (NULL);
1048
1049 #undef GETIP
1050 }
1051
1052 /*
1053  * Free a fragment reassembly header and all
1054  * associated datagrams.
1055  */
1056 static void
1057 ip_freef(fhp, fp)
1058         struct ipqhead *fhp;
1059         struct ipq *fp;
1060 {
1061         register struct mbuf *q;
1062
1063         IPQ_LOCK_ASSERT();
1064
1065         while (fp->ipq_frags) {
1066                 q = fp->ipq_frags;
1067                 fp->ipq_frags = q->m_nextpkt;
1068                 m_freem(q);
1069         }
1070         TAILQ_REMOVE(fhp, fp, ipq_list);
1071         uma_zfree(ipq_zone, fp);
1072         nipq--;
1073 }
1074
1075 /*
1076  * IP timer processing;
1077  * if a timer expires on a reassembly
1078  * queue, discard it.
1079  */
1080 void
1081 ip_slowtimo()
1082 {
1083         register struct ipq *fp;
1084         int i;
1085
1086         IPQ_LOCK();
1087         for (i = 0; i < IPREASS_NHASH; i++) {
1088                 for(fp = TAILQ_FIRST(&ipq[i]); fp;) {
1089                         struct ipq *fpp;
1090
1091                         fpp = fp;
1092                         fp = TAILQ_NEXT(fp, ipq_list);
1093                         if(--fpp->ipq_ttl == 0) {
1094                                 ipstat.ips_fragtimeout += fpp->ipq_nfrags;
1095                                 ip_freef(&ipq[i], fpp);
1096                         }
1097                 }
1098         }
1099         /*
1100          * If we are over the maximum number of fragments
1101          * (due to the limit being lowered), drain off
1102          * enough to get down to the new limit.
1103          */
1104         if (maxnipq >= 0 && nipq > maxnipq) {
1105                 for (i = 0; i < IPREASS_NHASH; i++) {
1106                         while (nipq > maxnipq && !TAILQ_EMPTY(&ipq[i])) {
1107                                 ipstat.ips_fragdropped +=
1108                                     TAILQ_FIRST(&ipq[i])->ipq_nfrags;
1109                                 ip_freef(&ipq[i], TAILQ_FIRST(&ipq[i]));
1110                         }
1111                 }
1112         }
1113         IPQ_UNLOCK();
1114 }
1115
1116 /*
1117  * Drain off all datagram fragments.
1118  */
1119 void
1120 ip_drain()
1121 {
1122         int     i;
1123
1124         IPQ_LOCK();
1125         for (i = 0; i < IPREASS_NHASH; i++) {
1126                 while(!TAILQ_EMPTY(&ipq[i])) {
1127                         ipstat.ips_fragdropped +=
1128                             TAILQ_FIRST(&ipq[i])->ipq_nfrags;
1129                         ip_freef(&ipq[i], TAILQ_FIRST(&ipq[i]));
1130                 }
1131         }
1132         IPQ_UNLOCK();
1133         in_rtqdrain();
1134 }
1135
1136 /*
1137  * The protocol to be inserted into ip_protox[] must be already registered
1138  * in inetsw[], either statically or through pf_proto_register().
1139  */
1140 int
1141 ipproto_register(u_char ipproto)
1142 {
1143         struct protosw *pr;
1144
1145         /* Sanity checks. */
1146         if (ipproto == 0)
1147                 return (EPROTONOSUPPORT);
1148
1149         /*
1150          * The protocol slot must not be occupied by another protocol
1151          * already.  An index pointing to IPPROTO_RAW is unused.
1152          */
1153         pr = pffindproto(PF_INET, IPPROTO_RAW, SOCK_RAW);
1154         if (pr == NULL)
1155                 return (EPFNOSUPPORT);
1156         if (ip_protox[ipproto] != pr - inetsw)  /* IPPROTO_RAW */
1157                 return (EEXIST);
1158
1159         /* Find the protocol position in inetsw[] and set the index. */
1160         for (pr = inetdomain.dom_protosw;
1161              pr < inetdomain.dom_protoswNPROTOSW; pr++) {
1162                 if (pr->pr_domain->dom_family == PF_INET &&
1163                     pr->pr_protocol && pr->pr_protocol == ipproto) {
1164                         /* Be careful to only index valid IP protocols. */
1165                         if (pr->pr_protocol < IPPROTO_MAX) {
1166                                 ip_protox[pr->pr_protocol] = pr - inetsw;
1167                                 return (0);
1168                         } else
1169                                 return (EINVAL);
1170                 }
1171         }
1172         return (EPROTONOSUPPORT);
1173 }
1174
1175 int
1176 ipproto_unregister(u_char ipproto)
1177 {
1178         struct protosw *pr;
1179
1180         /* Sanity checks. */
1181         if (ipproto == 0)
1182                 return (EPROTONOSUPPORT);
1183
1184         /* Check if the protocol was indeed registered. */
1185         pr = pffindproto(PF_INET, IPPROTO_RAW, SOCK_RAW);
1186         if (pr == NULL)
1187                 return (EPFNOSUPPORT);
1188         if (ip_protox[ipproto] == pr - inetsw)  /* IPPROTO_RAW */
1189                 return (ENOENT);
1190
1191         /* Reset the protocol slot to IPPROTO_RAW. */
1192         ip_protox[ipproto] = pr - inetsw;
1193         return (0);
1194 }
1195
1196 /*
1197  * Given address of next destination (final or next hop),
1198  * return internet address info of interface to be used to get there.
1199  */
1200 struct in_ifaddr *
1201 ip_rtaddr(dst)
1202         struct in_addr dst;
1203 {
1204         struct route sro;
1205         struct sockaddr_in *sin;
1206         struct in_ifaddr *ifa;
1207
1208         bzero(&sro, sizeof(sro));
1209         sin = (struct sockaddr_in *)&sro.ro_dst;
1210         sin->sin_family = AF_INET;
1211         sin->sin_len = sizeof(*sin);
1212         sin->sin_addr = dst;
1213         rtalloc_ign(&sro, RTF_CLONING);
1214
1215         if (sro.ro_rt == NULL)
1216                 return (NULL);
1217
1218         ifa = ifatoia(sro.ro_rt->rt_ifa);
1219         RTFREE(sro.ro_rt);
1220         return (ifa);
1221 }
1222
1223 u_char inetctlerrmap[PRC_NCMDS] = {
1224         0,              0,              0,              0,
1225         0,              EMSGSIZE,       EHOSTDOWN,      EHOSTUNREACH,
1226         EHOSTUNREACH,   EHOSTUNREACH,   ECONNREFUSED,   ECONNREFUSED,
1227         EMSGSIZE,       EHOSTUNREACH,   0,              0,
1228         0,              0,              EHOSTUNREACH,   0,
1229         ENOPROTOOPT,    ECONNREFUSED
1230 };
1231
1232 /*
1233  * Forward a packet.  If some error occurs return the sender
1234  * an icmp packet.  Note we can't always generate a meaningful
1235  * icmp message because icmp doesn't have a large enough repertoire
1236  * of codes and types.
1237  *
1238  * If not forwarding, just drop the packet.  This could be confusing
1239  * if ipforwarding was zero but some routing protocol was advancing
1240  * us as a gateway to somewhere.  However, we must let the routing
1241  * protocol deal with that.
1242  *
1243  * The srcrt parameter indicates whether the packet is being forwarded
1244  * via a source route.
1245  */
1246 void
1247 ip_forward(struct mbuf *m, int srcrt)
1248 {
1249         struct ip *ip = mtod(m, struct ip *);
1250         struct in_ifaddr *ia = NULL;
1251         struct mbuf *mcopy;
1252         struct in_addr dest;
1253         int error, type = 0, code = 0, mtu = 0;
1254
1255         if (m->m_flags & (M_BCAST|M_MCAST) || in_canforward(ip->ip_dst) == 0) {
1256                 ipstat.ips_cantforward++;
1257                 m_freem(m);
1258                 return;
1259         }
1260 #ifdef IPSTEALTH
1261         if (!ipstealth) {
1262 #endif
1263                 if (ip->ip_ttl <= IPTTLDEC) {
1264                         icmp_error(m, ICMP_TIMXCEED, ICMP_TIMXCEED_INTRANS,
1265                             0, 0);
1266                         return;
1267                 }
1268 #ifdef IPSTEALTH
1269         }
1270 #endif
1271
1272         if (!srcrt && (ia = ip_rtaddr(ip->ip_dst)) == NULL) {
1273                 icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_HOST, 0, 0);
1274                 return;
1275         }
1276
1277         /*
1278          * Save the IP header and at most 8 bytes of the payload,
1279          * in case we need to generate an ICMP message to the src.
1280          *
1281          * XXX this can be optimized a lot by saving the data in a local
1282          * buffer on the stack (72 bytes at most), and only allocating the
1283          * mbuf if really necessary. The vast majority of the packets
1284          * are forwarded without having to send an ICMP back (either
1285          * because unnecessary, or because rate limited), so we are
1286          * really we are wasting a lot of work here.
1287          *
1288          * We don't use m_copy() because it might return a reference
1289          * to a shared cluster. Both this function and ip_output()
1290          * assume exclusive access to the IP header in `m', so any
1291          * data in a cluster may change before we reach icmp_error().
1292          */
1293         MGETHDR(mcopy, M_DONTWAIT, m->m_type);
1294         if (mcopy != NULL && !m_dup_pkthdr(mcopy, m, M_DONTWAIT)) {
1295                 /*
1296                  * It's probably ok if the pkthdr dup fails (because
1297                  * the deep copy of the tag chain failed), but for now
1298                  * be conservative and just discard the copy since
1299                  * code below may some day want the tags.
1300                  */
1301                 m_free(mcopy);
1302                 mcopy = NULL;
1303         }
1304         if (mcopy != NULL) {
1305                 mcopy->m_len = min(ip->ip_len, M_TRAILINGSPACE(mcopy));
1306                 mcopy->m_pkthdr.len = mcopy->m_len;
1307                 m_copydata(m, 0, mcopy->m_len, mtod(mcopy, caddr_t));
1308         }
1309
1310 #ifdef IPSTEALTH
1311         if (!ipstealth) {
1312 #endif
1313                 ip->ip_ttl -= IPTTLDEC;
1314 #ifdef IPSTEALTH
1315         }
1316 #endif
1317
1318         /*
1319          * If forwarding packet using same interface that it came in on,
1320          * perhaps should send a redirect to sender to shortcut a hop.
1321          * Only send redirect if source is sending directly to us,
1322          * and if packet was not source routed (or has any options).
1323          * Also, don't send redirect if forwarding using a default route
1324          * or a route modified by a redirect.
1325          */
1326         dest.s_addr = 0;
1327         if (!srcrt && ipsendredirects && ia->ia_ifp == m->m_pkthdr.rcvif) {
1328                 struct sockaddr_in *sin;
1329                 struct route ro;
1330                 struct rtentry *rt;
1331
1332                 bzero(&ro, sizeof(ro));
1333                 sin = (struct sockaddr_in *)&ro.ro_dst;
1334                 sin->sin_family = AF_INET;
1335                 sin->sin_len = sizeof(*sin);
1336                 sin->sin_addr = ip->ip_dst;
1337                 rtalloc_ign(&ro, RTF_CLONING);
1338
1339                 rt = ro.ro_rt;
1340
1341                 if (rt && (rt->rt_flags & (RTF_DYNAMIC|RTF_MODIFIED)) == 0 &&
1342                     satosin(rt_key(rt))->sin_addr.s_addr != 0) {
1343 #define RTA(rt) ((struct in_ifaddr *)(rt->rt_ifa))
1344                         u_long src = ntohl(ip->ip_src.s_addr);
1345
1346                         if (RTA(rt) &&
1347                             (src & RTA(rt)->ia_subnetmask) == RTA(rt)->ia_subnet) {
1348                                 if (rt->rt_flags & RTF_GATEWAY)
1349                                         dest.s_addr = satosin(rt->rt_gateway)->sin_addr.s_addr;
1350                                 else
1351                                         dest.s_addr = ip->ip_dst.s_addr;
1352                                 /* Router requirements says to only send host redirects */
1353                                 type = ICMP_REDIRECT;
1354                                 code = ICMP_REDIRECT_HOST;
1355                         }
1356                 }
1357                 if (rt)
1358                         RTFREE(rt);
1359         }
1360
1361         error = ip_output(m, NULL, NULL, IP_FORWARDING, NULL, NULL);
1362         if (error)
1363                 ipstat.ips_cantforward++;
1364         else {
1365                 ipstat.ips_forward++;
1366                 if (type)
1367                         ipstat.ips_redirectsent++;
1368                 else {
1369                         if (mcopy)
1370                                 m_freem(mcopy);
1371                         return;
1372                 }
1373         }
1374         if (mcopy == NULL)
1375                 return;
1376
1377         switch (error) {
1378
1379         case 0:                         /* forwarded, but need redirect */
1380                 /* type, code set above */
1381                 break;
1382
1383         case ENETUNREACH:               /* shouldn't happen, checked above */
1384         case EHOSTUNREACH:
1385         case ENETDOWN:
1386         case EHOSTDOWN:
1387         default:
1388                 type = ICMP_UNREACH;
1389                 code = ICMP_UNREACH_HOST;
1390                 break;
1391
1392         case EMSGSIZE:
1393                 type = ICMP_UNREACH;
1394                 code = ICMP_UNREACH_NEEDFRAG;
1395
1396 #if defined(IPSEC) || defined(FAST_IPSEC)
1397                 mtu = ip_ipsec_mtu(m);
1398 #endif /* IPSEC */
1399                 /*
1400                  * If the MTU wasn't set before use the interface mtu or
1401                  * fall back to the next smaller mtu step compared to the
1402                  * current packet size.
1403                  */
1404                 if (mtu == 0) {
1405                         if (ia != NULL)
1406                                 mtu = ia->ia_ifp->if_mtu;
1407                         else
1408                                 mtu = ip_next_mtu(ip->ip_len, 0);
1409                 }
1410                 ipstat.ips_cantfrag++;
1411                 break;
1412
1413         case ENOBUFS:
1414                 /*
1415                  * A router should not generate ICMP_SOURCEQUENCH as
1416                  * required in RFC1812 Requirements for IP Version 4 Routers.
1417                  * Source quench could be a big problem under DoS attacks,
1418                  * or if the underlying interface is rate-limited.
1419                  * Those who need source quench packets may re-enable them
1420                  * via the net.inet.ip.sendsourcequench sysctl.
1421                  */
1422                 if (ip_sendsourcequench == 0) {
1423                         m_freem(mcopy);
1424                         return;
1425                 } else {
1426                         type = ICMP_SOURCEQUENCH;
1427                         code = 0;
1428                 }
1429                 break;
1430
1431         case EACCES:                    /* ipfw denied packet */
1432                 m_freem(mcopy);
1433                 return;
1434         }
1435         icmp_error(mcopy, type, code, dest.s_addr, mtu);
1436 }
1437
1438 void
1439 ip_savecontrol(inp, mp, ip, m)
1440         register struct inpcb *inp;
1441         register struct mbuf **mp;
1442         register struct ip *ip;
1443         register struct mbuf *m;
1444 {
1445         if (inp->inp_socket->so_options & (SO_BINTIME | SO_TIMESTAMP)) {
1446                 struct bintime bt;
1447
1448                 bintime(&bt);
1449                 if (inp->inp_socket->so_options & SO_BINTIME) {
1450                         *mp = sbcreatecontrol((caddr_t) &bt, sizeof(bt),
1451                         SCM_BINTIME, SOL_SOCKET);
1452                         if (*mp)
1453                                 mp = &(*mp)->m_next;
1454                 }
1455                 if (inp->inp_socket->so_options & SO_TIMESTAMP) {
1456                         struct timeval tv;
1457
1458                         bintime2timeval(&bt, &tv);
1459                         *mp = sbcreatecontrol((caddr_t) &tv, sizeof(tv),
1460                                 SCM_TIMESTAMP, SOL_SOCKET);
1461                         if (*mp)
1462                                 mp = &(*mp)->m_next;
1463                 }
1464         }
1465         if (inp->inp_flags & INP_RECVDSTADDR) {
1466                 *mp = sbcreatecontrol((caddr_t) &ip->ip_dst,
1467                     sizeof(struct in_addr), IP_RECVDSTADDR, IPPROTO_IP);
1468                 if (*mp)
1469                         mp = &(*mp)->m_next;
1470         }
1471         if (inp->inp_flags & INP_RECVTTL) {
1472                 *mp = sbcreatecontrol((caddr_t) &ip->ip_ttl,
1473                     sizeof(u_char), IP_RECVTTL, IPPROTO_IP);
1474                 if (*mp)
1475                         mp = &(*mp)->m_next;
1476         }
1477 #ifdef notyet
1478         /* XXX
1479          * Moving these out of udp_input() made them even more broken
1480          * than they already were.
1481          */
1482         /* options were tossed already */
1483         if (inp->inp_flags & INP_RECVOPTS) {
1484                 *mp = sbcreatecontrol((caddr_t) opts_deleted_above,
1485                     sizeof(struct in_addr), IP_RECVOPTS, IPPROTO_IP);
1486                 if (*mp)
1487                         mp = &(*mp)->m_next;
1488         }
1489         /* ip_srcroute doesn't do what we want here, need to fix */
1490         if (inp->inp_flags & INP_RECVRETOPTS) {
1491                 *mp = sbcreatecontrol((caddr_t) ip_srcroute(m),
1492                     sizeof(struct in_addr), IP_RECVRETOPTS, IPPROTO_IP);
1493                 if (*mp)
1494                         mp = &(*mp)->m_next;
1495         }
1496 #endif
1497         if (inp->inp_flags & INP_RECVIF) {
1498                 struct ifnet *ifp;
1499                 struct sdlbuf {
1500                         struct sockaddr_dl sdl;
1501                         u_char  pad[32];
1502                 } sdlbuf;
1503                 struct sockaddr_dl *sdp;
1504                 struct sockaddr_dl *sdl2 = &sdlbuf.sdl;
1505
1506                 if (((ifp = m->m_pkthdr.rcvif))
1507                 && ( ifp->if_index && (ifp->if_index <= if_index))) {
1508                         sdp = (struct sockaddr_dl *)ifp->if_addr->ifa_addr;
1509                         /*
1510                          * Change our mind and don't try copy.
1511                          */
1512                         if ((sdp->sdl_family != AF_LINK)
1513                         || (sdp->sdl_len > sizeof(sdlbuf))) {
1514                                 goto makedummy;
1515                         }
1516                         bcopy(sdp, sdl2, sdp->sdl_len);
1517                 } else {
1518 makedummy:
1519                         sdl2->sdl_len
1520                                 = offsetof(struct sockaddr_dl, sdl_data[0]);
1521                         sdl2->sdl_family = AF_LINK;
1522                         sdl2->sdl_index = 0;
1523                         sdl2->sdl_nlen = sdl2->sdl_alen = sdl2->sdl_slen = 0;
1524                 }
1525                 *mp = sbcreatecontrol((caddr_t) sdl2, sdl2->sdl_len,
1526                         IP_RECVIF, IPPROTO_IP);
1527                 if (*mp)
1528                         mp = &(*mp)->m_next;
1529         }
1530 }
1531
1532 /*
1533  * XXXRW: Multicast routing code in ip_mroute.c is generally MPSAFE, but the
1534  * ip_rsvp and ip_rsvp_on variables need to be interlocked with rsvp_on
1535  * locking.  This code remains in ip_input.c as ip_mroute.c is optionally
1536  * compiled.
1537  */
1538 static int ip_rsvp_on;
1539 struct socket *ip_rsvpd;
1540 int
1541 ip_rsvp_init(struct socket *so)
1542 {
1543         if (so->so_type != SOCK_RAW ||
1544             so->so_proto->pr_protocol != IPPROTO_RSVP)
1545                 return EOPNOTSUPP;
1546
1547         if (ip_rsvpd != NULL)
1548                 return EADDRINUSE;
1549
1550         ip_rsvpd = so;
1551         /*
1552          * This may seem silly, but we need to be sure we don't over-increment
1553          * the RSVP counter, in case something slips up.
1554          */
1555         if (!ip_rsvp_on) {
1556                 ip_rsvp_on = 1;
1557                 rsvp_on++;
1558         }
1559
1560         return 0;
1561 }
1562
1563 int
1564 ip_rsvp_done(void)
1565 {
1566         ip_rsvpd = NULL;
1567         /*
1568          * This may seem silly, but we need to be sure we don't over-decrement
1569          * the RSVP counter, in case something slips up.
1570          */
1571         if (ip_rsvp_on) {
1572                 ip_rsvp_on = 0;
1573                 rsvp_on--;
1574         }
1575         return 0;
1576 }
1577
1578 void
1579 rsvp_input(struct mbuf *m, int off)     /* XXX must fixup manually */
1580 {
1581         if (rsvp_input_p) { /* call the real one if loaded */
1582                 rsvp_input_p(m, off);
1583                 return;
1584         }
1585
1586         /* Can still get packets with rsvp_on = 0 if there is a local member
1587          * of the group to which the RSVP packet is addressed.  But in this
1588          * case we want to throw the packet away.
1589          */
1590
1591         if (!rsvp_on) {
1592                 m_freem(m);
1593                 return;
1594         }
1595
1596         if (ip_rsvpd != NULL) {
1597                 rip_input(m, off);
1598                 return;
1599         }
1600         /* Drop the packet */
1601         m_freem(m);
1602 }