net/ipv4/devinet.c

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