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