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

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