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 int devinet_ioctl(unsigned int cmd, void *arg)
 493 {
 494         struct ifreq ifr;
 495         struct sockaddr_in sin_orig;
 496         struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
 497         struct in_device *in_dev;
 498         struct in_ifaddr **ifap = NULL;
 499         struct in_ifaddr *ifa = NULL;
 500         struct net_device *dev;
 501         char *colon;
 502         int ret = -EFAULT;
 503         int tryaddrmatch = 0;
 504
 505         /*
 506          *      Fetch the caller's info block into kernel space
 507          */
 508
 509         if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
 510                 goto out;
 511         ifr.ifr_name[IFNAMSIZ - 1] = 0;
 512
 513         /* save original address for comparison */
 514         memcpy(&sin_orig, sin, sizeof(*sin));
 515
 516         colon = strchr(ifr.ifr_name, ':');
 517         if (colon)
 518                 *colon = 0;
 519
 520 #ifdef CONFIG_KMOD
 521         dev_load(ifr.ifr_name);
 522 #endif
 523
 524         switch(cmd) {
 525         case SIOCGIFADDR:       /* Get interface address */
 526         case SIOCGIFBRDADDR:    /* Get the broadcast address */
 527         case SIOCGIFDSTADDR:    /* Get the destination address */
 528         case SIOCGIFNETMASK:    /* Get the netmask for the interface */
 529                 /* Note that these ioctls will not sleep,
 530                    so that we do not impose a lock.
 531                    One day we will be forced to put shlock here (I mean SMP)
 532                  */
 533                 tryaddrmatch = (sin_orig.sin_family == AF_INET);
 534                 memset(sin, 0, sizeof(*sin));
 535                 sin->sin_family = AF_INET;
 536                 break;
 537
 538         case SIOCSIFFLAGS:
 539                 ret = -EACCES;
 540                 if (!capable(CAP_NET_ADMIN))
 541                         goto out;
 542                 break;
 543         case SIOCSIFADDR:       /* Set interface address (and family) */
 544         case SIOCSIFBRDADDR:    /* Set the broadcast address */
 545         case SIOCSIFDSTADDR:    /* Set the destination address */
 546         case SIOCSIFNETMASK:    /* Set the netmask for the interface */
 547                 ret = -EACCES;
 548                 if (!capable(CAP_NET_ADMIN))
 549                         goto out;
 550                 ret = -EINVAL;
 551                 if (sin->sin_family != AF_INET)
 552                         goto out;
 553                 break;
 554         default:
 555                 ret = -EINVAL;
 556                 goto out;
 557         }
 558
 559         rtnl_lock();
 560
 561         ret = -ENODEV;
 562         if ((dev = __dev_get_by_name(ifr.ifr_name)) == NULL)
 563                 goto done;
 564
 565         if (colon)
 566                 *colon = ':';
 567
 568         if ((in_dev = __in_dev_get(dev)) != NULL) {
 569                 if (tryaddrmatch) {
 570                         /* Matthias Andree */
 571                         /* compare label and address (4.4BSD style) */
 572                         /* note: we only do this for a limited set of ioctls
 573                            and only if the original address family was AF_INET.
 574                            This is checked above. */
 575                         for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
 576                              ifap = &ifa->ifa_next) {
 577                                 if (!strcmp(ifr.ifr_name, ifa->ifa_label) &&
 578                                     sin_orig.sin_addr.s_addr ==
 579                                                         ifa->ifa_address) {
 580                                         break; /* found */
 581                                 }
 582                         }
 583                 }
 584                 /* we didn't get a match, maybe the application is
 585                    4.3BSD-style and passed in junk so we fall back to
 586                    comparing just the label */
 587                 if (!ifa) {
 588                         for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
 589                              ifap = &ifa->ifa_next)
 590                                 if (!strcmp(ifr.ifr_name, ifa->ifa_label))
 591                                         break;
 592                 }
 593         }
 594
 595         ret = -EADDRNOTAVAIL;
 596         if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS)
 597                 goto done;
 598
 599         switch(cmd) {
 600         case SIOCGIFADDR:       /* Get interface address */
 601                 sin->sin_addr.s_addr = ifa->ifa_local;
 602                 goto rarok;
 603
 604         case SIOCGIFBRDADDR:    /* Get the broadcast address */
 605                 sin->sin_addr.s_addr = ifa->ifa_broadcast;
 606                 goto rarok;
 607
 608         case SIOCGIFDSTADDR:    /* Get the destination address */
 609                 sin->sin_addr.s_addr = ifa->ifa_address;
 610                 goto rarok;
 611
 612         case SIOCGIFNETMASK:    /* Get the netmask for the interface */
 613                 sin->sin_addr.s_addr = ifa->ifa_mask;
 614                 goto rarok;
 615
 616         case SIOCSIFFLAGS:
 617                 if (colon) {
 618                         ret = -EADDRNOTAVAIL;
 619                         if (!ifa)
 620                                 break;
 621                         ret = 0;
 622                         if (!(ifr.ifr_flags & IFF_UP))
 623                                 inet_del_ifa(in_dev, ifap, 1);
 624                         break;
 625                 }
 626                 ret = dev_change_flags(dev, ifr.ifr_flags);
 627                 break;
 628
 629         case SIOCSIFADDR:       /* Set interface address (and family) */
 630                 ret = -EINVAL;
 631                 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
 632                         break;
 633
 634                 if (!ifa) {
 635                         ret = -ENOBUFS;
 636                         if ((ifa = inet_alloc_ifa()) == NULL)
 637                                 break;
 638                         if (colon)
 639                                 memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ);
 640                         else
 641                                 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
 642                 } else {
 643                         ret = 0;
 644                         if (ifa->ifa_local == sin->sin_addr.s_addr)
 645                                 break;
 646                         inet_del_ifa(in_dev, ifap, 0);
 647                         ifa->ifa_broadcast = 0;
 648                         ifa->ifa_anycast = 0;
 649                 }
 650
 651                 ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr;
 652
 653                 if (!(dev->flags & IFF_POINTOPOINT)) {
 654                         ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address);
 655                         ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen);
 656                         if ((dev->flags & IFF_BROADCAST) &&
 657                             ifa->ifa_prefixlen < 31)
 658                                 ifa->ifa_broadcast = ifa->ifa_address |
 659                                                      ~ifa->ifa_mask;
 660                 } else {
 661                         ifa->ifa_prefixlen = 32;
 662                         ifa->ifa_mask = inet_make_mask(32);
 663                 }
 664                 ret = inet_set_ifa(dev, ifa);
 665                 break;
 666
 667         case SIOCSIFBRDADDR:    /* Set the broadcast address */
 668                 ret = 0;
 669                 if (ifa->ifa_broadcast != sin->sin_addr.s_addr) {
 670                         inet_del_ifa(in_dev, ifap, 0);
 671                         ifa->ifa_broadcast = sin->sin_addr.s_addr;
 672                         inet_insert_ifa(ifa);
 673                 }
 674                 break;
 675
 676         case SIOCSIFDSTADDR:    /* Set the destination address */
 677                 ret = 0;
 678                 if (ifa->ifa_address == sin->sin_addr.s_addr)
 679                         break;
 680                 ret = -EINVAL;
 681                 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
 682                         break;
 683                 ret = 0;
 684                 inet_del_ifa(in_dev, ifap, 0);
 685                 ifa->ifa_address = sin->sin_addr.s_addr;
 686                 inet_insert_ifa(ifa);
 687                 break;
 688
 689         case SIOCSIFNETMASK:    /* Set the netmask for the interface */
 690
 691                 /*
 692                  *      The mask we set must be legal.
 693                  */
 694                 ret = -EINVAL;
 695                 if (bad_mask(sin->sin_addr.s_addr, 0))
 696                         break;
 697                 ret = 0;
 698                 if (ifa->ifa_mask != sin->sin_addr.s_addr) {
 699                         inet_del_ifa(in_dev, ifap, 0);
 700                         ifa->ifa_mask = sin->sin_addr.s_addr;
 701                         ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask);
 702                         inet_insert_ifa(ifa);
 703                 }
 704                 break;
 705         }
 706 done:
 707         rtnl_unlock();
 708 out:
 709         return ret;
 710 rarok:
 711         rtnl_unlock();
 712         ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0;
 713         goto out;
 714 }
 715
 716 static int inet_gifconf(struct net_device *dev, char *buf, int len)
 717 {
 718         struct in_device *in_dev = __in_dev_get(dev);
 719         struct in_ifaddr *ifa;
 720         struct ifreq ifr;
 721         int done = 0;
 722
 723         if (!in_dev || (ifa = in_dev->ifa_list) == NULL)
 724                 goto out;
 725
 726         for (; ifa; ifa = ifa->ifa_next) {
 727                 if (!buf) {
 728                         done += sizeof(ifr);
 729                         continue;
 730                 }
 731                 if (len < (int) sizeof(ifr))
 732                         break;
 733                 memset(&ifr, 0, sizeof(struct ifreq));
 734                 if (ifa->ifa_label)
 735                         strcpy(ifr.ifr_name, ifa->ifa_label);
 736                 else
 737                         strcpy(ifr.ifr_name, dev->name);
 738
 739                 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET;
 740                 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr =
 741                                                                 ifa->ifa_local;
 742
 743                 if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) {
 744                         done = -EFAULT;
 745                         break;
 746                 }
 747                 buf  += sizeof(struct ifreq);
 748                 len  -= sizeof(struct ifreq);
 749                 done += sizeof(struct ifreq);
 750         }
 751 out:
 752         return done;
 753 }
 754
 755 u32 inet_select_addr(const struct net_device *dev, u32 dst, int scope)
 756 {
 757         u32 addr = 0;
 758         struct in_device *in_dev;
 759
 760         read_lock(&inetdev_lock);
 761         in_dev = __in_dev_get(dev);
 762         if (!in_dev)
 763                 goto out_unlock_inetdev;
 764
 765         read_lock(&in_dev->lock);
 766         for_primary_ifa(in_dev) {
 767                 if (ifa->ifa_scope > scope)
 768                         continue;
 769                 if (!dst || inet_ifa_match(dst, ifa)) {
 770                         addr = ifa->ifa_local;
 771                         break;
 772                 }
 773                 if (!addr)
 774                         addr = ifa->ifa_local;
 775         } endfor_ifa(in_dev);
 776         read_unlock(&in_dev->lock);
 777         read_unlock(&inetdev_lock);
 778
 779         if (addr)
 780                 goto out;
 781
 782         /* Not loopback addresses on loopback should be preferred
 783            in this case. It is importnat that lo is the first interface
 784            in dev_base list.
 785          */
 786         read_lock(&dev_base_lock);
 787         read_lock(&inetdev_lock);
 788         for (dev = dev_base; dev; dev = dev->next) {
 789                 if ((in_dev = __in_dev_get(dev)) == NULL)
 790                         continue;
 791
 792                 read_lock(&in_dev->lock);
 793                 for_primary_ifa(in_dev) {
 794                         if (ifa->ifa_scope != RT_SCOPE_LINK &&
 795                             ifa->ifa_scope <= scope) {
 796                                 read_unlock(&in_dev->lock);
 797                                 addr = ifa->ifa_local;
 798                                 goto out_unlock_both;
 799                         }
 800                 } endfor_ifa(in_dev);
 801                 read_unlock(&in_dev->lock);
 802         }
 803 out_unlock_both:
 804         read_unlock(&inetdev_lock);
 805         read_unlock(&dev_base_lock);
 806 out:
 807         return addr;
 808 out_unlock_inetdev:
 809         read_unlock(&inetdev_lock);
 810         goto out;
 811 }
 812
 813 static u32 confirm_addr_indev(struct in_device *in_dev, u32 dst,
 814                               u32 local, int scope)
 815 {
 816         int same = 0;
 817         u32 addr = 0;
 818
 819         for_ifa(in_dev) {
 820                 if (!addr &&
 821                     (local == ifa->ifa_local || !local) &&
 822                     ifa->ifa_scope <= scope) {
 823                         addr = ifa->ifa_local;
 824                         if (same)
 825                                 break;
 826                 }
 827                 if (!same) {
 828                         same = (!local || inet_ifa_match(local, ifa)) &&
 829                                 (!dst || inet_ifa_match(dst, ifa));
 830                         if (same && addr) {
 831                                 if (local || !dst)
 832                                         break;
 833                                 /* Is the selected addr into dst subnet? */
 834                                 if (inet_ifa_match(addr, ifa))
 835                                         break;
 836                                 /* No, then can we use new local src? */
 837                                 if (ifa->ifa_scope <= scope) {
 838                                         addr = ifa->ifa_local;
 839                                         break;
 840                                 }
 841                                 /* search for large dst subnet for addr */
 842                                 same = 0;
 843                         }
 844                 }
 845         } endfor_ifa(in_dev);
 846
 847         return same? addr : 0;
 848 }
 849
 850 /*
 851  * Confirm that local IP address exists using wildcards:
 852  * - dev: only on this interface, 0=any interface
 853  * - dst: only in the same subnet as dst, 0=any dst
 854  * - local: address, 0=autoselect the local address
 855  * - scope: maximum allowed scope value for the local address
 856  */
 857 u32 inet_confirm_addr(const struct net_device *dev, u32 dst, u32 local, int scope)
 858 {
 859         u32 addr = 0;
 860         struct in_device *in_dev;
 861
 862         if (dev) {
 863                 read_lock(&inetdev_lock);
 864                 if ((in_dev = __in_dev_get(dev))) {
 865                         read_lock(&in_dev->lock);
 866                         addr = confirm_addr_indev(in_dev, dst, local, scope);
 867                         read_unlock(&in_dev->lock);
 868                 }
 869                 read_unlock(&inetdev_lock);
 870
 871                 return addr;
 872         }
 873
 874         read_lock(&dev_base_lock);
 875         read_lock(&inetdev_lock);
 876         for (dev = dev_base; dev; dev = dev->next) {
 877                 if ((in_dev = __in_dev_get(dev))) {
 878                         read_lock(&in_dev->lock);
 879                         addr = confirm_addr_indev(in_dev, dst, local, scope);
 880                         read_unlock(&in_dev->lock);
 881                         if (addr)
 882                                 break;
 883                 }
 884         }
 885         read_unlock(&inetdev_lock);
 886         read_unlock(&dev_base_lock);
 887
 888         return addr;
 889 }
 890
 891 /*
 892  *      Device notifier
 893  */
 894
 895 int register_inetaddr_notifier(struct notifier_block *nb)
 896 {
 897         return notifier_chain_register(&inetaddr_chain, nb);
 898 }
 899
 900 int unregister_inetaddr_notifier(struct notifier_block *nb)
 901 {
 902         return notifier_chain_unregister(&inetaddr_chain, nb);
 903 }
 904
 905 /* Rename ifa_labels for a device name change. Make some effort to preserve existing
 906  * alias numbering and to create unique labels if possible.
 907 */
 908 static void inetdev_changename(struct net_device *dev, struct in_device *in_dev)
 909 {
 910         struct in_ifaddr *ifa;
 911         int named = 0;
 912
 913         for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
 914                 char old[IFNAMSIZ], *dot;
 915
 916                 memcpy(old, ifa->ifa_label, IFNAMSIZ);
 917                 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
 918                 if (named++ == 0)
 919                         continue;
 920                 dot = strchr(ifa->ifa_label, ':');
 921                 if (dot == NULL) {
 922                         sprintf(old, ":%d", named);
 923                         dot = old;
 924                 }
 925                 if (strlen(dot) + strlen(dev->name) < IFNAMSIZ) {
 926                         strcat(ifa->ifa_label, dot);
 927                 } else {
 928                         strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot);
 929                 }
 930         }
 931 }
 932
 933 /* Called only under RTNL semaphore */
 934
 935 static int inetdev_event(struct notifier_block *this, unsigned long event,
 936                          void *ptr)
 937 {
 938         struct net_device *dev = ptr;
 939         struct in_device *in_dev = __in_dev_get(dev);
 940
 941         ASSERT_RTNL();
 942
 943         if (!in_dev)
 944                 goto out;
 945
 946         switch (event) {
 947         case NETDEV_REGISTER:
 948                 printk(KERN_DEBUG "inetdev_event: bug\n");
 949                 dev->ip_ptr = NULL;
 950                 break;
 951         case NETDEV_UP:
 952                 if (dev->mtu < 68)
 953                         break;
 954                 if (dev == &loopback_dev) {
 955                         struct in_ifaddr *ifa;
 956                         if ((ifa = inet_alloc_ifa()) != NULL) {
 957                                 ifa->ifa_local =
 958                                   ifa->ifa_address = htonl(INADDR_LOOPBACK);
 959                                 ifa->ifa_prefixlen = 8;
 960                                 ifa->ifa_mask = inet_make_mask(8);
 961                                 in_dev_hold(in_dev);
 962                                 ifa->ifa_dev = in_dev;
 963                                 ifa->ifa_scope = RT_SCOPE_HOST;
 964                                 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
 965                                 inet_insert_ifa(ifa);
 966                         }
 967                         in_dev->cnf.no_xfrm = 1;
 968                         in_dev->cnf.no_policy = 1;
 969                 }
 970                 ip_mc_up(in_dev);
 971                 break;
 972         case NETDEV_DOWN:
 973                 ip_mc_down(in_dev);
 974                 break;
 975         case NETDEV_CHANGEMTU:
 976                 if (dev->mtu >= 68)
 977                         break;
 978                 /* MTU falled under 68, disable IP */
 979         case NETDEV_UNREGISTER:
 980                 inetdev_destroy(in_dev);
 981                 break;
 982         case NETDEV_CHANGENAME:
 983                 /* Do not notify about label change, this event is
 984                  * not interesting to applications using netlink.
 985                  */
 986                 inetdev_changename(dev, in_dev);
 987
 988 #ifdef CONFIG_SYSCTL
 989                 devinet_sysctl_unregister(&in_dev->cnf);
 990                 neigh_sysctl_unregister(in_dev->arp_parms);
 991                 neigh_sysctl_register(dev, in_dev->arp_parms, NET_IPV4,
 992                                       NET_IPV4_NEIGH, "ipv4", NULL);
 993                 devinet_sysctl_register(in_dev, &in_dev->cnf);
 994 #endif
 995                 break;
 996         }
 997 out:
 998         return NOTIFY_DONE;
 999 }
