1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116#define pr_fmt(fmt) "IPv4: " fmt
117
118#include <linux/module.h>
119#include <linux/types.h>
120#include <linux/kernel.h>
121#include <linux/string.h>
122#include <linux/errno.h>
123#include <linux/slab.h>
124
125#include <linux/net.h>
126#include <linux/socket.h>
127#include <linux/sockios.h>
128#include <linux/in.h>
129#include <linux/inet.h>
130#include <linux/inetdevice.h>
131#include <linux/netdevice.h>
132#include <linux/etherdevice.h>
133
134#include <net/snmp.h>
135#include <net/ip.h>
136#include <net/protocol.h>
137#include <net/route.h>
138#include <linux/skbuff.h>
139#include <net/sock.h>
140#include <net/arp.h>
141#include <net/icmp.h>
142#include <net/raw.h>
143#include <net/checksum.h>
144#include <net/inet_ecn.h>
145#include <linux/netfilter_ipv4.h>
146#include <net/xfrm.h>
147#include <linux/mroute.h>
148#include <linux/netlink.h>
149#include <net/dst_metadata.h>
150
151
152
153
154bool ip_call_ra_chain(struct sk_buff *skb)
155{
156 struct ip_ra_chain *ra;
157 u8 protocol = ip_hdr(skb)->protocol;
158 struct sock *last = NULL;
159 struct net_device *dev = skb->dev;
160 struct net *net = dev_net(dev);
161
162 for (ra = rcu_dereference(ip_ra_chain); ra; ra = rcu_dereference(ra->next)) {
163 struct sock *sk = ra->sk;
164
165
166
167
168 if (sk && inet_sk(sk)->inet_num == protocol &&
169 (!sk->sk_bound_dev_if ||
170 sk->sk_bound_dev_if == dev->ifindex) &&
171 net_eq(sock_net(sk), net)) {
172 if (ip_is_fragment(ip_hdr(skb))) {
173 if (ip_defrag(net, skb, IP_DEFRAG_CALL_RA_CHAIN))
174 return true;
175 }
176 if (last) {
177 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
178 if (skb2)
179 raw_rcv(last, skb2);
180 }
181 last = sk;
182 }
183 }
184
185 if (last) {
186 raw_rcv(last, skb);
187 return true;
188 }
189 return false;
190}
191
192static int ip_local_deliver_finish(struct net *net, struct sock *sk, struct sk_buff *skb)
193{
194 __skb_pull(skb, skb_network_header_len(skb));
195
196 rcu_read_lock();
197 {
198 int protocol = ip_hdr(skb)->protocol;
199 const struct net_protocol *ipprot;
200 int raw;
201
202 resubmit:
203 raw = raw_local_deliver(skb, protocol);
204
205 ipprot = rcu_dereference(inet_protos[protocol]);
206 if (ipprot) {
207 int ret;
208
209 if (!ipprot->no_policy) {
210 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
211 kfree_skb(skb);
212 goto out;
213 }
214 nf_reset(skb);
215 }
216 ret = ipprot->handler(skb);
217 if (ret < 0) {
218 protocol = -ret;
219 goto resubmit;
220 }
221 __IP_INC_STATS(net, IPSTATS_MIB_INDELIVERS);
222 } else {
223 if (!raw) {
224 if (xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
225 __IP_INC_STATS(net, IPSTATS_MIB_INUNKNOWNPROTOS);
226 icmp_send(skb, ICMP_DEST_UNREACH,
227 ICMP_PROT_UNREACH, 0);
228 }
229 kfree_skb(skb);
230 } else {
231 __IP_INC_STATS(net, IPSTATS_MIB_INDELIVERS);
232 consume_skb(skb);
233 }
234 }
235 }
236 out:
237 rcu_read_unlock();
238
239 return 0;
240}
241
242
243
244
245int ip_local_deliver(struct sk_buff *skb)
246{
247
248
249
250 struct net *net = dev_net(skb->dev);
251
252 if (ip_is_fragment(ip_hdr(skb))) {
253 if (ip_defrag(net, skb, IP_DEFRAG_LOCAL_DELIVER))
254 return 0;
255 }
256
257 return NF_HOOK(NFPROTO_IPV4, NF_INET_LOCAL_IN,
258 net, NULL, skb, skb->dev, NULL,
259 ip_local_deliver_finish);
260}
261
262static inline bool ip_rcv_options(struct sk_buff *skb)
263{
264 struct ip_options *opt;
265 const struct iphdr *iph;
266 struct net_device *dev = skb->dev;
267
268
269
270
271
272
273
274
275 if (skb_cow(skb, skb_headroom(skb))) {
276 __IP_INC_STATS(dev_net(dev), IPSTATS_MIB_INDISCARDS);
277 goto drop;
278 }
279
280 iph = ip_hdr(skb);
281 opt = &(IPCB(skb)->opt);
282 opt->optlen = iph->ihl*4 - sizeof(struct iphdr);
283
284 if (ip_options_compile(dev_net(dev), opt, skb)) {
285 __IP_INC_STATS(dev_net(dev), IPSTATS_MIB_INHDRERRORS);
286 goto drop;
287 }
288
289 if (unlikely(opt->srr)) {
290 struct in_device *in_dev = __in_dev_get_rcu(dev);
291
292 if (in_dev) {
293 if (!IN_DEV_SOURCE_ROUTE(in_dev)) {
294 if (IN_DEV_LOG_MARTIANS(in_dev))
295 net_info_ratelimited("source route option %pI4 -> %pI4\n",
296 &iph->saddr,
297 &iph->daddr);
298 goto drop;
299 }
300 }
301
302 if (ip_options_rcv_srr(skb))
303 goto drop;
304 }
305
306 return false;
307drop:
308 return true;
309}
310
311static int ip_rcv_finish(struct net *net, struct sock *sk, struct sk_buff *skb)
312{
313 const struct iphdr *iph = ip_hdr(skb);
314 int (*edemux)(struct sk_buff *skb);
315 struct net_device *dev = skb->dev;
316 struct rtable *rt;
317 int err;
318
319
320
321
322 skb = l3mdev_ip_rcv(skb);
323 if (!skb)
324 return NET_RX_SUCCESS;
325
326 if (net->ipv4.sysctl_ip_early_demux &&
327 !skb_dst(skb) &&
328 !skb->sk &&
329 !ip_is_fragment(iph)) {
330 const struct net_protocol *ipprot;
331 int protocol = iph->protocol;
332
333 ipprot = rcu_dereference(inet_protos[protocol]);
334 if (ipprot && (edemux = READ_ONCE(ipprot->early_demux))) {
335 err = edemux(skb);
336 if (unlikely(err))
337 goto drop_error;
338
339 iph = ip_hdr(skb);
340 }
341 }
342
343
344
345
346
347 if (!skb_valid_dst(skb)) {
348 err = ip_route_input_noref(skb, iph->daddr, iph->saddr,
349 iph->tos, dev);
350 if (unlikely(err))
351 goto drop_error;
352 }
353
354#ifdef CONFIG_IP_ROUTE_CLASSID
355 if (unlikely(skb_dst(skb)->tclassid)) {
356 struct ip_rt_acct *st = this_cpu_ptr(ip_rt_acct);
357 u32 idx = skb_dst(skb)->tclassid;
358 st[idx&0xFF].o_packets++;
359 st[idx&0xFF].o_bytes += skb->len;
360 st[(idx>>16)&0xFF].i_packets++;
361 st[(idx>>16)&0xFF].i_bytes += skb->len;
362 }
363#endif
364
365 if (iph->ihl > 5 && ip_rcv_options(skb))
366 goto drop;
367
368 rt = skb_rtable(skb);
369 if (rt->rt_type == RTN_MULTICAST) {
370 __IP_UPD_PO_STATS(net, IPSTATS_MIB_INMCAST, skb->len);
371 } else if (rt->rt_type == RTN_BROADCAST) {
372 __IP_UPD_PO_STATS(net, IPSTATS_MIB_INBCAST, skb->len);
373 } else if (skb->pkt_type == PACKET_BROADCAST ||
374 skb->pkt_type == PACKET_MULTICAST) {
375 struct in_device *in_dev = __in_dev_get_rcu(dev);
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392 if (in_dev &&
393 IN_DEV_ORCONF(in_dev, DROP_UNICAST_IN_L2_MULTICAST))
394 goto drop;
395 }
396
397 return dst_input(skb);
398
399drop:
400 kfree_skb(skb);
401 return NET_RX_DROP;
402
403drop_error:
404 if (err == -EXDEV)
405 __NET_INC_STATS(net, LINUX_MIB_IPRPFILTER);
406 goto drop;
407}
408
409
410
411
412int ip_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
413{
414 const struct iphdr *iph;
415 struct net *net;
416 u32 len;
417
418
419
420
421 if (skb->pkt_type == PACKET_OTHERHOST)
422 goto drop;
423
424
425 net = dev_net(dev);
426 __IP_UPD_PO_STATS(net, IPSTATS_MIB_IN, skb->len);
427
428 skb = skb_share_check(skb, GFP_ATOMIC);
429 if (!skb) {
430 __IP_INC_STATS(net, IPSTATS_MIB_INDISCARDS);
431 goto out;
432 }
433
434 if (!pskb_may_pull(skb, sizeof(struct iphdr)))
435 goto inhdr_error;
436
437 iph = ip_hdr(skb);
438
439
440
441
442
443
444
445
446
447
448
449
450 if (iph->ihl < 5 || iph->version != 4)
451 goto inhdr_error;
452
453 BUILD_BUG_ON(IPSTATS_MIB_ECT1PKTS != IPSTATS_MIB_NOECTPKTS + INET_ECN_ECT_1);
454 BUILD_BUG_ON(IPSTATS_MIB_ECT0PKTS != IPSTATS_MIB_NOECTPKTS + INET_ECN_ECT_0);
455 BUILD_BUG_ON(IPSTATS_MIB_CEPKTS != IPSTATS_MIB_NOECTPKTS + INET_ECN_CE);
456 __IP_ADD_STATS(net,
457 IPSTATS_MIB_NOECTPKTS + (iph->tos & INET_ECN_MASK),
458 max_t(unsigned short, 1, skb_shinfo(skb)->gso_segs));
459
460 if (!pskb_may_pull(skb, iph->ihl*4))
461 goto inhdr_error;
462
463 iph = ip_hdr(skb);
464
465 if (unlikely(ip_fast_csum((u8 *)iph, iph->ihl)))
466 goto csum_error;
467
468 len = ntohs(iph->tot_len);
469 if (skb->len < len) {
470 __IP_INC_STATS(net, IPSTATS_MIB_INTRUNCATEDPKTS);
471 goto drop;
472 } else if (len < (iph->ihl*4))
473 goto inhdr_error;
474
475
476
477
478
479 if (pskb_trim_rcsum(skb, len)) {
480 __IP_INC_STATS(net, IPSTATS_MIB_INDISCARDS);
481 goto drop;
482 }
483
484 skb->transport_header = skb->network_header + iph->ihl*4;
485
486
487 memset(IPCB(skb), 0, sizeof(struct inet_skb_parm));
488 IPCB(skb)->iif = skb->skb_iif;
489
490
491 skb_orphan(skb);
492
493 return NF_HOOK(NFPROTO_IPV4, NF_INET_PRE_ROUTING,
494 net, NULL, skb, dev, NULL,
495 ip_rcv_finish);
496
497csum_error:
498 __IP_INC_STATS(net, IPSTATS_MIB_CSUMERRORS);
499inhdr_error:
500 __IP_INC_STATS(net, IPSTATS_MIB_INHDRERRORS);
501drop:
502 kfree_skb(skb);
503out:
504 return NET_RX_DROP;
505}
506