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 (ip_hdr(skb)->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 (ip_hdr(skb)->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 const int ihl = ip_hdrlen(pkt);
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 skb_push(skb, sizeof(struct iphdr));
565 skb_reset_network_header(skb);
566 skb_reset_transport_header(skb);
567 msg = (struct igmpmsg *)skb_network_header(skb);
568 memcpy(msg, skb_network_header(pkt), sizeof(struct iphdr));
569 msg->im_msgtype = IGMPMSG_WHOLEPKT;
571 msg->im_vif = reg_vif_num;
572 ip_hdr(skb)->ihl = sizeof(struct iphdr) >> 2;
573 ip_hdr(skb)->tot_len = htons(ntohs(ip_hdr(pkt)->tot_len) +
574 sizeof(struct iphdr));
583 skb_set_network_header(skb, skb->tail - skb->data);
585 memcpy(skb->data,pkt->data,ihl);
586 ip_hdr(skb)->protocol = 0; /* Flag to the kernel this is a route add */
587 msg = (struct igmpmsg *)skb_network_header(skb);
589 skb->dst = dst_clone(pkt->dst);
595 igmp=(struct igmphdr *)skb_put(skb,sizeof(struct igmphdr));
597 msg->im_msgtype = assert;
599 ip_hdr(skb)->tot_len = htons(skb->len); /* Fix the length */
600 skb->transport_header = skb->network_header;
603 if (mroute_socket == NULL) {
611 if ((ret=sock_queue_rcv_skb(mroute_socket,skb))<0) {
613 printk(KERN_WARNING "mroute: pending queue full, dropping entries.\n");
621 * Queue a packet for resolution. It gets locked cache entry!
625 ipmr_cache_unresolved(vifi_t vifi, struct sk_buff *skb)
629 const struct iphdr *iph = ip_hdr(skb);
631 spin_lock_bh(&mfc_unres_lock);
632 for (c=mfc_unres_queue; c; c=c->next) {
633 if (c->mfc_mcastgrp == iph->daddr &&
634 c->mfc_origin == iph->saddr)
640 * Create a new entry if allowable
643 if (atomic_read(&cache_resolve_queue_len)>=10 ||
644 (c=ipmr_cache_alloc_unres())==NULL) {
645 spin_unlock_bh(&mfc_unres_lock);
652 * Fill in the new cache entry
655 c->mfc_origin = iph->saddr;
656 c->mfc_mcastgrp = iph->daddr;
659 * Reflect first query at mrouted.
661 if ((err = ipmr_cache_report(skb, vifi, IGMPMSG_NOCACHE))<0) {
662 /* If the report failed throw the cache entry
665 spin_unlock_bh(&mfc_unres_lock);
667 kmem_cache_free(mrt_cachep, c);
672 atomic_inc(&cache_resolve_queue_len);
673 c->next = mfc_unres_queue;
676 mod_timer(&ipmr_expire_timer, c->mfc_un.unres.expires);
680 * See if we can append the packet
682 if (c->mfc_un.unres.unresolved.qlen>3) {
686 skb_queue_tail(&c->mfc_un.unres.unresolved,skb);
690 spin_unlock_bh(&mfc_unres_lock);
695 * MFC cache manipulation by user space mroute daemon
698 static int ipmr_mfc_delete(struct mfcctl *mfc)
701 struct mfc_cache *c, **cp;
703 line=MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr);
705 for (cp=&mfc_cache_array[line]; (c=*cp) != NULL; cp = &c->next) {
706 if (c->mfc_origin == mfc->mfcc_origin.s_addr &&
707 c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr) {
708 write_lock_bh(&mrt_lock);
710 write_unlock_bh(&mrt_lock);
712 kmem_cache_free(mrt_cachep, c);
719 static int ipmr_mfc_add(struct mfcctl *mfc, int mrtsock)
722 struct mfc_cache *uc, *c, **cp;
724 line=MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr);
726 for (cp=&mfc_cache_array[line]; (c=*cp) != NULL; cp = &c->next) {
727 if (c->mfc_origin == mfc->mfcc_origin.s_addr &&
728 c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr)
733 write_lock_bh(&mrt_lock);
734 c->mfc_parent = mfc->mfcc_parent;
735 ipmr_update_thresholds(c, mfc->mfcc_ttls);
737 c->mfc_flags |= MFC_STATIC;
738 write_unlock_bh(&mrt_lock);
742 if (!MULTICAST(mfc->mfcc_mcastgrp.s_addr))
745 c=ipmr_cache_alloc();
749 c->mfc_origin=mfc->mfcc_origin.s_addr;
750 c->mfc_mcastgrp=mfc->mfcc_mcastgrp.s_addr;
751 c->mfc_parent=mfc->mfcc_parent;
752 ipmr_update_thresholds(c, mfc->mfcc_ttls);
754 c->mfc_flags |= MFC_STATIC;
756 write_lock_bh(&mrt_lock);
757 c->next = mfc_cache_array[line];
758 mfc_cache_array[line] = c;
759 write_unlock_bh(&mrt_lock);
762 * Check to see if we resolved a queued list. If so we
763 * need to send on the frames and tidy up.
765 spin_lock_bh(&mfc_unres_lock);
766 for (cp = &mfc_unres_queue; (uc=*cp) != NULL;
768 if (uc->mfc_origin == c->mfc_origin &&
769 uc->mfc_mcastgrp == c->mfc_mcastgrp) {
771 if (atomic_dec_and_test(&cache_resolve_queue_len))
772 del_timer(&ipmr_expire_timer);
776 spin_unlock_bh(&mfc_unres_lock);
779 ipmr_cache_resolve(uc, c);
780 kmem_cache_free(mrt_cachep, uc);
786 * Close the multicast socket, and clear the vif tables etc
789 static void mroute_clean_tables(struct sock *sk)
794 * Shut down all active vif entries
796 for (i=0; i<maxvif; i++) {
797 if (!(vif_table[i].flags&VIFF_STATIC))
804 for (i=0;i<MFC_LINES;i++) {
805 struct mfc_cache *c, **cp;
807 cp = &mfc_cache_array[i];
808 while ((c = *cp) != NULL) {
809 if (c->mfc_flags&MFC_STATIC) {
813 write_lock_bh(&mrt_lock);
815 write_unlock_bh(&mrt_lock);
817 kmem_cache_free(mrt_cachep, c);
821 if (atomic_read(&cache_resolve_queue_len) != 0) {
824 spin_lock_bh(&mfc_unres_lock);
825 while (mfc_unres_queue != NULL) {
827 mfc_unres_queue = c->next;
828 spin_unlock_bh(&mfc_unres_lock);
830 ipmr_destroy_unres(c);
832 spin_lock_bh(&mfc_unres_lock);
834 spin_unlock_bh(&mfc_unres_lock);
838 static void mrtsock_destruct(struct sock *sk)
841 if (sk == mroute_socket) {
842 ipv4_devconf.mc_forwarding--;
844 write_lock_bh(&mrt_lock);
846 write_unlock_bh(&mrt_lock);
848 mroute_clean_tables(sk);
854 * Socket options and virtual interface manipulation. The whole
855 * virtual interface system is a complete heap, but unfortunately
856 * that's how BSD mrouted happens to think. Maybe one day with a proper
857 * MOSPF/PIM router set up we can clean this up.
860 int ip_mroute_setsockopt(struct sock *sk,int optname,char __user *optval,int optlen)
866 if (optname != MRT_INIT) {
867 if (sk != mroute_socket && !capable(CAP_NET_ADMIN))
873 if (sk->sk_type != SOCK_RAW ||
874 inet_sk(sk)->num != IPPROTO_IGMP)
876 if (optlen!=sizeof(int))
885 ret = ip_ra_control(sk, 1, mrtsock_destruct);
887 write_lock_bh(&mrt_lock);
889 write_unlock_bh(&mrt_lock);
891 ipv4_devconf.mc_forwarding++;
896 if (sk!=mroute_socket)
898 return ip_ra_control(sk, 0, NULL);
901 if (optlen!=sizeof(vif))
903 if (copy_from_user(&vif,optval,sizeof(vif)))
905 if (vif.vifc_vifi >= MAXVIFS)
908 if (optname==MRT_ADD_VIF) {
909 ret = vif_add(&vif, sk==mroute_socket);
911 ret = vif_delete(vif.vifc_vifi);
917 * Manipulate the forwarding caches. These live
918 * in a sort of kernel/user symbiosis.
922 if (optlen!=sizeof(mfc))
924 if (copy_from_user(&mfc,optval, sizeof(mfc)))
927 if (optname==MRT_DEL_MFC)
928 ret = ipmr_mfc_delete(&mfc);
930 ret = ipmr_mfc_add(&mfc, sk==mroute_socket);
934 * Control PIM assert.
939 if (get_user(v,(int __user *)optval))
941 mroute_do_assert=(v)?1:0;
944 #ifdef CONFIG_IP_PIMSM
948 if (get_user(v,(int __user *)optval))
953 if (v != mroute_do_pim) {
955 mroute_do_assert = v;
956 #ifdef CONFIG_IP_PIMSM_V2
958 ret = inet_add_protocol(&pim_protocol,
961 ret = inet_del_protocol(&pim_protocol,
972 * Spurious command, or MRT_VERSION which you cannot
981 * Getsock opt support for the multicast routing system.
984 int ip_mroute_getsockopt(struct sock *sk,int optname,char __user *optval,int __user *optlen)
989 if (optname!=MRT_VERSION &&
990 #ifdef CONFIG_IP_PIMSM
996 if (get_user(olr, optlen))
999 olr = min_t(unsigned int, olr, sizeof(int));
1003 if (put_user(olr,optlen))
1005 if (optname==MRT_VERSION)
1007 #ifdef CONFIG_IP_PIMSM
1008 else if (optname==MRT_PIM)
1012 val=mroute_do_assert;
1013 if (copy_to_user(optval,&val,olr))
1019 * The IP multicast ioctl support routines.
1022 int ipmr_ioctl(struct sock *sk, int cmd, void __user *arg)
1024 struct sioc_sg_req sr;
1025 struct sioc_vif_req vr;
1026 struct vif_device *vif;
1027 struct mfc_cache *c;
1031 if (copy_from_user(&vr,arg,sizeof(vr)))
1033 if (vr.vifi>=maxvif)
1035 read_lock(&mrt_lock);
1036 vif=&vif_table[vr.vifi];
1037 if (VIF_EXISTS(vr.vifi)) {
1038 vr.icount=vif->pkt_in;
1039 vr.ocount=vif->pkt_out;
1040 vr.ibytes=vif->bytes_in;
1041 vr.obytes=vif->bytes_out;
1042 read_unlock(&mrt_lock);
1044 if (copy_to_user(arg,&vr,sizeof(vr)))
1048 read_unlock(&mrt_lock);
1049 return -EADDRNOTAVAIL;
1051 if (copy_from_user(&sr,arg,sizeof(sr)))
1054 read_lock(&mrt_lock);
1055 c = ipmr_cache_find(sr.src.s_addr, sr.grp.s_addr);
1057 sr.pktcnt = c->mfc_un.res.pkt;
1058 sr.bytecnt = c->mfc_un.res.bytes;
1059 sr.wrong_if = c->mfc_un.res.wrong_if;
1060 read_unlock(&mrt_lock);
1062 if (copy_to_user(arg,&sr,sizeof(sr)))
1066 read_unlock(&mrt_lock);
1067 return -EADDRNOTAVAIL;
1069 return -ENOIOCTLCMD;
1074 static int ipmr_device_event(struct notifier_block *this, unsigned long event, void *ptr)
1076 struct vif_device *v;
1078 if (event != NETDEV_UNREGISTER)
1081 for (ct=0;ct<maxvif;ct++,v++) {
1089 static struct notifier_block ip_mr_notifier={
1090 .notifier_call = ipmr_device_event,
1094 * Encapsulate a packet by attaching a valid IPIP header to it.
1095 * This avoids tunnel drivers and other mess and gives us the speed so
1096 * important for multicast video.
1099 static void ip_encap(struct sk_buff *skb, __be32 saddr, __be32 daddr)
1102 struct iphdr *old_iph = ip_hdr(skb);
1104 skb_push(skb, sizeof(struct iphdr));
1105 skb->transport_header = skb->network_header;
1106 skb_reset_network_header(skb);
1110 iph->tos = old_iph->tos;
1111 iph->ttl = old_iph->ttl;
1115 iph->protocol = IPPROTO_IPIP;
1117 iph->tot_len = htons(skb->len);
1118 ip_select_ident(iph, skb->dst, NULL);
1121 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
1125 static inline int ipmr_forward_finish(struct sk_buff *skb)
1127 struct ip_options * opt = &(IPCB(skb)->opt);
1129 IP_INC_STATS_BH(IPSTATS_MIB_OUTFORWDATAGRAMS);
1131 if (unlikely(opt->optlen))
1132 ip_forward_options(skb);
1134 return dst_output(skb);
1138 * Processing handlers for ipmr_forward
1141 static void ipmr_queue_xmit(struct sk_buff *skb, struct mfc_cache *c, int vifi)
1143 const struct iphdr *iph = ip_hdr(skb);
1144 struct vif_device *vif = &vif_table[vifi];
1145 struct net_device *dev;
1149 if (vif->dev == NULL)
1152 #ifdef CONFIG_IP_PIMSM
1153 if (vif->flags & VIFF_REGISTER) {
1155 vif->bytes_out+=skb->len;
1156 ((struct net_device_stats*)netdev_priv(vif->dev))->tx_bytes += skb->len;
1157 ((struct net_device_stats*)netdev_priv(vif->dev))->tx_packets++;
1158 ipmr_cache_report(skb, vifi, IGMPMSG_WHOLEPKT);
1164 if (vif->flags&VIFF_TUNNEL) {
1165 struct flowi fl = { .oif = vif->link,
1167 { .daddr = vif->remote,
1168 .saddr = vif->local,
1169 .tos = RT_TOS(iph->tos) } },
1170 .proto = IPPROTO_IPIP };
1171 if (ip_route_output_key(&rt, &fl))
1173 encap = sizeof(struct iphdr);
1175 struct flowi fl = { .oif = vif->link,
1177 { .daddr = iph->daddr,
1178 .tos = RT_TOS(iph->tos) } },
1179 .proto = IPPROTO_IPIP };
1180 if (ip_route_output_key(&rt, &fl))
1184 dev = rt->u.dst.dev;
1186 if (skb->len+encap > dst_mtu(&rt->u.dst) && (ntohs(iph->frag_off) & IP_DF)) {
1187 /* Do not fragment multicasts. Alas, IPv4 does not
1188 allow to send ICMP, so that packets will disappear
1192 IP_INC_STATS_BH(IPSTATS_MIB_FRAGFAILS);
1197 encap += LL_RESERVED_SPACE(dev) + rt->u.dst.header_len;
1199 if (skb_cow(skb, encap)) {
1205 vif->bytes_out+=skb->len;
1207 dst_release(skb->dst);
1208 skb->dst = &rt->u.dst;
1209 ip_decrease_ttl(ip_hdr(skb));
1211 /* FIXME: forward and output firewalls used to be called here.
1212 * What do we do with netfilter? -- RR */
1213 if (vif->flags & VIFF_TUNNEL) {
1214 ip_encap(skb, vif->local, vif->remote);
1215 /* FIXME: extra output firewall step used to be here. --RR */
1216 ((struct ip_tunnel *)netdev_priv(vif->dev))->stat.tx_packets++;
1217 ((struct ip_tunnel *)netdev_priv(vif->dev))->stat.tx_bytes+=skb->len;
1220 IPCB(skb)->flags |= IPSKB_FORWARDED;
1223 * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
1224 * not only before forwarding, but after forwarding on all output
1225 * interfaces. It is clear, if mrouter runs a multicasting
1226 * program, it should receive packets not depending to what interface
1227 * program is joined.
1228 * If we will not make it, the program will have to join on all
1229 * interfaces. On the other hand, multihoming host (or router, but
1230 * not mrouter) cannot join to more than one interface - it will
1231 * result in receiving multiple packets.
1233 NF_HOOK(PF_INET, NF_IP_FORWARD, skb, skb->dev, dev,
1234 ipmr_forward_finish);
1242 static int ipmr_find_vif(struct net_device *dev)
1245 for (ct=maxvif-1; ct>=0; ct--) {
1246 if (vif_table[ct].dev == dev)
1252 /* "local" means that we should preserve one skb (for local delivery) */
1254 static int ip_mr_forward(struct sk_buff *skb, struct mfc_cache *cache, int local)
1259 vif = cache->mfc_parent;
1260 cache->mfc_un.res.pkt++;
1261 cache->mfc_un.res.bytes += skb->len;
1264 * Wrong interface: drop packet and (maybe) send PIM assert.
1266 if (vif_table[vif].dev != skb->dev) {
1269 if (((struct rtable*)skb->dst)->fl.iif == 0) {
1270 /* It is our own packet, looped back.
1271 Very complicated situation...
1273 The best workaround until routing daemons will be
1274 fixed is not to redistribute packet, if it was
1275 send through wrong interface. It means, that
1276 multicast applications WILL NOT work for
1277 (S,G), which have default multicast route pointing
1278 to wrong oif. In any case, it is not a good
1279 idea to use multicasting applications on router.
1284 cache->mfc_un.res.wrong_if++;
1285 true_vifi = ipmr_find_vif(skb->dev);
1287 if (true_vifi >= 0 && mroute_do_assert &&
1288 /* pimsm uses asserts, when switching from RPT to SPT,
1289 so that we cannot check that packet arrived on an oif.
1290 It is bad, but otherwise we would need to move pretty
1291 large chunk of pimd to kernel. Ough... --ANK
1293 (mroute_do_pim || cache->mfc_un.res.ttls[true_vifi] < 255) &&
1295 cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
1296 cache->mfc_un.res.last_assert = jiffies;
1297 ipmr_cache_report(skb, true_vifi, IGMPMSG_WRONGVIF);
1302 vif_table[vif].pkt_in++;
1303 vif_table[vif].bytes_in+=skb->len;
1308 for (ct = cache->mfc_un.res.maxvif-1; ct >= cache->mfc_un.res.minvif; ct--) {
1309 if (ip_hdr(skb)->ttl > cache->mfc_un.res.ttls[ct]) {
1311 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1313 ipmr_queue_xmit(skb2, cache, psend);
1320 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1322 ipmr_queue_xmit(skb2, cache, psend);
1324 ipmr_queue_xmit(skb, cache, psend);
1337 * Multicast packets for forwarding arrive here
1340 int ip_mr_input(struct sk_buff *skb)
1342 struct mfc_cache *cache;
1343 int local = ((struct rtable*)skb->dst)->rt_flags&RTCF_LOCAL;
1345 /* Packet is looped back after forward, it should not be
1346 forwarded second time, but still can be delivered locally.
1348 if (IPCB(skb)->flags&IPSKB_FORWARDED)
1352 if (IPCB(skb)->opt.router_alert) {
1353 if (ip_call_ra_chain(skb))
1355 } else if (ip_hdr(skb)->protocol == IPPROTO_IGMP){
1356 /* IGMPv1 (and broken IGMPv2 implementations sort of
1357 Cisco IOS <= 11.2(8)) do not put router alert
1358 option to IGMP packets destined to routable
1359 groups. It is very bad, because it means
1360 that we can forward NO IGMP messages.
1362 read_lock(&mrt_lock);
1363 if (mroute_socket) {
1365 raw_rcv(mroute_socket, skb);
1366 read_unlock(&mrt_lock);
1369 read_unlock(&mrt_lock);
1373 read_lock(&mrt_lock);
1374 cache = ipmr_cache_find(ip_hdr(skb)->saddr, ip_hdr(skb)->daddr);
1377 * No usable cache entry
1383 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1384 ip_local_deliver(skb);
1386 read_unlock(&mrt_lock);
1392 vif = ipmr_find_vif(skb->dev);
1394 int err = ipmr_cache_unresolved(vif, skb);
1395 read_unlock(&mrt_lock);
1399 read_unlock(&mrt_lock);
1404 ip_mr_forward(skb, cache, local);
1406 read_unlock(&mrt_lock);
1409 return ip_local_deliver(skb);
1415 return ip_local_deliver(skb);
1420 #ifdef CONFIG_IP_PIMSM_V1
1422 * Handle IGMP messages of PIMv1
1425 int pim_rcv_v1(struct sk_buff * skb)
1427 struct igmphdr *pim;
1428 struct iphdr *encap;
1429 struct net_device *reg_dev = NULL;
1431 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
1434 pim = igmp_hdr(skb);
1436 if (!mroute_do_pim ||
1437 skb->len < sizeof(*pim) + sizeof(*encap) ||
1438 pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
1441 encap = (struct iphdr *)(skb_transport_header(skb) +
1442 sizeof(struct igmphdr));
1445 a. packet is really destinted to a multicast group
1446 b. packet is not a NULL-REGISTER
1447 c. packet is not truncated
1449 if (!MULTICAST(encap->daddr) ||
1450 encap->tot_len == 0 ||
1451 ntohs(encap->tot_len) + sizeof(*pim) > skb->len)
1454 read_lock(&mrt_lock);
1455 if (reg_vif_num >= 0)
1456 reg_dev = vif_table[reg_vif_num].dev;
1459 read_unlock(&mrt_lock);
1461 if (reg_dev == NULL)
1464 skb->mac_header = skb->network_header;
1465 skb_pull(skb, (u8*)encap - skb->data);
1466 skb_reset_network_header(skb);
1468 skb->protocol = htons(ETH_P_IP);
1470 skb->pkt_type = PACKET_HOST;
1471 dst_release(skb->dst);
1473 ((struct net_device_stats*)netdev_priv(reg_dev))->rx_bytes += skb->len;
1474 ((struct net_device_stats*)netdev_priv(reg_dev))->rx_packets++;
1485 #ifdef CONFIG_IP_PIMSM_V2
1486 static int pim_rcv(struct sk_buff * skb)
1488 struct pimreghdr *pim;
1489 struct iphdr *encap;
1490 struct net_device *reg_dev = NULL;
1492 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
1495 pim = (struct pimreghdr *)skb_transport_header(skb);
1496 if (pim->type != ((PIM_VERSION<<4)|(PIM_REGISTER)) ||
1497 (pim->flags&PIM_NULL_REGISTER) ||
1498 (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
1499 csum_fold(skb_checksum(skb, 0, skb->len, 0))))
1502 /* check if the inner packet is destined to mcast group */
1503 encap = (struct iphdr *)(skb_transport_header(skb) +
1504 sizeof(struct pimreghdr));
1505 if (!MULTICAST(encap->daddr) ||
1506 encap->tot_len == 0 ||
1507 ntohs(encap->tot_len) + sizeof(*pim) > skb->len)
1510 read_lock(&mrt_lock);
1511 if (reg_vif_num >= 0)
1512 reg_dev = vif_table[reg_vif_num].dev;
1515 read_unlock(&mrt_lock);
1517 if (reg_dev == NULL)
1520 skb->mac_header = skb->network_header;
1521 skb_pull(skb, (u8*)encap - skb->data);
1522 skb_reset_network_header(skb);
1524 skb->protocol = htons(ETH_P_IP);
1526 skb->pkt_type = PACKET_HOST;
1527 dst_release(skb->dst);
1528 ((struct net_device_stats*)netdev_priv(reg_dev))->rx_bytes += skb->len;
1529 ((struct net_device_stats*)netdev_priv(reg_dev))->rx_packets++;
1542 ipmr_fill_mroute(struct sk_buff *skb, struct mfc_cache *c, struct rtmsg *rtm)
1545 struct rtnexthop *nhp;
1546 struct net_device *dev = vif_table[c->mfc_parent].dev;
1548 struct rtattr *mp_head;
1551 RTA_PUT(skb, RTA_IIF, 4, &dev->ifindex);
1553 mp_head = (struct rtattr*)skb_put(skb, RTA_LENGTH(0));
1555 for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
1556 if (c->mfc_un.res.ttls[ct] < 255) {
1557 if (skb_tailroom(skb) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp)) + 4))
1558 goto rtattr_failure;
1559 nhp = (struct rtnexthop*)skb_put(skb, RTA_ALIGN(sizeof(*nhp)));
1560 nhp->rtnh_flags = 0;
1561 nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
1562 nhp->rtnh_ifindex = vif_table[ct].dev->ifindex;
1563 nhp->rtnh_len = sizeof(*nhp);
1566 mp_head->rta_type = RTA_MULTIPATH;
1567 mp_head->rta_len = skb->tail - (u8*)mp_head;
1568 rtm->rtm_type = RTN_MULTICAST;
1572 skb_trim(skb, b - skb->data);
1576 int ipmr_get_route(struct sk_buff *skb, struct rtmsg *rtm, int nowait)
1579 struct mfc_cache *cache;
1580 struct rtable *rt = (struct rtable*)skb->dst;
1582 read_lock(&mrt_lock);
1583 cache = ipmr_cache_find(rt->rt_src, rt->rt_dst);
1586 struct sk_buff *skb2;
1588 struct net_device *dev;
1592 read_unlock(&mrt_lock);
1597 if (dev == NULL || (vif = ipmr_find_vif(dev)) < 0) {
1598 read_unlock(&mrt_lock);
1601 skb2 = skb_clone(skb, GFP_ATOMIC);
1603 read_unlock(&mrt_lock);
1607 skb_push(skb2, sizeof(struct iphdr));
1608 skb_reset_network_header(skb2);
1610 iph->ihl = sizeof(struct iphdr) >> 2;
1611 iph->saddr = rt->rt_src;
1612 iph->daddr = rt->rt_dst;
1614 err = ipmr_cache_unresolved(vif, skb2);
1615 read_unlock(&mrt_lock);
1619 if (!nowait && (rtm->rtm_flags&RTM_F_NOTIFY))
1620 cache->mfc_flags |= MFC_NOTIFY;
1621 err = ipmr_fill_mroute(skb, cache, rtm);
1622 read_unlock(&mrt_lock);
1626 #ifdef CONFIG_PROC_FS
1628 * The /proc interfaces to multicast routing /proc/ip_mr_cache /proc/ip_mr_vif
1630 struct ipmr_vif_iter {
1634 static struct vif_device *ipmr_vif_seq_idx(struct ipmr_vif_iter *iter,
1637 for (iter->ct = 0; iter->ct < maxvif; ++iter->ct) {
1638 if (!VIF_EXISTS(iter->ct))
1641 return &vif_table[iter->ct];
1646 static void *ipmr_vif_seq_start(struct seq_file *seq, loff_t *pos)
1648 read_lock(&mrt_lock);
1649 return *pos ? ipmr_vif_seq_idx(seq->private, *pos - 1)
1653 static void *ipmr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1655 struct ipmr_vif_iter *iter = seq->private;
1658 if (v == SEQ_START_TOKEN)
1659 return ipmr_vif_seq_idx(iter, 0);
1661 while (++iter->ct < maxvif) {
1662 if (!VIF_EXISTS(iter->ct))
1664 return &vif_table[iter->ct];
1669 static void ipmr_vif_seq_stop(struct seq_file *seq, void *v)
1671 read_unlock(&mrt_lock);
1674 static int ipmr_vif_seq_show(struct seq_file *seq, void *v)
1676 if (v == SEQ_START_TOKEN) {
1678 "Interface BytesIn PktsIn BytesOut PktsOut Flags Local Remote\n");
1680 const struct vif_device *vif = v;
1681 const char *name = vif->dev ? vif->dev->name : "none";
1684 "%2Zd %-10s %8ld %7ld %8ld %7ld %05X %08X %08X\n",
1686 name, vif->bytes_in, vif->pkt_in,
1687 vif->bytes_out, vif->pkt_out,
1688 vif->flags, vif->local, vif->remote);
1693 static const struct seq_operations ipmr_vif_seq_ops = {
1694 .start = ipmr_vif_seq_start,
1695 .next = ipmr_vif_seq_next,
1696 .stop = ipmr_vif_seq_stop,
1697 .show = ipmr_vif_seq_show,
1700 static int ipmr_vif_open(struct inode *inode, struct file *file)
1702 struct seq_file *seq;
1704 struct ipmr_vif_iter *s = kmalloc(sizeof(*s), GFP_KERNEL);
1709 rc = seq_open(file, &ipmr_vif_seq_ops);
1714 seq = file->private_data;
1724 static const struct file_operations ipmr_vif_fops = {
1725 .owner = THIS_MODULE,
1726 .open = ipmr_vif_open,
1728 .llseek = seq_lseek,
1729 .release = seq_release_private,
1732 struct ipmr_mfc_iter {
1733 struct mfc_cache **cache;
1738 static struct mfc_cache *ipmr_mfc_seq_idx(struct ipmr_mfc_iter *it, loff_t pos)
1740 struct mfc_cache *mfc;
1742 it->cache = mfc_cache_array;
1743 read_lock(&mrt_lock);
1744 for (it->ct = 0; it->ct < MFC_LINES; it->ct++)
1745 for (mfc = mfc_cache_array[it->ct]; mfc; mfc = mfc->next)
1748 read_unlock(&mrt_lock);
1750 it->cache = &mfc_unres_queue;
1751 spin_lock_bh(&mfc_unres_lock);
1752 for (mfc = mfc_unres_queue; mfc; mfc = mfc->next)
1755 spin_unlock_bh(&mfc_unres_lock);
1762 static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
1764 struct ipmr_mfc_iter *it = seq->private;
1767 return *pos ? ipmr_mfc_seq_idx(seq->private, *pos - 1)
1771 static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1773 struct mfc_cache *mfc = v;
1774 struct ipmr_mfc_iter *it = seq->private;
1778 if (v == SEQ_START_TOKEN)
1779 return ipmr_mfc_seq_idx(seq->private, 0);
1784 if (it->cache == &mfc_unres_queue)
1787 BUG_ON(it->cache != mfc_cache_array);
1789 while (++it->ct < MFC_LINES) {
1790 mfc = mfc_cache_array[it->ct];
1795 /* exhausted cache_array, show unresolved */
1796 read_unlock(&mrt_lock);
1797 it->cache = &mfc_unres_queue;
1800 spin_lock_bh(&mfc_unres_lock);
1801 mfc = mfc_unres_queue;
1806 spin_unlock_bh(&mfc_unres_lock);
1812 static void ipmr_mfc_seq_stop(struct seq_file *seq, void *v)
1814 struct ipmr_mfc_iter *it = seq->private;
1816 if (it->cache == &mfc_unres_queue)
1817 spin_unlock_bh(&mfc_unres_lock);
1818 else if (it->cache == mfc_cache_array)
1819 read_unlock(&mrt_lock);
1822 static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
1826 if (v == SEQ_START_TOKEN) {
1828 "Group Origin Iif Pkts Bytes Wrong Oifs\n");
1830 const struct mfc_cache *mfc = v;
1831 const struct ipmr_mfc_iter *it = seq->private;
1833 seq_printf(seq, "%08lX %08lX %-3d %8ld %8ld %8ld",
1834 (unsigned long) mfc->mfc_mcastgrp,
1835 (unsigned long) mfc->mfc_origin,
1837 mfc->mfc_un.res.pkt,
1838 mfc->mfc_un.res.bytes,
1839 mfc->mfc_un.res.wrong_if);
1841 if (it->cache != &mfc_unres_queue) {
1842 for (n = mfc->mfc_un.res.minvif;
1843 n < mfc->mfc_un.res.maxvif; n++ ) {
1845 && mfc->mfc_un.res.ttls[n] < 255)
1848 n, mfc->mfc_un.res.ttls[n]);
1851 seq_putc(seq, '\n');
1856 static const struct seq_operations ipmr_mfc_seq_ops = {
1857 .start = ipmr_mfc_seq_start,
1858 .next = ipmr_mfc_seq_next,
1859 .stop = ipmr_mfc_seq_stop,
1860 .show = ipmr_mfc_seq_show,
1863 static int ipmr_mfc_open(struct inode *inode, struct file *file)
1865 struct seq_file *seq;
1867 struct ipmr_mfc_iter *s = kmalloc(sizeof(*s), GFP_KERNEL);
1872 rc = seq_open(file, &ipmr_mfc_seq_ops);
1876 seq = file->private_data;
1886 static const struct file_operations ipmr_mfc_fops = {
1887 .owner = THIS_MODULE,
1888 .open = ipmr_mfc_open,
1890 .llseek = seq_lseek,
1891 .release = seq_release_private,
1895 #ifdef CONFIG_IP_PIMSM_V2
1896 static struct net_protocol pim_protocol = {
1903 * Setup for IP multicast routing
1906 void __init ip_mr_init(void)
1908 mrt_cachep = kmem_cache_create("ip_mrt_cache",
1909 sizeof(struct mfc_cache),
1910 0, SLAB_HWCACHE_ALIGN|SLAB_PANIC,
1912 init_timer(&ipmr_expire_timer);
1913 ipmr_expire_timer.function=ipmr_expire_process;
1914 register_netdevice_notifier(&ip_mr_notifier);
1915 #ifdef CONFIG_PROC_FS
1916 proc_net_fops_create("ip_mr_vif", 0, &ipmr_vif_fops);
1917 proc_net_fops_create("ip_mr_cache", 0, &ipmr_mfc_fops);