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/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_ether.h>
47 #include <linux/inet.h>
48 #include <linux/netdevice.h>
49 #include <linux/etherdevice.h>
50 #include <linux/skbuff.h>
51 #include <linux/rtnetlink.h>
52 #include <linux/init.h>
53 #include <linux/notifier.h>
54 #include <linux/inetdevice.h>
55 #include <linux/igmp.h>
57 #include <linux/sysctl.h>
59 #include <linux/kmod.h>
62 #include <net/route.h>
63 #include <net/ip_fib.h>
65 struct ipv4_devconf ipv4_devconf = {
66 .accept_redirects = 1,
68 .secure_redirects = 1,
72 static struct ipv4_devconf ipv4_devconf_dflt = {
73 .accept_redirects = 1,
75 .secure_redirects = 1,
77 .accept_source_route = 1,
80 static void rtmsg_ifa(int event, struct in_ifaddr *);
82 static struct notifier_block *inetaddr_chain;
83 static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
86 static void devinet_sysctl_register(struct in_device *in_dev,
87 struct ipv4_devconf *p);
88 static void devinet_sysctl_unregister(struct ipv4_devconf *p);
91 /* Locks all the inet devices. */
93 static struct in_ifaddr *inet_alloc_ifa(void)
95 struct in_ifaddr *ifa = kmalloc(sizeof(*ifa), GFP_KERNEL);
98 memset(ifa, 0, sizeof(*ifa));
99 INIT_RCU_HEAD(&ifa->rcu_head);
105 static void inet_rcu_free_ifa(struct rcu_head *head)
107 struct in_ifaddr *ifa = container_of(head, struct in_ifaddr, rcu_head);
109 in_dev_put(ifa->ifa_dev);
113 static inline void inet_free_ifa(struct in_ifaddr *ifa)
115 call_rcu(&ifa->rcu_head, inet_rcu_free_ifa);
118 void in_dev_finish_destroy(struct in_device *idev)
120 struct net_device *dev = idev->dev;
122 BUG_TRAP(!idev->ifa_list);
123 BUG_TRAP(!idev->mc_list);
124 #ifdef NET_REFCNT_DEBUG
125 printk(KERN_DEBUG "in_dev_finish_destroy: %p=%s\n",
126 idev, dev ? dev->name : "NIL");
130 printk("Freeing alive in_device %p\n", idev);
136 struct in_device *inetdev_init(struct net_device *dev)
138 struct in_device *in_dev;
142 in_dev = kmalloc(sizeof(*in_dev), GFP_KERNEL);
145 memset(in_dev, 0, sizeof(*in_dev));
146 INIT_RCU_HEAD(&in_dev->rcu_head);
147 memcpy(&in_dev->cnf, &ipv4_devconf_dflt, sizeof(in_dev->cnf));
148 in_dev->cnf.sysctl = NULL;
150 if ((in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl)) == NULL)
152 /* Reference in_dev->dev */
155 neigh_sysctl_register(dev, in_dev->arp_parms, NET_IPV4,
156 NET_IPV4_NEIGH, "ipv4", NULL, NULL);
159 /* Account for reference dev->ip_ptr */
161 rcu_assign_pointer(dev->ip_ptr, in_dev);
164 devinet_sysctl_register(in_dev, &in_dev->cnf);
166 ip_mc_init_dev(in_dev);
167 if (dev->flags & IFF_UP)
177 static void in_dev_rcu_put(struct rcu_head *head)
179 struct in_device *idev = container_of(head, struct in_device, rcu_head);
183 static void inetdev_destroy(struct in_device *in_dev)
185 struct in_ifaddr *ifa;
186 struct net_device *dev;
191 if (dev == &loopback_dev)
196 ip_mc_destroy_dev(in_dev);
198 while ((ifa = in_dev->ifa_list) != NULL) {
199 inet_del_ifa(in_dev, &in_dev->ifa_list, 0);
204 devinet_sysctl_unregister(&in_dev->cnf);
210 neigh_sysctl_unregister(in_dev->arp_parms);
212 neigh_parms_release(&arp_tbl, in_dev->arp_parms);
215 call_rcu(&in_dev->rcu_head, in_dev_rcu_put);
218 int inet_addr_onlink(struct in_device *in_dev, u32 a, u32 b)
221 for_primary_ifa(in_dev) {
222 if (inet_ifa_match(a, ifa)) {
223 if (!b || inet_ifa_match(b, ifa)) {
228 } endfor_ifa(in_dev);
233 static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
236 struct in_ifaddr *promote = NULL;
237 struct in_ifaddr *ifa1 = *ifap;
241 /* 1. Deleting primary ifaddr forces deletion all secondaries
242 * unless alias promotion is set
245 if (!(ifa1->ifa_flags & IFA_F_SECONDARY)) {
246 struct in_ifaddr *ifa;
247 struct in_ifaddr **ifap1 = &ifa1->ifa_next;
249 while ((ifa = *ifap1) != NULL) {
250 if (!(ifa->ifa_flags & IFA_F_SECONDARY) ||
251 ifa1->ifa_mask != ifa->ifa_mask ||
252 !inet_ifa_match(ifa1->ifa_address, ifa)) {
253 ifap1 = &ifa->ifa_next;
257 if (!IN_DEV_PROMOTE_SECONDARIES(in_dev)) {
258 *ifap1 = ifa->ifa_next;
260 rtmsg_ifa(RTM_DELADDR, ifa);
261 notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa);
272 *ifap = ifa1->ifa_next;
274 /* 3. Announce address deletion */
276 /* Send message first, then call notifier.
277 At first sight, FIB update triggered by notifier
278 will refer to already deleted ifaddr, that could confuse
279 netlink listeners. It is not true: look, gated sees
280 that route deleted and if it still thinks that ifaddr
281 is valid, it will try to restore deleted routes... Grr.
282 So that, this order is correct.
284 rtmsg_ifa(RTM_DELADDR, ifa1);
285 notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1);
289 if (!in_dev->ifa_list)
290 inetdev_destroy(in_dev);
293 if (promote && IN_DEV_PROMOTE_SECONDARIES(in_dev)) {
294 /* not sure if we should send a delete notify first? */
295 promote->ifa_flags &= ~IFA_F_SECONDARY;
296 rtmsg_ifa(RTM_NEWADDR, promote);
297 notifier_call_chain(&inetaddr_chain, NETDEV_UP, promote);
301 static int inet_insert_ifa(struct in_ifaddr *ifa)
303 struct in_device *in_dev = ifa->ifa_dev;
304 struct in_ifaddr *ifa1, **ifap, **last_primary;
308 if (!ifa->ifa_local) {
313 ifa->ifa_flags &= ~IFA_F_SECONDARY;
314 last_primary = &in_dev->ifa_list;
316 for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL;
317 ifap = &ifa1->ifa_next) {
318 if (!(ifa1->ifa_flags & IFA_F_SECONDARY) &&
319 ifa->ifa_scope <= ifa1->ifa_scope)
320 last_primary = &ifa1->ifa_next;
321 if (ifa1->ifa_mask == ifa->ifa_mask &&
322 inet_ifa_match(ifa1->ifa_address, ifa)) {
323 if (ifa1->ifa_local == ifa->ifa_local) {
327 if (ifa1->ifa_scope != ifa->ifa_scope) {
331 ifa->ifa_flags |= IFA_F_SECONDARY;
335 if (!(ifa->ifa_flags & IFA_F_SECONDARY)) {
336 net_srandom(ifa->ifa_local);
340 ifa->ifa_next = *ifap;
343 /* Send message first, then call notifier.
344 Notifier will trigger FIB update, so that
345 listeners of netlink will know about new ifaddr */
346 rtmsg_ifa(RTM_NEWADDR, ifa);
347 notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
352 static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa)
354 struct in_device *in_dev = __in_dev_get(dev);
359 in_dev = inetdev_init(dev);
365 if (ifa->ifa_dev != in_dev) {
366 BUG_TRAP(!ifa->ifa_dev);
368 ifa->ifa_dev = in_dev;
370 if (LOOPBACK(ifa->ifa_local))
371 ifa->ifa_scope = RT_SCOPE_HOST;
372 return inet_insert_ifa(ifa);
375 struct in_device *inetdev_by_index(int ifindex)
377 struct net_device *dev;
378 struct in_device *in_dev = NULL;
379 read_lock(&dev_base_lock);
380 dev = __dev_get_by_index(ifindex);
382 in_dev = in_dev_get(dev);
383 read_unlock(&dev_base_lock);
387 /* Called only from RTNL semaphored context. No locks. */
389 struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, u32 prefix,
394 for_primary_ifa(in_dev) {
395 if (ifa->ifa_mask == mask && inet_ifa_match(prefix, ifa))
397 } endfor_ifa(in_dev);
401 static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
403 struct rtattr **rta = arg;
404 struct in_device *in_dev;
405 struct ifaddrmsg *ifm = NLMSG_DATA(nlh);
406 struct in_ifaddr *ifa, **ifap;
410 if ((in_dev = inetdev_by_index(ifm->ifa_index)) == NULL)
412 __in_dev_put(in_dev);
414 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
415 ifap = &ifa->ifa_next) {
416 if ((rta[IFA_LOCAL - 1] &&
417 memcmp(RTA_DATA(rta[IFA_LOCAL - 1]),
418 &ifa->ifa_local, 4)) ||
419 (rta[IFA_LABEL - 1] &&
420 rtattr_strcmp(rta[IFA_LABEL - 1], ifa->ifa_label)) ||
421 (rta[IFA_ADDRESS - 1] &&
422 (ifm->ifa_prefixlen != ifa->ifa_prefixlen ||
423 !inet_ifa_match(*(u32*)RTA_DATA(rta[IFA_ADDRESS - 1]),
426 inet_del_ifa(in_dev, ifap, 1);
430 return -EADDRNOTAVAIL;
433 static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
435 struct rtattr **rta = arg;
436 struct net_device *dev;
437 struct in_device *in_dev;
438 struct ifaddrmsg *ifm = NLMSG_DATA(nlh);
439 struct in_ifaddr *ifa;
444 if (ifm->ifa_prefixlen > 32 || !rta[IFA_LOCAL - 1])
448 if ((dev = __dev_get_by_index(ifm->ifa_index)) == NULL)
452 if ((in_dev = __in_dev_get(dev)) == NULL) {
453 in_dev = inetdev_init(dev);
458 if ((ifa = inet_alloc_ifa()) == NULL)
461 if (!rta[IFA_ADDRESS - 1])
462 rta[IFA_ADDRESS - 1] = rta[IFA_LOCAL - 1];
463 memcpy(&ifa->ifa_local, RTA_DATA(rta[IFA_LOCAL - 1]), 4);
464 memcpy(&ifa->ifa_address, RTA_DATA(rta[IFA_ADDRESS - 1]), 4);
465 ifa->ifa_prefixlen = ifm->ifa_prefixlen;
466 ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen);
467 if (rta[IFA_BROADCAST - 1])
468 memcpy(&ifa->ifa_broadcast,
469 RTA_DATA(rta[IFA_BROADCAST - 1]), 4);
470 if (rta[IFA_ANYCAST - 1])
471 memcpy(&ifa->ifa_anycast, RTA_DATA(rta[IFA_ANYCAST - 1]), 4);
472 ifa->ifa_flags = ifm->ifa_flags;
473 ifa->ifa_scope = ifm->ifa_scope;
475 ifa->ifa_dev = in_dev;
476 if (rta[IFA_LABEL - 1])
477 rtattr_strlcpy(ifa->ifa_label, rta[IFA_LABEL - 1], IFNAMSIZ);
479 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
481 rc = inet_insert_ifa(ifa);
487 * Determine a default network mask, based on the IP address.
490 static __inline__ int inet_abc_len(u32 addr)
492 int rc = -1; /* Something else, probably a multicast. */
501 else if (IN_CLASSB(addr))
503 else if (IN_CLASSC(addr))
511 Check that a device is not member of the ipv4root assigned to the process
512 Return true if this is the case
514 If the process is not bound to specific IP, then it returns 0 (all
517 static inline int devinet_notiproot (struct in_ifaddr *ifa)
522 if ((nxi = current->nx_info)) {
524 int nbip = nxi->nbipv4;
525 __u32 addr = ifa->ifa_local;
527 for (i=0; i<nbip; i++) {
528 if(nxi->ipv4[i] == addr) {
538 int devinet_ioctl(unsigned int cmd, void __user *arg)
541 struct sockaddr_in sin_orig;
542 struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
543 struct in_device *in_dev;
544 struct in_ifaddr **ifap = NULL;
545 struct in_ifaddr *ifa = NULL;
546 struct net_device *dev;
549 int tryaddrmatch = 0;
552 * Fetch the caller's info block into kernel space
555 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
557 ifr.ifr_name[IFNAMSIZ - 1] = 0;
559 /* save original address for comparison */
560 memcpy(&sin_orig, sin, sizeof(*sin));
562 colon = strchr(ifr.ifr_name, ':');
567 dev_load(ifr.ifr_name);
571 case SIOCGIFADDR: /* Get interface address */
572 case SIOCGIFBRDADDR: /* Get the broadcast address */
573 case SIOCGIFDSTADDR: /* Get the destination address */
574 case SIOCGIFNETMASK: /* Get the netmask for the interface */
575 /* Note that these ioctls will not sleep,
576 so that we do not impose a lock.
577 One day we will be forced to put shlock here (I mean SMP)
579 tryaddrmatch = (sin_orig.sin_family == AF_INET);
580 memset(sin, 0, sizeof(*sin));
581 sin->sin_family = AF_INET;
586 if (!capable(CAP_NET_ADMIN))
589 case SIOCSIFADDR: /* Set interface address (and family) */
590 case SIOCSIFBRDADDR: /* Set the broadcast address */
591 case SIOCSIFDSTADDR: /* Set the destination address */
592 case SIOCSIFNETMASK: /* Set the netmask for the interface */
594 if (!capable(CAP_NET_ADMIN))
597 if (sin->sin_family != AF_INET)
608 if ((dev = __dev_get_by_name(ifr.ifr_name)) == NULL)
614 if ((in_dev = __in_dev_get(dev)) != NULL) {
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 (!strcmp(ifr.ifr_name, ifa->ifa_label) &&
624 sin_orig.sin_addr.s_addr ==
630 /* we didn't get a match, maybe the application is
631 4.3BSD-style and passed in junk so we fall back to
632 comparing just the label */
634 for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
635 ifap = &ifa->ifa_next)
636 if (!strcmp(ifr.ifr_name, ifa->ifa_label))
641 ret = -EADDRNOTAVAIL;
642 if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS)
644 if (vx_flags(VXF_HIDE_NETIF, 0) &&
645 !ifa_in_nx_info(ifa, current->nx_info))
649 case SIOCGIFADDR: /* Get interface address */
650 sin->sin_addr.s_addr = ifa->ifa_local;
653 case SIOCGIFBRDADDR: /* Get the broadcast address */
654 sin->sin_addr.s_addr = ifa->ifa_broadcast;
657 case SIOCGIFDSTADDR: /* Get the destination address */
658 sin->sin_addr.s_addr = ifa->ifa_address;
661 case SIOCGIFNETMASK: /* Get the netmask for the interface */
662 sin->sin_addr.s_addr = ifa->ifa_mask;
667 ret = -EADDRNOTAVAIL;
671 if (!(ifr.ifr_flags & IFF_UP))
672 inet_del_ifa(in_dev, ifap, 1);
675 ret = dev_change_flags(dev, ifr.ifr_flags);
678 case SIOCSIFADDR: /* Set interface address (and family) */
680 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
685 if ((ifa = inet_alloc_ifa()) == NULL)
688 memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ);
690 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
693 if (ifa->ifa_local == sin->sin_addr.s_addr)
695 inet_del_ifa(in_dev, ifap, 0);
696 ifa->ifa_broadcast = 0;
697 ifa->ifa_anycast = 0;
700 ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr;
702 if (!(dev->flags & IFF_POINTOPOINT)) {
703 ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address);
704 ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen);
705 if ((dev->flags & IFF_BROADCAST) &&
706 ifa->ifa_prefixlen < 31)
707 ifa->ifa_broadcast = ifa->ifa_address |
710 ifa->ifa_prefixlen = 32;
711 ifa->ifa_mask = inet_make_mask(32);
713 ret = inet_set_ifa(dev, ifa);
716 case SIOCSIFBRDADDR: /* Set the broadcast address */
718 if (ifa->ifa_broadcast != sin->sin_addr.s_addr) {
719 inet_del_ifa(in_dev, ifap, 0);
720 ifa->ifa_broadcast = sin->sin_addr.s_addr;
721 inet_insert_ifa(ifa);
725 case SIOCSIFDSTADDR: /* Set the destination address */
727 if (ifa->ifa_address == sin->sin_addr.s_addr)
730 if (inet_abc_len(sin->sin_addr.s_addr) < 0)
733 inet_del_ifa(in_dev, ifap, 0);
734 ifa->ifa_address = sin->sin_addr.s_addr;
735 inet_insert_ifa(ifa);
738 case SIOCSIFNETMASK: /* Set the netmask for the interface */
741 * The mask we set must be legal.
744 if (bad_mask(sin->sin_addr.s_addr, 0))
747 if (ifa->ifa_mask != sin->sin_addr.s_addr) {
748 inet_del_ifa(in_dev, ifap, 0);
749 ifa->ifa_mask = sin->sin_addr.s_addr;
750 ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask);
752 /* See if current broadcast address matches
753 * with current netmask, then recalculate
754 * the broadcast address. Otherwise it's a
755 * funny address, so don't touch it since
756 * the user seems to know what (s)he's doing...
758 if ((dev->flags & IFF_BROADCAST) &&
759 (ifa->ifa_prefixlen < 31) &&
760 (ifa->ifa_broadcast ==
761 (ifa->ifa_local|~ifa->ifa_mask))) {
762 ifa->ifa_broadcast = (ifa->ifa_local |
763 ~sin->sin_addr.s_addr);
765 inet_insert_ifa(ifa);
775 ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0;
779 static int inet_gifconf(struct net_device *dev, char __user *buf, int len)
781 struct in_device *in_dev = __in_dev_get(dev);
782 struct in_ifaddr *ifa;
786 if (!in_dev || (ifa = in_dev->ifa_list) == NULL)
789 for (; ifa; ifa = ifa->ifa_next) {
790 if (vx_flags(VXF_HIDE_NETIF, 0) &&
791 !ifa_in_nx_info(ifa, current->nx_info))
797 if (len < (int) sizeof(ifr))
799 memset(&ifr, 0, sizeof(struct ifreq));
801 strcpy(ifr.ifr_name, ifa->ifa_label);
803 strcpy(ifr.ifr_name, dev->name);
805 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET;
806 (*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr =
809 if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) {
813 buf += sizeof(struct ifreq);
814 len -= sizeof(struct ifreq);
815 done += sizeof(struct ifreq);
821 u32 inet_select_addr(const struct net_device *dev, u32 dst, int scope)
824 struct in_device *in_dev;
827 in_dev = __in_dev_get(dev);
831 for_primary_ifa(in_dev) {
832 if (ifa->ifa_scope > scope)
834 if (!dst || inet_ifa_match(dst, ifa)) {
835 addr = ifa->ifa_local;
839 addr = ifa->ifa_local;
840 } endfor_ifa(in_dev);
847 /* Not loopback addresses on loopback should be preferred
848 in this case. It is importnat that lo is the first interface
851 read_lock(&dev_base_lock);
853 for (dev = dev_base; dev; dev = dev->next) {
854 if ((in_dev = __in_dev_get(dev)) == NULL)
857 for_primary_ifa(in_dev) {
858 if (ifa->ifa_scope != RT_SCOPE_LINK &&
859 ifa->ifa_scope <= scope) {
860 addr = ifa->ifa_local;
861 goto out_unlock_both;
863 } endfor_ifa(in_dev);
866 read_unlock(&dev_base_lock);
872 static u32 confirm_addr_indev(struct in_device *in_dev, u32 dst,
873 u32 local, int scope)
880 (local == ifa->ifa_local || !local) &&
881 ifa->ifa_scope <= scope) {
882 addr = ifa->ifa_local;
887 same = (!local || inet_ifa_match(local, ifa)) &&
888 (!dst || inet_ifa_match(dst, ifa));
892 /* Is the selected addr into dst subnet? */
893 if (inet_ifa_match(addr, ifa))
895 /* No, then can we use new local src? */
896 if (ifa->ifa_scope <= scope) {
897 addr = ifa->ifa_local;
900 /* search for large dst subnet for addr */
904 } endfor_ifa(in_dev);
906 return same? addr : 0;
910 * Confirm that local IP address exists using wildcards:
911 * - dev: only on this interface, 0=any interface
912 * - dst: only in the same subnet as dst, 0=any dst
913 * - local: address, 0=autoselect the local address
914 * - scope: maximum allowed scope value for the local address
916 u32 inet_confirm_addr(const struct net_device *dev, u32 dst, u32 local, int scope)
919 struct in_device *in_dev;
923 if ((in_dev = __in_dev_get(dev)))
924 addr = confirm_addr_indev(in_dev, dst, local, scope);
930 read_lock(&dev_base_lock);
932 for (dev = dev_base; dev; dev = dev->next) {
933 if ((in_dev = __in_dev_get(dev))) {
934 addr = confirm_addr_indev(in_dev, dst, local, scope);
940 read_unlock(&dev_base_lock);
949 int register_inetaddr_notifier(struct notifier_block *nb)
951 return notifier_chain_register(&inetaddr_chain, nb);
954 int unregister_inetaddr_notifier(struct notifier_block *nb)
956 return notifier_chain_unregister(&inetaddr_chain, nb);
959 /* Rename ifa_labels for a device name change. Make some effort to preserve existing
960 * alias numbering and to create unique labels if possible.
962 static void inetdev_changename(struct net_device *dev, struct in_device *in_dev)
964 struct in_ifaddr *ifa;
967 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
968 char old[IFNAMSIZ], *dot;
970 memcpy(old, ifa->ifa_label, IFNAMSIZ);
971 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
974 dot = strchr(ifa->ifa_label, ':');
976 sprintf(old, ":%d", named);
979 if (strlen(dot) + strlen(dev->name) < IFNAMSIZ) {
980 strcat(ifa->ifa_label, dot);
982 strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot);
987 /* Called only under RTNL semaphore */
989 static int inetdev_event(struct notifier_block *this, unsigned long event,
992 struct net_device *dev = ptr;
993 struct in_device *in_dev = __in_dev_get(dev);
998 if (event == NETDEV_REGISTER && dev == &loopback_dev) {
999 in_dev = inetdev_init(dev);
1001 panic("devinet: Failed to create loopback\n");
1002 in_dev->cnf.no_xfrm = 1;
1003 in_dev->cnf.no_policy = 1;
1009 case NETDEV_REGISTER:
1010 printk(KERN_DEBUG "inetdev_event: bug\n");
1016 if (dev == &loopback_dev) {
1017 struct in_ifaddr *ifa;
1018 if ((ifa = inet_alloc_ifa()) != NULL) {
1020 ifa->ifa_address = htonl(INADDR_LOOPBACK);
1021 ifa->ifa_prefixlen = 8;
1022 ifa->ifa_mask = inet_make_mask(8);
1023 in_dev_hold(in_dev);
1024 ifa->ifa_dev = in_dev;
1025 ifa->ifa_scope = RT_SCOPE_HOST;
1026 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
1027 inet_insert_ifa(ifa);
1035 case NETDEV_CHANGEMTU:
1038 /* MTU falled under 68, disable IP */
1039 case NETDEV_UNREGISTER:
1040 inetdev_destroy(in_dev);
1042 case NETDEV_CHANGENAME:
1043 /* Do not notify about label change, this event is
1044 * not interesting to applications using netlink.
1046 inetdev_changename(dev, in_dev);
1048 #ifdef CONFIG_SYSCTL
1049 devinet_sysctl_unregister(&in_dev->cnf);
1050 neigh_sysctl_unregister(in_dev->arp_parms);
1051 neigh_sysctl_register(dev, in_dev->arp_parms, NET_IPV4,
1052 NET_IPV4_NEIGH, "ipv4", NULL, NULL);
1053 devinet_sysctl_register(in_dev, &in_dev->cnf);
1061 static struct notifier_block ip_netdev_notifier = {
1062 .notifier_call =inetdev_event,
1065 static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
1066 u32 pid, u32 seq, int event)
1068 struct ifaddrmsg *ifm;
1069 struct nlmsghdr *nlh;
1070 unsigned char *b = skb->tail;
1072 nlh = NLMSG_PUT(skb, pid, seq, event, sizeof(*ifm));
1073 if (pid) nlh->nlmsg_flags |= NLM_F_MULTI;
1074 ifm = NLMSG_DATA(nlh);
1075 ifm->ifa_family = AF_INET;
1076 ifm->ifa_prefixlen = ifa->ifa_prefixlen;
1077 ifm->ifa_flags = ifa->ifa_flags|IFA_F_PERMANENT;
1078 ifm->ifa_scope = ifa->ifa_scope;
1079 ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
1080 if (ifa->ifa_address)
1081 RTA_PUT(skb, IFA_ADDRESS, 4, &ifa->ifa_address);
1083 RTA_PUT(skb, IFA_LOCAL, 4, &ifa->ifa_local);
1084 if (ifa->ifa_broadcast)
1085 RTA_PUT(skb, IFA_BROADCAST, 4, &ifa->ifa_broadcast);
1086 if (ifa->ifa_anycast)
1087 RTA_PUT(skb, IFA_ANYCAST, 4, &ifa->ifa_anycast);
1088 if (ifa->ifa_label[0])
1089 RTA_PUT(skb, IFA_LABEL, IFNAMSIZ, &ifa->ifa_label);
1090 nlh->nlmsg_len = skb->tail - b;
1095 skb_trim(skb, b - skb->data);
1099 static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
1102 struct net_device *dev;
1103 struct in_device *in_dev;
1104 struct in_ifaddr *ifa;
1105 struct sock *sk = skb->sk;
1106 int s_ip_idx, s_idx = cb->args[0];
1108 s_ip_idx = ip_idx = cb->args[1];
1109 read_lock(&dev_base_lock);
1110 for (dev = dev_base, idx = 0; dev; dev = dev->next, idx++) {
1116 if ((in_dev = __in_dev_get(dev)) == NULL) {
1121 for (ifa = in_dev->ifa_list, ip_idx = 0; ifa;
1122 ifa = ifa->ifa_next, ip_idx++) {
1123 if (sk && vx_info_flags(sk->sk_vx_info, VXF_HIDE_NETIF, 0) &&
1124 !ifa_in_nx_info(ifa, sk->sk_nx_info))
1126 if (ip_idx < s_ip_idx)
1128 if (inet_fill_ifaddr(skb, ifa, NETLINK_CB(cb->skb).pid,
1130 RTM_NEWADDR) <= 0) {
1139 read_unlock(&dev_base_lock);
1141 cb->args[1] = ip_idx;
1146 static void rtmsg_ifa(int event, struct in_ifaddr* ifa)
1148 int size = NLMSG_SPACE(sizeof(struct ifaddrmsg) + 128);
1149 struct sk_buff *skb = alloc_skb(size, GFP_KERNEL);
1152 netlink_set_err(rtnl, 0, RTMGRP_IPV4_IFADDR, ENOBUFS);
1153 else if (inet_fill_ifaddr(skb, ifa, 0, 0, event) < 0) {
1155 netlink_set_err(rtnl, 0, RTMGRP_IPV4_IFADDR, EINVAL);
1157 NETLINK_CB(skb).dst_groups = RTMGRP_IPV4_IFADDR;
1158 netlink_broadcast(rtnl, skb, 0, RTMGRP_IPV4_IFADDR, GFP_KERNEL);
1162 static struct rtnetlink_link inet_rtnetlink_table[RTM_NR_MSGTYPES] = {
1163 [RTM_NEWADDR - RTM_BASE] = { .doit = inet_rtm_newaddr, },
1164 [RTM_DELADDR - RTM_BASE] = { .doit = inet_rtm_deladdr, },
1165 [RTM_GETADDR - RTM_BASE] = { .dumpit = inet_dump_ifaddr, },
1166 [RTM_NEWROUTE - RTM_BASE] = { .doit = inet_rtm_newroute, },
1167 [RTM_DELROUTE - RTM_BASE] = { .doit = inet_rtm_delroute, },
1168 [RTM_GETROUTE - RTM_BASE] = { .doit = inet_rtm_getroute,
1169 .dumpit = inet_dump_fib, },
1170 #ifdef CONFIG_IP_MULTIPLE_TABLES
1171 [RTM_NEWRULE - RTM_BASE] = { .doit = inet_rtm_newrule, },
1172 [RTM_DELRULE - RTM_BASE] = { .doit = inet_rtm_delrule, },
1173 [RTM_GETRULE - RTM_BASE] = { .dumpit = inet_dump_rules, },
1177 #ifdef CONFIG_SYSCTL
1179 void inet_forward_change(void)
1181 struct net_device *dev;
1182 int on = ipv4_devconf.forwarding;
1184 ipv4_devconf.accept_redirects = !on;
1185 ipv4_devconf_dflt.forwarding = on;
1187 read_lock(&dev_base_lock);
1188 for (dev = dev_base; dev; dev = dev->next) {
1189 struct in_device *in_dev;
1191 in_dev = __in_dev_get(dev);
1193 in_dev->cnf.forwarding = on;
1196 read_unlock(&dev_base_lock);
1201 static int devinet_sysctl_forward(ctl_table *ctl, int write,
1202 struct file* filp, void __user *buffer,
1203 size_t *lenp, loff_t *ppos)
1205 int *valp = ctl->data;
1207 int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1209 if (write && *valp != val) {
1210 if (valp == &ipv4_devconf.forwarding)
1211 inet_forward_change();
1212 else if (valp != &ipv4_devconf_dflt.forwarding)
1219 int ipv4_doint_and_flush(ctl_table *ctl, int write,
1220 struct file* filp, void __user *buffer,
1221 size_t *lenp, loff_t *ppos)
1223 int *valp = ctl->data;
1225 int ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1227 if (write && *valp != val)
1233 int ipv4_doint_and_flush_strategy(ctl_table *table, int __user *name, int nlen,
1234 void __user *oldval, size_t __user *oldlenp,
1235 void __user *newval, size_t newlen,
1238 int *valp = table->data;
1241 if (!newval || !newlen)
1244 if (newlen != sizeof(int))
1247 if (get_user(new, (int __user *)newval))
1253 if (oldval && oldlenp) {
1256 if (get_user(len, oldlenp))
1260 if (len > table->maxlen)
1261 len = table->maxlen;
1262 if (copy_to_user(oldval, valp, len))
1264 if (put_user(len, oldlenp))
1275 static struct devinet_sysctl_table {
1276 struct ctl_table_header *sysctl_header;
1277 ctl_table devinet_vars[__NET_IPV4_CONF_MAX];
1278 ctl_table devinet_dev[2];
1279 ctl_table devinet_conf_dir[2];
1280 ctl_table devinet_proto_dir[2];
1281 ctl_table devinet_root_dir[2];
1282 } devinet_sysctl = {
1285 .ctl_name = NET_IPV4_CONF_FORWARDING,
1286 .procname = "forwarding",
1287 .data = &ipv4_devconf.forwarding,
1288 .maxlen = sizeof(int),
1290 .proc_handler = &devinet_sysctl_forward,
1293 .ctl_name = NET_IPV4_CONF_MC_FORWARDING,
1294 .procname = "mc_forwarding",
1295 .data = &ipv4_devconf.mc_forwarding,
1296 .maxlen = sizeof(int),
1298 .proc_handler = &proc_dointvec,
1301 .ctl_name = NET_IPV4_CONF_ACCEPT_REDIRECTS,
1302 .procname = "accept_redirects",
1303 .data = &ipv4_devconf.accept_redirects,
1304 .maxlen = sizeof(int),
1306 .proc_handler = &proc_dointvec,
1309 .ctl_name = NET_IPV4_CONF_SECURE_REDIRECTS,
1310 .procname = "secure_redirects",
1311 .data = &ipv4_devconf.secure_redirects,
1312 .maxlen = sizeof(int),
1314 .proc_handler = &proc_dointvec,
1317 .ctl_name = NET_IPV4_CONF_SHARED_MEDIA,
1318 .procname = "shared_media",
1319 .data = &ipv4_devconf.shared_media,
1320 .maxlen = sizeof(int),
1322 .proc_handler = &proc_dointvec,
1325 .ctl_name = NET_IPV4_CONF_RP_FILTER,
1326 .procname = "rp_filter",
1327 .data = &ipv4_devconf.rp_filter,
1328 .maxlen = sizeof(int),
1330 .proc_handler = &proc_dointvec,
1333 .ctl_name = NET_IPV4_CONF_SEND_REDIRECTS,
1334 .procname = "send_redirects",
1335 .data = &ipv4_devconf.send_redirects,
1336 .maxlen = sizeof(int),
1338 .proc_handler = &proc_dointvec,
1341 .ctl_name = NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE,
1342 .procname = "accept_source_route",
1343 .data = &ipv4_devconf.accept_source_route,
1344 .maxlen = sizeof(int),
1346 .proc_handler = &proc_dointvec,
1349 .ctl_name = NET_IPV4_CONF_PROXY_ARP,
1350 .procname = "proxy_arp",
1351 .data = &ipv4_devconf.proxy_arp,
1352 .maxlen = sizeof(int),
1354 .proc_handler = &proc_dointvec,
1357 .ctl_name = NET_IPV4_CONF_MEDIUM_ID,
1358 .procname = "medium_id",
1359 .data = &ipv4_devconf.medium_id,
1360 .maxlen = sizeof(int),
1362 .proc_handler = &proc_dointvec,
1365 .ctl_name = NET_IPV4_CONF_BOOTP_RELAY,
1366 .procname = "bootp_relay",
1367 .data = &ipv4_devconf.bootp_relay,
1368 .maxlen = sizeof(int),
1370 .proc_handler = &proc_dointvec,
1373 .ctl_name = NET_IPV4_CONF_LOG_MARTIANS,
1374 .procname = "log_martians",
1375 .data = &ipv4_devconf.log_martians,
1376 .maxlen = sizeof(int),
1378 .proc_handler = &proc_dointvec,
1381 .ctl_name = NET_IPV4_CONF_TAG,
1383 .data = &ipv4_devconf.tag,
1384 .maxlen = sizeof(int),
1386 .proc_handler = &proc_dointvec,
1389 .ctl_name = NET_IPV4_CONF_ARPFILTER,
1390 .procname = "arp_filter",
1391 .data = &ipv4_devconf.arp_filter,
1392 .maxlen = sizeof(int),
1394 .proc_handler = &proc_dointvec,
1397 .ctl_name = NET_IPV4_CONF_ARP_ANNOUNCE,
1398 .procname = "arp_announce",
1399 .data = &ipv4_devconf.arp_announce,
1400 .maxlen = sizeof(int),
1402 .proc_handler = &proc_dointvec,
1405 .ctl_name = NET_IPV4_CONF_ARP_IGNORE,
1406 .procname = "arp_ignore",
1407 .data = &ipv4_devconf.arp_ignore,
1408 .maxlen = sizeof(int),
1410 .proc_handler = &proc_dointvec,
1413 .ctl_name = NET_IPV4_CONF_NOXFRM,
1414 .procname = "disable_xfrm",
1415 .data = &ipv4_devconf.no_xfrm,
1416 .maxlen = sizeof(int),
1418 .proc_handler = &ipv4_doint_and_flush,
1419 .strategy = &ipv4_doint_and_flush_strategy,
1422 .ctl_name = NET_IPV4_CONF_NOPOLICY,
1423 .procname = "disable_policy",
1424 .data = &ipv4_devconf.no_policy,
1425 .maxlen = sizeof(int),
1427 .proc_handler = &ipv4_doint_and_flush,
1428 .strategy = &ipv4_doint_and_flush_strategy,
1431 .ctl_name = NET_IPV4_CONF_FORCE_IGMP_VERSION,
1432 .procname = "force_igmp_version",
1433 .data = &ipv4_devconf.force_igmp_version,
1434 .maxlen = sizeof(int),
1436 .proc_handler = &ipv4_doint_and_flush,
1437 .strategy = &ipv4_doint_and_flush_strategy,
1440 .ctl_name = NET_IPV4_CONF_PROMOTE_SECONDARIES,
1441 .procname = "promote_secondaries",
1442 .data = &ipv4_devconf.promote_secondaries,
1443 .maxlen = sizeof(int),
1445 .proc_handler = &ipv4_doint_and_flush,
1446 .strategy = &ipv4_doint_and_flush_strategy,
1451 .ctl_name = NET_PROTO_CONF_ALL,
1454 .child = devinet_sysctl.devinet_vars,
1457 .devinet_conf_dir = {
1459 .ctl_name = NET_IPV4_CONF,
1462 .child = devinet_sysctl.devinet_dev,
1465 .devinet_proto_dir = {
1467 .ctl_name = NET_IPV4,
1470 .child = devinet_sysctl.devinet_conf_dir,
1473 .devinet_root_dir = {
1475 .ctl_name = CTL_NET,
1478 .child = devinet_sysctl.devinet_proto_dir,
1483 static void devinet_sysctl_register(struct in_device *in_dev,
1484 struct ipv4_devconf *p)
1487 struct net_device *dev = in_dev ? in_dev->dev : NULL;
1488 struct devinet_sysctl_table *t = kmalloc(sizeof(*t), GFP_KERNEL);
1489 char *dev_name = NULL;
1493 memcpy(t, &devinet_sysctl, sizeof(*t));
1494 for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
1495 t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
1496 t->devinet_vars[i].de = NULL;
1500 dev_name = dev->name;
1501 t->devinet_dev[0].ctl_name = dev->ifindex;
1503 dev_name = "default";
1504 t->devinet_dev[0].ctl_name = NET_PROTO_CONF_DEFAULT;
1508 * Make a copy of dev_name, because '.procname' is regarded as const
1509 * by sysctl and we wouldn't want anyone to change it under our feet
1510 * (see SIOCSIFNAME).
1512 dev_name = net_sysctl_strdup(dev_name);
1516 t->devinet_dev[0].procname = dev_name;
1517 t->devinet_dev[0].child = t->devinet_vars;
1518 t->devinet_dev[0].de = NULL;
1519 t->devinet_conf_dir[0].child = t->devinet_dev;
1520 t->devinet_conf_dir[0].de = NULL;
1521 t->devinet_proto_dir[0].child = t->devinet_conf_dir;
1522 t->devinet_proto_dir[0].de = NULL;
1523 t->devinet_root_dir[0].child = t->devinet_proto_dir;
1524 t->devinet_root_dir[0].de = NULL;
1526 t->sysctl_header = register_sysctl_table(t->devinet_root_dir, 0);
1527 if (!t->sysctl_header)
1541 static void devinet_sysctl_unregister(struct ipv4_devconf *p)
1544 struct devinet_sysctl_table *t = p->sysctl;
1546 unregister_sysctl_table(t->sysctl_header);
1547 kfree(t->devinet_dev[0].procname);
1553 void __init devinet_init(void)
1555 register_gifconf(PF_INET, inet_gifconf);
1556 register_netdevice_notifier(&ip_netdev_notifier);
1557 rtnetlink_links[PF_INET] = inet_rtnetlink_table;
1558 #ifdef CONFIG_SYSCTL
1559 devinet_sysctl.sysctl_header =
1560 register_sysctl_table(devinet_sysctl.devinet_root_dir, 0);
1561 devinet_sysctl_register(NULL, &ipv4_devconf_dflt);
1565 EXPORT_SYMBOL(devinet_ioctl);
1566 EXPORT_SYMBOL(in_dev_finish_destroy);
1567 EXPORT_SYMBOL(inet_select_addr);
1568 EXPORT_SYMBOL(inetdev_by_index);
1569 EXPORT_SYMBOL(register_inetaddr_notifier);
1570 EXPORT_SYMBOL(unregister_inetaddr_notifier);