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