ip_input.c revision 1.405 1 /* $NetBSD: ip_input.c,v 1.405 2025/06/17 04:23:57 ozaki-r Exp $ */
2
3 /*
4 * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
5 * 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 project 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 PROJECT 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 PROJECT 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 /*
33 * Copyright (c) 1998 The NetBSD Foundation, Inc.
34 * All rights reserved.
35 *
36 * This code is derived from software contributed to The NetBSD Foundation
37 * by Public Access Networks Corporation ("Panix"). It was developed under
38 * contract to Panix by Eric Haszlakiewicz and Thor Lancelot Simon.
39 *
40 * Redistribution and use in source and binary forms, with or without
41 * modification, are permitted provided that the following conditions
42 * are met:
43 * 1. Redistributions of source code must retain the above copyright
44 * notice, this list of conditions and the following disclaimer.
45 * 2. Redistributions in binary form must reproduce the above copyright
46 * notice, this list of conditions and the following disclaimer in the
47 * documentation and/or other materials provided with the distribution.
48 *
49 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
50 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
51 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
52 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
53 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
54 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
55 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
56 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
57 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
58 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
59 * POSSIBILITY OF SUCH DAMAGE.
60 */
61
62 /*
63 * Copyright (c) 1982, 1986, 1988, 1993
64 * The Regents of the University of California. All rights reserved.
65 *
66 * Redistribution and use in source and binary forms, with or without
67 * modification, are permitted provided that the following conditions
68 * are met:
69 * 1. Redistributions of source code must retain the above copyright
70 * notice, this list of conditions and the following disclaimer.
71 * 2. Redistributions in binary form must reproduce the above copyright
72 * notice, this list of conditions and the following disclaimer in the
73 * documentation and/or other materials provided with the distribution.
74 * 3. Neither the name of the University nor the names of its contributors
75 * may be used to endorse or promote products derived from this software
76 * without specific prior written permission.
77 *
78 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
79 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
80 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
81 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
82 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
83 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
84 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
85 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
86 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
87 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
88 * SUCH DAMAGE.
89 *
90 * @(#)ip_input.c 8.2 (Berkeley) 1/4/94
91 */
92
93 #include <sys/cdefs.h>
94 __KERNEL_RCSID(0, "$NetBSD: ip_input.c,v 1.405 2025/06/17 04:23:57 ozaki-r Exp $");
95
96 #ifdef _KERNEL_OPT
97 #include "opt_inet.h"
98 #include "opt_gateway.h"
99 #include "opt_ipsec.h"
100 #include "opt_mrouting.h"
101 #include "opt_mbuftrace.h"
102 #include "opt_inet_csum.h"
103 #include "opt_net_mpsafe.h"
104 #endif
105
106 #include "arp.h"
107
108 #include <sys/param.h>
109 #include <sys/systm.h>
110 #include <sys/cpu.h>
111 #include <sys/mbuf.h>
112 #include <sys/domain.h>
113 #include <sys/protosw.h>
114 #include <sys/socket.h>
115 #include <sys/socketvar.h>
116 #include <sys/errno.h>
117 #include <sys/time.h>
118 #include <sys/kernel.h>
119 #include <sys/pool.h>
120 #include <sys/sysctl.h>
121 #include <sys/kauth.h>
122
123 #include <net/if.h>
124 #include <net/if_dl.h>
125 #include <net/if_types.h>
126 #include <net/route.h>
127 #include <net/pktqueue.h>
128 #include <net/pfil.h>
129
130 #include <netinet/in.h>
131 #include <netinet/in_systm.h>
132 #include <netinet/ip.h>
133 #include <netinet/in_pcb.h>
134 #include <netinet/in_proto.h>
135 #include <netinet/in_var.h>
136 #include <netinet/ip_var.h>
137 #include <netinet/ip_private.h>
138 #include <netinet/ip_icmp.h>
139 /* just for gif_ttl */
140 #include <netinet/in_gif.h>
141 #include "gif.h"
142 #include <net/if_gre.h>
143 #include "gre.h"
144
145 #ifdef MROUTING
146 #include <netinet/ip_mroute.h>
147 #endif
148 #include <netinet/portalgo.h>
149
150 #ifdef IPSEC
151 #include <netipsec/ipsec.h>
152 #endif
153
154 #ifndef IPFORWARDING
155 #ifdef GATEWAY
156 #define IPFORWARDING 1 /* forward IP packets not for us */
157 #else
158 #define IPFORWARDING 0 /* don't forward IP packets not for us */
159 #endif
160 #endif
161
162 #define IPMTUDISCTIMEOUT (10 * 60) /* as per RFC 1191 */
163
164 int ipforwarding = IPFORWARDING;
165 int ipsendredirects = 1;
166 int ip_defttl = IPDEFTTL;
167 int ip_forwsrcrt = 0;
168 int ip_directedbcast = 0;
169 int ip_allowsrcrt = 0;
170 int ip_mtudisc = 1;
171 int ip_mtudisc_timeout = IPMTUDISCTIMEOUT;
172 int ip_do_randomid = 1;
173
174 /*
175 * XXX - Setting ip_checkinterface mostly implements the receive side of
176 * the Strong ES model described in RFC 1122, but since the routing table
177 * and transmit implementation do not implement the Strong ES model,
178 * setting this to 1 results in an odd hybrid.
179 *
180 * XXX - ip_checkinterface currently must be disabled if you use NAT
181 * to translate the destination address to another local interface.
182 *
183 * XXX - ip_checkinterface must be disabled if you add IP aliases
184 * to the loopback interface instead of the interface where the
185 * packets for those addresses are received.
186 */
187 static int ip_checkinterface __read_mostly = 0;
188
189 struct rttimer_queue *ip_mtudisc_timeout_q = NULL;
190
191 pktqueue_t * ip_pktq __read_mostly;
192 pfil_head_t * inet_pfil_hook __read_mostly;
193 percpu_t * ipstat_percpu __read_mostly;
194
195 static percpu_t *ipforward_rt_percpu __cacheline_aligned;
196
197 uint16_t ip_id;
198
199 #ifdef INET_CSUM_COUNTERS
200 #include <sys/device.h>
201
202 struct evcnt ip_hwcsum_bad = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
203 NULL, "inet", "hwcsum bad");
204 struct evcnt ip_hwcsum_ok = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
205 NULL, "inet", "hwcsum ok");
206 struct evcnt ip_swcsum = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
207 NULL, "inet", "swcsum");
208
209 #define INET_CSUM_COUNTER_INCR(ev) (ev)->ev_count++
210
211 EVCNT_ATTACH_STATIC(ip_hwcsum_bad);
212 EVCNT_ATTACH_STATIC(ip_hwcsum_ok);
213 EVCNT_ATTACH_STATIC(ip_swcsum);
214
215 #else
216
217 #define INET_CSUM_COUNTER_INCR(ev) /* nothing */
218
219 #endif /* INET_CSUM_COUNTERS */
220
221 /*
222 * Used to save the IP options in case a protocol wants to respond
223 * to an incoming packet over the same route if the packet got here
224 * using IP source routing. This allows connection establishment and
225 * maintenance when the remote end is on a network that is not known
226 * to us.
227 */
228 struct ip_srcrt {
229 int isr_nhops; /* number of hops */
230 struct in_addr isr_dst; /* final destination */
231 char isr_nop; /* one NOP to align */
232 char isr_hdr[IPOPT_OFFSET + 1]; /* OPTVAL, OLEN & OFFSET */
233 struct in_addr isr_routes[MAX_IPOPTLEN/sizeof(struct in_addr)];
234 };
235
236 static int ip_drainwanted;
237
238 static void save_rte(struct mbuf *, u_char *, struct in_addr);
239
240 #ifdef MBUFTRACE
241 struct mowner ip_rx_mowner = MOWNER_INIT("internet", "rx");
242 struct mowner ip_tx_mowner = MOWNER_INIT("internet", "tx");
243 #endif
244
245 static void ipintr(void *);
246 static void ip_input(struct mbuf *, struct ifnet *);
247 static void ip_forward(struct mbuf *, int, struct ifnet *);
248 static bool ip_dooptions(struct mbuf *);
249 static struct in_ifaddr *ip_rtaddr(struct in_addr, struct psref *);
250 static void sysctl_net_inet_ip_setup(struct sysctllog **);
251
252 static struct in_ifaddr *ip_match_our_address(struct ifnet *, struct ip *,
253 int *);
254 static struct in_ifaddr *ip_match_our_address_broadcast(struct ifnet *,
255 struct ip *);
256
257 #ifdef NET_MPSAFE
258 #define SOFTNET_LOCK() mutex_enter(softnet_lock)
259 #define SOFTNET_UNLOCK() mutex_exit(softnet_lock)
260 #else
261 #define SOFTNET_LOCK() KASSERT(mutex_owned(softnet_lock))
262 #define SOFTNET_UNLOCK() KASSERT(mutex_owned(softnet_lock))
263 #endif
264
265 /*
266 * IP initialization: fill in IP protocol switch table.
267 * All protocols not implemented in kernel go to raw IP protocol handler.
268 */
269 void
270 ip_init(void)
271 {
272 const struct protosw *pr;
273
274 ip_pktq = pktq_create(IFQ_MAXLEN, ipintr, NULL);
275 KASSERT(ip_pktq != NULL);
276
277 in_init();
278 sysctl_net_inet_ip_setup(NULL);
279
280 pr = pffindproto(PF_INET, IPPROTO_RAW, SOCK_RAW);
281 KASSERT(pr != NULL);
282
283 for (u_int i = 0; i < IPPROTO_MAX; i++) {
284 ip_protox[i] = pr - inetsw;
285 }
286 for (pr = inetdomain.dom_protosw;
287 pr < inetdomain.dom_protoswNPROTOSW; pr++)
288 if (pr->pr_domain->dom_family == PF_INET &&
289 pr->pr_protocol && pr->pr_protocol != IPPROTO_RAW)
290 ip_protox[pr->pr_protocol] = pr - inetsw;
291
292 ip_reass_init();
293
294 ip_id = time_uptime & 0xfffff;
295
296 #ifdef GATEWAY
297 ipflow_init();
298 #endif
299
300 /* Register our Packet Filter hook. */
301 inet_pfil_hook = pfil_head_create(PFIL_TYPE_AF, (void *)AF_INET);
302 KASSERT(inet_pfil_hook != NULL);
303
304 #ifdef MBUFTRACE
305 MOWNER_ATTACH(&ip_tx_mowner);
306 MOWNER_ATTACH(&ip_rx_mowner);
307 #endif
308
309 ipstat_percpu = percpu_alloc(sizeof(uint64_t) * IP_NSTATS);
310 ipforward_rt_percpu = rtcache_percpu_alloc();
311 ip_mtudisc_timeout_q = rt_timer_queue_create(ip_mtudisc_timeout);
312 }
313
314 static struct in_ifaddr *
315 ip_match_our_address(struct ifnet *ifp, struct ip *ip, int *downmatch)
316 {
317 struct in_ifaddr *ia = NULL;
318 int checkif;
319
320 /*
321 * Enable a consistency check between the destination address
322 * and the arrival interface for a unicast packet (the RFC 1122
323 * strong ES model) if IP forwarding is disabled and the packet
324 * is not locally generated.
325 *
326 * XXX - We need to add a per ifaddr flag for this so that
327 * we get finer grain control.
328 */
329 checkif = ip_checkinterface && (ipforwarding == 0) &&
330 (ifp->if_flags & IFF_LOOPBACK) == 0;
331
332 IN_ADDRHASH_READER_FOREACH(ia, ip->ip_dst.s_addr) {
333 if (in_hosteq(ia->ia_addr.sin_addr, ip->ip_dst)) {
334 if (ia->ia4_flags & IN_IFF_NOTREADY)
335 continue;
336 if (checkif && ia->ia_ifp != ifp)
337 continue;
338 if ((ia->ia_ifp->if_flags & IFF_UP) == 0) {
339 (*downmatch)++;
340 continue;
341 }
342 if (ia->ia4_flags & IN_IFF_DETACHED &&
343 (ifp->if_flags & IFF_LOOPBACK) == 0)
344 continue;
345 break;
346 }
347 }
348
349 return ia;
350 }
351
352 static struct in_ifaddr *
353 ip_match_our_address_broadcast(struct ifnet *ifp, struct ip *ip)
354 {
355 struct in_ifaddr *ia = NULL;
356 struct ifaddr *ifa;
357
358 IFADDR_READER_FOREACH(ifa, ifp) {
359 if (ifa->ifa_addr->sa_family != AF_INET)
360 continue;
361 ia = ifatoia(ifa);
362 if (ia->ia4_flags & IN_IFF_NOTREADY)
363 continue;
364 if (ia->ia4_flags & IN_IFF_DETACHED &&
365 (ifp->if_flags & IFF_LOOPBACK) == 0)
366 continue;
367 if (in_hosteq(ip->ip_dst, ia->ia_broadaddr.sin_addr) ||
368 in_hosteq(ip->ip_dst, ia->ia_netbroadcast) ||
369 /*
370 * Look for all-0's host part (old broadcast addr),
371 * either for subnet or net.
372 */
373 ip->ip_dst.s_addr == ia->ia_subnet ||
374 ip->ip_dst.s_addr == ia->ia_net)
375 goto matched;
376 /*
377 * An interface with IP address zero accepts
378 * all packets that arrive on that interface.
379 */
380 if (in_nullhost(ia->ia_addr.sin_addr))
381 goto matched;
382 }
383 ia = NULL;
384
385 matched:
386 return ia;
387 }
388
389 /*
390 * IP software interrupt routine.
391 */
392 static void
393 ipintr(void *arg __unused)
394 {
395 struct mbuf *m;
396
397 KASSERT(cpu_softintr_p());
398
399 SOFTNET_KERNEL_LOCK_UNLESS_NET_MPSAFE();
400 while ((m = pktq_dequeue(ip_pktq)) != NULL) {
401 struct ifnet *ifp;
402 struct psref psref;
403
404 ifp = m_get_rcvif_psref(m, &psref);
405 if (__predict_false(ifp == NULL)) {
406 IP_STATINC(IP_STAT_IFDROP);
407 m_freem(m);
408 continue;
409 }
410
411 ip_input(m, ifp);
412
413 m_put_rcvif_psref(ifp, &psref);
414 }
415 SOFTNET_KERNEL_UNLOCK_UNLESS_NET_MPSAFE();
416 }
417
418 /*
419 * IP input routine. Checksum and byte swap header. If fragmented
420 * try to reassemble. Process options. Pass to next level.
421 */
422 static void
423 ip_input(struct mbuf *m, struct ifnet *ifp)
424 {
425 struct ip *ip = NULL;
426 struct in_ifaddr *ia = NULL;
427 int hlen = 0, len;
428 int downmatch;
429 int srcrt = 0;
430 int s;
431
432 KASSERTMSG(cpu_softintr_p(), "ip_input: not in the software "
433 "interrupt handler; synchronization assumptions violated");
434
435 MCLAIM(m, &ip_rx_mowner);
436 KASSERT((m->m_flags & M_PKTHDR) != 0);
437
438 /*
439 * If no IP addresses have been set yet but the interfaces
440 * are receiving, can't do anything with incoming packets yet.
441 * Note: we pre-check without locks held.
442 */
443 if (IN_ADDRLIST_READER_EMPTY()) {
444 IP_STATINC(IP_STAT_IFDROP);
445 goto out;
446 }
447
448 IP_STATINC(IP_STAT_TOTAL);
449
450 /*
451 * If the IP header is not aligned, slurp it up into a new
452 * mbuf with space for link headers, in the event we forward
453 * it. Otherwise, if it is aligned, make sure the entire
454 * base IP header is in the first mbuf of the chain.
455 */
456 if (M_GET_ALIGNED_HDR(&m, struct ip, true) != 0) {
457 /* XXXJRT new stat, please */
458 IP_STATINC(IP_STAT_TOOSMALL);
459 goto out;
460 }
461 ip = mtod(m, struct ip *);
462 if (ip->ip_v != IPVERSION) {
463 IP_STATINC(IP_STAT_BADVERS);
464 goto out;
465 }
466 hlen = ip->ip_hl << 2;
467 if (hlen < sizeof(struct ip)) { /* minimum header length */
468 IP_STATINC(IP_STAT_BADHLEN);
469 goto out;
470 }
471 if (hlen > m->m_len) {
472 if ((m = m_pullup(m, hlen)) == NULL) {
473 IP_STATINC(IP_STAT_BADHLEN);
474 goto out;
475 }
476 ip = mtod(m, struct ip *);
477 }
478
479 /*
480 * RFC1122: packets with a multicast source address are
481 * not allowed.
482 */
483 if (IN_MULTICAST(ip->ip_src.s_addr)) {
484 IP_STATINC(IP_STAT_BADADDR);
485 goto out;
486 }
487
488 /* 127/8 must not appear on wire - RFC1122 */
489 if ((ntohl(ip->ip_dst.s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET ||
490 (ntohl(ip->ip_src.s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET) {
491 if ((ifp->if_flags & IFF_LOOPBACK) == 0) {
492 IP_STATINC(IP_STAT_BADADDR);
493 goto out;
494 }
495 }
496
497 switch (m->m_pkthdr.csum_flags &
498 ((ifp->if_csum_flags_rx & M_CSUM_IPv4) | M_CSUM_IPv4_BAD)) {
499 case M_CSUM_IPv4|M_CSUM_IPv4_BAD:
500 INET_CSUM_COUNTER_INCR(&ip_hwcsum_bad);
501 IP_STATINC(IP_STAT_BADSUM);
502 goto out;
503
504 case M_CSUM_IPv4:
505 /* Checksum was okay. */
506 INET_CSUM_COUNTER_INCR(&ip_hwcsum_ok);
507 break;
508
509 default:
510 /*
511 * Must compute it ourselves. Maybe skip checksum on
512 * loopback interfaces.
513 */
514 if (__predict_true(!(ifp->if_flags & IFF_LOOPBACK) ||
515 ip_do_loopback_cksum)) {
516 INET_CSUM_COUNTER_INCR(&ip_swcsum);
517 if (in_cksum(m, hlen) != 0) {
518 IP_STATINC(IP_STAT_BADSUM);
519 goto out;
520 }
521 }
522 break;
523 }
524
525 /* Retrieve the packet length. */
526 len = ntohs(ip->ip_len);
527
528 /*
529 * Check for additional length bogosity
530 */
531 if (len < hlen) {
532 IP_STATINC(IP_STAT_BADLEN);
533 goto out;
534 }
535
536 /*
537 * Check that the amount of data in the buffers is at least as much
538 * as the IP header would have us expect. Trim mbufs if longer than
539 * we expect. Drop packet if shorter than we expect.
540 */
541 if (m->m_pkthdr.len < len) {
542 IP_STATINC(IP_STAT_TOOSHORT);
543 goto out;
544 }
545 if (m->m_pkthdr.len > len) {
546 if (m->m_len == m->m_pkthdr.len) {
547 m->m_len = len;
548 m->m_pkthdr.len = len;
549 } else
550 m_adj(m, len - m->m_pkthdr.len);
551 }
552
553 /*
554 * Assume that we can create a fast-forward IP flow entry
555 * based on this packet.
556 */
557 m->m_flags |= M_CANFASTFWD;
558
559 /*
560 * Run through list of hooks for input packets. If there are any
561 * filters which require that additional packets in the flow are
562 * not fast-forwarded, they must clear the M_CANFASTFWD flag.
563 * Note that filters must _never_ set this flag, as another filter
564 * in the list may have previously cleared it.
565 *
566 * Don't call hooks if the packet has already been processed by
567 * IPsec (encapsulated, tunnel mode).
568 */
569 #if defined(IPSEC)
570 if (!ipsec_used || !ipsec_skip_pfil(m))
571 #else
572 if (1)
573 #endif
574 {
575 struct in_addr odst = ip->ip_dst;
576 bool freed;
577
578 freed = pfil_run_hooks(inet_pfil_hook, &m, ifp, PFIL_IN) != 0;
579 if (freed || m == NULL) {
580 m = NULL;
581 IP_STATINC(IP_STAT_PFILDROP_IN);
582 goto out;
583 }
584 if (__predict_false(m->m_len < sizeof(struct ip))) {
585 if ((m = m_pullup(m, sizeof(struct ip))) == NULL) {
586 IP_STATINC(IP_STAT_TOOSMALL);
587 goto out;
588 }
589 }
590 ip = mtod(m, struct ip *);
591 hlen = ip->ip_hl << 2;
592 if (hlen < sizeof(struct ip)) { /* minimum header length */
593 IP_STATINC(IP_STAT_BADHLEN);
594 goto out;
595 }
596 if (hlen > m->m_len) {
597 if ((m = m_pullup(m, hlen)) == NULL) {
598 IP_STATINC(IP_STAT_BADHLEN);
599 goto out;
600 }
601 ip = mtod(m, struct ip *);
602 }
603
604 /*
605 * XXX The setting of "srcrt" here is to prevent ip_forward()
606 * from generating ICMP redirects for packets that have
607 * been redirected by a hook back out on to the same LAN that
608 * they came from and is not an indication that the packet
609 * is being influenced by source routing options. This
610 * allows things like
611 * "rdr tlp0 0/0 port 80 -> 1.1.1.200 3128 tcp"
612 * where tlp0 is both on the 1.1.1.0/24 network and is the
613 * default route for hosts on 1.1.1.0/24. Of course this
614 * also requires a "map tlp0 ..." to complete the story.
615 * One might argue whether or not this kind of network config.
616 * should be supported in this manner...
617 */
618 srcrt = (odst.s_addr != ip->ip_dst.s_addr);
619 }
620
621 #ifdef ALTQ
622 /* XXX Temporary until ALTQ is changed to use a pfil hook */
623 if (altq_input) {
624 SOFTNET_LOCK();
625 if ((*altq_input)(m, AF_INET) == 0) {
626 /* Packet dropped by traffic conditioner. */
627 SOFTNET_UNLOCK();
628 m = NULL;
629 goto out;
630 }
631 SOFTNET_UNLOCK();
632 }
633 #endif
634
635 /*
636 * Process options and, if not destined for us,
637 * ship it on. ip_dooptions returns 1 when an
638 * error was detected (causing an icmp message
639 * to be sent and the original packet to be freed).
640 */
641 if (hlen > sizeof(struct ip) && ip_dooptions(m)) {
642 m = NULL;
643 goto out;
644 }
645
646 /*
647 * Check our list of addresses, to see if the packet is for us.
648 *
649 * Traditional 4.4BSD did not consult IFF_UP at all.
650 * The behavior here is to treat addresses on !IFF_UP interface
651 * or IN_IFF_NOTREADY addresses as not mine.
652 */
653 downmatch = 0;
654 s = pserialize_read_enter();
655 ia = ip_match_our_address(ifp, ip, &downmatch);
656 if (ia != NULL) {
657 pserialize_read_exit(s);
658 goto ours;
659 }
660
661 if (ifp->if_flags & IFF_BROADCAST) {
662 ia = ip_match_our_address_broadcast(ifp, ip);
663 if (ia != NULL) {
664 pserialize_read_exit(s);
665 goto ours;
666 }
667 }
668 pserialize_read_exit(s);
669
670 if (IN_MULTICAST(ip->ip_dst.s_addr)) {
671 #ifdef MROUTING
672 extern struct socket *ip_mrouter;
673
674 if (ip_mrouter) {
675 /*
676 * If we are acting as a multicast router, all
677 * incoming multicast packets are passed to the
678 * kernel-level multicast forwarding function.
679 * The packet is returned (relatively) intact; if
680 * ip_mforward() returns a non-zero value, the packet
681 * must be discarded, else it may be accepted below.
682 *
683 * (The IP ident field is put in the same byte order
684 * as expected when ip_mforward() is called from
685 * ip_output().)
686 */
687 SOFTNET_LOCK();
688 if (ip_mforward(m, ifp) != 0) {
689 SOFTNET_UNLOCK();
690 IP_STATINC(IP_STAT_CANTFORWARD);
691 goto out;
692 }
693 SOFTNET_UNLOCK();
694
695 /*
696 * The process-level routing demon needs to receive
697 * all multicast IGMP packets, whether or not this
698 * host belongs to their destination groups.
699 */
700 if (ip->ip_p == IPPROTO_IGMP) {
701 goto ours;
702 }
703 IP_STATINC(IP_STAT_CANTFORWARD);
704 }
705 #endif
706 /*
707 * See if we belong to the destination multicast group on the
708 * arrival interface.
709 */
710 if (!in_multi_group(ip->ip_dst, ifp, 0)) {
711 IP_STATINC(IP_STAT_CANTFORWARD);
712 goto out;
713 }
714 goto ours;
715 }
716 if (ip->ip_dst.s_addr == INADDR_BROADCAST ||
717 in_nullhost(ip->ip_dst))
718 goto ours;
719
720 /*
721 * Not for us; forward if possible and desirable.
722 */
723 if (ipforwarding == 0) {
724 IP_STATINC(IP_STAT_CANTFORWARD);
725 m_freem(m);
726 } else {
727 /*
728 * If ip_dst matched any of my address on !IFF_UP interface,
729 * and there's no IFF_UP interface that matches ip_dst,
730 * send icmp unreach. Forwarding it will result in in-kernel
731 * forwarding loop till TTL goes to 0.
732 */
733 if (downmatch) {
734 icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_HOST, 0, 0);
735 IP_STATINC(IP_STAT_CANTFORWARD);
736 return;
737 }
738 #ifdef IPSEC
739 /* Check the security policy (SP) for the packet */
740 if (ipsec_used) {
741 if (ipsec_ip_input_checkpolicy(m, true) != 0) {
742 IP_STATINC(IP_STAT_IPSECDROP_IN);
743 goto out;
744 }
745 }
746 #endif
747 ip_forward(m, srcrt, ifp);
748 }
749 return;
750
751 ours:
752 /*
753 * If offset or IP_MF are set, must reassemble.
754 */
755 if (ip->ip_off & ~htons(IP_DF|IP_RF)) {
756 /*
757 * Pass to IP reassembly mechanism.
758 */
759 if (ip_reass_packet(&m) != 0) {
760 /* Failed; invalid fragment(s) or packet. */
761 goto out;
762 }
763 if (m == NULL) {
764 /* More fragments should come; silently return. */
765 goto out;
766 }
767 /*
768 * Reassembly is done, we have the final packet.
769 * Update cached data in local variable(s).
770 */
771 ip = mtod(m, struct ip *);
772 hlen = ip->ip_hl << 2;
773 }
774
775 M_VERIFY_PACKET(m);
776
777 #ifdef IPSEC
778 /*
779 * Enforce IPsec policy checking if we are seeing last header.
780 * Note that we do not visit this with protocols with PCB layer
781 * code - like UDP/TCP/raw IP.
782 */
783 if (ipsec_used &&
784 (inetsw[ip_protox[ip->ip_p]].pr_flags & PR_LASTHDR) != 0) {
785 if (ipsec_ip_input_checkpolicy(m, false) != 0) {
786 IP_STATINC(IP_STAT_IPSECDROP_IN);
787 goto out;
788 }
789 }
790 #endif
791
792 /*
793 * Switch out to protocol's input routine.
794 */
795 #if IFA_STATS
796 if (ia) {
797 struct in_ifaddr *_ia;
798 /*
799 * Keep a reference from ip_match_our_address with psref
800 * is expensive, so explore ia here again.
801 */
802 s = pserialize_read_enter();
803 _ia = in_get_ia(ip->ip_dst);
804 _ia->ia_ifa.ifa_data.ifad_inbytes += ntohs(ip->ip_len);
805 pserialize_read_exit(s);
806 }
807 #endif
808 IP_STATINC(IP_STAT_DELIVERED);
809
810 const int off = hlen, nh = ip->ip_p;
811
812 (*inetsw[ip_protox[nh]].pr_input)(m, off, nh);
813 return;
814
815 out:
816 m_freem(m);
817 }
818
819 /*
820 * IP timer processing.
821 */
822 void
823 ip_slowtimo(void)
824 {
825
826 SOFTNET_KERNEL_LOCK_UNLESS_NET_MPSAFE();
827
828 ip_reass_slowtimo();
829
830 SOFTNET_KERNEL_UNLOCK_UNLESS_NET_MPSAFE();
831 }
832
833 /*
834 * IP drain processing.
835 */
836 void
837 ip_drain(void)
838 {
839
840 KERNEL_LOCK(1, NULL);
841 ip_reass_drain();
842 KERNEL_UNLOCK_ONE(NULL);
843 }
844
845 /*
846 * ip_dooptions: perform option processing on a datagram, possibly discarding
847 * it if bad options are encountered, or forwarding it if source-routed.
848 *
849 * => Returns true if packet has been forwarded/freed.
850 * => Returns false if the packet should be processed further.
851 */
852 static bool
853 ip_dooptions(struct mbuf *m)
854 {
855 struct ip *ip = mtod(m, struct ip *);
856 u_char *cp, *cp0;
857 struct ip_timestamp *ipt;
858 struct in_ifaddr *ia;
859 int opt, optlen, cnt, off, code, type = ICMP_PARAMPROB, forward = 0;
860 int srr_present, rr_present, ts_present;
861 struct in_addr dst;
862 n_time ntime;
863 struct ifaddr *ifa = NULL;
864 int s;
865
866 srr_present = 0;
867 rr_present = 0;
868 ts_present = 0;
869
870 dst = ip->ip_dst;
871 cp = (u_char *)(ip + 1);
872 cnt = (ip->ip_hl << 2) - sizeof(struct ip);
873 for (; cnt > 0; cnt -= optlen, cp += optlen) {
874 opt = cp[IPOPT_OPTVAL];
875 if (opt == IPOPT_EOL)
876 break;
877 if (opt == IPOPT_NOP)
878 optlen = 1;
879 else {
880 if (cnt < IPOPT_OLEN + sizeof(*cp)) {
881 code = &cp[IPOPT_OLEN] - (u_char *)ip;
882 goto bad;
883 }
884 optlen = cp[IPOPT_OLEN];
885 if (optlen < IPOPT_OLEN + sizeof(*cp) || optlen > cnt) {
886 code = &cp[IPOPT_OLEN] - (u_char *)ip;
887 goto bad;
888 }
889 }
890 switch (opt) {
891
892 default:
893 break;
894
895 /*
896 * Source routing with record.
897 * Find interface with current destination address.
898 * If none on this machine then drop if strictly routed,
899 * or do nothing if loosely routed.
900 * Record interface address and bring up next address
901 * component. If strictly routed make sure next
902 * address is on directly accessible net.
903 */
904 case IPOPT_LSRR:
905 case IPOPT_SSRR: {
906 struct psref psref;
907 struct sockaddr_in ipaddr = {
908 .sin_len = sizeof(ipaddr),
909 .sin_family = AF_INET,
910 };
911
912 if (ip_allowsrcrt == 0) {
913 type = ICMP_UNREACH;
914 code = ICMP_UNREACH_NET_PROHIB;
915 goto bad;
916 }
917 if (srr_present++) {
918 code = &cp[IPOPT_OPTVAL] - (u_char *)ip;
919 goto bad;
920 }
921 if (optlen < IPOPT_OFFSET + sizeof(*cp)) {
922 code = &cp[IPOPT_OLEN] - (u_char *)ip;
923 goto bad;
924 }
925 if ((off = cp[IPOPT_OFFSET]) < IPOPT_MINOFF) {
926 code = &cp[IPOPT_OFFSET] - (u_char *)ip;
927 goto bad;
928 }
929 ipaddr.sin_addr = ip->ip_dst;
930
931 s = pserialize_read_enter();
932 ifa = ifa_ifwithaddr(sintosa(&ipaddr));
933 if (ifa == NULL) {
934 pserialize_read_exit(s);
935 if (opt == IPOPT_SSRR) {
936 type = ICMP_UNREACH;
937 code = ICMP_UNREACH_SRCFAIL;
938 goto bad;
939 }
940 /*
941 * Loose routing, and not at next destination
942 * yet; nothing to do except forward.
943 */
944 break;
945 }
946 pserialize_read_exit(s);
947
948 off--; /* 0 origin */
949 if ((off + sizeof(struct in_addr)) > optlen) {
950 /*
951 * End of source route. Should be for us.
952 */
953 save_rte(m, cp, ip->ip_src);
954 break;
955 }
956 /*
957 * locate outgoing interface
958 */
959 memcpy((void *)&ipaddr.sin_addr, (void *)(cp + off),
960 sizeof(ipaddr.sin_addr));
961 if (opt == IPOPT_SSRR) {
962 ifa = ifa_ifwithladdr_psref(sintosa(&ipaddr),
963 &psref);
964 if (ifa != NULL)
965 ia = ifatoia(ifa);
966 else
967 ia = NULL;
968 } else {
969 ia = ip_rtaddr(ipaddr.sin_addr, &psref);
970 }
971 if (ia == NULL) {
972 type = ICMP_UNREACH;
973 code = ICMP_UNREACH_SRCFAIL;
974 goto bad;
975 }
976 ip->ip_dst = ipaddr.sin_addr;
977 memcpy(cp + off, &ia->ia_addr.sin_addr,
978 sizeof(struct in_addr));
979 ia4_release(ia, &psref);
980 cp[IPOPT_OFFSET] += sizeof(struct in_addr);
981 /*
982 * Let ip_intr's mcast routing check handle mcast pkts
983 */
984 forward = !IN_MULTICAST(ip->ip_dst.s_addr);
985 break;
986 }
987
988 case IPOPT_RR: {
989 struct psref psref;
990 struct sockaddr_in ipaddr = {
991 .sin_len = sizeof(ipaddr),
992 .sin_family = AF_INET,
993 };
994
995 if (rr_present++) {
996 code = &cp[IPOPT_OPTVAL] - (u_char *)ip;
997 goto bad;
998 }
999 if (optlen < IPOPT_OFFSET + sizeof(*cp)) {
1000 code = &cp[IPOPT_OLEN] - (u_char *)ip;
1001 goto bad;
1002 }
1003 if ((off = cp[IPOPT_OFFSET]) < IPOPT_MINOFF) {
1004 code = &cp[IPOPT_OFFSET] - (u_char *)ip;
1005 goto bad;
1006 }
1007 /*
1008 * If no space remains, ignore.
1009 */
1010 off--; /* 0 origin */
1011 if ((off + sizeof(struct in_addr)) > optlen)
1012 break;
1013 memcpy((void *)&ipaddr.sin_addr, (void *)&ip->ip_dst,
1014 sizeof(ipaddr.sin_addr));
1015 /*
1016 * locate outgoing interface; if we're the destination,
1017 * use the incoming interface (should be same).
1018 */
1019 ifa = ifa_ifwithaddr_psref(sintosa(&ipaddr), &psref);
1020 if (ifa == NULL) {
1021 ia = ip_rtaddr(ipaddr.sin_addr, &psref);
1022 if (ia == NULL) {
1023 type = ICMP_UNREACH;
1024 code = ICMP_UNREACH_HOST;
1025 goto bad;
1026 }
1027 } else {
1028 ia = ifatoia(ifa);
1029 }
1030 memcpy(cp + off, &ia->ia_addr.sin_addr,
1031 sizeof(struct in_addr));
1032 ia4_release(ia, &psref);
1033 cp[IPOPT_OFFSET] += sizeof(struct in_addr);
1034 break;
1035 }
1036
1037 case IPOPT_TS:
1038 code = cp - (u_char *)ip;
1039 ipt = (struct ip_timestamp *)cp;
1040 if (ts_present++) {
1041 code = &cp[IPOPT_OPTVAL] - (u_char *)ip;
1042 goto bad;
1043 }
1044 if (ipt->ipt_len < 4 || ipt->ipt_len > 40) {
1045 code = (u_char *)&ipt->ipt_len - (u_char *)ip;
1046 goto bad;
1047 }
1048 if (ipt->ipt_ptr < 5) {
1049 code = (u_char *)&ipt->ipt_ptr - (u_char *)ip;
1050 goto bad;
1051 }
1052 if (ipt->ipt_ptr > ipt->ipt_len - sizeof(int32_t)) {
1053 if (++ipt->ipt_oflw == 0) {
1054 code = (u_char *)&ipt->ipt_ptr -
1055 (u_char *)ip;
1056 goto bad;
1057 }
1058 break;
1059 }
1060 cp0 = (cp + ipt->ipt_ptr - 1);
1061 switch (ipt->ipt_flg) {
1062
1063 case IPOPT_TS_TSONLY:
1064 break;
1065
1066 case IPOPT_TS_TSANDADDR: {
1067 struct ifnet *rcvif;
1068 int _s, _ss;
1069 struct sockaddr_in ipaddr = {
1070 .sin_len = sizeof(ipaddr),
1071 .sin_family = AF_INET,
1072 };
1073
1074 if (ipt->ipt_ptr - 1 + sizeof(n_time) +
1075 sizeof(struct in_addr) > ipt->ipt_len) {
1076 code = (u_char *)&ipt->ipt_ptr -
1077 (u_char *)ip;
1078 goto bad;
1079 }
1080 ipaddr.sin_addr = dst;
1081 _ss = pserialize_read_enter();
1082 rcvif = m_get_rcvif(m, &_s);
1083 if (__predict_true(rcvif != NULL)) {
1084 ifa = ifaof_ifpforaddr(sintosa(&ipaddr),
1085 rcvif);
1086 }
1087 m_put_rcvif(rcvif, &_s);
1088 if (ifa == NULL) {
1089 pserialize_read_exit(_ss);
1090 break;
1091 }
1092 ia = ifatoia(ifa);
1093 memcpy(cp0, &ia->ia_addr.sin_addr,
1094 sizeof(struct in_addr));
1095 pserialize_read_exit(_ss);
1096 ipt->ipt_ptr += sizeof(struct in_addr);
1097 break;
1098 }
1099
1100 case IPOPT_TS_PRESPEC: {
1101 struct sockaddr_in ipaddr = {
1102 .sin_len = sizeof(ipaddr),
1103 .sin_family = AF_INET,
1104 };
1105
1106 if (ipt->ipt_ptr - 1 + sizeof(n_time) +
1107 sizeof(struct in_addr) > ipt->ipt_len) {
1108 code = (u_char *)&ipt->ipt_ptr -
1109 (u_char *)ip;
1110 goto bad;
1111 }
1112 memcpy(&ipaddr.sin_addr, cp0,
1113 sizeof(struct in_addr));
1114 s = pserialize_read_enter();
1115 ifa = ifa_ifwithaddr(sintosa(&ipaddr));
1116 if (ifa == NULL) {
1117 pserialize_read_exit(s);
1118 continue;
1119 }
1120 pserialize_read_exit(s);
1121 ipt->ipt_ptr += sizeof(struct in_addr);
1122 break;
1123 }
1124
1125 default:
1126 /* XXX can't take &ipt->ipt_flg */
1127 code = (u_char *)&ipt->ipt_ptr -
1128 (u_char *)ip + 1;
1129 goto bad;
1130 }
1131 ntime = iptime();
1132 cp0 = (u_char *) &ntime; /* XXX grumble, GCC... */
1133 memmove((char *)cp + ipt->ipt_ptr - 1, cp0,
1134 sizeof(n_time));
1135 ipt->ipt_ptr += sizeof(n_time);
1136 }
1137 }
1138 if (forward) {
1139 struct ifnet *rcvif;
1140 struct psref _psref;
1141
1142 if (ip_forwsrcrt == 0) {
1143 type = ICMP_UNREACH;
1144 code = ICMP_UNREACH_SRCFAIL;
1145 goto bad;
1146 }
1147
1148 rcvif = m_get_rcvif_psref(m, &_psref);
1149 if (__predict_false(rcvif == NULL)) {
1150 type = ICMP_UNREACH;
1151 code = ICMP_UNREACH_HOST;
1152 goto bad;
1153 }
1154 ip_forward(m, 1, rcvif);
1155 m_put_rcvif_psref(rcvif, &_psref);
1156 return true;
1157 }
1158 return false;
1159 bad:
1160 icmp_error(m, type, code, 0, 0);
1161 IP_STATINC(IP_STAT_BADOPTIONS);
1162 return true;
1163 }
1164
1165 /*
1166 * ip_rtaddr: given address of next destination (final or next hop),
1167 * return internet address info of interface to be used to get there.
1168 */
1169 static struct in_ifaddr *
1170 ip_rtaddr(struct in_addr dst, struct psref *psref)
1171 {
1172 struct rtentry *rt;
1173 union {
1174 struct sockaddr dst;
1175 struct sockaddr_in dst4;
1176 } u;
1177 struct route *ro;
1178
1179 sockaddr_in_init(&u.dst4, &dst, 0);
1180
1181 ro = rtcache_percpu_getref(ipforward_rt_percpu);
1182 rt = rtcache_lookup(ro, &u.dst);
1183 if (rt == NULL) {
1184 rtcache_percpu_putref(ipforward_rt_percpu);
1185 return NULL;
1186 }
1187
1188 ia4_acquire(ifatoia(rt->rt_ifa), psref);
1189 rtcache_unref(rt, ro);
1190 rtcache_percpu_putref(ipforward_rt_percpu);
1191
1192 return ifatoia(rt->rt_ifa);
1193 }
1194
1195 /*
1196 * save_rte: save incoming source route for use in replies, to be picked
1197 * up later by ip_srcroute if the receiver is interested.
1198 */
1199 static void
1200 save_rte(struct mbuf *m, u_char *option, struct in_addr dst)
1201 {
1202 struct ip_srcrt *isr;
1203 struct m_tag *mtag;
1204 unsigned olen;
1205
1206 olen = option[IPOPT_OLEN];
1207 if (olen > sizeof(isr->isr_hdr) + sizeof(isr->isr_routes))
1208 return;
1209
1210 mtag = m_tag_get(PACKET_TAG_SRCROUTE, sizeof(*isr), M_NOWAIT);
1211 if (mtag == NULL)
1212 return;
1213 isr = (struct ip_srcrt *)(mtag + 1);
1214
1215 memcpy(isr->isr_hdr, option, olen);
1216 isr->isr_nhops = (olen - IPOPT_OFFSET - 1) / sizeof(struct in_addr);
1217 isr->isr_dst = dst;
1218 m_tag_prepend(m, mtag);
1219 }
1220
1221 /*
1222 * Retrieve incoming source route for use in replies,
1223 * in the same form used by setsockopt.
1224 * The first hop is placed before the options, will be removed later.
1225 */
1226 struct mbuf *
1227 ip_srcroute(struct mbuf *m0)
1228 {
1229 struct in_addr *p, *q;
1230 struct mbuf *m;
1231 struct ip_srcrt *isr;
1232 struct m_tag *mtag;
1233
1234 mtag = m_tag_find(m0, PACKET_TAG_SRCROUTE);
1235 if (mtag == NULL)
1236 return NULL;
1237 isr = (struct ip_srcrt *)(mtag + 1);
1238
1239 if (isr->isr_nhops == 0)
1240 return NULL;
1241
1242 m = m_get(M_DONTWAIT, MT_SOOPTS);
1243 if (m == NULL)
1244 return NULL;
1245
1246 MCLAIM(m, &inetdomain.dom_mowner);
1247 #define OPTSIZ (sizeof(isr->isr_nop) + sizeof(isr->isr_hdr))
1248
1249 /* length is (nhops+1)*sizeof(addr) + sizeof(nop + header) */
1250 m->m_len = (isr->isr_nhops + 1) * sizeof(struct in_addr) + OPTSIZ;
1251
1252 /*
1253 * First save first hop for return route
1254 */
1255 p = &(isr->isr_routes[isr->isr_nhops - 1]);
1256 *(mtod(m, struct in_addr *)) = *p--;
1257
1258 /*
1259 * Copy option fields and padding (nop) to mbuf.
1260 */
1261 isr->isr_nop = IPOPT_NOP;
1262 isr->isr_hdr[IPOPT_OFFSET] = IPOPT_MINOFF;
1263 memmove(mtod(m, char *) + sizeof(struct in_addr), &isr->isr_nop,
1264 OPTSIZ);
1265 q = (struct in_addr *)(mtod(m, char *) +
1266 sizeof(struct in_addr) + OPTSIZ);
1267 #undef OPTSIZ
1268 /*
1269 * Record return path as an IP source route,
1270 * reversing the path (pointers are now aligned).
1271 */
1272 while (p >= isr->isr_routes) {
1273 *q++ = *p--;
1274 }
1275 /*
1276 * Last hop goes to final destination.
1277 */
1278 *q = isr->isr_dst;
1279 m_tag_delete(m0, mtag);
1280 return m;
1281 }
1282
1283 const int inetctlerrmap[PRC_NCMDS] = {
1284 [PRC_MSGSIZE] = EMSGSIZE,
1285 [PRC_HOSTDEAD] = EHOSTDOWN,
1286 [PRC_HOSTUNREACH] = EHOSTUNREACH,
1287 [PRC_UNREACH_NET] = EHOSTUNREACH,
1288 [PRC_UNREACH_HOST] = EHOSTUNREACH,
1289 [PRC_UNREACH_PROTOCOL] = ECONNREFUSED,
1290 [PRC_UNREACH_PORT] = ECONNREFUSED,
1291 [PRC_UNREACH_SRCFAIL] = EHOSTUNREACH,
1292 [PRC_PARAMPROB] = ENOPROTOOPT,
1293 };
1294
1295 void
1296 ip_fasttimo(void)
1297 {
1298 if (ip_drainwanted) {
1299 ip_drain();
1300 ip_drainwanted = 0;
1301 }
1302 }
1303
1304 void
1305 ip_drainstub(void)
1306 {
1307 ip_drainwanted = 1;
1308 }
1309
1310 /*
1311 * Forward a packet. If some error occurs return the sender
1312 * an icmp packet. Note we can't always generate a meaningful
1313 * icmp message because icmp doesn't have a large enough repertoire
1314 * of codes and types.
1315 *
1316 * If not forwarding, just drop the packet. This could be confusing
1317 * if ipforwarding was zero but some routing protocol was advancing
1318 * us as a gateway to somewhere. However, we must let the routing
1319 * protocol deal with that.
1320 *
1321 * The srcrt parameter indicates whether the packet is being forwarded
1322 * via a source route.
1323 */
1324 static void
1325 ip_forward(struct mbuf *m, int srcrt, struct ifnet *rcvif)
1326 {
1327 struct ip *ip = mtod(m, struct ip *);
1328 struct rtentry *rt;
1329 int error, type = 0, code = 0, destmtu = 0;
1330 struct mbuf *mcopy;
1331 n_long dest;
1332 union {
1333 struct sockaddr dst;
1334 struct sockaddr_in dst4;
1335 } u;
1336 net_stat_ref_t ips;
1337 struct route *ro;
1338
1339 KASSERTMSG(cpu_softintr_p(), "ip_forward: not in the software "
1340 "interrupt handler; synchronization assumptions violated");
1341
1342 /*
1343 * We are now in the output path.
1344 */
1345 MCLAIM(m, &ip_tx_mowner);
1346
1347 /*
1348 * Clear any in-bound checksum flags for this packet.
1349 */
1350 m->m_pkthdr.csum_flags = 0;
1351
1352 dest = 0;
1353 if (m->m_flags & (M_BCAST|M_MCAST) || in_canforward(ip->ip_dst) == 0) {
1354 IP_STATINC(IP_STAT_CANTFORWARD);
1355 m_freem(m);
1356 return;
1357 }
1358
1359 if (ip->ip_ttl <= IPTTLDEC) {
1360 IP_STATINC(IP_STAT_TIMXCEED);
1361 icmp_error(m, ICMP_TIMXCEED, ICMP_TIMXCEED_INTRANS, dest, 0);
1362 return;
1363 }
1364
1365 sockaddr_in_init(&u.dst4, &ip->ip_dst, 0);
1366
1367 ro = rtcache_percpu_getref(ipforward_rt_percpu);
1368 rt = rtcache_lookup(ro, &u.dst);
1369 if (rt == NULL) {
1370 rtcache_percpu_putref(ipforward_rt_percpu);
1371 IP_STATINC(IP_STAT_NOROUTE);
1372 icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_NET, dest, 0);
1373 return;
1374 }
1375 #ifdef NET_MPSAFE
1376 /*
1377 * XXX workaround an inconsistency issue between address and route on
1378 * address initialization to avoid packet looping. See doc/TODO.smpnet.
1379 */
1380 if (__predict_false(rt->rt_ifp->if_type == IFT_LOOP)) {
1381 rtcache_unref(rt, ro);
1382 rtcache_percpu_putref(ipforward_rt_percpu);
1383 icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_HOST, 0, 0);
1384 IP_STATINC(IP_STAT_CANTFORWARD);
1385 return;
1386 }
1387 #endif
1388
1389 /*
1390 * Save at most 68 bytes of the packet in case
1391 * we need to generate an ICMP message to the src.
1392 * Pullup to avoid sharing mbuf cluster between m and mcopy.
1393 */
1394 mcopy = m_copym(m, 0, imin(ntohs(ip->ip_len), 68), M_DONTWAIT);
1395 if (mcopy)
1396 mcopy = m_pullup(mcopy, ip->ip_hl << 2);
1397
1398 ip->ip_ttl -= IPTTLDEC;
1399
1400 /*
1401 * If forwarding packet using same interface that it came in on,
1402 * perhaps should send a redirect to sender to shortcut a hop.
1403 * Only send redirect if source is sending directly to us,
1404 * and if packet was not source routed (or has any options).
1405 * Also, don't send redirect if forwarding using a default route
1406 * or a route modified by a redirect.
1407 */
1408 if (rt->rt_ifp == rcvif &&
1409 (rt->rt_flags & (RTF_DYNAMIC|RTF_MODIFIED)) == 0 &&
1410 !in_nullhost(satocsin(rt_getkey(rt))->sin_addr) &&
1411 ipsendredirects && !srcrt) {
1412 if ((ip->ip_src.s_addr & ifatoia(rt->rt_ifa)->ia_subnetmask) ==
1413 ifatoia(rt->rt_ifa)->ia_subnet) {
1414 if (rt->rt_flags & RTF_GATEWAY)
1415 dest = satosin(rt->rt_gateway)->sin_addr.s_addr;
1416 else
1417 dest = ip->ip_dst.s_addr;
1418 /*
1419 * Router requirements says to only send host
1420 * redirects.
1421 */
1422 type = ICMP_REDIRECT;
1423 code = ICMP_REDIRECT_HOST;
1424 }
1425 }
1426 rtcache_unref(rt, ro);
1427
1428 error = ip_output(m, NULL, ro,
1429 (IP_FORWARDING | (ip_directedbcast ? IP_ALLOWBROADCAST : 0)),
1430 NULL, NULL);
1431
1432 if (error) {
1433 IP_STATINC(IP_STAT_CANTFORWARD);
1434 goto error;
1435 }
1436
1437 ips = IP_STAT_GETREF();
1438 _NET_STATINC_REF(ips, IP_STAT_FORWARD);
1439
1440 if (type) {
1441 _NET_STATINC_REF(ips, IP_STAT_REDIRECTSENT);
1442 IP_STAT_PUTREF();
1443 goto redirect;
1444 }
1445
1446 IP_STAT_PUTREF();
1447 if (mcopy) {
1448 #ifdef GATEWAY
1449 if (mcopy->m_flags & M_CANFASTFWD)
1450 ipflow_create(ro, mcopy);
1451 #endif
1452 m_freem(mcopy);
1453 }
1454
1455 rtcache_percpu_putref(ipforward_rt_percpu);
1456 return;
1457
1458 redirect:
1459 error:
1460 if (mcopy == NULL) {
1461 rtcache_percpu_putref(ipforward_rt_percpu);
1462 return;
1463 }
1464
1465 switch (error) {
1466
1467 case 0: /* forwarded, but need redirect */
1468 /* type, code set above */
1469 break;
1470
1471 case ENETUNREACH: /* shouldn't happen, checked above */
1472 case EHOSTUNREACH:
1473 case ENETDOWN:
1474 case EHOSTDOWN:
1475 default:
1476 type = ICMP_UNREACH;
1477 code = ICMP_UNREACH_HOST;
1478 break;
1479
1480 case EMSGSIZE:
1481 type = ICMP_UNREACH;
1482 code = ICMP_UNREACH_NEEDFRAG;
1483
1484 if ((rt = rtcache_validate(ro)) != NULL) {
1485 destmtu = rt->rt_ifp->if_mtu;
1486 rtcache_unref(rt, ro);
1487 }
1488 #ifdef IPSEC
1489 if (ipsec_used)
1490 ipsec_mtu(mcopy, &destmtu);
1491 #endif
1492 IP_STATINC(IP_STAT_CANTFRAG);
1493 break;
1494
1495 case ENOBUFS:
1496 /*
1497 * Do not generate ICMP_SOURCEQUENCH as required in RFC 1812,
1498 * Requirements for IP Version 4 Routers. Source quench can
1499 * be a big problem under DoS attacks or if the underlying
1500 * interface is rate-limited.
1501 */
1502 m_freem(mcopy);
1503 rtcache_percpu_putref(ipforward_rt_percpu);
1504 return;
1505 }
1506 icmp_error(mcopy, type, code, dest, destmtu);
1507 rtcache_percpu_putref(ipforward_rt_percpu);
1508 }
1509
1510 void
1511 ip_savecontrol(struct inpcb *inp, struct mbuf **mp, struct ip *ip,
1512 struct mbuf *m)
1513 {
1514 struct socket *so = inp->inp_socket;
1515 int inpflags = inp->inp_flags;
1516
1517 if (SOOPT_TIMESTAMP(so->so_options))
1518 mp = sbsavetimestamp(so->so_options, mp);
1519
1520 if (inpflags & INP_RECVDSTADDR) {
1521 *mp = sbcreatecontrol(&ip->ip_dst,
1522 sizeof(struct in_addr), IP_RECVDSTADDR, IPPROTO_IP);
1523 if (*mp)
1524 mp = &(*mp)->m_next;
1525 }
1526
1527 if (inpflags & INP_RECVTTL) {
1528 *mp = sbcreatecontrol(&ip->ip_ttl,
1529 sizeof(uint8_t), IP_RECVTTL, IPPROTO_IP);
1530 if (*mp)
1531 mp = &(*mp)->m_next;
1532 }
1533
1534 struct psref psref;
1535 ifnet_t *ifp = m_get_rcvif_psref(m, &psref);
1536 if (__predict_false(ifp == NULL)) {
1537 #ifdef DIAGNOSTIC
1538 printf("%s: missing receive interface\n", __func__);
1539 #endif
1540 return; /* XXX should report error? */
1541 }
1542
1543 if (inpflags & INP_RECVPKTINFO) {
1544 struct in_pktinfo ipi;
1545 ipi.ipi_addr = ip->ip_dst;
1546 ipi.ipi_ifindex = ifp->if_index;
1547 *mp = sbcreatecontrol(&ipi,
1548 sizeof(ipi), IP_PKTINFO, IPPROTO_IP);
1549 if (*mp)
1550 mp = &(*mp)->m_next;
1551 }
1552 if (inpflags & INP_RECVIF) {
1553 struct sockaddr_dl sdl;
1554
1555 sockaddr_dl_init(&sdl, sizeof(sdl), ifp->if_index, 0, NULL, 0,
1556 NULL, 0);
1557 *mp = sbcreatecontrol(&sdl, sdl.sdl_len, IP_RECVIF, IPPROTO_IP);
1558 if (*mp)
1559 mp = &(*mp)->m_next;
1560 }
1561 m_put_rcvif_psref(ifp, &psref);
1562 }
1563
1564 /*
1565 * sysctl helper routine for net.inet.ip.forwsrcrt.
1566 */
1567 static int
1568 sysctl_net_inet_ip_forwsrcrt(SYSCTLFN_ARGS)
1569 {
1570 int error, tmp;
1571 struct sysctlnode node;
1572
1573 node = *rnode;
1574 tmp = ip_forwsrcrt;
1575 node.sysctl_data = &tmp;
1576 error = sysctl_lookup(SYSCTLFN_CALL(&node));
1577 if (error || newp == NULL)
1578 return (error);
1579
1580 error = kauth_authorize_network(l->l_cred, KAUTH_NETWORK_FORWSRCRT,
1581 0, NULL, NULL, NULL);
1582 if (error)
1583 return (error);
1584
1585 ip_forwsrcrt = tmp;
1586
1587 return (0);
1588 }
1589
1590 /*
1591 * sysctl helper routine for net.inet.ip.mtudisctimeout. checks the
1592 * range of the new value and tweaks timers if it changes.
1593 */
1594 static int
1595 sysctl_net_inet_ip_pmtudto(SYSCTLFN_ARGS)
1596 {
1597 int error, tmp;
1598 struct sysctlnode node;
1599
1600 icmp_mtudisc_lock();
1601
1602 node = *rnode;
1603 tmp = ip_mtudisc_timeout;
1604 node.sysctl_data = &tmp;
1605 error = sysctl_lookup(SYSCTLFN_CALL(&node));
1606 if (error || newp == NULL)
1607 goto out;
1608 if (tmp < 0) {
1609 error = EINVAL;
1610 goto out;
1611 }
1612
1613 ip_mtudisc_timeout = tmp;
1614 rt_timer_queue_change(ip_mtudisc_timeout_q, ip_mtudisc_timeout);
1615 error = 0;
1616 out:
1617 icmp_mtudisc_unlock();
1618 return error;
1619 }
1620
1621 static int
1622 sysctl_net_inet_ip_stats(SYSCTLFN_ARGS)
1623 {
1624
1625 return (NETSTAT_SYSCTL(ipstat_percpu, IP_NSTATS));
1626 }
1627
1628 static void
1629 sysctl_net_inet_ip_setup(struct sysctllog **clog)
1630 {
1631 const struct sysctlnode *ip_node;
1632
1633 sysctl_createv(clog, 0, NULL, NULL,
1634 CTLFLAG_PERMANENT,
1635 CTLTYPE_NODE, "inet",
1636 SYSCTL_DESCR("PF_INET related settings"),
1637 NULL, 0, NULL, 0,
1638 CTL_NET, PF_INET, CTL_EOL);
1639 sysctl_createv(clog, 0, NULL, &ip_node,
1640 CTLFLAG_PERMANENT,
1641 CTLTYPE_NODE, "ip",
1642 SYSCTL_DESCR("IPv4 related settings"),
1643 NULL, 0, NULL, 0,
1644 CTL_NET, PF_INET, IPPROTO_IP, CTL_EOL);
1645
1646 sysctl_createv(clog, 0, NULL, NULL,
1647 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1648 CTLTYPE_INT, "forwarding",
1649 SYSCTL_DESCR("Enable forwarding of INET datagrams"),
1650 NULL, 0, &ipforwarding, 0,
1651 CTL_NET, PF_INET, IPPROTO_IP,
1652 IPCTL_FORWARDING, CTL_EOL);
1653 sysctl_createv(clog, 0, NULL, NULL,
1654 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1655 CTLTYPE_INT, "redirect",
1656 SYSCTL_DESCR("Enable sending of ICMP redirect messages"),
1657 NULL, 0, &ipsendredirects, 0,
1658 CTL_NET, PF_INET, IPPROTO_IP,
1659 IPCTL_SENDREDIRECTS, CTL_EOL);
1660 sysctl_createv(clog, 0, NULL, NULL,
1661 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1662 CTLTYPE_INT, "ttl",
1663 SYSCTL_DESCR("Default TTL for an INET datagram"),
1664 NULL, 0, &ip_defttl, 0,
1665 CTL_NET, PF_INET, IPPROTO_IP,
1666 IPCTL_DEFTTL, CTL_EOL);
1667 sysctl_createv(clog, 0, NULL, NULL,
1668 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1669 CTLTYPE_INT, "forwsrcrt",
1670 SYSCTL_DESCR("Enable forwarding of source-routed "
1671 "datagrams"),
1672 sysctl_net_inet_ip_forwsrcrt, 0, &ip_forwsrcrt, 0,
1673 CTL_NET, PF_INET, IPPROTO_IP,
1674 IPCTL_FORWSRCRT, CTL_EOL);
1675 sysctl_createv(clog, 0, NULL, NULL,
1676 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1677 CTLTYPE_INT, "directed-broadcast",
1678 SYSCTL_DESCR("Enable forwarding of broadcast datagrams"),
1679 NULL, 0, &ip_directedbcast, 0,
1680 CTL_NET, PF_INET, IPPROTO_IP,
1681 IPCTL_DIRECTEDBCAST, CTL_EOL);
1682 sysctl_createv(clog, 0, NULL, NULL,
1683 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1684 CTLTYPE_INT, "allowsrcrt",
1685 SYSCTL_DESCR("Accept source-routed datagrams"),
1686 NULL, 0, &ip_allowsrcrt, 0,
1687 CTL_NET, PF_INET, IPPROTO_IP,
1688 IPCTL_ALLOWSRCRT, CTL_EOL);
1689
1690 sysctl_createv(clog, 0, NULL, NULL,
1691 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1692 CTLTYPE_INT, "mtudisc",
1693 SYSCTL_DESCR("Use RFC1191 Path MTU Discovery"),
1694 NULL, 0, &ip_mtudisc, 0,
1695 CTL_NET, PF_INET, IPPROTO_IP,
1696 IPCTL_MTUDISC, CTL_EOL);
1697 sysctl_createv(clog, 0, NULL, NULL,
1698 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1699 CTLTYPE_INT, "anonportmin",
1700 SYSCTL_DESCR("Lowest ephemeral port number to assign"),
1701 sysctl_net_inet_ip_ports, 0, &anonportmin, 0,
1702 CTL_NET, PF_INET, IPPROTO_IP,
1703 IPCTL_ANONPORTMIN, CTL_EOL);
1704 sysctl_createv(clog, 0, NULL, NULL,
1705 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1706 CTLTYPE_INT, "anonportmax",
1707 SYSCTL_DESCR("Highest ephemeral port number to assign"),
1708 sysctl_net_inet_ip_ports, 0, &anonportmax, 0,
1709 CTL_NET, PF_INET, IPPROTO_IP,
1710 IPCTL_ANONPORTMAX, CTL_EOL);
1711 sysctl_createv(clog, 0, NULL, NULL,
1712 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1713 CTLTYPE_INT, "mtudisctimeout",
1714 SYSCTL_DESCR("Lifetime of a Path MTU Discovered route"),
1715 sysctl_net_inet_ip_pmtudto, 0, (void *)&ip_mtudisc_timeout, 0,
1716 CTL_NET, PF_INET, IPPROTO_IP,
1717 IPCTL_MTUDISCTIMEOUT, CTL_EOL);
1718 #ifndef IPNOPRIVPORTS
1719 sysctl_createv(clog, 0, NULL, NULL,
1720 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1721 CTLTYPE_INT, "lowportmin",
1722 SYSCTL_DESCR("Lowest privileged ephemeral port number "
1723 "to assign"),
1724 sysctl_net_inet_ip_ports, 0, &lowportmin, 0,
1725 CTL_NET, PF_INET, IPPROTO_IP,
1726 IPCTL_LOWPORTMIN, CTL_EOL);
1727 sysctl_createv(clog, 0, NULL, NULL,
1728 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1729 CTLTYPE_INT, "lowportmax",
1730 SYSCTL_DESCR("Highest privileged ephemeral port number "
1731 "to assign"),
1732 sysctl_net_inet_ip_ports, 0, &lowportmax, 0,
1733 CTL_NET, PF_INET, IPPROTO_IP,
1734 IPCTL_LOWPORTMAX, CTL_EOL);
1735 #endif /* IPNOPRIVPORTS */
1736 #if NGRE > 0
1737 sysctl_createv(clog, 0, NULL, NULL,
1738 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1739 CTLTYPE_INT, "grettl",
1740 SYSCTL_DESCR("Default TTL for a gre tunnel datagram"),
1741 NULL, 0, &ip_gre_ttl, 0,
1742 CTL_NET, PF_INET, IPPROTO_IP,
1743 IPCTL_GRE_TTL, CTL_EOL);
1744 #endif /* NGRE */
1745 sysctl_createv(clog, 0, NULL, NULL,
1746 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1747 CTLTYPE_INT, "checkinterface",
1748 SYSCTL_DESCR("Enable receive side of Strong ES model "
1749 "from RFC1122"),
1750 NULL, 0, &ip_checkinterface, 0,
1751 CTL_NET, PF_INET, IPPROTO_IP,
1752 IPCTL_CHECKINTERFACE, CTL_EOL);
1753
1754 pktq_sysctl_setup(ip_pktq, clog, ip_node, IPCTL_IFQ);
1755
1756 sysctl_createv(clog, 0, NULL, NULL,
1757 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1758 CTLTYPE_INT, "random_id",
1759 SYSCTL_DESCR("Assign random ip_id values"),
1760 NULL, 0, &ip_do_randomid, 0,
1761 CTL_NET, PF_INET, IPPROTO_IP,
1762 IPCTL_RANDOMID, CTL_EOL);
1763 sysctl_createv(clog, 0, NULL, NULL,
1764 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1765 CTLTYPE_INT, "do_loopback_cksum",
1766 SYSCTL_DESCR("Perform IP checksum on loopback"),
1767 NULL, 0, &ip_do_loopback_cksum, 0,
1768 CTL_NET, PF_INET, IPPROTO_IP,
1769 IPCTL_LOOPBACKCKSUM, CTL_EOL);
1770 sysctl_createv(clog, 0, NULL, NULL,
1771 CTLFLAG_PERMANENT,
1772 CTLTYPE_STRUCT, "stats",
1773 SYSCTL_DESCR("IP statistics"),
1774 sysctl_net_inet_ip_stats, 0, NULL, 0,
1775 CTL_NET, PF_INET, IPPROTO_IP, IPCTL_STATS,
1776 CTL_EOL);
1777 #if NARP
1778 sysctl_createv(clog, 0, NULL, NULL,
1779 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1780 CTLTYPE_INT, "dad_count",
1781 SYSCTL_DESCR("Number of Duplicate Address Detection "
1782 "probes to send"),
1783 NULL, 0, &ip_dad_count, 0,
1784 CTL_NET, PF_INET, IPPROTO_IP,
1785 IPCTL_DAD_COUNT, CTL_EOL);
1786 #endif
1787
1788 /* anonportalgo RFC6056 subtree */
1789 const struct sysctlnode *portalgo_node;
1790 sysctl_createv(clog, 0, NULL, &portalgo_node,
1791 CTLFLAG_PERMANENT,
1792 CTLTYPE_NODE, "anonportalgo",
1793 SYSCTL_DESCR("Anonymous Port Algorithm Selection (RFC 6056)"),
1794 NULL, 0, NULL, 0,
1795 CTL_NET, PF_INET, IPPROTO_IP, CTL_CREATE, CTL_EOL);
1796 sysctl_createv(clog, 0, &portalgo_node, NULL,
1797 CTLFLAG_PERMANENT,
1798 CTLTYPE_STRING, "available",
1799 SYSCTL_DESCR("available algorithms"),
1800 sysctl_portalgo_available, 0, NULL, PORTALGO_MAXLEN,
1801 CTL_CREATE, CTL_EOL);
1802 sysctl_createv(clog, 0, &portalgo_node, NULL,
1803 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1804 CTLTYPE_STRING, "selected",
1805 SYSCTL_DESCR("selected algorithm"),
1806 sysctl_portalgo_selected4, 0, NULL, PORTALGO_MAXLEN,
1807 CTL_CREATE, CTL_EOL);
1808 sysctl_createv(clog, 0, &portalgo_node, NULL,
1809 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1810 CTLTYPE_STRUCT, "reserve",
1811 SYSCTL_DESCR("bitmap of reserved ports"),
1812 sysctl_portalgo_reserve4, 0, NULL, 0,
1813 CTL_CREATE, CTL_EOL);
1814 }
1815
1816 void
1817 ip_statinc(u_int stat)
1818 {
1819
1820 KASSERT(stat < IP_NSTATS);
1821 IP_STATINC(stat);
1822 }
1823