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