net/ipv4/route.c

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