Home | History | Annotate | Line # | Download | only in netinet
ip_output.c revision 1.229
      1  1.229  christos /*	$NetBSD: ip_output.c,v 1.229 2014/05/30 01:39:03 christos Exp $	*/
      2   1.61    itojun 
      3   1.61    itojun /*
      4   1.61    itojun  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
      5   1.61    itojun  * All rights reserved.
      6   1.97    itojun  *
      7   1.61    itojun  * Redistribution and use in source and binary forms, with or without
      8   1.61    itojun  * modification, are permitted provided that the following conditions
      9   1.61    itojun  * are met:
     10   1.61    itojun  * 1. Redistributions of source code must retain the above copyright
     11   1.61    itojun  *    notice, this list of conditions and the following disclaimer.
     12   1.61    itojun  * 2. Redistributions in binary form must reproduce the above copyright
     13   1.61    itojun  *    notice, this list of conditions and the following disclaimer in the
     14   1.61    itojun  *    documentation and/or other materials provided with the distribution.
     15   1.61    itojun  * 3. Neither the name of the project nor the names of its contributors
     16   1.61    itojun  *    may be used to endorse or promote products derived from this software
     17   1.61    itojun  *    without specific prior written permission.
     18   1.97    itojun  *
     19   1.61    itojun  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
     20   1.61    itojun  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     21   1.61    itojun  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     22   1.61    itojun  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
     23   1.61    itojun  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     24   1.61    itojun  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     25   1.61    itojun  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     26   1.61    itojun  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     27   1.61    itojun  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     28   1.61    itojun  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     29   1.61    itojun  * SUCH DAMAGE.
     30   1.61    itojun  */
     31   1.54   thorpej 
     32   1.54   thorpej /*-
     33   1.54   thorpej  * Copyright (c) 1998 The NetBSD Foundation, Inc.
     34   1.54   thorpej  * All rights reserved.
     35   1.54   thorpej  *
     36   1.54   thorpej  * This code is derived from software contributed to The NetBSD Foundation
     37   1.54   thorpej  * by Public Access Networks Corporation ("Panix").  It was developed under
     38   1.54   thorpej  * contract to Panix by Eric Haszlakiewicz and Thor Lancelot Simon.
     39   1.54   thorpej  *
     40   1.54   thorpej  * Redistribution and use in source and binary forms, with or without
     41   1.54   thorpej  * modification, are permitted provided that the following conditions
     42   1.54   thorpej  * are met:
     43   1.54   thorpej  * 1. Redistributions of source code must retain the above copyright
     44   1.54   thorpej  *    notice, this list of conditions and the following disclaimer.
     45   1.54   thorpej  * 2. Redistributions in binary form must reproduce the above copyright
     46   1.54   thorpej  *    notice, this list of conditions and the following disclaimer in the
     47   1.54   thorpej  *    documentation and/or other materials provided with the distribution.
     48   1.54   thorpej  *
     49   1.54   thorpej  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     50   1.54   thorpej  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     51   1.54   thorpej  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     52   1.54   thorpej  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     53   1.54   thorpej  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     54   1.54   thorpej  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     55   1.54   thorpej  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     56   1.54   thorpej  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     57   1.54   thorpej  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     58   1.54   thorpej  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     59   1.54   thorpej  * POSSIBILITY OF SUCH DAMAGE.
     60   1.54   thorpej  */
     61   1.19       cgd 
     62    1.1       cgd /*
     63   1.18   mycroft  * Copyright (c) 1982, 1986, 1988, 1990, 1993
     64   1.18   mycroft  *	The Regents of the University of California.  All rights reserved.
     65    1.1       cgd  *
     66    1.1       cgd  * Redistribution and use in source and binary forms, with or without
     67    1.1       cgd  * modification, are permitted provided that the following conditions
     68    1.1       cgd  * are met:
     69    1.1       cgd  * 1. Redistributions of source code must retain the above copyright
     70    1.1       cgd  *    notice, this list of conditions and the following disclaimer.
     71    1.1       cgd  * 2. Redistributions in binary form must reproduce the above copyright
     72    1.1       cgd  *    notice, this list of conditions and the following disclaimer in the
     73    1.1       cgd  *    documentation and/or other materials provided with the distribution.
     74  1.108       agc  * 3. Neither the name of the University nor the names of its contributors
     75    1.1       cgd  *    may be used to endorse or promote products derived from this software
     76    1.1       cgd  *    without specific prior written permission.
     77    1.1       cgd  *
     78    1.1       cgd  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     79    1.1       cgd  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     80    1.1       cgd  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     81    1.1       cgd  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     82    1.1       cgd  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     83    1.1       cgd  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     84    1.1       cgd  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     85    1.1       cgd  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     86    1.1       cgd  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     87    1.1       cgd  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     88    1.1       cgd  * SUCH DAMAGE.
     89    1.1       cgd  *
     90   1.19       cgd  *	@(#)ip_output.c	8.3 (Berkeley) 1/21/94
     91    1.1       cgd  */
     92   1.89     lukem 
     93   1.89     lukem #include <sys/cdefs.h>
     94  1.229  christos __KERNEL_RCSID(0, "$NetBSD: ip_output.c,v 1.229 2014/05/30 01:39:03 christos Exp $");
     95   1.42    scottr 
     96  1.128  jonathan #include "opt_inet.h"
     97   1.62   thorpej #include "opt_ipsec.h"
     98   1.42    scottr #include "opt_mrouting.h"
     99    1.1       cgd 
    100    1.8   mycroft #include <sys/param.h>
    101  1.215     rmind #include <sys/kmem.h>
    102    1.8   mycroft #include <sys/mbuf.h>
    103    1.8   mycroft #include <sys/protosw.h>
    104    1.8   mycroft #include <sys/socket.h>
    105    1.8   mycroft #include <sys/socketvar.h>
    106  1.162  christos #include <sys/kauth.h>
    107  1.220  christos #ifdef IPSEC
    108  1.118    itojun #include <sys/domain.h>
    109  1.118    itojun #endif
    110   1.28  christos #include <sys/systm.h>
    111   1.61    itojun 
    112    1.8   mycroft #include <net/if.h>
    113    1.8   mycroft #include <net/route.h>
    114   1.38       mrg #include <net/pfil.h>
    115    1.1       cgd 
    116    1.8   mycroft #include <netinet/in.h>
    117    1.8   mycroft #include <netinet/in_systm.h>
    118    1.8   mycroft #include <netinet/ip.h>
    119    1.8   mycroft #include <netinet/in_pcb.h>
    120    1.8   mycroft #include <netinet/in_var.h>
    121    1.8   mycroft #include <netinet/ip_var.h>
    122  1.194   thorpej #include <netinet/ip_private.h>
    123  1.152      yamt #include <netinet/in_offload.h>
    124  1.217  christos #include <netinet/portalgo.h>
    125  1.219  christos #include <netinet/udp.h>
    126   1.72  jdolecek 
    127   1.72  jdolecek #ifdef MROUTING
    128   1.72  jdolecek #include <netinet/ip_mroute.h>
    129   1.72  jdolecek #endif
    130   1.32       mrg 
    131  1.109  jonathan #include <netipsec/ipsec.h>
    132  1.109  jonathan #include <netipsec/key.h>
    133  1.160  christos 
    134  1.226     rmind static int ip_pcbopts(struct inpcb *, const struct sockopt *);
    135  1.139     perry static struct mbuf *ip_insertoptions(struct mbuf *, struct mbuf *, int *);
    136  1.139     perry static struct ifnet *ip_multicast_if(struct in_addr *, int *);
    137  1.180    dyoung static void ip_mloopback(struct ifnet *, struct mbuf *,
    138  1.180    dyoung     const struct sockaddr_in *);
    139  1.226     rmind static int ip_setmoptions(struct inpcb *, const struct sockopt *);
    140  1.226     rmind static int ip_getmoptions(struct inpcb *, struct sockopt *);
    141    1.1       cgd 
    142  1.224     rmind extern pfil_head_t *inet_pfil_hook;			/* XXX */
    143   1.78   thorpej 
    144  1.151      yamt int	ip_do_loopback_cksum = 0;
    145  1.151      yamt 
    146    1.1       cgd /*
    147    1.1       cgd  * IP output.  The packet in mbuf chain m contains a skeletal IP
    148    1.1       cgd  * header (with len, off, ttl, proto, tos, src, dst).
    149    1.1       cgd  * The mbuf chain containing the packet will be freed.
    150    1.1       cgd  * The mbuf opt, if present, will not be freed.
    151    1.1       cgd  */
    152   1.12   mycroft int
    153   1.28  christos ip_output(struct mbuf *m0, ...)
    154    1.1       cgd {
    155  1.186    dyoung 	struct rtentry *rt;
    156  1.110    itojun 	struct ip *ip;
    157   1.71  augustss 	struct ifnet *ifp;
    158   1.71  augustss 	struct mbuf *m = m0;
    159   1.71  augustss 	int hlen = sizeof (struct ip);
    160  1.110    itojun 	int len, error = 0;
    161    1.1       cgd 	struct route iproute;
    162  1.180    dyoung 	const struct sockaddr_in *dst;
    163    1.1       cgd 	struct in_ifaddr *ia;
    164  1.166    dyoung 	struct ifaddr *xifa;
    165   1.28  christos 	struct mbuf *opt;
    166   1.28  christos 	struct route *ro;
    167  1.226     rmind 	int flags, sw_csum;
    168   1.96    itojun 	u_long mtu;
    169   1.28  christos 	struct ip_moptions *imo;
    170  1.116    itojun 	struct socket *so;
    171   1.28  christos 	va_list ap;
    172  1.229  christos #ifdef IPSEC
    173  1.109  jonathan 	struct secpolicy *sp = NULL;
    174  1.229  christos #endif
    175  1.221     rmind 	bool natt_frag = false;
    176  1.221     rmind 	bool __unused done = false;
    177  1.180    dyoung 	union {
    178  1.180    dyoung 		struct sockaddr		dst;
    179  1.180    dyoung 		struct sockaddr_in	dst4;
    180  1.180    dyoung 	} u;
    181  1.180    dyoung 	struct sockaddr *rdst = &u.dst;	/* real IP destination, as opposed
    182  1.180    dyoung 					 * to the nexthop
    183  1.180    dyoung 					 */
    184   1.28  christos 
    185  1.102   darrenr 	len = 0;
    186   1.28  christos 	va_start(ap, m0);
    187   1.28  christos 	opt = va_arg(ap, struct mbuf *);
    188   1.28  christos 	ro = va_arg(ap, struct route *);
    189   1.28  christos 	flags = va_arg(ap, int);
    190   1.28  christos 	imo = va_arg(ap, struct ip_moptions *);
    191  1.116    itojun 	so = va_arg(ap, struct socket *);
    192   1.28  christos 	va_end(ap);
    193   1.28  christos 
    194  1.103      matt 	MCLAIM(m, &ip_tx_mowner);
    195   1.61    itojun 
    196  1.226     rmind 	KASSERT((m->m_flags & M_PKTHDR) != 0);
    197  1.226     rmind 	KASSERT((m->m_pkthdr.csum_flags & (M_CSUM_TCPv6|M_CSUM_UDPv6)) == 0);
    198  1.226     rmind 	KASSERT((m->m_pkthdr.csum_flags & (M_CSUM_TCPv4|M_CSUM_UDPv4)) !=
    199  1.226     rmind 	    (M_CSUM_TCPv4|M_CSUM_UDPv4));
    200  1.163      tron 
    201    1.1       cgd 	if (opt) {
    202    1.1       cgd 		m = ip_insertoptions(m, opt, &len);
    203  1.102   darrenr 		if (len >= sizeof(struct ip))
    204  1.102   darrenr 			hlen = len;
    205    1.1       cgd 	}
    206    1.1       cgd 	ip = mtod(m, struct ip *);
    207  1.226     rmind 
    208    1.1       cgd 	/*
    209    1.1       cgd 	 * Fill in IP header.
    210    1.1       cgd 	 */
    211   1.18   mycroft 	if ((flags & (IP_FORWARDING|IP_RAWOUTPUT)) == 0) {
    212    1.1       cgd 		ip->ip_v = IPVERSION;
    213  1.100    itojun 		ip->ip_off = htons(0);
    214  1.192      matt 		/* ip->ip_id filled in after we find out source ia */
    215    1.1       cgd 		ip->ip_hl = hlen >> 2;
    216  1.194   thorpej 		IP_STATINC(IP_STAT_LOCALOUT);
    217    1.1       cgd 	} else {
    218    1.1       cgd 		hlen = ip->ip_hl << 2;
    219    1.1       cgd 	}
    220  1.226     rmind 
    221    1.1       cgd 	/*
    222    1.1       cgd 	 * Route packet.
    223    1.1       cgd 	 */
    224  1.176    dyoung 	memset(&iproute, 0, sizeof(iproute));
    225  1.174     joerg 	if (ro == NULL)
    226    1.1       cgd 		ro = &iproute;
    227  1.180    dyoung 	sockaddr_in_init(&u.dst4, &ip->ip_dst, 0);
    228  1.180    dyoung 	dst = satocsin(rtcache_getdst(ro));
    229  1.226     rmind 
    230    1.1       cgd 	/*
    231  1.226     rmind 	 * If there is a cached route, check that it is to the same
    232  1.226     rmind 	 * destination and is still up.  If not, free it and try again.
    233  1.226     rmind 	 * The address family should also be checked in case of sharing
    234  1.226     rmind 	 * the cache with IPv6.
    235    1.1       cgd 	 */
    236  1.226     rmind 	if (dst && (dst->sin_family != AF_INET ||
    237  1.226     rmind 	    !in_hosteq(dst->sin_addr, ip->ip_dst)))
    238  1.171     joerg 		rtcache_free(ro);
    239  1.190    dyoung 
    240  1.190    dyoung 	if ((rt = rtcache_validate(ro)) == NULL &&
    241  1.190    dyoung 	    (rt = rtcache_update(ro, 1)) == NULL) {
    242  1.180    dyoung 		dst = &u.dst4;
    243  1.180    dyoung 		rtcache_setdst(ro, &u.dst);
    244    1.1       cgd 	}
    245  1.226     rmind 
    246    1.1       cgd 	/*
    247  1.226     rmind 	 * If routing to interface only, short circuit routing lookup.
    248    1.1       cgd 	 */
    249    1.1       cgd 	if (flags & IP_ROUTETOIF) {
    250  1.180    dyoung 		if ((ia = ifatoia(ifa_ifwithladdr(sintocsa(dst)))) == NULL) {
    251  1.194   thorpej 			IP_STATINC(IP_STAT_NOROUTE);
    252    1.1       cgd 			error = ENETUNREACH;
    253    1.1       cgd 			goto bad;
    254    1.1       cgd 		}
    255    1.1       cgd 		ifp = ia->ia_ifp;
    256   1.48      matt 		mtu = ifp->if_mtu;
    257   1.18   mycroft 		ip->ip_ttl = 1;
    258   1.98    itojun 	} else if ((IN_MULTICAST(ip->ip_dst.s_addr) ||
    259   1.98    itojun 	    ip->ip_dst.s_addr == INADDR_BROADCAST) &&
    260   1.98    itojun 	    imo != NULL && imo->imo_multicast_ifp != NULL) {
    261   1.98    itojun 		ifp = imo->imo_multicast_ifp;
    262   1.98    itojun 		mtu = ifp->if_mtu;
    263   1.99    itojun 		IFP_TO_IA(ifp, ia);
    264    1.1       cgd 	} else {
    265  1.186    dyoung 		if (rt == NULL)
    266  1.190    dyoung 			rt = rtcache_init(ro);
    267  1.190    dyoung 		if (rt == NULL) {
    268  1.194   thorpej 			IP_STATINC(IP_STAT_NOROUTE);
    269    1.1       cgd 			error = EHOSTUNREACH;
    270    1.1       cgd 			goto bad;
    271    1.1       cgd 		}
    272  1.186    dyoung 		ia = ifatoia(rt->rt_ifa);
    273  1.186    dyoung 		ifp = rt->rt_ifp;
    274  1.186    dyoung 		if ((mtu = rt->rt_rmx.rmx_mtu) == 0)
    275   1.48      matt 			mtu = ifp->if_mtu;
    276  1.186    dyoung 		rt->rt_use++;
    277  1.186    dyoung 		if (rt->rt_flags & RTF_GATEWAY)
    278  1.186    dyoung 			dst = satosin(rt->rt_gateway);
    279    1.1       cgd 	}
    280  1.226     rmind 
    281   1.64        is 	if (IN_MULTICAST(ip->ip_dst.s_addr) ||
    282   1.64        is 	    (ip->ip_dst.s_addr == INADDR_BROADCAST)) {
    283  1.228     rmind 		bool inmgroup;
    284    1.5   hpeyerl 
    285   1.64        is 		m->m_flags |= (ip->ip_dst.s_addr == INADDR_BROADCAST) ?
    286   1.64        is 			M_BCAST : M_MCAST;
    287    1.5   hpeyerl 		/*
    288    1.5   hpeyerl 		 * See if the caller provided any multicast options
    289    1.5   hpeyerl 		 */
    290   1.98    itojun 		if (imo != NULL)
    291    1.5   hpeyerl 			ip->ip_ttl = imo->imo_multicast_ttl;
    292   1.98    itojun 		else
    293    1.5   hpeyerl 			ip->ip_ttl = IP_DEFAULT_MULTICAST_TTL;
    294   1.98    itojun 
    295   1.98    itojun 		/*
    296   1.98    itojun 		 * if we don't know the outgoing ifp yet, we can't generate
    297   1.98    itojun 		 * output
    298   1.98    itojun 		 */
    299   1.98    itojun 		if (!ifp) {
    300  1.194   thorpej 			IP_STATINC(IP_STAT_NOROUTE);
    301   1.98    itojun 			error = ENETUNREACH;
    302   1.98    itojun 			goto bad;
    303   1.98    itojun 		}
    304   1.98    itojun 
    305    1.5   hpeyerl 		/*
    306   1.95   thorpej 		 * If the packet is multicast or broadcast, confirm that
    307   1.95   thorpej 		 * the outgoing interface can transmit it.
    308    1.5   hpeyerl 		 */
    309   1.64        is 		if (((m->m_flags & M_MCAST) &&
    310   1.64        is 		     (ifp->if_flags & IFF_MULTICAST) == 0) ||
    311   1.97    itojun 		    ((m->m_flags & M_BCAST) &&
    312   1.95   thorpej 		     (ifp->if_flags & (IFF_BROADCAST|IFF_POINTOPOINT)) == 0))  {
    313  1.194   thorpej 			IP_STATINC(IP_STAT_NOROUTE);
    314    1.5   hpeyerl 			error = ENETUNREACH;
    315    1.5   hpeyerl 			goto bad;
    316    1.5   hpeyerl 		}
    317    1.5   hpeyerl 		/*
    318   1.44       tls 		 * If source address not specified yet, use an address
    319    1.5   hpeyerl 		 * of outgoing interface.
    320    1.5   hpeyerl 		 */
    321   1.31   mycroft 		if (in_nullhost(ip->ip_src)) {
    322  1.153  christos 			struct in_ifaddr *xia;
    323    1.5   hpeyerl 
    324  1.153  christos 			IFP_TO_IA(ifp, xia);
    325  1.153  christos 			if (!xia) {
    326   1.91    itojun 				error = EADDRNOTAVAIL;
    327   1.91    itojun 				goto bad;
    328   1.91    itojun 			}
    329  1.166    dyoung 			xifa = &xia->ia_ifa;
    330  1.166    dyoung 			if (xifa->ifa_getifa != NULL) {
    331  1.180    dyoung 				xia = ifatoia((*xifa->ifa_getifa)(xifa, rdst));
    332  1.166    dyoung 			}
    333  1.153  christos 			ip->ip_src = xia->ia_addr.sin_addr;
    334    1.5   hpeyerl 		}
    335    1.5   hpeyerl 
    336  1.228     rmind 		inmgroup = in_multi_group(ip->ip_dst, ifp, flags);
    337  1.228     rmind 		if (inmgroup && (imo == NULL || imo->imo_multicast_loop)) {
    338    1.5   hpeyerl 			/*
    339   1.11   mycroft 			 * If we belong to the destination multicast group
    340    1.5   hpeyerl 			 * on the outgoing interface, and the caller did not
    341    1.5   hpeyerl 			 * forbid loopback, loop back a copy.
    342    1.5   hpeyerl 			 */
    343  1.180    dyoung 			ip_mloopback(ifp, m, &u.dst4);
    344    1.5   hpeyerl 		}
    345    1.5   hpeyerl #ifdef MROUTING
    346   1.18   mycroft 		else {
    347    1.5   hpeyerl 			/*
    348    1.5   hpeyerl 			 * If we are acting as a multicast router, perform
    349    1.5   hpeyerl 			 * multicast forwarding as if the packet had just
    350    1.5   hpeyerl 			 * arrived on the interface to which we are about
    351    1.5   hpeyerl 			 * to send.  The multicast forwarding function
    352    1.5   hpeyerl 			 * recursively calls this function, using the
    353    1.5   hpeyerl 			 * IP_FORWARDING flag to prevent infinite recursion.
    354    1.5   hpeyerl 			 *
    355    1.5   hpeyerl 			 * Multicasts that are looped back by ip_mloopback(),
    356    1.5   hpeyerl 			 * above, will be forwarded by the ip_input() routine,
    357    1.5   hpeyerl 			 * if necessary.
    358    1.5   hpeyerl 			 */
    359   1.18   mycroft 			extern struct socket *ip_mrouter;
    360   1.22       cgd 
    361   1.18   mycroft 			if (ip_mrouter && (flags & IP_FORWARDING) == 0) {
    362   1.18   mycroft 				if (ip_mforward(m, ifp) != 0) {
    363   1.18   mycroft 					m_freem(m);
    364   1.18   mycroft 					goto done;
    365   1.18   mycroft 				}
    366    1.5   hpeyerl 			}
    367    1.5   hpeyerl 		}
    368    1.5   hpeyerl #endif
    369    1.5   hpeyerl 		/*
    370    1.5   hpeyerl 		 * Multicasts with a time-to-live of zero may be looped-
    371    1.5   hpeyerl 		 * back, above, but must not be transmitted on a network.
    372    1.5   hpeyerl 		 * Also, multicasts addressed to the loopback interface
    373    1.5   hpeyerl 		 * are not sent -- the above call to ip_mloopback() will
    374    1.5   hpeyerl 		 * loop back a copy if this host actually belongs to the
    375    1.5   hpeyerl 		 * destination group on the loopback interface.
    376    1.5   hpeyerl 		 */
    377   1.20   mycroft 		if (ip->ip_ttl == 0 || (ifp->if_flags & IFF_LOOPBACK) != 0) {
    378    1.5   hpeyerl 			m_freem(m);
    379    1.5   hpeyerl 			goto done;
    380    1.5   hpeyerl 		}
    381    1.5   hpeyerl 
    382    1.5   hpeyerl 		goto sendit;
    383    1.5   hpeyerl 	}
    384    1.1       cgd 	/*
    385    1.1       cgd 	 * If source address not specified yet, use address
    386    1.1       cgd 	 * of outgoing interface.
    387    1.1       cgd 	 */
    388  1.166    dyoung 	if (in_nullhost(ip->ip_src)) {
    389  1.166    dyoung 		xifa = &ia->ia_ifa;
    390  1.166    dyoung 		if (xifa->ifa_getifa != NULL)
    391  1.180    dyoung 			ia = ifatoia((*xifa->ifa_getifa)(xifa, rdst));
    392   1.25   mycroft 		ip->ip_src = ia->ia_addr.sin_addr;
    393  1.166    dyoung 	}
    394   1.59       hwr 
    395   1.59       hwr 	/*
    396   1.97    itojun 	 * packets with Class-D address as source are not valid per
    397   1.59       hwr 	 * RFC 1112
    398   1.59       hwr 	 */
    399   1.59       hwr 	if (IN_MULTICAST(ip->ip_src.s_addr)) {
    400  1.194   thorpej 		IP_STATINC(IP_STAT_ODROPPED);
    401   1.59       hwr 		error = EADDRNOTAVAIL;
    402   1.59       hwr 		goto bad;
    403   1.59       hwr 	}
    404   1.59       hwr 
    405    1.1       cgd 	/*
    406    1.1       cgd 	 * Look for broadcast address and
    407    1.1       cgd 	 * and verify user is allowed to send
    408    1.1       cgd 	 * such a packet.
    409    1.1       cgd 	 */
    410   1.18   mycroft 	if (in_broadcast(dst->sin_addr, ifp)) {
    411    1.1       cgd 		if ((ifp->if_flags & IFF_BROADCAST) == 0) {
    412    1.1       cgd 			error = EADDRNOTAVAIL;
    413    1.1       cgd 			goto bad;
    414    1.1       cgd 		}
    415    1.1       cgd 		if ((flags & IP_ALLOWBROADCAST) == 0) {
    416    1.1       cgd 			error = EACCES;
    417    1.1       cgd 			goto bad;
    418    1.1       cgd 		}
    419    1.1       cgd 		/* don't allow broadcast messages to be fragmented */
    420  1.100    itojun 		if (ntohs(ip->ip_len) > ifp->if_mtu) {
    421    1.1       cgd 			error = EMSGSIZE;
    422    1.1       cgd 			goto bad;
    423    1.1       cgd 		}
    424    1.1       cgd 		m->m_flags |= M_BCAST;
    425   1.18   mycroft 	} else
    426   1.18   mycroft 		m->m_flags &= ~M_BCAST;
    427   1.18   mycroft 
    428   1.60       mrg sendit:
    429  1.192      matt 	if ((flags & (IP_FORWARDING|IP_NOIPNEWID)) == 0) {
    430  1.192      matt 		if (m->m_pkthdr.len < IP_MINFRAGSIZE) {
    431  1.192      matt 			ip->ip_id = 0;
    432  1.192      matt 		} else if ((m->m_pkthdr.csum_flags & M_CSUM_TSOv4) == 0) {
    433  1.192      matt 			ip->ip_id = ip_newid(ia);
    434  1.192      matt 		} else {
    435  1.192      matt 
    436  1.192      matt 			/*
    437  1.192      matt 			 * TSO capable interfaces (typically?) increment
    438  1.192      matt 			 * ip_id for each segment.
    439  1.192      matt 			 * "allocate" enough ids here to increase the chance
    440  1.192      matt 			 * for them to be unique.
    441  1.192      matt 			 *
    442  1.192      matt 			 * note that the following calculation is not
    443  1.192      matt 			 * needed to be precise.  wasting some ip_id is fine.
    444  1.192      matt 			 */
    445  1.192      matt 
    446  1.192      matt 			unsigned int segsz = m->m_pkthdr.segsz;
    447  1.192      matt 			unsigned int datasz = ntohs(ip->ip_len) - hlen;
    448  1.192      matt 			unsigned int num = howmany(datasz, segsz);
    449  1.192      matt 
    450  1.192      matt 			ip->ip_id = ip_newid_range(ia, num);
    451  1.192      matt 		}
    452  1.192      matt 	}
    453   1.76   thorpej 	/*
    454   1.76   thorpej 	 * If we're doing Path MTU Discovery, we need to set DF unless
    455   1.76   thorpej 	 * the route's MTU is locked.
    456   1.76   thorpej 	 */
    457  1.186    dyoung 	if ((flags & IP_MTUDISC) != 0 && rt != NULL &&
    458  1.186    dyoung 	    (rt->rt_rmx.rmx_locks & RTV_MTU) == 0)
    459  1.100    itojun 		ip->ip_off |= htons(IP_DF);
    460   1.76   thorpej 
    461  1.220  christos #ifdef IPSEC
    462  1.229  christos 	if (ipsec_used) {
    463  1.229  christos 		/* Perform IPsec processing, if any. */
    464  1.229  christos 		error = ipsec4_output(m, so, flags, &sp, &mtu, &natt_frag,
    465  1.229  christos 		    &done);
    466  1.229  christos 		if (error || done)
    467  1.229  christos 			goto done;
    468  1.221     rmind 	}
    469  1.109  jonathan #endif
    470  1.109  jonathan 
    471   1.82    itojun 	/*
    472   1.82    itojun 	 * Run through list of hooks for output packets.
    473   1.82    itojun 	 */
    474  1.224     rmind 	if ((error = pfil_run_hooks(inet_pfil_hook, &m, ifp, PFIL_OUT)) != 0)
    475   1.82    itojun 		goto done;
    476   1.82    itojun 	if (m == NULL)
    477   1.82    itojun 		goto done;
    478   1.82    itojun 
    479   1.82    itojun 	ip = mtod(m, struct ip *);
    480  1.106    itojun 	hlen = ip->ip_hl << 2;
    481   1.82    itojun 
    482  1.146      matt 	m->m_pkthdr.csum_data |= hlen << 16;
    483  1.146      matt 
    484  1.136   thorpej #if IFA_STATS
    485  1.136   thorpej 	/*
    486  1.136   thorpej 	 * search for the source address structure to
    487  1.136   thorpej 	 * maintain output statistics.
    488  1.136   thorpej 	 */
    489  1.136   thorpej 	INADDR_TO_IA(ip->ip_src, ia);
    490  1.136   thorpej #endif
    491  1.136   thorpej 
    492  1.138   thorpej 	/* Maybe skip checksums on loopback interfaces. */
    493  1.151      yamt 	if (IN_NEED_CHECKSUM(ifp, M_CSUM_IPv4)) {
    494  1.138   thorpej 		m->m_pkthdr.csum_flags |= M_CSUM_IPv4;
    495  1.151      yamt 	}
    496  1.104      yamt 	sw_csum = m->m_pkthdr.csum_flags & ~ifp->if_csum_flags_tx;
    497    1.1       cgd 	/*
    498  1.147      matt 	 * If small enough for mtu of path, or if using TCP segmentation
    499  1.147      matt 	 * offload, can just send directly.
    500    1.1       cgd 	 */
    501  1.218    kefren 	if (ntohs(ip->ip_len) <= mtu ||
    502  1.147      matt 	    (m->m_pkthdr.csum_flags & M_CSUM_TSOv4) != 0) {
    503   1.63    itojun #if IFA_STATS
    504   1.63    itojun 		if (ia)
    505  1.218    kefren 			ia->ia_ifa.ifa_data.ifad_outbytes += ntohs(ip->ip_len);
    506   1.63    itojun #endif
    507   1.86   thorpej 		/*
    508   1.86   thorpej 		 * Always initialize the sum to 0!  Some HW assisted
    509   1.86   thorpej 		 * checksumming requires this.
    510   1.86   thorpej 		 */
    511    1.1       cgd 		ip->ip_sum = 0;
    512   1.86   thorpej 
    513  1.149      matt 		if ((m->m_pkthdr.csum_flags & M_CSUM_TSOv4) == 0) {
    514  1.147      matt 			/*
    515  1.147      matt 			 * Perform any checksums that the hardware can't do
    516  1.147      matt 			 * for us.
    517  1.147      matt 			 *
    518  1.147      matt 			 * XXX Does any hardware require the {th,uh}_sum
    519  1.147      matt 			 * XXX fields to be 0?
    520  1.147      matt 			 */
    521  1.147      matt 			if (sw_csum & M_CSUM_IPv4) {
    522  1.151      yamt 				KASSERT(IN_NEED_CHECKSUM(ifp, M_CSUM_IPv4));
    523  1.147      matt 				ip->ip_sum = in_cksum(m, hlen);
    524  1.147      matt 				m->m_pkthdr.csum_flags &= ~M_CSUM_IPv4;
    525  1.147      matt 			}
    526  1.147      matt 			if (sw_csum & (M_CSUM_TCPv4|M_CSUM_UDPv4)) {
    527  1.151      yamt 				if (IN_NEED_CHECKSUM(ifp,
    528  1.151      yamt 				    sw_csum & (M_CSUM_TCPv4|M_CSUM_UDPv4))) {
    529  1.151      yamt 					in_delayed_cksum(m);
    530  1.151      yamt 				}
    531  1.147      matt 				m->m_pkthdr.csum_flags &=
    532  1.147      matt 				    ~(M_CSUM_TCPv4|M_CSUM_UDPv4);
    533  1.147      matt 			}
    534  1.146      matt 		}
    535   1.86   thorpej 
    536  1.152      yamt 		if (__predict_true(
    537  1.152      yamt 		    (m->m_pkthdr.csum_flags & M_CSUM_TSOv4) == 0 ||
    538  1.152      yamt 		    (ifp->if_capenable & IFCAP_TSOv4) != 0)) {
    539  1.208      yamt 			KERNEL_LOCK(1, NULL);
    540  1.152      yamt 			error =
    541  1.181      cube 			    (*ifp->if_output)(ifp, m,
    542  1.181      cube 				(m->m_flags & M_MCAST) ?
    543  1.181      cube 				    sintocsa(rdst) : sintocsa(dst),
    544  1.186    dyoung 				rt);
    545  1.208      yamt 			KERNEL_UNLOCK_ONE(NULL);
    546  1.152      yamt 		} else {
    547  1.152      yamt 			error =
    548  1.181      cube 			    ip_tso_output(ifp, m,
    549  1.181      cube 				(m->m_flags & M_MCAST) ?
    550  1.181      cube 				    sintocsa(rdst) : sintocsa(dst),
    551  1.186    dyoung 				rt);
    552  1.152      yamt 		}
    553    1.1       cgd 		goto done;
    554    1.1       cgd 	}
    555   1.61    itojun 
    556    1.1       cgd 	/*
    557   1.86   thorpej 	 * We can't use HW checksumming if we're about to
    558   1.86   thorpej 	 * to fragment the packet.
    559   1.86   thorpej 	 *
    560   1.86   thorpej 	 * XXX Some hardware can do this.
    561   1.86   thorpej 	 */
    562   1.86   thorpej 	if (m->m_pkthdr.csum_flags & (M_CSUM_TCPv4|M_CSUM_UDPv4)) {
    563  1.151      yamt 		if (IN_NEED_CHECKSUM(ifp,
    564  1.151      yamt 		    m->m_pkthdr.csum_flags & (M_CSUM_TCPv4|M_CSUM_UDPv4))) {
    565  1.151      yamt 			in_delayed_cksum(m);
    566  1.151      yamt 		}
    567   1.86   thorpej 		m->m_pkthdr.csum_flags &= ~(M_CSUM_TCPv4|M_CSUM_UDPv4);
    568   1.86   thorpej 	}
    569   1.86   thorpej 
    570   1.86   thorpej 	/*
    571    1.1       cgd 	 * Too large for interface; fragment if possible.
    572    1.1       cgd 	 * Must be able to put at least 8 bytes per fragment.
    573    1.1       cgd 	 */
    574  1.100    itojun 	if (ntohs(ip->ip_off) & IP_DF) {
    575  1.226     rmind 		if (flags & IP_RETURNMTU) {
    576  1.227     rmind 			struct inpcb *inp;
    577  1.227     rmind 
    578  1.227     rmind 			KASSERT(so && solocked(so));
    579  1.227     rmind 			inp = sotoinpcb(so);
    580  1.226     rmind 			inp->inp_errormtu = mtu;
    581  1.226     rmind 		}
    582    1.1       cgd 		error = EMSGSIZE;
    583  1.194   thorpej 		IP_STATINC(IP_STAT_CANTFRAG);
    584    1.1       cgd 		goto bad;
    585    1.1       cgd 	}
    586  1.110    itojun 
    587  1.110    itojun 	error = ip_fragment(m, ifp, mtu);
    588  1.124    itojun 	if (error) {
    589  1.124    itojun 		m = NULL;
    590    1.1       cgd 		goto bad;
    591  1.124    itojun 	}
    592  1.110    itojun 
    593  1.119    itojun 	for (; m; m = m0) {
    594  1.110    itojun 		m0 = m->m_nextpkt;
    595  1.110    itojun 		m->m_nextpkt = 0;
    596  1.110    itojun 		if (error == 0) {
    597  1.110    itojun #if IFA_STATS
    598  1.136   thorpej 			if (ia)
    599  1.110    itojun 				ia->ia_ifa.ifa_data.ifad_outbytes +=
    600  1.110    itojun 				    ntohs(ip->ip_len);
    601  1.110    itojun #endif
    602  1.144     perry 			/*
    603  1.219  christos 			 * If we get there, the packet has not been handled by
    604  1.222     rmind 			 * IPsec whereas it should have. Now that it has been
    605  1.141      manu 			 * fragmented, re-inject it in ip_output so that IPsec
    606  1.141      manu 			 * processing can occur.
    607  1.141      manu 			 */
    608  1.141      manu 			if (natt_frag) {
    609  1.219  christos 				error = ip_output(m, opt, ro,
    610  1.219  christos 				    flags | IP_RAWOUTPUT | IP_NOIPNEWID,
    611  1.226     rmind 				    imo, so);
    612  1.219  christos 			} else {
    613  1.141      manu 				KASSERT((m->m_pkthdr.csum_flags &
    614  1.141      manu 				    (M_CSUM_UDPv4 | M_CSUM_TCPv4)) == 0);
    615  1.208      yamt 				KERNEL_LOCK(1, NULL);
    616  1.181      cube 				error = (*ifp->if_output)(ifp, m,
    617  1.181      cube 				    (m->m_flags & M_MCAST) ?
    618  1.226     rmind 				    sintocsa(rdst) : sintocsa(dst), rt);
    619  1.208      yamt 				KERNEL_UNLOCK_ONE(NULL);
    620  1.141      manu 			}
    621  1.110    itojun 		} else
    622  1.110    itojun 			m_freem(m);
    623    1.1       cgd 	}
    624    1.1       cgd 
    625  1.110    itojun 	if (error == 0)
    626  1.194   thorpej 		IP_STATINC(IP_STAT_FRAGMENTED);
    627  1.110    itojun done:
    628  1.174     joerg 	rtcache_free(&iproute);
    629  1.229  christos #ifdef IPSEC
    630  1.221     rmind 	if (sp) {
    631  1.110    itojun 		KEY_FREESP(&sp);
    632  1.229  christos 	}
    633  1.221     rmind #endif
    634  1.221     rmind 	return error;
    635  1.110    itojun bad:
    636  1.110    itojun 	m_freem(m);
    637  1.110    itojun 	goto done;
    638  1.110    itojun }
    639  1.110    itojun 
    640  1.113    itojun int
    641  1.110    itojun ip_fragment(struct mbuf *m, struct ifnet *ifp, u_long mtu)
    642  1.110    itojun {
    643  1.110    itojun 	struct ip *ip, *mhip;
    644  1.110    itojun 	struct mbuf *m0;
    645  1.110    itojun 	int len, hlen, off;
    646  1.110    itojun 	int mhlen, firstlen;
    647  1.110    itojun 	struct mbuf **mnext;
    648  1.135      manu 	int sw_csum = m->m_pkthdr.csum_flags;
    649   1.48      matt 	int fragments = 0;
    650   1.48      matt 	int s;
    651  1.110    itojun 	int error = 0;
    652  1.110    itojun 
    653  1.110    itojun 	ip = mtod(m, struct ip *);
    654  1.110    itojun 	hlen = ip->ip_hl << 2;
    655  1.135      manu 	if (ifp != NULL)
    656  1.135      manu 		sw_csum &= ~ifp->if_csum_flags_tx;
    657  1.110    itojun 
    658  1.110    itojun 	len = (mtu - hlen) &~ 7;
    659  1.124    itojun 	if (len < 8) {
    660  1.124    itojun 		m_freem(m);
    661  1.110    itojun 		return (EMSGSIZE);
    662  1.124    itojun 	}
    663  1.110    itojun 
    664  1.110    itojun 	firstlen = len;
    665  1.110    itojun 	mnext = &m->m_nextpkt;
    666    1.1       cgd 
    667    1.1       cgd 	/*
    668    1.1       cgd 	 * Loop through length of segment after first fragment,
    669    1.1       cgd 	 * make new header and copy data of each part and link onto chain.
    670    1.1       cgd 	 */
    671    1.1       cgd 	m0 = m;
    672    1.1       cgd 	mhlen = sizeof (struct ip);
    673  1.100    itojun 	for (off = hlen + len; off < ntohs(ip->ip_len); off += len) {
    674    1.1       cgd 		MGETHDR(m, M_DONTWAIT, MT_HEADER);
    675    1.1       cgd 		if (m == 0) {
    676    1.1       cgd 			error = ENOBUFS;
    677  1.194   thorpej 			IP_STATINC(IP_STAT_ODROPPED);
    678    1.1       cgd 			goto sendorfree;
    679    1.1       cgd 		}
    680  1.103      matt 		MCLAIM(m, m0->m_owner);
    681   1.22       cgd 		*mnext = m;
    682   1.22       cgd 		mnext = &m->m_nextpkt;
    683    1.1       cgd 		m->m_data += max_linkhdr;
    684    1.1       cgd 		mhip = mtod(m, struct ip *);
    685    1.1       cgd 		*mhip = *ip;
    686   1.73        is 		/* we must inherit MCAST and BCAST flags */
    687   1.73        is 		m->m_flags |= m0->m_flags & (M_MCAST|M_BCAST);
    688    1.1       cgd 		if (hlen > sizeof (struct ip)) {
    689    1.1       cgd 			mhlen = ip_optcopy(ip, mhip) + sizeof (struct ip);
    690    1.1       cgd 			mhip->ip_hl = mhlen >> 2;
    691    1.1       cgd 		}
    692    1.1       cgd 		m->m_len = mhlen;
    693  1.122    itojun 		mhip->ip_off = ((off - hlen) >> 3) +
    694  1.122    itojun 		    (ntohs(ip->ip_off) & ~IP_MF);
    695  1.122    itojun 		if (ip->ip_off & htons(IP_MF))
    696    1.1       cgd 			mhip->ip_off |= IP_MF;
    697  1.100    itojun 		if (off + len >= ntohs(ip->ip_len))
    698  1.100    itojun 			len = ntohs(ip->ip_len) - off;
    699    1.1       cgd 		else
    700    1.1       cgd 			mhip->ip_off |= IP_MF;
    701  1.100    itojun 		HTONS(mhip->ip_off);
    702   1.21       cgd 		mhip->ip_len = htons((u_int16_t)(len + mhlen));
    703  1.182    dyoung 		m->m_next = m_copym(m0, off, len, M_DONTWAIT);
    704    1.1       cgd 		if (m->m_next == 0) {
    705    1.1       cgd 			error = ENOBUFS;	/* ??? */
    706  1.194   thorpej 			IP_STATINC(IP_STAT_ODROPPED);
    707    1.1       cgd 			goto sendorfree;
    708    1.1       cgd 		}
    709    1.1       cgd 		m->m_pkthdr.len = mhlen + len;
    710  1.212  christos 		m->m_pkthdr.rcvif = NULL;
    711    1.1       cgd 		mhip->ip_sum = 0;
    712  1.210      yamt 		KASSERT((m->m_pkthdr.csum_flags & M_CSUM_IPv4) == 0);
    713  1.104      yamt 		if (sw_csum & M_CSUM_IPv4) {
    714  1.104      yamt 			mhip->ip_sum = in_cksum(m, mhlen);
    715  1.104      yamt 		} else {
    716  1.210      yamt 			/*
    717  1.210      yamt 			 * checksum is hw-offloaded or not necessary.
    718  1.210      yamt 			 */
    719  1.210      yamt 			m->m_pkthdr.csum_flags |=
    720  1.210      yamt 			    m0->m_pkthdr.csum_flags & M_CSUM_IPv4;
    721  1.148   thorpej 			m->m_pkthdr.csum_data |= mhlen << 16;
    722  1.210      yamt 			KASSERT(!(ifp != NULL &&
    723  1.210      yamt 			    IN_NEED_CHECKSUM(ifp, M_CSUM_IPv4))
    724  1.210      yamt 			    || (m->m_pkthdr.csum_flags & M_CSUM_IPv4) != 0);
    725  1.104      yamt 		}
    726  1.194   thorpej 		IP_STATINC(IP_STAT_OFRAGMENTS);
    727   1.48      matt 		fragments++;
    728    1.1       cgd 	}
    729    1.1       cgd 	/*
    730    1.1       cgd 	 * Update first fragment by trimming what's been copied out
    731    1.1       cgd 	 * and updating header, then send each fragment (in order).
    732    1.1       cgd 	 */
    733    1.1       cgd 	m = m0;
    734  1.100    itojun 	m_adj(m, hlen + firstlen - ntohs(ip->ip_len));
    735    1.1       cgd 	m->m_pkthdr.len = hlen + firstlen;
    736   1.21       cgd 	ip->ip_len = htons((u_int16_t)m->m_pkthdr.len);
    737  1.100    itojun 	ip->ip_off |= htons(IP_MF);
    738    1.1       cgd 	ip->ip_sum = 0;
    739  1.210      yamt 	if (sw_csum & M_CSUM_IPv4) {
    740  1.210      yamt 		ip->ip_sum = in_cksum(m, hlen);
    741  1.210      yamt 		m->m_pkthdr.csum_flags &= ~M_CSUM_IPv4;
    742  1.210      yamt 	} else {
    743  1.210      yamt 		/*
    744  1.210      yamt 		 * checksum is hw-offloaded or not necessary.
    745  1.210      yamt 		 */
    746  1.210      yamt 		KASSERT(!(ifp != NULL && IN_NEED_CHECKSUM(ifp, M_CSUM_IPv4))
    747  1.210      yamt 		   || (m->m_pkthdr.csum_flags & M_CSUM_IPv4) != 0);
    748  1.210      yamt 		KASSERT(M_CSUM_DATA_IPv4_IPHL(m->m_pkthdr.csum_data) >=
    749  1.210      yamt 			sizeof(struct ip));
    750  1.104      yamt 	}
    751    1.1       cgd sendorfree:
    752   1.48      matt 	/*
    753   1.48      matt 	 * If there is no room for all the fragments, don't queue
    754   1.48      matt 	 * any of them.
    755   1.48      matt 	 */
    756  1.135      manu 	if (ifp != NULL) {
    757  1.135      manu 		s = splnet();
    758  1.135      manu 		if (ifp->if_snd.ifq_maxlen - ifp->if_snd.ifq_len < fragments &&
    759  1.135      manu 		    error == 0) {
    760  1.135      manu 			error = ENOBUFS;
    761  1.194   thorpej 			IP_STATINC(IP_STAT_ODROPPED);
    762  1.135      manu 			IFQ_INC_DROPS(&ifp->if_snd);
    763  1.135      manu 		}
    764  1.135      manu 		splx(s);
    765  1.126     enami 	}
    766  1.124    itojun 	if (error) {
    767  1.125    itojun 		for (m = m0; m; m = m0) {
    768  1.124    itojun 			m0 = m->m_nextpkt;
    769  1.124    itojun 			m->m_nextpkt = NULL;
    770  1.124    itojun 			m_freem(m);
    771  1.124    itojun 		}
    772  1.124    itojun 	}
    773    1.1       cgd 	return (error);
    774   1.86   thorpej }
    775   1.86   thorpej 
    776   1.86   thorpej /*
    777   1.86   thorpej  * Process a delayed payload checksum calculation.
    778   1.86   thorpej  */
    779   1.86   thorpej void
    780   1.86   thorpej in_delayed_cksum(struct mbuf *m)
    781   1.86   thorpej {
    782   1.86   thorpej 	struct ip *ip;
    783   1.86   thorpej 	u_int16_t csum, offset;
    784   1.86   thorpej 
    785   1.86   thorpej 	ip = mtod(m, struct ip *);
    786   1.86   thorpej 	offset = ip->ip_hl << 2;
    787   1.86   thorpej 	csum = in4_cksum(m, 0, offset, ntohs(ip->ip_len) - offset);
    788   1.86   thorpej 	if (csum == 0 && (m->m_pkthdr.csum_flags & M_CSUM_UDPv4) != 0)
    789   1.86   thorpej 		csum = 0xffff;
    790   1.86   thorpej 
    791  1.145    briggs 	offset += M_CSUM_DATA_IPv4_OFFSET(m->m_pkthdr.csum_data);
    792   1.86   thorpej 
    793   1.86   thorpej 	if ((offset + sizeof(u_int16_t)) > m->m_len) {
    794   1.87      yamt 		/* This happen when ip options were inserted
    795   1.86   thorpej 		printf("in_delayed_cksum: pullup len %d off %d proto %d\n",
    796   1.86   thorpej 		    m->m_len, offset, ip->ip_p);
    797   1.87      yamt 		 */
    798  1.179  christos 		m_copyback(m, offset, sizeof(csum), (void *) &csum);
    799   1.86   thorpej 	} else
    800  1.179  christos 		*(u_int16_t *)(mtod(m, char *) + offset) = csum;
    801    1.1       cgd }
    802   1.47       kml 
    803   1.47       kml /*
    804   1.47       kml  * Determine the maximum length of the options to be inserted;
    805   1.47       kml  * we would far rather allocate too much space rather than too little.
    806   1.47       kml  */
    807   1.47       kml 
    808   1.47       kml u_int
    809  1.140     perry ip_optlen(struct inpcb *inp)
    810   1.47       kml {
    811   1.47       kml 	struct mbuf *m = inp->inp_options;
    812   1.47       kml 
    813  1.226     rmind 	if (m && m->m_len > offsetof(struct ipoption, ipopt_dst)) {
    814  1.101    itojun 		return (m->m_len - offsetof(struct ipoption, ipopt_dst));
    815  1.226     rmind 	}
    816  1.226     rmind 	return 0;
    817   1.47       kml }
    818   1.47       kml 
    819    1.1       cgd /*
    820    1.1       cgd  * Insert IP options into preformed packet.
    821    1.1       cgd  * Adjust IP destination as required for IP source routing,
    822    1.1       cgd  * as indicated by a non-zero in_addr at the start of the options.
    823    1.1       cgd  */
    824   1.12   mycroft static struct mbuf *
    825  1.140     perry ip_insertoptions(struct mbuf *m, struct mbuf *opt, int *phlen)
    826    1.1       cgd {
    827   1.71  augustss 	struct ipoption *p = mtod(opt, struct ipoption *);
    828    1.1       cgd 	struct mbuf *n;
    829   1.71  augustss 	struct ip *ip = mtod(m, struct ip *);
    830    1.1       cgd 	unsigned optlen;
    831    1.1       cgd 
    832    1.1       cgd 	optlen = opt->m_len - sizeof(p->ipopt_dst);
    833  1.100    itojun 	if (optlen + ntohs(ip->ip_len) > IP_MAXPACKET)
    834    1.1       cgd 		return (m);		/* XXX should fail */
    835   1.31   mycroft 	if (!in_nullhost(p->ipopt_dst))
    836    1.1       cgd 		ip->ip_dst = p->ipopt_dst;
    837  1.123    itojun 	if (M_READONLY(m) || M_LEADINGSPACE(m) < optlen) {
    838    1.1       cgd 		MGETHDR(n, M_DONTWAIT, MT_HEADER);
    839    1.1       cgd 		if (n == 0)
    840    1.1       cgd 			return (m);
    841  1.103      matt 		MCLAIM(n, m->m_owner);
    842  1.155      yamt 		M_MOVE_PKTHDR(n, m);
    843    1.1       cgd 		m->m_len -= sizeof(struct ip);
    844    1.1       cgd 		m->m_data += sizeof(struct ip);
    845    1.1       cgd 		n->m_next = m;
    846    1.1       cgd 		m = n;
    847    1.1       cgd 		m->m_len = optlen + sizeof(struct ip);
    848    1.1       cgd 		m->m_data += max_linkhdr;
    849  1.179  christos 		bcopy((void *)ip, mtod(m, void *), sizeof(struct ip));
    850    1.1       cgd 	} else {
    851    1.1       cgd 		m->m_data -= optlen;
    852    1.1       cgd 		m->m_len += optlen;
    853  1.179  christos 		memmove(mtod(m, void *), ip, sizeof(struct ip));
    854    1.1       cgd 	}
    855   1.87      yamt 	m->m_pkthdr.len += optlen;
    856    1.1       cgd 	ip = mtod(m, struct ip *);
    857  1.179  christos 	bcopy((void *)p->ipopt_list, (void *)(ip + 1), (unsigned)optlen);
    858    1.1       cgd 	*phlen = sizeof(struct ip) + optlen;
    859  1.100    itojun 	ip->ip_len = htons(ntohs(ip->ip_len) + optlen);
    860    1.1       cgd 	return (m);
    861    1.1       cgd }
    862    1.1       cgd 
    863    1.1       cgd /*
    864    1.1       cgd  * Copy options from ip to jp,
    865    1.1       cgd  * omitting those not copied during fragmentation.
    866    1.1       cgd  */
    867   1.12   mycroft int
    868  1.140     perry ip_optcopy(struct ip *ip, struct ip *jp)
    869    1.1       cgd {
    870   1.71  augustss 	u_char *cp, *dp;
    871    1.1       cgd 	int opt, optlen, cnt;
    872    1.1       cgd 
    873    1.1       cgd 	cp = (u_char *)(ip + 1);
    874    1.1       cgd 	dp = (u_char *)(jp + 1);
    875    1.1       cgd 	cnt = (ip->ip_hl << 2) - sizeof (struct ip);
    876    1.1       cgd 	for (; cnt > 0; cnt -= optlen, cp += optlen) {
    877    1.1       cgd 		opt = cp[0];
    878    1.1       cgd 		if (opt == IPOPT_EOL)
    879    1.1       cgd 			break;
    880   1.18   mycroft 		if (opt == IPOPT_NOP) {
    881   1.18   mycroft 			/* Preserve for IP mcast tunnel's LSRR alignment. */
    882   1.18   mycroft 			*dp++ = IPOPT_NOP;
    883    1.1       cgd 			optlen = 1;
    884   1.18   mycroft 			continue;
    885   1.74    itojun 		}
    886  1.226     rmind 
    887  1.226     rmind 		KASSERT(cnt >= IPOPT_OLEN + sizeof(*cp));
    888   1.74    itojun 		optlen = cp[IPOPT_OLEN];
    889  1.226     rmind 		KASSERT(optlen >= IPOPT_OLEN + sizeof(*cp) && optlen < cnt);
    890  1.226     rmind 
    891  1.226     rmind 		/* Invalid lengths should have been caught by ip_dooptions. */
    892    1.1       cgd 		if (optlen > cnt)
    893    1.1       cgd 			optlen = cnt;
    894    1.1       cgd 		if (IPOPT_COPIED(opt)) {
    895  1.179  christos 			bcopy((void *)cp, (void *)dp, (unsigned)optlen);
    896    1.1       cgd 			dp += optlen;
    897    1.1       cgd 		}
    898    1.1       cgd 	}
    899    1.1       cgd 	for (optlen = dp - (u_char *)(jp+1); optlen & 0x3; optlen++)
    900    1.1       cgd 		*dp++ = IPOPT_EOL;
    901    1.1       cgd 	return (optlen);
    902    1.1       cgd }
    903    1.1       cgd 
    904    1.1       cgd /*
    905    1.1       cgd  * IP socket option processing.
    906    1.1       cgd  */
    907   1.12   mycroft int
    908  1.197    plunky ip_ctloutput(int op, struct socket *so, struct sockopt *sopt)
    909    1.1       cgd {
    910   1.71  augustss 	struct inpcb *inp = sotoinpcb(so);
    911  1.226     rmind 	struct ip *ip = &inp->inp_ip;
    912  1.226     rmind 	int inpflags = inp->inp_flags;
    913  1.226     rmind 	int optval = 0, error = 0;
    914    1.1       cgd 
    915  1.197    plunky 	if (sopt->sopt_level != IPPROTO_IP) {
    916  1.197    plunky 		if (sopt->sopt_level == SOL_SOCKET && sopt->sopt_name == SO_NOHEADER)
    917  1.184    dyoung 			return 0;
    918  1.184    dyoung 		return ENOPROTOOPT;
    919  1.184    dyoung 	}
    920  1.184    dyoung 
    921  1.184    dyoung 	switch (op) {
    922    1.1       cgd 	case PRCO_SETOPT:
    923  1.197    plunky 		switch (sopt->sopt_name) {
    924    1.1       cgd 		case IP_OPTIONS:
    925    1.1       cgd #ifdef notyet
    926    1.1       cgd 		case IP_RETOPTS:
    927    1.1       cgd #endif
    928  1.226     rmind 			error = ip_pcbopts(inp, sopt);
    929  1.197    plunky 			break;
    930    1.1       cgd 
    931    1.1       cgd 		case IP_TOS:
    932    1.1       cgd 		case IP_TTL:
    933  1.205   minskim 		case IP_MINTTL:
    934  1.223  christos 		case IP_PKTINFO:
    935    1.1       cgd 		case IP_RECVOPTS:
    936    1.1       cgd 		case IP_RECVRETOPTS:
    937    1.1       cgd 		case IP_RECVDSTADDR:
    938   1.37   thorpej 		case IP_RECVIF:
    939  1.223  christos 		case IP_RECVPKTINFO:
    940  1.204   minskim 		case IP_RECVTTL:
    941  1.197    plunky 			error = sockopt_getint(sopt, &optval);
    942  1.197    plunky 			if (error)
    943  1.197    plunky 				break;
    944  1.197    plunky 
    945  1.197    plunky 			switch (sopt->sopt_name) {
    946  1.197    plunky 			case IP_TOS:
    947  1.226     rmind 				ip->ip_tos = optval;
    948  1.197    plunky 				break;
    949  1.197    plunky 
    950  1.197    plunky 			case IP_TTL:
    951  1.226     rmind 				ip->ip_ttl = optval;
    952  1.197    plunky 				break;
    953  1.205   minskim 
    954  1.205   minskim 			case IP_MINTTL:
    955  1.205   minskim 				if (optval > 0 && optval <= MAXTTL)
    956  1.205   minskim 					inp->inp_ip_minttl = optval;
    957  1.205   minskim 				else
    958  1.205   minskim 					error = EINVAL;
    959  1.205   minskim 				break;
    960    1.1       cgd #define	OPTSET(bit) \
    961    1.1       cgd 	if (optval) \
    962  1.226     rmind 		inpflags |= bit; \
    963    1.1       cgd 	else \
    964  1.226     rmind 		inpflags &= ~bit;
    965    1.1       cgd 
    966  1.223  christos 			case IP_PKTINFO:
    967  1.223  christos 				OPTSET(INP_PKTINFO);
    968  1.223  christos 				break;
    969  1.223  christos 
    970  1.197    plunky 			case IP_RECVOPTS:
    971  1.197    plunky 				OPTSET(INP_RECVOPTS);
    972  1.197    plunky 				break;
    973  1.197    plunky 
    974  1.223  christos 			case IP_RECVPKTINFO:
    975  1.223  christos 				OPTSET(INP_RECVPKTINFO);
    976  1.223  christos 				break;
    977  1.223  christos 
    978  1.197    plunky 			case IP_RECVRETOPTS:
    979  1.197    plunky 				OPTSET(INP_RECVRETOPTS);
    980  1.197    plunky 				break;
    981  1.197    plunky 
    982  1.197    plunky 			case IP_RECVDSTADDR:
    983  1.197    plunky 				OPTSET(INP_RECVDSTADDR);
    984  1.197    plunky 				break;
    985  1.197    plunky 
    986  1.197    plunky 			case IP_RECVIF:
    987  1.197    plunky 				OPTSET(INP_RECVIF);
    988  1.197    plunky 				break;
    989  1.204   minskim 
    990  1.204   minskim 			case IP_RECVTTL:
    991  1.204   minskim 				OPTSET(INP_RECVTTL);
    992  1.204   minskim 				break;
    993    1.1       cgd 			}
    994  1.197    plunky 		break;
    995    1.1       cgd #undef OPTSET
    996   1.18   mycroft 
    997   1.18   mycroft 		case IP_MULTICAST_IF:
    998   1.18   mycroft 		case IP_MULTICAST_TTL:
    999   1.18   mycroft 		case IP_MULTICAST_LOOP:
   1000   1.18   mycroft 		case IP_ADD_MEMBERSHIP:
   1001   1.18   mycroft 		case IP_DROP_MEMBERSHIP:
   1002  1.226     rmind 			error = ip_setmoptions(inp, sopt);
   1003   1.18   mycroft 			break;
   1004    1.1       cgd 
   1005   1.41     lukem 		case IP_PORTRANGE:
   1006  1.197    plunky 			error = sockopt_getint(sopt, &optval);
   1007  1.197    plunky 			if (error)
   1008  1.197    plunky 				break;
   1009  1.197    plunky 
   1010  1.197    plunky 			switch (optval) {
   1011  1.197    plunky 			case IP_PORTRANGE_DEFAULT:
   1012  1.197    plunky 			case IP_PORTRANGE_HIGH:
   1013  1.226     rmind 				inpflags &= ~(INP_LOWPORT);
   1014  1.197    plunky 				break;
   1015   1.41     lukem 
   1016  1.197    plunky 			case IP_PORTRANGE_LOW:
   1017  1.226     rmind 				inpflags |= INP_LOWPORT;
   1018  1.197    plunky 				break;
   1019   1.41     lukem 
   1020  1.197    plunky 			default:
   1021  1.197    plunky 				error = EINVAL;
   1022  1.197    plunky 				break;
   1023   1.41     lukem 			}
   1024   1.41     lukem 			break;
   1025   1.41     lukem 
   1026  1.216  christos 		case IP_PORTALGO:
   1027  1.216  christos 			error = sockopt_getint(sopt, &optval);
   1028  1.216  christos 			if (error)
   1029  1.216  christos 				break;
   1030  1.216  christos 
   1031  1.217  christos 			error = portalgo_algo_index_select(
   1032  1.216  christos 			    (struct inpcb_hdr *)inp, optval);
   1033  1.216  christos 			break;
   1034  1.216  christos 
   1035  1.220  christos #if defined(IPSEC)
   1036   1.61    itojun 		case IP_IPSEC_POLICY:
   1037  1.229  christos 			if (ipsec_enabled) {
   1038  1.229  christos 				error = ipsec4_set_policy(inp, sopt->sopt_name,
   1039  1.229  christos 				    sopt->sopt_data, sopt->sopt_size,
   1040  1.229  christos 				    curlwp->l_cred);
   1041  1.229  christos 				break;
   1042  1.229  christos 			}
   1043  1.229  christos 			/*FALLTHROUGH*/
   1044  1.229  christos #endif /* IPSEC */
   1045   1.61    itojun 
   1046    1.1       cgd 		default:
   1047   1.18   mycroft 			error = ENOPROTOOPT;
   1048    1.1       cgd 			break;
   1049    1.1       cgd 		}
   1050    1.1       cgd 		break;
   1051    1.1       cgd 
   1052    1.1       cgd 	case PRCO_GETOPT:
   1053  1.197    plunky 		switch (sopt->sopt_name) {
   1054    1.1       cgd 		case IP_OPTIONS:
   1055  1.226     rmind 		case IP_RETOPTS: {
   1056  1.226     rmind 			struct mbuf *mopts = inp->inp_options;
   1057  1.226     rmind 
   1058  1.226     rmind 			if (mopts) {
   1059  1.197    plunky 				struct mbuf *m;
   1060  1.197    plunky 
   1061  1.226     rmind 				m = m_copym(mopts, 0, M_COPYALL, M_DONTWAIT);
   1062  1.199    plunky 				if (m == NULL) {
   1063  1.199    plunky 					error = ENOBUFS;
   1064  1.199    plunky 					break;
   1065  1.199    plunky 				}
   1066  1.197    plunky 				error = sockopt_setmbuf(sopt, m);
   1067  1.197    plunky 			}
   1068    1.1       cgd 			break;
   1069  1.226     rmind 		}
   1070  1.223  christos 		case IP_PKTINFO:
   1071    1.1       cgd 		case IP_TOS:
   1072    1.1       cgd 		case IP_TTL:
   1073  1.205   minskim 		case IP_MINTTL:
   1074    1.1       cgd 		case IP_RECVOPTS:
   1075    1.1       cgd 		case IP_RECVRETOPTS:
   1076    1.1       cgd 		case IP_RECVDSTADDR:
   1077   1.37   thorpej 		case IP_RECVIF:
   1078  1.223  christos 		case IP_RECVPKTINFO:
   1079  1.204   minskim 		case IP_RECVTTL:
   1080   1.40      matt 		case IP_ERRORMTU:
   1081  1.197    plunky 			switch (sopt->sopt_name) {
   1082    1.1       cgd 			case IP_TOS:
   1083  1.226     rmind 				optval = ip->ip_tos;
   1084    1.1       cgd 				break;
   1085    1.1       cgd 
   1086    1.1       cgd 			case IP_TTL:
   1087  1.226     rmind 				optval = ip->ip_ttl;
   1088   1.40      matt 				break;
   1089   1.40      matt 
   1090  1.205   minskim 			case IP_MINTTL:
   1091  1.205   minskim 				optval = inp->inp_ip_minttl;
   1092  1.205   minskim 				break;
   1093  1.205   minskim 
   1094   1.40      matt 			case IP_ERRORMTU:
   1095   1.40      matt 				optval = inp->inp_errormtu;
   1096    1.1       cgd 				break;
   1097    1.1       cgd 
   1098  1.226     rmind #define	OPTBIT(bit)	(inpflags & bit ? 1 : 0)
   1099    1.1       cgd 
   1100  1.223  christos 			case IP_PKTINFO:
   1101  1.223  christos 				optval = OPTBIT(INP_PKTINFO);
   1102  1.223  christos 				break;
   1103  1.223  christos 
   1104    1.1       cgd 			case IP_RECVOPTS:
   1105    1.1       cgd 				optval = OPTBIT(INP_RECVOPTS);
   1106    1.1       cgd 				break;
   1107    1.1       cgd 
   1108  1.223  christos 			case IP_RECVPKTINFO:
   1109  1.223  christos 				optval = OPTBIT(INP_RECVPKTINFO);
   1110  1.223  christos 				break;
   1111  1.223  christos 
   1112    1.1       cgd 			case IP_RECVRETOPTS:
   1113    1.1       cgd 				optval = OPTBIT(INP_RECVRETOPTS);
   1114    1.1       cgd 				break;
   1115    1.1       cgd 
   1116    1.1       cgd 			case IP_RECVDSTADDR:
   1117    1.1       cgd 				optval = OPTBIT(INP_RECVDSTADDR);
   1118   1.37   thorpej 				break;
   1119   1.37   thorpej 
   1120   1.37   thorpej 			case IP_RECVIF:
   1121   1.37   thorpej 				optval = OPTBIT(INP_RECVIF);
   1122    1.1       cgd 				break;
   1123  1.204   minskim 
   1124  1.204   minskim 			case IP_RECVTTL:
   1125  1.204   minskim 				optval = OPTBIT(INP_RECVTTL);
   1126  1.204   minskim 				break;
   1127    1.1       cgd 			}
   1128  1.197    plunky 			error = sockopt_setint(sopt, optval);
   1129    1.1       cgd 			break;
   1130   1.61    itojun 
   1131  1.220  christos #if 0	/* defined(IPSEC) */
   1132   1.61    itojun 		case IP_IPSEC_POLICY:
   1133   1.66    itojun 		{
   1134  1.197    plunky 			struct mbuf *m = NULL;
   1135   1.66    itojun 
   1136  1.197    plunky 			/* XXX this will return EINVAL as sopt is empty */
   1137  1.197    plunky 			error = ipsec4_get_policy(inp, sopt->sopt_data,
   1138  1.197    plunky 			    sopt->sopt_size, &m);
   1139  1.197    plunky 			if (error == 0)
   1140  1.197    plunky 				error = sockopt_setmbuf(sopt, m);
   1141   1.61    itojun 			break;
   1142   1.66    itojun 		}
   1143   1.61    itojun #endif /*IPSEC*/
   1144   1.18   mycroft 
   1145   1.18   mycroft 		case IP_MULTICAST_IF:
   1146   1.18   mycroft 		case IP_MULTICAST_TTL:
   1147   1.18   mycroft 		case IP_MULTICAST_LOOP:
   1148   1.18   mycroft 		case IP_ADD_MEMBERSHIP:
   1149   1.18   mycroft 		case IP_DROP_MEMBERSHIP:
   1150  1.226     rmind 			error = ip_getmoptions(inp, sopt);
   1151   1.41     lukem 			break;
   1152   1.41     lukem 
   1153   1.41     lukem 		case IP_PORTRANGE:
   1154  1.226     rmind 			if (inpflags & INP_LOWPORT)
   1155   1.41     lukem 				optval = IP_PORTRANGE_LOW;
   1156   1.41     lukem 			else
   1157   1.41     lukem 				optval = IP_PORTRANGE_DEFAULT;
   1158  1.197    plunky 			error = sockopt_setint(sopt, optval);
   1159   1.18   mycroft 			break;
   1160    1.1       cgd 
   1161  1.216  christos 		case IP_PORTALGO:
   1162  1.226     rmind 			optval = inp->inp_portalgo;
   1163  1.216  christos 			error = sockopt_setint(sopt, optval);
   1164  1.216  christos 			break;
   1165  1.216  christos 
   1166    1.1       cgd 		default:
   1167   1.18   mycroft 			error = ENOPROTOOPT;
   1168    1.1       cgd 			break;
   1169    1.1       cgd 		}
   1170    1.1       cgd 		break;
   1171    1.1       cgd 	}
   1172  1.226     rmind 
   1173  1.226     rmind 	if (!error) {
   1174  1.226     rmind 		inp->inp_flags = inpflags;
   1175  1.226     rmind 	}
   1176  1.226     rmind 	return error;
   1177    1.1       cgd }
   1178    1.1       cgd 
   1179    1.1       cgd /*
   1180    1.1       cgd  * Set up IP options in pcb for insertion in output packets.
   1181    1.1       cgd  * Store in mbuf with pointer in pcbopt, adding pseudo-option
   1182    1.1       cgd  * with destination address if source routed.
   1183    1.1       cgd  */
   1184  1.226     rmind static int
   1185  1.226     rmind ip_pcbopts(struct inpcb *inp, const struct sockopt *sopt)
   1186    1.1       cgd {
   1187  1.200    plunky 	struct mbuf *m;
   1188  1.200    plunky 	const u_char *cp;
   1189  1.200    plunky 	u_char *dp;
   1190  1.200    plunky 	int cnt;
   1191  1.200    plunky 
   1192  1.226     rmind 	/* Turn off any old options. */
   1193  1.226     rmind 	if (inp->inp_options) {
   1194  1.226     rmind 		m_free(inp->inp_options);
   1195  1.226     rmind 	}
   1196  1.226     rmind 	inp->inp_options = NULL;
   1197  1.226     rmind 	if ((cnt = sopt->sopt_size) == 0) {
   1198  1.226     rmind 		/* Only turning off any previous options. */
   1199  1.226     rmind 		return 0;
   1200  1.226     rmind 	}
   1201  1.200    plunky 	cp = sopt->sopt_data;
   1202    1.1       cgd 
   1203   1.85     ragge #ifndef	__vax__
   1204  1.200    plunky 	if (cnt % sizeof(int32_t))
   1205  1.200    plunky 		return (EINVAL);
   1206    1.1       cgd #endif
   1207  1.200    plunky 
   1208  1.200    plunky 	m = m_get(M_DONTWAIT, MT_SOOPTS);
   1209  1.200    plunky 	if (m == NULL)
   1210  1.200    plunky 		return (ENOBUFS);
   1211  1.200    plunky 
   1212  1.200    plunky 	dp = mtod(m, u_char *);
   1213  1.200    plunky 	memset(dp, 0, sizeof(struct in_addr));
   1214  1.200    plunky 	dp += sizeof(struct in_addr);
   1215  1.200    plunky 	m->m_len = sizeof(struct in_addr);
   1216  1.200    plunky 
   1217    1.1       cgd 	/*
   1218  1.200    plunky 	 * IP option list according to RFC791. Each option is of the form
   1219  1.200    plunky 	 *
   1220  1.200    plunky 	 *	[optval] [olen] [(olen - 2) data bytes]
   1221  1.200    plunky 	 *
   1222  1.226     rmind 	 * We validate the list and copy options to an mbuf for prepending
   1223  1.200    plunky 	 * to data packets. The IP first-hop destination address will be
   1224  1.200    plunky 	 * stored before actual options and is zero if unset.
   1225    1.1       cgd 	 */
   1226  1.200    plunky 	while (cnt > 0) {
   1227  1.226     rmind 		uint8_t optval, olen, offset;
   1228  1.226     rmind 
   1229  1.200    plunky 		optval = cp[IPOPT_OPTVAL];
   1230    1.1       cgd 
   1231  1.200    plunky 		if (optval == IPOPT_EOL || optval == IPOPT_NOP) {
   1232  1.200    plunky 			olen = 1;
   1233  1.200    plunky 		} else {
   1234  1.200    plunky 			if (cnt < IPOPT_OLEN + 1)
   1235   1.74    itojun 				goto bad;
   1236  1.200    plunky 
   1237  1.200    plunky 			olen = cp[IPOPT_OLEN];
   1238  1.200    plunky 			if (olen < IPOPT_OLEN + 1 || olen > cnt)
   1239    1.1       cgd 				goto bad;
   1240    1.1       cgd 		}
   1241    1.1       cgd 
   1242  1.200    plunky 		if (optval == IPOPT_LSRR || optval == IPOPT_SSRR) {
   1243    1.1       cgd 			/*
   1244    1.1       cgd 			 * user process specifies route as:
   1245    1.1       cgd 			 *	->A->B->C->D
   1246    1.1       cgd 			 * D must be our final destination (but we can't
   1247    1.1       cgd 			 * check that since we may not have connected yet).
   1248    1.1       cgd 			 * A is first hop destination, which doesn't appear in
   1249    1.1       cgd 			 * actual IP option, but is stored before the options.
   1250    1.1       cgd 			 */
   1251  1.200    plunky 			if (olen < IPOPT_OFFSET + 1 + sizeof(struct in_addr))
   1252    1.1       cgd 				goto bad;
   1253  1.200    plunky 
   1254  1.200    plunky 			offset = cp[IPOPT_OFFSET];
   1255  1.200    plunky 			memcpy(mtod(m, u_char *), cp + IPOPT_OFFSET + 1,
   1256  1.200    plunky 			    sizeof(struct in_addr));
   1257  1.200    plunky 
   1258  1.200    plunky 			cp += sizeof(struct in_addr);
   1259    1.1       cgd 			cnt -= sizeof(struct in_addr);
   1260  1.200    plunky 			olen -= sizeof(struct in_addr);
   1261  1.200    plunky 
   1262  1.200    plunky 			if (m->m_len + olen > MAX_IPOPTLEN + sizeof(struct in_addr))
   1263  1.200    plunky 				goto bad;
   1264  1.200    plunky 
   1265  1.200    plunky 			memcpy(dp, cp, olen);
   1266  1.200    plunky 			dp[IPOPT_OPTVAL] = optval;
   1267  1.200    plunky 			dp[IPOPT_OLEN] = olen;
   1268  1.200    plunky 			dp[IPOPT_OFFSET] = offset;
   1269  1.200    plunky 			break;
   1270  1.200    plunky 		} else {
   1271  1.200    plunky 			if (m->m_len + olen > MAX_IPOPTLEN + sizeof(struct in_addr))
   1272  1.200    plunky 				goto bad;
   1273  1.200    plunky 
   1274  1.200    plunky 			memcpy(dp, cp, olen);
   1275    1.1       cgd 			break;
   1276    1.1       cgd 		}
   1277  1.200    plunky 
   1278  1.200    plunky 		dp += olen;
   1279  1.200    plunky 		m->m_len += olen;
   1280  1.200    plunky 
   1281  1.200    plunky 		if (optval == IPOPT_EOL)
   1282  1.200    plunky 			break;
   1283  1.200    plunky 
   1284  1.200    plunky 		cp += olen;
   1285  1.200    plunky 		cnt -= olen;
   1286    1.1       cgd 	}
   1287  1.200    plunky 
   1288  1.226     rmind 	inp->inp_options = m;
   1289  1.226     rmind 	return 0;
   1290    1.1       cgd bad:
   1291    1.1       cgd 	(void)m_free(m);
   1292  1.226     rmind 	return EINVAL;
   1293    1.1       cgd }
   1294    1.5   hpeyerl 
   1295    1.5   hpeyerl /*
   1296   1.81    itojun  * following RFC1724 section 3.3, 0.0.0.0/8 is interpreted as interface index.
   1297   1.81    itojun  */
   1298   1.81    itojun static struct ifnet *
   1299  1.140     perry ip_multicast_if(struct in_addr *a, int *ifindexp)
   1300   1.81    itojun {
   1301   1.81    itojun 	int ifindex;
   1302  1.111    itojun 	struct ifnet *ifp = NULL;
   1303  1.110    itojun 	struct in_ifaddr *ia;
   1304   1.81    itojun 
   1305   1.81    itojun 	if (ifindexp)
   1306   1.81    itojun 		*ifindexp = 0;
   1307   1.81    itojun 	if (ntohl(a->s_addr) >> 24 == 0) {
   1308   1.81    itojun 		ifindex = ntohl(a->s_addr) & 0xffffff;
   1309  1.225     rmind 		ifp = if_byindex(ifindex);
   1310  1.129    itojun 		if (!ifp)
   1311  1.129    itojun 			return NULL;
   1312   1.81    itojun 		if (ifindexp)
   1313   1.81    itojun 			*ifindexp = ifindex;
   1314   1.81    itojun 	} else {
   1315  1.110    itojun 		LIST_FOREACH(ia, &IN_IFADDR_HASH(a->s_addr), ia_hash) {
   1316  1.110    itojun 			if (in_hosteq(ia->ia_addr.sin_addr, *a) &&
   1317  1.111    itojun 			    (ia->ia_ifp->if_flags & IFF_MULTICAST) != 0) {
   1318  1.111    itojun 				ifp = ia->ia_ifp;
   1319  1.110    itojun 				break;
   1320  1.111    itojun 			}
   1321  1.110    itojun 		}
   1322   1.81    itojun 	}
   1323   1.81    itojun 	return ifp;
   1324   1.81    itojun }
   1325   1.81    itojun 
   1326  1.156  christos static int
   1327  1.198    plunky ip_getoptval(const struct sockopt *sopt, u_int8_t *val, u_int maxval)
   1328  1.156  christos {
   1329  1.156  christos 	u_int tval;
   1330  1.197    plunky 	u_char cval;
   1331  1.197    plunky 	int error;
   1332  1.156  christos 
   1333  1.197    plunky 	if (sopt == NULL)
   1334  1.156  christos 		return EINVAL;
   1335  1.156  christos 
   1336  1.197    plunky 	switch (sopt->sopt_size) {
   1337  1.156  christos 	case sizeof(u_char):
   1338  1.197    plunky 		error = sockopt_get(sopt, &cval, sizeof(u_char));
   1339  1.197    plunky 		tval = cval;
   1340  1.156  christos 		break;
   1341  1.197    plunky 
   1342  1.156  christos 	case sizeof(u_int):
   1343  1.197    plunky 		error = sockopt_get(sopt, &tval, sizeof(u_int));
   1344  1.156  christos 		break;
   1345  1.197    plunky 
   1346  1.156  christos 	default:
   1347  1.197    plunky 		error = EINVAL;
   1348  1.156  christos 	}
   1349  1.156  christos 
   1350  1.197    plunky 	if (error)
   1351  1.197    plunky 		return error;
   1352  1.197    plunky 
   1353  1.156  christos 	if (tval > maxval)
   1354  1.156  christos 		return EINVAL;
   1355  1.156  christos 
   1356  1.156  christos 	*val = tval;
   1357  1.156  christos 	return 0;
   1358  1.156  christos }
   1359  1.156  christos 
   1360   1.81    itojun /*
   1361    1.5   hpeyerl  * Set the IP multicast options in response to user setsockopt().
   1362    1.5   hpeyerl  */
   1363  1.226     rmind static int
   1364  1.226     rmind ip_setmoptions(struct inpcb *inp, const struct sockopt *sopt)
   1365    1.5   hpeyerl {
   1366  1.226     rmind 	struct ip_moptions *imo = inp->inp_moptions;
   1367    1.5   hpeyerl 	struct in_addr addr;
   1368  1.197    plunky 	struct ip_mreq lmreq, *mreq;
   1369   1.71  augustss 	struct ifnet *ifp;
   1370  1.215     rmind 	int i, ifindex, error = 0;
   1371    1.5   hpeyerl 
   1372  1.226     rmind 	if (!imo) {
   1373    1.5   hpeyerl 		/*
   1374    1.5   hpeyerl 		 * No multicast option buffer attached to the pcb;
   1375    1.5   hpeyerl 		 * allocate one and initialize to default values.
   1376    1.5   hpeyerl 		 */
   1377  1.215     rmind 		imo = kmem_intr_alloc(sizeof(*imo), KM_NOSLEEP);
   1378    1.5   hpeyerl 		if (imo == NULL)
   1379  1.215     rmind 			return ENOBUFS;
   1380  1.199    plunky 
   1381    1.5   hpeyerl 		imo->imo_multicast_ifp = NULL;
   1382   1.81    itojun 		imo->imo_multicast_addr.s_addr = INADDR_ANY;
   1383    1.5   hpeyerl 		imo->imo_multicast_ttl = IP_DEFAULT_MULTICAST_TTL;
   1384    1.5   hpeyerl 		imo->imo_multicast_loop = IP_DEFAULT_MULTICAST_LOOP;
   1385    1.5   hpeyerl 		imo->imo_num_memberships = 0;
   1386  1.226     rmind 		inp->inp_moptions = imo;
   1387    1.5   hpeyerl 	}
   1388    1.5   hpeyerl 
   1389  1.197    plunky 	switch (sopt->sopt_name) {
   1390    1.5   hpeyerl 	case IP_MULTICAST_IF:
   1391    1.5   hpeyerl 		/*
   1392    1.5   hpeyerl 		 * Select the interface for outgoing multicast packets.
   1393    1.5   hpeyerl 		 */
   1394  1.197    plunky 		error = sockopt_get(sopt, &addr, sizeof(addr));
   1395  1.197    plunky 		if (error)
   1396    1.5   hpeyerl 			break;
   1397  1.197    plunky 
   1398    1.5   hpeyerl 		/*
   1399    1.5   hpeyerl 		 * INADDR_ANY is used to remove a previous selection.
   1400   1.11   mycroft 		 * When no interface is selected, a default one is
   1401    1.5   hpeyerl 		 * chosen every time a multicast packet is sent.
   1402    1.5   hpeyerl 		 */
   1403   1.31   mycroft 		if (in_nullhost(addr)) {
   1404    1.5   hpeyerl 			imo->imo_multicast_ifp = NULL;
   1405    1.5   hpeyerl 			break;
   1406    1.5   hpeyerl 		}
   1407    1.5   hpeyerl 		/*
   1408    1.5   hpeyerl 		 * The selected interface is identified by its local
   1409    1.5   hpeyerl 		 * IP address.  Find the interface and confirm that
   1410   1.11   mycroft 		 * it supports multicasting.
   1411    1.5   hpeyerl 		 */
   1412   1.81    itojun 		ifp = ip_multicast_if(&addr, &ifindex);
   1413    1.5   hpeyerl 		if (ifp == NULL || (ifp->if_flags & IFF_MULTICAST) == 0) {
   1414    1.5   hpeyerl 			error = EADDRNOTAVAIL;
   1415    1.5   hpeyerl 			break;
   1416    1.5   hpeyerl 		}
   1417    1.5   hpeyerl 		imo->imo_multicast_ifp = ifp;
   1418   1.81    itojun 		if (ifindex)
   1419   1.81    itojun 			imo->imo_multicast_addr = addr;
   1420   1.81    itojun 		else
   1421   1.81    itojun 			imo->imo_multicast_addr.s_addr = INADDR_ANY;
   1422    1.5   hpeyerl 		break;
   1423    1.5   hpeyerl 
   1424    1.5   hpeyerl 	case IP_MULTICAST_TTL:
   1425    1.5   hpeyerl 		/*
   1426    1.5   hpeyerl 		 * Set the IP time-to-live for outgoing multicast packets.
   1427    1.5   hpeyerl 		 */
   1428  1.197    plunky 		error = ip_getoptval(sopt, &imo->imo_multicast_ttl, MAXTTL);
   1429    1.5   hpeyerl 		break;
   1430   1.11   mycroft 
   1431    1.5   hpeyerl 	case IP_MULTICAST_LOOP:
   1432    1.5   hpeyerl 		/*
   1433    1.5   hpeyerl 		 * Set the loopback flag for outgoing multicast packets.
   1434    1.5   hpeyerl 		 * Must be zero or one.
   1435    1.5   hpeyerl 		 */
   1436  1.197    plunky 		error = ip_getoptval(sopt, &imo->imo_multicast_loop, 1);
   1437    1.5   hpeyerl 		break;
   1438    1.5   hpeyerl 
   1439    1.5   hpeyerl 	case IP_ADD_MEMBERSHIP:
   1440    1.5   hpeyerl 		/*
   1441    1.5   hpeyerl 		 * Add a multicast group membership.
   1442    1.5   hpeyerl 		 * Group must be a valid IP multicast address.
   1443    1.5   hpeyerl 		 */
   1444  1.197    plunky 		error = sockopt_get(sopt, &lmreq, sizeof(lmreq));
   1445  1.197    plunky 		if (error)
   1446    1.5   hpeyerl 			break;
   1447  1.197    plunky 
   1448  1.197    plunky 		mreq = &lmreq;
   1449  1.197    plunky 
   1450   1.23   mycroft 		if (!IN_MULTICAST(mreq->imr_multiaddr.s_addr)) {
   1451    1.5   hpeyerl 			error = EINVAL;
   1452    1.5   hpeyerl 			break;
   1453    1.5   hpeyerl 		}
   1454    1.5   hpeyerl 		/*
   1455    1.5   hpeyerl 		 * If no interface address was provided, use the interface of
   1456    1.5   hpeyerl 		 * the route to the given multicast address.
   1457    1.5   hpeyerl 		 */
   1458   1.31   mycroft 		if (in_nullhost(mreq->imr_interface)) {
   1459  1.186    dyoung 			struct rtentry *rt;
   1460  1.180    dyoung 			union {
   1461  1.180    dyoung 				struct sockaddr		dst;
   1462  1.180    dyoung 				struct sockaddr_in	dst4;
   1463  1.180    dyoung 			} u;
   1464  1.180    dyoung 			struct route ro;
   1465  1.180    dyoung 
   1466  1.176    dyoung 			memset(&ro, 0, sizeof(ro));
   1467  1.180    dyoung 
   1468  1.180    dyoung 			sockaddr_in_init(&u.dst4, &mreq->imr_multiaddr, 0);
   1469  1.180    dyoung 			rtcache_setdst(&ro, &u.dst);
   1470  1.190    dyoung 			ifp = (rt = rtcache_init(&ro)) != NULL ? rt->rt_ifp
   1471  1.186    dyoung 			                                        : NULL;
   1472  1.171     joerg 			rtcache_free(&ro);
   1473   1.23   mycroft 		} else {
   1474   1.81    itojun 			ifp = ip_multicast_if(&mreq->imr_interface, NULL);
   1475    1.5   hpeyerl 		}
   1476    1.5   hpeyerl 		/*
   1477    1.5   hpeyerl 		 * See if we found an interface, and confirm that it
   1478    1.5   hpeyerl 		 * supports multicast.
   1479    1.5   hpeyerl 		 */
   1480   1.11   mycroft 		if (ifp == NULL || (ifp->if_flags & IFF_MULTICAST) == 0) {
   1481    1.5   hpeyerl 			error = EADDRNOTAVAIL;
   1482    1.5   hpeyerl 			break;
   1483    1.5   hpeyerl 		}
   1484    1.5   hpeyerl 		/*
   1485    1.5   hpeyerl 		 * See if the membership already exists or if all the
   1486    1.5   hpeyerl 		 * membership slots are full.
   1487   1.11   mycroft 		 */
   1488    1.5   hpeyerl 		for (i = 0; i < imo->imo_num_memberships; ++i) {
   1489    1.5   hpeyerl 			if (imo->imo_membership[i]->inm_ifp == ifp &&
   1490   1.31   mycroft 			    in_hosteq(imo->imo_membership[i]->inm_addr,
   1491   1.31   mycroft 				      mreq->imr_multiaddr))
   1492    1.5   hpeyerl 				break;
   1493   1.11   mycroft 		}
   1494    1.5   hpeyerl 		if (i < imo->imo_num_memberships) {
   1495    1.5   hpeyerl 			error = EADDRINUSE;
   1496    1.5   hpeyerl 			break;
   1497    1.5   hpeyerl 		}
   1498    1.5   hpeyerl 		if (i == IP_MAX_MEMBERSHIPS) {
   1499   1.11   mycroft 			error = ETOOMANYREFS;
   1500    1.5   hpeyerl 			break;
   1501    1.5   hpeyerl 		}
   1502    1.5   hpeyerl 		/*
   1503    1.5   hpeyerl 		 * Everything looks good; add a new record to the multicast
   1504    1.5   hpeyerl 		 * address list for the given interface.
   1505    1.5   hpeyerl 		 */
   1506    1.5   hpeyerl 		if ((imo->imo_membership[i] =
   1507    1.5   hpeyerl 		    in_addmulti(&mreq->imr_multiaddr, ifp)) == NULL) {
   1508    1.5   hpeyerl 			error = ENOBUFS;
   1509    1.5   hpeyerl 			break;
   1510    1.5   hpeyerl 		}
   1511    1.5   hpeyerl 		++imo->imo_num_memberships;
   1512    1.5   hpeyerl 		break;
   1513    1.5   hpeyerl 
   1514    1.5   hpeyerl 	case IP_DROP_MEMBERSHIP:
   1515    1.5   hpeyerl 		/*
   1516    1.5   hpeyerl 		 * Drop a multicast group membership.
   1517    1.5   hpeyerl 		 * Group must be a valid IP multicast address.
   1518    1.5   hpeyerl 		 */
   1519  1.197    plunky 		error = sockopt_get(sopt, &lmreq, sizeof(lmreq));
   1520  1.197    plunky 		if (error)
   1521    1.5   hpeyerl 			break;
   1522  1.197    plunky 
   1523  1.197    plunky 		mreq = &lmreq;
   1524  1.197    plunky 
   1525   1.23   mycroft 		if (!IN_MULTICAST(mreq->imr_multiaddr.s_addr)) {
   1526    1.5   hpeyerl 			error = EINVAL;
   1527    1.5   hpeyerl 			break;
   1528    1.5   hpeyerl 		}
   1529    1.5   hpeyerl 		/*
   1530    1.5   hpeyerl 		 * If an interface address was specified, get a pointer
   1531    1.5   hpeyerl 		 * to its ifnet structure.
   1532    1.5   hpeyerl 		 */
   1533   1.31   mycroft 		if (in_nullhost(mreq->imr_interface))
   1534    1.5   hpeyerl 			ifp = NULL;
   1535    1.5   hpeyerl 		else {
   1536   1.81    itojun 			ifp = ip_multicast_if(&mreq->imr_interface, NULL);
   1537    1.5   hpeyerl 			if (ifp == NULL) {
   1538    1.5   hpeyerl 				error = EADDRNOTAVAIL;
   1539    1.5   hpeyerl 				break;
   1540    1.5   hpeyerl 			}
   1541    1.5   hpeyerl 		}
   1542    1.5   hpeyerl 		/*
   1543    1.5   hpeyerl 		 * Find the membership in the membership array.
   1544    1.5   hpeyerl 		 */
   1545    1.5   hpeyerl 		for (i = 0; i < imo->imo_num_memberships; ++i) {
   1546    1.5   hpeyerl 			if ((ifp == NULL ||
   1547    1.5   hpeyerl 			     imo->imo_membership[i]->inm_ifp == ifp) &&
   1548   1.31   mycroft 			     in_hosteq(imo->imo_membership[i]->inm_addr,
   1549   1.31   mycroft 				       mreq->imr_multiaddr))
   1550    1.5   hpeyerl 				break;
   1551    1.5   hpeyerl 		}
   1552    1.5   hpeyerl 		if (i == imo->imo_num_memberships) {
   1553    1.5   hpeyerl 			error = EADDRNOTAVAIL;
   1554    1.5   hpeyerl 			break;
   1555    1.5   hpeyerl 		}
   1556    1.5   hpeyerl 		/*
   1557    1.5   hpeyerl 		 * Give up the multicast address record to which the
   1558    1.5   hpeyerl 		 * membership points.
   1559    1.5   hpeyerl 		 */
   1560   1.11   mycroft 		in_delmulti(imo->imo_membership[i]);
   1561    1.5   hpeyerl 		/*
   1562    1.5   hpeyerl 		 * Remove the gap in the membership array.
   1563    1.5   hpeyerl 		 */
   1564    1.5   hpeyerl 		for (++i; i < imo->imo_num_memberships; ++i)
   1565    1.5   hpeyerl 			imo->imo_membership[i-1] = imo->imo_membership[i];
   1566    1.5   hpeyerl 		--imo->imo_num_memberships;
   1567    1.5   hpeyerl 		break;
   1568    1.5   hpeyerl 
   1569    1.5   hpeyerl 	default:
   1570    1.5   hpeyerl 		error = EOPNOTSUPP;
   1571    1.5   hpeyerl 		break;
   1572    1.5   hpeyerl 	}
   1573    1.5   hpeyerl 
   1574    1.5   hpeyerl 	/*
   1575    1.5   hpeyerl 	 * If all options have default values, no need to keep the mbuf.
   1576    1.5   hpeyerl 	 */
   1577    1.5   hpeyerl 	if (imo->imo_multicast_ifp == NULL &&
   1578    1.5   hpeyerl 	    imo->imo_multicast_ttl == IP_DEFAULT_MULTICAST_TTL &&
   1579    1.5   hpeyerl 	    imo->imo_multicast_loop == IP_DEFAULT_MULTICAST_LOOP &&
   1580    1.5   hpeyerl 	    imo->imo_num_memberships == 0) {
   1581  1.215     rmind 		kmem_free(imo, sizeof(*imo));
   1582  1.226     rmind 		inp->inp_moptions = NULL;
   1583    1.5   hpeyerl 	}
   1584    1.5   hpeyerl 
   1585  1.215     rmind 	return error;
   1586    1.5   hpeyerl }
   1587    1.5   hpeyerl 
   1588    1.5   hpeyerl /*
   1589    1.5   hpeyerl  * Return the IP multicast options in response to user getsockopt().
   1590    1.5   hpeyerl  */
   1591  1.226     rmind static int
   1592  1.226     rmind ip_getmoptions(struct inpcb *inp, struct sockopt *sopt)
   1593    1.5   hpeyerl {
   1594  1.226     rmind 	struct ip_moptions *imo = inp->inp_moptions;
   1595  1.197    plunky 	struct in_addr addr;
   1596    1.5   hpeyerl 	struct in_ifaddr *ia;
   1597  1.197    plunky 	uint8_t optval;
   1598  1.226     rmind 	int error = 0;
   1599    1.5   hpeyerl 
   1600  1.197    plunky 	switch (sopt->sopt_name) {
   1601    1.5   hpeyerl 	case IP_MULTICAST_IF:
   1602    1.5   hpeyerl 		if (imo == NULL || imo->imo_multicast_ifp == NULL)
   1603  1.197    plunky 			addr = zeroin_addr;
   1604   1.81    itojun 		else if (imo->imo_multicast_addr.s_addr) {
   1605   1.81    itojun 			/* return the value user has set */
   1606  1.197    plunky 			addr = imo->imo_multicast_addr;
   1607   1.81    itojun 		} else {
   1608    1.5   hpeyerl 			IFP_TO_IA(imo->imo_multicast_ifp, ia);
   1609  1.197    plunky 			addr = ia ? ia->ia_addr.sin_addr : zeroin_addr;
   1610    1.5   hpeyerl 		}
   1611  1.197    plunky 		error = sockopt_set(sopt, &addr, sizeof(addr));
   1612  1.197    plunky 		break;
   1613    1.5   hpeyerl 
   1614    1.5   hpeyerl 	case IP_MULTICAST_TTL:
   1615  1.197    plunky 		optval = imo ? imo->imo_multicast_ttl
   1616  1.197    plunky 			     : IP_DEFAULT_MULTICAST_TTL;
   1617  1.197    plunky 
   1618  1.197    plunky 		error = sockopt_set(sopt, &optval, sizeof(optval));
   1619  1.197    plunky 		break;
   1620    1.5   hpeyerl 
   1621    1.5   hpeyerl 	case IP_MULTICAST_LOOP:
   1622  1.197    plunky 		optval = imo ? imo->imo_multicast_loop
   1623  1.197    plunky 			     : IP_DEFAULT_MULTICAST_LOOP;
   1624  1.197    plunky 
   1625  1.197    plunky 		error = sockopt_set(sopt, &optval, sizeof(optval));
   1626  1.197    plunky 		break;
   1627    1.5   hpeyerl 
   1628    1.5   hpeyerl 	default:
   1629  1.197    plunky 		error = EOPNOTSUPP;
   1630    1.5   hpeyerl 	}
   1631  1.197    plunky 
   1632  1.226     rmind 	return error;
   1633    1.5   hpeyerl }
   1634    1.5   hpeyerl 
   1635    1.5   hpeyerl /*
   1636    1.5   hpeyerl  * Discard the IP multicast options.
   1637    1.5   hpeyerl  */
   1638    1.5   hpeyerl void
   1639  1.140     perry ip_freemoptions(struct ip_moptions *imo)
   1640    1.5   hpeyerl {
   1641   1.71  augustss 	int i;
   1642    1.5   hpeyerl 
   1643    1.5   hpeyerl 	if (imo != NULL) {
   1644    1.5   hpeyerl 		for (i = 0; i < imo->imo_num_memberships; ++i)
   1645    1.5   hpeyerl 			in_delmulti(imo->imo_membership[i]);
   1646  1.215     rmind 		kmem_free(imo, sizeof(*imo));
   1647    1.5   hpeyerl 	}
   1648    1.5   hpeyerl }
   1649    1.5   hpeyerl 
   1650    1.5   hpeyerl /*
   1651    1.5   hpeyerl  * Routine called from ip_output() to loop back a copy of an IP multicast
   1652    1.5   hpeyerl  * packet to the input queue of a specified interface.  Note that this
   1653    1.5   hpeyerl  * calls the output routine of the loopback "driver", but with an interface
   1654  1.137     peter  * pointer that might NOT be lo0ifp -- easier than replicating that code here.
   1655    1.5   hpeyerl  */
   1656   1.12   mycroft static void
   1657  1.180    dyoung ip_mloopback(struct ifnet *ifp, struct mbuf *m, const struct sockaddr_in *dst)
   1658    1.5   hpeyerl {
   1659   1.71  augustss 	struct ip *ip;
   1660    1.5   hpeyerl 	struct mbuf *copym;
   1661    1.5   hpeyerl 
   1662  1.183    dyoung 	copym = m_copypacket(m, M_DONTWAIT);
   1663   1.70    itojun 	if (copym != NULL
   1664   1.65    itojun 	 && (copym->m_flags & M_EXT || copym->m_len < sizeof(struct ip)))
   1665   1.65    itojun 		copym = m_pullup(copym, sizeof(struct ip));
   1666  1.180    dyoung 	if (copym == NULL)
   1667  1.180    dyoung 		return;
   1668  1.180    dyoung 	/*
   1669  1.180    dyoung 	 * We don't bother to fragment if the IP length is greater
   1670  1.180    dyoung 	 * than the interface's MTU.  Can this possibly matter?
   1671  1.180    dyoung 	 */
   1672  1.180    dyoung 	ip = mtod(copym, struct ip *);
   1673   1.93    itojun 
   1674  1.180    dyoung 	if (copym->m_pkthdr.csum_flags & (M_CSUM_TCPv4|M_CSUM_UDPv4)) {
   1675  1.180    dyoung 		in_delayed_cksum(copym);
   1676  1.180    dyoung 		copym->m_pkthdr.csum_flags &=
   1677  1.180    dyoung 		    ~(M_CSUM_TCPv4|M_CSUM_UDPv4);
   1678  1.180    dyoung 	}
   1679   1.93    itojun 
   1680  1.180    dyoung 	ip->ip_sum = 0;
   1681  1.180    dyoung 	ip->ip_sum = in_cksum(copym, ip->ip_hl << 2);
   1682  1.180    dyoung 	(void)looutput(ifp, copym, sintocsa(dst), NULL);
   1683    1.5   hpeyerl }
   1684