git.oblomov.eu Git - linux-2.6/blob - net/ipv4/devinet.c

   1 /*
   2  *      NET3    IP device support routines.
   3  *
   4  *      Version: $Id: devinet.c,v 1.44 2001/10/31 21:55:54 davem Exp $
   5  *
   6  *              This program is free software; you can redistribute it and/or
   7  *              modify it under the terms of the GNU General Public License
   8  *              as published by the Free Software Foundation; either version
   9  *              2 of the License, or (at your option) any later version.
  10  *
  11  *      Derived from the IP parts of dev.c 1.0.19
  12  *              Authors:        Ross Biro
  13  *                              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  14  *                              Mark Evans, <evansmp@uhura.aston.ac.uk>
  15  *
  16  *      Additional Authors:
  17  *              Alan Cox, <gw4pts@gw4pts.ampr.org>
  18  *              Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
  19  *
  20  *      Changes:
  21  *              Alexey Kuznetsov:       pa_* fields are replaced with ifaddr
  22  *                                      lists.
  23  *              Cyrus Durgin:           updated for kmod
  24  *              Matthias Andree:        in devinet_ioctl, compare label and
  25  *                                      address (4.4BSD alias style support),
  26  *                                      fall back to comparing just the label
  27  *                                      if no match found.
  28  */
  29
  30
  31 #include <asm/uaccess.h>
  32 #include <asm/system.h>
  33 #include <linux/bitops.h>
  34 #include <linux/capability.h>
  35 #include <linux/module.h>
  36 #include <linux/types.h>
  37 #include <linux/kernel.h>
  38 #include <linux/string.h>
  39 #include <linux/mm.h>
  40 #include <linux/socket.h>
  41 #include <linux/sockios.h>
  42 #include <linux/in.h>
  43 #include <linux/errno.h>
  44 #include <linux/interrupt.h>
  45 #include <linux/if_addr.h>
  46 #include <linux/if_ether.h>
  47 #include <linux/inet.h>
  48 #include <linux/netdevice.h>
  49 #include <linux/etherdevice.h>
  50 #include <linux/skbuff.h>
  51 #include <linux/init.h>
  52 #include <linux/notifier.h>
  53 #include <linux/inetdevice.h>
  54 #include <linux/igmp.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
  66 struct ipv4_devconf ipv4_devconf = {
  67         .data = {
  68                 [NET_IPV4_CONF_ACCEPT_REDIRECTS - 1] = 1,
  69                 [NET_IPV4_CONF_SEND_REDIRECTS - 1] = 1,
  70                 [NET_IPV4_CONF_SECURE_REDIRECTS - 1] = 1,
  71                 [NET_IPV4_CONF_SHARED_MEDIA - 1] = 1,
  72         },
  73 };
  74
  75 static struct ipv4_devconf ipv4_devconf_dflt = {
  76         .data = {
  77                 [NET_IPV4_CONF_ACCEPT_REDIRECTS - 1] = 1,
  78                 [NET_IPV4_CONF_SEND_REDIRECTS - 1] = 1,
  79                 [NET_IPV4_CONF_SECURE_REDIRECTS - 1] = 1,
  80                 [NET_IPV4_CONF_SHARED_MEDIA - 1] = 1,
  81                 [NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE - 1] = 1,
  82         },
  83 };
  84
  85 #define IPV4_DEVCONF_DFLT(attr) IPV4_DEVCONF(ipv4_devconf_dflt, attr)
  86
  87 static const struct nla_policy ifa_ipv4_policy[IFA_MAX+1] = {
  88         [IFA_LOCAL]             = { .type = NLA_U32 },
  89         [IFA_ADDRESS]           = { .type = NLA_U32 },
  90         [IFA_BROADCAST]         = { .type = NLA_U32 },
  91         [IFA_ANYCAST]           = { .type = NLA_U32 },
  92         [IFA_LABEL]             = { .type = NLA_STRING, .len = IFNAMSIZ - 1 },
  93 };
  94
  95 static void rtmsg_ifa(int event, struct in_ifaddr *, struct nlmsghdr *, u32);
  96
  97 static BLOCKING_NOTIFIER_HEAD(inetaddr_chain);
  98 static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
  99                          int destroy);
 100 #ifdef CONFIG_SYSCTL
 101 static void devinet_sysctl_register(struct in_device *in_dev,
 102                                     struct ipv4_devconf *p);
 103 static void devinet_sysctl_unregister(struct ipv4_devconf *p);
 104 #endif
 105
 106 /* Locks all the inet devices. */
 107
 108 static struct in_ifaddr *inet_alloc_ifa(void)
 109 {
 110         struct in_ifaddr *ifa = kzalloc(sizeof(*ifa), GFP_KERNEL);
 111
 112         if (ifa) {
 113                 INIT_RCU_HEAD(&ifa->rcu_head);
 114         }
 115
 116         return ifa;
 117 }
 118
 119 static void inet_rcu_free_ifa(struct rcu_head *head)
 120 {
 121         struct in_ifaddr *ifa = container_of(head, struct in_ifaddr, rcu_head);
 122         if (ifa->ifa_dev)
 123                 in_dev_put(ifa->ifa_dev);
 124         kfree(ifa);
 125 }
 126
 127 static inline void inet_free_ifa(struct in_ifaddr *ifa)
 128 {
 129         call_rcu(&ifa->rcu_head, inet_rcu_free_ifa);
 130 }
 131
 132 void in_dev_finish_destroy(struct in_device *idev)
 133 {
 134         struct net_device *dev = idev->dev;
 135
 136         BUG_TRAP(!idev->ifa_list);
 137         BUG_TRAP(!idev->mc_list);
 138 #ifdef NET_REFCNT_DEBUG
 139         printk(KERN_DEBUG "in_dev_finish_destroy: %p=%s\n",
 140                idev, dev ? dev->name : "NIL");
 141 #endif
 142         dev_put(dev);
 143         if (!idev->dead)
 144                 printk("Freeing alive in_device %p\n", idev);
 145         else {
 146                 kfree(idev);
 147         }
 148 }
 149
 150 static struct in_device *inetdev_init(struct net_device *dev)
 151 {
 152         struct in_device *in_dev;
 153
 154         ASSERT_RTNL();
 155
 156         in_dev = kzalloc(sizeof(*in_dev), GFP_KERNEL);
 157         if (!in_dev)
 158                 goto out;
 159         INIT_RCU_HEAD(&in_dev->rcu_head);
 160         memcpy(&in_dev->cnf, &ipv4_devconf_dflt, sizeof(in_dev->cnf));
 161         in_dev->cnf.sysctl = NULL;
 162         in_dev->dev = dev;
 163         if ((in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl)) == NULL)
 164                 goto out_kfree;
 165         /* Reference in_dev->dev */
 166         dev_hold(dev);
 167 #ifdef CONFIG_SYSCTL
 168         neigh_sysctl_register(dev, in_dev->arp_parms, NET_IPV4,
 169                               NET_IPV4_NEIGH, "ipv4", NULL, NULL);
 170 #endif
 171
 172         /* Account for reference dev->ip_ptr (below) */
 173         in_dev_hold(in_dev);
 174
 175 #ifdef CONFIG_SYSCTL
 176         devinet_sysctl_register(in_dev, &in_dev->cnf);
 177 #endif
 178         ip_mc_init_dev(in_dev);
 179         if (dev->flags & IFF_UP)
 180                 ip_mc_up(in_dev);
 181
 182         /* we can receive as soon as ip_ptr is set -- do this last */
 183         rcu_assign_pointer(dev->ip_ptr, in_dev);
 184 out:
 185         return in_dev;
 186 out_kfree:
 187         kfree(in_dev);
 188         in_dev = NULL;
 189         goto out;
 190 }
 191
 192 static void in_dev_rcu_put(struct rcu_head *head)
 193 {
 194         struct in_device *idev = container_of(head, struct in_device, rcu_head);
 195         in_dev_put(idev);
 196 }
 197
 198 static void inetdev_destroy(struct in_device *in_dev)
 199 {
 200         struct in_ifaddr *ifa;
 201         struct net_device *dev;
 202
 203         ASSERT_RTNL();
 204
 205         dev = in_dev->dev;
 206         if (dev == &loopback_dev)
 207                 return;
 208
 209         in_dev->dead = 1;
 210
 211         ip_mc_destroy_dev(in_dev);
 212
 213         while ((ifa = in_dev->ifa_list) != NULL) {
 214                 inet_del_ifa(in_dev, &in_dev->ifa_list, 0);
 215                 inet_free_ifa(ifa);
 216         }
 217
 218 #ifdef CONFIG_SYSCTL
 219         devinet_sysctl_unregister(&in_dev->cnf);
 220 #endif
 221
 222         dev->ip_ptr = NULL;
 223
 224 #ifdef CONFIG_SYSCTL
 225         neigh_sysctl_unregister(in_dev->arp_parms);
 226 #endif
 227         neigh_parms_release(&arp_tbl, in_dev->arp_parms);
 228         arp_ifdown(dev);
 229
 230         call_rcu(&in_dev->rcu_head, in_dev_rcu_put);
 231 }
 232
 233 int inet_addr_onlink(struct in_device *in_dev, __be32 a, __be32 b)
 234 {
 235         rcu_read_lock();
 236         for_primary_ifa(in_dev) {
 237                 if (inet_ifa_match(a, ifa)) {
 238                         if (!b || inet_ifa_match(b, ifa)) {
 239                                 rcu_read_unlock();
 240                                 return 1;
 241                         }
 242                 }
 243         } endfor_ifa(in_dev);
 244         rcu_read_unlock();
 245         return 0;
 246 }
 247
 248 static void __inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
 249                          int destroy, struct nlmsghdr *nlh, u32 pid)
 250 {
 251         struct in_ifaddr *promote = NULL;
 252         struct in_ifaddr *ifa, *ifa1 = *ifap;
 253         struct in_ifaddr *last_prim = in_dev->ifa_list;
 254         struct in_ifaddr *prev_prom = NULL;
 255         int do_promote = IN_DEV_PROMOTE_SECONDARIES(in_dev);
 256
 257         ASSERT_RTNL();
 258
 259         /* 1. Deleting primary ifaddr forces deletion all secondaries
 260          * unless alias promotion is set
 261          **/
 262
 263         if (!(ifa1->ifa_flags & IFA_F_SECONDARY)) {
 264                 struct in_ifaddr **ifap1 = &ifa1->ifa_next;
 265
 266                 while ((ifa = *ifap1) != NULL) {
 267                         if (!(ifa->ifa_flags & IFA_F_SECONDARY) &&
 268                             ifa1->ifa_scope <= ifa->ifa_scope)
 269                                 last_prim = ifa;
 270
 271                         if (!(ifa->ifa_flags & IFA_F_SECONDARY) ||
 272                             ifa1->ifa_mask != ifa->ifa_mask ||
 273                             !inet_ifa_match(ifa1->ifa_address, ifa)) {
 274                                 ifap1 = &ifa->ifa_next;
 275                                 prev_prom = ifa;
 276                                 continue;
 277                         }
 278
 279                         if (!do_promote) {
 280                                 *ifap1 = ifa->ifa_next;
 281
 282                                 rtmsg_ifa(RTM_DELADDR, ifa, nlh, pid);
 283                                 blocking_notifier_call_chain(&inetaddr_chain,
 284                                                 NETDEV_DOWN, ifa);
 285                                 inet_free_ifa(ifa);
 286                         } else {
 287                                 promote = ifa;
 288                                 break;
 289                         }
 290                 }
 291         }
 292
 293         /* 2. Unlink it */
 294
 295         *ifap = ifa1->ifa_next;
 296
 297         /* 3. Announce address deletion */
 298
 299         /* Send message first, then call notifier.
 300            At first sight, FIB update triggered by notifier
 301            will refer to already deleted ifaddr, that could confuse
 302            netlink listeners. It is not true: look, gated sees
 303            that route deleted and if it still thinks that ifaddr
 304            is valid, it will try to restore deleted routes... Grr.
 305            So that, this order is correct.
 306          */
 307         rtmsg_ifa(RTM_DELADDR, ifa1, nlh, pid);
 308         blocking_notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1);
 309
 310         if (promote) {
 311
 312                 if (prev_prom) {
 313                         prev_prom->ifa_next = promote->ifa_next;
 314                         promote->ifa_next = last_prim->ifa_next;
 315                         last_prim->ifa_next = promote;
 316                 }
 317
 318                 promote->ifa_flags &= ~IFA_F_SECONDARY;
 319                 rtmsg_ifa(RTM_NEWADDR, promote, nlh, pid);
 320                 blocking_notifier_call_chain(&inetaddr_chain,
 321                                 NETDEV_UP, promote);
 322                 for (ifa = promote->ifa_next; ifa; ifa = ifa->ifa_next) {
 323                         if (ifa1->ifa_mask != ifa->ifa_mask ||
 324                             !inet_ifa_match(ifa1->ifa_address, ifa))
 325                                         continue;
 326                         fib_add_ifaddr(ifa);
 327                 }
 328
 329         }
 330         if (destroy) {
 331                 inet_free_ifa(ifa1);
 332
 333                 if (!in_dev->ifa_list)
 334                         inetdev_destroy(in_dev);
 335         }
 336 }
 337
 338 static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
 339                          int destroy)
 340 {
 341         __inet_del_ifa(in_dev, ifap, destroy, NULL, 0);
 342 }
 343
 344 static int __inet_insert_ifa(struct in_ifaddr *ifa, struct nlmsghdr *nlh,
 345                              u32 pid)
 346 {
 347         struct in_device *in_dev = ifa->ifa_dev;
 348         struct in_ifaddr *ifa1, **ifap, **last_primary;
 349
 350         ASSERT_RTNL();
 351
 352         if (!ifa->ifa_local) {
 353                 inet_free_ifa(ifa);
 354                 return 0;
 355         }
 356
 357         ifa->ifa_flags &= ~IFA_F_SECONDARY;
 358         last_primary = &in_dev->ifa_list;
 359
 360         for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL;
 361              ifap = &ifa1->ifa_next) {
 362                 if (!(ifa1->ifa_flags & IFA_F_SECONDARY) &&
 363                     ifa->ifa_scope <= ifa1->ifa_scope)
 364                         last_primary = &ifa1->ifa_next;
 365                 if (ifa1->ifa_mask == ifa->ifa_mask &&
 366                     inet_ifa_match(ifa1->ifa_address, ifa)) {
 367                         if (ifa1->ifa_local == ifa->ifa_local) {
 368                                 inet_free_ifa(ifa);
 369                                 return -EEXIST;
 370                         }
 371                         if (ifa1->ifa_scope != ifa->ifa_scope) {
 372                                 inet_free_ifa(ifa);
 373                                 return -EINVAL;
 374                         }
 375                         ifa->ifa_flags |= IFA_F_SECONDARY;
 376                 }
 377         }
 378
 379         if (!(ifa->ifa_flags & IFA_F_SECONDARY)) {
 380                 net_srandom(ifa->ifa_local);
 381                 ifap = last_primary;
 382         }
 383
 384         ifa->ifa_next = *ifap;
 385         *ifap = ifa;
 386
 387         /* Send message first, then call notifier.
 388            Notifier will trigger FIB update, so that
 389            listeners of netlink will know about new ifaddr */
 390         rtmsg_ifa(RTM_NEWADDR, ifa, nlh, pid);
 391         blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
 392
 393         return 0;
 394 }
 395
 396 static int inet_insert_ifa(struct in_ifaddr *ifa)
 397 {
 398         return __inet_insert_ifa(ifa, NULL, 0);
 399 }
 400
 401 static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa)
 402 {
 403         struct in_device *in_dev = __in_dev_get_rtnl(dev);
 404
 405         ASSERT_RTNL();
 406
 407         if (!in_dev) {
 408                 inet_free_ifa(ifa);
 409                 return -ENOBUFS;
 410         }
 411         ipv4_devconf_setall(in_dev);
 412         if (ifa->ifa_dev != in_dev) {
 413                 BUG_TRAP(!ifa->ifa_dev);
 414                 in_dev_hold(in_dev);
 415                 ifa->ifa_dev = in_dev;
 416         }
 417         if (LOOPBACK(ifa->ifa_local))
 418                 ifa->ifa_scope = RT_SCOPE_HOST;
 419         return inet_insert_ifa(ifa);
 420 }
 421
 422 struct in_device *inetdev_by_index(int ifindex)
 423 {
 424         struct net_device *dev;
 425         struct in_device *in_dev = NULL;
 426         read_lock(&dev_base_lock);
 427         dev = __dev_get_by_index(ifindex);
 428         if (dev)
 429                 in_dev = in_dev_get(dev);
 430         read_unlock(&dev_base_lock);
 431         return in_dev;
 432 }
 433
 434 /* Called only from RTNL semaphored context. No locks. */
 435
 436 struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, __be32 prefix,
 437                                     __be32 mask)
 438 {
 439         ASSERT_RTNL();
 440
 441         for_primary_ifa(in_dev) {
 442                 if (ifa->ifa_mask == mask && inet_ifa_match(prefix, ifa))
 443                         return ifa;
 444         } endfor_ifa(in_dev);
 445         return NULL;
 446 }
 447
 448 static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
 449 {
 450         struct nlattr *tb[IFA_MAX+1];
 451         struct in_device *in_dev;
 452         struct ifaddrmsg *ifm;
 453         struct in_ifaddr *ifa, **ifap;
 454         int err = -EINVAL;
 455
 456         ASSERT_RTNL();
 457
 458         err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
 459         if (err < 0)
 460                 goto errout;
 461
 462         ifm = nlmsg_data(nlh);
 463         in_dev = inetdev_by_index(ifm->ifa_index);
 464         if (in_dev == NULL) {
 465                 err = -ENODEV;
 466                 goto errout;
 467         }
 468
 469         __in_dev_put(in_dev);
 470
 471         for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
 472              ifap = &ifa->ifa_next) {
 473                 if (tb[IFA_LOCAL] &&
 474                     ifa->ifa_local != nla_get_be32(tb[IFA_LOCAL]))
 475                         continue;
 476
 477                 if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label))
 478                         continue;
 479
 480                 if (tb[IFA_ADDRESS] &&
 481                     (ifm->ifa_prefixlen != ifa->ifa_prefixlen ||
 482                     !inet_ifa_match(nla_get_be32(tb[IFA_ADDRESS]), ifa)))
 483                         continue;
 484
 485                 __inet_del_ifa(in_dev, ifap, 1, nlh, NETLINK_CB(skb).pid);
 486                 return 0;
 487         }
 488
 489         err = -EADDRNOTAVAIL;
 490 errout:
 491         return err;
 492 }
 493
 494 static struct in_ifaddr *rtm_to_ifaddr(struct nlmsghdr *nlh)
 495 {
 496         struct nlattr *tb[IFA_MAX+1];
 497         struct in_ifaddr *ifa;
 498         struct ifaddrmsg *ifm;
 499         struct net_device *dev;
 500         struct in_device *in_dev;
 501         int err = -EINVAL;
 502
 503         err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
 504         if (err < 0)
 505                 goto errout;
 506
 507         ifm = nlmsg_data(nlh);
 508         if (ifm->ifa_prefixlen > 32 || tb[IFA_LOCAL] == NULL) {
 509                 err = -EINVAL;
 510                 goto errout;
 511         }
 512
 513         dev = __dev_get_by_index(ifm->ifa_index);
 514         if (dev == NULL) {
 515                 err = -ENODEV;
 516                 goto errout;
 517         }
 518
 519         in_dev = __in_dev_get_rtnl(dev);
 520         if (in_dev == NULL) {
 521                 err = -ENOBUFS;
 522                 goto errout;
 523         }
 524
 525         ipv4_devconf_setall(in_dev);
 526
 527         ifa = inet_alloc_ifa();
 528         if (ifa == NULL) {
 529                 /*
 530                  * A potential indev allocation can be left alive, it stays
 531                  * assigned to its device and is destroy with it.
 532                  */
 533                 err = -ENOBUFS;
 534                 goto errout;
 535         }
 536
 537         in_dev_hold(in_dev);
 538
 539         if (tb[IFA_ADDRESS] == NULL)
 540                 tb[IFA_ADDRESS] = tb[IFA_LOCAL];
 541
 542         ifa->ifa_prefixlen = ifm->ifa_prefixlen;
 543         ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen);
 544         ifa->ifa_flags = ifm->ifa_flags;
 545         ifa->ifa_scope = ifm->ifa_scope;
 546         ifa->ifa_dev = in_dev;
 547
 548         ifa->ifa_local = nla_get_be32(tb[IFA_LOCAL]);
 549         ifa->ifa_address = nla_get_be32(tb[IFA_ADDRESS]);
 550
 551         if (tb[IFA_BROADCAST])
 552                 ifa->ifa_broadcast = nla_get_be32(tb[IFA_BROADCAST]);
 553
 554         if (tb[IFA_ANYCAST])
 555                 ifa->ifa_anycast = nla_get_be32(tb[IFA_ANYCAST]);
 556
 557         if (tb[IFA_LABEL])
 558                 nla_strlcpy(ifa->ifa_label, tb[IFA_LABEL], IFNAMSIZ);
 559         else
 560                 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
 561
 562         return ifa;
 563
 564 errout:
 565         return ERR_PTR(err);
 566 }
 567
 568 static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
 569 {
 570         struct in_ifaddr *ifa;
 571
 572         ASSERT_RTNL();
 573
 574         ifa = rtm_to_ifaddr(nlh);
 575         if (IS_ERR(ifa))
 576                 return PTR_ERR(ifa);
 577
 578         return __inet_insert_ifa(ifa, nlh, NETLINK_CB(skb).pid);
 579 }
 580
 581 /*
 582  *      Determine a default network mask, based on the IP address.
 583  */
 584
 585 static __inline__ int inet_abc_len(__be32 addr)
 586 {
 587         int rc = -1;    /* Something else, probably a multicast. */
 588
 589         if (ZERONET(addr))
 590                 rc = 0;
 591         else {
 592                 __u32 haddr = ntohl(addr);
 593
 594                 if (IN_CLASSA(haddr))
 595                         rc = 8;
 596                 else if (IN_CLASSB(haddr))
 597                         rc = 16;
 598                 else if (IN_CLASSC(haddr))
 599                         rc = 24;
 600         }
 601
 602         return rc;
 603 }
 604
 605
 606 int devinet_ioctl(unsigned int cmd, void __user *arg)
 607 {
 608         struct ifreq ifr;
 609         struct sockaddr_in sin_orig;
 610         struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
 611         struct in_device *in_dev;
 612         struct in_ifaddr **ifap = NULL;
 613         struct in_ifaddr *ifa = NULL;
 614         struct net_device *dev;
 615         char *colon;
 616         int ret = -EFAULT;
 617         int tryaddrmatch = 0;
 618
 619         /*
 620          *      Fetch the caller's info block into kernel space
 621          */
 622
 623         if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
 624                 goto out;
 625         ifr.ifr_name[IFNAMSIZ - 1] = 0;
 626
 627         /* save original address for comparison */
 628         memcpy(&sin_orig, sin, sizeof(*sin));
 629
 630         colon = strchr(ifr.ifr_name, ':');
 631         if (colon)
 632                 *colon = 0;
 633
 634 #ifdef CONFIG_KMOD
 635         dev_load(ifr.ifr_name);
 636 #endif
 637
 638         switch (cmd) {
 639         case SIOCGIFADDR:       /* Get interface address */
 640         case SIOCGIFBRDADDR:    /* Get the broadcast address */
 641         case SIOCGIFDSTADDR:    /* Get the destination address */
 642         case SIOCGIFNETMASK:    /* Get the netmask for the interface */
 643                 /* Note that these ioctls will not sleep,
 644                    so that we do not impose a lock.
 645                    One day we will be forced to put shlock here (I mean SMP)
 646                  */
 647                 tryaddrmatch = (sin_orig.sin_family == AF_INET);
 648                 memset(sin, 0, sizeof(*sin));
 649                 sin->sin_family = AF_INET;
 650                 break;
 651
 652         case SIOCSIFFLAGS:
 653                 ret = -EACCES;
 654                 if (!capable(CAP_NET_ADMIN))
 655                         goto out;
 656                 break;
 657         case SIOCSIFADDR:       /* Set interface address (and family) */
 658         case SIOCSIFBRDADDR:    /* Set the broadcast address */
 659         case SIOCSIFDSTADDR:    /* Set the destination address */
 660         case SIOCSIFNETMASK:    /* Set the netmask for the interface */
 661                 ret = -EACCES;
 662                 if (!capable(CAP_NET_ADMIN))
 663                         goto out;
 664                 ret = -EINVAL;
 665                 if (sin->sin_family != AF_INET)
 666                         goto out;
 667                 break;
 668         default:
 669                 ret = -EINVAL;
 670                 goto out;
 671         }
 672
 673         rtnl_lock();
 674
 675         ret = -ENODEV;
 676         if ((dev = __dev_get_by_name(ifr.ifr_name)) == NULL)
 677                 goto done;
 678
 679         if (colon)
 680                 *colon = ':';
 681
 682         if ((in_dev = __in_dev_get_rtnl(dev)) != NULL) {
 683                 if (tryaddrmatch) {
 684                         /* Matthias Andree */
 685                         /* compare label and address (4.4BSD style) */
 686                         /* note: we only do this for a limited set of ioctls
 687                            and only if the original address family was AF_INET.
 688                            This is checked above. */
 689                         for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
 690                              ifap = &ifa->ifa_next) {
 691                                 if (!strcmp(ifr.ifr_name, ifa->ifa_label) &&
 692                                     sin_orig.sin_addr.s_addr ==
 693                                                         ifa->ifa_address) {
 694                                         break; /* found */
 695                                 }
 696                         }
 697                 }
 698                 /* we didn't get a match, maybe the application is
 699                    4.3BSD-style and passed in junk so we fall back to
 700                    comparing just the label */
 701                 if (!ifa) {
 702                         for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
 703                              ifap = &ifa->ifa_next)
 704                                 if (!strcmp(ifr.ifr_name, ifa->ifa_label))
 705                                         break;
 706                 }
 707         }
 708
 709         ret = -EADDRNOTAVAIL;
 710         if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS)
 711                 goto done;
 712
 713         switch (cmd) {
 714         case SIOCGIFADDR:       /* Get interface address */
 715                 sin->sin_addr.s_addr = ifa->ifa_local;
 716                 goto rarok;
 717
 718         case SIOCGIFBRDADDR:    /* Get the broadcast address */
 719                 sin->sin_addr.s_addr = ifa->ifa_broadcast;
 720                 goto rarok;
 721
 722         case SIOCGIFDSTADDR:    /* Get the destination address */
 723                 sin->sin_addr.s_addr = ifa->ifa_address;
 724                 goto rarok;
 725
 726         case SIOCGIFNETMASK:    /* Get the netmask for the interface */
 727                 sin->sin_addr.s_addr = ifa->ifa_mask;
 728                 goto rarok;
 729
 730         case SIOCSIFFLAGS:
 731                 if (colon) {
 732                         ret = -EADDRNOTAVAIL;
 733                         if (!ifa)
 734                                 break;
 735                         ret = 0;
 736                         if (!(ifr.ifr_flags & IFF_UP))
 737                                 inet_del_ifa(in_dev, ifap, 1);
 738                         break;
 739                 }
 740                 ret = dev_change_flags(dev, ifr.ifr_flags);
 741                 break;
 742
 743         case SIOCSIFADDR:       /* Set interface address (and family) */
 744                 ret = -EINVAL;
 745                 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
 746                         break;
 747
 748                 if (!ifa) {
 749                         ret = -ENOBUFS;
 750                         if ((ifa = inet_alloc_ifa()) == NULL)
 751                                 break;
 752                         if (colon)
 753                                 memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ);
 754                         else
 755                                 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
 756                 } else {
 757                         ret = 0;
 758                         if (ifa->ifa_local == sin->sin_addr.s_addr)
 759                                 break;
 760                         inet_del_ifa(in_dev, ifap, 0);
 761                         ifa->ifa_broadcast = 0;
 762                         ifa->ifa_anycast = 0;
 763                 }
 764
 765                 ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr;
 766
 767                 if (!(dev->flags & IFF_POINTOPOINT)) {
 768                         ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address);
 769                         ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen);
 770                         if ((dev->flags & IFF_BROADCAST) &&
 771                             ifa->ifa_prefixlen < 31)
 772                                 ifa->ifa_broadcast = ifa->ifa_address |
 773                                                      ~ifa->ifa_mask;
 774                 } else {
 775                         ifa->ifa_prefixlen = 32;
 776                         ifa->ifa_mask = inet_make_mask(32);
 777                 }
 778                 ret = inet_set_ifa(dev, ifa);
 779                 break;
 780
 781         case SIOCSIFBRDADDR:    /* Set the broadcast address */
 782                 ret = 0;
 783                 if (ifa->ifa_broadcast != sin->sin_addr.s_addr) {
 784                         inet_del_ifa(in_dev, ifap, 0);
 785                         ifa->ifa_broadcast = sin->sin_addr.s_addr;
 786                         inet_insert_ifa(ifa);
 787                 }
 788                 break;
 789
 790         case SIOCSIFDSTADDR:    /* Set the destination address */
 791                 ret = 0;
 792                 if (ifa->ifa_address == sin->sin_addr.s_addr)
 793                         break;
 794                 ret = -EINVAL;
 795                 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
 796                         break;
 797                 ret = 0;
 798                 inet_del_ifa(in_dev, ifap, 0);
 799                 ifa->ifa_address = sin->sin_addr.s_addr;
 800                 inet_insert_ifa(ifa);
 801                 break;
 802
 803         case SIOCSIFNETMASK:    /* Set the netmask for the interface */
 804
 805                 /*
 806                  *      The mask we set must be legal.
 807                  */
 808                 ret = -EINVAL;
 809                 if (bad_mask(sin->sin_addr.s_addr, 0))
 810                         break;
 811                 ret = 0;
 812                 if (ifa->ifa_mask != sin->sin_addr.s_addr) {
 813                         __be32 old_mask = ifa->ifa_mask;
 814                         inet_del_ifa(in_dev, ifap, 0);
 815                         ifa->ifa_mask = sin->sin_addr.s_addr;
 816                         ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask);
 817
 818                         /* See if current broadcast address matches
 819                          * with current netmask, then recalculate
 820                          * the broadcast address. Otherwise it's a
 821                          * funny address, so don't touch it since
 822                          * the user seems to know what (s)he's doing...
 823                          */
 824                         if ((dev->flags & IFF_BROADCAST) &&
 825                             (ifa->ifa_prefixlen < 31) &&
 826                             (ifa->ifa_broadcast ==
 827                              (ifa->ifa_local|~old_mask))) {
 828                                 ifa->ifa_broadcast = (ifa->ifa_local |
 829                                                       ~sin->sin_addr.s_addr);
 830                         }
 831                         inet_insert_ifa(ifa);
 832                 }
 833                 break;
 834         }
 835 done:
 836         rtnl_unlock();
 837 out:
 838         return ret;
 839 rarok:
 840         rtnl_unlock();
 841         ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0;
 842         goto out;
 843 }
 844
 845 static int inet_gifconf(struct net_device *dev, char __user *buf, int len)
 846 {
 847         struct in_device *in_dev = __in_dev_get_rtnl(dev);
 848         struct in_ifaddr *ifa;
 849         struct ifreq ifr;
 850         int done = 0;
 851
 852         if (!in_dev || (ifa = in_dev->ifa_list) == NULL)
 853                 goto out;
 854
 855         for (; ifa; ifa = ifa->ifa_next) {
 856                 if (!buf) {
 857                         done += sizeof(ifr);
 858                         continue;
 859                 }
 860                 if (len < (int) sizeof(ifr))
 861                         break;
 862                 memset(&ifr, 0, sizeof(struct ifreq));
 863                 if (ifa->ifa_label)
 864                         strcpy(ifr.ifr_name, ifa->ifa_label);
 865                 else
 866                         strcpy(ifr.ifr_name, dev->name);
 867
 868                 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET;
 869                 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr =
 870                                                                 ifa->ifa_local;
 871
 872                 if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) {
 873                         done = -EFAULT;
 874                         break;
 875                 }
 876                 buf  += sizeof(struct ifreq);
 877                 len  -= sizeof(struct ifreq);
 878                 done += sizeof(struct ifreq);
 879         }
 880 out:
 881         return done;
 882 }
 883
 884 __be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope)
 885 {
 886         __be32 addr = 0;
 887         struct in_device *in_dev;
 888
 889         rcu_read_lock();
 890         in_dev = __in_dev_get_rcu(dev);
 891         if (!in_dev)
 892                 goto no_in_dev;
 893
 894         for_primary_ifa(in_dev) {
 895                 if (ifa->ifa_scope > scope)
 896                         continue;
 897                 if (!dst || inet_ifa_match(dst, ifa)) {
 898                         addr = ifa->ifa_local;
 899                         break;
 900                 }
 901                 if (!addr)
 902                         addr = ifa->ifa_local;
 903         } endfor_ifa(in_dev);
 904 no_in_dev:
 905         rcu_read_unlock();
 906
 907         if (addr)
 908                 goto out;
 909
 910         /* Not loopback addresses on loopback should be preferred
 911            in this case. It is importnat that lo is the first interface
 912            in dev_base list.
 913          */
 914         read_lock(&dev_base_lock);
 915         rcu_read_lock();
 916         for_each_netdev(dev) {
 917                 if ((in_dev = __in_dev_get_rcu(dev)) == NULL)
 918                         continue;
 919
 920                 for_primary_ifa(in_dev) {
 921                         if (ifa->ifa_scope != RT_SCOPE_LINK &&
 922                             ifa->ifa_scope <= scope) {
 923                                 addr = ifa->ifa_local;
 924                                 goto out_unlock_both;
 925                         }
 926                 } endfor_ifa(in_dev);
 927         }
 928 out_unlock_both:
 929         read_unlock(&dev_base_lock);
 930         rcu_read_unlock();
 931 out:
 932         return addr;
 933 }
 934
 935 static __be32 confirm_addr_indev(struct in_device *in_dev, __be32 dst,
 936                               __be32 local, int scope)
 937 {
 938         int same = 0;
 939         __be32 addr = 0;
 940
 941         for_ifa(in_dev) {
 942                 if (!addr &&
 943                     (local == ifa->ifa_local || !local) &&
 944                     ifa->ifa_scope <= scope) {
 945                         addr = ifa->ifa_local;
 946                         if (same)
 947                                 break;
 948                 }
 949                 if (!same) {
 950                         same = (!local || inet_ifa_match(local, ifa)) &&
 951                                 (!dst || inet_ifa_match(dst, ifa));
 952                         if (same && addr) {
 953                                 if (local || !dst)
 954                                         break;
 955                                 /* Is the selected addr into dst subnet? */
 956                                 if (inet_ifa_match(addr, ifa))
 957                                         break;
 958                                 /* No, then can we use new local src? */
 959                                 if (ifa->ifa_scope <= scope) {
 960                                         addr = ifa->ifa_local;
 961                                         break;
 962                                 }
 963                                 /* search for large dst subnet for addr */
 964                                 same = 0;
 965                         }
 966                 }
 967         } endfor_ifa(in_dev);
 968
 969         return same? addr : 0;
 970 }
 971
 972 /*
 973  * Confirm that local IP address exists using wildcards:
 974  * - dev: only on this interface, 0=any interface
 975  * - dst: only in the same subnet as dst, 0=any dst
 976  * - local: address, 0=autoselect the local address
 977  * - scope: maximum allowed scope value for the local address
 978  */
 979 __be32 inet_confirm_addr(const struct net_device *dev, __be32 dst, __be32 local, int scope)
 980 {
 981         __be32 addr = 0;
 982         struct in_device *in_dev;
 983
 984         if (dev) {
 985                 rcu_read_lock();
 986                 if ((in_dev = __in_dev_get_rcu(dev)))
 987                         addr = confirm_addr_indev(in_dev, dst, local, scope);
 988                 rcu_read_unlock();
 989
 990                 return addr;
 991         }
 992
 993         read_lock(&dev_base_lock);
 994         rcu_read_lock();
 995         for_each_netdev(dev) {
 996                 if ((in_dev = __in_dev_get_rcu(dev))) {
 997                         addr = confirm_addr_indev(in_dev, dst, local, scope);
 998                         if (addr)
 999                                 break;
1000                 }
1001         }
1002         rcu_read_unlock();
1003         read_unlock(&dev_base_lock);
1004
1005         return addr;
1006 }
1007
1008 /*
1009  *      Device notifier
1010  */
1011
1012 int register_inetaddr_notifier(struct notifier_block *nb)
1013 {
1014         return blocking_notifier_chain_register(&inetaddr_chain, nb);
1015 }
1016
1017 int unregister_inetaddr_notifier(struct notifier_block *nb)
1018 {
1019         return blocking_notifier_chain_unregister(&inetaddr_chain, nb);
1020 }
1021
1022 /* Rename ifa_labels for a device name change. Make some effort to preserve existing
1023  * alias numbering and to create unique labels if possible.
1024 */
1025 static void inetdev_changename(struct net_device *dev, struct in_device *in_dev)
1026 {
1027         struct in_ifaddr *ifa;
1028         int named = 0;
1029
1030         for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
1031                 char old[IFNAMSIZ], *dot;
1032
1033                 memcpy(old, ifa->ifa_label, IFNAMSIZ);
1034                 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1035                 if (named++ == 0)
1036                         continue;
1037                 dot = strchr(ifa->ifa_label, ':');
1038                 if (dot == NULL) {
1039                         sprintf(old, ":%d", named);
1040                         dot = old;
1041                 }
1042                 if (strlen(dot) + strlen(dev->name) < IFNAMSIZ) {
1043                         strcat(ifa->ifa_label, dot);
1044                 } else {
1045                         strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot);
1046                 }
1047         }
1048 }
1049
1050 /* Called only under RTNL semaphore */
1051
1052 static int inetdev_event(struct notifier_block *this, unsigned long event,
1053                          void *ptr)
1054 {
1055         struct net_device *dev = ptr;
1056         struct in_device *in_dev = __in_dev_get_rtnl(dev);
1057
1058         ASSERT_RTNL();
1059
1060         if (!in_dev) {
1061                 if (event == NETDEV_REGISTER) {
1062                         in_dev = inetdev_init(dev);
1063                         if (dev == &loopback_dev) {
1064                                 if (!in_dev)
1065                                         panic("devinet: "
1066                                               "Failed to create loopback\n");
1067                                 IN_DEV_CONF_SET(in_dev, NOXFRM, 1);
1068                                 IN_DEV_CONF_SET(in_dev, NOPOLICY, 1);
1069                         }
1070                 }
1071                 goto out;
1072         }
1073
1074         switch (event) {
1075         case NETDEV_REGISTER:
1076                 printk(KERN_DEBUG "inetdev_event: bug\n");
1077                 dev->ip_ptr = NULL;
1078                 break;
1079         case NETDEV_UP:
1080                 if (dev->mtu < 68)
1081                         break;
1082                 if (dev == &loopback_dev) {
1083                         struct in_ifaddr *ifa;
1084                         if ((ifa = inet_alloc_ifa()) != NULL) {
1085                                 ifa->ifa_local =
1086                                   ifa->ifa_address = htonl(INADDR_LOOPBACK);
1087                                 ifa->ifa_prefixlen = 8;
1088                                 ifa->ifa_mask = inet_make_mask(8);
1089                                 in_dev_hold(in_dev);
1090                                 ifa->ifa_dev = in_dev;
1091                                 ifa->ifa_scope = RT_SCOPE_HOST;
1092                                 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1093                                 inet_insert_ifa(ifa);
1094                         }
1095                 }
1096                 ip_mc_up(in_dev);
1097                 break;
1098         case NETDEV_DOWN:
1099                 ip_mc_down(in_dev);
1100                 break;
1101         case NETDEV_CHANGEMTU:
1102                 if (dev->mtu >= 68)
1103                         break;
1104                 /* MTU falled under 68, disable IP */
1105         case NETDEV_UNREGISTER:
1106                 inetdev_destroy(in_dev);
1107                 break;
1108         case NETDEV_CHANGENAME:
1109                 /* Do not notify about label change, this event is
1110                  * not interesting to applications using netlink.
1111                  */
1112                 inetdev_changename(dev, in_dev);
1113
1114 #ifdef CONFIG_SYSCTL
1115                 devinet_sysctl_unregister(&in_dev->cnf);
1116                 neigh_sysctl_unregister(in_dev->arp_parms);
1117                 neigh_sysctl_register(dev, in_dev->arp_parms, NET_IPV4,
1118                                       NET_IPV4_NEIGH, "ipv4", NULL, NULL);
1119                 devinet_sysctl_register(in_dev, &in_dev->cnf);
1120 #endif
1121                 break;
1122         }
1123 out:
1124         return NOTIFY_DONE;
1125 }
1126
1127 static struct notifier_block ip_netdev_notifier = {
1128         .notifier_call =inetdev_event,
1129 };
1130
1131 static inline size_t inet_nlmsg_size(void)
1132 {
1133         return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
1134                + nla_total_size(4) /* IFA_ADDRESS */
1135                + nla_total_size(4) /* IFA_LOCAL */
1136                + nla_total_size(4) /* IFA_BROADCAST */
1137                + nla_total_size(4) /* IFA_ANYCAST */
1138                + nla_total_size(IFNAMSIZ); /* IFA_LABEL */
1139 }
1140
1141 static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
1142                             u32 pid, u32 seq, int event, unsigned int flags)
1143 {
1144         struct ifaddrmsg *ifm;
1145         struct nlmsghdr  *nlh;
1146
1147         nlh = nlmsg_put(skb, pid, seq, event, sizeof(*ifm), flags);
1148         if (nlh == NULL)
1149                 return -EMSGSIZE;
1150
1151         ifm = nlmsg_data(nlh);
1152         ifm->ifa_family = AF_INET;
1153         ifm->ifa_prefixlen = ifa->ifa_prefixlen;
1154         ifm->ifa_flags = ifa->ifa_flags|IFA_F_PERMANENT;
1155         ifm->ifa_scope = ifa->ifa_scope;
1156         ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
1157
1158         if (ifa->ifa_address)
1159                 NLA_PUT_BE32(skb, IFA_ADDRESS, ifa->ifa_address);
1160
1161         if (ifa->ifa_local)
1162                 NLA_PUT_BE32(skb, IFA_LOCAL, ifa->ifa_local);
1163
1164         if (ifa->ifa_broadcast)
1165                 NLA_PUT_BE32(skb, IFA_BROADCAST, ifa->ifa_broadcast);
1166
1167         if (ifa->ifa_anycast)
1168                 NLA_PUT_BE32(skb, IFA_ANYCAST, ifa->ifa_anycast);
1169
1170         if (ifa->ifa_label[0])
1171                 NLA_PUT_STRING(skb, IFA_LABEL, ifa->ifa_label);
1172
1173         return nlmsg_end(skb, nlh);
1174
1175 nla_put_failure:
1176         nlmsg_cancel(skb, nlh);
1177         return -EMSGSIZE;
1178 }
1179
1180 static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
1181 {
1182         int idx, ip_idx;
1183         struct net_device *dev;
1184         struct in_device *in_dev;
1185         struct in_ifaddr *ifa;
1186         int s_ip_idx, s_idx = cb->args[0];
1187
1188         s_ip_idx = ip_idx = cb->args[1];
1189         idx = 0;
1190         for_each_netdev(dev) {
1191                 if (idx < s_idx)
1192                         goto cont;
1193                 if (idx > s_idx)
1194                         s_ip_idx = 0;
1195                 if ((in_dev = __in_dev_get_rtnl(dev)) == NULL)
1196                         goto cont;
1197
1198                 for (ifa = in_dev->ifa_list, ip_idx = 0; ifa;
1199                      ifa = ifa->ifa_next, ip_idx++) {
1200                         if (ip_idx < s_ip_idx)
1201                                 goto cont;
1202                         if (inet_fill_ifaddr(skb, ifa, NETLINK_CB(cb->skb).pid,
1203                                              cb->nlh->nlmsg_seq,
1204                                              RTM_NEWADDR, NLM_F_MULTI) <= 0)
1205                                 goto done;
1206                 }
1207 cont:
1208                 idx++;
1209         }
1210
1211 done:
1212         cb->args[0] = idx;
1213         cb->args[1] = ip_idx;
1214
1215         return skb->len;
1216 }
1217
1218 static void rtmsg_ifa(int event, struct in_ifaddr* ifa, struct nlmsghdr *nlh,
1219                       u32 pid)
1220 {
1221         struct sk_buff *skb;
1222         u32 seq = nlh ? nlh->nlmsg_seq : 0;
1223         int err = -ENOBUFS;
1224
1225         skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL);
1226         if (skb == NULL)
1227                 goto errout;
1228
1229         err = inet_fill_ifaddr(skb, ifa, pid, seq, event, 0);
1230         if (err < 0) {
1231                 /* -EMSGSIZE implies BUG in inet_nlmsg_size() */
1232                 WARN_ON(err == -EMSGSIZE);
1233                 kfree_skb(skb);
1234                 goto errout;
1235         }
1236         err = rtnl_notify(skb, pid, RTNLGRP_IPV4_IFADDR, nlh, GFP_KERNEL);
1237 errout:
1238         if (err < 0)
1239                 rtnl_set_sk_err(RTNLGRP_IPV4_IFADDR, err);
1240 }
1241
1242 #ifdef CONFIG_SYSCTL
1243
1244 static void devinet_copy_dflt_conf(int i)
1245 {
1246         struct net_device *dev;
1247
1248         read_lock(&dev_base_lock);
1249         for_each_netdev(dev) {
1250                 struct in_device *in_dev;
1251                 rcu_read_lock();
1252                 in_dev = __in_dev_get_rcu(dev);
1253                 if (in_dev && !test_bit(i, in_dev->cnf.state))
1254                         in_dev->cnf.data[i] = ipv4_devconf_dflt.data[i];
1255                 rcu_read_unlock();
1256         }
1257         read_unlock(&dev_base_lock);
1258 }
1259
1260 static int devinet_conf_proc(ctl_table *ctl, int write,
1261                              struct file* filp, void __user *buffer,
1262                              size_t *lenp, loff_t *ppos)
1263 {
1264         int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1265
1266         if (write) {
1267                 struct ipv4_devconf *cnf = ctl->extra1;
1268                 int i = (int *)ctl->data - cnf->data;
1269
1270                 set_bit(i, cnf->state);
1271
1272                 if (cnf == &ipv4_devconf_dflt)
1273                         devinet_copy_dflt_conf(i);
1274         }
1275
1276         return ret;
1277 }
1278
1279 static int devinet_conf_sysctl(ctl_table *table, int __user *name, int nlen,
1280                                void __user *oldval, size_t __user *oldlenp,
1281                                void __user *newval, size_t newlen)
1282 {
1283         struct ipv4_devconf *cnf;
1284         int *valp = table->data;
1285         int new;
1286         int i;
1287
1288         if (!newval || !newlen)
1289                 return 0;
1290
1291         if (newlen != sizeof(int))
1292                 return -EINVAL;
1293
1294         if (get_user(new, (int __user *)newval))
1295                 return -EFAULT;
1296
1297         if (new == *valp)
1298                 return 0;
1299
1300         if (oldval && oldlenp) {
1301                 size_t len;
1302
1303                 if (get_user(len, oldlenp))
1304                         return -EFAULT;
1305
1306                 if (len) {
1307                         if (len > table->maxlen)
1308                                 len = table->maxlen;
1309                         if (copy_to_user(oldval, valp, len))
1310                                 return -EFAULT;
1311                         if (put_user(len, oldlenp))
1312                                 return -EFAULT;
1313                 }
1314         }
1315
1316         *valp = new;
1317
1318         cnf = table->extra1;
1319         i = (int *)table->data - cnf->data;
1320
1321         set_bit(i, cnf->state);
1322
1323         if (cnf == &ipv4_devconf_dflt)
1324                 devinet_copy_dflt_conf(i);
1325
1326         return 1;
1327 }
1328
1329 void inet_forward_change(void)
1330 {
1331         struct net_device *dev;
1332         int on = IPV4_DEVCONF_ALL(FORWARDING);
1333
1334         IPV4_DEVCONF_ALL(ACCEPT_REDIRECTS) = !on;
1335         IPV4_DEVCONF_DFLT(FORWARDING) = on;
1336
1337         read_lock(&dev_base_lock);
1338         for_each_netdev(dev) {
1339                 struct in_device *in_dev;
1340                 rcu_read_lock();
1341                 in_dev = __in_dev_get_rcu(dev);
1342                 if (in_dev)
1343                         IN_DEV_CONF_SET(in_dev, FORWARDING, on);
1344                 rcu_read_unlock();
1345         }
1346         read_unlock(&dev_base_lock);
1347
1348         rt_cache_flush(0);
1349 }
1350
1351 static int devinet_sysctl_forward(ctl_table *ctl, int write,
1352                                   struct file* filp, void __user *buffer,
1353                                   size_t *lenp, loff_t *ppos)
1354 {
1355         int *valp = ctl->data;
1356         int val = *valp;
1357         int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1358
1359         if (write && *valp != val) {
1360                 if (valp == &IPV4_DEVCONF_ALL(FORWARDING))
1361                         inet_forward_change();
1362                 else if (valp != &IPV4_DEVCONF_DFLT(FORWARDING))
1363                         rt_cache_flush(0);
1364         }
1365
1366         return ret;
1367 }
1368
1369 int ipv4_doint_and_flush(ctl_table *ctl, int write,
1370                          struct file* filp, void __user *buffer,
1371                          size_t *lenp, loff_t *ppos)
1372 {
1373         int *valp = ctl->data;
1374         int val = *valp;
1375         int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1376
1377         if (write && *valp != val)
1378                 rt_cache_flush(0);
1379
1380         return ret;
1381 }
1382
1383 int ipv4_doint_and_flush_strategy(ctl_table *table, int __user *name, int nlen,
1384                                   void __user *oldval, size_t __user *oldlenp,
1385                                   void __user *newval, size_t newlen)
1386 {
1387         int ret = devinet_conf_sysctl(table, name, nlen, oldval, oldlenp,
1388                                       newval, newlen);
1389
1390         if (ret == 1)
1391                 rt_cache_flush(0);
1392
1393         return ret;
1394 }
1395
1396
1397 #define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc, sysctl) \
1398         { \
1399                 .ctl_name       = NET_IPV4_CONF_ ## attr, \
1400                 .procname       = name, \
1401                 .data           = ipv4_devconf.data + \
1402                                   NET_IPV4_CONF_ ## attr - 1, \
1403                 .maxlen         = sizeof(int), \
1404                 .mode           = mval, \
1405                 .proc_handler   = proc, \
1406                 .strategy       = sysctl, \
1407                 .extra1         = &ipv4_devconf, \
1408         }
1409
1410 #define DEVINET_SYSCTL_RW_ENTRY(attr, name) \
1411         DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc, \
1412                              devinet_conf_sysctl)
1413
1414 #define DEVINET_SYSCTL_RO_ENTRY(attr, name) \
1415         DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc, \
1416                              devinet_conf_sysctl)
1417
1418 #define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc, sysctl) \
1419         DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc, sysctl)
1420
1421 #define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \
1422         DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush, \
1423                                      ipv4_doint_and_flush_strategy)
1424
1425 static struct devinet_sysctl_table {
1426         struct ctl_table_header *sysctl_header;
1427         ctl_table               devinet_vars[__NET_IPV4_CONF_MAX];
1428         ctl_table               devinet_dev[2];
1429         ctl_table               devinet_conf_dir[2];
1430         ctl_table               devinet_proto_dir[2];
1431         ctl_table               devinet_root_dir[2];
1432 } devinet_sysctl = {
1433         .devinet_vars = {
1434                 DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING, "forwarding",
1435                                              devinet_sysctl_forward,
1436                                              devinet_conf_sysctl),
1437                 DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING, "mc_forwarding"),
1438
1439                 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS, "accept_redirects"),
1440                 DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS, "secure_redirects"),
1441                 DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA, "shared_media"),
1442                 DEVINET_SYSCTL_RW_ENTRY(RP_FILTER, "rp_filter"),
1443                 DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS, "send_redirects"),
1444                 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE,
1445                                         "accept_source_route"),
1446                 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP, "proxy_arp"),
1447                 DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID, "medium_id"),
1448                 DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY, "bootp_relay"),
1449                 DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS, "log_martians"),
1450                 DEVINET_SYSCTL_RW_ENTRY(TAG, "tag"),
1451                 DEVINET_SYSCTL_RW_ENTRY(ARPFILTER, "arp_filter"),
1452                 DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE, "arp_announce"),
1453                 DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE, "arp_ignore"),
1454                 DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT, "arp_accept"),
1455
1456                 DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM, "disable_xfrm"),
1457                 DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY, "disable_policy"),
1458                 DEVINET_SYSCTL_FLUSHING_ENTRY(FORCE_IGMP_VERSION,
1459                                               "force_igmp_version"),
1460                 DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES,
1461                                               "promote_secondaries"),
1462         },
1463         .devinet_dev = {
1464                 {
1465                         .ctl_name       = NET_PROTO_CONF_ALL,
1466                         .procname       = "all",
1467                         .mode           = 0555,
1468                         .child          = devinet_sysctl.devinet_vars,
1469                 },
1470         },
1471         .devinet_conf_dir = {
1472                 {
1473                         .ctl_name       = NET_IPV4_CONF,
1474                         .procname       = "conf",
1475                         .mode           = 0555,
1476                         .child          = devinet_sysctl.devinet_dev,
1477                 },
1478         },
1479         .devinet_proto_dir = {
1480                 {
1481                         .ctl_name       = NET_IPV4,
1482                         .procname       = "ipv4",
1483                         .mode           = 0555,
1484                         .child          = devinet_sysctl.devinet_conf_dir,
1485                 },
1486         },
1487         .devinet_root_dir = {
1488                 {
1489                         .ctl_name       = CTL_NET,
1490                         .procname       = "net",
1491                         .mode           = 0555,
1492                         .child          = devinet_sysctl.devinet_proto_dir,
1493                 },
1494         },
1495 };
1496
1497 static void devinet_sysctl_register(struct in_device *in_dev,
1498                                     struct ipv4_devconf *p)
1499 {
1500         int i;
1501         struct net_device *dev = in_dev ? in_dev->dev : NULL;
1502         struct devinet_sysctl_table *t = kmemdup(&devinet_sysctl, sizeof(*t),
1503                                                  GFP_KERNEL);
1504         char *dev_name = NULL;
1505
1506         if (!t)
1507                 return;
1508         for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
1509                 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
1510                 t->devinet_vars[i].extra1 = p;
1511         }
1512
1513         if (dev) {
1514                 dev_name = dev->name;
1515                 t->devinet_dev[0].ctl_name = dev->ifindex;
1516         } else {
1517                 dev_name = "default";
1518                 t->devinet_dev[0].ctl_name = NET_PROTO_CONF_DEFAULT;
1519         }
1520
1521         /*
1522          * Make a copy of dev_name, because '.procname' is regarded as const
1523          * by sysctl and we wouldn't want anyone to change it under our feet
1524          * (see SIOCSIFNAME).
1525          */
1526         dev_name = kstrdup(dev_name, GFP_KERNEL);
1527         if (!dev_name)
1528             goto free;
1529
1530         t->devinet_dev[0].procname    = dev_name;
1531         t->devinet_dev[0].child       = t->devinet_vars;
1532         t->devinet_conf_dir[0].child  = t->devinet_dev;
1533         t->devinet_proto_dir[0].child = t->devinet_conf_dir;
1534         t->devinet_root_dir[0].child  = t->devinet_proto_dir;
1535
1536         t->sysctl_header = register_sysctl_table(t->devinet_root_dir);
1537         if (!t->sysctl_header)
1538             goto free_procname;
1539
1540         p->sysctl = t;
1541         return;
1542
1543         /* error path */
1544  free_procname:
1545         kfree(dev_name);
1546  free:
1547         kfree(t);
1548         return;
1549 }
1550
1551 static void devinet_sysctl_unregister(struct ipv4_devconf *p)
1552 {
1553         if (p->sysctl) {
1554                 struct devinet_sysctl_table *t = p->sysctl;
1555                 p->sysctl = NULL;
1556                 unregister_sysctl_table(t->sysctl_header);
1557                 kfree(t->devinet_dev[0].procname);
1558                 kfree(t);
1559         }
1560 }
1561 #endif
1562
1563 void __init devinet_init(void)
1564 {
1565         register_gifconf(PF_INET, inet_gifconf);
1566         register_netdevice_notifier(&ip_netdev_notifier);
1567
1568         rtnl_register(PF_INET, RTM_NEWADDR, inet_rtm_newaddr, NULL);
1569         rtnl_register(PF_INET, RTM_DELADDR, inet_rtm_deladdr, NULL);
1570         rtnl_register(PF_INET, RTM_GETADDR, NULL, inet_dump_ifaddr);
1571 #ifdef CONFIG_SYSCTL
1572         devinet_sysctl.sysctl_header =
1573                 register_sysctl_table(devinet_sysctl.devinet_root_dir);
1574         devinet_sysctl_register(NULL, &ipv4_devconf_dflt);
1575 #endif
1576 }
1577
1578 EXPORT_SYMBOL(in_dev_finish_destroy);
1579 EXPORT_SYMBOL(inet_select_addr);
1580 EXPORT_SYMBOL(inetdev_by_index);
1581 EXPORT_SYMBOL(register_inetaddr_notifier);
1582 EXPORT_SYMBOL(unregister_inetaddr_notifier);