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

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