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_addr.h>
47 #include <linux/if_ether.h>
48 #include <linux/inet.h>
49 #include <linux/netdevice.h>
50 #include <linux/etherdevice.h>
51 #include <linux/skbuff.h>
52 #include <linux/rtnetlink.h>
53 #include <linux/init.h>
54 #include <linux/notifier.h>
55 #include <linux/inetdevice.h>
56 #include <linux/igmp.h>
58 #include <linux/sysctl.h>
60 #include <linux/kmod.h>
64 #include <net/route.h>
65 #include <net/ip_fib.h>
66 #include <net/netlink.h>
68 struct ipv4_devconf ipv4_devconf = {
69 .accept_redirects = 1,
71 .secure_redirects = 1,
75 static struct ipv4_devconf ipv4_devconf_dflt = {
76 .accept_redirects = 1,
78 .secure_redirects = 1,
80 .accept_source_route = 1,
83 static struct nla_policy ifa_ipv4_policy[IFA_MAX+1] __read_mostly = {
84 [IFA_LOCAL] = { .type = NLA_U32 },
85 [IFA_ADDRESS] = { .type = NLA_U32 },
86 [IFA_BROADCAST] = { .type = NLA_U32 },
87 [IFA_ANYCAST] = { .type = NLA_U32 },
88 [IFA_LABEL] = { .type = NLA_STRING },
91 static void rtmsg_ifa(int event, struct in_ifaddr *);
93 static BLOCKING_NOTIFIER_HEAD(inetaddr_chain);
94 static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
97 static void devinet_sysctl_register(struct in_device *in_dev,
98 struct ipv4_devconf *p);
99 static void devinet_sysctl_unregister(struct ipv4_devconf *p);
102 /* Locks all the inet devices. */
104 static struct in_ifaddr *inet_alloc_ifa(void)
106 struct in_ifaddr *ifa = kzalloc(sizeof(*ifa), GFP_KERNEL);
109 INIT_RCU_HEAD(&ifa->rcu_head);
115 static void inet_rcu_free_ifa(struct rcu_head *head)
117 struct in_ifaddr *ifa = container_of(head, struct in_ifaddr, rcu_head);
119 in_dev_put(ifa->ifa_dev);
123 static inline void inet_free_ifa(struct in_ifaddr *ifa)
125 call_rcu(&ifa->rcu_head, inet_rcu_free_ifa);
128 void in_dev_finish_destroy(struct in_device *idev)
130 struct net_device *dev = idev->dev;
132 BUG_TRAP(!idev->ifa_list);
133 BUG_TRAP(!idev->mc_list);
134 #ifdef NET_REFCNT_DEBUG
135 printk(KERN_DEBUG "in_dev_finish_destroy: %p=%s\n",
136 idev, dev ? dev->name : "NIL");
140 printk("Freeing alive in_device %p\n", idev);
146 struct in_device *inetdev_init(struct net_device *dev)
148 struct in_device *in_dev;
152 in_dev = kzalloc(sizeof(*in_dev), GFP_KERNEL);
155 INIT_RCU_HEAD(&in_dev->rcu_head);
156 memcpy(&in_dev->cnf, &ipv4_devconf_dflt, sizeof(in_dev->cnf));
157 in_dev->cnf.sysctl = NULL;
159 if ((in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl)) == NULL)
161 /* Reference in_dev->dev */
164 neigh_sysctl_register(dev, in_dev->arp_parms, NET_IPV4,
165 NET_IPV4_NEIGH, "ipv4", NULL, NULL);
168 /* Account for reference dev->ip_ptr */
170 rcu_assign_pointer(dev->ip_ptr, in_dev);
173 devinet_sysctl_register(in_dev, &in_dev->cnf);
175 ip_mc_init_dev(in_dev);
176 if (dev->flags & IFF_UP)
186 static void in_dev_rcu_put(struct rcu_head *head)
188 struct in_device *idev = container_of(head, struct in_device, rcu_head);
192 static void inetdev_destroy(struct in_device *in_dev)
194 struct in_ifaddr *ifa;
195 struct net_device *dev;
200 if (dev == &loopback_dev)
205 ip_mc_destroy_dev(in_dev);
207 while ((ifa = in_dev->ifa_list) != NULL) {
208 inet_del_ifa(in_dev, &in_dev->ifa_list, 0);
213 devinet_sysctl_unregister(&in_dev->cnf);
219 neigh_sysctl_unregister(in_dev->arp_parms);
221 neigh_parms_release(&arp_tbl, in_dev->arp_parms);
224 call_rcu(&in_dev->rcu_head, in_dev_rcu_put);
227 int inet_addr_onlink(struct in_device *in_dev, u32 a, u32 b)
230 for_primary_ifa(in_dev) {
231 if (inet_ifa_match(a, ifa)) {
232 if (!b || inet_ifa_match(b, ifa)) {
237 } endfor_ifa(in_dev);
242 static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
245 struct in_ifaddr *promote = NULL;
246 struct in_ifaddr *ifa, *ifa1 = *ifap;
247 struct in_ifaddr *last_prim = in_dev->ifa_list;
248 struct in_ifaddr *prev_prom = NULL;
249 int do_promote = IN_DEV_PROMOTE_SECONDARIES(in_dev);
253 /* 1. Deleting primary ifaddr forces deletion all secondaries
254 * unless alias promotion is set
257 if (!(ifa1->ifa_flags & IFA_F_SECONDARY)) {
258 struct in_ifaddr **ifap1 = &ifa1->ifa_next;
260 while ((ifa = *ifap1) != NULL) {
261 if (!(ifa->ifa_flags & IFA_F_SECONDARY) &&
262 ifa1->ifa_scope <= ifa->ifa_scope)
265 if (!(ifa->ifa_flags & IFA_F_SECONDARY) ||
266 ifa1->ifa_mask != ifa->ifa_mask ||
267 !inet_ifa_match(ifa1->ifa_address, ifa)) {
268 ifap1 = &ifa->ifa_next;
274 *ifap1 = ifa->ifa_next;
276 rtmsg_ifa(RTM_DELADDR, ifa);
277 blocking_notifier_call_chain(&inetaddr_chain,
289 *ifap = ifa1->ifa_next;
291 /* 3. Announce address deletion */
293 /* Send message first, then call notifier.
294 At first sight, FIB update triggered by notifier
295 will refer to already deleted ifaddr, that could confuse
296 netlink listeners. It is not true: look, gated sees
297 that route deleted and if it still thinks that ifaddr
298 is valid, it will try to restore deleted routes... Grr.
299 So that, this order is correct.
301 rtmsg_ifa(RTM_DELADDR, ifa1);
302 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1);
307 prev_prom->ifa_next = promote->ifa_next;
308 promote->ifa_next = last_prim->ifa_next;
309 last_prim->ifa_next = promote;
312 promote->ifa_flags &= ~IFA_F_SECONDARY;
313 rtmsg_ifa(RTM_NEWADDR, promote);
314 blocking_notifier_call_chain(&inetaddr_chain,
316 for (ifa = promote->ifa_next; ifa; ifa = ifa->ifa_next) {
317 if (ifa1->ifa_mask != ifa->ifa_mask ||
318 !inet_ifa_match(ifa1->ifa_address, ifa))
327 if (!in_dev->ifa_list)
328 inetdev_destroy(in_dev);
332 static int inet_insert_ifa(struct in_ifaddr *ifa)
334 struct in_device *in_dev = ifa->ifa_dev;
335 struct in_ifaddr *ifa1, **ifap, **last_primary;
339 if (!ifa->ifa_local) {
344 ifa->ifa_flags &= ~IFA_F_SECONDARY;
345 last_primary = &in_dev->ifa_list;
347 for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL;
348 ifap = &ifa1->ifa_next) {
349 if (!(ifa1->ifa_flags & IFA_F_SECONDARY) &&
350 ifa->ifa_scope <= ifa1->ifa_scope)
351 last_primary = &ifa1->ifa_next;
352 if (ifa1->ifa_mask == ifa->ifa_mask &&
353 inet_ifa_match(ifa1->ifa_address, ifa)) {
354 if (ifa1->ifa_local == ifa->ifa_local) {
358 if (ifa1->ifa_scope != ifa->ifa_scope) {
362 ifa->ifa_flags |= IFA_F_SECONDARY;
366 if (!(ifa->ifa_flags & IFA_F_SECONDARY)) {
367 net_srandom(ifa->ifa_local);
371 ifa->ifa_next = *ifap;
374 /* Send message first, then call notifier.
375 Notifier will trigger FIB update, so that
376 listeners of netlink will know about new ifaddr */
377 rtmsg_ifa(RTM_NEWADDR, ifa);
378 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
383 static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa)
385 struct in_device *in_dev = __in_dev_get_rtnl(dev);
390 in_dev = inetdev_init(dev);
396 if (ifa->ifa_dev != in_dev) {
397 BUG_TRAP(!ifa->ifa_dev);
399 ifa->ifa_dev = in_dev;
401 if (LOOPBACK(ifa->ifa_local))
402 ifa->ifa_scope = RT_SCOPE_HOST;
403 return inet_insert_ifa(ifa);
406 struct in_device *inetdev_by_index(int ifindex)
408 struct net_device *dev;
409 struct in_device *in_dev = NULL;
410 read_lock(&dev_base_lock);
411 dev = __dev_get_by_index(ifindex);
413 in_dev = in_dev_get(dev);
414 read_unlock(&dev_base_lock);
418 /* Called only from RTNL semaphored context. No locks. */
420 struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, u32 prefix,
425 for_primary_ifa(in_dev) {
426 if (ifa->ifa_mask == mask && inet_ifa_match(prefix, ifa))
428 } endfor_ifa(in_dev);
432 static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
434 struct nlattr *tb[IFA_MAX+1];
435 struct in_device *in_dev;
436 struct ifaddrmsg *ifm;
437 struct in_ifaddr *ifa, **ifap;
442 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
446 ifm = nlmsg_data(nlh);
447 in_dev = inetdev_by_index(ifm->ifa_index);
448 if (in_dev == NULL) {
453 __in_dev_put(in_dev);
455 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
456 ifap = &ifa->ifa_next) {
458 ifa->ifa_local != nla_get_u32(tb[IFA_LOCAL]))
461 if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label))
464 if (tb[IFA_ADDRESS] &&
465 (ifm->ifa_prefixlen != ifa->ifa_prefixlen ||
466 !inet_ifa_match(nla_get_u32(tb[IFA_ADDRESS]), ifa)))
469 inet_del_ifa(in_dev, ifap, 1);
473 err = -EADDRNOTAVAIL;
478 static struct in_ifaddr *rtm_to_ifaddr(struct nlmsghdr *nlh)
480 struct nlattr *tb[IFA_MAX+1];
481 struct in_ifaddr *ifa;
482 struct ifaddrmsg *ifm;
483 struct net_device *dev;
484 struct in_device *in_dev;
487 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
491 ifm = nlmsg_data(nlh);
492 if (ifm->ifa_prefixlen > 32 || tb[IFA_LOCAL] == NULL)
495 dev = __dev_get_by_index(ifm->ifa_index);
501 in_dev = __in_dev_get_rtnl(dev);
502 if (in_dev == NULL) {
503 in_dev = inetdev_init(dev);
504 if (in_dev == NULL) {
510 ifa = inet_alloc_ifa();
513 * A potential indev allocation can be left alive, it stays
514 * assigned to its device and is destroy with it.
522 if (tb[IFA_ADDRESS] == NULL)
523 tb[IFA_ADDRESS] = tb[IFA_LOCAL];
525 ifa->ifa_prefixlen = ifm->ifa_prefixlen;
526 ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen);
527 ifa->ifa_flags = ifm->ifa_flags;
528 ifa->ifa_scope = ifm->ifa_scope;
529 ifa->ifa_dev = in_dev;
531 ifa->ifa_local = nla_get_u32(tb[IFA_LOCAL]);
532 ifa->ifa_address = nla_get_u32(tb[IFA_ADDRESS]);
534 if (tb[IFA_BROADCAST])
535 ifa->ifa_broadcast = nla_get_u32(tb[IFA_BROADCAST]);
538 ifa->ifa_anycast = nla_get_u32(tb[IFA_ANYCAST]);
541 nla_strlcpy(ifa->ifa_label, tb[IFA_LABEL], IFNAMSIZ);
543 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
551 static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
553 struct in_ifaddr *ifa;
557 ifa = rtm_to_ifaddr(nlh);
561 return inet_insert_ifa(ifa);
565 * Determine a default network mask, based on the IP address.
568 static __inline__ int inet_abc_len(u32 addr)
570 int rc = -1; /* Something else, probably a multicast. */
579 else if (IN_CLASSB(addr))
581 else if (IN_CLASSC(addr))
589 int devinet_ioctl(unsigned int cmd, void __user *arg)
592 struct sockaddr_in sin_orig;
593 struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
594 struct in_device *in_dev;
595 struct in_ifaddr **ifap = NULL;
596 struct in_ifaddr *ifa = NULL;
597 struct net_device *dev;
600 int tryaddrmatch = 0;
603 * Fetch the caller's info block into kernel space
606 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
608 ifr.ifr_name[IFNAMSIZ - 1] = 0;
610 /* save original address for comparison */
611 memcpy(&sin_orig, sin, sizeof(*sin));
613 colon = strchr(ifr.ifr_name, ':');
618 dev_load(ifr.ifr_name);
622 case SIOCGIFADDR: /* Get interface address */
623 case SIOCGIFBRDADDR: /* Get the broadcast address */
624 case SIOCGIFDSTADDR: /* Get the destination address */
625 case SIOCGIFNETMASK: /* Get the netmask for the interface */
626 /* Note that these ioctls will not sleep,
627 so that we do not impose a lock.
628 One day we will be forced to put shlock here (I mean SMP)
630 tryaddrmatch = (sin_orig.sin_family == AF_INET);
631 memset(sin, 0, sizeof(*sin));
632 sin->sin_family = AF_INET;
637 if (!capable(CAP_NET_ADMIN))
640 case SIOCSIFADDR: /* Set interface address (and family) */
641 case SIOCSIFBRDADDR: /* Set the broadcast address */
642 case SIOCSIFDSTADDR: /* Set the destination address */
643 case SIOCSIFNETMASK: /* Set the netmask for the interface */
645 if (!capable(CAP_NET_ADMIN))
648 if (sin->sin_family != AF_INET)
659 if ((dev = __dev_get_by_name(ifr.ifr_name)) == NULL)
665 if ((in_dev = __in_dev_get_rtnl(dev)) != NULL) {
667 /* Matthias Andree */
668 /* compare label and address (4.4BSD style) */
669 /* note: we only do this for a limited set of ioctls
670 and only if the original address family was AF_INET.
671 This is checked above. */
672 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
673 ifap = &ifa->ifa_next) {
674 if (!strcmp(ifr.ifr_name, ifa->ifa_label) &&
675 sin_orig.sin_addr.s_addr ==
681 /* we didn't get a match, maybe the application is
682 4.3BSD-style and passed in junk so we fall back to
683 comparing just the label */
685 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
686 ifap = &ifa->ifa_next)
687 if (!strcmp(ifr.ifr_name, ifa->ifa_label))
692 ret = -EADDRNOTAVAIL;
693 if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS)
697 case SIOCGIFADDR: /* Get interface address */
698 sin->sin_addr.s_addr = ifa->ifa_local;
701 case SIOCGIFBRDADDR: /* Get the broadcast address */
702 sin->sin_addr.s_addr = ifa->ifa_broadcast;
705 case SIOCGIFDSTADDR: /* Get the destination address */
706 sin->sin_addr.s_addr = ifa->ifa_address;
709 case SIOCGIFNETMASK: /* Get the netmask for the interface */
710 sin->sin_addr.s_addr = ifa->ifa_mask;
715 ret = -EADDRNOTAVAIL;
719 if (!(ifr.ifr_flags & IFF_UP))
720 inet_del_ifa(in_dev, ifap, 1);
723 ret = dev_change_flags(dev, ifr.ifr_flags);
726 case SIOCSIFADDR: /* Set interface address (and family) */
728 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
733 if ((ifa = inet_alloc_ifa()) == NULL)
736 memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ);
738 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
741 if (ifa->ifa_local == sin->sin_addr.s_addr)
743 inet_del_ifa(in_dev, ifap, 0);
744 ifa->ifa_broadcast = 0;
745 ifa->ifa_anycast = 0;
748 ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr;
750 if (!(dev->flags & IFF_POINTOPOINT)) {
751 ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address);
752 ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen);
753 if ((dev->flags & IFF_BROADCAST) &&
754 ifa->ifa_prefixlen < 31)
755 ifa->ifa_broadcast = ifa->ifa_address |
758 ifa->ifa_prefixlen = 32;
759 ifa->ifa_mask = inet_make_mask(32);
761 ret = inet_set_ifa(dev, ifa);
764 case SIOCSIFBRDADDR: /* Set the broadcast address */
766 if (ifa->ifa_broadcast != sin->sin_addr.s_addr) {
767 inet_del_ifa(in_dev, ifap, 0);
768 ifa->ifa_broadcast = sin->sin_addr.s_addr;
769 inet_insert_ifa(ifa);
773 case SIOCSIFDSTADDR: /* Set the destination address */
775 if (ifa->ifa_address == sin->sin_addr.s_addr)
778 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
781 inet_del_ifa(in_dev, ifap, 0);
782 ifa->ifa_address = sin->sin_addr.s_addr;
783 inet_insert_ifa(ifa);
786 case SIOCSIFNETMASK: /* Set the netmask for the interface */
789 * The mask we set must be legal.
792 if (bad_mask(sin->sin_addr.s_addr, 0))
795 if (ifa->ifa_mask != sin->sin_addr.s_addr) {
796 u32 old_mask = ifa->ifa_mask;
797 inet_del_ifa(in_dev, ifap, 0);
798 ifa->ifa_mask = sin->sin_addr.s_addr;
799 ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask);
801 /* See if current broadcast address matches
802 * with current netmask, then recalculate
803 * the broadcast address. Otherwise it's a
804 * funny address, so don't touch it since
805 * the user seems to know what (s)he's doing...
807 if ((dev->flags & IFF_BROADCAST) &&
808 (ifa->ifa_prefixlen < 31) &&
809 (ifa->ifa_broadcast ==
810 (ifa->ifa_local|~old_mask))) {
811 ifa->ifa_broadcast = (ifa->ifa_local |
812 ~sin->sin_addr.s_addr);
814 inet_insert_ifa(ifa);
824 ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0;
828 static int inet_gifconf(struct net_device *dev, char __user *buf, int len)
830 struct in_device *in_dev = __in_dev_get_rtnl(dev);
831 struct in_ifaddr *ifa;
835 if (!in_dev || (ifa = in_dev->ifa_list) == NULL)
838 for (; ifa; ifa = ifa->ifa_next) {
843 if (len < (int) sizeof(ifr))
845 memset(&ifr, 0, sizeof(struct ifreq));
847 strcpy(ifr.ifr_name, ifa->ifa_label);
849 strcpy(ifr.ifr_name, dev->name);
851 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET;
852 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr =
855 if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) {
859 buf += sizeof(struct ifreq);
860 len -= sizeof(struct ifreq);
861 done += sizeof(struct ifreq);
867 u32 inet_select_addr(const struct net_device *dev, u32 dst, int scope)
870 struct in_device *in_dev;
873 in_dev = __in_dev_get_rcu(dev);
877 for_primary_ifa(in_dev) {
878 if (ifa->ifa_scope > scope)
880 if (!dst || inet_ifa_match(dst, ifa)) {
881 addr = ifa->ifa_local;
885 addr = ifa->ifa_local;
886 } endfor_ifa(in_dev);
893 /* Not loopback addresses on loopback should be preferred
894 in this case. It is importnat that lo is the first interface
897 read_lock(&dev_base_lock);
899 for (dev = dev_base; dev; dev = dev->next) {
900 if ((in_dev = __in_dev_get_rcu(dev)) == NULL)
903 for_primary_ifa(in_dev) {
904 if (ifa->ifa_scope != RT_SCOPE_LINK &&
905 ifa->ifa_scope <= scope) {
906 addr = ifa->ifa_local;
907 goto out_unlock_both;
909 } endfor_ifa(in_dev);
912 read_unlock(&dev_base_lock);
918 static u32 confirm_addr_indev(struct in_device *in_dev, u32 dst,
919 u32 local, int scope)
926 (local == ifa->ifa_local || !local) &&
927 ifa->ifa_scope <= scope) {
928 addr = ifa->ifa_local;
933 same = (!local || inet_ifa_match(local, ifa)) &&
934 (!dst || inet_ifa_match(dst, ifa));
938 /* Is the selected addr into dst subnet? */
939 if (inet_ifa_match(addr, ifa))
941 /* No, then can we use new local src? */
942 if (ifa->ifa_scope <= scope) {
943 addr = ifa->ifa_local;
946 /* search for large dst subnet for addr */
950 } endfor_ifa(in_dev);
952 return same? addr : 0;
956 * Confirm that local IP address exists using wildcards:
957 * - dev: only on this interface, 0=any interface
958 * - dst: only in the same subnet as dst, 0=any dst
959 * - local: address, 0=autoselect the local address
960 * - scope: maximum allowed scope value for the local address
962 u32 inet_confirm_addr(const struct net_device *dev, u32 dst, u32 local, int scope)
965 struct in_device *in_dev;
969 if ((in_dev = __in_dev_get_rcu(dev)))
970 addr = confirm_addr_indev(in_dev, dst, local, scope);
976 read_lock(&dev_base_lock);
978 for (dev = dev_base; dev; dev = dev->next) {
979 if ((in_dev = __in_dev_get_rcu(dev))) {
980 addr = confirm_addr_indev(in_dev, dst, local, scope);
986 read_unlock(&dev_base_lock);
995 int register_inetaddr_notifier(struct notifier_block *nb)
997 return blocking_notifier_chain_register(&inetaddr_chain, nb);
1000 int unregister_inetaddr_notifier(struct notifier_block *nb)
1002 return blocking_notifier_chain_unregister(&inetaddr_chain, nb);
1005 /* Rename ifa_labels for a device name change. Make some effort to preserve existing
1006 * alias numbering and to create unique labels if possible.
1008 static void inetdev_changename(struct net_device *dev, struct in_device *in_dev)
1010 struct in_ifaddr *ifa;
1013 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
1014 char old[IFNAMSIZ], *dot;
1016 memcpy(old, ifa->ifa_label, IFNAMSIZ);
1017 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1020 dot = strchr(ifa->ifa_label, ':');
1022 sprintf(old, ":%d", named);
1025 if (strlen(dot) + strlen(dev->name) < IFNAMSIZ) {
1026 strcat(ifa->ifa_label, dot);
1028 strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot);
1033 /* Called only under RTNL semaphore */
1035 static int inetdev_event(struct notifier_block *this, unsigned long event,
1038 struct net_device *dev = ptr;
1039 struct in_device *in_dev = __in_dev_get_rtnl(dev);
1044 if (event == NETDEV_REGISTER && dev == &loopback_dev) {
1045 in_dev = inetdev_init(dev);
1047 panic("devinet: Failed to create loopback\n");
1048 in_dev->cnf.no_xfrm = 1;
1049 in_dev->cnf.no_policy = 1;
1055 case NETDEV_REGISTER:
1056 printk(KERN_DEBUG "inetdev_event: bug\n");
1062 if (dev == &loopback_dev) {
1063 struct in_ifaddr *ifa;
1064 if ((ifa = inet_alloc_ifa()) != NULL) {
1066 ifa->ifa_address = htonl(INADDR_LOOPBACK);
1067 ifa->ifa_prefixlen = 8;
1068 ifa->ifa_mask = inet_make_mask(8);
1069 in_dev_hold(in_dev);
1070 ifa->ifa_dev = in_dev;
1071 ifa->ifa_scope = RT_SCOPE_HOST;
1072 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1073 inet_insert_ifa(ifa);
1081 case NETDEV_CHANGEMTU:
1084 /* MTU falled under 68, disable IP */
1085 case NETDEV_UNREGISTER:
1086 inetdev_destroy(in_dev);
1088 case NETDEV_CHANGENAME:
1089 /* Do not notify about label change, this event is
1090 * not interesting to applications using netlink.
1092 inetdev_changename(dev, in_dev);
1094 #ifdef CONFIG_SYSCTL
1095 devinet_sysctl_unregister(&in_dev->cnf);
1096 neigh_sysctl_unregister(in_dev->arp_parms);
1097 neigh_sysctl_register(dev, in_dev->arp_parms, NET_IPV4,
1098 NET_IPV4_NEIGH, "ipv4", NULL, NULL);
1099 devinet_sysctl_register(in_dev, &in_dev->cnf);
1107 static struct notifier_block ip_netdev_notifier = {
1108 .notifier_call =inetdev_event,
1111 static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
1112 u32 pid, u32 seq, int event, unsigned int flags)
1114 struct ifaddrmsg *ifm;
1115 struct nlmsghdr *nlh;
1117 nlh = nlmsg_put(skb, pid, seq, event, sizeof(*ifm), flags);
1121 ifm = nlmsg_data(nlh);
1122 ifm->ifa_family = AF_INET;
1123 ifm->ifa_prefixlen = ifa->ifa_prefixlen;
1124 ifm->ifa_flags = ifa->ifa_flags|IFA_F_PERMANENT;
1125 ifm->ifa_scope = ifa->ifa_scope;
1126 ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
1128 if (ifa->ifa_address)
1129 NLA_PUT_U32(skb, IFA_ADDRESS, ifa->ifa_address);
1132 NLA_PUT_U32(skb, IFA_LOCAL, ifa->ifa_local);
1134 if (ifa->ifa_broadcast)
1135 NLA_PUT_U32(skb, IFA_BROADCAST, ifa->ifa_broadcast);
1137 if (ifa->ifa_anycast)
1138 NLA_PUT_U32(skb, IFA_ANYCAST, ifa->ifa_anycast);
1140 if (ifa->ifa_label[0])
1141 NLA_PUT_STRING(skb, IFA_LABEL, ifa->ifa_label);
1143 return nlmsg_end(skb, nlh);
1146 return nlmsg_cancel(skb, nlh);
1149 static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
1152 struct net_device *dev;
1153 struct in_device *in_dev;
1154 struct in_ifaddr *ifa;
1155 int s_ip_idx, s_idx = cb->args[0];
1157 s_ip_idx = ip_idx = cb->args[1];
1158 read_lock(&dev_base_lock);
1159 for (dev = dev_base, idx = 0; dev; dev = dev->next, idx++) {
1165 if ((in_dev = __in_dev_get_rcu(dev)) == NULL) {
1170 for (ifa = in_dev->ifa_list, ip_idx = 0; ifa;
1171 ifa = ifa->ifa_next, ip_idx++) {
1172 if (ip_idx < s_ip_idx)
1174 if (inet_fill_ifaddr(skb, ifa, NETLINK_CB(cb->skb).pid,
1176 RTM_NEWADDR, NLM_F_MULTI) <= 0) {
1185 read_unlock(&dev_base_lock);
1187 cb->args[1] = ip_idx;
1192 static void rtmsg_ifa(int event, struct in_ifaddr* ifa)
1194 struct sk_buff *skb;
1196 skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
1198 netlink_set_err(rtnl, 0, RTNLGRP_IPV4_IFADDR, ENOBUFS);
1199 else if (inet_fill_ifaddr(skb, ifa, 0, 0, event, 0) < 0) {
1201 netlink_set_err(rtnl, 0, RTNLGRP_IPV4_IFADDR, EINVAL);
1203 netlink_broadcast(rtnl, skb, 0, RTNLGRP_IPV4_IFADDR, GFP_KERNEL);
1206 static struct rtnetlink_link inet_rtnetlink_table[RTM_NR_MSGTYPES] = {
1207 [RTM_NEWADDR - RTM_BASE] = { .doit = inet_rtm_newaddr, },
1208 [RTM_DELADDR - RTM_BASE] = { .doit = inet_rtm_deladdr, },
1209 [RTM_GETADDR - RTM_BASE] = { .dumpit = inet_dump_ifaddr, },
1210 [RTM_NEWROUTE - RTM_BASE] = { .doit = inet_rtm_newroute, },
1211 [RTM_DELROUTE - RTM_BASE] = { .doit = inet_rtm_delroute, },
1212 [RTM_GETROUTE - RTM_BASE] = { .doit = inet_rtm_getroute,
1213 .dumpit = inet_dump_fib, },
1214 #ifdef CONFIG_IP_MULTIPLE_TABLES
1215 [RTM_GETRULE - RTM_BASE] = { .dumpit = fib4_rules_dump, },
1219 #ifdef CONFIG_SYSCTL
1221 void inet_forward_change(void)
1223 struct net_device *dev;
1224 int on = ipv4_devconf.forwarding;
1226 ipv4_devconf.accept_redirects = !on;
1227 ipv4_devconf_dflt.forwarding = on;
1229 read_lock(&dev_base_lock);
1230 for (dev = dev_base; dev; dev = dev->next) {
1231 struct in_device *in_dev;
1233 in_dev = __in_dev_get_rcu(dev);
1235 in_dev->cnf.forwarding = on;
1238 read_unlock(&dev_base_lock);
1243 static int devinet_sysctl_forward(ctl_table *ctl, int write,
1244 struct file* filp, void __user *buffer,
1245 size_t *lenp, loff_t *ppos)
1247 int *valp = ctl->data;
1249 int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1251 if (write && *valp != val) {
1252 if (valp == &ipv4_devconf.forwarding)
1253 inet_forward_change();
1254 else if (valp != &ipv4_devconf_dflt.forwarding)
1261 int ipv4_doint_and_flush(ctl_table *ctl, int write,
1262 struct file* filp, void __user *buffer,
1263 size_t *lenp, loff_t *ppos)
1265 int *valp = ctl->data;
1267 int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1269 if (write && *valp != val)
1275 int ipv4_doint_and_flush_strategy(ctl_table *table, int __user *name, int nlen,
1276 void __user *oldval, size_t __user *oldlenp,
1277 void __user *newval, size_t newlen,
1280 int *valp = table->data;
1283 if (!newval || !newlen)
1286 if (newlen != sizeof(int))
1289 if (get_user(new, (int __user *)newval))
1295 if (oldval && oldlenp) {
1298 if (get_user(len, oldlenp))
1302 if (len > table->maxlen)
1303 len = table->maxlen;
1304 if (copy_to_user(oldval, valp, len))
1306 if (put_user(len, oldlenp))
1317 static struct devinet_sysctl_table {
1318 struct ctl_table_header *sysctl_header;
1319 ctl_table devinet_vars[__NET_IPV4_CONF_MAX];
1320 ctl_table devinet_dev[2];
1321 ctl_table devinet_conf_dir[2];
1322 ctl_table devinet_proto_dir[2];
1323 ctl_table devinet_root_dir[2];
1324 } devinet_sysctl = {
1327 .ctl_name = NET_IPV4_CONF_FORWARDING,
1328 .procname = "forwarding",
1329 .data = &ipv4_devconf.forwarding,
1330 .maxlen = sizeof(int),
1332 .proc_handler = &devinet_sysctl_forward,
1335 .ctl_name = NET_IPV4_CONF_MC_FORWARDING,
1336 .procname = "mc_forwarding",
1337 .data = &ipv4_devconf.mc_forwarding,
1338 .maxlen = sizeof(int),
1340 .proc_handler = &proc_dointvec,
1343 .ctl_name = NET_IPV4_CONF_ACCEPT_REDIRECTS,
1344 .procname = "accept_redirects",
1345 .data = &ipv4_devconf.accept_redirects,
1346 .maxlen = sizeof(int),
1348 .proc_handler = &proc_dointvec,
1351 .ctl_name = NET_IPV4_CONF_SECURE_REDIRECTS,
1352 .procname = "secure_redirects",
1353 .data = &ipv4_devconf.secure_redirects,
1354 .maxlen = sizeof(int),
1356 .proc_handler = &proc_dointvec,
1359 .ctl_name = NET_IPV4_CONF_SHARED_MEDIA,
1360 .procname = "shared_media",
1361 .data = &ipv4_devconf.shared_media,
1362 .maxlen = sizeof(int),
1364 .proc_handler = &proc_dointvec,
1367 .ctl_name = NET_IPV4_CONF_RP_FILTER,
1368 .procname = "rp_filter",
1369 .data = &ipv4_devconf.rp_filter,
1370 .maxlen = sizeof(int),
1372 .proc_handler = &proc_dointvec,
1375 .ctl_name = NET_IPV4_CONF_SEND_REDIRECTS,
1376 .procname = "send_redirects",
1377 .data = &ipv4_devconf.send_redirects,
1378 .maxlen = sizeof(int),
1380 .proc_handler = &proc_dointvec,
1383 .ctl_name = NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE,
1384 .procname = "accept_source_route",
1385 .data = &ipv4_devconf.accept_source_route,
1386 .maxlen = sizeof(int),
1388 .proc_handler = &proc_dointvec,
1391 .ctl_name = NET_IPV4_CONF_PROXY_ARP,
1392 .procname = "proxy_arp",
1393 .data = &ipv4_devconf.proxy_arp,
1394 .maxlen = sizeof(int),
1396 .proc_handler = &proc_dointvec,
1399 .ctl_name = NET_IPV4_CONF_MEDIUM_ID,
1400 .procname = "medium_id",
1401 .data = &ipv4_devconf.medium_id,
1402 .maxlen = sizeof(int),
1404 .proc_handler = &proc_dointvec,
1407 .ctl_name = NET_IPV4_CONF_BOOTP_RELAY,
1408 .procname = "bootp_relay",
1409 .data = &ipv4_devconf.bootp_relay,
1410 .maxlen = sizeof(int),
1412 .proc_handler = &proc_dointvec,
1415 .ctl_name = NET_IPV4_CONF_LOG_MARTIANS,
1416 .procname = "log_martians",
1417 .data = &ipv4_devconf.log_martians,
1418 .maxlen = sizeof(int),
1420 .proc_handler = &proc_dointvec,
1423 .ctl_name = NET_IPV4_CONF_TAG,
1425 .data = &ipv4_devconf.tag,
1426 .maxlen = sizeof(int),
1428 .proc_handler = &proc_dointvec,
1431 .ctl_name = NET_IPV4_CONF_ARPFILTER,
1432 .procname = "arp_filter",
1433 .data = &ipv4_devconf.arp_filter,
1434 .maxlen = sizeof(int),
1436 .proc_handler = &proc_dointvec,
1439 .ctl_name = NET_IPV4_CONF_ARP_ANNOUNCE,
1440 .procname = "arp_announce",
1441 .data = &ipv4_devconf.arp_announce,
1442 .maxlen = sizeof(int),
1444 .proc_handler = &proc_dointvec,
1447 .ctl_name = NET_IPV4_CONF_ARP_IGNORE,
1448 .procname = "arp_ignore",
1449 .data = &ipv4_devconf.arp_ignore,
1450 .maxlen = sizeof(int),
1452 .proc_handler = &proc_dointvec,
1455 .ctl_name = NET_IPV4_CONF_ARP_ACCEPT,
1456 .procname = "arp_accept",
1457 .data = &ipv4_devconf.arp_accept,
1458 .maxlen = sizeof(int),
1460 .proc_handler = &proc_dointvec,
1463 .ctl_name = NET_IPV4_CONF_NOXFRM,
1464 .procname = "disable_xfrm",
1465 .data = &ipv4_devconf.no_xfrm,
1466 .maxlen = sizeof(int),
1468 .proc_handler = &ipv4_doint_and_flush,
1469 .strategy = &ipv4_doint_and_flush_strategy,
1472 .ctl_name = NET_IPV4_CONF_NOPOLICY,
1473 .procname = "disable_policy",
1474 .data = &ipv4_devconf.no_policy,
1475 .maxlen = sizeof(int),
1477 .proc_handler = &ipv4_doint_and_flush,
1478 .strategy = &ipv4_doint_and_flush_strategy,
1481 .ctl_name = NET_IPV4_CONF_FORCE_IGMP_VERSION,
1482 .procname = "force_igmp_version",
1483 .data = &ipv4_devconf.force_igmp_version,
1484 .maxlen = sizeof(int),
1486 .proc_handler = &ipv4_doint_and_flush,
1487 .strategy = &ipv4_doint_and_flush_strategy,
1490 .ctl_name = NET_IPV4_CONF_PROMOTE_SECONDARIES,
1491 .procname = "promote_secondaries",
1492 .data = &ipv4_devconf.promote_secondaries,
1493 .maxlen = sizeof(int),
1495 .proc_handler = &ipv4_doint_and_flush,
1496 .strategy = &ipv4_doint_and_flush_strategy,
1501 .ctl_name = NET_PROTO_CONF_ALL,
1504 .child = devinet_sysctl.devinet_vars,
1507 .devinet_conf_dir = {
1509 .ctl_name = NET_IPV4_CONF,
1512 .child = devinet_sysctl.devinet_dev,
1515 .devinet_proto_dir = {
1517 .ctl_name = NET_IPV4,
1520 .child = devinet_sysctl.devinet_conf_dir,
1523 .devinet_root_dir = {
1525 .ctl_name = CTL_NET,
1528 .child = devinet_sysctl.devinet_proto_dir,
1533 static void devinet_sysctl_register(struct in_device *in_dev,
1534 struct ipv4_devconf *p)
1537 struct net_device *dev = in_dev ? in_dev->dev : NULL;
1538 struct devinet_sysctl_table *t = kmalloc(sizeof(*t), GFP_KERNEL);
1539 char *dev_name = NULL;
1543 memcpy(t, &devinet_sysctl, sizeof(*t));
1544 for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
1545 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
1546 t->devinet_vars[i].de = NULL;
1550 dev_name = dev->name;
1551 t->devinet_dev[0].ctl_name = dev->ifindex;
1553 dev_name = "default";
1554 t->devinet_dev[0].ctl_name = NET_PROTO_CONF_DEFAULT;
1558 * Make a copy of dev_name, because '.procname' is regarded as const
1559 * by sysctl and we wouldn't want anyone to change it under our feet
1560 * (see SIOCSIFNAME).
1562 dev_name = kstrdup(dev_name, GFP_KERNEL);
1566 t->devinet_dev[0].procname = dev_name;
1567 t->devinet_dev[0].child = t->devinet_vars;
1568 t->devinet_dev[0].de = NULL;
1569 t->devinet_conf_dir[0].child = t->devinet_dev;
1570 t->devinet_conf_dir[0].de = NULL;
1571 t->devinet_proto_dir[0].child = t->devinet_conf_dir;
1572 t->devinet_proto_dir[0].de = NULL;
1573 t->devinet_root_dir[0].child = t->devinet_proto_dir;
1574 t->devinet_root_dir[0].de = NULL;
1576 t->sysctl_header = register_sysctl_table(t->devinet_root_dir, 0);
1577 if (!t->sysctl_header)
1591 static void devinet_sysctl_unregister(struct ipv4_devconf *p)
1594 struct devinet_sysctl_table *t = p->sysctl;
1596 unregister_sysctl_table(t->sysctl_header);
1597 kfree(t->devinet_dev[0].procname);
1603 void __init devinet_init(void)
1605 register_gifconf(PF_INET, inet_gifconf);
1606 register_netdevice_notifier(&ip_netdev_notifier);
1607 rtnetlink_links[PF_INET] = inet_rtnetlink_table;
1608 #ifdef CONFIG_SYSCTL
1609 devinet_sysctl.sysctl_header =
1610 register_sysctl_table(devinet_sysctl.devinet_root_dir, 0);
1611 devinet_sysctl_register(NULL, &ipv4_devconf_dflt);
1615 EXPORT_SYMBOL(in_dev_finish_destroy);
1616 EXPORT_SYMBOL(inet_select_addr);
1617 EXPORT_SYMBOL(inetdev_by_index);
1618 EXPORT_SYMBOL(register_inetaddr_notifier);
1619 EXPORT_SYMBOL(unregister_inetaddr_notifier);