1000
1001 static struct notifier_block ip_netdev_notifier = {
1002         .notifier_call =inetdev_event,
1003 };
1004
1005 static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
1006                             u32 pid, u32 seq, int event)
1007 {
1008         struct ifaddrmsg *ifm;
1009         struct nlmsghdr  *nlh;
1010         unsigned char    *b = skb->tail;
1011
1012         nlh = NLMSG_PUT(skb, pid, seq, event, sizeof(*ifm));
1013         if (pid) nlh->nlmsg_flags |= NLM_F_MULTI;
1014         ifm = NLMSG_DATA(nlh);
1015         ifm->ifa_family = AF_INET;
1016         ifm->ifa_prefixlen = ifa->ifa_prefixlen;
1017         ifm->ifa_flags = ifa->ifa_flags|IFA_F_PERMANENT;
1018         ifm->ifa_scope = ifa->ifa_scope;
1019         ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
1020         if (ifa->ifa_address)
1021                 RTA_PUT(skb, IFA_ADDRESS, 4, &ifa->ifa_address);
1022         if (ifa->ifa_local)
1023                 RTA_PUT(skb, IFA_LOCAL, 4, &ifa->ifa_local);
1024         if (ifa->ifa_broadcast)
1025                 RTA_PUT(skb, IFA_BROADCAST, 4, &ifa->ifa_broadcast);
1026         if (ifa->ifa_anycast)
1027                 RTA_PUT(skb, IFA_ANYCAST, 4, &ifa->ifa_anycast);
1028         if (ifa->ifa_label[0])
1029                 RTA_PUT(skb, IFA_LABEL, IFNAMSIZ, &ifa->ifa_label);
1030         nlh->nlmsg_len = skb->tail - b;
1031         return skb->len;
1032
1033 nlmsg_failure:
1034 rtattr_failure:
1035         skb_trim(skb, b - skb->data);
1036         return -1;
1037 }
1038
1039 static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
1040 {
1041         int idx, ip_idx;
1042         struct net_device *dev;
1043         struct in_device *in_dev;
1044         struct in_ifaddr *ifa;
1045         int s_ip_idx, s_idx = cb->args[0];
1046
1047         s_ip_idx = ip_idx = cb->args[1];
1048         read_lock(&dev_base_lock);
1049         for (dev = dev_base, idx = 0; dev; dev = dev->next, idx++) {
1050                 if (idx < s_idx)
1051                         continue;
1052                 if (idx > s_idx)
1053                         s_ip_idx = 0;
1054                 read_lock(&inetdev_lock);
1055                 if ((in_dev = __in_dev_get(dev)) == NULL) {
1056                         read_unlock(&inetdev_lock);
1057                         continue;
1058                 }
1059                 read_lock(&in_dev->lock);
1060                 for (ifa = in_dev->ifa_list, ip_idx = 0; ifa;
1061                      ifa = ifa->ifa_next, ip_idx++) {
1062                         if (ip_idx < s_ip_idx)
1063                                 continue;
1064                         if (inet_fill_ifaddr(skb, ifa, NETLINK_CB(cb->skb).pid,
1065                                              cb->nlh->nlmsg_seq,
1066                                              RTM_NEWADDR) <= 0) {
1067                                 read_unlock(&in_dev->lock);
1068                                 read_unlock(&inetdev_lock);
1069                                 goto done;
1070                         }
1071                 }
1072                 read_unlock(&in_dev->lock);
1073                 read_unlock(&inetdev_lock);
1074         }
1075
1076 done:
1077         read_unlock(&dev_base_lock);
1078         cb->args[0] = idx;
1079         cb->args[1] = ip_idx;
1080
1081         return skb->len;
1082 }
1083
1084 static void rtmsg_ifa(int event, struct in_ifaddr* ifa)
1085 {
1086         int size = NLMSG_SPACE(sizeof(struct ifaddrmsg) + 128);
1087         struct sk_buff *skb = alloc_skb(size, GFP_KERNEL);
1088
1089         if (!skb)
1090                 netlink_set_err(rtnl, 0, RTMGRP_IPV4_IFADDR, ENOBUFS);
1091         else if (inet_fill_ifaddr(skb, ifa, 0, 0, event) < 0) {
1092                 kfree_skb(skb);
1093                 netlink_set_err(rtnl, 0, RTMGRP_IPV4_IFADDR, EINVAL);
1094         } else {
1095                 NETLINK_CB(skb).dst_groups = RTMGRP_IPV4_IFADDR;
1096                 netlink_broadcast(rtnl, skb, 0, RTMGRP_IPV4_IFADDR, GFP_KERNEL);
1097         }
1098 }
1099
1100 static struct rtnetlink_link inet_rtnetlink_table[RTM_MAX - RTM_BASE + 1] = {
1101          [4] = { .doit   = inet_rtm_newaddr,  },
1102          [5] = { .doit   = inet_rtm_deladdr,  },
1103          [6] = { .dumpit = inet_dump_ifaddr,  },
1104          [8] = { .doit   = inet_rtm_newroute, },
1105          [9] = { .doit   = inet_rtm_delroute, },
1106         [10] = { .doit   = inet_rtm_getroute, .dumpit = inet_dump_fib, },
1107 #ifdef CONFIG_IP_MULTIPLE_TABLES
1108         [16] = { .doit   = inet_rtm_newrule, },
1109         [17] = { .doit   = inet_rtm_delrule, },
1110         [18] = { .dumpit = inet_dump_rules,  },
1111 #endif
1112 };
1113
1114 #ifdef CONFIG_SYSCTL
1115
1116 void inet_forward_change(void)
1117 {
1118         struct net_device *dev;
1119         int on = ipv4_devconf.forwarding;
1120
1121         ipv4_devconf.accept_redirects = !on;
1122         ipv4_devconf_dflt.forwarding = on;
1123
1124         read_lock(&dev_base_lock);
1125         for (dev = dev_base; dev; dev = dev->next) {
1126                 struct in_device *in_dev;
1127                 read_lock(&inetdev_lock);
1128                 in_dev = __in_dev_get(dev);
1129                 if (in_dev)
1130                         in_dev->cnf.forwarding = on;
1131                 read_unlock(&inetdev_lock);
1132         }
1133         read_unlock(&dev_base_lock);
1134
1135         rt_cache_flush(0);
1136 }
1137
1138 static int devinet_sysctl_forward(ctl_table *ctl, int write,
1139                                   struct file* filp, void *buffer,
1140                                   size_t *lenp)
1141 {
1142         int *valp = ctl->data;
1143         int val = *valp;
1144         int ret = proc_dointvec(ctl, write, filp, buffer, lenp);
1145
1146         if (write && *valp != val) {
1147                 if (valp == &ipv4_devconf.forwarding)
1148                         inet_forward_change();
1149                 else if (valp != &ipv4_devconf_dflt.forwarding)
1150                         rt_cache_flush(0);
1151         }
1152
1153         return ret;
1154 }
1155
1156 int ipv4_doint_and_flush(ctl_table *ctl, int write,
1157                          struct file* filp, void *buffer,
1158                          size_t *lenp)
1159 {
1160         int *valp = ctl->data;
1161         int val = *valp;
1162         int ret = proc_dointvec(ctl, write, filp, buffer, lenp);
1163
1164         if (write && *valp != val)
1165                 rt_cache_flush(0);
1166
1167         return ret;
1168 }
1169
1170 int ipv4_doint_and_flush_strategy(ctl_table *table, int *name, int nlen,
1171                                   void *oldval, size_t *oldlenp,
1172                                   void *newval, size_t newlen,
1173                                   void **context)
1174 {
1175         int *valp = table->data;
1176         int new;
1177
1178         if (!newval || !newlen)
1179                 return 0;
1180
1181         if (newlen != sizeof(int))
1182                 return -EINVAL;
1183
1184         if (get_user(new, (int *)newval))
1185                 return -EFAULT;
1186
1187         if (new == *valp)
1188                 return 0;
1189
1190         if (oldval && oldlenp) {
1191                 size_t len;
1192
1193                 if (get_user(len, oldlenp))
1194                         return -EFAULT;
1195
1196                 if (len) {
1197                         if (len > table->maxlen)
1198                                 len = table->maxlen;
1199                         if (copy_to_user(oldval, valp, len))
1200                                 return -EFAULT;
1201                         if (put_user(len, oldlenp))
1202                                 return -EFAULT;
1203                 }
1204         }
1205
1206         *valp = new;
1207         rt_cache_flush(0);
1208         return 1;
1209 }
1210
1211
1212 static struct devinet_sysctl_table {
1213         struct ctl_table_header *sysctl_header;
1214         ctl_table               devinet_vars[20];
1215         ctl_table               devinet_dev[2];
1216         ctl_table               devinet_conf_dir[2];
1217         ctl_table               devinet_proto_dir[2];
1218         ctl_table               devinet_root_dir[2];
1219 } devinet_sysctl = {
1220         .devinet_vars = {
1221                 {
1222                         .ctl_name       = NET_IPV4_CONF_FORWARDING,
1223                         .procname       = "forwarding",
1224                         .data           = &ipv4_devconf.forwarding,
1225                         .maxlen         = sizeof(int),
1226                         .mode           = 0644,
1227                         .proc_handler   = &devinet_sysctl_forward,
1228                 },
1229                 {
1230                         .ctl_name       = NET_IPV4_CONF_MC_FORWARDING,
1231                         .procname       = "mc_forwarding",
1232                         .data           = &ipv4_devconf.mc_forwarding,
1233                         .maxlen         = sizeof(int),
1234                         .mode           = 0444,
1235                         .proc_handler   = &proc_dointvec,
1236                 },
1237                 {
1238                         .ctl_name       = NET_IPV4_CONF_ACCEPT_REDIRECTS,
1239                         .procname       = "accept_redirects",
1240                         .data           = &ipv4_devconf.accept_redirects,
1241                         .maxlen         = sizeof(int),
1242                         .mode           = 0644,
1243                         .proc_handler   = &proc_dointvec,
1244                 },
1245                 {
1246                         .ctl_name       = NET_IPV4_CONF_SECURE_REDIRECTS,
1247                         .procname       = "secure_redirects",
1248                         .data           = &ipv4_devconf.secure_redirects,
1249                         .maxlen         = sizeof(int),
1250                         .mode           = 0644,
1251                         .proc_handler   = &proc_dointvec,
1252                 },
1253                 {
1254                         .ctl_name       = NET_IPV4_CONF_SHARED_MEDIA,
1255                         .procname       = "shared_media",
1256                         .data           = &ipv4_devconf.shared_media,
1257                         .maxlen         = sizeof(int),
1258                         .mode           = 0644,
1259                         .proc_handler   = &proc_dointvec,
1260                 },
1261                 {
1262                         .ctl_name       = NET_IPV4_CONF_RP_FILTER,
1263                         .procname       = "rp_filter",
1264                         .data           = &ipv4_devconf.rp_filter,
1265                         .maxlen         = sizeof(int),
1266                         .mode           = 0644,
1267                         .proc_handler   = &proc_dointvec,
1268                 },
1269                 {
1270                         .ctl_name       = NET_IPV4_CONF_SEND_REDIRECTS,
1271                         .procname       = "send_redirects",
1272                         .data           = &ipv4_devconf.send_redirects,
1273                         .maxlen         = sizeof(int),
1274                         .mode           = 0644,
1275                         .proc_handler   = &proc_dointvec,
1276                 },
1277                 {
1278                         .ctl_name       = NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE,
1279                         .procname       = "accept_source_route",
1280                         .data           = &ipv4_devconf.accept_source_route,
1281                         .maxlen         = sizeof(int),
1282                         .mode           = 0644,
1283                         .proc_handler   = &proc_dointvec,
1284                 },
1285                 {
1286                         .ctl_name       = NET_IPV4_CONF_PROXY_ARP,
1287                         .procname       = "proxy_arp",
1288                         .data           = &ipv4_devconf.proxy_arp,
1289                         .maxlen         = sizeof(int),
1290                         .mode           = 0644,
1291                         .proc_handler   = &proc_dointvec,
1292                 },
1293                 {
1294                         .ctl_name       = NET_IPV4_CONF_MEDIUM_ID,
1295                         .procname       = "medium_id",
1296                         .data           = &ipv4_devconf.medium_id,
1297                         .maxlen         = sizeof(int),
1298                         .mode           = 0644,
1299                         .proc_handler   = &proc_dointvec,
1300                 },
1301                 {
1302                         .ctl_name       = NET_IPV4_CONF_BOOTP_RELAY,
1303                         .procname       = "bootp_relay",
1304                         .data           = &ipv4_devconf.bootp_relay,
1305                         .maxlen         = sizeof(int),
1306                         .mode           = 0644,
1307                         .proc_handler   = &proc_dointvec,
1308                 },
1309                 {
1310                         .ctl_name       = NET_IPV4_CONF_LOG_MARTIANS,
1311                         .procname       = "log_martians",
1312                         .data           = &ipv4_devconf.log_martians,
1313                         .maxlen         = sizeof(int),
1314                         .mode           = 0644,
1315                         .proc_handler   = &proc_dointvec,
1316                 },
1317                 {
1318                         .ctl_name       = NET_IPV4_CONF_TAG,
1319                         .procname       = "tag",
1320                         .data           = &ipv4_devconf.tag,
1321                         .maxlen         = sizeof(int),
1322                         .mode           = 0644,
1323                         .proc_handler   = &proc_dointvec,
1324                 },
1325                 {
1326                         .ctl_name       = NET_IPV4_CONF_ARPFILTER,
1327                         .procname       = "arp_filter",
1328                         .data           = &ipv4_devconf.arp_filter,
1329                         .maxlen         = sizeof(int),
1330                         .mode           = 0644,
1331                         .proc_handler   = &proc_dointvec,
1332                 },
1333                 {
1334                         .ctl_name       = NET_IPV4_CONF_ARP_ANNOUNCE,
1335                         .procname       = "arp_announce",
1336                         .data           = &ipv4_devconf.arp_announce,
1337                         .maxlen         = sizeof(int),
1338                         .mode           = 0644,
1339                         .proc_handler   = &proc_dointvec,
1340                 },
1341                 {
1342                         .ctl_name       = NET_IPV4_CONF_ARP_IGNORE,
1343                         .procname       = "arp_ignore",
1344                         .data           = &ipv4_devconf.arp_ignore,
1345                         .maxlen         = sizeof(int),
1346                         .mode           = 0644,
1347                         .proc_handler   = &proc_dointvec,
1348                 },
1349                 {
1350                         .ctl_name       = NET_IPV4_CONF_NOXFRM,
1351                         .procname       = "disable_xfrm",
1352                         .data           = &ipv4_devconf.no_xfrm,
1353                         .maxlen         = sizeof(int),
1354                         .mode           = 0644,
1355                         .proc_handler   = &ipv4_doint_and_flush,
1356                         .strategy       = &ipv4_doint_and_flush_strategy,
1357                 },
1358                 {
1359                         .ctl_name       = NET_IPV4_CONF_NOPOLICY,
1360                         .procname       = "disable_policy",
1361                         .data           = &ipv4_devconf.no_policy,
1362                         .maxlen         = sizeof(int),
1363                         .mode           = 0644,
1364                         .proc_handler   = &ipv4_doint_and_flush,
1365                         .strategy       = &ipv4_doint_and_flush_strategy,
1366                 },
1367                 {
1368                         .ctl_name       = NET_IPV4_CONF_FORCE_IGMP_VERSION,
1369                         .procname       = "force_igmp_version",
1370                         .data           = &ipv4_devconf.force_igmp_version,
1371                         .maxlen         = sizeof(int),
1372                         .mode           = 0644,
1373                         .proc_handler   = &ipv4_doint_and_flush,
1374                         .strategy       = &ipv4_doint_and_flush_strategy,
1375                 },
1376         },
1377         .devinet_dev = {
1378                 {
1379                         .ctl_name       = NET_PROTO_CONF_ALL,
1380                         .procname       = "all",
1381                         .mode           = 0555,
1382                         .child          = devinet_sysctl.devinet_vars,
1383                 },
1384         },
1385         .devinet_conf_dir = {
1386                 {
1387                         .ctl_name       = NET_IPV4_CONF,
1388                         .procname       = "conf",
1389                         .mode           = 0555,
1390                         .child          = devinet_sysctl.devinet_dev,
1391                 },
1392         },
1393         .devinet_proto_dir = {
1394                 {
1395                         .ctl_name       = NET_IPV4,
1396                         .procname       = "ipv4",
1397                         .mode           = 0555,
1398                         .child          = devinet_sysctl.devinet_conf_dir,
1399                 },
1400         },
1401         .devinet_root_dir = {
1402                 {
1403                         .ctl_name       = CTL_NET,
1404                         .procname       = "net",
1405                         .mode           = 0555,
1406                         .child          = devinet_sysctl.devinet_proto_dir,
1407                 },
1408         },
1409 };
1410
1411 static void devinet_sysctl_register(struct in_device *in_dev,
1412                                     struct ipv4_devconf *p)
1413 {
1414         int i;
1415         struct net_device *dev = in_dev ? in_dev->dev : NULL;
1416         struct devinet_sysctl_table *t = kmalloc(sizeof(*t), GFP_KERNEL);
1417         char *dev_name = NULL;
1418
1419         if (!t)
1420                 return;
1421         memcpy(t, &devinet_sysctl, sizeof(*t));
1422         for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
1423                 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
1424                 t->devinet_vars[i].de = NULL;
1425         }
1426
1427         if (dev) {
1428                 dev_name = dev->name;
1429                 t->devinet_dev[0].ctl_name = dev->ifindex;
1430         } else {
1431                 dev_name = "default";
1432                 t->devinet_dev[0].ctl_name = NET_PROTO_CONF_DEFAULT;
1433         }
1434
1435         /*
1436          * Make a copy of dev_name, because '.procname' is regarded as const
1437          * by sysctl and we wouldn't want anyone to change it under our feet
1438          * (see SIOCSIFNAME).
1439          */
1440         dev_name = net_sysctl_strdup(dev_name);
1441         if (!dev_name)
1442             goto free;
1443
1444         t->devinet_dev[0].procname    = dev_name;
1445         t->devinet_dev[0].child       = t->devinet_vars;
1446         t->devinet_dev[0].de          = NULL;
1447         t->devinet_conf_dir[0].child  = t->devinet_dev;
1448         t->devinet_conf_dir[0].de     = NULL;
1449         t->devinet_proto_dir[0].child = t->devinet_conf_dir;
1450         t->devinet_proto_dir[0].de    = NULL;
1451         t->devinet_root_dir[0].child  = t->devinet_proto_dir;
1452         t->devinet_root_dir[0].de     = NULL;
1453
1454         t->sysctl_header = register_sysctl_table(t->devinet_root_dir, 0);
1455         if (!t->sysctl_header)
1456             goto free_procname;
1457
1458         p->sysctl = t;
1459         return;
1460
1461         /* error path */
1462  free_procname:
1463         kfree(dev_name);
1464  free:
1465         kfree(t);
1466         return;
1467 }
1468
1469 static void devinet_sysctl_unregister(struct ipv4_devconf *p)
1470 {
1471         if (p->sysctl) {
1472                 struct devinet_sysctl_table *t = p->sysctl;
1473                 p->sysctl = NULL;
1474                 unregister_sysctl_table(t->sysctl_header);
1475                 kfree(t->devinet_dev[0].procname);
1476                 kfree(t);
1477         }
1478 }
1479 #endif
1480
1481 void __init devinet_init(void)
1482 {
1483         register_gifconf(PF_INET, inet_gifconf);
1484         register_netdevice_notifier(&ip_netdev_notifier);
1485         rtnetlink_links[PF_INET] = inet_rtnetlink_table;
1486 #ifdef CONFIG_SYSCTL
1487         devinet_sysctl.sysctl_header =
1488                 register_sysctl_table(devinet_sysctl.devinet_root_dir, 0);
1489         devinet_sysctl_register(NULL, &ipv4_devconf_dflt);
1490 #endif
1491 }
1492
1493 EXPORT_SYMBOL(devinet_ioctl);
1494 EXPORT_SYMBOL(in_dev_finish_destroy);
1495 EXPORT_SYMBOL(inet_select_addr);
1496 EXPORT_SYMBOL(inetdev_by_index);
1497 EXPORT_SYMBOL(inetdev_lock);
1498 EXPORT_SYMBOL(register_inetaddr_notifier);
1499 EXPORT_SYMBOL(unregister_inetaddr_notifier);