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.
6 * ROUTE - implementation of the IP router.
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>
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
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.
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
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.
65 #define pr_fmt(fmt) "IPv4: " fmt
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>
73 #include <linux/string.h>
74 #include <linux/socket.h>
75 #include <linux/sockios.h>
76 #include <linux/errno.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>
94 #include <net/net_namespace.h>
95 #include <net/protocol.h>
97 #include <net/route.h>
98 #include <net/inetpeer.h>
100 #include <net/ip_fib.h>
103 #include <net/icmp.h>
104 #include <net/xfrm.h>
105 #include <net/netevent.h>
106 #include <net/rtnetlink.h>
108 #include <linux/sysctl.h>
109 #include <linux/kmemleak.h>
111 #include <net/secure_seq.h>
113 #define RT_FL_TOS(oldflp4) \
114 ((oldflp4)->flowi4_tos & (IPTOS_RT_MASK | RTO_ONLINK))
116 #define RT_GC_TIMEOUT (300*HZ)
118 static int ip_rt_max_size;
119 static int ip_rt_redirect_number __read_mostly = 9;
120 static int ip_rt_redirect_load __read_mostly = HZ / 50;
121 static int ip_rt_redirect_silence __read_mostly = ((HZ / 50) << (9 + 1));
122 static int ip_rt_error_cost __read_mostly = HZ;
123 static int ip_rt_error_burst __read_mostly = 5 * HZ;
124 static int ip_rt_mtu_expires __read_mostly = 10 * 60 * HZ;
125 static int ip_rt_min_pmtu __read_mostly = 512 + 20 + 20;
126 static int ip_rt_min_advmss __read_mostly = 256;
129 * Interface to generic destination cache.
132 static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie);
133 static unsigned int ipv4_default_advmss(const struct dst_entry *dst);
134 static unsigned int ipv4_mtu(const struct dst_entry *dst);
135 static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst);
136 static void ipv4_link_failure(struct sk_buff *skb);
137 static void ip_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
138 struct sk_buff *skb, u32 mtu);
139 static void ip_do_redirect(struct dst_entry *dst, struct sock *sk,
140 struct sk_buff *skb);
141 static void ipv4_dst_destroy(struct dst_entry *dst);
143 static u32 *ipv4_cow_metrics(struct dst_entry *dst, unsigned long old)
149 static struct neighbour *ipv4_neigh_lookup(const struct dst_entry *dst,
153 static struct dst_ops ipv4_dst_ops = {
155 .protocol = cpu_to_be16(ETH_P_IP),
156 .check = ipv4_dst_check,
157 .default_advmss = ipv4_default_advmss,
159 .cow_metrics = ipv4_cow_metrics,
160 .destroy = ipv4_dst_destroy,
161 .negative_advice = ipv4_negative_advice,
162 .link_failure = ipv4_link_failure,
163 .update_pmtu = ip_rt_update_pmtu,
164 .redirect = ip_do_redirect,
165 .local_out = __ip_local_out,
166 .neigh_lookup = ipv4_neigh_lookup,
169 #define ECN_OR_COST(class) TC_PRIO_##class
171 const __u8 ip_tos2prio[16] = {
173 ECN_OR_COST(BESTEFFORT),
175 ECN_OR_COST(BESTEFFORT),
181 ECN_OR_COST(INTERACTIVE),
183 ECN_OR_COST(INTERACTIVE),
184 TC_PRIO_INTERACTIVE_BULK,
185 ECN_OR_COST(INTERACTIVE_BULK),
186 TC_PRIO_INTERACTIVE_BULK,
187 ECN_OR_COST(INTERACTIVE_BULK)
189 EXPORT_SYMBOL(ip_tos2prio);
191 static DEFINE_PER_CPU(struct rt_cache_stat, rt_cache_stat);
192 #define RT_CACHE_STAT_INC(field) raw_cpu_inc(rt_cache_stat.field)
194 #ifdef CONFIG_PROC_FS
195 static void *rt_cache_seq_start(struct seq_file *seq, loff_t *pos)
199 return SEQ_START_TOKEN;
202 static void *rt_cache_seq_next(struct seq_file *seq, void *v, loff_t *pos)
208 static void rt_cache_seq_stop(struct seq_file *seq, void *v)
212 static int rt_cache_seq_show(struct seq_file *seq, void *v)
214 if (v == SEQ_START_TOKEN)
215 seq_printf(seq, "%-127s\n",
216 "Iface\tDestination\tGateway \tFlags\t\tRefCnt\tUse\t"
217 "Metric\tSource\t\tMTU\tWindow\tIRTT\tTOS\tHHRef\t"
222 static const struct seq_operations rt_cache_seq_ops = {
223 .start = rt_cache_seq_start,
224 .next = rt_cache_seq_next,
225 .stop = rt_cache_seq_stop,
226 .show = rt_cache_seq_show,
229 static int rt_cache_seq_open(struct inode *inode, struct file *file)
231 return seq_open(file, &rt_cache_seq_ops);
234 static const struct file_operations rt_cache_seq_fops = {
235 .owner = THIS_MODULE,
236 .open = rt_cache_seq_open,
239 .release = seq_release,
243 static void *rt_cpu_seq_start(struct seq_file *seq, loff_t *pos)
248 return SEQ_START_TOKEN;
250 for (cpu = *pos-1; cpu < nr_cpu_ids; ++cpu) {
251 if (!cpu_possible(cpu))
254 return &per_cpu(rt_cache_stat, cpu);
259 static void *rt_cpu_seq_next(struct seq_file *seq, void *v, loff_t *pos)
263 for (cpu = *pos; cpu < nr_cpu_ids; ++cpu) {
264 if (!cpu_possible(cpu))
267 return &per_cpu(rt_cache_stat, cpu);
273 static void rt_cpu_seq_stop(struct seq_file *seq, void *v)
278 static int rt_cpu_seq_show(struct seq_file *seq, void *v)
280 struct rt_cache_stat *st = v;
282 if (v == SEQ_START_TOKEN) {
283 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");
287 seq_printf(seq,"%08x %08x %08x %08x %08x %08x %08x %08x "
288 " %08x %08x %08x %08x %08x %08x %08x %08x %08x \n",
289 dst_entries_get_slow(&ipv4_dst_ops),
302 0, /* st->gc_total */
303 0, /* st->gc_ignored */
304 0, /* st->gc_goal_miss */
305 0, /* st->gc_dst_overflow */
306 0, /* st->in_hlist_search */
307 0 /* st->out_hlist_search */
312 static const struct seq_operations rt_cpu_seq_ops = {
313 .start = rt_cpu_seq_start,
314 .next = rt_cpu_seq_next,
315 .stop = rt_cpu_seq_stop,
316 .show = rt_cpu_seq_show,
320 static int rt_cpu_seq_open(struct inode *inode, struct file *file)
322 return seq_open(file, &rt_cpu_seq_ops);
325 static const struct file_operations rt_cpu_seq_fops = {
326 .owner = THIS_MODULE,
327 .open = rt_cpu_seq_open,
330 .release = seq_release,
333 #ifdef CONFIG_IP_ROUTE_CLASSID
334 static int rt_acct_proc_show(struct seq_file *m, void *v)
336 struct ip_rt_acct *dst, *src;
339 dst = kcalloc(256, sizeof(struct ip_rt_acct), GFP_KERNEL);
343 for_each_possible_cpu(i) {
344 src = (struct ip_rt_acct *)per_cpu_ptr(ip_rt_acct, i);
345 for (j = 0; j < 256; j++) {
346 dst[j].o_bytes += src[j].o_bytes;
347 dst[j].o_packets += src[j].o_packets;
348 dst[j].i_bytes += src[j].i_bytes;
349 dst[j].i_packets += src[j].i_packets;
353 seq_write(m, dst, 256 * sizeof(struct ip_rt_acct));
358 static int rt_acct_proc_open(struct inode *inode, struct file *file)
360 return single_open(file, rt_acct_proc_show, NULL);
363 static const struct file_operations rt_acct_proc_fops = {
364 .owner = THIS_MODULE,
365 .open = rt_acct_proc_open,
368 .release = single_release,
372 static int __net_init ip_rt_do_proc_init(struct net *net)
374 struct proc_dir_entry *pde;
376 pde = proc_create("rt_cache", S_IRUGO, net->proc_net,
381 pde = proc_create("rt_cache", S_IRUGO,
382 net->proc_net_stat, &rt_cpu_seq_fops);
386 #ifdef CONFIG_IP_ROUTE_CLASSID
387 pde = proc_create("rt_acct", 0, net->proc_net, &rt_acct_proc_fops);
393 #ifdef CONFIG_IP_ROUTE_CLASSID
395 remove_proc_entry("rt_cache", net->proc_net_stat);
398 remove_proc_entry("rt_cache", net->proc_net);
403 static void __net_exit ip_rt_do_proc_exit(struct net *net)
405 remove_proc_entry("rt_cache", net->proc_net_stat);
406 remove_proc_entry("rt_cache", net->proc_net);
407 #ifdef CONFIG_IP_ROUTE_CLASSID
408 remove_proc_entry("rt_acct", net->proc_net);
412 static struct pernet_operations ip_rt_proc_ops __net_initdata = {
413 .init = ip_rt_do_proc_init,
414 .exit = ip_rt_do_proc_exit,
417 static int __init ip_rt_proc_init(void)
419 return register_pernet_subsys(&ip_rt_proc_ops);
423 static inline int ip_rt_proc_init(void)
427 #endif /* CONFIG_PROC_FS */
429 static inline bool rt_is_expired(const struct rtable *rth)
431 return rth->rt_genid != rt_genid_ipv4(dev_net(rth->dst.dev));
434 void rt_cache_flush(struct net *net)
436 rt_genid_bump_ipv4(net);
439 static struct neighbour *ipv4_neigh_lookup(const struct dst_entry *dst,
443 struct net_device *dev = dst->dev;
444 const __be32 *pkey = daddr;
445 const struct rtable *rt;
448 rt = (const struct rtable *) dst;
450 pkey = (const __be32 *) &rt->rt_gateway;
452 pkey = &ip_hdr(skb)->daddr;
454 n = __ipv4_neigh_lookup(dev, *(__force u32 *)pkey);
457 return neigh_create(&arp_tbl, pkey, dev);
460 #define IP_IDENTS_SZ 2048u
461 struct ip_ident_bucket {
466 static struct ip_ident_bucket *ip_idents __read_mostly;
468 /* In order to protect privacy, we add a perturbation to identifiers
469 * if one generator is seldom used. This makes hard for an attacker
470 * to infer how many packets were sent between two points in time.
472 u32 ip_idents_reserve(u32 hash, int segs)
474 struct ip_ident_bucket *bucket = ip_idents + hash % IP_IDENTS_SZ;
475 u32 old = ACCESS_ONCE(bucket->stamp32);
476 u32 now = (u32)jiffies;
479 if (old != now && cmpxchg(&bucket->stamp32, old, now) == old)
480 delta = prandom_u32_max(now - old);
482 return atomic_add_return(segs + delta, &bucket->id) - segs;
484 EXPORT_SYMBOL(ip_idents_reserve);
486 void __ip_select_ident(struct iphdr *iph, int segs)
488 static u32 ip_idents_hashrnd __read_mostly;
491 net_get_random_once(&ip_idents_hashrnd, sizeof(ip_idents_hashrnd));
493 hash = jhash_3words((__force u32)iph->daddr,
494 (__force u32)iph->saddr,
497 id = ip_idents_reserve(hash, segs);
500 EXPORT_SYMBOL(__ip_select_ident);
502 static void __build_flow_key(struct flowi4 *fl4, const struct sock *sk,
503 const struct iphdr *iph,
505 u8 prot, u32 mark, int flow_flags)
508 const struct inet_sock *inet = inet_sk(sk);
510 oif = sk->sk_bound_dev_if;
512 tos = RT_CONN_FLAGS(sk);
513 prot = inet->hdrincl ? IPPROTO_RAW : sk->sk_protocol;
515 flowi4_init_output(fl4, oif, mark, tos,
516 RT_SCOPE_UNIVERSE, prot,
518 iph->daddr, iph->saddr, 0, 0);
521 static void build_skb_flow_key(struct flowi4 *fl4, const struct sk_buff *skb,
522 const struct sock *sk)
524 const struct iphdr *iph = ip_hdr(skb);
525 int oif = skb->dev->ifindex;
526 u8 tos = RT_TOS(iph->tos);
527 u8 prot = iph->protocol;
528 u32 mark = skb->mark;
530 __build_flow_key(fl4, sk, iph, oif, tos, prot, mark, 0);
533 static void build_sk_flow_key(struct flowi4 *fl4, const struct sock *sk)
535 const struct inet_sock *inet = inet_sk(sk);
536 const struct ip_options_rcu *inet_opt;
537 __be32 daddr = inet->inet_daddr;
540 inet_opt = rcu_dereference(inet->inet_opt);
541 if (inet_opt && inet_opt->opt.srr)
542 daddr = inet_opt->opt.faddr;
543 flowi4_init_output(fl4, sk->sk_bound_dev_if, sk->sk_mark,
544 RT_CONN_FLAGS(sk), RT_SCOPE_UNIVERSE,
545 inet->hdrincl ? IPPROTO_RAW : sk->sk_protocol,
546 inet_sk_flowi_flags(sk),
547 daddr, inet->inet_saddr, 0, 0);
551 static void ip_rt_build_flow_key(struct flowi4 *fl4, const struct sock *sk,
552 const struct sk_buff *skb)
555 build_skb_flow_key(fl4, skb, sk);
557 build_sk_flow_key(fl4, sk);
560 static inline void rt_free(struct rtable *rt)
562 call_rcu(&rt->dst.rcu_head, dst_rcu_free);
565 static DEFINE_SPINLOCK(fnhe_lock);
567 static void fnhe_flush_routes(struct fib_nh_exception *fnhe)
571 rt = rcu_dereference(fnhe->fnhe_rth_input);
573 RCU_INIT_POINTER(fnhe->fnhe_rth_input, NULL);
576 rt = rcu_dereference(fnhe->fnhe_rth_output);
578 RCU_INIT_POINTER(fnhe->fnhe_rth_output, NULL);
583 static struct fib_nh_exception *fnhe_oldest(struct fnhe_hash_bucket *hash)
585 struct fib_nh_exception *fnhe, *oldest;
587 oldest = rcu_dereference(hash->chain);
588 for (fnhe = rcu_dereference(oldest->fnhe_next); fnhe;
589 fnhe = rcu_dereference(fnhe->fnhe_next)) {
590 if (time_before(fnhe->fnhe_stamp, oldest->fnhe_stamp))
593 fnhe_flush_routes(oldest);
597 static inline u32 fnhe_hashfun(__be32 daddr)
599 static u32 fnhe_hashrnd __read_mostly;
602 net_get_random_once(&fnhe_hashrnd, sizeof(fnhe_hashrnd));
603 hval = jhash_1word((__force u32) daddr, fnhe_hashrnd);
604 return hash_32(hval, FNHE_HASH_SHIFT);
607 static void fill_route_from_fnhe(struct rtable *rt, struct fib_nh_exception *fnhe)
609 rt->rt_pmtu = fnhe->fnhe_pmtu;
610 rt->dst.expires = fnhe->fnhe_expires;
613 rt->rt_flags |= RTCF_REDIRECTED;
614 rt->rt_gateway = fnhe->fnhe_gw;
615 rt->rt_uses_gateway = 1;
619 static void update_or_create_fnhe(struct fib_nh *nh, __be32 daddr, __be32 gw,
620 u32 pmtu, unsigned long expires)
622 struct fnhe_hash_bucket *hash;
623 struct fib_nh_exception *fnhe;
627 u32 hval = fnhe_hashfun(daddr);
629 spin_lock_bh(&fnhe_lock);
631 hash = rcu_dereference(nh->nh_exceptions);
633 hash = kzalloc(FNHE_HASH_SIZE * sizeof(*hash), GFP_ATOMIC);
636 rcu_assign_pointer(nh->nh_exceptions, hash);
642 for (fnhe = rcu_dereference(hash->chain); fnhe;
643 fnhe = rcu_dereference(fnhe->fnhe_next)) {
644 if (fnhe->fnhe_daddr == daddr)
653 fnhe->fnhe_pmtu = pmtu;
654 fnhe->fnhe_expires = max(1UL, expires);
656 /* Update all cached dsts too */
657 rt = rcu_dereference(fnhe->fnhe_rth_input);
659 fill_route_from_fnhe(rt, fnhe);
660 rt = rcu_dereference(fnhe->fnhe_rth_output);
662 fill_route_from_fnhe(rt, fnhe);
664 if (depth > FNHE_RECLAIM_DEPTH)
665 fnhe = fnhe_oldest(hash);
667 fnhe = kzalloc(sizeof(*fnhe), GFP_ATOMIC);
671 fnhe->fnhe_next = hash->chain;
672 rcu_assign_pointer(hash->chain, fnhe);
674 fnhe->fnhe_genid = fnhe_genid(dev_net(nh->nh_dev));
675 fnhe->fnhe_daddr = daddr;
677 fnhe->fnhe_pmtu = pmtu;
678 fnhe->fnhe_expires = expires;
680 /* Exception created; mark the cached routes for the nexthop
681 * stale, so anyone caching it rechecks if this exception
684 rt = rcu_dereference(nh->nh_rth_input);
686 rt->dst.obsolete = DST_OBSOLETE_KILL;
688 for_each_possible_cpu(i) {
689 struct rtable __rcu **prt;
690 prt = per_cpu_ptr(nh->nh_pcpu_rth_output, i);
691 rt = rcu_dereference(*prt);
693 rt->dst.obsolete = DST_OBSOLETE_KILL;
697 fnhe->fnhe_stamp = jiffies;
700 spin_unlock_bh(&fnhe_lock);
703 static void __ip_do_redirect(struct rtable *rt, struct sk_buff *skb, struct flowi4 *fl4,
706 __be32 new_gw = icmp_hdr(skb)->un.gateway;
707 __be32 old_gw = ip_hdr(skb)->saddr;
708 struct net_device *dev = skb->dev;
709 struct in_device *in_dev;
710 struct fib_result res;
714 switch (icmp_hdr(skb)->code & 7) {
716 case ICMP_REDIR_NETTOS:
717 case ICMP_REDIR_HOST:
718 case ICMP_REDIR_HOSTTOS:
725 if (rt->rt_gateway != old_gw)
728 in_dev = __in_dev_get_rcu(dev);
733 if (new_gw == old_gw || !IN_DEV_RX_REDIRECTS(in_dev) ||
734 ipv4_is_multicast(new_gw) || ipv4_is_lbcast(new_gw) ||
735 ipv4_is_zeronet(new_gw))
736 goto reject_redirect;
738 if (!IN_DEV_SHARED_MEDIA(in_dev)) {
739 if (!inet_addr_onlink(in_dev, new_gw, old_gw))
740 goto reject_redirect;
741 if (IN_DEV_SEC_REDIRECTS(in_dev) && ip_fib_check_default(new_gw, dev))
742 goto reject_redirect;
744 if (inet_addr_type(net, new_gw) != RTN_UNICAST)
745 goto reject_redirect;
748 n = ipv4_neigh_lookup(&rt->dst, NULL, &new_gw);
750 if (!(n->nud_state & NUD_VALID)) {
751 neigh_event_send(n, NULL);
753 if (fib_lookup(net, fl4, &res) == 0) {
754 struct fib_nh *nh = &FIB_RES_NH(res);
756 update_or_create_fnhe(nh, fl4->daddr, new_gw,
760 rt->dst.obsolete = DST_OBSOLETE_KILL;
761 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, n);
768 #ifdef CONFIG_IP_ROUTE_VERBOSE
769 if (IN_DEV_LOG_MARTIANS(in_dev)) {
770 const struct iphdr *iph = (const struct iphdr *) skb->data;
771 __be32 daddr = iph->daddr;
772 __be32 saddr = iph->saddr;
774 net_info_ratelimited("Redirect from %pI4 on %s about %pI4 ignored\n"
775 " Advised path = %pI4 -> %pI4\n",
776 &old_gw, dev->name, &new_gw,
783 static void ip_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
787 const struct iphdr *iph = (const struct iphdr *) skb->data;
788 int oif = skb->dev->ifindex;
789 u8 tos = RT_TOS(iph->tos);
790 u8 prot = iph->protocol;
791 u32 mark = skb->mark;
793 rt = (struct rtable *) dst;
795 __build_flow_key(&fl4, sk, iph, oif, tos, prot, mark, 0);
796 __ip_do_redirect(rt, skb, &fl4, true);
799 static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst)
801 struct rtable *rt = (struct rtable *)dst;
802 struct dst_entry *ret = dst;
805 if (dst->obsolete > 0) {
808 } else if ((rt->rt_flags & RTCF_REDIRECTED) ||
819 * 1. The first ip_rt_redirect_number redirects are sent
820 * with exponential backoff, then we stop sending them at all,
821 * assuming that the host ignores our redirects.
822 * 2. If we did not see packets requiring redirects
823 * during ip_rt_redirect_silence, we assume that the host
824 * forgot redirected route and start to send redirects again.
826 * This algorithm is much cheaper and more intelligent than dumb load limiting
829 * NOTE. Do not forget to inhibit load limiting for redirects (redundant)
830 * and "frag. need" (breaks PMTU discovery) in icmp.c.
833 void ip_rt_send_redirect(struct sk_buff *skb)
835 struct rtable *rt = skb_rtable(skb);
836 struct in_device *in_dev;
837 struct inet_peer *peer;
842 in_dev = __in_dev_get_rcu(rt->dst.dev);
843 if (!in_dev || !IN_DEV_TX_REDIRECTS(in_dev)) {
847 log_martians = IN_DEV_LOG_MARTIANS(in_dev);
850 net = dev_net(rt->dst.dev);
851 peer = inet_getpeer_v4(net->ipv4.peers, ip_hdr(skb)->saddr, 1);
853 icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST,
854 rt_nexthop(rt, ip_hdr(skb)->daddr));
858 /* No redirected packets during ip_rt_redirect_silence;
859 * reset the algorithm.
861 if (time_after(jiffies, peer->rate_last + ip_rt_redirect_silence))
862 peer->rate_tokens = 0;
864 /* Too many ignored redirects; do not send anything
865 * set dst.rate_last to the last seen redirected packet.
867 if (peer->rate_tokens >= ip_rt_redirect_number) {
868 peer->rate_last = jiffies;
872 /* Check for load limit; set rate_last to the latest sent
875 if (peer->rate_tokens == 0 ||
878 (ip_rt_redirect_load << peer->rate_tokens)))) {
879 __be32 gw = rt_nexthop(rt, ip_hdr(skb)->daddr);
881 icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST, gw);
882 peer->rate_last = jiffies;
884 #ifdef CONFIG_IP_ROUTE_VERBOSE
886 peer->rate_tokens == ip_rt_redirect_number)
887 net_warn_ratelimited("host %pI4/if%d ignores redirects for %pI4 to %pI4\n",
888 &ip_hdr(skb)->saddr, inet_iif(skb),
889 &ip_hdr(skb)->daddr, &gw);
896 static int ip_error(struct sk_buff *skb)
898 struct in_device *in_dev = __in_dev_get_rcu(skb->dev);
899 struct rtable *rt = skb_rtable(skb);
900 struct inet_peer *peer;
906 net = dev_net(rt->dst.dev);
907 if (!IN_DEV_FORWARD(in_dev)) {
908 switch (rt->dst.error) {
910 IP_INC_STATS_BH(net, IPSTATS_MIB_INADDRERRORS);
914 IP_INC_STATS_BH(net, IPSTATS_MIB_INNOROUTES);
920 switch (rt->dst.error) {
925 code = ICMP_HOST_UNREACH;
928 code = ICMP_NET_UNREACH;
929 IP_INC_STATS_BH(net, IPSTATS_MIB_INNOROUTES);
932 code = ICMP_PKT_FILTERED;
936 peer = inet_getpeer_v4(net->ipv4.peers, ip_hdr(skb)->saddr, 1);
941 peer->rate_tokens += now - peer->rate_last;
942 if (peer->rate_tokens > ip_rt_error_burst)
943 peer->rate_tokens = ip_rt_error_burst;
944 peer->rate_last = now;
945 if (peer->rate_tokens >= ip_rt_error_cost)
946 peer->rate_tokens -= ip_rt_error_cost;
952 icmp_send(skb, ICMP_DEST_UNREACH, code, 0);
958 static void __ip_rt_update_pmtu(struct rtable *rt, struct flowi4 *fl4, u32 mtu)
960 struct dst_entry *dst = &rt->dst;
961 struct fib_result res;
963 if (dst_metric_locked(dst, RTAX_MTU))
966 if (dst->dev->mtu < mtu)
969 if (rt->rt_pmtu && rt->rt_pmtu < mtu)
972 if (mtu < ip_rt_min_pmtu)
973 mtu = ip_rt_min_pmtu;
975 if (rt->rt_pmtu == mtu &&
976 time_before(jiffies, dst->expires - ip_rt_mtu_expires / 2))
980 if (fib_lookup(dev_net(dst->dev), fl4, &res) == 0) {
981 struct fib_nh *nh = &FIB_RES_NH(res);
983 update_or_create_fnhe(nh, fl4->daddr, 0, mtu,
984 jiffies + ip_rt_mtu_expires);
989 static void ip_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
990 struct sk_buff *skb, u32 mtu)
992 struct rtable *rt = (struct rtable *) dst;
995 ip_rt_build_flow_key(&fl4, sk, skb);
996 __ip_rt_update_pmtu(rt, &fl4, mtu);
999 void ipv4_update_pmtu(struct sk_buff *skb, struct net *net, u32 mtu,
1000 int oif, u32 mark, u8 protocol, int flow_flags)
1002 const struct iphdr *iph = (const struct iphdr *) skb->data;
1007 mark = IP4_REPLY_MARK(net, skb->mark);
1009 __build_flow_key(&fl4, NULL, iph, oif,
1010 RT_TOS(iph->tos), protocol, mark, flow_flags);
1011 rt = __ip_route_output_key(net, &fl4);
1013 __ip_rt_update_pmtu(rt, &fl4, mtu);
1017 EXPORT_SYMBOL_GPL(ipv4_update_pmtu);
1019 static void __ipv4_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, u32 mtu)
1021 const struct iphdr *iph = (const struct iphdr *) skb->data;
1025 __build_flow_key(&fl4, sk, iph, 0, 0, 0, 0, 0);
1027 if (!fl4.flowi4_mark)
1028 fl4.flowi4_mark = IP4_REPLY_MARK(sock_net(sk), skb->mark);
1030 rt = __ip_route_output_key(sock_net(sk), &fl4);
1032 __ip_rt_update_pmtu(rt, &fl4, mtu);
1037 void ipv4_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, u32 mtu)
1039 const struct iphdr *iph = (const struct iphdr *) skb->data;
1042 struct dst_entry *odst = NULL;
1047 if (!ip_sk_accept_pmtu(sk))
1050 odst = sk_dst_get(sk);
1052 if (sock_owned_by_user(sk) || !odst) {
1053 __ipv4_sk_update_pmtu(skb, sk, mtu);
1057 __build_flow_key(&fl4, sk, iph, 0, 0, 0, 0, 0);
1059 rt = (struct rtable *)odst;
1060 if (odst->obsolete && odst->ops->check(odst, 0) == NULL) {
1061 rt = ip_route_output_flow(sock_net(sk), &fl4, sk);
1068 __ip_rt_update_pmtu((struct rtable *) rt->dst.path, &fl4, mtu);
1070 if (!dst_check(&rt->dst, 0)) {
1072 dst_release(&rt->dst);
1074 rt = ip_route_output_flow(sock_net(sk), &fl4, sk);
1082 sk_dst_set(sk, &rt->dst);
1088 EXPORT_SYMBOL_GPL(ipv4_sk_update_pmtu);
1090 void ipv4_redirect(struct sk_buff *skb, struct net *net,
1091 int oif, u32 mark, u8 protocol, int flow_flags)
1093 const struct iphdr *iph = (const struct iphdr *) skb->data;
1097 __build_flow_key(&fl4, NULL, iph, oif,
1098 RT_TOS(iph->tos), protocol, mark, flow_flags);
1099 rt = __ip_route_output_key(net, &fl4);
1101 __ip_do_redirect(rt, skb, &fl4, false);
1105 EXPORT_SYMBOL_GPL(ipv4_redirect);
1107 void ipv4_sk_redirect(struct sk_buff *skb, struct sock *sk)
1109 const struct iphdr *iph = (const struct iphdr *) skb->data;
1113 __build_flow_key(&fl4, sk, iph, 0, 0, 0, 0, 0);
1114 rt = __ip_route_output_key(sock_net(sk), &fl4);
1116 __ip_do_redirect(rt, skb, &fl4, false);
1120 EXPORT_SYMBOL_GPL(ipv4_sk_redirect);
1122 static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie)
1124 struct rtable *rt = (struct rtable *) dst;
1126 /* All IPV4 dsts are created with ->obsolete set to the value
1127 * DST_OBSOLETE_FORCE_CHK which forces validation calls down
1128 * into this function always.
1130 * When a PMTU/redirect information update invalidates a route,
1131 * this is indicated by setting obsolete to DST_OBSOLETE_KILL or
1132 * DST_OBSOLETE_DEAD by dst_free().
1134 if (dst->obsolete != DST_OBSOLETE_FORCE_CHK || rt_is_expired(rt))
1139 static void ipv4_link_failure(struct sk_buff *skb)
1143 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0);
1145 rt = skb_rtable(skb);
1147 dst_set_expires(&rt->dst, 0);
1150 static int ip_rt_bug(struct sock *sk, struct sk_buff *skb)
1152 pr_debug("%s: %pI4 -> %pI4, %s\n",
1153 __func__, &ip_hdr(skb)->saddr, &ip_hdr(skb)->daddr,
1154 skb->dev ? skb->dev->name : "?");
1161 We do not cache source address of outgoing interface,
1162 because it is used only by IP RR, TS and SRR options,
1163 so that it out of fast path.
1165 BTW remember: "addr" is allowed to be not aligned
1169 void ip_rt_get_source(u8 *addr, struct sk_buff *skb, struct rtable *rt)
1173 if (rt_is_output_route(rt))
1174 src = ip_hdr(skb)->saddr;
1176 struct fib_result res;
1182 memset(&fl4, 0, sizeof(fl4));
1183 fl4.daddr = iph->daddr;
1184 fl4.saddr = iph->saddr;
1185 fl4.flowi4_tos = RT_TOS(iph->tos);
1186 fl4.flowi4_oif = rt->dst.dev->ifindex;
1187 fl4.flowi4_iif = skb->dev->ifindex;
1188 fl4.flowi4_mark = skb->mark;
1191 if (fib_lookup(dev_net(rt->dst.dev), &fl4, &res) == 0)
1192 src = FIB_RES_PREFSRC(dev_net(rt->dst.dev), res);
1194 src = inet_select_addr(rt->dst.dev,
1195 rt_nexthop(rt, iph->daddr),
1199 memcpy(addr, &src, 4);
1202 #ifdef CONFIG_IP_ROUTE_CLASSID
1203 static void set_class_tag(struct rtable *rt, u32 tag)
1205 if (!(rt->dst.tclassid & 0xFFFF))
1206 rt->dst.tclassid |= tag & 0xFFFF;
1207 if (!(rt->dst.tclassid & 0xFFFF0000))
1208 rt->dst.tclassid |= tag & 0xFFFF0000;
1212 static unsigned int ipv4_default_advmss(const struct dst_entry *dst)
1214 unsigned int advmss = dst_metric_raw(dst, RTAX_ADVMSS);
1217 advmss = max_t(unsigned int, dst->dev->mtu - 40,
1219 if (advmss > 65535 - 40)
1220 advmss = 65535 - 40;
1225 static unsigned int ipv4_mtu(const struct dst_entry *dst)
1227 const struct rtable *rt = (const struct rtable *) dst;
1228 unsigned int mtu = rt->rt_pmtu;
1230 if (!mtu || time_after_eq(jiffies, rt->dst.expires))
1231 mtu = dst_metric_raw(dst, RTAX_MTU);
1236 mtu = dst->dev->mtu;
1238 if (unlikely(dst_metric_locked(dst, RTAX_MTU))) {
1239 if (rt->rt_uses_gateway && mtu > 576)
1243 return min_t(unsigned int, mtu, IP_MAX_MTU);
1246 static struct fib_nh_exception *find_exception(struct fib_nh *nh, __be32 daddr)
1248 struct fnhe_hash_bucket *hash = rcu_dereference(nh->nh_exceptions);
1249 struct fib_nh_exception *fnhe;
1255 hval = fnhe_hashfun(daddr);
1257 for (fnhe = rcu_dereference(hash[hval].chain); fnhe;
1258 fnhe = rcu_dereference(fnhe->fnhe_next)) {
1259 if (fnhe->fnhe_daddr == daddr)
1265 static bool rt_bind_exception(struct rtable *rt, struct fib_nh_exception *fnhe,
1270 spin_lock_bh(&fnhe_lock);
1272 if (daddr == fnhe->fnhe_daddr) {
1273 struct rtable __rcu **porig;
1274 struct rtable *orig;
1275 int genid = fnhe_genid(dev_net(rt->dst.dev));
1277 if (rt_is_input_route(rt))
1278 porig = &fnhe->fnhe_rth_input;
1280 porig = &fnhe->fnhe_rth_output;
1281 orig = rcu_dereference(*porig);
1283 if (fnhe->fnhe_genid != genid) {
1284 fnhe->fnhe_genid = genid;
1286 fnhe->fnhe_pmtu = 0;
1287 fnhe->fnhe_expires = 0;
1288 fnhe_flush_routes(fnhe);
1291 fill_route_from_fnhe(rt, fnhe);
1292 if (!rt->rt_gateway)
1293 rt->rt_gateway = daddr;
1295 if (!(rt->dst.flags & DST_NOCACHE)) {
1296 rcu_assign_pointer(*porig, rt);
1302 fnhe->fnhe_stamp = jiffies;
1304 spin_unlock_bh(&fnhe_lock);
1309 static bool rt_cache_route(struct fib_nh *nh, struct rtable *rt)
1311 struct rtable *orig, *prev, **p;
1314 if (rt_is_input_route(rt)) {
1315 p = (struct rtable **)&nh->nh_rth_input;
1317 p = (struct rtable **)raw_cpu_ptr(nh->nh_pcpu_rth_output);
1321 prev = cmpxchg(p, orig, rt);
1331 static DEFINE_SPINLOCK(rt_uncached_lock);
1332 static LIST_HEAD(rt_uncached_list);
1334 static void rt_add_uncached_list(struct rtable *rt)
1336 spin_lock_bh(&rt_uncached_lock);
1337 list_add_tail(&rt->rt_uncached, &rt_uncached_list);
1338 spin_unlock_bh(&rt_uncached_lock);
1341 static void ipv4_dst_destroy(struct dst_entry *dst)
1343 struct rtable *rt = (struct rtable *) dst;
1345 if (!list_empty(&rt->rt_uncached)) {
1346 spin_lock_bh(&rt_uncached_lock);
1347 list_del(&rt->rt_uncached);
1348 spin_unlock_bh(&rt_uncached_lock);
1352 void rt_flush_dev(struct net_device *dev)
1354 if (!list_empty(&rt_uncached_list)) {
1355 struct net *net = dev_net(dev);
1358 spin_lock_bh(&rt_uncached_lock);
1359 list_for_each_entry(rt, &rt_uncached_list, rt_uncached) {
1360 if (rt->dst.dev != dev)
1362 rt->dst.dev = net->loopback_dev;
1363 dev_hold(rt->dst.dev);
1366 spin_unlock_bh(&rt_uncached_lock);
1370 static bool rt_cache_valid(const struct rtable *rt)
1373 rt->dst.obsolete == DST_OBSOLETE_FORCE_CHK &&
1377 static void rt_set_nexthop(struct rtable *rt, __be32 daddr,
1378 const struct fib_result *res,
1379 struct fib_nh_exception *fnhe,
1380 struct fib_info *fi, u16 type, u32 itag)
1382 bool cached = false;
1385 struct fib_nh *nh = &FIB_RES_NH(*res);
1387 if (nh->nh_gw && nh->nh_scope == RT_SCOPE_LINK) {
1388 rt->rt_gateway = nh->nh_gw;
1389 rt->rt_uses_gateway = 1;
1391 dst_init_metrics(&rt->dst, fi->fib_metrics, true);
1392 #ifdef CONFIG_IP_ROUTE_CLASSID
1393 rt->dst.tclassid = nh->nh_tclassid;
1396 cached = rt_bind_exception(rt, fnhe, daddr);
1397 else if (!(rt->dst.flags & DST_NOCACHE))
1398 cached = rt_cache_route(nh, rt);
1399 if (unlikely(!cached)) {
1400 /* Routes we intend to cache in nexthop exception or
1401 * FIB nexthop have the DST_NOCACHE bit clear.
1402 * However, if we are unsuccessful at storing this
1403 * route into the cache we really need to set it.
1405 rt->dst.flags |= DST_NOCACHE;
1406 if (!rt->rt_gateway)
1407 rt->rt_gateway = daddr;
1408 rt_add_uncached_list(rt);
1411 rt_add_uncached_list(rt);
1413 #ifdef CONFIG_IP_ROUTE_CLASSID
1414 #ifdef CONFIG_IP_MULTIPLE_TABLES
1415 set_class_tag(rt, res->tclassid);
1417 set_class_tag(rt, itag);
1421 static struct rtable *rt_dst_alloc(struct net_device *dev,
1422 bool nopolicy, bool noxfrm, bool will_cache)
1424 return dst_alloc(&ipv4_dst_ops, dev, 1, DST_OBSOLETE_FORCE_CHK,
1425 (will_cache ? 0 : (DST_HOST | DST_NOCACHE)) |
1426 (nopolicy ? DST_NOPOLICY : 0) |
1427 (noxfrm ? DST_NOXFRM : 0));
1430 /* called in rcu_read_lock() section */
1431 static int ip_route_input_mc(struct sk_buff *skb, __be32 daddr, __be32 saddr,
1432 u8 tos, struct net_device *dev, int our)
1435 struct in_device *in_dev = __in_dev_get_rcu(dev);
1439 /* Primary sanity checks. */
1444 if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr) ||
1445 skb->protocol != htons(ETH_P_IP))
1448 if (likely(!IN_DEV_ROUTE_LOCALNET(in_dev)))
1449 if (ipv4_is_loopback(saddr))
1452 if (ipv4_is_zeronet(saddr)) {
1453 if (!ipv4_is_local_multicast(daddr))
1456 err = fib_validate_source(skb, saddr, 0, tos, 0, dev,
1461 rth = rt_dst_alloc(dev_net(dev)->loopback_dev,
1462 IN_DEV_CONF_GET(in_dev, NOPOLICY), false, false);
1466 #ifdef CONFIG_IP_ROUTE_CLASSID
1467 rth->dst.tclassid = itag;
1469 rth->dst.output = ip_rt_bug;
1471 rth->rt_genid = rt_genid_ipv4(dev_net(dev));
1472 rth->rt_flags = RTCF_MULTICAST;
1473 rth->rt_type = RTN_MULTICAST;
1474 rth->rt_is_input= 1;
1477 rth->rt_gateway = 0;
1478 rth->rt_uses_gateway = 0;
1479 INIT_LIST_HEAD(&rth->rt_uncached);
1481 rth->dst.input= ip_local_deliver;
1482 rth->rt_flags |= RTCF_LOCAL;
1485 #ifdef CONFIG_IP_MROUTE
1486 if (!ipv4_is_local_multicast(daddr) && IN_DEV_MFORWARD(in_dev))
1487 rth->dst.input = ip_mr_input;
1489 RT_CACHE_STAT_INC(in_slow_mc);
1491 skb_dst_set(skb, &rth->dst);
1503 static void ip_handle_martian_source(struct net_device *dev,
1504 struct in_device *in_dev,
1505 struct sk_buff *skb,
1509 RT_CACHE_STAT_INC(in_martian_src);
1510 #ifdef CONFIG_IP_ROUTE_VERBOSE
1511 if (IN_DEV_LOG_MARTIANS(in_dev) && net_ratelimit()) {
1513 * RFC1812 recommendation, if source is martian,
1514 * the only hint is MAC header.
1516 pr_warn("martian source %pI4 from %pI4, on dev %s\n",
1517 &daddr, &saddr, dev->name);
1518 if (dev->hard_header_len && skb_mac_header_was_set(skb)) {
1519 print_hex_dump(KERN_WARNING, "ll header: ",
1520 DUMP_PREFIX_OFFSET, 16, 1,
1521 skb_mac_header(skb),
1522 dev->hard_header_len, true);
1528 /* called in rcu_read_lock() section */
1529 static int __mkroute_input(struct sk_buff *skb,
1530 const struct fib_result *res,
1531 struct in_device *in_dev,
1532 __be32 daddr, __be32 saddr, u32 tos)
1534 struct fib_nh_exception *fnhe;
1537 struct in_device *out_dev;
1538 unsigned int flags = 0;
1542 /* get a working reference to the output device */
1543 out_dev = __in_dev_get_rcu(FIB_RES_DEV(*res));
1544 if (out_dev == NULL) {
1545 net_crit_ratelimited("Bug in ip_route_input_slow(). Please report.\n");
1549 err = fib_validate_source(skb, saddr, daddr, tos, FIB_RES_OIF(*res),
1550 in_dev->dev, in_dev, &itag);
1552 ip_handle_martian_source(in_dev->dev, in_dev, skb, daddr,
1558 do_cache = res->fi && !itag;
1559 if (out_dev == in_dev && err && IN_DEV_TX_REDIRECTS(out_dev) &&
1560 skb->protocol == htons(ETH_P_IP) &&
1561 (IN_DEV_SHARED_MEDIA(out_dev) ||
1562 inet_addr_onlink(out_dev, saddr, FIB_RES_GW(*res))))
1563 IPCB(skb)->flags |= IPSKB_DOREDIRECT;
1565 if (skb->protocol != htons(ETH_P_IP)) {
1566 /* Not IP (i.e. ARP). Do not create route, if it is
1567 * invalid for proxy arp. DNAT routes are always valid.
1569 * Proxy arp feature have been extended to allow, ARP
1570 * replies back to the same interface, to support
1571 * Private VLAN switch technologies. See arp.c.
1573 if (out_dev == in_dev &&
1574 IN_DEV_PROXY_ARP_PVLAN(in_dev) == 0) {
1580 fnhe = find_exception(&FIB_RES_NH(*res), daddr);
1583 rth = rcu_dereference(fnhe->fnhe_rth_input);
1585 rth = rcu_dereference(FIB_RES_NH(*res).nh_rth_input);
1587 if (rt_cache_valid(rth)) {
1588 skb_dst_set_noref(skb, &rth->dst);
1593 rth = rt_dst_alloc(out_dev->dev,
1594 IN_DEV_CONF_GET(in_dev, NOPOLICY),
1595 IN_DEV_CONF_GET(out_dev, NOXFRM), do_cache);
1601 rth->rt_genid = rt_genid_ipv4(dev_net(rth->dst.dev));
1602 rth->rt_flags = flags;
1603 rth->rt_type = res->type;
1604 rth->rt_is_input = 1;
1607 rth->rt_gateway = 0;
1608 rth->rt_uses_gateway = 0;
1609 INIT_LIST_HEAD(&rth->rt_uncached);
1610 RT_CACHE_STAT_INC(in_slow_tot);
1612 rth->dst.input = ip_forward;
1613 rth->dst.output = ip_output;
1615 rt_set_nexthop(rth, daddr, res, fnhe, res->fi, res->type, itag);
1616 skb_dst_set(skb, &rth->dst);
1623 static int ip_mkroute_input(struct sk_buff *skb,
1624 struct fib_result *res,
1625 const struct flowi4 *fl4,
1626 struct in_device *in_dev,
1627 __be32 daddr, __be32 saddr, u32 tos)
1629 #ifdef CONFIG_IP_ROUTE_MULTIPATH
1630 if (res->fi && res->fi->fib_nhs > 1)
1631 fib_select_multipath(res);
1634 /* create a routing cache entry */
1635 return __mkroute_input(skb, res, in_dev, daddr, saddr, tos);
1639 * NOTE. We drop all the packets that has local source
1640 * addresses, because every properly looped back packet
1641 * must have correct destination already attached by output routine.
1643 * Such approach solves two big problems:
1644 * 1. Not simplex devices are handled properly.
1645 * 2. IP spoofing attempts are filtered with 100% of guarantee.
1646 * called with rcu_read_lock()
1649 static int ip_route_input_slow(struct sk_buff *skb, __be32 daddr, __be32 saddr,
1650 u8 tos, struct net_device *dev)
1652 struct fib_result res;
1653 struct in_device *in_dev = __in_dev_get_rcu(dev);
1655 unsigned int flags = 0;
1659 struct net *net = dev_net(dev);
1662 /* IP on this device is disabled. */
1667 /* Check for the most weird martians, which can be not detected
1671 if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr))
1672 goto martian_source;
1675 if (ipv4_is_lbcast(daddr) || (saddr == 0 && daddr == 0))
1678 /* Accept zero addresses only to limited broadcast;
1679 * I even do not know to fix it or not. Waiting for complains :-)
1681 if (ipv4_is_zeronet(saddr))
1682 goto martian_source;
1684 if (ipv4_is_zeronet(daddr))
1685 goto martian_destination;
1687 /* Following code try to avoid calling IN_DEV_NET_ROUTE_LOCALNET(),
1688 * and call it once if daddr or/and saddr are loopback addresses
1690 if (ipv4_is_loopback(daddr)) {
1691 if (!IN_DEV_NET_ROUTE_LOCALNET(in_dev, net))
1692 goto martian_destination;
1693 } else if (ipv4_is_loopback(saddr)) {
1694 if (!IN_DEV_NET_ROUTE_LOCALNET(in_dev, net))
1695 goto martian_source;
1699 * Now we are ready to route packet.
1702 fl4.flowi4_iif = dev->ifindex;
1703 fl4.flowi4_mark = skb->mark;
1704 fl4.flowi4_tos = tos;
1705 fl4.flowi4_scope = RT_SCOPE_UNIVERSE;
1708 err = fib_lookup(net, &fl4, &res);
1710 if (!IN_DEV_FORWARD(in_dev))
1711 err = -EHOSTUNREACH;
1715 if (res.type == RTN_BROADCAST)
1718 if (res.type == RTN_LOCAL) {
1719 err = fib_validate_source(skb, saddr, daddr, tos,
1720 0, dev, in_dev, &itag);
1722 goto martian_source_keep_err;
1726 if (!IN_DEV_FORWARD(in_dev)) {
1727 err = -EHOSTUNREACH;
1730 if (res.type != RTN_UNICAST)
1731 goto martian_destination;
1733 err = ip_mkroute_input(skb, &res, &fl4, in_dev, daddr, saddr, tos);
1737 if (skb->protocol != htons(ETH_P_IP))
1740 if (!ipv4_is_zeronet(saddr)) {
1741 err = fib_validate_source(skb, saddr, 0, tos, 0, dev,
1744 goto martian_source_keep_err;
1746 flags |= RTCF_BROADCAST;
1747 res.type = RTN_BROADCAST;
1748 RT_CACHE_STAT_INC(in_brd);
1754 rth = rcu_dereference(FIB_RES_NH(res).nh_rth_input);
1755 if (rt_cache_valid(rth)) {
1756 skb_dst_set_noref(skb, &rth->dst);
1764 rth = rt_dst_alloc(net->loopback_dev,
1765 IN_DEV_CONF_GET(in_dev, NOPOLICY), false, do_cache);
1769 rth->dst.input= ip_local_deliver;
1770 rth->dst.output= ip_rt_bug;
1771 #ifdef CONFIG_IP_ROUTE_CLASSID
1772 rth->dst.tclassid = itag;
1775 rth->rt_genid = rt_genid_ipv4(net);
1776 rth->rt_flags = flags|RTCF_LOCAL;
1777 rth->rt_type = res.type;
1778 rth->rt_is_input = 1;
1781 rth->rt_gateway = 0;
1782 rth->rt_uses_gateway = 0;
1783 INIT_LIST_HEAD(&rth->rt_uncached);
1784 RT_CACHE_STAT_INC(in_slow_tot);
1785 if (res.type == RTN_UNREACHABLE) {
1786 rth->dst.input= ip_error;
1787 rth->dst.error= -err;
1788 rth->rt_flags &= ~RTCF_LOCAL;
1791 if (unlikely(!rt_cache_route(&FIB_RES_NH(res), rth))) {
1792 rth->dst.flags |= DST_NOCACHE;
1793 rt_add_uncached_list(rth);
1796 skb_dst_set(skb, &rth->dst);
1801 RT_CACHE_STAT_INC(in_no_route);
1802 res.type = RTN_UNREACHABLE;
1807 * Do not cache martian addresses: they should be logged (RFC1812)
1809 martian_destination:
1810 RT_CACHE_STAT_INC(in_martian_dst);
1811 #ifdef CONFIG_IP_ROUTE_VERBOSE
1812 if (IN_DEV_LOG_MARTIANS(in_dev))
1813 net_warn_ratelimited("martian destination %pI4 from %pI4, dev %s\n",
1814 &daddr, &saddr, dev->name);
1827 martian_source_keep_err:
1828 ip_handle_martian_source(dev, in_dev, skb, daddr, saddr);
1832 int ip_route_input_noref(struct sk_buff *skb, __be32 daddr, __be32 saddr,
1833 u8 tos, struct net_device *dev)
1839 /* Multicast recognition logic is moved from route cache to here.
1840 The problem was that too many Ethernet cards have broken/missing
1841 hardware multicast filters :-( As result the host on multicasting
1842 network acquires a lot of useless route cache entries, sort of
1843 SDR messages from all the world. Now we try to get rid of them.
1844 Really, provided software IP multicast filter is organized
1845 reasonably (at least, hashed), it does not result in a slowdown
1846 comparing with route cache reject entries.
1847 Note, that multicast routers are not affected, because
1848 route cache entry is created eventually.
1850 if (ipv4_is_multicast(daddr)) {
1851 struct in_device *in_dev = __in_dev_get_rcu(dev);
1854 int our = ip_check_mc_rcu(in_dev, daddr, saddr,
1855 ip_hdr(skb)->protocol);
1857 #ifdef CONFIG_IP_MROUTE
1859 (!ipv4_is_local_multicast(daddr) &&
1860 IN_DEV_MFORWARD(in_dev))
1863 int res = ip_route_input_mc(skb, daddr, saddr,
1872 res = ip_route_input_slow(skb, daddr, saddr, tos, dev);
1876 EXPORT_SYMBOL(ip_route_input_noref);
1878 /* called with rcu_read_lock() */
1879 static struct rtable *__mkroute_output(const struct fib_result *res,
1880 const struct flowi4 *fl4, int orig_oif,
1881 struct net_device *dev_out,
1884 struct fib_info *fi = res->fi;
1885 struct fib_nh_exception *fnhe;
1886 struct in_device *in_dev;
1887 u16 type = res->type;
1891 in_dev = __in_dev_get_rcu(dev_out);
1893 return ERR_PTR(-EINVAL);
1895 if (likely(!IN_DEV_ROUTE_LOCALNET(in_dev)))
1896 if (ipv4_is_loopback(fl4->saddr) && !(dev_out->flags & IFF_LOOPBACK))
1897 return ERR_PTR(-EINVAL);
1899 if (ipv4_is_lbcast(fl4->daddr))
1900 type = RTN_BROADCAST;
1901 else if (ipv4_is_multicast(fl4->daddr))
1902 type = RTN_MULTICAST;
1903 else if (ipv4_is_zeronet(fl4->daddr))
1904 return ERR_PTR(-EINVAL);
1906 if (dev_out->flags & IFF_LOOPBACK)
1907 flags |= RTCF_LOCAL;
1910 if (type == RTN_BROADCAST) {
1911 flags |= RTCF_BROADCAST | RTCF_LOCAL;
1913 } else if (type == RTN_MULTICAST) {
1914 flags |= RTCF_MULTICAST | RTCF_LOCAL;
1915 if (!ip_check_mc_rcu(in_dev, fl4->daddr, fl4->saddr,
1917 flags &= ~RTCF_LOCAL;
1920 /* If multicast route do not exist use
1921 * default one, but do not gateway in this case.
1924 if (fi && res->prefixlen < 4)
1929 do_cache &= fi != NULL;
1931 struct rtable __rcu **prth;
1932 struct fib_nh *nh = &FIB_RES_NH(*res);
1934 fnhe = find_exception(nh, fl4->daddr);
1936 prth = &fnhe->fnhe_rth_output;
1938 if (unlikely(fl4->flowi4_flags &
1939 FLOWI_FLAG_KNOWN_NH &&
1941 nh->nh_scope == RT_SCOPE_LINK))) {
1945 prth = raw_cpu_ptr(nh->nh_pcpu_rth_output);
1947 rth = rcu_dereference(*prth);
1948 if (rt_cache_valid(rth)) {
1949 dst_hold(&rth->dst);
1955 rth = rt_dst_alloc(dev_out,
1956 IN_DEV_CONF_GET(in_dev, NOPOLICY),
1957 IN_DEV_CONF_GET(in_dev, NOXFRM),
1960 return ERR_PTR(-ENOBUFS);
1962 rth->dst.output = ip_output;
1964 rth->rt_genid = rt_genid_ipv4(dev_net(dev_out));
1965 rth->rt_flags = flags;
1966 rth->rt_type = type;
1967 rth->rt_is_input = 0;
1968 rth->rt_iif = orig_oif ? : 0;
1970 rth->rt_gateway = 0;
1971 rth->rt_uses_gateway = 0;
1972 INIT_LIST_HEAD(&rth->rt_uncached);
1974 RT_CACHE_STAT_INC(out_slow_tot);
1976 if (flags & RTCF_LOCAL)
1977 rth->dst.input = ip_local_deliver;
1978 if (flags & (RTCF_BROADCAST | RTCF_MULTICAST)) {
1979 if (flags & RTCF_LOCAL &&
1980 !(dev_out->flags & IFF_LOOPBACK)) {
1981 rth->dst.output = ip_mc_output;
1982 RT_CACHE_STAT_INC(out_slow_mc);
1984 #ifdef CONFIG_IP_MROUTE
1985 if (type == RTN_MULTICAST) {
1986 if (IN_DEV_MFORWARD(in_dev) &&
1987 !ipv4_is_local_multicast(fl4->daddr)) {
1988 rth->dst.input = ip_mr_input;
1989 rth->dst.output = ip_mc_output;
1995 rt_set_nexthop(rth, fl4->daddr, res, fnhe, fi, type, 0);
2001 * Major route resolver routine.
2004 struct rtable *__ip_route_output_key(struct net *net, struct flowi4 *fl4)
2006 struct net_device *dev_out = NULL;
2007 __u8 tos = RT_FL_TOS(fl4);
2008 unsigned int flags = 0;
2009 struct fib_result res;
2017 orig_oif = fl4->flowi4_oif;
2019 fl4->flowi4_iif = LOOPBACK_IFINDEX;
2020 fl4->flowi4_tos = tos & IPTOS_RT_MASK;
2021 fl4->flowi4_scope = ((tos & RTO_ONLINK) ?
2022 RT_SCOPE_LINK : RT_SCOPE_UNIVERSE);
2026 rth = ERR_PTR(-EINVAL);
2027 if (ipv4_is_multicast(fl4->saddr) ||
2028 ipv4_is_lbcast(fl4->saddr) ||
2029 ipv4_is_zeronet(fl4->saddr))
2032 /* I removed check for oif == dev_out->oif here.
2033 It was wrong for two reasons:
2034 1. ip_dev_find(net, saddr) can return wrong iface, if saddr
2035 is assigned to multiple interfaces.
2036 2. Moreover, we are allowed to send packets with saddr
2037 of another iface. --ANK
2040 if (fl4->flowi4_oif == 0 &&
2041 (ipv4_is_multicast(fl4->daddr) ||
2042 ipv4_is_lbcast(fl4->daddr))) {
2043 /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
2044 dev_out = __ip_dev_find(net, fl4->saddr, false);
2045 if (dev_out == NULL)
2048 /* Special hack: user can direct multicasts
2049 and limited broadcast via necessary interface
2050 without fiddling with IP_MULTICAST_IF or IP_PKTINFO.
2051 This hack is not just for fun, it allows
2052 vic,vat and friends to work.
2053 They bind socket to loopback, set ttl to zero
2054 and expect that it will work.
2055 From the viewpoint of routing cache they are broken,
2056 because we are not allowed to build multicast path
2057 with loopback source addr (look, routing cache
2058 cannot know, that ttl is zero, so that packet
2059 will not leave this host and route is valid).
2060 Luckily, this hack is good workaround.
2063 fl4->flowi4_oif = dev_out->ifindex;
2067 if (!(fl4->flowi4_flags & FLOWI_FLAG_ANYSRC)) {
2068 /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
2069 if (!__ip_dev_find(net, fl4->saddr, false))
2075 if (fl4->flowi4_oif) {
2076 dev_out = dev_get_by_index_rcu(net, fl4->flowi4_oif);
2077 rth = ERR_PTR(-ENODEV);
2078 if (dev_out == NULL)
2081 /* RACE: Check return value of inet_select_addr instead. */
2082 if (!(dev_out->flags & IFF_UP) || !__in_dev_get_rcu(dev_out)) {
2083 rth = ERR_PTR(-ENETUNREACH);
2086 if (ipv4_is_local_multicast(fl4->daddr) ||
2087 ipv4_is_lbcast(fl4->daddr)) {
2089 fl4->saddr = inet_select_addr(dev_out, 0,
2094 if (ipv4_is_multicast(fl4->daddr))
2095 fl4->saddr = inet_select_addr(dev_out, 0,
2097 else if (!fl4->daddr)
2098 fl4->saddr = inet_select_addr(dev_out, 0,
2104 fl4->daddr = fl4->saddr;
2106 fl4->daddr = fl4->saddr = htonl(INADDR_LOOPBACK);
2107 dev_out = net->loopback_dev;
2108 fl4->flowi4_oif = LOOPBACK_IFINDEX;
2109 res.type = RTN_LOCAL;
2110 flags |= RTCF_LOCAL;
2114 if (fib_lookup(net, fl4, &res)) {
2117 if (fl4->flowi4_oif) {
2118 /* Apparently, routing tables are wrong. Assume,
2119 that the destination is on link.
2122 Because we are allowed to send to iface
2123 even if it has NO routes and NO assigned
2124 addresses. When oif is specified, routing
2125 tables are looked up with only one purpose:
2126 to catch if destination is gatewayed, rather than
2127 direct. Moreover, if MSG_DONTROUTE is set,
2128 we send packet, ignoring both routing tables
2129 and ifaddr state. --ANK
2132 We could make it even if oif is unknown,
2133 likely IPv6, but we do not.
2136 if (fl4->saddr == 0)
2137 fl4->saddr = inet_select_addr(dev_out, 0,
2139 res.type = RTN_UNICAST;
2142 rth = ERR_PTR(-ENETUNREACH);
2146 if (res.type == RTN_LOCAL) {
2148 if (res.fi->fib_prefsrc)
2149 fl4->saddr = res.fi->fib_prefsrc;
2151 fl4->saddr = fl4->daddr;
2153 dev_out = net->loopback_dev;
2154 fl4->flowi4_oif = dev_out->ifindex;
2155 flags |= RTCF_LOCAL;
2159 #ifdef CONFIG_IP_ROUTE_MULTIPATH
2160 if (res.fi->fib_nhs > 1 && fl4->flowi4_oif == 0)
2161 fib_select_multipath(&res);
2164 if (!res.prefixlen &&
2165 res.table->tb_num_default > 1 &&
2166 res.type == RTN_UNICAST && !fl4->flowi4_oif)
2167 fib_select_default(&res);
2170 fl4->saddr = FIB_RES_PREFSRC(net, res);
2172 dev_out = FIB_RES_DEV(res);
2173 fl4->flowi4_oif = dev_out->ifindex;
2177 rth = __mkroute_output(&res, fl4, orig_oif, dev_out, flags);
2183 EXPORT_SYMBOL_GPL(__ip_route_output_key);
2185 static struct dst_entry *ipv4_blackhole_dst_check(struct dst_entry *dst, u32 cookie)
2190 static unsigned int ipv4_blackhole_mtu(const struct dst_entry *dst)
2192 unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
2194 return mtu ? : dst->dev->mtu;
2197 static void ipv4_rt_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,
2198 struct sk_buff *skb, u32 mtu)
2202 static void ipv4_rt_blackhole_redirect(struct dst_entry *dst, struct sock *sk,
2203 struct sk_buff *skb)
2207 static u32 *ipv4_rt_blackhole_cow_metrics(struct dst_entry *dst,
2213 static struct dst_ops ipv4_dst_blackhole_ops = {
2215 .protocol = cpu_to_be16(ETH_P_IP),
2216 .check = ipv4_blackhole_dst_check,
2217 .mtu = ipv4_blackhole_mtu,
2218 .default_advmss = ipv4_default_advmss,
2219 .update_pmtu = ipv4_rt_blackhole_update_pmtu,
2220 .redirect = ipv4_rt_blackhole_redirect,
2221 .cow_metrics = ipv4_rt_blackhole_cow_metrics,
2222 .neigh_lookup = ipv4_neigh_lookup,
2225 struct dst_entry *ipv4_blackhole_route(struct net *net, struct dst_entry *dst_orig)
2227 struct rtable *ort = (struct rtable *) dst_orig;
2230 rt = dst_alloc(&ipv4_dst_blackhole_ops, NULL, 1, DST_OBSOLETE_NONE, 0);
2232 struct dst_entry *new = &rt->dst;
2235 new->input = dst_discard;
2236 new->output = dst_discard_sk;
2238 new->dev = ort->dst.dev;
2242 rt->rt_is_input = ort->rt_is_input;
2243 rt->rt_iif = ort->rt_iif;
2244 rt->rt_pmtu = ort->rt_pmtu;
2246 rt->rt_genid = rt_genid_ipv4(net);
2247 rt->rt_flags = ort->rt_flags;
2248 rt->rt_type = ort->rt_type;
2249 rt->rt_gateway = ort->rt_gateway;
2250 rt->rt_uses_gateway = ort->rt_uses_gateway;
2252 INIT_LIST_HEAD(&rt->rt_uncached);
2257 dst_release(dst_orig);
2259 return rt ? &rt->dst : ERR_PTR(-ENOMEM);
2262 struct rtable *ip_route_output_flow(struct net *net, struct flowi4 *flp4,
2265 struct rtable *rt = __ip_route_output_key(net, flp4);
2270 if (flp4->flowi4_proto)
2271 rt = (struct rtable *)xfrm_lookup_route(net, &rt->dst,
2272 flowi4_to_flowi(flp4),
2277 EXPORT_SYMBOL_GPL(ip_route_output_flow);
2279 static int rt_fill_info(struct net *net, __be32 dst, __be32 src,
2280 struct flowi4 *fl4, struct sk_buff *skb, u32 portid,
2281 u32 seq, int event, int nowait, unsigned int flags)
2283 struct rtable *rt = skb_rtable(skb);
2285 struct nlmsghdr *nlh;
2286 unsigned long expires = 0;
2288 u32 metrics[RTAX_MAX];
2290 nlh = nlmsg_put(skb, portid, seq, event, sizeof(*r), flags);
2294 r = nlmsg_data(nlh);
2295 r->rtm_family = AF_INET;
2296 r->rtm_dst_len = 32;
2298 r->rtm_tos = fl4->flowi4_tos;
2299 r->rtm_table = RT_TABLE_MAIN;
2300 if (nla_put_u32(skb, RTA_TABLE, RT_TABLE_MAIN))
2301 goto nla_put_failure;
2302 r->rtm_type = rt->rt_type;
2303 r->rtm_scope = RT_SCOPE_UNIVERSE;
2304 r->rtm_protocol = RTPROT_UNSPEC;
2305 r->rtm_flags = (rt->rt_flags & ~0xFFFF) | RTM_F_CLONED;
2306 if (rt->rt_flags & RTCF_NOTIFY)
2307 r->rtm_flags |= RTM_F_NOTIFY;
2308 if (IPCB(skb)->flags & IPSKB_DOREDIRECT)
2309 r->rtm_flags |= RTCF_DOREDIRECT;
2311 if (nla_put_be32(skb, RTA_DST, dst))
2312 goto nla_put_failure;
2314 r->rtm_src_len = 32;
2315 if (nla_put_be32(skb, RTA_SRC, src))
2316 goto nla_put_failure;
2319 nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
2320 goto nla_put_failure;
2321 #ifdef CONFIG_IP_ROUTE_CLASSID
2322 if (rt->dst.tclassid &&
2323 nla_put_u32(skb, RTA_FLOW, rt->dst.tclassid))
2324 goto nla_put_failure;
2326 if (!rt_is_input_route(rt) &&
2327 fl4->saddr != src) {
2328 if (nla_put_be32(skb, RTA_PREFSRC, fl4->saddr))
2329 goto nla_put_failure;
2331 if (rt->rt_uses_gateway &&
2332 nla_put_be32(skb, RTA_GATEWAY, rt->rt_gateway))
2333 goto nla_put_failure;
2335 expires = rt->dst.expires;
2337 unsigned long now = jiffies;
2339 if (time_before(now, expires))
2345 memcpy(metrics, dst_metrics_ptr(&rt->dst), sizeof(metrics));
2346 if (rt->rt_pmtu && expires)
2347 metrics[RTAX_MTU - 1] = rt->rt_pmtu;
2348 if (rtnetlink_put_metrics(skb, metrics) < 0)
2349 goto nla_put_failure;
2351 if (fl4->flowi4_mark &&
2352 nla_put_u32(skb, RTA_MARK, fl4->flowi4_mark))
2353 goto nla_put_failure;
2355 error = rt->dst.error;
2357 if (rt_is_input_route(rt)) {
2358 #ifdef CONFIG_IP_MROUTE
2359 if (ipv4_is_multicast(dst) && !ipv4_is_local_multicast(dst) &&
2360 IPV4_DEVCONF_ALL(net, MC_FORWARDING)) {
2361 int err = ipmr_get_route(net, skb,
2362 fl4->saddr, fl4->daddr,
2368 goto nla_put_failure;
2370 if (err == -EMSGSIZE)
2371 goto nla_put_failure;
2377 if (nla_put_u32(skb, RTA_IIF, skb->dev->ifindex))
2378 goto nla_put_failure;
2381 if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, error) < 0)
2382 goto nla_put_failure;
2384 return nlmsg_end(skb, nlh);
2387 nlmsg_cancel(skb, nlh);
2391 static int inet_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh)
2393 struct net *net = sock_net(in_skb->sk);
2395 struct nlattr *tb[RTA_MAX+1];
2396 struct rtable *rt = NULL;
2403 struct sk_buff *skb;
2405 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv4_policy);
2409 rtm = nlmsg_data(nlh);
2411 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
2417 /* Reserve room for dummy headers, this skb can pass
2418 through good chunk of routing engine.
2420 skb_reset_mac_header(skb);
2421 skb_reset_network_header(skb);
2423 /* Bugfix: need to give ip_route_input enough of an IP header to not gag. */
2424 ip_hdr(skb)->protocol = IPPROTO_ICMP;
2425 skb_reserve(skb, MAX_HEADER + sizeof(struct iphdr));
2427 src = tb[RTA_SRC] ? nla_get_be32(tb[RTA_SRC]) : 0;
2428 dst = tb[RTA_DST] ? nla_get_be32(tb[RTA_DST]) : 0;
2429 iif = tb[RTA_IIF] ? nla_get_u32(tb[RTA_IIF]) : 0;
2430 mark = tb[RTA_MARK] ? nla_get_u32(tb[RTA_MARK]) : 0;
2432 memset(&fl4, 0, sizeof(fl4));
2435 fl4.flowi4_tos = rtm->rtm_tos;
2436 fl4.flowi4_oif = tb[RTA_OIF] ? nla_get_u32(tb[RTA_OIF]) : 0;
2437 fl4.flowi4_mark = mark;
2440 struct net_device *dev;
2442 dev = __dev_get_by_index(net, iif);
2448 skb->protocol = htons(ETH_P_IP);
2452 err = ip_route_input(skb, dst, src, rtm->rtm_tos, dev);
2455 rt = skb_rtable(skb);
2456 if (err == 0 && rt->dst.error)
2457 err = -rt->dst.error;
2459 rt = ip_route_output_key(net, &fl4);
2469 skb_dst_set(skb, &rt->dst);
2470 if (rtm->rtm_flags & RTM_F_NOTIFY)
2471 rt->rt_flags |= RTCF_NOTIFY;
2473 err = rt_fill_info(net, dst, src, &fl4, skb,
2474 NETLINK_CB(in_skb).portid, nlh->nlmsg_seq,
2475 RTM_NEWROUTE, 0, 0);
2479 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
2488 void ip_rt_multicast_event(struct in_device *in_dev)
2490 rt_cache_flush(dev_net(in_dev->dev));
2493 #ifdef CONFIG_SYSCTL
2494 static int ip_rt_gc_timeout __read_mostly = RT_GC_TIMEOUT;
2495 static int ip_rt_gc_interval __read_mostly = 60 * HZ;
2496 static int ip_rt_gc_min_interval __read_mostly = HZ / 2;
2497 static int ip_rt_gc_elasticity __read_mostly = 8;
2499 static int ipv4_sysctl_rtcache_flush(struct ctl_table *__ctl, int write,
2500 void __user *buffer,
2501 size_t *lenp, loff_t *ppos)
2503 struct net *net = (struct net *)__ctl->extra1;
2506 rt_cache_flush(net);
2507 fnhe_genid_bump(net);
2514 static struct ctl_table ipv4_route_table[] = {
2516 .procname = "gc_thresh",
2517 .data = &ipv4_dst_ops.gc_thresh,
2518 .maxlen = sizeof(int),
2520 .proc_handler = proc_dointvec,
2523 .procname = "max_size",
2524 .data = &ip_rt_max_size,
2525 .maxlen = sizeof(int),
2527 .proc_handler = proc_dointvec,
2530 /* Deprecated. Use gc_min_interval_ms */
2532 .procname = "gc_min_interval",
2533 .data = &ip_rt_gc_min_interval,
2534 .maxlen = sizeof(int),
2536 .proc_handler = proc_dointvec_jiffies,
2539 .procname = "gc_min_interval_ms",
2540 .data = &ip_rt_gc_min_interval,
2541 .maxlen = sizeof(int),
2543 .proc_handler = proc_dointvec_ms_jiffies,
2546 .procname = "gc_timeout",
2547 .data = &ip_rt_gc_timeout,
2548 .maxlen = sizeof(int),
2550 .proc_handler = proc_dointvec_jiffies,
2553 .procname = "gc_interval",
2554 .data = &ip_rt_gc_interval,
2555 .maxlen = sizeof(int),
2557 .proc_handler = proc_dointvec_jiffies,
2560 .procname = "redirect_load",
2561 .data = &ip_rt_redirect_load,
2562 .maxlen = sizeof(int),
2564 .proc_handler = proc_dointvec,
2567 .procname = "redirect_number",
2568 .data = &ip_rt_redirect_number,
2569 .maxlen = sizeof(int),
2571 .proc_handler = proc_dointvec,
2574 .procname = "redirect_silence",
2575 .data = &ip_rt_redirect_silence,
2576 .maxlen = sizeof(int),
2578 .proc_handler = proc_dointvec,
2581 .procname = "error_cost",
2582 .data = &ip_rt_error_cost,
2583 .maxlen = sizeof(int),
2585 .proc_handler = proc_dointvec,
2588 .procname = "error_burst",
2589 .data = &ip_rt_error_burst,
2590 .maxlen = sizeof(int),
2592 .proc_handler = proc_dointvec,
2595 .procname = "gc_elasticity",
2596 .data = &ip_rt_gc_elasticity,
2597 .maxlen = sizeof(int),
2599 .proc_handler = proc_dointvec,
2602 .procname = "mtu_expires",
2603 .data = &ip_rt_mtu_expires,
2604 .maxlen = sizeof(int),
2606 .proc_handler = proc_dointvec_jiffies,
2609 .procname = "min_pmtu",
2610 .data = &ip_rt_min_pmtu,
2611 .maxlen = sizeof(int),
2613 .proc_handler = proc_dointvec,
2616 .procname = "min_adv_mss",
2617 .data = &ip_rt_min_advmss,
2618 .maxlen = sizeof(int),
2620 .proc_handler = proc_dointvec,
2625 static struct ctl_table ipv4_route_flush_table[] = {
2627 .procname = "flush",
2628 .maxlen = sizeof(int),
2630 .proc_handler = ipv4_sysctl_rtcache_flush,
2635 static __net_init int sysctl_route_net_init(struct net *net)
2637 struct ctl_table *tbl;
2639 tbl = ipv4_route_flush_table;
2640 if (!net_eq(net, &init_net)) {
2641 tbl = kmemdup(tbl, sizeof(ipv4_route_flush_table), GFP_KERNEL);
2645 /* Don't export sysctls to unprivileged users */
2646 if (net->user_ns != &init_user_ns)
2647 tbl[0].procname = NULL;
2649 tbl[0].extra1 = net;
2651 net->ipv4.route_hdr = register_net_sysctl(net, "net/ipv4/route", tbl);
2652 if (net->ipv4.route_hdr == NULL)
2657 if (tbl != ipv4_route_flush_table)
2663 static __net_exit void sysctl_route_net_exit(struct net *net)
2665 struct ctl_table *tbl;
2667 tbl = net->ipv4.route_hdr->ctl_table_arg;
2668 unregister_net_sysctl_table(net->ipv4.route_hdr);
2669 BUG_ON(tbl == ipv4_route_flush_table);
2673 static __net_initdata struct pernet_operations sysctl_route_ops = {
2674 .init = sysctl_route_net_init,
2675 .exit = sysctl_route_net_exit,
2679 static __net_init int rt_genid_init(struct net *net)
2681 atomic_set(&net->ipv4.rt_genid, 0);
2682 atomic_set(&net->fnhe_genid, 0);
2683 get_random_bytes(&net->ipv4.dev_addr_genid,
2684 sizeof(net->ipv4.dev_addr_genid));
2688 static __net_initdata struct pernet_operations rt_genid_ops = {
2689 .init = rt_genid_init,
2692 static int __net_init ipv4_inetpeer_init(struct net *net)
2694 struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
2698 inet_peer_base_init(bp);
2699 net->ipv4.peers = bp;
2703 static void __net_exit ipv4_inetpeer_exit(struct net *net)
2705 struct inet_peer_base *bp = net->ipv4.peers;
2707 net->ipv4.peers = NULL;
2708 inetpeer_invalidate_tree(bp);
2712 static __net_initdata struct pernet_operations ipv4_inetpeer_ops = {
2713 .init = ipv4_inetpeer_init,
2714 .exit = ipv4_inetpeer_exit,
2717 #ifdef CONFIG_IP_ROUTE_CLASSID
2718 struct ip_rt_acct __percpu *ip_rt_acct __read_mostly;
2719 #endif /* CONFIG_IP_ROUTE_CLASSID */
2721 int __init ip_rt_init(void)
2725 ip_idents = kmalloc(IP_IDENTS_SZ * sizeof(*ip_idents), GFP_KERNEL);
2727 panic("IP: failed to allocate ip_idents\n");
2729 prandom_bytes(ip_idents, IP_IDENTS_SZ * sizeof(*ip_idents));
2731 #ifdef CONFIG_IP_ROUTE_CLASSID
2732 ip_rt_acct = __alloc_percpu(256 * sizeof(struct ip_rt_acct), __alignof__(struct ip_rt_acct));
2734 panic("IP: failed to allocate ip_rt_acct\n");
2737 ipv4_dst_ops.kmem_cachep =
2738 kmem_cache_create("ip_dst_cache", sizeof(struct rtable), 0,
2739 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
2741 ipv4_dst_blackhole_ops.kmem_cachep = ipv4_dst_ops.kmem_cachep;
2743 if (dst_entries_init(&ipv4_dst_ops) < 0)
2744 panic("IP: failed to allocate ipv4_dst_ops counter\n");
2746 if (dst_entries_init(&ipv4_dst_blackhole_ops) < 0)
2747 panic("IP: failed to allocate ipv4_dst_blackhole_ops counter\n");
2749 ipv4_dst_ops.gc_thresh = ~0;
2750 ip_rt_max_size = INT_MAX;
2755 if (ip_rt_proc_init())
2756 pr_err("Unable to create route proc files\n");
2761 rtnl_register(PF_INET, RTM_GETROUTE, inet_rtm_getroute, NULL, NULL);
2763 #ifdef CONFIG_SYSCTL
2764 register_pernet_subsys(&sysctl_route_ops);
2766 register_pernet_subsys(&rt_genid_ops);
2767 register_pernet_subsys(&ipv4_inetpeer_ops);
2771 #ifdef CONFIG_SYSCTL
2773 * We really need to sanitize the damn ipv4 init order, then all
2774 * this nonsense will go away.
2776 void __init ip_static_sysctl_init(void)
2778 register_net_sysctl(&init_net, "net/ipv4/route", ipv4_route_table);