net/ipv4/devinet.c

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