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 <net/protocol.h>
37 #include <linux/skbuff.h>
40 #include <linux/notifier.h>
41 #include <linux/if_arp.h>
42 #include <net/checksum.h>
43 #include <net/netlink.h>
46 #include <net/ip6_route.h>
47 #include <linux/mroute6.h>
48 #include <linux/pim.h>
49 #include <net/addrconf.h>
50 #include <linux/netfilter_ipv6.h>
52 struct sock *mroute6_socket;
55 /* Big lock, protecting vif table, mrt cache and mroute socket state.
56 Note that the changes are semaphored via rtnl_lock.
59 static DEFINE_RWLOCK(mrt_lock);
62 * Multicast router control variables
65 static struct mif_device vif6_table[MAXMIFS]; /* Devices */
68 #define MIF_EXISTS(idx) (vif6_table[idx].dev != NULL)
70 static int mroute_do_assert; /* Set in PIM assert */
71 #ifdef CONFIG_IPV6_PIMSM_V2
72 static int mroute_do_pim;
74 #define mroute_do_pim 0
77 static struct mfc6_cache *mfc6_cache_array[MFC6_LINES]; /* Forwarding cache */
79 static struct mfc6_cache *mfc_unres_queue; /* Queue of unresolved entries */
80 static atomic_t cache_resolve_queue_len; /* Size of unresolved */
82 /* Special spinlock for queue of unresolved entries */
83 static DEFINE_SPINLOCK(mfc_unres_lock);
85 /* We return to original Alan's scheme. Hash table of resolved
86 entries is changed only in process context and protected
87 with weak lock mrt_lock. Queue of unresolved entries is protected
88 with strong spinlock mfc_unres_lock.
90 In this case data path is free of exclusive locks at all.
93 static struct kmem_cache *mrt_cachep __read_mostly;
95 static int ip6_mr_forward(struct sk_buff *skb, struct mfc6_cache *cache);
96 static int ip6mr_cache_report(struct sk_buff *pkt, mifi_t mifi, int assert);
97 static int ip6mr_fill_mroute(struct sk_buff *skb, struct mfc6_cache *c, struct rtmsg *rtm);
99 #ifdef CONFIG_IPV6_PIMSM_V2
100 static struct inet6_protocol pim6_protocol;
103 static struct timer_list ipmr_expire_timer;
106 #ifdef CONFIG_PROC_FS
108 struct ipmr_mfc_iter {
109 struct mfc6_cache **cache;
114 static struct mfc6_cache *ipmr_mfc_seq_idx(struct ipmr_mfc_iter *it, loff_t pos)
116 struct mfc6_cache *mfc;
118 it->cache = mfc6_cache_array;
119 read_lock(&mrt_lock);
120 for (it->ct = 0; it->ct < ARRAY_SIZE(mfc6_cache_array); it->ct++)
121 for (mfc = mfc6_cache_array[it->ct]; mfc; mfc = mfc->next)
124 read_unlock(&mrt_lock);
126 it->cache = &mfc_unres_queue;
127 spin_lock_bh(&mfc_unres_lock);
128 for (mfc = mfc_unres_queue; mfc; mfc = mfc->next)
131 spin_unlock_bh(&mfc_unres_lock);
141 * The /proc interfaces to multicast routing /proc/ip6_mr_cache /proc/ip6_mr_vif
144 struct ipmr_vif_iter {
148 static struct mif_device *ip6mr_vif_seq_idx(struct ipmr_vif_iter *iter,
151 for (iter->ct = 0; iter->ct < maxvif; ++iter->ct) {
152 if (!MIF_EXISTS(iter->ct))
155 return &vif6_table[iter->ct];
160 static void *ip6mr_vif_seq_start(struct seq_file *seq, loff_t *pos)
163 read_lock(&mrt_lock);
164 return (*pos ? ip6mr_vif_seq_idx(seq->private, *pos - 1)
168 static void *ip6mr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos)
170 struct ipmr_vif_iter *iter = seq->private;
173 if (v == SEQ_START_TOKEN)
174 return ip6mr_vif_seq_idx(iter, 0);
176 while (++iter->ct < maxvif) {
177 if (!MIF_EXISTS(iter->ct))
179 return &vif6_table[iter->ct];
184 static void ip6mr_vif_seq_stop(struct seq_file *seq, void *v)
187 read_unlock(&mrt_lock);
190 static int ip6mr_vif_seq_show(struct seq_file *seq, void *v)
192 if (v == SEQ_START_TOKEN) {
194 "Interface BytesIn PktsIn BytesOut PktsOut Flags\n");
196 const struct mif_device *vif = v;
197 const char *name = vif->dev ? vif->dev->name : "none";
200 "%2td %-10s %8ld %7ld %8ld %7ld %05X\n",
202 name, vif->bytes_in, vif->pkt_in,
203 vif->bytes_out, vif->pkt_out,
209 static struct seq_operations ip6mr_vif_seq_ops = {
210 .start = ip6mr_vif_seq_start,
211 .next = ip6mr_vif_seq_next,
212 .stop = ip6mr_vif_seq_stop,
213 .show = ip6mr_vif_seq_show,
216 static int ip6mr_vif_open(struct inode *inode, struct file *file)
218 return seq_open_private(file, &ip6mr_vif_seq_ops,
219 sizeof(struct ipmr_vif_iter));
222 static struct file_operations ip6mr_vif_fops = {
223 .owner = THIS_MODULE,
224 .open = ip6mr_vif_open,
227 .release = seq_release_private,
230 static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
232 return (*pos ? ipmr_mfc_seq_idx(seq->private, *pos - 1)
236 static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
238 struct mfc6_cache *mfc = v;
239 struct ipmr_mfc_iter *it = seq->private;
243 if (v == SEQ_START_TOKEN)
244 return ipmr_mfc_seq_idx(seq->private, 0);
249 if (it->cache == &mfc_unres_queue)
252 BUG_ON(it->cache != mfc6_cache_array);
254 while (++it->ct < ARRAY_SIZE(mfc6_cache_array)) {
255 mfc = mfc6_cache_array[it->ct];
260 /* exhausted cache_array, show unresolved */
261 read_unlock(&mrt_lock);
262 it->cache = &mfc_unres_queue;
265 spin_lock_bh(&mfc_unres_lock);
266 mfc = mfc_unres_queue;
271 spin_unlock_bh(&mfc_unres_lock);
277 static void ipmr_mfc_seq_stop(struct seq_file *seq, void *v)
279 struct ipmr_mfc_iter *it = seq->private;
281 if (it->cache == &mfc_unres_queue)
282 spin_unlock_bh(&mfc_unres_lock);
283 else if (it->cache == mfc6_cache_array)
284 read_unlock(&mrt_lock);
287 static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
291 if (v == SEQ_START_TOKEN) {
295 "Iif Pkts Bytes Wrong Oifs\n");
297 const struct mfc6_cache *mfc = v;
298 const struct ipmr_mfc_iter *it = seq->private;
300 seq_printf(seq, "%pI6 %pI6 %-3d %8ld %8ld %8ld",
301 &mfc->mf6c_mcastgrp, &mfc->mf6c_origin,
304 mfc->mfc_un.res.bytes,
305 mfc->mfc_un.res.wrong_if);
307 if (it->cache != &mfc_unres_queue) {
308 for (n = mfc->mfc_un.res.minvif;
309 n < mfc->mfc_un.res.maxvif; n++) {
311 mfc->mfc_un.res.ttls[n] < 255)
314 n, mfc->mfc_un.res.ttls[n]);
322 static struct seq_operations ipmr_mfc_seq_ops = {
323 .start = ipmr_mfc_seq_start,
324 .next = ipmr_mfc_seq_next,
325 .stop = ipmr_mfc_seq_stop,
326 .show = ipmr_mfc_seq_show,
329 static int ipmr_mfc_open(struct inode *inode, struct file *file)
331 return seq_open_private(file, &ipmr_mfc_seq_ops,
332 sizeof(struct ipmr_mfc_iter));
335 static struct file_operations ip6mr_mfc_fops = {
336 .owner = THIS_MODULE,
337 .open = ipmr_mfc_open,
340 .release = seq_release_private,
344 #ifdef CONFIG_IPV6_PIMSM_V2
345 static int reg_vif_num = -1;
347 static int pim6_rcv(struct sk_buff *skb)
349 struct pimreghdr *pim;
350 struct ipv6hdr *encap;
351 struct net_device *reg_dev = NULL;
353 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
356 pim = (struct pimreghdr *)skb_transport_header(skb);
357 if (pim->type != ((PIM_VERSION << 4) | PIM_REGISTER) ||
358 (pim->flags & PIM_NULL_REGISTER) ||
359 (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
360 csum_fold(skb_checksum(skb, 0, skb->len, 0))))
363 /* check if the inner packet is destined to mcast group */
364 encap = (struct ipv6hdr *)(skb_transport_header(skb) +
367 if (!ipv6_addr_is_multicast(&encap->daddr) ||
368 encap->payload_len == 0 ||
369 ntohs(encap->payload_len) + sizeof(*pim) > skb->len)
372 read_lock(&mrt_lock);
373 if (reg_vif_num >= 0)
374 reg_dev = vif6_table[reg_vif_num].dev;
377 read_unlock(&mrt_lock);
382 skb->mac_header = skb->network_header;
383 skb_pull(skb, (u8 *)encap - skb->data);
384 skb_reset_network_header(skb);
386 skb->protocol = htons(ETH_P_IP);
388 skb->pkt_type = PACKET_HOST;
389 dst_release(skb->dst);
390 reg_dev->stats.rx_bytes += skb->len;
391 reg_dev->stats.rx_packets++;
402 static struct inet6_protocol pim6_protocol = {
406 /* Service routines creating virtual interfaces: PIMREG */
408 static int reg_vif_xmit(struct sk_buff *skb, struct net_device *dev)
410 read_lock(&mrt_lock);
411 dev->stats.tx_bytes += skb->len;
412 dev->stats.tx_packets++;
413 ip6mr_cache_report(skb, reg_vif_num, MRT6MSG_WHOLEPKT);
414 read_unlock(&mrt_lock);
419 static const struct net_device_ops reg_vif_netdev_ops = {
420 .ndo_start_xmit = reg_vif_xmit,
423 static void reg_vif_setup(struct net_device *dev)
425 dev->type = ARPHRD_PIMREG;
426 dev->mtu = 1500 - sizeof(struct ipv6hdr) - 8;
427 dev->flags = IFF_NOARP;
428 dev->netdev_ops = ®_vif_netdev_ops;
429 dev->destructor = free_netdev;
432 static struct net_device *ip6mr_reg_vif(void)
434 struct net_device *dev;
436 dev = alloc_netdev(0, "pim6reg", reg_vif_setup);
440 if (register_netdevice(dev)) {
453 /* allow the register to be completed before unregistering. */
457 unregister_netdevice(dev);
466 static int mif6_delete(int vifi)
468 struct mif_device *v;
469 struct net_device *dev;
470 if (vifi < 0 || vifi >= maxvif)
471 return -EADDRNOTAVAIL;
473 v = &vif6_table[vifi];
475 write_lock_bh(&mrt_lock);
480 write_unlock_bh(&mrt_lock);
481 return -EADDRNOTAVAIL;
484 #ifdef CONFIG_IPV6_PIMSM_V2
485 if (vifi == reg_vif_num)
489 if (vifi + 1 == maxvif) {
491 for (tmp = vifi - 1; tmp >= 0; tmp--) {
498 write_unlock_bh(&mrt_lock);
500 dev_set_allmulti(dev, -1);
502 if (v->flags & MIFF_REGISTER)
503 unregister_netdevice(dev);
509 /* Destroy an unresolved cache entry, killing queued skbs
510 and reporting error to netlink readers.
513 static void ip6mr_destroy_unres(struct mfc6_cache *c)
517 atomic_dec(&cache_resolve_queue_len);
519 while((skb = skb_dequeue(&c->mfc_un.unres.unresolved)) != NULL) {
520 if (ipv6_hdr(skb)->version == 0) {
521 struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct ipv6hdr));
522 nlh->nlmsg_type = NLMSG_ERROR;
523 nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
524 skb_trim(skb, nlh->nlmsg_len);
525 ((struct nlmsgerr *)NLMSG_DATA(nlh))->error = -ETIMEDOUT;
526 rtnl_unicast(skb, &init_net, NETLINK_CB(skb).pid);
531 kmem_cache_free(mrt_cachep, c);
535 /* Single timer process for all the unresolved queue. */
537 static void ipmr_do_expire_process(unsigned long dummy)
539 unsigned long now = jiffies;
540 unsigned long expires = 10 * HZ;
541 struct mfc6_cache *c, **cp;
543 cp = &mfc_unres_queue;
545 while ((c = *cp) != NULL) {
546 if (time_after(c->mfc_un.unres.expires, now)) {
548 unsigned long interval = c->mfc_un.unres.expires - now;
549 if (interval < expires)
556 ip6mr_destroy_unres(c);
559 if (atomic_read(&cache_resolve_queue_len))
560 mod_timer(&ipmr_expire_timer, jiffies + expires);
563 static void ipmr_expire_process(unsigned long dummy)
565 if (!spin_trylock(&mfc_unres_lock)) {
566 mod_timer(&ipmr_expire_timer, jiffies + 1);
570 if (atomic_read(&cache_resolve_queue_len))
571 ipmr_do_expire_process(dummy);
573 spin_unlock(&mfc_unres_lock);
576 /* Fill oifs list. It is called under write locked mrt_lock. */
578 static void ip6mr_update_thresholds(struct mfc6_cache *cache, unsigned char *ttls)
582 cache->mfc_un.res.minvif = MAXMIFS;
583 cache->mfc_un.res.maxvif = 0;
584 memset(cache->mfc_un.res.ttls, 255, MAXMIFS);
586 for (vifi = 0; vifi < maxvif; vifi++) {
587 if (MIF_EXISTS(vifi) && ttls[vifi] && ttls[vifi] < 255) {
588 cache->mfc_un.res.ttls[vifi] = ttls[vifi];
589 if (cache->mfc_un.res.minvif > vifi)
590 cache->mfc_un.res.minvif = vifi;
591 if (cache->mfc_un.res.maxvif <= vifi)
592 cache->mfc_un.res.maxvif = vifi + 1;
597 static int mif6_add(struct mif6ctl *vifc, int mrtsock)
599 int vifi = vifc->mif6c_mifi;
600 struct mif_device *v = &vif6_table[vifi];
601 struct net_device *dev;
605 if (MIF_EXISTS(vifi))
608 switch (vifc->mif6c_flags) {
609 #ifdef CONFIG_IPV6_PIMSM_V2
612 * Special Purpose VIF in PIM
613 * All the packets will be sent to the daemon
615 if (reg_vif_num >= 0)
617 dev = ip6mr_reg_vif();
620 err = dev_set_allmulti(dev, 1);
622 unregister_netdevice(dev);
629 dev = dev_get_by_index(&init_net, vifc->mif6c_pifi);
631 return -EADDRNOTAVAIL;
632 err = dev_set_allmulti(dev, 1);
643 * Fill in the VIF structures
645 v->rate_limit = vifc->vifc_rate_limit;
646 v->flags = vifc->mif6c_flags;
648 v->flags |= VIFF_STATIC;
649 v->threshold = vifc->vifc_threshold;
654 v->link = dev->ifindex;
655 if (v->flags & MIFF_REGISTER)
656 v->link = dev->iflink;
658 /* And finish update writing critical data */
659 write_lock_bh(&mrt_lock);
661 #ifdef CONFIG_IPV6_PIMSM_V2
662 if (v->flags & MIFF_REGISTER)
665 if (vifi + 1 > maxvif)
667 write_unlock_bh(&mrt_lock);
671 static struct mfc6_cache *ip6mr_cache_find(struct in6_addr *origin, struct in6_addr *mcastgrp)
673 int line = MFC6_HASH(mcastgrp, origin);
674 struct mfc6_cache *c;
676 for (c = mfc6_cache_array[line]; c; c = c->next) {
677 if (ipv6_addr_equal(&c->mf6c_origin, origin) &&
678 ipv6_addr_equal(&c->mf6c_mcastgrp, mcastgrp))
685 * Allocate a multicast cache entry
687 static struct mfc6_cache *ip6mr_cache_alloc(void)
689 struct mfc6_cache *c = kmem_cache_alloc(mrt_cachep, GFP_KERNEL);
692 memset(c, 0, sizeof(*c));
693 c->mfc_un.res.minvif = MAXMIFS;
697 static struct mfc6_cache *ip6mr_cache_alloc_unres(void)
699 struct mfc6_cache *c = kmem_cache_alloc(mrt_cachep, GFP_ATOMIC);
702 memset(c, 0, sizeof(*c));
703 skb_queue_head_init(&c->mfc_un.unres.unresolved);
704 c->mfc_un.unres.expires = jiffies + 10 * HZ;
709 * A cache entry has gone into a resolved state from queued
712 static void ip6mr_cache_resolve(struct mfc6_cache *uc, struct mfc6_cache *c)
717 * Play the pending entries through our router
720 while((skb = __skb_dequeue(&uc->mfc_un.unres.unresolved))) {
721 if (ipv6_hdr(skb)->version == 0) {
723 struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct ipv6hdr));
725 if (ip6mr_fill_mroute(skb, c, NLMSG_DATA(nlh)) > 0) {
726 nlh->nlmsg_len = skb_tail_pointer(skb) - (u8 *)nlh;
728 nlh->nlmsg_type = NLMSG_ERROR;
729 nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
730 skb_trim(skb, nlh->nlmsg_len);
731 ((struct nlmsgerr *)NLMSG_DATA(nlh))->error = -EMSGSIZE;
733 err = rtnl_unicast(skb, &init_net, NETLINK_CB(skb).pid);
735 ip6_mr_forward(skb, c);
740 * Bounce a cache query up to pim6sd. We could use netlink for this but pim6sd
741 * expects the following bizarre scheme.
743 * Called under mrt_lock.
746 static int ip6mr_cache_report(struct sk_buff *pkt, mifi_t mifi, int assert)
752 #ifdef CONFIG_IPV6_PIMSM_V2
753 if (assert == MRT6MSG_WHOLEPKT)
754 skb = skb_realloc_headroom(pkt, -skb_network_offset(pkt)
758 skb = alloc_skb(sizeof(struct ipv6hdr) + sizeof(*msg), GFP_ATOMIC);
763 /* I suppose that internal messages
764 * do not require checksums */
766 skb->ip_summed = CHECKSUM_UNNECESSARY;
768 #ifdef CONFIG_IPV6_PIMSM_V2
769 if (assert == MRT6MSG_WHOLEPKT) {
770 /* Ugly, but we have no choice with this interface.
771 Duplicate old header, fix length etc.
772 And all this only to mangle msg->im6_msgtype and
773 to set msg->im6_mbz to "mbz" :-)
775 skb_push(skb, -skb_network_offset(pkt));
777 skb_push(skb, sizeof(*msg));
778 skb_reset_transport_header(skb);
779 msg = (struct mrt6msg *)skb_transport_header(skb);
781 msg->im6_msgtype = MRT6MSG_WHOLEPKT;
782 msg->im6_mif = reg_vif_num;
784 ipv6_addr_copy(&msg->im6_src, &ipv6_hdr(pkt)->saddr);
785 ipv6_addr_copy(&msg->im6_dst, &ipv6_hdr(pkt)->daddr);
787 skb->ip_summed = CHECKSUM_UNNECESSARY;
795 skb_put(skb, sizeof(struct ipv6hdr));
796 skb_reset_network_header(skb);
797 skb_copy_to_linear_data(skb, ipv6_hdr(pkt), sizeof(struct ipv6hdr));
802 skb_put(skb, sizeof(*msg));
803 skb_reset_transport_header(skb);
804 msg = (struct mrt6msg *)skb_transport_header(skb);
807 msg->im6_msgtype = assert;
810 ipv6_addr_copy(&msg->im6_src, &ipv6_hdr(pkt)->saddr);
811 ipv6_addr_copy(&msg->im6_dst, &ipv6_hdr(pkt)->daddr);
813 skb->dst = dst_clone(pkt->dst);
814 skb->ip_summed = CHECKSUM_UNNECESSARY;
816 skb_pull(skb, sizeof(struct ipv6hdr));
819 if (mroute6_socket == NULL) {
825 * Deliver to user space multicast routing algorithms
827 if ((ret = sock_queue_rcv_skb(mroute6_socket, skb)) < 0) {
829 printk(KERN_WARNING "mroute6: pending queue full, dropping entries.\n");
837 * Queue a packet for resolution. It gets locked cache entry!
841 ip6mr_cache_unresolved(mifi_t mifi, struct sk_buff *skb)
844 struct mfc6_cache *c;
846 spin_lock_bh(&mfc_unres_lock);
847 for (c = mfc_unres_queue; c; c = c->next) {
848 if (ipv6_addr_equal(&c->mf6c_mcastgrp, &ipv6_hdr(skb)->daddr) &&
849 ipv6_addr_equal(&c->mf6c_origin, &ipv6_hdr(skb)->saddr))
855 * Create a new entry if allowable
858 if (atomic_read(&cache_resolve_queue_len) >= 10 ||
859 (c = ip6mr_cache_alloc_unres()) == NULL) {
860 spin_unlock_bh(&mfc_unres_lock);
867 * Fill in the new cache entry
870 c->mf6c_origin = ipv6_hdr(skb)->saddr;
871 c->mf6c_mcastgrp = ipv6_hdr(skb)->daddr;
874 * Reflect first query at pim6sd
876 if ((err = ip6mr_cache_report(skb, mifi, MRT6MSG_NOCACHE)) < 0) {
877 /* If the report failed throw the cache entry
880 spin_unlock_bh(&mfc_unres_lock);
882 kmem_cache_free(mrt_cachep, c);
887 atomic_inc(&cache_resolve_queue_len);
888 c->next = mfc_unres_queue;
891 ipmr_do_expire_process(1);
895 * See if we can append the packet
897 if (c->mfc_un.unres.unresolved.qlen > 3) {
901 skb_queue_tail(&c->mfc_un.unres.unresolved, skb);
905 spin_unlock_bh(&mfc_unres_lock);
910 * MFC6 cache manipulation by user space
913 static int ip6mr_mfc_delete(struct mf6cctl *mfc)
916 struct mfc6_cache *c, **cp;
918 line = MFC6_HASH(&mfc->mf6cc_mcastgrp.sin6_addr, &mfc->mf6cc_origin.sin6_addr);
920 for (cp = &mfc6_cache_array[line]; (c = *cp) != NULL; cp = &c->next) {
921 if (ipv6_addr_equal(&c->mf6c_origin, &mfc->mf6cc_origin.sin6_addr) &&
922 ipv6_addr_equal(&c->mf6c_mcastgrp, &mfc->mf6cc_mcastgrp.sin6_addr)) {
923 write_lock_bh(&mrt_lock);
925 write_unlock_bh(&mrt_lock);
927 kmem_cache_free(mrt_cachep, c);
934 static int ip6mr_device_event(struct notifier_block *this,
935 unsigned long event, void *ptr)
937 struct net_device *dev = ptr;
938 struct mif_device *v;
941 if (!net_eq(dev_net(dev), &init_net))
944 if (event != NETDEV_UNREGISTER)
948 for (ct = 0; ct < maxvif; ct++, v++) {
955 static struct notifier_block ip6_mr_notifier = {
956 .notifier_call = ip6mr_device_event
960 * Setup for IP multicast routing
963 int __init ip6_mr_init(void)
967 mrt_cachep = kmem_cache_create("ip6_mrt_cache",
968 sizeof(struct mfc6_cache),
969 0, SLAB_HWCACHE_ALIGN,
974 setup_timer(&ipmr_expire_timer, ipmr_expire_process, 0);
975 err = register_netdevice_notifier(&ip6_mr_notifier);
978 #ifdef CONFIG_PROC_FS
980 if (!proc_net_fops_create(&init_net, "ip6_mr_vif", 0, &ip6mr_vif_fops))
982 if (!proc_net_fops_create(&init_net, "ip6_mr_cache",
984 goto proc_cache_fail;
987 #ifdef CONFIG_PROC_FS
989 proc_net_remove(&init_net, "ip6_mr_vif");
991 unregister_netdevice_notifier(&ip6_mr_notifier);
994 del_timer(&ipmr_expire_timer);
995 kmem_cache_destroy(mrt_cachep);
999 void ip6_mr_cleanup(void)
1001 #ifdef CONFIG_PROC_FS
1002 proc_net_remove(&init_net, "ip6_mr_cache");
1003 proc_net_remove(&init_net, "ip6_mr_vif");
1005 unregister_netdevice_notifier(&ip6_mr_notifier);
1006 del_timer(&ipmr_expire_timer);
1007 kmem_cache_destroy(mrt_cachep);
1010 static int ip6mr_mfc_add(struct mf6cctl *mfc, int mrtsock)
1013 struct mfc6_cache *uc, *c, **cp;
1014 unsigned char ttls[MAXMIFS];
1017 memset(ttls, 255, MAXMIFS);
1018 for (i = 0; i < MAXMIFS; i++) {
1019 if (IF_ISSET(i, &mfc->mf6cc_ifset))
1024 line = MFC6_HASH(&mfc->mf6cc_mcastgrp.sin6_addr, &mfc->mf6cc_origin.sin6_addr);
1026 for (cp = &mfc6_cache_array[line]; (c = *cp) != NULL; cp = &c->next) {
1027 if (ipv6_addr_equal(&c->mf6c_origin, &mfc->mf6cc_origin.sin6_addr) &&
1028 ipv6_addr_equal(&c->mf6c_mcastgrp, &mfc->mf6cc_mcastgrp.sin6_addr))
1033 write_lock_bh(&mrt_lock);
1034 c->mf6c_parent = mfc->mf6cc_parent;
1035 ip6mr_update_thresholds(c, ttls);
1037 c->mfc_flags |= MFC_STATIC;
1038 write_unlock_bh(&mrt_lock);
1042 if (!ipv6_addr_is_multicast(&mfc->mf6cc_mcastgrp.sin6_addr))
1045 c = ip6mr_cache_alloc();
1049 c->mf6c_origin = mfc->mf6cc_origin.sin6_addr;
1050 c->mf6c_mcastgrp = mfc->mf6cc_mcastgrp.sin6_addr;
1051 c->mf6c_parent = mfc->mf6cc_parent;
1052 ip6mr_update_thresholds(c, ttls);
1054 c->mfc_flags |= MFC_STATIC;
1056 write_lock_bh(&mrt_lock);
1057 c->next = mfc6_cache_array[line];
1058 mfc6_cache_array[line] = c;
1059 write_unlock_bh(&mrt_lock);
1062 * Check to see if we resolved a queued list. If so we
1063 * need to send on the frames and tidy up.
1065 spin_lock_bh(&mfc_unres_lock);
1066 for (cp = &mfc_unres_queue; (uc = *cp) != NULL;
1068 if (ipv6_addr_equal(&uc->mf6c_origin, &c->mf6c_origin) &&
1069 ipv6_addr_equal(&uc->mf6c_mcastgrp, &c->mf6c_mcastgrp)) {
1071 if (atomic_dec_and_test(&cache_resolve_queue_len))
1072 del_timer(&ipmr_expire_timer);
1076 spin_unlock_bh(&mfc_unres_lock);
1079 ip6mr_cache_resolve(uc, c);
1080 kmem_cache_free(mrt_cachep, uc);
1086 * Close the multicast socket, and clear the vif tables etc
1089 static void mroute_clean_tables(struct sock *sk)
1094 * Shut down all active vif entries
1096 for (i = 0; i < maxvif; i++) {
1097 if (!(vif6_table[i].flags & VIFF_STATIC))
1104 for (i = 0; i < ARRAY_SIZE(mfc6_cache_array); i++) {
1105 struct mfc6_cache *c, **cp;
1107 cp = &mfc6_cache_array[i];
1108 while ((c = *cp) != NULL) {
1109 if (c->mfc_flags & MFC_STATIC) {
1113 write_lock_bh(&mrt_lock);
1115 write_unlock_bh(&mrt_lock);
1117 kmem_cache_free(mrt_cachep, c);
1121 if (atomic_read(&cache_resolve_queue_len) != 0) {
1122 struct mfc6_cache *c;
1124 spin_lock_bh(&mfc_unres_lock);
1125 while (mfc_unres_queue != NULL) {
1126 c = mfc_unres_queue;
1127 mfc_unres_queue = c->next;
1128 spin_unlock_bh(&mfc_unres_lock);
1130 ip6mr_destroy_unres(c);
1132 spin_lock_bh(&mfc_unres_lock);
1134 spin_unlock_bh(&mfc_unres_lock);
1138 static int ip6mr_sk_init(struct sock *sk)
1143 write_lock_bh(&mrt_lock);
1144 if (likely(mroute6_socket == NULL))
1145 mroute6_socket = sk;
1148 write_unlock_bh(&mrt_lock);
1155 int ip6mr_sk_done(struct sock *sk)
1160 if (sk == mroute6_socket) {
1161 write_lock_bh(&mrt_lock);
1162 mroute6_socket = NULL;
1163 write_unlock_bh(&mrt_lock);
1165 mroute_clean_tables(sk);
1174 * Socket options and virtual interface manipulation. The whole
1175 * virtual interface system is a complete heap, but unfortunately
1176 * that's how BSD mrouted happens to think. Maybe one day with a proper
1177 * MOSPF/PIM router set up we can clean this up.
1180 int ip6_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, int optlen)
1187 if (optname != MRT6_INIT) {
1188 if (sk != mroute6_socket && !capable(CAP_NET_ADMIN))
1194 if (sk->sk_type != SOCK_RAW ||
1195 inet_sk(sk)->num != IPPROTO_ICMPV6)
1197 if (optlen < sizeof(int))
1200 return ip6mr_sk_init(sk);
1203 return ip6mr_sk_done(sk);
1206 if (optlen < sizeof(vif))
1208 if (copy_from_user(&vif, optval, sizeof(vif)))
1210 if (vif.mif6c_mifi >= MAXMIFS)
1213 ret = mif6_add(&vif, sk == mroute6_socket);
1218 if (optlen < sizeof(mifi_t))
1220 if (copy_from_user(&mifi, optval, sizeof(mifi_t)))
1223 ret = mif6_delete(mifi);
1228 * Manipulate the forwarding caches. These live
1229 * in a sort of kernel/user symbiosis.
1233 if (optlen < sizeof(mfc))
1235 if (copy_from_user(&mfc, optval, sizeof(mfc)))
1238 if (optname == MRT6_DEL_MFC)
1239 ret = ip6mr_mfc_delete(&mfc);
1241 ret = ip6mr_mfc_add(&mfc, sk == mroute6_socket);
1246 * Control PIM assert (to activate pim will activate assert)
1251 if (get_user(v, (int __user *)optval))
1253 mroute_do_assert = !!v;
1257 #ifdef CONFIG_IPV6_PIMSM_V2
1261 if (get_user(v, (int __user *)optval))
1266 if (v != mroute_do_pim) {
1268 mroute_do_assert = v;
1270 ret = inet6_add_protocol(&pim6_protocol,
1273 ret = inet6_del_protocol(&pim6_protocol,
1284 * Spurious command, or MRT6_VERSION which you cannot
1288 return -ENOPROTOOPT;
1293 * Getsock opt support for the multicast routing system.
1296 int ip6_mroute_getsockopt(struct sock *sk, int optname, char __user *optval,
1306 #ifdef CONFIG_IPV6_PIMSM_V2
1308 val = mroute_do_pim;
1312 val = mroute_do_assert;
1315 return -ENOPROTOOPT;
1318 if (get_user(olr, optlen))
1321 olr = min_t(int, olr, sizeof(int));
1325 if (put_user(olr, optlen))
1327 if (copy_to_user(optval, &val, olr))
1333 * The IP multicast ioctl support routines.
1336 int ip6mr_ioctl(struct sock *sk, int cmd, void __user *arg)
1338 struct sioc_sg_req6 sr;
1339 struct sioc_mif_req6 vr;
1340 struct mif_device *vif;
1341 struct mfc6_cache *c;
1344 case SIOCGETMIFCNT_IN6:
1345 if (copy_from_user(&vr, arg, sizeof(vr)))
1347 if (vr.mifi >= maxvif)
1349 read_lock(&mrt_lock);
1350 vif = &vif6_table[vr.mifi];
1351 if (MIF_EXISTS(vr.mifi)) {
1352 vr.icount = vif->pkt_in;
1353 vr.ocount = vif->pkt_out;
1354 vr.ibytes = vif->bytes_in;
1355 vr.obytes = vif->bytes_out;
1356 read_unlock(&mrt_lock);
1358 if (copy_to_user(arg, &vr, sizeof(vr)))
1362 read_unlock(&mrt_lock);
1363 return -EADDRNOTAVAIL;
1364 case SIOCGETSGCNT_IN6:
1365 if (copy_from_user(&sr, arg, sizeof(sr)))
1368 read_lock(&mrt_lock);
1369 c = ip6mr_cache_find(&sr.src.sin6_addr, &sr.grp.sin6_addr);
1371 sr.pktcnt = c->mfc_un.res.pkt;
1372 sr.bytecnt = c->mfc_un.res.bytes;
1373 sr.wrong_if = c->mfc_un.res.wrong_if;
1374 read_unlock(&mrt_lock);
1376 if (copy_to_user(arg, &sr, sizeof(sr)))
1380 read_unlock(&mrt_lock);
1381 return -EADDRNOTAVAIL;
1383 return -ENOIOCTLCMD;
1388 static inline int ip6mr_forward2_finish(struct sk_buff *skb)
1390 IP6_INC_STATS_BH(dev_net(skb->dst->dev), ip6_dst_idev(skb->dst),
1391 IPSTATS_MIB_OUTFORWDATAGRAMS);
1392 return dst_output(skb);
1396 * Processing handlers for ip6mr_forward
1399 static int ip6mr_forward2(struct sk_buff *skb, struct mfc6_cache *c, int vifi)
1401 struct ipv6hdr *ipv6h;
1402 struct mif_device *vif = &vif6_table[vifi];
1403 struct net_device *dev;
1404 struct dst_entry *dst;
1407 if (vif->dev == NULL)
1410 #ifdef CONFIG_IPV6_PIMSM_V2
1411 if (vif->flags & MIFF_REGISTER) {
1413 vif->bytes_out += skb->len;
1414 vif->dev->stats.tx_bytes += skb->len;
1415 vif->dev->stats.tx_packets++;
1416 ip6mr_cache_report(skb, vifi, MRT6MSG_WHOLEPKT);
1422 ipv6h = ipv6_hdr(skb);
1424 fl = (struct flowi) {
1427 { .daddr = ipv6h->daddr, }
1431 dst = ip6_route_output(&init_net, NULL, &fl);
1435 dst_release(skb->dst);
1439 * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
1440 * not only before forwarding, but after forwarding on all output
1441 * interfaces. It is clear, if mrouter runs a multicasting
1442 * program, it should receive packets not depending to what interface
1443 * program is joined.
1444 * If we will not make it, the program will have to join on all
1445 * interfaces. On the other hand, multihoming host (or router, but
1446 * not mrouter) cannot join to more than one interface - it will
1447 * result in receiving multiple packets.
1452 vif->bytes_out += skb->len;
1454 /* We are about to write */
1455 /* XXX: extension headers? */
1456 if (skb_cow(skb, sizeof(*ipv6h) + LL_RESERVED_SPACE(dev)))
1459 ipv6h = ipv6_hdr(skb);
1462 IP6CB(skb)->flags |= IP6SKB_FORWARDED;
1464 return NF_HOOK(PF_INET6, NF_INET_FORWARD, skb, skb->dev, dev,
1465 ip6mr_forward2_finish);
1472 static int ip6mr_find_vif(struct net_device *dev)
1475 for (ct = maxvif - 1; ct >= 0; ct--) {
1476 if (vif6_table[ct].dev == dev)
1482 static int ip6_mr_forward(struct sk_buff *skb, struct mfc6_cache *cache)
1487 vif = cache->mf6c_parent;
1488 cache->mfc_un.res.pkt++;
1489 cache->mfc_un.res.bytes += skb->len;
1492 * Wrong interface: drop packet and (maybe) send PIM assert.
1494 if (vif6_table[vif].dev != skb->dev) {
1497 cache->mfc_un.res.wrong_if++;
1498 true_vifi = ip6mr_find_vif(skb->dev);
1500 if (true_vifi >= 0 && mroute_do_assert &&
1501 /* pimsm uses asserts, when switching from RPT to SPT,
1502 so that we cannot check that packet arrived on an oif.
1503 It is bad, but otherwise we would need to move pretty
1504 large chunk of pimd to kernel. Ough... --ANK
1506 (mroute_do_pim || cache->mfc_un.res.ttls[true_vifi] < 255) &&
1508 cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
1509 cache->mfc_un.res.last_assert = jiffies;
1510 ip6mr_cache_report(skb, true_vifi, MRT6MSG_WRONGMIF);
1515 vif6_table[vif].pkt_in++;
1516 vif6_table[vif].bytes_in += skb->len;
1521 for (ct = cache->mfc_un.res.maxvif - 1; ct >= cache->mfc_un.res.minvif; ct--) {
1522 if (ipv6_hdr(skb)->hop_limit > cache->mfc_un.res.ttls[ct]) {
1524 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1526 ip6mr_forward2(skb2, cache, psend);
1532 ip6mr_forward2(skb, cache, psend);
1543 * Multicast packets for forwarding arrive here
1546 int ip6_mr_input(struct sk_buff *skb)
1548 struct mfc6_cache *cache;
1550 read_lock(&mrt_lock);
1551 cache = ip6mr_cache_find(&ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr);
1554 * No usable cache entry
1556 if (cache == NULL) {
1559 vif = ip6mr_find_vif(skb->dev);
1561 int err = ip6mr_cache_unresolved(vif, skb);
1562 read_unlock(&mrt_lock);
1566 read_unlock(&mrt_lock);
1571 ip6_mr_forward(skb, cache);
1573 read_unlock(&mrt_lock);
1580 ip6mr_fill_mroute(struct sk_buff *skb, struct mfc6_cache *c, struct rtmsg *rtm)
1583 struct rtnexthop *nhp;
1584 struct net_device *dev = vif6_table[c->mf6c_parent].dev;
1585 u8 *b = skb_tail_pointer(skb);
1586 struct rtattr *mp_head;
1589 RTA_PUT(skb, RTA_IIF, 4, &dev->ifindex);
1591 mp_head = (struct rtattr *)skb_put(skb, RTA_LENGTH(0));
1593 for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
1594 if (c->mfc_un.res.ttls[ct] < 255) {
1595 if (skb_tailroom(skb) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp)) + 4))
1596 goto rtattr_failure;
1597 nhp = (struct rtnexthop *)skb_put(skb, RTA_ALIGN(sizeof(*nhp)));
1598 nhp->rtnh_flags = 0;
1599 nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
1600 nhp->rtnh_ifindex = vif6_table[ct].dev->ifindex;
1601 nhp->rtnh_len = sizeof(*nhp);
1604 mp_head->rta_type = RTA_MULTIPATH;
1605 mp_head->rta_len = skb_tail_pointer(skb) - (u8 *)mp_head;
1606 rtm->rtm_type = RTN_MULTICAST;
1614 int ip6mr_get_route(struct sk_buff *skb, struct rtmsg *rtm, int nowait)
1617 struct mfc6_cache *cache;
1618 struct rt6_info *rt = (struct rt6_info *)skb->dst;
1620 read_lock(&mrt_lock);
1621 cache = ip6mr_cache_find(&rt->rt6i_src.addr, &rt->rt6i_dst.addr);
1624 struct sk_buff *skb2;
1625 struct ipv6hdr *iph;
1626 struct net_device *dev;
1630 read_unlock(&mrt_lock);
1635 if (dev == NULL || (vif = ip6mr_find_vif(dev)) < 0) {
1636 read_unlock(&mrt_lock);
1640 /* really correct? */
1641 skb2 = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC);
1643 read_unlock(&mrt_lock);
1647 skb_reset_transport_header(skb2);
1649 skb_put(skb2, sizeof(struct ipv6hdr));
1650 skb_reset_network_header(skb2);
1652 iph = ipv6_hdr(skb2);
1655 iph->flow_lbl[0] = 0;
1656 iph->flow_lbl[1] = 0;
1657 iph->flow_lbl[2] = 0;
1658 iph->payload_len = 0;
1659 iph->nexthdr = IPPROTO_NONE;
1661 ipv6_addr_copy(&iph->saddr, &rt->rt6i_src.addr);
1662 ipv6_addr_copy(&iph->daddr, &rt->rt6i_dst.addr);
1664 err = ip6mr_cache_unresolved(vif, skb2);
1665 read_unlock(&mrt_lock);
1670 if (!nowait && (rtm->rtm_flags&RTM_F_NOTIFY))
1671 cache->mfc_flags |= MFC_NOTIFY;
1673 err = ip6mr_fill_mroute(skb, cache, rtm);
1674 read_unlock(&mrt_lock);