2008-04-03 08:22:53 +08:00
|
|
|
/*
|
|
|
|
* Linux IPv6 multicast routing support for BSD pim6sd
|
|
|
|
* Based on net/ipv4/ipmr.c.
|
|
|
|
*
|
|
|
|
* (c) 2004 Mickael Hoerdt, <hoerdt@clarinet.u-strasbg.fr>
|
|
|
|
* LSIIT Laboratory, Strasbourg, France
|
|
|
|
* (c) 2004 Jean-Philippe Andriot, <jean-philippe.andriot@6WIND.com>
|
|
|
|
* 6WIND, Paris, France
|
|
|
|
* Copyright (C)2007,2008 USAGI/WIDE Project
|
|
|
|
* YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <asm/system.h>
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/timer.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/fcntl.h>
|
|
|
|
#include <linux/stat.h>
|
|
|
|
#include <linux/socket.h>
|
|
|
|
#include <linux/inet.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/inetdevice.h>
|
|
|
|
#include <linux/proc_fs.h>
|
|
|
|
#include <linux/seq_file.h>
|
|
|
|
#include <linux/init.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 16:04:11 +08:00
|
|
|
#include <linux/slab.h>
|
2011-02-04 09:59:32 +08:00
|
|
|
#include <linux/compat.h>
|
2008-04-03 08:22:53 +08:00
|
|
|
#include <net/protocol.h>
|
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <net/sock.h>
|
|
|
|
#include <net/raw.h>
|
|
|
|
#include <linux/notifier.h>
|
|
|
|
#include <linux/if_arp.h>
|
|
|
|
#include <net/checksum.h>
|
|
|
|
#include <net/netlink.h>
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
#include <net/fib_rules.h>
|
2008-04-03 08:22:53 +08:00
|
|
|
|
|
|
|
#include <net/ipv6.h>
|
|
|
|
#include <net/ip6_route.h>
|
|
|
|
#include <linux/mroute6.h>
|
2008-04-03 08:22:54 +08:00
|
|
|
#include <linux/pim.h>
|
2008-04-03 08:22:53 +08:00
|
|
|
#include <net/addrconf.h>
|
|
|
|
#include <linux/netfilter_ipv6.h>
|
2009-01-31 16:51:49 +08:00
|
|
|
#include <net/ip6_checksum.h>
|
2008-04-03 08:22:53 +08:00
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
struct mr6_table {
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
struct list_head list;
|
2010-05-11 20:40:53 +08:00
|
|
|
#ifdef CONFIG_NET_NS
|
|
|
|
struct net *net;
|
|
|
|
#endif
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
u32 id;
|
2010-05-11 20:40:53 +08:00
|
|
|
struct sock *mroute6_sk;
|
|
|
|
struct timer_list ipmr_expire_timer;
|
|
|
|
struct list_head mfc6_unres_queue;
|
|
|
|
struct list_head mfc6_cache_array[MFC6_LINES];
|
|
|
|
struct mif_device vif6_table[MAXMIFS];
|
|
|
|
int maxvif;
|
|
|
|
atomic_t cache_resolve_queue_len;
|
|
|
|
int mroute_do_assert;
|
|
|
|
int mroute_do_pim;
|
|
|
|
#ifdef CONFIG_IPV6_PIMSM_V2
|
|
|
|
int mroute_reg_vif_num;
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
struct ip6mr_rule {
|
|
|
|
struct fib_rule common;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ip6mr_result {
|
|
|
|
struct mr6_table *mrt;
|
|
|
|
};
|
|
|
|
|
2008-04-03 08:22:53 +08:00
|
|
|
/* Big lock, protecting vif table, mrt cache and mroute socket state.
|
|
|
|
Note that the changes are semaphored via rtnl_lock.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static DEFINE_RWLOCK(mrt_lock);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Multicast router control variables
|
|
|
|
*/
|
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
#define MIF_EXISTS(_mrt, _idx) ((_mrt)->vif6_table[_idx].dev != NULL)
|
2008-04-03 08:22:53 +08:00
|
|
|
|
|
|
|
/* Special spinlock for queue of unresolved entries */
|
|
|
|
static DEFINE_SPINLOCK(mfc_unres_lock);
|
|
|
|
|
|
|
|
/* We return to original Alan's scheme. Hash table of resolved
|
|
|
|
entries is changed only in process context and protected
|
|
|
|
with weak lock mrt_lock. Queue of unresolved entries is protected
|
|
|
|
with strong spinlock mfc_unres_lock.
|
|
|
|
|
|
|
|
In this case data path is free of exclusive locks at all.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static struct kmem_cache *mrt_cachep __read_mostly;
|
|
|
|
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
static struct mr6_table *ip6mr_new_table(struct net *net, u32 id);
|
|
|
|
static void ip6mr_free_table(struct mr6_table *mrt);
|
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
static int ip6_mr_forward(struct net *net, struct mr6_table *mrt,
|
|
|
|
struct sk_buff *skb, struct mfc6_cache *cache);
|
|
|
|
static int ip6mr_cache_report(struct mr6_table *mrt, struct sk_buff *pkt,
|
2008-12-11 08:30:15 +08:00
|
|
|
mifi_t mifi, int assert);
|
2010-05-11 20:40:56 +08:00
|
|
|
static int __ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb,
|
|
|
|
struct mfc6_cache *c, struct rtmsg *rtm);
|
|
|
|
static int ip6mr_rtm_dumproute(struct sk_buff *skb,
|
|
|
|
struct netlink_callback *cb);
|
2010-05-11 20:40:53 +08:00
|
|
|
static void mroute_clean_tables(struct mr6_table *mrt);
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
static void ipmr_expire_process(unsigned long arg);
|
|
|
|
|
|
|
|
#ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
|
2010-06-07 06:34:40 +08:00
|
|
|
#define ip6mr_for_each_table(mrt, net) \
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
list_for_each_entry_rcu(mrt, &net->ipv6.mr6_tables, list)
|
|
|
|
|
|
|
|
static struct mr6_table *ip6mr_get_table(struct net *net, u32 id)
|
|
|
|
{
|
|
|
|
struct mr6_table *mrt;
|
|
|
|
|
|
|
|
ip6mr_for_each_table(mrt, net) {
|
|
|
|
if (mrt->id == id)
|
|
|
|
return mrt;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2011-03-13 05:22:43 +08:00
|
|
|
static int ip6mr_fib_lookup(struct net *net, struct flowi6 *flp6,
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
struct mr6_table **mrt)
|
|
|
|
{
|
|
|
|
struct ip6mr_result res;
|
|
|
|
struct fib_lookup_arg arg = { .result = &res, };
|
|
|
|
int err;
|
|
|
|
|
2011-03-13 05:22:43 +08:00
|
|
|
err = fib_rules_lookup(net->ipv6.mr6_rules_ops,
|
|
|
|
flowi6_to_flowi(flp6), 0, &arg);
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
*mrt = res.mrt;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ip6mr_rule_action(struct fib_rule *rule, struct flowi *flp,
|
|
|
|
int flags, struct fib_lookup_arg *arg)
|
|
|
|
{
|
|
|
|
struct ip6mr_result *res = arg->result;
|
|
|
|
struct mr6_table *mrt;
|
|
|
|
|
|
|
|
switch (rule->action) {
|
|
|
|
case FR_ACT_TO_TBL:
|
|
|
|
break;
|
|
|
|
case FR_ACT_UNREACHABLE:
|
|
|
|
return -ENETUNREACH;
|
|
|
|
case FR_ACT_PROHIBIT:
|
|
|
|
return -EACCES;
|
|
|
|
case FR_ACT_BLACKHOLE:
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
mrt = ip6mr_get_table(rule->fr_net, rule->table);
|
|
|
|
if (mrt == NULL)
|
|
|
|
return -EAGAIN;
|
|
|
|
res->mrt = mrt;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ip6mr_rule_match(struct fib_rule *rule, struct flowi *flp, int flags)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct nla_policy ip6mr_rule_policy[FRA_MAX + 1] = {
|
|
|
|
FRA_GENERIC_POLICY,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int ip6mr_rule_configure(struct fib_rule *rule, struct sk_buff *skb,
|
|
|
|
struct fib_rule_hdr *frh, struct nlattr **tb)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ip6mr_rule_compare(struct fib_rule *rule, struct fib_rule_hdr *frh,
|
|
|
|
struct nlattr **tb)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ip6mr_rule_fill(struct fib_rule *rule, struct sk_buff *skb,
|
|
|
|
struct fib_rule_hdr *frh)
|
|
|
|
{
|
|
|
|
frh->dst_len = 0;
|
|
|
|
frh->src_len = 0;
|
|
|
|
frh->tos = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct fib_rules_ops __net_initdata ip6mr_rules_ops_template = {
|
|
|
|
.family = RTNL_FAMILY_IP6MR,
|
|
|
|
.rule_size = sizeof(struct ip6mr_rule),
|
|
|
|
.addr_size = sizeof(struct in6_addr),
|
|
|
|
.action = ip6mr_rule_action,
|
|
|
|
.match = ip6mr_rule_match,
|
|
|
|
.configure = ip6mr_rule_configure,
|
|
|
|
.compare = ip6mr_rule_compare,
|
|
|
|
.default_pref = fib_default_rule_pref,
|
|
|
|
.fill = ip6mr_rule_fill,
|
|
|
|
.nlgroup = RTNLGRP_IPV6_RULE,
|
|
|
|
.policy = ip6mr_rule_policy,
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int __net_init ip6mr_rules_init(struct net *net)
|
|
|
|
{
|
|
|
|
struct fib_rules_ops *ops;
|
|
|
|
struct mr6_table *mrt;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
ops = fib_rules_register(&ip6mr_rules_ops_template, net);
|
|
|
|
if (IS_ERR(ops))
|
|
|
|
return PTR_ERR(ops);
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&net->ipv6.mr6_tables);
|
|
|
|
|
|
|
|
mrt = ip6mr_new_table(net, RT6_TABLE_DFLT);
|
|
|
|
if (mrt == NULL) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto err1;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = fib_default_rule_add(ops, 0x7fff, RT6_TABLE_DFLT, 0);
|
|
|
|
if (err < 0)
|
|
|
|
goto err2;
|
|
|
|
|
|
|
|
net->ipv6.mr6_rules_ops = ops;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err2:
|
|
|
|
kfree(mrt);
|
|
|
|
err1:
|
|
|
|
fib_rules_unregister(ops);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __net_exit ip6mr_rules_exit(struct net *net)
|
|
|
|
{
|
|
|
|
struct mr6_table *mrt, *next;
|
|
|
|
|
2010-06-07 07:48:40 +08:00
|
|
|
list_for_each_entry_safe(mrt, next, &net->ipv6.mr6_tables, list) {
|
|
|
|
list_del(&mrt->list);
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
ip6mr_free_table(mrt);
|
2010-06-07 07:48:40 +08:00
|
|
|
}
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
fib_rules_unregister(net->ipv6.mr6_rules_ops);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
#define ip6mr_for_each_table(mrt, net) \
|
|
|
|
for (mrt = net->ipv6.mrt6; mrt; mrt = NULL)
|
|
|
|
|
|
|
|
static struct mr6_table *ip6mr_get_table(struct net *net, u32 id)
|
|
|
|
{
|
|
|
|
return net->ipv6.mrt6;
|
|
|
|
}
|
|
|
|
|
2011-03-13 05:22:43 +08:00
|
|
|
static int ip6mr_fib_lookup(struct net *net, struct flowi6 *flp6,
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
struct mr6_table **mrt)
|
|
|
|
{
|
|
|
|
*mrt = net->ipv6.mrt6;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __net_init ip6mr_rules_init(struct net *net)
|
|
|
|
{
|
|
|
|
net->ipv6.mrt6 = ip6mr_new_table(net, RT6_TABLE_DFLT);
|
|
|
|
return net->ipv6.mrt6 ? 0 : -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __net_exit ip6mr_rules_exit(struct net *net)
|
|
|
|
{
|
|
|
|
ip6mr_free_table(net->ipv6.mrt6);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static struct mr6_table *ip6mr_new_table(struct net *net, u32 id)
|
|
|
|
{
|
|
|
|
struct mr6_table *mrt;
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
mrt = ip6mr_get_table(net, id);
|
|
|
|
if (mrt != NULL)
|
|
|
|
return mrt;
|
|
|
|
|
|
|
|
mrt = kzalloc(sizeof(*mrt), GFP_KERNEL);
|
|
|
|
if (mrt == NULL)
|
|
|
|
return NULL;
|
|
|
|
mrt->id = id;
|
|
|
|
write_pnet(&mrt->net, net);
|
|
|
|
|
|
|
|
/* Forwarding cache */
|
|
|
|
for (i = 0; i < MFC6_LINES; i++)
|
|
|
|
INIT_LIST_HEAD(&mrt->mfc6_cache_array[i]);
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&mrt->mfc6_unres_queue);
|
|
|
|
|
|
|
|
setup_timer(&mrt->ipmr_expire_timer, ipmr_expire_process,
|
|
|
|
(unsigned long)mrt);
|
|
|
|
|
|
|
|
#ifdef CONFIG_IPV6_PIMSM_V2
|
|
|
|
mrt->mroute_reg_vif_num = -1;
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
|
|
|
|
list_add_tail_rcu(&mrt->list, &net->ipv6.mr6_tables);
|
|
|
|
#endif
|
|
|
|
return mrt;
|
|
|
|
}
|
2008-04-03 08:22:53 +08:00
|
|
|
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
static void ip6mr_free_table(struct mr6_table *mrt)
|
|
|
|
{
|
|
|
|
del_timer(&mrt->ipmr_expire_timer);
|
|
|
|
mroute_clean_tables(mrt);
|
|
|
|
kfree(mrt);
|
|
|
|
}
|
2008-04-03 08:22:53 +08:00
|
|
|
|
|
|
|
#ifdef CONFIG_PROC_FS
|
|
|
|
|
|
|
|
struct ipmr_mfc_iter {
|
2008-12-11 08:29:48 +08:00
|
|
|
struct seq_net_private p;
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
struct mr6_table *mrt;
|
2010-05-11 20:40:51 +08:00
|
|
|
struct list_head *cache;
|
2008-04-03 08:22:53 +08:00
|
|
|
int ct;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2008-12-11 08:29:48 +08:00
|
|
|
static struct mfc6_cache *ipmr_mfc_seq_idx(struct net *net,
|
|
|
|
struct ipmr_mfc_iter *it, loff_t pos)
|
2008-04-03 08:22:53 +08:00
|
|
|
{
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
struct mr6_table *mrt = it->mrt;
|
2008-04-03 08:22:53 +08:00
|
|
|
struct mfc6_cache *mfc;
|
|
|
|
|
|
|
|
read_lock(&mrt_lock);
|
2010-05-11 20:40:51 +08:00
|
|
|
for (it->ct = 0; it->ct < MFC6_LINES; it->ct++) {
|
2010-05-11 20:40:53 +08:00
|
|
|
it->cache = &mrt->mfc6_cache_array[it->ct];
|
2010-05-11 20:40:51 +08:00
|
|
|
list_for_each_entry(mfc, it->cache, list)
|
2008-04-03 08:22:53 +08:00
|
|
|
if (pos-- == 0)
|
|
|
|
return mfc;
|
2010-05-11 20:40:51 +08:00
|
|
|
}
|
2008-04-03 08:22:53 +08:00
|
|
|
read_unlock(&mrt_lock);
|
|
|
|
|
|
|
|
spin_lock_bh(&mfc_unres_lock);
|
2010-05-11 20:40:53 +08:00
|
|
|
it->cache = &mrt->mfc6_unres_queue;
|
2010-05-11 20:40:51 +08:00
|
|
|
list_for_each_entry(mfc, it->cache, list)
|
2010-05-11 20:40:48 +08:00
|
|
|
if (pos-- == 0)
|
2008-04-03 08:22:53 +08:00
|
|
|
return mfc;
|
|
|
|
spin_unlock_bh(&mfc_unres_lock);
|
|
|
|
|
|
|
|
it->cache = NULL;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The /proc interfaces to multicast routing /proc/ip6_mr_cache /proc/ip6_mr_vif
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct ipmr_vif_iter {
|
2008-12-11 08:29:48 +08:00
|
|
|
struct seq_net_private p;
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
struct mr6_table *mrt;
|
2008-04-03 08:22:53 +08:00
|
|
|
int ct;
|
|
|
|
};
|
|
|
|
|
2008-12-11 08:29:48 +08:00
|
|
|
static struct mif_device *ip6mr_vif_seq_idx(struct net *net,
|
|
|
|
struct ipmr_vif_iter *iter,
|
2008-04-03 08:22:53 +08:00
|
|
|
loff_t pos)
|
|
|
|
{
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
struct mr6_table *mrt = iter->mrt;
|
2010-05-11 20:40:53 +08:00
|
|
|
|
|
|
|
for (iter->ct = 0; iter->ct < mrt->maxvif; ++iter->ct) {
|
|
|
|
if (!MIF_EXISTS(mrt, iter->ct))
|
2008-04-03 08:22:53 +08:00
|
|
|
continue;
|
|
|
|
if (pos-- == 0)
|
2010-05-11 20:40:53 +08:00
|
|
|
return &mrt->vif6_table[iter->ct];
|
2008-04-03 08:22:53 +08:00
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *ip6mr_vif_seq_start(struct seq_file *seq, loff_t *pos)
|
|
|
|
__acquires(mrt_lock)
|
|
|
|
{
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
struct ipmr_vif_iter *iter = seq->private;
|
2008-12-11 08:29:48 +08:00
|
|
|
struct net *net = seq_file_net(seq);
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
struct mr6_table *mrt;
|
|
|
|
|
|
|
|
mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
|
|
|
|
if (mrt == NULL)
|
|
|
|
return ERR_PTR(-ENOENT);
|
|
|
|
|
|
|
|
iter->mrt = mrt;
|
2008-12-11 08:29:48 +08:00
|
|
|
|
2008-04-03 08:22:53 +08:00
|
|
|
read_lock(&mrt_lock);
|
2008-12-11 08:29:48 +08:00
|
|
|
return *pos ? ip6mr_vif_seq_idx(net, seq->private, *pos - 1)
|
|
|
|
: SEQ_START_TOKEN;
|
2008-04-03 08:22:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void *ip6mr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos)
|
|
|
|
{
|
|
|
|
struct ipmr_vif_iter *iter = seq->private;
|
2008-12-11 08:29:48 +08:00
|
|
|
struct net *net = seq_file_net(seq);
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
struct mr6_table *mrt = iter->mrt;
|
2008-04-03 08:22:53 +08:00
|
|
|
|
|
|
|
++*pos;
|
|
|
|
if (v == SEQ_START_TOKEN)
|
2008-12-11 08:29:48 +08:00
|
|
|
return ip6mr_vif_seq_idx(net, iter, 0);
|
2008-04-03 08:22:53 +08:00
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
while (++iter->ct < mrt->maxvif) {
|
|
|
|
if (!MIF_EXISTS(mrt, iter->ct))
|
2008-04-03 08:22:53 +08:00
|
|
|
continue;
|
2010-05-11 20:40:53 +08:00
|
|
|
return &mrt->vif6_table[iter->ct];
|
2008-04-03 08:22:53 +08:00
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ip6mr_vif_seq_stop(struct seq_file *seq, void *v)
|
|
|
|
__releases(mrt_lock)
|
|
|
|
{
|
|
|
|
read_unlock(&mrt_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ip6mr_vif_seq_show(struct seq_file *seq, void *v)
|
|
|
|
{
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
struct ipmr_vif_iter *iter = seq->private;
|
|
|
|
struct mr6_table *mrt = iter->mrt;
|
2008-12-11 08:29:48 +08:00
|
|
|
|
2008-04-03 08:22:53 +08:00
|
|
|
if (v == SEQ_START_TOKEN) {
|
|
|
|
seq_puts(seq,
|
|
|
|
"Interface BytesIn PktsIn BytesOut PktsOut Flags\n");
|
|
|
|
} else {
|
|
|
|
const struct mif_device *vif = v;
|
|
|
|
const char *name = vif->dev ? vif->dev->name : "none";
|
|
|
|
|
|
|
|
seq_printf(seq,
|
2008-06-02 17:59:02 +08:00
|
|
|
"%2td %-10s %8ld %7ld %8ld %7ld %05X\n",
|
2010-05-11 20:40:53 +08:00
|
|
|
vif - mrt->vif6_table,
|
2008-04-03 08:22:53 +08:00
|
|
|
name, vif->bytes_in, vif->pkt_in,
|
|
|
|
vif->bytes_out, vif->pkt_out,
|
|
|
|
vif->flags);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-09-02 03:25:02 +08:00
|
|
|
static const struct seq_operations ip6mr_vif_seq_ops = {
|
2008-04-03 08:22:53 +08:00
|
|
|
.start = ip6mr_vif_seq_start,
|
|
|
|
.next = ip6mr_vif_seq_next,
|
|
|
|
.stop = ip6mr_vif_seq_stop,
|
|
|
|
.show = ip6mr_vif_seq_show,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int ip6mr_vif_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
2008-12-11 08:29:48 +08:00
|
|
|
return seq_open_net(inode, file, &ip6mr_vif_seq_ops,
|
|
|
|
sizeof(struct ipmr_vif_iter));
|
2008-04-03 08:22:53 +08:00
|
|
|
}
|
|
|
|
|
2009-09-02 03:25:05 +08:00
|
|
|
static const struct file_operations ip6mr_vif_fops = {
|
2008-04-03 08:22:53 +08:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = ip6mr_vif_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
2008-12-11 08:29:48 +08:00
|
|
|
.release = seq_release_net,
|
2008-04-03 08:22:53 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
|
|
|
|
{
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
struct ipmr_mfc_iter *it = seq->private;
|
2008-12-11 08:29:48 +08:00
|
|
|
struct net *net = seq_file_net(seq);
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
struct mr6_table *mrt;
|
2008-12-11 08:29:48 +08:00
|
|
|
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
|
|
|
|
if (mrt == NULL)
|
|
|
|
return ERR_PTR(-ENOENT);
|
|
|
|
|
|
|
|
it->mrt = mrt;
|
2008-12-11 08:29:48 +08:00
|
|
|
return *pos ? ipmr_mfc_seq_idx(net, seq->private, *pos - 1)
|
|
|
|
: SEQ_START_TOKEN;
|
2008-04-03 08:22:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
|
|
|
|
{
|
|
|
|
struct mfc6_cache *mfc = v;
|
|
|
|
struct ipmr_mfc_iter *it = seq->private;
|
2008-12-11 08:29:48 +08:00
|
|
|
struct net *net = seq_file_net(seq);
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
struct mr6_table *mrt = it->mrt;
|
2008-04-03 08:22:53 +08:00
|
|
|
|
|
|
|
++*pos;
|
|
|
|
|
|
|
|
if (v == SEQ_START_TOKEN)
|
2008-12-11 08:29:48 +08:00
|
|
|
return ipmr_mfc_seq_idx(net, seq->private, 0);
|
2008-04-03 08:22:53 +08:00
|
|
|
|
2010-05-11 20:40:51 +08:00
|
|
|
if (mfc->list.next != it->cache)
|
|
|
|
return list_entry(mfc->list.next, struct mfc6_cache, list);
|
2008-04-03 08:22:53 +08:00
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
if (it->cache == &mrt->mfc6_unres_queue)
|
2008-04-03 08:22:53 +08:00
|
|
|
goto end_of_list;
|
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
BUG_ON(it->cache != &mrt->mfc6_cache_array[it->ct]);
|
2008-04-03 08:22:53 +08:00
|
|
|
|
2008-12-11 08:24:07 +08:00
|
|
|
while (++it->ct < MFC6_LINES) {
|
2010-05-11 20:40:53 +08:00
|
|
|
it->cache = &mrt->mfc6_cache_array[it->ct];
|
2010-05-11 20:40:51 +08:00
|
|
|
if (list_empty(it->cache))
|
|
|
|
continue;
|
|
|
|
return list_first_entry(it->cache, struct mfc6_cache, list);
|
2008-04-03 08:22:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* exhausted cache_array, show unresolved */
|
|
|
|
read_unlock(&mrt_lock);
|
2010-05-11 20:40:53 +08:00
|
|
|
it->cache = &mrt->mfc6_unres_queue;
|
2008-04-03 08:22:53 +08:00
|
|
|
it->ct = 0;
|
|
|
|
|
|
|
|
spin_lock_bh(&mfc_unres_lock);
|
2010-05-11 20:40:51 +08:00
|
|
|
if (!list_empty(it->cache))
|
|
|
|
return list_first_entry(it->cache, struct mfc6_cache, list);
|
2008-04-03 08:22:53 +08:00
|
|
|
|
|
|
|
end_of_list:
|
|
|
|
spin_unlock_bh(&mfc_unres_lock);
|
|
|
|
it->cache = NULL;
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ipmr_mfc_seq_stop(struct seq_file *seq, void *v)
|
|
|
|
{
|
|
|
|
struct ipmr_mfc_iter *it = seq->private;
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
struct mr6_table *mrt = it->mrt;
|
2008-04-03 08:22:53 +08:00
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
if (it->cache == &mrt->mfc6_unres_queue)
|
2008-04-03 08:22:53 +08:00
|
|
|
spin_unlock_bh(&mfc_unres_lock);
|
2010-05-11 20:40:53 +08:00
|
|
|
else if (it->cache == mrt->mfc6_cache_array)
|
2008-04-03 08:22:53 +08:00
|
|
|
read_unlock(&mrt_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
|
|
|
|
{
|
|
|
|
int n;
|
|
|
|
|
|
|
|
if (v == SEQ_START_TOKEN) {
|
|
|
|
seq_puts(seq,
|
|
|
|
"Group "
|
|
|
|
"Origin "
|
|
|
|
"Iif Pkts Bytes Wrong Oifs\n");
|
|
|
|
} else {
|
|
|
|
const struct mfc6_cache *mfc = v;
|
|
|
|
const struct ipmr_mfc_iter *it = seq->private;
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
struct mr6_table *mrt = it->mrt;
|
2008-04-03 08:22:53 +08:00
|
|
|
|
2008-12-04 14:22:16 +08:00
|
|
|
seq_printf(seq, "%pI6 %pI6 %-3hd",
|
2008-10-29 07:09:23 +08:00
|
|
|
&mfc->mf6c_mcastgrp, &mfc->mf6c_origin,
|
2008-12-04 14:21:47 +08:00
|
|
|
mfc->mf6c_parent);
|
2008-04-03 08:22:53 +08:00
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
if (it->cache != &mrt->mfc6_unres_queue) {
|
2008-12-04 14:21:47 +08:00
|
|
|
seq_printf(seq, " %8lu %8lu %8lu",
|
|
|
|
mfc->mfc_un.res.pkt,
|
|
|
|
mfc->mfc_un.res.bytes,
|
|
|
|
mfc->mfc_un.res.wrong_if);
|
2008-04-03 08:22:53 +08:00
|
|
|
for (n = mfc->mfc_un.res.minvif;
|
|
|
|
n < mfc->mfc_un.res.maxvif; n++) {
|
2010-05-11 20:40:53 +08:00
|
|
|
if (MIF_EXISTS(mrt, n) &&
|
2008-04-03 08:22:53 +08:00
|
|
|
mfc->mfc_un.res.ttls[n] < 255)
|
|
|
|
seq_printf(seq,
|
|
|
|
" %2d:%-3d",
|
|
|
|
n, mfc->mfc_un.res.ttls[n]);
|
|
|
|
}
|
2008-12-04 14:21:47 +08:00
|
|
|
} else {
|
|
|
|
/* unresolved mfc_caches don't contain
|
|
|
|
* pkt, bytes and wrong_if values
|
|
|
|
*/
|
|
|
|
seq_printf(seq, " %8lu %8lu %8lu", 0ul, 0ul, 0ul);
|
2008-04-03 08:22:53 +08:00
|
|
|
}
|
|
|
|
seq_putc(seq, '\n');
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-09-23 07:43:43 +08:00
|
|
|
static const struct seq_operations ipmr_mfc_seq_ops = {
|
2008-04-03 08:22:53 +08:00
|
|
|
.start = ipmr_mfc_seq_start,
|
|
|
|
.next = ipmr_mfc_seq_next,
|
|
|
|
.stop = ipmr_mfc_seq_stop,
|
|
|
|
.show = ipmr_mfc_seq_show,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int ipmr_mfc_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
2008-12-11 08:29:48 +08:00
|
|
|
return seq_open_net(inode, file, &ipmr_mfc_seq_ops,
|
|
|
|
sizeof(struct ipmr_mfc_iter));
|
2008-04-03 08:22:53 +08:00
|
|
|
}
|
|
|
|
|
2009-09-02 03:25:05 +08:00
|
|
|
static const struct file_operations ip6mr_mfc_fops = {
|
2008-04-03 08:22:53 +08:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = ipmr_mfc_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
2008-12-11 08:29:48 +08:00
|
|
|
.release = seq_release_net,
|
2008-04-03 08:22:53 +08:00
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
2008-04-03 08:22:54 +08:00
|
|
|
#ifdef CONFIG_IPV6_PIMSM_V2
|
|
|
|
|
|
|
|
static int pim6_rcv(struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
struct pimreghdr *pim;
|
|
|
|
struct ipv6hdr *encap;
|
|
|
|
struct net_device *reg_dev = NULL;
|
2008-12-11 08:30:15 +08:00
|
|
|
struct net *net = dev_net(skb->dev);
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
struct mr6_table *mrt;
|
2011-03-13 05:22:43 +08:00
|
|
|
struct flowi6 fl6 = {
|
|
|
|
.flowi6_iif = skb->dev->ifindex,
|
|
|
|
.flowi6_mark = skb->mark,
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
};
|
|
|
|
int reg_vif_num;
|
2008-04-03 08:22:54 +08:00
|
|
|
|
|
|
|
if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
|
|
|
|
goto drop;
|
|
|
|
|
|
|
|
pim = (struct pimreghdr *)skb_transport_header(skb);
|
|
|
|
if (pim->type != ((PIM_VERSION << 4) | PIM_REGISTER) ||
|
|
|
|
(pim->flags & PIM_NULL_REGISTER) ||
|
2009-01-28 14:39:59 +08:00
|
|
|
(csum_ipv6_magic(&ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr,
|
|
|
|
sizeof(*pim), IPPROTO_PIM,
|
|
|
|
csum_partial((void *)pim, sizeof(*pim), 0)) &&
|
2008-04-27 13:28:58 +08:00
|
|
|
csum_fold(skb_checksum(skb, 0, skb->len, 0))))
|
2008-04-03 08:22:54 +08:00
|
|
|
goto drop;
|
|
|
|
|
|
|
|
/* check if the inner packet is destined to mcast group */
|
|
|
|
encap = (struct ipv6hdr *)(skb_transport_header(skb) +
|
|
|
|
sizeof(*pim));
|
|
|
|
|
|
|
|
if (!ipv6_addr_is_multicast(&encap->daddr) ||
|
|
|
|
encap->payload_len == 0 ||
|
|
|
|
ntohs(encap->payload_len) + sizeof(*pim) > skb->len)
|
|
|
|
goto drop;
|
|
|
|
|
2011-03-13 05:22:43 +08:00
|
|
|
if (ip6mr_fib_lookup(net, &fl6, &mrt) < 0)
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
goto drop;
|
|
|
|
reg_vif_num = mrt->mroute_reg_vif_num;
|
|
|
|
|
2008-04-03 08:22:54 +08:00
|
|
|
read_lock(&mrt_lock);
|
|
|
|
if (reg_vif_num >= 0)
|
2010-05-11 20:40:53 +08:00
|
|
|
reg_dev = mrt->vif6_table[reg_vif_num].dev;
|
2008-04-03 08:22:54 +08:00
|
|
|
if (reg_dev)
|
|
|
|
dev_hold(reg_dev);
|
|
|
|
read_unlock(&mrt_lock);
|
|
|
|
|
|
|
|
if (reg_dev == NULL)
|
|
|
|
goto drop;
|
|
|
|
|
|
|
|
skb->mac_header = skb->network_header;
|
|
|
|
skb_pull(skb, (u8 *)encap - skb->data);
|
|
|
|
skb_reset_network_header(skb);
|
2009-01-28 14:39:59 +08:00
|
|
|
skb->protocol = htons(ETH_P_IPV6);
|
2011-03-26 13:10:30 +08:00
|
|
|
skb->ip_summed = CHECKSUM_NONE;
|
2008-04-03 08:22:54 +08:00
|
|
|
skb->pkt_type = PACKET_HOST;
|
2010-05-18 13:36:55 +08:00
|
|
|
|
|
|
|
skb_tunnel_rx(skb, reg_dev);
|
|
|
|
|
2010-10-01 05:06:55 +08:00
|
|
|
netif_rx(skb);
|
2010-09-20 08:12:11 +08:00
|
|
|
|
2008-04-03 08:22:54 +08:00
|
|
|
dev_put(reg_dev);
|
|
|
|
return 0;
|
|
|
|
drop:
|
|
|
|
kfree_skb(skb);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-09-14 20:22:28 +08:00
|
|
|
static const struct inet6_protocol pim6_protocol = {
|
2008-04-03 08:22:54 +08:00
|
|
|
.handler = pim6_rcv,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Service routines creating virtual interfaces: PIMREG */
|
|
|
|
|
2009-09-01 03:50:41 +08:00
|
|
|
static netdev_tx_t reg_vif_xmit(struct sk_buff *skb,
|
|
|
|
struct net_device *dev)
|
2008-04-03 08:22:54 +08:00
|
|
|
{
|
2008-12-11 08:30:15 +08:00
|
|
|
struct net *net = dev_net(dev);
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
struct mr6_table *mrt;
|
2011-03-13 05:22:43 +08:00
|
|
|
struct flowi6 fl6 = {
|
|
|
|
.flowi6_oif = dev->ifindex,
|
|
|
|
.flowi6_iif = skb->skb_iif,
|
|
|
|
.flowi6_mark = skb->mark,
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
};
|
|
|
|
int err;
|
|
|
|
|
2011-03-13 05:22:43 +08:00
|
|
|
err = ip6mr_fib_lookup(net, &fl6, &mrt);
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
2008-12-11 08:30:15 +08:00
|
|
|
|
2008-04-03 08:22:54 +08:00
|
|
|
read_lock(&mrt_lock);
|
2008-05-22 05:17:54 +08:00
|
|
|
dev->stats.tx_bytes += skb->len;
|
|
|
|
dev->stats.tx_packets++;
|
2010-05-11 20:40:53 +08:00
|
|
|
ip6mr_cache_report(mrt, skb, mrt->mroute_reg_vif_num, MRT6MSG_WHOLEPKT);
|
2008-04-03 08:22:54 +08:00
|
|
|
read_unlock(&mrt_lock);
|
|
|
|
kfree_skb(skb);
|
2009-06-23 14:03:08 +08:00
|
|
|
return NETDEV_TX_OK;
|
2008-04-03 08:22:54 +08:00
|
|
|
}
|
|
|
|
|
2008-11-21 12:28:35 +08:00
|
|
|
static const struct net_device_ops reg_vif_netdev_ops = {
|
|
|
|
.ndo_start_xmit = reg_vif_xmit,
|
|
|
|
};
|
|
|
|
|
2008-04-03 08:22:54 +08:00
|
|
|
static void reg_vif_setup(struct net_device *dev)
|
|
|
|
{
|
|
|
|
dev->type = ARPHRD_PIMREG;
|
|
|
|
dev->mtu = 1500 - sizeof(struct ipv6hdr) - 8;
|
|
|
|
dev->flags = IFF_NOARP;
|
2008-11-21 12:28:35 +08:00
|
|
|
dev->netdev_ops = ®_vif_netdev_ops;
|
2008-04-03 08:22:54 +08:00
|
|
|
dev->destructor = free_netdev;
|
2009-06-14 18:16:13 +08:00
|
|
|
dev->features |= NETIF_F_NETNS_LOCAL;
|
2008-04-03 08:22:54 +08:00
|
|
|
}
|
|
|
|
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
static struct net_device *ip6mr_reg_vif(struct net *net, struct mr6_table *mrt)
|
2008-04-03 08:22:54 +08:00
|
|
|
{
|
|
|
|
struct net_device *dev;
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
char name[IFNAMSIZ];
|
|
|
|
|
|
|
|
if (mrt->id == RT6_TABLE_DFLT)
|
|
|
|
sprintf(name, "pim6reg");
|
|
|
|
else
|
|
|
|
sprintf(name, "pim6reg%u", mrt->id);
|
2008-04-03 08:22:54 +08:00
|
|
|
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
dev = alloc_netdev(0, name, reg_vif_setup);
|
2008-04-03 08:22:54 +08:00
|
|
|
if (dev == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
2008-12-11 08:30:15 +08:00
|
|
|
dev_net_set(dev, net);
|
|
|
|
|
2008-04-03 08:22:54 +08:00
|
|
|
if (register_netdevice(dev)) {
|
|
|
|
free_netdev(dev);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
dev->iflink = 0;
|
|
|
|
|
|
|
|
if (dev_open(dev))
|
|
|
|
goto failure;
|
|
|
|
|
2008-07-15 11:54:54 +08:00
|
|
|
dev_hold(dev);
|
2008-04-03 08:22:54 +08:00
|
|
|
return dev;
|
|
|
|
|
|
|
|
failure:
|
|
|
|
/* allow the register to be completed before unregistering. */
|
|
|
|
rtnl_unlock();
|
|
|
|
rtnl_lock();
|
|
|
|
|
|
|
|
unregister_netdevice(dev);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-04-03 08:22:53 +08:00
|
|
|
/*
|
|
|
|
* Delete a VIF entry
|
|
|
|
*/
|
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
static int mif6_delete(struct mr6_table *mrt, int vifi, struct list_head *head)
|
2008-04-03 08:22:53 +08:00
|
|
|
{
|
|
|
|
struct mif_device *v;
|
|
|
|
struct net_device *dev;
|
2009-01-28 14:39:59 +08:00
|
|
|
struct inet6_dev *in6_dev;
|
2010-05-11 20:40:53 +08:00
|
|
|
|
|
|
|
if (vifi < 0 || vifi >= mrt->maxvif)
|
2008-04-03 08:22:53 +08:00
|
|
|
return -EADDRNOTAVAIL;
|
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
v = &mrt->vif6_table[vifi];
|
2008-04-03 08:22:53 +08:00
|
|
|
|
|
|
|
write_lock_bh(&mrt_lock);
|
|
|
|
dev = v->dev;
|
|
|
|
v->dev = NULL;
|
|
|
|
|
|
|
|
if (!dev) {
|
|
|
|
write_unlock_bh(&mrt_lock);
|
|
|
|
return -EADDRNOTAVAIL;
|
|
|
|
}
|
|
|
|
|
2008-04-03 08:22:54 +08:00
|
|
|
#ifdef CONFIG_IPV6_PIMSM_V2
|
2010-05-11 20:40:53 +08:00
|
|
|
if (vifi == mrt->mroute_reg_vif_num)
|
|
|
|
mrt->mroute_reg_vif_num = -1;
|
2008-04-03 08:22:54 +08:00
|
|
|
#endif
|
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
if (vifi + 1 == mrt->maxvif) {
|
2008-04-03 08:22:53 +08:00
|
|
|
int tmp;
|
|
|
|
for (tmp = vifi - 1; tmp >= 0; tmp--) {
|
2010-05-11 20:40:53 +08:00
|
|
|
if (MIF_EXISTS(mrt, tmp))
|
2008-04-03 08:22:53 +08:00
|
|
|
break;
|
|
|
|
}
|
2010-05-11 20:40:53 +08:00
|
|
|
mrt->maxvif = tmp + 1;
|
2008-04-03 08:22:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
write_unlock_bh(&mrt_lock);
|
|
|
|
|
|
|
|
dev_set_allmulti(dev, -1);
|
|
|
|
|
2009-01-28 14:39:59 +08:00
|
|
|
in6_dev = __in6_dev_get(dev);
|
|
|
|
if (in6_dev)
|
|
|
|
in6_dev->cnf.mc_forwarding--;
|
|
|
|
|
2008-04-03 08:22:53 +08:00
|
|
|
if (v->flags & MIFF_REGISTER)
|
2009-10-28 12:48:11 +08:00
|
|
|
unregister_netdevice_queue(dev, head);
|
2008-04-03 08:22:53 +08:00
|
|
|
|
|
|
|
dev_put(dev);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-12-11 08:22:34 +08:00
|
|
|
static inline void ip6mr_cache_free(struct mfc6_cache *c)
|
|
|
|
{
|
|
|
|
kmem_cache_free(mrt_cachep, c);
|
|
|
|
}
|
|
|
|
|
2008-04-03 08:22:53 +08:00
|
|
|
/* Destroy an unresolved cache entry, killing queued skbs
|
|
|
|
and reporting error to netlink readers.
|
|
|
|
*/
|
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
static void ip6mr_destroy_unres(struct mr6_table *mrt, struct mfc6_cache *c)
|
2008-04-03 08:22:53 +08:00
|
|
|
{
|
2010-05-11 20:40:53 +08:00
|
|
|
struct net *net = read_pnet(&mrt->net);
|
2008-04-03 08:22:53 +08:00
|
|
|
struct sk_buff *skb;
|
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
atomic_dec(&mrt->cache_resolve_queue_len);
|
2008-04-03 08:22:53 +08:00
|
|
|
|
|
|
|
while((skb = skb_dequeue(&c->mfc_un.unres.unresolved)) != NULL) {
|
|
|
|
if (ipv6_hdr(skb)->version == 0) {
|
|
|
|
struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct ipv6hdr));
|
|
|
|
nlh->nlmsg_type = NLMSG_ERROR;
|
|
|
|
nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
|
|
|
|
skb_trim(skb, nlh->nlmsg_len);
|
|
|
|
((struct nlmsgerr *)NLMSG_DATA(nlh))->error = -ETIMEDOUT;
|
2008-12-11 08:30:15 +08:00
|
|
|
rtnl_unicast(skb, net, NETLINK_CB(skb).pid);
|
2008-04-03 08:22:53 +08:00
|
|
|
} else
|
|
|
|
kfree_skb(skb);
|
|
|
|
}
|
|
|
|
|
2008-12-11 08:22:34 +08:00
|
|
|
ip6mr_cache_free(c);
|
2008-04-03 08:22:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-05-11 20:40:48 +08:00
|
|
|
/* Timer process for all the unresolved queue. */
|
2008-04-03 08:22:53 +08:00
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
static void ipmr_do_expire_process(struct mr6_table *mrt)
|
2008-04-03 08:22:53 +08:00
|
|
|
{
|
|
|
|
unsigned long now = jiffies;
|
|
|
|
unsigned long expires = 10 * HZ;
|
2010-05-11 20:40:51 +08:00
|
|
|
struct mfc6_cache *c, *next;
|
2008-04-03 08:22:53 +08:00
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
list_for_each_entry_safe(c, next, &mrt->mfc6_unres_queue, list) {
|
2008-04-03 08:22:53 +08:00
|
|
|
if (time_after(c->mfc_un.unres.expires, now)) {
|
|
|
|
/* not yet... */
|
|
|
|
unsigned long interval = c->mfc_un.unres.expires - now;
|
|
|
|
if (interval < expires)
|
|
|
|
expires = interval;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2010-05-11 20:40:51 +08:00
|
|
|
list_del(&c->list);
|
2010-05-11 20:40:53 +08:00
|
|
|
ip6mr_destroy_unres(mrt, c);
|
2008-04-03 08:22:53 +08:00
|
|
|
}
|
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
if (!list_empty(&mrt->mfc6_unres_queue))
|
|
|
|
mod_timer(&mrt->ipmr_expire_timer, jiffies + expires);
|
2008-04-03 08:22:53 +08:00
|
|
|
}
|
|
|
|
|
2010-05-11 20:40:48 +08:00
|
|
|
static void ipmr_expire_process(unsigned long arg)
|
2008-04-03 08:22:53 +08:00
|
|
|
{
|
2010-05-11 20:40:53 +08:00
|
|
|
struct mr6_table *mrt = (struct mr6_table *)arg;
|
2010-05-11 20:40:48 +08:00
|
|
|
|
2008-04-03 08:22:53 +08:00
|
|
|
if (!spin_trylock(&mfc_unres_lock)) {
|
2010-05-11 20:40:53 +08:00
|
|
|
mod_timer(&mrt->ipmr_expire_timer, jiffies + 1);
|
2008-04-03 08:22:53 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
if (!list_empty(&mrt->mfc6_unres_queue))
|
|
|
|
ipmr_do_expire_process(mrt);
|
2008-04-03 08:22:53 +08:00
|
|
|
|
|
|
|
spin_unlock(&mfc_unres_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Fill oifs list. It is called under write locked mrt_lock. */
|
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
static void ip6mr_update_thresholds(struct mr6_table *mrt, struct mfc6_cache *cache,
|
2010-05-11 20:40:50 +08:00
|
|
|
unsigned char *ttls)
|
2008-04-03 08:22:53 +08:00
|
|
|
{
|
|
|
|
int vifi;
|
|
|
|
|
2008-04-10 17:40:10 +08:00
|
|
|
cache->mfc_un.res.minvif = MAXMIFS;
|
2008-04-03 08:22:53 +08:00
|
|
|
cache->mfc_un.res.maxvif = 0;
|
2008-04-10 17:40:10 +08:00
|
|
|
memset(cache->mfc_un.res.ttls, 255, MAXMIFS);
|
2008-04-03 08:22:53 +08:00
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
for (vifi = 0; vifi < mrt->maxvif; vifi++) {
|
|
|
|
if (MIF_EXISTS(mrt, vifi) &&
|
2008-12-11 08:15:08 +08:00
|
|
|
ttls[vifi] && ttls[vifi] < 255) {
|
2008-04-03 08:22:53 +08:00
|
|
|
cache->mfc_un.res.ttls[vifi] = ttls[vifi];
|
|
|
|
if (cache->mfc_un.res.minvif > vifi)
|
|
|
|
cache->mfc_un.res.minvif = vifi;
|
|
|
|
if (cache->mfc_un.res.maxvif <= vifi)
|
|
|
|
cache->mfc_un.res.maxvif = vifi + 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
static int mif6_add(struct net *net, struct mr6_table *mrt,
|
|
|
|
struct mif6ctl *vifc, int mrtsock)
|
2008-04-03 08:22:53 +08:00
|
|
|
{
|
|
|
|
int vifi = vifc->mif6c_mifi;
|
2010-05-11 20:40:53 +08:00
|
|
|
struct mif_device *v = &mrt->vif6_table[vifi];
|
2008-04-03 08:22:53 +08:00
|
|
|
struct net_device *dev;
|
2009-01-28 14:39:59 +08:00
|
|
|
struct inet6_dev *in6_dev;
|
2008-07-15 11:54:23 +08:00
|
|
|
int err;
|
2008-04-03 08:22:53 +08:00
|
|
|
|
|
|
|
/* Is vif busy ? */
|
2010-05-11 20:40:53 +08:00
|
|
|
if (MIF_EXISTS(mrt, vifi))
|
2008-04-03 08:22:53 +08:00
|
|
|
return -EADDRINUSE;
|
|
|
|
|
|
|
|
switch (vifc->mif6c_flags) {
|
2008-04-03 08:22:54 +08:00
|
|
|
#ifdef CONFIG_IPV6_PIMSM_V2
|
|
|
|
case MIFF_REGISTER:
|
|
|
|
/*
|
|
|
|
* Special Purpose VIF in PIM
|
|
|
|
* All the packets will be sent to the daemon
|
|
|
|
*/
|
2010-05-11 20:40:53 +08:00
|
|
|
if (mrt->mroute_reg_vif_num >= 0)
|
2008-04-03 08:22:54 +08:00
|
|
|
return -EADDRINUSE;
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
dev = ip6mr_reg_vif(net, mrt);
|
2008-04-03 08:22:54 +08:00
|
|
|
if (!dev)
|
|
|
|
return -ENOBUFS;
|
2008-07-15 11:54:23 +08:00
|
|
|
err = dev_set_allmulti(dev, 1);
|
|
|
|
if (err) {
|
|
|
|
unregister_netdevice(dev);
|
2008-07-15 11:54:54 +08:00
|
|
|
dev_put(dev);
|
2008-07-15 11:54:23 +08:00
|
|
|
return err;
|
|
|
|
}
|
2008-04-03 08:22:54 +08:00
|
|
|
break;
|
|
|
|
#endif
|
2008-04-03 08:22:53 +08:00
|
|
|
case 0:
|
2008-12-11 08:30:15 +08:00
|
|
|
dev = dev_get_by_index(net, vifc->mif6c_pifi);
|
2008-04-03 08:22:53 +08:00
|
|
|
if (!dev)
|
|
|
|
return -EADDRNOTAVAIL;
|
2008-07-15 11:54:23 +08:00
|
|
|
err = dev_set_allmulti(dev, 1);
|
2008-07-15 11:54:54 +08:00
|
|
|
if (err) {
|
|
|
|
dev_put(dev);
|
2008-07-15 11:54:23 +08:00
|
|
|
return err;
|
2008-07-15 11:54:54 +08:00
|
|
|
}
|
2008-04-03 08:22:53 +08:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2009-01-28 14:39:59 +08:00
|
|
|
in6_dev = __in6_dev_get(dev);
|
|
|
|
if (in6_dev)
|
|
|
|
in6_dev->cnf.mc_forwarding++;
|
|
|
|
|
2008-04-03 08:22:53 +08:00
|
|
|
/*
|
|
|
|
* Fill in the VIF structures
|
|
|
|
*/
|
|
|
|
v->rate_limit = vifc->vifc_rate_limit;
|
|
|
|
v->flags = vifc->mif6c_flags;
|
|
|
|
if (!mrtsock)
|
|
|
|
v->flags |= VIFF_STATIC;
|
|
|
|
v->threshold = vifc->vifc_threshold;
|
|
|
|
v->bytes_in = 0;
|
|
|
|
v->bytes_out = 0;
|
|
|
|
v->pkt_in = 0;
|
|
|
|
v->pkt_out = 0;
|
|
|
|
v->link = dev->ifindex;
|
|
|
|
if (v->flags & MIFF_REGISTER)
|
|
|
|
v->link = dev->iflink;
|
|
|
|
|
|
|
|
/* And finish update writing critical data */
|
|
|
|
write_lock_bh(&mrt_lock);
|
|
|
|
v->dev = dev;
|
2008-04-03 08:22:54 +08:00
|
|
|
#ifdef CONFIG_IPV6_PIMSM_V2
|
|
|
|
if (v->flags & MIFF_REGISTER)
|
2010-05-11 20:40:53 +08:00
|
|
|
mrt->mroute_reg_vif_num = vifi;
|
2008-04-03 08:22:54 +08:00
|
|
|
#endif
|
2010-05-11 20:40:53 +08:00
|
|
|
if (vifi + 1 > mrt->maxvif)
|
|
|
|
mrt->maxvif = vifi + 1;
|
2008-04-03 08:22:53 +08:00
|
|
|
write_unlock_bh(&mrt_lock);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
static struct mfc6_cache *ip6mr_cache_find(struct mr6_table *mrt,
|
2008-12-11 08:30:15 +08:00
|
|
|
struct in6_addr *origin,
|
|
|
|
struct in6_addr *mcastgrp)
|
2008-04-03 08:22:53 +08:00
|
|
|
{
|
|
|
|
int line = MFC6_HASH(mcastgrp, origin);
|
|
|
|
struct mfc6_cache *c;
|
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
list_for_each_entry(c, &mrt->mfc6_cache_array[line], list) {
|
2008-04-03 08:22:53 +08:00
|
|
|
if (ipv6_addr_equal(&c->mf6c_origin, origin) &&
|
|
|
|
ipv6_addr_equal(&c->mf6c_mcastgrp, mcastgrp))
|
2010-05-11 20:40:51 +08:00
|
|
|
return c;
|
2008-04-03 08:22:53 +08:00
|
|
|
}
|
2010-05-11 20:40:51 +08:00
|
|
|
return NULL;
|
2008-04-03 08:22:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Allocate a multicast cache entry
|
|
|
|
*/
|
2010-05-11 20:40:50 +08:00
|
|
|
static struct mfc6_cache *ip6mr_cache_alloc(void)
|
2008-04-03 08:22:53 +08:00
|
|
|
{
|
2008-12-04 14:27:25 +08:00
|
|
|
struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
|
2008-04-03 08:22:53 +08:00
|
|
|
if (c == NULL)
|
|
|
|
return NULL;
|
2008-04-10 17:40:10 +08:00
|
|
|
c->mfc_un.res.minvif = MAXMIFS;
|
2008-04-03 08:22:53 +08:00
|
|
|
return c;
|
|
|
|
}
|
|
|
|
|
2010-05-11 20:40:50 +08:00
|
|
|
static struct mfc6_cache *ip6mr_cache_alloc_unres(void)
|
2008-04-03 08:22:53 +08:00
|
|
|
{
|
2008-12-04 14:27:25 +08:00
|
|
|
struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC);
|
2008-04-03 08:22:53 +08:00
|
|
|
if (c == NULL)
|
|
|
|
return NULL;
|
|
|
|
skb_queue_head_init(&c->mfc_un.unres.unresolved);
|
|
|
|
c->mfc_un.unres.expires = jiffies + 10 * HZ;
|
|
|
|
return c;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* A cache entry has gone into a resolved state from queued
|
|
|
|
*/
|
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
static void ip6mr_cache_resolve(struct net *net, struct mr6_table *mrt,
|
|
|
|
struct mfc6_cache *uc, struct mfc6_cache *c)
|
2008-04-03 08:22:53 +08:00
|
|
|
{
|
|
|
|
struct sk_buff *skb;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Play the pending entries through our router
|
|
|
|
*/
|
|
|
|
|
|
|
|
while((skb = __skb_dequeue(&uc->mfc_un.unres.unresolved))) {
|
|
|
|
if (ipv6_hdr(skb)->version == 0) {
|
|
|
|
struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct ipv6hdr));
|
|
|
|
|
2010-05-11 20:40:56 +08:00
|
|
|
if (__ip6mr_fill_mroute(mrt, skb, c, NLMSG_DATA(nlh)) > 0) {
|
2008-04-05 21:17:39 +08:00
|
|
|
nlh->nlmsg_len = skb_tail_pointer(skb) - (u8 *)nlh;
|
2008-04-03 08:22:53 +08:00
|
|
|
} else {
|
|
|
|
nlh->nlmsg_type = NLMSG_ERROR;
|
|
|
|
nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
|
|
|
|
skb_trim(skb, nlh->nlmsg_len);
|
|
|
|
((struct nlmsgerr *)NLMSG_DATA(nlh))->error = -EMSGSIZE;
|
|
|
|
}
|
2011-02-25 13:45:20 +08:00
|
|
|
rtnl_unicast(skb, net, NETLINK_CB(skb).pid);
|
2008-04-03 08:22:53 +08:00
|
|
|
} else
|
2010-05-11 20:40:53 +08:00
|
|
|
ip6_mr_forward(net, mrt, skb, c);
|
2008-04-03 08:22:53 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Bounce a cache query up to pim6sd. We could use netlink for this but pim6sd
|
|
|
|
* expects the following bizarre scheme.
|
|
|
|
*
|
|
|
|
* Called under mrt_lock.
|
|
|
|
*/
|
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
static int ip6mr_cache_report(struct mr6_table *mrt, struct sk_buff *pkt,
|
|
|
|
mifi_t mifi, int assert)
|
2008-04-03 08:22:53 +08:00
|
|
|
{
|
|
|
|
struct sk_buff *skb;
|
|
|
|
struct mrt6msg *msg;
|
|
|
|
int ret;
|
|
|
|
|
2008-04-03 08:22:54 +08:00
|
|
|
#ifdef CONFIG_IPV6_PIMSM_V2
|
|
|
|
if (assert == MRT6MSG_WHOLEPKT)
|
|
|
|
skb = skb_realloc_headroom(pkt, -skb_network_offset(pkt)
|
|
|
|
+sizeof(*msg));
|
|
|
|
else
|
|
|
|
#endif
|
|
|
|
skb = alloc_skb(sizeof(struct ipv6hdr) + sizeof(*msg), GFP_ATOMIC);
|
2008-04-03 08:22:53 +08:00
|
|
|
|
|
|
|
if (!skb)
|
|
|
|
return -ENOBUFS;
|
|
|
|
|
|
|
|
/* I suppose that internal messages
|
|
|
|
* do not require checksums */
|
|
|
|
|
|
|
|
skb->ip_summed = CHECKSUM_UNNECESSARY;
|
|
|
|
|
2008-04-03 08:22:54 +08:00
|
|
|
#ifdef CONFIG_IPV6_PIMSM_V2
|
|
|
|
if (assert == MRT6MSG_WHOLEPKT) {
|
|
|
|
/* Ugly, but we have no choice with this interface.
|
|
|
|
Duplicate old header, fix length etc.
|
|
|
|
And all this only to mangle msg->im6_msgtype and
|
|
|
|
to set msg->im6_mbz to "mbz" :-)
|
|
|
|
*/
|
|
|
|
skb_push(skb, -skb_network_offset(pkt));
|
|
|
|
|
|
|
|
skb_push(skb, sizeof(*msg));
|
|
|
|
skb_reset_transport_header(skb);
|
|
|
|
msg = (struct mrt6msg *)skb_transport_header(skb);
|
|
|
|
msg->im6_mbz = 0;
|
|
|
|
msg->im6_msgtype = MRT6MSG_WHOLEPKT;
|
2010-05-11 20:40:53 +08:00
|
|
|
msg->im6_mif = mrt->mroute_reg_vif_num;
|
2008-04-03 08:22:54 +08:00
|
|
|
msg->im6_pad = 0;
|
|
|
|
ipv6_addr_copy(&msg->im6_src, &ipv6_hdr(pkt)->saddr);
|
|
|
|
ipv6_addr_copy(&msg->im6_dst, &ipv6_hdr(pkt)->daddr);
|
|
|
|
|
|
|
|
skb->ip_summed = CHECKSUM_UNNECESSARY;
|
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
{
|
2008-04-03 08:22:53 +08:00
|
|
|
/*
|
|
|
|
* Copy the IP header
|
|
|
|
*/
|
|
|
|
|
|
|
|
skb_put(skb, sizeof(struct ipv6hdr));
|
|
|
|
skb_reset_network_header(skb);
|
|
|
|
skb_copy_to_linear_data(skb, ipv6_hdr(pkt), sizeof(struct ipv6hdr));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add our header
|
|
|
|
*/
|
|
|
|
skb_put(skb, sizeof(*msg));
|
|
|
|
skb_reset_transport_header(skb);
|
|
|
|
msg = (struct mrt6msg *)skb_transport_header(skb);
|
|
|
|
|
|
|
|
msg->im6_mbz = 0;
|
|
|
|
msg->im6_msgtype = assert;
|
2008-04-10 17:40:10 +08:00
|
|
|
msg->im6_mif = mifi;
|
2008-04-03 08:22:53 +08:00
|
|
|
msg->im6_pad = 0;
|
|
|
|
ipv6_addr_copy(&msg->im6_src, &ipv6_hdr(pkt)->saddr);
|
|
|
|
ipv6_addr_copy(&msg->im6_dst, &ipv6_hdr(pkt)->daddr);
|
|
|
|
|
2009-06-02 13:19:30 +08:00
|
|
|
skb_dst_set(skb, dst_clone(skb_dst(pkt)));
|
2008-04-03 08:22:53 +08:00
|
|
|
skb->ip_summed = CHECKSUM_UNNECESSARY;
|
2008-04-03 08:22:54 +08:00
|
|
|
}
|
2008-04-03 08:22:53 +08:00
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
if (mrt->mroute6_sk == NULL) {
|
2008-04-03 08:22:53 +08:00
|
|
|
kfree_skb(skb);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Deliver to user space multicast routing algorithms
|
|
|
|
*/
|
2010-05-11 20:40:53 +08:00
|
|
|
ret = sock_queue_rcv_skb(mrt->mroute6_sk, skb);
|
2008-12-11 08:07:08 +08:00
|
|
|
if (ret < 0) {
|
2008-04-03 08:22:53 +08:00
|
|
|
if (net_ratelimit())
|
|
|
|
printk(KERN_WARNING "mroute6: pending queue full, dropping entries.\n");
|
|
|
|
kfree_skb(skb);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Queue a packet for resolution. It gets locked cache entry!
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int
|
2010-05-11 20:40:53 +08:00
|
|
|
ip6mr_cache_unresolved(struct mr6_table *mrt, mifi_t mifi, struct sk_buff *skb)
|
2008-04-03 08:22:53 +08:00
|
|
|
{
|
2010-05-11 20:40:51 +08:00
|
|
|
bool found = false;
|
2008-04-03 08:22:53 +08:00
|
|
|
int err;
|
|
|
|
struct mfc6_cache *c;
|
|
|
|
|
|
|
|
spin_lock_bh(&mfc_unres_lock);
|
2010-05-11 20:40:53 +08:00
|
|
|
list_for_each_entry(c, &mrt->mfc6_unres_queue, list) {
|
2010-05-11 20:40:48 +08:00
|
|
|
if (ipv6_addr_equal(&c->mf6c_mcastgrp, &ipv6_hdr(skb)->daddr) &&
|
2010-05-11 20:40:51 +08:00
|
|
|
ipv6_addr_equal(&c->mf6c_origin, &ipv6_hdr(skb)->saddr)) {
|
|
|
|
found = true;
|
2008-04-03 08:22:53 +08:00
|
|
|
break;
|
2010-05-11 20:40:51 +08:00
|
|
|
}
|
2008-04-03 08:22:53 +08:00
|
|
|
}
|
|
|
|
|
2010-05-11 20:40:51 +08:00
|
|
|
if (!found) {
|
2008-04-03 08:22:53 +08:00
|
|
|
/*
|
|
|
|
* Create a new entry if allowable
|
|
|
|
*/
|
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
if (atomic_read(&mrt->cache_resolve_queue_len) >= 10 ||
|
2010-05-11 20:40:50 +08:00
|
|
|
(c = ip6mr_cache_alloc_unres()) == NULL) {
|
2008-04-03 08:22:53 +08:00
|
|
|
spin_unlock_bh(&mfc_unres_lock);
|
|
|
|
|
|
|
|
kfree_skb(skb);
|
|
|
|
return -ENOBUFS;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Fill in the new cache entry
|
|
|
|
*/
|
|
|
|
c->mf6c_parent = -1;
|
|
|
|
c->mf6c_origin = ipv6_hdr(skb)->saddr;
|
|
|
|
c->mf6c_mcastgrp = ipv6_hdr(skb)->daddr;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Reflect first query at pim6sd
|
|
|
|
*/
|
2010-05-11 20:40:53 +08:00
|
|
|
err = ip6mr_cache_report(mrt, skb, mifi, MRT6MSG_NOCACHE);
|
2008-12-11 08:30:15 +08:00
|
|
|
if (err < 0) {
|
2008-04-03 08:22:53 +08:00
|
|
|
/* If the report failed throw the cache entry
|
|
|
|
out - Brad Parker
|
|
|
|
*/
|
|
|
|
spin_unlock_bh(&mfc_unres_lock);
|
|
|
|
|
2008-12-11 08:22:34 +08:00
|
|
|
ip6mr_cache_free(c);
|
2008-04-03 08:22:53 +08:00
|
|
|
kfree_skb(skb);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
atomic_inc(&mrt->cache_resolve_queue_len);
|
|
|
|
list_add(&c->list, &mrt->mfc6_unres_queue);
|
2008-04-03 08:22:53 +08:00
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
ipmr_do_expire_process(mrt);
|
2008-04-03 08:22:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* See if we can append the packet
|
|
|
|
*/
|
|
|
|
if (c->mfc_un.unres.unresolved.qlen > 3) {
|
|
|
|
kfree_skb(skb);
|
|
|
|
err = -ENOBUFS;
|
|
|
|
} else {
|
|
|
|
skb_queue_tail(&c->mfc_un.unres.unresolved, skb);
|
|
|
|
err = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock_bh(&mfc_unres_lock);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* MFC6 cache manipulation by user space
|
|
|
|
*/
|
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
static int ip6mr_mfc_delete(struct mr6_table *mrt, struct mf6cctl *mfc)
|
2008-04-03 08:22:53 +08:00
|
|
|
{
|
|
|
|
int line;
|
2010-05-11 20:40:51 +08:00
|
|
|
struct mfc6_cache *c, *next;
|
2008-04-03 08:22:53 +08:00
|
|
|
|
|
|
|
line = MFC6_HASH(&mfc->mf6cc_mcastgrp.sin6_addr, &mfc->mf6cc_origin.sin6_addr);
|
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
list_for_each_entry_safe(c, next, &mrt->mfc6_cache_array[line], list) {
|
2008-04-03 08:22:53 +08:00
|
|
|
if (ipv6_addr_equal(&c->mf6c_origin, &mfc->mf6cc_origin.sin6_addr) &&
|
|
|
|
ipv6_addr_equal(&c->mf6c_mcastgrp, &mfc->mf6cc_mcastgrp.sin6_addr)) {
|
|
|
|
write_lock_bh(&mrt_lock);
|
2010-05-11 20:40:51 +08:00
|
|
|
list_del(&c->list);
|
2008-04-03 08:22:53 +08:00
|
|
|
write_unlock_bh(&mrt_lock);
|
|
|
|
|
2008-12-11 08:22:34 +08:00
|
|
|
ip6mr_cache_free(c);
|
2008-04-03 08:22:53 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ip6mr_device_event(struct notifier_block *this,
|
|
|
|
unsigned long event, void *ptr)
|
|
|
|
{
|
|
|
|
struct net_device *dev = ptr;
|
2008-12-11 08:30:15 +08:00
|
|
|
struct net *net = dev_net(dev);
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
struct mr6_table *mrt;
|
2008-04-03 08:22:53 +08:00
|
|
|
struct mif_device *v;
|
|
|
|
int ct;
|
2009-10-28 12:48:11 +08:00
|
|
|
LIST_HEAD(list);
|
2008-04-03 08:22:53 +08:00
|
|
|
|
|
|
|
if (event != NETDEV_UNREGISTER)
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
ip6mr_for_each_table(mrt, net) {
|
|
|
|
v = &mrt->vif6_table[0];
|
|
|
|
for (ct = 0; ct < mrt->maxvif; ct++, v++) {
|
|
|
|
if (v->dev == dev)
|
|
|
|
mif6_delete(mrt, ct, &list);
|
|
|
|
}
|
2008-04-03 08:22:53 +08:00
|
|
|
}
|
2009-10-28 12:48:11 +08:00
|
|
|
unregister_netdevice_many(&list);
|
|
|
|
|
2008-04-03 08:22:53 +08:00
|
|
|
return NOTIFY_DONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct notifier_block ip6_mr_notifier = {
|
|
|
|
.notifier_call = ip6mr_device_event
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Setup for IP multicast routing
|
|
|
|
*/
|
|
|
|
|
2008-12-11 08:15:08 +08:00
|
|
|
static int __net_init ip6mr_net_init(struct net *net)
|
|
|
|
{
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
int err;
|
2010-05-11 20:40:51 +08:00
|
|
|
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
err = ip6mr_rules_init(net);
|
|
|
|
if (err < 0)
|
2008-12-11 08:15:08 +08:00
|
|
|
goto fail;
|
2008-12-11 08:29:48 +08:00
|
|
|
|
|
|
|
#ifdef CONFIG_PROC_FS
|
|
|
|
err = -ENOMEM;
|
|
|
|
if (!proc_net_fops_create(net, "ip6_mr_vif", 0, &ip6mr_vif_fops))
|
|
|
|
goto proc_vif_fail;
|
|
|
|
if (!proc_net_fops_create(net, "ip6_mr_cache", 0, &ip6mr_mfc_fops))
|
|
|
|
goto proc_cache_fail;
|
|
|
|
#endif
|
2010-05-11 20:40:53 +08:00
|
|
|
|
2008-12-11 08:24:07 +08:00
|
|
|
return 0;
|
|
|
|
|
2008-12-11 08:29:48 +08:00
|
|
|
#ifdef CONFIG_PROC_FS
|
|
|
|
proc_cache_fail:
|
|
|
|
proc_net_remove(net, "ip6_mr_vif");
|
|
|
|
proc_vif_fail:
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
ip6mr_rules_exit(net);
|
2008-12-11 08:29:48 +08:00
|
|
|
#endif
|
2008-12-11 08:15:08 +08:00
|
|
|
fail:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __net_exit ip6mr_net_exit(struct net *net)
|
|
|
|
{
|
2008-12-11 08:29:48 +08:00
|
|
|
#ifdef CONFIG_PROC_FS
|
|
|
|
proc_net_remove(net, "ip6_mr_cache");
|
|
|
|
proc_net_remove(net, "ip6_mr_vif");
|
|
|
|
#endif
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
ip6mr_rules_exit(net);
|
2008-12-11 08:15:08 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct pernet_operations ip6mr_net_ops = {
|
|
|
|
.init = ip6mr_net_init,
|
|
|
|
.exit = ip6mr_net_exit,
|
|
|
|
};
|
|
|
|
|
2008-07-03 12:13:30 +08:00
|
|
|
int __init ip6_mr_init(void)
|
2008-04-03 08:22:53 +08:00
|
|
|
{
|
2008-07-03 12:13:30 +08:00
|
|
|
int err;
|
|
|
|
|
2008-04-03 08:22:53 +08:00
|
|
|
mrt_cachep = kmem_cache_create("ip6_mrt_cache",
|
|
|
|
sizeof(struct mfc6_cache),
|
|
|
|
0, SLAB_HWCACHE_ALIGN,
|
|
|
|
NULL);
|
|
|
|
if (!mrt_cachep)
|
2008-07-03 12:13:30 +08:00
|
|
|
return -ENOMEM;
|
2008-04-03 08:22:53 +08:00
|
|
|
|
2008-12-11 08:15:08 +08:00
|
|
|
err = register_pernet_subsys(&ip6mr_net_ops);
|
|
|
|
if (err)
|
|
|
|
goto reg_pernet_fail;
|
|
|
|
|
2008-07-03 12:13:30 +08:00
|
|
|
err = register_netdevice_notifier(&ip6_mr_notifier);
|
|
|
|
if (err)
|
|
|
|
goto reg_notif_fail;
|
2009-06-14 18:16:13 +08:00
|
|
|
#ifdef CONFIG_IPV6_PIMSM_V2
|
|
|
|
if (inet6_add_protocol(&pim6_protocol, IPPROTO_PIM) < 0) {
|
|
|
|
printk(KERN_ERR "ip6_mr_init: can't add PIM protocol\n");
|
|
|
|
err = -EAGAIN;
|
|
|
|
goto add_proto_fail;
|
|
|
|
}
|
|
|
|
#endif
|
2010-05-11 20:40:56 +08:00
|
|
|
rtnl_register(RTNL_FAMILY_IP6MR, RTM_GETROUTE, NULL, ip6mr_rtm_dumproute);
|
2008-07-03 12:13:30 +08:00
|
|
|
return 0;
|
2009-06-14 18:16:13 +08:00
|
|
|
#ifdef CONFIG_IPV6_PIMSM_V2
|
|
|
|
add_proto_fail:
|
|
|
|
unregister_netdevice_notifier(&ip6_mr_notifier);
|
|
|
|
#endif
|
2008-11-11 08:34:11 +08:00
|
|
|
reg_notif_fail:
|
2008-12-11 08:15:08 +08:00
|
|
|
unregister_pernet_subsys(&ip6mr_net_ops);
|
|
|
|
reg_pernet_fail:
|
2008-11-11 08:34:11 +08:00
|
|
|
kmem_cache_destroy(mrt_cachep);
|
2008-07-03 12:13:30 +08:00
|
|
|
return err;
|
2008-04-03 08:22:53 +08:00
|
|
|
}
|
|
|
|
|
2008-07-03 12:13:30 +08:00
|
|
|
void ip6_mr_cleanup(void)
|
|
|
|
{
|
|
|
|
unregister_netdevice_notifier(&ip6_mr_notifier);
|
2008-12-11 08:15:08 +08:00
|
|
|
unregister_pernet_subsys(&ip6mr_net_ops);
|
2008-07-03 12:13:30 +08:00
|
|
|
kmem_cache_destroy(mrt_cachep);
|
|
|
|
}
|
2008-04-03 08:22:53 +08:00
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
static int ip6mr_mfc_add(struct net *net, struct mr6_table *mrt,
|
|
|
|
struct mf6cctl *mfc, int mrtsock)
|
2008-04-03 08:22:53 +08:00
|
|
|
{
|
2010-05-11 20:40:51 +08:00
|
|
|
bool found = false;
|
2008-04-03 08:22:53 +08:00
|
|
|
int line;
|
2010-05-11 20:40:51 +08:00
|
|
|
struct mfc6_cache *uc, *c;
|
2008-04-10 17:40:10 +08:00
|
|
|
unsigned char ttls[MAXMIFS];
|
2008-04-03 08:22:53 +08:00
|
|
|
int i;
|
|
|
|
|
2010-03-17 14:04:14 +08:00
|
|
|
if (mfc->mf6cc_parent >= MAXMIFS)
|
|
|
|
return -ENFILE;
|
|
|
|
|
2008-04-10 17:40:10 +08:00
|
|
|
memset(ttls, 255, MAXMIFS);
|
|
|
|
for (i = 0; i < MAXMIFS; i++) {
|
2008-04-03 08:22:53 +08:00
|
|
|
if (IF_ISSET(i, &mfc->mf6cc_ifset))
|
|
|
|
ttls[i] = 1;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
line = MFC6_HASH(&mfc->mf6cc_mcastgrp.sin6_addr, &mfc->mf6cc_origin.sin6_addr);
|
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
list_for_each_entry(c, &mrt->mfc6_cache_array[line], list) {
|
2008-04-03 08:22:53 +08:00
|
|
|
if (ipv6_addr_equal(&c->mf6c_origin, &mfc->mf6cc_origin.sin6_addr) &&
|
2010-05-11 20:40:51 +08:00
|
|
|
ipv6_addr_equal(&c->mf6c_mcastgrp, &mfc->mf6cc_mcastgrp.sin6_addr)) {
|
|
|
|
found = true;
|
2008-04-03 08:22:53 +08:00
|
|
|
break;
|
2010-05-11 20:40:51 +08:00
|
|
|
}
|
2008-04-03 08:22:53 +08:00
|
|
|
}
|
|
|
|
|
2010-05-11 20:40:51 +08:00
|
|
|
if (found) {
|
2008-04-03 08:22:53 +08:00
|
|
|
write_lock_bh(&mrt_lock);
|
|
|
|
c->mf6c_parent = mfc->mf6cc_parent;
|
2010-05-11 20:40:53 +08:00
|
|
|
ip6mr_update_thresholds(mrt, c, ttls);
|
2008-04-03 08:22:53 +08:00
|
|
|
if (!mrtsock)
|
|
|
|
c->mfc_flags |= MFC_STATIC;
|
|
|
|
write_unlock_bh(&mrt_lock);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ipv6_addr_is_multicast(&mfc->mf6cc_mcastgrp.sin6_addr))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2010-05-11 20:40:50 +08:00
|
|
|
c = ip6mr_cache_alloc();
|
2008-04-03 08:22:53 +08:00
|
|
|
if (c == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
c->mf6c_origin = mfc->mf6cc_origin.sin6_addr;
|
|
|
|
c->mf6c_mcastgrp = mfc->mf6cc_mcastgrp.sin6_addr;
|
|
|
|
c->mf6c_parent = mfc->mf6cc_parent;
|
2010-05-11 20:40:53 +08:00
|
|
|
ip6mr_update_thresholds(mrt, c, ttls);
|
2008-04-03 08:22:53 +08:00
|
|
|
if (!mrtsock)
|
|
|
|
c->mfc_flags |= MFC_STATIC;
|
|
|
|
|
|
|
|
write_lock_bh(&mrt_lock);
|
2010-05-11 20:40:53 +08:00
|
|
|
list_add(&c->list, &mrt->mfc6_cache_array[line]);
|
2008-04-03 08:22:53 +08:00
|
|
|
write_unlock_bh(&mrt_lock);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check to see if we resolved a queued list. If so we
|
|
|
|
* need to send on the frames and tidy up.
|
|
|
|
*/
|
2010-05-11 20:40:51 +08:00
|
|
|
found = false;
|
2008-04-03 08:22:53 +08:00
|
|
|
spin_lock_bh(&mfc_unres_lock);
|
2010-05-11 20:40:53 +08:00
|
|
|
list_for_each_entry(uc, &mrt->mfc6_unres_queue, list) {
|
2010-05-11 20:40:48 +08:00
|
|
|
if (ipv6_addr_equal(&uc->mf6c_origin, &c->mf6c_origin) &&
|
2008-04-03 08:22:53 +08:00
|
|
|
ipv6_addr_equal(&uc->mf6c_mcastgrp, &c->mf6c_mcastgrp)) {
|
2010-05-11 20:40:51 +08:00
|
|
|
list_del(&uc->list);
|
2010-05-11 20:40:53 +08:00
|
|
|
atomic_dec(&mrt->cache_resolve_queue_len);
|
2010-05-11 20:40:51 +08:00
|
|
|
found = true;
|
2008-04-03 08:22:53 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2010-05-11 20:40:53 +08:00
|
|
|
if (list_empty(&mrt->mfc6_unres_queue))
|
|
|
|
del_timer(&mrt->ipmr_expire_timer);
|
2008-04-03 08:22:53 +08:00
|
|
|
spin_unlock_bh(&mfc_unres_lock);
|
|
|
|
|
2010-05-11 20:40:51 +08:00
|
|
|
if (found) {
|
2010-05-11 20:40:53 +08:00
|
|
|
ip6mr_cache_resolve(net, mrt, uc, c);
|
2008-12-11 08:22:34 +08:00
|
|
|
ip6mr_cache_free(uc);
|
2008-04-03 08:22:53 +08:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Close the multicast socket, and clear the vif tables etc
|
|
|
|
*/
|
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
static void mroute_clean_tables(struct mr6_table *mrt)
|
2008-04-03 08:22:53 +08:00
|
|
|
{
|
|
|
|
int i;
|
2009-10-28 12:48:11 +08:00
|
|
|
LIST_HEAD(list);
|
2010-05-11 20:40:51 +08:00
|
|
|
struct mfc6_cache *c, *next;
|
2008-04-03 08:22:53 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Shut down all active vif entries
|
|
|
|
*/
|
2010-05-11 20:40:53 +08:00
|
|
|
for (i = 0; i < mrt->maxvif; i++) {
|
|
|
|
if (!(mrt->vif6_table[i].flags & VIFF_STATIC))
|
|
|
|
mif6_delete(mrt, i, &list);
|
2008-04-03 08:22:53 +08:00
|
|
|
}
|
2009-10-28 12:48:11 +08:00
|
|
|
unregister_netdevice_many(&list);
|
2008-04-03 08:22:53 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Wipe the cache
|
|
|
|
*/
|
2008-12-11 08:24:07 +08:00
|
|
|
for (i = 0; i < MFC6_LINES; i++) {
|
2010-05-11 20:40:53 +08:00
|
|
|
list_for_each_entry_safe(c, next, &mrt->mfc6_cache_array[i], list) {
|
2010-05-11 20:40:51 +08:00
|
|
|
if (c->mfc_flags & MFC_STATIC)
|
2008-04-03 08:22:53 +08:00
|
|
|
continue;
|
|
|
|
write_lock_bh(&mrt_lock);
|
2010-05-11 20:40:51 +08:00
|
|
|
list_del(&c->list);
|
2008-04-03 08:22:53 +08:00
|
|
|
write_unlock_bh(&mrt_lock);
|
|
|
|
|
2008-12-11 08:22:34 +08:00
|
|
|
ip6mr_cache_free(c);
|
2008-04-03 08:22:53 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
if (atomic_read(&mrt->cache_resolve_queue_len) != 0) {
|
2008-04-03 08:22:53 +08:00
|
|
|
spin_lock_bh(&mfc_unres_lock);
|
2010-05-11 20:40:53 +08:00
|
|
|
list_for_each_entry_safe(c, next, &mrt->mfc6_unres_queue, list) {
|
2010-05-11 20:40:51 +08:00
|
|
|
list_del(&c->list);
|
2010-05-11 20:40:53 +08:00
|
|
|
ip6mr_destroy_unres(mrt, c);
|
2008-04-03 08:22:53 +08:00
|
|
|
}
|
|
|
|
spin_unlock_bh(&mfc_unres_lock);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
static int ip6mr_sk_init(struct mr6_table *mrt, struct sock *sk)
|
2008-04-03 08:22:53 +08:00
|
|
|
{
|
|
|
|
int err = 0;
|
2008-12-11 08:30:15 +08:00
|
|
|
struct net *net = sock_net(sk);
|
2008-04-03 08:22:53 +08:00
|
|
|
|
|
|
|
rtnl_lock();
|
|
|
|
write_lock_bh(&mrt_lock);
|
2010-05-11 20:40:53 +08:00
|
|
|
if (likely(mrt->mroute6_sk == NULL)) {
|
|
|
|
mrt->mroute6_sk = sk;
|
2009-01-28 14:39:59 +08:00
|
|
|
net->ipv6.devconf_all->mc_forwarding++;
|
|
|
|
}
|
2008-04-03 08:22:53 +08:00
|
|
|
else
|
|
|
|
err = -EADDRINUSE;
|
|
|
|
write_unlock_bh(&mrt_lock);
|
|
|
|
|
|
|
|
rtnl_unlock();
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
int ip6mr_sk_done(struct sock *sk)
|
|
|
|
{
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
int err = -EACCES;
|
2008-12-11 08:30:15 +08:00
|
|
|
struct net *net = sock_net(sk);
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
struct mr6_table *mrt;
|
2008-04-03 08:22:53 +08:00
|
|
|
|
|
|
|
rtnl_lock();
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
ip6mr_for_each_table(mrt, net) {
|
|
|
|
if (sk == mrt->mroute6_sk) {
|
|
|
|
write_lock_bh(&mrt_lock);
|
|
|
|
mrt->mroute6_sk = NULL;
|
|
|
|
net->ipv6.devconf_all->mc_forwarding--;
|
|
|
|
write_unlock_bh(&mrt_lock);
|
2008-04-03 08:22:53 +08:00
|
|
|
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
mroute_clean_tables(mrt);
|
|
|
|
err = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2008-04-03 08:22:53 +08:00
|
|
|
rtnl_unlock();
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
struct sock *mroute6_socket(struct net *net, struct sk_buff *skb)
|
2010-05-11 20:40:53 +08:00
|
|
|
{
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
struct mr6_table *mrt;
|
2011-03-13 05:22:43 +08:00
|
|
|
struct flowi6 fl6 = {
|
|
|
|
.flowi6_iif = skb->skb_iif,
|
|
|
|
.flowi6_oif = skb->dev->ifindex,
|
|
|
|
.flowi6_mark = skb->mark,
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
};
|
|
|
|
|
2011-03-13 05:22:43 +08:00
|
|
|
if (ip6mr_fib_lookup(net, &fl6, &mrt) < 0)
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
return NULL;
|
2010-05-11 20:40:53 +08:00
|
|
|
|
|
|
|
return mrt->mroute6_sk;
|
|
|
|
}
|
|
|
|
|
2008-04-03 08:22:53 +08:00
|
|
|
/*
|
|
|
|
* Socket options and virtual interface manipulation. The whole
|
|
|
|
* virtual interface system is a complete heap, but unfortunately
|
|
|
|
* that's how BSD mrouted happens to think. Maybe one day with a proper
|
|
|
|
* MOSPF/PIM router set up we can clean this up.
|
|
|
|
*/
|
|
|
|
|
2009-10-01 07:12:20 +08:00
|
|
|
int ip6_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsigned int optlen)
|
2008-04-03 08:22:53 +08:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct mif6ctl vif;
|
|
|
|
struct mf6cctl mfc;
|
|
|
|
mifi_t mifi;
|
2008-12-11 08:30:15 +08:00
|
|
|
struct net *net = sock_net(sk);
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
struct mr6_table *mrt;
|
|
|
|
|
|
|
|
mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
|
|
|
|
if (mrt == NULL)
|
|
|
|
return -ENOENT;
|
2008-04-03 08:22:53 +08:00
|
|
|
|
|
|
|
if (optname != MRT6_INIT) {
|
2010-05-11 20:40:53 +08:00
|
|
|
if (sk != mrt->mroute6_sk && !capable(CAP_NET_ADMIN))
|
2008-04-03 08:22:53 +08:00
|
|
|
return -EACCES;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (optname) {
|
|
|
|
case MRT6_INIT:
|
|
|
|
if (sk->sk_type != SOCK_RAW ||
|
2009-10-15 14:30:45 +08:00
|
|
|
inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
|
2008-04-03 08:22:53 +08:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
if (optlen < sizeof(int))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
return ip6mr_sk_init(mrt, sk);
|
2008-04-03 08:22:53 +08:00
|
|
|
|
|
|
|
case MRT6_DONE:
|
|
|
|
return ip6mr_sk_done(sk);
|
|
|
|
|
|
|
|
case MRT6_ADD_MIF:
|
|
|
|
if (optlen < sizeof(vif))
|
|
|
|
return -EINVAL;
|
|
|
|
if (copy_from_user(&vif, optval, sizeof(vif)))
|
|
|
|
return -EFAULT;
|
2008-04-10 17:40:10 +08:00
|
|
|
if (vif.mif6c_mifi >= MAXMIFS)
|
2008-04-03 08:22:53 +08:00
|
|
|
return -ENFILE;
|
|
|
|
rtnl_lock();
|
2010-05-11 20:40:53 +08:00
|
|
|
ret = mif6_add(net, mrt, &vif, sk == mrt->mroute6_sk);
|
2008-04-03 08:22:53 +08:00
|
|
|
rtnl_unlock();
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
case MRT6_DEL_MIF:
|
|
|
|
if (optlen < sizeof(mifi_t))
|
|
|
|
return -EINVAL;
|
|
|
|
if (copy_from_user(&mifi, optval, sizeof(mifi_t)))
|
|
|
|
return -EFAULT;
|
|
|
|
rtnl_lock();
|
2010-05-11 20:40:53 +08:00
|
|
|
ret = mif6_delete(mrt, mifi, NULL);
|
2008-04-03 08:22:53 +08:00
|
|
|
rtnl_unlock();
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Manipulate the forwarding caches. These live
|
|
|
|
* in a sort of kernel/user symbiosis.
|
|
|
|
*/
|
|
|
|
case MRT6_ADD_MFC:
|
|
|
|
case MRT6_DEL_MFC:
|
|
|
|
if (optlen < sizeof(mfc))
|
|
|
|
return -EINVAL;
|
|
|
|
if (copy_from_user(&mfc, optval, sizeof(mfc)))
|
|
|
|
return -EFAULT;
|
|
|
|
rtnl_lock();
|
|
|
|
if (optname == MRT6_DEL_MFC)
|
2010-05-11 20:40:53 +08:00
|
|
|
ret = ip6mr_mfc_delete(mrt, &mfc);
|
2008-04-03 08:22:53 +08:00
|
|
|
else
|
2010-05-11 20:40:53 +08:00
|
|
|
ret = ip6mr_mfc_add(net, mrt, &mfc, sk == mrt->mroute6_sk);
|
2008-04-03 08:22:53 +08:00
|
|
|
rtnl_unlock();
|
|
|
|
return ret;
|
|
|
|
|
2008-04-03 08:22:54 +08:00
|
|
|
/*
|
|
|
|
* Control PIM assert (to activate pim will activate assert)
|
|
|
|
*/
|
|
|
|
case MRT6_ASSERT:
|
|
|
|
{
|
|
|
|
int v;
|
|
|
|
if (get_user(v, (int __user *)optval))
|
|
|
|
return -EFAULT;
|
2010-05-11 20:40:53 +08:00
|
|
|
mrt->mroute_do_assert = !!v;
|
2008-04-03 08:22:54 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_IPV6_PIMSM_V2
|
|
|
|
case MRT6_PIM:
|
|
|
|
{
|
2008-04-10 14:41:28 +08:00
|
|
|
int v;
|
2008-04-03 08:22:54 +08:00
|
|
|
if (get_user(v, (int __user *)optval))
|
|
|
|
return -EFAULT;
|
|
|
|
v = !!v;
|
|
|
|
rtnl_lock();
|
|
|
|
ret = 0;
|
2010-05-11 20:40:53 +08:00
|
|
|
if (v != mrt->mroute_do_pim) {
|
|
|
|
mrt->mroute_do_pim = v;
|
|
|
|
mrt->mroute_do_assert = v;
|
2008-04-03 08:22:54 +08:00
|
|
|
}
|
|
|
|
rtnl_unlock();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
|
|
|
|
case MRT6_TABLE:
|
|
|
|
{
|
|
|
|
u32 v;
|
|
|
|
|
|
|
|
if (optlen != sizeof(u32))
|
|
|
|
return -EINVAL;
|
|
|
|
if (get_user(v, (u32 __user *)optval))
|
|
|
|
return -EFAULT;
|
|
|
|
if (sk == mrt->mroute6_sk)
|
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
rtnl_lock();
|
|
|
|
ret = 0;
|
|
|
|
if (!ip6mr_new_table(net, v))
|
|
|
|
ret = -ENOMEM;
|
|
|
|
raw6_sk(sk)->ip6mr_table = v;
|
|
|
|
rtnl_unlock();
|
|
|
|
return ret;
|
|
|
|
}
|
2008-04-03 08:22:54 +08:00
|
|
|
#endif
|
2008-04-03 08:22:53 +08:00
|
|
|
/*
|
2008-04-23 19:35:13 +08:00
|
|
|
* Spurious command, or MRT6_VERSION which you cannot
|
2008-04-03 08:22:53 +08:00
|
|
|
* set.
|
|
|
|
*/
|
|
|
|
default:
|
|
|
|
return -ENOPROTOOPT;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Getsock opt support for the multicast routing system.
|
|
|
|
*/
|
|
|
|
|
|
|
|
int ip6_mroute_getsockopt(struct sock *sk, int optname, char __user *optval,
|
|
|
|
int __user *optlen)
|
|
|
|
{
|
|
|
|
int olr;
|
|
|
|
int val;
|
2008-12-11 08:30:15 +08:00
|
|
|
struct net *net = sock_net(sk);
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
struct mr6_table *mrt;
|
|
|
|
|
|
|
|
mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
|
|
|
|
if (mrt == NULL)
|
|
|
|
return -ENOENT;
|
2008-04-03 08:22:53 +08:00
|
|
|
|
|
|
|
switch (optname) {
|
|
|
|
case MRT6_VERSION:
|
|
|
|
val = 0x0305;
|
|
|
|
break;
|
2008-04-03 08:22:54 +08:00
|
|
|
#ifdef CONFIG_IPV6_PIMSM_V2
|
|
|
|
case MRT6_PIM:
|
2010-05-11 20:40:53 +08:00
|
|
|
val = mrt->mroute_do_pim;
|
2008-04-03 08:22:54 +08:00
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
case MRT6_ASSERT:
|
2010-05-11 20:40:53 +08:00
|
|
|
val = mrt->mroute_do_assert;
|
2008-04-03 08:22:54 +08:00
|
|
|
break;
|
2008-04-03 08:22:53 +08:00
|
|
|
default:
|
|
|
|
return -ENOPROTOOPT;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (get_user(olr, optlen))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
olr = min_t(int, olr, sizeof(int));
|
|
|
|
if (olr < 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (put_user(olr, optlen))
|
|
|
|
return -EFAULT;
|
|
|
|
if (copy_to_user(optval, &val, olr))
|
|
|
|
return -EFAULT;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The IP multicast ioctl support routines.
|
|
|
|
*/
|
|
|
|
|
|
|
|
int ip6mr_ioctl(struct sock *sk, int cmd, void __user *arg)
|
|
|
|
{
|
|
|
|
struct sioc_sg_req6 sr;
|
|
|
|
struct sioc_mif_req6 vr;
|
|
|
|
struct mif_device *vif;
|
|
|
|
struct mfc6_cache *c;
|
2008-12-11 08:30:15 +08:00
|
|
|
struct net *net = sock_net(sk);
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
struct mr6_table *mrt;
|
|
|
|
|
|
|
|
mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
|
|
|
|
if (mrt == NULL)
|
|
|
|
return -ENOENT;
|
2008-04-03 08:22:53 +08:00
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case SIOCGETMIFCNT_IN6:
|
|
|
|
if (copy_from_user(&vr, arg, sizeof(vr)))
|
|
|
|
return -EFAULT;
|
2010-05-11 20:40:53 +08:00
|
|
|
if (vr.mifi >= mrt->maxvif)
|
2008-04-03 08:22:53 +08:00
|
|
|
return -EINVAL;
|
|
|
|
read_lock(&mrt_lock);
|
2010-05-11 20:40:53 +08:00
|
|
|
vif = &mrt->vif6_table[vr.mifi];
|
|
|
|
if (MIF_EXISTS(mrt, vr.mifi)) {
|
2008-04-03 08:22:53 +08:00
|
|
|
vr.icount = vif->pkt_in;
|
|
|
|
vr.ocount = vif->pkt_out;
|
|
|
|
vr.ibytes = vif->bytes_in;
|
|
|
|
vr.obytes = vif->bytes_out;
|
|
|
|
read_unlock(&mrt_lock);
|
|
|
|
|
|
|
|
if (copy_to_user(arg, &vr, sizeof(vr)))
|
|
|
|
return -EFAULT;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
read_unlock(&mrt_lock);
|
|
|
|
return -EADDRNOTAVAIL;
|
|
|
|
case SIOCGETSGCNT_IN6:
|
|
|
|
if (copy_from_user(&sr, arg, sizeof(sr)))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
read_lock(&mrt_lock);
|
2010-05-11 20:40:53 +08:00
|
|
|
c = ip6mr_cache_find(mrt, &sr.src.sin6_addr, &sr.grp.sin6_addr);
|
2008-04-03 08:22:53 +08:00
|
|
|
if (c) {
|
|
|
|
sr.pktcnt = c->mfc_un.res.pkt;
|
|
|
|
sr.bytecnt = c->mfc_un.res.bytes;
|
|
|
|
sr.wrong_if = c->mfc_un.res.wrong_if;
|
|
|
|
read_unlock(&mrt_lock);
|
|
|
|
|
|
|
|
if (copy_to_user(arg, &sr, sizeof(sr)))
|
|
|
|
return -EFAULT;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
read_unlock(&mrt_lock);
|
|
|
|
return -EADDRNOTAVAIL;
|
|
|
|
default:
|
|
|
|
return -ENOIOCTLCMD;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-02-04 09:59:32 +08:00
|
|
|
#ifdef CONFIG_COMPAT
|
|
|
|
struct compat_sioc_sg_req6 {
|
|
|
|
struct sockaddr_in6 src;
|
|
|
|
struct sockaddr_in6 grp;
|
|
|
|
compat_ulong_t pktcnt;
|
|
|
|
compat_ulong_t bytecnt;
|
|
|
|
compat_ulong_t wrong_if;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct compat_sioc_mif_req6 {
|
|
|
|
mifi_t mifi;
|
|
|
|
compat_ulong_t icount;
|
|
|
|
compat_ulong_t ocount;
|
|
|
|
compat_ulong_t ibytes;
|
|
|
|
compat_ulong_t obytes;
|
|
|
|
};
|
|
|
|
|
|
|
|
int ip6mr_compat_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
|
|
|
|
{
|
|
|
|
struct compat_sioc_sg_req6 sr;
|
|
|
|
struct compat_sioc_mif_req6 vr;
|
|
|
|
struct mif_device *vif;
|
|
|
|
struct mfc6_cache *c;
|
|
|
|
struct net *net = sock_net(sk);
|
|
|
|
struct mr6_table *mrt;
|
|
|
|
|
|
|
|
mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
|
|
|
|
if (mrt == NULL)
|
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case SIOCGETMIFCNT_IN6:
|
|
|
|
if (copy_from_user(&vr, arg, sizeof(vr)))
|
|
|
|
return -EFAULT;
|
|
|
|
if (vr.mifi >= mrt->maxvif)
|
|
|
|
return -EINVAL;
|
|
|
|
read_lock(&mrt_lock);
|
|
|
|
vif = &mrt->vif6_table[vr.mifi];
|
|
|
|
if (MIF_EXISTS(mrt, vr.mifi)) {
|
|
|
|
vr.icount = vif->pkt_in;
|
|
|
|
vr.ocount = vif->pkt_out;
|
|
|
|
vr.ibytes = vif->bytes_in;
|
|
|
|
vr.obytes = vif->bytes_out;
|
|
|
|
read_unlock(&mrt_lock);
|
|
|
|
|
|
|
|
if (copy_to_user(arg, &vr, sizeof(vr)))
|
|
|
|
return -EFAULT;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
read_unlock(&mrt_lock);
|
|
|
|
return -EADDRNOTAVAIL;
|
|
|
|
case SIOCGETSGCNT_IN6:
|
|
|
|
if (copy_from_user(&sr, arg, sizeof(sr)))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
read_lock(&mrt_lock);
|
|
|
|
c = ip6mr_cache_find(mrt, &sr.src.sin6_addr, &sr.grp.sin6_addr);
|
|
|
|
if (c) {
|
|
|
|
sr.pktcnt = c->mfc_un.res.pkt;
|
|
|
|
sr.bytecnt = c->mfc_un.res.bytes;
|
|
|
|
sr.wrong_if = c->mfc_un.res.wrong_if;
|
|
|
|
read_unlock(&mrt_lock);
|
|
|
|
|
|
|
|
if (copy_to_user(arg, &sr, sizeof(sr)))
|
|
|
|
return -EFAULT;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
read_unlock(&mrt_lock);
|
|
|
|
return -EADDRNOTAVAIL;
|
|
|
|
default:
|
|
|
|
return -ENOIOCTLCMD;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
2008-04-03 08:22:53 +08:00
|
|
|
|
|
|
|
static inline int ip6mr_forward2_finish(struct sk_buff *skb)
|
|
|
|
{
|
2009-06-02 13:19:30 +08:00
|
|
|
IP6_INC_STATS_BH(dev_net(skb_dst(skb)->dev), ip6_dst_idev(skb_dst(skb)),
|
2008-10-09 02:09:27 +08:00
|
|
|
IPSTATS_MIB_OUTFORWDATAGRAMS);
|
2008-04-03 08:22:53 +08:00
|
|
|
return dst_output(skb);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Processing handlers for ip6mr_forward
|
|
|
|
*/
|
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
static int ip6mr_forward2(struct net *net, struct mr6_table *mrt,
|
|
|
|
struct sk_buff *skb, struct mfc6_cache *c, int vifi)
|
2008-04-03 08:22:53 +08:00
|
|
|
{
|
|
|
|
struct ipv6hdr *ipv6h;
|
2010-05-11 20:40:53 +08:00
|
|
|
struct mif_device *vif = &mrt->vif6_table[vifi];
|
2008-04-03 08:22:53 +08:00
|
|
|
struct net_device *dev;
|
|
|
|
struct dst_entry *dst;
|
2011-03-13 05:22:43 +08:00
|
|
|
struct flowi6 fl6;
|
2008-04-03 08:22:53 +08:00
|
|
|
|
|
|
|
if (vif->dev == NULL)
|
|
|
|
goto out_free;
|
|
|
|
|
2008-04-03 08:22:54 +08:00
|
|
|
#ifdef CONFIG_IPV6_PIMSM_V2
|
|
|
|
if (vif->flags & MIFF_REGISTER) {
|
|
|
|
vif->pkt_out++;
|
|
|
|
vif->bytes_out += skb->len;
|
2008-05-22 05:17:54 +08:00
|
|
|
vif->dev->stats.tx_bytes += skb->len;
|
|
|
|
vif->dev->stats.tx_packets++;
|
2010-05-11 20:40:53 +08:00
|
|
|
ip6mr_cache_report(mrt, skb, vifi, MRT6MSG_WHOLEPKT);
|
2008-12-15 15:15:49 +08:00
|
|
|
goto out_free;
|
2008-04-03 08:22:54 +08:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-04-03 08:22:53 +08:00
|
|
|
ipv6h = ipv6_hdr(skb);
|
|
|
|
|
2011-03-13 05:22:43 +08:00
|
|
|
fl6 = (struct flowi6) {
|
|
|
|
.flowi6_oif = vif->link,
|
|
|
|
.daddr = ipv6h->daddr,
|
2008-04-03 08:22:53 +08:00
|
|
|
};
|
|
|
|
|
2011-03-13 05:22:43 +08:00
|
|
|
dst = ip6_route_output(net, NULL, &fl6);
|
2008-04-03 08:22:53 +08:00
|
|
|
if (!dst)
|
|
|
|
goto out_free;
|
|
|
|
|
2009-06-02 13:19:30 +08:00
|
|
|
skb_dst_drop(skb);
|
|
|
|
skb_dst_set(skb, dst);
|
2008-04-03 08:22:53 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
|
|
|
|
* not only before forwarding, but after forwarding on all output
|
|
|
|
* interfaces. It is clear, if mrouter runs a multicasting
|
|
|
|
* program, it should receive packets not depending to what interface
|
|
|
|
* program is joined.
|
|
|
|
* If we will not make it, the program will have to join on all
|
|
|
|
* interfaces. On the other hand, multihoming host (or router, but
|
|
|
|
* not mrouter) cannot join to more than one interface - it will
|
|
|
|
* result in receiving multiple packets.
|
|
|
|
*/
|
|
|
|
dev = vif->dev;
|
|
|
|
skb->dev = dev;
|
|
|
|
vif->pkt_out++;
|
|
|
|
vif->bytes_out += skb->len;
|
|
|
|
|
|
|
|
/* We are about to write */
|
|
|
|
/* XXX: extension headers? */
|
|
|
|
if (skb_cow(skb, sizeof(*ipv6h) + LL_RESERVED_SPACE(dev)))
|
|
|
|
goto out_free;
|
|
|
|
|
|
|
|
ipv6h = ipv6_hdr(skb);
|
|
|
|
ipv6h->hop_limit--;
|
|
|
|
|
|
|
|
IP6CB(skb)->flags |= IP6SKB_FORWARDED;
|
|
|
|
|
2010-03-23 11:09:07 +08:00
|
|
|
return NF_HOOK(NFPROTO_IPV6, NF_INET_FORWARD, skb, skb->dev, dev,
|
2008-04-03 08:22:53 +08:00
|
|
|
ip6mr_forward2_finish);
|
|
|
|
|
|
|
|
out_free:
|
|
|
|
kfree_skb(skb);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
static int ip6mr_find_vif(struct mr6_table *mrt, struct net_device *dev)
|
2008-04-03 08:22:53 +08:00
|
|
|
{
|
|
|
|
int ct;
|
2010-05-11 20:40:53 +08:00
|
|
|
|
|
|
|
for (ct = mrt->maxvif - 1; ct >= 0; ct--) {
|
|
|
|
if (mrt->vif6_table[ct].dev == dev)
|
2008-04-03 08:22:53 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
return ct;
|
|
|
|
}
|
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
static int ip6_mr_forward(struct net *net, struct mr6_table *mrt,
|
|
|
|
struct sk_buff *skb, struct mfc6_cache *cache)
|
2008-04-03 08:22:53 +08:00
|
|
|
{
|
|
|
|
int psend = -1;
|
|
|
|
int vif, ct;
|
|
|
|
|
|
|
|
vif = cache->mf6c_parent;
|
|
|
|
cache->mfc_un.res.pkt++;
|
|
|
|
cache->mfc_un.res.bytes += skb->len;
|
|
|
|
|
2008-04-03 08:22:54 +08:00
|
|
|
/*
|
|
|
|
* Wrong interface: drop packet and (maybe) send PIM assert.
|
|
|
|
*/
|
2010-05-11 20:40:53 +08:00
|
|
|
if (mrt->vif6_table[vif].dev != skb->dev) {
|
2008-04-03 08:22:54 +08:00
|
|
|
int true_vifi;
|
|
|
|
|
|
|
|
cache->mfc_un.res.wrong_if++;
|
2010-05-11 20:40:53 +08:00
|
|
|
true_vifi = ip6mr_find_vif(mrt, skb->dev);
|
2008-04-03 08:22:54 +08:00
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
if (true_vifi >= 0 && mrt->mroute_do_assert &&
|
2008-04-03 08:22:54 +08:00
|
|
|
/* pimsm uses asserts, when switching from RPT to SPT,
|
|
|
|
so that we cannot check that packet arrived on an oif.
|
|
|
|
It is bad, but otherwise we would need to move pretty
|
|
|
|
large chunk of pimd to kernel. Ough... --ANK
|
|
|
|
*/
|
2010-05-11 20:40:53 +08:00
|
|
|
(mrt->mroute_do_pim ||
|
2008-12-11 08:28:44 +08:00
|
|
|
cache->mfc_un.res.ttls[true_vifi] < 255) &&
|
2008-04-03 08:22:54 +08:00
|
|
|
time_after(jiffies,
|
|
|
|
cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
|
|
|
|
cache->mfc_un.res.last_assert = jiffies;
|
2010-05-11 20:40:53 +08:00
|
|
|
ip6mr_cache_report(mrt, skb, true_vifi, MRT6MSG_WRONGMIF);
|
2008-04-03 08:22:54 +08:00
|
|
|
}
|
|
|
|
goto dont_forward;
|
|
|
|
}
|
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
mrt->vif6_table[vif].pkt_in++;
|
|
|
|
mrt->vif6_table[vif].bytes_in += skb->len;
|
2008-04-03 08:22:53 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Forward the frame
|
|
|
|
*/
|
|
|
|
for (ct = cache->mfc_un.res.maxvif - 1; ct >= cache->mfc_un.res.minvif; ct--) {
|
|
|
|
if (ipv6_hdr(skb)->hop_limit > cache->mfc_un.res.ttls[ct]) {
|
|
|
|
if (psend != -1) {
|
|
|
|
struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
|
|
|
|
if (skb2)
|
2010-05-11 20:40:53 +08:00
|
|
|
ip6mr_forward2(net, mrt, skb2, cache, psend);
|
2008-04-03 08:22:53 +08:00
|
|
|
}
|
|
|
|
psend = ct;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (psend != -1) {
|
2010-05-11 20:40:53 +08:00
|
|
|
ip6mr_forward2(net, mrt, skb, cache, psend);
|
2008-04-03 08:22:53 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-04-03 08:22:54 +08:00
|
|
|
dont_forward:
|
2008-04-03 08:22:53 +08:00
|
|
|
kfree_skb(skb);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Multicast packets for forwarding arrive here
|
|
|
|
*/
|
|
|
|
|
|
|
|
int ip6_mr_input(struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
struct mfc6_cache *cache;
|
2008-12-11 08:30:15 +08:00
|
|
|
struct net *net = dev_net(skb->dev);
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
struct mr6_table *mrt;
|
2011-03-13 05:22:43 +08:00
|
|
|
struct flowi6 fl6 = {
|
|
|
|
.flowi6_iif = skb->dev->ifindex,
|
|
|
|
.flowi6_mark = skb->mark,
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
};
|
|
|
|
int err;
|
|
|
|
|
2011-03-13 05:22:43 +08:00
|
|
|
err = ip6mr_fib_lookup(net, &fl6, &mrt);
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
2008-04-03 08:22:53 +08:00
|
|
|
|
|
|
|
read_lock(&mrt_lock);
|
2010-05-11 20:40:53 +08:00
|
|
|
cache = ip6mr_cache_find(mrt,
|
2008-12-11 08:30:15 +08:00
|
|
|
&ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr);
|
2008-04-03 08:22:53 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* No usable cache entry
|
|
|
|
*/
|
|
|
|
if (cache == NULL) {
|
|
|
|
int vif;
|
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
vif = ip6mr_find_vif(mrt, skb->dev);
|
2008-04-03 08:22:53 +08:00
|
|
|
if (vif >= 0) {
|
2010-05-11 20:40:53 +08:00
|
|
|
int err = ip6mr_cache_unresolved(mrt, vif, skb);
|
2008-04-03 08:22:53 +08:00
|
|
|
read_unlock(&mrt_lock);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
read_unlock(&mrt_lock);
|
|
|
|
kfree_skb(skb);
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
ip6_mr_forward(net, mrt, skb, cache);
|
2008-04-03 08:22:53 +08:00
|
|
|
|
|
|
|
read_unlock(&mrt_lock);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-05-11 20:40:56 +08:00
|
|
|
static int __ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb,
|
|
|
|
struct mfc6_cache *c, struct rtmsg *rtm)
|
2008-04-03 08:22:53 +08:00
|
|
|
{
|
|
|
|
int ct;
|
|
|
|
struct rtnexthop *nhp;
|
2008-04-05 21:17:39 +08:00
|
|
|
u8 *b = skb_tail_pointer(skb);
|
2008-04-03 08:22:53 +08:00
|
|
|
struct rtattr *mp_head;
|
|
|
|
|
2010-03-26 07:45:35 +08:00
|
|
|
/* If cache is unresolved, don't try to parse IIF and OIF */
|
2010-05-26 15:38:56 +08:00
|
|
|
if (c->mf6c_parent >= MAXMIFS)
|
2010-03-26 07:45:35 +08:00
|
|
|
return -ENOENT;
|
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
if (MIF_EXISTS(mrt, c->mf6c_parent))
|
|
|
|
RTA_PUT(skb, RTA_IIF, 4, &mrt->vif6_table[c->mf6c_parent].dev->ifindex);
|
2008-04-03 08:22:53 +08:00
|
|
|
|
|
|
|
mp_head = (struct rtattr *)skb_put(skb, RTA_LENGTH(0));
|
|
|
|
|
|
|
|
for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
|
2010-05-11 20:40:53 +08:00
|
|
|
if (MIF_EXISTS(mrt, ct) && c->mfc_un.res.ttls[ct] < 255) {
|
2008-04-03 08:22:53 +08:00
|
|
|
if (skb_tailroom(skb) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp)) + 4))
|
|
|
|
goto rtattr_failure;
|
|
|
|
nhp = (struct rtnexthop *)skb_put(skb, RTA_ALIGN(sizeof(*nhp)));
|
|
|
|
nhp->rtnh_flags = 0;
|
|
|
|
nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
|
2010-05-11 20:40:53 +08:00
|
|
|
nhp->rtnh_ifindex = mrt->vif6_table[ct].dev->ifindex;
|
2008-04-03 08:22:53 +08:00
|
|
|
nhp->rtnh_len = sizeof(*nhp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mp_head->rta_type = RTA_MULTIPATH;
|
2008-04-05 21:17:39 +08:00
|
|
|
mp_head->rta_len = skb_tail_pointer(skb) - (u8 *)mp_head;
|
2008-04-03 08:22:53 +08:00
|
|
|
rtm->rtm_type = RTN_MULTICAST;
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
rtattr_failure:
|
|
|
|
nlmsg_trim(skb, b);
|
|
|
|
return -EMSGSIZE;
|
|
|
|
}
|
|
|
|
|
2008-12-11 08:30:15 +08:00
|
|
|
int ip6mr_get_route(struct net *net,
|
|
|
|
struct sk_buff *skb, struct rtmsg *rtm, int nowait)
|
2008-04-03 08:22:53 +08:00
|
|
|
{
|
|
|
|
int err;
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
struct mr6_table *mrt;
|
2008-04-03 08:22:53 +08:00
|
|
|
struct mfc6_cache *cache;
|
2009-06-02 13:19:30 +08:00
|
|
|
struct rt6_info *rt = (struct rt6_info *)skb_dst(skb);
|
2008-04-03 08:22:53 +08:00
|
|
|
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 20:40:55 +08:00
|
|
|
mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
|
|
|
|
if (mrt == NULL)
|
|
|
|
return -ENOENT;
|
|
|
|
|
2008-04-03 08:22:53 +08:00
|
|
|
read_lock(&mrt_lock);
|
2010-05-11 20:40:53 +08:00
|
|
|
cache = ip6mr_cache_find(mrt, &rt->rt6i_src.addr, &rt->rt6i_dst.addr);
|
2008-04-03 08:22:53 +08:00
|
|
|
|
|
|
|
if (!cache) {
|
|
|
|
struct sk_buff *skb2;
|
|
|
|
struct ipv6hdr *iph;
|
|
|
|
struct net_device *dev;
|
|
|
|
int vif;
|
|
|
|
|
|
|
|
if (nowait) {
|
|
|
|
read_unlock(&mrt_lock);
|
|
|
|
return -EAGAIN;
|
|
|
|
}
|
|
|
|
|
|
|
|
dev = skb->dev;
|
2010-05-11 20:40:53 +08:00
|
|
|
if (dev == NULL || (vif = ip6mr_find_vif(mrt, dev)) < 0) {
|
2008-04-03 08:22:53 +08:00
|
|
|
read_unlock(&mrt_lock);
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* really correct? */
|
|
|
|
skb2 = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC);
|
|
|
|
if (!skb2) {
|
|
|
|
read_unlock(&mrt_lock);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
skb_reset_transport_header(skb2);
|
|
|
|
|
|
|
|
skb_put(skb2, sizeof(struct ipv6hdr));
|
|
|
|
skb_reset_network_header(skb2);
|
|
|
|
|
|
|
|
iph = ipv6_hdr(skb2);
|
|
|
|
iph->version = 0;
|
|
|
|
iph->priority = 0;
|
|
|
|
iph->flow_lbl[0] = 0;
|
|
|
|
iph->flow_lbl[1] = 0;
|
|
|
|
iph->flow_lbl[2] = 0;
|
|
|
|
iph->payload_len = 0;
|
|
|
|
iph->nexthdr = IPPROTO_NONE;
|
|
|
|
iph->hop_limit = 0;
|
|
|
|
ipv6_addr_copy(&iph->saddr, &rt->rt6i_src.addr);
|
|
|
|
ipv6_addr_copy(&iph->daddr, &rt->rt6i_dst.addr);
|
|
|
|
|
2010-05-11 20:40:53 +08:00
|
|
|
err = ip6mr_cache_unresolved(mrt, vif, skb2);
|
2008-04-03 08:22:53 +08:00
|
|
|
read_unlock(&mrt_lock);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!nowait && (rtm->rtm_flags&RTM_F_NOTIFY))
|
|
|
|
cache->mfc_flags |= MFC_NOTIFY;
|
|
|
|
|
2010-05-11 20:40:56 +08:00
|
|
|
err = __ip6mr_fill_mroute(mrt, skb, cache, rtm);
|
2008-04-03 08:22:53 +08:00
|
|
|
read_unlock(&mrt_lock);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2010-05-11 20:40:56 +08:00
|
|
|
static int ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb,
|
|
|
|
u32 pid, u32 seq, struct mfc6_cache *c)
|
|
|
|
{
|
|
|
|
struct nlmsghdr *nlh;
|
|
|
|
struct rtmsg *rtm;
|
|
|
|
|
|
|
|
nlh = nlmsg_put(skb, pid, seq, RTM_NEWROUTE, sizeof(*rtm), NLM_F_MULTI);
|
|
|
|
if (nlh == NULL)
|
|
|
|
return -EMSGSIZE;
|
|
|
|
|
|
|
|
rtm = nlmsg_data(nlh);
|
|
|
|
rtm->rtm_family = RTNL_FAMILY_IPMR;
|
|
|
|
rtm->rtm_dst_len = 128;
|
|
|
|
rtm->rtm_src_len = 128;
|
|
|
|
rtm->rtm_tos = 0;
|
|
|
|
rtm->rtm_table = mrt->id;
|
|
|
|
NLA_PUT_U32(skb, RTA_TABLE, mrt->id);
|
|
|
|
rtm->rtm_scope = RT_SCOPE_UNIVERSE;
|
|
|
|
rtm->rtm_protocol = RTPROT_UNSPEC;
|
|
|
|
rtm->rtm_flags = 0;
|
|
|
|
|
|
|
|
NLA_PUT(skb, RTA_SRC, 16, &c->mf6c_origin);
|
|
|
|
NLA_PUT(skb, RTA_DST, 16, &c->mf6c_mcastgrp);
|
|
|
|
|
|
|
|
if (__ip6mr_fill_mroute(mrt, skb, c, rtm) < 0)
|
|
|
|
goto nla_put_failure;
|
|
|
|
|
|
|
|
return nlmsg_end(skb, nlh);
|
|
|
|
|
|
|
|
nla_put_failure:
|
|
|
|
nlmsg_cancel(skb, nlh);
|
|
|
|
return -EMSGSIZE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ip6mr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb)
|
|
|
|
{
|
|
|
|
struct net *net = sock_net(skb->sk);
|
|
|
|
struct mr6_table *mrt;
|
|
|
|
struct mfc6_cache *mfc;
|
|
|
|
unsigned int t = 0, s_t;
|
|
|
|
unsigned int h = 0, s_h;
|
|
|
|
unsigned int e = 0, s_e;
|
|
|
|
|
|
|
|
s_t = cb->args[0];
|
|
|
|
s_h = cb->args[1];
|
|
|
|
s_e = cb->args[2];
|
|
|
|
|
|
|
|
read_lock(&mrt_lock);
|
|
|
|
ip6mr_for_each_table(mrt, net) {
|
|
|
|
if (t < s_t)
|
|
|
|
goto next_table;
|
|
|
|
if (t > s_t)
|
|
|
|
s_h = 0;
|
|
|
|
for (h = s_h; h < MFC6_LINES; h++) {
|
|
|
|
list_for_each_entry(mfc, &mrt->mfc6_cache_array[h], list) {
|
|
|
|
if (e < s_e)
|
|
|
|
goto next_entry;
|
|
|
|
if (ip6mr_fill_mroute(mrt, skb,
|
|
|
|
NETLINK_CB(cb->skb).pid,
|
|
|
|
cb->nlh->nlmsg_seq,
|
|
|
|
mfc) < 0)
|
|
|
|
goto done;
|
|
|
|
next_entry:
|
|
|
|
e++;
|
|
|
|
}
|
|
|
|
e = s_e = 0;
|
|
|
|
}
|
|
|
|
s_h = 0;
|
|
|
|
next_table:
|
|
|
|
t++;
|
|
|
|
}
|
|
|
|
done:
|
|
|
|
read_unlock(&mrt_lock);
|
|
|
|
|
|
|
|
cb->args[2] = e;
|
|
|
|
cb->args[1] = h;
|
|
|
|
cb->args[0] = t;
|
|
|
|
|
|
|
|
return skb->len;
|
|
|
|
}
|