SAFE public projects git trees. - safe/jmp/linux-2.6/blob - net/ipv4/devinet.c

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