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