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