xref: /freebsd/sys/netinet/ip_output.c (revision 32a95656b51ebefcdf3e0b02c110825f59abd26f)
1 /*-
2  * SPDX-License-Identifier: BSD-3-Clause
3  *
4  * Copyright (c) 1982, 1986, 1988, 1990, 1993
5  *	The Regents of the University of California.  All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  * 3. Neither the name of the University nor the names of its contributors
16  *    may be used to endorse or promote products derived from this software
17  *    without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29  * SUCH DAMAGE.
30  *
31  *	@(#)ip_output.c	8.3 (Berkeley) 1/21/94
32  */
33 
34 #include <sys/cdefs.h>
35 __FBSDID("$FreeBSD$");
36 
37 #include "opt_inet.h"
38 #include "opt_ipsec.h"
39 #include "opt_kern_tls.h"
40 #include "opt_mbuf_stress_test.h"
41 #include "opt_ratelimit.h"
42 #include "opt_route.h"
43 #include "opt_rss.h"
44 #include "opt_sctp.h"
45 
46 #include <sys/param.h>
47 #include <sys/systm.h>
48 #include <sys/kernel.h>
49 #include <sys/ktls.h>
50 #include <sys/lock.h>
51 #include <sys/malloc.h>
52 #include <sys/mbuf.h>
53 #include <sys/priv.h>
54 #include <sys/proc.h>
55 #include <sys/protosw.h>
56 #include <sys/sdt.h>
57 #include <sys/socket.h>
58 #include <sys/socketvar.h>
59 #include <sys/sysctl.h>
60 #include <sys/ucred.h>
61 
62 #include <net/if.h>
63 #include <net/if_var.h>
64 #include <net/if_vlan_var.h>
65 #include <net/if_llatbl.h>
66 #include <net/ethernet.h>
67 #include <net/netisr.h>
68 #include <net/pfil.h>
69 #include <net/route.h>
70 #include <net/route/nhop.h>
71 #include <net/rss_config.h>
72 #include <net/vnet.h>
73 
74 #include <netinet/in.h>
75 #include <netinet/in_fib.h>
76 #include <netinet/in_kdtrace.h>
77 #include <netinet/in_systm.h>
78 #include <netinet/ip.h>
79 #include <netinet/in_fib.h>
80 #include <netinet/in_pcb.h>
81 #include <netinet/in_rss.h>
82 #include <netinet/in_var.h>
83 #include <netinet/ip_var.h>
84 #include <netinet/ip_options.h>
85 #include <netinet/ip_mroute.h>
86 
87 #include <netinet/udp.h>
88 #include <netinet/udp_var.h>
89 
90 #if defined(SCTP) || defined(SCTP_SUPPORT)
91 #include <netinet/sctp.h>
92 #include <netinet/sctp_crc32.h>
93 #endif
94 
95 #include <netipsec/ipsec_support.h>
96 
97 #include <machine/in_cksum.h>
98 
99 #include <security/mac/mac_framework.h>
100 
101 #ifdef MBUF_STRESS_TEST
102 static int mbuf_frag_size = 0;
103 SYSCTL_INT(_net_inet_ip, OID_AUTO, mbuf_frag_size, CTLFLAG_RW,
104 	&mbuf_frag_size, 0, "Fragment outgoing mbufs to this size");
105 #endif
106 
107 static void	ip_mloopback(struct ifnet *, const struct mbuf *, int);
108 
109 extern int in_mcast_loop;
110 extern	struct protosw inetsw[];
111 
112 static inline int
113 ip_output_pfil(struct mbuf **mp, struct ifnet *ifp, int flags,
114     struct inpcb *inp, struct sockaddr_in *dst, int *fibnum, int *error)
115 {
116 	struct m_tag *fwd_tag = NULL;
117 	struct mbuf *m;
118 	struct in_addr odst;
119 	struct ip *ip;
120 	int pflags = PFIL_OUT;
121 
122 	if (flags & IP_FORWARDING)
123 		pflags |= PFIL_FWD;
124 
125 	m = *mp;
126 	ip = mtod(m, struct ip *);
127 
128 	/* Run through list of hooks for output packets. */
129 	odst.s_addr = ip->ip_dst.s_addr;
130 	switch (pfil_run_hooks(V_inet_pfil_head, mp, ifp, pflags, inp)) {
131 	case PFIL_DROPPED:
132 		*error = EACCES;
133 		/* FALLTHROUGH */
134 	case PFIL_CONSUMED:
135 		return 1; /* Finished */
136 	case PFIL_PASS:
137 		*error = 0;
138 	}
139 	m = *mp;
140 	ip = mtod(m, struct ip *);
141 
142 	/* See if destination IP address was changed by packet filter. */
143 	if (odst.s_addr != ip->ip_dst.s_addr) {
144 		m->m_flags |= M_SKIP_FIREWALL;
145 		/* If destination is now ourself drop to ip_input(). */
146 		if (in_localip(ip->ip_dst)) {
147 			m->m_flags |= M_FASTFWD_OURS;
148 			if (m->m_pkthdr.rcvif == NULL)
149 				m->m_pkthdr.rcvif = V_loif;
150 			if (m->m_pkthdr.csum_flags & CSUM_DELAY_DATA) {
151 				m->m_pkthdr.csum_flags |=
152 					CSUM_DATA_VALID | CSUM_PSEUDO_HDR;
153 				m->m_pkthdr.csum_data = 0xffff;
154 			}
155 			m->m_pkthdr.csum_flags |=
156 				CSUM_IP_CHECKED | CSUM_IP_VALID;
157 #if defined(SCTP) || defined(SCTP_SUPPORT)
158 			if (m->m_pkthdr.csum_flags & CSUM_SCTP)
159 				m->m_pkthdr.csum_flags |= CSUM_SCTP_VALID;
160 #endif
161 			*error = netisr_queue(NETISR_IP, m);
162 			return 1; /* Finished */
163 		}
164 
165 		bzero(dst, sizeof(*dst));
166 		dst->sin_family = AF_INET;
167 		dst->sin_len = sizeof(*dst);
168 		dst->sin_addr = ip->ip_dst;
169 
170 		return -1; /* Reloop */
171 	}
172 	/* See if fib was changed by packet filter. */
173 	if ((*fibnum) != M_GETFIB(m)) {
174 		m->m_flags |= M_SKIP_FIREWALL;
175 		*fibnum = M_GETFIB(m);
176 		return -1; /* Reloop for FIB change */
177 	}
178 
179 	/* See if local, if yes, send it to netisr with IP_FASTFWD_OURS. */
180 	if (m->m_flags & M_FASTFWD_OURS) {
181 		if (m->m_pkthdr.rcvif == NULL)
182 			m->m_pkthdr.rcvif = V_loif;
183 		if (m->m_pkthdr.csum_flags & CSUM_DELAY_DATA) {
184 			m->m_pkthdr.csum_flags |=
185 				CSUM_DATA_VALID | CSUM_PSEUDO_HDR;
186 			m->m_pkthdr.csum_data = 0xffff;
187 		}
188 #if defined(SCTP) || defined(SCTP_SUPPORT)
189 		if (m->m_pkthdr.csum_flags & CSUM_SCTP)
190 			m->m_pkthdr.csum_flags |= CSUM_SCTP_VALID;
191 #endif
192 		m->m_pkthdr.csum_flags |=
193 			CSUM_IP_CHECKED | CSUM_IP_VALID;
194 
195 		*error = netisr_queue(NETISR_IP, m);
196 		return 1; /* Finished */
197 	}
198 	/* Or forward to some other address? */
199 	if ((m->m_flags & M_IP_NEXTHOP) &&
200 	    ((fwd_tag = m_tag_find(m, PACKET_TAG_IPFORWARD, NULL)) != NULL)) {
201 		bcopy((fwd_tag+1), dst, sizeof(struct sockaddr_in));
202 		m->m_flags |= M_SKIP_FIREWALL;
203 		m->m_flags &= ~M_IP_NEXTHOP;
204 		m_tag_delete(m, fwd_tag);
205 
206 		return -1; /* Reloop for CHANGE of dst */
207 	}
208 
209 	return 0;
210 }
211 
212 static int
213 ip_output_send(struct inpcb *inp, struct ifnet *ifp, struct mbuf *m,
214     const struct sockaddr *gw, struct route *ro, bool stamp_tag)
215 {
216 #ifdef KERN_TLS
217 	struct ktls_session *tls = NULL;
218 #endif
219 	struct m_snd_tag *mst;
220 	int error;
221 
222 	MPASS((m->m_pkthdr.csum_flags & CSUM_SND_TAG) == 0);
223 	mst = NULL;
224 
225 #ifdef KERN_TLS
226 	/*
227 	 * If this is an unencrypted TLS record, save a reference to
228 	 * the record.  This local reference is used to call
229 	 * ktls_output_eagain after the mbuf has been freed (thus
230 	 * dropping the mbuf's reference) in if_output.
231 	 */
232 	if (m->m_next != NULL && mbuf_has_tls_session(m->m_next)) {
233 		tls = ktls_hold(m->m_next->m_epg_tls);
234 		mst = tls->snd_tag;
235 
236 		/*
237 		 * If a TLS session doesn't have a valid tag, it must
238 		 * have had an earlier ifp mismatch, so drop this
239 		 * packet.
240 		 */
241 		if (mst == NULL) {
242 			error = EAGAIN;
243 			goto done;
244 		}
245 		/*
246 		 * Always stamp tags that include NIC ktls.
247 		 */
248 		stamp_tag = true;
249 	}
250 #endif
251 #ifdef RATELIMIT
252 	if (inp != NULL && mst == NULL) {
253 		if ((inp->inp_flags2 & INP_RATE_LIMIT_CHANGED) != 0 ||
254 		    (inp->inp_snd_tag != NULL &&
255 		    inp->inp_snd_tag->ifp != ifp))
256 			in_pcboutput_txrtlmt(inp, ifp, m);
257 
258 		if (inp->inp_snd_tag != NULL)
259 			mst = inp->inp_snd_tag;
260 	}
261 #endif
262 	if (stamp_tag && mst != NULL) {
263 		KASSERT(m->m_pkthdr.rcvif == NULL,
264 		    ("trying to add a send tag to a forwarded packet"));
265 		if (mst->ifp != ifp) {
266 			error = EAGAIN;
267 			goto done;
268 		}
269 
270 		/* stamp send tag on mbuf */
271 		m->m_pkthdr.snd_tag = m_snd_tag_ref(mst);
272 		m->m_pkthdr.csum_flags |= CSUM_SND_TAG;
273 	}
274 
275 	error = (*ifp->if_output)(ifp, m, gw, ro);
276 
277 done:
278 	/* Check for route change invalidating send tags. */
279 #ifdef KERN_TLS
280 	if (tls != NULL) {
281 		if (error == EAGAIN)
282 			error = ktls_output_eagain(inp, tls);
283 		ktls_free(tls);
284 	}
285 #endif
286 #ifdef RATELIMIT
287 	if (error == EAGAIN)
288 		in_pcboutput_eagain(inp);
289 #endif
290 	return (error);
291 }
292 
293 /* rte<>ro_flags translation */
294 static inline void
295 rt_update_ro_flags(struct route *ro, const struct nhop_object *nh)
296 {
297 	int nh_flags = nh->nh_flags;
298 
299 	ro->ro_flags &= ~ (RT_REJECT|RT_BLACKHOLE|RT_HAS_GW);
300 
301 	ro->ro_flags |= (nh_flags & NHF_REJECT) ? RT_REJECT : 0;
302 	ro->ro_flags |= (nh_flags & NHF_BLACKHOLE) ? RT_BLACKHOLE : 0;
303 	ro->ro_flags |= (nh_flags & NHF_GATEWAY) ? RT_HAS_GW : 0;
304 }
305 
306 /*
307  * IP output.  The packet in mbuf chain m contains a skeletal IP
308  * header (with len, off, ttl, proto, tos, src, dst).
309  * The mbuf chain containing the packet will be freed.
310  * The mbuf opt, if present, will not be freed.
311  * If route ro is present and has ro_rt initialized, route lookup would be
312  * skipped and ro->ro_rt would be used. If ro is present but ro->ro_rt is NULL,
313  * then result of route lookup is stored in ro->ro_rt.
314  *
315  * In the IP forwarding case, the packet will arrive with options already
316  * inserted, so must have a NULL opt pointer.
317  */
318 int
319 ip_output(struct mbuf *m, struct mbuf *opt, struct route *ro, int flags,
320     struct ip_moptions *imo, struct inpcb *inp)
321 {
322 	MROUTER_RLOCK_TRACKER;
323 	struct ip *ip;
324 	struct ifnet *ifp = NULL;	/* keep compiler happy */
325 	struct mbuf *m0;
326 	int hlen = sizeof (struct ip);
327 	int mtu = 0;
328 	int error = 0;
329 	int vlan_pcp = -1;
330 	struct sockaddr_in *dst;
331 	const struct sockaddr *gw;
332 	struct in_ifaddr *ia = NULL;
333 	struct in_addr src;
334 	int isbroadcast;
335 	uint16_t ip_len, ip_off;
336 	struct route iproute;
337 	uint32_t fibnum;
338 #if defined(IPSEC) || defined(IPSEC_SUPPORT)
339 	int no_route_but_check_spd = 0;
340 #endif
341 
342 	M_ASSERTPKTHDR(m);
343 	NET_EPOCH_ASSERT();
344 
345 	if (inp != NULL) {
346 		INP_LOCK_ASSERT(inp);
347 		M_SETFIB(m, inp->inp_inc.inc_fibnum);
348 		if ((flags & IP_NODEFAULTFLOWID) == 0) {
349 			m->m_pkthdr.flowid = inp->inp_flowid;
350 			M_HASHTYPE_SET(m, inp->inp_flowtype);
351 		}
352 		if ((inp->inp_flags2 & INP_2PCP_SET) != 0)
353 			vlan_pcp = (inp->inp_flags2 & INP_2PCP_MASK) >>
354 			    INP_2PCP_SHIFT;
355 #ifdef NUMA
356 		m->m_pkthdr.numa_domain = inp->inp_numa_domain;
357 #endif
358 	}
359 
360 	if (opt) {
361 		int len = 0;
362 		m = ip_insertoptions(m, opt, &len);
363 		if (len != 0)
364 			hlen = len; /* ip->ip_hl is updated above */
365 	}
366 	ip = mtod(m, struct ip *);
367 	ip_len = ntohs(ip->ip_len);
368 	ip_off = ntohs(ip->ip_off);
369 
370 	if ((flags & (IP_FORWARDING|IP_RAWOUTPUT)) == 0) {
371 		ip->ip_v = IPVERSION;
372 		ip->ip_hl = hlen >> 2;
373 		ip_fillid(ip);
374 	} else {
375 		/* Header already set, fetch hlen from there */
376 		hlen = ip->ip_hl << 2;
377 	}
378 	if ((flags & IP_FORWARDING) == 0)
379 		IPSTAT_INC(ips_localout);
380 
381 	/*
382 	 * dst/gw handling:
383 	 *
384 	 * gw is readonly but can point either to dst OR rt_gateway,
385 	 * therefore we need restore gw if we're redoing lookup.
386 	 */
387 	fibnum = (inp != NULL) ? inp->inp_inc.inc_fibnum : M_GETFIB(m);
388 	if (ro == NULL) {
389 		ro = &iproute;
390 		bzero(ro, sizeof (*ro));
391 	}
392 	dst = (struct sockaddr_in *)&ro->ro_dst;
393 	if (ro->ro_nh == NULL) {
394 		dst->sin_family = AF_INET;
395 		dst->sin_len = sizeof(*dst);
396 		dst->sin_addr = ip->ip_dst;
397 	}
398 	gw = (const struct sockaddr *)dst;
399 again:
400 	/*
401 	 * Validate route against routing table additions;
402 	 * a better/more specific route might have been added.
403 	 */
404 	if (inp != NULL && ro->ro_nh != NULL)
405 		NH_VALIDATE(ro, &inp->inp_rt_cookie, fibnum);
406 	/*
407 	 * If there is a cached route,
408 	 * check that it is to the same destination
409 	 * and is still up.  If not, free it and try again.
410 	 * The address family should also be checked in case of sharing the
411 	 * cache with IPv6.
412 	 * Also check whether routing cache needs invalidation.
413 	 */
414 	if (ro->ro_nh != NULL &&
415 	    ((!NH_IS_VALID(ro->ro_nh)) || dst->sin_family != AF_INET ||
416 	    dst->sin_addr.s_addr != ip->ip_dst.s_addr))
417 		RO_INVALIDATE_CACHE(ro);
418 	ia = NULL;
419 	/*
420 	 * If routing to interface only, short circuit routing lookup.
421 	 * The use of an all-ones broadcast address implies this; an
422 	 * interface is specified by the broadcast address of an interface,
423 	 * or the destination address of a ptp interface.
424 	 */
425 	if (flags & IP_SENDONES) {
426 		if ((ia = ifatoia(ifa_ifwithbroadaddr(sintosa(dst),
427 						      M_GETFIB(m)))) == NULL &&
428 		    (ia = ifatoia(ifa_ifwithdstaddr(sintosa(dst),
429 						    M_GETFIB(m)))) == NULL) {
430 			IPSTAT_INC(ips_noroute);
431 			error = ENETUNREACH;
432 			goto bad;
433 		}
434 		ip->ip_dst.s_addr = INADDR_BROADCAST;
435 		dst->sin_addr = ip->ip_dst;
436 		ifp = ia->ia_ifp;
437 		mtu = ifp->if_mtu;
438 		ip->ip_ttl = 1;
439 		isbroadcast = 1;
440 		src = IA_SIN(ia)->sin_addr;
441 	} else if (flags & IP_ROUTETOIF) {
442 		if ((ia = ifatoia(ifa_ifwithdstaddr(sintosa(dst),
443 						    M_GETFIB(m)))) == NULL &&
444 		    (ia = ifatoia(ifa_ifwithnet(sintosa(dst), 0,
445 						M_GETFIB(m)))) == NULL) {
446 			IPSTAT_INC(ips_noroute);
447 			error = ENETUNREACH;
448 			goto bad;
449 		}
450 		ifp = ia->ia_ifp;
451 		mtu = ifp->if_mtu;
452 		ip->ip_ttl = 1;
453 		isbroadcast = ifp->if_flags & IFF_BROADCAST ?
454 		    in_ifaddr_broadcast(dst->sin_addr, ia) : 0;
455 		src = IA_SIN(ia)->sin_addr;
456 	} else if (IN_MULTICAST(ntohl(ip->ip_dst.s_addr)) &&
457 	    imo != NULL && imo->imo_multicast_ifp != NULL) {
458 		/*
459 		 * Bypass the normal routing lookup for multicast
460 		 * packets if the interface is specified.
461 		 */
462 		ifp = imo->imo_multicast_ifp;
463 		mtu = ifp->if_mtu;
464 		IFP_TO_IA(ifp, ia);
465 		isbroadcast = 0;	/* fool gcc */
466 		/* Interface may have no addresses. */
467 		if (ia != NULL)
468 			src = IA_SIN(ia)->sin_addr;
469 		else
470 			src.s_addr = INADDR_ANY;
471 	} else if (ro != &iproute) {
472 		if (ro->ro_nh == NULL) {
473 			/*
474 			 * We want to do any cloning requested by the link
475 			 * layer, as this is probably required in all cases
476 			 * for correct operation (as it is for ARP).
477 			 */
478 			uint32_t flowid;
479 			flowid = m->m_pkthdr.flowid;
480 			ro->ro_nh = fib4_lookup(fibnum, dst->sin_addr, 0,
481 			    NHR_REF, flowid);
482 
483 			if (ro->ro_nh == NULL || (!NH_IS_VALID(ro->ro_nh))) {
484 #if defined(IPSEC) || defined(IPSEC_SUPPORT)
485 				/*
486 				 * There is no route for this packet, but it is
487 				 * possible that a matching SPD entry exists.
488 				 */
489 				no_route_but_check_spd = 1;
490 				goto sendit;
491 #endif
492 				IPSTAT_INC(ips_noroute);
493 				error = EHOSTUNREACH;
494 				goto bad;
495 			}
496 		}
497 		struct nhop_object *nh = ro->ro_nh;
498 
499 		ia = ifatoia(nh->nh_ifa);
500 		ifp = nh->nh_ifp;
501 		counter_u64_add(nh->nh_pksent, 1);
502 		rt_update_ro_flags(ro, nh);
503 		if (nh->nh_flags & NHF_GATEWAY)
504 			gw = &nh->gw_sa;
505 		if (nh->nh_flags & NHF_HOST)
506 			isbroadcast = (nh->nh_flags & NHF_BROADCAST);
507 		else if ((ifp->if_flags & IFF_BROADCAST) && (gw->sa_family == AF_INET))
508 			isbroadcast = in_ifaddr_broadcast(((const struct sockaddr_in *)gw)->sin_addr, ia);
509 		else
510 			isbroadcast = 0;
511 		mtu = nh->nh_mtu;
512 		src = IA_SIN(ia)->sin_addr;
513 	} else {
514 		struct nhop_object *nh;
515 
516 		nh = fib4_lookup(M_GETFIB(m), ip->ip_dst, 0, NHR_NONE,
517 		    m->m_pkthdr.flowid);
518 		if (nh == NULL) {
519 #if defined(IPSEC) || defined(IPSEC_SUPPORT)
520 			/*
521 			 * There is no route for this packet, but it is
522 			 * possible that a matching SPD entry exists.
523 			 */
524 			no_route_but_check_spd = 1;
525 			goto sendit;
526 #endif
527 			IPSTAT_INC(ips_noroute);
528 			error = EHOSTUNREACH;
529 			goto bad;
530 		}
531 		ifp = nh->nh_ifp;
532 		mtu = nh->nh_mtu;
533 		rt_update_ro_flags(ro, nh);
534 		if (nh->nh_flags & NHF_GATEWAY)
535 			gw = &nh->gw_sa;
536 		ia = ifatoia(nh->nh_ifa);
537 		src = IA_SIN(ia)->sin_addr;
538 		isbroadcast = (((nh->nh_flags & (NHF_HOST | NHF_BROADCAST)) ==
539 		    (NHF_HOST | NHF_BROADCAST)) ||
540 		    ((ifp->if_flags & IFF_BROADCAST) &&
541 		    (gw->sa_family == AF_INET) &&
542 		    in_ifaddr_broadcast(((const struct sockaddr_in *)gw)->sin_addr, ia)));
543 	}
544 
545 	/* Catch a possible divide by zero later. */
546 	KASSERT(mtu > 0, ("%s: mtu %d <= 0, ro=%p (nh_flags=0x%08x) ifp=%p",
547 	    __func__, mtu, ro,
548 	    (ro != NULL && ro->ro_nh != NULL) ? ro->ro_nh->nh_flags : 0, ifp));
549 
550 	if (IN_MULTICAST(ntohl(ip->ip_dst.s_addr))) {
551 		m->m_flags |= M_MCAST;
552 		/*
553 		 * IP destination address is multicast.  Make sure "gw"
554 		 * still points to the address in "ro".  (It may have been
555 		 * changed to point to a gateway address, above.)
556 		 */
557 		gw = (const struct sockaddr *)dst;
558 		/*
559 		 * See if the caller provided any multicast options
560 		 */
561 		if (imo != NULL) {
562 			ip->ip_ttl = imo->imo_multicast_ttl;
563 			if (imo->imo_multicast_vif != -1)
564 				ip->ip_src.s_addr =
565 				    ip_mcast_src ?
566 				    ip_mcast_src(imo->imo_multicast_vif) :
567 				    INADDR_ANY;
568 		} else
569 			ip->ip_ttl = IP_DEFAULT_MULTICAST_TTL;
570 		/*
571 		 * Confirm that the outgoing interface supports multicast.
572 		 */
573 		if ((imo == NULL) || (imo->imo_multicast_vif == -1)) {
574 			if ((ifp->if_flags & IFF_MULTICAST) == 0) {
575 				IPSTAT_INC(ips_noroute);
576 				error = ENETUNREACH;
577 				goto bad;
578 			}
579 		}
580 		/*
581 		 * If source address not specified yet, use address
582 		 * of outgoing interface.
583 		 */
584 		if (ip->ip_src.s_addr == INADDR_ANY)
585 			ip->ip_src = src;
586 
587 		if ((imo == NULL && in_mcast_loop) ||
588 		    (imo && imo->imo_multicast_loop)) {
589 			/*
590 			 * Loop back multicast datagram if not expressly
591 			 * forbidden to do so, even if we are not a member
592 			 * of the group; ip_input() will filter it later,
593 			 * thus deferring a hash lookup and mutex acquisition
594 			 * at the expense of a cheap copy using m_copym().
595 			 */
596 			ip_mloopback(ifp, m, hlen);
597 		} else {
598 			/*
599 			 * If we are acting as a multicast router, perform
600 			 * multicast forwarding as if the packet had just
601 			 * arrived on the interface to which we are about
602 			 * to send.  The multicast forwarding function
603 			 * recursively calls this function, using the
604 			 * IP_FORWARDING flag to prevent infinite recursion.
605 			 *
606 			 * Multicasts that are looped back by ip_mloopback(),
607 			 * above, will be forwarded by the ip_input() routine,
608 			 * if necessary.
609 			 */
610 			MROUTER_RLOCK();
611 			if (V_ip_mrouter && (flags & IP_FORWARDING) == 0) {
612 				/*
613 				 * If rsvp daemon is not running, do not
614 				 * set ip_moptions. This ensures that the packet
615 				 * is multicast and not just sent down one link
616 				 * as prescribed by rsvpd.
617 				 */
618 				if (!V_rsvp_on)
619 					imo = NULL;
620 				if (ip_mforward &&
621 				    ip_mforward(ip, ifp, m, imo) != 0) {
622 					MROUTER_RUNLOCK();
623 					m_freem(m);
624 					goto done;
625 				}
626 			}
627 			MROUTER_RUNLOCK();
628 		}
629 
630 		/*
631 		 * Multicasts with a time-to-live of zero may be looped-
632 		 * back, above, but must not be transmitted on a network.
633 		 * Also, multicasts addressed to the loopback interface
634 		 * are not sent -- the above call to ip_mloopback() will
635 		 * loop back a copy. ip_input() will drop the copy if
636 		 * this host does not belong to the destination group on
637 		 * the loopback interface.
638 		 */
639 		if (ip->ip_ttl == 0 || ifp->if_flags & IFF_LOOPBACK) {
640 			m_freem(m);
641 			goto done;
642 		}
643 
644 		goto sendit;
645 	}
646 
647 	/*
648 	 * If the source address is not specified yet, use the address
649 	 * of the outoing interface.
650 	 */
651 	if (ip->ip_src.s_addr == INADDR_ANY)
652 		ip->ip_src = src;
653 
654 	/*
655 	 * Look for broadcast address and
656 	 * verify user is allowed to send
657 	 * such a packet.
658 	 */
659 	if (isbroadcast) {
660 		if ((ifp->if_flags & IFF_BROADCAST) == 0) {
661 			error = EADDRNOTAVAIL;
662 			goto bad;
663 		}
664 		if ((flags & IP_ALLOWBROADCAST) == 0) {
665 			error = EACCES;
666 			goto bad;
667 		}
668 		/* don't allow broadcast messages to be fragmented */
669 		if (ip_len > mtu) {
670 			error = EMSGSIZE;
671 			goto bad;
672 		}
673 		m->m_flags |= M_BCAST;
674 	} else {
675 		m->m_flags &= ~M_BCAST;
676 	}
677 
678 sendit:
679 #if defined(IPSEC) || defined(IPSEC_SUPPORT)
680 	if (IPSEC_ENABLED(ipv4)) {
681 		if ((error = IPSEC_OUTPUT(ipv4, m, inp)) != 0) {
682 			if (error == EINPROGRESS)
683 				error = 0;
684 			goto done;
685 		}
686 	}
687 	/*
688 	 * Check if there was a route for this packet; return error if not.
689 	 */
690 	if (no_route_but_check_spd) {
691 		IPSTAT_INC(ips_noroute);
692 		error = EHOSTUNREACH;
693 		goto bad;
694 	}
695 	/* Update variables that are affected by ipsec4_output(). */
696 	ip = mtod(m, struct ip *);
697 	hlen = ip->ip_hl << 2;
698 #endif /* IPSEC */
699 
700 	/* Jump over all PFIL processing if hooks are not active. */
701 	if (PFIL_HOOKED_OUT(V_inet_pfil_head)) {
702 		switch (ip_output_pfil(&m, ifp, flags, inp, dst, &fibnum,
703 		    &error)) {
704 		case 1: /* Finished */
705 			goto done;
706 
707 		case 0: /* Continue normally */
708 			ip = mtod(m, struct ip *);
709 			break;
710 
711 		case -1: /* Need to try again */
712 			/* Reset everything for a new round */
713 			if (ro != NULL) {
714 				RO_NHFREE(ro);
715 				ro->ro_prepend = NULL;
716 			}
717 			gw = (const struct sockaddr *)dst;
718 			ip = mtod(m, struct ip *);
719 			goto again;
720 		}
721 	}
722 
723 	if (vlan_pcp > -1)
724 		EVL_APPLY_PRI(m, vlan_pcp);
725 
726 	/* IN_LOOPBACK must not appear on the wire - RFC1122. */
727 	if (IN_LOOPBACK(ntohl(ip->ip_dst.s_addr)) ||
728 	    IN_LOOPBACK(ntohl(ip->ip_src.s_addr))) {
729 		if ((ifp->if_flags & IFF_LOOPBACK) == 0) {
730 			IPSTAT_INC(ips_badaddr);
731 			error = EADDRNOTAVAIL;
732 			goto bad;
733 		}
734 	}
735 
736 	/* Ensure the packet data is mapped if the interface requires it. */
737 	if ((ifp->if_capenable & IFCAP_MEXTPG) == 0) {
738 		m = mb_unmapped_to_ext(m);
739 		if (m == NULL) {
740 			IPSTAT_INC(ips_odropped);
741 			error = ENOBUFS;
742 			goto bad;
743 		}
744 	}
745 
746 	m->m_pkthdr.csum_flags |= CSUM_IP;
747 	if (m->m_pkthdr.csum_flags & CSUM_DELAY_DATA & ~ifp->if_hwassist) {
748 		in_delayed_cksum(m);
749 		m->m_pkthdr.csum_flags &= ~CSUM_DELAY_DATA;
750 	}
751 #if defined(SCTP) || defined(SCTP_SUPPORT)
752 	if (m->m_pkthdr.csum_flags & CSUM_SCTP & ~ifp->if_hwassist) {
753 		sctp_delayed_cksum(m, (uint32_t)(ip->ip_hl << 2));
754 		m->m_pkthdr.csum_flags &= ~CSUM_SCTP;
755 	}
756 #endif
757 
758 	/*
759 	 * If small enough for interface, or the interface will take
760 	 * care of the fragmentation for us, we can just send directly.
761 	 * Note that if_vxlan could have requested TSO even though the outer
762 	 * frame is UDP.  It is correct to not fragment such datagrams and
763 	 * instead just pass them on to the driver.
764 	 */
765 	if (ip_len <= mtu ||
766 	    (m->m_pkthdr.csum_flags & ifp->if_hwassist &
767 	    (CSUM_TSO | CSUM_INNER_TSO)) != 0) {
768 		ip->ip_sum = 0;
769 		if (m->m_pkthdr.csum_flags & CSUM_IP & ~ifp->if_hwassist) {
770 			ip->ip_sum = in_cksum(m, hlen);
771 			m->m_pkthdr.csum_flags &= ~CSUM_IP;
772 		}
773 
774 		/*
775 		 * Record statistics for this interface address.
776 		 * With CSUM_TSO the byte/packet count will be slightly
777 		 * incorrect because we count the IP+TCP headers only
778 		 * once instead of for every generated packet.
779 		 */
780 		if (!(flags & IP_FORWARDING) && ia) {
781 			if (m->m_pkthdr.csum_flags &
782 			    (CSUM_TSO | CSUM_INNER_TSO))
783 				counter_u64_add(ia->ia_ifa.ifa_opackets,
784 				    m->m_pkthdr.len / m->m_pkthdr.tso_segsz);
785 			else
786 				counter_u64_add(ia->ia_ifa.ifa_opackets, 1);
787 
788 			counter_u64_add(ia->ia_ifa.ifa_obytes, m->m_pkthdr.len);
789 		}
790 #ifdef MBUF_STRESS_TEST
791 		if (mbuf_frag_size && m->m_pkthdr.len > mbuf_frag_size)
792 			m = m_fragment(m, M_NOWAIT, mbuf_frag_size);
793 #endif
794 		/*
795 		 * Reset layer specific mbuf flags
796 		 * to avoid confusing lower layers.
797 		 */
798 		m_clrprotoflags(m);
799 		IP_PROBE(send, NULL, NULL, ip, ifp, ip, NULL);
800 		error = ip_output_send(inp, ifp, m, gw, ro,
801 		    (flags & IP_NO_SND_TAG_RL) ? false : true);
802 		goto done;
803 	}
804 
805 	/* Balk when DF bit is set or the interface didn't support TSO. */
806 	if ((ip_off & IP_DF) ||
807 	    (m->m_pkthdr.csum_flags & (CSUM_TSO | CSUM_INNER_TSO))) {
808 		error = EMSGSIZE;
809 		IPSTAT_INC(ips_cantfrag);
810 		goto bad;
811 	}
812 
813 	/*
814 	 * Too large for interface; fragment if possible. If successful,
815 	 * on return, m will point to a list of packets to be sent.
816 	 */
817 	error = ip_fragment(ip, &m, mtu, ifp->if_hwassist);
818 	if (error)
819 		goto bad;
820 	for (; m; m = m0) {
821 		m0 = m->m_nextpkt;
822 		m->m_nextpkt = 0;
823 		if (error == 0) {
824 			/* Record statistics for this interface address. */
825 			if (ia != NULL) {
826 				counter_u64_add(ia->ia_ifa.ifa_opackets, 1);
827 				counter_u64_add(ia->ia_ifa.ifa_obytes,
828 				    m->m_pkthdr.len);
829 			}
830 			/*
831 			 * Reset layer specific mbuf flags
832 			 * to avoid confusing upper layers.
833 			 */
834 			m_clrprotoflags(m);
835 
836 			IP_PROBE(send, NULL, NULL, mtod(m, struct ip *), ifp,
837 			    mtod(m, struct ip *), NULL);
838 			error = ip_output_send(inp, ifp, m, gw, ro, true);
839 		} else
840 			m_freem(m);
841 	}
842 
843 	if (error == 0)
844 		IPSTAT_INC(ips_fragmented);
845 
846 done:
847 	return (error);
848  bad:
849 	m_freem(m);
850 	goto done;
851 }
852 
853 /*
854  * Create a chain of fragments which fit the given mtu. m_frag points to the
855  * mbuf to be fragmented; on return it points to the chain with the fragments.
856  * Return 0 if no error. If error, m_frag may contain a partially built
857  * chain of fragments that should be freed by the caller.
858  *
859  * if_hwassist_flags is the hw offload capabilities (see if_data.ifi_hwassist)
860  */
861 int
862 ip_fragment(struct ip *ip, struct mbuf **m_frag, int mtu,
863     u_long if_hwassist_flags)
864 {
865 	int error = 0;
866 	int hlen = ip->ip_hl << 2;
867 	int len = (mtu - hlen) & ~7;	/* size of payload in each fragment */
868 	int off;
869 	struct mbuf *m0 = *m_frag;	/* the original packet		*/
870 	int firstlen;
871 	struct mbuf **mnext;
872 	int nfrags;
873 	uint16_t ip_len, ip_off;
874 
875 	ip_len = ntohs(ip->ip_len);
876 	ip_off = ntohs(ip->ip_off);
877 
878 	if (ip_off & IP_DF) {	/* Fragmentation not allowed */
879 		IPSTAT_INC(ips_cantfrag);
880 		return EMSGSIZE;
881 	}
882 
883 	/*
884 	 * Must be able to put at least 8 bytes per fragment.
885 	 */
886 	if (len < 8)
887 		return EMSGSIZE;
888 
889 	/*
890 	 * If the interface will not calculate checksums on
891 	 * fragmented packets, then do it here.
892 	 */
893 	if (m0->m_pkthdr.csum_flags & CSUM_DELAY_DATA) {
894 		in_delayed_cksum(m0);
895 		m0->m_pkthdr.csum_flags &= ~CSUM_DELAY_DATA;
896 	}
897 #if defined(SCTP) || defined(SCTP_SUPPORT)
898 	if (m0->m_pkthdr.csum_flags & CSUM_SCTP) {
899 		sctp_delayed_cksum(m0, hlen);
900 		m0->m_pkthdr.csum_flags &= ~CSUM_SCTP;
901 	}
902 #endif
903 	if (len > PAGE_SIZE) {
904 		/*
905 		 * Fragment large datagrams such that each segment
906 		 * contains a multiple of PAGE_SIZE amount of data,
907 		 * plus headers. This enables a receiver to perform
908 		 * page-flipping zero-copy optimizations.
909 		 *
910 		 * XXX When does this help given that sender and receiver
911 		 * could have different page sizes, and also mtu could
912 		 * be less than the receiver's page size ?
913 		 */
914 		int newlen;
915 
916 		off = MIN(mtu, m0->m_pkthdr.len);
917 
918 		/*
919 		 * firstlen (off - hlen) must be aligned on an
920 		 * 8-byte boundary
921 		 */
922 		if (off < hlen)
923 			goto smart_frag_failure;
924 		off = ((off - hlen) & ~7) + hlen;
925 		newlen = (~PAGE_MASK) & mtu;
926 		if ((newlen + sizeof (struct ip)) > mtu) {
927 			/* we failed, go back the default */
928 smart_frag_failure:
929 			newlen = len;
930 			off = hlen + len;
931 		}
932 		len = newlen;
933 
934 	} else {
935 		off = hlen + len;
936 	}
937 
938 	firstlen = off - hlen;
939 	mnext = &m0->m_nextpkt;		/* pointer to next packet */
940 
941 	/*
942 	 * Loop through length of segment after first fragment,
943 	 * make new header and copy data of each part and link onto chain.
944 	 * Here, m0 is the original packet, m is the fragment being created.
945 	 * The fragments are linked off the m_nextpkt of the original
946 	 * packet, which after processing serves as the first fragment.
947 	 */
948 	for (nfrags = 1; off < ip_len; off += len, nfrags++) {
949 		struct ip *mhip;	/* ip header on the fragment */
950 		struct mbuf *m;
951 		int mhlen = sizeof (struct ip);
952 
953 		m = m_gethdr(M_NOWAIT, MT_DATA);
954 		if (m == NULL) {
955 			error = ENOBUFS;
956 			IPSTAT_INC(ips_odropped);
957 			goto done;
958 		}
959 		/*
960 		 * Make sure the complete packet header gets copied
961 		 * from the originating mbuf to the newly created
962 		 * mbuf. This also ensures that existing firewall
963 		 * classification(s), VLAN tags and so on get copied
964 		 * to the resulting fragmented packet(s):
965 		 */
966 		if (m_dup_pkthdr(m, m0, M_NOWAIT) == 0) {
967 			m_free(m);
968 			error = ENOBUFS;
969 			IPSTAT_INC(ips_odropped);
970 			goto done;
971 		}
972 		/*
973 		 * In the first mbuf, leave room for the link header, then
974 		 * copy the original IP header including options. The payload
975 		 * goes into an additional mbuf chain returned by m_copym().
976 		 */
977 		m->m_data += max_linkhdr;
978 		mhip = mtod(m, struct ip *);
979 		*mhip = *ip;
980 		if (hlen > sizeof (struct ip)) {
981 			mhlen = ip_optcopy(ip, mhip) + sizeof (struct ip);
982 			mhip->ip_v = IPVERSION;
983 			mhip->ip_hl = mhlen >> 2;
984 		}
985 		m->m_len = mhlen;
986 		/* XXX do we need to add ip_off below ? */
987 		mhip->ip_off = ((off - hlen) >> 3) + ip_off;
988 		if (off + len >= ip_len)
989 			len = ip_len - off;
990 		else
991 			mhip->ip_off |= IP_MF;
992 		mhip->ip_len = htons((u_short)(len + mhlen));
993 		m->m_next = m_copym(m0, off, len, M_NOWAIT);
994 		if (m->m_next == NULL) {	/* copy failed */
995 			m_free(m);
996 			error = ENOBUFS;	/* ??? */
997 			IPSTAT_INC(ips_odropped);
998 			goto done;
999 		}
1000 		m->m_pkthdr.len = mhlen + len;
1001 #ifdef MAC
1002 		mac_netinet_fragment(m0, m);
1003 #endif
1004 		mhip->ip_off = htons(mhip->ip_off);
1005 		mhip->ip_sum = 0;
1006 		if (m->m_pkthdr.csum_flags & CSUM_IP & ~if_hwassist_flags) {
1007 			mhip->ip_sum = in_cksum(m, mhlen);
1008 			m->m_pkthdr.csum_flags &= ~CSUM_IP;
1009 		}
1010 		*mnext = m;
1011 		mnext = &m->m_nextpkt;
1012 	}
1013 	IPSTAT_ADD(ips_ofragments, nfrags);
1014 
1015 	/*
1016 	 * Update first fragment by trimming what's been copied out
1017 	 * and updating header.
1018 	 */
1019 	m_adj(m0, hlen + firstlen - ip_len);
1020 	m0->m_pkthdr.len = hlen + firstlen;
1021 	ip->ip_len = htons((u_short)m0->m_pkthdr.len);
1022 	ip->ip_off = htons(ip_off | IP_MF);
1023 	ip->ip_sum = 0;
1024 	if (m0->m_pkthdr.csum_flags & CSUM_IP & ~if_hwassist_flags) {
1025 		ip->ip_sum = in_cksum(m0, hlen);
1026 		m0->m_pkthdr.csum_flags &= ~CSUM_IP;
1027 	}
1028 
1029 done:
1030 	*m_frag = m0;
1031 	return error;
1032 }
1033 
1034 void
1035 in_delayed_cksum(struct mbuf *m)
1036 {
1037 	struct ip *ip;
1038 	struct udphdr *uh;
1039 	uint16_t cklen, csum, offset;
1040 
1041 	ip = mtod(m, struct ip *);
1042 	offset = ip->ip_hl << 2 ;
1043 
1044 	if (m->m_pkthdr.csum_flags & CSUM_UDP) {
1045 		/* if udp header is not in the first mbuf copy udplen */
1046 		if (offset + sizeof(struct udphdr) > m->m_len) {
1047 			m_copydata(m, offset + offsetof(struct udphdr,
1048 			    uh_ulen), sizeof(cklen), (caddr_t)&cklen);
1049 			cklen = ntohs(cklen);
1050 		} else {
1051 			uh = (struct udphdr *)mtodo(m, offset);
1052 			cklen = ntohs(uh->uh_ulen);
1053 		}
1054 		csum = in_cksum_skip(m, cklen + offset, offset);
1055 		if (csum == 0)
1056 			csum = 0xffff;
1057 	} else {
1058 		cklen = ntohs(ip->ip_len);
1059 		csum = in_cksum_skip(m, cklen, offset);
1060 	}
1061 	offset += m->m_pkthdr.csum_data;	/* checksum offset */
1062 
1063 	if (offset + sizeof(csum) > m->m_len)
1064 		m_copyback(m, offset, sizeof(csum), (caddr_t)&csum);
1065 	else
1066 		*(u_short *)mtodo(m, offset) = csum;
1067 }
1068 
1069 /*
1070  * IP socket option processing.
1071  */
1072 int
1073 ip_ctloutput(struct socket *so, struct sockopt *sopt)
1074 {
1075 	struct inpcb *inp = sotoinpcb(so);
1076 	int	error, optval;
1077 #ifdef	RSS
1078 	uint32_t rss_bucket;
1079 	int retval;
1080 #endif
1081 
1082 	error = optval = 0;
1083 	if (sopt->sopt_level != IPPROTO_IP) {
1084 		error = EINVAL;
1085 
1086 		if (sopt->sopt_level == SOL_SOCKET &&
1087 		    sopt->sopt_dir == SOPT_SET) {
1088 			switch (sopt->sopt_name) {
1089 			case SO_REUSEADDR:
1090 				INP_WLOCK(inp);
1091 				if ((so->so_options & SO_REUSEADDR) != 0)
1092 					inp->inp_flags2 |= INP_REUSEADDR;
1093 				else
1094 					inp->inp_flags2 &= ~INP_REUSEADDR;
1095 				INP_WUNLOCK(inp);
1096 				error = 0;
1097 				break;
1098 			case SO_REUSEPORT:
1099 				INP_WLOCK(inp);
1100 				if ((so->so_options & SO_REUSEPORT) != 0)
1101 					inp->inp_flags2 |= INP_REUSEPORT;
1102 				else
1103 					inp->inp_flags2 &= ~INP_REUSEPORT;
1104 				INP_WUNLOCK(inp);
1105 				error = 0;
1106 				break;
1107 			case SO_REUSEPORT_LB:
1108 				INP_WLOCK(inp);
1109 				if ((so->so_options & SO_REUSEPORT_LB) != 0)
1110 					inp->inp_flags2 |= INP_REUSEPORT_LB;
1111 				else
1112 					inp->inp_flags2 &= ~INP_REUSEPORT_LB;
1113 				INP_WUNLOCK(inp);
1114 				error = 0;
1115 				break;
1116 			case SO_SETFIB:
1117 				INP_WLOCK(inp);
1118 				inp->inp_inc.inc_fibnum = so->so_fibnum;
1119 				INP_WUNLOCK(inp);
1120 				error = 0;
1121 				break;
1122 			case SO_MAX_PACING_RATE:
1123 #ifdef RATELIMIT
1124 				INP_WLOCK(inp);
1125 				inp->inp_flags2 |= INP_RATE_LIMIT_CHANGED;
1126 				INP_WUNLOCK(inp);
1127 				error = 0;
1128 #else
1129 				error = EOPNOTSUPP;
1130 #endif
1131 				break;
1132 			default:
1133 				break;
1134 			}
1135 		}
1136 		return (error);
1137 	}
1138 
1139 	switch (sopt->sopt_dir) {
1140 	case SOPT_SET:
1141 		switch (sopt->sopt_name) {
1142 		case IP_OPTIONS:
1143 #ifdef notyet
1144 		case IP_RETOPTS:
1145 #endif
1146 		{
1147 			struct mbuf *m;
1148 			if (sopt->sopt_valsize > MLEN) {
1149 				error = EMSGSIZE;
1150 				break;
1151 			}
1152 			m = m_get(sopt->sopt_td ? M_WAITOK : M_NOWAIT, MT_DATA);
1153 			if (m == NULL) {
1154 				error = ENOBUFS;
1155 				break;
1156 			}
1157 			m->m_len = sopt->sopt_valsize;
1158 			error = sooptcopyin(sopt, mtod(m, char *), m->m_len,
1159 					    m->m_len);
1160 			if (error) {
1161 				m_free(m);
1162 				break;
1163 			}
1164 			INP_WLOCK(inp);
1165 			error = ip_pcbopts(inp, sopt->sopt_name, m);
1166 			INP_WUNLOCK(inp);
1167 			return (error);
1168 		}
1169 
1170 		case IP_BINDANY:
1171 			if (sopt->sopt_td != NULL) {
1172 				error = priv_check(sopt->sopt_td,
1173 				    PRIV_NETINET_BINDANY);
1174 				if (error)
1175 					break;
1176 			}
1177 			/* FALLTHROUGH */
1178 		case IP_BINDMULTI:
1179 #ifdef	RSS
1180 		case IP_RSS_LISTEN_BUCKET:
1181 #endif
1182 		case IP_TOS:
1183 		case IP_TTL:
1184 		case IP_MINTTL:
1185 		case IP_RECVOPTS:
1186 		case IP_RECVRETOPTS:
1187 		case IP_ORIGDSTADDR:
1188 		case IP_RECVDSTADDR:
1189 		case IP_RECVTTL:
1190 		case IP_RECVIF:
1191 		case IP_ONESBCAST:
1192 		case IP_DONTFRAG:
1193 		case IP_RECVTOS:
1194 		case IP_RECVFLOWID:
1195 #ifdef	RSS
1196 		case IP_RECVRSSBUCKETID:
1197 #endif
1198 		case IP_VLAN_PCP:
1199 			error = sooptcopyin(sopt, &optval, sizeof optval,
1200 					    sizeof optval);
1201 			if (error)
1202 				break;
1203 
1204 			switch (sopt->sopt_name) {
1205 			case IP_TOS:
1206 				inp->inp_ip_tos = optval;
1207 				break;
1208 
1209 			case IP_TTL:
1210 				inp->inp_ip_ttl = optval;
1211 				break;
1212 
1213 			case IP_MINTTL:
1214 				if (optval >= 0 && optval <= MAXTTL)
1215 					inp->inp_ip_minttl = optval;
1216 				else
1217 					error = EINVAL;
1218 				break;
1219 
1220 #define	OPTSET(bit) do {						\
1221 	INP_WLOCK(inp);							\
1222 	if (optval)							\
1223 		inp->inp_flags |= bit;					\
1224 	else								\
1225 		inp->inp_flags &= ~bit;					\
1226 	INP_WUNLOCK(inp);						\
1227 } while (0)
1228 
1229 #define	OPTSET2(bit, val) do {						\
1230 	INP_WLOCK(inp);							\
1231 	if (val)							\
1232 		inp->inp_flags2 |= bit;					\
1233 	else								\
1234 		inp->inp_flags2 &= ~bit;				\
1235 	INP_WUNLOCK(inp);						\
1236 } while (0)
1237 
1238 			case IP_RECVOPTS:
1239 				OPTSET(INP_RECVOPTS);
1240 				break;
1241 
1242 			case IP_RECVRETOPTS:
1243 				OPTSET(INP_RECVRETOPTS);
1244 				break;
1245 
1246 			case IP_RECVDSTADDR:
1247 				OPTSET(INP_RECVDSTADDR);
1248 				break;
1249 
1250 			case IP_ORIGDSTADDR:
1251 				OPTSET2(INP_ORIGDSTADDR, optval);
1252 				break;
1253 
1254 			case IP_RECVTTL:
1255 				OPTSET(INP_RECVTTL);
1256 				break;
1257 
1258 			case IP_RECVIF:
1259 				OPTSET(INP_RECVIF);
1260 				break;
1261 
1262 			case IP_ONESBCAST:
1263 				OPTSET(INP_ONESBCAST);
1264 				break;
1265 			case IP_DONTFRAG:
1266 				OPTSET(INP_DONTFRAG);
1267 				break;
1268 			case IP_BINDANY:
1269 				OPTSET(INP_BINDANY);
1270 				break;
1271 			case IP_RECVTOS:
1272 				OPTSET(INP_RECVTOS);
1273 				break;
1274 			case IP_BINDMULTI:
1275 				OPTSET2(INP_BINDMULTI, optval);
1276 				break;
1277 			case IP_RECVFLOWID:
1278 				OPTSET2(INP_RECVFLOWID, optval);
1279 				break;
1280 #ifdef	RSS
1281 			case IP_RSS_LISTEN_BUCKET:
1282 				if ((optval >= 0) &&
1283 				    (optval < rss_getnumbuckets())) {
1284 					inp->inp_rss_listen_bucket = optval;
1285 					OPTSET2(INP_RSS_BUCKET_SET, 1);
1286 				} else {
1287 					error = EINVAL;
1288 				}
1289 				break;
1290 			case IP_RECVRSSBUCKETID:
1291 				OPTSET2(INP_RECVRSSBUCKETID, optval);
1292 				break;
1293 #endif
1294 			case IP_VLAN_PCP:
1295 				if ((optval >= -1) && (optval <=
1296 				    (INP_2PCP_MASK >> INP_2PCP_SHIFT))) {
1297 					if (optval == -1) {
1298 						INP_WLOCK(inp);
1299 						inp->inp_flags2 &=
1300 						    ~(INP_2PCP_SET |
1301 						      INP_2PCP_MASK);
1302 						INP_WUNLOCK(inp);
1303 					} else {
1304 						INP_WLOCK(inp);
1305 						inp->inp_flags2 |=
1306 						    INP_2PCP_SET;
1307 						inp->inp_flags2 &=
1308 						    ~INP_2PCP_MASK;
1309 						inp->inp_flags2 |=
1310 						    optval << INP_2PCP_SHIFT;
1311 						INP_WUNLOCK(inp);
1312 					}
1313 				} else
1314 					error = EINVAL;
1315 				break;
1316 			}
1317 			break;
1318 #undef OPTSET
1319 #undef OPTSET2
1320 
1321 		/*
1322 		 * Multicast socket options are processed by the in_mcast
1323 		 * module.
1324 		 */
1325 		case IP_MULTICAST_IF:
1326 		case IP_MULTICAST_VIF:
1327 		case IP_MULTICAST_TTL:
1328 		case IP_MULTICAST_LOOP:
1329 		case IP_ADD_MEMBERSHIP:
1330 		case IP_DROP_MEMBERSHIP:
1331 		case IP_ADD_SOURCE_MEMBERSHIP:
1332 		case IP_DROP_SOURCE_MEMBERSHIP:
1333 		case IP_BLOCK_SOURCE:
1334 		case IP_UNBLOCK_SOURCE:
1335 		case IP_MSFILTER:
1336 		case MCAST_JOIN_GROUP:
1337 		case MCAST_LEAVE_GROUP:
1338 		case MCAST_JOIN_SOURCE_GROUP:
1339 		case MCAST_LEAVE_SOURCE_GROUP:
1340 		case MCAST_BLOCK_SOURCE:
1341 		case MCAST_UNBLOCK_SOURCE:
1342 			error = inp_setmoptions(inp, sopt);
1343 			break;
1344 
1345 		case IP_PORTRANGE:
1346 			error = sooptcopyin(sopt, &optval, sizeof optval,
1347 					    sizeof optval);
1348 			if (error)
1349 				break;
1350 
1351 			INP_WLOCK(inp);
1352 			switch (optval) {
1353 			case IP_PORTRANGE_DEFAULT:
1354 				inp->inp_flags &= ~(INP_LOWPORT);
1355 				inp->inp_flags &= ~(INP_HIGHPORT);
1356 				break;
1357 
1358 			case IP_PORTRANGE_HIGH:
1359 				inp->inp_flags &= ~(INP_LOWPORT);
1360 				inp->inp_flags |= INP_HIGHPORT;
1361 				break;
1362 
1363 			case IP_PORTRANGE_LOW:
1364 				inp->inp_flags &= ~(INP_HIGHPORT);
1365 				inp->inp_flags |= INP_LOWPORT;
1366 				break;
1367 
1368 			default:
1369 				error = EINVAL;
1370 				break;
1371 			}
1372 			INP_WUNLOCK(inp);
1373 			break;
1374 
1375 #if defined(IPSEC) || defined(IPSEC_SUPPORT)
1376 		case IP_IPSEC_POLICY:
1377 			if (IPSEC_ENABLED(ipv4)) {
1378 				error = IPSEC_PCBCTL(ipv4, inp, sopt);
1379 				break;
1380 			}
1381 			/* FALLTHROUGH */
1382 #endif /* IPSEC */
1383 
1384 		default:
1385 			error = ENOPROTOOPT;
1386 			break;
1387 		}
1388 		break;
1389 
1390 	case SOPT_GET:
1391 		switch (sopt->sopt_name) {
1392 		case IP_OPTIONS:
1393 		case IP_RETOPTS:
1394 			INP_RLOCK(inp);
1395 			if (inp->inp_options) {
1396 				struct mbuf *options;
1397 
1398 				options = m_copym(inp->inp_options, 0,
1399 				    M_COPYALL, M_NOWAIT);
1400 				INP_RUNLOCK(inp);
1401 				if (options != NULL) {
1402 					error = sooptcopyout(sopt,
1403 							     mtod(options, char *),
1404 							     options->m_len);
1405 					m_freem(options);
1406 				} else
1407 					error = ENOMEM;
1408 			} else {
1409 				INP_RUNLOCK(inp);
1410 				sopt->sopt_valsize = 0;
1411 			}
1412 			break;
1413 
1414 		case IP_TOS:
1415 		case IP_TTL:
1416 		case IP_MINTTL:
1417 		case IP_RECVOPTS:
1418 		case IP_RECVRETOPTS:
1419 		case IP_ORIGDSTADDR:
1420 		case IP_RECVDSTADDR:
1421 		case IP_RECVTTL:
1422 		case IP_RECVIF:
1423 		case IP_PORTRANGE:
1424 		case IP_ONESBCAST:
1425 		case IP_DONTFRAG:
1426 		case IP_BINDANY:
1427 		case IP_RECVTOS:
1428 		case IP_BINDMULTI:
1429 		case IP_FLOWID:
1430 		case IP_FLOWTYPE:
1431 		case IP_RECVFLOWID:
1432 #ifdef	RSS
1433 		case IP_RSSBUCKETID:
1434 		case IP_RECVRSSBUCKETID:
1435 #endif
1436 		case IP_VLAN_PCP:
1437 			switch (sopt->sopt_name) {
1438 			case IP_TOS:
1439 				optval = inp->inp_ip_tos;
1440 				break;
1441 
1442 			case IP_TTL:
1443 				optval = inp->inp_ip_ttl;
1444 				break;
1445 
1446 			case IP_MINTTL:
1447 				optval = inp->inp_ip_minttl;
1448 				break;
1449 
1450 #define	OPTBIT(bit)	(inp->inp_flags & bit ? 1 : 0)
1451 #define	OPTBIT2(bit)	(inp->inp_flags2 & bit ? 1 : 0)
1452 
1453 			case IP_RECVOPTS:
1454 				optval = OPTBIT(INP_RECVOPTS);
1455 				break;
1456 
1457 			case IP_RECVRETOPTS:
1458 				optval = OPTBIT(INP_RECVRETOPTS);
1459 				break;
1460 
1461 			case IP_RECVDSTADDR:
1462 				optval = OPTBIT(INP_RECVDSTADDR);
1463 				break;
1464 
1465 			case IP_ORIGDSTADDR:
1466 				optval = OPTBIT2(INP_ORIGDSTADDR);
1467 				break;
1468 
1469 			case IP_RECVTTL:
1470 				optval = OPTBIT(INP_RECVTTL);
1471 				break;
1472 
1473 			case IP_RECVIF:
1474 				optval = OPTBIT(INP_RECVIF);
1475 				break;
1476 
1477 			case IP_PORTRANGE:
1478 				if (inp->inp_flags & INP_HIGHPORT)
1479 					optval = IP_PORTRANGE_HIGH;
1480 				else if (inp->inp_flags & INP_LOWPORT)
1481 					optval = IP_PORTRANGE_LOW;
1482 				else
1483 					optval = 0;
1484 				break;
1485 
1486 			case IP_ONESBCAST:
1487 				optval = OPTBIT(INP_ONESBCAST);
1488 				break;
1489 			case IP_DONTFRAG:
1490 				optval = OPTBIT(INP_DONTFRAG);
1491 				break;
1492 			case IP_BINDANY:
1493 				optval = OPTBIT(INP_BINDANY);
1494 				break;
1495 			case IP_RECVTOS:
1496 				optval = OPTBIT(INP_RECVTOS);
1497 				break;
1498 			case IP_FLOWID:
1499 				optval = inp->inp_flowid;
1500 				break;
1501 			case IP_FLOWTYPE:
1502 				optval = inp->inp_flowtype;
1503 				break;
1504 			case IP_RECVFLOWID:
1505 				optval = OPTBIT2(INP_RECVFLOWID);
1506 				break;
1507 #ifdef	RSS
1508 			case IP_RSSBUCKETID:
1509 				retval = rss_hash2bucket(inp->inp_flowid,
1510 				    inp->inp_flowtype,
1511 				    &rss_bucket);
1512 				if (retval == 0)
1513 					optval = rss_bucket;
1514 				else
1515 					error = EINVAL;
1516 				break;
1517 			case IP_RECVRSSBUCKETID:
1518 				optval = OPTBIT2(INP_RECVRSSBUCKETID);
1519 				break;
1520 #endif
1521 			case IP_BINDMULTI:
1522 				optval = OPTBIT2(INP_BINDMULTI);
1523 				break;
1524 			case IP_VLAN_PCP:
1525 				if (OPTBIT2(INP_2PCP_SET)) {
1526 					optval = (inp->inp_flags2 &
1527 					    INP_2PCP_MASK) >> INP_2PCP_SHIFT;
1528 				} else {
1529 					optval = -1;
1530 				}
1531 				break;
1532 			}
1533 			error = sooptcopyout(sopt, &optval, sizeof optval);
1534 			break;
1535 
1536 		/*
1537 		 * Multicast socket options are processed by the in_mcast
1538 		 * module.
1539 		 */
1540 		case IP_MULTICAST_IF:
1541 		case IP_MULTICAST_VIF:
1542 		case IP_MULTICAST_TTL:
1543 		case IP_MULTICAST_LOOP:
1544 		case IP_MSFILTER:
1545 			error = inp_getmoptions(inp, sopt);
1546 			break;
1547 
1548 #if defined(IPSEC) || defined(IPSEC_SUPPORT)
1549 		case IP_IPSEC_POLICY:
1550 			if (IPSEC_ENABLED(ipv4)) {
1551 				error = IPSEC_PCBCTL(ipv4, inp, sopt);
1552 				break;
1553 			}
1554 			/* FALLTHROUGH */
1555 #endif /* IPSEC */
1556 
1557 		default:
1558 			error = ENOPROTOOPT;
1559 			break;
1560 		}
1561 		break;
1562 	}
1563 	return (error);
1564 }
1565 
1566 /*
1567  * Routine called from ip_output() to loop back a copy of an IP multicast
1568  * packet to the input queue of a specified interface.  Note that this
1569  * calls the output routine of the loopback "driver", but with an interface
1570  * pointer that might NOT be a loopback interface -- evil, but easier than
1571  * replicating that code here.
1572  */
1573 static void
1574 ip_mloopback(struct ifnet *ifp, const struct mbuf *m, int hlen)
1575 {
1576 	struct ip *ip;
1577 	struct mbuf *copym;
1578 
1579 	/*
1580 	 * Make a deep copy of the packet because we're going to
1581 	 * modify the pack in order to generate checksums.
1582 	 */
1583 	copym = m_dup(m, M_NOWAIT);
1584 	if (copym != NULL && (!M_WRITABLE(copym) || copym->m_len < hlen))
1585 		copym = m_pullup(copym, hlen);
1586 	if (copym != NULL) {
1587 		/* If needed, compute the checksum and mark it as valid. */
1588 		if (copym->m_pkthdr.csum_flags & CSUM_DELAY_DATA) {
1589 			in_delayed_cksum(copym);
1590 			copym->m_pkthdr.csum_flags &= ~CSUM_DELAY_DATA;
1591 			copym->m_pkthdr.csum_flags |=
1592 			    CSUM_DATA_VALID | CSUM_PSEUDO_HDR;
1593 			copym->m_pkthdr.csum_data = 0xffff;
1594 		}
1595 		/*
1596 		 * We don't bother to fragment if the IP length is greater
1597 		 * than the interface's MTU.  Can this possibly matter?
1598 		 */
1599 		ip = mtod(copym, struct ip *);
1600 		ip->ip_sum = 0;
1601 		ip->ip_sum = in_cksum(copym, hlen);
1602 		if_simloop(ifp, copym, AF_INET, 0);
1603 	}
1604 }
1605