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 <net/ip6_checksum.h>
57 struct list_head list;
62 struct sock *mroute6_sk;
63 struct timer_list ipmr_expire_timer;
64 struct list_head mfc6_unres_queue;
65 struct list_head mfc6_cache_array[MFC6_LINES];
66 struct mif_device vif6_table[MAXMIFS];
68 atomic_t cache_resolve_queue_len;
71 #ifdef CONFIG_IPV6_PIMSM_V2
72 int mroute_reg_vif_num;
77 struct fib_rule common;
81 struct mr6_table *mrt;
84 /* Big lock, protecting vif table, mrt cache and mroute socket state.
85 Note that the changes are semaphored via rtnl_lock.
88 static DEFINE_RWLOCK(mrt_lock);
91 * Multicast router control variables
94 #define MIF_EXISTS(_mrt, _idx) ((_mrt)->vif6_table[_idx].dev != NULL)
96 /* Special spinlock for queue of unresolved entries */
97 static DEFINE_SPINLOCK(mfc_unres_lock);
99 /* We return to original Alan's scheme. Hash table of resolved
100 entries is changed only in process context and protected
101 with weak lock mrt_lock. Queue of unresolved entries is protected
102 with strong spinlock mfc_unres_lock.
104 In this case data path is free of exclusive locks at all.
107 static struct kmem_cache *mrt_cachep __read_mostly;
109 static struct mr6_table *ip6mr_new_table(struct net *net, u32 id);
110 static void ip6mr_free_table(struct mr6_table *mrt);
112 static int ip6_mr_forward(struct net *net, struct mr6_table *mrt,
113 struct sk_buff *skb, struct mfc6_cache *cache);
114 static int ip6mr_cache_report(struct mr6_table *mrt, struct sk_buff *pkt,
115 mifi_t mifi, int assert);
116 static int __ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb,
117 struct mfc6_cache *c, struct rtmsg *rtm);
118 static int ip6mr_rtm_dumproute(struct sk_buff *skb,
119 struct netlink_callback *cb);
120 static void mroute_clean_tables(struct mr6_table *mrt);
121 static void ipmr_expire_process(unsigned long arg);
123 #ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
124 #define ip6mr_for_each_table(mrt, net) \
125 list_for_each_entry_rcu(mrt, &net->ipv6.mr6_tables, list)
127 static struct mr6_table *ip6mr_get_table(struct net *net, u32 id)
129 struct mr6_table *mrt;
131 ip6mr_for_each_table(mrt, net) {
138 static int ip6mr_fib_lookup(struct net *net, struct flowi *flp,
139 struct mr6_table **mrt)
141 struct ip6mr_result res;
142 struct fib_lookup_arg arg = { .result = &res, };
145 err = fib_rules_lookup(net->ipv6.mr6_rules_ops, flp, 0, &arg);
152 static int ip6mr_rule_action(struct fib_rule *rule, struct flowi *flp,
153 int flags, struct fib_lookup_arg *arg)
155 struct ip6mr_result *res = arg->result;
156 struct mr6_table *mrt;
158 switch (rule->action) {
161 case FR_ACT_UNREACHABLE:
163 case FR_ACT_PROHIBIT:
165 case FR_ACT_BLACKHOLE:
170 mrt = ip6mr_get_table(rule->fr_net, rule->table);
177 static int ip6mr_rule_match(struct fib_rule *rule, struct flowi *flp, int flags)
182 static const struct nla_policy ip6mr_rule_policy[FRA_MAX + 1] = {
186 static int ip6mr_rule_configure(struct fib_rule *rule, struct sk_buff *skb,
187 struct fib_rule_hdr *frh, struct nlattr **tb)
192 static int ip6mr_rule_compare(struct fib_rule *rule, struct fib_rule_hdr *frh,
198 static int ip6mr_rule_fill(struct fib_rule *rule, struct sk_buff *skb,
199 struct fib_rule_hdr *frh)
207 static const struct fib_rules_ops __net_initdata ip6mr_rules_ops_template = {
208 .family = RTNL_FAMILY_IP6MR,
209 .rule_size = sizeof(struct ip6mr_rule),
210 .addr_size = sizeof(struct in6_addr),
211 .action = ip6mr_rule_action,
212 .match = ip6mr_rule_match,
213 .configure = ip6mr_rule_configure,
214 .compare = ip6mr_rule_compare,
215 .default_pref = fib_default_rule_pref,
216 .fill = ip6mr_rule_fill,
217 .nlgroup = RTNLGRP_IPV6_RULE,
218 .policy = ip6mr_rule_policy,
219 .owner = THIS_MODULE,
222 static int __net_init ip6mr_rules_init(struct net *net)
224 struct fib_rules_ops *ops;
225 struct mr6_table *mrt;
228 ops = fib_rules_register(&ip6mr_rules_ops_template, net);
232 INIT_LIST_HEAD(&net->ipv6.mr6_tables);
234 mrt = ip6mr_new_table(net, RT6_TABLE_DFLT);
240 err = fib_default_rule_add(ops, 0x7fff, RT6_TABLE_DFLT, 0);
244 net->ipv6.mr6_rules_ops = ops;
250 fib_rules_unregister(ops);
254 static void __net_exit ip6mr_rules_exit(struct net *net)
256 struct mr6_table *mrt, *next;
258 list_for_each_entry_safe(mrt, next, &net->ipv6.mr6_tables, list) {
259 list_del(&mrt->list);
260 ip6mr_free_table(mrt);
262 fib_rules_unregister(net->ipv6.mr6_rules_ops);
265 #define ip6mr_for_each_table(mrt, net) \
266 for (mrt = net->ipv6.mrt6; mrt; mrt = NULL)
268 static struct mr6_table *ip6mr_get_table(struct net *net, u32 id)
270 return net->ipv6.mrt6;
273 static int ip6mr_fib_lookup(struct net *net, struct flowi *flp,
274 struct mr6_table **mrt)
276 *mrt = net->ipv6.mrt6;
280 static int __net_init ip6mr_rules_init(struct net *net)
282 net->ipv6.mrt6 = ip6mr_new_table(net, RT6_TABLE_DFLT);
283 return net->ipv6.mrt6 ? 0 : -ENOMEM;
286 static void __net_exit ip6mr_rules_exit(struct net *net)
288 ip6mr_free_table(net->ipv6.mrt6);
292 static struct mr6_table *ip6mr_new_table(struct net *net, u32 id)
294 struct mr6_table *mrt;
297 mrt = ip6mr_get_table(net, id);
301 mrt = kzalloc(sizeof(*mrt), GFP_KERNEL);
305 write_pnet(&mrt->net, net);
307 /* Forwarding cache */
308 for (i = 0; i < MFC6_LINES; i++)
309 INIT_LIST_HEAD(&mrt->mfc6_cache_array[i]);
311 INIT_LIST_HEAD(&mrt->mfc6_unres_queue);
313 setup_timer(&mrt->ipmr_expire_timer, ipmr_expire_process,
316 #ifdef CONFIG_IPV6_PIMSM_V2
317 mrt->mroute_reg_vif_num = -1;
319 #ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
320 list_add_tail_rcu(&mrt->list, &net->ipv6.mr6_tables);
325 static void ip6mr_free_table(struct mr6_table *mrt)
327 del_timer(&mrt->ipmr_expire_timer);
328 mroute_clean_tables(mrt);
332 #ifdef CONFIG_PROC_FS
334 struct ipmr_mfc_iter {
335 struct seq_net_private p;
336 struct mr6_table *mrt;
337 struct list_head *cache;
342 static struct mfc6_cache *ipmr_mfc_seq_idx(struct net *net,
343 struct ipmr_mfc_iter *it, loff_t pos)
345 struct mr6_table *mrt = it->mrt;
346 struct mfc6_cache *mfc;
348 read_lock(&mrt_lock);
349 for (it->ct = 0; it->ct < MFC6_LINES; it->ct++) {
350 it->cache = &mrt->mfc6_cache_array[it->ct];
351 list_for_each_entry(mfc, it->cache, list)
355 read_unlock(&mrt_lock);
357 spin_lock_bh(&mfc_unres_lock);
358 it->cache = &mrt->mfc6_unres_queue;
359 list_for_each_entry(mfc, it->cache, list)
362 spin_unlock_bh(&mfc_unres_lock);
369 * The /proc interfaces to multicast routing /proc/ip6_mr_cache /proc/ip6_mr_vif
372 struct ipmr_vif_iter {
373 struct seq_net_private p;
374 struct mr6_table *mrt;
378 static struct mif_device *ip6mr_vif_seq_idx(struct net *net,
379 struct ipmr_vif_iter *iter,
382 struct mr6_table *mrt = iter->mrt;
384 for (iter->ct = 0; iter->ct < mrt->maxvif; ++iter->ct) {
385 if (!MIF_EXISTS(mrt, iter->ct))
388 return &mrt->vif6_table[iter->ct];
393 static void *ip6mr_vif_seq_start(struct seq_file *seq, loff_t *pos)
396 struct ipmr_vif_iter *iter = seq->private;
397 struct net *net = seq_file_net(seq);
398 struct mr6_table *mrt;
400 mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
402 return ERR_PTR(-ENOENT);
406 read_lock(&mrt_lock);
407 return *pos ? ip6mr_vif_seq_idx(net, seq->private, *pos - 1)
411 static void *ip6mr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos)
413 struct ipmr_vif_iter *iter = seq->private;
414 struct net *net = seq_file_net(seq);
415 struct mr6_table *mrt = iter->mrt;
418 if (v == SEQ_START_TOKEN)
419 return ip6mr_vif_seq_idx(net, iter, 0);
421 while (++iter->ct < mrt->maxvif) {
422 if (!MIF_EXISTS(mrt, iter->ct))
424 return &mrt->vif6_table[iter->ct];
429 static void ip6mr_vif_seq_stop(struct seq_file *seq, void *v)
432 read_unlock(&mrt_lock);
435 static int ip6mr_vif_seq_show(struct seq_file *seq, void *v)
437 struct ipmr_vif_iter *iter = seq->private;
438 struct mr6_table *mrt = iter->mrt;
440 if (v == SEQ_START_TOKEN) {
442 "Interface BytesIn PktsIn BytesOut PktsOut Flags\n");
444 const struct mif_device *vif = v;
445 const char *name = vif->dev ? vif->dev->name : "none";
448 "%2td %-10s %8ld %7ld %8ld %7ld %05X\n",
449 vif - mrt->vif6_table,
450 name, vif->bytes_in, vif->pkt_in,
451 vif->bytes_out, vif->pkt_out,
457 static const struct seq_operations ip6mr_vif_seq_ops = {
458 .start = ip6mr_vif_seq_start,
459 .next = ip6mr_vif_seq_next,
460 .stop = ip6mr_vif_seq_stop,
461 .show = ip6mr_vif_seq_show,
464 static int ip6mr_vif_open(struct inode *inode, struct file *file)
466 return seq_open_net(inode, file, &ip6mr_vif_seq_ops,
467 sizeof(struct ipmr_vif_iter));
470 static const struct file_operations ip6mr_vif_fops = {
471 .owner = THIS_MODULE,
472 .open = ip6mr_vif_open,
475 .release = seq_release_net,
478 static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
480 struct ipmr_mfc_iter *it = seq->private;
481 struct net *net = seq_file_net(seq);
482 struct mr6_table *mrt;
484 mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
486 return ERR_PTR(-ENOENT);
489 return *pos ? ipmr_mfc_seq_idx(net, seq->private, *pos - 1)
493 static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
495 struct mfc6_cache *mfc = v;
496 struct ipmr_mfc_iter *it = seq->private;
497 struct net *net = seq_file_net(seq);
498 struct mr6_table *mrt = it->mrt;
502 if (v == SEQ_START_TOKEN)
503 return ipmr_mfc_seq_idx(net, seq->private, 0);
505 if (mfc->list.next != it->cache)
506 return list_entry(mfc->list.next, struct mfc6_cache, list);
508 if (it->cache == &mrt->mfc6_unres_queue)
511 BUG_ON(it->cache != &mrt->mfc6_cache_array[it->ct]);
513 while (++it->ct < MFC6_LINES) {
514 it->cache = &mrt->mfc6_cache_array[it->ct];
515 if (list_empty(it->cache))
517 return list_first_entry(it->cache, struct mfc6_cache, list);
520 /* exhausted cache_array, show unresolved */
521 read_unlock(&mrt_lock);
522 it->cache = &mrt->mfc6_unres_queue;
525 spin_lock_bh(&mfc_unres_lock);
526 if (!list_empty(it->cache))
527 return list_first_entry(it->cache, struct mfc6_cache, list);
530 spin_unlock_bh(&mfc_unres_lock);
536 static void ipmr_mfc_seq_stop(struct seq_file *seq, void *v)
538 struct ipmr_mfc_iter *it = seq->private;
539 struct mr6_table *mrt = it->mrt;
541 if (it->cache == &mrt->mfc6_unres_queue)
542 spin_unlock_bh(&mfc_unres_lock);
543 else if (it->cache == mrt->mfc6_cache_array)
544 read_unlock(&mrt_lock);
547 static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
551 if (v == SEQ_START_TOKEN) {
555 "Iif Pkts Bytes Wrong Oifs\n");
557 const struct mfc6_cache *mfc = v;
558 const struct ipmr_mfc_iter *it = seq->private;
559 struct mr6_table *mrt = it->mrt;
561 seq_printf(seq, "%pI6 %pI6 %-3hd",
562 &mfc->mf6c_mcastgrp, &mfc->mf6c_origin,
565 if (it->cache != &mrt->mfc6_unres_queue) {
566 seq_printf(seq, " %8lu %8lu %8lu",
568 mfc->mfc_un.res.bytes,
569 mfc->mfc_un.res.wrong_if);
570 for (n = mfc->mfc_un.res.minvif;
571 n < mfc->mfc_un.res.maxvif; n++) {
572 if (MIF_EXISTS(mrt, n) &&
573 mfc->mfc_un.res.ttls[n] < 255)
576 n, mfc->mfc_un.res.ttls[n]);
579 /* unresolved mfc_caches don't contain
580 * pkt, bytes and wrong_if values
582 seq_printf(seq, " %8lu %8lu %8lu", 0ul, 0ul, 0ul);
589 static const struct seq_operations ipmr_mfc_seq_ops = {
590 .start = ipmr_mfc_seq_start,
591 .next = ipmr_mfc_seq_next,
592 .stop = ipmr_mfc_seq_stop,
593 .show = ipmr_mfc_seq_show,
596 static int ipmr_mfc_open(struct inode *inode, struct file *file)
598 return seq_open_net(inode, file, &ipmr_mfc_seq_ops,
599 sizeof(struct ipmr_mfc_iter));
602 static const struct file_operations ip6mr_mfc_fops = {
603 .owner = THIS_MODULE,
604 .open = ipmr_mfc_open,
607 .release = seq_release_net,
611 #ifdef CONFIG_IPV6_PIMSM_V2
613 static int pim6_rcv(struct sk_buff *skb)
615 struct pimreghdr *pim;
616 struct ipv6hdr *encap;
617 struct net_device *reg_dev = NULL;
618 struct net *net = dev_net(skb->dev);
619 struct mr6_table *mrt;
621 .iif = skb->dev->ifindex,
626 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
629 pim = (struct pimreghdr *)skb_transport_header(skb);
630 if (pim->type != ((PIM_VERSION << 4) | PIM_REGISTER) ||
631 (pim->flags & PIM_NULL_REGISTER) ||
632 (csum_ipv6_magic(&ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr,
633 sizeof(*pim), IPPROTO_PIM,
634 csum_partial((void *)pim, sizeof(*pim), 0)) &&
635 csum_fold(skb_checksum(skb, 0, skb->len, 0))))
638 /* check if the inner packet is destined to mcast group */
639 encap = (struct ipv6hdr *)(skb_transport_header(skb) +
642 if (!ipv6_addr_is_multicast(&encap->daddr) ||
643 encap->payload_len == 0 ||
644 ntohs(encap->payload_len) + sizeof(*pim) > skb->len)
647 if (ip6mr_fib_lookup(net, &fl, &mrt) < 0)
649 reg_vif_num = mrt->mroute_reg_vif_num;
651 read_lock(&mrt_lock);
652 if (reg_vif_num >= 0)
653 reg_dev = mrt->vif6_table[reg_vif_num].dev;
656 read_unlock(&mrt_lock);
661 skb->mac_header = skb->network_header;
662 skb_pull(skb, (u8 *)encap - skb->data);
663 skb_reset_network_header(skb);
664 skb->protocol = htons(ETH_P_IPV6);
666 skb->pkt_type = PACKET_HOST;
668 skb_tunnel_rx(skb, reg_dev);
679 static const struct inet6_protocol pim6_protocol = {
683 /* Service routines creating virtual interfaces: PIMREG */
685 static netdev_tx_t reg_vif_xmit(struct sk_buff *skb,
686 struct net_device *dev)
688 struct net *net = dev_net(dev);
689 struct mr6_table *mrt;
697 err = ip6mr_fib_lookup(net, &fl, &mrt);
701 read_lock(&mrt_lock);
702 dev->stats.tx_bytes += skb->len;
703 dev->stats.tx_packets++;
704 ip6mr_cache_report(mrt, skb, mrt->mroute_reg_vif_num, MRT6MSG_WHOLEPKT);
705 read_unlock(&mrt_lock);
710 static const struct net_device_ops reg_vif_netdev_ops = {
711 .ndo_start_xmit = reg_vif_xmit,
714 static void reg_vif_setup(struct net_device *dev)
716 dev->type = ARPHRD_PIMREG;
717 dev->mtu = 1500 - sizeof(struct ipv6hdr) - 8;
718 dev->flags = IFF_NOARP;
719 dev->netdev_ops = ®_vif_netdev_ops;
720 dev->destructor = free_netdev;
721 dev->features |= NETIF_F_NETNS_LOCAL;
724 static struct net_device *ip6mr_reg_vif(struct net *net, struct mr6_table *mrt)
726 struct net_device *dev;
729 if (mrt->id == RT6_TABLE_DFLT)
730 sprintf(name, "pim6reg");
732 sprintf(name, "pim6reg%u", mrt->id);
734 dev = alloc_netdev(0, name, reg_vif_setup);
738 dev_net_set(dev, net);
740 if (register_netdevice(dev)) {
753 /* allow the register to be completed before unregistering. */
757 unregister_netdevice(dev);
766 static int mif6_delete(struct mr6_table *mrt, int vifi, struct list_head *head)
768 struct mif_device *v;
769 struct net_device *dev;
770 struct inet6_dev *in6_dev;
772 if (vifi < 0 || vifi >= mrt->maxvif)
773 return -EADDRNOTAVAIL;
775 v = &mrt->vif6_table[vifi];
777 write_lock_bh(&mrt_lock);
782 write_unlock_bh(&mrt_lock);
783 return -EADDRNOTAVAIL;
786 #ifdef CONFIG_IPV6_PIMSM_V2
787 if (vifi == mrt->mroute_reg_vif_num)
788 mrt->mroute_reg_vif_num = -1;
791 if (vifi + 1 == mrt->maxvif) {
793 for (tmp = vifi - 1; tmp >= 0; tmp--) {
794 if (MIF_EXISTS(mrt, tmp))
797 mrt->maxvif = tmp + 1;
800 write_unlock_bh(&mrt_lock);
802 dev_set_allmulti(dev, -1);
804 in6_dev = __in6_dev_get(dev);
806 in6_dev->cnf.mc_forwarding--;
808 if (v->flags & MIFF_REGISTER)
809 unregister_netdevice_queue(dev, head);
815 static inline void ip6mr_cache_free(struct mfc6_cache *c)
817 kmem_cache_free(mrt_cachep, c);
820 /* Destroy an unresolved cache entry, killing queued skbs
821 and reporting error to netlink readers.
824 static void ip6mr_destroy_unres(struct mr6_table *mrt, struct mfc6_cache *c)
826 struct net *net = read_pnet(&mrt->net);
829 atomic_dec(&mrt->cache_resolve_queue_len);
831 while((skb = skb_dequeue(&c->mfc_un.unres.unresolved)) != NULL) {
832 if (ipv6_hdr(skb)->version == 0) {
833 struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct ipv6hdr));
834 nlh->nlmsg_type = NLMSG_ERROR;
835 nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
836 skb_trim(skb, nlh->nlmsg_len);
837 ((struct nlmsgerr *)NLMSG_DATA(nlh))->error = -ETIMEDOUT;
838 rtnl_unicast(skb, net, NETLINK_CB(skb).pid);
847 /* Timer process for all the unresolved queue. */
849 static void ipmr_do_expire_process(struct mr6_table *mrt)
851 unsigned long now = jiffies;
852 unsigned long expires = 10 * HZ;
853 struct mfc6_cache *c, *next;
855 list_for_each_entry_safe(c, next, &mrt->mfc6_unres_queue, list) {
856 if (time_after(c->mfc_un.unres.expires, now)) {
858 unsigned long interval = c->mfc_un.unres.expires - now;
859 if (interval < expires)
865 ip6mr_destroy_unres(mrt, c);
868 if (!list_empty(&mrt->mfc6_unres_queue))
869 mod_timer(&mrt->ipmr_expire_timer, jiffies + expires);
872 static void ipmr_expire_process(unsigned long arg)
874 struct mr6_table *mrt = (struct mr6_table *)arg;
876 if (!spin_trylock(&mfc_unres_lock)) {
877 mod_timer(&mrt->ipmr_expire_timer, jiffies + 1);
881 if (!list_empty(&mrt->mfc6_unres_queue))
882 ipmr_do_expire_process(mrt);
884 spin_unlock(&mfc_unres_lock);
887 /* Fill oifs list. It is called under write locked mrt_lock. */
889 static void ip6mr_update_thresholds(struct mr6_table *mrt, struct mfc6_cache *cache,
894 cache->mfc_un.res.minvif = MAXMIFS;
895 cache->mfc_un.res.maxvif = 0;
896 memset(cache->mfc_un.res.ttls, 255, MAXMIFS);
898 for (vifi = 0; vifi < mrt->maxvif; vifi++) {
899 if (MIF_EXISTS(mrt, vifi) &&
900 ttls[vifi] && ttls[vifi] < 255) {
901 cache->mfc_un.res.ttls[vifi] = ttls[vifi];
902 if (cache->mfc_un.res.minvif > vifi)
903 cache->mfc_un.res.minvif = vifi;
904 if (cache->mfc_un.res.maxvif <= vifi)
905 cache->mfc_un.res.maxvif = vifi + 1;
910 static int mif6_add(struct net *net, struct mr6_table *mrt,
911 struct mif6ctl *vifc, int mrtsock)
913 int vifi = vifc->mif6c_mifi;
914 struct mif_device *v = &mrt->vif6_table[vifi];
915 struct net_device *dev;
916 struct inet6_dev *in6_dev;
920 if (MIF_EXISTS(mrt, vifi))
923 switch (vifc->mif6c_flags) {
924 #ifdef CONFIG_IPV6_PIMSM_V2
927 * Special Purpose VIF in PIM
928 * All the packets will be sent to the daemon
930 if (mrt->mroute_reg_vif_num >= 0)
932 dev = ip6mr_reg_vif(net, mrt);
935 err = dev_set_allmulti(dev, 1);
937 unregister_netdevice(dev);
944 dev = dev_get_by_index(net, vifc->mif6c_pifi);
946 return -EADDRNOTAVAIL;
947 err = dev_set_allmulti(dev, 1);
957 in6_dev = __in6_dev_get(dev);
959 in6_dev->cnf.mc_forwarding++;
962 * Fill in the VIF structures
964 v->rate_limit = vifc->vifc_rate_limit;
965 v->flags = vifc->mif6c_flags;
967 v->flags |= VIFF_STATIC;
968 v->threshold = vifc->vifc_threshold;
973 v->link = dev->ifindex;
974 if (v->flags & MIFF_REGISTER)
975 v->link = dev->iflink;
977 /* And finish update writing critical data */
978 write_lock_bh(&mrt_lock);
980 #ifdef CONFIG_IPV6_PIMSM_V2
981 if (v->flags & MIFF_REGISTER)
982 mrt->mroute_reg_vif_num = vifi;
984 if (vifi + 1 > mrt->maxvif)
985 mrt->maxvif = vifi + 1;
986 write_unlock_bh(&mrt_lock);
990 static struct mfc6_cache *ip6mr_cache_find(struct mr6_table *mrt,
991 struct in6_addr *origin,
992 struct in6_addr *mcastgrp)
994 int line = MFC6_HASH(mcastgrp, origin);
995 struct mfc6_cache *c;
997 list_for_each_entry(c, &mrt->mfc6_cache_array[line], list) {
998 if (ipv6_addr_equal(&c->mf6c_origin, origin) &&
999 ipv6_addr_equal(&c->mf6c_mcastgrp, mcastgrp))
1006 * Allocate a multicast cache entry
1008 static struct mfc6_cache *ip6mr_cache_alloc(void)
1010 struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
1013 c->mfc_un.res.minvif = MAXMIFS;
1017 static struct mfc6_cache *ip6mr_cache_alloc_unres(void)
1019 struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC);
1022 skb_queue_head_init(&c->mfc_un.unres.unresolved);
1023 c->mfc_un.unres.expires = jiffies + 10 * HZ;
1028 * A cache entry has gone into a resolved state from queued
1031 static void ip6mr_cache_resolve(struct net *net, struct mr6_table *mrt,
1032 struct mfc6_cache *uc, struct mfc6_cache *c)
1034 struct sk_buff *skb;
1037 * Play the pending entries through our router
1040 while((skb = __skb_dequeue(&uc->mfc_un.unres.unresolved))) {
1041 if (ipv6_hdr(skb)->version == 0) {
1042 struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct ipv6hdr));
1044 if (__ip6mr_fill_mroute(mrt, skb, c, NLMSG_DATA(nlh)) > 0) {
1045 nlh->nlmsg_len = skb_tail_pointer(skb) - (u8 *)nlh;
1047 nlh->nlmsg_type = NLMSG_ERROR;
1048 nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
1049 skb_trim(skb, nlh->nlmsg_len);
1050 ((struct nlmsgerr *)NLMSG_DATA(nlh))->error = -EMSGSIZE;
1052 rtnl_unicast(skb, net, NETLINK_CB(skb).pid);
1054 ip6_mr_forward(net, mrt, skb, c);
1059 * Bounce a cache query up to pim6sd. We could use netlink for this but pim6sd
1060 * expects the following bizarre scheme.
1062 * Called under mrt_lock.
1065 static int ip6mr_cache_report(struct mr6_table *mrt, struct sk_buff *pkt,
1066 mifi_t mifi, int assert)
1068 struct sk_buff *skb;
1069 struct mrt6msg *msg;
1072 #ifdef CONFIG_IPV6_PIMSM_V2
1073 if (assert == MRT6MSG_WHOLEPKT)
1074 skb = skb_realloc_headroom(pkt, -skb_network_offset(pkt)
1078 skb = alloc_skb(sizeof(struct ipv6hdr) + sizeof(*msg), GFP_ATOMIC);
1083 /* I suppose that internal messages
1084 * do not require checksums */
1086 skb->ip_summed = CHECKSUM_UNNECESSARY;
1088 #ifdef CONFIG_IPV6_PIMSM_V2
1089 if (assert == MRT6MSG_WHOLEPKT) {
1090 /* Ugly, but we have no choice with this interface.
1091 Duplicate old header, fix length etc.
1092 And all this only to mangle msg->im6_msgtype and
1093 to set msg->im6_mbz to "mbz" :-)
1095 skb_push(skb, -skb_network_offset(pkt));
1097 skb_push(skb, sizeof(*msg));
1098 skb_reset_transport_header(skb);
1099 msg = (struct mrt6msg *)skb_transport_header(skb);
1101 msg->im6_msgtype = MRT6MSG_WHOLEPKT;
1102 msg->im6_mif = mrt->mroute_reg_vif_num;
1104 ipv6_addr_copy(&msg->im6_src, &ipv6_hdr(pkt)->saddr);
1105 ipv6_addr_copy(&msg->im6_dst, &ipv6_hdr(pkt)->daddr);
1107 skb->ip_summed = CHECKSUM_UNNECESSARY;
1112 * Copy the IP header
1115 skb_put(skb, sizeof(struct ipv6hdr));
1116 skb_reset_network_header(skb);
1117 skb_copy_to_linear_data(skb, ipv6_hdr(pkt), sizeof(struct ipv6hdr));
1122 skb_put(skb, sizeof(*msg));
1123 skb_reset_transport_header(skb);
1124 msg = (struct mrt6msg *)skb_transport_header(skb);
1127 msg->im6_msgtype = assert;
1128 msg->im6_mif = mifi;
1130 ipv6_addr_copy(&msg->im6_src, &ipv6_hdr(pkt)->saddr);
1131 ipv6_addr_copy(&msg->im6_dst, &ipv6_hdr(pkt)->daddr);
1133 skb_dst_set(skb, dst_clone(skb_dst(pkt)));
1134 skb->ip_summed = CHECKSUM_UNNECESSARY;
1137 if (mrt->mroute6_sk == NULL) {
1143 * Deliver to user space multicast routing algorithms
1145 ret = sock_queue_rcv_skb(mrt->mroute6_sk, skb);
1147 if (net_ratelimit())
1148 printk(KERN_WARNING "mroute6: pending queue full, dropping entries.\n");
1156 * Queue a packet for resolution. It gets locked cache entry!
1160 ip6mr_cache_unresolved(struct mr6_table *mrt, mifi_t mifi, struct sk_buff *skb)
1164 struct mfc6_cache *c;
1166 spin_lock_bh(&mfc_unres_lock);
1167 list_for_each_entry(c, &mrt->mfc6_unres_queue, list) {
1168 if (ipv6_addr_equal(&c->mf6c_mcastgrp, &ipv6_hdr(skb)->daddr) &&
1169 ipv6_addr_equal(&c->mf6c_origin, &ipv6_hdr(skb)->saddr)) {
1177 * Create a new entry if allowable
1180 if (atomic_read(&mrt->cache_resolve_queue_len) >= 10 ||
1181 (c = ip6mr_cache_alloc_unres()) == NULL) {
1182 spin_unlock_bh(&mfc_unres_lock);
1189 * Fill in the new cache entry
1191 c->mf6c_parent = -1;
1192 c->mf6c_origin = ipv6_hdr(skb)->saddr;
1193 c->mf6c_mcastgrp = ipv6_hdr(skb)->daddr;
1196 * Reflect first query at pim6sd
1198 err = ip6mr_cache_report(mrt, skb, mifi, MRT6MSG_NOCACHE);
1200 /* If the report failed throw the cache entry
1203 spin_unlock_bh(&mfc_unres_lock);
1205 ip6mr_cache_free(c);
1210 atomic_inc(&mrt->cache_resolve_queue_len);
1211 list_add(&c->list, &mrt->mfc6_unres_queue);
1213 ipmr_do_expire_process(mrt);
1217 * See if we can append the packet
1219 if (c->mfc_un.unres.unresolved.qlen > 3) {
1223 skb_queue_tail(&c->mfc_un.unres.unresolved, skb);
1227 spin_unlock_bh(&mfc_unres_lock);
1232 * MFC6 cache manipulation by user space
1235 static int ip6mr_mfc_delete(struct mr6_table *mrt, struct mf6cctl *mfc)
1238 struct mfc6_cache *c, *next;
1240 line = MFC6_HASH(&mfc->mf6cc_mcastgrp.sin6_addr, &mfc->mf6cc_origin.sin6_addr);
1242 list_for_each_entry_safe(c, next, &mrt->mfc6_cache_array[line], list) {
1243 if (ipv6_addr_equal(&c->mf6c_origin, &mfc->mf6cc_origin.sin6_addr) &&
1244 ipv6_addr_equal(&c->mf6c_mcastgrp, &mfc->mf6cc_mcastgrp.sin6_addr)) {
1245 write_lock_bh(&mrt_lock);
1247 write_unlock_bh(&mrt_lock);
1249 ip6mr_cache_free(c);
1256 static int ip6mr_device_event(struct notifier_block *this,
1257 unsigned long event, void *ptr)
1259 struct net_device *dev = ptr;
1260 struct net *net = dev_net(dev);
1261 struct mr6_table *mrt;
1262 struct mif_device *v;
1266 if (event != NETDEV_UNREGISTER)
1269 ip6mr_for_each_table(mrt, net) {
1270 v = &mrt->vif6_table[0];
1271 for (ct = 0; ct < mrt->maxvif; ct++, v++) {
1273 mif6_delete(mrt, ct, &list);
1276 unregister_netdevice_many(&list);
1281 static struct notifier_block ip6_mr_notifier = {
1282 .notifier_call = ip6mr_device_event
1286 * Setup for IP multicast routing
1289 static int __net_init ip6mr_net_init(struct net *net)
1293 err = ip6mr_rules_init(net);
1297 #ifdef CONFIG_PROC_FS
1299 if (!proc_net_fops_create(net, "ip6_mr_vif", 0, &ip6mr_vif_fops))
1301 if (!proc_net_fops_create(net, "ip6_mr_cache", 0, &ip6mr_mfc_fops))
1302 goto proc_cache_fail;
1307 #ifdef CONFIG_PROC_FS
1309 proc_net_remove(net, "ip6_mr_vif");
1311 ip6mr_rules_exit(net);
1317 static void __net_exit ip6mr_net_exit(struct net *net)
1319 #ifdef CONFIG_PROC_FS
1320 proc_net_remove(net, "ip6_mr_cache");
1321 proc_net_remove(net, "ip6_mr_vif");
1323 ip6mr_rules_exit(net);
1326 static struct pernet_operations ip6mr_net_ops = {
1327 .init = ip6mr_net_init,
1328 .exit = ip6mr_net_exit,
1331 int __init ip6_mr_init(void)
1335 mrt_cachep = kmem_cache_create("ip6_mrt_cache",
1336 sizeof(struct mfc6_cache),
1337 0, SLAB_HWCACHE_ALIGN,
1342 err = register_pernet_subsys(&ip6mr_net_ops);
1344 goto reg_pernet_fail;
1346 err = register_netdevice_notifier(&ip6_mr_notifier);
1348 goto reg_notif_fail;
1349 #ifdef CONFIG_IPV6_PIMSM_V2
1350 if (inet6_add_protocol(&pim6_protocol, IPPROTO_PIM) < 0) {
1351 printk(KERN_ERR "ip6_mr_init: can't add PIM protocol\n");
1353 goto add_proto_fail;
1356 rtnl_register(RTNL_FAMILY_IP6MR, RTM_GETROUTE, NULL, ip6mr_rtm_dumproute);
1358 #ifdef CONFIG_IPV6_PIMSM_V2
1360 unregister_netdevice_notifier(&ip6_mr_notifier);
1363 unregister_pernet_subsys(&ip6mr_net_ops);
1365 kmem_cache_destroy(mrt_cachep);
1369 void ip6_mr_cleanup(void)
1371 unregister_netdevice_notifier(&ip6_mr_notifier);
1372 unregister_pernet_subsys(&ip6mr_net_ops);
1373 kmem_cache_destroy(mrt_cachep);
1376 static int ip6mr_mfc_add(struct net *net, struct mr6_table *mrt,
1377 struct mf6cctl *mfc, int mrtsock)
1381 struct mfc6_cache *uc, *c;
1382 unsigned char ttls[MAXMIFS];
1385 if (mfc->mf6cc_parent >= MAXMIFS)
1388 memset(ttls, 255, MAXMIFS);
1389 for (i = 0; i < MAXMIFS; i++) {
1390 if (IF_ISSET(i, &mfc->mf6cc_ifset))
1395 line = MFC6_HASH(&mfc->mf6cc_mcastgrp.sin6_addr, &mfc->mf6cc_origin.sin6_addr);
1397 list_for_each_entry(c, &mrt->mfc6_cache_array[line], list) {
1398 if (ipv6_addr_equal(&c->mf6c_origin, &mfc->mf6cc_origin.sin6_addr) &&
1399 ipv6_addr_equal(&c->mf6c_mcastgrp, &mfc->mf6cc_mcastgrp.sin6_addr)) {
1406 write_lock_bh(&mrt_lock);
1407 c->mf6c_parent = mfc->mf6cc_parent;
1408 ip6mr_update_thresholds(mrt, c, ttls);
1410 c->mfc_flags |= MFC_STATIC;
1411 write_unlock_bh(&mrt_lock);
1415 if (!ipv6_addr_is_multicast(&mfc->mf6cc_mcastgrp.sin6_addr))
1418 c = ip6mr_cache_alloc();
1422 c->mf6c_origin = mfc->mf6cc_origin.sin6_addr;
1423 c->mf6c_mcastgrp = mfc->mf6cc_mcastgrp.sin6_addr;
1424 c->mf6c_parent = mfc->mf6cc_parent;
1425 ip6mr_update_thresholds(mrt, c, ttls);
1427 c->mfc_flags |= MFC_STATIC;
1429 write_lock_bh(&mrt_lock);
1430 list_add(&c->list, &mrt->mfc6_cache_array[line]);
1431 write_unlock_bh(&mrt_lock);
1434 * Check to see if we resolved a queued list. If so we
1435 * need to send on the frames and tidy up.
1438 spin_lock_bh(&mfc_unres_lock);
1439 list_for_each_entry(uc, &mrt->mfc6_unres_queue, list) {
1440 if (ipv6_addr_equal(&uc->mf6c_origin, &c->mf6c_origin) &&
1441 ipv6_addr_equal(&uc->mf6c_mcastgrp, &c->mf6c_mcastgrp)) {
1442 list_del(&uc->list);
1443 atomic_dec(&mrt->cache_resolve_queue_len);
1448 if (list_empty(&mrt->mfc6_unres_queue))
1449 del_timer(&mrt->ipmr_expire_timer);
1450 spin_unlock_bh(&mfc_unres_lock);
1453 ip6mr_cache_resolve(net, mrt, uc, c);
1454 ip6mr_cache_free(uc);
1460 * Close the multicast socket, and clear the vif tables etc
1463 static void mroute_clean_tables(struct mr6_table *mrt)
1467 struct mfc6_cache *c, *next;
1470 * Shut down all active vif entries
1472 for (i = 0; i < mrt->maxvif; i++) {
1473 if (!(mrt->vif6_table[i].flags & VIFF_STATIC))
1474 mif6_delete(mrt, i, &list);
1476 unregister_netdevice_many(&list);
1481 for (i = 0; i < MFC6_LINES; i++) {
1482 list_for_each_entry_safe(c, next, &mrt->mfc6_cache_array[i], list) {
1483 if (c->mfc_flags & MFC_STATIC)
1485 write_lock_bh(&mrt_lock);
1487 write_unlock_bh(&mrt_lock);
1489 ip6mr_cache_free(c);
1493 if (atomic_read(&mrt->cache_resolve_queue_len) != 0) {
1494 spin_lock_bh(&mfc_unres_lock);
1495 list_for_each_entry_safe(c, next, &mrt->mfc6_unres_queue, list) {
1497 ip6mr_destroy_unres(mrt, c);
1499 spin_unlock_bh(&mfc_unres_lock);
1503 static int ip6mr_sk_init(struct mr6_table *mrt, struct sock *sk)
1506 struct net *net = sock_net(sk);
1509 write_lock_bh(&mrt_lock);
1510 if (likely(mrt->mroute6_sk == NULL)) {
1511 mrt->mroute6_sk = sk;
1512 net->ipv6.devconf_all->mc_forwarding++;
1516 write_unlock_bh(&mrt_lock);
1523 int ip6mr_sk_done(struct sock *sk)
1526 struct net *net = sock_net(sk);
1527 struct mr6_table *mrt;
1530 ip6mr_for_each_table(mrt, net) {
1531 if (sk == mrt->mroute6_sk) {
1532 write_lock_bh(&mrt_lock);
1533 mrt->mroute6_sk = NULL;
1534 net->ipv6.devconf_all->mc_forwarding--;
1535 write_unlock_bh(&mrt_lock);
1537 mroute_clean_tables(mrt);
1547 struct sock *mroute6_socket(struct net *net, struct sk_buff *skb)
1549 struct mr6_table *mrt;
1551 .iif = skb->skb_iif,
1552 .oif = skb->dev->ifindex,
1556 if (ip6mr_fib_lookup(net, &fl, &mrt) < 0)
1559 return mrt->mroute6_sk;
1563 * Socket options and virtual interface manipulation. The whole
1564 * virtual interface system is a complete heap, but unfortunately
1565 * that's how BSD mrouted happens to think. Maybe one day with a proper
1566 * MOSPF/PIM router set up we can clean this up.
1569 int ip6_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsigned int optlen)
1575 struct net *net = sock_net(sk);
1576 struct mr6_table *mrt;
1578 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1582 if (optname != MRT6_INIT) {
1583 if (sk != mrt->mroute6_sk && !capable(CAP_NET_ADMIN))
1589 if (sk->sk_type != SOCK_RAW ||
1590 inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
1592 if (optlen < sizeof(int))
1595 return ip6mr_sk_init(mrt, sk);
1598 return ip6mr_sk_done(sk);
1601 if (optlen < sizeof(vif))
1603 if (copy_from_user(&vif, optval, sizeof(vif)))
1605 if (vif.mif6c_mifi >= MAXMIFS)
1608 ret = mif6_add(net, mrt, &vif, sk == mrt->mroute6_sk);
1613 if (optlen < sizeof(mifi_t))
1615 if (copy_from_user(&mifi, optval, sizeof(mifi_t)))
1618 ret = mif6_delete(mrt, mifi, NULL);
1623 * Manipulate the forwarding caches. These live
1624 * in a sort of kernel/user symbiosis.
1628 if (optlen < sizeof(mfc))
1630 if (copy_from_user(&mfc, optval, sizeof(mfc)))
1633 if (optname == MRT6_DEL_MFC)
1634 ret = ip6mr_mfc_delete(mrt, &mfc);
1636 ret = ip6mr_mfc_add(net, mrt, &mfc, sk == mrt->mroute6_sk);
1641 * Control PIM assert (to activate pim will activate assert)
1646 if (get_user(v, (int __user *)optval))
1648 mrt->mroute_do_assert = !!v;
1652 #ifdef CONFIG_IPV6_PIMSM_V2
1656 if (get_user(v, (int __user *)optval))
1661 if (v != mrt->mroute_do_pim) {
1662 mrt->mroute_do_pim = v;
1663 mrt->mroute_do_assert = v;
1670 #ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
1675 if (optlen != sizeof(u32))
1677 if (get_user(v, (u32 __user *)optval))
1679 if (sk == mrt->mroute6_sk)
1684 if (!ip6mr_new_table(net, v))
1686 raw6_sk(sk)->ip6mr_table = v;
1692 * Spurious command, or MRT6_VERSION which you cannot
1696 return -ENOPROTOOPT;
1701 * Getsock opt support for the multicast routing system.
1704 int ip6_mroute_getsockopt(struct sock *sk, int optname, char __user *optval,
1709 struct net *net = sock_net(sk);
1710 struct mr6_table *mrt;
1712 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1720 #ifdef CONFIG_IPV6_PIMSM_V2
1722 val = mrt->mroute_do_pim;
1726 val = mrt->mroute_do_assert;
1729 return -ENOPROTOOPT;
1732 if (get_user(olr, optlen))
1735 olr = min_t(int, olr, sizeof(int));
1739 if (put_user(olr, optlen))
1741 if (copy_to_user(optval, &val, olr))
1747 * The IP multicast ioctl support routines.
1750 int ip6mr_ioctl(struct sock *sk, int cmd, void __user *arg)
1752 struct sioc_sg_req6 sr;
1753 struct sioc_mif_req6 vr;
1754 struct mif_device *vif;
1755 struct mfc6_cache *c;
1756 struct net *net = sock_net(sk);
1757 struct mr6_table *mrt;
1759 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1764 case SIOCGETMIFCNT_IN6:
1765 if (copy_from_user(&vr, arg, sizeof(vr)))
1767 if (vr.mifi >= mrt->maxvif)
1769 read_lock(&mrt_lock);
1770 vif = &mrt->vif6_table[vr.mifi];
1771 if (MIF_EXISTS(mrt, vr.mifi)) {
1772 vr.icount = vif->pkt_in;
1773 vr.ocount = vif->pkt_out;
1774 vr.ibytes = vif->bytes_in;
1775 vr.obytes = vif->bytes_out;
1776 read_unlock(&mrt_lock);
1778 if (copy_to_user(arg, &vr, sizeof(vr)))
1782 read_unlock(&mrt_lock);
1783 return -EADDRNOTAVAIL;
1784 case SIOCGETSGCNT_IN6:
1785 if (copy_from_user(&sr, arg, sizeof(sr)))
1788 read_lock(&mrt_lock);
1789 c = ip6mr_cache_find(mrt, &sr.src.sin6_addr, &sr.grp.sin6_addr);
1791 sr.pktcnt = c->mfc_un.res.pkt;
1792 sr.bytecnt = c->mfc_un.res.bytes;
1793 sr.wrong_if = c->mfc_un.res.wrong_if;
1794 read_unlock(&mrt_lock);
1796 if (copy_to_user(arg, &sr, sizeof(sr)))
1800 read_unlock(&mrt_lock);
1801 return -EADDRNOTAVAIL;
1803 return -ENOIOCTLCMD;
1807 #ifdef CONFIG_COMPAT
1808 struct compat_sioc_sg_req6 {
1809 struct sockaddr_in6 src;
1810 struct sockaddr_in6 grp;
1811 compat_ulong_t pktcnt;
1812 compat_ulong_t bytecnt;
1813 compat_ulong_t wrong_if;
1816 struct compat_sioc_mif_req6 {
1818 compat_ulong_t icount;
1819 compat_ulong_t ocount;
1820 compat_ulong_t ibytes;
1821 compat_ulong_t obytes;
1824 int ip6mr_compat_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
1826 struct compat_sioc_sg_req6 sr;
1827 struct compat_sioc_mif_req6 vr;
1828 struct mif_device *vif;
1829 struct mfc6_cache *c;
1830 struct net *net = sock_net(sk);
1831 struct mr6_table *mrt;
1833 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1838 case SIOCGETMIFCNT_IN6:
1839 if (copy_from_user(&vr, arg, sizeof(vr)))
1841 if (vr.mifi >= mrt->maxvif)
1843 read_lock(&mrt_lock);
1844 vif = &mrt->vif6_table[vr.mifi];
1845 if (MIF_EXISTS(mrt, vr.mifi)) {
1846 vr.icount = vif->pkt_in;
1847 vr.ocount = vif->pkt_out;
1848 vr.ibytes = vif->bytes_in;
1849 vr.obytes = vif->bytes_out;
1850 read_unlock(&mrt_lock);
1852 if (copy_to_user(arg, &vr, sizeof(vr)))
1856 read_unlock(&mrt_lock);
1857 return -EADDRNOTAVAIL;
1858 case SIOCGETSGCNT_IN6:
1859 if (copy_from_user(&sr, arg, sizeof(sr)))
1862 read_lock(&mrt_lock);
1863 c = ip6mr_cache_find(mrt, &sr.src.sin6_addr, &sr.grp.sin6_addr);
1865 sr.pktcnt = c->mfc_un.res.pkt;
1866 sr.bytecnt = c->mfc_un.res.bytes;
1867 sr.wrong_if = c->mfc_un.res.wrong_if;
1868 read_unlock(&mrt_lock);
1870 if (copy_to_user(arg, &sr, sizeof(sr)))
1874 read_unlock(&mrt_lock);
1875 return -EADDRNOTAVAIL;
1877 return -ENOIOCTLCMD;
1882 static inline int ip6mr_forward2_finish(struct sk_buff *skb)
1884 IP6_INC_STATS_BH(dev_net(skb_dst(skb)->dev), ip6_dst_idev(skb_dst(skb)),
1885 IPSTATS_MIB_OUTFORWDATAGRAMS);
1886 return dst_output(skb);
1890 * Processing handlers for ip6mr_forward
1893 static int ip6mr_forward2(struct net *net, struct mr6_table *mrt,
1894 struct sk_buff *skb, struct mfc6_cache *c, int vifi)
1896 struct ipv6hdr *ipv6h;
1897 struct mif_device *vif = &mrt->vif6_table[vifi];
1898 struct net_device *dev;
1899 struct dst_entry *dst;
1902 if (vif->dev == NULL)
1905 #ifdef CONFIG_IPV6_PIMSM_V2
1906 if (vif->flags & MIFF_REGISTER) {
1908 vif->bytes_out += skb->len;
1909 vif->dev->stats.tx_bytes += skb->len;
1910 vif->dev->stats.tx_packets++;
1911 ip6mr_cache_report(mrt, skb, vifi, MRT6MSG_WHOLEPKT);
1916 ipv6h = ipv6_hdr(skb);
1918 fl = (struct flowi) {
1920 .fl6_dst = ipv6h->daddr,
1923 dst = ip6_route_output(net, NULL, &fl);
1928 skb_dst_set(skb, dst);
1931 * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
1932 * not only before forwarding, but after forwarding on all output
1933 * interfaces. It is clear, if mrouter runs a multicasting
1934 * program, it should receive packets not depending to what interface
1935 * program is joined.
1936 * If we will not make it, the program will have to join on all
1937 * interfaces. On the other hand, multihoming host (or router, but
1938 * not mrouter) cannot join to more than one interface - it will
1939 * result in receiving multiple packets.
1944 vif->bytes_out += skb->len;
1946 /* We are about to write */
1947 /* XXX: extension headers? */
1948 if (skb_cow(skb, sizeof(*ipv6h) + LL_RESERVED_SPACE(dev)))
1951 ipv6h = ipv6_hdr(skb);
1954 IP6CB(skb)->flags |= IP6SKB_FORWARDED;
1956 return NF_HOOK(NFPROTO_IPV6, NF_INET_FORWARD, skb, skb->dev, dev,
1957 ip6mr_forward2_finish);
1964 static int ip6mr_find_vif(struct mr6_table *mrt, struct net_device *dev)
1968 for (ct = mrt->maxvif - 1; ct >= 0; ct--) {
1969 if (mrt->vif6_table[ct].dev == dev)
1975 static int ip6_mr_forward(struct net *net, struct mr6_table *mrt,
1976 struct sk_buff *skb, struct mfc6_cache *cache)
1981 vif = cache->mf6c_parent;
1982 cache->mfc_un.res.pkt++;
1983 cache->mfc_un.res.bytes += skb->len;
1986 * Wrong interface: drop packet and (maybe) send PIM assert.
1988 if (mrt->vif6_table[vif].dev != skb->dev) {
1991 cache->mfc_un.res.wrong_if++;
1992 true_vifi = ip6mr_find_vif(mrt, skb->dev);
1994 if (true_vifi >= 0 && mrt->mroute_do_assert &&
1995 /* pimsm uses asserts, when switching from RPT to SPT,
1996 so that we cannot check that packet arrived on an oif.
1997 It is bad, but otherwise we would need to move pretty
1998 large chunk of pimd to kernel. Ough... --ANK
2000 (mrt->mroute_do_pim ||
2001 cache->mfc_un.res.ttls[true_vifi] < 255) &&
2003 cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
2004 cache->mfc_un.res.last_assert = jiffies;
2005 ip6mr_cache_report(mrt, skb, true_vifi, MRT6MSG_WRONGMIF);
2010 mrt->vif6_table[vif].pkt_in++;
2011 mrt->vif6_table[vif].bytes_in += skb->len;
2016 for (ct = cache->mfc_un.res.maxvif - 1; ct >= cache->mfc_un.res.minvif; ct--) {
2017 if (ipv6_hdr(skb)->hop_limit > cache->mfc_un.res.ttls[ct]) {
2019 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
2021 ip6mr_forward2(net, mrt, skb2, cache, psend);
2027 ip6mr_forward2(net, mrt, skb, cache, psend);
2038 * Multicast packets for forwarding arrive here
2041 int ip6_mr_input(struct sk_buff *skb)
2043 struct mfc6_cache *cache;
2044 struct net *net = dev_net(skb->dev);
2045 struct mr6_table *mrt;
2047 .iif = skb->dev->ifindex,
2052 err = ip6mr_fib_lookup(net, &fl, &mrt);
2056 read_lock(&mrt_lock);
2057 cache = ip6mr_cache_find(mrt,
2058 &ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr);
2061 * No usable cache entry
2063 if (cache == NULL) {
2066 vif = ip6mr_find_vif(mrt, skb->dev);
2068 int err = ip6mr_cache_unresolved(mrt, vif, skb);
2069 read_unlock(&mrt_lock);
2073 read_unlock(&mrt_lock);
2078 ip6_mr_forward(net, mrt, skb, cache);
2080 read_unlock(&mrt_lock);
2086 static int __ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb,
2087 struct mfc6_cache *c, struct rtmsg *rtm)
2090 struct rtnexthop *nhp;
2091 u8 *b = skb_tail_pointer(skb);
2092 struct rtattr *mp_head;
2094 /* If cache is unresolved, don't try to parse IIF and OIF */
2095 if (c->mf6c_parent >= MAXMIFS)
2098 if (MIF_EXISTS(mrt, c->mf6c_parent))
2099 RTA_PUT(skb, RTA_IIF, 4, &mrt->vif6_table[c->mf6c_parent].dev->ifindex);
2101 mp_head = (struct rtattr *)skb_put(skb, RTA_LENGTH(0));
2103 for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
2104 if (MIF_EXISTS(mrt, ct) && c->mfc_un.res.ttls[ct] < 255) {
2105 if (skb_tailroom(skb) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp)) + 4))
2106 goto rtattr_failure;
2107 nhp = (struct rtnexthop *)skb_put(skb, RTA_ALIGN(sizeof(*nhp)));
2108 nhp->rtnh_flags = 0;
2109 nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
2110 nhp->rtnh_ifindex = mrt->vif6_table[ct].dev->ifindex;
2111 nhp->rtnh_len = sizeof(*nhp);
2114 mp_head->rta_type = RTA_MULTIPATH;
2115 mp_head->rta_len = skb_tail_pointer(skb) - (u8 *)mp_head;
2116 rtm->rtm_type = RTN_MULTICAST;
2124 int ip6mr_get_route(struct net *net,
2125 struct sk_buff *skb, struct rtmsg *rtm, int nowait)
2128 struct mr6_table *mrt;
2129 struct mfc6_cache *cache;
2130 struct rt6_info *rt = (struct rt6_info *)skb_dst(skb);
2132 mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
2136 read_lock(&mrt_lock);
2137 cache = ip6mr_cache_find(mrt, &rt->rt6i_src.addr, &rt->rt6i_dst.addr);
2140 struct sk_buff *skb2;
2141 struct ipv6hdr *iph;
2142 struct net_device *dev;
2146 read_unlock(&mrt_lock);
2151 if (dev == NULL || (vif = ip6mr_find_vif(mrt, dev)) < 0) {
2152 read_unlock(&mrt_lock);
2156 /* really correct? */
2157 skb2 = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC);
2159 read_unlock(&mrt_lock);
2163 skb_reset_transport_header(skb2);
2165 skb_put(skb2, sizeof(struct ipv6hdr));
2166 skb_reset_network_header(skb2);
2168 iph = ipv6_hdr(skb2);
2171 iph->flow_lbl[0] = 0;
2172 iph->flow_lbl[1] = 0;
2173 iph->flow_lbl[2] = 0;
2174 iph->payload_len = 0;
2175 iph->nexthdr = IPPROTO_NONE;
2177 ipv6_addr_copy(&iph->saddr, &rt->rt6i_src.addr);
2178 ipv6_addr_copy(&iph->daddr, &rt->rt6i_dst.addr);
2180 err = ip6mr_cache_unresolved(mrt, vif, skb2);
2181 read_unlock(&mrt_lock);
2186 if (!nowait && (rtm->rtm_flags&RTM_F_NOTIFY))
2187 cache->mfc_flags |= MFC_NOTIFY;
2189 err = __ip6mr_fill_mroute(mrt, skb, cache, rtm);
2190 read_unlock(&mrt_lock);
2194 static int ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb,
2195 u32 pid, u32 seq, struct mfc6_cache *c)
2197 struct nlmsghdr *nlh;
2200 nlh = nlmsg_put(skb, pid, seq, RTM_NEWROUTE, sizeof(*rtm), NLM_F_MULTI);
2204 rtm = nlmsg_data(nlh);
2205 rtm->rtm_family = RTNL_FAMILY_IPMR;
2206 rtm->rtm_dst_len = 128;
2207 rtm->rtm_src_len = 128;
2209 rtm->rtm_table = mrt->id;
2210 NLA_PUT_U32(skb, RTA_TABLE, mrt->id);
2211 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2212 rtm->rtm_protocol = RTPROT_UNSPEC;
2215 NLA_PUT(skb, RTA_SRC, 16, &c->mf6c_origin);
2216 NLA_PUT(skb, RTA_DST, 16, &c->mf6c_mcastgrp);
2218 if (__ip6mr_fill_mroute(mrt, skb, c, rtm) < 0)
2219 goto nla_put_failure;
2221 return nlmsg_end(skb, nlh);
2224 nlmsg_cancel(skb, nlh);
2228 static int ip6mr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb)
2230 struct net *net = sock_net(skb->sk);
2231 struct mr6_table *mrt;
2232 struct mfc6_cache *mfc;
2233 unsigned int t = 0, s_t;
2234 unsigned int h = 0, s_h;
2235 unsigned int e = 0, s_e;
2241 read_lock(&mrt_lock);
2242 ip6mr_for_each_table(mrt, net) {
2247 for (h = s_h; h < MFC6_LINES; h++) {
2248 list_for_each_entry(mfc, &mrt->mfc6_cache_array[h], list) {
2251 if (ip6mr_fill_mroute(mrt, skb,
2252 NETLINK_CB(cb->skb).pid,
2266 read_unlock(&mrt_lock);