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

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