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/string.h>
40 #include <linux/socket.h>
41 #include <linux/sockios.h>
43 #include <linux/errno.h>
44 #include <linux/interrupt.h>
45 #include <linux/if_addr.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/init.h>
52 #include <linux/notifier.h>
53 #include <linux/inetdevice.h>
54 #include <linux/igmp.h>
56 #include <linux/sysctl.h>
58 #include <linux/kmod.h>
62 #include <net/route.h>
63 #include <net/ip_fib.h>
64 #include <net/rtnetlink.h>
65 #include <net/net_namespace.h>
67 struct ipv4_devconf ipv4_devconf = {
69 [NET_IPV4_CONF_ACCEPT_REDIRECTS - 1] = 1,
70 [NET_IPV4_CONF_SEND_REDIRECTS - 1] = 1,
71 [NET_IPV4_CONF_SECURE_REDIRECTS - 1] = 1,
72 [NET_IPV4_CONF_SHARED_MEDIA - 1] = 1,
76 static struct ipv4_devconf ipv4_devconf_dflt = {
78 [NET_IPV4_CONF_ACCEPT_REDIRECTS - 1] = 1,
79 [NET_IPV4_CONF_SEND_REDIRECTS - 1] = 1,
80 [NET_IPV4_CONF_SECURE_REDIRECTS - 1] = 1,
81 [NET_IPV4_CONF_SHARED_MEDIA - 1] = 1,
82 [NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE - 1] = 1,
86 #define IPV4_DEVCONF_DFLT(net, attr) \
87 IPV4_DEVCONF((*net->ipv4.devconf_dflt), attr)
89 static const struct nla_policy ifa_ipv4_policy[IFA_MAX+1] = {
90 [IFA_LOCAL] = { .type = NLA_U32 },
91 [IFA_ADDRESS] = { .type = NLA_U32 },
92 [IFA_BROADCAST] = { .type = NLA_U32 },
93 [IFA_ANYCAST] = { .type = NLA_U32 },
94 [IFA_LABEL] = { .type = NLA_STRING, .len = IFNAMSIZ - 1 },
97 static void rtmsg_ifa(int event, struct in_ifaddr *, struct nlmsghdr *, u32);
99 static BLOCKING_NOTIFIER_HEAD(inetaddr_chain);
100 static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
103 static void devinet_sysctl_register(struct in_device *idev);
104 static void devinet_sysctl_unregister(struct in_device *idev);
106 static inline void devinet_sysctl_register(struct in_device *idev)
109 static inline void devinet_sysctl_unregister(struct in_device *idev)
114 /* Locks all the inet devices. */
116 static struct in_ifaddr *inet_alloc_ifa(void)
118 struct in_ifaddr *ifa = kzalloc(sizeof(*ifa), GFP_KERNEL);
121 INIT_RCU_HEAD(&ifa->rcu_head);
127 static void inet_rcu_free_ifa(struct rcu_head *head)
129 struct in_ifaddr *ifa = container_of(head, struct in_ifaddr, rcu_head);
131 in_dev_put(ifa->ifa_dev);
135 static inline void inet_free_ifa(struct in_ifaddr *ifa)
137 call_rcu(&ifa->rcu_head, inet_rcu_free_ifa);
140 void in_dev_finish_destroy(struct in_device *idev)
142 struct net_device *dev = idev->dev;
144 BUG_TRAP(!idev->ifa_list);
145 BUG_TRAP(!idev->mc_list);
146 #ifdef NET_REFCNT_DEBUG
147 printk(KERN_DEBUG "in_dev_finish_destroy: %p=%s\n",
148 idev, dev ? dev->name : "NIL");
152 printk("Freeing alive in_device %p\n", idev);
158 static struct in_device *inetdev_init(struct net_device *dev)
160 struct in_device *in_dev;
164 in_dev = kzalloc(sizeof(*in_dev), GFP_KERNEL);
167 INIT_RCU_HEAD(&in_dev->rcu_head);
168 memcpy(&in_dev->cnf, dev->nd_net->ipv4.devconf_dflt,
169 sizeof(in_dev->cnf));
170 in_dev->cnf.sysctl = NULL;
172 if ((in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl)) == NULL)
174 /* Reference in_dev->dev */
176 /* Account for reference dev->ip_ptr (below) */
179 devinet_sysctl_register(in_dev);
180 ip_mc_init_dev(in_dev);
181 if (dev->flags & IFF_UP)
184 /* we can receive as soon as ip_ptr is set -- do this last */
185 rcu_assign_pointer(dev->ip_ptr, in_dev);
194 static void in_dev_rcu_put(struct rcu_head *head)
196 struct in_device *idev = container_of(head, struct in_device, rcu_head);
200 static void inetdev_destroy(struct in_device *in_dev)
202 struct in_ifaddr *ifa;
203 struct net_device *dev;
211 ip_mc_destroy_dev(in_dev);
213 while ((ifa = in_dev->ifa_list) != NULL) {
214 inet_del_ifa(in_dev, &in_dev->ifa_list, 0);
220 devinet_sysctl_unregister(in_dev);
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, __be32 a, __be32 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,
243 int destroy, struct nlmsghdr *nlh, u32 pid)
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, nlh, pid);
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, nlh, pid);
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, nlh, pid);
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))
328 static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
331 __inet_del_ifa(in_dev, ifap, destroy, NULL, 0);
334 static int __inet_insert_ifa(struct in_ifaddr *ifa, struct nlmsghdr *nlh,
337 struct in_device *in_dev = ifa->ifa_dev;
338 struct in_ifaddr *ifa1, **ifap, **last_primary;
342 if (!ifa->ifa_local) {
347 ifa->ifa_flags &= ~IFA_F_SECONDARY;
348 last_primary = &in_dev->ifa_list;
350 for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL;
351 ifap = &ifa1->ifa_next) {
352 if (!(ifa1->ifa_flags & IFA_F_SECONDARY) &&
353 ifa->ifa_scope <= ifa1->ifa_scope)
354 last_primary = &ifa1->ifa_next;
355 if (ifa1->ifa_mask == ifa->ifa_mask &&
356 inet_ifa_match(ifa1->ifa_address, ifa)) {
357 if (ifa1->ifa_local == ifa->ifa_local) {
361 if (ifa1->ifa_scope != ifa->ifa_scope) {
365 ifa->ifa_flags |= IFA_F_SECONDARY;
369 if (!(ifa->ifa_flags & IFA_F_SECONDARY)) {
370 net_srandom(ifa->ifa_local);
374 ifa->ifa_next = *ifap;
377 /* Send message first, then call notifier.
378 Notifier will trigger FIB update, so that
379 listeners of netlink will know about new ifaddr */
380 rtmsg_ifa(RTM_NEWADDR, ifa, nlh, pid);
381 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
386 static int inet_insert_ifa(struct in_ifaddr *ifa)
388 return __inet_insert_ifa(ifa, NULL, 0);
391 static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa)
393 struct in_device *in_dev = __in_dev_get_rtnl(dev);
401 ipv4_devconf_setall(in_dev);
402 if (ifa->ifa_dev != in_dev) {
403 BUG_TRAP(!ifa->ifa_dev);
405 ifa->ifa_dev = in_dev;
407 if (LOOPBACK(ifa->ifa_local))
408 ifa->ifa_scope = RT_SCOPE_HOST;
409 return inet_insert_ifa(ifa);
412 struct in_device *inetdev_by_index(int ifindex)
414 struct net_device *dev;
415 struct in_device *in_dev = NULL;
416 read_lock(&dev_base_lock);
417 dev = __dev_get_by_index(&init_net, ifindex);
419 in_dev = in_dev_get(dev);
420 read_unlock(&dev_base_lock);
424 /* Called only from RTNL semaphored context. No locks. */
426 struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, __be32 prefix,
431 for_primary_ifa(in_dev) {
432 if (ifa->ifa_mask == mask && inet_ifa_match(prefix, ifa))
434 } endfor_ifa(in_dev);
438 static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
440 struct net *net = skb->sk->sk_net;
441 struct nlattr *tb[IFA_MAX+1];
442 struct in_device *in_dev;
443 struct ifaddrmsg *ifm;
444 struct in_ifaddr *ifa, **ifap;
449 if (net != &init_net)
452 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
456 ifm = nlmsg_data(nlh);
457 in_dev = inetdev_by_index(ifm->ifa_index);
458 if (in_dev == NULL) {
463 __in_dev_put(in_dev);
465 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
466 ifap = &ifa->ifa_next) {
468 ifa->ifa_local != nla_get_be32(tb[IFA_LOCAL]))
471 if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label))
474 if (tb[IFA_ADDRESS] &&
475 (ifm->ifa_prefixlen != ifa->ifa_prefixlen ||
476 !inet_ifa_match(nla_get_be32(tb[IFA_ADDRESS]), ifa)))
479 __inet_del_ifa(in_dev, ifap, 1, nlh, NETLINK_CB(skb).pid);
483 err = -EADDRNOTAVAIL;
488 static struct in_ifaddr *rtm_to_ifaddr(struct nlmsghdr *nlh)
490 struct nlattr *tb[IFA_MAX+1];
491 struct in_ifaddr *ifa;
492 struct ifaddrmsg *ifm;
493 struct net_device *dev;
494 struct in_device *in_dev;
497 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
501 ifm = nlmsg_data(nlh);
502 if (ifm->ifa_prefixlen > 32 || tb[IFA_LOCAL] == NULL) {
507 dev = __dev_get_by_index(&init_net, ifm->ifa_index);
513 in_dev = __in_dev_get_rtnl(dev);
514 if (in_dev == NULL) {
519 ifa = inet_alloc_ifa();
522 * A potential indev allocation can be left alive, it stays
523 * assigned to its device and is destroy with it.
529 ipv4_devconf_setall(in_dev);
532 if (tb[IFA_ADDRESS] == NULL)
533 tb[IFA_ADDRESS] = tb[IFA_LOCAL];
535 ifa->ifa_prefixlen = ifm->ifa_prefixlen;
536 ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen);
537 ifa->ifa_flags = ifm->ifa_flags;
538 ifa->ifa_scope = ifm->ifa_scope;
539 ifa->ifa_dev = in_dev;
541 ifa->ifa_local = nla_get_be32(tb[IFA_LOCAL]);
542 ifa->ifa_address = nla_get_be32(tb[IFA_ADDRESS]);
544 if (tb[IFA_BROADCAST])
545 ifa->ifa_broadcast = nla_get_be32(tb[IFA_BROADCAST]);
548 ifa->ifa_anycast = nla_get_be32(tb[IFA_ANYCAST]);
551 nla_strlcpy(ifa->ifa_label, tb[IFA_LABEL], IFNAMSIZ);
553 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
561 static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
563 struct net *net = skb->sk->sk_net;
564 struct in_ifaddr *ifa;
568 if (net != &init_net)
571 ifa = rtm_to_ifaddr(nlh);
575 return __inet_insert_ifa(ifa, nlh, NETLINK_CB(skb).pid);
579 * Determine a default network mask, based on the IP address.
582 static __inline__ int inet_abc_len(__be32 addr)
584 int rc = -1; /* Something else, probably a multicast. */
589 __u32 haddr = ntohl(addr);
591 if (IN_CLASSA(haddr))
593 else if (IN_CLASSB(haddr))
595 else if (IN_CLASSC(haddr))
603 int devinet_ioctl(unsigned int cmd, void __user *arg)
606 struct sockaddr_in sin_orig;
607 struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
608 struct in_device *in_dev;
609 struct in_ifaddr **ifap = NULL;
610 struct in_ifaddr *ifa = NULL;
611 struct net_device *dev;
614 int tryaddrmatch = 0;
617 * Fetch the caller's info block into kernel space
620 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
622 ifr.ifr_name[IFNAMSIZ - 1] = 0;
624 /* save original address for comparison */
625 memcpy(&sin_orig, sin, sizeof(*sin));
627 colon = strchr(ifr.ifr_name, ':');
632 dev_load(&init_net, ifr.ifr_name);
636 case SIOCGIFADDR: /* Get interface address */
637 case SIOCGIFBRDADDR: /* Get the broadcast address */
638 case SIOCGIFDSTADDR: /* Get the destination address */
639 case SIOCGIFNETMASK: /* Get the netmask for the interface */
640 /* Note that these ioctls will not sleep,
641 so that we do not impose a lock.
642 One day we will be forced to put shlock here (I mean SMP)
644 tryaddrmatch = (sin_orig.sin_family == AF_INET);
645 memset(sin, 0, sizeof(*sin));
646 sin->sin_family = AF_INET;
651 if (!capable(CAP_NET_ADMIN))
654 case SIOCSIFADDR: /* Set interface address (and family) */
655 case SIOCSIFBRDADDR: /* Set the broadcast address */
656 case SIOCSIFDSTADDR: /* Set the destination address */
657 case SIOCSIFNETMASK: /* Set the netmask for the interface */
659 if (!capable(CAP_NET_ADMIN))
662 if (sin->sin_family != AF_INET)
673 if ((dev = __dev_get_by_name(&init_net, ifr.ifr_name)) == NULL)
679 if ((in_dev = __in_dev_get_rtnl(dev)) != NULL) {
681 /* Matthias Andree */
682 /* compare label and address (4.4BSD style) */
683 /* note: we only do this for a limited set of ioctls
684 and only if the original address family was AF_INET.
685 This is checked above. */
686 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
687 ifap = &ifa->ifa_next) {
688 if (!strcmp(ifr.ifr_name, ifa->ifa_label) &&
689 sin_orig.sin_addr.s_addr ==
695 /* we didn't get a match, maybe the application is
696 4.3BSD-style and passed in junk so we fall back to
697 comparing just the label */
699 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
700 ifap = &ifa->ifa_next)
701 if (!strcmp(ifr.ifr_name, ifa->ifa_label))
706 ret = -EADDRNOTAVAIL;
707 if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS)
711 case SIOCGIFADDR: /* Get interface address */
712 sin->sin_addr.s_addr = ifa->ifa_local;
715 case SIOCGIFBRDADDR: /* Get the broadcast address */
716 sin->sin_addr.s_addr = ifa->ifa_broadcast;
719 case SIOCGIFDSTADDR: /* Get the destination address */
720 sin->sin_addr.s_addr = ifa->ifa_address;
723 case SIOCGIFNETMASK: /* Get the netmask for the interface */
724 sin->sin_addr.s_addr = ifa->ifa_mask;
729 ret = -EADDRNOTAVAIL;
733 if (!(ifr.ifr_flags & IFF_UP))
734 inet_del_ifa(in_dev, ifap, 1);
737 ret = dev_change_flags(dev, ifr.ifr_flags);
740 case SIOCSIFADDR: /* Set interface address (and family) */
742 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
747 if ((ifa = inet_alloc_ifa()) == NULL)
750 memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ);
752 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
755 if (ifa->ifa_local == sin->sin_addr.s_addr)
757 inet_del_ifa(in_dev, ifap, 0);
758 ifa->ifa_broadcast = 0;
759 ifa->ifa_anycast = 0;
762 ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr;
764 if (!(dev->flags & IFF_POINTOPOINT)) {
765 ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address);
766 ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen);
767 if ((dev->flags & IFF_BROADCAST) &&
768 ifa->ifa_prefixlen < 31)
769 ifa->ifa_broadcast = ifa->ifa_address |
772 ifa->ifa_prefixlen = 32;
773 ifa->ifa_mask = inet_make_mask(32);
775 ret = inet_set_ifa(dev, ifa);
778 case SIOCSIFBRDADDR: /* Set the broadcast address */
780 if (ifa->ifa_broadcast != sin->sin_addr.s_addr) {
781 inet_del_ifa(in_dev, ifap, 0);
782 ifa->ifa_broadcast = sin->sin_addr.s_addr;
783 inet_insert_ifa(ifa);
787 case SIOCSIFDSTADDR: /* Set the destination address */
789 if (ifa->ifa_address == sin->sin_addr.s_addr)
792 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
795 inet_del_ifa(in_dev, ifap, 0);
796 ifa->ifa_address = sin->sin_addr.s_addr;
797 inet_insert_ifa(ifa);
800 case SIOCSIFNETMASK: /* Set the netmask for the interface */
803 * The mask we set must be legal.
806 if (bad_mask(sin->sin_addr.s_addr, 0))
809 if (ifa->ifa_mask != sin->sin_addr.s_addr) {
810 __be32 old_mask = ifa->ifa_mask;
811 inet_del_ifa(in_dev, ifap, 0);
812 ifa->ifa_mask = sin->sin_addr.s_addr;
813 ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask);
815 /* See if current broadcast address matches
816 * with current netmask, then recalculate
817 * the broadcast address. Otherwise it's a
818 * funny address, so don't touch it since
819 * the user seems to know what (s)he's doing...
821 if ((dev->flags & IFF_BROADCAST) &&
822 (ifa->ifa_prefixlen < 31) &&
823 (ifa->ifa_broadcast ==
824 (ifa->ifa_local|~old_mask))) {
825 ifa->ifa_broadcast = (ifa->ifa_local |
826 ~sin->sin_addr.s_addr);
828 inet_insert_ifa(ifa);
838 ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0;
842 static int inet_gifconf(struct net_device *dev, char __user *buf, int len)
844 struct in_device *in_dev = __in_dev_get_rtnl(dev);
845 struct in_ifaddr *ifa;
849 if (!in_dev || (ifa = in_dev->ifa_list) == NULL)
852 for (; ifa; ifa = ifa->ifa_next) {
857 if (len < (int) sizeof(ifr))
859 memset(&ifr, 0, sizeof(struct ifreq));
861 strcpy(ifr.ifr_name, ifa->ifa_label);
863 strcpy(ifr.ifr_name, dev->name);
865 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET;
866 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr =
869 if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) {
873 buf += sizeof(struct ifreq);
874 len -= sizeof(struct ifreq);
875 done += sizeof(struct ifreq);
881 __be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope)
884 struct in_device *in_dev;
887 in_dev = __in_dev_get_rcu(dev);
891 for_primary_ifa(in_dev) {
892 if (ifa->ifa_scope > scope)
894 if (!dst || inet_ifa_match(dst, ifa)) {
895 addr = ifa->ifa_local;
899 addr = ifa->ifa_local;
900 } endfor_ifa(in_dev);
907 /* Not loopback addresses on loopback should be preferred
908 in this case. It is importnat that lo is the first interface
911 read_lock(&dev_base_lock);
913 for_each_netdev(&init_net, dev) {
914 if ((in_dev = __in_dev_get_rcu(dev)) == NULL)
917 for_primary_ifa(in_dev) {
918 if (ifa->ifa_scope != RT_SCOPE_LINK &&
919 ifa->ifa_scope <= scope) {
920 addr = ifa->ifa_local;
921 goto out_unlock_both;
923 } endfor_ifa(in_dev);
926 read_unlock(&dev_base_lock);
932 static __be32 confirm_addr_indev(struct in_device *in_dev, __be32 dst,
933 __be32 local, int scope)
940 (local == ifa->ifa_local || !local) &&
941 ifa->ifa_scope <= scope) {
942 addr = ifa->ifa_local;
947 same = (!local || inet_ifa_match(local, ifa)) &&
948 (!dst || inet_ifa_match(dst, ifa));
952 /* Is the selected addr into dst subnet? */
953 if (inet_ifa_match(addr, ifa))
955 /* No, then can we use new local src? */
956 if (ifa->ifa_scope <= scope) {
957 addr = ifa->ifa_local;
960 /* search for large dst subnet for addr */
964 } endfor_ifa(in_dev);
966 return same? addr : 0;
970 * Confirm that local IP address exists using wildcards:
971 * - dev: only on this interface, 0=any interface
972 * - dst: only in the same subnet as dst, 0=any dst
973 * - local: address, 0=autoselect the local address
974 * - scope: maximum allowed scope value for the local address
976 __be32 inet_confirm_addr(const struct net_device *dev, __be32 dst, __be32 local, int scope)
979 struct in_device *in_dev;
983 if ((in_dev = __in_dev_get_rcu(dev)))
984 addr = confirm_addr_indev(in_dev, dst, local, scope);
990 read_lock(&dev_base_lock);
992 for_each_netdev(&init_net, dev) {
993 if ((in_dev = __in_dev_get_rcu(dev))) {
994 addr = confirm_addr_indev(in_dev, dst, local, scope);
1000 read_unlock(&dev_base_lock);
1009 int register_inetaddr_notifier(struct notifier_block *nb)
1011 return blocking_notifier_chain_register(&inetaddr_chain, nb);
1014 int unregister_inetaddr_notifier(struct notifier_block *nb)
1016 return blocking_notifier_chain_unregister(&inetaddr_chain, nb);
1019 /* Rename ifa_labels for a device name change. Make some effort to preserve existing
1020 * alias numbering and to create unique labels if possible.
1022 static void inetdev_changename(struct net_device *dev, struct in_device *in_dev)
1024 struct in_ifaddr *ifa;
1027 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
1028 char old[IFNAMSIZ], *dot;
1030 memcpy(old, ifa->ifa_label, IFNAMSIZ);
1031 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1034 dot = strchr(old, ':');
1036 sprintf(old, ":%d", named);
1039 if (strlen(dot) + strlen(dev->name) < IFNAMSIZ) {
1040 strcat(ifa->ifa_label, dot);
1042 strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot);
1047 /* Called only under RTNL semaphore */
1049 static int inetdev_event(struct notifier_block *this, unsigned long event,
1052 struct net_device *dev = ptr;
1053 struct in_device *in_dev = __in_dev_get_rtnl(dev);
1055 if (dev->nd_net != &init_net)
1061 if (event == NETDEV_REGISTER) {
1062 in_dev = inetdev_init(dev);
1064 return notifier_from_errno(-ENOMEM);
1065 if (dev->flags & IFF_LOOPBACK) {
1066 IN_DEV_CONF_SET(in_dev, NOXFRM, 1);
1067 IN_DEV_CONF_SET(in_dev, NOPOLICY, 1);
1074 case NETDEV_REGISTER:
1075 printk(KERN_DEBUG "inetdev_event: bug\n");
1081 if (dev->flags & IFF_LOOPBACK) {
1082 struct in_ifaddr *ifa;
1083 if ((ifa = inet_alloc_ifa()) != NULL) {
1085 ifa->ifa_address = htonl(INADDR_LOOPBACK);
1086 ifa->ifa_prefixlen = 8;
1087 ifa->ifa_mask = inet_make_mask(8);
1088 in_dev_hold(in_dev);
1089 ifa->ifa_dev = in_dev;
1090 ifa->ifa_scope = RT_SCOPE_HOST;
1091 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1092 inet_insert_ifa(ifa);
1100 case NETDEV_CHANGEMTU:
1103 /* MTU falled under 68, disable IP */
1104 case NETDEV_UNREGISTER:
1105 inetdev_destroy(in_dev);
1107 case NETDEV_CHANGENAME:
1108 /* Do not notify about label change, this event is
1109 * not interesting to applications using netlink.
1111 inetdev_changename(dev, in_dev);
1113 devinet_sysctl_unregister(in_dev);
1114 devinet_sysctl_register(in_dev);
1121 static struct notifier_block ip_netdev_notifier = {
1122 .notifier_call =inetdev_event,
1125 static inline size_t inet_nlmsg_size(void)
1127 return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
1128 + nla_total_size(4) /* IFA_ADDRESS */
1129 + nla_total_size(4) /* IFA_LOCAL */
1130 + nla_total_size(4) /* IFA_BROADCAST */
1131 + nla_total_size(4) /* IFA_ANYCAST */
1132 + nla_total_size(IFNAMSIZ); /* IFA_LABEL */
1135 static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
1136 u32 pid, u32 seq, int event, unsigned int flags)
1138 struct ifaddrmsg *ifm;
1139 struct nlmsghdr *nlh;
1141 nlh = nlmsg_put(skb, pid, seq, event, sizeof(*ifm), flags);
1145 ifm = nlmsg_data(nlh);
1146 ifm->ifa_family = AF_INET;
1147 ifm->ifa_prefixlen = ifa->ifa_prefixlen;
1148 ifm->ifa_flags = ifa->ifa_flags|IFA_F_PERMANENT;
1149 ifm->ifa_scope = ifa->ifa_scope;
1150 ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
1152 if (ifa->ifa_address)
1153 NLA_PUT_BE32(skb, IFA_ADDRESS, ifa->ifa_address);
1156 NLA_PUT_BE32(skb, IFA_LOCAL, ifa->ifa_local);
1158 if (ifa->ifa_broadcast)
1159 NLA_PUT_BE32(skb, IFA_BROADCAST, ifa->ifa_broadcast);
1161 if (ifa->ifa_anycast)
1162 NLA_PUT_BE32(skb, IFA_ANYCAST, ifa->ifa_anycast);
1164 if (ifa->ifa_label[0])
1165 NLA_PUT_STRING(skb, IFA_LABEL, ifa->ifa_label);
1167 return nlmsg_end(skb, nlh);
1170 nlmsg_cancel(skb, nlh);
1174 static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
1176 struct net *net = skb->sk->sk_net;
1178 struct net_device *dev;
1179 struct in_device *in_dev;
1180 struct in_ifaddr *ifa;
1181 int s_ip_idx, s_idx = cb->args[0];
1183 if (net != &init_net)
1186 s_ip_idx = ip_idx = cb->args[1];
1188 for_each_netdev(&init_net, dev) {
1193 if ((in_dev = __in_dev_get_rtnl(dev)) == NULL)
1196 for (ifa = in_dev->ifa_list, ip_idx = 0; ifa;
1197 ifa = ifa->ifa_next, ip_idx++) {
1198 if (ip_idx < s_ip_idx)
1200 if (inet_fill_ifaddr(skb, ifa, NETLINK_CB(cb->skb).pid,
1202 RTM_NEWADDR, NLM_F_MULTI) <= 0)
1211 cb->args[1] = ip_idx;
1216 static void rtmsg_ifa(int event, struct in_ifaddr* ifa, struct nlmsghdr *nlh,
1219 struct sk_buff *skb;
1220 u32 seq = nlh ? nlh->nlmsg_seq : 0;
1223 skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL);
1227 err = inet_fill_ifaddr(skb, ifa, pid, seq, event, 0);
1229 /* -EMSGSIZE implies BUG in inet_nlmsg_size() */
1230 WARN_ON(err == -EMSGSIZE);
1234 err = rtnl_notify(skb, &init_net, pid, RTNLGRP_IPV4_IFADDR, nlh, GFP_KERNEL);
1237 rtnl_set_sk_err(&init_net, RTNLGRP_IPV4_IFADDR, err);
1240 #ifdef CONFIG_SYSCTL
1242 static void devinet_copy_dflt_conf(struct net *net, int i)
1244 struct net_device *dev;
1246 read_lock(&dev_base_lock);
1247 for_each_netdev(net, dev) {
1248 struct in_device *in_dev;
1250 in_dev = __in_dev_get_rcu(dev);
1251 if (in_dev && !test_bit(i, in_dev->cnf.state))
1252 in_dev->cnf.data[i] = net->ipv4.devconf_dflt->data[i];
1255 read_unlock(&dev_base_lock);
1258 static void inet_forward_change(struct net *net)
1260 struct net_device *dev;
1261 int on = IPV4_DEVCONF_ALL(net, FORWARDING);
1263 IPV4_DEVCONF_ALL(net, ACCEPT_REDIRECTS) = !on;
1264 IPV4_DEVCONF_DFLT(net, FORWARDING) = on;
1266 read_lock(&dev_base_lock);
1267 for_each_netdev(net, dev) {
1268 struct in_device *in_dev;
1270 in_dev = __in_dev_get_rcu(dev);
1272 IN_DEV_CONF_SET(in_dev, FORWARDING, on);
1275 read_unlock(&dev_base_lock);
1280 static int devinet_conf_proc(ctl_table *ctl, int write,
1281 struct file* filp, void __user *buffer,
1282 size_t *lenp, loff_t *ppos)
1284 int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1287 struct ipv4_devconf *cnf = ctl->extra1;
1288 struct net *net = ctl->extra2;
1289 int i = (int *)ctl->data - cnf->data;
1291 set_bit(i, cnf->state);
1293 if (cnf == net->ipv4.devconf_dflt)
1294 devinet_copy_dflt_conf(net, i);
1300 static int devinet_conf_sysctl(ctl_table *table, int __user *name, int nlen,
1301 void __user *oldval, size_t __user *oldlenp,
1302 void __user *newval, size_t newlen)
1304 struct ipv4_devconf *cnf;
1306 int *valp = table->data;
1310 if (!newval || !newlen)
1313 if (newlen != sizeof(int))
1316 if (get_user(new, (int __user *)newval))
1322 if (oldval && oldlenp) {
1325 if (get_user(len, oldlenp))
1329 if (len > table->maxlen)
1330 len = table->maxlen;
1331 if (copy_to_user(oldval, valp, len))
1333 if (put_user(len, oldlenp))
1340 cnf = table->extra1;
1341 net = table->extra2;
1342 i = (int *)table->data - cnf->data;
1344 set_bit(i, cnf->state);
1346 if (cnf == net->ipv4.devconf_dflt)
1347 devinet_copy_dflt_conf(net, i);
1352 static int devinet_sysctl_forward(ctl_table *ctl, int write,
1353 struct file* filp, void __user *buffer,
1354 size_t *lenp, loff_t *ppos)
1356 int *valp = ctl->data;
1358 int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1360 if (write && *valp != val) {
1361 struct net *net = ctl->extra2;
1363 if (valp == &IPV4_DEVCONF_ALL(net, FORWARDING))
1364 inet_forward_change(net);
1365 else if (valp != &IPV4_DEVCONF_DFLT(net, FORWARDING))
1372 int ipv4_doint_and_flush(ctl_table *ctl, int write,
1373 struct file* filp, void __user *buffer,
1374 size_t *lenp, loff_t *ppos)
1376 int *valp = ctl->data;
1378 int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1380 if (write && *valp != val)
1386 int ipv4_doint_and_flush_strategy(ctl_table *table, int __user *name, int nlen,
1387 void __user *oldval, size_t __user *oldlenp,
1388 void __user *newval, size_t newlen)
1390 int ret = devinet_conf_sysctl(table, name, nlen, oldval, oldlenp,
1400 #define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc, sysctl) \
1402 .ctl_name = NET_IPV4_CONF_ ## attr, \
1404 .data = ipv4_devconf.data + \
1405 NET_IPV4_CONF_ ## attr - 1, \
1406 .maxlen = sizeof(int), \
1408 .proc_handler = proc, \
1409 .strategy = sysctl, \
1410 .extra1 = &ipv4_devconf, \
1413 #define DEVINET_SYSCTL_RW_ENTRY(attr, name) \
1414 DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc, \
1415 devinet_conf_sysctl)
1417 #define DEVINET_SYSCTL_RO_ENTRY(attr, name) \
1418 DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc, \
1419 devinet_conf_sysctl)
1421 #define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc, sysctl) \
1422 DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc, sysctl)
1424 #define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \
1425 DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush, \
1426 ipv4_doint_and_flush_strategy)
1428 static struct devinet_sysctl_table {
1429 struct ctl_table_header *sysctl_header;
1430 struct ctl_table devinet_vars[__NET_IPV4_CONF_MAX];
1432 } devinet_sysctl = {
1434 DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING, "forwarding",
1435 devinet_sysctl_forward,
1436 devinet_conf_sysctl),
1437 DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING, "mc_forwarding"),
1439 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS, "accept_redirects"),
1440 DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS, "secure_redirects"),
1441 DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA, "shared_media"),
1442 DEVINET_SYSCTL_RW_ENTRY(RP_FILTER, "rp_filter"),
1443 DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS, "send_redirects"),
1444 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE,
1445 "accept_source_route"),
1446 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP, "proxy_arp"),
1447 DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID, "medium_id"),
1448 DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY, "bootp_relay"),
1449 DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS, "log_martians"),
1450 DEVINET_SYSCTL_RW_ENTRY(TAG, "tag"),
1451 DEVINET_SYSCTL_RW_ENTRY(ARPFILTER, "arp_filter"),
1452 DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE, "arp_announce"),
1453 DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE, "arp_ignore"),
1454 DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT, "arp_accept"),
1456 DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM, "disable_xfrm"),
1457 DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY, "disable_policy"),
1458 DEVINET_SYSCTL_FLUSHING_ENTRY(FORCE_IGMP_VERSION,
1459 "force_igmp_version"),
1460 DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES,
1461 "promote_secondaries"),
1465 static int __devinet_sysctl_register(struct net *net, char *dev_name,
1466 int ctl_name, struct ipv4_devconf *p)
1469 struct devinet_sysctl_table *t;
1471 #define DEVINET_CTL_PATH_DEV 3
1473 struct ctl_path devinet_ctl_path[] = {
1474 { .procname = "net", .ctl_name = CTL_NET, },
1475 { .procname = "ipv4", .ctl_name = NET_IPV4, },
1476 { .procname = "conf", .ctl_name = NET_IPV4_CONF, },
1477 { /* to be set */ },
1481 t = kmemdup(&devinet_sysctl, sizeof(*t), GFP_KERNEL);
1485 for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
1486 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
1487 t->devinet_vars[i].extra1 = p;
1488 t->devinet_vars[i].extra2 = net;
1492 * Make a copy of dev_name, because '.procname' is regarded as const
1493 * by sysctl and we wouldn't want anyone to change it under our feet
1494 * (see SIOCSIFNAME).
1496 t->dev_name = kstrdup(dev_name, GFP_KERNEL);
1500 devinet_ctl_path[DEVINET_CTL_PATH_DEV].procname = t->dev_name;
1501 devinet_ctl_path[DEVINET_CTL_PATH_DEV].ctl_name = ctl_name;
1503 t->sysctl_header = register_net_sysctl_table(net, devinet_ctl_path,
1505 if (!t->sysctl_header)
1519 static void __devinet_sysctl_unregister(struct ipv4_devconf *cnf)
1521 struct devinet_sysctl_table *t = cnf->sysctl;
1527 unregister_sysctl_table(t->sysctl_header);
1532 static void devinet_sysctl_register(struct in_device *idev)
1534 neigh_sysctl_register(idev->dev, idev->arp_parms, NET_IPV4,
1535 NET_IPV4_NEIGH, "ipv4", NULL, NULL);
1536 __devinet_sysctl_register(idev->dev->nd_net, idev->dev->name,
1537 idev->dev->ifindex, &idev->cnf);
1540 static void devinet_sysctl_unregister(struct in_device *idev)
1542 __devinet_sysctl_unregister(&idev->cnf);
1543 neigh_sysctl_unregister(idev->arp_parms);
1547 static struct ctl_table ctl_forward_entry[] = {
1549 .ctl_name = NET_IPV4_FORWARD,
1550 .procname = "ip_forward",
1551 .data = &ipv4_devconf.data[
1552 NET_IPV4_CONF_FORWARDING - 1],
1553 .maxlen = sizeof(int),
1555 .proc_handler = devinet_sysctl_forward,
1556 .strategy = devinet_conf_sysctl,
1557 .extra1 = &ipv4_devconf,
1558 .extra2 = &init_net,
1563 static __net_initdata struct ctl_path net_ipv4_path[] = {
1564 { .procname = "net", .ctl_name = CTL_NET, },
1565 { .procname = "ipv4", .ctl_name = NET_IPV4, },
1569 static __net_init int devinet_init_net(struct net *net)
1572 struct ctl_table *tbl;
1573 struct ipv4_devconf *all, *dflt;
1574 struct ctl_table_header *forw_hdr;
1577 all = &ipv4_devconf;
1578 dflt = &ipv4_devconf_dflt;
1579 tbl = ctl_forward_entry;
1581 if (net != &init_net) {
1582 all = kmemdup(all, sizeof(ipv4_devconf), GFP_KERNEL);
1586 dflt = kmemdup(dflt, sizeof(ipv4_devconf_dflt), GFP_KERNEL);
1588 goto err_alloc_dflt;
1590 tbl = kmemdup(tbl, sizeof(ctl_forward_entry), GFP_KERNEL);
1594 tbl[0].data = &all->data[NET_IPV4_CONF_FORWARDING - 1];
1595 tbl[0].extra1 = all;
1596 tbl[0].extra2 = net;
1599 #ifdef CONFIG_SYSCTL
1600 err = __devinet_sysctl_register(net, "all",
1601 NET_PROTO_CONF_ALL, all);
1605 err = __devinet_sysctl_register(net, "default",
1606 NET_PROTO_CONF_DEFAULT, dflt);
1611 forw_hdr = register_net_sysctl_table(net, net_ipv4_path, tbl);
1612 if (forw_hdr == NULL)
1616 net->ipv4.forw_hdr = forw_hdr;
1617 net->ipv4.devconf_all = all;
1618 net->ipv4.devconf_dflt = dflt;
1621 #ifdef CONFIG_SYSCTL
1623 __devinet_sysctl_unregister(dflt);
1625 __devinet_sysctl_unregister(all);
1627 if (tbl != ctl_forward_entry)
1631 if (dflt != &ipv4_devconf_dflt)
1634 if (all != &ipv4_devconf)
1640 static __net_exit void devinet_exit_net(struct net *net)
1642 struct ctl_table *tbl;
1644 tbl = net->ipv4.forw_hdr->ctl_table_arg;
1645 #ifdef CONFIG_SYSCTL
1646 unregister_net_sysctl_table(net->ipv4.forw_hdr);
1647 __devinet_sysctl_unregister(net->ipv4.devconf_dflt);
1648 __devinet_sysctl_unregister(net->ipv4.devconf_all);
1651 kfree(net->ipv4.devconf_dflt);
1652 kfree(net->ipv4.devconf_all);
1655 static __net_initdata struct pernet_operations devinet_ops = {
1656 .init = devinet_init_net,
1657 .exit = devinet_exit_net,
1660 void __init devinet_init(void)
1662 register_pernet_subsys(&devinet_ops);
1664 register_gifconf(PF_INET, inet_gifconf);
1665 register_netdevice_notifier(&ip_netdev_notifier);
1667 rtnl_register(PF_INET, RTM_NEWADDR, inet_rtm_newaddr, NULL);
1668 rtnl_register(PF_INET, RTM_DELADDR, inet_rtm_deladdr, NULL);
1669 rtnl_register(PF_INET, RTM_GETADDR, NULL, inet_dump_ifaddr);
1672 EXPORT_SYMBOL(in_dev_finish_destroy);
1673 EXPORT_SYMBOL(inet_select_addr);
1674 EXPORT_SYMBOL(inetdev_by_index);
1675 EXPORT_SYMBOL(register_inetaddr_notifier);
1676 EXPORT_SYMBOL(unregister_inetaddr_notifier);