net/ipv4/devinet.c

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