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