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