xref: /freebsd/sys/netinet/ip_output.c (revision 87c1627502a5dde91e5284118eec8682b60f27a2)
1 /*-
2  * Copyright (c) 1982, 1986, 1988, 1990, 1993
3  *	The Regents of the University of California.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 4. Neither the name of the University nor the names of its contributors
14  *    may be used to endorse or promote products derived from this software
15  *    without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  *
29  *	@(#)ip_output.c	8.3 (Berkeley) 1/21/94
30  */
31 
32 #include <sys/cdefs.h>
33 __FBSDID("$FreeBSD$");
34 
35 #include "opt_ipfw.h"
36 #include "opt_ipsec.h"
37 #include "opt_route.h"
38 #include "opt_mbuf_stress_test.h"
39 #include "opt_mpath.h"
40 #include "opt_sctp.h"
41 
42 #include <sys/param.h>
43 #include <sys/systm.h>
44 #include <sys/kernel.h>
45 #include <sys/malloc.h>
46 #include <sys/mbuf.h>
47 #include <sys/priv.h>
48 #include <sys/proc.h>
49 #include <sys/protosw.h>
50 #include <sys/socket.h>
51 #include <sys/socketvar.h>
52 #include <sys/sysctl.h>
53 #include <sys/ucred.h>
54 
55 #include <net/if.h>
56 #include <net/if_llatbl.h>
57 #include <net/netisr.h>
58 #include <net/pfil.h>
59 #include <net/route.h>
60 #include <net/flowtable.h>
61 #ifdef RADIX_MPATH
62 #include <net/radix_mpath.h>
63 #endif
64 #include <net/vnet.h>
65 
66 #include <netinet/in.h>
67 #include <netinet/in_systm.h>
68 #include <netinet/ip.h>
69 #include <netinet/in_pcb.h>
70 #include <netinet/in_var.h>
71 #include <netinet/ip_var.h>
72 #include <netinet/ip_options.h>
73 #ifdef SCTP
74 #include <netinet/sctp.h>
75 #include <netinet/sctp_crc32.h>
76 #endif
77 
78 #ifdef IPSEC
79 #include <netinet/ip_ipsec.h>
80 #include <netipsec/ipsec.h>
81 #endif /* IPSEC*/
82 
83 #include <machine/in_cksum.h>
84 
85 #include <security/mac/mac_framework.h>
86 
87 VNET_DEFINE(u_short, ip_id);
88 
89 #ifdef MBUF_STRESS_TEST
90 static int mbuf_frag_size = 0;
91 SYSCTL_INT(_net_inet_ip, OID_AUTO, mbuf_frag_size, CTLFLAG_RW,
92 	&mbuf_frag_size, 0, "Fragment outgoing mbufs to this size");
93 #endif
94 
95 static void	ip_mloopback
96 	(struct ifnet *, struct mbuf *, struct sockaddr_in *, int);
97 
98 
99 extern int in_mcast_loop;
100 extern	struct protosw inetsw[];
101 
102 /*
103  * IP output.  The packet in mbuf chain m contains a skeletal IP
104  * header (with len, off, ttl, proto, tos, src, dst).
105  * The mbuf chain containing the packet will be freed.
106  * The mbuf opt, if present, will not be freed.
107  * If route ro is present and has ro_rt initialized, route lookup would be
108  * skipped and ro->ro_rt would be used. If ro is present but ro->ro_rt is NULL,
109  * then result of route lookup is stored in ro->ro_rt.
110  *
111  * In the IP forwarding case, the packet will arrive with options already
112  * inserted, so must have a NULL opt pointer.
113  */
114 int
115 ip_output(struct mbuf *m, struct mbuf *opt, struct route *ro, int flags,
116     struct ip_moptions *imo, struct inpcb *inp)
117 {
118 	struct ip *ip;
119 	struct ifnet *ifp = NULL;	/* keep compiler happy */
120 	struct mbuf *m0;
121 	int hlen = sizeof (struct ip);
122 	int mtu;
123 	int n;	/* scratchpad */
124 	int error = 0;
125 	struct sockaddr_in *dst;
126 	const struct sockaddr_in *gw;
127 	struct in_ifaddr *ia;
128 	int isbroadcast;
129 	uint16_t ip_len, ip_off;
130 	struct route iproute;
131 	struct rtentry *rte;	/* cache for ro->ro_rt */
132 	struct in_addr odst;
133 	struct m_tag *fwd_tag = NULL;
134 #ifdef IPSEC
135 	int no_route_but_check_spd = 0;
136 #endif
137 	M_ASSERTPKTHDR(m);
138 
139 	if (inp != NULL) {
140 		INP_LOCK_ASSERT(inp);
141 		M_SETFIB(m, inp->inp_inc.inc_fibnum);
142 		if (inp->inp_flags & (INP_HW_FLOWID|INP_SW_FLOWID)) {
143 			m->m_pkthdr.flowid = inp->inp_flowid;
144 			m->m_flags |= M_FLOWID;
145 		}
146 	}
147 
148 	if (ro == NULL) {
149 		ro = &iproute;
150 		bzero(ro, sizeof (*ro));
151 	}
152 
153 #ifdef FLOWTABLE
154 	if (ro->ro_rt == NULL) {
155 		struct flentry *fle;
156 
157 		/*
158 		 * The flow table returns route entries valid for up to 30
159 		 * seconds; we rely on the remainder of ip_output() taking no
160 		 * longer than that long for the stability of ro_rt. The
161 		 * flow ID assignment must have happened before this point.
162 		 */
163 		fle = flowtable_lookup_mbuf(V_ip_ft, m, AF_INET);
164 		if (fle != NULL)
165 			flow_to_route(fle, ro);
166 	}
167 #endif
168 
169 	if (opt) {
170 		int len = 0;
171 		m = ip_insertoptions(m, opt, &len);
172 		if (len != 0)
173 			hlen = len; /* ip->ip_hl is updated above */
174 	}
175 	ip = mtod(m, struct ip *);
176 	ip_len = ntohs(ip->ip_len);
177 	ip_off = ntohs(ip->ip_off);
178 
179 	/*
180 	 * Fill in IP header.  If we are not allowing fragmentation,
181 	 * then the ip_id field is meaningless, but we don't set it
182 	 * to zero.  Doing so causes various problems when devices along
183 	 * the path (routers, load balancers, firewalls, etc.) illegally
184 	 * disable DF on our packet.  Note that a 16-bit counter
185 	 * will wrap around in less than 10 seconds at 100 Mbit/s on a
186 	 * medium with MTU 1500.  See Steven M. Bellovin, "A Technique
187 	 * for Counting NATted Hosts", Proc. IMW'02, available at
188 	 * <http://www.cs.columbia.edu/~smb/papers/fnat.pdf>.
189 	 */
190 	if ((flags & (IP_FORWARDING|IP_RAWOUTPUT)) == 0) {
191 		ip->ip_v = IPVERSION;
192 		ip->ip_hl = hlen >> 2;
193 		ip->ip_id = ip_newid();
194 		IPSTAT_INC(ips_localout);
195 	} else {
196 		/* Header already set, fetch hlen from there */
197 		hlen = ip->ip_hl << 2;
198 	}
199 
200 	gw = dst = (struct sockaddr_in *)&ro->ro_dst;
201 again:
202 	ia = NULL;
203 	/*
204 	 * If there is a cached route,
205 	 * check that it is to the same destination
206 	 * and is still up.  If not, free it and try again.
207 	 * The address family should also be checked in case of sharing the
208 	 * cache with IPv6.
209 	 */
210 	rte = ro->ro_rt;
211 	if (rte && ((rte->rt_flags & RTF_UP) == 0 ||
212 		    rte->rt_ifp == NULL ||
213 		    !RT_LINK_IS_UP(rte->rt_ifp) ||
214 			  dst->sin_family != AF_INET ||
215 			  dst->sin_addr.s_addr != ip->ip_dst.s_addr)) {
216 		RO_RTFREE(ro);
217 		ro->ro_lle = NULL;
218 		rte = NULL;
219 	}
220 	if (rte == NULL && fwd_tag == NULL) {
221 		bzero(dst, sizeof(*dst));
222 		dst->sin_family = AF_INET;
223 		dst->sin_len = sizeof(*dst);
224 		dst->sin_addr = ip->ip_dst;
225 	}
226 	/*
227 	 * If routing to interface only, short circuit routing lookup.
228 	 * The use of an all-ones broadcast address implies this; an
229 	 * interface is specified by the broadcast address of an interface,
230 	 * or the destination address of a ptp interface.
231 	 */
232 	if (flags & IP_SENDONES) {
233 		if ((ia = ifatoia(ifa_ifwithbroadaddr(sintosa(dst)))) == NULL &&
234 		    (ia = ifatoia(ifa_ifwithdstaddr(sintosa(dst)))) == NULL) {
235 			IPSTAT_INC(ips_noroute);
236 			error = ENETUNREACH;
237 			goto bad;
238 		}
239 		ip->ip_dst.s_addr = INADDR_BROADCAST;
240 		dst->sin_addr = ip->ip_dst;
241 		ifp = ia->ia_ifp;
242 		ip->ip_ttl = 1;
243 		isbroadcast = 1;
244 	} else if (flags & IP_ROUTETOIF) {
245 		if ((ia = ifatoia(ifa_ifwithdstaddr(sintosa(dst)))) == NULL &&
246 		    (ia = ifatoia(ifa_ifwithnet(sintosa(dst), 0))) == NULL) {
247 			IPSTAT_INC(ips_noroute);
248 			error = ENETUNREACH;
249 			goto bad;
250 		}
251 		ifp = ia->ia_ifp;
252 		ip->ip_ttl = 1;
253 		isbroadcast = in_broadcast(dst->sin_addr, ifp);
254 	} else if (IN_MULTICAST(ntohl(ip->ip_dst.s_addr)) &&
255 	    imo != NULL && imo->imo_multicast_ifp != NULL) {
256 		/*
257 		 * Bypass the normal routing lookup for multicast
258 		 * packets if the interface is specified.
259 		 */
260 		ifp = imo->imo_multicast_ifp;
261 		IFP_TO_IA(ifp, ia);
262 		isbroadcast = 0;	/* fool gcc */
263 	} else {
264 		/*
265 		 * We want to do any cloning requested by the link layer,
266 		 * as this is probably required in all cases for correct
267 		 * operation (as it is for ARP).
268 		 */
269 		if (rte == NULL) {
270 #ifdef RADIX_MPATH
271 			rtalloc_mpath_fib(ro,
272 			    ntohl(ip->ip_src.s_addr ^ ip->ip_dst.s_addr),
273 			    inp ? inp->inp_inc.inc_fibnum : M_GETFIB(m));
274 #else
275 			in_rtalloc_ign(ro, 0,
276 			    inp ? inp->inp_inc.inc_fibnum : M_GETFIB(m));
277 #endif
278 			rte = ro->ro_rt;
279 		}
280 		if (rte == NULL ||
281 		    rte->rt_ifp == NULL ||
282 		    !RT_LINK_IS_UP(rte->rt_ifp)) {
283 #ifdef IPSEC
284 			/*
285 			 * There is no route for this packet, but it is
286 			 * possible that a matching SPD entry exists.
287 			 */
288 			no_route_but_check_spd = 1;
289 			mtu = 0; /* Silence GCC warning. */
290 			goto sendit;
291 #endif
292 			IPSTAT_INC(ips_noroute);
293 			error = EHOSTUNREACH;
294 			goto bad;
295 		}
296 		ia = ifatoia(rte->rt_ifa);
297 		ifa_ref(&ia->ia_ifa);
298 		ifp = rte->rt_ifp;
299 		rte->rt_rmx.rmx_pksent++;
300 		if (rte->rt_flags & RTF_GATEWAY)
301 			gw = (struct sockaddr_in *)rte->rt_gateway;
302 		if (rte->rt_flags & RTF_HOST)
303 			isbroadcast = (rte->rt_flags & RTF_BROADCAST);
304 		else
305 			isbroadcast = in_broadcast(gw->sin_addr, ifp);
306 	}
307 	/*
308 	 * Calculate MTU.  If we have a route that is up, use that,
309 	 * otherwise use the interface's MTU.
310 	 */
311 	if (rte != NULL && (rte->rt_flags & (RTF_UP|RTF_HOST))) {
312 		/*
313 		 * This case can happen if the user changed the MTU
314 		 * of an interface after enabling IP on it.  Because
315 		 * most netifs don't keep track of routes pointing to
316 		 * them, there is no way for one to update all its
317 		 * routes when the MTU is changed.
318 		 */
319 		if (rte->rt_rmx.rmx_mtu > ifp->if_mtu)
320 			rte->rt_rmx.rmx_mtu = ifp->if_mtu;
321 		mtu = rte->rt_rmx.rmx_mtu;
322 	} else {
323 		mtu = ifp->if_mtu;
324 	}
325 	/* Catch a possible divide by zero later. */
326 	KASSERT(mtu > 0, ("%s: mtu %d <= 0, rte=%p (rt_flags=0x%08x) ifp=%p",
327 	    __func__, mtu, rte, (rte != NULL) ? rte->rt_flags : 0, ifp));
328 	if (IN_MULTICAST(ntohl(ip->ip_dst.s_addr))) {
329 		m->m_flags |= M_MCAST;
330 		/*
331 		 * See if the caller provided any multicast options
332 		 */
333 		if (imo != NULL) {
334 			ip->ip_ttl = imo->imo_multicast_ttl;
335 			if (imo->imo_multicast_vif != -1)
336 				ip->ip_src.s_addr =
337 				    ip_mcast_src ?
338 				    ip_mcast_src(imo->imo_multicast_vif) :
339 				    INADDR_ANY;
340 		} else
341 			ip->ip_ttl = IP_DEFAULT_MULTICAST_TTL;
342 		/*
343 		 * Confirm that the outgoing interface supports multicast.
344 		 */
345 		if ((imo == NULL) || (imo->imo_multicast_vif == -1)) {
346 			if ((ifp->if_flags & IFF_MULTICAST) == 0) {
347 				IPSTAT_INC(ips_noroute);
348 				error = ENETUNREACH;
349 				goto bad;
350 			}
351 		}
352 		/*
353 		 * If source address not specified yet, use address
354 		 * of outgoing interface.
355 		 */
356 		if (ip->ip_src.s_addr == INADDR_ANY) {
357 			/* Interface may have no addresses. */
358 			if (ia != NULL)
359 				ip->ip_src = IA_SIN(ia)->sin_addr;
360 		}
361 
362 		if ((imo == NULL && in_mcast_loop) ||
363 		    (imo && imo->imo_multicast_loop)) {
364 			/*
365 			 * Loop back multicast datagram if not expressly
366 			 * forbidden to do so, even if we are not a member
367 			 * of the group; ip_input() will filter it later,
368 			 * thus deferring a hash lookup and mutex acquisition
369 			 * at the expense of a cheap copy using m_copym().
370 			 */
371 			ip_mloopback(ifp, m, dst, hlen);
372 		} else {
373 			/*
374 			 * If we are acting as a multicast router, perform
375 			 * multicast forwarding as if the packet had just
376 			 * arrived on the interface to which we are about
377 			 * to send.  The multicast forwarding function
378 			 * recursively calls this function, using the
379 			 * IP_FORWARDING flag to prevent infinite recursion.
380 			 *
381 			 * Multicasts that are looped back by ip_mloopback(),
382 			 * above, will be forwarded by the ip_input() routine,
383 			 * if necessary.
384 			 */
385 			if (V_ip_mrouter && (flags & IP_FORWARDING) == 0) {
386 				/*
387 				 * If rsvp daemon is not running, do not
388 				 * set ip_moptions. This ensures that the packet
389 				 * is multicast and not just sent down one link
390 				 * as prescribed by rsvpd.
391 				 */
392 				if (!V_rsvp_on)
393 					imo = NULL;
394 				if (ip_mforward &&
395 				    ip_mforward(ip, ifp, m, imo) != 0) {
396 					m_freem(m);
397 					goto done;
398 				}
399 			}
400 		}
401 
402 		/*
403 		 * Multicasts with a time-to-live of zero may be looped-
404 		 * back, above, but must not be transmitted on a network.
405 		 * Also, multicasts addressed to the loopback interface
406 		 * are not sent -- the above call to ip_mloopback() will
407 		 * loop back a copy. ip_input() will drop the copy if
408 		 * this host does not belong to the destination group on
409 		 * the loopback interface.
410 		 */
411 		if (ip->ip_ttl == 0 || ifp->if_flags & IFF_LOOPBACK) {
412 			m_freem(m);
413 			goto done;
414 		}
415 
416 		goto sendit;
417 	}
418 
419 	/*
420 	 * If the source address is not specified yet, use the address
421 	 * of the outoing interface.
422 	 */
423 	if (ip->ip_src.s_addr == INADDR_ANY) {
424 		/* Interface may have no addresses. */
425 		if (ia != NULL) {
426 			ip->ip_src = IA_SIN(ia)->sin_addr;
427 		}
428 	}
429 
430 	/*
431 	 * Verify that we have any chance at all of being able to queue the
432 	 * packet or packet fragments, unless ALTQ is enabled on the given
433 	 * interface in which case packetdrop should be done by queueing.
434 	 */
435 	n = ip_len / mtu + 1; /* how many fragments ? */
436 	if (
437 #ifdef ALTQ
438 	    (!ALTQ_IS_ENABLED(&ifp->if_snd)) &&
439 #endif /* ALTQ */
440 	    (ifp->if_snd.ifq_len + n) >= ifp->if_snd.ifq_maxlen ) {
441 		error = ENOBUFS;
442 		IPSTAT_INC(ips_odropped);
443 		ifp->if_snd.ifq_drops += n;
444 		goto bad;
445 	}
446 
447 	/*
448 	 * Look for broadcast address and
449 	 * verify user is allowed to send
450 	 * such a packet.
451 	 */
452 	if (isbroadcast) {
453 		if ((ifp->if_flags & IFF_BROADCAST) == 0) {
454 			error = EADDRNOTAVAIL;
455 			goto bad;
456 		}
457 		if ((flags & IP_ALLOWBROADCAST) == 0) {
458 			error = EACCES;
459 			goto bad;
460 		}
461 		/* don't allow broadcast messages to be fragmented */
462 		if (ip_len > mtu) {
463 			error = EMSGSIZE;
464 			goto bad;
465 		}
466 		m->m_flags |= M_BCAST;
467 	} else {
468 		m->m_flags &= ~M_BCAST;
469 	}
470 
471 sendit:
472 #ifdef IPSEC
473 	switch(ip_ipsec_output(&m, inp, &flags, &error)) {
474 	case 1:
475 		goto bad;
476 	case -1:
477 		goto done;
478 	case 0:
479 	default:
480 		break;	/* Continue with packet processing. */
481 	}
482 	/*
483 	 * Check if there was a route for this packet; return error if not.
484 	 */
485 	if (no_route_but_check_spd) {
486 		IPSTAT_INC(ips_noroute);
487 		error = EHOSTUNREACH;
488 		goto bad;
489 	}
490 	/* Update variables that are affected by ipsec4_output(). */
491 	ip = mtod(m, struct ip *);
492 	hlen = ip->ip_hl << 2;
493 #endif /* IPSEC */
494 
495 	/* Jump over all PFIL processing if hooks are not active. */
496 	if (!PFIL_HOOKED(&V_inet_pfil_hook))
497 		goto passout;
498 
499 	/* Run through list of hooks for output packets. */
500 	odst.s_addr = ip->ip_dst.s_addr;
501 	error = pfil_run_hooks(&V_inet_pfil_hook, &m, ifp, PFIL_OUT, inp);
502 	if (error != 0 || m == NULL)
503 		goto done;
504 
505 	ip = mtod(m, struct ip *);
506 
507 	/* See if destination IP address was changed by packet filter. */
508 	if (odst.s_addr != ip->ip_dst.s_addr) {
509 		m->m_flags |= M_SKIP_FIREWALL;
510 		/* If destination is now ourself drop to ip_input(). */
511 		if (in_localip(ip->ip_dst)) {
512 			m->m_flags |= M_FASTFWD_OURS;
513 			if (m->m_pkthdr.rcvif == NULL)
514 				m->m_pkthdr.rcvif = V_loif;
515 			if (m->m_pkthdr.csum_flags & CSUM_DELAY_DATA) {
516 				m->m_pkthdr.csum_flags |=
517 				    CSUM_DATA_VALID | CSUM_PSEUDO_HDR;
518 				m->m_pkthdr.csum_data = 0xffff;
519 			}
520 			m->m_pkthdr.csum_flags |=
521 			    CSUM_IP_CHECKED | CSUM_IP_VALID;
522 #ifdef SCTP
523 			if (m->m_pkthdr.csum_flags & CSUM_SCTP)
524 				m->m_pkthdr.csum_flags |= CSUM_SCTP_VALID;
525 #endif
526 			error = netisr_queue(NETISR_IP, m);
527 			goto done;
528 		} else {
529 			if (ia != NULL)
530 				ifa_free(&ia->ia_ifa);
531 			goto again;	/* Redo the routing table lookup. */
532 		}
533 	}
534 
535 	/* See if local, if yes, send it to netisr with IP_FASTFWD_OURS. */
536 	if (m->m_flags & M_FASTFWD_OURS) {
537 		if (m->m_pkthdr.rcvif == NULL)
538 			m->m_pkthdr.rcvif = V_loif;
539 		if (m->m_pkthdr.csum_flags & CSUM_DELAY_DATA) {
540 			m->m_pkthdr.csum_flags |=
541 			    CSUM_DATA_VALID | CSUM_PSEUDO_HDR;
542 			m->m_pkthdr.csum_data = 0xffff;
543 		}
544 #ifdef SCTP
545 		if (m->m_pkthdr.csum_flags & CSUM_SCTP)
546 			m->m_pkthdr.csum_flags |= CSUM_SCTP_VALID;
547 #endif
548 		m->m_pkthdr.csum_flags |=
549 			    CSUM_IP_CHECKED | CSUM_IP_VALID;
550 
551 		error = netisr_queue(NETISR_IP, m);
552 		goto done;
553 	}
554 	/* Or forward to some other address? */
555 	if ((m->m_flags & M_IP_NEXTHOP) &&
556 	    (fwd_tag = m_tag_find(m, PACKET_TAG_IPFORWARD, NULL)) != NULL) {
557 		bcopy((fwd_tag+1), dst, sizeof(struct sockaddr_in));
558 		m->m_flags |= M_SKIP_FIREWALL;
559 		m->m_flags &= ~M_IP_NEXTHOP;
560 		m_tag_delete(m, fwd_tag);
561 		if (ia != NULL)
562 			ifa_free(&ia->ia_ifa);
563 		goto again;
564 	}
565 
566 passout:
567 	/* 127/8 must not appear on wire - RFC1122. */
568 	if ((ntohl(ip->ip_dst.s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET ||
569 	    (ntohl(ip->ip_src.s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET) {
570 		if ((ifp->if_flags & IFF_LOOPBACK) == 0) {
571 			IPSTAT_INC(ips_badaddr);
572 			error = EADDRNOTAVAIL;
573 			goto bad;
574 		}
575 	}
576 
577 	m->m_pkthdr.csum_flags |= CSUM_IP;
578 	if (m->m_pkthdr.csum_flags & CSUM_DELAY_DATA & ~ifp->if_hwassist) {
579 		in_delayed_cksum(m);
580 		m->m_pkthdr.csum_flags &= ~CSUM_DELAY_DATA;
581 	}
582 #ifdef SCTP
583 	if (m->m_pkthdr.csum_flags & CSUM_SCTP & ~ifp->if_hwassist) {
584 		sctp_delayed_cksum(m, (uint32_t)(ip->ip_hl << 2));
585 		m->m_pkthdr.csum_flags &= ~CSUM_SCTP;
586 	}
587 #endif
588 
589 	/*
590 	 * If small enough for interface, or the interface will take
591 	 * care of the fragmentation for us, we can just send directly.
592 	 */
593 	if (ip_len <= mtu ||
594 	    (m->m_pkthdr.csum_flags & ifp->if_hwassist & CSUM_TSO) != 0 ||
595 	    ((ip_off & IP_DF) == 0 && (ifp->if_hwassist & CSUM_FRAGMENT))) {
596 		ip->ip_sum = 0;
597 		if (m->m_pkthdr.csum_flags & CSUM_IP & ~ifp->if_hwassist) {
598 			ip->ip_sum = in_cksum(m, hlen);
599 			m->m_pkthdr.csum_flags &= ~CSUM_IP;
600 		}
601 
602 		/*
603 		 * Record statistics for this interface address.
604 		 * With CSUM_TSO the byte/packet count will be slightly
605 		 * incorrect because we count the IP+TCP headers only
606 		 * once instead of for every generated packet.
607 		 */
608 		if (!(flags & IP_FORWARDING) && ia) {
609 			if (m->m_pkthdr.csum_flags & CSUM_TSO)
610 				ia->ia_ifa.if_opackets +=
611 				    m->m_pkthdr.len / m->m_pkthdr.tso_segsz;
612 			else
613 				ia->ia_ifa.if_opackets++;
614 			ia->ia_ifa.if_obytes += m->m_pkthdr.len;
615 		}
616 #ifdef MBUF_STRESS_TEST
617 		if (mbuf_frag_size && m->m_pkthdr.len > mbuf_frag_size)
618 			m = m_fragment(m, M_NOWAIT, mbuf_frag_size);
619 #endif
620 		/*
621 		 * Reset layer specific mbuf flags
622 		 * to avoid confusing lower layers.
623 		 */
624 		m->m_flags &= ~(M_PROTOFLAGS);
625 		error = (*ifp->if_output)(ifp, m,
626 		    (const struct sockaddr *)gw, ro);
627 		goto done;
628 	}
629 
630 	/* Balk when DF bit is set or the interface didn't support TSO. */
631 	if ((ip_off & IP_DF) || (m->m_pkthdr.csum_flags & CSUM_TSO)) {
632 		error = EMSGSIZE;
633 		IPSTAT_INC(ips_cantfrag);
634 		goto bad;
635 	}
636 
637 	/*
638 	 * Too large for interface; fragment if possible. If successful,
639 	 * on return, m will point to a list of packets to be sent.
640 	 */
641 	error = ip_fragment(ip, &m, mtu, ifp->if_hwassist);
642 	if (error)
643 		goto bad;
644 	for (; m; m = m0) {
645 		m0 = m->m_nextpkt;
646 		m->m_nextpkt = 0;
647 		if (error == 0) {
648 			/* Record statistics for this interface address. */
649 			if (ia != NULL) {
650 				ia->ia_ifa.if_opackets++;
651 				ia->ia_ifa.if_obytes += m->m_pkthdr.len;
652 			}
653 			/*
654 			 * Reset layer specific mbuf flags
655 			 * to avoid confusing upper layers.
656 			 */
657 			m->m_flags &= ~(M_PROTOFLAGS);
658 
659 			error = (*ifp->if_output)(ifp, m,
660 			    (const struct sockaddr *)gw, ro);
661 		} else
662 			m_freem(m);
663 	}
664 
665 	if (error == 0)
666 		IPSTAT_INC(ips_fragmented);
667 
668 done:
669 	if (ro == &iproute)
670 		RO_RTFREE(ro);
671 	if (ia != NULL)
672 		ifa_free(&ia->ia_ifa);
673 	return (error);
674 bad:
675 	m_freem(m);
676 	goto done;
677 }
678 
679 /*
680  * Create a chain of fragments which fit the given mtu. m_frag points to the
681  * mbuf to be fragmented; on return it points to the chain with the fragments.
682  * Return 0 if no error. If error, m_frag may contain a partially built
683  * chain of fragments that should be freed by the caller.
684  *
685  * if_hwassist_flags is the hw offload capabilities (see if_data.ifi_hwassist)
686  */
687 int
688 ip_fragment(struct ip *ip, struct mbuf **m_frag, int mtu,
689     u_long if_hwassist_flags)
690 {
691 	int error = 0;
692 	int hlen = ip->ip_hl << 2;
693 	int len = (mtu - hlen) & ~7;	/* size of payload in each fragment */
694 	int off;
695 	struct mbuf *m0 = *m_frag;	/* the original packet		*/
696 	int firstlen;
697 	struct mbuf **mnext;
698 	int nfrags;
699 	uint16_t ip_len, ip_off;
700 
701 	ip_len = ntohs(ip->ip_len);
702 	ip_off = ntohs(ip->ip_off);
703 
704 	if (ip_off & IP_DF) {	/* Fragmentation not allowed */
705 		IPSTAT_INC(ips_cantfrag);
706 		return EMSGSIZE;
707 	}
708 
709 	/*
710 	 * Must be able to put at least 8 bytes per fragment.
711 	 */
712 	if (len < 8)
713 		return EMSGSIZE;
714 
715 	/*
716 	 * If the interface will not calculate checksums on
717 	 * fragmented packets, then do it here.
718 	 */
719 	if (m0->m_pkthdr.csum_flags & CSUM_DELAY_DATA) {
720 		in_delayed_cksum(m0);
721 		m0->m_pkthdr.csum_flags &= ~CSUM_DELAY_DATA;
722 	}
723 #ifdef SCTP
724 	if (m0->m_pkthdr.csum_flags & CSUM_SCTP) {
725 		sctp_delayed_cksum(m0, hlen);
726 		m0->m_pkthdr.csum_flags &= ~CSUM_SCTP;
727 	}
728 #endif
729 	if (len > PAGE_SIZE) {
730 		/*
731 		 * Fragment large datagrams such that each segment
732 		 * contains a multiple of PAGE_SIZE amount of data,
733 		 * plus headers. This enables a receiver to perform
734 		 * page-flipping zero-copy optimizations.
735 		 *
736 		 * XXX When does this help given that sender and receiver
737 		 * could have different page sizes, and also mtu could
738 		 * be less than the receiver's page size ?
739 		 */
740 		int newlen;
741 		struct mbuf *m;
742 
743 		for (m = m0, off = 0; m && (off+m->m_len) <= mtu; m = m->m_next)
744 			off += m->m_len;
745 
746 		/*
747 		 * firstlen (off - hlen) must be aligned on an
748 		 * 8-byte boundary
749 		 */
750 		if (off < hlen)
751 			goto smart_frag_failure;
752 		off = ((off - hlen) & ~7) + hlen;
753 		newlen = (~PAGE_MASK) & mtu;
754 		if ((newlen + sizeof (struct ip)) > mtu) {
755 			/* we failed, go back the default */
756 smart_frag_failure:
757 			newlen = len;
758 			off = hlen + len;
759 		}
760 		len = newlen;
761 
762 	} else {
763 		off = hlen + len;
764 	}
765 
766 	firstlen = off - hlen;
767 	mnext = &m0->m_nextpkt;		/* pointer to next packet */
768 
769 	/*
770 	 * Loop through length of segment after first fragment,
771 	 * make new header and copy data of each part and link onto chain.
772 	 * Here, m0 is the original packet, m is the fragment being created.
773 	 * The fragments are linked off the m_nextpkt of the original
774 	 * packet, which after processing serves as the first fragment.
775 	 */
776 	for (nfrags = 1; off < ip_len; off += len, nfrags++) {
777 		struct ip *mhip;	/* ip header on the fragment */
778 		struct mbuf *m;
779 		int mhlen = sizeof (struct ip);
780 
781 		m = m_gethdr(M_NOWAIT, MT_DATA);
782 		if (m == NULL) {
783 			error = ENOBUFS;
784 			IPSTAT_INC(ips_odropped);
785 			goto done;
786 		}
787 		m->m_flags |= (m0->m_flags & M_MCAST) | M_FRAG;
788 		/*
789 		 * In the first mbuf, leave room for the link header, then
790 		 * copy the original IP header including options. The payload
791 		 * goes into an additional mbuf chain returned by m_copym().
792 		 */
793 		m->m_data += max_linkhdr;
794 		mhip = mtod(m, struct ip *);
795 		*mhip = *ip;
796 		if (hlen > sizeof (struct ip)) {
797 			mhlen = ip_optcopy(ip, mhip) + sizeof (struct ip);
798 			mhip->ip_v = IPVERSION;
799 			mhip->ip_hl = mhlen >> 2;
800 		}
801 		m->m_len = mhlen;
802 		/* XXX do we need to add ip_off below ? */
803 		mhip->ip_off = ((off - hlen) >> 3) + ip_off;
804 		if (off + len >= ip_len) {	/* last fragment */
805 			len = ip_len - off;
806 			m->m_flags |= M_LASTFRAG;
807 		} else
808 			mhip->ip_off |= IP_MF;
809 		mhip->ip_len = htons((u_short)(len + mhlen));
810 		m->m_next = m_copym(m0, off, len, M_NOWAIT);
811 		if (m->m_next == NULL) {	/* copy failed */
812 			m_free(m);
813 			error = ENOBUFS;	/* ??? */
814 			IPSTAT_INC(ips_odropped);
815 			goto done;
816 		}
817 		m->m_pkthdr.len = mhlen + len;
818 		m->m_pkthdr.rcvif = NULL;
819 #ifdef MAC
820 		mac_netinet_fragment(m0, m);
821 #endif
822 		m->m_pkthdr.csum_flags = m0->m_pkthdr.csum_flags;
823 		mhip->ip_off = htons(mhip->ip_off);
824 		mhip->ip_sum = 0;
825 		if (m->m_pkthdr.csum_flags & CSUM_IP & ~if_hwassist_flags) {
826 			mhip->ip_sum = in_cksum(m, mhlen);
827 			m->m_pkthdr.csum_flags &= ~CSUM_IP;
828 		}
829 		*mnext = m;
830 		mnext = &m->m_nextpkt;
831 	}
832 	IPSTAT_ADD(ips_ofragments, nfrags);
833 
834 	/* set first marker for fragment chain */
835 	m0->m_flags |= M_FIRSTFRAG | M_FRAG;
836 	m0->m_pkthdr.csum_data = nfrags;
837 
838 	/*
839 	 * Update first fragment by trimming what's been copied out
840 	 * and updating header.
841 	 */
842 	m_adj(m0, hlen + firstlen - ip_len);
843 	m0->m_pkthdr.len = hlen + firstlen;
844 	ip->ip_len = htons((u_short)m0->m_pkthdr.len);
845 	ip->ip_off = htons(ip_off | IP_MF);
846 	ip->ip_sum = 0;
847 	if (m0->m_pkthdr.csum_flags & CSUM_IP & ~if_hwassist_flags) {
848 		ip->ip_sum = in_cksum(m0, hlen);
849 		m0->m_pkthdr.csum_flags &= ~CSUM_IP;
850 	}
851 
852 done:
853 	*m_frag = m0;
854 	return error;
855 }
856 
857 void
858 in_delayed_cksum(struct mbuf *m)
859 {
860 	struct ip *ip;
861 	uint16_t csum, offset, ip_len;
862 
863 	ip = mtod(m, struct ip *);
864 	offset = ip->ip_hl << 2 ;
865 	ip_len = ntohs(ip->ip_len);
866 	csum = in_cksum_skip(m, ip_len, offset);
867 	if (m->m_pkthdr.csum_flags & CSUM_UDP && csum == 0)
868 		csum = 0xffff;
869 	offset += m->m_pkthdr.csum_data;	/* checksum offset */
870 
871 	if (offset + sizeof(u_short) > m->m_len) {
872 		printf("delayed m_pullup, m->len: %d  off: %d  p: %d\n",
873 		    m->m_len, offset, ip->ip_p);
874 		/*
875 		 * XXX
876 		 * this shouldn't happen, but if it does, the
877 		 * correct behavior may be to insert the checksum
878 		 * in the appropriate next mbuf in the chain.
879 		 */
880 		return;
881 	}
882 	*(u_short *)(m->m_data + offset) = csum;
883 }
884 
885 /*
886  * IP socket option processing.
887  */
888 int
889 ip_ctloutput(struct socket *so, struct sockopt *sopt)
890 {
891 	struct	inpcb *inp = sotoinpcb(so);
892 	int	error, optval;
893 
894 	error = optval = 0;
895 	if (sopt->sopt_level != IPPROTO_IP) {
896 		error = EINVAL;
897 
898 		if (sopt->sopt_level == SOL_SOCKET &&
899 		    sopt->sopt_dir == SOPT_SET) {
900 			switch (sopt->sopt_name) {
901 			case SO_REUSEADDR:
902 				INP_WLOCK(inp);
903 				if (IN_MULTICAST(ntohl(inp->inp_laddr.s_addr))) {
904 					if ((so->so_options &
905 					    (SO_REUSEADDR | SO_REUSEPORT)) != 0)
906 						inp->inp_flags2 |= INP_REUSEPORT;
907 					else
908 						inp->inp_flags2 &= ~INP_REUSEPORT;
909 				}
910 				INP_WUNLOCK(inp);
911 				error = 0;
912 				break;
913 			case SO_REUSEPORT:
914 				INP_WLOCK(inp);
915 				if ((so->so_options & SO_REUSEPORT) != 0)
916 					inp->inp_flags2 |= INP_REUSEPORT;
917 				else
918 					inp->inp_flags2 &= ~INP_REUSEPORT;
919 				INP_WUNLOCK(inp);
920 				error = 0;
921 				break;
922 			case SO_SETFIB:
923 				INP_WLOCK(inp);
924 				inp->inp_inc.inc_fibnum = so->so_fibnum;
925 				INP_WUNLOCK(inp);
926 				error = 0;
927 				break;
928 			default:
929 				break;
930 			}
931 		}
932 		return (error);
933 	}
934 
935 	switch (sopt->sopt_dir) {
936 	case SOPT_SET:
937 		switch (sopt->sopt_name) {
938 		case IP_OPTIONS:
939 #ifdef notyet
940 		case IP_RETOPTS:
941 #endif
942 		{
943 			struct mbuf *m;
944 			if (sopt->sopt_valsize > MLEN) {
945 				error = EMSGSIZE;
946 				break;
947 			}
948 			m = m_get(sopt->sopt_td ? M_WAITOK : M_NOWAIT, MT_DATA);
949 			if (m == NULL) {
950 				error = ENOBUFS;
951 				break;
952 			}
953 			m->m_len = sopt->sopt_valsize;
954 			error = sooptcopyin(sopt, mtod(m, char *), m->m_len,
955 					    m->m_len);
956 			if (error) {
957 				m_free(m);
958 				break;
959 			}
960 			INP_WLOCK(inp);
961 			error = ip_pcbopts(inp, sopt->sopt_name, m);
962 			INP_WUNLOCK(inp);
963 			return (error);
964 		}
965 
966 		case IP_BINDANY:
967 			if (sopt->sopt_td != NULL) {
968 				error = priv_check(sopt->sopt_td,
969 				    PRIV_NETINET_BINDANY);
970 				if (error)
971 					break;
972 			}
973 			/* FALLTHROUGH */
974 		case IP_TOS:
975 		case IP_TTL:
976 		case IP_MINTTL:
977 		case IP_RECVOPTS:
978 		case IP_RECVRETOPTS:
979 		case IP_RECVDSTADDR:
980 		case IP_RECVTTL:
981 		case IP_RECVIF:
982 		case IP_FAITH:
983 		case IP_ONESBCAST:
984 		case IP_DONTFRAG:
985 		case IP_RECVTOS:
986 			error = sooptcopyin(sopt, &optval, sizeof optval,
987 					    sizeof optval);
988 			if (error)
989 				break;
990 
991 			switch (sopt->sopt_name) {
992 			case IP_TOS:
993 				inp->inp_ip_tos = optval;
994 				break;
995 
996 			case IP_TTL:
997 				inp->inp_ip_ttl = optval;
998 				break;
999 
1000 			case IP_MINTTL:
1001 				if (optval >= 0 && optval <= MAXTTL)
1002 					inp->inp_ip_minttl = optval;
1003 				else
1004 					error = EINVAL;
1005 				break;
1006 
1007 #define	OPTSET(bit) do {						\
1008 	INP_WLOCK(inp);							\
1009 	if (optval)							\
1010 		inp->inp_flags |= bit;					\
1011 	else								\
1012 		inp->inp_flags &= ~bit;					\
1013 	INP_WUNLOCK(inp);						\
1014 } while (0)
1015 
1016 			case IP_RECVOPTS:
1017 				OPTSET(INP_RECVOPTS);
1018 				break;
1019 
1020 			case IP_RECVRETOPTS:
1021 				OPTSET(INP_RECVRETOPTS);
1022 				break;
1023 
1024 			case IP_RECVDSTADDR:
1025 				OPTSET(INP_RECVDSTADDR);
1026 				break;
1027 
1028 			case IP_RECVTTL:
1029 				OPTSET(INP_RECVTTL);
1030 				break;
1031 
1032 			case IP_RECVIF:
1033 				OPTSET(INP_RECVIF);
1034 				break;
1035 
1036 			case IP_FAITH:
1037 				OPTSET(INP_FAITH);
1038 				break;
1039 
1040 			case IP_ONESBCAST:
1041 				OPTSET(INP_ONESBCAST);
1042 				break;
1043 			case IP_DONTFRAG:
1044 				OPTSET(INP_DONTFRAG);
1045 				break;
1046 			case IP_BINDANY:
1047 				OPTSET(INP_BINDANY);
1048 				break;
1049 			case IP_RECVTOS:
1050 				OPTSET(INP_RECVTOS);
1051 				break;
1052 			}
1053 			break;
1054 #undef OPTSET
1055 
1056 		/*
1057 		 * Multicast socket options are processed by the in_mcast
1058 		 * module.
1059 		 */
1060 		case IP_MULTICAST_IF:
1061 		case IP_MULTICAST_VIF:
1062 		case IP_MULTICAST_TTL:
1063 		case IP_MULTICAST_LOOP:
1064 		case IP_ADD_MEMBERSHIP:
1065 		case IP_DROP_MEMBERSHIP:
1066 		case IP_ADD_SOURCE_MEMBERSHIP:
1067 		case IP_DROP_SOURCE_MEMBERSHIP:
1068 		case IP_BLOCK_SOURCE:
1069 		case IP_UNBLOCK_SOURCE:
1070 		case IP_MSFILTER:
1071 		case MCAST_JOIN_GROUP:
1072 		case MCAST_LEAVE_GROUP:
1073 		case MCAST_JOIN_SOURCE_GROUP:
1074 		case MCAST_LEAVE_SOURCE_GROUP:
1075 		case MCAST_BLOCK_SOURCE:
1076 		case MCAST_UNBLOCK_SOURCE:
1077 			error = inp_setmoptions(inp, sopt);
1078 			break;
1079 
1080 		case IP_PORTRANGE:
1081 			error = sooptcopyin(sopt, &optval, sizeof optval,
1082 					    sizeof optval);
1083 			if (error)
1084 				break;
1085 
1086 			INP_WLOCK(inp);
1087 			switch (optval) {
1088 			case IP_PORTRANGE_DEFAULT:
1089 				inp->inp_flags &= ~(INP_LOWPORT);
1090 				inp->inp_flags &= ~(INP_HIGHPORT);
1091 				break;
1092 
1093 			case IP_PORTRANGE_HIGH:
1094 				inp->inp_flags &= ~(INP_LOWPORT);
1095 				inp->inp_flags |= INP_HIGHPORT;
1096 				break;
1097 
1098 			case IP_PORTRANGE_LOW:
1099 				inp->inp_flags &= ~(INP_HIGHPORT);
1100 				inp->inp_flags |= INP_LOWPORT;
1101 				break;
1102 
1103 			default:
1104 				error = EINVAL;
1105 				break;
1106 			}
1107 			INP_WUNLOCK(inp);
1108 			break;
1109 
1110 #ifdef IPSEC
1111 		case IP_IPSEC_POLICY:
1112 		{
1113 			caddr_t req;
1114 			struct mbuf *m;
1115 
1116 			if ((error = soopt_getm(sopt, &m)) != 0) /* XXX */
1117 				break;
1118 			if ((error = soopt_mcopyin(sopt, m)) != 0) /* XXX */
1119 				break;
1120 			req = mtod(m, caddr_t);
1121 			error = ipsec_set_policy(inp, sopt->sopt_name, req,
1122 			    m->m_len, (sopt->sopt_td != NULL) ?
1123 			    sopt->sopt_td->td_ucred : NULL);
1124 			m_freem(m);
1125 			break;
1126 		}
1127 #endif /* IPSEC */
1128 
1129 		default:
1130 			error = ENOPROTOOPT;
1131 			break;
1132 		}
1133 		break;
1134 
1135 	case SOPT_GET:
1136 		switch (sopt->sopt_name) {
1137 		case IP_OPTIONS:
1138 		case IP_RETOPTS:
1139 			if (inp->inp_options)
1140 				error = sooptcopyout(sopt,
1141 						     mtod(inp->inp_options,
1142 							  char *),
1143 						     inp->inp_options->m_len);
1144 			else
1145 				sopt->sopt_valsize = 0;
1146 			break;
1147 
1148 		case IP_TOS:
1149 		case IP_TTL:
1150 		case IP_MINTTL:
1151 		case IP_RECVOPTS:
1152 		case IP_RECVRETOPTS:
1153 		case IP_RECVDSTADDR:
1154 		case IP_RECVTTL:
1155 		case IP_RECVIF:
1156 		case IP_PORTRANGE:
1157 		case IP_FAITH:
1158 		case IP_ONESBCAST:
1159 		case IP_DONTFRAG:
1160 		case IP_BINDANY:
1161 		case IP_RECVTOS:
1162 			switch (sopt->sopt_name) {
1163 
1164 			case IP_TOS:
1165 				optval = inp->inp_ip_tos;
1166 				break;
1167 
1168 			case IP_TTL:
1169 				optval = inp->inp_ip_ttl;
1170 				break;
1171 
1172 			case IP_MINTTL:
1173 				optval = inp->inp_ip_minttl;
1174 				break;
1175 
1176 #define	OPTBIT(bit)	(inp->inp_flags & bit ? 1 : 0)
1177 
1178 			case IP_RECVOPTS:
1179 				optval = OPTBIT(INP_RECVOPTS);
1180 				break;
1181 
1182 			case IP_RECVRETOPTS:
1183 				optval = OPTBIT(INP_RECVRETOPTS);
1184 				break;
1185 
1186 			case IP_RECVDSTADDR:
1187 				optval = OPTBIT(INP_RECVDSTADDR);
1188 				break;
1189 
1190 			case IP_RECVTTL:
1191 				optval = OPTBIT(INP_RECVTTL);
1192 				break;
1193 
1194 			case IP_RECVIF:
1195 				optval = OPTBIT(INP_RECVIF);
1196 				break;
1197 
1198 			case IP_PORTRANGE:
1199 				if (inp->inp_flags & INP_HIGHPORT)
1200 					optval = IP_PORTRANGE_HIGH;
1201 				else if (inp->inp_flags & INP_LOWPORT)
1202 					optval = IP_PORTRANGE_LOW;
1203 				else
1204 					optval = 0;
1205 				break;
1206 
1207 			case IP_FAITH:
1208 				optval = OPTBIT(INP_FAITH);
1209 				break;
1210 
1211 			case IP_ONESBCAST:
1212 				optval = OPTBIT(INP_ONESBCAST);
1213 				break;
1214 			case IP_DONTFRAG:
1215 				optval = OPTBIT(INP_DONTFRAG);
1216 				break;
1217 			case IP_BINDANY:
1218 				optval = OPTBIT(INP_BINDANY);
1219 				break;
1220 			case IP_RECVTOS:
1221 				optval = OPTBIT(INP_RECVTOS);
1222 				break;
1223 			}
1224 			error = sooptcopyout(sopt, &optval, sizeof optval);
1225 			break;
1226 
1227 		/*
1228 		 * Multicast socket options are processed by the in_mcast
1229 		 * module.
1230 		 */
1231 		case IP_MULTICAST_IF:
1232 		case IP_MULTICAST_VIF:
1233 		case IP_MULTICAST_TTL:
1234 		case IP_MULTICAST_LOOP:
1235 		case IP_MSFILTER:
1236 			error = inp_getmoptions(inp, sopt);
1237 			break;
1238 
1239 #ifdef IPSEC
1240 		case IP_IPSEC_POLICY:
1241 		{
1242 			struct mbuf *m = NULL;
1243 			caddr_t req = NULL;
1244 			size_t len = 0;
1245 
1246 			if (m != 0) {
1247 				req = mtod(m, caddr_t);
1248 				len = m->m_len;
1249 			}
1250 			error = ipsec_get_policy(sotoinpcb(so), req, len, &m);
1251 			if (error == 0)
1252 				error = soopt_mcopyout(sopt, m); /* XXX */
1253 			if (error == 0)
1254 				m_freem(m);
1255 			break;
1256 		}
1257 #endif /* IPSEC */
1258 
1259 		default:
1260 			error = ENOPROTOOPT;
1261 			break;
1262 		}
1263 		break;
1264 	}
1265 	return (error);
1266 }
1267 
1268 /*
1269  * Routine called from ip_output() to loop back a copy of an IP multicast
1270  * packet to the input queue of a specified interface.  Note that this
1271  * calls the output routine of the loopback "driver", but with an interface
1272  * pointer that might NOT be a loopback interface -- evil, but easier than
1273  * replicating that code here.
1274  */
1275 static void
1276 ip_mloopback(struct ifnet *ifp, struct mbuf *m, struct sockaddr_in *dst,
1277     int hlen)
1278 {
1279 	register struct ip *ip;
1280 	struct mbuf *copym;
1281 
1282 	/*
1283 	 * Make a deep copy of the packet because we're going to
1284 	 * modify the pack in order to generate checksums.
1285 	 */
1286 	copym = m_dup(m, M_NOWAIT);
1287 	if (copym != NULL && (copym->m_flags & M_EXT || copym->m_len < hlen))
1288 		copym = m_pullup(copym, hlen);
1289 	if (copym != NULL) {
1290 		/* If needed, compute the checksum and mark it as valid. */
1291 		if (copym->m_pkthdr.csum_flags & CSUM_DELAY_DATA) {
1292 			in_delayed_cksum(copym);
1293 			copym->m_pkthdr.csum_flags &= ~CSUM_DELAY_DATA;
1294 			copym->m_pkthdr.csum_flags |=
1295 			    CSUM_DATA_VALID | CSUM_PSEUDO_HDR;
1296 			copym->m_pkthdr.csum_data = 0xffff;
1297 		}
1298 		/*
1299 		 * We don't bother to fragment if the IP length is greater
1300 		 * than the interface's MTU.  Can this possibly matter?
1301 		 */
1302 		ip = mtod(copym, struct ip *);
1303 		ip->ip_sum = 0;
1304 		ip->ip_sum = in_cksum(copym, hlen);
1305 #if 1 /* XXX */
1306 		if (dst->sin_family != AF_INET) {
1307 			printf("ip_mloopback: bad address family %d\n",
1308 						dst->sin_family);
1309 			dst->sin_family = AF_INET;
1310 		}
1311 #endif
1312 		if_simloop(ifp, copym, dst->sin_family, 0);
1313 	}
1314 }
1315