xref: /freebsd/sys/netinet/ip_output.c (revision fed1c7e9e49e3145f0fdca9bc6ac91be93ab1898)
1df8bae1dSRodney W. Grimes /*
2df8bae1dSRodney W. Grimes  * Copyright (c) 1982, 1986, 1988, 1990, 1993
3df8bae1dSRodney W. Grimes  *	The Regents of the University of California.  All rights reserved.
4df8bae1dSRodney W. Grimes  *
5df8bae1dSRodney W. Grimes  * Redistribution and use in source and binary forms, with or without
6df8bae1dSRodney W. Grimes  * modification, are permitted provided that the following conditions
7df8bae1dSRodney W. Grimes  * are met:
8df8bae1dSRodney W. Grimes  * 1. Redistributions of source code must retain the above copyright
9df8bae1dSRodney W. Grimes  *    notice, this list of conditions and the following disclaimer.
10df8bae1dSRodney W. Grimes  * 2. Redistributions in binary form must reproduce the above copyright
11df8bae1dSRodney W. Grimes  *    notice, this list of conditions and the following disclaimer in the
12df8bae1dSRodney W. Grimes  *    documentation and/or other materials provided with the distribution.
13df8bae1dSRodney W. Grimes  * 3. All advertising materials mentioning features or use of this software
14df8bae1dSRodney W. Grimes  *    must display the following acknowledgement:
15df8bae1dSRodney W. Grimes  *	This product includes software developed by the University of
16df8bae1dSRodney W. Grimes  *	California, Berkeley and its contributors.
17df8bae1dSRodney W. Grimes  * 4. Neither the name of the University nor the names of its contributors
18df8bae1dSRodney W. Grimes  *    may be used to endorse or promote products derived from this software
19df8bae1dSRodney W. Grimes  *    without specific prior written permission.
20df8bae1dSRodney W. Grimes  *
21df8bae1dSRodney W. Grimes  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22df8bae1dSRodney W. Grimes  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23df8bae1dSRodney W. Grimes  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24df8bae1dSRodney W. Grimes  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25df8bae1dSRodney W. Grimes  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26df8bae1dSRodney W. Grimes  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27df8bae1dSRodney W. Grimes  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28df8bae1dSRodney W. Grimes  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29df8bae1dSRodney W. Grimes  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30df8bae1dSRodney W. Grimes  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31df8bae1dSRodney W. Grimes  * SUCH DAMAGE.
32df8bae1dSRodney W. Grimes  *
33df8bae1dSRodney W. Grimes  *	@(#)ip_output.c	8.3 (Berkeley) 1/21/94
34fed1c7e9SSøren Schmidt  *	$Id: ip_output.c,v 1.41 1996/07/10 19:44:26 julian Exp $
35df8bae1dSRodney W. Grimes  */
36df8bae1dSRodney W. Grimes 
379c9137eaSGarrett Wollman #define _IP_VHL
389c9137eaSGarrett Wollman 
39df8bae1dSRodney W. Grimes #include <sys/param.h>
402ee45d7dSDavid Greenman #include <sys/queue.h>
4126f9a767SRodney W. Grimes #include <sys/systm.h>
42df8bae1dSRodney W. Grimes #include <sys/malloc.h>
43df8bae1dSRodney W. Grimes #include <sys/mbuf.h>
44df8bae1dSRodney W. Grimes #include <sys/errno.h>
45df8bae1dSRodney W. Grimes #include <sys/protosw.h>
46df8bae1dSRodney W. Grimes #include <sys/socket.h>
47df8bae1dSRodney W. Grimes #include <sys/socketvar.h>
48df8bae1dSRodney W. Grimes 
49df8bae1dSRodney W. Grimes #include <net/if.h>
50df8bae1dSRodney W. Grimes #include <net/route.h>
51df8bae1dSRodney W. Grimes 
52df8bae1dSRodney W. Grimes #include <netinet/in.h>
53df8bae1dSRodney W. Grimes #include <netinet/in_systm.h>
54df8bae1dSRodney W. Grimes #include <netinet/ip.h>
55df8bae1dSRodney W. Grimes #include <netinet/in_pcb.h>
56df8bae1dSRodney W. Grimes #include <netinet/in_var.h>
57df8bae1dSRodney W. Grimes #include <netinet/ip_var.h>
58df8bae1dSRodney W. Grimes 
59df8bae1dSRodney W. Grimes #ifdef vax
60df8bae1dSRodney W. Grimes #include <machine/mtpr.h>
61df8bae1dSRodney W. Grimes #endif
629c9137eaSGarrett Wollman #include <machine/in_cksum.h>
63df8bae1dSRodney W. Grimes 
64f9493383SGarrett Wollman #if !defined(COMPAT_IPFW) || COMPAT_IPFW == 1
65f9493383SGarrett Wollman #undef COMPAT_IPFW
66f9493383SGarrett Wollman #define COMPAT_IPFW 1
67f9493383SGarrett Wollman #else
68f9493383SGarrett Wollman #undef COMPAT_IPFW
69f9493383SGarrett Wollman #endif
70f9493383SGarrett Wollman 
71f23b4c91SGarrett Wollman u_short ip_id;
72f23b4c91SGarrett Wollman 
73df8bae1dSRodney W. Grimes static struct mbuf *ip_insertoptions __P((struct mbuf *, struct mbuf *, int *));
74df8bae1dSRodney W. Grimes static void	ip_mloopback
75df8bae1dSRodney W. Grimes 	__P((struct ifnet *, struct mbuf *, struct sockaddr_in *));
760312fbe9SPoul-Henning Kamp static int	ip_getmoptions
770312fbe9SPoul-Henning Kamp 	__P((int, struct ip_moptions *, struct mbuf **));
780312fbe9SPoul-Henning Kamp static int	ip_optcopy __P((struct ip *, struct ip *));
790312fbe9SPoul-Henning Kamp static int	ip_pcbopts __P((struct mbuf **, struct mbuf *));
800312fbe9SPoul-Henning Kamp static int	ip_setmoptions
810312fbe9SPoul-Henning Kamp 	__P((int, struct ip_moptions **, struct mbuf *));
82df8bae1dSRodney W. Grimes 
8393e0e116SJulian Elischer extern	struct protosw inetsw[];
8493e0e116SJulian Elischer 
85df8bae1dSRodney W. Grimes /*
86df8bae1dSRodney W. Grimes  * IP output.  The packet in mbuf chain m contains a skeletal IP
87df8bae1dSRodney W. Grimes  * header (with len, off, ttl, proto, tos, src, dst).
88df8bae1dSRodney W. Grimes  * The mbuf chain containing the packet will be freed.
89df8bae1dSRodney W. Grimes  * The mbuf opt, if present, will not be freed.
90df8bae1dSRodney W. Grimes  */
91df8bae1dSRodney W. Grimes int
92df8bae1dSRodney W. Grimes ip_output(m0, opt, ro, flags, imo)
93df8bae1dSRodney W. Grimes 	struct mbuf *m0;
94df8bae1dSRodney W. Grimes 	struct mbuf *opt;
95df8bae1dSRodney W. Grimes 	struct route *ro;
96df8bae1dSRodney W. Grimes 	int flags;
97df8bae1dSRodney W. Grimes 	struct ip_moptions *imo;
98df8bae1dSRodney W. Grimes {
9923bf9953SPoul-Henning Kamp 	struct ip *ip, *mhip;
10023bf9953SPoul-Henning Kamp 	struct ifnet *ifp;
10123bf9953SPoul-Henning Kamp 	struct mbuf *m = m0;
10223bf9953SPoul-Henning Kamp 	int hlen = sizeof (struct ip);
103df8bae1dSRodney W. Grimes 	int len, off, error = 0;
104df8bae1dSRodney W. Grimes 	struct sockaddr_in *dst;
105df8bae1dSRodney W. Grimes 	struct in_ifaddr *ia;
1069f9b3dc4SGarrett Wollman 	int isbroadcast;
107df8bae1dSRodney W. Grimes 
108df8bae1dSRodney W. Grimes #ifdef	DIAGNOSTIC
109df8bae1dSRodney W. Grimes 	if ((m->m_flags & M_PKTHDR) == 0)
110df8bae1dSRodney W. Grimes 		panic("ip_output no HDR");
1119c9137eaSGarrett Wollman 	if (!ro)
1129c9137eaSGarrett Wollman 		panic("ip_output no route, proto = %d",
1139c9137eaSGarrett Wollman 		      mtod(m, struct ip *)->ip_p);
114df8bae1dSRodney W. Grimes #endif
115df8bae1dSRodney W. Grimes 	if (opt) {
116df8bae1dSRodney W. Grimes 		m = ip_insertoptions(m, opt, &len);
117df8bae1dSRodney W. Grimes 		hlen = len;
118df8bae1dSRodney W. Grimes 	}
119df8bae1dSRodney W. Grimes 	ip = mtod(m, struct ip *);
120df8bae1dSRodney W. Grimes 	/*
121df8bae1dSRodney W. Grimes 	 * Fill in IP header.
122df8bae1dSRodney W. Grimes 	 */
123df8bae1dSRodney W. Grimes 	if ((flags & (IP_FORWARDING|IP_RAWOUTPUT)) == 0) {
1249c9137eaSGarrett Wollman 		ip->ip_vhl = IP_MAKE_VHL(IPVERSION, hlen >> 2);
125df8bae1dSRodney W. Grimes 		ip->ip_off &= IP_DF;
126df8bae1dSRodney W. Grimes 		ip->ip_id = htons(ip_id++);
127df8bae1dSRodney W. Grimes 		ipstat.ips_localout++;
128df8bae1dSRodney W. Grimes 	} else {
1299c9137eaSGarrett Wollman 		hlen = IP_VHL_HL(ip->ip_vhl) << 2;
130df8bae1dSRodney W. Grimes 	}
1319c9137eaSGarrett Wollman 
132df8bae1dSRodney W. Grimes 	dst = (struct sockaddr_in *)&ro->ro_dst;
133df8bae1dSRodney W. Grimes 	/*
134df8bae1dSRodney W. Grimes 	 * If there is a cached route,
135df8bae1dSRodney W. Grimes 	 * check that it is to the same destination
136df8bae1dSRodney W. Grimes 	 * and is still up.  If not, free it and try again.
137df8bae1dSRodney W. Grimes 	 */
138df8bae1dSRodney W. Grimes 	if (ro->ro_rt && ((ro->ro_rt->rt_flags & RTF_UP) == 0 ||
139df8bae1dSRodney W. Grimes 	   dst->sin_addr.s_addr != ip->ip_dst.s_addr)) {
140df8bae1dSRodney W. Grimes 		RTFREE(ro->ro_rt);
141df8bae1dSRodney W. Grimes 		ro->ro_rt = (struct rtentry *)0;
142df8bae1dSRodney W. Grimes 	}
143df8bae1dSRodney W. Grimes 	if (ro->ro_rt == 0) {
144df8bae1dSRodney W. Grimes 		dst->sin_family = AF_INET;
145df8bae1dSRodney W. Grimes 		dst->sin_len = sizeof(*dst);
146df8bae1dSRodney W. Grimes 		dst->sin_addr = ip->ip_dst;
147df8bae1dSRodney W. Grimes 	}
148df8bae1dSRodney W. Grimes 	/*
149df8bae1dSRodney W. Grimes 	 * If routing to interface only,
150df8bae1dSRodney W. Grimes 	 * short circuit routing lookup.
151df8bae1dSRodney W. Grimes 	 */
152df8bae1dSRodney W. Grimes #define ifatoia(ifa)	((struct in_ifaddr *)(ifa))
153df8bae1dSRodney W. Grimes #define sintosa(sin)	((struct sockaddr *)(sin))
154df8bae1dSRodney W. Grimes 	if (flags & IP_ROUTETOIF) {
155df8bae1dSRodney W. Grimes 		if ((ia = ifatoia(ifa_ifwithdstaddr(sintosa(dst)))) == 0 &&
156df8bae1dSRodney W. Grimes 		    (ia = ifatoia(ifa_ifwithnet(sintosa(dst)))) == 0) {
157df8bae1dSRodney W. Grimes 			ipstat.ips_noroute++;
158df8bae1dSRodney W. Grimes 			error = ENETUNREACH;
159df8bae1dSRodney W. Grimes 			goto bad;
160df8bae1dSRodney W. Grimes 		}
161df8bae1dSRodney W. Grimes 		ifp = ia->ia_ifp;
162df8bae1dSRodney W. Grimes 		ip->ip_ttl = 1;
1639f9b3dc4SGarrett Wollman 		isbroadcast = in_broadcast(dst->sin_addr, ifp);
164df8bae1dSRodney W. Grimes 	} else {
1652c17fe93SGarrett Wollman 		/*
1662c17fe93SGarrett Wollman 		 * If this is the case, we probably don't want to allocate
1672c17fe93SGarrett Wollman 		 * a protocol-cloned route since we didn't get one from the
1682c17fe93SGarrett Wollman 		 * ULP.  This lets TCP do its thing, while not burdening
1692c17fe93SGarrett Wollman 		 * forwarding or ICMP with the overhead of cloning a route.
1702c17fe93SGarrett Wollman 		 * Of course, we still want to do any cloning requested by
1712c17fe93SGarrett Wollman 		 * the link layer, as this is probably required in all cases
1722c17fe93SGarrett Wollman 		 * for correct operation (as it is for ARP).
1732c17fe93SGarrett Wollman 		 */
174df8bae1dSRodney W. Grimes 		if (ro->ro_rt == 0)
1752c17fe93SGarrett Wollman 			rtalloc_ign(ro, RTF_PRCLONING);
176df8bae1dSRodney W. Grimes 		if (ro->ro_rt == 0) {
177df8bae1dSRodney W. Grimes 			ipstat.ips_noroute++;
178df8bae1dSRodney W. Grimes 			error = EHOSTUNREACH;
179df8bae1dSRodney W. Grimes 			goto bad;
180df8bae1dSRodney W. Grimes 		}
181df8bae1dSRodney W. Grimes 		ia = ifatoia(ro->ro_rt->rt_ifa);
182df8bae1dSRodney W. Grimes 		ifp = ro->ro_rt->rt_ifp;
183df8bae1dSRodney W. Grimes 		ro->ro_rt->rt_use++;
184df8bae1dSRodney W. Grimes 		if (ro->ro_rt->rt_flags & RTF_GATEWAY)
185df8bae1dSRodney W. Grimes 			dst = (struct sockaddr_in *)ro->ro_rt->rt_gateway;
1869f9b3dc4SGarrett Wollman 		if (ro->ro_rt->rt_flags & RTF_HOST)
1879f9b3dc4SGarrett Wollman 			isbroadcast = (ro->ro_rt->rt_flags & RTF_BROADCAST);
1889f9b3dc4SGarrett Wollman 		else
1899f9b3dc4SGarrett Wollman 			isbroadcast = in_broadcast(dst->sin_addr, ifp);
190df8bae1dSRodney W. Grimes 	}
191df8bae1dSRodney W. Grimes 	if (IN_MULTICAST(ntohl(ip->ip_dst.s_addr))) {
192df8bae1dSRodney W. Grimes 		struct in_multi *inm;
193df8bae1dSRodney W. Grimes 
194df8bae1dSRodney W. Grimes 		m->m_flags |= M_MCAST;
195df8bae1dSRodney W. Grimes 		/*
196df8bae1dSRodney W. Grimes 		 * IP destination address is multicast.  Make sure "dst"
197df8bae1dSRodney W. Grimes 		 * still points to the address in "ro".  (It may have been
198df8bae1dSRodney W. Grimes 		 * changed to point to a gateway address, above.)
199df8bae1dSRodney W. Grimes 		 */
200df8bae1dSRodney W. Grimes 		dst = (struct sockaddr_in *)&ro->ro_dst;
201df8bae1dSRodney W. Grimes 		/*
202df8bae1dSRodney W. Grimes 		 * See if the caller provided any multicast options
203df8bae1dSRodney W. Grimes 		 */
204df8bae1dSRodney W. Grimes 		if (imo != NULL) {
205df8bae1dSRodney W. Grimes 			ip->ip_ttl = imo->imo_multicast_ttl;
206df8bae1dSRodney W. Grimes 			if (imo->imo_multicast_ifp != NULL)
207df8bae1dSRodney W. Grimes 				ifp = imo->imo_multicast_ifp;
2081c5de19aSGarrett Wollman 			if (imo->imo_multicast_vif != -1)
2091c5de19aSGarrett Wollman 				ip->ip_src.s_addr =
2101c5de19aSGarrett Wollman 				    ip_mcast_src(imo->imo_multicast_vif);
211df8bae1dSRodney W. Grimes 		} else
212df8bae1dSRodney W. Grimes 			ip->ip_ttl = IP_DEFAULT_MULTICAST_TTL;
213df8bae1dSRodney W. Grimes 		/*
214df8bae1dSRodney W. Grimes 		 * Confirm that the outgoing interface supports multicast.
215df8bae1dSRodney W. Grimes 		 */
2161c5de19aSGarrett Wollman 		if ((imo == NULL) || (imo->imo_multicast_vif == -1)) {
217df8bae1dSRodney W. Grimes 			if ((ifp->if_flags & IFF_MULTICAST) == 0) {
218df8bae1dSRodney W. Grimes 				ipstat.ips_noroute++;
219df8bae1dSRodney W. Grimes 				error = ENETUNREACH;
220df8bae1dSRodney W. Grimes 				goto bad;
221df8bae1dSRodney W. Grimes 			}
2221c5de19aSGarrett Wollman 		}
223df8bae1dSRodney W. Grimes 		/*
224df8bae1dSRodney W. Grimes 		 * If source address not specified yet, use address
225df8bae1dSRodney W. Grimes 		 * of outgoing interface.
226df8bae1dSRodney W. Grimes 		 */
227df8bae1dSRodney W. Grimes 		if (ip->ip_src.s_addr == INADDR_ANY) {
228df8bae1dSRodney W. Grimes 			register struct in_ifaddr *ia;
229df8bae1dSRodney W. Grimes 
230df8bae1dSRodney W. Grimes 			for (ia = in_ifaddr; ia; ia = ia->ia_next)
231df8bae1dSRodney W. Grimes 				if (ia->ia_ifp == ifp) {
232df8bae1dSRodney W. Grimes 					ip->ip_src = IA_SIN(ia)->sin_addr;
233df8bae1dSRodney W. Grimes 					break;
234df8bae1dSRodney W. Grimes 				}
235df8bae1dSRodney W. Grimes 		}
236df8bae1dSRodney W. Grimes 
237df8bae1dSRodney W. Grimes 		IN_LOOKUP_MULTI(ip->ip_dst, ifp, inm);
238df8bae1dSRodney W. Grimes 		if (inm != NULL &&
239df8bae1dSRodney W. Grimes 		   (imo == NULL || imo->imo_multicast_loop)) {
240df8bae1dSRodney W. Grimes 			/*
241df8bae1dSRodney W. Grimes 			 * If we belong to the destination multicast group
242df8bae1dSRodney W. Grimes 			 * on the outgoing interface, and the caller did not
243df8bae1dSRodney W. Grimes 			 * forbid loopback, loop back a copy.
244df8bae1dSRodney W. Grimes 			 */
245df8bae1dSRodney W. Grimes 			ip_mloopback(ifp, m, dst);
246df8bae1dSRodney W. Grimes 		}
247df8bae1dSRodney W. Grimes 		else {
248df8bae1dSRodney W. Grimes 			/*
249df8bae1dSRodney W. Grimes 			 * If we are acting as a multicast router, perform
250df8bae1dSRodney W. Grimes 			 * multicast forwarding as if the packet had just
251df8bae1dSRodney W. Grimes 			 * arrived on the interface to which we are about
252df8bae1dSRodney W. Grimes 			 * to send.  The multicast forwarding function
253df8bae1dSRodney W. Grimes 			 * recursively calls this function, using the
254df8bae1dSRodney W. Grimes 			 * IP_FORWARDING flag to prevent infinite recursion.
255df8bae1dSRodney W. Grimes 			 *
256df8bae1dSRodney W. Grimes 			 * Multicasts that are looped back by ip_mloopback(),
257df8bae1dSRodney W. Grimes 			 * above, will be forwarded by the ip_input() routine,
258df8bae1dSRodney W. Grimes 			 * if necessary.
259df8bae1dSRodney W. Grimes 			 */
260df8bae1dSRodney W. Grimes 			if (ip_mrouter && (flags & IP_FORWARDING) == 0) {
261f0068c4aSGarrett Wollman 				/*
262f0068c4aSGarrett Wollman 				 * Check if rsvp daemon is running. If not, don't
263f0068c4aSGarrett Wollman 				 * set ip_moptions. This ensures that the packet
264f0068c4aSGarrett Wollman 				 * is multicast and not just sent down one link
265f0068c4aSGarrett Wollman 				 * as prescribed by rsvpd.
266f0068c4aSGarrett Wollman 				 */
267b124e4f2SGarrett Wollman 				if (!rsvp_on)
268f0068c4aSGarrett Wollman 				  imo = NULL;
269f0068c4aSGarrett Wollman 				if (ip_mforward(ip, ifp, m, imo) != 0) {
270df8bae1dSRodney W. Grimes 					m_freem(m);
271df8bae1dSRodney W. Grimes 					goto done;
272df8bae1dSRodney W. Grimes 				}
273df8bae1dSRodney W. Grimes 			}
274df8bae1dSRodney W. Grimes 		}
2755e9ae478SGarrett Wollman 
276df8bae1dSRodney W. Grimes 		/*
277df8bae1dSRodney W. Grimes 		 * Multicasts with a time-to-live of zero may be looped-
278df8bae1dSRodney W. Grimes 		 * back, above, but must not be transmitted on a network.
279df8bae1dSRodney W. Grimes 		 * Also, multicasts addressed to the loopback interface
280df8bae1dSRodney W. Grimes 		 * are not sent -- the above call to ip_mloopback() will
281df8bae1dSRodney W. Grimes 		 * loop back a copy if this host actually belongs to the
282df8bae1dSRodney W. Grimes 		 * destination group on the loopback interface.
283df8bae1dSRodney W. Grimes 		 */
284f5fea3ddSPaul Traina 		if (ip->ip_ttl == 0 || ifp->if_flags & IFF_LOOPBACK) {
285df8bae1dSRodney W. Grimes 			m_freem(m);
286df8bae1dSRodney W. Grimes 			goto done;
287df8bae1dSRodney W. Grimes 		}
288df8bae1dSRodney W. Grimes 
289df8bae1dSRodney W. Grimes 		goto sendit;
290df8bae1dSRodney W. Grimes 	}
291df8bae1dSRodney W. Grimes #ifndef notdef
292df8bae1dSRodney W. Grimes 	/*
293df8bae1dSRodney W. Grimes 	 * If source address not specified yet, use address
294df8bae1dSRodney W. Grimes 	 * of outgoing interface.
295df8bae1dSRodney W. Grimes 	 */
296df8bae1dSRodney W. Grimes 	if (ip->ip_src.s_addr == INADDR_ANY)
297df8bae1dSRodney W. Grimes 		ip->ip_src = IA_SIN(ia)->sin_addr;
298df8bae1dSRodney W. Grimes #endif
299df8bae1dSRodney W. Grimes 	/*
300b5390296SDavid Greenman 	 * Verify that we have any chance at all of being able to queue
301b5390296SDavid Greenman 	 *      the packet or packet fragments
302b5390296SDavid Greenman 	 */
303b5390296SDavid Greenman 	if ((ifp->if_snd.ifq_len + ip->ip_len / ifp->if_mtu + 1) >=
304b5390296SDavid Greenman 		ifp->if_snd.ifq_maxlen) {
305b5390296SDavid Greenman 			error = ENOBUFS;
306b5390296SDavid Greenman 			goto bad;
307b5390296SDavid Greenman 	}
308b5390296SDavid Greenman 
309b5390296SDavid Greenman 	/*
310df8bae1dSRodney W. Grimes 	 * Look for broadcast address and
311df8bae1dSRodney W. Grimes 	 * and verify user is allowed to send
312df8bae1dSRodney W. Grimes 	 * such a packet.
313df8bae1dSRodney W. Grimes 	 */
3149f9b3dc4SGarrett Wollman 	if (isbroadcast) {
315df8bae1dSRodney W. Grimes 		if ((ifp->if_flags & IFF_BROADCAST) == 0) {
316df8bae1dSRodney W. Grimes 			error = EADDRNOTAVAIL;
317df8bae1dSRodney W. Grimes 			goto bad;
318df8bae1dSRodney W. Grimes 		}
319df8bae1dSRodney W. Grimes 		if ((flags & IP_ALLOWBROADCAST) == 0) {
320df8bae1dSRodney W. Grimes 			error = EACCES;
321df8bae1dSRodney W. Grimes 			goto bad;
322df8bae1dSRodney W. Grimes 		}
323df8bae1dSRodney W. Grimes 		/* don't allow broadcast messages to be fragmented */
324df8bae1dSRodney W. Grimes 		if ((u_short)ip->ip_len > ifp->if_mtu) {
325df8bae1dSRodney W. Grimes 			error = EMSGSIZE;
326df8bae1dSRodney W. Grimes 			goto bad;
327df8bae1dSRodney W. Grimes 		}
328df8bae1dSRodney W. Grimes 		m->m_flags |= M_BCAST;
3299f9b3dc4SGarrett Wollman 	} else {
330df8bae1dSRodney W. Grimes 		m->m_flags &= ~M_BCAST;
3319f9b3dc4SGarrett Wollman 	}
332df8bae1dSRodney W. Grimes 
333df8bae1dSRodney W. Grimes sendit:
334fed1c7e9SSøren Schmidt         /*
335fed1c7e9SSøren Schmidt 	 * IpHack's section.
336fed1c7e9SSøren Schmidt 	 * - Xlate: translate packet's addr/port (NAT).
337fed1c7e9SSøren Schmidt 	 * - Firewall: deny/allow
338fed1c7e9SSøren Schmidt 	 * - Wrap: fake packet's addr/port <unimpl.>
339fed1c7e9SSøren Schmidt 	 * - Encapsulate: put it in another IP and send out. <unimp.>
340fed1c7e9SSøren Schmidt 	 */
341fed1c7e9SSøren Schmidt 
342fed1c7e9SSøren Schmidt         if (ip_nat_ptr && !(*ip_nat_ptr)(&ip, &m, IP_NAT_OUT)) {
343fed1c7e9SSøren Schmidt 		error = EACCES;
344fed1c7e9SSøren Schmidt 		goto done;
345fed1c7e9SSøren Schmidt 	}
346fed1c7e9SSøren Schmidt 
34793e0e116SJulian Elischer #ifdef COMPAT_IPFW
348df8bae1dSRodney W. Grimes 	/*
349e7319babSPoul-Henning Kamp 	 * Check with the firewall...
350e7319babSPoul-Henning Kamp 	 */
35193e0e116SJulian Elischer 	if (ip_fw_chk_ptr) {
35293e0e116SJulian Elischer 		int action;
35393e0e116SJulian Elischer 
35493e0e116SJulian Elischer #ifdef IPDIVERT
35593e0e116SJulian Elischer 		action = (*ip_fw_chk_ptr)(&ip,
35693e0e116SJulian Elischer 				hlen, ifp, (~0 << 16) | ip_divert_ignore, &m);
35793e0e116SJulian Elischer #else
35893e0e116SJulian Elischer 		action = (*ip_fw_chk_ptr)(&ip, hlen, ifp, (~0 << 16), &m);
359f9493383SGarrett Wollman #endif
36093e0e116SJulian Elischer 		if (action == -1) {
36193e0e116SJulian Elischer 			error = EACCES;		/* XXX is this appropriate? */
36293e0e116SJulian Elischer 			goto done;
36393e0e116SJulian Elischer 		} else if (action != 0) {
36493e0e116SJulian Elischer #ifdef IPDIVERT
36593e0e116SJulian Elischer 			ip_divert_port = action;	/* divert to port */
36693e0e116SJulian Elischer 			(*inetsw[ip_protox[IPPROTO_DIVERT]].pr_input)(m, 0);
36793e0e116SJulian Elischer 			goto done;
36893e0e116SJulian Elischer #else
36993e0e116SJulian Elischer 			m_freem(m);	/* ipfw says divert, but we can't */
37093e0e116SJulian Elischer 			goto done;
37193e0e116SJulian Elischer #endif
37293e0e116SJulian Elischer 		}
37393e0e116SJulian Elischer 	}
37493e0e116SJulian Elischer #endif /* COMPAT_IPFW */
375e7319babSPoul-Henning Kamp 
376e7319babSPoul-Henning Kamp 	/*
377df8bae1dSRodney W. Grimes 	 * If small enough for interface, can just send directly.
378df8bae1dSRodney W. Grimes 	 */
379df8bae1dSRodney W. Grimes 	if ((u_short)ip->ip_len <= ifp->if_mtu) {
380df8bae1dSRodney W. Grimes 		ip->ip_len = htons((u_short)ip->ip_len);
381df8bae1dSRodney W. Grimes 		ip->ip_off = htons((u_short)ip->ip_off);
382df8bae1dSRodney W. Grimes 		ip->ip_sum = 0;
3839c9137eaSGarrett Wollman 		if (ip->ip_vhl == IP_VHL_BORING) {
3849c9137eaSGarrett Wollman 			ip->ip_sum = in_cksum_hdr(ip);
3859c9137eaSGarrett Wollman 		} else {
386df8bae1dSRodney W. Grimes 			ip->ip_sum = in_cksum(m, hlen);
3879c9137eaSGarrett Wollman 		}
388df8bae1dSRodney W. Grimes 		error = (*ifp->if_output)(ifp, m,
389df8bae1dSRodney W. Grimes 				(struct sockaddr *)dst, ro->ro_rt);
390df8bae1dSRodney W. Grimes 		goto done;
391df8bae1dSRodney W. Grimes 	}
392df8bae1dSRodney W. Grimes 	/*
393df8bae1dSRodney W. Grimes 	 * Too large for interface; fragment if possible.
394df8bae1dSRodney W. Grimes 	 * Must be able to put at least 8 bytes per fragment.
395df8bae1dSRodney W. Grimes 	 */
396df8bae1dSRodney W. Grimes 	if (ip->ip_off & IP_DF) {
397df8bae1dSRodney W. Grimes 		error = EMSGSIZE;
3983d1f141bSGarrett Wollman 		/*
3993d1f141bSGarrett Wollman 		 * This case can happen if the user changed the MTU
4003d1f141bSGarrett Wollman 		 * of an interface after enabling IP on it.  Because
4013d1f141bSGarrett Wollman 		 * most netifs don't keep track of routes pointing to
4023d1f141bSGarrett Wollman 		 * them, there is no way for one to update all its
4033d1f141bSGarrett Wollman 		 * routes when the MTU is changed.
4043d1f141bSGarrett Wollman 		 */
4053d1f141bSGarrett Wollman 		if ((ro->ro_rt->rt_flags & (RTF_UP | RTF_HOST))
4063d1f141bSGarrett Wollman 		    && !(ro->ro_rt->rt_rmx.rmx_locks & RTV_MTU)
4073d1f141bSGarrett Wollman 		    && (ro->ro_rt->rt_rmx.rmx_mtu > ifp->if_mtu)) {
4083d1f141bSGarrett Wollman 			ro->ro_rt->rt_rmx.rmx_mtu = ifp->if_mtu;
4093d1f141bSGarrett Wollman 		}
410df8bae1dSRodney W. Grimes 		ipstat.ips_cantfrag++;
411df8bae1dSRodney W. Grimes 		goto bad;
412df8bae1dSRodney W. Grimes 	}
413df8bae1dSRodney W. Grimes 	len = (ifp->if_mtu - hlen) &~ 7;
414df8bae1dSRodney W. Grimes 	if (len < 8) {
415df8bae1dSRodney W. Grimes 		error = EMSGSIZE;
416df8bae1dSRodney W. Grimes 		goto bad;
417df8bae1dSRodney W. Grimes 	}
418df8bae1dSRodney W. Grimes 
419df8bae1dSRodney W. Grimes     {
420df8bae1dSRodney W. Grimes 	int mhlen, firstlen = len;
421df8bae1dSRodney W. Grimes 	struct mbuf **mnext = &m->m_nextpkt;
422df8bae1dSRodney W. Grimes 
423df8bae1dSRodney W. Grimes 	/*
424df8bae1dSRodney W. Grimes 	 * Loop through length of segment after first fragment,
425df8bae1dSRodney W. Grimes 	 * make new header and copy data of each part and link onto chain.
426df8bae1dSRodney W. Grimes 	 */
427df8bae1dSRodney W. Grimes 	m0 = m;
428df8bae1dSRodney W. Grimes 	mhlen = sizeof (struct ip);
429df8bae1dSRodney W. Grimes 	for (off = hlen + len; off < (u_short)ip->ip_len; off += len) {
430df8bae1dSRodney W. Grimes 		MGETHDR(m, M_DONTWAIT, MT_HEADER);
431df8bae1dSRodney W. Grimes 		if (m == 0) {
432df8bae1dSRodney W. Grimes 			error = ENOBUFS;
433df8bae1dSRodney W. Grimes 			ipstat.ips_odropped++;
434df8bae1dSRodney W. Grimes 			goto sendorfree;
435df8bae1dSRodney W. Grimes 		}
436df8bae1dSRodney W. Grimes 		m->m_data += max_linkhdr;
437df8bae1dSRodney W. Grimes 		mhip = mtod(m, struct ip *);
438df8bae1dSRodney W. Grimes 		*mhip = *ip;
439df8bae1dSRodney W. Grimes 		if (hlen > sizeof (struct ip)) {
440df8bae1dSRodney W. Grimes 			mhlen = ip_optcopy(ip, mhip) + sizeof (struct ip);
4419c9137eaSGarrett Wollman 			mhip->ip_vhl = IP_MAKE_VHL(IPVERSION, mhlen >> 2);
442df8bae1dSRodney W. Grimes 		}
443df8bae1dSRodney W. Grimes 		m->m_len = mhlen;
444df8bae1dSRodney W. Grimes 		mhip->ip_off = ((off - hlen) >> 3) + (ip->ip_off & ~IP_MF);
445df8bae1dSRodney W. Grimes 		if (ip->ip_off & IP_MF)
446df8bae1dSRodney W. Grimes 			mhip->ip_off |= IP_MF;
447df8bae1dSRodney W. Grimes 		if (off + len >= (u_short)ip->ip_len)
448df8bae1dSRodney W. Grimes 			len = (u_short)ip->ip_len - off;
449df8bae1dSRodney W. Grimes 		else
450df8bae1dSRodney W. Grimes 			mhip->ip_off |= IP_MF;
451df8bae1dSRodney W. Grimes 		mhip->ip_len = htons((u_short)(len + mhlen));
452df8bae1dSRodney W. Grimes 		m->m_next = m_copy(m0, off, len);
453df8bae1dSRodney W. Grimes 		if (m->m_next == 0) {
454df8bae1dSRodney W. Grimes 			(void) m_free(m);
455df8bae1dSRodney W. Grimes 			error = ENOBUFS;	/* ??? */
456df8bae1dSRodney W. Grimes 			ipstat.ips_odropped++;
457df8bae1dSRodney W. Grimes 			goto sendorfree;
458df8bae1dSRodney W. Grimes 		}
459df8bae1dSRodney W. Grimes 		m->m_pkthdr.len = mhlen + len;
460df8bae1dSRodney W. Grimes 		m->m_pkthdr.rcvif = (struct ifnet *)0;
461df8bae1dSRodney W. Grimes 		mhip->ip_off = htons((u_short)mhip->ip_off);
462df8bae1dSRodney W. Grimes 		mhip->ip_sum = 0;
4639c9137eaSGarrett Wollman 		if (mhip->ip_vhl == IP_VHL_BORING) {
464e2184122SBruce Evans 			mhip->ip_sum = in_cksum_hdr(mhip);
4659c9137eaSGarrett Wollman 		} else {
466df8bae1dSRodney W. Grimes 			mhip->ip_sum = in_cksum(m, mhlen);
4679c9137eaSGarrett Wollman 		}
468df8bae1dSRodney W. Grimes 		*mnext = m;
469df8bae1dSRodney W. Grimes 		mnext = &m->m_nextpkt;
470df8bae1dSRodney W. Grimes 		ipstat.ips_ofragments++;
471df8bae1dSRodney W. Grimes 	}
472df8bae1dSRodney W. Grimes 	/*
473df8bae1dSRodney W. Grimes 	 * Update first fragment by trimming what's been copied out
474df8bae1dSRodney W. Grimes 	 * and updating header, then send each fragment (in order).
475df8bae1dSRodney W. Grimes 	 */
476df8bae1dSRodney W. Grimes 	m = m0;
477df8bae1dSRodney W. Grimes 	m_adj(m, hlen + firstlen - (u_short)ip->ip_len);
478df8bae1dSRodney W. Grimes 	m->m_pkthdr.len = hlen + firstlen;
479df8bae1dSRodney W. Grimes 	ip->ip_len = htons((u_short)m->m_pkthdr.len);
480df8bae1dSRodney W. Grimes 	ip->ip_off = htons((u_short)(ip->ip_off | IP_MF));
481df8bae1dSRodney W. Grimes 	ip->ip_sum = 0;
4829c9137eaSGarrett Wollman 	if (ip->ip_vhl == IP_VHL_BORING) {
4839c9137eaSGarrett Wollman 		ip->ip_sum = in_cksum_hdr(ip);
4849c9137eaSGarrett Wollman 	} else {
485df8bae1dSRodney W. Grimes 		ip->ip_sum = in_cksum(m, hlen);
4869c9137eaSGarrett Wollman 	}
487df8bae1dSRodney W. Grimes sendorfree:
488df8bae1dSRodney W. Grimes 	for (m = m0; m; m = m0) {
489df8bae1dSRodney W. Grimes 		m0 = m->m_nextpkt;
490df8bae1dSRodney W. Grimes 		m->m_nextpkt = 0;
491df8bae1dSRodney W. Grimes 		if (error == 0)
492df8bae1dSRodney W. Grimes 			error = (*ifp->if_output)(ifp, m,
493df8bae1dSRodney W. Grimes 			    (struct sockaddr *)dst, ro->ro_rt);
494df8bae1dSRodney W. Grimes 		else
495df8bae1dSRodney W. Grimes 			m_freem(m);
496df8bae1dSRodney W. Grimes 	}
497df8bae1dSRodney W. Grimes 
498df8bae1dSRodney W. Grimes 	if (error == 0)
499df8bae1dSRodney W. Grimes 		ipstat.ips_fragmented++;
500df8bae1dSRodney W. Grimes     }
501df8bae1dSRodney W. Grimes done:
502df8bae1dSRodney W. Grimes 	return (error);
503df8bae1dSRodney W. Grimes bad:
504df8bae1dSRodney W. Grimes 	m_freem(m0);
505df8bae1dSRodney W. Grimes 	goto done;
506df8bae1dSRodney W. Grimes }
507df8bae1dSRodney W. Grimes 
508df8bae1dSRodney W. Grimes /*
509df8bae1dSRodney W. Grimes  * Insert IP options into preformed packet.
510df8bae1dSRodney W. Grimes  * Adjust IP destination as required for IP source routing,
511df8bae1dSRodney W. Grimes  * as indicated by a non-zero in_addr at the start of the options.
512072b9b24SPaul Traina  *
513072b9b24SPaul Traina  * XXX This routine assumes that the packet has no options in place.
514df8bae1dSRodney W. Grimes  */
515df8bae1dSRodney W. Grimes static struct mbuf *
516df8bae1dSRodney W. Grimes ip_insertoptions(m, opt, phlen)
517df8bae1dSRodney W. Grimes 	register struct mbuf *m;
518df8bae1dSRodney W. Grimes 	struct mbuf *opt;
519df8bae1dSRodney W. Grimes 	int *phlen;
520df8bae1dSRodney W. Grimes {
521df8bae1dSRodney W. Grimes 	register struct ipoption *p = mtod(opt, struct ipoption *);
522df8bae1dSRodney W. Grimes 	struct mbuf *n;
523df8bae1dSRodney W. Grimes 	register struct ip *ip = mtod(m, struct ip *);
524df8bae1dSRodney W. Grimes 	unsigned optlen;
525df8bae1dSRodney W. Grimes 
526df8bae1dSRodney W. Grimes 	optlen = opt->m_len - sizeof(p->ipopt_dst);
527df8bae1dSRodney W. Grimes 	if (optlen + (u_short)ip->ip_len > IP_MAXPACKET)
528df8bae1dSRodney W. Grimes 		return (m);		/* XXX should fail */
529df8bae1dSRodney W. Grimes 	if (p->ipopt_dst.s_addr)
530df8bae1dSRodney W. Grimes 		ip->ip_dst = p->ipopt_dst;
531df8bae1dSRodney W. Grimes 	if (m->m_flags & M_EXT || m->m_data - optlen < m->m_pktdat) {
532df8bae1dSRodney W. Grimes 		MGETHDR(n, M_DONTWAIT, MT_HEADER);
533df8bae1dSRodney W. Grimes 		if (n == 0)
534df8bae1dSRodney W. Grimes 			return (m);
535df8bae1dSRodney W. Grimes 		n->m_pkthdr.len = m->m_pkthdr.len + optlen;
536df8bae1dSRodney W. Grimes 		m->m_len -= sizeof(struct ip);
537df8bae1dSRodney W. Grimes 		m->m_data += sizeof(struct ip);
538df8bae1dSRodney W. Grimes 		n->m_next = m;
539df8bae1dSRodney W. Grimes 		m = n;
540df8bae1dSRodney W. Grimes 		m->m_len = optlen + sizeof(struct ip);
541df8bae1dSRodney W. Grimes 		m->m_data += max_linkhdr;
54294a5d9b6SDavid Greenman 		(void)memcpy(mtod(m, void *), ip, sizeof(struct ip));
543df8bae1dSRodney W. Grimes 	} else {
544df8bae1dSRodney W. Grimes 		m->m_data -= optlen;
545df8bae1dSRodney W. Grimes 		m->m_len += optlen;
546df8bae1dSRodney W. Grimes 		m->m_pkthdr.len += optlen;
547df8bae1dSRodney W. Grimes 		ovbcopy((caddr_t)ip, mtod(m, caddr_t), sizeof(struct ip));
548df8bae1dSRodney W. Grimes 	}
549df8bae1dSRodney W. Grimes 	ip = mtod(m, struct ip *);
5500453d3cbSBruce Evans 	bcopy(p->ipopt_list, ip + 1, optlen);
551df8bae1dSRodney W. Grimes 	*phlen = sizeof(struct ip) + optlen;
5529c9137eaSGarrett Wollman 	ip->ip_vhl = IP_MAKE_VHL(IPVERSION, *phlen >> 2);
553df8bae1dSRodney W. Grimes 	ip->ip_len += optlen;
554df8bae1dSRodney W. Grimes 	return (m);
555df8bae1dSRodney W. Grimes }
556df8bae1dSRodney W. Grimes 
557df8bae1dSRodney W. Grimes /*
558df8bae1dSRodney W. Grimes  * Copy options from ip to jp,
559df8bae1dSRodney W. Grimes  * omitting those not copied during fragmentation.
560df8bae1dSRodney W. Grimes  */
5610312fbe9SPoul-Henning Kamp static int
562df8bae1dSRodney W. Grimes ip_optcopy(ip, jp)
563df8bae1dSRodney W. Grimes 	struct ip *ip, *jp;
564df8bae1dSRodney W. Grimes {
565df8bae1dSRodney W. Grimes 	register u_char *cp, *dp;
566df8bae1dSRodney W. Grimes 	int opt, optlen, cnt;
567df8bae1dSRodney W. Grimes 
568df8bae1dSRodney W. Grimes 	cp = (u_char *)(ip + 1);
569df8bae1dSRodney W. Grimes 	dp = (u_char *)(jp + 1);
5709c9137eaSGarrett Wollman 	cnt = (IP_VHL_HL(ip->ip_vhl) << 2) - sizeof (struct ip);
571df8bae1dSRodney W. Grimes 	for (; cnt > 0; cnt -= optlen, cp += optlen) {
572df8bae1dSRodney W. Grimes 		opt = cp[0];
573df8bae1dSRodney W. Grimes 		if (opt == IPOPT_EOL)
574df8bae1dSRodney W. Grimes 			break;
575df8bae1dSRodney W. Grimes 		if (opt == IPOPT_NOP) {
576df8bae1dSRodney W. Grimes 			/* Preserve for IP mcast tunnel's LSRR alignment. */
577df8bae1dSRodney W. Grimes 			*dp++ = IPOPT_NOP;
578df8bae1dSRodney W. Grimes 			optlen = 1;
579df8bae1dSRodney W. Grimes 			continue;
580df8bae1dSRodney W. Grimes 		} else
581df8bae1dSRodney W. Grimes 			optlen = cp[IPOPT_OLEN];
582df8bae1dSRodney W. Grimes 		/* bogus lengths should have been caught by ip_dooptions */
583df8bae1dSRodney W. Grimes 		if (optlen > cnt)
584df8bae1dSRodney W. Grimes 			optlen = cnt;
585df8bae1dSRodney W. Grimes 		if (IPOPT_COPIED(opt)) {
5860453d3cbSBruce Evans 			bcopy(cp, dp, optlen);
587df8bae1dSRodney W. Grimes 			dp += optlen;
588df8bae1dSRodney W. Grimes 		}
589df8bae1dSRodney W. Grimes 	}
590df8bae1dSRodney W. Grimes 	for (optlen = dp - (u_char *)(jp+1); optlen & 0x3; optlen++)
591df8bae1dSRodney W. Grimes 		*dp++ = IPOPT_EOL;
592df8bae1dSRodney W. Grimes 	return (optlen);
593df8bae1dSRodney W. Grimes }
594df8bae1dSRodney W. Grimes 
595df8bae1dSRodney W. Grimes /*
596df8bae1dSRodney W. Grimes  * IP socket option processing.
597df8bae1dSRodney W. Grimes  */
598df8bae1dSRodney W. Grimes int
599df8bae1dSRodney W. Grimes ip_ctloutput(op, so, level, optname, mp)
600df8bae1dSRodney W. Grimes 	int op;
601df8bae1dSRodney W. Grimes 	struct socket *so;
602df8bae1dSRodney W. Grimes 	int level, optname;
603df8bae1dSRodney W. Grimes 	struct mbuf **mp;
604df8bae1dSRodney W. Grimes {
605df8bae1dSRodney W. Grimes 	register struct inpcb *inp = sotoinpcb(so);
606df8bae1dSRodney W. Grimes 	register struct mbuf *m = *mp;
60726f9a767SRodney W. Grimes 	register int optval = 0;
608df8bae1dSRodney W. Grimes 	int error = 0;
609df8bae1dSRodney W. Grimes 
610df8bae1dSRodney W. Grimes 	if (level != IPPROTO_IP) {
611df8bae1dSRodney W. Grimes 		error = EINVAL;
612df8bae1dSRodney W. Grimes 		if (op == PRCO_SETOPT && *mp)
613df8bae1dSRodney W. Grimes 			(void) m_free(*mp);
614df8bae1dSRodney W. Grimes 	} else switch (op) {
615df8bae1dSRodney W. Grimes 
616df8bae1dSRodney W. Grimes 	case PRCO_SETOPT:
617df8bae1dSRodney W. Grimes 		switch (optname) {
618df8bae1dSRodney W. Grimes 		case IP_OPTIONS:
619df8bae1dSRodney W. Grimes #ifdef notyet
620df8bae1dSRodney W. Grimes 		case IP_RETOPTS:
621df8bae1dSRodney W. Grimes 			return (ip_pcbopts(optname, &inp->inp_options, m));
622df8bae1dSRodney W. Grimes #else
623df8bae1dSRodney W. Grimes 			return (ip_pcbopts(&inp->inp_options, m));
624df8bae1dSRodney W. Grimes #endif
625df8bae1dSRodney W. Grimes 
626df8bae1dSRodney W. Grimes 		case IP_TOS:
627df8bae1dSRodney W. Grimes 		case IP_TTL:
628df8bae1dSRodney W. Grimes 		case IP_RECVOPTS:
629df8bae1dSRodney W. Grimes 		case IP_RECVRETOPTS:
630df8bae1dSRodney W. Grimes 		case IP_RECVDSTADDR:
63140a63d93SJoerg Wunsch 			if (m == 0 || m->m_len != sizeof(int))
632df8bae1dSRodney W. Grimes 				error = EINVAL;
633df8bae1dSRodney W. Grimes 			else {
634df8bae1dSRodney W. Grimes 				optval = *mtod(m, int *);
635df8bae1dSRodney W. Grimes 				switch (optname) {
636df8bae1dSRodney W. Grimes 
637df8bae1dSRodney W. Grimes 				case IP_TOS:
638df8bae1dSRodney W. Grimes 					inp->inp_ip.ip_tos = optval;
639df8bae1dSRodney W. Grimes 					break;
640df8bae1dSRodney W. Grimes 
641df8bae1dSRodney W. Grimes 				case IP_TTL:
642df8bae1dSRodney W. Grimes 					inp->inp_ip.ip_ttl = optval;
643df8bae1dSRodney W. Grimes 					break;
644df8bae1dSRodney W. Grimes #define	OPTSET(bit) \
645df8bae1dSRodney W. Grimes 	if (optval) \
646df8bae1dSRodney W. Grimes 		inp->inp_flags |= bit; \
647df8bae1dSRodney W. Grimes 	else \
648df8bae1dSRodney W. Grimes 		inp->inp_flags &= ~bit;
649df8bae1dSRodney W. Grimes 
650df8bae1dSRodney W. Grimes 				case IP_RECVOPTS:
651df8bae1dSRodney W. Grimes 					OPTSET(INP_RECVOPTS);
652df8bae1dSRodney W. Grimes 					break;
653df8bae1dSRodney W. Grimes 
654df8bae1dSRodney W. Grimes 				case IP_RECVRETOPTS:
655df8bae1dSRodney W. Grimes 					OPTSET(INP_RECVRETOPTS);
656df8bae1dSRodney W. Grimes 					break;
657df8bae1dSRodney W. Grimes 
658df8bae1dSRodney W. Grimes 				case IP_RECVDSTADDR:
659df8bae1dSRodney W. Grimes 					OPTSET(INP_RECVDSTADDR);
660df8bae1dSRodney W. Grimes 					break;
661df8bae1dSRodney W. Grimes 				}
662df8bae1dSRodney W. Grimes 			}
663df8bae1dSRodney W. Grimes 			break;
664df8bae1dSRodney W. Grimes #undef OPTSET
665df8bae1dSRodney W. Grimes 
666df8bae1dSRodney W. Grimes 		case IP_MULTICAST_IF:
667f0068c4aSGarrett Wollman 		case IP_MULTICAST_VIF:
668df8bae1dSRodney W. Grimes 		case IP_MULTICAST_TTL:
669df8bae1dSRodney W. Grimes 		case IP_MULTICAST_LOOP:
670df8bae1dSRodney W. Grimes 		case IP_ADD_MEMBERSHIP:
671df8bae1dSRodney W. Grimes 		case IP_DROP_MEMBERSHIP:
672df8bae1dSRodney W. Grimes 			error = ip_setmoptions(optname, &inp->inp_moptions, m);
673df8bae1dSRodney W. Grimes 			break;
674df8bae1dSRodney W. Grimes 
67533b3ac06SPeter Wemm 		case IP_PORTRANGE:
67633b3ac06SPeter Wemm 			if (m == 0 || m->m_len != sizeof(int))
67733b3ac06SPeter Wemm 				error = EINVAL;
67833b3ac06SPeter Wemm 			else {
67933b3ac06SPeter Wemm 				optval = *mtod(m, int *);
68033b3ac06SPeter Wemm 
68133b3ac06SPeter Wemm 				switch (optval) {
68233b3ac06SPeter Wemm 
68333b3ac06SPeter Wemm 				case IP_PORTRANGE_DEFAULT:
68433b3ac06SPeter Wemm 					inp->inp_flags &= ~(INP_LOWPORT);
68533b3ac06SPeter Wemm 					inp->inp_flags &= ~(INP_HIGHPORT);
68633b3ac06SPeter Wemm 					break;
68733b3ac06SPeter Wemm 
68833b3ac06SPeter Wemm 				case IP_PORTRANGE_HIGH:
68933b3ac06SPeter Wemm 					inp->inp_flags &= ~(INP_LOWPORT);
69033b3ac06SPeter Wemm 					inp->inp_flags |= INP_HIGHPORT;
69133b3ac06SPeter Wemm 					break;
69233b3ac06SPeter Wemm 
69333b3ac06SPeter Wemm 				case IP_PORTRANGE_LOW:
69433b3ac06SPeter Wemm 					inp->inp_flags &= ~(INP_HIGHPORT);
69533b3ac06SPeter Wemm 					inp->inp_flags |= INP_LOWPORT;
69633b3ac06SPeter Wemm 					break;
69733b3ac06SPeter Wemm 
69833b3ac06SPeter Wemm 				default:
69933b3ac06SPeter Wemm 					error = EINVAL;
70033b3ac06SPeter Wemm 					break;
70133b3ac06SPeter Wemm 				}
70233b3ac06SPeter Wemm 			}
703ce8c72b1SPeter Wemm 			break;
70433b3ac06SPeter Wemm 
705df8bae1dSRodney W. Grimes 		default:
706df8bae1dSRodney W. Grimes 			error = ENOPROTOOPT;
707df8bae1dSRodney W. Grimes 			break;
708df8bae1dSRodney W. Grimes 		}
709df8bae1dSRodney W. Grimes 		if (m)
710df8bae1dSRodney W. Grimes 			(void)m_free(m);
711df8bae1dSRodney W. Grimes 		break;
712df8bae1dSRodney W. Grimes 
713df8bae1dSRodney W. Grimes 	case PRCO_GETOPT:
714df8bae1dSRodney W. Grimes 		switch (optname) {
715df8bae1dSRodney W. Grimes 		case IP_OPTIONS:
716df8bae1dSRodney W. Grimes 		case IP_RETOPTS:
717df8bae1dSRodney W. Grimes 			*mp = m = m_get(M_WAIT, MT_SOOPTS);
718df8bae1dSRodney W. Grimes 			if (inp->inp_options) {
719df8bae1dSRodney W. Grimes 				m->m_len = inp->inp_options->m_len;
7200453d3cbSBruce Evans 				bcopy(mtod(inp->inp_options, void *),
7210453d3cbSBruce Evans 				    mtod(m, void *), m->m_len);
722df8bae1dSRodney W. Grimes 			} else
723df8bae1dSRodney W. Grimes 				m->m_len = 0;
724df8bae1dSRodney W. Grimes 			break;
725df8bae1dSRodney W. Grimes 
726df8bae1dSRodney W. Grimes 		case IP_TOS:
727df8bae1dSRodney W. Grimes 		case IP_TTL:
728df8bae1dSRodney W. Grimes 		case IP_RECVOPTS:
729df8bae1dSRodney W. Grimes 		case IP_RECVRETOPTS:
730df8bae1dSRodney W. Grimes 		case IP_RECVDSTADDR:
731df8bae1dSRodney W. Grimes 			*mp = m = m_get(M_WAIT, MT_SOOPTS);
732df8bae1dSRodney W. Grimes 			m->m_len = sizeof(int);
733df8bae1dSRodney W. Grimes 			switch (optname) {
734df8bae1dSRodney W. Grimes 
735df8bae1dSRodney W. Grimes 			case IP_TOS:
736df8bae1dSRodney W. Grimes 				optval = inp->inp_ip.ip_tos;
737df8bae1dSRodney W. Grimes 				break;
738df8bae1dSRodney W. Grimes 
739df8bae1dSRodney W. Grimes 			case IP_TTL:
740df8bae1dSRodney W. Grimes 				optval = inp->inp_ip.ip_ttl;
741df8bae1dSRodney W. Grimes 				break;
742df8bae1dSRodney W. Grimes 
743df8bae1dSRodney W. Grimes #define	OPTBIT(bit)	(inp->inp_flags & bit ? 1 : 0)
744df8bae1dSRodney W. Grimes 
745df8bae1dSRodney W. Grimes 			case IP_RECVOPTS:
746df8bae1dSRodney W. Grimes 				optval = OPTBIT(INP_RECVOPTS);
747df8bae1dSRodney W. Grimes 				break;
748df8bae1dSRodney W. Grimes 
749df8bae1dSRodney W. Grimes 			case IP_RECVRETOPTS:
750df8bae1dSRodney W. Grimes 				optval = OPTBIT(INP_RECVRETOPTS);
751df8bae1dSRodney W. Grimes 				break;
752df8bae1dSRodney W. Grimes 
753df8bae1dSRodney W. Grimes 			case IP_RECVDSTADDR:
754df8bae1dSRodney W. Grimes 				optval = OPTBIT(INP_RECVDSTADDR);
755df8bae1dSRodney W. Grimes 				break;
756df8bae1dSRodney W. Grimes 			}
757df8bae1dSRodney W. Grimes 			*mtod(m, int *) = optval;
758df8bae1dSRodney W. Grimes 			break;
759df8bae1dSRodney W. Grimes 
760df8bae1dSRodney W. Grimes 		case IP_MULTICAST_IF:
761f0068c4aSGarrett Wollman 		case IP_MULTICAST_VIF:
762df8bae1dSRodney W. Grimes 		case IP_MULTICAST_TTL:
763df8bae1dSRodney W. Grimes 		case IP_MULTICAST_LOOP:
764df8bae1dSRodney W. Grimes 		case IP_ADD_MEMBERSHIP:
765df8bae1dSRodney W. Grimes 		case IP_DROP_MEMBERSHIP:
766df8bae1dSRodney W. Grimes 			error = ip_getmoptions(optname, inp->inp_moptions, mp);
767df8bae1dSRodney W. Grimes 			break;
768df8bae1dSRodney W. Grimes 
76933b3ac06SPeter Wemm 		case IP_PORTRANGE:
77033b3ac06SPeter Wemm 			*mp = m = m_get(M_WAIT, MT_SOOPTS);
77133b3ac06SPeter Wemm 			m->m_len = sizeof(int);
77233b3ac06SPeter Wemm 
77333b3ac06SPeter Wemm 			if (inp->inp_flags & INP_HIGHPORT)
77433b3ac06SPeter Wemm 				optval = IP_PORTRANGE_HIGH;
77533b3ac06SPeter Wemm 			else if (inp->inp_flags & INP_LOWPORT)
77633b3ac06SPeter Wemm 				optval = IP_PORTRANGE_LOW;
77733b3ac06SPeter Wemm 			else
77833b3ac06SPeter Wemm 				optval = 0;
77933b3ac06SPeter Wemm 
78033b3ac06SPeter Wemm 			*mtod(m, int *) = optval;
78133b3ac06SPeter Wemm 			break;
78233b3ac06SPeter Wemm 
783df8bae1dSRodney W. Grimes 		default:
784df8bae1dSRodney W. Grimes 			error = ENOPROTOOPT;
785df8bae1dSRodney W. Grimes 			break;
786df8bae1dSRodney W. Grimes 		}
787df8bae1dSRodney W. Grimes 		break;
788df8bae1dSRodney W. Grimes 	}
789df8bae1dSRodney W. Grimes 	return (error);
790df8bae1dSRodney W. Grimes }
791df8bae1dSRodney W. Grimes 
792df8bae1dSRodney W. Grimes /*
793df8bae1dSRodney W. Grimes  * Set up IP options in pcb for insertion in output packets.
794df8bae1dSRodney W. Grimes  * Store in mbuf with pointer in pcbopt, adding pseudo-option
795df8bae1dSRodney W. Grimes  * with destination address if source routed.
796df8bae1dSRodney W. Grimes  */
7970312fbe9SPoul-Henning Kamp static int
798df8bae1dSRodney W. Grimes #ifdef notyet
799df8bae1dSRodney W. Grimes ip_pcbopts(optname, pcbopt, m)
800df8bae1dSRodney W. Grimes 	int optname;
801df8bae1dSRodney W. Grimes #else
802df8bae1dSRodney W. Grimes ip_pcbopts(pcbopt, m)
803df8bae1dSRodney W. Grimes #endif
804df8bae1dSRodney W. Grimes 	struct mbuf **pcbopt;
805df8bae1dSRodney W. Grimes 	register struct mbuf *m;
806df8bae1dSRodney W. Grimes {
807df8bae1dSRodney W. Grimes 	register cnt, optlen;
808df8bae1dSRodney W. Grimes 	register u_char *cp;
809df8bae1dSRodney W. Grimes 	u_char opt;
810df8bae1dSRodney W. Grimes 
811df8bae1dSRodney W. Grimes 	/* turn off any old options */
812df8bae1dSRodney W. Grimes 	if (*pcbopt)
813df8bae1dSRodney W. Grimes 		(void)m_free(*pcbopt);
814df8bae1dSRodney W. Grimes 	*pcbopt = 0;
815df8bae1dSRodney W. Grimes 	if (m == (struct mbuf *)0 || m->m_len == 0) {
816df8bae1dSRodney W. Grimes 		/*
817df8bae1dSRodney W. Grimes 		 * Only turning off any previous options.
818df8bae1dSRodney W. Grimes 		 */
819df8bae1dSRodney W. Grimes 		if (m)
820df8bae1dSRodney W. Grimes 			(void)m_free(m);
821df8bae1dSRodney W. Grimes 		return (0);
822df8bae1dSRodney W. Grimes 	}
823df8bae1dSRodney W. Grimes 
824df8bae1dSRodney W. Grimes #ifndef	vax
825df8bae1dSRodney W. Grimes 	if (m->m_len % sizeof(long))
826df8bae1dSRodney W. Grimes 		goto bad;
827df8bae1dSRodney W. Grimes #endif
828df8bae1dSRodney W. Grimes 	/*
829df8bae1dSRodney W. Grimes 	 * IP first-hop destination address will be stored before
830df8bae1dSRodney W. Grimes 	 * actual options; move other options back
831df8bae1dSRodney W. Grimes 	 * and clear it when none present.
832df8bae1dSRodney W. Grimes 	 */
833df8bae1dSRodney W. Grimes 	if (m->m_data + m->m_len + sizeof(struct in_addr) >= &m->m_dat[MLEN])
834df8bae1dSRodney W. Grimes 		goto bad;
835df8bae1dSRodney W. Grimes 	cnt = m->m_len;
836df8bae1dSRodney W. Grimes 	m->m_len += sizeof(struct in_addr);
837df8bae1dSRodney W. Grimes 	cp = mtod(m, u_char *) + sizeof(struct in_addr);
838df8bae1dSRodney W. Grimes 	ovbcopy(mtod(m, caddr_t), (caddr_t)cp, (unsigned)cnt);
839df8bae1dSRodney W. Grimes 	bzero(mtod(m, caddr_t), sizeof(struct in_addr));
840df8bae1dSRodney W. Grimes 
841df8bae1dSRodney W. Grimes 	for (; cnt > 0; cnt -= optlen, cp += optlen) {
842df8bae1dSRodney W. Grimes 		opt = cp[IPOPT_OPTVAL];
843df8bae1dSRodney W. Grimes 		if (opt == IPOPT_EOL)
844df8bae1dSRodney W. Grimes 			break;
845df8bae1dSRodney W. Grimes 		if (opt == IPOPT_NOP)
846df8bae1dSRodney W. Grimes 			optlen = 1;
847df8bae1dSRodney W. Grimes 		else {
848df8bae1dSRodney W. Grimes 			optlen = cp[IPOPT_OLEN];
849df8bae1dSRodney W. Grimes 			if (optlen <= IPOPT_OLEN || optlen > cnt)
850df8bae1dSRodney W. Grimes 				goto bad;
851df8bae1dSRodney W. Grimes 		}
852df8bae1dSRodney W. Grimes 		switch (opt) {
853df8bae1dSRodney W. Grimes 
854df8bae1dSRodney W. Grimes 		default:
855df8bae1dSRodney W. Grimes 			break;
856df8bae1dSRodney W. Grimes 
857df8bae1dSRodney W. Grimes 		case IPOPT_LSRR:
858df8bae1dSRodney W. Grimes 		case IPOPT_SSRR:
859df8bae1dSRodney W. Grimes 			/*
860df8bae1dSRodney W. Grimes 			 * user process specifies route as:
861df8bae1dSRodney W. Grimes 			 *	->A->B->C->D
862df8bae1dSRodney W. Grimes 			 * D must be our final destination (but we can't
863df8bae1dSRodney W. Grimes 			 * check that since we may not have connected yet).
864df8bae1dSRodney W. Grimes 			 * A is first hop destination, which doesn't appear in
865df8bae1dSRodney W. Grimes 			 * actual IP option, but is stored before the options.
866df8bae1dSRodney W. Grimes 			 */
867df8bae1dSRodney W. Grimes 			if (optlen < IPOPT_MINOFF - 1 + sizeof(struct in_addr))
868df8bae1dSRodney W. Grimes 				goto bad;
869df8bae1dSRodney W. Grimes 			m->m_len -= sizeof(struct in_addr);
870df8bae1dSRodney W. Grimes 			cnt -= sizeof(struct in_addr);
871df8bae1dSRodney W. Grimes 			optlen -= sizeof(struct in_addr);
872df8bae1dSRodney W. Grimes 			cp[IPOPT_OLEN] = optlen;
873df8bae1dSRodney W. Grimes 			/*
874df8bae1dSRodney W. Grimes 			 * Move first hop before start of options.
875df8bae1dSRodney W. Grimes 			 */
876df8bae1dSRodney W. Grimes 			bcopy((caddr_t)&cp[IPOPT_OFFSET+1], mtod(m, caddr_t),
877df8bae1dSRodney W. Grimes 			    sizeof(struct in_addr));
878df8bae1dSRodney W. Grimes 			/*
879df8bae1dSRodney W. Grimes 			 * Then copy rest of options back
880df8bae1dSRodney W. Grimes 			 * to close up the deleted entry.
881df8bae1dSRodney W. Grimes 			 */
882df8bae1dSRodney W. Grimes 			ovbcopy((caddr_t)(&cp[IPOPT_OFFSET+1] +
883df8bae1dSRodney W. Grimes 			    sizeof(struct in_addr)),
884df8bae1dSRodney W. Grimes 			    (caddr_t)&cp[IPOPT_OFFSET+1],
885df8bae1dSRodney W. Grimes 			    (unsigned)cnt + sizeof(struct in_addr));
886df8bae1dSRodney W. Grimes 			break;
887df8bae1dSRodney W. Grimes 		}
888df8bae1dSRodney W. Grimes 	}
889df8bae1dSRodney W. Grimes 	if (m->m_len > MAX_IPOPTLEN + sizeof(struct in_addr))
890df8bae1dSRodney W. Grimes 		goto bad;
891df8bae1dSRodney W. Grimes 	*pcbopt = m;
892df8bae1dSRodney W. Grimes 	return (0);
893df8bae1dSRodney W. Grimes 
894df8bae1dSRodney W. Grimes bad:
895df8bae1dSRodney W. Grimes 	(void)m_free(m);
896df8bae1dSRodney W. Grimes 	return (EINVAL);
897df8bae1dSRodney W. Grimes }
898df8bae1dSRodney W. Grimes 
899df8bae1dSRodney W. Grimes /*
900df8bae1dSRodney W. Grimes  * Set the IP multicast options in response to user setsockopt().
901df8bae1dSRodney W. Grimes  */
9020312fbe9SPoul-Henning Kamp static int
903df8bae1dSRodney W. Grimes ip_setmoptions(optname, imop, m)
904df8bae1dSRodney W. Grimes 	int optname;
905df8bae1dSRodney W. Grimes 	struct ip_moptions **imop;
906df8bae1dSRodney W. Grimes 	struct mbuf *m;
907df8bae1dSRodney W. Grimes {
908df8bae1dSRodney W. Grimes 	register int error = 0;
909df8bae1dSRodney W. Grimes 	u_char loop;
910df8bae1dSRodney W. Grimes 	register int i;
911df8bae1dSRodney W. Grimes 	struct in_addr addr;
912df8bae1dSRodney W. Grimes 	register struct ip_mreq *mreq;
913df8bae1dSRodney W. Grimes 	register struct ifnet *ifp;
914df8bae1dSRodney W. Grimes 	register struct ip_moptions *imo = *imop;
915df8bae1dSRodney W. Grimes 	struct route ro;
916df8bae1dSRodney W. Grimes 	register struct sockaddr_in *dst;
9179b626c29SGarrett Wollman 	int s;
918df8bae1dSRodney W. Grimes 
919df8bae1dSRodney W. Grimes 	if (imo == NULL) {
920df8bae1dSRodney W. Grimes 		/*
921df8bae1dSRodney W. Grimes 		 * No multicast option buffer attached to the pcb;
922df8bae1dSRodney W. Grimes 		 * allocate one and initialize to default values.
923df8bae1dSRodney W. Grimes 		 */
924df8bae1dSRodney W. Grimes 		imo = (struct ip_moptions*)malloc(sizeof(*imo), M_IPMOPTS,
925df8bae1dSRodney W. Grimes 		    M_WAITOK);
926df8bae1dSRodney W. Grimes 
927df8bae1dSRodney W. Grimes 		if (imo == NULL)
928df8bae1dSRodney W. Grimes 			return (ENOBUFS);
929df8bae1dSRodney W. Grimes 		*imop = imo;
930df8bae1dSRodney W. Grimes 		imo->imo_multicast_ifp = NULL;
9311c5de19aSGarrett Wollman 		imo->imo_multicast_vif = -1;
932df8bae1dSRodney W. Grimes 		imo->imo_multicast_ttl = IP_DEFAULT_MULTICAST_TTL;
933df8bae1dSRodney W. Grimes 		imo->imo_multicast_loop = IP_DEFAULT_MULTICAST_LOOP;
934df8bae1dSRodney W. Grimes 		imo->imo_num_memberships = 0;
935df8bae1dSRodney W. Grimes 	}
936df8bae1dSRodney W. Grimes 
937df8bae1dSRodney W. Grimes 	switch (optname) {
938f0068c4aSGarrett Wollman 	/* store an index number for the vif you wanna use in the send */
939f0068c4aSGarrett Wollman 	case IP_MULTICAST_VIF:
9405e9ae478SGarrett Wollman 		if (!legal_vif_num) {
9415e9ae478SGarrett Wollman 			error = EOPNOTSUPP;
9425e9ae478SGarrett Wollman 			break;
9435e9ae478SGarrett Wollman 		}
944f0068c4aSGarrett Wollman 		if (m == NULL || m->m_len != sizeof(int)) {
945f0068c4aSGarrett Wollman 			error = EINVAL;
946f0068c4aSGarrett Wollman 			break;
947f0068c4aSGarrett Wollman 		}
948f0068c4aSGarrett Wollman 		i = *(mtod(m, int *));
9491c5de19aSGarrett Wollman 		if (!legal_vif_num(i) && (i != -1)) {
950f0068c4aSGarrett Wollman 			error = EINVAL;
951f0068c4aSGarrett Wollman 			break;
952f0068c4aSGarrett Wollman 		}
953f0068c4aSGarrett Wollman 		imo->imo_multicast_vif = i;
954f0068c4aSGarrett Wollman 		break;
955f0068c4aSGarrett Wollman 
956df8bae1dSRodney W. Grimes 	case IP_MULTICAST_IF:
957df8bae1dSRodney W. Grimes 		/*
958df8bae1dSRodney W. Grimes 		 * Select the interface for outgoing multicast packets.
959df8bae1dSRodney W. Grimes 		 */
960df8bae1dSRodney W. Grimes 		if (m == NULL || m->m_len != sizeof(struct in_addr)) {
961df8bae1dSRodney W. Grimes 			error = EINVAL;
962df8bae1dSRodney W. Grimes 			break;
963df8bae1dSRodney W. Grimes 		}
964df8bae1dSRodney W. Grimes 		addr = *(mtod(m, struct in_addr *));
965df8bae1dSRodney W. Grimes 		/*
966df8bae1dSRodney W. Grimes 		 * INADDR_ANY is used to remove a previous selection.
967df8bae1dSRodney W. Grimes 		 * When no interface is selected, a default one is
968df8bae1dSRodney W. Grimes 		 * chosen every time a multicast packet is sent.
969df8bae1dSRodney W. Grimes 		 */
970df8bae1dSRodney W. Grimes 		if (addr.s_addr == INADDR_ANY) {
971df8bae1dSRodney W. Grimes 			imo->imo_multicast_ifp = NULL;
972df8bae1dSRodney W. Grimes 			break;
973df8bae1dSRodney W. Grimes 		}
974df8bae1dSRodney W. Grimes 		/*
975df8bae1dSRodney W. Grimes 		 * The selected interface is identified by its local
976df8bae1dSRodney W. Grimes 		 * IP address.  Find the interface and confirm that
977df8bae1dSRodney W. Grimes 		 * it supports multicasting.
978df8bae1dSRodney W. Grimes 		 */
97920e8807cSGarrett Wollman 		s = splimp();
980df8bae1dSRodney W. Grimes 		INADDR_TO_IFP(addr, ifp);
981df8bae1dSRodney W. Grimes 		if (ifp == NULL || (ifp->if_flags & IFF_MULTICAST) == 0) {
982fbc6ab00SBill Fenner 			splx(s);
983df8bae1dSRodney W. Grimes 			error = EADDRNOTAVAIL;
984df8bae1dSRodney W. Grimes 			break;
985df8bae1dSRodney W. Grimes 		}
986df8bae1dSRodney W. Grimes 		imo->imo_multicast_ifp = ifp;
9879b626c29SGarrett Wollman 		splx(s);
988df8bae1dSRodney W. Grimes 		break;
989df8bae1dSRodney W. Grimes 
990df8bae1dSRodney W. Grimes 	case IP_MULTICAST_TTL:
991df8bae1dSRodney W. Grimes 		/*
992df8bae1dSRodney W. Grimes 		 * Set the IP time-to-live for outgoing multicast packets.
993df8bae1dSRodney W. Grimes 		 */
994df8bae1dSRodney W. Grimes 		if (m == NULL || m->m_len != 1) {
995df8bae1dSRodney W. Grimes 			error = EINVAL;
996df8bae1dSRodney W. Grimes 			break;
997df8bae1dSRodney W. Grimes 		}
998df8bae1dSRodney W. Grimes 		imo->imo_multicast_ttl = *(mtod(m, u_char *));
999df8bae1dSRodney W. Grimes 		break;
1000df8bae1dSRodney W. Grimes 
1001df8bae1dSRodney W. Grimes 	case IP_MULTICAST_LOOP:
1002df8bae1dSRodney W. Grimes 		/*
1003df8bae1dSRodney W. Grimes 		 * Set the loopback flag for outgoing multicast packets.
1004df8bae1dSRodney W. Grimes 		 * Must be zero or one.
1005df8bae1dSRodney W. Grimes 		 */
1006df8bae1dSRodney W. Grimes 		if (m == NULL || m->m_len != 1 ||
1007df8bae1dSRodney W. Grimes 		   (loop = *(mtod(m, u_char *))) > 1) {
1008df8bae1dSRodney W. Grimes 			error = EINVAL;
1009df8bae1dSRodney W. Grimes 			break;
1010df8bae1dSRodney W. Grimes 		}
1011df8bae1dSRodney W. Grimes 		imo->imo_multicast_loop = loop;
1012df8bae1dSRodney W. Grimes 		break;
1013df8bae1dSRodney W. Grimes 
1014df8bae1dSRodney W. Grimes 	case IP_ADD_MEMBERSHIP:
1015df8bae1dSRodney W. Grimes 		/*
1016df8bae1dSRodney W. Grimes 		 * Add a multicast group membership.
1017df8bae1dSRodney W. Grimes 		 * Group must be a valid IP multicast address.
1018df8bae1dSRodney W. Grimes 		 */
1019df8bae1dSRodney W. Grimes 		if (m == NULL || m->m_len != sizeof(struct ip_mreq)) {
1020df8bae1dSRodney W. Grimes 			error = EINVAL;
1021df8bae1dSRodney W. Grimes 			break;
1022df8bae1dSRodney W. Grimes 		}
1023df8bae1dSRodney W. Grimes 		mreq = mtod(m, struct ip_mreq *);
1024df8bae1dSRodney W. Grimes 		if (!IN_MULTICAST(ntohl(mreq->imr_multiaddr.s_addr))) {
1025df8bae1dSRodney W. Grimes 			error = EINVAL;
1026df8bae1dSRodney W. Grimes 			break;
1027df8bae1dSRodney W. Grimes 		}
102820e8807cSGarrett Wollman 		s = splimp();
1029df8bae1dSRodney W. Grimes 		/*
1030df8bae1dSRodney W. Grimes 		 * If no interface address was provided, use the interface of
1031df8bae1dSRodney W. Grimes 		 * the route to the given multicast address.
1032df8bae1dSRodney W. Grimes 		 */
1033df8bae1dSRodney W. Grimes 		if (mreq->imr_interface.s_addr == INADDR_ANY) {
10341c5de19aSGarrett Wollman 			bzero((caddr_t)&ro, sizeof(ro));
1035df8bae1dSRodney W. Grimes 			dst = (struct sockaddr_in *)&ro.ro_dst;
1036df8bae1dSRodney W. Grimes 			dst->sin_len = sizeof(*dst);
1037df8bae1dSRodney W. Grimes 			dst->sin_family = AF_INET;
1038df8bae1dSRodney W. Grimes 			dst->sin_addr = mreq->imr_multiaddr;
1039df8bae1dSRodney W. Grimes 			rtalloc(&ro);
1040df8bae1dSRodney W. Grimes 			if (ro.ro_rt == NULL) {
1041df8bae1dSRodney W. Grimes 				error = EADDRNOTAVAIL;
10429b626c29SGarrett Wollman 				splx(s);
1043df8bae1dSRodney W. Grimes 				break;
1044df8bae1dSRodney W. Grimes 			}
1045df8bae1dSRodney W. Grimes 			ifp = ro.ro_rt->rt_ifp;
1046df8bae1dSRodney W. Grimes 			rtfree(ro.ro_rt);
1047df8bae1dSRodney W. Grimes 		}
1048df8bae1dSRodney W. Grimes 		else {
1049df8bae1dSRodney W. Grimes 			INADDR_TO_IFP(mreq->imr_interface, ifp);
1050df8bae1dSRodney W. Grimes 		}
10519b626c29SGarrett Wollman 
1052df8bae1dSRodney W. Grimes 		/*
1053df8bae1dSRodney W. Grimes 		 * See if we found an interface, and confirm that it
1054df8bae1dSRodney W. Grimes 		 * supports multicast.
1055df8bae1dSRodney W. Grimes 		 */
1056df8bae1dSRodney W. Grimes 		if (ifp == NULL || (ifp->if_flags & IFF_MULTICAST) == 0) {
1057df8bae1dSRodney W. Grimes 			error = EADDRNOTAVAIL;
10589b626c29SGarrett Wollman 			splx(s);
1059df8bae1dSRodney W. Grimes 			break;
1060df8bae1dSRodney W. Grimes 		}
1061df8bae1dSRodney W. Grimes 		/*
1062df8bae1dSRodney W. Grimes 		 * See if the membership already exists or if all the
1063df8bae1dSRodney W. Grimes 		 * membership slots are full.
1064df8bae1dSRodney W. Grimes 		 */
1065df8bae1dSRodney W. Grimes 		for (i = 0; i < imo->imo_num_memberships; ++i) {
1066df8bae1dSRodney W. Grimes 			if (imo->imo_membership[i]->inm_ifp == ifp &&
1067df8bae1dSRodney W. Grimes 			    imo->imo_membership[i]->inm_addr.s_addr
1068df8bae1dSRodney W. Grimes 						== mreq->imr_multiaddr.s_addr)
1069df8bae1dSRodney W. Grimes 				break;
1070df8bae1dSRodney W. Grimes 		}
1071df8bae1dSRodney W. Grimes 		if (i < imo->imo_num_memberships) {
1072df8bae1dSRodney W. Grimes 			error = EADDRINUSE;
10739b626c29SGarrett Wollman 			splx(s);
1074df8bae1dSRodney W. Grimes 			break;
1075df8bae1dSRodney W. Grimes 		}
1076df8bae1dSRodney W. Grimes 		if (i == IP_MAX_MEMBERSHIPS) {
1077df8bae1dSRodney W. Grimes 			error = ETOOMANYREFS;
10789b626c29SGarrett Wollman 			splx(s);
1079df8bae1dSRodney W. Grimes 			break;
1080df8bae1dSRodney W. Grimes 		}
1081df8bae1dSRodney W. Grimes 		/*
1082df8bae1dSRodney W. Grimes 		 * Everything looks good; add a new record to the multicast
1083df8bae1dSRodney W. Grimes 		 * address list for the given interface.
1084df8bae1dSRodney W. Grimes 		 */
1085df8bae1dSRodney W. Grimes 		if ((imo->imo_membership[i] =
1086df8bae1dSRodney W. Grimes 		    in_addmulti(&mreq->imr_multiaddr, ifp)) == NULL) {
1087df8bae1dSRodney W. Grimes 			error = ENOBUFS;
10889b626c29SGarrett Wollman 			splx(s);
1089df8bae1dSRodney W. Grimes 			break;
1090df8bae1dSRodney W. Grimes 		}
1091df8bae1dSRodney W. Grimes 		++imo->imo_num_memberships;
10929b626c29SGarrett Wollman 		splx(s);
1093df8bae1dSRodney W. Grimes 		break;
1094df8bae1dSRodney W. Grimes 
1095df8bae1dSRodney W. Grimes 	case IP_DROP_MEMBERSHIP:
1096df8bae1dSRodney W. Grimes 		/*
1097df8bae1dSRodney W. Grimes 		 * Drop a multicast group membership.
1098df8bae1dSRodney W. Grimes 		 * Group must be a valid IP multicast address.
1099df8bae1dSRodney W. Grimes 		 */
1100df8bae1dSRodney W. Grimes 		if (m == NULL || m->m_len != sizeof(struct ip_mreq)) {
1101df8bae1dSRodney W. Grimes 			error = EINVAL;
1102df8bae1dSRodney W. Grimes 			break;
1103df8bae1dSRodney W. Grimes 		}
1104df8bae1dSRodney W. Grimes 		mreq = mtod(m, struct ip_mreq *);
1105df8bae1dSRodney W. Grimes 		if (!IN_MULTICAST(ntohl(mreq->imr_multiaddr.s_addr))) {
1106df8bae1dSRodney W. Grimes 			error = EINVAL;
1107df8bae1dSRodney W. Grimes 			break;
1108df8bae1dSRodney W. Grimes 		}
11099b626c29SGarrett Wollman 
111020e8807cSGarrett Wollman 		s = splimp();
1111df8bae1dSRodney W. Grimes 		/*
1112df8bae1dSRodney W. Grimes 		 * If an interface address was specified, get a pointer
1113df8bae1dSRodney W. Grimes 		 * to its ifnet structure.
1114df8bae1dSRodney W. Grimes 		 */
1115df8bae1dSRodney W. Grimes 		if (mreq->imr_interface.s_addr == INADDR_ANY)
1116df8bae1dSRodney W. Grimes 			ifp = NULL;
1117df8bae1dSRodney W. Grimes 		else {
1118df8bae1dSRodney W. Grimes 			INADDR_TO_IFP(mreq->imr_interface, ifp);
1119df8bae1dSRodney W. Grimes 			if (ifp == NULL) {
1120df8bae1dSRodney W. Grimes 				error = EADDRNOTAVAIL;
11219b626c29SGarrett Wollman 				splx(s);
1122df8bae1dSRodney W. Grimes 				break;
1123df8bae1dSRodney W. Grimes 			}
1124df8bae1dSRodney W. Grimes 		}
1125df8bae1dSRodney W. Grimes 		/*
1126df8bae1dSRodney W. Grimes 		 * Find the membership in the membership array.
1127df8bae1dSRodney W. Grimes 		 */
1128df8bae1dSRodney W. Grimes 		for (i = 0; i < imo->imo_num_memberships; ++i) {
1129df8bae1dSRodney W. Grimes 			if ((ifp == NULL ||
1130df8bae1dSRodney W. Grimes 			     imo->imo_membership[i]->inm_ifp == ifp) &&
1131df8bae1dSRodney W. Grimes 			     imo->imo_membership[i]->inm_addr.s_addr ==
1132df8bae1dSRodney W. Grimes 			     mreq->imr_multiaddr.s_addr)
1133df8bae1dSRodney W. Grimes 				break;
1134df8bae1dSRodney W. Grimes 		}
1135df8bae1dSRodney W. Grimes 		if (i == imo->imo_num_memberships) {
1136df8bae1dSRodney W. Grimes 			error = EADDRNOTAVAIL;
11379b626c29SGarrett Wollman 			splx(s);
1138df8bae1dSRodney W. Grimes 			break;
1139df8bae1dSRodney W. Grimes 		}
1140df8bae1dSRodney W. Grimes 		/*
1141df8bae1dSRodney W. Grimes 		 * Give up the multicast address record to which the
1142df8bae1dSRodney W. Grimes 		 * membership points.
1143df8bae1dSRodney W. Grimes 		 */
1144df8bae1dSRodney W. Grimes 		in_delmulti(imo->imo_membership[i]);
1145df8bae1dSRodney W. Grimes 		/*
1146df8bae1dSRodney W. Grimes 		 * Remove the gap in the membership array.
1147df8bae1dSRodney W. Grimes 		 */
1148df8bae1dSRodney W. Grimes 		for (++i; i < imo->imo_num_memberships; ++i)
1149df8bae1dSRodney W. Grimes 			imo->imo_membership[i-1] = imo->imo_membership[i];
1150df8bae1dSRodney W. Grimes 		--imo->imo_num_memberships;
11519b626c29SGarrett Wollman 		splx(s);
1152df8bae1dSRodney W. Grimes 		break;
1153df8bae1dSRodney W. Grimes 
1154df8bae1dSRodney W. Grimes 	default:
1155df8bae1dSRodney W. Grimes 		error = EOPNOTSUPP;
1156df8bae1dSRodney W. Grimes 		break;
1157df8bae1dSRodney W. Grimes 	}
1158df8bae1dSRodney W. Grimes 
1159df8bae1dSRodney W. Grimes 	/*
1160df8bae1dSRodney W. Grimes 	 * If all options have default values, no need to keep the mbuf.
1161df8bae1dSRodney W. Grimes 	 */
1162df8bae1dSRodney W. Grimes 	if (imo->imo_multicast_ifp == NULL &&
11631c5de19aSGarrett Wollman 	    imo->imo_multicast_vif == -1 &&
1164df8bae1dSRodney W. Grimes 	    imo->imo_multicast_ttl == IP_DEFAULT_MULTICAST_TTL &&
1165df8bae1dSRodney W. Grimes 	    imo->imo_multicast_loop == IP_DEFAULT_MULTICAST_LOOP &&
1166df8bae1dSRodney W. Grimes 	    imo->imo_num_memberships == 0) {
1167df8bae1dSRodney W. Grimes 		free(*imop, M_IPMOPTS);
1168df8bae1dSRodney W. Grimes 		*imop = NULL;
1169df8bae1dSRodney W. Grimes 	}
1170df8bae1dSRodney W. Grimes 
1171df8bae1dSRodney W. Grimes 	return (error);
1172df8bae1dSRodney W. Grimes }
1173df8bae1dSRodney W. Grimes 
1174df8bae1dSRodney W. Grimes /*
1175df8bae1dSRodney W. Grimes  * Return the IP multicast options in response to user getsockopt().
1176df8bae1dSRodney W. Grimes  */
11770312fbe9SPoul-Henning Kamp static int
1178df8bae1dSRodney W. Grimes ip_getmoptions(optname, imo, mp)
1179df8bae1dSRodney W. Grimes 	int optname;
1180df8bae1dSRodney W. Grimes 	register struct ip_moptions *imo;
1181df8bae1dSRodney W. Grimes 	register struct mbuf **mp;
1182df8bae1dSRodney W. Grimes {
1183df8bae1dSRodney W. Grimes 	u_char *ttl;
1184df8bae1dSRodney W. Grimes 	u_char *loop;
1185df8bae1dSRodney W. Grimes 	struct in_addr *addr;
1186df8bae1dSRodney W. Grimes 	struct in_ifaddr *ia;
1187df8bae1dSRodney W. Grimes 
1188df8bae1dSRodney W. Grimes 	*mp = m_get(M_WAIT, MT_SOOPTS);
1189df8bae1dSRodney W. Grimes 
1190df8bae1dSRodney W. Grimes 	switch (optname) {
1191df8bae1dSRodney W. Grimes 
1192f0068c4aSGarrett Wollman 	case IP_MULTICAST_VIF:
1193f0068c4aSGarrett Wollman 		if (imo != NULL)
1194f0068c4aSGarrett Wollman 			*(mtod(*mp, int *)) = imo->imo_multicast_vif;
1195f0068c4aSGarrett Wollman 		else
11961c5de19aSGarrett Wollman 			*(mtod(*mp, int *)) = -1;
1197f0068c4aSGarrett Wollman 		(*mp)->m_len = sizeof(int);
1198f0068c4aSGarrett Wollman 		return(0);
1199f0068c4aSGarrett Wollman 
1200df8bae1dSRodney W. Grimes 	case IP_MULTICAST_IF:
1201df8bae1dSRodney W. Grimes 		addr = mtod(*mp, struct in_addr *);
1202df8bae1dSRodney W. Grimes 		(*mp)->m_len = sizeof(struct in_addr);
1203df8bae1dSRodney W. Grimes 		if (imo == NULL || imo->imo_multicast_ifp == NULL)
1204df8bae1dSRodney W. Grimes 			addr->s_addr = INADDR_ANY;
1205df8bae1dSRodney W. Grimes 		else {
1206df8bae1dSRodney W. Grimes 			IFP_TO_IA(imo->imo_multicast_ifp, ia);
1207df8bae1dSRodney W. Grimes 			addr->s_addr = (ia == NULL) ? INADDR_ANY
1208df8bae1dSRodney W. Grimes 					: IA_SIN(ia)->sin_addr.s_addr;
1209df8bae1dSRodney W. Grimes 		}
1210df8bae1dSRodney W. Grimes 		return (0);
1211df8bae1dSRodney W. Grimes 
1212df8bae1dSRodney W. Grimes 	case IP_MULTICAST_TTL:
1213df8bae1dSRodney W. Grimes 		ttl = mtod(*mp, u_char *);
1214df8bae1dSRodney W. Grimes 		(*mp)->m_len = 1;
1215df8bae1dSRodney W. Grimes 		*ttl = (imo == NULL) ? IP_DEFAULT_MULTICAST_TTL
1216df8bae1dSRodney W. Grimes 				     : imo->imo_multicast_ttl;
1217df8bae1dSRodney W. Grimes 		return (0);
1218df8bae1dSRodney W. Grimes 
1219df8bae1dSRodney W. Grimes 	case IP_MULTICAST_LOOP:
1220df8bae1dSRodney W. Grimes 		loop = mtod(*mp, u_char *);
1221df8bae1dSRodney W. Grimes 		(*mp)->m_len = 1;
1222df8bae1dSRodney W. Grimes 		*loop = (imo == NULL) ? IP_DEFAULT_MULTICAST_LOOP
1223df8bae1dSRodney W. Grimes 				      : imo->imo_multicast_loop;
1224df8bae1dSRodney W. Grimes 		return (0);
1225df8bae1dSRodney W. Grimes 
1226df8bae1dSRodney W. Grimes 	default:
1227df8bae1dSRodney W. Grimes 		return (EOPNOTSUPP);
1228df8bae1dSRodney W. Grimes 	}
1229df8bae1dSRodney W. Grimes }
1230df8bae1dSRodney W. Grimes 
1231df8bae1dSRodney W. Grimes /*
1232df8bae1dSRodney W. Grimes  * Discard the IP multicast options.
1233df8bae1dSRodney W. Grimes  */
1234df8bae1dSRodney W. Grimes void
1235df8bae1dSRodney W. Grimes ip_freemoptions(imo)
1236df8bae1dSRodney W. Grimes 	register struct ip_moptions *imo;
1237df8bae1dSRodney W. Grimes {
1238df8bae1dSRodney W. Grimes 	register int i;
1239df8bae1dSRodney W. Grimes 
1240df8bae1dSRodney W. Grimes 	if (imo != NULL) {
1241df8bae1dSRodney W. Grimes 		for (i = 0; i < imo->imo_num_memberships; ++i)
1242df8bae1dSRodney W. Grimes 			in_delmulti(imo->imo_membership[i]);
1243df8bae1dSRodney W. Grimes 		free(imo, M_IPMOPTS);
1244df8bae1dSRodney W. Grimes 	}
1245df8bae1dSRodney W. Grimes }
1246df8bae1dSRodney W. Grimes 
1247df8bae1dSRodney W. Grimes /*
1248df8bae1dSRodney W. Grimes  * Routine called from ip_output() to loop back a copy of an IP multicast
1249df8bae1dSRodney W. Grimes  * packet to the input queue of a specified interface.  Note that this
1250df8bae1dSRodney W. Grimes  * calls the output routine of the loopback "driver", but with an interface
1251f5fea3ddSPaul Traina  * pointer that might NOT be a loopback interface -- evil, but easier than
1252f5fea3ddSPaul Traina  * replicating that code here.
1253df8bae1dSRodney W. Grimes  */
1254df8bae1dSRodney W. Grimes static void
1255df8bae1dSRodney W. Grimes ip_mloopback(ifp, m, dst)
1256df8bae1dSRodney W. Grimes 	struct ifnet *ifp;
1257df8bae1dSRodney W. Grimes 	register struct mbuf *m;
1258df8bae1dSRodney W. Grimes 	register struct sockaddr_in *dst;
1259df8bae1dSRodney W. Grimes {
1260df8bae1dSRodney W. Grimes 	register struct ip *ip;
1261df8bae1dSRodney W. Grimes 	struct mbuf *copym;
1262df8bae1dSRodney W. Grimes 
1263df8bae1dSRodney W. Grimes 	copym = m_copy(m, 0, M_COPYALL);
1264df8bae1dSRodney W. Grimes 	if (copym != NULL) {
1265df8bae1dSRodney W. Grimes 		/*
1266df8bae1dSRodney W. Grimes 		 * We don't bother to fragment if the IP length is greater
1267df8bae1dSRodney W. Grimes 		 * than the interface's MTU.  Can this possibly matter?
1268df8bae1dSRodney W. Grimes 		 */
1269df8bae1dSRodney W. Grimes 		ip = mtod(copym, struct ip *);
1270df8bae1dSRodney W. Grimes 		ip->ip_len = htons((u_short)ip->ip_len);
1271df8bae1dSRodney W. Grimes 		ip->ip_off = htons((u_short)ip->ip_off);
1272df8bae1dSRodney W. Grimes 		ip->ip_sum = 0;
12739c9137eaSGarrett Wollman 		if (ip->ip_vhl == IP_VHL_BORING) {
12749c9137eaSGarrett Wollman 			ip->ip_sum = in_cksum_hdr(ip);
12759c9137eaSGarrett Wollman 		} else {
12769c9137eaSGarrett Wollman 			ip->ip_sum = in_cksum(copym,
12779c9137eaSGarrett Wollman 					      IP_VHL_HL(ip->ip_vhl) << 2);
12789c9137eaSGarrett Wollman 		}
12799c9137eaSGarrett Wollman 		/*
12809c9137eaSGarrett Wollman 		 * NB:
12819c9137eaSGarrett Wollman 		 * We can't simply call ip_input() directly because
12829c9137eaSGarrett Wollman 		 * the ip_mforward() depends on the `input interface'
12839c9137eaSGarrett Wollman 		 * being set to something unreasonable so that we don't
12849c9137eaSGarrett Wollman 		 * attempt to forward the looped-back copy.
12859c9137eaSGarrett Wollman 		 * It's also not clear whether there are any lingering
12869c9137eaSGarrett Wollman 		 * reentrancy problems in other areas which might be
12879c9137eaSGarrett Wollman 		 * exposed by this code.  For the moment, we'll err
12889c9137eaSGarrett Wollman 		 * on the side of safety by continuing to abuse
12899c9137eaSGarrett Wollman 		 * loinput().
12909c9137eaSGarrett Wollman 		 */
12919c9137eaSGarrett Wollman #ifdef notdef
12929c9137eaSGarrett Wollman 		copym->m_pkthdr.rcvif = &loif[0];
12939c9137eaSGarrett Wollman 		ip_input(copym)
12949c9137eaSGarrett Wollman #else
1295df8bae1dSRodney W. Grimes 		(void) looutput(ifp, copym, (struct sockaddr *)dst, NULL);
12969c9137eaSGarrett Wollman #endif
1297df8bae1dSRodney W. Grimes 	}
1298df8bae1dSRodney W. Grimes }
1299