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