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