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