11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * IP multicast routing support for mrouted 3.6/3.8 31da177e4SLinus Torvalds * 4113aa838SAlan Cox * (c) 1995 Alan Cox, <alan@lxorguk.ukuu.org.uk> 51da177e4SLinus Torvalds * Linux Consultancy and Custom Driver Development 61da177e4SLinus Torvalds * 71da177e4SLinus Torvalds * This program is free software; you can redistribute it and/or 81da177e4SLinus Torvalds * modify it under the terms of the GNU General Public License 91da177e4SLinus Torvalds * as published by the Free Software Foundation; either version 101da177e4SLinus Torvalds * 2 of the License, or (at your option) any later version. 111da177e4SLinus Torvalds * 121da177e4SLinus Torvalds * Fixes: 131da177e4SLinus Torvalds * Michael Chastain : Incorrect size of copying. 141da177e4SLinus Torvalds * Alan Cox : Added the cache manager code 151da177e4SLinus Torvalds * Alan Cox : Fixed the clone/copy bug and device race. 161da177e4SLinus Torvalds * Mike McLagan : Routing by source 171da177e4SLinus Torvalds * Malcolm Beattie : Buffer handling fixes. 181da177e4SLinus Torvalds * Alexey Kuznetsov : Double buffer free and other fixes. 191da177e4SLinus Torvalds * SVR Anand : Fixed several multicast bugs and problems. 201da177e4SLinus Torvalds * Alexey Kuznetsov : Status, optimisations and more. 211da177e4SLinus Torvalds * Brad Parker : Better behaviour on mrouted upcall 221da177e4SLinus Torvalds * overflow. 231da177e4SLinus Torvalds * Carlos Picoto : PIMv1 Support 241da177e4SLinus Torvalds * Pavlin Ivanov Radoslavov: PIMv2 Registers must checksum only PIM header 251da177e4SLinus Torvalds * Relax this requrement to work with older peers. 261da177e4SLinus Torvalds * 271da177e4SLinus Torvalds */ 281da177e4SLinus Torvalds 291da177e4SLinus Torvalds #include <asm/system.h> 301da177e4SLinus Torvalds #include <asm/uaccess.h> 311da177e4SLinus Torvalds #include <linux/types.h> 324fc268d2SRandy Dunlap #include <linux/capability.h> 331da177e4SLinus Torvalds #include <linux/errno.h> 341da177e4SLinus Torvalds #include <linux/timer.h> 351da177e4SLinus Torvalds #include <linux/mm.h> 361da177e4SLinus Torvalds #include <linux/kernel.h> 371da177e4SLinus Torvalds #include <linux/fcntl.h> 381da177e4SLinus Torvalds #include <linux/stat.h> 391da177e4SLinus Torvalds #include <linux/socket.h> 401da177e4SLinus Torvalds #include <linux/in.h> 411da177e4SLinus Torvalds #include <linux/inet.h> 421da177e4SLinus Torvalds #include <linux/netdevice.h> 431da177e4SLinus Torvalds #include <linux/inetdevice.h> 441da177e4SLinus Torvalds #include <linux/igmp.h> 451da177e4SLinus Torvalds #include <linux/proc_fs.h> 461da177e4SLinus Torvalds #include <linux/seq_file.h> 471da177e4SLinus Torvalds #include <linux/mroute.h> 481da177e4SLinus Torvalds #include <linux/init.h> 4946f25dffSKris Katterjohn #include <linux/if_ether.h> 50457c4cbcSEric W. Biederman #include <net/net_namespace.h> 511da177e4SLinus Torvalds #include <net/ip.h> 521da177e4SLinus Torvalds #include <net/protocol.h> 531da177e4SLinus Torvalds #include <linux/skbuff.h> 5414c85021SArnaldo Carvalho de Melo #include <net/route.h> 551da177e4SLinus Torvalds #include <net/sock.h> 561da177e4SLinus Torvalds #include <net/icmp.h> 571da177e4SLinus Torvalds #include <net/udp.h> 581da177e4SLinus Torvalds #include <net/raw.h> 591da177e4SLinus Torvalds #include <linux/notifier.h> 601da177e4SLinus Torvalds #include <linux/if_arp.h> 611da177e4SLinus Torvalds #include <linux/netfilter_ipv4.h> 621da177e4SLinus Torvalds #include <net/ipip.h> 631da177e4SLinus Torvalds #include <net/checksum.h> 64dc5fc579SArnaldo Carvalho de Melo #include <net/netlink.h> 651da177e4SLinus Torvalds 661da177e4SLinus Torvalds #if defined(CONFIG_IP_PIMSM_V1) || defined(CONFIG_IP_PIMSM_V2) 671da177e4SLinus Torvalds #define CONFIG_IP_PIMSM 1 681da177e4SLinus Torvalds #endif 691da177e4SLinus Torvalds 701da177e4SLinus Torvalds /* Big lock, protecting vif table, mrt cache and mroute socket state. 711da177e4SLinus Torvalds Note that the changes are semaphored via rtnl_lock. 721da177e4SLinus Torvalds */ 731da177e4SLinus Torvalds 741da177e4SLinus Torvalds static DEFINE_RWLOCK(mrt_lock); 751da177e4SLinus Torvalds 761da177e4SLinus Torvalds /* 771da177e4SLinus Torvalds * Multicast router control variables 781da177e4SLinus Torvalds */ 791da177e4SLinus Torvalds 80cf958ae3SBenjamin Thery #define VIF_EXISTS(_net, _idx) ((_net)->ipv4.vif_table[_idx].dev != NULL) 811da177e4SLinus Torvalds 821da177e4SLinus Torvalds static struct mfc_cache *mfc_unres_queue; /* Queue of unresolved entries */ 831da177e4SLinus Torvalds 841da177e4SLinus Torvalds /* Special spinlock for queue of unresolved entries */ 851da177e4SLinus Torvalds static DEFINE_SPINLOCK(mfc_unres_lock); 861da177e4SLinus Torvalds 871da177e4SLinus Torvalds /* We return to original Alan's scheme. Hash table of resolved 881da177e4SLinus Torvalds entries is changed only in process context and protected 891da177e4SLinus Torvalds with weak lock mrt_lock. Queue of unresolved entries is protected 901da177e4SLinus Torvalds with strong spinlock mfc_unres_lock. 911da177e4SLinus Torvalds 921da177e4SLinus Torvalds In this case data path is free of exclusive locks at all. 931da177e4SLinus Torvalds */ 941da177e4SLinus Torvalds 95e18b890bSChristoph Lameter static struct kmem_cache *mrt_cachep __read_mostly; 961da177e4SLinus Torvalds 971da177e4SLinus Torvalds static int ip_mr_forward(struct sk_buff *skb, struct mfc_cache *cache, int local); 981da177e4SLinus Torvalds static int ipmr_cache_report(struct sk_buff *pkt, vifi_t vifi, int assert); 991da177e4SLinus Torvalds static int ipmr_fill_mroute(struct sk_buff *skb, struct mfc_cache *c, struct rtmsg *rtm); 1001da177e4SLinus Torvalds 1011da177e4SLinus Torvalds #ifdef CONFIG_IP_PIMSM_V2 1021da177e4SLinus Torvalds static struct net_protocol pim_protocol; 1031da177e4SLinus Torvalds #endif 1041da177e4SLinus Torvalds 1051da177e4SLinus Torvalds static struct timer_list ipmr_expire_timer; 1061da177e4SLinus Torvalds 1071da177e4SLinus Torvalds /* Service routines creating virtual interfaces: DVMRP tunnels and PIMREG */ 1081da177e4SLinus Torvalds 109d607032dSWang Chen static void ipmr_del_tunnel(struct net_device *dev, struct vifctl *v) 110d607032dSWang Chen { 111d607032dSWang Chen dev_close(dev); 112d607032dSWang Chen 113d607032dSWang Chen dev = __dev_get_by_name(&init_net, "tunl0"); 114d607032dSWang Chen if (dev) { 1155bc3eb7eSStephen Hemminger const struct net_device_ops *ops = dev->netdev_ops; 116d607032dSWang Chen struct ifreq ifr; 117d607032dSWang Chen struct ip_tunnel_parm p; 118d607032dSWang Chen 119d607032dSWang Chen memset(&p, 0, sizeof(p)); 120d607032dSWang Chen p.iph.daddr = v->vifc_rmt_addr.s_addr; 121d607032dSWang Chen p.iph.saddr = v->vifc_lcl_addr.s_addr; 122d607032dSWang Chen p.iph.version = 4; 123d607032dSWang Chen p.iph.ihl = 5; 124d607032dSWang Chen p.iph.protocol = IPPROTO_IPIP; 125d607032dSWang Chen sprintf(p.name, "dvmrp%d", v->vifc_vifi); 126d607032dSWang Chen ifr.ifr_ifru.ifru_data = (__force void __user *)&p; 127d607032dSWang Chen 1285bc3eb7eSStephen Hemminger if (ops->ndo_do_ioctl) { 1295bc3eb7eSStephen Hemminger mm_segment_t oldfs = get_fs(); 1305bc3eb7eSStephen Hemminger 1315bc3eb7eSStephen Hemminger set_fs(KERNEL_DS); 1325bc3eb7eSStephen Hemminger ops->ndo_do_ioctl(dev, &ifr, SIOCDELTUNNEL); 133d607032dSWang Chen set_fs(oldfs); 134d607032dSWang Chen } 135d607032dSWang Chen } 1365bc3eb7eSStephen Hemminger } 137d607032dSWang Chen 1381da177e4SLinus Torvalds static 1391da177e4SLinus Torvalds struct net_device *ipmr_new_tunnel(struct vifctl *v) 1401da177e4SLinus Torvalds { 1411da177e4SLinus Torvalds struct net_device *dev; 1421da177e4SLinus Torvalds 143881d966bSEric W. Biederman dev = __dev_get_by_name(&init_net, "tunl0"); 1441da177e4SLinus Torvalds 1451da177e4SLinus Torvalds if (dev) { 1465bc3eb7eSStephen Hemminger const struct net_device_ops *ops = dev->netdev_ops; 1471da177e4SLinus Torvalds int err; 1481da177e4SLinus Torvalds struct ifreq ifr; 1491da177e4SLinus Torvalds struct ip_tunnel_parm p; 1501da177e4SLinus Torvalds struct in_device *in_dev; 1511da177e4SLinus Torvalds 1521da177e4SLinus Torvalds memset(&p, 0, sizeof(p)); 1531da177e4SLinus Torvalds p.iph.daddr = v->vifc_rmt_addr.s_addr; 1541da177e4SLinus Torvalds p.iph.saddr = v->vifc_lcl_addr.s_addr; 1551da177e4SLinus Torvalds p.iph.version = 4; 1561da177e4SLinus Torvalds p.iph.ihl = 5; 1571da177e4SLinus Torvalds p.iph.protocol = IPPROTO_IPIP; 1581da177e4SLinus Torvalds sprintf(p.name, "dvmrp%d", v->vifc_vifi); 159ba93ef74SStephen Hemminger ifr.ifr_ifru.ifru_data = (__force void __user *)&p; 1601da177e4SLinus Torvalds 1615bc3eb7eSStephen Hemminger if (ops->ndo_do_ioctl) { 1625bc3eb7eSStephen Hemminger mm_segment_t oldfs = get_fs(); 1635bc3eb7eSStephen Hemminger 1645bc3eb7eSStephen Hemminger set_fs(KERNEL_DS); 1655bc3eb7eSStephen Hemminger err = ops->ndo_do_ioctl(dev, &ifr, SIOCADDTUNNEL); 1661da177e4SLinus Torvalds set_fs(oldfs); 1675bc3eb7eSStephen Hemminger } else 1685bc3eb7eSStephen Hemminger err = -EOPNOTSUPP; 1691da177e4SLinus Torvalds 1701da177e4SLinus Torvalds dev = NULL; 1711da177e4SLinus Torvalds 172881d966bSEric W. Biederman if (err == 0 && (dev = __dev_get_by_name(&init_net, p.name)) != NULL) { 1731da177e4SLinus Torvalds dev->flags |= IFF_MULTICAST; 1741da177e4SLinus Torvalds 175e5ed6399SHerbert Xu in_dev = __in_dev_get_rtnl(dev); 17671e27da9SHerbert Xu if (in_dev == NULL) 1771da177e4SLinus Torvalds goto failure; 17871e27da9SHerbert Xu 17971e27da9SHerbert Xu ipv4_devconf_setall(in_dev); 18071e27da9SHerbert Xu IPV4_DEVCONF(in_dev->cnf, RP_FILTER) = 0; 1811da177e4SLinus Torvalds 1821da177e4SLinus Torvalds if (dev_open(dev)) 1831da177e4SLinus Torvalds goto failure; 1847dc00c82SWang Chen dev_hold(dev); 1851da177e4SLinus Torvalds } 1861da177e4SLinus Torvalds } 1871da177e4SLinus Torvalds return dev; 1881da177e4SLinus Torvalds 1891da177e4SLinus Torvalds failure: 1901da177e4SLinus Torvalds /* allow the register to be completed before unregistering. */ 1911da177e4SLinus Torvalds rtnl_unlock(); 1921da177e4SLinus Torvalds rtnl_lock(); 1931da177e4SLinus Torvalds 1941da177e4SLinus Torvalds unregister_netdevice(dev); 1951da177e4SLinus Torvalds return NULL; 1961da177e4SLinus Torvalds } 1971da177e4SLinus Torvalds 1981da177e4SLinus Torvalds #ifdef CONFIG_IP_PIMSM 1991da177e4SLinus Torvalds 2001da177e4SLinus Torvalds static int reg_vif_xmit(struct sk_buff *skb, struct net_device *dev) 2011da177e4SLinus Torvalds { 2021da177e4SLinus Torvalds read_lock(&mrt_lock); 203cf3677aeSPavel Emelyanov dev->stats.tx_bytes += skb->len; 204cf3677aeSPavel Emelyanov dev->stats.tx_packets++; 205*6c5143dbSBenjamin Thery ipmr_cache_report(skb, init_net.ipv4.mroute_reg_vif_num, IGMPMSG_WHOLEPKT); 2061da177e4SLinus Torvalds read_unlock(&mrt_lock); 2071da177e4SLinus Torvalds kfree_skb(skb); 2081da177e4SLinus Torvalds return 0; 2091da177e4SLinus Torvalds } 2101da177e4SLinus Torvalds 211007c3838SStephen Hemminger static const struct net_device_ops reg_vif_netdev_ops = { 212007c3838SStephen Hemminger .ndo_start_xmit = reg_vif_xmit, 213007c3838SStephen Hemminger }; 214007c3838SStephen Hemminger 2151da177e4SLinus Torvalds static void reg_vif_setup(struct net_device *dev) 2161da177e4SLinus Torvalds { 2171da177e4SLinus Torvalds dev->type = ARPHRD_PIMREG; 21846f25dffSKris Katterjohn dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr) - 8; 2191da177e4SLinus Torvalds dev->flags = IFF_NOARP; 220007c3838SStephen Hemminger dev->netdev_ops = ®_vif_netdev_ops, 2211da177e4SLinus Torvalds dev->destructor = free_netdev; 2221da177e4SLinus Torvalds } 2231da177e4SLinus Torvalds 2241da177e4SLinus Torvalds static struct net_device *ipmr_reg_vif(void) 2251da177e4SLinus Torvalds { 2261da177e4SLinus Torvalds struct net_device *dev; 2271da177e4SLinus Torvalds struct in_device *in_dev; 2281da177e4SLinus Torvalds 229cf3677aeSPavel Emelyanov dev = alloc_netdev(0, "pimreg", reg_vif_setup); 2301da177e4SLinus Torvalds 2311da177e4SLinus Torvalds if (dev == NULL) 2321da177e4SLinus Torvalds return NULL; 2331da177e4SLinus Torvalds 2341da177e4SLinus Torvalds if (register_netdevice(dev)) { 2351da177e4SLinus Torvalds free_netdev(dev); 2361da177e4SLinus Torvalds return NULL; 2371da177e4SLinus Torvalds } 2381da177e4SLinus Torvalds dev->iflink = 0; 2391da177e4SLinus Torvalds 24071e27da9SHerbert Xu rcu_read_lock(); 24171e27da9SHerbert Xu if ((in_dev = __in_dev_get_rcu(dev)) == NULL) { 24271e27da9SHerbert Xu rcu_read_unlock(); 2431da177e4SLinus Torvalds goto failure; 24471e27da9SHerbert Xu } 2451da177e4SLinus Torvalds 24671e27da9SHerbert Xu ipv4_devconf_setall(in_dev); 24771e27da9SHerbert Xu IPV4_DEVCONF(in_dev->cnf, RP_FILTER) = 0; 24871e27da9SHerbert Xu rcu_read_unlock(); 2491da177e4SLinus Torvalds 2501da177e4SLinus Torvalds if (dev_open(dev)) 2511da177e4SLinus Torvalds goto failure; 2521da177e4SLinus Torvalds 2537dc00c82SWang Chen dev_hold(dev); 2547dc00c82SWang Chen 2551da177e4SLinus Torvalds return dev; 2561da177e4SLinus Torvalds 2571da177e4SLinus Torvalds failure: 2581da177e4SLinus Torvalds /* allow the register to be completed before unregistering. */ 2591da177e4SLinus Torvalds rtnl_unlock(); 2601da177e4SLinus Torvalds rtnl_lock(); 2611da177e4SLinus Torvalds 2621da177e4SLinus Torvalds unregister_netdevice(dev); 2631da177e4SLinus Torvalds return NULL; 2641da177e4SLinus Torvalds } 2651da177e4SLinus Torvalds #endif 2661da177e4SLinus Torvalds 2671da177e4SLinus Torvalds /* 2681da177e4SLinus Torvalds * Delete a VIF entry 2697dc00c82SWang Chen * @notify: Set to 1, if the caller is a notifier_call 2701da177e4SLinus Torvalds */ 2711da177e4SLinus Torvalds 2727dc00c82SWang Chen static int vif_delete(int vifi, int notify) 2731da177e4SLinus Torvalds { 2741da177e4SLinus Torvalds struct vif_device *v; 2751da177e4SLinus Torvalds struct net_device *dev; 2761da177e4SLinus Torvalds struct in_device *in_dev; 2771da177e4SLinus Torvalds 278cf958ae3SBenjamin Thery if (vifi < 0 || vifi >= init_net.ipv4.maxvif) 2791da177e4SLinus Torvalds return -EADDRNOTAVAIL; 2801da177e4SLinus Torvalds 281cf958ae3SBenjamin Thery v = &init_net.ipv4.vif_table[vifi]; 2821da177e4SLinus Torvalds 2831da177e4SLinus Torvalds write_lock_bh(&mrt_lock); 2841da177e4SLinus Torvalds dev = v->dev; 2851da177e4SLinus Torvalds v->dev = NULL; 2861da177e4SLinus Torvalds 2871da177e4SLinus Torvalds if (!dev) { 2881da177e4SLinus Torvalds write_unlock_bh(&mrt_lock); 2891da177e4SLinus Torvalds return -EADDRNOTAVAIL; 2901da177e4SLinus Torvalds } 2911da177e4SLinus Torvalds 2921da177e4SLinus Torvalds #ifdef CONFIG_IP_PIMSM 293*6c5143dbSBenjamin Thery if (vifi == init_net.ipv4.mroute_reg_vif_num) 294*6c5143dbSBenjamin Thery init_net.ipv4.mroute_reg_vif_num = -1; 2951da177e4SLinus Torvalds #endif 2961da177e4SLinus Torvalds 297cf958ae3SBenjamin Thery if (vifi+1 == init_net.ipv4.maxvif) { 2981da177e4SLinus Torvalds int tmp; 2991da177e4SLinus Torvalds for (tmp=vifi-1; tmp>=0; tmp--) { 300cf958ae3SBenjamin Thery if (VIF_EXISTS(&init_net, tmp)) 3011da177e4SLinus Torvalds break; 3021da177e4SLinus Torvalds } 303cf958ae3SBenjamin Thery init_net.ipv4.maxvif = tmp+1; 3041da177e4SLinus Torvalds } 3051da177e4SLinus Torvalds 3061da177e4SLinus Torvalds write_unlock_bh(&mrt_lock); 3071da177e4SLinus Torvalds 3081da177e4SLinus Torvalds dev_set_allmulti(dev, -1); 3091da177e4SLinus Torvalds 310e5ed6399SHerbert Xu if ((in_dev = __in_dev_get_rtnl(dev)) != NULL) { 31142f811b8SHerbert Xu IPV4_DEVCONF(in_dev->cnf, MC_FORWARDING)--; 3121da177e4SLinus Torvalds ip_rt_multicast_event(in_dev); 3131da177e4SLinus Torvalds } 3141da177e4SLinus Torvalds 3157dc00c82SWang Chen if (v->flags&(VIFF_TUNNEL|VIFF_REGISTER) && !notify) 3161da177e4SLinus Torvalds unregister_netdevice(dev); 3171da177e4SLinus Torvalds 3181da177e4SLinus Torvalds dev_put(dev); 3191da177e4SLinus Torvalds return 0; 3201da177e4SLinus Torvalds } 3211da177e4SLinus Torvalds 3225c0a66f5SBenjamin Thery static inline void ipmr_cache_free(struct mfc_cache *c) 3235c0a66f5SBenjamin Thery { 3245c0a66f5SBenjamin Thery release_net(mfc_net(c)); 3255c0a66f5SBenjamin Thery kmem_cache_free(mrt_cachep, c); 3265c0a66f5SBenjamin Thery } 3275c0a66f5SBenjamin Thery 3281da177e4SLinus Torvalds /* Destroy an unresolved cache entry, killing queued skbs 3291da177e4SLinus Torvalds and reporting error to netlink readers. 3301da177e4SLinus Torvalds */ 3311da177e4SLinus Torvalds 3321da177e4SLinus Torvalds static void ipmr_destroy_unres(struct mfc_cache *c) 3331da177e4SLinus Torvalds { 3341da177e4SLinus Torvalds struct sk_buff *skb; 3359ef1d4c7SPatrick McHardy struct nlmsgerr *e; 3361da177e4SLinus Torvalds 3371e8fb3b6SBenjamin Thery atomic_dec(&init_net.ipv4.cache_resolve_queue_len); 3381da177e4SLinus Torvalds 3391da177e4SLinus Torvalds while ((skb = skb_dequeue(&c->mfc_un.unres.unresolved))) { 340eddc9ec5SArnaldo Carvalho de Melo if (ip_hdr(skb)->version == 0) { 3411da177e4SLinus Torvalds struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr)); 3421da177e4SLinus Torvalds nlh->nlmsg_type = NLMSG_ERROR; 3431da177e4SLinus Torvalds nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr)); 3441da177e4SLinus Torvalds skb_trim(skb, nlh->nlmsg_len); 3459ef1d4c7SPatrick McHardy e = NLMSG_DATA(nlh); 3469ef1d4c7SPatrick McHardy e->error = -ETIMEDOUT; 3479ef1d4c7SPatrick McHardy memset(&e->msg, 0, sizeof(e->msg)); 3482942e900SThomas Graf 34997c53cacSDenis V. Lunev rtnl_unicast(skb, &init_net, NETLINK_CB(skb).pid); 3501da177e4SLinus Torvalds } else 3511da177e4SLinus Torvalds kfree_skb(skb); 3521da177e4SLinus Torvalds } 3531da177e4SLinus Torvalds 3545c0a66f5SBenjamin Thery ipmr_cache_free(c); 3551da177e4SLinus Torvalds } 3561da177e4SLinus Torvalds 3571da177e4SLinus Torvalds 3581da177e4SLinus Torvalds /* Single timer process for all the unresolved queue. */ 3591da177e4SLinus Torvalds 3601da177e4SLinus Torvalds static void ipmr_expire_process(unsigned long dummy) 3611da177e4SLinus Torvalds { 3621da177e4SLinus Torvalds unsigned long now; 3631da177e4SLinus Torvalds unsigned long expires; 3641da177e4SLinus Torvalds struct mfc_cache *c, **cp; 3651da177e4SLinus Torvalds 3661da177e4SLinus Torvalds if (!spin_trylock(&mfc_unres_lock)) { 3671da177e4SLinus Torvalds mod_timer(&ipmr_expire_timer, jiffies+HZ/10); 3681da177e4SLinus Torvalds return; 3691da177e4SLinus Torvalds } 3701da177e4SLinus Torvalds 3711e8fb3b6SBenjamin Thery if (mfc_unres_queue == NULL) 3721da177e4SLinus Torvalds goto out; 3731da177e4SLinus Torvalds 3741da177e4SLinus Torvalds now = jiffies; 3751da177e4SLinus Torvalds expires = 10*HZ; 3761da177e4SLinus Torvalds cp = &mfc_unres_queue; 3771da177e4SLinus Torvalds 3781da177e4SLinus Torvalds while ((c=*cp) != NULL) { 3791da177e4SLinus Torvalds if (time_after(c->mfc_un.unres.expires, now)) { 3801da177e4SLinus Torvalds unsigned long interval = c->mfc_un.unres.expires - now; 3811da177e4SLinus Torvalds if (interval < expires) 3821da177e4SLinus Torvalds expires = interval; 3831da177e4SLinus Torvalds cp = &c->next; 3841da177e4SLinus Torvalds continue; 3851da177e4SLinus Torvalds } 3861da177e4SLinus Torvalds 3871da177e4SLinus Torvalds *cp = c->next; 3881da177e4SLinus Torvalds 3891da177e4SLinus Torvalds ipmr_destroy_unres(c); 3901da177e4SLinus Torvalds } 3911da177e4SLinus Torvalds 3921e8fb3b6SBenjamin Thery if (mfc_unres_queue != NULL) 3931da177e4SLinus Torvalds mod_timer(&ipmr_expire_timer, jiffies + expires); 3941da177e4SLinus Torvalds 3951da177e4SLinus Torvalds out: 3961da177e4SLinus Torvalds spin_unlock(&mfc_unres_lock); 3971da177e4SLinus Torvalds } 3981da177e4SLinus Torvalds 3991da177e4SLinus Torvalds /* Fill oifs list. It is called under write locked mrt_lock. */ 4001da177e4SLinus Torvalds 401d1b04c08SBaruch Even static void ipmr_update_thresholds(struct mfc_cache *cache, unsigned char *ttls) 4021da177e4SLinus Torvalds { 4031da177e4SLinus Torvalds int vifi; 4041da177e4SLinus Torvalds 4051da177e4SLinus Torvalds cache->mfc_un.res.minvif = MAXVIFS; 4061da177e4SLinus Torvalds cache->mfc_un.res.maxvif = 0; 4071da177e4SLinus Torvalds memset(cache->mfc_un.res.ttls, 255, MAXVIFS); 4081da177e4SLinus Torvalds 409cf958ae3SBenjamin Thery for (vifi = 0; vifi < init_net.ipv4.maxvif; vifi++) { 410cf958ae3SBenjamin Thery if (VIF_EXISTS(&init_net, vifi) && 411cf958ae3SBenjamin Thery ttls[vifi] && ttls[vifi] < 255) { 4121da177e4SLinus Torvalds cache->mfc_un.res.ttls[vifi] = ttls[vifi]; 4131da177e4SLinus Torvalds if (cache->mfc_un.res.minvif > vifi) 4141da177e4SLinus Torvalds cache->mfc_un.res.minvif = vifi; 4151da177e4SLinus Torvalds if (cache->mfc_un.res.maxvif <= vifi) 4161da177e4SLinus Torvalds cache->mfc_un.res.maxvif = vifi + 1; 4171da177e4SLinus Torvalds } 4181da177e4SLinus Torvalds } 4191da177e4SLinus Torvalds } 4201da177e4SLinus Torvalds 4211da177e4SLinus Torvalds static int vif_add(struct vifctl *vifc, int mrtsock) 4221da177e4SLinus Torvalds { 4231da177e4SLinus Torvalds int vifi = vifc->vifc_vifi; 424cf958ae3SBenjamin Thery struct vif_device *v = &init_net.ipv4.vif_table[vifi]; 4251da177e4SLinus Torvalds struct net_device *dev; 4261da177e4SLinus Torvalds struct in_device *in_dev; 427d607032dSWang Chen int err; 4281da177e4SLinus Torvalds 4291da177e4SLinus Torvalds /* Is vif busy ? */ 430cf958ae3SBenjamin Thery if (VIF_EXISTS(&init_net, vifi)) 4311da177e4SLinus Torvalds return -EADDRINUSE; 4321da177e4SLinus Torvalds 4331da177e4SLinus Torvalds switch (vifc->vifc_flags) { 4341da177e4SLinus Torvalds #ifdef CONFIG_IP_PIMSM 4351da177e4SLinus Torvalds case VIFF_REGISTER: 4361da177e4SLinus Torvalds /* 4371da177e4SLinus Torvalds * Special Purpose VIF in PIM 4381da177e4SLinus Torvalds * All the packets will be sent to the daemon 4391da177e4SLinus Torvalds */ 440*6c5143dbSBenjamin Thery if (init_net.ipv4.mroute_reg_vif_num >= 0) 4411da177e4SLinus Torvalds return -EADDRINUSE; 4421da177e4SLinus Torvalds dev = ipmr_reg_vif(); 4431da177e4SLinus Torvalds if (!dev) 4441da177e4SLinus Torvalds return -ENOBUFS; 445d607032dSWang Chen err = dev_set_allmulti(dev, 1); 446d607032dSWang Chen if (err) { 447d607032dSWang Chen unregister_netdevice(dev); 4487dc00c82SWang Chen dev_put(dev); 449d607032dSWang Chen return err; 450d607032dSWang Chen } 4511da177e4SLinus Torvalds break; 4521da177e4SLinus Torvalds #endif 4531da177e4SLinus Torvalds case VIFF_TUNNEL: 4541da177e4SLinus Torvalds dev = ipmr_new_tunnel(vifc); 4551da177e4SLinus Torvalds if (!dev) 4561da177e4SLinus Torvalds return -ENOBUFS; 457d607032dSWang Chen err = dev_set_allmulti(dev, 1); 458d607032dSWang Chen if (err) { 459d607032dSWang Chen ipmr_del_tunnel(dev, vifc); 4607dc00c82SWang Chen dev_put(dev); 461d607032dSWang Chen return err; 462d607032dSWang Chen } 4631da177e4SLinus Torvalds break; 4641da177e4SLinus Torvalds case 0: 4651ab35276SDenis V. Lunev dev = ip_dev_find(&init_net, vifc->vifc_lcl_addr.s_addr); 4661da177e4SLinus Torvalds if (!dev) 4671da177e4SLinus Torvalds return -EADDRNOTAVAIL; 468d607032dSWang Chen err = dev_set_allmulti(dev, 1); 4697dc00c82SWang Chen if (err) { 4707dc00c82SWang Chen dev_put(dev); 471d607032dSWang Chen return err; 4727dc00c82SWang Chen } 4731da177e4SLinus Torvalds break; 4741da177e4SLinus Torvalds default: 4751da177e4SLinus Torvalds return -EINVAL; 4761da177e4SLinus Torvalds } 4771da177e4SLinus Torvalds 478e5ed6399SHerbert Xu if ((in_dev = __in_dev_get_rtnl(dev)) == NULL) 4791da177e4SLinus Torvalds return -EADDRNOTAVAIL; 48042f811b8SHerbert Xu IPV4_DEVCONF(in_dev->cnf, MC_FORWARDING)++; 4811da177e4SLinus Torvalds ip_rt_multicast_event(in_dev); 4821da177e4SLinus Torvalds 4831da177e4SLinus Torvalds /* 4841da177e4SLinus Torvalds * Fill in the VIF structures 4851da177e4SLinus Torvalds */ 4861da177e4SLinus Torvalds v->rate_limit = vifc->vifc_rate_limit; 4871da177e4SLinus Torvalds v->local = vifc->vifc_lcl_addr.s_addr; 4881da177e4SLinus Torvalds v->remote = vifc->vifc_rmt_addr.s_addr; 4891da177e4SLinus Torvalds v->flags = vifc->vifc_flags; 4901da177e4SLinus Torvalds if (!mrtsock) 4911da177e4SLinus Torvalds v->flags |= VIFF_STATIC; 4921da177e4SLinus Torvalds v->threshold = vifc->vifc_threshold; 4931da177e4SLinus Torvalds v->bytes_in = 0; 4941da177e4SLinus Torvalds v->bytes_out = 0; 4951da177e4SLinus Torvalds v->pkt_in = 0; 4961da177e4SLinus Torvalds v->pkt_out = 0; 4971da177e4SLinus Torvalds v->link = dev->ifindex; 4981da177e4SLinus Torvalds if (v->flags&(VIFF_TUNNEL|VIFF_REGISTER)) 4991da177e4SLinus Torvalds v->link = dev->iflink; 5001da177e4SLinus Torvalds 5011da177e4SLinus Torvalds /* And finish update writing critical data */ 5021da177e4SLinus Torvalds write_lock_bh(&mrt_lock); 5031da177e4SLinus Torvalds v->dev = dev; 5041da177e4SLinus Torvalds #ifdef CONFIG_IP_PIMSM 5051da177e4SLinus Torvalds if (v->flags&VIFF_REGISTER) 506*6c5143dbSBenjamin Thery init_net.ipv4.mroute_reg_vif_num = vifi; 5071da177e4SLinus Torvalds #endif 508cf958ae3SBenjamin Thery if (vifi+1 > init_net.ipv4.maxvif) 509cf958ae3SBenjamin Thery init_net.ipv4.maxvif = vifi+1; 5101da177e4SLinus Torvalds write_unlock_bh(&mrt_lock); 5111da177e4SLinus Torvalds return 0; 5121da177e4SLinus Torvalds } 5131da177e4SLinus Torvalds 514114c7844SAl Viro static struct mfc_cache *ipmr_cache_find(__be32 origin, __be32 mcastgrp) 5151da177e4SLinus Torvalds { 5161da177e4SLinus Torvalds int line = MFC_HASH(mcastgrp, origin); 5171da177e4SLinus Torvalds struct mfc_cache *c; 5181da177e4SLinus Torvalds 5192bb8b26cSBenjamin Thery for (c = init_net.ipv4.mfc_cache_array[line]; c; c = c->next) { 5201da177e4SLinus Torvalds if (c->mfc_origin==origin && c->mfc_mcastgrp==mcastgrp) 5211da177e4SLinus Torvalds break; 5221da177e4SLinus Torvalds } 5231da177e4SLinus Torvalds return c; 5241da177e4SLinus Torvalds } 5251da177e4SLinus Torvalds 5261da177e4SLinus Torvalds /* 5271da177e4SLinus Torvalds * Allocate a multicast cache entry 5281da177e4SLinus Torvalds */ 5295c0a66f5SBenjamin Thery static struct mfc_cache *ipmr_cache_alloc(struct net *net) 5301da177e4SLinus Torvalds { 531c3762229SRobert P. J. Day struct mfc_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL); 5321da177e4SLinus Torvalds if (c == NULL) 5331da177e4SLinus Torvalds return NULL; 5341da177e4SLinus Torvalds c->mfc_un.res.minvif = MAXVIFS; 5355c0a66f5SBenjamin Thery mfc_net_set(c, net); 5361da177e4SLinus Torvalds return c; 5371da177e4SLinus Torvalds } 5381da177e4SLinus Torvalds 5395c0a66f5SBenjamin Thery static struct mfc_cache *ipmr_cache_alloc_unres(struct net *net) 5401da177e4SLinus Torvalds { 541c3762229SRobert P. J. Day struct mfc_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC); 5421da177e4SLinus Torvalds if (c == NULL) 5431da177e4SLinus Torvalds return NULL; 5441da177e4SLinus Torvalds skb_queue_head_init(&c->mfc_un.unres.unresolved); 5451da177e4SLinus Torvalds c->mfc_un.unres.expires = jiffies + 10*HZ; 5465c0a66f5SBenjamin Thery mfc_net_set(c, net); 5471da177e4SLinus Torvalds return c; 5481da177e4SLinus Torvalds } 5491da177e4SLinus Torvalds 5501da177e4SLinus Torvalds /* 5511da177e4SLinus Torvalds * A cache entry has gone into a resolved state from queued 5521da177e4SLinus Torvalds */ 5531da177e4SLinus Torvalds 5541da177e4SLinus Torvalds static void ipmr_cache_resolve(struct mfc_cache *uc, struct mfc_cache *c) 5551da177e4SLinus Torvalds { 5561da177e4SLinus Torvalds struct sk_buff *skb; 5579ef1d4c7SPatrick McHardy struct nlmsgerr *e; 5581da177e4SLinus Torvalds 5591da177e4SLinus Torvalds /* 5601da177e4SLinus Torvalds * Play the pending entries through our router 5611da177e4SLinus Torvalds */ 5621da177e4SLinus Torvalds 5631da177e4SLinus Torvalds while ((skb = __skb_dequeue(&uc->mfc_un.unres.unresolved))) { 564eddc9ec5SArnaldo Carvalho de Melo if (ip_hdr(skb)->version == 0) { 5651da177e4SLinus Torvalds struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr)); 5661da177e4SLinus Torvalds 5671da177e4SLinus Torvalds if (ipmr_fill_mroute(skb, c, NLMSG_DATA(nlh)) > 0) { 56827a884dcSArnaldo Carvalho de Melo nlh->nlmsg_len = (skb_tail_pointer(skb) - 56927a884dcSArnaldo Carvalho de Melo (u8 *)nlh); 5701da177e4SLinus Torvalds } else { 5711da177e4SLinus Torvalds nlh->nlmsg_type = NLMSG_ERROR; 5721da177e4SLinus Torvalds nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr)); 5731da177e4SLinus Torvalds skb_trim(skb, nlh->nlmsg_len); 5749ef1d4c7SPatrick McHardy e = NLMSG_DATA(nlh); 5759ef1d4c7SPatrick McHardy e->error = -EMSGSIZE; 5769ef1d4c7SPatrick McHardy memset(&e->msg, 0, sizeof(e->msg)); 5771da177e4SLinus Torvalds } 5782942e900SThomas Graf 57997c53cacSDenis V. Lunev rtnl_unicast(skb, &init_net, NETLINK_CB(skb).pid); 5801da177e4SLinus Torvalds } else 5811da177e4SLinus Torvalds ip_mr_forward(skb, c, 0); 5821da177e4SLinus Torvalds } 5831da177e4SLinus Torvalds } 5841da177e4SLinus Torvalds 5851da177e4SLinus Torvalds /* 5861da177e4SLinus Torvalds * Bounce a cache query up to mrouted. We could use netlink for this but mrouted 5871da177e4SLinus Torvalds * expects the following bizarre scheme. 5881da177e4SLinus Torvalds * 5891da177e4SLinus Torvalds * Called under mrt_lock. 5901da177e4SLinus Torvalds */ 5911da177e4SLinus Torvalds 5921da177e4SLinus Torvalds static int ipmr_cache_report(struct sk_buff *pkt, vifi_t vifi, int assert) 5931da177e4SLinus Torvalds { 5941da177e4SLinus Torvalds struct sk_buff *skb; 595c9bdd4b5SArnaldo Carvalho de Melo const int ihl = ip_hdrlen(pkt); 5961da177e4SLinus Torvalds struct igmphdr *igmp; 5971da177e4SLinus Torvalds struct igmpmsg *msg; 5981da177e4SLinus Torvalds int ret; 5991da177e4SLinus Torvalds 6001da177e4SLinus Torvalds #ifdef CONFIG_IP_PIMSM 6011da177e4SLinus Torvalds if (assert == IGMPMSG_WHOLEPKT) 6021da177e4SLinus Torvalds skb = skb_realloc_headroom(pkt, sizeof(struct iphdr)); 6031da177e4SLinus Torvalds else 6041da177e4SLinus Torvalds #endif 6051da177e4SLinus Torvalds skb = alloc_skb(128, GFP_ATOMIC); 6061da177e4SLinus Torvalds 6071da177e4SLinus Torvalds if (!skb) 6081da177e4SLinus Torvalds return -ENOBUFS; 6091da177e4SLinus Torvalds 6101da177e4SLinus Torvalds #ifdef CONFIG_IP_PIMSM 6111da177e4SLinus Torvalds if (assert == IGMPMSG_WHOLEPKT) { 6121da177e4SLinus Torvalds /* Ugly, but we have no choice with this interface. 6131da177e4SLinus Torvalds Duplicate old header, fix ihl, length etc. 6141da177e4SLinus Torvalds And all this only to mangle msg->im_msgtype and 6151da177e4SLinus Torvalds to set msg->im_mbz to "mbz" :-) 6161da177e4SLinus Torvalds */ 617878c8145SArnaldo Carvalho de Melo skb_push(skb, sizeof(struct iphdr)); 618878c8145SArnaldo Carvalho de Melo skb_reset_network_header(skb); 619badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 6200272ffc4SArnaldo Carvalho de Melo msg = (struct igmpmsg *)skb_network_header(skb); 621d56f90a7SArnaldo Carvalho de Melo memcpy(msg, skb_network_header(pkt), sizeof(struct iphdr)); 6221da177e4SLinus Torvalds msg->im_msgtype = IGMPMSG_WHOLEPKT; 6231da177e4SLinus Torvalds msg->im_mbz = 0; 624*6c5143dbSBenjamin Thery msg->im_vif = init_net.ipv4.mroute_reg_vif_num; 625eddc9ec5SArnaldo Carvalho de Melo ip_hdr(skb)->ihl = sizeof(struct iphdr) >> 2; 626eddc9ec5SArnaldo Carvalho de Melo ip_hdr(skb)->tot_len = htons(ntohs(ip_hdr(pkt)->tot_len) + 627eddc9ec5SArnaldo Carvalho de Melo sizeof(struct iphdr)); 6281da177e4SLinus Torvalds } else 6291da177e4SLinus Torvalds #endif 6301da177e4SLinus Torvalds { 6311da177e4SLinus Torvalds 6321da177e4SLinus Torvalds /* 6331da177e4SLinus Torvalds * Copy the IP header 6341da177e4SLinus Torvalds */ 6351da177e4SLinus Torvalds 63627a884dcSArnaldo Carvalho de Melo skb->network_header = skb->tail; 637ddc7b8e3SArnaldo Carvalho de Melo skb_put(skb, ihl); 63827d7ff46SArnaldo Carvalho de Melo skb_copy_to_linear_data(skb, pkt->data, ihl); 639eddc9ec5SArnaldo Carvalho de Melo ip_hdr(skb)->protocol = 0; /* Flag to the kernel this is a route add */ 640eddc9ec5SArnaldo Carvalho de Melo msg = (struct igmpmsg *)skb_network_header(skb); 6411da177e4SLinus Torvalds msg->im_vif = vifi; 6421da177e4SLinus Torvalds skb->dst = dst_clone(pkt->dst); 6431da177e4SLinus Torvalds 6441da177e4SLinus Torvalds /* 6451da177e4SLinus Torvalds * Add our header 6461da177e4SLinus Torvalds */ 6471da177e4SLinus Torvalds 6481da177e4SLinus Torvalds igmp=(struct igmphdr *)skb_put(skb, sizeof(struct igmphdr)); 6491da177e4SLinus Torvalds igmp->type = 6501da177e4SLinus Torvalds msg->im_msgtype = assert; 6511da177e4SLinus Torvalds igmp->code = 0; 652eddc9ec5SArnaldo Carvalho de Melo ip_hdr(skb)->tot_len = htons(skb->len); /* Fix the length */ 653b0e380b1SArnaldo Carvalho de Melo skb->transport_header = skb->network_header; 6541da177e4SLinus Torvalds } 6551da177e4SLinus Torvalds 65670a269e6SBenjamin Thery if (init_net.ipv4.mroute_sk == NULL) { 6571da177e4SLinus Torvalds kfree_skb(skb); 6581da177e4SLinus Torvalds return -EINVAL; 6591da177e4SLinus Torvalds } 6601da177e4SLinus Torvalds 6611da177e4SLinus Torvalds /* 6621da177e4SLinus Torvalds * Deliver to mrouted 6631da177e4SLinus Torvalds */ 66470a269e6SBenjamin Thery ret = sock_queue_rcv_skb(init_net.ipv4.mroute_sk, skb); 66570a269e6SBenjamin Thery if (ret < 0) { 6661da177e4SLinus Torvalds if (net_ratelimit()) 6671da177e4SLinus Torvalds printk(KERN_WARNING "mroute: pending queue full, dropping entries.\n"); 6681da177e4SLinus Torvalds kfree_skb(skb); 6691da177e4SLinus Torvalds } 6701da177e4SLinus Torvalds 6711da177e4SLinus Torvalds return ret; 6721da177e4SLinus Torvalds } 6731da177e4SLinus Torvalds 6741da177e4SLinus Torvalds /* 6751da177e4SLinus Torvalds * Queue a packet for resolution. It gets locked cache entry! 6761da177e4SLinus Torvalds */ 6771da177e4SLinus Torvalds 6781da177e4SLinus Torvalds static int 6791da177e4SLinus Torvalds ipmr_cache_unresolved(vifi_t vifi, struct sk_buff *skb) 6801da177e4SLinus Torvalds { 6811da177e4SLinus Torvalds int err; 6821da177e4SLinus Torvalds struct mfc_cache *c; 683eddc9ec5SArnaldo Carvalho de Melo const struct iphdr *iph = ip_hdr(skb); 6841da177e4SLinus Torvalds 6851da177e4SLinus Torvalds spin_lock_bh(&mfc_unres_lock); 6861da177e4SLinus Torvalds for (c=mfc_unres_queue; c; c=c->next) { 6871e8fb3b6SBenjamin Thery if (net_eq(mfc_net(c), &init_net) && 6881e8fb3b6SBenjamin Thery c->mfc_mcastgrp == iph->daddr && 689eddc9ec5SArnaldo Carvalho de Melo c->mfc_origin == iph->saddr) 6901da177e4SLinus Torvalds break; 6911da177e4SLinus Torvalds } 6921da177e4SLinus Torvalds 6931da177e4SLinus Torvalds if (c == NULL) { 6941da177e4SLinus Torvalds /* 6951da177e4SLinus Torvalds * Create a new entry if allowable 6961da177e4SLinus Torvalds */ 6971da177e4SLinus Torvalds 6981e8fb3b6SBenjamin Thery if (atomic_read(&init_net.ipv4.cache_resolve_queue_len) >= 10 || 6995c0a66f5SBenjamin Thery (c = ipmr_cache_alloc_unres(&init_net)) == NULL) { 7001da177e4SLinus Torvalds spin_unlock_bh(&mfc_unres_lock); 7011da177e4SLinus Torvalds 7021da177e4SLinus Torvalds kfree_skb(skb); 7031da177e4SLinus Torvalds return -ENOBUFS; 7041da177e4SLinus Torvalds } 7051da177e4SLinus Torvalds 7061da177e4SLinus Torvalds /* 7071da177e4SLinus Torvalds * Fill in the new cache entry 7081da177e4SLinus Torvalds */ 7091da177e4SLinus Torvalds c->mfc_parent = -1; 710eddc9ec5SArnaldo Carvalho de Melo c->mfc_origin = iph->saddr; 711eddc9ec5SArnaldo Carvalho de Melo c->mfc_mcastgrp = iph->daddr; 7121da177e4SLinus Torvalds 7131da177e4SLinus Torvalds /* 7141da177e4SLinus Torvalds * Reflect first query at mrouted. 7151da177e4SLinus Torvalds */ 7161da177e4SLinus Torvalds if ((err = ipmr_cache_report(skb, vifi, IGMPMSG_NOCACHE))<0) { 7171da177e4SLinus Torvalds /* If the report failed throw the cache entry 7181da177e4SLinus Torvalds out - Brad Parker 7191da177e4SLinus Torvalds */ 7201da177e4SLinus Torvalds spin_unlock_bh(&mfc_unres_lock); 7211da177e4SLinus Torvalds 7225c0a66f5SBenjamin Thery ipmr_cache_free(c); 7231da177e4SLinus Torvalds kfree_skb(skb); 7241da177e4SLinus Torvalds return err; 7251da177e4SLinus Torvalds } 7261da177e4SLinus Torvalds 7271e8fb3b6SBenjamin Thery atomic_inc(&init_net.ipv4.cache_resolve_queue_len); 7281da177e4SLinus Torvalds c->next = mfc_unres_queue; 7291da177e4SLinus Torvalds mfc_unres_queue = c; 7301da177e4SLinus Torvalds 7311da177e4SLinus Torvalds mod_timer(&ipmr_expire_timer, c->mfc_un.unres.expires); 7321da177e4SLinus Torvalds } 7331da177e4SLinus Torvalds 7341da177e4SLinus Torvalds /* 7351da177e4SLinus Torvalds * See if we can append the packet 7361da177e4SLinus Torvalds */ 7371da177e4SLinus Torvalds if (c->mfc_un.unres.unresolved.qlen>3) { 7381da177e4SLinus Torvalds kfree_skb(skb); 7391da177e4SLinus Torvalds err = -ENOBUFS; 7401da177e4SLinus Torvalds } else { 7411da177e4SLinus Torvalds skb_queue_tail(&c->mfc_un.unres.unresolved, skb); 7421da177e4SLinus Torvalds err = 0; 7431da177e4SLinus Torvalds } 7441da177e4SLinus Torvalds 7451da177e4SLinus Torvalds spin_unlock_bh(&mfc_unres_lock); 7461da177e4SLinus Torvalds return err; 7471da177e4SLinus Torvalds } 7481da177e4SLinus Torvalds 7491da177e4SLinus Torvalds /* 7501da177e4SLinus Torvalds * MFC cache manipulation by user space mroute daemon 7511da177e4SLinus Torvalds */ 7521da177e4SLinus Torvalds 7531da177e4SLinus Torvalds static int ipmr_mfc_delete(struct mfcctl *mfc) 7541da177e4SLinus Torvalds { 7551da177e4SLinus Torvalds int line; 7561da177e4SLinus Torvalds struct mfc_cache *c, **cp; 7571da177e4SLinus Torvalds 7581da177e4SLinus Torvalds line = MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr); 7591da177e4SLinus Torvalds 7602bb8b26cSBenjamin Thery for (cp = &init_net.ipv4.mfc_cache_array[line]; 7612bb8b26cSBenjamin Thery (c = *cp) != NULL; cp = &c->next) { 7621da177e4SLinus Torvalds if (c->mfc_origin == mfc->mfcc_origin.s_addr && 7631da177e4SLinus Torvalds c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr) { 7641da177e4SLinus Torvalds write_lock_bh(&mrt_lock); 7651da177e4SLinus Torvalds *cp = c->next; 7661da177e4SLinus Torvalds write_unlock_bh(&mrt_lock); 7671da177e4SLinus Torvalds 7685c0a66f5SBenjamin Thery ipmr_cache_free(c); 7691da177e4SLinus Torvalds return 0; 7701da177e4SLinus Torvalds } 7711da177e4SLinus Torvalds } 7721da177e4SLinus Torvalds return -ENOENT; 7731da177e4SLinus Torvalds } 7741da177e4SLinus Torvalds 7751da177e4SLinus Torvalds static int ipmr_mfc_add(struct mfcctl *mfc, int mrtsock) 7761da177e4SLinus Torvalds { 7771da177e4SLinus Torvalds int line; 7781da177e4SLinus Torvalds struct mfc_cache *uc, *c, **cp; 7791da177e4SLinus Torvalds 7801da177e4SLinus Torvalds line = MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr); 7811da177e4SLinus Torvalds 7822bb8b26cSBenjamin Thery for (cp = &init_net.ipv4.mfc_cache_array[line]; 7832bb8b26cSBenjamin Thery (c = *cp) != NULL; cp = &c->next) { 7841da177e4SLinus Torvalds if (c->mfc_origin == mfc->mfcc_origin.s_addr && 7851da177e4SLinus Torvalds c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr) 7861da177e4SLinus Torvalds break; 7871da177e4SLinus Torvalds } 7881da177e4SLinus Torvalds 7891da177e4SLinus Torvalds if (c != NULL) { 7901da177e4SLinus Torvalds write_lock_bh(&mrt_lock); 7911da177e4SLinus Torvalds c->mfc_parent = mfc->mfcc_parent; 792d1b04c08SBaruch Even ipmr_update_thresholds(c, mfc->mfcc_ttls); 7931da177e4SLinus Torvalds if (!mrtsock) 7941da177e4SLinus Torvalds c->mfc_flags |= MFC_STATIC; 7951da177e4SLinus Torvalds write_unlock_bh(&mrt_lock); 7961da177e4SLinus Torvalds return 0; 7971da177e4SLinus Torvalds } 7981da177e4SLinus Torvalds 799f97c1e0cSJoe Perches if (!ipv4_is_multicast(mfc->mfcc_mcastgrp.s_addr)) 8001da177e4SLinus Torvalds return -EINVAL; 8011da177e4SLinus Torvalds 8025c0a66f5SBenjamin Thery c = ipmr_cache_alloc(&init_net); 8031da177e4SLinus Torvalds if (c == NULL) 8041da177e4SLinus Torvalds return -ENOMEM; 8051da177e4SLinus Torvalds 8061da177e4SLinus Torvalds c->mfc_origin = mfc->mfcc_origin.s_addr; 8071da177e4SLinus Torvalds c->mfc_mcastgrp = mfc->mfcc_mcastgrp.s_addr; 8081da177e4SLinus Torvalds c->mfc_parent = mfc->mfcc_parent; 809d1b04c08SBaruch Even ipmr_update_thresholds(c, mfc->mfcc_ttls); 8101da177e4SLinus Torvalds if (!mrtsock) 8111da177e4SLinus Torvalds c->mfc_flags |= MFC_STATIC; 8121da177e4SLinus Torvalds 8131da177e4SLinus Torvalds write_lock_bh(&mrt_lock); 8142bb8b26cSBenjamin Thery c->next = init_net.ipv4.mfc_cache_array[line]; 8152bb8b26cSBenjamin Thery init_net.ipv4.mfc_cache_array[line] = c; 8161da177e4SLinus Torvalds write_unlock_bh(&mrt_lock); 8171da177e4SLinus Torvalds 8181da177e4SLinus Torvalds /* 8191da177e4SLinus Torvalds * Check to see if we resolved a queued list. If so we 8201da177e4SLinus Torvalds * need to send on the frames and tidy up. 8211da177e4SLinus Torvalds */ 8221da177e4SLinus Torvalds spin_lock_bh(&mfc_unres_lock); 8231da177e4SLinus Torvalds for (cp = &mfc_unres_queue; (uc=*cp) != NULL; 8241da177e4SLinus Torvalds cp = &uc->next) { 8251e8fb3b6SBenjamin Thery if (net_eq(mfc_net(uc), &init_net) && 8261e8fb3b6SBenjamin Thery uc->mfc_origin == c->mfc_origin && 8271da177e4SLinus Torvalds uc->mfc_mcastgrp == c->mfc_mcastgrp) { 8281da177e4SLinus Torvalds *cp = uc->next; 8291e8fb3b6SBenjamin Thery atomic_dec(&init_net.ipv4.cache_resolve_queue_len); 8301da177e4SLinus Torvalds break; 8311da177e4SLinus Torvalds } 8321da177e4SLinus Torvalds } 8331e8fb3b6SBenjamin Thery if (mfc_unres_queue == NULL) 8341e8fb3b6SBenjamin Thery del_timer(&ipmr_expire_timer); 8351da177e4SLinus Torvalds spin_unlock_bh(&mfc_unres_lock); 8361da177e4SLinus Torvalds 8371da177e4SLinus Torvalds if (uc) { 8381da177e4SLinus Torvalds ipmr_cache_resolve(uc, c); 8395c0a66f5SBenjamin Thery ipmr_cache_free(uc); 8401da177e4SLinus Torvalds } 8411da177e4SLinus Torvalds return 0; 8421da177e4SLinus Torvalds } 8431da177e4SLinus Torvalds 8441da177e4SLinus Torvalds /* 8451da177e4SLinus Torvalds * Close the multicast socket, and clear the vif tables etc 8461da177e4SLinus Torvalds */ 8471da177e4SLinus Torvalds 8481da177e4SLinus Torvalds static void mroute_clean_tables(struct sock *sk) 8491da177e4SLinus Torvalds { 8501da177e4SLinus Torvalds int i; 8511da177e4SLinus Torvalds 8521da177e4SLinus Torvalds /* 8531da177e4SLinus Torvalds * Shut down all active vif entries 8541da177e4SLinus Torvalds */ 855cf958ae3SBenjamin Thery for (i = 0; i < init_net.ipv4.maxvif; i++) { 856cf958ae3SBenjamin Thery if (!(init_net.ipv4.vif_table[i].flags&VIFF_STATIC)) 8577dc00c82SWang Chen vif_delete(i, 0); 8581da177e4SLinus Torvalds } 8591da177e4SLinus Torvalds 8601da177e4SLinus Torvalds /* 8611da177e4SLinus Torvalds * Wipe the cache 8621da177e4SLinus Torvalds */ 8631da177e4SLinus Torvalds for (i=0; i<MFC_LINES; i++) { 8641da177e4SLinus Torvalds struct mfc_cache *c, **cp; 8651da177e4SLinus Torvalds 8662bb8b26cSBenjamin Thery cp = &init_net.ipv4.mfc_cache_array[i]; 8671da177e4SLinus Torvalds while ((c = *cp) != NULL) { 8681da177e4SLinus Torvalds if (c->mfc_flags&MFC_STATIC) { 8691da177e4SLinus Torvalds cp = &c->next; 8701da177e4SLinus Torvalds continue; 8711da177e4SLinus Torvalds } 8721da177e4SLinus Torvalds write_lock_bh(&mrt_lock); 8731da177e4SLinus Torvalds *cp = c->next; 8741da177e4SLinus Torvalds write_unlock_bh(&mrt_lock); 8751da177e4SLinus Torvalds 8765c0a66f5SBenjamin Thery ipmr_cache_free(c); 8771da177e4SLinus Torvalds } 8781da177e4SLinus Torvalds } 8791da177e4SLinus Torvalds 8801e8fb3b6SBenjamin Thery if (atomic_read(&init_net.ipv4.cache_resolve_queue_len) != 0) { 8811e8fb3b6SBenjamin Thery struct mfc_cache *c, **cp; 8821da177e4SLinus Torvalds 8831da177e4SLinus Torvalds spin_lock_bh(&mfc_unres_lock); 8841e8fb3b6SBenjamin Thery cp = &mfc_unres_queue; 8851e8fb3b6SBenjamin Thery while ((c = *cp) != NULL) { 8861e8fb3b6SBenjamin Thery if (!net_eq(mfc_net(c), &init_net)) { 8871e8fb3b6SBenjamin Thery cp = &c->next; 8881e8fb3b6SBenjamin Thery continue; 8891e8fb3b6SBenjamin Thery } 8901e8fb3b6SBenjamin Thery *cp = c->next; 8911da177e4SLinus Torvalds 8921da177e4SLinus Torvalds ipmr_destroy_unres(c); 8931da177e4SLinus Torvalds } 8941da177e4SLinus Torvalds spin_unlock_bh(&mfc_unres_lock); 8951da177e4SLinus Torvalds } 8961da177e4SLinus Torvalds } 8971da177e4SLinus Torvalds 8981da177e4SLinus Torvalds static void mrtsock_destruct(struct sock *sk) 8991da177e4SLinus Torvalds { 9001da177e4SLinus Torvalds rtnl_lock(); 90170a269e6SBenjamin Thery if (sk == init_net.ipv4.mroute_sk) { 9023b1e0a65SYOSHIFUJI Hideaki IPV4_DEVCONF_ALL(sock_net(sk), MC_FORWARDING)--; 9031da177e4SLinus Torvalds 9041da177e4SLinus Torvalds write_lock_bh(&mrt_lock); 90570a269e6SBenjamin Thery init_net.ipv4.mroute_sk = NULL; 9061da177e4SLinus Torvalds write_unlock_bh(&mrt_lock); 9071da177e4SLinus Torvalds 9081da177e4SLinus Torvalds mroute_clean_tables(sk); 9091da177e4SLinus Torvalds } 9101da177e4SLinus Torvalds rtnl_unlock(); 9111da177e4SLinus Torvalds } 9121da177e4SLinus Torvalds 9131da177e4SLinus Torvalds /* 9141da177e4SLinus Torvalds * Socket options and virtual interface manipulation. The whole 9151da177e4SLinus Torvalds * virtual interface system is a complete heap, but unfortunately 9161da177e4SLinus Torvalds * that's how BSD mrouted happens to think. Maybe one day with a proper 9171da177e4SLinus Torvalds * MOSPF/PIM router set up we can clean this up. 9181da177e4SLinus Torvalds */ 9191da177e4SLinus Torvalds 9201da177e4SLinus Torvalds int ip_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, int optlen) 9211da177e4SLinus Torvalds { 9221da177e4SLinus Torvalds int ret; 9231da177e4SLinus Torvalds struct vifctl vif; 9241da177e4SLinus Torvalds struct mfcctl mfc; 9251da177e4SLinus Torvalds 926132adf54SStephen Hemminger if (optname != MRT_INIT) { 92770a269e6SBenjamin Thery if (sk != init_net.ipv4.mroute_sk && !capable(CAP_NET_ADMIN)) 9281da177e4SLinus Torvalds return -EACCES; 9291da177e4SLinus Torvalds } 9301da177e4SLinus Torvalds 931132adf54SStephen Hemminger switch (optname) { 9321da177e4SLinus Torvalds case MRT_INIT: 9331da177e4SLinus Torvalds if (sk->sk_type != SOCK_RAW || 9341da177e4SLinus Torvalds inet_sk(sk)->num != IPPROTO_IGMP) 9351da177e4SLinus Torvalds return -EOPNOTSUPP; 9361da177e4SLinus Torvalds if (optlen != sizeof(int)) 9371da177e4SLinus Torvalds return -ENOPROTOOPT; 9381da177e4SLinus Torvalds 9391da177e4SLinus Torvalds rtnl_lock(); 94070a269e6SBenjamin Thery if (init_net.ipv4.mroute_sk) { 9411da177e4SLinus Torvalds rtnl_unlock(); 9421da177e4SLinus Torvalds return -EADDRINUSE; 9431da177e4SLinus Torvalds } 9441da177e4SLinus Torvalds 9451da177e4SLinus Torvalds ret = ip_ra_control(sk, 1, mrtsock_destruct); 9461da177e4SLinus Torvalds if (ret == 0) { 9471da177e4SLinus Torvalds write_lock_bh(&mrt_lock); 94870a269e6SBenjamin Thery init_net.ipv4.mroute_sk = sk; 9491da177e4SLinus Torvalds write_unlock_bh(&mrt_lock); 9501da177e4SLinus Torvalds 9513b1e0a65SYOSHIFUJI Hideaki IPV4_DEVCONF_ALL(sock_net(sk), MC_FORWARDING)++; 9521da177e4SLinus Torvalds } 9531da177e4SLinus Torvalds rtnl_unlock(); 9541da177e4SLinus Torvalds return ret; 9551da177e4SLinus Torvalds case MRT_DONE: 95670a269e6SBenjamin Thery if (sk != init_net.ipv4.mroute_sk) 9571da177e4SLinus Torvalds return -EACCES; 9581da177e4SLinus Torvalds return ip_ra_control(sk, 0, NULL); 9591da177e4SLinus Torvalds case MRT_ADD_VIF: 9601da177e4SLinus Torvalds case MRT_DEL_VIF: 9611da177e4SLinus Torvalds if (optlen != sizeof(vif)) 9621da177e4SLinus Torvalds return -EINVAL; 9631da177e4SLinus Torvalds if (copy_from_user(&vif, optval, sizeof(vif))) 9641da177e4SLinus Torvalds return -EFAULT; 9651da177e4SLinus Torvalds if (vif.vifc_vifi >= MAXVIFS) 9661da177e4SLinus Torvalds return -ENFILE; 9671da177e4SLinus Torvalds rtnl_lock(); 9681da177e4SLinus Torvalds if (optname == MRT_ADD_VIF) { 96970a269e6SBenjamin Thery ret = vif_add(&vif, sk == init_net.ipv4.mroute_sk); 9701da177e4SLinus Torvalds } else { 9717dc00c82SWang Chen ret = vif_delete(vif.vifc_vifi, 0); 9721da177e4SLinus Torvalds } 9731da177e4SLinus Torvalds rtnl_unlock(); 9741da177e4SLinus Torvalds return ret; 9751da177e4SLinus Torvalds 9761da177e4SLinus Torvalds /* 9771da177e4SLinus Torvalds * Manipulate the forwarding caches. These live 9781da177e4SLinus Torvalds * in a sort of kernel/user symbiosis. 9791da177e4SLinus Torvalds */ 9801da177e4SLinus Torvalds case MRT_ADD_MFC: 9811da177e4SLinus Torvalds case MRT_DEL_MFC: 9821da177e4SLinus Torvalds if (optlen != sizeof(mfc)) 9831da177e4SLinus Torvalds return -EINVAL; 9841da177e4SLinus Torvalds if (copy_from_user(&mfc, optval, sizeof(mfc))) 9851da177e4SLinus Torvalds return -EFAULT; 9861da177e4SLinus Torvalds rtnl_lock(); 9871da177e4SLinus Torvalds if (optname == MRT_DEL_MFC) 9881da177e4SLinus Torvalds ret = ipmr_mfc_delete(&mfc); 9891da177e4SLinus Torvalds else 99070a269e6SBenjamin Thery ret = ipmr_mfc_add(&mfc, sk == init_net.ipv4.mroute_sk); 9911da177e4SLinus Torvalds rtnl_unlock(); 9921da177e4SLinus Torvalds return ret; 9931da177e4SLinus Torvalds /* 9941da177e4SLinus Torvalds * Control PIM assert. 9951da177e4SLinus Torvalds */ 9961da177e4SLinus Torvalds case MRT_ASSERT: 9971da177e4SLinus Torvalds { 9981da177e4SLinus Torvalds int v; 9991da177e4SLinus Torvalds if (get_user(v,(int __user *)optval)) 10001da177e4SLinus Torvalds return -EFAULT; 10016f9374a9SBenjamin Thery init_net.ipv4.mroute_do_assert = (v) ? 1 : 0; 10021da177e4SLinus Torvalds return 0; 10031da177e4SLinus Torvalds } 10041da177e4SLinus Torvalds #ifdef CONFIG_IP_PIMSM 10051da177e4SLinus Torvalds case MRT_PIM: 10061da177e4SLinus Torvalds { 1007ba93ef74SStephen Hemminger int v; 1008ba93ef74SStephen Hemminger 10091da177e4SLinus Torvalds if (get_user(v,(int __user *)optval)) 10101da177e4SLinus Torvalds return -EFAULT; 10111da177e4SLinus Torvalds v = (v) ? 1 : 0; 1012ba93ef74SStephen Hemminger 10131da177e4SLinus Torvalds rtnl_lock(); 10141da177e4SLinus Torvalds ret = 0; 10156f9374a9SBenjamin Thery if (v != init_net.ipv4.mroute_do_pim) { 10166f9374a9SBenjamin Thery init_net.ipv4.mroute_do_pim = v; 10176f9374a9SBenjamin Thery init_net.ipv4.mroute_do_assert = v; 10181da177e4SLinus Torvalds #ifdef CONFIG_IP_PIMSM_V2 10196f9374a9SBenjamin Thery if (init_net.ipv4.mroute_do_pim) 10201da177e4SLinus Torvalds ret = inet_add_protocol(&pim_protocol, 10211da177e4SLinus Torvalds IPPROTO_PIM); 10221da177e4SLinus Torvalds else 10231da177e4SLinus Torvalds ret = inet_del_protocol(&pim_protocol, 10241da177e4SLinus Torvalds IPPROTO_PIM); 10251da177e4SLinus Torvalds if (ret < 0) 10261da177e4SLinus Torvalds ret = -EAGAIN; 10271da177e4SLinus Torvalds #endif 10281da177e4SLinus Torvalds } 10291da177e4SLinus Torvalds rtnl_unlock(); 10301da177e4SLinus Torvalds return ret; 10311da177e4SLinus Torvalds } 10321da177e4SLinus Torvalds #endif 10331da177e4SLinus Torvalds /* 10341da177e4SLinus Torvalds * Spurious command, or MRT_VERSION which you cannot 10351da177e4SLinus Torvalds * set. 10361da177e4SLinus Torvalds */ 10371da177e4SLinus Torvalds default: 10381da177e4SLinus Torvalds return -ENOPROTOOPT; 10391da177e4SLinus Torvalds } 10401da177e4SLinus Torvalds } 10411da177e4SLinus Torvalds 10421da177e4SLinus Torvalds /* 10431da177e4SLinus Torvalds * Getsock opt support for the multicast routing system. 10441da177e4SLinus Torvalds */ 10451da177e4SLinus Torvalds 10461da177e4SLinus Torvalds int ip_mroute_getsockopt(struct sock *sk, int optname, char __user *optval, int __user *optlen) 10471da177e4SLinus Torvalds { 10481da177e4SLinus Torvalds int olr; 10491da177e4SLinus Torvalds int val; 10501da177e4SLinus Torvalds 10511da177e4SLinus Torvalds if (optname != MRT_VERSION && 10521da177e4SLinus Torvalds #ifdef CONFIG_IP_PIMSM 10531da177e4SLinus Torvalds optname!=MRT_PIM && 10541da177e4SLinus Torvalds #endif 10551da177e4SLinus Torvalds optname!=MRT_ASSERT) 10561da177e4SLinus Torvalds return -ENOPROTOOPT; 10571da177e4SLinus Torvalds 10581da177e4SLinus Torvalds if (get_user(olr, optlen)) 10591da177e4SLinus Torvalds return -EFAULT; 10601da177e4SLinus Torvalds 10611da177e4SLinus Torvalds olr = min_t(unsigned int, olr, sizeof(int)); 10621da177e4SLinus Torvalds if (olr < 0) 10631da177e4SLinus Torvalds return -EINVAL; 10641da177e4SLinus Torvalds 10651da177e4SLinus Torvalds if (put_user(olr, optlen)) 10661da177e4SLinus Torvalds return -EFAULT; 10671da177e4SLinus Torvalds if (optname == MRT_VERSION) 10681da177e4SLinus Torvalds val = 0x0305; 10691da177e4SLinus Torvalds #ifdef CONFIG_IP_PIMSM 10701da177e4SLinus Torvalds else if (optname == MRT_PIM) 10716f9374a9SBenjamin Thery val = init_net.ipv4.mroute_do_pim; 10721da177e4SLinus Torvalds #endif 10731da177e4SLinus Torvalds else 10746f9374a9SBenjamin Thery val = init_net.ipv4.mroute_do_assert; 10751da177e4SLinus Torvalds if (copy_to_user(optval, &val, olr)) 10761da177e4SLinus Torvalds return -EFAULT; 10771da177e4SLinus Torvalds return 0; 10781da177e4SLinus Torvalds } 10791da177e4SLinus Torvalds 10801da177e4SLinus Torvalds /* 10811da177e4SLinus Torvalds * The IP multicast ioctl support routines. 10821da177e4SLinus Torvalds */ 10831da177e4SLinus Torvalds 10841da177e4SLinus Torvalds int ipmr_ioctl(struct sock *sk, int cmd, void __user *arg) 10851da177e4SLinus Torvalds { 10861da177e4SLinus Torvalds struct sioc_sg_req sr; 10871da177e4SLinus Torvalds struct sioc_vif_req vr; 10881da177e4SLinus Torvalds struct vif_device *vif; 10891da177e4SLinus Torvalds struct mfc_cache *c; 10901da177e4SLinus Torvalds 1091132adf54SStephen Hemminger switch (cmd) { 10921da177e4SLinus Torvalds case SIOCGETVIFCNT: 10931da177e4SLinus Torvalds if (copy_from_user(&vr, arg, sizeof(vr))) 10941da177e4SLinus Torvalds return -EFAULT; 1095cf958ae3SBenjamin Thery if (vr.vifi >= init_net.ipv4.maxvif) 10961da177e4SLinus Torvalds return -EINVAL; 10971da177e4SLinus Torvalds read_lock(&mrt_lock); 1098cf958ae3SBenjamin Thery vif = &init_net.ipv4.vif_table[vr.vifi]; 1099cf958ae3SBenjamin Thery if (VIF_EXISTS(&init_net, vr.vifi)) { 11001da177e4SLinus Torvalds vr.icount = vif->pkt_in; 11011da177e4SLinus Torvalds vr.ocount = vif->pkt_out; 11021da177e4SLinus Torvalds vr.ibytes = vif->bytes_in; 11031da177e4SLinus Torvalds vr.obytes = vif->bytes_out; 11041da177e4SLinus Torvalds read_unlock(&mrt_lock); 11051da177e4SLinus Torvalds 11061da177e4SLinus Torvalds if (copy_to_user(arg, &vr, sizeof(vr))) 11071da177e4SLinus Torvalds return -EFAULT; 11081da177e4SLinus Torvalds return 0; 11091da177e4SLinus Torvalds } 11101da177e4SLinus Torvalds read_unlock(&mrt_lock); 11111da177e4SLinus Torvalds return -EADDRNOTAVAIL; 11121da177e4SLinus Torvalds case SIOCGETSGCNT: 11131da177e4SLinus Torvalds if (copy_from_user(&sr, arg, sizeof(sr))) 11141da177e4SLinus Torvalds return -EFAULT; 11151da177e4SLinus Torvalds 11161da177e4SLinus Torvalds read_lock(&mrt_lock); 11171da177e4SLinus Torvalds c = ipmr_cache_find(sr.src.s_addr, sr.grp.s_addr); 11181da177e4SLinus Torvalds if (c) { 11191da177e4SLinus Torvalds sr.pktcnt = c->mfc_un.res.pkt; 11201da177e4SLinus Torvalds sr.bytecnt = c->mfc_un.res.bytes; 11211da177e4SLinus Torvalds sr.wrong_if = c->mfc_un.res.wrong_if; 11221da177e4SLinus Torvalds read_unlock(&mrt_lock); 11231da177e4SLinus Torvalds 11241da177e4SLinus Torvalds if (copy_to_user(arg, &sr, sizeof(sr))) 11251da177e4SLinus Torvalds return -EFAULT; 11261da177e4SLinus Torvalds return 0; 11271da177e4SLinus Torvalds } 11281da177e4SLinus Torvalds read_unlock(&mrt_lock); 11291da177e4SLinus Torvalds return -EADDRNOTAVAIL; 11301da177e4SLinus Torvalds default: 11311da177e4SLinus Torvalds return -ENOIOCTLCMD; 11321da177e4SLinus Torvalds } 11331da177e4SLinus Torvalds } 11341da177e4SLinus Torvalds 11351da177e4SLinus Torvalds 11361da177e4SLinus Torvalds static int ipmr_device_event(struct notifier_block *this, unsigned long event, void *ptr) 11371da177e4SLinus Torvalds { 1138e9dc8653SEric W. Biederman struct net_device *dev = ptr; 11391da177e4SLinus Torvalds struct vif_device *v; 11401da177e4SLinus Torvalds int ct; 1141e9dc8653SEric W. Biederman 1142721499e8SYOSHIFUJI Hideaki if (!net_eq(dev_net(dev), &init_net)) 1143e9dc8653SEric W. Biederman return NOTIFY_DONE; 1144e9dc8653SEric W. Biederman 11451da177e4SLinus Torvalds if (event != NETDEV_UNREGISTER) 11461da177e4SLinus Torvalds return NOTIFY_DONE; 1147cf958ae3SBenjamin Thery v = &init_net.ipv4.vif_table[0]; 1148cf958ae3SBenjamin Thery for (ct = 0; ct < init_net.ipv4.maxvif; ct++, v++) { 1149e9dc8653SEric W. Biederman if (v->dev == dev) 11507dc00c82SWang Chen vif_delete(ct, 1); 11511da177e4SLinus Torvalds } 11521da177e4SLinus Torvalds return NOTIFY_DONE; 11531da177e4SLinus Torvalds } 11541da177e4SLinus Torvalds 11551da177e4SLinus Torvalds 11561da177e4SLinus Torvalds static struct notifier_block ip_mr_notifier = { 11571da177e4SLinus Torvalds .notifier_call = ipmr_device_event, 11581da177e4SLinus Torvalds }; 11591da177e4SLinus Torvalds 11601da177e4SLinus Torvalds /* 11611da177e4SLinus Torvalds * Encapsulate a packet by attaching a valid IPIP header to it. 11621da177e4SLinus Torvalds * This avoids tunnel drivers and other mess and gives us the speed so 11631da177e4SLinus Torvalds * important for multicast video. 11641da177e4SLinus Torvalds */ 11651da177e4SLinus Torvalds 1166114c7844SAl Viro static void ip_encap(struct sk_buff *skb, __be32 saddr, __be32 daddr) 11671da177e4SLinus Torvalds { 11688856dfa3SArnaldo Carvalho de Melo struct iphdr *iph; 1169eddc9ec5SArnaldo Carvalho de Melo struct iphdr *old_iph = ip_hdr(skb); 11708856dfa3SArnaldo Carvalho de Melo 11718856dfa3SArnaldo Carvalho de Melo skb_push(skb, sizeof(struct iphdr)); 1172b0e380b1SArnaldo Carvalho de Melo skb->transport_header = skb->network_header; 11738856dfa3SArnaldo Carvalho de Melo skb_reset_network_header(skb); 1174eddc9ec5SArnaldo Carvalho de Melo iph = ip_hdr(skb); 11751da177e4SLinus Torvalds 11761da177e4SLinus Torvalds iph->version = 4; 1177e023dd64SArnaldo Carvalho de Melo iph->tos = old_iph->tos; 1178e023dd64SArnaldo Carvalho de Melo iph->ttl = old_iph->ttl; 11791da177e4SLinus Torvalds iph->frag_off = 0; 11801da177e4SLinus Torvalds iph->daddr = daddr; 11811da177e4SLinus Torvalds iph->saddr = saddr; 11821da177e4SLinus Torvalds iph->protocol = IPPROTO_IPIP; 11831da177e4SLinus Torvalds iph->ihl = 5; 11841da177e4SLinus Torvalds iph->tot_len = htons(skb->len); 11851da177e4SLinus Torvalds ip_select_ident(iph, skb->dst, NULL); 11861da177e4SLinus Torvalds ip_send_check(iph); 11871da177e4SLinus Torvalds 11881da177e4SLinus Torvalds memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt)); 11891da177e4SLinus Torvalds nf_reset(skb); 11901da177e4SLinus Torvalds } 11911da177e4SLinus Torvalds 11921da177e4SLinus Torvalds static inline int ipmr_forward_finish(struct sk_buff *skb) 11931da177e4SLinus Torvalds { 11941da177e4SLinus Torvalds struct ip_options * opt = &(IPCB(skb)->opt); 11951da177e4SLinus Torvalds 11967c73a6faSPavel Emelyanov IP_INC_STATS_BH(dev_net(skb->dst->dev), IPSTATS_MIB_OUTFORWDATAGRAMS); 11971da177e4SLinus Torvalds 11981da177e4SLinus Torvalds if (unlikely(opt->optlen)) 11991da177e4SLinus Torvalds ip_forward_options(skb); 12001da177e4SLinus Torvalds 12011da177e4SLinus Torvalds return dst_output(skb); 12021da177e4SLinus Torvalds } 12031da177e4SLinus Torvalds 12041da177e4SLinus Torvalds /* 12051da177e4SLinus Torvalds * Processing handlers for ipmr_forward 12061da177e4SLinus Torvalds */ 12071da177e4SLinus Torvalds 12081da177e4SLinus Torvalds static void ipmr_queue_xmit(struct sk_buff *skb, struct mfc_cache *c, int vifi) 12091da177e4SLinus Torvalds { 1210eddc9ec5SArnaldo Carvalho de Melo const struct iphdr *iph = ip_hdr(skb); 1211cf958ae3SBenjamin Thery struct vif_device *vif = &init_net.ipv4.vif_table[vifi]; 12121da177e4SLinus Torvalds struct net_device *dev; 12131da177e4SLinus Torvalds struct rtable *rt; 12141da177e4SLinus Torvalds int encap = 0; 12151da177e4SLinus Torvalds 12161da177e4SLinus Torvalds if (vif->dev == NULL) 12171da177e4SLinus Torvalds goto out_free; 12181da177e4SLinus Torvalds 12191da177e4SLinus Torvalds #ifdef CONFIG_IP_PIMSM 12201da177e4SLinus Torvalds if (vif->flags & VIFF_REGISTER) { 12211da177e4SLinus Torvalds vif->pkt_out++; 12221da177e4SLinus Torvalds vif->bytes_out += skb->len; 1223cf3677aeSPavel Emelyanov vif->dev->stats.tx_bytes += skb->len; 1224cf3677aeSPavel Emelyanov vif->dev->stats.tx_packets++; 12251da177e4SLinus Torvalds ipmr_cache_report(skb, vifi, IGMPMSG_WHOLEPKT); 12261da177e4SLinus Torvalds kfree_skb(skb); 12271da177e4SLinus Torvalds return; 12281da177e4SLinus Torvalds } 12291da177e4SLinus Torvalds #endif 12301da177e4SLinus Torvalds 12311da177e4SLinus Torvalds if (vif->flags&VIFF_TUNNEL) { 12321da177e4SLinus Torvalds struct flowi fl = { .oif = vif->link, 12331da177e4SLinus Torvalds .nl_u = { .ip4_u = 12341da177e4SLinus Torvalds { .daddr = vif->remote, 12351da177e4SLinus Torvalds .saddr = vif->local, 12361da177e4SLinus Torvalds .tos = RT_TOS(iph->tos) } }, 12371da177e4SLinus Torvalds .proto = IPPROTO_IPIP }; 1238f206351aSDenis V. Lunev if (ip_route_output_key(&init_net, &rt, &fl)) 12391da177e4SLinus Torvalds goto out_free; 12401da177e4SLinus Torvalds encap = sizeof(struct iphdr); 12411da177e4SLinus Torvalds } else { 12421da177e4SLinus Torvalds struct flowi fl = { .oif = vif->link, 12431da177e4SLinus Torvalds .nl_u = { .ip4_u = 12441da177e4SLinus Torvalds { .daddr = iph->daddr, 12451da177e4SLinus Torvalds .tos = RT_TOS(iph->tos) } }, 12461da177e4SLinus Torvalds .proto = IPPROTO_IPIP }; 1247f206351aSDenis V. Lunev if (ip_route_output_key(&init_net, &rt, &fl)) 12481da177e4SLinus Torvalds goto out_free; 12491da177e4SLinus Torvalds } 12501da177e4SLinus Torvalds 12511da177e4SLinus Torvalds dev = rt->u.dst.dev; 12521da177e4SLinus Torvalds 12531da177e4SLinus Torvalds if (skb->len+encap > dst_mtu(&rt->u.dst) && (ntohs(iph->frag_off) & IP_DF)) { 12541da177e4SLinus Torvalds /* Do not fragment multicasts. Alas, IPv4 does not 12551da177e4SLinus Torvalds allow to send ICMP, so that packets will disappear 12561da177e4SLinus Torvalds to blackhole. 12571da177e4SLinus Torvalds */ 12581da177e4SLinus Torvalds 12597c73a6faSPavel Emelyanov IP_INC_STATS_BH(dev_net(dev), IPSTATS_MIB_FRAGFAILS); 12601da177e4SLinus Torvalds ip_rt_put(rt); 12611da177e4SLinus Torvalds goto out_free; 12621da177e4SLinus Torvalds } 12631da177e4SLinus Torvalds 12641da177e4SLinus Torvalds encap += LL_RESERVED_SPACE(dev) + rt->u.dst.header_len; 12651da177e4SLinus Torvalds 12661da177e4SLinus Torvalds if (skb_cow(skb, encap)) { 12671da177e4SLinus Torvalds ip_rt_put(rt); 12681da177e4SLinus Torvalds goto out_free; 12691da177e4SLinus Torvalds } 12701da177e4SLinus Torvalds 12711da177e4SLinus Torvalds vif->pkt_out++; 12721da177e4SLinus Torvalds vif->bytes_out += skb->len; 12731da177e4SLinus Torvalds 12741da177e4SLinus Torvalds dst_release(skb->dst); 12751da177e4SLinus Torvalds skb->dst = &rt->u.dst; 1276eddc9ec5SArnaldo Carvalho de Melo ip_decrease_ttl(ip_hdr(skb)); 12771da177e4SLinus Torvalds 12781da177e4SLinus Torvalds /* FIXME: forward and output firewalls used to be called here. 12791da177e4SLinus Torvalds * What do we do with netfilter? -- RR */ 12801da177e4SLinus Torvalds if (vif->flags & VIFF_TUNNEL) { 12811da177e4SLinus Torvalds ip_encap(skb, vif->local, vif->remote); 12821da177e4SLinus Torvalds /* FIXME: extra output firewall step used to be here. --RR */ 12832f4c02d4SPavel Emelyanov vif->dev->stats.tx_packets++; 12842f4c02d4SPavel Emelyanov vif->dev->stats.tx_bytes += skb->len; 12851da177e4SLinus Torvalds } 12861da177e4SLinus Torvalds 12871da177e4SLinus Torvalds IPCB(skb)->flags |= IPSKB_FORWARDED; 12881da177e4SLinus Torvalds 12891da177e4SLinus Torvalds /* 12901da177e4SLinus Torvalds * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally 12911da177e4SLinus Torvalds * not only before forwarding, but after forwarding on all output 12921da177e4SLinus Torvalds * interfaces. It is clear, if mrouter runs a multicasting 12931da177e4SLinus Torvalds * program, it should receive packets not depending to what interface 12941da177e4SLinus Torvalds * program is joined. 12951da177e4SLinus Torvalds * If we will not make it, the program will have to join on all 12961da177e4SLinus Torvalds * interfaces. On the other hand, multihoming host (or router, but 12971da177e4SLinus Torvalds * not mrouter) cannot join to more than one interface - it will 12981da177e4SLinus Torvalds * result in receiving multiple packets. 12991da177e4SLinus Torvalds */ 13006e23ae2aSPatrick McHardy NF_HOOK(PF_INET, NF_INET_FORWARD, skb, skb->dev, dev, 13011da177e4SLinus Torvalds ipmr_forward_finish); 13021da177e4SLinus Torvalds return; 13031da177e4SLinus Torvalds 13041da177e4SLinus Torvalds out_free: 13051da177e4SLinus Torvalds kfree_skb(skb); 13061da177e4SLinus Torvalds return; 13071da177e4SLinus Torvalds } 13081da177e4SLinus Torvalds 13091da177e4SLinus Torvalds static int ipmr_find_vif(struct net_device *dev) 13101da177e4SLinus Torvalds { 13111da177e4SLinus Torvalds int ct; 1312cf958ae3SBenjamin Thery for (ct = init_net.ipv4.maxvif-1; ct >= 0; ct--) { 1313cf958ae3SBenjamin Thery if (init_net.ipv4.vif_table[ct].dev == dev) 13141da177e4SLinus Torvalds break; 13151da177e4SLinus Torvalds } 13161da177e4SLinus Torvalds return ct; 13171da177e4SLinus Torvalds } 13181da177e4SLinus Torvalds 13191da177e4SLinus Torvalds /* "local" means that we should preserve one skb (for local delivery) */ 13201da177e4SLinus Torvalds 13211da177e4SLinus Torvalds static int ip_mr_forward(struct sk_buff *skb, struct mfc_cache *cache, int local) 13221da177e4SLinus Torvalds { 13231da177e4SLinus Torvalds int psend = -1; 13241da177e4SLinus Torvalds int vif, ct; 13251da177e4SLinus Torvalds 13261da177e4SLinus Torvalds vif = cache->mfc_parent; 13271da177e4SLinus Torvalds cache->mfc_un.res.pkt++; 13281da177e4SLinus Torvalds cache->mfc_un.res.bytes += skb->len; 13291da177e4SLinus Torvalds 13301da177e4SLinus Torvalds /* 13311da177e4SLinus Torvalds * Wrong interface: drop packet and (maybe) send PIM assert. 13321da177e4SLinus Torvalds */ 1333cf958ae3SBenjamin Thery if (init_net.ipv4.vif_table[vif].dev != skb->dev) { 13341da177e4SLinus Torvalds int true_vifi; 13351da177e4SLinus Torvalds 1336ee6b9673SEric Dumazet if (skb->rtable->fl.iif == 0) { 13371da177e4SLinus Torvalds /* It is our own packet, looped back. 13381da177e4SLinus Torvalds Very complicated situation... 13391da177e4SLinus Torvalds 13401da177e4SLinus Torvalds The best workaround until routing daemons will be 13411da177e4SLinus Torvalds fixed is not to redistribute packet, if it was 13421da177e4SLinus Torvalds send through wrong interface. It means, that 13431da177e4SLinus Torvalds multicast applications WILL NOT work for 13441da177e4SLinus Torvalds (S,G), which have default multicast route pointing 13451da177e4SLinus Torvalds to wrong oif. In any case, it is not a good 13461da177e4SLinus Torvalds idea to use multicasting applications on router. 13471da177e4SLinus Torvalds */ 13481da177e4SLinus Torvalds goto dont_forward; 13491da177e4SLinus Torvalds } 13501da177e4SLinus Torvalds 13511da177e4SLinus Torvalds cache->mfc_un.res.wrong_if++; 13521da177e4SLinus Torvalds true_vifi = ipmr_find_vif(skb->dev); 13531da177e4SLinus Torvalds 13546f9374a9SBenjamin Thery if (true_vifi >= 0 && init_net.ipv4.mroute_do_assert && 13551da177e4SLinus Torvalds /* pimsm uses asserts, when switching from RPT to SPT, 13561da177e4SLinus Torvalds so that we cannot check that packet arrived on an oif. 13571da177e4SLinus Torvalds It is bad, but otherwise we would need to move pretty 13581da177e4SLinus Torvalds large chunk of pimd to kernel. Ough... --ANK 13591da177e4SLinus Torvalds */ 13606f9374a9SBenjamin Thery (init_net.ipv4.mroute_do_pim || 13616f9374a9SBenjamin Thery cache->mfc_un.res.ttls[true_vifi] < 255) && 13621da177e4SLinus Torvalds time_after(jiffies, 13631da177e4SLinus Torvalds cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) { 13641da177e4SLinus Torvalds cache->mfc_un.res.last_assert = jiffies; 13651da177e4SLinus Torvalds ipmr_cache_report(skb, true_vifi, IGMPMSG_WRONGVIF); 13661da177e4SLinus Torvalds } 13671da177e4SLinus Torvalds goto dont_forward; 13681da177e4SLinus Torvalds } 13691da177e4SLinus Torvalds 1370cf958ae3SBenjamin Thery init_net.ipv4.vif_table[vif].pkt_in++; 1371cf958ae3SBenjamin Thery init_net.ipv4.vif_table[vif].bytes_in += skb->len; 13721da177e4SLinus Torvalds 13731da177e4SLinus Torvalds /* 13741da177e4SLinus Torvalds * Forward the frame 13751da177e4SLinus Torvalds */ 13761da177e4SLinus Torvalds for (ct = cache->mfc_un.res.maxvif-1; ct >= cache->mfc_un.res.minvif; ct--) { 1377eddc9ec5SArnaldo Carvalho de Melo if (ip_hdr(skb)->ttl > cache->mfc_un.res.ttls[ct]) { 13781da177e4SLinus Torvalds if (psend != -1) { 13791da177e4SLinus Torvalds struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC); 13801da177e4SLinus Torvalds if (skb2) 13811da177e4SLinus Torvalds ipmr_queue_xmit(skb2, cache, psend); 13821da177e4SLinus Torvalds } 13831da177e4SLinus Torvalds psend = ct; 13841da177e4SLinus Torvalds } 13851da177e4SLinus Torvalds } 13861da177e4SLinus Torvalds if (psend != -1) { 13871da177e4SLinus Torvalds if (local) { 13881da177e4SLinus Torvalds struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC); 13891da177e4SLinus Torvalds if (skb2) 13901da177e4SLinus Torvalds ipmr_queue_xmit(skb2, cache, psend); 13911da177e4SLinus Torvalds } else { 13921da177e4SLinus Torvalds ipmr_queue_xmit(skb, cache, psend); 13931da177e4SLinus Torvalds return 0; 13941da177e4SLinus Torvalds } 13951da177e4SLinus Torvalds } 13961da177e4SLinus Torvalds 13971da177e4SLinus Torvalds dont_forward: 13981da177e4SLinus Torvalds if (!local) 13991da177e4SLinus Torvalds kfree_skb(skb); 14001da177e4SLinus Torvalds return 0; 14011da177e4SLinus Torvalds } 14021da177e4SLinus Torvalds 14031da177e4SLinus Torvalds 14041da177e4SLinus Torvalds /* 14051da177e4SLinus Torvalds * Multicast packets for forwarding arrive here 14061da177e4SLinus Torvalds */ 14071da177e4SLinus Torvalds 14081da177e4SLinus Torvalds int ip_mr_input(struct sk_buff *skb) 14091da177e4SLinus Torvalds { 14101da177e4SLinus Torvalds struct mfc_cache *cache; 1411ee6b9673SEric Dumazet int local = skb->rtable->rt_flags&RTCF_LOCAL; 14121da177e4SLinus Torvalds 14131da177e4SLinus Torvalds /* Packet is looped back after forward, it should not be 14141da177e4SLinus Torvalds forwarded second time, but still can be delivered locally. 14151da177e4SLinus Torvalds */ 14161da177e4SLinus Torvalds if (IPCB(skb)->flags&IPSKB_FORWARDED) 14171da177e4SLinus Torvalds goto dont_forward; 14181da177e4SLinus Torvalds 14191da177e4SLinus Torvalds if (!local) { 14201da177e4SLinus Torvalds if (IPCB(skb)->opt.router_alert) { 14211da177e4SLinus Torvalds if (ip_call_ra_chain(skb)) 14221da177e4SLinus Torvalds return 0; 1423eddc9ec5SArnaldo Carvalho de Melo } else if (ip_hdr(skb)->protocol == IPPROTO_IGMP){ 14241da177e4SLinus Torvalds /* IGMPv1 (and broken IGMPv2 implementations sort of 14251da177e4SLinus Torvalds Cisco IOS <= 11.2(8)) do not put router alert 14261da177e4SLinus Torvalds option to IGMP packets destined to routable 14271da177e4SLinus Torvalds groups. It is very bad, because it means 14281da177e4SLinus Torvalds that we can forward NO IGMP messages. 14291da177e4SLinus Torvalds */ 14301da177e4SLinus Torvalds read_lock(&mrt_lock); 143170a269e6SBenjamin Thery if (init_net.ipv4.mroute_sk) { 14322715bcf9SPatrick McHardy nf_reset(skb); 143370a269e6SBenjamin Thery raw_rcv(init_net.ipv4.mroute_sk, skb); 14341da177e4SLinus Torvalds read_unlock(&mrt_lock); 14351da177e4SLinus Torvalds return 0; 14361da177e4SLinus Torvalds } 14371da177e4SLinus Torvalds read_unlock(&mrt_lock); 14381da177e4SLinus Torvalds } 14391da177e4SLinus Torvalds } 14401da177e4SLinus Torvalds 14411da177e4SLinus Torvalds read_lock(&mrt_lock); 1442eddc9ec5SArnaldo Carvalho de Melo cache = ipmr_cache_find(ip_hdr(skb)->saddr, ip_hdr(skb)->daddr); 14431da177e4SLinus Torvalds 14441da177e4SLinus Torvalds /* 14451da177e4SLinus Torvalds * No usable cache entry 14461da177e4SLinus Torvalds */ 14471da177e4SLinus Torvalds if (cache == NULL) { 14481da177e4SLinus Torvalds int vif; 14491da177e4SLinus Torvalds 14501da177e4SLinus Torvalds if (local) { 14511da177e4SLinus Torvalds struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC); 14521da177e4SLinus Torvalds ip_local_deliver(skb); 14531da177e4SLinus Torvalds if (skb2 == NULL) { 14541da177e4SLinus Torvalds read_unlock(&mrt_lock); 14551da177e4SLinus Torvalds return -ENOBUFS; 14561da177e4SLinus Torvalds } 14571da177e4SLinus Torvalds skb = skb2; 14581da177e4SLinus Torvalds } 14591da177e4SLinus Torvalds 14601da177e4SLinus Torvalds vif = ipmr_find_vif(skb->dev); 14611da177e4SLinus Torvalds if (vif >= 0) { 14621da177e4SLinus Torvalds int err = ipmr_cache_unresolved(vif, skb); 14631da177e4SLinus Torvalds read_unlock(&mrt_lock); 14641da177e4SLinus Torvalds 14651da177e4SLinus Torvalds return err; 14661da177e4SLinus Torvalds } 14671da177e4SLinus Torvalds read_unlock(&mrt_lock); 14681da177e4SLinus Torvalds kfree_skb(skb); 14691da177e4SLinus Torvalds return -ENODEV; 14701da177e4SLinus Torvalds } 14711da177e4SLinus Torvalds 14721da177e4SLinus Torvalds ip_mr_forward(skb, cache, local); 14731da177e4SLinus Torvalds 14741da177e4SLinus Torvalds read_unlock(&mrt_lock); 14751da177e4SLinus Torvalds 14761da177e4SLinus Torvalds if (local) 14771da177e4SLinus Torvalds return ip_local_deliver(skb); 14781da177e4SLinus Torvalds 14791da177e4SLinus Torvalds return 0; 14801da177e4SLinus Torvalds 14811da177e4SLinus Torvalds dont_forward: 14821da177e4SLinus Torvalds if (local) 14831da177e4SLinus Torvalds return ip_local_deliver(skb); 14841da177e4SLinus Torvalds kfree_skb(skb); 14851da177e4SLinus Torvalds return 0; 14861da177e4SLinus Torvalds } 14871da177e4SLinus Torvalds 1488b1879204SIlpo Järvinen #ifdef CONFIG_IP_PIMSM 1489b1879204SIlpo Järvinen static int __pim_rcv(struct sk_buff *skb, unsigned int pimlen) 14901da177e4SLinus Torvalds { 14911da177e4SLinus Torvalds struct net_device *reg_dev = NULL; 1492b1879204SIlpo Järvinen struct iphdr *encap; 14931da177e4SLinus Torvalds 1494b1879204SIlpo Järvinen encap = (struct iphdr *)(skb_transport_header(skb) + pimlen); 14951da177e4SLinus Torvalds /* 14961da177e4SLinus Torvalds Check that: 14971da177e4SLinus Torvalds a. packet is really destinted to a multicast group 14981da177e4SLinus Torvalds b. packet is not a NULL-REGISTER 14991da177e4SLinus Torvalds c. packet is not truncated 15001da177e4SLinus Torvalds */ 1501f97c1e0cSJoe Perches if (!ipv4_is_multicast(encap->daddr) || 15021da177e4SLinus Torvalds encap->tot_len == 0 || 1503b1879204SIlpo Järvinen ntohs(encap->tot_len) + pimlen > skb->len) 1504b1879204SIlpo Järvinen return 1; 15051da177e4SLinus Torvalds 15061da177e4SLinus Torvalds read_lock(&mrt_lock); 1507*6c5143dbSBenjamin Thery if (init_net.ipv4.mroute_reg_vif_num >= 0) 1508*6c5143dbSBenjamin Thery reg_dev = init_net.ipv4.vif_table[init_net.ipv4.mroute_reg_vif_num].dev; 15091da177e4SLinus Torvalds if (reg_dev) 15101da177e4SLinus Torvalds dev_hold(reg_dev); 15111da177e4SLinus Torvalds read_unlock(&mrt_lock); 15121da177e4SLinus Torvalds 15131da177e4SLinus Torvalds if (reg_dev == NULL) 1514b1879204SIlpo Järvinen return 1; 15151da177e4SLinus Torvalds 1516b0e380b1SArnaldo Carvalho de Melo skb->mac_header = skb->network_header; 15171da177e4SLinus Torvalds skb_pull(skb, (u8*)encap - skb->data); 151831c7711bSArnaldo Carvalho de Melo skb_reset_network_header(skb); 15191da177e4SLinus Torvalds skb->dev = reg_dev; 15201da177e4SLinus Torvalds skb->protocol = htons(ETH_P_IP); 15211da177e4SLinus Torvalds skb->ip_summed = 0; 15221da177e4SLinus Torvalds skb->pkt_type = PACKET_HOST; 15231da177e4SLinus Torvalds dst_release(skb->dst); 15241da177e4SLinus Torvalds skb->dst = NULL; 1525cf3677aeSPavel Emelyanov reg_dev->stats.rx_bytes += skb->len; 1526cf3677aeSPavel Emelyanov reg_dev->stats.rx_packets++; 15271da177e4SLinus Torvalds nf_reset(skb); 15281da177e4SLinus Torvalds netif_rx(skb); 15291da177e4SLinus Torvalds dev_put(reg_dev); 1530b1879204SIlpo Järvinen 15311da177e4SLinus Torvalds return 0; 1532b1879204SIlpo Järvinen } 1533b1879204SIlpo Järvinen #endif 1534b1879204SIlpo Järvinen 1535b1879204SIlpo Järvinen #ifdef CONFIG_IP_PIMSM_V1 1536b1879204SIlpo Järvinen /* 1537b1879204SIlpo Järvinen * Handle IGMP messages of PIMv1 1538b1879204SIlpo Järvinen */ 1539b1879204SIlpo Järvinen 1540b1879204SIlpo Järvinen int pim_rcv_v1(struct sk_buff * skb) 1541b1879204SIlpo Järvinen { 1542b1879204SIlpo Järvinen struct igmphdr *pim; 1543b1879204SIlpo Järvinen 1544b1879204SIlpo Järvinen if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(struct iphdr))) 1545b1879204SIlpo Järvinen goto drop; 1546b1879204SIlpo Järvinen 1547b1879204SIlpo Järvinen pim = igmp_hdr(skb); 1548b1879204SIlpo Järvinen 15496f9374a9SBenjamin Thery if (!init_net.ipv4.mroute_do_pim || 1550b1879204SIlpo Järvinen pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER) 1551b1879204SIlpo Järvinen goto drop; 1552b1879204SIlpo Järvinen 1553b1879204SIlpo Järvinen if (__pim_rcv(skb, sizeof(*pim))) { 15541da177e4SLinus Torvalds drop: 15551da177e4SLinus Torvalds kfree_skb(skb); 1556b1879204SIlpo Järvinen } 15571da177e4SLinus Torvalds return 0; 15581da177e4SLinus Torvalds } 15591da177e4SLinus Torvalds #endif 15601da177e4SLinus Torvalds 15611da177e4SLinus Torvalds #ifdef CONFIG_IP_PIMSM_V2 15621da177e4SLinus Torvalds static int pim_rcv(struct sk_buff * skb) 15631da177e4SLinus Torvalds { 15641da177e4SLinus Torvalds struct pimreghdr *pim; 15651da177e4SLinus Torvalds 1566b1879204SIlpo Järvinen if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(struct iphdr))) 15671da177e4SLinus Torvalds goto drop; 15681da177e4SLinus Torvalds 15699c70220bSArnaldo Carvalho de Melo pim = (struct pimreghdr *)skb_transport_header(skb); 15701da177e4SLinus Torvalds if (pim->type != ((PIM_VERSION<<4)|(PIM_REGISTER)) || 15711da177e4SLinus Torvalds (pim->flags&PIM_NULL_REGISTER) || 15721da177e4SLinus Torvalds (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 && 1573d3bc23e7SAl Viro csum_fold(skb_checksum(skb, 0, skb->len, 0)))) 15741da177e4SLinus Torvalds goto drop; 15751da177e4SLinus Torvalds 1576b1879204SIlpo Järvinen if (__pim_rcv(skb, sizeof(*pim))) { 15771da177e4SLinus Torvalds drop: 15781da177e4SLinus Torvalds kfree_skb(skb); 1579b1879204SIlpo Järvinen } 15801da177e4SLinus Torvalds return 0; 15811da177e4SLinus Torvalds } 15821da177e4SLinus Torvalds #endif 15831da177e4SLinus Torvalds 15841da177e4SLinus Torvalds static int 15851da177e4SLinus Torvalds ipmr_fill_mroute(struct sk_buff *skb, struct mfc_cache *c, struct rtmsg *rtm) 15861da177e4SLinus Torvalds { 15871da177e4SLinus Torvalds int ct; 15881da177e4SLinus Torvalds struct rtnexthop *nhp; 1589cf958ae3SBenjamin Thery struct net_device *dev = init_net.ipv4.vif_table[c->mfc_parent].dev; 159027a884dcSArnaldo Carvalho de Melo u8 *b = skb_tail_pointer(skb); 15911da177e4SLinus Torvalds struct rtattr *mp_head; 15921da177e4SLinus Torvalds 15931da177e4SLinus Torvalds if (dev) 15941da177e4SLinus Torvalds RTA_PUT(skb, RTA_IIF, 4, &dev->ifindex); 15951da177e4SLinus Torvalds 15961da177e4SLinus Torvalds mp_head = (struct rtattr *)skb_put(skb, RTA_LENGTH(0)); 15971da177e4SLinus Torvalds 15981da177e4SLinus Torvalds for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) { 15991da177e4SLinus Torvalds if (c->mfc_un.res.ttls[ct] < 255) { 16001da177e4SLinus Torvalds if (skb_tailroom(skb) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp)) + 4)) 16011da177e4SLinus Torvalds goto rtattr_failure; 16021da177e4SLinus Torvalds nhp = (struct rtnexthop *)skb_put(skb, RTA_ALIGN(sizeof(*nhp))); 16031da177e4SLinus Torvalds nhp->rtnh_flags = 0; 16041da177e4SLinus Torvalds nhp->rtnh_hops = c->mfc_un.res.ttls[ct]; 1605cf958ae3SBenjamin Thery nhp->rtnh_ifindex = init_net.ipv4.vif_table[ct].dev->ifindex; 16061da177e4SLinus Torvalds nhp->rtnh_len = sizeof(*nhp); 16071da177e4SLinus Torvalds } 16081da177e4SLinus Torvalds } 16091da177e4SLinus Torvalds mp_head->rta_type = RTA_MULTIPATH; 161027a884dcSArnaldo Carvalho de Melo mp_head->rta_len = skb_tail_pointer(skb) - (u8 *)mp_head; 16111da177e4SLinus Torvalds rtm->rtm_type = RTN_MULTICAST; 16121da177e4SLinus Torvalds return 1; 16131da177e4SLinus Torvalds 16141da177e4SLinus Torvalds rtattr_failure: 1615dc5fc579SArnaldo Carvalho de Melo nlmsg_trim(skb, b); 16161da177e4SLinus Torvalds return -EMSGSIZE; 16171da177e4SLinus Torvalds } 16181da177e4SLinus Torvalds 16191da177e4SLinus Torvalds int ipmr_get_route(struct sk_buff *skb, struct rtmsg *rtm, int nowait) 16201da177e4SLinus Torvalds { 16211da177e4SLinus Torvalds int err; 16221da177e4SLinus Torvalds struct mfc_cache *cache; 1623ee6b9673SEric Dumazet struct rtable *rt = skb->rtable; 16241da177e4SLinus Torvalds 16251da177e4SLinus Torvalds read_lock(&mrt_lock); 16261da177e4SLinus Torvalds cache = ipmr_cache_find(rt->rt_src, rt->rt_dst); 16271da177e4SLinus Torvalds 16281da177e4SLinus Torvalds if (cache == NULL) { 162972287490SAlexey Kuznetsov struct sk_buff *skb2; 1630eddc9ec5SArnaldo Carvalho de Melo struct iphdr *iph; 16311da177e4SLinus Torvalds struct net_device *dev; 16321da177e4SLinus Torvalds int vif; 16331da177e4SLinus Torvalds 16341da177e4SLinus Torvalds if (nowait) { 16351da177e4SLinus Torvalds read_unlock(&mrt_lock); 16361da177e4SLinus Torvalds return -EAGAIN; 16371da177e4SLinus Torvalds } 16381da177e4SLinus Torvalds 16391da177e4SLinus Torvalds dev = skb->dev; 16401da177e4SLinus Torvalds if (dev == NULL || (vif = ipmr_find_vif(dev)) < 0) { 16411da177e4SLinus Torvalds read_unlock(&mrt_lock); 16421da177e4SLinus Torvalds return -ENODEV; 16431da177e4SLinus Torvalds } 164472287490SAlexey Kuznetsov skb2 = skb_clone(skb, GFP_ATOMIC); 164572287490SAlexey Kuznetsov if (!skb2) { 164672287490SAlexey Kuznetsov read_unlock(&mrt_lock); 164772287490SAlexey Kuznetsov return -ENOMEM; 164872287490SAlexey Kuznetsov } 164972287490SAlexey Kuznetsov 1650e2d1bca7SArnaldo Carvalho de Melo skb_push(skb2, sizeof(struct iphdr)); 1651e2d1bca7SArnaldo Carvalho de Melo skb_reset_network_header(skb2); 1652eddc9ec5SArnaldo Carvalho de Melo iph = ip_hdr(skb2); 1653eddc9ec5SArnaldo Carvalho de Melo iph->ihl = sizeof(struct iphdr) >> 2; 1654eddc9ec5SArnaldo Carvalho de Melo iph->saddr = rt->rt_src; 1655eddc9ec5SArnaldo Carvalho de Melo iph->daddr = rt->rt_dst; 1656eddc9ec5SArnaldo Carvalho de Melo iph->version = 0; 165772287490SAlexey Kuznetsov err = ipmr_cache_unresolved(vif, skb2); 16581da177e4SLinus Torvalds read_unlock(&mrt_lock); 16591da177e4SLinus Torvalds return err; 16601da177e4SLinus Torvalds } 16611da177e4SLinus Torvalds 16621da177e4SLinus Torvalds if (!nowait && (rtm->rtm_flags&RTM_F_NOTIFY)) 16631da177e4SLinus Torvalds cache->mfc_flags |= MFC_NOTIFY; 16641da177e4SLinus Torvalds err = ipmr_fill_mroute(skb, cache, rtm); 16651da177e4SLinus Torvalds read_unlock(&mrt_lock); 16661da177e4SLinus Torvalds return err; 16671da177e4SLinus Torvalds } 16681da177e4SLinus Torvalds 16691da177e4SLinus Torvalds #ifdef CONFIG_PROC_FS 16701da177e4SLinus Torvalds /* 16711da177e4SLinus Torvalds * The /proc interfaces to multicast routing /proc/ip_mr_cache /proc/ip_mr_vif 16721da177e4SLinus Torvalds */ 16731da177e4SLinus Torvalds struct ipmr_vif_iter { 16741da177e4SLinus Torvalds int ct; 16751da177e4SLinus Torvalds }; 16761da177e4SLinus Torvalds 16771da177e4SLinus Torvalds static struct vif_device *ipmr_vif_seq_idx(struct ipmr_vif_iter *iter, 16781da177e4SLinus Torvalds loff_t pos) 16791da177e4SLinus Torvalds { 1680cf958ae3SBenjamin Thery for (iter->ct = 0; iter->ct < init_net.ipv4.maxvif; ++iter->ct) { 1681cf958ae3SBenjamin Thery if (!VIF_EXISTS(&init_net, iter->ct)) 16821da177e4SLinus Torvalds continue; 16831da177e4SLinus Torvalds if (pos-- == 0) 1684cf958ae3SBenjamin Thery return &init_net.ipv4.vif_table[iter->ct]; 16851da177e4SLinus Torvalds } 16861da177e4SLinus Torvalds return NULL; 16871da177e4SLinus Torvalds } 16881da177e4SLinus Torvalds 16891da177e4SLinus Torvalds static void *ipmr_vif_seq_start(struct seq_file *seq, loff_t *pos) 1690ba93ef74SStephen Hemminger __acquires(mrt_lock) 16911da177e4SLinus Torvalds { 16921da177e4SLinus Torvalds read_lock(&mrt_lock); 16931da177e4SLinus Torvalds return *pos ? ipmr_vif_seq_idx(seq->private, *pos - 1) 16941da177e4SLinus Torvalds : SEQ_START_TOKEN; 16951da177e4SLinus Torvalds } 16961da177e4SLinus Torvalds 16971da177e4SLinus Torvalds static void *ipmr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos) 16981da177e4SLinus Torvalds { 16991da177e4SLinus Torvalds struct ipmr_vif_iter *iter = seq->private; 17001da177e4SLinus Torvalds 17011da177e4SLinus Torvalds ++*pos; 17021da177e4SLinus Torvalds if (v == SEQ_START_TOKEN) 17031da177e4SLinus Torvalds return ipmr_vif_seq_idx(iter, 0); 17041da177e4SLinus Torvalds 1705cf958ae3SBenjamin Thery while (++iter->ct < init_net.ipv4.maxvif) { 1706cf958ae3SBenjamin Thery if (!VIF_EXISTS(&init_net, iter->ct)) 17071da177e4SLinus Torvalds continue; 1708cf958ae3SBenjamin Thery return &init_net.ipv4.vif_table[iter->ct]; 17091da177e4SLinus Torvalds } 17101da177e4SLinus Torvalds return NULL; 17111da177e4SLinus Torvalds } 17121da177e4SLinus Torvalds 17131da177e4SLinus Torvalds static void ipmr_vif_seq_stop(struct seq_file *seq, void *v) 1714ba93ef74SStephen Hemminger __releases(mrt_lock) 17151da177e4SLinus Torvalds { 17161da177e4SLinus Torvalds read_unlock(&mrt_lock); 17171da177e4SLinus Torvalds } 17181da177e4SLinus Torvalds 17191da177e4SLinus Torvalds static int ipmr_vif_seq_show(struct seq_file *seq, void *v) 17201da177e4SLinus Torvalds { 17211da177e4SLinus Torvalds if (v == SEQ_START_TOKEN) { 17221da177e4SLinus Torvalds seq_puts(seq, 17231da177e4SLinus Torvalds "Interface BytesIn PktsIn BytesOut PktsOut Flags Local Remote\n"); 17241da177e4SLinus Torvalds } else { 17251da177e4SLinus Torvalds const struct vif_device *vif = v; 17261da177e4SLinus Torvalds const char *name = vif->dev ? vif->dev->name : "none"; 17271da177e4SLinus Torvalds 17281da177e4SLinus Torvalds seq_printf(seq, 17291da177e4SLinus Torvalds "%2Zd %-10s %8ld %7ld %8ld %7ld %05X %08X %08X\n", 1730cf958ae3SBenjamin Thery vif - init_net.ipv4.vif_table, 17311da177e4SLinus Torvalds name, vif->bytes_in, vif->pkt_in, 17321da177e4SLinus Torvalds vif->bytes_out, vif->pkt_out, 17331da177e4SLinus Torvalds vif->flags, vif->local, vif->remote); 17341da177e4SLinus Torvalds } 17351da177e4SLinus Torvalds return 0; 17361da177e4SLinus Torvalds } 17371da177e4SLinus Torvalds 1738f690808eSStephen Hemminger static const struct seq_operations ipmr_vif_seq_ops = { 17391da177e4SLinus Torvalds .start = ipmr_vif_seq_start, 17401da177e4SLinus Torvalds .next = ipmr_vif_seq_next, 17411da177e4SLinus Torvalds .stop = ipmr_vif_seq_stop, 17421da177e4SLinus Torvalds .show = ipmr_vif_seq_show, 17431da177e4SLinus Torvalds }; 17441da177e4SLinus Torvalds 17451da177e4SLinus Torvalds static int ipmr_vif_open(struct inode *inode, struct file *file) 17461da177e4SLinus Torvalds { 1747cf7732e4SPavel Emelyanov return seq_open_private(file, &ipmr_vif_seq_ops, 1748cf7732e4SPavel Emelyanov sizeof(struct ipmr_vif_iter)); 17491da177e4SLinus Torvalds } 17501da177e4SLinus Torvalds 17519a32144eSArjan van de Ven static const struct file_operations ipmr_vif_fops = { 17521da177e4SLinus Torvalds .owner = THIS_MODULE, 17531da177e4SLinus Torvalds .open = ipmr_vif_open, 17541da177e4SLinus Torvalds .read = seq_read, 17551da177e4SLinus Torvalds .llseek = seq_lseek, 17561da177e4SLinus Torvalds .release = seq_release_private, 17571da177e4SLinus Torvalds }; 17581da177e4SLinus Torvalds 17591da177e4SLinus Torvalds struct ipmr_mfc_iter { 17601da177e4SLinus Torvalds struct mfc_cache **cache; 17611da177e4SLinus Torvalds int ct; 17621da177e4SLinus Torvalds }; 17631da177e4SLinus Torvalds 17641da177e4SLinus Torvalds 17651da177e4SLinus Torvalds static struct mfc_cache *ipmr_mfc_seq_idx(struct ipmr_mfc_iter *it, loff_t pos) 17661da177e4SLinus Torvalds { 17671da177e4SLinus Torvalds struct mfc_cache *mfc; 17681da177e4SLinus Torvalds 17692bb8b26cSBenjamin Thery it->cache = init_net.ipv4.mfc_cache_array; 17701da177e4SLinus Torvalds read_lock(&mrt_lock); 17711da177e4SLinus Torvalds for (it->ct = 0; it->ct < MFC_LINES; it->ct++) 17722bb8b26cSBenjamin Thery for (mfc = init_net.ipv4.mfc_cache_array[it->ct]; 17732bb8b26cSBenjamin Thery mfc; mfc = mfc->next) 17741da177e4SLinus Torvalds if (pos-- == 0) 17751da177e4SLinus Torvalds return mfc; 17761da177e4SLinus Torvalds read_unlock(&mrt_lock); 17771da177e4SLinus Torvalds 17781da177e4SLinus Torvalds it->cache = &mfc_unres_queue; 17791da177e4SLinus Torvalds spin_lock_bh(&mfc_unres_lock); 17801da177e4SLinus Torvalds for (mfc = mfc_unres_queue; mfc; mfc = mfc->next) 17811da177e4SLinus Torvalds if (pos-- == 0) 17821da177e4SLinus Torvalds return mfc; 17831da177e4SLinus Torvalds spin_unlock_bh(&mfc_unres_lock); 17841da177e4SLinus Torvalds 17851da177e4SLinus Torvalds it->cache = NULL; 17861da177e4SLinus Torvalds return NULL; 17871da177e4SLinus Torvalds } 17881da177e4SLinus Torvalds 17891da177e4SLinus Torvalds 17901da177e4SLinus Torvalds static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos) 17911da177e4SLinus Torvalds { 17921da177e4SLinus Torvalds struct ipmr_mfc_iter *it = seq->private; 17931da177e4SLinus Torvalds it->cache = NULL; 17941da177e4SLinus Torvalds it->ct = 0; 17951da177e4SLinus Torvalds return *pos ? ipmr_mfc_seq_idx(seq->private, *pos - 1) 17961da177e4SLinus Torvalds : SEQ_START_TOKEN; 17971da177e4SLinus Torvalds } 17981da177e4SLinus Torvalds 17991da177e4SLinus Torvalds static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos) 18001da177e4SLinus Torvalds { 18011da177e4SLinus Torvalds struct mfc_cache *mfc = v; 18021da177e4SLinus Torvalds struct ipmr_mfc_iter *it = seq->private; 18031da177e4SLinus Torvalds 18041da177e4SLinus Torvalds ++*pos; 18051da177e4SLinus Torvalds 18061da177e4SLinus Torvalds if (v == SEQ_START_TOKEN) 18071da177e4SLinus Torvalds return ipmr_mfc_seq_idx(seq->private, 0); 18081da177e4SLinus Torvalds 18091da177e4SLinus Torvalds if (mfc->next) 18101da177e4SLinus Torvalds return mfc->next; 18111da177e4SLinus Torvalds 18121da177e4SLinus Torvalds if (it->cache == &mfc_unres_queue) 18131da177e4SLinus Torvalds goto end_of_list; 18141da177e4SLinus Torvalds 18152bb8b26cSBenjamin Thery BUG_ON(it->cache != init_net.ipv4.mfc_cache_array); 18161da177e4SLinus Torvalds 18171da177e4SLinus Torvalds while (++it->ct < MFC_LINES) { 18182bb8b26cSBenjamin Thery mfc = init_net.ipv4.mfc_cache_array[it->ct]; 18191da177e4SLinus Torvalds if (mfc) 18201da177e4SLinus Torvalds return mfc; 18211da177e4SLinus Torvalds } 18221da177e4SLinus Torvalds 18231da177e4SLinus Torvalds /* exhausted cache_array, show unresolved */ 18241da177e4SLinus Torvalds read_unlock(&mrt_lock); 18251da177e4SLinus Torvalds it->cache = &mfc_unres_queue; 18261da177e4SLinus Torvalds it->ct = 0; 18271da177e4SLinus Torvalds 18281da177e4SLinus Torvalds spin_lock_bh(&mfc_unres_lock); 18291da177e4SLinus Torvalds mfc = mfc_unres_queue; 18301da177e4SLinus Torvalds if (mfc) 18311da177e4SLinus Torvalds return mfc; 18321da177e4SLinus Torvalds 18331da177e4SLinus Torvalds end_of_list: 18341da177e4SLinus Torvalds spin_unlock_bh(&mfc_unres_lock); 18351da177e4SLinus Torvalds it->cache = NULL; 18361da177e4SLinus Torvalds 18371da177e4SLinus Torvalds return NULL; 18381da177e4SLinus Torvalds } 18391da177e4SLinus Torvalds 18401da177e4SLinus Torvalds static void ipmr_mfc_seq_stop(struct seq_file *seq, void *v) 18411da177e4SLinus Torvalds { 18421da177e4SLinus Torvalds struct ipmr_mfc_iter *it = seq->private; 18431da177e4SLinus Torvalds 18441da177e4SLinus Torvalds if (it->cache == &mfc_unres_queue) 18451da177e4SLinus Torvalds spin_unlock_bh(&mfc_unres_lock); 18462bb8b26cSBenjamin Thery else if (it->cache == init_net.ipv4.mfc_cache_array) 18471da177e4SLinus Torvalds read_unlock(&mrt_lock); 18481da177e4SLinus Torvalds } 18491da177e4SLinus Torvalds 18501da177e4SLinus Torvalds static int ipmr_mfc_seq_show(struct seq_file *seq, void *v) 18511da177e4SLinus Torvalds { 18521da177e4SLinus Torvalds int n; 18531da177e4SLinus Torvalds 18541da177e4SLinus Torvalds if (v == SEQ_START_TOKEN) { 18551da177e4SLinus Torvalds seq_puts(seq, 18561da177e4SLinus Torvalds "Group Origin Iif Pkts Bytes Wrong Oifs\n"); 18571da177e4SLinus Torvalds } else { 18581da177e4SLinus Torvalds const struct mfc_cache *mfc = v; 18591da177e4SLinus Torvalds const struct ipmr_mfc_iter *it = seq->private; 18601da177e4SLinus Torvalds 1861999890b2SBenjamin Thery seq_printf(seq, "%08lX %08lX %-3hd", 18621da177e4SLinus Torvalds (unsigned long) mfc->mfc_mcastgrp, 18631da177e4SLinus Torvalds (unsigned long) mfc->mfc_origin, 18641ea472e2SBenjamin Thery mfc->mfc_parent); 18651ea472e2SBenjamin Thery 18661ea472e2SBenjamin Thery if (it->cache != &mfc_unres_queue) { 18671ea472e2SBenjamin Thery seq_printf(seq, " %8lu %8lu %8lu", 18681da177e4SLinus Torvalds mfc->mfc_un.res.pkt, 18691da177e4SLinus Torvalds mfc->mfc_un.res.bytes, 18701da177e4SLinus Torvalds mfc->mfc_un.res.wrong_if); 18711da177e4SLinus Torvalds for (n = mfc->mfc_un.res.minvif; 18721da177e4SLinus Torvalds n < mfc->mfc_un.res.maxvif; n++ ) { 1873cf958ae3SBenjamin Thery if (VIF_EXISTS(&init_net, n) && 1874cf958ae3SBenjamin Thery mfc->mfc_un.res.ttls[n] < 255) 18751da177e4SLinus Torvalds seq_printf(seq, 18761da177e4SLinus Torvalds " %2d:%-3d", 18771da177e4SLinus Torvalds n, mfc->mfc_un.res.ttls[n]); 18781da177e4SLinus Torvalds } 18791ea472e2SBenjamin Thery } else { 18801ea472e2SBenjamin Thery /* unresolved mfc_caches don't contain 18811ea472e2SBenjamin Thery * pkt, bytes and wrong_if values 18821ea472e2SBenjamin Thery */ 18831ea472e2SBenjamin Thery seq_printf(seq, " %8lu %8lu %8lu", 0ul, 0ul, 0ul); 18841da177e4SLinus Torvalds } 18851da177e4SLinus Torvalds seq_putc(seq, '\n'); 18861da177e4SLinus Torvalds } 18871da177e4SLinus Torvalds return 0; 18881da177e4SLinus Torvalds } 18891da177e4SLinus Torvalds 1890f690808eSStephen Hemminger static const struct seq_operations ipmr_mfc_seq_ops = { 18911da177e4SLinus Torvalds .start = ipmr_mfc_seq_start, 18921da177e4SLinus Torvalds .next = ipmr_mfc_seq_next, 18931da177e4SLinus Torvalds .stop = ipmr_mfc_seq_stop, 18941da177e4SLinus Torvalds .show = ipmr_mfc_seq_show, 18951da177e4SLinus Torvalds }; 18961da177e4SLinus Torvalds 18971da177e4SLinus Torvalds static int ipmr_mfc_open(struct inode *inode, struct file *file) 18981da177e4SLinus Torvalds { 1899cf7732e4SPavel Emelyanov return seq_open_private(file, &ipmr_mfc_seq_ops, 1900cf7732e4SPavel Emelyanov sizeof(struct ipmr_mfc_iter)); 19011da177e4SLinus Torvalds } 19021da177e4SLinus Torvalds 19039a32144eSArjan van de Ven static const struct file_operations ipmr_mfc_fops = { 19041da177e4SLinus Torvalds .owner = THIS_MODULE, 19051da177e4SLinus Torvalds .open = ipmr_mfc_open, 19061da177e4SLinus Torvalds .read = seq_read, 19071da177e4SLinus Torvalds .llseek = seq_lseek, 19081da177e4SLinus Torvalds .release = seq_release_private, 19091da177e4SLinus Torvalds }; 19101da177e4SLinus Torvalds #endif 19111da177e4SLinus Torvalds 19121da177e4SLinus Torvalds #ifdef CONFIG_IP_PIMSM_V2 19131da177e4SLinus Torvalds static struct net_protocol pim_protocol = { 19141da177e4SLinus Torvalds .handler = pim_rcv, 19151da177e4SLinus Torvalds }; 19161da177e4SLinus Torvalds #endif 19171da177e4SLinus Torvalds 19181da177e4SLinus Torvalds 19191da177e4SLinus Torvalds /* 19201da177e4SLinus Torvalds * Setup for IP multicast routing 19211da177e4SLinus Torvalds */ 1922cf958ae3SBenjamin Thery static int __net_init ipmr_net_init(struct net *net) 1923cf958ae3SBenjamin Thery { 1924cf958ae3SBenjamin Thery int err = 0; 1925cf958ae3SBenjamin Thery 1926cf958ae3SBenjamin Thery net->ipv4.vif_table = kcalloc(MAXVIFS, sizeof(struct vif_device), 1927cf958ae3SBenjamin Thery GFP_KERNEL); 1928cf958ae3SBenjamin Thery if (!net->ipv4.vif_table) { 1929cf958ae3SBenjamin Thery err = -ENOMEM; 1930cf958ae3SBenjamin Thery goto fail; 1931cf958ae3SBenjamin Thery } 19322bb8b26cSBenjamin Thery 19332bb8b26cSBenjamin Thery /* Forwarding cache */ 19342bb8b26cSBenjamin Thery net->ipv4.mfc_cache_array = kcalloc(MFC_LINES, 19352bb8b26cSBenjamin Thery sizeof(struct mfc_cache *), 19362bb8b26cSBenjamin Thery GFP_KERNEL); 19372bb8b26cSBenjamin Thery if (!net->ipv4.mfc_cache_array) { 19382bb8b26cSBenjamin Thery err = -ENOMEM; 19392bb8b26cSBenjamin Thery goto fail_mfc_cache; 19402bb8b26cSBenjamin Thery } 1941*6c5143dbSBenjamin Thery 1942*6c5143dbSBenjamin Thery #ifdef CONFIG_IP_PIMSM 1943*6c5143dbSBenjamin Thery net->ipv4.mroute_reg_vif_num = -1; 1944*6c5143dbSBenjamin Thery #endif 19452bb8b26cSBenjamin Thery return 0; 19462bb8b26cSBenjamin Thery 19472bb8b26cSBenjamin Thery fail_mfc_cache: 19482bb8b26cSBenjamin Thery kfree(net->ipv4.vif_table); 1949cf958ae3SBenjamin Thery fail: 1950cf958ae3SBenjamin Thery return err; 1951cf958ae3SBenjamin Thery } 1952cf958ae3SBenjamin Thery 1953cf958ae3SBenjamin Thery static void __net_exit ipmr_net_exit(struct net *net) 1954cf958ae3SBenjamin Thery { 19552bb8b26cSBenjamin Thery kfree(net->ipv4.mfc_cache_array); 1956cf958ae3SBenjamin Thery kfree(net->ipv4.vif_table); 1957cf958ae3SBenjamin Thery } 1958cf958ae3SBenjamin Thery 1959cf958ae3SBenjamin Thery static struct pernet_operations ipmr_net_ops = { 1960cf958ae3SBenjamin Thery .init = ipmr_net_init, 1961cf958ae3SBenjamin Thery .exit = ipmr_net_exit, 1962cf958ae3SBenjamin Thery }; 19631da177e4SLinus Torvalds 196403d2f897SWang Chen int __init ip_mr_init(void) 19651da177e4SLinus Torvalds { 196603d2f897SWang Chen int err; 196703d2f897SWang Chen 19681da177e4SLinus Torvalds mrt_cachep = kmem_cache_create("ip_mrt_cache", 19691da177e4SLinus Torvalds sizeof(struct mfc_cache), 1970e5d679f3SAlexey Dobriyan 0, SLAB_HWCACHE_ALIGN|SLAB_PANIC, 197120c2df83SPaul Mundt NULL); 197203d2f897SWang Chen if (!mrt_cachep) 197303d2f897SWang Chen return -ENOMEM; 197403d2f897SWang Chen 1975cf958ae3SBenjamin Thery err = register_pernet_subsys(&ipmr_net_ops); 1976cf958ae3SBenjamin Thery if (err) 1977cf958ae3SBenjamin Thery goto reg_pernet_fail; 1978cf958ae3SBenjamin Thery 1979b24b8a24SPavel Emelyanov setup_timer(&ipmr_expire_timer, ipmr_expire_process, 0); 198003d2f897SWang Chen err = register_netdevice_notifier(&ip_mr_notifier); 198103d2f897SWang Chen if (err) 198203d2f897SWang Chen goto reg_notif_fail; 19831da177e4SLinus Torvalds #ifdef CONFIG_PROC_FS 198403d2f897SWang Chen err = -ENOMEM; 198503d2f897SWang Chen if (!proc_net_fops_create(&init_net, "ip_mr_vif", 0, &ipmr_vif_fops)) 198603d2f897SWang Chen goto proc_vif_fail; 198703d2f897SWang Chen if (!proc_net_fops_create(&init_net, "ip_mr_cache", 0, &ipmr_mfc_fops)) 198803d2f897SWang Chen goto proc_cache_fail; 19891da177e4SLinus Torvalds #endif 199003d2f897SWang Chen return 0; 199103d2f897SWang Chen #ifdef CONFIG_PROC_FS 199203d2f897SWang Chen proc_cache_fail: 199303d2f897SWang Chen proc_net_remove(&init_net, "ip_mr_vif"); 1994c3e38896SBenjamin Thery proc_vif_fail: 1995c3e38896SBenjamin Thery unregister_netdevice_notifier(&ip_mr_notifier); 199603d2f897SWang Chen #endif 1997c3e38896SBenjamin Thery reg_notif_fail: 1998c3e38896SBenjamin Thery del_timer(&ipmr_expire_timer); 1999cf958ae3SBenjamin Thery unregister_pernet_subsys(&ipmr_net_ops); 2000cf958ae3SBenjamin Thery reg_pernet_fail: 2001c3e38896SBenjamin Thery kmem_cache_destroy(mrt_cachep); 200203d2f897SWang Chen return err; 20031da177e4SLinus Torvalds } 2004