source: src/linux/universal/linux-3.18/net/ipv4/route.c @ 31869

Last change on this file since 31869 was 31869, checked in by brainslayer, 6 weeks ago

update

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