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