2 * NET3 IP device support routines.
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version
7 * 2 of the License, or (at your option) any later version.
9 * Derived from the IP parts of dev.c 1.0.19
11 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
12 * Mark Evans, <evansmp@uhura.aston.ac.uk>
15 * Alan Cox, <gw4pts@gw4pts.ampr.org>
16 * Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
19 * Alexey Kuznetsov: pa_* fields are replaced with ifaddr
21 * Cyrus Durgin: updated for kmod
22 * Matthias Andree: in devinet_ioctl, compare label and
23 * address (4.4BSD alias style support),
24 * fall back to comparing just the label
29 #include <asm/uaccess.h>
30 #include <asm/system.h>
31 #include <linux/bitops.h>
32 #include <linux/capability.h>
33 #include <linux/module.h>
34 #include <linux/types.h>
35 #include <linux/kernel.h>
36 #include <linux/string.h>
38 #include <linux/socket.h>
39 #include <linux/sockios.h>
41 #include <linux/errno.h>
42 #include <linux/interrupt.h>
43 #include <linux/if_addr.h>
44 #include <linux/if_ether.h>
45 #include <linux/inet.h>
46 #include <linux/netdevice.h>
47 #include <linux/etherdevice.h>
48 #include <linux/skbuff.h>
49 #include <linux/init.h>
50 #include <linux/notifier.h>
51 #include <linux/inetdevice.h>
52 #include <linux/igmp.h>
54 #include <linux/sysctl.h>
56 #include <linux/kmod.h>
60 #include <net/route.h>
61 #include <net/ip_fib.h>
62 #include <net/rtnetlink.h>
63 #include <net/net_namespace.h>
65 static struct ipv4_devconf ipv4_devconf = {
67 [NET_IPV4_CONF_ACCEPT_REDIRECTS - 1] = 1,
68 [NET_IPV4_CONF_SEND_REDIRECTS - 1] = 1,
69 [NET_IPV4_CONF_SECURE_REDIRECTS - 1] = 1,
70 [NET_IPV4_CONF_SHARED_MEDIA - 1] = 1,
74 static struct ipv4_devconf ipv4_devconf_dflt = {
76 [NET_IPV4_CONF_ACCEPT_REDIRECTS - 1] = 1,
77 [NET_IPV4_CONF_SEND_REDIRECTS - 1] = 1,
78 [NET_IPV4_CONF_SECURE_REDIRECTS - 1] = 1,
79 [NET_IPV4_CONF_SHARED_MEDIA - 1] = 1,
80 [NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE - 1] = 1,
84 #define IPV4_DEVCONF_DFLT(net, attr) \
85 IPV4_DEVCONF((*net->ipv4.devconf_dflt), attr)
87 static const struct nla_policy ifa_ipv4_policy[IFA_MAX+1] = {
88 [IFA_LOCAL] = { .type = NLA_U32 },
89 [IFA_ADDRESS] = { .type = NLA_U32 },
90 [IFA_BROADCAST] = { .type = NLA_U32 },
91 [IFA_LABEL] = { .type = NLA_STRING, .len = IFNAMSIZ - 1 },
94 static void rtmsg_ifa(int event, struct in_ifaddr *, struct nlmsghdr *, u32);
96 static BLOCKING_NOTIFIER_HEAD(inetaddr_chain);
97 static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
100 static void devinet_sysctl_register(struct in_device *idev);
101 static void devinet_sysctl_unregister(struct in_device *idev);
103 static inline void devinet_sysctl_register(struct in_device *idev)
106 static inline void devinet_sysctl_unregister(struct in_device *idev)
111 /* Locks all the inet devices. */
113 static struct in_ifaddr *inet_alloc_ifa(void)
115 return kzalloc(sizeof(struct in_ifaddr), GFP_KERNEL);
118 static void inet_rcu_free_ifa(struct rcu_head *head)
120 struct in_ifaddr *ifa = container_of(head, struct in_ifaddr, rcu_head);
122 in_dev_put(ifa->ifa_dev);
126 static inline void inet_free_ifa(struct in_ifaddr *ifa)
128 call_rcu(&ifa->rcu_head, inet_rcu_free_ifa);
131 void in_dev_finish_destroy(struct in_device *idev)
133 struct net_device *dev = idev->dev;
135 WARN_ON(idev->ifa_list);
136 WARN_ON(idev->mc_list);
137 #ifdef NET_REFCNT_DEBUG
138 printk(KERN_DEBUG "in_dev_finish_destroy: %p=%s\n",
139 idev, dev ? dev->name : "NIL");
143 printk("Freeing alive in_device %p\n", idev);
149 static struct in_device *inetdev_init(struct net_device *dev)
151 struct in_device *in_dev;
155 in_dev = kzalloc(sizeof(*in_dev), GFP_KERNEL);
158 memcpy(&in_dev->cnf, dev_net(dev)->ipv4.devconf_dflt,
159 sizeof(in_dev->cnf));
160 in_dev->cnf.sysctl = NULL;
162 if ((in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl)) == NULL)
164 if (IPV4_DEVCONF(in_dev->cnf, FORWARDING))
165 dev_disable_lro(dev);
166 /* Reference in_dev->dev */
168 /* Account for reference dev->ip_ptr (below) */
171 devinet_sysctl_register(in_dev);
172 ip_mc_init_dev(in_dev);
173 if (dev->flags & IFF_UP)
176 /* we can receive as soon as ip_ptr is set -- do this last */
177 rcu_assign_pointer(dev->ip_ptr, in_dev);
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;
203 ip_mc_destroy_dev(in_dev);
205 while ((ifa = in_dev->ifa_list) != NULL) {
206 inet_del_ifa(in_dev, &in_dev->ifa_list, 0);
212 devinet_sysctl_unregister(in_dev);
213 neigh_parms_release(&arp_tbl, in_dev->arp_parms);
216 call_rcu(&in_dev->rcu_head, in_dev_rcu_put);
219 int inet_addr_onlink(struct in_device *in_dev, __be32 a, __be32 b)
222 for_primary_ifa(in_dev) {
223 if (inet_ifa_match(a, ifa)) {
224 if (!b || inet_ifa_match(b, ifa)) {
229 } endfor_ifa(in_dev);
234 static void __inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
235 int destroy, struct nlmsghdr *nlh, u32 pid)
237 struct in_ifaddr *promote = NULL;
238 struct in_ifaddr *ifa, *ifa1 = *ifap;
239 struct in_ifaddr *last_prim = in_dev->ifa_list;
240 struct in_ifaddr *prev_prom = NULL;
241 int do_promote = IN_DEV_PROMOTE_SECONDARIES(in_dev);
245 /* 1. Deleting primary ifaddr forces deletion all secondaries
246 * unless alias promotion is set
249 if (!(ifa1->ifa_flags & IFA_F_SECONDARY)) {
250 struct in_ifaddr **ifap1 = &ifa1->ifa_next;
252 while ((ifa = *ifap1) != NULL) {
253 if (!(ifa->ifa_flags & IFA_F_SECONDARY) &&
254 ifa1->ifa_scope <= ifa->ifa_scope)
257 if (!(ifa->ifa_flags & IFA_F_SECONDARY) ||
258 ifa1->ifa_mask != ifa->ifa_mask ||
259 !inet_ifa_match(ifa1->ifa_address, ifa)) {
260 ifap1 = &ifa->ifa_next;
266 *ifap1 = ifa->ifa_next;
268 rtmsg_ifa(RTM_DELADDR, ifa, nlh, pid);
269 blocking_notifier_call_chain(&inetaddr_chain,
281 *ifap = ifa1->ifa_next;
283 /* 3. Announce address deletion */
285 /* Send message first, then call notifier.
286 At first sight, FIB update triggered by notifier
287 will refer to already deleted ifaddr, that could confuse
288 netlink listeners. It is not true: look, gated sees
289 that route deleted and if it still thinks that ifaddr
290 is valid, it will try to restore deleted routes... Grr.
291 So that, this order is correct.
293 rtmsg_ifa(RTM_DELADDR, ifa1, nlh, pid);
294 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1);
299 prev_prom->ifa_next = promote->ifa_next;
300 promote->ifa_next = last_prim->ifa_next;
301 last_prim->ifa_next = promote;
304 promote->ifa_flags &= ~IFA_F_SECONDARY;
305 rtmsg_ifa(RTM_NEWADDR, promote, nlh, pid);
306 blocking_notifier_call_chain(&inetaddr_chain,
308 for (ifa = promote->ifa_next; ifa; ifa = ifa->ifa_next) {
309 if (ifa1->ifa_mask != ifa->ifa_mask ||
310 !inet_ifa_match(ifa1->ifa_address, ifa))
320 static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
323 __inet_del_ifa(in_dev, ifap, destroy, NULL, 0);
326 static int __inet_insert_ifa(struct in_ifaddr *ifa, struct nlmsghdr *nlh,
329 struct in_device *in_dev = ifa->ifa_dev;
330 struct in_ifaddr *ifa1, **ifap, **last_primary;
334 if (!ifa->ifa_local) {
339 ifa->ifa_flags &= ~IFA_F_SECONDARY;
340 last_primary = &in_dev->ifa_list;
342 for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL;
343 ifap = &ifa1->ifa_next) {
344 if (!(ifa1->ifa_flags & IFA_F_SECONDARY) &&
345 ifa->ifa_scope <= ifa1->ifa_scope)
346 last_primary = &ifa1->ifa_next;
347 if (ifa1->ifa_mask == ifa->ifa_mask &&
348 inet_ifa_match(ifa1->ifa_address, ifa)) {
349 if (ifa1->ifa_local == ifa->ifa_local) {
353 if (ifa1->ifa_scope != ifa->ifa_scope) {
357 ifa->ifa_flags |= IFA_F_SECONDARY;
361 if (!(ifa->ifa_flags & IFA_F_SECONDARY)) {
362 net_srandom(ifa->ifa_local);
366 ifa->ifa_next = *ifap;
369 /* Send message first, then call notifier.
370 Notifier will trigger FIB update, so that
371 listeners of netlink will know about new ifaddr */
372 rtmsg_ifa(RTM_NEWADDR, ifa, nlh, pid);
373 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
378 static int inet_insert_ifa(struct in_ifaddr *ifa)
380 return __inet_insert_ifa(ifa, NULL, 0);
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);
393 ipv4_devconf_setall(in_dev);
394 if (ifa->ifa_dev != in_dev) {
395 WARN_ON(ifa->ifa_dev);
397 ifa->ifa_dev = in_dev;
399 if (ipv4_is_loopback(ifa->ifa_local))
400 ifa->ifa_scope = RT_SCOPE_HOST;
401 return inet_insert_ifa(ifa);
404 struct in_device *inetdev_by_index(struct net *net, int ifindex)
406 struct net_device *dev;
407 struct in_device *in_dev = NULL;
408 read_lock(&dev_base_lock);
409 dev = __dev_get_by_index(net, ifindex);
411 in_dev = in_dev_get(dev);
412 read_unlock(&dev_base_lock);
416 /* Called only from RTNL semaphored context. No locks. */
418 struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, __be32 prefix,
423 for_primary_ifa(in_dev) {
424 if (ifa->ifa_mask == mask && inet_ifa_match(prefix, ifa))
426 } endfor_ifa(in_dev);
430 static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
432 struct net *net = sock_net(skb->sk);
433 struct nlattr *tb[IFA_MAX+1];
434 struct in_device *in_dev;
435 struct ifaddrmsg *ifm;
436 struct in_ifaddr *ifa, **ifap;
441 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
445 ifm = nlmsg_data(nlh);
446 in_dev = inetdev_by_index(net, ifm->ifa_index);
447 if (in_dev == NULL) {
452 __in_dev_put(in_dev);
454 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
455 ifap = &ifa->ifa_next) {
457 ifa->ifa_local != nla_get_be32(tb[IFA_LOCAL]))
460 if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label))
463 if (tb[IFA_ADDRESS] &&
464 (ifm->ifa_prefixlen != ifa->ifa_prefixlen ||
465 !inet_ifa_match(nla_get_be32(tb[IFA_ADDRESS]), ifa)))
468 __inet_del_ifa(in_dev, ifap, 1, nlh, NETLINK_CB(skb).pid);
472 err = -EADDRNOTAVAIL;
477 static struct in_ifaddr *rtm_to_ifaddr(struct net *net, struct nlmsghdr *nlh)
479 struct nlattr *tb[IFA_MAX+1];
480 struct in_ifaddr *ifa;
481 struct ifaddrmsg *ifm;
482 struct net_device *dev;
483 struct in_device *in_dev;
486 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
490 ifm = nlmsg_data(nlh);
492 if (ifm->ifa_prefixlen > 32 || tb[IFA_LOCAL] == NULL)
495 dev = __dev_get_by_index(net, ifm->ifa_index);
500 in_dev = __in_dev_get_rtnl(dev);
505 ifa = inet_alloc_ifa();
508 * A potential indev allocation can be left alive, it stays
509 * assigned to its device and is destroy with it.
513 ipv4_devconf_setall(in_dev);
516 if (tb[IFA_ADDRESS] == NULL)
517 tb[IFA_ADDRESS] = tb[IFA_LOCAL];
519 ifa->ifa_prefixlen = ifm->ifa_prefixlen;
520 ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen);
521 ifa->ifa_flags = ifm->ifa_flags;
522 ifa->ifa_scope = ifm->ifa_scope;
523 ifa->ifa_dev = in_dev;
525 ifa->ifa_local = nla_get_be32(tb[IFA_LOCAL]);
526 ifa->ifa_address = nla_get_be32(tb[IFA_ADDRESS]);
528 if (tb[IFA_BROADCAST])
529 ifa->ifa_broadcast = nla_get_be32(tb[IFA_BROADCAST]);
532 nla_strlcpy(ifa->ifa_label, tb[IFA_LABEL], IFNAMSIZ);
534 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
542 static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
544 struct net *net = sock_net(skb->sk);
545 struct in_ifaddr *ifa;
549 ifa = rtm_to_ifaddr(net, nlh);
553 return __inet_insert_ifa(ifa, nlh, NETLINK_CB(skb).pid);
557 * Determine a default network mask, based on the IP address.
560 static __inline__ int inet_abc_len(__be32 addr)
562 int rc = -1; /* Something else, probably a multicast. */
564 if (ipv4_is_zeronet(addr))
567 __u32 haddr = ntohl(addr);
569 if (IN_CLASSA(haddr))
571 else if (IN_CLASSB(haddr))
573 else if (IN_CLASSC(haddr))
581 int devinet_ioctl(struct net *net, unsigned int cmd, void __user *arg)
584 struct sockaddr_in sin_orig;
585 struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
586 struct in_device *in_dev;
587 struct in_ifaddr **ifap = NULL;
588 struct in_ifaddr *ifa = NULL;
589 struct net_device *dev;
592 int tryaddrmatch = 0;
595 * Fetch the caller's info block into kernel space
598 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
600 ifr.ifr_name[IFNAMSIZ - 1] = 0;
602 /* save original address for comparison */
603 memcpy(&sin_orig, sin, sizeof(*sin));
605 colon = strchr(ifr.ifr_name, ':');
609 dev_load(net, ifr.ifr_name);
612 case SIOCGIFADDR: /* Get interface address */
613 case SIOCGIFBRDADDR: /* Get the broadcast address */
614 case SIOCGIFDSTADDR: /* Get the destination address */
615 case SIOCGIFNETMASK: /* Get the netmask for the interface */
616 /* Note that these ioctls will not sleep,
617 so that we do not impose a lock.
618 One day we will be forced to put shlock here (I mean SMP)
620 tryaddrmatch = (sin_orig.sin_family == AF_INET);
621 memset(sin, 0, sizeof(*sin));
622 sin->sin_family = AF_INET;
627 if (!capable(CAP_NET_ADMIN))
630 case SIOCSIFADDR: /* Set interface address (and family) */
631 case SIOCSIFBRDADDR: /* Set the broadcast address */
632 case SIOCSIFDSTADDR: /* Set the destination address */
633 case SIOCSIFNETMASK: /* Set the netmask for the interface */
635 if (!capable(CAP_NET_ADMIN))
638 if (sin->sin_family != AF_INET)
649 if ((dev = __dev_get_by_name(net, ifr.ifr_name)) == NULL)
655 if ((in_dev = __in_dev_get_rtnl(dev)) != NULL) {
657 /* Matthias Andree */
658 /* compare label and address (4.4BSD style) */
659 /* note: we only do this for a limited set of ioctls
660 and only if the original address family was AF_INET.
661 This is checked above. */
662 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
663 ifap = &ifa->ifa_next) {
664 if (!strcmp(ifr.ifr_name, ifa->ifa_label) &&
665 sin_orig.sin_addr.s_addr ==
671 /* we didn't get a match, maybe the application is
672 4.3BSD-style and passed in junk so we fall back to
673 comparing just the label */
675 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
676 ifap = &ifa->ifa_next)
677 if (!strcmp(ifr.ifr_name, ifa->ifa_label))
682 ret = -EADDRNOTAVAIL;
683 if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS)
687 case SIOCGIFADDR: /* Get interface address */
688 sin->sin_addr.s_addr = ifa->ifa_local;
691 case SIOCGIFBRDADDR: /* Get the broadcast address */
692 sin->sin_addr.s_addr = ifa->ifa_broadcast;
695 case SIOCGIFDSTADDR: /* Get the destination address */
696 sin->sin_addr.s_addr = ifa->ifa_address;
699 case SIOCGIFNETMASK: /* Get the netmask for the interface */
700 sin->sin_addr.s_addr = ifa->ifa_mask;
705 ret = -EADDRNOTAVAIL;
709 if (!(ifr.ifr_flags & IFF_UP))
710 inet_del_ifa(in_dev, ifap, 1);
713 ret = dev_change_flags(dev, ifr.ifr_flags);
716 case SIOCSIFADDR: /* Set interface address (and family) */
718 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
723 if ((ifa = inet_alloc_ifa()) == NULL)
726 memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ);
728 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
731 if (ifa->ifa_local == sin->sin_addr.s_addr)
733 inet_del_ifa(in_dev, ifap, 0);
734 ifa->ifa_broadcast = 0;
738 ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr;
740 if (!(dev->flags & IFF_POINTOPOINT)) {
741 ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address);
742 ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen);
743 if ((dev->flags & IFF_BROADCAST) &&
744 ifa->ifa_prefixlen < 31)
745 ifa->ifa_broadcast = ifa->ifa_address |
748 ifa->ifa_prefixlen = 32;
749 ifa->ifa_mask = inet_make_mask(32);
751 ret = inet_set_ifa(dev, ifa);
754 case SIOCSIFBRDADDR: /* Set the broadcast address */
756 if (ifa->ifa_broadcast != sin->sin_addr.s_addr) {
757 inet_del_ifa(in_dev, ifap, 0);
758 ifa->ifa_broadcast = sin->sin_addr.s_addr;
759 inet_insert_ifa(ifa);
763 case SIOCSIFDSTADDR: /* Set the destination address */
765 if (ifa->ifa_address == sin->sin_addr.s_addr)
768 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
771 inet_del_ifa(in_dev, ifap, 0);
772 ifa->ifa_address = sin->sin_addr.s_addr;
773 inet_insert_ifa(ifa);
776 case SIOCSIFNETMASK: /* Set the netmask for the interface */
779 * The mask we set must be legal.
782 if (bad_mask(sin->sin_addr.s_addr, 0))
785 if (ifa->ifa_mask != sin->sin_addr.s_addr) {
786 __be32 old_mask = ifa->ifa_mask;
787 inet_del_ifa(in_dev, ifap, 0);
788 ifa->ifa_mask = sin->sin_addr.s_addr;
789 ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask);
791 /* See if current broadcast address matches
792 * with current netmask, then recalculate
793 * the broadcast address. Otherwise it's a
794 * funny address, so don't touch it since
795 * the user seems to know what (s)he's doing...
797 if ((dev->flags & IFF_BROADCAST) &&
798 (ifa->ifa_prefixlen < 31) &&
799 (ifa->ifa_broadcast ==
800 (ifa->ifa_local|~old_mask))) {
801 ifa->ifa_broadcast = (ifa->ifa_local |
802 ~sin->sin_addr.s_addr);
804 inet_insert_ifa(ifa);
814 ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0;
818 static int inet_gifconf(struct net_device *dev, char __user *buf, int len)
820 struct in_device *in_dev = __in_dev_get_rtnl(dev);
821 struct in_ifaddr *ifa;
825 if (!in_dev || (ifa = in_dev->ifa_list) == NULL)
828 for (; ifa; ifa = ifa->ifa_next) {
833 if (len < (int) sizeof(ifr))
835 memset(&ifr, 0, sizeof(struct ifreq));
837 strcpy(ifr.ifr_name, ifa->ifa_label);
839 strcpy(ifr.ifr_name, dev->name);
841 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET;
842 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr =
845 if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) {
849 buf += sizeof(struct ifreq);
850 len -= sizeof(struct ifreq);
851 done += sizeof(struct ifreq);
857 __be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope)
860 struct in_device *in_dev;
861 struct net *net = dev_net(dev);
864 in_dev = __in_dev_get_rcu(dev);
868 for_primary_ifa(in_dev) {
869 if (ifa->ifa_scope > scope)
871 if (!dst || inet_ifa_match(dst, ifa)) {
872 addr = ifa->ifa_local;
876 addr = ifa->ifa_local;
877 } endfor_ifa(in_dev);
884 /* Not loopback addresses on loopback should be preferred
885 in this case. It is importnat that lo is the first interface
888 read_lock(&dev_base_lock);
890 for_each_netdev(net, dev) {
891 if ((in_dev = __in_dev_get_rcu(dev)) == NULL)
894 for_primary_ifa(in_dev) {
895 if (ifa->ifa_scope != RT_SCOPE_LINK &&
896 ifa->ifa_scope <= scope) {
897 addr = ifa->ifa_local;
898 goto out_unlock_both;
900 } endfor_ifa(in_dev);
903 read_unlock(&dev_base_lock);
909 static __be32 confirm_addr_indev(struct in_device *in_dev, __be32 dst,
910 __be32 local, int scope)
917 (local == ifa->ifa_local || !local) &&
918 ifa->ifa_scope <= scope) {
919 addr = ifa->ifa_local;
924 same = (!local || inet_ifa_match(local, ifa)) &&
925 (!dst || inet_ifa_match(dst, ifa));
929 /* Is the selected addr into dst subnet? */
930 if (inet_ifa_match(addr, ifa))
932 /* No, then can we use new local src? */
933 if (ifa->ifa_scope <= scope) {
934 addr = ifa->ifa_local;
937 /* search for large dst subnet for addr */
941 } endfor_ifa(in_dev);
943 return same? addr : 0;
947 * Confirm that local IP address exists using wildcards:
948 * - in_dev: only on this interface, 0=any interface
949 * - dst: only in the same subnet as dst, 0=any dst
950 * - local: address, 0=autoselect the local address
951 * - scope: maximum allowed scope value for the local address
953 __be32 inet_confirm_addr(struct in_device *in_dev,
954 __be32 dst, __be32 local, int scope)
957 struct net_device *dev;
960 if (scope != RT_SCOPE_LINK)
961 return confirm_addr_indev(in_dev, dst, local, scope);
963 net = dev_net(in_dev->dev);
964 read_lock(&dev_base_lock);
966 for_each_netdev(net, dev) {
967 if ((in_dev = __in_dev_get_rcu(dev))) {
968 addr = confirm_addr_indev(in_dev, dst, local, scope);
974 read_unlock(&dev_base_lock);
983 int register_inetaddr_notifier(struct notifier_block *nb)
985 return blocking_notifier_chain_register(&inetaddr_chain, nb);
988 int unregister_inetaddr_notifier(struct notifier_block *nb)
990 return blocking_notifier_chain_unregister(&inetaddr_chain, nb);
993 /* Rename ifa_labels for a device name change. Make some effort to preserve existing
994 * alias numbering and to create unique labels if possible.
996 static void inetdev_changename(struct net_device *dev, struct in_device *in_dev)
998 struct in_ifaddr *ifa;
1001 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
1002 char old[IFNAMSIZ], *dot;
1004 memcpy(old, ifa->ifa_label, IFNAMSIZ);
1005 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1008 dot = strchr(old, ':');
1010 sprintf(old, ":%d", named);
1013 if (strlen(dot) + strlen(dev->name) < IFNAMSIZ) {
1014 strcat(ifa->ifa_label, dot);
1016 strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot);
1019 rtmsg_ifa(RTM_NEWADDR, ifa, NULL, 0);
1023 static inline bool inetdev_valid_mtu(unsigned mtu)
1028 /* Called only under RTNL semaphore */
1030 static int inetdev_event(struct notifier_block *this, unsigned long event,
1033 struct net_device *dev = ptr;
1034 struct in_device *in_dev = __in_dev_get_rtnl(dev);
1039 if (event == NETDEV_REGISTER) {
1040 in_dev = inetdev_init(dev);
1042 return notifier_from_errno(-ENOMEM);
1043 if (dev->flags & IFF_LOOPBACK) {
1044 IN_DEV_CONF_SET(in_dev, NOXFRM, 1);
1045 IN_DEV_CONF_SET(in_dev, NOPOLICY, 1);
1047 } else if (event == NETDEV_CHANGEMTU) {
1048 /* Re-enabling IP */
1049 if (inetdev_valid_mtu(dev->mtu))
1050 in_dev = inetdev_init(dev);
1056 case NETDEV_REGISTER:
1057 printk(KERN_DEBUG "inetdev_event: bug\n");
1061 if (!inetdev_valid_mtu(dev->mtu))
1063 if (dev->flags & IFF_LOOPBACK) {
1064 struct in_ifaddr *ifa;
1065 if ((ifa = inet_alloc_ifa()) != NULL) {
1067 ifa->ifa_address = htonl(INADDR_LOOPBACK);
1068 ifa->ifa_prefixlen = 8;
1069 ifa->ifa_mask = inet_make_mask(8);
1070 in_dev_hold(in_dev);
1071 ifa->ifa_dev = in_dev;
1072 ifa->ifa_scope = RT_SCOPE_HOST;
1073 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1074 inet_insert_ifa(ifa);
1079 case NETDEV_CHANGEADDR:
1080 if (IN_DEV_ARP_NOTIFY(in_dev))
1081 arp_send(ARPOP_REQUEST, ETH_P_ARP,
1082 in_dev->ifa_list->ifa_address,
1084 in_dev->ifa_list->ifa_address,
1085 NULL, dev->dev_addr, NULL);
1090 case NETDEV_CHANGEMTU:
1091 if (inetdev_valid_mtu(dev->mtu))
1093 /* disable IP when MTU is not enough */
1094 case NETDEV_UNREGISTER:
1095 inetdev_destroy(in_dev);
1097 case NETDEV_CHANGENAME:
1098 /* Do not notify about label change, this event is
1099 * not interesting to applications using netlink.
1101 inetdev_changename(dev, in_dev);
1103 devinet_sysctl_unregister(in_dev);
1104 devinet_sysctl_register(in_dev);
1111 static struct notifier_block ip_netdev_notifier = {
1112 .notifier_call = inetdev_event,
1115 static inline size_t inet_nlmsg_size(void)
1117 return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
1118 + nla_total_size(4) /* IFA_ADDRESS */
1119 + nla_total_size(4) /* IFA_LOCAL */
1120 + nla_total_size(4) /* IFA_BROADCAST */
1121 + nla_total_size(IFNAMSIZ); /* IFA_LABEL */
1124 static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
1125 u32 pid, u32 seq, int event, unsigned int flags)
1127 struct ifaddrmsg *ifm;
1128 struct nlmsghdr *nlh;
1130 nlh = nlmsg_put(skb, pid, seq, event, sizeof(*ifm), flags);
1134 ifm = nlmsg_data(nlh);
1135 ifm->ifa_family = AF_INET;
1136 ifm->ifa_prefixlen = ifa->ifa_prefixlen;
1137 ifm->ifa_flags = ifa->ifa_flags|IFA_F_PERMANENT;
1138 ifm->ifa_scope = ifa->ifa_scope;
1139 ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
1141 if (ifa->ifa_address)
1142 NLA_PUT_BE32(skb, IFA_ADDRESS, ifa->ifa_address);
1145 NLA_PUT_BE32(skb, IFA_LOCAL, ifa->ifa_local);
1147 if (ifa->ifa_broadcast)
1148 NLA_PUT_BE32(skb, IFA_BROADCAST, ifa->ifa_broadcast);
1150 if (ifa->ifa_label[0])
1151 NLA_PUT_STRING(skb, IFA_LABEL, ifa->ifa_label);
1153 return nlmsg_end(skb, nlh);
1156 nlmsg_cancel(skb, nlh);
1160 static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
1162 struct net *net = sock_net(skb->sk);
1164 struct net_device *dev;
1165 struct in_device *in_dev;
1166 struct in_ifaddr *ifa;
1167 int s_ip_idx, s_idx = cb->args[0];
1169 s_ip_idx = ip_idx = cb->args[1];
1171 for_each_netdev(net, dev) {
1176 if ((in_dev = __in_dev_get_rtnl(dev)) == NULL)
1179 for (ifa = in_dev->ifa_list, ip_idx = 0; ifa;
1180 ifa = ifa->ifa_next, ip_idx++) {
1181 if (ip_idx < s_ip_idx)
1183 if (inet_fill_ifaddr(skb, ifa, NETLINK_CB(cb->skb).pid,
1185 RTM_NEWADDR, NLM_F_MULTI) <= 0)
1194 cb->args[1] = ip_idx;
1199 static void rtmsg_ifa(int event, struct in_ifaddr *ifa, struct nlmsghdr *nlh,
1202 struct sk_buff *skb;
1203 u32 seq = nlh ? nlh->nlmsg_seq : 0;
1207 net = dev_net(ifa->ifa_dev->dev);
1208 skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL);
1212 err = inet_fill_ifaddr(skb, ifa, pid, seq, event, 0);
1214 /* -EMSGSIZE implies BUG in inet_nlmsg_size() */
1215 WARN_ON(err == -EMSGSIZE);
1219 rtnl_notify(skb, net, pid, RTNLGRP_IPV4_IFADDR, nlh, GFP_KERNEL);
1223 rtnl_set_sk_err(net, RTNLGRP_IPV4_IFADDR, err);
1226 #ifdef CONFIG_SYSCTL
1228 static void devinet_copy_dflt_conf(struct net *net, int i)
1230 struct net_device *dev;
1232 read_lock(&dev_base_lock);
1233 for_each_netdev(net, dev) {
1234 struct in_device *in_dev;
1236 in_dev = __in_dev_get_rcu(dev);
1237 if (in_dev && !test_bit(i, in_dev->cnf.state))
1238 in_dev->cnf.data[i] = net->ipv4.devconf_dflt->data[i];
1241 read_unlock(&dev_base_lock);
1244 static void inet_forward_change(struct net *net)
1246 struct net_device *dev;
1247 int on = IPV4_DEVCONF_ALL(net, FORWARDING);
1249 IPV4_DEVCONF_ALL(net, ACCEPT_REDIRECTS) = !on;
1250 IPV4_DEVCONF_DFLT(net, FORWARDING) = on;
1252 read_lock(&dev_base_lock);
1253 for_each_netdev(net, dev) {
1254 struct in_device *in_dev;
1256 dev_disable_lro(dev);
1258 in_dev = __in_dev_get_rcu(dev);
1260 IN_DEV_CONF_SET(in_dev, FORWARDING, on);
1263 read_unlock(&dev_base_lock);
1266 static int devinet_conf_proc(ctl_table *ctl, int write,
1267 struct file *filp, void __user *buffer,
1268 size_t *lenp, loff_t *ppos)
1270 int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1273 struct ipv4_devconf *cnf = ctl->extra1;
1274 struct net *net = ctl->extra2;
1275 int i = (int *)ctl->data - cnf->data;
1277 set_bit(i, cnf->state);
1279 if (cnf == net->ipv4.devconf_dflt)
1280 devinet_copy_dflt_conf(net, i);
1286 static int devinet_conf_sysctl(ctl_table *table,
1287 void __user *oldval, size_t __user *oldlenp,
1288 void __user *newval, size_t newlen)
1290 struct ipv4_devconf *cnf;
1292 int *valp = table->data;
1296 if (!newval || !newlen)
1299 if (newlen != sizeof(int))
1302 if (get_user(new, (int __user *)newval))
1308 if (oldval && oldlenp) {
1311 if (get_user(len, oldlenp))
1315 if (len > table->maxlen)
1316 len = table->maxlen;
1317 if (copy_to_user(oldval, valp, len))
1319 if (put_user(len, oldlenp))
1326 cnf = table->extra1;
1327 net = table->extra2;
1328 i = (int *)table->data - cnf->data;
1330 set_bit(i, cnf->state);
1332 if (cnf == net->ipv4.devconf_dflt)
1333 devinet_copy_dflt_conf(net, i);
1338 static int devinet_sysctl_forward(ctl_table *ctl, int write,
1339 struct file *filp, void __user *buffer,
1340 size_t *lenp, loff_t *ppos)
1342 int *valp = ctl->data;
1344 int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1346 if (write && *valp != val) {
1347 struct net *net = ctl->extra2;
1349 if (valp != &IPV4_DEVCONF_DFLT(net, FORWARDING)) {
1351 if (valp == &IPV4_DEVCONF_ALL(net, FORWARDING)) {
1352 inet_forward_change(net);
1354 struct ipv4_devconf *cnf = ctl->extra1;
1355 struct in_device *idev =
1356 container_of(cnf, struct in_device, cnf);
1357 dev_disable_lro(idev->dev);
1360 rt_cache_flush(net, 0);
1367 int ipv4_doint_and_flush(ctl_table *ctl, int write,
1368 struct file *filp, void __user *buffer,
1369 size_t *lenp, loff_t *ppos)
1371 int *valp = ctl->data;
1373 int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1374 struct net *net = ctl->extra2;
1376 if (write && *valp != val)
1377 rt_cache_flush(net, 0);
1382 int ipv4_doint_and_flush_strategy(ctl_table *table,
1383 void __user *oldval, size_t __user *oldlenp,
1384 void __user *newval, size_t newlen)
1386 int ret = devinet_conf_sysctl(table, oldval, oldlenp, newval, newlen);
1387 struct net *net = table->extra2;
1390 rt_cache_flush(net, 0);
1396 #define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc, sysctl) \
1398 .ctl_name = NET_IPV4_CONF_ ## attr, \
1400 .data = ipv4_devconf.data + \
1401 NET_IPV4_CONF_ ## attr - 1, \
1402 .maxlen = sizeof(int), \
1404 .proc_handler = proc, \
1405 .strategy = sysctl, \
1406 .extra1 = &ipv4_devconf, \
1409 #define DEVINET_SYSCTL_RW_ENTRY(attr, name) \
1410 DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc, \
1411 devinet_conf_sysctl)
1413 #define DEVINET_SYSCTL_RO_ENTRY(attr, name) \
1414 DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc, \
1415 devinet_conf_sysctl)
1417 #define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc, sysctl) \
1418 DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc, sysctl)
1420 #define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \
1421 DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush, \
1422 ipv4_doint_and_flush_strategy)
1424 static struct devinet_sysctl_table {
1425 struct ctl_table_header *sysctl_header;
1426 struct ctl_table devinet_vars[__NET_IPV4_CONF_MAX];
1428 } devinet_sysctl = {
1430 DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING, "forwarding",
1431 devinet_sysctl_forward,
1432 devinet_conf_sysctl),
1433 DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING, "mc_forwarding"),
1435 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS, "accept_redirects"),
1436 DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS, "secure_redirects"),
1437 DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA, "shared_media"),
1438 DEVINET_SYSCTL_RW_ENTRY(RP_FILTER, "rp_filter"),
1439 DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS, "send_redirects"),
1440 DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE,
1441 "accept_source_route"),
1442 DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP, "proxy_arp"),
1443 DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID, "medium_id"),
1444 DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY, "bootp_relay"),
1445 DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS, "log_martians"),
1446 DEVINET_SYSCTL_RW_ENTRY(TAG, "tag"),
1447 DEVINET_SYSCTL_RW_ENTRY(ARPFILTER, "arp_filter"),
1448 DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE, "arp_announce"),
1449 DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE, "arp_ignore"),
1450 DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT, "arp_accept"),
1451 DEVINET_SYSCTL_RW_ENTRY(ARP_NOTIFY, "arp_notify"),
1453 DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM, "disable_xfrm"),
1454 DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY, "disable_policy"),
1455 DEVINET_SYSCTL_FLUSHING_ENTRY(FORCE_IGMP_VERSION,
1456 "force_igmp_version"),
1457 DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES,
1458 "promote_secondaries"),
1462 static int __devinet_sysctl_register(struct net *net, char *dev_name,
1463 int ctl_name, struct ipv4_devconf *p)
1466 struct devinet_sysctl_table *t;
1468 #define DEVINET_CTL_PATH_DEV 3
1470 struct ctl_path devinet_ctl_path[] = {
1471 { .procname = "net", .ctl_name = CTL_NET, },
1472 { .procname = "ipv4", .ctl_name = NET_IPV4, },
1473 { .procname = "conf", .ctl_name = NET_IPV4_CONF, },
1474 { /* to be set */ },
1478 t = kmemdup(&devinet_sysctl, sizeof(*t), GFP_KERNEL);
1482 for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
1483 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
1484 t->devinet_vars[i].extra1 = p;
1485 t->devinet_vars[i].extra2 = net;
1489 * Make a copy of dev_name, because '.procname' is regarded as const
1490 * by sysctl and we wouldn't want anyone to change it under our feet
1491 * (see SIOCSIFNAME).
1493 t->dev_name = kstrdup(dev_name, GFP_KERNEL);
1497 devinet_ctl_path[DEVINET_CTL_PATH_DEV].procname = t->dev_name;
1498 devinet_ctl_path[DEVINET_CTL_PATH_DEV].ctl_name = ctl_name;
1500 t->sysctl_header = register_net_sysctl_table(net, devinet_ctl_path,
1502 if (!t->sysctl_header)
1516 static void __devinet_sysctl_unregister(struct ipv4_devconf *cnf)
1518 struct devinet_sysctl_table *t = cnf->sysctl;
1524 unregister_sysctl_table(t->sysctl_header);
1529 static void devinet_sysctl_register(struct in_device *idev)
1531 neigh_sysctl_register(idev->dev, idev->arp_parms, NET_IPV4,
1532 NET_IPV4_NEIGH, "ipv4", NULL, NULL);
1533 __devinet_sysctl_register(dev_net(idev->dev), idev->dev->name,
1534 idev->dev->ifindex, &idev->cnf);
1537 static void devinet_sysctl_unregister(struct in_device *idev)
1539 __devinet_sysctl_unregister(&idev->cnf);
1540 neigh_sysctl_unregister(idev->arp_parms);
1543 static struct ctl_table ctl_forward_entry[] = {
1545 .ctl_name = NET_IPV4_FORWARD,
1546 .procname = "ip_forward",
1547 .data = &ipv4_devconf.data[
1548 NET_IPV4_CONF_FORWARDING - 1],
1549 .maxlen = sizeof(int),
1551 .proc_handler = devinet_sysctl_forward,
1552 .strategy = devinet_conf_sysctl,
1553 .extra1 = &ipv4_devconf,
1554 .extra2 = &init_net,
1559 static __net_initdata struct ctl_path net_ipv4_path[] = {
1560 { .procname = "net", .ctl_name = CTL_NET, },
1561 { .procname = "ipv4", .ctl_name = NET_IPV4, },
1566 static __net_init int devinet_init_net(struct net *net)
1569 struct ipv4_devconf *all, *dflt;
1570 #ifdef CONFIG_SYSCTL
1571 struct ctl_table *tbl = ctl_forward_entry;
1572 struct ctl_table_header *forw_hdr;
1576 all = &ipv4_devconf;
1577 dflt = &ipv4_devconf_dflt;
1579 if (net != &init_net) {
1580 all = kmemdup(all, sizeof(ipv4_devconf), GFP_KERNEL);
1584 dflt = kmemdup(dflt, sizeof(ipv4_devconf_dflt), GFP_KERNEL);
1586 goto err_alloc_dflt;
1588 #ifdef CONFIG_SYSCTL
1589 tbl = kmemdup(tbl, sizeof(ctl_forward_entry), GFP_KERNEL);
1593 tbl[0].data = &all->data[NET_IPV4_CONF_FORWARDING - 1];
1594 tbl[0].extra1 = all;
1595 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)
1614 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 #ifdef CONFIG_SYSCTL
1643 struct ctl_table *tbl;
1645 tbl = net->ipv4.forw_hdr->ctl_table_arg;
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);