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/system.h>
20 #include <asm/uaccess.h>
21 #include <linux/types.h>
22 #include <linux/sched.h>
23 #include <linux/errno.h>
24 #include <linux/timer.h>
26 #include <linux/kernel.h>
27 #include <linux/fcntl.h>
28 #include <linux/stat.h>
29 #include <linux/socket.h>
30 #include <linux/inet.h>
31 #include <linux/netdevice.h>
32 #include <linux/inetdevice.h>
33 #include <linux/proc_fs.h>
34 #include <linux/seq_file.h>
35 #include <linux/init.h>
36 #include <linux/slab.h>
37 #include <linux/compat.h>
38 #include <net/protocol.h>
39 #include <linux/skbuff.h>
42 #include <linux/notifier.h>
43 #include <linux/if_arp.h>
44 #include <net/checksum.h>
45 #include <net/netlink.h>
46 #include <net/fib_rules.h>
49 #include <net/ip6_route.h>
50 #include <linux/mroute6.h>
51 #include <linux/pim.h>
52 #include <net/addrconf.h>
53 #include <linux/netfilter_ipv6.h>
54 #include <linux/export.h>
55 #include <net/ip6_checksum.h>
58 struct list_head list;
63 struct sock *mroute6_sk;
64 struct timer_list ipmr_expire_timer;
65 struct list_head mfc6_unres_queue;
66 struct list_head mfc6_cache_array[MFC6_LINES];
67 struct mif_device vif6_table[MAXMIFS];
69 atomic_t cache_resolve_queue_len;
72 #ifdef CONFIG_IPV6_PIMSM_V2
73 int mroute_reg_vif_num;
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 int 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 int ip6mr_rtm_dumproute(struct sk_buff *skb,
120 struct netlink_callback *cb);
121 static void mroute_clean_tables(struct mr6_table *mrt);
122 static void ipmr_expire_process(unsigned long arg);
124 #ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
125 #define ip6mr_for_each_table(mrt, net) \
126 list_for_each_entry_rcu(mrt, &net->ipv6.mr6_tables, list)
128 static struct mr6_table *ip6mr_get_table(struct net *net, u32 id)
130 struct mr6_table *mrt;
132 ip6mr_for_each_table(mrt, net) {
139 static int ip6mr_fib_lookup(struct net *net, struct flowi6 *flp6,
140 struct mr6_table **mrt)
143 struct ip6mr_result res;
144 struct fib_lookup_arg arg = {
146 .flags = FIB_LOOKUP_NOREF,
149 err = fib_rules_lookup(net->ipv6.mr6_rules_ops,
150 flowi6_to_flowi(flp6), 0, &arg);
157 static int ip6mr_rule_action(struct fib_rule *rule, struct flowi *flp,
158 int flags, struct fib_lookup_arg *arg)
160 struct ip6mr_result *res = arg->result;
161 struct mr6_table *mrt;
163 switch (rule->action) {
166 case FR_ACT_UNREACHABLE:
168 case FR_ACT_PROHIBIT:
170 case FR_ACT_BLACKHOLE:
175 mrt = ip6mr_get_table(rule->fr_net, rule->table);
182 static int ip6mr_rule_match(struct fib_rule *rule, struct flowi *flp, int flags)
187 static const struct nla_policy ip6mr_rule_policy[FRA_MAX + 1] = {
191 static int ip6mr_rule_configure(struct fib_rule *rule, struct sk_buff *skb,
192 struct fib_rule_hdr *frh, struct nlattr **tb)
197 static int ip6mr_rule_compare(struct fib_rule *rule, struct fib_rule_hdr *frh,
203 static int ip6mr_rule_fill(struct fib_rule *rule, struct sk_buff *skb,
204 struct fib_rule_hdr *frh)
212 static const struct fib_rules_ops __net_initdata ip6mr_rules_ops_template = {
213 .family = RTNL_FAMILY_IP6MR,
214 .rule_size = sizeof(struct ip6mr_rule),
215 .addr_size = sizeof(struct in6_addr),
216 .action = ip6mr_rule_action,
217 .match = ip6mr_rule_match,
218 .configure = ip6mr_rule_configure,
219 .compare = ip6mr_rule_compare,
220 .default_pref = fib_default_rule_pref,
221 .fill = ip6mr_rule_fill,
222 .nlgroup = RTNLGRP_IPV6_RULE,
223 .policy = ip6mr_rule_policy,
224 .owner = THIS_MODULE,
227 static int __net_init ip6mr_rules_init(struct net *net)
229 struct fib_rules_ops *ops;
230 struct mr6_table *mrt;
233 ops = fib_rules_register(&ip6mr_rules_ops_template, net);
237 INIT_LIST_HEAD(&net->ipv6.mr6_tables);
239 mrt = ip6mr_new_table(net, RT6_TABLE_DFLT);
245 err = fib_default_rule_add(ops, 0x7fff, RT6_TABLE_DFLT, 0);
249 net->ipv6.mr6_rules_ops = ops;
255 fib_rules_unregister(ops);
259 static void __net_exit ip6mr_rules_exit(struct net *net)
261 struct mr6_table *mrt, *next;
264 list_for_each_entry_safe(mrt, next, &net->ipv6.mr6_tables, list) {
265 list_del(&mrt->list);
266 ip6mr_free_table(mrt);
269 fib_rules_unregister(net->ipv6.mr6_rules_ops);
272 #define ip6mr_for_each_table(mrt, net) \
273 for (mrt = net->ipv6.mrt6; mrt; mrt = NULL)
275 static struct mr6_table *ip6mr_get_table(struct net *net, u32 id)
277 return net->ipv6.mrt6;
280 static int ip6mr_fib_lookup(struct net *net, struct flowi6 *flp6,
281 struct mr6_table **mrt)
283 *mrt = net->ipv6.mrt6;
287 static int __net_init ip6mr_rules_init(struct net *net)
289 net->ipv6.mrt6 = ip6mr_new_table(net, RT6_TABLE_DFLT);
290 return net->ipv6.mrt6 ? 0 : -ENOMEM;
293 static void __net_exit ip6mr_rules_exit(struct net *net)
296 ip6mr_free_table(net->ipv6.mrt6);
297 net->ipv6.mrt6 = NULL;
302 static struct mr6_table *ip6mr_new_table(struct net *net, u32 id)
304 struct mr6_table *mrt;
307 mrt = ip6mr_get_table(net, id);
311 mrt = kzalloc(sizeof(*mrt), GFP_KERNEL);
315 write_pnet(&mrt->net, net);
317 /* Forwarding cache */
318 for (i = 0; i < MFC6_LINES; i++)
319 INIT_LIST_HEAD(&mrt->mfc6_cache_array[i]);
321 INIT_LIST_HEAD(&mrt->mfc6_unres_queue);
323 setup_timer(&mrt->ipmr_expire_timer, ipmr_expire_process,
326 #ifdef CONFIG_IPV6_PIMSM_V2
327 mrt->mroute_reg_vif_num = -1;
329 #ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
330 list_add_tail_rcu(&mrt->list, &net->ipv6.mr6_tables);
335 static void ip6mr_free_table(struct mr6_table *mrt)
337 del_timer(&mrt->ipmr_expire_timer);
338 mroute_clean_tables(mrt);
342 #ifdef CONFIG_PROC_FS
344 struct ipmr_mfc_iter {
345 struct seq_net_private p;
346 struct mr6_table *mrt;
347 struct list_head *cache;
352 static struct mfc6_cache *ipmr_mfc_seq_idx(struct net *net,
353 struct ipmr_mfc_iter *it, loff_t pos)
355 struct mr6_table *mrt = it->mrt;
356 struct mfc6_cache *mfc;
358 read_lock(&mrt_lock);
359 for (it->ct = 0; it->ct < MFC6_LINES; it->ct++) {
360 it->cache = &mrt->mfc6_cache_array[it->ct];
361 list_for_each_entry(mfc, it->cache, list)
365 read_unlock(&mrt_lock);
367 spin_lock_bh(&mfc_unres_lock);
368 it->cache = &mrt->mfc6_unres_queue;
369 list_for_each_entry(mfc, it->cache, list)
372 spin_unlock_bh(&mfc_unres_lock);
379 * The /proc interfaces to multicast routing /proc/ip6_mr_cache /proc/ip6_mr_vif
382 struct ipmr_vif_iter {
383 struct seq_net_private p;
384 struct mr6_table *mrt;
388 static struct mif_device *ip6mr_vif_seq_idx(struct net *net,
389 struct ipmr_vif_iter *iter,
392 struct mr6_table *mrt = iter->mrt;
394 for (iter->ct = 0; iter->ct < mrt->maxvif; ++iter->ct) {
395 if (!MIF_EXISTS(mrt, iter->ct))
398 return &mrt->vif6_table[iter->ct];
403 static void *ip6mr_vif_seq_start(struct seq_file *seq, loff_t *pos)
406 struct ipmr_vif_iter *iter = seq->private;
407 struct net *net = seq_file_net(seq);
408 struct mr6_table *mrt;
410 mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
412 return ERR_PTR(-ENOENT);
416 read_lock(&mrt_lock);
417 return *pos ? ip6mr_vif_seq_idx(net, seq->private, *pos - 1)
421 static void *ip6mr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos)
423 struct ipmr_vif_iter *iter = seq->private;
424 struct net *net = seq_file_net(seq);
425 struct mr6_table *mrt = iter->mrt;
428 if (v == SEQ_START_TOKEN)
429 return ip6mr_vif_seq_idx(net, iter, 0);
431 while (++iter->ct < mrt->maxvif) {
432 if (!MIF_EXISTS(mrt, iter->ct))
434 return &mrt->vif6_table[iter->ct];
439 static void ip6mr_vif_seq_stop(struct seq_file *seq, void *v)
442 read_unlock(&mrt_lock);
445 static int ip6mr_vif_seq_show(struct seq_file *seq, void *v)
447 struct ipmr_vif_iter *iter = seq->private;
448 struct mr6_table *mrt = iter->mrt;
450 if (v == SEQ_START_TOKEN) {
452 "Interface BytesIn PktsIn BytesOut PktsOut Flags\n");
454 const struct mif_device *vif = v;
455 const char *name = vif->dev ? vif->dev->name : "none";
458 "%2td %-10s %8ld %7ld %8ld %7ld %05X\n",
459 vif - mrt->vif6_table,
460 name, vif->bytes_in, vif->pkt_in,
461 vif->bytes_out, vif->pkt_out,
467 static const struct seq_operations ip6mr_vif_seq_ops = {
468 .start = ip6mr_vif_seq_start,
469 .next = ip6mr_vif_seq_next,
470 .stop = ip6mr_vif_seq_stop,
471 .show = ip6mr_vif_seq_show,
474 static int ip6mr_vif_open(struct inode *inode, struct file *file)
476 return seq_open_net(inode, file, &ip6mr_vif_seq_ops,
477 sizeof(struct ipmr_vif_iter));
480 static const struct file_operations ip6mr_vif_fops = {
481 .owner = THIS_MODULE,
482 .open = ip6mr_vif_open,
485 .release = seq_release_net,
488 static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
490 struct ipmr_mfc_iter *it = seq->private;
491 struct net *net = seq_file_net(seq);
492 struct mr6_table *mrt;
494 mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
496 return ERR_PTR(-ENOENT);
499 return *pos ? ipmr_mfc_seq_idx(net, seq->private, *pos - 1)
503 static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
505 struct mfc6_cache *mfc = v;
506 struct ipmr_mfc_iter *it = seq->private;
507 struct net *net = seq_file_net(seq);
508 struct mr6_table *mrt = it->mrt;
512 if (v == SEQ_START_TOKEN)
513 return ipmr_mfc_seq_idx(net, seq->private, 0);
515 if (mfc->list.next != it->cache)
516 return list_entry(mfc->list.next, struct mfc6_cache, list);
518 if (it->cache == &mrt->mfc6_unres_queue)
521 BUG_ON(it->cache != &mrt->mfc6_cache_array[it->ct]);
523 while (++it->ct < MFC6_LINES) {
524 it->cache = &mrt->mfc6_cache_array[it->ct];
525 if (list_empty(it->cache))
527 return list_first_entry(it->cache, struct mfc6_cache, list);
530 /* exhausted cache_array, show unresolved */
531 read_unlock(&mrt_lock);
532 it->cache = &mrt->mfc6_unres_queue;
535 spin_lock_bh(&mfc_unres_lock);
536 if (!list_empty(it->cache))
537 return list_first_entry(it->cache, struct mfc6_cache, list);
540 spin_unlock_bh(&mfc_unres_lock);
546 static void ipmr_mfc_seq_stop(struct seq_file *seq, void *v)
548 struct ipmr_mfc_iter *it = seq->private;
549 struct mr6_table *mrt = it->mrt;
551 if (it->cache == &mrt->mfc6_unres_queue)
552 spin_unlock_bh(&mfc_unres_lock);
553 else if (it->cache == mrt->mfc6_cache_array)
554 read_unlock(&mrt_lock);
557 static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
561 if (v == SEQ_START_TOKEN) {
565 "Iif Pkts Bytes Wrong Oifs\n");
567 const struct mfc6_cache *mfc = v;
568 const struct ipmr_mfc_iter *it = seq->private;
569 struct mr6_table *mrt = it->mrt;
571 seq_printf(seq, "%pI6 %pI6 %-3hd",
572 &mfc->mf6c_mcastgrp, &mfc->mf6c_origin,
575 if (it->cache != &mrt->mfc6_unres_queue) {
576 seq_printf(seq, " %8lu %8lu %8lu",
578 mfc->mfc_un.res.bytes,
579 mfc->mfc_un.res.wrong_if);
580 for (n = mfc->mfc_un.res.minvif;
581 n < mfc->mfc_un.res.maxvif; n++) {
582 if (MIF_EXISTS(mrt, n) &&
583 mfc->mfc_un.res.ttls[n] < 255)
586 n, mfc->mfc_un.res.ttls[n]);
589 /* unresolved mfc_caches don't contain
590 * pkt, bytes and wrong_if values
592 seq_printf(seq, " %8lu %8lu %8lu", 0ul, 0ul, 0ul);
599 static const struct seq_operations ipmr_mfc_seq_ops = {
600 .start = ipmr_mfc_seq_start,
601 .next = ipmr_mfc_seq_next,
602 .stop = ipmr_mfc_seq_stop,
603 .show = ipmr_mfc_seq_show,
606 static int ipmr_mfc_open(struct inode *inode, struct file *file)
608 return seq_open_net(inode, file, &ipmr_mfc_seq_ops,
609 sizeof(struct ipmr_mfc_iter));
612 static const struct file_operations ip6mr_mfc_fops = {
613 .owner = THIS_MODULE,
614 .open = ipmr_mfc_open,
617 .release = seq_release_net,
621 #ifdef CONFIG_IPV6_PIMSM_V2
623 static int pim6_rcv(struct sk_buff *skb)
625 struct pimreghdr *pim;
626 struct ipv6hdr *encap;
627 struct net_device *reg_dev = NULL;
628 struct net *net = dev_net(skb->dev);
629 struct mr6_table *mrt;
630 struct flowi6 fl6 = {
631 .flowi6_iif = skb->dev->ifindex,
632 .flowi6_mark = skb->mark,
636 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
639 pim = (struct pimreghdr *)skb_transport_header(skb);
640 if (pim->type != ((PIM_VERSION << 4) | PIM_REGISTER) ||
641 (pim->flags & PIM_NULL_REGISTER) ||
642 (csum_ipv6_magic(&ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr,
643 sizeof(*pim), IPPROTO_PIM,
644 csum_partial((void *)pim, sizeof(*pim), 0)) &&
645 csum_fold(skb_checksum(skb, 0, skb->len, 0))))
648 /* check if the inner packet is destined to mcast group */
649 encap = (struct ipv6hdr *)(skb_transport_header(skb) +
652 if (!ipv6_addr_is_multicast(&encap->daddr) ||
653 encap->payload_len == 0 ||
654 ntohs(encap->payload_len) + sizeof(*pim) > skb->len)
657 if (ip6mr_fib_lookup(net, &fl6, &mrt) < 0)
659 reg_vif_num = mrt->mroute_reg_vif_num;
661 read_lock(&mrt_lock);
662 if (reg_vif_num >= 0)
663 reg_dev = mrt->vif6_table[reg_vif_num].dev;
666 read_unlock(&mrt_lock);
671 skb->mac_header = skb->network_header;
672 skb_pull(skb, (u8 *)encap - skb->data);
673 skb_reset_network_header(skb);
674 skb->protocol = htons(ETH_P_IPV6);
675 skb->ip_summed = CHECKSUM_NONE;
676 skb->pkt_type = PACKET_HOST;
678 skb_tunnel_rx(skb, reg_dev);
689 static const struct inet6_protocol pim6_protocol = {
693 /* Service routines creating virtual interfaces: PIMREG */
695 static netdev_tx_t reg_vif_xmit(struct sk_buff *skb,
696 struct net_device *dev)
698 struct net *net = dev_net(dev);
699 struct mr6_table *mrt;
700 struct flowi6 fl6 = {
701 .flowi6_oif = dev->ifindex,
702 .flowi6_iif = skb->skb_iif,
703 .flowi6_mark = skb->mark,
707 err = ip6mr_fib_lookup(net, &fl6, &mrt);
713 read_lock(&mrt_lock);
714 dev->stats.tx_bytes += skb->len;
715 dev->stats.tx_packets++;
716 ip6mr_cache_report(mrt, skb, mrt->mroute_reg_vif_num, MRT6MSG_WHOLEPKT);
717 read_unlock(&mrt_lock);
722 static const struct net_device_ops reg_vif_netdev_ops = {
723 .ndo_start_xmit = reg_vif_xmit,
726 static void reg_vif_setup(struct net_device *dev)
728 dev->type = ARPHRD_PIMREG;
729 dev->mtu = 1500 - sizeof(struct ipv6hdr) - 8;
730 dev->flags = IFF_NOARP;
731 dev->netdev_ops = ®_vif_netdev_ops;
732 dev->destructor = free_netdev;
733 dev->features |= NETIF_F_NETNS_LOCAL;
736 static struct net_device *ip6mr_reg_vif(struct net *net, struct mr6_table *mrt)
738 struct net_device *dev;
741 if (mrt->id == RT6_TABLE_DFLT)
742 sprintf(name, "pim6reg");
744 sprintf(name, "pim6reg%u", mrt->id);
746 dev = alloc_netdev(0, name, reg_vif_setup);
750 dev_net_set(dev, net);
752 if (register_netdevice(dev)) {
765 /* allow the register to be completed before unregistering. */
769 unregister_netdevice(dev);
778 static int mif6_delete(struct mr6_table *mrt, int vifi, struct list_head *head)
780 struct mif_device *v;
781 struct net_device *dev;
782 struct inet6_dev *in6_dev;
784 if (vifi < 0 || vifi >= mrt->maxvif)
785 return -EADDRNOTAVAIL;
787 v = &mrt->vif6_table[vifi];
789 write_lock_bh(&mrt_lock);
794 write_unlock_bh(&mrt_lock);
795 return -EADDRNOTAVAIL;
798 #ifdef CONFIG_IPV6_PIMSM_V2
799 if (vifi == mrt->mroute_reg_vif_num)
800 mrt->mroute_reg_vif_num = -1;
803 if (vifi + 1 == mrt->maxvif) {
805 for (tmp = vifi - 1; tmp >= 0; tmp--) {
806 if (MIF_EXISTS(mrt, tmp))
809 mrt->maxvif = tmp + 1;
812 write_unlock_bh(&mrt_lock);
814 dev_set_allmulti(dev, -1);
816 in6_dev = __in6_dev_get(dev);
818 in6_dev->cnf.mc_forwarding--;
820 if (v->flags & MIFF_REGISTER)
821 unregister_netdevice_queue(dev, head);
827 static inline void ip6mr_cache_free(struct mfc6_cache *c)
829 kmem_cache_free(mrt_cachep, c);
832 /* Destroy an unresolved cache entry, killing queued skbs
833 and reporting error to netlink readers.
836 static void ip6mr_destroy_unres(struct mr6_table *mrt, struct mfc6_cache *c)
838 struct net *net = read_pnet(&mrt->net);
841 atomic_dec(&mrt->cache_resolve_queue_len);
843 while((skb = skb_dequeue(&c->mfc_un.unres.unresolved)) != NULL) {
844 if (ipv6_hdr(skb)->version == 0) {
845 struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct ipv6hdr));
846 nlh->nlmsg_type = NLMSG_ERROR;
847 nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
848 skb_trim(skb, nlh->nlmsg_len);
849 ((struct nlmsgerr *)NLMSG_DATA(nlh))->error = -ETIMEDOUT;
850 rtnl_unicast(skb, net, NETLINK_CB(skb).pid);
859 /* Timer process for all the unresolved queue. */
861 static void ipmr_do_expire_process(struct mr6_table *mrt)
863 unsigned long now = jiffies;
864 unsigned long expires = 10 * HZ;
865 struct mfc6_cache *c, *next;
867 list_for_each_entry_safe(c, next, &mrt->mfc6_unres_queue, list) {
868 if (time_after(c->mfc_un.unres.expires, now)) {
870 unsigned long interval = c->mfc_un.unres.expires - now;
871 if (interval < expires)
877 ip6mr_destroy_unres(mrt, c);
880 if (!list_empty(&mrt->mfc6_unres_queue))
881 mod_timer(&mrt->ipmr_expire_timer, jiffies + expires);
884 static void ipmr_expire_process(unsigned long arg)
886 struct mr6_table *mrt = (struct mr6_table *)arg;
888 if (!spin_trylock(&mfc_unres_lock)) {
889 mod_timer(&mrt->ipmr_expire_timer, jiffies + 1);
893 if (!list_empty(&mrt->mfc6_unres_queue))
894 ipmr_do_expire_process(mrt);
896 spin_unlock(&mfc_unres_lock);
899 /* Fill oifs list. It is called under write locked mrt_lock. */
901 static void ip6mr_update_thresholds(struct mr6_table *mrt, struct mfc6_cache *cache,
906 cache->mfc_un.res.minvif = MAXMIFS;
907 cache->mfc_un.res.maxvif = 0;
908 memset(cache->mfc_un.res.ttls, 255, MAXMIFS);
910 for (vifi = 0; vifi < mrt->maxvif; vifi++) {
911 if (MIF_EXISTS(mrt, vifi) &&
912 ttls[vifi] && ttls[vifi] < 255) {
913 cache->mfc_un.res.ttls[vifi] = ttls[vifi];
914 if (cache->mfc_un.res.minvif > vifi)
915 cache->mfc_un.res.minvif = vifi;
916 if (cache->mfc_un.res.maxvif <= vifi)
917 cache->mfc_un.res.maxvif = vifi + 1;
922 static int mif6_add(struct net *net, struct mr6_table *mrt,
923 struct mif6ctl *vifc, int mrtsock)
925 int vifi = vifc->mif6c_mifi;
926 struct mif_device *v = &mrt->vif6_table[vifi];
927 struct net_device *dev;
928 struct inet6_dev *in6_dev;
932 if (MIF_EXISTS(mrt, vifi))
935 switch (vifc->mif6c_flags) {
936 #ifdef CONFIG_IPV6_PIMSM_V2
939 * Special Purpose VIF in PIM
940 * All the packets will be sent to the daemon
942 if (mrt->mroute_reg_vif_num >= 0)
944 dev = ip6mr_reg_vif(net, mrt);
947 err = dev_set_allmulti(dev, 1);
949 unregister_netdevice(dev);
956 dev = dev_get_by_index(net, vifc->mif6c_pifi);
958 return -EADDRNOTAVAIL;
959 err = dev_set_allmulti(dev, 1);
969 in6_dev = __in6_dev_get(dev);
971 in6_dev->cnf.mc_forwarding++;
974 * Fill in the VIF structures
976 v->rate_limit = vifc->vifc_rate_limit;
977 v->flags = vifc->mif6c_flags;
979 v->flags |= VIFF_STATIC;
980 v->threshold = vifc->vifc_threshold;
985 v->link = dev->ifindex;
986 if (v->flags & MIFF_REGISTER)
987 v->link = dev->iflink;
989 /* And finish update writing critical data */
990 write_lock_bh(&mrt_lock);
992 #ifdef CONFIG_IPV6_PIMSM_V2
993 if (v->flags & MIFF_REGISTER)
994 mrt->mroute_reg_vif_num = vifi;
996 if (vifi + 1 > mrt->maxvif)
997 mrt->maxvif = vifi + 1;
998 write_unlock_bh(&mrt_lock);
1002 static struct mfc6_cache *ip6mr_cache_find(struct mr6_table *mrt,
1003 const struct in6_addr *origin,
1004 const struct in6_addr *mcastgrp)
1006 int line = MFC6_HASH(mcastgrp, origin);
1007 struct mfc6_cache *c;
1009 list_for_each_entry(c, &mrt->mfc6_cache_array[line], list) {
1010 if (ipv6_addr_equal(&c->mf6c_origin, origin) &&
1011 ipv6_addr_equal(&c->mf6c_mcastgrp, mcastgrp))
1018 * Allocate a multicast cache entry
1020 static struct mfc6_cache *ip6mr_cache_alloc(void)
1022 struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
1025 c->mfc_un.res.minvif = MAXMIFS;
1029 static struct mfc6_cache *ip6mr_cache_alloc_unres(void)
1031 struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC);
1034 skb_queue_head_init(&c->mfc_un.unres.unresolved);
1035 c->mfc_un.unres.expires = jiffies + 10 * HZ;
1040 * A cache entry has gone into a resolved state from queued
1043 static void ip6mr_cache_resolve(struct net *net, struct mr6_table *mrt,
1044 struct mfc6_cache *uc, struct mfc6_cache *c)
1046 struct sk_buff *skb;
1049 * Play the pending entries through our router
1052 while((skb = __skb_dequeue(&uc->mfc_un.unres.unresolved))) {
1053 if (ipv6_hdr(skb)->version == 0) {
1054 struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct ipv6hdr));
1056 if (__ip6mr_fill_mroute(mrt, skb, c, NLMSG_DATA(nlh)) > 0) {
1057 nlh->nlmsg_len = skb_tail_pointer(skb) - (u8 *)nlh;
1059 nlh->nlmsg_type = NLMSG_ERROR;
1060 nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
1061 skb_trim(skb, nlh->nlmsg_len);
1062 ((struct nlmsgerr *)NLMSG_DATA(nlh))->error = -EMSGSIZE;
1064 rtnl_unicast(skb, net, NETLINK_CB(skb).pid);
1066 ip6_mr_forward(net, mrt, skb, c);
1071 * Bounce a cache query up to pim6sd. We could use netlink for this but pim6sd
1072 * expects the following bizarre scheme.
1074 * Called under mrt_lock.
1077 static int ip6mr_cache_report(struct mr6_table *mrt, struct sk_buff *pkt,
1078 mifi_t mifi, int assert)
1080 struct sk_buff *skb;
1081 struct mrt6msg *msg;
1084 #ifdef CONFIG_IPV6_PIMSM_V2
1085 if (assert == MRT6MSG_WHOLEPKT)
1086 skb = skb_realloc_headroom(pkt, -skb_network_offset(pkt)
1090 skb = alloc_skb(sizeof(struct ipv6hdr) + sizeof(*msg), GFP_ATOMIC);
1095 /* I suppose that internal messages
1096 * do not require checksums */
1098 skb->ip_summed = CHECKSUM_UNNECESSARY;
1100 #ifdef CONFIG_IPV6_PIMSM_V2
1101 if (assert == MRT6MSG_WHOLEPKT) {
1102 /* Ugly, but we have no choice with this interface.
1103 Duplicate old header, fix length etc.
1104 And all this only to mangle msg->im6_msgtype and
1105 to set msg->im6_mbz to "mbz" :-)
1107 skb_push(skb, -skb_network_offset(pkt));
1109 skb_push(skb, sizeof(*msg));
1110 skb_reset_transport_header(skb);
1111 msg = (struct mrt6msg *)skb_transport_header(skb);
1113 msg->im6_msgtype = MRT6MSG_WHOLEPKT;
1114 msg->im6_mif = mrt->mroute_reg_vif_num;
1116 ipv6_addr_copy(&msg->im6_src, &ipv6_hdr(pkt)->saddr);
1117 ipv6_addr_copy(&msg->im6_dst, &ipv6_hdr(pkt)->daddr);
1119 skb->ip_summed = CHECKSUM_UNNECESSARY;
1124 * Copy the IP header
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));
1134 skb_put(skb, sizeof(*msg));
1135 skb_reset_transport_header(skb);
1136 msg = (struct mrt6msg *)skb_transport_header(skb);
1139 msg->im6_msgtype = assert;
1140 msg->im6_mif = mifi;
1142 ipv6_addr_copy(&msg->im6_src, &ipv6_hdr(pkt)->saddr);
1143 ipv6_addr_copy(&msg->im6_dst, &ipv6_hdr(pkt)->daddr);
1145 skb_dst_set(skb, dst_clone(skb_dst(pkt)));
1146 skb->ip_summed = CHECKSUM_UNNECESSARY;
1149 if (mrt->mroute6_sk == NULL) {
1155 * Deliver to user space multicast routing algorithms
1157 ret = sock_queue_rcv_skb(mrt->mroute6_sk, skb);
1159 if (net_ratelimit())
1160 printk(KERN_WARNING "mroute6: pending queue full, dropping entries.\n");
1168 * Queue a packet for resolution. It gets locked cache entry!
1172 ip6mr_cache_unresolved(struct mr6_table *mrt, mifi_t mifi, struct sk_buff *skb)
1176 struct mfc6_cache *c;
1178 spin_lock_bh(&mfc_unres_lock);
1179 list_for_each_entry(c, &mrt->mfc6_unres_queue, list) {
1180 if (ipv6_addr_equal(&c->mf6c_mcastgrp, &ipv6_hdr(skb)->daddr) &&
1181 ipv6_addr_equal(&c->mf6c_origin, &ipv6_hdr(skb)->saddr)) {
1189 * Create a new entry if allowable
1192 if (atomic_read(&mrt->cache_resolve_queue_len) >= 10 ||
1193 (c = ip6mr_cache_alloc_unres()) == NULL) {
1194 spin_unlock_bh(&mfc_unres_lock);
1201 * Fill in the new cache entry
1203 c->mf6c_parent = -1;
1204 c->mf6c_origin = ipv6_hdr(skb)->saddr;
1205 c->mf6c_mcastgrp = ipv6_hdr(skb)->daddr;
1208 * Reflect first query at pim6sd
1210 err = ip6mr_cache_report(mrt, skb, mifi, MRT6MSG_NOCACHE);
1212 /* If the report failed throw the cache entry
1215 spin_unlock_bh(&mfc_unres_lock);
1217 ip6mr_cache_free(c);
1222 atomic_inc(&mrt->cache_resolve_queue_len);
1223 list_add(&c->list, &mrt->mfc6_unres_queue);
1225 ipmr_do_expire_process(mrt);
1229 * See if we can append the packet
1231 if (c->mfc_un.unres.unresolved.qlen > 3) {
1235 skb_queue_tail(&c->mfc_un.unres.unresolved, skb);
1239 spin_unlock_bh(&mfc_unres_lock);
1244 * MFC6 cache manipulation by user space
1247 static int ip6mr_mfc_delete(struct mr6_table *mrt, struct mf6cctl *mfc)
1250 struct mfc6_cache *c, *next;
1252 line = MFC6_HASH(&mfc->mf6cc_mcastgrp.sin6_addr, &mfc->mf6cc_origin.sin6_addr);
1254 list_for_each_entry_safe(c, next, &mrt->mfc6_cache_array[line], list) {
1255 if (ipv6_addr_equal(&c->mf6c_origin, &mfc->mf6cc_origin.sin6_addr) &&
1256 ipv6_addr_equal(&c->mf6c_mcastgrp, &mfc->mf6cc_mcastgrp.sin6_addr)) {
1257 write_lock_bh(&mrt_lock);
1259 write_unlock_bh(&mrt_lock);
1261 ip6mr_cache_free(c);
1268 static int ip6mr_device_event(struct notifier_block *this,
1269 unsigned long event, void *ptr)
1271 struct net_device *dev = ptr;
1272 struct net *net = dev_net(dev);
1273 struct mr6_table *mrt;
1274 struct mif_device *v;
1278 if (event != NETDEV_UNREGISTER)
1281 ip6mr_for_each_table(mrt, net) {
1282 v = &mrt->vif6_table[0];
1283 for (ct = 0; ct < mrt->maxvif; ct++, v++) {
1285 mif6_delete(mrt, ct, &list);
1288 unregister_netdevice_many(&list);
1293 static struct notifier_block ip6_mr_notifier = {
1294 .notifier_call = ip6mr_device_event
1298 * Setup for IP multicast routing
1301 static int __net_init ip6mr_net_init(struct net *net)
1305 err = ip6mr_rules_init(net);
1309 #ifdef CONFIG_PROC_FS
1311 if (!proc_net_fops_create(net, "ip6_mr_vif", 0, &ip6mr_vif_fops))
1313 if (!proc_net_fops_create(net, "ip6_mr_cache", 0, &ip6mr_mfc_fops))
1314 goto proc_cache_fail;
1319 #ifdef CONFIG_PROC_FS
1321 proc_net_remove(net, "ip6_mr_vif");
1323 ip6mr_rules_exit(net);
1329 static void __net_exit ip6mr_net_exit(struct net *net)
1331 #ifdef CONFIG_PROC_FS
1332 proc_net_remove(net, "ip6_mr_cache");
1333 proc_net_remove(net, "ip6_mr_vif");
1335 ip6mr_rules_exit(net);
1338 static struct pernet_operations ip6mr_net_ops = {
1339 .init = ip6mr_net_init,
1340 .exit = ip6mr_net_exit,
1343 int __init ip6_mr_init(void)
1347 mrt_cachep = kmem_cache_create("ip6_mrt_cache",
1348 sizeof(struct mfc6_cache),
1349 0, SLAB_HWCACHE_ALIGN,
1354 err = register_pernet_subsys(&ip6mr_net_ops);
1356 goto reg_pernet_fail;
1358 err = register_netdevice_notifier(&ip6_mr_notifier);
1360 goto reg_notif_fail;
1361 #ifdef CONFIG_IPV6_PIMSM_V2
1362 if (inet6_add_protocol(&pim6_protocol, IPPROTO_PIM) < 0) {
1363 printk(KERN_ERR "ip6_mr_init: can't add PIM protocol\n");
1365 goto add_proto_fail;
1368 rtnl_register(RTNL_FAMILY_IP6MR, RTM_GETROUTE, NULL,
1369 ip6mr_rtm_dumproute, NULL);
1371 #ifdef CONFIG_IPV6_PIMSM_V2
1373 unregister_netdevice_notifier(&ip6_mr_notifier);
1376 unregister_pernet_subsys(&ip6mr_net_ops);
1378 kmem_cache_destroy(mrt_cachep);
1382 void ip6_mr_cleanup(void)
1384 unregister_netdevice_notifier(&ip6_mr_notifier);
1385 unregister_pernet_subsys(&ip6mr_net_ops);
1386 kmem_cache_destroy(mrt_cachep);
1389 static int ip6mr_mfc_add(struct net *net, struct mr6_table *mrt,
1390 struct mf6cctl *mfc, int mrtsock)
1394 struct mfc6_cache *uc, *c;
1395 unsigned char ttls[MAXMIFS];
1398 if (mfc->mf6cc_parent >= MAXMIFS)
1401 memset(ttls, 255, MAXMIFS);
1402 for (i = 0; i < MAXMIFS; i++) {
1403 if (IF_ISSET(i, &mfc->mf6cc_ifset))
1408 line = MFC6_HASH(&mfc->mf6cc_mcastgrp.sin6_addr, &mfc->mf6cc_origin.sin6_addr);
1410 list_for_each_entry(c, &mrt->mfc6_cache_array[line], list) {
1411 if (ipv6_addr_equal(&c->mf6c_origin, &mfc->mf6cc_origin.sin6_addr) &&
1412 ipv6_addr_equal(&c->mf6c_mcastgrp, &mfc->mf6cc_mcastgrp.sin6_addr)) {
1419 write_lock_bh(&mrt_lock);
1420 c->mf6c_parent = mfc->mf6cc_parent;
1421 ip6mr_update_thresholds(mrt, c, ttls);
1423 c->mfc_flags |= MFC_STATIC;
1424 write_unlock_bh(&mrt_lock);
1428 if (!ipv6_addr_is_multicast(&mfc->mf6cc_mcastgrp.sin6_addr))
1431 c = ip6mr_cache_alloc();
1435 c->mf6c_origin = mfc->mf6cc_origin.sin6_addr;
1436 c->mf6c_mcastgrp = mfc->mf6cc_mcastgrp.sin6_addr;
1437 c->mf6c_parent = mfc->mf6cc_parent;
1438 ip6mr_update_thresholds(mrt, c, ttls);
1440 c->mfc_flags |= MFC_STATIC;
1442 write_lock_bh(&mrt_lock);
1443 list_add(&c->list, &mrt->mfc6_cache_array[line]);
1444 write_unlock_bh(&mrt_lock);
1447 * Check to see if we resolved a queued list. If so we
1448 * need to send on the frames and tidy up.
1451 spin_lock_bh(&mfc_unres_lock);
1452 list_for_each_entry(uc, &mrt->mfc6_unres_queue, list) {
1453 if (ipv6_addr_equal(&uc->mf6c_origin, &c->mf6c_origin) &&
1454 ipv6_addr_equal(&uc->mf6c_mcastgrp, &c->mf6c_mcastgrp)) {
1455 list_del(&uc->list);
1456 atomic_dec(&mrt->cache_resolve_queue_len);
1461 if (list_empty(&mrt->mfc6_unres_queue))
1462 del_timer(&mrt->ipmr_expire_timer);
1463 spin_unlock_bh(&mfc_unres_lock);
1466 ip6mr_cache_resolve(net, mrt, uc, c);
1467 ip6mr_cache_free(uc);
1473 * Close the multicast socket, and clear the vif tables etc
1476 static void mroute_clean_tables(struct mr6_table *mrt)
1480 struct mfc6_cache *c, *next;
1483 * Shut down all active vif entries
1485 for (i = 0; i < mrt->maxvif; i++) {
1486 if (!(mrt->vif6_table[i].flags & VIFF_STATIC))
1487 mif6_delete(mrt, i, &list);
1489 unregister_netdevice_many(&list);
1494 for (i = 0; i < MFC6_LINES; i++) {
1495 list_for_each_entry_safe(c, next, &mrt->mfc6_cache_array[i], list) {
1496 if (c->mfc_flags & MFC_STATIC)
1498 write_lock_bh(&mrt_lock);
1500 write_unlock_bh(&mrt_lock);
1502 ip6mr_cache_free(c);
1506 if (atomic_read(&mrt->cache_resolve_queue_len) != 0) {
1507 spin_lock_bh(&mfc_unres_lock);
1508 list_for_each_entry_safe(c, next, &mrt->mfc6_unres_queue, list) {
1510 ip6mr_destroy_unres(mrt, c);
1512 spin_unlock_bh(&mfc_unres_lock);
1516 static int ip6mr_sk_init(struct mr6_table *mrt, struct sock *sk)
1519 struct net *net = sock_net(sk);
1522 write_lock_bh(&mrt_lock);
1523 if (likely(mrt->mroute6_sk == NULL)) {
1524 mrt->mroute6_sk = sk;
1525 net->ipv6.devconf_all->mc_forwarding++;
1529 write_unlock_bh(&mrt_lock);
1536 int ip6mr_sk_done(struct sock *sk)
1539 struct net *net = sock_net(sk);
1540 struct mr6_table *mrt;
1543 ip6mr_for_each_table(mrt, net) {
1544 if (sk == mrt->mroute6_sk) {
1545 write_lock_bh(&mrt_lock);
1546 mrt->mroute6_sk = NULL;
1547 net->ipv6.devconf_all->mc_forwarding--;
1548 write_unlock_bh(&mrt_lock);
1550 mroute_clean_tables(mrt);
1560 struct sock *mroute6_socket(struct net *net, struct sk_buff *skb)
1562 struct mr6_table *mrt;
1563 struct flowi6 fl6 = {
1564 .flowi6_iif = skb->skb_iif,
1565 .flowi6_oif = skb->dev->ifindex,
1566 .flowi6_mark = skb->mark,
1569 if (ip6mr_fib_lookup(net, &fl6, &mrt) < 0)
1572 return mrt->mroute6_sk;
1576 * Socket options and virtual interface manipulation. The whole
1577 * virtual interface system is a complete heap, but unfortunately
1578 * that's how BSD mrouted happens to think. Maybe one day with a proper
1579 * MOSPF/PIM router set up we can clean this up.
1582 int ip6_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsigned int optlen)
1588 struct net *net = sock_net(sk);
1589 struct mr6_table *mrt;
1591 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1595 if (optname != MRT6_INIT) {
1596 if (sk != mrt->mroute6_sk && !capable(CAP_NET_ADMIN))
1602 if (sk->sk_type != SOCK_RAW ||
1603 inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
1605 if (optlen < sizeof(int))
1608 return ip6mr_sk_init(mrt, sk);
1611 return ip6mr_sk_done(sk);
1614 if (optlen < sizeof(vif))
1616 if (copy_from_user(&vif, optval, sizeof(vif)))
1618 if (vif.mif6c_mifi >= MAXMIFS)
1621 ret = mif6_add(net, mrt, &vif, sk == mrt->mroute6_sk);
1626 if (optlen < sizeof(mifi_t))
1628 if (copy_from_user(&mifi, optval, sizeof(mifi_t)))
1631 ret = mif6_delete(mrt, mifi, NULL);
1636 * Manipulate the forwarding caches. These live
1637 * in a sort of kernel/user symbiosis.
1641 if (optlen < sizeof(mfc))
1643 if (copy_from_user(&mfc, optval, sizeof(mfc)))
1646 if (optname == MRT6_DEL_MFC)
1647 ret = ip6mr_mfc_delete(mrt, &mfc);
1649 ret = ip6mr_mfc_add(net, mrt, &mfc, sk == mrt->mroute6_sk);
1654 * Control PIM assert (to activate pim will activate assert)
1659 if (get_user(v, (int __user *)optval))
1661 mrt->mroute_do_assert = !!v;
1665 #ifdef CONFIG_IPV6_PIMSM_V2
1669 if (get_user(v, (int __user *)optval))
1674 if (v != mrt->mroute_do_pim) {
1675 mrt->mroute_do_pim = v;
1676 mrt->mroute_do_assert = v;
1683 #ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
1688 if (optlen != sizeof(u32))
1690 if (get_user(v, (u32 __user *)optval))
1692 if (sk == mrt->mroute6_sk)
1697 if (!ip6mr_new_table(net, v))
1699 raw6_sk(sk)->ip6mr_table = v;
1705 * Spurious command, or MRT6_VERSION which you cannot
1709 return -ENOPROTOOPT;
1714 * Getsock opt support for the multicast routing system.
1717 int ip6_mroute_getsockopt(struct sock *sk, int optname, char __user *optval,
1722 struct net *net = sock_net(sk);
1723 struct mr6_table *mrt;
1725 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1733 #ifdef CONFIG_IPV6_PIMSM_V2
1735 val = mrt->mroute_do_pim;
1739 val = mrt->mroute_do_assert;
1742 return -ENOPROTOOPT;
1745 if (get_user(olr, optlen))
1748 olr = min_t(int, olr, sizeof(int));
1752 if (put_user(olr, optlen))
1754 if (copy_to_user(optval, &val, olr))
1760 * The IP multicast ioctl support routines.
1763 int ip6mr_ioctl(struct sock *sk, int cmd, void __user *arg)
1765 struct sioc_sg_req6 sr;
1766 struct sioc_mif_req6 vr;
1767 struct mif_device *vif;
1768 struct mfc6_cache *c;
1769 struct net *net = sock_net(sk);
1770 struct mr6_table *mrt;
1772 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1777 case SIOCGETMIFCNT_IN6:
1778 if (copy_from_user(&vr, arg, sizeof(vr)))
1780 if (vr.mifi >= mrt->maxvif)
1782 read_lock(&mrt_lock);
1783 vif = &mrt->vif6_table[vr.mifi];
1784 if (MIF_EXISTS(mrt, vr.mifi)) {
1785 vr.icount = vif->pkt_in;
1786 vr.ocount = vif->pkt_out;
1787 vr.ibytes = vif->bytes_in;
1788 vr.obytes = vif->bytes_out;
1789 read_unlock(&mrt_lock);
1791 if (copy_to_user(arg, &vr, sizeof(vr)))
1795 read_unlock(&mrt_lock);
1796 return -EADDRNOTAVAIL;
1797 case SIOCGETSGCNT_IN6:
1798 if (copy_from_user(&sr, arg, sizeof(sr)))
1801 read_lock(&mrt_lock);
1802 c = ip6mr_cache_find(mrt, &sr.src.sin6_addr, &sr.grp.sin6_addr);
1804 sr.pktcnt = c->mfc_un.res.pkt;
1805 sr.bytecnt = c->mfc_un.res.bytes;
1806 sr.wrong_if = c->mfc_un.res.wrong_if;
1807 read_unlock(&mrt_lock);
1809 if (copy_to_user(arg, &sr, sizeof(sr)))
1813 read_unlock(&mrt_lock);
1814 return -EADDRNOTAVAIL;
1816 return -ENOIOCTLCMD;
1820 #ifdef CONFIG_COMPAT
1821 struct compat_sioc_sg_req6 {
1822 struct sockaddr_in6 src;
1823 struct sockaddr_in6 grp;
1824 compat_ulong_t pktcnt;
1825 compat_ulong_t bytecnt;
1826 compat_ulong_t wrong_if;
1829 struct compat_sioc_mif_req6 {
1831 compat_ulong_t icount;
1832 compat_ulong_t ocount;
1833 compat_ulong_t ibytes;
1834 compat_ulong_t obytes;
1837 int ip6mr_compat_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
1839 struct compat_sioc_sg_req6 sr;
1840 struct compat_sioc_mif_req6 vr;
1841 struct mif_device *vif;
1842 struct mfc6_cache *c;
1843 struct net *net = sock_net(sk);
1844 struct mr6_table *mrt;
1846 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1851 case SIOCGETMIFCNT_IN6:
1852 if (copy_from_user(&vr, arg, sizeof(vr)))
1854 if (vr.mifi >= mrt->maxvif)
1856 read_lock(&mrt_lock);
1857 vif = &mrt->vif6_table[vr.mifi];
1858 if (MIF_EXISTS(mrt, vr.mifi)) {
1859 vr.icount = vif->pkt_in;
1860 vr.ocount = vif->pkt_out;
1861 vr.ibytes = vif->bytes_in;
1862 vr.obytes = vif->bytes_out;
1863 read_unlock(&mrt_lock);
1865 if (copy_to_user(arg, &vr, sizeof(vr)))
1869 read_unlock(&mrt_lock);
1870 return -EADDRNOTAVAIL;
1871 case SIOCGETSGCNT_IN6:
1872 if (copy_from_user(&sr, arg, sizeof(sr)))
1875 read_lock(&mrt_lock);
1876 c = ip6mr_cache_find(mrt, &sr.src.sin6_addr, &sr.grp.sin6_addr);
1878 sr.pktcnt = c->mfc_un.res.pkt;
1879 sr.bytecnt = c->mfc_un.res.bytes;
1880 sr.wrong_if = c->mfc_un.res.wrong_if;
1881 read_unlock(&mrt_lock);
1883 if (copy_to_user(arg, &sr, sizeof(sr)))
1887 read_unlock(&mrt_lock);
1888 return -EADDRNOTAVAIL;
1890 return -ENOIOCTLCMD;
1895 static inline int ip6mr_forward2_finish(struct sk_buff *skb)
1897 IP6_INC_STATS_BH(dev_net(skb_dst(skb)->dev), ip6_dst_idev(skb_dst(skb)),
1898 IPSTATS_MIB_OUTFORWDATAGRAMS);
1899 return dst_output(skb);
1903 * Processing handlers for ip6mr_forward
1906 static int ip6mr_forward2(struct net *net, struct mr6_table *mrt,
1907 struct sk_buff *skb, struct mfc6_cache *c, int vifi)
1909 struct ipv6hdr *ipv6h;
1910 struct mif_device *vif = &mrt->vif6_table[vifi];
1911 struct net_device *dev;
1912 struct dst_entry *dst;
1915 if (vif->dev == NULL)
1918 #ifdef CONFIG_IPV6_PIMSM_V2
1919 if (vif->flags & MIFF_REGISTER) {
1921 vif->bytes_out += skb->len;
1922 vif->dev->stats.tx_bytes += skb->len;
1923 vif->dev->stats.tx_packets++;
1924 ip6mr_cache_report(mrt, skb, vifi, MRT6MSG_WHOLEPKT);
1929 ipv6h = ipv6_hdr(skb);
1931 fl6 = (struct flowi6) {
1932 .flowi6_oif = vif->link,
1933 .daddr = ipv6h->daddr,
1936 dst = ip6_route_output(net, NULL, &fl6);
1941 skb_dst_set(skb, dst);
1944 * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
1945 * not only before forwarding, but after forwarding on all output
1946 * interfaces. It is clear, if mrouter runs a multicasting
1947 * program, it should receive packets not depending to what interface
1948 * program is joined.
1949 * If we will not make it, the program will have to join on all
1950 * interfaces. On the other hand, multihoming host (or router, but
1951 * not mrouter) cannot join to more than one interface - it will
1952 * result in receiving multiple packets.
1957 vif->bytes_out += skb->len;
1959 /* We are about to write */
1960 /* XXX: extension headers? */
1961 if (skb_cow(skb, sizeof(*ipv6h) + LL_RESERVED_SPACE(dev)))
1964 ipv6h = ipv6_hdr(skb);
1967 IP6CB(skb)->flags |= IP6SKB_FORWARDED;
1969 return NF_HOOK(NFPROTO_IPV6, NF_INET_FORWARD, skb, skb->dev, dev,
1970 ip6mr_forward2_finish);
1977 static int ip6mr_find_vif(struct mr6_table *mrt, struct net_device *dev)
1981 for (ct = mrt->maxvif - 1; ct >= 0; ct--) {
1982 if (mrt->vif6_table[ct].dev == dev)
1988 static int ip6_mr_forward(struct net *net, struct mr6_table *mrt,
1989 struct sk_buff *skb, struct mfc6_cache *cache)
1994 vif = cache->mf6c_parent;
1995 cache->mfc_un.res.pkt++;
1996 cache->mfc_un.res.bytes += skb->len;
1999 * Wrong interface: drop packet and (maybe) send PIM assert.
2001 if (mrt->vif6_table[vif].dev != skb->dev) {
2004 cache->mfc_un.res.wrong_if++;
2005 true_vifi = ip6mr_find_vif(mrt, skb->dev);
2007 if (true_vifi >= 0 && mrt->mroute_do_assert &&
2008 /* pimsm uses asserts, when switching from RPT to SPT,
2009 so that we cannot check that packet arrived on an oif.
2010 It is bad, but otherwise we would need to move pretty
2011 large chunk of pimd to kernel. Ough... --ANK
2013 (mrt->mroute_do_pim ||
2014 cache->mfc_un.res.ttls[true_vifi] < 255) &&
2016 cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
2017 cache->mfc_un.res.last_assert = jiffies;
2018 ip6mr_cache_report(mrt, skb, true_vifi, MRT6MSG_WRONGMIF);
2023 mrt->vif6_table[vif].pkt_in++;
2024 mrt->vif6_table[vif].bytes_in += skb->len;
2029 for (ct = cache->mfc_un.res.maxvif - 1; ct >= cache->mfc_un.res.minvif; ct--) {
2030 if (ipv6_hdr(skb)->hop_limit > cache->mfc_un.res.ttls[ct]) {
2032 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
2034 ip6mr_forward2(net, mrt, skb2, cache, psend);
2040 ip6mr_forward2(net, mrt, skb, cache, psend);
2051 * Multicast packets for forwarding arrive here
2054 int ip6_mr_input(struct sk_buff *skb)
2056 struct mfc6_cache *cache;
2057 struct net *net = dev_net(skb->dev);
2058 struct mr6_table *mrt;
2059 struct flowi6 fl6 = {
2060 .flowi6_iif = skb->dev->ifindex,
2061 .flowi6_mark = skb->mark,
2065 err = ip6mr_fib_lookup(net, &fl6, &mrt);
2071 read_lock(&mrt_lock);
2072 cache = ip6mr_cache_find(mrt,
2073 &ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr);
2076 * No usable cache entry
2078 if (cache == NULL) {
2081 vif = ip6mr_find_vif(mrt, skb->dev);
2083 int err = ip6mr_cache_unresolved(mrt, vif, skb);
2084 read_unlock(&mrt_lock);
2088 read_unlock(&mrt_lock);
2093 ip6_mr_forward(net, mrt, skb, cache);
2095 read_unlock(&mrt_lock);
2101 static int __ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb,
2102 struct mfc6_cache *c, struct rtmsg *rtm)
2105 struct rtnexthop *nhp;
2106 u8 *b = skb_tail_pointer(skb);
2107 struct rtattr *mp_head;
2109 /* If cache is unresolved, don't try to parse IIF and OIF */
2110 if (c->mf6c_parent >= MAXMIFS)
2113 if (MIF_EXISTS(mrt, c->mf6c_parent))
2114 RTA_PUT(skb, RTA_IIF, 4, &mrt->vif6_table[c->mf6c_parent].dev->ifindex);
2116 mp_head = (struct rtattr *)skb_put(skb, RTA_LENGTH(0));
2118 for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
2119 if (MIF_EXISTS(mrt, ct) && c->mfc_un.res.ttls[ct] < 255) {
2120 if (skb_tailroom(skb) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp)) + 4))
2121 goto rtattr_failure;
2122 nhp = (struct rtnexthop *)skb_put(skb, RTA_ALIGN(sizeof(*nhp)));
2123 nhp->rtnh_flags = 0;
2124 nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
2125 nhp->rtnh_ifindex = mrt->vif6_table[ct].dev->ifindex;
2126 nhp->rtnh_len = sizeof(*nhp);
2129 mp_head->rta_type = RTA_MULTIPATH;
2130 mp_head->rta_len = skb_tail_pointer(skb) - (u8 *)mp_head;
2131 rtm->rtm_type = RTN_MULTICAST;
2139 int ip6mr_get_route(struct net *net,
2140 struct sk_buff *skb, struct rtmsg *rtm, int nowait)
2143 struct mr6_table *mrt;
2144 struct mfc6_cache *cache;
2145 struct rt6_info *rt = (struct rt6_info *)skb_dst(skb);
2147 mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
2151 read_lock(&mrt_lock);
2152 cache = ip6mr_cache_find(mrt, &rt->rt6i_src.addr, &rt->rt6i_dst.addr);
2155 struct sk_buff *skb2;
2156 struct ipv6hdr *iph;
2157 struct net_device *dev;
2161 read_unlock(&mrt_lock);
2166 if (dev == NULL || (vif = ip6mr_find_vif(mrt, dev)) < 0) {
2167 read_unlock(&mrt_lock);
2171 /* really correct? */
2172 skb2 = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC);
2174 read_unlock(&mrt_lock);
2178 skb_reset_transport_header(skb2);
2180 skb_put(skb2, sizeof(struct ipv6hdr));
2181 skb_reset_network_header(skb2);
2183 iph = ipv6_hdr(skb2);
2186 iph->flow_lbl[0] = 0;
2187 iph->flow_lbl[1] = 0;
2188 iph->flow_lbl[2] = 0;
2189 iph->payload_len = 0;
2190 iph->nexthdr = IPPROTO_NONE;
2192 ipv6_addr_copy(&iph->saddr, &rt->rt6i_src.addr);
2193 ipv6_addr_copy(&iph->daddr, &rt->rt6i_dst.addr);
2195 err = ip6mr_cache_unresolved(mrt, vif, skb2);
2196 read_unlock(&mrt_lock);
2201 if (!nowait && (rtm->rtm_flags&RTM_F_NOTIFY))
2202 cache->mfc_flags |= MFC_NOTIFY;
2204 err = __ip6mr_fill_mroute(mrt, skb, cache, rtm);
2205 read_unlock(&mrt_lock);
2209 static int ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb,
2210 u32 pid, u32 seq, struct mfc6_cache *c)
2212 struct nlmsghdr *nlh;
2215 nlh = nlmsg_put(skb, pid, seq, RTM_NEWROUTE, sizeof(*rtm), NLM_F_MULTI);
2219 rtm = nlmsg_data(nlh);
2220 rtm->rtm_family = RTNL_FAMILY_IPMR;
2221 rtm->rtm_dst_len = 128;
2222 rtm->rtm_src_len = 128;
2224 rtm->rtm_table = mrt->id;
2225 NLA_PUT_U32(skb, RTA_TABLE, mrt->id);
2226 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2227 rtm->rtm_protocol = RTPROT_UNSPEC;
2230 NLA_PUT(skb, RTA_SRC, 16, &c->mf6c_origin);
2231 NLA_PUT(skb, RTA_DST, 16, &c->mf6c_mcastgrp);
2233 if (__ip6mr_fill_mroute(mrt, skb, c, rtm) < 0)
2234 goto nla_put_failure;
2236 return nlmsg_end(skb, nlh);
2239 nlmsg_cancel(skb, nlh);
2243 static int ip6mr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb)
2245 struct net *net = sock_net(skb->sk);
2246 struct mr6_table *mrt;
2247 struct mfc6_cache *mfc;
2248 unsigned int t = 0, s_t;
2249 unsigned int h = 0, s_h;
2250 unsigned int e = 0, s_e;
2256 read_lock(&mrt_lock);
2257 ip6mr_for_each_table(mrt, net) {
2262 for (h = s_h; h < MFC6_LINES; h++) {
2263 list_for_each_entry(mfc, &mrt->mfc6_cache_array[h], list) {
2266 if (ip6mr_fill_mroute(mrt, skb,
2267 NETLINK_CB(cb->skb).pid,
2281 read_unlock(&mrt_lock);