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