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, struct in_addr 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.s_addr;
 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         struct in_addr 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         if (in_localip(ip->ip_dst))
 334                 return 0;
 335
 336         /*
 337          * Or is it for a local IP broadcast address on this host?
 338          */
 339         if ((m->m_flags & M_BCAST) &&
 340             (m->m_pkthdr.rcvif->if_flags & IFF_BROADCAST)) {
 341                 TAILQ_FOREACH(ifa, &m->m_pkthdr.rcvif->if_addrhead, ifa_link) {
 342                         if (ifa->ifa_addr->sa_family != AF_INET)
 343                                 continue;
 344                         ia = ifatoia(ifa);
 345                         if (ia->ia_netbroadcast.s_addr == ip->ip_dst.s_addr)
 346                                 return 0;
 347                         if (satosin(&ia->ia_broadaddr)->sin_addr.s_addr ==
 348                             ip->ip_dst.s_addr)
 349                                 return 0;
 350                 }
 351         }
 352         ipstat.ips_total++;
 353
 354         /*
 355          * Step 3: incoming packet firewall processing
 356          */
 357
 358         /*
 359          * Convert to host representation
 360          */
 361         ip->ip_len = ntohs(ip->ip_len);
 362         ip->ip_off = ntohs(ip->ip_off);
 363
 364         odest.s_addr = dest.s_addr = ip->ip_dst.s_addr;
 365 #ifdef PFIL_HOOKS
 366         /*
 367          * Run through list of ipfilter hooks for input packets
 368          */
 369         if (pfil_run_hooks(&inet_pfil_hook, &m, m->m_pkthdr.rcvif, PFIL_IN) ||
 370             m == NULL)
 371                 return 1;
 372
 373         M_ASSERTVALID(m);
 374         M_ASSERTPKTHDR(m);
 375
 376         ip = mtod(m, struct ip *);      /* m may have changed by pfil hook */
 377         dest.s_addr = ip->ip_dst.s_addr;
 378 #endif
 379
 380         /*
 381          * Run through ipfw for input packets
 382          */
 383         if (fw_enable && IPFW_LOADED) {
 384                 bzero(&args, sizeof(args));
 385                 args.m = m;
 386
 387                 ipfw = ip_fw_chk_ptr(&args);
 388                 m = args.m;
 389
 390                 M_ASSERTVALID(m);
 391                 M_ASSERTPKTHDR(m);
 392
 393                 /*
 394                  * Packet denied, drop it
 395                  */
 396                 if ((ipfw & IP_FW_PORT_DENY_FLAG) || m == NULL)
 397                         goto drop;
 398                 /*
 399                  * Send packet to the appropriate pipe
 400                  */
 401                 if (DUMMYNET_LOADED && (ipfw & IP_FW_PORT_DYNT_FLAG) != 0) {
 402                         ip_dn_io_ptr(m, ipfw & 0xffff, DN_TO_IP_IN, &args);
 403                         return 1;
 404                 }
 405 #ifdef IPDIVERT
 406                 /*
 407                  * Divert packet
 408                  */
 409                 if (ipfw != 0 && (ipfw & IP_FW_PORT_DYNT_FLAG) == 0) {
 410                         /*
 411                          * See if this is a fragment
 412                          */
 413                         if (ip->ip_off & (IP_MF | IP_OFFMASK))
 414                                 goto droptoours;
 415                         /*
 416                          * Tee packet
 417                          */
 418                         if ((ipfw & IP_FW_PORT_TEE_FLAG) != 0)
 419                                 clone = divert_clone(m);
 420                         else
 421                                 clone = m;
 422                         if (clone == NULL)
 423                                 goto passin;
 424
 425                         /*
 426                          * Delayed checksums are not compatible
 427                          */
 428                         if (m->m_pkthdr.csum_flags & CSUM_DELAY_DATA) {
 429                                 in_delayed_cksum(m);
 430                                 m->m_pkthdr.csum_flags &= ~CSUM_DELAY_DATA;
 431                         }
 432                         /*
 433                          * Restore packet header fields to original values
 434                          */
 435                         tip = mtod(m, struct ip *);
 436                         tip->ip_len = htons(tip->ip_len);
 437                         tip->ip_off = htons(tip->ip_off);
 438                         /*
 439                          * Deliver packet to divert input routine
 440                          */
 441                         divert_packet(m, 0);
 442                         /*
 443                          * If this was not tee, we are done
 444                          */
 445                         m = clone;
 446                         if ((ipfw & IP_FW_PORT_TEE_FLAG) == 0)
 447                                 return 1;
 448                         /* Continue if it was tee */
 449                         goto passin;
 450                 }
 451 #endif
 452                 if (ipfw == 0 && args.next_hop != NULL) {
 453                         dest.s_addr = args.next_hop->sin_addr.s_addr;
 454                         goto passin;
 455                 }
 456                 /*
 457                  * Let through or not?
 458                  */
 459                 if (ipfw != 0)
 460                         goto drop;
 461         }
 462 passin:
 463         ip = mtod(m, struct ip *);      /* if m changed during fw processing */
 464
 465         /*
 466          * Destination address changed?
 467          */
 468         if (odest.s_addr != dest.s_addr) {
 469                 /*
 470                  * Is it now for a local address on this host?
 471                  */
 472                 if (in_localip(dest))
 473                         goto forwardlocal;
 474                 /*
 475                  * Go on with new destination address
 476                  */
 477         }
 478
 479         /*
 480          * Step 4: decrement TTL and look up route
 481          */
 482
 483         /*
 484          * Check TTL
 485          */
 486 #ifdef IPSTEALTH
 487         if (!ipstealth) {
 488 #endif
 489         if (ip->ip_ttl <= IPTTLDEC) {
 490                 icmp_error(m, ICMP_TIMXCEED, ICMP_TIMXCEED_INTRANS, 0, NULL);
 491                 return 1;
 492         }
 493
 494         /*
 495          * Decrement the TTL and incrementally change the checksum.
 496          * Don't bother doing this with hw checksum offloading.
 497          */
 498         ip->ip_ttl -= IPTTLDEC;
 499         if (ip->ip_sum >= (u_int16_t) ~htons(IPTTLDEC << 8))
 500                 ip->ip_sum -= ~htons(IPTTLDEC << 8);
 501         else
 502                 ip->ip_sum += htons(IPTTLDEC << 8);
 503 #ifdef IPSTEALTH
 504         }
 505 #endif
 506
 507         /*
 508          * Find route to destination.
 509          */
 510         if ((dst = ip_findroute(&ro, dest, m)) == NULL)
 511                 return 1;       /* icmp unreach already sent */
 512         ifp = ro.ro_rt->rt_ifp;
 513
 514         /*
 515          * Step 5: outgoing firewall packet processing
 516          */
 517
 518 #ifdef PFIL_HOOKS
 519         /*
 520          * Run through list of hooks for output packets.
 521          */
 522         if (pfil_run_hooks(&inet_pfil_hook, &m, ifp, PFIL_OUT) || m == NULL) {
 523                 goto consumed;
 524         }
 525
 526         M_ASSERTVALID(m);
 527         M_ASSERTPKTHDR(m);
 528
 529         ip = mtod(m, struct ip *);
 530         dest.s_addr = ip->ip_dst.s_addr;
 531 #endif
 532         if (fw_enable && IPFW_LOADED && !args.next_hop) {
 533                 bzero(&args, sizeof(args));
 534                 args.m = m;
 535                 args.oif = ifp;
 536
 537                 ipfw = ip_fw_chk_ptr(&args);
 538                 m = args.m;
 539
 540                 M_ASSERTVALID(m);
 541                 M_ASSERTPKTHDR(m);
 542
 543                 if ((ipfw & IP_FW_PORT_DENY_FLAG) || m == NULL)
 544                         goto drop;
 545
 546                 if (DUMMYNET_LOADED && (ipfw & IP_FW_PORT_DYNT_FLAG) != 0) {
 547                         /*
 548                          * XXX note: if the ifp or rt entry are deleted
 549                          * while a pkt is in dummynet, we are in trouble!
 550                          */
 551                         args.ro = &ro;          /* dummynet does not save it */
 552                         args.dst = dst;
 553
 554                         ip_dn_io_ptr(m, ipfw & 0xffff, DN_TO_IP_OUT, &args);
 555                         goto consumed;
 556                 }
 557 #ifdef IPDIVERT
 558                 if (ipfw != 0 && (ipfw & IP_FW_PORT_DYNT_FLAG) == 0) {
 559                         /*
 560                          * See if this is a fragment
 561                          */
 562                         if (ip->ip_off & (IP_MF | IP_OFFMASK))
 563                                 goto droptoours;
 564                         /*
 565                          * Tee packet
 566                          */
 567                         if ((ipfw & IP_FW_PORT_TEE_FLAG) != 0)
 568                                 clone = divert_clone(m);
 569                         else
 570                                 clone = m;
 571                         if (clone == NULL)
 572                                 goto passout;
 573
 574                         /*
 575                          * Delayed checksums are not compatible with divert
 576                          */
 577                         if (m->m_pkthdr.csum_flags & CSUM_DELAY_DATA) {
 578                                 in_delayed_cksum(m);
 579                                 m->m_pkthdr.csum_flags &= ~CSUM_DELAY_DATA;
 580                         }
 581                         /*
 582                          * Restore packet header fields to original values
 583                          */
 584                         tip = mtod(m, struct ip *);
 585                         tip->ip_len = htons(tip->ip_len);
 586                         tip->ip_off = htons(tip->ip_off);
 587                         /*
 588                          * Deliver packet to divert input routine
 589                          */
 590                         divert_packet(m, 0);
 591                         /*
 592                          * If this was not tee, we are done
 593                          */
 594                         m = clone;
 595                         if ((ipfw & IP_FW_PORT_TEE_FLAG) == 0) {
 596                                 goto consumed;
 597                         }
 598                         /* Continue if it was tee */
 599                         goto passout;
 600                 }
 601 #endif
 602                 if (ipfw == 0 && args.next_hop != NULL) {
 603                         dest.s_addr = args.next_hop->sin_addr.s_addr;
 604                         goto passout;
 605                 }
 606                 /*
 607                  * Let through or not?
 608                  */
 609                 if (ipfw != 0)
 610                         goto drop;
 611         }
 612 passout:
 613         ip = mtod(m, struct ip *);
 614
 615         /*
 616          * Destination address changed?
 617          */
 618         if (odest.s_addr != dest.s_addr) {
 619                 /*
 620                  * Is it now for a local address on this host?
 621                  */
 622                 if (in_localip(dest)) {
 623 forwardlocal:
 624                         if (args.next_hop) {
 625                                 struct m_tag *mtag = m_tag_get(
 626                                     PACKET_TAG_IPFORWARD,
 627                                     sizeof(struct sockaddr_in *),
 628                                     M_NOWAIT);
 629                                 if (mtag == NULL) {
 630                                         goto drop;
 631                                 }
 632                                 *(struct sockaddr_in **)(mtag+1) =
 633                                     args.next_hop;
 634                                 m_tag_prepend(m, mtag);
 635                         }
 636 #ifdef IPDIVERT
 637 droptoours:     /* Used for DIVERT */
 638 #endif
 639                         /* for ip_input */
 640                         m->m_flags |= M_FASTFWD_OURS;
 641
 642                         /* ip still points to the real packet */
 643                         ip->ip_len = htons(ip->ip_len);
 644                         ip->ip_off = htons(ip->ip_off);
 645
 646                         /*
 647                          * Return packet for processing by ip_input
 648                          */
 649                         if (ro.ro_rt)
 650                                 RTFREE(ro.ro_rt);
 651                         return 0;
 652                 }
 653                 /*
 654                  * Redo route lookup with new destination address
 655                  */
 656                 RTFREE(ro.ro_rt);
 657                 if ((dst = ip_findroute(&ro, dest, m)) == NULL)
 658                         return 1;       /* icmp unreach already sent */
 659                 ifp = ro.ro_rt->rt_ifp;
 660         }
 661
 662         /*
 663          * Step 6: send off the packet
 664          */
 665
 666         /*
 667          * Check if route is dampned (when ARP is unable to resolve)
 668          */
 669         if ((ro.ro_rt->rt_flags & RTF_REJECT) &&
 670             ro.ro_rt->rt_rmx.rmx_expire >= time_second) {
 671                 icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_HOST, 0, NULL);
 672                 goto consumed;
 673         }
 674
 675 #ifndef ALTQ
 676         /*
 677          * Check if there is enough space in the interface queue
 678          */
 679         if ((ifp->if_snd.ifq_len + ip->ip_len / ifp->if_mtu + 1) >=
 680             ifp->if_snd.ifq_maxlen) {
 681                 ipstat.ips_odropped++;
 682                 /* would send source quench here but that is depreciated */
 683                 goto drop;
 684         }
 685 #endif
 686
 687         /*
 688          * Check if media link state of interface is not down
 689          */
 690         if (ifp->if_link_state == LINK_STATE_DOWN) {
 691                 icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_HOST, 0, NULL);
 692                 goto consumed;
 693         }
 694
 695         /*
 696          * Check if packet fits MTU or if hardware will fragement for us
 697          */
 698         if (ro.ro_rt->rt_rmx.rmx_mtu)
 699                 mtu = min(ro.ro_rt->rt_rmx.rmx_mtu, ifp->if_mtu);
 700         else
 701                 mtu = ifp->if_mtu;
 702
 703         if (ip->ip_len <= mtu ||
 704             (ifp->if_hwassist & CSUM_FRAGMENT && (ip->ip_off & IP_DF) == 0)) {
 705                 /*
 706                  * Restore packet header fields to original values
 707                  */
 708                 ip->ip_len = htons(ip->ip_len);
 709                 ip->ip_off = htons(ip->ip_off);
 710                 /*
 711                  * Send off the packet via outgoing interface
 712                  */
 713                 error = (*ifp->if_output)(ifp, m,
 714                                 (struct sockaddr *)dst, ro.ro_rt);
 715         } else {
 716                 /*
 717                  * Handle EMSGSIZE with icmp reply needfrag for TCP MTU discovery
 718                  */
 719                 if (ip->ip_off & IP_DF) {
 720                         ipstat.ips_cantfrag++;
 721                         icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_NEEDFRAG,
 722                                 0, ifp);
 723                         goto consumed;
 724                 } else {
 725                         /*
 726                          * We have to fragement the packet
 727                          */
 728                         m->m_pkthdr.csum_flags |= CSUM_IP;
 729                         /*
 730                          * ip_fragment expects ip_len and ip_off in host byte
 731                          * order but returns all packets in network byte order
 732                          */
 733                         if (ip_fragment(ip, &m, mtu, ifp->if_hwassist,
 734                                         (~ifp->if_hwassist & CSUM_DELAY_IP))) {
 735                                 goto drop;
 736                         }
 737                         KASSERT(m != NULL, ("null mbuf and no error"));
 738                         /*
 739                          * Send off the fragments via outgoing interface
 740                          */
 741                         error = 0;
 742                         do {
 743                                 m0 = m->m_nextpkt;
 744                                 m->m_nextpkt = NULL;
 745
 746                                 error = (*ifp->if_output)(ifp, m,
 747                                         (struct sockaddr *)dst, ro.ro_rt);
 748                                 if (error)
 749                                         break;
 750                         } while ((m = m0) != NULL);
 751                         if (error) {
 752                                 /* Reclaim remaining fragments */
 753                                 for (; m; m = m0) {
 754                                         m0 = m->m_nextpkt;
 755                                         m->m_nextpkt = NULL;
 756                                         m_freem(m);
 757                                 }
 758                         } else
 759                                 ipstat.ips_fragmented++;
 760                 }
 761         }
 762
 763         if (error != 0)
 764                 ipstat.ips_odropped++;
 765         else {
 766                 ro.ro_rt->rt_rmx.rmx_pksent++;
 767                 ipstat.ips_forward++;
 768                 ipstat.ips_fastforward++;
 769         }
 770 consumed:
 771         RTFREE(ro.ro_rt);
 772         return 1;
 773 drop:
 774         if (m)
 775                 m_freem(m);
 776         if (ro.ro_rt)
 777                 RTFREE(ro.ro_rt);
 778         return 1;
 779 }