sys/netinet/ip_output.c

   1 /*
   2  * Copyright (c) 1982, 1986, 1988, 1990, 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  * 3. 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_output.c 8.3 (Berkeley) 1/21/94
  30  * $FreeBSD: src/sys/netinet/ip_output.c,v 1.99.2.37 2003/04/15 06:44:45 silby Exp $
  31  * $DragonFly: src/sys/netinet/ip_output.c,v 1.61 2008/09/13 05:49:08 sephe Exp $
  32  */
  33
  34 #define _IP_VHL
  35
  36 #include "opt_ipfw.h"
  37 #include "opt_ipdn.h"
  38 #include "opt_ipdivert.h"
  39 #include "opt_ipfilter.h"
  40 #include "opt_ipsec.h"
  41 #include "opt_mbuf_stress_test.h"
  42 #include "opt_mpls.h"
  43
  44 #include <sys/param.h>
  45 #include <sys/systm.h>
  46 #include <sys/kernel.h>
  47 #include <sys/malloc.h>
  48 #include <sys/mbuf.h>
  49 #include <sys/protosw.h>
  50 #include <sys/socket.h>
  51 #include <sys/socketvar.h>
  52 #include <sys/proc.h>
  53 #include <sys/sysctl.h>
  54 #include <sys/thread2.h>
  55 #include <sys/in_cksum.h>
  56
  57 #include <net/if.h>
  58 #include <net/netisr.h>
  59 #include <net/pfil.h>
  60 #include <net/route.h>
  61
  62 #include <netinet/in.h>
  63 #include <netinet/in_systm.h>
  64 #include <netinet/ip.h>
  65 #include <netinet/in_pcb.h>
  66 #include <netinet/in_var.h>
  67 #include <netinet/ip_var.h>
  68 #ifdef IPDIVERT
  69 #include <netinet/ip_divert.h>
  70 #endif
  71
  72 #include <netproto/mpls/mpls_var.h>
  73
  74 static MALLOC_DEFINE(M_IPMOPTS, "ip_moptions", "internet multicast options");
  75
  76 #ifdef IPSEC
  77 #include <netinet6/ipsec.h>
  78 #include <netproto/key/key.h>
  79 #ifdef IPSEC_DEBUG
  80 #include <netproto/key/key_debug.h>
  81 #else
  82 #define KEYDEBUG(lev,arg)
  83 #endif
  84 #endif /*IPSEC*/
  85
  86 #ifdef FAST_IPSEC
  87 #include <netproto/ipsec/ipsec.h>
  88 #include <netproto/ipsec/xform.h>
  89 #include <netproto/ipsec/key.h>
  90 #endif /*FAST_IPSEC*/
  91
  92 #include <net/ipfw/ip_fw.h>
  93 #include <net/dummynet/ip_dummynet.h>
  94
  95 #define print_ip(x, a, y)        kprintf("%s %d.%d.%d.%d%s",\
  96                                 x, (ntohl(a.s_addr)>>24)&0xFF,\
  97                                   (ntohl(a.s_addr)>>16)&0xFF,\
  98                                   (ntohl(a.s_addr)>>8)&0xFF,\
  99                                   (ntohl(a.s_addr))&0xFF, y);
 100
 101 u_short ip_id;
 102
 103 #ifdef MBUF_STRESS_TEST
 104 int mbuf_frag_size = 0;
 105 SYSCTL_INT(_net_inet_ip, OID_AUTO, mbuf_frag_size, CTLFLAG_RW,
 106         &mbuf_frag_size, 0, "Fragment outgoing mbufs to this size");
 107 #endif
 108
 109 static struct mbuf *ip_insertoptions(struct mbuf *, struct mbuf *, int *);
 110 static struct ifnet *ip_multicast_if(struct in_addr *, int *);
 111 static void     ip_mloopback
 112         (struct ifnet *, struct mbuf *, struct sockaddr_in *, int);
 113 static int      ip_getmoptions
 114         (struct sockopt *, struct ip_moptions *);
 115 static int      ip_pcbopts(int, struct mbuf **, struct mbuf *);
 116 static int      ip_setmoptions
 117         (struct sockopt *, struct ip_moptions **);
 118
 119 int     ip_optcopy(struct ip *, struct ip *);
 120
 121 extern  int route_assert_owner_access;
 122 extern  void db_print_backtrace(void);
 123
 124 extern  struct protosw inetsw[];
 125
 126 #ifdef IPDIVERT
 127 static struct mbuf *
 128 ip_divert_out(struct mbuf *m, int tee)
 129 {
 130         struct mbuf *clone = NULL;
 131         struct ip *ip = mtod(m, struct ip *);
 132
 133         /* Clone packet if we're doing a 'tee' */
 134         if (tee)
 135                 clone = m_dup(m, MB_DONTWAIT);
 136
 137         /*
 138          * XXX
 139          * delayed checksums are not currently compatible
 140          * with divert sockets.
 141          */
 142         if (m->m_pkthdr.csum_flags & CSUM_DELAY_DATA) {
 143                 in_delayed_cksum(m);
 144                 m->m_pkthdr.csum_flags &= ~CSUM_DELAY_DATA;
 145         }
 146
 147         /* Restore packet header fields to original values */
 148         ip->ip_len = htons(ip->ip_len);
 149         ip->ip_off = htons(ip->ip_off);
 150
 151         /* Deliver packet to divert input routine */
 152         divert_packet(m, 0);
 153
 154         /* If 'tee', continue with original packet */
 155         return clone;
 156 }
 157 #endif  /* IPDIVERT */
 158
 159 static int
 160 ip_localforward(struct mbuf *m, const struct sockaddr_in *dst)
 161 {
 162         struct in_ifaddr_container *iac;
 163
 164         /*
 165          * We need to figure out if we have been forwarded to a local
 166          * socket.  If so, then we should somehow "loop back" to
 167          * ip_input(), and get directed to the PCB as if we had received
 168          * this packet.  This is because it may be difficult to identify
 169          * the packets you want to forward until they are being output
 170          * and have selected an interface (e.g. locally initiated
 171          * packets).  If we used the loopback inteface, we would not be
 172          * able to control what happens as the packet runs through
 173          * ip_input() as it is done through a ISR.
 174          */
 175         LIST_FOREACH(iac, INADDR_HASH(dst->sin_addr.s_addr), ia_hash) {
 176                 /*
 177                  * If the addr to forward to is one of ours, we pretend
 178                  * to be the destination for this packet.
 179                  */
 180                 if (IA_SIN(iac->ia)->sin_addr.s_addr == dst->sin_addr.s_addr)
 181                         break;
 182         }
 183         if (iac != NULL) {
 184                 struct ip *ip = mtod(m, struct ip *);
 185
 186                 if (m->m_pkthdr.rcvif == NULL)
 187                         m->m_pkthdr.rcvif = ifunit("lo0");
 188                 if (m->m_pkthdr.csum_flags & CSUM_DELAY_DATA) {
 189                         m->m_pkthdr.csum_flags |= CSUM_DATA_VALID |
 190                                                   CSUM_PSEUDO_HDR;
 191                         m->m_pkthdr.csum_data = 0xffff;
 192                 }
 193                 m->m_pkthdr.csum_flags |= CSUM_IP_CHECKED | CSUM_IP_VALID;
 194
 195                 ip->ip_len = htons(ip->ip_len);
 196                 ip->ip_off = htons(ip->ip_off);
 197                 ip_input(m);
 198
 199                 return 1; /* Packet gets forwarded locally */
 200         }
 201         return 0;
 202 }
 203
 204 /*
 205  * IP output.  The packet in mbuf chain m contains a skeletal IP
 206  * header (with len, off, ttl, proto, tos, src, dst).
 207  * The mbuf chain containing the packet will be freed.
 208  * The mbuf opt, if present, will not be freed.
 209  */
 210 int
 211 ip_output(struct mbuf *m0, struct mbuf *opt, struct route *ro,
 212           int flags, struct ip_moptions *imo, struct inpcb *inp)
 213 {
 214         struct ip *ip;
 215         struct ifnet *ifp = NULL;       /* keep compiler happy */
 216         struct mbuf *m;
 217         int hlen = sizeof(struct ip);
 218         int len, off, error = 0;
 219         struct sockaddr_in *dst = NULL; /* keep compiler happy */
 220         struct in_ifaddr *ia = NULL;
 221         int isbroadcast, sw_csum;
 222         struct in_addr pkt_dst;
 223         struct route iproute;
 224         struct m_tag *mtag;
 225 #ifdef IPSEC
 226         struct secpolicy *sp = NULL;
 227         struct socket *so = inp ? inp->inp_socket : NULL;
 228 #endif
 229 #ifdef FAST_IPSEC
 230         struct secpolicy *sp = NULL;
 231         struct tdb_ident *tdbi;
 232 #endif /* FAST_IPSEC */
 233         struct sockaddr_in *next_hop = NULL;
 234         int src_was_INADDR_ANY = 0;     /* as the name says... */
 235
 236         m = m0;
 237         M_ASSERTPKTHDR(m);
 238
 239         if (ro == NULL) {
 240                 ro = &iproute;
 241                 bzero(ro, sizeof *ro);
 242         } else if (ro->ro_rt != NULL && ro->ro_rt->rt_cpuid != mycpuid) {
 243                 if (flags & IP_DEBUGROUTE) {
 244                         if (route_assert_owner_access) {
 245                                 panic("ip_output: "
 246                                       "rt rt_cpuid %d accessed on cpu %d\n",
 247                                       ro->ro_rt->rt_cpuid, mycpuid);
 248                         } else {
 249                                 kprintf("ip_output: "
 250                                         "rt rt_cpuid %d accessed on cpu %d\n",
 251                                         ro->ro_rt->rt_cpuid, mycpuid);
 252                                 db_print_backtrace();
 253                         }
 254                 }
 255
 256                 /*
 257                  * XXX
 258                  * If the cached rtentry's owner CPU is not the current CPU,
 259                  * then don't touch the cached rtentry (remote free is too
 260                  * expensive in this context); just relocate the route.
 261                  */
 262                 ro = &iproute;
 263                 bzero(ro, sizeof *ro);
 264         }
 265
 266         if (m->m_pkthdr.fw_flags & IPFORWARD_MBUF_TAGGED) {
 267                 /* Next hop */
 268                 mtag = m_tag_find(m, PACKET_TAG_IPFORWARD, NULL);
 269                 KKASSERT(mtag != NULL);
 270                 next_hop = m_tag_data(mtag);
 271         }
 272
 273         if (m->m_pkthdr.fw_flags & DUMMYNET_MBUF_TAGGED) {
 274                 struct dn_pkt *dn_pkt;
 275
 276                 /* Extract info from dummynet tag */
 277                 mtag = m_tag_find(m, PACKET_TAG_DUMMYNET, NULL);
 278                 KKASSERT(mtag != NULL);
 279                 dn_pkt = m_tag_data(mtag);
 280
 281                 /*
 282                  * The packet was already tagged, so part of the
 283                  * processing was already done, and we need to go down.
 284                  * Get the calculated parameters from the tag.
 285                  */
 286                 ifp = dn_pkt->ifp;
 287
 288                 KKASSERT(ro == &iproute);
 289                 *ro = dn_pkt->ro; /* structure copy */
 290                 KKASSERT(ro->ro_rt == NULL || ro->ro_rt->rt_cpuid == mycpuid);
 291
 292                 dst = dn_pkt->dn_dst;
 293                 if (dst == (struct sockaddr_in *)&(dn_pkt->ro.ro_dst)) {
 294                         /* If 'dst' points into dummynet tag, adjust it */
 295                         dst = (struct sockaddr_in *)&(ro->ro_dst);
 296                 }
 297
 298                 ip = mtod(m, struct ip *);
 299                 hlen = IP_VHL_HL(ip->ip_vhl) << 2 ;
 300                 if (ro->ro_rt)
 301                         ia = ifatoia(ro->ro_rt->rt_ifa);
 302                 goto sendit;
 303         }
 304
 305         if (opt) {
 306                 len = 0;
 307                 m = ip_insertoptions(m, opt, &len);
 308                 if (len != 0)
 309                         hlen = len;
 310         }
 311         ip = mtod(m, struct ip *);
 312
 313         /*
 314          * Fill in IP header.
 315          */
 316         if (!(flags & (IP_FORWARDING|IP_RAWOUTPUT))) {
 317                 ip->ip_vhl = IP_MAKE_VHL(IPVERSION, hlen >> 2);
 318                 ip->ip_off &= IP_DF;
 319                 ip->ip_id = ip_newid();
 320                 ipstat.ips_localout++;
 321         } else {
 322                 hlen = IP_VHL_HL(ip->ip_vhl) << 2;
 323         }
 324
 325 reroute:
 326         pkt_dst = next_hop ? next_hop->sin_addr : ip->ip_dst;
 327
 328         dst = (struct sockaddr_in *)&ro->ro_dst;
 329         /*
 330          * If there is a cached route,
 331          * check that it is to the same destination
 332          * and is still up.  If not, free it and try again.
 333          * The address family should also be checked in case of sharing the
 334          * cache with IPv6.
 335          */
 336         if (ro->ro_rt &&
 337             (!(ro->ro_rt->rt_flags & RTF_UP) ||
 338              dst->sin_family != AF_INET ||
 339              dst->sin_addr.s_addr != pkt_dst.s_addr)) {
 340                 rtfree(ro->ro_rt);
 341                 ro->ro_rt = (struct rtentry *)NULL;
 342         }
 343         if (ro->ro_rt == NULL) {
 344                 bzero(dst, sizeof *dst);
 345                 dst->sin_family = AF_INET;
 346                 dst->sin_len = sizeof *dst;
 347                 dst->sin_addr = pkt_dst;
 348         }
 349         /*
 350          * If routing to interface only,
 351          * short circuit routing lookup.
 352          */
 353         if (flags & IP_ROUTETOIF) {
 354                 if ((ia = ifatoia(ifa_ifwithdstaddr(sintosa(dst)))) == NULL &&
 355                     (ia = ifatoia(ifa_ifwithnet(sintosa(dst)))) == NULL) {
 356                         ipstat.ips_noroute++;
 357                         error = ENETUNREACH;
 358                         goto bad;
 359                 }
 360                 ifp = ia->ia_ifp;
 361                 ip->ip_ttl = 1;
 362                 isbroadcast = in_broadcast(dst->sin_addr, ifp);
 363         } else if (IN_MULTICAST(ntohl(pkt_dst.s_addr)) &&
 364                    imo != NULL && imo->imo_multicast_ifp != NULL) {
 365                 /*
 366                  * Bypass the normal routing lookup for multicast
 367                  * packets if the interface is specified.
 368                  */
 369                 ifp = imo->imo_multicast_ifp;
 370                 ia = IFP_TO_IA(ifp);
 371                 isbroadcast = 0;        /* fool gcc */
 372         } else {
 373                 /*
 374                  * If this is the case, we probably don't want to allocate
 375                  * a protocol-cloned route since we didn't get one from the
 376                  * ULP.  This lets TCP do its thing, while not burdening
 377                  * forwarding or ICMP with the overhead of cloning a route.
 378                  * Of course, we still want to do any cloning requested by
 379                  * the link layer, as this is probably required in all cases
 380                  * for correct operation (as it is for ARP).
 381                  */
 382                 if (ro->ro_rt == NULL)
 383                         rtalloc_ign(ro, RTF_PRCLONING);
 384                 if (ro->ro_rt == NULL) {
 385                         ipstat.ips_noroute++;
 386                         error = EHOSTUNREACH;
 387                         goto bad;
 388                 }
 389                 ia = ifatoia(ro->ro_rt->rt_ifa);
 390                 ifp = ro->ro_rt->rt_ifp;
 391                 ro->ro_rt->rt_use++;
 392                 if (ro->ro_rt->rt_flags & RTF_GATEWAY)
 393                         dst = (struct sockaddr_in *)ro->ro_rt->rt_gateway;
 394                 if (ro->ro_rt->rt_flags & RTF_HOST)
 395                         isbroadcast = (ro->ro_rt->rt_flags & RTF_BROADCAST);
 396                 else
 397                         isbroadcast = in_broadcast(dst->sin_addr, ifp);
 398         }
 399         if (IN_MULTICAST(ntohl(pkt_dst.s_addr))) {
 400                 struct in_multi *inm;
 401
 402                 m->m_flags |= M_MCAST;
 403                 /*
 404                  * IP destination address is multicast.  Make sure "dst"
 405                  * still points to the address in "ro".  (It may have been
 406                  * changed to point to a gateway address, above.)
 407                  */
 408                 dst = (struct sockaddr_in *)&ro->ro_dst;
 409                 /*
 410                  * See if the caller provided any multicast options
 411                  */
 412                 if (imo != NULL) {
 413                         ip->ip_ttl = imo->imo_multicast_ttl;
 414                         if (imo->imo_multicast_vif != -1)
 415                                 ip->ip_src.s_addr =
 416                                     ip_mcast_src ?
 417                                     ip_mcast_src(imo->imo_multicast_vif) :
 418                                     INADDR_ANY;
 419                 } else
 420                         ip->ip_ttl = IP_DEFAULT_MULTICAST_TTL;
 421                 /*
 422                  * Confirm that the outgoing interface supports multicast.
 423                  */
 424                 if ((imo == NULL) || (imo->imo_multicast_vif == -1)) {
 425                         if (!(ifp->if_flags & IFF_MULTICAST)) {
 426                                 ipstat.ips_noroute++;
 427                                 error = ENETUNREACH;
 428                                 goto bad;
 429                         }
 430                 }
 431                 /*
 432                  * If source address not specified yet, use address
 433                  * of outgoing interface.
 434                  */
 435                 if (ip->ip_src.s_addr == INADDR_ANY) {
 436                         /* Interface may have no addresses. */
 437                         if (ia != NULL)
 438                                 ip->ip_src = IA_SIN(ia)->sin_addr;
 439                 }
 440
 441                 IN_LOOKUP_MULTI(pkt_dst, ifp, inm);
 442                 if (inm != NULL &&
 443                    (imo == NULL || imo->imo_multicast_loop)) {
 444                         /*
 445                          * If we belong to the destination multicast group
 446                          * on the outgoing interface, and the caller did not
 447                          * forbid loopback, loop back a copy.
 448                          */
 449                         ip_mloopback(ifp, m, dst, hlen);
 450                 }
 451                 else {
 452                         /*
 453                          * If we are acting as a multicast router, perform
 454                          * multicast forwarding as if the packet had just
 455                          * arrived on the interface to which we are about
 456                          * to send.  The multicast forwarding function
 457                          * recursively calls this function, using the
 458                          * IP_FORWARDING flag to prevent infinite recursion.
 459                          *
 460                          * Multicasts that are looped back by ip_mloopback(),
 461                          * above, will be forwarded by the ip_input() routine,
 462                          * if necessary.
 463                          */
 464                         if (ip_mrouter && !(flags & IP_FORWARDING)) {
 465                                 /*
 466                                  * If rsvp daemon is not running, do not
 467                                  * set ip_moptions. This ensures that the packet
 468                                  * is multicast and not just sent down one link
 469                                  * as prescribed by rsvpd.
 470                                  */
 471                                 if (!rsvp_on)
 472                                         imo = NULL;
 473                                 if (ip_mforward &&
 474                                     ip_mforward(ip, ifp, m, imo) != 0) {
 475                                         m_freem(m);
 476                                         goto done;
 477                                 }
 478                         }
 479                 }
 480
 481                 /*
 482                  * Multicasts with a time-to-live of zero may be looped-
 483                  * back, above, but must not be transmitted on a network.
 484                  * Also, multicasts addressed to the loopback interface
 485                  * are not sent -- the above call to ip_mloopback() will
 486                  * loop back a copy if this host actually belongs to the
 487                  * destination group on the loopback interface.
 488                  */
 489                 if (ip->ip_ttl == 0 || ifp->if_flags & IFF_LOOPBACK) {
 490                         m_freem(m);
 491                         goto done;
 492                 }
 493
 494                 goto sendit;
 495         } else {
 496                 m->m_flags &= ~M_MCAST;
 497         }
 498
 499         /*
 500          * If the source address is not specified yet, use the address
 501          * of the outoing interface. In case, keep note we did that, so
 502          * if the the firewall changes the next-hop causing the output
 503          * interface to change, we can fix that.
 504          */
 505         if (ip->ip_src.s_addr == INADDR_ANY || src_was_INADDR_ANY) {
 506                 /* Interface may have no addresses. */
 507                 if (ia != NULL) {
 508                         ip->ip_src = IA_SIN(ia)->sin_addr;
 509                         src_was_INADDR_ANY = 1;
 510                 }
 511         }
 512
 513 #ifdef ALTQ
 514         /*
 515          * Disable packet drop hack.
 516          * Packetdrop should be done by queueing.
 517          */
 518 #else /* !ALTQ */
 519         /*
 520          * Verify that we have any chance at all of being able to queue
 521          *      the packet or packet fragments
 522          */
 523         if ((ifp->if_snd.ifq_len + ip->ip_len / ifp->if_mtu + 1) >=
 524                 ifp->if_snd.ifq_maxlen) {
 525                         error = ENOBUFS;
 526                         ipstat.ips_odropped++;
 527                         goto bad;
 528         }
 529 #endif /* !ALTQ */
 530
 531         /*
 532          * Look for broadcast address and
 533          * verify user is allowed to send
 534          * such a packet.
 535          */
 536         if (isbroadcast) {
 537                 if (!(ifp->if_flags & IFF_BROADCAST)) {
 538                         error = EADDRNOTAVAIL;
 539                         goto bad;
 540                 }
 541                 if (!(flags & IP_ALLOWBROADCAST)) {
 542                         error = EACCES;
 543                         goto bad;
 544                 }
 545                 /* don't allow broadcast messages to be fragmented */
 546                 if (ip->ip_len > ifp->if_mtu) {
 547                         error = EMSGSIZE;
 548                         goto bad;
 549                 }
 550                 m->m_flags |= M_BCAST;
 551         } else {
 552                 m->m_flags &= ~M_BCAST;
 553         }
 554
 555 sendit:
 556 #ifdef IPSEC
 557         /* get SP for this packet */
 558         if (so == NULL)
 559                 sp = ipsec4_getpolicybyaddr(m, IPSEC_DIR_OUTBOUND, flags, &error);
 560         else
 561                 sp = ipsec4_getpolicybysock(m, IPSEC_DIR_OUTBOUND, so, &error);
 562
 563         if (sp == NULL) {
 564                 ipsecstat.out_inval++;
 565                 goto bad;
 566         }
 567
 568         error = 0;
 569
 570         /* check policy */
 571         switch (sp->policy) {
 572         case IPSEC_POLICY_DISCARD:
 573                 /*
 574                  * This packet is just discarded.
 575                  */
 576                 ipsecstat.out_polvio++;
 577                 goto bad;
 578
 579         case IPSEC_POLICY_BYPASS:
 580         case IPSEC_POLICY_NONE:
 581                 /* no need to do IPsec. */
 582                 goto skip_ipsec;
 583
 584         case IPSEC_POLICY_IPSEC:
 585                 if (sp->req == NULL) {
 586                         /* acquire a policy */
 587                         error = key_spdacquire(sp);
 588                         goto bad;
 589                 }
 590                 break;
 591
 592         case IPSEC_POLICY_ENTRUST:
 593         default:
 594                 kprintf("ip_output: Invalid policy found. %d\n", sp->policy);
 595         }
 596     {
 597         struct ipsec_output_state state;
 598         bzero(&state, sizeof state);
 599         state.m = m;
 600         if (flags & IP_ROUTETOIF) {
 601                 state.ro = &iproute;
 602                 bzero(&iproute, sizeof iproute);
 603         } else
 604                 state.ro = ro;
 605         state.dst = (struct sockaddr *)dst;
 606
 607         ip->ip_sum = 0;
 608
 609         /*
 610          * XXX
 611          * delayed checksums are not currently compatible with IPsec
 612          */
 613         if (m->m_pkthdr.csum_flags & CSUM_DELAY_DATA) {
 614                 in_delayed_cksum(m);
 615                 m->m_pkthdr.csum_flags &= ~CSUM_DELAY_DATA;
 616         }
 617
 618         ip->ip_len = htons(ip->ip_len);
 619         ip->ip_off = htons(ip->ip_off);
 620
 621         error = ipsec4_output(&state, sp, flags);
 622
 623         m = state.m;
 624         if (flags & IP_ROUTETOIF) {
 625                 /*
 626                  * if we have tunnel mode SA, we may need to ignore
 627                  * IP_ROUTETOIF.
 628                  */
 629                 if (state.ro != &iproute || state.ro->ro_rt != NULL) {
 630                         flags &= ~IP_ROUTETOIF;
 631                         ro = state.ro;
 632                 }
 633         } else
 634                 ro = state.ro;
 635         dst = (struct sockaddr_in *)state.dst;
 636         if (error) {
 637                 /* mbuf is already reclaimed in ipsec4_output. */
 638                 m0 = NULL;
 639                 switch (error) {
 640                 case EHOSTUNREACH:
 641                 case ENETUNREACH:
 642                 case EMSGSIZE:
 643                 case ENOBUFS:
 644                 case ENOMEM:
 645                         break;
 646                 default:
 647                         kprintf("ip4_output (ipsec): error code %d\n", error);
 648                         /*fall through*/
 649                 case ENOENT:
 650                         /* don't show these error codes to the user */
 651                         error = 0;
 652                         break;
 653                 }
 654                 goto bad;
 655         }
 656     }
 657
 658         /* be sure to update variables that are affected by ipsec4_output() */
 659         ip = mtod(m, struct ip *);
 660 #ifdef _IP_VHL
 661         hlen = IP_VHL_HL(ip->ip_vhl) << 2;
 662 #else
 663         hlen = ip->ip_hl << 2;
 664 #endif
 665         if (ro->ro_rt == NULL) {
 666                 if (!(flags & IP_ROUTETOIF)) {
 667                         kprintf("ip_output: "
 668                                 "can't update route after IPsec processing\n");
 669                         error = EHOSTUNREACH;   /*XXX*/
 670                         goto bad;
 671                 }
 672         } else {
 673                 ia = ifatoia(ro->ro_rt->rt_ifa);
 674                 ifp = ro->ro_rt->rt_ifp;
 675         }
 676
 677         /* make it flipped, again. */
 678         ip->ip_len = ntohs(ip->ip_len);
 679         ip->ip_off = ntohs(ip->ip_off);
 680 skip_ipsec:
 681 #endif /*IPSEC*/
 682 #ifdef FAST_IPSEC
 683         /*
 684          * Check the security policy (SP) for the packet and, if
 685          * required, do IPsec-related processing.  There are two
 686          * cases here; the first time a packet is sent through
 687          * it will be untagged and handled by ipsec4_checkpolicy.
 688          * If the packet is resubmitted to ip_output (e.g. after
 689          * AH, ESP, etc. processing), there will be a tag to bypass
 690          * the lookup and related policy checking.
 691          */
 692         mtag = m_tag_find(m, PACKET_TAG_IPSEC_PENDING_TDB, NULL);
 693         crit_enter();
 694         if (mtag != NULL) {
 695                 tdbi = (struct tdb_ident *)m_tag_data(mtag);
 696                 sp = ipsec_getpolicy(tdbi, IPSEC_DIR_OUTBOUND);
 697                 if (sp == NULL)
 698                         error = -EINVAL;        /* force silent drop */
 699                 m_tag_delete(m, mtag);
 700         } else {
 701                 sp = ipsec4_checkpolicy(m, IPSEC_DIR_OUTBOUND, flags,
 702                                         &error, inp);
 703         }
 704         /*
 705          * There are four return cases:
 706          *    sp != NULL                    apply IPsec policy
 707          *    sp == NULL, error == 0        no IPsec handling needed
 708          *    sp == NULL, error == -EINVAL  discard packet w/o error
 709          *    sp == NULL, error != 0        discard packet, report error
 710          */
 711         if (sp != NULL) {
 712                 /* Loop detection, check if ipsec processing already done */
 713                 KASSERT(sp->req != NULL, ("ip_output: no ipsec request"));
 714                 for (mtag = m_tag_first(m); mtag != NULL;
 715                      mtag = m_tag_next(m, mtag)) {
 716                         if (mtag->m_tag_cookie != MTAG_ABI_COMPAT)
 717                                 continue;
 718                         if (mtag->m_tag_id != PACKET_TAG_IPSEC_OUT_DONE &&
 719                             mtag->m_tag_id != PACKET_TAG_IPSEC_OUT_CRYPTO_NEEDED)
 720                                 continue;
 721                         /*
 722                          * Check if policy has an SA associated with it.
 723                          * This can happen when an SP has yet to acquire
 724                          * an SA; e.g. on first reference.  If it occurs,
 725                          * then we let ipsec4_process_packet do its thing.
 726                          */
 727                         if (sp->req->sav == NULL)
 728                                 break;
 729                         tdbi = (struct tdb_ident *)m_tag_data(mtag);
 730                         if (tdbi->spi == sp->req->sav->spi &&
 731                             tdbi->proto == sp->req->sav->sah->saidx.proto &&
 732                             bcmp(&tdbi->dst, &sp->req->sav->sah->saidx.dst,
 733                                  sizeof(union sockaddr_union)) == 0) {
 734                                 /*
 735                                  * No IPsec processing is needed, free
 736                                  * reference to SP.
 737                                  *
 738                                  * NB: null pointer to avoid free at
 739                                  *     done: below.
 740                                  */
 741                                 KEY_FREESP(&sp), sp = NULL;
 742                                 crit_exit();
 743                                 goto spd_done;
 744                         }
 745                 }
 746
 747                 /*
 748                  * Do delayed checksums now because we send before
 749                  * this is done in the normal processing path.
 750                  */
 751                 if (m->m_pkthdr.csum_flags & CSUM_DELAY_DATA) {
 752                         in_delayed_cksum(m);
 753                         m->m_pkthdr.csum_flags &= ~CSUM_DELAY_DATA;
 754                 }
 755
 756                 ip->ip_len = htons(ip->ip_len);
 757                 ip->ip_off = htons(ip->ip_off);
 758
 759                 /* NB: callee frees mbuf */
 760                 error = ipsec4_process_packet(m, sp->req, flags, 0);
 761                 /*
 762                  * Preserve KAME behaviour: ENOENT can be returned
 763                  * when an SA acquire is in progress.  Don't propagate
 764                  * this to user-level; it confuses applications.
 765                  *
 766                  * XXX this will go away when the SADB is redone.
 767                  */
 768                 if (error == ENOENT)
 769                         error = 0;
 770                 crit_exit();
 771                 goto done;
 772         } else {
 773                 crit_exit();
 774
 775                 if (error != 0) {
 776                         /*
 777                          * Hack: -EINVAL is used to signal that a packet
 778                          * should be silently discarded.  This is typically
 779                          * because we asked key management for an SA and
 780                          * it was delayed (e.g. kicked up to IKE).
 781                          */
 782                         if (error == -EINVAL)
 783                                 error = 0;
 784                         goto bad;
 785                 } else {
 786                         /* No IPsec processing for this packet. */
 787                 }
 788 #ifdef notyet
 789                 /*
 790                  * If deferred crypto processing is needed, check that
 791                  * the interface supports it.
 792                  */
 793                 mtag = m_tag_find(m, PACKET_TAG_IPSEC_OUT_CRYPTO_NEEDED, NULL);
 794                 if (mtag != NULL && !(ifp->if_capenable & IFCAP_IPSEC)) {
 795                         /* notify IPsec to do its own crypto */
 796                         ipsp_skipcrypto_unmark((struct tdb_ident *)m_tag_data(mtag));
 797                         error = EHOSTUNREACH;
 798                         goto bad;
 799                 }
 800 #endif
 801         }
 802 spd_done:
 803 #endif /* FAST_IPSEC */
 804
 805         /* We are already being fwd'd from a firewall. */
 806         if (next_hop != NULL)
 807                 goto pass;
 808
 809         /*
 810          * IpHack's section.
 811          * - Xlate: translate packet's addr/port (NAT).
 812          * - Firewall: deny/allow/etc.
 813          * - Wrap: fake packet's addr/port <unimpl.>
 814          * - Encapsulate: put it in another IP and send out. <unimp.>
 815          */
 816
 817         /*
 818          * Run through list of hooks for output packets.
 819          */
 820         if (pfil_has_hooks(&inet_pfil_hook)) {
 821                 error = pfil_run_hooks(&inet_pfil_hook, &m, ifp, PFIL_OUT);
 822                 if (error != 0 || m == NULL)
 823                         goto done;
 824                 ip = mtod(m, struct ip *);
 825         }
 826
 827         /*
 828          * Check with the firewall...
 829          */
 830         if (fw_enable && IPFW_LOADED) {
 831                 struct ip_fw_args args;
 832                 int tee = 0;
 833
 834                 if (m->m_pkthdr.fw_flags & DUMMYNET_MBUF_TAGGED) {
 835                         /* Extract info from dummynet tag */
 836                         mtag = m_tag_find(m, PACKET_TAG_DUMMYNET, NULL);
 837                         KKASSERT(mtag != NULL);
 838                         args.rule =
 839                         ((struct dn_pkt *)m_tag_data(mtag))->dn_priv;
 840                         KKASSERT(args.rule != NULL);
 841
 842                         m_tag_delete(m, mtag);
 843                         m->m_pkthdr.fw_flags &= ~DUMMYNET_MBUF_TAGGED;
 844                 } else {
 845                         args.rule = NULL;
 846                 }
 847
 848                 args.eh = NULL;
 849                 args.m = m;
 850                 args.oif = ifp;
 851                 off = ip_fw_chk_ptr(&args);
 852                 m = args.m;
 853
 854                 if (m == NULL) {
 855                         error = EACCES;
 856                         goto done;
 857                 }
 858                 ip = mtod(m, struct ip *);
 859
 860                 switch (off) {
 861                 case IP_FW_PASS:
 862                         break;
 863
 864                 case IP_FW_DENY:
 865                         m_freem(m);
 866                         error = EACCES;
 867                         goto done;
 868
 869                 case IP_FW_DUMMYNET:
 870                         error = 0;
 871                         ip_fw_dn_io_ptr(m, args.cookie, DN_TO_IP_OUT, &args);
 872                         break;
 873
 874                 case IP_FW_TEE:
 875                         tee = 1;
 876                         /* FALL THROUGH */
 877
 878                 case IP_FW_DIVERT:
 879 #ifdef IPDIVERT
 880                         m = ip_divert_out(m, tee);
 881                         if (m == NULL)
 882                                 goto done;
 883                         ip = mtod(m, struct ip *);
 884                         break;
 885 #else
 886                         m_freem(m);
 887                         /* not sure this is the right error msg */
 888                         error = EACCES;
 889                         goto done;
 890 #endif
 891
 892                 default:
 893                         panic("unknown ipfw return value: %d\n", off);
 894                 }
 895         }
 896
 897         if (m->m_pkthdr.fw_flags & IPFORWARD_MBUF_TAGGED) {
 898                 /*
 899                  * Check dst to make sure it is directly reachable on the
 900                  * interface we previously thought it was.
 901                  * If it isn't (which may be likely in some situations) we have
 902                  * to re-route it (ie, find a route for the next-hop and the
 903                  * associated interface) and set them here. This is nested
 904                  * forwarding which in most cases is undesirable, except where
 905                  * such control is nigh impossible. So we do it here.
 906                  * And I'm babbling.
 907                  */
 908                 mtag = m_tag_find(m, PACKET_TAG_IPFORWARD, NULL);
 909                 KKASSERT(mtag != NULL);
 910                 next_hop = m_tag_data(mtag);
 911
 912                 /*
 913                  * Try local forwarding first
 914                  */
 915                 if (ip_localforward(m, next_hop))
 916                         goto done;
 917
 918                 /*
 919                  * Relocate the route based on next_hop.
 920                  * If the current route is inp's cache, keep it untouched.
 921                  */
 922                 if (ro == &iproute && ro->ro_rt != NULL) {
 923                         RTFREE(ro->ro_rt);
 924                         ro->ro_rt = NULL;
 925                 }
 926                 ro = &iproute;
 927                 bzero(ro, sizeof *ro);
 928
 929                 /*
 930                  * Forwarding to broadcast address is not allowed.
 931                  * XXX Should we follow IP_ROUTETOIF?
 932                  */
 933                 flags &= ~(IP_ALLOWBROADCAST | IP_ROUTETOIF);
 934
 935                 /* We are doing forwarding now */
 936                 flags |= IP_FORWARDING;
 937
 938                 goto reroute;
 939         }
 940
 941         if (m->m_pkthdr.fw_flags & DUMMYNET_MBUF_TAGGED) {
 942                 struct dn_pkt *dn_pkt;
 943
 944                 mtag = m_tag_find(m, PACKET_TAG_DUMMYNET, NULL);
 945                 KKASSERT(mtag != NULL);
 946                 dn_pkt = m_tag_data(mtag);
 947
 948                 /*
 949                  * Under certain cases it is not possible to recalculate
 950                  * 'ro' and 'dst', let alone 'flags', so just save them in
 951                  * dummynet tag and avoid the possible wrong reculcalation
 952                  * when we come back to ip_output() again.
 953                  *
 954                  * All other parameters have been already used and so they
 955                  * are not needed anymore.
 956                  * XXX if the ifp is deleted while a pkt is in dummynet,
 957                  * we are in trouble! (TODO use ifnet_detach_event)
 958                  *
 959                  * We need to copy *ro because for ICMP pkts (and maybe
 960                  * others) the caller passed a pointer into the stack;
 961                  * dst might also be a pointer into *ro so it needs to
 962                  * be updated.
 963                  */
 964                 dn_pkt->ro = *ro;
 965                 if (ro->ro_rt)
 966                         ro->ro_rt->rt_refcnt++;
 967                 if (dst == (struct sockaddr_in *)&ro->ro_dst) {
 968                         /* 'dst' points into 'ro' */
 969                         dst = (struct sockaddr_in *)&(dn_pkt->ro.ro_dst);
 970                 }
 971                 dn_pkt->dn_dst = dst;
 972                 dn_pkt->flags = flags;
 973
 974                 ip_dn_queue(m);
 975                 goto done;
 976         }
 977 pass:
 978         /* 127/8 must not appear on wire - RFC1122. */
 979         if ((ntohl(ip->ip_dst.s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET ||
 980             (ntohl(ip->ip_src.s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET) {
 981                 if (!(ifp->if_flags & IFF_LOOPBACK)) {
 982                         ipstat.ips_badaddr++;
 983                         error = EADDRNOTAVAIL;
 984                         goto bad;
 985                 }
 986         }
 987
 988         m->m_pkthdr.csum_flags |= CSUM_IP;
 989         sw_csum = m->m_pkthdr.csum_flags & ~ifp->if_hwassist;
 990         if (sw_csum & CSUM_DELAY_DATA) {
 991                 in_delayed_cksum(m);
 992                 sw_csum &= ~CSUM_DELAY_DATA;
 993         }
 994         m->m_pkthdr.csum_flags &= ifp->if_hwassist;
 995
 996         /*
 997          * If small enough for interface, or the interface will take
 998          * care of the fragmentation for us, can just send directly.
 999          */
1000         if (ip->ip_len <= ifp->if_mtu || ((ifp->if_hwassist & CSUM_FRAGMENT) &&
1001             !(ip->ip_off & IP_DF))) {
1002                 ip->ip_len = htons(ip->ip_len);
1003                 ip->ip_off = htons(ip->ip_off);
1004                 ip->ip_sum = 0;
1005                 if (sw_csum & CSUM_DELAY_IP) {
1006                         if (ip->ip_vhl == IP_VHL_BORING) {
1007                                 ip->ip_sum = in_cksum_hdr(ip);
1008                         } else {
1009                                 ip->ip_sum = in_cksum(m, hlen);
1010                         }
1011                 }
1012
1013                 /* Record statistics for this interface address. */
1014                 if (!(flags & IP_FORWARDING) && ia) {
1015                         ia->ia_ifa.if_opackets++;
1016                         ia->ia_ifa.if_obytes += m->m_pkthdr.len;
1017                 }
1018
1019 #ifdef IPSEC
1020                 /* clean ipsec history once it goes out of the node */
1021                 ipsec_delaux(m);
1022 #endif
1023
1024 #ifdef MBUF_STRESS_TEST
1025                 if (mbuf_frag_size && m->m_pkthdr.len > mbuf_frag_size) {
1026                         struct mbuf *m1, *m2;
1027                         int length, tmp;
1028
1029                         tmp = length = m->m_pkthdr.len;
1030
1031                         while ((length -= mbuf_frag_size) >= 1) {
1032                                 m1 = m_split(m, length, MB_DONTWAIT);
1033                                 if (m1 == NULL)
1034                                         break;
1035                                 m2 = m;
1036                                 while (m2->m_next != NULL)
1037                                         m2 = m2->m_next;
1038                                 m2->m_next = m1;
1039                         }
1040                         m->m_pkthdr.len = tmp;
1041                 }
1042 #endif
1043
1044 #ifdef MPLS
1045                 if (!mpls_output_process(m, ro->ro_rt))
1046                         goto done;
1047 #endif
1048                 error = ifp->if_output(ifp, m, (struct sockaddr *)dst,
1049                                        ro->ro_rt);
1050                 goto done;
1051         }
1052
1053         if (ip->ip_off & IP_DF) {
1054                 error = EMSGSIZE;
1055                 /*
1056                  * This case can happen if the user changed the MTU
1057                  * of an interface after enabling IP on it.  Because
1058                  * most netifs don't keep track of routes pointing to
1059                  * them, there is no way for one to update all its
1060                  * routes when the MTU is changed.
1061                  */
1062                 if ((ro->ro_rt->rt_flags & (RTF_UP | RTF_HOST)) &&
1063                     !(ro->ro_rt->rt_rmx.rmx_locks & RTV_MTU) &&
1064                     (ro->ro_rt->rt_rmx.rmx_mtu > ifp->if_mtu)) {
1065                         ro->ro_rt->rt_rmx.rmx_mtu = ifp->if_mtu;
1066                 }
1067                 ipstat.ips_cantfrag++;
1068                 goto bad;
1069         }
1070
1071         /*
1072          * Too large for interface; fragment if possible. If successful,
1073          * on return, m will point to a list of packets to be sent.
1074          */
1075         error = ip_fragment(ip, &m, ifp->if_mtu, ifp->if_hwassist, sw_csum);
1076         if (error)
1077                 goto bad;
1078         for (; m; m = m0) {
1079                 m0 = m->m_nextpkt;
1080                 m->m_nextpkt = NULL;
1081 #ifdef IPSEC
1082                 /* clean ipsec history once it goes out of the node */
1083                 ipsec_delaux(m);
1084 #endif
1085                 if (error == 0) {
1086                         /* Record statistics for this interface address. */
1087                         if (ia != NULL) {
1088                                 ia->ia_ifa.if_opackets++;
1089                                 ia->ia_ifa.if_obytes += m->m_pkthdr.len;
1090                         }
1091 #ifdef MPLS
1092                         if (!mpls_output_process(m, ro->ro_rt))
1093                                 continue;
1094 #endif
1095                         error = ifp->if_output(ifp, m, (struct sockaddr *)dst,
1096                                                ro->ro_rt);
1097                 } else {
1098                         m_freem(m);
1099                 }
1100         }
1101
1102         if (error == 0)
1103                 ipstat.ips_fragmented++;
1104
1105 done:
1106         if (ro == &iproute && ro->ro_rt != NULL) {
1107                 RTFREE(ro->ro_rt);
1108                 ro->ro_rt = NULL;
1109         }
1110 #ifdef IPSEC
1111         if (sp != NULL) {
1112                 KEYDEBUG(KEYDEBUG_IPSEC_STAMP,
1113                         kprintf("DP ip_output call free SP:%p\n", sp));
1114                 key_freesp(sp);
1115         }
1116 #endif
1117 #ifdef FAST_IPSEC
1118         if (sp != NULL)
1119                 KEY_FREESP(&sp);
1120 #endif
1121         return (error);
1122 bad:
1123         m_freem(m);
1124         goto done;
1125 }
1126
1127 /*
1128  * Create a chain of fragments which fit the given mtu. m_frag points to the
1129  * mbuf to be fragmented; on return it points to the chain with the fragments.
1130  * Return 0 if no error. If error, m_frag may contain a partially built
1131  * chain of fragments that should be freed by the caller.
1132  *
1133  * if_hwassist_flags is the hw offload capabilities (see if_data.ifi_hwassist)
1134  * sw_csum contains the delayed checksums flags (e.g., CSUM_DELAY_IP).
1135  */
1136 int
1137 ip_fragment(struct ip *ip, struct mbuf **m_frag, int mtu,
1138             u_long if_hwassist_flags, int sw_csum)
1139 {
1140         int error = 0;
1141         int hlen = IP_VHL_HL(ip->ip_vhl) << 2;
1142         int len = (mtu - hlen) & ~7;    /* size of payload in each fragment */
1143         int off;
1144         struct mbuf *m0 = *m_frag;      /* the original packet          */
1145         int firstlen;
1146         struct mbuf **mnext;
1147         int nfrags;
1148
1149         if (ip->ip_off & IP_DF) {       /* Fragmentation not allowed */
1150                 ipstat.ips_cantfrag++;
1151                 return EMSGSIZE;
1152         }
1153
1154         /*
1155          * Must be able to put at least 8 bytes per fragment.
1156          */
1157         if (len < 8)
1158                 return EMSGSIZE;
1159
1160         /*
1161          * If the interface will not calculate checksums on
1162          * fragmented packets, then do it here.
1163          */
1164         if ((m0->m_pkthdr.csum_flags & CSUM_DELAY_DATA) &&
1165             !(if_hwassist_flags & CSUM_IP_FRAGS)) {
1166                 in_delayed_cksum(m0);
1167                 m0->m_pkthdr.csum_flags &= ~CSUM_DELAY_DATA;
1168         }
1169
1170         if (len > PAGE_SIZE) {
1171                 /*
1172                  * Fragment large datagrams such that each segment
1173                  * contains a multiple of PAGE_SIZE amount of data,
1174                  * plus headers. This enables a receiver to perform
1175                  * page-flipping zero-copy optimizations.
1176                  *
1177                  * XXX When does this help given that sender and receiver
1178                  * could have different page sizes, and also mtu could
1179                  * be less than the receiver's page size ?
1180                  */
1181                 int newlen;
1182                 struct mbuf *m;
1183
1184                 for (m = m0, off = 0; m && (off+m->m_len) <= mtu; m = m->m_next)
1185                         off += m->m_len;
1186
1187                 /*
1188                  * firstlen (off - hlen) must be aligned on an
1189                  * 8-byte boundary
1190                  */
1191                 if (off < hlen)
1192                         goto smart_frag_failure;
1193                 off = ((off - hlen) & ~7) + hlen;
1194                 newlen = (~PAGE_MASK) & mtu;
1195                 if ((newlen + sizeof(struct ip)) > mtu) {
1196                         /* we failed, go back the default */
1197 smart_frag_failure:
1198                         newlen = len;
1199                         off = hlen + len;
1200                 }
1201                 len = newlen;
1202
1203         } else {
1204                 off = hlen + len;
1205         }
1206
1207         firstlen = off - hlen;
1208         mnext = &m0->m_nextpkt;         /* pointer to next packet */
1209
1210         /*
1211          * Loop through length of segment after first fragment,
1212          * make new header and copy data of each part and link onto chain.
1213          * Here, m0 is the original packet, m is the fragment being created.
1214          * The fragments are linked off the m_nextpkt of the original
1215          * packet, which after processing serves as the first fragment.
1216          */
1217         for (nfrags = 1; off < ip->ip_len; off += len, nfrags++) {
1218                 struct ip *mhip;        /* ip header on the fragment */
1219                 struct mbuf *m;
1220                 int mhlen = sizeof(struct ip);
1221
1222                 MGETHDR(m, MB_DONTWAIT, MT_HEADER);
1223                 if (m == NULL) {
1224                         error = ENOBUFS;
1225                         ipstat.ips_odropped++;
1226                         goto done;
1227                 }
1228                 m->m_flags |= (m0->m_flags & M_MCAST) | M_FRAG;
1229                 /*
1230                  * In the first mbuf, leave room for the link header, then
1231                  * copy the original IP header including options. The payload
1232                  * goes into an additional mbuf chain returned by m_copy().
1233                  */
1234                 m->m_data += max_linkhdr;
1235                 mhip = mtod(m, struct ip *);
1236                 *mhip = *ip;
1237                 if (hlen > sizeof(struct ip)) {
1238                         mhlen = ip_optcopy(ip, mhip) + sizeof(struct ip);
1239                         mhip->ip_vhl = IP_MAKE_VHL(IPVERSION, mhlen >> 2);
1240                 }
1241                 m->m_len = mhlen;
1242                 /* XXX do we need to add ip->ip_off below ? */
1243                 mhip->ip_off = ((off - hlen) >> 3) + ip->ip_off;
1244                 if (off + len >= ip->ip_len) {  /* last fragment */
1245                         len = ip->ip_len - off;
1246                         m->m_flags |= M_LASTFRAG;
1247                 } else
1248                         mhip->ip_off |= IP_MF;
1249                 mhip->ip_len = htons((u_short)(len + mhlen));
1250                 m->m_next = m_copy(m0, off, len);
1251                 if (m->m_next == NULL) {                /* copy failed */
1252                         m_free(m);
1253                         error = ENOBUFS;        /* ??? */
1254                         ipstat.ips_odropped++;
1255                         goto done;
1256                 }
1257                 m->m_pkthdr.len = mhlen + len;
1258                 m->m_pkthdr.rcvif = (struct ifnet *)NULL;
1259                 m->m_pkthdr.csum_flags = m0->m_pkthdr.csum_flags;
1260                 mhip->ip_off = htons(mhip->ip_off);
1261                 mhip->ip_sum = 0;
1262                 if (sw_csum & CSUM_DELAY_IP)
1263                         mhip->ip_sum = in_cksum(m, mhlen);
1264                 *mnext = m;
1265                 mnext = &m->m_nextpkt;
1266         }
1267         ipstat.ips_ofragments += nfrags;
1268
1269         /* set first marker for fragment chain */
1270         m0->m_flags |= M_FIRSTFRAG | M_FRAG;
1271         m0->m_pkthdr.csum_data = nfrags;
1272
1273         /*
1274          * Update first fragment by trimming what's been copied out
1275          * and updating header.
1276          */
1277         m_adj(m0, hlen + firstlen - ip->ip_len);
1278         m0->m_pkthdr.len = hlen + firstlen;
1279         ip->ip_len = htons((u_short)m0->m_pkthdr.len);
1280         ip->ip_off |= IP_MF;
1281         ip->ip_off = htons(ip->ip_off);
1282         ip->ip_sum = 0;
1283         if (sw_csum & CSUM_DELAY_IP)
1284                 ip->ip_sum = in_cksum(m0, hlen);
1285
1286 done:
1287         *m_frag = m0;
1288         return error;
1289 }
1290
1291 void
1292 in_delayed_cksum(struct mbuf *m)
1293 {
1294         struct ip *ip;
1295         u_short csum, offset;
1296
1297         ip = mtod(m, struct ip *);
1298         offset = IP_VHL_HL(ip->ip_vhl) << 2 ;
1299         csum = in_cksum_skip(m, ip->ip_len, offset);
1300         if (m->m_pkthdr.csum_flags & CSUM_UDP && csum == 0)
1301                 csum = 0xffff;
1302         offset += m->m_pkthdr.csum_data;        /* checksum offset */
1303
1304         if (offset + sizeof(u_short) > m->m_len) {
1305                 kprintf("delayed m_pullup, m->len: %d  off: %d  p: %d\n",
1306                     m->m_len, offset, ip->ip_p);
1307                 /*
1308                  * XXX
1309                  * this shouldn't happen, but if it does, the
1310                  * correct behavior may be to insert the checksum
1311                  * in the existing chain instead of rearranging it.
1312                  */
1313                 m = m_pullup(m, offset + sizeof(u_short));
1314         }
1315         *(u_short *)(m->m_data + offset) = csum;
1316 }
1317
1318 /*
1319  * Insert IP options into preformed packet.
1320  * Adjust IP destination as required for IP source routing,
1321  * as indicated by a non-zero in_addr at the start of the options.
1322  *
1323  * XXX This routine assumes that the packet has no options in place.
1324  */
1325 static struct mbuf *
1326 ip_insertoptions(struct mbuf *m, struct mbuf *opt, int *phlen)
1327 {
1328         struct ipoption *p = mtod(opt, struct ipoption *);
1329         struct mbuf *n;
1330         struct ip *ip = mtod(m, struct ip *);
1331         unsigned optlen;
1332
1333         optlen = opt->m_len - sizeof p->ipopt_dst;
1334         if (optlen + (u_short)ip->ip_len > IP_MAXPACKET) {
1335                 *phlen = 0;
1336                 return (m);             /* XXX should fail */
1337         }
1338         if (p->ipopt_dst.s_addr)
1339                 ip->ip_dst = p->ipopt_dst;
1340         if (m->m_flags & M_EXT || m->m_data - optlen < m->m_pktdat) {
1341                 MGETHDR(n, MB_DONTWAIT, MT_HEADER);
1342                 if (n == NULL) {
1343                         *phlen = 0;
1344                         return (m);
1345                 }
1346                 n->m_pkthdr.rcvif = (struct ifnet *)NULL;
1347                 n->m_pkthdr.len = m->m_pkthdr.len + optlen;
1348                 m->m_len -= sizeof(struct ip);
1349                 m->m_data += sizeof(struct ip);
1350                 n->m_next = m;
1351                 m = n;
1352                 m->m_len = optlen + sizeof(struct ip);
1353                 m->m_data += max_linkhdr;
1354                 memcpy(mtod(m, void *), ip, sizeof(struct ip));
1355         } else {
1356                 m->m_data -= optlen;
1357                 m->m_len += optlen;
1358                 m->m_pkthdr.len += optlen;
1359                 ovbcopy(ip, mtod(m, caddr_t), sizeof(struct ip));
1360         }
1361         ip = mtod(m, struct ip *);
1362         bcopy(p->ipopt_list, ip + 1, optlen);
1363         *phlen = sizeof(struct ip) + optlen;
1364         ip->ip_vhl = IP_MAKE_VHL(IPVERSION, *phlen >> 2);
1365         ip->ip_len += optlen;
1366         return (m);
1367 }
1368
1369 /*
1370  * Copy options from ip to jp,
1371  * omitting those not copied during fragmentation.
1372  */
1373 int
1374 ip_optcopy(struct ip *ip, struct ip *jp)
1375 {
1376         u_char *cp, *dp;
1377         int opt, optlen, cnt;
1378
1379         cp = (u_char *)(ip + 1);
1380         dp = (u_char *)(jp + 1);
1381         cnt = (IP_VHL_HL(ip->ip_vhl) << 2) - sizeof(struct ip);
1382         for (; cnt > 0; cnt -= optlen, cp += optlen) {
1383                 opt = cp[0];
1384                 if (opt == IPOPT_EOL)
1385                         break;
1386                 if (opt == IPOPT_NOP) {
1387                         /* Preserve for IP mcast tunnel's LSRR alignment. */
1388                         *dp++ = IPOPT_NOP;
1389                         optlen = 1;
1390                         continue;
1391                 }
1392
1393                 KASSERT(cnt >= IPOPT_OLEN + sizeof *cp,
1394                     ("ip_optcopy: malformed ipv4 option"));
1395                 optlen = cp[IPOPT_OLEN];
1396                 KASSERT(optlen >= IPOPT_OLEN + sizeof *cp && optlen <= cnt,
1397                     ("ip_optcopy: malformed ipv4 option"));
1398
1399                 /* bogus lengths should have been caught by ip_dooptions */
1400                 if (optlen > cnt)
1401                         optlen = cnt;
1402                 if (IPOPT_COPIED(opt)) {
1403                         bcopy(cp, dp, optlen);
1404                         dp += optlen;
1405                 }
1406         }
1407         for (optlen = dp - (u_char *)(jp+1); optlen & 0x3; optlen++)
1408                 *dp++ = IPOPT_EOL;
1409         return (optlen);
1410 }
1411
1412 /*
1413  * IP socket option processing.
1414  */
1415 int
1416 ip_ctloutput(struct socket *so, struct sockopt *sopt)
1417 {
1418         struct  inpcb *inp = so->so_pcb;
1419         int     error, optval;
1420
1421         error = optval = 0;
1422         if (sopt->sopt_level != IPPROTO_IP) {
1423                 return (EINVAL);
1424         }
1425
1426         switch (sopt->sopt_dir) {
1427         case SOPT_SET:
1428                 switch (sopt->sopt_name) {
1429                 case IP_OPTIONS:
1430 #ifdef notyet
1431                 case IP_RETOPTS:
1432 #endif
1433                 {
1434                         struct mbuf *m;
1435                         if (sopt->sopt_valsize > MLEN) {
1436                                 error = EMSGSIZE;
1437                                 break;
1438                         }
1439                         MGET(m, sopt->sopt_td ? MB_WAIT : MB_DONTWAIT, MT_HEADER);
1440                         if (m == NULL) {
1441                                 error = ENOBUFS;
1442                                 break;
1443                         }
1444                         m->m_len = sopt->sopt_valsize;
1445                         error = soopt_to_kbuf(sopt, mtod(m, void *), m->m_len,
1446                                               m->m_len);
1447                         return (ip_pcbopts(sopt->sopt_name, &inp->inp_options,
1448                                            m));
1449                 }
1450
1451                 case IP_TOS:
1452                 case IP_TTL:
1453                 case IP_MINTTL:
1454                 case IP_RECVOPTS:
1455                 case IP_RECVRETOPTS:
1456                 case IP_RECVDSTADDR:
1457                 case IP_RECVIF:
1458                 case IP_RECVTTL:
1459                 case IP_FAITH:
1460                         error = soopt_to_kbuf(sopt, &optval, sizeof optval,
1461                                              sizeof optval);
1462                         if (error)
1463                                 break;
1464                         switch (sopt->sopt_name) {
1465                         case IP_TOS:
1466                                 inp->inp_ip_tos = optval;
1467                                 break;
1468
1469                         case IP_TTL:
1470                                 inp->inp_ip_ttl = optval;
1471                                 break;
1472                         case IP_MINTTL:
1473                                 if (optval > 0 && optval <= MAXTTL)
1474                                         inp->inp_ip_minttl = optval;
1475                                 else
1476                                         error = EINVAL;
1477                                 break;
1478 #define OPTSET(bit) \
1479         if (optval) \
1480                 inp->inp_flags |= bit; \
1481         else \
1482                 inp->inp_flags &= ~bit;
1483
1484                         case IP_RECVOPTS:
1485                                 OPTSET(INP_RECVOPTS);
1486                                 break;
1487
1488                         case IP_RECVRETOPTS:
1489                                 OPTSET(INP_RECVRETOPTS);
1490                                 break;
1491
1492                         case IP_RECVDSTADDR:
1493                                 OPTSET(INP_RECVDSTADDR);
1494                                 break;
1495
1496                         case IP_RECVIF:
1497                                 OPTSET(INP_RECVIF);
1498                                 break;
1499
1500                         case IP_RECVTTL:
1501                                 OPTSET(INP_RECVTTL);
1502                                 break;
1503
1504                         case IP_FAITH:
1505                                 OPTSET(INP_FAITH);
1506                                 break;
1507                         }
1508                         break;
1509 #undef OPTSET
1510
1511                 case IP_MULTICAST_IF:
1512                 case IP_MULTICAST_VIF:
1513                 case IP_MULTICAST_TTL:
1514                 case IP_MULTICAST_LOOP:
1515                 case IP_ADD_MEMBERSHIP:
1516                 case IP_DROP_MEMBERSHIP:
1517                         error = ip_setmoptions(sopt, &inp->inp_moptions);
1518                         break;
1519
1520                 case IP_PORTRANGE:
1521                         error = soopt_to_kbuf(sopt, &optval, sizeof optval,
1522                                             sizeof optval);
1523                         if (error)
1524                                 break;
1525
1526                         switch (optval) {
1527                         case IP_PORTRANGE_DEFAULT:
1528                                 inp->inp_flags &= ~(INP_LOWPORT);
1529                                 inp->inp_flags &= ~(INP_HIGHPORT);
1530                                 break;
1531
1532                         case IP_PORTRANGE_HIGH:
1533                                 inp->inp_flags &= ~(INP_LOWPORT);
1534                                 inp->inp_flags |= INP_HIGHPORT;
1535                                 break;
1536
1537                         case IP_PORTRANGE_LOW:
1538                                 inp->inp_flags &= ~(INP_HIGHPORT);
1539                                 inp->inp_flags |= INP_LOWPORT;
1540                                 break;
1541
1542                         default:
1543                                 error = EINVAL;
1544                                 break;
1545                         }
1546                         break;
1547
1548 #if defined(IPSEC) || defined(FAST_IPSEC)
1549                 case IP_IPSEC_POLICY:
1550                 {
1551                         caddr_t req;
1552                         size_t len = 0;
1553                         int priv;
1554                         struct mbuf *m;
1555                         int optname;
1556
1557                         if ((error = soopt_getm(sopt, &m)) != 0) /* XXX */
1558                                 break;
1559                         soopt_to_mbuf(sopt, m);
1560                         priv = (sopt->sopt_td != NULL &&
1561                                 suser(sopt->sopt_td) != 0) ? 0 : 1;
1562                         req = mtod(m, caddr_t);
1563                         len = m->m_len;
1564                         optname = sopt->sopt_name;
1565                         error = ipsec4_set_policy(inp, optname, req, len, priv);
1566                         m_freem(m);
1567                         break;
1568                 }
1569 #endif /*IPSEC*/
1570
1571                 default:
1572                         error = ENOPROTOOPT;
1573                         break;
1574                 }
1575                 break;
1576
1577         case SOPT_GET:
1578                 switch (sopt->sopt_name) {
1579                 case IP_OPTIONS:
1580                 case IP_RETOPTS:
1581                         if (inp->inp_options)
1582                                 soopt_from_kbuf(sopt, mtod(inp->inp_options,
1583                                                            char *),
1584                                                 inp->inp_options->m_len);
1585                         else
1586                                 sopt->sopt_valsize = 0;
1587                         break;
1588
1589                 case IP_TOS:
1590                 case IP_TTL:
1591                 case IP_MINTTL:
1592                 case IP_RECVOPTS:
1593                 case IP_RECVRETOPTS:
1594                 case IP_RECVDSTADDR:
1595                 case IP_RECVTTL:
1596                 case IP_RECVIF:
1597                 case IP_PORTRANGE:
1598                 case IP_FAITH:
1599                         switch (sopt->sopt_name) {
1600
1601                         case IP_TOS:
1602                                 optval = inp->inp_ip_tos;
1603                                 break;
1604
1605                         case IP_TTL:
1606                                 optval = inp->inp_ip_ttl;
1607                                 break;
1608                         case IP_MINTTL:
1609                                 optval = inp->inp_ip_minttl;
1610                                 break;
1611
1612 #define OPTBIT(bit)     (inp->inp_flags & bit ? 1 : 0)
1613
1614                         case IP_RECVOPTS:
1615                                 optval = OPTBIT(INP_RECVOPTS);
1616                                 break;
1617
1618                         case IP_RECVRETOPTS:
1619                                 optval = OPTBIT(INP_RECVRETOPTS);
1620                                 break;
1621
1622                         case IP_RECVDSTADDR:
1623                                 optval = OPTBIT(INP_RECVDSTADDR);
1624                                 break;
1625
1626                         case IP_RECVTTL:
1627                                 optval = OPTBIT(INP_RECVTTL);
1628                                 break;
1629
1630                         case IP_RECVIF:
1631                                 optval = OPTBIT(INP_RECVIF);
1632                                 break;
1633
1634                         case IP_PORTRANGE:
1635                                 if (inp->inp_flags & INP_HIGHPORT)
1636                                         optval = IP_PORTRANGE_HIGH;
1637                                 else if (inp->inp_flags & INP_LOWPORT)
1638                                         optval = IP_PORTRANGE_LOW;
1639                                 else
1640                                         optval = 0;
1641                                 break;
1642
1643                         case IP_FAITH:
1644                                 optval = OPTBIT(INP_FAITH);
1645                                 break;
1646                         }
1647                         soopt_from_kbuf(sopt, &optval, sizeof optval);
1648                         break;
1649
1650                 case IP_MULTICAST_IF:
1651                 case IP_MULTICAST_VIF:
1652                 case IP_MULTICAST_TTL:
1653                 case IP_MULTICAST_LOOP:
1654                 case IP_ADD_MEMBERSHIP:
1655                 case IP_DROP_MEMBERSHIP:
1656                         error = ip_getmoptions(sopt, inp->inp_moptions);
1657                         break;
1658
1659 #if defined(IPSEC) || defined(FAST_IPSEC)
1660                 case IP_IPSEC_POLICY:
1661                 {
1662                         struct mbuf *m = NULL;
1663                         caddr_t req = NULL;
1664                         size_t len = 0;
1665
1666                         if (m != NULL) {
1667                                 req = mtod(m, caddr_t);
1668                                 len = m->m_len;
1669                         }
1670                         error = ipsec4_get_policy(so->so_pcb, req, len, &m);
1671                         if (error == 0)
1672                                 error = soopt_from_mbuf(sopt, m); /* XXX */
1673                         if (error == 0)
1674                                 m_freem(m);
1675                         break;
1676                 }
1677 #endif /*IPSEC*/
1678
1679                 default:
1680                         error = ENOPROTOOPT;
1681                         break;
1682                 }
1683                 break;
1684         }
1685         return (error);
1686 }
1687
1688 /*
1689  * Set up IP options in pcb for insertion in output packets.
1690  * Store in mbuf with pointer in pcbopt, adding pseudo-option
1691  * with destination address if source routed.
1692  */
1693 static int
1694 ip_pcbopts(int optname, struct mbuf **pcbopt, struct mbuf *m)
1695 {
1696         int cnt, optlen;
1697         u_char *cp;
1698         u_char opt;
1699
1700         /* turn off any old options */
1701         if (*pcbopt)
1702                 m_free(*pcbopt);
1703         *pcbopt = 0;
1704         if (m == NULL || m->m_len == 0) {
1705                 /*
1706                  * Only turning off any previous options.
1707                  */
1708                 if (m != NULL)
1709                         m_free(m);
1710                 return (0);
1711         }
1712
1713         if (m->m_len % sizeof(int32_t))
1714                 goto bad;
1715         /*
1716          * IP first-hop destination address will be stored before
1717          * actual options; move other options back
1718          * and clear it when none present.
1719          */
1720         if (m->m_data + m->m_len + sizeof(struct in_addr) >= &m->m_dat[MLEN])
1721                 goto bad;
1722         cnt = m->m_len;
1723         m->m_len += sizeof(struct in_addr);
1724         cp = mtod(m, u_char *) + sizeof(struct in_addr);
1725         ovbcopy(mtod(m, caddr_t), cp, cnt);
1726         bzero(mtod(m, caddr_t), sizeof(struct in_addr));
1727
1728         for (; cnt > 0; cnt -= optlen, cp += optlen) {
1729                 opt = cp[IPOPT_OPTVAL];
1730                 if (opt == IPOPT_EOL)
1731                         break;
1732                 if (opt == IPOPT_NOP)
1733                         optlen = 1;
1734                 else {
1735                         if (cnt < IPOPT_OLEN + sizeof *cp)
1736                                 goto bad;
1737                         optlen = cp[IPOPT_OLEN];
1738                         if (optlen < IPOPT_OLEN + sizeof *cp || optlen > cnt)
1739                                 goto bad;
1740                 }
1741                 switch (opt) {
1742
1743                 default:
1744                         break;
1745
1746                 case IPOPT_LSRR:
1747                 case IPOPT_SSRR:
1748                         /*
1749                          * user process specifies route as:
1750                          *      ->A->B->C->D
1751                          * D must be our final destination (but we can't
1752                          * check that since we may not have connected yet).
1753                          * A is first hop destination, which doesn't appear in
1754                          * actual IP option, but is stored before the options.
1755                          */
1756                         if (optlen < IPOPT_MINOFF - 1 + sizeof(struct in_addr))
1757                                 goto bad;
1758                         m->m_len -= sizeof(struct in_addr);
1759                         cnt -= sizeof(struct in_addr);
1760                         optlen -= sizeof(struct in_addr);
1761                         cp[IPOPT_OLEN] = optlen;
1762                         /*
1763                          * Move first hop before start of options.
1764                          */
1765                         bcopy(&cp[IPOPT_OFFSET+1], mtod(m, caddr_t),
1766                               sizeof(struct in_addr));
1767                         /*
1768                          * Then copy rest of options back
1769                          * to close up the deleted entry.
1770                          */
1771                         ovbcopy(&cp[IPOPT_OFFSET+1] + sizeof(struct in_addr),
1772                                 &cp[IPOPT_OFFSET+1],
1773                                 cnt - (IPOPT_MINOFF - 1));
1774                         break;
1775                 }
1776         }
1777         if (m->m_len > MAX_IPOPTLEN + sizeof(struct in_addr))
1778                 goto bad;
1779         *pcbopt = m;
1780         return (0);
1781
1782 bad:
1783         m_free(m);
1784         return (EINVAL);
1785 }
1786
1787 /*
1788  * XXX
1789  * The whole multicast option thing needs to be re-thought.
1790  * Several of these options are equally applicable to non-multicast
1791  * transmission, and one (IP_MULTICAST_TTL) totally duplicates a
1792  * standard option (IP_TTL).
1793  */
1794
1795 /*
1796  * following RFC1724 section 3.3, 0.0.0.0/8 is interpreted as interface index.
1797  */
1798 static struct ifnet *
1799 ip_multicast_if(struct in_addr *a, int *ifindexp)
1800 {
1801         int ifindex;
1802         struct ifnet *ifp;
1803
1804         if (ifindexp)
1805                 *ifindexp = 0;
1806         if (ntohl(a->s_addr) >> 24 == 0) {
1807                 ifindex = ntohl(a->s_addr) & 0xffffff;
1808                 if (ifindex < 0 || if_index < ifindex)
1809                         return NULL;
1810                 ifp = ifindex2ifnet[ifindex];
1811                 if (ifindexp)
1812                         *ifindexp = ifindex;
1813         } else {
1814                 ifp = INADDR_TO_IFP(a);
1815         }
1816         return ifp;
1817 }
1818
1819 /*
1820  * Set the IP multicast options in response to user setsockopt().
1821  */
1822 static int
1823 ip_setmoptions(struct sockopt *sopt, struct ip_moptions **imop)
1824 {
1825         int error = 0;
1826         int i;
1827         struct in_addr addr;
1828         struct ip_mreq mreq;
1829         struct ifnet *ifp;
1830         struct ip_moptions *imo = *imop;
1831         int ifindex;
1832
1833         if (imo == NULL) {
1834                 /*
1835                  * No multicast option buffer attached to the pcb;
1836                  * allocate one and initialize to default values.
1837                  */
1838                 imo = kmalloc(sizeof *imo, M_IPMOPTS, M_WAITOK);
1839
1840                 *imop = imo;
1841                 imo->imo_multicast_ifp = NULL;
1842                 imo->imo_multicast_addr.s_addr = INADDR_ANY;
1843                 imo->imo_multicast_vif = -1;
1844                 imo->imo_multicast_ttl = IP_DEFAULT_MULTICAST_TTL;
1845                 imo->imo_multicast_loop = IP_DEFAULT_MULTICAST_LOOP;
1846                 imo->imo_num_memberships = 0;
1847         }
1848         switch (sopt->sopt_name) {
1849         /* store an index number for the vif you wanna use in the send */
1850         case IP_MULTICAST_VIF:
1851                 if (legal_vif_num == 0) {
1852                         error = EOPNOTSUPP;
1853                         break;
1854                 }
1855                 error = soopt_to_kbuf(sopt, &i, sizeof i, sizeof i);
1856                 if (error)
1857                         break;
1858                 if (!legal_vif_num(i) && (i != -1)) {
1859                         error = EINVAL;
1860                         break;
1861                 }
1862                 imo->imo_multicast_vif = i;
1863                 break;
1864
1865         case IP_MULTICAST_IF:
1866                 /*
1867                  * Select the interface for outgoing multicast packets.
1868                  */
1869                 error = soopt_to_kbuf(sopt, &addr, sizeof addr, sizeof addr);
1870                 if (error)
1871                         break;
1872
1873                 /*
1874                  * INADDR_ANY is used to remove a previous selection.
1875                  * When no interface is selected, a default one is
1876                  * chosen every time a multicast packet is sent.
1877                  */
1878                 if (addr.s_addr == INADDR_ANY) {
1879                         imo->imo_multicast_ifp = NULL;
1880                         break;
1881                 }
1882                 /*
1883                  * The selected interface is identified by its local
1884                  * IP address.  Find the interface and confirm that
1885                  * it supports multicasting.
1886                  */
1887                 crit_enter();
1888                 ifp = ip_multicast_if(&addr, &ifindex);
1889                 if (ifp == NULL || !(ifp->if_flags & IFF_MULTICAST)) {
1890                         crit_exit();
1891                         error = EADDRNOTAVAIL;
1892                         break;
1893                 }
1894                 imo->imo_multicast_ifp = ifp;
1895                 if (ifindex)
1896                         imo->imo_multicast_addr = addr;
1897                 else
1898                         imo->imo_multicast_addr.s_addr = INADDR_ANY;
1899                 crit_exit();
1900                 break;
1901
1902         case IP_MULTICAST_TTL:
1903                 /*
1904                  * Set the IP time-to-live for outgoing multicast packets.
1905                  * The original multicast API required a char argument,
1906                  * which is inconsistent with the rest of the socket API.
1907                  * We allow either a char or an int.
1908                  */
1909                 if (sopt->sopt_valsize == 1) {
1910                         u_char ttl;
1911                         error = soopt_to_kbuf(sopt, &ttl, 1, 1);
1912                         if (error)
1913                                 break;
1914                         imo->imo_multicast_ttl = ttl;
1915                 } else {
1916                         u_int ttl;
1917                         error = soopt_to_kbuf(sopt, &ttl, sizeof ttl, sizeof ttl);
1918                         if (error)
1919                                 break;
1920                         if (ttl > 255)
1921                                 error = EINVAL;
1922                         else
1923                                 imo->imo_multicast_ttl = ttl;
1924                 }
1925                 break;
1926
1927         case IP_MULTICAST_LOOP:
1928                 /*
1929                  * Set the loopback flag for outgoing multicast packets.
1930                  * Must be zero or one.  The original multicast API required a
1931                  * char argument, which is inconsistent with the rest
1932                  * of the socket API.  We allow either a char or an int.
1933                  */
1934                 if (sopt->sopt_valsize == 1) {
1935                         u_char loop;
1936
1937                         error = soopt_to_kbuf(sopt, &loop, 1, 1);
1938                         if (error)
1939                                 break;
1940                         imo->imo_multicast_loop = !!loop;
1941                 } else {
1942                         u_int loop;
1943
1944                         error = soopt_to_kbuf(sopt, &loop, sizeof loop,
1945                                             sizeof loop);
1946                         if (error)
1947                                 break;
1948                         imo->imo_multicast_loop = !!loop;
1949                 }
1950                 break;
1951
1952         case IP_ADD_MEMBERSHIP:
1953                 /*
1954                  * Add a multicast group membership.
1955                  * Group must be a valid IP multicast address.
1956                  */
1957                 error = soopt_to_kbuf(sopt, &mreq, sizeof mreq, sizeof mreq);
1958                 if (error)
1959                         break;
1960
1961                 if (!IN_MULTICAST(ntohl(mreq.imr_multiaddr.s_addr))) {
1962                         error = EINVAL;
1963                         break;
1964                 }
1965                 crit_enter();
1966                 /*
1967                  * If no interface address was provided, use the interface of
1968                  * the route to the given multicast address.
1969                  */
1970                 if (mreq.imr_interface.s_addr == INADDR_ANY) {
1971                         struct sockaddr_in dst;
1972                         struct rtentry *rt;
1973
1974                         bzero(&dst, sizeof(struct sockaddr_in));
1975                         dst.sin_len = sizeof(struct sockaddr_in);
1976                         dst.sin_family = AF_INET;
1977                         dst.sin_addr = mreq.imr_multiaddr;
1978                         rt = rtlookup((struct sockaddr *)&dst);
1979                         if (rt == NULL) {
1980                                 error = EADDRNOTAVAIL;
1981                                 crit_exit();
1982                                 break;
1983                         }
1984                         --rt->rt_refcnt;
1985                         ifp = rt->rt_ifp;
1986                 } else {
1987                         ifp = ip_multicast_if(&mreq.imr_interface, NULL);
1988                 }
1989
1990                 /*
1991                  * See if we found an interface, and confirm that it
1992                  * supports multicast.
1993                  */
1994                 if (ifp == NULL || !(ifp->if_flags & IFF_MULTICAST)) {
1995                         error = EADDRNOTAVAIL;
1996                         crit_exit();
1997                         break;
1998                 }
1999                 /*
2000                  * See if the membership already exists or if all the
2001                  * membership slots are full.
2002                  */
2003                 for (i = 0; i < imo->imo_num_memberships; ++i) {
2004                         if (imo->imo_membership[i]->inm_ifp == ifp &&
2005                             imo->imo_membership[i]->inm_addr.s_addr
2006                                                 == mreq.imr_multiaddr.s_addr)
2007                                 break;
2008                 }
2009                 if (i < imo->imo_num_memberships) {
2010                         error = EADDRINUSE;
2011                         crit_exit();
2012                         break;
2013                 }
2014                 if (i == IP_MAX_MEMBERSHIPS) {
2015                         error = ETOOMANYREFS;
2016                         crit_exit();
2017                         break;
2018                 }
2019                 /*
2020                  * Everything looks good; add a new record to the multicast
2021                  * address list for the given interface.
2022                  */
2023                 if ((imo->imo_membership[i] =
2024                      in_addmulti(&mreq.imr_multiaddr, ifp)) == NULL) {
2025                         error = ENOBUFS;
2026                         crit_exit();
2027                         break;
2028                 }
2029                 ++imo->imo_num_memberships;
2030                 crit_exit();
2031                 break;
2032
2033         case IP_DROP_MEMBERSHIP:
2034                 /*
2035                  * Drop a multicast group membership.
2036                  * Group must be a valid IP multicast address.
2037                  */
2038                 error = soopt_to_kbuf(sopt, &mreq, sizeof mreq, sizeof mreq);
2039                 if (error)
2040                         break;
2041
2042                 if (!IN_MULTICAST(ntohl(mreq.imr_multiaddr.s_addr))) {
2043                         error = EINVAL;
2044                         break;
2045                 }
2046
2047                 crit_enter();
2048                 /*
2049                  * If an interface address was specified, get a pointer
2050                  * to its ifnet structure.
2051                  */
2052                 if (mreq.imr_interface.s_addr == INADDR_ANY)
2053                         ifp = NULL;
2054                 else {
2055                         ifp = ip_multicast_if(&mreq.imr_interface, NULL);
2056                         if (ifp == NULL) {
2057                                 error = EADDRNOTAVAIL;
2058                                 crit_exit();
2059                                 break;
2060                         }
2061                 }
2062                 /*
2063                  * Find the membership in the membership array.
2064                  */
2065                 for (i = 0; i < imo->imo_num_memberships; ++i) {
2066                         if ((ifp == NULL ||
2067                              imo->imo_membership[i]->inm_ifp == ifp) &&
2068                             imo->imo_membership[i]->inm_addr.s_addr ==
2069                             mreq.imr_multiaddr.s_addr)
2070                                 break;
2071                 }
2072                 if (i == imo->imo_num_memberships) {
2073                         error = EADDRNOTAVAIL;
2074                         crit_exit();
2075                         break;
2076                 }
2077                 /*
2078                  * Give up the multicast address record to which the
2079                  * membership points.
2080                  */
2081                 in_delmulti(imo->imo_membership[i]);
2082                 /*
2083                  * Remove the gap in the membership array.
2084                  */
2085                 for (++i; i < imo->imo_num_memberships; ++i)
2086                         imo->imo_membership[i-1] = imo->imo_membership[i];
2087                 --imo->imo_num_memberships;
2088                 crit_exit();
2089                 break;
2090
2091         default:
2092                 error = EOPNOTSUPP;
2093                 break;
2094         }
2095
2096         /*
2097          * If all options have default values, no need to keep the mbuf.
2098          */
2099         if (imo->imo_multicast_ifp == NULL &&
2100             imo->imo_multicast_vif == -1 &&
2101             imo->imo_multicast_ttl == IP_DEFAULT_MULTICAST_TTL &&
2102             imo->imo_multicast_loop == IP_DEFAULT_MULTICAST_LOOP &&
2103             imo->imo_num_memberships == 0) {
2104                 kfree(*imop, M_IPMOPTS);
2105                 *imop = NULL;
2106         }
2107
2108         return (error);
2109 }
2110
2111 /*
2112  * Return the IP multicast options in response to user getsockopt().
2113  */
2114 static int
2115 ip_getmoptions(struct sockopt *sopt, struct ip_moptions *imo)
2116 {
2117         struct in_addr addr;
2118         struct in_ifaddr *ia;
2119         int error, optval;
2120         u_char coptval;
2121
2122         error = 0;
2123         switch (sopt->sopt_name) {
2124         case IP_MULTICAST_VIF:
2125                 if (imo != NULL)
2126                         optval = imo->imo_multicast_vif;
2127                 else
2128                         optval = -1;
2129                 soopt_from_kbuf(sopt, &optval, sizeof optval);
2130                 break;
2131
2132         case IP_MULTICAST_IF:
2133                 if (imo == NULL || imo->imo_multicast_ifp == NULL)
2134                         addr.s_addr = INADDR_ANY;
2135                 else if (imo->imo_multicast_addr.s_addr) {
2136                         /* return the value user has set */
2137                         addr = imo->imo_multicast_addr;
2138                 } else {
2139                         ia = IFP_TO_IA(imo->imo_multicast_ifp);
2140                         addr.s_addr = (ia == NULL) ? INADDR_ANY
2141                                 : IA_SIN(ia)->sin_addr.s_addr;
2142                 }
2143                 soopt_from_kbuf(sopt, &addr, sizeof addr);
2144                 break;
2145
2146         case IP_MULTICAST_TTL:
2147                 if (imo == NULL)
2148                         optval = coptval = IP_DEFAULT_MULTICAST_TTL;
2149                 else
2150                         optval = coptval = imo->imo_multicast_ttl;
2151                 if (sopt->sopt_valsize == 1)
2152                         soopt_from_kbuf(sopt, &coptval, 1);
2153                 else
2154                         soopt_from_kbuf(sopt, &optval, sizeof optval);
2155                 break;
2156
2157         case IP_MULTICAST_LOOP:
2158                 if (imo == NULL)
2159                         optval = coptval = IP_DEFAULT_MULTICAST_LOOP;
2160                 else
2161                         optval = coptval = imo->imo_multicast_loop;
2162                 if (sopt->sopt_valsize == 1)
2163                         soopt_from_kbuf(sopt, &coptval, 1);
2164                 else
2165                         soopt_from_kbuf(sopt, &optval, sizeof optval);
2166                 break;
2167
2168         default:
2169                 error = ENOPROTOOPT;
2170                 break;
2171         }
2172         return (error);
2173 }
2174
2175 /*
2176  * Discard the IP multicast options.
2177  */
2178 void
2179 ip_freemoptions(struct ip_moptions *imo)
2180 {
2181         int i;
2182
2183         if (imo != NULL) {
2184                 for (i = 0; i < imo->imo_num_memberships; ++i)
2185                         in_delmulti(imo->imo_membership[i]);
2186                 kfree(imo, M_IPMOPTS);
2187         }
2188 }
2189
2190 /*
2191  * Routine called from ip_output() to loop back a copy of an IP multicast
2192  * packet to the input queue of a specified interface.  Note that this
2193  * calls the output routine of the loopback "driver", but with an interface
2194  * pointer that might NOT be a loopback interface -- evil, but easier than
2195  * replicating that code here.
2196  */
2197 static void
2198 ip_mloopback(struct ifnet *ifp, struct mbuf *m, struct sockaddr_in *dst,
2199              int hlen)
2200 {
2201         struct ip *ip;
2202         struct mbuf *copym;
2203
2204         copym = m_copypacket(m, MB_DONTWAIT);
2205         if (copym != NULL && (copym->m_flags & M_EXT || copym->m_len < hlen))
2206                 copym = m_pullup(copym, hlen);
2207         if (copym != NULL) {
2208                 /*
2209                  * if the checksum hasn't been computed, mark it as valid
2210                  */
2211                 if (copym->m_pkthdr.csum_flags & CSUM_DELAY_DATA) {
2212                         in_delayed_cksum(copym);
2213                         copym->m_pkthdr.csum_flags &= ~CSUM_DELAY_DATA;
2214                         copym->m_pkthdr.csum_flags |=
2215                             CSUM_DATA_VALID | CSUM_PSEUDO_HDR;
2216                         copym->m_pkthdr.csum_data = 0xffff;
2217                 }
2218                 /*
2219                  * We don't bother to fragment if the IP length is greater
2220                  * than the interface's MTU.  Can this possibly matter?
2221                  */
2222                 ip = mtod(copym, struct ip *);
2223                 ip->ip_len = htons(ip->ip_len);
2224                 ip->ip_off = htons(ip->ip_off);
2225                 ip->ip_sum = 0;
2226                 if (ip->ip_vhl == IP_VHL_BORING) {
2227                         ip->ip_sum = in_cksum_hdr(ip);
2228                 } else {
2229                         ip->ip_sum = in_cksum(copym, hlen);
2230                 }
2231                 /*
2232                  * NB:
2233                  * It's not clear whether there are any lingering
2234                  * reentrancy problems in other areas which might
2235                  * be exposed by using ip_input directly (in
2236                  * particular, everything which modifies the packet
2237                  * in-place).  Yet another option is using the
2238                  * protosw directly to deliver the looped back
2239                  * packet.  For the moment, we'll err on the side
2240                  * of safety by using if_simloop().
2241                  */
2242 #if 1 /* XXX */
2243                 if (dst->sin_family != AF_INET) {
2244                         kprintf("ip_mloopback: bad address family %d\n",
2245                                                 dst->sin_family);
2246                         dst->sin_family = AF_INET;
2247                 }
2248 #endif
2249
2250 #ifdef notdef
2251                 copym->m_pkthdr.rcvif = ifp;
2252                 ip_input(copym);
2253 #else
2254                 if_simloop(ifp, copym, dst->sin_family, 0);
2255 #endif
2256         }
2257 }