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