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