LCOV - code coverage report
Current view: top level - net/ipv4 - devinet.c (source / functions) Hit Total Coverage
Test: Real Lines: 529 1022 51.8 %
Date: 2020-10-17 15:46:16 Functions: 1 63 1.6 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

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

Generated by: LCOV version 1.14