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                 if (IN_DEV_ARP_NOTIFY(in_dev))
1081                         arp_send(ARPOP_REQUEST, ETH_P_ARP,
1082                                  in_dev->ifa_list->ifa_address,
1083                                  dev,
1084                                  in_dev->ifa_list->ifa_address,
1085                                  NULL, dev->dev_addr, NULL);
1086                 break;
1087         case NETDEV_DOWN:
1088                 ip_mc_down(in_dev);
1089                 break;
1090         case NETDEV_BONDING_OLDTYPE:
1091                 ip_mc_unmap(in_dev);
1092                 break;
1093         case NETDEV_BONDING_NEWTYPE:
1094                 ip_mc_remap(in_dev);
1095                 break;
1096         case NETDEV_CHANGEMTU:
1097                 if (inetdev_valid_mtu(dev->mtu))
1098                         break;
1099                 /* disable IP when MTU is not enough */
1100         case NETDEV_UNREGISTER:
1101                 inetdev_destroy(in_dev);
1102                 break;
1103         case NETDEV_CHANGENAME:
1104                 /* Do not notify about label change, this event is
1105                  * not interesting to applications using netlink.
1106                  */
1107                 inetdev_changename(dev, in_dev);
1108
1109                 devinet_sysctl_unregister(in_dev);
1110                 devinet_sysctl_register(in_dev);
1111                 break;
1112         }
1113 out:
1114         return NOTIFY_DONE;
1115 }
1116
1117 static struct notifier_block ip_netdev_notifier = {
1118         .notifier_call = inetdev_event,
1119 };
1120
1121 static inline size_t inet_nlmsg_size(void)
1122 {
1123         return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
1124                + nla_total_size(4) /* IFA_ADDRESS */
1125                + nla_total_size(4) /* IFA_LOCAL */
1126                + nla_total_size(4) /* IFA_BROADCAST */
1127                + nla_total_size(IFNAMSIZ); /* IFA_LABEL */
1128 }
1129
1130 static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
1131                             u32 pid, u32 seq, int event, unsigned int flags)
1132 {
1133         struct ifaddrmsg *ifm;
1134         struct nlmsghdr  *nlh;
1135
1136         nlh = nlmsg_put(skb, pid, seq, event, sizeof(*ifm), flags);
1137         if (nlh == NULL)
1138                 return -EMSGSIZE;
1139
1140         ifm = nlmsg_data(nlh);
1141         ifm->ifa_family = AF_INET;
1142         ifm->ifa_prefixlen = ifa->ifa_prefixlen;
1143         ifm->ifa_flags = ifa->ifa_flags|IFA_F_PERMANENT;
1144         ifm->ifa_scope = ifa->ifa_scope;
1145         ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
1146
1147         if (ifa->ifa_address)
1148                 NLA_PUT_BE32(skb, IFA_ADDRESS, ifa->ifa_address);
1149
1150         if (ifa->ifa_local)
1151                 NLA_PUT_BE32(skb, IFA_LOCAL, ifa->ifa_local);
1152
1153         if (ifa->ifa_broadcast)
1154                 NLA_PUT_BE32(skb, IFA_BROADCAST, ifa->ifa_broadcast);
1155
1156         if (ifa->ifa_label[0])
1157                 NLA_PUT_STRING(skb, IFA_LABEL, ifa->ifa_label);
1158
1159         return nlmsg_end(skb, nlh);
1160
1161 nla_put_failure:
1162         nlmsg_cancel(skb, nlh);
1163         return -EMSGSIZE;
1164 }
1165
1166 static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
1167 {
1168         struct net *net = sock_net(skb->sk);
1169         int idx, ip_idx;
1170         struct net_device *dev;
1171         struct in_device *in_dev;
1172         struct in_ifaddr *ifa;
1173         int s_ip_idx, s_idx = cb->args[0];
1174
1175         s_ip_idx = ip_idx = cb->args[1];
1176         idx = 0;
1177         for_each_netdev(net, dev) {
1178                 if (idx < s_idx)
1179                         goto cont;
1180                 if (idx > s_idx)
1181                         s_ip_idx = 0;
1182                 if ((in_dev = __in_dev_get_rtnl(dev)) == NULL)
1183                         goto cont;
1184
1185                 for (ifa = in_dev->ifa_list, ip_idx = 0; ifa;
1186                      ifa = ifa->ifa_next, ip_idx++) {
1187                         if (ip_idx < s_ip_idx)
1188                                 continue;
1189                         if (inet_fill_ifaddr(skb, ifa, NETLINK_CB(cb->skb).pid,
1190                                              cb->nlh->nlmsg_seq,
1191                                              RTM_NEWADDR, NLM_F_MULTI) <= 0)
1192                                 goto done;
1193                 }
1194 cont:
1195                 idx++;
1196         }
1197
1198 done:
1199         cb->args[0] = idx;
1200         cb->args[1] = ip_idx;
1201
1202         return skb->len;
1203 }
1204
1205 static void rtmsg_ifa(int event, struct in_ifaddr *ifa, struct nlmsghdr *nlh,
1206                       u32 pid)
1207 {
1208         struct sk_buff *skb;
1209         u32 seq = nlh ? nlh->nlmsg_seq : 0;
1210         int err = -ENOBUFS;
1211         struct net *net;
1212
1213         net = dev_net(ifa->ifa_dev->dev);
1214         skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL);
1215         if (skb == NULL)
1216                 goto errout;
1217
1218         err = inet_fill_ifaddr(skb, ifa, pid, seq, event, 0);
1219         if (err < 0) {
1220                 /* -EMSGSIZE implies BUG in inet_nlmsg_size() */
1221                 WARN_ON(err == -EMSGSIZE);
1222                 kfree_skb(skb);
1223                 goto errout;
1224         }
1225         rtnl_notify(skb, net, pid, RTNLGRP_IPV4_IFADDR, nlh, GFP_KERNEL);
1226         return;
1227 errout:
1228         if (err < 0)
1229                 rtnl_set_sk_err(net, RTNLGRP_IPV4_IFADDR, err);
1230 }
1231
1232 #ifdef CONFIG_SYSCTL
1233
1234 static void devinet_copy_dflt_conf(struct net *net, int i)
1235 {
1236         struct net_device *dev;
1237
1238         read_lock(&dev_base_lock);
1239         for_each_netdev(net, dev) {
1240                 struct in_device *in_dev;
1241                 rcu_read_lock();
1242                 in_dev = __in_dev_get_rcu(dev);
1243                 if (in_dev && !test_bit(i, in_dev->cnf.state))
1244                         in_dev->cnf.data[i] = net->ipv4.devconf_dflt->data[i];
1245                 rcu_read_unlock();
1246         }
1247         read_unlock(&dev_base_lock);
1248 }
1249
1250 static void inet_forward_change(struct net *net)
1251 {
1252         struct net_device *dev;
1253         int on = IPV4_DEVCONF_ALL(net, FORWARDING);
1254
1255         IPV4_DEVCONF_ALL(net, ACCEPT_REDIRECTS) = !on;
1256         IPV4_DEVCONF_DFLT(net, FORWARDING) = on;
1257
1258         read_lock(&dev_base_lock);
1259         for_each_netdev(net, dev) {
1260                 struct in_device *in_dev;
1261                 if (on)
1262                         dev_disable_lro(dev);
1263                 rcu_read_lock();
1264                 in_dev = __in_dev_get_rcu(dev);
1265                 if (in_dev)
1266                         IN_DEV_CONF_SET(in_dev, FORWARDING, on);
1267                 rcu_read_unlock();
1268         }
1269         read_unlock(&dev_base_lock);
1270 }
1271
1272 static int devinet_conf_proc(ctl_table *ctl, int write,
1273                              void __user *buffer,
1274                              size_t *lenp, loff_t *ppos)
1275 {
1276         int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
1277
1278         if (write) {
1279                 struct ipv4_devconf *cnf = ctl->extra1;
1280                 struct net *net = ctl->extra2;
1281                 int i = (int *)ctl->data - cnf->data;
1282
1283                 set_bit(i, cnf->state);
1284
1285                 if (cnf == net->ipv4.devconf_dflt)
1286                         devinet_copy_dflt_conf(net, i);
1287         }
1288
1289         return ret;
1290 }
1291
1292 static int devinet_conf_sysctl(ctl_table *table,
1293                                void __user *oldval, size_t __user *oldlenp,
1294                                void __user *newval, size_t newlen)
1295 {
1296         struct ipv4_devconf *cnf;
1297         struct net *net;
1298         int *valp = table->data;
1299         int new;
1300         int i;
1301
1302         if (!newval || !newlen)
1303                 return 0;
1304
1305         if (newlen != sizeof(int))
1306                 return -EINVAL;
1307
1308         if (get_user(new, (int __user *)newval))
1309                 return -EFAULT;
1310
1311         if (new == *valp)
1312                 return 0;
1313
1314         if (oldval && oldlenp) {
1315                 size_t len;
1316
1317                 if (get_user(len, oldlenp))
1318                         return -EFAULT;
1319
1320                 if (len) {
1321                         if (len > table->maxlen)
1322                                 len = table->maxlen;
1323                         if (copy_to_user(oldval, valp, len))
1324                                 return -EFAULT;
1325                         if (put_user(len, oldlenp))
1326                                 return -EFAULT;
1327                 }
1328         }
1329
1330         *valp = new;
1331
1332         cnf = table->extra1;
1333         net = table->extra2;
1334         i = (int *)table->data - cnf->data;
1335
1336         set_bit(i, cnf->state);
1337
1338         if (cnf == net->ipv4.devconf_dflt)
1339                 devinet_copy_dflt_conf(net, i);
1340
1341         return 1;
1342 }
1343
1344 static int devinet_sysctl_forward(ctl_table *ctl, int write,
1345                                   void __user *buffer,
1346                                   size_t *lenp, loff_t *ppos)
1347 {
1348         int *valp = ctl->data;
1349         int val = *valp;
1350         int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
1351
1352         if (write && *valp != val) {
1353                 struct net *net = ctl->extra2;
1354
1355                 if (valp != &IPV4_DEVCONF_DFLT(net, FORWARDING)) {
1356                         if (!rtnl_trylock())
1357                                 return restart_syscall();
1358                         if (valp == &IPV4_DEVCONF_ALL(net, FORWARDING)) {
1359                                 inet_forward_change(net);
1360                         } else if (*valp) {
1361                                 struct ipv4_devconf *cnf = ctl->extra1;
1362                                 struct in_device *idev =
1363                                         container_of(cnf, struct in_device, cnf);
1364                                 dev_disable_lro(idev->dev);
1365                         }
1366                         rtnl_unlock();
1367                         rt_cache_flush(net, 0);
1368                 }
1369         }
1370
1371         return ret;
1372 }
1373
1374 int ipv4_doint_and_flush(ctl_table *ctl, int write,
1375                          void __user *buffer,
1376                          size_t *lenp, loff_t *ppos)
1377 {
1378         int *valp = ctl->data;
1379         int val = *valp;
1380         int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
1381         struct net *net = ctl->extra2;
1382
1383         if (write && *valp != val)
1384                 rt_cache_flush(net, 0);
1385
1386         return ret;
1387 }
1388
1389 int ipv4_doint_and_flush_strategy(ctl_table *table,
1390                                   void __user *oldval, size_t __user *oldlenp,
1391                                   void __user *newval, size_t newlen)
1392 {
1393         int ret = devinet_conf_sysctl(table, oldval, oldlenp, newval, newlen);
1394         struct net *net = table->extra2;
1395
1396         if (ret == 1)
1397                 rt_cache_flush(net, 0);
1398
1399         return ret;
1400 }
1401
1402
1403 #define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc, sysctl) \
1404         { \
1405                 .ctl_name       = NET_IPV4_CONF_ ## attr, \
1406                 .procname       = name, \
1407                 .data           = ipv4_devconf.data + \
1408                                   NET_IPV4_CONF_ ## attr - 1, \
1409                 .maxlen         = sizeof(int), \
1410                 .mode           = mval, \
1411                 .proc_handler   = proc, \
1412                 .strategy       = sysctl, \
1413                 .extra1         = &ipv4_devconf, \
1414         }
1415
1416 #define DEVINET_SYSCTL_RW_ENTRY(attr, name) \
1417         DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc, \
1418                              devinet_conf_sysctl)
1419
1420 #define DEVINET_SYSCTL_RO_ENTRY(attr, name) \
1421         DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc, \
1422                              devinet_conf_sysctl)
1423
1424 #define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc, sysctl) \
1425         DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc, sysctl)
1426
1427 #define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \
1428         DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush, \
1429                                      ipv4_doint_and_flush_strategy)
1430
1431 static struct devinet_sysctl_table {
1432         struct ctl_table_header *sysctl_header;
1433         struct ctl_table devinet_vars[__NET_IPV4_CONF_MAX];
1434         char *dev_name;
1435 } devinet_sysctl = {
1436         .devinet_vars = {
1437                 DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING, "forwarding",
1438                                              devinet_sysctl_forward,
1439                                              devinet_conf_sysctl),
1440                 DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING, "mc_forwarding"),
1441
1442                 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS, "accept_redirects"),
1443                 DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS, "secure_redirects"),
1444                 DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA, "shared_media"),
1445                 DEVINET_SYSCTL_RW_ENTRY(RP_FILTER, "rp_filter"),
1446                 DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS, "send_redirects"),
1447                 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE,
1448                                         "accept_source_route"),
1449                 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP, "proxy_arp"),
1450                 DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID, "medium_id"),
1451                 DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY, "bootp_relay"),
1452                 DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS, "log_martians"),
1453                 DEVINET_SYSCTL_RW_ENTRY(TAG, "tag"),
1454                 DEVINET_SYSCTL_RW_ENTRY(ARPFILTER, "arp_filter"),
1455                 DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE, "arp_announce"),
1456                 DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE, "arp_ignore"),
1457                 DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT, "arp_accept"),
1458                 DEVINET_SYSCTL_RW_ENTRY(ARP_NOTIFY, "arp_notify"),
1459
1460                 DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM, "disable_xfrm"),
1461                 DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY, "disable_policy"),
1462                 DEVINET_SYSCTL_FLUSHING_ENTRY(FORCE_IGMP_VERSION,
1463                                               "force_igmp_version"),
1464                 DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES,
1465                                               "promote_secondaries"),
1466         },
1467 };
1468
1469 static int __devinet_sysctl_register(struct net *net, char *dev_name,
1470                 int ctl_name, struct ipv4_devconf *p)
1471 {
1472         int i;
1473         struct devinet_sysctl_table *t;
1474
1475 #define DEVINET_CTL_PATH_DEV    3
1476
1477         struct ctl_path devinet_ctl_path[] = {
1478                 { .procname = "net", .ctl_name = CTL_NET, },
1479                 { .procname = "ipv4", .ctl_name = NET_IPV4, },
1480                 { .procname = "conf", .ctl_name = NET_IPV4_CONF, },
1481                 { /* to be set */ },
1482                 { },
1483         };
1484
1485         t = kmemdup(&devinet_sysctl, sizeof(*t), GFP_KERNEL);
1486         if (!t)
1487                 goto out;
1488
1489         for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
1490                 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
1491                 t->devinet_vars[i].extra1 = p;
1492                 t->devinet_vars[i].extra2 = net;
1493         }
1494
1495         /*
1496          * Make a copy of dev_name, because '.procname' is regarded as const
1497          * by sysctl and we wouldn't want anyone to change it under our feet
1498          * (see SIOCSIFNAME).
1499          */
1500         t->dev_name = kstrdup(dev_name, GFP_KERNEL);
1501         if (!t->dev_name)
1502                 goto free;
1503
1504         devinet_ctl_path[DEVINET_CTL_PATH_DEV].procname = t->dev_name;
1505         devinet_ctl_path[DEVINET_CTL_PATH_DEV].ctl_name = ctl_name;
1506
1507         t->sysctl_header = register_net_sysctl_table(net, devinet_ctl_path,
1508                         t->devinet_vars);
1509         if (!t->sysctl_header)
1510                 goto free_procname;
1511
1512         p->sysctl = t;
1513         return 0;
1514
1515 free_procname:
1516         kfree(t->dev_name);
1517 free:
1518         kfree(t);
1519 out:
1520         return -ENOBUFS;
1521 }
1522
1523 static void __devinet_sysctl_unregister(struct ipv4_devconf *cnf)
1524 {
1525         struct devinet_sysctl_table *t = cnf->sysctl;
1526
1527         if (t == NULL)
1528                 return;
1529
1530         cnf->sysctl = NULL;
1531         unregister_sysctl_table(t->sysctl_header);
1532         kfree(t->dev_name);
1533         kfree(t);
1534 }
1535
1536 static void devinet_sysctl_register(struct in_device *idev)
1537 {
1538         neigh_sysctl_register(idev->dev, idev->arp_parms, NET_IPV4,
1539                         NET_IPV4_NEIGH, "ipv4", NULL, NULL);
1540         __devinet_sysctl_register(dev_net(idev->dev), idev->dev->name,
1541                         idev->dev->ifindex, &idev->cnf);
1542 }
1543
1544 static void devinet_sysctl_unregister(struct in_device *idev)
1545 {
1546         __devinet_sysctl_unregister(&idev->cnf);
1547         neigh_sysctl_unregister(idev->arp_parms);
1548 }
1549
1550 static struct ctl_table ctl_forward_entry[] = {
1551         {
1552                 .ctl_name       = NET_IPV4_FORWARD,
1553                 .procname       = "ip_forward",
1554                 .data           = &ipv4_devconf.data[
1555                                         NET_IPV4_CONF_FORWARDING - 1],
1556                 .maxlen         = sizeof(int),
1557                 .mode           = 0644,
1558                 .proc_handler   = devinet_sysctl_forward,
1559                 .strategy       = devinet_conf_sysctl,
1560                 .extra1         = &ipv4_devconf,
1561                 .extra2         = &init_net,
1562         },
1563         { },
1564 };
1565
1566 static __net_initdata struct ctl_path net_ipv4_path[] = {
1567         { .procname = "net", .ctl_name = CTL_NET, },
1568         { .procname = "ipv4", .ctl_name = NET_IPV4, },
1569         { },
1570 };
1571 #endif
1572
1573 static __net_init int devinet_init_net(struct net *net)
1574 {
1575         int err;
1576         struct ipv4_devconf *all, *dflt;
1577 #ifdef CONFIG_SYSCTL
1578         struct ctl_table *tbl = ctl_forward_entry;
1579         struct ctl_table_header *forw_hdr;
1580 #endif
1581
1582         err = -ENOMEM;
1583         all = &ipv4_devconf;
1584         dflt = &ipv4_devconf_dflt;
1585
1586         if (net != &init_net) {
1587                 all = kmemdup(all, sizeof(ipv4_devconf), GFP_KERNEL);
1588                 if (all == NULL)
1589                         goto err_alloc_all;
1590
1591                 dflt = kmemdup(dflt, sizeof(ipv4_devconf_dflt), GFP_KERNEL);
1592                 if (dflt == NULL)
1593                         goto err_alloc_dflt;
1594
1595 #ifdef CONFIG_SYSCTL
1596                 tbl = kmemdup(tbl, sizeof(ctl_forward_entry), GFP_KERNEL);
1597                 if (tbl == NULL)
1598                         goto err_alloc_ctl;
1599
1600                 tbl[0].data = &all->data[NET_IPV4_CONF_FORWARDING - 1];
1601                 tbl[0].extra1 = all;
1602                 tbl[0].extra2 = net;
1603 #endif
1604         }
1605
1606 #ifdef CONFIG_SYSCTL
1607         err = __devinet_sysctl_register(net, "all",
1608                         NET_PROTO_CONF_ALL, all);
1609         if (err < 0)
1610                 goto err_reg_all;
1611
1612         err = __devinet_sysctl_register(net, "default",
1613                         NET_PROTO_CONF_DEFAULT, dflt);
1614         if (err < 0)
1615                 goto err_reg_dflt;
1616
1617         err = -ENOMEM;
1618         forw_hdr = register_net_sysctl_table(net, net_ipv4_path, tbl);
1619         if (forw_hdr == NULL)
1620                 goto err_reg_ctl;
1621         net->ipv4.forw_hdr = forw_hdr;
1622 #endif
1623
1624         net->ipv4.devconf_all = all;
1625         net->ipv4.devconf_dflt = dflt;
1626         return 0;
1627
1628 #ifdef CONFIG_SYSCTL
1629 err_reg_ctl:
1630         __devinet_sysctl_unregister(dflt);
1631 err_reg_dflt:
1632         __devinet_sysctl_unregister(all);
1633 err_reg_all:
1634         if (tbl != ctl_forward_entry)
1635                 kfree(tbl);
1636 err_alloc_ctl:
1637 #endif
1638         if (dflt != &ipv4_devconf_dflt)
1639                 kfree(dflt);
1640 err_alloc_dflt:
1641         if (all != &ipv4_devconf)
1642                 kfree(all);
1643 err_alloc_all:
1644         return err;
1645 }
1646
1647 static __net_exit void devinet_exit_net(struct net *net)
1648 {
1649 #ifdef CONFIG_SYSCTL
1650         struct ctl_table *tbl;
1651
1652         tbl = net->ipv4.forw_hdr->ctl_table_arg;
1653         unregister_net_sysctl_table(net->ipv4.forw_hdr);
1654         __devinet_sysctl_unregister(net->ipv4.devconf_dflt);
1655         __devinet_sysctl_unregister(net->ipv4.devconf_all);
1656         kfree(tbl);
1657 #endif
1658         kfree(net->ipv4.devconf_dflt);
1659         kfree(net->ipv4.devconf_all);
1660 }
1661
1662 static __net_initdata struct pernet_operations devinet_ops = {
1663         .init = devinet_init_net,
1664         .exit = devinet_exit_net,
1665 };
1666
1667 void __init devinet_init(void)
1668 {
1669         register_pernet_subsys(&devinet_ops);
1670
1671         register_gifconf(PF_INET, inet_gifconf);
1672         register_netdevice_notifier(&ip_netdev_notifier);
1673
1674         rtnl_register(PF_INET, RTM_NEWADDR, inet_rtm_newaddr, NULL);
1675         rtnl_register(PF_INET, RTM_DELADDR, inet_rtm_deladdr, NULL);
1676         rtnl_register(PF_INET, RTM_GETADDR, NULL, inet_dump_ifaddr);
1677 }
1678
1679 EXPORT_SYMBOL(in_dev_finish_destroy);
1680 EXPORT_SYMBOL(inet_select_addr);
1681 EXPORT_SYMBOL(inetdev_by_index);
1682 EXPORT_SYMBOL(register_inetaddr_notifier);
1683 EXPORT_SYMBOL(unregister_inetaddr_notifier);