2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* IPv6 Address [auto]configuration
|
|
|
|
* Linux INET6 implementation
|
|
|
|
*
|
|
|
|
* Authors:
|
2007-02-09 15:24:49 +01:00
|
|
|
* Pedro Roque <roque@di.fc.ul.pt>
|
2005-04-17 00:20:36 +02:00
|
|
|
* Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Changes:
|
|
|
|
*
|
|
|
|
* Janos Farkas : delete timer on ifdown
|
|
|
|
* <chexum@bankinf.banki.hu>
|
|
|
|
* Andi Kleen : kill double kfree on module
|
|
|
|
* unload.
|
|
|
|
* Maciej W. Rozycki : FDDI support
|
|
|
|
* sekiya@USAGI : Don't send too many RS
|
|
|
|
* packets.
|
|
|
|
* yoshfuji@USAGI : Fixed interval between DAD
|
|
|
|
* packets.
|
|
|
|
* YOSHIFUJI Hideaki @USAGI : improved accuracy of
|
|
|
|
* address validation timer.
|
|
|
|
* YOSHIFUJI Hideaki @USAGI : Privacy Extensions (RFC3041)
|
|
|
|
* support.
|
|
|
|
* Yuji SEKIYA @USAGI : Don't assign a same IPv6
|
|
|
|
* address on a same interface.
|
|
|
|
* YOSHIFUJI Hideaki @USAGI : ARCnet support
|
|
|
|
* YOSHIFUJI Hideaki @USAGI : convert /proc/net/if_inet6 to
|
|
|
|
* seq_file.
|
2005-11-08 18:38:12 +01:00
|
|
|
* YOSHIFUJI Hideaki @USAGI : improved source address
|
|
|
|
* selection; consider scope,
|
|
|
|
* status etc.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/socket.h>
|
|
|
|
#include <linux/sockios.h>
|
|
|
|
#include <linux/net.h>
|
|
|
|
#include <linux/in6.h>
|
|
|
|
#include <linux/netdevice.h>
|
2006-08-05 08:04:54 +02:00
|
|
|
#include <linux/if_addr.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <linux/if_arp.h>
|
|
|
|
#include <linux/if_arcnet.h>
|
|
|
|
#include <linux/if_infiniband.h>
|
|
|
|
#include <linux/route.h>
|
|
|
|
#include <linux/inetdevice.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#ifdef CONFIG_SYSCTL
|
|
|
|
#include <linux/sysctl.h>
|
|
|
|
#endif
|
2006-01-11 21:17:47 +01:00
|
|
|
#include <linux/capability.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/notifier.h>
|
2005-06-23 09:09:02 +02:00
|
|
|
#include <linux/string.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-09-12 12:01:34 +02:00
|
|
|
#include <net/net_namespace.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <net/sock.h>
|
|
|
|
#include <net/snmp.h>
|
|
|
|
|
|
|
|
#include <net/ipv6.h>
|
|
|
|
#include <net/protocol.h>
|
|
|
|
#include <net/ndisc.h>
|
|
|
|
#include <net/ip6_route.h>
|
|
|
|
#include <net/addrconf.h>
|
|
|
|
#include <net/tcp.h>
|
|
|
|
#include <net/ip.h>
|
2006-08-15 09:35:02 +02:00
|
|
|
#include <net/netlink.h>
|
2007-10-10 11:53:43 +02:00
|
|
|
#include <net/pkt_sched.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <linux/if_tunnel.h>
|
|
|
|
#include <linux/rtnetlink.h>
|
|
|
|
|
|
|
|
#ifdef CONFIG_IPV6_PRIVACY
|
|
|
|
#include <linux/random.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include <asm/uaccess.h>
|
2007-04-25 06:54:09 +02:00
|
|
|
#include <asm/unaligned.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
#include <linux/proc_fs.h>
|
|
|
|
#include <linux/seq_file.h>
|
|
|
|
|
|
|
|
/* Set to 3 to get tracing... */
|
|
|
|
#define ACONF_DEBUG 2
|
|
|
|
|
|
|
|
#if ACONF_DEBUG >= 3
|
|
|
|
#define ADBG(x) printk x
|
|
|
|
#else
|
|
|
|
#define ADBG(x)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#define INFINITY_LIFE_TIME 0xFFFFFFFF
|
|
|
|
#define TIME_DELTA(a,b) ((unsigned long)((long)(a) - (long)(b)))
|
|
|
|
|
|
|
|
#ifdef CONFIG_SYSCTL
|
2007-12-01 14:58:37 +01:00
|
|
|
static void addrconf_sysctl_register(struct inet6_dev *idev);
|
2008-01-11 02:41:21 +01:00
|
|
|
static void addrconf_sysctl_unregister(struct inet6_dev *idev);
|
|
|
|
#else
|
|
|
|
static inline void addrconf_sysctl_register(struct inet6_dev *idev)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void addrconf_sysctl_unregister(struct inet6_dev *idev)
|
|
|
|
{
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_IPV6_PRIVACY
|
|
|
|
static int __ipv6_regen_rndid(struct inet6_dev *idev);
|
2007-02-09 15:24:49 +01:00
|
|
|
static int __ipv6_try_regen_rndid(struct inet6_dev *idev, struct in6_addr *tmpaddr);
|
2005-04-17 00:20:36 +02:00
|
|
|
static void ipv6_regen_rndid(unsigned long data);
|
|
|
|
|
|
|
|
static int desync_factor = MAX_DESYNC_FACTOR * HZ;
|
|
|
|
#endif
|
|
|
|
|
2008-06-28 07:18:38 +02:00
|
|
|
static int ipv6_generate_eui64(u8 *eui, struct net_device *dev);
|
2005-04-17 00:20:36 +02:00
|
|
|
static int ipv6_count_addresses(struct inet6_dev *idev);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Configured unicast address hash table
|
|
|
|
*/
|
|
|
|
static struct inet6_ifaddr *inet6_addr_lst[IN6_ADDR_HSIZE];
|
|
|
|
static DEFINE_RWLOCK(addrconf_hash_lock);
|
|
|
|
|
|
|
|
static void addrconf_verify(unsigned long);
|
|
|
|
|
2005-09-09 22:10:40 +02:00
|
|
|
static DEFINE_TIMER(addr_chk_timer, addrconf_verify, 0, 0);
|
2005-04-17 00:20:36 +02:00
|
|
|
static DEFINE_SPINLOCK(addrconf_verify_lock);
|
|
|
|
|
|
|
|
static void addrconf_join_anycast(struct inet6_ifaddr *ifp);
|
|
|
|
static void addrconf_leave_anycast(struct inet6_ifaddr *ifp);
|
|
|
|
|
|
|
|
static int addrconf_ifdown(struct net_device *dev, int how);
|
|
|
|
|
2005-06-19 07:55:31 +02:00
|
|
|
static void addrconf_dad_start(struct inet6_ifaddr *ifp, u32 flags);
|
2005-04-17 00:20:36 +02:00
|
|
|
static void addrconf_dad_timer(unsigned long data);
|
|
|
|
static void addrconf_dad_completed(struct inet6_ifaddr *ifp);
|
2005-12-21 14:57:44 +01:00
|
|
|
static void addrconf_dad_run(struct inet6_dev *idev);
|
2005-04-17 00:20:36 +02:00
|
|
|
static void addrconf_rs_timer(unsigned long data);
|
|
|
|
static void __ipv6_ifa_notify(int event, struct inet6_ifaddr *ifa);
|
|
|
|
static void ipv6_ifa_notify(int event, struct inet6_ifaddr *ifa);
|
|
|
|
|
2007-02-09 15:24:49 +01:00
|
|
|
static void inet6_prefix_notify(int event, struct inet6_dev *idev,
|
2005-04-17 00:20:36 +02:00
|
|
|
struct prefix_info *pinfo);
|
2008-01-11 07:43:42 +01:00
|
|
|
static int ipv6_chk_same_addr(struct net *net, const struct in6_addr *addr,
|
|
|
|
struct net_device *dev);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
[PATCH] Notifier chain update: API changes
The kernel's implementation of notifier chains is unsafe. There is no
protection against entries being added to or removed from a chain while the
chain is in use. The issues were discussed in this thread:
http://marc.theaimsgroup.com/?l=linux-kernel&m=113018709002036&w=2
We noticed that notifier chains in the kernel fall into two basic usage
classes:
"Blocking" chains are always called from a process context
and the callout routines are allowed to sleep;
"Atomic" chains can be called from an atomic context and
the callout routines are not allowed to sleep.
We decided to codify this distinction and make it part of the API. Therefore
this set of patches introduces three new, parallel APIs: one for blocking
notifiers, one for atomic notifiers, and one for "raw" notifiers (which is
really just the old API under a new name). New kinds of data structures are
used for the heads of the chains, and new routines are defined for
registration, unregistration, and calling a chain. The three APIs are
explained in include/linux/notifier.h and their implementation is in
kernel/sys.c.
With atomic and blocking chains, the implementation guarantees that the chain
links will not be corrupted and that chain callers will not get messed up by
entries being added or removed. For raw chains the implementation provides no
guarantees at all; users of this API must provide their own protections. (The
idea was that situations may come up where the assumptions of the atomic and
blocking APIs are not appropriate, so it should be possible for users to
handle these things in their own way.)
There are some limitations, which should not be too hard to live with. For
atomic/blocking chains, registration and unregistration must always be done in
a process context since the chain is protected by a mutex/rwsem. Also, a
callout routine for a non-raw chain must not try to register or unregister
entries on its own chain. (This did happen in a couple of places and the code
had to be changed to avoid it.)
Since atomic chains may be called from within an NMI handler, they cannot use
spinlocks for synchronization. Instead we use RCU. The overhead falls almost
entirely in the unregister routine, which is okay since unregistration is much
less frequent that calling a chain.
Here is the list of chains that we adjusted and their classifications. None
of them use the raw API, so for the moment it is only a placeholder.
ATOMIC CHAINS
-------------
arch/i386/kernel/traps.c: i386die_chain
arch/ia64/kernel/traps.c: ia64die_chain
arch/powerpc/kernel/traps.c: powerpc_die_chain
arch/sparc64/kernel/traps.c: sparc64die_chain
arch/x86_64/kernel/traps.c: die_chain
drivers/char/ipmi/ipmi_si_intf.c: xaction_notifier_list
kernel/panic.c: panic_notifier_list
kernel/profile.c: task_free_notifier
net/bluetooth/hci_core.c: hci_notifier
net/ipv4/netfilter/ip_conntrack_core.c: ip_conntrack_chain
net/ipv4/netfilter/ip_conntrack_core.c: ip_conntrack_expect_chain
net/ipv6/addrconf.c: inet6addr_chain
net/netfilter/nf_conntrack_core.c: nf_conntrack_chain
net/netfilter/nf_conntrack_core.c: nf_conntrack_expect_chain
net/netlink/af_netlink.c: netlink_chain
BLOCKING CHAINS
---------------
arch/powerpc/platforms/pseries/reconfig.c: pSeries_reconfig_chain
arch/s390/kernel/process.c: idle_chain
arch/x86_64/kernel/process.c idle_notifier
drivers/base/memory.c: memory_chain
drivers/cpufreq/cpufreq.c cpufreq_policy_notifier_list
drivers/cpufreq/cpufreq.c cpufreq_transition_notifier_list
drivers/macintosh/adb.c: adb_client_list
drivers/macintosh/via-pmu.c sleep_notifier_list
drivers/macintosh/via-pmu68k.c sleep_notifier_list
drivers/macintosh/windfarm_core.c wf_client_list
drivers/usb/core/notify.c usb_notifier_list
drivers/video/fbmem.c fb_notifier_list
kernel/cpu.c cpu_chain
kernel/module.c module_notify_list
kernel/profile.c munmap_notifier
kernel/profile.c task_exit_notifier
kernel/sys.c reboot_notifier_list
net/core/dev.c netdev_chain
net/decnet/dn_dev.c: dnaddr_chain
net/ipv4/devinet.c: inetaddr_chain
It's possible that some of these classifications are wrong. If they are,
please let us know or submit a patch to fix them. Note that any chain that
gets called very frequently should be atomic, because the rwsem read-locking
used for blocking chains is very likely to incur cache misses on SMP systems.
(However, if the chain's callout routines may sleep then the chain cannot be
atomic.)
The patch set was written by Alan Stern and Chandra Seetharaman, incorporating
material written by Keith Owens and suggestions from Paul McKenney and Andrew
Morton.
[jes@sgi.com: restructure the notifier chain initialization macros]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Chandra Seetharaman <sekharan@us.ibm.com>
Signed-off-by: Jes Sorensen <jes@sgi.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-03-27 11:16:30 +02:00
|
|
|
static ATOMIC_NOTIFIER_HEAD(inet6addr_chain);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-07-22 23:21:58 +02:00
|
|
|
static struct ipv6_devconf ipv6_devconf __read_mostly = {
|
2005-04-17 00:20:36 +02:00
|
|
|
.forwarding = 0,
|
|
|
|
.hop_limit = IPV6_DEFAULT_HOPLIMIT,
|
|
|
|
.mtu6 = IPV6_MIN_MTU,
|
|
|
|
.accept_ra = 1,
|
|
|
|
.accept_redirects = 1,
|
|
|
|
.autoconf = 1,
|
|
|
|
.force_mld_version = 0,
|
|
|
|
.dad_transmits = 1,
|
|
|
|
.rtr_solicits = MAX_RTR_SOLICITATIONS,
|
|
|
|
.rtr_solicit_interval = RTR_SOLICITATION_INTERVAL,
|
|
|
|
.rtr_solicit_delay = MAX_RTR_SOLICITATION_DELAY,
|
|
|
|
#ifdef CONFIG_IPV6_PRIVACY
|
|
|
|
.use_tempaddr = 0,
|
|
|
|
.temp_valid_lft = TEMP_VALID_LIFETIME,
|
|
|
|
.temp_prefered_lft = TEMP_PREFERRED_LIFETIME,
|
|
|
|
.regen_max_retry = REGEN_MAX_RETRY,
|
|
|
|
.max_desync_factor = MAX_DESYNC_FACTOR,
|
|
|
|
#endif
|
|
|
|
.max_addresses = IPV6_MAX_ADDRESSES,
|
2006-03-21 01:55:08 +01:00
|
|
|
.accept_ra_defrtr = 1,
|
2006-03-21 01:55:26 +01:00
|
|
|
.accept_ra_pinfo = 1,
|
2006-03-21 02:05:30 +01:00
|
|
|
#ifdef CONFIG_IPV6_ROUTER_PREF
|
|
|
|
.accept_ra_rtr_pref = 1,
|
2006-03-21 02:05:47 +01:00
|
|
|
.rtr_probe_interval = 60 * HZ,
|
2006-03-21 02:07:03 +01:00
|
|
|
#ifdef CONFIG_IPV6_ROUTE_INFO
|
|
|
|
.accept_ra_rt_info_max_plen = 0,
|
|
|
|
#endif
|
2006-03-21 02:05:30 +01:00
|
|
|
#endif
|
2006-09-22 23:43:49 +02:00
|
|
|
.proxy_ndp = 0,
|
2007-04-24 23:58:30 +02:00
|
|
|
.accept_source_route = 0, /* we do not accept RH0 by default. */
|
2008-06-28 07:17:11 +02:00
|
|
|
.disable_ipv6 = 0,
|
2008-06-28 07:18:38 +02:00
|
|
|
.accept_dad = 1,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
2006-09-22 23:15:41 +02:00
|
|
|
static struct ipv6_devconf ipv6_devconf_dflt __read_mostly = {
|
2005-04-17 00:20:36 +02:00
|
|
|
.forwarding = 0,
|
|
|
|
.hop_limit = IPV6_DEFAULT_HOPLIMIT,
|
|
|
|
.mtu6 = IPV6_MIN_MTU,
|
|
|
|
.accept_ra = 1,
|
|
|
|
.accept_redirects = 1,
|
|
|
|
.autoconf = 1,
|
|
|
|
.dad_transmits = 1,
|
|
|
|
.rtr_solicits = MAX_RTR_SOLICITATIONS,
|
|
|
|
.rtr_solicit_interval = RTR_SOLICITATION_INTERVAL,
|
|
|
|
.rtr_solicit_delay = MAX_RTR_SOLICITATION_DELAY,
|
|
|
|
#ifdef CONFIG_IPV6_PRIVACY
|
|
|
|
.use_tempaddr = 0,
|
|
|
|
.temp_valid_lft = TEMP_VALID_LIFETIME,
|
|
|
|
.temp_prefered_lft = TEMP_PREFERRED_LIFETIME,
|
|
|
|
.regen_max_retry = REGEN_MAX_RETRY,
|
|
|
|
.max_desync_factor = MAX_DESYNC_FACTOR,
|
|
|
|
#endif
|
|
|
|
.max_addresses = IPV6_MAX_ADDRESSES,
|
2006-03-21 01:55:08 +01:00
|
|
|
.accept_ra_defrtr = 1,
|
2006-03-21 01:55:26 +01:00
|
|
|
.accept_ra_pinfo = 1,
|
2006-03-21 02:05:30 +01:00
|
|
|
#ifdef CONFIG_IPV6_ROUTER_PREF
|
|
|
|
.accept_ra_rtr_pref = 1,
|
2006-03-21 02:05:47 +01:00
|
|
|
.rtr_probe_interval = 60 * HZ,
|
2006-03-21 02:07:03 +01:00
|
|
|
#ifdef CONFIG_IPV6_ROUTE_INFO
|
|
|
|
.accept_ra_rt_info_max_plen = 0,
|
|
|
|
#endif
|
2006-03-21 02:05:30 +01:00
|
|
|
#endif
|
2006-09-22 23:43:49 +02:00
|
|
|
.proxy_ndp = 0,
|
2007-04-24 23:58:30 +02:00
|
|
|
.accept_source_route = 0, /* we do not accept RH0 by default. */
|
2008-06-28 07:17:11 +02:00
|
|
|
.disable_ipv6 = 0,
|
2008-06-28 07:18:38 +02:00
|
|
|
.accept_dad = 1,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
/* IPv6 Wildcard Address and Loopback Address defined by RFC2553 */
|
|
|
|
const struct in6_addr in6addr_any = IN6ADDR_ANY_INIT;
|
|
|
|
const struct in6_addr in6addr_loopback = IN6ADDR_LOOPBACK_INIT;
|
2008-04-10 08:42:11 +02:00
|
|
|
const struct in6_addr in6addr_linklocal_allnodes = IN6ADDR_LINKLOCAL_ALLNODES_INIT;
|
|
|
|
const struct in6_addr in6addr_linklocal_allrouters = IN6ADDR_LINKLOCAL_ALLROUTERS_INIT;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-10-10 11:53:43 +02:00
|
|
|
/* Check if a valid qdisc is available */
|
2008-07-09 08:01:27 +02:00
|
|
|
static inline bool addrconf_qdisc_ok(const struct net_device *dev)
|
2007-10-10 11:53:43 +02:00
|
|
|
{
|
2008-07-09 08:01:27 +02:00
|
|
|
return !qdisc_tx_is_noop(dev);
|
2007-10-10 11:53:43 +02:00
|
|
|
}
|
|
|
|
|
2008-05-12 18:16:24 +02:00
|
|
|
/* Check if a route is valid prefix route */
|
|
|
|
static inline int addrconf_is_prefix_route(const struct rt6_info *rt)
|
|
|
|
{
|
|
|
|
return ((rt->rt6i_flags & (RTF_GATEWAY | RTF_DEFAULT)) == 0);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static void addrconf_del_timer(struct inet6_ifaddr *ifp)
|
|
|
|
{
|
|
|
|
if (del_timer(&ifp->timer))
|
|
|
|
__in6_ifa_put(ifp);
|
|
|
|
}
|
|
|
|
|
|
|
|
enum addrconf_timer_t
|
|
|
|
{
|
|
|
|
AC_NONE,
|
|
|
|
AC_DAD,
|
|
|
|
AC_RS,
|
|
|
|
};
|
|
|
|
|
|
|
|
static void addrconf_mod_timer(struct inet6_ifaddr *ifp,
|
|
|
|
enum addrconf_timer_t what,
|
|
|
|
unsigned long when)
|
|
|
|
{
|
|
|
|
if (!del_timer(&ifp->timer))
|
|
|
|
in6_ifa_hold(ifp);
|
|
|
|
|
|
|
|
switch (what) {
|
|
|
|
case AC_DAD:
|
|
|
|
ifp->timer.function = addrconf_dad_timer;
|
|
|
|
break;
|
|
|
|
case AC_RS:
|
|
|
|
ifp->timer.function = addrconf_rs_timer;
|
|
|
|
break;
|
|
|
|
default:;
|
|
|
|
}
|
|
|
|
ifp->timer.expires = jiffies + when;
|
|
|
|
add_timer(&ifp->timer);
|
|
|
|
}
|
|
|
|
|
2007-04-25 06:54:09 +02:00
|
|
|
static int snmp6_alloc_dev(struct inet6_dev *idev)
|
|
|
|
{
|
|
|
|
if (snmp_mib_init((void **)idev->stats.ipv6,
|
2008-01-24 07:31:45 +01:00
|
|
|
sizeof(struct ipstats_mib)) < 0)
|
2007-04-25 06:54:09 +02:00
|
|
|
goto err_ip;
|
|
|
|
if (snmp_mib_init((void **)idev->stats.icmpv6,
|
2008-01-24 07:31:45 +01:00
|
|
|
sizeof(struct icmpv6_mib)) < 0)
|
2007-04-25 06:54:09 +02:00
|
|
|
goto err_icmp;
|
2007-09-17 01:52:35 +02:00
|
|
|
if (snmp_mib_init((void **)idev->stats.icmpv6msg,
|
2008-01-24 07:31:45 +01:00
|
|
|
sizeof(struct icmpv6msg_mib)) < 0)
|
2007-09-17 01:52:35 +02:00
|
|
|
goto err_icmpmsg;
|
2007-04-25 06:54:09 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
2007-09-17 01:52:35 +02:00
|
|
|
err_icmpmsg:
|
|
|
|
snmp_mib_free((void **)idev->stats.icmpv6);
|
2007-04-25 06:54:09 +02:00
|
|
|
err_icmp:
|
|
|
|
snmp_mib_free((void **)idev->stats.ipv6);
|
|
|
|
err_ip:
|
2007-10-18 06:25:32 +02:00
|
|
|
return -ENOMEM;
|
2007-04-25 06:54:09 +02:00
|
|
|
}
|
|
|
|
|
2007-10-18 06:23:43 +02:00
|
|
|
static void snmp6_free_dev(struct inet6_dev *idev)
|
2007-04-25 06:54:09 +02:00
|
|
|
{
|
2007-09-17 01:52:35 +02:00
|
|
|
snmp_mib_free((void **)idev->stats.icmpv6msg);
|
2007-04-25 06:54:09 +02:00
|
|
|
snmp_mib_free((void **)idev->stats.icmpv6);
|
|
|
|
snmp_mib_free((void **)idev->stats.ipv6);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* Nobody refers to this device, we may destroy it. */
|
|
|
|
|
2006-09-22 23:44:24 +02:00
|
|
|
static void in6_dev_finish_destroy_rcu(struct rcu_head *head)
|
|
|
|
{
|
|
|
|
struct inet6_dev *idev = container_of(head, struct inet6_dev, rcu);
|
|
|
|
kfree(idev);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
void in6_dev_finish_destroy(struct inet6_dev *idev)
|
|
|
|
{
|
|
|
|
struct net_device *dev = idev->dev;
|
2008-07-26 06:43:18 +02:00
|
|
|
|
|
|
|
WARN_ON(idev->addr_list != NULL);
|
|
|
|
WARN_ON(idev->mc_list != NULL);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
#ifdef NET_REFCNT_DEBUG
|
|
|
|
printk(KERN_DEBUG "in6_dev_finish_destroy: %s\n", dev ? dev->name : "NIL");
|
|
|
|
#endif
|
|
|
|
dev_put(dev);
|
|
|
|
if (!idev->dead) {
|
|
|
|
printk("Freeing alive inet6 device %p\n", idev);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
snmp6_free_dev(idev);
|
2006-09-22 23:44:24 +02:00
|
|
|
call_rcu(&idev->rcu, in6_dev_finish_destroy_rcu);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-02-22 14:05:40 +01:00
|
|
|
EXPORT_SYMBOL(in6_dev_finish_destroy);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static struct inet6_dev * ipv6_add_dev(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct inet6_dev *ndev;
|
|
|
|
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
|
|
|
if (dev->mtu < IPV6_MIN_MTU)
|
|
|
|
return NULL;
|
|
|
|
|
2007-02-09 15:24:49 +01:00
|
|
|
ndev = kzalloc(sizeof(struct inet6_dev), GFP_KERNEL);
|
2006-03-21 08:01:47 +01:00
|
|
|
|
2007-02-09 15:24:49 +01:00
|
|
|
if (ndev == NULL)
|
|
|
|
return NULL;
|
2006-03-21 08:01:47 +01:00
|
|
|
|
|
|
|
rwlock_init(&ndev->lock);
|
|
|
|
ndev->dev = dev;
|
2008-03-25 13:47:49 +01:00
|
|
|
memcpy(&ndev->cnf, dev_net(dev)->ipv6.devconf_dflt, sizeof(ndev->cnf));
|
2006-03-21 08:01:47 +01:00
|
|
|
ndev->cnf.mtu6 = dev->mtu;
|
|
|
|
ndev->cnf.sysctl = NULL;
|
|
|
|
ndev->nd_parms = neigh_parms_alloc(dev, &nd_tbl);
|
|
|
|
if (ndev->nd_parms == NULL) {
|
|
|
|
kfree(ndev);
|
|
|
|
return NULL;
|
|
|
|
}
|
2008-06-20 01:15:47 +02:00
|
|
|
if (ndev->cnf.forwarding)
|
|
|
|
dev_disable_lro(dev);
|
2006-03-21 08:01:47 +01:00
|
|
|
/* We refer to the device */
|
|
|
|
dev_hold(dev);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-03-21 08:01:47 +01:00
|
|
|
if (snmp6_alloc_dev(ndev) < 0) {
|
|
|
|
ADBG((KERN_WARNING
|
|
|
|
"%s(): cannot allocate memory for statistics; dev=%s.\n",
|
2008-03-06 05:47:47 +01:00
|
|
|
__func__, dev->name));
|
2006-03-21 08:01:47 +01:00
|
|
|
neigh_parms_release(&nd_tbl, ndev->nd_parms);
|
|
|
|
ndev->dead = 1;
|
|
|
|
in6_dev_finish_destroy(ndev);
|
|
|
|
return NULL;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-03-21 08:01:47 +01:00
|
|
|
if (snmp6_register_dev(ndev) < 0) {
|
|
|
|
ADBG((KERN_WARNING
|
|
|
|
"%s(): cannot create /proc/net/dev_snmp6/%s\n",
|
2008-03-06 05:47:47 +01:00
|
|
|
__func__, dev->name));
|
2006-03-21 08:01:47 +01:00
|
|
|
neigh_parms_release(&nd_tbl, ndev->nd_parms);
|
|
|
|
ndev->dead = 1;
|
|
|
|
in6_dev_finish_destroy(ndev);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* One reference from device. We must do this before
|
|
|
|
* we invoke __ipv6_regen_rndid().
|
|
|
|
*/
|
|
|
|
in6_dev_hold(ndev);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-06-28 07:18:38 +02:00
|
|
|
if (dev->flags & (IFF_NOARP | IFF_LOOPBACK))
|
|
|
|
ndev->cnf.accept_dad = -1;
|
|
|
|
|
2008-04-14 08:42:18 +02:00
|
|
|
#if defined(CONFIG_IPV6_SIT) || defined(CONFIG_IPV6_SIT_MODULE)
|
|
|
|
if (dev->type == ARPHRD_SIT && (dev->priv_flags & IFF_ISATAP)) {
|
|
|
|
printk(KERN_INFO
|
|
|
|
"%s: Disabled Multicast RS\n",
|
|
|
|
dev->name);
|
|
|
|
ndev->cnf.rtr_solicits = 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
#ifdef CONFIG_IPV6_PRIVACY
|
2008-01-24 06:20:07 +01:00
|
|
|
setup_timer(&ndev->regen_timer, ipv6_regen_rndid, (unsigned long)ndev);
|
2006-03-21 08:01:47 +01:00
|
|
|
if ((dev->flags&IFF_LOOPBACK) ||
|
|
|
|
dev->type == ARPHRD_TUNNEL ||
|
2008-04-14 08:47:11 +02:00
|
|
|
dev->type == ARPHRD_TUNNEL6 ||
|
2006-10-10 23:49:53 +02:00
|
|
|
dev->type == ARPHRD_SIT ||
|
|
|
|
dev->type == ARPHRD_NONE) {
|
2006-03-21 08:01:47 +01:00
|
|
|
printk(KERN_INFO
|
|
|
|
"%s: Disabled Privacy Extensions\n",
|
|
|
|
dev->name);
|
|
|
|
ndev->cnf.use_tempaddr = -1;
|
|
|
|
} else {
|
|
|
|
in6_dev_hold(ndev);
|
|
|
|
ipv6_regen_rndid((unsigned long) ndev);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
#endif
|
|
|
|
|
2007-10-10 11:53:43 +02:00
|
|
|
if (netif_running(dev) && addrconf_qdisc_ok(dev))
|
2007-03-27 23:31:52 +02:00
|
|
|
ndev->if_flags |= IF_READY;
|
|
|
|
|
2006-03-21 08:01:47 +01:00
|
|
|
ipv6_mc_init_dev(ndev);
|
|
|
|
ndev->tstamp = jiffies;
|
2007-12-01 14:58:37 +01:00
|
|
|
addrconf_sysctl_register(ndev);
|
2007-01-04 21:31:14 +01:00
|
|
|
/* protected by rtnl_lock */
|
|
|
|
rcu_assign_pointer(dev->ip6_ptr, ndev);
|
2007-01-15 06:48:40 +01:00
|
|
|
|
|
|
|
/* Join all-node multicast group */
|
2008-04-10 08:42:11 +02:00
|
|
|
ipv6_dev_mc_inc(dev, &in6addr_linklocal_allnodes);
|
2007-01-15 06:48:40 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
return ndev;
|
|
|
|
}
|
|
|
|
|
2008-04-14 08:21:16 +02:00
|
|
|
static struct inet6_dev * ipv6_find_idev(struct net_device *dev)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct inet6_dev *idev;
|
|
|
|
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
|
|
|
if ((idev = __in6_dev_get(dev)) == NULL) {
|
|
|
|
if ((idev = ipv6_add_dev(dev)) == NULL)
|
|
|
|
return NULL;
|
|
|
|
}
|
2005-12-21 14:57:44 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
if (dev->flags&IFF_UP)
|
|
|
|
ipv6_mc_up(idev);
|
|
|
|
return idev;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_SYSCTL
|
|
|
|
static void dev_forward_change(struct inet6_dev *idev)
|
|
|
|
{
|
|
|
|
struct net_device *dev;
|
|
|
|
struct inet6_ifaddr *ifa;
|
|
|
|
|
|
|
|
if (!idev)
|
|
|
|
return;
|
|
|
|
dev = idev->dev;
|
2008-06-20 01:15:47 +02:00
|
|
|
if (idev->cnf.forwarding)
|
|
|
|
dev_disable_lro(dev);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (dev && (dev->flags & IFF_MULTICAST)) {
|
|
|
|
if (idev->cnf.forwarding)
|
2008-04-10 08:42:11 +02:00
|
|
|
ipv6_dev_mc_inc(dev, &in6addr_linklocal_allrouters);
|
2005-04-17 00:20:36 +02:00
|
|
|
else
|
2008-04-10 08:42:11 +02:00
|
|
|
ipv6_dev_mc_dec(dev, &in6addr_linklocal_allrouters);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
for (ifa=idev->addr_list; ifa; ifa=ifa->if_next) {
|
2007-02-27 00:36:10 +01:00
|
|
|
if (ifa->flags&IFA_F_TENTATIVE)
|
|
|
|
continue;
|
2005-04-17 00:20:36 +02:00
|
|
|
if (idev->cnf.forwarding)
|
|
|
|
addrconf_join_anycast(ifa);
|
|
|
|
else
|
|
|
|
addrconf_leave_anycast(ifa);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-01-11 02:43:50 +01:00
|
|
|
static void addrconf_forward_change(struct net *net, __s32 newf)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct net_device *dev;
|
|
|
|
struct inet6_dev *idev;
|
|
|
|
|
|
|
|
read_lock(&dev_base_lock);
|
2008-01-11 02:42:13 +01:00
|
|
|
for_each_netdev(net, dev) {
|
2006-09-22 23:44:24 +02:00
|
|
|
rcu_read_lock();
|
2005-04-17 00:20:36 +02:00
|
|
|
idev = __in6_dev_get(dev);
|
|
|
|
if (idev) {
|
2008-01-11 02:43:50 +01:00
|
|
|
int changed = (!idev->cnf.forwarding) ^ (!newf);
|
|
|
|
idev->cnf.forwarding = newf;
|
2005-04-17 00:20:36 +02:00
|
|
|
if (changed)
|
|
|
|
dev_forward_change(idev);
|
|
|
|
}
|
2006-09-22 23:44:24 +02:00
|
|
|
rcu_read_unlock();
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
read_unlock(&dev_base_lock);
|
|
|
|
}
|
2007-12-05 10:50:24 +01:00
|
|
|
|
|
|
|
static void addrconf_fixup_forwarding(struct ctl_table *table, int *p, int old)
|
|
|
|
{
|
2008-01-11 02:42:13 +01:00
|
|
|
struct net *net;
|
|
|
|
|
|
|
|
net = (struct net *)table->extra2;
|
2008-01-11 02:43:22 +01:00
|
|
|
if (p == &net->ipv6.devconf_dflt->forwarding)
|
2007-12-05 10:50:24 +01:00
|
|
|
return;
|
|
|
|
|
2008-06-20 01:15:47 +02:00
|
|
|
rtnl_lock();
|
2008-01-11 02:43:50 +01:00
|
|
|
if (p == &net->ipv6.devconf_all->forwarding) {
|
|
|
|
__s32 newf = net->ipv6.devconf_all->forwarding;
|
|
|
|
net->ipv6.devconf_dflt->forwarding = newf;
|
|
|
|
addrconf_forward_change(net, newf);
|
2007-12-05 10:50:24 +01:00
|
|
|
} else if ((!*p) ^ (!old))
|
|
|
|
dev_forward_change((struct inet6_dev *)table->extra1);
|
2008-06-20 01:15:47 +02:00
|
|
|
rtnl_unlock();
|
2007-12-05 10:50:24 +01:00
|
|
|
|
|
|
|
if (*p)
|
2008-03-04 22:47:14 +01:00
|
|
|
rt6_purge_dflt_routers(net);
|
2007-12-05 10:50:24 +01:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Nobody refers to this ifaddr, destroy it */
|
|
|
|
|
|
|
|
void inet6_ifa_finish_destroy(struct inet6_ifaddr *ifp)
|
|
|
|
{
|
2008-07-26 06:43:18 +02:00
|
|
|
WARN_ON(ifp->if_next != NULL);
|
|
|
|
WARN_ON(ifp->lst_next != NULL);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
#ifdef NET_REFCNT_DEBUG
|
|
|
|
printk(KERN_DEBUG "inet6_ifa_finish_destroy\n");
|
|
|
|
#endif
|
|
|
|
|
|
|
|
in6_dev_put(ifp->idev);
|
|
|
|
|
|
|
|
if (del_timer(&ifp->timer))
|
|
|
|
printk("Timer is still running, when freeing ifa=%p\n", ifp);
|
|
|
|
|
|
|
|
if (!ifp->dead) {
|
|
|
|
printk("Freeing alive inet6 address %p\n", ifp);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
dst_release(&ifp->rt->u.dst);
|
|
|
|
|
|
|
|
kfree(ifp);
|
|
|
|
}
|
|
|
|
|
2006-07-11 00:25:51 +02:00
|
|
|
static void
|
|
|
|
ipv6_link_dev_addr(struct inet6_dev *idev, struct inet6_ifaddr *ifp)
|
|
|
|
{
|
|
|
|
struct inet6_ifaddr *ifa, **ifap;
|
2006-07-11 22:05:30 +02:00
|
|
|
int ifp_scope = ipv6_addr_src_scope(&ifp->addr);
|
2006-07-11 00:25:51 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Each device address list is sorted in order of scope -
|
|
|
|
* global before linklocal.
|
|
|
|
*/
|
|
|
|
for (ifap = &idev->addr_list; (ifa = *ifap) != NULL;
|
|
|
|
ifap = &ifa->if_next) {
|
2006-07-11 22:05:30 +02:00
|
|
|
if (ifp_scope >= ipv6_addr_src_scope(&ifa->addr))
|
2006-07-11 00:25:51 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
ifp->if_next = *ifap;
|
|
|
|
*ifap = ifp;
|
|
|
|
}
|
|
|
|
|
2008-04-10 08:42:08 +02:00
|
|
|
/*
|
|
|
|
* Hash function taken from net_alias.c
|
|
|
|
*/
|
|
|
|
static u8 ipv6_addr_hash(const struct in6_addr *addr)
|
|
|
|
{
|
|
|
|
__u32 word;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We perform the hash function over the last 64 bits of the address
|
|
|
|
* This will include the IEEE address token on links that support it.
|
|
|
|
*/
|
|
|
|
|
|
|
|
word = (__force u32)(addr->s6_addr32[2] ^ addr->s6_addr32[3]);
|
|
|
|
word ^= (word >> 16);
|
|
|
|
word ^= (word >> 8);
|
|
|
|
|
|
|
|
return ((word ^ (word >> 4)) & 0x0f);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* On success it returns ifp with increased reference count */
|
|
|
|
|
|
|
|
static struct inet6_ifaddr *
|
|
|
|
ipv6_add_addr(struct inet6_dev *idev, const struct in6_addr *addr, int pfxlen,
|
2005-06-19 07:55:31 +02:00
|
|
|
int scope, u32 flags)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct inet6_ifaddr *ifa = NULL;
|
|
|
|
struct rt6_info *rt;
|
|
|
|
int hash;
|
|
|
|
int err = 0;
|
2008-06-25 09:26:47 +02:00
|
|
|
int addr_type = ipv6_addr_type(addr);
|
|
|
|
|
|
|
|
if (addr_type == IPV6_ADDR_ANY ||
|
|
|
|
addr_type & IPV6_ADDR_MULTICAST ||
|
|
|
|
(!(idev->dev->flags & IFF_LOOPBACK) &&
|
|
|
|
addr_type & IPV6_ADDR_LOOPBACK))
|
|
|
|
return ERR_PTR(-EADDRNOTAVAIL);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-09-22 23:44:24 +02:00
|
|
|
rcu_read_lock_bh();
|
2005-04-17 00:20:36 +02:00
|
|
|
if (idev->dead) {
|
|
|
|
err = -ENODEV; /*XXX*/
|
|
|
|
goto out2;
|
|
|
|
}
|
|
|
|
|
|
|
|
write_lock(&addrconf_hash_lock);
|
|
|
|
|
|
|
|
/* Ignore adding duplicate addresses on an interface */
|
2008-03-25 13:47:49 +01:00
|
|
|
if (ipv6_chk_same_addr(dev_net(idev->dev), addr, idev->dev)) {
|
2005-04-17 00:20:36 +02:00
|
|
|
ADBG(("ipv6_add_addr: already assigned\n"));
|
|
|
|
err = -EEXIST;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2006-03-21 08:01:47 +01:00
|
|
|
ifa = kzalloc(sizeof(struct inet6_ifaddr), GFP_ATOMIC);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (ifa == NULL) {
|
|
|
|
ADBG(("ipv6_add_addr: malloc failed\n"));
|
|
|
|
err = -ENOBUFS;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
rt = addrconf_dst_alloc(idev, addr, 0);
|
|
|
|
if (IS_ERR(rt)) {
|
|
|
|
err = PTR_ERR(rt);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
ipv6_addr_copy(&ifa->addr, addr);
|
|
|
|
|
|
|
|
spin_lock_init(&ifa->lock);
|
|
|
|
init_timer(&ifa->timer);
|
|
|
|
ifa->timer.data = (unsigned long) ifa;
|
|
|
|
ifa->scope = scope;
|
|
|
|
ifa->prefix_len = pfxlen;
|
|
|
|
ifa->flags = flags | IFA_F_TENTATIVE;
|
|
|
|
ifa->cstamp = ifa->tstamp = jiffies;
|
|
|
|
|
2006-08-29 11:43:49 +02:00
|
|
|
ifa->rt = rt;
|
|
|
|
|
2007-04-26 02:08:10 +02:00
|
|
|
/*
|
|
|
|
* part one of RFC 4429, section 3.3
|
|
|
|
* We should not configure an address as
|
|
|
|
* optimistic if we do not yet know the link
|
|
|
|
* layer address of our nexhop router
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (rt->rt6i_nexthop == NULL)
|
|
|
|
ifa->flags &= ~IFA_F_OPTIMISTIC;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
ifa->idev = idev;
|
|
|
|
in6_dev_hold(idev);
|
|
|
|
/* For caller */
|
|
|
|
in6_ifa_hold(ifa);
|
|
|
|
|
|
|
|
/* Add to big hash table */
|
|
|
|
hash = ipv6_addr_hash(addr);
|
|
|
|
|
|
|
|
ifa->lst_next = inet6_addr_lst[hash];
|
|
|
|
inet6_addr_lst[hash] = ifa;
|
|
|
|
in6_ifa_hold(ifa);
|
|
|
|
write_unlock(&addrconf_hash_lock);
|
|
|
|
|
|
|
|
write_lock(&idev->lock);
|
|
|
|
/* Add to inet6_dev unicast addr list. */
|
2006-07-11 00:25:51 +02:00
|
|
|
ipv6_link_dev_addr(idev, ifa);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
#ifdef CONFIG_IPV6_PRIVACY
|
|
|
|
if (ifa->flags&IFA_F_TEMPORARY) {
|
|
|
|
ifa->tmp_next = idev->tempaddr_list;
|
|
|
|
idev->tempaddr_list = ifa;
|
|
|
|
in6_ifa_hold(ifa);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
in6_ifa_hold(ifa);
|
|
|
|
write_unlock(&idev->lock);
|
|
|
|
out2:
|
2006-09-22 23:44:24 +02:00
|
|
|
rcu_read_unlock_bh();
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-04-20 07:27:09 +02:00
|
|
|
if (likely(err == 0))
|
[PATCH] Notifier chain update: API changes
The kernel's implementation of notifier chains is unsafe. There is no
protection against entries being added to or removed from a chain while the
chain is in use. The issues were discussed in this thread:
http://marc.theaimsgroup.com/?l=linux-kernel&m=113018709002036&w=2
We noticed that notifier chains in the kernel fall into two basic usage
classes:
"Blocking" chains are always called from a process context
and the callout routines are allowed to sleep;
"Atomic" chains can be called from an atomic context and
the callout routines are not allowed to sleep.
We decided to codify this distinction and make it part of the API. Therefore
this set of patches introduces three new, parallel APIs: one for blocking
notifiers, one for atomic notifiers, and one for "raw" notifiers (which is
really just the old API under a new name). New kinds of data structures are
used for the heads of the chains, and new routines are defined for
registration, unregistration, and calling a chain. The three APIs are
explained in include/linux/notifier.h and their implementation is in
kernel/sys.c.
With atomic and blocking chains, the implementation guarantees that the chain
links will not be corrupted and that chain callers will not get messed up by
entries being added or removed. For raw chains the implementation provides no
guarantees at all; users of this API must provide their own protections. (The
idea was that situations may come up where the assumptions of the atomic and
blocking APIs are not appropriate, so it should be possible for users to
handle these things in their own way.)
There are some limitations, which should not be too hard to live with. For
atomic/blocking chains, registration and unregistration must always be done in
a process context since the chain is protected by a mutex/rwsem. Also, a
callout routine for a non-raw chain must not try to register or unregister
entries on its own chain. (This did happen in a couple of places and the code
had to be changed to avoid it.)
Since atomic chains may be called from within an NMI handler, they cannot use
spinlocks for synchronization. Instead we use RCU. The overhead falls almost
entirely in the unregister routine, which is okay since unregistration is much
less frequent that calling a chain.
Here is the list of chains that we adjusted and their classifications. None
of them use the raw API, so for the moment it is only a placeholder.
ATOMIC CHAINS
-------------
arch/i386/kernel/traps.c: i386die_chain
arch/ia64/kernel/traps.c: ia64die_chain
arch/powerpc/kernel/traps.c: powerpc_die_chain
arch/sparc64/kernel/traps.c: sparc64die_chain
arch/x86_64/kernel/traps.c: die_chain
drivers/char/ipmi/ipmi_si_intf.c: xaction_notifier_list
kernel/panic.c: panic_notifier_list
kernel/profile.c: task_free_notifier
net/bluetooth/hci_core.c: hci_notifier
net/ipv4/netfilter/ip_conntrack_core.c: ip_conntrack_chain
net/ipv4/netfilter/ip_conntrack_core.c: ip_conntrack_expect_chain
net/ipv6/addrconf.c: inet6addr_chain
net/netfilter/nf_conntrack_core.c: nf_conntrack_chain
net/netfilter/nf_conntrack_core.c: nf_conntrack_expect_chain
net/netlink/af_netlink.c: netlink_chain
BLOCKING CHAINS
---------------
arch/powerpc/platforms/pseries/reconfig.c: pSeries_reconfig_chain
arch/s390/kernel/process.c: idle_chain
arch/x86_64/kernel/process.c idle_notifier
drivers/base/memory.c: memory_chain
drivers/cpufreq/cpufreq.c cpufreq_policy_notifier_list
drivers/cpufreq/cpufreq.c cpufreq_transition_notifier_list
drivers/macintosh/adb.c: adb_client_list
drivers/macintosh/via-pmu.c sleep_notifier_list
drivers/macintosh/via-pmu68k.c sleep_notifier_list
drivers/macintosh/windfarm_core.c wf_client_list
drivers/usb/core/notify.c usb_notifier_list
drivers/video/fbmem.c fb_notifier_list
kernel/cpu.c cpu_chain
kernel/module.c module_notify_list
kernel/profile.c munmap_notifier
kernel/profile.c task_exit_notifier
kernel/sys.c reboot_notifier_list
net/core/dev.c netdev_chain
net/decnet/dn_dev.c: dnaddr_chain
net/ipv4/devinet.c: inetaddr_chain
It's possible that some of these classifications are wrong. If they are,
please let us know or submit a patch to fix them. Note that any chain that
gets called very frequently should be atomic, because the rwsem read-locking
used for blocking chains is very likely to incur cache misses on SMP systems.
(However, if the chain's callout routines may sleep then the chain cannot be
atomic.)
The patch set was written by Alan Stern and Chandra Seetharaman, incorporating
material written by Keith Owens and suggestions from Paul McKenney and Andrew
Morton.
[jes@sgi.com: restructure the notifier chain initialization macros]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Chandra Seetharaman <sekharan@us.ibm.com>
Signed-off-by: Jes Sorensen <jes@sgi.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-03-27 11:16:30 +02:00
|
|
|
atomic_notifier_call_chain(&inet6addr_chain, NETDEV_UP, ifa);
|
2005-04-17 00:20:36 +02:00
|
|
|
else {
|
|
|
|
kfree(ifa);
|
|
|
|
ifa = ERR_PTR(err);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ifa;
|
|
|
|
out:
|
|
|
|
write_unlock(&addrconf_hash_lock);
|
|
|
|
goto out2;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This function wants to get referenced ifp and releases it before return */
|
|
|
|
|
|
|
|
static void ipv6_del_addr(struct inet6_ifaddr *ifp)
|
|
|
|
{
|
|
|
|
struct inet6_ifaddr *ifa, **ifap;
|
|
|
|
struct inet6_dev *idev = ifp->idev;
|
|
|
|
int hash;
|
|
|
|
int deleted = 0, onlink = 0;
|
|
|
|
unsigned long expires = jiffies;
|
|
|
|
|
|
|
|
hash = ipv6_addr_hash(&ifp->addr);
|
|
|
|
|
|
|
|
ifp->dead = 1;
|
|
|
|
|
|
|
|
write_lock_bh(&addrconf_hash_lock);
|
|
|
|
for (ifap = &inet6_addr_lst[hash]; (ifa=*ifap) != NULL;
|
|
|
|
ifap = &ifa->lst_next) {
|
|
|
|
if (ifa == ifp) {
|
|
|
|
*ifap = ifa->lst_next;
|
|
|
|
__in6_ifa_put(ifp);
|
|
|
|
ifa->lst_next = NULL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
write_unlock_bh(&addrconf_hash_lock);
|
|
|
|
|
|
|
|
write_lock_bh(&idev->lock);
|
|
|
|
#ifdef CONFIG_IPV6_PRIVACY
|
|
|
|
if (ifp->flags&IFA_F_TEMPORARY) {
|
|
|
|
for (ifap = &idev->tempaddr_list; (ifa=*ifap) != NULL;
|
|
|
|
ifap = &ifa->tmp_next) {
|
|
|
|
if (ifa == ifp) {
|
|
|
|
*ifap = ifa->tmp_next;
|
|
|
|
if (ifp->ifpub) {
|
|
|
|
in6_ifa_put(ifp->ifpub);
|
|
|
|
ifp->ifpub = NULL;
|
|
|
|
}
|
|
|
|
__in6_ifa_put(ifp);
|
|
|
|
ifa->tmp_next = NULL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-12-22 03:47:24 +01:00
|
|
|
for (ifap = &idev->addr_list; (ifa=*ifap) != NULL;) {
|
2005-04-17 00:20:36 +02:00
|
|
|
if (ifa == ifp) {
|
|
|
|
*ifap = ifa->if_next;
|
|
|
|
__in6_ifa_put(ifp);
|
|
|
|
ifa->if_next = NULL;
|
|
|
|
if (!(ifp->flags & IFA_F_PERMANENT) || onlink > 0)
|
|
|
|
break;
|
|
|
|
deleted = 1;
|
2005-12-22 03:47:24 +01:00
|
|
|
continue;
|
2005-04-17 00:20:36 +02:00
|
|
|
} else if (ifp->flags & IFA_F_PERMANENT) {
|
|
|
|
if (ipv6_prefix_equal(&ifa->addr, &ifp->addr,
|
|
|
|
ifp->prefix_len)) {
|
|
|
|
if (ifa->flags & IFA_F_PERMANENT) {
|
|
|
|
onlink = 1;
|
|
|
|
if (deleted)
|
|
|
|
break;
|
|
|
|
} else {
|
|
|
|
unsigned long lifetime;
|
|
|
|
|
|
|
|
if (!onlink)
|
|
|
|
onlink = -1;
|
|
|
|
|
|
|
|
spin_lock(&ifa->lock);
|
2008-05-27 10:37:49 +02:00
|
|
|
|
|
|
|
lifetime = addrconf_timeout_fixup(ifa->valid_lft, HZ);
|
|
|
|
/*
|
|
|
|
* Note: Because this address is
|
|
|
|
* not permanent, lifetime <
|
|
|
|
* LONG_MAX / HZ here.
|
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
if (time_before(expires,
|
|
|
|
ifa->tstamp + lifetime * HZ))
|
|
|
|
expires = ifa->tstamp + lifetime * HZ;
|
|
|
|
spin_unlock(&ifa->lock);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2005-12-22 03:47:24 +01:00
|
|
|
ifap = &ifa->if_next;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
write_unlock_bh(&idev->lock);
|
|
|
|
|
2008-07-09 00:13:31 +02:00
|
|
|
addrconf_del_timer(ifp);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
ipv6_ifa_notify(RTM_DELADDR, ifp);
|
|
|
|
|
[PATCH] Notifier chain update: API changes
The kernel's implementation of notifier chains is unsafe. There is no
protection against entries being added to or removed from a chain while the
chain is in use. The issues were discussed in this thread:
http://marc.theaimsgroup.com/?l=linux-kernel&m=113018709002036&w=2
We noticed that notifier chains in the kernel fall into two basic usage
classes:
"Blocking" chains are always called from a process context
and the callout routines are allowed to sleep;
"Atomic" chains can be called from an atomic context and
the callout routines are not allowed to sleep.
We decided to codify this distinction and make it part of the API. Therefore
this set of patches introduces three new, parallel APIs: one for blocking
notifiers, one for atomic notifiers, and one for "raw" notifiers (which is
really just the old API under a new name). New kinds of data structures are
used for the heads of the chains, and new routines are defined for
registration, unregistration, and calling a chain. The three APIs are
explained in include/linux/notifier.h and their implementation is in
kernel/sys.c.
With atomic and blocking chains, the implementation guarantees that the chain
links will not be corrupted and that chain callers will not get messed up by
entries being added or removed. For raw chains the implementation provides no
guarantees at all; users of this API must provide their own protections. (The
idea was that situations may come up where the assumptions of the atomic and
blocking APIs are not appropriate, so it should be possible for users to
handle these things in their own way.)
There are some limitations, which should not be too hard to live with. For
atomic/blocking chains, registration and unregistration must always be done in
a process context since the chain is protected by a mutex/rwsem. Also, a
callout routine for a non-raw chain must not try to register or unregister
entries on its own chain. (This did happen in a couple of places and the code
had to be changed to avoid it.)
Since atomic chains may be called from within an NMI handler, they cannot use
spinlocks for synchronization. Instead we use RCU. The overhead falls almost
entirely in the unregister routine, which is okay since unregistration is much
less frequent that calling a chain.
Here is the list of chains that we adjusted and their classifications. None
of them use the raw API, so for the moment it is only a placeholder.
ATOMIC CHAINS
-------------
arch/i386/kernel/traps.c: i386die_chain
arch/ia64/kernel/traps.c: ia64die_chain
arch/powerpc/kernel/traps.c: powerpc_die_chain
arch/sparc64/kernel/traps.c: sparc64die_chain
arch/x86_64/kernel/traps.c: die_chain
drivers/char/ipmi/ipmi_si_intf.c: xaction_notifier_list
kernel/panic.c: panic_notifier_list
kernel/profile.c: task_free_notifier
net/bluetooth/hci_core.c: hci_notifier
net/ipv4/netfilter/ip_conntrack_core.c: ip_conntrack_chain
net/ipv4/netfilter/ip_conntrack_core.c: ip_conntrack_expect_chain
net/ipv6/addrconf.c: inet6addr_chain
net/netfilter/nf_conntrack_core.c: nf_conntrack_chain
net/netfilter/nf_conntrack_core.c: nf_conntrack_expect_chain
net/netlink/af_netlink.c: netlink_chain
BLOCKING CHAINS
---------------
arch/powerpc/platforms/pseries/reconfig.c: pSeries_reconfig_chain
arch/s390/kernel/process.c: idle_chain
arch/x86_64/kernel/process.c idle_notifier
drivers/base/memory.c: memory_chain
drivers/cpufreq/cpufreq.c cpufreq_policy_notifier_list
drivers/cpufreq/cpufreq.c cpufreq_transition_notifier_list
drivers/macintosh/adb.c: adb_client_list
drivers/macintosh/via-pmu.c sleep_notifier_list
drivers/macintosh/via-pmu68k.c sleep_notifier_list
drivers/macintosh/windfarm_core.c wf_client_list
drivers/usb/core/notify.c usb_notifier_list
drivers/video/fbmem.c fb_notifier_list
kernel/cpu.c cpu_chain
kernel/module.c module_notify_list
kernel/profile.c munmap_notifier
kernel/profile.c task_exit_notifier
kernel/sys.c reboot_notifier_list
net/core/dev.c netdev_chain
net/decnet/dn_dev.c: dnaddr_chain
net/ipv4/devinet.c: inetaddr_chain
It's possible that some of these classifications are wrong. If they are,
please let us know or submit a patch to fix them. Note that any chain that
gets called very frequently should be atomic, because the rwsem read-locking
used for blocking chains is very likely to incur cache misses on SMP systems.
(However, if the chain's callout routines may sleep then the chain cannot be
atomic.)
The patch set was written by Alan Stern and Chandra Seetharaman, incorporating
material written by Keith Owens and suggestions from Paul McKenney and Andrew
Morton.
[jes@sgi.com: restructure the notifier chain initialization macros]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Chandra Seetharaman <sekharan@us.ibm.com>
Signed-off-by: Jes Sorensen <jes@sgi.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-03-27 11:16:30 +02:00
|
|
|
atomic_notifier_call_chain(&inet6addr_chain, NETDEV_DOWN, ifp);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Purge or update corresponding prefix
|
|
|
|
*
|
|
|
|
* 1) we don't purge prefix here if address was not permanent.
|
|
|
|
* prefix is managed by its own lifetime.
|
|
|
|
* 2) if there're no addresses, delete prefix.
|
|
|
|
* 3) if there're still other permanent address(es),
|
|
|
|
* corresponding prefix is still permanent.
|
|
|
|
* 4) otherwise, update prefix lifetime to the
|
|
|
|
* longest valid lifetime among the corresponding
|
|
|
|
* addresses on the device.
|
|
|
|
* Note: subsequent RA will update lifetime.
|
|
|
|
*
|
|
|
|
* --yoshfuji
|
|
|
|
*/
|
|
|
|
if ((ifp->flags & IFA_F_PERMANENT) && onlink < 1) {
|
|
|
|
struct in6_addr prefix;
|
|
|
|
struct rt6_info *rt;
|
2008-03-25 13:47:49 +01:00
|
|
|
struct net *net = dev_net(ifp->idev->dev);
|
2005-04-17 00:20:36 +02:00
|
|
|
ipv6_addr_prefix(&prefix, &ifp->addr, ifp->prefix_len);
|
2008-03-05 19:47:47 +01:00
|
|
|
rt = rt6_lookup(net, &prefix, NULL, ifp->idev->dev->ifindex, 1);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-05-12 18:16:24 +02:00
|
|
|
if (rt && addrconf_is_prefix_route(rt)) {
|
2005-04-17 00:20:36 +02:00
|
|
|
if (onlink == 0) {
|
2006-08-22 09:00:21 +02:00
|
|
|
ip6_del_rt(rt);
|
2005-04-17 00:20:36 +02:00
|
|
|
rt = NULL;
|
|
|
|
} else if (!(rt->rt6i_flags & RTF_EXPIRES)) {
|
|
|
|
rt->rt6i_expires = expires;
|
|
|
|
rt->rt6i_flags |= RTF_EXPIRES;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
dst_release(&rt->u.dst);
|
|
|
|
}
|
|
|
|
|
|
|
|
in6_ifa_put(ifp);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_IPV6_PRIVACY
|
|
|
|
static int ipv6_create_tempaddr(struct inet6_ifaddr *ifp, struct inet6_ifaddr *ift)
|
|
|
|
{
|
|
|
|
struct inet6_dev *idev = ifp->idev;
|
|
|
|
struct in6_addr addr, *tmpaddr;
|
|
|
|
unsigned long tmp_prefered_lft, tmp_valid_lft, tmp_cstamp, tmp_tstamp;
|
2008-04-02 09:01:35 +02:00
|
|
|
unsigned long regen_advance;
|
2005-04-17 00:20:36 +02:00
|
|
|
int tmp_plen;
|
|
|
|
int ret = 0;
|
|
|
|
int max_addresses;
|
2007-04-26 02:08:10 +02:00
|
|
|
u32 addr_flags;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
write_lock(&idev->lock);
|
|
|
|
if (ift) {
|
|
|
|
spin_lock_bh(&ift->lock);
|
|
|
|
memcpy(&addr.s6_addr[8], &ift->addr.s6_addr[8], 8);
|
|
|
|
spin_unlock_bh(&ift->lock);
|
|
|
|
tmpaddr = &addr;
|
|
|
|
} else {
|
|
|
|
tmpaddr = NULL;
|
|
|
|
}
|
|
|
|
retry:
|
|
|
|
in6_dev_hold(idev);
|
|
|
|
if (idev->cnf.use_tempaddr <= 0) {
|
|
|
|
write_unlock(&idev->lock);
|
|
|
|
printk(KERN_INFO
|
|
|
|
"ipv6_create_tempaddr(): use_tempaddr is disabled.\n");
|
|
|
|
in6_dev_put(idev);
|
|
|
|
ret = -1;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
spin_lock_bh(&ifp->lock);
|
|
|
|
if (ifp->regen_count++ >= idev->cnf.regen_max_retry) {
|
|
|
|
idev->cnf.use_tempaddr = -1; /*XXX*/
|
|
|
|
spin_unlock_bh(&ifp->lock);
|
|
|
|
write_unlock(&idev->lock);
|
|
|
|
printk(KERN_WARNING
|
|
|
|
"ipv6_create_tempaddr(): regeneration time exceeded. disabled temporary address support.\n");
|
|
|
|
in6_dev_put(idev);
|
|
|
|
ret = -1;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
in6_ifa_hold(ifp);
|
|
|
|
memcpy(addr.s6_addr, ifp->addr.s6_addr, 8);
|
|
|
|
if (__ipv6_try_regen_rndid(idev, tmpaddr) < 0) {
|
|
|
|
spin_unlock_bh(&ifp->lock);
|
|
|
|
write_unlock(&idev->lock);
|
|
|
|
printk(KERN_WARNING
|
|
|
|
"ipv6_create_tempaddr(): regeneration of randomized interface id failed.\n");
|
|
|
|
in6_ifa_put(ifp);
|
|
|
|
in6_dev_put(idev);
|
|
|
|
ret = -1;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
memcpy(&addr.s6_addr[8], idev->rndid, 8);
|
|
|
|
tmp_valid_lft = min_t(__u32,
|
|
|
|
ifp->valid_lft,
|
|
|
|
idev->cnf.temp_valid_lft);
|
2007-02-09 15:24:49 +01:00
|
|
|
tmp_prefered_lft = min_t(__u32,
|
|
|
|
ifp->prefered_lft,
|
2005-04-17 00:20:36 +02:00
|
|
|
idev->cnf.temp_prefered_lft - desync_factor / HZ);
|
|
|
|
tmp_plen = ifp->prefix_len;
|
|
|
|
max_addresses = idev->cnf.max_addresses;
|
|
|
|
tmp_cstamp = ifp->cstamp;
|
|
|
|
tmp_tstamp = ifp->tstamp;
|
|
|
|
spin_unlock_bh(&ifp->lock);
|
|
|
|
|
2008-04-02 09:01:35 +02:00
|
|
|
regen_advance = idev->cnf.regen_max_retry *
|
|
|
|
idev->cnf.dad_transmits *
|
|
|
|
idev->nd_parms->retrans_time / HZ;
|
2005-04-17 00:20:36 +02:00
|
|
|
write_unlock(&idev->lock);
|
2007-04-26 02:08:10 +02:00
|
|
|
|
2008-04-02 09:01:35 +02:00
|
|
|
/* A temporary address is created only if this calculated Preferred
|
|
|
|
* Lifetime is greater than REGEN_ADVANCE time units. In particular,
|
|
|
|
* an implementation must not create a temporary address with a zero
|
|
|
|
* Preferred Lifetime.
|
|
|
|
*/
|
|
|
|
if (tmp_prefered_lft <= regen_advance) {
|
|
|
|
in6_ifa_put(ifp);
|
|
|
|
in6_dev_put(idev);
|
|
|
|
ret = -1;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2007-04-26 02:08:10 +02:00
|
|
|
addr_flags = IFA_F_TEMPORARY;
|
|
|
|
/* set in addrconf_prefix_rcv() */
|
|
|
|
if (ifp->flags & IFA_F_OPTIMISTIC)
|
|
|
|
addr_flags |= IFA_F_OPTIMISTIC;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
ift = !max_addresses ||
|
2007-02-09 15:24:49 +01:00
|
|
|
ipv6_count_addresses(idev) < max_addresses ?
|
2005-04-17 00:20:36 +02:00
|
|
|
ipv6_add_addr(idev, &addr, tmp_plen,
|
2007-04-26 02:08:10 +02:00
|
|
|
ipv6_addr_type(&addr)&IPV6_ADDR_SCOPE_MASK,
|
|
|
|
addr_flags) : NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!ift || IS_ERR(ift)) {
|
|
|
|
in6_ifa_put(ifp);
|
|
|
|
in6_dev_put(idev);
|
|
|
|
printk(KERN_INFO
|
|
|
|
"ipv6_create_tempaddr(): retry temporary address regeneration.\n");
|
|
|
|
tmpaddr = &addr;
|
|
|
|
write_lock(&idev->lock);
|
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock_bh(&ift->lock);
|
|
|
|
ift->ifpub = ifp;
|
|
|
|
ift->valid_lft = tmp_valid_lft;
|
|
|
|
ift->prefered_lft = tmp_prefered_lft;
|
|
|
|
ift->cstamp = tmp_cstamp;
|
|
|
|
ift->tstamp = tmp_tstamp;
|
|
|
|
spin_unlock_bh(&ift->lock);
|
|
|
|
|
|
|
|
addrconf_dad_start(ift, 0);
|
|
|
|
in6_ifa_put(ift);
|
|
|
|
in6_dev_put(idev);
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
2005-11-08 18:38:30 +01:00
|
|
|
* Choose an appropriate source address (RFC3484)
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2008-03-02 02:48:21 +01:00
|
|
|
enum {
|
|
|
|
IPV6_SADDR_RULE_INIT = 0,
|
|
|
|
IPV6_SADDR_RULE_LOCAL,
|
|
|
|
IPV6_SADDR_RULE_SCOPE,
|
|
|
|
IPV6_SADDR_RULE_PREFERRED,
|
|
|
|
#ifdef CONFIG_IPV6_MIP6
|
|
|
|
IPV6_SADDR_RULE_HOA,
|
|
|
|
#endif
|
|
|
|
IPV6_SADDR_RULE_OIF,
|
|
|
|
IPV6_SADDR_RULE_LABEL,
|
|
|
|
#ifdef CONFIG_IPV6_PRIVACY
|
|
|
|
IPV6_SADDR_RULE_PRIVACY,
|
|
|
|
#endif
|
|
|
|
IPV6_SADDR_RULE_ORCHID,
|
|
|
|
IPV6_SADDR_RULE_PREFIX,
|
|
|
|
IPV6_SADDR_RULE_MAX
|
|
|
|
};
|
|
|
|
|
2005-11-08 18:38:30 +01:00
|
|
|
struct ipv6_saddr_score {
|
2008-03-02 02:48:21 +01:00
|
|
|
int rule;
|
|
|
|
int addr_type;
|
|
|
|
struct inet6_ifaddr *ifa;
|
|
|
|
DECLARE_BITMAP(scorebits, IPV6_SADDR_RULE_MAX);
|
|
|
|
int scopedist;
|
|
|
|
int matchlen;
|
2005-11-08 18:38:30 +01:00
|
|
|
};
|
|
|
|
|
2008-03-02 02:48:21 +01:00
|
|
|
struct ipv6_saddr_dst {
|
[IPV6]: Make address arguments const.
- net/ipv6/addrconf.c:
ipv6_get_ifaddr(), ipv6_dev_get_saddr()
- net/ipv6/mcast.c:
ipv6_sock_mc_join(), ipv6_sock_mc_drop(),
inet6_mc_check(),
ipv6_dev_mc_inc(), __ipv6_dev_mc_dec(), ipv6_dev_mc_dec(),
ipv6_chk_mcast_addr()
- net/ipv6/route.c:
rt6_lookup(), icmp6_dst_alloc()
- net/ipv6/ip6_output.c:
ip6_nd_hdr()
- net/ipv6/ndisc.c:
ndisc_send_ns(), ndisc_send_rs(), ndisc_send_redirect(),
ndisc_get_neigh(), __ndisc_send()
Signed-off-by: YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
2008-04-10 08:42:10 +02:00
|
|
|
const struct in6_addr *addr;
|
2008-03-02 02:48:21 +01:00
|
|
|
int ifindex;
|
|
|
|
int scope;
|
|
|
|
int label;
|
2008-03-25 01:37:42 +01:00
|
|
|
unsigned int prefs;
|
2008-03-02 02:48:21 +01:00
|
|
|
};
|
2005-11-08 18:38:30 +01:00
|
|
|
|
2007-03-22 20:27:49 +01:00
|
|
|
static inline int ipv6_saddr_preferred(int type)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-11-08 18:38:30 +01:00
|
|
|
if (type & (IPV6_ADDR_MAPPED|IPV6_ADDR_COMPATv4|
|
|
|
|
IPV6_ADDR_LOOPBACK|IPV6_ADDR_RESERVED))
|
|
|
|
return 1;
|
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-05-28 14:51:24 +02:00
|
|
|
static int ipv6_get_saddr_eval(struct net *net,
|
|
|
|
struct ipv6_saddr_score *score,
|
2008-03-02 02:48:21 +01:00
|
|
|
struct ipv6_saddr_dst *dst,
|
|
|
|
int i)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (i <= score->rule) {
|
|
|
|
switch (i) {
|
|
|
|
case IPV6_SADDR_RULE_SCOPE:
|
|
|
|
ret = score->scopedist;
|
|
|
|
break;
|
|
|
|
case IPV6_SADDR_RULE_PREFIX:
|
|
|
|
ret = score->matchlen;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ret = !!test_bit(i, score->scorebits);
|
|
|
|
}
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (i) {
|
|
|
|
case IPV6_SADDR_RULE_INIT:
|
|
|
|
/* Rule 0: remember if hiscore is not ready yet */
|
|
|
|
ret = !!score->ifa;
|
|
|
|
break;
|
|
|
|
case IPV6_SADDR_RULE_LOCAL:
|
|
|
|
/* Rule 1: Prefer same address */
|
|
|
|
ret = ipv6_addr_equal(&score->ifa->addr, dst->addr);
|
|
|
|
break;
|
|
|
|
case IPV6_SADDR_RULE_SCOPE:
|
|
|
|
/* Rule 2: Prefer appropriate scope
|
|
|
|
*
|
|
|
|
* ret
|
|
|
|
* ^
|
|
|
|
* -1 | d 15
|
|
|
|
* ---+--+-+---> scope
|
|
|
|
* |
|
|
|
|
* | d is scope of the destination.
|
|
|
|
* B-d | \
|
|
|
|
* | \ <- smaller scope is better if
|
|
|
|
* B-15 | \ if scope is enough for destinaion.
|
|
|
|
* | ret = B - scope (-1 <= scope >= d <= 15).
|
|
|
|
* d-C-1 | /
|
|
|
|
* |/ <- greater is better
|
|
|
|
* -C / if scope is not enough for destination.
|
|
|
|
* /| ret = scope - C (-1 <= d < scope <= 15).
|
|
|
|
*
|
|
|
|
* d - C - 1 < B -15 (for all -1 <= d <= 15).
|
|
|
|
* C > d + 14 - B >= 15 + 14 - B = 29 - B.
|
|
|
|
* Assume B = 0 and we get C > 29.
|
|
|
|
*/
|
|
|
|
ret = __ipv6_addr_src_scope(score->addr_type);
|
|
|
|
if (ret >= dst->scope)
|
|
|
|
ret = -ret;
|
|
|
|
else
|
|
|
|
ret -= 128; /* 30 is enough */
|
|
|
|
score->scopedist = ret;
|
|
|
|
break;
|
|
|
|
case IPV6_SADDR_RULE_PREFERRED:
|
|
|
|
/* Rule 3: Avoid deprecated and optimistic addresses */
|
|
|
|
ret = ipv6_saddr_preferred(score->addr_type) ||
|
|
|
|
!(score->ifa->flags & (IFA_F_DEPRECATED|IFA_F_OPTIMISTIC));
|
|
|
|
break;
|
|
|
|
#ifdef CONFIG_IPV6_MIP6
|
|
|
|
case IPV6_SADDR_RULE_HOA:
|
2008-03-25 01:37:42 +01:00
|
|
|
{
|
2008-03-02 02:48:21 +01:00
|
|
|
/* Rule 4: Prefer home address */
|
2008-03-25 01:37:42 +01:00
|
|
|
int prefhome = !(dst->prefs & IPV6_PREFER_SRC_COA);
|
|
|
|
ret = !(score->ifa->flags & IFA_F_HOMEADDRESS) ^ prefhome;
|
2008-03-02 02:48:21 +01:00
|
|
|
break;
|
2008-03-25 01:37:42 +01:00
|
|
|
}
|
2008-03-02 02:48:21 +01:00
|
|
|
#endif
|
|
|
|
case IPV6_SADDR_RULE_OIF:
|
|
|
|
/* Rule 5: Prefer outgoing interface */
|
|
|
|
ret = (!dst->ifindex ||
|
|
|
|
dst->ifindex == score->ifa->idev->dev->ifindex);
|
|
|
|
break;
|
|
|
|
case IPV6_SADDR_RULE_LABEL:
|
|
|
|
/* Rule 6: Prefer matching label */
|
2008-05-28 14:51:24 +02:00
|
|
|
ret = ipv6_addr_label(net,
|
|
|
|
&score->ifa->addr, score->addr_type,
|
2008-03-02 02:48:21 +01:00
|
|
|
score->ifa->idev->dev->ifindex) == dst->label;
|
|
|
|
break;
|
|
|
|
#ifdef CONFIG_IPV6_PRIVACY
|
|
|
|
case IPV6_SADDR_RULE_PRIVACY:
|
2008-03-25 01:37:42 +01:00
|
|
|
{
|
2008-03-02 02:48:21 +01:00
|
|
|
/* Rule 7: Prefer public address
|
|
|
|
* Note: prefer temprary address if use_tempaddr >= 2
|
|
|
|
*/
|
2008-03-25 01:37:42 +01:00
|
|
|
int preftmp = dst->prefs & (IPV6_PREFER_SRC_PUBLIC|IPV6_PREFER_SRC_TMP) ?
|
|
|
|
!!(dst->prefs & IPV6_PREFER_SRC_TMP) :
|
|
|
|
score->ifa->idev->cnf.use_tempaddr >= 2;
|
|
|
|
ret = (!(score->ifa->flags & IFA_F_TEMPORARY)) ^ preftmp;
|
2008-03-02 02:48:21 +01:00
|
|
|
break;
|
2008-03-25 01:37:42 +01:00
|
|
|
}
|
2008-03-02 02:48:21 +01:00
|
|
|
#endif
|
|
|
|
case IPV6_SADDR_RULE_ORCHID:
|
|
|
|
/* Rule 8-: Prefer ORCHID vs ORCHID or
|
|
|
|
* non-ORCHID vs non-ORCHID
|
|
|
|
*/
|
|
|
|
ret = !(ipv6_addr_orchid(&score->ifa->addr) ^
|
|
|
|
ipv6_addr_orchid(dst->addr));
|
|
|
|
break;
|
|
|
|
case IPV6_SADDR_RULE_PREFIX:
|
|
|
|
/* Rule 8: Use longest matching prefix */
|
|
|
|
score->matchlen = ret = ipv6_addr_diff(&score->ifa->addr,
|
|
|
|
dst->addr);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ret = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
__set_bit(i, score->scorebits);
|
|
|
|
score->rule = i;
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-08-15 00:33:21 +02:00
|
|
|
int ipv6_dev_get_saddr(struct net *net, struct net_device *dst_dev,
|
[IPV6]: Make address arguments const.
- net/ipv6/addrconf.c:
ipv6_get_ifaddr(), ipv6_dev_get_saddr()
- net/ipv6/mcast.c:
ipv6_sock_mc_join(), ipv6_sock_mc_drop(),
inet6_mc_check(),
ipv6_dev_mc_inc(), __ipv6_dev_mc_dec(), ipv6_dev_mc_dec(),
ipv6_chk_mcast_addr()
- net/ipv6/route.c:
rt6_lookup(), icmp6_dst_alloc()
- net/ipv6/ip6_output.c:
ip6_nd_hdr()
- net/ipv6/ndisc.c:
ndisc_send_ns(), ndisc_send_rs(), ndisc_send_redirect(),
ndisc_get_neigh(), __ndisc_send()
Signed-off-by: YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
2008-04-10 08:42:10 +02:00
|
|
|
const struct in6_addr *daddr, unsigned int prefs,
|
2008-03-25 01:37:42 +01:00
|
|
|
struct in6_addr *saddr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-03-02 02:48:21 +01:00
|
|
|
struct ipv6_saddr_score scores[2],
|
|
|
|
*score = &scores[0], *hiscore = &scores[1];
|
|
|
|
struct ipv6_saddr_dst dst;
|
2005-11-08 18:38:30 +01:00
|
|
|
struct net_device *dev;
|
2008-03-02 02:48:21 +01:00
|
|
|
int dst_type;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-03-02 02:48:21 +01:00
|
|
|
dst_type = __ipv6_addr_type(daddr);
|
|
|
|
dst.addr = daddr;
|
|
|
|
dst.ifindex = dst_dev ? dst_dev->ifindex : 0;
|
|
|
|
dst.scope = __ipv6_addr_src_scope(dst_type);
|
2008-05-28 14:51:24 +02:00
|
|
|
dst.label = ipv6_addr_label(net, daddr, dst_type, dst.ifindex);
|
2008-03-25 01:37:42 +01:00
|
|
|
dst.prefs = prefs;
|
2008-03-02 02:48:21 +01:00
|
|
|
|
|
|
|
hiscore->rule = -1;
|
|
|
|
hiscore->ifa = NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-11-08 18:38:30 +01:00
|
|
|
read_lock(&dev_base_lock);
|
2006-09-22 23:44:24 +02:00
|
|
|
rcu_read_lock();
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-03-05 19:47:47 +01:00
|
|
|
for_each_netdev(net, dev) {
|
2005-11-08 18:38:30 +01:00
|
|
|
struct inet6_dev *idev;
|
|
|
|
|
2008-03-02 02:48:21 +01:00
|
|
|
/* Candidate Source Address (section 4)
|
2005-11-08 18:38:30 +01:00
|
|
|
* - multicast and link-local destination address,
|
|
|
|
* the set of candidate source address MUST only
|
|
|
|
* include addresses assigned to interfaces
|
|
|
|
* belonging to the same link as the outgoing
|
|
|
|
* interface.
|
|
|
|
* (- For site-local destination addresses, the
|
|
|
|
* set of candidate source addresses MUST only
|
|
|
|
* include addresses assigned to interfaces
|
|
|
|
* belonging to the same site as the outgoing
|
|
|
|
* interface.)
|
|
|
|
*/
|
2008-03-02 02:48:21 +01:00
|
|
|
if (((dst_type & IPV6_ADDR_MULTICAST) ||
|
|
|
|
dst.scope <= IPV6_ADDR_SCOPE_LINKLOCAL) &&
|
|
|
|
dst.ifindex && dev->ifindex != dst.ifindex)
|
2005-11-08 18:38:30 +01:00
|
|
|
continue;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
idev = __in6_dev_get(dev);
|
2005-11-08 18:38:30 +01:00
|
|
|
if (!idev)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
read_lock_bh(&idev->lock);
|
2008-03-02 02:48:21 +01:00
|
|
|
for (score->ifa = idev->addr_list; score->ifa; score->ifa = score->ifa->if_next) {
|
|
|
|
int i;
|
2005-11-08 18:38:30 +01:00
|
|
|
|
2008-03-02 02:48:21 +01:00
|
|
|
/*
|
2005-12-21 14:58:01 +01:00
|
|
|
* - Tentative Address (RFC2462 section 5.4)
|
|
|
|
* - A tentative address is not considered
|
|
|
|
* "assigned to an interface" in the traditional
|
2007-04-26 02:08:10 +02:00
|
|
|
* sense, unless it is also flagged as optimistic.
|
2005-12-21 14:58:01 +01:00
|
|
|
* - Candidate Source Address (section 4)
|
2005-11-08 18:38:30 +01:00
|
|
|
* - In any case, anycast addresses, multicast
|
|
|
|
* addresses, and the unspecified address MUST
|
|
|
|
* NOT be included in a candidate set.
|
|
|
|
*/
|
2008-03-02 02:48:21 +01:00
|
|
|
if ((score->ifa->flags & IFA_F_TENTATIVE) &&
|
|
|
|
(!(score->ifa->flags & IFA_F_OPTIMISTIC)))
|
2005-12-21 14:58:01 +01:00
|
|
|
continue;
|
2008-03-02 02:48:21 +01:00
|
|
|
|
|
|
|
score->addr_type = __ipv6_addr_type(&score->ifa->addr);
|
|
|
|
|
|
|
|
if (unlikely(score->addr_type == IPV6_ADDR_ANY ||
|
|
|
|
score->addr_type & IPV6_ADDR_MULTICAST)) {
|
2005-11-08 18:38:30 +01:00
|
|
|
LIMIT_NETDEBUG(KERN_DEBUG
|
2007-11-20 08:47:25 +01:00
|
|
|
"ADDRCONF: unspecified / multicast address "
|
2005-11-08 18:38:30 +01:00
|
|
|
"assigned as unicast address on %s",
|
|
|
|
dev->name);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2008-03-02 02:48:21 +01:00
|
|
|
score->rule = -1;
|
|
|
|
bitmap_zero(score->scorebits, IPV6_SADDR_RULE_MAX);
|
|
|
|
|
|
|
|
for (i = 0; i < IPV6_SADDR_RULE_MAX; i++) {
|
|
|
|
int minihiscore, miniscore;
|
|
|
|
|
2008-05-28 14:51:24 +02:00
|
|
|
minihiscore = ipv6_get_saddr_eval(net, hiscore, &dst, i);
|
|
|
|
miniscore = ipv6_get_saddr_eval(net, score, &dst, i);
|
2008-03-02 02:48:21 +01:00
|
|
|
|
|
|
|
if (minihiscore > miniscore) {
|
|
|
|
if (i == IPV6_SADDR_RULE_SCOPE &&
|
|
|
|
score->scopedist > 0) {
|
|
|
|
/*
|
|
|
|
* special case:
|
|
|
|
* each remaining entry
|
|
|
|
* has too small (not enough)
|
|
|
|
* scope, because ifa entries
|
|
|
|
* are sorted by their scope
|
|
|
|
* values.
|
|
|
|
*/
|
|
|
|
goto try_nextdev;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
} else if (minihiscore < miniscore) {
|
|
|
|
struct ipv6_saddr_score *tmp;
|
|
|
|
|
|
|
|
if (hiscore->ifa)
|
|
|
|
in6_ifa_put(hiscore->ifa);
|
|
|
|
|
|
|
|
in6_ifa_hold(score->ifa);
|
|
|
|
|
|
|
|
tmp = hiscore;
|
|
|
|
hiscore = score;
|
|
|
|
score = tmp;
|
|
|
|
|
|
|
|
/* restore our iterator */
|
|
|
|
score->ifa = hiscore->ifa;
|
|
|
|
|
|
|
|
break;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2005-11-08 18:38:30 +01:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2008-03-02 02:48:21 +01:00
|
|
|
try_nextdev:
|
2005-11-08 18:38:30 +01:00
|
|
|
read_unlock_bh(&idev->lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2006-09-22 23:44:24 +02:00
|
|
|
rcu_read_unlock();
|
2005-04-17 00:20:36 +02:00
|
|
|
read_unlock(&dev_base_lock);
|
|
|
|
|
2008-03-02 02:48:21 +01:00
|
|
|
if (!hiscore->ifa)
|
2005-11-08 18:38:30 +01:00
|
|
|
return -EADDRNOTAVAIL;
|
2007-02-09 15:24:49 +01:00
|
|
|
|
2008-03-02 02:48:21 +01:00
|
|
|
ipv6_addr_copy(saddr, &hiscore->ifa->addr);
|
|
|
|
in6_ifa_put(hiscore->ifa);
|
2005-11-08 18:38:30 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-03-03 13:44:34 +01:00
|
|
|
EXPORT_SYMBOL(ipv6_dev_get_saddr);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-04-26 02:08:10 +02:00
|
|
|
int ipv6_get_lladdr(struct net_device *dev, struct in6_addr *addr,
|
|
|
|
unsigned char banned_flags)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct inet6_dev *idev;
|
|
|
|
int err = -EADDRNOTAVAIL;
|
|
|
|
|
2006-09-22 23:44:24 +02:00
|
|
|
rcu_read_lock();
|
2005-04-17 00:20:36 +02:00
|
|
|
if ((idev = __in6_dev_get(dev)) != NULL) {
|
|
|
|
struct inet6_ifaddr *ifp;
|
|
|
|
|
|
|
|
read_lock_bh(&idev->lock);
|
|
|
|
for (ifp=idev->addr_list; ifp; ifp=ifp->if_next) {
|
2007-04-26 02:08:10 +02:00
|
|
|
if (ifp->scope == IFA_LINK && !(ifp->flags & banned_flags)) {
|
2005-04-17 00:20:36 +02:00
|
|
|
ipv6_addr_copy(addr, &ifp->addr);
|
|
|
|
err = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
read_unlock_bh(&idev->lock);
|
|
|
|
}
|
2006-09-22 23:44:24 +02:00
|
|
|
rcu_read_unlock();
|
2005-04-17 00:20:36 +02:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ipv6_count_addresses(struct inet6_dev *idev)
|
|
|
|
{
|
|
|
|
int cnt = 0;
|
|
|
|
struct inet6_ifaddr *ifp;
|
|
|
|
|
|
|
|
read_lock_bh(&idev->lock);
|
|
|
|
for (ifp=idev->addr_list; ifp; ifp=ifp->if_next)
|
|
|
|
cnt++;
|
|
|
|
read_unlock_bh(&idev->lock);
|
|
|
|
return cnt;
|
|
|
|
}
|
|
|
|
|
2008-01-11 07:43:18 +01:00
|
|
|
int ipv6_chk_addr(struct net *net, struct in6_addr *addr,
|
|
|
|
struct net_device *dev, int strict)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct inet6_ifaddr * ifp;
|
|
|
|
u8 hash = ipv6_addr_hash(addr);
|
|
|
|
|
|
|
|
read_lock_bh(&addrconf_hash_lock);
|
|
|
|
for(ifp = inet6_addr_lst[hash]; ifp; ifp=ifp->lst_next) {
|
2008-03-25 19:57:35 +01:00
|
|
|
if (!net_eq(dev_net(ifp->idev->dev), net))
|
2008-01-11 07:43:18 +01:00
|
|
|
continue;
|
2005-04-17 00:20:36 +02:00
|
|
|
if (ipv6_addr_equal(&ifp->addr, addr) &&
|
|
|
|
!(ifp->flags&IFA_F_TENTATIVE)) {
|
|
|
|
if (dev == NULL || ifp->idev->dev == dev ||
|
|
|
|
!(ifp->scope&(IFA_LINK|IFA_HOST) || strict))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
read_unlock_bh(&addrconf_hash_lock);
|
|
|
|
return ifp != NULL;
|
|
|
|
}
|
2007-02-22 14:05:40 +01:00
|
|
|
EXPORT_SYMBOL(ipv6_chk_addr);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static
|
2008-01-11 07:43:42 +01:00
|
|
|
int ipv6_chk_same_addr(struct net *net, const struct in6_addr *addr,
|
|
|
|
struct net_device *dev)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct inet6_ifaddr * ifp;
|
|
|
|
u8 hash = ipv6_addr_hash(addr);
|
|
|
|
|
|
|
|
for(ifp = inet6_addr_lst[hash]; ifp; ifp=ifp->lst_next) {
|
2008-03-25 19:57:35 +01:00
|
|
|
if (!net_eq(dev_net(ifp->idev->dev), net))
|
2008-01-11 07:43:42 +01:00
|
|
|
continue;
|
2005-04-17 00:20:36 +02:00
|
|
|
if (ipv6_addr_equal(&ifp->addr, addr)) {
|
|
|
|
if (dev == NULL || ifp->idev->dev == dev)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ifp != NULL;
|
|
|
|
}
|
|
|
|
|
2008-03-16 03:54:23 +01:00
|
|
|
int ipv6_chk_prefix(struct in6_addr *addr, struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct inet6_dev *idev;
|
|
|
|
struct inet6_ifaddr *ifa;
|
|
|
|
int onlink;
|
|
|
|
|
|
|
|
onlink = 0;
|
|
|
|
rcu_read_lock();
|
|
|
|
idev = __in6_dev_get(dev);
|
|
|
|
if (idev) {
|
|
|
|
read_lock_bh(&idev->lock);
|
|
|
|
for (ifa = idev->addr_list; ifa; ifa = ifa->if_next) {
|
|
|
|
onlink = ipv6_prefix_equal(addr, &ifa->addr,
|
|
|
|
ifa->prefix_len);
|
|
|
|
if (onlink)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
read_unlock_bh(&idev->lock);
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
|
|
|
return onlink;
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(ipv6_chk_prefix);
|
|
|
|
|
[IPV6]: Make address arguments const.
- net/ipv6/addrconf.c:
ipv6_get_ifaddr(), ipv6_dev_get_saddr()
- net/ipv6/mcast.c:
ipv6_sock_mc_join(), ipv6_sock_mc_drop(),
inet6_mc_check(),
ipv6_dev_mc_inc(), __ipv6_dev_mc_dec(), ipv6_dev_mc_dec(),
ipv6_chk_mcast_addr()
- net/ipv6/route.c:
rt6_lookup(), icmp6_dst_alloc()
- net/ipv6/ip6_output.c:
ip6_nd_hdr()
- net/ipv6/ndisc.c:
ndisc_send_ns(), ndisc_send_rs(), ndisc_send_redirect(),
ndisc_get_neigh(), __ndisc_send()
Signed-off-by: YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
2008-04-10 08:42:10 +02:00
|
|
|
struct inet6_ifaddr *ipv6_get_ifaddr(struct net *net, const struct in6_addr *addr,
|
2008-01-11 07:44:09 +01:00
|
|
|
struct net_device *dev, int strict)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct inet6_ifaddr * ifp;
|
|
|
|
u8 hash = ipv6_addr_hash(addr);
|
|
|
|
|
|
|
|
read_lock_bh(&addrconf_hash_lock);
|
|
|
|
for(ifp = inet6_addr_lst[hash]; ifp; ifp=ifp->lst_next) {
|
2008-03-25 19:57:35 +01:00
|
|
|
if (!net_eq(dev_net(ifp->idev->dev), net))
|
2008-01-11 07:44:09 +01:00
|
|
|
continue;
|
2005-04-17 00:20:36 +02:00
|
|
|
if (ipv6_addr_equal(&ifp->addr, addr)) {
|
|
|
|
if (dev == NULL || ifp->idev->dev == dev ||
|
|
|
|
!(ifp->scope&(IFA_LINK|IFA_HOST) || strict)) {
|
|
|
|
in6_ifa_hold(ifp);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
read_unlock_bh(&addrconf_hash_lock);
|
|
|
|
|
|
|
|
return ifp;
|
|
|
|
}
|
|
|
|
|
|
|
|
int ipv6_rcv_saddr_equal(const struct sock *sk, const struct sock *sk2)
|
|
|
|
{
|
|
|
|
const struct in6_addr *sk_rcv_saddr6 = &inet6_sk(sk)->rcv_saddr;
|
2005-12-14 08:23:09 +01:00
|
|
|
const struct in6_addr *sk2_rcv_saddr6 = inet6_rcv_saddr(sk2);
|
2006-09-28 03:44:10 +02:00
|
|
|
__be32 sk_rcv_saddr = inet_sk(sk)->rcv_saddr;
|
|
|
|
__be32 sk2_rcv_saddr = inet_rcv_saddr(sk2);
|
2005-04-17 00:20:36 +02:00
|
|
|
int sk_ipv6only = ipv6_only_sock(sk);
|
2005-08-10 05:10:42 +02:00
|
|
|
int sk2_ipv6only = inet_v6_ipv6only(sk2);
|
2005-04-17 00:20:36 +02:00
|
|
|
int addr_type = ipv6_addr_type(sk_rcv_saddr6);
|
|
|
|
int addr_type2 = sk2_rcv_saddr6 ? ipv6_addr_type(sk2_rcv_saddr6) : IPV6_ADDR_MAPPED;
|
|
|
|
|
|
|
|
if (!sk2_rcv_saddr && !sk_ipv6only)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (addr_type2 == IPV6_ADDR_ANY &&
|
|
|
|
!(sk2_ipv6only && addr_type == IPV6_ADDR_MAPPED))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (addr_type == IPV6_ADDR_ANY &&
|
|
|
|
!(sk_ipv6only && addr_type2 == IPV6_ADDR_MAPPED))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (sk2_rcv_saddr6 &&
|
|
|
|
ipv6_addr_equal(sk_rcv_saddr6, sk2_rcv_saddr6))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (addr_type == IPV6_ADDR_MAPPED &&
|
|
|
|
!sk2_ipv6only &&
|
|
|
|
(!sk2_rcv_saddr || !sk_rcv_saddr || sk_rcv_saddr == sk2_rcv_saddr))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Gets referenced address, destroys ifaddr */
|
|
|
|
|
2006-01-07 22:24:25 +01:00
|
|
|
static void addrconf_dad_stop(struct inet6_ifaddr *ifp)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
if (ifp->flags&IFA_F_PERMANENT) {
|
|
|
|
spin_lock_bh(&ifp->lock);
|
|
|
|
addrconf_del_timer(ifp);
|
|
|
|
ifp->flags |= IFA_F_TENTATIVE;
|
|
|
|
spin_unlock_bh(&ifp->lock);
|
|
|
|
in6_ifa_put(ifp);
|
|
|
|
#ifdef CONFIG_IPV6_PRIVACY
|
|
|
|
} else if (ifp->flags&IFA_F_TEMPORARY) {
|
|
|
|
struct inet6_ifaddr *ifpub;
|
|
|
|
spin_lock_bh(&ifp->lock);
|
|
|
|
ifpub = ifp->ifpub;
|
|
|
|
if (ifpub) {
|
|
|
|
in6_ifa_hold(ifpub);
|
|
|
|
spin_unlock_bh(&ifp->lock);
|
|
|
|
ipv6_create_tempaddr(ifpub, ifp);
|
|
|
|
in6_ifa_put(ifpub);
|
|
|
|
} else {
|
|
|
|
spin_unlock_bh(&ifp->lock);
|
|
|
|
}
|
|
|
|
ipv6_del_addr(ifp);
|
|
|
|
#endif
|
|
|
|
} else
|
|
|
|
ipv6_del_addr(ifp);
|
|
|
|
}
|
|
|
|
|
2005-12-21 14:57:24 +01:00
|
|
|
void addrconf_dad_failure(struct inet6_ifaddr *ifp)
|
|
|
|
{
|
2008-06-28 07:18:38 +02:00
|
|
|
struct inet6_dev *idev = ifp->idev;
|
|
|
|
if (idev->cnf.accept_dad > 1 && !idev->cnf.disable_ipv6) {
|
|
|
|
struct in6_addr addr;
|
|
|
|
|
|
|
|
addr.s6_addr32[0] = htonl(0xfe800000);
|
|
|
|
addr.s6_addr32[1] = 0;
|
|
|
|
|
|
|
|
if (!ipv6_generate_eui64(addr.s6_addr + 8, idev->dev) &&
|
|
|
|
ipv6_addr_equal(&ifp->addr, &addr)) {
|
|
|
|
/* DAD failed for link-local based on MAC address */
|
|
|
|
idev->cnf.disable_ipv6 = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-12-21 14:57:24 +01:00
|
|
|
if (net_ratelimit())
|
|
|
|
printk(KERN_INFO "%s: duplicate address detected!\n", ifp->idev->dev->name);
|
|
|
|
addrconf_dad_stop(ifp);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* Join to solicited addr multicast group. */
|
|
|
|
|
|
|
|
void addrconf_join_solict(struct net_device *dev, struct in6_addr *addr)
|
|
|
|
{
|
|
|
|
struct in6_addr maddr;
|
|
|
|
|
|
|
|
if (dev->flags&(IFF_LOOPBACK|IFF_NOARP))
|
|
|
|
return;
|
|
|
|
|
|
|
|
addrconf_addr_solict_mult(addr, &maddr);
|
|
|
|
ipv6_dev_mc_inc(dev, &maddr);
|
|
|
|
}
|
|
|
|
|
|
|
|
void addrconf_leave_solict(struct inet6_dev *idev, struct in6_addr *addr)
|
|
|
|
{
|
|
|
|
struct in6_addr maddr;
|
|
|
|
|
|
|
|
if (idev->dev->flags&(IFF_LOOPBACK|IFF_NOARP))
|
|
|
|
return;
|
|
|
|
|
|
|
|
addrconf_addr_solict_mult(addr, &maddr);
|
|
|
|
__ipv6_dev_mc_dec(idev, &maddr);
|
|
|
|
}
|
|
|
|
|
2005-08-16 07:18:02 +02:00
|
|
|
static void addrconf_join_anycast(struct inet6_ifaddr *ifp)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct in6_addr addr;
|
|
|
|
ipv6_addr_prefix(&addr, &ifp->addr, ifp->prefix_len);
|
|
|
|
if (ipv6_addr_any(&addr))
|
|
|
|
return;
|
|
|
|
ipv6_dev_ac_inc(ifp->idev->dev, &addr);
|
|
|
|
}
|
|
|
|
|
2005-08-16 07:18:02 +02:00
|
|
|
static void addrconf_leave_anycast(struct inet6_ifaddr *ifp)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct in6_addr addr;
|
|
|
|
ipv6_addr_prefix(&addr, &ifp->addr, ifp->prefix_len);
|
|
|
|
if (ipv6_addr_any(&addr))
|
|
|
|
return;
|
|
|
|
__ipv6_dev_ac_dec(ifp->idev, &addr);
|
|
|
|
}
|
|
|
|
|
2006-03-21 01:54:49 +01:00
|
|
|
static int addrconf_ifid_eui48(u8 *eui, struct net_device *dev)
|
|
|
|
{
|
|
|
|
if (dev->addr_len != ETH_ALEN)
|
|
|
|
return -1;
|
|
|
|
memcpy(eui, dev->dev_addr, 3);
|
|
|
|
memcpy(eui + 5, dev->dev_addr + 3, 3);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The zSeries OSA network cards can be shared among various
|
|
|
|
* OS instances, but the OSA cards have only one MAC address.
|
|
|
|
* This leads to duplicate address conflicts in conjunction
|
|
|
|
* with IPv6 if more than one instance uses the same card.
|
|
|
|
*
|
|
|
|
* The driver for these cards can deliver a unique 16-bit
|
|
|
|
* identifier for each instance sharing the same card. It is
|
|
|
|
* placed instead of 0xFFFE in the interface identifier. The
|
|
|
|
* "u" bit of the interface identifier is not inverted in this
|
|
|
|
* case. Hence the resulting interface identifier has local
|
|
|
|
* scope according to RFC2373.
|
|
|
|
*/
|
|
|
|
if (dev->dev_id) {
|
|
|
|
eui[3] = (dev->dev_id >> 8) & 0xFF;
|
|
|
|
eui[4] = dev->dev_id & 0xFF;
|
|
|
|
} else {
|
|
|
|
eui[3] = 0xFF;
|
|
|
|
eui[4] = 0xFE;
|
|
|
|
eui[0] ^= 2;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int addrconf_ifid_arcnet(u8 *eui, struct net_device *dev)
|
|
|
|
{
|
|
|
|
/* XXX: inherit EUI-64 from other interface -- yoshfuji */
|
|
|
|
if (dev->addr_len != ARCNET_ALEN)
|
|
|
|
return -1;
|
|
|
|
memset(eui, 0, 7);
|
|
|
|
eui[7] = *(u8*)dev->dev_addr;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int addrconf_ifid_infiniband(u8 *eui, struct net_device *dev)
|
|
|
|
{
|
|
|
|
if (dev->addr_len != INFINIBAND_ALEN)
|
|
|
|
return -1;
|
|
|
|
memcpy(eui, dev->dev_addr + 12, 8);
|
|
|
|
eui[0] |= 2;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-04-10 08:42:09 +02:00
|
|
|
int __ipv6_isatap_ifid(u8 *eui, __be32 addr)
|
|
|
|
{
|
|
|
|
eui[0] = (ipv4_is_zeronet(addr) || ipv4_is_private_10(addr) ||
|
|
|
|
ipv4_is_loopback(addr) || ipv4_is_linklocal_169(addr) ||
|
|
|
|
ipv4_is_private_172(addr) || ipv4_is_test_192(addr) ||
|
|
|
|
ipv4_is_anycast_6to4(addr) || ipv4_is_private_192(addr) ||
|
|
|
|
ipv4_is_test_198(addr) || ipv4_is_multicast(addr) ||
|
|
|
|
ipv4_is_lbcast(addr)) ? 0x00 : 0x02;
|
|
|
|
eui[1] = 0;
|
|
|
|
eui[2] = 0x5E;
|
|
|
|
eui[3] = 0xFE;
|
|
|
|
memcpy(eui + 4, &addr, 4);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(__ipv6_isatap_ifid);
|
|
|
|
|
|
|
|
static int addrconf_ifid_sit(u8 *eui, struct net_device *dev)
|
|
|
|
{
|
|
|
|
if (dev->priv_flags & IFF_ISATAP)
|
|
|
|
return __ipv6_isatap_ifid(eui, *(__be32 *)dev->dev_addr);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static int ipv6_generate_eui64(u8 *eui, struct net_device *dev)
|
|
|
|
{
|
|
|
|
switch (dev->type) {
|
|
|
|
case ARPHRD_ETHER:
|
|
|
|
case ARPHRD_FDDI:
|
|
|
|
case ARPHRD_IEEE802_TR:
|
2006-03-21 01:54:49 +01:00
|
|
|
return addrconf_ifid_eui48(eui, dev);
|
2005-04-17 00:20:36 +02:00
|
|
|
case ARPHRD_ARCNET:
|
2006-03-21 01:54:49 +01:00
|
|
|
return addrconf_ifid_arcnet(eui, dev);
|
2005-04-17 00:20:36 +02:00
|
|
|
case ARPHRD_INFINIBAND:
|
2006-03-21 01:54:49 +01:00
|
|
|
return addrconf_ifid_infiniband(eui, dev);
|
2007-11-29 12:11:40 +01:00
|
|
|
case ARPHRD_SIT:
|
2008-04-10 08:42:09 +02:00
|
|
|
return addrconf_ifid_sit(eui, dev);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ipv6_inherit_eui64(u8 *eui, struct inet6_dev *idev)
|
|
|
|
{
|
|
|
|
int err = -1;
|
|
|
|
struct inet6_ifaddr *ifp;
|
|
|
|
|
|
|
|
read_lock_bh(&idev->lock);
|
|
|
|
for (ifp=idev->addr_list; ifp; ifp=ifp->if_next) {
|
|
|
|
if (ifp->scope == IFA_LINK && !(ifp->flags&IFA_F_TENTATIVE)) {
|
|
|
|
memcpy(eui, ifp->addr.s6_addr+8, 8);
|
|
|
|
err = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
read_unlock_bh(&idev->lock);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_IPV6_PRIVACY
|
|
|
|
/* (re)generation of randomized interface identifier (RFC 3041 3.2, 3.5) */
|
|
|
|
static int __ipv6_regen_rndid(struct inet6_dev *idev)
|
|
|
|
{
|
|
|
|
regen:
|
2006-03-21 01:54:09 +01:00
|
|
|
get_random_bytes(idev->rndid, sizeof(idev->rndid));
|
2005-04-17 00:20:36 +02:00
|
|
|
idev->rndid[0] &= ~0x02;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* <draft-ietf-ipngwg-temp-addresses-v2-00.txt>:
|
|
|
|
* check if generated address is not inappropriate
|
|
|
|
*
|
|
|
|
* - Reserved subnet anycast (RFC 2526)
|
|
|
|
* 11111101 11....11 1xxxxxxx
|
2007-11-29 12:11:40 +01:00
|
|
|
* - ISATAP (RFC4214) 6.1
|
2005-04-17 00:20:36 +02:00
|
|
|
* 00-00-5E-FE-xx-xx-xx-xx
|
|
|
|
* - value 0
|
|
|
|
* - XXX: already assigned to an address on the device
|
|
|
|
*/
|
2007-02-09 15:24:49 +01:00
|
|
|
if (idev->rndid[0] == 0xfd &&
|
2005-04-17 00:20:36 +02:00
|
|
|
(idev->rndid[1]&idev->rndid[2]&idev->rndid[3]&idev->rndid[4]&idev->rndid[5]&idev->rndid[6]) == 0xff &&
|
|
|
|
(idev->rndid[7]&0x80))
|
|
|
|
goto regen;
|
|
|
|
if ((idev->rndid[0]|idev->rndid[1]) == 0) {
|
|
|
|
if (idev->rndid[2] == 0x5e && idev->rndid[3] == 0xfe)
|
|
|
|
goto regen;
|
|
|
|
if ((idev->rndid[2]|idev->rndid[3]|idev->rndid[4]|idev->rndid[5]|idev->rndid[6]|idev->rndid[7]) == 0x00)
|
|
|
|
goto regen;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ipv6_regen_rndid(unsigned long data)
|
|
|
|
{
|
|
|
|
struct inet6_dev *idev = (struct inet6_dev *) data;
|
|
|
|
unsigned long expires;
|
|
|
|
|
2006-09-22 23:44:24 +02:00
|
|
|
rcu_read_lock_bh();
|
2005-04-17 00:20:36 +02:00
|
|
|
write_lock_bh(&idev->lock);
|
|
|
|
|
|
|
|
if (idev->dead)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (__ipv6_regen_rndid(idev) < 0)
|
|
|
|
goto out;
|
2007-02-09 15:24:49 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
expires = jiffies +
|
2007-02-09 15:24:49 +01:00
|
|
|
idev->cnf.temp_prefered_lft * HZ -
|
2005-04-17 00:20:36 +02:00
|
|
|
idev->cnf.regen_max_retry * idev->cnf.dad_transmits * idev->nd_parms->retrans_time - desync_factor;
|
|
|
|
if (time_before(expires, jiffies)) {
|
|
|
|
printk(KERN_WARNING
|
|
|
|
"ipv6_regen_rndid(): too short regeneration interval; timer disabled for %s.\n",
|
|
|
|
idev->dev->name);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!mod_timer(&idev->regen_timer, expires))
|
|
|
|
in6_dev_hold(idev);
|
|
|
|
|
|
|
|
out:
|
|
|
|
write_unlock_bh(&idev->lock);
|
2006-09-22 23:44:24 +02:00
|
|
|
rcu_read_unlock_bh();
|
2005-04-17 00:20:36 +02:00
|
|
|
in6_dev_put(idev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __ipv6_try_regen_rndid(struct inet6_dev *idev, struct in6_addr *tmpaddr) {
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (tmpaddr && memcmp(idev->rndid, &tmpaddr->s6_addr[8], 8) == 0)
|
|
|
|
ret = __ipv6_regen_rndid(idev);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add prefix route.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
addrconf_prefix_route(struct in6_addr *pfx, int plen, struct net_device *dev,
|
2005-06-19 07:55:31 +02:00
|
|
|
unsigned long expires, u32 flags)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-08-22 09:01:08 +02:00
|
|
|
struct fib6_config cfg = {
|
|
|
|
.fc_table = RT6_TABLE_PREFIX,
|
|
|
|
.fc_metric = IP6_RT_PRIO_ADDRCONF,
|
|
|
|
.fc_ifindex = dev->ifindex,
|
|
|
|
.fc_expires = expires,
|
|
|
|
.fc_dst_len = plen,
|
|
|
|
.fc_flags = RTF_UP | flags,
|
2008-03-25 13:47:49 +01:00
|
|
|
.fc_nlinfo.nl_net = dev_net(dev),
|
2008-08-23 14:16:46 +02:00
|
|
|
.fc_protocol = RTPROT_KERNEL,
|
2006-08-22 09:01:08 +02:00
|
|
|
};
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-08-22 09:01:08 +02:00
|
|
|
ipv6_addr_copy(&cfg.fc_dst, pfx);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* Prevent useless cloning on PtP SIT.
|
|
|
|
This thing is done here expecting that the whole
|
|
|
|
class of non-broadcast devices need not cloning.
|
|
|
|
*/
|
2006-10-10 23:49:53 +02:00
|
|
|
#if defined(CONFIG_IPV6_SIT) || defined(CONFIG_IPV6_SIT_MODULE)
|
2006-08-22 09:01:08 +02:00
|
|
|
if (dev->type == ARPHRD_SIT && (dev->flags & IFF_POINTOPOINT))
|
|
|
|
cfg.fc_flags |= RTF_NONEXTHOP;
|
2006-10-10 23:49:53 +02:00
|
|
|
#endif
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-08-22 09:01:08 +02:00
|
|
|
ip6_route_add(&cfg);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Create "default" multicast route to the interface */
|
|
|
|
|
|
|
|
static void addrconf_add_mroute(struct net_device *dev)
|
|
|
|
{
|
2006-08-22 09:01:08 +02:00
|
|
|
struct fib6_config cfg = {
|
|
|
|
.fc_table = RT6_TABLE_LOCAL,
|
|
|
|
.fc_metric = IP6_RT_PRIO_ADDRCONF,
|
|
|
|
.fc_ifindex = dev->ifindex,
|
|
|
|
.fc_dst_len = 8,
|
|
|
|
.fc_flags = RTF_UP,
|
2008-03-25 13:47:49 +01:00
|
|
|
.fc_nlinfo.nl_net = dev_net(dev),
|
2006-08-22 09:01:08 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
ipv6_addr_set(&cfg.fc_dst, htonl(0xFF000000), 0, 0, 0);
|
|
|
|
|
|
|
|
ip6_route_add(&cfg);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-10-10 23:49:53 +02:00
|
|
|
#if defined(CONFIG_IPV6_SIT) || defined(CONFIG_IPV6_SIT_MODULE)
|
2005-04-17 00:20:36 +02:00
|
|
|
static void sit_route_add(struct net_device *dev)
|
|
|
|
{
|
2006-08-22 09:01:08 +02:00
|
|
|
struct fib6_config cfg = {
|
|
|
|
.fc_table = RT6_TABLE_MAIN,
|
|
|
|
.fc_metric = IP6_RT_PRIO_ADDRCONF,
|
|
|
|
.fc_ifindex = dev->ifindex,
|
|
|
|
.fc_dst_len = 96,
|
|
|
|
.fc_flags = RTF_UP | RTF_NONEXTHOP,
|
2008-03-25 13:47:49 +01:00
|
|
|
.fc_nlinfo.nl_net = dev_net(dev),
|
2006-08-22 09:01:08 +02:00
|
|
|
};
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* prefix length - 96 bits "::d.d.d.d" */
|
2006-08-22 09:01:08 +02:00
|
|
|
ip6_route_add(&cfg);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2006-10-10 23:49:53 +02:00
|
|
|
#endif
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
static void addrconf_add_lroute(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct in6_addr addr;
|
|
|
|
|
|
|
|
ipv6_addr_set(&addr, htonl(0xFE800000), 0, 0, 0);
|
|
|
|
addrconf_prefix_route(&addr, 64, dev, 0, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct inet6_dev *addrconf_add_dev(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct inet6_dev *idev;
|
|
|
|
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
|
|
|
if ((idev = ipv6_find_idev(dev)) == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
/* Add default multicast route */
|
|
|
|
addrconf_add_mroute(dev);
|
|
|
|
|
|
|
|
/* Add link local route */
|
|
|
|
addrconf_add_lroute(dev);
|
|
|
|
return idev;
|
|
|
|
}
|
|
|
|
|
|
|
|
void addrconf_prefix_rcv(struct net_device *dev, u8 *opt, int len)
|
|
|
|
{
|
|
|
|
struct prefix_info *pinfo;
|
|
|
|
__u32 valid_lft;
|
|
|
|
__u32 prefered_lft;
|
|
|
|
int addr_type;
|
|
|
|
struct inet6_dev *in6_dev;
|
|
|
|
|
|
|
|
pinfo = (struct prefix_info *) opt;
|
2007-02-09 15:24:49 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
if (len < sizeof(struct prefix_info)) {
|
|
|
|
ADBG(("addrconf: prefix option too short\n"));
|
|
|
|
return;
|
|
|
|
}
|
2007-02-09 15:24:49 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Validation checks ([ADDRCONF], page 19)
|
|
|
|
*/
|
|
|
|
|
|
|
|
addr_type = ipv6_addr_type(&pinfo->prefix);
|
|
|
|
|
|
|
|
if (addr_type & (IPV6_ADDR_MULTICAST|IPV6_ADDR_LINKLOCAL))
|
|
|
|
return;
|
|
|
|
|
|
|
|
valid_lft = ntohl(pinfo->valid);
|
|
|
|
prefered_lft = ntohl(pinfo->prefered);
|
|
|
|
|
|
|
|
if (prefered_lft > valid_lft) {
|
|
|
|
if (net_ratelimit())
|
|
|
|
printk(KERN_WARNING "addrconf: prefix option has invalid lifetime\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
in6_dev = in6_dev_get(dev);
|
|
|
|
|
|
|
|
if (in6_dev == NULL) {
|
|
|
|
if (net_ratelimit())
|
|
|
|
printk(KERN_DEBUG "addrconf: device %s not configured\n", dev->name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Two things going on here:
|
|
|
|
* 1) Add routes for on-link prefixes
|
|
|
|
* 2) Configure prefixes with the auto flag set
|
|
|
|
*/
|
|
|
|
|
2008-05-27 10:37:49 +02:00
|
|
|
if (pinfo->onlink) {
|
|
|
|
struct rt6_info *rt;
|
|
|
|
unsigned long rt_expires;
|
|
|
|
|
2008-05-20 01:56:11 +02:00
|
|
|
/* Avoid arithmetic overflow. Really, we could
|
|
|
|
* save rt_expires in seconds, likely valid_lft,
|
|
|
|
* but it would require division in fib gc, that it
|
|
|
|
* not good.
|
|
|
|
*/
|
2008-05-27 10:37:49 +02:00
|
|
|
if (HZ > USER_HZ)
|
|
|
|
rt_expires = addrconf_timeout_fixup(valid_lft, HZ);
|
|
|
|
else
|
|
|
|
rt_expires = addrconf_timeout_fixup(valid_lft, USER_HZ);
|
2005-12-19 23:02:45 +01:00
|
|
|
|
2008-05-27 10:37:49 +02:00
|
|
|
if (addrconf_finite_timeout(rt_expires))
|
|
|
|
rt_expires *= HZ;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-03-25 13:47:49 +01:00
|
|
|
rt = rt6_lookup(dev_net(dev), &pinfo->prefix, NULL,
|
2008-03-05 19:47:47 +01:00
|
|
|
dev->ifindex, 1);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-05-12 18:16:24 +02:00
|
|
|
if (rt && addrconf_is_prefix_route(rt)) {
|
2008-05-20 01:56:11 +02:00
|
|
|
/* Autoconf prefix route */
|
|
|
|
if (valid_lft == 0) {
|
|
|
|
ip6_del_rt(rt);
|
|
|
|
rt = NULL;
|
2008-05-27 10:37:49 +02:00
|
|
|
} else if (addrconf_finite_timeout(rt_expires)) {
|
2008-05-20 01:56:11 +02:00
|
|
|
/* not infinity */
|
|
|
|
rt->rt6i_expires = jiffies + rt_expires;
|
|
|
|
rt->rt6i_flags |= RTF_EXPIRES;
|
|
|
|
} else {
|
|
|
|
rt->rt6i_flags &= ~RTF_EXPIRES;
|
|
|
|
rt->rt6i_expires = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
} else if (valid_lft) {
|
2008-05-20 01:56:11 +02:00
|
|
|
clock_t expires = 0;
|
2008-05-27 10:37:49 +02:00
|
|
|
int flags = RTF_ADDRCONF | RTF_PREFIX_RT;
|
|
|
|
if (addrconf_finite_timeout(rt_expires)) {
|
2008-05-20 01:56:11 +02:00
|
|
|
/* not infinity */
|
|
|
|
flags |= RTF_EXPIRES;
|
|
|
|
expires = jiffies_to_clock_t(rt_expires);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
addrconf_prefix_route(&pinfo->prefix, pinfo->prefix_len,
|
2008-05-20 01:56:11 +02:00
|
|
|
dev, expires, flags);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
if (rt)
|
|
|
|
dst_release(&rt->u.dst);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Try to figure out our local address for this prefix */
|
|
|
|
|
|
|
|
if (pinfo->autoconf && in6_dev->cnf.autoconf) {
|
|
|
|
struct inet6_ifaddr * ifp;
|
|
|
|
struct in6_addr addr;
|
|
|
|
int create = 0, update_lft = 0;
|
2008-07-20 07:35:03 +02:00
|
|
|
struct net *net = dev_net(dev);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (pinfo->prefix_len == 64) {
|
|
|
|
memcpy(&addr, &pinfo->prefix, 8);
|
|
|
|
if (ipv6_generate_eui64(addr.s6_addr + 8, dev) &&
|
|
|
|
ipv6_inherit_eui64(addr.s6_addr + 8, in6_dev)) {
|
|
|
|
in6_dev_put(in6_dev);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
goto ok;
|
|
|
|
}
|
|
|
|
if (net_ratelimit())
|
|
|
|
printk(KERN_DEBUG "IPv6 addrconf: prefix with wrong length %d\n",
|
|
|
|
pinfo->prefix_len);
|
|
|
|
in6_dev_put(in6_dev);
|
|
|
|
return;
|
|
|
|
|
|
|
|
ok:
|
|
|
|
|
2008-07-20 07:35:03 +02:00
|
|
|
ifp = ipv6_get_ifaddr(net, &addr, dev, 1);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (ifp == NULL && valid_lft) {
|
|
|
|
int max_addresses = in6_dev->cnf.max_addresses;
|
2007-04-26 02:08:10 +02:00
|
|
|
u32 addr_flags = 0;
|
|
|
|
|
|
|
|
#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
|
|
|
|
if (in6_dev->cnf.optimistic_dad &&
|
2008-07-20 07:35:03 +02:00
|
|
|
!net->ipv6.devconf_all->forwarding)
|
2007-04-26 02:08:10 +02:00
|
|
|
addr_flags = IFA_F_OPTIMISTIC;
|
|
|
|
#endif
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* Do not allow to create too much of autoconfigured
|
|
|
|
* addresses; this would be too easy way to crash kernel.
|
|
|
|
*/
|
|
|
|
if (!max_addresses ||
|
|
|
|
ipv6_count_addresses(in6_dev) < max_addresses)
|
|
|
|
ifp = ipv6_add_addr(in6_dev, &addr, pinfo->prefix_len,
|
2007-04-26 02:08:10 +02:00
|
|
|
addr_type&IPV6_ADDR_SCOPE_MASK,
|
|
|
|
addr_flags);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (!ifp || IS_ERR(ifp)) {
|
|
|
|
in6_dev_put(in6_dev);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
update_lft = create = 1;
|
|
|
|
ifp->cstamp = jiffies;
|
|
|
|
addrconf_dad_start(ifp, RTF_ADDRCONF|RTF_PREFIX_RT);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ifp) {
|
|
|
|
int flags;
|
|
|
|
unsigned long now;
|
|
|
|
#ifdef CONFIG_IPV6_PRIVACY
|
|
|
|
struct inet6_ifaddr *ift;
|
|
|
|
#endif
|
|
|
|
u32 stored_lft;
|
|
|
|
|
|
|
|
/* update lifetime (RFC2462 5.5.3 e) */
|
|
|
|
spin_lock(&ifp->lock);
|
|
|
|
now = jiffies;
|
|
|
|
if (ifp->valid_lft > (now - ifp->tstamp) / HZ)
|
|
|
|
stored_lft = ifp->valid_lft - (now - ifp->tstamp) / HZ;
|
|
|
|
else
|
|
|
|
stored_lft = 0;
|
|
|
|
if (!update_lft && stored_lft) {
|
|
|
|
if (valid_lft > MIN_VALID_LIFETIME ||
|
|
|
|
valid_lft > stored_lft)
|
|
|
|
update_lft = 1;
|
|
|
|
else if (stored_lft <= MIN_VALID_LIFETIME) {
|
|
|
|
/* valid_lft <= stored_lft is always true */
|
|
|
|
/* XXX: IPsec */
|
|
|
|
update_lft = 0;
|
|
|
|
} else {
|
|
|
|
valid_lft = MIN_VALID_LIFETIME;
|
|
|
|
if (valid_lft < prefered_lft)
|
|
|
|
prefered_lft = valid_lft;
|
|
|
|
update_lft = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (update_lft) {
|
|
|
|
ifp->valid_lft = valid_lft;
|
|
|
|
ifp->prefered_lft = prefered_lft;
|
|
|
|
ifp->tstamp = now;
|
|
|
|
flags = ifp->flags;
|
|
|
|
ifp->flags &= ~IFA_F_DEPRECATED;
|
|
|
|
spin_unlock(&ifp->lock);
|
|
|
|
|
|
|
|
if (!(flags&IFA_F_TENTATIVE))
|
|
|
|
ipv6_ifa_notify(0, ifp);
|
|
|
|
} else
|
|
|
|
spin_unlock(&ifp->lock);
|
|
|
|
|
|
|
|
#ifdef CONFIG_IPV6_PRIVACY
|
|
|
|
read_lock_bh(&in6_dev->lock);
|
|
|
|
/* update all temporary addresses in the list */
|
|
|
|
for (ift=in6_dev->tempaddr_list; ift; ift=ift->tmp_next) {
|
|
|
|
/*
|
|
|
|
* When adjusting the lifetimes of an existing
|
|
|
|
* temporary address, only lower the lifetimes.
|
|
|
|
* Implementations must not increase the
|
|
|
|
* lifetimes of an existing temporary address
|
|
|
|
* when processing a Prefix Information Option.
|
|
|
|
*/
|
2008-04-02 09:00:58 +02:00
|
|
|
if (ifp != ift->ifpub)
|
|
|
|
continue;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
spin_lock(&ift->lock);
|
|
|
|
flags = ift->flags;
|
|
|
|
if (ift->valid_lft > valid_lft &&
|
|
|
|
ift->valid_lft - valid_lft > (jiffies - ift->tstamp) / HZ)
|
|
|
|
ift->valid_lft = valid_lft + (jiffies - ift->tstamp) / HZ;
|
|
|
|
if (ift->prefered_lft > prefered_lft &&
|
|
|
|
ift->prefered_lft - prefered_lft > (jiffies - ift->tstamp) / HZ)
|
|
|
|
ift->prefered_lft = prefered_lft + (jiffies - ift->tstamp) / HZ;
|
|
|
|
spin_unlock(&ift->lock);
|
|
|
|
if (!(flags&IFA_F_TENTATIVE))
|
|
|
|
ipv6_ifa_notify(0, ift);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (create && in6_dev->cnf.use_tempaddr > 0) {
|
|
|
|
/*
|
|
|
|
* When a new public address is created as described in [ADDRCONF],
|
|
|
|
* also create a new temporary address.
|
|
|
|
*/
|
2007-02-09 15:24:49 +01:00
|
|
|
read_unlock_bh(&in6_dev->lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
ipv6_create_tempaddr(ifp, NULL);
|
|
|
|
} else {
|
|
|
|
read_unlock_bh(&in6_dev->lock);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
in6_ifa_put(ifp);
|
|
|
|
addrconf_verify(0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
inet6_prefix_notify(RTM_NEWPREFIX, in6_dev, pinfo);
|
|
|
|
in6_dev_put(in6_dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set destination address.
|
|
|
|
* Special case for SIT interfaces where we create a new "virtual"
|
|
|
|
* device.
|
|
|
|
*/
|
2008-03-05 19:46:57 +01:00
|
|
|
int addrconf_set_dstaddr(struct net *net, void __user *arg)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct in6_ifreq ireq;
|
|
|
|
struct net_device *dev;
|
|
|
|
int err = -EINVAL;
|
|
|
|
|
|
|
|
rtnl_lock();
|
|
|
|
|
|
|
|
err = -EFAULT;
|
|
|
|
if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq)))
|
|
|
|
goto err_exit;
|
|
|
|
|
2008-03-05 19:46:57 +01:00
|
|
|
dev = __dev_get_by_index(net, ireq.ifr6_ifindex);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
err = -ENODEV;
|
|
|
|
if (dev == NULL)
|
|
|
|
goto err_exit;
|
|
|
|
|
2006-10-10 23:49:53 +02:00
|
|
|
#if defined(CONFIG_IPV6_SIT) || defined(CONFIG_IPV6_SIT_MODULE)
|
2005-04-17 00:20:36 +02:00
|
|
|
if (dev->type == ARPHRD_SIT) {
|
|
|
|
struct ifreq ifr;
|
|
|
|
mm_segment_t oldfs;
|
|
|
|
struct ip_tunnel_parm p;
|
|
|
|
|
|
|
|
err = -EADDRNOTAVAIL;
|
|
|
|
if (!(ipv6_addr_type(&ireq.ifr6_addr) & IPV6_ADDR_COMPATv4))
|
|
|
|
goto err_exit;
|
|
|
|
|
|
|
|
memset(&p, 0, sizeof(p));
|
|
|
|
p.iph.daddr = ireq.ifr6_addr.s6_addr32[3];
|
|
|
|
p.iph.saddr = 0;
|
|
|
|
p.iph.version = 4;
|
|
|
|
p.iph.ihl = 5;
|
|
|
|
p.iph.protocol = IPPROTO_IPV6;
|
|
|
|
p.iph.ttl = 64;
|
2008-01-21 09:48:43 +01:00
|
|
|
ifr.ifr_ifru.ifru_data = (__force void __user *)&p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
oldfs = get_fs(); set_fs(KERNEL_DS);
|
|
|
|
err = dev->do_ioctl(dev, &ifr, SIOCADDTUNNEL);
|
|
|
|
set_fs(oldfs);
|
|
|
|
|
|
|
|
if (err == 0) {
|
|
|
|
err = -ENOBUFS;
|
2008-03-05 19:46:57 +01:00
|
|
|
dev = __dev_get_by_name(net, p.name);
|
|
|
|
if (!dev)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto err_exit;
|
|
|
|
err = dev_open(dev);
|
|
|
|
}
|
|
|
|
}
|
2006-10-10 23:49:53 +02:00
|
|
|
#endif
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
err_exit:
|
|
|
|
rtnl_unlock();
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Manual configuration of address on an interface
|
|
|
|
*/
|
2008-03-05 19:46:57 +01:00
|
|
|
static int inet6_addr_add(struct net *net, int ifindex, struct in6_addr *pfx,
|
2008-05-28 16:54:22 +02:00
|
|
|
unsigned int plen, __u8 ifa_flags, __u32 prefered_lft,
|
2008-03-05 19:46:57 +01:00
|
|
|
__u32 valid_lft)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct inet6_ifaddr *ifp;
|
|
|
|
struct inet6_dev *idev;
|
|
|
|
struct net_device *dev;
|
|
|
|
int scope;
|
2008-05-20 01:56:11 +02:00
|
|
|
u32 flags;
|
|
|
|
clock_t expires;
|
2008-05-27 10:37:49 +02:00
|
|
|
unsigned long timeout;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
ASSERT_RTNL();
|
2007-02-09 15:24:49 +01:00
|
|
|
|
2008-05-28 16:54:22 +02:00
|
|
|
if (plen > 128)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2006-07-28 11:12:10 +02:00
|
|
|
/* check the lifetime */
|
|
|
|
if (!valid_lft || prefered_lft > valid_lft)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2008-03-05 19:46:57 +01:00
|
|
|
dev = __dev_get_by_index(net, ifindex);
|
|
|
|
if (!dev)
|
2005-04-17 00:20:36 +02:00
|
|
|
return -ENODEV;
|
2007-02-09 15:24:49 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
if ((idev = addrconf_add_dev(dev)) == NULL)
|
|
|
|
return -ENOBUFS;
|
|
|
|
|
|
|
|
scope = ipv6_addr_scope(pfx);
|
|
|
|
|
2008-05-27 10:37:49 +02:00
|
|
|
timeout = addrconf_timeout_fixup(valid_lft, HZ);
|
|
|
|
if (addrconf_finite_timeout(timeout)) {
|
|
|
|
expires = jiffies_to_clock_t(timeout * HZ);
|
|
|
|
valid_lft = timeout;
|
2008-05-20 01:56:11 +02:00
|
|
|
flags = RTF_EXPIRES;
|
2008-05-27 10:37:49 +02:00
|
|
|
} else {
|
|
|
|
expires = 0;
|
|
|
|
flags = 0;
|
|
|
|
ifa_flags |= IFA_F_PERMANENT;
|
2008-05-20 01:56:11 +02:00
|
|
|
}
|
2006-07-28 11:12:10 +02:00
|
|
|
|
2008-05-27 10:37:49 +02:00
|
|
|
timeout = addrconf_timeout_fixup(prefered_lft, HZ);
|
|
|
|
if (addrconf_finite_timeout(timeout)) {
|
|
|
|
if (timeout == 0)
|
|
|
|
ifa_flags |= IFA_F_DEPRECATED;
|
|
|
|
prefered_lft = timeout;
|
|
|
|
}
|
2006-07-28 11:12:10 +02:00
|
|
|
|
|
|
|
ifp = ipv6_add_addr(idev, pfx, plen, scope, ifa_flags);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!IS_ERR(ifp)) {
|
2006-08-10 01:52:04 +02:00
|
|
|
spin_lock_bh(&ifp->lock);
|
2006-07-28 11:12:10 +02:00
|
|
|
ifp->valid_lft = valid_lft;
|
|
|
|
ifp->prefered_lft = prefered_lft;
|
|
|
|
ifp->tstamp = jiffies;
|
2006-08-10 01:52:04 +02:00
|
|
|
spin_unlock_bh(&ifp->lock);
|
2006-07-28 11:12:10 +02:00
|
|
|
|
2007-02-07 12:36:26 +01:00
|
|
|
addrconf_prefix_route(&ifp->addr, ifp->prefix_len, dev,
|
2008-05-20 01:56:11 +02:00
|
|
|
expires, flags);
|
2007-04-26 02:08:10 +02:00
|
|
|
/*
|
|
|
|
* Note that section 3.1 of RFC 4429 indicates
|
|
|
|
* that the Optimistic flag should not be set for
|
|
|
|
* manually configured addresses
|
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
addrconf_dad_start(ifp, 0);
|
|
|
|
in6_ifa_put(ifp);
|
2006-07-28 11:12:10 +02:00
|
|
|
addrconf_verify(0);
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return PTR_ERR(ifp);
|
|
|
|
}
|
|
|
|
|
2008-03-05 19:46:57 +01:00
|
|
|
static int inet6_addr_del(struct net *net, int ifindex, struct in6_addr *pfx,
|
2008-05-28 16:54:22 +02:00
|
|
|
unsigned int plen)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct inet6_ifaddr *ifp;
|
|
|
|
struct inet6_dev *idev;
|
|
|
|
struct net_device *dev;
|
2007-02-09 15:24:49 +01:00
|
|
|
|
2008-05-28 16:54:22 +02:00
|
|
|
if (plen > 128)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2008-03-05 19:46:57 +01:00
|
|
|
dev = __dev_get_by_index(net, ifindex);
|
|
|
|
if (!dev)
|
2005-04-17 00:20:36 +02:00
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
if ((idev = __in6_dev_get(dev)) == NULL)
|
|
|
|
return -ENXIO;
|
|
|
|
|
|
|
|
read_lock_bh(&idev->lock);
|
|
|
|
for (ifp = idev->addr_list; ifp; ifp=ifp->if_next) {
|
|
|
|
if (ifp->prefix_len == plen &&
|
|
|
|
ipv6_addr_equal(pfx, &ifp->addr)) {
|
|
|
|
in6_ifa_hold(ifp);
|
|
|
|
read_unlock_bh(&idev->lock);
|
2007-02-09 15:24:49 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
ipv6_del_addr(ifp);
|
|
|
|
|
|
|
|
/* If the last address is deleted administratively,
|
|
|
|
disable IPv6 on this interface.
|
|
|
|
*/
|
|
|
|
if (idev->addr_list == NULL)
|
|
|
|
addrconf_ifdown(idev->dev, 1);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
read_unlock_bh(&idev->lock);
|
|
|
|
return -EADDRNOTAVAIL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-03-05 19:46:57 +01:00
|
|
|
int addrconf_add_ifaddr(struct net *net, void __user *arg)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct in6_ifreq ireq;
|
|
|
|
int err;
|
2007-02-09 15:24:49 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!capable(CAP_NET_ADMIN))
|
|
|
|
return -EPERM;
|
2007-02-09 15:24:49 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq)))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
rtnl_lock();
|
2008-03-05 19:46:57 +01:00
|
|
|
err = inet6_addr_add(net, ireq.ifr6_ifindex, &ireq.ifr6_addr,
|
|
|
|
ireq.ifr6_prefixlen, IFA_F_PERMANENT,
|
|
|
|
INFINITY_LIFE_TIME, INFINITY_LIFE_TIME);
|
2005-04-17 00:20:36 +02:00
|
|
|
rtnl_unlock();
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2008-03-05 19:46:57 +01:00
|
|
|
int addrconf_del_ifaddr(struct net *net, void __user *arg)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct in6_ifreq ireq;
|
|
|
|
int err;
|
2007-02-09 15:24:49 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!capable(CAP_NET_ADMIN))
|
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq)))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
rtnl_lock();
|
2008-03-05 19:46:57 +01:00
|
|
|
err = inet6_addr_del(net, ireq.ifr6_ifindex, &ireq.ifr6_addr,
|
|
|
|
ireq.ifr6_prefixlen);
|
2005-04-17 00:20:36 +02:00
|
|
|
rtnl_unlock();
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2006-10-10 23:49:53 +02:00
|
|
|
#if defined(CONFIG_IPV6_SIT) || defined(CONFIG_IPV6_SIT_MODULE)
|
2005-04-17 00:20:36 +02:00
|
|
|
static void sit_add_v4_addrs(struct inet6_dev *idev)
|
|
|
|
{
|
|
|
|
struct inet6_ifaddr * ifp;
|
|
|
|
struct in6_addr addr;
|
|
|
|
struct net_device *dev;
|
2008-03-25 13:47:49 +01:00
|
|
|
struct net *net = dev_net(idev->dev);
|
2005-04-17 00:20:36 +02:00
|
|
|
int scope;
|
|
|
|
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
|
|
|
memset(&addr, 0, sizeof(struct in6_addr));
|
|
|
|
memcpy(&addr.s6_addr32[3], idev->dev->dev_addr, 4);
|
|
|
|
|
|
|
|
if (idev->dev->flags&IFF_POINTOPOINT) {
|
|
|
|
addr.s6_addr32[0] = htonl(0xfe800000);
|
|
|
|
scope = IFA_LINK;
|
|
|
|
} else {
|
|
|
|
scope = IPV6_ADDR_COMPATv4;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (addr.s6_addr32[3]) {
|
|
|
|
ifp = ipv6_add_addr(idev, &addr, 128, scope, IFA_F_PERMANENT);
|
|
|
|
if (!IS_ERR(ifp)) {
|
|
|
|
spin_lock_bh(&ifp->lock);
|
|
|
|
ifp->flags &= ~IFA_F_TENTATIVE;
|
|
|
|
spin_unlock_bh(&ifp->lock);
|
|
|
|
ipv6_ifa_notify(RTM_NEWADDR, ifp);
|
|
|
|
in6_ifa_put(ifp);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-03-05 19:47:47 +01:00
|
|
|
for_each_netdev(net, dev) {
|
2005-10-03 23:35:55 +02:00
|
|
|
struct in_device * in_dev = __in_dev_get_rtnl(dev);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (in_dev && (dev->flags & IFF_UP)) {
|
|
|
|
struct in_ifaddr * ifa;
|
|
|
|
|
|
|
|
int flag = scope;
|
|
|
|
|
|
|
|
for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
|
|
|
|
int plen;
|
|
|
|
|
|
|
|
addr.s6_addr32[3] = ifa->ifa_local;
|
|
|
|
|
|
|
|
if (ifa->ifa_scope == RT_SCOPE_LINK)
|
|
|
|
continue;
|
|
|
|
if (ifa->ifa_scope >= RT_SCOPE_HOST) {
|
|
|
|
if (idev->dev->flags&IFF_POINTOPOINT)
|
|
|
|
continue;
|
|
|
|
flag |= IFA_HOST;
|
|
|
|
}
|
|
|
|
if (idev->dev->flags&IFF_POINTOPOINT)
|
|
|
|
plen = 64;
|
|
|
|
else
|
|
|
|
plen = 96;
|
|
|
|
|
|
|
|
ifp = ipv6_add_addr(idev, &addr, plen, flag,
|
|
|
|
IFA_F_PERMANENT);
|
|
|
|
if (!IS_ERR(ifp)) {
|
|
|
|
spin_lock_bh(&ifp->lock);
|
|
|
|
ifp->flags &= ~IFA_F_TENTATIVE;
|
|
|
|
spin_unlock_bh(&ifp->lock);
|
|
|
|
ipv6_ifa_notify(RTM_NEWADDR, ifp);
|
|
|
|
in6_ifa_put(ifp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2007-02-09 15:24:49 +01:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2006-10-10 23:49:53 +02:00
|
|
|
#endif
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
static void init_loopback(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct inet6_dev *idev;
|
|
|
|
struct inet6_ifaddr * ifp;
|
|
|
|
|
|
|
|
/* ::1 */
|
|
|
|
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
|
|
|
if ((idev = ipv6_find_idev(dev)) == NULL) {
|
|
|
|
printk(KERN_DEBUG "init loopback: add_dev failed\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
ifp = ipv6_add_addr(idev, &in6addr_loopback, 128, IFA_HOST, IFA_F_PERMANENT);
|
|
|
|
if (!IS_ERR(ifp)) {
|
|
|
|
spin_lock_bh(&ifp->lock);
|
|
|
|
ifp->flags &= ~IFA_F_TENTATIVE;
|
|
|
|
spin_unlock_bh(&ifp->lock);
|
|
|
|
ipv6_ifa_notify(RTM_NEWADDR, ifp);
|
|
|
|
in6_ifa_put(ifp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void addrconf_add_linklocal(struct inet6_dev *idev, struct in6_addr *addr)
|
|
|
|
{
|
|
|
|
struct inet6_ifaddr * ifp;
|
2007-04-26 02:08:10 +02:00
|
|
|
u32 addr_flags = IFA_F_PERMANENT;
|
|
|
|
|
|
|
|
#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
|
|
|
|
if (idev->cnf.optimistic_dad &&
|
2008-07-21 03:17:02 +02:00
|
|
|
!dev_net(idev->dev)->ipv6.devconf_all->forwarding)
|
2007-04-26 02:08:10 +02:00
|
|
|
addr_flags |= IFA_F_OPTIMISTIC;
|
|
|
|
#endif
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-04-26 02:08:10 +02:00
|
|
|
|
|
|
|
ifp = ipv6_add_addr(idev, addr, 64, IFA_LINK, addr_flags);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!IS_ERR(ifp)) {
|
2007-02-07 12:36:26 +01:00
|
|
|
addrconf_prefix_route(&ifp->addr, ifp->prefix_len, idev->dev, 0, 0);
|
2005-04-17 00:20:36 +02:00
|
|
|
addrconf_dad_start(ifp, 0);
|
|
|
|
in6_ifa_put(ifp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void addrconf_dev_config(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct in6_addr addr;
|
|
|
|
struct inet6_dev * idev;
|
|
|
|
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
2007-06-14 22:02:55 +02:00
|
|
|
if ((dev->type != ARPHRD_ETHER) &&
|
|
|
|
(dev->type != ARPHRD_FDDI) &&
|
|
|
|
(dev->type != ARPHRD_IEEE802_TR) &&
|
|
|
|
(dev->type != ARPHRD_ARCNET) &&
|
|
|
|
(dev->type != ARPHRD_INFINIBAND)) {
|
|
|
|
/* Alas, we support only Ethernet autoconfiguration. */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
idev = addrconf_add_dev(dev);
|
|
|
|
if (idev == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
memset(&addr, 0, sizeof(struct in6_addr));
|
|
|
|
addr.s6_addr32[0] = htonl(0xFE800000);
|
|
|
|
|
|
|
|
if (ipv6_generate_eui64(addr.s6_addr + 8, dev) == 0)
|
|
|
|
addrconf_add_linklocal(idev, &addr);
|
|
|
|
}
|
|
|
|
|
2006-10-10 23:49:53 +02:00
|
|
|
#if defined(CONFIG_IPV6_SIT) || defined(CONFIG_IPV6_SIT_MODULE)
|
2005-04-17 00:20:36 +02:00
|
|
|
static void addrconf_sit_config(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct inet6_dev *idev;
|
|
|
|
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
2007-02-09 15:24:49 +01:00
|
|
|
/*
|
|
|
|
* Configure the tunnel with one of our IPv4
|
|
|
|
* addresses... we should configure all of
|
2005-04-17 00:20:36 +02:00
|
|
|
* our v4 addrs in the tunnel
|
|
|
|
*/
|
|
|
|
|
|
|
|
if ((idev = ipv6_find_idev(dev)) == NULL) {
|
|
|
|
printk(KERN_DEBUG "init sit: add_dev failed\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2007-11-29 12:11:40 +01:00
|
|
|
if (dev->priv_flags & IFF_ISATAP) {
|
|
|
|
struct in6_addr addr;
|
|
|
|
|
|
|
|
ipv6_addr_set(&addr, htonl(0xFE800000), 0, 0, 0);
|
|
|
|
addrconf_prefix_route(&addr, 64, dev, 0, 0);
|
|
|
|
if (!ipv6_generate_eui64(addr.s6_addr + 8, dev))
|
|
|
|
addrconf_add_linklocal(idev, &addr);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
sit_add_v4_addrs(idev);
|
|
|
|
|
|
|
|
if (dev->flags&IFF_POINTOPOINT) {
|
|
|
|
addrconf_add_mroute(dev);
|
|
|
|
addrconf_add_lroute(dev);
|
|
|
|
} else
|
|
|
|
sit_route_add(dev);
|
|
|
|
}
|
2006-10-10 23:49:53 +02:00
|
|
|
#endif
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
static inline int
|
|
|
|
ipv6_inherit_linklocal(struct inet6_dev *idev, struct net_device *link_dev)
|
|
|
|
{
|
|
|
|
struct in6_addr lladdr;
|
|
|
|
|
2007-04-26 02:08:10 +02:00
|
|
|
if (!ipv6_get_lladdr(link_dev, &lladdr, IFA_F_TENTATIVE)) {
|
2005-04-17 00:20:36 +02:00
|
|
|
addrconf_add_linklocal(idev, &lladdr);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ip6_tnl_add_linklocal(struct inet6_dev *idev)
|
|
|
|
{
|
|
|
|
struct net_device *link_dev;
|
2008-03-25 13:47:49 +01:00
|
|
|
struct net *net = dev_net(idev->dev);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* first try to inherit the link-local address from the link device */
|
|
|
|
if (idev->dev->iflink &&
|
2008-03-05 19:47:47 +01:00
|
|
|
(link_dev = __dev_get_by_index(net, idev->dev->iflink))) {
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!ipv6_inherit_linklocal(idev, link_dev))
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* then try to inherit it from any device */
|
2008-03-05 19:47:47 +01:00
|
|
|
for_each_netdev(net, link_dev) {
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!ipv6_inherit_linklocal(idev, link_dev))
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
printk(KERN_DEBUG "init ip6-ip6: add_linklocal failed\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Autoconfigure tunnel with a link-local address so routing protocols,
|
|
|
|
* DHCPv6, MLD etc. can be run over the virtual link
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void addrconf_ip6_tnl_config(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct inet6_dev *idev;
|
|
|
|
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
|
|
|
if ((idev = addrconf_add_dev(dev)) == NULL) {
|
|
|
|
printk(KERN_DEBUG "init ip6-ip6: add_dev failed\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
ip6_tnl_add_linklocal(idev);
|
|
|
|
}
|
|
|
|
|
2007-02-09 15:24:49 +01:00
|
|
|
static int addrconf_notify(struct notifier_block *this, unsigned long event,
|
2005-04-17 00:20:36 +02:00
|
|
|
void * data)
|
|
|
|
{
|
|
|
|
struct net_device *dev = (struct net_device *) data;
|
2007-06-14 22:02:55 +02:00
|
|
|
struct inet6_dev *idev = __in6_dev_get(dev);
|
2005-12-21 14:57:44 +01:00
|
|
|
int run_pending = 0;
|
2007-07-31 02:04:52 +02:00
|
|
|
int err;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
switch(event) {
|
2007-02-14 18:07:27 +01:00
|
|
|
case NETDEV_REGISTER:
|
2007-06-14 22:02:55 +02:00
|
|
|
if (!idev && dev->mtu >= IPV6_MIN_MTU) {
|
2007-02-14 18:07:27 +01:00
|
|
|
idev = ipv6_add_dev(dev);
|
|
|
|
if (!idev)
|
2007-07-31 02:04:52 +02:00
|
|
|
return notifier_from_errno(-ENOMEM);
|
2007-02-14 18:07:27 +01:00
|
|
|
}
|
|
|
|
break;
|
2005-04-17 00:20:36 +02:00
|
|
|
case NETDEV_UP:
|
2005-12-21 14:57:24 +01:00
|
|
|
case NETDEV_CHANGE:
|
bonding / ipv6: no addrconf for slaves separately from master
At present, when a device is enslaved to bonding, if ipv6 is
active then addrconf will be initated on the slave (because it is closed
then opened during the enslavement processing). This causes DAD and RS
packets to be sent from the slave. These packets in turn can confuse
switches that perform ipv6 snooping, causing them to incorrectly update
their forwarding tables (if, e.g., the slave being added is an inactve
backup that won't be used right away) and direct traffic away from the
active slave to a backup slave (where the incoming packets will be
dropped).
This patch alters the behavior so that addrconf will only run on
the master device itself. I believe this is logically correct, as it
prevents slaves from having an IPv6 identity independent from the
master. This is consistent with the IPv4 behavior for bonding.
This is accomplished by (a) having bonding set IFF_SLAVE sooner
in the enslavement processing than currently occurs (before open, not
after), and (b) having ipv6 addrconf ignore UP and CHANGE events on
slave devices.
The eql driver also uses the IFF_SLAVE flag. I inspected eql,
and I believe this change is reasonable for its usage of IFF_SLAVE, but
I did not test it.
Signed-off-by: Jay Vosburgh <fubar@us.ibm.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-07-09 19:42:47 +02:00
|
|
|
if (dev->flags & IFF_SLAVE)
|
|
|
|
break;
|
|
|
|
|
2005-12-21 14:57:24 +01:00
|
|
|
if (event == NETDEV_UP) {
|
2007-10-10 11:53:43 +02:00
|
|
|
if (!addrconf_qdisc_ok(dev)) {
|
2005-12-21 14:57:24 +01:00
|
|
|
/* device is not ready yet. */
|
|
|
|
printk(KERN_INFO
|
|
|
|
"ADDRCONF(NETDEV_UP): %s: "
|
|
|
|
"link is not ready\n",
|
|
|
|
dev->name);
|
|
|
|
break;
|
|
|
|
}
|
2006-02-09 01:10:53 +01:00
|
|
|
|
2007-11-30 13:36:08 +01:00
|
|
|
if (!idev && dev->mtu >= IPV6_MIN_MTU)
|
|
|
|
idev = ipv6_add_dev(dev);
|
|
|
|
|
ipv6: fix run pending DAD when interface becomes ready
With some net devices types, an IPv6 address configured while the
interface was down can stay 'tentative' forever, even after the interface
is set up. In some case, pending IPv6 DADs are not executed when the
device becomes ready.
I observed this while doing some tests with kvm. If I assign an IPv6
address to my interface eth0 (kvm driver rtl8139) when it is still down
then the address is flagged tentative (IFA_F_TENTATIVE). Then, I set
eth0 up, and to my surprise, the address stays 'tentative', no DAD is
executed and the address can't be pinged.
I also observed the same behaviour, without kvm, with virtual interfaces
types macvlan and veth.
Some easy steps to reproduce the issue with macvlan:
1. ip link add link eth0 type macvlan
2. ip -6 addr add 2003::ab32/64 dev macvlan0
3. ip addr show dev macvlan0
...
inet6 2003::ab32/64 scope global tentative
...
4. ip link set macvlan0 up
5. ip addr show dev macvlan0
...
inet6 2003::ab32/64 scope global tentative
...
Address is still tentative
I think there's a bug in net/ipv6/addrconf.c, addrconf_notify():
addrconf_dad_run() is not always run when the interface is flagged IF_READY.
Currently it is only run when receiving NETDEV_CHANGE event. Looks like
some (virtual) devices doesn't send this event when becoming up.
For both NETDEV_UP and NETDEV_CHANGE events, when the interface becomes
ready, run_pending should be set to 1. Patch below.
'run_pending = 1' could be moved below the if/else block but it makes
the code less readable.
Signed-off-by: Benjamin Thery <benjamin.thery@bull.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2008-11-05 10:43:57 +01:00
|
|
|
if (idev) {
|
2006-02-09 01:10:53 +01:00
|
|
|
idev->if_flags |= IF_READY;
|
ipv6: fix run pending DAD when interface becomes ready
With some net devices types, an IPv6 address configured while the
interface was down can stay 'tentative' forever, even after the interface
is set up. In some case, pending IPv6 DADs are not executed when the
device becomes ready.
I observed this while doing some tests with kvm. If I assign an IPv6
address to my interface eth0 (kvm driver rtl8139) when it is still down
then the address is flagged tentative (IFA_F_TENTATIVE). Then, I set
eth0 up, and to my surprise, the address stays 'tentative', no DAD is
executed and the address can't be pinged.
I also observed the same behaviour, without kvm, with virtual interfaces
types macvlan and veth.
Some easy steps to reproduce the issue with macvlan:
1. ip link add link eth0 type macvlan
2. ip -6 addr add 2003::ab32/64 dev macvlan0
3. ip addr show dev macvlan0
...
inet6 2003::ab32/64 scope global tentative
...
4. ip link set macvlan0 up
5. ip addr show dev macvlan0
...
inet6 2003::ab32/64 scope global tentative
...
Address is still tentative
I think there's a bug in net/ipv6/addrconf.c, addrconf_notify():
addrconf_dad_run() is not always run when the interface is flagged IF_READY.
Currently it is only run when receiving NETDEV_CHANGE event. Looks like
some (virtual) devices doesn't send this event when becoming up.
For both NETDEV_UP and NETDEV_CHANGE events, when the interface becomes
ready, run_pending should be set to 1. Patch below.
'run_pending = 1' could be moved below the if/else block but it makes
the code less readable.
Signed-off-by: Benjamin Thery <benjamin.thery@bull.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2008-11-05 10:43:57 +01:00
|
|
|
run_pending = 1;
|
|
|
|
}
|
2005-12-21 14:57:24 +01:00
|
|
|
} else {
|
2007-10-10 11:53:43 +02:00
|
|
|
if (!addrconf_qdisc_ok(dev)) {
|
2005-12-21 14:57:24 +01:00
|
|
|
/* device is still not ready. */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (idev) {
|
|
|
|
if (idev->if_flags & IF_READY) {
|
|
|
|
/* device is already configured. */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
idev->if_flags |= IF_READY;
|
|
|
|
}
|
|
|
|
|
|
|
|
printk(KERN_INFO
|
|
|
|
"ADDRCONF(NETDEV_CHANGE): %s: "
|
|
|
|
"link becomes ready\n",
|
|
|
|
dev->name);
|
|
|
|
|
2005-12-21 14:57:44 +01:00
|
|
|
run_pending = 1;
|
2005-12-21 14:57:24 +01:00
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
switch(dev->type) {
|
2006-10-10 23:49:53 +02:00
|
|
|
#if defined(CONFIG_IPV6_SIT) || defined(CONFIG_IPV6_SIT_MODULE)
|
2005-04-17 00:20:36 +02:00
|
|
|
case ARPHRD_SIT:
|
|
|
|
addrconf_sit_config(dev);
|
|
|
|
break;
|
2006-10-10 23:49:53 +02:00
|
|
|
#endif
|
2005-04-17 00:20:36 +02:00
|
|
|
case ARPHRD_TUNNEL6:
|
|
|
|
addrconf_ip6_tnl_config(dev);
|
|
|
|
break;
|
|
|
|
case ARPHRD_LOOPBACK:
|
|
|
|
init_loopback(dev);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
addrconf_dev_config(dev);
|
|
|
|
break;
|
2007-04-21 02:09:22 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
if (idev) {
|
2005-12-21 14:57:44 +01:00
|
|
|
if (run_pending)
|
|
|
|
addrconf_dad_run(idev);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* If the MTU changed during the interface down, when the
|
|
|
|
interface up, the changed MTU must be reflected in the
|
|
|
|
idev as well as routers.
|
|
|
|
*/
|
|
|
|
if (idev->cnf.mtu6 != dev->mtu && dev->mtu >= IPV6_MIN_MTU) {
|
|
|
|
rt6_mtu_change(dev, dev->mtu);
|
|
|
|
idev->cnf.mtu6 = dev->mtu;
|
|
|
|
}
|
|
|
|
idev->tstamp = jiffies;
|
|
|
|
inet6_ifinfo_notify(RTM_NEWLINK, idev);
|
|
|
|
/* If the changed mtu during down is lower than IPV6_MIN_MTU
|
|
|
|
stop IPv6 on this interface.
|
|
|
|
*/
|
|
|
|
if (dev->mtu < IPV6_MIN_MTU)
|
|
|
|
addrconf_ifdown(dev, event != NETDEV_DOWN);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case NETDEV_CHANGEMTU:
|
2007-11-30 13:36:08 +01:00
|
|
|
if (idev && dev->mtu >= IPV6_MIN_MTU) {
|
2005-04-17 00:20:36 +02:00
|
|
|
rt6_mtu_change(dev, dev->mtu);
|
|
|
|
idev->cnf.mtu6 = dev->mtu;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2007-11-30 13:36:08 +01:00
|
|
|
if (!idev && dev->mtu >= IPV6_MIN_MTU) {
|
|
|
|
idev = ipv6_add_dev(dev);
|
|
|
|
if (idev)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* MTU falled under IPV6_MIN_MTU. Stop IPv6 on this interface. */
|
|
|
|
|
|
|
|
case NETDEV_DOWN:
|
|
|
|
case NETDEV_UNREGISTER:
|
|
|
|
/*
|
|
|
|
* Remove all addresses from this interface.
|
|
|
|
*/
|
|
|
|
addrconf_ifdown(dev, event != NETDEV_DOWN);
|
|
|
|
break;
|
2005-12-21 14:57:24 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
case NETDEV_CHANGENAME:
|
|
|
|
if (idev) {
|
2007-04-29 06:16:39 +02:00
|
|
|
snmp6_unregister_dev(idev);
|
2008-01-11 02:41:21 +01:00
|
|
|
addrconf_sysctl_unregister(idev);
|
2007-12-01 14:58:37 +01:00
|
|
|
addrconf_sysctl_register(idev);
|
2007-07-31 02:04:52 +02:00
|
|
|
err = snmp6_register_dev(idev);
|
|
|
|
if (err)
|
|
|
|
return notifier_from_errno(err);
|
2007-04-29 06:16:39 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
2007-04-21 02:09:22 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
return NOTIFY_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* addrconf module should be notified of a device going up
|
|
|
|
*/
|
|
|
|
static struct notifier_block ipv6_dev_notf = {
|
|
|
|
.notifier_call = addrconf_notify,
|
|
|
|
.priority = 0
|
|
|
|
};
|
|
|
|
|
|
|
|
static int addrconf_ifdown(struct net_device *dev, int how)
|
|
|
|
{
|
|
|
|
struct inet6_dev *idev;
|
|
|
|
struct inet6_ifaddr *ifa, **bifa;
|
2008-03-25 13:47:49 +01:00
|
|
|
struct net *net = dev_net(dev);
|
2005-04-17 00:20:36 +02:00
|
|
|
int i;
|
|
|
|
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
2008-04-03 22:31:53 +02:00
|
|
|
if ((dev->flags & IFF_LOOPBACK) && how == 1)
|
2005-04-17 00:20:36 +02:00
|
|
|
how = 0;
|
|
|
|
|
2008-03-04 08:27:06 +01:00
|
|
|
rt6_ifdown(net, dev);
|
2005-04-17 00:20:36 +02:00
|
|
|
neigh_ifdown(&nd_tbl, dev);
|
|
|
|
|
|
|
|
idev = __in6_dev_get(dev);
|
|
|
|
if (idev == NULL)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
/* Step 1: remove reference to ipv6 device from parent device.
|
2007-02-09 15:24:49 +01:00
|
|
|
Do not dev_put!
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2008-04-03 22:30:17 +02:00
|
|
|
if (how) {
|
2005-04-17 00:20:36 +02:00
|
|
|
idev->dead = 1;
|
2006-09-22 23:44:24 +02:00
|
|
|
|
|
|
|
/* protected by rtnl_lock */
|
|
|
|
rcu_assign_pointer(dev->ip6_ptr, NULL);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* Step 1.5: remove snmp6 entry */
|
|
|
|
snmp6_unregister_dev(idev);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Step 2: clear hash table */
|
|
|
|
for (i=0; i<IN6_ADDR_HSIZE; i++) {
|
|
|
|
bifa = &inet6_addr_lst[i];
|
|
|
|
|
|
|
|
write_lock_bh(&addrconf_hash_lock);
|
|
|
|
while ((ifa = *bifa) != NULL) {
|
|
|
|
if (ifa->idev == idev) {
|
|
|
|
*bifa = ifa->lst_next;
|
|
|
|
ifa->lst_next = NULL;
|
|
|
|
addrconf_del_timer(ifa);
|
|
|
|
in6_ifa_put(ifa);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
bifa = &ifa->lst_next;
|
|
|
|
}
|
|
|
|
write_unlock_bh(&addrconf_hash_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
write_lock_bh(&idev->lock);
|
|
|
|
|
|
|
|
/* Step 3: clear flags for stateless addrconf */
|
2008-04-03 22:30:17 +02:00
|
|
|
if (!how)
|
2005-12-21 14:57:24 +01:00
|
|
|
idev->if_flags &= ~(IF_RS_SENT|IF_RA_RCVD|IF_READY);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* Step 4: clear address list */
|
|
|
|
#ifdef CONFIG_IPV6_PRIVACY
|
2008-04-03 22:30:17 +02:00
|
|
|
if (how && del_timer(&idev->regen_timer))
|
2005-04-17 00:20:36 +02:00
|
|
|
in6_dev_put(idev);
|
|
|
|
|
|
|
|
/* clear tempaddr list */
|
|
|
|
while ((ifa = idev->tempaddr_list) != NULL) {
|
|
|
|
idev->tempaddr_list = ifa->tmp_next;
|
|
|
|
ifa->tmp_next = NULL;
|
|
|
|
ifa->dead = 1;
|
|
|
|
write_unlock_bh(&idev->lock);
|
|
|
|
spin_lock_bh(&ifa->lock);
|
|
|
|
|
|
|
|
if (ifa->ifpub) {
|
|
|
|
in6_ifa_put(ifa->ifpub);
|
|
|
|
ifa->ifpub = NULL;
|
|
|
|
}
|
|
|
|
spin_unlock_bh(&ifa->lock);
|
|
|
|
in6_ifa_put(ifa);
|
|
|
|
write_lock_bh(&idev->lock);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
while ((ifa = idev->addr_list) != NULL) {
|
|
|
|
idev->addr_list = ifa->if_next;
|
|
|
|
ifa->if_next = NULL;
|
|
|
|
ifa->dead = 1;
|
|
|
|
addrconf_del_timer(ifa);
|
|
|
|
write_unlock_bh(&idev->lock);
|
|
|
|
|
|
|
|
__ipv6_ifa_notify(RTM_DELADDR, ifa);
|
2007-07-15 09:16:35 +02:00
|
|
|
atomic_notifier_call_chain(&inet6addr_chain, NETDEV_DOWN, ifa);
|
2005-04-17 00:20:36 +02:00
|
|
|
in6_ifa_put(ifa);
|
|
|
|
|
|
|
|
write_lock_bh(&idev->lock);
|
|
|
|
}
|
|
|
|
write_unlock_bh(&idev->lock);
|
|
|
|
|
|
|
|
/* Step 5: Discard multicast list */
|
|
|
|
|
2008-04-03 22:30:17 +02:00
|
|
|
if (how)
|
2005-04-17 00:20:36 +02:00
|
|
|
ipv6_mc_destroy_dev(idev);
|
|
|
|
else
|
|
|
|
ipv6_mc_down(idev);
|
|
|
|
|
|
|
|
idev->tstamp = jiffies;
|
2007-02-09 15:24:49 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* Shot the device (if unregistered) */
|
|
|
|
|
2008-04-03 22:30:17 +02:00
|
|
|
if (how) {
|
2008-01-11 02:41:21 +01:00
|
|
|
addrconf_sysctl_unregister(idev);
|
2005-04-17 00:20:36 +02:00
|
|
|
neigh_parms_release(&nd_tbl, idev->nd_parms);
|
|
|
|
neigh_ifdown(&nd_tbl, dev);
|
|
|
|
in6_dev_put(idev);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void addrconf_rs_timer(unsigned long data)
|
|
|
|
{
|
|
|
|
struct inet6_ifaddr *ifp = (struct inet6_ifaddr *) data;
|
|
|
|
|
|
|
|
if (ifp->idev->cnf.forwarding)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (ifp->idev->if_flags & IF_RA_RCVD) {
|
|
|
|
/*
|
|
|
|
* Announcement received after solicitation
|
|
|
|
* was sent
|
|
|
|
*/
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock(&ifp->lock);
|
|
|
|
if (ifp->probes++ < ifp->idev->cnf.rtr_solicits) {
|
|
|
|
/* The wait after the last probe can be shorter */
|
|
|
|
addrconf_mod_timer(ifp, AC_RS,
|
|
|
|
(ifp->probes == ifp->idev->cnf.rtr_solicits) ?
|
|
|
|
ifp->idev->cnf.rtr_solicit_delay :
|
|
|
|
ifp->idev->cnf.rtr_solicit_interval);
|
|
|
|
spin_unlock(&ifp->lock);
|
|
|
|
|
2008-04-10 08:42:11 +02:00
|
|
|
ndisc_send_rs(ifp->idev->dev, &ifp->addr, &in6addr_linklocal_allrouters);
|
2005-04-17 00:20:36 +02:00
|
|
|
} else {
|
|
|
|
spin_unlock(&ifp->lock);
|
|
|
|
/*
|
|
|
|
* Note: we do not support deprecated "all on-link"
|
|
|
|
* assumption any longer.
|
|
|
|
*/
|
|
|
|
printk(KERN_DEBUG "%s: no IPv6 routers present\n",
|
|
|
|
ifp->idev->dev->name);
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
in6_ifa_put(ifp);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Duplicate Address Detection
|
|
|
|
*/
|
2005-12-21 14:57:24 +01:00
|
|
|
static void addrconf_dad_kick(struct inet6_ifaddr *ifp)
|
|
|
|
{
|
|
|
|
unsigned long rand_num;
|
|
|
|
struct inet6_dev *idev = ifp->idev;
|
|
|
|
|
2007-04-26 02:08:10 +02:00
|
|
|
if (ifp->flags & IFA_F_OPTIMISTIC)
|
|
|
|
rand_num = 0;
|
|
|
|
else
|
|
|
|
rand_num = net_random() % (idev->cnf.rtr_solicit_delay ? : 1);
|
|
|
|
|
2005-12-21 14:57:24 +01:00
|
|
|
ifp->probes = idev->cnf.dad_transmits;
|
|
|
|
addrconf_mod_timer(ifp, AC_DAD, rand_num);
|
|
|
|
}
|
|
|
|
|
2005-06-19 07:55:31 +02:00
|
|
|
static void addrconf_dad_start(struct inet6_ifaddr *ifp, u32 flags)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct inet6_dev *idev = ifp->idev;
|
|
|
|
struct net_device *dev = idev->dev;
|
|
|
|
|
|
|
|
addrconf_join_solict(dev, &ifp->addr);
|
|
|
|
|
|
|
|
net_srandom(ifp->addr.s6_addr32[3]);
|
|
|
|
|
|
|
|
read_lock_bh(&idev->lock);
|
|
|
|
if (ifp->dead)
|
|
|
|
goto out;
|
|
|
|
spin_lock_bh(&ifp->lock);
|
|
|
|
|
|
|
|
if (dev->flags&(IFF_NOARP|IFF_LOOPBACK) ||
|
2008-06-28 07:18:38 +02:00
|
|
|
idev->cnf.accept_dad < 1 ||
|
2006-09-22 23:45:27 +02:00
|
|
|
!(ifp->flags&IFA_F_TENTATIVE) ||
|
|
|
|
ifp->flags & IFA_F_NODAD) {
|
2007-04-26 02:08:10 +02:00
|
|
|
ifp->flags &= ~(IFA_F_TENTATIVE|IFA_F_OPTIMISTIC);
|
2005-04-17 00:20:36 +02:00
|
|
|
spin_unlock_bh(&ifp->lock);
|
|
|
|
read_unlock_bh(&idev->lock);
|
|
|
|
|
|
|
|
addrconf_dad_completed(ifp);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2005-12-27 22:35:15 +01:00
|
|
|
if (!(idev->if_flags & IF_READY)) {
|
2005-12-23 20:23:21 +01:00
|
|
|
spin_unlock_bh(&ifp->lock);
|
2005-12-27 22:35:15 +01:00
|
|
|
read_unlock_bh(&idev->lock);
|
2005-12-21 14:57:24 +01:00
|
|
|
/*
|
|
|
|
* If the defice is not ready:
|
|
|
|
* - keep it tentative if it is a permanent address.
|
|
|
|
* - otherwise, kill it.
|
|
|
|
*/
|
|
|
|
in6_ifa_hold(ifp);
|
|
|
|
addrconf_dad_stop(ifp);
|
2005-12-27 22:35:15 +01:00
|
|
|
return;
|
2005-12-21 14:57:24 +01:00
|
|
|
}
|
2007-04-26 02:08:10 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Optimistic nodes can start receiving
|
|
|
|
* Frames right away
|
|
|
|
*/
|
|
|
|
if(ifp->flags & IFA_F_OPTIMISTIC)
|
|
|
|
ip6_ins_rt(ifp->rt);
|
|
|
|
|
2005-12-27 22:35:15 +01:00
|
|
|
addrconf_dad_kick(ifp);
|
|
|
|
spin_unlock_bh(&ifp->lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
out:
|
|
|
|
read_unlock_bh(&idev->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void addrconf_dad_timer(unsigned long data)
|
|
|
|
{
|
|
|
|
struct inet6_ifaddr *ifp = (struct inet6_ifaddr *) data;
|
|
|
|
struct inet6_dev *idev = ifp->idev;
|
|
|
|
struct in6_addr mcaddr;
|
|
|
|
|
|
|
|
read_lock_bh(&idev->lock);
|
|
|
|
if (idev->dead) {
|
|
|
|
read_unlock_bh(&idev->lock);
|
|
|
|
goto out;
|
|
|
|
}
|
2008-06-28 07:18:38 +02:00
|
|
|
if (idev->cnf.accept_dad > 1 && idev->cnf.disable_ipv6) {
|
|
|
|
read_unlock_bh(&idev->lock);
|
|
|
|
addrconf_dad_failure(ifp);
|
|
|
|
return;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
spin_lock_bh(&ifp->lock);
|
|
|
|
if (ifp->probes == 0) {
|
|
|
|
/*
|
|
|
|
* DAD was successful
|
|
|
|
*/
|
|
|
|
|
2007-04-26 02:08:10 +02:00
|
|
|
ifp->flags &= ~(IFA_F_TENTATIVE|IFA_F_OPTIMISTIC);
|
2005-04-17 00:20:36 +02:00
|
|
|
spin_unlock_bh(&ifp->lock);
|
|
|
|
read_unlock_bh(&idev->lock);
|
|
|
|
|
|
|
|
addrconf_dad_completed(ifp);
|
|
|
|
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
ifp->probes--;
|
|
|
|
addrconf_mod_timer(ifp, AC_DAD, ifp->idev->nd_parms->retrans_time);
|
|
|
|
spin_unlock_bh(&ifp->lock);
|
|
|
|
read_unlock_bh(&idev->lock);
|
|
|
|
|
|
|
|
/* send a neighbour solicitation for our addr */
|
|
|
|
addrconf_addr_solict_mult(&ifp->addr, &mcaddr);
|
2008-04-10 08:42:11 +02:00
|
|
|
ndisc_send_ns(ifp->idev->dev, NULL, &ifp->addr, &mcaddr, &in6addr_any);
|
2005-04-17 00:20:36 +02:00
|
|
|
out:
|
|
|
|
in6_ifa_put(ifp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void addrconf_dad_completed(struct inet6_ifaddr *ifp)
|
|
|
|
{
|
|
|
|
struct net_device * dev = ifp->idev->dev;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Configure the address for reception. Now it is valid.
|
|
|
|
*/
|
|
|
|
|
|
|
|
ipv6_ifa_notify(RTM_NEWADDR, ifp);
|
|
|
|
|
|
|
|
/* If added prefix is link local and forwarding is off,
|
|
|
|
start sending router solicitations.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (ifp->idev->cnf.forwarding == 0 &&
|
|
|
|
ifp->idev->cnf.rtr_solicits > 0 &&
|
|
|
|
(dev->flags&IFF_LOOPBACK) == 0 &&
|
|
|
|
(ipv6_addr_type(&ifp->addr) & IPV6_ADDR_LINKLOCAL)) {
|
|
|
|
/*
|
|
|
|
* If a host as already performed a random delay
|
|
|
|
* [...] as part of DAD [...] there is no need
|
|
|
|
* to delay again before sending the first RS
|
|
|
|
*/
|
2008-04-10 08:42:11 +02:00
|
|
|
ndisc_send_rs(ifp->idev->dev, &ifp->addr, &in6addr_linklocal_allrouters);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
spin_lock_bh(&ifp->lock);
|
|
|
|
ifp->probes = 1;
|
|
|
|
ifp->idev->if_flags |= IF_RS_SENT;
|
|
|
|
addrconf_mod_timer(ifp, AC_RS, ifp->idev->cnf.rtr_solicit_interval);
|
|
|
|
spin_unlock_bh(&ifp->lock);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-12-21 14:57:44 +01:00
|
|
|
static void addrconf_dad_run(struct inet6_dev *idev) {
|
|
|
|
struct inet6_ifaddr *ifp;
|
|
|
|
|
|
|
|
read_lock_bh(&idev->lock);
|
|
|
|
for (ifp = idev->addr_list; ifp; ifp = ifp->if_next) {
|
|
|
|
spin_lock_bh(&ifp->lock);
|
|
|
|
if (!(ifp->flags & IFA_F_TENTATIVE)) {
|
|
|
|
spin_unlock_bh(&ifp->lock);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
spin_unlock_bh(&ifp->lock);
|
|
|
|
addrconf_dad_kick(ifp);
|
|
|
|
}
|
|
|
|
read_unlock_bh(&idev->lock);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
#ifdef CONFIG_PROC_FS
|
|
|
|
struct if6_iter_state {
|
2008-01-11 07:42:49 +01:00
|
|
|
struct seq_net_private p;
|
2005-04-17 00:20:36 +02:00
|
|
|
int bucket;
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct inet6_ifaddr *if6_get_first(struct seq_file *seq)
|
|
|
|
{
|
|
|
|
struct inet6_ifaddr *ifa = NULL;
|
|
|
|
struct if6_iter_state *state = seq->private;
|
2008-03-25 18:36:06 +01:00
|
|
|
struct net *net = seq_file_net(seq);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
for (state->bucket = 0; state->bucket < IN6_ADDR_HSIZE; ++state->bucket) {
|
|
|
|
ifa = inet6_addr_lst[state->bucket];
|
2008-01-11 07:42:49 +01:00
|
|
|
|
2008-03-25 19:57:35 +01:00
|
|
|
while (ifa && !net_eq(dev_net(ifa->idev->dev), net))
|
2008-01-11 07:42:49 +01:00
|
|
|
ifa = ifa->lst_next;
|
2005-04-17 00:20:36 +02:00
|
|
|
if (ifa)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return ifa;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct inet6_ifaddr *if6_get_next(struct seq_file *seq, struct inet6_ifaddr *ifa)
|
|
|
|
{
|
|
|
|
struct if6_iter_state *state = seq->private;
|
2008-03-25 18:36:06 +01:00
|
|
|
struct net *net = seq_file_net(seq);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
ifa = ifa->lst_next;
|
|
|
|
try_again:
|
2008-01-11 07:42:49 +01:00
|
|
|
if (ifa) {
|
2008-03-25 19:57:35 +01:00
|
|
|
if (!net_eq(dev_net(ifa->idev->dev), net)) {
|
2008-01-11 07:42:49 +01:00
|
|
|
ifa = ifa->lst_next;
|
|
|
|
goto try_again;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!ifa && ++state->bucket < IN6_ADDR_HSIZE) {
|
|
|
|
ifa = inet6_addr_lst[state->bucket];
|
|
|
|
goto try_again;
|
|
|
|
}
|
2008-01-11 07:42:49 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
return ifa;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct inet6_ifaddr *if6_get_idx(struct seq_file *seq, loff_t pos)
|
|
|
|
{
|
|
|
|
struct inet6_ifaddr *ifa = if6_get_first(seq);
|
|
|
|
|
|
|
|
if (ifa)
|
|
|
|
while(pos && (ifa = if6_get_next(seq, ifa)) != NULL)
|
|
|
|
--pos;
|
|
|
|
return pos ? NULL : ifa;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *if6_seq_start(struct seq_file *seq, loff_t *pos)
|
2008-01-21 09:48:43 +01:00
|
|
|
__acquires(addrconf_hash_lock)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
read_lock_bh(&addrconf_hash_lock);
|
|
|
|
return if6_get_idx(seq, *pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *if6_seq_next(struct seq_file *seq, void *v, loff_t *pos)
|
|
|
|
{
|
|
|
|
struct inet6_ifaddr *ifa;
|
|
|
|
|
|
|
|
ifa = if6_get_next(seq, v);
|
|
|
|
++*pos;
|
|
|
|
return ifa;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void if6_seq_stop(struct seq_file *seq, void *v)
|
2008-01-21 09:48:43 +01:00
|
|
|
__releases(addrconf_hash_lock)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
read_unlock_bh(&addrconf_hash_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int if6_seq_show(struct seq_file *seq, void *v)
|
|
|
|
{
|
|
|
|
struct inet6_ifaddr *ifp = (struct inet6_ifaddr *)v;
|
|
|
|
seq_printf(seq,
|
2006-01-17 11:10:53 +01:00
|
|
|
NIP6_SEQFMT " %02x %02x %02x %02x %8s\n",
|
2005-04-17 00:20:36 +02:00
|
|
|
NIP6(ifp->addr),
|
|
|
|
ifp->idev->dev->ifindex,
|
|
|
|
ifp->prefix_len,
|
|
|
|
ifp->scope,
|
|
|
|
ifp->flags,
|
|
|
|
ifp->idev->dev->name);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-07-11 08:07:31 +02:00
|
|
|
static const struct seq_operations if6_seq_ops = {
|
2005-04-17 00:20:36 +02:00
|
|
|
.start = if6_seq_start,
|
|
|
|
.next = if6_seq_next,
|
|
|
|
.show = if6_seq_show,
|
|
|
|
.stop = if6_seq_stop,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int if6_seq_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
2008-01-11 07:42:49 +01:00
|
|
|
return seq_open_net(inode, file, &if6_seq_ops,
|
|
|
|
sizeof(struct if6_iter_state));
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-02-12 09:55:35 +01:00
|
|
|
static const struct file_operations if6_fops = {
|
2005-04-17 00:20:36 +02:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = if6_seq_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
2008-01-11 07:42:49 +01:00
|
|
|
.release = seq_release_net,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
2008-01-11 07:42:49 +01:00
|
|
|
static int if6_proc_net_init(struct net *net)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-01-11 07:42:49 +01:00
|
|
|
if (!proc_net_fops_create(net, "if_inet6", S_IRUGO, &if6_fops))
|
2005-04-17 00:20:36 +02:00
|
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-01-11 07:42:49 +01:00
|
|
|
static void if6_proc_net_exit(struct net *net)
|
|
|
|
{
|
|
|
|
proc_net_remove(net, "if_inet6");
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct pernet_operations if6_proc_net_ops = {
|
|
|
|
.init = if6_proc_net_init,
|
|
|
|
.exit = if6_proc_net_exit,
|
|
|
|
};
|
|
|
|
|
|
|
|
int __init if6_proc_init(void)
|
|
|
|
{
|
|
|
|
return register_pernet_subsys(&if6_proc_net_ops);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
void if6_proc_exit(void)
|
|
|
|
{
|
2008-01-11 07:42:49 +01:00
|
|
|
unregister_pernet_subsys(&if6_proc_net_ops);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
#endif /* CONFIG_PROC_FS */
|
|
|
|
|
2007-06-27 08:56:32 +02:00
|
|
|
#if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
|
2006-09-22 23:45:56 +02:00
|
|
|
/* Check if address is a home address configured on any interface. */
|
2008-01-11 07:44:40 +01:00
|
|
|
int ipv6_chk_home_addr(struct net *net, struct in6_addr *addr)
|
2006-09-22 23:45:56 +02:00
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
struct inet6_ifaddr * ifp;
|
|
|
|
u8 hash = ipv6_addr_hash(addr);
|
|
|
|
read_lock_bh(&addrconf_hash_lock);
|
|
|
|
for (ifp = inet6_addr_lst[hash]; ifp; ifp = ifp->lst_next) {
|
2008-03-25 19:57:35 +01:00
|
|
|
if (!net_eq(dev_net(ifp->idev->dev), net))
|
2008-01-11 07:44:40 +01:00
|
|
|
continue;
|
2008-04-10 08:42:07 +02:00
|
|
|
if (ipv6_addr_equal(&ifp->addr, addr) &&
|
2006-09-22 23:45:56 +02:00
|
|
|
(ifp->flags & IFA_F_HOMEADDRESS)) {
|
|
|
|
ret = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
read_unlock_bh(&addrconf_hash_lock);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Periodic address status verification
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void addrconf_verify(unsigned long foo)
|
|
|
|
{
|
|
|
|
struct inet6_ifaddr *ifp;
|
|
|
|
unsigned long now, next;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
spin_lock_bh(&addrconf_verify_lock);
|
|
|
|
now = jiffies;
|
|
|
|
next = now + ADDR_CHECK_FREQUENCY;
|
|
|
|
|
|
|
|
del_timer(&addr_chk_timer);
|
|
|
|
|
|
|
|
for (i=0; i < IN6_ADDR_HSIZE; i++) {
|
|
|
|
|
|
|
|
restart:
|
2005-11-20 22:42:20 +01:00
|
|
|
read_lock(&addrconf_hash_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
for (ifp=inet6_addr_lst[i]; ifp; ifp=ifp->lst_next) {
|
|
|
|
unsigned long age;
|
|
|
|
#ifdef CONFIG_IPV6_PRIVACY
|
|
|
|
unsigned long regen_advance;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (ifp->flags & IFA_F_PERMANENT)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
spin_lock(&ifp->lock);
|
|
|
|
age = (now - ifp->tstamp) / HZ;
|
|
|
|
|
|
|
|
#ifdef CONFIG_IPV6_PRIVACY
|
2007-02-09 15:24:49 +01:00
|
|
|
regen_advance = ifp->idev->cnf.regen_max_retry *
|
|
|
|
ifp->idev->cnf.dad_transmits *
|
2005-04-17 00:20:36 +02:00
|
|
|
ifp->idev->nd_parms->retrans_time / HZ;
|
|
|
|
#endif
|
|
|
|
|
2006-07-28 11:12:11 +02:00
|
|
|
if (ifp->valid_lft != INFINITY_LIFE_TIME &&
|
|
|
|
age >= ifp->valid_lft) {
|
2005-04-17 00:20:36 +02:00
|
|
|
spin_unlock(&ifp->lock);
|
|
|
|
in6_ifa_hold(ifp);
|
2005-11-20 22:42:20 +01:00
|
|
|
read_unlock(&addrconf_hash_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
ipv6_del_addr(ifp);
|
|
|
|
goto restart;
|
2006-07-28 11:12:11 +02:00
|
|
|
} else if (ifp->prefered_lft == INFINITY_LIFE_TIME) {
|
|
|
|
spin_unlock(&ifp->lock);
|
|
|
|
continue;
|
2005-04-17 00:20:36 +02:00
|
|
|
} else if (age >= ifp->prefered_lft) {
|
|
|
|
/* jiffies - ifp->tsamp > age >= ifp->prefered_lft */
|
|
|
|
int deprecate = 0;
|
|
|
|
|
|
|
|
if (!(ifp->flags&IFA_F_DEPRECATED)) {
|
|
|
|
deprecate = 1;
|
|
|
|
ifp->flags |= IFA_F_DEPRECATED;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (time_before(ifp->tstamp + ifp->valid_lft * HZ, next))
|
|
|
|
next = ifp->tstamp + ifp->valid_lft * HZ;
|
|
|
|
|
|
|
|
spin_unlock(&ifp->lock);
|
|
|
|
|
|
|
|
if (deprecate) {
|
|
|
|
in6_ifa_hold(ifp);
|
2005-11-20 22:42:20 +01:00
|
|
|
read_unlock(&addrconf_hash_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
ipv6_ifa_notify(0, ifp);
|
|
|
|
in6_ifa_put(ifp);
|
|
|
|
goto restart;
|
|
|
|
}
|
|
|
|
#ifdef CONFIG_IPV6_PRIVACY
|
|
|
|
} else if ((ifp->flags&IFA_F_TEMPORARY) &&
|
|
|
|
!(ifp->flags&IFA_F_TENTATIVE)) {
|
|
|
|
if (age >= ifp->prefered_lft - regen_advance) {
|
|
|
|
struct inet6_ifaddr *ifpub = ifp->ifpub;
|
|
|
|
if (time_before(ifp->tstamp + ifp->prefered_lft * HZ, next))
|
|
|
|
next = ifp->tstamp + ifp->prefered_lft * HZ;
|
|
|
|
if (!ifp->regen_count && ifpub) {
|
|
|
|
ifp->regen_count++;
|
|
|
|
in6_ifa_hold(ifp);
|
|
|
|
in6_ifa_hold(ifpub);
|
|
|
|
spin_unlock(&ifp->lock);
|
2005-11-20 22:42:20 +01:00
|
|
|
read_unlock(&addrconf_hash_lock);
|
2005-12-23 20:24:05 +01:00
|
|
|
spin_lock(&ifpub->lock);
|
|
|
|
ifpub->regen_count = 0;
|
|
|
|
spin_unlock(&ifpub->lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
ipv6_create_tempaddr(ifpub, ifp);
|
|
|
|
in6_ifa_put(ifpub);
|
|
|
|
in6_ifa_put(ifp);
|
|
|
|
goto restart;
|
|
|
|
}
|
|
|
|
} else if (time_before(ifp->tstamp + ifp->prefered_lft * HZ - regen_advance * HZ, next))
|
|
|
|
next = ifp->tstamp + ifp->prefered_lft * HZ - regen_advance * HZ;
|
|
|
|
spin_unlock(&ifp->lock);
|
|
|
|
#endif
|
|
|
|
} else {
|
|
|
|
/* ifp->prefered_lft <= ifp->valid_lft */
|
|
|
|
if (time_before(ifp->tstamp + ifp->prefered_lft * HZ, next))
|
|
|
|
next = ifp->tstamp + ifp->prefered_lft * HZ;
|
|
|
|
spin_unlock(&ifp->lock);
|
|
|
|
}
|
|
|
|
}
|
2005-11-20 22:42:20 +01:00
|
|
|
read_unlock(&addrconf_hash_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
addr_chk_timer.expires = time_before(next, jiffies + HZ) ? jiffies + HZ : next;
|
|
|
|
add_timer(&addr_chk_timer);
|
|
|
|
spin_unlock_bh(&addrconf_verify_lock);
|
|
|
|
}
|
|
|
|
|
2006-09-18 09:09:49 +02:00
|
|
|
static struct in6_addr *extract_addr(struct nlattr *addr, struct nlattr *local)
|
|
|
|
{
|
|
|
|
struct in6_addr *pfx = NULL;
|
|
|
|
|
|
|
|
if (addr)
|
|
|
|
pfx = nla_data(addr);
|
|
|
|
|
|
|
|
if (local) {
|
|
|
|
if (pfx && nla_memcmp(local, pfx, sizeof(*pfx)))
|
|
|
|
pfx = NULL;
|
|
|
|
else
|
|
|
|
pfx = nla_data(local);
|
|
|
|
}
|
|
|
|
|
|
|
|
return pfx;
|
|
|
|
}
|
|
|
|
|
2007-06-05 21:38:30 +02:00
|
|
|
static const struct nla_policy ifa_ipv6_policy[IFA_MAX+1] = {
|
2006-09-18 09:09:49 +02:00
|
|
|
[IFA_ADDRESS] = { .len = sizeof(struct in6_addr) },
|
|
|
|
[IFA_LOCAL] = { .len = sizeof(struct in6_addr) },
|
|
|
|
[IFA_CACHEINFO] = { .len = sizeof(struct ifa_cacheinfo) },
|
|
|
|
};
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static int
|
|
|
|
inet6_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
|
|
|
|
{
|
2008-03-25 18:26:21 +01:00
|
|
|
struct net *net = sock_net(skb->sk);
|
2006-09-18 09:10:19 +02:00
|
|
|
struct ifaddrmsg *ifm;
|
|
|
|
struct nlattr *tb[IFA_MAX+1];
|
2005-04-17 00:20:36 +02:00
|
|
|
struct in6_addr *pfx;
|
2006-09-18 09:10:19 +02:00
|
|
|
int err;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-09-18 09:10:19 +02:00
|
|
|
err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv6_policy);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
ifm = nlmsg_data(nlh);
|
|
|
|
pfx = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL]);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (pfx == NULL)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2008-03-05 19:46:57 +01:00
|
|
|
return inet6_addr_del(net, ifm->ifa_index, pfx, ifm->ifa_prefixlen);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-09-22 23:45:27 +02:00
|
|
|
static int inet6_addr_modify(struct inet6_ifaddr *ifp, u8 ifa_flags,
|
|
|
|
u32 prefered_lft, u32 valid_lft)
|
2006-07-28 11:12:13 +02:00
|
|
|
{
|
2008-05-20 01:56:11 +02:00
|
|
|
u32 flags;
|
|
|
|
clock_t expires;
|
2008-05-27 10:37:49 +02:00
|
|
|
unsigned long timeout;
|
2007-02-07 12:36:26 +01:00
|
|
|
|
2006-07-28 11:12:13 +02:00
|
|
|
if (!valid_lft || (prefered_lft > valid_lft))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2008-05-27 10:37:49 +02:00
|
|
|
timeout = addrconf_timeout_fixup(valid_lft, HZ);
|
|
|
|
if (addrconf_finite_timeout(timeout)) {
|
|
|
|
expires = jiffies_to_clock_t(timeout * HZ);
|
|
|
|
valid_lft = timeout;
|
2008-05-20 01:56:11 +02:00
|
|
|
flags = RTF_EXPIRES;
|
2008-05-27 10:37:49 +02:00
|
|
|
} else {
|
|
|
|
expires = 0;
|
|
|
|
flags = 0;
|
|
|
|
ifa_flags |= IFA_F_PERMANENT;
|
2008-05-20 01:56:11 +02:00
|
|
|
}
|
2006-07-28 11:12:13 +02:00
|
|
|
|
2008-05-27 10:37:49 +02:00
|
|
|
timeout = addrconf_timeout_fixup(prefered_lft, HZ);
|
|
|
|
if (addrconf_finite_timeout(timeout)) {
|
|
|
|
if (timeout == 0)
|
|
|
|
ifa_flags |= IFA_F_DEPRECATED;
|
|
|
|
prefered_lft = timeout;
|
|
|
|
}
|
2006-07-28 11:12:13 +02:00
|
|
|
|
|
|
|
spin_lock_bh(&ifp->lock);
|
2006-09-22 23:45:56 +02:00
|
|
|
ifp->flags = (ifp->flags & ~(IFA_F_DEPRECATED | IFA_F_PERMANENT | IFA_F_NODAD | IFA_F_HOMEADDRESS)) | ifa_flags;
|
2006-07-28 11:12:13 +02:00
|
|
|
ifp->tstamp = jiffies;
|
|
|
|
ifp->valid_lft = valid_lft;
|
|
|
|
ifp->prefered_lft = prefered_lft;
|
|
|
|
|
|
|
|
spin_unlock_bh(&ifp->lock);
|
|
|
|
if (!(ifp->flags&IFA_F_TENTATIVE))
|
|
|
|
ipv6_ifa_notify(0, ifp);
|
|
|
|
|
2007-02-07 12:36:26 +01:00
|
|
|
addrconf_prefix_route(&ifp->addr, ifp->prefix_len, ifp->idev->dev,
|
2008-05-20 01:56:11 +02:00
|
|
|
expires, flags);
|
2006-07-28 11:12:13 +02:00
|
|
|
addrconf_verify(0);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static int
|
|
|
|
inet6_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
|
|
|
|
{
|
2008-03-25 18:26:21 +01:00
|
|
|
struct net *net = sock_net(skb->sk);
|
2006-09-18 09:09:49 +02:00
|
|
|
struct ifaddrmsg *ifm;
|
|
|
|
struct nlattr *tb[IFA_MAX+1];
|
2005-04-17 00:20:36 +02:00
|
|
|
struct in6_addr *pfx;
|
2006-09-18 09:13:46 +02:00
|
|
|
struct inet6_ifaddr *ifa;
|
|
|
|
struct net_device *dev;
|
2006-09-22 23:45:27 +02:00
|
|
|
u32 valid_lft = INFINITY_LIFE_TIME, preferred_lft = INFINITY_LIFE_TIME;
|
|
|
|
u8 ifa_flags;
|
2006-09-18 09:09:49 +02:00
|
|
|
int err;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-09-18 09:09:49 +02:00
|
|
|
err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv6_policy);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
ifm = nlmsg_data(nlh);
|
|
|
|
pfx = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL]);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (pfx == NULL)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2006-09-18 09:09:49 +02:00
|
|
|
if (tb[IFA_CACHEINFO]) {
|
2006-07-28 11:12:10 +02:00
|
|
|
struct ifa_cacheinfo *ci;
|
2006-09-18 09:09:49 +02:00
|
|
|
|
|
|
|
ci = nla_data(tb[IFA_CACHEINFO]);
|
2006-07-28 11:12:10 +02:00
|
|
|
valid_lft = ci->ifa_valid;
|
2006-09-18 09:09:49 +02:00
|
|
|
preferred_lft = ci->ifa_prefered;
|
|
|
|
} else {
|
|
|
|
preferred_lft = INFINITY_LIFE_TIME;
|
|
|
|
valid_lft = INFINITY_LIFE_TIME;
|
2006-07-28 11:12:10 +02:00
|
|
|
}
|
|
|
|
|
2008-03-05 19:46:57 +01:00
|
|
|
dev = __dev_get_by_index(net, ifm->ifa_index);
|
2006-09-18 09:13:46 +02:00
|
|
|
if (dev == NULL)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2006-09-22 23:45:27 +02:00
|
|
|
/* We ignore other flags so far. */
|
2006-09-22 23:45:56 +02:00
|
|
|
ifa_flags = ifm->ifa_flags & (IFA_F_NODAD | IFA_F_HOMEADDRESS);
|
2006-09-22 23:45:27 +02:00
|
|
|
|
2008-01-11 07:44:09 +01:00
|
|
|
ifa = ipv6_get_ifaddr(net, pfx, dev, 1);
|
2006-09-18 09:13:46 +02:00
|
|
|
if (ifa == NULL) {
|
|
|
|
/*
|
|
|
|
* It would be best to check for !NLM_F_CREATE here but
|
|
|
|
* userspace alreay relies on not having to provide this.
|
|
|
|
*/
|
2008-03-05 19:46:57 +01:00
|
|
|
return inet6_addr_add(net, ifm->ifa_index, pfx,
|
|
|
|
ifm->ifa_prefixlen, ifa_flags,
|
|
|
|
preferred_lft, valid_lft);
|
2006-07-28 11:12:13 +02:00
|
|
|
}
|
|
|
|
|
2006-09-18 09:13:46 +02:00
|
|
|
if (nlh->nlmsg_flags & NLM_F_EXCL ||
|
|
|
|
!(nlh->nlmsg_flags & NLM_F_REPLACE))
|
|
|
|
err = -EEXIST;
|
|
|
|
else
|
2006-09-22 23:45:27 +02:00
|
|
|
err = inet6_addr_modify(ifa, ifa_flags, preferred_lft, valid_lft);
|
2006-09-18 09:13:46 +02:00
|
|
|
|
|
|
|
in6_ifa_put(ifa);
|
|
|
|
|
|
|
|
return err;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-09-18 09:11:52 +02:00
|
|
|
static void put_ifaddrmsg(struct nlmsghdr *nlh, u8 prefixlen, u8 flags,
|
|
|
|
u8 scope, int ifindex)
|
|
|
|
{
|
|
|
|
struct ifaddrmsg *ifm;
|
|
|
|
|
|
|
|
ifm = nlmsg_data(nlh);
|
|
|
|
ifm->ifa_family = AF_INET6;
|
|
|
|
ifm->ifa_prefixlen = prefixlen;
|
|
|
|
ifm->ifa_flags = flags;
|
|
|
|
ifm->ifa_scope = scope;
|
|
|
|
ifm->ifa_index = ifindex;
|
|
|
|
}
|
|
|
|
|
2006-09-18 09:11:24 +02:00
|
|
|
static int put_cacheinfo(struct sk_buff *skb, unsigned long cstamp,
|
|
|
|
unsigned long tstamp, u32 preferred, u32 valid)
|
|
|
|
{
|
|
|
|
struct ifa_cacheinfo ci;
|
|
|
|
|
|
|
|
ci.cstamp = (u32)(TIME_DELTA(cstamp, INITIAL_JIFFIES) / HZ * 100
|
|
|
|
+ TIME_DELTA(cstamp, INITIAL_JIFFIES) % HZ * 100 / HZ);
|
|
|
|
ci.tstamp = (u32)(TIME_DELTA(tstamp, INITIAL_JIFFIES) / HZ * 100
|
|
|
|
+ TIME_DELTA(tstamp, INITIAL_JIFFIES) % HZ * 100 / HZ);
|
|
|
|
ci.ifa_prefered = preferred;
|
|
|
|
ci.ifa_valid = valid;
|
|
|
|
|
|
|
|
return nla_put(skb, IFA_CACHEINFO, sizeof(ci), &ci);
|
|
|
|
}
|
|
|
|
|
2006-09-18 09:11:52 +02:00
|
|
|
static inline int rt_scope(int ifa_scope)
|
|
|
|
{
|
|
|
|
if (ifa_scope & IFA_HOST)
|
|
|
|
return RT_SCOPE_HOST;
|
|
|
|
else if (ifa_scope & IFA_LINK)
|
|
|
|
return RT_SCOPE_LINK;
|
|
|
|
else if (ifa_scope & IFA_SITE)
|
|
|
|
return RT_SCOPE_SITE;
|
|
|
|
else
|
|
|
|
return RT_SCOPE_UNIVERSE;
|
|
|
|
}
|
|
|
|
|
2006-09-18 09:12:35 +02:00
|
|
|
static inline int inet6_ifaddr_msgsize(void)
|
|
|
|
{
|
2006-11-10 23:10:15 +01:00
|
|
|
return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
|
|
|
|
+ nla_total_size(16) /* IFA_ADDRESS */
|
|
|
|
+ nla_total_size(sizeof(struct ifa_cacheinfo));
|
2006-09-18 09:12:35 +02:00
|
|
|
}
|
2006-06-18 07:48:48 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static int inet6_fill_ifaddr(struct sk_buff *skb, struct inet6_ifaddr *ifa,
|
2005-06-19 07:54:12 +02:00
|
|
|
u32 pid, u32 seq, int event, unsigned int flags)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct nlmsghdr *nlh;
|
2006-09-18 09:11:24 +02:00
|
|
|
u32 preferred, valid;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-09-18 09:12:35 +02:00
|
|
|
nlh = nlmsg_put(skb, pid, seq, event, sizeof(struct ifaddrmsg), flags);
|
|
|
|
if (nlh == NULL)
|
2007-02-01 08:16:40 +01:00
|
|
|
return -EMSGSIZE;
|
2006-09-18 09:12:35 +02:00
|
|
|
|
2006-09-18 09:11:52 +02:00
|
|
|
put_ifaddrmsg(nlh, ifa->prefix_len, ifa->flags, rt_scope(ifa->scope),
|
|
|
|
ifa->idev->dev->ifindex);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!(ifa->flags&IFA_F_PERMANENT)) {
|
2006-09-18 09:11:24 +02:00
|
|
|
preferred = ifa->prefered_lft;
|
|
|
|
valid = ifa->valid_lft;
|
|
|
|
if (preferred != INFINITY_LIFE_TIME) {
|
2005-04-17 00:20:36 +02:00
|
|
|
long tval = (jiffies - ifa->tstamp)/HZ;
|
2006-09-18 09:11:24 +02:00
|
|
|
preferred -= tval;
|
|
|
|
if (valid != INFINITY_LIFE_TIME)
|
|
|
|
valid -= tval;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
} else {
|
2006-09-18 09:11:24 +02:00
|
|
|
preferred = INFINITY_LIFE_TIME;
|
|
|
|
valid = INFINITY_LIFE_TIME;
|
|
|
|
}
|
|
|
|
|
2006-09-18 09:12:35 +02:00
|
|
|
if (nla_put(skb, IFA_ADDRESS, 16, &ifa->addr) < 0 ||
|
2007-02-01 08:16:40 +01:00
|
|
|
put_cacheinfo(skb, ifa->cstamp, ifa->tstamp, preferred, valid) < 0) {
|
|
|
|
nlmsg_cancel(skb, nlh);
|
|
|
|
return -EMSGSIZE;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-09-18 09:12:35 +02:00
|
|
|
return nlmsg_end(skb, nlh);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int inet6_fill_ifmcaddr(struct sk_buff *skb, struct ifmcaddr6 *ifmca,
|
2005-06-19 07:55:31 +02:00
|
|
|
u32 pid, u32 seq, int event, u16 flags)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct nlmsghdr *nlh;
|
2006-09-18 09:11:52 +02:00
|
|
|
u8 scope = RT_SCOPE_UNIVERSE;
|
|
|
|
int ifindex = ifmca->idev->dev->ifindex;
|
|
|
|
|
|
|
|
if (ipv6_addr_scope(&ifmca->mca_addr) & IFA_SITE)
|
|
|
|
scope = RT_SCOPE_SITE;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-09-18 09:12:35 +02:00
|
|
|
nlh = nlmsg_put(skb, pid, seq, event, sizeof(struct ifaddrmsg), flags);
|
|
|
|
if (nlh == NULL)
|
2007-02-01 08:16:40 +01:00
|
|
|
return -EMSGSIZE;
|
2006-09-18 09:11:24 +02:00
|
|
|
|
2006-09-18 09:12:35 +02:00
|
|
|
put_ifaddrmsg(nlh, 128, IFA_F_PERMANENT, scope, ifindex);
|
|
|
|
if (nla_put(skb, IFA_MULTICAST, 16, &ifmca->mca_addr) < 0 ||
|
|
|
|
put_cacheinfo(skb, ifmca->mca_cstamp, ifmca->mca_tstamp,
|
2007-02-01 08:16:40 +01:00
|
|
|
INFINITY_LIFE_TIME, INFINITY_LIFE_TIME) < 0) {
|
|
|
|
nlmsg_cancel(skb, nlh);
|
|
|
|
return -EMSGSIZE;
|
|
|
|
}
|
2006-09-18 09:11:24 +02:00
|
|
|
|
2006-09-18 09:12:35 +02:00
|
|
|
return nlmsg_end(skb, nlh);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int inet6_fill_ifacaddr(struct sk_buff *skb, struct ifacaddr6 *ifaca,
|
2005-06-19 07:54:12 +02:00
|
|
|
u32 pid, u32 seq, int event, unsigned int flags)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct nlmsghdr *nlh;
|
2006-09-18 09:11:52 +02:00
|
|
|
u8 scope = RT_SCOPE_UNIVERSE;
|
|
|
|
int ifindex = ifaca->aca_idev->dev->ifindex;
|
|
|
|
|
|
|
|
if (ipv6_addr_scope(&ifaca->aca_addr) & IFA_SITE)
|
|
|
|
scope = RT_SCOPE_SITE;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-09-18 09:12:35 +02:00
|
|
|
nlh = nlmsg_put(skb, pid, seq, event, sizeof(struct ifaddrmsg), flags);
|
|
|
|
if (nlh == NULL)
|
2007-02-01 08:16:40 +01:00
|
|
|
return -EMSGSIZE;
|
2006-09-18 09:11:24 +02:00
|
|
|
|
2006-09-18 09:12:35 +02:00
|
|
|
put_ifaddrmsg(nlh, 128, IFA_F_PERMANENT, scope, ifindex);
|
|
|
|
if (nla_put(skb, IFA_ANYCAST, 16, &ifaca->aca_addr) < 0 ||
|
|
|
|
put_cacheinfo(skb, ifaca->aca_cstamp, ifaca->aca_tstamp,
|
2007-02-01 08:16:40 +01:00
|
|
|
INFINITY_LIFE_TIME, INFINITY_LIFE_TIME) < 0) {
|
|
|
|
nlmsg_cancel(skb, nlh);
|
|
|
|
return -EMSGSIZE;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-09-18 09:12:35 +02:00
|
|
|
return nlmsg_end(skb, nlh);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
enum addr_type_t
|
|
|
|
{
|
|
|
|
UNICAST_ADDR,
|
|
|
|
MULTICAST_ADDR,
|
|
|
|
ANYCAST_ADDR,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int inet6_dump_addr(struct sk_buff *skb, struct netlink_callback *cb,
|
|
|
|
enum addr_type_t type)
|
|
|
|
{
|
|
|
|
int idx, ip_idx;
|
|
|
|
int s_idx, s_ip_idx;
|
|
|
|
int err = 1;
|
|
|
|
struct net_device *dev;
|
|
|
|
struct inet6_dev *idev = NULL;
|
|
|
|
struct inet6_ifaddr *ifa;
|
|
|
|
struct ifmcaddr6 *ifmca;
|
|
|
|
struct ifacaddr6 *ifaca;
|
2008-03-25 18:26:21 +01:00
|
|
|
struct net *net = sock_net(skb->sk);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
s_idx = cb->args[0];
|
|
|
|
s_ip_idx = ip_idx = cb->args[1];
|
2007-02-09 15:24:49 +01:00
|
|
|
|
2007-05-04 00:13:45 +02:00
|
|
|
idx = 0;
|
2008-03-05 19:47:47 +01:00
|
|
|
for_each_netdev(net, dev) {
|
2005-04-17 00:20:36 +02:00
|
|
|
if (idx < s_idx)
|
2007-05-04 00:13:45 +02:00
|
|
|
goto cont;
|
2005-04-17 00:20:36 +02:00
|
|
|
if (idx > s_idx)
|
|
|
|
s_ip_idx = 0;
|
|
|
|
ip_idx = 0;
|
|
|
|
if ((idev = in6_dev_get(dev)) == NULL)
|
2007-05-04 00:13:45 +02:00
|
|
|
goto cont;
|
2005-04-17 00:20:36 +02:00
|
|
|
read_lock_bh(&idev->lock);
|
|
|
|
switch (type) {
|
|
|
|
case UNICAST_ADDR:
|
2005-06-28 22:00:30 +02:00
|
|
|
/* unicast address incl. temp addr */
|
2005-04-17 00:20:36 +02:00
|
|
|
for (ifa = idev->addr_list; ifa;
|
|
|
|
ifa = ifa->if_next, ip_idx++) {
|
|
|
|
if (ip_idx < s_ip_idx)
|
|
|
|
continue;
|
2008-01-22 09:29:40 +01:00
|
|
|
err = inet6_fill_ifaddr(skb, ifa,
|
|
|
|
NETLINK_CB(cb->skb).pid,
|
|
|
|
cb->nlh->nlmsg_seq,
|
|
|
|
RTM_NEWADDR,
|
|
|
|
NLM_F_MULTI);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case MULTICAST_ADDR:
|
|
|
|
/* multicast address */
|
2007-02-09 15:24:49 +01:00
|
|
|
for (ifmca = idev->mc_list; ifmca;
|
2005-04-17 00:20:36 +02:00
|
|
|
ifmca = ifmca->next, ip_idx++) {
|
|
|
|
if (ip_idx < s_ip_idx)
|
|
|
|
continue;
|
2008-01-22 09:29:40 +01:00
|
|
|
err = inet6_fill_ifmcaddr(skb, ifmca,
|
|
|
|
NETLINK_CB(cb->skb).pid,
|
|
|
|
cb->nlh->nlmsg_seq,
|
|
|
|
RTM_GETMULTICAST,
|
|
|
|
NLM_F_MULTI);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ANYCAST_ADDR:
|
|
|
|
/* anycast address */
|
|
|
|
for (ifaca = idev->ac_list; ifaca;
|
|
|
|
ifaca = ifaca->aca_next, ip_idx++) {
|
|
|
|
if (ip_idx < s_ip_idx)
|
|
|
|
continue;
|
2008-01-22 09:29:40 +01:00
|
|
|
err = inet6_fill_ifacaddr(skb, ifaca,
|
|
|
|
NETLINK_CB(cb->skb).pid,
|
|
|
|
cb->nlh->nlmsg_seq,
|
|
|
|
RTM_GETANYCAST,
|
|
|
|
NLM_F_MULTI);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
read_unlock_bh(&idev->lock);
|
|
|
|
in6_dev_put(idev);
|
2008-01-22 09:29:40 +01:00
|
|
|
|
|
|
|
if (err <= 0)
|
|
|
|
break;
|
2007-05-04 00:13:45 +02:00
|
|
|
cont:
|
|
|
|
idx++;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
cb->args[0] = idx;
|
|
|
|
cb->args[1] = ip_idx;
|
|
|
|
return skb->len;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int inet6_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
|
|
|
|
{
|
|
|
|
enum addr_type_t type = UNICAST_ADDR;
|
2007-11-30 14:21:31 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
return inet6_dump_addr(skb, cb, type);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int inet6_dump_ifmcaddr(struct sk_buff *skb, struct netlink_callback *cb)
|
|
|
|
{
|
|
|
|
enum addr_type_t type = MULTICAST_ADDR;
|
2007-11-30 14:21:31 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
return inet6_dump_addr(skb, cb, type);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int inet6_dump_ifacaddr(struct sk_buff *skb, struct netlink_callback *cb)
|
|
|
|
{
|
|
|
|
enum addr_type_t type = ANYCAST_ADDR;
|
2007-11-30 14:21:31 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
return inet6_dump_addr(skb, cb, type);
|
|
|
|
}
|
|
|
|
|
2006-09-18 09:10:50 +02:00
|
|
|
static int inet6_rtm_getaddr(struct sk_buff *in_skb, struct nlmsghdr* nlh,
|
|
|
|
void *arg)
|
2006-07-28 11:12:12 +02:00
|
|
|
{
|
2008-03-25 18:26:21 +01:00
|
|
|
struct net *net = sock_net(in_skb->sk);
|
2006-09-18 09:10:50 +02:00
|
|
|
struct ifaddrmsg *ifm;
|
|
|
|
struct nlattr *tb[IFA_MAX+1];
|
2006-07-28 11:12:12 +02:00
|
|
|
struct in6_addr *addr = NULL;
|
|
|
|
struct net_device *dev = NULL;
|
|
|
|
struct inet6_ifaddr *ifa;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
int err;
|
|
|
|
|
2006-09-18 09:10:50 +02:00
|
|
|
err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv6_policy);
|
|
|
|
if (err < 0)
|
|
|
|
goto errout;
|
|
|
|
|
|
|
|
addr = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL]);
|
|
|
|
if (addr == NULL) {
|
|
|
|
err = -EINVAL;
|
|
|
|
goto errout;
|
2006-07-28 11:12:12 +02:00
|
|
|
}
|
|
|
|
|
2006-09-18 09:10:50 +02:00
|
|
|
ifm = nlmsg_data(nlh);
|
2006-07-28 11:12:12 +02:00
|
|
|
if (ifm->ifa_index)
|
2008-03-05 19:47:47 +01:00
|
|
|
dev = __dev_get_by_index(net, ifm->ifa_index);
|
2006-07-28 11:12:12 +02:00
|
|
|
|
2008-01-11 07:44:09 +01:00
|
|
|
if ((ifa = ipv6_get_ifaddr(net, addr, dev, 1)) == NULL) {
|
2006-09-18 09:10:50 +02:00
|
|
|
err = -EADDRNOTAVAIL;
|
|
|
|
goto errout;
|
|
|
|
}
|
2006-07-28 11:12:12 +02:00
|
|
|
|
2006-09-18 09:12:35 +02:00
|
|
|
if ((skb = nlmsg_new(inet6_ifaddr_msgsize(), GFP_KERNEL)) == NULL) {
|
2006-07-28 11:12:12 +02:00
|
|
|
err = -ENOBUFS;
|
2006-09-18 09:10:50 +02:00
|
|
|
goto errout_ifa;
|
2006-07-28 11:12:12 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
err = inet6_fill_ifaddr(skb, ifa, NETLINK_CB(in_skb).pid,
|
|
|
|
nlh->nlmsg_seq, RTM_NEWADDR, 0);
|
2007-02-01 08:16:40 +01:00
|
|
|
if (err < 0) {
|
|
|
|
/* -EMSGSIZE implies BUG in inet6_ifaddr_msgsize() */
|
|
|
|
WARN_ON(err == -EMSGSIZE);
|
|
|
|
kfree_skb(skb);
|
|
|
|
goto errout_ifa;
|
|
|
|
}
|
2008-03-05 19:47:47 +01:00
|
|
|
err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).pid);
|
2006-09-18 09:10:50 +02:00
|
|
|
errout_ifa:
|
2006-07-28 11:12:12 +02:00
|
|
|
in6_ifa_put(ifa);
|
2006-09-18 09:10:50 +02:00
|
|
|
errout:
|
2006-07-28 11:12:12 +02:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static void inet6_ifa_notify(int event, struct inet6_ifaddr *ifa)
|
|
|
|
{
|
|
|
|
struct sk_buff *skb;
|
2008-03-25 13:47:49 +01:00
|
|
|
struct net *net = dev_net(ifa->idev->dev);
|
2006-08-15 09:35:02 +02:00
|
|
|
int err = -ENOBUFS;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-09-18 09:12:35 +02:00
|
|
|
skb = nlmsg_new(inet6_ifaddr_msgsize(), GFP_ATOMIC);
|
2006-08-15 09:35:02 +02:00
|
|
|
if (skb == NULL)
|
|
|
|
goto errout;
|
|
|
|
|
|
|
|
err = inet6_fill_ifaddr(skb, ifa, 0, 0, event, 0);
|
2007-02-01 08:16:40 +01:00
|
|
|
if (err < 0) {
|
|
|
|
/* -EMSGSIZE implies BUG in inet6_ifaddr_msgsize() */
|
|
|
|
WARN_ON(err == -EMSGSIZE);
|
|
|
|
kfree_skb(skb);
|
|
|
|
goto errout;
|
|
|
|
}
|
2008-03-05 19:47:47 +01:00
|
|
|
err = rtnl_notify(skb, net, 0, RTNLGRP_IPV6_IFADDR, NULL, GFP_ATOMIC);
|
2006-08-15 09:35:02 +02:00
|
|
|
errout:
|
|
|
|
if (err < 0)
|
2008-03-05 19:47:47 +01:00
|
|
|
rtnl_set_sk_err(net, RTNLGRP_IPV6_IFADDR, err);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-03-22 20:27:49 +01:00
|
|
|
static inline void ipv6_store_devconf(struct ipv6_devconf *cnf,
|
2005-04-17 00:20:36 +02:00
|
|
|
__s32 *array, int bytes)
|
|
|
|
{
|
2006-11-15 04:53:58 +01:00
|
|
|
BUG_ON(bytes < (DEVCONF_MAX * 4));
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
memset(array, 0, bytes);
|
|
|
|
array[DEVCONF_FORWARDING] = cnf->forwarding;
|
|
|
|
array[DEVCONF_HOPLIMIT] = cnf->hop_limit;
|
|
|
|
array[DEVCONF_MTU6] = cnf->mtu6;
|
|
|
|
array[DEVCONF_ACCEPT_RA] = cnf->accept_ra;
|
|
|
|
array[DEVCONF_ACCEPT_REDIRECTS] = cnf->accept_redirects;
|
|
|
|
array[DEVCONF_AUTOCONF] = cnf->autoconf;
|
|
|
|
array[DEVCONF_DAD_TRANSMITS] = cnf->dad_transmits;
|
|
|
|
array[DEVCONF_RTR_SOLICITS] = cnf->rtr_solicits;
|
|
|
|
array[DEVCONF_RTR_SOLICIT_INTERVAL] = cnf->rtr_solicit_interval;
|
|
|
|
array[DEVCONF_RTR_SOLICIT_DELAY] = cnf->rtr_solicit_delay;
|
|
|
|
array[DEVCONF_FORCE_MLD_VERSION] = cnf->force_mld_version;
|
|
|
|
#ifdef CONFIG_IPV6_PRIVACY
|
|
|
|
array[DEVCONF_USE_TEMPADDR] = cnf->use_tempaddr;
|
|
|
|
array[DEVCONF_TEMP_VALID_LFT] = cnf->temp_valid_lft;
|
|
|
|
array[DEVCONF_TEMP_PREFERED_LFT] = cnf->temp_prefered_lft;
|
|
|
|
array[DEVCONF_REGEN_MAX_RETRY] = cnf->regen_max_retry;
|
|
|
|
array[DEVCONF_MAX_DESYNC_FACTOR] = cnf->max_desync_factor;
|
|
|
|
#endif
|
|
|
|
array[DEVCONF_MAX_ADDRESSES] = cnf->max_addresses;
|
2006-03-21 01:55:08 +01:00
|
|
|
array[DEVCONF_ACCEPT_RA_DEFRTR] = cnf->accept_ra_defrtr;
|
2006-03-21 01:55:26 +01:00
|
|
|
array[DEVCONF_ACCEPT_RA_PINFO] = cnf->accept_ra_pinfo;
|
2006-03-21 02:05:30 +01:00
|
|
|
#ifdef CONFIG_IPV6_ROUTER_PREF
|
|
|
|
array[DEVCONF_ACCEPT_RA_RTR_PREF] = cnf->accept_ra_rtr_pref;
|
2006-03-21 02:05:47 +01:00
|
|
|
array[DEVCONF_RTR_PROBE_INTERVAL] = cnf->rtr_probe_interval;
|
2007-01-30 23:30:10 +01:00
|
|
|
#ifdef CONFIG_IPV6_ROUTE_INFO
|
2006-03-21 02:07:03 +01:00
|
|
|
array[DEVCONF_ACCEPT_RA_RT_INFO_MAX_PLEN] = cnf->accept_ra_rt_info_max_plen;
|
|
|
|
#endif
|
2006-03-21 02:05:30 +01:00
|
|
|
#endif
|
2006-09-22 23:43:49 +02:00
|
|
|
array[DEVCONF_PROXY_NDP] = cnf->proxy_ndp;
|
2007-04-24 23:58:30 +02:00
|
|
|
array[DEVCONF_ACCEPT_SOURCE_ROUTE] = cnf->accept_source_route;
|
2007-04-26 02:08:10 +02:00
|
|
|
#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
|
|
|
|
array[DEVCONF_OPTIMISTIC_DAD] = cnf->optimistic_dad;
|
|
|
|
#endif
|
2008-04-03 02:22:53 +02:00
|
|
|
#ifdef CONFIG_IPV6_MROUTE
|
|
|
|
array[DEVCONF_MC_FORWARDING] = cnf->mc_forwarding;
|
|
|
|
#endif
|
2008-06-28 07:17:11 +02:00
|
|
|
array[DEVCONF_DISABLE_IPV6] = cnf->disable_ipv6;
|
2008-06-28 07:18:38 +02:00
|
|
|
array[DEVCONF_ACCEPT_DAD] = cnf->accept_dad;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-11-10 23:10:15 +01:00
|
|
|
static inline size_t inet6_if_nlmsg_size(void)
|
|
|
|
{
|
|
|
|
return NLMSG_ALIGN(sizeof(struct ifinfomsg))
|
|
|
|
+ nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */
|
|
|
|
+ nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */
|
|
|
|
+ nla_total_size(4) /* IFLA_MTU */
|
|
|
|
+ nla_total_size(4) /* IFLA_LINK */
|
|
|
|
+ nla_total_size( /* IFLA_PROTINFO */
|
|
|
|
nla_total_size(4) /* IFLA_INET6_FLAGS */
|
|
|
|
+ nla_total_size(sizeof(struct ifla_cacheinfo))
|
|
|
|
+ nla_total_size(DEVCONF_MAX * 4) /* IFLA_INET6_CONF */
|
2007-04-21 00:56:20 +02:00
|
|
|
+ nla_total_size(IPSTATS_MIB_MAX * 8) /* IFLA_INET6_STATS */
|
|
|
|
+ nla_total_size(ICMP6_MIB_MAX * 8) /* IFLA_INET6_ICMP6STATS */
|
2006-11-10 23:10:15 +01:00
|
|
|
);
|
|
|
|
}
|
2006-06-18 07:48:48 +02:00
|
|
|
|
2007-04-25 06:54:09 +02:00
|
|
|
static inline void __snmp6_fill_stats(u64 *stats, void **mib, int items,
|
|
|
|
int bytes)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int pad = bytes - sizeof(u64) * items;
|
|
|
|
BUG_ON(pad < 0);
|
|
|
|
|
|
|
|
/* Use put_unaligned() because stats may not be aligned for u64. */
|
|
|
|
put_unaligned(items, &stats[0]);
|
|
|
|
for (i = 1; i < items; i++)
|
|
|
|
put_unaligned(snmp_fold_field(mib, i), &stats[i]);
|
|
|
|
|
|
|
|
memset(&stats[items], 0, pad);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void snmp6_fill_stats(u64 *stats, struct inet6_dev *idev, int attrtype,
|
|
|
|
int bytes)
|
|
|
|
{
|
|
|
|
switch(attrtype) {
|
|
|
|
case IFLA_INET6_STATS:
|
|
|
|
__snmp6_fill_stats(stats, (void **)idev->stats.ipv6, IPSTATS_MIB_MAX, bytes);
|
|
|
|
break;
|
|
|
|
case IFLA_INET6_ICMP6STATS:
|
|
|
|
__snmp6_fill_stats(stats, (void **)idev->stats.icmpv6, ICMP6_MIB_MAX, bytes);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-02-09 15:24:49 +01:00
|
|
|
static int inet6_fill_ifinfo(struct sk_buff *skb, struct inet6_dev *idev,
|
2005-06-19 07:54:12 +02:00
|
|
|
u32 pid, u32 seq, int event, unsigned int flags)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-11-15 04:53:58 +01:00
|
|
|
struct net_device *dev = idev->dev;
|
2007-04-21 00:56:20 +02:00
|
|
|
struct nlattr *nla;
|
2006-11-15 04:53:58 +01:00
|
|
|
struct ifinfomsg *hdr;
|
|
|
|
struct nlmsghdr *nlh;
|
|
|
|
void *protoinfo;
|
|
|
|
struct ifla_cacheinfo ci;
|
|
|
|
|
|
|
|
nlh = nlmsg_put(skb, pid, seq, event, sizeof(*hdr), flags);
|
|
|
|
if (nlh == NULL)
|
2007-02-01 08:16:40 +01:00
|
|
|
return -EMSGSIZE;
|
2006-11-15 04:53:58 +01:00
|
|
|
|
|
|
|
hdr = nlmsg_data(nlh);
|
|
|
|
hdr->ifi_family = AF_INET6;
|
|
|
|
hdr->__ifi_pad = 0;
|
|
|
|
hdr->ifi_type = dev->type;
|
|
|
|
hdr->ifi_index = dev->ifindex;
|
|
|
|
hdr->ifi_flags = dev_get_flags(dev);
|
|
|
|
hdr->ifi_change = 0;
|
|
|
|
|
|
|
|
NLA_PUT_STRING(skb, IFLA_IFNAME, dev->name);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (dev->addr_len)
|
2006-11-15 04:53:58 +01:00
|
|
|
NLA_PUT(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-11-15 04:53:58 +01:00
|
|
|
NLA_PUT_U32(skb, IFLA_MTU, dev->mtu);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (dev->ifindex != dev->iflink)
|
2006-11-15 04:53:58 +01:00
|
|
|
NLA_PUT_U32(skb, IFLA_LINK, dev->iflink);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-11-15 04:53:58 +01:00
|
|
|
protoinfo = nla_nest_start(skb, IFLA_PROTINFO);
|
|
|
|
if (protoinfo == NULL)
|
|
|
|
goto nla_put_failure;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-11-15 04:53:58 +01:00
|
|
|
NLA_PUT_U32(skb, IFLA_INET6_FLAGS, idev->if_flags);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
ci.max_reasm_len = IPV6_MAXPLEN;
|
|
|
|
ci.tstamp = (__u32)(TIME_DELTA(idev->tstamp, INITIAL_JIFFIES) / HZ * 100
|
|
|
|
+ TIME_DELTA(idev->tstamp, INITIAL_JIFFIES) % HZ * 100 / HZ);
|
|
|
|
ci.reachable_time = idev->nd_parms->reachable_time;
|
|
|
|
ci.retrans_time = idev->nd_parms->retrans_time;
|
2006-11-15 04:53:58 +01:00
|
|
|
NLA_PUT(skb, IFLA_INET6_CACHEINFO, sizeof(ci), &ci);
|
|
|
|
|
2007-04-21 00:56:20 +02:00
|
|
|
nla = nla_reserve(skb, IFLA_INET6_CONF, DEVCONF_MAX * sizeof(s32));
|
|
|
|
if (nla == NULL)
|
2006-11-15 04:53:58 +01:00
|
|
|
goto nla_put_failure;
|
2007-04-21 00:56:20 +02:00
|
|
|
ipv6_store_devconf(&idev->cnf, nla_data(nla), nla_len(nla));
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-04-21 00:56:20 +02:00
|
|
|
/* XXX - MC not implemented */
|
|
|
|
|
|
|
|
nla = nla_reserve(skb, IFLA_INET6_STATS, IPSTATS_MIB_MAX * sizeof(u64));
|
|
|
|
if (nla == NULL)
|
|
|
|
goto nla_put_failure;
|
|
|
|
snmp6_fill_stats(nla_data(nla), idev, IFLA_INET6_STATS, nla_len(nla));
|
|
|
|
|
|
|
|
nla = nla_reserve(skb, IFLA_INET6_ICMP6STATS, ICMP6_MIB_MAX * sizeof(u64));
|
|
|
|
if (nla == NULL)
|
|
|
|
goto nla_put_failure;
|
|
|
|
snmp6_fill_stats(nla_data(nla), idev, IFLA_INET6_ICMP6STATS, nla_len(nla));
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-11-15 04:53:58 +01:00
|
|
|
nla_nest_end(skb, protoinfo);
|
|
|
|
return nlmsg_end(skb, nlh);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-11-15 04:53:58 +01:00
|
|
|
nla_put_failure:
|
2007-02-01 08:16:40 +01:00
|
|
|
nlmsg_cancel(skb, nlh);
|
|
|
|
return -EMSGSIZE;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int inet6_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb)
|
|
|
|
{
|
2008-03-25 18:26:21 +01:00
|
|
|
struct net *net = sock_net(skb->sk);
|
2005-04-17 00:20:36 +02:00
|
|
|
int idx, err;
|
|
|
|
int s_idx = cb->args[0];
|
|
|
|
struct net_device *dev;
|
|
|
|
struct inet6_dev *idev;
|
|
|
|
|
|
|
|
read_lock(&dev_base_lock);
|
2007-05-04 00:13:45 +02:00
|
|
|
idx = 0;
|
2008-03-05 19:47:47 +01:00
|
|
|
for_each_netdev(net, dev) {
|
2005-04-17 00:20:36 +02:00
|
|
|
if (idx < s_idx)
|
2007-05-04 00:13:45 +02:00
|
|
|
goto cont;
|
2005-04-17 00:20:36 +02:00
|
|
|
if ((idev = in6_dev_get(dev)) == NULL)
|
2007-05-04 00:13:45 +02:00
|
|
|
goto cont;
|
2007-02-09 15:24:49 +01:00
|
|
|
err = inet6_fill_ifinfo(skb, idev, NETLINK_CB(cb->skb).pid,
|
2005-06-19 07:54:12 +02:00
|
|
|
cb->nlh->nlmsg_seq, RTM_NEWLINK, NLM_F_MULTI);
|
2005-04-17 00:20:36 +02:00
|
|
|
in6_dev_put(idev);
|
|
|
|
if (err <= 0)
|
|
|
|
break;
|
2007-05-04 00:13:45 +02:00
|
|
|
cont:
|
|
|
|
idx++;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
read_unlock(&dev_base_lock);
|
|
|
|
cb->args[0] = idx;
|
|
|
|
|
|
|
|
return skb->len;
|
|
|
|
}
|
|
|
|
|
|
|
|
void inet6_ifinfo_notify(int event, struct inet6_dev *idev)
|
|
|
|
{
|
|
|
|
struct sk_buff *skb;
|
2008-03-25 13:47:49 +01:00
|
|
|
struct net *net = dev_net(idev->dev);
|
2006-08-15 09:35:47 +02:00
|
|
|
int err = -ENOBUFS;
|
2007-02-09 15:24:49 +01:00
|
|
|
|
2006-11-10 23:10:15 +01:00
|
|
|
skb = nlmsg_new(inet6_if_nlmsg_size(), GFP_ATOMIC);
|
2006-08-15 09:35:47 +02:00
|
|
|
if (skb == NULL)
|
|
|
|
goto errout;
|
|
|
|
|
|
|
|
err = inet6_fill_ifinfo(skb, idev, 0, 0, event, 0);
|
2007-02-01 08:16:40 +01:00
|
|
|
if (err < 0) {
|
|
|
|
/* -EMSGSIZE implies BUG in inet6_if_nlmsg_size() */
|
|
|
|
WARN_ON(err == -EMSGSIZE);
|
|
|
|
kfree_skb(skb);
|
|
|
|
goto errout;
|
|
|
|
}
|
2008-03-05 19:47:47 +01:00
|
|
|
err = rtnl_notify(skb, net, 0, RTNLGRP_IPV6_IFADDR, NULL, GFP_ATOMIC);
|
2006-08-15 09:35:47 +02:00
|
|
|
errout:
|
|
|
|
if (err < 0)
|
2008-03-05 19:47:47 +01:00
|
|
|
rtnl_set_sk_err(net, RTNLGRP_IPV6_IFADDR, err);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-11-10 23:10:15 +01:00
|
|
|
static inline size_t inet6_prefix_nlmsg_size(void)
|
|
|
|
{
|
|
|
|
return NLMSG_ALIGN(sizeof(struct prefixmsg))
|
|
|
|
+ nla_total_size(sizeof(struct in6_addr))
|
|
|
|
+ nla_total_size(sizeof(struct prefix_cacheinfo));
|
|
|
|
}
|
2006-06-18 07:48:48 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static int inet6_fill_prefix(struct sk_buff *skb, struct inet6_dev *idev,
|
2006-11-15 04:54:19 +01:00
|
|
|
struct prefix_info *pinfo, u32 pid, u32 seq,
|
|
|
|
int event, unsigned int flags)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-11-15 04:54:19 +01:00
|
|
|
struct prefixmsg *pmsg;
|
|
|
|
struct nlmsghdr *nlh;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct prefix_cacheinfo ci;
|
|
|
|
|
2006-11-15 04:54:19 +01:00
|
|
|
nlh = nlmsg_put(skb, pid, seq, event, sizeof(*pmsg), flags);
|
|
|
|
if (nlh == NULL)
|
2007-02-01 08:16:40 +01:00
|
|
|
return -EMSGSIZE;
|
2006-11-15 04:54:19 +01:00
|
|
|
|
|
|
|
pmsg = nlmsg_data(nlh);
|
2005-04-17 00:20:36 +02:00
|
|
|
pmsg->prefix_family = AF_INET6;
|
2005-06-28 21:56:45 +02:00
|
|
|
pmsg->prefix_pad1 = 0;
|
|
|
|
pmsg->prefix_pad2 = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
pmsg->prefix_ifindex = idev->dev->ifindex;
|
|
|
|
pmsg->prefix_len = pinfo->prefix_len;
|
|
|
|
pmsg->prefix_type = pinfo->type;
|
2005-06-28 21:56:45 +02:00
|
|
|
pmsg->prefix_pad3 = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
pmsg->prefix_flags = 0;
|
|
|
|
if (pinfo->onlink)
|
|
|
|
pmsg->prefix_flags |= IF_PREFIX_ONLINK;
|
|
|
|
if (pinfo->autoconf)
|
|
|
|
pmsg->prefix_flags |= IF_PREFIX_AUTOCONF;
|
|
|
|
|
2006-11-15 04:54:19 +01:00
|
|
|
NLA_PUT(skb, PREFIX_ADDRESS, sizeof(pinfo->prefix), &pinfo->prefix);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
ci.preferred_time = ntohl(pinfo->prefered);
|
|
|
|
ci.valid_time = ntohl(pinfo->valid);
|
2006-11-15 04:54:19 +01:00
|
|
|
NLA_PUT(skb, PREFIX_CACHEINFO, sizeof(ci), &ci);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-11-15 04:54:19 +01:00
|
|
|
return nlmsg_end(skb, nlh);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-11-15 04:54:19 +01:00
|
|
|
nla_put_failure:
|
2007-02-01 08:16:40 +01:00
|
|
|
nlmsg_cancel(skb, nlh);
|
|
|
|
return -EMSGSIZE;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-02-09 15:24:49 +01:00
|
|
|
static void inet6_prefix_notify(int event, struct inet6_dev *idev,
|
2005-04-17 00:20:36 +02:00
|
|
|
struct prefix_info *pinfo)
|
|
|
|
{
|
|
|
|
struct sk_buff *skb;
|
2008-03-25 13:47:49 +01:00
|
|
|
struct net *net = dev_net(idev->dev);
|
2006-08-15 09:36:07 +02:00
|
|
|
int err = -ENOBUFS;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-11-10 23:10:15 +01:00
|
|
|
skb = nlmsg_new(inet6_prefix_nlmsg_size(), GFP_ATOMIC);
|
2006-08-15 09:36:07 +02:00
|
|
|
if (skb == NULL)
|
|
|
|
goto errout;
|
|
|
|
|
|
|
|
err = inet6_fill_prefix(skb, idev, pinfo, 0, 0, event, 0);
|
2007-02-01 08:16:40 +01:00
|
|
|
if (err < 0) {
|
|
|
|
/* -EMSGSIZE implies BUG in inet6_prefix_nlmsg_size() */
|
|
|
|
WARN_ON(err == -EMSGSIZE);
|
|
|
|
kfree_skb(skb);
|
|
|
|
goto errout;
|
|
|
|
}
|
2008-03-05 19:47:47 +01:00
|
|
|
err = rtnl_notify(skb, net, 0, RTNLGRP_IPV6_PREFIX, NULL, GFP_ATOMIC);
|
2006-08-15 09:36:07 +02:00
|
|
|
errout:
|
|
|
|
if (err < 0)
|
2008-03-05 19:47:47 +01:00
|
|
|
rtnl_set_sk_err(net, RTNLGRP_IPV6_PREFIX, err);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __ipv6_ifa_notify(int event, struct inet6_ifaddr *ifp)
|
|
|
|
{
|
|
|
|
inet6_ifa_notify(event ? : RTM_NEWADDR, ifp);
|
|
|
|
|
|
|
|
switch (event) {
|
|
|
|
case RTM_NEWADDR:
|
2007-04-26 02:08:10 +02:00
|
|
|
/*
|
|
|
|
* If the address was optimistic
|
|
|
|
* we inserted the route at the start of
|
|
|
|
* our DAD process, so we don't need
|
|
|
|
* to do it again
|
|
|
|
*/
|
|
|
|
if (!(ifp->rt->rt6i_node))
|
|
|
|
ip6_ins_rt(ifp->rt);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (ifp->idev->cnf.forwarding)
|
|
|
|
addrconf_join_anycast(ifp);
|
|
|
|
break;
|
|
|
|
case RTM_DELADDR:
|
|
|
|
if (ifp->idev->cnf.forwarding)
|
|
|
|
addrconf_leave_anycast(ifp);
|
|
|
|
addrconf_leave_solict(ifp->idev, &ifp->addr);
|
|
|
|
dst_hold(&ifp->rt->u.dst);
|
2006-08-22 09:00:21 +02:00
|
|
|
if (ip6_del_rt(ifp->rt))
|
2005-04-17 00:20:36 +02:00
|
|
|
dst_free(&ifp->rt->u.dst);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ipv6_ifa_notify(int event, struct inet6_ifaddr *ifp)
|
|
|
|
{
|
2006-09-22 23:44:24 +02:00
|
|
|
rcu_read_lock_bh();
|
2005-04-17 00:20:36 +02:00
|
|
|
if (likely(ifp->idev->dead == 0))
|
|
|
|
__ipv6_ifa_notify(event, ifp);
|
2006-09-22 23:44:24 +02:00
|
|
|
rcu_read_unlock_bh();
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_SYSCTL
|
|
|
|
|
|
|
|
static
|
|
|
|
int addrconf_sysctl_forward(ctl_table *ctl, int write, struct file * filp,
|
|
|
|
void __user *buffer, size_t *lenp, loff_t *ppos)
|
|
|
|
{
|
|
|
|
int *valp = ctl->data;
|
|
|
|
int val = *valp;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
|
|
|
|
|
2007-12-05 10:50:24 +01:00
|
|
|
if (write)
|
|
|
|
addrconf_fixup_forwarding(ctl, valp, val);
|
2007-02-09 15:24:49 +01:00
|
|
|
return ret;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-02-09 15:24:49 +01:00
|
|
|
static int addrconf_sysctl_forward_strategy(ctl_table *table,
|
2005-04-17 00:20:36 +02:00
|
|
|
void __user *oldval,
|
|
|
|
size_t __user *oldlenp,
|
2006-12-10 11:19:10 +01:00
|
|
|
void __user *newval, size_t newlen)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
int *valp = table->data;
|
2007-12-05 10:50:24 +01:00
|
|
|
int val = *valp;
|
2005-04-17 00:20:36 +02:00
|
|
|
int new;
|
|
|
|
|
|
|
|
if (!newval || !newlen)
|
|
|
|
return 0;
|
|
|
|
if (newlen != sizeof(int))
|
|
|
|
return -EINVAL;
|
|
|
|
if (get_user(new, (int __user *)newval))
|
|
|
|
return -EFAULT;
|
|
|
|
if (new == *valp)
|
|
|
|
return 0;
|
|
|
|
if (oldval && oldlenp) {
|
|
|
|
size_t len;
|
|
|
|
if (get_user(len, oldlenp))
|
|
|
|
return -EFAULT;
|
|
|
|
if (len) {
|
|
|
|
if (len > table->maxlen)
|
|
|
|
len = table->maxlen;
|
|
|
|
if (copy_to_user(oldval, valp, len))
|
|
|
|
return -EFAULT;
|
|
|
|
if (put_user(len, oldlenp))
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-12-05 10:50:24 +01:00
|
|
|
*valp = new;
|
|
|
|
addrconf_fixup_forwarding(table, valp, val);
|
2005-04-17 00:20:36 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct addrconf_sysctl_table
|
|
|
|
{
|
|
|
|
struct ctl_table_header *sysctl_header;
|
2008-03-24 16:25:11 +01:00
|
|
|
ctl_table addrconf_vars[DEVCONF_MAX+1];
|
2007-12-01 14:59:38 +01:00
|
|
|
char *dev_name;
|
2006-09-22 23:15:41 +02:00
|
|
|
} addrconf_sysctl __read_mostly = {
|
2005-04-17 00:20:36 +02:00
|
|
|
.sysctl_header = NULL,
|
|
|
|
.addrconf_vars = {
|
2007-02-09 15:24:49 +01:00
|
|
|
{
|
2005-04-17 00:20:36 +02:00
|
|
|
.ctl_name = NET_IPV6_FORWARDING,
|
|
|
|
.procname = "forwarding",
|
2007-02-09 15:24:49 +01:00
|
|
|
.data = &ipv6_devconf.forwarding,
|
2005-04-17 00:20:36 +02:00
|
|
|
.maxlen = sizeof(int),
|
|
|
|
.mode = 0644,
|
2007-02-09 15:24:49 +01:00
|
|
|
.proc_handler = &addrconf_sysctl_forward,
|
2005-04-17 00:20:36 +02:00
|
|
|
.strategy = &addrconf_sysctl_forward_strategy,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.ctl_name = NET_IPV6_HOP_LIMIT,
|
|
|
|
.procname = "hop_limit",
|
2007-02-09 15:24:49 +01:00
|
|
|
.data = &ipv6_devconf.hop_limit,
|
2005-04-17 00:20:36 +02:00
|
|
|
.maxlen = sizeof(int),
|
|
|
|
.mode = 0644,
|
|
|
|
.proc_handler = proc_dointvec,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.ctl_name = NET_IPV6_MTU,
|
|
|
|
.procname = "mtu",
|
|
|
|
.data = &ipv6_devconf.mtu6,
|
2007-02-09 15:24:49 +01:00
|
|
|
.maxlen = sizeof(int),
|
2005-04-17 00:20:36 +02:00
|
|
|
.mode = 0644,
|
2007-02-09 15:24:49 +01:00
|
|
|
.proc_handler = &proc_dointvec,
|
2005-04-17 00:20:36 +02:00
|
|
|
},
|
|
|
|
{
|
|
|
|
.ctl_name = NET_IPV6_ACCEPT_RA,
|
|
|
|
.procname = "accept_ra",
|
2007-02-09 15:24:49 +01:00
|
|
|
.data = &ipv6_devconf.accept_ra,
|
2005-04-17 00:20:36 +02:00
|
|
|
.maxlen = sizeof(int),
|
|
|
|
.mode = 0644,
|
2007-02-09 15:24:49 +01:00
|
|
|
.proc_handler = &proc_dointvec,
|
2005-04-17 00:20:36 +02:00
|
|
|
},
|
|
|
|
{
|
|
|
|
.ctl_name = NET_IPV6_ACCEPT_REDIRECTS,
|
|
|
|
.procname = "accept_redirects",
|
2007-02-09 15:24:49 +01:00
|
|
|
.data = &ipv6_devconf.accept_redirects,
|
2005-04-17 00:20:36 +02:00
|
|
|
.maxlen = sizeof(int),
|
|
|
|
.mode = 0644,
|
2007-02-09 15:24:49 +01:00
|
|
|
.proc_handler = &proc_dointvec,
|
2005-04-17 00:20:36 +02:00
|
|
|
},
|
|
|
|
{
|
|
|
|
.ctl_name = NET_IPV6_AUTOCONF,
|
|
|
|
.procname = "autoconf",
|
2007-02-09 15:24:49 +01:00
|
|
|
.data = &ipv6_devconf.autoconf,
|
2005-04-17 00:20:36 +02:00
|
|
|
.maxlen = sizeof(int),
|
|
|
|
.mode = 0644,
|
2007-02-09 15:24:49 +01:00
|
|
|
.proc_handler = &proc_dointvec,
|
2005-04-17 00:20:36 +02:00
|
|
|
},
|
|
|
|
{
|
|
|
|
.ctl_name = NET_IPV6_DAD_TRANSMITS,
|
|
|
|
.procname = "dad_transmits",
|
2007-02-09 15:24:49 +01:00
|
|
|
.data = &ipv6_devconf.dad_transmits,
|
2005-04-17 00:20:36 +02:00
|
|
|
.maxlen = sizeof(int),
|
|
|
|
.mode = 0644,
|
2007-02-09 15:24:49 +01:00
|
|
|
.proc_handler = &proc_dointvec,
|
2005-04-17 00:20:36 +02:00
|
|
|
},
|
|
|
|
{
|
|
|
|
.ctl_name = NET_IPV6_RTR_SOLICITS,
|
|
|
|
.procname = "router_solicitations",
|
2007-02-09 15:24:49 +01:00
|
|
|
.data = &ipv6_devconf.rtr_solicits,
|
2005-04-17 00:20:36 +02:00
|
|
|
.maxlen = sizeof(int),
|
|
|
|
.mode = 0644,
|
2007-02-09 15:24:49 +01:00
|
|
|
.proc_handler = &proc_dointvec,
|
2005-04-17 00:20:36 +02:00
|
|
|
},
|
|
|
|
{
|
|
|
|
.ctl_name = NET_IPV6_RTR_SOLICIT_INTERVAL,
|
|
|
|
.procname = "router_solicitation_interval",
|
2007-02-09 15:24:49 +01:00
|
|
|
.data = &ipv6_devconf.rtr_solicit_interval,
|
2005-04-17 00:20:36 +02:00
|
|
|
.maxlen = sizeof(int),
|
|
|
|
.mode = 0644,
|
2007-02-09 15:24:49 +01:00
|
|
|
.proc_handler = &proc_dointvec_jiffies,
|
2005-04-17 00:20:36 +02:00
|
|
|
.strategy = &sysctl_jiffies,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.ctl_name = NET_IPV6_RTR_SOLICIT_DELAY,
|
|
|
|
.procname = "router_solicitation_delay",
|
2007-02-09 15:24:49 +01:00
|
|
|
.data = &ipv6_devconf.rtr_solicit_delay,
|
2005-04-17 00:20:36 +02:00
|
|
|
.maxlen = sizeof(int),
|
|
|
|
.mode = 0644,
|
2007-02-09 15:24:49 +01:00
|
|
|
.proc_handler = &proc_dointvec_jiffies,
|
2005-04-17 00:20:36 +02:00
|
|
|
.strategy = &sysctl_jiffies,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.ctl_name = NET_IPV6_FORCE_MLD_VERSION,
|
|
|
|
.procname = "force_mld_version",
|
2007-02-09 15:24:49 +01:00
|
|
|
.data = &ipv6_devconf.force_mld_version,
|
2005-04-17 00:20:36 +02:00
|
|
|
.maxlen = sizeof(int),
|
|
|
|
.mode = 0644,
|
2007-02-09 15:24:49 +01:00
|
|
|
.proc_handler = &proc_dointvec,
|
2005-04-17 00:20:36 +02:00
|
|
|
},
|
|
|
|
#ifdef CONFIG_IPV6_PRIVACY
|
|
|
|
{
|
|
|
|
.ctl_name = NET_IPV6_USE_TEMPADDR,
|
|
|
|
.procname = "use_tempaddr",
|
2007-02-09 15:24:49 +01:00
|
|
|
.data = &ipv6_devconf.use_tempaddr,
|
2005-04-17 00:20:36 +02:00
|
|
|
.maxlen = sizeof(int),
|
|
|
|
.mode = 0644,
|
2007-02-09 15:24:49 +01:00
|
|
|
.proc_handler = &proc_dointvec,
|
2005-04-17 00:20:36 +02:00
|
|
|
},
|
|
|
|
{
|
|
|
|
.ctl_name = NET_IPV6_TEMP_VALID_LFT,
|
|
|
|
.procname = "temp_valid_lft",
|
2007-02-09 15:24:49 +01:00
|
|
|
.data = &ipv6_devconf.temp_valid_lft,
|
2005-04-17 00:20:36 +02:00
|
|
|
.maxlen = sizeof(int),
|
|
|
|
.mode = 0644,
|
2007-02-09 15:24:49 +01:00
|
|
|
.proc_handler = &proc_dointvec,
|
2005-04-17 00:20:36 +02:00
|
|
|
},
|
|
|
|
{
|
|
|
|
.ctl_name = NET_IPV6_TEMP_PREFERED_LFT,
|
|
|
|
.procname = "temp_prefered_lft",
|
2007-02-09 15:24:49 +01:00
|
|
|
.data = &ipv6_devconf.temp_prefered_lft,
|
2005-04-17 00:20:36 +02:00
|
|
|
.maxlen = sizeof(int),
|
|
|
|
.mode = 0644,
|
2007-02-09 15:24:49 +01:00
|
|
|
.proc_handler = &proc_dointvec,
|
2005-04-17 00:20:36 +02:00
|
|
|
},
|
|
|
|
{
|
|
|
|
.ctl_name = NET_IPV6_REGEN_MAX_RETRY,
|
|
|
|
.procname = "regen_max_retry",
|
2007-02-09 15:24:49 +01:00
|
|
|
.data = &ipv6_devconf.regen_max_retry,
|
2005-04-17 00:20:36 +02:00
|
|
|
.maxlen = sizeof(int),
|
|
|
|
.mode = 0644,
|
2007-02-09 15:24:49 +01:00
|
|
|
.proc_handler = &proc_dointvec,
|
2005-04-17 00:20:36 +02:00
|
|
|
},
|
|
|
|
{
|
|
|
|
.ctl_name = NET_IPV6_MAX_DESYNC_FACTOR,
|
|
|
|
.procname = "max_desync_factor",
|
2007-02-09 15:24:49 +01:00
|
|
|
.data = &ipv6_devconf.max_desync_factor,
|
2005-04-17 00:20:36 +02:00
|
|
|
.maxlen = sizeof(int),
|
|
|
|
.mode = 0644,
|
2007-02-09 15:24:49 +01:00
|
|
|
.proc_handler = &proc_dointvec,
|
2005-04-17 00:20:36 +02:00
|
|
|
},
|
|
|
|
#endif
|
|
|
|
{
|
|
|
|
.ctl_name = NET_IPV6_MAX_ADDRESSES,
|
|
|
|
.procname = "max_addresses",
|
|
|
|
.data = &ipv6_devconf.max_addresses,
|
|
|
|
.maxlen = sizeof(int),
|
|
|
|
.mode = 0644,
|
|
|
|
.proc_handler = &proc_dointvec,
|
|
|
|
},
|
2006-03-21 01:55:08 +01:00
|
|
|
{
|
|
|
|
.ctl_name = NET_IPV6_ACCEPT_RA_DEFRTR,
|
|
|
|
.procname = "accept_ra_defrtr",
|
2007-02-09 15:24:49 +01:00
|
|
|
.data = &ipv6_devconf.accept_ra_defrtr,
|
2006-03-21 01:55:08 +01:00
|
|
|
.maxlen = sizeof(int),
|
|
|
|
.mode = 0644,
|
2007-02-09 15:24:49 +01:00
|
|
|
.proc_handler = &proc_dointvec,
|
2006-03-21 01:55:08 +01:00
|
|
|
},
|
2006-03-21 01:55:26 +01:00
|
|
|
{
|
|
|
|
.ctl_name = NET_IPV6_ACCEPT_RA_PINFO,
|
|
|
|
.procname = "accept_ra_pinfo",
|
2007-02-09 15:24:49 +01:00
|
|
|
.data = &ipv6_devconf.accept_ra_pinfo,
|
2006-03-21 01:55:26 +01:00
|
|
|
.maxlen = sizeof(int),
|
|
|
|
.mode = 0644,
|
2007-02-09 15:24:49 +01:00
|
|
|
.proc_handler = &proc_dointvec,
|
2006-03-21 01:55:26 +01:00
|
|
|
},
|
2006-03-21 02:05:30 +01:00
|
|
|
#ifdef CONFIG_IPV6_ROUTER_PREF
|
|
|
|
{
|
|
|
|
.ctl_name = NET_IPV6_ACCEPT_RA_RTR_PREF,
|
|
|
|
.procname = "accept_ra_rtr_pref",
|
|
|
|
.data = &ipv6_devconf.accept_ra_rtr_pref,
|
|
|
|
.maxlen = sizeof(int),
|
|
|
|
.mode = 0644,
|
|
|
|
.proc_handler = &proc_dointvec,
|
|
|
|
},
|
2006-03-21 02:05:47 +01:00
|
|
|
{
|
|
|
|
.ctl_name = NET_IPV6_RTR_PROBE_INTERVAL,
|
|
|
|
.procname = "router_probe_interval",
|
|
|
|
.data = &ipv6_devconf.rtr_probe_interval,
|
|
|
|
.maxlen = sizeof(int),
|
|
|
|
.mode = 0644,
|
|
|
|
.proc_handler = &proc_dointvec_jiffies,
|
|
|
|
.strategy = &sysctl_jiffies,
|
|
|
|
},
|
2007-01-30 23:30:10 +01:00
|
|
|
#ifdef CONFIG_IPV6_ROUTE_INFO
|
2006-03-21 02:07:03 +01:00
|
|
|
{
|
|
|
|
.ctl_name = NET_IPV6_ACCEPT_RA_RT_INFO_MAX_PLEN,
|
|
|
|
.procname = "accept_ra_rt_info_max_plen",
|
|
|
|
.data = &ipv6_devconf.accept_ra_rt_info_max_plen,
|
|
|
|
.maxlen = sizeof(int),
|
|
|
|
.mode = 0644,
|
|
|
|
.proc_handler = &proc_dointvec,
|
|
|
|
},
|
|
|
|
#endif
|
2006-03-21 02:05:30 +01:00
|
|
|
#endif
|
2006-09-22 23:43:49 +02:00
|
|
|
{
|
|
|
|
.ctl_name = NET_IPV6_PROXY_NDP,
|
|
|
|
.procname = "proxy_ndp",
|
|
|
|
.data = &ipv6_devconf.proxy_ndp,
|
|
|
|
.maxlen = sizeof(int),
|
|
|
|
.mode = 0644,
|
|
|
|
.proc_handler = &proc_dointvec,
|
|
|
|
},
|
2007-04-24 23:58:30 +02:00
|
|
|
{
|
|
|
|
.ctl_name = NET_IPV6_ACCEPT_SOURCE_ROUTE,
|
|
|
|
.procname = "accept_source_route",
|
|
|
|
.data = &ipv6_devconf.accept_source_route,
|
|
|
|
.maxlen = sizeof(int),
|
|
|
|
.mode = 0644,
|
|
|
|
.proc_handler = &proc_dointvec,
|
|
|
|
},
|
2007-04-26 02:08:10 +02:00
|
|
|
#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
|
|
|
|
{
|
|
|
|
.ctl_name = CTL_UNNUMBERED,
|
|
|
|
.procname = "optimistic_dad",
|
|
|
|
.data = &ipv6_devconf.optimistic_dad,
|
|
|
|
.maxlen = sizeof(int),
|
|
|
|
.mode = 0644,
|
|
|
|
.proc_handler = &proc_dointvec,
|
|
|
|
|
|
|
|
},
|
2008-04-03 02:22:53 +02:00
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_IPV6_MROUTE
|
|
|
|
{
|
|
|
|
.ctl_name = CTL_UNNUMBERED,
|
|
|
|
.procname = "mc_forwarding",
|
|
|
|
.data = &ipv6_devconf.mc_forwarding,
|
|
|
|
.maxlen = sizeof(int),
|
|
|
|
.mode = 0644,
|
|
|
|
.proc_handler = &proc_dointvec,
|
|
|
|
},
|
2007-04-26 02:08:10 +02:00
|
|
|
#endif
|
2008-06-28 07:17:11 +02:00
|
|
|
{
|
|
|
|
.ctl_name = CTL_UNNUMBERED,
|
|
|
|
.procname = "disable_ipv6",
|
|
|
|
.data = &ipv6_devconf.disable_ipv6,
|
|
|
|
.maxlen = sizeof(int),
|
|
|
|
.mode = 0644,
|
|
|
|
.proc_handler = &proc_dointvec,
|
|
|
|
},
|
2008-06-28 07:18:38 +02:00
|
|
|
{
|
|
|
|
.ctl_name = CTL_UNNUMBERED,
|
|
|
|
.procname = "accept_dad",
|
|
|
|
.data = &ipv6_devconf.accept_dad,
|
|
|
|
.maxlen = sizeof(int),
|
|
|
|
.mode = 0644,
|
|
|
|
.proc_handler = &proc_dointvec,
|
|
|
|
},
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
.ctl_name = 0, /* sentinel */
|
|
|
|
}
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2008-01-11 02:42:13 +01:00
|
|
|
static int __addrconf_sysctl_register(struct net *net, char *dev_name,
|
|
|
|
int ctl_name, struct inet6_dev *idev, struct ipv6_devconf *p)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct addrconf_sysctl_table *t;
|
|
|
|
|
2007-12-01 14:59:38 +01:00
|
|
|
#define ADDRCONF_CTL_PATH_DEV 3
|
|
|
|
|
|
|
|
struct ctl_path addrconf_ctl_path[] = {
|
|
|
|
{ .procname = "net", .ctl_name = CTL_NET, },
|
|
|
|
{ .procname = "ipv6", .ctl_name = NET_IPV6, },
|
|
|
|
{ .procname = "conf", .ctl_name = NET_IPV6_CONF, },
|
|
|
|
{ /* to be set */ },
|
|
|
|
{ },
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2006-11-17 15:14:37 +01:00
|
|
|
t = kmemdup(&addrconf_sysctl, sizeof(*t), GFP_KERNEL);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (t == NULL)
|
2007-12-01 14:21:52 +01:00
|
|
|
goto out;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
for (i=0; t->addrconf_vars[i].data; i++) {
|
|
|
|
t->addrconf_vars[i].data += (char*)p - (char*)&ipv6_devconf;
|
|
|
|
t->addrconf_vars[i].extra1 = idev; /* embedded; no ref */
|
2008-01-11 02:42:13 +01:00
|
|
|
t->addrconf_vars[i].extra2 = net;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-02-09 15:24:49 +01:00
|
|
|
/*
|
|
|
|
* Make a copy of dev_name, because '.procname' is regarded as const
|
2005-04-17 00:20:36 +02:00
|
|
|
* by sysctl and we wouldn't want anyone to change it under our feet
|
|
|
|
* (see SIOCSIFNAME).
|
2007-02-09 15:24:49 +01:00
|
|
|
*/
|
2007-12-01 14:59:38 +01:00
|
|
|
t->dev_name = kstrdup(dev_name, GFP_KERNEL);
|
|
|
|
if (!t->dev_name)
|
2007-12-01 14:21:52 +01:00
|
|
|
goto free;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-12-01 14:59:38 +01:00
|
|
|
addrconf_ctl_path[ADDRCONF_CTL_PATH_DEV].procname = t->dev_name;
|
|
|
|
addrconf_ctl_path[ADDRCONF_CTL_PATH_DEV].ctl_name = ctl_name;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-01-11 02:42:13 +01:00
|
|
|
t->sysctl_header = register_net_sysctl_table(net, addrconf_ctl_path,
|
2007-12-01 14:59:38 +01:00
|
|
|
t->addrconf_vars);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (t->sysctl_header == NULL)
|
|
|
|
goto free_procname;
|
2007-12-01 14:21:52 +01:00
|
|
|
|
|
|
|
p->sysctl = t;
|
2008-01-11 02:41:45 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-12-01 14:21:52 +01:00
|
|
|
free_procname:
|
2007-12-01 14:59:38 +01:00
|
|
|
kfree(t->dev_name);
|
2007-12-01 14:21:52 +01:00
|
|
|
free:
|
2005-04-17 00:20:36 +02:00
|
|
|
kfree(t);
|
2007-12-01 14:21:52 +01:00
|
|
|
out:
|
2008-01-11 02:41:45 +01:00
|
|
|
return -ENOBUFS;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-01-11 02:41:21 +01:00
|
|
|
static void __addrconf_sysctl_unregister(struct ipv6_devconf *p)
|
|
|
|
{
|
|
|
|
struct addrconf_sysctl_table *t;
|
|
|
|
|
|
|
|
if (p->sysctl == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
t = p->sysctl;
|
|
|
|
p->sysctl = NULL;
|
|
|
|
unregister_sysctl_table(t->sysctl_header);
|
|
|
|
kfree(t->dev_name);
|
|
|
|
kfree(t);
|
|
|
|
}
|
|
|
|
|
2007-12-01 14:58:37 +01:00
|
|
|
static void addrconf_sysctl_register(struct inet6_dev *idev)
|
|
|
|
{
|
2008-01-11 02:41:21 +01:00
|
|
|
neigh_sysctl_register(idev->dev, idev->nd_parms, NET_IPV6,
|
|
|
|
NET_IPV6_NEIGH, "ipv6",
|
|
|
|
&ndisc_ifinfo_sysctl_change,
|
2008-05-20 01:25:42 +02:00
|
|
|
ndisc_ifinfo_sysctl_strategy);
|
2008-03-25 13:47:49 +01:00
|
|
|
__addrconf_sysctl_register(dev_net(idev->dev), idev->dev->name,
|
2008-01-11 02:42:13 +01:00
|
|
|
idev->dev->ifindex, idev, &idev->cnf);
|
2007-12-01 14:58:37 +01:00
|
|
|
}
|
|
|
|
|
2008-01-11 02:41:21 +01:00
|
|
|
static void addrconf_sysctl_unregister(struct inet6_dev *idev)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-01-11 02:41:21 +01:00
|
|
|
__addrconf_sysctl_unregister(&idev->cnf);
|
|
|
|
neigh_sysctl_unregister(idev->nd_parms);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2008-01-11 02:42:55 +01:00
|
|
|
static int addrconf_init_net(struct net *net)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
struct ipv6_devconf *all, *dflt;
|
|
|
|
|
|
|
|
err = -ENOMEM;
|
|
|
|
all = &ipv6_devconf;
|
|
|
|
dflt = &ipv6_devconf_dflt;
|
|
|
|
|
|
|
|
if (net != &init_net) {
|
|
|
|
all = kmemdup(all, sizeof(ipv6_devconf), GFP_KERNEL);
|
|
|
|
if (all == NULL)
|
|
|
|
goto err_alloc_all;
|
|
|
|
|
|
|
|
dflt = kmemdup(dflt, sizeof(ipv6_devconf_dflt), GFP_KERNEL);
|
|
|
|
if (dflt == NULL)
|
|
|
|
goto err_alloc_dflt;
|
|
|
|
}
|
|
|
|
|
|
|
|
net->ipv6.devconf_all = all;
|
|
|
|
net->ipv6.devconf_dflt = dflt;
|
|
|
|
|
|
|
|
#ifdef CONFIG_SYSCTL
|
|
|
|
err = __addrconf_sysctl_register(net, "all", NET_PROTO_CONF_ALL,
|
|
|
|
NULL, all);
|
|
|
|
if (err < 0)
|
|
|
|
goto err_reg_all;
|
|
|
|
|
|
|
|
err = __addrconf_sysctl_register(net, "default", NET_PROTO_CONF_DEFAULT,
|
|
|
|
NULL, dflt);
|
|
|
|
if (err < 0)
|
|
|
|
goto err_reg_dflt;
|
|
|
|
#endif
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
#ifdef CONFIG_SYSCTL
|
|
|
|
err_reg_dflt:
|
|
|
|
__addrconf_sysctl_unregister(all);
|
|
|
|
err_reg_all:
|
|
|
|
kfree(dflt);
|
|
|
|
#endif
|
|
|
|
err_alloc_dflt:
|
|
|
|
kfree(all);
|
|
|
|
err_alloc_all:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void addrconf_exit_net(struct net *net)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_SYSCTL
|
|
|
|
__addrconf_sysctl_unregister(net->ipv6.devconf_dflt);
|
|
|
|
__addrconf_sysctl_unregister(net->ipv6.devconf_all);
|
|
|
|
#endif
|
|
|
|
if (net != &init_net) {
|
|
|
|
kfree(net->ipv6.devconf_dflt);
|
|
|
|
kfree(net->ipv6.devconf_all);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct pernet_operations addrconf_ops = {
|
|
|
|
.init = addrconf_init_net,
|
|
|
|
.exit = addrconf_exit_net,
|
|
|
|
};
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Device notifier
|
|
|
|
*/
|
|
|
|
|
|
|
|
int register_inet6addr_notifier(struct notifier_block *nb)
|
|
|
|
{
|
2007-02-09 15:24:49 +01:00
|
|
|
return atomic_notifier_chain_register(&inet6addr_chain, nb);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-02-22 14:05:40 +01:00
|
|
|
EXPORT_SYMBOL(register_inet6addr_notifier);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
int unregister_inet6addr_notifier(struct notifier_block *nb)
|
|
|
|
{
|
2007-02-09 15:24:49 +01:00
|
|
|
return atomic_notifier_chain_unregister(&inet6addr_chain,nb);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-02-22 14:05:40 +01:00
|
|
|
EXPORT_SYMBOL(unregister_inet6addr_notifier);
|
|
|
|
|
2008-03-05 19:46:57 +01:00
|
|
|
static void addrconf_net_exit(struct net *net)
|
|
|
|
{
|
2008-03-05 19:47:47 +01:00
|
|
|
struct net_device *dev;
|
|
|
|
|
|
|
|
rtnl_lock();
|
|
|
|
/* clean dev list */
|
|
|
|
for_each_netdev(net, dev) {
|
|
|
|
if (__in6_dev_get(dev) == NULL)
|
|
|
|
continue;
|
|
|
|
addrconf_ifdown(dev, 1);
|
|
|
|
}
|
|
|
|
addrconf_ifdown(net->loopback_dev, 2);
|
|
|
|
rtnl_unlock();
|
2008-03-05 19:46:57 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct pernet_operations addrconf_net_ops = {
|
|
|
|
.exit = addrconf_net_exit,
|
|
|
|
};
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Init / cleanup code
|
|
|
|
*/
|
|
|
|
|
|
|
|
int __init addrconf_init(void)
|
|
|
|
{
|
2007-11-14 07:56:23 +01:00
|
|
|
int err;
|
|
|
|
|
|
|
|
if ((err = ipv6_addr_label_init()) < 0) {
|
|
|
|
printk(KERN_CRIT "IPv6 Addrconf: cannot initialize default policy table: %d.\n",
|
|
|
|
err);
|
|
|
|
return err;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-01-11 02:42:55 +01:00
|
|
|
register_pernet_subsys(&addrconf_ops);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* The addrconf netdev notifier requires that loopback_dev
|
|
|
|
* has it's ipv6 private information allocated and setup
|
|
|
|
* before it can bring up and give link-local addresses
|
|
|
|
* to other devices which are up.
|
|
|
|
*
|
|
|
|
* Unfortunately, loopback_dev is not necessarily the first
|
|
|
|
* entry in the global dev_base list of net devices. In fact,
|
|
|
|
* it is likely to be the very last entry on that list.
|
|
|
|
* So this causes the notifier registry below to try and
|
|
|
|
* give link-local addresses to all devices besides loopback_dev
|
|
|
|
* first, then loopback_dev, which cases all the non-loopback_dev
|
|
|
|
* devices to fail to get a link-local address.
|
|
|
|
*
|
|
|
|
* So, as a temporary fix, allocate the ipv6 structure for
|
|
|
|
* loopback_dev first by hand.
|
|
|
|
* Longer term, all of the dependencies ipv6 has upon the loopback
|
|
|
|
* device and it being up should be removed.
|
|
|
|
*/
|
|
|
|
rtnl_lock();
|
2007-09-27 07:10:56 +02:00
|
|
|
if (!ipv6_add_dev(init_net.loopback_dev))
|
2005-04-17 00:20:36 +02:00
|
|
|
err = -ENOMEM;
|
|
|
|
rtnl_unlock();
|
|
|
|
if (err)
|
2008-01-11 02:42:55 +01:00
|
|
|
goto errlo;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-03-05 19:46:57 +01:00
|
|
|
err = register_pernet_device(&addrconf_net_ops);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
register_netdevice_notifier(&ipv6_dev_notf);
|
|
|
|
|
|
|
|
addrconf_verify(0);
|
2007-03-22 19:58:32 +01:00
|
|
|
|
|
|
|
err = __rtnl_register(PF_INET6, RTM_GETLINK, NULL, inet6_dump_ifinfo);
|
|
|
|
if (err < 0)
|
|
|
|
goto errout;
|
|
|
|
|
|
|
|
/* Only the first call to __rtnl_register can fail */
|
|
|
|
__rtnl_register(PF_INET6, RTM_NEWADDR, inet6_rtm_newaddr, NULL);
|
|
|
|
__rtnl_register(PF_INET6, RTM_DELADDR, inet6_rtm_deladdr, NULL);
|
|
|
|
__rtnl_register(PF_INET6, RTM_GETADDR, inet6_rtm_getaddr, inet6_dump_ifaddr);
|
|
|
|
__rtnl_register(PF_INET6, RTM_GETMULTICAST, NULL, inet6_dump_ifmcaddr);
|
|
|
|
__rtnl_register(PF_INET6, RTM_GETANYCAST, NULL, inet6_dump_ifacaddr);
|
|
|
|
|
2007-11-14 07:56:23 +01:00
|
|
|
ipv6_addr_label_rtnl_register();
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
2007-03-22 19:58:32 +01:00
|
|
|
errout:
|
|
|
|
unregister_netdevice_notifier(&ipv6_dev_notf);
|
2008-01-11 02:42:55 +01:00
|
|
|
errlo:
|
|
|
|
unregister_pernet_subsys(&addrconf_ops);
|
2007-03-22 19:58:32 +01:00
|
|
|
|
|
|
|
return err;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-12-13 14:34:58 +01:00
|
|
|
void addrconf_cleanup(void)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2007-02-09 15:24:49 +01:00
|
|
|
struct inet6_ifaddr *ifa;
|
2005-04-17 00:20:36 +02:00
|
|
|
int i;
|
|
|
|
|
|
|
|
unregister_netdevice_notifier(&ipv6_dev_notf);
|
2008-03-05 19:46:57 +01:00
|
|
|
unregister_pernet_device(&addrconf_net_ops);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-01-11 02:42:55 +01:00
|
|
|
unregister_pernet_subsys(&addrconf_ops);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
rtnl_lock();
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check hash table.
|
|
|
|
*/
|
|
|
|
write_lock_bh(&addrconf_hash_lock);
|
|
|
|
for (i=0; i < IN6_ADDR_HSIZE; i++) {
|
|
|
|
for (ifa=inet6_addr_lst[i]; ifa; ) {
|
|
|
|
struct inet6_ifaddr *bifa;
|
|
|
|
|
|
|
|
bifa = ifa;
|
|
|
|
ifa = ifa->lst_next;
|
|
|
|
printk(KERN_DEBUG "bug: IPv6 address leakage detected: ifa=%p\n", bifa);
|
|
|
|
/* Do not free it; something is wrong.
|
|
|
|
Now we can investigate it with debugger.
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
}
|
|
|
|
write_unlock_bh(&addrconf_hash_lock);
|
|
|
|
|
|
|
|
del_timer(&addr_chk_timer);
|
|
|
|
rtnl_unlock();
|
2008-03-05 19:46:57 +01:00
|
|
|
|
|
|
|
unregister_pernet_subsys(&addrconf_net_ops);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|