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