LCOV - code coverage report
Current view: top level - net/ipv4 - devinet.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 500 1360 36.8 %
Date: 2022-04-01 14:58:12 Functions: 28 57 49.1 %
Branches: 198 975 20.3 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-or-later
       2                 :            : /*
       3                 :            :  *      NET3    IP device support routines.
       4                 :            :  *
       5                 :            :  *      Derived from the IP parts of dev.c 1.0.19
       6                 :            :  *              Authors:        Ross Biro
       7                 :            :  *                              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
       8                 :            :  *                              Mark Evans, <evansmp@uhura.aston.ac.uk>
       9                 :            :  *
      10                 :            :  *      Additional Authors:
      11                 :            :  *              Alan Cox, <gw4pts@gw4pts.ampr.org>
      12                 :            :  *              Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
      13                 :            :  *
      14                 :            :  *      Changes:
      15                 :            :  *              Alexey Kuznetsov:       pa_* fields are replaced with ifaddr
      16                 :            :  *                                      lists.
      17                 :            :  *              Cyrus Durgin:           updated for kmod
      18                 :            :  *              Matthias Andree:        in devinet_ioctl, compare label and
      19                 :            :  *                                      address (4.4BSD alias style support),
      20                 :            :  *                                      fall back to comparing just the label
      21                 :            :  *                                      if no match found.
      22                 :            :  */
      23                 :            : 
      24                 :            : 
      25                 :            : #include <linux/uaccess.h>
      26                 :            : #include <linux/bitops.h>
      27                 :            : #include <linux/capability.h>
      28                 :            : #include <linux/module.h>
      29                 :            : #include <linux/types.h>
      30                 :            : #include <linux/kernel.h>
      31                 :            : #include <linux/sched/signal.h>
      32                 :            : #include <linux/string.h>
      33                 :            : #include <linux/mm.h>
      34                 :            : #include <linux/socket.h>
      35                 :            : #include <linux/sockios.h>
      36                 :            : #include <linux/in.h>
      37                 :            : #include <linux/errno.h>
      38                 :            : #include <linux/interrupt.h>
      39                 :            : #include <linux/if_addr.h>
      40                 :            : #include <linux/if_ether.h>
      41                 :            : #include <linux/inet.h>
      42                 :            : #include <linux/netdevice.h>
      43                 :            : #include <linux/etherdevice.h>
      44                 :            : #include <linux/skbuff.h>
      45                 :            : #include <linux/init.h>
      46                 :            : #include <linux/notifier.h>
      47                 :            : #include <linux/inetdevice.h>
      48                 :            : #include <linux/igmp.h>
      49                 :            : #include <linux/slab.h>
      50                 :            : #include <linux/hash.h>
      51                 :            : #ifdef CONFIG_SYSCTL
      52                 :            : #include <linux/sysctl.h>
      53                 :            : #endif
      54                 :            : #include <linux/kmod.h>
      55                 :            : #include <linux/netconf.h>
      56                 :            : 
      57                 :            : #include <net/arp.h>
      58                 :            : #include <net/ip.h>
      59                 :            : #include <net/route.h>
      60                 :            : #include <net/ip_fib.h>
      61                 :            : #include <net/rtnetlink.h>
      62                 :            : #include <net/net_namespace.h>
      63                 :            : #include <net/addrconf.h>
      64                 :            : 
      65                 :            : #define IPV6ONLY_FLAGS  \
      66                 :            :                 (IFA_F_NODAD | IFA_F_OPTIMISTIC | IFA_F_DADFAILED | \
      67                 :            :                  IFA_F_HOMEADDRESS | IFA_F_TENTATIVE | \
      68                 :            :                  IFA_F_MANAGETEMPADDR | IFA_F_STABLE_PRIVACY)
      69                 :            : 
      70                 :            : static struct ipv4_devconf ipv4_devconf = {
      71                 :            :         .data = {
      72                 :            :                 [IPV4_DEVCONF_ACCEPT_REDIRECTS - 1] = 1,
      73                 :            :                 [IPV4_DEVCONF_SEND_REDIRECTS - 1] = 1,
      74                 :            :                 [IPV4_DEVCONF_SECURE_REDIRECTS - 1] = 1,
      75                 :            :                 [IPV4_DEVCONF_SHARED_MEDIA - 1] = 1,
      76                 :            :                 [IPV4_DEVCONF_IGMPV2_UNSOLICITED_REPORT_INTERVAL - 1] = 10000 /*ms*/,
      77                 :            :                 [IPV4_DEVCONF_IGMPV3_UNSOLICITED_REPORT_INTERVAL - 1] =  1000 /*ms*/,
      78                 :            :         },
      79                 :            : };
      80                 :            : 
      81                 :            : static struct ipv4_devconf ipv4_devconf_dflt = {
      82                 :            :         .data = {
      83                 :            :                 [IPV4_DEVCONF_ACCEPT_REDIRECTS - 1] = 1,
      84                 :            :                 [IPV4_DEVCONF_SEND_REDIRECTS - 1] = 1,
      85                 :            :                 [IPV4_DEVCONF_SECURE_REDIRECTS - 1] = 1,
      86                 :            :                 [IPV4_DEVCONF_SHARED_MEDIA - 1] = 1,
      87                 :            :                 [IPV4_DEVCONF_ACCEPT_SOURCE_ROUTE - 1] = 1,
      88                 :            :                 [IPV4_DEVCONF_IGMPV2_UNSOLICITED_REPORT_INTERVAL - 1] = 10000 /*ms*/,
      89                 :            :                 [IPV4_DEVCONF_IGMPV3_UNSOLICITED_REPORT_INTERVAL - 1] =  1000 /*ms*/,
      90                 :            :         },
      91                 :            : };
      92                 :            : 
      93                 :            : #define IPV4_DEVCONF_DFLT(net, attr) \
      94                 :            :         IPV4_DEVCONF((*net->ipv4.devconf_dflt), attr)
      95                 :            : 
      96                 :            : static const struct nla_policy ifa_ipv4_policy[IFA_MAX+1] = {
      97                 :            :         [IFA_LOCAL]             = { .type = NLA_U32 },
      98                 :            :         [IFA_ADDRESS]           = { .type = NLA_U32 },
      99                 :            :         [IFA_BROADCAST]         = { .type = NLA_U32 },
     100                 :            :         [IFA_LABEL]             = { .type = NLA_STRING, .len = IFNAMSIZ - 1 },
     101                 :            :         [IFA_CACHEINFO]         = { .len = sizeof(struct ifa_cacheinfo) },
     102                 :            :         [IFA_FLAGS]             = { .type = NLA_U32 },
     103                 :            :         [IFA_RT_PRIORITY]       = { .type = NLA_U32 },
     104                 :            :         [IFA_TARGET_NETNSID]    = { .type = NLA_S32 },
     105                 :            : };
     106                 :            : 
     107                 :            : struct inet_fill_args {
     108                 :            :         u32 portid;
     109                 :            :         u32 seq;
     110                 :            :         int event;
     111                 :            :         unsigned int flags;
     112                 :            :         int netnsid;
     113                 :            :         int ifindex;
     114                 :            : };
     115                 :            : 
     116                 :            : #define IN4_ADDR_HSIZE_SHIFT    8
     117                 :            : #define IN4_ADDR_HSIZE          (1U << IN4_ADDR_HSIZE_SHIFT)
     118                 :            : 
     119                 :            : static struct hlist_head inet_addr_lst[IN4_ADDR_HSIZE];
     120                 :            : 
     121                 :          9 : static u32 inet_addr_hash(const struct net *net, __be32 addr)
     122                 :            : {
     123                 :          9 :         u32 val = (__force u32) addr ^ net_hash_mix(net);
     124                 :            : 
     125         [ -  + ]:          9 :         return hash_32(val, IN4_ADDR_HSIZE_SHIFT);
     126                 :            : }
     127                 :            : 
     128                 :          3 : static void inet_hash_insert(struct net *net, struct in_ifaddr *ifa)
     129                 :            : {
     130                 :          3 :         u32 hash = inet_addr_hash(net, ifa->ifa_local);
     131                 :            : 
     132   [ -  +  -  - ]:          3 :         ASSERT_RTNL();
     133                 :          3 :         hlist_add_head_rcu(&ifa->hash, &inet_addr_lst[hash]);
     134                 :          3 : }
     135                 :            : 
     136                 :          0 : static void inet_hash_remove(struct in_ifaddr *ifa)
     137                 :            : {
     138   [ #  #  #  # ]:          0 :         ASSERT_RTNL();
     139         [ #  # ]:          0 :         hlist_del_init_rcu(&ifa->hash);
     140                 :          0 : }
     141                 :            : 
     142                 :            : /**
     143                 :            :  * __ip_dev_find - find the first device with a given source address.
     144                 :            :  * @net: the net namespace
     145                 :            :  * @addr: the source address
     146                 :            :  * @devref: if true, take a reference on the found device
     147                 :            :  *
     148                 :            :  * If a caller uses devref=false, it should be protected by RCU, or RTNL
     149                 :            :  */
     150                 :          6 : struct net_device *__ip_dev_find(struct net *net, __be32 addr, bool devref)
     151                 :            : {
     152                 :          6 :         struct net_device *result = NULL;
     153                 :          6 :         struct in_ifaddr *ifa;
     154                 :            : 
     155                 :          6 :         rcu_read_lock();
     156                 :          6 :         ifa = inet_lookup_ifaddr_rcu(net, addr);
     157         [ -  + ]:          6 :         if (!ifa) {
     158                 :          0 :                 struct flowi4 fl4 = { .daddr = addr };
     159                 :          0 :                 struct fib_result res = { 0 };
     160                 :          0 :                 struct fib_table *local;
     161                 :            : 
     162                 :            :                 /* Fallback to FIB local table so that communication
     163                 :            :                  * over loopback subnets work.
     164                 :            :                  */
     165                 :          0 :                 local = fib_get_table(net, RT_TABLE_LOCAL);
     166   [ #  #  #  # ]:          0 :                 if (local &&
     167                 :          0 :                     !fib_table_lookup(local, &fl4, &res, FIB_LOOKUP_NOREF) &&
     168         [ #  # ]:          0 :                     res.type == RTN_LOCAL)
     169                 :          0 :                         result = FIB_RES_DEV(res);
     170                 :            :         } else {
     171                 :          6 :                 result = ifa->ifa_dev->dev;
     172                 :            :         }
     173         [ -  + ]:          6 :         if (result && devref)
     174                 :          0 :                 dev_hold(result);
     175                 :          6 :         rcu_read_unlock();
     176                 :          6 :         return result;
     177                 :            : }
     178                 :            : EXPORT_SYMBOL(__ip_dev_find);
     179                 :            : 
     180                 :            : /* called under RCU lock */
     181                 :          6 : struct in_ifaddr *inet_lookup_ifaddr_rcu(struct net *net, __be32 addr)
     182                 :            : {
     183         [ -  + ]:          6 :         u32 hash = inet_addr_hash(net, addr);
     184                 :          6 :         struct in_ifaddr *ifa;
     185                 :            : 
     186   [ -  +  -  -  :         12 :         hlist_for_each_entry_rcu(ifa, &inet_addr_lst[hash], hash)
                   +  - ]
     187   [ +  -  +  - ]:          6 :                 if (ifa->ifa_local == addr &&
     188         [ +  - ]:          6 :                     net_eq(dev_net(ifa->ifa_dev->dev), net))
     189                 :          6 :                         return ifa;
     190                 :            : 
     191                 :            :         return NULL;
     192                 :            : }
     193                 :            : 
     194                 :            : static void rtmsg_ifa(int event, struct in_ifaddr *, struct nlmsghdr *, u32);
     195                 :            : 
     196                 :            : static BLOCKING_NOTIFIER_HEAD(inetaddr_chain);
     197                 :            : static BLOCKING_NOTIFIER_HEAD(inetaddr_validator_chain);
     198                 :            : static void inet_del_ifa(struct in_device *in_dev,
     199                 :            :                          struct in_ifaddr __rcu **ifap,
     200                 :            :                          int destroy);
     201                 :            : #ifdef CONFIG_SYSCTL
     202                 :            : static int devinet_sysctl_register(struct in_device *idev);
     203                 :            : static void devinet_sysctl_unregister(struct in_device *idev);
     204                 :            : #else
     205                 :            : static int devinet_sysctl_register(struct in_device *idev)
     206                 :            : {
     207                 :            :         return 0;
     208                 :            : }
     209                 :            : static void devinet_sysctl_unregister(struct in_device *idev)
     210                 :            : {
     211                 :            : }
     212                 :            : #endif
     213                 :            : 
     214                 :            : /* Locks all the inet devices. */
     215                 :            : 
     216                 :          6 : static struct in_ifaddr *inet_alloc_ifa(void)
     217                 :            : {
     218                 :          6 :         return kzalloc(sizeof(struct in_ifaddr), GFP_KERNEL);
     219                 :            : }
     220                 :            : 
     221                 :          3 : static void inet_rcu_free_ifa(struct rcu_head *head)
     222                 :            : {
     223                 :          3 :         struct in_ifaddr *ifa = container_of(head, struct in_ifaddr, rcu_head);
     224         [ +  - ]:          3 :         if (ifa->ifa_dev)
     225                 :          3 :                 in_dev_put(ifa->ifa_dev);
     226                 :          3 :         kfree(ifa);
     227                 :          3 : }
     228                 :            : 
     229                 :          3 : static void inet_free_ifa(struct in_ifaddr *ifa)
     230                 :            : {
     231                 :          3 :         call_rcu(&ifa->rcu_head, inet_rcu_free_ifa);
     232                 :          0 : }
     233                 :            : 
     234                 :          0 : void in_dev_finish_destroy(struct in_device *idev)
     235                 :            : {
     236                 :          0 :         struct net_device *dev = idev->dev;
     237                 :            : 
     238         [ #  # ]:          0 :         WARN_ON(idev->ifa_list);
     239         [ #  # ]:          0 :         WARN_ON(idev->mc_list);
     240                 :          0 :         kfree(rcu_dereference_protected(idev->mc_hash, 1));
     241                 :            : #ifdef NET_REFCNT_DEBUG
     242                 :            :         pr_debug("%s: %p=%s\n", __func__, idev, dev ? dev->name : "NIL");
     243                 :            : #endif
     244                 :          0 :         dev_put(dev);
     245         [ #  # ]:          0 :         if (!idev->dead)
     246                 :          0 :                 pr_err("Freeing alive in_device %p\n", idev);
     247                 :            :         else
     248                 :          0 :                 kfree(idev);
     249                 :          0 : }
     250                 :            : EXPORT_SYMBOL(in_dev_finish_destroy);
     251                 :            : 
     252                 :          9 : static struct in_device *inetdev_init(struct net_device *dev)
     253                 :            : {
     254                 :          9 :         struct in_device *in_dev;
     255                 :          9 :         int err = -ENOMEM;
     256                 :            : 
     257   [ -  +  -  - ]:          9 :         ASSERT_RTNL();
     258                 :            : 
     259                 :          9 :         in_dev = kzalloc(sizeof(*in_dev), GFP_KERNEL);
     260         [ -  + ]:          9 :         if (!in_dev)
     261                 :          0 :                 goto out;
     262                 :          9 :         memcpy(&in_dev->cnf, dev_net(dev)->ipv4.devconf_dflt,
     263                 :            :                         sizeof(in_dev->cnf));
     264                 :          9 :         in_dev->cnf.sysctl = NULL;
     265                 :          9 :         in_dev->dev = dev;
     266                 :          9 :         in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl);
     267         [ -  + ]:          9 :         if (!in_dev->arp_parms)
     268                 :          0 :                 goto out_kfree;
     269         [ -  + ]:          9 :         if (IPV4_DEVCONF(in_dev->cnf, FORWARDING))
     270                 :          0 :                 dev_disable_lro(dev);
     271                 :            :         /* Reference in_dev->dev */
     272                 :          9 :         dev_hold(dev);
     273                 :            :         /* Account for reference dev->ip_ptr (below) */
     274                 :          9 :         refcount_set(&in_dev->refcnt, 1);
     275                 :            : 
     276                 :          9 :         err = devinet_sysctl_register(in_dev);
     277         [ -  + ]:          9 :         if (err) {
     278                 :          0 :                 in_dev->dead = 1;
     279                 :          0 :                 in_dev_put(in_dev);
     280                 :          0 :                 in_dev = NULL;
     281                 :          0 :                 goto out;
     282                 :            :         }
     283                 :          9 :         ip_mc_init_dev(in_dev);
     284         [ -  + ]:          9 :         if (dev->flags & IFF_UP)
     285                 :          0 :                 ip_mc_up(in_dev);
     286                 :            : 
     287                 :            :         /* we can receive as soon as ip_ptr is set -- do this last */
     288                 :          9 :         rcu_assign_pointer(dev->ip_ptr, in_dev);
     289                 :          9 : out:
     290         [ -  + ]:          9 :         return in_dev ?: ERR_PTR(err);
     291                 :            : out_kfree:
     292                 :          0 :         kfree(in_dev);
     293                 :          0 :         in_dev = NULL;
     294                 :          0 :         goto out;
     295                 :            : }
     296                 :            : 
     297                 :          0 : static void in_dev_rcu_put(struct rcu_head *head)
     298                 :            : {
     299                 :          0 :         struct in_device *idev = container_of(head, struct in_device, rcu_head);
     300                 :          0 :         in_dev_put(idev);
     301                 :          0 : }
     302                 :            : 
     303                 :          0 : static void inetdev_destroy(struct in_device *in_dev)
     304                 :            : {
     305                 :          0 :         struct net_device *dev;
     306                 :          0 :         struct in_ifaddr *ifa;
     307                 :            : 
     308   [ #  #  #  # ]:          0 :         ASSERT_RTNL();
     309                 :            : 
     310                 :          0 :         dev = in_dev->dev;
     311                 :            : 
     312                 :          0 :         in_dev->dead = 1;
     313                 :            : 
     314                 :          0 :         ip_mc_destroy_dev(in_dev);
     315                 :            : 
     316         [ #  # ]:          0 :         while ((ifa = rtnl_dereference(in_dev->ifa_list)) != NULL) {
     317                 :          0 :                 inet_del_ifa(in_dev, &in_dev->ifa_list, 0);
     318                 :          0 :                 inet_free_ifa(ifa);
     319                 :            :         }
     320                 :            : 
     321                 :          0 :         RCU_INIT_POINTER(dev->ip_ptr, NULL);
     322                 :            : 
     323                 :          0 :         devinet_sysctl_unregister(in_dev);
     324                 :          0 :         neigh_parms_release(&arp_tbl, in_dev->arp_parms);
     325                 :          0 :         arp_ifdown(dev);
     326                 :            : 
     327                 :          0 :         call_rcu(&in_dev->rcu_head, in_dev_rcu_put);
     328                 :          0 : }
     329                 :            : 
     330                 :          0 : int inet_addr_onlink(struct in_device *in_dev, __be32 a, __be32 b)
     331                 :            : {
     332                 :          0 :         const struct in_ifaddr *ifa;
     333                 :            : 
     334                 :          0 :         rcu_read_lock();
     335         [ #  # ]:          0 :         in_dev_for_each_ifa_rcu(ifa, in_dev) {
     336         [ #  # ]:          0 :                 if (inet_ifa_match(a, ifa)) {
     337   [ #  #  #  # ]:          0 :                         if (!b || inet_ifa_match(b, ifa)) {
     338                 :          0 :                                 rcu_read_unlock();
     339                 :          0 :                                 return 1;
     340                 :            :                         }
     341                 :            :                 }
     342                 :            :         }
     343                 :          0 :         rcu_read_unlock();
     344                 :          0 :         return 0;
     345                 :            : }
     346                 :            : 
     347                 :          0 : static void __inet_del_ifa(struct in_device *in_dev,
     348                 :            :                            struct in_ifaddr __rcu **ifap,
     349                 :            :                            int destroy, struct nlmsghdr *nlh, u32 portid)
     350                 :            : {
     351                 :          0 :         struct in_ifaddr *promote = NULL;
     352                 :          0 :         struct in_ifaddr *ifa, *ifa1;
     353                 :          0 :         struct in_ifaddr *last_prim;
     354                 :          0 :         struct in_ifaddr *prev_prom = NULL;
     355   [ #  #  #  # ]:          0 :         int do_promote = IN_DEV_PROMOTE_SECONDARIES(in_dev);
     356                 :            : 
     357   [ #  #  #  # ]:          0 :         ASSERT_RTNL();
     358                 :            : 
     359                 :          0 :         ifa1 = rtnl_dereference(*ifap);
     360                 :          0 :         last_prim = rtnl_dereference(in_dev->ifa_list);
     361         [ #  # ]:          0 :         if (in_dev->dead)
     362                 :          0 :                 goto no_promotions;
     363                 :            : 
     364                 :            :         /* 1. Deleting primary ifaddr forces deletion all secondaries
     365                 :            :          * unless alias promotion is set
     366                 :            :          **/
     367                 :            : 
     368         [ #  # ]:          0 :         if (!(ifa1->ifa_flags & IFA_F_SECONDARY)) {
     369                 :          0 :                 struct in_ifaddr __rcu **ifap1 = &ifa1->ifa_next;
     370                 :            : 
     371         [ #  # ]:          0 :                 while ((ifa = rtnl_dereference(*ifap1)) != NULL) {
     372         [ #  # ]:          0 :                         if (!(ifa->ifa_flags & IFA_F_SECONDARY) &&
     373         [ #  # ]:          0 :                             ifa1->ifa_scope <= ifa->ifa_scope)
     374                 :          0 :                                 last_prim = ifa;
     375                 :            : 
     376         [ #  # ]:          0 :                         if (!(ifa->ifa_flags & IFA_F_SECONDARY) ||
     377   [ #  #  #  # ]:          0 :                             ifa1->ifa_mask != ifa->ifa_mask ||
     378         [ #  # ]:          0 :                             !inet_ifa_match(ifa1->ifa_address, ifa)) {
     379                 :          0 :                                 ifap1 = &ifa->ifa_next;
     380                 :          0 :                                 prev_prom = ifa;
     381                 :          0 :                                 continue;
     382                 :            :                         }
     383                 :            : 
     384         [ #  # ]:          0 :                         if (!do_promote) {
     385                 :          0 :                                 inet_hash_remove(ifa);
     386                 :          0 :                                 *ifap1 = ifa->ifa_next;
     387                 :            : 
     388                 :          0 :                                 rtmsg_ifa(RTM_DELADDR, ifa, nlh, portid);
     389                 :          0 :                                 blocking_notifier_call_chain(&inetaddr_chain,
     390                 :            :                                                 NETDEV_DOWN, ifa);
     391                 :          0 :                                 inet_free_ifa(ifa);
     392                 :            :                         } else {
     393                 :            :                                 promote = ifa;
     394                 :            :                                 break;
     395                 :            :                         }
     396                 :            :                 }
     397                 :            :         }
     398                 :            : 
     399                 :            :         /* On promotion all secondaries from subnet are changing
     400                 :            :          * the primary IP, we must remove all their routes silently
     401                 :            :          * and later to add them back with new prefsrc. Do this
     402                 :            :          * while all addresses are on the device list.
     403                 :            :          */
     404         [ #  # ]:          0 :         for (ifa = promote; ifa; ifa = rtnl_dereference(ifa->ifa_next)) {
     405   [ #  #  #  # ]:          0 :                 if (ifa1->ifa_mask == ifa->ifa_mask &&
     406         [ #  # ]:          0 :                     inet_ifa_match(ifa1->ifa_address, ifa))
     407                 :          0 :                         fib_del_ifaddr(ifa, ifa1);
     408                 :            :         }
     409                 :            : 
     410                 :          0 : no_promotions:
     411                 :            :         /* 2. Unlink it */
     412                 :            : 
     413                 :          0 :         *ifap = ifa1->ifa_next;
     414                 :          0 :         inet_hash_remove(ifa1);
     415                 :            : 
     416                 :            :         /* 3. Announce address deletion */
     417                 :            : 
     418                 :            :         /* Send message first, then call notifier.
     419                 :            :            At first sight, FIB update triggered by notifier
     420                 :            :            will refer to already deleted ifaddr, that could confuse
     421                 :            :            netlink listeners. It is not true: look, gated sees
     422                 :            :            that route deleted and if it still thinks that ifaddr
     423                 :            :            is valid, it will try to restore deleted routes... Grr.
     424                 :            :            So that, this order is correct.
     425                 :            :          */
     426                 :          0 :         rtmsg_ifa(RTM_DELADDR, ifa1, nlh, portid);
     427                 :          0 :         blocking_notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1);
     428                 :            : 
     429         [ #  # ]:          0 :         if (promote) {
     430                 :          0 :                 struct in_ifaddr *next_sec;
     431                 :            : 
     432                 :          0 :                 next_sec = rtnl_dereference(promote->ifa_next);
     433         [ #  # ]:          0 :                 if (prev_prom) {
     434                 :          0 :                         struct in_ifaddr *last_sec;
     435                 :            : 
     436                 :          0 :                         rcu_assign_pointer(prev_prom->ifa_next, next_sec);
     437                 :            : 
     438                 :          0 :                         last_sec = rtnl_dereference(last_prim->ifa_next);
     439                 :          0 :                         rcu_assign_pointer(promote->ifa_next, last_sec);
     440                 :          0 :                         rcu_assign_pointer(last_prim->ifa_next, promote);
     441                 :            :                 }
     442                 :            : 
     443                 :          0 :                 promote->ifa_flags &= ~IFA_F_SECONDARY;
     444                 :          0 :                 rtmsg_ifa(RTM_NEWADDR, promote, nlh, portid);
     445                 :          0 :                 blocking_notifier_call_chain(&inetaddr_chain,
     446                 :            :                                 NETDEV_UP, promote);
     447         [ #  # ]:          0 :                 for (ifa = next_sec; ifa;
     448                 :          0 :                      ifa = rtnl_dereference(ifa->ifa_next)) {
     449   [ #  #  #  # ]:          0 :                         if (ifa1->ifa_mask != ifa->ifa_mask ||
     450         [ #  # ]:          0 :                             !inet_ifa_match(ifa1->ifa_address, ifa))
     451                 :          0 :                                         continue;
     452                 :          0 :                         fib_add_ifaddr(ifa);
     453                 :            :                 }
     454                 :            : 
     455                 :            :         }
     456         [ #  # ]:          0 :         if (destroy)
     457                 :          0 :                 inet_free_ifa(ifa1);
     458                 :          0 : }
     459                 :            : 
     460                 :          0 : static void inet_del_ifa(struct in_device *in_dev,
     461                 :            :                          struct in_ifaddr __rcu **ifap,
     462                 :            :                          int destroy)
     463                 :            : {
     464                 :          0 :         __inet_del_ifa(in_dev, ifap, destroy, NULL, 0);
     465                 :          0 : }
     466                 :            : 
     467                 :            : static void check_lifetime(struct work_struct *work);
     468                 :            : 
     469                 :            : static DECLARE_DELAYED_WORK(check_lifetime_work, check_lifetime);
     470                 :            : 
     471                 :          6 : static int __inet_insert_ifa(struct in_ifaddr *ifa, struct nlmsghdr *nlh,
     472                 :            :                              u32 portid, struct netlink_ext_ack *extack)
     473                 :            : {
     474                 :          6 :         struct in_ifaddr __rcu **last_primary, **ifap;
     475                 :          6 :         struct in_device *in_dev = ifa->ifa_dev;
     476                 :          6 :         struct in_validator_info ivi;
     477                 :          6 :         struct in_ifaddr *ifa1;
     478                 :          6 :         int ret;
     479                 :            : 
     480   [ -  +  -  - ]:          6 :         ASSERT_RTNL();
     481                 :            : 
     482         [ -  + ]:          6 :         if (!ifa->ifa_local) {
     483                 :          0 :                 inet_free_ifa(ifa);
     484                 :          0 :                 return 0;
     485                 :            :         }
     486                 :            : 
     487                 :          6 :         ifa->ifa_flags &= ~IFA_F_SECONDARY;
     488                 :          6 :         last_primary = &in_dev->ifa_list;
     489                 :            : 
     490                 :            :         /* Don't set IPv6 only flags to IPv4 addresses */
     491                 :          6 :         ifa->ifa_flags &= ~IPV6ONLY_FLAGS;
     492                 :            : 
     493                 :          6 :         ifap = &in_dev->ifa_list;
     494                 :          6 :         ifa1 = rtnl_dereference(*ifap);
     495                 :            : 
     496         [ +  + ]:          6 :         while (ifa1) {
     497         [ +  - ]:          3 :                 if (!(ifa1->ifa_flags & IFA_F_SECONDARY) &&
     498         [ +  - ]:          3 :                     ifa->ifa_scope <= ifa1->ifa_scope)
     499                 :          3 :                         last_primary = &ifa1->ifa_next;
     500   [ +  -  +  - ]:          3 :                 if (ifa1->ifa_mask == ifa->ifa_mask &&
     501         [ +  - ]:          3 :                     inet_ifa_match(ifa1->ifa_address, ifa)) {
     502         [ +  - ]:          3 :                         if (ifa1->ifa_local == ifa->ifa_local) {
     503                 :          3 :                                 inet_free_ifa(ifa);
     504                 :          3 :                                 return -EEXIST;
     505                 :            :                         }
     506         [ #  # ]:          0 :                         if (ifa1->ifa_scope != ifa->ifa_scope) {
     507                 :          0 :                                 inet_free_ifa(ifa);
     508                 :          0 :                                 return -EINVAL;
     509                 :            :                         }
     510                 :          0 :                         ifa->ifa_flags |= IFA_F_SECONDARY;
     511                 :            :                 }
     512                 :            : 
     513                 :          0 :                 ifap = &ifa1->ifa_next;
     514                 :          0 :                 ifa1 = rtnl_dereference(*ifap);
     515                 :            :         }
     516                 :            : 
     517                 :            :         /* Allow any devices that wish to register ifaddr validtors to weigh
     518                 :            :          * in now, before changes are committed.  The rntl lock is serializing
     519                 :            :          * access here, so the state should not change between a validator call
     520                 :            :          * and a final notify on commit.  This isn't invoked on promotion under
     521                 :            :          * the assumption that validators are checking the address itself, and
     522                 :            :          * not the flags.
     523                 :            :          */
     524                 :          3 :         ivi.ivi_addr = ifa->ifa_address;
     525                 :          3 :         ivi.ivi_dev = ifa->ifa_dev;
     526                 :          3 :         ivi.extack = extack;
     527                 :          3 :         ret = blocking_notifier_call_chain(&inetaddr_validator_chain,
     528                 :            :                                            NETDEV_UP, &ivi);
     529         [ -  + ]:          3 :         ret = notifier_to_errno(ret);
     530                 :          0 :         if (ret) {
     531                 :          0 :                 inet_free_ifa(ifa);
     532                 :          0 :                 return ret;
     533                 :            :         }
     534                 :            : 
     535         [ +  - ]:          3 :         if (!(ifa->ifa_flags & IFA_F_SECONDARY)) {
     536                 :          3 :                 prandom_seed((__force u32) ifa->ifa_local);
     537                 :          3 :                 ifap = last_primary;
     538                 :            :         }
     539                 :            : 
     540                 :          3 :         rcu_assign_pointer(ifa->ifa_next, *ifap);
     541                 :          3 :         rcu_assign_pointer(*ifap, ifa);
     542                 :            : 
     543                 :          3 :         inet_hash_insert(dev_net(in_dev->dev), ifa);
     544                 :            : 
     545                 :          3 :         cancel_delayed_work(&check_lifetime_work);
     546                 :          3 :         queue_delayed_work(system_power_efficient_wq, &check_lifetime_work, 0);
     547                 :            : 
     548                 :            :         /* Send message first, then call notifier.
     549                 :            :            Notifier will trigger FIB update, so that
     550                 :            :            listeners of netlink will know about new ifaddr */
     551                 :          3 :         rtmsg_ifa(RTM_NEWADDR, ifa, nlh, portid);
     552                 :          3 :         blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
     553                 :            : 
     554                 :          3 :         return 0;
     555                 :            : }
     556                 :            : 
     557                 :          3 : static int inet_insert_ifa(struct in_ifaddr *ifa)
     558                 :            : {
     559                 :          3 :         return __inet_insert_ifa(ifa, NULL, 0, NULL);
     560                 :            : }
     561                 :            : 
     562                 :          0 : static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa)
     563                 :            : {
     564                 :          0 :         struct in_device *in_dev = __in_dev_get_rtnl(dev);
     565                 :            : 
     566   [ #  #  #  # ]:          0 :         ASSERT_RTNL();
     567                 :            : 
     568         [ #  # ]:          0 :         if (!in_dev) {
     569                 :          0 :                 inet_free_ifa(ifa);
     570                 :          0 :                 return -ENOBUFS;
     571                 :            :         }
     572         [ #  # ]:          0 :         ipv4_devconf_setall(in_dev);
     573         [ #  # ]:          0 :         neigh_parms_data_state_setall(in_dev->arp_parms);
     574         [ #  # ]:          0 :         if (ifa->ifa_dev != in_dev) {
     575         [ #  # ]:          0 :                 WARN_ON(ifa->ifa_dev);
     576                 :          0 :                 in_dev_hold(in_dev);
     577                 :          0 :                 ifa->ifa_dev = in_dev;
     578                 :            :         }
     579         [ #  # ]:          0 :         if (ipv4_is_loopback(ifa->ifa_local))
     580                 :          0 :                 ifa->ifa_scope = RT_SCOPE_HOST;
     581                 :          0 :         return inet_insert_ifa(ifa);
     582                 :            : }
     583                 :            : 
     584                 :            : /* Caller must hold RCU or RTNL :
     585                 :            :  * We dont take a reference on found in_device
     586                 :            :  */
     587                 :          6 : struct in_device *inetdev_by_index(struct net *net, int ifindex)
     588                 :            : {
     589                 :          6 :         struct net_device *dev;
     590                 :          6 :         struct in_device *in_dev = NULL;
     591                 :            : 
     592                 :          6 :         rcu_read_lock();
     593                 :          6 :         dev = dev_get_by_index_rcu(net, ifindex);
     594   [ -  -  +  - ]:          6 :         if (dev)
     595                 :          6 :                 in_dev = rcu_dereference_rtnl(dev->ip_ptr);
     596                 :          6 :         rcu_read_unlock();
     597                 :          6 :         return in_dev;
     598                 :            : }
     599                 :            : EXPORT_SYMBOL(inetdev_by_index);
     600                 :            : 
     601                 :            : /* Called only from RTNL semaphored context. No locks. */
     602                 :            : 
     603                 :          0 : struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, __be32 prefix,
     604                 :            :                                     __be32 mask)
     605                 :            : {
     606                 :          0 :         struct in_ifaddr *ifa;
     607                 :            : 
     608   [ #  #  #  # ]:          0 :         ASSERT_RTNL();
     609                 :            : 
     610         [ #  # ]:          0 :         in_dev_for_each_ifa_rtnl(ifa, in_dev) {
     611   [ #  #  #  # ]:          0 :                 if (ifa->ifa_mask == mask && inet_ifa_match(prefix, ifa))
     612                 :          0 :                         return ifa;
     613                 :            :         }
     614                 :            :         return NULL;
     615                 :            : }
     616                 :            : 
     617                 :          0 : static int ip_mc_config(struct sock *sk, bool join, const struct in_ifaddr *ifa)
     618                 :            : {
     619                 :          0 :         struct ip_mreqn mreq = {
     620                 :          0 :                 .imr_multiaddr.s_addr = ifa->ifa_address,
     621                 :          0 :                 .imr_ifindex = ifa->ifa_dev->dev->ifindex,
     622                 :            :         };
     623                 :          0 :         int ret;
     624                 :            : 
     625   [ #  #  #  # ]:          0 :         ASSERT_RTNL();
     626                 :            : 
     627                 :          0 :         lock_sock(sk);
     628         [ #  # ]:          0 :         if (join)
     629                 :          0 :                 ret = ip_mc_join_group(sk, &mreq);
     630                 :            :         else
     631                 :          0 :                 ret = ip_mc_leave_group(sk, &mreq);
     632                 :          0 :         release_sock(sk);
     633                 :            : 
     634                 :          0 :         return ret;
     635                 :            : }
     636                 :            : 
     637                 :          0 : static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh,
     638                 :            :                             struct netlink_ext_ack *extack)
     639                 :            : {
     640                 :          0 :         struct net *net = sock_net(skb->sk);
     641                 :          0 :         struct in_ifaddr __rcu **ifap;
     642                 :          0 :         struct nlattr *tb[IFA_MAX+1];
     643                 :          0 :         struct in_device *in_dev;
     644                 :          0 :         struct ifaddrmsg *ifm;
     645                 :          0 :         struct in_ifaddr *ifa;
     646                 :            : 
     647                 :          0 :         int err = -EINVAL;
     648                 :            : 
     649   [ #  #  #  # ]:          0 :         ASSERT_RTNL();
     650                 :            : 
     651                 :          0 :         err = nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFA_MAX,
     652                 :            :                                      ifa_ipv4_policy, extack);
     653         [ #  # ]:          0 :         if (err < 0)
     654                 :          0 :                 goto errout;
     655                 :            : 
     656                 :          0 :         ifm = nlmsg_data(nlh);
     657                 :          0 :         in_dev = inetdev_by_index(net, ifm->ifa_index);
     658         [ #  # ]:          0 :         if (!in_dev) {
     659                 :          0 :                 err = -ENODEV;
     660                 :          0 :                 goto errout;
     661                 :            :         }
     662                 :            : 
     663         [ #  # ]:          0 :         for (ifap = &in_dev->ifa_list; (ifa = rtnl_dereference(*ifap)) != NULL;
     664                 :          0 :              ifap = &ifa->ifa_next) {
     665   [ #  #  #  # ]:          0 :                 if (tb[IFA_LOCAL] &&
     666         [ #  # ]:          0 :                     ifa->ifa_local != nla_get_in_addr(tb[IFA_LOCAL]))
     667                 :          0 :                         continue;
     668                 :            : 
     669   [ #  #  #  # ]:          0 :                 if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label))
     670                 :          0 :                         continue;
     671                 :            : 
     672         [ #  # ]:          0 :                 if (tb[IFA_ADDRESS] &&
     673   [ #  #  #  # ]:          0 :                     (ifm->ifa_prefixlen != ifa->ifa_prefixlen ||
     674         [ #  # ]:          0 :                     !inet_ifa_match(nla_get_in_addr(tb[IFA_ADDRESS]), ifa)))
     675                 :          0 :                         continue;
     676                 :            : 
     677         [ #  # ]:          0 :                 if (ipv4_is_multicast(ifa->ifa_address))
     678                 :          0 :                         ip_mc_config(net->ipv4.mc_autojoin_sk, false, ifa);
     679                 :          0 :                 __inet_del_ifa(in_dev, ifap, 1, nlh, NETLINK_CB(skb).portid);
     680                 :          0 :                 return 0;
     681                 :            :         }
     682                 :            : 
     683                 :            :         err = -EADDRNOTAVAIL;
     684                 :            : errout:
     685                 :            :         return err;
     686                 :            : }
     687                 :            : 
     688                 :            : #define INFINITY_LIFE_TIME      0xFFFFFFFF
     689                 :            : 
     690                 :          6 : static void check_lifetime(struct work_struct *work)
     691                 :            : {
     692                 :          6 :         unsigned long now, next, next_sec, next_sched;
     693                 :          6 :         struct in_ifaddr *ifa;
     694                 :          6 :         struct hlist_node *n;
     695                 :          6 :         int i;
     696                 :            : 
     697                 :          6 :         now = jiffies;
     698                 :          6 :         next = round_jiffies_up(now + ADDR_CHECK_FREQUENCY);
     699                 :            : 
     700         [ +  + ]:       1548 :         for (i = 0; i < IN4_ADDR_HSIZE; i++) {
     701                 :       1536 :                 bool change_needed = false;
     702                 :            : 
     703                 :       1536 :                 rcu_read_lock();
     704   [ +  +  +  -  :       3078 :                 hlist_for_each_entry_rcu(ifa, &inet_addr_lst[i], hash) {
                   +  + ]
     705                 :          3 :                         unsigned long age;
     706                 :            : 
     707         [ +  - ]:          3 :                         if (ifa->ifa_flags & IFA_F_PERMANENT)
     708                 :          3 :                                 continue;
     709                 :            : 
     710                 :            :                         /* We try to batch several events at once. */
     711                 :          0 :                         age = (now - ifa->ifa_tstamp +
     712                 :            :                                ADDRCONF_TIMER_FUZZ_MINUS) / HZ;
     713                 :            : 
     714         [ #  # ]:          0 :                         if (ifa->ifa_valid_lft != INFINITY_LIFE_TIME &&
     715         [ #  # ]:          0 :                             age >= ifa->ifa_valid_lft) {
     716                 :            :                                 change_needed = true;
     717         [ #  # ]:          0 :                         } else if (ifa->ifa_preferred_lft ==
     718                 :            :                                    INFINITY_LIFE_TIME) {
     719                 :          0 :                                 continue;
     720         [ #  # ]:          0 :                         } else if (age >= ifa->ifa_preferred_lft) {
     721         [ #  # ]:          0 :                                 if (time_before(ifa->ifa_tstamp +
     722                 :            :                                                 ifa->ifa_valid_lft * HZ, next))
     723                 :          0 :                                         next = ifa->ifa_tstamp +
     724                 :            :                                                ifa->ifa_valid_lft * HZ;
     725                 :            : 
     726         [ #  # ]:          0 :                                 if (!(ifa->ifa_flags & IFA_F_DEPRECATED))
     727                 :          0 :                                         change_needed = true;
     728         [ #  # ]:          0 :                         } else if (time_before(ifa->ifa_tstamp +
     729                 :            :                                                ifa->ifa_preferred_lft * HZ,
     730                 :            :                                                next)) {
     731                 :          0 :                                 next = ifa->ifa_tstamp +
     732                 :            :                                        ifa->ifa_preferred_lft * HZ;
     733                 :            :                         }
     734                 :            :                 }
     735                 :       1536 :                 rcu_read_unlock();
     736         [ +  - ]:       1536 :                 if (!change_needed)
     737                 :       1536 :                         continue;
     738                 :          0 :                 rtnl_lock();
     739   [ #  #  #  #  :          0 :                 hlist_for_each_entry_safe(ifa, n, &inet_addr_lst[i], hash) {
                   #  # ]
     740                 :          0 :                         unsigned long age;
     741                 :            : 
     742         [ #  # ]:          0 :                         if (ifa->ifa_flags & IFA_F_PERMANENT)
     743                 :          0 :                                 continue;
     744                 :            : 
     745                 :            :                         /* We try to batch several events at once. */
     746                 :          0 :                         age = (now - ifa->ifa_tstamp +
     747                 :            :                                ADDRCONF_TIMER_FUZZ_MINUS) / HZ;
     748                 :            : 
     749         [ #  # ]:          0 :                         if (ifa->ifa_valid_lft != INFINITY_LIFE_TIME &&
     750         [ #  # ]:          0 :                             age >= ifa->ifa_valid_lft) {
     751                 :          0 :                                 struct in_ifaddr __rcu **ifap;
     752                 :          0 :                                 struct in_ifaddr *tmp;
     753                 :            : 
     754                 :          0 :                                 ifap = &ifa->ifa_dev->ifa_list;
     755                 :          0 :                                 tmp = rtnl_dereference(*ifap);
     756         [ #  # ]:          0 :                                 while (tmp) {
     757         [ #  # ]:          0 :                                         if (tmp == ifa) {
     758                 :          0 :                                                 inet_del_ifa(ifa->ifa_dev,
     759                 :            :                                                              ifap, 1);
     760                 :            :                                                 break;
     761                 :            :                                         }
     762                 :          0 :                                         ifap = &tmp->ifa_next;
     763                 :          0 :                                         tmp = rtnl_dereference(*ifap);
     764                 :            :                                 }
     765         [ #  # ]:          0 :                         } else if (ifa->ifa_preferred_lft !=
     766                 :          0 :                                    INFINITY_LIFE_TIME &&
     767         [ #  # ]:          0 :                                    age >= ifa->ifa_preferred_lft &&
     768         [ #  # ]:          0 :                                    !(ifa->ifa_flags & IFA_F_DEPRECATED)) {
     769                 :          0 :                                 ifa->ifa_flags |= IFA_F_DEPRECATED;
     770                 :          0 :                                 rtmsg_ifa(RTM_NEWADDR, ifa, NULL, 0);
     771                 :            :                         }
     772                 :            :                 }
     773                 :          0 :                 rtnl_unlock();
     774                 :            :         }
     775                 :            : 
     776                 :          6 :         next_sec = round_jiffies_up(next);
     777                 :          6 :         next_sched = next;
     778                 :            : 
     779                 :            :         /* If rounded timeout is accurate enough, accept it. */
     780         [ -  + ]:          6 :         if (time_before(next_sec, next + ADDRCONF_TIMER_FUZZ))
     781                 :          0 :                 next_sched = next_sec;
     782                 :            : 
     783                 :          6 :         now = jiffies;
     784                 :            :         /* And minimum interval is ADDRCONF_TIMER_FUZZ_MAX. */
     785         [ -  + ]:          6 :         if (time_before(next_sched, now + ADDRCONF_TIMER_FUZZ_MAX))
     786                 :          0 :                 next_sched = now + ADDRCONF_TIMER_FUZZ_MAX;
     787                 :            : 
     788                 :          6 :         queue_delayed_work(system_power_efficient_wq, &check_lifetime_work,
     789                 :            :                         next_sched - now);
     790                 :          6 : }
     791                 :            : 
     792                 :          6 : static void set_ifa_lifetime(struct in_ifaddr *ifa, __u32 valid_lft,
     793                 :            :                              __u32 prefered_lft)
     794                 :            : {
     795                 :          6 :         unsigned long timeout;
     796                 :            : 
     797                 :          6 :         ifa->ifa_flags &= ~(IFA_F_PERMANENT | IFA_F_DEPRECATED);
     798                 :            : 
     799         [ -  + ]:          3 :         timeout = addrconf_timeout_fixup(valid_lft, HZ);
     800   [ +  -  -  -  :          6 :         if (addrconf_finite_timeout(timeout))
                   -  + ]
     801                 :          0 :                 ifa->ifa_valid_lft = timeout;
     802                 :            :         else
     803                 :          3 :                 ifa->ifa_flags |= IFA_F_PERMANENT;
     804                 :            : 
     805         [ -  + ]:          3 :         timeout = addrconf_timeout_fixup(prefered_lft, HZ);
     806         [ -  + ]:          3 :         if (addrconf_finite_timeout(timeout)) {
     807         [ #  # ]:          0 :                 if (timeout == 0)
     808                 :          0 :                         ifa->ifa_flags |= IFA_F_DEPRECATED;
     809                 :          0 :                 ifa->ifa_preferred_lft = timeout;
     810                 :            :         }
     811                 :          6 :         ifa->ifa_tstamp = jiffies;
     812   [ +  -  -  -  :          6 :         if (!ifa->ifa_cstamp)
                   +  - ]
     813                 :          6 :                 ifa->ifa_cstamp = ifa->ifa_tstamp;
     814                 :          3 : }
     815                 :            : 
     816                 :          3 : static struct in_ifaddr *rtm_to_ifaddr(struct net *net, struct nlmsghdr *nlh,
     817                 :            :                                        __u32 *pvalid_lft, __u32 *pprefered_lft,
     818                 :            :                                        struct netlink_ext_ack *extack)
     819                 :            : {
     820                 :          3 :         struct nlattr *tb[IFA_MAX+1];
     821                 :          3 :         struct in_ifaddr *ifa;
     822                 :          3 :         struct ifaddrmsg *ifm;
     823                 :          3 :         struct net_device *dev;
     824                 :          3 :         struct in_device *in_dev;
     825                 :          3 :         int err;
     826                 :            : 
     827                 :          3 :         err = nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFA_MAX,
     828                 :            :                                      ifa_ipv4_policy, extack);
     829         [ -  + ]:          3 :         if (err < 0)
     830                 :          0 :                 goto errout;
     831                 :            : 
     832         [ +  - ]:          3 :         ifm = nlmsg_data(nlh);
     833                 :          3 :         err = -EINVAL;
     834   [ +  -  -  + ]:          3 :         if (ifm->ifa_prefixlen > 32 || !tb[IFA_LOCAL])
     835                 :          0 :                 goto errout;
     836                 :            : 
     837                 :          3 :         dev = __dev_get_by_index(net, ifm->ifa_index);
     838                 :          3 :         err = -ENODEV;
     839         [ -  + ]:          3 :         if (!dev)
     840                 :          0 :                 goto errout;
     841                 :            : 
     842         [ -  + ]:          3 :         in_dev = __in_dev_get_rtnl(dev);
     843                 :          3 :         err = -ENOBUFS;
     844         [ -  + ]:          3 :         if (!in_dev)
     845                 :          0 :                 goto errout;
     846                 :            : 
     847                 :          3 :         ifa = inet_alloc_ifa();
     848         [ -  + ]:          3 :         if (!ifa)
     849                 :            :                 /*
     850                 :            :                  * A potential indev allocation can be left alive, it stays
     851                 :            :                  * assigned to its device and is destroy with it.
     852                 :            :                  */
     853                 :          0 :                 goto errout;
     854                 :            : 
     855                 :          3 :         ipv4_devconf_setall(in_dev);
     856                 :          3 :         neigh_parms_data_state_setall(in_dev->arp_parms);
     857                 :          3 :         in_dev_hold(in_dev);
     858                 :            : 
     859         [ +  - ]:          3 :         if (!tb[IFA_ADDRESS])
     860                 :          3 :                 tb[IFA_ADDRESS] = tb[IFA_LOCAL];
     861                 :            : 
     862         [ +  - ]:          3 :         INIT_HLIST_NODE(&ifa->hash);
     863                 :          3 :         ifa->ifa_prefixlen = ifm->ifa_prefixlen;
     864         [ +  - ]:          3 :         ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen);
     865         [ -  + ]:          3 :         ifa->ifa_flags = tb[IFA_FLAGS] ? nla_get_u32(tb[IFA_FLAGS]) :
     866                 :          3 :                                          ifm->ifa_flags;
     867                 :          3 :         ifa->ifa_scope = ifm->ifa_scope;
     868                 :          3 :         ifa->ifa_dev = in_dev;
     869                 :            : 
     870         [ -  + ]:          3 :         ifa->ifa_local = nla_get_in_addr(tb[IFA_LOCAL]);
     871                 :          3 :         ifa->ifa_address = nla_get_in_addr(tb[IFA_ADDRESS]);
     872                 :            : 
     873         [ -  + ]:          3 :         if (tb[IFA_BROADCAST])
     874                 :          0 :                 ifa->ifa_broadcast = nla_get_in_addr(tb[IFA_BROADCAST]);
     875                 :            : 
     876         [ -  + ]:          3 :         if (tb[IFA_LABEL])
     877                 :          0 :                 nla_strlcpy(ifa->ifa_label, tb[IFA_LABEL], IFNAMSIZ);
     878                 :            :         else
     879                 :          3 :                 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
     880                 :            : 
     881         [ -  + ]:          3 :         if (tb[IFA_RT_PRIORITY])
     882                 :          0 :                 ifa->ifa_rt_priority = nla_get_u32(tb[IFA_RT_PRIORITY]);
     883                 :            : 
     884         [ -  + ]:          3 :         if (tb[IFA_CACHEINFO]) {
     885                 :          0 :                 struct ifa_cacheinfo *ci;
     886                 :            : 
     887         [ #  # ]:          0 :                 ci = nla_data(tb[IFA_CACHEINFO]);
     888   [ #  #  #  # ]:          0 :                 if (!ci->ifa_valid || ci->ifa_prefered > ci->ifa_valid) {
     889                 :          0 :                         err = -EINVAL;
     890                 :          0 :                         goto errout_free;
     891                 :            :                 }
     892                 :          0 :                 *pvalid_lft = ci->ifa_valid;
     893                 :          0 :                 *pprefered_lft = ci->ifa_prefered;
     894                 :            :         }
     895                 :            : 
     896                 :            :         return ifa;
     897                 :            : 
     898                 :            : errout_free:
     899                 :          0 :         inet_free_ifa(ifa);
     900                 :          0 : errout:
     901                 :          0 :         return ERR_PTR(err);
     902                 :            : }
     903                 :            : 
     904                 :          3 : static struct in_ifaddr *find_matching_ifa(struct in_ifaddr *ifa)
     905                 :            : {
     906                 :          3 :         struct in_device *in_dev = ifa->ifa_dev;
     907                 :          3 :         struct in_ifaddr *ifa1;
     908                 :            : 
     909         [ +  - ]:          3 :         if (!ifa->ifa_local)
     910                 :            :                 return NULL;
     911                 :            : 
     912         [ -  + ]:          3 :         in_dev_for_each_ifa_rtnl(ifa1, in_dev) {
     913   [ #  #  #  # ]:          0 :                 if (ifa1->ifa_mask == ifa->ifa_mask &&
     914         [ #  # ]:          0 :                     inet_ifa_match(ifa1->ifa_address, ifa) &&
     915         [ #  # ]:          0 :                     ifa1->ifa_local == ifa->ifa_local)
     916                 :          0 :                         return ifa1;
     917                 :            :         }
     918                 :            :         return NULL;
     919                 :            : }
     920                 :            : 
     921                 :          3 : static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh,
     922                 :            :                             struct netlink_ext_ack *extack)
     923                 :            : {
     924                 :          3 :         struct net *net = sock_net(skb->sk);
     925                 :          3 :         struct in_ifaddr *ifa;
     926                 :          3 :         struct in_ifaddr *ifa_existing;
     927                 :          3 :         __u32 valid_lft = INFINITY_LIFE_TIME;
     928                 :          3 :         __u32 prefered_lft = INFINITY_LIFE_TIME;
     929                 :            : 
     930   [ -  +  -  - ]:          3 :         ASSERT_RTNL();
     931                 :            : 
     932                 :          3 :         ifa = rtm_to_ifaddr(net, nlh, &valid_lft, &prefered_lft, extack);
     933         [ -  + ]:          3 :         if (IS_ERR(ifa))
     934                 :          0 :                 return PTR_ERR(ifa);
     935                 :            : 
     936                 :          3 :         ifa_existing = find_matching_ifa(ifa);
     937         [ +  - ]:          3 :         if (!ifa_existing) {
     938                 :            :                 /* It would be best to check for !NLM_F_CREATE here but
     939                 :            :                  * userspace already relies on not having to provide this.
     940                 :            :                  */
     941                 :          3 :                 set_ifa_lifetime(ifa, valid_lft, prefered_lft);
     942         [ -  + ]:          3 :                 if (ifa->ifa_flags & IFA_F_MCAUTOJOIN) {
     943                 :          0 :                         int ret = ip_mc_config(net->ipv4.mc_autojoin_sk,
     944                 :            :                                                true, ifa);
     945                 :            : 
     946         [ #  # ]:          0 :                         if (ret < 0) {
     947                 :          0 :                                 inet_free_ifa(ifa);
     948                 :          0 :                                 return ret;
     949                 :            :                         }
     950                 :            :                 }
     951                 :          3 :                 return __inet_insert_ifa(ifa, nlh, NETLINK_CB(skb).portid,
     952                 :            :                                          extack);
     953                 :            :         } else {
     954                 :          0 :                 u32 new_metric = ifa->ifa_rt_priority;
     955                 :            : 
     956                 :          0 :                 inet_free_ifa(ifa);
     957                 :            : 
     958         [ #  # ]:          0 :                 if (nlh->nlmsg_flags & NLM_F_EXCL ||
     959                 :            :                     !(nlh->nlmsg_flags & NLM_F_REPLACE))
     960                 :            :                         return -EEXIST;
     961                 :          0 :                 ifa = ifa_existing;
     962                 :            : 
     963         [ #  # ]:          0 :                 if (ifa->ifa_rt_priority != new_metric) {
     964                 :          0 :                         fib_modify_prefix_metric(ifa, new_metric);
     965                 :          0 :                         ifa->ifa_rt_priority = new_metric;
     966                 :            :                 }
     967                 :            : 
     968                 :          0 :                 set_ifa_lifetime(ifa, valid_lft, prefered_lft);
     969                 :          0 :                 cancel_delayed_work(&check_lifetime_work);
     970                 :          0 :                 queue_delayed_work(system_power_efficient_wq,
     971                 :            :                                 &check_lifetime_work, 0);
     972                 :          0 :                 rtmsg_ifa(RTM_NEWADDR, ifa, nlh, NETLINK_CB(skb).portid);
     973                 :            :         }
     974                 :          0 :         return 0;
     975                 :            : }
     976                 :            : 
     977                 :            : /*
     978                 :            :  *      Determine a default network mask, based on the IP address.
     979                 :            :  */
     980                 :            : 
     981                 :          0 : static int inet_abc_len(__be32 addr)
     982                 :            : {
     983                 :          0 :         int rc = -1;    /* Something else, probably a multicast. */
     984                 :            : 
     985   [ #  #  #  #  :          0 :         if (ipv4_is_zeronet(addr) || ipv4_is_lbcast(addr))
                   #  # ]
     986                 :            :                 rc = 0;
     987                 :            :         else {
     988                 :          0 :                 __u32 haddr = ntohl(addr);
     989   [ #  #  #  #  :          0 :                 if (IN_CLASSA(haddr))
                   #  # ]
     990                 :            :                         rc = 8;
     991   [ #  #  #  #  :          0 :                 else if (IN_CLASSB(haddr))
                   #  # ]
     992                 :            :                         rc = 16;
     993   [ #  #  #  #  :          0 :                 else if (IN_CLASSC(haddr))
                   #  # ]
     994                 :            :                         rc = 24;
     995   [ #  #  #  #  :          0 :                 else if (IN_CLASSE(haddr))
                   #  # ]
     996                 :          0 :                         rc = 32;
     997                 :            :         }
     998                 :            : 
     999                 :          0 :         return rc;
    1000                 :            : }
    1001                 :            : 
    1002                 :            : 
    1003                 :          0 : int devinet_ioctl(struct net *net, unsigned int cmd, struct ifreq *ifr)
    1004                 :            : {
    1005                 :          0 :         struct sockaddr_in sin_orig;
    1006                 :          0 :         struct sockaddr_in *sin = (struct sockaddr_in *)&ifr->ifr_addr;
    1007                 :          0 :         struct in_ifaddr __rcu **ifap = NULL;
    1008                 :          0 :         struct in_device *in_dev;
    1009                 :          0 :         struct in_ifaddr *ifa = NULL;
    1010                 :          0 :         struct net_device *dev;
    1011                 :          0 :         char *colon;
    1012                 :          0 :         int ret = -EFAULT;
    1013                 :          0 :         int tryaddrmatch = 0;
    1014                 :            : 
    1015                 :          0 :         ifr->ifr_name[IFNAMSIZ - 1] = 0;
    1016                 :            : 
    1017                 :            :         /* save original address for comparison */
    1018                 :          0 :         memcpy(&sin_orig, sin, sizeof(*sin));
    1019                 :            : 
    1020                 :          0 :         colon = strchr(ifr->ifr_name, ':');
    1021         [ #  # ]:          0 :         if (colon)
    1022                 :          0 :                 *colon = 0;
    1023                 :            : 
    1024                 :          0 :         dev_load(net, ifr->ifr_name);
    1025                 :            : 
    1026   [ #  #  #  # ]:          0 :         switch (cmd) {
    1027                 :          0 :         case SIOCGIFADDR:       /* Get interface address */
    1028                 :            :         case SIOCGIFBRDADDR:    /* Get the broadcast address */
    1029                 :            :         case SIOCGIFDSTADDR:    /* Get the destination address */
    1030                 :            :         case SIOCGIFNETMASK:    /* Get the netmask for the interface */
    1031                 :            :                 /* Note that these ioctls will not sleep,
    1032                 :            :                    so that we do not impose a lock.
    1033                 :            :                    One day we will be forced to put shlock here (I mean SMP)
    1034                 :            :                  */
    1035                 :          0 :                 tryaddrmatch = (sin_orig.sin_family == AF_INET);
    1036                 :          0 :                 memset(sin, 0, sizeof(*sin));
    1037                 :          0 :                 sin->sin_family = AF_INET;
    1038                 :          0 :                 break;
    1039                 :            : 
    1040                 :          0 :         case SIOCSIFFLAGS:
    1041                 :          0 :                 ret = -EPERM;
    1042         [ #  # ]:          0 :                 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
    1043                 :          0 :                         goto out;
    1044                 :            :                 break;
    1045                 :          0 :         case SIOCSIFADDR:       /* Set interface address (and family) */
    1046                 :            :         case SIOCSIFBRDADDR:    /* Set the broadcast address */
    1047                 :            :         case SIOCSIFDSTADDR:    /* Set the destination address */
    1048                 :            :         case SIOCSIFNETMASK:    /* Set the netmask for the interface */
    1049                 :          0 :                 ret = -EPERM;
    1050         [ #  # ]:          0 :                 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
    1051                 :          0 :                         goto out;
    1052                 :          0 :                 ret = -EINVAL;
    1053         [ #  # ]:          0 :                 if (sin->sin_family != AF_INET)
    1054                 :          0 :                         goto out;
    1055                 :            :                 break;
    1056                 :          0 :         default:
    1057                 :          0 :                 ret = -EINVAL;
    1058                 :          0 :                 goto out;
    1059                 :            :         }
    1060                 :            : 
    1061                 :          0 :         rtnl_lock();
    1062                 :            : 
    1063                 :          0 :         ret = -ENODEV;
    1064                 :          0 :         dev = __dev_get_by_name(net, ifr->ifr_name);
    1065         [ #  # ]:          0 :         if (!dev)
    1066                 :          0 :                 goto done;
    1067                 :            : 
    1068         [ #  # ]:          0 :         if (colon)
    1069                 :          0 :                 *colon = ':';
    1070                 :            : 
    1071         [ #  # ]:          0 :         in_dev = __in_dev_get_rtnl(dev);
    1072         [ #  # ]:          0 :         if (in_dev) {
    1073         [ #  # ]:          0 :                 if (tryaddrmatch) {
    1074                 :            :                         /* Matthias Andree */
    1075                 :            :                         /* compare label and address (4.4BSD style) */
    1076                 :            :                         /* note: we only do this for a limited set of ioctls
    1077                 :            :                            and only if the original address family was AF_INET.
    1078                 :            :                            This is checked above. */
    1079                 :            : 
    1080                 :          0 :                         for (ifap = &in_dev->ifa_list;
    1081         [ #  # ]:          0 :                              (ifa = rtnl_dereference(*ifap)) != NULL;
    1082                 :          0 :                              ifap = &ifa->ifa_next) {
    1083         [ #  # ]:          0 :                                 if (!strcmp(ifr->ifr_name, ifa->ifa_label) &&
    1084                 :            :                                     sin_orig.sin_addr.s_addr ==
    1085         [ #  # ]:          0 :                                                         ifa->ifa_local) {
    1086                 :            :                                         break; /* found */
    1087                 :            :                                 }
    1088                 :            :                         }
    1089                 :            :                 }
    1090                 :            :                 /* we didn't get a match, maybe the application is
    1091                 :            :                    4.3BSD-style and passed in junk so we fall back to
    1092                 :            :                    comparing just the label */
    1093         [ #  # ]:          0 :                 if (!ifa) {
    1094                 :          0 :                         for (ifap = &in_dev->ifa_list;
    1095         [ #  # ]:          0 :                              (ifa = rtnl_dereference(*ifap)) != NULL;
    1096                 :          0 :                              ifap = &ifa->ifa_next)
    1097         [ #  # ]:          0 :                                 if (!strcmp(ifr->ifr_name, ifa->ifa_label))
    1098                 :            :                                         break;
    1099                 :            :                 }
    1100                 :            :         }
    1101                 :            : 
    1102                 :          0 :         ret = -EADDRNOTAVAIL;
    1103   [ #  #  #  # ]:          0 :         if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS)
    1104                 :          0 :                 goto done;
    1105                 :            : 
    1106   [ #  #  #  #  :          0 :         switch (cmd) {
          #  #  #  #  #  
                      # ]
    1107                 :          0 :         case SIOCGIFADDR:       /* Get interface address */
    1108                 :          0 :                 ret = 0;
    1109                 :          0 :                 sin->sin_addr.s_addr = ifa->ifa_local;
    1110                 :          0 :                 break;
    1111                 :            : 
    1112                 :          0 :         case SIOCGIFBRDADDR:    /* Get the broadcast address */
    1113                 :          0 :                 ret = 0;
    1114                 :          0 :                 sin->sin_addr.s_addr = ifa->ifa_broadcast;
    1115                 :          0 :                 break;
    1116                 :            : 
    1117                 :          0 :         case SIOCGIFDSTADDR:    /* Get the destination address */
    1118                 :          0 :                 ret = 0;
    1119                 :          0 :                 sin->sin_addr.s_addr = ifa->ifa_address;
    1120                 :          0 :                 break;
    1121                 :            : 
    1122                 :          0 :         case SIOCGIFNETMASK:    /* Get the netmask for the interface */
    1123                 :          0 :                 ret = 0;
    1124                 :          0 :                 sin->sin_addr.s_addr = ifa->ifa_mask;
    1125                 :          0 :                 break;
    1126                 :            : 
    1127                 :          0 :         case SIOCSIFFLAGS:
    1128         [ #  # ]:          0 :                 if (colon) {
    1129                 :          0 :                         ret = -EADDRNOTAVAIL;
    1130         [ #  # ]:          0 :                         if (!ifa)
    1131                 :            :                                 break;
    1132                 :          0 :                         ret = 0;
    1133         [ #  # ]:          0 :                         if (!(ifr->ifr_flags & IFF_UP))
    1134                 :          0 :                                 inet_del_ifa(in_dev, ifap, 1);
    1135                 :            :                         break;
    1136                 :            :                 }
    1137                 :          0 :                 ret = dev_change_flags(dev, ifr->ifr_flags, NULL);
    1138                 :          0 :                 break;
    1139                 :            : 
    1140                 :          0 :         case SIOCSIFADDR:       /* Set interface address (and family) */
    1141                 :          0 :                 ret = -EINVAL;
    1142         [ #  # ]:          0 :                 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
    1143                 :            :                         break;
    1144                 :            : 
    1145         [ #  # ]:          0 :                 if (!ifa) {
    1146                 :          0 :                         ret = -ENOBUFS;
    1147                 :          0 :                         ifa = inet_alloc_ifa();
    1148         [ #  # ]:          0 :                         if (!ifa)
    1149                 :            :                                 break;
    1150         [ #  # ]:          0 :                         INIT_HLIST_NODE(&ifa->hash);
    1151         [ #  # ]:          0 :                         if (colon)
    1152                 :          0 :                                 memcpy(ifa->ifa_label, ifr->ifr_name, IFNAMSIZ);
    1153                 :            :                         else
    1154                 :          0 :                                 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
    1155                 :            :                 } else {
    1156                 :          0 :                         ret = 0;
    1157         [ #  # ]:          0 :                         if (ifa->ifa_local == sin->sin_addr.s_addr)
    1158                 :            :                                 break;
    1159                 :          0 :                         inet_del_ifa(in_dev, ifap, 0);
    1160                 :          0 :                         ifa->ifa_broadcast = 0;
    1161                 :          0 :                         ifa->ifa_scope = 0;
    1162                 :            :                 }
    1163                 :            : 
    1164                 :          0 :                 ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr;
    1165                 :            : 
    1166         [ #  # ]:          0 :                 if (!(dev->flags & IFF_POINTOPOINT)) {
    1167         [ #  # ]:          0 :                         ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address);
    1168         [ #  # ]:          0 :                         ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen);
    1169   [ #  #  #  # ]:          0 :                         if ((dev->flags & IFF_BROADCAST) &&
    1170                 :            :                             ifa->ifa_prefixlen < 31)
    1171                 :          0 :                                 ifa->ifa_broadcast = ifa->ifa_address |
    1172                 :          0 :                                                      ~ifa->ifa_mask;
    1173                 :            :                 } else {
    1174                 :          0 :                         ifa->ifa_prefixlen = 32;
    1175                 :          0 :                         ifa->ifa_mask = inet_make_mask(32);
    1176                 :            :                 }
    1177         [ #  # ]:          0 :                 set_ifa_lifetime(ifa, INFINITY_LIFE_TIME, INFINITY_LIFE_TIME);
    1178                 :          0 :                 ret = inet_set_ifa(dev, ifa);
    1179                 :          0 :                 break;
    1180                 :            : 
    1181                 :          0 :         case SIOCSIFBRDADDR:    /* Set the broadcast address */
    1182                 :          0 :                 ret = 0;
    1183         [ #  # ]:          0 :                 if (ifa->ifa_broadcast != sin->sin_addr.s_addr) {
    1184                 :          0 :                         inet_del_ifa(in_dev, ifap, 0);
    1185                 :          0 :                         ifa->ifa_broadcast = sin->sin_addr.s_addr;
    1186                 :          0 :                         inet_insert_ifa(ifa);
    1187                 :            :                 }
    1188                 :            :                 break;
    1189                 :            : 
    1190                 :          0 :         case SIOCSIFDSTADDR:    /* Set the destination address */
    1191                 :          0 :                 ret = 0;
    1192         [ #  # ]:          0 :                 if (ifa->ifa_address == sin->sin_addr.s_addr)
    1193                 :            :                         break;
    1194                 :          0 :                 ret = -EINVAL;
    1195         [ #  # ]:          0 :                 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
    1196                 :            :                         break;
    1197                 :          0 :                 ret = 0;
    1198                 :          0 :                 inet_del_ifa(in_dev, ifap, 0);
    1199                 :          0 :                 ifa->ifa_address = sin->sin_addr.s_addr;
    1200                 :          0 :                 inet_insert_ifa(ifa);
    1201                 :            :                 break;
    1202                 :            : 
    1203                 :          0 :         case SIOCSIFNETMASK:    /* Set the netmask for the interface */
    1204                 :            : 
    1205                 :            :                 /*
    1206                 :            :                  *      The mask we set must be legal.
    1207                 :            :                  */
    1208                 :          0 :                 ret = -EINVAL;
    1209         [ #  # ]:          0 :                 if (bad_mask(sin->sin_addr.s_addr, 0))
    1210                 :            :                         break;
    1211                 :          0 :                 ret = 0;
    1212         [ #  # ]:          0 :                 if (ifa->ifa_mask != sin->sin_addr.s_addr) {
    1213                 :          0 :                         __be32 old_mask = ifa->ifa_mask;
    1214                 :          0 :                         inet_del_ifa(in_dev, ifap, 0);
    1215                 :          0 :                         ifa->ifa_mask = sin->sin_addr.s_addr;
    1216         [ #  # ]:          0 :                         ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask);
    1217                 :            : 
    1218                 :            :                         /* See if current broadcast address matches
    1219                 :            :                          * with current netmask, then recalculate
    1220                 :            :                          * the broadcast address. Otherwise it's a
    1221                 :            :                          * funny address, so don't touch it since
    1222                 :            :                          * the user seems to know what (s)he's doing...
    1223                 :            :                          */
    1224   [ #  #  #  # ]:          0 :                         if ((dev->flags & IFF_BROADCAST) &&
    1225                 :          0 :                             (ifa->ifa_prefixlen < 31) &&
    1226                 :          0 :                             (ifa->ifa_broadcast ==
    1227         [ #  # ]:          0 :                              (ifa->ifa_local|~old_mask))) {
    1228                 :          0 :                                 ifa->ifa_broadcast = (ifa->ifa_local |
    1229                 :          0 :                                                       ~sin->sin_addr.s_addr);
    1230                 :            :                         }
    1231                 :          0 :                         inet_insert_ifa(ifa);
    1232                 :            :                 }
    1233                 :            :                 break;
    1234                 :            :         }
    1235                 :          0 : done:
    1236                 :          0 :         rtnl_unlock();
    1237                 :          0 : out:
    1238                 :          0 :         return ret;
    1239                 :            : }
    1240                 :            : 
    1241                 :          0 : static int inet_gifconf(struct net_device *dev, char __user *buf, int len, int size)
    1242                 :            : {
    1243         [ #  # ]:          0 :         struct in_device *in_dev = __in_dev_get_rtnl(dev);
    1244                 :          0 :         const struct in_ifaddr *ifa;
    1245                 :          0 :         struct ifreq ifr;
    1246                 :          0 :         int done = 0;
    1247                 :            : 
    1248   [ #  #  #  # ]:          0 :         if (WARN_ON(size > sizeof(struct ifreq)))
    1249                 :          0 :                 goto out;
    1250                 :            : 
    1251         [ #  # ]:          0 :         if (!in_dev)
    1252                 :          0 :                 goto out;
    1253                 :            : 
    1254         [ #  # ]:          0 :         in_dev_for_each_ifa_rtnl(ifa, in_dev) {
    1255         [ #  # ]:          0 :                 if (!buf) {
    1256                 :          0 :                         done += size;
    1257                 :          0 :                         continue;
    1258                 :            :                 }
    1259         [ #  # ]:          0 :                 if (len < size)
    1260                 :            :                         break;
    1261                 :          0 :                 memset(&ifr, 0, sizeof(struct ifreq));
    1262                 :          0 :                 strcpy(ifr.ifr_name, ifa->ifa_label);
    1263                 :            : 
    1264                 :          0 :                 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET;
    1265                 :          0 :                 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr =
    1266                 :          0 :                                                                 ifa->ifa_local;
    1267                 :            : 
    1268   [ #  #  #  # ]:          0 :                 if (copy_to_user(buf + done, &ifr, size)) {
    1269                 :            :                         done = -EFAULT;
    1270                 :            :                         break;
    1271                 :            :                 }
    1272                 :          0 :                 len  -= size;
    1273                 :          0 :                 done += size;
    1274                 :            :         }
    1275                 :          0 : out:
    1276                 :          0 :         return done;
    1277                 :            : }
    1278                 :            : 
    1279                 :         12 : static __be32 in_dev_select_addr(const struct in_device *in_dev,
    1280                 :            :                                  int scope)
    1281                 :            : {
    1282                 :         12 :         const struct in_ifaddr *ifa;
    1283                 :            : 
    1284         [ +  + ]:         18 :         in_dev_for_each_ifa_rcu(ifa, in_dev) {
    1285         [ -  + ]:          6 :                 if (ifa->ifa_flags & IFA_F_SECONDARY)
    1286                 :          0 :                         continue;
    1287         [ +  - ]:          6 :                 if (ifa->ifa_scope != RT_SCOPE_LINK &&
    1288         [ -  + ]:          6 :                     ifa->ifa_scope <= scope)
    1289                 :          0 :                         return ifa->ifa_local;
    1290                 :            :         }
    1291                 :            : 
    1292                 :            :         return 0;
    1293                 :            : }
    1294                 :            : 
    1295                 :         15 : __be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope)
    1296                 :            : {
    1297                 :         15 :         const struct in_ifaddr *ifa;
    1298                 :         15 :         __be32 addr = 0;
    1299                 :         15 :         unsigned char localnet_scope = RT_SCOPE_HOST;
    1300                 :         15 :         struct in_device *in_dev;
    1301                 :         15 :         struct net *net = dev_net(dev);
    1302                 :         15 :         int master_idx;
    1303                 :            : 
    1304                 :         15 :         rcu_read_lock();
    1305         [ -  + ]:         15 :         in_dev = __in_dev_get_rcu(dev);
    1306         [ -  + ]:         15 :         if (!in_dev)
    1307                 :          0 :                 goto no_in_dev;
    1308                 :            : 
    1309   [ +  -  -  + ]:         15 :         if (unlikely(IN_DEV_ROUTE_LOCALNET(in_dev)))
    1310                 :            :                 localnet_scope = RT_SCOPE_LINK;
    1311                 :            : 
    1312         [ +  + ]:         21 :         in_dev_for_each_ifa_rcu(ifa, in_dev) {
    1313         [ -  + ]:         15 :                 if (ifa->ifa_flags & IFA_F_SECONDARY)
    1314                 :          0 :                         continue;
    1315         [ +  + ]:         15 :                 if (min(ifa->ifa_scope, localnet_scope) > scope)
    1316                 :          6 :                         continue;
    1317   [ -  +  -  - ]:          9 :                 if (!dst || inet_ifa_match(dst, ifa)) {
    1318                 :          9 :                         addr = ifa->ifa_local;
    1319                 :          9 :                         break;
    1320                 :            :                 }
    1321         [ #  # ]:          0 :                 if (!addr)
    1322                 :          0 :                         addr = ifa->ifa_local;
    1323                 :            :         }
    1324                 :            : 
    1325         [ +  + ]:         15 :         if (addr)
    1326                 :          9 :                 goto out_unlock;
    1327                 :          6 : no_in_dev:
    1328                 :          6 :         master_idx = l3mdev_master_ifindex_rcu(dev);
    1329                 :            : 
    1330                 :            :         /* For VRFs, the VRF device takes the place of the loopback device,
    1331                 :            :          * with addresses on it being preferred.  Note in such cases the
    1332                 :            :          * loopback device will be among the devices that fail the master_idx
    1333                 :            :          * equality check in the loop below.
    1334                 :            :          */
    1335                 :          6 :         if (master_idx &&
    1336                 :            :             (dev = dev_get_by_index_rcu(net, master_idx)) &&
    1337                 :            :             (in_dev = __in_dev_get_rcu(dev))) {
    1338                 :            :                 addr = in_dev_select_addr(in_dev, scope);
    1339                 :            :                 if (addr)
    1340                 :            :                         goto out_unlock;
    1341                 :            :         }
    1342                 :            : 
    1343                 :            :         /* Not loopback addresses on loopback should be preferred
    1344                 :            :            in this case. It is important that lo is the first interface
    1345                 :            :            in dev_base list.
    1346                 :            :          */
    1347         [ +  + ]:         18 :         for_each_netdev_rcu(net, dev) {
    1348         [ -  + ]:         12 :                 if (l3mdev_master_ifindex_rcu(dev) != master_idx)
    1349                 :            :                         continue;
    1350                 :            : 
    1351         [ -  + ]:         12 :                 in_dev = __in_dev_get_rcu(dev);
    1352         [ -  + ]:         12 :                 if (!in_dev)
    1353                 :          0 :                         continue;
    1354                 :            : 
    1355                 :         12 :                 addr = in_dev_select_addr(in_dev, scope);
    1356         [ -  + ]:         12 :                 if (addr)
    1357                 :          0 :                         goto out_unlock;
    1358                 :            :         }
    1359                 :          6 : out_unlock:
    1360                 :         15 :         rcu_read_unlock();
    1361                 :         15 :         return addr;
    1362                 :            : }
    1363                 :            : EXPORT_SYMBOL(inet_select_addr);
    1364                 :            : 
    1365                 :          0 : static __be32 confirm_addr_indev(struct in_device *in_dev, __be32 dst,
    1366                 :            :                               __be32 local, int scope)
    1367                 :            : {
    1368                 :          0 :         unsigned char localnet_scope = RT_SCOPE_HOST;
    1369                 :          0 :         const struct in_ifaddr *ifa;
    1370                 :          0 :         __be32 addr = 0;
    1371                 :          0 :         int same = 0;
    1372                 :            : 
    1373   [ #  #  #  # ]:          0 :         if (unlikely(IN_DEV_ROUTE_LOCALNET(in_dev)))
    1374                 :            :                 localnet_scope = RT_SCOPE_LINK;
    1375                 :            : 
    1376         [ #  # ]:          0 :         in_dev_for_each_ifa_rcu(ifa, in_dev) {
    1377                 :          0 :                 unsigned char min_scope = min(ifa->ifa_scope, localnet_scope);
    1378                 :            : 
    1379         [ #  # ]:          0 :                 if (!addr &&
    1380   [ #  #  #  #  :          0 :                     (local == ifa->ifa_local || !local) &&
                   #  # ]
    1381                 :            :                     min_scope <= scope) {
    1382                 :          0 :                         addr = ifa->ifa_local;
    1383         [ #  # ]:          0 :                         if (same)
    1384                 :            :                                 break;
    1385                 :            :                 }
    1386         [ #  # ]:          0 :                 if (!same) {
    1387   [ #  #  #  #  :          0 :                         same = (!local || inet_ifa_match(local, ifa)) &&
                   #  # ]
    1388         [ #  # ]:          0 :                                 (!dst || inet_ifa_match(dst, ifa));
    1389         [ #  # ]:          0 :                         if (same && addr) {
    1390         [ #  # ]:          0 :                                 if (local || !dst)
    1391                 :            :                                         break;
    1392                 :            :                                 /* Is the selected addr into dst subnet? */
    1393         [ #  # ]:          0 :                                 if (inet_ifa_match(addr, ifa))
    1394                 :            :                                         break;
    1395                 :            :                                 /* No, then can we use new local src? */
    1396         [ #  # ]:          0 :                                 if (min_scope <= scope) {
    1397                 :          0 :                                         addr = ifa->ifa_local;
    1398                 :          0 :                                         break;
    1399                 :            :                                 }
    1400                 :            :                                 /* search for large dst subnet for addr */
    1401                 :            :                                 same = 0;
    1402                 :            :                         }
    1403                 :            :                 }
    1404                 :            :         }
    1405                 :            : 
    1406         [ #  # ]:          0 :         return same ? addr : 0;
    1407                 :            : }
    1408                 :            : 
    1409                 :            : /*
    1410                 :            :  * Confirm that local IP address exists using wildcards:
    1411                 :            :  * - net: netns to check, cannot be NULL
    1412                 :            :  * - in_dev: only on this interface, NULL=any interface
    1413                 :            :  * - dst: only in the same subnet as dst, 0=any dst
    1414                 :            :  * - local: address, 0=autoselect the local address
    1415                 :            :  * - scope: maximum allowed scope value for the local address
    1416                 :            :  */
    1417                 :          0 : __be32 inet_confirm_addr(struct net *net, struct in_device *in_dev,
    1418                 :            :                          __be32 dst, __be32 local, int scope)
    1419                 :            : {
    1420                 :          0 :         __be32 addr = 0;
    1421                 :          0 :         struct net_device *dev;
    1422                 :            : 
    1423         [ #  # ]:          0 :         if (in_dev)
    1424                 :          0 :                 return confirm_addr_indev(in_dev, dst, local, scope);
    1425                 :            : 
    1426                 :          0 :         rcu_read_lock();
    1427         [ #  # ]:          0 :         for_each_netdev_rcu(net, dev) {
    1428         [ #  # ]:          0 :                 in_dev = __in_dev_get_rcu(dev);
    1429         [ #  # ]:          0 :                 if (in_dev) {
    1430                 :          0 :                         addr = confirm_addr_indev(in_dev, dst, local, scope);
    1431         [ #  # ]:          0 :                         if (addr)
    1432                 :            :                                 break;
    1433                 :            :                 }
    1434                 :            :         }
    1435                 :          0 :         rcu_read_unlock();
    1436                 :            : 
    1437                 :          0 :         return addr;
    1438                 :            : }
    1439                 :            : EXPORT_SYMBOL(inet_confirm_addr);
    1440                 :            : 
    1441                 :            : /*
    1442                 :            :  *      Device notifier
    1443                 :            :  */
    1444                 :            : 
    1445                 :          3 : int register_inetaddr_notifier(struct notifier_block *nb)
    1446                 :            : {
    1447                 :          3 :         return blocking_notifier_chain_register(&inetaddr_chain, nb);
    1448                 :            : }
    1449                 :            : EXPORT_SYMBOL(register_inetaddr_notifier);
    1450                 :            : 
    1451                 :          0 : int unregister_inetaddr_notifier(struct notifier_block *nb)
    1452                 :            : {
    1453                 :          0 :         return blocking_notifier_chain_unregister(&inetaddr_chain, nb);
    1454                 :            : }
    1455                 :            : EXPORT_SYMBOL(unregister_inetaddr_notifier);
    1456                 :            : 
    1457                 :          0 : int register_inetaddr_validator_notifier(struct notifier_block *nb)
    1458                 :            : {
    1459                 :          0 :         return blocking_notifier_chain_register(&inetaddr_validator_chain, nb);
    1460                 :            : }
    1461                 :            : EXPORT_SYMBOL(register_inetaddr_validator_notifier);
    1462                 :            : 
    1463                 :          0 : int unregister_inetaddr_validator_notifier(struct notifier_block *nb)
    1464                 :            : {
    1465                 :          0 :         return blocking_notifier_chain_unregister(&inetaddr_validator_chain,
    1466                 :            :             nb);
    1467                 :            : }
    1468                 :            : EXPORT_SYMBOL(unregister_inetaddr_validator_notifier);
    1469                 :            : 
    1470                 :            : /* Rename ifa_labels for a device name change. Make some effort to preserve
    1471                 :            :  * existing alias numbering and to create unique labels if possible.
    1472                 :            : */
    1473                 :            : static void inetdev_changename(struct net_device *dev, struct in_device *in_dev)
    1474                 :            : {
    1475                 :            :         struct in_ifaddr *ifa;
    1476                 :            :         int named = 0;
    1477                 :            : 
    1478                 :            :         in_dev_for_each_ifa_rtnl(ifa, in_dev) {
    1479                 :            :                 char old[IFNAMSIZ], *dot;
    1480                 :            : 
    1481                 :            :                 memcpy(old, ifa->ifa_label, IFNAMSIZ);
    1482                 :            :                 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
    1483                 :            :                 if (named++ == 0)
    1484                 :            :                         goto skip;
    1485                 :            :                 dot = strchr(old, ':');
    1486                 :            :                 if (!dot) {
    1487                 :            :                         sprintf(old, ":%d", named);
    1488                 :            :                         dot = old;
    1489                 :            :                 }
    1490                 :            :                 if (strlen(dot) + strlen(dev->name) < IFNAMSIZ)
    1491                 :            :                         strcat(ifa->ifa_label, dot);
    1492                 :            :                 else
    1493                 :            :                         strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot);
    1494                 :            : skip:
    1495                 :            :                 rtmsg_ifa(RTM_NEWADDR, ifa, NULL, 0);
    1496                 :            :         }
    1497                 :            : }
    1498                 :            : 
    1499                 :            : static void inetdev_send_gratuitous_arp(struct net_device *dev,
    1500                 :            :                                         struct in_device *in_dev)
    1501                 :            : 
    1502                 :            : {
    1503                 :            :         const struct in_ifaddr *ifa;
    1504                 :            : 
    1505                 :            :         in_dev_for_each_ifa_rtnl(ifa, in_dev) {
    1506                 :            :                 arp_send(ARPOP_REQUEST, ETH_P_ARP,
    1507                 :            :                          ifa->ifa_local, dev,
    1508                 :            :                          ifa->ifa_local, NULL,
    1509                 :            :                          dev->dev_addr, NULL);
    1510                 :            :         }
    1511                 :            : }
    1512                 :            : 
    1513                 :            : /* Called only under RTNL semaphore */
    1514                 :            : 
    1515                 :         30 : static int inetdev_event(struct notifier_block *this, unsigned long event,
    1516                 :            :                          void *ptr)
    1517                 :            : {
    1518                 :         30 :         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
    1519                 :         30 :         struct in_device *in_dev = __in_dev_get_rtnl(dev);
    1520                 :            : 
    1521   [ -  +  -  - ]:         30 :         ASSERT_RTNL();
    1522                 :            : 
    1523         [ +  + ]:         30 :         if (!in_dev) {
    1524         [ +  + ]:         15 :                 if (event == NETDEV_REGISTER) {
    1525                 :          9 :                         in_dev = inetdev_init(dev);
    1526         [ -  + ]:          9 :                         if (IS_ERR(in_dev))
    1527         [ #  # ]:          0 :                                 return notifier_from_errno(PTR_ERR(in_dev));
    1528         [ +  + ]:          9 :                         if (dev->flags & IFF_LOOPBACK) {
    1529                 :          3 :                                 IN_DEV_CONF_SET(in_dev, NOXFRM, 1);
    1530                 :          3 :                                 IN_DEV_CONF_SET(in_dev, NOPOLICY, 1);
    1531                 :            :                         }
    1532         [ -  + ]:          6 :                 } else if (event == NETDEV_CHANGEMTU) {
    1533                 :            :                         /* Re-enabling IP */
    1534         [ #  # ]:          0 :                         if (inetdev_valid_mtu(dev->mtu))
    1535                 :          0 :                                 in_dev = inetdev_init(dev);
    1536                 :            :                 }
    1537                 :         15 :                 goto out;
    1538                 :            :         }
    1539                 :            : 
    1540   [ -  +  -  -  :         15 :         switch (event) {
          -  -  -  -  -  
                   -  + ]
    1541                 :            :         case NETDEV_REGISTER:
    1542                 :          0 :                 pr_debug("%s: bug\n", __func__);
    1543                 :          0 :                 RCU_INIT_POINTER(dev->ip_ptr, NULL);
    1544                 :          0 :                 break;
    1545                 :          6 :         case NETDEV_UP:
    1546         [ -  + ]:          6 :                 if (!inetdev_valid_mtu(dev->mtu))
    1547                 :            :                         break;
    1548         [ +  + ]:          6 :                 if (dev->flags & IFF_LOOPBACK) {
    1549                 :          3 :                         struct in_ifaddr *ifa = inet_alloc_ifa();
    1550                 :            : 
    1551         [ +  - ]:          3 :                         if (ifa) {
    1552                 :          3 :                                 INIT_HLIST_NODE(&ifa->hash);
    1553                 :          3 :                                 ifa->ifa_local =
    1554                 :          3 :                                   ifa->ifa_address = htonl(INADDR_LOOPBACK);
    1555                 :          3 :                                 ifa->ifa_prefixlen = 8;
    1556                 :          3 :                                 ifa->ifa_mask = inet_make_mask(8);
    1557                 :          3 :                                 in_dev_hold(in_dev);
    1558                 :          3 :                                 ifa->ifa_dev = in_dev;
    1559                 :          3 :                                 ifa->ifa_scope = RT_SCOPE_HOST;
    1560                 :          3 :                                 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
    1561         [ +  - ]:          3 :                                 set_ifa_lifetime(ifa, INFINITY_LIFE_TIME,
    1562                 :            :                                                  INFINITY_LIFE_TIME);
    1563                 :          3 :                                 ipv4_devconf_setall(in_dev);
    1564                 :          3 :                                 neigh_parms_data_state_setall(in_dev->arp_parms);
    1565                 :          3 :                                 inet_insert_ifa(ifa);
    1566                 :            :                         }
    1567                 :            :                 }
    1568                 :          6 :                 ip_mc_up(in_dev);
    1569                 :            :                 /* fall through */
    1570                 :          6 :         case NETDEV_CHANGEADDR:
    1571         [ +  - ]:          6 :                 if (!IN_DEV_ARP_NOTIFY(in_dev))
    1572                 :            :                         break;
    1573                 :            :                 /* fall through */
    1574                 :            :         case NETDEV_NOTIFY_PEERS:
    1575                 :            :                 /* Send gratuitous ARP to notify of link change */
    1576                 :          0 :                 inetdev_send_gratuitous_arp(dev, in_dev);
    1577                 :          0 :                 break;
    1578                 :          0 :         case NETDEV_DOWN:
    1579                 :          0 :                 ip_mc_down(in_dev);
    1580                 :          0 :                 break;
    1581                 :          0 :         case NETDEV_PRE_TYPE_CHANGE:
    1582                 :          0 :                 ip_mc_unmap(in_dev);
    1583                 :          0 :                 break;
    1584                 :          0 :         case NETDEV_POST_TYPE_CHANGE:
    1585                 :          0 :                 ip_mc_remap(in_dev);
    1586                 :          0 :                 break;
    1587                 :          0 :         case NETDEV_CHANGEMTU:
    1588         [ #  # ]:          0 :                 if (inetdev_valid_mtu(dev->mtu))
    1589                 :            :                         break;
    1590                 :            :                 /* disable IP when MTU is not enough */
    1591                 :            :                 /* fall through */
    1592                 :            :         case NETDEV_UNREGISTER:
    1593                 :          0 :                 inetdev_destroy(in_dev);
    1594                 :          0 :                 break;
    1595                 :          0 :         case NETDEV_CHANGENAME:
    1596                 :            :                 /* Do not notify about label change, this event is
    1597                 :            :                  * not interesting to applications using netlink.
    1598                 :            :                  */
    1599                 :          0 :                 inetdev_changename(dev, in_dev);
    1600                 :            : 
    1601                 :          0 :                 devinet_sysctl_unregister(in_dev);
    1602                 :          0 :                 devinet_sysctl_register(in_dev);
    1603                 :          0 :                 break;
    1604                 :            :         }
    1605                 :          6 : out:
    1606                 :            :         return NOTIFY_DONE;
    1607                 :            : }
    1608                 :            : 
    1609                 :            : static struct notifier_block ip_netdev_notifier = {
    1610                 :            :         .notifier_call = inetdev_event,
    1611                 :            : };
    1612                 :            : 
    1613                 :          3 : static size_t inet_nlmsg_size(void)
    1614                 :            : {
    1615                 :          3 :         return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
    1616                 :            :                + nla_total_size(4) /* IFA_ADDRESS */
    1617                 :            :                + nla_total_size(4) /* IFA_LOCAL */
    1618                 :            :                + nla_total_size(4) /* IFA_BROADCAST */
    1619                 :            :                + nla_total_size(IFNAMSIZ) /* IFA_LABEL */
    1620                 :            :                + nla_total_size(4)  /* IFA_FLAGS */
    1621                 :            :                + nla_total_size(4)  /* IFA_RT_PRIORITY */
    1622                 :            :                + nla_total_size(sizeof(struct ifa_cacheinfo)); /* IFA_CACHEINFO */
    1623                 :            : }
    1624                 :            : 
    1625                 :         21 : static inline u32 cstamp_delta(unsigned long cstamp)
    1626                 :            : {
    1627                 :         21 :         return (cstamp - INITIAL_JIFFIES) * 100UL / HZ;
    1628                 :            : }
    1629                 :            : 
    1630                 :         21 : static int put_cacheinfo(struct sk_buff *skb, unsigned long cstamp,
    1631                 :            :                          unsigned long tstamp, u32 preferred, u32 valid)
    1632                 :            : {
    1633                 :         21 :         struct ifa_cacheinfo ci;
    1634                 :            : 
    1635                 :         21 :         ci.cstamp = cstamp_delta(cstamp);
    1636                 :         21 :         ci.tstamp = cstamp_delta(tstamp);
    1637                 :         21 :         ci.ifa_prefered = preferred;
    1638                 :         21 :         ci.ifa_valid = valid;
    1639                 :            : 
    1640                 :         21 :         return nla_put(skb, IFA_CACHEINFO, sizeof(ci), &ci);
    1641                 :            : }
    1642                 :            : 
    1643                 :         21 : static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
    1644                 :            :                             struct inet_fill_args *args)
    1645                 :            : {
    1646                 :         21 :         struct ifaddrmsg *ifm;
    1647                 :         21 :         struct nlmsghdr  *nlh;
    1648                 :         21 :         u32 preferred, valid;
    1649                 :            : 
    1650                 :         21 :         nlh = nlmsg_put(skb, args->portid, args->seq, args->event, sizeof(*ifm),
    1651         [ +  - ]:         21 :                         args->flags);
    1652         [ -  + ]:         21 :         if (!nlh)
    1653                 :          0 :                 return -EMSGSIZE;
    1654                 :            : 
    1655         [ -  + ]:         21 :         ifm = nlmsg_data(nlh);
    1656                 :         21 :         ifm->ifa_family = AF_INET;
    1657                 :         21 :         ifm->ifa_prefixlen = ifa->ifa_prefixlen;
    1658                 :         21 :         ifm->ifa_flags = ifa->ifa_flags;
    1659                 :         21 :         ifm->ifa_scope = ifa->ifa_scope;
    1660                 :         21 :         ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
    1661                 :            : 
    1662   [ -  +  -  - ]:         21 :         if (args->netnsid >= 0 &&
    1663                 :            :             nla_put_s32(skb, IFA_TARGET_NETNSID, args->netnsid))
    1664                 :          0 :                 goto nla_put_failure;
    1665                 :            : 
    1666         [ -  + ]:         21 :         if (!(ifm->ifa_flags & IFA_F_PERMANENT)) {
    1667                 :          0 :                 preferred = ifa->ifa_preferred_lft;
    1668                 :          0 :                 valid = ifa->ifa_valid_lft;
    1669         [ #  # ]:          0 :                 if (preferred != INFINITY_LIFE_TIME) {
    1670                 :          0 :                         long tval = (jiffies - ifa->ifa_tstamp) / HZ;
    1671                 :            : 
    1672         [ #  # ]:          0 :                         if (preferred > tval)
    1673                 :          0 :                                 preferred -= tval;
    1674                 :            :                         else
    1675                 :            :                                 preferred = 0;
    1676         [ #  # ]:          0 :                         if (valid != INFINITY_LIFE_TIME) {
    1677         [ #  # ]:          0 :                                 if (valid > tval)
    1678                 :          0 :                                         valid -= tval;
    1679                 :            :                                 else
    1680                 :            :                                         valid = 0;
    1681                 :            :                         }
    1682                 :            :                 }
    1683                 :            :         } else {
    1684                 :            :                 preferred = INFINITY_LIFE_TIME;
    1685                 :            :                 valid = INFINITY_LIFE_TIME;
    1686                 :            :         }
    1687   [ +  -  +  - ]:         42 :         if ((ifa->ifa_address &&
    1688                 :         21 :              nla_put_in_addr(skb, IFA_ADDRESS, ifa->ifa_address)) ||
    1689   [ +  -  +  - ]:         42 :             (ifa->ifa_local &&
    1690                 :         21 :              nla_put_in_addr(skb, IFA_LOCAL, ifa->ifa_local)) ||
    1691   [ -  +  -  - ]:         21 :             (ifa->ifa_broadcast &&
    1692                 :         21 :              nla_put_in_addr(skb, IFA_BROADCAST, ifa->ifa_broadcast)) ||
    1693   [ +  -  +  - ]:         42 :             (ifa->ifa_label[0] &&
    1694         [ +  - ]:         42 :              nla_put_string(skb, IFA_LABEL, ifa->ifa_label)) ||
    1695                 :         21 :             nla_put_u32(skb, IFA_FLAGS, ifa->ifa_flags) ||
    1696   [ -  +  -  - ]:         21 :             (ifa->ifa_rt_priority &&
    1697         [ -  + ]:         21 :              nla_put_u32(skb, IFA_RT_PRIORITY, ifa->ifa_rt_priority)) ||
    1698                 :         21 :             put_cacheinfo(skb, ifa->ifa_cstamp, ifa->ifa_tstamp,
    1699                 :            :                           preferred, valid))
    1700                 :          0 :                 goto nla_put_failure;
    1701                 :            : 
    1702                 :         21 :         nlmsg_end(skb, nlh);
    1703                 :         21 :         return 0;
    1704                 :            : 
    1705                 :          0 : nla_put_failure:
    1706                 :          0 :         nlmsg_cancel(skb, nlh);
    1707                 :          0 :         return -EMSGSIZE;
    1708                 :            : }
    1709                 :            : 
    1710                 :            : static int inet_valid_dump_ifaddr_req(const struct nlmsghdr *nlh,
    1711                 :            :                                       struct inet_fill_args *fillargs,
    1712                 :            :                                       struct net **tgt_net, struct sock *sk,
    1713                 :            :                                       struct netlink_callback *cb)
    1714                 :            : {
    1715                 :            :         struct netlink_ext_ack *extack = cb->extack;
    1716                 :            :         struct nlattr *tb[IFA_MAX+1];
    1717                 :            :         struct ifaddrmsg *ifm;
    1718                 :            :         int err, i;
    1719                 :            : 
    1720                 :            :         if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifm))) {
    1721                 :            :                 NL_SET_ERR_MSG(extack, "ipv4: Invalid header for address dump request");
    1722                 :            :                 return -EINVAL;
    1723                 :            :         }
    1724                 :            : 
    1725                 :            :         ifm = nlmsg_data(nlh);
    1726                 :            :         if (ifm->ifa_prefixlen || ifm->ifa_flags || ifm->ifa_scope) {
    1727                 :            :                 NL_SET_ERR_MSG(extack, "ipv4: Invalid values in header for address dump request");
    1728                 :            :                 return -EINVAL;
    1729                 :            :         }
    1730                 :            : 
    1731                 :            :         fillargs->ifindex = ifm->ifa_index;
    1732                 :            :         if (fillargs->ifindex) {
    1733                 :            :                 cb->answer_flags |= NLM_F_DUMP_FILTERED;
    1734                 :            :                 fillargs->flags |= NLM_F_DUMP_FILTERED;
    1735                 :            :         }
    1736                 :            : 
    1737                 :            :         err = nlmsg_parse_deprecated_strict(nlh, sizeof(*ifm), tb, IFA_MAX,
    1738                 :            :                                             ifa_ipv4_policy, extack);
    1739                 :            :         if (err < 0)
    1740                 :            :                 return err;
    1741                 :            : 
    1742                 :            :         for (i = 0; i <= IFA_MAX; ++i) {
    1743                 :            :                 if (!tb[i])
    1744                 :            :                         continue;
    1745                 :            : 
    1746                 :            :                 if (i == IFA_TARGET_NETNSID) {
    1747                 :            :                         struct net *net;
    1748                 :            : 
    1749                 :            :                         fillargs->netnsid = nla_get_s32(tb[i]);
    1750                 :            : 
    1751                 :            :                         net = rtnl_get_net_ns_capable(sk, fillargs->netnsid);
    1752                 :            :                         if (IS_ERR(net)) {
    1753                 :            :                                 fillargs->netnsid = -1;
    1754                 :            :                                 NL_SET_ERR_MSG(extack, "ipv4: Invalid target network namespace id");
    1755                 :            :                                 return PTR_ERR(net);
    1756                 :            :                         }
    1757                 :            :                         *tgt_net = net;
    1758                 :            :                 } else {
    1759                 :            :                         NL_SET_ERR_MSG(extack, "ipv4: Unsupported attribute in dump request");
    1760                 :            :                         return -EINVAL;
    1761                 :            :                 }
    1762                 :            :         }
    1763                 :            : 
    1764                 :            :         return 0;
    1765                 :            : }
    1766                 :            : 
    1767                 :            : static int in_dev_dump_addr(struct in_device *in_dev, struct sk_buff *skb,
    1768                 :            :                             struct netlink_callback *cb, int s_ip_idx,
    1769                 :            :                             struct inet_fill_args *fillargs)
    1770                 :            : {
    1771                 :            :         struct in_ifaddr *ifa;
    1772                 :            :         int ip_idx = 0;
    1773                 :            :         int err;
    1774                 :            : 
    1775                 :            :         in_dev_for_each_ifa_rtnl(ifa, in_dev) {
    1776                 :            :                 if (ip_idx < s_ip_idx) {
    1777                 :            :                         ip_idx++;
    1778                 :            :                         continue;
    1779                 :            :                 }
    1780                 :            :                 err = inet_fill_ifaddr(skb, ifa, fillargs);
    1781                 :            :                 if (err < 0)
    1782                 :            :                         goto done;
    1783                 :            : 
    1784                 :            :                 nl_dump_check_consistent(cb, nlmsg_hdr(skb));
    1785                 :            :                 ip_idx++;
    1786                 :            :         }
    1787                 :            :         err = 0;
    1788                 :            : 
    1789                 :            : done:
    1790                 :            :         cb->args[2] = ip_idx;
    1791                 :            : 
    1792                 :            :         return err;
    1793                 :            : }
    1794                 :            : 
    1795                 :         36 : static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
    1796                 :            : {
    1797                 :         36 :         const struct nlmsghdr *nlh = cb->nlh;
    1798                 :         36 :         struct inet_fill_args fillargs = {
    1799                 :         36 :                 .portid = NETLINK_CB(cb->skb).portid,
    1800                 :         36 :                 .seq = nlh->nlmsg_seq,
    1801                 :            :                 .event = RTM_NEWADDR,
    1802                 :            :                 .flags = NLM_F_MULTI,
    1803                 :            :                 .netnsid = -1,
    1804                 :            :         };
    1805         [ -  + ]:         36 :         struct net *net = sock_net(skb->sk);
    1806                 :         36 :         struct net *tgt_net = net;
    1807                 :         36 :         int h, s_h;
    1808                 :         36 :         int idx, s_idx;
    1809                 :         36 :         int s_ip_idx;
    1810                 :         36 :         struct net_device *dev;
    1811                 :         36 :         struct in_device *in_dev;
    1812                 :         36 :         struct hlist_head *head;
    1813                 :         36 :         int err = 0;
    1814                 :            : 
    1815                 :         36 :         s_h = cb->args[0];
    1816                 :         36 :         s_idx = idx = cb->args[1];
    1817                 :         36 :         s_ip_idx = cb->args[2];
    1818                 :            : 
    1819         [ -  + ]:         36 :         if (cb->strict_check) {
    1820                 :          0 :                 err = inet_valid_dump_ifaddr_req(nlh, &fillargs, &tgt_net,
    1821                 :            :                                                  skb->sk, cb);
    1822         [ #  # ]:          0 :                 if (err < 0)
    1823                 :          0 :                         goto put_tgt_net;
    1824                 :            : 
    1825                 :          0 :                 err = 0;
    1826         [ #  # ]:          0 :                 if (fillargs.ifindex) {
    1827                 :          0 :                         dev = __dev_get_by_index(tgt_net, fillargs.ifindex);
    1828         [ #  # ]:          0 :                         if (!dev) {
    1829                 :          0 :                                 err = -ENODEV;
    1830                 :          0 :                                 goto put_tgt_net;
    1831                 :            :                         }
    1832                 :            : 
    1833         [ #  # ]:          0 :                         in_dev = __in_dev_get_rtnl(dev);
    1834         [ #  # ]:          0 :                         if (in_dev) {
    1835                 :          0 :                                 err = in_dev_dump_addr(in_dev, skb, cb, s_ip_idx,
    1836                 :            :                                                        &fillargs);
    1837                 :            :                         }
    1838                 :          0 :                         goto put_tgt_net;
    1839                 :            :                 }
    1840                 :            :         }
    1841                 :            : 
    1842         [ +  + ]:       4644 :         for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
    1843                 :       4608 :                 idx = 0;
    1844                 :       4608 :                 head = &tgt_net->dev_index_head[h];
    1845                 :       4608 :                 rcu_read_lock();
    1846                 :       4608 :                 cb->seq = atomic_read(&tgt_net->ipv4.dev_addr_genid) ^
    1847                 :       4608 :                           tgt_net->dev_base_seq;
    1848   [ +  +  +  + ]:       9255 :                 hlist_for_each_entry_rcu(dev, head, index_hlist) {
    1849         [ -  + ]:         39 :                         if (idx < s_idx)
    1850                 :          0 :                                 goto cont;
    1851         [ +  - ]:         39 :                         if (h > s_h || idx > s_idx)
    1852                 :         39 :                                 s_ip_idx = 0;
    1853         [ -  + ]:         39 :                         in_dev = __in_dev_get_rcu(dev);
    1854         [ -  + ]:         39 :                         if (!in_dev)
    1855                 :          0 :                                 goto cont;
    1856                 :            : 
    1857                 :         39 :                         err = in_dev_dump_addr(in_dev, skb, cb, s_ip_idx,
    1858                 :            :                                                &fillargs);
    1859         [ -  + ]:         39 :                         if (err < 0) {
    1860                 :          0 :                                 rcu_read_unlock();
    1861                 :          0 :                                 goto done;
    1862                 :            :                         }
    1863                 :         39 : cont:
    1864         [ -  + ]:         39 :                         idx++;
    1865                 :            :                 }
    1866                 :       4608 :                 rcu_read_unlock();
    1867                 :            :         }
    1868                 :            : 
    1869                 :         36 : done:
    1870                 :         36 :         cb->args[0] = h;
    1871                 :         36 :         cb->args[1] = idx;
    1872                 :         36 : put_tgt_net:
    1873         [ -  + ]:         36 :         if (fillargs.netnsid >= 0)
    1874                 :          0 :                 put_net(tgt_net);
    1875                 :            : 
    1876         [ +  + ]:         36 :         return skb->len ? : err;
    1877                 :            : }
    1878                 :            : 
    1879                 :          3 : static void rtmsg_ifa(int event, struct in_ifaddr *ifa, struct nlmsghdr *nlh,
    1880                 :            :                       u32 portid)
    1881                 :            : {
    1882                 :          6 :         struct inet_fill_args fillargs = {
    1883                 :            :                 .portid = portid,
    1884         [ +  - ]:          3 :                 .seq = nlh ? nlh->nlmsg_seq : 0,
    1885                 :            :                 .event = event,
    1886                 :            :                 .flags = 0,
    1887                 :            :                 .netnsid = -1,
    1888                 :            :         };
    1889                 :          3 :         struct sk_buff *skb;
    1890                 :          3 :         int err = -ENOBUFS;
    1891                 :          3 :         struct net *net;
    1892                 :            : 
    1893                 :          3 :         net = dev_net(ifa->ifa_dev->dev);
    1894                 :          3 :         skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL);
    1895         [ -  + ]:          3 :         if (!skb)
    1896                 :          0 :                 goto errout;
    1897                 :            : 
    1898                 :          3 :         err = inet_fill_ifaddr(skb, ifa, &fillargs);
    1899         [ -  + ]:          3 :         if (err < 0) {
    1900                 :            :                 /* -EMSGSIZE implies BUG in inet_nlmsg_size() */
    1901         [ #  # ]:          0 :                 WARN_ON(err == -EMSGSIZE);
    1902                 :          0 :                 kfree_skb(skb);
    1903                 :          0 :                 goto errout;
    1904                 :            :         }
    1905                 :          3 :         rtnl_notify(skb, net, portid, RTNLGRP_IPV4_IFADDR, nlh, GFP_KERNEL);
    1906                 :          3 :         return;
    1907                 :            : errout:
    1908                 :          0 :         if (err < 0)
    1909                 :          0 :                 rtnl_set_sk_err(net, RTNLGRP_IPV4_IFADDR, err);
    1910                 :            : }
    1911                 :            : 
    1912                 :         24 : static size_t inet_get_link_af_size(const struct net_device *dev,
    1913                 :            :                                     u32 ext_filter_mask)
    1914                 :            : {
    1915         [ -  + ]:         24 :         struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr);
    1916                 :            : 
    1917         [ -  + ]:         24 :         if (!in_dev)
    1918                 :          0 :                 return 0;
    1919                 :            : 
    1920                 :            :         return nla_total_size(IPV4_DEVCONF_MAX * 4); /* IFLA_INET_CONF */
    1921                 :            : }
    1922                 :            : 
    1923                 :         57 : static int inet_fill_link_af(struct sk_buff *skb, const struct net_device *dev,
    1924                 :            :                              u32 ext_filter_mask)
    1925                 :            : {
    1926         [ +  - ]:         57 :         struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr);
    1927                 :         57 :         struct nlattr *nla;
    1928                 :         57 :         int i;
    1929                 :            : 
    1930         [ +  - ]:         57 :         if (!in_dev)
    1931                 :            :                 return -ENODATA;
    1932                 :            : 
    1933                 :         57 :         nla = nla_reserve(skb, IFLA_INET_CONF, IPV4_DEVCONF_MAX * 4);
    1934         [ +  - ]:         57 :         if (!nla)
    1935                 :            :                 return -EMSGSIZE;
    1936                 :            : 
    1937         [ +  + ]:       1881 :         for (i = 0; i < IPV4_DEVCONF_MAX; i++)
    1938                 :       1824 :                 ((u32 *) nla_data(nla))[i] = in_dev->cnf.data[i];
    1939                 :            : 
    1940                 :            :         return 0;
    1941                 :            : }
    1942                 :            : 
    1943                 :            : static const struct nla_policy inet_af_policy[IFLA_INET_MAX+1] = {
    1944                 :            :         [IFLA_INET_CONF]        = { .type = NLA_NESTED },
    1945                 :            : };
    1946                 :            : 
    1947                 :          0 : static int inet_validate_link_af(const struct net_device *dev,
    1948                 :            :                                  const struct nlattr *nla)
    1949                 :            : {
    1950                 :          0 :         struct nlattr *a, *tb[IFLA_INET_MAX+1];
    1951                 :          0 :         int err, rem;
    1952                 :            : 
    1953   [ #  #  #  # ]:          0 :         if (dev && !__in_dev_get_rcu(dev))
    1954                 :            :                 return -EAFNOSUPPORT;
    1955                 :            : 
    1956                 :          0 :         err = nla_parse_nested_deprecated(tb, IFLA_INET_MAX, nla,
    1957                 :            :                                           inet_af_policy, NULL);
    1958         [ #  # ]:          0 :         if (err < 0)
    1959                 :            :                 return err;
    1960                 :            : 
    1961         [ #  # ]:          0 :         if (tb[IFLA_INET_CONF]) {
    1962         [ #  # ]:          0 :                 nla_for_each_nested(a, tb[IFLA_INET_CONF], rem) {
    1963         [ #  # ]:          0 :                         int cfgid = nla_type(a);
    1964                 :            : 
    1965         [ #  # ]:          0 :                         if (nla_len(a) < 4)
    1966                 :            :                                 return -EINVAL;
    1967                 :            : 
    1968         [ #  # ]:          0 :                         if (cfgid <= 0 || cfgid > IPV4_DEVCONF_MAX)
    1969                 :            :                                 return -EINVAL;
    1970                 :            :                 }
    1971                 :            :         }
    1972                 :            : 
    1973                 :            :         return 0;
    1974                 :            : }
    1975                 :            : 
    1976                 :          0 : static int inet_set_link_af(struct net_device *dev, const struct nlattr *nla)
    1977                 :            : {
    1978         [ #  # ]:          0 :         struct in_device *in_dev = __in_dev_get_rcu(dev);
    1979                 :          0 :         struct nlattr *a, *tb[IFLA_INET_MAX+1];
    1980                 :          0 :         int rem;
    1981                 :            : 
    1982         [ #  # ]:          0 :         if (!in_dev)
    1983                 :            :                 return -EAFNOSUPPORT;
    1984                 :            : 
    1985         [ #  # ]:          0 :         if (nla_parse_nested_deprecated(tb, IFLA_INET_MAX, nla, NULL, NULL) < 0)
    1986                 :          0 :                 BUG();
    1987                 :            : 
    1988         [ #  # ]:          0 :         if (tb[IFLA_INET_CONF]) {
    1989         [ #  # ]:          0 :                 nla_for_each_nested(a, tb[IFLA_INET_CONF], rem)
    1990                 :          0 :                         ipv4_devconf_set(in_dev, nla_type(a), nla_get_u32(a));
    1991                 :            :         }
    1992                 :            : 
    1993                 :            :         return 0;
    1994                 :            : }
    1995                 :            : 
    1996                 :         15 : static int inet_netconf_msgsize_devconf(int type)
    1997                 :            : {
    1998         [ +  - ]:         15 :         int size = NLMSG_ALIGN(sizeof(struct netconfmsg))
    1999                 :            :                    + nla_total_size(4); /* NETCONFA_IFINDEX */
    2000                 :         15 :         bool all = false;
    2001                 :            : 
    2002         [ +  - ]:         15 :         if (type == NETCONFA_ALL)
    2003                 :         15 :                 all = true;
    2004                 :            : 
    2005         [ +  - ]:         15 :         if (all || type == NETCONFA_FORWARDING)
    2006                 :         15 :                 size += nla_total_size(4);
    2007         [ +  - ]:         15 :         if (all || type == NETCONFA_RP_FILTER)
    2008                 :         15 :                 size += nla_total_size(4);
    2009         [ +  - ]:         15 :         if (all || type == NETCONFA_MC_FORWARDING)
    2010                 :         15 :                 size += nla_total_size(4);
    2011         [ +  - ]:         15 :         if (all || type == NETCONFA_BC_FORWARDING)
    2012                 :         15 :                 size += nla_total_size(4);
    2013         [ +  - ]:         15 :         if (all || type == NETCONFA_PROXY_NEIGH)
    2014                 :         15 :                 size += nla_total_size(4);
    2015         [ +  - ]:         15 :         if (all || type == NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN)
    2016                 :         15 :                 size += nla_total_size(4);
    2017                 :            : 
    2018                 :          0 :         return size;
    2019                 :            : }
    2020                 :            : 
    2021                 :         15 : static int inet_netconf_fill_devconf(struct sk_buff *skb, int ifindex,
    2022                 :            :                                      struct ipv4_devconf *devconf, u32 portid,
    2023                 :            :                                      u32 seq, int event, unsigned int flags,
    2024                 :            :                                      int type)
    2025                 :            : {
    2026                 :         15 :         struct nlmsghdr  *nlh;
    2027                 :         15 :         struct netconfmsg *ncm;
    2028                 :         15 :         bool all = false;
    2029                 :            : 
    2030         [ +  - ]:         15 :         nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct netconfmsg),
    2031                 :            :                         flags);
    2032         [ -  + ]:         15 :         if (!nlh)
    2033                 :          0 :                 return -EMSGSIZE;
    2034                 :            : 
    2035         [ +  - ]:         15 :         if (type == NETCONFA_ALL)
    2036                 :         15 :                 all = true;
    2037                 :            : 
    2038                 :         15 :         ncm = nlmsg_data(nlh);
    2039                 :         15 :         ncm->ncm_family = AF_INET;
    2040                 :            : 
    2041         [ -  + ]:         15 :         if (nla_put_s32(skb, NETCONFA_IFINDEX, ifindex) < 0)
    2042                 :          0 :                 goto nla_put_failure;
    2043                 :            : 
    2044         [ -  + ]:         15 :         if (!devconf)
    2045                 :          0 :                 goto out;
    2046                 :            : 
    2047   [ +  -  -  + ]:         30 :         if ((all || type == NETCONFA_FORWARDING) &&
    2048                 :         15 :             nla_put_s32(skb, NETCONFA_FORWARDING,
    2049                 :            :                         IPV4_DEVCONF(*devconf, FORWARDING)) < 0)
    2050                 :          0 :                 goto nla_put_failure;
    2051   [ +  -  -  + ]:         30 :         if ((all || type == NETCONFA_RP_FILTER) &&
    2052                 :         15 :             nla_put_s32(skb, NETCONFA_RP_FILTER,
    2053                 :            :                         IPV4_DEVCONF(*devconf, RP_FILTER)) < 0)
    2054                 :          0 :                 goto nla_put_failure;
    2055   [ +  -  -  + ]:         30 :         if ((all || type == NETCONFA_MC_FORWARDING) &&
    2056                 :         15 :             nla_put_s32(skb, NETCONFA_MC_FORWARDING,
    2057                 :            :                         IPV4_DEVCONF(*devconf, MC_FORWARDING)) < 0)
    2058                 :          0 :                 goto nla_put_failure;
    2059   [ +  -  -  + ]:         30 :         if ((all || type == NETCONFA_BC_FORWARDING) &&
    2060                 :         15 :             nla_put_s32(skb, NETCONFA_BC_FORWARDING,
    2061                 :            :                         IPV4_DEVCONF(*devconf, BC_FORWARDING)) < 0)
    2062                 :          0 :                 goto nla_put_failure;
    2063   [ +  -  -  + ]:         30 :         if ((all || type == NETCONFA_PROXY_NEIGH) &&
    2064                 :         15 :             nla_put_s32(skb, NETCONFA_PROXY_NEIGH,
    2065                 :            :                         IPV4_DEVCONF(*devconf, PROXY_ARP)) < 0)
    2066                 :          0 :                 goto nla_put_failure;
    2067   [ +  -  +  - ]:         30 :         if ((all || type == NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN) &&
    2068                 :         15 :             nla_put_s32(skb, NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
    2069                 :            :                         IPV4_DEVCONF(*devconf, IGNORE_ROUTES_WITH_LINKDOWN)) < 0)
    2070                 :          0 :                 goto nla_put_failure;
    2071                 :            : 
    2072                 :         15 : out:
    2073                 :         15 :         nlmsg_end(skb, nlh);
    2074                 :         15 :         return 0;
    2075                 :            : 
    2076                 :          0 : nla_put_failure:
    2077                 :          0 :         nlmsg_cancel(skb, nlh);
    2078                 :          0 :         return -EMSGSIZE;
    2079                 :            : }
    2080                 :            : 
    2081                 :         15 : void inet_netconf_notify_devconf(struct net *net, int event, int type,
    2082                 :            :                                  int ifindex, struct ipv4_devconf *devconf)
    2083                 :            : {
    2084                 :         15 :         struct sk_buff *skb;
    2085                 :         15 :         int err = -ENOBUFS;
    2086                 :            : 
    2087                 :         15 :         skb = nlmsg_new(inet_netconf_msgsize_devconf(type), GFP_KERNEL);
    2088         [ -  + ]:         15 :         if (!skb)
    2089                 :          0 :                 goto errout;
    2090                 :            : 
    2091                 :         15 :         err = inet_netconf_fill_devconf(skb, ifindex, devconf, 0, 0,
    2092                 :            :                                         event, 0, type);
    2093         [ -  + ]:         15 :         if (err < 0) {
    2094                 :            :                 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
    2095         [ #  # ]:          0 :                 WARN_ON(err == -EMSGSIZE);
    2096                 :          0 :                 kfree_skb(skb);
    2097                 :          0 :                 goto errout;
    2098                 :            :         }
    2099                 :         15 :         rtnl_notify(skb, net, 0, RTNLGRP_IPV4_NETCONF, NULL, GFP_KERNEL);
    2100                 :         15 :         return;
    2101                 :            : errout:
    2102                 :          0 :         if (err < 0)
    2103                 :          0 :                 rtnl_set_sk_err(net, RTNLGRP_IPV4_NETCONF, err);
    2104                 :            : }
    2105                 :            : 
    2106                 :            : static const struct nla_policy devconf_ipv4_policy[NETCONFA_MAX+1] = {
    2107                 :            :         [NETCONFA_IFINDEX]      = { .len = sizeof(int) },
    2108                 :            :         [NETCONFA_FORWARDING]   = { .len = sizeof(int) },
    2109                 :            :         [NETCONFA_RP_FILTER]    = { .len = sizeof(int) },
    2110                 :            :         [NETCONFA_PROXY_NEIGH]  = { .len = sizeof(int) },
    2111                 :            :         [NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN]  = { .len = sizeof(int) },
    2112                 :            : };
    2113                 :            : 
    2114                 :          0 : static int inet_netconf_valid_get_req(struct sk_buff *skb,
    2115                 :            :                                       const struct nlmsghdr *nlh,
    2116                 :            :                                       struct nlattr **tb,
    2117                 :            :                                       struct netlink_ext_ack *extack)
    2118                 :            : {
    2119                 :          0 :         int i, err;
    2120                 :            : 
    2121         [ #  # ]:          0 :         if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(struct netconfmsg))) {
    2122         [ #  # ]:          0 :                 NL_SET_ERR_MSG(extack, "ipv4: Invalid header for netconf get request");
    2123                 :          0 :                 return -EINVAL;
    2124                 :            :         }
    2125                 :            : 
    2126         [ #  # ]:          0 :         if (!netlink_strict_get_check(skb))
    2127                 :          0 :                 return nlmsg_parse_deprecated(nlh, sizeof(struct netconfmsg),
    2128                 :            :                                               tb, NETCONFA_MAX,
    2129                 :            :                                               devconf_ipv4_policy, extack);
    2130                 :            : 
    2131                 :          0 :         err = nlmsg_parse_deprecated_strict(nlh, sizeof(struct netconfmsg),
    2132                 :            :                                             tb, NETCONFA_MAX,
    2133                 :            :                                             devconf_ipv4_policy, extack);
    2134         [ #  # ]:          0 :         if (err)
    2135                 :            :                 return err;
    2136                 :            : 
    2137         [ #  # ]:          0 :         for (i = 0; i <= NETCONFA_MAX; i++) {
    2138         [ #  # ]:          0 :                 if (!tb[i])
    2139                 :          0 :                         continue;
    2140                 :            : 
    2141         [ #  # ]:          0 :                 switch (i) {
    2142                 :            :                 case NETCONFA_IFINDEX:
    2143                 :            :                         break;
    2144                 :          0 :                 default:
    2145         [ #  # ]:          0 :                         NL_SET_ERR_MSG(extack, "ipv4: Unsupported attribute in netconf get request");
    2146                 :            :                         return -EINVAL;
    2147                 :            :                 }
    2148                 :            :         }
    2149                 :            : 
    2150                 :            :         return 0;
    2151                 :            : }
    2152                 :            : 
    2153                 :          0 : static int inet_netconf_get_devconf(struct sk_buff *in_skb,
    2154                 :            :                                     struct nlmsghdr *nlh,
    2155                 :            :                                     struct netlink_ext_ack *extack)
    2156                 :            : {
    2157                 :          0 :         struct net *net = sock_net(in_skb->sk);
    2158                 :          0 :         struct nlattr *tb[NETCONFA_MAX+1];
    2159                 :          0 :         struct sk_buff *skb;
    2160                 :          0 :         struct ipv4_devconf *devconf;
    2161                 :          0 :         struct in_device *in_dev;
    2162                 :          0 :         struct net_device *dev;
    2163                 :          0 :         int ifindex;
    2164                 :          0 :         int err;
    2165                 :            : 
    2166                 :          0 :         err = inet_netconf_valid_get_req(in_skb, nlh, tb, extack);
    2167         [ #  # ]:          0 :         if (err)
    2168                 :          0 :                 goto errout;
    2169                 :            : 
    2170                 :          0 :         err = -EINVAL;
    2171         [ #  # ]:          0 :         if (!tb[NETCONFA_IFINDEX])
    2172                 :          0 :                 goto errout;
    2173                 :            : 
    2174      [ #  #  # ]:          0 :         ifindex = nla_get_s32(tb[NETCONFA_IFINDEX]);
    2175      [ #  #  # ]:          0 :         switch (ifindex) {
    2176                 :          0 :         case NETCONFA_IFINDEX_ALL:
    2177                 :          0 :                 devconf = net->ipv4.devconf_all;
    2178                 :          0 :                 break;
    2179                 :          0 :         case NETCONFA_IFINDEX_DEFAULT:
    2180                 :          0 :                 devconf = net->ipv4.devconf_dflt;
    2181                 :          0 :                 break;
    2182                 :          0 :         default:
    2183                 :          0 :                 dev = __dev_get_by_index(net, ifindex);
    2184         [ #  # ]:          0 :                 if (!dev)
    2185                 :          0 :                         goto errout;
    2186         [ #  # ]:          0 :                 in_dev = __in_dev_get_rtnl(dev);
    2187         [ #  # ]:          0 :                 if (!in_dev)
    2188                 :          0 :                         goto errout;
    2189                 :          0 :                 devconf = &in_dev->cnf;
    2190                 :          0 :                 break;
    2191                 :            :         }
    2192                 :            : 
    2193                 :          0 :         err = -ENOBUFS;
    2194                 :          0 :         skb = nlmsg_new(inet_netconf_msgsize_devconf(NETCONFA_ALL), GFP_KERNEL);
    2195         [ #  # ]:          0 :         if (!skb)
    2196                 :          0 :                 goto errout;
    2197                 :            : 
    2198                 :          0 :         err = inet_netconf_fill_devconf(skb, ifindex, devconf,
    2199                 :            :                                         NETLINK_CB(in_skb).portid,
    2200                 :            :                                         nlh->nlmsg_seq, RTM_NEWNETCONF, 0,
    2201                 :            :                                         NETCONFA_ALL);
    2202         [ #  # ]:          0 :         if (err < 0) {
    2203                 :            :                 /* -EMSGSIZE implies BUG in inet_netconf_msgsize_devconf() */
    2204         [ #  # ]:          0 :                 WARN_ON(err == -EMSGSIZE);
    2205                 :          0 :                 kfree_skb(skb);
    2206                 :          0 :                 goto errout;
    2207                 :            :         }
    2208                 :          0 :         err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
    2209                 :          0 : errout:
    2210                 :          0 :         return err;
    2211                 :            : }
    2212                 :            : 
    2213                 :          0 : static int inet_netconf_dump_devconf(struct sk_buff *skb,
    2214                 :            :                                      struct netlink_callback *cb)
    2215                 :            : {
    2216                 :          0 :         const struct nlmsghdr *nlh = cb->nlh;
    2217         [ #  # ]:          0 :         struct net *net = sock_net(skb->sk);
    2218                 :          0 :         int h, s_h;
    2219                 :          0 :         int idx, s_idx;
    2220                 :          0 :         struct net_device *dev;
    2221                 :          0 :         struct in_device *in_dev;
    2222                 :          0 :         struct hlist_head *head;
    2223                 :            : 
    2224         [ #  # ]:          0 :         if (cb->strict_check) {
    2225                 :          0 :                 struct netlink_ext_ack *extack = cb->extack;
    2226                 :          0 :                 struct netconfmsg *ncm;
    2227                 :            : 
    2228         [ #  # ]:          0 :                 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ncm))) {
    2229         [ #  # ]:          0 :                         NL_SET_ERR_MSG(extack, "ipv4: Invalid header for netconf dump request");
    2230                 :          0 :                         return -EINVAL;
    2231                 :            :                 }
    2232                 :            : 
    2233         [ #  # ]:          0 :                 if (nlmsg_attrlen(nlh, sizeof(*ncm))) {
    2234         [ #  # ]:          0 :                         NL_SET_ERR_MSG(extack, "ipv4: Invalid data after header in netconf dump request");
    2235                 :          0 :                         return -EINVAL;
    2236                 :            :                 }
    2237                 :            :         }
    2238                 :            : 
    2239                 :          0 :         s_h = cb->args[0];
    2240                 :          0 :         s_idx = idx = cb->args[1];
    2241                 :            : 
    2242         [ #  # ]:          0 :         for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
    2243                 :          0 :                 idx = 0;
    2244                 :          0 :                 head = &net->dev_index_head[h];
    2245                 :          0 :                 rcu_read_lock();
    2246                 :          0 :                 cb->seq = atomic_read(&net->ipv4.dev_addr_genid) ^
    2247                 :          0 :                           net->dev_base_seq;
    2248   [ #  #  #  # ]:          0 :                 hlist_for_each_entry_rcu(dev, head, index_hlist) {
    2249         [ #  # ]:          0 :                         if (idx < s_idx)
    2250                 :          0 :                                 goto cont;
    2251         [ #  # ]:          0 :                         in_dev = __in_dev_get_rcu(dev);
    2252         [ #  # ]:          0 :                         if (!in_dev)
    2253                 :          0 :                                 goto cont;
    2254                 :            : 
    2255         [ #  # ]:          0 :                         if (inet_netconf_fill_devconf(skb, dev->ifindex,
    2256                 :            :                                                       &in_dev->cnf,
    2257                 :          0 :                                                       NETLINK_CB(cb->skb).portid,
    2258                 :            :                                                       nlh->nlmsg_seq,
    2259                 :            :                                                       RTM_NEWNETCONF,
    2260                 :            :                                                       NLM_F_MULTI,
    2261                 :            :                                                       NETCONFA_ALL) < 0) {
    2262                 :          0 :                                 rcu_read_unlock();
    2263                 :          0 :                                 goto done;
    2264                 :            :                         }
    2265         [ #  # ]:          0 :                         nl_dump_check_consistent(cb, nlmsg_hdr(skb));
    2266                 :          0 : cont:
    2267         [ #  # ]:          0 :                         idx++;
    2268                 :            :                 }
    2269                 :          0 :                 rcu_read_unlock();
    2270                 :            :         }
    2271         [ #  # ]:          0 :         if (h == NETDEV_HASHENTRIES) {
    2272         [ #  # ]:          0 :                 if (inet_netconf_fill_devconf(skb, NETCONFA_IFINDEX_ALL,
    2273                 :            :                                               net->ipv4.devconf_all,
    2274                 :          0 :                                               NETLINK_CB(cb->skb).portid,
    2275                 :            :                                               nlh->nlmsg_seq,
    2276                 :            :                                               RTM_NEWNETCONF, NLM_F_MULTI,
    2277                 :            :                                               NETCONFA_ALL) < 0)
    2278                 :          0 :                         goto done;
    2279                 :            :                 else
    2280                 :            :                         h++;
    2281                 :            :         }
    2282         [ #  # ]:          0 :         if (h == NETDEV_HASHENTRIES + 1) {
    2283         [ #  # ]:          0 :                 if (inet_netconf_fill_devconf(skb, NETCONFA_IFINDEX_DEFAULT,
    2284                 :            :                                               net->ipv4.devconf_dflt,
    2285                 :          0 :                                               NETLINK_CB(cb->skb).portid,
    2286                 :            :                                               nlh->nlmsg_seq,
    2287                 :            :                                               RTM_NEWNETCONF, NLM_F_MULTI,
    2288                 :            :                                               NETCONFA_ALL) < 0)
    2289                 :          0 :                         goto done;
    2290                 :            :                 else
    2291                 :            :                         h++;
    2292                 :            :         }
    2293                 :          0 : done:
    2294                 :          0 :         cb->args[0] = h;
    2295                 :          0 :         cb->args[1] = idx;
    2296                 :            : 
    2297                 :          0 :         return skb->len;
    2298                 :            : }
    2299                 :            : 
    2300                 :            : #ifdef CONFIG_SYSCTL
    2301                 :            : 
    2302                 :          0 : static void devinet_copy_dflt_conf(struct net *net, int i)
    2303                 :            : {
    2304                 :          0 :         struct net_device *dev;
    2305                 :            : 
    2306                 :          0 :         rcu_read_lock();
    2307         [ #  # ]:          0 :         for_each_netdev_rcu(net, dev) {
    2308                 :          0 :                 struct in_device *in_dev;
    2309                 :            : 
    2310         [ #  # ]:          0 :                 in_dev = __in_dev_get_rcu(dev);
    2311   [ #  #  #  # ]:          0 :                 if (in_dev && !test_bit(i, in_dev->cnf.state))
    2312                 :          0 :                         in_dev->cnf.data[i] = net->ipv4.devconf_dflt->data[i];
    2313                 :            :         }
    2314                 :          0 :         rcu_read_unlock();
    2315                 :          0 : }
    2316                 :            : 
    2317                 :            : /* called with RTNL locked */
    2318                 :          0 : static void inet_forward_change(struct net *net)
    2319                 :            : {
    2320                 :          0 :         struct net_device *dev;
    2321                 :          0 :         int on = IPV4_DEVCONF_ALL(net, FORWARDING);
    2322                 :            : 
    2323                 :          0 :         IPV4_DEVCONF_ALL(net, ACCEPT_REDIRECTS) = !on;
    2324                 :          0 :         IPV4_DEVCONF_DFLT(net, FORWARDING) = on;
    2325                 :          0 :         inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
    2326                 :            :                                     NETCONFA_FORWARDING,
    2327                 :            :                                     NETCONFA_IFINDEX_ALL,
    2328                 :            :                                     net->ipv4.devconf_all);
    2329                 :          0 :         inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
    2330                 :            :                                     NETCONFA_FORWARDING,
    2331                 :            :                                     NETCONFA_IFINDEX_DEFAULT,
    2332                 :            :                                     net->ipv4.devconf_dflt);
    2333                 :            : 
    2334         [ #  # ]:          0 :         for_each_netdev(net, dev) {
    2335                 :          0 :                 struct in_device *in_dev;
    2336                 :            : 
    2337         [ #  # ]:          0 :                 if (on)
    2338                 :          0 :                         dev_disable_lro(dev);
    2339                 :            : 
    2340         [ #  # ]:          0 :                 in_dev = __in_dev_get_rtnl(dev);
    2341         [ #  # ]:          0 :                 if (in_dev) {
    2342                 :          0 :                         IN_DEV_CONF_SET(in_dev, FORWARDING, on);
    2343                 :          0 :                         inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
    2344                 :            :                                                     NETCONFA_FORWARDING,
    2345                 :            :                                                     dev->ifindex, &in_dev->cnf);
    2346                 :            :                 }
    2347                 :            :         }
    2348                 :          0 : }
    2349                 :            : 
    2350                 :          0 : static int devinet_conf_ifindex(struct net *net, struct ipv4_devconf *cnf)
    2351                 :            : {
    2352                 :          0 :         if (cnf == net->ipv4.devconf_dflt)
    2353                 :            :                 return NETCONFA_IFINDEX_DEFAULT;
    2354   [ #  #  #  #  :          0 :         else if (cnf == net->ipv4.devconf_all)
                   #  # ]
    2355                 :            :                 return NETCONFA_IFINDEX_ALL;
    2356                 :            :         else {
    2357                 :          0 :                 struct in_device *idev
    2358                 :          0 :                         = container_of(cnf, struct in_device, cnf);
    2359                 :          0 :                 return idev->dev->ifindex;
    2360                 :            :         }
    2361                 :            : }
    2362                 :            : 
    2363                 :          0 : static int devinet_conf_proc(struct ctl_table *ctl, int write,
    2364                 :            :                              void __user *buffer,
    2365                 :            :                              size_t *lenp, loff_t *ppos)
    2366                 :            : {
    2367                 :          0 :         int old_value = *(int *)ctl->data;
    2368                 :          0 :         int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
    2369                 :          0 :         int new_value = *(int *)ctl->data;
    2370                 :            : 
    2371         [ #  # ]:          0 :         if (write) {
    2372                 :          0 :                 struct ipv4_devconf *cnf = ctl->extra1;
    2373                 :          0 :                 struct net *net = ctl->extra2;
    2374                 :          0 :                 int i = (int *)ctl->data - cnf->data;
    2375                 :          0 :                 int ifindex;
    2376                 :            : 
    2377                 :          0 :                 set_bit(i, cnf->state);
    2378                 :            : 
    2379         [ #  # ]:          0 :                 if (cnf == net->ipv4.devconf_dflt)
    2380                 :          0 :                         devinet_copy_dflt_conf(net, i);
    2381                 :          0 :                 if (i == IPV4_DEVCONF_ACCEPT_LOCAL - 1 ||
    2382         [ #  # ]:          0 :                     i == IPV4_DEVCONF_ROUTE_LOCALNET - 1)
    2383         [ #  # ]:          0 :                         if ((new_value == 0) && (old_value != 0))
    2384                 :          0 :                                 rt_cache_flush(net);
    2385                 :            : 
    2386                 :          0 :                 if (i == IPV4_DEVCONF_BC_FORWARDING - 1 &&
    2387         [ #  # ]:          0 :                     new_value != old_value)
    2388                 :          0 :                         rt_cache_flush(net);
    2389                 :            : 
    2390         [ #  # ]:          0 :                 if (i == IPV4_DEVCONF_RP_FILTER - 1 &&
    2391                 :            :                     new_value != old_value) {
    2392         [ #  # ]:          0 :                         ifindex = devinet_conf_ifindex(net, cnf);
    2393                 :          0 :                         inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
    2394                 :            :                                                     NETCONFA_RP_FILTER,
    2395                 :            :                                                     ifindex, cnf);
    2396                 :            :                 }
    2397         [ #  # ]:          0 :                 if (i == IPV4_DEVCONF_PROXY_ARP - 1 &&
    2398                 :            :                     new_value != old_value) {
    2399         [ #  # ]:          0 :                         ifindex = devinet_conf_ifindex(net, cnf);
    2400                 :          0 :                         inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
    2401                 :            :                                                     NETCONFA_PROXY_NEIGH,
    2402                 :            :                                                     ifindex, cnf);
    2403                 :            :                 }
    2404         [ #  # ]:          0 :                 if (i == IPV4_DEVCONF_IGNORE_ROUTES_WITH_LINKDOWN - 1 &&
    2405                 :            :                     new_value != old_value) {
    2406         [ #  # ]:          0 :                         ifindex = devinet_conf_ifindex(net, cnf);
    2407                 :          0 :                         inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
    2408                 :            :                                                     NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
    2409                 :            :                                                     ifindex, cnf);
    2410                 :            :                 }
    2411                 :            :         }
    2412                 :            : 
    2413                 :          0 :         return ret;
    2414                 :            : }
    2415                 :            : 
    2416                 :          0 : static int devinet_sysctl_forward(struct ctl_table *ctl, int write,
    2417                 :            :                                   void __user *buffer,
    2418                 :            :                                   size_t *lenp, loff_t *ppos)
    2419                 :            : {
    2420                 :          0 :         int *valp = ctl->data;
    2421                 :          0 :         int val = *valp;
    2422                 :          0 :         loff_t pos = *ppos;
    2423                 :          0 :         int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
    2424                 :            : 
    2425   [ #  #  #  # ]:          0 :         if (write && *valp != val) {
    2426                 :          0 :                 struct net *net = ctl->extra2;
    2427                 :            : 
    2428         [ #  # ]:          0 :                 if (valp != &IPV4_DEVCONF_DFLT(net, FORWARDING)) {
    2429         [ #  # ]:          0 :                         if (!rtnl_trylock()) {
    2430                 :            :                                 /* Restore the original values before restarting */
    2431                 :          0 :                                 *valp = val;
    2432                 :          0 :                                 *ppos = pos;
    2433                 :          0 :                                 return restart_syscall();
    2434                 :            :                         }
    2435         [ #  # ]:          0 :                         if (valp == &IPV4_DEVCONF_ALL(net, FORWARDING)) {
    2436                 :          0 :                                 inet_forward_change(net);
    2437                 :            :                         } else {
    2438                 :          0 :                                 struct ipv4_devconf *cnf = ctl->extra1;
    2439                 :          0 :                                 struct in_device *idev =
    2440                 :          0 :                                         container_of(cnf, struct in_device, cnf);
    2441         [ #  # ]:          0 :                                 if (*valp)
    2442                 :          0 :                                         dev_disable_lro(idev->dev);
    2443                 :          0 :                                 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
    2444                 :            :                                                             NETCONFA_FORWARDING,
    2445                 :          0 :                                                             idev->dev->ifindex,
    2446                 :            :                                                             cnf);
    2447                 :            :                         }
    2448                 :          0 :                         rtnl_unlock();
    2449                 :          0 :                         rt_cache_flush(net);
    2450                 :            :                 } else
    2451                 :          0 :                         inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
    2452                 :            :                                                     NETCONFA_FORWARDING,
    2453                 :            :                                                     NETCONFA_IFINDEX_DEFAULT,
    2454                 :            :                                                     net->ipv4.devconf_dflt);
    2455                 :            :         }
    2456                 :            : 
    2457                 :            :         return ret;
    2458                 :            : }
    2459                 :            : 
    2460                 :          0 : static int ipv4_doint_and_flush(struct ctl_table *ctl, int write,
    2461                 :            :                                 void __user *buffer,
    2462                 :            :                                 size_t *lenp, loff_t *ppos)
    2463                 :            : {
    2464                 :          0 :         int *valp = ctl->data;
    2465                 :          0 :         int val = *valp;
    2466                 :          0 :         int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
    2467                 :          0 :         struct net *net = ctl->extra2;
    2468                 :            : 
    2469   [ #  #  #  # ]:          0 :         if (write && *valp != val)
    2470                 :          0 :                 rt_cache_flush(net);
    2471                 :            : 
    2472                 :          0 :         return ret;
    2473                 :            : }
    2474                 :            : 
    2475                 :            : #define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc) \
    2476                 :            :         { \
    2477                 :            :                 .procname       = name, \
    2478                 :            :                 .data           = ipv4_devconf.data + \
    2479                 :            :                                   IPV4_DEVCONF_ ## attr - 1, \
    2480                 :            :                 .maxlen         = sizeof(int), \
    2481                 :            :                 .mode           = mval, \
    2482                 :            :                 .proc_handler   = proc, \
    2483                 :            :                 .extra1         = &ipv4_devconf, \
    2484                 :            :         }
    2485                 :            : 
    2486                 :            : #define DEVINET_SYSCTL_RW_ENTRY(attr, name) \
    2487                 :            :         DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc)
    2488                 :            : 
    2489                 :            : #define DEVINET_SYSCTL_RO_ENTRY(attr, name) \
    2490                 :            :         DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc)
    2491                 :            : 
    2492                 :            : #define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc) \
    2493                 :            :         DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc)
    2494                 :            : 
    2495                 :            : #define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \
    2496                 :            :         DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush)
    2497                 :            : 
    2498                 :            : static struct devinet_sysctl_table {
    2499                 :            :         struct ctl_table_header *sysctl_header;
    2500                 :            :         struct ctl_table devinet_vars[__IPV4_DEVCONF_MAX];
    2501                 :            : } devinet_sysctl = {
    2502                 :            :         .devinet_vars = {
    2503                 :            :                 DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING, "forwarding",
    2504                 :            :                                              devinet_sysctl_forward),
    2505                 :            :                 DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING, "mc_forwarding"),
    2506                 :            :                 DEVINET_SYSCTL_RW_ENTRY(BC_FORWARDING, "bc_forwarding"),
    2507                 :            : 
    2508                 :            :                 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS, "accept_redirects"),
    2509                 :            :                 DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS, "secure_redirects"),
    2510                 :            :                 DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA, "shared_media"),
    2511                 :            :                 DEVINET_SYSCTL_RW_ENTRY(RP_FILTER, "rp_filter"),
    2512                 :            :                 DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS, "send_redirects"),
    2513                 :            :                 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE,
    2514                 :            :                                         "accept_source_route"),
    2515                 :            :                 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_LOCAL, "accept_local"),
    2516                 :            :                 DEVINET_SYSCTL_RW_ENTRY(SRC_VMARK, "src_valid_mark"),
    2517                 :            :                 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP, "proxy_arp"),
    2518                 :            :                 DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID, "medium_id"),
    2519                 :            :                 DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY, "bootp_relay"),
    2520                 :            :                 DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS, "log_martians"),
    2521                 :            :                 DEVINET_SYSCTL_RW_ENTRY(TAG, "tag"),
    2522                 :            :                 DEVINET_SYSCTL_RW_ENTRY(ARPFILTER, "arp_filter"),
    2523                 :            :                 DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE, "arp_announce"),
    2524                 :            :                 DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE, "arp_ignore"),
    2525                 :            :                 DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT, "arp_accept"),
    2526                 :            :                 DEVINET_SYSCTL_RW_ENTRY(ARP_NOTIFY, "arp_notify"),
    2527                 :            :                 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP_PVLAN, "proxy_arp_pvlan"),
    2528                 :            :                 DEVINET_SYSCTL_RW_ENTRY(FORCE_IGMP_VERSION,
    2529                 :            :                                         "force_igmp_version"),
    2530                 :            :                 DEVINET_SYSCTL_RW_ENTRY(IGMPV2_UNSOLICITED_REPORT_INTERVAL,
    2531                 :            :                                         "igmpv2_unsolicited_report_interval"),
    2532                 :            :                 DEVINET_SYSCTL_RW_ENTRY(IGMPV3_UNSOLICITED_REPORT_INTERVAL,
    2533                 :            :                                         "igmpv3_unsolicited_report_interval"),
    2534                 :            :                 DEVINET_SYSCTL_RW_ENTRY(IGNORE_ROUTES_WITH_LINKDOWN,
    2535                 :            :                                         "ignore_routes_with_linkdown"),
    2536                 :            :                 DEVINET_SYSCTL_RW_ENTRY(DROP_GRATUITOUS_ARP,
    2537                 :            :                                         "drop_gratuitous_arp"),
    2538                 :            : 
    2539                 :            :                 DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM, "disable_xfrm"),
    2540                 :            :                 DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY, "disable_policy"),
    2541                 :            :                 DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES,
    2542                 :            :                                               "promote_secondaries"),
    2543                 :            :                 DEVINET_SYSCTL_FLUSHING_ENTRY(ROUTE_LOCALNET,
    2544                 :            :                                               "route_localnet"),
    2545                 :            :                 DEVINET_SYSCTL_FLUSHING_ENTRY(DROP_UNICAST_IN_L2_MULTICAST,
    2546                 :            :                                               "drop_unicast_in_l2_multicast"),
    2547                 :            :         },
    2548                 :            : };
    2549                 :            : 
    2550                 :         15 : static int __devinet_sysctl_register(struct net *net, char *dev_name,
    2551                 :            :                                      int ifindex, struct ipv4_devconf *p)
    2552                 :            : {
    2553                 :         15 :         int i;
    2554                 :         15 :         struct devinet_sysctl_table *t;
    2555                 :         15 :         char path[sizeof("net/ipv4/conf/") + IFNAMSIZ];
    2556                 :            : 
    2557                 :         15 :         t = kmemdup(&devinet_sysctl, sizeof(*t), GFP_KERNEL);
    2558         [ +  - ]:         15 :         if (!t)
    2559                 :          0 :                 goto out;
    2560                 :            : 
    2561         [ +  + ]:        495 :         for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
    2562                 :        480 :                 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
    2563                 :        480 :                 t->devinet_vars[i].extra1 = p;
    2564                 :        480 :                 t->devinet_vars[i].extra2 = net;
    2565                 :            :         }
    2566                 :            : 
    2567                 :         15 :         snprintf(path, sizeof(path), "net/ipv4/conf/%s", dev_name);
    2568                 :            : 
    2569                 :         15 :         t->sysctl_header = register_net_sysctl(net, path, t->devinet_vars);
    2570         [ -  + ]:         15 :         if (!t->sysctl_header)
    2571                 :          0 :                 goto free;
    2572                 :            : 
    2573                 :         15 :         p->sysctl = t;
    2574                 :            : 
    2575                 :         15 :         inet_netconf_notify_devconf(net, RTM_NEWNETCONF, NETCONFA_ALL,
    2576                 :            :                                     ifindex, p);
    2577                 :         15 :         return 0;
    2578                 :            : 
    2579                 :            : free:
    2580                 :          0 :         kfree(t);
    2581                 :            : out:
    2582                 :            :         return -ENOBUFS;
    2583                 :            : }
    2584                 :            : 
    2585                 :            : static void __devinet_sysctl_unregister(struct net *net,
    2586                 :            :                                         struct ipv4_devconf *cnf, int ifindex)
    2587                 :            : {
    2588                 :            :         struct devinet_sysctl_table *t = cnf->sysctl;
    2589                 :            : 
    2590                 :            :         if (t) {
    2591                 :            :                 cnf->sysctl = NULL;
    2592                 :            :                 unregister_net_sysctl_table(t->sysctl_header);
    2593                 :            :                 kfree(t);
    2594                 :            :         }
    2595                 :            : 
    2596                 :            :         inet_netconf_notify_devconf(net, RTM_DELNETCONF, 0, ifindex, NULL);
    2597                 :            : }
    2598                 :            : 
    2599                 :          9 : static int devinet_sysctl_register(struct in_device *idev)
    2600                 :            : {
    2601                 :          9 :         int err;
    2602                 :            : 
    2603         [ +  - ]:          9 :         if (!sysctl_dev_name_is_allowed(idev->dev->name))
    2604                 :            :                 return -EINVAL;
    2605                 :            : 
    2606                 :          9 :         err = neigh_sysctl_register(idev->dev, idev->arp_parms, NULL);
    2607         [ +  - ]:          9 :         if (err)
    2608                 :            :                 return err;
    2609                 :          9 :         err = __devinet_sysctl_register(dev_net(idev->dev), idev->dev->name,
    2610                 :          9 :                                         idev->dev->ifindex, &idev->cnf);
    2611         [ -  + ]:          9 :         if (err)
    2612                 :          0 :                 neigh_sysctl_unregister(idev->arp_parms);
    2613                 :            :         return err;
    2614                 :            : }
    2615                 :            : 
    2616                 :          0 : static void devinet_sysctl_unregister(struct in_device *idev)
    2617                 :            : {
    2618                 :          0 :         struct net *net = dev_net(idev->dev);
    2619                 :            : 
    2620                 :          0 :         __devinet_sysctl_unregister(net, &idev->cnf, idev->dev->ifindex);
    2621                 :          0 :         neigh_sysctl_unregister(idev->arp_parms);
    2622                 :          0 : }
    2623                 :            : 
    2624                 :            : static struct ctl_table ctl_forward_entry[] = {
    2625                 :            :         {
    2626                 :            :                 .procname       = "ip_forward",
    2627                 :            :                 .data           = &ipv4_devconf.data[
    2628                 :            :                                         IPV4_DEVCONF_FORWARDING - 1],
    2629                 :            :                 .maxlen         = sizeof(int),
    2630                 :            :                 .mode           = 0644,
    2631                 :            :                 .proc_handler   = devinet_sysctl_forward,
    2632                 :            :                 .extra1         = &ipv4_devconf,
    2633                 :            :                 .extra2         = &init_net,
    2634                 :            :         },
    2635                 :            :         { },
    2636                 :            : };
    2637                 :            : #endif
    2638                 :            : 
    2639                 :          3 : static __net_init int devinet_init_net(struct net *net)
    2640                 :            : {
    2641                 :          3 :         int err;
    2642                 :          3 :         struct ipv4_devconf *all, *dflt;
    2643                 :            : #ifdef CONFIG_SYSCTL
    2644                 :          3 :         struct ctl_table *tbl;
    2645                 :          3 :         struct ctl_table_header *forw_hdr;
    2646                 :            : #endif
    2647                 :            : 
    2648                 :          3 :         err = -ENOMEM;
    2649                 :          3 :         all = kmemdup(&ipv4_devconf, sizeof(ipv4_devconf), GFP_KERNEL);
    2650         [ -  + ]:          3 :         if (!all)
    2651                 :          0 :                 goto err_alloc_all;
    2652                 :            : 
    2653                 :          3 :         dflt = kmemdup(&ipv4_devconf_dflt, sizeof(ipv4_devconf_dflt), GFP_KERNEL);
    2654         [ -  + ]:          3 :         if (!dflt)
    2655                 :          0 :                 goto err_alloc_dflt;
    2656                 :            : 
    2657                 :            : #ifdef CONFIG_SYSCTL
    2658                 :          3 :         tbl = kmemdup(ctl_forward_entry, sizeof(ctl_forward_entry), GFP_KERNEL);
    2659         [ -  + ]:          3 :         if (!tbl)
    2660                 :          0 :                 goto err_alloc_ctl;
    2661                 :            : 
    2662                 :          3 :         tbl[0].data = &all->data[IPV4_DEVCONF_FORWARDING - 1];
    2663                 :          3 :         tbl[0].extra1 = all;
    2664                 :          3 :         tbl[0].extra2 = net;
    2665                 :            : #endif
    2666                 :            : 
    2667         [ +  - ]:          3 :         if ((!IS_ENABLED(CONFIG_SYSCTL) ||
    2668         [ -  + ]:          3 :              sysctl_devconf_inherit_init_net != 2) &&
    2669                 :            :             !net_eq(net, &init_net)) {
    2670                 :          0 :                 memcpy(all, init_net.ipv4.devconf_all, sizeof(ipv4_devconf));
    2671                 :          0 :                 memcpy(dflt, init_net.ipv4.devconf_dflt, sizeof(ipv4_devconf_dflt));
    2672                 :            :         }
    2673                 :            : 
    2674                 :            : #ifdef CONFIG_SYSCTL
    2675                 :          3 :         err = __devinet_sysctl_register(net, "all", NETCONFA_IFINDEX_ALL, all);
    2676         [ -  + ]:          3 :         if (err < 0)
    2677                 :          0 :                 goto err_reg_all;
    2678                 :            : 
    2679                 :          3 :         err = __devinet_sysctl_register(net, "default",
    2680                 :            :                                         NETCONFA_IFINDEX_DEFAULT, dflt);
    2681         [ -  + ]:          3 :         if (err < 0)
    2682                 :          0 :                 goto err_reg_dflt;
    2683                 :            : 
    2684                 :          3 :         err = -ENOMEM;
    2685                 :          3 :         forw_hdr = register_net_sysctl(net, "net/ipv4", tbl);
    2686         [ -  + ]:          3 :         if (!forw_hdr)
    2687                 :          0 :                 goto err_reg_ctl;
    2688                 :          3 :         net->ipv4.forw_hdr = forw_hdr;
    2689                 :            : #endif
    2690                 :            : 
    2691                 :          3 :         net->ipv4.devconf_all = all;
    2692                 :          3 :         net->ipv4.devconf_dflt = dflt;
    2693                 :          3 :         return 0;
    2694                 :            : 
    2695                 :            : #ifdef CONFIG_SYSCTL
    2696                 :            : err_reg_ctl:
    2697                 :          0 :         __devinet_sysctl_unregister(net, dflt, NETCONFA_IFINDEX_DEFAULT);
    2698                 :          0 : err_reg_dflt:
    2699                 :          0 :         __devinet_sysctl_unregister(net, all, NETCONFA_IFINDEX_ALL);
    2700                 :          0 : err_reg_all:
    2701                 :          0 :         kfree(tbl);
    2702                 :          0 : err_alloc_ctl:
    2703                 :            : #endif
    2704                 :          0 :         kfree(dflt);
    2705                 :          0 : err_alloc_dflt:
    2706                 :          0 :         kfree(all);
    2707                 :            : err_alloc_all:
    2708                 :            :         return err;
    2709                 :            : }
    2710                 :            : 
    2711                 :          0 : static __net_exit void devinet_exit_net(struct net *net)
    2712                 :            : {
    2713                 :            : #ifdef CONFIG_SYSCTL
    2714                 :          0 :         struct ctl_table *tbl;
    2715                 :            : 
    2716                 :          0 :         tbl = net->ipv4.forw_hdr->ctl_table_arg;
    2717                 :          0 :         unregister_net_sysctl_table(net->ipv4.forw_hdr);
    2718                 :          0 :         __devinet_sysctl_unregister(net, net->ipv4.devconf_dflt,
    2719                 :            :                                     NETCONFA_IFINDEX_DEFAULT);
    2720                 :          0 :         __devinet_sysctl_unregister(net, net->ipv4.devconf_all,
    2721                 :            :                                     NETCONFA_IFINDEX_ALL);
    2722                 :          0 :         kfree(tbl);
    2723                 :            : #endif
    2724                 :          0 :         kfree(net->ipv4.devconf_dflt);
    2725                 :          0 :         kfree(net->ipv4.devconf_all);
    2726                 :          0 : }
    2727                 :            : 
    2728                 :            : static __net_initdata struct pernet_operations devinet_ops = {
    2729                 :            :         .init = devinet_init_net,
    2730                 :            :         .exit = devinet_exit_net,
    2731                 :            : };
    2732                 :            : 
    2733                 :            : static struct rtnl_af_ops inet_af_ops __read_mostly = {
    2734                 :            :         .family           = AF_INET,
    2735                 :            :         .fill_link_af     = inet_fill_link_af,
    2736                 :            :         .get_link_af_size = inet_get_link_af_size,
    2737                 :            :         .validate_link_af = inet_validate_link_af,
    2738                 :            :         .set_link_af      = inet_set_link_af,
    2739                 :            : };
    2740                 :            : 
    2741                 :          3 : void __init devinet_init(void)
    2742                 :            : {
    2743                 :          3 :         int i;
    2744                 :            : 
    2745         [ +  + ]:        771 :         for (i = 0; i < IN4_ADDR_HSIZE; i++)
    2746                 :        768 :                 INIT_HLIST_HEAD(&inet_addr_lst[i]);
    2747                 :            : 
    2748                 :          3 :         register_pernet_subsys(&devinet_ops);
    2749                 :            : 
    2750                 :          3 :         register_gifconf(PF_INET, inet_gifconf);
    2751                 :          3 :         register_netdevice_notifier(&ip_netdev_notifier);
    2752                 :            : 
    2753                 :          3 :         queue_delayed_work(system_power_efficient_wq, &check_lifetime_work, 0);
    2754                 :            : 
    2755                 :          3 :         rtnl_af_register(&inet_af_ops);
    2756                 :            : 
    2757                 :          3 :         rtnl_register(PF_INET, RTM_NEWADDR, inet_rtm_newaddr, NULL, 0);
    2758                 :          3 :         rtnl_register(PF_INET, RTM_DELADDR, inet_rtm_deladdr, NULL, 0);
    2759                 :          3 :         rtnl_register(PF_INET, RTM_GETADDR, NULL, inet_dump_ifaddr, 0);
    2760                 :          3 :         rtnl_register(PF_INET, RTM_GETNETCONF, inet_netconf_get_devconf,
    2761                 :            :                       inet_netconf_dump_devconf, 0);
    2762                 :          3 : }

Generated by: LCOV version 1.14