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 skb_push(skb, sizeof(struct iphdr));
565 skb_reset_network_header(skb);
566 skb->h.raw = skb->data;
567 msg = (struct igmpmsg *)skb->nh.raw;
568 memcpy(msg, skb_network_header(pkt), sizeof(struct iphdr));
569 msg->im_msgtype = IGMPMSG_WHOLEPKT;
571 msg->im_vif = reg_vif_num;
572 skb->nh.iph->ihl = sizeof(struct iphdr) >> 2;
573 skb->nh.iph->tot_len = htons(ntohs(pkt->nh.iph->tot_len) + sizeof(struct iphdr));
582 skb->nh.iph = (struct iphdr *)skb_put(skb, ihl);
583 memcpy(skb->data,pkt->data,ihl);
584 skb->nh.iph->protocol = 0; /* Flag to the kernel this is a route add */
585 msg = (struct igmpmsg*)skb->nh.iph;
587 skb->dst = dst_clone(pkt->dst);
593 igmp=(struct igmphdr *)skb_put(skb,sizeof(struct igmphdr));
595 msg->im_msgtype = assert;
597 skb->nh.iph->tot_len=htons(skb->len); /* Fix the length */
598 skb->h.raw = skb->nh.raw;
601 if (mroute_socket == NULL) {
609 if ((ret=sock_queue_rcv_skb(mroute_socket,skb))<0) {
611 printk(KERN_WARNING "mroute: pending queue full, dropping entries.\n");
619 * Queue a packet for resolution. It gets locked cache entry!
623 ipmr_cache_unresolved(vifi_t vifi, struct sk_buff *skb)
628 spin_lock_bh(&mfc_unres_lock);
629 for (c=mfc_unres_queue; c; c=c->next) {
630 if (c->mfc_mcastgrp == skb->nh.iph->daddr &&
631 c->mfc_origin == skb->nh.iph->saddr)
637 * Create a new entry if allowable
640 if (atomic_read(&cache_resolve_queue_len)>=10 ||
641 (c=ipmr_cache_alloc_unres())==NULL) {
642 spin_unlock_bh(&mfc_unres_lock);
649 * Fill in the new cache entry
652 c->mfc_origin=skb->nh.iph->saddr;
653 c->mfc_mcastgrp=skb->nh.iph->daddr;
656 * Reflect first query at mrouted.
658 if ((err = ipmr_cache_report(skb, vifi, IGMPMSG_NOCACHE))<0) {
659 /* If the report failed throw the cache entry
662 spin_unlock_bh(&mfc_unres_lock);
664 kmem_cache_free(mrt_cachep, c);
669 atomic_inc(&cache_resolve_queue_len);
670 c->next = mfc_unres_queue;
673 mod_timer(&ipmr_expire_timer, c->mfc_un.unres.expires);
677 * See if we can append the packet
679 if (c->mfc_un.unres.unresolved.qlen>3) {
683 skb_queue_tail(&c->mfc_un.unres.unresolved,skb);
687 spin_unlock_bh(&mfc_unres_lock);
692 * MFC cache manipulation by user space mroute daemon
695 static int ipmr_mfc_delete(struct mfcctl *mfc)
698 struct mfc_cache *c, **cp;
700 line=MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr);
702 for (cp=&mfc_cache_array[line]; (c=*cp) != NULL; cp = &c->next) {
703 if (c->mfc_origin == mfc->mfcc_origin.s_addr &&
704 c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr) {
705 write_lock_bh(&mrt_lock);
707 write_unlock_bh(&mrt_lock);
709 kmem_cache_free(mrt_cachep, c);
716 static int ipmr_mfc_add(struct mfcctl *mfc, int mrtsock)
719 struct mfc_cache *uc, *c, **cp;
721 line=MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr);
723 for (cp=&mfc_cache_array[line]; (c=*cp) != NULL; cp = &c->next) {
724 if (c->mfc_origin == mfc->mfcc_origin.s_addr &&
725 c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr)
730 write_lock_bh(&mrt_lock);
731 c->mfc_parent = mfc->mfcc_parent;
732 ipmr_update_thresholds(c, mfc->mfcc_ttls);
734 c->mfc_flags |= MFC_STATIC;
735 write_unlock_bh(&mrt_lock);
739 if (!MULTICAST(mfc->mfcc_mcastgrp.s_addr))
742 c=ipmr_cache_alloc();
746 c->mfc_origin=mfc->mfcc_origin.s_addr;
747 c->mfc_mcastgrp=mfc->mfcc_mcastgrp.s_addr;
748 c->mfc_parent=mfc->mfcc_parent;
749 ipmr_update_thresholds(c, mfc->mfcc_ttls);
751 c->mfc_flags |= MFC_STATIC;
753 write_lock_bh(&mrt_lock);
754 c->next = mfc_cache_array[line];
755 mfc_cache_array[line] = c;
756 write_unlock_bh(&mrt_lock);
759 * Check to see if we resolved a queued list. If so we
760 * need to send on the frames and tidy up.
762 spin_lock_bh(&mfc_unres_lock);
763 for (cp = &mfc_unres_queue; (uc=*cp) != NULL;
765 if (uc->mfc_origin == c->mfc_origin &&
766 uc->mfc_mcastgrp == c->mfc_mcastgrp) {
768 if (atomic_dec_and_test(&cache_resolve_queue_len))
769 del_timer(&ipmr_expire_timer);
773 spin_unlock_bh(&mfc_unres_lock);
776 ipmr_cache_resolve(uc, c);
777 kmem_cache_free(mrt_cachep, uc);
783 * Close the multicast socket, and clear the vif tables etc
786 static void mroute_clean_tables(struct sock *sk)
791 * Shut down all active vif entries
793 for (i=0; i<maxvif; i++) {
794 if (!(vif_table[i].flags&VIFF_STATIC))
801 for (i=0;i<MFC_LINES;i++) {
802 struct mfc_cache *c, **cp;
804 cp = &mfc_cache_array[i];
805 while ((c = *cp) != NULL) {
806 if (c->mfc_flags&MFC_STATIC) {
810 write_lock_bh(&mrt_lock);
812 write_unlock_bh(&mrt_lock);
814 kmem_cache_free(mrt_cachep, c);
818 if (atomic_read(&cache_resolve_queue_len) != 0) {
821 spin_lock_bh(&mfc_unres_lock);
822 while (mfc_unres_queue != NULL) {
824 mfc_unres_queue = c->next;
825 spin_unlock_bh(&mfc_unres_lock);
827 ipmr_destroy_unres(c);
829 spin_lock_bh(&mfc_unres_lock);
831 spin_unlock_bh(&mfc_unres_lock);
835 static void mrtsock_destruct(struct sock *sk)
838 if (sk == mroute_socket) {
839 ipv4_devconf.mc_forwarding--;
841 write_lock_bh(&mrt_lock);
843 write_unlock_bh(&mrt_lock);
845 mroute_clean_tables(sk);
851 * Socket options and virtual interface manipulation. The whole
852 * virtual interface system is a complete heap, but unfortunately
853 * that's how BSD mrouted happens to think. Maybe one day with a proper
854 * MOSPF/PIM router set up we can clean this up.
857 int ip_mroute_setsockopt(struct sock *sk,int optname,char __user *optval,int optlen)
863 if (optname != MRT_INIT) {
864 if (sk != mroute_socket && !capable(CAP_NET_ADMIN))
870 if (sk->sk_type != SOCK_RAW ||
871 inet_sk(sk)->num != IPPROTO_IGMP)
873 if (optlen!=sizeof(int))
882 ret = ip_ra_control(sk, 1, mrtsock_destruct);
884 write_lock_bh(&mrt_lock);
886 write_unlock_bh(&mrt_lock);
888 ipv4_devconf.mc_forwarding++;
893 if (sk!=mroute_socket)
895 return ip_ra_control(sk, 0, NULL);
898 if (optlen!=sizeof(vif))
900 if (copy_from_user(&vif,optval,sizeof(vif)))
902 if (vif.vifc_vifi >= MAXVIFS)
905 if (optname==MRT_ADD_VIF) {
906 ret = vif_add(&vif, sk==mroute_socket);
908 ret = vif_delete(vif.vifc_vifi);
914 * Manipulate the forwarding caches. These live
915 * in a sort of kernel/user symbiosis.
919 if (optlen!=sizeof(mfc))
921 if (copy_from_user(&mfc,optval, sizeof(mfc)))
924 if (optname==MRT_DEL_MFC)
925 ret = ipmr_mfc_delete(&mfc);
927 ret = ipmr_mfc_add(&mfc, sk==mroute_socket);
931 * Control PIM assert.
936 if (get_user(v,(int __user *)optval))
938 mroute_do_assert=(v)?1:0;
941 #ifdef CONFIG_IP_PIMSM
945 if (get_user(v,(int __user *)optval))
950 if (v != mroute_do_pim) {
952 mroute_do_assert = v;
953 #ifdef CONFIG_IP_PIMSM_V2
955 ret = inet_add_protocol(&pim_protocol,
958 ret = inet_del_protocol(&pim_protocol,
969 * Spurious command, or MRT_VERSION which you cannot
978 * Getsock opt support for the multicast routing system.
981 int ip_mroute_getsockopt(struct sock *sk,int optname,char __user *optval,int __user *optlen)
986 if (optname!=MRT_VERSION &&
987 #ifdef CONFIG_IP_PIMSM
993 if (get_user(olr, optlen))
996 olr = min_t(unsigned int, olr, sizeof(int));
1000 if (put_user(olr,optlen))
1002 if (optname==MRT_VERSION)
1004 #ifdef CONFIG_IP_PIMSM
1005 else if (optname==MRT_PIM)
1009 val=mroute_do_assert;
1010 if (copy_to_user(optval,&val,olr))
1016 * The IP multicast ioctl support routines.
1019 int ipmr_ioctl(struct sock *sk, int cmd, void __user *arg)
1021 struct sioc_sg_req sr;
1022 struct sioc_vif_req vr;
1023 struct vif_device *vif;
1024 struct mfc_cache *c;
1028 if (copy_from_user(&vr,arg,sizeof(vr)))
1030 if (vr.vifi>=maxvif)
1032 read_lock(&mrt_lock);
1033 vif=&vif_table[vr.vifi];
1034 if (VIF_EXISTS(vr.vifi)) {
1035 vr.icount=vif->pkt_in;
1036 vr.ocount=vif->pkt_out;
1037 vr.ibytes=vif->bytes_in;
1038 vr.obytes=vif->bytes_out;
1039 read_unlock(&mrt_lock);
1041 if (copy_to_user(arg,&vr,sizeof(vr)))
1045 read_unlock(&mrt_lock);
1046 return -EADDRNOTAVAIL;
1048 if (copy_from_user(&sr,arg,sizeof(sr)))
1051 read_lock(&mrt_lock);
1052 c = ipmr_cache_find(sr.src.s_addr, sr.grp.s_addr);
1054 sr.pktcnt = c->mfc_un.res.pkt;
1055 sr.bytecnt = c->mfc_un.res.bytes;
1056 sr.wrong_if = c->mfc_un.res.wrong_if;
1057 read_unlock(&mrt_lock);
1059 if (copy_to_user(arg,&sr,sizeof(sr)))
1063 read_unlock(&mrt_lock);
1064 return -EADDRNOTAVAIL;
1066 return -ENOIOCTLCMD;
1071 static int ipmr_device_event(struct notifier_block *this, unsigned long event, void *ptr)
1073 struct vif_device *v;
1075 if (event != NETDEV_UNREGISTER)
1078 for (ct=0;ct<maxvif;ct++,v++) {
1086 static struct notifier_block ip_mr_notifier={
1087 .notifier_call = ipmr_device_event,
1091 * Encapsulate a packet by attaching a valid IPIP header to it.
1092 * This avoids tunnel drivers and other mess and gives us the speed so
1093 * important for multicast video.
1096 static void ip_encap(struct sk_buff *skb, __be32 saddr, __be32 daddr)
1100 skb_push(skb, sizeof(struct iphdr));
1101 skb->h.ipiph = skb->nh.iph;
1102 skb_reset_network_header(skb);
1106 iph->tos = skb->nh.iph->tos;
1107 iph->ttl = skb->nh.iph->ttl;
1111 iph->protocol = IPPROTO_IPIP;
1113 iph->tot_len = htons(skb->len);
1114 ip_select_ident(iph, skb->dst, NULL);
1117 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
1121 static inline int ipmr_forward_finish(struct sk_buff *skb)
1123 struct ip_options * opt = &(IPCB(skb)->opt);
1125 IP_INC_STATS_BH(IPSTATS_MIB_OUTFORWDATAGRAMS);
1127 if (unlikely(opt->optlen))
1128 ip_forward_options(skb);
1130 return dst_output(skb);
1134 * Processing handlers for ipmr_forward
1137 static void ipmr_queue_xmit(struct sk_buff *skb, struct mfc_cache *c, int vifi)
1139 struct iphdr *iph = skb->nh.iph;
1140 struct vif_device *vif = &vif_table[vifi];
1141 struct net_device *dev;
1145 if (vif->dev == NULL)
1148 #ifdef CONFIG_IP_PIMSM
1149 if (vif->flags & VIFF_REGISTER) {
1151 vif->bytes_out+=skb->len;
1152 ((struct net_device_stats*)netdev_priv(vif->dev))->tx_bytes += skb->len;
1153 ((struct net_device_stats*)netdev_priv(vif->dev))->tx_packets++;
1154 ipmr_cache_report(skb, vifi, IGMPMSG_WHOLEPKT);
1160 if (vif->flags&VIFF_TUNNEL) {
1161 struct flowi fl = { .oif = vif->link,
1163 { .daddr = vif->remote,
1164 .saddr = vif->local,
1165 .tos = RT_TOS(iph->tos) } },
1166 .proto = IPPROTO_IPIP };
1167 if (ip_route_output_key(&rt, &fl))
1169 encap = sizeof(struct iphdr);
1171 struct flowi fl = { .oif = vif->link,
1173 { .daddr = iph->daddr,
1174 .tos = RT_TOS(iph->tos) } },
1175 .proto = IPPROTO_IPIP };
1176 if (ip_route_output_key(&rt, &fl))
1180 dev = rt->u.dst.dev;
1182 if (skb->len+encap > dst_mtu(&rt->u.dst) && (ntohs(iph->frag_off) & IP_DF)) {
1183 /* Do not fragment multicasts. Alas, IPv4 does not
1184 allow to send ICMP, so that packets will disappear
1188 IP_INC_STATS_BH(IPSTATS_MIB_FRAGFAILS);
1193 encap += LL_RESERVED_SPACE(dev) + rt->u.dst.header_len;
1195 if (skb_cow(skb, encap)) {
1201 vif->bytes_out+=skb->len;
1203 dst_release(skb->dst);
1204 skb->dst = &rt->u.dst;
1206 ip_decrease_ttl(iph);
1208 /* FIXME: forward and output firewalls used to be called here.
1209 * What do we do with netfilter? -- RR */
1210 if (vif->flags & VIFF_TUNNEL) {
1211 ip_encap(skb, vif->local, vif->remote);
1212 /* FIXME: extra output firewall step used to be here. --RR */
1213 ((struct ip_tunnel *)netdev_priv(vif->dev))->stat.tx_packets++;
1214 ((struct ip_tunnel *)netdev_priv(vif->dev))->stat.tx_bytes+=skb->len;
1217 IPCB(skb)->flags |= IPSKB_FORWARDED;
1220 * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
1221 * not only before forwarding, but after forwarding on all output
1222 * interfaces. It is clear, if mrouter runs a multicasting
1223 * program, it should receive packets not depending to what interface
1224 * program is joined.
1225 * If we will not make it, the program will have to join on all
1226 * interfaces. On the other hand, multihoming host (or router, but
1227 * not mrouter) cannot join to more than one interface - it will
1228 * result in receiving multiple packets.
1230 NF_HOOK(PF_INET, NF_IP_FORWARD, skb, skb->dev, dev,
1231 ipmr_forward_finish);
1239 static int ipmr_find_vif(struct net_device *dev)
1242 for (ct=maxvif-1; ct>=0; ct--) {
1243 if (vif_table[ct].dev == dev)
1249 /* "local" means that we should preserve one skb (for local delivery) */
1251 static int ip_mr_forward(struct sk_buff *skb, struct mfc_cache *cache, int local)
1256 vif = cache->mfc_parent;
1257 cache->mfc_un.res.pkt++;
1258 cache->mfc_un.res.bytes += skb->len;
1261 * Wrong interface: drop packet and (maybe) send PIM assert.
1263 if (vif_table[vif].dev != skb->dev) {
1266 if (((struct rtable*)skb->dst)->fl.iif == 0) {
1267 /* It is our own packet, looped back.
1268 Very complicated situation...
1270 The best workaround until routing daemons will be
1271 fixed is not to redistribute packet, if it was
1272 send through wrong interface. It means, that
1273 multicast applications WILL NOT work for
1274 (S,G), which have default multicast route pointing
1275 to wrong oif. In any case, it is not a good
1276 idea to use multicasting applications on router.
1281 cache->mfc_un.res.wrong_if++;
1282 true_vifi = ipmr_find_vif(skb->dev);
1284 if (true_vifi >= 0 && mroute_do_assert &&
1285 /* pimsm uses asserts, when switching from RPT to SPT,
1286 so that we cannot check that packet arrived on an oif.
1287 It is bad, but otherwise we would need to move pretty
1288 large chunk of pimd to kernel. Ough... --ANK
1290 (mroute_do_pim || cache->mfc_un.res.ttls[true_vifi] < 255) &&
1292 cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
1293 cache->mfc_un.res.last_assert = jiffies;
1294 ipmr_cache_report(skb, true_vifi, IGMPMSG_WRONGVIF);
1299 vif_table[vif].pkt_in++;
1300 vif_table[vif].bytes_in+=skb->len;
1305 for (ct = cache->mfc_un.res.maxvif-1; ct >= cache->mfc_un.res.minvif; ct--) {
1306 if (skb->nh.iph->ttl > cache->mfc_un.res.ttls[ct]) {
1308 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1310 ipmr_queue_xmit(skb2, cache, psend);
1317 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1319 ipmr_queue_xmit(skb2, cache, psend);
1321 ipmr_queue_xmit(skb, cache, psend);
1334 * Multicast packets for forwarding arrive here
1337 int ip_mr_input(struct sk_buff *skb)
1339 struct mfc_cache *cache;
1340 int local = ((struct rtable*)skb->dst)->rt_flags&RTCF_LOCAL;
1342 /* Packet is looped back after forward, it should not be
1343 forwarded second time, but still can be delivered locally.
1345 if (IPCB(skb)->flags&IPSKB_FORWARDED)
1349 if (IPCB(skb)->opt.router_alert) {
1350 if (ip_call_ra_chain(skb))
1352 } else if (skb->nh.iph->protocol == IPPROTO_IGMP){
1353 /* IGMPv1 (and broken IGMPv2 implementations sort of
1354 Cisco IOS <= 11.2(8)) do not put router alert
1355 option to IGMP packets destined to routable
1356 groups. It is very bad, because it means
1357 that we can forward NO IGMP messages.
1359 read_lock(&mrt_lock);
1360 if (mroute_socket) {
1362 raw_rcv(mroute_socket, skb);
1363 read_unlock(&mrt_lock);
1366 read_unlock(&mrt_lock);
1370 read_lock(&mrt_lock);
1371 cache = ipmr_cache_find(skb->nh.iph->saddr, skb->nh.iph->daddr);
1374 * No usable cache entry
1380 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1381 ip_local_deliver(skb);
1383 read_unlock(&mrt_lock);
1389 vif = ipmr_find_vif(skb->dev);
1391 int err = ipmr_cache_unresolved(vif, skb);
1392 read_unlock(&mrt_lock);
1396 read_unlock(&mrt_lock);
1401 ip_mr_forward(skb, cache, local);
1403 read_unlock(&mrt_lock);
1406 return ip_local_deliver(skb);
1412 return ip_local_deliver(skb);
1417 #ifdef CONFIG_IP_PIMSM_V1
1419 * Handle IGMP messages of PIMv1
1422 int pim_rcv_v1(struct sk_buff * skb)
1424 struct igmphdr *pim;
1425 struct iphdr *encap;
1426 struct net_device *reg_dev = NULL;
1428 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
1431 pim = (struct igmphdr*)skb->h.raw;
1433 if (!mroute_do_pim ||
1434 skb->len < sizeof(*pim) + sizeof(*encap) ||
1435 pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
1438 encap = (struct iphdr*)(skb->h.raw + sizeof(struct igmphdr));
1441 a. packet is really destinted to a multicast group
1442 b. packet is not a NULL-REGISTER
1443 c. packet is not truncated
1445 if (!MULTICAST(encap->daddr) ||
1446 encap->tot_len == 0 ||
1447 ntohs(encap->tot_len) + sizeof(*pim) > skb->len)
1450 read_lock(&mrt_lock);
1451 if (reg_vif_num >= 0)
1452 reg_dev = vif_table[reg_vif_num].dev;
1455 read_unlock(&mrt_lock);
1457 if (reg_dev == NULL)
1460 skb->mac.raw = skb->nh.raw;
1461 skb_pull(skb, (u8*)encap - skb->data);
1462 skb_reset_network_header(skb);
1464 skb->protocol = htons(ETH_P_IP);
1466 skb->pkt_type = PACKET_HOST;
1467 dst_release(skb->dst);
1469 ((struct net_device_stats*)netdev_priv(reg_dev))->rx_bytes += skb->len;
1470 ((struct net_device_stats*)netdev_priv(reg_dev))->rx_packets++;
1481 #ifdef CONFIG_IP_PIMSM_V2
1482 static int pim_rcv(struct sk_buff * skb)
1484 struct pimreghdr *pim;
1485 struct iphdr *encap;
1486 struct net_device *reg_dev = NULL;
1488 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
1491 pim = (struct pimreghdr*)skb->h.raw;
1492 if (pim->type != ((PIM_VERSION<<4)|(PIM_REGISTER)) ||
1493 (pim->flags&PIM_NULL_REGISTER) ||
1494 (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
1495 csum_fold(skb_checksum(skb, 0, skb->len, 0))))
1498 /* check if the inner packet is destined to mcast group */
1499 encap = (struct iphdr*)(skb->h.raw + sizeof(struct pimreghdr));
1500 if (!MULTICAST(encap->daddr) ||
1501 encap->tot_len == 0 ||
1502 ntohs(encap->tot_len) + sizeof(*pim) > skb->len)
1505 read_lock(&mrt_lock);
1506 if (reg_vif_num >= 0)
1507 reg_dev = vif_table[reg_vif_num].dev;
1510 read_unlock(&mrt_lock);
1512 if (reg_dev == NULL)
1515 skb->mac.raw = skb->nh.raw;
1516 skb_pull(skb, (u8*)encap - skb->data);
1517 skb_reset_network_header(skb);
1519 skb->protocol = htons(ETH_P_IP);
1521 skb->pkt_type = PACKET_HOST;
1522 dst_release(skb->dst);
1523 ((struct net_device_stats*)netdev_priv(reg_dev))->rx_bytes += skb->len;
1524 ((struct net_device_stats*)netdev_priv(reg_dev))->rx_packets++;
1537 ipmr_fill_mroute(struct sk_buff *skb, struct mfc_cache *c, struct rtmsg *rtm)
1540 struct rtnexthop *nhp;
1541 struct net_device *dev = vif_table[c->mfc_parent].dev;
1543 struct rtattr *mp_head;
1546 RTA_PUT(skb, RTA_IIF, 4, &dev->ifindex);
1548 mp_head = (struct rtattr*)skb_put(skb, RTA_LENGTH(0));
1550 for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
1551 if (c->mfc_un.res.ttls[ct] < 255) {
1552 if (skb_tailroom(skb) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp)) + 4))
1553 goto rtattr_failure;
1554 nhp = (struct rtnexthop*)skb_put(skb, RTA_ALIGN(sizeof(*nhp)));
1555 nhp->rtnh_flags = 0;
1556 nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
1557 nhp->rtnh_ifindex = vif_table[ct].dev->ifindex;
1558 nhp->rtnh_len = sizeof(*nhp);
1561 mp_head->rta_type = RTA_MULTIPATH;
1562 mp_head->rta_len = skb->tail - (u8*)mp_head;
1563 rtm->rtm_type = RTN_MULTICAST;
1567 skb_trim(skb, b - skb->data);
1571 int ipmr_get_route(struct sk_buff *skb, struct rtmsg *rtm, int nowait)
1574 struct mfc_cache *cache;
1575 struct rtable *rt = (struct rtable*)skb->dst;
1577 read_lock(&mrt_lock);
1578 cache = ipmr_cache_find(rt->rt_src, rt->rt_dst);
1581 struct sk_buff *skb2;
1582 struct net_device *dev;
1586 read_unlock(&mrt_lock);
1591 if (dev == NULL || (vif = ipmr_find_vif(dev)) < 0) {
1592 read_unlock(&mrt_lock);
1595 skb2 = skb_clone(skb, GFP_ATOMIC);
1597 read_unlock(&mrt_lock);
1601 skb_push(skb2, sizeof(struct iphdr));
1602 skb_reset_network_header(skb2);
1603 skb2->nh.iph->ihl = sizeof(struct iphdr)>>2;
1604 skb2->nh.iph->saddr = rt->rt_src;
1605 skb2->nh.iph->daddr = rt->rt_dst;
1606 skb2->nh.iph->version = 0;
1607 err = ipmr_cache_unresolved(vif, skb2);
1608 read_unlock(&mrt_lock);
1612 if (!nowait && (rtm->rtm_flags&RTM_F_NOTIFY))
1613 cache->mfc_flags |= MFC_NOTIFY;
1614 err = ipmr_fill_mroute(skb, cache, rtm);
1615 read_unlock(&mrt_lock);
1619 #ifdef CONFIG_PROC_FS
1621 * The /proc interfaces to multicast routing /proc/ip_mr_cache /proc/ip_mr_vif
1623 struct ipmr_vif_iter {
1627 static struct vif_device *ipmr_vif_seq_idx(struct ipmr_vif_iter *iter,
1630 for (iter->ct = 0; iter->ct < maxvif; ++iter->ct) {
1631 if (!VIF_EXISTS(iter->ct))
1634 return &vif_table[iter->ct];
1639 static void *ipmr_vif_seq_start(struct seq_file *seq, loff_t *pos)
1641 read_lock(&mrt_lock);
1642 return *pos ? ipmr_vif_seq_idx(seq->private, *pos - 1)
1646 static void *ipmr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1648 struct ipmr_vif_iter *iter = seq->private;
1651 if (v == SEQ_START_TOKEN)
1652 return ipmr_vif_seq_idx(iter, 0);
1654 while (++iter->ct < maxvif) {
1655 if (!VIF_EXISTS(iter->ct))
1657 return &vif_table[iter->ct];
1662 static void ipmr_vif_seq_stop(struct seq_file *seq, void *v)
1664 read_unlock(&mrt_lock);
1667 static int ipmr_vif_seq_show(struct seq_file *seq, void *v)
1669 if (v == SEQ_START_TOKEN) {
1671 "Interface BytesIn PktsIn BytesOut PktsOut Flags Local Remote\n");
1673 const struct vif_device *vif = v;
1674 const char *name = vif->dev ? vif->dev->name : "none";
1677 "%2Zd %-10s %8ld %7ld %8ld %7ld %05X %08X %08X\n",
1679 name, vif->bytes_in, vif->pkt_in,
1680 vif->bytes_out, vif->pkt_out,
1681 vif->flags, vif->local, vif->remote);
1686 static const struct seq_operations ipmr_vif_seq_ops = {
1687 .start = ipmr_vif_seq_start,
1688 .next = ipmr_vif_seq_next,
1689 .stop = ipmr_vif_seq_stop,
1690 .show = ipmr_vif_seq_show,
1693 static int ipmr_vif_open(struct inode *inode, struct file *file)
1695 struct seq_file *seq;
1697 struct ipmr_vif_iter *s = kmalloc(sizeof(*s), GFP_KERNEL);
1702 rc = seq_open(file, &ipmr_vif_seq_ops);
1707 seq = file->private_data;
1717 static const struct file_operations ipmr_vif_fops = {
1718 .owner = THIS_MODULE,
1719 .open = ipmr_vif_open,
1721 .llseek = seq_lseek,
1722 .release = seq_release_private,
1725 struct ipmr_mfc_iter {
1726 struct mfc_cache **cache;
1731 static struct mfc_cache *ipmr_mfc_seq_idx(struct ipmr_mfc_iter *it, loff_t pos)
1733 struct mfc_cache *mfc;
1735 it->cache = mfc_cache_array;
1736 read_lock(&mrt_lock);
1737 for (it->ct = 0; it->ct < MFC_LINES; it->ct++)
1738 for (mfc = mfc_cache_array[it->ct]; mfc; mfc = mfc->next)
1741 read_unlock(&mrt_lock);
1743 it->cache = &mfc_unres_queue;
1744 spin_lock_bh(&mfc_unres_lock);
1745 for (mfc = mfc_unres_queue; mfc; mfc = mfc->next)
1748 spin_unlock_bh(&mfc_unres_lock);
1755 static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
1757 struct ipmr_mfc_iter *it = seq->private;
1760 return *pos ? ipmr_mfc_seq_idx(seq->private, *pos - 1)
1764 static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1766 struct mfc_cache *mfc = v;
1767 struct ipmr_mfc_iter *it = seq->private;
1771 if (v == SEQ_START_TOKEN)
1772 return ipmr_mfc_seq_idx(seq->private, 0);
1777 if (it->cache == &mfc_unres_queue)
1780 BUG_ON(it->cache != mfc_cache_array);
1782 while (++it->ct < MFC_LINES) {
1783 mfc = mfc_cache_array[it->ct];
1788 /* exhausted cache_array, show unresolved */
1789 read_unlock(&mrt_lock);
1790 it->cache = &mfc_unres_queue;
1793 spin_lock_bh(&mfc_unres_lock);
1794 mfc = mfc_unres_queue;
1799 spin_unlock_bh(&mfc_unres_lock);
1805 static void ipmr_mfc_seq_stop(struct seq_file *seq, void *v)
1807 struct ipmr_mfc_iter *it = seq->private;
1809 if (it->cache == &mfc_unres_queue)
1810 spin_unlock_bh(&mfc_unres_lock);
1811 else if (it->cache == mfc_cache_array)
1812 read_unlock(&mrt_lock);
1815 static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
1819 if (v == SEQ_START_TOKEN) {
1821 "Group Origin Iif Pkts Bytes Wrong Oifs\n");
1823 const struct mfc_cache *mfc = v;
1824 const struct ipmr_mfc_iter *it = seq->private;
1826 seq_printf(seq, "%08lX %08lX %-3d %8ld %8ld %8ld",
1827 (unsigned long) mfc->mfc_mcastgrp,
1828 (unsigned long) mfc->mfc_origin,
1830 mfc->mfc_un.res.pkt,
1831 mfc->mfc_un.res.bytes,
1832 mfc->mfc_un.res.wrong_if);
1834 if (it->cache != &mfc_unres_queue) {
1835 for (n = mfc->mfc_un.res.minvif;
1836 n < mfc->mfc_un.res.maxvif; n++ ) {
1838 && mfc->mfc_un.res.ttls[n] < 255)
1841 n, mfc->mfc_un.res.ttls[n]);
1844 seq_putc(seq, '\n');
1849 static const struct seq_operations ipmr_mfc_seq_ops = {
1850 .start = ipmr_mfc_seq_start,
1851 .next = ipmr_mfc_seq_next,
1852 .stop = ipmr_mfc_seq_stop,
1853 .show = ipmr_mfc_seq_show,
1856 static int ipmr_mfc_open(struct inode *inode, struct file *file)
1858 struct seq_file *seq;
1860 struct ipmr_mfc_iter *s = kmalloc(sizeof(*s), GFP_KERNEL);
1865 rc = seq_open(file, &ipmr_mfc_seq_ops);
1869 seq = file->private_data;
1879 static const struct file_operations ipmr_mfc_fops = {
1880 .owner = THIS_MODULE,
1881 .open = ipmr_mfc_open,
1883 .llseek = seq_lseek,
1884 .release = seq_release_private,
1888 #ifdef CONFIG_IP_PIMSM_V2
1889 static struct net_protocol pim_protocol = {
1896 * Setup for IP multicast routing
1899 void __init ip_mr_init(void)
1901 mrt_cachep = kmem_cache_create("ip_mrt_cache",
1902 sizeof(struct mfc_cache),
1903 0, SLAB_HWCACHE_ALIGN|SLAB_PANIC,
1905 init_timer(&ipmr_expire_timer);
1906 ipmr_expire_timer.function=ipmr_expire_process;
1907 register_netdevice_notifier(&ip_mr_notifier);
1908 #ifdef CONFIG_PROC_FS
1909 proc_net_fops_create("ip_mr_vif", 0, &ipmr_vif_fops);
1910 proc_net_fops_create("ip_mr_cache", 0, &ipmr_mfc_fops);