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> 505a0e3ad6STejun Heo #include <linux/slab.h> 51457c4cbcSEric W. Biederman #include <net/net_namespace.h> 521da177e4SLinus Torvalds #include <net/ip.h> 531da177e4SLinus Torvalds #include <net/protocol.h> 541da177e4SLinus Torvalds #include <linux/skbuff.h> 5514c85021SArnaldo Carvalho de Melo #include <net/route.h> 561da177e4SLinus Torvalds #include <net/sock.h> 571da177e4SLinus Torvalds #include <net/icmp.h> 581da177e4SLinus Torvalds #include <net/udp.h> 591da177e4SLinus Torvalds #include <net/raw.h> 601da177e4SLinus Torvalds #include <linux/notifier.h> 611da177e4SLinus Torvalds #include <linux/if_arp.h> 621da177e4SLinus Torvalds #include <linux/netfilter_ipv4.h> 631da177e4SLinus Torvalds #include <net/ipip.h> 641da177e4SLinus Torvalds #include <net/checksum.h> 65dc5fc579SArnaldo Carvalho de Melo #include <net/netlink.h> 661da177e4SLinus Torvalds 671da177e4SLinus Torvalds #if defined(CONFIG_IP_PIMSM_V1) || defined(CONFIG_IP_PIMSM_V2) 681da177e4SLinus Torvalds #define CONFIG_IP_PIMSM 1 691da177e4SLinus Torvalds #endif 701da177e4SLinus Torvalds 711da177e4SLinus Torvalds /* Big lock, protecting vif table, mrt cache and mroute socket state. 721da177e4SLinus Torvalds Note that the changes are semaphored via rtnl_lock. 731da177e4SLinus Torvalds */ 741da177e4SLinus Torvalds 751da177e4SLinus Torvalds static DEFINE_RWLOCK(mrt_lock); 761da177e4SLinus Torvalds 771da177e4SLinus Torvalds /* 781da177e4SLinus Torvalds * Multicast router control variables 791da177e4SLinus Torvalds */ 801da177e4SLinus Torvalds 81cf958ae3SBenjamin Thery #define VIF_EXISTS(_net, _idx) ((_net)->ipv4.vif_table[_idx].dev != NULL) 821da177e4SLinus Torvalds 831da177e4SLinus Torvalds /* Special spinlock for queue of unresolved entries */ 841da177e4SLinus Torvalds static DEFINE_SPINLOCK(mfc_unres_lock); 851da177e4SLinus Torvalds 861da177e4SLinus Torvalds /* We return to original Alan's scheme. Hash table of resolved 871da177e4SLinus Torvalds entries is changed only in process context and protected 881da177e4SLinus Torvalds with weak lock mrt_lock. Queue of unresolved entries is protected 891da177e4SLinus Torvalds with strong spinlock mfc_unres_lock. 901da177e4SLinus Torvalds 911da177e4SLinus Torvalds In this case data path is free of exclusive locks at all. 921da177e4SLinus Torvalds */ 931da177e4SLinus Torvalds 94e18b890bSChristoph Lameter static struct kmem_cache *mrt_cachep __read_mostly; 951da177e4SLinus Torvalds 96d658f8a0SPatrick McHardy static int ip_mr_forward(struct net *net, struct sk_buff *skb, 97d658f8a0SPatrick McHardy struct mfc_cache *cache, int local); 984feb88e5SBenjamin Thery static int ipmr_cache_report(struct net *net, 994feb88e5SBenjamin Thery struct sk_buff *pkt, vifi_t vifi, int assert); 100d658f8a0SPatrick McHardy static int ipmr_fill_mroute(struct net *net, struct sk_buff *skb, 101d658f8a0SPatrick McHardy struct mfc_cache *c, struct rtmsg *rtm); 1021da177e4SLinus Torvalds 1031da177e4SLinus Torvalds /* Service routines creating virtual interfaces: DVMRP tunnels and PIMREG */ 1041da177e4SLinus Torvalds 105d607032dSWang Chen static void ipmr_del_tunnel(struct net_device *dev, struct vifctl *v) 106d607032dSWang Chen { 1074feb88e5SBenjamin Thery struct net *net = dev_net(dev); 1084feb88e5SBenjamin Thery 109d607032dSWang Chen dev_close(dev); 110d607032dSWang Chen 1114feb88e5SBenjamin Thery dev = __dev_get_by_name(net, "tunl0"); 112d607032dSWang Chen if (dev) { 1135bc3eb7eSStephen Hemminger const struct net_device_ops *ops = dev->netdev_ops; 114d607032dSWang Chen struct ifreq ifr; 115d607032dSWang Chen struct ip_tunnel_parm p; 116d607032dSWang Chen 117d607032dSWang Chen memset(&p, 0, sizeof(p)); 118d607032dSWang Chen p.iph.daddr = v->vifc_rmt_addr.s_addr; 119d607032dSWang Chen p.iph.saddr = v->vifc_lcl_addr.s_addr; 120d607032dSWang Chen p.iph.version = 4; 121d607032dSWang Chen p.iph.ihl = 5; 122d607032dSWang Chen p.iph.protocol = IPPROTO_IPIP; 123d607032dSWang Chen sprintf(p.name, "dvmrp%d", v->vifc_vifi); 124d607032dSWang Chen ifr.ifr_ifru.ifru_data = (__force void __user *)&p; 125d607032dSWang Chen 1265bc3eb7eSStephen Hemminger if (ops->ndo_do_ioctl) { 1275bc3eb7eSStephen Hemminger mm_segment_t oldfs = get_fs(); 1285bc3eb7eSStephen Hemminger 1295bc3eb7eSStephen Hemminger set_fs(KERNEL_DS); 1305bc3eb7eSStephen Hemminger ops->ndo_do_ioctl(dev, &ifr, SIOCDELTUNNEL); 131d607032dSWang Chen set_fs(oldfs); 132d607032dSWang Chen } 133d607032dSWang Chen } 1345bc3eb7eSStephen Hemminger } 135d607032dSWang Chen 1361da177e4SLinus Torvalds static 1374feb88e5SBenjamin Thery struct net_device *ipmr_new_tunnel(struct net *net, struct vifctl *v) 1381da177e4SLinus Torvalds { 1391da177e4SLinus Torvalds struct net_device *dev; 1401da177e4SLinus Torvalds 1414feb88e5SBenjamin Thery dev = __dev_get_by_name(net, "tunl0"); 1421da177e4SLinus Torvalds 1431da177e4SLinus Torvalds if (dev) { 1445bc3eb7eSStephen Hemminger const struct net_device_ops *ops = dev->netdev_ops; 1451da177e4SLinus Torvalds int err; 1461da177e4SLinus Torvalds struct ifreq ifr; 1471da177e4SLinus Torvalds struct ip_tunnel_parm p; 1481da177e4SLinus Torvalds struct in_device *in_dev; 1491da177e4SLinus Torvalds 1501da177e4SLinus Torvalds memset(&p, 0, sizeof(p)); 1511da177e4SLinus Torvalds p.iph.daddr = v->vifc_rmt_addr.s_addr; 1521da177e4SLinus Torvalds p.iph.saddr = v->vifc_lcl_addr.s_addr; 1531da177e4SLinus Torvalds p.iph.version = 4; 1541da177e4SLinus Torvalds p.iph.ihl = 5; 1551da177e4SLinus Torvalds p.iph.protocol = IPPROTO_IPIP; 1561da177e4SLinus Torvalds sprintf(p.name, "dvmrp%d", v->vifc_vifi); 157ba93ef74SStephen Hemminger ifr.ifr_ifru.ifru_data = (__force void __user *)&p; 1581da177e4SLinus Torvalds 1595bc3eb7eSStephen Hemminger if (ops->ndo_do_ioctl) { 1605bc3eb7eSStephen Hemminger mm_segment_t oldfs = get_fs(); 1615bc3eb7eSStephen Hemminger 1625bc3eb7eSStephen Hemminger set_fs(KERNEL_DS); 1635bc3eb7eSStephen Hemminger err = ops->ndo_do_ioctl(dev, &ifr, SIOCADDTUNNEL); 1641da177e4SLinus Torvalds set_fs(oldfs); 1655bc3eb7eSStephen Hemminger } else 1665bc3eb7eSStephen Hemminger err = -EOPNOTSUPP; 1671da177e4SLinus Torvalds 1681da177e4SLinus Torvalds dev = NULL; 1691da177e4SLinus Torvalds 1704feb88e5SBenjamin Thery if (err == 0 && 1714feb88e5SBenjamin Thery (dev = __dev_get_by_name(net, p.name)) != NULL) { 1721da177e4SLinus Torvalds dev->flags |= IFF_MULTICAST; 1731da177e4SLinus Torvalds 174e5ed6399SHerbert Xu in_dev = __in_dev_get_rtnl(dev); 17571e27da9SHerbert Xu if (in_dev == NULL) 1761da177e4SLinus Torvalds goto failure; 17771e27da9SHerbert Xu 17871e27da9SHerbert Xu ipv4_devconf_setall(in_dev); 17971e27da9SHerbert Xu IPV4_DEVCONF(in_dev->cnf, RP_FILTER) = 0; 1801da177e4SLinus Torvalds 1811da177e4SLinus Torvalds if (dev_open(dev)) 1821da177e4SLinus Torvalds goto failure; 1837dc00c82SWang Chen dev_hold(dev); 1841da177e4SLinus Torvalds } 1851da177e4SLinus Torvalds } 1861da177e4SLinus Torvalds return dev; 1871da177e4SLinus Torvalds 1881da177e4SLinus Torvalds failure: 1891da177e4SLinus Torvalds /* allow the register to be completed before unregistering. */ 1901da177e4SLinus Torvalds rtnl_unlock(); 1911da177e4SLinus Torvalds rtnl_lock(); 1921da177e4SLinus Torvalds 1931da177e4SLinus Torvalds unregister_netdevice(dev); 1941da177e4SLinus Torvalds return NULL; 1951da177e4SLinus Torvalds } 1961da177e4SLinus Torvalds 1971da177e4SLinus Torvalds #ifdef CONFIG_IP_PIMSM 1981da177e4SLinus Torvalds 1996fef4c0cSStephen Hemminger static netdev_tx_t reg_vif_xmit(struct sk_buff *skb, struct net_device *dev) 2001da177e4SLinus Torvalds { 2014feb88e5SBenjamin Thery struct net *net = dev_net(dev); 2024feb88e5SBenjamin Thery 2031da177e4SLinus Torvalds read_lock(&mrt_lock); 204cf3677aeSPavel Emelyanov dev->stats.tx_bytes += skb->len; 205cf3677aeSPavel Emelyanov dev->stats.tx_packets++; 2064feb88e5SBenjamin Thery ipmr_cache_report(net, skb, net->ipv4.mroute_reg_vif_num, 2074feb88e5SBenjamin Thery IGMPMSG_WHOLEPKT); 2081da177e4SLinus Torvalds read_unlock(&mrt_lock); 2091da177e4SLinus Torvalds kfree_skb(skb); 2106ed10654SPatrick McHardy return NETDEV_TX_OK; 2111da177e4SLinus Torvalds } 2121da177e4SLinus Torvalds 213007c3838SStephen Hemminger static const struct net_device_ops reg_vif_netdev_ops = { 214007c3838SStephen Hemminger .ndo_start_xmit = reg_vif_xmit, 215007c3838SStephen Hemminger }; 216007c3838SStephen Hemminger 2171da177e4SLinus Torvalds static void reg_vif_setup(struct net_device *dev) 2181da177e4SLinus Torvalds { 2191da177e4SLinus Torvalds dev->type = ARPHRD_PIMREG; 22046f25dffSKris Katterjohn dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr) - 8; 2211da177e4SLinus Torvalds dev->flags = IFF_NOARP; 222007c3838SStephen Hemminger dev->netdev_ops = ®_vif_netdev_ops, 2231da177e4SLinus Torvalds dev->destructor = free_netdev; 224403dbb97STom Goff dev->features |= NETIF_F_NETNS_LOCAL; 2251da177e4SLinus Torvalds } 2261da177e4SLinus Torvalds 227403dbb97STom Goff static struct net_device *ipmr_reg_vif(struct net *net) 2281da177e4SLinus Torvalds { 2291da177e4SLinus Torvalds struct net_device *dev; 2301da177e4SLinus Torvalds struct in_device *in_dev; 2311da177e4SLinus Torvalds 232cf3677aeSPavel Emelyanov dev = alloc_netdev(0, "pimreg", reg_vif_setup); 2331da177e4SLinus Torvalds 2341da177e4SLinus Torvalds if (dev == NULL) 2351da177e4SLinus Torvalds return NULL; 2361da177e4SLinus Torvalds 237403dbb97STom Goff dev_net_set(dev, net); 238403dbb97STom Goff 2391da177e4SLinus Torvalds if (register_netdevice(dev)) { 2401da177e4SLinus Torvalds free_netdev(dev); 2411da177e4SLinus Torvalds return NULL; 2421da177e4SLinus Torvalds } 2431da177e4SLinus Torvalds dev->iflink = 0; 2441da177e4SLinus Torvalds 24571e27da9SHerbert Xu rcu_read_lock(); 24671e27da9SHerbert Xu if ((in_dev = __in_dev_get_rcu(dev)) == NULL) { 24771e27da9SHerbert Xu rcu_read_unlock(); 2481da177e4SLinus Torvalds goto failure; 24971e27da9SHerbert Xu } 2501da177e4SLinus Torvalds 25171e27da9SHerbert Xu ipv4_devconf_setall(in_dev); 25271e27da9SHerbert Xu IPV4_DEVCONF(in_dev->cnf, RP_FILTER) = 0; 25371e27da9SHerbert Xu rcu_read_unlock(); 2541da177e4SLinus Torvalds 2551da177e4SLinus Torvalds if (dev_open(dev)) 2561da177e4SLinus Torvalds goto failure; 2571da177e4SLinus Torvalds 2587dc00c82SWang Chen dev_hold(dev); 2597dc00c82SWang Chen 2601da177e4SLinus Torvalds return dev; 2611da177e4SLinus Torvalds 2621da177e4SLinus Torvalds failure: 2631da177e4SLinus Torvalds /* allow the register to be completed before unregistering. */ 2641da177e4SLinus Torvalds rtnl_unlock(); 2651da177e4SLinus Torvalds rtnl_lock(); 2661da177e4SLinus Torvalds 2671da177e4SLinus Torvalds unregister_netdevice(dev); 2681da177e4SLinus Torvalds return NULL; 2691da177e4SLinus Torvalds } 2701da177e4SLinus Torvalds #endif 2711da177e4SLinus Torvalds 2721da177e4SLinus Torvalds /* 2731da177e4SLinus Torvalds * Delete a VIF entry 2747dc00c82SWang Chen * @notify: Set to 1, if the caller is a notifier_call 2751da177e4SLinus Torvalds */ 2761da177e4SLinus Torvalds 277d17fa6faSEric Dumazet static int vif_delete(struct net *net, int vifi, int notify, 278d17fa6faSEric Dumazet struct list_head *head) 2791da177e4SLinus Torvalds { 2801da177e4SLinus Torvalds struct vif_device *v; 2811da177e4SLinus Torvalds struct net_device *dev; 2821da177e4SLinus Torvalds struct in_device *in_dev; 2831da177e4SLinus Torvalds 2844feb88e5SBenjamin Thery if (vifi < 0 || vifi >= net->ipv4.maxvif) 2851da177e4SLinus Torvalds return -EADDRNOTAVAIL; 2861da177e4SLinus Torvalds 2874feb88e5SBenjamin Thery v = &net->ipv4.vif_table[vifi]; 2881da177e4SLinus Torvalds 2891da177e4SLinus Torvalds write_lock_bh(&mrt_lock); 2901da177e4SLinus Torvalds dev = v->dev; 2911da177e4SLinus Torvalds v->dev = NULL; 2921da177e4SLinus Torvalds 2931da177e4SLinus Torvalds if (!dev) { 2941da177e4SLinus Torvalds write_unlock_bh(&mrt_lock); 2951da177e4SLinus Torvalds return -EADDRNOTAVAIL; 2961da177e4SLinus Torvalds } 2971da177e4SLinus Torvalds 2981da177e4SLinus Torvalds #ifdef CONFIG_IP_PIMSM 2994feb88e5SBenjamin Thery if (vifi == net->ipv4.mroute_reg_vif_num) 3004feb88e5SBenjamin Thery net->ipv4.mroute_reg_vif_num = -1; 3011da177e4SLinus Torvalds #endif 3021da177e4SLinus Torvalds 3034feb88e5SBenjamin Thery if (vifi+1 == net->ipv4.maxvif) { 3041da177e4SLinus Torvalds int tmp; 3051da177e4SLinus Torvalds for (tmp=vifi-1; tmp>=0; tmp--) { 3064feb88e5SBenjamin Thery if (VIF_EXISTS(net, tmp)) 3071da177e4SLinus Torvalds break; 3081da177e4SLinus Torvalds } 3094feb88e5SBenjamin Thery net->ipv4.maxvif = tmp+1; 3101da177e4SLinus Torvalds } 3111da177e4SLinus Torvalds 3121da177e4SLinus Torvalds write_unlock_bh(&mrt_lock); 3131da177e4SLinus Torvalds 3141da177e4SLinus Torvalds dev_set_allmulti(dev, -1); 3151da177e4SLinus Torvalds 316e5ed6399SHerbert Xu if ((in_dev = __in_dev_get_rtnl(dev)) != NULL) { 31742f811b8SHerbert Xu IPV4_DEVCONF(in_dev->cnf, MC_FORWARDING)--; 3181da177e4SLinus Torvalds ip_rt_multicast_event(in_dev); 3191da177e4SLinus Torvalds } 3201da177e4SLinus Torvalds 3217dc00c82SWang Chen if (v->flags&(VIFF_TUNNEL|VIFF_REGISTER) && !notify) 322d17fa6faSEric Dumazet unregister_netdevice_queue(dev, head); 3231da177e4SLinus Torvalds 3241da177e4SLinus Torvalds dev_put(dev); 3251da177e4SLinus Torvalds return 0; 3261da177e4SLinus Torvalds } 3271da177e4SLinus Torvalds 3285c0a66f5SBenjamin Thery static inline void ipmr_cache_free(struct mfc_cache *c) 3295c0a66f5SBenjamin Thery { 3305c0a66f5SBenjamin Thery kmem_cache_free(mrt_cachep, c); 3315c0a66f5SBenjamin Thery } 3325c0a66f5SBenjamin Thery 3331da177e4SLinus Torvalds /* Destroy an unresolved cache entry, killing queued skbs 3341da177e4SLinus Torvalds and reporting error to netlink readers. 3351da177e4SLinus Torvalds */ 3361da177e4SLinus Torvalds 337d658f8a0SPatrick McHardy static void ipmr_destroy_unres(struct net *net, struct mfc_cache *c) 3381da177e4SLinus Torvalds { 3391da177e4SLinus Torvalds struct sk_buff *skb; 3409ef1d4c7SPatrick McHardy struct nlmsgerr *e; 3411da177e4SLinus Torvalds 3424feb88e5SBenjamin Thery atomic_dec(&net->ipv4.cache_resolve_queue_len); 3431da177e4SLinus Torvalds 3441da177e4SLinus Torvalds while ((skb = skb_dequeue(&c->mfc_un.unres.unresolved))) { 345eddc9ec5SArnaldo Carvalho de Melo if (ip_hdr(skb)->version == 0) { 3461da177e4SLinus Torvalds struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr)); 3471da177e4SLinus Torvalds nlh->nlmsg_type = NLMSG_ERROR; 3481da177e4SLinus Torvalds nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr)); 3491da177e4SLinus Torvalds skb_trim(skb, nlh->nlmsg_len); 3509ef1d4c7SPatrick McHardy e = NLMSG_DATA(nlh); 3519ef1d4c7SPatrick McHardy e->error = -ETIMEDOUT; 3529ef1d4c7SPatrick McHardy memset(&e->msg, 0, sizeof(e->msg)); 3532942e900SThomas Graf 3544feb88e5SBenjamin Thery rtnl_unicast(skb, net, NETLINK_CB(skb).pid); 3551da177e4SLinus Torvalds } else 3561da177e4SLinus Torvalds kfree_skb(skb); 3571da177e4SLinus Torvalds } 3581da177e4SLinus Torvalds 3595c0a66f5SBenjamin Thery ipmr_cache_free(c); 3601da177e4SLinus Torvalds } 3611da177e4SLinus Torvalds 3621da177e4SLinus Torvalds 363e258beb2SPatrick McHardy /* Timer process for the unresolved queue. */ 3641da177e4SLinus Torvalds 365e258beb2SPatrick McHardy static void ipmr_expire_process(unsigned long arg) 3661da177e4SLinus Torvalds { 367e258beb2SPatrick McHardy struct net *net = (struct net *)arg; 3681da177e4SLinus Torvalds unsigned long now; 3691da177e4SLinus Torvalds unsigned long expires; 370*862465f2SPatrick McHardy struct mfc_cache *c, *next; 3711da177e4SLinus Torvalds 3721da177e4SLinus Torvalds if (!spin_trylock(&mfc_unres_lock)) { 373e258beb2SPatrick McHardy mod_timer(&net->ipv4.ipmr_expire_timer, jiffies+HZ/10); 3741da177e4SLinus Torvalds return; 3751da177e4SLinus Torvalds } 3761da177e4SLinus Torvalds 377*862465f2SPatrick McHardy if (list_empty(&net->ipv4.mfc_unres_queue)) 3781da177e4SLinus Torvalds goto out; 3791da177e4SLinus Torvalds 3801da177e4SLinus Torvalds now = jiffies; 3811da177e4SLinus Torvalds expires = 10*HZ; 3821da177e4SLinus Torvalds 383*862465f2SPatrick McHardy list_for_each_entry_safe(c, next, &net->ipv4.mfc_unres_queue, list) { 3841da177e4SLinus Torvalds if (time_after(c->mfc_un.unres.expires, now)) { 3851da177e4SLinus Torvalds unsigned long interval = c->mfc_un.unres.expires - now; 3861da177e4SLinus Torvalds if (interval < expires) 3871da177e4SLinus Torvalds expires = interval; 3881da177e4SLinus Torvalds continue; 3891da177e4SLinus Torvalds } 3901da177e4SLinus Torvalds 391*862465f2SPatrick McHardy list_del(&c->list); 392d658f8a0SPatrick McHardy ipmr_destroy_unres(net, c); 3931da177e4SLinus Torvalds } 3941da177e4SLinus Torvalds 395*862465f2SPatrick McHardy if (!list_empty(&net->ipv4.mfc_unres_queue)) 396e258beb2SPatrick McHardy mod_timer(&net->ipv4.ipmr_expire_timer, jiffies + expires); 3971da177e4SLinus Torvalds 3981da177e4SLinus Torvalds out: 3991da177e4SLinus Torvalds spin_unlock(&mfc_unres_lock); 4001da177e4SLinus Torvalds } 4011da177e4SLinus Torvalds 4021da177e4SLinus Torvalds /* Fill oifs list. It is called under write locked mrt_lock. */ 4031da177e4SLinus Torvalds 404d658f8a0SPatrick McHardy static void ipmr_update_thresholds(struct net *net, struct mfc_cache *cache, 405d658f8a0SPatrick McHardy unsigned char *ttls) 4061da177e4SLinus Torvalds { 4071da177e4SLinus Torvalds int vifi; 4081da177e4SLinus Torvalds 4091da177e4SLinus Torvalds cache->mfc_un.res.minvif = MAXVIFS; 4101da177e4SLinus Torvalds cache->mfc_un.res.maxvif = 0; 4111da177e4SLinus Torvalds memset(cache->mfc_un.res.ttls, 255, MAXVIFS); 4121da177e4SLinus Torvalds 4134feb88e5SBenjamin Thery for (vifi = 0; vifi < net->ipv4.maxvif; vifi++) { 4144feb88e5SBenjamin Thery if (VIF_EXISTS(net, vifi) && 415cf958ae3SBenjamin Thery ttls[vifi] && ttls[vifi] < 255) { 4161da177e4SLinus Torvalds cache->mfc_un.res.ttls[vifi] = ttls[vifi]; 4171da177e4SLinus Torvalds if (cache->mfc_un.res.minvif > vifi) 4181da177e4SLinus Torvalds cache->mfc_un.res.minvif = vifi; 4191da177e4SLinus Torvalds if (cache->mfc_un.res.maxvif <= vifi) 4201da177e4SLinus Torvalds cache->mfc_un.res.maxvif = vifi + 1; 4211da177e4SLinus Torvalds } 4221da177e4SLinus Torvalds } 4231da177e4SLinus Torvalds } 4241da177e4SLinus Torvalds 4254feb88e5SBenjamin Thery static int vif_add(struct net *net, struct vifctl *vifc, int mrtsock) 4261da177e4SLinus Torvalds { 4271da177e4SLinus Torvalds int vifi = vifc->vifc_vifi; 4284feb88e5SBenjamin Thery struct vif_device *v = &net->ipv4.vif_table[vifi]; 4291da177e4SLinus Torvalds struct net_device *dev; 4301da177e4SLinus Torvalds struct in_device *in_dev; 431d607032dSWang Chen int err; 4321da177e4SLinus Torvalds 4331da177e4SLinus Torvalds /* Is vif busy ? */ 4344feb88e5SBenjamin Thery if (VIF_EXISTS(net, vifi)) 4351da177e4SLinus Torvalds return -EADDRINUSE; 4361da177e4SLinus Torvalds 4371da177e4SLinus Torvalds switch (vifc->vifc_flags) { 4381da177e4SLinus Torvalds #ifdef CONFIG_IP_PIMSM 4391da177e4SLinus Torvalds case VIFF_REGISTER: 4401da177e4SLinus Torvalds /* 4411da177e4SLinus Torvalds * Special Purpose VIF in PIM 4421da177e4SLinus Torvalds * All the packets will be sent to the daemon 4431da177e4SLinus Torvalds */ 4444feb88e5SBenjamin Thery if (net->ipv4.mroute_reg_vif_num >= 0) 4451da177e4SLinus Torvalds return -EADDRINUSE; 446403dbb97STom Goff dev = ipmr_reg_vif(net); 4471da177e4SLinus Torvalds if (!dev) 4481da177e4SLinus Torvalds return -ENOBUFS; 449d607032dSWang Chen err = dev_set_allmulti(dev, 1); 450d607032dSWang Chen if (err) { 451d607032dSWang Chen unregister_netdevice(dev); 4527dc00c82SWang Chen dev_put(dev); 453d607032dSWang Chen return err; 454d607032dSWang Chen } 4551da177e4SLinus Torvalds break; 4561da177e4SLinus Torvalds #endif 4571da177e4SLinus Torvalds case VIFF_TUNNEL: 4584feb88e5SBenjamin Thery dev = ipmr_new_tunnel(net, vifc); 4591da177e4SLinus Torvalds if (!dev) 4601da177e4SLinus Torvalds return -ENOBUFS; 461d607032dSWang Chen err = dev_set_allmulti(dev, 1); 462d607032dSWang Chen if (err) { 463d607032dSWang Chen ipmr_del_tunnel(dev, vifc); 4647dc00c82SWang Chen dev_put(dev); 465d607032dSWang Chen return err; 466d607032dSWang Chen } 4671da177e4SLinus Torvalds break; 468ee5e81f0SIlia K 469ee5e81f0SIlia K case VIFF_USE_IFINDEX: 4701da177e4SLinus Torvalds case 0: 471ee5e81f0SIlia K if (vifc->vifc_flags == VIFF_USE_IFINDEX) { 472ee5e81f0SIlia K dev = dev_get_by_index(net, vifc->vifc_lcl_ifindex); 473ee5e81f0SIlia K if (dev && dev->ip_ptr == NULL) { 474ee5e81f0SIlia K dev_put(dev); 475ee5e81f0SIlia K return -EADDRNOTAVAIL; 476ee5e81f0SIlia K } 477ee5e81f0SIlia K } else 4784feb88e5SBenjamin Thery dev = ip_dev_find(net, vifc->vifc_lcl_addr.s_addr); 479ee5e81f0SIlia K 4801da177e4SLinus Torvalds if (!dev) 4811da177e4SLinus Torvalds return -EADDRNOTAVAIL; 482d607032dSWang Chen err = dev_set_allmulti(dev, 1); 4837dc00c82SWang Chen if (err) { 4847dc00c82SWang Chen dev_put(dev); 485d607032dSWang Chen return err; 4867dc00c82SWang Chen } 4871da177e4SLinus Torvalds break; 4881da177e4SLinus Torvalds default: 4891da177e4SLinus Torvalds return -EINVAL; 4901da177e4SLinus Torvalds } 4911da177e4SLinus Torvalds 492d0490cfdSDan Carpenter if ((in_dev = __in_dev_get_rtnl(dev)) == NULL) { 493d0490cfdSDan Carpenter dev_put(dev); 4941da177e4SLinus Torvalds return -EADDRNOTAVAIL; 495d0490cfdSDan Carpenter } 49642f811b8SHerbert Xu IPV4_DEVCONF(in_dev->cnf, MC_FORWARDING)++; 4971da177e4SLinus Torvalds ip_rt_multicast_event(in_dev); 4981da177e4SLinus Torvalds 4991da177e4SLinus Torvalds /* 5001da177e4SLinus Torvalds * Fill in the VIF structures 5011da177e4SLinus Torvalds */ 5021da177e4SLinus Torvalds v->rate_limit = vifc->vifc_rate_limit; 5031da177e4SLinus Torvalds v->local = vifc->vifc_lcl_addr.s_addr; 5041da177e4SLinus Torvalds v->remote = vifc->vifc_rmt_addr.s_addr; 5051da177e4SLinus Torvalds v->flags = vifc->vifc_flags; 5061da177e4SLinus Torvalds if (!mrtsock) 5071da177e4SLinus Torvalds v->flags |= VIFF_STATIC; 5081da177e4SLinus Torvalds v->threshold = vifc->vifc_threshold; 5091da177e4SLinus Torvalds v->bytes_in = 0; 5101da177e4SLinus Torvalds v->bytes_out = 0; 5111da177e4SLinus Torvalds v->pkt_in = 0; 5121da177e4SLinus Torvalds v->pkt_out = 0; 5131da177e4SLinus Torvalds v->link = dev->ifindex; 5141da177e4SLinus Torvalds if (v->flags&(VIFF_TUNNEL|VIFF_REGISTER)) 5151da177e4SLinus Torvalds v->link = dev->iflink; 5161da177e4SLinus Torvalds 5171da177e4SLinus Torvalds /* And finish update writing critical data */ 5181da177e4SLinus Torvalds write_lock_bh(&mrt_lock); 5191da177e4SLinus Torvalds v->dev = dev; 5201da177e4SLinus Torvalds #ifdef CONFIG_IP_PIMSM 5211da177e4SLinus Torvalds if (v->flags&VIFF_REGISTER) 5224feb88e5SBenjamin Thery net->ipv4.mroute_reg_vif_num = vifi; 5231da177e4SLinus Torvalds #endif 5244feb88e5SBenjamin Thery if (vifi+1 > net->ipv4.maxvif) 5254feb88e5SBenjamin Thery net->ipv4.maxvif = vifi+1; 5261da177e4SLinus Torvalds write_unlock_bh(&mrt_lock); 5271da177e4SLinus Torvalds return 0; 5281da177e4SLinus Torvalds } 5291da177e4SLinus Torvalds 5304feb88e5SBenjamin Thery static struct mfc_cache *ipmr_cache_find(struct net *net, 5314feb88e5SBenjamin Thery __be32 origin, 5324feb88e5SBenjamin Thery __be32 mcastgrp) 5331da177e4SLinus Torvalds { 5341da177e4SLinus Torvalds int line = MFC_HASH(mcastgrp, origin); 5351da177e4SLinus Torvalds struct mfc_cache *c; 5361da177e4SLinus Torvalds 537*862465f2SPatrick McHardy list_for_each_entry(c, &net->ipv4.mfc_cache_array[line], list) { 5381da177e4SLinus Torvalds if (c->mfc_origin == origin && c->mfc_mcastgrp == mcastgrp) 5391da177e4SLinus Torvalds return c; 5401da177e4SLinus Torvalds } 541*862465f2SPatrick McHardy return NULL; 542*862465f2SPatrick McHardy } 5431da177e4SLinus Torvalds 5441da177e4SLinus Torvalds /* 5451da177e4SLinus Torvalds * Allocate a multicast cache entry 5461da177e4SLinus Torvalds */ 547d658f8a0SPatrick McHardy static struct mfc_cache *ipmr_cache_alloc(void) 5481da177e4SLinus Torvalds { 549c3762229SRobert P. J. Day struct mfc_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL); 5501da177e4SLinus Torvalds if (c == NULL) 5511da177e4SLinus Torvalds return NULL; 5521da177e4SLinus Torvalds c->mfc_un.res.minvif = MAXVIFS; 5531da177e4SLinus Torvalds return c; 5541da177e4SLinus Torvalds } 5551da177e4SLinus Torvalds 556d658f8a0SPatrick McHardy static struct mfc_cache *ipmr_cache_alloc_unres(void) 5571da177e4SLinus Torvalds { 558c3762229SRobert P. J. Day struct mfc_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC); 5591da177e4SLinus Torvalds if (c == NULL) 5601da177e4SLinus Torvalds return NULL; 5611da177e4SLinus Torvalds skb_queue_head_init(&c->mfc_un.unres.unresolved); 5621da177e4SLinus Torvalds c->mfc_un.unres.expires = jiffies + 10*HZ; 5631da177e4SLinus Torvalds return c; 5641da177e4SLinus Torvalds } 5651da177e4SLinus Torvalds 5661da177e4SLinus Torvalds /* 5671da177e4SLinus Torvalds * A cache entry has gone into a resolved state from queued 5681da177e4SLinus Torvalds */ 5691da177e4SLinus Torvalds 570d658f8a0SPatrick McHardy static void ipmr_cache_resolve(struct net *net, struct mfc_cache *uc, 571d658f8a0SPatrick McHardy struct mfc_cache *c) 5721da177e4SLinus Torvalds { 5731da177e4SLinus Torvalds struct sk_buff *skb; 5749ef1d4c7SPatrick McHardy struct nlmsgerr *e; 5751da177e4SLinus Torvalds 5761da177e4SLinus Torvalds /* 5771da177e4SLinus Torvalds * Play the pending entries through our router 5781da177e4SLinus Torvalds */ 5791da177e4SLinus Torvalds 5801da177e4SLinus Torvalds while ((skb = __skb_dequeue(&uc->mfc_un.unres.unresolved))) { 581eddc9ec5SArnaldo Carvalho de Melo if (ip_hdr(skb)->version == 0) { 5821da177e4SLinus Torvalds struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr)); 5831da177e4SLinus Torvalds 584d658f8a0SPatrick McHardy if (ipmr_fill_mroute(net, skb, c, NLMSG_DATA(nlh)) > 0) { 58527a884dcSArnaldo Carvalho de Melo nlh->nlmsg_len = (skb_tail_pointer(skb) - 58627a884dcSArnaldo Carvalho de Melo (u8 *)nlh); 5871da177e4SLinus Torvalds } else { 5881da177e4SLinus Torvalds nlh->nlmsg_type = NLMSG_ERROR; 5891da177e4SLinus Torvalds nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr)); 5901da177e4SLinus Torvalds skb_trim(skb, nlh->nlmsg_len); 5919ef1d4c7SPatrick McHardy e = NLMSG_DATA(nlh); 5929ef1d4c7SPatrick McHardy e->error = -EMSGSIZE; 5939ef1d4c7SPatrick McHardy memset(&e->msg, 0, sizeof(e->msg)); 5941da177e4SLinus Torvalds } 5952942e900SThomas Graf 596d658f8a0SPatrick McHardy rtnl_unicast(skb, net, NETLINK_CB(skb).pid); 5971da177e4SLinus Torvalds } else 598d658f8a0SPatrick McHardy ip_mr_forward(net, skb, c, 0); 5991da177e4SLinus Torvalds } 6001da177e4SLinus Torvalds } 6011da177e4SLinus Torvalds 6021da177e4SLinus Torvalds /* 6031da177e4SLinus Torvalds * Bounce a cache query up to mrouted. We could use netlink for this but mrouted 6041da177e4SLinus Torvalds * expects the following bizarre scheme. 6051da177e4SLinus Torvalds * 6061da177e4SLinus Torvalds * Called under mrt_lock. 6071da177e4SLinus Torvalds */ 6081da177e4SLinus Torvalds 6094feb88e5SBenjamin Thery static int ipmr_cache_report(struct net *net, 6104feb88e5SBenjamin Thery struct sk_buff *pkt, vifi_t vifi, int assert) 6111da177e4SLinus Torvalds { 6121da177e4SLinus Torvalds struct sk_buff *skb; 613c9bdd4b5SArnaldo Carvalho de Melo const int ihl = ip_hdrlen(pkt); 6141da177e4SLinus Torvalds struct igmphdr *igmp; 6151da177e4SLinus Torvalds struct igmpmsg *msg; 6161da177e4SLinus Torvalds int ret; 6171da177e4SLinus Torvalds 6181da177e4SLinus Torvalds #ifdef CONFIG_IP_PIMSM 6191da177e4SLinus Torvalds if (assert == IGMPMSG_WHOLEPKT) 6201da177e4SLinus Torvalds skb = skb_realloc_headroom(pkt, sizeof(struct iphdr)); 6211da177e4SLinus Torvalds else 6221da177e4SLinus Torvalds #endif 6231da177e4SLinus Torvalds skb = alloc_skb(128, GFP_ATOMIC); 6241da177e4SLinus Torvalds 6251da177e4SLinus Torvalds if (!skb) 6261da177e4SLinus Torvalds return -ENOBUFS; 6271da177e4SLinus Torvalds 6281da177e4SLinus Torvalds #ifdef CONFIG_IP_PIMSM 6291da177e4SLinus Torvalds if (assert == IGMPMSG_WHOLEPKT) { 6301da177e4SLinus Torvalds /* Ugly, but we have no choice with this interface. 6311da177e4SLinus Torvalds Duplicate old header, fix ihl, length etc. 6321da177e4SLinus Torvalds And all this only to mangle msg->im_msgtype and 6331da177e4SLinus Torvalds to set msg->im_mbz to "mbz" :-) 6341da177e4SLinus Torvalds */ 635878c8145SArnaldo Carvalho de Melo skb_push(skb, sizeof(struct iphdr)); 636878c8145SArnaldo Carvalho de Melo skb_reset_network_header(skb); 637badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 6380272ffc4SArnaldo Carvalho de Melo msg = (struct igmpmsg *)skb_network_header(skb); 639d56f90a7SArnaldo Carvalho de Melo memcpy(msg, skb_network_header(pkt), sizeof(struct iphdr)); 6401da177e4SLinus Torvalds msg->im_msgtype = IGMPMSG_WHOLEPKT; 6411da177e4SLinus Torvalds msg->im_mbz = 0; 6424feb88e5SBenjamin Thery msg->im_vif = net->ipv4.mroute_reg_vif_num; 643eddc9ec5SArnaldo Carvalho de Melo ip_hdr(skb)->ihl = sizeof(struct iphdr) >> 2; 644eddc9ec5SArnaldo Carvalho de Melo ip_hdr(skb)->tot_len = htons(ntohs(ip_hdr(pkt)->tot_len) + 645eddc9ec5SArnaldo Carvalho de Melo sizeof(struct iphdr)); 6461da177e4SLinus Torvalds } else 6471da177e4SLinus Torvalds #endif 6481da177e4SLinus Torvalds { 6491da177e4SLinus Torvalds 6501da177e4SLinus Torvalds /* 6511da177e4SLinus Torvalds * Copy the IP header 6521da177e4SLinus Torvalds */ 6531da177e4SLinus Torvalds 65427a884dcSArnaldo Carvalho de Melo skb->network_header = skb->tail; 655ddc7b8e3SArnaldo Carvalho de Melo skb_put(skb, ihl); 65627d7ff46SArnaldo Carvalho de Melo skb_copy_to_linear_data(skb, pkt->data, ihl); 657eddc9ec5SArnaldo Carvalho de Melo ip_hdr(skb)->protocol = 0; /* Flag to the kernel this is a route add */ 658eddc9ec5SArnaldo Carvalho de Melo msg = (struct igmpmsg *)skb_network_header(skb); 6591da177e4SLinus Torvalds msg->im_vif = vifi; 660adf30907SEric Dumazet skb_dst_set(skb, dst_clone(skb_dst(pkt))); 6611da177e4SLinus Torvalds 6621da177e4SLinus Torvalds /* 6631da177e4SLinus Torvalds * Add our header 6641da177e4SLinus Torvalds */ 6651da177e4SLinus Torvalds 6661da177e4SLinus Torvalds igmp=(struct igmphdr *)skb_put(skb, sizeof(struct igmphdr)); 6671da177e4SLinus Torvalds igmp->type = 6681da177e4SLinus Torvalds msg->im_msgtype = assert; 6691da177e4SLinus Torvalds igmp->code = 0; 670eddc9ec5SArnaldo Carvalho de Melo ip_hdr(skb)->tot_len = htons(skb->len); /* Fix the length */ 671b0e380b1SArnaldo Carvalho de Melo skb->transport_header = skb->network_header; 6721da177e4SLinus Torvalds } 6731da177e4SLinus Torvalds 6744feb88e5SBenjamin Thery if (net->ipv4.mroute_sk == NULL) { 6751da177e4SLinus Torvalds kfree_skb(skb); 6761da177e4SLinus Torvalds return -EINVAL; 6771da177e4SLinus Torvalds } 6781da177e4SLinus Torvalds 6791da177e4SLinus Torvalds /* 6801da177e4SLinus Torvalds * Deliver to mrouted 6811da177e4SLinus Torvalds */ 6824feb88e5SBenjamin Thery ret = sock_queue_rcv_skb(net->ipv4.mroute_sk, skb); 68370a269e6SBenjamin Thery if (ret < 0) { 6841da177e4SLinus Torvalds if (net_ratelimit()) 6851da177e4SLinus Torvalds printk(KERN_WARNING "mroute: pending queue full, dropping entries.\n"); 6861da177e4SLinus Torvalds kfree_skb(skb); 6871da177e4SLinus Torvalds } 6881da177e4SLinus Torvalds 6891da177e4SLinus Torvalds return ret; 6901da177e4SLinus Torvalds } 6911da177e4SLinus Torvalds 6921da177e4SLinus Torvalds /* 6931da177e4SLinus Torvalds * Queue a packet for resolution. It gets locked cache entry! 6941da177e4SLinus Torvalds */ 6951da177e4SLinus Torvalds 6961da177e4SLinus Torvalds static int 6974feb88e5SBenjamin Thery ipmr_cache_unresolved(struct net *net, vifi_t vifi, struct sk_buff *skb) 6981da177e4SLinus Torvalds { 699*862465f2SPatrick McHardy bool found = false; 7001da177e4SLinus Torvalds int err; 7011da177e4SLinus Torvalds struct mfc_cache *c; 702eddc9ec5SArnaldo Carvalho de Melo const struct iphdr *iph = ip_hdr(skb); 7031da177e4SLinus Torvalds 7041da177e4SLinus Torvalds spin_lock_bh(&mfc_unres_lock); 705*862465f2SPatrick McHardy list_for_each_entry(c, &net->ipv4.mfc_unres_queue, list) { 706e258beb2SPatrick McHardy if (c->mfc_mcastgrp == iph->daddr && 707*862465f2SPatrick McHardy c->mfc_origin == iph->saddr) { 708*862465f2SPatrick McHardy found = true; 7091da177e4SLinus Torvalds break; 7101da177e4SLinus Torvalds } 711*862465f2SPatrick McHardy } 7121da177e4SLinus Torvalds 713*862465f2SPatrick McHardy if (!found) { 7141da177e4SLinus Torvalds /* 7151da177e4SLinus Torvalds * Create a new entry if allowable 7161da177e4SLinus Torvalds */ 7171da177e4SLinus Torvalds 7184feb88e5SBenjamin Thery if (atomic_read(&net->ipv4.cache_resolve_queue_len) >= 10 || 719d658f8a0SPatrick McHardy (c = ipmr_cache_alloc_unres()) == NULL) { 7201da177e4SLinus Torvalds spin_unlock_bh(&mfc_unres_lock); 7211da177e4SLinus Torvalds 7221da177e4SLinus Torvalds kfree_skb(skb); 7231da177e4SLinus Torvalds return -ENOBUFS; 7241da177e4SLinus Torvalds } 7251da177e4SLinus Torvalds 7261da177e4SLinus Torvalds /* 7271da177e4SLinus Torvalds * Fill in the new cache entry 7281da177e4SLinus Torvalds */ 7291da177e4SLinus Torvalds c->mfc_parent = -1; 730eddc9ec5SArnaldo Carvalho de Melo c->mfc_origin = iph->saddr; 731eddc9ec5SArnaldo Carvalho de Melo c->mfc_mcastgrp = iph->daddr; 7321da177e4SLinus Torvalds 7331da177e4SLinus Torvalds /* 7341da177e4SLinus Torvalds * Reflect first query at mrouted. 7351da177e4SLinus Torvalds */ 7364feb88e5SBenjamin Thery err = ipmr_cache_report(net, skb, vifi, IGMPMSG_NOCACHE); 7374feb88e5SBenjamin Thery if (err < 0) { 7381da177e4SLinus Torvalds /* If the report failed throw the cache entry 7391da177e4SLinus Torvalds out - Brad Parker 7401da177e4SLinus Torvalds */ 7411da177e4SLinus Torvalds spin_unlock_bh(&mfc_unres_lock); 7421da177e4SLinus Torvalds 7435c0a66f5SBenjamin Thery ipmr_cache_free(c); 7441da177e4SLinus Torvalds kfree_skb(skb); 7451da177e4SLinus Torvalds return err; 7461da177e4SLinus Torvalds } 7471da177e4SLinus Torvalds 7484feb88e5SBenjamin Thery atomic_inc(&net->ipv4.cache_resolve_queue_len); 749*862465f2SPatrick McHardy list_add(&c->list, &net->ipv4.mfc_unres_queue); 7501da177e4SLinus Torvalds 751e258beb2SPatrick McHardy mod_timer(&net->ipv4.ipmr_expire_timer, c->mfc_un.unres.expires); 7521da177e4SLinus Torvalds } 7531da177e4SLinus Torvalds 7541da177e4SLinus Torvalds /* 7551da177e4SLinus Torvalds * See if we can append the packet 7561da177e4SLinus Torvalds */ 7571da177e4SLinus Torvalds if (c->mfc_un.unres.unresolved.qlen>3) { 7581da177e4SLinus Torvalds kfree_skb(skb); 7591da177e4SLinus Torvalds err = -ENOBUFS; 7601da177e4SLinus Torvalds } else { 7611da177e4SLinus Torvalds skb_queue_tail(&c->mfc_un.unres.unresolved, skb); 7621da177e4SLinus Torvalds err = 0; 7631da177e4SLinus Torvalds } 7641da177e4SLinus Torvalds 7651da177e4SLinus Torvalds spin_unlock_bh(&mfc_unres_lock); 7661da177e4SLinus Torvalds return err; 7671da177e4SLinus Torvalds } 7681da177e4SLinus Torvalds 7691da177e4SLinus Torvalds /* 7701da177e4SLinus Torvalds * MFC cache manipulation by user space mroute daemon 7711da177e4SLinus Torvalds */ 7721da177e4SLinus Torvalds 7734feb88e5SBenjamin Thery static int ipmr_mfc_delete(struct net *net, struct mfcctl *mfc) 7741da177e4SLinus Torvalds { 7751da177e4SLinus Torvalds int line; 776*862465f2SPatrick McHardy struct mfc_cache *c, *next; 7771da177e4SLinus Torvalds 7781da177e4SLinus Torvalds line = MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr); 7791da177e4SLinus Torvalds 780*862465f2SPatrick McHardy list_for_each_entry_safe(c, next, &net->ipv4.mfc_cache_array[line], list) { 7811da177e4SLinus Torvalds if (c->mfc_origin == mfc->mfcc_origin.s_addr && 7821da177e4SLinus Torvalds c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr) { 7831da177e4SLinus Torvalds write_lock_bh(&mrt_lock); 784*862465f2SPatrick McHardy list_del(&c->list); 7851da177e4SLinus Torvalds write_unlock_bh(&mrt_lock); 7861da177e4SLinus Torvalds 7875c0a66f5SBenjamin Thery ipmr_cache_free(c); 7881da177e4SLinus Torvalds return 0; 7891da177e4SLinus Torvalds } 7901da177e4SLinus Torvalds } 7911da177e4SLinus Torvalds return -ENOENT; 7921da177e4SLinus Torvalds } 7931da177e4SLinus Torvalds 7944feb88e5SBenjamin Thery static int ipmr_mfc_add(struct net *net, struct mfcctl *mfc, int mrtsock) 7951da177e4SLinus Torvalds { 796*862465f2SPatrick McHardy bool found = false; 7971da177e4SLinus Torvalds int line; 798*862465f2SPatrick McHardy struct mfc_cache *uc, *c; 7991da177e4SLinus Torvalds 800a50436f2SPatrick McHardy if (mfc->mfcc_parent >= MAXVIFS) 801a50436f2SPatrick McHardy return -ENFILE; 802a50436f2SPatrick McHardy 8031da177e4SLinus Torvalds line = MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr); 8041da177e4SLinus Torvalds 805*862465f2SPatrick McHardy list_for_each_entry(c, &net->ipv4.mfc_cache_array[line], list) { 8061da177e4SLinus Torvalds if (c->mfc_origin == mfc->mfcc_origin.s_addr && 807*862465f2SPatrick McHardy c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr) { 808*862465f2SPatrick McHardy found = true; 8091da177e4SLinus Torvalds break; 8101da177e4SLinus Torvalds } 811*862465f2SPatrick McHardy } 8121da177e4SLinus Torvalds 813*862465f2SPatrick McHardy if (found) { 8141da177e4SLinus Torvalds write_lock_bh(&mrt_lock); 8151da177e4SLinus Torvalds c->mfc_parent = mfc->mfcc_parent; 816d658f8a0SPatrick McHardy ipmr_update_thresholds(net, c, mfc->mfcc_ttls); 8171da177e4SLinus Torvalds if (!mrtsock) 8181da177e4SLinus Torvalds c->mfc_flags |= MFC_STATIC; 8191da177e4SLinus Torvalds write_unlock_bh(&mrt_lock); 8201da177e4SLinus Torvalds return 0; 8211da177e4SLinus Torvalds } 8221da177e4SLinus Torvalds 823f97c1e0cSJoe Perches if (!ipv4_is_multicast(mfc->mfcc_mcastgrp.s_addr)) 8241da177e4SLinus Torvalds return -EINVAL; 8251da177e4SLinus Torvalds 826d658f8a0SPatrick McHardy c = ipmr_cache_alloc(); 8271da177e4SLinus Torvalds if (c == NULL) 8281da177e4SLinus Torvalds return -ENOMEM; 8291da177e4SLinus Torvalds 8301da177e4SLinus Torvalds c->mfc_origin = mfc->mfcc_origin.s_addr; 8311da177e4SLinus Torvalds c->mfc_mcastgrp = mfc->mfcc_mcastgrp.s_addr; 8321da177e4SLinus Torvalds c->mfc_parent = mfc->mfcc_parent; 833d658f8a0SPatrick McHardy ipmr_update_thresholds(net, c, mfc->mfcc_ttls); 8341da177e4SLinus Torvalds if (!mrtsock) 8351da177e4SLinus Torvalds c->mfc_flags |= MFC_STATIC; 8361da177e4SLinus Torvalds 8371da177e4SLinus Torvalds write_lock_bh(&mrt_lock); 838*862465f2SPatrick McHardy list_add(&c->list, &net->ipv4.mfc_cache_array[line]); 8391da177e4SLinus Torvalds write_unlock_bh(&mrt_lock); 8401da177e4SLinus Torvalds 8411da177e4SLinus Torvalds /* 8421da177e4SLinus Torvalds * Check to see if we resolved a queued list. If so we 8431da177e4SLinus Torvalds * need to send on the frames and tidy up. 8441da177e4SLinus Torvalds */ 8451da177e4SLinus Torvalds spin_lock_bh(&mfc_unres_lock); 846*862465f2SPatrick McHardy list_for_each_entry(uc, &net->ipv4.mfc_unres_queue, list) { 847e258beb2SPatrick McHardy if (uc->mfc_origin == c->mfc_origin && 8481da177e4SLinus Torvalds uc->mfc_mcastgrp == c->mfc_mcastgrp) { 849*862465f2SPatrick McHardy list_del(&uc->list); 8504feb88e5SBenjamin Thery atomic_dec(&net->ipv4.cache_resolve_queue_len); 8511da177e4SLinus Torvalds break; 8521da177e4SLinus Torvalds } 8531da177e4SLinus Torvalds } 854*862465f2SPatrick McHardy if (list_empty(&net->ipv4.mfc_unres_queue)) 855e258beb2SPatrick McHardy del_timer(&net->ipv4.ipmr_expire_timer); 8561da177e4SLinus Torvalds spin_unlock_bh(&mfc_unres_lock); 8571da177e4SLinus Torvalds 8581da177e4SLinus Torvalds if (uc) { 859d658f8a0SPatrick McHardy ipmr_cache_resolve(net, uc, c); 8605c0a66f5SBenjamin Thery ipmr_cache_free(uc); 8611da177e4SLinus Torvalds } 8621da177e4SLinus Torvalds return 0; 8631da177e4SLinus Torvalds } 8641da177e4SLinus Torvalds 8651da177e4SLinus Torvalds /* 8661da177e4SLinus Torvalds * Close the multicast socket, and clear the vif tables etc 8671da177e4SLinus Torvalds */ 8681da177e4SLinus Torvalds 8694feb88e5SBenjamin Thery static void mroute_clean_tables(struct net *net) 8701da177e4SLinus Torvalds { 8711da177e4SLinus Torvalds int i; 872d17fa6faSEric Dumazet LIST_HEAD(list); 873*862465f2SPatrick McHardy struct mfc_cache *c, *next; 8741da177e4SLinus Torvalds 8751da177e4SLinus Torvalds /* 8761da177e4SLinus Torvalds * Shut down all active vif entries 8771da177e4SLinus Torvalds */ 8784feb88e5SBenjamin Thery for (i = 0; i < net->ipv4.maxvif; i++) { 8794feb88e5SBenjamin Thery if (!(net->ipv4.vif_table[i].flags&VIFF_STATIC)) 880d17fa6faSEric Dumazet vif_delete(net, i, 0, &list); 8811da177e4SLinus Torvalds } 882d17fa6faSEric Dumazet unregister_netdevice_many(&list); 8831da177e4SLinus Torvalds 8841da177e4SLinus Torvalds /* 8851da177e4SLinus Torvalds * Wipe the cache 8861da177e4SLinus Torvalds */ 8871da177e4SLinus Torvalds for (i = 0; i < MFC_LINES; i++) { 888*862465f2SPatrick McHardy list_for_each_entry_safe(c, next, &net->ipv4.mfc_cache_array[i], list) { 889*862465f2SPatrick McHardy if (c->mfc_flags&MFC_STATIC) 8901da177e4SLinus Torvalds continue; 8911da177e4SLinus Torvalds write_lock_bh(&mrt_lock); 892*862465f2SPatrick McHardy list_del(&c->list); 8931da177e4SLinus Torvalds write_unlock_bh(&mrt_lock); 8941da177e4SLinus Torvalds 8955c0a66f5SBenjamin Thery ipmr_cache_free(c); 8961da177e4SLinus Torvalds } 8971da177e4SLinus Torvalds } 8981da177e4SLinus Torvalds 8994feb88e5SBenjamin Thery if (atomic_read(&net->ipv4.cache_resolve_queue_len) != 0) { 9001da177e4SLinus Torvalds spin_lock_bh(&mfc_unres_lock); 901*862465f2SPatrick McHardy list_for_each_entry_safe(c, next, &net->ipv4.mfc_unres_queue, list) { 902*862465f2SPatrick McHardy list_del(&c->list); 903d658f8a0SPatrick McHardy ipmr_destroy_unres(net, c); 9041da177e4SLinus Torvalds } 9051da177e4SLinus Torvalds spin_unlock_bh(&mfc_unres_lock); 9061da177e4SLinus Torvalds } 9071da177e4SLinus Torvalds } 9081da177e4SLinus Torvalds 9091da177e4SLinus Torvalds static void mrtsock_destruct(struct sock *sk) 9101da177e4SLinus Torvalds { 9114feb88e5SBenjamin Thery struct net *net = sock_net(sk); 9124feb88e5SBenjamin Thery 9131da177e4SLinus Torvalds rtnl_lock(); 9144feb88e5SBenjamin Thery if (sk == net->ipv4.mroute_sk) { 9154feb88e5SBenjamin Thery IPV4_DEVCONF_ALL(net, MC_FORWARDING)--; 9161da177e4SLinus Torvalds 9171da177e4SLinus Torvalds write_lock_bh(&mrt_lock); 9184feb88e5SBenjamin Thery net->ipv4.mroute_sk = NULL; 9191da177e4SLinus Torvalds write_unlock_bh(&mrt_lock); 9201da177e4SLinus Torvalds 9214feb88e5SBenjamin Thery mroute_clean_tables(net); 9221da177e4SLinus Torvalds } 9231da177e4SLinus Torvalds rtnl_unlock(); 9241da177e4SLinus Torvalds } 9251da177e4SLinus Torvalds 9261da177e4SLinus Torvalds /* 9271da177e4SLinus Torvalds * Socket options and virtual interface manipulation. The whole 9281da177e4SLinus Torvalds * virtual interface system is a complete heap, but unfortunately 9291da177e4SLinus Torvalds * that's how BSD mrouted happens to think. Maybe one day with a proper 9301da177e4SLinus Torvalds * MOSPF/PIM router set up we can clean this up. 9311da177e4SLinus Torvalds */ 9321da177e4SLinus Torvalds 933b7058842SDavid S. Miller int ip_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsigned int optlen) 9341da177e4SLinus Torvalds { 9351da177e4SLinus Torvalds int ret; 9361da177e4SLinus Torvalds struct vifctl vif; 9371da177e4SLinus Torvalds struct mfcctl mfc; 9384feb88e5SBenjamin Thery struct net *net = sock_net(sk); 9391da177e4SLinus Torvalds 940132adf54SStephen Hemminger if (optname != MRT_INIT) { 9414feb88e5SBenjamin Thery if (sk != net->ipv4.mroute_sk && !capable(CAP_NET_ADMIN)) 9421da177e4SLinus Torvalds return -EACCES; 9431da177e4SLinus Torvalds } 9441da177e4SLinus Torvalds 945132adf54SStephen Hemminger switch (optname) { 9461da177e4SLinus Torvalds case MRT_INIT: 9471da177e4SLinus Torvalds if (sk->sk_type != SOCK_RAW || 948c720c7e8SEric Dumazet inet_sk(sk)->inet_num != IPPROTO_IGMP) 9491da177e4SLinus Torvalds return -EOPNOTSUPP; 9501da177e4SLinus Torvalds if (optlen != sizeof(int)) 9511da177e4SLinus Torvalds return -ENOPROTOOPT; 9521da177e4SLinus Torvalds 9531da177e4SLinus Torvalds rtnl_lock(); 9544feb88e5SBenjamin Thery if (net->ipv4.mroute_sk) { 9551da177e4SLinus Torvalds rtnl_unlock(); 9561da177e4SLinus Torvalds return -EADDRINUSE; 9571da177e4SLinus Torvalds } 9581da177e4SLinus Torvalds 9591da177e4SLinus Torvalds ret = ip_ra_control(sk, 1, mrtsock_destruct); 9601da177e4SLinus Torvalds if (ret == 0) { 9611da177e4SLinus Torvalds write_lock_bh(&mrt_lock); 9624feb88e5SBenjamin Thery net->ipv4.mroute_sk = sk; 9631da177e4SLinus Torvalds write_unlock_bh(&mrt_lock); 9641da177e4SLinus Torvalds 9654feb88e5SBenjamin Thery IPV4_DEVCONF_ALL(net, MC_FORWARDING)++; 9661da177e4SLinus Torvalds } 9671da177e4SLinus Torvalds rtnl_unlock(); 9681da177e4SLinus Torvalds return ret; 9691da177e4SLinus Torvalds case MRT_DONE: 9704feb88e5SBenjamin Thery if (sk != net->ipv4.mroute_sk) 9711da177e4SLinus Torvalds return -EACCES; 9721da177e4SLinus Torvalds return ip_ra_control(sk, 0, NULL); 9731da177e4SLinus Torvalds case MRT_ADD_VIF: 9741da177e4SLinus Torvalds case MRT_DEL_VIF: 9751da177e4SLinus Torvalds if (optlen != sizeof(vif)) 9761da177e4SLinus Torvalds return -EINVAL; 9771da177e4SLinus Torvalds if (copy_from_user(&vif, optval, sizeof(vif))) 9781da177e4SLinus Torvalds return -EFAULT; 9791da177e4SLinus Torvalds if (vif.vifc_vifi >= MAXVIFS) 9801da177e4SLinus Torvalds return -ENFILE; 9811da177e4SLinus Torvalds rtnl_lock(); 9821da177e4SLinus Torvalds if (optname == MRT_ADD_VIF) { 9834feb88e5SBenjamin Thery ret = vif_add(net, &vif, sk == net->ipv4.mroute_sk); 9841da177e4SLinus Torvalds } else { 985d17fa6faSEric Dumazet ret = vif_delete(net, vif.vifc_vifi, 0, NULL); 9861da177e4SLinus Torvalds } 9871da177e4SLinus Torvalds rtnl_unlock(); 9881da177e4SLinus Torvalds return ret; 9891da177e4SLinus Torvalds 9901da177e4SLinus Torvalds /* 9911da177e4SLinus Torvalds * Manipulate the forwarding caches. These live 9921da177e4SLinus Torvalds * in a sort of kernel/user symbiosis. 9931da177e4SLinus Torvalds */ 9941da177e4SLinus Torvalds case MRT_ADD_MFC: 9951da177e4SLinus Torvalds case MRT_DEL_MFC: 9961da177e4SLinus Torvalds if (optlen != sizeof(mfc)) 9971da177e4SLinus Torvalds return -EINVAL; 9981da177e4SLinus Torvalds if (copy_from_user(&mfc, optval, sizeof(mfc))) 9991da177e4SLinus Torvalds return -EFAULT; 10001da177e4SLinus Torvalds rtnl_lock(); 10011da177e4SLinus Torvalds if (optname == MRT_DEL_MFC) 10024feb88e5SBenjamin Thery ret = ipmr_mfc_delete(net, &mfc); 10031da177e4SLinus Torvalds else 10044feb88e5SBenjamin Thery ret = ipmr_mfc_add(net, &mfc, sk == net->ipv4.mroute_sk); 10051da177e4SLinus Torvalds rtnl_unlock(); 10061da177e4SLinus Torvalds return ret; 10071da177e4SLinus Torvalds /* 10081da177e4SLinus Torvalds * Control PIM assert. 10091da177e4SLinus Torvalds */ 10101da177e4SLinus Torvalds case MRT_ASSERT: 10111da177e4SLinus Torvalds { 10121da177e4SLinus Torvalds int v; 10131da177e4SLinus Torvalds if (get_user(v,(int __user *)optval)) 10141da177e4SLinus Torvalds return -EFAULT; 10154feb88e5SBenjamin Thery net->ipv4.mroute_do_assert = (v) ? 1 : 0; 10161da177e4SLinus Torvalds return 0; 10171da177e4SLinus Torvalds } 10181da177e4SLinus Torvalds #ifdef CONFIG_IP_PIMSM 10191da177e4SLinus Torvalds case MRT_PIM: 10201da177e4SLinus Torvalds { 1021ba93ef74SStephen Hemminger int v; 1022ba93ef74SStephen Hemminger 10231da177e4SLinus Torvalds if (get_user(v,(int __user *)optval)) 10241da177e4SLinus Torvalds return -EFAULT; 10251da177e4SLinus Torvalds v = (v) ? 1 : 0; 1026ba93ef74SStephen Hemminger 10271da177e4SLinus Torvalds rtnl_lock(); 10281da177e4SLinus Torvalds ret = 0; 10294feb88e5SBenjamin Thery if (v != net->ipv4.mroute_do_pim) { 10304feb88e5SBenjamin Thery net->ipv4.mroute_do_pim = v; 10314feb88e5SBenjamin Thery net->ipv4.mroute_do_assert = v; 10321da177e4SLinus Torvalds } 10331da177e4SLinus Torvalds rtnl_unlock(); 10341da177e4SLinus Torvalds return ret; 10351da177e4SLinus Torvalds } 10361da177e4SLinus Torvalds #endif 10371da177e4SLinus Torvalds /* 10381da177e4SLinus Torvalds * Spurious command, or MRT_VERSION which you cannot 10391da177e4SLinus Torvalds * set. 10401da177e4SLinus Torvalds */ 10411da177e4SLinus Torvalds default: 10421da177e4SLinus Torvalds return -ENOPROTOOPT; 10431da177e4SLinus Torvalds } 10441da177e4SLinus Torvalds } 10451da177e4SLinus Torvalds 10461da177e4SLinus Torvalds /* 10471da177e4SLinus Torvalds * Getsock opt support for the multicast routing system. 10481da177e4SLinus Torvalds */ 10491da177e4SLinus Torvalds 10501da177e4SLinus Torvalds int ip_mroute_getsockopt(struct sock *sk, int optname, char __user *optval, int __user *optlen) 10511da177e4SLinus Torvalds { 10521da177e4SLinus Torvalds int olr; 10531da177e4SLinus Torvalds int val; 10544feb88e5SBenjamin Thery struct net *net = sock_net(sk); 10551da177e4SLinus Torvalds 10561da177e4SLinus Torvalds if (optname != MRT_VERSION && 10571da177e4SLinus Torvalds #ifdef CONFIG_IP_PIMSM 10581da177e4SLinus Torvalds optname!=MRT_PIM && 10591da177e4SLinus Torvalds #endif 10601da177e4SLinus Torvalds optname!=MRT_ASSERT) 10611da177e4SLinus Torvalds return -ENOPROTOOPT; 10621da177e4SLinus Torvalds 10631da177e4SLinus Torvalds if (get_user(olr, optlen)) 10641da177e4SLinus Torvalds return -EFAULT; 10651da177e4SLinus Torvalds 10661da177e4SLinus Torvalds olr = min_t(unsigned int, olr, sizeof(int)); 10671da177e4SLinus Torvalds if (olr < 0) 10681da177e4SLinus Torvalds return -EINVAL; 10691da177e4SLinus Torvalds 10701da177e4SLinus Torvalds if (put_user(olr, optlen)) 10711da177e4SLinus Torvalds return -EFAULT; 10721da177e4SLinus Torvalds if (optname == MRT_VERSION) 10731da177e4SLinus Torvalds val = 0x0305; 10741da177e4SLinus Torvalds #ifdef CONFIG_IP_PIMSM 10751da177e4SLinus Torvalds else if (optname == MRT_PIM) 10764feb88e5SBenjamin Thery val = net->ipv4.mroute_do_pim; 10771da177e4SLinus Torvalds #endif 10781da177e4SLinus Torvalds else 10794feb88e5SBenjamin Thery val = net->ipv4.mroute_do_assert; 10801da177e4SLinus Torvalds if (copy_to_user(optval, &val, olr)) 10811da177e4SLinus Torvalds return -EFAULT; 10821da177e4SLinus Torvalds return 0; 10831da177e4SLinus Torvalds } 10841da177e4SLinus Torvalds 10851da177e4SLinus Torvalds /* 10861da177e4SLinus Torvalds * The IP multicast ioctl support routines. 10871da177e4SLinus Torvalds */ 10881da177e4SLinus Torvalds 10891da177e4SLinus Torvalds int ipmr_ioctl(struct sock *sk, int cmd, void __user *arg) 10901da177e4SLinus Torvalds { 10911da177e4SLinus Torvalds struct sioc_sg_req sr; 10921da177e4SLinus Torvalds struct sioc_vif_req vr; 10931da177e4SLinus Torvalds struct vif_device *vif; 10941da177e4SLinus Torvalds struct mfc_cache *c; 10954feb88e5SBenjamin Thery struct net *net = sock_net(sk); 10961da177e4SLinus Torvalds 1097132adf54SStephen Hemminger switch (cmd) { 10981da177e4SLinus Torvalds case SIOCGETVIFCNT: 10991da177e4SLinus Torvalds if (copy_from_user(&vr, arg, sizeof(vr))) 11001da177e4SLinus Torvalds return -EFAULT; 11014feb88e5SBenjamin Thery if (vr.vifi >= net->ipv4.maxvif) 11021da177e4SLinus Torvalds return -EINVAL; 11031da177e4SLinus Torvalds read_lock(&mrt_lock); 11044feb88e5SBenjamin Thery vif = &net->ipv4.vif_table[vr.vifi]; 11054feb88e5SBenjamin Thery if (VIF_EXISTS(net, vr.vifi)) { 11061da177e4SLinus Torvalds vr.icount = vif->pkt_in; 11071da177e4SLinus Torvalds vr.ocount = vif->pkt_out; 11081da177e4SLinus Torvalds vr.ibytes = vif->bytes_in; 11091da177e4SLinus Torvalds vr.obytes = vif->bytes_out; 11101da177e4SLinus Torvalds read_unlock(&mrt_lock); 11111da177e4SLinus Torvalds 11121da177e4SLinus Torvalds if (copy_to_user(arg, &vr, sizeof(vr))) 11131da177e4SLinus Torvalds return -EFAULT; 11141da177e4SLinus Torvalds return 0; 11151da177e4SLinus Torvalds } 11161da177e4SLinus Torvalds read_unlock(&mrt_lock); 11171da177e4SLinus Torvalds return -EADDRNOTAVAIL; 11181da177e4SLinus Torvalds case SIOCGETSGCNT: 11191da177e4SLinus Torvalds if (copy_from_user(&sr, arg, sizeof(sr))) 11201da177e4SLinus Torvalds return -EFAULT; 11211da177e4SLinus Torvalds 11221da177e4SLinus Torvalds read_lock(&mrt_lock); 11234feb88e5SBenjamin Thery c = ipmr_cache_find(net, sr.src.s_addr, sr.grp.s_addr); 11241da177e4SLinus Torvalds if (c) { 11251da177e4SLinus Torvalds sr.pktcnt = c->mfc_un.res.pkt; 11261da177e4SLinus Torvalds sr.bytecnt = c->mfc_un.res.bytes; 11271da177e4SLinus Torvalds sr.wrong_if = c->mfc_un.res.wrong_if; 11281da177e4SLinus Torvalds read_unlock(&mrt_lock); 11291da177e4SLinus Torvalds 11301da177e4SLinus Torvalds if (copy_to_user(arg, &sr, sizeof(sr))) 11311da177e4SLinus Torvalds return -EFAULT; 11321da177e4SLinus Torvalds return 0; 11331da177e4SLinus Torvalds } 11341da177e4SLinus Torvalds read_unlock(&mrt_lock); 11351da177e4SLinus Torvalds return -EADDRNOTAVAIL; 11361da177e4SLinus Torvalds default: 11371da177e4SLinus Torvalds return -ENOIOCTLCMD; 11381da177e4SLinus Torvalds } 11391da177e4SLinus Torvalds } 11401da177e4SLinus Torvalds 11411da177e4SLinus Torvalds 11421da177e4SLinus Torvalds static int ipmr_device_event(struct notifier_block *this, unsigned long event, void *ptr) 11431da177e4SLinus Torvalds { 1144e9dc8653SEric W. Biederman struct net_device *dev = ptr; 11454feb88e5SBenjamin Thery struct net *net = dev_net(dev); 11461da177e4SLinus Torvalds struct vif_device *v; 11471da177e4SLinus Torvalds int ct; 1148d17fa6faSEric Dumazet LIST_HEAD(list); 1149e9dc8653SEric W. Biederman 11501da177e4SLinus Torvalds if (event != NETDEV_UNREGISTER) 11511da177e4SLinus Torvalds return NOTIFY_DONE; 11524feb88e5SBenjamin Thery v = &net->ipv4.vif_table[0]; 11534feb88e5SBenjamin Thery for (ct = 0; ct < net->ipv4.maxvif; ct++, v++) { 1154e9dc8653SEric W. Biederman if (v->dev == dev) 1155d17fa6faSEric Dumazet vif_delete(net, ct, 1, &list); 11561da177e4SLinus Torvalds } 1157d17fa6faSEric Dumazet unregister_netdevice_many(&list); 11581da177e4SLinus Torvalds return NOTIFY_DONE; 11591da177e4SLinus Torvalds } 11601da177e4SLinus Torvalds 11611da177e4SLinus Torvalds 11621da177e4SLinus Torvalds static struct notifier_block ip_mr_notifier = { 11631da177e4SLinus Torvalds .notifier_call = ipmr_device_event, 11641da177e4SLinus Torvalds }; 11651da177e4SLinus Torvalds 11661da177e4SLinus Torvalds /* 11671da177e4SLinus Torvalds * Encapsulate a packet by attaching a valid IPIP header to it. 11681da177e4SLinus Torvalds * This avoids tunnel drivers and other mess and gives us the speed so 11691da177e4SLinus Torvalds * important for multicast video. 11701da177e4SLinus Torvalds */ 11711da177e4SLinus Torvalds 1172114c7844SAl Viro static void ip_encap(struct sk_buff *skb, __be32 saddr, __be32 daddr) 11731da177e4SLinus Torvalds { 11748856dfa3SArnaldo Carvalho de Melo struct iphdr *iph; 1175eddc9ec5SArnaldo Carvalho de Melo struct iphdr *old_iph = ip_hdr(skb); 11768856dfa3SArnaldo Carvalho de Melo 11778856dfa3SArnaldo Carvalho de Melo skb_push(skb, sizeof(struct iphdr)); 1178b0e380b1SArnaldo Carvalho de Melo skb->transport_header = skb->network_header; 11798856dfa3SArnaldo Carvalho de Melo skb_reset_network_header(skb); 1180eddc9ec5SArnaldo Carvalho de Melo iph = ip_hdr(skb); 11811da177e4SLinus Torvalds 11821da177e4SLinus Torvalds iph->version = 4; 1183e023dd64SArnaldo Carvalho de Melo iph->tos = old_iph->tos; 1184e023dd64SArnaldo Carvalho de Melo iph->ttl = old_iph->ttl; 11851da177e4SLinus Torvalds iph->frag_off = 0; 11861da177e4SLinus Torvalds iph->daddr = daddr; 11871da177e4SLinus Torvalds iph->saddr = saddr; 11881da177e4SLinus Torvalds iph->protocol = IPPROTO_IPIP; 11891da177e4SLinus Torvalds iph->ihl = 5; 11901da177e4SLinus Torvalds iph->tot_len = htons(skb->len); 1191adf30907SEric Dumazet ip_select_ident(iph, skb_dst(skb), NULL); 11921da177e4SLinus Torvalds ip_send_check(iph); 11931da177e4SLinus Torvalds 11941da177e4SLinus Torvalds memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt)); 11951da177e4SLinus Torvalds nf_reset(skb); 11961da177e4SLinus Torvalds } 11971da177e4SLinus Torvalds 11981da177e4SLinus Torvalds static inline int ipmr_forward_finish(struct sk_buff *skb) 11991da177e4SLinus Torvalds { 12001da177e4SLinus Torvalds struct ip_options * opt = &(IPCB(skb)->opt); 12011da177e4SLinus Torvalds 1202adf30907SEric Dumazet IP_INC_STATS_BH(dev_net(skb_dst(skb)->dev), IPSTATS_MIB_OUTFORWDATAGRAMS); 12031da177e4SLinus Torvalds 12041da177e4SLinus Torvalds if (unlikely(opt->optlen)) 12051da177e4SLinus Torvalds ip_forward_options(skb); 12061da177e4SLinus Torvalds 12071da177e4SLinus Torvalds return dst_output(skb); 12081da177e4SLinus Torvalds } 12091da177e4SLinus Torvalds 12101da177e4SLinus Torvalds /* 12111da177e4SLinus Torvalds * Processing handlers for ipmr_forward 12121da177e4SLinus Torvalds */ 12131da177e4SLinus Torvalds 1214d658f8a0SPatrick McHardy static void ipmr_queue_xmit(struct net *net, struct sk_buff *skb, 1215d658f8a0SPatrick McHardy struct mfc_cache *c, int vifi) 12161da177e4SLinus Torvalds { 1217eddc9ec5SArnaldo Carvalho de Melo const struct iphdr *iph = ip_hdr(skb); 12184feb88e5SBenjamin Thery struct vif_device *vif = &net->ipv4.vif_table[vifi]; 12191da177e4SLinus Torvalds struct net_device *dev; 12201da177e4SLinus Torvalds struct rtable *rt; 12211da177e4SLinus Torvalds int encap = 0; 12221da177e4SLinus Torvalds 12231da177e4SLinus Torvalds if (vif->dev == NULL) 12241da177e4SLinus Torvalds goto out_free; 12251da177e4SLinus Torvalds 12261da177e4SLinus Torvalds #ifdef CONFIG_IP_PIMSM 12271da177e4SLinus Torvalds if (vif->flags & VIFF_REGISTER) { 12281da177e4SLinus Torvalds vif->pkt_out++; 12291da177e4SLinus Torvalds vif->bytes_out += skb->len; 1230cf3677aeSPavel Emelyanov vif->dev->stats.tx_bytes += skb->len; 1231cf3677aeSPavel Emelyanov vif->dev->stats.tx_packets++; 12324feb88e5SBenjamin Thery ipmr_cache_report(net, skb, vifi, IGMPMSG_WHOLEPKT); 123369ebbf58SIlpo Järvinen goto out_free; 12341da177e4SLinus Torvalds } 12351da177e4SLinus Torvalds #endif 12361da177e4SLinus Torvalds 12371da177e4SLinus Torvalds if (vif->flags&VIFF_TUNNEL) { 12381da177e4SLinus Torvalds struct flowi fl = { .oif = vif->link, 12391da177e4SLinus Torvalds .nl_u = { .ip4_u = 12401da177e4SLinus Torvalds { .daddr = vif->remote, 12411da177e4SLinus Torvalds .saddr = vif->local, 12421da177e4SLinus Torvalds .tos = RT_TOS(iph->tos) } }, 12431da177e4SLinus Torvalds .proto = IPPROTO_IPIP }; 12444feb88e5SBenjamin Thery if (ip_route_output_key(net, &rt, &fl)) 12451da177e4SLinus Torvalds goto out_free; 12461da177e4SLinus Torvalds encap = sizeof(struct iphdr); 12471da177e4SLinus Torvalds } else { 12481da177e4SLinus Torvalds struct flowi fl = { .oif = vif->link, 12491da177e4SLinus Torvalds .nl_u = { .ip4_u = 12501da177e4SLinus Torvalds { .daddr = iph->daddr, 12511da177e4SLinus Torvalds .tos = RT_TOS(iph->tos) } }, 12521da177e4SLinus Torvalds .proto = IPPROTO_IPIP }; 12534feb88e5SBenjamin Thery if (ip_route_output_key(net, &rt, &fl)) 12541da177e4SLinus Torvalds goto out_free; 12551da177e4SLinus Torvalds } 12561da177e4SLinus Torvalds 12571da177e4SLinus Torvalds dev = rt->u.dst.dev; 12581da177e4SLinus Torvalds 12591da177e4SLinus Torvalds if (skb->len+encap > dst_mtu(&rt->u.dst) && (ntohs(iph->frag_off) & IP_DF)) { 12601da177e4SLinus Torvalds /* Do not fragment multicasts. Alas, IPv4 does not 12611da177e4SLinus Torvalds allow to send ICMP, so that packets will disappear 12621da177e4SLinus Torvalds to blackhole. 12631da177e4SLinus Torvalds */ 12641da177e4SLinus Torvalds 12657c73a6faSPavel Emelyanov IP_INC_STATS_BH(dev_net(dev), IPSTATS_MIB_FRAGFAILS); 12661da177e4SLinus Torvalds ip_rt_put(rt); 12671da177e4SLinus Torvalds goto out_free; 12681da177e4SLinus Torvalds } 12691da177e4SLinus Torvalds 12701da177e4SLinus Torvalds encap += LL_RESERVED_SPACE(dev) + rt->u.dst.header_len; 12711da177e4SLinus Torvalds 12721da177e4SLinus Torvalds if (skb_cow(skb, encap)) { 12731da177e4SLinus Torvalds ip_rt_put(rt); 12741da177e4SLinus Torvalds goto out_free; 12751da177e4SLinus Torvalds } 12761da177e4SLinus Torvalds 12771da177e4SLinus Torvalds vif->pkt_out++; 12781da177e4SLinus Torvalds vif->bytes_out += skb->len; 12791da177e4SLinus Torvalds 1280adf30907SEric Dumazet skb_dst_drop(skb); 1281adf30907SEric Dumazet skb_dst_set(skb, &rt->u.dst); 1282eddc9ec5SArnaldo Carvalho de Melo ip_decrease_ttl(ip_hdr(skb)); 12831da177e4SLinus Torvalds 12841da177e4SLinus Torvalds /* FIXME: forward and output firewalls used to be called here. 12851da177e4SLinus Torvalds * What do we do with netfilter? -- RR */ 12861da177e4SLinus Torvalds if (vif->flags & VIFF_TUNNEL) { 12871da177e4SLinus Torvalds ip_encap(skb, vif->local, vif->remote); 12881da177e4SLinus Torvalds /* FIXME: extra output firewall step used to be here. --RR */ 12892f4c02d4SPavel Emelyanov vif->dev->stats.tx_packets++; 12902f4c02d4SPavel Emelyanov vif->dev->stats.tx_bytes += skb->len; 12911da177e4SLinus Torvalds } 12921da177e4SLinus Torvalds 12931da177e4SLinus Torvalds IPCB(skb)->flags |= IPSKB_FORWARDED; 12941da177e4SLinus Torvalds 12951da177e4SLinus Torvalds /* 12961da177e4SLinus Torvalds * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally 12971da177e4SLinus Torvalds * not only before forwarding, but after forwarding on all output 12981da177e4SLinus Torvalds * interfaces. It is clear, if mrouter runs a multicasting 12991da177e4SLinus Torvalds * program, it should receive packets not depending to what interface 13001da177e4SLinus Torvalds * program is joined. 13011da177e4SLinus Torvalds * If we will not make it, the program will have to join on all 13021da177e4SLinus Torvalds * interfaces. On the other hand, multihoming host (or router, but 13031da177e4SLinus Torvalds * not mrouter) cannot join to more than one interface - it will 13041da177e4SLinus Torvalds * result in receiving multiple packets. 13051da177e4SLinus Torvalds */ 13066e23ae2aSPatrick McHardy NF_HOOK(PF_INET, NF_INET_FORWARD, skb, skb->dev, dev, 13071da177e4SLinus Torvalds ipmr_forward_finish); 13081da177e4SLinus Torvalds return; 13091da177e4SLinus Torvalds 13101da177e4SLinus Torvalds out_free: 13111da177e4SLinus Torvalds kfree_skb(skb); 13121da177e4SLinus Torvalds return; 13131da177e4SLinus Torvalds } 13141da177e4SLinus Torvalds 13151da177e4SLinus Torvalds static int ipmr_find_vif(struct net_device *dev) 13161da177e4SLinus Torvalds { 13174feb88e5SBenjamin Thery struct net *net = dev_net(dev); 13181da177e4SLinus Torvalds int ct; 13194feb88e5SBenjamin Thery for (ct = net->ipv4.maxvif-1; ct >= 0; ct--) { 13204feb88e5SBenjamin Thery if (net->ipv4.vif_table[ct].dev == dev) 13211da177e4SLinus Torvalds break; 13221da177e4SLinus Torvalds } 13231da177e4SLinus Torvalds return ct; 13241da177e4SLinus Torvalds } 13251da177e4SLinus Torvalds 13261da177e4SLinus Torvalds /* "local" means that we should preserve one skb (for local delivery) */ 13271da177e4SLinus Torvalds 1328d658f8a0SPatrick McHardy static int ip_mr_forward(struct net *net, struct sk_buff *skb, 1329d658f8a0SPatrick McHardy struct mfc_cache *cache, int local) 13301da177e4SLinus Torvalds { 13311da177e4SLinus Torvalds int psend = -1; 13321da177e4SLinus Torvalds int vif, ct; 13331da177e4SLinus Torvalds 13341da177e4SLinus Torvalds vif = cache->mfc_parent; 13351da177e4SLinus Torvalds cache->mfc_un.res.pkt++; 13361da177e4SLinus Torvalds cache->mfc_un.res.bytes += skb->len; 13371da177e4SLinus Torvalds 13381da177e4SLinus Torvalds /* 13391da177e4SLinus Torvalds * Wrong interface: drop packet and (maybe) send PIM assert. 13401da177e4SLinus Torvalds */ 13414feb88e5SBenjamin Thery if (net->ipv4.vif_table[vif].dev != skb->dev) { 13421da177e4SLinus Torvalds int true_vifi; 13431da177e4SLinus Torvalds 1344511c3f92SEric Dumazet if (skb_rtable(skb)->fl.iif == 0) { 13451da177e4SLinus Torvalds /* It is our own packet, looped back. 13461da177e4SLinus Torvalds Very complicated situation... 13471da177e4SLinus Torvalds 13481da177e4SLinus Torvalds The best workaround until routing daemons will be 13491da177e4SLinus Torvalds fixed is not to redistribute packet, if it was 13501da177e4SLinus Torvalds send through wrong interface. It means, that 13511da177e4SLinus Torvalds multicast applications WILL NOT work for 13521da177e4SLinus Torvalds (S,G), which have default multicast route pointing 13531da177e4SLinus Torvalds to wrong oif. In any case, it is not a good 13541da177e4SLinus Torvalds idea to use multicasting applications on router. 13551da177e4SLinus Torvalds */ 13561da177e4SLinus Torvalds goto dont_forward; 13571da177e4SLinus Torvalds } 13581da177e4SLinus Torvalds 13591da177e4SLinus Torvalds cache->mfc_un.res.wrong_if++; 13601da177e4SLinus Torvalds true_vifi = ipmr_find_vif(skb->dev); 13611da177e4SLinus Torvalds 13624feb88e5SBenjamin Thery if (true_vifi >= 0 && net->ipv4.mroute_do_assert && 13631da177e4SLinus Torvalds /* pimsm uses asserts, when switching from RPT to SPT, 13641da177e4SLinus Torvalds so that we cannot check that packet arrived on an oif. 13651da177e4SLinus Torvalds It is bad, but otherwise we would need to move pretty 13661da177e4SLinus Torvalds large chunk of pimd to kernel. Ough... --ANK 13671da177e4SLinus Torvalds */ 13684feb88e5SBenjamin Thery (net->ipv4.mroute_do_pim || 13696f9374a9SBenjamin Thery cache->mfc_un.res.ttls[true_vifi] < 255) && 13701da177e4SLinus Torvalds time_after(jiffies, 13711da177e4SLinus Torvalds cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) { 13721da177e4SLinus Torvalds cache->mfc_un.res.last_assert = jiffies; 13734feb88e5SBenjamin Thery ipmr_cache_report(net, skb, true_vifi, IGMPMSG_WRONGVIF); 13741da177e4SLinus Torvalds } 13751da177e4SLinus Torvalds goto dont_forward; 13761da177e4SLinus Torvalds } 13771da177e4SLinus Torvalds 13784feb88e5SBenjamin Thery net->ipv4.vif_table[vif].pkt_in++; 13794feb88e5SBenjamin Thery net->ipv4.vif_table[vif].bytes_in += skb->len; 13801da177e4SLinus Torvalds 13811da177e4SLinus Torvalds /* 13821da177e4SLinus Torvalds * Forward the frame 13831da177e4SLinus Torvalds */ 13841da177e4SLinus Torvalds for (ct = cache->mfc_un.res.maxvif-1; ct >= cache->mfc_un.res.minvif; ct--) { 1385eddc9ec5SArnaldo Carvalho de Melo if (ip_hdr(skb)->ttl > cache->mfc_un.res.ttls[ct]) { 13861da177e4SLinus Torvalds if (psend != -1) { 13871da177e4SLinus Torvalds struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC); 13881da177e4SLinus Torvalds if (skb2) 1389d658f8a0SPatrick McHardy ipmr_queue_xmit(net, skb2, cache, psend); 13901da177e4SLinus Torvalds } 13911da177e4SLinus Torvalds psend = ct; 13921da177e4SLinus Torvalds } 13931da177e4SLinus Torvalds } 13941da177e4SLinus Torvalds if (psend != -1) { 13951da177e4SLinus Torvalds if (local) { 13961da177e4SLinus Torvalds struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC); 13971da177e4SLinus Torvalds if (skb2) 1398d658f8a0SPatrick McHardy ipmr_queue_xmit(net, skb2, cache, psend); 13991da177e4SLinus Torvalds } else { 1400d658f8a0SPatrick McHardy ipmr_queue_xmit(net, skb, cache, psend); 14011da177e4SLinus Torvalds return 0; 14021da177e4SLinus Torvalds } 14031da177e4SLinus Torvalds } 14041da177e4SLinus Torvalds 14051da177e4SLinus Torvalds dont_forward: 14061da177e4SLinus Torvalds if (!local) 14071da177e4SLinus Torvalds kfree_skb(skb); 14081da177e4SLinus Torvalds return 0; 14091da177e4SLinus Torvalds } 14101da177e4SLinus Torvalds 14111da177e4SLinus Torvalds 14121da177e4SLinus Torvalds /* 14131da177e4SLinus Torvalds * Multicast packets for forwarding arrive here 14141da177e4SLinus Torvalds */ 14151da177e4SLinus Torvalds 14161da177e4SLinus Torvalds int ip_mr_input(struct sk_buff *skb) 14171da177e4SLinus Torvalds { 14181da177e4SLinus Torvalds struct mfc_cache *cache; 14194feb88e5SBenjamin Thery struct net *net = dev_net(skb->dev); 1420511c3f92SEric Dumazet int local = skb_rtable(skb)->rt_flags & RTCF_LOCAL; 14211da177e4SLinus Torvalds 14221da177e4SLinus Torvalds /* Packet is looped back after forward, it should not be 14231da177e4SLinus Torvalds forwarded second time, but still can be delivered locally. 14241da177e4SLinus Torvalds */ 14251da177e4SLinus Torvalds if (IPCB(skb)->flags&IPSKB_FORWARDED) 14261da177e4SLinus Torvalds goto dont_forward; 14271da177e4SLinus Torvalds 14281da177e4SLinus Torvalds if (!local) { 14291da177e4SLinus Torvalds if (IPCB(skb)->opt.router_alert) { 14301da177e4SLinus Torvalds if (ip_call_ra_chain(skb)) 14311da177e4SLinus Torvalds return 0; 1432eddc9ec5SArnaldo Carvalho de Melo } else if (ip_hdr(skb)->protocol == IPPROTO_IGMP){ 14331da177e4SLinus Torvalds /* IGMPv1 (and broken IGMPv2 implementations sort of 14341da177e4SLinus Torvalds Cisco IOS <= 11.2(8)) do not put router alert 14351da177e4SLinus Torvalds option to IGMP packets destined to routable 14361da177e4SLinus Torvalds groups. It is very bad, because it means 14371da177e4SLinus Torvalds that we can forward NO IGMP messages. 14381da177e4SLinus Torvalds */ 14391da177e4SLinus Torvalds read_lock(&mrt_lock); 14404feb88e5SBenjamin Thery if (net->ipv4.mroute_sk) { 14412715bcf9SPatrick McHardy nf_reset(skb); 14424feb88e5SBenjamin Thery raw_rcv(net->ipv4.mroute_sk, skb); 14431da177e4SLinus Torvalds read_unlock(&mrt_lock); 14441da177e4SLinus Torvalds return 0; 14451da177e4SLinus Torvalds } 14461da177e4SLinus Torvalds read_unlock(&mrt_lock); 14471da177e4SLinus Torvalds } 14481da177e4SLinus Torvalds } 14491da177e4SLinus Torvalds 14501da177e4SLinus Torvalds read_lock(&mrt_lock); 14514feb88e5SBenjamin Thery cache = ipmr_cache_find(net, ip_hdr(skb)->saddr, ip_hdr(skb)->daddr); 14521da177e4SLinus Torvalds 14531da177e4SLinus Torvalds /* 14541da177e4SLinus Torvalds * No usable cache entry 14551da177e4SLinus Torvalds */ 14561da177e4SLinus Torvalds if (cache == NULL) { 14571da177e4SLinus Torvalds int vif; 14581da177e4SLinus Torvalds 14591da177e4SLinus Torvalds if (local) { 14601da177e4SLinus Torvalds struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC); 14611da177e4SLinus Torvalds ip_local_deliver(skb); 14621da177e4SLinus Torvalds if (skb2 == NULL) { 14631da177e4SLinus Torvalds read_unlock(&mrt_lock); 14641da177e4SLinus Torvalds return -ENOBUFS; 14651da177e4SLinus Torvalds } 14661da177e4SLinus Torvalds skb = skb2; 14671da177e4SLinus Torvalds } 14681da177e4SLinus Torvalds 14691da177e4SLinus Torvalds vif = ipmr_find_vif(skb->dev); 14701da177e4SLinus Torvalds if (vif >= 0) { 14714feb88e5SBenjamin Thery int err = ipmr_cache_unresolved(net, vif, skb); 14721da177e4SLinus Torvalds read_unlock(&mrt_lock); 14731da177e4SLinus Torvalds 14741da177e4SLinus Torvalds return err; 14751da177e4SLinus Torvalds } 14761da177e4SLinus Torvalds read_unlock(&mrt_lock); 14771da177e4SLinus Torvalds kfree_skb(skb); 14781da177e4SLinus Torvalds return -ENODEV; 14791da177e4SLinus Torvalds } 14801da177e4SLinus Torvalds 1481d658f8a0SPatrick McHardy ip_mr_forward(net, skb, cache, local); 14821da177e4SLinus Torvalds 14831da177e4SLinus Torvalds read_unlock(&mrt_lock); 14841da177e4SLinus Torvalds 14851da177e4SLinus Torvalds if (local) 14861da177e4SLinus Torvalds return ip_local_deliver(skb); 14871da177e4SLinus Torvalds 14881da177e4SLinus Torvalds return 0; 14891da177e4SLinus Torvalds 14901da177e4SLinus Torvalds dont_forward: 14911da177e4SLinus Torvalds if (local) 14921da177e4SLinus Torvalds return ip_local_deliver(skb); 14931da177e4SLinus Torvalds kfree_skb(skb); 14941da177e4SLinus Torvalds return 0; 14951da177e4SLinus Torvalds } 14961da177e4SLinus Torvalds 1497b1879204SIlpo Järvinen #ifdef CONFIG_IP_PIMSM 1498b1879204SIlpo Järvinen static int __pim_rcv(struct sk_buff *skb, unsigned int pimlen) 14991da177e4SLinus Torvalds { 15001da177e4SLinus Torvalds struct net_device *reg_dev = NULL; 1501b1879204SIlpo Järvinen struct iphdr *encap; 15024feb88e5SBenjamin Thery struct net *net = dev_net(skb->dev); 15031da177e4SLinus Torvalds 1504b1879204SIlpo Järvinen encap = (struct iphdr *)(skb_transport_header(skb) + pimlen); 15051da177e4SLinus Torvalds /* 15061da177e4SLinus Torvalds Check that: 15071da177e4SLinus Torvalds a. packet is really destinted to a multicast group 15081da177e4SLinus Torvalds b. packet is not a NULL-REGISTER 15091da177e4SLinus Torvalds c. packet is not truncated 15101da177e4SLinus Torvalds */ 1511f97c1e0cSJoe Perches if (!ipv4_is_multicast(encap->daddr) || 15121da177e4SLinus Torvalds encap->tot_len == 0 || 1513b1879204SIlpo Järvinen ntohs(encap->tot_len) + pimlen > skb->len) 1514b1879204SIlpo Järvinen return 1; 15151da177e4SLinus Torvalds 15161da177e4SLinus Torvalds read_lock(&mrt_lock); 15174feb88e5SBenjamin Thery if (net->ipv4.mroute_reg_vif_num >= 0) 15184feb88e5SBenjamin Thery reg_dev = net->ipv4.vif_table[net->ipv4.mroute_reg_vif_num].dev; 15191da177e4SLinus Torvalds if (reg_dev) 15201da177e4SLinus Torvalds dev_hold(reg_dev); 15211da177e4SLinus Torvalds read_unlock(&mrt_lock); 15221da177e4SLinus Torvalds 15231da177e4SLinus Torvalds if (reg_dev == NULL) 1524b1879204SIlpo Järvinen return 1; 15251da177e4SLinus Torvalds 1526b0e380b1SArnaldo Carvalho de Melo skb->mac_header = skb->network_header; 15271da177e4SLinus Torvalds skb_pull(skb, (u8*)encap - skb->data); 152831c7711bSArnaldo Carvalho de Melo skb_reset_network_header(skb); 15291da177e4SLinus Torvalds skb->dev = reg_dev; 15301da177e4SLinus Torvalds skb->protocol = htons(ETH_P_IP); 15311da177e4SLinus Torvalds skb->ip_summed = 0; 15321da177e4SLinus Torvalds skb->pkt_type = PACKET_HOST; 1533adf30907SEric Dumazet skb_dst_drop(skb); 1534cf3677aeSPavel Emelyanov reg_dev->stats.rx_bytes += skb->len; 1535cf3677aeSPavel Emelyanov reg_dev->stats.rx_packets++; 15361da177e4SLinus Torvalds nf_reset(skb); 15371da177e4SLinus Torvalds netif_rx(skb); 15381da177e4SLinus Torvalds dev_put(reg_dev); 1539b1879204SIlpo Järvinen 15401da177e4SLinus Torvalds return 0; 1541b1879204SIlpo Järvinen } 1542b1879204SIlpo Järvinen #endif 1543b1879204SIlpo Järvinen 1544b1879204SIlpo Järvinen #ifdef CONFIG_IP_PIMSM_V1 1545b1879204SIlpo Järvinen /* 1546b1879204SIlpo Järvinen * Handle IGMP messages of PIMv1 1547b1879204SIlpo Järvinen */ 1548b1879204SIlpo Järvinen 1549b1879204SIlpo Järvinen int pim_rcv_v1(struct sk_buff * skb) 1550b1879204SIlpo Järvinen { 1551b1879204SIlpo Järvinen struct igmphdr *pim; 15524feb88e5SBenjamin Thery struct net *net = dev_net(skb->dev); 1553b1879204SIlpo Järvinen 1554b1879204SIlpo Järvinen if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(struct iphdr))) 1555b1879204SIlpo Järvinen goto drop; 1556b1879204SIlpo Järvinen 1557b1879204SIlpo Järvinen pim = igmp_hdr(skb); 1558b1879204SIlpo Järvinen 15594feb88e5SBenjamin Thery if (!net->ipv4.mroute_do_pim || 1560b1879204SIlpo Järvinen pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER) 1561b1879204SIlpo Järvinen goto drop; 1562b1879204SIlpo Järvinen 1563b1879204SIlpo Järvinen if (__pim_rcv(skb, sizeof(*pim))) { 15641da177e4SLinus Torvalds drop: 15651da177e4SLinus Torvalds kfree_skb(skb); 1566b1879204SIlpo Järvinen } 15671da177e4SLinus Torvalds return 0; 15681da177e4SLinus Torvalds } 15691da177e4SLinus Torvalds #endif 15701da177e4SLinus Torvalds 15711da177e4SLinus Torvalds #ifdef CONFIG_IP_PIMSM_V2 15721da177e4SLinus Torvalds static int pim_rcv(struct sk_buff * skb) 15731da177e4SLinus Torvalds { 15741da177e4SLinus Torvalds struct pimreghdr *pim; 15751da177e4SLinus Torvalds 1576b1879204SIlpo Järvinen if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(struct iphdr))) 15771da177e4SLinus Torvalds goto drop; 15781da177e4SLinus Torvalds 15799c70220bSArnaldo Carvalho de Melo pim = (struct pimreghdr *)skb_transport_header(skb); 15801da177e4SLinus Torvalds if (pim->type != ((PIM_VERSION<<4)|(PIM_REGISTER)) || 15811da177e4SLinus Torvalds (pim->flags&PIM_NULL_REGISTER) || 15821da177e4SLinus Torvalds (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 && 1583d3bc23e7SAl Viro csum_fold(skb_checksum(skb, 0, skb->len, 0)))) 15841da177e4SLinus Torvalds goto drop; 15851da177e4SLinus Torvalds 1586b1879204SIlpo Järvinen if (__pim_rcv(skb, sizeof(*pim))) { 15871da177e4SLinus Torvalds drop: 15881da177e4SLinus Torvalds kfree_skb(skb); 1589b1879204SIlpo Järvinen } 15901da177e4SLinus Torvalds return 0; 15911da177e4SLinus Torvalds } 15921da177e4SLinus Torvalds #endif 15931da177e4SLinus Torvalds 15941da177e4SLinus Torvalds static int 1595d658f8a0SPatrick McHardy ipmr_fill_mroute(struct net *net, struct sk_buff *skb, struct mfc_cache *c, 1596d658f8a0SPatrick McHardy struct rtmsg *rtm) 15971da177e4SLinus Torvalds { 15981da177e4SLinus Torvalds int ct; 15991da177e4SLinus Torvalds struct rtnexthop *nhp; 160027a884dcSArnaldo Carvalho de Melo u8 *b = skb_tail_pointer(skb); 16011da177e4SLinus Torvalds struct rtattr *mp_head; 16021da177e4SLinus Torvalds 16037438189bSNicolas Dichtel /* If cache is unresolved, don't try to parse IIF and OIF */ 16047438189bSNicolas Dichtel if (c->mfc_parent > MAXVIFS) 16057438189bSNicolas Dichtel return -ENOENT; 16067438189bSNicolas Dichtel 16077438189bSNicolas Dichtel if (VIF_EXISTS(net, c->mfc_parent)) 16087438189bSNicolas Dichtel RTA_PUT(skb, RTA_IIF, 4, &net->ipv4.vif_table[c->mfc_parent].dev->ifindex); 16091da177e4SLinus Torvalds 16101da177e4SLinus Torvalds mp_head = (struct rtattr *)skb_put(skb, RTA_LENGTH(0)); 16111da177e4SLinus Torvalds 16121da177e4SLinus Torvalds for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) { 16137438189bSNicolas Dichtel if (VIF_EXISTS(net, ct) && c->mfc_un.res.ttls[ct] < 255) { 16141da177e4SLinus Torvalds if (skb_tailroom(skb) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp)) + 4)) 16151da177e4SLinus Torvalds goto rtattr_failure; 16161da177e4SLinus Torvalds nhp = (struct rtnexthop *)skb_put(skb, RTA_ALIGN(sizeof(*nhp))); 16171da177e4SLinus Torvalds nhp->rtnh_flags = 0; 16181da177e4SLinus Torvalds nhp->rtnh_hops = c->mfc_un.res.ttls[ct]; 16194feb88e5SBenjamin Thery nhp->rtnh_ifindex = net->ipv4.vif_table[ct].dev->ifindex; 16201da177e4SLinus Torvalds nhp->rtnh_len = sizeof(*nhp); 16211da177e4SLinus Torvalds } 16221da177e4SLinus Torvalds } 16231da177e4SLinus Torvalds mp_head->rta_type = RTA_MULTIPATH; 162427a884dcSArnaldo Carvalho de Melo mp_head->rta_len = skb_tail_pointer(skb) - (u8 *)mp_head; 16251da177e4SLinus Torvalds rtm->rtm_type = RTN_MULTICAST; 16261da177e4SLinus Torvalds return 1; 16271da177e4SLinus Torvalds 16281da177e4SLinus Torvalds rtattr_failure: 1629dc5fc579SArnaldo Carvalho de Melo nlmsg_trim(skb, b); 16301da177e4SLinus Torvalds return -EMSGSIZE; 16311da177e4SLinus Torvalds } 16321da177e4SLinus Torvalds 16334feb88e5SBenjamin Thery int ipmr_get_route(struct net *net, 16344feb88e5SBenjamin Thery struct sk_buff *skb, struct rtmsg *rtm, int nowait) 16351da177e4SLinus Torvalds { 16361da177e4SLinus Torvalds int err; 16371da177e4SLinus Torvalds struct mfc_cache *cache; 1638511c3f92SEric Dumazet struct rtable *rt = skb_rtable(skb); 16391da177e4SLinus Torvalds 16401da177e4SLinus Torvalds read_lock(&mrt_lock); 16414feb88e5SBenjamin Thery cache = ipmr_cache_find(net, rt->rt_src, rt->rt_dst); 16421da177e4SLinus Torvalds 16431da177e4SLinus Torvalds if (cache == NULL) { 164472287490SAlexey Kuznetsov struct sk_buff *skb2; 1645eddc9ec5SArnaldo Carvalho de Melo struct iphdr *iph; 16461da177e4SLinus Torvalds struct net_device *dev; 16471da177e4SLinus Torvalds int vif; 16481da177e4SLinus Torvalds 16491da177e4SLinus Torvalds if (nowait) { 16501da177e4SLinus Torvalds read_unlock(&mrt_lock); 16511da177e4SLinus Torvalds return -EAGAIN; 16521da177e4SLinus Torvalds } 16531da177e4SLinus Torvalds 16541da177e4SLinus Torvalds dev = skb->dev; 16551da177e4SLinus Torvalds if (dev == NULL || (vif = ipmr_find_vif(dev)) < 0) { 16561da177e4SLinus Torvalds read_unlock(&mrt_lock); 16571da177e4SLinus Torvalds return -ENODEV; 16581da177e4SLinus Torvalds } 165972287490SAlexey Kuznetsov skb2 = skb_clone(skb, GFP_ATOMIC); 166072287490SAlexey Kuznetsov if (!skb2) { 166172287490SAlexey Kuznetsov read_unlock(&mrt_lock); 166272287490SAlexey Kuznetsov return -ENOMEM; 166372287490SAlexey Kuznetsov } 166472287490SAlexey Kuznetsov 1665e2d1bca7SArnaldo Carvalho de Melo skb_push(skb2, sizeof(struct iphdr)); 1666e2d1bca7SArnaldo Carvalho de Melo skb_reset_network_header(skb2); 1667eddc9ec5SArnaldo Carvalho de Melo iph = ip_hdr(skb2); 1668eddc9ec5SArnaldo Carvalho de Melo iph->ihl = sizeof(struct iphdr) >> 2; 1669eddc9ec5SArnaldo Carvalho de Melo iph->saddr = rt->rt_src; 1670eddc9ec5SArnaldo Carvalho de Melo iph->daddr = rt->rt_dst; 1671eddc9ec5SArnaldo Carvalho de Melo iph->version = 0; 16724feb88e5SBenjamin Thery err = ipmr_cache_unresolved(net, vif, skb2); 16731da177e4SLinus Torvalds read_unlock(&mrt_lock); 16741da177e4SLinus Torvalds return err; 16751da177e4SLinus Torvalds } 16761da177e4SLinus Torvalds 16771da177e4SLinus Torvalds if (!nowait && (rtm->rtm_flags&RTM_F_NOTIFY)) 16781da177e4SLinus Torvalds cache->mfc_flags |= MFC_NOTIFY; 1679d658f8a0SPatrick McHardy err = ipmr_fill_mroute(net, skb, cache, rtm); 16801da177e4SLinus Torvalds read_unlock(&mrt_lock); 16811da177e4SLinus Torvalds return err; 16821da177e4SLinus Torvalds } 16831da177e4SLinus Torvalds 16841da177e4SLinus Torvalds #ifdef CONFIG_PROC_FS 16851da177e4SLinus Torvalds /* 16861da177e4SLinus Torvalds * The /proc interfaces to multicast routing /proc/ip_mr_cache /proc/ip_mr_vif 16871da177e4SLinus Torvalds */ 16881da177e4SLinus Torvalds struct ipmr_vif_iter { 1689f6bb4514SBenjamin Thery struct seq_net_private p; 16901da177e4SLinus Torvalds int ct; 16911da177e4SLinus Torvalds }; 16921da177e4SLinus Torvalds 1693f6bb4514SBenjamin Thery static struct vif_device *ipmr_vif_seq_idx(struct net *net, 1694f6bb4514SBenjamin Thery struct ipmr_vif_iter *iter, 16951da177e4SLinus Torvalds loff_t pos) 16961da177e4SLinus Torvalds { 1697f6bb4514SBenjamin Thery for (iter->ct = 0; iter->ct < net->ipv4.maxvif; ++iter->ct) { 1698f6bb4514SBenjamin Thery if (!VIF_EXISTS(net, iter->ct)) 16991da177e4SLinus Torvalds continue; 17001da177e4SLinus Torvalds if (pos-- == 0) 1701f6bb4514SBenjamin Thery return &net->ipv4.vif_table[iter->ct]; 17021da177e4SLinus Torvalds } 17031da177e4SLinus Torvalds return NULL; 17041da177e4SLinus Torvalds } 17051da177e4SLinus Torvalds 17061da177e4SLinus Torvalds static void *ipmr_vif_seq_start(struct seq_file *seq, loff_t *pos) 1707ba93ef74SStephen Hemminger __acquires(mrt_lock) 17081da177e4SLinus Torvalds { 1709f6bb4514SBenjamin Thery struct net *net = seq_file_net(seq); 1710f6bb4514SBenjamin Thery 17111da177e4SLinus Torvalds read_lock(&mrt_lock); 1712f6bb4514SBenjamin Thery return *pos ? ipmr_vif_seq_idx(net, seq->private, *pos - 1) 17131da177e4SLinus Torvalds : SEQ_START_TOKEN; 17141da177e4SLinus Torvalds } 17151da177e4SLinus Torvalds 17161da177e4SLinus Torvalds static void *ipmr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos) 17171da177e4SLinus Torvalds { 17181da177e4SLinus Torvalds struct ipmr_vif_iter *iter = seq->private; 1719f6bb4514SBenjamin Thery struct net *net = seq_file_net(seq); 17201da177e4SLinus Torvalds 17211da177e4SLinus Torvalds ++*pos; 17221da177e4SLinus Torvalds if (v == SEQ_START_TOKEN) 1723f6bb4514SBenjamin Thery return ipmr_vif_seq_idx(net, iter, 0); 17241da177e4SLinus Torvalds 1725f6bb4514SBenjamin Thery while (++iter->ct < net->ipv4.maxvif) { 1726f6bb4514SBenjamin Thery if (!VIF_EXISTS(net, iter->ct)) 17271da177e4SLinus Torvalds continue; 1728f6bb4514SBenjamin Thery return &net->ipv4.vif_table[iter->ct]; 17291da177e4SLinus Torvalds } 17301da177e4SLinus Torvalds return NULL; 17311da177e4SLinus Torvalds } 17321da177e4SLinus Torvalds 17331da177e4SLinus Torvalds static void ipmr_vif_seq_stop(struct seq_file *seq, void *v) 1734ba93ef74SStephen Hemminger __releases(mrt_lock) 17351da177e4SLinus Torvalds { 17361da177e4SLinus Torvalds read_unlock(&mrt_lock); 17371da177e4SLinus Torvalds } 17381da177e4SLinus Torvalds 17391da177e4SLinus Torvalds static int ipmr_vif_seq_show(struct seq_file *seq, void *v) 17401da177e4SLinus Torvalds { 1741f6bb4514SBenjamin Thery struct net *net = seq_file_net(seq); 1742f6bb4514SBenjamin Thery 17431da177e4SLinus Torvalds if (v == SEQ_START_TOKEN) { 17441da177e4SLinus Torvalds seq_puts(seq, 17451da177e4SLinus Torvalds "Interface BytesIn PktsIn BytesOut PktsOut Flags Local Remote\n"); 17461da177e4SLinus Torvalds } else { 17471da177e4SLinus Torvalds const struct vif_device *vif = v; 17481da177e4SLinus Torvalds const char *name = vif->dev ? vif->dev->name : "none"; 17491da177e4SLinus Torvalds 17501da177e4SLinus Torvalds seq_printf(seq, 17511da177e4SLinus Torvalds "%2Zd %-10s %8ld %7ld %8ld %7ld %05X %08X %08X\n", 1752f6bb4514SBenjamin Thery vif - net->ipv4.vif_table, 17531da177e4SLinus Torvalds name, vif->bytes_in, vif->pkt_in, 17541da177e4SLinus Torvalds vif->bytes_out, vif->pkt_out, 17551da177e4SLinus Torvalds vif->flags, vif->local, vif->remote); 17561da177e4SLinus Torvalds } 17571da177e4SLinus Torvalds return 0; 17581da177e4SLinus Torvalds } 17591da177e4SLinus Torvalds 1760f690808eSStephen Hemminger static const struct seq_operations ipmr_vif_seq_ops = { 17611da177e4SLinus Torvalds .start = ipmr_vif_seq_start, 17621da177e4SLinus Torvalds .next = ipmr_vif_seq_next, 17631da177e4SLinus Torvalds .stop = ipmr_vif_seq_stop, 17641da177e4SLinus Torvalds .show = ipmr_vif_seq_show, 17651da177e4SLinus Torvalds }; 17661da177e4SLinus Torvalds 17671da177e4SLinus Torvalds static int ipmr_vif_open(struct inode *inode, struct file *file) 17681da177e4SLinus Torvalds { 1769f6bb4514SBenjamin Thery return seq_open_net(inode, file, &ipmr_vif_seq_ops, 1770cf7732e4SPavel Emelyanov sizeof(struct ipmr_vif_iter)); 17711da177e4SLinus Torvalds } 17721da177e4SLinus Torvalds 17739a32144eSArjan van de Ven static const struct file_operations ipmr_vif_fops = { 17741da177e4SLinus Torvalds .owner = THIS_MODULE, 17751da177e4SLinus Torvalds .open = ipmr_vif_open, 17761da177e4SLinus Torvalds .read = seq_read, 17771da177e4SLinus Torvalds .llseek = seq_lseek, 1778f6bb4514SBenjamin Thery .release = seq_release_net, 17791da177e4SLinus Torvalds }; 17801da177e4SLinus Torvalds 17811da177e4SLinus Torvalds struct ipmr_mfc_iter { 1782f6bb4514SBenjamin Thery struct seq_net_private p; 1783*862465f2SPatrick McHardy struct list_head *cache; 17841da177e4SLinus Torvalds int ct; 17851da177e4SLinus Torvalds }; 17861da177e4SLinus Torvalds 17871da177e4SLinus Torvalds 1788f6bb4514SBenjamin Thery static struct mfc_cache *ipmr_mfc_seq_idx(struct net *net, 1789f6bb4514SBenjamin Thery struct ipmr_mfc_iter *it, loff_t pos) 17901da177e4SLinus Torvalds { 17911da177e4SLinus Torvalds struct mfc_cache *mfc; 17921da177e4SLinus Torvalds 17931da177e4SLinus Torvalds read_lock(&mrt_lock); 1794*862465f2SPatrick McHardy for (it->ct = 0; it->ct < MFC_LINES; it->ct++) { 1795*862465f2SPatrick McHardy it->cache = &net->ipv4.mfc_cache_array[it->ct]; 1796*862465f2SPatrick McHardy list_for_each_entry(mfc, it->cache, list) 17971da177e4SLinus Torvalds if (pos-- == 0) 17981da177e4SLinus Torvalds return mfc; 1799*862465f2SPatrick McHardy } 18001da177e4SLinus Torvalds read_unlock(&mrt_lock); 18011da177e4SLinus Torvalds 18021da177e4SLinus Torvalds spin_lock_bh(&mfc_unres_lock); 1803*862465f2SPatrick McHardy it->cache = &net->ipv4.mfc_unres_queue; 1804*862465f2SPatrick McHardy list_for_each_entry(mfc, it->cache, list) 1805e258beb2SPatrick McHardy if (pos-- == 0) 18061da177e4SLinus Torvalds return mfc; 18071da177e4SLinus Torvalds spin_unlock_bh(&mfc_unres_lock); 18081da177e4SLinus Torvalds 18091da177e4SLinus Torvalds it->cache = NULL; 18101da177e4SLinus Torvalds return NULL; 18111da177e4SLinus Torvalds } 18121da177e4SLinus Torvalds 18131da177e4SLinus Torvalds 18141da177e4SLinus Torvalds static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos) 18151da177e4SLinus Torvalds { 18161da177e4SLinus Torvalds struct ipmr_mfc_iter *it = seq->private; 1817f6bb4514SBenjamin Thery struct net *net = seq_file_net(seq); 1818f6bb4514SBenjamin Thery 18191da177e4SLinus Torvalds it->cache = NULL; 18201da177e4SLinus Torvalds it->ct = 0; 1821f6bb4514SBenjamin Thery return *pos ? ipmr_mfc_seq_idx(net, seq->private, *pos - 1) 18221da177e4SLinus Torvalds : SEQ_START_TOKEN; 18231da177e4SLinus Torvalds } 18241da177e4SLinus Torvalds 18251da177e4SLinus Torvalds static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos) 18261da177e4SLinus Torvalds { 18271da177e4SLinus Torvalds struct mfc_cache *mfc = v; 18281da177e4SLinus Torvalds struct ipmr_mfc_iter *it = seq->private; 1829f6bb4514SBenjamin Thery struct net *net = seq_file_net(seq); 18301da177e4SLinus Torvalds 18311da177e4SLinus Torvalds ++*pos; 18321da177e4SLinus Torvalds 18331da177e4SLinus Torvalds if (v == SEQ_START_TOKEN) 1834f6bb4514SBenjamin Thery return ipmr_mfc_seq_idx(net, seq->private, 0); 18351da177e4SLinus Torvalds 1836*862465f2SPatrick McHardy if (mfc->list.next != it->cache) 1837*862465f2SPatrick McHardy return list_entry(mfc->list.next, struct mfc_cache, list); 18381da177e4SLinus Torvalds 1839e258beb2SPatrick McHardy if (it->cache == &net->ipv4.mfc_unres_queue) 18401da177e4SLinus Torvalds goto end_of_list; 18411da177e4SLinus Torvalds 1842*862465f2SPatrick McHardy BUG_ON(it->cache != &net->ipv4.mfc_cache_array[it->ct]); 18431da177e4SLinus Torvalds 18441da177e4SLinus Torvalds while (++it->ct < MFC_LINES) { 1845*862465f2SPatrick McHardy it->cache = &net->ipv4.mfc_cache_array[it->ct]; 1846*862465f2SPatrick McHardy if (list_empty(it->cache)) 1847*862465f2SPatrick McHardy continue; 1848*862465f2SPatrick McHardy return list_first_entry(it->cache, struct mfc_cache, list); 18491da177e4SLinus Torvalds } 18501da177e4SLinus Torvalds 18511da177e4SLinus Torvalds /* exhausted cache_array, show unresolved */ 18521da177e4SLinus Torvalds read_unlock(&mrt_lock); 1853e258beb2SPatrick McHardy it->cache = &net->ipv4.mfc_unres_queue; 18541da177e4SLinus Torvalds it->ct = 0; 18551da177e4SLinus Torvalds 18561da177e4SLinus Torvalds spin_lock_bh(&mfc_unres_lock); 1857*862465f2SPatrick McHardy if (!list_empty(it->cache)) 1858*862465f2SPatrick McHardy return list_first_entry(it->cache, struct mfc_cache, list); 18591da177e4SLinus Torvalds 18601da177e4SLinus Torvalds end_of_list: 18611da177e4SLinus Torvalds spin_unlock_bh(&mfc_unres_lock); 18621da177e4SLinus Torvalds it->cache = NULL; 18631da177e4SLinus Torvalds 18641da177e4SLinus Torvalds return NULL; 18651da177e4SLinus Torvalds } 18661da177e4SLinus Torvalds 18671da177e4SLinus Torvalds static void ipmr_mfc_seq_stop(struct seq_file *seq, void *v) 18681da177e4SLinus Torvalds { 18691da177e4SLinus Torvalds struct ipmr_mfc_iter *it = seq->private; 1870f6bb4514SBenjamin Thery struct net *net = seq_file_net(seq); 18711da177e4SLinus Torvalds 1872e258beb2SPatrick McHardy if (it->cache == &net->ipv4.mfc_unres_queue) 18731da177e4SLinus Torvalds spin_unlock_bh(&mfc_unres_lock); 1874*862465f2SPatrick McHardy else if (it->cache == &net->ipv4.mfc_cache_array[it->ct]) 18751da177e4SLinus Torvalds read_unlock(&mrt_lock); 18761da177e4SLinus Torvalds } 18771da177e4SLinus Torvalds 18781da177e4SLinus Torvalds static int ipmr_mfc_seq_show(struct seq_file *seq, void *v) 18791da177e4SLinus Torvalds { 18801da177e4SLinus Torvalds int n; 1881f6bb4514SBenjamin Thery struct net *net = seq_file_net(seq); 18821da177e4SLinus Torvalds 18831da177e4SLinus Torvalds if (v == SEQ_START_TOKEN) { 18841da177e4SLinus Torvalds seq_puts(seq, 18851da177e4SLinus Torvalds "Group Origin Iif Pkts Bytes Wrong Oifs\n"); 18861da177e4SLinus Torvalds } else { 18871da177e4SLinus Torvalds const struct mfc_cache *mfc = v; 18881da177e4SLinus Torvalds const struct ipmr_mfc_iter *it = seq->private; 18891da177e4SLinus Torvalds 1890999890b2SBenjamin Thery seq_printf(seq, "%08lX %08lX %-3hd", 18911da177e4SLinus Torvalds (unsigned long) mfc->mfc_mcastgrp, 18921da177e4SLinus Torvalds (unsigned long) mfc->mfc_origin, 18931ea472e2SBenjamin Thery mfc->mfc_parent); 18941ea472e2SBenjamin Thery 1895e258beb2SPatrick McHardy if (it->cache != &net->ipv4.mfc_unres_queue) { 18961ea472e2SBenjamin Thery seq_printf(seq, " %8lu %8lu %8lu", 18971da177e4SLinus Torvalds mfc->mfc_un.res.pkt, 18981da177e4SLinus Torvalds mfc->mfc_un.res.bytes, 18991da177e4SLinus Torvalds mfc->mfc_un.res.wrong_if); 19001da177e4SLinus Torvalds for (n = mfc->mfc_un.res.minvif; 19011da177e4SLinus Torvalds n < mfc->mfc_un.res.maxvif; n++ ) { 1902f6bb4514SBenjamin Thery if (VIF_EXISTS(net, n) && 1903cf958ae3SBenjamin Thery mfc->mfc_un.res.ttls[n] < 255) 19041da177e4SLinus Torvalds seq_printf(seq, 19051da177e4SLinus Torvalds " %2d:%-3d", 19061da177e4SLinus Torvalds n, mfc->mfc_un.res.ttls[n]); 19071da177e4SLinus Torvalds } 19081ea472e2SBenjamin Thery } else { 19091ea472e2SBenjamin Thery /* unresolved mfc_caches don't contain 19101ea472e2SBenjamin Thery * pkt, bytes and wrong_if values 19111ea472e2SBenjamin Thery */ 19121ea472e2SBenjamin Thery seq_printf(seq, " %8lu %8lu %8lu", 0ul, 0ul, 0ul); 19131da177e4SLinus Torvalds } 19141da177e4SLinus Torvalds seq_putc(seq, '\n'); 19151da177e4SLinus Torvalds } 19161da177e4SLinus Torvalds return 0; 19171da177e4SLinus Torvalds } 19181da177e4SLinus Torvalds 1919f690808eSStephen Hemminger static const struct seq_operations ipmr_mfc_seq_ops = { 19201da177e4SLinus Torvalds .start = ipmr_mfc_seq_start, 19211da177e4SLinus Torvalds .next = ipmr_mfc_seq_next, 19221da177e4SLinus Torvalds .stop = ipmr_mfc_seq_stop, 19231da177e4SLinus Torvalds .show = ipmr_mfc_seq_show, 19241da177e4SLinus Torvalds }; 19251da177e4SLinus Torvalds 19261da177e4SLinus Torvalds static int ipmr_mfc_open(struct inode *inode, struct file *file) 19271da177e4SLinus Torvalds { 1928f6bb4514SBenjamin Thery return seq_open_net(inode, file, &ipmr_mfc_seq_ops, 1929cf7732e4SPavel Emelyanov sizeof(struct ipmr_mfc_iter)); 19301da177e4SLinus Torvalds } 19311da177e4SLinus Torvalds 19329a32144eSArjan van de Ven static const struct file_operations ipmr_mfc_fops = { 19331da177e4SLinus Torvalds .owner = THIS_MODULE, 19341da177e4SLinus Torvalds .open = ipmr_mfc_open, 19351da177e4SLinus Torvalds .read = seq_read, 19361da177e4SLinus Torvalds .llseek = seq_lseek, 1937f6bb4514SBenjamin Thery .release = seq_release_net, 19381da177e4SLinus Torvalds }; 19391da177e4SLinus Torvalds #endif 19401da177e4SLinus Torvalds 19411da177e4SLinus Torvalds #ifdef CONFIG_IP_PIMSM_V2 194232613090SAlexey Dobriyan static const struct net_protocol pim_protocol = { 19431da177e4SLinus Torvalds .handler = pim_rcv, 1944403dbb97STom Goff .netns_ok = 1, 19451da177e4SLinus Torvalds }; 19461da177e4SLinus Torvalds #endif 19471da177e4SLinus Torvalds 19481da177e4SLinus Torvalds 19491da177e4SLinus Torvalds /* 19501da177e4SLinus Torvalds * Setup for IP multicast routing 19511da177e4SLinus Torvalds */ 1952cf958ae3SBenjamin Thery static int __net_init ipmr_net_init(struct net *net) 1953cf958ae3SBenjamin Thery { 1954*862465f2SPatrick McHardy unsigned int i; 1955cf958ae3SBenjamin Thery int err = 0; 1956cf958ae3SBenjamin Thery 1957cf958ae3SBenjamin Thery net->ipv4.vif_table = kcalloc(MAXVIFS, sizeof(struct vif_device), 1958cf958ae3SBenjamin Thery GFP_KERNEL); 1959cf958ae3SBenjamin Thery if (!net->ipv4.vif_table) { 1960cf958ae3SBenjamin Thery err = -ENOMEM; 1961cf958ae3SBenjamin Thery goto fail; 1962cf958ae3SBenjamin Thery } 19632bb8b26cSBenjamin Thery 19642bb8b26cSBenjamin Thery /* Forwarding cache */ 19652bb8b26cSBenjamin Thery net->ipv4.mfc_cache_array = kcalloc(MFC_LINES, 1966*862465f2SPatrick McHardy sizeof(struct list_head), 19672bb8b26cSBenjamin Thery GFP_KERNEL); 19682bb8b26cSBenjamin Thery if (!net->ipv4.mfc_cache_array) { 19692bb8b26cSBenjamin Thery err = -ENOMEM; 19702bb8b26cSBenjamin Thery goto fail_mfc_cache; 19712bb8b26cSBenjamin Thery } 19726c5143dbSBenjamin Thery 1973*862465f2SPatrick McHardy for (i = 0; i < MFC_LINES; i++) 1974*862465f2SPatrick McHardy INIT_LIST_HEAD(&net->ipv4.mfc_cache_array[i]); 1975*862465f2SPatrick McHardy 1976*862465f2SPatrick McHardy INIT_LIST_HEAD(&net->ipv4.mfc_unres_queue); 1977*862465f2SPatrick McHardy 1978e258beb2SPatrick McHardy setup_timer(&net->ipv4.ipmr_expire_timer, ipmr_expire_process, 1979e258beb2SPatrick McHardy (unsigned long)net); 1980e258beb2SPatrick McHardy 19816c5143dbSBenjamin Thery #ifdef CONFIG_IP_PIMSM 19826c5143dbSBenjamin Thery net->ipv4.mroute_reg_vif_num = -1; 19836c5143dbSBenjamin Thery #endif 1984f6bb4514SBenjamin Thery 1985f6bb4514SBenjamin Thery #ifdef CONFIG_PROC_FS 1986f6bb4514SBenjamin Thery err = -ENOMEM; 1987f6bb4514SBenjamin Thery if (!proc_net_fops_create(net, "ip_mr_vif", 0, &ipmr_vif_fops)) 1988f6bb4514SBenjamin Thery goto proc_vif_fail; 1989f6bb4514SBenjamin Thery if (!proc_net_fops_create(net, "ip_mr_cache", 0, &ipmr_mfc_fops)) 1990f6bb4514SBenjamin Thery goto proc_cache_fail; 1991f6bb4514SBenjamin Thery #endif 19922bb8b26cSBenjamin Thery return 0; 19932bb8b26cSBenjamin Thery 1994f6bb4514SBenjamin Thery #ifdef CONFIG_PROC_FS 1995f6bb4514SBenjamin Thery proc_cache_fail: 1996f6bb4514SBenjamin Thery proc_net_remove(net, "ip_mr_vif"); 1997f6bb4514SBenjamin Thery proc_vif_fail: 1998f6bb4514SBenjamin Thery kfree(net->ipv4.mfc_cache_array); 1999f6bb4514SBenjamin Thery #endif 20002bb8b26cSBenjamin Thery fail_mfc_cache: 20012bb8b26cSBenjamin Thery kfree(net->ipv4.vif_table); 2002cf958ae3SBenjamin Thery fail: 2003cf958ae3SBenjamin Thery return err; 2004cf958ae3SBenjamin Thery } 2005cf958ae3SBenjamin Thery 2006cf958ae3SBenjamin Thery static void __net_exit ipmr_net_exit(struct net *net) 2007cf958ae3SBenjamin Thery { 2008f6bb4514SBenjamin Thery #ifdef CONFIG_PROC_FS 2009f6bb4514SBenjamin Thery proc_net_remove(net, "ip_mr_cache"); 2010f6bb4514SBenjamin Thery proc_net_remove(net, "ip_mr_vif"); 2011f6bb4514SBenjamin Thery #endif 20122bb8b26cSBenjamin Thery kfree(net->ipv4.mfc_cache_array); 2013cf958ae3SBenjamin Thery kfree(net->ipv4.vif_table); 2014cf958ae3SBenjamin Thery } 2015cf958ae3SBenjamin Thery 2016cf958ae3SBenjamin Thery static struct pernet_operations ipmr_net_ops = { 2017cf958ae3SBenjamin Thery .init = ipmr_net_init, 2018cf958ae3SBenjamin Thery .exit = ipmr_net_exit, 2019cf958ae3SBenjamin Thery }; 20201da177e4SLinus Torvalds 202103d2f897SWang Chen int __init ip_mr_init(void) 20221da177e4SLinus Torvalds { 202303d2f897SWang Chen int err; 202403d2f897SWang Chen 20251da177e4SLinus Torvalds mrt_cachep = kmem_cache_create("ip_mrt_cache", 20261da177e4SLinus Torvalds sizeof(struct mfc_cache), 2027e5d679f3SAlexey Dobriyan 0, SLAB_HWCACHE_ALIGN|SLAB_PANIC, 202820c2df83SPaul Mundt NULL); 202903d2f897SWang Chen if (!mrt_cachep) 203003d2f897SWang Chen return -ENOMEM; 203103d2f897SWang Chen 2032cf958ae3SBenjamin Thery err = register_pernet_subsys(&ipmr_net_ops); 2033cf958ae3SBenjamin Thery if (err) 2034cf958ae3SBenjamin Thery goto reg_pernet_fail; 2035cf958ae3SBenjamin Thery 203603d2f897SWang Chen err = register_netdevice_notifier(&ip_mr_notifier); 203703d2f897SWang Chen if (err) 203803d2f897SWang Chen goto reg_notif_fail; 2039403dbb97STom Goff #ifdef CONFIG_IP_PIMSM_V2 2040403dbb97STom Goff if (inet_add_protocol(&pim_protocol, IPPROTO_PIM) < 0) { 2041403dbb97STom Goff printk(KERN_ERR "ip_mr_init: can't add PIM protocol\n"); 2042403dbb97STom Goff err = -EAGAIN; 2043403dbb97STom Goff goto add_proto_fail; 2044403dbb97STom Goff } 2045403dbb97STom Goff #endif 204603d2f897SWang Chen return 0; 2047f6bb4514SBenjamin Thery 2048403dbb97STom Goff #ifdef CONFIG_IP_PIMSM_V2 2049403dbb97STom Goff add_proto_fail: 2050403dbb97STom Goff unregister_netdevice_notifier(&ip_mr_notifier); 2051403dbb97STom Goff #endif 2052c3e38896SBenjamin Thery reg_notif_fail: 2053cf958ae3SBenjamin Thery unregister_pernet_subsys(&ipmr_net_ops); 2054cf958ae3SBenjamin Thery reg_pernet_fail: 2055c3e38896SBenjamin Thery kmem_cache_destroy(mrt_cachep); 205603d2f897SWang Chen return err; 20571da177e4SLinus Torvalds } 2058