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