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, .len = IFNAMSIZ - 1 },
91 static void rtmsg_ifa(int event, struct in_ifaddr *, struct nlmsghdr *, u32);
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, __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))
327 if (!in_dev->ifa_list)
328 inetdev_destroy(in_dev);
332 static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
335 __inet_del_ifa(in_dev, ifap, destroy, NULL, 0);
338 static int __inet_insert_ifa(struct in_ifaddr *ifa, struct nlmsghdr *nlh,
341 struct in_device *in_dev = ifa->ifa_dev;
342 struct in_ifaddr *ifa1, **ifap, **last_primary;
346 if (!ifa->ifa_local) {
351 ifa->ifa_flags &= ~IFA_F_SECONDARY;
352 last_primary = &in_dev->ifa_list;
354 for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL;
355 ifap = &ifa1->ifa_next) {
356 if (!(ifa1->ifa_flags & IFA_F_SECONDARY) &&
357 ifa->ifa_scope <= ifa1->ifa_scope)
358 last_primary = &ifa1->ifa_next;
359 if (ifa1->ifa_mask == ifa->ifa_mask &&
360 inet_ifa_match(ifa1->ifa_address, ifa)) {
361 if (ifa1->ifa_local == ifa->ifa_local) {
365 if (ifa1->ifa_scope != ifa->ifa_scope) {
369 ifa->ifa_flags |= IFA_F_SECONDARY;
373 if (!(ifa->ifa_flags & IFA_F_SECONDARY)) {
374 net_srandom(ifa->ifa_local);
378 ifa->ifa_next = *ifap;
381 /* Send message first, then call notifier.
382 Notifier will trigger FIB update, so that
383 listeners of netlink will know about new ifaddr */
384 rtmsg_ifa(RTM_NEWADDR, ifa, nlh, pid);
385 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
390 static int inet_insert_ifa(struct in_ifaddr *ifa)
392 return __inet_insert_ifa(ifa, NULL, 0);
395 static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa)
397 struct in_device *in_dev = __in_dev_get_rtnl(dev);
402 in_dev = inetdev_init(dev);
408 if (ifa->ifa_dev != in_dev) {
409 BUG_TRAP(!ifa->ifa_dev);
411 ifa->ifa_dev = in_dev;
413 if (LOOPBACK(ifa->ifa_local))
414 ifa->ifa_scope = RT_SCOPE_HOST;
415 return inet_insert_ifa(ifa);
418 struct in_device *inetdev_by_index(int ifindex)
420 struct net_device *dev;
421 struct in_device *in_dev = NULL;
422 read_lock(&dev_base_lock);
423 dev = __dev_get_by_index(ifindex);
425 in_dev = in_dev_get(dev);
426 read_unlock(&dev_base_lock);
430 /* Called only from RTNL semaphored context. No locks. */
432 struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, __be32 prefix,
437 for_primary_ifa(in_dev) {
438 if (ifa->ifa_mask == mask && inet_ifa_match(prefix, ifa))
440 } endfor_ifa(in_dev);
444 static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
446 struct nlattr *tb[IFA_MAX+1];
447 struct in_device *in_dev;
448 struct ifaddrmsg *ifm;
449 struct in_ifaddr *ifa, **ifap;
454 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
458 ifm = nlmsg_data(nlh);
459 in_dev = inetdev_by_index(ifm->ifa_index);
460 if (in_dev == NULL) {
465 __in_dev_put(in_dev);
467 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
468 ifap = &ifa->ifa_next) {
470 ifa->ifa_local != nla_get_be32(tb[IFA_LOCAL]))
473 if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label))
476 if (tb[IFA_ADDRESS] &&
477 (ifm->ifa_prefixlen != ifa->ifa_prefixlen ||
478 !inet_ifa_match(nla_get_be32(tb[IFA_ADDRESS]), ifa)))
481 __inet_del_ifa(in_dev, ifap, 1, nlh, NETLINK_CB(skb).pid);
485 err = -EADDRNOTAVAIL;
490 static struct in_ifaddr *rtm_to_ifaddr(struct nlmsghdr *nlh)
492 struct nlattr *tb[IFA_MAX+1];
493 struct in_ifaddr *ifa;
494 struct ifaddrmsg *ifm;
495 struct net_device *dev;
496 struct in_device *in_dev;
499 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
503 ifm = nlmsg_data(nlh);
504 if (ifm->ifa_prefixlen > 32 || tb[IFA_LOCAL] == NULL)
507 dev = __dev_get_by_index(ifm->ifa_index);
513 in_dev = __in_dev_get_rtnl(dev);
514 if (in_dev == NULL) {
515 in_dev = inetdev_init(dev);
516 if (in_dev == NULL) {
522 ifa = inet_alloc_ifa();
525 * A potential indev allocation can be left alive, it stays
526 * assigned to its device and is destroy with it.
534 if (tb[IFA_ADDRESS] == NULL)
535 tb[IFA_ADDRESS] = tb[IFA_LOCAL];
537 ifa->ifa_prefixlen = ifm->ifa_prefixlen;
538 ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen);
539 ifa->ifa_flags = ifm->ifa_flags;
540 ifa->ifa_scope = ifm->ifa_scope;
541 ifa->ifa_dev = in_dev;
543 ifa->ifa_local = nla_get_be32(tb[IFA_LOCAL]);
544 ifa->ifa_address = nla_get_be32(tb[IFA_ADDRESS]);
546 if (tb[IFA_BROADCAST])
547 ifa->ifa_broadcast = nla_get_be32(tb[IFA_BROADCAST]);
550 ifa->ifa_anycast = nla_get_be32(tb[IFA_ANYCAST]);
553 nla_strlcpy(ifa->ifa_label, tb[IFA_LABEL], IFNAMSIZ);
555 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
563 static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
565 struct in_ifaddr *ifa;
569 ifa = rtm_to_ifaddr(nlh);
573 return __inet_insert_ifa(ifa, nlh, NETLINK_CB(skb).pid);
577 * Determine a default network mask, based on the IP address.
580 static __inline__ int inet_abc_len(__be32 addr)
582 int rc = -1; /* Something else, probably a multicast. */
587 __u32 haddr = ntohl(addr);
589 if (IN_CLASSA(haddr))
591 else if (IN_CLASSB(haddr))
593 else if (IN_CLASSC(haddr))
601 int devinet_ioctl(unsigned int cmd, void __user *arg)
604 struct sockaddr_in sin_orig;
605 struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
606 struct in_device *in_dev;
607 struct in_ifaddr **ifap = NULL;
608 struct in_ifaddr *ifa = NULL;
609 struct net_device *dev;
612 int tryaddrmatch = 0;
615 * Fetch the caller's info block into kernel space
618 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
620 ifr.ifr_name[IFNAMSIZ - 1] = 0;
622 /* save original address for comparison */
623 memcpy(&sin_orig, sin, sizeof(*sin));
625 colon = strchr(ifr.ifr_name, ':');
630 dev_load(ifr.ifr_name);
634 case SIOCGIFADDR: /* Get interface address */
635 case SIOCGIFBRDADDR: /* Get the broadcast address */
636 case SIOCGIFDSTADDR: /* Get the destination address */
637 case SIOCGIFNETMASK: /* Get the netmask for the interface */
638 /* Note that these ioctls will not sleep,
639 so that we do not impose a lock.
640 One day we will be forced to put shlock here (I mean SMP)
642 tryaddrmatch = (sin_orig.sin_family == AF_INET);
643 memset(sin, 0, sizeof(*sin));
644 sin->sin_family = AF_INET;
649 if (!capable(CAP_NET_ADMIN))
652 case SIOCSIFADDR: /* Set interface address (and family) */
653 case SIOCSIFBRDADDR: /* Set the broadcast address */
654 case SIOCSIFDSTADDR: /* Set the destination address */
655 case SIOCSIFNETMASK: /* Set the netmask for the interface */
657 if (!capable(CAP_NET_ADMIN))
660 if (sin->sin_family != AF_INET)
671 if ((dev = __dev_get_by_name(ifr.ifr_name)) == NULL)
677 if ((in_dev = __in_dev_get_rtnl(dev)) != NULL) {
679 /* Matthias Andree */
680 /* compare label and address (4.4BSD style) */
681 /* note: we only do this for a limited set of ioctls
682 and only if the original address family was AF_INET.
683 This is checked above. */
684 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
685 ifap = &ifa->ifa_next) {
686 if (!strcmp(ifr.ifr_name, ifa->ifa_label) &&
687 sin_orig.sin_addr.s_addr ==
693 /* we didn't get a match, maybe the application is
694 4.3BSD-style and passed in junk so we fall back to
695 comparing just the label */
697 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
698 ifap = &ifa->ifa_next)
699 if (!strcmp(ifr.ifr_name, ifa->ifa_label))
704 ret = -EADDRNOTAVAIL;
705 if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS)
709 case SIOCGIFADDR: /* Get interface address */
710 sin->sin_addr.s_addr = ifa->ifa_local;
713 case SIOCGIFBRDADDR: /* Get the broadcast address */
714 sin->sin_addr.s_addr = ifa->ifa_broadcast;
717 case SIOCGIFDSTADDR: /* Get the destination address */
718 sin->sin_addr.s_addr = ifa->ifa_address;
721 case SIOCGIFNETMASK: /* Get the netmask for the interface */
722 sin->sin_addr.s_addr = ifa->ifa_mask;
727 ret = -EADDRNOTAVAIL;
731 if (!(ifr.ifr_flags & IFF_UP))
732 inet_del_ifa(in_dev, ifap, 1);
735 ret = dev_change_flags(dev, ifr.ifr_flags);
738 case SIOCSIFADDR: /* Set interface address (and family) */
740 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
745 if ((ifa = inet_alloc_ifa()) == NULL)
748 memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ);
750 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
753 if (ifa->ifa_local == sin->sin_addr.s_addr)
755 inet_del_ifa(in_dev, ifap, 0);
756 ifa->ifa_broadcast = 0;
757 ifa->ifa_anycast = 0;
760 ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr;
762 if (!(dev->flags & IFF_POINTOPOINT)) {
763 ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address);
764 ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen);
765 if ((dev->flags & IFF_BROADCAST) &&
766 ifa->ifa_prefixlen < 31)
767 ifa->ifa_broadcast = ifa->ifa_address |
770 ifa->ifa_prefixlen = 32;
771 ifa->ifa_mask = inet_make_mask(32);
773 ret = inet_set_ifa(dev, ifa);
776 case SIOCSIFBRDADDR: /* Set the broadcast address */
778 if (ifa->ifa_broadcast != sin->sin_addr.s_addr) {
779 inet_del_ifa(in_dev, ifap, 0);
780 ifa->ifa_broadcast = sin->sin_addr.s_addr;
781 inet_insert_ifa(ifa);
785 case SIOCSIFDSTADDR: /* Set the destination address */
787 if (ifa->ifa_address == sin->sin_addr.s_addr)
790 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
793 inet_del_ifa(in_dev, ifap, 0);
794 ifa->ifa_address = sin->sin_addr.s_addr;
795 inet_insert_ifa(ifa);
798 case SIOCSIFNETMASK: /* Set the netmask for the interface */
801 * The mask we set must be legal.
804 if (bad_mask(sin->sin_addr.s_addr, 0))
807 if (ifa->ifa_mask != sin->sin_addr.s_addr) {
808 __be32 old_mask = ifa->ifa_mask;
809 inet_del_ifa(in_dev, ifap, 0);
810 ifa->ifa_mask = sin->sin_addr.s_addr;
811 ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask);
813 /* See if current broadcast address matches
814 * with current netmask, then recalculate
815 * the broadcast address. Otherwise it's a
816 * funny address, so don't touch it since
817 * the user seems to know what (s)he's doing...
819 if ((dev->flags & IFF_BROADCAST) &&
820 (ifa->ifa_prefixlen < 31) &&
821 (ifa->ifa_broadcast ==
822 (ifa->ifa_local|~old_mask))) {
823 ifa->ifa_broadcast = (ifa->ifa_local |
824 ~sin->sin_addr.s_addr);
826 inet_insert_ifa(ifa);
836 ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0;
840 static int inet_gifconf(struct net_device *dev, char __user *buf, int len)
842 struct in_device *in_dev = __in_dev_get_rtnl(dev);
843 struct in_ifaddr *ifa;
847 if (!in_dev || (ifa = in_dev->ifa_list) == NULL)
850 for (; ifa; ifa = ifa->ifa_next) {
855 if (len < (int) sizeof(ifr))
857 memset(&ifr, 0, sizeof(struct ifreq));
859 strcpy(ifr.ifr_name, ifa->ifa_label);
861 strcpy(ifr.ifr_name, dev->name);
863 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET;
864 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr =
867 if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) {
871 buf += sizeof(struct ifreq);
872 len -= sizeof(struct ifreq);
873 done += sizeof(struct ifreq);
879 __be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope)
882 struct in_device *in_dev;
885 in_dev = __in_dev_get_rcu(dev);
889 for_primary_ifa(in_dev) {
890 if (ifa->ifa_scope > scope)
892 if (!dst || inet_ifa_match(dst, ifa)) {
893 addr = ifa->ifa_local;
897 addr = ifa->ifa_local;
898 } endfor_ifa(in_dev);
905 /* Not loopback addresses on loopback should be preferred
906 in this case. It is importnat that lo is the first interface
909 read_lock(&dev_base_lock);
911 for (dev = dev_base; dev; dev = dev->next) {
912 if ((in_dev = __in_dev_get_rcu(dev)) == NULL)
915 for_primary_ifa(in_dev) {
916 if (ifa->ifa_scope != RT_SCOPE_LINK &&
917 ifa->ifa_scope <= scope) {
918 addr = ifa->ifa_local;
919 goto out_unlock_both;
921 } endfor_ifa(in_dev);
924 read_unlock(&dev_base_lock);
930 static __be32 confirm_addr_indev(struct in_device *in_dev, __be32 dst,
931 __be32 local, int scope)
938 (local == ifa->ifa_local || !local) &&
939 ifa->ifa_scope <= scope) {
940 addr = ifa->ifa_local;
945 same = (!local || inet_ifa_match(local, ifa)) &&
946 (!dst || inet_ifa_match(dst, ifa));
950 /* Is the selected addr into dst subnet? */
951 if (inet_ifa_match(addr, ifa))
953 /* No, then can we use new local src? */
954 if (ifa->ifa_scope <= scope) {
955 addr = ifa->ifa_local;
958 /* search for large dst subnet for addr */
962 } endfor_ifa(in_dev);
964 return same? addr : 0;
968 * Confirm that local IP address exists using wildcards:
969 * - dev: only on this interface, 0=any interface
970 * - dst: only in the same subnet as dst, 0=any dst
971 * - local: address, 0=autoselect the local address
972 * - scope: maximum allowed scope value for the local address
974 __be32 inet_confirm_addr(const struct net_device *dev, __be32 dst, __be32 local, int scope)
977 struct in_device *in_dev;
981 if ((in_dev = __in_dev_get_rcu(dev)))
982 addr = confirm_addr_indev(in_dev, dst, local, scope);
988 read_lock(&dev_base_lock);
990 for (dev = dev_base; dev; dev = dev->next) {
991 if ((in_dev = __in_dev_get_rcu(dev))) {
992 addr = confirm_addr_indev(in_dev, dst, local, scope);
998 read_unlock(&dev_base_lock);
1007 int register_inetaddr_notifier(struct notifier_block *nb)
1009 return blocking_notifier_chain_register(&inetaddr_chain, nb);
1012 int unregister_inetaddr_notifier(struct notifier_block *nb)
1014 return blocking_notifier_chain_unregister(&inetaddr_chain, nb);
1017 /* Rename ifa_labels for a device name change. Make some effort to preserve existing
1018 * alias numbering and to create unique labels if possible.
1020 static void inetdev_changename(struct net_device *dev, struct in_device *in_dev)
1022 struct in_ifaddr *ifa;
1025 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
1026 char old[IFNAMSIZ], *dot;
1028 memcpy(old, ifa->ifa_label, IFNAMSIZ);
1029 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1032 dot = strchr(ifa->ifa_label, ':');
1034 sprintf(old, ":%d", named);
1037 if (strlen(dot) + strlen(dev->name) < IFNAMSIZ) {
1038 strcat(ifa->ifa_label, dot);
1040 strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot);
1045 /* Called only under RTNL semaphore */
1047 static int inetdev_event(struct notifier_block *this, unsigned long event,
1050 struct net_device *dev = ptr;
1051 struct in_device *in_dev = __in_dev_get_rtnl(dev);
1056 if (event == NETDEV_REGISTER && dev == &loopback_dev) {
1057 in_dev = inetdev_init(dev);
1059 panic("devinet: Failed to create loopback\n");
1060 in_dev->cnf.no_xfrm = 1;
1061 in_dev->cnf.no_policy = 1;
1067 case NETDEV_REGISTER:
1068 printk(KERN_DEBUG "inetdev_event: bug\n");
1074 if (dev == &loopback_dev) {
1075 struct in_ifaddr *ifa;
1076 if ((ifa = inet_alloc_ifa()) != NULL) {
1078 ifa->ifa_address = htonl(INADDR_LOOPBACK);
1079 ifa->ifa_prefixlen = 8;
1080 ifa->ifa_mask = inet_make_mask(8);
1081 in_dev_hold(in_dev);
1082 ifa->ifa_dev = in_dev;
1083 ifa->ifa_scope = RT_SCOPE_HOST;
1084 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1085 inet_insert_ifa(ifa);
1093 case NETDEV_CHANGEMTU:
1096 /* MTU falled under 68, disable IP */
1097 case NETDEV_UNREGISTER:
1098 inetdev_destroy(in_dev);
1100 case NETDEV_CHANGENAME:
1101 /* Do not notify about label change, this event is
1102 * not interesting to applications using netlink.
1104 inetdev_changename(dev, in_dev);
1106 #ifdef CONFIG_SYSCTL
1107 devinet_sysctl_unregister(&in_dev->cnf);
1108 neigh_sysctl_unregister(in_dev->arp_parms);
1109 neigh_sysctl_register(dev, in_dev->arp_parms, NET_IPV4,
1110 NET_IPV4_NEIGH, "ipv4", NULL, NULL);
1111 devinet_sysctl_register(in_dev, &in_dev->cnf);
1119 static struct notifier_block ip_netdev_notifier = {
1120 .notifier_call =inetdev_event,
1123 static inline size_t inet_nlmsg_size(void)
1125 return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
1126 + nla_total_size(4) /* IFA_ADDRESS */
1127 + nla_total_size(4) /* IFA_LOCAL */
1128 + nla_total_size(4) /* IFA_BROADCAST */
1129 + nla_total_size(4) /* IFA_ANYCAST */
1130 + nla_total_size(IFNAMSIZ); /* IFA_LABEL */
1133 static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
1134 u32 pid, u32 seq, int event, unsigned int flags)
1136 struct ifaddrmsg *ifm;
1137 struct nlmsghdr *nlh;
1139 nlh = nlmsg_put(skb, pid, seq, event, sizeof(*ifm), flags);
1143 ifm = nlmsg_data(nlh);
1144 ifm->ifa_family = AF_INET;
1145 ifm->ifa_prefixlen = ifa->ifa_prefixlen;
1146 ifm->ifa_flags = ifa->ifa_flags|IFA_F_PERMANENT;
1147 ifm->ifa_scope = ifa->ifa_scope;
1148 ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
1150 if (ifa->ifa_address)
1151 NLA_PUT_BE32(skb, IFA_ADDRESS, ifa->ifa_address);
1154 NLA_PUT_BE32(skb, IFA_LOCAL, ifa->ifa_local);
1156 if (ifa->ifa_broadcast)
1157 NLA_PUT_BE32(skb, IFA_BROADCAST, ifa->ifa_broadcast);
1159 if (ifa->ifa_anycast)
1160 NLA_PUT_BE32(skb, IFA_ANYCAST, ifa->ifa_anycast);
1162 if (ifa->ifa_label[0])
1163 NLA_PUT_STRING(skb, IFA_LABEL, ifa->ifa_label);
1165 return nlmsg_end(skb, nlh);
1168 return nlmsg_cancel(skb, nlh);
1171 static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
1174 struct net_device *dev;
1175 struct in_device *in_dev;
1176 struct in_ifaddr *ifa;
1177 int s_ip_idx, s_idx = cb->args[0];
1179 s_ip_idx = ip_idx = cb->args[1];
1180 read_lock(&dev_base_lock);
1181 for (dev = dev_base, idx = 0; dev; dev = dev->next, idx++) {
1187 if ((in_dev = __in_dev_get_rcu(dev)) == NULL) {
1192 for (ifa = in_dev->ifa_list, ip_idx = 0; ifa;
1193 ifa = ifa->ifa_next, ip_idx++) {
1194 if (ip_idx < s_ip_idx)
1196 if (inet_fill_ifaddr(skb, ifa, NETLINK_CB(cb->skb).pid,
1198 RTM_NEWADDR, NLM_F_MULTI) <= 0) {
1207 read_unlock(&dev_base_lock);
1209 cb->args[1] = ip_idx;
1214 static void rtmsg_ifa(int event, struct in_ifaddr* ifa, struct nlmsghdr *nlh,
1217 struct sk_buff *skb;
1218 u32 seq = nlh ? nlh->nlmsg_seq : 0;
1221 skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL);
1225 err = inet_fill_ifaddr(skb, ifa, pid, seq, event, 0);
1226 /* failure implies BUG in inet_nlmsg_size() */
1229 err = rtnl_notify(skb, pid, RTNLGRP_IPV4_IFADDR, nlh, GFP_KERNEL);
1232 rtnl_set_sk_err(RTNLGRP_IPV4_IFADDR, err);
1235 static struct rtnetlink_link inet_rtnetlink_table[RTM_NR_MSGTYPES] = {
1236 [RTM_NEWADDR - RTM_BASE] = { .doit = inet_rtm_newaddr, },
1237 [RTM_DELADDR - RTM_BASE] = { .doit = inet_rtm_deladdr, },
1238 [RTM_GETADDR - RTM_BASE] = { .dumpit = inet_dump_ifaddr, },
1239 [RTM_NEWROUTE - RTM_BASE] = { .doit = inet_rtm_newroute, },
1240 [RTM_DELROUTE - RTM_BASE] = { .doit = inet_rtm_delroute, },
1241 [RTM_GETROUTE - RTM_BASE] = { .doit = inet_rtm_getroute,
1242 .dumpit = inet_dump_fib, },
1243 #ifdef CONFIG_IP_MULTIPLE_TABLES
1244 [RTM_GETRULE - RTM_BASE] = { .dumpit = fib4_rules_dump, },
1248 #ifdef CONFIG_SYSCTL
1250 void inet_forward_change(void)
1252 struct net_device *dev;
1253 int on = ipv4_devconf.forwarding;
1255 ipv4_devconf.accept_redirects = !on;
1256 ipv4_devconf_dflt.forwarding = on;
1258 read_lock(&dev_base_lock);
1259 for (dev = dev_base; dev; dev = dev->next) {
1260 struct in_device *in_dev;
1262 in_dev = __in_dev_get_rcu(dev);
1264 in_dev->cnf.forwarding = on;
1267 read_unlock(&dev_base_lock);
1272 static int devinet_sysctl_forward(ctl_table *ctl, int write,
1273 struct file* filp, void __user *buffer,
1274 size_t *lenp, loff_t *ppos)
1276 int *valp = ctl->data;
1278 int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1280 if (write && *valp != val) {
1281 if (valp == &ipv4_devconf.forwarding)
1282 inet_forward_change();
1283 else if (valp != &ipv4_devconf_dflt.forwarding)
1290 int ipv4_doint_and_flush(ctl_table *ctl, int write,
1291 struct file* filp, void __user *buffer,
1292 size_t *lenp, loff_t *ppos)
1294 int *valp = ctl->data;
1296 int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1298 if (write && *valp != val)
1304 int ipv4_doint_and_flush_strategy(ctl_table *table, int __user *name, int nlen,
1305 void __user *oldval, size_t __user *oldlenp,
1306 void __user *newval, size_t newlen,
1309 int *valp = table->data;
1312 if (!newval || !newlen)
1315 if (newlen != sizeof(int))
1318 if (get_user(new, (int __user *)newval))
1324 if (oldval && oldlenp) {
1327 if (get_user(len, oldlenp))
1331 if (len > table->maxlen)
1332 len = table->maxlen;
1333 if (copy_to_user(oldval, valp, len))
1335 if (put_user(len, oldlenp))
1346 static struct devinet_sysctl_table {
1347 struct ctl_table_header *sysctl_header;
1348 ctl_table devinet_vars[__NET_IPV4_CONF_MAX];
1349 ctl_table devinet_dev[2];
1350 ctl_table devinet_conf_dir[2];
1351 ctl_table devinet_proto_dir[2];
1352 ctl_table devinet_root_dir[2];
1353 } devinet_sysctl = {
1356 .ctl_name = NET_IPV4_CONF_FORWARDING,
1357 .procname = "forwarding",
1358 .data = &ipv4_devconf.forwarding,
1359 .maxlen = sizeof(int),
1361 .proc_handler = &devinet_sysctl_forward,
1364 .ctl_name = NET_IPV4_CONF_MC_FORWARDING,
1365 .procname = "mc_forwarding",
1366 .data = &ipv4_devconf.mc_forwarding,
1367 .maxlen = sizeof(int),
1369 .proc_handler = &proc_dointvec,
1372 .ctl_name = NET_IPV4_CONF_ACCEPT_REDIRECTS,
1373 .procname = "accept_redirects",
1374 .data = &ipv4_devconf.accept_redirects,
1375 .maxlen = sizeof(int),
1377 .proc_handler = &proc_dointvec,
1380 .ctl_name = NET_IPV4_CONF_SECURE_REDIRECTS,
1381 .procname = "secure_redirects",
1382 .data = &ipv4_devconf.secure_redirects,
1383 .maxlen = sizeof(int),
1385 .proc_handler = &proc_dointvec,
1388 .ctl_name = NET_IPV4_CONF_SHARED_MEDIA,
1389 .procname = "shared_media",
1390 .data = &ipv4_devconf.shared_media,
1391 .maxlen = sizeof(int),
1393 .proc_handler = &proc_dointvec,
1396 .ctl_name = NET_IPV4_CONF_RP_FILTER,
1397 .procname = "rp_filter",
1398 .data = &ipv4_devconf.rp_filter,
1399 .maxlen = sizeof(int),
1401 .proc_handler = &proc_dointvec,
1404 .ctl_name = NET_IPV4_CONF_SEND_REDIRECTS,
1405 .procname = "send_redirects",
1406 .data = &ipv4_devconf.send_redirects,
1407 .maxlen = sizeof(int),
1409 .proc_handler = &proc_dointvec,
1412 .ctl_name = NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE,
1413 .procname = "accept_source_route",
1414 .data = &ipv4_devconf.accept_source_route,
1415 .maxlen = sizeof(int),
1417 .proc_handler = &proc_dointvec,
1420 .ctl_name = NET_IPV4_CONF_PROXY_ARP,
1421 .procname = "proxy_arp",
1422 .data = &ipv4_devconf.proxy_arp,
1423 .maxlen = sizeof(int),
1425 .proc_handler = &proc_dointvec,
1428 .ctl_name = NET_IPV4_CONF_MEDIUM_ID,
1429 .procname = "medium_id",
1430 .data = &ipv4_devconf.medium_id,
1431 .maxlen = sizeof(int),
1433 .proc_handler = &proc_dointvec,
1436 .ctl_name = NET_IPV4_CONF_BOOTP_RELAY,
1437 .procname = "bootp_relay",
1438 .data = &ipv4_devconf.bootp_relay,
1439 .maxlen = sizeof(int),
1441 .proc_handler = &proc_dointvec,
1444 .ctl_name = NET_IPV4_CONF_LOG_MARTIANS,
1445 .procname = "log_martians",
1446 .data = &ipv4_devconf.log_martians,
1447 .maxlen = sizeof(int),
1449 .proc_handler = &proc_dointvec,
1452 .ctl_name = NET_IPV4_CONF_TAG,
1454 .data = &ipv4_devconf.tag,
1455 .maxlen = sizeof(int),
1457 .proc_handler = &proc_dointvec,
1460 .ctl_name = NET_IPV4_CONF_ARPFILTER,
1461 .procname = "arp_filter",
1462 .data = &ipv4_devconf.arp_filter,
1463 .maxlen = sizeof(int),
1465 .proc_handler = &proc_dointvec,
1468 .ctl_name = NET_IPV4_CONF_ARP_ANNOUNCE,
1469 .procname = "arp_announce",
1470 .data = &ipv4_devconf.arp_announce,
1471 .maxlen = sizeof(int),
1473 .proc_handler = &proc_dointvec,
1476 .ctl_name = NET_IPV4_CONF_ARP_IGNORE,
1477 .procname = "arp_ignore",
1478 .data = &ipv4_devconf.arp_ignore,
1479 .maxlen = sizeof(int),
1481 .proc_handler = &proc_dointvec,
1484 .ctl_name = NET_IPV4_CONF_ARP_ACCEPT,
1485 .procname = "arp_accept",
1486 .data = &ipv4_devconf.arp_accept,
1487 .maxlen = sizeof(int),
1489 .proc_handler = &proc_dointvec,
1492 .ctl_name = NET_IPV4_CONF_NOXFRM,
1493 .procname = "disable_xfrm",
1494 .data = &ipv4_devconf.no_xfrm,
1495 .maxlen = sizeof(int),
1497 .proc_handler = &ipv4_doint_and_flush,
1498 .strategy = &ipv4_doint_and_flush_strategy,
1501 .ctl_name = NET_IPV4_CONF_NOPOLICY,
1502 .procname = "disable_policy",
1503 .data = &ipv4_devconf.no_policy,
1504 .maxlen = sizeof(int),
1506 .proc_handler = &ipv4_doint_and_flush,
1507 .strategy = &ipv4_doint_and_flush_strategy,
1510 .ctl_name = NET_IPV4_CONF_FORCE_IGMP_VERSION,
1511 .procname = "force_igmp_version",
1512 .data = &ipv4_devconf.force_igmp_version,
1513 .maxlen = sizeof(int),
1515 .proc_handler = &ipv4_doint_and_flush,
1516 .strategy = &ipv4_doint_and_flush_strategy,
1519 .ctl_name = NET_IPV4_CONF_PROMOTE_SECONDARIES,
1520 .procname = "promote_secondaries",
1521 .data = &ipv4_devconf.promote_secondaries,
1522 .maxlen = sizeof(int),
1524 .proc_handler = &ipv4_doint_and_flush,
1525 .strategy = &ipv4_doint_and_flush_strategy,
1530 .ctl_name = NET_PROTO_CONF_ALL,
1533 .child = devinet_sysctl.devinet_vars,
1536 .devinet_conf_dir = {
1538 .ctl_name = NET_IPV4_CONF,
1541 .child = devinet_sysctl.devinet_dev,
1544 .devinet_proto_dir = {
1546 .ctl_name = NET_IPV4,
1549 .child = devinet_sysctl.devinet_conf_dir,
1552 .devinet_root_dir = {
1554 .ctl_name = CTL_NET,
1557 .child = devinet_sysctl.devinet_proto_dir,
1562 static void devinet_sysctl_register(struct in_device *in_dev,
1563 struct ipv4_devconf *p)
1566 struct net_device *dev = in_dev ? in_dev->dev : NULL;
1567 struct devinet_sysctl_table *t = kmalloc(sizeof(*t), GFP_KERNEL);
1568 char *dev_name = NULL;
1572 memcpy(t, &devinet_sysctl, sizeof(*t));
1573 for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
1574 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
1575 t->devinet_vars[i].de = NULL;
1579 dev_name = dev->name;
1580 t->devinet_dev[0].ctl_name = dev->ifindex;
1582 dev_name = "default";
1583 t->devinet_dev[0].ctl_name = NET_PROTO_CONF_DEFAULT;
1587 * Make a copy of dev_name, because '.procname' is regarded as const
1588 * by sysctl and we wouldn't want anyone to change it under our feet
1589 * (see SIOCSIFNAME).
1591 dev_name = kstrdup(dev_name, GFP_KERNEL);
1595 t->devinet_dev[0].procname = dev_name;
1596 t->devinet_dev[0].child = t->devinet_vars;
1597 t->devinet_dev[0].de = NULL;
1598 t->devinet_conf_dir[0].child = t->devinet_dev;
1599 t->devinet_conf_dir[0].de = NULL;
1600 t->devinet_proto_dir[0].child = t->devinet_conf_dir;
1601 t->devinet_proto_dir[0].de = NULL;
1602 t->devinet_root_dir[0].child = t->devinet_proto_dir;
1603 t->devinet_root_dir[0].de = NULL;
1605 t->sysctl_header = register_sysctl_table(t->devinet_root_dir, 0);
1606 if (!t->sysctl_header)
1620 static void devinet_sysctl_unregister(struct ipv4_devconf *p)
1623 struct devinet_sysctl_table *t = p->sysctl;
1625 unregister_sysctl_table(t->sysctl_header);
1626 kfree(t->devinet_dev[0].procname);
1632 void __init devinet_init(void)
1634 register_gifconf(PF_INET, inet_gifconf);
1635 register_netdevice_notifier(&ip_netdev_notifier);
1636 rtnetlink_links[PF_INET] = inet_rtnetlink_table;
1637 #ifdef CONFIG_SYSCTL
1638 devinet_sysctl.sysctl_header =
1639 register_sysctl_table(devinet_sysctl.devinet_root_dir, 0);
1640 devinet_sysctl_register(NULL, &ipv4_devconf_dflt);
1644 EXPORT_SYMBOL(in_dev_finish_destroy);
1645 EXPORT_SYMBOL(inet_select_addr);
1646 EXPORT_SYMBOL(inetdev_by_index);
1647 EXPORT_SYMBOL(register_inetaddr_notifier);
1648 EXPORT_SYMBOL(unregister_inetaddr_notifier);