net/ipv4/devinet.c

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