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