sys/netinet/ip_fastfwd.c

   1 /*
   2  * Copyright (c) 2003 Andre Oppermann, Internet Business Solutions AG
   3  * 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  * 3. The name of the author may not be used to endorse or promote
  14  *    products derived from this software without specific prior written
  15  *    permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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  * $FreeBSD$
  30  */
  31
  32 /*
  33  * ip_fastforward gets its speed from processing the forwarded packet to
  34  * completion (if_output on the other side) without any queues or netisr's.
  35  * The receiving interface DMAs the packet into memory, the upper half of
  36  * driver calls ip_fastforward, we do our routing table lookup and directly
  37  * send it off to the outgoing interface which DMAs the packet to the
  38  * network card. The only part of the packet we touch with the CPU is the
  39  * IP header (unless there are complex firewall rules touching other parts
  40  * of the packet, but that is up to you). We are essentially limited by bus
  41  * bandwidth and how fast the network card/driver can set up receives and
  42  * transmits.
  43  *
  44  * We handle basic errors, ip header errors, checksum errors,
  45  * destination unreachable, fragmentation and fragmentation needed and
  46  * report them via icmp to the sender.
  47  *
  48  * Else if something is not pure IPv4 unicast forwarding we fall back to
  49  * the normal ip_input processing path. We should only be called from
  50  * interfaces connected to the outside world.
  51  *
  52  * Firewalling is fully supported including divert, ipfw fwd and ipfilter
  53  * ipnat and address rewrite.
  54  *
  55  * IPSEC is not supported if this host is a tunnel broker. IPSEC is
  56  * supported for connections to/from local host.
  57  *
  58  * We try to do the least expensive (in CPU ops) checks and operations
  59  * first to catch junk with as little overhead as possible.
  60  *
  61  * We take full advantage of hardware support for ip checksum and
  62  * fragmentation offloading.
  63  *
  64  * We don't do ICMP redirect in the fast forwarding path. I have had my own
  65  * cases where two core routers with Zebra routing suite would send millions
  66  * ICMP redirects to connected hosts if the router to dest was not the default
  67  * gateway. In one case it was filling the routing table of a host with close
  68  * 300'000 cloned redirect entries until it ran out of kernel memory. However
  69  * the networking code proved very robust and it didn't crash or went ill
  70  * otherwise.
  71  */
  72
  73 /*
  74  * Many thanks to Matt Thomas of NetBSD for basic structure of ip_flow.c which
  75  * is being followed here.
  76  */
  77
  78 #include "opt_ipfw.h"
  79 #include "opt_ipdn.h"
  80 #include "opt_ipdivert.h"
  81 #include "opt_ipfilter.h"
  82 #include "opt_ipstealth.h"
  83 #include "opt_pfil_hooks.h"
  84
  85 #include <sys/param.h>
  86 #include <sys/systm.h>
  87 #include <sys/kernel.h>
  88 #include <sys/malloc.h>
  89 #include <sys/mbuf.h>
  90 #include <sys/protosw.h>
  91 #include <sys/socket.h>
  92 #include <sys/sysctl.h>
  93
  94 #include <net/pfil.h>
  95 #include <net/if.h>
  96 #include <net/if_types.h>
  97 #include <net/if_var.h>
  98 #include <net/if_dl.h>
  99 #include <net/route.h>
 100
 101 #include <netinet/in.h>
 102 #include <netinet/in_systm.h>
 103 #include <netinet/in_var.h>
 104 #include <netinet/ip.h>
 105 #include <netinet/ip_var.h>
 106 #include <netinet/ip_icmp.h>
 107
 108 #include <machine/in_cksum.h>
 109
 110 #include <netinet/ip_fw.h>
 111 #include <netinet/ip_divert.h>
 112 #include <netinet/ip_dummynet.h>
 113
 114 static int ipfastforward_active = 0;
 115 SYSCTL_INT(_net_inet_ip, OID_AUTO, fastforwarding, CTLFLAG_RW,
 116     &ipfastforward_active, 0, "Enable fast IP forwarding");
 117
 118 static struct sockaddr_in *
 119 ip_findroute(struct route *ro, in_addr_t dest, struct mbuf *m)
 120 {
 121         struct sockaddr_in *dst;
 122         struct rtentry *rt;
 123
 124         /*
 125          * Find route to destination.
 126          */
 127         bzero(ro, sizeof(*ro));
 128         dst = (struct sockaddr_in *)&ro->ro_dst;
 129         dst->sin_family = AF_INET;
 130         dst->sin_len = sizeof(*dst);
 131         dst->sin_addr.s_addr = dest;
 132         rtalloc_ign(ro, RTF_CLONING);
 133
 134         /*
 135          * Route there and interface still up?
 136          */
 137         rt = ro->ro_rt;
 138         if (rt && (rt->rt_flags & RTF_UP) &&
 139             (rt->rt_ifp->if_flags & IFF_UP) &&
 140             (rt->rt_ifp->if_flags & IFF_RUNNING)) {
 141                 if (rt->rt_flags & RTF_GATEWAY)
 142                         dst = (struct sockaddr_in *)rt->rt_gateway;
 143         } else {
 144                 ipstat.ips_noroute++;
 145                 ipstat.ips_cantforward++;
 146                 if (rt)
 147                         RTFREE(rt);
 148                 icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_HOST, 0, NULL);
 149                 return NULL;
 150         }
 151         return dst;
 152 }
 153
 154 /*
 155  * Try to forward a packet based on the destination address.
 156  * This is a fast path optimized for the plain forwarding case.
 157  * If the packet is handled (and consumed) here then we return 1;
 158  * otherwise 0 is returned and the packet should be delivered
 159  * to ip_input for full processing.
 160  */
 161 int
 162 ip_fastforward(struct mbuf *m)
 163 {
 164         struct ip *ip;
 165         struct mbuf *m0 = NULL;
 166 #ifdef IPDIVERT
 167         struct ip *tip;
 168         struct mbuf *clone = NULL;
 169 #endif
 170         struct route ro;
 171         struct sockaddr_in *dst = NULL;
 172         struct in_ifaddr *ia = NULL;
 173         struct ifaddr *ifa = NULL;
 174         struct ifnet *ifp;
 175         struct ip_fw_args args;
 176         in_addr_t odest, dest;
 177         u_short sum, ip_len;
 178         int error = 0;
 179         int hlen, ipfw, mtu;
 180
 181         /*
 182          * Are we active and forwarding packets?
 183          */
 184         if (!ipfastforward_active || !ipforwarding)
 185                 return 0;
 186
 187         M_ASSERTVALID(m);
 188         M_ASSERTPKTHDR(m);
 189
 190         ro.ro_rt = NULL;
 191
 192         /*
 193          * Step 1: check for packet drop conditions (and sanity checks)
 194          */
 195
 196         /*
 197          * Is entire packet big enough?
 198          */
 199         if (m->m_pkthdr.len < sizeof(struct ip)) {
 200                 ipstat.ips_tooshort++;
 201                 goto drop;
 202         }
 203
 204         /*
 205          * Is first mbuf large enough for ip header and is header present?
 206          */
 207         if (m->m_len < sizeof (struct ip) &&
 208            (m = m_pullup(m, sizeof (struct ip))) == 0) {
 209                 ipstat.ips_toosmall++;
 210                 goto drop;
 211         }
 212
 213         ip = mtod(m, struct ip *);
 214
 215         /*
 216          * Is it IPv4?
 217          */
 218         if (ip->ip_v != IPVERSION) {
 219                 ipstat.ips_badvers++;
 220                 goto drop;
 221         }
 222
 223         /*
 224          * Is IP header length correct and is it in first mbuf?
 225          */
 226         hlen = ip->ip_hl << 2;
 227         if (hlen < sizeof(struct ip)) { /* minimum header length */
 228                 ipstat.ips_badlen++;
 229                 goto drop;
 230         }
 231         if (hlen > m->m_len) {
 232                 if ((m = m_pullup(m, hlen)) == 0) {
 233                         ipstat.ips_badhlen++;
 234                         goto drop;
 235                 }
 236                 ip = mtod(m, struct ip *);
 237         }
 238
 239         /*
 240          * Checksum correct?
 241          */
 242         if (m->m_pkthdr.csum_flags & CSUM_IP_CHECKED)
 243                 sum = !(m->m_pkthdr.csum_flags & CSUM_IP_VALID);
 244         else {
 245                 if (hlen == sizeof(struct ip))
 246                         sum = in_cksum_hdr(ip);
 247                 else
 248                         sum = in_cksum(m, hlen);
 249         }
 250         if (sum) {
 251                 ipstat.ips_badsum++;
 252                 goto drop;
 253         }
 254         m->m_pkthdr.csum_flags |= (CSUM_IP_CHECKED | CSUM_IP_VALID);
 255
 256         ip_len = ntohs(ip->ip_len);
 257
 258         /*
 259          * Is IP length longer than packet we have got?
 260          */
 261         if (m->m_pkthdr.len < ip_len) {
 262                 ipstat.ips_tooshort++;
 263                 goto drop;
 264         }
 265
 266         /*
 267          * Is packet longer than IP header tells us? If yes, truncate packet.
 268          */
 269         if (m->m_pkthdr.len > ip_len) {
 270                 if (m->m_len == m->m_pkthdr.len) {
 271                         m->m_len = ip_len;
 272                         m->m_pkthdr.len = ip_len;
 273                 } else
 274                         m_adj(m, ip_len - m->m_pkthdr.len);
 275         }
 276
 277         /*
 278          * Is packet from or to 127/8?
 279          */
 280         if ((ntohl(ip->ip_dst.s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET ||
 281             (ntohl(ip->ip_src.s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET) {
 282                 ipstat.ips_badaddr++;
 283                 goto drop;
 284         }
 285
 286 #ifdef ALTQ
 287         /*
 288          * Is packet dropped by traffic conditioner?
 289          */
 290         if (altq_input != NULL && (*altq_input)(m, AF_INET) == 0)
 291                 return 1;
 292 #endif
 293
 294         /*
 295          * Step 2: fallback conditions to normal ip_input path processing
 296          */
 297
 298         /*
 299          * Only IP packets without options
 300          */
 301         if (ip->ip_hl != (sizeof(struct ip) >> 2)) {
 302                 if (ip_doopts == 1)
 303                         return 0;
 304                 else if (ip_doopts == 2) {
 305                         icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_FILTER_PROHIB,
 306                                 0, NULL);
 307                         return 1;
 308                 }
 309                 /* else ignore IP options and continue */
 310         }
 311
 312         /*
 313          * Only unicast IP, not from loopback, no L2 or IP broadcast,
 314          * no multicast, no INADDR_ANY
 315          *
 316          * XXX: Probably some of these checks could be direct drop
 317          * conditions.  However it is not clear whether there are some
 318          * hacks or obscure behaviours which make it neccessary to
 319          * let ip_input handle it.  We play safe here and let ip_input
 320          * deal with it until it is proven that we can directly drop it.
 321          */
 322         if ((m->m_pkthdr.rcvif->if_flags & IFF_LOOPBACK) ||
 323             ntohl(ip->ip_src.s_addr) == (u_long)INADDR_BROADCAST ||
 324             ntohl(ip->ip_dst.s_addr) == (u_long)INADDR_BROADCAST ||
 325             IN_MULTICAST(ntohl(ip->ip_src.s_addr)) ||
 326             IN_MULTICAST(ntohl(ip->ip_dst.s_addr)) ||
 327             ip->ip_dst.s_addr == INADDR_ANY )
 328                 return 0;
 329
 330         /*
 331          * Is it for a local address on this host?
 332          */
 333         LIST_FOREACH(ia, INADDR_HASH(ip->ip_dst.s_addr), ia_hash) {
 334                 if (IA_SIN(ia)->sin_addr.s_addr == ip->ip_dst.s_addr)
 335                         return 0;
 336         }
 337
 338         /*
 339          * Or is it for a local IP broadcast address on this host?
 340          */
 341         if ((m->m_flags & M_BCAST) &&
 342             (m->m_pkthdr.rcvif->if_flags & IFF_BROADCAST)) {
 343                 TAILQ_FOREACH(ifa, &m->m_pkthdr.rcvif->if_addrhead, ifa_link) {
 344                         if (ifa->ifa_addr->sa_family != AF_INET)
 345                                 continue;
 346                         ia = ifatoia(ifa);
 347                         if (ia->ia_netbroadcast.s_addr == ip->ip_dst.s_addr)
 348                                 return 0;
 349                         if (satosin(&ia->ia_broadaddr)->sin_addr.s_addr ==
 350                             ip->ip_dst.s_addr)
 351                                 return 0;
 352                 }
 353         }
 354         ipstat.ips_total++;
 355
 356         /*
 357          * Step 3: incoming packet firewall processing
 358          */
 359
 360         /*
 361          * Convert to host representation
 362          */
 363         ip->ip_len = ntohs(ip->ip_len);
 364         ip->ip_off = ntohs(ip->ip_off);
 365
 366         odest = dest = ip->ip_dst.s_addr;
 367 #ifdef PFIL_HOOKS
 368         /*
 369          * Run through list of ipfilter hooks for input packets
 370          */
 371         if (pfil_run_hooks(&inet_pfil_hook, &m, m->m_pkthdr.rcvif, PFIL_IN) ||
 372             m == NULL)
 373                 return 1;
 374
 375         M_ASSERTVALID(m);
 376         M_ASSERTPKTHDR(m);
 377
 378         ip = mtod(m, struct ip *);      /* m may have changed by pfil hook */
 379         dest = ip->ip_dst.s_addr;
 380 #endif
 381
 382         /*
 383          * Run through ipfw for input packets
 384          */
 385         if (fw_enable && IPFW_LOADED) {
 386                 bzero(&args, sizeof(args));
 387                 args.m = m;
 388
 389                 ipfw = ip_fw_chk_ptr(&args);
 390                 m = args.m;
 391
 392                 M_ASSERTVALID(m);
 393                 M_ASSERTPKTHDR(m);
 394
 395                 /*
 396                  * Packet denied, drop it
 397                  */
 398                 if ((ipfw & IP_FW_PORT_DENY_FLAG) || m == NULL)
 399                         goto drop;
 400                 /*
 401                  * Send packet to the appropriate pipe
 402                  */
 403                 if (DUMMYNET_LOADED && (ipfw & IP_FW_PORT_DYNT_FLAG) != 0) {
 404                         ip_dn_io_ptr(m, ipfw & 0xffff, DN_TO_IP_IN, &args);
 405                         return 1;
 406                 }
 407 #ifdef IPDIVERT
 408                 /*
 409                  * Divert packet
 410                  */
 411                 if (ipfw != 0 && (ipfw & IP_FW_PORT_DYNT_FLAG) == 0) {
 412                         /*
 413                          * See if this is a fragment
 414                          */
 415                         if (ip->ip_off & (IP_MF | IP_OFFMASK))
 416                                 goto droptoours;
 417                         /*
 418                          * Tee packet
 419                          */
 420                         if ((ipfw & IP_FW_PORT_TEE_FLAG) != 0)
 421                                 clone = divert_clone(m);
 422                         else
 423                                 clone = m;
 424                         if (clone == NULL)
 425                                 goto passin;
 426
 427                         /*
 428                          * Delayed checksums are not compatible
 429                          */
 430                         if (m->m_pkthdr.csum_flags & CSUM_DELAY_DATA) {
 431                                 in_delayed_cksum(m);
 432                                 m->m_pkthdr.csum_flags &= ~CSUM_DELAY_DATA;
 433                         }
 434                         /*
 435                          * Restore packet header fields to original values
 436                          */
 437                         tip = mtod(m, struct ip *);
 438                         tip->ip_len = htons(tip->ip_len);
 439                         tip->ip_off = htons(tip->ip_off);
 440                         /*
 441                          * Deliver packet to divert input routine
 442                          */
 443                         divert_packet(m, 0);
 444                         /*
 445                          * If this was not tee, we are done
 446                          */
 447                         m = clone;
 448                         if ((ipfw & IP_FW_PORT_TEE_FLAG) == 0)
 449                                 return 1;
 450                         /* Continue if it was tee */
 451                         goto passin;
 452                 }
 453 #endif
 454                 if (ipfw == 0 && args.next_hop != NULL) {
 455                         dest = args.next_hop->sin_addr.s_addr;
 456                         goto passin;
 457                 }
 458                 /*
 459                  * Let through or not?
 460                  */
 461                 if (ipfw != 0)
 462                         goto drop;
 463         }
 464 passin:
 465         ip = mtod(m, struct ip *);      /* if m changed during fw processing */
 466
 467         /*
 468          * Destination address changed?
 469          */
 470         if (odest != dest) {
 471                 /*
 472                  * Is it now for a local address on this host?
 473                  */
 474                 LIST_FOREACH(ia, INADDR_HASH(ip->ip_dst.s_addr), ia_hash) {
 475                         if (IA_SIN(ia)->sin_addr.s_addr == ip->ip_dst.s_addr)
 476                                 goto forwardlocal;
 477                 }
 478                 /*
 479                  * Go on with new destination address
 480                  */
 481         }
 482
 483         /*
 484          * Step 4: decrement TTL and look up route
 485          */
 486
 487         /*
 488          * Check TTL
 489          */
 490 #ifdef IPSTEALTH
 491         if (!ipstealth) {
 492 #endif
 493         if (ip->ip_ttl <= IPTTLDEC) {
 494                 icmp_error(m, ICMP_TIMXCEED, ICMP_TIMXCEED_INTRANS, 0, NULL);
 495                 return 1;
 496         }
 497
 498         /*
 499          * Decrement the TTL and incrementally change the checksum.
 500          * Don't bother doing this with hw checksum offloading.
 501          */
 502         ip->ip_ttl -= IPTTLDEC;
 503         if (ip->ip_sum >= (u_int16_t) ~htons(IPTTLDEC << 8))
 504                 ip->ip_sum -= ~htons(IPTTLDEC << 8);
 505         else
 506                 ip->ip_sum += htons(IPTTLDEC << 8);
 507 #ifdef IPSTEALTH
 508         }
 509 #endif
 510
 511         /*
 512          * Find route to destination.
 513          */
 514         if ((dst = ip_findroute(&ro, dest, m)) == NULL)
 515                 return 1;       /* icmp unreach already sent */
 516         ifp = ro.ro_rt->rt_ifp;
 517
 518         /*
 519          * Step 5: outgoing firewall packet processing
 520          */
 521
 522 #ifdef PFIL_HOOKS
 523         /*
 524          * Run through list of hooks for output packets.
 525          */
 526         if (pfil_run_hooks(&inet_pfil_hook, &m, ifp, PFIL_OUT) || m == NULL) {
 527                 goto consumed;
 528         }
 529
 530         M_ASSERTVALID(m);
 531         M_ASSERTPKTHDR(m);
 532
 533         ip = mtod(m, struct ip *);
 534         dest = ip->ip_dst.s_addr;
 535 #endif
 536         if (fw_enable && IPFW_LOADED && !args.next_hop) {
 537                 bzero(&args, sizeof(args));
 538                 args.m = m;
 539                 args.oif = ifp;
 540
 541                 ipfw = ip_fw_chk_ptr(&args);
 542                 m = args.m;
 543
 544                 M_ASSERTVALID(m);
 545                 M_ASSERTPKTHDR(m);
 546
 547                 if ((ipfw & IP_FW_PORT_DENY_FLAG) || m == NULL)
 548                         goto drop;
 549
 550                 if (DUMMYNET_LOADED && (ipfw & IP_FW_PORT_DYNT_FLAG) != 0) {
 551                         /*
 552                          * XXX note: if the ifp or rt entry are deleted
 553                          * while a pkt is in dummynet, we are in trouble!
 554                          */
 555                         args.ro = &ro;          /* dummynet does not save it */
 556                         args.dst = dst;
 557
 558                         ip_dn_io_ptr(m, ipfw & 0xffff, DN_TO_IP_OUT, &args);
 559                         goto consumed;
 560                 }
 561 #ifdef IPDIVERT
 562                 if (ipfw != 0 && (ipfw & IP_FW_PORT_DYNT_FLAG) == 0) {
 563                         /*
 564                          * See if this is a fragment
 565                          */
 566                         if (ip->ip_off & (IP_MF | IP_OFFMASK))
 567                                 goto droptoours;
 568                         /*
 569                          * Tee packet
 570                          */
 571                         if ((ipfw & IP_FW_PORT_TEE_FLAG) != 0)
 572                                 clone = divert_clone(m);
 573                         else
 574                                 clone = m;
 575                         if (clone == NULL)
 576                                 goto passout;
 577
 578                         /*
 579                          * Delayed checksums are not compatible with divert
 580                          */
 581                         if (m->m_pkthdr.csum_flags & CSUM_DELAY_DATA) {
 582                                 in_delayed_cksum(m);
 583                                 m->m_pkthdr.csum_flags &= ~CSUM_DELAY_DATA;
 584                         }
 585                         /*
 586                          * Restore packet header fields to original values
 587                          */
 588                         tip = mtod(m, struct ip *);
 589                         tip->ip_len = htons(tip->ip_len);
 590                         tip->ip_off = htons(tip->ip_off);
 591                         /*
 592                          * Deliver packet to divert input routine
 593                          */
 594                         divert_packet(m, 0);
 595                         /*
 596                          * If this was not tee, we are done
 597                          */
 598                         m = clone;
 599                         if ((ipfw & IP_FW_PORT_TEE_FLAG) == 0) {
 600                                 goto consumed;
 601                         }
 602                         /* Continue if it was tee */
 603                         goto passout;
 604                 }
 605 #endif
 606                 if (ipfw == 0 && args.next_hop != NULL) {
 607                         dest = args.next_hop->sin_addr.s_addr;
 608                         goto passout;
 609                 }
 610                 /*
 611                  * Let through or not?
 612                  */
 613                 if (ipfw != 0)
 614                         goto drop;
 615         }
 616 passout:
 617         ip = mtod(m, struct ip *);
 618
 619         /*
 620          * Destination address changed?
 621          */
 622         if (odest != dest) {
 623                 /*
 624                  * Is it now for a local address on this host?
 625                  */
 626                 LIST_FOREACH(ia, INADDR_HASH(ip->ip_dst.s_addr), ia_hash) {
 627                         if (IA_SIN(ia)->sin_addr.s_addr == ip->ip_dst.s_addr) {
 628 forwardlocal:
 629                                 if (args.next_hop) {
 630                                         struct m_tag *mtag = m_tag_get(
 631                                             PACKET_TAG_IPFORWARD,
 632                                             sizeof(struct sockaddr_in *),
 633                                             M_NOWAIT);
 634                                         if (mtag == NULL) {
 635                                                 goto drop;
 636                                         }
 637                                         *(struct sockaddr_in **)(mtag+1) =
 638                                             args.next_hop;
 639                                         m_tag_prepend(m, mtag);
 640                                 }
 641 #ifdef IPDIVERT
 642 droptoours:     /* Used for DIVERT */
 643 #endif
 644                                 /* for ip_input */
 645                                 m->m_flags |= M_FASTFWD_OURS;
 646
 647                                 /* ip still points to the real packet */
 648                                 ip->ip_len = htons(ip->ip_len);
 649                                 ip->ip_off = htons(ip->ip_off);
 650
 651                                 /*
 652                                  * Return packet for processing by ip_input
 653                                  */
 654                                 if (ro.ro_rt)
 655                                         RTFREE(ro.ro_rt);
 656                                 return 0;
 657                         }
 658                 }
 659                 /*
 660                  * Redo route lookup with new destination address
 661                  */
 662                 RTFREE(ro.ro_rt);
 663                 if ((dst = ip_findroute(&ro, dest, m)) == NULL)
 664                         return 1;       /* icmp unreach already sent */
 665                 ifp = ro.ro_rt->rt_ifp;
 666         }
 667
 668         /*
 669          * Step 6: send off the packet
 670          */
 671
 672         /*
 673          * Check if route is dampned (when ARP is unable to resolve)
 674          */
 675         if ((ro.ro_rt->rt_flags & RTF_REJECT) &&
 676             ro.ro_rt->rt_rmx.rmx_expire >= time_second) {
 677                 icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_HOST, 0, NULL);
 678                 goto consumed;
 679         }
 680
 681 #ifndef ALTQ
 682         /*
 683          * Check if there is enough space in the interface queue
 684          */
 685         if ((ifp->if_snd.ifq_len + ip->ip_len / ifp->if_mtu + 1) >=
 686             ifp->if_snd.ifq_maxlen) {
 687                 ipstat.ips_odropped++;
 688                 /* would send source quench here but that is depreciated */
 689                 goto drop;
 690         }
 691 #endif
 692
 693         /*
 694          * Check if media link state of interface is not down
 695          */
 696         if (ifp->if_link_state == LINK_STATE_DOWN) {
 697                 icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_HOST, 0, NULL);
 698                 goto consumed;
 699         }
 700
 701         /*
 702          * Check if packet fits MTU or if hardware will fragement for us
 703          */
 704         if (ro.ro_rt->rt_rmx.rmx_mtu)
 705                 mtu = min(ro.ro_rt->rt_rmx.rmx_mtu, ifp->if_mtu);
 706         else
 707                 mtu = ifp->if_mtu;
 708
 709         if (ip->ip_len <= mtu ||
 710             (ifp->if_hwassist & CSUM_FRAGMENT && (ip->ip_off & IP_DF) == 0)) {
 711                 /*
 712                  * Restore packet header fields to original values
 713                  */
 714                 ip->ip_len = htons(ip->ip_len);
 715                 ip->ip_off = htons(ip->ip_off);
 716                 /*
 717                  * Send off the packet via outgoing interface
 718                  */
 719                 error = (*ifp->if_output)(ifp, m,
 720                                 (struct sockaddr *)dst, ro.ro_rt);
 721         } else {
 722                 /*
 723                  * Handle EMSGSIZE with icmp reply needfrag for TCP MTU discovery
 724                  */
 725                 if (ip->ip_off & IP_DF) {
 726                         ipstat.ips_cantfrag++;
 727                         icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_NEEDFRAG,
 728                                 0, ifp);
 729                         goto consumed;
 730                 } else {
 731                         /*
 732                          * We have to fragement the packet
 733                          */
 734                         m->m_pkthdr.csum_flags |= CSUM_IP;
 735                         /*
 736                          * ip_fragment expects ip_len and ip_off in host byte
 737                          * order but returns all packets in network byte order
 738                          */
 739                         if (ip_fragment(ip, &m, mtu, ifp->if_hwassist,
 740                                         (~ifp->if_hwassist & CSUM_DELAY_IP))) {
 741                                 goto drop;
 742                         }
 743                         KASSERT(m != NULL, ("null mbuf and no error"));
 744                         /*
 745                          * Send off the fragments via outgoing interface
 746                          */
 747                         error = 0;
 748                         do {
 749                                 m0 = m->m_nextpkt;
 750                                 m->m_nextpkt = NULL;
 751
 752                                 error = (*ifp->if_output)(ifp, m,
 753                                         (struct sockaddr *)dst, ro.ro_rt);
 754                                 if (error)
 755                                         break;
 756                         } while ((m = m0) != NULL);
 757                         if (error) {
 758                                 /* Reclaim remaining fragments */
 759                                 for (; m; m = m0) {
 760                                         m0 = m->m_nextpkt;
 761                                         m->m_nextpkt = NULL;
 762                                         m_freem(m);
 763                                 }
 764                         } else
 765                                 ipstat.ips_fragmented++;
 766                 }
 767         }
 768
 769         if (error != 0)
 770                 ipstat.ips_odropped++;
 771         else {
 772                 ro.ro_rt->rt_rmx.rmx_pksent++;
 773                 ipstat.ips_forward++;
 774                 ipstat.ips_fastforward++;
 775         }
 776 consumed:
 777         RTFREE(ro.ro_rt);
 778         return 1;
 779 drop:
 780         if (m)
 781                 m_freem(m);
 782         if (ro.ro_rt)
 783                 RTFREE(ro.ro_rt);
 784         return 1;
 785 }