Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /*
3 : : * INET An implementation of the TCP/IP protocol suite for the LINUX
4 : : * operating system. INET is implemented using the BSD Socket
5 : : * interface as the means of communication with the user level.
6 : : *
7 : : * The Internet Protocol (IP) module.
8 : : *
9 : : * Authors: Ross Biro
10 : : * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
11 : : * Donald Becker, <becker@super.org>
12 : : * Alan Cox, <alan@lxorguk.ukuu.org.uk>
13 : : * Richard Underwood
14 : : * Stefan Becker, <stefanb@yello.ping.de>
15 : : * Jorge Cwik, <jorge@laser.satlink.net>
16 : : * Arnt Gulbrandsen, <agulbra@nvg.unit.no>
17 : : *
18 : : * Fixes:
19 : : * Alan Cox : Commented a couple of minor bits of surplus code
20 : : * Alan Cox : Undefining IP_FORWARD doesn't include the code
21 : : * (just stops a compiler warning).
22 : : * Alan Cox : Frames with >=MAX_ROUTE record routes, strict routes or loose routes
23 : : * are junked rather than corrupting things.
24 : : * Alan Cox : Frames to bad broadcast subnets are dumped
25 : : * We used to process them non broadcast and
26 : : * boy could that cause havoc.
27 : : * Alan Cox : ip_forward sets the free flag on the
28 : : * new frame it queues. Still crap because
29 : : * it copies the frame but at least it
30 : : * doesn't eat memory too.
31 : : * Alan Cox : Generic queue code and memory fixes.
32 : : * Fred Van Kempen : IP fragment support (borrowed from NET2E)
33 : : * Gerhard Koerting: Forward fragmented frames correctly.
34 : : * Gerhard Koerting: Fixes to my fix of the above 8-).
35 : : * Gerhard Koerting: IP interface addressing fix.
36 : : * Linus Torvalds : More robustness checks
37 : : * Alan Cox : Even more checks: Still not as robust as it ought to be
38 : : * Alan Cox : Save IP header pointer for later
39 : : * Alan Cox : ip option setting
40 : : * Alan Cox : Use ip_tos/ip_ttl settings
41 : : * Alan Cox : Fragmentation bogosity removed
42 : : * (Thanks to Mark.Bush@prg.ox.ac.uk)
43 : : * Dmitry Gorodchanin : Send of a raw packet crash fix.
44 : : * Alan Cox : Silly ip bug when an overlength
45 : : * fragment turns up. Now frees the
46 : : * queue.
47 : : * Linus Torvalds/ : Memory leakage on fragmentation
48 : : * Alan Cox : handling.
49 : : * Gerhard Koerting: Forwarding uses IP priority hints
50 : : * Teemu Rantanen : Fragment problems.
51 : : * Alan Cox : General cleanup, comments and reformat
52 : : * Alan Cox : SNMP statistics
53 : : * Alan Cox : BSD address rule semantics. Also see
54 : : * UDP as there is a nasty checksum issue
55 : : * if you do things the wrong way.
56 : : * Alan Cox : Always defrag, moved IP_FORWARD to the config.in file
57 : : * Alan Cox : IP options adjust sk->priority.
58 : : * Pedro Roque : Fix mtu/length error in ip_forward.
59 : : * Alan Cox : Avoid ip_chk_addr when possible.
60 : : * Richard Underwood : IP multicasting.
61 : : * Alan Cox : Cleaned up multicast handlers.
62 : : * Alan Cox : RAW sockets demultiplex in the BSD style.
63 : : * Gunther Mayer : Fix the SNMP reporting typo
64 : : * Alan Cox : Always in group 224.0.0.1
65 : : * Pauline Middelink : Fast ip_checksum update when forwarding
66 : : * Masquerading support.
67 : : * Alan Cox : Multicast loopback error for 224.0.0.1
68 : : * Alan Cox : IP_MULTICAST_LOOP option.
69 : : * Alan Cox : Use notifiers.
70 : : * Bjorn Ekwall : Removed ip_csum (from slhc.c too)
71 : : * Bjorn Ekwall : Moved ip_fast_csum to ip.h (inline!)
72 : : * Stefan Becker : Send out ICMP HOST REDIRECT
73 : : * Arnt Gulbrandsen : ip_build_xmit
74 : : * Alan Cox : Per socket routing cache
75 : : * Alan Cox : Fixed routing cache, added header cache.
76 : : * Alan Cox : Loopback didn't work right in original ip_build_xmit - fixed it.
77 : : * Alan Cox : Only send ICMP_REDIRECT if src/dest are the same net.
78 : : * Alan Cox : Incoming IP option handling.
79 : : * Alan Cox : Set saddr on raw output frames as per BSD.
80 : : * Alan Cox : Stopped broadcast source route explosions.
81 : : * Alan Cox : Can disable source routing
82 : : * Takeshi Sone : Masquerading didn't work.
83 : : * Dave Bonn,Alan Cox : Faster IP forwarding whenever possible.
84 : : * Alan Cox : Memory leaks, tramples, misc debugging.
85 : : * Alan Cox : Fixed multicast (by popular demand 8))
86 : : * Alan Cox : Fixed forwarding (by even more popular demand 8))
87 : : * Alan Cox : Fixed SNMP statistics [I think]
88 : : * Gerhard Koerting : IP fragmentation forwarding fix
89 : : * Alan Cox : Device lock against page fault.
90 : : * Alan Cox : IP_HDRINCL facility.
91 : : * Werner Almesberger : Zero fragment bug
92 : : * Alan Cox : RAW IP frame length bug
93 : : * Alan Cox : Outgoing firewall on build_xmit
94 : : * A.N.Kuznetsov : IP_OPTIONS support throughout the kernel
95 : : * Alan Cox : Multicast routing hooks
96 : : * Jos Vos : Do accounting *before* call_in_firewall
97 : : * Willy Konynenberg : Transparent proxying support
98 : : *
99 : : * To Fix:
100 : : * IP fragmentation wants rewriting cleanly. The RFC815 algorithm is much more efficient
101 : : * and could be made very efficient with the addition of some virtual memory hacks to permit
102 : : * the allocation of a buffer that can then be 'grown' by twiddling page tables.
103 : : * Output fragmentation wants updating along with the buffer management to use a single
104 : : * interleaved copy algorithm so that fragmenting has a one copy overhead. Actual packet
105 : : * output should probably do its own fragmentation at the UDP/RAW layer. TCP shouldn't cause
106 : : * fragmentation anyway.
107 : : */
108 : :
109 : : #define pr_fmt(fmt) "IPv4: " fmt
110 : :
111 : : #include <linux/module.h>
112 : : #include <linux/types.h>
113 : : #include <linux/kernel.h>
114 : : #include <linux/string.h>
115 : : #include <linux/errno.h>
116 : : #include <linux/slab.h>
117 : :
118 : : #include <linux/net.h>
119 : : #include <linux/socket.h>
120 : : #include <linux/sockios.h>
121 : : #include <linux/in.h>
122 : : #include <linux/inet.h>
123 : : #include <linux/inetdevice.h>
124 : : #include <linux/netdevice.h>
125 : : #include <linux/etherdevice.h>
126 : : #include <linux/indirect_call_wrapper.h>
127 : :
128 : : #include <net/snmp.h>
129 : : #include <net/ip.h>
130 : : #include <net/protocol.h>
131 : : #include <net/route.h>
132 : : #include <linux/skbuff.h>
133 : : #include <net/sock.h>
134 : : #include <net/arp.h>
135 : : #include <net/icmp.h>
136 : : #include <net/raw.h>
137 : : #include <net/checksum.h>
138 : : #include <net/inet_ecn.h>
139 : : #include <linux/netfilter_ipv4.h>
140 : : #include <net/xfrm.h>
141 : : #include <linux/mroute.h>
142 : : #include <linux/netlink.h>
143 : : #include <net/dst_metadata.h>
144 : :
145 : : /*
146 : : * Process Router Attention IP option (RFC 2113)
147 : : */
148 : 0 : bool ip_call_ra_chain(struct sk_buff *skb)
149 : : {
150 : 0 : struct ip_ra_chain *ra;
151 : 0 : u8 protocol = ip_hdr(skb)->protocol;
152 : 0 : struct sock *last = NULL;
153 : 0 : struct net_device *dev = skb->dev;
154 : 0 : struct net *net = dev_net(dev);
155 : :
156 [ # # ]: 0 : for (ra = rcu_dereference(net->ipv4.ra_chain); ra; ra = rcu_dereference(ra->next)) {
157 : 0 : struct sock *sk = ra->sk;
158 : :
159 : : /* If socket is bound to an interface, only report
160 : : * the packet if it came from that interface.
161 : : */
162 [ # # # # ]: 0 : if (sk && inet_sk(sk)->inet_num == protocol &&
163 [ # # ]: 0 : (!sk->sk_bound_dev_if ||
164 [ # # ]: 0 : sk->sk_bound_dev_if == dev->ifindex)) {
165 [ # # ]: 0 : if (ip_is_fragment(ip_hdr(skb))) {
166 [ # # ]: 0 : if (ip_defrag(net, skb, IP_DEFRAG_CALL_RA_CHAIN))
167 : : return true;
168 : : }
169 [ # # ]: 0 : if (last) {
170 : 0 : struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
171 [ # # ]: 0 : if (skb2)
172 : 0 : raw_rcv(last, skb2);
173 : : }
174 : : last = sk;
175 : : }
176 : : }
177 : :
178 [ # # ]: 0 : if (last) {
179 : 0 : raw_rcv(last, skb);
180 : 0 : return true;
181 : : }
182 : : return false;
183 : : }
184 : :
185 : : INDIRECT_CALLABLE_DECLARE(int udp_rcv(struct sk_buff *));
186 : : INDIRECT_CALLABLE_DECLARE(int tcp_v4_rcv(struct sk_buff *));
187 : 0 : void ip_protocol_deliver_rcu(struct net *net, struct sk_buff *skb, int protocol)
188 : : {
189 : 0 : const struct net_protocol *ipprot;
190 : 0 : int raw, ret;
191 : :
192 : 0 : resubmit:
193 : 0 : raw = raw_local_deliver(skb, protocol);
194 : :
195 [ # # ]: 0 : ipprot = rcu_dereference(inet_protos[protocol]);
196 [ # # ]: 0 : if (ipprot) {
197 [ # # ]: 0 : if (!ipprot->no_policy) {
198 [ # # ]: 0 : if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
199 : 0 : kfree_skb(skb);
200 : 0 : return;
201 : : }
202 : 0 : nf_reset_ct(skb);
203 : : }
204 [ # # # # ]: 0 : ret = INDIRECT_CALL_2(ipprot->handler, tcp_v4_rcv, udp_rcv,
205 : : skb);
206 [ # # ]: 0 : if (ret < 0) {
207 : 0 : protocol = -ret;
208 : 0 : goto resubmit;
209 : : }
210 : 0 : __IP_INC_STATS(net, IPSTATS_MIB_INDELIVERS);
211 : : } else {
212 [ # # ]: 0 : if (!raw) {
213 [ # # ]: 0 : if (xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
214 : 0 : __IP_INC_STATS(net, IPSTATS_MIB_INUNKNOWNPROTOS);
215 : 0 : icmp_send(skb, ICMP_DEST_UNREACH,
216 : : ICMP_PROT_UNREACH, 0);
217 : : }
218 : 0 : kfree_skb(skb);
219 : : } else {
220 : 0 : __IP_INC_STATS(net, IPSTATS_MIB_INDELIVERS);
221 : 0 : consume_skb(skb);
222 : : }
223 : : }
224 : : }
225 : :
226 : 0 : static int ip_local_deliver_finish(struct net *net, struct sock *sk, struct sk_buff *skb)
227 : : {
228 [ # # ]: 0 : __skb_pull(skb, skb_network_header_len(skb));
229 : :
230 : 0 : rcu_read_lock();
231 : 0 : ip_protocol_deliver_rcu(net, skb, ip_hdr(skb)->protocol);
232 : 0 : rcu_read_unlock();
233 : :
234 : 0 : return 0;
235 : : }
236 : :
237 : : /*
238 : : * Deliver IP Packets to the higher protocol layers.
239 : : */
240 : 0 : int ip_local_deliver(struct sk_buff *skb)
241 : : {
242 : : /*
243 : : * Reassemble IP fragments.
244 : : */
245 [ # # ]: 0 : struct net *net = dev_net(skb->dev);
246 : :
247 [ # # ]: 0 : if (ip_is_fragment(ip_hdr(skb))) {
248 [ # # ]: 0 : if (ip_defrag(net, skb, IP_DEFRAG_LOCAL_DELIVER))
249 : : return 0;
250 : : }
251 : :
252 : 0 : return NF_HOOK(NFPROTO_IPV4, NF_INET_LOCAL_IN,
253 : : net, NULL, skb, skb->dev, NULL,
254 : : ip_local_deliver_finish);
255 : : }
256 : :
257 : 0 : static inline bool ip_rcv_options(struct sk_buff *skb, struct net_device *dev)
258 : : {
259 : 0 : struct ip_options *opt;
260 : 0 : const struct iphdr *iph;
261 : :
262 : : /* It looks as overkill, because not all
263 : : IP options require packet mangling.
264 : : But it is the easiest for now, especially taking
265 : : into account that combination of IP options
266 : : and running sniffer is extremely rare condition.
267 : : --ANK (980813)
268 : : */
269 [ # # ]: 0 : if (skb_cow(skb, skb_headroom(skb))) {
270 : 0 : __IP_INC_STATS(dev_net(dev), IPSTATS_MIB_INDISCARDS);
271 : 0 : goto drop;
272 : : }
273 : :
274 : 0 : iph = ip_hdr(skb);
275 : 0 : opt = &(IPCB(skb)->opt);
276 : 0 : opt->optlen = iph->ihl*4 - sizeof(struct iphdr);
277 : :
278 [ # # ]: 0 : if (ip_options_compile(dev_net(dev), opt, skb)) {
279 : 0 : __IP_INC_STATS(dev_net(dev), IPSTATS_MIB_INHDRERRORS);
280 : 0 : goto drop;
281 : : }
282 : :
283 [ # # ]: 0 : if (unlikely(opt->srr)) {
284 [ # # ]: 0 : struct in_device *in_dev = __in_dev_get_rcu(dev);
285 : :
286 [ # # ]: 0 : if (in_dev) {
287 [ # # # # ]: 0 : if (!IN_DEV_SOURCE_ROUTE(in_dev)) {
288 [ # # # # ]: 0 : if (IN_DEV_LOG_MARTIANS(in_dev))
289 [ # # ]: 0 : net_info_ratelimited("source route option %pI4 -> %pI4\n",
290 : : &iph->saddr,
291 : : &iph->daddr);
292 : 0 : goto drop;
293 : : }
294 : : }
295 : :
296 [ # # ]: 0 : if (ip_options_rcv_srr(skb, dev))
297 : 0 : goto drop;
298 : : }
299 : :
300 : : return false;
301 : : drop:
302 : : return true;
303 : : }
304 : :
305 : : static bool ip_can_use_hint(const struct sk_buff *skb, const struct iphdr *iph,
306 : : const struct sk_buff *hint)
307 : : {
308 : : return hint && !skb_dst(skb) && ip_hdr(hint)->daddr == iph->daddr &&
309 : : ip_hdr(hint)->tos == iph->tos;
310 : : }
311 : :
312 : : INDIRECT_CALLABLE_DECLARE(int udp_v4_early_demux(struct sk_buff *));
313 : : INDIRECT_CALLABLE_DECLARE(int tcp_v4_early_demux(struct sk_buff *));
314 : : static int ip_rcv_finish_core(struct net *net, struct sock *sk,
315 : : struct sk_buff *skb, struct net_device *dev,
316 : : const struct sk_buff *hint)
317 : : {
318 : : const struct iphdr *iph = ip_hdr(skb);
319 : : int (*edemux)(struct sk_buff *skb);
320 : : struct rtable *rt;
321 : : int err;
322 : :
323 : : if (ip_can_use_hint(skb, iph, hint)) {
324 : : err = ip_route_use_hint(skb, iph->daddr, iph->saddr, iph->tos,
325 : : dev, hint);
326 : : if (unlikely(err))
327 : : goto drop_error;
328 : : }
329 : :
330 : : if (net->ipv4.sysctl_ip_early_demux &&
331 : : !skb_dst(skb) &&
332 : : !skb->sk &&
333 : : !ip_is_fragment(iph)) {
334 : : const struct net_protocol *ipprot;
335 : : int protocol = iph->protocol;
336 : :
337 : : ipprot = rcu_dereference(inet_protos[protocol]);
338 : : if (ipprot && (edemux = READ_ONCE(ipprot->early_demux))) {
339 : : err = INDIRECT_CALL_2(edemux, tcp_v4_early_demux,
340 : : udp_v4_early_demux, skb);
341 : : if (unlikely(err))
342 : : goto drop_error;
343 : : /* must reload iph, skb->head might have changed */
344 : : iph = ip_hdr(skb);
345 : : }
346 : : }
347 : :
348 : : /*
349 : : * Initialise the virtual path cache for the packet. It describes
350 : : * how the packet travels inside Linux networking.
351 : : */
352 : : if (!skb_valid_dst(skb)) {
353 : : err = ip_route_input_noref(skb, iph->daddr, iph->saddr,
354 : : iph->tos, dev);
355 : : if (unlikely(err))
356 : : goto drop_error;
357 : : }
358 : :
359 : : #ifdef CONFIG_IP_ROUTE_CLASSID
360 : : if (unlikely(skb_dst(skb)->tclassid)) {
361 : : struct ip_rt_acct *st = this_cpu_ptr(ip_rt_acct);
362 : : u32 idx = skb_dst(skb)->tclassid;
363 : : st[idx&0xFF].o_packets++;
364 : : st[idx&0xFF].o_bytes += skb->len;
365 : : st[(idx>>16)&0xFF].i_packets++;
366 : : st[(idx>>16)&0xFF].i_bytes += skb->len;
367 : : }
368 : : #endif
369 : :
370 : : if (iph->ihl > 5 && ip_rcv_options(skb, dev))
371 : : goto drop;
372 : :
373 : : rt = skb_rtable(skb);
374 : : if (rt->rt_type == RTN_MULTICAST) {
375 : : __IP_UPD_PO_STATS(net, IPSTATS_MIB_INMCAST, skb->len);
376 : : } else if (rt->rt_type == RTN_BROADCAST) {
377 : : __IP_UPD_PO_STATS(net, IPSTATS_MIB_INBCAST, skb->len);
378 : : } else if (skb->pkt_type == PACKET_BROADCAST ||
379 : : skb->pkt_type == PACKET_MULTICAST) {
380 : : struct in_device *in_dev = __in_dev_get_rcu(dev);
381 : :
382 : : /* RFC 1122 3.3.6:
383 : : *
384 : : * When a host sends a datagram to a link-layer broadcast
385 : : * address, the IP destination address MUST be a legal IP
386 : : * broadcast or IP multicast address.
387 : : *
388 : : * A host SHOULD silently discard a datagram that is received
389 : : * via a link-layer broadcast (see Section 2.4) but does not
390 : : * specify an IP multicast or broadcast destination address.
391 : : *
392 : : * This doesn't explicitly say L2 *broadcast*, but broadcast is
393 : : * in a way a form of multicast and the most common use case for
394 : : * this is 802.11 protecting against cross-station spoofing (the
395 : : * so-called "hole-196" attack) so do it for both.
396 : : */
397 : : if (in_dev &&
398 : : IN_DEV_ORCONF(in_dev, DROP_UNICAST_IN_L2_MULTICAST))
399 : : goto drop;
400 : : }
401 : :
402 : : return NET_RX_SUCCESS;
403 : :
404 : : drop:
405 : : kfree_skb(skb);
406 : : return NET_RX_DROP;
407 : :
408 : : drop_error:
409 : : if (err == -EXDEV)
410 : : __NET_INC_STATS(net, LINUX_MIB_IPRPFILTER);
411 : : goto drop;
412 : : }
413 : :
414 : 0 : static int ip_rcv_finish(struct net *net, struct sock *sk, struct sk_buff *skb)
415 : : {
416 : 0 : struct net_device *dev = skb->dev;
417 : 0 : int ret;
418 : :
419 : : /* if ingress device is enslaved to an L3 master device pass the
420 : : * skb to its handler for processing
421 : : */
422 [ # # ]: 0 : skb = l3mdev_ip_rcv(skb);
423 [ # # ]: 0 : if (!skb)
424 : : return NET_RX_SUCCESS;
425 : :
426 : 0 : ret = ip_rcv_finish_core(net, sk, skb, dev, NULL);
427 [ # # ]: 0 : if (ret != NET_RX_DROP)
428 : 0 : ret = dst_input(skb);
429 : : return ret;
430 : : }
431 : :
432 : : /*
433 : : * Main IP Receive routine.
434 : : */
435 : : static struct sk_buff *ip_rcv_core(struct sk_buff *skb, struct net *net)
436 : : {
437 : : const struct iphdr *iph;
438 : : u32 len;
439 : :
440 : : /* When the interface is in promisc. mode, drop all the crap
441 : : * that it receives, do not try to analyse it.
442 : : */
443 : : if (skb->pkt_type == PACKET_OTHERHOST)
444 : : goto drop;
445 : :
446 : : __IP_UPD_PO_STATS(net, IPSTATS_MIB_IN, skb->len);
447 : :
448 : : skb = skb_share_check(skb, GFP_ATOMIC);
449 : : if (!skb) {
450 : : __IP_INC_STATS(net, IPSTATS_MIB_INDISCARDS);
451 : : goto out;
452 : : }
453 : :
454 : : if (!pskb_may_pull(skb, sizeof(struct iphdr)))
455 : : goto inhdr_error;
456 : :
457 : : iph = ip_hdr(skb);
458 : :
459 : : /*
460 : : * RFC1122: 3.2.1.2 MUST silently discard any IP frame that fails the checksum.
461 : : *
462 : : * Is the datagram acceptable?
463 : : *
464 : : * 1. Length at least the size of an ip header
465 : : * 2. Version of 4
466 : : * 3. Checksums correctly. [Speed optimisation for later, skip loopback checksums]
467 : : * 4. Doesn't have a bogus length
468 : : */
469 : :
470 : : if (iph->ihl < 5 || iph->version != 4)
471 : : goto inhdr_error;
472 : :
473 : : BUILD_BUG_ON(IPSTATS_MIB_ECT1PKTS != IPSTATS_MIB_NOECTPKTS + INET_ECN_ECT_1);
474 : : BUILD_BUG_ON(IPSTATS_MIB_ECT0PKTS != IPSTATS_MIB_NOECTPKTS + INET_ECN_ECT_0);
475 : : BUILD_BUG_ON(IPSTATS_MIB_CEPKTS != IPSTATS_MIB_NOECTPKTS + INET_ECN_CE);
476 : : __IP_ADD_STATS(net,
477 : : IPSTATS_MIB_NOECTPKTS + (iph->tos & INET_ECN_MASK),
478 : : max_t(unsigned short, 1, skb_shinfo(skb)->gso_segs));
479 : :
480 : : if (!pskb_may_pull(skb, iph->ihl*4))
481 : : goto inhdr_error;
482 : :
483 : : iph = ip_hdr(skb);
484 : :
485 : : if (unlikely(ip_fast_csum((u8 *)iph, iph->ihl)))
486 : : goto csum_error;
487 : :
488 : : len = ntohs(iph->tot_len);
489 : : if (skb->len < len) {
490 : : __IP_INC_STATS(net, IPSTATS_MIB_INTRUNCATEDPKTS);
491 : : goto drop;
492 : : } else if (len < (iph->ihl*4))
493 : : goto inhdr_error;
494 : :
495 : : /* Our transport medium may have padded the buffer out. Now we know it
496 : : * is IP we can trim to the true length of the frame.
497 : : * Note this now means skb->len holds ntohs(iph->tot_len).
498 : : */
499 : : if (pskb_trim_rcsum(skb, len)) {
500 : : __IP_INC_STATS(net, IPSTATS_MIB_INDISCARDS);
501 : : goto drop;
502 : : }
503 : :
504 : : iph = ip_hdr(skb);
505 : : skb->transport_header = skb->network_header + iph->ihl*4;
506 : :
507 : : /* Remove any debris in the socket control block */
508 : : memset(IPCB(skb), 0, sizeof(struct inet_skb_parm));
509 : : IPCB(skb)->iif = skb->skb_iif;
510 : :
511 : : /* Must drop socket now because of tproxy. */
512 : : skb_orphan(skb);
513 : :
514 : : return skb;
515 : :
516 : : csum_error:
517 : : __IP_INC_STATS(net, IPSTATS_MIB_CSUMERRORS);
518 : : inhdr_error:
519 : : __IP_INC_STATS(net, IPSTATS_MIB_INHDRERRORS);
520 : : drop:
521 : : kfree_skb(skb);
522 : : out:
523 : : return NULL;
524 : : }
525 : :
526 : : /*
527 : : * IP receive entry point
528 : : */
529 : 0 : int ip_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt,
530 : : struct net_device *orig_dev)
531 : : {
532 : 0 : struct net *net = dev_net(dev);
533 : :
534 : 0 : skb = ip_rcv_core(skb, net);
535 [ # # ]: 0 : if (skb == NULL)
536 : : return NET_RX_DROP;
537 : :
538 : 0 : return NF_HOOK(NFPROTO_IPV4, NF_INET_PRE_ROUTING,
539 : : net, NULL, skb, dev, NULL,
540 : : ip_rcv_finish);
541 : : }
542 : :
543 : 0 : static void ip_sublist_rcv_finish(struct list_head *head)
544 : : {
545 : 0 : struct sk_buff *skb, *next;
546 : :
547 [ # # ]: 0 : list_for_each_entry_safe(skb, next, head, list) {
548 : 0 : skb_list_del_init(skb);
549 : 0 : dst_input(skb);
550 : : }
551 : 0 : }
552 : :
553 : : static struct sk_buff *ip_extract_route_hint(const struct net *net,
554 : : struct sk_buff *skb, int rt_type)
555 : : {
556 : : if (fib4_has_custom_rules(net) || rt_type == RTN_BROADCAST)
557 : : return NULL;
558 : :
559 : : return skb;
560 : : }
561 : :
562 : : static void ip_list_rcv_finish(struct net *net, struct sock *sk,
563 : : struct list_head *head)
564 : : {
565 : : struct sk_buff *skb, *next, *hint = NULL;
566 : : struct dst_entry *curr_dst = NULL;
567 : : struct list_head sublist;
568 : :
569 : : INIT_LIST_HEAD(&sublist);
570 : : list_for_each_entry_safe(skb, next, head, list) {
571 : : struct net_device *dev = skb->dev;
572 : : struct dst_entry *dst;
573 : :
574 : : skb_list_del_init(skb);
575 : : /* if ingress device is enslaved to an L3 master device pass the
576 : : * skb to its handler for processing
577 : : */
578 : : skb = l3mdev_ip_rcv(skb);
579 : : if (!skb)
580 : : continue;
581 : : if (ip_rcv_finish_core(net, sk, skb, dev, hint) == NET_RX_DROP)
582 : : continue;
583 : :
584 : : dst = skb_dst(skb);
585 : : if (curr_dst != dst) {
586 : : hint = ip_extract_route_hint(net, skb,
587 : : ((struct rtable *)dst)->rt_type);
588 : :
589 : : /* dispatch old sublist */
590 : : if (!list_empty(&sublist))
591 : : ip_sublist_rcv_finish(&sublist);
592 : : /* start new sublist */
593 : : INIT_LIST_HEAD(&sublist);
594 : : curr_dst = dst;
595 : : }
596 : : list_add_tail(&skb->list, &sublist);
597 : : }
598 : : /* dispatch final sublist */
599 : : ip_sublist_rcv_finish(&sublist);
600 : : }
601 : :
602 : 0 : static void ip_sublist_rcv(struct list_head *head, struct net_device *dev,
603 : : struct net *net)
604 : : {
605 : 0 : NF_HOOK_LIST(NFPROTO_IPV4, NF_INET_PRE_ROUTING, net, NULL,
606 : : head, dev, NULL, ip_rcv_finish);
607 : 0 : ip_list_rcv_finish(net, NULL, head);
608 : 0 : }
609 : :
610 : : /* Receive a list of IP packets */
611 : 0 : void ip_list_rcv(struct list_head *head, struct packet_type *pt,
612 : : struct net_device *orig_dev)
613 : : {
614 : 0 : struct net_device *curr_dev = NULL;
615 : 0 : struct net *curr_net = NULL;
616 : 0 : struct sk_buff *skb, *next;
617 : 0 : struct list_head sublist;
618 : :
619 : 0 : INIT_LIST_HEAD(&sublist);
620 [ # # ]: 0 : list_for_each_entry_safe(skb, next, head, list) {
621 : 0 : struct net_device *dev = skb->dev;
622 : 0 : struct net *net = dev_net(dev);
623 : :
624 : 0 : skb_list_del_init(skb);
625 : 0 : skb = ip_rcv_core(skb, net);
626 [ # # ]: 0 : if (skb == NULL)
627 : 0 : continue;
628 : :
629 [ # # ]: 0 : if (curr_dev != dev || curr_net != net) {
630 : : /* dispatch old sublist */
631 [ # # ]: 0 : if (!list_empty(&sublist))
632 : 0 : ip_sublist_rcv(&sublist, curr_dev, curr_net);
633 : : /* start new sublist */
634 : 0 : INIT_LIST_HEAD(&sublist);
635 : 0 : curr_dev = dev;
636 : 0 : curr_net = net;
637 : : }
638 : 0 : list_add_tail(&skb->list, &sublist);
639 : : }
640 : : /* dispatch final sublist */
641 [ # # ]: 0 : if (!list_empty(&sublist))
642 : 0 : ip_sublist_rcv(&sublist, curr_dev, curr_net);
643 : 0 : }
|
