SAFE public projects git trees. - safe/jmp/linux-2.6/blob - net/ipv4/devinet.c

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