net/ipv4/route.c

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