/*
* NET3 IP device support routines.
*
* Version: $Id: devinet.c,v 1.39 2000/12/10 22:24:11 davem Exp $
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version
* 2 of the License, or (at your option) any later version.
*
* Derived from the IP parts of dev.c 1.0.19
* Authors: Ross Biro, <bir7@leland.Stanford.Edu>
* Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
* Mark Evans, <evansmp@uhura.aston.ac.uk>
*
* Additional Authors:
* Alan Cox, <gw4pts@gw4pts.ampr.org>
* Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
*
* Changes:
* Alexey Kuznetsov: pa_* fields are replaced with ifaddr lists.
* Cyrus Durgin: updated for kmod
*/
#include <linux/config.h>
#include <asm/uaccess.h>
#include <asm/system.h>
#include <asm/bitops.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/string.h>
#include <linux/mm.h>
#include <linux/socket.h>
#include <linux/sockios.h>
#include <linux/in.h>
#include <linux/errno.h>
#include <linux/interrupt.h>
#include <linux/if_ether.h>
#include <linux/inet.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/skbuff.h>
#include <linux/rtnetlink.h>
#include <linux/init.h>
#include <linux/notifier.h>
#include <linux/inetdevice.h>
#include <linux/igmp.h>
#ifdef CONFIG_SYSCTL
#include <linux/sysctl.h>
#endif
#ifdef CONFIG_KMOD
#include <linux/kmod.h>
#endif
#include <net/ip.h>
#include <net/route.h>
#include <net/ip_fib.h>
struct ipv4_devconf ipv4_devconf = { 1, 1, 1, 1, 0, };
static struct ipv4_devconf ipv4_devconf_dflt = { 1, 1, 1, 1, 1, };
#ifdef CONFIG_RTNETLINK
static void rtmsg_ifa(int event, struct in_ifaddr *);
#else
#define rtmsg_ifa(a,b) do { } while(0)
#endif
static struct notifier_block *inetaddr_chain;
static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap, int destroy);
#ifdef CONFIG_SYSCTL
static void devinet_sysctl_register(struct in_device *in_dev, struct ipv4_devconf *p);
static void devinet_sysctl_unregister(struct ipv4_devconf *p);
#endif
int inet_ifa_count;
int inet_dev_count;
/* Locks all the inet devices. */
rwlock_t inetdev_lock = RW_LOCK_UNLOCKED;
85 static struct in_ifaddr * inet_alloc_ifa(void)
{
struct in_ifaddr *ifa;
ifa = kmalloc(sizeof(*ifa), GFP_KERNEL);
90 if (ifa) {
memset(ifa, 0, sizeof(*ifa));
inet_ifa_count++;
}
95 return ifa;
}
98 static __inline__ void inet_free_ifa(struct in_ifaddr *ifa)
{
100 if (ifa->ifa_dev)
__in_dev_put(ifa->ifa_dev);
kfree(ifa);
inet_ifa_count--;
}
106 void in_dev_finish_destroy(struct in_device *idev)
{
struct net_device *dev = idev->dev;
110 BUG_TRAP(idev->ifa_list==NULL);
111 BUG_TRAP(idev->mc_list==NULL);
#ifdef NET_REFCNT_DEBUG
printk(KERN_DEBUG "in_dev_finish_destroy: %p=%s\n", idev, dev ? dev->name : "NIL");
#endif
dev_put(dev);
116 if (!idev->dead) {
printk("Freeing alive in_device %p\n", idev);
118 return;
}
inet_dev_count--;
kfree(idev);
}
124 struct in_device *inetdev_init(struct net_device *dev)
{
struct in_device *in_dev;
128 ASSERT_RTNL();
in_dev = kmalloc(sizeof(*in_dev), GFP_KERNEL);
131 if (!in_dev)
132 return NULL;
memset(in_dev, 0, sizeof(*in_dev));
in_dev->lock = RW_LOCK_UNLOCKED;
memcpy(&in_dev->cnf, &ipv4_devconf_dflt, sizeof(in_dev->cnf));
in_dev->cnf.sysctl = NULL;
in_dev->dev = dev;
138 if ((in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl)) == NULL) {
kfree(in_dev);
140 return NULL;
}
inet_dev_count++;
/* Reference in_dev->dev */
dev_hold(dev);
#ifdef CONFIG_SYSCTL
neigh_sysctl_register(dev, in_dev->arp_parms, NET_IPV4, NET_IPV4_NEIGH, "ipv4");
#endif
148 write_lock_bh(&inetdev_lock);
dev->ip_ptr = in_dev;
/* Account for reference dev->ip_ptr */
in_dev_hold(in_dev);
152 write_unlock_bh(&inetdev_lock);
#ifdef CONFIG_SYSCTL
devinet_sysctl_register(in_dev, &in_dev->cnf);
#endif
156 if (dev->flags&IFF_UP)
ip_mc_up(in_dev);
158 return in_dev;
}
161 static void inetdev_destroy(struct in_device *in_dev)
{
struct in_ifaddr *ifa;
165 ASSERT_RTNL();
in_dev->dead = 1;
ip_mc_destroy_dev(in_dev);
171 while ((ifa = in_dev->ifa_list) != NULL) {
inet_del_ifa(in_dev, &in_dev->ifa_list, 0);
inet_free_ifa(ifa);
}
#ifdef CONFIG_SYSCTL
devinet_sysctl_unregister(&in_dev->cnf);
#endif
179 write_lock_bh(&inetdev_lock);
in_dev->dev->ip_ptr = NULL;
/* in_dev_put following below will kill the in_device */
182 write_unlock_bh(&inetdev_lock);
neigh_parms_release(&arp_tbl, in_dev->arp_parms);
in_dev_put(in_dev);
}
189 int inet_addr_onlink(struct in_device *in_dev, u32 a, u32 b)
{
read_lock(&in_dev->lock);
192 for_primary_ifa(in_dev) {
193 if (inet_ifa_match(a, ifa)) {
194 if (!b || inet_ifa_match(b, ifa)) {
195 read_unlock(&in_dev->lock);
196 return 1;
}
}
} endfor_ifa(in_dev);
200 read_unlock(&in_dev->lock);
201 return 0;
}
static void
205 inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap, int destroy)
{
struct in_ifaddr *ifa1 = *ifap;
209 ASSERT_RTNL();
/* 1. Deleting primary ifaddr forces deletion all secondaries */
213 if (!(ifa1->ifa_flags&IFA_F_SECONDARY)) {
struct in_ifaddr *ifa;
struct in_ifaddr **ifap1 = &ifa1->ifa_next;
217 while ((ifa=*ifap1) != NULL) {
if (!(ifa->ifa_flags&IFA_F_SECONDARY) ||
ifa1->ifa_mask != ifa->ifa_mask ||
220 !inet_ifa_match(ifa1->ifa_address, ifa)) {
ifap1 = &ifa->ifa_next;
222 continue;
}
224 write_lock_bh(&in_dev->lock);
*ifap1 = ifa->ifa_next;
226 write_unlock_bh(&in_dev->lock);
228 rtmsg_ifa(RTM_DELADDR, ifa);
notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa);
inet_free_ifa(ifa);
}
}
/* 2. Unlink it */
236 write_lock_bh(&in_dev->lock);
*ifap = ifa1->ifa_next;
238 write_unlock_bh(&in_dev->lock);
/* 3. Announce address deletion */
/* Send message first, then call notifier.
At first sight, FIB update triggered by notifier
will refer to already deleted ifaddr, that could confuse
netlink listeners. It is not true: look, gated sees
that route deleted and if it still thinks that ifaddr
is valid, it will try to restore deleted routes... Grr.
So that, this order is correct.
*/
250 rtmsg_ifa(RTM_DELADDR, ifa1);
notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1);
252 if (destroy) {
inet_free_ifa(ifa1);
255 if (in_dev->ifa_list == NULL)
inetdev_destroy(in_dev);
}
}
static int
261 inet_insert_ifa(struct in_ifaddr *ifa)
{
struct in_device *in_dev = ifa->ifa_dev;
struct in_ifaddr *ifa1, **ifap, **last_primary;
266 ASSERT_RTNL();
268 if (ifa->ifa_local == 0) {
inet_free_ifa(ifa);
270 return 0;
}
ifa->ifa_flags &= ~IFA_F_SECONDARY;
last_primary = &in_dev->ifa_list;
276 for (ifap=&in_dev->ifa_list; (ifa1=*ifap)!=NULL; ifap=&ifa1->ifa_next) {
277 if (!(ifa1->ifa_flags&IFA_F_SECONDARY) && ifa->ifa_scope <= ifa1->ifa_scope)
last_primary = &ifa1->ifa_next;
279 if (ifa1->ifa_mask == ifa->ifa_mask && inet_ifa_match(ifa1->ifa_address, ifa)) {
280 if (ifa1->ifa_local == ifa->ifa_local) {
inet_free_ifa(ifa);
282 return -EEXIST;
}
284 if (ifa1->ifa_scope != ifa->ifa_scope) {
inet_free_ifa(ifa);
286 return -EINVAL;
}
ifa->ifa_flags |= IFA_F_SECONDARY;
}
}
292 if (!(ifa->ifa_flags&IFA_F_SECONDARY)) {
net_srandom(ifa->ifa_local);
ifap = last_primary;
}
ifa->ifa_next = *ifap;
298 write_lock_bh(&in_dev->lock);
*ifap = ifa;
300 write_unlock_bh(&in_dev->lock);
/* Send message first, then call notifier.
Notifier will trigger FIB update, so that
listeners of netlink will know about new ifaddr */
305 rtmsg_ifa(RTM_NEWADDR, ifa);
notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
308 return 0;
}
static int
312 inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa)
{
struct in_device *in_dev = __in_dev_get(dev);
316 ASSERT_RTNL();
318 if (in_dev == NULL) {
in_dev = inetdev_init(dev);
320 if (in_dev == NULL) {
inet_free_ifa(ifa);
322 return -ENOBUFS;
}
}
325 if (ifa->ifa_dev != in_dev) {
326 BUG_TRAP(ifa->ifa_dev==NULL);
in_dev_hold(in_dev);
ifa->ifa_dev=in_dev;
}
330 if (LOOPBACK(ifa->ifa_local))
ifa->ifa_scope = RT_SCOPE_HOST;
332 return inet_insert_ifa(ifa);
}
335 struct in_device *inetdev_by_index(int ifindex)
{
struct net_device *dev;
struct in_device *in_dev = NULL;
read_lock(&dev_base_lock);
dev = __dev_get_by_index(ifindex);
341 if (dev)
in_dev = in_dev_get(dev);
343 read_unlock(&dev_base_lock);
344 return in_dev;
}
/* Called only from RTNL semaphored context. No locks. */
349 struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, u32 prefix, u32 mask)
{
351 ASSERT_RTNL();
353 for_primary_ifa(in_dev) {
354 if (ifa->ifa_mask == mask && inet_ifa_match(prefix, ifa))
355 return ifa;
} endfor_ifa(in_dev);
357 return NULL;
}
#ifdef CONFIG_RTNETLINK
int
inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
{
struct rtattr **rta = arg;
struct in_device *in_dev;
struct ifaddrmsg *ifm = NLMSG_DATA(nlh);
struct in_ifaddr *ifa, **ifap;
ASSERT_RTNL();
if ((in_dev = inetdev_by_index(ifm->ifa_index)) == NULL)
return -EADDRNOTAVAIL;
__in_dev_put(in_dev);
for (ifap=&in_dev->ifa_list; (ifa=*ifap)!=NULL; ifap=&ifa->ifa_next) {
if ((rta[IFA_LOCAL-1] && memcmp(RTA_DATA(rta[IFA_LOCAL-1]), &ifa->ifa_local, 4)) ||
(rta[IFA_LABEL-1] && strcmp(RTA_DATA(rta[IFA_LABEL-1]), ifa->ifa_label)) ||
(rta[IFA_ADDRESS-1] &&
(ifm->ifa_prefixlen != ifa->ifa_prefixlen ||
!inet_ifa_match(*(u32*)RTA_DATA(rta[IFA_ADDRESS-1]), ifa))))
continue;
inet_del_ifa(in_dev, ifap, 1);
return 0;
}
return -EADDRNOTAVAIL;
}
int
inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
{
struct rtattr **rta = arg;
struct net_device *dev;
struct in_device *in_dev;
struct ifaddrmsg *ifm = NLMSG_DATA(nlh);
struct in_ifaddr *ifa;
ASSERT_RTNL();
if (ifm->ifa_prefixlen > 32 || rta[IFA_LOCAL-1] == NULL)
return -EINVAL;
if ((dev = __dev_get_by_index(ifm->ifa_index)) == NULL)
return -ENODEV;
if ((in_dev = __in_dev_get(dev)) == NULL) {
in_dev = inetdev_init(dev);
if (!in_dev)
return -ENOBUFS;
}
if ((ifa = inet_alloc_ifa()) == NULL)
return -ENOBUFS;
if (rta[IFA_ADDRESS-1] == NULL)
rta[IFA_ADDRESS-1] = rta[IFA_LOCAL-1];
memcpy(&ifa->ifa_local, RTA_DATA(rta[IFA_LOCAL-1]), 4);
memcpy(&ifa->ifa_address, RTA_DATA(rta[IFA_ADDRESS-1]), 4);
ifa->ifa_prefixlen = ifm->ifa_prefixlen;
ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen);
if (rta[IFA_BROADCAST-1])
memcpy(&ifa->ifa_broadcast, RTA_DATA(rta[IFA_BROADCAST-1]), 4);
if (rta[IFA_ANYCAST-1])
memcpy(&ifa->ifa_anycast, RTA_DATA(rta[IFA_ANYCAST-1]), 4);
ifa->ifa_flags = ifm->ifa_flags;
ifa->ifa_scope = ifm->ifa_scope;
in_dev_hold(in_dev);
ifa->ifa_dev = in_dev;
if (rta[IFA_LABEL-1])
memcpy(ifa->ifa_label, RTA_DATA(rta[IFA_LABEL-1]), IFNAMSIZ);
else
memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
return inet_insert_ifa(ifa);
}
#endif
/*
* Determine a default network mask, based on the IP address.
*/
444 static __inline__ int inet_abc_len(u32 addr)
{
446 if (ZERONET(addr))
447 return 0;
addr = ntohl(addr);
450 if (IN_CLASSA(addr))
451 return 8;
452 if (IN_CLASSB(addr))
453 return 16;
454 if (IN_CLASSC(addr))
455 return 24;
/*
* Something else, probably a multicast.
*/
461 return -1;
}
465 int devinet_ioctl(unsigned int cmd, void *arg)
{
struct ifreq ifr;
struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
struct in_device *in_dev;
struct in_ifaddr **ifap = NULL;
struct in_ifaddr *ifa = NULL;
struct net_device *dev;
char *colon;
int ret = 0;
/*
* Fetch the caller's info block into kernel space
*/
480 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
481 return -EFAULT;
ifr.ifr_name[IFNAMSIZ-1] = 0;
colon = strchr(ifr.ifr_name, ':');
485 if (colon)
*colon = 0;
#ifdef CONFIG_KMOD
dev_load(ifr.ifr_name);
#endif
492 switch(cmd) {
493 case SIOCGIFADDR: /* Get interface address */
494 case SIOCGIFBRDADDR: /* Get the broadcast address */
495 case SIOCGIFDSTADDR: /* Get the destination address */
496 case SIOCGIFNETMASK: /* Get the netmask for the interface */
/* Note that this ioctls will not sleep,
so that we do not impose a lock.
One day we will be forced to put shlock here (I mean SMP)
*/
memset(sin, 0, sizeof(*sin));
sin->sin_family = AF_INET;
503 break;
505 case SIOCSIFFLAGS:
506 if (!capable(CAP_NET_ADMIN))
507 return -EACCES;
508 break;
509 case SIOCSIFADDR: /* Set interface address (and family) */
510 case SIOCSIFBRDADDR: /* Set the broadcast address */
511 case SIOCSIFDSTADDR: /* Set the destination address */
512 case SIOCSIFNETMASK: /* Set the netmask for the interface */
513 if (!capable(CAP_NET_ADMIN))
514 return -EACCES;
515 if (sin->sin_family != AF_INET)
516 return -EINVAL;
517 break;
518 default:
519 return -EINVAL;
}
dev_probe_lock();
rtnl_lock();
525 if ((dev = __dev_get_by_name(ifr.ifr_name)) == NULL) {
ret = -ENODEV;
527 goto done;
}
530 if (colon)
*colon = ':';
533 if ((in_dev=__in_dev_get(dev)) != NULL) {
534 for (ifap=&in_dev->ifa_list; (ifa=*ifap) != NULL; ifap=&ifa->ifa_next)
535 if (strcmp(ifr.ifr_name, ifa->ifa_label) == 0)
536 break;
}
539 if (ifa == NULL && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS) {
ret = -EADDRNOTAVAIL;
541 goto done;
}
544 switch(cmd) {
545 case SIOCGIFADDR: /* Get interface address */
sin->sin_addr.s_addr = ifa->ifa_local;
547 goto rarok;
549 case SIOCGIFBRDADDR: /* Get the broadcast address */
sin->sin_addr.s_addr = ifa->ifa_broadcast;
551 goto rarok;
553 case SIOCGIFDSTADDR: /* Get the destination address */
sin->sin_addr.s_addr = ifa->ifa_address;
555 goto rarok;
557 case SIOCGIFNETMASK: /* Get the netmask for the interface */
sin->sin_addr.s_addr = ifa->ifa_mask;
559 goto rarok;
561 case SIOCSIFFLAGS:
562 if (colon) {
563 if (ifa == NULL) {
ret = -EADDRNOTAVAIL;
565 break;
}
567 if (!(ifr.ifr_flags&IFF_UP))
inet_del_ifa(in_dev, ifap, 1);
569 break;
}
ret = dev_change_flags(dev, ifr.ifr_flags);
572 break;
574 case SIOCSIFADDR: /* Set interface address (and family) */
575 if (inet_abc_len(sin->sin_addr.s_addr) < 0) {
ret = -EINVAL;
577 break;
}
580 if (!ifa) {
581 if ((ifa = inet_alloc_ifa()) == NULL) {
ret = -ENOBUFS;
583 break;
}
585 if (colon)
memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ);
587 else
memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
589 } else {
ret = 0;
591 if (ifa->ifa_local == sin->sin_addr.s_addr)
592 break;
inet_del_ifa(in_dev, ifap, 0);
ifa->ifa_broadcast = 0;
ifa->ifa_anycast = 0;
}
ifa->ifa_address =
ifa->ifa_local = sin->sin_addr.s_addr;
601 if (!(dev->flags&IFF_POINTOPOINT)) {
ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address);
ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen);
604 if ((dev->flags&IFF_BROADCAST) && ifa->ifa_prefixlen < 31)
ifa->ifa_broadcast = ifa->ifa_address|~ifa->ifa_mask;
606 } else {
ifa->ifa_prefixlen = 32;
ifa->ifa_mask = inet_make_mask(32);
}
ret = inet_set_ifa(dev, ifa);
611 break;
613 case SIOCSIFBRDADDR: /* Set the broadcast address */
614 if (ifa->ifa_broadcast != sin->sin_addr.s_addr) {
inet_del_ifa(in_dev, ifap, 0);
ifa->ifa_broadcast = sin->sin_addr.s_addr;
inet_insert_ifa(ifa);
}
619 break;
621 case SIOCSIFDSTADDR: /* Set the destination address */
622 if (ifa->ifa_address != sin->sin_addr.s_addr) {
623 if (inet_abc_len(sin->sin_addr.s_addr) < 0) {
ret = -EINVAL;
625 break;
}
inet_del_ifa(in_dev, ifap, 0);
ifa->ifa_address = sin->sin_addr.s_addr;
inet_insert_ifa(ifa);
}
631 break;
633 case SIOCSIFNETMASK: /* Set the netmask for the interface */
/*
* The mask we set must be legal.
*/
638 if (bad_mask(sin->sin_addr.s_addr, 0)) {
ret = -EINVAL;
640 break;
}
643 if (ifa->ifa_mask != sin->sin_addr.s_addr) {
inet_del_ifa(in_dev, ifap, 0);
ifa->ifa_mask = sin->sin_addr.s_addr;
ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask);
inet_insert_ifa(ifa);
}
649 break;
}
done:
rtnl_unlock();
dev_probe_unlock();
654 return ret;
rarok:
rtnl_unlock();
dev_probe_unlock();
659 if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
660 return -EFAULT;
661 return 0;
}
static int
665 inet_gifconf(struct net_device *dev, char *buf, int len)
{
struct in_device *in_dev = __in_dev_get(dev);
struct in_ifaddr *ifa;
struct ifreq ifr;
int done=0;
672 if (in_dev==NULL || (ifa=in_dev->ifa_list)==NULL)
673 return 0;
675 for ( ; ifa; ifa = ifa->ifa_next) {
676 if (!buf) {
done += sizeof(ifr);
678 continue;
}
680 if (len < (int) sizeof(ifr))
681 return done;
memset(&ifr, 0, sizeof(struct ifreq));
683 if (ifa->ifa_label)
strcpy(ifr.ifr_name, ifa->ifa_label);
685 else
strcpy(ifr.ifr_name, dev->name);
(*(struct sockaddr_in *) &ifr.ifr_addr).sin_family = AF_INET;
(*(struct sockaddr_in *) &ifr.ifr_addr).sin_addr.s_addr = ifa->ifa_local;
691 if (copy_to_user(buf, &ifr, sizeof(struct ifreq)))
692 return -EFAULT;
buf += sizeof(struct ifreq);
len -= sizeof(struct ifreq);
done += sizeof(struct ifreq);
}
697 return done;
}
700 u32 inet_select_addr(const struct net_device *dev, u32 dst, int scope)
{
u32 addr = 0;
struct in_device *in_dev;
read_lock(&inetdev_lock);
in_dev = __in_dev_get(dev);
707 if (in_dev == NULL) {
708 read_unlock(&inetdev_lock);
709 return 0;
}
read_lock(&in_dev->lock);
713 for_primary_ifa(in_dev) {
714 if (ifa->ifa_scope > scope)
715 continue;
716 if (!dst || inet_ifa_match(dst, ifa)) {
addr = ifa->ifa_local;
718 break;
}
720 if (!addr)
addr = ifa->ifa_local;
} endfor_ifa(in_dev);
723 read_unlock(&in_dev->lock);
724 read_unlock(&inetdev_lock);
726 if (addr)
727 return addr;
/* Not loopback addresses on loopback should be preferred
in this case. It is importnat that lo is the first interface
in dev_base list.
*/
read_lock(&dev_base_lock);
read_lock(&inetdev_lock);
735 for (dev=dev_base; dev; dev=dev->next) {
736 if ((in_dev=__in_dev_get(dev)) == NULL)
737 continue;
read_lock(&in_dev->lock);
740 for_primary_ifa(in_dev) {
if (ifa->ifa_scope != RT_SCOPE_LINK &&
742 ifa->ifa_scope <= scope) {
743 read_unlock(&in_dev->lock);
744 read_unlock(&inetdev_lock);
745 read_unlock(&dev_base_lock);
746 return ifa->ifa_local;
}
} endfor_ifa(in_dev);
749 read_unlock(&in_dev->lock);
}
751 read_unlock(&inetdev_lock);
752 read_unlock(&dev_base_lock);
754 return 0;
}
/*
* Device notifier
*/
761 int register_inetaddr_notifier(struct notifier_block *nb)
{
763 return notifier_chain_register(&inetaddr_chain, nb);
}
766 int unregister_inetaddr_notifier(struct notifier_block *nb)
{
768 return notifier_chain_unregister(&inetaddr_chain,nb);
}
/* Called only under RTNL semaphore */
773 static int inetdev_event(struct notifier_block *this, unsigned long event, void *ptr)
{
struct net_device *dev = ptr;
struct in_device *in_dev = __in_dev_get(dev);
778 ASSERT_RTNL();
780 if (in_dev == NULL)
781 return NOTIFY_DONE;
783 switch (event) {
784 case NETDEV_REGISTER:
printk(KERN_DEBUG "inetdev_event: bug\n");
dev->ip_ptr = NULL;
787 break;
788 case NETDEV_UP:
789 if (dev->mtu < 68)
790 break;
791 if (dev == &loopback_dev) {
struct in_ifaddr *ifa;
793 if ((ifa = inet_alloc_ifa()) != NULL) {
ifa->ifa_local =
ifa->ifa_address = htonl(INADDR_LOOPBACK);
ifa->ifa_prefixlen = 8;
ifa->ifa_mask = inet_make_mask(8);
in_dev_hold(in_dev);
ifa->ifa_dev = in_dev;
ifa->ifa_scope = RT_SCOPE_HOST;
memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
inet_insert_ifa(ifa);
}
}
ip_mc_up(in_dev);
806 break;
807 case NETDEV_DOWN:
ip_mc_down(in_dev);
809 break;
810 case NETDEV_CHANGEMTU:
811 if (dev->mtu >= 68)
812 break;
/* MTU falled under 68, disable IP */
814 case NETDEV_UNREGISTER:
inetdev_destroy(in_dev);
816 break;
817 case NETDEV_CHANGENAME:
818 if (in_dev->ifa_list) {
struct in_ifaddr *ifa;
820 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next)
memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
/* Do not notify about label change, this event is
not interesting to applications using netlink.
*/
}
826 break;
}
829 return NOTIFY_DONE;
}
struct notifier_block ip_netdev_notifier={
inetdev_event,
NULL,
0
};
#ifdef CONFIG_RTNETLINK
static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
u32 pid, u32 seq, int event)
{
struct ifaddrmsg *ifm;
struct nlmsghdr *nlh;
unsigned char *b = skb->tail;
nlh = NLMSG_PUT(skb, pid, seq, event, sizeof(*ifm));
ifm = NLMSG_DATA(nlh);
ifm->ifa_family = AF_INET;
ifm->ifa_prefixlen = ifa->ifa_prefixlen;
ifm->ifa_flags = ifa->ifa_flags|IFA_F_PERMANENT;
ifm->ifa_scope = ifa->ifa_scope;
ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
if (ifa->ifa_address)
RTA_PUT(skb, IFA_ADDRESS, 4, &ifa->ifa_address);
if (ifa->ifa_local)
RTA_PUT(skb, IFA_LOCAL, 4, &ifa->ifa_local);
if (ifa->ifa_broadcast)
RTA_PUT(skb, IFA_BROADCAST, 4, &ifa->ifa_broadcast);
if (ifa->ifa_anycast)
RTA_PUT(skb, IFA_ANYCAST, 4, &ifa->ifa_anycast);
if (ifa->ifa_label[0])
RTA_PUT(skb, IFA_LABEL, IFNAMSIZ, &ifa->ifa_label);
nlh->nlmsg_len = skb->tail - b;
return skb->len;
nlmsg_failure:
rtattr_failure:
skb_trim(skb, b - skb->data);
return -1;
}
static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
{
int idx, ip_idx;
int s_idx, s_ip_idx;
struct net_device *dev;
struct in_device *in_dev;
struct in_ifaddr *ifa;
s_idx = cb->args[0];
s_ip_idx = ip_idx = cb->args[1];
read_lock(&dev_base_lock);
for (dev=dev_base, idx=0; dev; dev = dev->next, idx++) {
if (idx < s_idx)
continue;
if (idx > s_idx)
s_ip_idx = 0;
read_lock(&inetdev_lock);
if ((in_dev = __in_dev_get(dev)) == NULL) {
read_unlock(&inetdev_lock);
continue;
}
read_lock(&in_dev->lock);
for (ifa = in_dev->ifa_list, ip_idx = 0; ifa;
ifa = ifa->ifa_next, ip_idx++) {
if (ip_idx < s_ip_idx)
continue;
if (inet_fill_ifaddr(skb, ifa, NETLINK_CB(cb->skb).pid,
cb->nlh->nlmsg_seq, RTM_NEWADDR) <= 0) {
read_unlock(&in_dev->lock);
read_unlock(&inetdev_lock);
goto done;
}
}
read_unlock(&in_dev->lock);
read_unlock(&inetdev_lock);
}
done:
read_unlock(&dev_base_lock);
cb->args[0] = idx;
cb->args[1] = ip_idx;
return skb->len;
}
static void rtmsg_ifa(int event, struct in_ifaddr * ifa)
{
struct sk_buff *skb;
int size = NLMSG_SPACE(sizeof(struct ifaddrmsg)+128);
skb = alloc_skb(size, GFP_KERNEL);
if (!skb) {
netlink_set_err(rtnl, 0, RTMGRP_IPV4_IFADDR, ENOBUFS);
return;
}
if (inet_fill_ifaddr(skb, ifa, 0, 0, event) < 0) {
kfree_skb(skb);
netlink_set_err(rtnl, 0, RTMGRP_IPV4_IFADDR, EINVAL);
return;
}
NETLINK_CB(skb).dst_groups = RTMGRP_IPV4_IFADDR;
netlink_broadcast(rtnl, skb, 0, RTMGRP_IPV4_IFADDR, GFP_KERNEL);
}
static struct rtnetlink_link inet_rtnetlink_table[RTM_MAX-RTM_BASE+1] =
{
{ NULL, NULL, },
{ NULL, NULL, },
{ NULL, NULL, },
{ NULL, NULL, },
{ inet_rtm_newaddr, NULL, },
{ inet_rtm_deladdr, NULL, },
{ NULL, inet_dump_ifaddr, },
{ NULL, NULL, },
{ inet_rtm_newroute, NULL, },
{ inet_rtm_delroute, NULL, },
{ inet_rtm_getroute, inet_dump_fib, },
{ NULL, NULL, },
{ NULL, NULL, },
{ NULL, NULL, },
{ NULL, NULL, },
{ NULL, NULL, },
#ifdef CONFIG_IP_MULTIPLE_TABLES
{ inet_rtm_newrule, NULL, },
{ inet_rtm_delrule, NULL, },
{ NULL, inet_dump_rules, },
{ NULL, NULL, },
#else
{ NULL, NULL, },
{ NULL, NULL, },
{ NULL, NULL, },
{ NULL, NULL, },
#endif
};
#endif /* CONFIG_RTNETLINK */
#ifdef CONFIG_SYSCTL
978 void inet_forward_change()
{
struct net_device *dev;
int on = ipv4_devconf.forwarding;
ipv4_devconf.accept_redirects = !on;
ipv4_devconf_dflt.forwarding = on;
read_lock(&dev_base_lock);
987 for (dev = dev_base; dev; dev = dev->next) {
struct in_device *in_dev;
read_lock(&inetdev_lock);
in_dev = __in_dev_get(dev);
991 if (in_dev)
in_dev->cnf.forwarding = on;
993 read_unlock(&inetdev_lock);
}
995 read_unlock(&dev_base_lock);
rt_cache_flush(0);
}
static
1001 int devinet_sysctl_forward(ctl_table *ctl, int write, struct file * filp,
void *buffer, size_t *lenp)
{
int *valp = ctl->data;
int val = *valp;
int ret;
ret = proc_dointvec(ctl, write, filp, buffer, lenp);
1010 if (write && *valp != val) {
1011 if (valp == &ipv4_devconf.forwarding)
inet_forward_change();
1013 else if (valp != &ipv4_devconf_dflt.forwarding)
rt_cache_flush(0);
}
1017 return ret;
}
static struct devinet_sysctl_table
{
struct ctl_table_header *sysctl_header;
ctl_table devinet_vars[13];
ctl_table devinet_dev[2];
ctl_table devinet_conf_dir[2];
ctl_table devinet_proto_dir[2];
ctl_table devinet_root_dir[2];
} devinet_sysctl = {
NULL,
{{NET_IPV4_CONF_FORWARDING, "forwarding",
&ipv4_devconf.forwarding, sizeof(int), 0644, NULL,
&devinet_sysctl_forward},
{NET_IPV4_CONF_MC_FORWARDING, "mc_forwarding",
&ipv4_devconf.mc_forwarding, sizeof(int), 0444, NULL,
&proc_dointvec},
{NET_IPV4_CONF_ACCEPT_REDIRECTS, "accept_redirects",
&ipv4_devconf.accept_redirects, sizeof(int), 0644, NULL,
&proc_dointvec},
{NET_IPV4_CONF_SECURE_REDIRECTS, "secure_redirects",
&ipv4_devconf.secure_redirects, sizeof(int), 0644, NULL,
&proc_dointvec},
{NET_IPV4_CONF_SHARED_MEDIA, "shared_media",
&ipv4_devconf.shared_media, sizeof(int), 0644, NULL,
&proc_dointvec},
{NET_IPV4_CONF_RP_FILTER, "rp_filter",
&ipv4_devconf.rp_filter, sizeof(int), 0644, NULL,
&proc_dointvec},
{NET_IPV4_CONF_SEND_REDIRECTS, "send_redirects",
&ipv4_devconf.send_redirects, sizeof(int), 0644, NULL,
&proc_dointvec},
{NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE, "accept_source_route",
&ipv4_devconf.accept_source_route, sizeof(int), 0644, NULL,
&proc_dointvec},
{NET_IPV4_CONF_PROXY_ARP, "proxy_arp",
&ipv4_devconf.proxy_arp, sizeof(int), 0644, NULL,
&proc_dointvec},
{NET_IPV4_CONF_BOOTP_RELAY, "bootp_relay",
&ipv4_devconf.bootp_relay, sizeof(int), 0644, NULL,
&proc_dointvec},
{NET_IPV4_CONF_LOG_MARTIANS, "log_martians",
&ipv4_devconf.log_martians, sizeof(int), 0644, NULL,
&proc_dointvec},
{NET_IPV4_CONF_TAG, "tag",
&ipv4_devconf.tag, sizeof(int), 0644, NULL,
&proc_dointvec},
{0}},
{{NET_PROTO_CONF_ALL, "all", NULL, 0, 0555, devinet_sysctl.devinet_vars},{0}},
{{NET_IPV4_CONF, "conf", NULL, 0, 0555, devinet_sysctl.devinet_dev},{0}},
{{NET_IPV4, "ipv4", NULL, 0, 0555, devinet_sysctl.devinet_conf_dir},{0}},
{{CTL_NET, "net", NULL, 0, 0555, devinet_sysctl.devinet_proto_dir},{0}}
};
1074 static void devinet_sysctl_register(struct in_device *in_dev, struct ipv4_devconf *p)
{
int i;
struct net_device *dev = in_dev ? in_dev->dev : NULL;
struct devinet_sysctl_table *t;
t = kmalloc(sizeof(*t), GFP_KERNEL);
1081 if (t == NULL)
1082 return;
memcpy(t, &devinet_sysctl, sizeof(*t));
1084 for (i=0; i<sizeof(t->devinet_vars)/sizeof(t->devinet_vars[0])-1; i++) {
t->devinet_vars[i].data += (char*)p - (char*)&ipv4_devconf;
t->devinet_vars[i].de = NULL;
}
1088 if (dev) {
t->devinet_dev[0].procname = dev->name;
t->devinet_dev[0].ctl_name = dev->ifindex;
1091 } else {
t->devinet_dev[0].procname = "default";
t->devinet_dev[0].ctl_name = NET_PROTO_CONF_DEFAULT;
}
t->devinet_dev[0].child = t->devinet_vars;
t->devinet_dev[0].de = NULL;
t->devinet_conf_dir[0].child = t->devinet_dev;
t->devinet_conf_dir[0].de = NULL;
t->devinet_proto_dir[0].child = t->devinet_conf_dir;
t->devinet_proto_dir[0].de = NULL;
t->devinet_root_dir[0].child = t->devinet_proto_dir;
t->devinet_root_dir[0].de = NULL;
t->sysctl_header = register_sysctl_table(t->devinet_root_dir, 0);
1105 if (t->sysctl_header == NULL)
kfree(t);
1107 else
p->sysctl = t;
}
1111 static void devinet_sysctl_unregister(struct ipv4_devconf *p)
{
1113 if (p->sysctl) {
struct devinet_sysctl_table *t = p->sysctl;
p->sysctl = NULL;
unregister_sysctl_table(t->sysctl_header);
kfree(t);
}
}
#endif
1122 void __init devinet_init(void)
{
register_gifconf(PF_INET, inet_gifconf);
register_netdevice_notifier(&ip_netdev_notifier);
#ifdef CONFIG_RTNETLINK
rtnetlink_links[PF_INET] = inet_rtnetlink_table;
#endif
#ifdef CONFIG_SYSCTL
devinet_sysctl.sysctl_header =
register_sysctl_table(devinet_sysctl.devinet_root_dir, 0);
devinet_sysctl_register(NULL, &ipv4_devconf_dflt);
#endif
}