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