projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ipv6: make ip6_rt_gc_expire an atomic_t
[linux-block.git] / net / ipv6 / ip6mr.c
CommitLineData
2874c5fd 1// SPDX-License-Identifier: GPL-2.0-or-later
7bc570c8
YH		 2/*
3 * Linux IPv6 multicast routing support for BSD pim6sd
4 * Based on net/ipv4/ipmr.c.
5 *
6 * (c) 2004 Mickael Hoerdt, <hoerdt@clarinet.u-strasbg.fr>
7 * LSIIT Laboratory, Strasbourg, France
8 * (c) 2004 Jean-Philippe Andriot, <jean-philippe.andriot@6WIND.com>
9 * 6WIND, Paris, France
10 * Copyright (C)2007,2008 USAGI/WIDE Project
11 * YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
7bc570c8
YH		 12 */
13
7c0f6ba6 14#include <linux/uaccess.h>
7bc570c8
YH		 15#include <linux/types.h>
16#include <linux/sched.h>
17#include <linux/errno.h>
7bc570c8
YH		 18#include <linux/mm.h>
19#include <linux/kernel.h>
20#include <linux/fcntl.h>
21#include <linux/stat.h>
22#include <linux/socket.h>
7bc570c8
YH		 23#include <linux/inet.h>
24#include <linux/netdevice.h>
25#include <linux/inetdevice.h>
7bc570c8
YH		 26#include <linux/proc_fs.h>
27#include <linux/seq_file.h>
7bc570c8 28#include <linux/init.h>
e2d57766 29#include <linux/compat.h>
0eb71a9d 30#include <linux/rhashtable.h>
7bc570c8
YH		 31#include <net/protocol.h>
32#include <linux/skbuff.h>
7bc570c8 33#include <net/raw.h>
7bc570c8
YH		 34#include <linux/notifier.h>
35#include <linux/if_arp.h>
7bc570c8
YH		 36#include <net/checksum.h>
37#include <net/netlink.h>
d1db275d 38#include <net/fib_rules.h>
7bc570c8
YH		 39
40#include <net/ipv6.h>
41#include <net/ip6_route.h>
42#include <linux/mroute6.h>
14fb64e1 43#include <linux/pim.h>
7bc570c8
YH		 44#include <net/addrconf.h>
45#include <linux/netfilter_ipv6.h>
bc3b2d7f 46#include <linux/export.h>
5d6e430d 47#include <net/ip6_checksum.h>
d67b8c61 48#include <linux/netconf.h>
cb9f1b78 49#include <net/ip_tunnels.h>
7bc570c8 50
69d2c867
GS		 51#include <linux/nospec.h>
52
d1db275d
PM		 53struct ip6mr_rule {
54 struct fib_rule common;
55};
56
57struct ip6mr_result {
b70432f7 58 struct mr_table *mrt;
d1db275d
PM		 59};
60
7bc570c8
YH		 61/* Big lock, protecting vif table, mrt cache and mroute socket state.
62 Note that the changes are semaphored via rtnl_lock.
63 */
64
65static DEFINE_RWLOCK(mrt_lock);
66
b70432f7 67/* Multicast router control variables */
7bc570c8 68
7bc570c8
YH		 69/* Special spinlock for queue of unresolved entries */
70static DEFINE_SPINLOCK(mfc_unres_lock);
71
72/* We return to original Alan's scheme. Hash table of resolved
73 entries is changed only in process context and protected
74 with weak lock mrt_lock. Queue of unresolved entries is protected
75 with strong spinlock mfc_unres_lock.
76
77 In this case data path is free of exclusive locks at all.
78 */
79
80static struct kmem_cache *mrt_cachep __read_mostly;
81
b70432f7
YM		 82static struct mr_table *ip6mr_new_table(struct net *net, u32 id);
83static void ip6mr_free_table(struct mr_table *mrt);
d1db275d 84
b70432f7 85static void ip6_mr_forward(struct net *net, struct mr_table *mrt,
e4a38c0c
PR		 86 struct net_device *dev, struct sk_buff *skb,
87 struct mfc6_cache *cache);
b70432f7 88static int ip6mr_cache_report(struct mr_table *mrt, struct sk_buff *pkt,
8229efda 89 mifi_t mifi, int assert);
b70432f7 90static void mr6_netlink_event(struct mr_table *mrt, struct mfc6_cache *mfc,
812e44dd 91 int cmd);
b70432f7 92static void mrt6msg_netlink_event(struct mr_table *mrt, struct sk_buff *pkt);
5b285cac
PM		 93static int ip6mr_rtm_dumproute(struct sk_buff *skb,
94 struct netlink_callback *cb);
ca8d4794 95static void mroute_clean_tables(struct mr_table *mrt, int flags);
e99e88a9 96static void ipmr_expire_process(struct timer_list *t);
d1db275d
PM		 97
98#ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
8ffb335e 99#define ip6mr_for_each_table(mrt, net) \
28b380e2 100 list_for_each_entry_rcu(mrt, &net->ipv6.mr6_tables, list, \
b6dd5acd
MB		 101 lockdep_rtnl_is_held() || \
102 list_empty(&net->ipv6.mr6_tables))
d1db275d 103
7b0db857
YM		 104static struct mr_table *ip6mr_mr_table_iter(struct net *net,
105 struct mr_table *mrt)
106{
107 struct mr_table *ret;
108
109 if (!mrt)
110 ret = list_entry_rcu(net->ipv6.mr6_tables.next,
111 struct mr_table, list);
112 else
113 ret = list_entry_rcu(mrt->list.next,
114 struct mr_table, list);
115
116 if (&ret->list == &net->ipv6.mr6_tables)
117 return NULL;
118 return ret;
119}
120
b70432f7 121static struct mr_table *ip6mr_get_table(struct net *net, u32 id)
d1db275d 122{
b70432f7 123 struct mr_table *mrt;
d1db275d
PM		 124
125 ip6mr_for_each_table(mrt, net) {
126 if (mrt->id == id)
127 return mrt;
128 }
129 return NULL;
130}
131
4c9483b2 132static int ip6mr_fib_lookup(struct net *net, struct flowi6 *flp6,
b70432f7 133 struct mr_table **mrt)
d1db275d 134{
d1db275d 135 int err;
95f4a45d
HFS		 136 struct ip6mr_result res;
137 struct fib_lookup_arg arg = {
138 .result = &res,
139 .flags = FIB_LOOKUP_NOREF,
140 };
d1db275d 141
e4a38c0c
PR		 142 /* update flow if oif or iif point to device enslaved to l3mdev */
143 l3mdev_update_flow(net, flowi6_to_flowi(flp6));
144
4c9483b2
DM		 145 err = fib_rules_lookup(net->ipv6.mr6_rules_ops,
146 flowi6_to_flowi(flp6), 0, &arg);
d1db275d
PM		 147 if (err < 0)
148 return err;
149 *mrt = res.mrt;
150 return 0;
151}
152
153static int ip6mr_rule_action(struct fib_rule *rule, struct flowi *flp,
154 int flags, struct fib_lookup_arg *arg)
155{
156 struct ip6mr_result *res = arg->result;
b70432f7 157 struct mr_table *mrt;
d1db275d
PM		 158
159 switch (rule->action) {
160 case FR_ACT_TO_TBL:
161 break;
162 case FR_ACT_UNREACHABLE:
163 return -ENETUNREACH;
164 case FR_ACT_PROHIBIT:
165 return -EACCES;
166 case FR_ACT_BLACKHOLE:
167 default:
168 return -EINVAL;
169 }
170
e4a38c0c
PR		 171 arg->table = fib_rule_get_table(rule, arg);
172
173 mrt = ip6mr_get_table(rule->fr_net, arg->table);
63159f29 174 if (!mrt)
d1db275d
PM		 175 return -EAGAIN;
176 res->mrt = mrt;
177 return 0;
178}
179
180static int ip6mr_rule_match(struct fib_rule *rule, struct flowi *flp, int flags)
181{
182 return 1;
183}
184
d1db275d 185static int ip6mr_rule_configure(struct fib_rule *rule, struct sk_buff *skb,
b16fb418
RP		 186 struct fib_rule_hdr *frh, struct nlattr **tb,
187 struct netlink_ext_ack *extack)
d1db275d
PM		 188{
189 return 0;
190}
191
192static int ip6mr_rule_compare(struct fib_rule *rule, struct fib_rule_hdr *frh,
193 struct nlattr **tb)
194{
195 return 1;
196}
197
198static int ip6mr_rule_fill(struct fib_rule *rule, struct sk_buff *skb,
199 struct fib_rule_hdr *frh)
200{
201 frh->dst_len = 0;
202 frh->src_len = 0;
203 frh->tos = 0;
204 return 0;
205}
206
04a6f82c 207static const struct fib_rules_ops __net_initconst ip6mr_rules_ops_template = {
d1db275d
PM		 208 .family = RTNL_FAMILY_IP6MR,
209 .rule_size = sizeof(struct ip6mr_rule),
210 .addr_size = sizeof(struct in6_addr),
211 .action = ip6mr_rule_action,
212 .match = ip6mr_rule_match,
213 .configure = ip6mr_rule_configure,
214 .compare = ip6mr_rule_compare,
d1db275d
PM		 215 .fill = ip6mr_rule_fill,
216 .nlgroup = RTNLGRP_IPV6_RULE,
d1db275d
PM		 217 .owner = THIS_MODULE,
218};
219
220static int __net_init ip6mr_rules_init(struct net *net)
221{
222 struct fib_rules_ops *ops;
b70432f7 223 struct mr_table *mrt;
d1db275d
PM		 224 int err;
225
226 ops = fib_rules_register(&ip6mr_rules_ops_template, net);
227 if (IS_ERR(ops))
228 return PTR_ERR(ops);
229
230 INIT_LIST_HEAD(&net->ipv6.mr6_tables);
231
232 mrt = ip6mr_new_table(net, RT6_TABLE_DFLT);
e783bb00
SD		 233 if (IS_ERR(mrt)) {
234 err = PTR_ERR(mrt);
d1db275d
PM		 235 goto err1;
236 }
237
238 err = fib_default_rule_add(ops, 0x7fff, RT6_TABLE_DFLT, 0);
239 if (err < 0)
240 goto err2;
241
242 net->ipv6.mr6_rules_ops = ops;
243 return 0;
244
245err2:
5611a006 246 rtnl_lock();
f243e5a7 247 ip6mr_free_table(mrt);
5611a006 248 rtnl_unlock();
d1db275d
PM		 249err1:
250 fib_rules_unregister(ops);
251 return err;
252}
253
254static void __net_exit ip6mr_rules_exit(struct net *net)
255{
b70432f7 256 struct mr_table *mrt, *next;
d1db275d 257
e2f736b7 258 ASSERT_RTNL();
035320d5
ED		 259 list_for_each_entry_safe(mrt, next, &net->ipv6.mr6_tables, list) {
260 list_del(&mrt->list);
d1db275d 261 ip6mr_free_table(mrt);
035320d5 262 }
d1db275d
PM		 263 fib_rules_unregister(net->ipv6.mr6_rules_ops);
264}
088aa3ee 265
b7a59557
JP		 266static int ip6mr_rules_dump(struct net *net, struct notifier_block *nb,
267 struct netlink_ext_ack *extack)
088aa3ee 268{
b7a59557 269 return fib_rules_dump(net, nb, RTNL_FAMILY_IP6MR, extack);
088aa3ee
YM		 270}
271
272static unsigned int ip6mr_rules_seq_read(struct net *net)
273{
274 return fib_rules_seq_read(net, RTNL_FAMILY_IP6MR);
275}
d3c07e5b
YM		 276
277bool ip6mr_rule_default(const struct fib_rule *rule)
278{
279 return fib_rule_matchall(rule) && rule->action == FR_ACT_TO_TBL &&
280 rule->table == RT6_TABLE_DFLT && !rule->l3mdev;
281}
282EXPORT_SYMBOL(ip6mr_rule_default);
d1db275d
PM		 283#else
284#define ip6mr_for_each_table(mrt, net) \
285 for (mrt = net->ipv6.mrt6; mrt; mrt = NULL)
286
7b0db857
YM		 287static struct mr_table *ip6mr_mr_table_iter(struct net *net,
288 struct mr_table *mrt)
289{
290 if (!mrt)
291 return net->ipv6.mrt6;
292 return NULL;
293}
294
b70432f7 295static struct mr_table *ip6mr_get_table(struct net *net, u32 id)
d1db275d
PM		 296{
297 return net->ipv6.mrt6;
298}
299
4c9483b2 300static int ip6mr_fib_lookup(struct net *net, struct flowi6 *flp6,
b70432f7 301 struct mr_table **mrt)
d1db275d
PM		 302{
303 *mrt = net->ipv6.mrt6;
304 return 0;
305}
306
307static int __net_init ip6mr_rules_init(struct net *net)
308{
e783bb00
SD		 309 struct mr_table *mrt;
310
311 mrt = ip6mr_new_table(net, RT6_TABLE_DFLT);
312 if (IS_ERR(mrt))
313 return PTR_ERR(mrt);
314 net->ipv6.mrt6 = mrt;
315 return 0;
d1db275d
PM		 316}
317
318static void __net_exit ip6mr_rules_exit(struct net *net)
319{
e2f736b7 320 ASSERT_RTNL();
d1db275d 321 ip6mr_free_table(net->ipv6.mrt6);
905a6f96 322 net->ipv6.mrt6 = NULL;
d1db275d 323}
088aa3ee 324
b7a59557
JP		 325static int ip6mr_rules_dump(struct net *net, struct notifier_block *nb,
326 struct netlink_ext_ack *extack)
088aa3ee
YM		 327{
328 return 0;
329}
330
331static unsigned int ip6mr_rules_seq_read(struct net *net)
332{
333 return 0;
334}
d1db275d
PM		 335#endif
336
87c418bf
YM		 337static int ip6mr_hash_cmp(struct rhashtable_compare_arg *arg,
338 const void *ptr)
339{
340 const struct mfc6_cache_cmp_arg *cmparg = arg->key;
341 struct mfc6_cache *c = (struct mfc6_cache *)ptr;
342
343 return !ipv6_addr_equal(&c->mf6c_mcastgrp, &cmparg->mf6c_mcastgrp) ||
344 !ipv6_addr_equal(&c->mf6c_origin, &cmparg->mf6c_origin);
345}
346
347static const struct rhashtable_params ip6mr_rht_params = {
494fff56 348 .head_offset = offsetof(struct mr_mfc, mnode),
87c418bf
YM		 349 .key_offset = offsetof(struct mfc6_cache, cmparg),
350 .key_len = sizeof(struct mfc6_cache_cmp_arg),
351 .nelem_hint = 3,
87c418bf
YM		 352 .obj_cmpfn = ip6mr_hash_cmp,
353 .automatic_shrinking = true,
354};
355
0bbbf0e7
YM		 356static void ip6mr_new_table_set(struct mr_table *mrt,
357 struct net *net)
358{
359#ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
360 list_add_tail_rcu(&mrt->list, &net->ipv6.mr6_tables);
361#endif
362}
363
845c9a7a
YM		 364static struct mfc6_cache_cmp_arg ip6mr_mr_table_ops_cmparg_any = {
365 .mf6c_origin = IN6ADDR_ANY_INIT,
366 .mf6c_mcastgrp = IN6ADDR_ANY_INIT,
367};
368
369static struct mr_table_ops ip6mr_mr_table_ops = {
370 .rht_params = &ip6mr_rht_params,
371 .cmparg_any = &ip6mr_mr_table_ops_cmparg_any,
372};
373
b70432f7 374static struct mr_table *ip6mr_new_table(struct net *net, u32 id)
d1db275d 375{
b70432f7 376 struct mr_table *mrt;
d1db275d
PM		 377
378 mrt = ip6mr_get_table(net, id);
53b24b8f 379 if (mrt)
d1db275d
PM		 380 return mrt;
381
845c9a7a 382 return mr_table_alloc(net, id, &ip6mr_mr_table_ops,
0bbbf0e7 383 ipmr_expire_process, ip6mr_new_table_set);
d1db275d 384}
7bc570c8 385
b70432f7 386static void ip6mr_free_table(struct mr_table *mrt)
d1db275d 387{
7ba0c47c 388 del_timer_sync(&mrt->ipmr_expire_timer);
ca8d4794
CS		 389 mroute_clean_tables(mrt, MRT6_FLUSH_MIFS | MRT6_FLUSH_MIFS_STATIC |
390 MRT6_FLUSH_MFC | MRT6_FLUSH_MFC_STATIC);
b70432f7 391 rhltable_destroy(&mrt->mfc_hash);
d1db275d
PM		 392 kfree(mrt);
393}
7bc570c8
YH		 394
395#ifdef CONFIG_PROC_FS
c8d61968
YM		 396/* The /proc interfaces to multicast routing
397 * /proc/ip6_mr_cache /proc/ip6_mr_vif
7bc570c8
YH		 398 */
399
7bc570c8
YH		 400static void *ip6mr_vif_seq_start(struct seq_file *seq, loff_t *pos)
401 __acquires(mrt_lock)
402{
3feda6b4 403 struct mr_vif_iter *iter = seq->private;
8b90fc7e 404 struct net *net = seq_file_net(seq);
b70432f7 405 struct mr_table *mrt;
d1db275d
PM		 406
407 mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
63159f29 408 if (!mrt)
d1db275d
PM		 409 return ERR_PTR(-ENOENT);
410
411 iter->mrt = mrt;
8b90fc7e 412
7bc570c8 413 read_lock(&mrt_lock);
3feda6b4 414 return mr_vif_seq_start(seq, pos);
7bc570c8
YH		 415}
416
417static void ip6mr_vif_seq_stop(struct seq_file *seq, void *v)
418 __releases(mrt_lock)
419{
420 read_unlock(&mrt_lock);
421}
422
423static int ip6mr_vif_seq_show(struct seq_file *seq, void *v)
424{
3feda6b4 425 struct mr_vif_iter *iter = seq->private;
b70432f7 426 struct mr_table *mrt = iter->mrt;
8b90fc7e 427
7bc570c8
YH		 428 if (v == SEQ_START_TOKEN) {
429 seq_puts(seq,
430 "Interface BytesIn PktsIn BytesOut PktsOut Flags\n");
431 } else {
6853f21f 432 const struct vif_device *vif = v;
7bc570c8
YH		 433 const char *name = vif->dev ? vif->dev->name : "none";
434
435 seq_printf(seq,
d430a227 436 "%2td %-10s %8ld %7ld %8ld %7ld %05X\n",
b70432f7 437 vif - mrt->vif_table,
7bc570c8
YH		 438 name, vif->bytes_in, vif->pkt_in,
439 vif->bytes_out, vif->pkt_out,
440 vif->flags);
441 }
442 return 0;
443}
444
98147d52 445static const struct seq_operations ip6mr_vif_seq_ops = {
7bc570c8 446 .start = ip6mr_vif_seq_start,
3feda6b4 447 .next = mr_vif_seq_next,
7bc570c8
YH		 448 .stop = ip6mr_vif_seq_stop,
449 .show = ip6mr_vif_seq_show,
450};
451
7bc570c8
YH		 452static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
453{
8b90fc7e 454 struct net *net = seq_file_net(seq);
b70432f7 455 struct mr_table *mrt;
8b90fc7e 456
d1db275d 457 mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
63159f29 458 if (!mrt)
d1db275d
PM		 459 return ERR_PTR(-ENOENT);
460
c8d61968 461 return mr_mfc_seq_start(seq, pos, mrt, &mfc_unres_lock);
7bc570c8
YH		 462}
463
464static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
465{
466 int n;
467
468 if (v == SEQ_START_TOKEN) {
469 seq_puts(seq,
470 "Group "
471 "Origin "
472 "Iif Pkts Bytes Wrong Oifs\n");
473 } else {
474 const struct mfc6_cache *mfc = v;
c8d61968 475 const struct mr_mfc_iter *it = seq->private;
b70432f7 476 struct mr_table *mrt = it->mrt;
7bc570c8 477
999890b2 478 seq_printf(seq, "%pI6 %pI6 %-3hd",
0c6ce78a 479 &mfc->mf6c_mcastgrp, &mfc->mf6c_origin,
494fff56 480 mfc->_c.mfc_parent);
7bc570c8 481
b70432f7 482 if (it->cache != &mrt->mfc_unres_queue) {
1ea472e2 483 seq_printf(seq, " %8lu %8lu %8lu",
494fff56
YM		 484 mfc->_c.mfc_un.res.pkt,
485 mfc->_c.mfc_un.res.bytes,
486 mfc->_c.mfc_un.res.wrong_if);
487 for (n = mfc->_c.mfc_un.res.minvif;
488 n < mfc->_c.mfc_un.res.maxvif; n++) {
b70432f7 489 if (VIF_EXISTS(mrt, n) &&
494fff56 490 mfc->_c.mfc_un.res.ttls[n] < 255)
7bc570c8 491 seq_printf(seq,
494fff56
YM		 492 " %2d:%-3d", n,
493 mfc->_c.mfc_un.res.ttls[n]);
7bc570c8 494 }
1ea472e2
BT		 495 } else {
496 /* unresolved mfc_caches don't contain
497 * pkt, bytes and wrong_if values
498 */
499 seq_printf(seq, " %8lu %8lu %8lu", 0ul, 0ul, 0ul);
7bc570c8
YH		 500 }
501 seq_putc(seq, '\n');
502 }
503 return 0;
504}
505
88e9d34c 506static const struct seq_operations ipmr_mfc_seq_ops = {
7bc570c8 507 .start = ipmr_mfc_seq_start,
c8d61968
YM		 508 .next = mr_mfc_seq_next,
509 .stop = mr_mfc_seq_stop,
7bc570c8
YH		 510 .show = ipmr_mfc_seq_show,
511};
7bc570c8
YH		 512#endif
513
14fb64e1 514#ifdef CONFIG_IPV6_PIMSM_V2
14fb64e1
YH		 515
516static int pim6_rcv(struct sk_buff *skb)
517{
518 struct pimreghdr *pim;
519 struct ipv6hdr *encap;
520 struct net_device *reg_dev = NULL;
8229efda 521 struct net *net = dev_net(skb->dev);
b70432f7 522 struct mr_table *mrt;
4c9483b2
DM		 523 struct flowi6 fl6 = {
524 .flowi6_iif = skb->dev->ifindex,
525 .flowi6_mark = skb->mark,
d1db275d
PM		 526 };
527 int reg_vif_num;
14fb64e1
YH		 528
529 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
530 goto drop;
531
532 pim = (struct pimreghdr *)skb_transport_header(skb);
56245cae 533 if (pim->type != ((PIM_VERSION << 4) | PIM_TYPE_REGISTER) ||
14fb64e1 534 (pim->flags & PIM_NULL_REGISTER) ||
1d6e55f1
TG		 535 (csum_ipv6_magic(&ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr,
536 sizeof(*pim), IPPROTO_PIM,
537 csum_partial((void *)pim, sizeof(*pim), 0)) &&
ec6b486f 538 csum_fold(skb_checksum(skb, 0, skb->len, 0))))
14fb64e1
YH		 539 goto drop;
540
541 /* check if the inner packet is destined to mcast group */
542 encap = (struct ipv6hdr *)(skb_transport_header(skb) +
543 sizeof(*pim));
544
545 if (!ipv6_addr_is_multicast(&encap->daddr) ||
546 encap->payload_len == 0 ||
547 ntohs(encap->payload_len) + sizeof(*pim) > skb->len)
548 goto drop;
549
4c9483b2 550 if (ip6mr_fib_lookup(net, &fl6, &mrt) < 0)
d1db275d
PM		 551 goto drop;
552 reg_vif_num = mrt->mroute_reg_vif_num;
553
14fb64e1
YH		 554 read_lock(&mrt_lock);
555 if (reg_vif_num >= 0)
b70432f7 556 reg_dev = mrt->vif_table[reg_vif_num].dev;
1160dfa1 557 dev_hold(reg_dev);
14fb64e1
YH		 558 read_unlock(&mrt_lock);
559
63159f29 560 if (!reg_dev)
14fb64e1
YH		 561 goto drop;
562
563 skb->mac_header = skb->network_header;
564 skb_pull(skb, (u8 *)encap - skb->data);
565 skb_reset_network_header(skb);
1d6e55f1 566 skb->protocol = htons(ETH_P_IPV6);
3e49e6d5 567 skb->ip_summed = CHECKSUM_NONE;
d19d56dd 568
ea23192e 569 skb_tunnel_rx(skb, reg_dev, dev_net(reg_dev));
d19d56dd 570
caf586e5 571 netif_rx(skb);
8990f468 572
14fb64e1
YH		 573 dev_put(reg_dev);
574 return 0;
575 drop:
576 kfree_skb(skb);
577 return 0;
578}
579
41135cc8 580static const struct inet6_protocol pim6_protocol = {
14fb64e1
YH		 581 .handler = pim6_rcv,
582};
583
584/* Service routines creating virtual interfaces: PIMREG */
585
6fef4c0c
SH		 586static netdev_tx_t reg_vif_xmit(struct sk_buff *skb,
587 struct net_device *dev)
14fb64e1 588{
8229efda 589 struct net *net = dev_net(dev);
b70432f7 590 struct mr_table *mrt;
4c9483b2
DM		 591 struct flowi6 fl6 = {
592 .flowi6_oif = dev->ifindex,
6a662719 593 .flowi6_iif = skb->skb_iif ? : LOOPBACK_IFINDEX,
4c9483b2 594 .flowi6_mark = skb->mark,
d1db275d 595 };
d1db275d 596
cb9f1b78
WB		 597 if (!pskb_inet_may_pull(skb))
598 goto tx_err;
599
600 if (ip6mr_fib_lookup(net, &fl6, &mrt) < 0)
601 goto tx_err;
8229efda 602
14fb64e1 603 read_lock(&mrt_lock);
dc58c78c
PE		 604 dev->stats.tx_bytes += skb->len;
605 dev->stats.tx_packets++;
6bd52143 606 ip6mr_cache_report(mrt, skb, mrt->mroute_reg_vif_num, MRT6MSG_WHOLEPKT);
14fb64e1
YH		 607 read_unlock(&mrt_lock);
608 kfree_skb(skb);
6ed10654 609 return NETDEV_TX_OK;
cb9f1b78
WB		 610
611tx_err:
612 dev->stats.tx_errors++;
613 kfree_skb(skb);
614 return NETDEV_TX_OK;
14fb64e1
YH		 615}
616
ee9b9596
ND		 617static int reg_vif_get_iflink(const struct net_device *dev)
618{
619 return 0;
620}
621
007c3838
SH		 622static const struct net_device_ops reg_vif_netdev_ops = {
623 .ndo_start_xmit = reg_vif_xmit,
ee9b9596 624 .ndo_get_iflink = reg_vif_get_iflink,
007c3838
SH		 625};
626
14fb64e1
YH		 627static void reg_vif_setup(struct net_device *dev)
628{
629 dev->type = ARPHRD_PIMREG;
630 dev->mtu = 1500 - sizeof(struct ipv6hdr) - 8;
631 dev->flags = IFF_NOARP;
007c3838 632 dev->netdev_ops = &reg_vif_netdev_ops;
cf124db5 633 dev->needs_free_netdev = true;
403dbb97 634 dev->features |= NETIF_F_NETNS_LOCAL;
14fb64e1
YH		 635}
636
b70432f7 637static struct net_device *ip6mr_reg_vif(struct net *net, struct mr_table *mrt)
14fb64e1
YH		 638{
639 struct net_device *dev;
d1db275d
PM		 640 char name[IFNAMSIZ];
641
642 if (mrt->id == RT6_TABLE_DFLT)
643 sprintf(name, "pim6reg");
644 else
645 sprintf(name, "pim6reg%u", mrt->id);
14fb64e1 646
c835a677 647 dev = alloc_netdev(0, name, NET_NAME_UNKNOWN, reg_vif_setup);
63159f29 648 if (!dev)
14fb64e1
YH		 649 return NULL;
650
8229efda
BT		 651 dev_net_set(dev, net);
652
14fb64e1
YH		 653 if (register_netdevice(dev)) {
654 free_netdev(dev);
655 return NULL;
656 }
14fb64e1 657
00f54e68 658 if (dev_open(dev, NULL))
14fb64e1
YH		 659 goto failure;
660
7af3db78 661 dev_hold(dev);
14fb64e1
YH		 662 return dev;
663
664failure:
14fb64e1
YH		 665 unregister_netdevice(dev);
666 return NULL;
667}
668#endif
669
088aa3ee
YM		 670static int call_ip6mr_vif_entry_notifiers(struct net *net,
671 enum fib_event_type event_type,
672 struct vif_device *vif,
673 mifi_t vif_index, u32 tb_id)
674{
675 return mr_call_vif_notifiers(net, RTNL_FAMILY_IP6MR, event_type,
676 vif, vif_index, tb_id,
677 &net->ipv6.ipmr_seq);
678}
7bc570c8 679
088aa3ee
YM		 680static int call_ip6mr_mfc_entry_notifiers(struct net *net,
681 enum fib_event_type event_type,
682 struct mfc6_cache *mfc, u32 tb_id)
683{
684 return mr_call_mfc_notifiers(net, RTNL_FAMILY_IP6MR, event_type,
685 &mfc->_c, tb_id, &net->ipv6.ipmr_seq);
686}
687
688/* Delete a VIF entry */
b70432f7 689static int mif6_delete(struct mr_table *mrt, int vifi, int notify,
723b929c 690 struct list_head *head)
7bc570c8 691{
6853f21f 692 struct vif_device *v;
7bc570c8 693 struct net_device *dev;
1d6e55f1 694 struct inet6_dev *in6_dev;
6bd52143
PM		 695
696 if (vifi < 0 || vifi >= mrt->maxvif)
7bc570c8
YH		 697 return -EADDRNOTAVAIL;
698
b70432f7 699 v = &mrt->vif_table[vifi];
7bc570c8 700
088aa3ee
YM		 701 if (VIF_EXISTS(mrt, vifi))
702 call_ip6mr_vif_entry_notifiers(read_pnet(&mrt->net),
703 FIB_EVENT_VIF_DEL, v, vifi,
704 mrt->id);
705
7bc570c8
YH		 706 write_lock_bh(&mrt_lock);
707 dev = v->dev;
708 v->dev = NULL;
709
710 if (!dev) {
711 write_unlock_bh(&mrt_lock);
712 return -EADDRNOTAVAIL;
713 }
714
14fb64e1 715#ifdef CONFIG_IPV6_PIMSM_V2
6bd52143
PM		 716 if (vifi == mrt->mroute_reg_vif_num)
717 mrt->mroute_reg_vif_num = -1;
14fb64e1
YH		 718#endif
719
6bd52143 720 if (vifi + 1 == mrt->maxvif) {
7bc570c8
YH		 721 int tmp;
722 for (tmp = vifi - 1; tmp >= 0; tmp--) {
b70432f7 723 if (VIF_EXISTS(mrt, tmp))
7bc570c8
YH		 724 break;
725 }
6bd52143 726 mrt->maxvif = tmp + 1;
7bc570c8
YH		 727 }
728
729 write_unlock_bh(&mrt_lock);
730
731 dev_set_allmulti(dev, -1);
732
1d6e55f1 733 in6_dev = __in6_dev_get(dev);
d67b8c61 734 if (in6_dev) {
145c7a79 735 atomic_dec(&in6_dev->cnf.mc_forwarding);
85b3daad 736 inet6_netconf_notify_devconf(dev_net(dev), RTM_NEWNETCONF,
d67b8c61
ND		 737 NETCONFA_MC_FORWARDING,
738 dev->ifindex, &in6_dev->cnf);
739 }
1d6e55f1 740
723b929c 741 if ((v->flags & MIFF_REGISTER) && !notify)
c871e664 742 unregister_netdevice_queue(dev, head);
7bc570c8 743
42120a86 744 dev_put_track(dev, &v->dev_tracker);
7bc570c8
YH		 745 return 0;
746}
747
87c418bf 748static inline void ip6mr_cache_free_rcu(struct rcu_head *head)
58701ad4 749{
494fff56 750 struct mr_mfc *c = container_of(head, struct mr_mfc, rcu);
87c418bf 751
494fff56 752 kmem_cache_free(mrt_cachep, (struct mfc6_cache *)c);
58701ad4
BT		 753}
754
87c418bf
YM		 755static inline void ip6mr_cache_free(struct mfc6_cache *c)
756{
494fff56 757 call_rcu(&c->_c.rcu, ip6mr_cache_free_rcu);
87c418bf
YM		 758}
759
7bc570c8
YH		 760/* Destroy an unresolved cache entry, killing queued skbs
761 and reporting error to netlink readers.
762 */
763
b70432f7 764static void ip6mr_destroy_unres(struct mr_table *mrt, struct mfc6_cache *c)
7bc570c8 765{
6bd52143 766 struct net *net = read_pnet(&mrt->net);
7bc570c8
YH		 767 struct sk_buff *skb;
768
6bd52143 769 atomic_dec(&mrt->cache_resolve_queue_len);
7bc570c8 770
494fff56 771 while ((skb = skb_dequeue(&c->_c.mfc_un.unres.unresolved)) != NULL) {
7bc570c8 772 if (ipv6_hdr(skb)->version == 0) {
af72868b
JB		 773 struct nlmsghdr *nlh = skb_pull(skb,
774 sizeof(struct ipv6hdr));
7bc570c8 775 nlh->nlmsg_type = NLMSG_ERROR;
573ce260 776 nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
7bc570c8 777 skb_trim(skb, nlh->nlmsg_len);
573ce260 778 ((struct nlmsgerr *)nlmsg_data(nlh))->error = -ETIMEDOUT;
15e47304 779 rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
7bc570c8
YH		 780 } else
781 kfree_skb(skb);
782 }
783
58701ad4 784 ip6mr_cache_free(c);
7bc570c8
YH		 785}
786
787
c476efbc 788/* Timer process for all the unresolved queue. */
7bc570c8 789
b70432f7 790static void ipmr_do_expire_process(struct mr_table *mrt)
7bc570c8
YH		 791{
792 unsigned long now = jiffies;
793 unsigned long expires = 10 * HZ;
494fff56 794 struct mr_mfc *c, *next;
7bc570c8 795
b70432f7 796 list_for_each_entry_safe(c, next, &mrt->mfc_unres_queue, list) {
7bc570c8
YH		 797 if (time_after(c->mfc_un.unres.expires, now)) {
798 /* not yet... */
799 unsigned long interval = c->mfc_un.unres.expires - now;
800 if (interval < expires)
801 expires = interval;
7bc570c8
YH		 802 continue;
803 }
804
f30a7784 805 list_del(&c->list);
494fff56
YM		 806 mr6_netlink_event(mrt, (struct mfc6_cache *)c, RTM_DELROUTE);
807 ip6mr_destroy_unres(mrt, (struct mfc6_cache *)c);
7bc570c8
YH		 808 }
809
b70432f7 810 if (!list_empty(&mrt->mfc_unres_queue))
6bd52143 811 mod_timer(&mrt->ipmr_expire_timer, jiffies + expires);
7bc570c8
YH		 812}
813
e99e88a9 814static void ipmr_expire_process(struct timer_list *t)
7bc570c8 815{
b70432f7 816 struct mr_table *mrt = from_timer(mrt, t, ipmr_expire_timer);
c476efbc 817
7bc570c8 818 if (!spin_trylock(&mfc_unres_lock)) {
6bd52143 819 mod_timer(&mrt->ipmr_expire_timer, jiffies + 1);
7bc570c8
YH		 820 return;
821 }
822
b70432f7 823 if (!list_empty(&mrt->mfc_unres_queue))
6bd52143 824 ipmr_do_expire_process(mrt);
7bc570c8
YH		 825
826 spin_unlock(&mfc_unres_lock);
827}
828
829/* Fill oifs list. It is called under write locked mrt_lock. */
830
b70432f7 831static void ip6mr_update_thresholds(struct mr_table *mrt,
494fff56 832 struct mr_mfc *cache,
b5aa30b1 833 unsigned char *ttls)
7bc570c8
YH		 834{
835 int vifi;
836
6ac7eb08 837 cache->mfc_un.res.minvif = MAXMIFS;
7bc570c8 838 cache->mfc_un.res.maxvif = 0;
6ac7eb08 839 memset(cache->mfc_un.res.ttls, 255, MAXMIFS);
7bc570c8 840
6bd52143 841 for (vifi = 0; vifi < mrt->maxvif; vifi++) {
b70432f7 842 if (VIF_EXISTS(mrt, vifi) &&
4e16880c 843 ttls[vifi] && ttls[vifi] < 255) {
7bc570c8
YH		 844 cache->mfc_un.res.ttls[vifi] = ttls[vifi];
845 if (cache->mfc_un.res.minvif > vifi)
846 cache->mfc_un.res.minvif = vifi;
847 if (cache->mfc_un.res.maxvif <= vifi)
848 cache->mfc_un.res.maxvif = vifi + 1;
849 }
850 }
90b5ca17 851 cache->mfc_un.res.lastuse = jiffies;
7bc570c8
YH		 852}
853
b70432f7 854static int mif6_add(struct net *net, struct mr_table *mrt,
6bd52143 855 struct mif6ctl *vifc, int mrtsock)
7bc570c8
YH		 856{
857 int vifi = vifc->mif6c_mifi;
b70432f7 858 struct vif_device *v = &mrt->vif_table[vifi];
7bc570c8 859 struct net_device *dev;
1d6e55f1 860 struct inet6_dev *in6_dev;
5ae7b444 861 int err;
7bc570c8
YH		 862
863 /* Is vif busy ? */
b70432f7 864 if (VIF_EXISTS(mrt, vifi))
7bc570c8
YH		 865 return -EADDRINUSE;
866
867 switch (vifc->mif6c_flags) {
14fb64e1
YH		 868#ifdef CONFIG_IPV6_PIMSM_V2
869 case MIFF_REGISTER:
870 /*
871 * Special Purpose VIF in PIM
872 * All the packets will be sent to the daemon
873 */
6bd52143 874 if (mrt->mroute_reg_vif_num >= 0)
14fb64e1 875 return -EADDRINUSE;
d1db275d 876 dev = ip6mr_reg_vif(net, mrt);
14fb64e1
YH		 877 if (!dev)
878 return -ENOBUFS;
5ae7b444
WC		 879 err = dev_set_allmulti(dev, 1);
880 if (err) {
881 unregister_netdevice(dev);
7af3db78 882 dev_put(dev);
5ae7b444
WC		 883 return err;
884 }
14fb64e1
YH		 885 break;
886#endif
7bc570c8 887 case 0:
8229efda 888 dev = dev_get_by_index(net, vifc->mif6c_pifi);
7bc570c8
YH		 889 if (!dev)
890 return -EADDRNOTAVAIL;
5ae7b444 891 err = dev_set_allmulti(dev, 1);
7af3db78
WC		 892 if (err) {
893 dev_put(dev);
5ae7b444 894 return err;
7af3db78 895 }
7bc570c8
YH		 896 break;
897 default:
898 return -EINVAL;
899 }
900
1d6e55f1 901 in6_dev = __in6_dev_get(dev);
d67b8c61 902 if (in6_dev) {
145c7a79 903 atomic_inc(&in6_dev->cnf.mc_forwarding);
85b3daad 904 inet6_netconf_notify_devconf(dev_net(dev), RTM_NEWNETCONF,
d67b8c61
ND		 905 NETCONFA_MC_FORWARDING,
906 dev->ifindex, &in6_dev->cnf);
907 }
1d6e55f1 908
6853f21f
YM		 909 /* Fill in the VIF structures */
910 vif_device_init(v, dev, vifc->vifc_rate_limit, vifc->vifc_threshold,
911 vifc->mif6c_flags | (!mrtsock ? VIFF_STATIC : 0),
912 MIFF_REGISTER);
7bc570c8
YH		 913
914 /* And finish update writing critical data */
915 write_lock_bh(&mrt_lock);
7bc570c8 916 v->dev = dev;
42120a86 917 netdev_tracker_alloc(dev, &v->dev_tracker, GFP_ATOMIC);
14fb64e1
YH		 918#ifdef CONFIG_IPV6_PIMSM_V2
919 if (v->flags & MIFF_REGISTER)
6bd52143 920 mrt->mroute_reg_vif_num = vifi;
14fb64e1 921#endif
6bd52143
PM		 922 if (vifi + 1 > mrt->maxvif)
923 mrt->maxvif = vifi + 1;
7bc570c8 924 write_unlock_bh(&mrt_lock);
088aa3ee
YM		 925 call_ip6mr_vif_entry_notifiers(net, FIB_EVENT_VIF_ADD,
926 v, vifi, mrt->id);
7bc570c8
YH		 927 return 0;
928}
929
b70432f7 930static struct mfc6_cache *ip6mr_cache_find(struct mr_table *mrt,
b71d1d42
ED		 931 const struct in6_addr *origin,
932 const struct in6_addr *mcastgrp)
7bc570c8 933{
87c418bf
YM		 934 struct mfc6_cache_cmp_arg arg = {
935 .mf6c_origin = *origin,
936 .mf6c_mcastgrp = *mcastgrp,
937 };
87c418bf 938
845c9a7a 939 return mr_mfc_find(mrt, &arg);
660b26dc
ND		 940}
941
942/* Look for a (*,G) entry */
b70432f7 943static struct mfc6_cache *ip6mr_cache_find_any(struct mr_table *mrt,
660b26dc
ND		 944 struct in6_addr *mcastgrp,
945 mifi_t mifi)
946{
87c418bf
YM		 947 struct mfc6_cache_cmp_arg arg = {
948 .mf6c_origin = in6addr_any,
949 .mf6c_mcastgrp = *mcastgrp,
950 };
660b26dc
ND		 951
952 if (ipv6_addr_any(mcastgrp))
845c9a7a
YM		 953 return mr_mfc_find_any_parent(mrt, mifi);
954 return mr_mfc_find_any(mrt, mifi, &arg);
660b26dc
ND		 955}
956
87c418bf
YM		 957/* Look for a (S,G,iif) entry if parent != -1 */
958static struct mfc6_cache *
b70432f7 959ip6mr_cache_find_parent(struct mr_table *mrt,
87c418bf
YM		 960 const struct in6_addr *origin,
961 const struct in6_addr *mcastgrp,
962 int parent)
963{
964 struct mfc6_cache_cmp_arg arg = {
965 .mf6c_origin = *origin,
966 .mf6c_mcastgrp = *mcastgrp,
967 };
87c418bf 968
845c9a7a 969 return mr_mfc_find_parent(mrt, &arg, parent);
87c418bf
YM		 970}
971
845c9a7a 972/* Allocate a multicast cache entry */
b5aa30b1 973static struct mfc6_cache *ip6mr_cache_alloc(void)
7bc570c8 974{
36cbac59 975 struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
63159f29 976 if (!c)
7bc570c8 977 return NULL;
494fff56
YM		 978 c->_c.mfc_un.res.last_assert = jiffies - MFC_ASSERT_THRESH - 1;
979 c->_c.mfc_un.res.minvif = MAXMIFS;
8c13af2a
YM		 980 c->_c.free = ip6mr_cache_free_rcu;
981 refcount_set(&c->_c.mfc_un.res.refcount, 1);
7bc570c8
YH		 982 return c;
983}
984
b5aa30b1 985static struct mfc6_cache *ip6mr_cache_alloc_unres(void)
7bc570c8 986{
36cbac59 987 struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC);
63159f29 988 if (!c)
7bc570c8 989 return NULL;
494fff56
YM		 990 skb_queue_head_init(&c->_c.mfc_un.unres.unresolved);
991 c->_c.mfc_un.unres.expires = jiffies + 10 * HZ;
7bc570c8
YH		 992 return c;
993}
994
995/*
996 * A cache entry has gone into a resolved state from queued
997 */
998
b70432f7 999static void ip6mr_cache_resolve(struct net *net, struct mr_table *mrt,
6bd52143 1000 struct mfc6_cache *uc, struct mfc6_cache *c)
7bc570c8
YH		 1001{
1002 struct sk_buff *skb;
1003
1004 /*
1005 * Play the pending entries through our router
1006 */
1007
494fff56 1008 while ((skb = __skb_dequeue(&uc->_c.mfc_un.unres.unresolved))) {
7bc570c8 1009 if (ipv6_hdr(skb)->version == 0) {
af72868b
JB		 1010 struct nlmsghdr *nlh = skb_pull(skb,
1011 sizeof(struct ipv6hdr));
7bc570c8 1012
7b0db857
YM		 1013 if (mr_fill_mroute(mrt, skb, &c->_c,
1014 nlmsg_data(nlh)) > 0) {
549e028d 1015 nlh->nlmsg_len = skb_tail_pointer(skb) - (u8 *)nlh;
7bc570c8
YH		 1016 } else {
1017 nlh->nlmsg_type = NLMSG_ERROR;
573ce260 1018 nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
7bc570c8 1019 skb_trim(skb, nlh->nlmsg_len);
573ce260 1020 ((struct nlmsgerr *)nlmsg_data(nlh))->error = -EMSGSIZE;
7bc570c8 1021 }
15e47304 1022 rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
7bc570c8 1023 } else
e4a38c0c 1024 ip6_mr_forward(net, mrt, skb->dev, skb, c);
7bc570c8
YH		 1025 }
1026}
1027
1028/*
dd12d15c 1029 * Bounce a cache query up to pim6sd and netlink.
7bc570c8
YH		 1030 *
1031 * Called under mrt_lock.
1032 */
1033
b70432f7 1034static int ip6mr_cache_report(struct mr_table *mrt, struct sk_buff *pkt,
6bd52143 1035 mifi_t mifi, int assert)
7bc570c8 1036{
8571ab47 1037 struct sock *mroute6_sk;
7bc570c8
YH		 1038 struct sk_buff *skb;
1039 struct mrt6msg *msg;
1040 int ret;
1041
14fb64e1 1042#ifdef CONFIG_IPV6_PIMSM_V2
4b340a5a 1043 if (assert == MRT6MSG_WHOLEPKT || assert == MRT6MSG_WRMIFWHOLE)
14fb64e1
YH		 1044 skb = skb_realloc_headroom(pkt, -skb_network_offset(pkt)
1045 +sizeof(*msg));
1046 else
1047#endif
1048 skb = alloc_skb(sizeof(struct ipv6hdr) + sizeof(*msg), GFP_ATOMIC);
7bc570c8
YH		 1049
1050 if (!skb)
1051 return -ENOBUFS;
1052
1053 /* I suppose that internal messages
1054 * do not require checksums */
1055
1056 skb->ip_summed = CHECKSUM_UNNECESSARY;
1057
14fb64e1 1058#ifdef CONFIG_IPV6_PIMSM_V2
4b340a5a 1059 if (assert == MRT6MSG_WHOLEPKT || assert == MRT6MSG_WRMIFWHOLE) {
14fb64e1
YH		 1060 /* Ugly, but we have no choice with this interface.
1061 Duplicate old header, fix length etc.
1062 And all this only to mangle msg->im6_msgtype and
1063 to set msg->im6_mbz to "mbz" :-)
1064 */
1065 skb_push(skb, -skb_network_offset(pkt));
1066
1067 skb_push(skb, sizeof(*msg));
1068 skb_reset_transport_header(skb);
1069 msg = (struct mrt6msg *)skb_transport_header(skb);
1070 msg->im6_mbz = 0;
4b340a5a
MR		 1071 msg->im6_msgtype = assert;
1072 if (assert == MRT6MSG_WRMIFWHOLE)
1073 msg->im6_mif = mifi;
1074 else
1075 msg->im6_mif = mrt->mroute_reg_vif_num;
14fb64e1 1076 msg->im6_pad = 0;
4e3fd7a0
AD		 1077 msg->im6_src = ipv6_hdr(pkt)->saddr;
1078 msg->im6_dst = ipv6_hdr(pkt)->daddr;
14fb64e1
YH		 1079
1080 skb->ip_summed = CHECKSUM_UNNECESSARY;
1081 } else
1082#endif
1083 {
7bc570c8
YH		 1084 /*
1085 * Copy the IP header
1086 */
1087
1088 skb_put(skb, sizeof(struct ipv6hdr));
1089 skb_reset_network_header(skb);
1090 skb_copy_to_linear_data(skb, ipv6_hdr(pkt), sizeof(struct ipv6hdr));
1091
1092 /*
1093 * Add our header
1094 */
1095 skb_put(skb, sizeof(*msg));
1096 skb_reset_transport_header(skb);
1097 msg = (struct mrt6msg *)skb_transport_header(skb);
1098
1099 msg->im6_mbz = 0;
1100 msg->im6_msgtype = assert;
6ac7eb08 1101 msg->im6_mif = mifi;
7bc570c8 1102 msg->im6_pad = 0;
4e3fd7a0
AD		 1103 msg->im6_src = ipv6_hdr(pkt)->saddr;
1104 msg->im6_dst = ipv6_hdr(pkt)->daddr;
7bc570c8 1105
adf30907 1106 skb_dst_set(skb, dst_clone(skb_dst(pkt)));
7bc570c8 1107 skb->ip_summed = CHECKSUM_UNNECESSARY;
14fb64e1 1108 }
7bc570c8 1109
8571ab47 1110 rcu_read_lock();
b70432f7 1111 mroute6_sk = rcu_dereference(mrt->mroute_sk);
8571ab47
YM		 1112 if (!mroute6_sk) {
1113 rcu_read_unlock();
7bc570c8
YH		 1114 kfree_skb(skb);
1115 return -EINVAL;
1116 }
1117
dd12d15c
JG		 1118 mrt6msg_netlink_event(mrt, skb);
1119
8571ab47
YM		 1120 /* Deliver to user space multicast routing algorithms */
1121 ret = sock_queue_rcv_skb(mroute6_sk, skb);
1122 rcu_read_unlock();
bd91b8bf 1123 if (ret < 0) {
e87cc472 1124 net_warn_ratelimited("mroute6: pending queue full, dropping entries\n");
7bc570c8
YH		 1125 kfree_skb(skb);
1126 }
1127
1128 return ret;
1129}
1130
494fff56
YM		 1131/* Queue a packet for resolution. It gets locked cache entry! */
1132static int ip6mr_cache_unresolved(struct mr_table *mrt, mifi_t mifi,
e4a38c0c 1133 struct sk_buff *skb, struct net_device *dev)
7bc570c8 1134{
494fff56 1135 struct mfc6_cache *c;
f30a7784 1136 bool found = false;
7bc570c8 1137 int err;
7bc570c8
YH		 1138
1139 spin_lock_bh(&mfc_unres_lock);
494fff56 1140 list_for_each_entry(c, &mrt->mfc_unres_queue, _c.list) {
c476efbc 1141 if (ipv6_addr_equal(&c->mf6c_mcastgrp, &ipv6_hdr(skb)->daddr) &&
f30a7784
PM		 1142 ipv6_addr_equal(&c->mf6c_origin, &ipv6_hdr(skb)->saddr)) {
1143 found = true;
7bc570c8 1144 break;
f30a7784 1145 }
7bc570c8
YH		 1146 }
1147
f30a7784 1148 if (!found) {
7bc570c8
YH		 1149 /*
1150 * Create a new entry if allowable
1151 */
1152
0079ad8e
HL		 1153 c = ip6mr_cache_alloc_unres();
1154 if (!c) {
7bc570c8
YH		 1155 spin_unlock_bh(&mfc_unres_lock);
1156
1157 kfree_skb(skb);
1158 return -ENOBUFS;
1159 }
1160
494fff56
YM		 1161 /* Fill in the new cache entry */
1162 c->_c.mfc_parent = -1;
7bc570c8
YH		 1163 c->mf6c_origin = ipv6_hdr(skb)->saddr;
1164 c->mf6c_mcastgrp = ipv6_hdr(skb)->daddr;
1165
1166 /*
1167 * Reflect first query at pim6sd
1168 */
6bd52143 1169 err = ip6mr_cache_report(mrt, skb, mifi, MRT6MSG_NOCACHE);
8229efda 1170 if (err < 0) {
7bc570c8
YH		 1171 /* If the report failed throw the cache entry
1172 out - Brad Parker
1173 */
1174 spin_unlock_bh(&mfc_unres_lock);
1175
58701ad4 1176 ip6mr_cache_free(c);
7bc570c8
YH		 1177 kfree_skb(skb);
1178 return err;
1179 }
1180
6bd52143 1181 atomic_inc(&mrt->cache_resolve_queue_len);
494fff56 1182 list_add(&c->_c.list, &mrt->mfc_unres_queue);
812e44dd 1183 mr6_netlink_event(mrt, c, RTM_NEWROUTE);
7bc570c8 1184
6bd52143 1185 ipmr_do_expire_process(mrt);
7bc570c8
YH		 1186 }
1187
494fff56
YM		 1188 /* See if we can append the packet */
1189 if (c->_c.mfc_un.unres.unresolved.qlen > 3) {
7bc570c8
YH		 1190 kfree_skb(skb);
1191 err = -ENOBUFS;
1192 } else {
e4a38c0c
PR		 1193 if (dev) {
1194 skb->dev = dev;
1195 skb->skb_iif = dev->ifindex;
1196 }
494fff56 1197 skb_queue_tail(&c->_c.mfc_un.unres.unresolved, skb);
7bc570c8
YH		 1198 err = 0;
1199 }
1200
1201 spin_unlock_bh(&mfc_unres_lock);
1202 return err;
1203}
1204
1205/*
1206 * MFC6 cache manipulation by user space
1207 */
1208
b70432f7 1209static int ip6mr_mfc_delete(struct mr_table *mrt, struct mf6cctl *mfc,
660b26dc 1210 int parent)
7bc570c8 1211{
87c418bf 1212 struct mfc6_cache *c;
7bc570c8 1213
87c418bf
YM		 1214 /* The entries are added/deleted only under RTNL */
1215 rcu_read_lock();
1216 c = ip6mr_cache_find_parent(mrt, &mfc->mf6cc_origin.sin6_addr,
1217 &mfc->mf6cc_mcastgrp.sin6_addr, parent);
1218 rcu_read_unlock();
1219 if (!c)
1220 return -ENOENT;
494fff56
YM		 1221 rhltable_remove(&mrt->mfc_hash, &c->_c.mnode, ip6mr_rht_params);
1222 list_del_rcu(&c->_c.list);
7bc570c8 1223
088aa3ee
YM		 1224 call_ip6mr_mfc_entry_notifiers(read_pnet(&mrt->net),
1225 FIB_EVENT_ENTRY_DEL, c, mrt->id);
87c418bf 1226 mr6_netlink_event(mrt, c, RTM_DELROUTE);
8c13af2a 1227 mr_cache_put(&c->_c);
87c418bf 1228 return 0;
7bc570c8
YH		 1229}
1230
1231static int ip6mr_device_event(struct notifier_block *this,
1232 unsigned long event, void *ptr)
1233{
351638e7 1234 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
8229efda 1235 struct net *net = dev_net(dev);
b70432f7 1236 struct mr_table *mrt;
6853f21f 1237 struct vif_device *v;
7bc570c8
YH		 1238 int ct;
1239
7bc570c8
YH		 1240 if (event != NETDEV_UNREGISTER)
1241 return NOTIFY_DONE;
1242
d1db275d 1243 ip6mr_for_each_table(mrt, net) {
b70432f7 1244 v = &mrt->vif_table[0];
d1db275d
PM		 1245 for (ct = 0; ct < mrt->maxvif; ct++, v++) {
1246 if (v->dev == dev)
723b929c 1247 mif6_delete(mrt, ct, 1, NULL);
d1db275d 1248 }
7bc570c8 1249 }
c871e664 1250
7bc570c8
YH		 1251 return NOTIFY_DONE;
1252}
1253
088aa3ee
YM		 1254static unsigned int ip6mr_seq_read(struct net *net)
1255{
1256 ASSERT_RTNL();
1257
1258 return net->ipv6.ipmr_seq + ip6mr_rules_seq_read(net);
1259}
1260
b7a59557
JP		 1261static int ip6mr_dump(struct net *net, struct notifier_block *nb,
1262 struct netlink_ext_ack *extack)
088aa3ee
YM		 1263{
1264 return mr_dump(net, nb, RTNL_FAMILY_IP6MR, ip6mr_rules_dump,
b7a59557 1265 ip6mr_mr_table_iter, &mrt_lock, extack);
088aa3ee
YM		 1266}
1267
7bc570c8
YH		 1268static struct notifier_block ip6_mr_notifier = {
1269 .notifier_call = ip6mr_device_event
1270};
1271
088aa3ee
YM		 1272static const struct fib_notifier_ops ip6mr_notifier_ops_template = {
1273 .family = RTNL_FAMILY_IP6MR,
1274 .fib_seq_read = ip6mr_seq_read,
1275 .fib_dump = ip6mr_dump,
1276 .owner = THIS_MODULE,
1277};
1278
1279static int __net_init ip6mr_notifier_init(struct net *net)
1280{
1281 struct fib_notifier_ops *ops;
1282
1283 net->ipv6.ipmr_seq = 0;
7bc570c8 1284
088aa3ee
YM		 1285 ops = fib_notifier_ops_register(&ip6mr_notifier_ops_template, net);
1286 if (IS_ERR(ops))
1287 return PTR_ERR(ops);
1288
1289 net->ipv6.ip6mr_notifier_ops = ops;
1290
1291 return 0;
1292}
1293
1294static void __net_exit ip6mr_notifier_exit(struct net *net)
1295{
1296 fib_notifier_ops_unregister(net->ipv6.ip6mr_notifier_ops);
1297 net->ipv6.ip6mr_notifier_ops = NULL;
1298}
1299
1300/* Setup for IP multicast routing */
4e16880c
BT		 1301static int __net_init ip6mr_net_init(struct net *net)
1302{
d1db275d 1303 int err;
f30a7784 1304
088aa3ee
YM		 1305 err = ip6mr_notifier_init(net);
1306 if (err)
1307 return err;
1308
d1db275d
PM		 1309 err = ip6mr_rules_init(net);
1310 if (err < 0)
088aa3ee 1311 goto ip6mr_rules_fail;
8b90fc7e
BT		 1312
1313#ifdef CONFIG_PROC_FS
1314 err = -ENOMEM;
c3506372
CH		 1315 if (!proc_create_net("ip6_mr_vif", 0, net->proc_net, &ip6mr_vif_seq_ops,
1316 sizeof(struct mr_vif_iter)))
8b90fc7e 1317 goto proc_vif_fail;
c3506372
CH		 1318 if (!proc_create_net("ip6_mr_cache", 0, net->proc_net, &ipmr_mfc_seq_ops,
1319 sizeof(struct mr_mfc_iter)))
8b90fc7e
BT		 1320 goto proc_cache_fail;
1321#endif
6bd52143 1322
4a6258a0
BT		 1323 return 0;
1324
8b90fc7e
BT		 1325#ifdef CONFIG_PROC_FS
1326proc_cache_fail:
ece31ffd 1327 remove_proc_entry("ip6_mr_vif", net->proc_net);
8b90fc7e 1328proc_vif_fail:
e2f736b7 1329 rtnl_lock();
d1db275d 1330 ip6mr_rules_exit(net);
e2f736b7 1331 rtnl_unlock();
8b90fc7e 1332#endif
088aa3ee
YM		 1333ip6mr_rules_fail:
1334 ip6mr_notifier_exit(net);
4e16880c
BT		 1335 return err;
1336}
1337
1338static void __net_exit ip6mr_net_exit(struct net *net)
1339{
8b90fc7e 1340#ifdef CONFIG_PROC_FS
ece31ffd
G		 1341 remove_proc_entry("ip6_mr_cache", net->proc_net);
1342 remove_proc_entry("ip6_mr_vif", net->proc_net);
8b90fc7e 1343#endif
088aa3ee 1344 ip6mr_notifier_exit(net);
4e16880c
BT		 1345}
1346
e2f736b7
ED		 1347static void __net_exit ip6mr_net_exit_batch(struct list_head *net_list)
1348{
1349 struct net *net;
1350
1351 rtnl_lock();
1352 list_for_each_entry(net, net_list, exit_list)
1353 ip6mr_rules_exit(net);
1354 rtnl_unlock();
1355}
1356
4e16880c
BT		 1357static struct pernet_operations ip6mr_net_ops = {
1358 .init = ip6mr_net_init,
1359 .exit = ip6mr_net_exit,
e2f736b7 1360 .exit_batch = ip6mr_net_exit_batch,
4e16880c
BT		 1361};
1362
623d1a1a 1363int __init ip6_mr_init(void)
7bc570c8 1364{
623d1a1a
WC		 1365 int err;
1366
7bc570c8
YH		 1367 mrt_cachep = kmem_cache_create("ip6_mrt_cache",
1368 sizeof(struct mfc6_cache),
1369 0, SLAB_HWCACHE_ALIGN,
1370 NULL);
1371 if (!mrt_cachep)
623d1a1a 1372 return -ENOMEM;
7bc570c8 1373
4e16880c
BT		 1374 err = register_pernet_subsys(&ip6mr_net_ops);
1375 if (err)
1376 goto reg_pernet_fail;
1377
623d1a1a
WC		 1378 err = register_netdevice_notifier(&ip6_mr_notifier);
1379 if (err)
1380 goto reg_notif_fail;
403dbb97
TG		 1381#ifdef CONFIG_IPV6_PIMSM_V2
1382 if (inet6_add_protocol(&pim6_protocol, IPPROTO_PIM) < 0) {
f3213831 1383 pr_err("%s: can't add PIM protocol\n", __func__);
403dbb97
TG		 1384 err = -EAGAIN;
1385 goto add_proto_fail;
1386 }
1387#endif
a3fde2ad
FW		 1388 err = rtnl_register_module(THIS_MODULE, RTNL_FAMILY_IP6MR, RTM_GETROUTE,
1389 NULL, ip6mr_rtm_dumproute, 0);
1390 if (err == 0)
1391 return 0;
1392
403dbb97 1393#ifdef CONFIG_IPV6_PIMSM_V2
a3fde2ad 1394 inet6_del_protocol(&pim6_protocol, IPPROTO_PIM);
403dbb97
TG		 1395add_proto_fail:
1396 unregister_netdevice_notifier(&ip6_mr_notifier);
1397#endif
87b30a65 1398reg_notif_fail:
4e16880c
BT		 1399 unregister_pernet_subsys(&ip6mr_net_ops);
1400reg_pernet_fail:
87b30a65 1401 kmem_cache_destroy(mrt_cachep);
623d1a1a 1402 return err;
7bc570c8
YH		 1403}
1404
623d1a1a
WC		 1405void ip6_mr_cleanup(void)
1406{
ffb1388a
DJ		 1407 rtnl_unregister(RTNL_FAMILY_IP6MR, RTM_GETROUTE);
1408#ifdef CONFIG_IPV6_PIMSM_V2
1409 inet6_del_protocol(&pim6_protocol, IPPROTO_PIM);
1410#endif
623d1a1a 1411 unregister_netdevice_notifier(&ip6_mr_notifier);
4e16880c 1412 unregister_pernet_subsys(&ip6mr_net_ops);
623d1a1a
WC		 1413 kmem_cache_destroy(mrt_cachep);
1414}
7bc570c8 1415
b70432f7 1416static int ip6mr_mfc_add(struct net *net, struct mr_table *mrt,
660b26dc 1417 struct mf6cctl *mfc, int mrtsock, int parent)
7bc570c8 1418{
6ac7eb08 1419 unsigned char ttls[MAXMIFS];
87c418bf 1420 struct mfc6_cache *uc, *c;
494fff56 1421 struct mr_mfc *_uc;
87c418bf
YM		 1422 bool found;
1423 int i, err;
7bc570c8 1424
a50436f2
PM		 1425 if (mfc->mf6cc_parent >= MAXMIFS)
1426 return -ENFILE;
1427
6ac7eb08
RR		 1428 memset(ttls, 255, MAXMIFS);
1429 for (i = 0; i < MAXMIFS; i++) {
7bc570c8
YH		 1430 if (IF_ISSET(i, &mfc->mf6cc_ifset))
1431 ttls[i] = 1;
7bc570c8
YH		 1432 }
1433
87c418bf
YM		 1434 /* The entries are added/deleted only under RTNL */
1435 rcu_read_lock();
1436 c = ip6mr_cache_find_parent(mrt, &mfc->mf6cc_origin.sin6_addr,
1437 &mfc->mf6cc_mcastgrp.sin6_addr, parent);
1438 rcu_read_unlock();
1439 if (c) {
7bc570c8 1440 write_lock_bh(&mrt_lock);
494fff56
YM		 1441 c->_c.mfc_parent = mfc->mf6cc_parent;
1442 ip6mr_update_thresholds(mrt, &c->_c, ttls);
7bc570c8 1443 if (!mrtsock)
494fff56 1444 c->_c.mfc_flags |= MFC_STATIC;
7bc570c8 1445 write_unlock_bh(&mrt_lock);
088aa3ee
YM		 1446 call_ip6mr_mfc_entry_notifiers(net, FIB_EVENT_ENTRY_REPLACE,
1447 c, mrt->id);
812e44dd 1448 mr6_netlink_event(mrt, c, RTM_NEWROUTE);
7bc570c8
YH		 1449 return 0;
1450 }
1451
660b26dc
ND		 1452 if (!ipv6_addr_any(&mfc->mf6cc_mcastgrp.sin6_addr) &&
1453 !ipv6_addr_is_multicast(&mfc->mf6cc_mcastgrp.sin6_addr))
7bc570c8
YH		 1454 return -EINVAL;
1455
b5aa30b1 1456 c = ip6mr_cache_alloc();
63159f29 1457 if (!c)
7bc570c8
YH		 1458 return -ENOMEM;
1459
1460 c->mf6c_origin = mfc->mf6cc_origin.sin6_addr;
1461 c->mf6c_mcastgrp = mfc->mf6cc_mcastgrp.sin6_addr;
494fff56
YM		 1462 c->_c.mfc_parent = mfc->mf6cc_parent;
1463 ip6mr_update_thresholds(mrt, &c->_c, ttls);
7bc570c8 1464 if (!mrtsock)
494fff56 1465 c->_c.mfc_flags |= MFC_STATIC;
7bc570c8 1466
494fff56 1467 err = rhltable_insert_key(&mrt->mfc_hash, &c->cmparg, &c->_c.mnode,
87c418bf
YM		 1468 ip6mr_rht_params);
1469 if (err) {
1470 pr_err("ip6mr: rhtable insert error %d\n", err);
1471 ip6mr_cache_free(c);
1472 return err;
1473 }
494fff56 1474 list_add_tail_rcu(&c->_c.list, &mrt->mfc_cache_list);
7bc570c8 1475
87c418bf
YM		 1476 /* Check to see if we resolved a queued list. If so we
1477 * need to send on the frames and tidy up.
7bc570c8 1478 */
f30a7784 1479 found = false;
7bc570c8 1480 spin_lock_bh(&mfc_unres_lock);
494fff56
YM		 1481 list_for_each_entry(_uc, &mrt->mfc_unres_queue, list) {
1482 uc = (struct mfc6_cache *)_uc;
c476efbc 1483 if (ipv6_addr_equal(&uc->mf6c_origin, &c->mf6c_origin) &&
7bc570c8 1484 ipv6_addr_equal(&uc->mf6c_mcastgrp, &c->mf6c_mcastgrp)) {
494fff56 1485 list_del(&_uc->list);
6bd52143 1486 atomic_dec(&mrt->cache_resolve_queue_len);
f30a7784 1487 found = true;
7bc570c8
YH		 1488 break;
1489 }
1490 }
b70432f7 1491 if (list_empty(&mrt->mfc_unres_queue))
6bd52143 1492 del_timer(&mrt->ipmr_expire_timer);
7bc570c8
YH		 1493 spin_unlock_bh(&mfc_unres_lock);
1494
f30a7784 1495 if (found) {
6bd52143 1496 ip6mr_cache_resolve(net, mrt, uc, c);
58701ad4 1497 ip6mr_cache_free(uc);
7bc570c8 1498 }
088aa3ee
YM		 1499 call_ip6mr_mfc_entry_notifiers(net, FIB_EVENT_ENTRY_ADD,
1500 c, mrt->id);
812e44dd 1501 mr6_netlink_event(mrt, c, RTM_NEWROUTE);
7bc570c8
YH		 1502 return 0;
1503}
1504
1505/*
1506 * Close the multicast socket, and clear the vif tables etc
1507 */
1508
ca8d4794 1509static void mroute_clean_tables(struct mr_table *mrt, int flags)
7bc570c8 1510{
494fff56 1511 struct mr_mfc *c, *tmp;
c871e664 1512 LIST_HEAD(list);
87c418bf 1513 int i;
7bc570c8 1514
87c418bf 1515 /* Shut down all active vif entries */
ca8d4794
CS		 1516 if (flags & (MRT6_FLUSH_MIFS | MRT6_FLUSH_MIFS_STATIC)) {
1517 for (i = 0; i < mrt->maxvif; i++) {
1518 if (((mrt->vif_table[i].flags & VIFF_STATIC) &&
1519 !(flags & MRT6_FLUSH_MIFS_STATIC)) ||
1520 (!(mrt->vif_table[i].flags & VIFF_STATIC) && !(flags & MRT6_FLUSH_MIFS)))
1521 continue;
1522 mif6_delete(mrt, i, 0, &list);
1523 }
1524 unregister_netdevice_many(&list);
7bc570c8
YH		 1525 }
1526
87c418bf 1527 /* Wipe the cache */
ca8d4794
CS		 1528 if (flags & (MRT6_FLUSH_MFC | MRT6_FLUSH_MFC_STATIC)) {
1529 list_for_each_entry_safe(c, tmp, &mrt->mfc_cache_list, list) {
1530 if (((c->mfc_flags & MFC_STATIC) && !(flags & MRT6_FLUSH_MFC_STATIC)) ||
1531 (!(c->mfc_flags & MFC_STATIC) && !(flags & MRT6_FLUSH_MFC)))
1532 continue;
1533 rhltable_remove(&mrt->mfc_hash, &c->mnode, ip6mr_rht_params);
1534 list_del_rcu(&c->list);
1535 call_ip6mr_mfc_entry_notifiers(read_pnet(&mrt->net),
1536 FIB_EVENT_ENTRY_DEL,
1537 (struct mfc6_cache *)c, mrt->id);
1538 mr6_netlink_event(mrt, (struct mfc6_cache *)c, RTM_DELROUTE);
1539 mr_cache_put(c);
1540 }
7bc570c8
YH		 1541 }
1542
ca8d4794
CS		 1543 if (flags & MRT6_FLUSH_MFC) {
1544 if (atomic_read(&mrt->cache_resolve_queue_len) != 0) {
1545 spin_lock_bh(&mfc_unres_lock);
1546 list_for_each_entry_safe(c, tmp, &mrt->mfc_unres_queue, list) {
1547 list_del(&c->list);
1548 mr6_netlink_event(mrt, (struct mfc6_cache *)c,
1549 RTM_DELROUTE);
1550 ip6mr_destroy_unres(mrt, (struct mfc6_cache *)c);
1551 }
1552 spin_unlock_bh(&mfc_unres_lock);
7bc570c8 1553 }
7bc570c8
YH		 1554 }
1555}
1556
b70432f7 1557static int ip6mr_sk_init(struct mr_table *mrt, struct sock *sk)
7bc570c8
YH		 1558{
1559 int err = 0;
8229efda 1560 struct net *net = sock_net(sk);
7bc570c8
YH		 1561
1562 rtnl_lock();
1563 write_lock_bh(&mrt_lock);
b70432f7 1564 if (rtnl_dereference(mrt->mroute_sk)) {
7bc570c8 1565 err = -EADDRINUSE;
8571ab47 1566 } else {
b70432f7 1567 rcu_assign_pointer(mrt->mroute_sk, sk);
a366e300 1568 sock_set_flag(sk, SOCK_RCU_FREE);
145c7a79 1569 atomic_inc(&net->ipv6.devconf_all->mc_forwarding);
927265bc 1570 }
7bc570c8
YH		 1571 write_unlock_bh(&mrt_lock);
1572
927265bc 1573 if (!err)
85b3daad
DA		 1574 inet6_netconf_notify_devconf(net, RTM_NEWNETCONF,
1575 NETCONFA_MC_FORWARDING,
927265bc
ED		 1576 NETCONFA_IFINDEX_ALL,
1577 net->ipv6.devconf_all);
7bc570c8
YH		 1578 rtnl_unlock();
1579
1580 return err;
1581}
1582
1583int ip6mr_sk_done(struct sock *sk)
1584{
8229efda 1585 struct net *net = sock_net(sk);
7d9b1b57 1586 struct ipv6_devconf *devconf;
b70432f7 1587 struct mr_table *mrt;
7d9b1b57 1588 int err = -EACCES;
7bc570c8 1589
338d182f
FR		 1590 if (sk->sk_type != SOCK_RAW ||
1591 inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
1592 return err;
1593
7d9b1b57
ED		 1594 devconf = net->ipv6.devconf_all;
1595 if (!devconf || !atomic_read(&devconf->mc_forwarding))
f2f2325e
ED		 1596 return err;
1597
7bc570c8 1598 rtnl_lock();
d1db275d 1599 ip6mr_for_each_table(mrt, net) {
b70432f7 1600 if (sk == rtnl_dereference(mrt->mroute_sk)) {
d1db275d 1601 write_lock_bh(&mrt_lock);
b70432f7 1602 RCU_INIT_POINTER(mrt->mroute_sk, NULL);
a366e300
ED		 1603 /* Note that mroute_sk had SOCK_RCU_FREE set,
1604 * so the RCU grace period before sk freeing
1605 * is guaranteed by sk_destruct()
1606 */
7d9b1b57 1607 atomic_dec(&devconf->mc_forwarding);
927265bc 1608 write_unlock_bh(&mrt_lock);
85b3daad 1609 inet6_netconf_notify_devconf(net, RTM_NEWNETCONF,
d67b8c61
ND		 1610 NETCONFA_MC_FORWARDING,
1611 NETCONFA_IFINDEX_ALL,
1612 net->ipv6.devconf_all);
7bc570c8 1613
ca8d4794 1614 mroute_clean_tables(mrt, MRT6_FLUSH_MIFS | MRT6_FLUSH_MFC);
d1db275d
PM		 1615 err = 0;
1616 break;
1617 }
1618 }
7bc570c8
YH		 1619 rtnl_unlock();
1620
1621 return err;
1622}
1623
8571ab47 1624bool mroute6_is_socket(struct net *net, struct sk_buff *skb)
6bd52143 1625{
b70432f7 1626 struct mr_table *mrt;
4c9483b2 1627 struct flowi6 fl6 = {
e374c618 1628 .flowi6_iif = skb->skb_iif ? : LOOPBACK_IFINDEX,
4c9483b2
DM		 1629 .flowi6_oif = skb->dev->ifindex,
1630 .flowi6_mark = skb->mark,
d1db275d
PM		 1631 };
1632
4c9483b2 1633 if (ip6mr_fib_lookup(net, &fl6, &mrt) < 0)
d1db275d 1634 return NULL;
6bd52143 1635
b70432f7 1636 return rcu_access_pointer(mrt->mroute_sk);
6bd52143 1637}
8571ab47 1638EXPORT_SYMBOL(mroute6_is_socket);
6bd52143 1639
7bc570c8
YH		 1640/*
1641 * Socket options and virtual interface manipulation. The whole
1642 * virtual interface system is a complete heap, but unfortunately
1643 * that's how BSD mrouted happens to think. Maybe one day with a proper
1644 * MOSPF/PIM router set up we can clean this up.
1645 */
1646
b43c6153
CH		 1647int ip6_mroute_setsockopt(struct sock *sk, int optname, sockptr_t optval,
1648 unsigned int optlen)
7bc570c8 1649{
660b26dc 1650 int ret, parent = 0;
7bc570c8
YH		 1651 struct mif6ctl vif;
1652 struct mf6cctl mfc;
1653 mifi_t mifi;
8229efda 1654 struct net *net = sock_net(sk);
b70432f7 1655 struct mr_table *mrt;
d1db275d 1656
99253eb7
XL		 1657 if (sk->sk_type != SOCK_RAW ||
1658 inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
1659 return -EOPNOTSUPP;
1660
d1db275d 1661 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
63159f29 1662 if (!mrt)
d1db275d 1663 return -ENOENT;
7bc570c8
YH		 1664
1665 if (optname != MRT6_INIT) {
b70432f7 1666 if (sk != rcu_access_pointer(mrt->mroute_sk) &&
8571ab47 1667 !ns_capable(net->user_ns, CAP_NET_ADMIN))
7bc570c8
YH		 1668 return -EACCES;
1669 }
1670
1671 switch (optname) {
1672 case MRT6_INIT:
7bc570c8
YH		 1673 if (optlen < sizeof(int))
1674 return -EINVAL;
1675
6bd52143 1676 return ip6mr_sk_init(mrt, sk);
7bc570c8
YH		 1677
1678 case MRT6_DONE:
1679 return ip6mr_sk_done(sk);
1680
1681 case MRT6_ADD_MIF:
1682 if (optlen < sizeof(vif))
1683 return -EINVAL;
b43c6153 1684 if (copy_from_sockptr(&vif, optval, sizeof(vif)))
7bc570c8 1685 return -EFAULT;
6ac7eb08 1686 if (vif.mif6c_mifi >= MAXMIFS)
7bc570c8
YH		 1687 return -ENFILE;
1688 rtnl_lock();
8571ab47 1689 ret = mif6_add(net, mrt, &vif,
b70432f7 1690 sk == rtnl_dereference(mrt->mroute_sk));
7bc570c8
YH		 1691 rtnl_unlock();
1692 return ret;
1693
1694 case MRT6_DEL_MIF:
1695 if (optlen < sizeof(mifi_t))
1696 return -EINVAL;
b43c6153 1697 if (copy_from_sockptr(&mifi, optval, sizeof(mifi_t)))
7bc570c8
YH		 1698 return -EFAULT;
1699 rtnl_lock();
723b929c 1700 ret = mif6_delete(mrt, mifi, 0, NULL);
7bc570c8
YH		 1701 rtnl_unlock();
1702 return ret;
1703
1704 /*
1705 * Manipulate the forwarding caches. These live
1706 * in a sort of kernel/user symbiosis.
1707 */
1708 case MRT6_ADD_MFC:
1709 case MRT6_DEL_MFC:
660b26dc 1710 parent = -1;
a8eceea8 1711 fallthrough;
660b26dc
ND		 1712 case MRT6_ADD_MFC_PROXY:
1713 case MRT6_DEL_MFC_PROXY:
7bc570c8
YH		 1714 if (optlen < sizeof(mfc))
1715 return -EINVAL;
b43c6153 1716 if (copy_from_sockptr(&mfc, optval, sizeof(mfc)))
7bc570c8 1717 return -EFAULT;
660b26dc
ND		 1718 if (parent == 0)
1719 parent = mfc.mf6cc_parent;
7bc570c8 1720 rtnl_lock();
660b26dc
ND		 1721 if (optname == MRT6_DEL_MFC || optname == MRT6_DEL_MFC_PROXY)
1722 ret = ip6mr_mfc_delete(mrt, &mfc, parent);
7bc570c8 1723 else
660b26dc 1724 ret = ip6mr_mfc_add(net, mrt, &mfc,
8571ab47 1725 sk ==
b70432f7 1726 rtnl_dereference(mrt->mroute_sk),
8571ab47 1727 parent);
7bc570c8
YH		 1728 rtnl_unlock();
1729 return ret;
1730
ca8d4794
CS		 1731 case MRT6_FLUSH:
1732 {
1733 int flags;
1734
1735 if (optlen != sizeof(flags))
1736 return -EINVAL;
b43c6153 1737 if (copy_from_sockptr(&flags, optval, sizeof(flags)))
ca8d4794
CS		 1738 return -EFAULT;
1739 rtnl_lock();
1740 mroute_clean_tables(mrt, flags);
1741 rtnl_unlock();
1742 return 0;
1743 }
1744
14fb64e1
YH		 1745 /*
1746 * Control PIM assert (to activate pim will activate assert)
1747 */
1748 case MRT6_ASSERT:
1749 {
1750 int v;
03f52a0a
JP		 1751
1752 if (optlen != sizeof(v))
1753 return -EINVAL;
b43c6153 1754 if (copy_from_sockptr(&v, optval, sizeof(v)))
14fb64e1 1755 return -EFAULT;
53d6841d 1756 mrt->mroute_do_assert = v;
14fb64e1
YH		 1757 return 0;
1758 }
1759
1760#ifdef CONFIG_IPV6_PIMSM_V2
1761 case MRT6_PIM:
1762 {
a3ebe92a 1763 bool do_wrmifwhole;
a9f83bf3 1764 int v;
03f52a0a
JP		 1765
1766 if (optlen != sizeof(v))
1767 return -EINVAL;
b43c6153 1768 if (copy_from_sockptr(&v, optval, sizeof(v)))
14fb64e1 1769 return -EFAULT;
4b340a5a
MR		 1770
1771 do_wrmifwhole = (v == MRT6MSG_WRMIFWHOLE);
14fb64e1
YH		 1772 v = !!v;
1773 rtnl_lock();
1774 ret = 0;
6bd52143
PM		 1775 if (v != mrt->mroute_do_pim) {
1776 mrt->mroute_do_pim = v;
1777 mrt->mroute_do_assert = v;
4b340a5a 1778 mrt->mroute_do_wrvifwhole = do_wrmifwhole;
14fb64e1
YH		 1779 }
1780 rtnl_unlock();
1781 return ret;
1782 }
1783
d1db275d
PM		 1784#endif
1785#ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
1786 case MRT6_TABLE:
1787 {
1788 u32 v;
1789
1790 if (optlen != sizeof(u32))
1791 return -EINVAL;
b43c6153 1792 if (copy_from_sockptr(&v, optval, sizeof(v)))
d1db275d 1793 return -EFAULT;
75356a81
DC		 1794 /* "pim6reg%u" should not exceed 16 bytes (IFNAMSIZ) */
1795 if (v != RT_TABLE_DEFAULT && v >= 100000000)
1796 return -EINVAL;
b70432f7 1797 if (sk == rcu_access_pointer(mrt->mroute_sk))
d1db275d
PM		 1798 return -EBUSY;
1799
1800 rtnl_lock();
1801 ret = 0;
e783bb00
SD		 1802 mrt = ip6mr_new_table(net, v);
1803 if (IS_ERR(mrt))
1804 ret = PTR_ERR(mrt);
848235ed
SD		 1805 else
1806 raw6_sk(sk)->ip6mr_table = v;
d1db275d
PM		 1807 rtnl_unlock();
1808 return ret;
1809 }
14fb64e1 1810#endif
7bc570c8 1811 /*
7d120c55 1812 * Spurious command, or MRT6_VERSION which you cannot
7bc570c8
YH		 1813 * set.
1814 */
1815 default:
1816 return -ENOPROTOOPT;
1817 }
1818}
1819
1820/*
1821 * Getsock opt support for the multicast routing system.
1822 */
1823
1824int ip6_mroute_getsockopt(struct sock *sk, int optname, char __user *optval,
1825 int __user *optlen)
1826{
1827 int olr;
1828 int val;
8229efda 1829 struct net *net = sock_net(sk);
b70432f7 1830 struct mr_table *mrt;
d1db275d 1831
99253eb7
XL		 1832 if (sk->sk_type != SOCK_RAW ||
1833 inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
1834 return -EOPNOTSUPP;
1835
d1db275d 1836 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
63159f29 1837 if (!mrt)
d1db275d 1838 return -ENOENT;
7bc570c8
YH		 1839
1840 switch (optname) {
1841 case MRT6_VERSION:
1842 val = 0x0305;
1843 break;
14fb64e1
YH		 1844#ifdef CONFIG_IPV6_PIMSM_V2
1845 case MRT6_PIM:
6bd52143 1846 val = mrt->mroute_do_pim;
14fb64e1
YH		 1847 break;
1848#endif
1849 case MRT6_ASSERT:
6bd52143 1850 val = mrt->mroute_do_assert;
14fb64e1 1851 break;
7bc570c8
YH		 1852 default:
1853 return -ENOPROTOOPT;
1854 }
1855
1856 if (get_user(olr, optlen))
1857 return -EFAULT;
1858
1859 olr = min_t(int, olr, sizeof(int));
1860 if (olr < 0)
1861 return -EINVAL;
1862
1863 if (put_user(olr, optlen))
1864 return -EFAULT;
1865 if (copy_to_user(optval, &val, olr))
1866 return -EFAULT;
1867 return 0;
1868}
1869
1870/*
1871 * The IP multicast ioctl support routines.
1872 */
1873
1874int ip6mr_ioctl(struct sock *sk, int cmd, void __user *arg)
1875{
1876 struct sioc_sg_req6 sr;
1877 struct sioc_mif_req6 vr;
6853f21f 1878 struct vif_device *vif;
7bc570c8 1879 struct mfc6_cache *c;
8229efda 1880 struct net *net = sock_net(sk);
b70432f7 1881 struct mr_table *mrt;
d1db275d
PM		 1882
1883 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
63159f29 1884 if (!mrt)
d1db275d 1885 return -ENOENT;
7bc570c8
YH		 1886
1887 switch (cmd) {
1888 case SIOCGETMIFCNT_IN6:
1889 if (copy_from_user(&vr, arg, sizeof(vr)))
1890 return -EFAULT;
6bd52143 1891 if (vr.mifi >= mrt->maxvif)
7bc570c8 1892 return -EINVAL;
69d2c867 1893 vr.mifi = array_index_nospec(vr.mifi, mrt->maxvif);
7bc570c8 1894 read_lock(&mrt_lock);
b70432f7
YM		 1895 vif = &mrt->vif_table[vr.mifi];
1896 if (VIF_EXISTS(mrt, vr.mifi)) {
7bc570c8
YH		 1897 vr.icount = vif->pkt_in;
1898 vr.ocount = vif->pkt_out;
1899 vr.ibytes = vif->bytes_in;
1900 vr.obytes = vif->bytes_out;
1901 read_unlock(&mrt_lock);
1902
1903 if (copy_to_user(arg, &vr, sizeof(vr)))
1904 return -EFAULT;
1905 return 0;
1906 }
1907 read_unlock(&mrt_lock);
1908 return -EADDRNOTAVAIL;
1909 case SIOCGETSGCNT_IN6:
1910 if (copy_from_user(&sr, arg, sizeof(sr)))
1911 return -EFAULT;
1912
87c418bf 1913 rcu_read_lock();
6bd52143 1914 c = ip6mr_cache_find(mrt, &sr.src.sin6_addr, &sr.grp.sin6_addr);
7bc570c8 1915 if (c) {
494fff56
YM		 1916 sr.pktcnt = c->_c.mfc_un.res.pkt;
1917 sr.bytecnt = c->_c.mfc_un.res.bytes;
1918 sr.wrong_if = c->_c.mfc_un.res.wrong_if;
87c418bf 1919 rcu_read_unlock();
7bc570c8
YH		 1920
1921 if (copy_to_user(arg, &sr, sizeof(sr)))
1922 return -EFAULT;
1923 return 0;
1924 }
87c418bf 1925 rcu_read_unlock();
7bc570c8
YH		 1926 return -EADDRNOTAVAIL;
1927 default:
1928 return -ENOIOCTLCMD;
1929 }
1930}
1931
e2d57766
DM		 1932#ifdef CONFIG_COMPAT
1933struct compat_sioc_sg_req6 {
1934 struct sockaddr_in6 src;
1935 struct sockaddr_in6 grp;
1936 compat_ulong_t pktcnt;
1937 compat_ulong_t bytecnt;
1938 compat_ulong_t wrong_if;
1939};
1940
1941struct compat_sioc_mif_req6 {
1942 mifi_t mifi;
1943 compat_ulong_t icount;
1944 compat_ulong_t ocount;
1945 compat_ulong_t ibytes;
1946 compat_ulong_t obytes;
1947};
1948
1949int ip6mr_compat_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
1950{
1951 struct compat_sioc_sg_req6 sr;
1952 struct compat_sioc_mif_req6 vr;
6853f21f 1953 struct vif_device *vif;
e2d57766
DM		 1954 struct mfc6_cache *c;
1955 struct net *net = sock_net(sk);
b70432f7 1956 struct mr_table *mrt;
e2d57766
DM		 1957
1958 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
63159f29 1959 if (!mrt)
e2d57766
DM		 1960 return -ENOENT;
1961
1962 switch (cmd) {
1963 case SIOCGETMIFCNT_IN6:
1964 if (copy_from_user(&vr, arg, sizeof(vr)))
1965 return -EFAULT;
1966 if (vr.mifi >= mrt->maxvif)
1967 return -EINVAL;
69d2c867 1968 vr.mifi = array_index_nospec(vr.mifi, mrt->maxvif);
e2d57766 1969 read_lock(&mrt_lock);
b70432f7
YM		 1970 vif = &mrt->vif_table[vr.mifi];
1971 if (VIF_EXISTS(mrt, vr.mifi)) {
e2d57766
DM		 1972 vr.icount = vif->pkt_in;
1973 vr.ocount = vif->pkt_out;
1974 vr.ibytes = vif->bytes_in;
1975 vr.obytes = vif->bytes_out;
1976 read_unlock(&mrt_lock);
1977
1978 if (copy_to_user(arg, &vr, sizeof(vr)))
1979 return -EFAULT;
1980 return 0;
1981 }
1982 read_unlock(&mrt_lock);
1983 return -EADDRNOTAVAIL;
1984 case SIOCGETSGCNT_IN6:
1985 if (copy_from_user(&sr, arg, sizeof(sr)))
1986 return -EFAULT;
1987
87c418bf 1988 rcu_read_lock();
e2d57766
DM		 1989 c = ip6mr_cache_find(mrt, &sr.src.sin6_addr, &sr.grp.sin6_addr);
1990 if (c) {
494fff56
YM		 1991 sr.pktcnt = c->_c.mfc_un.res.pkt;
1992 sr.bytecnt = c->_c.mfc_un.res.bytes;
1993 sr.wrong_if = c->_c.mfc_un.res.wrong_if;
87c418bf 1994 rcu_read_unlock();
e2d57766
DM		 1995
1996 if (copy_to_user(arg, &sr, sizeof(sr)))
1997 return -EFAULT;
1998 return 0;
1999 }
87c418bf 2000 rcu_read_unlock();
e2d57766
DM		 2001 return -EADDRNOTAVAIL;
2002 default:
2003 return -ENOIOCTLCMD;
2004 }
2005}
2006#endif
7bc570c8 2007
0c4b51f0 2008static inline int ip6mr_forward2_finish(struct net *net, struct sock *sk, struct sk_buff *skb)
7bc570c8 2009{
87c11f1d
IS		 2010 IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
2011 IPSTATS_MIB_OUTFORWDATAGRAMS);
2012 IP6_ADD_STATS(net, ip6_dst_idev(skb_dst(skb)),
2013 IPSTATS_MIB_OUTOCTETS, skb->len);
13206b6b 2014 return dst_output(net, sk, skb);
7bc570c8
YH		 2015}
2016
2017/*
2018 * Processing handlers for ip6mr_forward
2019 */
2020
b70432f7 2021static int ip6mr_forward2(struct net *net, struct mr_table *mrt,
f5c6dfde 2022 struct sk_buff *skb, int vifi)
7bc570c8
YH		 2023{
2024 struct ipv6hdr *ipv6h;
b70432f7 2025 struct vif_device *vif = &mrt->vif_table[vifi];
7bc570c8
YH		 2026 struct net_device *dev;
2027 struct dst_entry *dst;
4c9483b2 2028 struct flowi6 fl6;
7bc570c8 2029
63159f29 2030 if (!vif->dev)
7bc570c8
YH		 2031 goto out_free;
2032
14fb64e1
YH		 2033#ifdef CONFIG_IPV6_PIMSM_V2
2034 if (vif->flags & MIFF_REGISTER) {
2035 vif->pkt_out++;
2036 vif->bytes_out += skb->len;
dc58c78c
PE		 2037 vif->dev->stats.tx_bytes += skb->len;
2038 vif->dev->stats.tx_packets++;
6bd52143 2039 ip6mr_cache_report(mrt, skb, vifi, MRT6MSG_WHOLEPKT);
8da73b73 2040 goto out_free;
14fb64e1
YH		 2041 }
2042#endif
2043
7bc570c8
YH		 2044 ipv6h = ipv6_hdr(skb);
2045
4c9483b2
DM		 2046 fl6 = (struct flowi6) {
2047 .flowi6_oif = vif->link,
2048 .daddr = ipv6h->daddr,
7bc570c8
YH		 2049 };
2050
4c9483b2 2051 dst = ip6_route_output(net, NULL, &fl6);
5095d64d
RL		 2052 if (dst->error) {
2053 dst_release(dst);
7bc570c8 2054 goto out_free;
5095d64d 2055 }
7bc570c8 2056
adf30907
ED		 2057 skb_dst_drop(skb);
2058 skb_dst_set(skb, dst);
7bc570c8
YH		 2059
2060 /*
2061 * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
2062 * not only before forwarding, but after forwarding on all output
2063 * interfaces. It is clear, if mrouter runs a multicasting
2064 * program, it should receive packets not depending to what interface
2065 * program is joined.
2066 * If we will not make it, the program will have to join on all
2067 * interfaces. On the other hand, multihoming host (or router, but
2068 * not mrouter) cannot join to more than one interface - it will
2069 * result in receiving multiple packets.
2070 */
2071 dev = vif->dev;
2072 skb->dev = dev;
2073 vif->pkt_out++;
2074 vif->bytes_out += skb->len;
2075
2076 /* We are about to write */
2077 /* XXX: extension headers? */
2078 if (skb_cow(skb, sizeof(*ipv6h) + LL_RESERVED_SPACE(dev)))
2079 goto out_free;
2080
2081 ipv6h = ipv6_hdr(skb);
2082 ipv6h->hop_limit--;
2083
2084 IP6CB(skb)->flags |= IP6SKB_FORWARDED;
2085
29a26a56
EB		 2086 return NF_HOOK(NFPROTO_IPV6, NF_INET_FORWARD,
2087 net, NULL, skb, skb->dev, dev,
7bc570c8
YH		 2088 ip6mr_forward2_finish);
2089
2090out_free:
2091 kfree_skb(skb);
2092 return 0;
2093}
2094
b70432f7 2095static int ip6mr_find_vif(struct mr_table *mrt, struct net_device *dev)
7bc570c8
YH		 2096{
2097 int ct;
6bd52143
PM		 2098
2099 for (ct = mrt->maxvif - 1; ct >= 0; ct--) {
b70432f7 2100 if (mrt->vif_table[ct].dev == dev)
7bc570c8
YH		 2101 break;
2102 }
2103 return ct;
2104}
2105
b70432f7 2106static void ip6_mr_forward(struct net *net, struct mr_table *mrt,
e4a38c0c
PR		 2107 struct net_device *dev, struct sk_buff *skb,
2108 struct mfc6_cache *c)
7bc570c8
YH		 2109{
2110 int psend = -1;
2111 int vif, ct;
e4a38c0c 2112 int true_vifi = ip6mr_find_vif(mrt, dev);
7bc570c8 2113
494fff56
YM		 2114 vif = c->_c.mfc_parent;
2115 c->_c.mfc_un.res.pkt++;
2116 c->_c.mfc_un.res.bytes += skb->len;
2117 c->_c.mfc_un.res.lastuse = jiffies;
7bc570c8 2118
494fff56 2119 if (ipv6_addr_any(&c->mf6c_origin) && true_vifi >= 0) {
660b26dc
ND		 2120 struct mfc6_cache *cache_proxy;
2121
40dc2ca3 2122 /* For an (*,G) entry, we only check that the incoming
660b26dc
ND		 2123 * interface is part of the static tree.
2124 */
87c418bf 2125 rcu_read_lock();
845c9a7a 2126 cache_proxy = mr_mfc_find_any_parent(mrt, vif);
660b26dc 2127 if (cache_proxy &&
494fff56 2128 cache_proxy->_c.mfc_un.res.ttls[true_vifi] < 255) {
87c418bf 2129 rcu_read_unlock();
660b26dc 2130 goto forward;
87c418bf
YM		 2131 }
2132 rcu_read_unlock();
660b26dc
ND		 2133 }
2134
14fb64e1
YH		 2135 /*
2136 * Wrong interface: drop packet and (maybe) send PIM assert.
2137 */
e4a38c0c 2138 if (mrt->vif_table[vif].dev != dev) {
494fff56 2139 c->_c.mfc_un.res.wrong_if++;
14fb64e1 2140
6bd52143 2141 if (true_vifi >= 0 && mrt->mroute_do_assert &&
14fb64e1
YH		 2142 /* pimsm uses asserts, when switching from RPT to SPT,
2143 so that we cannot check that packet arrived on an oif.
2144 It is bad, but otherwise we would need to move pretty
2145 large chunk of pimd to kernel. Ough... --ANK
2146 */
6bd52143 2147 (mrt->mroute_do_pim ||
494fff56 2148 c->_c.mfc_un.res.ttls[true_vifi] < 255) &&
14fb64e1 2149 time_after(jiffies,
494fff56
YM		 2150 c->_c.mfc_un.res.last_assert +
2151 MFC_ASSERT_THRESH)) {
2152 c->_c.mfc_un.res.last_assert = jiffies;
6bd52143 2153 ip6mr_cache_report(mrt, skb, true_vifi, MRT6MSG_WRONGMIF);
4b340a5a
MR		 2154 if (mrt->mroute_do_wrvifwhole)
2155 ip6mr_cache_report(mrt, skb, true_vifi,
2156 MRT6MSG_WRMIFWHOLE);
14fb64e1
YH		 2157 }
2158 goto dont_forward;
2159 }
2160
660b26dc 2161forward:
b70432f7
YM		 2162 mrt->vif_table[vif].pkt_in++;
2163 mrt->vif_table[vif].bytes_in += skb->len;
7bc570c8
YH		 2164
2165 /*
2166 * Forward the frame
2167 */
494fff56
YM		 2168 if (ipv6_addr_any(&c->mf6c_origin) &&
2169 ipv6_addr_any(&c->mf6c_mcastgrp)) {
660b26dc 2170 if (true_vifi >= 0 &&
494fff56 2171 true_vifi != c->_c.mfc_parent &&
660b26dc 2172 ipv6_hdr(skb)->hop_limit >
494fff56 2173 c->_c.mfc_un.res.ttls[c->_c.mfc_parent]) {
660b26dc
ND		 2174 /* It's an (*,*) entry and the packet is not coming from
2175 * the upstream: forward the packet to the upstream
2176 * only.
2177 */
494fff56 2178 psend = c->_c.mfc_parent;
660b26dc
ND		 2179 goto last_forward;
2180 }
2181 goto dont_forward;
2182 }
494fff56
YM		 2183 for (ct = c->_c.mfc_un.res.maxvif - 1;
2184 ct >= c->_c.mfc_un.res.minvif; ct--) {
660b26dc 2185 /* For (*,G) entry, don't forward to the incoming interface */
494fff56
YM		 2186 if ((!ipv6_addr_any(&c->mf6c_origin) || ct != true_vifi) &&
2187 ipv6_hdr(skb)->hop_limit > c->_c.mfc_un.res.ttls[ct]) {
7bc570c8
YH		 2188 if (psend != -1) {
2189 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
2190 if (skb2)
f5c6dfde 2191 ip6mr_forward2(net, mrt, skb2, psend);
7bc570c8
YH		 2192 }
2193 psend = ct;
2194 }
2195 }
660b26dc 2196last_forward:
7bc570c8 2197 if (psend != -1) {
f5c6dfde 2198 ip6mr_forward2(net, mrt, skb, psend);
2b52c3ad 2199 return;
7bc570c8
YH		 2200 }
2201
14fb64e1 2202dont_forward:
7bc570c8 2203 kfree_skb(skb);
7bc570c8
YH		 2204}
2205
2206
2207/*
2208 * Multicast packets for forwarding arrive here
2209 */
2210
2211int ip6_mr_input(struct sk_buff *skb)
2212{
2213 struct mfc6_cache *cache;
8229efda 2214 struct net *net = dev_net(skb->dev);
b70432f7 2215 struct mr_table *mrt;
4c9483b2
DM		 2216 struct flowi6 fl6 = {
2217 .flowi6_iif = skb->dev->ifindex,
2218 .flowi6_mark = skb->mark,
d1db275d
PM		 2219 };
2220 int err;
e4a38c0c
PR		 2221 struct net_device *dev;
2222
2223 /* skb->dev passed in is the master dev for vrfs.
2224 * Get the proper interface that does have a vif associated with it.
2225 */
2226 dev = skb->dev;
2227 if (netif_is_l3_master(skb->dev)) {
2228 dev = dev_get_by_index_rcu(net, IPCB(skb)->iif);
2229 if (!dev) {
2230 kfree_skb(skb);
2231 return -ENODEV;
2232 }
2233 }
d1db275d 2234
4c9483b2 2235 err = ip6mr_fib_lookup(net, &fl6, &mrt);
2015de5f
BG		 2236 if (err < 0) {
2237 kfree_skb(skb);
d1db275d 2238 return err;
2015de5f 2239 }
7bc570c8
YH		 2240
2241 read_lock(&mrt_lock);
6bd52143 2242 cache = ip6mr_cache_find(mrt,
8229efda 2243 &ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr);
63159f29 2244 if (!cache) {
e4a38c0c 2245 int vif = ip6mr_find_vif(mrt, dev);
660b26dc
ND		 2246
2247 if (vif >= 0)
2248 cache = ip6mr_cache_find_any(mrt,
2249 &ipv6_hdr(skb)->daddr,
2250 vif);
2251 }
7bc570c8
YH		 2252
2253 /*
2254 * No usable cache entry
2255 */
63159f29 2256 if (!cache) {
7bc570c8
YH		 2257 int vif;
2258
e4a38c0c 2259 vif = ip6mr_find_vif(mrt, dev);
7bc570c8 2260 if (vif >= 0) {
e4a38c0c 2261 int err = ip6mr_cache_unresolved(mrt, vif, skb, dev);
7bc570c8
YH		 2262 read_unlock(&mrt_lock);
2263
2264 return err;
2265 }
2266 read_unlock(&mrt_lock);
2267 kfree_skb(skb);
2268 return -ENODEV;
2269 }
2270
e4a38c0c 2271 ip6_mr_forward(net, mrt, dev, skb, cache);
7bc570c8
YH		 2272
2273 read_unlock(&mrt_lock);
2274
2275 return 0;
2276}
2277
2cf75070 2278int ip6mr_get_route(struct net *net, struct sk_buff *skb, struct rtmsg *rtm,
fd61c6ba 2279 u32 portid)
7bc570c8
YH		 2280{
2281 int err;
b70432f7 2282 struct mr_table *mrt;
7bc570c8 2283 struct mfc6_cache *cache;
adf30907 2284 struct rt6_info *rt = (struct rt6_info *)skb_dst(skb);
7bc570c8 2285
d1db275d 2286 mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
63159f29 2287 if (!mrt)
d1db275d
PM		 2288 return -ENOENT;
2289
7bc570c8 2290 read_lock(&mrt_lock);
6bd52143 2291 cache = ip6mr_cache_find(mrt, &rt->rt6i_src.addr, &rt->rt6i_dst.addr);
660b26dc
ND		 2292 if (!cache && skb->dev) {
2293 int vif = ip6mr_find_vif(mrt, skb->dev);
2294
2295 if (vif >= 0)
2296 cache = ip6mr_cache_find_any(mrt, &rt->rt6i_dst.addr,
2297 vif);
2298 }
7bc570c8
YH		 2299
2300 if (!cache) {
2301 struct sk_buff *skb2;
2302 struct ipv6hdr *iph;
2303 struct net_device *dev;
2304 int vif;
2305
7bc570c8 2306 dev = skb->dev;
63159f29 2307 if (!dev || (vif = ip6mr_find_vif(mrt, dev)) < 0) {
7bc570c8
YH		 2308 read_unlock(&mrt_lock);
2309 return -ENODEV;
2310 }
2311
2312 /* really correct? */
2313 skb2 = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC);
2314 if (!skb2) {
2315 read_unlock(&mrt_lock);
2316 return -ENOMEM;
2317 }
2318
2cf75070 2319 NETLINK_CB(skb2).portid = portid;
7bc570c8
YH		 2320 skb_reset_transport_header(skb2);
2321
2322 skb_put(skb2, sizeof(struct ipv6hdr));
2323 skb_reset_network_header(skb2);
2324
2325 iph = ipv6_hdr(skb2);
2326 iph->version = 0;
2327 iph->priority = 0;
2328 iph->flow_lbl[0] = 0;
2329 iph->flow_lbl[1] = 0;
2330 iph->flow_lbl[2] = 0;
2331 iph->payload_len = 0;
2332 iph->nexthdr = IPPROTO_NONE;
2333 iph->hop_limit = 0;
4e3fd7a0
AD		 2334 iph->saddr = rt->rt6i_src.addr;
2335 iph->daddr = rt->rt6i_dst.addr;
7bc570c8 2336
e4a38c0c 2337 err = ip6mr_cache_unresolved(mrt, vif, skb2, dev);
7bc570c8
YH		 2338 read_unlock(&mrt_lock);
2339
2340 return err;
2341 }
2342
7b0db857 2343 err = mr_fill_mroute(mrt, skb, &cache->_c, rtm);
7bc570c8
YH		 2344 read_unlock(&mrt_lock);
2345 return err;
2346}
2347
b70432f7 2348static int ip6mr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
f518338b
ND		 2349 u32 portid, u32 seq, struct mfc6_cache *c, int cmd,
2350 int flags)
5b285cac
PM		 2351{
2352 struct nlmsghdr *nlh;
2353 struct rtmsg *rtm;
1eb99af5 2354 int err;
5b285cac 2355
f518338b 2356 nlh = nlmsg_put(skb, portid, seq, cmd, sizeof(*rtm), flags);
63159f29 2357 if (!nlh)
5b285cac
PM		 2358 return -EMSGSIZE;
2359
2360 rtm = nlmsg_data(nlh);
193c1e47 2361 rtm->rtm_family = RTNL_FAMILY_IP6MR;
5b285cac
PM		 2362 rtm->rtm_dst_len = 128;
2363 rtm->rtm_src_len = 128;
2364 rtm->rtm_tos = 0;
2365 rtm->rtm_table = mrt->id;
c78679e8
DM		 2366 if (nla_put_u32(skb, RTA_TABLE, mrt->id))
2367 goto nla_put_failure;
1eb99af5 2368 rtm->rtm_type = RTN_MULTICAST;
5b285cac 2369 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
494fff56 2370 if (c->_c.mfc_flags & MFC_STATIC)
9a68ac72
ND		 2371 rtm->rtm_protocol = RTPROT_STATIC;
2372 else
2373 rtm->rtm_protocol = RTPROT_MROUTED;
5b285cac
PM		 2374 rtm->rtm_flags = 0;
2375
930345ea
JB		 2376 if (nla_put_in6_addr(skb, RTA_SRC, &c->mf6c_origin) ||
2377 nla_put_in6_addr(skb, RTA_DST, &c->mf6c_mcastgrp))
c78679e8 2378 goto nla_put_failure;
7b0db857 2379 err = mr_fill_mroute(mrt, skb, &c->_c, rtm);
1eb99af5
ND		 2380 /* do not break the dump if cache is unresolved */
2381 if (err < 0 && err != -ENOENT)
5b285cac
PM		 2382 goto nla_put_failure;
2383
053c095a
JB		 2384 nlmsg_end(skb, nlh);
2385 return 0;
5b285cac
PM		 2386
2387nla_put_failure:
2388 nlmsg_cancel(skb, nlh);
2389 return -EMSGSIZE;
2390}
2391
7b0db857
YM		 2392static int _ip6mr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
2393 u32 portid, u32 seq, struct mr_mfc *c,
2394 int cmd, int flags)
2395{
2396 return ip6mr_fill_mroute(mrt, skb, portid, seq, (struct mfc6_cache *)c,
2397 cmd, flags);
2398}
2399
812e44dd
ND		 2400static int mr6_msgsize(bool unresolved, int maxvif)
2401{
2402 size_t len =
2403 NLMSG_ALIGN(sizeof(struct rtmsg))
2404 + nla_total_size(4) /* RTA_TABLE */
2405 + nla_total_size(sizeof(struct in6_addr)) /* RTA_SRC */
2406 + nla_total_size(sizeof(struct in6_addr)) /* RTA_DST */
2407 ;
2408
2409 if (!unresolved)
2410 len = len
2411 + nla_total_size(4) /* RTA_IIF */
2412 + nla_total_size(0) /* RTA_MULTIPATH */
2413 + maxvif * NLA_ALIGN(sizeof(struct rtnexthop))
2414 /* RTA_MFC_STATS */
3d6b66c1 2415 + nla_total_size_64bit(sizeof(struct rta_mfc_stats))
812e44dd
ND		 2416 ;
2417
2418 return len;
2419}
2420
b70432f7 2421static void mr6_netlink_event(struct mr_table *mrt, struct mfc6_cache *mfc,
812e44dd
ND		 2422 int cmd)
2423{
2424 struct net *net = read_pnet(&mrt->net);
2425 struct sk_buff *skb;
2426 int err = -ENOBUFS;
2427
494fff56 2428 skb = nlmsg_new(mr6_msgsize(mfc->_c.mfc_parent >= MAXMIFS, mrt->maxvif),
812e44dd 2429 GFP_ATOMIC);
63159f29 2430 if (!skb)
812e44dd
ND		 2431 goto errout;
2432
f518338b 2433 err = ip6mr_fill_mroute(mrt, skb, 0, 0, mfc, cmd, 0);
812e44dd
ND		 2434 if (err < 0)
2435 goto errout;
2436
2437 rtnl_notify(skb, net, 0, RTNLGRP_IPV6_MROUTE, NULL, GFP_ATOMIC);
2438 return;
2439
2440errout:
2441 kfree_skb(skb);
2442 if (err < 0)
2443 rtnl_set_sk_err(net, RTNLGRP_IPV6_MROUTE, err);
2444}
2445
dd12d15c
JG		 2446static size_t mrt6msg_netlink_msgsize(size_t payloadlen)
2447{
2448 size_t len =
2449 NLMSG_ALIGN(sizeof(struct rtgenmsg))
2450 + nla_total_size(1) /* IP6MRA_CREPORT_MSGTYPE */
2451 + nla_total_size(4) /* IP6MRA_CREPORT_MIF_ID */
2452 /* IP6MRA_CREPORT_SRC_ADDR */
2453 + nla_total_size(sizeof(struct in6_addr))
2454 /* IP6MRA_CREPORT_DST_ADDR */
2455 + nla_total_size(sizeof(struct in6_addr))
2456 /* IP6MRA_CREPORT_PKT */
2457 + nla_total_size(payloadlen)
2458 ;
2459
2460 return len;
2461}
2462
b70432f7 2463static void mrt6msg_netlink_event(struct mr_table *mrt, struct sk_buff *pkt)
dd12d15c
JG		 2464{
2465 struct net *net = read_pnet(&mrt->net);
2466 struct nlmsghdr *nlh;
2467 struct rtgenmsg *rtgenm;
2468 struct mrt6msg *msg;
2469 struct sk_buff *skb;
2470 struct nlattr *nla;
2471 int payloadlen;
2472
2473 payloadlen = pkt->len - sizeof(struct mrt6msg);
2474 msg = (struct mrt6msg *)skb_transport_header(pkt);
2475
2476 skb = nlmsg_new(mrt6msg_netlink_msgsize(payloadlen), GFP_ATOMIC);
2477 if (!skb)
2478 goto errout;
2479
2480 nlh = nlmsg_put(skb, 0, 0, RTM_NEWCACHEREPORT,
2481 sizeof(struct rtgenmsg), 0);
2482 if (!nlh)
2483 goto errout;
2484 rtgenm = nlmsg_data(nlh);
2485 rtgenm->rtgen_family = RTNL_FAMILY_IP6MR;
2486 if (nla_put_u8(skb, IP6MRA_CREPORT_MSGTYPE, msg->im6_msgtype) ||
2487 nla_put_u32(skb, IP6MRA_CREPORT_MIF_ID, msg->im6_mif) ||
2488 nla_put_in6_addr(skb, IP6MRA_CREPORT_SRC_ADDR,
2489 &msg->im6_src) ||
2490 nla_put_in6_addr(skb, IP6MRA_CREPORT_DST_ADDR,
2491 &msg->im6_dst))
2492 goto nla_put_failure;
2493
2494 nla = nla_reserve(skb, IP6MRA_CREPORT_PKT, payloadlen);
2495 if (!nla || skb_copy_bits(pkt, sizeof(struct mrt6msg),
2496 nla_data(nla), payloadlen))
2497 goto nla_put_failure;
2498
2499 nlmsg_end(skb, nlh);
2500
2501 rtnl_notify(skb, net, 0, RTNLGRP_IPV6_MROUTE_R, NULL, GFP_ATOMIC);
2502 return;
2503
2504nla_put_failure:
2505 nlmsg_cancel(skb, nlh);
2506errout:
2507 kfree_skb(skb);
2508 rtnl_set_sk_err(net, RTNLGRP_IPV6_MROUTE_R, -ENOBUFS);
2509}
2510
5b285cac
PM		 2511static int ip6mr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb)
2512{
e8ba330a 2513 const struct nlmsghdr *nlh = cb->nlh;
4724676d 2514 struct fib_dump_filter filter = {};
cb167893 2515 int err;
e8ba330a
DA		 2516
2517 if (cb->strict_check) {
4724676d 2518 err = ip_valid_fib_dump_req(sock_net(skb->sk), nlh,
effe6792 2519 &filter, cb);
e8ba330a
DA		 2520 if (err < 0)
2521 return err;
2522 }
2523
cb167893
DA		 2524 if (filter.table_id) {
2525 struct mr_table *mrt;
2526
2527 mrt = ip6mr_get_table(sock_net(skb->sk), filter.table_id);
2528 if (!mrt) {
41b4bd98 2529 if (rtnl_msg_family(cb->nlh) != RTNL_FAMILY_IP6MR)
ae677bbb
DA		 2530 return skb->len;
2531
cb167893
DA		 2532 NL_SET_ERR_MSG_MOD(cb->extack, "MR table does not exist");
2533 return -ENOENT;
2534 }
2535 err = mr_table_dump(mrt, skb, cb, _ip6mr_fill_mroute,
2536 &mfc_unres_lock, &filter);
2537 return skb->len ? : err;
2538 }
2539
7b0db857 2540 return mr_rtm_dumproute(skb, cb, ip6mr_mr_table_iter,
cb167893 2541 _ip6mr_fill_mroute, &mfc_unres_lock, &filter);
5b285cac 2542}
Linux 6.x block layer and io_uring tree(s)