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