LCOV - code coverage report
Current view: top level - net/ipv4 - route.c (source / functions) Hit Total Coverage
Test: Real Lines: 455 1279 35.6 %
Date: 2020-10-17 15:46:43 Functions: 6 94 6.4 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

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

Generated by: LCOV version 1.14