blob: 0e004cc42a22b1593fa308f3adac735568ddf2ee [file] [log] [blame]
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001/*
2 * Linux IPv6 multicast routing support for BSD pim6sd
3 * Based on net/ipv4/ipmr.c.
4 *
5 * (c) 2004 Mickael Hoerdt, <hoerdt@clarinet.u-strasbg.fr>
6 * LSIIT Laboratory, Strasbourg, France
7 * (c) 2004 Jean-Philippe Andriot, <jean-philippe.andriot@6WIND.com>
8 * 6WIND, Paris, France
9 * Copyright (C)2007,2008 USAGI/WIDE Project
10 * YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version
15 * 2 of the License, or (at your option) any later version.
16 *
17 */
18
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +090019#include <asm/uaccess.h>
20#include <linux/types.h>
21#include <linux/sched.h>
22#include <linux/errno.h>
23#include <linux/timer.h>
24#include <linux/mm.h>
25#include <linux/kernel.h>
26#include <linux/fcntl.h>
27#include <linux/stat.h>
28#include <linux/socket.h>
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +090029#include <linux/inet.h>
30#include <linux/netdevice.h>
31#include <linux/inetdevice.h>
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +090032#include <linux/proc_fs.h>
33#include <linux/seq_file.h>
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +090034#include <linux/init.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090035#include <linux/slab.h>
David S. Millere2d57762011-02-03 17:59:32 -080036#include <linux/compat.h>
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +090037#include <net/protocol.h>
38#include <linux/skbuff.h>
39#include <net/sock.h>
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +090040#include <net/raw.h>
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +090041#include <linux/notifier.h>
42#include <linux/if_arp.h>
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +090043#include <net/checksum.h>
44#include <net/netlink.h>
Patrick McHardyd1db2752010-05-11 14:40:55 +020045#include <net/fib_rules.h>
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +090046
47#include <net/ipv6.h>
48#include <net/ip6_route.h>
49#include <linux/mroute6.h>
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +090050#include <linux/pim.h>
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +090051#include <net/addrconf.h>
52#include <linux/netfilter_ipv6.h>
Paul Gortmakerbc3b2d72011-07-15 11:47:34 -040053#include <linux/export.h>
Dave Jones5d6e4302009-01-31 00:51:49 -080054#include <net/ip6_checksum.h>
Nicolas Dichteld67b8c62012-12-04 01:13:35 +000055#include <linux/netconf.h>
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +090056
Patrick McHardy6bd52142010-05-11 14:40:53 +020057struct mr6_table {
Patrick McHardyd1db2752010-05-11 14:40:55 +020058 struct list_head list;
Eric W. Biederman0c5c9fb2015-03-11 23:06:44 -050059 possible_net_t net;
Patrick McHardyd1db2752010-05-11 14:40:55 +020060 u32 id;
Patrick McHardy6bd52142010-05-11 14:40:53 +020061 struct sock *mroute6_sk;
62 struct timer_list ipmr_expire_timer;
63 struct list_head mfc6_unres_queue;
64 struct list_head mfc6_cache_array[MFC6_LINES];
65 struct mif_device vif6_table[MAXMIFS];
66 int maxvif;
67 atomic_t cache_resolve_queue_len;
Joe Perches53d68412012-11-25 09:35:30 +000068 bool mroute_do_assert;
69 bool mroute_do_pim;
Patrick McHardy6bd52142010-05-11 14:40:53 +020070#ifdef CONFIG_IPV6_PIMSM_V2
71 int mroute_reg_vif_num;
72#endif
73};
74
Patrick McHardyd1db2752010-05-11 14:40:55 +020075struct ip6mr_rule {
76 struct fib_rule common;
77};
78
79struct ip6mr_result {
80 struct mr6_table *mrt;
81};
82
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +090083/* Big lock, protecting vif table, mrt cache and mroute socket state.
84 Note that the changes are semaphored via rtnl_lock.
85 */
86
87static DEFINE_RWLOCK(mrt_lock);
88
89/*
90 * Multicast router control variables
91 */
92
Patrick McHardy6bd52142010-05-11 14:40:53 +020093#define MIF_EXISTS(_mrt, _idx) ((_mrt)->vif6_table[_idx].dev != NULL)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +090094
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +090095/* Special spinlock for queue of unresolved entries */
96static DEFINE_SPINLOCK(mfc_unres_lock);
97
98/* We return to original Alan's scheme. Hash table of resolved
99 entries is changed only in process context and protected
100 with weak lock mrt_lock. Queue of unresolved entries is protected
101 with strong spinlock mfc_unres_lock.
102
103 In this case data path is free of exclusive locks at all.
104 */
105
106static struct kmem_cache *mrt_cachep __read_mostly;
107
Patrick McHardyd1db2752010-05-11 14:40:55 +0200108static struct mr6_table *ip6mr_new_table(struct net *net, u32 id);
109static void ip6mr_free_table(struct mr6_table *mrt);
110
Rami Rosen2b52c3a2013-07-21 03:00:31 +0300111static void ip6_mr_forward(struct net *net, struct mr6_table *mrt,
112 struct sk_buff *skb, struct mfc6_cache *cache);
Patrick McHardy6bd52142010-05-11 14:40:53 +0200113static int ip6mr_cache_report(struct mr6_table *mrt, struct sk_buff *pkt,
Benjamin Thery8229efd2008-12-10 16:30:15 -0800114 mifi_t mifi, int assert);
Patrick McHardy5b285ca2010-05-11 14:40:56 +0200115static int __ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb,
116 struct mfc6_cache *c, struct rtmsg *rtm);
Nicolas Dichtel812e44d2012-12-04 01:13:41 +0000117static void mr6_netlink_event(struct mr6_table *mrt, struct mfc6_cache *mfc,
118 int cmd);
Patrick McHardy5b285ca2010-05-11 14:40:56 +0200119static int ip6mr_rtm_dumproute(struct sk_buff *skb,
120 struct netlink_callback *cb);
Patrick McHardy6bd52142010-05-11 14:40:53 +0200121static void mroute_clean_tables(struct mr6_table *mrt);
Patrick McHardyd1db2752010-05-11 14:40:55 +0200122static void ipmr_expire_process(unsigned long arg);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900123
Patrick McHardyd1db2752010-05-11 14:40:55 +0200124#ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
Eric Dumazet8ffb3352010-06-06 15:34:40 -0700125#define ip6mr_for_each_table(mrt, net) \
Patrick McHardyd1db2752010-05-11 14:40:55 +0200126 list_for_each_entry_rcu(mrt, &net->ipv6.mr6_tables, list)
127
128static struct mr6_table *ip6mr_get_table(struct net *net, u32 id)
129{
130 struct mr6_table *mrt;
131
132 ip6mr_for_each_table(mrt, net) {
133 if (mrt->id == id)
134 return mrt;
135 }
136 return NULL;
137}
138
David S. Miller4c9483b2011-03-12 16:22:43 -0500139static int ip6mr_fib_lookup(struct net *net, struct flowi6 *flp6,
Patrick McHardyd1db2752010-05-11 14:40:55 +0200140 struct mr6_table **mrt)
141{
Patrick McHardyd1db2752010-05-11 14:40:55 +0200142 int err;
Hannes Frederic Sowa95f4a452014-01-13 02:45:22 +0100143 struct ip6mr_result res;
144 struct fib_lookup_arg arg = {
145 .result = &res,
146 .flags = FIB_LOOKUP_NOREF,
147 };
Patrick McHardyd1db2752010-05-11 14:40:55 +0200148
David S. Miller4c9483b2011-03-12 16:22:43 -0500149 err = fib_rules_lookup(net->ipv6.mr6_rules_ops,
150 flowi6_to_flowi(flp6), 0, &arg);
Patrick McHardyd1db2752010-05-11 14:40:55 +0200151 if (err < 0)
152 return err;
153 *mrt = res.mrt;
154 return 0;
155}
156
157static int ip6mr_rule_action(struct fib_rule *rule, struct flowi *flp,
158 int flags, struct fib_lookup_arg *arg)
159{
160 struct ip6mr_result *res = arg->result;
161 struct mr6_table *mrt;
162
163 switch (rule->action) {
164 case FR_ACT_TO_TBL:
165 break;
166 case FR_ACT_UNREACHABLE:
167 return -ENETUNREACH;
168 case FR_ACT_PROHIBIT:
169 return -EACCES;
170 case FR_ACT_BLACKHOLE:
171 default:
172 return -EINVAL;
173 }
174
175 mrt = ip6mr_get_table(rule->fr_net, rule->table);
Ian Morris63159f22015-03-29 14:00:04 +0100176 if (!mrt)
Patrick McHardyd1db2752010-05-11 14:40:55 +0200177 return -EAGAIN;
178 res->mrt = mrt;
179 return 0;
180}
181
182static int ip6mr_rule_match(struct fib_rule *rule, struct flowi *flp, int flags)
183{
184 return 1;
185}
186
187static const struct nla_policy ip6mr_rule_policy[FRA_MAX + 1] = {
188 FRA_GENERIC_POLICY,
189};
190
191static int ip6mr_rule_configure(struct fib_rule *rule, struct sk_buff *skb,
192 struct fib_rule_hdr *frh, struct nlattr **tb)
193{
194 return 0;
195}
196
197static int ip6mr_rule_compare(struct fib_rule *rule, struct fib_rule_hdr *frh,
198 struct nlattr **tb)
199{
200 return 1;
201}
202
203static int ip6mr_rule_fill(struct fib_rule *rule, struct sk_buff *skb,
204 struct fib_rule_hdr *frh)
205{
206 frh->dst_len = 0;
207 frh->src_len = 0;
208 frh->tos = 0;
209 return 0;
210}
211
Andi Kleen04a6f822012-10-04 17:12:11 -0700212static const struct fib_rules_ops __net_initconst ip6mr_rules_ops_template = {
Patrick McHardyd1db2752010-05-11 14:40:55 +0200213 .family = RTNL_FAMILY_IP6MR,
214 .rule_size = sizeof(struct ip6mr_rule),
215 .addr_size = sizeof(struct in6_addr),
216 .action = ip6mr_rule_action,
217 .match = ip6mr_rule_match,
218 .configure = ip6mr_rule_configure,
219 .compare = ip6mr_rule_compare,
Patrick McHardyd1db2752010-05-11 14:40:55 +0200220 .fill = ip6mr_rule_fill,
221 .nlgroup = RTNLGRP_IPV6_RULE,
222 .policy = ip6mr_rule_policy,
223 .owner = THIS_MODULE,
224};
225
226static int __net_init ip6mr_rules_init(struct net *net)
227{
228 struct fib_rules_ops *ops;
229 struct mr6_table *mrt;
230 int err;
231
232 ops = fib_rules_register(&ip6mr_rules_ops_template, net);
233 if (IS_ERR(ops))
234 return PTR_ERR(ops);
235
236 INIT_LIST_HEAD(&net->ipv6.mr6_tables);
237
238 mrt = ip6mr_new_table(net, RT6_TABLE_DFLT);
Ian Morris63159f22015-03-29 14:00:04 +0100239 if (!mrt) {
Patrick McHardyd1db2752010-05-11 14:40:55 +0200240 err = -ENOMEM;
241 goto err1;
242 }
243
244 err = fib_default_rule_add(ops, 0x7fff, RT6_TABLE_DFLT, 0);
245 if (err < 0)
246 goto err2;
247
248 net->ipv6.mr6_rules_ops = ops;
249 return 0;
250
251err2:
WANG Congf243e5a2015-03-25 14:45:03 -0700252 ip6mr_free_table(mrt);
Patrick McHardyd1db2752010-05-11 14:40:55 +0200253err1:
254 fib_rules_unregister(ops);
255 return err;
256}
257
258static void __net_exit ip6mr_rules_exit(struct net *net)
259{
260 struct mr6_table *mrt, *next;
261
Hannes Frederic Sowa905a6f92013-07-22 23:45:53 +0200262 rtnl_lock();
Eric Dumazet035320d2010-06-06 23:48:40 +0000263 list_for_each_entry_safe(mrt, next, &net->ipv6.mr6_tables, list) {
264 list_del(&mrt->list);
Patrick McHardyd1db2752010-05-11 14:40:55 +0200265 ip6mr_free_table(mrt);
Eric Dumazet035320d2010-06-06 23:48:40 +0000266 }
Patrick McHardyd1db2752010-05-11 14:40:55 +0200267 fib_rules_unregister(net->ipv6.mr6_rules_ops);
WANG Cong419df122015-03-31 11:01:46 -0700268 rtnl_unlock();
Patrick McHardyd1db2752010-05-11 14:40:55 +0200269}
270#else
271#define ip6mr_for_each_table(mrt, net) \
272 for (mrt = net->ipv6.mrt6; mrt; mrt = NULL)
273
274static struct mr6_table *ip6mr_get_table(struct net *net, u32 id)
275{
276 return net->ipv6.mrt6;
277}
278
David S. Miller4c9483b2011-03-12 16:22:43 -0500279static int ip6mr_fib_lookup(struct net *net, struct flowi6 *flp6,
Patrick McHardyd1db2752010-05-11 14:40:55 +0200280 struct mr6_table **mrt)
281{
282 *mrt = net->ipv6.mrt6;
283 return 0;
284}
285
286static int __net_init ip6mr_rules_init(struct net *net)
287{
288 net->ipv6.mrt6 = ip6mr_new_table(net, RT6_TABLE_DFLT);
289 return net->ipv6.mrt6 ? 0 : -ENOMEM;
290}
291
292static void __net_exit ip6mr_rules_exit(struct net *net)
293{
Hannes Frederic Sowa905a6f92013-07-22 23:45:53 +0200294 rtnl_lock();
Patrick McHardyd1db2752010-05-11 14:40:55 +0200295 ip6mr_free_table(net->ipv6.mrt6);
Hannes Frederic Sowa905a6f92013-07-22 23:45:53 +0200296 net->ipv6.mrt6 = NULL;
297 rtnl_unlock();
Patrick McHardyd1db2752010-05-11 14:40:55 +0200298}
299#endif
300
301static struct mr6_table *ip6mr_new_table(struct net *net, u32 id)
302{
303 struct mr6_table *mrt;
304 unsigned int i;
305
306 mrt = ip6mr_get_table(net, id);
Ian Morris53b24b82015-03-29 14:00:05 +0100307 if (mrt)
Patrick McHardyd1db2752010-05-11 14:40:55 +0200308 return mrt;
309
310 mrt = kzalloc(sizeof(*mrt), GFP_KERNEL);
Ian Morris63159f22015-03-29 14:00:04 +0100311 if (!mrt)
Patrick McHardyd1db2752010-05-11 14:40:55 +0200312 return NULL;
313 mrt->id = id;
314 write_pnet(&mrt->net, net);
315
316 /* Forwarding cache */
317 for (i = 0; i < MFC6_LINES; i++)
318 INIT_LIST_HEAD(&mrt->mfc6_cache_array[i]);
319
320 INIT_LIST_HEAD(&mrt->mfc6_unres_queue);
321
322 setup_timer(&mrt->ipmr_expire_timer, ipmr_expire_process,
323 (unsigned long)mrt);
324
325#ifdef CONFIG_IPV6_PIMSM_V2
326 mrt->mroute_reg_vif_num = -1;
327#endif
328#ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
329 list_add_tail_rcu(&mrt->list, &net->ipv6.mr6_tables);
330#endif
331 return mrt;
332}
333
334static void ip6mr_free_table(struct mr6_table *mrt)
335{
WANG Cong7ba0c472015-03-31 11:01:47 -0700336 del_timer_sync(&mrt->ipmr_expire_timer);
Patrick McHardyd1db2752010-05-11 14:40:55 +0200337 mroute_clean_tables(mrt);
338 kfree(mrt);
339}
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900340
341#ifdef CONFIG_PROC_FS
342
343struct ipmr_mfc_iter {
Benjamin Thery8b90fc72008-12-10 16:29:48 -0800344 struct seq_net_private p;
Patrick McHardyd1db2752010-05-11 14:40:55 +0200345 struct mr6_table *mrt;
Patrick McHardyf30a77842010-05-11 14:40:51 +0200346 struct list_head *cache;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900347 int ct;
348};
349
350
Benjamin Thery8b90fc72008-12-10 16:29:48 -0800351static struct mfc6_cache *ipmr_mfc_seq_idx(struct net *net,
352 struct ipmr_mfc_iter *it, loff_t pos)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900353{
Patrick McHardyd1db2752010-05-11 14:40:55 +0200354 struct mr6_table *mrt = it->mrt;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900355 struct mfc6_cache *mfc;
356
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900357 read_lock(&mrt_lock);
Patrick McHardyf30a77842010-05-11 14:40:51 +0200358 for (it->ct = 0; it->ct < MFC6_LINES; it->ct++) {
Patrick McHardy6bd52142010-05-11 14:40:53 +0200359 it->cache = &mrt->mfc6_cache_array[it->ct];
Patrick McHardyf30a77842010-05-11 14:40:51 +0200360 list_for_each_entry(mfc, it->cache, list)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900361 if (pos-- == 0)
362 return mfc;
Patrick McHardyf30a77842010-05-11 14:40:51 +0200363 }
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900364 read_unlock(&mrt_lock);
365
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900366 spin_lock_bh(&mfc_unres_lock);
Patrick McHardy6bd52142010-05-11 14:40:53 +0200367 it->cache = &mrt->mfc6_unres_queue;
Patrick McHardyf30a77842010-05-11 14:40:51 +0200368 list_for_each_entry(mfc, it->cache, list)
Patrick McHardyc476efb2010-05-11 14:40:48 +0200369 if (pos-- == 0)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900370 return mfc;
371 spin_unlock_bh(&mfc_unres_lock);
372
373 it->cache = NULL;
374 return NULL;
375}
376
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900377/*
378 * The /proc interfaces to multicast routing /proc/ip6_mr_cache /proc/ip6_mr_vif
379 */
380
381struct ipmr_vif_iter {
Benjamin Thery8b90fc72008-12-10 16:29:48 -0800382 struct seq_net_private p;
Patrick McHardyd1db2752010-05-11 14:40:55 +0200383 struct mr6_table *mrt;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900384 int ct;
385};
386
Benjamin Thery8b90fc72008-12-10 16:29:48 -0800387static struct mif_device *ip6mr_vif_seq_idx(struct net *net,
388 struct ipmr_vif_iter *iter,
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900389 loff_t pos)
390{
Patrick McHardyd1db2752010-05-11 14:40:55 +0200391 struct mr6_table *mrt = iter->mrt;
Patrick McHardy6bd52142010-05-11 14:40:53 +0200392
393 for (iter->ct = 0; iter->ct < mrt->maxvif; ++iter->ct) {
394 if (!MIF_EXISTS(mrt, iter->ct))
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900395 continue;
396 if (pos-- == 0)
Patrick McHardy6bd52142010-05-11 14:40:53 +0200397 return &mrt->vif6_table[iter->ct];
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900398 }
399 return NULL;
400}
401
402static void *ip6mr_vif_seq_start(struct seq_file *seq, loff_t *pos)
403 __acquires(mrt_lock)
404{
Patrick McHardyd1db2752010-05-11 14:40:55 +0200405 struct ipmr_vif_iter *iter = seq->private;
Benjamin Thery8b90fc72008-12-10 16:29:48 -0800406 struct net *net = seq_file_net(seq);
Patrick McHardyd1db2752010-05-11 14:40:55 +0200407 struct mr6_table *mrt;
408
409 mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
Ian Morris63159f22015-03-29 14:00:04 +0100410 if (!mrt)
Patrick McHardyd1db2752010-05-11 14:40:55 +0200411 return ERR_PTR(-ENOENT);
412
413 iter->mrt = mrt;
Benjamin Thery8b90fc72008-12-10 16:29:48 -0800414
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900415 read_lock(&mrt_lock);
Benjamin Thery8b90fc72008-12-10 16:29:48 -0800416 return *pos ? ip6mr_vif_seq_idx(net, seq->private, *pos - 1)
417 : SEQ_START_TOKEN;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900418}
419
420static void *ip6mr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos)
421{
422 struct ipmr_vif_iter *iter = seq->private;
Benjamin Thery8b90fc72008-12-10 16:29:48 -0800423 struct net *net = seq_file_net(seq);
Patrick McHardyd1db2752010-05-11 14:40:55 +0200424 struct mr6_table *mrt = iter->mrt;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900425
426 ++*pos;
427 if (v == SEQ_START_TOKEN)
Benjamin Thery8b90fc72008-12-10 16:29:48 -0800428 return ip6mr_vif_seq_idx(net, iter, 0);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900429
Patrick McHardy6bd52142010-05-11 14:40:53 +0200430 while (++iter->ct < mrt->maxvif) {
431 if (!MIF_EXISTS(mrt, iter->ct))
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900432 continue;
Patrick McHardy6bd52142010-05-11 14:40:53 +0200433 return &mrt->vif6_table[iter->ct];
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900434 }
435 return NULL;
436}
437
438static void ip6mr_vif_seq_stop(struct seq_file *seq, void *v)
439 __releases(mrt_lock)
440{
441 read_unlock(&mrt_lock);
442}
443
444static int ip6mr_vif_seq_show(struct seq_file *seq, void *v)
445{
Patrick McHardyd1db2752010-05-11 14:40:55 +0200446 struct ipmr_vif_iter *iter = seq->private;
447 struct mr6_table *mrt = iter->mrt;
Benjamin Thery8b90fc72008-12-10 16:29:48 -0800448
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900449 if (v == SEQ_START_TOKEN) {
450 seq_puts(seq,
451 "Interface BytesIn PktsIn BytesOut PktsOut Flags\n");
452 } else {
453 const struct mif_device *vif = v;
454 const char *name = vif->dev ? vif->dev->name : "none";
455
456 seq_printf(seq,
Al Virod430a222008-06-02 10:59:02 +0100457 "%2td %-10s %8ld %7ld %8ld %7ld %05X\n",
Patrick McHardy6bd52142010-05-11 14:40:53 +0200458 vif - mrt->vif6_table,
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900459 name, vif->bytes_in, vif->pkt_in,
460 vif->bytes_out, vif->pkt_out,
461 vif->flags);
462 }
463 return 0;
464}
465
Stephen Hemminger98147d52009-09-01 19:25:02 +0000466static const struct seq_operations ip6mr_vif_seq_ops = {
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900467 .start = ip6mr_vif_seq_start,
468 .next = ip6mr_vif_seq_next,
469 .stop = ip6mr_vif_seq_stop,
470 .show = ip6mr_vif_seq_show,
471};
472
473static int ip6mr_vif_open(struct inode *inode, struct file *file)
474{
Benjamin Thery8b90fc72008-12-10 16:29:48 -0800475 return seq_open_net(inode, file, &ip6mr_vif_seq_ops,
476 sizeof(struct ipmr_vif_iter));
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900477}
478
Stephen Hemminger5ca1b992009-09-01 19:25:05 +0000479static const struct file_operations ip6mr_vif_fops = {
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900480 .owner = THIS_MODULE,
481 .open = ip6mr_vif_open,
482 .read = seq_read,
483 .llseek = seq_lseek,
Benjamin Thery8b90fc72008-12-10 16:29:48 -0800484 .release = seq_release_net,
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900485};
486
487static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
488{
Patrick McHardyd1db2752010-05-11 14:40:55 +0200489 struct ipmr_mfc_iter *it = seq->private;
Benjamin Thery8b90fc72008-12-10 16:29:48 -0800490 struct net *net = seq_file_net(seq);
Patrick McHardyd1db2752010-05-11 14:40:55 +0200491 struct mr6_table *mrt;
Benjamin Thery8b90fc72008-12-10 16:29:48 -0800492
Patrick McHardyd1db2752010-05-11 14:40:55 +0200493 mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
Ian Morris63159f22015-03-29 14:00:04 +0100494 if (!mrt)
Patrick McHardyd1db2752010-05-11 14:40:55 +0200495 return ERR_PTR(-ENOENT);
496
497 it->mrt = mrt;
Benjamin Thery8b90fc72008-12-10 16:29:48 -0800498 return *pos ? ipmr_mfc_seq_idx(net, seq->private, *pos - 1)
499 : SEQ_START_TOKEN;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900500}
501
502static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
503{
504 struct mfc6_cache *mfc = v;
505 struct ipmr_mfc_iter *it = seq->private;
Benjamin Thery8b90fc72008-12-10 16:29:48 -0800506 struct net *net = seq_file_net(seq);
Patrick McHardyd1db2752010-05-11 14:40:55 +0200507 struct mr6_table *mrt = it->mrt;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900508
509 ++*pos;
510
511 if (v == SEQ_START_TOKEN)
Benjamin Thery8b90fc72008-12-10 16:29:48 -0800512 return ipmr_mfc_seq_idx(net, seq->private, 0);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900513
Patrick McHardyf30a77842010-05-11 14:40:51 +0200514 if (mfc->list.next != it->cache)
515 return list_entry(mfc->list.next, struct mfc6_cache, list);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900516
Patrick McHardy6bd52142010-05-11 14:40:53 +0200517 if (it->cache == &mrt->mfc6_unres_queue)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900518 goto end_of_list;
519
Patrick McHardy6bd52142010-05-11 14:40:53 +0200520 BUG_ON(it->cache != &mrt->mfc6_cache_array[it->ct]);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900521
Benjamin Thery4a6258a2008-12-10 16:24:07 -0800522 while (++it->ct < MFC6_LINES) {
Patrick McHardy6bd52142010-05-11 14:40:53 +0200523 it->cache = &mrt->mfc6_cache_array[it->ct];
Patrick McHardyf30a77842010-05-11 14:40:51 +0200524 if (list_empty(it->cache))
525 continue;
526 return list_first_entry(it->cache, struct mfc6_cache, list);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900527 }
528
529 /* exhausted cache_array, show unresolved */
530 read_unlock(&mrt_lock);
Patrick McHardy6bd52142010-05-11 14:40:53 +0200531 it->cache = &mrt->mfc6_unres_queue;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900532 it->ct = 0;
533
534 spin_lock_bh(&mfc_unres_lock);
Patrick McHardyf30a77842010-05-11 14:40:51 +0200535 if (!list_empty(it->cache))
536 return list_first_entry(it->cache, struct mfc6_cache, list);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900537
538 end_of_list:
539 spin_unlock_bh(&mfc_unres_lock);
540 it->cache = NULL;
541
542 return NULL;
543}
544
545static void ipmr_mfc_seq_stop(struct seq_file *seq, void *v)
546{
547 struct ipmr_mfc_iter *it = seq->private;
Patrick McHardyd1db2752010-05-11 14:40:55 +0200548 struct mr6_table *mrt = it->mrt;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900549
Patrick McHardy6bd52142010-05-11 14:40:53 +0200550 if (it->cache == &mrt->mfc6_unres_queue)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900551 spin_unlock_bh(&mfc_unres_lock);
Richard Laing25b4a442015-09-03 13:52:31 +1200552 else if (it->cache == &mrt->mfc6_cache_array[it->ct])
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900553 read_unlock(&mrt_lock);
554}
555
556static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
557{
558 int n;
559
560 if (v == SEQ_START_TOKEN) {
561 seq_puts(seq,
562 "Group "
563 "Origin "
564 "Iif Pkts Bytes Wrong Oifs\n");
565 } else {
566 const struct mfc6_cache *mfc = v;
567 const struct ipmr_mfc_iter *it = seq->private;
Patrick McHardyd1db2752010-05-11 14:40:55 +0200568 struct mr6_table *mrt = it->mrt;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900569
Benjamin Thery999890b2008-12-03 22:22:16 -0800570 seq_printf(seq, "%pI6 %pI6 %-3hd",
Harvey Harrison0c6ce782008-10-28 16:09:23 -0700571 &mfc->mf6c_mcastgrp, &mfc->mf6c_origin,
Benjamin Thery1ea472e2008-12-03 22:21:47 -0800572 mfc->mf6c_parent);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900573
Patrick McHardy6bd52142010-05-11 14:40:53 +0200574 if (it->cache != &mrt->mfc6_unres_queue) {
Benjamin Thery1ea472e2008-12-03 22:21:47 -0800575 seq_printf(seq, " %8lu %8lu %8lu",
576 mfc->mfc_un.res.pkt,
577 mfc->mfc_un.res.bytes,
578 mfc->mfc_un.res.wrong_if);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900579 for (n = mfc->mfc_un.res.minvif;
580 n < mfc->mfc_un.res.maxvif; n++) {
Patrick McHardy6bd52142010-05-11 14:40:53 +0200581 if (MIF_EXISTS(mrt, n) &&
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900582 mfc->mfc_un.res.ttls[n] < 255)
583 seq_printf(seq,
584 " %2d:%-3d",
585 n, mfc->mfc_un.res.ttls[n]);
586 }
Benjamin Thery1ea472e2008-12-03 22:21:47 -0800587 } else {
588 /* unresolved mfc_caches don't contain
589 * pkt, bytes and wrong_if values
590 */
591 seq_printf(seq, " %8lu %8lu %8lu", 0ul, 0ul, 0ul);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900592 }
593 seq_putc(seq, '\n');
594 }
595 return 0;
596}
597
James Morris88e9d342009-09-22 16:43:43 -0700598static const struct seq_operations ipmr_mfc_seq_ops = {
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900599 .start = ipmr_mfc_seq_start,
600 .next = ipmr_mfc_seq_next,
601 .stop = ipmr_mfc_seq_stop,
602 .show = ipmr_mfc_seq_show,
603};
604
605static int ipmr_mfc_open(struct inode *inode, struct file *file)
606{
Benjamin Thery8b90fc72008-12-10 16:29:48 -0800607 return seq_open_net(inode, file, &ipmr_mfc_seq_ops,
608 sizeof(struct ipmr_mfc_iter));
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900609}
610
Stephen Hemminger5ca1b992009-09-01 19:25:05 +0000611static const struct file_operations ip6mr_mfc_fops = {
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900612 .owner = THIS_MODULE,
613 .open = ipmr_mfc_open,
614 .read = seq_read,
615 .llseek = seq_lseek,
Benjamin Thery8b90fc72008-12-10 16:29:48 -0800616 .release = seq_release_net,
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900617};
618#endif
619
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +0900620#ifdef CONFIG_IPV6_PIMSM_V2
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +0900621
622static int pim6_rcv(struct sk_buff *skb)
623{
624 struct pimreghdr *pim;
625 struct ipv6hdr *encap;
626 struct net_device *reg_dev = NULL;
Benjamin Thery8229efd2008-12-10 16:30:15 -0800627 struct net *net = dev_net(skb->dev);
Patrick McHardyd1db2752010-05-11 14:40:55 +0200628 struct mr6_table *mrt;
David S. Miller4c9483b2011-03-12 16:22:43 -0500629 struct flowi6 fl6 = {
630 .flowi6_iif = skb->dev->ifindex,
631 .flowi6_mark = skb->mark,
Patrick McHardyd1db2752010-05-11 14:40:55 +0200632 };
633 int reg_vif_num;
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +0900634
635 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
636 goto drop;
637
638 pim = (struct pimreghdr *)skb_transport_header(skb);
639 if (pim->type != ((PIM_VERSION << 4) | PIM_REGISTER) ||
640 (pim->flags & PIM_NULL_REGISTER) ||
Thomas Goff1d6e55f2009-01-27 22:39:59 -0800641 (csum_ipv6_magic(&ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr,
642 sizeof(*pim), IPPROTO_PIM,
643 csum_partial((void *)pim, sizeof(*pim), 0)) &&
Al Viroec6b4862008-04-26 22:28:58 -0700644 csum_fold(skb_checksum(skb, 0, skb->len, 0))))
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +0900645 goto drop;
646
647 /* check if the inner packet is destined to mcast group */
648 encap = (struct ipv6hdr *)(skb_transport_header(skb) +
649 sizeof(*pim));
650
651 if (!ipv6_addr_is_multicast(&encap->daddr) ||
652 encap->payload_len == 0 ||
653 ntohs(encap->payload_len) + sizeof(*pim) > skb->len)
654 goto drop;
655
David S. Miller4c9483b2011-03-12 16:22:43 -0500656 if (ip6mr_fib_lookup(net, &fl6, &mrt) < 0)
Patrick McHardyd1db2752010-05-11 14:40:55 +0200657 goto drop;
658 reg_vif_num = mrt->mroute_reg_vif_num;
659
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +0900660 read_lock(&mrt_lock);
661 if (reg_vif_num >= 0)
Patrick McHardy6bd52142010-05-11 14:40:53 +0200662 reg_dev = mrt->vif6_table[reg_vif_num].dev;
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +0900663 if (reg_dev)
664 dev_hold(reg_dev);
665 read_unlock(&mrt_lock);
666
Ian Morris63159f22015-03-29 14:00:04 +0100667 if (!reg_dev)
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +0900668 goto drop;
669
670 skb->mac_header = skb->network_header;
671 skb_pull(skb, (u8 *)encap - skb->data);
672 skb_reset_network_header(skb);
Thomas Goff1d6e55f2009-01-27 22:39:59 -0800673 skb->protocol = htons(ETH_P_IPV6);
Cesar Eduardo Barros3e49e6d2011-03-26 05:10:30 +0000674 skb->ip_summed = CHECKSUM_NONE;
Eric Dumazetd19d56d2010-05-17 22:36:55 -0700675
Nicolas Dichtelea231922013-09-02 15:34:58 +0200676 skb_tunnel_rx(skb, reg_dev, dev_net(reg_dev));
Eric Dumazetd19d56d2010-05-17 22:36:55 -0700677
Eric Dumazetcaf586e2010-09-30 21:06:55 +0000678 netif_rx(skb);
Eric Dumazet8990f462010-09-20 00:12:11 +0000679
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +0900680 dev_put(reg_dev);
681 return 0;
682 drop:
683 kfree_skb(skb);
684 return 0;
685}
686
Alexey Dobriyan41135cc2009-09-14 12:22:28 +0000687static const struct inet6_protocol pim6_protocol = {
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +0900688 .handler = pim6_rcv,
689};
690
691/* Service routines creating virtual interfaces: PIMREG */
692
Stephen Hemminger6fef4c02009-08-31 19:50:41 +0000693static netdev_tx_t reg_vif_xmit(struct sk_buff *skb,
694 struct net_device *dev)
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +0900695{
Benjamin Thery8229efd2008-12-10 16:30:15 -0800696 struct net *net = dev_net(dev);
Patrick McHardyd1db2752010-05-11 14:40:55 +0200697 struct mr6_table *mrt;
David S. Miller4c9483b2011-03-12 16:22:43 -0500698 struct flowi6 fl6 = {
699 .flowi6_oif = dev->ifindex,
Cong Wang6a662712014-04-15 16:25:34 -0700700 .flowi6_iif = skb->skb_iif ? : LOOPBACK_IFINDEX,
David S. Miller4c9483b2011-03-12 16:22:43 -0500701 .flowi6_mark = skb->mark,
Patrick McHardyd1db2752010-05-11 14:40:55 +0200702 };
703 int err;
704
David S. Miller4c9483b2011-03-12 16:22:43 -0500705 err = ip6mr_fib_lookup(net, &fl6, &mrt);
Ben Greear67928c42011-09-23 13:11:01 +0000706 if (err < 0) {
707 kfree_skb(skb);
Patrick McHardyd1db2752010-05-11 14:40:55 +0200708 return err;
Ben Greear67928c42011-09-23 13:11:01 +0000709 }
Benjamin Thery8229efd2008-12-10 16:30:15 -0800710
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +0900711 read_lock(&mrt_lock);
Pavel Emelyanovdc58c782008-05-21 14:17:54 -0700712 dev->stats.tx_bytes += skb->len;
713 dev->stats.tx_packets++;
Patrick McHardy6bd52142010-05-11 14:40:53 +0200714 ip6mr_cache_report(mrt, skb, mrt->mroute_reg_vif_num, MRT6MSG_WHOLEPKT);
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +0900715 read_unlock(&mrt_lock);
716 kfree_skb(skb);
Patrick McHardy6ed10652009-06-23 06:03:08 +0000717 return NETDEV_TX_OK;
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +0900718}
719
Nicolas Dichtelee9b9592015-04-02 17:07:03 +0200720static int reg_vif_get_iflink(const struct net_device *dev)
721{
722 return 0;
723}
724
Stephen Hemminger007c3832008-11-20 20:28:35 -0800725static const struct net_device_ops reg_vif_netdev_ops = {
726 .ndo_start_xmit = reg_vif_xmit,
Nicolas Dichtelee9b9592015-04-02 17:07:03 +0200727 .ndo_get_iflink = reg_vif_get_iflink,
Stephen Hemminger007c3832008-11-20 20:28:35 -0800728};
729
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +0900730static void reg_vif_setup(struct net_device *dev)
731{
732 dev->type = ARPHRD_PIMREG;
733 dev->mtu = 1500 - sizeof(struct ipv6hdr) - 8;
734 dev->flags = IFF_NOARP;
Stephen Hemminger007c3832008-11-20 20:28:35 -0800735 dev->netdev_ops = &reg_vif_netdev_ops;
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +0900736 dev->destructor = free_netdev;
Tom Goff403dbb92009-06-14 03:16:13 -0700737 dev->features |= NETIF_F_NETNS_LOCAL;
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +0900738}
739
Patrick McHardyd1db2752010-05-11 14:40:55 +0200740static struct net_device *ip6mr_reg_vif(struct net *net, struct mr6_table *mrt)
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +0900741{
742 struct net_device *dev;
Patrick McHardyd1db2752010-05-11 14:40:55 +0200743 char name[IFNAMSIZ];
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +0900744
Patrick McHardyd1db2752010-05-11 14:40:55 +0200745 if (mrt->id == RT6_TABLE_DFLT)
746 sprintf(name, "pim6reg");
747 else
748 sprintf(name, "pim6reg%u", mrt->id);
749
Tom Gundersenc835a672014-07-14 16:37:24 +0200750 dev = alloc_netdev(0, name, NET_NAME_UNKNOWN, reg_vif_setup);
Ian Morris63159f22015-03-29 14:00:04 +0100751 if (!dev)
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +0900752 return NULL;
753
Benjamin Thery8229efd2008-12-10 16:30:15 -0800754 dev_net_set(dev, net);
755
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +0900756 if (register_netdevice(dev)) {
757 free_netdev(dev);
758 return NULL;
759 }
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +0900760
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +0900761 if (dev_open(dev))
762 goto failure;
763
Wang Chen7af3db72008-07-14 20:54:54 -0700764 dev_hold(dev);
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +0900765 return dev;
766
767failure:
768 /* allow the register to be completed before unregistering. */
769 rtnl_unlock();
770 rtnl_lock();
771
772 unregister_netdevice(dev);
773 return NULL;
774}
775#endif
776
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900777/*
778 * Delete a VIF entry
779 */
780
Patrick McHardy6bd52142010-05-11 14:40:53 +0200781static int mif6_delete(struct mr6_table *mrt, int vifi, struct list_head *head)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900782{
783 struct mif_device *v;
784 struct net_device *dev;
Thomas Goff1d6e55f2009-01-27 22:39:59 -0800785 struct inet6_dev *in6_dev;
Patrick McHardy6bd52142010-05-11 14:40:53 +0200786
787 if (vifi < 0 || vifi >= mrt->maxvif)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900788 return -EADDRNOTAVAIL;
789
Patrick McHardy6bd52142010-05-11 14:40:53 +0200790 v = &mrt->vif6_table[vifi];
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900791
792 write_lock_bh(&mrt_lock);
793 dev = v->dev;
794 v->dev = NULL;
795
796 if (!dev) {
797 write_unlock_bh(&mrt_lock);
798 return -EADDRNOTAVAIL;
799 }
800
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +0900801#ifdef CONFIG_IPV6_PIMSM_V2
Patrick McHardy6bd52142010-05-11 14:40:53 +0200802 if (vifi == mrt->mroute_reg_vif_num)
803 mrt->mroute_reg_vif_num = -1;
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +0900804#endif
805
Patrick McHardy6bd52142010-05-11 14:40:53 +0200806 if (vifi + 1 == mrt->maxvif) {
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900807 int tmp;
808 for (tmp = vifi - 1; tmp >= 0; tmp--) {
Patrick McHardy6bd52142010-05-11 14:40:53 +0200809 if (MIF_EXISTS(mrt, tmp))
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900810 break;
811 }
Patrick McHardy6bd52142010-05-11 14:40:53 +0200812 mrt->maxvif = tmp + 1;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900813 }
814
815 write_unlock_bh(&mrt_lock);
816
817 dev_set_allmulti(dev, -1);
818
Thomas Goff1d6e55f2009-01-27 22:39:59 -0800819 in6_dev = __in6_dev_get(dev);
Nicolas Dichteld67b8c62012-12-04 01:13:35 +0000820 if (in6_dev) {
Thomas Goff1d6e55f2009-01-27 22:39:59 -0800821 in6_dev->cnf.mc_forwarding--;
Nicolas Dichteld67b8c62012-12-04 01:13:35 +0000822 inet6_netconf_notify_devconf(dev_net(dev),
823 NETCONFA_MC_FORWARDING,
824 dev->ifindex, &in6_dev->cnf);
825 }
Thomas Goff1d6e55f2009-01-27 22:39:59 -0800826
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900827 if (v->flags & MIFF_REGISTER)
Eric Dumazetc871e662009-10-28 04:48:11 +0000828 unregister_netdevice_queue(dev, head);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900829
830 dev_put(dev);
831 return 0;
832}
833
Benjamin Thery58701ad2008-12-10 16:22:34 -0800834static inline void ip6mr_cache_free(struct mfc6_cache *c)
835{
Benjamin Thery58701ad2008-12-10 16:22:34 -0800836 kmem_cache_free(mrt_cachep, c);
837}
838
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900839/* Destroy an unresolved cache entry, killing queued skbs
840 and reporting error to netlink readers.
841 */
842
Patrick McHardy6bd52142010-05-11 14:40:53 +0200843static void ip6mr_destroy_unres(struct mr6_table *mrt, struct mfc6_cache *c)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900844{
Patrick McHardy6bd52142010-05-11 14:40:53 +0200845 struct net *net = read_pnet(&mrt->net);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900846 struct sk_buff *skb;
847
Patrick McHardy6bd52142010-05-11 14:40:53 +0200848 atomic_dec(&mrt->cache_resolve_queue_len);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900849
Ian Morris67ba4152014-08-24 21:53:10 +0100850 while ((skb = skb_dequeue(&c->mfc_un.unres.unresolved)) != NULL) {
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900851 if (ipv6_hdr(skb)->version == 0) {
852 struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct ipv6hdr));
853 nlh->nlmsg_type = NLMSG_ERROR;
Hong zhi guo573ce262013-03-27 06:47:04 +0000854 nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900855 skb_trim(skb, nlh->nlmsg_len);
Hong zhi guo573ce262013-03-27 06:47:04 +0000856 ((struct nlmsgerr *)nlmsg_data(nlh))->error = -ETIMEDOUT;
Eric W. Biederman15e47302012-09-07 20:12:54 +0000857 rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900858 } else
859 kfree_skb(skb);
860 }
861
Benjamin Thery58701ad2008-12-10 16:22:34 -0800862 ip6mr_cache_free(c);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900863}
864
865
Patrick McHardyc476efb2010-05-11 14:40:48 +0200866/* Timer process for all the unresolved queue. */
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900867
Patrick McHardy6bd52142010-05-11 14:40:53 +0200868static void ipmr_do_expire_process(struct mr6_table *mrt)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900869{
870 unsigned long now = jiffies;
871 unsigned long expires = 10 * HZ;
Patrick McHardyf30a77842010-05-11 14:40:51 +0200872 struct mfc6_cache *c, *next;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900873
Patrick McHardy6bd52142010-05-11 14:40:53 +0200874 list_for_each_entry_safe(c, next, &mrt->mfc6_unres_queue, list) {
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900875 if (time_after(c->mfc_un.unres.expires, now)) {
876 /* not yet... */
877 unsigned long interval = c->mfc_un.unres.expires - now;
878 if (interval < expires)
879 expires = interval;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900880 continue;
881 }
882
Patrick McHardyf30a77842010-05-11 14:40:51 +0200883 list_del(&c->list);
Nicolas Dichtel812e44d2012-12-04 01:13:41 +0000884 mr6_netlink_event(mrt, c, RTM_DELROUTE);
Patrick McHardy6bd52142010-05-11 14:40:53 +0200885 ip6mr_destroy_unres(mrt, c);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900886 }
887
Patrick McHardy6bd52142010-05-11 14:40:53 +0200888 if (!list_empty(&mrt->mfc6_unres_queue))
889 mod_timer(&mrt->ipmr_expire_timer, jiffies + expires);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900890}
891
Patrick McHardyc476efb2010-05-11 14:40:48 +0200892static void ipmr_expire_process(unsigned long arg)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900893{
Patrick McHardy6bd52142010-05-11 14:40:53 +0200894 struct mr6_table *mrt = (struct mr6_table *)arg;
Patrick McHardyc476efb2010-05-11 14:40:48 +0200895
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900896 if (!spin_trylock(&mfc_unres_lock)) {
Patrick McHardy6bd52142010-05-11 14:40:53 +0200897 mod_timer(&mrt->ipmr_expire_timer, jiffies + 1);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900898 return;
899 }
900
Patrick McHardy6bd52142010-05-11 14:40:53 +0200901 if (!list_empty(&mrt->mfc6_unres_queue))
902 ipmr_do_expire_process(mrt);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900903
904 spin_unlock(&mfc_unres_lock);
905}
906
907/* Fill oifs list. It is called under write locked mrt_lock. */
908
Patrick McHardy6bd52142010-05-11 14:40:53 +0200909static void ip6mr_update_thresholds(struct mr6_table *mrt, struct mfc6_cache *cache,
Patrick McHardyb5aa30b2010-05-11 14:40:50 +0200910 unsigned char *ttls)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900911{
912 int vifi;
913
Rami Rosen6ac7eb02008-04-10 12:40:10 +0300914 cache->mfc_un.res.minvif = MAXMIFS;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900915 cache->mfc_un.res.maxvif = 0;
Rami Rosen6ac7eb02008-04-10 12:40:10 +0300916 memset(cache->mfc_un.res.ttls, 255, MAXMIFS);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900917
Patrick McHardy6bd52142010-05-11 14:40:53 +0200918 for (vifi = 0; vifi < mrt->maxvif; vifi++) {
919 if (MIF_EXISTS(mrt, vifi) &&
Benjamin Thery4e168802008-12-10 16:15:08 -0800920 ttls[vifi] && ttls[vifi] < 255) {
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900921 cache->mfc_un.res.ttls[vifi] = ttls[vifi];
922 if (cache->mfc_un.res.minvif > vifi)
923 cache->mfc_un.res.minvif = vifi;
924 if (cache->mfc_un.res.maxvif <= vifi)
925 cache->mfc_un.res.maxvif = vifi + 1;
926 }
927 }
928}
929
Patrick McHardy6bd52142010-05-11 14:40:53 +0200930static int mif6_add(struct net *net, struct mr6_table *mrt,
931 struct mif6ctl *vifc, int mrtsock)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900932{
933 int vifi = vifc->mif6c_mifi;
Patrick McHardy6bd52142010-05-11 14:40:53 +0200934 struct mif_device *v = &mrt->vif6_table[vifi];
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900935 struct net_device *dev;
Thomas Goff1d6e55f2009-01-27 22:39:59 -0800936 struct inet6_dev *in6_dev;
Wang Chen5ae7b442008-07-14 20:54:23 -0700937 int err;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900938
939 /* Is vif busy ? */
Patrick McHardy6bd52142010-05-11 14:40:53 +0200940 if (MIF_EXISTS(mrt, vifi))
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900941 return -EADDRINUSE;
942
943 switch (vifc->mif6c_flags) {
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +0900944#ifdef CONFIG_IPV6_PIMSM_V2
945 case MIFF_REGISTER:
946 /*
947 * Special Purpose VIF in PIM
948 * All the packets will be sent to the daemon
949 */
Patrick McHardy6bd52142010-05-11 14:40:53 +0200950 if (mrt->mroute_reg_vif_num >= 0)
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +0900951 return -EADDRINUSE;
Patrick McHardyd1db2752010-05-11 14:40:55 +0200952 dev = ip6mr_reg_vif(net, mrt);
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +0900953 if (!dev)
954 return -ENOBUFS;
Wang Chen5ae7b442008-07-14 20:54:23 -0700955 err = dev_set_allmulti(dev, 1);
956 if (err) {
957 unregister_netdevice(dev);
Wang Chen7af3db72008-07-14 20:54:54 -0700958 dev_put(dev);
Wang Chen5ae7b442008-07-14 20:54:23 -0700959 return err;
960 }
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +0900961 break;
962#endif
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900963 case 0:
Benjamin Thery8229efd2008-12-10 16:30:15 -0800964 dev = dev_get_by_index(net, vifc->mif6c_pifi);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900965 if (!dev)
966 return -EADDRNOTAVAIL;
Wang Chen5ae7b442008-07-14 20:54:23 -0700967 err = dev_set_allmulti(dev, 1);
Wang Chen7af3db72008-07-14 20:54:54 -0700968 if (err) {
969 dev_put(dev);
Wang Chen5ae7b442008-07-14 20:54:23 -0700970 return err;
Wang Chen7af3db72008-07-14 20:54:54 -0700971 }
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900972 break;
973 default:
974 return -EINVAL;
975 }
976
Thomas Goff1d6e55f2009-01-27 22:39:59 -0800977 in6_dev = __in6_dev_get(dev);
Nicolas Dichteld67b8c62012-12-04 01:13:35 +0000978 if (in6_dev) {
Thomas Goff1d6e55f2009-01-27 22:39:59 -0800979 in6_dev->cnf.mc_forwarding++;
Nicolas Dichteld67b8c62012-12-04 01:13:35 +0000980 inet6_netconf_notify_devconf(dev_net(dev),
981 NETCONFA_MC_FORWARDING,
982 dev->ifindex, &in6_dev->cnf);
983 }
Thomas Goff1d6e55f2009-01-27 22:39:59 -0800984
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900985 /*
986 * Fill in the VIF structures
987 */
988 v->rate_limit = vifc->vifc_rate_limit;
989 v->flags = vifc->mif6c_flags;
990 if (!mrtsock)
991 v->flags |= VIFF_STATIC;
992 v->threshold = vifc->vifc_threshold;
993 v->bytes_in = 0;
994 v->bytes_out = 0;
995 v->pkt_in = 0;
996 v->pkt_out = 0;
997 v->link = dev->ifindex;
998 if (v->flags & MIFF_REGISTER)
Nicolas Dichtela54acb32015-04-02 17:07:00 +0200999 v->link = dev_get_iflink(dev);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001000
1001 /* And finish update writing critical data */
1002 write_lock_bh(&mrt_lock);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001003 v->dev = dev;
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +09001004#ifdef CONFIG_IPV6_PIMSM_V2
1005 if (v->flags & MIFF_REGISTER)
Patrick McHardy6bd52142010-05-11 14:40:53 +02001006 mrt->mroute_reg_vif_num = vifi;
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +09001007#endif
Patrick McHardy6bd52142010-05-11 14:40:53 +02001008 if (vifi + 1 > mrt->maxvif)
1009 mrt->maxvif = vifi + 1;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001010 write_unlock_bh(&mrt_lock);
1011 return 0;
1012}
1013
Patrick McHardy6bd52142010-05-11 14:40:53 +02001014static struct mfc6_cache *ip6mr_cache_find(struct mr6_table *mrt,
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001015 const struct in6_addr *origin,
1016 const struct in6_addr *mcastgrp)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001017{
1018 int line = MFC6_HASH(mcastgrp, origin);
1019 struct mfc6_cache *c;
1020
Patrick McHardy6bd52142010-05-11 14:40:53 +02001021 list_for_each_entry(c, &mrt->mfc6_cache_array[line], list) {
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001022 if (ipv6_addr_equal(&c->mf6c_origin, origin) &&
1023 ipv6_addr_equal(&c->mf6c_mcastgrp, mcastgrp))
Patrick McHardyf30a77842010-05-11 14:40:51 +02001024 return c;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001025 }
Patrick McHardyf30a77842010-05-11 14:40:51 +02001026 return NULL;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001027}
1028
Nicolas Dichtel660b26d2013-01-21 06:00:26 +00001029/* Look for a (*,*,oif) entry */
1030static struct mfc6_cache *ip6mr_cache_find_any_parent(struct mr6_table *mrt,
1031 mifi_t mifi)
1032{
1033 int line = MFC6_HASH(&in6addr_any, &in6addr_any);
1034 struct mfc6_cache *c;
1035
1036 list_for_each_entry(c, &mrt->mfc6_cache_array[line], list)
1037 if (ipv6_addr_any(&c->mf6c_origin) &&
1038 ipv6_addr_any(&c->mf6c_mcastgrp) &&
1039 (c->mfc_un.res.ttls[mifi] < 255))
1040 return c;
1041
1042 return NULL;
1043}
1044
1045/* Look for a (*,G) entry */
1046static struct mfc6_cache *ip6mr_cache_find_any(struct mr6_table *mrt,
1047 struct in6_addr *mcastgrp,
1048 mifi_t mifi)
1049{
1050 int line = MFC6_HASH(mcastgrp, &in6addr_any);
1051 struct mfc6_cache *c, *proxy;
1052
1053 if (ipv6_addr_any(mcastgrp))
1054 goto skip;
1055
1056 list_for_each_entry(c, &mrt->mfc6_cache_array[line], list)
1057 if (ipv6_addr_any(&c->mf6c_origin) &&
1058 ipv6_addr_equal(&c->mf6c_mcastgrp, mcastgrp)) {
1059 if (c->mfc_un.res.ttls[mifi] < 255)
1060 return c;
1061
1062 /* It's ok if the mifi is part of the static tree */
1063 proxy = ip6mr_cache_find_any_parent(mrt,
1064 c->mf6c_parent);
1065 if (proxy && proxy->mfc_un.res.ttls[mifi] < 255)
1066 return c;
1067 }
1068
1069skip:
1070 return ip6mr_cache_find_any_parent(mrt, mifi);
1071}
1072
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001073/*
1074 * Allocate a multicast cache entry
1075 */
Patrick McHardyb5aa30b2010-05-11 14:40:50 +02001076static struct mfc6_cache *ip6mr_cache_alloc(void)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001077{
Joe Perches36cbac52008-12-03 22:27:25 -08001078 struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
Ian Morris63159f22015-03-29 14:00:04 +01001079 if (!c)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001080 return NULL;
Rami Rosen6ac7eb02008-04-10 12:40:10 +03001081 c->mfc_un.res.minvif = MAXMIFS;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001082 return c;
1083}
1084
Patrick McHardyb5aa30b2010-05-11 14:40:50 +02001085static struct mfc6_cache *ip6mr_cache_alloc_unres(void)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001086{
Joe Perches36cbac52008-12-03 22:27:25 -08001087 struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC);
Ian Morris63159f22015-03-29 14:00:04 +01001088 if (!c)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001089 return NULL;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001090 skb_queue_head_init(&c->mfc_un.unres.unresolved);
1091 c->mfc_un.unres.expires = jiffies + 10 * HZ;
1092 return c;
1093}
1094
1095/*
1096 * A cache entry has gone into a resolved state from queued
1097 */
1098
Patrick McHardy6bd52142010-05-11 14:40:53 +02001099static void ip6mr_cache_resolve(struct net *net, struct mr6_table *mrt,
1100 struct mfc6_cache *uc, struct mfc6_cache *c)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001101{
1102 struct sk_buff *skb;
1103
1104 /*
1105 * Play the pending entries through our router
1106 */
1107
Ian Morris67ba4152014-08-24 21:53:10 +01001108 while ((skb = __skb_dequeue(&uc->mfc_un.unres.unresolved))) {
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001109 if (ipv6_hdr(skb)->version == 0) {
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001110 struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct ipv6hdr));
1111
Hong zhi guo573ce262013-03-27 06:47:04 +00001112 if (__ip6mr_fill_mroute(mrt, skb, c, nlmsg_data(nlh)) > 0) {
YOSHIFUJI Hideaki549e0282008-04-05 22:17:39 +09001113 nlh->nlmsg_len = skb_tail_pointer(skb) - (u8 *)nlh;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001114 } else {
1115 nlh->nlmsg_type = NLMSG_ERROR;
Hong zhi guo573ce262013-03-27 06:47:04 +00001116 nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001117 skb_trim(skb, nlh->nlmsg_len);
Hong zhi guo573ce262013-03-27 06:47:04 +00001118 ((struct nlmsgerr *)nlmsg_data(nlh))->error = -EMSGSIZE;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001119 }
Eric W. Biederman15e47302012-09-07 20:12:54 +00001120 rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001121 } else
Patrick McHardy6bd52142010-05-11 14:40:53 +02001122 ip6_mr_forward(net, mrt, skb, c);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001123 }
1124}
1125
1126/*
1127 * Bounce a cache query up to pim6sd. We could use netlink for this but pim6sd
1128 * expects the following bizarre scheme.
1129 *
1130 * Called under mrt_lock.
1131 */
1132
Patrick McHardy6bd52142010-05-11 14:40:53 +02001133static int ip6mr_cache_report(struct mr6_table *mrt, struct sk_buff *pkt,
1134 mifi_t mifi, int assert)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001135{
1136 struct sk_buff *skb;
1137 struct mrt6msg *msg;
1138 int ret;
1139
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +09001140#ifdef CONFIG_IPV6_PIMSM_V2
1141 if (assert == MRT6MSG_WHOLEPKT)
1142 skb = skb_realloc_headroom(pkt, -skb_network_offset(pkt)
1143 +sizeof(*msg));
1144 else
1145#endif
1146 skb = alloc_skb(sizeof(struct ipv6hdr) + sizeof(*msg), GFP_ATOMIC);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001147
1148 if (!skb)
1149 return -ENOBUFS;
1150
1151 /* I suppose that internal messages
1152 * do not require checksums */
1153
1154 skb->ip_summed = CHECKSUM_UNNECESSARY;
1155
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +09001156#ifdef CONFIG_IPV6_PIMSM_V2
1157 if (assert == MRT6MSG_WHOLEPKT) {
1158 /* Ugly, but we have no choice with this interface.
1159 Duplicate old header, fix length etc.
1160 And all this only to mangle msg->im6_msgtype and
1161 to set msg->im6_mbz to "mbz" :-)
1162 */
1163 skb_push(skb, -skb_network_offset(pkt));
1164
1165 skb_push(skb, sizeof(*msg));
1166 skb_reset_transport_header(skb);
1167 msg = (struct mrt6msg *)skb_transport_header(skb);
1168 msg->im6_mbz = 0;
1169 msg->im6_msgtype = MRT6MSG_WHOLEPKT;
Patrick McHardy6bd52142010-05-11 14:40:53 +02001170 msg->im6_mif = mrt->mroute_reg_vif_num;
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +09001171 msg->im6_pad = 0;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00001172 msg->im6_src = ipv6_hdr(pkt)->saddr;
1173 msg->im6_dst = ipv6_hdr(pkt)->daddr;
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +09001174
1175 skb->ip_summed = CHECKSUM_UNNECESSARY;
1176 } else
1177#endif
1178 {
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001179 /*
1180 * Copy the IP header
1181 */
1182
1183 skb_put(skb, sizeof(struct ipv6hdr));
1184 skb_reset_network_header(skb);
1185 skb_copy_to_linear_data(skb, ipv6_hdr(pkt), sizeof(struct ipv6hdr));
1186
1187 /*
1188 * Add our header
1189 */
1190 skb_put(skb, sizeof(*msg));
1191 skb_reset_transport_header(skb);
1192 msg = (struct mrt6msg *)skb_transport_header(skb);
1193
1194 msg->im6_mbz = 0;
1195 msg->im6_msgtype = assert;
Rami Rosen6ac7eb02008-04-10 12:40:10 +03001196 msg->im6_mif = mifi;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001197 msg->im6_pad = 0;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00001198 msg->im6_src = ipv6_hdr(pkt)->saddr;
1199 msg->im6_dst = ipv6_hdr(pkt)->daddr;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001200
Eric Dumazetadf30902009-06-02 05:19:30 +00001201 skb_dst_set(skb, dst_clone(skb_dst(pkt)));
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001202 skb->ip_summed = CHECKSUM_UNNECESSARY;
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +09001203 }
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001204
Ian Morris63159f22015-03-29 14:00:04 +01001205 if (!mrt->mroute6_sk) {
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001206 kfree_skb(skb);
1207 return -EINVAL;
1208 }
1209
1210 /*
1211 * Deliver to user space multicast routing algorithms
1212 */
Patrick McHardy6bd52142010-05-11 14:40:53 +02001213 ret = sock_queue_rcv_skb(mrt->mroute6_sk, skb);
Benjamin Therybd91b8b2008-12-10 16:07:08 -08001214 if (ret < 0) {
Joe Perchese87cc472012-05-13 21:56:26 +00001215 net_warn_ratelimited("mroute6: pending queue full, dropping entries\n");
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001216 kfree_skb(skb);
1217 }
1218
1219 return ret;
1220}
1221
1222/*
1223 * Queue a packet for resolution. It gets locked cache entry!
1224 */
1225
1226static int
Patrick McHardy6bd52142010-05-11 14:40:53 +02001227ip6mr_cache_unresolved(struct mr6_table *mrt, mifi_t mifi, struct sk_buff *skb)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001228{
Patrick McHardyf30a77842010-05-11 14:40:51 +02001229 bool found = false;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001230 int err;
1231 struct mfc6_cache *c;
1232
1233 spin_lock_bh(&mfc_unres_lock);
Patrick McHardy6bd52142010-05-11 14:40:53 +02001234 list_for_each_entry(c, &mrt->mfc6_unres_queue, list) {
Patrick McHardyc476efb2010-05-11 14:40:48 +02001235 if (ipv6_addr_equal(&c->mf6c_mcastgrp, &ipv6_hdr(skb)->daddr) &&
Patrick McHardyf30a77842010-05-11 14:40:51 +02001236 ipv6_addr_equal(&c->mf6c_origin, &ipv6_hdr(skb)->saddr)) {
1237 found = true;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001238 break;
Patrick McHardyf30a77842010-05-11 14:40:51 +02001239 }
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001240 }
1241
Patrick McHardyf30a77842010-05-11 14:40:51 +02001242 if (!found) {
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001243 /*
1244 * Create a new entry if allowable
1245 */
1246
Patrick McHardy6bd52142010-05-11 14:40:53 +02001247 if (atomic_read(&mrt->cache_resolve_queue_len) >= 10 ||
Patrick McHardyb5aa30b2010-05-11 14:40:50 +02001248 (c = ip6mr_cache_alloc_unres()) == NULL) {
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001249 spin_unlock_bh(&mfc_unres_lock);
1250
1251 kfree_skb(skb);
1252 return -ENOBUFS;
1253 }
1254
1255 /*
1256 * Fill in the new cache entry
1257 */
1258 c->mf6c_parent = -1;
1259 c->mf6c_origin = ipv6_hdr(skb)->saddr;
1260 c->mf6c_mcastgrp = ipv6_hdr(skb)->daddr;
1261
1262 /*
1263 * Reflect first query at pim6sd
1264 */
Patrick McHardy6bd52142010-05-11 14:40:53 +02001265 err = ip6mr_cache_report(mrt, skb, mifi, MRT6MSG_NOCACHE);
Benjamin Thery8229efd2008-12-10 16:30:15 -08001266 if (err < 0) {
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001267 /* If the report failed throw the cache entry
1268 out - Brad Parker
1269 */
1270 spin_unlock_bh(&mfc_unres_lock);
1271
Benjamin Thery58701ad2008-12-10 16:22:34 -08001272 ip6mr_cache_free(c);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001273 kfree_skb(skb);
1274 return err;
1275 }
1276
Patrick McHardy6bd52142010-05-11 14:40:53 +02001277 atomic_inc(&mrt->cache_resolve_queue_len);
1278 list_add(&c->list, &mrt->mfc6_unres_queue);
Nicolas Dichtel812e44d2012-12-04 01:13:41 +00001279 mr6_netlink_event(mrt, c, RTM_NEWROUTE);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001280
Patrick McHardy6bd52142010-05-11 14:40:53 +02001281 ipmr_do_expire_process(mrt);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001282 }
1283
1284 /*
1285 * See if we can append the packet
1286 */
1287 if (c->mfc_un.unres.unresolved.qlen > 3) {
1288 kfree_skb(skb);
1289 err = -ENOBUFS;
1290 } else {
1291 skb_queue_tail(&c->mfc_un.unres.unresolved, skb);
1292 err = 0;
1293 }
1294
1295 spin_unlock_bh(&mfc_unres_lock);
1296 return err;
1297}
1298
1299/*
1300 * MFC6 cache manipulation by user space
1301 */
1302
Nicolas Dichtel660b26d2013-01-21 06:00:26 +00001303static int ip6mr_mfc_delete(struct mr6_table *mrt, struct mf6cctl *mfc,
1304 int parent)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001305{
1306 int line;
Patrick McHardyf30a77842010-05-11 14:40:51 +02001307 struct mfc6_cache *c, *next;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001308
1309 line = MFC6_HASH(&mfc->mf6cc_mcastgrp.sin6_addr, &mfc->mf6cc_origin.sin6_addr);
1310
Patrick McHardy6bd52142010-05-11 14:40:53 +02001311 list_for_each_entry_safe(c, next, &mrt->mfc6_cache_array[line], list) {
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001312 if (ipv6_addr_equal(&c->mf6c_origin, &mfc->mf6cc_origin.sin6_addr) &&
Nicolas Dichtel660b26d2013-01-21 06:00:26 +00001313 ipv6_addr_equal(&c->mf6c_mcastgrp,
1314 &mfc->mf6cc_mcastgrp.sin6_addr) &&
1315 (parent == -1 || parent == c->mf6c_parent)) {
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001316 write_lock_bh(&mrt_lock);
Patrick McHardyf30a77842010-05-11 14:40:51 +02001317 list_del(&c->list);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001318 write_unlock_bh(&mrt_lock);
1319
Nicolas Dichtel812e44d2012-12-04 01:13:41 +00001320 mr6_netlink_event(mrt, c, RTM_DELROUTE);
Benjamin Thery58701ad2008-12-10 16:22:34 -08001321 ip6mr_cache_free(c);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001322 return 0;
1323 }
1324 }
1325 return -ENOENT;
1326}
1327
1328static int ip6mr_device_event(struct notifier_block *this,
1329 unsigned long event, void *ptr)
1330{
Jiri Pirko351638e2013-05-28 01:30:21 +00001331 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
Benjamin Thery8229efd2008-12-10 16:30:15 -08001332 struct net *net = dev_net(dev);
Patrick McHardyd1db2752010-05-11 14:40:55 +02001333 struct mr6_table *mrt;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001334 struct mif_device *v;
1335 int ct;
Eric Dumazetc871e662009-10-28 04:48:11 +00001336 LIST_HEAD(list);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001337
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001338 if (event != NETDEV_UNREGISTER)
1339 return NOTIFY_DONE;
1340
Patrick McHardyd1db2752010-05-11 14:40:55 +02001341 ip6mr_for_each_table(mrt, net) {
1342 v = &mrt->vif6_table[0];
1343 for (ct = 0; ct < mrt->maxvif; ct++, v++) {
1344 if (v->dev == dev)
1345 mif6_delete(mrt, ct, &list);
1346 }
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001347 }
Eric Dumazetc871e662009-10-28 04:48:11 +00001348 unregister_netdevice_many(&list);
1349
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001350 return NOTIFY_DONE;
1351}
1352
1353static struct notifier_block ip6_mr_notifier = {
1354 .notifier_call = ip6mr_device_event
1355};
1356
1357/*
1358 * Setup for IP multicast routing
1359 */
1360
Benjamin Thery4e168802008-12-10 16:15:08 -08001361static int __net_init ip6mr_net_init(struct net *net)
1362{
Patrick McHardyd1db2752010-05-11 14:40:55 +02001363 int err;
Patrick McHardyf30a77842010-05-11 14:40:51 +02001364
Patrick McHardyd1db2752010-05-11 14:40:55 +02001365 err = ip6mr_rules_init(net);
1366 if (err < 0)
Benjamin Thery4e168802008-12-10 16:15:08 -08001367 goto fail;
Benjamin Thery8b90fc72008-12-10 16:29:48 -08001368
1369#ifdef CONFIG_PROC_FS
1370 err = -ENOMEM;
Gao fengd4beaa62013-02-18 01:34:54 +00001371 if (!proc_create("ip6_mr_vif", 0, net->proc_net, &ip6mr_vif_fops))
Benjamin Thery8b90fc72008-12-10 16:29:48 -08001372 goto proc_vif_fail;
Gao fengd4beaa62013-02-18 01:34:54 +00001373 if (!proc_create("ip6_mr_cache", 0, net->proc_net, &ip6mr_mfc_fops))
Benjamin Thery8b90fc72008-12-10 16:29:48 -08001374 goto proc_cache_fail;
1375#endif
Patrick McHardy6bd52142010-05-11 14:40:53 +02001376
Benjamin Thery4a6258a2008-12-10 16:24:07 -08001377 return 0;
1378
Benjamin Thery8b90fc72008-12-10 16:29:48 -08001379#ifdef CONFIG_PROC_FS
1380proc_cache_fail:
Gao fengece31ff2013-02-18 01:34:56 +00001381 remove_proc_entry("ip6_mr_vif", net->proc_net);
Benjamin Thery8b90fc72008-12-10 16:29:48 -08001382proc_vif_fail:
Patrick McHardyd1db2752010-05-11 14:40:55 +02001383 ip6mr_rules_exit(net);
Benjamin Thery8b90fc72008-12-10 16:29:48 -08001384#endif
Benjamin Thery4e168802008-12-10 16:15:08 -08001385fail:
1386 return err;
1387}
1388
1389static void __net_exit ip6mr_net_exit(struct net *net)
1390{
Benjamin Thery8b90fc72008-12-10 16:29:48 -08001391#ifdef CONFIG_PROC_FS
Gao fengece31ff2013-02-18 01:34:56 +00001392 remove_proc_entry("ip6_mr_cache", net->proc_net);
1393 remove_proc_entry("ip6_mr_vif", net->proc_net);
Benjamin Thery8b90fc72008-12-10 16:29:48 -08001394#endif
Patrick McHardyd1db2752010-05-11 14:40:55 +02001395 ip6mr_rules_exit(net);
Benjamin Thery4e168802008-12-10 16:15:08 -08001396}
1397
1398static struct pernet_operations ip6mr_net_ops = {
1399 .init = ip6mr_net_init,
1400 .exit = ip6mr_net_exit,
1401};
1402
Wang Chen623d1a12008-07-03 12:13:30 +08001403int __init ip6_mr_init(void)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001404{
Wang Chen623d1a12008-07-03 12:13:30 +08001405 int err;
1406
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001407 mrt_cachep = kmem_cache_create("ip6_mrt_cache",
1408 sizeof(struct mfc6_cache),
1409 0, SLAB_HWCACHE_ALIGN,
1410 NULL);
1411 if (!mrt_cachep)
Wang Chen623d1a12008-07-03 12:13:30 +08001412 return -ENOMEM;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001413
Benjamin Thery4e168802008-12-10 16:15:08 -08001414 err = register_pernet_subsys(&ip6mr_net_ops);
1415 if (err)
1416 goto reg_pernet_fail;
1417
Wang Chen623d1a12008-07-03 12:13:30 +08001418 err = register_netdevice_notifier(&ip6_mr_notifier);
1419 if (err)
1420 goto reg_notif_fail;
Tom Goff403dbb92009-06-14 03:16:13 -07001421#ifdef CONFIG_IPV6_PIMSM_V2
1422 if (inet6_add_protocol(&pim6_protocol, IPPROTO_PIM) < 0) {
Joe Perchesf3213832012-05-15 14:11:53 +00001423 pr_err("%s: can't add PIM protocol\n", __func__);
Tom Goff403dbb92009-06-14 03:16:13 -07001424 err = -EAGAIN;
1425 goto add_proto_fail;
1426 }
1427#endif
Greg Rosec7ac8672011-06-10 01:27:09 +00001428 rtnl_register(RTNL_FAMILY_IP6MR, RTM_GETROUTE, NULL,
1429 ip6mr_rtm_dumproute, NULL);
Wang Chen623d1a12008-07-03 12:13:30 +08001430 return 0;
Tom Goff403dbb92009-06-14 03:16:13 -07001431#ifdef CONFIG_IPV6_PIMSM_V2
1432add_proto_fail:
1433 unregister_netdevice_notifier(&ip6_mr_notifier);
1434#endif
Benjamin Thery87b30a62008-11-10 16:34:11 -08001435reg_notif_fail:
Benjamin Thery4e168802008-12-10 16:15:08 -08001436 unregister_pernet_subsys(&ip6mr_net_ops);
1437reg_pernet_fail:
Benjamin Thery87b30a62008-11-10 16:34:11 -08001438 kmem_cache_destroy(mrt_cachep);
Wang Chen623d1a12008-07-03 12:13:30 +08001439 return err;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001440}
1441
Wang Chen623d1a12008-07-03 12:13:30 +08001442void ip6_mr_cleanup(void)
1443{
Duan Jiongffb13882014-11-19 09:35:39 +08001444 rtnl_unregister(RTNL_FAMILY_IP6MR, RTM_GETROUTE);
1445#ifdef CONFIG_IPV6_PIMSM_V2
1446 inet6_del_protocol(&pim6_protocol, IPPROTO_PIM);
1447#endif
Wang Chen623d1a12008-07-03 12:13:30 +08001448 unregister_netdevice_notifier(&ip6_mr_notifier);
Benjamin Thery4e168802008-12-10 16:15:08 -08001449 unregister_pernet_subsys(&ip6mr_net_ops);
Wang Chen623d1a12008-07-03 12:13:30 +08001450 kmem_cache_destroy(mrt_cachep);
1451}
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001452
Patrick McHardy6bd52142010-05-11 14:40:53 +02001453static int ip6mr_mfc_add(struct net *net, struct mr6_table *mrt,
Nicolas Dichtel660b26d2013-01-21 06:00:26 +00001454 struct mf6cctl *mfc, int mrtsock, int parent)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001455{
Patrick McHardyf30a77842010-05-11 14:40:51 +02001456 bool found = false;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001457 int line;
Patrick McHardyf30a77842010-05-11 14:40:51 +02001458 struct mfc6_cache *uc, *c;
Rami Rosen6ac7eb02008-04-10 12:40:10 +03001459 unsigned char ttls[MAXMIFS];
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001460 int i;
1461
Patrick McHardya50436f22010-03-17 06:04:14 +00001462 if (mfc->mf6cc_parent >= MAXMIFS)
1463 return -ENFILE;
1464
Rami Rosen6ac7eb02008-04-10 12:40:10 +03001465 memset(ttls, 255, MAXMIFS);
1466 for (i = 0; i < MAXMIFS; i++) {
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001467 if (IF_ISSET(i, &mfc->mf6cc_ifset))
1468 ttls[i] = 1;
1469
1470 }
1471
1472 line = MFC6_HASH(&mfc->mf6cc_mcastgrp.sin6_addr, &mfc->mf6cc_origin.sin6_addr);
1473
Patrick McHardy6bd52142010-05-11 14:40:53 +02001474 list_for_each_entry(c, &mrt->mfc6_cache_array[line], list) {
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001475 if (ipv6_addr_equal(&c->mf6c_origin, &mfc->mf6cc_origin.sin6_addr) &&
Nicolas Dichtel660b26d2013-01-21 06:00:26 +00001476 ipv6_addr_equal(&c->mf6c_mcastgrp,
1477 &mfc->mf6cc_mcastgrp.sin6_addr) &&
1478 (parent == -1 || parent == mfc->mf6cc_parent)) {
Patrick McHardyf30a77842010-05-11 14:40:51 +02001479 found = true;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001480 break;
Patrick McHardyf30a77842010-05-11 14:40:51 +02001481 }
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001482 }
1483
Patrick McHardyf30a77842010-05-11 14:40:51 +02001484 if (found) {
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001485 write_lock_bh(&mrt_lock);
1486 c->mf6c_parent = mfc->mf6cc_parent;
Patrick McHardy6bd52142010-05-11 14:40:53 +02001487 ip6mr_update_thresholds(mrt, c, ttls);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001488 if (!mrtsock)
1489 c->mfc_flags |= MFC_STATIC;
1490 write_unlock_bh(&mrt_lock);
Nicolas Dichtel812e44d2012-12-04 01:13:41 +00001491 mr6_netlink_event(mrt, c, RTM_NEWROUTE);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001492 return 0;
1493 }
1494
Nicolas Dichtel660b26d2013-01-21 06:00:26 +00001495 if (!ipv6_addr_any(&mfc->mf6cc_mcastgrp.sin6_addr) &&
1496 !ipv6_addr_is_multicast(&mfc->mf6cc_mcastgrp.sin6_addr))
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001497 return -EINVAL;
1498
Patrick McHardyb5aa30b2010-05-11 14:40:50 +02001499 c = ip6mr_cache_alloc();
Ian Morris63159f22015-03-29 14:00:04 +01001500 if (!c)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001501 return -ENOMEM;
1502
1503 c->mf6c_origin = mfc->mf6cc_origin.sin6_addr;
1504 c->mf6c_mcastgrp = mfc->mf6cc_mcastgrp.sin6_addr;
1505 c->mf6c_parent = mfc->mf6cc_parent;
Patrick McHardy6bd52142010-05-11 14:40:53 +02001506 ip6mr_update_thresholds(mrt, c, ttls);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001507 if (!mrtsock)
1508 c->mfc_flags |= MFC_STATIC;
1509
1510 write_lock_bh(&mrt_lock);
Patrick McHardy6bd52142010-05-11 14:40:53 +02001511 list_add(&c->list, &mrt->mfc6_cache_array[line]);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001512 write_unlock_bh(&mrt_lock);
1513
1514 /*
1515 * Check to see if we resolved a queued list. If so we
1516 * need to send on the frames and tidy up.
1517 */
Patrick McHardyf30a77842010-05-11 14:40:51 +02001518 found = false;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001519 spin_lock_bh(&mfc_unres_lock);
Patrick McHardy6bd52142010-05-11 14:40:53 +02001520 list_for_each_entry(uc, &mrt->mfc6_unres_queue, list) {
Patrick McHardyc476efb2010-05-11 14:40:48 +02001521 if (ipv6_addr_equal(&uc->mf6c_origin, &c->mf6c_origin) &&
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001522 ipv6_addr_equal(&uc->mf6c_mcastgrp, &c->mf6c_mcastgrp)) {
Patrick McHardyf30a77842010-05-11 14:40:51 +02001523 list_del(&uc->list);
Patrick McHardy6bd52142010-05-11 14:40:53 +02001524 atomic_dec(&mrt->cache_resolve_queue_len);
Patrick McHardyf30a77842010-05-11 14:40:51 +02001525 found = true;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001526 break;
1527 }
1528 }
Patrick McHardy6bd52142010-05-11 14:40:53 +02001529 if (list_empty(&mrt->mfc6_unres_queue))
1530 del_timer(&mrt->ipmr_expire_timer);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001531 spin_unlock_bh(&mfc_unres_lock);
1532
Patrick McHardyf30a77842010-05-11 14:40:51 +02001533 if (found) {
Patrick McHardy6bd52142010-05-11 14:40:53 +02001534 ip6mr_cache_resolve(net, mrt, uc, c);
Benjamin Thery58701ad2008-12-10 16:22:34 -08001535 ip6mr_cache_free(uc);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001536 }
Nicolas Dichtel812e44d2012-12-04 01:13:41 +00001537 mr6_netlink_event(mrt, c, RTM_NEWROUTE);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001538 return 0;
1539}
1540
1541/*
1542 * Close the multicast socket, and clear the vif tables etc
1543 */
1544
Patrick McHardy6bd52142010-05-11 14:40:53 +02001545static void mroute_clean_tables(struct mr6_table *mrt)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001546{
1547 int i;
Eric Dumazetc871e662009-10-28 04:48:11 +00001548 LIST_HEAD(list);
Patrick McHardyf30a77842010-05-11 14:40:51 +02001549 struct mfc6_cache *c, *next;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001550
1551 /*
1552 * Shut down all active vif entries
1553 */
Patrick McHardy6bd52142010-05-11 14:40:53 +02001554 for (i = 0; i < mrt->maxvif; i++) {
1555 if (!(mrt->vif6_table[i].flags & VIFF_STATIC))
1556 mif6_delete(mrt, i, &list);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001557 }
Eric Dumazetc871e662009-10-28 04:48:11 +00001558 unregister_netdevice_many(&list);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001559
1560 /*
1561 * Wipe the cache
1562 */
Benjamin Thery4a6258a2008-12-10 16:24:07 -08001563 for (i = 0; i < MFC6_LINES; i++) {
Patrick McHardy6bd52142010-05-11 14:40:53 +02001564 list_for_each_entry_safe(c, next, &mrt->mfc6_cache_array[i], list) {
Patrick McHardyf30a77842010-05-11 14:40:51 +02001565 if (c->mfc_flags & MFC_STATIC)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001566 continue;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001567 write_lock_bh(&mrt_lock);
Patrick McHardyf30a77842010-05-11 14:40:51 +02001568 list_del(&c->list);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001569 write_unlock_bh(&mrt_lock);
1570
Nicolas Dichtel812e44d2012-12-04 01:13:41 +00001571 mr6_netlink_event(mrt, c, RTM_DELROUTE);
Benjamin Thery58701ad2008-12-10 16:22:34 -08001572 ip6mr_cache_free(c);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001573 }
1574 }
1575
Patrick McHardy6bd52142010-05-11 14:40:53 +02001576 if (atomic_read(&mrt->cache_resolve_queue_len) != 0) {
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001577 spin_lock_bh(&mfc_unres_lock);
Patrick McHardy6bd52142010-05-11 14:40:53 +02001578 list_for_each_entry_safe(c, next, &mrt->mfc6_unres_queue, list) {
Patrick McHardyf30a77842010-05-11 14:40:51 +02001579 list_del(&c->list);
Nicolas Dichtel812e44d2012-12-04 01:13:41 +00001580 mr6_netlink_event(mrt, c, RTM_DELROUTE);
Patrick McHardy6bd52142010-05-11 14:40:53 +02001581 ip6mr_destroy_unres(mrt, c);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001582 }
1583 spin_unlock_bh(&mfc_unres_lock);
1584 }
1585}
1586
Patrick McHardy6bd52142010-05-11 14:40:53 +02001587static int ip6mr_sk_init(struct mr6_table *mrt, struct sock *sk)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001588{
1589 int err = 0;
Benjamin Thery8229efd2008-12-10 16:30:15 -08001590 struct net *net = sock_net(sk);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001591
1592 rtnl_lock();
1593 write_lock_bh(&mrt_lock);
Patrick McHardy6bd52142010-05-11 14:40:53 +02001594 if (likely(mrt->mroute6_sk == NULL)) {
1595 mrt->mroute6_sk = sk;
Thomas Goff1d6e55f2009-01-27 22:39:59 -08001596 net->ipv6.devconf_all->mc_forwarding++;
Nicolas Dichteld67b8c62012-12-04 01:13:35 +00001597 inet6_netconf_notify_devconf(net, NETCONFA_MC_FORWARDING,
1598 NETCONFA_IFINDEX_ALL,
1599 net->ipv6.devconf_all);
Thomas Goff1d6e55f2009-01-27 22:39:59 -08001600 }
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001601 else
1602 err = -EADDRINUSE;
1603 write_unlock_bh(&mrt_lock);
1604
1605 rtnl_unlock();
1606
1607 return err;
1608}
1609
1610int ip6mr_sk_done(struct sock *sk)
1611{
Patrick McHardyd1db2752010-05-11 14:40:55 +02001612 int err = -EACCES;
Benjamin Thery8229efd2008-12-10 16:30:15 -08001613 struct net *net = sock_net(sk);
Patrick McHardyd1db2752010-05-11 14:40:55 +02001614 struct mr6_table *mrt;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001615
1616 rtnl_lock();
Patrick McHardyd1db2752010-05-11 14:40:55 +02001617 ip6mr_for_each_table(mrt, net) {
1618 if (sk == mrt->mroute6_sk) {
1619 write_lock_bh(&mrt_lock);
1620 mrt->mroute6_sk = NULL;
1621 net->ipv6.devconf_all->mc_forwarding--;
Nicolas Dichteld67b8c62012-12-04 01:13:35 +00001622 inet6_netconf_notify_devconf(net,
1623 NETCONFA_MC_FORWARDING,
1624 NETCONFA_IFINDEX_ALL,
1625 net->ipv6.devconf_all);
Patrick McHardyd1db2752010-05-11 14:40:55 +02001626 write_unlock_bh(&mrt_lock);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001627
Patrick McHardyd1db2752010-05-11 14:40:55 +02001628 mroute_clean_tables(mrt);
1629 err = 0;
1630 break;
1631 }
1632 }
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001633 rtnl_unlock();
1634
1635 return err;
1636}
1637
Patrick McHardyd1db2752010-05-11 14:40:55 +02001638struct sock *mroute6_socket(struct net *net, struct sk_buff *skb)
Patrick McHardy6bd52142010-05-11 14:40:53 +02001639{
Patrick McHardyd1db2752010-05-11 14:40:55 +02001640 struct mr6_table *mrt;
David S. Miller4c9483b2011-03-12 16:22:43 -05001641 struct flowi6 fl6 = {
Julian Anastasove374c612014-04-28 10:51:56 +03001642 .flowi6_iif = skb->skb_iif ? : LOOPBACK_IFINDEX,
David S. Miller4c9483b2011-03-12 16:22:43 -05001643 .flowi6_oif = skb->dev->ifindex,
1644 .flowi6_mark = skb->mark,
Patrick McHardyd1db2752010-05-11 14:40:55 +02001645 };
1646
David S. Miller4c9483b2011-03-12 16:22:43 -05001647 if (ip6mr_fib_lookup(net, &fl6, &mrt) < 0)
Patrick McHardyd1db2752010-05-11 14:40:55 +02001648 return NULL;
Patrick McHardy6bd52142010-05-11 14:40:53 +02001649
1650 return mrt->mroute6_sk;
1651}
1652
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001653/*
1654 * Socket options and virtual interface manipulation. The whole
1655 * virtual interface system is a complete heap, but unfortunately
1656 * that's how BSD mrouted happens to think. Maybe one day with a proper
1657 * MOSPF/PIM router set up we can clean this up.
1658 */
1659
David S. Millerb7058842009-09-30 16:12:20 -07001660int ip6_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsigned int optlen)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001661{
Nicolas Dichtel660b26d2013-01-21 06:00:26 +00001662 int ret, parent = 0;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001663 struct mif6ctl vif;
1664 struct mf6cctl mfc;
1665 mifi_t mifi;
Benjamin Thery8229efd2008-12-10 16:30:15 -08001666 struct net *net = sock_net(sk);
Patrick McHardyd1db2752010-05-11 14:40:55 +02001667 struct mr6_table *mrt;
1668
1669 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
Ian Morris63159f22015-03-29 14:00:04 +01001670 if (!mrt)
Patrick McHardyd1db2752010-05-11 14:40:55 +02001671 return -ENOENT;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001672
1673 if (optname != MRT6_INIT) {
Eric W. Biedermanaf31f412012-11-16 03:03:06 +00001674 if (sk != mrt->mroute6_sk && !ns_capable(net->user_ns, CAP_NET_ADMIN))
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001675 return -EACCES;
1676 }
1677
1678 switch (optname) {
1679 case MRT6_INIT:
1680 if (sk->sk_type != SOCK_RAW ||
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001681 inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001682 return -EOPNOTSUPP;
1683 if (optlen < sizeof(int))
1684 return -EINVAL;
1685
Patrick McHardy6bd52142010-05-11 14:40:53 +02001686 return ip6mr_sk_init(mrt, sk);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001687
1688 case MRT6_DONE:
1689 return ip6mr_sk_done(sk);
1690
1691 case MRT6_ADD_MIF:
1692 if (optlen < sizeof(vif))
1693 return -EINVAL;
1694 if (copy_from_user(&vif, optval, sizeof(vif)))
1695 return -EFAULT;
Rami Rosen6ac7eb02008-04-10 12:40:10 +03001696 if (vif.mif6c_mifi >= MAXMIFS)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001697 return -ENFILE;
1698 rtnl_lock();
Patrick McHardy6bd52142010-05-11 14:40:53 +02001699 ret = mif6_add(net, mrt, &vif, sk == mrt->mroute6_sk);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001700 rtnl_unlock();
1701 return ret;
1702
1703 case MRT6_DEL_MIF:
1704 if (optlen < sizeof(mifi_t))
1705 return -EINVAL;
1706 if (copy_from_user(&mifi, optval, sizeof(mifi_t)))
1707 return -EFAULT;
1708 rtnl_lock();
Patrick McHardy6bd52142010-05-11 14:40:53 +02001709 ret = mif6_delete(mrt, mifi, NULL);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001710 rtnl_unlock();
1711 return ret;
1712
1713 /*
1714 * Manipulate the forwarding caches. These live
1715 * in a sort of kernel/user symbiosis.
1716 */
1717 case MRT6_ADD_MFC:
1718 case MRT6_DEL_MFC:
Nicolas Dichtel660b26d2013-01-21 06:00:26 +00001719 parent = -1;
1720 case MRT6_ADD_MFC_PROXY:
1721 case MRT6_DEL_MFC_PROXY:
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001722 if (optlen < sizeof(mfc))
1723 return -EINVAL;
1724 if (copy_from_user(&mfc, optval, sizeof(mfc)))
1725 return -EFAULT;
Nicolas Dichtel660b26d2013-01-21 06:00:26 +00001726 if (parent == 0)
1727 parent = mfc.mf6cc_parent;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001728 rtnl_lock();
Nicolas Dichtel660b26d2013-01-21 06:00:26 +00001729 if (optname == MRT6_DEL_MFC || optname == MRT6_DEL_MFC_PROXY)
1730 ret = ip6mr_mfc_delete(mrt, &mfc, parent);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001731 else
Nicolas Dichtel660b26d2013-01-21 06:00:26 +00001732 ret = ip6mr_mfc_add(net, mrt, &mfc,
1733 sk == mrt->mroute6_sk, parent);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001734 rtnl_unlock();
1735 return ret;
1736
1737 /*
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +09001738 * Control PIM assert (to activate pim will activate assert)
1739 */
1740 case MRT6_ASSERT:
1741 {
1742 int v;
Joe Perches03f52a02012-11-25 18:26:34 +00001743
1744 if (optlen != sizeof(v))
1745 return -EINVAL;
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +09001746 if (get_user(v, (int __user *)optval))
1747 return -EFAULT;
Joe Perches53d68412012-11-25 09:35:30 +00001748 mrt->mroute_do_assert = v;
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +09001749 return 0;
1750 }
1751
1752#ifdef CONFIG_IPV6_PIMSM_V2
1753 case MRT6_PIM:
1754 {
YOSHIFUJI Hideakia9f83bf2008-04-10 15:41:28 +09001755 int v;
Joe Perches03f52a02012-11-25 18:26:34 +00001756
1757 if (optlen != sizeof(v))
1758 return -EINVAL;
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +09001759 if (get_user(v, (int __user *)optval))
1760 return -EFAULT;
1761 v = !!v;
1762 rtnl_lock();
1763 ret = 0;
Patrick McHardy6bd52142010-05-11 14:40:53 +02001764 if (v != mrt->mroute_do_pim) {
1765 mrt->mroute_do_pim = v;
1766 mrt->mroute_do_assert = v;
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +09001767 }
1768 rtnl_unlock();
1769 return ret;
1770 }
1771
1772#endif
Patrick McHardyd1db2752010-05-11 14:40:55 +02001773#ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
1774 case MRT6_TABLE:
1775 {
1776 u32 v;
1777
1778 if (optlen != sizeof(u32))
1779 return -EINVAL;
1780 if (get_user(v, (u32 __user *)optval))
1781 return -EFAULT;
Dan Carpenter75356a82013-01-23 20:38:34 +00001782 /* "pim6reg%u" should not exceed 16 bytes (IFNAMSIZ) */
1783 if (v != RT_TABLE_DEFAULT && v >= 100000000)
1784 return -EINVAL;
Patrick McHardyd1db2752010-05-11 14:40:55 +02001785 if (sk == mrt->mroute6_sk)
1786 return -EBUSY;
1787
1788 rtnl_lock();
1789 ret = 0;
1790 if (!ip6mr_new_table(net, v))
1791 ret = -ENOMEM;
1792 raw6_sk(sk)->ip6mr_table = v;
1793 rtnl_unlock();
1794 return ret;
1795 }
1796#endif
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +09001797 /*
Rami Rosen7d120c52008-04-23 14:35:13 +03001798 * Spurious command, or MRT6_VERSION which you cannot
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001799 * set.
1800 */
1801 default:
1802 return -ENOPROTOOPT;
1803 }
1804}
1805
1806/*
1807 * Getsock opt support for the multicast routing system.
1808 */
1809
1810int ip6_mroute_getsockopt(struct sock *sk, int optname, char __user *optval,
1811 int __user *optlen)
1812{
1813 int olr;
1814 int val;
Benjamin Thery8229efd2008-12-10 16:30:15 -08001815 struct net *net = sock_net(sk);
Patrick McHardyd1db2752010-05-11 14:40:55 +02001816 struct mr6_table *mrt;
1817
1818 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
Ian Morris63159f22015-03-29 14:00:04 +01001819 if (!mrt)
Patrick McHardyd1db2752010-05-11 14:40:55 +02001820 return -ENOENT;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001821
1822 switch (optname) {
1823 case MRT6_VERSION:
1824 val = 0x0305;
1825 break;
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +09001826#ifdef CONFIG_IPV6_PIMSM_V2
1827 case MRT6_PIM:
Patrick McHardy6bd52142010-05-11 14:40:53 +02001828 val = mrt->mroute_do_pim;
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +09001829 break;
1830#endif
1831 case MRT6_ASSERT:
Patrick McHardy6bd52142010-05-11 14:40:53 +02001832 val = mrt->mroute_do_assert;
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +09001833 break;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001834 default:
1835 return -ENOPROTOOPT;
1836 }
1837
1838 if (get_user(olr, optlen))
1839 return -EFAULT;
1840
1841 olr = min_t(int, olr, sizeof(int));
1842 if (olr < 0)
1843 return -EINVAL;
1844
1845 if (put_user(olr, optlen))
1846 return -EFAULT;
1847 if (copy_to_user(optval, &val, olr))
1848 return -EFAULT;
1849 return 0;
1850}
1851
1852/*
1853 * The IP multicast ioctl support routines.
1854 */
1855
1856int ip6mr_ioctl(struct sock *sk, int cmd, void __user *arg)
1857{
1858 struct sioc_sg_req6 sr;
1859 struct sioc_mif_req6 vr;
1860 struct mif_device *vif;
1861 struct mfc6_cache *c;
Benjamin Thery8229efd2008-12-10 16:30:15 -08001862 struct net *net = sock_net(sk);
Patrick McHardyd1db2752010-05-11 14:40:55 +02001863 struct mr6_table *mrt;
1864
1865 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
Ian Morris63159f22015-03-29 14:00:04 +01001866 if (!mrt)
Patrick McHardyd1db2752010-05-11 14:40:55 +02001867 return -ENOENT;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001868
1869 switch (cmd) {
1870 case SIOCGETMIFCNT_IN6:
1871 if (copy_from_user(&vr, arg, sizeof(vr)))
1872 return -EFAULT;
Patrick McHardy6bd52142010-05-11 14:40:53 +02001873 if (vr.mifi >= mrt->maxvif)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001874 return -EINVAL;
1875 read_lock(&mrt_lock);
Patrick McHardy6bd52142010-05-11 14:40:53 +02001876 vif = &mrt->vif6_table[vr.mifi];
1877 if (MIF_EXISTS(mrt, vr.mifi)) {
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001878 vr.icount = vif->pkt_in;
1879 vr.ocount = vif->pkt_out;
1880 vr.ibytes = vif->bytes_in;
1881 vr.obytes = vif->bytes_out;
1882 read_unlock(&mrt_lock);
1883
1884 if (copy_to_user(arg, &vr, sizeof(vr)))
1885 return -EFAULT;
1886 return 0;
1887 }
1888 read_unlock(&mrt_lock);
1889 return -EADDRNOTAVAIL;
1890 case SIOCGETSGCNT_IN6:
1891 if (copy_from_user(&sr, arg, sizeof(sr)))
1892 return -EFAULT;
1893
1894 read_lock(&mrt_lock);
Patrick McHardy6bd52142010-05-11 14:40:53 +02001895 c = ip6mr_cache_find(mrt, &sr.src.sin6_addr, &sr.grp.sin6_addr);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001896 if (c) {
1897 sr.pktcnt = c->mfc_un.res.pkt;
1898 sr.bytecnt = c->mfc_un.res.bytes;
1899 sr.wrong_if = c->mfc_un.res.wrong_if;
1900 read_unlock(&mrt_lock);
1901
1902 if (copy_to_user(arg, &sr, sizeof(sr)))
1903 return -EFAULT;
1904 return 0;
1905 }
1906 read_unlock(&mrt_lock);
1907 return -EADDRNOTAVAIL;
1908 default:
1909 return -ENOIOCTLCMD;
1910 }
1911}
1912
David S. Millere2d57762011-02-03 17:59:32 -08001913#ifdef CONFIG_COMPAT
1914struct compat_sioc_sg_req6 {
1915 struct sockaddr_in6 src;
1916 struct sockaddr_in6 grp;
1917 compat_ulong_t pktcnt;
1918 compat_ulong_t bytecnt;
1919 compat_ulong_t wrong_if;
1920};
1921
1922struct compat_sioc_mif_req6 {
1923 mifi_t mifi;
1924 compat_ulong_t icount;
1925 compat_ulong_t ocount;
1926 compat_ulong_t ibytes;
1927 compat_ulong_t obytes;
1928};
1929
1930int ip6mr_compat_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
1931{
1932 struct compat_sioc_sg_req6 sr;
1933 struct compat_sioc_mif_req6 vr;
1934 struct mif_device *vif;
1935 struct mfc6_cache *c;
1936 struct net *net = sock_net(sk);
1937 struct mr6_table *mrt;
1938
1939 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
Ian Morris63159f22015-03-29 14:00:04 +01001940 if (!mrt)
David S. Millere2d57762011-02-03 17:59:32 -08001941 return -ENOENT;
1942
1943 switch (cmd) {
1944 case SIOCGETMIFCNT_IN6:
1945 if (copy_from_user(&vr, arg, sizeof(vr)))
1946 return -EFAULT;
1947 if (vr.mifi >= mrt->maxvif)
1948 return -EINVAL;
1949 read_lock(&mrt_lock);
1950 vif = &mrt->vif6_table[vr.mifi];
1951 if (MIF_EXISTS(mrt, vr.mifi)) {
1952 vr.icount = vif->pkt_in;
1953 vr.ocount = vif->pkt_out;
1954 vr.ibytes = vif->bytes_in;
1955 vr.obytes = vif->bytes_out;
1956 read_unlock(&mrt_lock);
1957
1958 if (copy_to_user(arg, &vr, sizeof(vr)))
1959 return -EFAULT;
1960 return 0;
1961 }
1962 read_unlock(&mrt_lock);
1963 return -EADDRNOTAVAIL;
1964 case SIOCGETSGCNT_IN6:
1965 if (copy_from_user(&sr, arg, sizeof(sr)))
1966 return -EFAULT;
1967
1968 read_lock(&mrt_lock);
1969 c = ip6mr_cache_find(mrt, &sr.src.sin6_addr, &sr.grp.sin6_addr);
1970 if (c) {
1971 sr.pktcnt = c->mfc_un.res.pkt;
1972 sr.bytecnt = c->mfc_un.res.bytes;
1973 sr.wrong_if = c->mfc_un.res.wrong_if;
1974 read_unlock(&mrt_lock);
1975
1976 if (copy_to_user(arg, &sr, sizeof(sr)))
1977 return -EFAULT;
1978 return 0;
1979 }
1980 read_unlock(&mrt_lock);
1981 return -EADDRNOTAVAIL;
1982 default:
1983 return -ENOIOCTLCMD;
1984 }
1985}
1986#endif
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001987
David Miller7026b1d2015-04-05 22:19:04 -04001988static inline int ip6mr_forward2_finish(struct sock *sk, struct sk_buff *skb)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001989{
Eric Dumazetadf30902009-06-02 05:19:30 +00001990 IP6_INC_STATS_BH(dev_net(skb_dst(skb)->dev), ip6_dst_idev(skb_dst(skb)),
Denis V. Lunev483a47d2008-10-08 11:09:27 -07001991 IPSTATS_MIB_OUTFORWDATAGRAMS);
Vincent Bernat2d8dbb02012-06-05 03:41:42 +00001992 IP6_ADD_STATS_BH(dev_net(skb_dst(skb)->dev), ip6_dst_idev(skb_dst(skb)),
1993 IPSTATS_MIB_OUTOCTETS, skb->len);
David Miller7026b1d2015-04-05 22:19:04 -04001994 return dst_output_sk(sk, skb);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09001995}
1996
1997/*
1998 * Processing handlers for ip6mr_forward
1999 */
2000
Patrick McHardy6bd52142010-05-11 14:40:53 +02002001static int ip6mr_forward2(struct net *net, struct mr6_table *mrt,
2002 struct sk_buff *skb, struct mfc6_cache *c, int vifi)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002003{
2004 struct ipv6hdr *ipv6h;
Patrick McHardy6bd52142010-05-11 14:40:53 +02002005 struct mif_device *vif = &mrt->vif6_table[vifi];
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002006 struct net_device *dev;
2007 struct dst_entry *dst;
David S. Miller4c9483b2011-03-12 16:22:43 -05002008 struct flowi6 fl6;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002009
Ian Morris63159f22015-03-29 14:00:04 +01002010 if (!vif->dev)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002011 goto out_free;
2012
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +09002013#ifdef CONFIG_IPV6_PIMSM_V2
2014 if (vif->flags & MIFF_REGISTER) {
2015 vif->pkt_out++;
2016 vif->bytes_out += skb->len;
Pavel Emelyanovdc58c782008-05-21 14:17:54 -07002017 vif->dev->stats.tx_bytes += skb->len;
2018 vif->dev->stats.tx_packets++;
Patrick McHardy6bd52142010-05-11 14:40:53 +02002019 ip6mr_cache_report(mrt, skb, vifi, MRT6MSG_WHOLEPKT);
Ilpo Järvinen8da73b72008-12-14 23:15:49 -08002020 goto out_free;
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +09002021 }
2022#endif
2023
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002024 ipv6h = ipv6_hdr(skb);
2025
David S. Miller4c9483b2011-03-12 16:22:43 -05002026 fl6 = (struct flowi6) {
2027 .flowi6_oif = vif->link,
2028 .daddr = ipv6h->daddr,
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002029 };
2030
David S. Miller4c9483b2011-03-12 16:22:43 -05002031 dst = ip6_route_output(net, NULL, &fl6);
RongQing.Li5095d642012-02-21 22:10:49 +00002032 if (dst->error) {
2033 dst_release(dst);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002034 goto out_free;
RongQing.Li5095d642012-02-21 22:10:49 +00002035 }
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002036
Eric Dumazetadf30902009-06-02 05:19:30 +00002037 skb_dst_drop(skb);
2038 skb_dst_set(skb, dst);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002039
2040 /*
2041 * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
2042 * not only before forwarding, but after forwarding on all output
2043 * interfaces. It is clear, if mrouter runs a multicasting
2044 * program, it should receive packets not depending to what interface
2045 * program is joined.
2046 * If we will not make it, the program will have to join on all
2047 * interfaces. On the other hand, multihoming host (or router, but
2048 * not mrouter) cannot join to more than one interface - it will
2049 * result in receiving multiple packets.
2050 */
2051 dev = vif->dev;
2052 skb->dev = dev;
2053 vif->pkt_out++;
2054 vif->bytes_out += skb->len;
2055
2056 /* We are about to write */
2057 /* XXX: extension headers? */
2058 if (skb_cow(skb, sizeof(*ipv6h) + LL_RESERVED_SPACE(dev)))
2059 goto out_free;
2060
2061 ipv6h = ipv6_hdr(skb);
2062 ipv6h->hop_limit--;
2063
2064 IP6CB(skb)->flags |= IP6SKB_FORWARDED;
2065
David Miller7026b1d2015-04-05 22:19:04 -04002066 return NF_HOOK(NFPROTO_IPV6, NF_INET_FORWARD, NULL, skb,
2067 skb->dev, dev,
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002068 ip6mr_forward2_finish);
2069
2070out_free:
2071 kfree_skb(skb);
2072 return 0;
2073}
2074
Patrick McHardy6bd52142010-05-11 14:40:53 +02002075static int ip6mr_find_vif(struct mr6_table *mrt, struct net_device *dev)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002076{
2077 int ct;
Patrick McHardy6bd52142010-05-11 14:40:53 +02002078
2079 for (ct = mrt->maxvif - 1; ct >= 0; ct--) {
2080 if (mrt->vif6_table[ct].dev == dev)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002081 break;
2082 }
2083 return ct;
2084}
2085
Rami Rosen2b52c3a2013-07-21 03:00:31 +03002086static void ip6_mr_forward(struct net *net, struct mr6_table *mrt,
2087 struct sk_buff *skb, struct mfc6_cache *cache)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002088{
2089 int psend = -1;
2090 int vif, ct;
Nicolas Dichtel660b26d2013-01-21 06:00:26 +00002091 int true_vifi = ip6mr_find_vif(mrt, skb->dev);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002092
2093 vif = cache->mf6c_parent;
2094 cache->mfc_un.res.pkt++;
2095 cache->mfc_un.res.bytes += skb->len;
2096
Nicolas Dichtel660b26d2013-01-21 06:00:26 +00002097 if (ipv6_addr_any(&cache->mf6c_origin) && true_vifi >= 0) {
2098 struct mfc6_cache *cache_proxy;
2099
Fabian Frederick40dc2ca2014-10-29 10:00:26 +01002100 /* For an (*,G) entry, we only check that the incoming
Nicolas Dichtel660b26d2013-01-21 06:00:26 +00002101 * interface is part of the static tree.
2102 */
2103 cache_proxy = ip6mr_cache_find_any_parent(mrt, vif);
2104 if (cache_proxy &&
2105 cache_proxy->mfc_un.res.ttls[true_vifi] < 255)
2106 goto forward;
2107 }
2108
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +09002109 /*
2110 * Wrong interface: drop packet and (maybe) send PIM assert.
2111 */
Patrick McHardy6bd52142010-05-11 14:40:53 +02002112 if (mrt->vif6_table[vif].dev != skb->dev) {
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +09002113 cache->mfc_un.res.wrong_if++;
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +09002114
Patrick McHardy6bd52142010-05-11 14:40:53 +02002115 if (true_vifi >= 0 && mrt->mroute_do_assert &&
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +09002116 /* pimsm uses asserts, when switching from RPT to SPT,
2117 so that we cannot check that packet arrived on an oif.
2118 It is bad, but otherwise we would need to move pretty
2119 large chunk of pimd to kernel. Ough... --ANK
2120 */
Patrick McHardy6bd52142010-05-11 14:40:53 +02002121 (mrt->mroute_do_pim ||
Benjamin Therya21f3f92008-12-10 16:28:44 -08002122 cache->mfc_un.res.ttls[true_vifi] < 255) &&
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +09002123 time_after(jiffies,
2124 cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
2125 cache->mfc_un.res.last_assert = jiffies;
Patrick McHardy6bd52142010-05-11 14:40:53 +02002126 ip6mr_cache_report(mrt, skb, true_vifi, MRT6MSG_WRONGMIF);
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +09002127 }
2128 goto dont_forward;
2129 }
2130
Nicolas Dichtel660b26d2013-01-21 06:00:26 +00002131forward:
Patrick McHardy6bd52142010-05-11 14:40:53 +02002132 mrt->vif6_table[vif].pkt_in++;
2133 mrt->vif6_table[vif].bytes_in += skb->len;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002134
2135 /*
2136 * Forward the frame
2137 */
Nicolas Dichtel660b26d2013-01-21 06:00:26 +00002138 if (ipv6_addr_any(&cache->mf6c_origin) &&
2139 ipv6_addr_any(&cache->mf6c_mcastgrp)) {
2140 if (true_vifi >= 0 &&
2141 true_vifi != cache->mf6c_parent &&
2142 ipv6_hdr(skb)->hop_limit >
2143 cache->mfc_un.res.ttls[cache->mf6c_parent]) {
2144 /* It's an (*,*) entry and the packet is not coming from
2145 * the upstream: forward the packet to the upstream
2146 * only.
2147 */
2148 psend = cache->mf6c_parent;
2149 goto last_forward;
2150 }
2151 goto dont_forward;
2152 }
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002153 for (ct = cache->mfc_un.res.maxvif - 1; ct >= cache->mfc_un.res.minvif; ct--) {
Nicolas Dichtel660b26d2013-01-21 06:00:26 +00002154 /* For (*,G) entry, don't forward to the incoming interface */
2155 if ((!ipv6_addr_any(&cache->mf6c_origin) || ct != true_vifi) &&
2156 ipv6_hdr(skb)->hop_limit > cache->mfc_un.res.ttls[ct]) {
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002157 if (psend != -1) {
2158 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
2159 if (skb2)
Patrick McHardy6bd52142010-05-11 14:40:53 +02002160 ip6mr_forward2(net, mrt, skb2, cache, psend);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002161 }
2162 psend = ct;
2163 }
2164 }
Nicolas Dichtel660b26d2013-01-21 06:00:26 +00002165last_forward:
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002166 if (psend != -1) {
Patrick McHardy6bd52142010-05-11 14:40:53 +02002167 ip6mr_forward2(net, mrt, skb, cache, psend);
Rami Rosen2b52c3a2013-07-21 03:00:31 +03002168 return;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002169 }
2170
YOSHIFUJI Hideaki14fb64e2008-04-03 09:22:54 +09002171dont_forward:
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002172 kfree_skb(skb);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002173}
2174
2175
2176/*
2177 * Multicast packets for forwarding arrive here
2178 */
2179
2180int ip6_mr_input(struct sk_buff *skb)
2181{
2182 struct mfc6_cache *cache;
Benjamin Thery8229efd2008-12-10 16:30:15 -08002183 struct net *net = dev_net(skb->dev);
Patrick McHardyd1db2752010-05-11 14:40:55 +02002184 struct mr6_table *mrt;
David S. Miller4c9483b2011-03-12 16:22:43 -05002185 struct flowi6 fl6 = {
2186 .flowi6_iif = skb->dev->ifindex,
2187 .flowi6_mark = skb->mark,
Patrick McHardyd1db2752010-05-11 14:40:55 +02002188 };
2189 int err;
2190
David S. Miller4c9483b2011-03-12 16:22:43 -05002191 err = ip6mr_fib_lookup(net, &fl6, &mrt);
Ben Greear2015de52011-09-27 15:16:08 -04002192 if (err < 0) {
2193 kfree_skb(skb);
Patrick McHardyd1db2752010-05-11 14:40:55 +02002194 return err;
Ben Greear2015de52011-09-27 15:16:08 -04002195 }
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002196
2197 read_lock(&mrt_lock);
Patrick McHardy6bd52142010-05-11 14:40:53 +02002198 cache = ip6mr_cache_find(mrt,
Benjamin Thery8229efd2008-12-10 16:30:15 -08002199 &ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr);
Ian Morris63159f22015-03-29 14:00:04 +01002200 if (!cache) {
Nicolas Dichtel660b26d2013-01-21 06:00:26 +00002201 int vif = ip6mr_find_vif(mrt, skb->dev);
2202
2203 if (vif >= 0)
2204 cache = ip6mr_cache_find_any(mrt,
2205 &ipv6_hdr(skb)->daddr,
2206 vif);
2207 }
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002208
2209 /*
2210 * No usable cache entry
2211 */
Ian Morris63159f22015-03-29 14:00:04 +01002212 if (!cache) {
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002213 int vif;
2214
Patrick McHardy6bd52142010-05-11 14:40:53 +02002215 vif = ip6mr_find_vif(mrt, skb->dev);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002216 if (vif >= 0) {
Patrick McHardy6bd52142010-05-11 14:40:53 +02002217 int err = ip6mr_cache_unresolved(mrt, vif, skb);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002218 read_unlock(&mrt_lock);
2219
2220 return err;
2221 }
2222 read_unlock(&mrt_lock);
2223 kfree_skb(skb);
2224 return -ENODEV;
2225 }
2226
Patrick McHardy6bd52142010-05-11 14:40:53 +02002227 ip6_mr_forward(net, mrt, skb, cache);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002228
2229 read_unlock(&mrt_lock);
2230
2231 return 0;
2232}
2233
2234
Patrick McHardy5b285ca2010-05-11 14:40:56 +02002235static int __ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb,
2236 struct mfc6_cache *c, struct rtmsg *rtm)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002237{
2238 int ct;
2239 struct rtnexthop *nhp;
Nicolas Dichtel70b386a2012-12-04 01:13:36 +00002240 struct nlattr *mp_attr;
Nicolas Dichteladfa85e2012-12-04 01:13:37 +00002241 struct rta_mfc_stats mfcs;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002242
Nicolas Dichtel74381892010-03-25 23:45:35 +00002243 /* If cache is unresolved, don't try to parse IIF and OIF */
Dan Carpentered0f160a2010-05-26 00:38:56 -07002244 if (c->mf6c_parent >= MAXMIFS)
Nicolas Dichtel74381892010-03-25 23:45:35 +00002245 return -ENOENT;
2246
Thomas Graf74a0bd72012-06-26 23:36:14 +00002247 if (MIF_EXISTS(mrt, c->mf6c_parent) &&
2248 nla_put_u32(skb, RTA_IIF, mrt->vif6_table[c->mf6c_parent].dev->ifindex) < 0)
2249 return -EMSGSIZE;
Nicolas Dichtel70b386a2012-12-04 01:13:36 +00002250 mp_attr = nla_nest_start(skb, RTA_MULTIPATH);
Ian Morris63159f22015-03-29 14:00:04 +01002251 if (!mp_attr)
Nicolas Dichtel70b386a2012-12-04 01:13:36 +00002252 return -EMSGSIZE;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002253
2254 for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
Patrick McHardy6bd52142010-05-11 14:40:53 +02002255 if (MIF_EXISTS(mrt, ct) && c->mfc_un.res.ttls[ct] < 255) {
Nicolas Dichtel70b386a2012-12-04 01:13:36 +00002256 nhp = nla_reserve_nohdr(skb, sizeof(*nhp));
Ian Morris63159f22015-03-29 14:00:04 +01002257 if (!nhp) {
Nicolas Dichtel70b386a2012-12-04 01:13:36 +00002258 nla_nest_cancel(skb, mp_attr);
2259 return -EMSGSIZE;
2260 }
2261
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002262 nhp->rtnh_flags = 0;
2263 nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
Patrick McHardy6bd52142010-05-11 14:40:53 +02002264 nhp->rtnh_ifindex = mrt->vif6_table[ct].dev->ifindex;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002265 nhp->rtnh_len = sizeof(*nhp);
2266 }
2267 }
Nicolas Dichtel70b386a2012-12-04 01:13:36 +00002268
2269 nla_nest_end(skb, mp_attr);
2270
Nicolas Dichteladfa85e2012-12-04 01:13:37 +00002271 mfcs.mfcs_packets = c->mfc_un.res.pkt;
2272 mfcs.mfcs_bytes = c->mfc_un.res.bytes;
2273 mfcs.mfcs_wrong_if = c->mfc_un.res.wrong_if;
2274 if (nla_put(skb, RTA_MFC_STATS, sizeof(mfcs), &mfcs) < 0)
2275 return -EMSGSIZE;
2276
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002277 rtm->rtm_type = RTN_MULTICAST;
2278 return 1;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002279}
2280
Benjamin Thery8229efd2008-12-10 16:30:15 -08002281int ip6mr_get_route(struct net *net,
2282 struct sk_buff *skb, struct rtmsg *rtm, int nowait)
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002283{
2284 int err;
Patrick McHardyd1db2752010-05-11 14:40:55 +02002285 struct mr6_table *mrt;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002286 struct mfc6_cache *cache;
Eric Dumazetadf30902009-06-02 05:19:30 +00002287 struct rt6_info *rt = (struct rt6_info *)skb_dst(skb);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002288
Patrick McHardyd1db2752010-05-11 14:40:55 +02002289 mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
Ian Morris63159f22015-03-29 14:00:04 +01002290 if (!mrt)
Patrick McHardyd1db2752010-05-11 14:40:55 +02002291 return -ENOENT;
2292
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002293 read_lock(&mrt_lock);
Patrick McHardy6bd52142010-05-11 14:40:53 +02002294 cache = ip6mr_cache_find(mrt, &rt->rt6i_src.addr, &rt->rt6i_dst.addr);
Nicolas Dichtel660b26d2013-01-21 06:00:26 +00002295 if (!cache && skb->dev) {
2296 int vif = ip6mr_find_vif(mrt, skb->dev);
2297
2298 if (vif >= 0)
2299 cache = ip6mr_cache_find_any(mrt, &rt->rt6i_dst.addr,
2300 vif);
2301 }
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002302
2303 if (!cache) {
2304 struct sk_buff *skb2;
2305 struct ipv6hdr *iph;
2306 struct net_device *dev;
2307 int vif;
2308
2309 if (nowait) {
2310 read_unlock(&mrt_lock);
2311 return -EAGAIN;
2312 }
2313
2314 dev = skb->dev;
Ian Morris63159f22015-03-29 14:00:04 +01002315 if (!dev || (vif = ip6mr_find_vif(mrt, dev)) < 0) {
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002316 read_unlock(&mrt_lock);
2317 return -ENODEV;
2318 }
2319
2320 /* really correct? */
2321 skb2 = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC);
2322 if (!skb2) {
2323 read_unlock(&mrt_lock);
2324 return -ENOMEM;
2325 }
2326
2327 skb_reset_transport_header(skb2);
2328
2329 skb_put(skb2, sizeof(struct ipv6hdr));
2330 skb_reset_network_header(skb2);
2331
2332 iph = ipv6_hdr(skb2);
2333 iph->version = 0;
2334 iph->priority = 0;
2335 iph->flow_lbl[0] = 0;
2336 iph->flow_lbl[1] = 0;
2337 iph->flow_lbl[2] = 0;
2338 iph->payload_len = 0;
2339 iph->nexthdr = IPPROTO_NONE;
2340 iph->hop_limit = 0;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00002341 iph->saddr = rt->rt6i_src.addr;
2342 iph->daddr = rt->rt6i_dst.addr;
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002343
Patrick McHardy6bd52142010-05-11 14:40:53 +02002344 err = ip6mr_cache_unresolved(mrt, vif, skb2);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002345 read_unlock(&mrt_lock);
2346
2347 return err;
2348 }
2349
2350 if (!nowait && (rtm->rtm_flags&RTM_F_NOTIFY))
2351 cache->mfc_flags |= MFC_NOTIFY;
2352
Patrick McHardy5b285ca2010-05-11 14:40:56 +02002353 err = __ip6mr_fill_mroute(mrt, skb, cache, rtm);
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +09002354 read_unlock(&mrt_lock);
2355 return err;
2356}
2357
Patrick McHardy5b285ca2010-05-11 14:40:56 +02002358static int ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb,
Nicolas Dichtelf5183382014-03-19 17:47:51 +01002359 u32 portid, u32 seq, struct mfc6_cache *c, int cmd,
2360 int flags)
Patrick McHardy5b285ca2010-05-11 14:40:56 +02002361{
2362 struct nlmsghdr *nlh;
2363 struct rtmsg *rtm;
Nicolas Dichtel1eb99af2012-12-04 01:13:39 +00002364 int err;
Patrick McHardy5b285ca2010-05-11 14:40:56 +02002365
Nicolas Dichtelf5183382014-03-19 17:47:51 +01002366 nlh = nlmsg_put(skb, portid, seq, cmd, sizeof(*rtm), flags);
Ian Morris63159f22015-03-29 14:00:04 +01002367 if (!nlh)
Patrick McHardy5b285ca2010-05-11 14:40:56 +02002368 return -EMSGSIZE;
2369
2370 rtm = nlmsg_data(nlh);
Nicolas Dichtel193c1e42012-12-04 01:01:49 +00002371 rtm->rtm_family = RTNL_FAMILY_IP6MR;
Patrick McHardy5b285ca2010-05-11 14:40:56 +02002372 rtm->rtm_dst_len = 128;
2373 rtm->rtm_src_len = 128;
2374 rtm->rtm_tos = 0;
2375 rtm->rtm_table = mrt->id;
David S. Millerc78679e2012-04-01 20:27:33 -04002376 if (nla_put_u32(skb, RTA_TABLE, mrt->id))
2377 goto nla_put_failure;
Nicolas Dichtel1eb99af2012-12-04 01:13:39 +00002378 rtm->rtm_type = RTN_MULTICAST;
Patrick McHardy5b285ca2010-05-11 14:40:56 +02002379 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
Nicolas Dichtel9a68ac72012-12-04 01:13:38 +00002380 if (c->mfc_flags & MFC_STATIC)
2381 rtm->rtm_protocol = RTPROT_STATIC;
2382 else
2383 rtm->rtm_protocol = RTPROT_MROUTED;
Patrick McHardy5b285ca2010-05-11 14:40:56 +02002384 rtm->rtm_flags = 0;
2385
Jiri Benc930345e2015-03-29 16:59:25 +02002386 if (nla_put_in6_addr(skb, RTA_SRC, &c->mf6c_origin) ||
2387 nla_put_in6_addr(skb, RTA_DST, &c->mf6c_mcastgrp))
David S. Millerc78679e2012-04-01 20:27:33 -04002388 goto nla_put_failure;
Nicolas Dichtel1eb99af2012-12-04 01:13:39 +00002389 err = __ip6mr_fill_mroute(mrt, skb, c, rtm);
2390 /* do not break the dump if cache is unresolved */
2391 if (err < 0 && err != -ENOENT)
Patrick McHardy5b285ca2010-05-11 14:40:56 +02002392 goto nla_put_failure;
2393
Johannes Berg053c0952015-01-16 22:09:00 +01002394 nlmsg_end(skb, nlh);
2395 return 0;
Patrick McHardy5b285ca2010-05-11 14:40:56 +02002396
2397nla_put_failure:
2398 nlmsg_cancel(skb, nlh);
2399 return -EMSGSIZE;
2400}
2401
Nicolas Dichtel812e44d2012-12-04 01:13:41 +00002402static int mr6_msgsize(bool unresolved, int maxvif)
2403{
2404 size_t len =
2405 NLMSG_ALIGN(sizeof(struct rtmsg))
2406 + nla_total_size(4) /* RTA_TABLE */
2407 + nla_total_size(sizeof(struct in6_addr)) /* RTA_SRC */
2408 + nla_total_size(sizeof(struct in6_addr)) /* RTA_DST */
2409 ;
2410
2411 if (!unresolved)
2412 len = len
2413 + nla_total_size(4) /* RTA_IIF */
2414 + nla_total_size(0) /* RTA_MULTIPATH */
2415 + maxvif * NLA_ALIGN(sizeof(struct rtnexthop))
2416 /* RTA_MFC_STATS */
2417 + nla_total_size(sizeof(struct rta_mfc_stats))
2418 ;
2419
2420 return len;
2421}
2422
2423static void mr6_netlink_event(struct mr6_table *mrt, struct mfc6_cache *mfc,
2424 int cmd)
2425{
2426 struct net *net = read_pnet(&mrt->net);
2427 struct sk_buff *skb;
2428 int err = -ENOBUFS;
2429
2430 skb = nlmsg_new(mr6_msgsize(mfc->mf6c_parent >= MAXMIFS, mrt->maxvif),
2431 GFP_ATOMIC);
Ian Morris63159f22015-03-29 14:00:04 +01002432 if (!skb)
Nicolas Dichtel812e44d2012-12-04 01:13:41 +00002433 goto errout;
2434
Nicolas Dichtelf5183382014-03-19 17:47:51 +01002435 err = ip6mr_fill_mroute(mrt, skb, 0, 0, mfc, cmd, 0);
Nicolas Dichtel812e44d2012-12-04 01:13:41 +00002436 if (err < 0)
2437 goto errout;
2438
2439 rtnl_notify(skb, net, 0, RTNLGRP_IPV6_MROUTE, NULL, GFP_ATOMIC);
2440 return;
2441
2442errout:
2443 kfree_skb(skb);
2444 if (err < 0)
2445 rtnl_set_sk_err(net, RTNLGRP_IPV6_MROUTE, err);
2446}
2447
Patrick McHardy5b285ca2010-05-11 14:40:56 +02002448static int ip6mr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb)
2449{
2450 struct net *net = sock_net(skb->sk);
2451 struct mr6_table *mrt;
2452 struct mfc6_cache *mfc;
2453 unsigned int t = 0, s_t;
2454 unsigned int h = 0, s_h;
2455 unsigned int e = 0, s_e;
2456
2457 s_t = cb->args[0];
2458 s_h = cb->args[1];
2459 s_e = cb->args[2];
2460
2461 read_lock(&mrt_lock);
2462 ip6mr_for_each_table(mrt, net) {
2463 if (t < s_t)
2464 goto next_table;
2465 if (t > s_t)
2466 s_h = 0;
2467 for (h = s_h; h < MFC6_LINES; h++) {
2468 list_for_each_entry(mfc, &mrt->mfc6_cache_array[h], list) {
2469 if (e < s_e)
2470 goto next_entry;
2471 if (ip6mr_fill_mroute(mrt, skb,
Eric W. Biederman15e47302012-09-07 20:12:54 +00002472 NETLINK_CB(cb->skb).portid,
Patrick McHardy5b285ca2010-05-11 14:40:56 +02002473 cb->nlh->nlmsg_seq,
Nicolas Dichtelf5183382014-03-19 17:47:51 +01002474 mfc, RTM_NEWROUTE,
2475 NLM_F_MULTI) < 0)
Patrick McHardy5b285ca2010-05-11 14:40:56 +02002476 goto done;
2477next_entry:
2478 e++;
2479 }
2480 e = s_e = 0;
2481 }
Nicolas Dichtel1eb99af2012-12-04 01:13:39 +00002482 spin_lock_bh(&mfc_unres_lock);
2483 list_for_each_entry(mfc, &mrt->mfc6_unres_queue, list) {
2484 if (e < s_e)
2485 goto next_entry2;
2486 if (ip6mr_fill_mroute(mrt, skb,
2487 NETLINK_CB(cb->skb).portid,
2488 cb->nlh->nlmsg_seq,
Nicolas Dichtelf5183382014-03-19 17:47:51 +01002489 mfc, RTM_NEWROUTE,
2490 NLM_F_MULTI) < 0) {
Nicolas Dichtel1eb99af2012-12-04 01:13:39 +00002491 spin_unlock_bh(&mfc_unres_lock);
2492 goto done;
2493 }
2494next_entry2:
2495 e++;
2496 }
2497 spin_unlock_bh(&mfc_unres_lock);
2498 e = s_e = 0;
Patrick McHardy5b285ca2010-05-11 14:40:56 +02002499 s_h = 0;
2500next_table:
2501 t++;
2502 }
2503done:
2504 read_unlock(&mrt_lock);
2505
2506 cb->args[2] = e;
2507 cb->args[1] = h;
2508 cb->args[0] = t;
2509
2510 return skb->len;
2511}