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