xref: /freebsd/sys/netinet/ip_input.c (revision ebacd8013fe5f7fdf9f6a5b286f6680dd2891036)
1 /*-
2  * SPDX-License-Identifier: BSD-3-Clause
3  *
4  * Copyright (c) 1982, 1986, 1988, 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_input.c	8.2 (Berkeley) 1/4/94
32  */
33 
34 #include <sys/cdefs.h>
35 __FBSDID("$FreeBSD$");
36 
37 #include "opt_bootp.h"
38 #include "opt_inet.h"
39 #include "opt_ipstealth.h"
40 #include "opt_ipsec.h"
41 #include "opt_route.h"
42 #include "opt_rss.h"
43 #include "opt_sctp.h"
44 
45 #include <sys/param.h>
46 #include <sys/systm.h>
47 #include <sys/hhook.h>
48 #include <sys/mbuf.h>
49 #include <sys/malloc.h>
50 #include <sys/domain.h>
51 #include <sys/protosw.h>
52 #include <sys/socket.h>
53 #include <sys/time.h>
54 #include <sys/kernel.h>
55 #include <sys/lock.h>
56 #include <sys/rmlock.h>
57 #include <sys/rwlock.h>
58 #include <sys/sdt.h>
59 #include <sys/syslog.h>
60 #include <sys/sysctl.h>
61 
62 #include <net/if.h>
63 #include <net/if_types.h>
64 #include <net/if_var.h>
65 #include <net/if_dl.h>
66 #include <net/if_private.h>
67 #include <net/pfil.h>
68 #include <net/route.h>
69 #include <net/route/nhop.h>
70 #include <net/netisr.h>
71 #include <net/rss_config.h>
72 #include <net/vnet.h>
73 
74 #include <netinet/in.h>
75 #include <netinet/in_kdtrace.h>
76 #include <netinet/in_systm.h>
77 #include <netinet/in_var.h>
78 #include <netinet/ip.h>
79 #include <netinet/in_fib.h>
80 #include <netinet/in_pcb.h>
81 #include <netinet/ip_var.h>
82 #include <netinet/ip_encap.h>
83 #include <netinet/ip_fw.h>
84 #include <netinet/ip_icmp.h>
85 #include <netinet/igmp_var.h>
86 #include <netinet/ip_options.h>
87 #include <machine/in_cksum.h>
88 #include <netinet/ip_carp.h>
89 #include <netinet/in_rss.h>
90 #ifdef SCTP
91 #include <netinet/sctp_var.h>
92 #endif
93 
94 #include <netipsec/ipsec_support.h>
95 
96 #include <sys/socketvar.h>
97 
98 #include <security/mac/mac_framework.h>
99 
100 #ifdef CTASSERT
101 CTASSERT(sizeof(struct ip) == 20);
102 #endif
103 
104 /* IP reassembly functions are defined in ip_reass.c. */
105 extern void ipreass_init(void);
106 extern void ipreass_vnet_init(void);
107 #ifdef VIMAGE
108 extern void ipreass_destroy(void);
109 #endif
110 
111 VNET_DEFINE(int, rsvp_on);
112 
113 VNET_DEFINE(int, ipforwarding);
114 SYSCTL_INT(_net_inet_ip, IPCTL_FORWARDING, forwarding, CTLFLAG_VNET | CTLFLAG_RW,
115     &VNET_NAME(ipforwarding), 0,
116     "Enable IP forwarding between interfaces");
117 
118 /*
119  * Respond with an ICMP host redirect when we forward a packet out of
120  * the same interface on which it was received.  See RFC 792.
121  */
122 VNET_DEFINE(int, ipsendredirects) = 1;
123 SYSCTL_INT(_net_inet_ip, IPCTL_SENDREDIRECTS, redirect, CTLFLAG_VNET | CTLFLAG_RW,
124     &VNET_NAME(ipsendredirects), 0,
125     "Enable sending IP redirects");
126 
127 VNET_DEFINE_STATIC(bool, ip_strong_es) = false;
128 #define	V_ip_strong_es	VNET(ip_strong_es)
129 SYSCTL_BOOL(_net_inet_ip, OID_AUTO, rfc1122_strong_es,
130     CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(ip_strong_es), false,
131     "Packet's IP destination address must match address on arrival interface");
132 
133 VNET_DEFINE_STATIC(bool, ip_sav) = true;
134 #define	V_ip_sav	VNET(ip_sav)
135 SYSCTL_BOOL(_net_inet_ip, OID_AUTO, source_address_validation,
136     CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(ip_sav), true,
137     "Drop incoming packets with source address that is a local address");
138 
139 VNET_DEFINE(pfil_head_t, inet_pfil_head);	/* Packet filter hooks */
140 
141 static struct netisr_handler ip_nh = {
142 	.nh_name = "ip",
143 	.nh_handler = ip_input,
144 	.nh_proto = NETISR_IP,
145 #ifdef	RSS
146 	.nh_m2cpuid = rss_soft_m2cpuid_v4,
147 	.nh_policy = NETISR_POLICY_CPU,
148 	.nh_dispatch = NETISR_DISPATCH_HYBRID,
149 #else
150 	.nh_policy = NETISR_POLICY_FLOW,
151 #endif
152 };
153 
154 #ifdef	RSS
155 /*
156  * Directly dispatched frames are currently assumed
157  * to have a flowid already calculated.
158  *
159  * It should likely have something that assert it
160  * actually has valid flow details.
161  */
162 static struct netisr_handler ip_direct_nh = {
163 	.nh_name = "ip_direct",
164 	.nh_handler = ip_direct_input,
165 	.nh_proto = NETISR_IP_DIRECT,
166 	.nh_m2cpuid = rss_soft_m2cpuid_v4,
167 	.nh_policy = NETISR_POLICY_CPU,
168 	.nh_dispatch = NETISR_DISPATCH_HYBRID,
169 };
170 #endif
171 
172 ipproto_input_t		*ip_protox[IPPROTO_MAX] = {
173 			    [0 ... IPPROTO_MAX - 1] = rip_input };
174 ipproto_ctlinput_t	*ip_ctlprotox[IPPROTO_MAX] = {
175 			    [0 ... IPPROTO_MAX - 1] = rip_ctlinput };
176 
177 VNET_DEFINE(struct in_ifaddrhead, in_ifaddrhead);  /* first inet address */
178 VNET_DEFINE(struct in_ifaddrhashhead *, in_ifaddrhashtbl); /* inet addr hash table  */
179 VNET_DEFINE(u_long, in_ifaddrhmask);		/* mask for hash table */
180 
181 /* Make sure it is safe to use hashinit(9) on CK_LIST. */
182 CTASSERT(sizeof(struct in_ifaddrhashhead) == sizeof(LIST_HEAD(, in_addr)));
183 
184 #ifdef IPCTL_DEFMTU
185 SYSCTL_INT(_net_inet_ip, IPCTL_DEFMTU, mtu, CTLFLAG_RW,
186     &ip_mtu, 0, "Default MTU");
187 #endif
188 
189 #ifdef IPSTEALTH
190 VNET_DEFINE(int, ipstealth);
191 SYSCTL_INT(_net_inet_ip, OID_AUTO, stealth, CTLFLAG_VNET | CTLFLAG_RW,
192     &VNET_NAME(ipstealth), 0,
193     "IP stealth mode, no TTL decrementation on forwarding");
194 #endif
195 
196 /*
197  * IP statistics are stored in the "array" of counter(9)s.
198  */
199 VNET_PCPUSTAT_DEFINE(struct ipstat, ipstat);
200 VNET_PCPUSTAT_SYSINIT(ipstat);
201 SYSCTL_VNET_PCPUSTAT(_net_inet_ip, IPCTL_STATS, stats, struct ipstat, ipstat,
202     "IP statistics (struct ipstat, netinet/ip_var.h)");
203 
204 #ifdef VIMAGE
205 VNET_PCPUSTAT_SYSUNINIT(ipstat);
206 #endif /* VIMAGE */
207 
208 /*
209  * Kernel module interface for updating ipstat.  The argument is an index
210  * into ipstat treated as an array.
211  */
212 void
213 kmod_ipstat_inc(int statnum)
214 {
215 
216 	counter_u64_add(VNET(ipstat)[statnum], 1);
217 }
218 
219 void
220 kmod_ipstat_dec(int statnum)
221 {
222 
223 	counter_u64_add(VNET(ipstat)[statnum], -1);
224 }
225 
226 static int
227 sysctl_netinet_intr_queue_maxlen(SYSCTL_HANDLER_ARGS)
228 {
229 	int error, qlimit;
230 
231 	netisr_getqlimit(&ip_nh, &qlimit);
232 	error = sysctl_handle_int(oidp, &qlimit, 0, req);
233 	if (error || !req->newptr)
234 		return (error);
235 	if (qlimit < 1)
236 		return (EINVAL);
237 	return (netisr_setqlimit(&ip_nh, qlimit));
238 }
239 SYSCTL_PROC(_net_inet_ip, IPCTL_INTRQMAXLEN, intr_queue_maxlen,
240     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE, 0, 0,
241     sysctl_netinet_intr_queue_maxlen, "I",
242     "Maximum size of the IP input queue");
243 
244 static int
245 sysctl_netinet_intr_queue_drops(SYSCTL_HANDLER_ARGS)
246 {
247 	u_int64_t qdrops_long;
248 	int error, qdrops;
249 
250 	netisr_getqdrops(&ip_nh, &qdrops_long);
251 	qdrops = qdrops_long;
252 	error = sysctl_handle_int(oidp, &qdrops, 0, req);
253 	if (error || !req->newptr)
254 		return (error);
255 	if (qdrops != 0)
256 		return (EINVAL);
257 	netisr_clearqdrops(&ip_nh);
258 	return (0);
259 }
260 
261 SYSCTL_PROC(_net_inet_ip, IPCTL_INTRQDROPS, intr_queue_drops,
262     CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE,
263     0, 0, sysctl_netinet_intr_queue_drops, "I",
264     "Number of packets dropped from the IP input queue");
265 
266 #ifdef	RSS
267 static int
268 sysctl_netinet_intr_direct_queue_maxlen(SYSCTL_HANDLER_ARGS)
269 {
270 	int error, qlimit;
271 
272 	netisr_getqlimit(&ip_direct_nh, &qlimit);
273 	error = sysctl_handle_int(oidp, &qlimit, 0, req);
274 	if (error || !req->newptr)
275 		return (error);
276 	if (qlimit < 1)
277 		return (EINVAL);
278 	return (netisr_setqlimit(&ip_direct_nh, qlimit));
279 }
280 SYSCTL_PROC(_net_inet_ip, IPCTL_INTRDQMAXLEN, intr_direct_queue_maxlen,
281     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE,
282     0, 0, sysctl_netinet_intr_direct_queue_maxlen,
283     "I", "Maximum size of the IP direct input queue");
284 
285 static int
286 sysctl_netinet_intr_direct_queue_drops(SYSCTL_HANDLER_ARGS)
287 {
288 	u_int64_t qdrops_long;
289 	int error, qdrops;
290 
291 	netisr_getqdrops(&ip_direct_nh, &qdrops_long);
292 	qdrops = qdrops_long;
293 	error = sysctl_handle_int(oidp, &qdrops, 0, req);
294 	if (error || !req->newptr)
295 		return (error);
296 	if (qdrops != 0)
297 		return (EINVAL);
298 	netisr_clearqdrops(&ip_direct_nh);
299 	return (0);
300 }
301 
302 SYSCTL_PROC(_net_inet_ip, IPCTL_INTRDQDROPS, intr_direct_queue_drops,
303     CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE, 0, 0,
304     sysctl_netinet_intr_direct_queue_drops, "I",
305     "Number of packets dropped from the IP direct input queue");
306 #endif	/* RSS */
307 
308 /*
309  * IP initialization: fill in IP protocol switch table.
310  * All protocols not implemented in kernel go to raw IP protocol handler.
311  */
312 static void
313 ip_vnet_init(void *arg __unused)
314 {
315 	struct pfil_head_args args;
316 
317 	CK_STAILQ_INIT(&V_in_ifaddrhead);
318 	V_in_ifaddrhashtbl = hashinit(INADDR_NHASH, M_IFADDR, &V_in_ifaddrhmask);
319 
320 	/* Initialize IP reassembly queue. */
321 	ipreass_vnet_init();
322 
323 	/* Initialize packet filter hooks. */
324 	args.pa_version = PFIL_VERSION;
325 	args.pa_flags = PFIL_IN | PFIL_OUT;
326 	args.pa_type = PFIL_TYPE_IP4;
327 	args.pa_headname = PFIL_INET_NAME;
328 	V_inet_pfil_head = pfil_head_register(&args);
329 
330 	if (hhook_head_register(HHOOK_TYPE_IPSEC_IN, AF_INET,
331 	    &V_ipsec_hhh_in[HHOOK_IPSEC_INET],
332 	    HHOOK_WAITOK | HHOOK_HEADISINVNET) != 0)
333 		printf("%s: WARNING: unable to register input helper hook\n",
334 		    __func__);
335 	if (hhook_head_register(HHOOK_TYPE_IPSEC_OUT, AF_INET,
336 	    &V_ipsec_hhh_out[HHOOK_IPSEC_INET],
337 	    HHOOK_WAITOK | HHOOK_HEADISINVNET) != 0)
338 		printf("%s: WARNING: unable to register output helper hook\n",
339 		    __func__);
340 
341 #ifdef VIMAGE
342 	netisr_register_vnet(&ip_nh);
343 #ifdef	RSS
344 	netisr_register_vnet(&ip_direct_nh);
345 #endif
346 #endif
347 }
348 VNET_SYSINIT(ip_vnet_init, SI_SUB_PROTO_DOMAIN, SI_ORDER_FOURTH,
349     ip_vnet_init, NULL);
350 
351 static void
352 ip_init(const void *unused __unused)
353 {
354 
355 	ipreass_init();
356 
357 	/*
358 	 * Register statically compiled protocols, that are unlikely to
359 	 * ever become dynamic.
360 	 */
361 	IPPROTO_REGISTER(IPPROTO_ICMP, icmp_input, NULL);
362 	IPPROTO_REGISTER(IPPROTO_IGMP, igmp_input, NULL);
363 	IPPROTO_REGISTER(IPPROTO_RSVP, rsvp_input, NULL);
364 	IPPROTO_REGISTER(IPPROTO_IPV4, encap4_input, NULL);
365 	IPPROTO_REGISTER(IPPROTO_MOBILE, encap4_input, NULL);
366 	IPPROTO_REGISTER(IPPROTO_ETHERIP, encap4_input, NULL);
367 	IPPROTO_REGISTER(IPPROTO_GRE, encap4_input, NULL);
368 	IPPROTO_REGISTER(IPPROTO_IPV6, encap4_input, NULL);
369 	IPPROTO_REGISTER(IPPROTO_PIM, encap4_input, NULL);
370 #ifdef SCTP	/* XXX: has a loadable & static version */
371 	IPPROTO_REGISTER(IPPROTO_SCTP, sctp_input, sctp_ctlinput);
372 #endif
373 
374 	netisr_register(&ip_nh);
375 #ifdef	RSS
376 	netisr_register(&ip_direct_nh);
377 #endif
378 }
379 SYSINIT(ip_init, SI_SUB_PROTO_DOMAIN, SI_ORDER_THIRD, ip_init, NULL);
380 
381 #ifdef VIMAGE
382 static void
383 ip_destroy(void *unused __unused)
384 {
385 	int error;
386 
387 #ifdef	RSS
388 	netisr_unregister_vnet(&ip_direct_nh);
389 #endif
390 	netisr_unregister_vnet(&ip_nh);
391 
392 	pfil_head_unregister(V_inet_pfil_head);
393 	error = hhook_head_deregister(V_ipsec_hhh_in[HHOOK_IPSEC_INET]);
394 	if (error != 0) {
395 		printf("%s: WARNING: unable to deregister input helper hook "
396 		    "type HHOOK_TYPE_IPSEC_IN, id HHOOK_IPSEC_INET: "
397 		    "error %d returned\n", __func__, error);
398 	}
399 	error = hhook_head_deregister(V_ipsec_hhh_out[HHOOK_IPSEC_INET]);
400 	if (error != 0) {
401 		printf("%s: WARNING: unable to deregister output helper hook "
402 		    "type HHOOK_TYPE_IPSEC_OUT, id HHOOK_IPSEC_INET: "
403 		    "error %d returned\n", __func__, error);
404 	}
405 
406 	/* Remove the IPv4 addresses from all interfaces. */
407 	in_ifscrub_all();
408 
409 	/* Make sure the IPv4 routes are gone as well. */
410 	rib_flush_routes_family(AF_INET);
411 
412 	/* Destroy IP reassembly queue. */
413 	ipreass_destroy();
414 
415 	/* Cleanup in_ifaddr hash table; should be empty. */
416 	hashdestroy(V_in_ifaddrhashtbl, M_IFADDR, V_in_ifaddrhmask);
417 }
418 
419 VNET_SYSUNINIT(ip, SI_SUB_PROTO_DOMAIN, SI_ORDER_THIRD, ip_destroy, NULL);
420 #endif
421 
422 #ifdef	RSS
423 /*
424  * IP direct input routine.
425  *
426  * This is called when reinjecting completed fragments where
427  * all of the previous checking and book-keeping has been done.
428  */
429 void
430 ip_direct_input(struct mbuf *m)
431 {
432 	struct ip *ip;
433 	int hlen;
434 
435 	ip = mtod(m, struct ip *);
436 	hlen = ip->ip_hl << 2;
437 
438 #if defined(IPSEC) || defined(IPSEC_SUPPORT)
439 	if (IPSEC_ENABLED(ipv4)) {
440 		if (IPSEC_INPUT(ipv4, m, hlen, ip->ip_p) != 0)
441 			return;
442 	}
443 #endif /* IPSEC */
444 	IPSTAT_INC(ips_delivered);
445 	ip_protox[ip->ip_p](&m, &hlen, ip->ip_p);
446 }
447 #endif
448 
449 /*
450  * Ip input routine.  Checksum and byte swap header.  If fragmented
451  * try to reassemble.  Process options.  Pass to next level.
452  */
453 void
454 ip_input(struct mbuf *m)
455 {
456 	struct ip *ip = NULL;
457 	struct in_ifaddr *ia = NULL;
458 	struct ifaddr *ifa;
459 	struct ifnet *ifp;
460 	int hlen = 0;
461 	uint16_t sum, ip_len;
462 	int dchg = 0;				/* dest changed after fw */
463 	struct in_addr odst;			/* original dst address */
464 	bool strong_es;
465 
466 	M_ASSERTPKTHDR(m);
467 	NET_EPOCH_ASSERT();
468 
469 	if (m->m_flags & M_FASTFWD_OURS) {
470 		m->m_flags &= ~M_FASTFWD_OURS;
471 		/* Set up some basics that will be used later. */
472 		ip = mtod(m, struct ip *);
473 		hlen = ip->ip_hl << 2;
474 		ip_len = ntohs(ip->ip_len);
475 		goto ours;
476 	}
477 
478 	IPSTAT_INC(ips_total);
479 
480 	if (__predict_false(m->m_pkthdr.len < sizeof(struct ip)))
481 		goto tooshort;
482 
483 	if (m->m_len < sizeof(struct ip)) {
484 		m = m_pullup(m, sizeof(struct ip));
485 		if (__predict_false(m == NULL)) {
486 			IPSTAT_INC(ips_toosmall);
487 			return;
488 		}
489 	}
490 	ip = mtod(m, struct ip *);
491 
492 	if (__predict_false(ip->ip_v != IPVERSION)) {
493 		IPSTAT_INC(ips_badvers);
494 		goto bad;
495 	}
496 
497 	hlen = ip->ip_hl << 2;
498 	if (__predict_false(hlen < sizeof(struct ip))) {	/* minimum header length */
499 		IPSTAT_INC(ips_badhlen);
500 		goto bad;
501 	}
502 	if (hlen > m->m_len) {
503 		m = m_pullup(m, hlen);
504 		if (__predict_false(m == NULL)) {
505 			IPSTAT_INC(ips_badhlen);
506 			return;
507 		}
508 		ip = mtod(m, struct ip *);
509 	}
510 
511 	IP_PROBE(receive, NULL, NULL, ip, m->m_pkthdr.rcvif, ip, NULL);
512 
513 	/* IN_LOOPBACK must not appear on the wire - RFC1122 */
514 	ifp = m->m_pkthdr.rcvif;
515 	if (IN_LOOPBACK(ntohl(ip->ip_dst.s_addr)) ||
516 	    IN_LOOPBACK(ntohl(ip->ip_src.s_addr))) {
517 		if ((ifp->if_flags & IFF_LOOPBACK) == 0) {
518 			IPSTAT_INC(ips_badaddr);
519 			goto bad;
520 		}
521 	}
522 	/* The unspecified address can appear only as a src address - RFC1122 */
523 	if (__predict_false(ntohl(ip->ip_dst.s_addr) == INADDR_ANY)) {
524 		IPSTAT_INC(ips_badaddr);
525 		goto bad;
526 	}
527 
528 	if (m->m_pkthdr.csum_flags & CSUM_IP_CHECKED) {
529 		sum = !(m->m_pkthdr.csum_flags & CSUM_IP_VALID);
530 	} else {
531 		if (hlen == sizeof(struct ip)) {
532 			sum = in_cksum_hdr(ip);
533 		} else {
534 			sum = in_cksum(m, hlen);
535 		}
536 	}
537 	if (__predict_false(sum)) {
538 		IPSTAT_INC(ips_badsum);
539 		goto bad;
540 	}
541 
542 	ip_len = ntohs(ip->ip_len);
543 	if (__predict_false(ip_len < hlen)) {
544 		IPSTAT_INC(ips_badlen);
545 		goto bad;
546 	}
547 
548 	/*
549 	 * Check that the amount of data in the buffers
550 	 * is as at least much as the IP header would have us expect.
551 	 * Trim mbufs if longer than we expect.
552 	 * Drop packet if shorter than we expect.
553 	 */
554 	if (__predict_false(m->m_pkthdr.len < ip_len)) {
555 tooshort:
556 		IPSTAT_INC(ips_tooshort);
557 		goto bad;
558 	}
559 	if (m->m_pkthdr.len > ip_len) {
560 		if (m->m_len == m->m_pkthdr.len) {
561 			m->m_len = ip_len;
562 			m->m_pkthdr.len = ip_len;
563 		} else
564 			m_adj(m, ip_len - m->m_pkthdr.len);
565 	}
566 
567 	/*
568 	 * Try to forward the packet, but if we fail continue.
569 	 * ip_tryforward() may generate redirects these days.
570 	 * XXX the logic below falling through to normal processing
571 	 * if redirects are required should be revisited as well.
572 	 * ip_tryforward() does inbound and outbound packet firewall
573 	 * processing. If firewall has decided that destination becomes
574 	 * our local address, it sets M_FASTFWD_OURS flag. In this
575 	 * case skip another inbound firewall processing and update
576 	 * ip pointer.
577 	 */
578 	if (V_ipforwarding != 0
579 #if defined(IPSEC) || defined(IPSEC_SUPPORT)
580 	    && (!IPSEC_ENABLED(ipv4) ||
581 	    IPSEC_CAPS(ipv4, m, IPSEC_CAP_OPERABLE) == 0)
582 #endif
583 	    ) {
584 		/*
585 		 * ip_dooptions() was run so we can ignore the source route (or
586 		 * any IP options case) case for redirects in ip_tryforward().
587 		 */
588 		if ((m = ip_tryforward(m)) == NULL)
589 			return;
590 		if (m->m_flags & M_FASTFWD_OURS) {
591 			m->m_flags &= ~M_FASTFWD_OURS;
592 			ip = mtod(m, struct ip *);
593 			goto ours;
594 		}
595 	}
596 
597 #if defined(IPSEC) || defined(IPSEC_SUPPORT)
598 	/*
599 	 * Bypass packet filtering for packets previously handled by IPsec.
600 	 */
601 	if (IPSEC_ENABLED(ipv4) &&
602 	    IPSEC_CAPS(ipv4, m, IPSEC_CAP_BYPASS_FILTER) != 0)
603 			goto passin;
604 #endif
605 
606 	/*
607 	 * Run through list of hooks for input packets.
608 	 *
609 	 * NB: Beware of the destination address changing (e.g.
610 	 *     by NAT rewriting).  When this happens, tell
611 	 *     ip_forward to do the right thing.
612 	 */
613 
614 	/* Jump over all PFIL processing if hooks are not active. */
615 	if (!PFIL_HOOKED_IN(V_inet_pfil_head))
616 		goto passin;
617 
618 	odst = ip->ip_dst;
619 	if (pfil_mbuf_in(V_inet_pfil_head, &m, ifp, NULL) !=
620 	    PFIL_PASS)
621 		return;
622 	if (m == NULL)			/* consumed by filter */
623 		return;
624 
625 	ip = mtod(m, struct ip *);
626 	dchg = (odst.s_addr != ip->ip_dst.s_addr);
627 
628 	if (m->m_flags & M_FASTFWD_OURS) {
629 		m->m_flags &= ~M_FASTFWD_OURS;
630 		goto ours;
631 	}
632 	if (m->m_flags & M_IP_NEXTHOP) {
633 		if (m_tag_find(m, PACKET_TAG_IPFORWARD, NULL) != NULL) {
634 			/*
635 			 * Directly ship the packet on.  This allows
636 			 * forwarding packets originally destined to us
637 			 * to some other directly connected host.
638 			 */
639 			ip_forward(m, 1);
640 			return;
641 		}
642 	}
643 passin:
644 
645 	/*
646 	 * Process options and, if not destined for us,
647 	 * ship it on.  ip_dooptions returns 1 when an
648 	 * error was detected (causing an icmp message
649 	 * to be sent and the original packet to be freed).
650 	 */
651 	if (hlen > sizeof (struct ip) && ip_dooptions(m, 0))
652 		return;
653 
654         /* greedy RSVP, snatches any PATH packet of the RSVP protocol and no
655          * matter if it is destined to another node, or whether it is
656          * a multicast one, RSVP wants it! and prevents it from being forwarded
657          * anywhere else. Also checks if the rsvp daemon is running before
658 	 * grabbing the packet.
659          */
660 	if (ip->ip_p == IPPROTO_RSVP && V_rsvp_on)
661 		goto ours;
662 
663 	/*
664 	 * Check our list of addresses, to see if the packet is for us.
665 	 * If we don't have any addresses, assume any unicast packet
666 	 * we receive might be for us (and let the upper layers deal
667 	 * with it).
668 	 */
669 	if (CK_STAILQ_EMPTY(&V_in_ifaddrhead) &&
670 	    (m->m_flags & (M_MCAST|M_BCAST)) == 0)
671 		goto ours;
672 
673 	/*
674 	 * Enable a consistency check between the destination address
675 	 * and the arrival interface for a unicast packet (the RFC 1122
676 	 * strong ES model) with a list of additional predicates:
677 	 * - if IP forwarding is disabled
678 	 * - the packet is not locally generated
679 	 * - the packet is not subject to 'ipfw fwd'
680 	 * - Interface is not running CARP. If the packet got here, we already
681 	 *   checked it with carp_iamatch() and carp_forus().
682 	 */
683 	strong_es = V_ip_strong_es && (V_ipforwarding == 0) &&
684 	    ((ifp->if_flags & IFF_LOOPBACK) == 0) &&
685 	    ifp->if_carp == NULL && (dchg == 0);
686 
687 	/*
688 	 * Check for exact addresses in the hash bucket.
689 	 */
690 	CK_LIST_FOREACH(ia, INADDR_HASH(ip->ip_dst.s_addr), ia_hash) {
691 		if (IA_SIN(ia)->sin_addr.s_addr != ip->ip_dst.s_addr)
692 			continue;
693 
694 		/*
695 		 * net.inet.ip.rfc1122_strong_es: the address matches, verify
696 		 * that the packet arrived via the correct interface.
697 		 */
698 		if (__predict_false(strong_es && ia->ia_ifp != ifp)) {
699 			IPSTAT_INC(ips_badaddr);
700 			goto bad;
701 		}
702 
703 		/*
704 		 * net.inet.ip.source_address_validation: drop incoming
705 		 * packets that pretend to be ours.
706 		 */
707 		if (V_ip_sav && !(ifp->if_flags & IFF_LOOPBACK) &&
708 		    __predict_false(in_localip_fib(ip->ip_src, ifp->if_fib))) {
709 			IPSTAT_INC(ips_badaddr);
710 			goto bad;
711 		}
712 
713 		counter_u64_add(ia->ia_ifa.ifa_ipackets, 1);
714 		counter_u64_add(ia->ia_ifa.ifa_ibytes, m->m_pkthdr.len);
715 		goto ours;
716 	}
717 
718 	/*
719 	 * Check for broadcast addresses.
720 	 *
721 	 * Only accept broadcast packets that arrive via the matching
722 	 * interface.  Reception of forwarded directed broadcasts would
723 	 * be handled via ip_forward() and ether_output() with the loopback
724 	 * into the stack for SIMPLEX interfaces handled by ether_output().
725 	 */
726 	if (ifp->if_flags & IFF_BROADCAST) {
727 		CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
728 			if (ifa->ifa_addr->sa_family != AF_INET)
729 				continue;
730 			ia = ifatoia(ifa);
731 			if (satosin(&ia->ia_broadaddr)->sin_addr.s_addr ==
732 			    ip->ip_dst.s_addr) {
733 				counter_u64_add(ia->ia_ifa.ifa_ipackets, 1);
734 				counter_u64_add(ia->ia_ifa.ifa_ibytes,
735 				    m->m_pkthdr.len);
736 				goto ours;
737 			}
738 #ifdef BOOTP_COMPAT
739 			if (IA_SIN(ia)->sin_addr.s_addr == INADDR_ANY) {
740 				counter_u64_add(ia->ia_ifa.ifa_ipackets, 1);
741 				counter_u64_add(ia->ia_ifa.ifa_ibytes,
742 				    m->m_pkthdr.len);
743 				goto ours;
744 			}
745 #endif
746 		}
747 		ia = NULL;
748 	}
749 	if (IN_MULTICAST(ntohl(ip->ip_dst.s_addr))) {
750 		/*
751 		 * RFC 3927 2.7: Do not forward multicast packets from
752 		 * IN_LINKLOCAL.
753 		 */
754 		if (V_ip_mrouter && !IN_LINKLOCAL(ntohl(ip->ip_src.s_addr))) {
755 			/*
756 			 * If we are acting as a multicast router, all
757 			 * incoming multicast packets are passed to the
758 			 * kernel-level multicast forwarding function.
759 			 * The packet is returned (relatively) intact; if
760 			 * ip_mforward() returns a non-zero value, the packet
761 			 * must be discarded, else it may be accepted below.
762 			 */
763 			if (ip_mforward && ip_mforward(ip, ifp, m, 0) != 0) {
764 				IPSTAT_INC(ips_cantforward);
765 				m_freem(m);
766 				return;
767 			}
768 
769 			/*
770 			 * The process-level routing daemon needs to receive
771 			 * all multicast IGMP packets, whether or not this
772 			 * host belongs to their destination groups.
773 			 */
774 			if (ip->ip_p == IPPROTO_IGMP) {
775 				goto ours;
776 			}
777 			IPSTAT_INC(ips_forward);
778 		}
779 		/*
780 		 * Assume the packet is for us, to avoid prematurely taking
781 		 * a lock on the in_multi hash. Protocols must perform
782 		 * their own filtering and update statistics accordingly.
783 		 */
784 		goto ours;
785 	}
786 	if (ip->ip_dst.s_addr == (u_long)INADDR_BROADCAST)
787 		goto ours;
788 	if (ip->ip_dst.s_addr == INADDR_ANY)
789 		goto ours;
790 	/* RFC 3927 2.7: Do not forward packets to or from IN_LINKLOCAL. */
791 	if (IN_LINKLOCAL(ntohl(ip->ip_dst.s_addr)) ||
792 	    IN_LINKLOCAL(ntohl(ip->ip_src.s_addr))) {
793 		IPSTAT_INC(ips_cantforward);
794 		m_freem(m);
795 		return;
796 	}
797 
798 	/*
799 	 * Not for us; forward if possible and desirable.
800 	 */
801 	if (V_ipforwarding == 0) {
802 		IPSTAT_INC(ips_cantforward);
803 		m_freem(m);
804 	} else {
805 		ip_forward(m, dchg);
806 	}
807 	return;
808 
809 ours:
810 #ifdef IPSTEALTH
811 	/*
812 	 * IPSTEALTH: Process non-routing options only
813 	 * if the packet is destined for us.
814 	 */
815 	if (V_ipstealth && hlen > sizeof (struct ip) && ip_dooptions(m, 1))
816 		return;
817 #endif /* IPSTEALTH */
818 
819 	/*
820 	 * Attempt reassembly; if it succeeds, proceed.
821 	 * ip_reass() will return a different mbuf.
822 	 */
823 	if (ip->ip_off & htons(IP_MF | IP_OFFMASK)) {
824 		/* XXXGL: shouldn't we save & set m_flags? */
825 		m = ip_reass(m);
826 		if (m == NULL)
827 			return;
828 		ip = mtod(m, struct ip *);
829 		/* Get the header length of the reassembled packet */
830 		hlen = ip->ip_hl << 2;
831 	}
832 
833 #if defined(IPSEC) || defined(IPSEC_SUPPORT)
834 	if (IPSEC_ENABLED(ipv4)) {
835 		if (IPSEC_INPUT(ipv4, m, hlen, ip->ip_p) != 0)
836 			return;
837 	}
838 #endif /* IPSEC */
839 
840 	/*
841 	 * Switch out to protocol's input routine.
842 	 */
843 	IPSTAT_INC(ips_delivered);
844 
845 	ip_protox[ip->ip_p](&m, &hlen, ip->ip_p);
846 	return;
847 bad:
848 	m_freem(m);
849 }
850 
851 int
852 ipproto_register(uint8_t proto, ipproto_input_t input, ipproto_ctlinput_t ctl)
853 {
854 
855 	MPASS(proto > 0);
856 
857 	/*
858 	 * The protocol slot must not be occupied by another protocol
859 	 * already.  An index pointing to rip_input() is unused.
860 	 */
861 	if (ip_protox[proto] == rip_input) {
862 		ip_protox[proto] = input;
863 		ip_ctlprotox[proto] = ctl;
864 		return (0);
865 	} else
866 		return (EEXIST);
867 }
868 
869 int
870 ipproto_unregister(uint8_t proto)
871 {
872 
873 	MPASS(proto > 0);
874 
875 	if (ip_protox[proto] != rip_input) {
876 		ip_protox[proto] = rip_input;
877 		ip_ctlprotox[proto] = rip_ctlinput;
878 		return (0);
879 	} else
880 		return (ENOENT);
881 }
882 
883 /*
884  * Forward a packet.  If some error occurs return the sender
885  * an icmp packet.  Note we can't always generate a meaningful
886  * icmp message because icmp doesn't have a large enough repertoire
887  * of codes and types.
888  *
889  * If not forwarding, just drop the packet.  This could be confusing
890  * if ipforwarding was zero but some routing protocol was advancing
891  * us as a gateway to somewhere.  However, we must let the routing
892  * protocol deal with that.
893  *
894  * The srcrt parameter indicates whether the packet is being forwarded
895  * via a source route.
896  */
897 void
898 ip_forward(struct mbuf *m, int srcrt)
899 {
900 	struct ip *ip = mtod(m, struct ip *);
901 	struct in_ifaddr *ia;
902 	struct mbuf *mcopy;
903 	struct sockaddr_in *sin;
904 	struct in_addr dest;
905 	struct route ro;
906 	uint32_t flowid;
907 	int error, type = 0, code = 0, mtu = 0;
908 
909 	NET_EPOCH_ASSERT();
910 
911 	if (m->m_flags & (M_BCAST|M_MCAST) || in_canforward(ip->ip_dst) == 0) {
912 		IPSTAT_INC(ips_cantforward);
913 		m_freem(m);
914 		return;
915 	}
916 	if (
917 #ifdef IPSTEALTH
918 	    V_ipstealth == 0 &&
919 #endif
920 	    ip->ip_ttl <= IPTTLDEC) {
921 		icmp_error(m, ICMP_TIMXCEED, ICMP_TIMXCEED_INTRANS, 0, 0);
922 		return;
923 	}
924 
925 	bzero(&ro, sizeof(ro));
926 	sin = (struct sockaddr_in *)&ro.ro_dst;
927 	sin->sin_family = AF_INET;
928 	sin->sin_len = sizeof(*sin);
929 	sin->sin_addr = ip->ip_dst;
930 	flowid = m->m_pkthdr.flowid;
931 	ro.ro_nh = fib4_lookup(M_GETFIB(m), ip->ip_dst, 0, NHR_REF, flowid);
932 	if (ro.ro_nh != NULL) {
933 		ia = ifatoia(ro.ro_nh->nh_ifa);
934 	} else
935 		ia = NULL;
936 	/*
937 	 * Save the IP header and at most 8 bytes of the payload,
938 	 * in case we need to generate an ICMP message to the src.
939 	 *
940 	 * XXX this can be optimized a lot by saving the data in a local
941 	 * buffer on the stack (72 bytes at most), and only allocating the
942 	 * mbuf if really necessary. The vast majority of the packets
943 	 * are forwarded without having to send an ICMP back (either
944 	 * because unnecessary, or because rate limited), so we are
945 	 * really we are wasting a lot of work here.
946 	 *
947 	 * We don't use m_copym() because it might return a reference
948 	 * to a shared cluster. Both this function and ip_output()
949 	 * assume exclusive access to the IP header in `m', so any
950 	 * data in a cluster may change before we reach icmp_error().
951 	 */
952 	mcopy = m_gethdr(M_NOWAIT, m->m_type);
953 	if (mcopy != NULL && !m_dup_pkthdr(mcopy, m, M_NOWAIT)) {
954 		/*
955 		 * It's probably ok if the pkthdr dup fails (because
956 		 * the deep copy of the tag chain failed), but for now
957 		 * be conservative and just discard the copy since
958 		 * code below may some day want the tags.
959 		 */
960 		m_free(mcopy);
961 		mcopy = NULL;
962 	}
963 	if (mcopy != NULL) {
964 		mcopy->m_len = min(ntohs(ip->ip_len), M_TRAILINGSPACE(mcopy));
965 		mcopy->m_pkthdr.len = mcopy->m_len;
966 		m_copydata(m, 0, mcopy->m_len, mtod(mcopy, caddr_t));
967 	}
968 #ifdef IPSTEALTH
969 	if (V_ipstealth == 0)
970 #endif
971 		ip->ip_ttl -= IPTTLDEC;
972 #if defined(IPSEC) || defined(IPSEC_SUPPORT)
973 	if (IPSEC_ENABLED(ipv4)) {
974 		if ((error = IPSEC_FORWARD(ipv4, m)) != 0) {
975 			/* mbuf consumed by IPsec */
976 			RO_NHFREE(&ro);
977 			m_freem(mcopy);
978 			if (error != EINPROGRESS)
979 				IPSTAT_INC(ips_cantforward);
980 			return;
981 		}
982 		/* No IPsec processing required */
983 	}
984 #endif /* IPSEC */
985 	/*
986 	 * If forwarding packet using same interface that it came in on,
987 	 * perhaps should send a redirect to sender to shortcut a hop.
988 	 * Only send redirect if source is sending directly to us,
989 	 * and if packet was not source routed (or has any options).
990 	 * Also, don't send redirect if forwarding using a default route
991 	 * or a route modified by a redirect.
992 	 */
993 	dest.s_addr = 0;
994 	if (!srcrt && V_ipsendredirects &&
995 	    ia != NULL && ia->ia_ifp == m->m_pkthdr.rcvif) {
996 		struct nhop_object *nh;
997 
998 		nh = ro.ro_nh;
999 
1000 		if (nh != NULL && ((nh->nh_flags & (NHF_REDIRECT|NHF_DEFAULT)) == 0)) {
1001 			struct in_ifaddr *nh_ia = (struct in_ifaddr *)(nh->nh_ifa);
1002 			u_long src = ntohl(ip->ip_src.s_addr);
1003 
1004 			if (nh_ia != NULL &&
1005 			    (src & nh_ia->ia_subnetmask) == nh_ia->ia_subnet) {
1006 				/* Router requirements says to only send host redirects */
1007 				type = ICMP_REDIRECT;
1008 				code = ICMP_REDIRECT_HOST;
1009 				if (nh->nh_flags & NHF_GATEWAY) {
1010 				    if (nh->gw_sa.sa_family == AF_INET)
1011 					dest.s_addr = nh->gw4_sa.sin_addr.s_addr;
1012 				    else /* Do not redirect in case gw is AF_INET6 */
1013 					type = 0;
1014 				} else
1015 					dest.s_addr = ip->ip_dst.s_addr;
1016 			}
1017 		}
1018 	}
1019 
1020 	error = ip_output(m, NULL, &ro, IP_FORWARDING, NULL, NULL);
1021 
1022 	if (error == EMSGSIZE && ro.ro_nh)
1023 		mtu = ro.ro_nh->nh_mtu;
1024 	RO_NHFREE(&ro);
1025 
1026 	if (error)
1027 		IPSTAT_INC(ips_cantforward);
1028 	else {
1029 		IPSTAT_INC(ips_forward);
1030 		if (type)
1031 			IPSTAT_INC(ips_redirectsent);
1032 		else {
1033 			if (mcopy)
1034 				m_freem(mcopy);
1035 			return;
1036 		}
1037 	}
1038 	if (mcopy == NULL)
1039 		return;
1040 
1041 	switch (error) {
1042 	case 0:				/* forwarded, but need redirect */
1043 		/* type, code set above */
1044 		break;
1045 
1046 	case ENETUNREACH:
1047 	case EHOSTUNREACH:
1048 	case ENETDOWN:
1049 	case EHOSTDOWN:
1050 	default:
1051 		type = ICMP_UNREACH;
1052 		code = ICMP_UNREACH_HOST;
1053 		break;
1054 
1055 	case EMSGSIZE:
1056 		type = ICMP_UNREACH;
1057 		code = ICMP_UNREACH_NEEDFRAG;
1058 		/*
1059 		 * If the MTU was set before make sure we are below the
1060 		 * interface MTU.
1061 		 * If the MTU wasn't set before use the interface mtu or
1062 		 * fall back to the next smaller mtu step compared to the
1063 		 * current packet size.
1064 		 */
1065 		if (mtu != 0) {
1066 			if (ia != NULL)
1067 				mtu = min(mtu, ia->ia_ifp->if_mtu);
1068 		} else {
1069 			if (ia != NULL)
1070 				mtu = ia->ia_ifp->if_mtu;
1071 			else
1072 				mtu = ip_next_mtu(ntohs(ip->ip_len), 0);
1073 		}
1074 		IPSTAT_INC(ips_cantfrag);
1075 		break;
1076 
1077 	case ENOBUFS:
1078 	case EACCES:			/* ipfw denied packet */
1079 		m_freem(mcopy);
1080 		return;
1081 	}
1082 	icmp_error(mcopy, type, code, dest.s_addr, mtu);
1083 }
1084 
1085 #define	CHECK_SO_CT(sp, ct) \
1086     (((sp->so_options & SO_TIMESTAMP) && (sp->so_ts_clock == ct)) ? 1 : 0)
1087 
1088 void
1089 ip_savecontrol(struct inpcb *inp, struct mbuf **mp, struct ip *ip,
1090     struct mbuf *m)
1091 {
1092 	bool stamped;
1093 
1094 	stamped = false;
1095 	if ((inp->inp_socket->so_options & SO_BINTIME) ||
1096 	    CHECK_SO_CT(inp->inp_socket, SO_TS_BINTIME)) {
1097 		struct bintime boottimebin, bt;
1098 		struct timespec ts1;
1099 
1100 		if ((m->m_flags & (M_PKTHDR | M_TSTMP)) == (M_PKTHDR |
1101 		    M_TSTMP)) {
1102 			mbuf_tstmp2timespec(m, &ts1);
1103 			timespec2bintime(&ts1, &bt);
1104 			getboottimebin(&boottimebin);
1105 			bintime_add(&bt, &boottimebin);
1106 		} else {
1107 			bintime(&bt);
1108 		}
1109 		*mp = sbcreatecontrol(&bt, sizeof(bt), SCM_BINTIME,
1110 		    SOL_SOCKET, M_NOWAIT);
1111 		if (*mp != NULL) {
1112 			mp = &(*mp)->m_next;
1113 			stamped = true;
1114 		}
1115 	}
1116 	if (CHECK_SO_CT(inp->inp_socket, SO_TS_REALTIME_MICRO)) {
1117 		struct bintime boottimebin, bt1;
1118 		struct timespec ts1;
1119 		struct timeval tv;
1120 
1121 		if ((m->m_flags & (M_PKTHDR | M_TSTMP)) == (M_PKTHDR |
1122 		    M_TSTMP)) {
1123 			mbuf_tstmp2timespec(m, &ts1);
1124 			timespec2bintime(&ts1, &bt1);
1125 			getboottimebin(&boottimebin);
1126 			bintime_add(&bt1, &boottimebin);
1127 			bintime2timeval(&bt1, &tv);
1128 		} else {
1129 			microtime(&tv);
1130 		}
1131 		*mp = sbcreatecontrol((caddr_t)&tv, sizeof(tv), SCM_TIMESTAMP,
1132 		    SOL_SOCKET, M_NOWAIT);
1133 		if (*mp != NULL) {
1134 			mp = &(*mp)->m_next;
1135 			stamped = true;
1136 		}
1137 	} else if (CHECK_SO_CT(inp->inp_socket, SO_TS_REALTIME)) {
1138 		struct bintime boottimebin;
1139 		struct timespec ts, ts1;
1140 
1141 		if ((m->m_flags & (M_PKTHDR | M_TSTMP)) == (M_PKTHDR |
1142 		    M_TSTMP)) {
1143 			mbuf_tstmp2timespec(m, &ts);
1144 			getboottimebin(&boottimebin);
1145 			bintime2timespec(&boottimebin, &ts1);
1146 			timespecadd(&ts, &ts1, &ts);
1147 		} else {
1148 			nanotime(&ts);
1149 		}
1150 		*mp = sbcreatecontrol(&ts, sizeof(ts), SCM_REALTIME,
1151 		    SOL_SOCKET, M_NOWAIT);
1152 		if (*mp != NULL) {
1153 			mp = &(*mp)->m_next;
1154 			stamped = true;
1155 		}
1156 	} else if (CHECK_SO_CT(inp->inp_socket, SO_TS_MONOTONIC)) {
1157 		struct timespec ts;
1158 
1159 		if ((m->m_flags & (M_PKTHDR | M_TSTMP)) == (M_PKTHDR |
1160 		    M_TSTMP))
1161 			mbuf_tstmp2timespec(m, &ts);
1162 		else
1163 			nanouptime(&ts);
1164 		*mp = sbcreatecontrol(&ts, sizeof(ts), SCM_MONOTONIC,
1165 		    SOL_SOCKET, M_NOWAIT);
1166 		if (*mp != NULL) {
1167 			mp = &(*mp)->m_next;
1168 			stamped = true;
1169 		}
1170 	}
1171 	if (stamped && (m->m_flags & (M_PKTHDR | M_TSTMP)) == (M_PKTHDR |
1172 	    M_TSTMP)) {
1173 		struct sock_timestamp_info sti;
1174 
1175 		bzero(&sti, sizeof(sti));
1176 		sti.st_info_flags = ST_INFO_HW;
1177 		if ((m->m_flags & M_TSTMP_HPREC) != 0)
1178 			sti.st_info_flags |= ST_INFO_HW_HPREC;
1179 		*mp = sbcreatecontrol(&sti, sizeof(sti), SCM_TIME_INFO,
1180 		    SOL_SOCKET, M_NOWAIT);
1181 		if (*mp != NULL)
1182 			mp = &(*mp)->m_next;
1183 	}
1184 	if (inp->inp_flags & INP_RECVDSTADDR) {
1185 		*mp = sbcreatecontrol(&ip->ip_dst, sizeof(struct in_addr),
1186 		    IP_RECVDSTADDR, IPPROTO_IP, M_NOWAIT);
1187 		if (*mp)
1188 			mp = &(*mp)->m_next;
1189 	}
1190 	if (inp->inp_flags & INP_RECVTTL) {
1191 		*mp = sbcreatecontrol(&ip->ip_ttl, sizeof(u_char), IP_RECVTTL,
1192 		    IPPROTO_IP, M_NOWAIT);
1193 		if (*mp)
1194 			mp = &(*mp)->m_next;
1195 	}
1196 #ifdef notyet
1197 	/* XXX
1198 	 * Moving these out of udp_input() made them even more broken
1199 	 * than they already were.
1200 	 */
1201 	/* options were tossed already */
1202 	if (inp->inp_flags & INP_RECVOPTS) {
1203 		*mp = sbcreatecontrol(opts_deleted_above,
1204 		    sizeof(struct in_addr), IP_RECVOPTS, IPPROTO_IP, M_NOWAIT);
1205 		if (*mp)
1206 			mp = &(*mp)->m_next;
1207 	}
1208 	/* ip_srcroute doesn't do what we want here, need to fix */
1209 	if (inp->inp_flags & INP_RECVRETOPTS) {
1210 		*mp = sbcreatecontrol(ip_srcroute(m), sizeof(struct in_addr),
1211 		    IP_RECVRETOPTS, IPPROTO_IP, M_NOWAIT);
1212 		if (*mp)
1213 			mp = &(*mp)->m_next;
1214 	}
1215 #endif
1216 	if (inp->inp_flags & INP_RECVIF) {
1217 		struct ifnet *ifp;
1218 		struct sdlbuf {
1219 			struct sockaddr_dl sdl;
1220 			u_char	pad[32];
1221 		} sdlbuf;
1222 		struct sockaddr_dl *sdp;
1223 		struct sockaddr_dl *sdl2 = &sdlbuf.sdl;
1224 
1225 		if ((ifp = m->m_pkthdr.rcvif)) {
1226 			sdp = (struct sockaddr_dl *)ifp->if_addr->ifa_addr;
1227 			/*
1228 			 * Change our mind and don't try copy.
1229 			 */
1230 			if (sdp->sdl_family != AF_LINK ||
1231 			    sdp->sdl_len > sizeof(sdlbuf)) {
1232 				goto makedummy;
1233 			}
1234 			bcopy(sdp, sdl2, sdp->sdl_len);
1235 		} else {
1236 makedummy:
1237 			sdl2->sdl_len =
1238 			    offsetof(struct sockaddr_dl, sdl_data[0]);
1239 			sdl2->sdl_family = AF_LINK;
1240 			sdl2->sdl_index = 0;
1241 			sdl2->sdl_nlen = sdl2->sdl_alen = sdl2->sdl_slen = 0;
1242 		}
1243 		*mp = sbcreatecontrol(sdl2, sdl2->sdl_len, IP_RECVIF,
1244 		    IPPROTO_IP, M_NOWAIT);
1245 		if (*mp)
1246 			mp = &(*mp)->m_next;
1247 	}
1248 	if (inp->inp_flags & INP_RECVTOS) {
1249 		*mp = sbcreatecontrol(&ip->ip_tos, sizeof(u_char), IP_RECVTOS,
1250 		    IPPROTO_IP, M_NOWAIT);
1251 		if (*mp)
1252 			mp = &(*mp)->m_next;
1253 	}
1254 
1255 	if (inp->inp_flags2 & INP_RECVFLOWID) {
1256 		uint32_t flowid, flow_type;
1257 
1258 		flowid = m->m_pkthdr.flowid;
1259 		flow_type = M_HASHTYPE_GET(m);
1260 
1261 		/*
1262 		 * XXX should handle the failure of one or the
1263 		 * other - don't populate both?
1264 		 */
1265 		*mp = sbcreatecontrol(&flowid, sizeof(uint32_t), IP_FLOWID,
1266 		    IPPROTO_IP, M_NOWAIT);
1267 		if (*mp)
1268 			mp = &(*mp)->m_next;
1269 		*mp = sbcreatecontrol(&flow_type, sizeof(uint32_t),
1270 		    IP_FLOWTYPE, IPPROTO_IP, M_NOWAIT);
1271 		if (*mp)
1272 			mp = &(*mp)->m_next;
1273 	}
1274 
1275 #ifdef	RSS
1276 	if (inp->inp_flags2 & INP_RECVRSSBUCKETID) {
1277 		uint32_t flowid, flow_type;
1278 		uint32_t rss_bucketid;
1279 
1280 		flowid = m->m_pkthdr.flowid;
1281 		flow_type = M_HASHTYPE_GET(m);
1282 
1283 		if (rss_hash2bucket(flowid, flow_type, &rss_bucketid) == 0) {
1284 			*mp = sbcreatecontrol(&rss_bucketid, sizeof(uint32_t),
1285 			    IP_RSSBUCKETID, IPPROTO_IP, M_NOWAIT);
1286 			if (*mp)
1287 				mp = &(*mp)->m_next;
1288 		}
1289 	}
1290 #endif
1291 }
1292 
1293 /*
1294  * XXXRW: Multicast routing code in ip_mroute.c is generally MPSAFE, but the
1295  * ip_rsvp and ip_rsvp_on variables need to be interlocked with rsvp_on
1296  * locking.  This code remains in ip_input.c as ip_mroute.c is optionally
1297  * compiled.
1298  */
1299 VNET_DEFINE_STATIC(int, ip_rsvp_on);
1300 VNET_DEFINE(struct socket *, ip_rsvpd);
1301 
1302 #define	V_ip_rsvp_on		VNET(ip_rsvp_on)
1303 
1304 int
1305 ip_rsvp_init(struct socket *so)
1306 {
1307 
1308 	if (V_ip_rsvpd != NULL)
1309 		return EADDRINUSE;
1310 
1311 	V_ip_rsvpd = so;
1312 	/*
1313 	 * This may seem silly, but we need to be sure we don't over-increment
1314 	 * the RSVP counter, in case something slips up.
1315 	 */
1316 	if (!V_ip_rsvp_on) {
1317 		V_ip_rsvp_on = 1;
1318 		V_rsvp_on++;
1319 	}
1320 
1321 	return 0;
1322 }
1323 
1324 int
1325 ip_rsvp_done(void)
1326 {
1327 
1328 	V_ip_rsvpd = NULL;
1329 	/*
1330 	 * This may seem silly, but we need to be sure we don't over-decrement
1331 	 * the RSVP counter, in case something slips up.
1332 	 */
1333 	if (V_ip_rsvp_on) {
1334 		V_ip_rsvp_on = 0;
1335 		V_rsvp_on--;
1336 	}
1337 	return 0;
1338 }
1339 
1340 int
1341 rsvp_input(struct mbuf **mp, int *offp, int proto)
1342 {
1343 	struct mbuf *m;
1344 
1345 	m = *mp;
1346 	*mp = NULL;
1347 
1348 	if (rsvp_input_p) { /* call the real one if loaded */
1349 		*mp = m;
1350 		rsvp_input_p(mp, offp, proto);
1351 		return (IPPROTO_DONE);
1352 	}
1353 
1354 	/* Can still get packets with rsvp_on = 0 if there is a local member
1355 	 * of the group to which the RSVP packet is addressed.  But in this
1356 	 * case we want to throw the packet away.
1357 	 */
1358 
1359 	if (!V_rsvp_on) {
1360 		m_freem(m);
1361 		return (IPPROTO_DONE);
1362 	}
1363 
1364 	if (V_ip_rsvpd != NULL) {
1365 		*mp = m;
1366 		rip_input(mp, offp, proto);
1367 		return (IPPROTO_DONE);
1368 	}
1369 	/* Drop the packet */
1370 	m_freem(m);
1371 	return (IPPROTO_DONE);
1372 }
1373