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