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