projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'v3.10.105' into update
[GitHub/mt8127/android_kernel_alcatel_ttab.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 <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/net_namespace.h>
95 #include <net/protocol.h>
96 #include <net/ip.h>
97 #include <net/route.h>
98 #include <net/inetpeer.h>
99 #include <net/sock.h>
100 #include <net/ip_fib.h>
101 #include <net/arp.h>
102 #include <net/tcp.h>
103 #include <net/icmp.h>
104 #include <net/xfrm.h>
105 #include <net/netevent.h>
106 #include <net/rtnetlink.h>
107 #ifdef CONFIG_SYSCTL
108 #include <linux/sysctl.h>
109 #include <linux/kmemleak.h>
110 #endif
111 #include <net/secure_seq.h>
112
113 #define RT_FL_TOS(oldflp4) \
114 ((oldflp4)->flowi4_tos & (IPTOS_RT_MASK | RTO_ONLINK))
115
116 #define IP_MAX_MTU 0xFFF0
117
118 #define RT_GC_TIMEOUT (300*HZ)
119
120 static int ip_rt_max_size;
121 static int ip_rt_redirect_number __read_mostly = 9;
122 static int ip_rt_redirect_load __read_mostly = HZ / 50;
123 static int ip_rt_redirect_silence __read_mostly = ((HZ / 50) << (9 + 1));
124 static int ip_rt_error_cost __read_mostly = HZ;
125 static int ip_rt_error_burst __read_mostly = 5 * HZ;
126 static int ip_rt_mtu_expires __read_mostly = 10 * 60 * HZ;
127 static int ip_rt_min_pmtu __read_mostly = 512 + 20 + 20;
128 static int ip_rt_min_advmss __read_mostly = 256;
129
130 /*
131 * Interface to generic destination cache.
132 */
133
134 static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie);
135 static unsigned int ipv4_default_advmss(const struct dst_entry *dst);
136 static unsigned int ipv4_mtu(const struct dst_entry *dst);
137 static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst);
138 static void ipv4_link_failure(struct sk_buff *skb);
139 static void ip_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
140 struct sk_buff *skb, u32 mtu);
141 static void ip_do_redirect(struct dst_entry *dst, struct sock *sk,
142 struct sk_buff *skb);
143 static void ipv4_dst_destroy(struct dst_entry *dst);
144
145 static void ipv4_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
146 int how)
147 {
148 }
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
160 static struct dst_ops ipv4_dst_ops = {
161 .family = AF_INET,
162 .protocol = cpu_to_be16(ETH_P_IP),
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 .ifdown = ipv4_dst_ifdown,
169 .negative_advice = ipv4_negative_advice,
170 .link_failure = ipv4_link_failure,
171 .update_pmtu = ip_rt_update_pmtu,
172 .redirect = ip_do_redirect,
173 .local_out = __ip_local_out,
174 .neigh_lookup = ipv4_neigh_lookup,
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) __this_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 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 st->out_hit,
307 st->out_slow_tot,
308 st->out_slow_mc,
309
310 st->gc_total,
311 st->gc_ignored,
312 st->gc_goal_miss,
313 st->gc_dst_overflow,
314 st->in_hlist_search,
315 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(dev_net(rth->dst.dev));
440 }
441
442 void rt_cache_flush(struct net *net)
443 {
444 rt_genid_bump(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 #define IP_IDENTS_SZ 2048u
469 struct ip_ident_bucket {
470 atomic_t id;
471 u32 stamp32;
472 };
473
474 static struct ip_ident_bucket *ip_idents __read_mostly;
475
476 /* In order to protect privacy, we add a perturbation to identifiers
477 * if one generator is seldom used. This makes hard for an attacker
478 * to infer how many packets were sent between two points in time.
479 */
480 u32 ip_idents_reserve(u32 hash, int segs)
481 {
482 struct ip_ident_bucket *bucket = ip_idents + hash % IP_IDENTS_SZ;
483 u32 old = ACCESS_ONCE(bucket->stamp32);
484 u32 now = (u32)jiffies;
485 u32 delta = 0;
486
487 if (old != now && cmpxchg(&bucket->stamp32, old, now) == old) {
488 u64 x = prandom_u32();
489
490 x *= (now - old);
491 delta = (u32)(x >> 32);
492 }
493
494 return atomic_add_return(segs + delta, &bucket->id) - segs;
495 }
496 EXPORT_SYMBOL(ip_idents_reserve);
497
498 void __ip_select_ident(struct iphdr *iph, int segs)
499 {
500 static u32 ip_idents_hashrnd __read_mostly;
501 static bool hashrnd_initialized = false;
502 u32 hash, id;
503
504 if (unlikely(!hashrnd_initialized)) {
505 hashrnd_initialized = true;
506 get_random_bytes(&ip_idents_hashrnd, sizeof(ip_idents_hashrnd));
507 }
508
509 hash = jhash_3words((__force u32)iph->daddr,
510 (__force u32)iph->saddr,
511 iph->protocol,
512 ip_idents_hashrnd);
513 id = ip_idents_reserve(hash, segs);
514 iph->id = htons(id);
515 }
516 EXPORT_SYMBOL(__ip_select_ident);
517
518 static void __build_flow_key(struct flowi4 *fl4, struct sock *sk,
519 const struct iphdr *iph,
520 int oif, u8 tos,
521 u8 prot, u32 mark, int flow_flags)
522 {
523 if (sk) {
524 const struct inet_sock *inet = inet_sk(sk);
525
526 oif = sk->sk_bound_dev_if;
527 mark = sk->sk_mark;
528 tos = RT_CONN_FLAGS(sk);
529 prot = inet->hdrincl ? IPPROTO_RAW : sk->sk_protocol;
530 }
531 flowi4_init_output(fl4, oif, mark, tos,
532 RT_SCOPE_UNIVERSE, prot,
533 flow_flags,
534 iph->daddr, iph->saddr, 0, 0,
535 sk ? sock_i_uid(sk) : 0);
536 }
537
538 static void build_skb_flow_key(struct flowi4 *fl4, const struct sk_buff *skb,
539 struct sock *sk)
540 {
541 const struct iphdr *iph = ip_hdr(skb);
542 int oif = skb->dev->ifindex;
543 u8 tos = RT_TOS(iph->tos);
544 u8 prot = iph->protocol;
545 u32 mark = skb->mark;
546
547 __build_flow_key(fl4, sk, iph, oif, tos, prot, mark, 0);
548 }
549
550 static void build_sk_flow_key(struct flowi4 *fl4, struct sock *sk)
551 {
552 const struct inet_sock *inet = inet_sk(sk);
553 const struct ip_options_rcu *inet_opt;
554 __be32 daddr = inet->inet_daddr;
555
556 rcu_read_lock();
557 inet_opt = rcu_dereference(inet->inet_opt);
558 if (inet_opt && inet_opt->opt.srr)
559 daddr = inet_opt->opt.faddr;
560 flowi4_init_output(fl4, sk->sk_bound_dev_if, sk->sk_mark,
561 RT_CONN_FLAGS(sk), RT_SCOPE_UNIVERSE,
562 inet->hdrincl ? IPPROTO_RAW : sk->sk_protocol,
563 inet_sk_flowi_flags(sk),
564 daddr, inet->inet_saddr, 0, 0,
565 sock_i_uid(sk));
566 rcu_read_unlock();
567 }
568
569 static void ip_rt_build_flow_key(struct flowi4 *fl4, struct sock *sk,
570 const struct sk_buff *skb)
571 {
572 if (skb)
573 build_skb_flow_key(fl4, skb, sk);
574 else
575 build_sk_flow_key(fl4, sk);
576 }
577
578 static inline void rt_free(struct rtable *rt)
579 {
580 call_rcu(&rt->dst.rcu_head, dst_rcu_free);
581 }
582
583 static DEFINE_SPINLOCK(fnhe_lock);
584
585 static struct fib_nh_exception *fnhe_oldest(struct fnhe_hash_bucket *hash)
586 {
587 struct fib_nh_exception *fnhe, *oldest;
588 struct rtable *orig;
589
590 oldest = rcu_dereference(hash->chain);
591 for (fnhe = rcu_dereference(oldest->fnhe_next); fnhe;
592 fnhe = rcu_dereference(fnhe->fnhe_next)) {
593 if (time_before(fnhe->fnhe_stamp, oldest->fnhe_stamp))
594 oldest = fnhe;
595 }
596 orig = rcu_dereference(oldest->fnhe_rth);
597 if (orig) {
598 RCU_INIT_POINTER(oldest->fnhe_rth, NULL);
599 rt_free(orig);
600 }
601 return oldest;
602 }
603
604 static inline u32 fnhe_hashfun(__be32 daddr)
605 {
606 u32 hval;
607
608 hval = (__force u32) daddr;
609 hval ^= (hval >> 11) ^ (hval >> 22);
610
611 return hval & (FNHE_HASH_SIZE - 1);
612 }
613
614 static void update_or_create_fnhe(struct fib_nh *nh, __be32 daddr, __be32 gw,
615 u32 pmtu, unsigned long expires)
616 {
617 struct fnhe_hash_bucket *hash;
618 struct fib_nh_exception *fnhe;
619 int depth;
620 u32 hval = fnhe_hashfun(daddr);
621
622 spin_lock_bh(&fnhe_lock);
623
624 hash = nh->nh_exceptions;
625 if (!hash) {
626 hash = kzalloc(FNHE_HASH_SIZE * sizeof(*hash), GFP_ATOMIC);
627 if (!hash)
628 goto out_unlock;
629 nh->nh_exceptions = hash;
630 }
631
632 hash += hval;
633
634 depth = 0;
635 for (fnhe = rcu_dereference(hash->chain); fnhe;
636 fnhe = rcu_dereference(fnhe->fnhe_next)) {
637 if (fnhe->fnhe_daddr == daddr)
638 break;
639 depth++;
640 }
641
642 if (fnhe) {
643 if (gw)
644 fnhe->fnhe_gw = gw;
645 if (pmtu) {
646 fnhe->fnhe_pmtu = pmtu;
647 fnhe->fnhe_expires = expires;
648 }
649 } else {
650 if (depth > FNHE_RECLAIM_DEPTH)
651 fnhe = fnhe_oldest(hash);
652 else {
653 fnhe = kzalloc(sizeof(*fnhe), GFP_ATOMIC);
654 if (!fnhe)
655 goto out_unlock;
656
657 fnhe->fnhe_next = hash->chain;
658 rcu_assign_pointer(hash->chain, fnhe);
659 }
660 fnhe->fnhe_daddr = daddr;
661 fnhe->fnhe_gw = gw;
662 fnhe->fnhe_pmtu = pmtu;
663 fnhe->fnhe_expires = expires;
664 }
665
666 fnhe->fnhe_stamp = jiffies;
667
668 out_unlock:
669 spin_unlock_bh(&fnhe_lock);
670 return;
671 }
672
673 static void __ip_do_redirect(struct rtable *rt, struct sk_buff *skb, struct flowi4 *fl4,
674 bool kill_route)
675 {
676 __be32 new_gw = icmp_hdr(skb)->un.gateway;
677 __be32 old_gw = ip_hdr(skb)->saddr;
678 struct net_device *dev = skb->dev;
679 struct in_device *in_dev;
680 struct fib_result res;
681 struct neighbour *n;
682 struct net *net;
683
684 switch (icmp_hdr(skb)->code & 7) {
685 case ICMP_REDIR_NET:
686 case ICMP_REDIR_NETTOS:
687 case ICMP_REDIR_HOST:
688 case ICMP_REDIR_HOSTTOS:
689 break;
690
691 default:
692 return;
693 }
694
695 if (rt->rt_gateway != old_gw)
696 return;
697
698 in_dev = __in_dev_get_rcu(dev);
699 if (!in_dev)
700 return;
701
702 net = dev_net(dev);
703 if (new_gw == old_gw || !IN_DEV_RX_REDIRECTS(in_dev) ||
704 ipv4_is_multicast(new_gw) || ipv4_is_lbcast(new_gw) ||
705 ipv4_is_zeronet(new_gw))
706 goto reject_redirect;
707
708 if (!IN_DEV_SHARED_MEDIA(in_dev)) {
709 if (!inet_addr_onlink(in_dev, new_gw, old_gw))
710 goto reject_redirect;
711 if (IN_DEV_SEC_REDIRECTS(in_dev) && ip_fib_check_default(new_gw, dev))
712 goto reject_redirect;
713 } else {
714 if (inet_addr_type(net, new_gw) != RTN_UNICAST)
715 goto reject_redirect;
716 }
717
718 n = __ipv4_neigh_lookup(rt->dst.dev, new_gw);
719 if (!n)
720 n = neigh_create(&arp_tbl, &new_gw, rt->dst.dev);
721 if (!IS_ERR(n)) {
722 if (!(n->nud_state & NUD_VALID)) {
723 neigh_event_send(n, NULL);
724 } else {
725 if (fib_lookup(net, fl4, &res) == 0) {
726 struct fib_nh *nh = &FIB_RES_NH(res);
727
728 update_or_create_fnhe(nh, fl4->daddr, new_gw,
729 0, 0);
730 }
731 if (kill_route)
732 rt->dst.obsolete = DST_OBSOLETE_KILL;
733 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, n);
734 }
735 neigh_release(n);
736 }
737 return;
738
739 reject_redirect:
740 #ifdef CONFIG_IP_ROUTE_VERBOSE
741 if (IN_DEV_LOG_MARTIANS(in_dev)) {
742 const struct iphdr *iph = (const struct iphdr *) skb->data;
743 __be32 daddr = iph->daddr;
744 __be32 saddr = iph->saddr;
745
746 net_info_ratelimited("Redirect from %pI4 on %s about %pI4 ignored\n"
747 " Advised path = %pI4 -> %pI4\n",
748 &old_gw, dev->name, &new_gw,
749 &saddr, &daddr);
750 }
751 #endif
752 ;
753 }
754
755 static void ip_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
756 {
757 struct rtable *rt;
758 struct flowi4 fl4;
759 const struct iphdr *iph = (const struct iphdr *) skb->data;
760 int oif = skb->dev->ifindex;
761 u8 tos = RT_TOS(iph->tos);
762 u8 prot = iph->protocol;
763 u32 mark = skb->mark;
764
765 rt = (struct rtable *) dst;
766
767 __build_flow_key(&fl4, sk, iph, oif, tos, prot, mark, 0);
768 __ip_do_redirect(rt, skb, &fl4, true);
769 }
770
771 static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst)
772 {
773 struct rtable *rt = (struct rtable *)dst;
774 struct dst_entry *ret = dst;
775
776 if (rt) {
777 if (dst->obsolete > 0) {
778 ip_rt_put(rt);
779 ret = NULL;
780 } else if ((rt->rt_flags & RTCF_REDIRECTED) ||
781 rt->dst.expires) {
782 ip_rt_put(rt);
783 ret = NULL;
784 }
785 }
786 return ret;
787 }
788
789 /*
790 * Algorithm:
791 * 1. The first ip_rt_redirect_number redirects are sent
792 * with exponential backoff, then we stop sending them at all,
793 * assuming that the host ignores our redirects.
794 * 2. If we did not see packets requiring redirects
795 * during ip_rt_redirect_silence, we assume that the host
796 * forgot redirected route and start to send redirects again.
797 *
798 * This algorithm is much cheaper and more intelligent than dumb load limiting
799 * in icmp.c.
800 *
801 * NOTE. Do not forget to inhibit load limiting for redirects (redundant)
802 * and "frag. need" (breaks PMTU discovery) in icmp.c.
803 */
804
805 void ip_rt_send_redirect(struct sk_buff *skb)
806 {
807 struct rtable *rt = skb_rtable(skb);
808 struct in_device *in_dev;
809 struct inet_peer *peer;
810 struct net *net;
811 int log_martians;
812
813 rcu_read_lock();
814 in_dev = __in_dev_get_rcu(rt->dst.dev);
815 if (!in_dev || !IN_DEV_TX_REDIRECTS(in_dev)) {
816 rcu_read_unlock();
817 return;
818 }
819 log_martians = IN_DEV_LOG_MARTIANS(in_dev);
820 rcu_read_unlock();
821
822 net = dev_net(rt->dst.dev);
823 peer = inet_getpeer_v4(net->ipv4.peers, ip_hdr(skb)->saddr, 1);
824 if (!peer) {
825 icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST,
826 rt_nexthop(rt, ip_hdr(skb)->daddr));
827 return;
828 }
829
830 /* No redirected packets during ip_rt_redirect_silence;
831 * reset the algorithm.
832 */
833 if (time_after(jiffies, peer->rate_last + ip_rt_redirect_silence))
834 peer->rate_tokens = 0;
835
836 /* Too many ignored redirects; do not send anything
837 * set dst.rate_last to the last seen redirected packet.
838 */
839 if (peer->rate_tokens >= ip_rt_redirect_number) {
840 peer->rate_last = jiffies;
841 goto out_put_peer;
842 }
843
844 /* Check for load limit; set rate_last to the latest sent
845 * redirect.
846 */
847 if (peer->rate_tokens == 0 ||
848 time_after(jiffies,
849 (peer->rate_last +
850 (ip_rt_redirect_load << peer->rate_tokens)))) {
851 __be32 gw = rt_nexthop(rt, ip_hdr(skb)->daddr);
852
853 icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST, gw);
854 peer->rate_last = jiffies;
855 ++peer->rate_tokens;
856 #ifdef CONFIG_IP_ROUTE_VERBOSE
857 if (log_martians &&
858 peer->rate_tokens == ip_rt_redirect_number)
859 net_warn_ratelimited("host %pI4/if%d ignores redirects for %pI4 to %pI4\n",
860 &ip_hdr(skb)->saddr, inet_iif(skb),
861 &ip_hdr(skb)->daddr, &gw);
862 #endif
863 }
864 out_put_peer:
865 inet_putpeer(peer);
866 }
867
868 static int ip_error(struct sk_buff *skb)
869 {
870 struct in_device *in_dev = __in_dev_get_rcu(skb->dev);
871 struct rtable *rt = skb_rtable(skb);
872 struct inet_peer *peer;
873 unsigned long now;
874 struct net *net;
875 bool send;
876 int code;
877
878 /* IP on this device is disabled. */
879 if (!in_dev)
880 goto out;
881
882 net = dev_net(rt->dst.dev);
883 if (!IN_DEV_FORWARD(in_dev)) {
884 switch (rt->dst.error) {
885 case EHOSTUNREACH:
886 IP_INC_STATS_BH(net, IPSTATS_MIB_INADDRERRORS);
887 break;
888
889 case ENETUNREACH:
890 IP_INC_STATS_BH(net, IPSTATS_MIB_INNOROUTES);
891 break;
892 }
893 goto out;
894 }
895
896 switch (rt->dst.error) {
897 case EINVAL:
898 default:
899 goto out;
900 case EHOSTUNREACH:
901 code = ICMP_HOST_UNREACH;
902 break;
903 case ENETUNREACH:
904 code = ICMP_NET_UNREACH;
905 IP_INC_STATS_BH(net, IPSTATS_MIB_INNOROUTES);
906 break;
907 case EACCES:
908 code = ICMP_PKT_FILTERED;
909 break;
910 }
911
912 peer = inet_getpeer_v4(net->ipv4.peers, ip_hdr(skb)->saddr, 1);
913
914 send = true;
915 if (peer) {
916 now = jiffies;
917 peer->rate_tokens += now - peer->rate_last;
918 if (peer->rate_tokens > ip_rt_error_burst)
919 peer->rate_tokens = ip_rt_error_burst;
920 peer->rate_last = now;
921 if (peer->rate_tokens >= ip_rt_error_cost)
922 peer->rate_tokens -= ip_rt_error_cost;
923 else
924 send = false;
925 inet_putpeer(peer);
926 }
927 if (send)
928 icmp_send(skb, ICMP_DEST_UNREACH, code, 0);
929
930 out: kfree_skb(skb);
931 return 0;
932 }
933
934 static void __ip_rt_update_pmtu(struct rtable *rt, struct flowi4 *fl4, u32 mtu)
935 {
936 struct dst_entry *dst = &rt->dst;
937 struct fib_result res;
938
939 if (dst_metric_locked(dst, RTAX_MTU))
940 return;
941
942 if (dst->dev->mtu < mtu)
943 return;
944
945 if (mtu < ip_rt_min_pmtu)
946 mtu = ip_rt_min_pmtu;
947
948 if (!rt->rt_pmtu) {
949 dst->obsolete = DST_OBSOLETE_KILL;
950 } else {
951 rt->rt_pmtu = mtu;
952 dst->expires = max(1UL, jiffies + ip_rt_mtu_expires);
953 }
954
955 rcu_read_lock();
956 if (fib_lookup(dev_net(dst->dev), fl4, &res) == 0) {
957 struct fib_nh *nh = &FIB_RES_NH(res);
958
959 update_or_create_fnhe(nh, fl4->daddr, 0, mtu,
960 jiffies + ip_rt_mtu_expires);
961 }
962 rcu_read_unlock();
963 }
964
965 static void ip_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
966 struct sk_buff *skb, u32 mtu)
967 {
968 struct rtable *rt = (struct rtable *) dst;
969 struct flowi4 fl4;
970
971 ip_rt_build_flow_key(&fl4, sk, skb);
972 __ip_rt_update_pmtu(rt, &fl4, mtu);
973 }
974
975 void ipv4_update_pmtu(struct sk_buff *skb, struct net *net, u32 mtu,
976 int oif, u32 mark, u8 protocol, int flow_flags)
977 {
978 const struct iphdr *iph = (const struct iphdr *) skb->data;
979 struct flowi4 fl4;
980 struct rtable *rt;
981
982 if (!mark)
983 mark = IP4_REPLY_MARK(net, skb->mark);
984
985 __build_flow_key(&fl4, NULL, iph, oif,
986 RT_TOS(iph->tos), protocol, mark, flow_flags);
987 rt = __ip_route_output_key(net, &fl4);
988 if (!IS_ERR(rt)) {
989 __ip_rt_update_pmtu(rt, &fl4, mtu);
990 ip_rt_put(rt);
991 }
992 }
993 EXPORT_SYMBOL_GPL(ipv4_update_pmtu);
994
995 static void __ipv4_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, u32 mtu)
996 {
997 const struct iphdr *iph = (const struct iphdr *) skb->data;
998 struct flowi4 fl4;
999 struct rtable *rt;
1000
1001 __build_flow_key(&fl4, sk, iph, 0, 0, 0, 0, 0);
1002
1003 if (!fl4.flowi4_mark)
1004 fl4.flowi4_mark = IP4_REPLY_MARK(sock_net(sk), skb->mark);
1005
1006 rt = __ip_route_output_key(sock_net(sk), &fl4);
1007 if (!IS_ERR(rt)) {
1008 __ip_rt_update_pmtu(rt, &fl4, mtu);
1009 ip_rt_put(rt);
1010 }
1011 }
1012
1013 void ipv4_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, u32 mtu)
1014 {
1015 const struct iphdr *iph = (const struct iphdr *) skb->data;
1016 struct flowi4 fl4;
1017 struct rtable *rt;
1018 struct dst_entry *odst = NULL;
1019 bool new = false;
1020
1021 bh_lock_sock(sk);
1022 odst = sk_dst_get(sk);
1023
1024 if (sock_owned_by_user(sk) || !odst) {
1025 __ipv4_sk_update_pmtu(skb, sk, mtu);
1026 goto out;
1027 }
1028
1029 __build_flow_key(&fl4, sk, iph, 0, 0, 0, 0, 0);
1030
1031 rt = (struct rtable *)odst;
1032 if (odst->obsolete && odst->ops->check(odst, 0) == NULL) {
1033 rt = ip_route_output_flow(sock_net(sk), &fl4, sk);
1034 if (IS_ERR(rt))
1035 goto out;
1036
1037 new = true;
1038 }
1039
1040 __ip_rt_update_pmtu((struct rtable *) rt->dst.path, &fl4, mtu);
1041
1042 if (!dst_check(&rt->dst, 0)) {
1043 if (new)
1044 dst_release(&rt->dst);
1045
1046 rt = ip_route_output_flow(sock_net(sk), &fl4, sk);
1047 if (IS_ERR(rt))
1048 goto out;
1049
1050 new = true;
1051 }
1052
1053 if (new)
1054 sk_dst_set(sk, &rt->dst);
1055
1056 out:
1057 bh_unlock_sock(sk);
1058 dst_release(odst);
1059 }
1060 EXPORT_SYMBOL_GPL(ipv4_sk_update_pmtu);
1061
1062 void ipv4_redirect(struct sk_buff *skb, struct net *net,
1063 int oif, u32 mark, u8 protocol, int flow_flags)
1064 {
1065 const struct iphdr *iph = (const struct iphdr *) skb->data;
1066 struct flowi4 fl4;
1067 struct rtable *rt;
1068
1069 __build_flow_key(&fl4, NULL, iph, oif,
1070 RT_TOS(iph->tos), protocol, mark, flow_flags);
1071 rt = __ip_route_output_key(net, &fl4);
1072 if (!IS_ERR(rt)) {
1073 __ip_do_redirect(rt, skb, &fl4, false);
1074 ip_rt_put(rt);
1075 }
1076 }
1077 EXPORT_SYMBOL_GPL(ipv4_redirect);
1078
1079 void ipv4_sk_redirect(struct sk_buff *skb, struct sock *sk)
1080 {
1081 const struct iphdr *iph = (const struct iphdr *) skb->data;
1082 struct flowi4 fl4;
1083 struct rtable *rt;
1084
1085 __build_flow_key(&fl4, sk, iph, 0, 0, 0, 0, 0);
1086 rt = __ip_route_output_key(sock_net(sk), &fl4);
1087 if (!IS_ERR(rt)) {
1088 __ip_do_redirect(rt, skb, &fl4, false);
1089 ip_rt_put(rt);
1090 }
1091 }
1092 EXPORT_SYMBOL_GPL(ipv4_sk_redirect);
1093
1094 static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie)
1095 {
1096 struct rtable *rt = (struct rtable *) dst;
1097
1098 /* All IPV4 dsts are created with ->obsolete set to the value
1099 * DST_OBSOLETE_FORCE_CHK which forces validation calls down
1100 * into this function always.
1101 *
1102 * When a PMTU/redirect information update invalidates a
1103 * route, this is indicated by setting obsolete to
1104 * DST_OBSOLETE_KILL.
1105 */
1106 if (dst->obsolete == DST_OBSOLETE_KILL || rt_is_expired(rt))
1107 return NULL;
1108 return dst;
1109 }
1110
1111 static void ipv4_link_failure(struct sk_buff *skb)
1112 {
1113 struct rtable *rt;
1114
1115 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0);
1116
1117 rt = skb_rtable(skb);
1118 if (rt)
1119 dst_set_expires(&rt->dst, 0);
1120 }
1121
1122 static int ip_rt_bug(struct sk_buff *skb)
1123 {
1124 pr_debug("%s: %pI4 -> %pI4, %s\n",
1125 __func__, &ip_hdr(skb)->saddr, &ip_hdr(skb)->daddr,
1126 skb->dev ? skb->dev->name : "?");
1127 kfree_skb(skb);
1128 WARN_ON(1);
1129 return 0;
1130 }
1131
1132 /*
1133 We do not cache source address of outgoing interface,
1134 because it is used only by IP RR, TS and SRR options,
1135 so that it out of fast path.
1136
1137 BTW remember: "addr" is allowed to be not aligned
1138 in IP options!
1139 */
1140
1141 void ip_rt_get_source(u8 *addr, struct sk_buff *skb, struct rtable *rt)
1142 {
1143 __be32 src;
1144
1145 if (rt_is_output_route(rt))
1146 src = ip_hdr(skb)->saddr;
1147 else {
1148 struct fib_result res;
1149 struct flowi4 fl4;
1150 struct iphdr *iph;
1151
1152 iph = ip_hdr(skb);
1153
1154 memset(&fl4, 0, sizeof(fl4));
1155 fl4.daddr = iph->daddr;
1156 fl4.saddr = iph->saddr;
1157 fl4.flowi4_tos = RT_TOS(iph->tos);
1158 fl4.flowi4_oif = rt->dst.dev->ifindex;
1159 fl4.flowi4_iif = skb->dev->ifindex;
1160 fl4.flowi4_mark = skb->mark;
1161
1162 rcu_read_lock();
1163 if (fib_lookup(dev_net(rt->dst.dev), &fl4, &res) == 0)
1164 src = FIB_RES_PREFSRC(dev_net(rt->dst.dev), res);
1165 else
1166 src = inet_select_addr(rt->dst.dev,
1167 rt_nexthop(rt, iph->daddr),
1168 RT_SCOPE_UNIVERSE);
1169 rcu_read_unlock();
1170 }
1171 memcpy(addr, &src, 4);
1172 }
1173
1174 #ifdef CONFIG_IP_ROUTE_CLASSID
1175 static void set_class_tag(struct rtable *rt, u32 tag)
1176 {
1177 if (!(rt->dst.tclassid & 0xFFFF))
1178 rt->dst.tclassid |= tag & 0xFFFF;
1179 if (!(rt->dst.tclassid & 0xFFFF0000))
1180 rt->dst.tclassid |= tag & 0xFFFF0000;
1181 }
1182 #endif
1183
1184 static unsigned int ipv4_default_advmss(const struct dst_entry *dst)
1185 {
1186 unsigned int advmss = dst_metric_raw(dst, RTAX_ADVMSS);
1187
1188 if (advmss == 0) {
1189 advmss = max_t(unsigned int, dst->dev->mtu - 40,
1190 ip_rt_min_advmss);
1191 if (advmss > 65535 - 40)
1192 advmss = 65535 - 40;
1193 }
1194 return advmss;
1195 }
1196
1197 static unsigned int ipv4_mtu(const struct dst_entry *dst)
1198 {
1199 const struct rtable *rt = (const struct rtable *) dst;
1200 unsigned int mtu = rt->rt_pmtu;
1201
1202 if (!mtu || time_after_eq(jiffies, rt->dst.expires))
1203 mtu = dst_metric_raw(dst, RTAX_MTU);
1204
1205 if (mtu)
1206 return mtu;
1207
1208 mtu = dst->dev->mtu;
1209
1210 if (unlikely(dst_metric_locked(dst, RTAX_MTU))) {
1211 if (rt->rt_uses_gateway && mtu > 576)
1212 mtu = 576;
1213 }
1214
1215 if (mtu > IP_MAX_MTU)
1216 mtu = IP_MAX_MTU;
1217
1218 return mtu;
1219 }
1220
1221 static struct fib_nh_exception *find_exception(struct fib_nh *nh, __be32 daddr)
1222 {
1223 struct fnhe_hash_bucket *hash = nh->nh_exceptions;
1224 struct fib_nh_exception *fnhe;
1225 u32 hval;
1226
1227 if (!hash)
1228 return NULL;
1229
1230 hval = fnhe_hashfun(daddr);
1231
1232 for (fnhe = rcu_dereference(hash[hval].chain); fnhe;
1233 fnhe = rcu_dereference(fnhe->fnhe_next)) {
1234 if (fnhe->fnhe_daddr == daddr)
1235 return fnhe;
1236 }
1237 return NULL;
1238 }
1239
1240 static bool rt_bind_exception(struct rtable *rt, struct fib_nh_exception *fnhe,
1241 __be32 daddr)
1242 {
1243 bool ret = false;
1244
1245 spin_lock_bh(&fnhe_lock);
1246
1247 if (daddr == fnhe->fnhe_daddr) {
1248 struct rtable *orig = rcu_dereference(fnhe->fnhe_rth);
1249 if (orig && rt_is_expired(orig)) {
1250 fnhe->fnhe_gw = 0;
1251 fnhe->fnhe_pmtu = 0;
1252 fnhe->fnhe_expires = 0;
1253 }
1254 if (fnhe->fnhe_pmtu) {
1255 unsigned long expires = fnhe->fnhe_expires;
1256 unsigned long diff = expires - jiffies;
1257
1258 if (time_before(jiffies, expires)) {
1259 rt->rt_pmtu = fnhe->fnhe_pmtu;
1260 dst_set_expires(&rt->dst, diff);
1261 }
1262 }
1263 if (fnhe->fnhe_gw) {
1264 rt->rt_flags |= RTCF_REDIRECTED;
1265 rt->rt_gateway = fnhe->fnhe_gw;
1266 rt->rt_uses_gateway = 1;
1267 } else if (!rt->rt_gateway)
1268 rt->rt_gateway = daddr;
1269
1270 rcu_assign_pointer(fnhe->fnhe_rth, rt);
1271 if (orig)
1272 rt_free(orig);
1273
1274 fnhe->fnhe_stamp = jiffies;
1275 ret = true;
1276 }
1277 spin_unlock_bh(&fnhe_lock);
1278
1279 return ret;
1280 }
1281
1282 static bool rt_cache_route(struct fib_nh *nh, struct rtable *rt)
1283 {
1284 struct rtable *orig, *prev, **p;
1285 bool ret = true;
1286
1287 if (rt_is_input_route(rt)) {
1288 p = (struct rtable **)&nh->nh_rth_input;
1289 } else {
1290 p = (struct rtable **)__this_cpu_ptr(nh->nh_pcpu_rth_output);
1291 }
1292 orig = *p;
1293
1294 prev = cmpxchg(p, orig, rt);
1295 if (prev == orig) {
1296 if (orig)
1297 rt_free(orig);
1298 } else
1299 ret = false;
1300
1301 return ret;
1302 }
1303
1304 static DEFINE_SPINLOCK(rt_uncached_lock);
1305 static LIST_HEAD(rt_uncached_list);
1306
1307 static void rt_add_uncached_list(struct rtable *rt)
1308 {
1309 spin_lock_bh(&rt_uncached_lock);
1310 list_add_tail(&rt->rt_uncached, &rt_uncached_list);
1311 spin_unlock_bh(&rt_uncached_lock);
1312 }
1313
1314 static void ipv4_dst_destroy(struct dst_entry *dst)
1315 {
1316 struct rtable *rt = (struct rtable *) dst;
1317
1318 if (!list_empty(&rt->rt_uncached)) {
1319 spin_lock_bh(&rt_uncached_lock);
1320 list_del(&rt->rt_uncached);
1321 spin_unlock_bh(&rt_uncached_lock);
1322 }
1323 }
1324
1325 void rt_flush_dev(struct net_device *dev)
1326 {
1327 if (!list_empty(&rt_uncached_list)) {
1328 struct net *net = dev_net(dev);
1329 struct rtable *rt;
1330
1331 spin_lock_bh(&rt_uncached_lock);
1332 list_for_each_entry(rt, &rt_uncached_list, rt_uncached) {
1333 if (rt->dst.dev != dev)
1334 continue;
1335 rt->dst.dev = net->loopback_dev;
1336 dev_hold(rt->dst.dev);
1337 dev_put(dev);
1338 }
1339 spin_unlock_bh(&rt_uncached_lock);
1340 }
1341 }
1342
1343 static bool rt_cache_valid(const struct rtable *rt)
1344 {
1345 return rt &&
1346 rt->dst.obsolete == DST_OBSOLETE_FORCE_CHK &&
1347 !rt_is_expired(rt);
1348 }
1349
1350 static void rt_set_nexthop(struct rtable *rt, __be32 daddr,
1351 const struct fib_result *res,
1352 struct fib_nh_exception *fnhe,
1353 struct fib_info *fi, u16 type, u32 itag)
1354 {
1355 bool cached = false;
1356
1357 if (fi) {
1358 struct fib_nh *nh = &FIB_RES_NH(*res);
1359
1360 if (nh->nh_gw && nh->nh_scope == RT_SCOPE_LINK) {
1361 rt->rt_gateway = nh->nh_gw;
1362 rt->rt_uses_gateway = 1;
1363 }
1364 dst_init_metrics(&rt->dst, fi->fib_metrics, true);
1365 #ifdef CONFIG_IP_ROUTE_CLASSID
1366 rt->dst.tclassid = nh->nh_tclassid;
1367 #endif
1368 if (unlikely(fnhe))
1369 cached = rt_bind_exception(rt, fnhe, daddr);
1370 else if (!(rt->dst.flags & DST_NOCACHE))
1371 cached = rt_cache_route(nh, rt);
1372 if (unlikely(!cached)) {
1373 /* Routes we intend to cache in nexthop exception or
1374 * FIB nexthop have the DST_NOCACHE bit clear.
1375 * However, if we are unsuccessful at storing this
1376 * route into the cache we really need to set it.
1377 */
1378 rt->dst.flags |= DST_NOCACHE;
1379 if (!rt->rt_gateway)
1380 rt->rt_gateway = daddr;
1381 rt_add_uncached_list(rt);
1382 }
1383 } else
1384 rt_add_uncached_list(rt);
1385
1386 #ifdef CONFIG_IP_ROUTE_CLASSID
1387 #ifdef CONFIG_IP_MULTIPLE_TABLES
1388 set_class_tag(rt, res->tclassid);
1389 #endif
1390 set_class_tag(rt, itag);
1391 #endif
1392 }
1393
1394 static struct rtable *rt_dst_alloc(struct net_device *dev,
1395 bool nopolicy, bool noxfrm, bool will_cache)
1396 {
1397 return dst_alloc(&ipv4_dst_ops, dev, 1, DST_OBSOLETE_FORCE_CHK,
1398 (will_cache ? 0 : (DST_HOST | DST_NOCACHE)) |
1399 (nopolicy ? DST_NOPOLICY : 0) |
1400 (noxfrm ? DST_NOXFRM : 0));
1401 }
1402
1403 /* called in rcu_read_lock() section */
1404 static int ip_route_input_mc(struct sk_buff *skb, __be32 daddr, __be32 saddr,
1405 u8 tos, struct net_device *dev, int our)
1406 {
1407 struct rtable *rth;
1408 struct in_device *in_dev = __in_dev_get_rcu(dev);
1409 u32 itag = 0;
1410 int err;
1411
1412 /* Primary sanity checks. */
1413
1414 if (in_dev == NULL)
1415 return -EINVAL;
1416
1417 if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr) ||
1418 skb->protocol != htons(ETH_P_IP))
1419 goto e_inval;
1420
1421 if (likely(!IN_DEV_ROUTE_LOCALNET(in_dev)))
1422 if (ipv4_is_loopback(saddr))
1423 goto e_inval;
1424
1425 if (ipv4_is_zeronet(saddr)) {
1426 if (!ipv4_is_local_multicast(daddr))
1427 goto e_inval;
1428 } else {
1429 err = fib_validate_source(skb, saddr, 0, tos, 0, dev,
1430 in_dev, &itag);
1431 if (err < 0)
1432 goto e_err;
1433 }
1434 rth = rt_dst_alloc(dev_net(dev)->loopback_dev,
1435 IN_DEV_CONF_GET(in_dev, NOPOLICY), false, false);
1436 if (!rth)
1437 goto e_nobufs;
1438
1439 #ifdef CONFIG_IP_ROUTE_CLASSID
1440 rth->dst.tclassid = itag;
1441 #endif
1442 rth->dst.output = ip_rt_bug;
1443
1444 rth->rt_genid = rt_genid(dev_net(dev));
1445 rth->rt_flags = RTCF_MULTICAST;
1446 rth->rt_type = RTN_MULTICAST;
1447 rth->rt_is_input= 1;
1448 rth->rt_iif = 0;
1449 rth->rt_pmtu = 0;
1450 rth->rt_gateway = 0;
1451 rth->rt_uses_gateway = 0;
1452 INIT_LIST_HEAD(&rth->rt_uncached);
1453 if (our) {
1454 rth->dst.input= ip_local_deliver;
1455 rth->rt_flags |= RTCF_LOCAL;
1456 }
1457
1458 #ifdef CONFIG_IP_MROUTE
1459 if (!ipv4_is_local_multicast(daddr) && IN_DEV_MFORWARD(in_dev))
1460 rth->dst.input = ip_mr_input;
1461 #endif
1462 RT_CACHE_STAT_INC(in_slow_mc);
1463
1464 skb_dst_set(skb, &rth->dst);
1465 return 0;
1466
1467 e_nobufs:
1468 return -ENOBUFS;
1469 e_inval:
1470 return -EINVAL;
1471 e_err:
1472 return err;
1473 }
1474
1475
1476 static void ip_handle_martian_source(struct net_device *dev,
1477 struct in_device *in_dev,
1478 struct sk_buff *skb,
1479 __be32 daddr,
1480 __be32 saddr)
1481 {
1482 RT_CACHE_STAT_INC(in_martian_src);
1483 #ifdef CONFIG_IP_ROUTE_VERBOSE
1484 if (IN_DEV_LOG_MARTIANS(in_dev) && net_ratelimit()) {
1485 /*
1486 * RFC1812 recommendation, if source is martian,
1487 * the only hint is MAC header.
1488 */
1489 pr_warn("martian source %pI4 from %pI4, on dev %s\n",
1490 &daddr, &saddr, dev->name);
1491 if (dev->hard_header_len && skb_mac_header_was_set(skb)) {
1492 print_hex_dump(KERN_WARNING, "ll header: ",
1493 DUMP_PREFIX_OFFSET, 16, 1,
1494 skb_mac_header(skb),
1495 dev->hard_header_len, true);
1496 }
1497 }
1498 #endif
1499 }
1500
1501 /* called in rcu_read_lock() section */
1502 static int __mkroute_input(struct sk_buff *skb,
1503 const struct fib_result *res,
1504 struct in_device *in_dev,
1505 __be32 daddr, __be32 saddr, u32 tos)
1506 {
1507 struct rtable *rth;
1508 int err;
1509 struct in_device *out_dev;
1510 unsigned int flags = 0;
1511 bool do_cache;
1512 u32 itag = 0;
1513
1514 /* get a working reference to the output device */
1515 out_dev = __in_dev_get_rcu(FIB_RES_DEV(*res));
1516 if (out_dev == NULL) {
1517 net_crit_ratelimited("Bug in ip_route_input_slow(). Please report.\n");
1518 return -EINVAL;
1519 }
1520
1521 err = fib_validate_source(skb, saddr, daddr, tos, FIB_RES_OIF(*res),
1522 in_dev->dev, in_dev, &itag);
1523 if (err < 0) {
1524 ip_handle_martian_source(in_dev->dev, in_dev, skb, daddr,
1525 saddr);
1526
1527 goto cleanup;
1528 }
1529
1530 do_cache = res->fi && !itag;
1531 if (out_dev == in_dev && err && IN_DEV_TX_REDIRECTS(out_dev) &&
1532 skb->protocol == htons(ETH_P_IP) &&
1533 (IN_DEV_SHARED_MEDIA(out_dev) ||
1534 inet_addr_onlink(out_dev, saddr, FIB_RES_GW(*res))))
1535 IPCB(skb)->flags |= IPSKB_DOREDIRECT;
1536
1537 if (skb->protocol != htons(ETH_P_IP)) {
1538 /* Not IP (i.e. ARP). Do not create route, if it is
1539 * invalid for proxy arp. DNAT routes are always valid.
1540 *
1541 * Proxy arp feature have been extended to allow, ARP
1542 * replies back to the same interface, to support
1543 * Private VLAN switch technologies. See arp.c.
1544 */
1545 if (out_dev == in_dev &&
1546 IN_DEV_PROXY_ARP_PVLAN(in_dev) == 0) {
1547 err = -EINVAL;
1548 goto cleanup;
1549 }
1550 }
1551
1552 if (do_cache) {
1553 rth = rcu_dereference(FIB_RES_NH(*res).nh_rth_input);
1554 if (rt_cache_valid(rth)) {
1555 skb_dst_set_noref(skb, &rth->dst);
1556 goto out;
1557 }
1558 }
1559
1560 rth = rt_dst_alloc(out_dev->dev,
1561 IN_DEV_CONF_GET(in_dev, NOPOLICY),
1562 IN_DEV_CONF_GET(out_dev, NOXFRM), do_cache);
1563 if (!rth) {
1564 err = -ENOBUFS;
1565 goto cleanup;
1566 }
1567
1568 rth->rt_genid = rt_genid(dev_net(rth->dst.dev));
1569 rth->rt_flags = flags;
1570 rth->rt_type = res->type;
1571 rth->rt_is_input = 1;
1572 rth->rt_iif = 0;
1573 rth->rt_pmtu = 0;
1574 rth->rt_gateway = 0;
1575 rth->rt_uses_gateway = 0;
1576 INIT_LIST_HEAD(&rth->rt_uncached);
1577 RT_CACHE_STAT_INC(in_slow_tot);
1578
1579 rth->dst.input = ip_forward;
1580 rth->dst.output = ip_output;
1581
1582 rt_set_nexthop(rth, daddr, res, NULL, res->fi, res->type, itag);
1583 skb_dst_set(skb, &rth->dst);
1584 out:
1585 err = 0;
1586 cleanup:
1587 return err;
1588 }
1589
1590 static int ip_mkroute_input(struct sk_buff *skb,
1591 struct fib_result *res,
1592 const struct flowi4 *fl4,
1593 struct in_device *in_dev,
1594 __be32 daddr, __be32 saddr, u32 tos)
1595 {
1596 #ifdef CONFIG_IP_ROUTE_MULTIPATH
1597 if (res->fi && res->fi->fib_nhs > 1)
1598 fib_select_multipath(res);
1599 #endif
1600
1601 /* create a routing cache entry */
1602 return __mkroute_input(skb, res, in_dev, daddr, saddr, tos);
1603 }
1604
1605 /*
1606 * NOTE. We drop all the packets that has local source
1607 * addresses, because every properly looped back packet
1608 * must have correct destination already attached by output routine.
1609 *
1610 * Such approach solves two big problems:
1611 * 1. Not simplex devices are handled properly.
1612 * 2. IP spoofing attempts are filtered with 100% of guarantee.
1613 * called with rcu_read_lock()
1614 */
1615
1616 static int ip_route_input_slow(struct sk_buff *skb, __be32 daddr, __be32 saddr,
1617 u8 tos, struct net_device *dev)
1618 {
1619 struct fib_result res;
1620 struct in_device *in_dev = __in_dev_get_rcu(dev);
1621 struct flowi4 fl4;
1622 unsigned int flags = 0;
1623 u32 itag = 0;
1624 struct rtable *rth;
1625 int err = -EINVAL;
1626 struct net *net = dev_net(dev);
1627 bool do_cache;
1628
1629 /* IP on this device is disabled. */
1630
1631 if (!in_dev)
1632 goto out;
1633
1634 /* Check for the most weird martians, which can be not detected
1635 by fib_lookup.
1636 */
1637
1638 if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr))
1639 goto martian_source;
1640
1641 res.fi = NULL;
1642 if (ipv4_is_lbcast(daddr) || (saddr == 0 && daddr == 0))
1643 goto brd_input;
1644
1645 /* Accept zero addresses only to limited broadcast;
1646 * I even do not know to fix it or not. Waiting for complains :-)
1647 */
1648 if (ipv4_is_zeronet(saddr))
1649 goto martian_source;
1650
1651 if (ipv4_is_zeronet(daddr))
1652 goto martian_destination;
1653
1654 /* Following code try to avoid calling IN_DEV_NET_ROUTE_LOCALNET(),
1655 * and call it once if daddr or/and saddr are loopback addresses
1656 */
1657 if (ipv4_is_loopback(daddr)) {
1658 if (!IN_DEV_NET_ROUTE_LOCALNET(in_dev, net))
1659 goto martian_destination;
1660 } else if (ipv4_is_loopback(saddr)) {
1661 if (!IN_DEV_NET_ROUTE_LOCALNET(in_dev, net))
1662 goto martian_source;
1663 }
1664
1665 /*
1666 * Now we are ready to route packet.
1667 */
1668 fl4.flowi4_oif = 0;
1669 fl4.flowi4_iif = dev->ifindex;
1670 fl4.flowi4_mark = skb->mark;
1671 fl4.flowi4_tos = tos;
1672 fl4.flowi4_scope = RT_SCOPE_UNIVERSE;
1673 fl4.daddr = daddr;
1674 fl4.saddr = saddr;
1675 err = fib_lookup(net, &fl4, &res);
1676 if (err != 0)
1677 goto no_route;
1678
1679 if (res.type == RTN_BROADCAST)
1680 goto brd_input;
1681
1682 if (res.type == RTN_LOCAL) {
1683 err = fib_validate_source(skb, saddr, daddr, tos,
1684 LOOPBACK_IFINDEX,
1685 dev, in_dev, &itag);
1686 if (err < 0)
1687 goto martian_source_keep_err;
1688 goto local_input;
1689 }
1690
1691 if (!IN_DEV_FORWARD(in_dev))
1692 goto no_route;
1693 if (res.type != RTN_UNICAST)
1694 goto martian_destination;
1695
1696 err = ip_mkroute_input(skb, &res, &fl4, in_dev, daddr, saddr, tos);
1697 out: return err;
1698
1699 brd_input:
1700 if (skb->protocol != htons(ETH_P_IP))
1701 goto e_inval;
1702
1703 if (!ipv4_is_zeronet(saddr)) {
1704 err = fib_validate_source(skb, saddr, 0, tos, 0, dev,
1705 in_dev, &itag);
1706 if (err < 0)
1707 goto martian_source_keep_err;
1708 }
1709 flags |= RTCF_BROADCAST;
1710 res.type = RTN_BROADCAST;
1711 RT_CACHE_STAT_INC(in_brd);
1712
1713 local_input:
1714 do_cache = false;
1715 if (res.fi) {
1716 if (!itag) {
1717 rth = rcu_dereference(FIB_RES_NH(res).nh_rth_input);
1718 if (rt_cache_valid(rth)) {
1719 skb_dst_set_noref(skb, &rth->dst);
1720 err = 0;
1721 goto out;
1722 }
1723 do_cache = true;
1724 }
1725 }
1726
1727 rth = rt_dst_alloc(net->loopback_dev,
1728 IN_DEV_CONF_GET(in_dev, NOPOLICY), false, do_cache);
1729 if (!rth)
1730 goto e_nobufs;
1731
1732 rth->dst.input= ip_local_deliver;
1733 rth->dst.output= ip_rt_bug;
1734 #ifdef CONFIG_IP_ROUTE_CLASSID
1735 rth->dst.tclassid = itag;
1736 #endif
1737
1738 rth->rt_genid = rt_genid(net);
1739 rth->rt_flags = flags|RTCF_LOCAL;
1740 rth->rt_type = res.type;
1741 rth->rt_is_input = 1;
1742 rth->rt_iif = 0;
1743 rth->rt_pmtu = 0;
1744 rth->rt_gateway = 0;
1745 rth->rt_uses_gateway = 0;
1746 INIT_LIST_HEAD(&rth->rt_uncached);
1747 RT_CACHE_STAT_INC(in_slow_tot);
1748 if (res.type == RTN_UNREACHABLE) {
1749 rth->dst.input= ip_error;
1750 rth->dst.error= -err;
1751 rth->rt_flags &= ~RTCF_LOCAL;
1752 }
1753 if (do_cache) {
1754 if (unlikely(!rt_cache_route(&FIB_RES_NH(res), rth))) {
1755 rth->dst.flags |= DST_NOCACHE;
1756 rt_add_uncached_list(rth);
1757 }
1758 }
1759 skb_dst_set(skb, &rth->dst);
1760 err = 0;
1761 goto out;
1762
1763 no_route:
1764 RT_CACHE_STAT_INC(in_no_route);
1765 res.type = RTN_UNREACHABLE;
1766 if (err == -ESRCH)
1767 err = -ENETUNREACH;
1768 goto local_input;
1769
1770 /*
1771 * Do not cache martian addresses: they should be logged (RFC1812)
1772 */
1773 martian_destination:
1774 RT_CACHE_STAT_INC(in_martian_dst);
1775 #ifdef CONFIG_IP_ROUTE_VERBOSE
1776 if (IN_DEV_LOG_MARTIANS(in_dev))
1777 net_warn_ratelimited("martian destination %pI4 from %pI4, dev %s\n",
1778 &daddr, &saddr, dev->name);
1779 #endif
1780
1781 e_inval:
1782 err = -EINVAL;
1783 goto out;
1784
1785 e_nobufs:
1786 err = -ENOBUFS;
1787 goto out;
1788
1789 martian_source:
1790 err = -EINVAL;
1791 martian_source_keep_err:
1792 ip_handle_martian_source(dev, in_dev, skb, daddr, saddr);
1793 goto out;
1794 }
1795
1796 int ip_route_input_noref(struct sk_buff *skb, __be32 daddr, __be32 saddr,
1797 u8 tos, struct net_device *dev)
1798 {
1799 int res;
1800
1801 rcu_read_lock();
1802
1803 /* Multicast recognition logic is moved from route cache to here.
1804 The problem was that too many Ethernet cards have broken/missing
1805 hardware multicast filters :-( As result the host on multicasting
1806 network acquires a lot of useless route cache entries, sort of
1807 SDR messages from all the world. Now we try to get rid of them.
1808 Really, provided software IP multicast filter is organized
1809 reasonably (at least, hashed), it does not result in a slowdown
1810 comparing with route cache reject entries.
1811 Note, that multicast routers are not affected, because
1812 route cache entry is created eventually.
1813 */
1814 if (ipv4_is_multicast(daddr)) {
1815 struct in_device *in_dev = __in_dev_get_rcu(dev);
1816
1817 if (in_dev) {
1818 int our = ip_check_mc_rcu(in_dev, daddr, saddr,
1819 ip_hdr(skb)->protocol);
1820 if (our
1821 #ifdef CONFIG_IP_MROUTE
1822 ||
1823 (!ipv4_is_local_multicast(daddr) &&
1824 IN_DEV_MFORWARD(in_dev))
1825 #endif
1826 ) {
1827 int res = ip_route_input_mc(skb, daddr, saddr,
1828 tos, dev, our);
1829 rcu_read_unlock();
1830 return res;
1831 }
1832 }
1833 rcu_read_unlock();
1834 return -EINVAL;
1835 }
1836 res = ip_route_input_slow(skb, daddr, saddr, tos, dev);
1837 rcu_read_unlock();
1838 return res;
1839 }
1840 EXPORT_SYMBOL(ip_route_input_noref);
1841
1842 /* called with rcu_read_lock() */
1843 static struct rtable *__mkroute_output(const struct fib_result *res,
1844 const struct flowi4 *fl4, int orig_oif,
1845 struct net_device *dev_out,
1846 unsigned int flags)
1847 {
1848 struct fib_info *fi = res->fi;
1849 struct fib_nh_exception *fnhe;
1850 struct in_device *in_dev;
1851 u16 type = res->type;
1852 struct rtable *rth;
1853 bool do_cache;
1854
1855 in_dev = __in_dev_get_rcu(dev_out);
1856 if (!in_dev)
1857 return ERR_PTR(-EINVAL);
1858
1859 if (likely(!IN_DEV_ROUTE_LOCALNET(in_dev)))
1860 if (ipv4_is_loopback(fl4->saddr) && !(dev_out->flags & IFF_LOOPBACK))
1861 return ERR_PTR(-EINVAL);
1862
1863 if (ipv4_is_lbcast(fl4->daddr))
1864 type = RTN_BROADCAST;
1865 else if (ipv4_is_multicast(fl4->daddr))
1866 type = RTN_MULTICAST;
1867 else if (ipv4_is_zeronet(fl4->daddr))
1868 return ERR_PTR(-EINVAL);
1869
1870 if (dev_out->flags & IFF_LOOPBACK)
1871 flags |= RTCF_LOCAL;
1872
1873 do_cache = true;
1874 if (type == RTN_BROADCAST) {
1875 flags |= RTCF_BROADCAST | RTCF_LOCAL;
1876 fi = NULL;
1877 } else if (type == RTN_MULTICAST) {
1878 flags |= RTCF_MULTICAST | RTCF_LOCAL;
1879 if (!ip_check_mc_rcu(in_dev, fl4->daddr, fl4->saddr,
1880 fl4->flowi4_proto))
1881 flags &= ~RTCF_LOCAL;
1882 else
1883 do_cache = false;
1884 /* If multicast route do not exist use
1885 * default one, but do not gateway in this case.
1886 * Yes, it is hack.
1887 */
1888 if (fi && res->prefixlen < 4)
1889 fi = NULL;
1890 } else if ((type == RTN_LOCAL) && (orig_oif != 0) &&
1891 (orig_oif != dev_out->ifindex)) {
1892 /* For local routes that require a particular output interface
1893 * we do not want to cache the result. Caching the result
1894 * causes incorrect behaviour when there are multiple source
1895 * addresses on the interface, the end result being that if the
1896 * intended recipient is waiting on that interface for the
1897 * packet he won't receive it because it will be delivered on
1898 * the loopback interface and the IP_PKTINFO ipi_ifindex will
1899 * be set to the loopback interface as well.
1900 */
1901 fi = NULL;
1902 }
1903
1904 fnhe = NULL;
1905 do_cache &= fi != NULL;
1906 if (do_cache) {
1907 struct rtable __rcu **prth;
1908 struct fib_nh *nh = &FIB_RES_NH(*res);
1909
1910 fnhe = find_exception(nh, fl4->daddr);
1911 if (fnhe)
1912 prth = &fnhe->fnhe_rth;
1913 else {
1914 if (unlikely(fl4->flowi4_flags &
1915 FLOWI_FLAG_KNOWN_NH &&
1916 !(nh->nh_gw &&
1917 nh->nh_scope == RT_SCOPE_LINK))) {
1918 do_cache = false;
1919 goto add;
1920 }
1921 prth = __this_cpu_ptr(nh->nh_pcpu_rth_output);
1922 }
1923 rth = rcu_dereference(*prth);
1924 if (rt_cache_valid(rth)) {
1925 dst_hold(&rth->dst);
1926 return rth;
1927 }
1928 }
1929
1930 add:
1931 rth = rt_dst_alloc(dev_out,
1932 IN_DEV_CONF_GET(in_dev, NOPOLICY),
1933 IN_DEV_CONF_GET(in_dev, NOXFRM),
1934 do_cache);
1935 if (!rth)
1936 return ERR_PTR(-ENOBUFS);
1937
1938 rth->dst.output = ip_output;
1939
1940 rth->rt_genid = rt_genid(dev_net(dev_out));
1941 rth->rt_flags = flags;
1942 rth->rt_type = type;
1943 rth->rt_is_input = 0;
1944 rth->rt_iif = orig_oif ? : 0;
1945 rth->rt_pmtu = 0;
1946 rth->rt_gateway = 0;
1947 rth->rt_uses_gateway = 0;
1948 INIT_LIST_HEAD(&rth->rt_uncached);
1949
1950 RT_CACHE_STAT_INC(out_slow_tot);
1951
1952 if (flags & RTCF_LOCAL)
1953 rth->dst.input = ip_local_deliver;
1954 if (flags & (RTCF_BROADCAST | RTCF_MULTICAST)) {
1955 if (flags & RTCF_LOCAL &&
1956 !(dev_out->flags & IFF_LOOPBACK)) {
1957 rth->dst.output = ip_mc_output;
1958 RT_CACHE_STAT_INC(out_slow_mc);
1959 }
1960 #ifdef CONFIG_IP_MROUTE
1961 if (type == RTN_MULTICAST) {
1962 if (IN_DEV_MFORWARD(in_dev) &&
1963 !ipv4_is_local_multicast(fl4->daddr)) {
1964 rth->dst.input = ip_mr_input;
1965 rth->dst.output = ip_mc_output;
1966 }
1967 }
1968 #endif
1969 }
1970
1971 rt_set_nexthop(rth, fl4->daddr, res, fnhe, fi, type, 0);
1972
1973 return rth;
1974 }
1975
1976 /*
1977 * Major route resolver routine.
1978 */
1979
1980 struct rtable *__ip_route_output_key(struct net *net, struct flowi4 *fl4)
1981 {
1982 struct net_device *dev_out = NULL;
1983 __u8 tos = RT_FL_TOS(fl4);
1984 unsigned int flags = 0;
1985 struct fib_result res;
1986 struct rtable *rth;
1987 int orig_oif;
1988
1989 res.tclassid = 0;
1990 res.fi = NULL;
1991 res.table = NULL;
1992
1993 orig_oif = fl4->flowi4_oif;
1994
1995 fl4->flowi4_iif = LOOPBACK_IFINDEX;
1996 fl4->flowi4_tos = tos & IPTOS_RT_MASK;
1997 fl4->flowi4_scope = ((tos & RTO_ONLINK) ?
1998 RT_SCOPE_LINK : RT_SCOPE_UNIVERSE);
1999
2000 rcu_read_lock();
2001 if (fl4->saddr) {
2002 rth = ERR_PTR(-EINVAL);
2003 if (ipv4_is_multicast(fl4->saddr) ||
2004 ipv4_is_lbcast(fl4->saddr) ||
2005 ipv4_is_zeronet(fl4->saddr))
2006 goto out;
2007
2008 /* I removed check for oif == dev_out->oif here.
2009 It was wrong for two reasons:
2010 1. ip_dev_find(net, saddr) can return wrong iface, if saddr
2011 is assigned to multiple interfaces.
2012 2. Moreover, we are allowed to send packets with saddr
2013 of another iface. --ANK
2014 */
2015
2016 if (fl4->flowi4_oif == 0 &&
2017 (ipv4_is_multicast(fl4->daddr) ||
2018 ipv4_is_lbcast(fl4->daddr))) {
2019 /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
2020 dev_out = __ip_dev_find(net, fl4->saddr, false);
2021 if (dev_out == NULL)
2022 goto out;
2023
2024 /* Special hack: user can direct multicasts
2025 and limited broadcast via necessary interface
2026 without fiddling with IP_MULTICAST_IF or IP_PKTINFO.
2027 This hack is not just for fun, it allows
2028 vic,vat and friends to work.
2029 They bind socket to loopback, set ttl to zero
2030 and expect that it will work.
2031 From the viewpoint of routing cache they are broken,
2032 because we are not allowed to build multicast path
2033 with loopback source addr (look, routing cache
2034 cannot know, that ttl is zero, so that packet
2035 will not leave this host and route is valid).
2036 Luckily, this hack is good workaround.
2037 */
2038
2039 fl4->flowi4_oif = dev_out->ifindex;
2040 goto make_route;
2041 }
2042
2043 if (!(fl4->flowi4_flags & FLOWI_FLAG_ANYSRC)) {
2044 /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
2045 if (!__ip_dev_find(net, fl4->saddr, false))
2046 goto out;
2047 }
2048 }
2049
2050
2051 if (fl4->flowi4_oif) {
2052 dev_out = dev_get_by_index_rcu(net, fl4->flowi4_oif);
2053 rth = ERR_PTR(-ENODEV);
2054 if (dev_out == NULL)
2055 goto out;
2056
2057 /* RACE: Check return value of inet_select_addr instead. */
2058 if (!(dev_out->flags & IFF_UP) || !__in_dev_get_rcu(dev_out)) {
2059 rth = ERR_PTR(-ENETUNREACH);
2060 goto out;
2061 }
2062 if (ipv4_is_local_multicast(fl4->daddr) ||
2063 ipv4_is_lbcast(fl4->daddr)) {
2064 if (!fl4->saddr)
2065 fl4->saddr = inet_select_addr(dev_out, 0,
2066 RT_SCOPE_LINK);
2067 goto make_route;
2068 }
2069 if (!fl4->saddr) {
2070 if (ipv4_is_multicast(fl4->daddr))
2071 fl4->saddr = inet_select_addr(dev_out, 0,
2072 fl4->flowi4_scope);
2073 else if (!fl4->daddr)
2074 fl4->saddr = inet_select_addr(dev_out, 0,
2075 RT_SCOPE_HOST);
2076 }
2077 }
2078
2079 if (!fl4->daddr) {
2080 fl4->daddr = fl4->saddr;
2081 if (!fl4->daddr)
2082 fl4->daddr = fl4->saddr = htonl(INADDR_LOOPBACK);
2083 dev_out = net->loopback_dev;
2084 fl4->flowi4_oif = LOOPBACK_IFINDEX;
2085 res.type = RTN_LOCAL;
2086 flags |= RTCF_LOCAL;
2087 goto make_route;
2088 }
2089
2090 if (fib_lookup(net, fl4, &res)) {
2091 res.fi = NULL;
2092 res.table = NULL;
2093 if (fl4->flowi4_oif) {
2094 /* Apparently, routing tables are wrong. Assume,
2095 that the destination is on link.
2096
2097 WHY? DW.
2098 Because we are allowed to send to iface
2099 even if it has NO routes and NO assigned
2100 addresses. When oif is specified, routing
2101 tables are looked up with only one purpose:
2102 to catch if destination is gatewayed, rather than
2103 direct. Moreover, if MSG_DONTROUTE is set,
2104 we send packet, ignoring both routing tables
2105 and ifaddr state. --ANK
2106
2107
2108 We could make it even if oif is unknown,
2109 likely IPv6, but we do not.
2110 */
2111
2112 if (fl4->saddr == 0)
2113 fl4->saddr = inet_select_addr(dev_out, 0,
2114 RT_SCOPE_LINK);
2115 res.type = RTN_UNICAST;
2116 goto make_route;
2117 }
2118 rth = ERR_PTR(-ENETUNREACH);
2119 goto out;
2120 }
2121
2122 if (res.type == RTN_LOCAL) {
2123 if (!fl4->saddr) {
2124 if (res.fi->fib_prefsrc)
2125 fl4->saddr = res.fi->fib_prefsrc;
2126 else
2127 fl4->saddr = fl4->daddr;
2128 }
2129 dev_out = net->loopback_dev;
2130 fl4->flowi4_oif = dev_out->ifindex;
2131 flags |= RTCF_LOCAL;
2132 goto make_route;
2133 }
2134
2135 #ifdef CONFIG_IP_ROUTE_MULTIPATH
2136 if (res.fi->fib_nhs > 1 && fl4->flowi4_oif == 0)
2137 fib_select_multipath(&res);
2138 else
2139 #endif
2140 if (!res.prefixlen &&
2141 res.table->tb_num_default > 1 &&
2142 res.type == RTN_UNICAST && !fl4->flowi4_oif)
2143 fib_select_default(&res);
2144
2145 if (!fl4->saddr)
2146 fl4->saddr = FIB_RES_PREFSRC(net, res);
2147
2148 dev_out = FIB_RES_DEV(res);
2149 fl4->flowi4_oif = dev_out->ifindex;
2150
2151
2152 make_route:
2153 rth = __mkroute_output(&res, fl4, orig_oif, dev_out, flags);
2154
2155 out:
2156 rcu_read_unlock();
2157 return rth;
2158 }
2159 EXPORT_SYMBOL_GPL(__ip_route_output_key);
2160
2161 static struct dst_entry *ipv4_blackhole_dst_check(struct dst_entry *dst, u32 cookie)
2162 {
2163 return NULL;
2164 }
2165
2166 static unsigned int ipv4_blackhole_mtu(const struct dst_entry *dst)
2167 {
2168 unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
2169
2170 return mtu ? : dst->dev->mtu;
2171 }
2172
2173 static void ipv4_rt_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,
2174 struct sk_buff *skb, u32 mtu)
2175 {
2176 }
2177
2178 static void ipv4_rt_blackhole_redirect(struct dst_entry *dst, struct sock *sk,
2179 struct sk_buff *skb)
2180 {
2181 }
2182
2183 static u32 *ipv4_rt_blackhole_cow_metrics(struct dst_entry *dst,
2184 unsigned long old)
2185 {
2186 return NULL;
2187 }
2188
2189 static struct dst_ops ipv4_dst_blackhole_ops = {
2190 .family = AF_INET,
2191 .protocol = cpu_to_be16(ETH_P_IP),
2192 .check = ipv4_blackhole_dst_check,
2193 .mtu = ipv4_blackhole_mtu,
2194 .default_advmss = ipv4_default_advmss,
2195 .update_pmtu = ipv4_rt_blackhole_update_pmtu,
2196 .redirect = ipv4_rt_blackhole_redirect,
2197 .cow_metrics = ipv4_rt_blackhole_cow_metrics,
2198 .neigh_lookup = ipv4_neigh_lookup,
2199 };
2200
2201 struct dst_entry *ipv4_blackhole_route(struct net *net, struct dst_entry *dst_orig)
2202 {
2203 struct rtable *ort = (struct rtable *) dst_orig;
2204 struct rtable *rt;
2205
2206 rt = dst_alloc(&ipv4_dst_blackhole_ops, NULL, 1, DST_OBSOLETE_NONE, 0);
2207 if (rt) {
2208 struct dst_entry *new = &rt->dst;
2209
2210 new->__use = 1;
2211 new->input = dst_discard;
2212 new->output = dst_discard;
2213
2214 new->dev = ort->dst.dev;
2215 if (new->dev)
2216 dev_hold(new->dev);
2217
2218 rt->rt_is_input = ort->rt_is_input;
2219 rt->rt_iif = ort->rt_iif;
2220 rt->rt_pmtu = ort->rt_pmtu;
2221
2222 rt->rt_genid = rt_genid(net);
2223 rt->rt_flags = ort->rt_flags;
2224 rt->rt_type = ort->rt_type;
2225 rt->rt_gateway = ort->rt_gateway;
2226 rt->rt_uses_gateway = ort->rt_uses_gateway;
2227
2228 INIT_LIST_HEAD(&rt->rt_uncached);
2229
2230 dst_free(new);
2231 }
2232
2233 dst_release(dst_orig);
2234
2235 return rt ? &rt->dst : ERR_PTR(-ENOMEM);
2236 }
2237
2238 struct rtable *ip_route_output_flow(struct net *net, struct flowi4 *flp4,
2239 struct sock *sk)
2240 {
2241 struct rtable *rt = __ip_route_output_key(net, flp4);
2242
2243 if (IS_ERR(rt))
2244 return rt;
2245
2246 if (flp4->flowi4_proto)
2247 rt = (struct rtable *) xfrm_lookup(net, &rt->dst,
2248 flowi4_to_flowi(flp4),
2249 sk, 0);
2250
2251 return rt;
2252 }
2253 EXPORT_SYMBOL_GPL(ip_route_output_flow);
2254
2255 static int rt_fill_info(struct net *net, __be32 dst, __be32 src,
2256 struct flowi4 *fl4, struct sk_buff *skb, u32 portid,
2257 u32 seq, int event, int nowait, unsigned int flags)
2258 {
2259 struct rtable *rt = skb_rtable(skb);
2260 struct rtmsg *r;
2261 struct nlmsghdr *nlh;
2262 unsigned long expires = 0;
2263 u32 error;
2264 u32 metrics[RTAX_MAX];
2265
2266 nlh = nlmsg_put(skb, portid, seq, event, sizeof(*r), flags);
2267 if (nlh == NULL)
2268 return -EMSGSIZE;
2269
2270 r = nlmsg_data(nlh);
2271 r->rtm_family = AF_INET;
2272 r->rtm_dst_len = 32;
2273 r->rtm_src_len = 0;
2274 r->rtm_tos = fl4->flowi4_tos;
2275 r->rtm_table = RT_TABLE_MAIN;
2276 if (nla_put_u32(skb, RTA_TABLE, RT_TABLE_MAIN))
2277 goto nla_put_failure;
2278 r->rtm_type = rt->rt_type;
2279 r->rtm_scope = RT_SCOPE_UNIVERSE;
2280 r->rtm_protocol = RTPROT_UNSPEC;
2281 r->rtm_flags = (rt->rt_flags & ~0xFFFF) | RTM_F_CLONED;
2282 if (rt->rt_flags & RTCF_NOTIFY)
2283 r->rtm_flags |= RTM_F_NOTIFY;
2284 if (IPCB(skb)->flags & IPSKB_DOREDIRECT)
2285 r->rtm_flags |= RTCF_DOREDIRECT;
2286
2287 if (nla_put_be32(skb, RTA_DST, dst))
2288 goto nla_put_failure;
2289 if (src) {
2290 r->rtm_src_len = 32;
2291 if (nla_put_be32(skb, RTA_SRC, src))
2292 goto nla_put_failure;
2293 }
2294 if (rt->dst.dev &&
2295 nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
2296 goto nla_put_failure;
2297 #ifdef CONFIG_IP_ROUTE_CLASSID
2298 if (rt->dst.tclassid &&
2299 nla_put_u32(skb, RTA_FLOW, rt->dst.tclassid))
2300 goto nla_put_failure;
2301 #endif
2302 if (!rt_is_input_route(rt) &&
2303 fl4->saddr != src) {
2304 if (nla_put_be32(skb, RTA_PREFSRC, fl4->saddr))
2305 goto nla_put_failure;
2306 }
2307 if (rt->rt_uses_gateway &&
2308 nla_put_be32(skb, RTA_GATEWAY, rt->rt_gateway))
2309 goto nla_put_failure;
2310
2311 expires = rt->dst.expires;
2312 if (expires) {
2313 unsigned long now = jiffies;
2314
2315 if (time_before(now, expires))
2316 expires -= now;
2317 else
2318 expires = 0;
2319 }
2320
2321 memcpy(metrics, dst_metrics_ptr(&rt->dst), sizeof(metrics));
2322 if (rt->rt_pmtu && expires)
2323 metrics[RTAX_MTU - 1] = rt->rt_pmtu;
2324 if (rtnetlink_put_metrics(skb, metrics) < 0)
2325 goto nla_put_failure;
2326
2327 if (fl4->flowi4_mark &&
2328 nla_put_u32(skb, RTA_MARK, fl4->flowi4_mark))
2329 goto nla_put_failure;
2330
2331 if (!uid_eq(fl4->flowi4_uid, INVALID_UID) &&
2332 nla_put_u32(skb, RTA_UID,
2333 from_kuid_munged(current_user_ns(), fl4->flowi4_uid)))
2334 goto nla_put_failure;
2335
2336 error = rt->dst.error;
2337
2338 if (rt_is_input_route(rt)) {
2339 #ifdef CONFIG_IP_MROUTE
2340 if (ipv4_is_multicast(dst) && !ipv4_is_local_multicast(dst) &&
2341 IPV4_DEVCONF_ALL(net, MC_FORWARDING)) {
2342 int err = ipmr_get_route(net, skb,
2343 fl4->saddr, fl4->daddr,
2344 r, nowait, portid);
2345
2346 if (err <= 0) {
2347 if (!nowait) {
2348 if (err == 0)
2349 return 0;
2350 goto nla_put_failure;
2351 } else {
2352 if (err == -EMSGSIZE)
2353 goto nla_put_failure;
2354 error = err;
2355 }
2356 }
2357 } else
2358 #endif
2359 if (nla_put_u32(skb, RTA_IIF, skb->dev->ifindex))
2360 goto nla_put_failure;
2361 }
2362
2363 if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, error) < 0)
2364 goto nla_put_failure;
2365
2366 return nlmsg_end(skb, nlh);
2367
2368 nla_put_failure:
2369 nlmsg_cancel(skb, nlh);
2370 return -EMSGSIZE;
2371 }
2372
2373 static int inet_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh)
2374 {
2375 struct net *net = sock_net(in_skb->sk);
2376 struct rtmsg *rtm;
2377 struct nlattr *tb[RTA_MAX+1];
2378 struct rtable *rt = NULL;
2379 struct flowi4 fl4;
2380 __be32 dst = 0;
2381 __be32 src = 0;
2382 u32 iif;
2383 int err;
2384 int mark;
2385 struct sk_buff *skb;
2386 kuid_t uid;
2387
2388 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv4_policy);
2389 if (err < 0)
2390 goto errout;
2391
2392 rtm = nlmsg_data(nlh);
2393
2394 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
2395 if (skb == NULL) {
2396 err = -ENOBUFS;
2397 goto errout;
2398 }
2399
2400 /* Reserve room for dummy headers, this skb can pass
2401 through good chunk of routing engine.
2402 */
2403 skb_reset_mac_header(skb);
2404 skb_reset_network_header(skb);
2405
2406 /* Bugfix: need to give ip_route_input enough of an IP header to not gag. */
2407 ip_hdr(skb)->protocol = IPPROTO_ICMP;
2408 skb_reserve(skb, MAX_HEADER + sizeof(struct iphdr));
2409
2410 src = tb[RTA_SRC] ? nla_get_be32(tb[RTA_SRC]) : 0;
2411 dst = tb[RTA_DST] ? nla_get_be32(tb[RTA_DST]) : 0;
2412 iif = tb[RTA_IIF] ? nla_get_u32(tb[RTA_IIF]) : 0;
2413 mark = tb[RTA_MARK] ? nla_get_u32(tb[RTA_MARK]) : 0;
2414 if (tb[RTA_UID])
2415 uid = make_kuid(current_user_ns(), nla_get_u32(tb[RTA_UID]));
2416 else
2417 uid = (iif ? INVALID_UID : current_uid());
2418
2419 memset(&fl4, 0, sizeof(fl4));
2420 fl4.daddr = dst;
2421 fl4.saddr = src;
2422 fl4.flowi4_tos = rtm->rtm_tos;
2423 fl4.flowi4_oif = tb[RTA_OIF] ? nla_get_u32(tb[RTA_OIF]) : 0;
2424 fl4.flowi4_mark = mark;
2425 fl4.flowi4_uid = uid;
2426
2427 if (iif) {
2428 struct net_device *dev;
2429
2430 dev = __dev_get_by_index(net, iif);
2431 if (dev == NULL) {
2432 err = -ENODEV;
2433 goto errout_free;
2434 }
2435
2436 skb->protocol = htons(ETH_P_IP);
2437 skb->dev = dev;
2438 skb->mark = mark;
2439 local_bh_disable();
2440 err = ip_route_input(skb, dst, src, rtm->rtm_tos, dev);
2441 local_bh_enable();
2442
2443 rt = skb_rtable(skb);
2444 if (err == 0 && rt->dst.error)
2445 err = -rt->dst.error;
2446 } else {
2447 rt = ip_route_output_key(net, &fl4);
2448
2449 err = 0;
2450 if (IS_ERR(rt))
2451 err = PTR_ERR(rt);
2452 }
2453
2454 if (err)
2455 goto errout_free;
2456
2457 skb_dst_set(skb, &rt->dst);
2458 if (rtm->rtm_flags & RTM_F_NOTIFY)
2459 rt->rt_flags |= RTCF_NOTIFY;
2460
2461 err = rt_fill_info(net, dst, src, &fl4, skb,
2462 NETLINK_CB(in_skb).portid, nlh->nlmsg_seq,
2463 RTM_NEWROUTE, 0, 0);
2464 if (err <= 0)
2465 goto errout_free;
2466
2467 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
2468 errout:
2469 return err;
2470
2471 errout_free:
2472 kfree_skb(skb);
2473 goto errout;
2474 }
2475
2476 int ip_rt_dump(struct sk_buff *skb, struct netlink_callback *cb)
2477 {
2478 return skb->len;
2479 }
2480
2481 void ip_rt_multicast_event(struct in_device *in_dev)
2482 {
2483 rt_cache_flush(dev_net(in_dev->dev));
2484 }
2485
2486 #ifdef CONFIG_SYSCTL
2487 static int ip_rt_gc_timeout __read_mostly = RT_GC_TIMEOUT;
2488 static int ip_rt_gc_interval __read_mostly = 60 * HZ;
2489 static int ip_rt_gc_min_interval __read_mostly = HZ / 2;
2490 static int ip_rt_gc_elasticity __read_mostly = 8;
2491
2492 static int ipv4_sysctl_rtcache_flush(ctl_table *__ctl, int write,
2493 void __user *buffer,
2494 size_t *lenp, loff_t *ppos)
2495 {
2496 if (write) {
2497 rt_cache_flush((struct net *)__ctl->extra1);
2498 return 0;
2499 }
2500
2501 return -EINVAL;
2502 }
2503
2504 static ctl_table ipv4_route_table[] = {
2505 {
2506 .procname = "gc_thresh",
2507 .data = &ipv4_dst_ops.gc_thresh,
2508 .maxlen = sizeof(int),
2509 .mode = 0644,
2510 .proc_handler = proc_dointvec,
2511 },
2512 {
2513 .procname = "max_size",
2514 .data = &ip_rt_max_size,
2515 .maxlen = sizeof(int),
2516 .mode = 0644,
2517 .proc_handler = proc_dointvec,
2518 },
2519 {
2520 /* Deprecated. Use gc_min_interval_ms */
2521
2522 .procname = "gc_min_interval",
2523 .data = &ip_rt_gc_min_interval,
2524 .maxlen = sizeof(int),
2525 .mode = 0644,
2526 .proc_handler = proc_dointvec_jiffies,
2527 },
2528 {
2529 .procname = "gc_min_interval_ms",
2530 .data = &ip_rt_gc_min_interval,
2531 .maxlen = sizeof(int),
2532 .mode = 0644,
2533 .proc_handler = proc_dointvec_ms_jiffies,
2534 },
2535 {
2536 .procname = "gc_timeout",
2537 .data = &ip_rt_gc_timeout,
2538 .maxlen = sizeof(int),
2539 .mode = 0644,
2540 .proc_handler = proc_dointvec_jiffies,
2541 },
2542 {
2543 .procname = "gc_interval",
2544 .data = &ip_rt_gc_interval,
2545 .maxlen = sizeof(int),
2546 .mode = 0644,
2547 .proc_handler = proc_dointvec_jiffies,
2548 },
2549 {
2550 .procname = "redirect_load",
2551 .data = &ip_rt_redirect_load,
2552 .maxlen = sizeof(int),
2553 .mode = 0644,
2554 .proc_handler = proc_dointvec,
2555 },
2556 {
2557 .procname = "redirect_number",
2558 .data = &ip_rt_redirect_number,
2559 .maxlen = sizeof(int),
2560 .mode = 0644,
2561 .proc_handler = proc_dointvec,
2562 },
2563 {
2564 .procname = "redirect_silence",
2565 .data = &ip_rt_redirect_silence,
2566 .maxlen = sizeof(int),
2567 .mode = 0644,
2568 .proc_handler = proc_dointvec,
2569 },
2570 {
2571 .procname = "error_cost",
2572 .data = &ip_rt_error_cost,
2573 .maxlen = sizeof(int),
2574 .mode = 0644,
2575 .proc_handler = proc_dointvec,
2576 },
2577 {
2578 .procname = "error_burst",
2579 .data = &ip_rt_error_burst,
2580 .maxlen = sizeof(int),
2581 .mode = 0644,
2582 .proc_handler = proc_dointvec,
2583 },
2584 {
2585 .procname = "gc_elasticity",
2586 .data = &ip_rt_gc_elasticity,
2587 .maxlen = sizeof(int),
2588 .mode = 0644,
2589 .proc_handler = proc_dointvec,
2590 },
2591 {
2592 .procname = "mtu_expires",
2593 .data = &ip_rt_mtu_expires,
2594 .maxlen = sizeof(int),
2595 .mode = 0644,
2596 .proc_handler = proc_dointvec_jiffies,
2597 },
2598 {
2599 .procname = "min_pmtu",
2600 .data = &ip_rt_min_pmtu,
2601 .maxlen = sizeof(int),
2602 .mode = 0644,
2603 .proc_handler = proc_dointvec,
2604 },
2605 {
2606 .procname = "min_adv_mss",
2607 .data = &ip_rt_min_advmss,
2608 .maxlen = sizeof(int),
2609 .mode = 0644,
2610 .proc_handler = proc_dointvec,
2611 },
2612 { }
2613 };
2614
2615 static struct ctl_table ipv4_route_flush_table[] = {
2616 {
2617 .procname = "flush",
2618 .maxlen = sizeof(int),
2619 .mode = 0200,
2620 .proc_handler = ipv4_sysctl_rtcache_flush,
2621 },
2622 { },
2623 };
2624
2625 static __net_init int sysctl_route_net_init(struct net *net)
2626 {
2627 struct ctl_table *tbl;
2628
2629 tbl = ipv4_route_flush_table;
2630 if (!net_eq(net, &init_net)) {
2631 tbl = kmemdup(tbl, sizeof(ipv4_route_flush_table), GFP_KERNEL);
2632 if (tbl == NULL)
2633 goto err_dup;
2634
2635 /* Don't export sysctls to unprivileged users */
2636 if (net->user_ns != &init_user_ns)
2637 tbl[0].procname = NULL;
2638 }
2639 tbl[0].extra1 = net;
2640
2641 net->ipv4.route_hdr = register_net_sysctl(net, "net/ipv4/route", tbl);
2642 if (net->ipv4.route_hdr == NULL)
2643 goto err_reg;
2644 return 0;
2645
2646 err_reg:
2647 if (tbl != ipv4_route_flush_table)
2648 kfree(tbl);
2649 err_dup:
2650 return -ENOMEM;
2651 }
2652
2653 static __net_exit void sysctl_route_net_exit(struct net *net)
2654 {
2655 struct ctl_table *tbl;
2656
2657 tbl = net->ipv4.route_hdr->ctl_table_arg;
2658 unregister_net_sysctl_table(net->ipv4.route_hdr);
2659 BUG_ON(tbl == ipv4_route_flush_table);
2660 kfree(tbl);
2661 }
2662
2663 static __net_initdata struct pernet_operations sysctl_route_ops = {
2664 .init = sysctl_route_net_init,
2665 .exit = sysctl_route_net_exit,
2666 };
2667 #endif
2668
2669 static __net_init int rt_genid_init(struct net *net)
2670 {
2671 atomic_set(&net->rt_genid, 0);
2672 get_random_bytes(&net->ipv4.dev_addr_genid,
2673 sizeof(net->ipv4.dev_addr_genid));
2674 return 0;
2675 }
2676
2677 static __net_initdata struct pernet_operations rt_genid_ops = {
2678 .init = rt_genid_init,
2679 };
2680
2681 static int __net_init ipv4_inetpeer_init(struct net *net)
2682 {
2683 struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
2684
2685 if (!bp)
2686 return -ENOMEM;
2687 inet_peer_base_init(bp);
2688 net->ipv4.peers = bp;
2689 return 0;
2690 }
2691
2692 static void __net_exit ipv4_inetpeer_exit(struct net *net)
2693 {
2694 struct inet_peer_base *bp = net->ipv4.peers;
2695
2696 net->ipv4.peers = NULL;
2697 inetpeer_invalidate_tree(bp);
2698 kfree(bp);
2699 }
2700
2701 static __net_initdata struct pernet_operations ipv4_inetpeer_ops = {
2702 .init = ipv4_inetpeer_init,
2703 .exit = ipv4_inetpeer_exit,
2704 };
2705
2706 #ifdef CONFIG_IP_ROUTE_CLASSID
2707 struct ip_rt_acct __percpu *ip_rt_acct __read_mostly;
2708 #endif /* CONFIG_IP_ROUTE_CLASSID */
2709
2710 int __init ip_rt_init(void)
2711 {
2712 int rc = 0;
2713
2714 ip_idents = kmalloc(IP_IDENTS_SZ * sizeof(*ip_idents), GFP_KERNEL);
2715 if (!ip_idents)
2716 panic("IP: failed to allocate ip_idents\n");
2717
2718 prandom_bytes(ip_idents, IP_IDENTS_SZ * sizeof(*ip_idents));
2719
2720 #ifdef CONFIG_IP_ROUTE_CLASSID
2721 ip_rt_acct = __alloc_percpu(256 * sizeof(struct ip_rt_acct), __alignof__(struct ip_rt_acct));
2722 if (!ip_rt_acct)
2723 panic("IP: failed to allocate ip_rt_acct\n");
2724 #endif
2725
2726 ipv4_dst_ops.kmem_cachep =
2727 kmem_cache_create("ip_dst_cache", sizeof(struct rtable), 0,
2728 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
2729
2730 ipv4_dst_blackhole_ops.kmem_cachep = ipv4_dst_ops.kmem_cachep;
2731
2732 if (dst_entries_init(&ipv4_dst_ops) < 0)
2733 panic("IP: failed to allocate ipv4_dst_ops counter\n");
2734
2735 if (dst_entries_init(&ipv4_dst_blackhole_ops) < 0)
2736 panic("IP: failed to allocate ipv4_dst_blackhole_ops counter\n");
2737
2738 ipv4_dst_ops.gc_thresh = ~0;
2739 ip_rt_max_size = INT_MAX;
2740
2741 devinet_init();
2742 ip_fib_init();
2743
2744 if (ip_rt_proc_init())
2745 pr_err("Unable to create route proc files\n");
2746 #ifdef CONFIG_XFRM
2747 xfrm_init();
2748 xfrm4_init();
2749 #endif
2750 rtnl_register(PF_INET, RTM_GETROUTE, inet_rtm_getroute, NULL, NULL);
2751
2752 #ifdef CONFIG_SYSCTL
2753 register_pernet_subsys(&sysctl_route_ops);
2754 #endif
2755 register_pernet_subsys(&rt_genid_ops);
2756 register_pernet_subsys(&ipv4_inetpeer_ops);
2757 return rc;
2758 }
2759
2760 #ifdef CONFIG_SYSCTL
2761 /*
2762 * We really need to sanitize the damn ipv4 init order, then all
2763 * this nonsense will go away.
2764 */
2765 void __init ip_static_sysctl_init(void)
2766 {
2767 register_net_sysctl(&init_net, "net/ipv4/route", ipv4_route_table);
2768 }
2769 #endif
kernel source for telekom puls (alcatel/mediatek)