2 * NET3 IP device support routines.
4 * Version: $Id: devinet.c,v 1.44 2001/10/31 21:55:54 davem Exp $
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.
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>
17 * Alan Cox, <gw4pts@gw4pts.ampr.org>
18 * Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
21 * Alexey Kuznetsov: pa_* fields are replaced with ifaddr
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
30 #include <linux/config.h>
32 #include <asm/uaccess.h>
33 #include <asm/system.h>
34 #include <asm/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>
41 #include <linux/socket.h>
42 #include <linux/sockios.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>
57 #include <linux/sysctl.h>
59 #include <linux/kmod.h>
62 #include <net/route.h>
63 #include <net/ip_fib.h>
65 struct ipv4_devconf ipv4_devconf = {
66 .accept_redirects = 1,
68 .secure_redirects = 1,
72 static struct ipv4_devconf ipv4_devconf_dflt = {
73 .accept_redirects = 1,
75 .secure_redirects = 1,
77 .accept_source_route = 1,
80 static void rtmsg_ifa(int event, struct in_ifaddr *);
82 static struct notifier_block *inetaddr_chain;
83 static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
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);
94 /* Locks all the inet devices. */
96 rwlock_t inetdev_lock = RW_LOCK_UNLOCKED;
98 static struct in_ifaddr *inet_alloc_ifa(void)
100 struct in_ifaddr *ifa = kmalloc(sizeof(*ifa), GFP_KERNEL);
103 memset(ifa, 0, sizeof(*ifa));
110 static __inline__ void inet_free_ifa(struct in_ifaddr *ifa)
113 __in_dev_put(ifa->ifa_dev);
118 void in_dev_finish_destroy(struct in_device *idev)
120 struct net_device *dev = idev->dev;
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");
130 printk("Freeing alive in_device %p\n", idev);
137 struct in_device *inetdev_init(struct net_device *dev)
139 struct in_device *in_dev;
143 in_dev = kmalloc(sizeof(*in_dev), GFP_KERNEL);
146 memset(in_dev, 0, sizeof(*in_dev));
147 in_dev->lock = RW_LOCK_UNLOCKED;
148 memcpy(&in_dev->cnf, &ipv4_devconf_dflt, sizeof(in_dev->cnf));
149 in_dev->cnf.sysctl = NULL;
151 if ((in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl)) == NULL)
154 /* Reference in_dev->dev */
157 neigh_sysctl_register(dev, in_dev->arp_parms, NET_IPV4,
158 NET_IPV4_NEIGH, "ipv4", NULL);
160 write_lock_bh(&inetdev_lock);
161 dev->ip_ptr = in_dev;
162 /* Account for reference dev->ip_ptr */
164 write_unlock_bh(&inetdev_lock);
166 devinet_sysctl_register(in_dev, &in_dev->cnf);
168 ip_mc_init_dev(in_dev);
169 if (dev->flags & IFF_UP)
179 static void inetdev_destroy(struct in_device *in_dev)
181 struct in_ifaddr *ifa;
187 ip_mc_destroy_dev(in_dev);
189 while ((ifa = in_dev->ifa_list) != NULL) {
190 inet_del_ifa(in_dev, &in_dev->ifa_list, 0);
195 devinet_sysctl_unregister(&in_dev->cnf);
197 write_lock_bh(&inetdev_lock);
198 in_dev->dev->ip_ptr = NULL;
199 /* in_dev_put following below will kill the in_device */
200 write_unlock_bh(&inetdev_lock);
203 neigh_sysctl_unregister(in_dev->arp_parms);
205 neigh_parms_release(&arp_tbl, in_dev->arp_parms);
209 int inet_addr_onlink(struct in_device *in_dev, u32 a, u32 b)
211 read_lock(&in_dev->lock);
212 for_primary_ifa(in_dev) {
213 if (inet_ifa_match(a, ifa)) {
214 if (!b || inet_ifa_match(b, ifa)) {
215 read_unlock(&in_dev->lock);
219 } endfor_ifa(in_dev);
220 read_unlock(&in_dev->lock);
224 static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
227 struct in_ifaddr *ifa1 = *ifap;
231 /* 1. Deleting primary ifaddr forces deletion all secondaries */
233 if (!(ifa1->ifa_flags & IFA_F_SECONDARY)) {
234 struct in_ifaddr *ifa;
235 struct in_ifaddr **ifap1 = &ifa1->ifa_next;
237 while ((ifa = *ifap1) != NULL) {
238 if (!(ifa->ifa_flags & IFA_F_SECONDARY) ||
239 ifa1->ifa_mask != ifa->ifa_mask ||
240 !inet_ifa_match(ifa1->ifa_address, ifa)) {
241 ifap1 = &ifa->ifa_next;
244 write_lock_bh(&in_dev->lock);
245 *ifap1 = ifa->ifa_next;
246 write_unlock_bh(&in_dev->lock);
248 rtmsg_ifa(RTM_DELADDR, ifa);
249 notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa);
256 write_lock_bh(&in_dev->lock);
257 *ifap = ifa1->ifa_next;
258 write_unlock_bh(&in_dev->lock);
260 /* 3. Announce address deletion */
262 /* Send message first, then call notifier.
263 At first sight, FIB update triggered by notifier
264 will refer to already deleted ifaddr, that could confuse
265 netlink listeners. It is not true: look, gated sees
266 that route deleted and if it still thinks that ifaddr
267 is valid, it will try to restore deleted routes... Grr.
268 So that, this order is correct.
270 rtmsg_ifa(RTM_DELADDR, ifa1);
271 notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1);
275 if (!in_dev->ifa_list)
276 inetdev_destroy(in_dev);
280 static int inet_insert_ifa(struct in_ifaddr *ifa)
282 struct in_device *in_dev = ifa->ifa_dev;
283 struct in_ifaddr *ifa1, **ifap, **last_primary;
287 if (!ifa->ifa_local) {
292 ifa->ifa_flags &= ~IFA_F_SECONDARY;
293 last_primary = &in_dev->ifa_list;
295 for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL;
296 ifap = &ifa1->ifa_next) {
297 if (!(ifa1->ifa_flags & IFA_F_SECONDARY) &&
298 ifa->ifa_scope <= ifa1->ifa_scope)
299 last_primary = &ifa1->ifa_next;
300 if (ifa1->ifa_mask == ifa->ifa_mask &&
301 inet_ifa_match(ifa1->ifa_address, ifa)) {
302 if (ifa1->ifa_local == ifa->ifa_local) {
306 if (ifa1->ifa_scope != ifa->ifa_scope) {
310 ifa->ifa_flags |= IFA_F_SECONDARY;
314 if (!(ifa->ifa_flags & IFA_F_SECONDARY)) {
315 net_srandom(ifa->ifa_local);
319 ifa->ifa_next = *ifap;
320 write_lock_bh(&in_dev->lock);
322 write_unlock_bh(&in_dev->lock);
324 /* Send message first, then call notifier.
325 Notifier will trigger FIB update, so that
326 listeners of netlink will know about new ifaddr */
327 rtmsg_ifa(RTM_NEWADDR, ifa);
328 notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
333 static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa)
335 struct in_device *in_dev = __in_dev_get(dev);
340 in_dev = inetdev_init(dev);
346 if (ifa->ifa_dev != in_dev) {
347 BUG_TRAP(!ifa->ifa_dev);
349 ifa->ifa_dev = in_dev;
351 if (LOOPBACK(ifa->ifa_local))
352 ifa->ifa_scope = RT_SCOPE_HOST;
353 return inet_insert_ifa(ifa);
356 struct in_device *inetdev_by_index(int ifindex)
358 struct net_device *dev;
359 struct in_device *in_dev = NULL;
360 read_lock(&dev_base_lock);
361 dev = __dev_get_by_index(ifindex);
363 in_dev = in_dev_get(dev);
364 read_unlock(&dev_base_lock);
368 /* Called only from RTNL semaphored context. No locks. */
370 struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, u32 prefix,
375 for_primary_ifa(in_dev) {
376 if (ifa->ifa_mask == mask && inet_ifa_match(prefix, ifa))
378 } endfor_ifa(in_dev);
382 int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
384 struct rtattr **rta = arg;
385 struct in_device *in_dev;
386 struct ifaddrmsg *ifm = NLMSG_DATA(nlh);
387 struct in_ifaddr *ifa, **ifap;
391 if ((in_dev = inetdev_by_index(ifm->ifa_index)) == NULL)
393 __in_dev_put(in_dev);
395 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
396 ifap = &ifa->ifa_next) {
397 if ((rta[IFA_LOCAL - 1] &&
398 memcmp(RTA_DATA(rta[IFA_LOCAL - 1]),
399 &ifa->ifa_local, 4)) ||
400 (rta[IFA_LABEL - 1] &&
401 strcmp(RTA_DATA(rta[IFA_LABEL - 1]), ifa->ifa_label)) ||
402 (rta[IFA_ADDRESS - 1] &&
403 (ifm->ifa_prefixlen != ifa->ifa_prefixlen ||
404 !inet_ifa_match(*(u32*)RTA_DATA(rta[IFA_ADDRESS - 1]),
407 inet_del_ifa(in_dev, ifap, 1);
411 return -EADDRNOTAVAIL;
414 int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
416 struct rtattr **rta = arg;
417 struct net_device *dev;
418 struct in_device *in_dev;
419 struct ifaddrmsg *ifm = NLMSG_DATA(nlh);
420 struct in_ifaddr *ifa;
425 if (ifm->ifa_prefixlen > 32 || !rta[IFA_LOCAL - 1])
429 if ((dev = __dev_get_by_index(ifm->ifa_index)) == NULL)
433 if ((in_dev = __in_dev_get(dev)) == NULL) {
434 in_dev = inetdev_init(dev);
439 if ((ifa = inet_alloc_ifa()) == NULL)
442 if (!rta[IFA_ADDRESS - 1])
443 rta[IFA_ADDRESS - 1] = rta[IFA_LOCAL - 1];
444 memcpy(&ifa->ifa_local, RTA_DATA(rta[IFA_LOCAL - 1]), 4);
445 memcpy(&ifa->ifa_address, RTA_DATA(rta[IFA_ADDRESS - 1]), 4);
446 ifa->ifa_prefixlen = ifm->ifa_prefixlen;
447 ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen);
448 if (rta[IFA_BROADCAST - 1])
449 memcpy(&ifa->ifa_broadcast,
450 RTA_DATA(rta[IFA_BROADCAST - 1]), 4);
451 if (rta[IFA_ANYCAST - 1])
452 memcpy(&ifa->ifa_anycast, RTA_DATA(rta[IFA_ANYCAST - 1]), 4);
453 ifa->ifa_flags = ifm->ifa_flags;
454 ifa->ifa_scope = ifm->ifa_scope;
456 ifa->ifa_dev = in_dev;
457 if (rta[IFA_LABEL - 1])
458 memcpy(ifa->ifa_label, RTA_DATA(rta[IFA_LABEL - 1]), IFNAMSIZ);
460 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
462 rc = inet_insert_ifa(ifa);
468 * Determine a default network mask, based on the IP address.
471 static __inline__ int inet_abc_len(u32 addr)
473 int rc = -1; /* Something else, probably a multicast. */
482 else if (IN_CLASSB(addr))
484 else if (IN_CLASSC(addr))
492 int devinet_ioctl(unsigned int cmd, void *arg)
495 struct sockaddr_in sin_orig;
496 struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
497 struct in_device *in_dev;
498 struct in_ifaddr **ifap = NULL;
499 struct in_ifaddr *ifa = NULL;
500 struct net_device *dev;
503 int tryaddrmatch = 0;
506 * Fetch the caller's info block into kernel space
509 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
511 ifr.ifr_name[IFNAMSIZ - 1] = 0;
513 /* save original address for comparison */
514 memcpy(&sin_orig, sin, sizeof(*sin));
516 colon = strchr(ifr.ifr_name, ':');
521 dev_load(ifr.ifr_name);
525 case SIOCGIFADDR: /* Get interface address */
526 case SIOCGIFBRDADDR: /* Get the broadcast address */
527 case SIOCGIFDSTADDR: /* Get the destination address */
528 case SIOCGIFNETMASK: /* Get the netmask for the interface */
529 /* Note that these ioctls will not sleep,
530 so that we do not impose a lock.
531 One day we will be forced to put shlock here (I mean SMP)
533 tryaddrmatch = (sin_orig.sin_family == AF_INET);
534 memset(sin, 0, sizeof(*sin));
535 sin->sin_family = AF_INET;
540 if (!capable(CAP_NET_ADMIN))
543 case SIOCSIFADDR: /* Set interface address (and family) */
544 case SIOCSIFBRDADDR: /* Set the broadcast address */
545 case SIOCSIFDSTADDR: /* Set the destination address */
546 case SIOCSIFNETMASK: /* Set the netmask for the interface */
548 if (!capable(CAP_NET_ADMIN))
551 if (sin->sin_family != AF_INET)
562 if ((dev = __dev_get_by_name(ifr.ifr_name)) == NULL)
568 if ((in_dev = __in_dev_get(dev)) != NULL) {
570 /* Matthias Andree */
571 /* compare label and address (4.4BSD style) */
572 /* note: we only do this for a limited set of ioctls
573 and only if the original address family was AF_INET.
574 This is checked above. */
575 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
576 ifap = &ifa->ifa_next) {
577 if (!strcmp(ifr.ifr_name, ifa->ifa_label) &&
578 sin_orig.sin_addr.s_addr ==
584 /* we didn't get a match, maybe the application is
585 4.3BSD-style and passed in junk so we fall back to
586 comparing just the label */
588 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
589 ifap = &ifa->ifa_next)
590 if (!strcmp(ifr.ifr_name, ifa->ifa_label))
595 ret = -EADDRNOTAVAIL;
596 if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS)
600 case SIOCGIFADDR: /* Get interface address */
601 sin->sin_addr.s_addr = ifa->ifa_local;
604 case SIOCGIFBRDADDR: /* Get the broadcast address */
605 sin->sin_addr.s_addr = ifa->ifa_broadcast;
608 case SIOCGIFDSTADDR: /* Get the destination address */
609 sin->sin_addr.s_addr = ifa->ifa_address;
612 case SIOCGIFNETMASK: /* Get the netmask for the interface */
613 sin->sin_addr.s_addr = ifa->ifa_mask;
618 ret = -EADDRNOTAVAIL;
622 if (!(ifr.ifr_flags & IFF_UP))
623 inet_del_ifa(in_dev, ifap, 1);
626 ret = dev_change_flags(dev, ifr.ifr_flags);
629 case SIOCSIFADDR: /* Set interface address (and family) */
631 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
636 if ((ifa = inet_alloc_ifa()) == NULL)
639 memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ);
641 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
644 if (ifa->ifa_local == sin->sin_addr.s_addr)
646 inet_del_ifa(in_dev, ifap, 0);
647 ifa->ifa_broadcast = 0;
648 ifa->ifa_anycast = 0;
651 ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr;
653 if (!(dev->flags & IFF_POINTOPOINT)) {
654 ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address);
655 ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen);
656 if ((dev->flags & IFF_BROADCAST) &&
657 ifa->ifa_prefixlen < 31)
658 ifa->ifa_broadcast = ifa->ifa_address |
661 ifa->ifa_prefixlen = 32;
662 ifa->ifa_mask = inet_make_mask(32);
664 ret = inet_set_ifa(dev, ifa);
667 case SIOCSIFBRDADDR: /* Set the broadcast address */
669 if (ifa->ifa_broadcast != sin->sin_addr.s_addr) {
670 inet_del_ifa(in_dev, ifap, 0);
671 ifa->ifa_broadcast = sin->sin_addr.s_addr;
672 inet_insert_ifa(ifa);
676 case SIOCSIFDSTADDR: /* Set the destination address */
678 if (ifa->ifa_address == sin->sin_addr.s_addr)
681 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
684 inet_del_ifa(in_dev, ifap, 0);
685 ifa->ifa_address = sin->sin_addr.s_addr;
686 inet_insert_ifa(ifa);
689 case SIOCSIFNETMASK: /* Set the netmask for the interface */
692 * The mask we set must be legal.
695 if (bad_mask(sin->sin_addr.s_addr, 0))
698 if (ifa->ifa_mask != sin->sin_addr.s_addr) {
699 inet_del_ifa(in_dev, ifap, 0);
700 ifa->ifa_mask = sin->sin_addr.s_addr;
701 ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask);
702 inet_insert_ifa(ifa);
712 ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0;
716 static int inet_gifconf(struct net_device *dev, char *buf, int len)
718 struct in_device *in_dev = __in_dev_get(dev);
719 struct in_ifaddr *ifa;
723 if (!in_dev || (ifa = in_dev->ifa_list) == NULL)
726 for (; ifa; ifa = ifa->ifa_next) {
731 if (len < (int) sizeof(ifr))
733 memset(&ifr, 0, sizeof(struct ifreq));
735 strcpy(ifr.ifr_name, ifa->ifa_label);
737 strcpy(ifr.ifr_name, dev->name);
739 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET;
740 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr =
743 if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) {
747 buf += sizeof(struct ifreq);
748 len -= sizeof(struct ifreq);
749 done += sizeof(struct ifreq);
755 u32 inet_select_addr(const struct net_device *dev, u32 dst, int scope)
758 struct in_device *in_dev;
760 read_lock(&inetdev_lock);
761 in_dev = __in_dev_get(dev);
763 goto out_unlock_inetdev;
765 read_lock(&in_dev->lock);
766 for_primary_ifa(in_dev) {
767 if (ifa->ifa_scope > scope)
769 if (!dst || inet_ifa_match(dst, ifa)) {
770 addr = ifa->ifa_local;
774 addr = ifa->ifa_local;
775 } endfor_ifa(in_dev);
776 read_unlock(&in_dev->lock);
777 read_unlock(&inetdev_lock);
782 /* Not loopback addresses on loopback should be preferred
783 in this case. It is importnat that lo is the first interface
786 read_lock(&dev_base_lock);
787 read_lock(&inetdev_lock);
788 for (dev = dev_base; dev; dev = dev->next) {
789 if ((in_dev = __in_dev_get(dev)) == NULL)
792 read_lock(&in_dev->lock);
793 for_primary_ifa(in_dev) {
794 if (ifa->ifa_scope != RT_SCOPE_LINK &&
795 ifa->ifa_scope <= scope) {
796 read_unlock(&in_dev->lock);
797 addr = ifa->ifa_local;
798 goto out_unlock_both;
800 } endfor_ifa(in_dev);
801 read_unlock(&in_dev->lock);
804 read_unlock(&inetdev_lock);
805 read_unlock(&dev_base_lock);
809 read_unlock(&inetdev_lock);
813 static u32 confirm_addr_indev(struct in_device *in_dev, u32 dst,
814 u32 local, int scope)
821 (local == ifa->ifa_local || !local) &&
822 ifa->ifa_scope <= scope) {
823 addr = ifa->ifa_local;
828 same = (!local || inet_ifa_match(local, ifa)) &&
829 (!dst || inet_ifa_match(dst, ifa));
833 /* Is the selected addr into dst subnet? */
834 if (inet_ifa_match(addr, ifa))
836 /* No, then can we use new local src? */
837 if (ifa->ifa_scope <= scope) {
838 addr = ifa->ifa_local;
841 /* search for large dst subnet for addr */
845 } endfor_ifa(in_dev);
847 return same? addr : 0;
851 * Confirm that local IP address exists using wildcards:
852 * - dev: only on this interface, 0=any interface
853 * - dst: only in the same subnet as dst, 0=any dst
854 * - local: address, 0=autoselect the local address
855 * - scope: maximum allowed scope value for the local address
857 u32 inet_confirm_addr(const struct net_device *dev, u32 dst, u32 local, int scope)
860 struct in_device *in_dev;
863 read_lock(&inetdev_lock);
864 if ((in_dev = __in_dev_get(dev))) {
865 read_lock(&in_dev->lock);
866 addr = confirm_addr_indev(in_dev, dst, local, scope);
867 read_unlock(&in_dev->lock);
869 read_unlock(&inetdev_lock);
874 read_lock(&dev_base_lock);
875 read_lock(&inetdev_lock);
876 for (dev = dev_base; dev; dev = dev->next) {
877 if ((in_dev = __in_dev_get(dev))) {
878 read_lock(&in_dev->lock);
879 addr = confirm_addr_indev(in_dev, dst, local, scope);
880 read_unlock(&in_dev->lock);
885 read_unlock(&inetdev_lock);
886 read_unlock(&dev_base_lock);
895 int register_inetaddr_notifier(struct notifier_block *nb)
897 return notifier_chain_register(&inetaddr_chain, nb);
900 int unregister_inetaddr_notifier(struct notifier_block *nb)
902 return notifier_chain_unregister(&inetaddr_chain, nb);
905 /* Rename ifa_labels for a device name change. Make some effort to preserve existing
906 * alias numbering and to create unique labels if possible.
908 static void inetdev_changename(struct net_device *dev, struct in_device *in_dev)
910 struct in_ifaddr *ifa;
913 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
914 char old[IFNAMSIZ], *dot;
916 memcpy(old, ifa->ifa_label, IFNAMSIZ);
917 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
920 dot = strchr(ifa->ifa_label, ':');
922 sprintf(old, ":%d", named);
925 if (strlen(dot) + strlen(dev->name) < IFNAMSIZ) {
926 strcat(ifa->ifa_label, dot);
928 strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot);
933 /* Called only under RTNL semaphore */
935 static int inetdev_event(struct notifier_block *this, unsigned long event,
938 struct net_device *dev = ptr;
939 struct in_device *in_dev = __in_dev_get(dev);
947 case NETDEV_REGISTER:
948 printk(KERN_DEBUG "inetdev_event: bug\n");
954 if (dev == &loopback_dev) {
955 struct in_ifaddr *ifa;
956 if ((ifa = inet_alloc_ifa()) != NULL) {
958 ifa->ifa_address = htonl(INADDR_LOOPBACK);
959 ifa->ifa_prefixlen = 8;
960 ifa->ifa_mask = inet_make_mask(8);
962 ifa->ifa_dev = in_dev;
963 ifa->ifa_scope = RT_SCOPE_HOST;
964 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
965 inet_insert_ifa(ifa);
967 in_dev->cnf.no_xfrm = 1;
968 in_dev->cnf.no_policy = 1;
975 case NETDEV_CHANGEMTU:
978 /* MTU falled under 68, disable IP */
979 case NETDEV_UNREGISTER:
980 inetdev_destroy(in_dev);
982 case NETDEV_CHANGENAME:
983 /* Do not notify about label change, this event is
984 * not interesting to applications using netlink.
986 inetdev_changename(dev, in_dev);
989 devinet_sysctl_unregister(&in_dev->cnf);
990 neigh_sysctl_unregister(in_dev->arp_parms);
991 neigh_sysctl_register(dev, in_dev->arp_parms, NET_IPV4,
992 NET_IPV4_NEIGH, "ipv4", NULL);
993 devinet_sysctl_register(in_dev, &in_dev->cnf);
1001 static struct notifier_block ip_netdev_notifier = {
1002 .notifier_call =inetdev_event,
1005 static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
1006 u32 pid, u32 seq, int event)
1008 struct ifaddrmsg *ifm;
1009 struct nlmsghdr *nlh;
1010 unsigned char *b = skb->tail;
1012 nlh = NLMSG_PUT(skb, pid, seq, event, sizeof(*ifm));
1013 if (pid) nlh->nlmsg_flags |= NLM_F_MULTI;
1014 ifm = NLMSG_DATA(nlh);
1015 ifm->ifa_family = AF_INET;
1016 ifm->ifa_prefixlen = ifa->ifa_prefixlen;
1017 ifm->ifa_flags = ifa->ifa_flags|IFA_F_PERMANENT;
1018 ifm->ifa_scope = ifa->ifa_scope;
1019 ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
1020 if (ifa->ifa_address)
1021 RTA_PUT(skb, IFA_ADDRESS, 4, &ifa->ifa_address);
1023 RTA_PUT(skb, IFA_LOCAL, 4, &ifa->ifa_local);
1024 if (ifa->ifa_broadcast)
1025 RTA_PUT(skb, IFA_BROADCAST, 4, &ifa->ifa_broadcast);
1026 if (ifa->ifa_anycast)
1027 RTA_PUT(skb, IFA_ANYCAST, 4, &ifa->ifa_anycast);
1028 if (ifa->ifa_label[0])
1029 RTA_PUT(skb, IFA_LABEL, IFNAMSIZ, &ifa->ifa_label);
1030 nlh->nlmsg_len = skb->tail - b;
1035 skb_trim(skb, b - skb->data);
1039 static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
1042 struct net_device *dev;
1043 struct in_device *in_dev;
1044 struct in_ifaddr *ifa;
1045 int s_ip_idx, s_idx = cb->args[0];
1047 s_ip_idx = ip_idx = cb->args[1];
1048 read_lock(&dev_base_lock);
1049 for (dev = dev_base, idx = 0; dev; dev = dev->next, idx++) {
1054 read_lock(&inetdev_lock);
1055 if ((in_dev = __in_dev_get(dev)) == NULL) {
1056 read_unlock(&inetdev_lock);
1059 read_lock(&in_dev->lock);
1060 for (ifa = in_dev->ifa_list, ip_idx = 0; ifa;
1061 ifa = ifa->ifa_next, ip_idx++) {
1062 if (ip_idx < s_ip_idx)
1064 if (inet_fill_ifaddr(skb, ifa, NETLINK_CB(cb->skb).pid,
1066 RTM_NEWADDR) <= 0) {
1067 read_unlock(&in_dev->lock);
1068 read_unlock(&inetdev_lock);
1072 read_unlock(&in_dev->lock);
1073 read_unlock(&inetdev_lock);
1077 read_unlock(&dev_base_lock);
1079 cb->args[1] = ip_idx;
1084 static void rtmsg_ifa(int event, struct in_ifaddr* ifa)
1086 int size = NLMSG_SPACE(sizeof(struct ifaddrmsg) + 128);
1087 struct sk_buff *skb = alloc_skb(size, GFP_KERNEL);
1090 netlink_set_err(rtnl, 0, RTMGRP_IPV4_IFADDR, ENOBUFS);
1091 else if (inet_fill_ifaddr(skb, ifa, 0, 0, event) < 0) {
1093 netlink_set_err(rtnl, 0, RTMGRP_IPV4_IFADDR, EINVAL);
1095 NETLINK_CB(skb).dst_groups = RTMGRP_IPV4_IFADDR;
1096 netlink_broadcast(rtnl, skb, 0, RTMGRP_IPV4_IFADDR, GFP_KERNEL);
1100 static struct rtnetlink_link inet_rtnetlink_table[RTM_MAX - RTM_BASE + 1] = {
1101 [4] = { .doit = inet_rtm_newaddr, },
1102 [5] = { .doit = inet_rtm_deladdr, },
1103 [6] = { .dumpit = inet_dump_ifaddr, },
1104 [8] = { .doit = inet_rtm_newroute, },
1105 [9] = { .doit = inet_rtm_delroute, },
1106 [10] = { .doit = inet_rtm_getroute, .dumpit = inet_dump_fib, },
1107 #ifdef CONFIG_IP_MULTIPLE_TABLES
1108 [16] = { .doit = inet_rtm_newrule, },
1109 [17] = { .doit = inet_rtm_delrule, },
1110 [18] = { .dumpit = inet_dump_rules, },
1114 #ifdef CONFIG_SYSCTL
1116 void inet_forward_change(void)
1118 struct net_device *dev;
1119 int on = ipv4_devconf.forwarding;
1121 ipv4_devconf.accept_redirects = !on;
1122 ipv4_devconf_dflt.forwarding = on;
1124 read_lock(&dev_base_lock);
1125 for (dev = dev_base; dev; dev = dev->next) {
1126 struct in_device *in_dev;
1127 read_lock(&inetdev_lock);
1128 in_dev = __in_dev_get(dev);
1130 in_dev->cnf.forwarding = on;
1131 read_unlock(&inetdev_lock);
1133 read_unlock(&dev_base_lock);
1138 static int devinet_sysctl_forward(ctl_table *ctl, int write,
1139 struct file* filp, void *buffer,
1142 int *valp = ctl->data;
1144 int ret = proc_dointvec(ctl, write, filp, buffer, lenp);
1146 if (write && *valp != val) {
1147 if (valp == &ipv4_devconf.forwarding)
1148 inet_forward_change();
1149 else if (valp != &ipv4_devconf_dflt.forwarding)
1156 int ipv4_doint_and_flush(ctl_table *ctl, int write,
1157 struct file* filp, void *buffer,
1160 int *valp = ctl->data;
1162 int ret = proc_dointvec(ctl, write, filp, buffer, lenp);
1164 if (write && *valp != val)
1170 int ipv4_doint_and_flush_strategy(ctl_table *table, int *name, int nlen,
1171 void *oldval, size_t *oldlenp,
1172 void *newval, size_t newlen,
1175 int *valp = table->data;
1178 if (!newval || !newlen)
1181 if (newlen != sizeof(int))
1184 if (get_user(new, (int *)newval))
1190 if (oldval && oldlenp) {
1193 if (get_user(len, oldlenp))
1197 if (len > table->maxlen)
1198 len = table->maxlen;
1199 if (copy_to_user(oldval, valp, len))
1201 if (put_user(len, oldlenp))
1212 static struct devinet_sysctl_table {
1213 struct ctl_table_header *sysctl_header;
1214 ctl_table devinet_vars[20];
1215 ctl_table devinet_dev[2];
1216 ctl_table devinet_conf_dir[2];
1217 ctl_table devinet_proto_dir[2];
1218 ctl_table devinet_root_dir[2];
1219 } devinet_sysctl = {
1222 .ctl_name = NET_IPV4_CONF_FORWARDING,
1223 .procname = "forwarding",
1224 .data = &ipv4_devconf.forwarding,
1225 .maxlen = sizeof(int),
1227 .proc_handler = &devinet_sysctl_forward,
1230 .ctl_name = NET_IPV4_CONF_MC_FORWARDING,
1231 .procname = "mc_forwarding",
1232 .data = &ipv4_devconf.mc_forwarding,
1233 .maxlen = sizeof(int),
1235 .proc_handler = &proc_dointvec,
1238 .ctl_name = NET_IPV4_CONF_ACCEPT_REDIRECTS,
1239 .procname = "accept_redirects",
1240 .data = &ipv4_devconf.accept_redirects,
1241 .maxlen = sizeof(int),
1243 .proc_handler = &proc_dointvec,
1246 .ctl_name = NET_IPV4_CONF_SECURE_REDIRECTS,
1247 .procname = "secure_redirects",
1248 .data = &ipv4_devconf.secure_redirects,
1249 .maxlen = sizeof(int),
1251 .proc_handler = &proc_dointvec,
1254 .ctl_name = NET_IPV4_CONF_SHARED_MEDIA,
1255 .procname = "shared_media",
1256 .data = &ipv4_devconf.shared_media,
1257 .maxlen = sizeof(int),
1259 .proc_handler = &proc_dointvec,
1262 .ctl_name = NET_IPV4_CONF_RP_FILTER,
1263 .procname = "rp_filter",
1264 .data = &ipv4_devconf.rp_filter,
1265 .maxlen = sizeof(int),
1267 .proc_handler = &proc_dointvec,
1270 .ctl_name = NET_IPV4_CONF_SEND_REDIRECTS,
1271 .procname = "send_redirects",
1272 .data = &ipv4_devconf.send_redirects,
1273 .maxlen = sizeof(int),
1275 .proc_handler = &proc_dointvec,
1278 .ctl_name = NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE,
1279 .procname = "accept_source_route",
1280 .data = &ipv4_devconf.accept_source_route,
1281 .maxlen = sizeof(int),
1283 .proc_handler = &proc_dointvec,
1286 .ctl_name = NET_IPV4_CONF_PROXY_ARP,
1287 .procname = "proxy_arp",
1288 .data = &ipv4_devconf.proxy_arp,
1289 .maxlen = sizeof(int),
1291 .proc_handler = &proc_dointvec,
1294 .ctl_name = NET_IPV4_CONF_MEDIUM_ID,
1295 .procname = "medium_id",
1296 .data = &ipv4_devconf.medium_id,
1297 .maxlen = sizeof(int),
1299 .proc_handler = &proc_dointvec,
1302 .ctl_name = NET_IPV4_CONF_BOOTP_RELAY,
1303 .procname = "bootp_relay",
1304 .data = &ipv4_devconf.bootp_relay,
1305 .maxlen = sizeof(int),
1307 .proc_handler = &proc_dointvec,
1310 .ctl_name = NET_IPV4_CONF_LOG_MARTIANS,
1311 .procname = "log_martians",
1312 .data = &ipv4_devconf.log_martians,
1313 .maxlen = sizeof(int),
1315 .proc_handler = &proc_dointvec,
1318 .ctl_name = NET_IPV4_CONF_TAG,
1320 .data = &ipv4_devconf.tag,
1321 .maxlen = sizeof(int),
1323 .proc_handler = &proc_dointvec,
1326 .ctl_name = NET_IPV4_CONF_ARPFILTER,
1327 .procname = "arp_filter",
1328 .data = &ipv4_devconf.arp_filter,
1329 .maxlen = sizeof(int),
1331 .proc_handler = &proc_dointvec,
1334 .ctl_name = NET_IPV4_CONF_ARP_ANNOUNCE,
1335 .procname = "arp_announce",
1336 .data = &ipv4_devconf.arp_announce,
1337 .maxlen = sizeof(int),
1339 .proc_handler = &proc_dointvec,
1342 .ctl_name = NET_IPV4_CONF_ARP_IGNORE,
1343 .procname = "arp_ignore",
1344 .data = &ipv4_devconf.arp_ignore,
1345 .maxlen = sizeof(int),
1347 .proc_handler = &proc_dointvec,
1350 .ctl_name = NET_IPV4_CONF_NOXFRM,
1351 .procname = "disable_xfrm",
1352 .data = &ipv4_devconf.no_xfrm,
1353 .maxlen = sizeof(int),
1355 .proc_handler = &ipv4_doint_and_flush,
1356 .strategy = &ipv4_doint_and_flush_strategy,
1359 .ctl_name = NET_IPV4_CONF_NOPOLICY,
1360 .procname = "disable_policy",
1361 .data = &ipv4_devconf.no_policy,
1362 .maxlen = sizeof(int),
1364 .proc_handler = &ipv4_doint_and_flush,
1365 .strategy = &ipv4_doint_and_flush_strategy,
1368 .ctl_name = NET_IPV4_CONF_FORCE_IGMP_VERSION,
1369 .procname = "force_igmp_version",
1370 .data = &ipv4_devconf.force_igmp_version,
1371 .maxlen = sizeof(int),
1373 .proc_handler = &ipv4_doint_and_flush,
1374 .strategy = &ipv4_doint_and_flush_strategy,
1379 .ctl_name = NET_PROTO_CONF_ALL,
1382 .child = devinet_sysctl.devinet_vars,
1385 .devinet_conf_dir = {
1387 .ctl_name = NET_IPV4_CONF,
1390 .child = devinet_sysctl.devinet_dev,
1393 .devinet_proto_dir = {
1395 .ctl_name = NET_IPV4,
1398 .child = devinet_sysctl.devinet_conf_dir,
1401 .devinet_root_dir = {
1403 .ctl_name = CTL_NET,
1406 .child = devinet_sysctl.devinet_proto_dir,
1411 static void devinet_sysctl_register(struct in_device *in_dev,
1412 struct ipv4_devconf *p)
1415 struct net_device *dev = in_dev ? in_dev->dev : NULL;
1416 struct devinet_sysctl_table *t = kmalloc(sizeof(*t), GFP_KERNEL);
1417 char *dev_name = NULL;
1421 memcpy(t, &devinet_sysctl, sizeof(*t));
1422 for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
1423 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
1424 t->devinet_vars[i].de = NULL;
1428 dev_name = dev->name;
1429 t->devinet_dev[0].ctl_name = dev->ifindex;
1431 dev_name = "default";
1432 t->devinet_dev[0].ctl_name = NET_PROTO_CONF_DEFAULT;
1436 * Make a copy of dev_name, because '.procname' is regarded as const
1437 * by sysctl and we wouldn't want anyone to change it under our feet
1438 * (see SIOCSIFNAME).
1440 dev_name = net_sysctl_strdup(dev_name);
1444 t->devinet_dev[0].procname = dev_name;
1445 t->devinet_dev[0].child = t->devinet_vars;
1446 t->devinet_dev[0].de = NULL;
1447 t->devinet_conf_dir[0].child = t->devinet_dev;
1448 t->devinet_conf_dir[0].de = NULL;
1449 t->devinet_proto_dir[0].child = t->devinet_conf_dir;
1450 t->devinet_proto_dir[0].de = NULL;
1451 t->devinet_root_dir[0].child = t->devinet_proto_dir;
1452 t->devinet_root_dir[0].de = NULL;
1454 t->sysctl_header = register_sysctl_table(t->devinet_root_dir, 0);
1455 if (!t->sysctl_header)
1469 static void devinet_sysctl_unregister(struct ipv4_devconf *p)
1472 struct devinet_sysctl_table *t = p->sysctl;
1474 unregister_sysctl_table(t->sysctl_header);
1475 kfree(t->devinet_dev[0].procname);
1481 void __init devinet_init(void)
1483 register_gifconf(PF_INET, inet_gifconf);
1484 register_netdevice_notifier(&ip_netdev_notifier);
1485 rtnetlink_links[PF_INET] = inet_rtnetlink_table;
1486 #ifdef CONFIG_SYSCTL
1487 devinet_sysctl.sysctl_header =
1488 register_sysctl_table(devinet_sysctl.devinet_root_dir, 0);
1489 devinet_sysctl_register(NULL, &ipv4_devconf_dflt);
1493 EXPORT_SYMBOL(devinet_ioctl);
1494 EXPORT_SYMBOL(in_dev_finish_destroy);
1495 EXPORT_SYMBOL(inet_select_addr);
1496 EXPORT_SYMBOL(inetdev_by_index);
1497 EXPORT_SYMBOL(inetdev_lock);
1498 EXPORT_SYMBOL(register_inetaddr_notifier);
1499 EXPORT_SYMBOL(unregister_inetaddr_notifier);