]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - net/ipv4/route.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'armsoc-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc
[mirror_ubuntu-bionic-kernel.git] / net / ipv4 / route.c
1 /*
2 * INET An implementation of the TCP/IP protocol suite for the LINUX
3 * operating system. INET is implemented using the BSD Socket
4 * interface as the means of communication with the user level.
5 *
6 * ROUTE - implementation of the IP router.
7 *
8 * Authors: Ross Biro
9 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
10 * Alan Cox, <gw4pts@gw4pts.ampr.org>
11 * Linus Torvalds, <Linus.Torvalds@helsinki.fi>
12 * Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
13 *
14 * Fixes:
15 * Alan Cox : Verify area fixes.
16 * Alan Cox : cli() protects routing changes
17 * Rui Oliveira : ICMP routing table updates
18 * (rco@di.uminho.pt) Routing table insertion and update
19 * Linus Torvalds : Rewrote bits to be sensible
20 * Alan Cox : Added BSD route gw semantics
21 * Alan Cox : Super /proc >4K
22 * Alan Cox : MTU in route table
23 * Alan Cox : MSS actually. Also added the window
24 * clamper.
25 * Sam Lantinga : Fixed route matching in rt_del()
26 * Alan Cox : Routing cache support.
27 * Alan Cox : Removed compatibility cruft.
28 * Alan Cox : RTF_REJECT support.
29 * Alan Cox : TCP irtt support.
30 * Jonathan Naylor : Added Metric support.
31 * Miquel van Smoorenburg : BSD API fixes.
32 * Miquel van Smoorenburg : Metrics.
33 * Alan Cox : Use __u32 properly
34 * Alan Cox : Aligned routing errors more closely with BSD
35 * our system is still very different.
36 * Alan Cox : Faster /proc handling
37 * Alexey Kuznetsov : Massive rework to support tree based routing,
38 * routing caches and better behaviour.
39 *
40 * Olaf Erb : irtt wasn't being copied right.
41 * Bjorn Ekwall : Kerneld route support.
42 * Alan Cox : Multicast fixed (I hope)
43 * Pavel Krauz : Limited broadcast fixed
44 * Mike McLagan : Routing by source
45 * Alexey Kuznetsov : End of old history. Split to fib.c and
46 * route.c and rewritten from scratch.
47 * Andi Kleen : Load-limit warning messages.
48 * Vitaly E. Lavrov : Transparent proxy revived after year coma.
49 * Vitaly E. Lavrov : Race condition in ip_route_input_slow.
50 * Tobias Ringstrom : Uninitialized res.type in ip_route_output_slow.
51 * Vladimir V. Ivanov : IP rule info (flowid) is really useful.
52 * Marc Boucher : routing by fwmark
53 * Robert Olsson : Added rt_cache statistics
54 * Arnaldo C. Melo : Convert proc stuff to seq_file
55 * Eric Dumazet : hashed spinlocks and rt_check_expire() fixes.
56 * Ilia Sotnikov : Ignore TOS on PMTUD and Redirect
57 * Ilia Sotnikov : Removed TOS from hash calculations
58 *
59 * This program is free software; you can redistribute it and/or
60 * modify it under the terms of the GNU General Public License
61 * as published by the Free Software Foundation; either version
62 * 2 of the License, or (at your option) any later version.
63 */
64
65 #define pr_fmt(fmt) "IPv4: " fmt
66
67 #include <linux/module.h>
68 #include <linux/uaccess.h>
69 #include <linux/bitops.h>
70 #include <linux/types.h>
71 #include <linux/kernel.h>
72 #include <linux/mm.h>
73 #include <linux/string.h>
74 #include <linux/socket.h>
75 #include <linux/sockios.h>
76 #include <linux/errno.h>
77 #include <linux/in.h>
78 #include <linux/inet.h>
79 #include <linux/netdevice.h>
80 #include <linux/proc_fs.h>
81 #include <linux/init.h>
82 #include <linux/skbuff.h>
83 #include <linux/inetdevice.h>
84 #include <linux/igmp.h>
85 #include <linux/pkt_sched.h>
86 #include <linux/mroute.h>
87 #include <linux/netfilter_ipv4.h>
88 #include <linux/random.h>
89 #include <linux/rcupdate.h>
90 #include <linux/times.h>
91 #include <linux/slab.h>
92 #include <linux/jhash.h>
93 #include <net/dst.h>
94 #include <net/dst_metadata.h>
95 #include <net/net_namespace.h>
96 #include <net/protocol.h>
97 #include <net/ip.h>
98 #include <net/route.h>
99 #include <net/inetpeer.h>
100 #include <net/sock.h>
101 #include <net/ip_fib.h>
102 #include <net/arp.h>
103 #include <net/tcp.h>
104 #include <net/icmp.h>
105 #include <net/xfrm.h>
106 #include <net/lwtunnel.h>
107 #include <net/netevent.h>
108 #include <net/rtnetlink.h>
109 #ifdef CONFIG_SYSCTL
110 #include <linux/sysctl.h>
111 #include <linux/kmemleak.h>
112 #endif
113 #include <net/secure_seq.h>
114 #include <net/ip_tunnels.h>
115 #include <net/l3mdev.h>
116
117 #include "fib_lookup.h"
118
119 #define RT_FL_TOS(oldflp4) \
120 ((oldflp4)->flowi4_tos & (IPTOS_RT_MASK | RTO_ONLINK))
121
122 #define RT_GC_TIMEOUT (300*HZ)
123
124 static int ip_rt_max_size;
125 static int ip_rt_redirect_number __read_mostly = 9;
126 static int ip_rt_redirect_load __read_mostly = HZ / 50;
127 static int ip_rt_redirect_silence __read_mostly = ((HZ / 50) << (9 + 1));
128 static int ip_rt_error_cost __read_mostly = HZ;
129 static int ip_rt_error_burst __read_mostly = 5 * HZ;
130 static int ip_rt_mtu_expires __read_mostly = 10 * 60 * HZ;
131 static int ip_rt_min_pmtu __read_mostly = 512 + 20 + 20;
132 static int ip_rt_min_advmss __read_mostly = 256;
133
134 static int ip_rt_gc_timeout __read_mostly = RT_GC_TIMEOUT;
135 /*
136 * Interface to generic destination cache.
137 */
138
139 static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie);
140 static unsigned int ipv4_default_advmss(const struct dst_entry *dst);
141 static unsigned int ipv4_mtu(const struct dst_entry *dst);
142 static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst);
143 static void ipv4_link_failure(struct sk_buff *skb);
144 static void ip_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
145 struct sk_buff *skb, u32 mtu);
146 static void ip_do_redirect(struct dst_entry *dst, struct sock *sk,
147 struct sk_buff *skb);
148 static void ipv4_dst_destroy(struct dst_entry *dst);
149
150 static u32 *ipv4_cow_metrics(struct dst_entry *dst, unsigned long old)
151 {
152 WARN_ON(1);
153 return NULL;
154 }
155
156 static struct neighbour *ipv4_neigh_lookup(const struct dst_entry *dst,
157 struct sk_buff *skb,
158 const void *daddr);
159 static void ipv4_confirm_neigh(const struct dst_entry *dst, const void *daddr);
160
161 static struct dst_ops ipv4_dst_ops = {
162 .family = AF_INET,
163 .check = ipv4_dst_check,
164 .default_advmss = ipv4_default_advmss,
165 .mtu = ipv4_mtu,
166 .cow_metrics = ipv4_cow_metrics,
167 .destroy = ipv4_dst_destroy,
168 .negative_advice = ipv4_negative_advice,
169 .link_failure = ipv4_link_failure,
170 .update_pmtu = ip_rt_update_pmtu,
171 .redirect = ip_do_redirect,
172 .local_out = __ip_local_out,
173 .neigh_lookup = ipv4_neigh_lookup,
174 .confirm_neigh = ipv4_confirm_neigh,
175 };
176
177 #define ECN_OR_COST(class) TC_PRIO_##class
178
179 const __u8 ip_tos2prio[16] = {
180 TC_PRIO_BESTEFFORT,
181 ECN_OR_COST(BESTEFFORT),
182 TC_PRIO_BESTEFFORT,
183 ECN_OR_COST(BESTEFFORT),
184 TC_PRIO_BULK,
185 ECN_OR_COST(BULK),
186 TC_PRIO_BULK,
187 ECN_OR_COST(BULK),
188 TC_PRIO_INTERACTIVE,
189 ECN_OR_COST(INTERACTIVE),
190 TC_PRIO_INTERACTIVE,
191 ECN_OR_COST(INTERACTIVE),
192 TC_PRIO_INTERACTIVE_BULK,
193 ECN_OR_COST(INTERACTIVE_BULK),
194 TC_PRIO_INTERACTIVE_BULK,
195 ECN_OR_COST(INTERACTIVE_BULK)
196 };
197 EXPORT_SYMBOL(ip_tos2prio);
198
199 static DEFINE_PER_CPU(struct rt_cache_stat, rt_cache_stat);
200 #define RT_CACHE_STAT_INC(field) raw_cpu_inc(rt_cache_stat.field)
201
202 #ifdef CONFIG_PROC_FS
203 static void *rt_cache_seq_start(struct seq_file *seq, loff_t *pos)
204 {
205 if (*pos)
206 return NULL;
207 return SEQ_START_TOKEN;
208 }
209
210 static void *rt_cache_seq_next(struct seq_file *seq, void *v, loff_t *pos)
211 {
212 ++*pos;
213 return NULL;
214 }
215
216 static void rt_cache_seq_stop(struct seq_file *seq, void *v)
217 {
218 }
219
220 static int rt_cache_seq_show(struct seq_file *seq, void *v)
221 {
222 if (v == SEQ_START_TOKEN)
223 seq_printf(seq, "%-127s\n",
224 "Iface\tDestination\tGateway \tFlags\t\tRefCnt\tUse\t"
225 "Metric\tSource\t\tMTU\tWindow\tIRTT\tTOS\tHHRef\t"
226 "HHUptod\tSpecDst");
227 return 0;
228 }
229
230 static const struct seq_operations rt_cache_seq_ops = {
231 .start = rt_cache_seq_start,
232 .next = rt_cache_seq_next,
233 .stop = rt_cache_seq_stop,
234 .show = rt_cache_seq_show,
235 };
236
237 static int rt_cache_seq_open(struct inode *inode, struct file *file)
238 {
239 return seq_open(file, &rt_cache_seq_ops);
240 }
241
242 static const struct file_operations rt_cache_seq_fops = {
243 .owner = THIS_MODULE,
244 .open = rt_cache_seq_open,
245 .read = seq_read,
246 .llseek = seq_lseek,
247 .release = seq_release,
248 };
249
250
251 static void *rt_cpu_seq_start(struct seq_file *seq, loff_t *pos)
252 {
253 int cpu;
254
255 if (*pos == 0)
256 return SEQ_START_TOKEN;
257
258 for (cpu = *pos-1; cpu < nr_cpu_ids; ++cpu) {
259 if (!cpu_possible(cpu))
260 continue;
261 *pos = cpu+1;
262 return &per_cpu(rt_cache_stat, cpu);
263 }
264 return NULL;
265 }
266
267 static void *rt_cpu_seq_next(struct seq_file *seq, void *v, loff_t *pos)
268 {
269 int cpu;
270
271 for (cpu = *pos; cpu < nr_cpu_ids; ++cpu) {
272 if (!cpu_possible(cpu))
273 continue;
274 *pos = cpu+1;
275 return &per_cpu(rt_cache_stat, cpu);
276 }
277 return NULL;
278
279 }
280
281 static void rt_cpu_seq_stop(struct seq_file *seq, void *v)
282 {
283
284 }
285
286 static int rt_cpu_seq_show(struct seq_file *seq, void *v)
287 {
288 struct rt_cache_stat *st = v;
289
290 if (v == SEQ_START_TOKEN) {
291 seq_printf(seq, "entries in_hit in_slow_tot in_slow_mc in_no_route in_brd in_martian_dst in_martian_src out_hit out_slow_tot out_slow_mc gc_total gc_ignored gc_goal_miss gc_dst_overflow in_hlist_search out_hlist_search\n");
292 return 0;
293 }
294
295 seq_printf(seq,"%08x %08x %08x %08x %08x %08x %08x %08x "
296 " %08x %08x %08x %08x %08x %08x %08x %08x %08x \n",
297 dst_entries_get_slow(&ipv4_dst_ops),
298 0, /* st->in_hit */
299 st->in_slow_tot,
300 st->in_slow_mc,
301 st->in_no_route,
302 st->in_brd,
303 st->in_martian_dst,
304 st->in_martian_src,
305
306 0, /* st->out_hit */
307 st->out_slow_tot,
308 st->out_slow_mc,
309
310 0, /* st->gc_total */
311 0, /* st->gc_ignored */
312 0, /* st->gc_goal_miss */
313 0, /* st->gc_dst_overflow */
314 0, /* st->in_hlist_search */
315 0 /* st->out_hlist_search */
316 );
317 return 0;
318 }
319
320 static const struct seq_operations rt_cpu_seq_ops = {
321 .start = rt_cpu_seq_start,
322 .next = rt_cpu_seq_next,
323 .stop = rt_cpu_seq_stop,
324 .show = rt_cpu_seq_show,
325 };
326
327
328 static int rt_cpu_seq_open(struct inode *inode, struct file *file)
329 {
330 return seq_open(file, &rt_cpu_seq_ops);
331 }
332
333 static const struct file_operations rt_cpu_seq_fops = {
334 .owner = THIS_MODULE,
335 .open = rt_cpu_seq_open,
336 .read = seq_read,
337 .llseek = seq_lseek,
338 .release = seq_release,
339 };
340
341 #ifdef CONFIG_IP_ROUTE_CLASSID
342 static int rt_acct_proc_show(struct seq_file *m, void *v)
343 {
344 struct ip_rt_acct *dst, *src;
345 unsigned int i, j;
346
347 dst = kcalloc(256, sizeof(struct ip_rt_acct), GFP_KERNEL);
348 if (!dst)
349 return -ENOMEM;
350
351 for_each_possible_cpu(i) {
352 src = (struct ip_rt_acct *)per_cpu_ptr(ip_rt_acct, i);
353 for (j = 0; j < 256; j++) {
354 dst[j].o_bytes += src[j].o_bytes;
355 dst[j].o_packets += src[j].o_packets;
356 dst[j].i_bytes += src[j].i_bytes;
357 dst[j].i_packets += src[j].i_packets;
358 }
359 }
360
361 seq_write(m, dst, 256 * sizeof(struct ip_rt_acct));
362 kfree(dst);
363 return 0;
364 }
365
366 static int rt_acct_proc_open(struct inode *inode, struct file *file)
367 {
368 return single_open(file, rt_acct_proc_show, NULL);
369 }
370
371 static const struct file_operations rt_acct_proc_fops = {
372 .owner = THIS_MODULE,
373 .open = rt_acct_proc_open,
374 .read = seq_read,
375 .llseek = seq_lseek,
376 .release = single_release,
377 };
378 #endif
379
380 static int __net_init ip_rt_do_proc_init(struct net *net)
381 {
382 struct proc_dir_entry *pde;
383
384 pde = proc_create("rt_cache", S_IRUGO, net->proc_net,
385 &rt_cache_seq_fops);
386 if (!pde)
387 goto err1;
388
389 pde = proc_create("rt_cache", S_IRUGO,
390 net->proc_net_stat, &rt_cpu_seq_fops);
391 if (!pde)
392 goto err2;
393
394 #ifdef CONFIG_IP_ROUTE_CLASSID
395 pde = proc_create("rt_acct", 0, net->proc_net, &rt_acct_proc_fops);
396 if (!pde)
397 goto err3;
398 #endif
399 return 0;
400
401 #ifdef CONFIG_IP_ROUTE_CLASSID
402 err3:
403 remove_proc_entry("rt_cache", net->proc_net_stat);
404 #endif
405 err2:
406 remove_proc_entry("rt_cache", net->proc_net);
407 err1:
408 return -ENOMEM;
409 }
410
411 static void __net_exit ip_rt_do_proc_exit(struct net *net)
412 {
413 remove_proc_entry("rt_cache", net->proc_net_stat);
414 remove_proc_entry("rt_cache", net->proc_net);
415 #ifdef CONFIG_IP_ROUTE_CLASSID
416 remove_proc_entry("rt_acct", net->proc_net);
417 #endif
418 }
419
420 static struct pernet_operations ip_rt_proc_ops __net_initdata = {
421 .init = ip_rt_do_proc_init,
422 .exit = ip_rt_do_proc_exit,
423 };
424
425 static int __init ip_rt_proc_init(void)
426 {
427 return register_pernet_subsys(&ip_rt_proc_ops);
428 }
429
430 #else
431 static inline int ip_rt_proc_init(void)
432 {
433 return 0;
434 }
435 #endif /* CONFIG_PROC_FS */
436
437 static inline bool rt_is_expired(const struct rtable *rth)
438 {
439 return rth->rt_genid != rt_genid_ipv4(dev_net(rth->dst.dev));
440 }
441
442 void rt_cache_flush(struct net *net)
443 {
444 rt_genid_bump_ipv4(net);
445 }
446
447 static struct neighbour *ipv4_neigh_lookup(const struct dst_entry *dst,
448 struct sk_buff *skb,
449 const void *daddr)
450 {
451 struct net_device *dev = dst->dev;
452 const __be32 *pkey = daddr;
453 const struct rtable *rt;
454 struct neighbour *n;
455
456 rt = (const struct rtable *) dst;
457 if (rt->rt_gateway)
458 pkey = (const __be32 *) &rt->rt_gateway;
459 else if (skb)
460 pkey = &ip_hdr(skb)->daddr;
461
462 n = __ipv4_neigh_lookup(dev, *(__force u32 *)pkey);
463 if (n)
464 return n;
465 return neigh_create(&arp_tbl, pkey, dev);
466 }
467
468 static void ipv4_confirm_neigh(const struct dst_entry *dst, const void *daddr)
469 {
470 struct net_device *dev = dst->dev;
471 const __be32 *pkey = daddr;
472 const struct rtable *rt;
473
474 rt = (const struct rtable *)dst;
475 if (rt->rt_gateway)
476 pkey = (const __be32 *)&rt->rt_gateway;
477 else if (!daddr ||
478 (rt->rt_flags &
479 (RTCF_MULTICAST | RTCF_BROADCAST | RTCF_LOCAL)))
480 return;
481
482 __ipv4_confirm_neigh(dev, *(__force u32 *)pkey);
483 }
484
485 #define IP_IDENTS_SZ 2048u
486
487 static atomic_t *ip_idents __read_mostly;
488 static u32 *ip_tstamps __read_mostly;
489
490 /* In order to protect privacy, we add a perturbation to identifiers
491 * if one generator is seldom used. This makes hard for an attacker
492 * to infer how many packets were sent between two points in time.
493 */
494 u32 ip_idents_reserve(u32 hash, int segs)
495 {
496 u32 *p_tstamp = ip_tstamps + hash % IP_IDENTS_SZ;
497 atomic_t *p_id = ip_idents + hash % IP_IDENTS_SZ;
498 u32 old = READ_ONCE(*p_tstamp);
499 u32 now = (u32)jiffies;
500 u32 new, delta = 0;
501
502 if (old != now && cmpxchg(p_tstamp, old, now) == old)
503 delta = prandom_u32_max(now - old);
504
505 /* Do not use atomic_add_return() as it makes UBSAN unhappy */
506 do {
507 old = (u32)atomic_read(p_id);
508 new = old + delta + segs;
509 } while (atomic_cmpxchg(p_id, old, new) != old);
510
511 return new - segs;
512 }
513 EXPORT_SYMBOL(ip_idents_reserve);
514
515 void __ip_select_ident(struct net *net, struct iphdr *iph, int segs)
516 {
517 static u32 ip_idents_hashrnd __read_mostly;
518 u32 hash, id;
519
520 net_get_random_once(&ip_idents_hashrnd, sizeof(ip_idents_hashrnd));
521
522 hash = jhash_3words((__force u32)iph->daddr,
523 (__force u32)iph->saddr,
524 iph->protocol ^ net_hash_mix(net),
525 ip_idents_hashrnd);
526 id = ip_idents_reserve(hash, segs);
527 iph->id = htons(id);
528 }
529 EXPORT_SYMBOL(__ip_select_ident);
530
531 static void __build_flow_key(const struct net *net, struct flowi4 *fl4,
532 const struct sock *sk,
533 const struct iphdr *iph,
534 int oif, u8 tos,
535 u8 prot, u32 mark, int flow_flags)
536 {
537 if (sk) {
538 const struct inet_sock *inet = inet_sk(sk);
539
540 oif = sk->sk_bound_dev_if;
541 mark = sk->sk_mark;
542 tos = RT_CONN_FLAGS(sk);
543 prot = inet->hdrincl ? IPPROTO_RAW : sk->sk_protocol;
544 }
545 flowi4_init_output(fl4, oif, mark, tos,
546 RT_SCOPE_UNIVERSE, prot,
547 flow_flags,
548 iph->daddr, iph->saddr, 0, 0,
549 sock_net_uid(net, sk));
550 }
551
552 static void build_skb_flow_key(struct flowi4 *fl4, const struct sk_buff *skb,
553 const struct sock *sk)
554 {
555 const struct net *net = dev_net(skb->dev);
556 const struct iphdr *iph = ip_hdr(skb);
557 int oif = skb->dev->ifindex;
558 u8 tos = RT_TOS(iph->tos);
559 u8 prot = iph->protocol;
560 u32 mark = skb->mark;
561
562 __build_flow_key(net, fl4, sk, iph, oif, tos, prot, mark, 0);
563 }
564
565 static void build_sk_flow_key(struct flowi4 *fl4, const struct sock *sk)
566 {
567 const struct inet_sock *inet = inet_sk(sk);
568 const struct ip_options_rcu *inet_opt;
569 __be32 daddr = inet->inet_daddr;
570
571 rcu_read_lock();
572 inet_opt = rcu_dereference(inet->inet_opt);
573 if (inet_opt && inet_opt->opt.srr)
574 daddr = inet_opt->opt.faddr;
575 flowi4_init_output(fl4, sk->sk_bound_dev_if, sk->sk_mark,
576 RT_CONN_FLAGS(sk), RT_SCOPE_UNIVERSE,
577 inet->hdrincl ? IPPROTO_RAW : sk->sk_protocol,
578 inet_sk_flowi_flags(sk),
579 daddr, inet->inet_saddr, 0, 0, sk->sk_uid);
580 rcu_read_unlock();
581 }
582
583 static void ip_rt_build_flow_key(struct flowi4 *fl4, const struct sock *sk,
584 const struct sk_buff *skb)
585 {
586 if (skb)
587 build_skb_flow_key(fl4, skb, sk);
588 else
589 build_sk_flow_key(fl4, sk);
590 }
591
592 static DEFINE_SPINLOCK(fnhe_lock);
593
594 static void fnhe_flush_routes(struct fib_nh_exception *fnhe)
595 {
596 struct rtable *rt;
597
598 rt = rcu_dereference(fnhe->fnhe_rth_input);
599 if (rt) {
600 RCU_INIT_POINTER(fnhe->fnhe_rth_input, NULL);
601 dst_dev_put(&rt->dst);
602 dst_release(&rt->dst);
603 }
604 rt = rcu_dereference(fnhe->fnhe_rth_output);
605 if (rt) {
606 RCU_INIT_POINTER(fnhe->fnhe_rth_output, NULL);
607 dst_dev_put(&rt->dst);
608 dst_release(&rt->dst);
609 }
610 }
611
612 static struct fib_nh_exception *fnhe_oldest(struct fnhe_hash_bucket *hash)
613 {
614 struct fib_nh_exception *fnhe, *oldest;
615
616 oldest = rcu_dereference(hash->chain);
617 for (fnhe = rcu_dereference(oldest->fnhe_next); fnhe;
618 fnhe = rcu_dereference(fnhe->fnhe_next)) {
619 if (time_before(fnhe->fnhe_stamp, oldest->fnhe_stamp))
620 oldest = fnhe;
621 }
622 fnhe_flush_routes(oldest);
623 return oldest;
624 }
625
626 static inline u32 fnhe_hashfun(__be32 daddr)
627 {
628 static u32 fnhe_hashrnd __read_mostly;
629 u32 hval;
630
631 net_get_random_once(&fnhe_hashrnd, sizeof(fnhe_hashrnd));
632 hval = jhash_1word((__force u32) daddr, fnhe_hashrnd);
633 return hash_32(hval, FNHE_HASH_SHIFT);
634 }
635
636 static void fill_route_from_fnhe(struct rtable *rt, struct fib_nh_exception *fnhe)
637 {
638 rt->rt_pmtu = fnhe->fnhe_pmtu;
639 rt->dst.expires = fnhe->fnhe_expires;
640
641 if (fnhe->fnhe_gw) {
642 rt->rt_flags |= RTCF_REDIRECTED;
643 rt->rt_gateway = fnhe->fnhe_gw;
644 rt->rt_uses_gateway = 1;
645 }
646 }
647
648 static void update_or_create_fnhe(struct fib_nh *nh, __be32 daddr, __be32 gw,
649 u32 pmtu, unsigned long expires)
650 {
651 struct fnhe_hash_bucket *hash;
652 struct fib_nh_exception *fnhe;
653 struct rtable *rt;
654 u32 genid, hval;
655 unsigned int i;
656 int depth;
657
658 genid = fnhe_genid(dev_net(nh->nh_dev));
659 hval = fnhe_hashfun(daddr);
660
661 spin_lock_bh(&fnhe_lock);
662
663 hash = rcu_dereference(nh->nh_exceptions);
664 if (!hash) {
665 hash = kzalloc(FNHE_HASH_SIZE * sizeof(*hash), GFP_ATOMIC);
666 if (!hash)
667 goto out_unlock;
668 rcu_assign_pointer(nh->nh_exceptions, hash);
669 }
670
671 hash += hval;
672
673 depth = 0;
674 for (fnhe = rcu_dereference(hash->chain); fnhe;
675 fnhe = rcu_dereference(fnhe->fnhe_next)) {
676 if (fnhe->fnhe_daddr == daddr)
677 break;
678 depth++;
679 }
680
681 if (fnhe) {
682 if (fnhe->fnhe_genid != genid)
683 fnhe->fnhe_genid = genid;
684 if (gw)
685 fnhe->fnhe_gw = gw;
686 if (pmtu)
687 fnhe->fnhe_pmtu = pmtu;
688 fnhe->fnhe_expires = max(1UL, expires);
689 /* Update all cached dsts too */
690 rt = rcu_dereference(fnhe->fnhe_rth_input);
691 if (rt)
692 fill_route_from_fnhe(rt, fnhe);
693 rt = rcu_dereference(fnhe->fnhe_rth_output);
694 if (rt)
695 fill_route_from_fnhe(rt, fnhe);
696 } else {
697 if (depth > FNHE_RECLAIM_DEPTH)
698 fnhe = fnhe_oldest(hash);
699 else {
700 fnhe = kzalloc(sizeof(*fnhe), GFP_ATOMIC);
701 if (!fnhe)
702 goto out_unlock;
703
704 fnhe->fnhe_next = hash->chain;
705 rcu_assign_pointer(hash->chain, fnhe);
706 }
707 fnhe->fnhe_genid = genid;
708 fnhe->fnhe_daddr = daddr;
709 fnhe->fnhe_gw = gw;
710 fnhe->fnhe_pmtu = pmtu;
711 fnhe->fnhe_expires = expires;
712
713 /* Exception created; mark the cached routes for the nexthop
714 * stale, so anyone caching it rechecks if this exception
715 * applies to them.
716 */
717 rt = rcu_dereference(nh->nh_rth_input);
718 if (rt)
719 rt->dst.obsolete = DST_OBSOLETE_KILL;
720
721 for_each_possible_cpu(i) {
722 struct rtable __rcu **prt;
723 prt = per_cpu_ptr(nh->nh_pcpu_rth_output, i);
724 rt = rcu_dereference(*prt);
725 if (rt)
726 rt->dst.obsolete = DST_OBSOLETE_KILL;
727 }
728 }
729
730 fnhe->fnhe_stamp = jiffies;
731
732 out_unlock:
733 spin_unlock_bh(&fnhe_lock);
734 }
735
736 static void __ip_do_redirect(struct rtable *rt, struct sk_buff *skb, struct flowi4 *fl4,
737 bool kill_route)
738 {
739 __be32 new_gw = icmp_hdr(skb)->un.gateway;
740 __be32 old_gw = ip_hdr(skb)->saddr;
741 struct net_device *dev = skb->dev;
742 struct in_device *in_dev;
743 struct fib_result res;
744 struct neighbour *n;
745 struct net *net;
746
747 switch (icmp_hdr(skb)->code & 7) {
748 case ICMP_REDIR_NET:
749 case ICMP_REDIR_NETTOS:
750 case ICMP_REDIR_HOST:
751 case ICMP_REDIR_HOSTTOS:
752 break;
753
754 default:
755 return;
756 }
757
758 if (rt->rt_gateway != old_gw)
759 return;
760
761 in_dev = __in_dev_get_rcu(dev);
762 if (!in_dev)
763 return;
764
765 net = dev_net(dev);
766 if (new_gw == old_gw || !IN_DEV_RX_REDIRECTS(in_dev) ||
767 ipv4_is_multicast(new_gw) || ipv4_is_lbcast(new_gw) ||
768 ipv4_is_zeronet(new_gw))
769 goto reject_redirect;
770
771 if (!IN_DEV_SHARED_MEDIA(in_dev)) {
772 if (!inet_addr_onlink(in_dev, new_gw, old_gw))
773 goto reject_redirect;
774 if (IN_DEV_SEC_REDIRECTS(in_dev) && ip_fib_check_default(new_gw, dev))
775 goto reject_redirect;
776 } else {
777 if (inet_addr_type(net, new_gw) != RTN_UNICAST)
778 goto reject_redirect;
779 }
780
781 n = __ipv4_neigh_lookup(rt->dst.dev, new_gw);
782 if (!n)
783 n = neigh_create(&arp_tbl, &new_gw, rt->dst.dev);
784 if (!IS_ERR(n)) {
785 if (!(n->nud_state & NUD_VALID)) {
786 neigh_event_send(n, NULL);
787 } else {
788 if (fib_lookup(net, fl4, &res, 0) == 0) {
789 struct fib_nh *nh = &FIB_RES_NH(res);
790
791 update_or_create_fnhe(nh, fl4->daddr, new_gw,
792 0, jiffies + ip_rt_gc_timeout);
793 }
794 if (kill_route)
795 rt->dst.obsolete = DST_OBSOLETE_KILL;
796 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, n);
797 }
798 neigh_release(n);
799 }
800 return;
801
802 reject_redirect:
803 #ifdef CONFIG_IP_ROUTE_VERBOSE
804 if (IN_DEV_LOG_MARTIANS(in_dev)) {
805 const struct iphdr *iph = (const struct iphdr *) skb->data;
806 __be32 daddr = iph->daddr;
807 __be32 saddr = iph->saddr;
808
809 net_info_ratelimited("Redirect from %pI4 on %s about %pI4 ignored\n"
810 " Advised path = %pI4 -> %pI4\n",
811 &old_gw, dev->name, &new_gw,
812 &saddr, &daddr);
813 }
814 #endif
815 ;
816 }
817
818 static void ip_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
819 {
820 struct rtable *rt;
821 struct flowi4 fl4;
822 const struct iphdr *iph = (const struct iphdr *) skb->data;
823 struct net *net = dev_net(skb->dev);
824 int oif = skb->dev->ifindex;
825 u8 tos = RT_TOS(iph->tos);
826 u8 prot = iph->protocol;
827 u32 mark = skb->mark;
828
829 rt = (struct rtable *) dst;
830
831 __build_flow_key(net, &fl4, sk, iph, oif, tos, prot, mark, 0);
832 __ip_do_redirect(rt, skb, &fl4, true);
833 }
834
835 static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst)
836 {
837 struct rtable *rt = (struct rtable *)dst;
838 struct dst_entry *ret = dst;
839
840 if (rt) {
841 if (dst->obsolete > 0) {
842 ip_rt_put(rt);
843 ret = NULL;
844 } else if ((rt->rt_flags & RTCF_REDIRECTED) ||
845 rt->dst.expires) {
846 ip_rt_put(rt);
847 ret = NULL;
848 }
849 }
850 return ret;
851 }
852
853 /*
854 * Algorithm:
855 * 1. The first ip_rt_redirect_number redirects are sent
856 * with exponential backoff, then we stop sending them at all,
857 * assuming that the host ignores our redirects.
858 * 2. If we did not see packets requiring redirects
859 * during ip_rt_redirect_silence, we assume that the host
860 * forgot redirected route and start to send redirects again.
861 *
862 * This algorithm is much cheaper and more intelligent than dumb load limiting
863 * in icmp.c.
864 *
865 * NOTE. Do not forget to inhibit load limiting for redirects (redundant)
866 * and "frag. need" (breaks PMTU discovery) in icmp.c.
867 */
868
869 void ip_rt_send_redirect(struct sk_buff *skb)
870 {
871 struct rtable *rt = skb_rtable(skb);
872 struct in_device *in_dev;
873 struct inet_peer *peer;
874 struct net *net;
875 int log_martians;
876 int vif;
877
878 rcu_read_lock();
879 in_dev = __in_dev_get_rcu(rt->dst.dev);
880 if (!in_dev || !IN_DEV_TX_REDIRECTS(in_dev)) {
881 rcu_read_unlock();
882 return;
883 }
884 log_martians = IN_DEV_LOG_MARTIANS(in_dev);
885 vif = l3mdev_master_ifindex_rcu(rt->dst.dev);
886 rcu_read_unlock();
887
888 net = dev_net(rt->dst.dev);
889 peer = inet_getpeer_v4(net->ipv4.peers, ip_hdr(skb)->saddr, vif, 1);
890 if (!peer) {
891 icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST,
892 rt_nexthop(rt, ip_hdr(skb)->daddr));
893 return;
894 }
895
896 /* No redirected packets during ip_rt_redirect_silence;
897 * reset the algorithm.
898 */
899 if (time_after(jiffies, peer->rate_last + ip_rt_redirect_silence))
900 peer->rate_tokens = 0;
901
902 /* Too many ignored redirects; do not send anything
903 * set dst.rate_last to the last seen redirected packet.
904 */
905 if (peer->rate_tokens >= ip_rt_redirect_number) {
906 peer->rate_last = jiffies;
907 goto out_put_peer;
908 }
909
910 /* Check for load limit; set rate_last to the latest sent
911 * redirect.
912 */
913 if (peer->rate_tokens == 0 ||
914 time_after(jiffies,
915 (peer->rate_last +
916 (ip_rt_redirect_load << peer->rate_tokens)))) {
917 __be32 gw = rt_nexthop(rt, ip_hdr(skb)->daddr);
918
919 icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST, gw);
920 peer->rate_last = jiffies;
921 ++peer->rate_tokens;
922 #ifdef CONFIG_IP_ROUTE_VERBOSE
923 if (log_martians &&
924 peer->rate_tokens == ip_rt_redirect_number)
925 net_warn_ratelimited("host %pI4/if%d ignores redirects for %pI4 to %pI4\n",
926 &ip_hdr(skb)->saddr, inet_iif(skb),
927 &ip_hdr(skb)->daddr, &gw);
928 #endif
929 }
930 out_put_peer:
931 inet_putpeer(peer);
932 }
933
934 static int ip_error(struct sk_buff *skb)
935 {
936 struct in_device *in_dev = __in_dev_get_rcu(skb->dev);
937 struct rtable *rt = skb_rtable(skb);
938 struct inet_peer *peer;
939 unsigned long now;
940 struct net *net;
941 bool send;
942 int code;
943
944 /* IP on this device is disabled. */
945 if (!in_dev)
946 goto out;
947
948 net = dev_net(rt->dst.dev);
949 if (!IN_DEV_FORWARD(in_dev)) {
950 switch (rt->dst.error) {
951 case EHOSTUNREACH:
952 __IP_INC_STATS(net, IPSTATS_MIB_INADDRERRORS);
953 break;
954
955 case ENETUNREACH:
956 __IP_INC_STATS(net, IPSTATS_MIB_INNOROUTES);
957 break;
958 }
959 goto out;
960 }
961
962 switch (rt->dst.error) {
963 case EINVAL:
964 default:
965 goto out;
966 case EHOSTUNREACH:
967 code = ICMP_HOST_UNREACH;
968 break;
969 case ENETUNREACH:
970 code = ICMP_NET_UNREACH;
971 __IP_INC_STATS(net, IPSTATS_MIB_INNOROUTES);
972 break;
973 case EACCES:
974 code = ICMP_PKT_FILTERED;
975 break;
976 }
977
978 peer = inet_getpeer_v4(net->ipv4.peers, ip_hdr(skb)->saddr,
979 l3mdev_master_ifindex(skb->dev), 1);
980
981 send = true;
982 if (peer) {
983 now = jiffies;
984 peer->rate_tokens += now - peer->rate_last;
985 if (peer->rate_tokens > ip_rt_error_burst)
986 peer->rate_tokens = ip_rt_error_burst;
987 peer->rate_last = now;
988 if (peer->rate_tokens >= ip_rt_error_cost)
989 peer->rate_tokens -= ip_rt_error_cost;
990 else
991 send = false;
992 inet_putpeer(peer);
993 }
994 if (send)
995 icmp_send(skb, ICMP_DEST_UNREACH, code, 0);
996
997 out: kfree_skb(skb);
998 return 0;
999 }
1000
1001 static void __ip_rt_update_pmtu(struct rtable *rt, struct flowi4 *fl4, u32 mtu)
1002 {
1003 struct dst_entry *dst = &rt->dst;
1004 struct fib_result res;
1005
1006 if (dst_metric_locked(dst, RTAX_MTU))
1007 return;
1008
1009 if (ipv4_mtu(dst) < mtu)
1010 return;
1011
1012 if (mtu < ip_rt_min_pmtu)
1013 mtu = ip_rt_min_pmtu;
1014
1015 if (rt->rt_pmtu == mtu &&
1016 time_before(jiffies, dst->expires - ip_rt_mtu_expires / 2))
1017 return;
1018
1019 rcu_read_lock();
1020 if (fib_lookup(dev_net(dst->dev), fl4, &res, 0) == 0) {
1021 struct fib_nh *nh = &FIB_RES_NH(res);
1022
1023 update_or_create_fnhe(nh, fl4->daddr, 0, mtu,
1024 jiffies + ip_rt_mtu_expires);
1025 }
1026 rcu_read_unlock();
1027 }
1028
1029 static void ip_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
1030 struct sk_buff *skb, u32 mtu)
1031 {
1032 struct rtable *rt = (struct rtable *) dst;
1033 struct flowi4 fl4;
1034
1035 ip_rt_build_flow_key(&fl4, sk, skb);
1036 __ip_rt_update_pmtu(rt, &fl4, mtu);
1037 }
1038
1039 void ipv4_update_pmtu(struct sk_buff *skb, struct net *net, u32 mtu,
1040 int oif, u32 mark, u8 protocol, int flow_flags)
1041 {
1042 const struct iphdr *iph = (const struct iphdr *) skb->data;
1043 struct flowi4 fl4;
1044 struct rtable *rt;
1045
1046 if (!mark)
1047 mark = IP4_REPLY_MARK(net, skb->mark);
1048
1049 __build_flow_key(net, &fl4, NULL, iph, oif,
1050 RT_TOS(iph->tos), protocol, mark, flow_flags);
1051 rt = __ip_route_output_key(net, &fl4);
1052 if (!IS_ERR(rt)) {
1053 __ip_rt_update_pmtu(rt, &fl4, mtu);
1054 ip_rt_put(rt);
1055 }
1056 }
1057 EXPORT_SYMBOL_GPL(ipv4_update_pmtu);
1058
1059 static void __ipv4_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, u32 mtu)
1060 {
1061 const struct iphdr *iph = (const struct iphdr *) skb->data;
1062 struct flowi4 fl4;
1063 struct rtable *rt;
1064
1065 __build_flow_key(sock_net(sk), &fl4, sk, iph, 0, 0, 0, 0, 0);
1066
1067 if (!fl4.flowi4_mark)
1068 fl4.flowi4_mark = IP4_REPLY_MARK(sock_net(sk), skb->mark);
1069
1070 rt = __ip_route_output_key(sock_net(sk), &fl4);
1071 if (!IS_ERR(rt)) {
1072 __ip_rt_update_pmtu(rt, &fl4, mtu);
1073 ip_rt_put(rt);
1074 }
1075 }
1076
1077 void ipv4_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, u32 mtu)
1078 {
1079 const struct iphdr *iph = (const struct iphdr *) skb->data;
1080 struct flowi4 fl4;
1081 struct rtable *rt;
1082 struct dst_entry *odst = NULL;
1083 bool new = false;
1084 struct net *net = sock_net(sk);
1085
1086 bh_lock_sock(sk);
1087
1088 if (!ip_sk_accept_pmtu(sk))
1089 goto out;
1090
1091 odst = sk_dst_get(sk);
1092
1093 if (sock_owned_by_user(sk) || !odst) {
1094 __ipv4_sk_update_pmtu(skb, sk, mtu);
1095 goto out;
1096 }
1097
1098 __build_flow_key(net, &fl4, sk, iph, 0, 0, 0, 0, 0);
1099
1100 rt = (struct rtable *)odst;
1101 if (odst->obsolete && !odst->ops->check(odst, 0)) {
1102 rt = ip_route_output_flow(sock_net(sk), &fl4, sk);
1103 if (IS_ERR(rt))
1104 goto out;
1105
1106 new = true;
1107 }
1108
1109 __ip_rt_update_pmtu((struct rtable *) rt->dst.path, &fl4, mtu);
1110
1111 if (!dst_check(&rt->dst, 0)) {
1112 if (new)
1113 dst_release(&rt->dst);
1114
1115 rt = ip_route_output_flow(sock_net(sk), &fl4, sk);
1116 if (IS_ERR(rt))
1117 goto out;
1118
1119 new = true;
1120 }
1121
1122 if (new)
1123 sk_dst_set(sk, &rt->dst);
1124
1125 out:
1126 bh_unlock_sock(sk);
1127 dst_release(odst);
1128 }
1129 EXPORT_SYMBOL_GPL(ipv4_sk_update_pmtu);
1130
1131 void ipv4_redirect(struct sk_buff *skb, struct net *net,
1132 int oif, u32 mark, u8 protocol, int flow_flags)
1133 {
1134 const struct iphdr *iph = (const struct iphdr *) skb->data;
1135 struct flowi4 fl4;
1136 struct rtable *rt;
1137
1138 __build_flow_key(net, &fl4, NULL, iph, oif,
1139 RT_TOS(iph->tos), protocol, mark, flow_flags);
1140 rt = __ip_route_output_key(net, &fl4);
1141 if (!IS_ERR(rt)) {
1142 __ip_do_redirect(rt, skb, &fl4, false);
1143 ip_rt_put(rt);
1144 }
1145 }
1146 EXPORT_SYMBOL_GPL(ipv4_redirect);
1147
1148 void ipv4_sk_redirect(struct sk_buff *skb, struct sock *sk)
1149 {
1150 const struct iphdr *iph = (const struct iphdr *) skb->data;
1151 struct flowi4 fl4;
1152 struct rtable *rt;
1153 struct net *net = sock_net(sk);
1154
1155 __build_flow_key(net, &fl4, sk, iph, 0, 0, 0, 0, 0);
1156 rt = __ip_route_output_key(net, &fl4);
1157 if (!IS_ERR(rt)) {
1158 __ip_do_redirect(rt, skb, &fl4, false);
1159 ip_rt_put(rt);
1160 }
1161 }
1162 EXPORT_SYMBOL_GPL(ipv4_sk_redirect);
1163
1164 static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie)
1165 {
1166 struct rtable *rt = (struct rtable *) dst;
1167
1168 /* All IPV4 dsts are created with ->obsolete set to the value
1169 * DST_OBSOLETE_FORCE_CHK which forces validation calls down
1170 * into this function always.
1171 *
1172 * When a PMTU/redirect information update invalidates a route,
1173 * this is indicated by setting obsolete to DST_OBSOLETE_KILL or
1174 * DST_OBSOLETE_DEAD by dst_free().
1175 */
1176 if (dst->obsolete != DST_OBSOLETE_FORCE_CHK || rt_is_expired(rt))
1177 return NULL;
1178 return dst;
1179 }
1180
1181 static void ipv4_link_failure(struct sk_buff *skb)
1182 {
1183 struct rtable *rt;
1184
1185 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0);
1186
1187 rt = skb_rtable(skb);
1188 if (rt)
1189 dst_set_expires(&rt->dst, 0);
1190 }
1191
1192 static int ip_rt_bug(struct net *net, struct sock *sk, struct sk_buff *skb)
1193 {
1194 pr_debug("%s: %pI4 -> %pI4, %s\n",
1195 __func__, &ip_hdr(skb)->saddr, &ip_hdr(skb)->daddr,
1196 skb->dev ? skb->dev->name : "?");
1197 kfree_skb(skb);
1198 WARN_ON(1);
1199 return 0;
1200 }
1201
1202 /*
1203 We do not cache source address of outgoing interface,
1204 because it is used only by IP RR, TS and SRR options,
1205 so that it out of fast path.
1206
1207 BTW remember: "addr" is allowed to be not aligned
1208 in IP options!
1209 */
1210
1211 void ip_rt_get_source(u8 *addr, struct sk_buff *skb, struct rtable *rt)
1212 {
1213 __be32 src;
1214
1215 if (rt_is_output_route(rt))
1216 src = ip_hdr(skb)->saddr;
1217 else {
1218 struct fib_result res;
1219 struct flowi4 fl4;
1220 struct iphdr *iph;
1221
1222 iph = ip_hdr(skb);
1223
1224 memset(&fl4, 0, sizeof(fl4));
1225 fl4.daddr = iph->daddr;
1226 fl4.saddr = iph->saddr;
1227 fl4.flowi4_tos = RT_TOS(iph->tos);
1228 fl4.flowi4_oif = rt->dst.dev->ifindex;
1229 fl4.flowi4_iif = skb->dev->ifindex;
1230 fl4.flowi4_mark = skb->mark;
1231
1232 rcu_read_lock();
1233 if (fib_lookup(dev_net(rt->dst.dev), &fl4, &res, 0) == 0)
1234 src = FIB_RES_PREFSRC(dev_net(rt->dst.dev), res);
1235 else
1236 src = inet_select_addr(rt->dst.dev,
1237 rt_nexthop(rt, iph->daddr),
1238 RT_SCOPE_UNIVERSE);
1239 rcu_read_unlock();
1240 }
1241 memcpy(addr, &src, 4);
1242 }
1243
1244 #ifdef CONFIG_IP_ROUTE_CLASSID
1245 static void set_class_tag(struct rtable *rt, u32 tag)
1246 {
1247 if (!(rt->dst.tclassid & 0xFFFF))
1248 rt->dst.tclassid |= tag & 0xFFFF;
1249 if (!(rt->dst.tclassid & 0xFFFF0000))
1250 rt->dst.tclassid |= tag & 0xFFFF0000;
1251 }
1252 #endif
1253
1254 static unsigned int ipv4_default_advmss(const struct dst_entry *dst)
1255 {
1256 unsigned int header_size = sizeof(struct tcphdr) + sizeof(struct iphdr);
1257 unsigned int advmss = max_t(unsigned int, ipv4_mtu(dst) - header_size,
1258 ip_rt_min_advmss);
1259
1260 return min(advmss, IPV4_MAX_PMTU - header_size);
1261 }
1262
1263 static unsigned int ipv4_mtu(const struct dst_entry *dst)
1264 {
1265 const struct rtable *rt = (const struct rtable *) dst;
1266 unsigned int mtu = rt->rt_pmtu;
1267
1268 if (!mtu || time_after_eq(jiffies, rt->dst.expires))
1269 mtu = dst_metric_raw(dst, RTAX_MTU);
1270
1271 if (mtu)
1272 return mtu;
1273
1274 mtu = READ_ONCE(dst->dev->mtu);
1275
1276 if (unlikely(dst_metric_locked(dst, RTAX_MTU))) {
1277 if (rt->rt_uses_gateway && mtu > 576)
1278 mtu = 576;
1279 }
1280
1281 mtu = min_t(unsigned int, mtu, IP_MAX_MTU);
1282
1283 return mtu - lwtunnel_headroom(dst->lwtstate, mtu);
1284 }
1285
1286 static struct fib_nh_exception *find_exception(struct fib_nh *nh, __be32 daddr)
1287 {
1288 struct fnhe_hash_bucket *hash = rcu_dereference(nh->nh_exceptions);
1289 struct fib_nh_exception *fnhe;
1290 u32 hval;
1291
1292 if (!hash)
1293 return NULL;
1294
1295 hval = fnhe_hashfun(daddr);
1296
1297 for (fnhe = rcu_dereference(hash[hval].chain); fnhe;
1298 fnhe = rcu_dereference(fnhe->fnhe_next)) {
1299 if (fnhe->fnhe_daddr == daddr)
1300 return fnhe;
1301 }
1302 return NULL;
1303 }
1304
1305 static bool rt_bind_exception(struct rtable *rt, struct fib_nh_exception *fnhe,
1306 __be32 daddr, const bool do_cache)
1307 {
1308 bool ret = false;
1309
1310 spin_lock_bh(&fnhe_lock);
1311
1312 if (daddr == fnhe->fnhe_daddr) {
1313 struct rtable __rcu **porig;
1314 struct rtable *orig;
1315 int genid = fnhe_genid(dev_net(rt->dst.dev));
1316
1317 if (rt_is_input_route(rt))
1318 porig = &fnhe->fnhe_rth_input;
1319 else
1320 porig = &fnhe->fnhe_rth_output;
1321 orig = rcu_dereference(*porig);
1322
1323 if (fnhe->fnhe_genid != genid) {
1324 fnhe->fnhe_genid = genid;
1325 fnhe->fnhe_gw = 0;
1326 fnhe->fnhe_pmtu = 0;
1327 fnhe->fnhe_expires = 0;
1328 fnhe_flush_routes(fnhe);
1329 orig = NULL;
1330 }
1331 fill_route_from_fnhe(rt, fnhe);
1332 if (!rt->rt_gateway)
1333 rt->rt_gateway = daddr;
1334
1335 if (do_cache) {
1336 dst_hold(&rt->dst);
1337 rcu_assign_pointer(*porig, rt);
1338 if (orig) {
1339 dst_dev_put(&orig->dst);
1340 dst_release(&orig->dst);
1341 }
1342 ret = true;
1343 }
1344
1345 fnhe->fnhe_stamp = jiffies;
1346 }
1347 spin_unlock_bh(&fnhe_lock);
1348
1349 return ret;
1350 }
1351
1352 static bool rt_cache_route(struct fib_nh *nh, struct rtable *rt)
1353 {
1354 struct rtable *orig, *prev, **p;
1355 bool ret = true;
1356
1357 if (rt_is_input_route(rt)) {
1358 p = (struct rtable **)&nh->nh_rth_input;
1359 } else {
1360 p = (struct rtable **)raw_cpu_ptr(nh->nh_pcpu_rth_output);
1361 }
1362 orig = *p;
1363
1364 /* hold dst before doing cmpxchg() to avoid race condition
1365 * on this dst
1366 */
1367 dst_hold(&rt->dst);
1368 prev = cmpxchg(p, orig, rt);
1369 if (prev == orig) {
1370 if (orig) {
1371 dst_dev_put(&orig->dst);
1372 dst_release(&orig->dst);
1373 }
1374 } else {
1375 dst_release(&rt->dst);
1376 ret = false;
1377 }
1378
1379 return ret;
1380 }
1381
1382 struct uncached_list {
1383 spinlock_t lock;
1384 struct list_head head;
1385 };
1386
1387 static DEFINE_PER_CPU_ALIGNED(struct uncached_list, rt_uncached_list);
1388
1389 static void rt_add_uncached_list(struct rtable *rt)
1390 {
1391 struct uncached_list *ul = raw_cpu_ptr(&rt_uncached_list);
1392
1393 rt->rt_uncached_list = ul;
1394
1395 spin_lock_bh(&ul->lock);
1396 list_add_tail(&rt->rt_uncached, &ul->head);
1397 spin_unlock_bh(&ul->lock);
1398 }
1399
1400 static void ipv4_dst_destroy(struct dst_entry *dst)
1401 {
1402 struct dst_metrics *p = (struct dst_metrics *)DST_METRICS_PTR(dst);
1403 struct rtable *rt = (struct rtable *) dst;
1404
1405 if (p != &dst_default_metrics && refcount_dec_and_test(&p->refcnt))
1406 kfree(p);
1407
1408 if (!list_empty(&rt->rt_uncached)) {
1409 struct uncached_list *ul = rt->rt_uncached_list;
1410
1411 spin_lock_bh(&ul->lock);
1412 list_del(&rt->rt_uncached);
1413 spin_unlock_bh(&ul->lock);
1414 }
1415 }
1416
1417 void rt_flush_dev(struct net_device *dev)
1418 {
1419 struct net *net = dev_net(dev);
1420 struct rtable *rt;
1421 int cpu;
1422
1423 for_each_possible_cpu(cpu) {
1424 struct uncached_list *ul = &per_cpu(rt_uncached_list, cpu);
1425
1426 spin_lock_bh(&ul->lock);
1427 list_for_each_entry(rt, &ul->head, rt_uncached) {
1428 if (rt->dst.dev != dev)
1429 continue;
1430 rt->dst.dev = net->loopback_dev;
1431 dev_hold(rt->dst.dev);
1432 dev_put(dev);
1433 }
1434 spin_unlock_bh(&ul->lock);
1435 }
1436 }
1437
1438 static bool rt_cache_valid(const struct rtable *rt)
1439 {
1440 return rt &&
1441 rt->dst.obsolete == DST_OBSOLETE_FORCE_CHK &&
1442 !rt_is_expired(rt);
1443 }
1444
1445 static void rt_set_nexthop(struct rtable *rt, __be32 daddr,
1446 const struct fib_result *res,
1447 struct fib_nh_exception *fnhe,
1448 struct fib_info *fi, u16 type, u32 itag,
1449 const bool do_cache)
1450 {
1451 bool cached = false;
1452
1453 if (fi) {
1454 struct fib_nh *nh = &FIB_RES_NH(*res);
1455
1456 if (nh->nh_gw && nh->nh_scope == RT_SCOPE_LINK) {
1457 rt->rt_gateway = nh->nh_gw;
1458 rt->rt_uses_gateway = 1;
1459 }
1460 dst_init_metrics(&rt->dst, fi->fib_metrics->metrics, true);
1461 if (fi->fib_metrics != &dst_default_metrics) {
1462 rt->dst._metrics |= DST_METRICS_REFCOUNTED;
1463 refcount_inc(&fi->fib_metrics->refcnt);
1464 }
1465 #ifdef CONFIG_IP_ROUTE_CLASSID
1466 rt->dst.tclassid = nh->nh_tclassid;
1467 #endif
1468 rt->dst.lwtstate = lwtstate_get(nh->nh_lwtstate);
1469 if (unlikely(fnhe))
1470 cached = rt_bind_exception(rt, fnhe, daddr, do_cache);
1471 else if (do_cache)
1472 cached = rt_cache_route(nh, rt);
1473 if (unlikely(!cached)) {
1474 /* Routes we intend to cache in nexthop exception or
1475 * FIB nexthop have the DST_NOCACHE bit clear.
1476 * However, if we are unsuccessful at storing this
1477 * route into the cache we really need to set it.
1478 */
1479 if (!rt->rt_gateway)
1480 rt->rt_gateway = daddr;
1481 rt_add_uncached_list(rt);
1482 }
1483 } else
1484 rt_add_uncached_list(rt);
1485
1486 #ifdef CONFIG_IP_ROUTE_CLASSID
1487 #ifdef CONFIG_IP_MULTIPLE_TABLES
1488 set_class_tag(rt, res->tclassid);
1489 #endif
1490 set_class_tag(rt, itag);
1491 #endif
1492 }
1493
1494 struct rtable *rt_dst_alloc(struct net_device *dev,
1495 unsigned int flags, u16 type,
1496 bool nopolicy, bool noxfrm, bool will_cache)
1497 {
1498 struct rtable *rt;
1499
1500 rt = dst_alloc(&ipv4_dst_ops, dev, 1, DST_OBSOLETE_FORCE_CHK,
1501 (will_cache ? 0 : DST_HOST) |
1502 (nopolicy ? DST_NOPOLICY : 0) |
1503 (noxfrm ? DST_NOXFRM : 0));
1504
1505 if (rt) {
1506 rt->rt_genid = rt_genid_ipv4(dev_net(dev));
1507 rt->rt_flags = flags;
1508 rt->rt_type = type;
1509 rt->rt_is_input = 0;
1510 rt->rt_iif = 0;
1511 rt->rt_pmtu = 0;
1512 rt->rt_gateway = 0;
1513 rt->rt_uses_gateway = 0;
1514 rt->rt_table_id = 0;
1515 INIT_LIST_HEAD(&rt->rt_uncached);
1516
1517 rt->dst.output = ip_output;
1518 if (flags & RTCF_LOCAL)
1519 rt->dst.input = ip_local_deliver;
1520 }
1521
1522 return rt;
1523 }
1524 EXPORT_SYMBOL(rt_dst_alloc);
1525
1526 /* called in rcu_read_lock() section */
1527 int ip_mc_validate_source(struct sk_buff *skb, __be32 daddr, __be32 saddr,
1528 u8 tos, struct net_device *dev,
1529 struct in_device *in_dev, u32 *itag)
1530 {
1531 int err;
1532
1533 /* Primary sanity checks. */
1534 if (!in_dev)
1535 return -EINVAL;
1536
1537 if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr) ||
1538 skb->protocol != htons(ETH_P_IP))
1539 return -EINVAL;
1540
1541 if (ipv4_is_loopback(saddr) && !IN_DEV_ROUTE_LOCALNET(in_dev))
1542 return -EINVAL;
1543
1544 if (ipv4_is_zeronet(saddr)) {
1545 if (!ipv4_is_local_multicast(daddr))
1546 return -EINVAL;
1547 } else {
1548 err = fib_validate_source(skb, saddr, 0, tos, 0, dev,
1549 in_dev, itag);
1550 if (err < 0)
1551 return err;
1552 }
1553 return 0;
1554 }
1555
1556 /* called in rcu_read_lock() section */
1557 static int ip_route_input_mc(struct sk_buff *skb, __be32 daddr, __be32 saddr,
1558 u8 tos, struct net_device *dev, int our)
1559 {
1560 struct in_device *in_dev = __in_dev_get_rcu(dev);
1561 unsigned int flags = RTCF_MULTICAST;
1562 struct rtable *rth;
1563 u32 itag = 0;
1564 int err;
1565
1566 err = ip_mc_validate_source(skb, daddr, saddr, tos, dev, in_dev, &itag);
1567 if (err)
1568 return err;
1569
1570 if (our)
1571 flags |= RTCF_LOCAL;
1572
1573 rth = rt_dst_alloc(dev_net(dev)->loopback_dev, flags, RTN_MULTICAST,
1574 IN_DEV_CONF_GET(in_dev, NOPOLICY), false, false);
1575 if (!rth)
1576 return -ENOBUFS;
1577
1578 #ifdef CONFIG_IP_ROUTE_CLASSID
1579 rth->dst.tclassid = itag;
1580 #endif
1581 rth->dst.output = ip_rt_bug;
1582 rth->rt_is_input= 1;
1583
1584 #ifdef CONFIG_IP_MROUTE
1585 if (!ipv4_is_local_multicast(daddr) && IN_DEV_MFORWARD(in_dev))
1586 rth->dst.input = ip_mr_input;
1587 #endif
1588 RT_CACHE_STAT_INC(in_slow_mc);
1589
1590 skb_dst_set(skb, &rth->dst);
1591 return 0;
1592 }
1593
1594
1595 static void ip_handle_martian_source(struct net_device *dev,
1596 struct in_device *in_dev,
1597 struct sk_buff *skb,
1598 __be32 daddr,
1599 __be32 saddr)
1600 {
1601 RT_CACHE_STAT_INC(in_martian_src);
1602 #ifdef CONFIG_IP_ROUTE_VERBOSE
1603 if (IN_DEV_LOG_MARTIANS(in_dev) && net_ratelimit()) {
1604 /*
1605 * RFC1812 recommendation, if source is martian,
1606 * the only hint is MAC header.
1607 */
1608 pr_warn("martian source %pI4 from %pI4, on dev %s\n",
1609 &daddr, &saddr, dev->name);
1610 if (dev->hard_header_len && skb_mac_header_was_set(skb)) {
1611 print_hex_dump(KERN_WARNING, "ll header: ",
1612 DUMP_PREFIX_OFFSET, 16, 1,
1613 skb_mac_header(skb),
1614 dev->hard_header_len, true);
1615 }
1616 }
1617 #endif
1618 }
1619
1620 static void ip_del_fnhe(struct fib_nh *nh, __be32 daddr)
1621 {
1622 struct fnhe_hash_bucket *hash;
1623 struct fib_nh_exception *fnhe, __rcu **fnhe_p;
1624 u32 hval = fnhe_hashfun(daddr);
1625
1626 spin_lock_bh(&fnhe_lock);
1627
1628 hash = rcu_dereference_protected(nh->nh_exceptions,
1629 lockdep_is_held(&fnhe_lock));
1630 hash += hval;
1631
1632 fnhe_p = &hash->chain;
1633 fnhe = rcu_dereference_protected(*fnhe_p, lockdep_is_held(&fnhe_lock));
1634 while (fnhe) {
1635 if (fnhe->fnhe_daddr == daddr) {
1636 rcu_assign_pointer(*fnhe_p, rcu_dereference_protected(
1637 fnhe->fnhe_next, lockdep_is_held(&fnhe_lock)));
1638 fnhe_flush_routes(fnhe);
1639 kfree_rcu(fnhe, rcu);
1640 break;
1641 }
1642 fnhe_p = &fnhe->fnhe_next;
1643 fnhe = rcu_dereference_protected(fnhe->fnhe_next,
1644 lockdep_is_held(&fnhe_lock));
1645 }
1646
1647 spin_unlock_bh(&fnhe_lock);
1648 }
1649
1650 static void set_lwt_redirect(struct rtable *rth)
1651 {
1652 if (lwtunnel_output_redirect(rth->dst.lwtstate)) {
1653 rth->dst.lwtstate->orig_output = rth->dst.output;
1654 rth->dst.output = lwtunnel_output;
1655 }
1656
1657 if (lwtunnel_input_redirect(rth->dst.lwtstate)) {
1658 rth->dst.lwtstate->orig_input = rth->dst.input;
1659 rth->dst.input = lwtunnel_input;
1660 }
1661 }
1662
1663 /* called in rcu_read_lock() section */
1664 static int __mkroute_input(struct sk_buff *skb,
1665 const struct fib_result *res,
1666 struct in_device *in_dev,
1667 __be32 daddr, __be32 saddr, u32 tos)
1668 {
1669 struct fib_nh_exception *fnhe;
1670 struct rtable *rth;
1671 int err;
1672 struct in_device *out_dev;
1673 bool do_cache;
1674 u32 itag = 0;
1675
1676 /* get a working reference to the output device */
1677 out_dev = __in_dev_get_rcu(FIB_RES_DEV(*res));
1678 if (!out_dev) {
1679 net_crit_ratelimited("Bug in ip_route_input_slow(). Please report.\n");
1680 return -EINVAL;
1681 }
1682
1683 err = fib_validate_source(skb, saddr, daddr, tos, FIB_RES_OIF(*res),
1684 in_dev->dev, in_dev, &itag);
1685 if (err < 0) {
1686 ip_handle_martian_source(in_dev->dev, in_dev, skb, daddr,
1687 saddr);
1688
1689 goto cleanup;
1690 }
1691
1692 do_cache = res->fi && !itag;
1693 if (out_dev == in_dev && err && IN_DEV_TX_REDIRECTS(out_dev) &&
1694 skb->protocol == htons(ETH_P_IP) &&
1695 (IN_DEV_SHARED_MEDIA(out_dev) ||
1696 inet_addr_onlink(out_dev, saddr, FIB_RES_GW(*res))))
1697 IPCB(skb)->flags |= IPSKB_DOREDIRECT;
1698
1699 if (skb->protocol != htons(ETH_P_IP)) {
1700 /* Not IP (i.e. ARP). Do not create route, if it is
1701 * invalid for proxy arp. DNAT routes are always valid.
1702 *
1703 * Proxy arp feature have been extended to allow, ARP
1704 * replies back to the same interface, to support
1705 * Private VLAN switch technologies. See arp.c.
1706 */
1707 if (out_dev == in_dev &&
1708 IN_DEV_PROXY_ARP_PVLAN(in_dev) == 0) {
1709 err = -EINVAL;
1710 goto cleanup;
1711 }
1712 }
1713
1714 fnhe = find_exception(&FIB_RES_NH(*res), daddr);
1715 if (do_cache) {
1716 if (fnhe) {
1717 rth = rcu_dereference(fnhe->fnhe_rth_input);
1718 if (rth && rth->dst.expires &&
1719 time_after(jiffies, rth->dst.expires)) {
1720 ip_del_fnhe(&FIB_RES_NH(*res), daddr);
1721 fnhe = NULL;
1722 } else {
1723 goto rt_cache;
1724 }
1725 }
1726
1727 rth = rcu_dereference(FIB_RES_NH(*res).nh_rth_input);
1728
1729 rt_cache:
1730 if (rt_cache_valid(rth)) {
1731 skb_dst_set_noref(skb, &rth->dst);
1732 goto out;
1733 }
1734 }
1735
1736 rth = rt_dst_alloc(out_dev->dev, 0, res->type,
1737 IN_DEV_CONF_GET(in_dev, NOPOLICY),
1738 IN_DEV_CONF_GET(out_dev, NOXFRM), do_cache);
1739 if (!rth) {
1740 err = -ENOBUFS;
1741 goto cleanup;
1742 }
1743
1744 rth->rt_is_input = 1;
1745 if (res->table)
1746 rth->rt_table_id = res->table->tb_id;
1747 RT_CACHE_STAT_INC(in_slow_tot);
1748
1749 rth->dst.input = ip_forward;
1750
1751 rt_set_nexthop(rth, daddr, res, fnhe, res->fi, res->type, itag,
1752 do_cache);
1753 set_lwt_redirect(rth);
1754 skb_dst_set(skb, &rth->dst);
1755 out:
1756 err = 0;
1757 cleanup:
1758 return err;
1759 }
1760
1761 #ifdef CONFIG_IP_ROUTE_MULTIPATH
1762 /* To make ICMP packets follow the right flow, the multipath hash is
1763 * calculated from the inner IP addresses.
1764 */
1765 static void ip_multipath_l3_keys(const struct sk_buff *skb,
1766 struct flow_keys *hash_keys)
1767 {
1768 const struct iphdr *outer_iph = ip_hdr(skb);
1769 const struct iphdr *inner_iph;
1770 const struct icmphdr *icmph;
1771 struct iphdr _inner_iph;
1772 struct icmphdr _icmph;
1773
1774 hash_keys->addrs.v4addrs.src = outer_iph->saddr;
1775 hash_keys->addrs.v4addrs.dst = outer_iph->daddr;
1776 if (likely(outer_iph->protocol != IPPROTO_ICMP))
1777 return;
1778
1779 if (unlikely((outer_iph->frag_off & htons(IP_OFFSET)) != 0))
1780 return;
1781
1782 icmph = skb_header_pointer(skb, outer_iph->ihl * 4, sizeof(_icmph),
1783 &_icmph);
1784 if (!icmph)
1785 return;
1786
1787 if (icmph->type != ICMP_DEST_UNREACH &&
1788 icmph->type != ICMP_REDIRECT &&
1789 icmph->type != ICMP_TIME_EXCEEDED &&
1790 icmph->type != ICMP_PARAMETERPROB)
1791 return;
1792
1793 inner_iph = skb_header_pointer(skb,
1794 outer_iph->ihl * 4 + sizeof(_icmph),
1795 sizeof(_inner_iph), &_inner_iph);
1796 if (!inner_iph)
1797 return;
1798 hash_keys->addrs.v4addrs.src = inner_iph->saddr;
1799 hash_keys->addrs.v4addrs.dst = inner_iph->daddr;
1800 }
1801
1802 /* if skb is set it will be used and fl4 can be NULL */
1803 int fib_multipath_hash(const struct fib_info *fi, const struct flowi4 *fl4,
1804 const struct sk_buff *skb)
1805 {
1806 struct net *net = fi->fib_net;
1807 struct flow_keys hash_keys;
1808 u32 mhash;
1809
1810 switch (net->ipv4.sysctl_fib_multipath_hash_policy) {
1811 case 0:
1812 memset(&hash_keys, 0, sizeof(hash_keys));
1813 hash_keys.control.addr_type = FLOW_DISSECTOR_KEY_IPV4_ADDRS;
1814 if (skb) {
1815 ip_multipath_l3_keys(skb, &hash_keys);
1816 } else {
1817 hash_keys.addrs.v4addrs.src = fl4->saddr;
1818 hash_keys.addrs.v4addrs.dst = fl4->daddr;
1819 }
1820 break;
1821 case 1:
1822 /* skb is currently provided only when forwarding */
1823 if (skb) {
1824 unsigned int flag = FLOW_DISSECTOR_F_STOP_AT_ENCAP;
1825 struct flow_keys keys;
1826
1827 /* short-circuit if we already have L4 hash present */
1828 if (skb->l4_hash)
1829 return skb_get_hash_raw(skb) >> 1;
1830 memset(&hash_keys, 0, sizeof(hash_keys));
1831 skb_flow_dissect_flow_keys(skb, &keys, flag);
1832 hash_keys.addrs.v4addrs.src = keys.addrs.v4addrs.src;
1833 hash_keys.addrs.v4addrs.dst = keys.addrs.v4addrs.dst;
1834 hash_keys.ports.src = keys.ports.src;
1835 hash_keys.ports.dst = keys.ports.dst;
1836 hash_keys.basic.ip_proto = keys.basic.ip_proto;
1837 } else {
1838 memset(&hash_keys, 0, sizeof(hash_keys));
1839 hash_keys.control.addr_type = FLOW_DISSECTOR_KEY_IPV4_ADDRS;
1840 hash_keys.addrs.v4addrs.src = fl4->saddr;
1841 hash_keys.addrs.v4addrs.dst = fl4->daddr;
1842 hash_keys.ports.src = fl4->fl4_sport;
1843 hash_keys.ports.dst = fl4->fl4_dport;
1844 hash_keys.basic.ip_proto = fl4->flowi4_proto;
1845 }
1846 break;
1847 }
1848 mhash = flow_hash_from_keys(&hash_keys);
1849
1850 return mhash >> 1;
1851 }
1852 EXPORT_SYMBOL_GPL(fib_multipath_hash);
1853 #endif /* CONFIG_IP_ROUTE_MULTIPATH */
1854
1855 static int ip_mkroute_input(struct sk_buff *skb,
1856 struct fib_result *res,
1857 struct in_device *in_dev,
1858 __be32 daddr, __be32 saddr, u32 tos)
1859 {
1860 #ifdef CONFIG_IP_ROUTE_MULTIPATH
1861 if (res->fi && res->fi->fib_nhs > 1) {
1862 int h = fib_multipath_hash(res->fi, NULL, skb);
1863
1864 fib_select_multipath(res, h);
1865 }
1866 #endif
1867
1868 /* create a routing cache entry */
1869 return __mkroute_input(skb, res, in_dev, daddr, saddr, tos);
1870 }
1871
1872 /*
1873 * NOTE. We drop all the packets that has local source
1874 * addresses, because every properly looped back packet
1875 * must have correct destination already attached by output routine.
1876 *
1877 * Such approach solves two big problems:
1878 * 1. Not simplex devices are handled properly.
1879 * 2. IP spoofing attempts are filtered with 100% of guarantee.
1880 * called with rcu_read_lock()
1881 */
1882
1883 static int ip_route_input_slow(struct sk_buff *skb, __be32 daddr, __be32 saddr,
1884 u8 tos, struct net_device *dev,
1885 struct fib_result *res)
1886 {
1887 struct in_device *in_dev = __in_dev_get_rcu(dev);
1888 struct ip_tunnel_info *tun_info;
1889 struct flowi4 fl4;
1890 unsigned int flags = 0;
1891 u32 itag = 0;
1892 struct rtable *rth;
1893 int err = -EINVAL;
1894 struct net *net = dev_net(dev);
1895 bool do_cache;
1896
1897 /* IP on this device is disabled. */
1898
1899 if (!in_dev)
1900 goto out;
1901
1902 /* Check for the most weird martians, which can be not detected
1903 by fib_lookup.
1904 */
1905
1906 tun_info = skb_tunnel_info(skb);
1907 if (tun_info && !(tun_info->mode & IP_TUNNEL_INFO_TX))
1908 fl4.flowi4_tun_key.tun_id = tun_info->key.tun_id;
1909 else
1910 fl4.flowi4_tun_key.tun_id = 0;
1911 skb_dst_drop(skb);
1912
1913 if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr))
1914 goto martian_source;
1915
1916 res->fi = NULL;
1917 res->table = NULL;
1918 if (ipv4_is_lbcast(daddr) || (saddr == 0 && daddr == 0))
1919 goto brd_input;
1920
1921 /* Accept zero addresses only to limited broadcast;
1922 * I even do not know to fix it or not. Waiting for complains :-)
1923 */
1924 if (ipv4_is_zeronet(saddr))
1925 goto martian_source;
1926
1927 if (ipv4_is_zeronet(daddr))
1928 goto martian_destination;
1929
1930 /* Following code try to avoid calling IN_DEV_NET_ROUTE_LOCALNET(),
1931 * and call it once if daddr or/and saddr are loopback addresses
1932 */
1933 if (ipv4_is_loopback(daddr)) {
1934 if (!IN_DEV_NET_ROUTE_LOCALNET(in_dev, net))
1935 goto martian_destination;
1936 } else if (ipv4_is_loopback(saddr)) {
1937 if (!IN_DEV_NET_ROUTE_LOCALNET(in_dev, net))
1938 goto martian_source;
1939 }
1940
1941 /*
1942 * Now we are ready to route packet.
1943 */
1944 fl4.flowi4_oif = 0;
1945 fl4.flowi4_iif = dev->ifindex;
1946 fl4.flowi4_mark = skb->mark;
1947 fl4.flowi4_tos = tos;
1948 fl4.flowi4_scope = RT_SCOPE_UNIVERSE;
1949 fl4.flowi4_flags = 0;
1950 fl4.daddr = daddr;
1951 fl4.saddr = saddr;
1952 fl4.flowi4_uid = sock_net_uid(net, NULL);
1953 err = fib_lookup(net, &fl4, res, 0);
1954 if (err != 0) {
1955 if (!IN_DEV_FORWARD(in_dev))
1956 err = -EHOSTUNREACH;
1957 goto no_route;
1958 }
1959
1960 if (res->type == RTN_BROADCAST)
1961 goto brd_input;
1962
1963 if (res->type == RTN_LOCAL) {
1964 err = fib_validate_source(skb, saddr, daddr, tos,
1965 0, dev, in_dev, &itag);
1966 if (err < 0)
1967 goto martian_source;
1968 goto local_input;
1969 }
1970
1971 if (!IN_DEV_FORWARD(in_dev)) {
1972 err = -EHOSTUNREACH;
1973 goto no_route;
1974 }
1975 if (res->type != RTN_UNICAST)
1976 goto martian_destination;
1977
1978 err = ip_mkroute_input(skb, res, in_dev, daddr, saddr, tos);
1979 out: return err;
1980
1981 brd_input:
1982 if (skb->protocol != htons(ETH_P_IP))
1983 goto e_inval;
1984
1985 if (!ipv4_is_zeronet(saddr)) {
1986 err = fib_validate_source(skb, saddr, 0, tos, 0, dev,
1987 in_dev, &itag);
1988 if (err < 0)
1989 goto martian_source;
1990 }
1991 flags |= RTCF_BROADCAST;
1992 res->type = RTN_BROADCAST;
1993 RT_CACHE_STAT_INC(in_brd);
1994
1995 local_input:
1996 do_cache = false;
1997 if (res->fi) {
1998 if (!itag) {
1999 rth = rcu_dereference(FIB_RES_NH(*res).nh_rth_input);
2000 if (rt_cache_valid(rth)) {
2001 skb_dst_set_noref(skb, &rth->dst);
2002 err = 0;
2003 goto out;
2004 }
2005 do_cache = true;
2006 }
2007 }
2008
2009 rth = rt_dst_alloc(l3mdev_master_dev_rcu(dev) ? : net->loopback_dev,
2010 flags | RTCF_LOCAL, res->type,
2011 IN_DEV_CONF_GET(in_dev, NOPOLICY), false, do_cache);
2012 if (!rth)
2013 goto e_nobufs;
2014
2015 rth->dst.output= ip_rt_bug;
2016 #ifdef CONFIG_IP_ROUTE_CLASSID
2017 rth->dst.tclassid = itag;
2018 #endif
2019 rth->rt_is_input = 1;
2020 if (res->table)
2021 rth->rt_table_id = res->table->tb_id;
2022
2023 RT_CACHE_STAT_INC(in_slow_tot);
2024 if (res->type == RTN_UNREACHABLE) {
2025 rth->dst.input= ip_error;
2026 rth->dst.error= -err;
2027 rth->rt_flags &= ~RTCF_LOCAL;
2028 }
2029
2030 if (do_cache) {
2031 struct fib_nh *nh = &FIB_RES_NH(*res);
2032
2033 rth->dst.lwtstate = lwtstate_get(nh->nh_lwtstate);
2034 if (lwtunnel_input_redirect(rth->dst.lwtstate)) {
2035 WARN_ON(rth->dst.input == lwtunnel_input);
2036 rth->dst.lwtstate->orig_input = rth->dst.input;
2037 rth->dst.input = lwtunnel_input;
2038 }
2039
2040 if (unlikely(!rt_cache_route(nh, rth)))
2041 rt_add_uncached_list(rth);
2042 }
2043 skb_dst_set(skb, &rth->dst);
2044 err = 0;
2045 goto out;
2046
2047 no_route:
2048 RT_CACHE_STAT_INC(in_no_route);
2049 res->type = RTN_UNREACHABLE;
2050 res->fi = NULL;
2051 res->table = NULL;
2052 goto local_input;
2053
2054 /*
2055 * Do not cache martian addresses: they should be logged (RFC1812)
2056 */
2057 martian_destination:
2058 RT_CACHE_STAT_INC(in_martian_dst);
2059 #ifdef CONFIG_IP_ROUTE_VERBOSE
2060 if (IN_DEV_LOG_MARTIANS(in_dev))
2061 net_warn_ratelimited("martian destination %pI4 from %pI4, dev %s\n",
2062 &daddr, &saddr, dev->name);
2063 #endif
2064
2065 e_inval:
2066 err = -EINVAL;
2067 goto out;
2068
2069 e_nobufs:
2070 err = -ENOBUFS;
2071 goto out;
2072
2073 martian_source:
2074 ip_handle_martian_source(dev, in_dev, skb, daddr, saddr);
2075 goto out;
2076 }
2077
2078 int ip_route_input_noref(struct sk_buff *skb, __be32 daddr, __be32 saddr,
2079 u8 tos, struct net_device *dev)
2080 {
2081 struct fib_result res;
2082 int err;
2083
2084 tos &= IPTOS_RT_MASK;
2085 rcu_read_lock();
2086 err = ip_route_input_rcu(skb, daddr, saddr, tos, dev, &res);
2087 rcu_read_unlock();
2088
2089 return err;
2090 }
2091 EXPORT_SYMBOL(ip_route_input_noref);
2092
2093 /* called with rcu_read_lock held */
2094 int ip_route_input_rcu(struct sk_buff *skb, __be32 daddr, __be32 saddr,
2095 u8 tos, struct net_device *dev, struct fib_result *res)
2096 {
2097 /* Multicast recognition logic is moved from route cache to here.
2098 The problem was that too many Ethernet cards have broken/missing
2099 hardware multicast filters :-( As result the host on multicasting
2100 network acquires a lot of useless route cache entries, sort of
2101 SDR messages from all the world. Now we try to get rid of them.
2102 Really, provided software IP multicast filter is organized
2103 reasonably (at least, hashed), it does not result in a slowdown
2104 comparing with route cache reject entries.
2105 Note, that multicast routers are not affected, because
2106 route cache entry is created eventually.
2107 */
2108 if (ipv4_is_multicast(daddr)) {
2109 struct in_device *in_dev = __in_dev_get_rcu(dev);
2110 int our = 0;
2111 int err = -EINVAL;
2112
2113 if (in_dev)
2114 our = ip_check_mc_rcu(in_dev, daddr, saddr,
2115 ip_hdr(skb)->protocol);
2116
2117 /* check l3 master if no match yet */
2118 if ((!in_dev || !our) && netif_is_l3_slave(dev)) {
2119 struct in_device *l3_in_dev;
2120
2121 l3_in_dev = __in_dev_get_rcu(skb->dev);
2122 if (l3_in_dev)
2123 our = ip_check_mc_rcu(l3_in_dev, daddr, saddr,
2124 ip_hdr(skb)->protocol);
2125 }
2126
2127 if (our
2128 #ifdef CONFIG_IP_MROUTE
2129 ||
2130 (!ipv4_is_local_multicast(daddr) &&
2131 IN_DEV_MFORWARD(in_dev))
2132 #endif
2133 ) {
2134 err = ip_route_input_mc(skb, daddr, saddr,
2135 tos, dev, our);
2136 }
2137 return err;
2138 }
2139
2140 return ip_route_input_slow(skb, daddr, saddr, tos, dev, res);
2141 }
2142
2143 /* called with rcu_read_lock() */
2144 static struct rtable *__mkroute_output(const struct fib_result *res,
2145 const struct flowi4 *fl4, int orig_oif,
2146 struct net_device *dev_out,
2147 unsigned int flags)
2148 {
2149 struct fib_info *fi = res->fi;
2150 struct fib_nh_exception *fnhe;
2151 struct in_device *in_dev;
2152 u16 type = res->type;
2153 struct rtable *rth;
2154 bool do_cache;
2155
2156 in_dev = __in_dev_get_rcu(dev_out);
2157 if (!in_dev)
2158 return ERR_PTR(-EINVAL);
2159
2160 if (likely(!IN_DEV_ROUTE_LOCALNET(in_dev)))
2161 if (ipv4_is_loopback(fl4->saddr) &&
2162 !(dev_out->flags & IFF_LOOPBACK) &&
2163 !netif_is_l3_master(dev_out))
2164 return ERR_PTR(-EINVAL);
2165
2166 if (ipv4_is_lbcast(fl4->daddr))
2167 type = RTN_BROADCAST;
2168 else if (ipv4_is_multicast(fl4->daddr))
2169 type = RTN_MULTICAST;
2170 else if (ipv4_is_zeronet(fl4->daddr))
2171 return ERR_PTR(-EINVAL);
2172
2173 if (dev_out->flags & IFF_LOOPBACK)
2174 flags |= RTCF_LOCAL;
2175
2176 do_cache = true;
2177 if (type == RTN_BROADCAST) {
2178 flags |= RTCF_BROADCAST | RTCF_LOCAL;
2179 fi = NULL;
2180 } else if (type == RTN_MULTICAST) {
2181 flags |= RTCF_MULTICAST | RTCF_LOCAL;
2182 if (!ip_check_mc_rcu(in_dev, fl4->daddr, fl4->saddr,
2183 fl4->flowi4_proto))
2184 flags &= ~RTCF_LOCAL;
2185 else
2186 do_cache = false;
2187 /* If multicast route do not exist use
2188 * default one, but do not gateway in this case.
2189 * Yes, it is hack.
2190 */
2191 if (fi && res->prefixlen < 4)
2192 fi = NULL;
2193 } else if ((type == RTN_LOCAL) && (orig_oif != 0) &&
2194 (orig_oif != dev_out->ifindex)) {
2195 /* For local routes that require a particular output interface
2196 * we do not want to cache the result. Caching the result
2197 * causes incorrect behaviour when there are multiple source
2198 * addresses on the interface, the end result being that if the
2199 * intended recipient is waiting on that interface for the
2200 * packet he won't receive it because it will be delivered on
2201 * the loopback interface and the IP_PKTINFO ipi_ifindex will
2202 * be set to the loopback interface as well.
2203 */
2204 fi = NULL;
2205 }
2206
2207 fnhe = NULL;
2208 do_cache &= fi != NULL;
2209 if (do_cache) {
2210 struct rtable __rcu **prth;
2211 struct fib_nh *nh = &FIB_RES_NH(*res);
2212
2213 fnhe = find_exception(nh, fl4->daddr);
2214 if (fnhe) {
2215 prth = &fnhe->fnhe_rth_output;
2216 rth = rcu_dereference(*prth);
2217 if (rth && rth->dst.expires &&
2218 time_after(jiffies, rth->dst.expires)) {
2219 ip_del_fnhe(nh, fl4->daddr);
2220 fnhe = NULL;
2221 } else {
2222 goto rt_cache;
2223 }
2224 }
2225
2226 if (unlikely(fl4->flowi4_flags &
2227 FLOWI_FLAG_KNOWN_NH &&
2228 !(nh->nh_gw &&
2229 nh->nh_scope == RT_SCOPE_LINK))) {
2230 do_cache = false;
2231 goto add;
2232 }
2233 prth = raw_cpu_ptr(nh->nh_pcpu_rth_output);
2234 rth = rcu_dereference(*prth);
2235
2236 rt_cache:
2237 if (rt_cache_valid(rth) && dst_hold_safe(&rth->dst))
2238 return rth;
2239 }
2240
2241 add:
2242 rth = rt_dst_alloc(dev_out, flags, type,
2243 IN_DEV_CONF_GET(in_dev, NOPOLICY),
2244 IN_DEV_CONF_GET(in_dev, NOXFRM),
2245 do_cache);
2246 if (!rth)
2247 return ERR_PTR(-ENOBUFS);
2248
2249 rth->rt_iif = orig_oif;
2250 if (res->table)
2251 rth->rt_table_id = res->table->tb_id;
2252
2253 RT_CACHE_STAT_INC(out_slow_tot);
2254
2255 if (flags & (RTCF_BROADCAST | RTCF_MULTICAST)) {
2256 if (flags & RTCF_LOCAL &&
2257 !(dev_out->flags & IFF_LOOPBACK)) {
2258 rth->dst.output = ip_mc_output;
2259 RT_CACHE_STAT_INC(out_slow_mc);
2260 }
2261 #ifdef CONFIG_IP_MROUTE
2262 if (type == RTN_MULTICAST) {
2263 if (IN_DEV_MFORWARD(in_dev) &&
2264 !ipv4_is_local_multicast(fl4->daddr)) {
2265 rth->dst.input = ip_mr_input;
2266 rth->dst.output = ip_mc_output;
2267 }
2268 }
2269 #endif
2270 }
2271
2272 rt_set_nexthop(rth, fl4->daddr, res, fnhe, fi, type, 0, do_cache);
2273 set_lwt_redirect(rth);
2274
2275 return rth;
2276 }
2277
2278 /*
2279 * Major route resolver routine.
2280 */
2281
2282 struct rtable *ip_route_output_key_hash(struct net *net, struct flowi4 *fl4,
2283 const struct sk_buff *skb)
2284 {
2285 __u8 tos = RT_FL_TOS(fl4);
2286 struct fib_result res;
2287 struct rtable *rth;
2288
2289 res.tclassid = 0;
2290 res.fi = NULL;
2291 res.table = NULL;
2292
2293 fl4->flowi4_iif = LOOPBACK_IFINDEX;
2294 fl4->flowi4_tos = tos & IPTOS_RT_MASK;
2295 fl4->flowi4_scope = ((tos & RTO_ONLINK) ?
2296 RT_SCOPE_LINK : RT_SCOPE_UNIVERSE);
2297
2298 rcu_read_lock();
2299 rth = ip_route_output_key_hash_rcu(net, fl4, &res, skb);
2300 rcu_read_unlock();
2301
2302 return rth;
2303 }
2304 EXPORT_SYMBOL_GPL(ip_route_output_key_hash);
2305
2306 struct rtable *ip_route_output_key_hash_rcu(struct net *net, struct flowi4 *fl4,
2307 struct fib_result *res,
2308 const struct sk_buff *skb)
2309 {
2310 struct net_device *dev_out = NULL;
2311 int orig_oif = fl4->flowi4_oif;
2312 unsigned int flags = 0;
2313 struct rtable *rth;
2314 int err = -ENETUNREACH;
2315
2316 if (fl4->saddr) {
2317 rth = ERR_PTR(-EINVAL);
2318 if (ipv4_is_multicast(fl4->saddr) ||
2319 ipv4_is_lbcast(fl4->saddr) ||
2320 ipv4_is_zeronet(fl4->saddr))
2321 goto out;
2322
2323 /* I removed check for oif == dev_out->oif here.
2324 It was wrong for two reasons:
2325 1. ip_dev_find(net, saddr) can return wrong iface, if saddr
2326 is assigned to multiple interfaces.
2327 2. Moreover, we are allowed to send packets with saddr
2328 of another iface. --ANK
2329 */
2330
2331 if (fl4->flowi4_oif == 0 &&
2332 (ipv4_is_multicast(fl4->daddr) ||
2333 ipv4_is_lbcast(fl4->daddr))) {
2334 /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
2335 dev_out = __ip_dev_find(net, fl4->saddr, false);
2336 if (!dev_out)
2337 goto out;
2338
2339 /* Special hack: user can direct multicasts
2340 and limited broadcast via necessary interface
2341 without fiddling with IP_MULTICAST_IF or IP_PKTINFO.
2342 This hack is not just for fun, it allows
2343 vic,vat and friends to work.
2344 They bind socket to loopback, set ttl to zero
2345 and expect that it will work.
2346 From the viewpoint of routing cache they are broken,
2347 because we are not allowed to build multicast path
2348 with loopback source addr (look, routing cache
2349 cannot know, that ttl is zero, so that packet
2350 will not leave this host and route is valid).
2351 Luckily, this hack is good workaround.
2352 */
2353
2354 fl4->flowi4_oif = dev_out->ifindex;
2355 goto make_route;
2356 }
2357
2358 if (!(fl4->flowi4_flags & FLOWI_FLAG_ANYSRC)) {
2359 /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
2360 if (!__ip_dev_find(net, fl4->saddr, false))
2361 goto out;
2362 }
2363 }
2364
2365
2366 if (fl4->flowi4_oif) {
2367 dev_out = dev_get_by_index_rcu(net, fl4->flowi4_oif);
2368 rth = ERR_PTR(-ENODEV);
2369 if (!dev_out)
2370 goto out;
2371
2372 /* RACE: Check return value of inet_select_addr instead. */
2373 if (!(dev_out->flags & IFF_UP) || !__in_dev_get_rcu(dev_out)) {
2374 rth = ERR_PTR(-ENETUNREACH);
2375 goto out;
2376 }
2377 if (ipv4_is_local_multicast(fl4->daddr) ||
2378 ipv4_is_lbcast(fl4->daddr) ||
2379 fl4->flowi4_proto == IPPROTO_IGMP) {
2380 if (!fl4->saddr)
2381 fl4->saddr = inet_select_addr(dev_out, 0,
2382 RT_SCOPE_LINK);
2383 goto make_route;
2384 }
2385 if (!fl4->saddr) {
2386 if (ipv4_is_multicast(fl4->daddr))
2387 fl4->saddr = inet_select_addr(dev_out, 0,
2388 fl4->flowi4_scope);
2389 else if (!fl4->daddr)
2390 fl4->saddr = inet_select_addr(dev_out, 0,
2391 RT_SCOPE_HOST);
2392 }
2393 }
2394
2395 if (!fl4->daddr) {
2396 fl4->daddr = fl4->saddr;
2397 if (!fl4->daddr)
2398 fl4->daddr = fl4->saddr = htonl(INADDR_LOOPBACK);
2399 dev_out = net->loopback_dev;
2400 fl4->flowi4_oif = LOOPBACK_IFINDEX;
2401 res->type = RTN_LOCAL;
2402 flags |= RTCF_LOCAL;
2403 goto make_route;
2404 }
2405
2406 err = fib_lookup(net, fl4, res, 0);
2407 if (err) {
2408 res->fi = NULL;
2409 res->table = NULL;
2410 if (fl4->flowi4_oif &&
2411 (ipv4_is_multicast(fl4->daddr) ||
2412 !netif_index_is_l3_master(net, fl4->flowi4_oif))) {
2413 /* Apparently, routing tables are wrong. Assume,
2414 that the destination is on link.
2415
2416 WHY? DW.
2417 Because we are allowed to send to iface
2418 even if it has NO routes and NO assigned
2419 addresses. When oif is specified, routing
2420 tables are looked up with only one purpose:
2421 to catch if destination is gatewayed, rather than
2422 direct. Moreover, if MSG_DONTROUTE is set,
2423 we send packet, ignoring both routing tables
2424 and ifaddr state. --ANK
2425
2426
2427 We could make it even if oif is unknown,
2428 likely IPv6, but we do not.
2429 */
2430
2431 if (fl4->saddr == 0)
2432 fl4->saddr = inet_select_addr(dev_out, 0,
2433 RT_SCOPE_LINK);
2434 res->type = RTN_UNICAST;
2435 goto make_route;
2436 }
2437 rth = ERR_PTR(err);
2438 goto out;
2439 }
2440
2441 if (res->type == RTN_LOCAL) {
2442 if (!fl4->saddr) {
2443 if (res->fi->fib_prefsrc)
2444 fl4->saddr = res->fi->fib_prefsrc;
2445 else
2446 fl4->saddr = fl4->daddr;
2447 }
2448
2449 /* L3 master device is the loopback for that domain */
2450 dev_out = l3mdev_master_dev_rcu(FIB_RES_DEV(*res)) ? :
2451 net->loopback_dev;
2452
2453 /* make sure orig_oif points to fib result device even
2454 * though packet rx/tx happens over loopback or l3mdev
2455 */
2456 orig_oif = FIB_RES_OIF(*res);
2457
2458 fl4->flowi4_oif = dev_out->ifindex;
2459 flags |= RTCF_LOCAL;
2460 goto make_route;
2461 }
2462
2463 fib_select_path(net, res, fl4, skb);
2464
2465 dev_out = FIB_RES_DEV(*res);
2466 fl4->flowi4_oif = dev_out->ifindex;
2467
2468
2469 make_route:
2470 rth = __mkroute_output(res, fl4, orig_oif, dev_out, flags);
2471
2472 out:
2473 return rth;
2474 }
2475
2476 static struct dst_entry *ipv4_blackhole_dst_check(struct dst_entry *dst, u32 cookie)
2477 {
2478 return NULL;
2479 }
2480
2481 static unsigned int ipv4_blackhole_mtu(const struct dst_entry *dst)
2482 {
2483 unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
2484
2485 return mtu ? : dst->dev->mtu;
2486 }
2487
2488 static void ipv4_rt_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,
2489 struct sk_buff *skb, u32 mtu)
2490 {
2491 }
2492
2493 static void ipv4_rt_blackhole_redirect(struct dst_entry *dst, struct sock *sk,
2494 struct sk_buff *skb)
2495 {
2496 }
2497
2498 static u32 *ipv4_rt_blackhole_cow_metrics(struct dst_entry *dst,
2499 unsigned long old)
2500 {
2501 return NULL;
2502 }
2503
2504 static struct dst_ops ipv4_dst_blackhole_ops = {
2505 .family = AF_INET,
2506 .check = ipv4_blackhole_dst_check,
2507 .mtu = ipv4_blackhole_mtu,
2508 .default_advmss = ipv4_default_advmss,
2509 .update_pmtu = ipv4_rt_blackhole_update_pmtu,
2510 .redirect = ipv4_rt_blackhole_redirect,
2511 .cow_metrics = ipv4_rt_blackhole_cow_metrics,
2512 .neigh_lookup = ipv4_neigh_lookup,
2513 };
2514
2515 struct dst_entry *ipv4_blackhole_route(struct net *net, struct dst_entry *dst_orig)
2516 {
2517 struct rtable *ort = (struct rtable *) dst_orig;
2518 struct rtable *rt;
2519
2520 rt = dst_alloc(&ipv4_dst_blackhole_ops, NULL, 1, DST_OBSOLETE_DEAD, 0);
2521 if (rt) {
2522 struct dst_entry *new = &rt->dst;
2523
2524 new->__use = 1;
2525 new->input = dst_discard;
2526 new->output = dst_discard_out;
2527
2528 new->dev = net->loopback_dev;
2529 if (new->dev)
2530 dev_hold(new->dev);
2531
2532 rt->rt_is_input = ort->rt_is_input;
2533 rt->rt_iif = ort->rt_iif;
2534 rt->rt_pmtu = ort->rt_pmtu;
2535
2536 rt->rt_genid = rt_genid_ipv4(net);
2537 rt->rt_flags = ort->rt_flags;
2538 rt->rt_type = ort->rt_type;
2539 rt->rt_gateway = ort->rt_gateway;
2540 rt->rt_uses_gateway = ort->rt_uses_gateway;
2541
2542 INIT_LIST_HEAD(&rt->rt_uncached);
2543 }
2544
2545 dst_release(dst_orig);
2546
2547 return rt ? &rt->dst : ERR_PTR(-ENOMEM);
2548 }
2549
2550 struct rtable *ip_route_output_flow(struct net *net, struct flowi4 *flp4,
2551 const struct sock *sk)
2552 {
2553 struct rtable *rt = __ip_route_output_key(net, flp4);
2554
2555 if (IS_ERR(rt))
2556 return rt;
2557
2558 if (flp4->flowi4_proto)
2559 rt = (struct rtable *)xfrm_lookup_route(net, &rt->dst,
2560 flowi4_to_flowi(flp4),
2561 sk, 0);
2562
2563 return rt;
2564 }
2565 EXPORT_SYMBOL_GPL(ip_route_output_flow);
2566
2567 /* called with rcu_read_lock held */
2568 static int rt_fill_info(struct net *net, __be32 dst, __be32 src, u32 table_id,
2569 struct flowi4 *fl4, struct sk_buff *skb, u32 portid,
2570 u32 seq)
2571 {
2572 struct rtable *rt = skb_rtable(skb);
2573 struct rtmsg *r;
2574 struct nlmsghdr *nlh;
2575 unsigned long expires = 0;
2576 u32 error;
2577 u32 metrics[RTAX_MAX];
2578
2579 nlh = nlmsg_put(skb, portid, seq, RTM_NEWROUTE, sizeof(*r), 0);
2580 if (!nlh)
2581 return -EMSGSIZE;
2582
2583 r = nlmsg_data(nlh);
2584 r->rtm_family = AF_INET;
2585 r->rtm_dst_len = 32;
2586 r->rtm_src_len = 0;
2587 r->rtm_tos = fl4->flowi4_tos;
2588 r->rtm_table = table_id < 256 ? table_id : RT_TABLE_COMPAT;
2589 if (nla_put_u32(skb, RTA_TABLE, table_id))
2590 goto nla_put_failure;
2591 r->rtm_type = rt->rt_type;
2592 r->rtm_scope = RT_SCOPE_UNIVERSE;
2593 r->rtm_protocol = RTPROT_UNSPEC;
2594 r->rtm_flags = (rt->rt_flags & ~0xFFFF) | RTM_F_CLONED;
2595 if (rt->rt_flags & RTCF_NOTIFY)
2596 r->rtm_flags |= RTM_F_NOTIFY;
2597 if (IPCB(skb)->flags & IPSKB_DOREDIRECT)
2598 r->rtm_flags |= RTCF_DOREDIRECT;
2599
2600 if (nla_put_in_addr(skb, RTA_DST, dst))
2601 goto nla_put_failure;
2602 if (src) {
2603 r->rtm_src_len = 32;
2604 if (nla_put_in_addr(skb, RTA_SRC, src))
2605 goto nla_put_failure;
2606 }
2607 if (rt->dst.dev &&
2608 nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
2609 goto nla_put_failure;
2610 #ifdef CONFIG_IP_ROUTE_CLASSID
2611 if (rt->dst.tclassid &&
2612 nla_put_u32(skb, RTA_FLOW, rt->dst.tclassid))
2613 goto nla_put_failure;
2614 #endif
2615 if (!rt_is_input_route(rt) &&
2616 fl4->saddr != src) {
2617 if (nla_put_in_addr(skb, RTA_PREFSRC, fl4->saddr))
2618 goto nla_put_failure;
2619 }
2620 if (rt->rt_uses_gateway &&
2621 nla_put_in_addr(skb, RTA_GATEWAY, rt->rt_gateway))
2622 goto nla_put_failure;
2623
2624 expires = rt->dst.expires;
2625 if (expires) {
2626 unsigned long now = jiffies;
2627
2628 if (time_before(now, expires))
2629 expires -= now;
2630 else
2631 expires = 0;
2632 }
2633
2634 memcpy(metrics, dst_metrics_ptr(&rt->dst), sizeof(metrics));
2635 if (rt->rt_pmtu && expires)
2636 metrics[RTAX_MTU - 1] = rt->rt_pmtu;
2637 if (rtnetlink_put_metrics(skb, metrics) < 0)
2638 goto nla_put_failure;
2639
2640 if (fl4->flowi4_mark &&
2641 nla_put_u32(skb, RTA_MARK, fl4->flowi4_mark))
2642 goto nla_put_failure;
2643
2644 if (!uid_eq(fl4->flowi4_uid, INVALID_UID) &&
2645 nla_put_u32(skb, RTA_UID,
2646 from_kuid_munged(current_user_ns(), fl4->flowi4_uid)))
2647 goto nla_put_failure;
2648
2649 error = rt->dst.error;
2650
2651 if (rt_is_input_route(rt)) {
2652 #ifdef CONFIG_IP_MROUTE
2653 if (ipv4_is_multicast(dst) && !ipv4_is_local_multicast(dst) &&
2654 IPV4_DEVCONF_ALL(net, MC_FORWARDING)) {
2655 int err = ipmr_get_route(net, skb,
2656 fl4->saddr, fl4->daddr,
2657 r, portid);
2658
2659 if (err <= 0) {
2660 if (err == 0)
2661 return 0;
2662 goto nla_put_failure;
2663 }
2664 } else
2665 #endif
2666 if (nla_put_u32(skb, RTA_IIF, skb->dev->ifindex))
2667 goto nla_put_failure;
2668 }
2669
2670 if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, error) < 0)
2671 goto nla_put_failure;
2672
2673 nlmsg_end(skb, nlh);
2674 return 0;
2675
2676 nla_put_failure:
2677 nlmsg_cancel(skb, nlh);
2678 return -EMSGSIZE;
2679 }
2680
2681 static int inet_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh,
2682 struct netlink_ext_ack *extack)
2683 {
2684 struct net *net = sock_net(in_skb->sk);
2685 struct rtmsg *rtm;
2686 struct nlattr *tb[RTA_MAX+1];
2687 struct fib_result res = {};
2688 struct rtable *rt = NULL;
2689 struct flowi4 fl4;
2690 __be32 dst = 0;
2691 __be32 src = 0;
2692 u32 iif;
2693 int err;
2694 int mark;
2695 struct sk_buff *skb;
2696 u32 table_id = RT_TABLE_MAIN;
2697 kuid_t uid;
2698
2699 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv4_policy,
2700 extack);
2701 if (err < 0)
2702 goto errout;
2703
2704 rtm = nlmsg_data(nlh);
2705
2706 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
2707 if (!skb) {
2708 err = -ENOBUFS;
2709 goto errout;
2710 }
2711
2712 /* Reserve room for dummy headers, this skb can pass
2713 through good chunk of routing engine.
2714 */
2715 skb_reset_mac_header(skb);
2716 skb_reset_network_header(skb);
2717
2718 src = tb[RTA_SRC] ? nla_get_in_addr(tb[RTA_SRC]) : 0;
2719 dst = tb[RTA_DST] ? nla_get_in_addr(tb[RTA_DST]) : 0;
2720 iif = tb[RTA_IIF] ? nla_get_u32(tb[RTA_IIF]) : 0;
2721 mark = tb[RTA_MARK] ? nla_get_u32(tb[RTA_MARK]) : 0;
2722 if (tb[RTA_UID])
2723 uid = make_kuid(current_user_ns(), nla_get_u32(tb[RTA_UID]));
2724 else
2725 uid = (iif ? INVALID_UID : current_uid());
2726
2727 /* Bugfix: need to give ip_route_input enough of an IP header to
2728 * not gag.
2729 */
2730 ip_hdr(skb)->protocol = IPPROTO_UDP;
2731 ip_hdr(skb)->saddr = src;
2732 ip_hdr(skb)->daddr = dst;
2733
2734 skb_reserve(skb, MAX_HEADER + sizeof(struct iphdr));
2735
2736 memset(&fl4, 0, sizeof(fl4));
2737 fl4.daddr = dst;
2738 fl4.saddr = src;
2739 fl4.flowi4_tos = rtm->rtm_tos;
2740 fl4.flowi4_oif = tb[RTA_OIF] ? nla_get_u32(tb[RTA_OIF]) : 0;
2741 fl4.flowi4_mark = mark;
2742 fl4.flowi4_uid = uid;
2743
2744 rcu_read_lock();
2745
2746 if (iif) {
2747 struct net_device *dev;
2748
2749 dev = dev_get_by_index_rcu(net, iif);
2750 if (!dev) {
2751 err = -ENODEV;
2752 goto errout_free;
2753 }
2754
2755 skb->protocol = htons(ETH_P_IP);
2756 skb->dev = dev;
2757 skb->mark = mark;
2758 err = ip_route_input_rcu(skb, dst, src, rtm->rtm_tos,
2759 dev, &res);
2760
2761 rt = skb_rtable(skb);
2762 if (err == 0 && rt->dst.error)
2763 err = -rt->dst.error;
2764 } else {
2765 fl4.flowi4_iif = LOOPBACK_IFINDEX;
2766 rt = ip_route_output_key_hash_rcu(net, &fl4, &res, skb);
2767 err = 0;
2768 if (IS_ERR(rt))
2769 err = PTR_ERR(rt);
2770 else
2771 skb_dst_set(skb, &rt->dst);
2772 }
2773
2774 if (err)
2775 goto errout_free;
2776
2777 if (rtm->rtm_flags & RTM_F_NOTIFY)
2778 rt->rt_flags |= RTCF_NOTIFY;
2779
2780 if (rtm->rtm_flags & RTM_F_LOOKUP_TABLE)
2781 table_id = rt->rt_table_id;
2782
2783 if (rtm->rtm_flags & RTM_F_FIB_MATCH) {
2784 if (!res.fi) {
2785 err = fib_props[res.type].error;
2786 if (!err)
2787 err = -EHOSTUNREACH;
2788 goto errout_free;
2789 }
2790 err = fib_dump_info(skb, NETLINK_CB(in_skb).portid,
2791 nlh->nlmsg_seq, RTM_NEWROUTE, table_id,
2792 rt->rt_type, res.prefix, res.prefixlen,
2793 fl4.flowi4_tos, res.fi, 0);
2794 } else {
2795 err = rt_fill_info(net, dst, src, table_id, &fl4, skb,
2796 NETLINK_CB(in_skb).portid, nlh->nlmsg_seq);
2797 }
2798 if (err < 0)
2799 goto errout_free;
2800
2801 rcu_read_unlock();
2802
2803 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
2804 errout:
2805 return err;
2806
2807 errout_free:
2808 rcu_read_unlock();
2809 kfree_skb(skb);
2810 goto errout;
2811 }
2812
2813 void ip_rt_multicast_event(struct in_device *in_dev)
2814 {
2815 rt_cache_flush(dev_net(in_dev->dev));
2816 }
2817
2818 #ifdef CONFIG_SYSCTL
2819 static int ip_rt_gc_interval __read_mostly = 60 * HZ;
2820 static int ip_rt_gc_min_interval __read_mostly = HZ / 2;
2821 static int ip_rt_gc_elasticity __read_mostly = 8;
2822
2823 static int ipv4_sysctl_rtcache_flush(struct ctl_table *__ctl, int write,
2824 void __user *buffer,
2825 size_t *lenp, loff_t *ppos)
2826 {
2827 struct net *net = (struct net *)__ctl->extra1;
2828
2829 if (write) {
2830 rt_cache_flush(net);
2831 fnhe_genid_bump(net);
2832 return 0;
2833 }
2834
2835 return -EINVAL;
2836 }
2837
2838 static struct ctl_table ipv4_route_table[] = {
2839 {
2840 .procname = "gc_thresh",
2841 .data = &ipv4_dst_ops.gc_thresh,
2842 .maxlen = sizeof(int),
2843 .mode = 0644,
2844 .proc_handler = proc_dointvec,
2845 },
2846 {
2847 .procname = "max_size",
2848 .data = &ip_rt_max_size,
2849 .maxlen = sizeof(int),
2850 .mode = 0644,
2851 .proc_handler = proc_dointvec,
2852 },
2853 {
2854 /* Deprecated. Use gc_min_interval_ms */
2855
2856 .procname = "gc_min_interval",
2857 .data = &ip_rt_gc_min_interval,
2858 .maxlen = sizeof(int),
2859 .mode = 0644,
2860 .proc_handler = proc_dointvec_jiffies,
2861 },
2862 {
2863 .procname = "gc_min_interval_ms",
2864 .data = &ip_rt_gc_min_interval,
2865 .maxlen = sizeof(int),
2866 .mode = 0644,
2867 .proc_handler = proc_dointvec_ms_jiffies,
2868 },
2869 {
2870 .procname = "gc_timeout",
2871 .data = &ip_rt_gc_timeout,
2872 .maxlen = sizeof(int),
2873 .mode = 0644,
2874 .proc_handler = proc_dointvec_jiffies,
2875 },
2876 {
2877 .procname = "gc_interval",
2878 .data = &ip_rt_gc_interval,
2879 .maxlen = sizeof(int),
2880 .mode = 0644,
2881 .proc_handler = proc_dointvec_jiffies,
2882 },
2883 {
2884 .procname = "redirect_load",
2885 .data = &ip_rt_redirect_load,
2886 .maxlen = sizeof(int),
2887 .mode = 0644,
2888 .proc_handler = proc_dointvec,
2889 },
2890 {
2891 .procname = "redirect_number",
2892 .data = &ip_rt_redirect_number,
2893 .maxlen = sizeof(int),
2894 .mode = 0644,
2895 .proc_handler = proc_dointvec,
2896 },
2897 {
2898 .procname = "redirect_silence",
2899 .data = &ip_rt_redirect_silence,
2900 .maxlen = sizeof(int),
2901 .mode = 0644,
2902 .proc_handler = proc_dointvec,
2903 },
2904 {
2905 .procname = "error_cost",
2906 .data = &ip_rt_error_cost,
2907 .maxlen = sizeof(int),
2908 .mode = 0644,
2909 .proc_handler = proc_dointvec,
2910 },
2911 {
2912 .procname = "error_burst",
2913 .data = &ip_rt_error_burst,
2914 .maxlen = sizeof(int),
2915 .mode = 0644,
2916 .proc_handler = proc_dointvec,
2917 },
2918 {
2919 .procname = "gc_elasticity",
2920 .data = &ip_rt_gc_elasticity,
2921 .maxlen = sizeof(int),
2922 .mode = 0644,
2923 .proc_handler = proc_dointvec,
2924 },
2925 {
2926 .procname = "mtu_expires",
2927 .data = &ip_rt_mtu_expires,
2928 .maxlen = sizeof(int),
2929 .mode = 0644,
2930 .proc_handler = proc_dointvec_jiffies,
2931 },
2932 {
2933 .procname = "min_pmtu",
2934 .data = &ip_rt_min_pmtu,
2935 .maxlen = sizeof(int),
2936 .mode = 0644,
2937 .proc_handler = proc_dointvec,
2938 },
2939 {
2940 .procname = "min_adv_mss",
2941 .data = &ip_rt_min_advmss,
2942 .maxlen = sizeof(int),
2943 .mode = 0644,
2944 .proc_handler = proc_dointvec,
2945 },
2946 { }
2947 };
2948
2949 static struct ctl_table ipv4_route_flush_table[] = {
2950 {
2951 .procname = "flush",
2952 .maxlen = sizeof(int),
2953 .mode = 0200,
2954 .proc_handler = ipv4_sysctl_rtcache_flush,
2955 },
2956 { },
2957 };
2958
2959 static __net_init int sysctl_route_net_init(struct net *net)
2960 {
2961 struct ctl_table *tbl;
2962
2963 tbl = ipv4_route_flush_table;
2964 if (!net_eq(net, &init_net)) {
2965 tbl = kmemdup(tbl, sizeof(ipv4_route_flush_table), GFP_KERNEL);
2966 if (!tbl)
2967 goto err_dup;
2968
2969 /* Don't export sysctls to unprivileged users */
2970 if (net->user_ns != &init_user_ns)
2971 tbl[0].procname = NULL;
2972 }
2973 tbl[0].extra1 = net;
2974
2975 net->ipv4.route_hdr = register_net_sysctl(net, "net/ipv4/route", tbl);
2976 if (!net->ipv4.route_hdr)
2977 goto err_reg;
2978 return 0;
2979
2980 err_reg:
2981 if (tbl != ipv4_route_flush_table)
2982 kfree(tbl);
2983 err_dup:
2984 return -ENOMEM;
2985 }
2986
2987 static __net_exit void sysctl_route_net_exit(struct net *net)
2988 {
2989 struct ctl_table *tbl;
2990
2991 tbl = net->ipv4.route_hdr->ctl_table_arg;
2992 unregister_net_sysctl_table(net->ipv4.route_hdr);
2993 BUG_ON(tbl == ipv4_route_flush_table);
2994 kfree(tbl);
2995 }
2996
2997 static __net_initdata struct pernet_operations sysctl_route_ops = {
2998 .init = sysctl_route_net_init,
2999 .exit = sysctl_route_net_exit,
3000 };
3001 #endif
3002
3003 static __net_init int rt_genid_init(struct net *net)
3004 {
3005 atomic_set(&net->ipv4.rt_genid, 0);
3006 atomic_set(&net->fnhe_genid, 0);
3007 atomic_set(&net->ipv4.dev_addr_genid, get_random_int());
3008 return 0;
3009 }
3010
3011 static __net_initdata struct pernet_operations rt_genid_ops = {
3012 .init = rt_genid_init,
3013 };
3014
3015 static int __net_init ipv4_inetpeer_init(struct net *net)
3016 {
3017 struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
3018
3019 if (!bp)
3020 return -ENOMEM;
3021 inet_peer_base_init(bp);
3022 net->ipv4.peers = bp;
3023 return 0;
3024 }
3025
3026 static void __net_exit ipv4_inetpeer_exit(struct net *net)
3027 {
3028 struct inet_peer_base *bp = net->ipv4.peers;
3029
3030 net->ipv4.peers = NULL;
3031 inetpeer_invalidate_tree(bp);
3032 kfree(bp);
3033 }
3034
3035 static __net_initdata struct pernet_operations ipv4_inetpeer_ops = {
3036 .init = ipv4_inetpeer_init,
3037 .exit = ipv4_inetpeer_exit,
3038 };
3039
3040 #ifdef CONFIG_IP_ROUTE_CLASSID
3041 struct ip_rt_acct __percpu *ip_rt_acct __read_mostly;
3042 #endif /* CONFIG_IP_ROUTE_CLASSID */
3043
3044 int __init ip_rt_init(void)
3045 {
3046 int cpu;
3047
3048 ip_idents = kmalloc(IP_IDENTS_SZ * sizeof(*ip_idents), GFP_KERNEL);
3049 if (!ip_idents)
3050 panic("IP: failed to allocate ip_idents\n");
3051
3052 prandom_bytes(ip_idents, IP_IDENTS_SZ * sizeof(*ip_idents));
3053
3054 ip_tstamps = kcalloc(IP_IDENTS_SZ, sizeof(*ip_tstamps), GFP_KERNEL);
3055 if (!ip_tstamps)
3056 panic("IP: failed to allocate ip_tstamps\n");
3057
3058 for_each_possible_cpu(cpu) {
3059 struct uncached_list *ul = &per_cpu(rt_uncached_list, cpu);
3060
3061 INIT_LIST_HEAD(&ul->head);
3062 spin_lock_init(&ul->lock);
3063 }
3064 #ifdef CONFIG_IP_ROUTE_CLASSID
3065 ip_rt_acct = __alloc_percpu(256 * sizeof(struct ip_rt_acct), __alignof__(struct ip_rt_acct));
3066 if (!ip_rt_acct)
3067 panic("IP: failed to allocate ip_rt_acct\n");
3068 #endif
3069
3070 ipv4_dst_ops.kmem_cachep =
3071 kmem_cache_create("ip_dst_cache", sizeof(struct rtable), 0,
3072 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
3073
3074 ipv4_dst_blackhole_ops.kmem_cachep = ipv4_dst_ops.kmem_cachep;
3075
3076 if (dst_entries_init(&ipv4_dst_ops) < 0)
3077 panic("IP: failed to allocate ipv4_dst_ops counter\n");
3078
3079 if (dst_entries_init(&ipv4_dst_blackhole_ops) < 0)
3080 panic("IP: failed to allocate ipv4_dst_blackhole_ops counter\n");
3081
3082 ipv4_dst_ops.gc_thresh = ~0;
3083 ip_rt_max_size = INT_MAX;
3084
3085 devinet_init();
3086 ip_fib_init();
3087
3088 if (ip_rt_proc_init())
3089 pr_err("Unable to create route proc files\n");
3090 #ifdef CONFIG_XFRM
3091 xfrm_init();
3092 xfrm4_init();
3093 #endif
3094 rtnl_register(PF_INET, RTM_GETROUTE, inet_rtm_getroute, NULL,
3095 RTNL_FLAG_DOIT_UNLOCKED);
3096
3097 #ifdef CONFIG_SYSCTL
3098 register_pernet_subsys(&sysctl_route_ops);
3099 #endif
3100 register_pernet_subsys(&rt_genid_ops);
3101 register_pernet_subsys(&ipv4_inetpeer_ops);
3102 return 0;
3103 }
3104
3105 #ifdef CONFIG_SYSCTL
3106 /*
3107 * We really need to sanitize the damn ipv4 init order, then all
3108 * this nonsense will go away.
3109 */
3110 void __init ip_static_sysctl_init(void)
3111 {
3112 register_net_sysctl(&init_net, "net/ipv4/route", ipv4_route_table);
3113 }
3114 #endif
ubuntu-bionic-kernel mirror