Home | History | Annotate | Line # | Download | only in netinet
ip_output.c revision 1.54
      1  1.54   thorpej /*	$NetBSD: ip_output.c,v 1.54 1998/12/19 02:46:12 thorpej Exp $	*/
      2  1.54   thorpej 
      3  1.54   thorpej /*-
      4  1.54   thorpej  * Copyright (c) 1998 The NetBSD Foundation, Inc.
      5  1.54   thorpej  * All rights reserved.
      6  1.54   thorpej  *
      7  1.54   thorpej  * This code is derived from software contributed to The NetBSD Foundation
      8  1.54   thorpej  * by Public Access Networks Corporation ("Panix").  It was developed under
      9  1.54   thorpej  * contract to Panix by Eric Haszlakiewicz and Thor Lancelot Simon.
     10  1.54   thorpej  *
     11  1.54   thorpej  * Redistribution and use in source and binary forms, with or without
     12  1.54   thorpej  * modification, are permitted provided that the following conditions
     13  1.54   thorpej  * are met:
     14  1.54   thorpej  * 1. Redistributions of source code must retain the above copyright
     15  1.54   thorpej  *    notice, this list of conditions and the following disclaimer.
     16  1.54   thorpej  * 2. Redistributions in binary form must reproduce the above copyright
     17  1.54   thorpej  *    notice, this list of conditions and the following disclaimer in the
     18  1.54   thorpej  *    documentation and/or other materials provided with the distribution.
     19  1.54   thorpej  * 3. All advertising materials mentioning features or use of this software
     20  1.54   thorpej  *    must display the following acknowledgement:
     21  1.54   thorpej  *	This product includes software developed by the NetBSD
     22  1.54   thorpej  *	Foundation, Inc. and its contributors.
     23  1.54   thorpej  * 4. Neither the name of The NetBSD Foundation nor the names of its
     24  1.54   thorpej  *    contributors may be used to endorse or promote products derived
     25  1.54   thorpej  *    from this software without specific prior written permission.
     26  1.54   thorpej  *
     27  1.54   thorpej  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     28  1.54   thorpej  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     29  1.54   thorpej  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     30  1.54   thorpej  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     31  1.54   thorpej  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     32  1.54   thorpej  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     33  1.54   thorpej  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     34  1.54   thorpej  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     35  1.54   thorpej  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     36  1.54   thorpej  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     37  1.54   thorpej  * POSSIBILITY OF SUCH DAMAGE.
     38  1.54   thorpej  */
     39  1.19       cgd 
     40   1.1       cgd /*
     41  1.18   mycroft  * Copyright (c) 1982, 1986, 1988, 1990, 1993
     42  1.18   mycroft  *	The Regents of the University of California.  All rights reserved.
     43   1.1       cgd  *
     44   1.1       cgd  * Redistribution and use in source and binary forms, with or without
     45   1.1       cgd  * modification, are permitted provided that the following conditions
     46   1.1       cgd  * are met:
     47   1.1       cgd  * 1. Redistributions of source code must retain the above copyright
     48   1.1       cgd  *    notice, this list of conditions and the following disclaimer.
     49   1.1       cgd  * 2. Redistributions in binary form must reproduce the above copyright
     50   1.1       cgd  *    notice, this list of conditions and the following disclaimer in the
     51   1.1       cgd  *    documentation and/or other materials provided with the distribution.
     52   1.1       cgd  * 3. All advertising materials mentioning features or use of this software
     53   1.1       cgd  *    must display the following acknowledgement:
     54   1.1       cgd  *	This product includes software developed by the University of
     55   1.1       cgd  *	California, Berkeley and its contributors.
     56   1.1       cgd  * 4. Neither the name of the University nor the names of its contributors
     57   1.1       cgd  *    may be used to endorse or promote products derived from this software
     58   1.1       cgd  *    without specific prior written permission.
     59   1.1       cgd  *
     60   1.1       cgd  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     61   1.1       cgd  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     62   1.1       cgd  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     63   1.1       cgd  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     64   1.1       cgd  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     65   1.1       cgd  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     66   1.1       cgd  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     67   1.1       cgd  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     68   1.1       cgd  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     69   1.1       cgd  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     70   1.1       cgd  * SUCH DAMAGE.
     71   1.1       cgd  *
     72  1.19       cgd  *	@(#)ip_output.c	8.3 (Berkeley) 1/21/94
     73   1.1       cgd  */
     74  1.42    scottr 
     75  1.50       mrg #include "opt_pfil_hooks.h"
     76  1.42    scottr #include "opt_mrouting.h"
     77   1.1       cgd 
     78   1.8   mycroft #include <sys/param.h>
     79   1.8   mycroft #include <sys/malloc.h>
     80   1.8   mycroft #include <sys/mbuf.h>
     81   1.8   mycroft #include <sys/errno.h>
     82   1.8   mycroft #include <sys/protosw.h>
     83   1.8   mycroft #include <sys/socket.h>
     84   1.8   mycroft #include <sys/socketvar.h>
     85  1.28  christos #include <sys/systm.h>
     86   1.1       cgd 
     87   1.8   mycroft #include <net/if.h>
     88   1.8   mycroft #include <net/route.h>
     89  1.38       mrg #include <net/pfil.h>
     90   1.1       cgd 
     91   1.8   mycroft #include <netinet/in.h>
     92   1.8   mycroft #include <netinet/in_systm.h>
     93   1.8   mycroft #include <netinet/ip.h>
     94   1.8   mycroft #include <netinet/in_pcb.h>
     95   1.8   mycroft #include <netinet/in_var.h>
     96   1.8   mycroft #include <netinet/ip_var.h>
     97  1.32       mrg 
     98  1.52      matt #ifdef __vax__
     99   1.8   mycroft #include <machine/mtpr.h>
    100   1.1       cgd #endif
    101   1.1       cgd 
    102  1.28  christos #include <machine/stdarg.h>
    103  1.28  christos 
    104  1.12   mycroft static struct mbuf *ip_insertoptions __P((struct mbuf *, struct mbuf *, int *));
    105  1.12   mycroft static void ip_mloopback
    106  1.18   mycroft 	__P((struct ifnet *, struct mbuf *, struct sockaddr_in *));
    107   1.1       cgd 
    108   1.1       cgd /*
    109   1.1       cgd  * IP output.  The packet in mbuf chain m contains a skeletal IP
    110   1.1       cgd  * header (with len, off, ttl, proto, tos, src, dst).
    111   1.1       cgd  * The mbuf chain containing the packet will be freed.
    112   1.1       cgd  * The mbuf opt, if present, will not be freed.
    113   1.1       cgd  */
    114  1.12   mycroft int
    115  1.28  christos #if __STDC__
    116  1.28  christos ip_output(struct mbuf *m0, ...)
    117  1.28  christos #else
    118  1.28  christos ip_output(m0, va_alist)
    119   1.1       cgd 	struct mbuf *m0;
    120  1.28  christos 	va_dcl
    121  1.28  christos #endif
    122   1.1       cgd {
    123   1.1       cgd 	register struct ip *ip, *mhip;
    124   1.1       cgd 	register struct ifnet *ifp;
    125   1.1       cgd 	register struct mbuf *m = m0;
    126   1.1       cgd 	register int hlen = sizeof (struct ip);
    127   1.1       cgd 	int len, off, error = 0;
    128   1.1       cgd 	struct route iproute;
    129   1.1       cgd 	struct sockaddr_in *dst;
    130   1.1       cgd 	struct in_ifaddr *ia;
    131  1.28  christos 	struct mbuf *opt;
    132  1.28  christos 	struct route *ro;
    133  1.28  christos 	int flags;
    134  1.40      matt 	int *mtu_p;
    135  1.48      matt 	int mtu;
    136  1.28  christos 	struct ip_moptions *imo;
    137  1.28  christos 	va_list ap;
    138  1.32       mrg #ifdef PFIL_HOOKS
    139  1.30       mrg 	struct packet_filter_hook *pfh;
    140  1.30       mrg 	struct mbuf *m1;
    141  1.36       mrg 	int rv;
    142  1.32       mrg #endif /* PFIL_HOOKS */
    143  1.28  christos 
    144  1.28  christos 	va_start(ap, m0);
    145  1.28  christos 	opt = va_arg(ap, struct mbuf *);
    146  1.28  christos 	ro = va_arg(ap, struct route *);
    147  1.28  christos 	flags = va_arg(ap, int);
    148  1.28  christos 	imo = va_arg(ap, struct ip_moptions *);
    149  1.40      matt 	if (flags & IP_RETURNMTU)
    150  1.40      matt 		mtu_p = va_arg(ap, int *);
    151  1.40      matt 	else
    152  1.40      matt 		mtu_p = NULL;
    153  1.28  christos 	va_end(ap);
    154  1.28  christos 
    155   1.1       cgd #ifdef	DIAGNOSTIC
    156   1.1       cgd 	if ((m->m_flags & M_PKTHDR) == 0)
    157   1.1       cgd 		panic("ip_output no HDR");
    158   1.1       cgd #endif
    159   1.1       cgd 	if (opt) {
    160   1.1       cgd 		m = ip_insertoptions(m, opt, &len);
    161   1.1       cgd 		hlen = len;
    162   1.1       cgd 	}
    163   1.1       cgd 	ip = mtod(m, struct ip *);
    164   1.1       cgd 	/*
    165   1.1       cgd 	 * Fill in IP header.
    166   1.1       cgd 	 */
    167  1.18   mycroft 	if ((flags & (IP_FORWARDING|IP_RAWOUTPUT)) == 0) {
    168   1.1       cgd 		ip->ip_v = IPVERSION;
    169   1.1       cgd 		ip->ip_off &= IP_DF;
    170   1.1       cgd 		ip->ip_id = htons(ip_id++);
    171   1.1       cgd 		ip->ip_hl = hlen >> 2;
    172  1.18   mycroft 		ipstat.ips_localout++;
    173   1.1       cgd 	} else {
    174   1.1       cgd 		hlen = ip->ip_hl << 2;
    175   1.1       cgd 	}
    176   1.1       cgd 	/*
    177   1.1       cgd 	 * Route packet.
    178   1.1       cgd 	 */
    179   1.1       cgd 	if (ro == 0) {
    180   1.1       cgd 		ro = &iproute;
    181   1.1       cgd 		bzero((caddr_t)ro, sizeof (*ro));
    182   1.1       cgd 	}
    183  1.24   mycroft 	dst = satosin(&ro->ro_dst);
    184   1.1       cgd 	/*
    185   1.1       cgd 	 * If there is a cached route,
    186   1.1       cgd 	 * check that it is to the same destination
    187   1.1       cgd 	 * and is still up.  If not, free it and try again.
    188   1.1       cgd 	 */
    189   1.1       cgd 	if (ro->ro_rt && ((ro->ro_rt->rt_flags & RTF_UP) == 0 ||
    190  1.31   mycroft 	    !in_hosteq(dst->sin_addr, ip->ip_dst))) {
    191   1.1       cgd 		RTFREE(ro->ro_rt);
    192   1.1       cgd 		ro->ro_rt = (struct rtentry *)0;
    193   1.1       cgd 	}
    194   1.1       cgd 	if (ro->ro_rt == 0) {
    195   1.1       cgd 		dst->sin_family = AF_INET;
    196   1.1       cgd 		dst->sin_len = sizeof(*dst);
    197   1.1       cgd 		dst->sin_addr = ip->ip_dst;
    198   1.1       cgd 	}
    199   1.1       cgd 	/*
    200   1.1       cgd 	 * If routing to interface only,
    201   1.1       cgd 	 * short circuit routing lookup.
    202   1.1       cgd 	 */
    203   1.1       cgd 	if (flags & IP_ROUTETOIF) {
    204  1.29       mrg 		if ((ia = ifatoia(ifa_ifwithladdr(sintosa(dst)))) == 0) {
    205  1.18   mycroft 			ipstat.ips_noroute++;
    206   1.1       cgd 			error = ENETUNREACH;
    207   1.1       cgd 			goto bad;
    208   1.1       cgd 		}
    209   1.1       cgd 		ifp = ia->ia_ifp;
    210  1.48      matt 		mtu = ifp->if_mtu;
    211  1.18   mycroft 		ip->ip_ttl = 1;
    212   1.1       cgd 	} else {
    213   1.1       cgd 		if (ro->ro_rt == 0)
    214   1.1       cgd 			rtalloc(ro);
    215   1.1       cgd 		if (ro->ro_rt == 0) {
    216  1.18   mycroft 			ipstat.ips_noroute++;
    217   1.1       cgd 			error = EHOSTUNREACH;
    218   1.1       cgd 			goto bad;
    219   1.1       cgd 		}
    220  1.18   mycroft 		ia = ifatoia(ro->ro_rt->rt_ifa);
    221   1.1       cgd 		ifp = ro->ro_rt->rt_ifp;
    222  1.48      matt 		if ((mtu = ro->ro_rt->rt_rmx.rmx_mtu) == 0)
    223  1.48      matt 			mtu = ifp->if_mtu;
    224   1.1       cgd 		ro->ro_rt->rt_use++;
    225   1.1       cgd 		if (ro->ro_rt->rt_flags & RTF_GATEWAY)
    226  1.24   mycroft 			dst = satosin(ro->ro_rt->rt_gateway);
    227   1.1       cgd 	}
    228  1.23   mycroft 	if (IN_MULTICAST(ip->ip_dst.s_addr)) {
    229   1.5   hpeyerl 		struct in_multi *inm;
    230   1.5   hpeyerl 
    231   1.5   hpeyerl 		m->m_flags |= M_MCAST;
    232   1.5   hpeyerl 		/*
    233   1.5   hpeyerl 		 * IP destination address is multicast.  Make sure "dst"
    234   1.5   hpeyerl 		 * still points to the address in "ro".  (It may have been
    235   1.5   hpeyerl 		 * changed to point to a gateway address, above.)
    236   1.5   hpeyerl 		 */
    237  1.24   mycroft 		dst = satosin(&ro->ro_dst);
    238   1.5   hpeyerl 		/*
    239   1.5   hpeyerl 		 * See if the caller provided any multicast options
    240   1.5   hpeyerl 		 */
    241  1.13   mycroft 		if (imo != NULL) {
    242   1.5   hpeyerl 			ip->ip_ttl = imo->imo_multicast_ttl;
    243  1.48      matt 			if (imo->imo_multicast_ifp != NULL) {
    244   1.5   hpeyerl 				ifp = imo->imo_multicast_ifp;
    245  1.48      matt 				mtu = ifp->if_mtu;
    246  1.48      matt 			}
    247  1.18   mycroft 		} else
    248   1.5   hpeyerl 			ip->ip_ttl = IP_DEFAULT_MULTICAST_TTL;
    249   1.5   hpeyerl 		/*
    250   1.5   hpeyerl 		 * Confirm that the outgoing interface supports multicast.
    251   1.5   hpeyerl 		 */
    252   1.5   hpeyerl 		if ((ifp->if_flags & IFF_MULTICAST) == 0) {
    253  1.18   mycroft 			ipstat.ips_noroute++;
    254   1.5   hpeyerl 			error = ENETUNREACH;
    255   1.5   hpeyerl 			goto bad;
    256   1.5   hpeyerl 		}
    257   1.5   hpeyerl 		/*
    258  1.44       tls 		 * If source address not specified yet, use an address
    259   1.5   hpeyerl 		 * of outgoing interface.
    260   1.5   hpeyerl 		 */
    261  1.31   mycroft 		if (in_nullhost(ip->ip_src)) {
    262   1.5   hpeyerl 			register struct in_ifaddr *ia;
    263   1.5   hpeyerl 
    264  1.44       tls 			IFP_TO_IA(ifp, ia);
    265  1.44       tls 			ip->ip_src = ia->ia_addr.sin_addr;
    266   1.5   hpeyerl 		}
    267   1.5   hpeyerl 
    268   1.5   hpeyerl 		IN_LOOKUP_MULTI(ip->ip_dst, ifp, inm);
    269   1.5   hpeyerl 		if (inm != NULL &&
    270   1.5   hpeyerl 		   (imo == NULL || imo->imo_multicast_loop)) {
    271   1.5   hpeyerl 			/*
    272  1.11   mycroft 			 * If we belong to the destination multicast group
    273   1.5   hpeyerl 			 * on the outgoing interface, and the caller did not
    274   1.5   hpeyerl 			 * forbid loopback, loop back a copy.
    275   1.5   hpeyerl 			 */
    276   1.5   hpeyerl 			ip_mloopback(ifp, m, dst);
    277   1.5   hpeyerl 		}
    278   1.5   hpeyerl #ifdef MROUTING
    279  1.18   mycroft 		else {
    280   1.5   hpeyerl 			/*
    281   1.5   hpeyerl 			 * If we are acting as a multicast router, perform
    282   1.5   hpeyerl 			 * multicast forwarding as if the packet had just
    283   1.5   hpeyerl 			 * arrived on the interface to which we are about
    284   1.5   hpeyerl 			 * to send.  The multicast forwarding function
    285   1.5   hpeyerl 			 * recursively calls this function, using the
    286   1.5   hpeyerl 			 * IP_FORWARDING flag to prevent infinite recursion.
    287   1.5   hpeyerl 			 *
    288   1.5   hpeyerl 			 * Multicasts that are looped back by ip_mloopback(),
    289   1.5   hpeyerl 			 * above, will be forwarded by the ip_input() routine,
    290   1.5   hpeyerl 			 * if necessary.
    291   1.5   hpeyerl 			 */
    292  1.18   mycroft 			extern struct socket *ip_mrouter;
    293  1.22       cgd 
    294  1.18   mycroft 			if (ip_mrouter && (flags & IP_FORWARDING) == 0) {
    295  1.18   mycroft 				if (ip_mforward(m, ifp) != 0) {
    296  1.18   mycroft 					m_freem(m);
    297  1.18   mycroft 					goto done;
    298  1.18   mycroft 				}
    299   1.5   hpeyerl 			}
    300   1.5   hpeyerl 		}
    301   1.5   hpeyerl #endif
    302   1.5   hpeyerl 		/*
    303   1.5   hpeyerl 		 * Multicasts with a time-to-live of zero may be looped-
    304   1.5   hpeyerl 		 * back, above, but must not be transmitted on a network.
    305   1.5   hpeyerl 		 * Also, multicasts addressed to the loopback interface
    306   1.5   hpeyerl 		 * are not sent -- the above call to ip_mloopback() will
    307   1.5   hpeyerl 		 * loop back a copy if this host actually belongs to the
    308   1.5   hpeyerl 		 * destination group on the loopback interface.
    309   1.5   hpeyerl 		 */
    310  1.20   mycroft 		if (ip->ip_ttl == 0 || (ifp->if_flags & IFF_LOOPBACK) != 0) {
    311   1.5   hpeyerl 			m_freem(m);
    312   1.5   hpeyerl 			goto done;
    313   1.5   hpeyerl 		}
    314   1.5   hpeyerl 
    315   1.5   hpeyerl 		goto sendit;
    316   1.5   hpeyerl 	}
    317   1.1       cgd #ifndef notdef
    318   1.1       cgd 	/*
    319   1.1       cgd 	 * If source address not specified yet, use address
    320   1.1       cgd 	 * of outgoing interface.
    321   1.1       cgd 	 */
    322  1.31   mycroft 	if (in_nullhost(ip->ip_src))
    323  1.25   mycroft 		ip->ip_src = ia->ia_addr.sin_addr;
    324   1.1       cgd #endif
    325   1.1       cgd 	/*
    326   1.1       cgd 	 * Look for broadcast address and
    327   1.1       cgd 	 * and verify user is allowed to send
    328   1.1       cgd 	 * such a packet.
    329   1.1       cgd 	 */
    330  1.18   mycroft 	if (in_broadcast(dst->sin_addr, ifp)) {
    331   1.1       cgd 		if ((ifp->if_flags & IFF_BROADCAST) == 0) {
    332   1.1       cgd 			error = EADDRNOTAVAIL;
    333   1.1       cgd 			goto bad;
    334   1.1       cgd 		}
    335   1.1       cgd 		if ((flags & IP_ALLOWBROADCAST) == 0) {
    336   1.1       cgd 			error = EACCES;
    337   1.1       cgd 			goto bad;
    338   1.1       cgd 		}
    339   1.1       cgd 		/* don't allow broadcast messages to be fragmented */
    340  1.21       cgd 		if ((u_int16_t)ip->ip_len > ifp->if_mtu) {
    341   1.1       cgd 			error = EMSGSIZE;
    342   1.1       cgd 			goto bad;
    343   1.1       cgd 		}
    344   1.1       cgd 		m->m_flags |= M_BCAST;
    345  1.18   mycroft 	} else
    346  1.18   mycroft 		m->m_flags &= ~M_BCAST;
    347  1.18   mycroft 
    348  1.32       mrg #ifdef PFIL_HOOKS
    349  1.30       mrg 	/*
    350  1.30       mrg 	 * Run through list of hooks for output packets.
    351  1.30       mrg 	 */
    352  1.30       mrg 	m1 = m;
    353  1.46       mrg 	for (pfh = pfil_hook_get(PFIL_OUT); pfh; pfh = pfh->pfil_link.tqe_next)
    354  1.30       mrg 		if (pfh->pfil_func) {
    355  1.36       mrg 		    	rv = pfh->pfil_func(ip, hlen, ifp, 1, &m1);
    356  1.36       mrg 			if (rv) {
    357  1.30       mrg 				error = EHOSTUNREACH;
    358  1.34     veego 				goto done;
    359  1.30       mrg 			}
    360  1.49  sommerfe 			m = m1;
    361  1.49  sommerfe 			if (m == NULL)
    362  1.49  sommerfe 				goto done;
    363  1.49  sommerfe 			ip = mtod(m, struct ip *);
    364  1.30       mrg 		}
    365  1.32       mrg #endif /* PFIL_HOOKS */
    366   1.5   hpeyerl sendit:
    367   1.1       cgd 	/*
    368  1.48      matt 	 * If small enough for mtu of path, can just send directly.
    369   1.1       cgd 	 */
    370  1.48      matt 	if ((u_int16_t)ip->ip_len <= mtu) {
    371  1.21       cgd 		ip->ip_len = htons((u_int16_t)ip->ip_len);
    372  1.21       cgd 		ip->ip_off = htons((u_int16_t)ip->ip_off);
    373   1.1       cgd 		ip->ip_sum = 0;
    374   1.1       cgd 		ip->ip_sum = in_cksum(m, hlen);
    375  1.24   mycroft 		error = (*ifp->if_output)(ifp, m, sintosa(dst), ro->ro_rt);
    376   1.1       cgd 		goto done;
    377   1.1       cgd 	}
    378   1.1       cgd 	/*
    379   1.1       cgd 	 * Too large for interface; fragment if possible.
    380   1.1       cgd 	 * Must be able to put at least 8 bytes per fragment.
    381   1.1       cgd 	 */
    382   1.1       cgd 	if (ip->ip_off & IP_DF) {
    383  1.40      matt 		if (flags & IP_RETURNMTU)
    384  1.48      matt 			*mtu_p = mtu;
    385   1.1       cgd 		error = EMSGSIZE;
    386  1.18   mycroft 		ipstat.ips_cantfrag++;
    387   1.1       cgd 		goto bad;
    388   1.1       cgd 	}
    389  1.48      matt 	len = (mtu - hlen) &~ 7;
    390   1.1       cgd 	if (len < 8) {
    391   1.1       cgd 		error = EMSGSIZE;
    392   1.1       cgd 		goto bad;
    393   1.1       cgd 	}
    394   1.1       cgd 
    395   1.1       cgd     {
    396   1.1       cgd 	int mhlen, firstlen = len;
    397   1.1       cgd 	struct mbuf **mnext = &m->m_nextpkt;
    398  1.48      matt 	int fragments = 0;
    399  1.48      matt 	int s;
    400   1.1       cgd 
    401   1.1       cgd 	/*
    402   1.1       cgd 	 * Loop through length of segment after first fragment,
    403   1.1       cgd 	 * make new header and copy data of each part and link onto chain.
    404   1.1       cgd 	 */
    405   1.1       cgd 	m0 = m;
    406   1.1       cgd 	mhlen = sizeof (struct ip);
    407  1.21       cgd 	for (off = hlen + len; off < (u_int16_t)ip->ip_len; off += len) {
    408   1.1       cgd 		MGETHDR(m, M_DONTWAIT, MT_HEADER);
    409   1.1       cgd 		if (m == 0) {
    410   1.1       cgd 			error = ENOBUFS;
    411  1.18   mycroft 			ipstat.ips_odropped++;
    412   1.1       cgd 			goto sendorfree;
    413   1.1       cgd 		}
    414  1.22       cgd 		*mnext = m;
    415  1.22       cgd 		mnext = &m->m_nextpkt;
    416   1.1       cgd 		m->m_data += max_linkhdr;
    417   1.1       cgd 		mhip = mtod(m, struct ip *);
    418   1.1       cgd 		*mhip = *ip;
    419   1.1       cgd 		if (hlen > sizeof (struct ip)) {
    420   1.1       cgd 			mhlen = ip_optcopy(ip, mhip) + sizeof (struct ip);
    421   1.1       cgd 			mhip->ip_hl = mhlen >> 2;
    422   1.1       cgd 		}
    423   1.1       cgd 		m->m_len = mhlen;
    424   1.1       cgd 		mhip->ip_off = ((off - hlen) >> 3) + (ip->ip_off & ~IP_MF);
    425   1.1       cgd 		if (ip->ip_off & IP_MF)
    426   1.1       cgd 			mhip->ip_off |= IP_MF;
    427  1.21       cgd 		if (off + len >= (u_int16_t)ip->ip_len)
    428  1.21       cgd 			len = (u_int16_t)ip->ip_len - off;
    429   1.1       cgd 		else
    430   1.1       cgd 			mhip->ip_off |= IP_MF;
    431  1.21       cgd 		mhip->ip_len = htons((u_int16_t)(len + mhlen));
    432   1.1       cgd 		m->m_next = m_copy(m0, off, len);
    433   1.1       cgd 		if (m->m_next == 0) {
    434   1.1       cgd 			error = ENOBUFS;	/* ??? */
    435  1.18   mycroft 			ipstat.ips_odropped++;
    436   1.1       cgd 			goto sendorfree;
    437   1.1       cgd 		}
    438   1.1       cgd 		m->m_pkthdr.len = mhlen + len;
    439   1.1       cgd 		m->m_pkthdr.rcvif = (struct ifnet *)0;
    440  1.21       cgd 		mhip->ip_off = htons((u_int16_t)mhip->ip_off);
    441   1.1       cgd 		mhip->ip_sum = 0;
    442   1.1       cgd 		mhip->ip_sum = in_cksum(m, mhlen);
    443   1.1       cgd 		ipstat.ips_ofragments++;
    444  1.48      matt 		fragments++;
    445   1.1       cgd 	}
    446   1.1       cgd 	/*
    447   1.1       cgd 	 * Update first fragment by trimming what's been copied out
    448   1.1       cgd 	 * and updating header, then send each fragment (in order).
    449   1.1       cgd 	 */
    450   1.1       cgd 	m = m0;
    451  1.21       cgd 	m_adj(m, hlen + firstlen - (u_int16_t)ip->ip_len);
    452   1.1       cgd 	m->m_pkthdr.len = hlen + firstlen;
    453  1.21       cgd 	ip->ip_len = htons((u_int16_t)m->m_pkthdr.len);
    454  1.21       cgd 	ip->ip_off = htons((u_int16_t)(ip->ip_off | IP_MF));
    455   1.1       cgd 	ip->ip_sum = 0;
    456   1.1       cgd 	ip->ip_sum = in_cksum(m, hlen);
    457   1.1       cgd sendorfree:
    458  1.48      matt 	/*
    459  1.48      matt 	 * If there is no room for all the fragments, don't queue
    460  1.48      matt 	 * any of them.
    461  1.48      matt 	 */
    462  1.48      matt 	s = splimp();
    463  1.48      matt 	if (ifp->if_snd.ifq_maxlen - ifp->if_snd.ifq_len < fragments)
    464  1.48      matt 		error = ENOBUFS;
    465  1.48      matt 	splx(s);
    466   1.1       cgd 	for (m = m0; m; m = m0) {
    467   1.1       cgd 		m0 = m->m_nextpkt;
    468   1.1       cgd 		m->m_nextpkt = 0;
    469   1.1       cgd 		if (error == 0)
    470  1.24   mycroft 			error = (*ifp->if_output)(ifp, m, sintosa(dst),
    471  1.24   mycroft 			    ro->ro_rt);
    472   1.1       cgd 		else
    473   1.1       cgd 			m_freem(m);
    474   1.1       cgd 	}
    475  1.18   mycroft 
    476  1.18   mycroft 	if (error == 0)
    477  1.18   mycroft 		ipstat.ips_fragmented++;
    478   1.1       cgd     }
    479   1.1       cgd done:
    480  1.31   mycroft 	if (ro == &iproute && (flags & IP_ROUTETOIF) == 0 && ro->ro_rt) {
    481   1.1       cgd 		RTFREE(ro->ro_rt);
    482  1.31   mycroft 		ro->ro_rt = 0;
    483  1.31   mycroft 	}
    484   1.1       cgd 	return (error);
    485   1.1       cgd bad:
    486  1.33        is 	m_freem(m);
    487   1.1       cgd 	goto done;
    488   1.1       cgd }
    489  1.47       kml 
    490  1.47       kml /*
    491  1.47       kml  * Determine the maximum length of the options to be inserted;
    492  1.47       kml  * we would far rather allocate too much space rather than too little.
    493  1.47       kml  */
    494  1.47       kml 
    495  1.47       kml u_int
    496  1.47       kml ip_optlen(inp)
    497  1.47       kml 	struct inpcb *inp;
    498  1.47       kml {
    499  1.47       kml 	struct mbuf *m = inp->inp_options;
    500  1.47       kml 
    501  1.47       kml 	if (m && m->m_len > offsetof(struct ipoption, ipopt_dst))
    502  1.47       kml 		return(m->m_len - offsetof(struct ipoption, ipopt_dst));
    503  1.47       kml 	else
    504  1.47       kml 		return 0;
    505  1.47       kml }
    506  1.47       kml 
    507   1.1       cgd 
    508   1.1       cgd /*
    509   1.1       cgd  * Insert IP options into preformed packet.
    510   1.1       cgd  * Adjust IP destination as required for IP source routing,
    511   1.1       cgd  * as indicated by a non-zero in_addr at the start of the options.
    512   1.1       cgd  */
    513  1.12   mycroft static struct mbuf *
    514   1.1       cgd ip_insertoptions(m, opt, phlen)
    515   1.1       cgd 	register struct mbuf *m;
    516   1.1       cgd 	struct mbuf *opt;
    517   1.1       cgd 	int *phlen;
    518   1.1       cgd {
    519   1.1       cgd 	register struct ipoption *p = mtod(opt, struct ipoption *);
    520   1.1       cgd 	struct mbuf *n;
    521   1.1       cgd 	register struct ip *ip = mtod(m, struct ip *);
    522   1.1       cgd 	unsigned optlen;
    523   1.1       cgd 
    524   1.1       cgd 	optlen = opt->m_len - sizeof(p->ipopt_dst);
    525  1.21       cgd 	if (optlen + (u_int16_t)ip->ip_len > IP_MAXPACKET)
    526   1.1       cgd 		return (m);		/* XXX should fail */
    527  1.31   mycroft 	if (!in_nullhost(p->ipopt_dst))
    528   1.1       cgd 		ip->ip_dst = p->ipopt_dst;
    529   1.1       cgd 	if (m->m_flags & M_EXT || m->m_data - optlen < m->m_pktdat) {
    530   1.1       cgd 		MGETHDR(n, M_DONTWAIT, MT_HEADER);
    531   1.1       cgd 		if (n == 0)
    532   1.1       cgd 			return (m);
    533   1.1       cgd 		n->m_pkthdr.len = m->m_pkthdr.len + optlen;
    534   1.1       cgd 		m->m_len -= sizeof(struct ip);
    535   1.1       cgd 		m->m_data += sizeof(struct ip);
    536   1.1       cgd 		n->m_next = m;
    537   1.1       cgd 		m = n;
    538   1.1       cgd 		m->m_len = optlen + sizeof(struct ip);
    539   1.1       cgd 		m->m_data += max_linkhdr;
    540   1.1       cgd 		bcopy((caddr_t)ip, mtod(m, caddr_t), sizeof(struct ip));
    541   1.1       cgd 	} else {
    542   1.1       cgd 		m->m_data -= optlen;
    543   1.1       cgd 		m->m_len += optlen;
    544   1.1       cgd 		m->m_pkthdr.len += optlen;
    545   1.1       cgd 		ovbcopy((caddr_t)ip, mtod(m, caddr_t), sizeof(struct ip));
    546   1.1       cgd 	}
    547   1.1       cgd 	ip = mtod(m, struct ip *);
    548   1.1       cgd 	bcopy((caddr_t)p->ipopt_list, (caddr_t)(ip + 1), (unsigned)optlen);
    549   1.1       cgd 	*phlen = sizeof(struct ip) + optlen;
    550   1.1       cgd 	ip->ip_len += optlen;
    551   1.1       cgd 	return (m);
    552   1.1       cgd }
    553   1.1       cgd 
    554   1.1       cgd /*
    555   1.1       cgd  * Copy options from ip to jp,
    556   1.1       cgd  * omitting those not copied during fragmentation.
    557   1.1       cgd  */
    558  1.12   mycroft int
    559   1.1       cgd ip_optcopy(ip, jp)
    560   1.1       cgd 	struct ip *ip, *jp;
    561   1.1       cgd {
    562   1.1       cgd 	register u_char *cp, *dp;
    563   1.1       cgd 	int opt, optlen, cnt;
    564   1.1       cgd 
    565   1.1       cgd 	cp = (u_char *)(ip + 1);
    566   1.1       cgd 	dp = (u_char *)(jp + 1);
    567   1.1       cgd 	cnt = (ip->ip_hl << 2) - sizeof (struct ip);
    568   1.1       cgd 	for (; cnt > 0; cnt -= optlen, cp += optlen) {
    569   1.1       cgd 		opt = cp[0];
    570   1.1       cgd 		if (opt == IPOPT_EOL)
    571   1.1       cgd 			break;
    572  1.18   mycroft 		if (opt == IPOPT_NOP) {
    573  1.18   mycroft 			/* Preserve for IP mcast tunnel's LSRR alignment. */
    574  1.18   mycroft 			*dp++ = IPOPT_NOP;
    575   1.1       cgd 			optlen = 1;
    576  1.18   mycroft 			continue;
    577  1.18   mycroft 		} else
    578   1.1       cgd 			optlen = cp[IPOPT_OLEN];
    579   1.1       cgd 		/* bogus lengths should have been caught by ip_dooptions */
    580   1.1       cgd 		if (optlen > cnt)
    581   1.1       cgd 			optlen = cnt;
    582   1.1       cgd 		if (IPOPT_COPIED(opt)) {
    583   1.1       cgd 			bcopy((caddr_t)cp, (caddr_t)dp, (unsigned)optlen);
    584   1.1       cgd 			dp += optlen;
    585   1.1       cgd 		}
    586   1.1       cgd 	}
    587   1.1       cgd 	for (optlen = dp - (u_char *)(jp+1); optlen & 0x3; optlen++)
    588   1.1       cgd 		*dp++ = IPOPT_EOL;
    589   1.1       cgd 	return (optlen);
    590   1.1       cgd }
    591   1.1       cgd 
    592   1.1       cgd /*
    593   1.1       cgd  * IP socket option processing.
    594   1.1       cgd  */
    595  1.12   mycroft int
    596   1.1       cgd ip_ctloutput(op, so, level, optname, mp)
    597   1.1       cgd 	int op;
    598   1.1       cgd 	struct socket *so;
    599   1.1       cgd 	int level, optname;
    600   1.1       cgd 	struct mbuf **mp;
    601   1.1       cgd {
    602   1.1       cgd 	register struct inpcb *inp = sotoinpcb(so);
    603  1.16    brezak 	register struct mbuf *m = *mp;
    604  1.28  christos 	register int optval = 0;
    605   1.1       cgd 	int error = 0;
    606   1.1       cgd 
    607  1.18   mycroft 	if (level != IPPROTO_IP) {
    608   1.1       cgd 		error = EINVAL;
    609  1.18   mycroft 		if (op == PRCO_SETOPT && *mp)
    610  1.18   mycroft 			(void) m_free(*mp);
    611  1.18   mycroft 	} else switch (op) {
    612   1.1       cgd 
    613   1.1       cgd 	case PRCO_SETOPT:
    614   1.1       cgd 		switch (optname) {
    615   1.1       cgd 		case IP_OPTIONS:
    616   1.1       cgd #ifdef notyet
    617   1.1       cgd 		case IP_RETOPTS:
    618   1.1       cgd 			return (ip_pcbopts(optname, &inp->inp_options, m));
    619   1.1       cgd #else
    620   1.1       cgd 			return (ip_pcbopts(&inp->inp_options, m));
    621   1.1       cgd #endif
    622   1.1       cgd 
    623   1.1       cgd 		case IP_TOS:
    624   1.1       cgd 		case IP_TTL:
    625   1.1       cgd 		case IP_RECVOPTS:
    626   1.1       cgd 		case IP_RECVRETOPTS:
    627   1.1       cgd 		case IP_RECVDSTADDR:
    628  1.37   thorpej 		case IP_RECVIF:
    629  1.27       cgd 			if (m == NULL || m->m_len != sizeof(int))
    630   1.1       cgd 				error = EINVAL;
    631   1.1       cgd 			else {
    632   1.1       cgd 				optval = *mtod(m, int *);
    633   1.1       cgd 				switch (optname) {
    634   1.1       cgd 
    635   1.1       cgd 				case IP_TOS:
    636   1.1       cgd 					inp->inp_ip.ip_tos = optval;
    637   1.1       cgd 					break;
    638   1.1       cgd 
    639   1.1       cgd 				case IP_TTL:
    640   1.1       cgd 					inp->inp_ip.ip_ttl = optval;
    641   1.1       cgd 					break;
    642   1.1       cgd #define	OPTSET(bit) \
    643   1.1       cgd 	if (optval) \
    644   1.1       cgd 		inp->inp_flags |= bit; \
    645   1.1       cgd 	else \
    646   1.1       cgd 		inp->inp_flags &= ~bit;
    647   1.1       cgd 
    648   1.1       cgd 				case IP_RECVOPTS:
    649   1.1       cgd 					OPTSET(INP_RECVOPTS);
    650   1.1       cgd 					break;
    651   1.1       cgd 
    652   1.1       cgd 				case IP_RECVRETOPTS:
    653   1.1       cgd 					OPTSET(INP_RECVRETOPTS);
    654   1.1       cgd 					break;
    655   1.1       cgd 
    656   1.1       cgd 				case IP_RECVDSTADDR:
    657   1.1       cgd 					OPTSET(INP_RECVDSTADDR);
    658   1.1       cgd 					break;
    659  1.37   thorpej 
    660  1.37   thorpej 				case IP_RECVIF:
    661  1.37   thorpej 					OPTSET(INP_RECVIF);
    662  1.37   thorpej 					break;
    663   1.1       cgd 				}
    664   1.1       cgd 			}
    665   1.1       cgd 			break;
    666   1.1       cgd #undef OPTSET
    667  1.18   mycroft 
    668  1.18   mycroft 		case IP_MULTICAST_IF:
    669  1.18   mycroft 		case IP_MULTICAST_TTL:
    670  1.18   mycroft 		case IP_MULTICAST_LOOP:
    671  1.18   mycroft 		case IP_ADD_MEMBERSHIP:
    672  1.18   mycroft 		case IP_DROP_MEMBERSHIP:
    673  1.18   mycroft 			error = ip_setmoptions(optname, &inp->inp_moptions, m);
    674  1.18   mycroft 			break;
    675   1.1       cgd 
    676  1.41     lukem 		case IP_PORTRANGE:
    677  1.41     lukem 			if (m == 0 || m->m_len != sizeof(int))
    678  1.41     lukem 				error = EINVAL;
    679  1.41     lukem 			else {
    680  1.41     lukem 				optval = *mtod(m, int *);
    681  1.41     lukem 
    682  1.41     lukem 				switch (optval) {
    683  1.41     lukem 
    684  1.41     lukem 				case IP_PORTRANGE_DEFAULT:
    685  1.41     lukem 				case IP_PORTRANGE_HIGH:
    686  1.41     lukem 					inp->inp_flags &= ~(INP_LOWPORT);
    687  1.41     lukem 					break;
    688  1.41     lukem 
    689  1.41     lukem 				case IP_PORTRANGE_LOW:
    690  1.41     lukem 					inp->inp_flags |= INP_LOWPORT;
    691  1.41     lukem 					break;
    692  1.41     lukem 
    693  1.41     lukem 				default:
    694  1.41     lukem 					error = EINVAL;
    695  1.41     lukem 					break;
    696  1.41     lukem 				}
    697  1.41     lukem 			}
    698  1.41     lukem 			break;
    699  1.41     lukem 
    700   1.1       cgd 		default:
    701  1.18   mycroft 			error = ENOPROTOOPT;
    702   1.1       cgd 			break;
    703   1.1       cgd 		}
    704   1.1       cgd 		if (m)
    705   1.1       cgd 			(void)m_free(m);
    706   1.1       cgd 		break;
    707   1.1       cgd 
    708   1.1       cgd 	case PRCO_GETOPT:
    709   1.1       cgd 		switch (optname) {
    710   1.1       cgd 		case IP_OPTIONS:
    711   1.1       cgd 		case IP_RETOPTS:
    712   1.1       cgd 			*mp = m = m_get(M_WAIT, MT_SOOPTS);
    713   1.1       cgd 			if (inp->inp_options) {
    714   1.1       cgd 				m->m_len = inp->inp_options->m_len;
    715   1.1       cgd 				bcopy(mtod(inp->inp_options, caddr_t),
    716   1.1       cgd 				    mtod(m, caddr_t), (unsigned)m->m_len);
    717   1.1       cgd 			} else
    718   1.1       cgd 				m->m_len = 0;
    719   1.1       cgd 			break;
    720   1.1       cgd 
    721   1.1       cgd 		case IP_TOS:
    722   1.1       cgd 		case IP_TTL:
    723   1.1       cgd 		case IP_RECVOPTS:
    724   1.1       cgd 		case IP_RECVRETOPTS:
    725   1.1       cgd 		case IP_RECVDSTADDR:
    726  1.37   thorpej 		case IP_RECVIF:
    727  1.40      matt 		case IP_ERRORMTU:
    728   1.1       cgd 			*mp = m = m_get(M_WAIT, MT_SOOPTS);
    729   1.1       cgd 			m->m_len = sizeof(int);
    730   1.1       cgd 			switch (optname) {
    731   1.1       cgd 
    732   1.1       cgd 			case IP_TOS:
    733   1.1       cgd 				optval = inp->inp_ip.ip_tos;
    734   1.1       cgd 				break;
    735   1.1       cgd 
    736   1.1       cgd 			case IP_TTL:
    737   1.1       cgd 				optval = inp->inp_ip.ip_ttl;
    738  1.40      matt 				break;
    739  1.40      matt 
    740  1.40      matt 			case IP_ERRORMTU:
    741  1.40      matt 				optval = inp->inp_errormtu;
    742   1.1       cgd 				break;
    743   1.1       cgd 
    744   1.1       cgd #define	OPTBIT(bit)	(inp->inp_flags & bit ? 1 : 0)
    745   1.1       cgd 
    746   1.1       cgd 			case IP_RECVOPTS:
    747   1.1       cgd 				optval = OPTBIT(INP_RECVOPTS);
    748   1.1       cgd 				break;
    749   1.1       cgd 
    750   1.1       cgd 			case IP_RECVRETOPTS:
    751   1.1       cgd 				optval = OPTBIT(INP_RECVRETOPTS);
    752   1.1       cgd 				break;
    753   1.1       cgd 
    754   1.1       cgd 			case IP_RECVDSTADDR:
    755   1.1       cgd 				optval = OPTBIT(INP_RECVDSTADDR);
    756  1.37   thorpej 				break;
    757  1.37   thorpej 
    758  1.37   thorpej 			case IP_RECVIF:
    759  1.37   thorpej 				optval = OPTBIT(INP_RECVIF);
    760   1.1       cgd 				break;
    761   1.1       cgd 			}
    762   1.1       cgd 			*mtod(m, int *) = optval;
    763   1.1       cgd 			break;
    764  1.18   mycroft 
    765  1.18   mycroft 		case IP_MULTICAST_IF:
    766  1.18   mycroft 		case IP_MULTICAST_TTL:
    767  1.18   mycroft 		case IP_MULTICAST_LOOP:
    768  1.18   mycroft 		case IP_ADD_MEMBERSHIP:
    769  1.18   mycroft 		case IP_DROP_MEMBERSHIP:
    770  1.18   mycroft 			error = ip_getmoptions(optname, inp->inp_moptions, mp);
    771  1.41     lukem 			break;
    772  1.41     lukem 
    773  1.41     lukem 		case IP_PORTRANGE:
    774  1.41     lukem 			*mp = m = m_get(M_WAIT, MT_SOOPTS);
    775  1.41     lukem 			m->m_len = sizeof(int);
    776  1.41     lukem 
    777  1.41     lukem 			if (inp->inp_flags & INP_LOWPORT)
    778  1.41     lukem 				optval = IP_PORTRANGE_LOW;
    779  1.41     lukem 			else
    780  1.41     lukem 				optval = IP_PORTRANGE_DEFAULT;
    781  1.41     lukem 
    782  1.41     lukem 			*mtod(m, int *) = optval;
    783  1.18   mycroft 			break;
    784   1.1       cgd 
    785   1.1       cgd 		default:
    786  1.18   mycroft 			error = ENOPROTOOPT;
    787   1.1       cgd 			break;
    788   1.1       cgd 		}
    789   1.1       cgd 		break;
    790   1.1       cgd 	}
    791   1.1       cgd 	return (error);
    792   1.1       cgd }
    793   1.1       cgd 
    794   1.1       cgd /*
    795   1.1       cgd  * Set up IP options in pcb for insertion in output packets.
    796   1.1       cgd  * Store in mbuf with pointer in pcbopt, adding pseudo-option
    797   1.1       cgd  * with destination address if source routed.
    798   1.1       cgd  */
    799  1.12   mycroft int
    800   1.1       cgd #ifdef notyet
    801   1.1       cgd ip_pcbopts(optname, pcbopt, m)
    802   1.1       cgd 	int optname;
    803   1.1       cgd #else
    804   1.1       cgd ip_pcbopts(pcbopt, m)
    805   1.1       cgd #endif
    806   1.1       cgd 	struct mbuf **pcbopt;
    807   1.1       cgd 	register struct mbuf *m;
    808   1.1       cgd {
    809  1.43    kleink 	register int cnt, optlen;
    810   1.1       cgd 	register u_char *cp;
    811   1.1       cgd 	u_char opt;
    812   1.1       cgd 
    813   1.1       cgd 	/* turn off any old options */
    814   1.1       cgd 	if (*pcbopt)
    815   1.1       cgd 		(void)m_free(*pcbopt);
    816   1.1       cgd 	*pcbopt = 0;
    817   1.1       cgd 	if (m == (struct mbuf *)0 || m->m_len == 0) {
    818   1.1       cgd 		/*
    819   1.1       cgd 		 * Only turning off any previous options.
    820   1.1       cgd 		 */
    821   1.1       cgd 		if (m)
    822   1.1       cgd 			(void)m_free(m);
    823   1.1       cgd 		return (0);
    824   1.1       cgd 	}
    825   1.1       cgd 
    826   1.1       cgd #ifndef	vax
    827  1.21       cgd 	if (m->m_len % sizeof(int32_t))
    828   1.1       cgd 		goto bad;
    829   1.1       cgd #endif
    830   1.1       cgd 	/*
    831   1.1       cgd 	 * IP first-hop destination address will be stored before
    832   1.1       cgd 	 * actual options; move other options back
    833   1.1       cgd 	 * and clear it when none present.
    834   1.1       cgd 	 */
    835   1.1       cgd 	if (m->m_data + m->m_len + sizeof(struct in_addr) >= &m->m_dat[MLEN])
    836   1.1       cgd 		goto bad;
    837   1.1       cgd 	cnt = m->m_len;
    838   1.1       cgd 	m->m_len += sizeof(struct in_addr);
    839   1.1       cgd 	cp = mtod(m, u_char *) + sizeof(struct in_addr);
    840   1.1       cgd 	ovbcopy(mtod(m, caddr_t), (caddr_t)cp, (unsigned)cnt);
    841   1.1       cgd 	bzero(mtod(m, caddr_t), sizeof(struct in_addr));
    842   1.1       cgd 
    843   1.1       cgd 	for (; cnt > 0; cnt -= optlen, cp += optlen) {
    844   1.1       cgd 		opt = cp[IPOPT_OPTVAL];
    845   1.1       cgd 		if (opt == IPOPT_EOL)
    846   1.1       cgd 			break;
    847   1.1       cgd 		if (opt == IPOPT_NOP)
    848   1.1       cgd 			optlen = 1;
    849   1.1       cgd 		else {
    850   1.1       cgd 			optlen = cp[IPOPT_OLEN];
    851   1.1       cgd 			if (optlen <= IPOPT_OLEN || optlen > cnt)
    852   1.1       cgd 				goto bad;
    853   1.1       cgd 		}
    854   1.1       cgd 		switch (opt) {
    855   1.1       cgd 
    856   1.1       cgd 		default:
    857   1.1       cgd 			break;
    858   1.1       cgd 
    859   1.1       cgd 		case IPOPT_LSRR:
    860   1.1       cgd 		case IPOPT_SSRR:
    861   1.1       cgd 			/*
    862   1.1       cgd 			 * user process specifies route as:
    863   1.1       cgd 			 *	->A->B->C->D
    864   1.1       cgd 			 * D must be our final destination (but we can't
    865   1.1       cgd 			 * check that since we may not have connected yet).
    866   1.1       cgd 			 * A is first hop destination, which doesn't appear in
    867   1.1       cgd 			 * actual IP option, but is stored before the options.
    868   1.1       cgd 			 */
    869   1.1       cgd 			if (optlen < IPOPT_MINOFF - 1 + sizeof(struct in_addr))
    870   1.1       cgd 				goto bad;
    871   1.1       cgd 			m->m_len -= sizeof(struct in_addr);
    872   1.1       cgd 			cnt -= sizeof(struct in_addr);
    873   1.1       cgd 			optlen -= sizeof(struct in_addr);
    874   1.1       cgd 			cp[IPOPT_OLEN] = optlen;
    875   1.1       cgd 			/*
    876   1.1       cgd 			 * Move first hop before start of options.
    877   1.1       cgd 			 */
    878   1.1       cgd 			bcopy((caddr_t)&cp[IPOPT_OFFSET+1], mtod(m, caddr_t),
    879   1.1       cgd 			    sizeof(struct in_addr));
    880   1.1       cgd 			/*
    881   1.1       cgd 			 * Then copy rest of options back
    882   1.1       cgd 			 * to close up the deleted entry.
    883   1.1       cgd 			 */
    884   1.1       cgd 			ovbcopy((caddr_t)(&cp[IPOPT_OFFSET+1] +
    885   1.1       cgd 			    sizeof(struct in_addr)),
    886   1.1       cgd 			    (caddr_t)&cp[IPOPT_OFFSET+1],
    887   1.1       cgd 			    (unsigned)cnt + sizeof(struct in_addr));
    888   1.1       cgd 			break;
    889   1.1       cgd 		}
    890   1.1       cgd 	}
    891   1.1       cgd 	if (m->m_len > MAX_IPOPTLEN + sizeof(struct in_addr))
    892   1.1       cgd 		goto bad;
    893   1.1       cgd 	*pcbopt = m;
    894   1.1       cgd 	return (0);
    895   1.1       cgd 
    896   1.1       cgd bad:
    897   1.1       cgd 	(void)m_free(m);
    898   1.1       cgd 	return (EINVAL);
    899   1.1       cgd }
    900   1.5   hpeyerl 
    901   1.5   hpeyerl /*
    902   1.5   hpeyerl  * Set the IP multicast options in response to user setsockopt().
    903   1.5   hpeyerl  */
    904   1.5   hpeyerl int
    905   1.5   hpeyerl ip_setmoptions(optname, imop, m)
    906   1.5   hpeyerl 	int optname;
    907   1.5   hpeyerl 	struct ip_moptions **imop;
    908   1.5   hpeyerl 	struct mbuf *m;
    909   1.5   hpeyerl {
    910   1.5   hpeyerl 	register int error = 0;
    911   1.5   hpeyerl 	u_char loop;
    912   1.5   hpeyerl 	register int i;
    913   1.5   hpeyerl 	struct in_addr addr;
    914   1.5   hpeyerl 	register struct ip_mreq *mreq;
    915   1.5   hpeyerl 	register struct ifnet *ifp;
    916   1.5   hpeyerl 	register struct ip_moptions *imo = *imop;
    917   1.5   hpeyerl 	struct route ro;
    918   1.5   hpeyerl 	register struct sockaddr_in *dst;
    919   1.5   hpeyerl 
    920   1.5   hpeyerl 	if (imo == NULL) {
    921   1.5   hpeyerl 		/*
    922   1.5   hpeyerl 		 * No multicast option buffer attached to the pcb;
    923   1.5   hpeyerl 		 * allocate one and initialize to default values.
    924   1.5   hpeyerl 		 */
    925  1.22       cgd 		imo = (struct ip_moptions *)malloc(sizeof(*imo), M_IPMOPTS,
    926   1.5   hpeyerl 		    M_WAITOK);
    927   1.5   hpeyerl 
    928   1.5   hpeyerl 		if (imo == NULL)
    929   1.5   hpeyerl 			return (ENOBUFS);
    930   1.5   hpeyerl 		*imop = imo;
    931   1.5   hpeyerl 		imo->imo_multicast_ifp = NULL;
    932   1.5   hpeyerl 		imo->imo_multicast_ttl = IP_DEFAULT_MULTICAST_TTL;
    933   1.5   hpeyerl 		imo->imo_multicast_loop = IP_DEFAULT_MULTICAST_LOOP;
    934   1.5   hpeyerl 		imo->imo_num_memberships = 0;
    935   1.5   hpeyerl 	}
    936   1.5   hpeyerl 
    937   1.5   hpeyerl 	switch (optname) {
    938   1.5   hpeyerl 
    939   1.5   hpeyerl 	case IP_MULTICAST_IF:
    940   1.5   hpeyerl 		/*
    941   1.5   hpeyerl 		 * Select the interface for outgoing multicast packets.
    942   1.5   hpeyerl 		 */
    943   1.5   hpeyerl 		if (m == NULL || m->m_len != sizeof(struct in_addr)) {
    944   1.5   hpeyerl 			error = EINVAL;
    945   1.5   hpeyerl 			break;
    946   1.5   hpeyerl 		}
    947   1.5   hpeyerl 		addr = *(mtod(m, struct in_addr *));
    948   1.5   hpeyerl 		/*
    949   1.5   hpeyerl 		 * INADDR_ANY is used to remove a previous selection.
    950  1.11   mycroft 		 * When no interface is selected, a default one is
    951   1.5   hpeyerl 		 * chosen every time a multicast packet is sent.
    952   1.5   hpeyerl 		 */
    953  1.31   mycroft 		if (in_nullhost(addr)) {
    954   1.5   hpeyerl 			imo->imo_multicast_ifp = NULL;
    955   1.5   hpeyerl 			break;
    956   1.5   hpeyerl 		}
    957   1.5   hpeyerl 		/*
    958   1.5   hpeyerl 		 * The selected interface is identified by its local
    959   1.5   hpeyerl 		 * IP address.  Find the interface and confirm that
    960  1.11   mycroft 		 * it supports multicasting.
    961   1.5   hpeyerl 		 */
    962   1.5   hpeyerl 		INADDR_TO_IFP(addr, ifp);
    963   1.5   hpeyerl 		if (ifp == NULL || (ifp->if_flags & IFF_MULTICAST) == 0) {
    964   1.5   hpeyerl 			error = EADDRNOTAVAIL;
    965   1.5   hpeyerl 			break;
    966   1.5   hpeyerl 		}
    967   1.5   hpeyerl 		imo->imo_multicast_ifp = ifp;
    968   1.5   hpeyerl 		break;
    969   1.5   hpeyerl 
    970   1.5   hpeyerl 	case IP_MULTICAST_TTL:
    971   1.5   hpeyerl 		/*
    972   1.5   hpeyerl 		 * Set the IP time-to-live for outgoing multicast packets.
    973   1.5   hpeyerl 		 */
    974   1.5   hpeyerl 		if (m == NULL || m->m_len != 1) {
    975   1.5   hpeyerl 			error = EINVAL;
    976   1.5   hpeyerl 			break;
    977   1.5   hpeyerl 		}
    978   1.5   hpeyerl 		imo->imo_multicast_ttl = *(mtod(m, u_char *));
    979   1.5   hpeyerl 		break;
    980  1.11   mycroft 
    981   1.5   hpeyerl 	case IP_MULTICAST_LOOP:
    982   1.5   hpeyerl 		/*
    983   1.5   hpeyerl 		 * Set the loopback flag for outgoing multicast packets.
    984   1.5   hpeyerl 		 * Must be zero or one.
    985   1.5   hpeyerl 		 */
    986   1.5   hpeyerl 		if (m == NULL || m->m_len != 1 ||
    987   1.5   hpeyerl 		   (loop = *(mtod(m, u_char *))) > 1) {
    988   1.5   hpeyerl 			error = EINVAL;
    989   1.5   hpeyerl 			break;
    990  1.11   mycroft 		}
    991   1.5   hpeyerl 		imo->imo_multicast_loop = loop;
    992   1.5   hpeyerl 		break;
    993   1.5   hpeyerl 
    994   1.5   hpeyerl 	case IP_ADD_MEMBERSHIP:
    995   1.5   hpeyerl 		/*
    996   1.5   hpeyerl 		 * Add a multicast group membership.
    997   1.5   hpeyerl 		 * Group must be a valid IP multicast address.
    998   1.5   hpeyerl 		 */
    999   1.5   hpeyerl 		if (m == NULL || m->m_len != sizeof(struct ip_mreq)) {
   1000   1.5   hpeyerl 			error = EINVAL;
   1001   1.5   hpeyerl 			break;
   1002   1.5   hpeyerl 		}
   1003   1.5   hpeyerl 		mreq = mtod(m, struct ip_mreq *);
   1004  1.23   mycroft 		if (!IN_MULTICAST(mreq->imr_multiaddr.s_addr)) {
   1005   1.5   hpeyerl 			error = EINVAL;
   1006   1.5   hpeyerl 			break;
   1007   1.5   hpeyerl 		}
   1008   1.5   hpeyerl 		/*
   1009   1.5   hpeyerl 		 * If no interface address was provided, use the interface of
   1010   1.5   hpeyerl 		 * the route to the given multicast address.
   1011   1.5   hpeyerl 		 */
   1012  1.31   mycroft 		if (in_nullhost(mreq->imr_interface)) {
   1013  1.53        ws 			bzero((caddr_t)&ro, sizeof(ro));
   1014   1.5   hpeyerl 			ro.ro_rt = NULL;
   1015  1.24   mycroft 			dst = satosin(&ro.ro_dst);
   1016   1.5   hpeyerl 			dst->sin_len = sizeof(*dst);
   1017   1.5   hpeyerl 			dst->sin_family = AF_INET;
   1018   1.5   hpeyerl 			dst->sin_addr = mreq->imr_multiaddr;
   1019   1.5   hpeyerl 			rtalloc(&ro);
   1020   1.5   hpeyerl 			if (ro.ro_rt == NULL) {
   1021   1.5   hpeyerl 				error = EADDRNOTAVAIL;
   1022   1.5   hpeyerl 				break;
   1023   1.5   hpeyerl 			}
   1024   1.5   hpeyerl 			ifp = ro.ro_rt->rt_ifp;
   1025   1.5   hpeyerl 			rtfree(ro.ro_rt);
   1026  1.23   mycroft 		} else {
   1027   1.5   hpeyerl 			INADDR_TO_IFP(mreq->imr_interface, ifp);
   1028   1.5   hpeyerl 		}
   1029   1.5   hpeyerl 		/*
   1030   1.5   hpeyerl 		 * See if we found an interface, and confirm that it
   1031   1.5   hpeyerl 		 * supports multicast.
   1032   1.5   hpeyerl 		 */
   1033  1.11   mycroft 		if (ifp == NULL || (ifp->if_flags & IFF_MULTICAST) == 0) {
   1034   1.5   hpeyerl 			error = EADDRNOTAVAIL;
   1035   1.5   hpeyerl 			break;
   1036   1.5   hpeyerl 		}
   1037   1.5   hpeyerl 		/*
   1038   1.5   hpeyerl 		 * See if the membership already exists or if all the
   1039   1.5   hpeyerl 		 * membership slots are full.
   1040  1.11   mycroft 		 */
   1041   1.5   hpeyerl 		for (i = 0; i < imo->imo_num_memberships; ++i) {
   1042   1.5   hpeyerl 			if (imo->imo_membership[i]->inm_ifp == ifp &&
   1043  1.31   mycroft 			    in_hosteq(imo->imo_membership[i]->inm_addr,
   1044  1.31   mycroft 				      mreq->imr_multiaddr))
   1045   1.5   hpeyerl 				break;
   1046  1.11   mycroft 		}
   1047   1.5   hpeyerl 		if (i < imo->imo_num_memberships) {
   1048   1.5   hpeyerl 			error = EADDRINUSE;
   1049   1.5   hpeyerl 			break;
   1050   1.5   hpeyerl 		}
   1051   1.5   hpeyerl 		if (i == IP_MAX_MEMBERSHIPS) {
   1052  1.11   mycroft 			error = ETOOMANYREFS;
   1053   1.5   hpeyerl 			break;
   1054   1.5   hpeyerl 		}
   1055   1.5   hpeyerl 		/*
   1056   1.5   hpeyerl 		 * Everything looks good; add a new record to the multicast
   1057   1.5   hpeyerl 		 * address list for the given interface.
   1058   1.5   hpeyerl 		 */
   1059   1.5   hpeyerl 		if ((imo->imo_membership[i] =
   1060   1.5   hpeyerl 		    in_addmulti(&mreq->imr_multiaddr, ifp)) == NULL) {
   1061   1.5   hpeyerl 			error = ENOBUFS;
   1062   1.5   hpeyerl 			break;
   1063   1.5   hpeyerl 		}
   1064   1.5   hpeyerl 		++imo->imo_num_memberships;
   1065   1.5   hpeyerl 		break;
   1066   1.5   hpeyerl 
   1067   1.5   hpeyerl 	case IP_DROP_MEMBERSHIP:
   1068   1.5   hpeyerl 		/*
   1069   1.5   hpeyerl 		 * Drop a multicast group membership.
   1070   1.5   hpeyerl 		 * Group must be a valid IP multicast address.
   1071   1.5   hpeyerl 		 */
   1072   1.5   hpeyerl 		if (m == NULL || m->m_len != sizeof(struct ip_mreq)) {
   1073   1.5   hpeyerl 			error = EINVAL;
   1074   1.5   hpeyerl 			break;
   1075   1.5   hpeyerl 		}
   1076   1.5   hpeyerl 		mreq = mtod(m, struct ip_mreq *);
   1077  1.23   mycroft 		if (!IN_MULTICAST(mreq->imr_multiaddr.s_addr)) {
   1078   1.5   hpeyerl 			error = EINVAL;
   1079   1.5   hpeyerl 			break;
   1080   1.5   hpeyerl 		}
   1081   1.5   hpeyerl 		/*
   1082   1.5   hpeyerl 		 * If an interface address was specified, get a pointer
   1083   1.5   hpeyerl 		 * to its ifnet structure.
   1084   1.5   hpeyerl 		 */
   1085  1.31   mycroft 		if (in_nullhost(mreq->imr_interface))
   1086   1.5   hpeyerl 			ifp = NULL;
   1087   1.5   hpeyerl 		else {
   1088   1.5   hpeyerl 			INADDR_TO_IFP(mreq->imr_interface, ifp);
   1089   1.5   hpeyerl 			if (ifp == NULL) {
   1090   1.5   hpeyerl 				error = EADDRNOTAVAIL;
   1091   1.5   hpeyerl 				break;
   1092   1.5   hpeyerl 			}
   1093   1.5   hpeyerl 		}
   1094   1.5   hpeyerl 		/*
   1095   1.5   hpeyerl 		 * Find the membership in the membership array.
   1096   1.5   hpeyerl 		 */
   1097   1.5   hpeyerl 		for (i = 0; i < imo->imo_num_memberships; ++i) {
   1098   1.5   hpeyerl 			if ((ifp == NULL ||
   1099   1.5   hpeyerl 			     imo->imo_membership[i]->inm_ifp == ifp) &&
   1100  1.31   mycroft 			     in_hosteq(imo->imo_membership[i]->inm_addr,
   1101  1.31   mycroft 				       mreq->imr_multiaddr))
   1102   1.5   hpeyerl 				break;
   1103   1.5   hpeyerl 		}
   1104   1.5   hpeyerl 		if (i == imo->imo_num_memberships) {
   1105   1.5   hpeyerl 			error = EADDRNOTAVAIL;
   1106   1.5   hpeyerl 			break;
   1107   1.5   hpeyerl 		}
   1108   1.5   hpeyerl 		/*
   1109   1.5   hpeyerl 		 * Give up the multicast address record to which the
   1110   1.5   hpeyerl 		 * membership points.
   1111   1.5   hpeyerl 		 */
   1112  1.11   mycroft 		in_delmulti(imo->imo_membership[i]);
   1113   1.5   hpeyerl 		/*
   1114   1.5   hpeyerl 		 * Remove the gap in the membership array.
   1115   1.5   hpeyerl 		 */
   1116   1.5   hpeyerl 		for (++i; i < imo->imo_num_memberships; ++i)
   1117   1.5   hpeyerl 			imo->imo_membership[i-1] = imo->imo_membership[i];
   1118   1.5   hpeyerl 		--imo->imo_num_memberships;
   1119   1.5   hpeyerl 		break;
   1120   1.5   hpeyerl 
   1121   1.5   hpeyerl 	default:
   1122   1.5   hpeyerl 		error = EOPNOTSUPP;
   1123   1.5   hpeyerl 		break;
   1124   1.5   hpeyerl 	}
   1125   1.5   hpeyerl 
   1126   1.5   hpeyerl 	/*
   1127   1.5   hpeyerl 	 * If all options have default values, no need to keep the mbuf.
   1128   1.5   hpeyerl 	 */
   1129   1.5   hpeyerl 	if (imo->imo_multicast_ifp == NULL &&
   1130   1.5   hpeyerl 	    imo->imo_multicast_ttl == IP_DEFAULT_MULTICAST_TTL &&
   1131   1.5   hpeyerl 	    imo->imo_multicast_loop == IP_DEFAULT_MULTICAST_LOOP &&
   1132   1.5   hpeyerl 	    imo->imo_num_memberships == 0) {
   1133   1.5   hpeyerl 		free(*imop, M_IPMOPTS);
   1134   1.5   hpeyerl 		*imop = NULL;
   1135   1.5   hpeyerl 	}
   1136   1.5   hpeyerl 
   1137   1.5   hpeyerl 	return (error);
   1138   1.5   hpeyerl }
   1139   1.5   hpeyerl 
   1140   1.5   hpeyerl /*
   1141   1.5   hpeyerl  * Return the IP multicast options in response to user getsockopt().
   1142   1.5   hpeyerl  */
   1143   1.5   hpeyerl int
   1144   1.5   hpeyerl ip_getmoptions(optname, imo, mp)
   1145   1.5   hpeyerl 	int optname;
   1146   1.5   hpeyerl 	register struct ip_moptions *imo;
   1147   1.5   hpeyerl 	register struct mbuf **mp;
   1148   1.5   hpeyerl {
   1149   1.5   hpeyerl 	u_char *ttl;
   1150   1.5   hpeyerl 	u_char *loop;
   1151   1.5   hpeyerl 	struct in_addr *addr;
   1152   1.5   hpeyerl 	struct in_ifaddr *ia;
   1153   1.5   hpeyerl 
   1154   1.5   hpeyerl 	*mp = m_get(M_WAIT, MT_SOOPTS);
   1155   1.5   hpeyerl 
   1156   1.5   hpeyerl 	switch (optname) {
   1157   1.5   hpeyerl 
   1158   1.5   hpeyerl 	case IP_MULTICAST_IF:
   1159   1.5   hpeyerl 		addr = mtod(*mp, struct in_addr *);
   1160   1.5   hpeyerl 		(*mp)->m_len = sizeof(struct in_addr);
   1161   1.5   hpeyerl 		if (imo == NULL || imo->imo_multicast_ifp == NULL)
   1162  1.31   mycroft 			*addr = zeroin_addr;
   1163   1.5   hpeyerl 		else {
   1164   1.5   hpeyerl 			IFP_TO_IA(imo->imo_multicast_ifp, ia);
   1165  1.31   mycroft 			*addr = ia ? ia->ia_addr.sin_addr : zeroin_addr;
   1166   1.5   hpeyerl 		}
   1167   1.5   hpeyerl 		return (0);
   1168   1.5   hpeyerl 
   1169   1.5   hpeyerl 	case IP_MULTICAST_TTL:
   1170   1.5   hpeyerl 		ttl = mtod(*mp, u_char *);
   1171   1.5   hpeyerl 		(*mp)->m_len = 1;
   1172  1.31   mycroft 		*ttl = imo ? imo->imo_multicast_ttl
   1173  1.31   mycroft 			   : IP_DEFAULT_MULTICAST_TTL;
   1174   1.5   hpeyerl 		return (0);
   1175   1.5   hpeyerl 
   1176   1.5   hpeyerl 	case IP_MULTICAST_LOOP:
   1177   1.5   hpeyerl 		loop = mtod(*mp, u_char *);
   1178   1.5   hpeyerl 		(*mp)->m_len = 1;
   1179  1.31   mycroft 		*loop = imo ? imo->imo_multicast_loop
   1180  1.31   mycroft 			    : IP_DEFAULT_MULTICAST_LOOP;
   1181   1.5   hpeyerl 		return (0);
   1182   1.5   hpeyerl 
   1183   1.5   hpeyerl 	default:
   1184   1.5   hpeyerl 		return (EOPNOTSUPP);
   1185   1.5   hpeyerl 	}
   1186   1.5   hpeyerl }
   1187   1.5   hpeyerl 
   1188   1.5   hpeyerl /*
   1189   1.5   hpeyerl  * Discard the IP multicast options.
   1190   1.5   hpeyerl  */
   1191   1.5   hpeyerl void
   1192   1.5   hpeyerl ip_freemoptions(imo)
   1193   1.5   hpeyerl 	register struct ip_moptions *imo;
   1194   1.5   hpeyerl {
   1195   1.5   hpeyerl 	register int i;
   1196   1.5   hpeyerl 
   1197   1.5   hpeyerl 	if (imo != NULL) {
   1198   1.5   hpeyerl 		for (i = 0; i < imo->imo_num_memberships; ++i)
   1199   1.5   hpeyerl 			in_delmulti(imo->imo_membership[i]);
   1200   1.5   hpeyerl 		free(imo, M_IPMOPTS);
   1201   1.5   hpeyerl 	}
   1202   1.5   hpeyerl }
   1203   1.5   hpeyerl 
   1204   1.5   hpeyerl /*
   1205   1.5   hpeyerl  * Routine called from ip_output() to loop back a copy of an IP multicast
   1206   1.5   hpeyerl  * packet to the input queue of a specified interface.  Note that this
   1207   1.5   hpeyerl  * calls the output routine of the loopback "driver", but with an interface
   1208   1.5   hpeyerl  * pointer that might NOT be &loif -- easier than replicating that code here.
   1209   1.5   hpeyerl  */
   1210  1.12   mycroft static void
   1211   1.5   hpeyerl ip_mloopback(ifp, m, dst)
   1212   1.5   hpeyerl 	struct ifnet *ifp;
   1213   1.5   hpeyerl 	register struct mbuf *m;
   1214   1.5   hpeyerl 	register struct sockaddr_in *dst;
   1215   1.5   hpeyerl {
   1216   1.5   hpeyerl 	register struct ip *ip;
   1217   1.5   hpeyerl 	struct mbuf *copym;
   1218   1.5   hpeyerl 
   1219   1.5   hpeyerl 	copym = m_copy(m, 0, M_COPYALL);
   1220   1.5   hpeyerl 	if (copym != NULL) {
   1221   1.5   hpeyerl 		/*
   1222   1.5   hpeyerl 		 * We don't bother to fragment if the IP length is greater
   1223   1.5   hpeyerl 		 * than the interface's MTU.  Can this possibly matter?
   1224   1.5   hpeyerl 		 */
   1225   1.5   hpeyerl 		ip = mtod(copym, struct ip *);
   1226  1.21       cgd 		ip->ip_len = htons((u_int16_t)ip->ip_len);
   1227  1.21       cgd 		ip->ip_off = htons((u_int16_t)ip->ip_off);
   1228   1.5   hpeyerl 		ip->ip_sum = 0;
   1229   1.5   hpeyerl 		ip->ip_sum = in_cksum(copym, ip->ip_hl << 2);
   1230  1.24   mycroft 		(void) looutput(ifp, copym, sintosa(dst), NULL);
   1231   1.5   hpeyerl 	}
   1232   1.5   hpeyerl }
   1233