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