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

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