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

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