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