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