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
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
31 #include <asm/uaccess.h>
32 #include <asm/system.h>
33 #include <linux/bitops.h>
34 #include <linux/capability.h>
35 #include <linux/module.h>
36 #include <linux/types.h>
37 #include <linux/kernel.h>
38 #include <linux/sched.h>
39 #include <linux/string.h>
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>
63 #include <net/route.h>
64 #include <net/ip_fib.h>
66 struct ipv4_devconf ipv4_devconf = {
67 .accept_redirects = 1,
69 .secure_redirects = 1,
73 static struct ipv4_devconf ipv4_devconf_dflt = {
74 .accept_redirects = 1,
76 .secure_redirects = 1,
78 .accept_source_route = 1,
81 static void rtmsg_ifa(int event, struct in_ifaddr *);
83 static BLOCKING_NOTIFIER_HEAD(inetaddr_chain);
84 static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
87 static void devinet_sysctl_register(struct in_device *in_dev,
88 struct ipv4_devconf *p);
89 static void devinet_sysctl_unregister(struct ipv4_devconf *p);
92 /* Locks all the inet devices. */
94 static struct in_ifaddr *inet_alloc_ifa(void)
96 struct in_ifaddr *ifa = kzalloc(sizeof(*ifa), GFP_KERNEL);
99 INIT_RCU_HEAD(&ifa->rcu_head);
105 static void inet_rcu_free_ifa(struct rcu_head *head)
107 struct in_ifaddr *ifa = container_of(head, struct in_ifaddr, rcu_head);
109 in_dev_put(ifa->ifa_dev);
113 static inline void inet_free_ifa(struct in_ifaddr *ifa)
115 call_rcu(&ifa->rcu_head, inet_rcu_free_ifa);
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);
136 struct in_device *inetdev_init(struct net_device *dev)
138 struct in_device *in_dev;
142 in_dev = kzalloc(sizeof(*in_dev), GFP_KERNEL);
145 INIT_RCU_HEAD(&in_dev->rcu_head);
146 memcpy(&in_dev->cnf, &ipv4_devconf_dflt, sizeof(in_dev->cnf));
147 in_dev->cnf.sysctl = NULL;
149 if ((in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl)) == NULL)
151 /* Reference in_dev->dev */
154 neigh_sysctl_register(dev, in_dev->arp_parms, NET_IPV4,
155 NET_IPV4_NEIGH, "ipv4", NULL, NULL);
158 /* Account for reference dev->ip_ptr */
160 rcu_assign_pointer(dev->ip_ptr, in_dev);
163 devinet_sysctl_register(in_dev, &in_dev->cnf);
165 ip_mc_init_dev(in_dev);
166 if (dev->flags & IFF_UP)
176 static void in_dev_rcu_put(struct rcu_head *head)
178 struct in_device *idev = container_of(head, struct in_device, rcu_head);
182 static void inetdev_destroy(struct in_device *in_dev)
184 struct in_ifaddr *ifa;
185 struct net_device *dev;
190 if (dev == &loopback_dev)
195 ip_mc_destroy_dev(in_dev);
197 while ((ifa = in_dev->ifa_list) != NULL) {
198 inet_del_ifa(in_dev, &in_dev->ifa_list, 0);
203 devinet_sysctl_unregister(&in_dev->cnf);
209 neigh_sysctl_unregister(in_dev->arp_parms);
211 neigh_parms_release(&arp_tbl, in_dev->arp_parms);
214 call_rcu(&in_dev->rcu_head, in_dev_rcu_put);
217 int inet_addr_onlink(struct in_device *in_dev, u32 a, u32 b)
220 for_primary_ifa(in_dev) {
221 if (inet_ifa_match(a, ifa)) {
222 if (!b || inet_ifa_match(b, ifa)) {
227 } endfor_ifa(in_dev);
232 static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
235 struct in_ifaddr *promote = NULL;
236 struct in_ifaddr *ifa, *ifa1 = *ifap;
237 struct in_ifaddr *last_prim = in_dev->ifa_list;
238 struct in_ifaddr *prev_prom = NULL;
239 int do_promote = IN_DEV_PROMOTE_SECONDARIES(in_dev);
243 /* 1. Deleting primary ifaddr forces deletion all secondaries
244 * unless alias promotion is set
247 if (!(ifa1->ifa_flags & IFA_F_SECONDARY)) {
248 struct in_ifaddr **ifap1 = &ifa1->ifa_next;
250 while ((ifa = *ifap1) != NULL) {
251 if (!(ifa->ifa_flags & IFA_F_SECONDARY) &&
252 ifa1->ifa_scope <= ifa->ifa_scope)
255 if (!(ifa->ifa_flags & IFA_F_SECONDARY) ||
256 ifa1->ifa_mask != ifa->ifa_mask ||
257 !inet_ifa_match(ifa1->ifa_address, ifa)) {
258 ifap1 = &ifa->ifa_next;
264 *ifap1 = ifa->ifa_next;
266 rtmsg_ifa(RTM_DELADDR, ifa);
267 blocking_notifier_call_chain(&inetaddr_chain,
279 *ifap = ifa1->ifa_next;
281 /* 3. Announce address deletion */
283 /* Send message first, then call notifier.
284 At first sight, FIB update triggered by notifier
285 will refer to already deleted ifaddr, that could confuse
286 netlink listeners. It is not true: look, gated sees
287 that route deleted and if it still thinks that ifaddr
288 is valid, it will try to restore deleted routes... Grr.
289 So that, this order is correct.
291 rtmsg_ifa(RTM_DELADDR, ifa1);
292 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1);
297 prev_prom->ifa_next = promote->ifa_next;
298 promote->ifa_next = last_prim->ifa_next;
299 last_prim->ifa_next = promote;
302 promote->ifa_flags &= ~IFA_F_SECONDARY;
303 rtmsg_ifa(RTM_NEWADDR, promote);
304 blocking_notifier_call_chain(&inetaddr_chain,
306 for (ifa = promote->ifa_next; ifa; ifa = ifa->ifa_next) {
307 if (ifa1->ifa_mask != ifa->ifa_mask ||
308 !inet_ifa_match(ifa1->ifa_address, ifa))
317 if (!in_dev->ifa_list)
318 inetdev_destroy(in_dev);
322 static int inet_insert_ifa(struct in_ifaddr *ifa)
324 struct in_device *in_dev = ifa->ifa_dev;
325 struct in_ifaddr *ifa1, **ifap, **last_primary;
329 if (!ifa->ifa_local) {
334 ifa->ifa_flags &= ~IFA_F_SECONDARY;
335 last_primary = &in_dev->ifa_list;
337 for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL;
338 ifap = &ifa1->ifa_next) {
339 if (!(ifa1->ifa_flags & IFA_F_SECONDARY) &&
340 ifa->ifa_scope <= ifa1->ifa_scope)
341 last_primary = &ifa1->ifa_next;
342 if (ifa1->ifa_mask == ifa->ifa_mask &&
343 inet_ifa_match(ifa1->ifa_address, ifa)) {
344 if (ifa1->ifa_local == ifa->ifa_local) {
348 if (ifa1->ifa_scope != ifa->ifa_scope) {
352 ifa->ifa_flags |= IFA_F_SECONDARY;
356 if (!(ifa->ifa_flags & IFA_F_SECONDARY)) {
357 net_srandom(ifa->ifa_local);
361 ifa->ifa_next = *ifap;
364 /* Send message first, then call notifier.
365 Notifier will trigger FIB update, so that
366 listeners of netlink will know about new ifaddr */
367 rtmsg_ifa(RTM_NEWADDR, ifa);
368 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
373 static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa)
375 struct in_device *in_dev = __in_dev_get_rtnl(dev);
380 in_dev = inetdev_init(dev);
386 if (ifa->ifa_dev != in_dev) {
387 BUG_TRAP(!ifa->ifa_dev);
389 ifa->ifa_dev = in_dev;
391 if (LOOPBACK(ifa->ifa_local))
392 ifa->ifa_scope = RT_SCOPE_HOST;
393 return inet_insert_ifa(ifa);
396 struct in_device *inetdev_by_index(int ifindex)
398 struct net_device *dev;
399 struct in_device *in_dev = NULL;
400 read_lock(&dev_base_lock);
401 dev = __dev_get_by_index(ifindex);
403 in_dev = in_dev_get(dev);
404 read_unlock(&dev_base_lock);
408 /* Called only from RTNL semaphored context. No locks. */
410 struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, u32 prefix,
415 for_primary_ifa(in_dev) {
416 if (ifa->ifa_mask == mask && inet_ifa_match(prefix, ifa))
418 } endfor_ifa(in_dev);
422 static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
424 struct rtattr **rta = arg;
425 struct in_device *in_dev;
426 struct ifaddrmsg *ifm = NLMSG_DATA(nlh);
427 struct in_ifaddr *ifa, **ifap;
431 if ((in_dev = inetdev_by_index(ifm->ifa_index)) == NULL)
433 __in_dev_put(in_dev);
435 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
436 ifap = &ifa->ifa_next) {
437 if ((rta[IFA_LOCAL - 1] &&
438 memcmp(RTA_DATA(rta[IFA_LOCAL - 1]),
439 &ifa->ifa_local, 4)) ||
440 (rta[IFA_LABEL - 1] &&
441 rtattr_strcmp(rta[IFA_LABEL - 1], ifa->ifa_label)) ||
442 (rta[IFA_ADDRESS - 1] &&
443 (ifm->ifa_prefixlen != ifa->ifa_prefixlen ||
444 !inet_ifa_match(*(u32*)RTA_DATA(rta[IFA_ADDRESS - 1]),
447 inet_del_ifa(in_dev, ifap, 1);
451 return -EADDRNOTAVAIL;
454 static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
456 struct rtattr **rta = arg;
457 struct net_device *dev;
458 struct in_device *in_dev;
459 struct ifaddrmsg *ifm = NLMSG_DATA(nlh);
460 struct in_ifaddr *ifa;
465 if (ifm->ifa_prefixlen > 32 || !rta[IFA_LOCAL - 1])
469 if ((dev = __dev_get_by_index(ifm->ifa_index)) == NULL)
473 if ((in_dev = __in_dev_get_rtnl(dev)) == NULL) {
474 in_dev = inetdev_init(dev);
479 if ((ifa = inet_alloc_ifa()) == NULL)
482 if (!rta[IFA_ADDRESS - 1])
483 rta[IFA_ADDRESS - 1] = rta[IFA_LOCAL - 1];
484 memcpy(&ifa->ifa_local, RTA_DATA(rta[IFA_LOCAL - 1]), 4);
485 memcpy(&ifa->ifa_address, RTA_DATA(rta[IFA_ADDRESS - 1]), 4);
486 ifa->ifa_prefixlen = ifm->ifa_prefixlen;
487 ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen);
488 if (rta[IFA_BROADCAST - 1])
489 memcpy(&ifa->ifa_broadcast,
490 RTA_DATA(rta[IFA_BROADCAST - 1]), 4);
491 if (rta[IFA_ANYCAST - 1])
492 memcpy(&ifa->ifa_anycast, RTA_DATA(rta[IFA_ANYCAST - 1]), 4);
493 ifa->ifa_flags = ifm->ifa_flags;
494 ifa->ifa_scope = ifm->ifa_scope;
496 ifa->ifa_dev = in_dev;
497 if (rta[IFA_LABEL - 1])
498 rtattr_strlcpy(ifa->ifa_label, rta[IFA_LABEL - 1], IFNAMSIZ);
500 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
502 rc = inet_insert_ifa(ifa);
508 * Determine a default network mask, based on the IP address.
511 static __inline__ int inet_abc_len(u32 addr)
513 int rc = -1; /* Something else, probably a multicast. */
522 else if (IN_CLASSB(addr))
524 else if (IN_CLASSC(addr))
532 int devinet_ioctl(unsigned int cmd, void __user *arg)
535 struct sockaddr_in sin_orig;
536 struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
537 struct in_device *in_dev;
538 struct in_ifaddr **ifap = NULL;
539 struct in_ifaddr *ifa = NULL;
540 struct net_device *dev;
543 int tryaddrmatch = 0;
546 * Fetch the caller's info block into kernel space
549 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
551 ifr.ifr_name[IFNAMSIZ - 1] = 0;
553 /* save original address for comparison */
554 memcpy(&sin_orig, sin, sizeof(*sin));
556 colon = strchr(ifr.ifr_name, ':');
561 dev_load(ifr.ifr_name);
565 case SIOCGIFADDR: /* Get interface address */
566 case SIOCGIFBRDADDR: /* Get the broadcast address */
567 case SIOCGIFDSTADDR: /* Get the destination address */
568 case SIOCGIFNETMASK: /* Get the netmask for the interface */
569 /* Note that these ioctls will not sleep,
570 so that we do not impose a lock.
571 One day we will be forced to put shlock here (I mean SMP)
573 tryaddrmatch = (sin_orig.sin_family == AF_INET);
574 memset(sin, 0, sizeof(*sin));
575 sin->sin_family = AF_INET;
580 if (!capable(CAP_NET_ADMIN))
583 case SIOCSIFADDR: /* Set interface address (and family) */
584 case SIOCSIFBRDADDR: /* Set the broadcast address */
585 case SIOCSIFDSTADDR: /* Set the destination address */
586 case SIOCSIFNETMASK: /* Set the netmask for the interface */
588 if (!capable(CAP_NET_ADMIN))
591 if (sin->sin_family != AF_INET)
602 if ((dev = __dev_get_by_name(ifr.ifr_name)) == NULL)
608 if ((in_dev = __in_dev_get_rtnl(dev)) != NULL) {
609 struct nx_info *nxi = current->nx_info;
610 int hide_netif = vx_flags(VXF_HIDE_NETIF, 0);
613 /* Matthias Andree */
614 /* compare label and address (4.4BSD style) */
615 /* note: we only do this for a limited set of ioctls
616 and only if the original address family was AF_INET.
617 This is checked above. */
618 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
619 ifap = &ifa->ifa_next) {
620 if (hide_netif && !ifa_in_nx_info(ifa, nxi))
622 if (!strcmp(ifr.ifr_name, ifa->ifa_label) &&
623 sin_orig.sin_addr.s_addr ==
629 /* we didn't get a match, maybe the application is
630 4.3BSD-style and passed in junk so we fall back to
631 comparing just the label */
633 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
634 ifap = &ifa->ifa_next) {
635 if (hide_netif && !ifa_in_nx_info(ifa, nxi))
637 if (!strcmp(ifr.ifr_name, ifa->ifa_label))
643 ret = -EADDRNOTAVAIL;
644 if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS)
648 case SIOCGIFADDR: /* Get interface address */
649 sin->sin_addr.s_addr = ifa->ifa_local;
652 case SIOCGIFBRDADDR: /* Get the broadcast address */
653 sin->sin_addr.s_addr = ifa->ifa_broadcast;
656 case SIOCGIFDSTADDR: /* Get the destination address */
657 sin->sin_addr.s_addr = ifa->ifa_address;
660 case SIOCGIFNETMASK: /* Get the netmask for the interface */
661 sin->sin_addr.s_addr = ifa->ifa_mask;
666 ret = -EADDRNOTAVAIL;
670 if (!(ifr.ifr_flags & IFF_UP))
671 inet_del_ifa(in_dev, ifap, 1);
674 ret = dev_change_flags(dev, ifr.ifr_flags);
677 case SIOCSIFADDR: /* Set interface address (and family) */
679 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
684 if ((ifa = inet_alloc_ifa()) == NULL)
687 memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ);
689 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
692 if (ifa->ifa_local == sin->sin_addr.s_addr)
694 inet_del_ifa(in_dev, ifap, 0);
695 ifa->ifa_broadcast = 0;
696 ifa->ifa_anycast = 0;
699 ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr;
701 if (!(dev->flags & IFF_POINTOPOINT)) {
702 ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address);
703 ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen);
704 if ((dev->flags & IFF_BROADCAST) &&
705 ifa->ifa_prefixlen < 31)
706 ifa->ifa_broadcast = ifa->ifa_address |
709 ifa->ifa_prefixlen = 32;
710 ifa->ifa_mask = inet_make_mask(32);
712 ret = inet_set_ifa(dev, ifa);
715 case SIOCSIFBRDADDR: /* Set the broadcast address */
717 if (ifa->ifa_broadcast != sin->sin_addr.s_addr) {
718 inet_del_ifa(in_dev, ifap, 0);
719 ifa->ifa_broadcast = sin->sin_addr.s_addr;
720 inet_insert_ifa(ifa);
724 case SIOCSIFDSTADDR: /* Set the destination address */
726 if (ifa->ifa_address == sin->sin_addr.s_addr)
729 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
732 inet_del_ifa(in_dev, ifap, 0);
733 ifa->ifa_address = sin->sin_addr.s_addr;
734 inet_insert_ifa(ifa);
737 case SIOCSIFNETMASK: /* Set the netmask for the interface */
740 * The mask we set must be legal.
743 if (bad_mask(sin->sin_addr.s_addr, 0))
746 if (ifa->ifa_mask != sin->sin_addr.s_addr) {
747 u32 old_mask = ifa->ifa_mask;
748 inet_del_ifa(in_dev, ifap, 0);
749 ifa->ifa_mask = sin->sin_addr.s_addr;
750 ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask);
752 /* See if current broadcast address matches
753 * with current netmask, then recalculate
754 * the broadcast address. Otherwise it's a
755 * funny address, so don't touch it since
756 * the user seems to know what (s)he's doing...
758 if ((dev->flags & IFF_BROADCAST) &&
759 (ifa->ifa_prefixlen < 31) &&
760 (ifa->ifa_broadcast ==
761 (ifa->ifa_local|~old_mask))) {
762 ifa->ifa_broadcast = (ifa->ifa_local |
763 ~sin->sin_addr.s_addr);
765 inet_insert_ifa(ifa);
775 ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0;
779 static int inet_gifconf(struct net_device *dev, char __user *buf, int len)
781 struct in_device *in_dev = __in_dev_get_rtnl(dev);
782 struct in_ifaddr *ifa;
786 if (!in_dev || (ifa = in_dev->ifa_list) == NULL)
789 for (; ifa; ifa = ifa->ifa_next) {
790 if (vx_flags(VXF_HIDE_NETIF, 0) &&
791 !ifa_in_nx_info(ifa, current->nx_info))
797 if (len < (int) sizeof(ifr))
799 memset(&ifr, 0, sizeof(struct ifreq));
801 strcpy(ifr.ifr_name, ifa->ifa_label);
803 strcpy(ifr.ifr_name, dev->name);
805 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET;
806 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr =
809 if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) {
813 buf += sizeof(struct ifreq);
814 len -= sizeof(struct ifreq);
815 done += sizeof(struct ifreq);
821 u32 inet_select_addr(const struct net_device *dev, u32 dst, int scope)
824 struct in_device *in_dev;
827 in_dev = __in_dev_get_rcu(dev);
831 for_primary_ifa(in_dev) {
832 if (ifa->ifa_scope > scope)
834 if (!dst || inet_ifa_match(dst, ifa)) {
835 addr = ifa->ifa_local;
839 addr = ifa->ifa_local;
840 } endfor_ifa(in_dev);
847 /* Not loopback addresses on loopback should be preferred
848 in this case. It is importnat that lo is the first interface
851 read_lock(&dev_base_lock);
853 for (dev = dev_base; dev; dev = dev->next) {
854 if ((in_dev = __in_dev_get_rcu(dev)) == NULL)
857 for_primary_ifa(in_dev) {
858 if (ifa->ifa_scope != RT_SCOPE_LINK &&
859 ifa->ifa_scope <= scope) {
860 addr = ifa->ifa_local;
861 goto out_unlock_both;
863 } endfor_ifa(in_dev);
866 read_unlock(&dev_base_lock);
872 static u32 confirm_addr_indev(struct in_device *in_dev, u32 dst,
873 u32 local, int scope)
880 (local == ifa->ifa_local || !local) &&
881 ifa->ifa_scope <= scope) {
882 addr = ifa->ifa_local;
887 same = (!local || inet_ifa_match(local, ifa)) &&
888 (!dst || inet_ifa_match(dst, ifa));
892 /* Is the selected addr into dst subnet? */
893 if (inet_ifa_match(addr, ifa))
895 /* No, then can we use new local src? */
896 if (ifa->ifa_scope <= scope) {
897 addr = ifa->ifa_local;
900 /* search for large dst subnet for addr */
904 } endfor_ifa(in_dev);
906 return same? addr : 0;
910 * Confirm that local IP address exists using wildcards:
911 * - dev: only on this interface, 0=any interface
912 * - dst: only in the same subnet as dst, 0=any dst
913 * - local: address, 0=autoselect the local address
914 * - scope: maximum allowed scope value for the local address
916 u32 inet_confirm_addr(const struct net_device *dev, u32 dst, u32 local, int scope)
919 struct in_device *in_dev;
923 if ((in_dev = __in_dev_get_rcu(dev)))
924 addr = confirm_addr_indev(in_dev, dst, local, scope);
930 read_lock(&dev_base_lock);
932 for (dev = dev_base; dev; dev = dev->next) {
933 if ((in_dev = __in_dev_get_rcu(dev))) {
934 addr = confirm_addr_indev(in_dev, dst, local, scope);
940 read_unlock(&dev_base_lock);
949 int register_inetaddr_notifier(struct notifier_block *nb)
951 return blocking_notifier_chain_register(&inetaddr_chain, nb);
954 int unregister_inetaddr_notifier(struct notifier_block *nb)
956 return blocking_notifier_chain_unregister(&inetaddr_chain, nb);
959 /* Rename ifa_labels for a device name change. Make some effort to preserve existing
960 * alias numbering and to create unique labels if possible.
962 static void inetdev_changename(struct net_device *dev, struct in_device *in_dev)
964 struct in_ifaddr *ifa;
967 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
968 char old[IFNAMSIZ], *dot;
970 memcpy(old, ifa->ifa_label, IFNAMSIZ);
971 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
974 dot = strchr(ifa->ifa_label, ':');
976 sprintf(old, ":%d", named);
979 if (strlen(dot) + strlen(dev->name) < IFNAMSIZ) {
980 strcat(ifa->ifa_label, dot);
982 strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot);
987 /* Called only under RTNL semaphore */
989 static int inetdev_event(struct notifier_block *this, unsigned long event,
992 struct net_device *dev = ptr;
993 struct in_device *in_dev = __in_dev_get_rtnl(dev);
998 if (event == NETDEV_REGISTER && dev == &loopback_dev) {
999 in_dev = inetdev_init(dev);
1001 panic("devinet: Failed to create loopback\n");
1002 in_dev->cnf.no_xfrm = 1;
1003 in_dev->cnf.no_policy = 1;
1009 case NETDEV_REGISTER:
1010 printk(KERN_DEBUG "inetdev_event: bug\n");
1016 if (dev == &loopback_dev) {
1017 struct in_ifaddr *ifa;
1018 if ((ifa = inet_alloc_ifa()) != NULL) {
1020 ifa->ifa_address = htonl(INADDR_LOOPBACK);
1021 ifa->ifa_prefixlen = 8;
1022 ifa->ifa_mask = inet_make_mask(8);
1023 in_dev_hold(in_dev);
1024 ifa->ifa_dev = in_dev;
1025 ifa->ifa_scope = RT_SCOPE_HOST;
1026 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1027 inet_insert_ifa(ifa);
1035 case NETDEV_CHANGEMTU:
1038 /* MTU falled under 68, disable IP */
1039 case NETDEV_UNREGISTER:
1040 inetdev_destroy(in_dev);
1042 case NETDEV_CHANGENAME:
1043 /* Do not notify about label change, this event is
1044 * not interesting to applications using netlink.
1046 inetdev_changename(dev, in_dev);
1048 #ifdef CONFIG_SYSCTL
1049 devinet_sysctl_unregister(&in_dev->cnf);
1050 neigh_sysctl_unregister(in_dev->arp_parms);
1051 neigh_sysctl_register(dev, in_dev->arp_parms, NET_IPV4,
1052 NET_IPV4_NEIGH, "ipv4", NULL, NULL);
1053 devinet_sysctl_register(in_dev, &in_dev->cnf);
1061 static struct notifier_block ip_netdev_notifier = {
1062 .notifier_call =inetdev_event,
1065 static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
1066 u32 pid, u32 seq, int event, unsigned int flags)
1068 struct ifaddrmsg *ifm;
1069 struct nlmsghdr *nlh;
1070 unsigned char *b = skb->tail;
1072 nlh = NLMSG_NEW(skb, pid, seq, event, sizeof(*ifm), flags);
1073 ifm = NLMSG_DATA(nlh);
1074 ifm->ifa_family = AF_INET;
1075 ifm->ifa_prefixlen = ifa->ifa_prefixlen;
1076 ifm->ifa_flags = ifa->ifa_flags|IFA_F_PERMANENT;
1077 ifm->ifa_scope = ifa->ifa_scope;
1078 ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
1079 if (ifa->ifa_address)
1080 RTA_PUT(skb, IFA_ADDRESS, 4, &ifa->ifa_address);
1082 RTA_PUT(skb, IFA_LOCAL, 4, &ifa->ifa_local);
1083 if (ifa->ifa_broadcast)
1084 RTA_PUT(skb, IFA_BROADCAST, 4, &ifa->ifa_broadcast);
1085 if (ifa->ifa_anycast)
1086 RTA_PUT(skb, IFA_ANYCAST, 4, &ifa->ifa_anycast);
1087 if (ifa->ifa_label[0])
1088 RTA_PUT(skb, IFA_LABEL, IFNAMSIZ, &ifa->ifa_label);
1089 nlh->nlmsg_len = skb->tail - b;
1094 skb_trim(skb, b - skb->data);
1098 static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
1101 struct net_device *dev;
1102 struct in_device *in_dev;
1103 struct in_ifaddr *ifa;
1104 struct sock *sk = skb->sk;
1105 int s_ip_idx, s_idx = cb->args[0];
1107 s_ip_idx = ip_idx = cb->args[1];
1108 read_lock(&dev_base_lock);
1109 for (dev = dev_base, idx = 0; dev; dev = dev->next, idx++) {
1115 if ((in_dev = __in_dev_get_rcu(dev)) == NULL) {
1120 for (ifa = in_dev->ifa_list, ip_idx = 0; ifa;
1121 ifa = ifa->ifa_next, ip_idx++) {
1122 if (sk && vx_info_flags(sk->sk_vx_info, VXF_HIDE_NETIF, 0) &&
1123 !ifa_in_nx_info(ifa, sk->sk_nx_info))
1125 if (ip_idx < s_ip_idx)
1127 if (inet_fill_ifaddr(skb, ifa, NETLINK_CB(cb->skb).pid,
1129 RTM_NEWADDR, NLM_F_MULTI) <= 0) {
1138 read_unlock(&dev_base_lock);
1140 cb->args[1] = ip_idx;
1145 static void rtmsg_ifa(int event, struct in_ifaddr* ifa)
1147 int size = NLMSG_SPACE(sizeof(struct ifaddrmsg) + 128);
1148 struct sk_buff *skb = alloc_skb(size, GFP_KERNEL);
1151 netlink_set_err(rtnl, 0, RTNLGRP_IPV4_IFADDR, ENOBUFS);
1152 else if (inet_fill_ifaddr(skb, ifa, 0, 0, event, 0) < 0) {
1154 netlink_set_err(rtnl, 0, RTNLGRP_IPV4_IFADDR, EINVAL);
1156 netlink_broadcast(rtnl, skb, 0, RTNLGRP_IPV4_IFADDR, GFP_KERNEL);
1160 static struct rtnetlink_link inet_rtnetlink_table[RTM_NR_MSGTYPES] = {
1161 [RTM_NEWADDR - RTM_BASE] = { .doit = inet_rtm_newaddr, },
1162 [RTM_DELADDR - RTM_BASE] = { .doit = inet_rtm_deladdr, },
1163 [RTM_GETADDR - RTM_BASE] = { .dumpit = inet_dump_ifaddr, },
1164 [RTM_NEWROUTE - RTM_BASE] = { .doit = inet_rtm_newroute, },
1165 [RTM_DELROUTE - RTM_BASE] = { .doit = inet_rtm_delroute, },
1166 [RTM_GETROUTE - RTM_BASE] = { .doit = inet_rtm_getroute,
1167 .dumpit = inet_dump_fib, },
1168 #ifdef CONFIG_IP_MULTIPLE_TABLES
1169 [RTM_NEWRULE - RTM_BASE] = { .doit = inet_rtm_newrule, },
1170 [RTM_DELRULE - RTM_BASE] = { .doit = inet_rtm_delrule, },
1171 [RTM_GETRULE - RTM_BASE] = { .dumpit = inet_dump_rules, },
1175 #ifdef CONFIG_SYSCTL
1177 void inet_forward_change(void)
1179 struct net_device *dev;
1180 int on = ipv4_devconf.forwarding;
1182 ipv4_devconf.accept_redirects = !on;
1183 ipv4_devconf_dflt.forwarding = on;
1185 read_lock(&dev_base_lock);
1186 for (dev = dev_base; dev; dev = dev->next) {
1187 struct in_device *in_dev;
1189 in_dev = __in_dev_get_rcu(dev);
1191 in_dev->cnf.forwarding = on;
1194 read_unlock(&dev_base_lock);
1199 static int devinet_sysctl_forward(ctl_table *ctl, int write,
1200 struct file* filp, void __user *buffer,
1201 size_t *lenp, loff_t *ppos)
1203 int *valp = ctl->data;
1205 int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1207 if (write && *valp != val) {
1208 if (valp == &ipv4_devconf.forwarding)
1209 inet_forward_change();
1210 else if (valp != &ipv4_devconf_dflt.forwarding)
1217 int ipv4_doint_and_flush(ctl_table *ctl, int write,
1218 struct file* filp, void __user *buffer,
1219 size_t *lenp, loff_t *ppos)
1221 int *valp = ctl->data;
1223 int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1225 if (write && *valp != val)
1231 int ipv4_doint_and_flush_strategy(ctl_table *table, int __user *name, int nlen,
1232 void __user *oldval, size_t __user *oldlenp,
1233 void __user *newval, size_t newlen,
1236 int *valp = table->data;
1239 if (!newval || !newlen)
1242 if (newlen != sizeof(int))
1245 if (get_user(new, (int __user *)newval))
1251 if (oldval && oldlenp) {
1254 if (get_user(len, oldlenp))
1258 if (len > table->maxlen)
1259 len = table->maxlen;
1260 if (copy_to_user(oldval, valp, len))
1262 if (put_user(len, oldlenp))
1273 static struct devinet_sysctl_table {
1274 struct ctl_table_header *sysctl_header;
1275 ctl_table devinet_vars[__NET_IPV4_CONF_MAX];
1276 ctl_table devinet_dev[2];
1277 ctl_table devinet_conf_dir[2];
1278 ctl_table devinet_proto_dir[2];
1279 ctl_table devinet_root_dir[2];
1280 } devinet_sysctl = {
1283 .ctl_name = NET_IPV4_CONF_FORWARDING,
1284 .procname = "forwarding",
1285 .data = &ipv4_devconf.forwarding,
1286 .maxlen = sizeof(int),
1288 .proc_handler = &devinet_sysctl_forward,
1291 .ctl_name = NET_IPV4_CONF_MC_FORWARDING,
1292 .procname = "mc_forwarding",
1293 .data = &ipv4_devconf.mc_forwarding,
1294 .maxlen = sizeof(int),
1296 .proc_handler = &proc_dointvec,
1299 .ctl_name = NET_IPV4_CONF_ACCEPT_REDIRECTS,
1300 .procname = "accept_redirects",
1301 .data = &ipv4_devconf.accept_redirects,
1302 .maxlen = sizeof(int),
1304 .proc_handler = &proc_dointvec,
1307 .ctl_name = NET_IPV4_CONF_SECURE_REDIRECTS,
1308 .procname = "secure_redirects",
1309 .data = &ipv4_devconf.secure_redirects,
1310 .maxlen = sizeof(int),
1312 .proc_handler = &proc_dointvec,
1315 .ctl_name = NET_IPV4_CONF_SHARED_MEDIA,
1316 .procname = "shared_media",
1317 .data = &ipv4_devconf.shared_media,
1318 .maxlen = sizeof(int),
1320 .proc_handler = &proc_dointvec,
1323 .ctl_name = NET_IPV4_CONF_RP_FILTER,
1324 .procname = "rp_filter",
1325 .data = &ipv4_devconf.rp_filter,
1326 .maxlen = sizeof(int),
1328 .proc_handler = &proc_dointvec,
1331 .ctl_name = NET_IPV4_CONF_SEND_REDIRECTS,
1332 .procname = "send_redirects",
1333 .data = &ipv4_devconf.send_redirects,
1334 .maxlen = sizeof(int),
1336 .proc_handler = &proc_dointvec,
1339 .ctl_name = NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE,
1340 .procname = "accept_source_route",
1341 .data = &ipv4_devconf.accept_source_route,
1342 .maxlen = sizeof(int),
1344 .proc_handler = &proc_dointvec,
1347 .ctl_name = NET_IPV4_CONF_PROXY_ARP,
1348 .procname = "proxy_arp",
1349 .data = &ipv4_devconf.proxy_arp,
1350 .maxlen = sizeof(int),
1352 .proc_handler = &proc_dointvec,
1355 .ctl_name = NET_IPV4_CONF_MEDIUM_ID,
1356 .procname = "medium_id",
1357 .data = &ipv4_devconf.medium_id,
1358 .maxlen = sizeof(int),
1360 .proc_handler = &proc_dointvec,
1363 .ctl_name = NET_IPV4_CONF_BOOTP_RELAY,
1364 .procname = "bootp_relay",
1365 .data = &ipv4_devconf.bootp_relay,
1366 .maxlen = sizeof(int),
1368 .proc_handler = &proc_dointvec,
1371 .ctl_name = NET_IPV4_CONF_LOG_MARTIANS,
1372 .procname = "log_martians",
1373 .data = &ipv4_devconf.log_martians,
1374 .maxlen = sizeof(int),
1376 .proc_handler = &proc_dointvec,
1379 .ctl_name = NET_IPV4_CONF_TAG,
1381 .data = &ipv4_devconf.tag,
1382 .maxlen = sizeof(int),
1384 .proc_handler = &proc_dointvec,
1387 .ctl_name = NET_IPV4_CONF_ARPFILTER,
1388 .procname = "arp_filter",
1389 .data = &ipv4_devconf.arp_filter,
1390 .maxlen = sizeof(int),
1392 .proc_handler = &proc_dointvec,
1395 .ctl_name = NET_IPV4_CONF_ARP_ANNOUNCE,
1396 .procname = "arp_announce",
1397 .data = &ipv4_devconf.arp_announce,
1398 .maxlen = sizeof(int),
1400 .proc_handler = &proc_dointvec,
1403 .ctl_name = NET_IPV4_CONF_ARP_IGNORE,
1404 .procname = "arp_ignore",
1405 .data = &ipv4_devconf.arp_ignore,
1406 .maxlen = sizeof(int),
1408 .proc_handler = &proc_dointvec,
1411 .ctl_name = NET_IPV4_CONF_ARP_ACCEPT,
1412 .procname = "arp_accept",
1413 .data = &ipv4_devconf.arp_accept,
1414 .maxlen = sizeof(int),
1416 .proc_handler = &proc_dointvec,
1419 .ctl_name = NET_IPV4_CONF_NOXFRM,
1420 .procname = "disable_xfrm",
1421 .data = &ipv4_devconf.no_xfrm,
1422 .maxlen = sizeof(int),
1424 .proc_handler = &ipv4_doint_and_flush,
1425 .strategy = &ipv4_doint_and_flush_strategy,
1428 .ctl_name = NET_IPV4_CONF_NOPOLICY,
1429 .procname = "disable_policy",
1430 .data = &ipv4_devconf.no_policy,
1431 .maxlen = sizeof(int),
1433 .proc_handler = &ipv4_doint_and_flush,
1434 .strategy = &ipv4_doint_and_flush_strategy,
1437 .ctl_name = NET_IPV4_CONF_FORCE_IGMP_VERSION,
1438 .procname = "force_igmp_version",
1439 .data = &ipv4_devconf.force_igmp_version,
1440 .maxlen = sizeof(int),
1442 .proc_handler = &ipv4_doint_and_flush,
1443 .strategy = &ipv4_doint_and_flush_strategy,
1446 .ctl_name = NET_IPV4_CONF_PROMOTE_SECONDARIES,
1447 .procname = "promote_secondaries",
1448 .data = &ipv4_devconf.promote_secondaries,
1449 .maxlen = sizeof(int),
1451 .proc_handler = &ipv4_doint_and_flush,
1452 .strategy = &ipv4_doint_and_flush_strategy,
1457 .ctl_name = NET_PROTO_CONF_ALL,
1460 .child = devinet_sysctl.devinet_vars,
1463 .devinet_conf_dir = {
1465 .ctl_name = NET_IPV4_CONF,
1468 .child = devinet_sysctl.devinet_dev,
1471 .devinet_proto_dir = {
1473 .ctl_name = NET_IPV4,
1476 .child = devinet_sysctl.devinet_conf_dir,
1479 .devinet_root_dir = {
1481 .ctl_name = CTL_NET,
1484 .child = devinet_sysctl.devinet_proto_dir,
1489 static void devinet_sysctl_register(struct in_device *in_dev,
1490 struct ipv4_devconf *p)
1493 struct net_device *dev = in_dev ? in_dev->dev : NULL;
1494 struct devinet_sysctl_table *t = kmalloc(sizeof(*t), GFP_KERNEL);
1495 char *dev_name = NULL;
1499 memcpy(t, &devinet_sysctl, sizeof(*t));
1500 for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
1501 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
1502 t->devinet_vars[i].de = NULL;
1506 dev_name = dev->name;
1507 t->devinet_dev[0].ctl_name = dev->ifindex;
1509 dev_name = "default";
1510 t->devinet_dev[0].ctl_name = NET_PROTO_CONF_DEFAULT;
1514 * Make a copy of dev_name, because '.procname' is regarded as const
1515 * by sysctl and we wouldn't want anyone to change it under our feet
1516 * (see SIOCSIFNAME).
1518 dev_name = kstrdup(dev_name, GFP_KERNEL);
1522 t->devinet_dev[0].procname = dev_name;
1523 t->devinet_dev[0].child = t->devinet_vars;
1524 t->devinet_dev[0].de = NULL;
1525 t->devinet_conf_dir[0].child = t->devinet_dev;
1526 t->devinet_conf_dir[0].de = NULL;
1527 t->devinet_proto_dir[0].child = t->devinet_conf_dir;
1528 t->devinet_proto_dir[0].de = NULL;
1529 t->devinet_root_dir[0].child = t->devinet_proto_dir;
1530 t->devinet_root_dir[0].de = NULL;
1532 t->sysctl_header = register_sysctl_table(t->devinet_root_dir, 0);
1533 if (!t->sysctl_header)
1547 static void devinet_sysctl_unregister(struct ipv4_devconf *p)
1550 struct devinet_sysctl_table *t = p->sysctl;
1552 unregister_sysctl_table(t->sysctl_header);
1553 kfree(t->devinet_dev[0].procname);
1559 void __init devinet_init(void)
1561 register_gifconf(PF_INET, inet_gifconf);
1562 register_netdevice_notifier(&ip_netdev_notifier);
1563 rtnetlink_links[PF_INET] = inet_rtnetlink_table;
1564 #ifdef CONFIG_SYSCTL
1565 devinet_sysctl.sysctl_header =
1566 register_sysctl_table(devinet_sysctl.devinet_root_dir, 0);
1567 devinet_sysctl_register(NULL, &ipv4_devconf_dflt);
1571 EXPORT_SYMBOL(in_dev_finish_destroy);
1572 EXPORT_SYMBOL(inet_select_addr);
1573 EXPORT_SYMBOL(inetdev_by_index);
1574 EXPORT_SYMBOL(register_inetaddr_notifier);
1575 EXPORT_SYMBOL(unregister_inetaddr_notifier);