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