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