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