2 * IP multicast routing support for mrouted 3.6/3.8
4 * (c) 1995 Alan Cox, <alan@redhat.com>
5 * Linux Consultancy and Custom Driver Development
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
12 * Version: $Id: ipmr.c,v 1.65 2001/10/31 21:55:54 davem Exp $
15 * Michael Chastain : Incorrect size of copying.
16 * Alan Cox : Added the cache manager code
17 * Alan Cox : Fixed the clone/copy bug and device race.
18 * Mike McLagan : Routing by source
19 * Malcolm Beattie : Buffer handling fixes.
20 * Alexey Kuznetsov : Double buffer free and other fixes.
21 * SVR Anand : Fixed several multicast bugs and problems.
22 * Alexey Kuznetsov : Status, optimisations and more.
23 * Brad Parker : Better behaviour on mrouted upcall
25 * Carlos Picoto : PIMv1 Support
26 * Pavlin Ivanov Radoslavov: PIMv2 Registers must checksum only PIM header
27 * Relax this requrement to work with older peers.
31 #include <asm/system.h>
32 #include <asm/uaccess.h>
33 #include <linux/types.h>
34 #include <linux/capability.h>
35 #include <linux/errno.h>
36 #include <linux/timer.h>
38 #include <linux/kernel.h>
39 #include <linux/fcntl.h>
40 #include <linux/stat.h>
41 #include <linux/socket.h>
43 #include <linux/inet.h>
44 #include <linux/netdevice.h>
45 #include <linux/inetdevice.h>
46 #include <linux/igmp.h>
47 #include <linux/proc_fs.h>
48 #include <linux/seq_file.h>
49 #include <linux/mroute.h>
50 #include <linux/init.h>
51 #include <linux/if_ether.h>
53 #include <net/protocol.h>
54 #include <linux/skbuff.h>
55 #include <net/route.h>
60 #include <linux/notifier.h>
61 #include <linux/if_arp.h>
62 #include <linux/netfilter_ipv4.h>
64 #include <net/checksum.h>
66 #if defined(CONFIG_IP_PIMSM_V1) || defined(CONFIG_IP_PIMSM_V2)
67 #define CONFIG_IP_PIMSM 1
70 static struct sock *mroute_socket;
73 /* Big lock, protecting vif table, mrt cache and mroute socket state.
74 Note that the changes are semaphored via rtnl_lock.
77 static DEFINE_RWLOCK(mrt_lock);
80 * Multicast router control variables
83 static struct vif_device vif_table[MAXVIFS]; /* Devices */
86 #define VIF_EXISTS(idx) (vif_table[idx].dev != NULL)
88 static int mroute_do_assert; /* Set in PIM assert */
89 static int mroute_do_pim;
91 static struct mfc_cache *mfc_cache_array[MFC_LINES]; /* Forwarding cache */
93 static struct mfc_cache *mfc_unres_queue; /* Queue of unresolved entries */
94 static atomic_t cache_resolve_queue_len; /* Size of unresolved */
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 int ip_mr_forward(struct sk_buff *skb, struct mfc_cache *cache, int local);
110 static int ipmr_cache_report(struct sk_buff *pkt, vifi_t vifi, int assert);
111 static int ipmr_fill_mroute(struct sk_buff *skb, struct mfc_cache *c, struct rtmsg *rtm);
113 #ifdef CONFIG_IP_PIMSM_V2
114 static struct net_protocol pim_protocol;
117 static struct timer_list ipmr_expire_timer;
119 /* Service routines creating virtual interfaces: DVMRP tunnels and PIMREG */
122 struct net_device *ipmr_new_tunnel(struct vifctl *v)
124 struct net_device *dev;
126 dev = __dev_get_by_name("tunl0");
132 struct ip_tunnel_parm p;
133 struct in_device *in_dev;
135 memset(&p, 0, sizeof(p));
136 p.iph.daddr = v->vifc_rmt_addr.s_addr;
137 p.iph.saddr = v->vifc_lcl_addr.s_addr;
140 p.iph.protocol = IPPROTO_IPIP;
141 sprintf(p.name, "dvmrp%d", v->vifc_vifi);
142 ifr.ifr_ifru.ifru_data = (void*)&p;
144 oldfs = get_fs(); set_fs(KERNEL_DS);
145 err = dev->do_ioctl(dev, &ifr, SIOCADDTUNNEL);
150 if (err == 0 && (dev = __dev_get_by_name(p.name)) != NULL) {
151 dev->flags |= IFF_MULTICAST;
153 in_dev = __in_dev_get_rtnl(dev);
154 if (in_dev == NULL && (in_dev = inetdev_init(dev)) == NULL)
156 in_dev->cnf.rp_filter = 0;
165 /* allow the register to be completed before unregistering. */
169 unregister_netdevice(dev);
173 #ifdef CONFIG_IP_PIMSM
175 static int reg_vif_num = -1;
177 static int reg_vif_xmit(struct sk_buff *skb, struct net_device *dev)
179 read_lock(&mrt_lock);
180 ((struct net_device_stats*)netdev_priv(dev))->tx_bytes += skb->len;
181 ((struct net_device_stats*)netdev_priv(dev))->tx_packets++;
182 ipmr_cache_report(skb, reg_vif_num, IGMPMSG_WHOLEPKT);
183 read_unlock(&mrt_lock);
188 static struct net_device_stats *reg_vif_get_stats(struct net_device *dev)
190 return (struct net_device_stats*)netdev_priv(dev);
193 static void reg_vif_setup(struct net_device *dev)
195 dev->type = ARPHRD_PIMREG;
196 dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr) - 8;
197 dev->flags = IFF_NOARP;
198 dev->hard_start_xmit = reg_vif_xmit;
199 dev->get_stats = reg_vif_get_stats;
200 dev->destructor = free_netdev;
203 static struct net_device *ipmr_reg_vif(void)
205 struct net_device *dev;
206 struct in_device *in_dev;
208 dev = alloc_netdev(sizeof(struct net_device_stats), "pimreg",
214 if (register_netdevice(dev)) {
220 if ((in_dev = inetdev_init(dev)) == NULL)
223 in_dev->cnf.rp_filter = 0;
231 /* allow the register to be completed before unregistering. */
235 unregister_netdevice(dev);
244 static int vif_delete(int vifi)
246 struct vif_device *v;
247 struct net_device *dev;
248 struct in_device *in_dev;
250 if (vifi < 0 || vifi >= maxvif)
251 return -EADDRNOTAVAIL;
253 v = &vif_table[vifi];
255 write_lock_bh(&mrt_lock);
260 write_unlock_bh(&mrt_lock);
261 return -EADDRNOTAVAIL;
264 #ifdef CONFIG_IP_PIMSM
265 if (vifi == reg_vif_num)
269 if (vifi+1 == maxvif) {
271 for (tmp=vifi-1; tmp>=0; tmp--) {
278 write_unlock_bh(&mrt_lock);
280 dev_set_allmulti(dev, -1);
282 if ((in_dev = __in_dev_get_rtnl(dev)) != NULL) {
283 in_dev->cnf.mc_forwarding--;
284 ip_rt_multicast_event(in_dev);
287 if (v->flags&(VIFF_TUNNEL|VIFF_REGISTER))
288 unregister_netdevice(dev);
294 /* Destroy an unresolved cache entry, killing queued skbs
295 and reporting error to netlink readers.
298 static void ipmr_destroy_unres(struct mfc_cache *c)
303 atomic_dec(&cache_resolve_queue_len);
305 while ((skb=skb_dequeue(&c->mfc_un.unres.unresolved))) {
306 if (skb->nh.iph->version == 0) {
307 struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr));
308 nlh->nlmsg_type = NLMSG_ERROR;
309 nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
310 skb_trim(skb, nlh->nlmsg_len);
312 e->error = -ETIMEDOUT;
313 memset(&e->msg, 0, sizeof(e->msg));
315 rtnl_unicast(skb, NETLINK_CB(skb).pid);
320 kmem_cache_free(mrt_cachep, c);
324 /* Single timer process for all the unresolved queue. */
326 static void ipmr_expire_process(unsigned long dummy)
329 unsigned long expires;
330 struct mfc_cache *c, **cp;
332 if (!spin_trylock(&mfc_unres_lock)) {
333 mod_timer(&ipmr_expire_timer, jiffies+HZ/10);
337 if (atomic_read(&cache_resolve_queue_len) == 0)
342 cp = &mfc_unres_queue;
344 while ((c=*cp) != NULL) {
345 if (time_after(c->mfc_un.unres.expires, now)) {
346 unsigned long interval = c->mfc_un.unres.expires - now;
347 if (interval < expires)
355 ipmr_destroy_unres(c);
358 if (atomic_read(&cache_resolve_queue_len))
359 mod_timer(&ipmr_expire_timer, jiffies + expires);
362 spin_unlock(&mfc_unres_lock);
365 /* Fill oifs list. It is called under write locked mrt_lock. */
367 static void ipmr_update_thresholds(struct mfc_cache *cache, unsigned char *ttls)
371 cache->mfc_un.res.minvif = MAXVIFS;
372 cache->mfc_un.res.maxvif = 0;
373 memset(cache->mfc_un.res.ttls, 255, MAXVIFS);
375 for (vifi=0; vifi<maxvif; vifi++) {
376 if (VIF_EXISTS(vifi) && ttls[vifi] && ttls[vifi] < 255) {
377 cache->mfc_un.res.ttls[vifi] = ttls[vifi];
378 if (cache->mfc_un.res.minvif > vifi)
379 cache->mfc_un.res.minvif = vifi;
380 if (cache->mfc_un.res.maxvif <= vifi)
381 cache->mfc_un.res.maxvif = vifi + 1;
386 static int vif_add(struct vifctl *vifc, int mrtsock)
388 int vifi = vifc->vifc_vifi;
389 struct vif_device *v = &vif_table[vifi];
390 struct net_device *dev;
391 struct in_device *in_dev;
394 if (VIF_EXISTS(vifi))
397 switch (vifc->vifc_flags) {
398 #ifdef CONFIG_IP_PIMSM
401 * Special Purpose VIF in PIM
402 * All the packets will be sent to the daemon
404 if (reg_vif_num >= 0)
406 dev = ipmr_reg_vif();
412 dev = ipmr_new_tunnel(vifc);
417 dev = ip_dev_find(vifc->vifc_lcl_addr.s_addr);
419 return -EADDRNOTAVAIL;
426 if ((in_dev = __in_dev_get_rtnl(dev)) == NULL)
427 return -EADDRNOTAVAIL;
428 in_dev->cnf.mc_forwarding++;
429 dev_set_allmulti(dev, +1);
430 ip_rt_multicast_event(in_dev);
433 * Fill in the VIF structures
435 v->rate_limit=vifc->vifc_rate_limit;
436 v->local=vifc->vifc_lcl_addr.s_addr;
437 v->remote=vifc->vifc_rmt_addr.s_addr;
438 v->flags=vifc->vifc_flags;
440 v->flags |= VIFF_STATIC;
441 v->threshold=vifc->vifc_threshold;
446 v->link = dev->ifindex;
447 if (v->flags&(VIFF_TUNNEL|VIFF_REGISTER))
448 v->link = dev->iflink;
450 /* And finish update writing critical data */
451 write_lock_bh(&mrt_lock);
454 #ifdef CONFIG_IP_PIMSM
455 if (v->flags&VIFF_REGISTER)
460 write_unlock_bh(&mrt_lock);
464 static struct mfc_cache *ipmr_cache_find(__be32 origin, __be32 mcastgrp)
466 int line=MFC_HASH(mcastgrp,origin);
469 for (c=mfc_cache_array[line]; c; c = c->next) {
470 if (c->mfc_origin==origin && c->mfc_mcastgrp==mcastgrp)
477 * Allocate a multicast cache entry
479 static struct mfc_cache *ipmr_cache_alloc(void)
481 struct mfc_cache *c=kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
484 c->mfc_un.res.minvif = MAXVIFS;
488 static struct mfc_cache *ipmr_cache_alloc_unres(void)
490 struct mfc_cache *c=kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC);
493 skb_queue_head_init(&c->mfc_un.unres.unresolved);
494 c->mfc_un.unres.expires = jiffies + 10*HZ;
499 * A cache entry has gone into a resolved state from queued
502 static void ipmr_cache_resolve(struct mfc_cache *uc, struct mfc_cache *c)
508 * Play the pending entries through our router
511 while ((skb=__skb_dequeue(&uc->mfc_un.unres.unresolved))) {
512 if (skb->nh.iph->version == 0) {
513 struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr));
515 if (ipmr_fill_mroute(skb, c, NLMSG_DATA(nlh)) > 0) {
516 nlh->nlmsg_len = skb->tail - (u8*)nlh;
518 nlh->nlmsg_type = NLMSG_ERROR;
519 nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
520 skb_trim(skb, nlh->nlmsg_len);
522 e->error = -EMSGSIZE;
523 memset(&e->msg, 0, sizeof(e->msg));
526 rtnl_unicast(skb, NETLINK_CB(skb).pid);
528 ip_mr_forward(skb, c, 0);
533 * Bounce a cache query up to mrouted. We could use netlink for this but mrouted
534 * expects the following bizarre scheme.
536 * Called under mrt_lock.
539 static int ipmr_cache_report(struct sk_buff *pkt, vifi_t vifi, int assert)
542 int ihl = pkt->nh.iph->ihl<<2;
543 struct igmphdr *igmp;
547 #ifdef CONFIG_IP_PIMSM
548 if (assert == IGMPMSG_WHOLEPKT)
549 skb = skb_realloc_headroom(pkt, sizeof(struct iphdr));
552 skb = alloc_skb(128, GFP_ATOMIC);
557 #ifdef CONFIG_IP_PIMSM
558 if (assert == IGMPMSG_WHOLEPKT) {
559 /* Ugly, but we have no choice with this interface.
560 Duplicate old header, fix ihl, length etc.
561 And all this only to mangle msg->im_msgtype and
562 to set msg->im_mbz to "mbz" :-)
564 msg = (struct igmpmsg*)skb_push(skb, sizeof(struct iphdr));
565 skb->nh.raw = skb->h.raw = (u8*)msg;
566 memcpy(msg, pkt->nh.raw, sizeof(struct iphdr));
567 msg->im_msgtype = IGMPMSG_WHOLEPKT;
569 msg->im_vif = reg_vif_num;
570 skb->nh.iph->ihl = sizeof(struct iphdr) >> 2;
571 skb->nh.iph->tot_len = htons(ntohs(pkt->nh.iph->tot_len) + sizeof(struct iphdr));
580 skb->nh.iph = (struct iphdr *)skb_put(skb, ihl);
581 memcpy(skb->data,pkt->data,ihl);
582 skb->nh.iph->protocol = 0; /* Flag to the kernel this is a route add */
583 msg = (struct igmpmsg*)skb->nh.iph;
585 skb->dst = dst_clone(pkt->dst);
591 igmp=(struct igmphdr *)skb_put(skb,sizeof(struct igmphdr));
593 msg->im_msgtype = assert;
595 skb->nh.iph->tot_len=htons(skb->len); /* Fix the length */
596 skb->h.raw = skb->nh.raw;
599 if (mroute_socket == NULL) {
607 if ((ret=sock_queue_rcv_skb(mroute_socket,skb))<0) {
609 printk(KERN_WARNING "mroute: pending queue full, dropping entries.\n");
617 * Queue a packet for resolution. It gets locked cache entry!
621 ipmr_cache_unresolved(vifi_t vifi, struct sk_buff *skb)
626 spin_lock_bh(&mfc_unres_lock);
627 for (c=mfc_unres_queue; c; c=c->next) {
628 if (c->mfc_mcastgrp == skb->nh.iph->daddr &&
629 c->mfc_origin == skb->nh.iph->saddr)
635 * Create a new entry if allowable
638 if (atomic_read(&cache_resolve_queue_len)>=10 ||
639 (c=ipmr_cache_alloc_unres())==NULL) {
640 spin_unlock_bh(&mfc_unres_lock);
647 * Fill in the new cache entry
650 c->mfc_origin=skb->nh.iph->saddr;
651 c->mfc_mcastgrp=skb->nh.iph->daddr;
654 * Reflect first query at mrouted.
656 if ((err = ipmr_cache_report(skb, vifi, IGMPMSG_NOCACHE))<0) {
657 /* If the report failed throw the cache entry
660 spin_unlock_bh(&mfc_unres_lock);
662 kmem_cache_free(mrt_cachep, c);
667 atomic_inc(&cache_resolve_queue_len);
668 c->next = mfc_unres_queue;
671 mod_timer(&ipmr_expire_timer, c->mfc_un.unres.expires);
675 * See if we can append the packet
677 if (c->mfc_un.unres.unresolved.qlen>3) {
681 skb_queue_tail(&c->mfc_un.unres.unresolved,skb);
685 spin_unlock_bh(&mfc_unres_lock);
690 * MFC cache manipulation by user space mroute daemon
693 static int ipmr_mfc_delete(struct mfcctl *mfc)
696 struct mfc_cache *c, **cp;
698 line=MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr);
700 for (cp=&mfc_cache_array[line]; (c=*cp) != NULL; cp = &c->next) {
701 if (c->mfc_origin == mfc->mfcc_origin.s_addr &&
702 c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr) {
703 write_lock_bh(&mrt_lock);
705 write_unlock_bh(&mrt_lock);
707 kmem_cache_free(mrt_cachep, c);
714 static int ipmr_mfc_add(struct mfcctl *mfc, int mrtsock)
717 struct mfc_cache *uc, *c, **cp;
719 line=MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr);
721 for (cp=&mfc_cache_array[line]; (c=*cp) != NULL; cp = &c->next) {
722 if (c->mfc_origin == mfc->mfcc_origin.s_addr &&
723 c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr)
728 write_lock_bh(&mrt_lock);
729 c->mfc_parent = mfc->mfcc_parent;
730 ipmr_update_thresholds(c, mfc->mfcc_ttls);
732 c->mfc_flags |= MFC_STATIC;
733 write_unlock_bh(&mrt_lock);
737 if (!MULTICAST(mfc->mfcc_mcastgrp.s_addr))
740 c=ipmr_cache_alloc();
744 c->mfc_origin=mfc->mfcc_origin.s_addr;
745 c->mfc_mcastgrp=mfc->mfcc_mcastgrp.s_addr;
746 c->mfc_parent=mfc->mfcc_parent;
747 ipmr_update_thresholds(c, mfc->mfcc_ttls);
749 c->mfc_flags |= MFC_STATIC;
751 write_lock_bh(&mrt_lock);
752 c->next = mfc_cache_array[line];
753 mfc_cache_array[line] = c;
754 write_unlock_bh(&mrt_lock);
757 * Check to see if we resolved a queued list. If so we
758 * need to send on the frames and tidy up.
760 spin_lock_bh(&mfc_unres_lock);
761 for (cp = &mfc_unres_queue; (uc=*cp) != NULL;
763 if (uc->mfc_origin == c->mfc_origin &&
764 uc->mfc_mcastgrp == c->mfc_mcastgrp) {
766 if (atomic_dec_and_test(&cache_resolve_queue_len))
767 del_timer(&ipmr_expire_timer);
771 spin_unlock_bh(&mfc_unres_lock);
774 ipmr_cache_resolve(uc, c);
775 kmem_cache_free(mrt_cachep, uc);
781 * Close the multicast socket, and clear the vif tables etc
784 static void mroute_clean_tables(struct sock *sk)
789 * Shut down all active vif entries
791 for (i=0; i<maxvif; i++) {
792 if (!(vif_table[i].flags&VIFF_STATIC))
799 for (i=0;i<MFC_LINES;i++) {
800 struct mfc_cache *c, **cp;
802 cp = &mfc_cache_array[i];
803 while ((c = *cp) != NULL) {
804 if (c->mfc_flags&MFC_STATIC) {
808 write_lock_bh(&mrt_lock);
810 write_unlock_bh(&mrt_lock);
812 kmem_cache_free(mrt_cachep, c);
816 if (atomic_read(&cache_resolve_queue_len) != 0) {
819 spin_lock_bh(&mfc_unres_lock);
820 while (mfc_unres_queue != NULL) {
822 mfc_unres_queue = c->next;
823 spin_unlock_bh(&mfc_unres_lock);
825 ipmr_destroy_unres(c);
827 spin_lock_bh(&mfc_unres_lock);
829 spin_unlock_bh(&mfc_unres_lock);
833 static void mrtsock_destruct(struct sock *sk)
836 if (sk == mroute_socket) {
837 ipv4_devconf.mc_forwarding--;
839 write_lock_bh(&mrt_lock);
841 write_unlock_bh(&mrt_lock);
843 mroute_clean_tables(sk);
849 * Socket options and virtual interface manipulation. The whole
850 * virtual interface system is a complete heap, but unfortunately
851 * that's how BSD mrouted happens to think. Maybe one day with a proper
852 * MOSPF/PIM router set up we can clean this up.
855 int ip_mroute_setsockopt(struct sock *sk,int optname,char __user *optval,int optlen)
861 if (optname != MRT_INIT) {
862 if (sk != mroute_socket && !capable(CAP_NET_ADMIN))
868 if (sk->sk_type != SOCK_RAW ||
869 inet_sk(sk)->num != IPPROTO_IGMP)
871 if (optlen!=sizeof(int))
880 ret = ip_ra_control(sk, 1, mrtsock_destruct);
882 write_lock_bh(&mrt_lock);
884 write_unlock_bh(&mrt_lock);
886 ipv4_devconf.mc_forwarding++;
891 if (sk!=mroute_socket)
893 return ip_ra_control(sk, 0, NULL);
896 if (optlen!=sizeof(vif))
898 if (copy_from_user(&vif,optval,sizeof(vif)))
900 if (vif.vifc_vifi >= MAXVIFS)
903 if (optname==MRT_ADD_VIF) {
904 ret = vif_add(&vif, sk==mroute_socket);
906 ret = vif_delete(vif.vifc_vifi);
912 * Manipulate the forwarding caches. These live
913 * in a sort of kernel/user symbiosis.
917 if (optlen!=sizeof(mfc))
919 if (copy_from_user(&mfc,optval, sizeof(mfc)))
922 if (optname==MRT_DEL_MFC)
923 ret = ipmr_mfc_delete(&mfc);
925 ret = ipmr_mfc_add(&mfc, sk==mroute_socket);
929 * Control PIM assert.
934 if (get_user(v,(int __user *)optval))
936 mroute_do_assert=(v)?1:0;
939 #ifdef CONFIG_IP_PIMSM
943 if (get_user(v,(int __user *)optval))
948 if (v != mroute_do_pim) {
950 mroute_do_assert = v;
951 #ifdef CONFIG_IP_PIMSM_V2
953 ret = inet_add_protocol(&pim_protocol,
956 ret = inet_del_protocol(&pim_protocol,
967 * Spurious command, or MRT_VERSION which you cannot
976 * Getsock opt support for the multicast routing system.
979 int ip_mroute_getsockopt(struct sock *sk,int optname,char __user *optval,int __user *optlen)
984 if (optname!=MRT_VERSION &&
985 #ifdef CONFIG_IP_PIMSM
991 if (get_user(olr, optlen))
994 olr = min_t(unsigned int, olr, sizeof(int));
998 if (put_user(olr,optlen))
1000 if (optname==MRT_VERSION)
1002 #ifdef CONFIG_IP_PIMSM
1003 else if (optname==MRT_PIM)
1007 val=mroute_do_assert;
1008 if (copy_to_user(optval,&val,olr))
1014 * The IP multicast ioctl support routines.
1017 int ipmr_ioctl(struct sock *sk, int cmd, void __user *arg)
1019 struct sioc_sg_req sr;
1020 struct sioc_vif_req vr;
1021 struct vif_device *vif;
1022 struct mfc_cache *c;
1026 if (copy_from_user(&vr,arg,sizeof(vr)))
1028 if (vr.vifi>=maxvif)
1030 read_lock(&mrt_lock);
1031 vif=&vif_table[vr.vifi];
1032 if (VIF_EXISTS(vr.vifi)) {
1033 vr.icount=vif->pkt_in;
1034 vr.ocount=vif->pkt_out;
1035 vr.ibytes=vif->bytes_in;
1036 vr.obytes=vif->bytes_out;
1037 read_unlock(&mrt_lock);
1039 if (copy_to_user(arg,&vr,sizeof(vr)))
1043 read_unlock(&mrt_lock);
1044 return -EADDRNOTAVAIL;
1046 if (copy_from_user(&sr,arg,sizeof(sr)))
1049 read_lock(&mrt_lock);
1050 c = ipmr_cache_find(sr.src.s_addr, sr.grp.s_addr);
1052 sr.pktcnt = c->mfc_un.res.pkt;
1053 sr.bytecnt = c->mfc_un.res.bytes;
1054 sr.wrong_if = c->mfc_un.res.wrong_if;
1055 read_unlock(&mrt_lock);
1057 if (copy_to_user(arg,&sr,sizeof(sr)))
1061 read_unlock(&mrt_lock);
1062 return -EADDRNOTAVAIL;
1064 return -ENOIOCTLCMD;
1069 static int ipmr_device_event(struct notifier_block *this, unsigned long event, void *ptr)
1071 struct vif_device *v;
1073 if (event != NETDEV_UNREGISTER)
1076 for (ct=0;ct<maxvif;ct++,v++) {
1084 static struct notifier_block ip_mr_notifier={
1085 .notifier_call = ipmr_device_event,
1089 * Encapsulate a packet by attaching a valid IPIP header to it.
1090 * This avoids tunnel drivers and other mess and gives us the speed so
1091 * important for multicast video.
1094 static void ip_encap(struct sk_buff *skb, __be32 saddr, __be32 daddr)
1096 struct iphdr *iph = (struct iphdr *)skb_push(skb,sizeof(struct iphdr));
1099 iph->tos = skb->nh.iph->tos;
1100 iph->ttl = skb->nh.iph->ttl;
1104 iph->protocol = IPPROTO_IPIP;
1106 iph->tot_len = htons(skb->len);
1107 ip_select_ident(iph, skb->dst, NULL);
1110 skb->h.ipiph = skb->nh.iph;
1112 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
1116 static inline int ipmr_forward_finish(struct sk_buff *skb)
1118 struct ip_options * opt = &(IPCB(skb)->opt);
1120 IP_INC_STATS_BH(IPSTATS_MIB_OUTFORWDATAGRAMS);
1122 if (unlikely(opt->optlen))
1123 ip_forward_options(skb);
1125 return dst_output(skb);
1129 * Processing handlers for ipmr_forward
1132 static void ipmr_queue_xmit(struct sk_buff *skb, struct mfc_cache *c, int vifi)
1134 struct iphdr *iph = skb->nh.iph;
1135 struct vif_device *vif = &vif_table[vifi];
1136 struct net_device *dev;
1140 if (vif->dev == NULL)
1143 #ifdef CONFIG_IP_PIMSM
1144 if (vif->flags & VIFF_REGISTER) {
1146 vif->bytes_out+=skb->len;
1147 ((struct net_device_stats*)netdev_priv(vif->dev))->tx_bytes += skb->len;
1148 ((struct net_device_stats*)netdev_priv(vif->dev))->tx_packets++;
1149 ipmr_cache_report(skb, vifi, IGMPMSG_WHOLEPKT);
1155 if (vif->flags&VIFF_TUNNEL) {
1156 struct flowi fl = { .oif = vif->link,
1158 { .daddr = vif->remote,
1159 .saddr = vif->local,
1160 .tos = RT_TOS(iph->tos) } },
1161 .proto = IPPROTO_IPIP };
1162 if (ip_route_output_key(&rt, &fl))
1164 encap = sizeof(struct iphdr);
1166 struct flowi fl = { .oif = vif->link,
1168 { .daddr = iph->daddr,
1169 .tos = RT_TOS(iph->tos) } },
1170 .proto = IPPROTO_IPIP };
1171 if (ip_route_output_key(&rt, &fl))
1175 dev = rt->u.dst.dev;
1177 if (skb->len+encap > dst_mtu(&rt->u.dst) && (ntohs(iph->frag_off) & IP_DF)) {
1178 /* Do not fragment multicasts. Alas, IPv4 does not
1179 allow to send ICMP, so that packets will disappear
1183 IP_INC_STATS_BH(IPSTATS_MIB_FRAGFAILS);
1188 encap += LL_RESERVED_SPACE(dev) + rt->u.dst.header_len;
1190 if (skb_cow(skb, encap)) {
1196 vif->bytes_out+=skb->len;
1198 dst_release(skb->dst);
1199 skb->dst = &rt->u.dst;
1201 ip_decrease_ttl(iph);
1203 /* FIXME: forward and output firewalls used to be called here.
1204 * What do we do with netfilter? -- RR */
1205 if (vif->flags & VIFF_TUNNEL) {
1206 ip_encap(skb, vif->local, vif->remote);
1207 /* FIXME: extra output firewall step used to be here. --RR */
1208 ((struct ip_tunnel *)netdev_priv(vif->dev))->stat.tx_packets++;
1209 ((struct ip_tunnel *)netdev_priv(vif->dev))->stat.tx_bytes+=skb->len;
1212 IPCB(skb)->flags |= IPSKB_FORWARDED;
1215 * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
1216 * not only before forwarding, but after forwarding on all output
1217 * interfaces. It is clear, if mrouter runs a multicasting
1218 * program, it should receive packets not depending to what interface
1219 * program is joined.
1220 * If we will not make it, the program will have to join on all
1221 * interfaces. On the other hand, multihoming host (or router, but
1222 * not mrouter) cannot join to more than one interface - it will
1223 * result in receiving multiple packets.
1225 NF_HOOK(PF_INET, NF_IP_FORWARD, skb, skb->dev, dev,
1226 ipmr_forward_finish);
1234 static int ipmr_find_vif(struct net_device *dev)
1237 for (ct=maxvif-1; ct>=0; ct--) {
1238 if (vif_table[ct].dev == dev)
1244 /* "local" means that we should preserve one skb (for local delivery) */
1246 static int ip_mr_forward(struct sk_buff *skb, struct mfc_cache *cache, int local)
1251 vif = cache->mfc_parent;
1252 cache->mfc_un.res.pkt++;
1253 cache->mfc_un.res.bytes += skb->len;
1256 * Wrong interface: drop packet and (maybe) send PIM assert.
1258 if (vif_table[vif].dev != skb->dev) {
1261 if (((struct rtable*)skb->dst)->fl.iif == 0) {
1262 /* It is our own packet, looped back.
1263 Very complicated situation...
1265 The best workaround until routing daemons will be
1266 fixed is not to redistribute packet, if it was
1267 send through wrong interface. It means, that
1268 multicast applications WILL NOT work for
1269 (S,G), which have default multicast route pointing
1270 to wrong oif. In any case, it is not a good
1271 idea to use multicasting applications on router.
1276 cache->mfc_un.res.wrong_if++;
1277 true_vifi = ipmr_find_vif(skb->dev);
1279 if (true_vifi >= 0 && mroute_do_assert &&
1280 /* pimsm uses asserts, when switching from RPT to SPT,
1281 so that we cannot check that packet arrived on an oif.
1282 It is bad, but otherwise we would need to move pretty
1283 large chunk of pimd to kernel. Ough... --ANK
1285 (mroute_do_pim || cache->mfc_un.res.ttls[true_vifi] < 255) &&
1287 cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
1288 cache->mfc_un.res.last_assert = jiffies;
1289 ipmr_cache_report(skb, true_vifi, IGMPMSG_WRONGVIF);
1294 vif_table[vif].pkt_in++;
1295 vif_table[vif].bytes_in+=skb->len;
1300 for (ct = cache->mfc_un.res.maxvif-1; ct >= cache->mfc_un.res.minvif; ct--) {
1301 if (skb->nh.iph->ttl > cache->mfc_un.res.ttls[ct]) {
1303 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1305 ipmr_queue_xmit(skb2, cache, psend);
1312 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1314 ipmr_queue_xmit(skb2, cache, psend);
1316 ipmr_queue_xmit(skb, cache, psend);
1329 * Multicast packets for forwarding arrive here
1332 int ip_mr_input(struct sk_buff *skb)
1334 struct mfc_cache *cache;
1335 int local = ((struct rtable*)skb->dst)->rt_flags&RTCF_LOCAL;
1337 /* Packet is looped back after forward, it should not be
1338 forwarded second time, but still can be delivered locally.
1340 if (IPCB(skb)->flags&IPSKB_FORWARDED)
1344 if (IPCB(skb)->opt.router_alert) {
1345 if (ip_call_ra_chain(skb))
1347 } else if (skb->nh.iph->protocol == IPPROTO_IGMP){
1348 /* IGMPv1 (and broken IGMPv2 implementations sort of
1349 Cisco IOS <= 11.2(8)) do not put router alert
1350 option to IGMP packets destined to routable
1351 groups. It is very bad, because it means
1352 that we can forward NO IGMP messages.
1354 read_lock(&mrt_lock);
1355 if (mroute_socket) {
1357 raw_rcv(mroute_socket, skb);
1358 read_unlock(&mrt_lock);
1361 read_unlock(&mrt_lock);
1365 read_lock(&mrt_lock);
1366 cache = ipmr_cache_find(skb->nh.iph->saddr, skb->nh.iph->daddr);
1369 * No usable cache entry
1375 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1376 ip_local_deliver(skb);
1378 read_unlock(&mrt_lock);
1384 vif = ipmr_find_vif(skb->dev);
1386 int err = ipmr_cache_unresolved(vif, skb);
1387 read_unlock(&mrt_lock);
1391 read_unlock(&mrt_lock);
1396 ip_mr_forward(skb, cache, local);
1398 read_unlock(&mrt_lock);
1401 return ip_local_deliver(skb);
1407 return ip_local_deliver(skb);
1412 #ifdef CONFIG_IP_PIMSM_V1
1414 * Handle IGMP messages of PIMv1
1417 int pim_rcv_v1(struct sk_buff * skb)
1419 struct igmphdr *pim;
1420 struct iphdr *encap;
1421 struct net_device *reg_dev = NULL;
1423 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
1426 pim = (struct igmphdr*)skb->h.raw;
1428 if (!mroute_do_pim ||
1429 skb->len < sizeof(*pim) + sizeof(*encap) ||
1430 pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
1433 encap = (struct iphdr*)(skb->h.raw + sizeof(struct igmphdr));
1436 a. packet is really destinted to a multicast group
1437 b. packet is not a NULL-REGISTER
1438 c. packet is not truncated
1440 if (!MULTICAST(encap->daddr) ||
1441 encap->tot_len == 0 ||
1442 ntohs(encap->tot_len) + sizeof(*pim) > skb->len)
1445 read_lock(&mrt_lock);
1446 if (reg_vif_num >= 0)
1447 reg_dev = vif_table[reg_vif_num].dev;
1450 read_unlock(&mrt_lock);
1452 if (reg_dev == NULL)
1455 skb->mac.raw = skb->nh.raw;
1456 skb_pull(skb, (u8*)encap - skb->data);
1457 skb->nh.iph = (struct iphdr *)skb->data;
1459 skb->protocol = htons(ETH_P_IP);
1461 skb->pkt_type = PACKET_HOST;
1462 dst_release(skb->dst);
1464 ((struct net_device_stats*)netdev_priv(reg_dev))->rx_bytes += skb->len;
1465 ((struct net_device_stats*)netdev_priv(reg_dev))->rx_packets++;
1476 #ifdef CONFIG_IP_PIMSM_V2
1477 static int pim_rcv(struct sk_buff * skb)
1479 struct pimreghdr *pim;
1480 struct iphdr *encap;
1481 struct net_device *reg_dev = NULL;
1483 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
1486 pim = (struct pimreghdr*)skb->h.raw;
1487 if (pim->type != ((PIM_VERSION<<4)|(PIM_REGISTER)) ||
1488 (pim->flags&PIM_NULL_REGISTER) ||
1489 (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
1490 csum_fold(skb_checksum(skb, 0, skb->len, 0))))
1493 /* check if the inner packet is destined to mcast group */
1494 encap = (struct iphdr*)(skb->h.raw + sizeof(struct pimreghdr));
1495 if (!MULTICAST(encap->daddr) ||
1496 encap->tot_len == 0 ||
1497 ntohs(encap->tot_len) + sizeof(*pim) > skb->len)
1500 read_lock(&mrt_lock);
1501 if (reg_vif_num >= 0)
1502 reg_dev = vif_table[reg_vif_num].dev;
1505 read_unlock(&mrt_lock);
1507 if (reg_dev == NULL)
1510 skb->mac.raw = skb->nh.raw;
1511 skb_pull(skb, (u8*)encap - skb->data);
1512 skb->nh.iph = (struct iphdr *)skb->data;
1514 skb->protocol = htons(ETH_P_IP);
1516 skb->pkt_type = PACKET_HOST;
1517 dst_release(skb->dst);
1518 ((struct net_device_stats*)netdev_priv(reg_dev))->rx_bytes += skb->len;
1519 ((struct net_device_stats*)netdev_priv(reg_dev))->rx_packets++;
1532 ipmr_fill_mroute(struct sk_buff *skb, struct mfc_cache *c, struct rtmsg *rtm)
1535 struct rtnexthop *nhp;
1536 struct net_device *dev = vif_table[c->mfc_parent].dev;
1538 struct rtattr *mp_head;
1541 RTA_PUT(skb, RTA_IIF, 4, &dev->ifindex);
1543 mp_head = (struct rtattr*)skb_put(skb, RTA_LENGTH(0));
1545 for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
1546 if (c->mfc_un.res.ttls[ct] < 255) {
1547 if (skb_tailroom(skb) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp)) + 4))
1548 goto rtattr_failure;
1549 nhp = (struct rtnexthop*)skb_put(skb, RTA_ALIGN(sizeof(*nhp)));
1550 nhp->rtnh_flags = 0;
1551 nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
1552 nhp->rtnh_ifindex = vif_table[ct].dev->ifindex;
1553 nhp->rtnh_len = sizeof(*nhp);
1556 mp_head->rta_type = RTA_MULTIPATH;
1557 mp_head->rta_len = skb->tail - (u8*)mp_head;
1558 rtm->rtm_type = RTN_MULTICAST;
1562 skb_trim(skb, b - skb->data);
1566 int ipmr_get_route(struct sk_buff *skb, struct rtmsg *rtm, int nowait)
1569 struct mfc_cache *cache;
1570 struct rtable *rt = (struct rtable*)skb->dst;
1572 read_lock(&mrt_lock);
1573 cache = ipmr_cache_find(rt->rt_src, rt->rt_dst);
1576 struct sk_buff *skb2;
1577 struct net_device *dev;
1581 read_unlock(&mrt_lock);
1586 if (dev == NULL || (vif = ipmr_find_vif(dev)) < 0) {
1587 read_unlock(&mrt_lock);
1590 skb2 = skb_clone(skb, GFP_ATOMIC);
1592 read_unlock(&mrt_lock);
1596 skb2->nh.raw = skb_push(skb2, sizeof(struct iphdr));
1597 skb2->nh.iph->ihl = sizeof(struct iphdr)>>2;
1598 skb2->nh.iph->saddr = rt->rt_src;
1599 skb2->nh.iph->daddr = rt->rt_dst;
1600 skb2->nh.iph->version = 0;
1601 err = ipmr_cache_unresolved(vif, skb2);
1602 read_unlock(&mrt_lock);
1606 if (!nowait && (rtm->rtm_flags&RTM_F_NOTIFY))
1607 cache->mfc_flags |= MFC_NOTIFY;
1608 err = ipmr_fill_mroute(skb, cache, rtm);
1609 read_unlock(&mrt_lock);
1613 #ifdef CONFIG_PROC_FS
1615 * The /proc interfaces to multicast routing /proc/ip_mr_cache /proc/ip_mr_vif
1617 struct ipmr_vif_iter {
1621 static struct vif_device *ipmr_vif_seq_idx(struct ipmr_vif_iter *iter,
1624 for (iter->ct = 0; iter->ct < maxvif; ++iter->ct) {
1625 if (!VIF_EXISTS(iter->ct))
1628 return &vif_table[iter->ct];
1633 static void *ipmr_vif_seq_start(struct seq_file *seq, loff_t *pos)
1635 read_lock(&mrt_lock);
1636 return *pos ? ipmr_vif_seq_idx(seq->private, *pos - 1)
1640 static void *ipmr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1642 struct ipmr_vif_iter *iter = seq->private;
1645 if (v == SEQ_START_TOKEN)
1646 return ipmr_vif_seq_idx(iter, 0);
1648 while (++iter->ct < maxvif) {
1649 if (!VIF_EXISTS(iter->ct))
1651 return &vif_table[iter->ct];
1656 static void ipmr_vif_seq_stop(struct seq_file *seq, void *v)
1658 read_unlock(&mrt_lock);
1661 static int ipmr_vif_seq_show(struct seq_file *seq, void *v)
1663 if (v == SEQ_START_TOKEN) {
1665 "Interface BytesIn PktsIn BytesOut PktsOut Flags Local Remote\n");
1667 const struct vif_device *vif = v;
1668 const char *name = vif->dev ? vif->dev->name : "none";
1671 "%2Zd %-10s %8ld %7ld %8ld %7ld %05X %08X %08X\n",
1673 name, vif->bytes_in, vif->pkt_in,
1674 vif->bytes_out, vif->pkt_out,
1675 vif->flags, vif->local, vif->remote);
1680 static struct seq_operations ipmr_vif_seq_ops = {
1681 .start = ipmr_vif_seq_start,
1682 .next = ipmr_vif_seq_next,
1683 .stop = ipmr_vif_seq_stop,
1684 .show = ipmr_vif_seq_show,
1687 static int ipmr_vif_open(struct inode *inode, struct file *file)
1689 struct seq_file *seq;
1691 struct ipmr_vif_iter *s = kmalloc(sizeof(*s), GFP_KERNEL);
1696 rc = seq_open(file, &ipmr_vif_seq_ops);
1701 seq = file->private_data;
1711 static const struct file_operations ipmr_vif_fops = {
1712 .owner = THIS_MODULE,
1713 .open = ipmr_vif_open,
1715 .llseek = seq_lseek,
1716 .release = seq_release_private,
1719 struct ipmr_mfc_iter {
1720 struct mfc_cache **cache;
1725 static struct mfc_cache *ipmr_mfc_seq_idx(struct ipmr_mfc_iter *it, loff_t pos)
1727 struct mfc_cache *mfc;
1729 it->cache = mfc_cache_array;
1730 read_lock(&mrt_lock);
1731 for (it->ct = 0; it->ct < MFC_LINES; it->ct++)
1732 for (mfc = mfc_cache_array[it->ct]; mfc; mfc = mfc->next)
1735 read_unlock(&mrt_lock);
1737 it->cache = &mfc_unres_queue;
1738 spin_lock_bh(&mfc_unres_lock);
1739 for (mfc = mfc_unres_queue; mfc; mfc = mfc->next)
1742 spin_unlock_bh(&mfc_unres_lock);
1749 static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
1751 struct ipmr_mfc_iter *it = seq->private;
1754 return *pos ? ipmr_mfc_seq_idx(seq->private, *pos - 1)
1758 static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1760 struct mfc_cache *mfc = v;
1761 struct ipmr_mfc_iter *it = seq->private;
1765 if (v == SEQ_START_TOKEN)
1766 return ipmr_mfc_seq_idx(seq->private, 0);
1771 if (it->cache == &mfc_unres_queue)
1774 BUG_ON(it->cache != mfc_cache_array);
1776 while (++it->ct < MFC_LINES) {
1777 mfc = mfc_cache_array[it->ct];
1782 /* exhausted cache_array, show unresolved */
1783 read_unlock(&mrt_lock);
1784 it->cache = &mfc_unres_queue;
1787 spin_lock_bh(&mfc_unres_lock);
1788 mfc = mfc_unres_queue;
1793 spin_unlock_bh(&mfc_unres_lock);
1799 static void ipmr_mfc_seq_stop(struct seq_file *seq, void *v)
1801 struct ipmr_mfc_iter *it = seq->private;
1803 if (it->cache == &mfc_unres_queue)
1804 spin_unlock_bh(&mfc_unres_lock);
1805 else if (it->cache == mfc_cache_array)
1806 read_unlock(&mrt_lock);
1809 static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
1813 if (v == SEQ_START_TOKEN) {
1815 "Group Origin Iif Pkts Bytes Wrong Oifs\n");
1817 const struct mfc_cache *mfc = v;
1818 const struct ipmr_mfc_iter *it = seq->private;
1820 seq_printf(seq, "%08lX %08lX %-3d %8ld %8ld %8ld",
1821 (unsigned long) mfc->mfc_mcastgrp,
1822 (unsigned long) mfc->mfc_origin,
1824 mfc->mfc_un.res.pkt,
1825 mfc->mfc_un.res.bytes,
1826 mfc->mfc_un.res.wrong_if);
1828 if (it->cache != &mfc_unres_queue) {
1829 for (n = mfc->mfc_un.res.minvif;
1830 n < mfc->mfc_un.res.maxvif; n++ ) {
1832 && mfc->mfc_un.res.ttls[n] < 255)
1835 n, mfc->mfc_un.res.ttls[n]);
1838 seq_putc(seq, '\n');
1843 static struct seq_operations ipmr_mfc_seq_ops = {
1844 .start = ipmr_mfc_seq_start,
1845 .next = ipmr_mfc_seq_next,
1846 .stop = ipmr_mfc_seq_stop,
1847 .show = ipmr_mfc_seq_show,
1850 static int ipmr_mfc_open(struct inode *inode, struct file *file)
1852 struct seq_file *seq;
1854 struct ipmr_mfc_iter *s = kmalloc(sizeof(*s), GFP_KERNEL);
1859 rc = seq_open(file, &ipmr_mfc_seq_ops);
1863 seq = file->private_data;
1873 static const struct file_operations ipmr_mfc_fops = {
1874 .owner = THIS_MODULE,
1875 .open = ipmr_mfc_open,
1877 .llseek = seq_lseek,
1878 .release = seq_release_private,
1882 #ifdef CONFIG_IP_PIMSM_V2
1883 static struct net_protocol pim_protocol = {
1890 * Setup for IP multicast routing
1893 void __init ip_mr_init(void)
1895 mrt_cachep = kmem_cache_create("ip_mrt_cache",
1896 sizeof(struct mfc_cache),
1897 0, SLAB_HWCACHE_ALIGN|SLAB_PANIC,
1899 init_timer(&ipmr_expire_timer);
1900 ipmr_expire_timer.function=ipmr_expire_process;
1901 register_netdevice_notifier(&ip_mr_notifier);
1902 #ifdef CONFIG_PROC_FS
1903 proc_net_fops_create("ip_mr_vif", 0, &ipmr_vif_fops);
1904 proc_net_fops_create("ip_mr_cache", 0, &ipmr_mfc_fops);