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