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