2 * Linux IPv6 multicast routing support for BSD pim6sd
3 * Based on net/ipv4/ipmr.c.
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>
9 * Copyright (C)2007,2008 USAGI/WIDE Project
10 * YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
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.
19 #include <asm/uaccess.h>
20 #include <linux/types.h>
21 #include <linux/sched.h>
22 #include <linux/errno.h>
23 #include <linux/timer.h>
25 #include <linux/kernel.h>
26 #include <linux/fcntl.h>
27 #include <linux/stat.h>
28 #include <linux/socket.h>
29 #include <linux/inet.h>
30 #include <linux/netdevice.h>
31 #include <linux/inetdevice.h>
32 #include <linux/proc_fs.h>
33 #include <linux/seq_file.h>
34 #include <linux/init.h>
35 #include <linux/slab.h>
36 #include <linux/compat.h>
37 #include <net/protocol.h>
38 #include <linux/skbuff.h>
41 #include <linux/notifier.h>
42 #include <linux/if_arp.h>
43 #include <net/checksum.h>
44 #include <net/netlink.h>
45 #include <net/fib_rules.h>
48 #include <net/ip6_route.h>
49 #include <linux/mroute6.h>
50 #include <linux/pim.h>
51 #include <net/addrconf.h>
52 #include <linux/netfilter_ipv6.h>
53 #include <linux/export.h>
54 #include <net/ip6_checksum.h>
55 #include <linux/netconf.h>
58 struct list_head list;
61 struct sock *mroute6_sk;
62 struct timer_list ipmr_expire_timer;
63 struct list_head mfc6_unres_queue;
64 struct list_head mfc6_cache_array[MFC6_LINES];
65 struct mif_device vif6_table[MAXMIFS];
67 atomic_t cache_resolve_queue_len;
68 bool mroute_do_assert;
70 #ifdef CONFIG_IPV6_PIMSM_V2
71 int mroute_reg_vif_num;
75 #include <linux/nospec.h>
78 struct fib_rule common;
82 struct mr6_table *mrt;
85 /* Big lock, protecting vif table, mrt cache and mroute socket state.
86 Note that the changes are semaphored via rtnl_lock.
89 static DEFINE_RWLOCK(mrt_lock);
92 * Multicast router control variables
95 #define MIF_EXISTS(_mrt, _idx) ((_mrt)->vif6_table[_idx].dev != NULL)
97 /* Special spinlock for queue of unresolved entries */
98 static DEFINE_SPINLOCK(mfc_unres_lock);
100 /* We return to original Alan's scheme. Hash table of resolved
101 entries is changed only in process context and protected
102 with weak lock mrt_lock. Queue of unresolved entries is protected
103 with strong spinlock mfc_unres_lock.
105 In this case data path is free of exclusive locks at all.
108 static struct kmem_cache *mrt_cachep __read_mostly;
110 static struct mr6_table *ip6mr_new_table(struct net *net, u32 id);
111 static void ip6mr_free_table(struct mr6_table *mrt);
113 static void ip6_mr_forward(struct net *net, struct mr6_table *mrt,
114 struct sk_buff *skb, struct mfc6_cache *cache);
115 static int ip6mr_cache_report(struct mr6_table *mrt, struct sk_buff *pkt,
116 mifi_t mifi, int assert);
117 static int __ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb,
118 struct mfc6_cache *c, struct rtmsg *rtm);
119 static void mr6_netlink_event(struct mr6_table *mrt, struct mfc6_cache *mfc,
121 static int ip6mr_rtm_dumproute(struct sk_buff *skb,
122 struct netlink_callback *cb);
123 static void mroute_clean_tables(struct mr6_table *mrt, bool all);
124 static void ipmr_expire_process(unsigned long arg);
126 #ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
127 #define ip6mr_for_each_table(mrt, net) \
128 list_for_each_entry_rcu(mrt, &net->ipv6.mr6_tables, list)
130 static struct mr6_table *ip6mr_get_table(struct net *net, u32 id)
132 struct mr6_table *mrt;
134 ip6mr_for_each_table(mrt, net) {
141 static int ip6mr_fib_lookup(struct net *net, struct flowi6 *flp6,
142 struct mr6_table **mrt)
145 struct ip6mr_result res;
146 struct fib_lookup_arg arg = {
148 .flags = FIB_LOOKUP_NOREF,
151 err = fib_rules_lookup(net->ipv6.mr6_rules_ops,
152 flowi6_to_flowi(flp6), 0, &arg);
159 static int ip6mr_rule_action(struct fib_rule *rule, struct flowi *flp,
160 int flags, struct fib_lookup_arg *arg)
162 struct ip6mr_result *res = arg->result;
163 struct mr6_table *mrt;
165 switch (rule->action) {
168 case FR_ACT_UNREACHABLE:
170 case FR_ACT_PROHIBIT:
172 case FR_ACT_BLACKHOLE:
177 mrt = ip6mr_get_table(rule->fr_net, rule->table);
184 static int ip6mr_rule_match(struct fib_rule *rule, struct flowi *flp, int flags)
189 static const struct nla_policy ip6mr_rule_policy[FRA_MAX + 1] = {
193 static int ip6mr_rule_configure(struct fib_rule *rule, struct sk_buff *skb,
194 struct fib_rule_hdr *frh, struct nlattr **tb)
199 static int ip6mr_rule_compare(struct fib_rule *rule, struct fib_rule_hdr *frh,
205 static int ip6mr_rule_fill(struct fib_rule *rule, struct sk_buff *skb,
206 struct fib_rule_hdr *frh)
214 static const struct fib_rules_ops __net_initconst ip6mr_rules_ops_template = {
215 .family = RTNL_FAMILY_IP6MR,
216 .rule_size = sizeof(struct ip6mr_rule),
217 .addr_size = sizeof(struct in6_addr),
218 .action = ip6mr_rule_action,
219 .match = ip6mr_rule_match,
220 .configure = ip6mr_rule_configure,
221 .compare = ip6mr_rule_compare,
222 .fill = ip6mr_rule_fill,
223 .nlgroup = RTNLGRP_IPV6_RULE,
224 .policy = ip6mr_rule_policy,
225 .owner = THIS_MODULE,
228 static int __net_init ip6mr_rules_init(struct net *net)
230 struct fib_rules_ops *ops;
231 struct mr6_table *mrt;
234 ops = fib_rules_register(&ip6mr_rules_ops_template, net);
238 INIT_LIST_HEAD(&net->ipv6.mr6_tables);
240 mrt = ip6mr_new_table(net, RT6_TABLE_DFLT);
246 err = fib_default_rule_add(ops, 0x7fff, RT6_TABLE_DFLT, 0);
250 net->ipv6.mr6_rules_ops = ops;
255 ip6mr_free_table(mrt);
258 fib_rules_unregister(ops);
262 static void __net_exit ip6mr_rules_exit(struct net *net)
264 struct mr6_table *mrt, *next;
267 list_for_each_entry_safe(mrt, next, &net->ipv6.mr6_tables, list) {
268 list_del(&mrt->list);
269 ip6mr_free_table(mrt);
271 fib_rules_unregister(net->ipv6.mr6_rules_ops);
275 #define ip6mr_for_each_table(mrt, net) \
276 for (mrt = net->ipv6.mrt6; mrt; mrt = NULL)
278 static struct mr6_table *ip6mr_get_table(struct net *net, u32 id)
280 return net->ipv6.mrt6;
283 static int ip6mr_fib_lookup(struct net *net, struct flowi6 *flp6,
284 struct mr6_table **mrt)
286 *mrt = net->ipv6.mrt6;
290 static int __net_init ip6mr_rules_init(struct net *net)
292 net->ipv6.mrt6 = ip6mr_new_table(net, RT6_TABLE_DFLT);
293 return net->ipv6.mrt6 ? 0 : -ENOMEM;
296 static void __net_exit ip6mr_rules_exit(struct net *net)
299 ip6mr_free_table(net->ipv6.mrt6);
300 net->ipv6.mrt6 = NULL;
305 static struct mr6_table *ip6mr_new_table(struct net *net, u32 id)
307 struct mr6_table *mrt;
310 mrt = ip6mr_get_table(net, id);
314 mrt = kzalloc(sizeof(*mrt), GFP_KERNEL);
318 write_pnet(&mrt->net, net);
320 /* Forwarding cache */
321 for (i = 0; i < MFC6_LINES; i++)
322 INIT_LIST_HEAD(&mrt->mfc6_cache_array[i]);
324 INIT_LIST_HEAD(&mrt->mfc6_unres_queue);
326 setup_timer(&mrt->ipmr_expire_timer, ipmr_expire_process,
329 #ifdef CONFIG_IPV6_PIMSM_V2
330 mrt->mroute_reg_vif_num = -1;
332 #ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
333 list_add_tail_rcu(&mrt->list, &net->ipv6.mr6_tables);
338 static void ip6mr_free_table(struct mr6_table *mrt)
340 del_timer_sync(&mrt->ipmr_expire_timer);
341 mroute_clean_tables(mrt, true);
345 #ifdef CONFIG_PROC_FS
347 struct ipmr_mfc_iter {
348 struct seq_net_private p;
349 struct mr6_table *mrt;
350 struct list_head *cache;
355 static struct mfc6_cache *ipmr_mfc_seq_idx(struct net *net,
356 struct ipmr_mfc_iter *it, loff_t pos)
358 struct mr6_table *mrt = it->mrt;
359 struct mfc6_cache *mfc;
361 read_lock(&mrt_lock);
362 for (it->ct = 0; it->ct < MFC6_LINES; it->ct++) {
363 it->cache = &mrt->mfc6_cache_array[it->ct];
364 list_for_each_entry(mfc, it->cache, list)
368 read_unlock(&mrt_lock);
370 spin_lock_bh(&mfc_unres_lock);
371 it->cache = &mrt->mfc6_unres_queue;
372 list_for_each_entry(mfc, it->cache, list)
375 spin_unlock_bh(&mfc_unres_lock);
382 * The /proc interfaces to multicast routing /proc/ip6_mr_cache /proc/ip6_mr_vif
385 struct ipmr_vif_iter {
386 struct seq_net_private p;
387 struct mr6_table *mrt;
391 static struct mif_device *ip6mr_vif_seq_idx(struct net *net,
392 struct ipmr_vif_iter *iter,
395 struct mr6_table *mrt = iter->mrt;
397 for (iter->ct = 0; iter->ct < mrt->maxvif; ++iter->ct) {
398 if (!MIF_EXISTS(mrt, iter->ct))
401 return &mrt->vif6_table[iter->ct];
406 static void *ip6mr_vif_seq_start(struct seq_file *seq, loff_t *pos)
409 struct ipmr_vif_iter *iter = seq->private;
410 struct net *net = seq_file_net(seq);
411 struct mr6_table *mrt;
413 mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
415 return ERR_PTR(-ENOENT);
419 read_lock(&mrt_lock);
420 return *pos ? ip6mr_vif_seq_idx(net, seq->private, *pos - 1)
424 static void *ip6mr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos)
426 struct ipmr_vif_iter *iter = seq->private;
427 struct net *net = seq_file_net(seq);
428 struct mr6_table *mrt = iter->mrt;
431 if (v == SEQ_START_TOKEN)
432 return ip6mr_vif_seq_idx(net, iter, 0);
434 while (++iter->ct < mrt->maxvif) {
435 if (!MIF_EXISTS(mrt, iter->ct))
437 return &mrt->vif6_table[iter->ct];
442 static void ip6mr_vif_seq_stop(struct seq_file *seq, void *v)
445 read_unlock(&mrt_lock);
448 static int ip6mr_vif_seq_show(struct seq_file *seq, void *v)
450 struct ipmr_vif_iter *iter = seq->private;
451 struct mr6_table *mrt = iter->mrt;
453 if (v == SEQ_START_TOKEN) {
455 "Interface BytesIn PktsIn BytesOut PktsOut Flags\n");
457 const struct mif_device *vif = v;
458 const char *name = vif->dev ? vif->dev->name : "none";
461 "%2td %-10s %8ld %7ld %8ld %7ld %05X\n",
462 vif - mrt->vif6_table,
463 name, vif->bytes_in, vif->pkt_in,
464 vif->bytes_out, vif->pkt_out,
470 static const struct seq_operations ip6mr_vif_seq_ops = {
471 .start = ip6mr_vif_seq_start,
472 .next = ip6mr_vif_seq_next,
473 .stop = ip6mr_vif_seq_stop,
474 .show = ip6mr_vif_seq_show,
477 static int ip6mr_vif_open(struct inode *inode, struct file *file)
479 return seq_open_net(inode, file, &ip6mr_vif_seq_ops,
480 sizeof(struct ipmr_vif_iter));
483 static const struct file_operations ip6mr_vif_fops = {
484 .owner = THIS_MODULE,
485 .open = ip6mr_vif_open,
488 .release = seq_release_net,
491 static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
493 struct ipmr_mfc_iter *it = seq->private;
494 struct net *net = seq_file_net(seq);
495 struct mr6_table *mrt;
497 mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
499 return ERR_PTR(-ENOENT);
503 return *pos ? ipmr_mfc_seq_idx(net, seq->private, *pos - 1)
507 static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
509 struct mfc6_cache *mfc = v;
510 struct ipmr_mfc_iter *it = seq->private;
511 struct net *net = seq_file_net(seq);
512 struct mr6_table *mrt = it->mrt;
516 if (v == SEQ_START_TOKEN)
517 return ipmr_mfc_seq_idx(net, seq->private, 0);
519 if (mfc->list.next != it->cache)
520 return list_entry(mfc->list.next, struct mfc6_cache, list);
522 if (it->cache == &mrt->mfc6_unres_queue)
525 BUG_ON(it->cache != &mrt->mfc6_cache_array[it->ct]);
527 while (++it->ct < MFC6_LINES) {
528 it->cache = &mrt->mfc6_cache_array[it->ct];
529 if (list_empty(it->cache))
531 return list_first_entry(it->cache, struct mfc6_cache, list);
534 /* exhausted cache_array, show unresolved */
535 read_unlock(&mrt_lock);
536 it->cache = &mrt->mfc6_unres_queue;
539 spin_lock_bh(&mfc_unres_lock);
540 if (!list_empty(it->cache))
541 return list_first_entry(it->cache, struct mfc6_cache, list);
544 spin_unlock_bh(&mfc_unres_lock);
550 static void ipmr_mfc_seq_stop(struct seq_file *seq, void *v)
552 struct ipmr_mfc_iter *it = seq->private;
553 struct mr6_table *mrt = it->mrt;
555 if (it->cache == &mrt->mfc6_unres_queue)
556 spin_unlock_bh(&mfc_unres_lock);
557 else if (it->cache == &mrt->mfc6_cache_array[it->ct])
558 read_unlock(&mrt_lock);
561 static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
565 if (v == SEQ_START_TOKEN) {
569 "Iif Pkts Bytes Wrong Oifs\n");
571 const struct mfc6_cache *mfc = v;
572 const struct ipmr_mfc_iter *it = seq->private;
573 struct mr6_table *mrt = it->mrt;
575 seq_printf(seq, "%pI6 %pI6 %-3hd",
576 &mfc->mf6c_mcastgrp, &mfc->mf6c_origin,
579 if (it->cache != &mrt->mfc6_unres_queue) {
580 seq_printf(seq, " %8lu %8lu %8lu",
582 mfc->mfc_un.res.bytes,
583 mfc->mfc_un.res.wrong_if);
584 for (n = mfc->mfc_un.res.minvif;
585 n < mfc->mfc_un.res.maxvif; n++) {
586 if (MIF_EXISTS(mrt, n) &&
587 mfc->mfc_un.res.ttls[n] < 255)
590 n, mfc->mfc_un.res.ttls[n]);
593 /* unresolved mfc_caches don't contain
594 * pkt, bytes and wrong_if values
596 seq_printf(seq, " %8lu %8lu %8lu", 0ul, 0ul, 0ul);
603 static const struct seq_operations ipmr_mfc_seq_ops = {
604 .start = ipmr_mfc_seq_start,
605 .next = ipmr_mfc_seq_next,
606 .stop = ipmr_mfc_seq_stop,
607 .show = ipmr_mfc_seq_show,
610 static int ipmr_mfc_open(struct inode *inode, struct file *file)
612 return seq_open_net(inode, file, &ipmr_mfc_seq_ops,
613 sizeof(struct ipmr_mfc_iter));
616 static const struct file_operations ip6mr_mfc_fops = {
617 .owner = THIS_MODULE,
618 .open = ipmr_mfc_open,
621 .release = seq_release_net,
625 #ifdef CONFIG_IPV6_PIMSM_V2
627 static int pim6_rcv(struct sk_buff *skb)
629 struct pimreghdr *pim;
630 struct ipv6hdr *encap;
631 struct net_device *reg_dev = NULL;
632 struct net *net = dev_net(skb->dev);
633 struct mr6_table *mrt;
634 struct flowi6 fl6 = {
635 .flowi6_iif = skb->dev->ifindex,
636 .flowi6_mark = skb->mark,
640 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
643 pim = (struct pimreghdr *)skb_transport_header(skb);
644 if (pim->type != ((PIM_VERSION << 4) | PIM_REGISTER) ||
645 (pim->flags & PIM_NULL_REGISTER) ||
646 (csum_ipv6_magic(&ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr,
647 sizeof(*pim), IPPROTO_PIM,
648 csum_partial((void *)pim, sizeof(*pim), 0)) &&
649 csum_fold(skb_checksum(skb, 0, skb->len, 0))))
652 /* check if the inner packet is destined to mcast group */
653 encap = (struct ipv6hdr *)(skb_transport_header(skb) +
656 if (!ipv6_addr_is_multicast(&encap->daddr) ||
657 encap->payload_len == 0 ||
658 ntohs(encap->payload_len) + sizeof(*pim) > skb->len)
661 if (ip6mr_fib_lookup(net, &fl6, &mrt) < 0)
663 reg_vif_num = mrt->mroute_reg_vif_num;
665 read_lock(&mrt_lock);
666 if (reg_vif_num >= 0)
667 reg_dev = mrt->vif6_table[reg_vif_num].dev;
670 read_unlock(&mrt_lock);
675 skb->mac_header = skb->network_header;
676 skb_pull(skb, (u8 *)encap - skb->data);
677 skb_reset_network_header(skb);
678 skb->protocol = htons(ETH_P_IPV6);
679 skb->ip_summed = CHECKSUM_NONE;
681 skb_tunnel_rx(skb, reg_dev, dev_net(reg_dev));
692 static const struct inet6_protocol pim6_protocol = {
696 /* Service routines creating virtual interfaces: PIMREG */
698 static netdev_tx_t reg_vif_xmit(struct sk_buff *skb,
699 struct net_device *dev)
701 struct net *net = dev_net(dev);
702 struct mr6_table *mrt;
703 struct flowi6 fl6 = {
704 .flowi6_oif = dev->ifindex,
705 .flowi6_iif = skb->skb_iif ? : LOOPBACK_IFINDEX,
706 .flowi6_mark = skb->mark,
710 err = ip6mr_fib_lookup(net, &fl6, &mrt);
716 read_lock(&mrt_lock);
717 dev->stats.tx_bytes += skb->len;
718 dev->stats.tx_packets++;
719 ip6mr_cache_report(mrt, skb, mrt->mroute_reg_vif_num, MRT6MSG_WHOLEPKT);
720 read_unlock(&mrt_lock);
725 static int reg_vif_get_iflink(const struct net_device *dev)
730 static const struct net_device_ops reg_vif_netdev_ops = {
731 .ndo_start_xmit = reg_vif_xmit,
732 .ndo_get_iflink = reg_vif_get_iflink,
735 static void reg_vif_setup(struct net_device *dev)
737 dev->type = ARPHRD_PIMREG;
738 dev->mtu = 1500 - sizeof(struct ipv6hdr) - 8;
739 dev->flags = IFF_NOARP;
740 dev->netdev_ops = ®_vif_netdev_ops;
741 dev->destructor = free_netdev;
742 dev->features |= NETIF_F_NETNS_LOCAL;
745 static struct net_device *ip6mr_reg_vif(struct net *net, struct mr6_table *mrt)
747 struct net_device *dev;
750 if (mrt->id == RT6_TABLE_DFLT)
751 sprintf(name, "pim6reg");
753 sprintf(name, "pim6reg%u", mrt->id);
755 dev = alloc_netdev(0, name, NET_NAME_UNKNOWN, reg_vif_setup);
759 dev_net_set(dev, net);
761 if (register_netdevice(dev)) {
773 unregister_netdevice(dev);
782 static int mif6_delete(struct mr6_table *mrt, int vifi, int notify,
783 struct list_head *head)
785 struct mif_device *v;
786 struct net_device *dev;
787 struct inet6_dev *in6_dev;
789 if (vifi < 0 || vifi >= mrt->maxvif)
790 return -EADDRNOTAVAIL;
792 v = &mrt->vif6_table[vifi];
794 write_lock_bh(&mrt_lock);
799 write_unlock_bh(&mrt_lock);
800 return -EADDRNOTAVAIL;
803 #ifdef CONFIG_IPV6_PIMSM_V2
804 if (vifi == mrt->mroute_reg_vif_num)
805 mrt->mroute_reg_vif_num = -1;
808 if (vifi + 1 == mrt->maxvif) {
810 for (tmp = vifi - 1; tmp >= 0; tmp--) {
811 if (MIF_EXISTS(mrt, tmp))
814 mrt->maxvif = tmp + 1;
817 write_unlock_bh(&mrt_lock);
819 dev_set_allmulti(dev, -1);
821 in6_dev = __in6_dev_get(dev);
823 in6_dev->cnf.mc_forwarding--;
824 inet6_netconf_notify_devconf(dev_net(dev),
825 NETCONFA_MC_FORWARDING,
826 dev->ifindex, &in6_dev->cnf);
829 if ((v->flags & MIFF_REGISTER) && !notify)
830 unregister_netdevice_queue(dev, head);
836 static inline void ip6mr_cache_free(struct mfc6_cache *c)
838 kmem_cache_free(mrt_cachep, c);
841 /* Destroy an unresolved cache entry, killing queued skbs
842 and reporting error to netlink readers.
845 static void ip6mr_destroy_unres(struct mr6_table *mrt, struct mfc6_cache *c)
847 struct net *net = read_pnet(&mrt->net);
850 atomic_dec(&mrt->cache_resolve_queue_len);
852 while ((skb = skb_dequeue(&c->mfc_un.unres.unresolved)) != NULL) {
853 if (ipv6_hdr(skb)->version == 0) {
854 struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct ipv6hdr));
855 nlh->nlmsg_type = NLMSG_ERROR;
856 nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
857 skb_trim(skb, nlh->nlmsg_len);
858 ((struct nlmsgerr *)nlmsg_data(nlh))->error = -ETIMEDOUT;
859 rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
868 /* Timer process for all the unresolved queue. */
870 static void ipmr_do_expire_process(struct mr6_table *mrt)
872 unsigned long now = jiffies;
873 unsigned long expires = 10 * HZ;
874 struct mfc6_cache *c, *next;
876 list_for_each_entry_safe(c, next, &mrt->mfc6_unres_queue, list) {
877 if (time_after(c->mfc_un.unres.expires, now)) {
879 unsigned long interval = c->mfc_un.unres.expires - now;
880 if (interval < expires)
886 mr6_netlink_event(mrt, c, RTM_DELROUTE);
887 ip6mr_destroy_unres(mrt, c);
890 if (!list_empty(&mrt->mfc6_unres_queue))
891 mod_timer(&mrt->ipmr_expire_timer, jiffies + expires);
894 static void ipmr_expire_process(unsigned long arg)
896 struct mr6_table *mrt = (struct mr6_table *)arg;
898 if (!spin_trylock(&mfc_unres_lock)) {
899 mod_timer(&mrt->ipmr_expire_timer, jiffies + 1);
903 if (!list_empty(&mrt->mfc6_unres_queue))
904 ipmr_do_expire_process(mrt);
906 spin_unlock(&mfc_unres_lock);
909 /* Fill oifs list. It is called under write locked mrt_lock. */
911 static void ip6mr_update_thresholds(struct mr6_table *mrt, struct mfc6_cache *cache,
916 cache->mfc_un.res.minvif = MAXMIFS;
917 cache->mfc_un.res.maxvif = 0;
918 memset(cache->mfc_un.res.ttls, 255, MAXMIFS);
920 for (vifi = 0; vifi < mrt->maxvif; vifi++) {
921 if (MIF_EXISTS(mrt, vifi) &&
922 ttls[vifi] && ttls[vifi] < 255) {
923 cache->mfc_un.res.ttls[vifi] = ttls[vifi];
924 if (cache->mfc_un.res.minvif > vifi)
925 cache->mfc_un.res.minvif = vifi;
926 if (cache->mfc_un.res.maxvif <= vifi)
927 cache->mfc_un.res.maxvif = vifi + 1;
930 cache->mfc_un.res.lastuse = jiffies;
933 static int mif6_add(struct net *net, struct mr6_table *mrt,
934 struct mif6ctl *vifc, int mrtsock)
936 int vifi = vifc->mif6c_mifi;
937 struct mif_device *v = &mrt->vif6_table[vifi];
938 struct net_device *dev;
939 struct inet6_dev *in6_dev;
943 if (MIF_EXISTS(mrt, vifi))
946 switch (vifc->mif6c_flags) {
947 #ifdef CONFIG_IPV6_PIMSM_V2
950 * Special Purpose VIF in PIM
951 * All the packets will be sent to the daemon
953 if (mrt->mroute_reg_vif_num >= 0)
955 dev = ip6mr_reg_vif(net, mrt);
958 err = dev_set_allmulti(dev, 1);
960 unregister_netdevice(dev);
967 dev = dev_get_by_index(net, vifc->mif6c_pifi);
969 return -EADDRNOTAVAIL;
970 err = dev_set_allmulti(dev, 1);
980 in6_dev = __in6_dev_get(dev);
982 in6_dev->cnf.mc_forwarding++;
983 inet6_netconf_notify_devconf(dev_net(dev),
984 NETCONFA_MC_FORWARDING,
985 dev->ifindex, &in6_dev->cnf);
989 * Fill in the VIF structures
991 v->rate_limit = vifc->vifc_rate_limit;
992 v->flags = vifc->mif6c_flags;
994 v->flags |= VIFF_STATIC;
995 v->threshold = vifc->vifc_threshold;
1000 v->link = dev->ifindex;
1001 if (v->flags & MIFF_REGISTER)
1002 v->link = dev_get_iflink(dev);
1004 /* And finish update writing critical data */
1005 write_lock_bh(&mrt_lock);
1007 #ifdef CONFIG_IPV6_PIMSM_V2
1008 if (v->flags & MIFF_REGISTER)
1009 mrt->mroute_reg_vif_num = vifi;
1011 if (vifi + 1 > mrt->maxvif)
1012 mrt->maxvif = vifi + 1;
1013 write_unlock_bh(&mrt_lock);
1017 static struct mfc6_cache *ip6mr_cache_find(struct mr6_table *mrt,
1018 const struct in6_addr *origin,
1019 const struct in6_addr *mcastgrp)
1021 int line = MFC6_HASH(mcastgrp, origin);
1022 struct mfc6_cache *c;
1024 list_for_each_entry(c, &mrt->mfc6_cache_array[line], list) {
1025 if (ipv6_addr_equal(&c->mf6c_origin, origin) &&
1026 ipv6_addr_equal(&c->mf6c_mcastgrp, mcastgrp))
1032 /* Look for a (*,*,oif) entry */
1033 static struct mfc6_cache *ip6mr_cache_find_any_parent(struct mr6_table *mrt,
1036 int line = MFC6_HASH(&in6addr_any, &in6addr_any);
1037 struct mfc6_cache *c;
1039 list_for_each_entry(c, &mrt->mfc6_cache_array[line], list)
1040 if (ipv6_addr_any(&c->mf6c_origin) &&
1041 ipv6_addr_any(&c->mf6c_mcastgrp) &&
1042 (c->mfc_un.res.ttls[mifi] < 255))
1048 /* Look for a (*,G) entry */
1049 static struct mfc6_cache *ip6mr_cache_find_any(struct mr6_table *mrt,
1050 struct in6_addr *mcastgrp,
1053 int line = MFC6_HASH(mcastgrp, &in6addr_any);
1054 struct mfc6_cache *c, *proxy;
1056 if (ipv6_addr_any(mcastgrp))
1059 list_for_each_entry(c, &mrt->mfc6_cache_array[line], list)
1060 if (ipv6_addr_any(&c->mf6c_origin) &&
1061 ipv6_addr_equal(&c->mf6c_mcastgrp, mcastgrp)) {
1062 if (c->mfc_un.res.ttls[mifi] < 255)
1065 /* It's ok if the mifi is part of the static tree */
1066 proxy = ip6mr_cache_find_any_parent(mrt,
1068 if (proxy && proxy->mfc_un.res.ttls[mifi] < 255)
1073 return ip6mr_cache_find_any_parent(mrt, mifi);
1077 * Allocate a multicast cache entry
1079 static struct mfc6_cache *ip6mr_cache_alloc(void)
1081 struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
1084 c->mfc_un.res.last_assert = jiffies - MFC_ASSERT_THRESH - 1;
1085 c->mfc_un.res.minvif = MAXMIFS;
1089 static struct mfc6_cache *ip6mr_cache_alloc_unres(void)
1091 struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC);
1094 skb_queue_head_init(&c->mfc_un.unres.unresolved);
1095 c->mfc_un.unres.expires = jiffies + 10 * HZ;
1100 * A cache entry has gone into a resolved state from queued
1103 static void ip6mr_cache_resolve(struct net *net, struct mr6_table *mrt,
1104 struct mfc6_cache *uc, struct mfc6_cache *c)
1106 struct sk_buff *skb;
1109 * Play the pending entries through our router
1112 while ((skb = __skb_dequeue(&uc->mfc_un.unres.unresolved))) {
1113 if (ipv6_hdr(skb)->version == 0) {
1114 struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct ipv6hdr));
1116 if (__ip6mr_fill_mroute(mrt, skb, c, nlmsg_data(nlh)) > 0) {
1117 nlh->nlmsg_len = skb_tail_pointer(skb) - (u8 *)nlh;
1119 nlh->nlmsg_type = NLMSG_ERROR;
1120 nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
1121 skb_trim(skb, nlh->nlmsg_len);
1122 ((struct nlmsgerr *)nlmsg_data(nlh))->error = -EMSGSIZE;
1124 rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
1126 ip6_mr_forward(net, mrt, skb, c);
1131 * Bounce a cache query up to pim6sd. We could use netlink for this but pim6sd
1132 * expects the following bizarre scheme.
1134 * Called under mrt_lock.
1137 static int ip6mr_cache_report(struct mr6_table *mrt, struct sk_buff *pkt,
1138 mifi_t mifi, int assert)
1140 struct sk_buff *skb;
1141 struct mrt6msg *msg;
1144 #ifdef CONFIG_IPV6_PIMSM_V2
1145 if (assert == MRT6MSG_WHOLEPKT)
1146 skb = skb_realloc_headroom(pkt, -skb_network_offset(pkt)
1150 skb = alloc_skb(sizeof(struct ipv6hdr) + sizeof(*msg), GFP_ATOMIC);
1155 /* I suppose that internal messages
1156 * do not require checksums */
1158 skb->ip_summed = CHECKSUM_UNNECESSARY;
1160 #ifdef CONFIG_IPV6_PIMSM_V2
1161 if (assert == MRT6MSG_WHOLEPKT) {
1162 /* Ugly, but we have no choice with this interface.
1163 Duplicate old header, fix length etc.
1164 And all this only to mangle msg->im6_msgtype and
1165 to set msg->im6_mbz to "mbz" :-)
1167 skb_push(skb, -skb_network_offset(pkt));
1169 skb_push(skb, sizeof(*msg));
1170 skb_reset_transport_header(skb);
1171 msg = (struct mrt6msg *)skb_transport_header(skb);
1173 msg->im6_msgtype = MRT6MSG_WHOLEPKT;
1174 msg->im6_mif = mrt->mroute_reg_vif_num;
1176 msg->im6_src = ipv6_hdr(pkt)->saddr;
1177 msg->im6_dst = ipv6_hdr(pkt)->daddr;
1179 skb->ip_summed = CHECKSUM_UNNECESSARY;
1184 * Copy the IP header
1187 skb_put(skb, sizeof(struct ipv6hdr));
1188 skb_reset_network_header(skb);
1189 skb_copy_to_linear_data(skb, ipv6_hdr(pkt), sizeof(struct ipv6hdr));
1194 skb_put(skb, sizeof(*msg));
1195 skb_reset_transport_header(skb);
1196 msg = (struct mrt6msg *)skb_transport_header(skb);
1199 msg->im6_msgtype = assert;
1200 msg->im6_mif = mifi;
1202 msg->im6_src = ipv6_hdr(pkt)->saddr;
1203 msg->im6_dst = ipv6_hdr(pkt)->daddr;
1205 skb_dst_set(skb, dst_clone(skb_dst(pkt)));
1206 skb->ip_summed = CHECKSUM_UNNECESSARY;
1209 if (!mrt->mroute6_sk) {
1215 * Deliver to user space multicast routing algorithms
1217 ret = sock_queue_rcv_skb(mrt->mroute6_sk, skb);
1219 net_warn_ratelimited("mroute6: pending queue full, dropping entries\n");
1227 * Queue a packet for resolution. It gets locked cache entry!
1231 ip6mr_cache_unresolved(struct mr6_table *mrt, mifi_t mifi, struct sk_buff *skb)
1235 struct mfc6_cache *c;
1237 spin_lock_bh(&mfc_unres_lock);
1238 list_for_each_entry(c, &mrt->mfc6_unres_queue, list) {
1239 if (ipv6_addr_equal(&c->mf6c_mcastgrp, &ipv6_hdr(skb)->daddr) &&
1240 ipv6_addr_equal(&c->mf6c_origin, &ipv6_hdr(skb)->saddr)) {
1248 * Create a new entry if allowable
1251 if (atomic_read(&mrt->cache_resolve_queue_len) >= 10 ||
1252 (c = ip6mr_cache_alloc_unres()) == NULL) {
1253 spin_unlock_bh(&mfc_unres_lock);
1260 * Fill in the new cache entry
1262 c->mf6c_parent = -1;
1263 c->mf6c_origin = ipv6_hdr(skb)->saddr;
1264 c->mf6c_mcastgrp = ipv6_hdr(skb)->daddr;
1267 * Reflect first query at pim6sd
1269 err = ip6mr_cache_report(mrt, skb, mifi, MRT6MSG_NOCACHE);
1271 /* If the report failed throw the cache entry
1274 spin_unlock_bh(&mfc_unres_lock);
1276 ip6mr_cache_free(c);
1281 atomic_inc(&mrt->cache_resolve_queue_len);
1282 list_add(&c->list, &mrt->mfc6_unres_queue);
1283 mr6_netlink_event(mrt, c, RTM_NEWROUTE);
1285 ipmr_do_expire_process(mrt);
1289 * See if we can append the packet
1291 if (c->mfc_un.unres.unresolved.qlen > 3) {
1295 skb_queue_tail(&c->mfc_un.unres.unresolved, skb);
1299 spin_unlock_bh(&mfc_unres_lock);
1304 * MFC6 cache manipulation by user space
1307 static int ip6mr_mfc_delete(struct mr6_table *mrt, struct mf6cctl *mfc,
1311 struct mfc6_cache *c, *next;
1313 line = MFC6_HASH(&mfc->mf6cc_mcastgrp.sin6_addr, &mfc->mf6cc_origin.sin6_addr);
1315 list_for_each_entry_safe(c, next, &mrt->mfc6_cache_array[line], list) {
1316 if (ipv6_addr_equal(&c->mf6c_origin, &mfc->mf6cc_origin.sin6_addr) &&
1317 ipv6_addr_equal(&c->mf6c_mcastgrp,
1318 &mfc->mf6cc_mcastgrp.sin6_addr) &&
1319 (parent == -1 || parent == c->mf6c_parent)) {
1320 write_lock_bh(&mrt_lock);
1322 write_unlock_bh(&mrt_lock);
1324 mr6_netlink_event(mrt, c, RTM_DELROUTE);
1325 ip6mr_cache_free(c);
1332 static int ip6mr_device_event(struct notifier_block *this,
1333 unsigned long event, void *ptr)
1335 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1336 struct net *net = dev_net(dev);
1337 struct mr6_table *mrt;
1338 struct mif_device *v;
1341 if (event != NETDEV_UNREGISTER)
1344 ip6mr_for_each_table(mrt, net) {
1345 v = &mrt->vif6_table[0];
1346 for (ct = 0; ct < mrt->maxvif; ct++, v++) {
1348 mif6_delete(mrt, ct, 1, NULL);
1355 static struct notifier_block ip6_mr_notifier = {
1356 .notifier_call = ip6mr_device_event
1360 * Setup for IP multicast routing
1363 static int __net_init ip6mr_net_init(struct net *net)
1367 err = ip6mr_rules_init(net);
1371 #ifdef CONFIG_PROC_FS
1373 if (!proc_create("ip6_mr_vif", 0, net->proc_net, &ip6mr_vif_fops))
1375 if (!proc_create("ip6_mr_cache", 0, net->proc_net, &ip6mr_mfc_fops))
1376 goto proc_cache_fail;
1381 #ifdef CONFIG_PROC_FS
1383 remove_proc_entry("ip6_mr_vif", net->proc_net);
1385 ip6mr_rules_exit(net);
1391 static void __net_exit ip6mr_net_exit(struct net *net)
1393 #ifdef CONFIG_PROC_FS
1394 remove_proc_entry("ip6_mr_cache", net->proc_net);
1395 remove_proc_entry("ip6_mr_vif", net->proc_net);
1397 ip6mr_rules_exit(net);
1400 static struct pernet_operations ip6mr_net_ops = {
1401 .init = ip6mr_net_init,
1402 .exit = ip6mr_net_exit,
1405 int __init ip6_mr_init(void)
1409 mrt_cachep = kmem_cache_create("ip6_mrt_cache",
1410 sizeof(struct mfc6_cache),
1411 0, SLAB_HWCACHE_ALIGN,
1416 err = register_pernet_subsys(&ip6mr_net_ops);
1418 goto reg_pernet_fail;
1420 err = register_netdevice_notifier(&ip6_mr_notifier);
1422 goto reg_notif_fail;
1423 #ifdef CONFIG_IPV6_PIMSM_V2
1424 if (inet6_add_protocol(&pim6_protocol, IPPROTO_PIM) < 0) {
1425 pr_err("%s: can't add PIM protocol\n", __func__);
1427 goto add_proto_fail;
1430 rtnl_register(RTNL_FAMILY_IP6MR, RTM_GETROUTE, NULL,
1431 ip6mr_rtm_dumproute, NULL);
1433 #ifdef CONFIG_IPV6_PIMSM_V2
1435 unregister_netdevice_notifier(&ip6_mr_notifier);
1438 unregister_pernet_subsys(&ip6mr_net_ops);
1440 kmem_cache_destroy(mrt_cachep);
1444 void ip6_mr_cleanup(void)
1446 rtnl_unregister(RTNL_FAMILY_IP6MR, RTM_GETROUTE);
1447 #ifdef CONFIG_IPV6_PIMSM_V2
1448 inet6_del_protocol(&pim6_protocol, IPPROTO_PIM);
1450 unregister_netdevice_notifier(&ip6_mr_notifier);
1451 unregister_pernet_subsys(&ip6mr_net_ops);
1452 kmem_cache_destroy(mrt_cachep);
1455 static int ip6mr_mfc_add(struct net *net, struct mr6_table *mrt,
1456 struct mf6cctl *mfc, int mrtsock, int parent)
1460 struct mfc6_cache *uc, *c;
1461 unsigned char ttls[MAXMIFS];
1464 if (mfc->mf6cc_parent >= MAXMIFS)
1467 memset(ttls, 255, MAXMIFS);
1468 for (i = 0; i < MAXMIFS; i++) {
1469 if (IF_ISSET(i, &mfc->mf6cc_ifset))
1474 line = MFC6_HASH(&mfc->mf6cc_mcastgrp.sin6_addr, &mfc->mf6cc_origin.sin6_addr);
1476 list_for_each_entry(c, &mrt->mfc6_cache_array[line], list) {
1477 if (ipv6_addr_equal(&c->mf6c_origin, &mfc->mf6cc_origin.sin6_addr) &&
1478 ipv6_addr_equal(&c->mf6c_mcastgrp,
1479 &mfc->mf6cc_mcastgrp.sin6_addr) &&
1480 (parent == -1 || parent == mfc->mf6cc_parent)) {
1487 write_lock_bh(&mrt_lock);
1488 c->mf6c_parent = mfc->mf6cc_parent;
1489 ip6mr_update_thresholds(mrt, c, ttls);
1491 c->mfc_flags |= MFC_STATIC;
1492 write_unlock_bh(&mrt_lock);
1493 mr6_netlink_event(mrt, c, RTM_NEWROUTE);
1497 if (!ipv6_addr_any(&mfc->mf6cc_mcastgrp.sin6_addr) &&
1498 !ipv6_addr_is_multicast(&mfc->mf6cc_mcastgrp.sin6_addr))
1501 c = ip6mr_cache_alloc();
1505 c->mf6c_origin = mfc->mf6cc_origin.sin6_addr;
1506 c->mf6c_mcastgrp = mfc->mf6cc_mcastgrp.sin6_addr;
1507 c->mf6c_parent = mfc->mf6cc_parent;
1508 ip6mr_update_thresholds(mrt, c, ttls);
1510 c->mfc_flags |= MFC_STATIC;
1512 write_lock_bh(&mrt_lock);
1513 list_add(&c->list, &mrt->mfc6_cache_array[line]);
1514 write_unlock_bh(&mrt_lock);
1517 * Check to see if we resolved a queued list. If so we
1518 * need to send on the frames and tidy up.
1521 spin_lock_bh(&mfc_unres_lock);
1522 list_for_each_entry(uc, &mrt->mfc6_unres_queue, list) {
1523 if (ipv6_addr_equal(&uc->mf6c_origin, &c->mf6c_origin) &&
1524 ipv6_addr_equal(&uc->mf6c_mcastgrp, &c->mf6c_mcastgrp)) {
1525 list_del(&uc->list);
1526 atomic_dec(&mrt->cache_resolve_queue_len);
1531 if (list_empty(&mrt->mfc6_unres_queue))
1532 del_timer(&mrt->ipmr_expire_timer);
1533 spin_unlock_bh(&mfc_unres_lock);
1536 ip6mr_cache_resolve(net, mrt, uc, c);
1537 ip6mr_cache_free(uc);
1539 mr6_netlink_event(mrt, c, RTM_NEWROUTE);
1544 * Close the multicast socket, and clear the vif tables etc
1547 static void mroute_clean_tables(struct mr6_table *mrt, bool all)
1551 struct mfc6_cache *c, *next;
1554 * Shut down all active vif entries
1556 for (i = 0; i < mrt->maxvif; i++) {
1557 if (!all && (mrt->vif6_table[i].flags & VIFF_STATIC))
1559 mif6_delete(mrt, i, 0, &list);
1561 unregister_netdevice_many(&list);
1566 for (i = 0; i < MFC6_LINES; i++) {
1567 list_for_each_entry_safe(c, next, &mrt->mfc6_cache_array[i], list) {
1568 if (!all && (c->mfc_flags & MFC_STATIC))
1570 write_lock_bh(&mrt_lock);
1572 write_unlock_bh(&mrt_lock);
1574 mr6_netlink_event(mrt, c, RTM_DELROUTE);
1575 ip6mr_cache_free(c);
1579 if (atomic_read(&mrt->cache_resolve_queue_len) != 0) {
1580 spin_lock_bh(&mfc_unres_lock);
1581 list_for_each_entry_safe(c, next, &mrt->mfc6_unres_queue, list) {
1583 mr6_netlink_event(mrt, c, RTM_DELROUTE);
1584 ip6mr_destroy_unres(mrt, c);
1586 spin_unlock_bh(&mfc_unres_lock);
1590 static int ip6mr_sk_init(struct mr6_table *mrt, struct sock *sk)
1593 struct net *net = sock_net(sk);
1596 write_lock_bh(&mrt_lock);
1597 if (likely(mrt->mroute6_sk == NULL)) {
1598 mrt->mroute6_sk = sk;
1599 net->ipv6.devconf_all->mc_forwarding++;
1603 write_unlock_bh(&mrt_lock);
1606 inet6_netconf_notify_devconf(net, NETCONFA_MC_FORWARDING,
1607 NETCONFA_IFINDEX_ALL,
1608 net->ipv6.devconf_all);
1614 int ip6mr_sk_done(struct sock *sk)
1617 struct net *net = sock_net(sk);
1618 struct mr6_table *mrt;
1621 ip6mr_for_each_table(mrt, net) {
1622 if (sk == mrt->mroute6_sk) {
1623 write_lock_bh(&mrt_lock);
1624 mrt->mroute6_sk = NULL;
1625 net->ipv6.devconf_all->mc_forwarding--;
1626 write_unlock_bh(&mrt_lock);
1627 inet6_netconf_notify_devconf(net,
1628 NETCONFA_MC_FORWARDING,
1629 NETCONFA_IFINDEX_ALL,
1630 net->ipv6.devconf_all);
1632 mroute_clean_tables(mrt, false);
1642 struct sock *mroute6_socket(struct net *net, struct sk_buff *skb)
1644 struct mr6_table *mrt;
1645 struct flowi6 fl6 = {
1646 .flowi6_iif = skb->skb_iif ? : LOOPBACK_IFINDEX,
1647 .flowi6_oif = skb->dev->ifindex,
1648 .flowi6_mark = skb->mark,
1651 if (ip6mr_fib_lookup(net, &fl6, &mrt) < 0)
1654 return mrt->mroute6_sk;
1658 * Socket options and virtual interface manipulation. The whole
1659 * virtual interface system is a complete heap, but unfortunately
1660 * that's how BSD mrouted happens to think. Maybe one day with a proper
1661 * MOSPF/PIM router set up we can clean this up.
1664 int ip6_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsigned int optlen)
1666 int ret, parent = 0;
1670 struct net *net = sock_net(sk);
1671 struct mr6_table *mrt;
1673 if (sk->sk_type != SOCK_RAW ||
1674 inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
1677 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1681 if (optname != MRT6_INIT) {
1682 if (sk != mrt->mroute6_sk && !ns_capable(net->user_ns, CAP_NET_ADMIN))
1688 if (optlen < sizeof(int))
1691 return ip6mr_sk_init(mrt, sk);
1694 return ip6mr_sk_done(sk);
1697 if (optlen < sizeof(vif))
1699 if (copy_from_user(&vif, optval, sizeof(vif)))
1701 if (vif.mif6c_mifi >= MAXMIFS)
1704 ret = mif6_add(net, mrt, &vif, sk == mrt->mroute6_sk);
1709 if (optlen < sizeof(mifi_t))
1711 if (copy_from_user(&mifi, optval, sizeof(mifi_t)))
1714 ret = mif6_delete(mrt, mifi, 0, NULL);
1719 * Manipulate the forwarding caches. These live
1720 * in a sort of kernel/user symbiosis.
1725 case MRT6_ADD_MFC_PROXY:
1726 case MRT6_DEL_MFC_PROXY:
1727 if (optlen < sizeof(mfc))
1729 if (copy_from_user(&mfc, optval, sizeof(mfc)))
1732 parent = mfc.mf6cc_parent;
1734 if (optname == MRT6_DEL_MFC || optname == MRT6_DEL_MFC_PROXY)
1735 ret = ip6mr_mfc_delete(mrt, &mfc, parent);
1737 ret = ip6mr_mfc_add(net, mrt, &mfc,
1738 sk == mrt->mroute6_sk, parent);
1743 * Control PIM assert (to activate pim will activate assert)
1749 if (optlen != sizeof(v))
1751 if (get_user(v, (int __user *)optval))
1753 mrt->mroute_do_assert = v;
1757 #ifdef CONFIG_IPV6_PIMSM_V2
1762 if (optlen != sizeof(v))
1764 if (get_user(v, (int __user *)optval))
1769 if (v != mrt->mroute_do_pim) {
1770 mrt->mroute_do_pim = v;
1771 mrt->mroute_do_assert = v;
1778 #ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
1783 if (optlen != sizeof(u32))
1785 if (get_user(v, (u32 __user *)optval))
1787 /* "pim6reg%u" should not exceed 16 bytes (IFNAMSIZ) */
1788 if (v != RT_TABLE_DEFAULT && v >= 100000000)
1790 if (sk == mrt->mroute6_sk)
1795 if (!ip6mr_new_table(net, v))
1798 raw6_sk(sk)->ip6mr_table = v;
1804 * Spurious command, or MRT6_VERSION which you cannot
1808 return -ENOPROTOOPT;
1813 * Getsock opt support for the multicast routing system.
1816 int ip6_mroute_getsockopt(struct sock *sk, int optname, char __user *optval,
1821 struct net *net = sock_net(sk);
1822 struct mr6_table *mrt;
1824 if (sk->sk_type != SOCK_RAW ||
1825 inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
1828 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1836 #ifdef CONFIG_IPV6_PIMSM_V2
1838 val = mrt->mroute_do_pim;
1842 val = mrt->mroute_do_assert;
1845 return -ENOPROTOOPT;
1848 if (get_user(olr, optlen))
1851 olr = min_t(int, olr, sizeof(int));
1855 if (put_user(olr, optlen))
1857 if (copy_to_user(optval, &val, olr))
1863 * The IP multicast ioctl support routines.
1866 int ip6mr_ioctl(struct sock *sk, int cmd, void __user *arg)
1868 struct sioc_sg_req6 sr;
1869 struct sioc_mif_req6 vr;
1870 struct mif_device *vif;
1871 struct mfc6_cache *c;
1872 struct net *net = sock_net(sk);
1873 struct mr6_table *mrt;
1875 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1880 case SIOCGETMIFCNT_IN6:
1881 if (copy_from_user(&vr, arg, sizeof(vr)))
1883 if (vr.mifi >= mrt->maxvif)
1885 vr.mifi = array_index_nospec(vr.mifi, mrt->maxvif);
1886 read_lock(&mrt_lock);
1887 vif = &mrt->vif6_table[vr.mifi];
1888 if (MIF_EXISTS(mrt, vr.mifi)) {
1889 vr.icount = vif->pkt_in;
1890 vr.ocount = vif->pkt_out;
1891 vr.ibytes = vif->bytes_in;
1892 vr.obytes = vif->bytes_out;
1893 read_unlock(&mrt_lock);
1895 if (copy_to_user(arg, &vr, sizeof(vr)))
1899 read_unlock(&mrt_lock);
1900 return -EADDRNOTAVAIL;
1901 case SIOCGETSGCNT_IN6:
1902 if (copy_from_user(&sr, arg, sizeof(sr)))
1905 read_lock(&mrt_lock);
1906 c = ip6mr_cache_find(mrt, &sr.src.sin6_addr, &sr.grp.sin6_addr);
1908 sr.pktcnt = c->mfc_un.res.pkt;
1909 sr.bytecnt = c->mfc_un.res.bytes;
1910 sr.wrong_if = c->mfc_un.res.wrong_if;
1911 read_unlock(&mrt_lock);
1913 if (copy_to_user(arg, &sr, sizeof(sr)))
1917 read_unlock(&mrt_lock);
1918 return -EADDRNOTAVAIL;
1920 return -ENOIOCTLCMD;
1924 #ifdef CONFIG_COMPAT
1925 struct compat_sioc_sg_req6 {
1926 struct sockaddr_in6 src;
1927 struct sockaddr_in6 grp;
1928 compat_ulong_t pktcnt;
1929 compat_ulong_t bytecnt;
1930 compat_ulong_t wrong_if;
1933 struct compat_sioc_mif_req6 {
1935 compat_ulong_t icount;
1936 compat_ulong_t ocount;
1937 compat_ulong_t ibytes;
1938 compat_ulong_t obytes;
1941 int ip6mr_compat_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
1943 struct compat_sioc_sg_req6 sr;
1944 struct compat_sioc_mif_req6 vr;
1945 struct mif_device *vif;
1946 struct mfc6_cache *c;
1947 struct net *net = sock_net(sk);
1948 struct mr6_table *mrt;
1950 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1955 case SIOCGETMIFCNT_IN6:
1956 if (copy_from_user(&vr, arg, sizeof(vr)))
1958 if (vr.mifi >= mrt->maxvif)
1960 vr.mifi = array_index_nospec(vr.mifi, mrt->maxvif);
1961 read_lock(&mrt_lock);
1962 vif = &mrt->vif6_table[vr.mifi];
1963 if (MIF_EXISTS(mrt, vr.mifi)) {
1964 vr.icount = vif->pkt_in;
1965 vr.ocount = vif->pkt_out;
1966 vr.ibytes = vif->bytes_in;
1967 vr.obytes = vif->bytes_out;
1968 read_unlock(&mrt_lock);
1970 if (copy_to_user(arg, &vr, sizeof(vr)))
1974 read_unlock(&mrt_lock);
1975 return -EADDRNOTAVAIL;
1976 case SIOCGETSGCNT_IN6:
1977 if (copy_from_user(&sr, arg, sizeof(sr)))
1980 read_lock(&mrt_lock);
1981 c = ip6mr_cache_find(mrt, &sr.src.sin6_addr, &sr.grp.sin6_addr);
1983 sr.pktcnt = c->mfc_un.res.pkt;
1984 sr.bytecnt = c->mfc_un.res.bytes;
1985 sr.wrong_if = c->mfc_un.res.wrong_if;
1986 read_unlock(&mrt_lock);
1988 if (copy_to_user(arg, &sr, sizeof(sr)))
1992 read_unlock(&mrt_lock);
1993 return -EADDRNOTAVAIL;
1995 return -ENOIOCTLCMD;
2000 static inline int ip6mr_forward2_finish(struct net *net, struct sock *sk, struct sk_buff *skb)
2002 IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
2003 IPSTATS_MIB_OUTFORWDATAGRAMS);
2004 IP6_ADD_STATS(net, ip6_dst_idev(skb_dst(skb)),
2005 IPSTATS_MIB_OUTOCTETS, skb->len);
2006 return dst_output(net, sk, skb);
2010 * Processing handlers for ip6mr_forward
2013 static int ip6mr_forward2(struct net *net, struct mr6_table *mrt,
2014 struct sk_buff *skb, struct mfc6_cache *c, int vifi)
2016 struct ipv6hdr *ipv6h;
2017 struct mif_device *vif = &mrt->vif6_table[vifi];
2018 struct net_device *dev;
2019 struct dst_entry *dst;
2025 #ifdef CONFIG_IPV6_PIMSM_V2
2026 if (vif->flags & MIFF_REGISTER) {
2028 vif->bytes_out += skb->len;
2029 vif->dev->stats.tx_bytes += skb->len;
2030 vif->dev->stats.tx_packets++;
2031 ip6mr_cache_report(mrt, skb, vifi, MRT6MSG_WHOLEPKT);
2036 ipv6h = ipv6_hdr(skb);
2038 fl6 = (struct flowi6) {
2039 .flowi6_oif = vif->link,
2040 .daddr = ipv6h->daddr,
2043 dst = ip6_route_output(net, NULL, &fl6);
2050 skb_dst_set(skb, dst);
2053 * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
2054 * not only before forwarding, but after forwarding on all output
2055 * interfaces. It is clear, if mrouter runs a multicasting
2056 * program, it should receive packets not depending to what interface
2057 * program is joined.
2058 * If we will not make it, the program will have to join on all
2059 * interfaces. On the other hand, multihoming host (or router, but
2060 * not mrouter) cannot join to more than one interface - it will
2061 * result in receiving multiple packets.
2066 vif->bytes_out += skb->len;
2068 /* We are about to write */
2069 /* XXX: extension headers? */
2070 if (skb_cow(skb, sizeof(*ipv6h) + LL_RESERVED_SPACE(dev)))
2073 ipv6h = ipv6_hdr(skb);
2076 IP6CB(skb)->flags |= IP6SKB_FORWARDED;
2078 return NF_HOOK(NFPROTO_IPV6, NF_INET_FORWARD,
2079 net, NULL, skb, skb->dev, dev,
2080 ip6mr_forward2_finish);
2087 static int ip6mr_find_vif(struct mr6_table *mrt, struct net_device *dev)
2091 for (ct = mrt->maxvif - 1; ct >= 0; ct--) {
2092 if (mrt->vif6_table[ct].dev == dev)
2098 static void ip6_mr_forward(struct net *net, struct mr6_table *mrt,
2099 struct sk_buff *skb, struct mfc6_cache *cache)
2103 int true_vifi = ip6mr_find_vif(mrt, skb->dev);
2105 vif = cache->mf6c_parent;
2106 cache->mfc_un.res.pkt++;
2107 cache->mfc_un.res.bytes += skb->len;
2108 cache->mfc_un.res.lastuse = jiffies;
2110 if (ipv6_addr_any(&cache->mf6c_origin) && true_vifi >= 0) {
2111 struct mfc6_cache *cache_proxy;
2113 /* For an (*,G) entry, we only check that the incoming
2114 * interface is part of the static tree.
2116 cache_proxy = ip6mr_cache_find_any_parent(mrt, vif);
2118 cache_proxy->mfc_un.res.ttls[true_vifi] < 255)
2123 * Wrong interface: drop packet and (maybe) send PIM assert.
2125 if (mrt->vif6_table[vif].dev != skb->dev) {
2126 cache->mfc_un.res.wrong_if++;
2128 if (true_vifi >= 0 && mrt->mroute_do_assert &&
2129 /* pimsm uses asserts, when switching from RPT to SPT,
2130 so that we cannot check that packet arrived on an oif.
2131 It is bad, but otherwise we would need to move pretty
2132 large chunk of pimd to kernel. Ough... --ANK
2134 (mrt->mroute_do_pim ||
2135 cache->mfc_un.res.ttls[true_vifi] < 255) &&
2137 cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
2138 cache->mfc_un.res.last_assert = jiffies;
2139 ip6mr_cache_report(mrt, skb, true_vifi, MRT6MSG_WRONGMIF);
2145 mrt->vif6_table[vif].pkt_in++;
2146 mrt->vif6_table[vif].bytes_in += skb->len;
2151 if (ipv6_addr_any(&cache->mf6c_origin) &&
2152 ipv6_addr_any(&cache->mf6c_mcastgrp)) {
2153 if (true_vifi >= 0 &&
2154 true_vifi != cache->mf6c_parent &&
2155 ipv6_hdr(skb)->hop_limit >
2156 cache->mfc_un.res.ttls[cache->mf6c_parent]) {
2157 /* It's an (*,*) entry and the packet is not coming from
2158 * the upstream: forward the packet to the upstream
2161 psend = cache->mf6c_parent;
2166 for (ct = cache->mfc_un.res.maxvif - 1; ct >= cache->mfc_un.res.minvif; ct--) {
2167 /* For (*,G) entry, don't forward to the incoming interface */
2168 if ((!ipv6_addr_any(&cache->mf6c_origin) || ct != true_vifi) &&
2169 ipv6_hdr(skb)->hop_limit > cache->mfc_un.res.ttls[ct]) {
2171 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
2173 ip6mr_forward2(net, mrt, skb2, cache, psend);
2180 ip6mr_forward2(net, mrt, skb, cache, psend);
2190 * Multicast packets for forwarding arrive here
2193 int ip6_mr_input(struct sk_buff *skb)
2195 struct mfc6_cache *cache;
2196 struct net *net = dev_net(skb->dev);
2197 struct mr6_table *mrt;
2198 struct flowi6 fl6 = {
2199 .flowi6_iif = skb->dev->ifindex,
2200 .flowi6_mark = skb->mark,
2204 err = ip6mr_fib_lookup(net, &fl6, &mrt);
2210 read_lock(&mrt_lock);
2211 cache = ip6mr_cache_find(mrt,
2212 &ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr);
2214 int vif = ip6mr_find_vif(mrt, skb->dev);
2217 cache = ip6mr_cache_find_any(mrt,
2218 &ipv6_hdr(skb)->daddr,
2223 * No usable cache entry
2228 vif = ip6mr_find_vif(mrt, skb->dev);
2230 int err = ip6mr_cache_unresolved(mrt, vif, skb);
2231 read_unlock(&mrt_lock);
2235 read_unlock(&mrt_lock);
2240 ip6_mr_forward(net, mrt, skb, cache);
2242 read_unlock(&mrt_lock);
2248 static int __ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb,
2249 struct mfc6_cache *c, struct rtmsg *rtm)
2251 struct rta_mfc_stats mfcs;
2252 struct nlattr *mp_attr;
2253 struct rtnexthop *nhp;
2254 unsigned long lastuse;
2257 /* If cache is unresolved, don't try to parse IIF and OIF */
2258 if (c->mf6c_parent >= MAXMIFS)
2261 if (MIF_EXISTS(mrt, c->mf6c_parent) &&
2262 nla_put_u32(skb, RTA_IIF, mrt->vif6_table[c->mf6c_parent].dev->ifindex) < 0)
2264 mp_attr = nla_nest_start(skb, RTA_MULTIPATH);
2268 for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
2269 if (MIF_EXISTS(mrt, ct) && c->mfc_un.res.ttls[ct] < 255) {
2270 nhp = nla_reserve_nohdr(skb, sizeof(*nhp));
2272 nla_nest_cancel(skb, mp_attr);
2276 nhp->rtnh_flags = 0;
2277 nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
2278 nhp->rtnh_ifindex = mrt->vif6_table[ct].dev->ifindex;
2279 nhp->rtnh_len = sizeof(*nhp);
2283 nla_nest_end(skb, mp_attr);
2285 lastuse = READ_ONCE(c->mfc_un.res.lastuse);
2286 lastuse = time_after_eq(jiffies, lastuse) ? jiffies - lastuse : 0;
2288 mfcs.mfcs_packets = c->mfc_un.res.pkt;
2289 mfcs.mfcs_bytes = c->mfc_un.res.bytes;
2290 mfcs.mfcs_wrong_if = c->mfc_un.res.wrong_if;
2291 if (nla_put_64bit(skb, RTA_MFC_STATS, sizeof(mfcs), &mfcs, RTA_PAD) ||
2292 nla_put_u64_64bit(skb, RTA_EXPIRES, jiffies_to_clock_t(lastuse),
2296 rtm->rtm_type = RTN_MULTICAST;
2300 int ip6mr_get_route(struct net *net, struct sk_buff *skb, struct rtmsg *rtm,
2301 int nowait, u32 portid)
2304 struct mr6_table *mrt;
2305 struct mfc6_cache *cache;
2306 struct rt6_info *rt = (struct rt6_info *)skb_dst(skb);
2308 mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
2312 read_lock(&mrt_lock);
2313 cache = ip6mr_cache_find(mrt, &rt->rt6i_src.addr, &rt->rt6i_dst.addr);
2314 if (!cache && skb->dev) {
2315 int vif = ip6mr_find_vif(mrt, skb->dev);
2318 cache = ip6mr_cache_find_any(mrt, &rt->rt6i_dst.addr,
2323 struct sk_buff *skb2;
2324 struct ipv6hdr *iph;
2325 struct net_device *dev;
2329 read_unlock(&mrt_lock);
2334 if (!dev || (vif = ip6mr_find_vif(mrt, dev)) < 0) {
2335 read_unlock(&mrt_lock);
2339 /* really correct? */
2340 skb2 = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC);
2342 read_unlock(&mrt_lock);
2346 NETLINK_CB(skb2).portid = portid;
2347 skb_reset_transport_header(skb2);
2349 skb_put(skb2, sizeof(struct ipv6hdr));
2350 skb_reset_network_header(skb2);
2352 iph = ipv6_hdr(skb2);
2355 iph->flow_lbl[0] = 0;
2356 iph->flow_lbl[1] = 0;
2357 iph->flow_lbl[2] = 0;
2358 iph->payload_len = 0;
2359 iph->nexthdr = IPPROTO_NONE;
2361 iph->saddr = rt->rt6i_src.addr;
2362 iph->daddr = rt->rt6i_dst.addr;
2364 err = ip6mr_cache_unresolved(mrt, vif, skb2);
2365 read_unlock(&mrt_lock);
2370 if (!nowait && (rtm->rtm_flags&RTM_F_NOTIFY))
2371 cache->mfc_flags |= MFC_NOTIFY;
2373 err = __ip6mr_fill_mroute(mrt, skb, cache, rtm);
2374 read_unlock(&mrt_lock);
2378 static int ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb,
2379 u32 portid, u32 seq, struct mfc6_cache *c, int cmd,
2382 struct nlmsghdr *nlh;
2386 nlh = nlmsg_put(skb, portid, seq, cmd, sizeof(*rtm), flags);
2390 rtm = nlmsg_data(nlh);
2391 rtm->rtm_family = RTNL_FAMILY_IP6MR;
2392 rtm->rtm_dst_len = 128;
2393 rtm->rtm_src_len = 128;
2395 rtm->rtm_table = mrt->id;
2396 if (nla_put_u32(skb, RTA_TABLE, mrt->id))
2397 goto nla_put_failure;
2398 rtm->rtm_type = RTN_MULTICAST;
2399 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2400 if (c->mfc_flags & MFC_STATIC)
2401 rtm->rtm_protocol = RTPROT_STATIC;
2403 rtm->rtm_protocol = RTPROT_MROUTED;
2406 if (nla_put_in6_addr(skb, RTA_SRC, &c->mf6c_origin) ||
2407 nla_put_in6_addr(skb, RTA_DST, &c->mf6c_mcastgrp))
2408 goto nla_put_failure;
2409 err = __ip6mr_fill_mroute(mrt, skb, c, rtm);
2410 /* do not break the dump if cache is unresolved */
2411 if (err < 0 && err != -ENOENT)
2412 goto nla_put_failure;
2414 nlmsg_end(skb, nlh);
2418 nlmsg_cancel(skb, nlh);
2422 static int mr6_msgsize(bool unresolved, int maxvif)
2425 NLMSG_ALIGN(sizeof(struct rtmsg))
2426 + nla_total_size(4) /* RTA_TABLE */
2427 + nla_total_size(sizeof(struct in6_addr)) /* RTA_SRC */
2428 + nla_total_size(sizeof(struct in6_addr)) /* RTA_DST */
2433 + nla_total_size(4) /* RTA_IIF */
2434 + nla_total_size(0) /* RTA_MULTIPATH */
2435 + maxvif * NLA_ALIGN(sizeof(struct rtnexthop))
2437 + nla_total_size_64bit(sizeof(struct rta_mfc_stats))
2443 static void mr6_netlink_event(struct mr6_table *mrt, struct mfc6_cache *mfc,
2446 struct net *net = read_pnet(&mrt->net);
2447 struct sk_buff *skb;
2450 skb = nlmsg_new(mr6_msgsize(mfc->mf6c_parent >= MAXMIFS, mrt->maxvif),
2455 err = ip6mr_fill_mroute(mrt, skb, 0, 0, mfc, cmd, 0);
2459 rtnl_notify(skb, net, 0, RTNLGRP_IPV6_MROUTE, NULL, GFP_ATOMIC);
2465 rtnl_set_sk_err(net, RTNLGRP_IPV6_MROUTE, err);
2468 static int ip6mr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb)
2470 struct net *net = sock_net(skb->sk);
2471 struct mr6_table *mrt;
2472 struct mfc6_cache *mfc;
2473 unsigned int t = 0, s_t;
2474 unsigned int h = 0, s_h;
2475 unsigned int e = 0, s_e;
2481 read_lock(&mrt_lock);
2482 ip6mr_for_each_table(mrt, net) {
2487 for (h = s_h; h < MFC6_LINES; h++) {
2488 list_for_each_entry(mfc, &mrt->mfc6_cache_array[h], list) {
2491 if (ip6mr_fill_mroute(mrt, skb,
2492 NETLINK_CB(cb->skb).portid,
2502 spin_lock_bh(&mfc_unres_lock);
2503 list_for_each_entry(mfc, &mrt->mfc6_unres_queue, list) {
2506 if (ip6mr_fill_mroute(mrt, skb,
2507 NETLINK_CB(cb->skb).portid,
2511 spin_unlock_bh(&mfc_unres_lock);
2517 spin_unlock_bh(&mfc_unres_lock);
2524 read_unlock(&mrt_lock);