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