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
30 #include <linux/config.h>
32 #include <asm/uaccess.h>
33 #include <asm/system.h>
34 #include <linux/bitops.h>
35 #include <linux/capability.h>
36 #include <linux/module.h>
37 #include <linux/types.h>
38 #include <linux/kernel.h>
39 #include <linux/sched.h>
40 #include <linux/string.h>
42 #include <linux/socket.h>
43 #include <linux/sockios.h>
45 #include <linux/errno.h>
46 #include <linux/interrupt.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>
67 struct ipv4_devconf ipv4_devconf = {
68 .accept_redirects = 1,
70 .secure_redirects = 1,
74 static struct ipv4_devconf ipv4_devconf_dflt = {
75 .accept_redirects = 1,
77 .secure_redirects = 1,
79 .accept_source_route = 1,
82 static void rtmsg_ifa(int event, struct in_ifaddr *);
84 static BLOCKING_NOTIFIER_HEAD(inetaddr_chain);
85 static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
88 static void devinet_sysctl_register(struct in_device *in_dev,
89 struct ipv4_devconf *p);
90 static void devinet_sysctl_unregister(struct ipv4_devconf *p);
93 /* Locks all the inet devices. */
95 static struct in_ifaddr *inet_alloc_ifa(void)
97 struct in_ifaddr *ifa = kmalloc(sizeof(*ifa), GFP_KERNEL);
100 memset(ifa, 0, sizeof(*ifa));
101 INIT_RCU_HEAD(&ifa->rcu_head);
107 static void inet_rcu_free_ifa(struct rcu_head *head)
109 struct in_ifaddr *ifa = container_of(head, struct in_ifaddr, rcu_head);
111 in_dev_put(ifa->ifa_dev);
115 static inline void inet_free_ifa(struct in_ifaddr *ifa)
117 call_rcu(&ifa->rcu_head, inet_rcu_free_ifa);
120 void in_dev_finish_destroy(struct in_device *idev)
122 struct net_device *dev = idev->dev;
124 BUG_TRAP(!idev->ifa_list);
125 BUG_TRAP(!idev->mc_list);
126 #ifdef NET_REFCNT_DEBUG
127 printk(KERN_DEBUG "in_dev_finish_destroy: %p=%s\n",
128 idev, dev ? dev->name : "NIL");
132 printk("Freeing alive in_device %p\n", idev);
138 struct in_device *inetdev_init(struct net_device *dev)
140 struct in_device *in_dev;
144 in_dev = kmalloc(sizeof(*in_dev), GFP_KERNEL);
147 memset(in_dev, 0, sizeof(*in_dev));
148 INIT_RCU_HEAD(&in_dev->rcu_head);
149 memcpy(&in_dev->cnf, &ipv4_devconf_dflt, sizeof(in_dev->cnf));
150 in_dev->cnf.sysctl = NULL;
152 if ((in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl)) == NULL)
154 /* Reference in_dev->dev */
157 neigh_sysctl_register(dev, in_dev->arp_parms, NET_IPV4,
158 NET_IPV4_NEIGH, "ipv4", NULL, NULL);
161 /* Account for reference dev->ip_ptr */
163 rcu_assign_pointer(dev->ip_ptr, in_dev);
166 devinet_sysctl_register(in_dev, &in_dev->cnf);
168 ip_mc_init_dev(in_dev);
169 if (dev->flags & IFF_UP)
179 static void in_dev_rcu_put(struct rcu_head *head)
181 struct in_device *idev = container_of(head, struct in_device, rcu_head);
185 static void inetdev_destroy(struct in_device *in_dev)
187 struct in_ifaddr *ifa;
188 struct net_device *dev;
193 if (dev == &loopback_dev)
198 ip_mc_destroy_dev(in_dev);
200 while ((ifa = in_dev->ifa_list) != NULL) {
201 inet_del_ifa(in_dev, &in_dev->ifa_list, 0);
206 devinet_sysctl_unregister(&in_dev->cnf);
212 neigh_sysctl_unregister(in_dev->arp_parms);
214 neigh_parms_release(&arp_tbl, in_dev->arp_parms);
217 call_rcu(&in_dev->rcu_head, in_dev_rcu_put);
220 int inet_addr_onlink(struct in_device *in_dev, u32 a, u32 b)
223 for_primary_ifa(in_dev) {
224 if (inet_ifa_match(a, ifa)) {
225 if (!b || inet_ifa_match(b, ifa)) {
230 } endfor_ifa(in_dev);
235 static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
238 struct in_ifaddr *promote = NULL;
239 struct in_ifaddr *ifa, *ifa1 = *ifap;
240 struct in_ifaddr *last_prim = in_dev->ifa_list;
241 struct in_ifaddr *prev_prom = NULL;
242 int do_promote = IN_DEV_PROMOTE_SECONDARIES(in_dev);
246 /* 1. Deleting primary ifaddr forces deletion all secondaries
247 * unless alias promotion is set
250 if (!(ifa1->ifa_flags & IFA_F_SECONDARY)) {
251 struct in_ifaddr **ifap1 = &ifa1->ifa_next;
253 while ((ifa = *ifap1) != NULL) {
254 if (!(ifa->ifa_flags & IFA_F_SECONDARY) &&
255 ifa1->ifa_scope <= ifa->ifa_scope)
258 if (!(ifa->ifa_flags & IFA_F_SECONDARY) ||
259 ifa1->ifa_mask != ifa->ifa_mask ||
260 !inet_ifa_match(ifa1->ifa_address, ifa)) {
261 ifap1 = &ifa->ifa_next;
267 *ifap1 = ifa->ifa_next;
269 rtmsg_ifa(RTM_DELADDR, ifa);
270 blocking_notifier_call_chain(&inetaddr_chain,
282 *ifap = ifa1->ifa_next;
284 /* 3. Announce address deletion */
286 /* Send message first, then call notifier.
287 At first sight, FIB update triggered by notifier
288 will refer to already deleted ifaddr, that could confuse
289 netlink listeners. It is not true: look, gated sees
290 that route deleted and if it still thinks that ifaddr
291 is valid, it will try to restore deleted routes... Grr.
292 So that, this order is correct.
294 rtmsg_ifa(RTM_DELADDR, ifa1);
295 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1);
300 prev_prom->ifa_next = promote->ifa_next;
301 promote->ifa_next = last_prim->ifa_next;
302 last_prim->ifa_next = promote;
305 promote->ifa_flags &= ~IFA_F_SECONDARY;
306 rtmsg_ifa(RTM_NEWADDR, promote);
307 blocking_notifier_call_chain(&inetaddr_chain,
309 for (ifa = promote->ifa_next; ifa; ifa = ifa->ifa_next) {
310 if (ifa1->ifa_mask != ifa->ifa_mask ||
311 !inet_ifa_match(ifa1->ifa_address, ifa))
320 if (!in_dev->ifa_list)
321 inetdev_destroy(in_dev);
325 static int inet_insert_ifa(struct in_ifaddr *ifa)
327 struct in_device *in_dev = ifa->ifa_dev;
328 struct in_ifaddr *ifa1, **ifap, **last_primary;
332 if (!ifa->ifa_local) {
337 ifa->ifa_flags &= ~IFA_F_SECONDARY;
338 last_primary = &in_dev->ifa_list;
340 for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL;
341 ifap = &ifa1->ifa_next) {
342 if (!(ifa1->ifa_flags & IFA_F_SECONDARY) &&
343 ifa->ifa_scope <= ifa1->ifa_scope)
344 last_primary = &ifa1->ifa_next;
345 if (ifa1->ifa_mask == ifa->ifa_mask &&
346 inet_ifa_match(ifa1->ifa_address, ifa)) {
347 if (ifa1->ifa_local == ifa->ifa_local) {
351 if (ifa1->ifa_scope != ifa->ifa_scope) {
355 ifa->ifa_flags |= IFA_F_SECONDARY;
359 if (!(ifa->ifa_flags & IFA_F_SECONDARY)) {
360 net_srandom(ifa->ifa_local);
364 ifa->ifa_next = *ifap;
367 /* Send message first, then call notifier.
368 Notifier will trigger FIB update, so that
369 listeners of netlink will know about new ifaddr */
370 rtmsg_ifa(RTM_NEWADDR, ifa);
371 blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
376 static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa)
378 struct in_device *in_dev = __in_dev_get_rtnl(dev);
383 in_dev = inetdev_init(dev);
389 if (ifa->ifa_dev != in_dev) {
390 BUG_TRAP(!ifa->ifa_dev);
392 ifa->ifa_dev = in_dev;
394 if (LOOPBACK(ifa->ifa_local))
395 ifa->ifa_scope = RT_SCOPE_HOST;
396 return inet_insert_ifa(ifa);
399 struct in_device *inetdev_by_index(int ifindex)
401 struct net_device *dev;
402 struct in_device *in_dev = NULL;
403 read_lock(&dev_base_lock);
404 dev = __dev_get_by_index(ifindex);
406 in_dev = in_dev_get(dev);
407 read_unlock(&dev_base_lock);
411 /* Called only from RTNL semaphored context. No locks. */
413 struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, u32 prefix,
418 for_primary_ifa(in_dev) {
419 if (ifa->ifa_mask == mask && inet_ifa_match(prefix, ifa))
421 } endfor_ifa(in_dev);
425 static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
427 struct rtattr **rta = arg;
428 struct in_device *in_dev;
429 struct ifaddrmsg *ifm = NLMSG_DATA(nlh);
430 struct in_ifaddr *ifa, **ifap;
434 if ((in_dev = inetdev_by_index(ifm->ifa_index)) == NULL)
436 __in_dev_put(in_dev);
438 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
439 ifap = &ifa->ifa_next) {
440 if ((rta[IFA_LOCAL - 1] &&
441 memcmp(RTA_DATA(rta[IFA_LOCAL - 1]),
442 &ifa->ifa_local, 4)) ||
443 (rta[IFA_LABEL - 1] &&
444 rtattr_strcmp(rta[IFA_LABEL - 1], ifa->ifa_label)) ||
445 (rta[IFA_ADDRESS - 1] &&
446 (ifm->ifa_prefixlen != ifa->ifa_prefixlen ||
447 !inet_ifa_match(*(u32*)RTA_DATA(rta[IFA_ADDRESS - 1]),
450 inet_del_ifa(in_dev, ifap, 1);
454 return -EADDRNOTAVAIL;
457 static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
459 struct rtattr **rta = arg;
460 struct net_device *dev;
461 struct in_device *in_dev;
462 struct ifaddrmsg *ifm = NLMSG_DATA(nlh);
463 struct in_ifaddr *ifa;
468 if (ifm->ifa_prefixlen > 32 || !rta[IFA_LOCAL - 1])
472 if ((dev = __dev_get_by_index(ifm->ifa_index)) == NULL)
476 if ((in_dev = __in_dev_get_rtnl(dev)) == NULL) {
477 in_dev = inetdev_init(dev);
482 if ((ifa = inet_alloc_ifa()) == NULL)
485 if (!rta[IFA_ADDRESS - 1])
486 rta[IFA_ADDRESS - 1] = rta[IFA_LOCAL - 1];
487 memcpy(&ifa->ifa_local, RTA_DATA(rta[IFA_LOCAL - 1]), 4);
488 memcpy(&ifa->ifa_address, RTA_DATA(rta[IFA_ADDRESS - 1]), 4);
489 ifa->ifa_prefixlen = ifm->ifa_prefixlen;
490 ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen);
491 if (rta[IFA_BROADCAST - 1])
492 memcpy(&ifa->ifa_broadcast,
493 RTA_DATA(rta[IFA_BROADCAST - 1]), 4);
494 if (rta[IFA_ANYCAST - 1])
495 memcpy(&ifa->ifa_anycast, RTA_DATA(rta[IFA_ANYCAST - 1]), 4);
496 ifa->ifa_flags = ifm->ifa_flags;
497 ifa->ifa_scope = ifm->ifa_scope;
499 ifa->ifa_dev = in_dev;
500 if (rta[IFA_LABEL - 1])
501 rtattr_strlcpy(ifa->ifa_label, rta[IFA_LABEL - 1], IFNAMSIZ);
503 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
505 rc = inet_insert_ifa(ifa);
511 * Determine a default network mask, based on the IP address.
514 static __inline__ int inet_abc_len(u32 addr)
516 int rc = -1; /* Something else, probably a multicast. */
525 else if (IN_CLASSB(addr))
527 else if (IN_CLASSC(addr))
535 int devinet_ioctl(unsigned int cmd, void __user *arg)
538 struct sockaddr_in sin_orig;
539 struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
540 struct in_device *in_dev;
541 struct in_ifaddr **ifap = NULL;
542 struct in_ifaddr *ifa = NULL;
543 struct net_device *dev;
546 int tryaddrmatch = 0;
549 * Fetch the caller's info block into kernel space
552 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
554 ifr.ifr_name[IFNAMSIZ - 1] = 0;
556 /* save original address for comparison */
557 memcpy(&sin_orig, sin, sizeof(*sin));
559 colon = strchr(ifr.ifr_name, ':');
564 dev_load(ifr.ifr_name);
568 case SIOCGIFADDR: /* Get interface address */
569 case SIOCGIFBRDADDR: /* Get the broadcast address */
570 case SIOCGIFDSTADDR: /* Get the destination address */
571 case SIOCGIFNETMASK: /* Get the netmask for the interface */
572 /* Note that these ioctls will not sleep,
573 so that we do not impose a lock.
574 One day we will be forced to put shlock here (I mean SMP)
576 tryaddrmatch = (sin_orig.sin_family == AF_INET);
577 memset(sin, 0, sizeof(*sin));
578 sin->sin_family = AF_INET;
583 if (!capable(CAP_NET_ADMIN))
586 case SIOCSIFADDR: /* Set interface address (and family) */
587 case SIOCSIFBRDADDR: /* Set the broadcast address */
588 case SIOCSIFDSTADDR: /* Set the destination address */
589 case SIOCSIFNETMASK: /* Set the netmask for the interface */
591 if (!capable(CAP_NET_ADMIN))
594 if (sin->sin_family != AF_INET)
605 if ((dev = __dev_get_by_name(ifr.ifr_name)) == NULL)
611 if ((in_dev = __in_dev_get_rtnl(dev)) != NULL) {
612 struct nx_info *nxi = current->nx_info;
613 int hide_netif = vx_flags(VXF_HIDE_NETIF, 0);
616 /* Matthias Andree */
617 /* compare label and address (4.4BSD style) */
618 /* note: we only do this for a limited set of ioctls
619 and only if the original address family was AF_INET.
620 This is checked above. */
621 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
622 ifap = &ifa->ifa_next) {
623 if (hide_netif && !ifa_in_nx_info(ifa, nxi))
625 if (!strcmp(ifr.ifr_name, ifa->ifa_label) &&
626 sin_orig.sin_addr.s_addr ==
632 /* we didn't get a match, maybe the application is
633 4.3BSD-style and passed in junk so we fall back to
634 comparing just the label */
636 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
637 ifap = &ifa->ifa_next) {
638 if (hide_netif && !ifa_in_nx_info(ifa, nxi))
640 if (!strcmp(ifr.ifr_name, ifa->ifa_label))
646 ret = -EADDRNOTAVAIL;
647 if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS)
651 case SIOCGIFADDR: /* Get interface address */
652 sin->sin_addr.s_addr = ifa->ifa_local;
655 case SIOCGIFBRDADDR: /* Get the broadcast address */
656 sin->sin_addr.s_addr = ifa->ifa_broadcast;
659 case SIOCGIFDSTADDR: /* Get the destination address */
660 sin->sin_addr.s_addr = ifa->ifa_address;
663 case SIOCGIFNETMASK: /* Get the netmask for the interface */
664 sin->sin_addr.s_addr = ifa->ifa_mask;
669 ret = -EADDRNOTAVAIL;
673 if (!(ifr.ifr_flags & IFF_UP))
674 inet_del_ifa(in_dev, ifap, 1);
677 ret = dev_change_flags(dev, ifr.ifr_flags);
680 case SIOCSIFADDR: /* Set interface address (and family) */
682 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
687 if ((ifa = inet_alloc_ifa()) == NULL)
690 memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ);
692 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
695 if (ifa->ifa_local == sin->sin_addr.s_addr)
697 inet_del_ifa(in_dev, ifap, 0);
698 ifa->ifa_broadcast = 0;
699 ifa->ifa_anycast = 0;
702 ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr;
704 if (!(dev->flags & IFF_POINTOPOINT)) {
705 ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address);
706 ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen);
707 if ((dev->flags & IFF_BROADCAST) &&
708 ifa->ifa_prefixlen < 31)
709 ifa->ifa_broadcast = ifa->ifa_address |
712 ifa->ifa_prefixlen = 32;
713 ifa->ifa_mask = inet_make_mask(32);
715 ret = inet_set_ifa(dev, ifa);
718 case SIOCSIFBRDADDR: /* Set the broadcast address */
720 if (ifa->ifa_broadcast != sin->sin_addr.s_addr) {
721 inet_del_ifa(in_dev, ifap, 0);
722 ifa->ifa_broadcast = sin->sin_addr.s_addr;
723 inet_insert_ifa(ifa);
727 case SIOCSIFDSTADDR: /* Set the destination address */
729 if (ifa->ifa_address == sin->sin_addr.s_addr)
732 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
735 inet_del_ifa(in_dev, ifap, 0);
736 ifa->ifa_address = sin->sin_addr.s_addr;
737 inet_insert_ifa(ifa);
740 case SIOCSIFNETMASK: /* Set the netmask for the interface */
743 * The mask we set must be legal.
746 if (bad_mask(sin->sin_addr.s_addr, 0))
749 if (ifa->ifa_mask != sin->sin_addr.s_addr) {
750 u32 old_mask = ifa->ifa_mask;
751 inet_del_ifa(in_dev, ifap, 0);
752 ifa->ifa_mask = sin->sin_addr.s_addr;
753 ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask);
755 /* See if current broadcast address matches
756 * with current netmask, then recalculate
757 * the broadcast address. Otherwise it's a
758 * funny address, so don't touch it since
759 * the user seems to know what (s)he's doing...
761 if ((dev->flags & IFF_BROADCAST) &&
762 (ifa->ifa_prefixlen < 31) &&
763 (ifa->ifa_broadcast ==
764 (ifa->ifa_local|~old_mask))) {
765 ifa->ifa_broadcast = (ifa->ifa_local |
766 ~sin->sin_addr.s_addr);
768 inet_insert_ifa(ifa);
778 ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0;
782 static int inet_gifconf(struct net_device *dev, char __user *buf, int len)
784 struct in_device *in_dev = __in_dev_get_rtnl(dev);
785 struct in_ifaddr *ifa;
789 if (!in_dev || (ifa = in_dev->ifa_list) == NULL)
792 for (; ifa; ifa = ifa->ifa_next) {
793 if (vx_flags(VXF_HIDE_NETIF, 0) &&
794 !ifa_in_nx_info(ifa, current->nx_info))
800 if (len < (int) sizeof(ifr))
802 memset(&ifr, 0, sizeof(struct ifreq));
804 strcpy(ifr.ifr_name, ifa->ifa_label);
806 strcpy(ifr.ifr_name, dev->name);
808 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET;
809 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr =
812 if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) {
816 buf += sizeof(struct ifreq);
817 len -= sizeof(struct ifreq);
818 done += sizeof(struct ifreq);
824 u32 inet_select_addr(const struct net_device *dev, u32 dst, int scope)
827 struct in_device *in_dev;
830 in_dev = __in_dev_get_rcu(dev);
834 for_primary_ifa(in_dev) {
835 if (ifa->ifa_scope > scope)
837 if (!dst || inet_ifa_match(dst, ifa)) {
838 addr = ifa->ifa_local;
842 addr = ifa->ifa_local;
843 } endfor_ifa(in_dev);
850 /* Not loopback addresses on loopback should be preferred
851 in this case. It is importnat that lo is the first interface
854 read_lock(&dev_base_lock);
856 for (dev = dev_base; dev; dev = dev->next) {
857 if ((in_dev = __in_dev_get_rcu(dev)) == NULL)
860 for_primary_ifa(in_dev) {
861 if (ifa->ifa_scope != RT_SCOPE_LINK &&
862 ifa->ifa_scope <= scope) {
863 addr = ifa->ifa_local;
864 goto out_unlock_both;
866 } endfor_ifa(in_dev);
869 read_unlock(&dev_base_lock);
875 static u32 confirm_addr_indev(struct in_device *in_dev, u32 dst,
876 u32 local, int scope)
883 (local == ifa->ifa_local || !local) &&
884 ifa->ifa_scope <= scope) {
885 addr = ifa->ifa_local;
890 same = (!local || inet_ifa_match(local, ifa)) &&
891 (!dst || inet_ifa_match(dst, ifa));
895 /* Is the selected addr into dst subnet? */
896 if (inet_ifa_match(addr, ifa))
898 /* No, then can we use new local src? */
899 if (ifa->ifa_scope <= scope) {
900 addr = ifa->ifa_local;
903 /* search for large dst subnet for addr */
907 } endfor_ifa(in_dev);
909 return same? addr : 0;
913 * Confirm that local IP address exists using wildcards:
914 * - dev: only on this interface, 0=any interface
915 * - dst: only in the same subnet as dst, 0=any dst
916 * - local: address, 0=autoselect the local address
917 * - scope: maximum allowed scope value for the local address
919 u32 inet_confirm_addr(const struct net_device *dev, u32 dst, u32 local, int scope)
922 struct in_device *in_dev;
926 if ((in_dev = __in_dev_get_rcu(dev)))
927 addr = confirm_addr_indev(in_dev, dst, local, scope);
933 read_lock(&dev_base_lock);
935 for (dev = dev_base; dev; dev = dev->next) {
936 if ((in_dev = __in_dev_get_rcu(dev))) {
937 addr = confirm_addr_indev(in_dev, dst, local, scope);
943 read_unlock(&dev_base_lock);
952 int register_inetaddr_notifier(struct notifier_block *nb)
954 return blocking_notifier_chain_register(&inetaddr_chain, nb);
957 int unregister_inetaddr_notifier(struct notifier_block *nb)
959 return blocking_notifier_chain_unregister(&inetaddr_chain, nb);
962 /* Rename ifa_labels for a device name change. Make some effort to preserve existing
963 * alias numbering and to create unique labels if possible.
965 static void inetdev_changename(struct net_device *dev, struct in_device *in_dev)
967 struct in_ifaddr *ifa;
970 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
971 char old[IFNAMSIZ], *dot;
973 memcpy(old, ifa->ifa_label, IFNAMSIZ);
974 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
977 dot = strchr(ifa->ifa_label, ':');
979 sprintf(old, ":%d", named);
982 if (strlen(dot) + strlen(dev->name) < IFNAMSIZ) {
983 strcat(ifa->ifa_label, dot);
985 strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot);
990 /* Called only under RTNL semaphore */
992 static int inetdev_event(struct notifier_block *this, unsigned long event,
995 struct net_device *dev = ptr;
996 struct in_device *in_dev = __in_dev_get_rtnl(dev);
1001 if (event == NETDEV_REGISTER && dev == &loopback_dev) {
1002 in_dev = inetdev_init(dev);
1004 panic("devinet: Failed to create loopback\n");
1005 in_dev->cnf.no_xfrm = 1;
1006 in_dev->cnf.no_policy = 1;
1012 case NETDEV_REGISTER:
1013 printk(KERN_DEBUG "inetdev_event: bug\n");
1019 if (dev == &loopback_dev) {
1020 struct in_ifaddr *ifa;
1021 if ((ifa = inet_alloc_ifa()) != NULL) {
1023 ifa->ifa_address = htonl(INADDR_LOOPBACK);
1024 ifa->ifa_prefixlen = 8;
1025 ifa->ifa_mask = inet_make_mask(8);
1026 in_dev_hold(in_dev);
1027 ifa->ifa_dev = in_dev;
1028 ifa->ifa_scope = RT_SCOPE_HOST;
1029 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1030 inet_insert_ifa(ifa);
1038 case NETDEV_CHANGEMTU:
1041 /* MTU falled under 68, disable IP */
1042 case NETDEV_UNREGISTER:
1043 inetdev_destroy(in_dev);
1045 case NETDEV_CHANGENAME:
1046 /* Do not notify about label change, this event is
1047 * not interesting to applications using netlink.
1049 inetdev_changename(dev, in_dev);
1051 #ifdef CONFIG_SYSCTL
1052 devinet_sysctl_unregister(&in_dev->cnf);
1053 neigh_sysctl_unregister(in_dev->arp_parms);
1054 neigh_sysctl_register(dev, in_dev->arp_parms, NET_IPV4,
1055 NET_IPV4_NEIGH, "ipv4", NULL, NULL);
1056 devinet_sysctl_register(in_dev, &in_dev->cnf);
1064 static struct notifier_block ip_netdev_notifier = {
1065 .notifier_call =inetdev_event,
1068 static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
1069 u32 pid, u32 seq, int event, unsigned int flags)
1071 struct ifaddrmsg *ifm;
1072 struct nlmsghdr *nlh;
1073 unsigned char *b = skb->tail;
1075 nlh = NLMSG_NEW(skb, pid, seq, event, sizeof(*ifm), flags);
1076 ifm = NLMSG_DATA(nlh);
1077 ifm->ifa_family = AF_INET;
1078 ifm->ifa_prefixlen = ifa->ifa_prefixlen;
1079 ifm->ifa_flags = ifa->ifa_flags|IFA_F_PERMANENT;
1080 ifm->ifa_scope = ifa->ifa_scope;
1081 ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
1082 if (ifa->ifa_address)
1083 RTA_PUT(skb, IFA_ADDRESS, 4, &ifa->ifa_address);
1085 RTA_PUT(skb, IFA_LOCAL, 4, &ifa->ifa_local);
1086 if (ifa->ifa_broadcast)
1087 RTA_PUT(skb, IFA_BROADCAST, 4, &ifa->ifa_broadcast);
1088 if (ifa->ifa_anycast)
1089 RTA_PUT(skb, IFA_ANYCAST, 4, &ifa->ifa_anycast);
1090 if (ifa->ifa_label[0])
1091 RTA_PUT(skb, IFA_LABEL, IFNAMSIZ, &ifa->ifa_label);
1092 nlh->nlmsg_len = skb->tail - b;
1097 skb_trim(skb, b - skb->data);
1101 static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
1104 struct net_device *dev;
1105 struct in_device *in_dev;
1106 struct in_ifaddr *ifa;
1107 struct sock *sk = skb->sk;
1108 int s_ip_idx, s_idx = cb->args[0];
1110 s_ip_idx = ip_idx = cb->args[1];
1111 read_lock(&dev_base_lock);
1112 for (dev = dev_base, idx = 0; dev; dev = dev->next, idx++) {
1118 if ((in_dev = __in_dev_get_rcu(dev)) == NULL) {
1123 for (ifa = in_dev->ifa_list, ip_idx = 0; ifa;
1124 ifa = ifa->ifa_next, ip_idx++) {
1125 if (sk && vx_info_flags(sk->sk_vx_info, VXF_HIDE_NETIF, 0) &&
1126 !ifa_in_nx_info(ifa, sk->sk_nx_info))
1128 if (ip_idx < s_ip_idx)
1130 if (inet_fill_ifaddr(skb, ifa, NETLINK_CB(cb->skb).pid,
1132 RTM_NEWADDR, NLM_F_MULTI) <= 0) {
1141 read_unlock(&dev_base_lock);
1143 cb->args[1] = ip_idx;
1148 static void rtmsg_ifa(int event, struct in_ifaddr* ifa)
1150 int size = NLMSG_SPACE(sizeof(struct ifaddrmsg) + 128);
1151 struct sk_buff *skb = alloc_skb(size, GFP_KERNEL);
1154 netlink_set_err(rtnl, 0, RTNLGRP_IPV4_IFADDR, ENOBUFS);
1155 else if (inet_fill_ifaddr(skb, ifa, 0, 0, event, 0) < 0) {
1157 netlink_set_err(rtnl, 0, RTNLGRP_IPV4_IFADDR, EINVAL);
1159 netlink_broadcast(rtnl, skb, 0, RTNLGRP_IPV4_IFADDR, GFP_KERNEL);
1163 static struct rtnetlink_link inet_rtnetlink_table[RTM_NR_MSGTYPES] = {
1164 [RTM_NEWADDR - RTM_BASE] = { .doit = inet_rtm_newaddr, },
1165 [RTM_DELADDR - RTM_BASE] = { .doit = inet_rtm_deladdr, },
1166 [RTM_GETADDR - RTM_BASE] = { .dumpit = inet_dump_ifaddr, },
1167 [RTM_NEWROUTE - RTM_BASE] = { .doit = inet_rtm_newroute, },
1168 [RTM_DELROUTE - RTM_BASE] = { .doit = inet_rtm_delroute, },
1169 [RTM_GETROUTE - RTM_BASE] = { .doit = inet_rtm_getroute,
1170 .dumpit = inet_dump_fib, },
1171 #ifdef CONFIG_IP_MULTIPLE_TABLES
1172 [RTM_NEWRULE - RTM_BASE] = { .doit = inet_rtm_newrule, },
1173 [RTM_DELRULE - RTM_BASE] = { .doit = inet_rtm_delrule, },
1174 [RTM_GETRULE - RTM_BASE] = { .dumpit = inet_dump_rules, },
1178 #ifdef CONFIG_SYSCTL
1180 void inet_forward_change(void)
1182 struct net_device *dev;
1183 int on = ipv4_devconf.forwarding;
1185 ipv4_devconf.accept_redirects = !on;
1186 ipv4_devconf_dflt.forwarding = on;
1188 read_lock(&dev_base_lock);
1189 for (dev = dev_base; dev; dev = dev->next) {
1190 struct in_device *in_dev;
1192 in_dev = __in_dev_get_rcu(dev);
1194 in_dev->cnf.forwarding = on;
1197 read_unlock(&dev_base_lock);
1202 static int devinet_sysctl_forward(ctl_table *ctl, int write,
1203 struct file* filp, void __user *buffer,
1204 size_t *lenp, loff_t *ppos)
1206 int *valp = ctl->data;
1208 int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1210 if (write && *valp != val) {
1211 if (valp == &ipv4_devconf.forwarding)
1212 inet_forward_change();
1213 else if (valp != &ipv4_devconf_dflt.forwarding)
1220 int ipv4_doint_and_flush(ctl_table *ctl, int write,
1221 struct file* filp, void __user *buffer,
1222 size_t *lenp, loff_t *ppos)
1224 int *valp = ctl->data;
1226 int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1228 if (write && *valp != val)
1234 int ipv4_doint_and_flush_strategy(ctl_table *table, int __user *name, int nlen,
1235 void __user *oldval, size_t __user *oldlenp,
1236 void __user *newval, size_t newlen,
1239 int *valp = table->data;
1242 if (!newval || !newlen)
1245 if (newlen != sizeof(int))
1248 if (get_user(new, (int __user *)newval))
1254 if (oldval && oldlenp) {
1257 if (get_user(len, oldlenp))
1261 if (len > table->maxlen)
1262 len = table->maxlen;
1263 if (copy_to_user(oldval, valp, len))
1265 if (put_user(len, oldlenp))
1276 static struct devinet_sysctl_table {
1277 struct ctl_table_header *sysctl_header;
1278 ctl_table devinet_vars[__NET_IPV4_CONF_MAX];
1279 ctl_table devinet_dev[2];
1280 ctl_table devinet_conf_dir[2];
1281 ctl_table devinet_proto_dir[2];
1282 ctl_table devinet_root_dir[2];
1283 } devinet_sysctl = {
1286 .ctl_name = NET_IPV4_CONF_FORWARDING,
1287 .procname = "forwarding",
1288 .data = &ipv4_devconf.forwarding,
1289 .maxlen = sizeof(int),
1291 .proc_handler = &devinet_sysctl_forward,
1294 .ctl_name = NET_IPV4_CONF_MC_FORWARDING,
1295 .procname = "mc_forwarding",
1296 .data = &ipv4_devconf.mc_forwarding,
1297 .maxlen = sizeof(int),
1299 .proc_handler = &proc_dointvec,
1302 .ctl_name = NET_IPV4_CONF_ACCEPT_REDIRECTS,
1303 .procname = "accept_redirects",
1304 .data = &ipv4_devconf.accept_redirects,
1305 .maxlen = sizeof(int),
1307 .proc_handler = &proc_dointvec,
1310 .ctl_name = NET_IPV4_CONF_SECURE_REDIRECTS,
1311 .procname = "secure_redirects",
1312 .data = &ipv4_devconf.secure_redirects,
1313 .maxlen = sizeof(int),
1315 .proc_handler = &proc_dointvec,
1318 .ctl_name = NET_IPV4_CONF_SHARED_MEDIA,
1319 .procname = "shared_media",
1320 .data = &ipv4_devconf.shared_media,
1321 .maxlen = sizeof(int),
1323 .proc_handler = &proc_dointvec,
1326 .ctl_name = NET_IPV4_CONF_RP_FILTER,
1327 .procname = "rp_filter",
1328 .data = &ipv4_devconf.rp_filter,
1329 .maxlen = sizeof(int),
1331 .proc_handler = &proc_dointvec,
1334 .ctl_name = NET_IPV4_CONF_SEND_REDIRECTS,
1335 .procname = "send_redirects",
1336 .data = &ipv4_devconf.send_redirects,
1337 .maxlen = sizeof(int),
1339 .proc_handler = &proc_dointvec,
1342 .ctl_name = NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE,
1343 .procname = "accept_source_route",
1344 .data = &ipv4_devconf.accept_source_route,
1345 .maxlen = sizeof(int),
1347 .proc_handler = &proc_dointvec,
1350 .ctl_name = NET_IPV4_CONF_PROXY_ARP,
1351 .procname = "proxy_arp",
1352 .data = &ipv4_devconf.proxy_arp,
1353 .maxlen = sizeof(int),
1355 .proc_handler = &proc_dointvec,
1358 .ctl_name = NET_IPV4_CONF_MEDIUM_ID,
1359 .procname = "medium_id",
1360 .data = &ipv4_devconf.medium_id,
1361 .maxlen = sizeof(int),
1363 .proc_handler = &proc_dointvec,
1366 .ctl_name = NET_IPV4_CONF_BOOTP_RELAY,
1367 .procname = "bootp_relay",
1368 .data = &ipv4_devconf.bootp_relay,
1369 .maxlen = sizeof(int),
1371 .proc_handler = &proc_dointvec,
1374 .ctl_name = NET_IPV4_CONF_LOG_MARTIANS,
1375 .procname = "log_martians",
1376 .data = &ipv4_devconf.log_martians,
1377 .maxlen = sizeof(int),
1379 .proc_handler = &proc_dointvec,
1382 .ctl_name = NET_IPV4_CONF_TAG,
1384 .data = &ipv4_devconf.tag,
1385 .maxlen = sizeof(int),
1387 .proc_handler = &proc_dointvec,
1390 .ctl_name = NET_IPV4_CONF_ARPFILTER,
1391 .procname = "arp_filter",
1392 .data = &ipv4_devconf.arp_filter,
1393 .maxlen = sizeof(int),
1395 .proc_handler = &proc_dointvec,
1398 .ctl_name = NET_IPV4_CONF_ARP_ANNOUNCE,
1399 .procname = "arp_announce",
1400 .data = &ipv4_devconf.arp_announce,
1401 .maxlen = sizeof(int),
1403 .proc_handler = &proc_dointvec,
1406 .ctl_name = NET_IPV4_CONF_ARP_IGNORE,
1407 .procname = "arp_ignore",
1408 .data = &ipv4_devconf.arp_ignore,
1409 .maxlen = sizeof(int),
1411 .proc_handler = &proc_dointvec,
1414 .ctl_name = NET_IPV4_CONF_ARP_ACCEPT,
1415 .procname = "arp_accept",
1416 .data = &ipv4_devconf.arp_accept,
1417 .maxlen = sizeof(int),
1419 .proc_handler = &proc_dointvec,
1422 .ctl_name = NET_IPV4_CONF_NOXFRM,
1423 .procname = "disable_xfrm",
1424 .data = &ipv4_devconf.no_xfrm,
1425 .maxlen = sizeof(int),
1427 .proc_handler = &ipv4_doint_and_flush,
1428 .strategy = &ipv4_doint_and_flush_strategy,
1431 .ctl_name = NET_IPV4_CONF_NOPOLICY,
1432 .procname = "disable_policy",
1433 .data = &ipv4_devconf.no_policy,
1434 .maxlen = sizeof(int),
1436 .proc_handler = &ipv4_doint_and_flush,
1437 .strategy = &ipv4_doint_and_flush_strategy,
1440 .ctl_name = NET_IPV4_CONF_FORCE_IGMP_VERSION,
1441 .procname = "force_igmp_version",
1442 .data = &ipv4_devconf.force_igmp_version,
1443 .maxlen = sizeof(int),
1445 .proc_handler = &ipv4_doint_and_flush,
1446 .strategy = &ipv4_doint_and_flush_strategy,
1449 .ctl_name = NET_IPV4_CONF_PROMOTE_SECONDARIES,
1450 .procname = "promote_secondaries",
1451 .data = &ipv4_devconf.promote_secondaries,
1452 .maxlen = sizeof(int),
1454 .proc_handler = &ipv4_doint_and_flush,
1455 .strategy = &ipv4_doint_and_flush_strategy,
1460 .ctl_name = NET_PROTO_CONF_ALL,
1463 .child = devinet_sysctl.devinet_vars,
1466 .devinet_conf_dir = {
1468 .ctl_name = NET_IPV4_CONF,
1471 .child = devinet_sysctl.devinet_dev,
1474 .devinet_proto_dir = {
1476 .ctl_name = NET_IPV4,
1479 .child = devinet_sysctl.devinet_conf_dir,
1482 .devinet_root_dir = {
1484 .ctl_name = CTL_NET,
1487 .child = devinet_sysctl.devinet_proto_dir,
1492 static void devinet_sysctl_register(struct in_device *in_dev,
1493 struct ipv4_devconf *p)
1496 struct net_device *dev = in_dev ? in_dev->dev : NULL;
1497 struct devinet_sysctl_table *t = kmalloc(sizeof(*t), GFP_KERNEL);
1498 char *dev_name = NULL;
1502 memcpy(t, &devinet_sysctl, sizeof(*t));
1503 for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
1504 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
1505 t->devinet_vars[i].de = NULL;
1509 dev_name = dev->name;
1510 t->devinet_dev[0].ctl_name = dev->ifindex;
1512 dev_name = "default";
1513 t->devinet_dev[0].ctl_name = NET_PROTO_CONF_DEFAULT;
1517 * Make a copy of dev_name, because '.procname' is regarded as const
1518 * by sysctl and we wouldn't want anyone to change it under our feet
1519 * (see SIOCSIFNAME).
1521 dev_name = kstrdup(dev_name, GFP_KERNEL);
1525 t->devinet_dev[0].procname = dev_name;
1526 t->devinet_dev[0].child = t->devinet_vars;
1527 t->devinet_dev[0].de = NULL;
1528 t->devinet_conf_dir[0].child = t->devinet_dev;
1529 t->devinet_conf_dir[0].de = NULL;
1530 t->devinet_proto_dir[0].child = t->devinet_conf_dir;
1531 t->devinet_proto_dir[0].de = NULL;
1532 t->devinet_root_dir[0].child = t->devinet_proto_dir;
1533 t->devinet_root_dir[0].de = NULL;
1535 t->sysctl_header = register_sysctl_table(t->devinet_root_dir, 0);
1536 if (!t->sysctl_header)
1550 static void devinet_sysctl_unregister(struct ipv4_devconf *p)
1553 struct devinet_sysctl_table *t = p->sysctl;
1555 unregister_sysctl_table(t->sysctl_header);
1556 kfree(t->devinet_dev[0].procname);
1562 void __init devinet_init(void)
1564 register_gifconf(PF_INET, inet_gifconf);
1565 register_netdevice_notifier(&ip_netdev_notifier);
1566 rtnetlink_links[PF_INET] = inet_rtnetlink_table;
1567 #ifdef CONFIG_SYSCTL
1568 devinet_sysctl.sysctl_header =
1569 register_sysctl_table(devinet_sysctl.devinet_root_dir, 0);
1570 devinet_sysctl_register(NULL, &ipv4_devconf_dflt);
1574 EXPORT_SYMBOL(in_dev_finish_destroy);
1575 EXPORT_SYMBOL(inet_select_addr);
1576 EXPORT_SYMBOL(inetdev_by_index);
1577 EXPORT_SYMBOL(register_inetaddr_notifier);
1578 EXPORT_SYMBOL(unregister_inetaddr_notifier);