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