xref: /freebsd/sys/netinet/ip_output.c (revision 93e0e11657c61975fdd909f535d89bc6f0eaeceb)
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
3493e0e116SJulian Elischer  *	$Id: ip_output.c,v 1.40 1996/06/08 08:18:59 bde 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:
33493e0e116SJulian Elischer #ifdef COMPAT_IPFW
335df8bae1dSRodney W. Grimes 	/*
336e7319babSPoul-Henning Kamp 	 * Check with the firewall...
337e7319babSPoul-Henning Kamp 	 */
33893e0e116SJulian Elischer 	if (ip_fw_chk_ptr) {
33993e0e116SJulian Elischer 		int action;
34093e0e116SJulian Elischer 
34193e0e116SJulian Elischer #ifdef IPDIVERT
34293e0e116SJulian Elischer 		action = (*ip_fw_chk_ptr)(&ip,
34393e0e116SJulian Elischer 				hlen, ifp, (~0 << 16) | ip_divert_ignore, &m);
34493e0e116SJulian Elischer #else
34593e0e116SJulian Elischer 		action = (*ip_fw_chk_ptr)(&ip, hlen, ifp, (~0 << 16), &m);
346f9493383SGarrett Wollman #endif
34793e0e116SJulian Elischer 		if (action == -1) {
34893e0e116SJulian Elischer 			error = EACCES;		/* XXX is this appropriate? */
34993e0e116SJulian Elischer 			goto done;
35093e0e116SJulian Elischer 		} else if (action != 0) {
35193e0e116SJulian Elischer #ifdef IPDIVERT
35293e0e116SJulian Elischer 			ip_divert_port = action;	/* divert to port */
35393e0e116SJulian Elischer 			(*inetsw[ip_protox[IPPROTO_DIVERT]].pr_input)(m, 0);
35493e0e116SJulian Elischer 			goto done;
35593e0e116SJulian Elischer #else
35693e0e116SJulian Elischer 			m_freem(m);	/* ipfw says divert, but we can't */
35793e0e116SJulian Elischer 			goto done;
35893e0e116SJulian Elischer #endif
35993e0e116SJulian Elischer 		}
36093e0e116SJulian Elischer 	}
36193e0e116SJulian Elischer #endif /* COMPAT_IPFW */
362e7319babSPoul-Henning Kamp 
363e7319babSPoul-Henning Kamp 	/*
364df8bae1dSRodney W. Grimes 	 * If small enough for interface, can just send directly.
365df8bae1dSRodney W. Grimes 	 */
366df8bae1dSRodney W. Grimes 	if ((u_short)ip->ip_len <= ifp->if_mtu) {
367df8bae1dSRodney W. Grimes 		ip->ip_len = htons((u_short)ip->ip_len);
368df8bae1dSRodney W. Grimes 		ip->ip_off = htons((u_short)ip->ip_off);
369df8bae1dSRodney W. Grimes 		ip->ip_sum = 0;
3709c9137eaSGarrett Wollman 		if (ip->ip_vhl == IP_VHL_BORING) {
3719c9137eaSGarrett Wollman 			ip->ip_sum = in_cksum_hdr(ip);
3729c9137eaSGarrett Wollman 		} else {
373df8bae1dSRodney W. Grimes 			ip->ip_sum = in_cksum(m, hlen);
3749c9137eaSGarrett Wollman 		}
375df8bae1dSRodney W. Grimes 		error = (*ifp->if_output)(ifp, m,
376df8bae1dSRodney W. Grimes 				(struct sockaddr *)dst, ro->ro_rt);
377df8bae1dSRodney W. Grimes 		goto done;
378df8bae1dSRodney W. Grimes 	}
379df8bae1dSRodney W. Grimes 	/*
380df8bae1dSRodney W. Grimes 	 * Too large for interface; fragment if possible.
381df8bae1dSRodney W. Grimes 	 * Must be able to put at least 8 bytes per fragment.
382df8bae1dSRodney W. Grimes 	 */
383df8bae1dSRodney W. Grimes 	if (ip->ip_off & IP_DF) {
384df8bae1dSRodney W. Grimes 		error = EMSGSIZE;
3853d1f141bSGarrett Wollman 		/*
3863d1f141bSGarrett Wollman 		 * This case can happen if the user changed the MTU
3873d1f141bSGarrett Wollman 		 * of an interface after enabling IP on it.  Because
3883d1f141bSGarrett Wollman 		 * most netifs don't keep track of routes pointing to
3893d1f141bSGarrett Wollman 		 * them, there is no way for one to update all its
3903d1f141bSGarrett Wollman 		 * routes when the MTU is changed.
3913d1f141bSGarrett Wollman 		 */
3923d1f141bSGarrett Wollman 		if ((ro->ro_rt->rt_flags & (RTF_UP | RTF_HOST))
3933d1f141bSGarrett Wollman 		    && !(ro->ro_rt->rt_rmx.rmx_locks & RTV_MTU)
3943d1f141bSGarrett Wollman 		    && (ro->ro_rt->rt_rmx.rmx_mtu > ifp->if_mtu)) {
3953d1f141bSGarrett Wollman 			ro->ro_rt->rt_rmx.rmx_mtu = ifp->if_mtu;
3963d1f141bSGarrett Wollman 		}
397df8bae1dSRodney W. Grimes 		ipstat.ips_cantfrag++;
398df8bae1dSRodney W. Grimes 		goto bad;
399df8bae1dSRodney W. Grimes 	}
400df8bae1dSRodney W. Grimes 	len = (ifp->if_mtu - hlen) &~ 7;
401df8bae1dSRodney W. Grimes 	if (len < 8) {
402df8bae1dSRodney W. Grimes 		error = EMSGSIZE;
403df8bae1dSRodney W. Grimes 		goto bad;
404df8bae1dSRodney W. Grimes 	}
405df8bae1dSRodney W. Grimes 
406df8bae1dSRodney W. Grimes     {
407df8bae1dSRodney W. Grimes 	int mhlen, firstlen = len;
408df8bae1dSRodney W. Grimes 	struct mbuf **mnext = &m->m_nextpkt;
409df8bae1dSRodney W. Grimes 
410df8bae1dSRodney W. Grimes 	/*
411df8bae1dSRodney W. Grimes 	 * Loop through length of segment after first fragment,
412df8bae1dSRodney W. Grimes 	 * make new header and copy data of each part and link onto chain.
413df8bae1dSRodney W. Grimes 	 */
414df8bae1dSRodney W. Grimes 	m0 = m;
415df8bae1dSRodney W. Grimes 	mhlen = sizeof (struct ip);
416df8bae1dSRodney W. Grimes 	for (off = hlen + len; off < (u_short)ip->ip_len; off += len) {
417df8bae1dSRodney W. Grimes 		MGETHDR(m, M_DONTWAIT, MT_HEADER);
418df8bae1dSRodney W. Grimes 		if (m == 0) {
419df8bae1dSRodney W. Grimes 			error = ENOBUFS;
420df8bae1dSRodney W. Grimes 			ipstat.ips_odropped++;
421df8bae1dSRodney W. Grimes 			goto sendorfree;
422df8bae1dSRodney W. Grimes 		}
423df8bae1dSRodney W. Grimes 		m->m_data += max_linkhdr;
424df8bae1dSRodney W. Grimes 		mhip = mtod(m, struct ip *);
425df8bae1dSRodney W. Grimes 		*mhip = *ip;
426df8bae1dSRodney W. Grimes 		if (hlen > sizeof (struct ip)) {
427df8bae1dSRodney W. Grimes 			mhlen = ip_optcopy(ip, mhip) + sizeof (struct ip);
4289c9137eaSGarrett Wollman 			mhip->ip_vhl = IP_MAKE_VHL(IPVERSION, mhlen >> 2);
429df8bae1dSRodney W. Grimes 		}
430df8bae1dSRodney W. Grimes 		m->m_len = mhlen;
431df8bae1dSRodney W. Grimes 		mhip->ip_off = ((off - hlen) >> 3) + (ip->ip_off & ~IP_MF);
432df8bae1dSRodney W. Grimes 		if (ip->ip_off & IP_MF)
433df8bae1dSRodney W. Grimes 			mhip->ip_off |= IP_MF;
434df8bae1dSRodney W. Grimes 		if (off + len >= (u_short)ip->ip_len)
435df8bae1dSRodney W. Grimes 			len = (u_short)ip->ip_len - off;
436df8bae1dSRodney W. Grimes 		else
437df8bae1dSRodney W. Grimes 			mhip->ip_off |= IP_MF;
438df8bae1dSRodney W. Grimes 		mhip->ip_len = htons((u_short)(len + mhlen));
439df8bae1dSRodney W. Grimes 		m->m_next = m_copy(m0, off, len);
440df8bae1dSRodney W. Grimes 		if (m->m_next == 0) {
441df8bae1dSRodney W. Grimes 			(void) m_free(m);
442df8bae1dSRodney W. Grimes 			error = ENOBUFS;	/* ??? */
443df8bae1dSRodney W. Grimes 			ipstat.ips_odropped++;
444df8bae1dSRodney W. Grimes 			goto sendorfree;
445df8bae1dSRodney W. Grimes 		}
446df8bae1dSRodney W. Grimes 		m->m_pkthdr.len = mhlen + len;
447df8bae1dSRodney W. Grimes 		m->m_pkthdr.rcvif = (struct ifnet *)0;
448df8bae1dSRodney W. Grimes 		mhip->ip_off = htons((u_short)mhip->ip_off);
449df8bae1dSRodney W. Grimes 		mhip->ip_sum = 0;
4509c9137eaSGarrett Wollman 		if (mhip->ip_vhl == IP_VHL_BORING) {
451e2184122SBruce Evans 			mhip->ip_sum = in_cksum_hdr(mhip);
4529c9137eaSGarrett Wollman 		} else {
453df8bae1dSRodney W. Grimes 			mhip->ip_sum = in_cksum(m, mhlen);
4549c9137eaSGarrett Wollman 		}
455df8bae1dSRodney W. Grimes 		*mnext = m;
456df8bae1dSRodney W. Grimes 		mnext = &m->m_nextpkt;
457df8bae1dSRodney W. Grimes 		ipstat.ips_ofragments++;
458df8bae1dSRodney W. Grimes 	}
459df8bae1dSRodney W. Grimes 	/*
460df8bae1dSRodney W. Grimes 	 * Update first fragment by trimming what's been copied out
461df8bae1dSRodney W. Grimes 	 * and updating header, then send each fragment (in order).
462df8bae1dSRodney W. Grimes 	 */
463df8bae1dSRodney W. Grimes 	m = m0;
464df8bae1dSRodney W. Grimes 	m_adj(m, hlen + firstlen - (u_short)ip->ip_len);
465df8bae1dSRodney W. Grimes 	m->m_pkthdr.len = hlen + firstlen;
466df8bae1dSRodney W. Grimes 	ip->ip_len = htons((u_short)m->m_pkthdr.len);
467df8bae1dSRodney W. Grimes 	ip->ip_off = htons((u_short)(ip->ip_off | IP_MF));
468df8bae1dSRodney W. Grimes 	ip->ip_sum = 0;
4699c9137eaSGarrett Wollman 	if (ip->ip_vhl == IP_VHL_BORING) {
4709c9137eaSGarrett Wollman 		ip->ip_sum = in_cksum_hdr(ip);
4719c9137eaSGarrett Wollman 	} else {
472df8bae1dSRodney W. Grimes 		ip->ip_sum = in_cksum(m, hlen);
4739c9137eaSGarrett Wollman 	}
474df8bae1dSRodney W. Grimes sendorfree:
475df8bae1dSRodney W. Grimes 	for (m = m0; m; m = m0) {
476df8bae1dSRodney W. Grimes 		m0 = m->m_nextpkt;
477df8bae1dSRodney W. Grimes 		m->m_nextpkt = 0;
478df8bae1dSRodney W. Grimes 		if (error == 0)
479df8bae1dSRodney W. Grimes 			error = (*ifp->if_output)(ifp, m,
480df8bae1dSRodney W. Grimes 			    (struct sockaddr *)dst, ro->ro_rt);
481df8bae1dSRodney W. Grimes 		else
482df8bae1dSRodney W. Grimes 			m_freem(m);
483df8bae1dSRodney W. Grimes 	}
484df8bae1dSRodney W. Grimes 
485df8bae1dSRodney W. Grimes 	if (error == 0)
486df8bae1dSRodney W. Grimes 		ipstat.ips_fragmented++;
487df8bae1dSRodney W. Grimes     }
488df8bae1dSRodney W. Grimes done:
489df8bae1dSRodney W. Grimes 	return (error);
490df8bae1dSRodney W. Grimes bad:
491df8bae1dSRodney W. Grimes 	m_freem(m0);
492df8bae1dSRodney W. Grimes 	goto done;
493df8bae1dSRodney W. Grimes }
494df8bae1dSRodney W. Grimes 
495df8bae1dSRodney W. Grimes /*
496df8bae1dSRodney W. Grimes  * Insert IP options into preformed packet.
497df8bae1dSRodney W. Grimes  * Adjust IP destination as required for IP source routing,
498df8bae1dSRodney W. Grimes  * as indicated by a non-zero in_addr at the start of the options.
499072b9b24SPaul Traina  *
500072b9b24SPaul Traina  * XXX This routine assumes that the packet has no options in place.
501df8bae1dSRodney W. Grimes  */
502df8bae1dSRodney W. Grimes static struct mbuf *
503df8bae1dSRodney W. Grimes ip_insertoptions(m, opt, phlen)
504df8bae1dSRodney W. Grimes 	register struct mbuf *m;
505df8bae1dSRodney W. Grimes 	struct mbuf *opt;
506df8bae1dSRodney W. Grimes 	int *phlen;
507df8bae1dSRodney W. Grimes {
508df8bae1dSRodney W. Grimes 	register struct ipoption *p = mtod(opt, struct ipoption *);
509df8bae1dSRodney W. Grimes 	struct mbuf *n;
510df8bae1dSRodney W. Grimes 	register struct ip *ip = mtod(m, struct ip *);
511df8bae1dSRodney W. Grimes 	unsigned optlen;
512df8bae1dSRodney W. Grimes 
513df8bae1dSRodney W. Grimes 	optlen = opt->m_len - sizeof(p->ipopt_dst);
514df8bae1dSRodney W. Grimes 	if (optlen + (u_short)ip->ip_len > IP_MAXPACKET)
515df8bae1dSRodney W. Grimes 		return (m);		/* XXX should fail */
516df8bae1dSRodney W. Grimes 	if (p->ipopt_dst.s_addr)
517df8bae1dSRodney W. Grimes 		ip->ip_dst = p->ipopt_dst;
518df8bae1dSRodney W. Grimes 	if (m->m_flags & M_EXT || m->m_data - optlen < m->m_pktdat) {
519df8bae1dSRodney W. Grimes 		MGETHDR(n, M_DONTWAIT, MT_HEADER);
520df8bae1dSRodney W. Grimes 		if (n == 0)
521df8bae1dSRodney W. Grimes 			return (m);
522df8bae1dSRodney W. Grimes 		n->m_pkthdr.len = m->m_pkthdr.len + optlen;
523df8bae1dSRodney W. Grimes 		m->m_len -= sizeof(struct ip);
524df8bae1dSRodney W. Grimes 		m->m_data += sizeof(struct ip);
525df8bae1dSRodney W. Grimes 		n->m_next = m;
526df8bae1dSRodney W. Grimes 		m = n;
527df8bae1dSRodney W. Grimes 		m->m_len = optlen + sizeof(struct ip);
528df8bae1dSRodney W. Grimes 		m->m_data += max_linkhdr;
52994a5d9b6SDavid Greenman 		(void)memcpy(mtod(m, void *), ip, sizeof(struct ip));
530df8bae1dSRodney W. Grimes 	} else {
531df8bae1dSRodney W. Grimes 		m->m_data -= optlen;
532df8bae1dSRodney W. Grimes 		m->m_len += optlen;
533df8bae1dSRodney W. Grimes 		m->m_pkthdr.len += optlen;
534df8bae1dSRodney W. Grimes 		ovbcopy((caddr_t)ip, mtod(m, caddr_t), sizeof(struct ip));
535df8bae1dSRodney W. Grimes 	}
536df8bae1dSRodney W. Grimes 	ip = mtod(m, struct ip *);
5370453d3cbSBruce Evans 	bcopy(p->ipopt_list, ip + 1, optlen);
538df8bae1dSRodney W. Grimes 	*phlen = sizeof(struct ip) + optlen;
5399c9137eaSGarrett Wollman 	ip->ip_vhl = IP_MAKE_VHL(IPVERSION, *phlen >> 2);
540df8bae1dSRodney W. Grimes 	ip->ip_len += optlen;
541df8bae1dSRodney W. Grimes 	return (m);
542df8bae1dSRodney W. Grimes }
543df8bae1dSRodney W. Grimes 
544df8bae1dSRodney W. Grimes /*
545df8bae1dSRodney W. Grimes  * Copy options from ip to jp,
546df8bae1dSRodney W. Grimes  * omitting those not copied during fragmentation.
547df8bae1dSRodney W. Grimes  */
5480312fbe9SPoul-Henning Kamp static int
549df8bae1dSRodney W. Grimes ip_optcopy(ip, jp)
550df8bae1dSRodney W. Grimes 	struct ip *ip, *jp;
551df8bae1dSRodney W. Grimes {
552df8bae1dSRodney W. Grimes 	register u_char *cp, *dp;
553df8bae1dSRodney W. Grimes 	int opt, optlen, cnt;
554df8bae1dSRodney W. Grimes 
555df8bae1dSRodney W. Grimes 	cp = (u_char *)(ip + 1);
556df8bae1dSRodney W. Grimes 	dp = (u_char *)(jp + 1);
5579c9137eaSGarrett Wollman 	cnt = (IP_VHL_HL(ip->ip_vhl) << 2) - sizeof (struct ip);
558df8bae1dSRodney W. Grimes 	for (; cnt > 0; cnt -= optlen, cp += optlen) {
559df8bae1dSRodney W. Grimes 		opt = cp[0];
560df8bae1dSRodney W. Grimes 		if (opt == IPOPT_EOL)
561df8bae1dSRodney W. Grimes 			break;
562df8bae1dSRodney W. Grimes 		if (opt == IPOPT_NOP) {
563df8bae1dSRodney W. Grimes 			/* Preserve for IP mcast tunnel's LSRR alignment. */
564df8bae1dSRodney W. Grimes 			*dp++ = IPOPT_NOP;
565df8bae1dSRodney W. Grimes 			optlen = 1;
566df8bae1dSRodney W. Grimes 			continue;
567df8bae1dSRodney W. Grimes 		} else
568df8bae1dSRodney W. Grimes 			optlen = cp[IPOPT_OLEN];
569df8bae1dSRodney W. Grimes 		/* bogus lengths should have been caught by ip_dooptions */
570df8bae1dSRodney W. Grimes 		if (optlen > cnt)
571df8bae1dSRodney W. Grimes 			optlen = cnt;
572df8bae1dSRodney W. Grimes 		if (IPOPT_COPIED(opt)) {
5730453d3cbSBruce Evans 			bcopy(cp, dp, optlen);
574df8bae1dSRodney W. Grimes 			dp += optlen;
575df8bae1dSRodney W. Grimes 		}
576df8bae1dSRodney W. Grimes 	}
577df8bae1dSRodney W. Grimes 	for (optlen = dp - (u_char *)(jp+1); optlen & 0x3; optlen++)
578df8bae1dSRodney W. Grimes 		*dp++ = IPOPT_EOL;
579df8bae1dSRodney W. Grimes 	return (optlen);
580df8bae1dSRodney W. Grimes }
581df8bae1dSRodney W. Grimes 
582df8bae1dSRodney W. Grimes /*
583df8bae1dSRodney W. Grimes  * IP socket option processing.
584df8bae1dSRodney W. Grimes  */
585df8bae1dSRodney W. Grimes int
586df8bae1dSRodney W. Grimes ip_ctloutput(op, so, level, optname, mp)
587df8bae1dSRodney W. Grimes 	int op;
588df8bae1dSRodney W. Grimes 	struct socket *so;
589df8bae1dSRodney W. Grimes 	int level, optname;
590df8bae1dSRodney W. Grimes 	struct mbuf **mp;
591df8bae1dSRodney W. Grimes {
592df8bae1dSRodney W. Grimes 	register struct inpcb *inp = sotoinpcb(so);
593df8bae1dSRodney W. Grimes 	register struct mbuf *m = *mp;
59426f9a767SRodney W. Grimes 	register int optval = 0;
595df8bae1dSRodney W. Grimes 	int error = 0;
596df8bae1dSRodney W. Grimes 
597df8bae1dSRodney W. Grimes 	if (level != IPPROTO_IP) {
598df8bae1dSRodney W. Grimes 		error = EINVAL;
599df8bae1dSRodney W. Grimes 		if (op == PRCO_SETOPT && *mp)
600df8bae1dSRodney W. Grimes 			(void) m_free(*mp);
601df8bae1dSRodney W. Grimes 	} else switch (op) {
602df8bae1dSRodney W. Grimes 
603df8bae1dSRodney W. Grimes 	case PRCO_SETOPT:
604df8bae1dSRodney W. Grimes 		switch (optname) {
605df8bae1dSRodney W. Grimes 		case IP_OPTIONS:
606df8bae1dSRodney W. Grimes #ifdef notyet
607df8bae1dSRodney W. Grimes 		case IP_RETOPTS:
608df8bae1dSRodney W. Grimes 			return (ip_pcbopts(optname, &inp->inp_options, m));
609df8bae1dSRodney W. Grimes #else
610df8bae1dSRodney W. Grimes 			return (ip_pcbopts(&inp->inp_options, m));
611df8bae1dSRodney W. Grimes #endif
612df8bae1dSRodney W. Grimes 
613df8bae1dSRodney W. Grimes 		case IP_TOS:
614df8bae1dSRodney W. Grimes 		case IP_TTL:
615df8bae1dSRodney W. Grimes 		case IP_RECVOPTS:
616df8bae1dSRodney W. Grimes 		case IP_RECVRETOPTS:
617df8bae1dSRodney W. Grimes 		case IP_RECVDSTADDR:
61840a63d93SJoerg Wunsch 			if (m == 0 || m->m_len != sizeof(int))
619df8bae1dSRodney W. Grimes 				error = EINVAL;
620df8bae1dSRodney W. Grimes 			else {
621df8bae1dSRodney W. Grimes 				optval = *mtod(m, int *);
622df8bae1dSRodney W. Grimes 				switch (optname) {
623df8bae1dSRodney W. Grimes 
624df8bae1dSRodney W. Grimes 				case IP_TOS:
625df8bae1dSRodney W. Grimes 					inp->inp_ip.ip_tos = optval;
626df8bae1dSRodney W. Grimes 					break;
627df8bae1dSRodney W. Grimes 
628df8bae1dSRodney W. Grimes 				case IP_TTL:
629df8bae1dSRodney W. Grimes 					inp->inp_ip.ip_ttl = optval;
630df8bae1dSRodney W. Grimes 					break;
631df8bae1dSRodney W. Grimes #define	OPTSET(bit) \
632df8bae1dSRodney W. Grimes 	if (optval) \
633df8bae1dSRodney W. Grimes 		inp->inp_flags |= bit; \
634df8bae1dSRodney W. Grimes 	else \
635df8bae1dSRodney W. Grimes 		inp->inp_flags &= ~bit;
636df8bae1dSRodney W. Grimes 
637df8bae1dSRodney W. Grimes 				case IP_RECVOPTS:
638df8bae1dSRodney W. Grimes 					OPTSET(INP_RECVOPTS);
639df8bae1dSRodney W. Grimes 					break;
640df8bae1dSRodney W. Grimes 
641df8bae1dSRodney W. Grimes 				case IP_RECVRETOPTS:
642df8bae1dSRodney W. Grimes 					OPTSET(INP_RECVRETOPTS);
643df8bae1dSRodney W. Grimes 					break;
644df8bae1dSRodney W. Grimes 
645df8bae1dSRodney W. Grimes 				case IP_RECVDSTADDR:
646df8bae1dSRodney W. Grimes 					OPTSET(INP_RECVDSTADDR);
647df8bae1dSRodney W. Grimes 					break;
648df8bae1dSRodney W. Grimes 				}
649df8bae1dSRodney W. Grimes 			}
650df8bae1dSRodney W. Grimes 			break;
651df8bae1dSRodney W. Grimes #undef OPTSET
652df8bae1dSRodney W. Grimes 
653df8bae1dSRodney W. Grimes 		case IP_MULTICAST_IF:
654f0068c4aSGarrett Wollman 		case IP_MULTICAST_VIF:
655df8bae1dSRodney W. Grimes 		case IP_MULTICAST_TTL:
656df8bae1dSRodney W. Grimes 		case IP_MULTICAST_LOOP:
657df8bae1dSRodney W. Grimes 		case IP_ADD_MEMBERSHIP:
658df8bae1dSRodney W. Grimes 		case IP_DROP_MEMBERSHIP:
659df8bae1dSRodney W. Grimes 			error = ip_setmoptions(optname, &inp->inp_moptions, m);
660df8bae1dSRodney W. Grimes 			break;
661df8bae1dSRodney W. Grimes 
66233b3ac06SPeter Wemm 		case IP_PORTRANGE:
66333b3ac06SPeter Wemm 			if (m == 0 || m->m_len != sizeof(int))
66433b3ac06SPeter Wemm 				error = EINVAL;
66533b3ac06SPeter Wemm 			else {
66633b3ac06SPeter Wemm 				optval = *mtod(m, int *);
66733b3ac06SPeter Wemm 
66833b3ac06SPeter Wemm 				switch (optval) {
66933b3ac06SPeter Wemm 
67033b3ac06SPeter Wemm 				case IP_PORTRANGE_DEFAULT:
67133b3ac06SPeter Wemm 					inp->inp_flags &= ~(INP_LOWPORT);
67233b3ac06SPeter Wemm 					inp->inp_flags &= ~(INP_HIGHPORT);
67333b3ac06SPeter Wemm 					break;
67433b3ac06SPeter Wemm 
67533b3ac06SPeter Wemm 				case IP_PORTRANGE_HIGH:
67633b3ac06SPeter Wemm 					inp->inp_flags &= ~(INP_LOWPORT);
67733b3ac06SPeter Wemm 					inp->inp_flags |= INP_HIGHPORT;
67833b3ac06SPeter Wemm 					break;
67933b3ac06SPeter Wemm 
68033b3ac06SPeter Wemm 				case IP_PORTRANGE_LOW:
68133b3ac06SPeter Wemm 					inp->inp_flags &= ~(INP_HIGHPORT);
68233b3ac06SPeter Wemm 					inp->inp_flags |= INP_LOWPORT;
68333b3ac06SPeter Wemm 					break;
68433b3ac06SPeter Wemm 
68533b3ac06SPeter Wemm 				default:
68633b3ac06SPeter Wemm 					error = EINVAL;
68733b3ac06SPeter Wemm 					break;
68833b3ac06SPeter Wemm 				}
68933b3ac06SPeter Wemm 			}
690ce8c72b1SPeter Wemm 			break;
69133b3ac06SPeter Wemm 
692df8bae1dSRodney W. Grimes 		default:
693df8bae1dSRodney W. Grimes 			error = ENOPROTOOPT;
694df8bae1dSRodney W. Grimes 			break;
695df8bae1dSRodney W. Grimes 		}
696df8bae1dSRodney W. Grimes 		if (m)
697df8bae1dSRodney W. Grimes 			(void)m_free(m);
698df8bae1dSRodney W. Grimes 		break;
699df8bae1dSRodney W. Grimes 
700df8bae1dSRodney W. Grimes 	case PRCO_GETOPT:
701df8bae1dSRodney W. Grimes 		switch (optname) {
702df8bae1dSRodney W. Grimes 		case IP_OPTIONS:
703df8bae1dSRodney W. Grimes 		case IP_RETOPTS:
704df8bae1dSRodney W. Grimes 			*mp = m = m_get(M_WAIT, MT_SOOPTS);
705df8bae1dSRodney W. Grimes 			if (inp->inp_options) {
706df8bae1dSRodney W. Grimes 				m->m_len = inp->inp_options->m_len;
7070453d3cbSBruce Evans 				bcopy(mtod(inp->inp_options, void *),
7080453d3cbSBruce Evans 				    mtod(m, void *), m->m_len);
709df8bae1dSRodney W. Grimes 			} else
710df8bae1dSRodney W. Grimes 				m->m_len = 0;
711df8bae1dSRodney W. Grimes 			break;
712df8bae1dSRodney W. Grimes 
713df8bae1dSRodney W. Grimes 		case IP_TOS:
714df8bae1dSRodney W. Grimes 		case IP_TTL:
715df8bae1dSRodney W. Grimes 		case IP_RECVOPTS:
716df8bae1dSRodney W. Grimes 		case IP_RECVRETOPTS:
717df8bae1dSRodney W. Grimes 		case IP_RECVDSTADDR:
718df8bae1dSRodney W. Grimes 			*mp = m = m_get(M_WAIT, MT_SOOPTS);
719df8bae1dSRodney W. Grimes 			m->m_len = sizeof(int);
720df8bae1dSRodney W. Grimes 			switch (optname) {
721df8bae1dSRodney W. Grimes 
722df8bae1dSRodney W. Grimes 			case IP_TOS:
723df8bae1dSRodney W. Grimes 				optval = inp->inp_ip.ip_tos;
724df8bae1dSRodney W. Grimes 				break;
725df8bae1dSRodney W. Grimes 
726df8bae1dSRodney W. Grimes 			case IP_TTL:
727df8bae1dSRodney W. Grimes 				optval = inp->inp_ip.ip_ttl;
728df8bae1dSRodney W. Grimes 				break;
729df8bae1dSRodney W. Grimes 
730df8bae1dSRodney W. Grimes #define	OPTBIT(bit)	(inp->inp_flags & bit ? 1 : 0)
731df8bae1dSRodney W. Grimes 
732df8bae1dSRodney W. Grimes 			case IP_RECVOPTS:
733df8bae1dSRodney W. Grimes 				optval = OPTBIT(INP_RECVOPTS);
734df8bae1dSRodney W. Grimes 				break;
735df8bae1dSRodney W. Grimes 
736df8bae1dSRodney W. Grimes 			case IP_RECVRETOPTS:
737df8bae1dSRodney W. Grimes 				optval = OPTBIT(INP_RECVRETOPTS);
738df8bae1dSRodney W. Grimes 				break;
739df8bae1dSRodney W. Grimes 
740df8bae1dSRodney W. Grimes 			case IP_RECVDSTADDR:
741df8bae1dSRodney W. Grimes 				optval = OPTBIT(INP_RECVDSTADDR);
742df8bae1dSRodney W. Grimes 				break;
743df8bae1dSRodney W. Grimes 			}
744df8bae1dSRodney W. Grimes 			*mtod(m, int *) = optval;
745df8bae1dSRodney W. Grimes 			break;
746df8bae1dSRodney W. Grimes 
747df8bae1dSRodney W. Grimes 		case IP_MULTICAST_IF:
748f0068c4aSGarrett Wollman 		case IP_MULTICAST_VIF:
749df8bae1dSRodney W. Grimes 		case IP_MULTICAST_TTL:
750df8bae1dSRodney W. Grimes 		case IP_MULTICAST_LOOP:
751df8bae1dSRodney W. Grimes 		case IP_ADD_MEMBERSHIP:
752df8bae1dSRodney W. Grimes 		case IP_DROP_MEMBERSHIP:
753df8bae1dSRodney W. Grimes 			error = ip_getmoptions(optname, inp->inp_moptions, mp);
754df8bae1dSRodney W. Grimes 			break;
755df8bae1dSRodney W. Grimes 
75633b3ac06SPeter Wemm 		case IP_PORTRANGE:
75733b3ac06SPeter Wemm 			*mp = m = m_get(M_WAIT, MT_SOOPTS);
75833b3ac06SPeter Wemm 			m->m_len = sizeof(int);
75933b3ac06SPeter Wemm 
76033b3ac06SPeter Wemm 			if (inp->inp_flags & INP_HIGHPORT)
76133b3ac06SPeter Wemm 				optval = IP_PORTRANGE_HIGH;
76233b3ac06SPeter Wemm 			else if (inp->inp_flags & INP_LOWPORT)
76333b3ac06SPeter Wemm 				optval = IP_PORTRANGE_LOW;
76433b3ac06SPeter Wemm 			else
76533b3ac06SPeter Wemm 				optval = 0;
76633b3ac06SPeter Wemm 
76733b3ac06SPeter Wemm 			*mtod(m, int *) = optval;
76833b3ac06SPeter Wemm 			break;
76933b3ac06SPeter Wemm 
770df8bae1dSRodney W. Grimes 		default:
771df8bae1dSRodney W. Grimes 			error = ENOPROTOOPT;
772df8bae1dSRodney W. Grimes 			break;
773df8bae1dSRodney W. Grimes 		}
774df8bae1dSRodney W. Grimes 		break;
775df8bae1dSRodney W. Grimes 	}
776df8bae1dSRodney W. Grimes 	return (error);
777df8bae1dSRodney W. Grimes }
778df8bae1dSRodney W. Grimes 
779df8bae1dSRodney W. Grimes /*
780df8bae1dSRodney W. Grimes  * Set up IP options in pcb for insertion in output packets.
781df8bae1dSRodney W. Grimes  * Store in mbuf with pointer in pcbopt, adding pseudo-option
782df8bae1dSRodney W. Grimes  * with destination address if source routed.
783df8bae1dSRodney W. Grimes  */
7840312fbe9SPoul-Henning Kamp static int
785df8bae1dSRodney W. Grimes #ifdef notyet
786df8bae1dSRodney W. Grimes ip_pcbopts(optname, pcbopt, m)
787df8bae1dSRodney W. Grimes 	int optname;
788df8bae1dSRodney W. Grimes #else
789df8bae1dSRodney W. Grimes ip_pcbopts(pcbopt, m)
790df8bae1dSRodney W. Grimes #endif
791df8bae1dSRodney W. Grimes 	struct mbuf **pcbopt;
792df8bae1dSRodney W. Grimes 	register struct mbuf *m;
793df8bae1dSRodney W. Grimes {
794df8bae1dSRodney W. Grimes 	register cnt, optlen;
795df8bae1dSRodney W. Grimes 	register u_char *cp;
796df8bae1dSRodney W. Grimes 	u_char opt;
797df8bae1dSRodney W. Grimes 
798df8bae1dSRodney W. Grimes 	/* turn off any old options */
799df8bae1dSRodney W. Grimes 	if (*pcbopt)
800df8bae1dSRodney W. Grimes 		(void)m_free(*pcbopt);
801df8bae1dSRodney W. Grimes 	*pcbopt = 0;
802df8bae1dSRodney W. Grimes 	if (m == (struct mbuf *)0 || m->m_len == 0) {
803df8bae1dSRodney W. Grimes 		/*
804df8bae1dSRodney W. Grimes 		 * Only turning off any previous options.
805df8bae1dSRodney W. Grimes 		 */
806df8bae1dSRodney W. Grimes 		if (m)
807df8bae1dSRodney W. Grimes 			(void)m_free(m);
808df8bae1dSRodney W. Grimes 		return (0);
809df8bae1dSRodney W. Grimes 	}
810df8bae1dSRodney W. Grimes 
811df8bae1dSRodney W. Grimes #ifndef	vax
812df8bae1dSRodney W. Grimes 	if (m->m_len % sizeof(long))
813df8bae1dSRodney W. Grimes 		goto bad;
814df8bae1dSRodney W. Grimes #endif
815df8bae1dSRodney W. Grimes 	/*
816df8bae1dSRodney W. Grimes 	 * IP first-hop destination address will be stored before
817df8bae1dSRodney W. Grimes 	 * actual options; move other options back
818df8bae1dSRodney W. Grimes 	 * and clear it when none present.
819df8bae1dSRodney W. Grimes 	 */
820df8bae1dSRodney W. Grimes 	if (m->m_data + m->m_len + sizeof(struct in_addr) >= &m->m_dat[MLEN])
821df8bae1dSRodney W. Grimes 		goto bad;
822df8bae1dSRodney W. Grimes 	cnt = m->m_len;
823df8bae1dSRodney W. Grimes 	m->m_len += sizeof(struct in_addr);
824df8bae1dSRodney W. Grimes 	cp = mtod(m, u_char *) + sizeof(struct in_addr);
825df8bae1dSRodney W. Grimes 	ovbcopy(mtod(m, caddr_t), (caddr_t)cp, (unsigned)cnt);
826df8bae1dSRodney W. Grimes 	bzero(mtod(m, caddr_t), sizeof(struct in_addr));
827df8bae1dSRodney W. Grimes 
828df8bae1dSRodney W. Grimes 	for (; cnt > 0; cnt -= optlen, cp += optlen) {
829df8bae1dSRodney W. Grimes 		opt = cp[IPOPT_OPTVAL];
830df8bae1dSRodney W. Grimes 		if (opt == IPOPT_EOL)
831df8bae1dSRodney W. Grimes 			break;
832df8bae1dSRodney W. Grimes 		if (opt == IPOPT_NOP)
833df8bae1dSRodney W. Grimes 			optlen = 1;
834df8bae1dSRodney W. Grimes 		else {
835df8bae1dSRodney W. Grimes 			optlen = cp[IPOPT_OLEN];
836df8bae1dSRodney W. Grimes 			if (optlen <= IPOPT_OLEN || optlen > cnt)
837df8bae1dSRodney W. Grimes 				goto bad;
838df8bae1dSRodney W. Grimes 		}
839df8bae1dSRodney W. Grimes 		switch (opt) {
840df8bae1dSRodney W. Grimes 
841df8bae1dSRodney W. Grimes 		default:
842df8bae1dSRodney W. Grimes 			break;
843df8bae1dSRodney W. Grimes 
844df8bae1dSRodney W. Grimes 		case IPOPT_LSRR:
845df8bae1dSRodney W. Grimes 		case IPOPT_SSRR:
846df8bae1dSRodney W. Grimes 			/*
847df8bae1dSRodney W. Grimes 			 * user process specifies route as:
848df8bae1dSRodney W. Grimes 			 *	->A->B->C->D
849df8bae1dSRodney W. Grimes 			 * D must be our final destination (but we can't
850df8bae1dSRodney W. Grimes 			 * check that since we may not have connected yet).
851df8bae1dSRodney W. Grimes 			 * A is first hop destination, which doesn't appear in
852df8bae1dSRodney W. Grimes 			 * actual IP option, but is stored before the options.
853df8bae1dSRodney W. Grimes 			 */
854df8bae1dSRodney W. Grimes 			if (optlen < IPOPT_MINOFF - 1 + sizeof(struct in_addr))
855df8bae1dSRodney W. Grimes 				goto bad;
856df8bae1dSRodney W. Grimes 			m->m_len -= sizeof(struct in_addr);
857df8bae1dSRodney W. Grimes 			cnt -= sizeof(struct in_addr);
858df8bae1dSRodney W. Grimes 			optlen -= sizeof(struct in_addr);
859df8bae1dSRodney W. Grimes 			cp[IPOPT_OLEN] = optlen;
860df8bae1dSRodney W. Grimes 			/*
861df8bae1dSRodney W. Grimes 			 * Move first hop before start of options.
862df8bae1dSRodney W. Grimes 			 */
863df8bae1dSRodney W. Grimes 			bcopy((caddr_t)&cp[IPOPT_OFFSET+1], mtod(m, caddr_t),
864df8bae1dSRodney W. Grimes 			    sizeof(struct in_addr));
865df8bae1dSRodney W. Grimes 			/*
866df8bae1dSRodney W. Grimes 			 * Then copy rest of options back
867df8bae1dSRodney W. Grimes 			 * to close up the deleted entry.
868df8bae1dSRodney W. Grimes 			 */
869df8bae1dSRodney W. Grimes 			ovbcopy((caddr_t)(&cp[IPOPT_OFFSET+1] +
870df8bae1dSRodney W. Grimes 			    sizeof(struct in_addr)),
871df8bae1dSRodney W. Grimes 			    (caddr_t)&cp[IPOPT_OFFSET+1],
872df8bae1dSRodney W. Grimes 			    (unsigned)cnt + sizeof(struct in_addr));
873df8bae1dSRodney W. Grimes 			break;
874df8bae1dSRodney W. Grimes 		}
875df8bae1dSRodney W. Grimes 	}
876df8bae1dSRodney W. Grimes 	if (m->m_len > MAX_IPOPTLEN + sizeof(struct in_addr))
877df8bae1dSRodney W. Grimes 		goto bad;
878df8bae1dSRodney W. Grimes 	*pcbopt = m;
879df8bae1dSRodney W. Grimes 	return (0);
880df8bae1dSRodney W. Grimes 
881df8bae1dSRodney W. Grimes bad:
882df8bae1dSRodney W. Grimes 	(void)m_free(m);
883df8bae1dSRodney W. Grimes 	return (EINVAL);
884df8bae1dSRodney W. Grimes }
885df8bae1dSRodney W. Grimes 
886df8bae1dSRodney W. Grimes /*
887df8bae1dSRodney W. Grimes  * Set the IP multicast options in response to user setsockopt().
888df8bae1dSRodney W. Grimes  */
8890312fbe9SPoul-Henning Kamp static int
890df8bae1dSRodney W. Grimes ip_setmoptions(optname, imop, m)
891df8bae1dSRodney W. Grimes 	int optname;
892df8bae1dSRodney W. Grimes 	struct ip_moptions **imop;
893df8bae1dSRodney W. Grimes 	struct mbuf *m;
894df8bae1dSRodney W. Grimes {
895df8bae1dSRodney W. Grimes 	register int error = 0;
896df8bae1dSRodney W. Grimes 	u_char loop;
897df8bae1dSRodney W. Grimes 	register int i;
898df8bae1dSRodney W. Grimes 	struct in_addr addr;
899df8bae1dSRodney W. Grimes 	register struct ip_mreq *mreq;
900df8bae1dSRodney W. Grimes 	register struct ifnet *ifp;
901df8bae1dSRodney W. Grimes 	register struct ip_moptions *imo = *imop;
902df8bae1dSRodney W. Grimes 	struct route ro;
903df8bae1dSRodney W. Grimes 	register struct sockaddr_in *dst;
9049b626c29SGarrett Wollman 	int s;
905df8bae1dSRodney W. Grimes 
906df8bae1dSRodney W. Grimes 	if (imo == NULL) {
907df8bae1dSRodney W. Grimes 		/*
908df8bae1dSRodney W. Grimes 		 * No multicast option buffer attached to the pcb;
909df8bae1dSRodney W. Grimes 		 * allocate one and initialize to default values.
910df8bae1dSRodney W. Grimes 		 */
911df8bae1dSRodney W. Grimes 		imo = (struct ip_moptions*)malloc(sizeof(*imo), M_IPMOPTS,
912df8bae1dSRodney W. Grimes 		    M_WAITOK);
913df8bae1dSRodney W. Grimes 
914df8bae1dSRodney W. Grimes 		if (imo == NULL)
915df8bae1dSRodney W. Grimes 			return (ENOBUFS);
916df8bae1dSRodney W. Grimes 		*imop = imo;
917df8bae1dSRodney W. Grimes 		imo->imo_multicast_ifp = NULL;
9181c5de19aSGarrett Wollman 		imo->imo_multicast_vif = -1;
919df8bae1dSRodney W. Grimes 		imo->imo_multicast_ttl = IP_DEFAULT_MULTICAST_TTL;
920df8bae1dSRodney W. Grimes 		imo->imo_multicast_loop = IP_DEFAULT_MULTICAST_LOOP;
921df8bae1dSRodney W. Grimes 		imo->imo_num_memberships = 0;
922df8bae1dSRodney W. Grimes 	}
923df8bae1dSRodney W. Grimes 
924df8bae1dSRodney W. Grimes 	switch (optname) {
925f0068c4aSGarrett Wollman 	/* store an index number for the vif you wanna use in the send */
926f0068c4aSGarrett Wollman 	case IP_MULTICAST_VIF:
9275e9ae478SGarrett Wollman 		if (!legal_vif_num) {
9285e9ae478SGarrett Wollman 			error = EOPNOTSUPP;
9295e9ae478SGarrett Wollman 			break;
9305e9ae478SGarrett Wollman 		}
931f0068c4aSGarrett Wollman 		if (m == NULL || m->m_len != sizeof(int)) {
932f0068c4aSGarrett Wollman 			error = EINVAL;
933f0068c4aSGarrett Wollman 			break;
934f0068c4aSGarrett Wollman 		}
935f0068c4aSGarrett Wollman 		i = *(mtod(m, int *));
9361c5de19aSGarrett Wollman 		if (!legal_vif_num(i) && (i != -1)) {
937f0068c4aSGarrett Wollman 			error = EINVAL;
938f0068c4aSGarrett Wollman 			break;
939f0068c4aSGarrett Wollman 		}
940f0068c4aSGarrett Wollman 		imo->imo_multicast_vif = i;
941f0068c4aSGarrett Wollman 		break;
942f0068c4aSGarrett Wollman 
943df8bae1dSRodney W. Grimes 	case IP_MULTICAST_IF:
944df8bae1dSRodney W. Grimes 		/*
945df8bae1dSRodney W. Grimes 		 * Select the interface for outgoing multicast packets.
946df8bae1dSRodney W. Grimes 		 */
947df8bae1dSRodney W. Grimes 		if (m == NULL || m->m_len != sizeof(struct in_addr)) {
948df8bae1dSRodney W. Grimes 			error = EINVAL;
949df8bae1dSRodney W. Grimes 			break;
950df8bae1dSRodney W. Grimes 		}
951df8bae1dSRodney W. Grimes 		addr = *(mtod(m, struct in_addr *));
952df8bae1dSRodney W. Grimes 		/*
953df8bae1dSRodney W. Grimes 		 * INADDR_ANY is used to remove a previous selection.
954df8bae1dSRodney W. Grimes 		 * When no interface is selected, a default one is
955df8bae1dSRodney W. Grimes 		 * chosen every time a multicast packet is sent.
956df8bae1dSRodney W. Grimes 		 */
957df8bae1dSRodney W. Grimes 		if (addr.s_addr == INADDR_ANY) {
958df8bae1dSRodney W. Grimes 			imo->imo_multicast_ifp = NULL;
959df8bae1dSRodney W. Grimes 			break;
960df8bae1dSRodney W. Grimes 		}
961df8bae1dSRodney W. Grimes 		/*
962df8bae1dSRodney W. Grimes 		 * The selected interface is identified by its local
963df8bae1dSRodney W. Grimes 		 * IP address.  Find the interface and confirm that
964df8bae1dSRodney W. Grimes 		 * it supports multicasting.
965df8bae1dSRodney W. Grimes 		 */
96620e8807cSGarrett Wollman 		s = splimp();
967df8bae1dSRodney W. Grimes 		INADDR_TO_IFP(addr, ifp);
968df8bae1dSRodney W. Grimes 		if (ifp == NULL || (ifp->if_flags & IFF_MULTICAST) == 0) {
969fbc6ab00SBill Fenner 			splx(s);
970df8bae1dSRodney W. Grimes 			error = EADDRNOTAVAIL;
971df8bae1dSRodney W. Grimes 			break;
972df8bae1dSRodney W. Grimes 		}
973df8bae1dSRodney W. Grimes 		imo->imo_multicast_ifp = ifp;
9749b626c29SGarrett Wollman 		splx(s);
975df8bae1dSRodney W. Grimes 		break;
976df8bae1dSRodney W. Grimes 
977df8bae1dSRodney W. Grimes 	case IP_MULTICAST_TTL:
978df8bae1dSRodney W. Grimes 		/*
979df8bae1dSRodney W. Grimes 		 * Set the IP time-to-live for outgoing multicast packets.
980df8bae1dSRodney W. Grimes 		 */
981df8bae1dSRodney W. Grimes 		if (m == NULL || m->m_len != 1) {
982df8bae1dSRodney W. Grimes 			error = EINVAL;
983df8bae1dSRodney W. Grimes 			break;
984df8bae1dSRodney W. Grimes 		}
985df8bae1dSRodney W. Grimes 		imo->imo_multicast_ttl = *(mtod(m, u_char *));
986df8bae1dSRodney W. Grimes 		break;
987df8bae1dSRodney W. Grimes 
988df8bae1dSRodney W. Grimes 	case IP_MULTICAST_LOOP:
989df8bae1dSRodney W. Grimes 		/*
990df8bae1dSRodney W. Grimes 		 * Set the loopback flag for outgoing multicast packets.
991df8bae1dSRodney W. Grimes 		 * Must be zero or one.
992df8bae1dSRodney W. Grimes 		 */
993df8bae1dSRodney W. Grimes 		if (m == NULL || m->m_len != 1 ||
994df8bae1dSRodney W. Grimes 		   (loop = *(mtod(m, u_char *))) > 1) {
995df8bae1dSRodney W. Grimes 			error = EINVAL;
996df8bae1dSRodney W. Grimes 			break;
997df8bae1dSRodney W. Grimes 		}
998df8bae1dSRodney W. Grimes 		imo->imo_multicast_loop = loop;
999df8bae1dSRodney W. Grimes 		break;
1000df8bae1dSRodney W. Grimes 
1001df8bae1dSRodney W. Grimes 	case IP_ADD_MEMBERSHIP:
1002df8bae1dSRodney W. Grimes 		/*
1003df8bae1dSRodney W. Grimes 		 * Add a multicast group membership.
1004df8bae1dSRodney W. Grimes 		 * Group must be a valid IP multicast address.
1005df8bae1dSRodney W. Grimes 		 */
1006df8bae1dSRodney W. Grimes 		if (m == NULL || m->m_len != sizeof(struct ip_mreq)) {
1007df8bae1dSRodney W. Grimes 			error = EINVAL;
1008df8bae1dSRodney W. Grimes 			break;
1009df8bae1dSRodney W. Grimes 		}
1010df8bae1dSRodney W. Grimes 		mreq = mtod(m, struct ip_mreq *);
1011df8bae1dSRodney W. Grimes 		if (!IN_MULTICAST(ntohl(mreq->imr_multiaddr.s_addr))) {
1012df8bae1dSRodney W. Grimes 			error = EINVAL;
1013df8bae1dSRodney W. Grimes 			break;
1014df8bae1dSRodney W. Grimes 		}
101520e8807cSGarrett Wollman 		s = splimp();
1016df8bae1dSRodney W. Grimes 		/*
1017df8bae1dSRodney W. Grimes 		 * If no interface address was provided, use the interface of
1018df8bae1dSRodney W. Grimes 		 * the route to the given multicast address.
1019df8bae1dSRodney W. Grimes 		 */
1020df8bae1dSRodney W. Grimes 		if (mreq->imr_interface.s_addr == INADDR_ANY) {
10211c5de19aSGarrett Wollman 			bzero((caddr_t)&ro, sizeof(ro));
1022df8bae1dSRodney W. Grimes 			dst = (struct sockaddr_in *)&ro.ro_dst;
1023df8bae1dSRodney W. Grimes 			dst->sin_len = sizeof(*dst);
1024df8bae1dSRodney W. Grimes 			dst->sin_family = AF_INET;
1025df8bae1dSRodney W. Grimes 			dst->sin_addr = mreq->imr_multiaddr;
1026df8bae1dSRodney W. Grimes 			rtalloc(&ro);
1027df8bae1dSRodney W. Grimes 			if (ro.ro_rt == NULL) {
1028df8bae1dSRodney W. Grimes 				error = EADDRNOTAVAIL;
10299b626c29SGarrett Wollman 				splx(s);
1030df8bae1dSRodney W. Grimes 				break;
1031df8bae1dSRodney W. Grimes 			}
1032df8bae1dSRodney W. Grimes 			ifp = ro.ro_rt->rt_ifp;
1033df8bae1dSRodney W. Grimes 			rtfree(ro.ro_rt);
1034df8bae1dSRodney W. Grimes 		}
1035df8bae1dSRodney W. Grimes 		else {
1036df8bae1dSRodney W. Grimes 			INADDR_TO_IFP(mreq->imr_interface, ifp);
1037df8bae1dSRodney W. Grimes 		}
10389b626c29SGarrett Wollman 
1039df8bae1dSRodney W. Grimes 		/*
1040df8bae1dSRodney W. Grimes 		 * See if we found an interface, and confirm that it
1041df8bae1dSRodney W. Grimes 		 * supports multicast.
1042df8bae1dSRodney W. Grimes 		 */
1043df8bae1dSRodney W. Grimes 		if (ifp == NULL || (ifp->if_flags & IFF_MULTICAST) == 0) {
1044df8bae1dSRodney W. Grimes 			error = EADDRNOTAVAIL;
10459b626c29SGarrett Wollman 			splx(s);
1046df8bae1dSRodney W. Grimes 			break;
1047df8bae1dSRodney W. Grimes 		}
1048df8bae1dSRodney W. Grimes 		/*
1049df8bae1dSRodney W. Grimes 		 * See if the membership already exists or if all the
1050df8bae1dSRodney W. Grimes 		 * membership slots are full.
1051df8bae1dSRodney W. Grimes 		 */
1052df8bae1dSRodney W. Grimes 		for (i = 0; i < imo->imo_num_memberships; ++i) {
1053df8bae1dSRodney W. Grimes 			if (imo->imo_membership[i]->inm_ifp == ifp &&
1054df8bae1dSRodney W. Grimes 			    imo->imo_membership[i]->inm_addr.s_addr
1055df8bae1dSRodney W. Grimes 						== mreq->imr_multiaddr.s_addr)
1056df8bae1dSRodney W. Grimes 				break;
1057df8bae1dSRodney W. Grimes 		}
1058df8bae1dSRodney W. Grimes 		if (i < imo->imo_num_memberships) {
1059df8bae1dSRodney W. Grimes 			error = EADDRINUSE;
10609b626c29SGarrett Wollman 			splx(s);
1061df8bae1dSRodney W. Grimes 			break;
1062df8bae1dSRodney W. Grimes 		}
1063df8bae1dSRodney W. Grimes 		if (i == IP_MAX_MEMBERSHIPS) {
1064df8bae1dSRodney W. Grimes 			error = ETOOMANYREFS;
10659b626c29SGarrett Wollman 			splx(s);
1066df8bae1dSRodney W. Grimes 			break;
1067df8bae1dSRodney W. Grimes 		}
1068df8bae1dSRodney W. Grimes 		/*
1069df8bae1dSRodney W. Grimes 		 * Everything looks good; add a new record to the multicast
1070df8bae1dSRodney W. Grimes 		 * address list for the given interface.
1071df8bae1dSRodney W. Grimes 		 */
1072df8bae1dSRodney W. Grimes 		if ((imo->imo_membership[i] =
1073df8bae1dSRodney W. Grimes 		    in_addmulti(&mreq->imr_multiaddr, ifp)) == NULL) {
1074df8bae1dSRodney W. Grimes 			error = ENOBUFS;
10759b626c29SGarrett Wollman 			splx(s);
1076df8bae1dSRodney W. Grimes 			break;
1077df8bae1dSRodney W. Grimes 		}
1078df8bae1dSRodney W. Grimes 		++imo->imo_num_memberships;
10799b626c29SGarrett Wollman 		splx(s);
1080df8bae1dSRodney W. Grimes 		break;
1081df8bae1dSRodney W. Grimes 
1082df8bae1dSRodney W. Grimes 	case IP_DROP_MEMBERSHIP:
1083df8bae1dSRodney W. Grimes 		/*
1084df8bae1dSRodney W. Grimes 		 * Drop a multicast group membership.
1085df8bae1dSRodney W. Grimes 		 * Group must be a valid IP multicast address.
1086df8bae1dSRodney W. Grimes 		 */
1087df8bae1dSRodney W. Grimes 		if (m == NULL || m->m_len != sizeof(struct ip_mreq)) {
1088df8bae1dSRodney W. Grimes 			error = EINVAL;
1089df8bae1dSRodney W. Grimes 			break;
1090df8bae1dSRodney W. Grimes 		}
1091df8bae1dSRodney W. Grimes 		mreq = mtod(m, struct ip_mreq *);
1092df8bae1dSRodney W. Grimes 		if (!IN_MULTICAST(ntohl(mreq->imr_multiaddr.s_addr))) {
1093df8bae1dSRodney W. Grimes 			error = EINVAL;
1094df8bae1dSRodney W. Grimes 			break;
1095df8bae1dSRodney W. Grimes 		}
10969b626c29SGarrett Wollman 
109720e8807cSGarrett Wollman 		s = splimp();
1098df8bae1dSRodney W. Grimes 		/*
1099df8bae1dSRodney W. Grimes 		 * If an interface address was specified, get a pointer
1100df8bae1dSRodney W. Grimes 		 * to its ifnet structure.
1101df8bae1dSRodney W. Grimes 		 */
1102df8bae1dSRodney W. Grimes 		if (mreq->imr_interface.s_addr == INADDR_ANY)
1103df8bae1dSRodney W. Grimes 			ifp = NULL;
1104df8bae1dSRodney W. Grimes 		else {
1105df8bae1dSRodney W. Grimes 			INADDR_TO_IFP(mreq->imr_interface, ifp);
1106df8bae1dSRodney W. Grimes 			if (ifp == NULL) {
1107df8bae1dSRodney W. Grimes 				error = EADDRNOTAVAIL;
11089b626c29SGarrett Wollman 				splx(s);
1109df8bae1dSRodney W. Grimes 				break;
1110df8bae1dSRodney W. Grimes 			}
1111df8bae1dSRodney W. Grimes 		}
1112df8bae1dSRodney W. Grimes 		/*
1113df8bae1dSRodney W. Grimes 		 * Find the membership in the membership array.
1114df8bae1dSRodney W. Grimes 		 */
1115df8bae1dSRodney W. Grimes 		for (i = 0; i < imo->imo_num_memberships; ++i) {
1116df8bae1dSRodney W. Grimes 			if ((ifp == NULL ||
1117df8bae1dSRodney W. Grimes 			     imo->imo_membership[i]->inm_ifp == ifp) &&
1118df8bae1dSRodney W. Grimes 			     imo->imo_membership[i]->inm_addr.s_addr ==
1119df8bae1dSRodney W. Grimes 			     mreq->imr_multiaddr.s_addr)
1120df8bae1dSRodney W. Grimes 				break;
1121df8bae1dSRodney W. Grimes 		}
1122df8bae1dSRodney W. Grimes 		if (i == imo->imo_num_memberships) {
1123df8bae1dSRodney W. Grimes 			error = EADDRNOTAVAIL;
11249b626c29SGarrett Wollman 			splx(s);
1125df8bae1dSRodney W. Grimes 			break;
1126df8bae1dSRodney W. Grimes 		}
1127df8bae1dSRodney W. Grimes 		/*
1128df8bae1dSRodney W. Grimes 		 * Give up the multicast address record to which the
1129df8bae1dSRodney W. Grimes 		 * membership points.
1130df8bae1dSRodney W. Grimes 		 */
1131df8bae1dSRodney W. Grimes 		in_delmulti(imo->imo_membership[i]);
1132df8bae1dSRodney W. Grimes 		/*
1133df8bae1dSRodney W. Grimes 		 * Remove the gap in the membership array.
1134df8bae1dSRodney W. Grimes 		 */
1135df8bae1dSRodney W. Grimes 		for (++i; i < imo->imo_num_memberships; ++i)
1136df8bae1dSRodney W. Grimes 			imo->imo_membership[i-1] = imo->imo_membership[i];
1137df8bae1dSRodney W. Grimes 		--imo->imo_num_memberships;
11389b626c29SGarrett Wollman 		splx(s);
1139df8bae1dSRodney W. Grimes 		break;
1140df8bae1dSRodney W. Grimes 
1141df8bae1dSRodney W. Grimes 	default:
1142df8bae1dSRodney W. Grimes 		error = EOPNOTSUPP;
1143df8bae1dSRodney W. Grimes 		break;
1144df8bae1dSRodney W. Grimes 	}
1145df8bae1dSRodney W. Grimes 
1146df8bae1dSRodney W. Grimes 	/*
1147df8bae1dSRodney W. Grimes 	 * If all options have default values, no need to keep the mbuf.
1148df8bae1dSRodney W. Grimes 	 */
1149df8bae1dSRodney W. Grimes 	if (imo->imo_multicast_ifp == NULL &&
11501c5de19aSGarrett Wollman 	    imo->imo_multicast_vif == -1 &&
1151df8bae1dSRodney W. Grimes 	    imo->imo_multicast_ttl == IP_DEFAULT_MULTICAST_TTL &&
1152df8bae1dSRodney W. Grimes 	    imo->imo_multicast_loop == IP_DEFAULT_MULTICAST_LOOP &&
1153df8bae1dSRodney W. Grimes 	    imo->imo_num_memberships == 0) {
1154df8bae1dSRodney W. Grimes 		free(*imop, M_IPMOPTS);
1155df8bae1dSRodney W. Grimes 		*imop = NULL;
1156df8bae1dSRodney W. Grimes 	}
1157df8bae1dSRodney W. Grimes 
1158df8bae1dSRodney W. Grimes 	return (error);
1159df8bae1dSRodney W. Grimes }
1160df8bae1dSRodney W. Grimes 
1161df8bae1dSRodney W. Grimes /*
1162df8bae1dSRodney W. Grimes  * Return the IP multicast options in response to user getsockopt().
1163df8bae1dSRodney W. Grimes  */
11640312fbe9SPoul-Henning Kamp static int
1165df8bae1dSRodney W. Grimes ip_getmoptions(optname, imo, mp)
1166df8bae1dSRodney W. Grimes 	int optname;
1167df8bae1dSRodney W. Grimes 	register struct ip_moptions *imo;
1168df8bae1dSRodney W. Grimes 	register struct mbuf **mp;
1169df8bae1dSRodney W. Grimes {
1170df8bae1dSRodney W. Grimes 	u_char *ttl;
1171df8bae1dSRodney W. Grimes 	u_char *loop;
1172df8bae1dSRodney W. Grimes 	struct in_addr *addr;
1173df8bae1dSRodney W. Grimes 	struct in_ifaddr *ia;
1174df8bae1dSRodney W. Grimes 
1175df8bae1dSRodney W. Grimes 	*mp = m_get(M_WAIT, MT_SOOPTS);
1176df8bae1dSRodney W. Grimes 
1177df8bae1dSRodney W. Grimes 	switch (optname) {
1178df8bae1dSRodney W. Grimes 
1179f0068c4aSGarrett Wollman 	case IP_MULTICAST_VIF:
1180f0068c4aSGarrett Wollman 		if (imo != NULL)
1181f0068c4aSGarrett Wollman 			*(mtod(*mp, int *)) = imo->imo_multicast_vif;
1182f0068c4aSGarrett Wollman 		else
11831c5de19aSGarrett Wollman 			*(mtod(*mp, int *)) = -1;
1184f0068c4aSGarrett Wollman 		(*mp)->m_len = sizeof(int);
1185f0068c4aSGarrett Wollman 		return(0);
1186f0068c4aSGarrett Wollman 
1187df8bae1dSRodney W. Grimes 	case IP_MULTICAST_IF:
1188df8bae1dSRodney W. Grimes 		addr = mtod(*mp, struct in_addr *);
1189df8bae1dSRodney W. Grimes 		(*mp)->m_len = sizeof(struct in_addr);
1190df8bae1dSRodney W. Grimes 		if (imo == NULL || imo->imo_multicast_ifp == NULL)
1191df8bae1dSRodney W. Grimes 			addr->s_addr = INADDR_ANY;
1192df8bae1dSRodney W. Grimes 		else {
1193df8bae1dSRodney W. Grimes 			IFP_TO_IA(imo->imo_multicast_ifp, ia);
1194df8bae1dSRodney W. Grimes 			addr->s_addr = (ia == NULL) ? INADDR_ANY
1195df8bae1dSRodney W. Grimes 					: IA_SIN(ia)->sin_addr.s_addr;
1196df8bae1dSRodney W. Grimes 		}
1197df8bae1dSRodney W. Grimes 		return (0);
1198df8bae1dSRodney W. Grimes 
1199df8bae1dSRodney W. Grimes 	case IP_MULTICAST_TTL:
1200df8bae1dSRodney W. Grimes 		ttl = mtod(*mp, u_char *);
1201df8bae1dSRodney W. Grimes 		(*mp)->m_len = 1;
1202df8bae1dSRodney W. Grimes 		*ttl = (imo == NULL) ? IP_DEFAULT_MULTICAST_TTL
1203df8bae1dSRodney W. Grimes 				     : imo->imo_multicast_ttl;
1204df8bae1dSRodney W. Grimes 		return (0);
1205df8bae1dSRodney W. Grimes 
1206df8bae1dSRodney W. Grimes 	case IP_MULTICAST_LOOP:
1207df8bae1dSRodney W. Grimes 		loop = mtod(*mp, u_char *);
1208df8bae1dSRodney W. Grimes 		(*mp)->m_len = 1;
1209df8bae1dSRodney W. Grimes 		*loop = (imo == NULL) ? IP_DEFAULT_MULTICAST_LOOP
1210df8bae1dSRodney W. Grimes 				      : imo->imo_multicast_loop;
1211df8bae1dSRodney W. Grimes 		return (0);
1212df8bae1dSRodney W. Grimes 
1213df8bae1dSRodney W. Grimes 	default:
1214df8bae1dSRodney W. Grimes 		return (EOPNOTSUPP);
1215df8bae1dSRodney W. Grimes 	}
1216df8bae1dSRodney W. Grimes }
1217df8bae1dSRodney W. Grimes 
1218df8bae1dSRodney W. Grimes /*
1219df8bae1dSRodney W. Grimes  * Discard the IP multicast options.
1220df8bae1dSRodney W. Grimes  */
1221df8bae1dSRodney W. Grimes void
1222df8bae1dSRodney W. Grimes ip_freemoptions(imo)
1223df8bae1dSRodney W. Grimes 	register struct ip_moptions *imo;
1224df8bae1dSRodney W. Grimes {
1225df8bae1dSRodney W. Grimes 	register int i;
1226df8bae1dSRodney W. Grimes 
1227df8bae1dSRodney W. Grimes 	if (imo != NULL) {
1228df8bae1dSRodney W. Grimes 		for (i = 0; i < imo->imo_num_memberships; ++i)
1229df8bae1dSRodney W. Grimes 			in_delmulti(imo->imo_membership[i]);
1230df8bae1dSRodney W. Grimes 		free(imo, M_IPMOPTS);
1231df8bae1dSRodney W. Grimes 	}
1232df8bae1dSRodney W. Grimes }
1233df8bae1dSRodney W. Grimes 
1234df8bae1dSRodney W. Grimes /*
1235df8bae1dSRodney W. Grimes  * Routine called from ip_output() to loop back a copy of an IP multicast
1236df8bae1dSRodney W. Grimes  * packet to the input queue of a specified interface.  Note that this
1237df8bae1dSRodney W. Grimes  * calls the output routine of the loopback "driver", but with an interface
1238f5fea3ddSPaul Traina  * pointer that might NOT be a loopback interface -- evil, but easier than
1239f5fea3ddSPaul Traina  * replicating that code here.
1240df8bae1dSRodney W. Grimes  */
1241df8bae1dSRodney W. Grimes static void
1242df8bae1dSRodney W. Grimes ip_mloopback(ifp, m, dst)
1243df8bae1dSRodney W. Grimes 	struct ifnet *ifp;
1244df8bae1dSRodney W. Grimes 	register struct mbuf *m;
1245df8bae1dSRodney W. Grimes 	register struct sockaddr_in *dst;
1246df8bae1dSRodney W. Grimes {
1247df8bae1dSRodney W. Grimes 	register struct ip *ip;
1248df8bae1dSRodney W. Grimes 	struct mbuf *copym;
1249df8bae1dSRodney W. Grimes 
1250df8bae1dSRodney W. Grimes 	copym = m_copy(m, 0, M_COPYALL);
1251df8bae1dSRodney W. Grimes 	if (copym != NULL) {
1252df8bae1dSRodney W. Grimes 		/*
1253df8bae1dSRodney W. Grimes 		 * We don't bother to fragment if the IP length is greater
1254df8bae1dSRodney W. Grimes 		 * than the interface's MTU.  Can this possibly matter?
1255df8bae1dSRodney W. Grimes 		 */
1256df8bae1dSRodney W. Grimes 		ip = mtod(copym, struct ip *);
1257df8bae1dSRodney W. Grimes 		ip->ip_len = htons((u_short)ip->ip_len);
1258df8bae1dSRodney W. Grimes 		ip->ip_off = htons((u_short)ip->ip_off);
1259df8bae1dSRodney W. Grimes 		ip->ip_sum = 0;
12609c9137eaSGarrett Wollman 		if (ip->ip_vhl == IP_VHL_BORING) {
12619c9137eaSGarrett Wollman 			ip->ip_sum = in_cksum_hdr(ip);
12629c9137eaSGarrett Wollman 		} else {
12639c9137eaSGarrett Wollman 			ip->ip_sum = in_cksum(copym,
12649c9137eaSGarrett Wollman 					      IP_VHL_HL(ip->ip_vhl) << 2);
12659c9137eaSGarrett Wollman 		}
12669c9137eaSGarrett Wollman 		/*
12679c9137eaSGarrett Wollman 		 * NB:
12689c9137eaSGarrett Wollman 		 * We can't simply call ip_input() directly because
12699c9137eaSGarrett Wollman 		 * the ip_mforward() depends on the `input interface'
12709c9137eaSGarrett Wollman 		 * being set to something unreasonable so that we don't
12719c9137eaSGarrett Wollman 		 * attempt to forward the looped-back copy.
12729c9137eaSGarrett Wollman 		 * It's also not clear whether there are any lingering
12739c9137eaSGarrett Wollman 		 * reentrancy problems in other areas which might be
12749c9137eaSGarrett Wollman 		 * exposed by this code.  For the moment, we'll err
12759c9137eaSGarrett Wollman 		 * on the side of safety by continuing to abuse
12769c9137eaSGarrett Wollman 		 * loinput().
12779c9137eaSGarrett Wollman 		 */
12789c9137eaSGarrett Wollman #ifdef notdef
12799c9137eaSGarrett Wollman 		copym->m_pkthdr.rcvif = &loif[0];
12809c9137eaSGarrett Wollman 		ip_input(copym)
12819c9137eaSGarrett Wollman #else
1282df8bae1dSRodney W. Grimes 		(void) looutput(ifp, copym, (struct sockaddr *)dst, NULL);
12839c9137eaSGarrett Wollman #endif
1284df8bae1dSRodney W. Grimes 	}
1285df8bae1dSRodney W. Grimes }
1286