11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * Linux NET3: Internet Group Management Protocol [IGMP] 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * This code implements the IGMP protocol as defined in RFC1112. There has 51da177e4SLinus Torvalds * been a further revision of this protocol since which is now supported. 61da177e4SLinus Torvalds * 71da177e4SLinus Torvalds * If you have trouble with this module be careful what gcc you have used, 81da177e4SLinus Torvalds * the older version didn't come out right using gcc 2.5.8, the newer one 91da177e4SLinus Torvalds * seems to fall out with gcc 2.6.2. 101da177e4SLinus Torvalds * 111da177e4SLinus Torvalds * Authors: 12113aa838SAlan Cox * Alan Cox <alan@lxorguk.ukuu.org.uk> 131da177e4SLinus Torvalds * 141da177e4SLinus Torvalds * This program is free software; you can redistribute it and/or 151da177e4SLinus Torvalds * modify it under the terms of the GNU General Public License 161da177e4SLinus Torvalds * as published by the Free Software Foundation; either version 171da177e4SLinus Torvalds * 2 of the License, or (at your option) any later version. 181da177e4SLinus Torvalds * 191da177e4SLinus Torvalds * Fixes: 201da177e4SLinus Torvalds * 211da177e4SLinus Torvalds * Alan Cox : Added lots of __inline__ to optimise 221da177e4SLinus Torvalds * the memory usage of all the tiny little 231da177e4SLinus Torvalds * functions. 241da177e4SLinus Torvalds * Alan Cox : Dumped the header building experiment. 251da177e4SLinus Torvalds * Alan Cox : Minor tweaks ready for multicast routing 261da177e4SLinus Torvalds * and extended IGMP protocol. 271da177e4SLinus Torvalds * Alan Cox : Removed a load of inline directives. Gcc 2.5.8 281da177e4SLinus Torvalds * writes utterly bogus code otherwise (sigh) 291da177e4SLinus Torvalds * fixed IGMP loopback to behave in the manner 301da177e4SLinus Torvalds * desired by mrouted, fixed the fact it has been 311da177e4SLinus Torvalds * broken since 1.3.6 and cleaned up a few minor 321da177e4SLinus Torvalds * points. 331da177e4SLinus Torvalds * 341da177e4SLinus Torvalds * Chih-Jen Chang : Tried to revise IGMP to Version 2 351da177e4SLinus Torvalds * Tsu-Sheng Tsao E-mail: chihjenc@scf.usc.edu and tsusheng@scf.usc.edu 361da177e4SLinus Torvalds * The enhancements are mainly based on Steve Deering's 371da177e4SLinus Torvalds * ipmulti-3.5 source code. 381da177e4SLinus Torvalds * Chih-Jen Chang : Added the igmp_get_mrouter_info and 391da177e4SLinus Torvalds * Tsu-Sheng Tsao igmp_set_mrouter_info to keep track of 401da177e4SLinus Torvalds * the mrouted version on that device. 411da177e4SLinus Torvalds * Chih-Jen Chang : Added the max_resp_time parameter to 421da177e4SLinus Torvalds * Tsu-Sheng Tsao igmp_heard_query(). Using this parameter 431da177e4SLinus Torvalds * to identify the multicast router version 441da177e4SLinus Torvalds * and do what the IGMP version 2 specified. 451da177e4SLinus Torvalds * Chih-Jen Chang : Added a timer to revert to IGMP V2 router 461da177e4SLinus Torvalds * Tsu-Sheng Tsao if the specified time expired. 471da177e4SLinus Torvalds * Alan Cox : Stop IGMP from 0.0.0.0 being accepted. 481da177e4SLinus Torvalds * Alan Cox : Use GFP_ATOMIC in the right places. 491da177e4SLinus Torvalds * Christian Daudt : igmp timer wasn't set for local group 501da177e4SLinus Torvalds * memberships but was being deleted, 511da177e4SLinus Torvalds * which caused a "del_timer() called 521da177e4SLinus Torvalds * from %p with timer not initialized\n" 531da177e4SLinus Torvalds * message (960131). 541da177e4SLinus Torvalds * Christian Daudt : removed del_timer from 551da177e4SLinus Torvalds * igmp_timer_expire function (960205). 561da177e4SLinus Torvalds * Christian Daudt : igmp_heard_report now only calls 571da177e4SLinus Torvalds * igmp_timer_expire if tm->running is 581da177e4SLinus Torvalds * true (960216). 591da177e4SLinus Torvalds * Malcolm Beattie : ttl comparison wrong in igmp_rcv made 601da177e4SLinus Torvalds * igmp_heard_query never trigger. Expiry 611da177e4SLinus Torvalds * miscalculation fixed in igmp_heard_query 621da177e4SLinus Torvalds * and random() made to return unsigned to 631da177e4SLinus Torvalds * prevent negative expiry times. 641da177e4SLinus Torvalds * Alexey Kuznetsov: Wrong group leaving behaviour, backport 651da177e4SLinus Torvalds * fix from pending 2.1.x patches. 661da177e4SLinus Torvalds * Alan Cox: Forget to enable FDDI support earlier. 671da177e4SLinus Torvalds * Alexey Kuznetsov: Fixed leaving groups on device down. 681da177e4SLinus Torvalds * Alexey Kuznetsov: Accordance to igmp-v2-06 draft. 691da177e4SLinus Torvalds * David L Stevens: IGMPv3 support, with help from 701da177e4SLinus Torvalds * Vinay Kulkarni 711da177e4SLinus Torvalds */ 721da177e4SLinus Torvalds 731da177e4SLinus Torvalds #include <linux/module.h> 745a0e3ad6STejun Heo #include <linux/slab.h> 751da177e4SLinus Torvalds #include <asm/uaccess.h> 761da177e4SLinus Torvalds #include <linux/types.h> 771da177e4SLinus Torvalds #include <linux/kernel.h> 781da177e4SLinus Torvalds #include <linux/jiffies.h> 791da177e4SLinus Torvalds #include <linux/string.h> 801da177e4SLinus Torvalds #include <linux/socket.h> 811da177e4SLinus Torvalds #include <linux/sockios.h> 821da177e4SLinus Torvalds #include <linux/in.h> 831da177e4SLinus Torvalds #include <linux/inet.h> 841da177e4SLinus Torvalds #include <linux/netdevice.h> 851da177e4SLinus Torvalds #include <linux/skbuff.h> 861da177e4SLinus Torvalds #include <linux/inetdevice.h> 871da177e4SLinus Torvalds #include <linux/igmp.h> 881da177e4SLinus Torvalds #include <linux/if_arp.h> 891da177e4SLinus Torvalds #include <linux/rtnetlink.h> 901da177e4SLinus Torvalds #include <linux/times.h> 91*9d4a0314SHannes Frederic Sowa #include <linux/pkt_sched.h> 9214c85021SArnaldo Carvalho de Melo 93457c4cbcSEric W. Biederman #include <net/net_namespace.h> 9414c85021SArnaldo Carvalho de Melo #include <net/arp.h> 951da177e4SLinus Torvalds #include <net/ip.h> 961da177e4SLinus Torvalds #include <net/protocol.h> 971da177e4SLinus Torvalds #include <net/route.h> 981da177e4SLinus Torvalds #include <net/sock.h> 991da177e4SLinus Torvalds #include <net/checksum.h> 1001da177e4SLinus Torvalds #include <linux/netfilter_ipv4.h> 1011da177e4SLinus Torvalds #ifdef CONFIG_IP_MROUTE 1021da177e4SLinus Torvalds #include <linux/mroute.h> 1031da177e4SLinus Torvalds #endif 1041da177e4SLinus Torvalds #ifdef CONFIG_PROC_FS 1051da177e4SLinus Torvalds #include <linux/proc_fs.h> 1061da177e4SLinus Torvalds #include <linux/seq_file.h> 1071da177e4SLinus Torvalds #endif 1081da177e4SLinus Torvalds 1091da177e4SLinus Torvalds #define IP_MAX_MEMBERSHIPS 20 1101da177e4SLinus Torvalds #define IP_MAX_MSF 10 1111da177e4SLinus Torvalds 1121da177e4SLinus Torvalds #ifdef CONFIG_IP_MULTICAST 1131da177e4SLinus Torvalds /* Parameter names and values are taken from igmp-v2-06 draft */ 1141da177e4SLinus Torvalds 1151da177e4SLinus Torvalds #define IGMP_V1_Router_Present_Timeout (400*HZ) 1161da177e4SLinus Torvalds #define IGMP_V2_Router_Present_Timeout (400*HZ) 1171da177e4SLinus Torvalds #define IGMP_Unsolicited_Report_Interval (10*HZ) 1181da177e4SLinus Torvalds #define IGMP_Query_Response_Interval (10*HZ) 1191da177e4SLinus Torvalds #define IGMP_Unsolicited_Report_Count 2 1201da177e4SLinus Torvalds 1211da177e4SLinus Torvalds 1221da177e4SLinus Torvalds #define IGMP_Initial_Report_Delay (1) 1231da177e4SLinus Torvalds 1241da177e4SLinus Torvalds /* IGMP_Initial_Report_Delay is not from IGMP specs! 1251da177e4SLinus Torvalds * IGMP specs require to report membership immediately after 1261da177e4SLinus Torvalds * joining a group, but we delay the first report by a 1271da177e4SLinus Torvalds * small interval. It seems more natural and still does not 1281da177e4SLinus Torvalds * contradict to specs provided this delay is small enough. 1291da177e4SLinus Torvalds */ 1301da177e4SLinus Torvalds 13142f811b8SHerbert Xu #define IGMP_V1_SEEN(in_dev) \ 132c346dca1SYOSHIFUJI Hideaki (IPV4_DEVCONF_ALL(dev_net(in_dev->dev), FORCE_IGMP_VERSION) == 1 || \ 13342f811b8SHerbert Xu IN_DEV_CONF_GET((in_dev), FORCE_IGMP_VERSION) == 1 || \ 1341da177e4SLinus Torvalds ((in_dev)->mr_v1_seen && \ 1351da177e4SLinus Torvalds time_before(jiffies, (in_dev)->mr_v1_seen))) 13642f811b8SHerbert Xu #define IGMP_V2_SEEN(in_dev) \ 137c346dca1SYOSHIFUJI Hideaki (IPV4_DEVCONF_ALL(dev_net(in_dev->dev), FORCE_IGMP_VERSION) == 2 || \ 13842f811b8SHerbert Xu IN_DEV_CONF_GET((in_dev), FORCE_IGMP_VERSION) == 2 || \ 1391da177e4SLinus Torvalds ((in_dev)->mr_v2_seen && \ 1401da177e4SLinus Torvalds time_before(jiffies, (in_dev)->mr_v2_seen))) 1411da177e4SLinus Torvalds 1421da177e4SLinus Torvalds static void igmpv3_add_delrec(struct in_device *in_dev, struct ip_mc_list *im); 14363007727SAl Viro static void igmpv3_del_delrec(struct in_device *in_dev, __be32 multiaddr); 1441da177e4SLinus Torvalds static void igmpv3_clear_delrec(struct in_device *in_dev); 1451da177e4SLinus Torvalds static int sf_setstate(struct ip_mc_list *pmc); 1461da177e4SLinus Torvalds static void sf_markstate(struct ip_mc_list *pmc); 1471da177e4SLinus Torvalds #endif 1481da177e4SLinus Torvalds static void ip_mc_clear_src(struct ip_mc_list *pmc); 1498f935bbdSAl Viro static int ip_mc_add_src(struct in_device *in_dev, __be32 *pmca, int sfmode, 1508f935bbdSAl Viro int sfcount, __be32 *psfsrc, int delta); 1511da177e4SLinus Torvalds 1521da177e4SLinus Torvalds static void ip_ma_put(struct ip_mc_list *im) 1531da177e4SLinus Torvalds { 1541da177e4SLinus Torvalds if (atomic_dec_and_test(&im->refcnt)) { 1551da177e4SLinus Torvalds in_dev_put(im->interface); 15642ea299dSLai Jiangshan kfree_rcu(im, rcu); 1571da177e4SLinus Torvalds } 1581da177e4SLinus Torvalds } 1591da177e4SLinus Torvalds 160d9aa9380SDavid S. Miller #define for_each_pmc_rcu(in_dev, pmc) \ 161d9aa9380SDavid S. Miller for (pmc = rcu_dereference(in_dev->mc_list); \ 162d9aa9380SDavid S. Miller pmc != NULL; \ 163d9aa9380SDavid S. Miller pmc = rcu_dereference(pmc->next_rcu)) 164d9aa9380SDavid S. Miller 165d9aa9380SDavid S. Miller #define for_each_pmc_rtnl(in_dev, pmc) \ 166d9aa9380SDavid S. Miller for (pmc = rtnl_dereference(in_dev->mc_list); \ 167d9aa9380SDavid S. Miller pmc != NULL; \ 168d9aa9380SDavid S. Miller pmc = rtnl_dereference(pmc->next_rcu)) 169d9aa9380SDavid S. Miller 1701da177e4SLinus Torvalds #ifdef CONFIG_IP_MULTICAST 1711da177e4SLinus Torvalds 1721da177e4SLinus Torvalds /* 1731da177e4SLinus Torvalds * Timer management 1741da177e4SLinus Torvalds */ 1751da177e4SLinus Torvalds 1761d7138deSEric Dumazet static void igmp_stop_timer(struct ip_mc_list *im) 1771da177e4SLinus Torvalds { 1781da177e4SLinus Torvalds spin_lock_bh(&im->lock); 1791da177e4SLinus Torvalds if (del_timer(&im->timer)) 1801da177e4SLinus Torvalds atomic_dec(&im->refcnt); 1811da177e4SLinus Torvalds im->tm_running = 0; 1821da177e4SLinus Torvalds im->reporter = 0; 1831da177e4SLinus Torvalds im->unsolicit_count = 0; 1841da177e4SLinus Torvalds spin_unlock_bh(&im->lock); 1851da177e4SLinus Torvalds } 1861da177e4SLinus Torvalds 1871da177e4SLinus Torvalds /* It must be called with locked im->lock */ 1881da177e4SLinus Torvalds static void igmp_start_timer(struct ip_mc_list *im, int max_delay) 1891da177e4SLinus Torvalds { 1901da177e4SLinus Torvalds int tv = net_random() % max_delay; 1911da177e4SLinus Torvalds 1921da177e4SLinus Torvalds im->tm_running = 1; 1931da177e4SLinus Torvalds if (!mod_timer(&im->timer, jiffies+tv+2)) 1941da177e4SLinus Torvalds atomic_inc(&im->refcnt); 1951da177e4SLinus Torvalds } 1961da177e4SLinus Torvalds 1971da177e4SLinus Torvalds static void igmp_gq_start_timer(struct in_device *in_dev) 1981da177e4SLinus Torvalds { 1991da177e4SLinus Torvalds int tv = net_random() % in_dev->mr_maxdelay; 2001da177e4SLinus Torvalds 2011da177e4SLinus Torvalds in_dev->mr_gq_running = 1; 2021da177e4SLinus Torvalds if (!mod_timer(&in_dev->mr_gq_timer, jiffies+tv+2)) 2031da177e4SLinus Torvalds in_dev_hold(in_dev); 2041da177e4SLinus Torvalds } 2051da177e4SLinus Torvalds 2061da177e4SLinus Torvalds static void igmp_ifc_start_timer(struct in_device *in_dev, int delay) 2071da177e4SLinus Torvalds { 2081da177e4SLinus Torvalds int tv = net_random() % delay; 2091da177e4SLinus Torvalds 2101da177e4SLinus Torvalds if (!mod_timer(&in_dev->mr_ifc_timer, jiffies+tv+2)) 2111da177e4SLinus Torvalds in_dev_hold(in_dev); 2121da177e4SLinus Torvalds } 2131da177e4SLinus Torvalds 2141da177e4SLinus Torvalds static void igmp_mod_timer(struct ip_mc_list *im, int max_delay) 2151da177e4SLinus Torvalds { 2161da177e4SLinus Torvalds spin_lock_bh(&im->lock); 2171da177e4SLinus Torvalds im->unsolicit_count = 0; 2181da177e4SLinus Torvalds if (del_timer(&im->timer)) { 2191da177e4SLinus Torvalds if ((long)(im->timer.expires-jiffies) < max_delay) { 2201da177e4SLinus Torvalds add_timer(&im->timer); 2211da177e4SLinus Torvalds im->tm_running = 1; 2221da177e4SLinus Torvalds spin_unlock_bh(&im->lock); 2231da177e4SLinus Torvalds return; 2241da177e4SLinus Torvalds } 2251da177e4SLinus Torvalds atomic_dec(&im->refcnt); 2261da177e4SLinus Torvalds } 2271da177e4SLinus Torvalds igmp_start_timer(im, max_delay); 2281da177e4SLinus Torvalds spin_unlock_bh(&im->lock); 2291da177e4SLinus Torvalds } 2301da177e4SLinus Torvalds 2311da177e4SLinus Torvalds 2321da177e4SLinus Torvalds /* 2331da177e4SLinus Torvalds * Send an IGMP report. 2341da177e4SLinus Torvalds */ 2351da177e4SLinus Torvalds 2361da177e4SLinus Torvalds #define IGMP_SIZE (sizeof(struct igmphdr)+sizeof(struct iphdr)+4) 2371da177e4SLinus Torvalds 2381da177e4SLinus Torvalds 2391da177e4SLinus Torvalds static int is_in(struct ip_mc_list *pmc, struct ip_sf_list *psf, int type, 2401da177e4SLinus Torvalds int gdeleted, int sdeleted) 2411da177e4SLinus Torvalds { 2421da177e4SLinus Torvalds switch (type) { 2431da177e4SLinus Torvalds case IGMPV3_MODE_IS_INCLUDE: 2441da177e4SLinus Torvalds case IGMPV3_MODE_IS_EXCLUDE: 2451da177e4SLinus Torvalds if (gdeleted || sdeleted) 2461da177e4SLinus Torvalds return 0; 247ad12583fSDavid L Stevens if (!(pmc->gsquery && !psf->sf_gsresp)) { 248ad12583fSDavid L Stevens if (pmc->sfmode == MCAST_INCLUDE) 249ad12583fSDavid L Stevens return 1; 250ad12583fSDavid L Stevens /* don't include if this source is excluded 251ad12583fSDavid L Stevens * in all filters 252ad12583fSDavid L Stevens */ 253ad12583fSDavid L Stevens if (psf->sf_count[MCAST_INCLUDE]) 254ad12583fSDavid L Stevens return type == IGMPV3_MODE_IS_INCLUDE; 255ad12583fSDavid L Stevens return pmc->sfcount[MCAST_EXCLUDE] == 256ad12583fSDavid L Stevens psf->sf_count[MCAST_EXCLUDE]; 257ad12583fSDavid L Stevens } 258ad12583fSDavid L Stevens return 0; 2591da177e4SLinus Torvalds case IGMPV3_CHANGE_TO_INCLUDE: 2601da177e4SLinus Torvalds if (gdeleted || sdeleted) 2611da177e4SLinus Torvalds return 0; 2621da177e4SLinus Torvalds return psf->sf_count[MCAST_INCLUDE] != 0; 2631da177e4SLinus Torvalds case IGMPV3_CHANGE_TO_EXCLUDE: 2641da177e4SLinus Torvalds if (gdeleted || sdeleted) 2651da177e4SLinus Torvalds return 0; 2661da177e4SLinus Torvalds if (pmc->sfcount[MCAST_EXCLUDE] == 0 || 2671da177e4SLinus Torvalds psf->sf_count[MCAST_INCLUDE]) 2681da177e4SLinus Torvalds return 0; 2691da177e4SLinus Torvalds return pmc->sfcount[MCAST_EXCLUDE] == 2701da177e4SLinus Torvalds psf->sf_count[MCAST_EXCLUDE]; 2711da177e4SLinus Torvalds case IGMPV3_ALLOW_NEW_SOURCES: 2721da177e4SLinus Torvalds if (gdeleted || !psf->sf_crcount) 2731da177e4SLinus Torvalds return 0; 2741da177e4SLinus Torvalds return (pmc->sfmode == MCAST_INCLUDE) ^ sdeleted; 2751da177e4SLinus Torvalds case IGMPV3_BLOCK_OLD_SOURCES: 2761da177e4SLinus Torvalds if (pmc->sfmode == MCAST_INCLUDE) 2771da177e4SLinus Torvalds return gdeleted || (psf->sf_crcount && sdeleted); 2781da177e4SLinus Torvalds return psf->sf_crcount && !gdeleted && !sdeleted; 2791da177e4SLinus Torvalds } 2801da177e4SLinus Torvalds return 0; 2811da177e4SLinus Torvalds } 2821da177e4SLinus Torvalds 2831da177e4SLinus Torvalds static int 2841da177e4SLinus Torvalds igmp_scount(struct ip_mc_list *pmc, int type, int gdeleted, int sdeleted) 2851da177e4SLinus Torvalds { 2861da177e4SLinus Torvalds struct ip_sf_list *psf; 2871da177e4SLinus Torvalds int scount = 0; 2881da177e4SLinus Torvalds 2891da177e4SLinus Torvalds for (psf=pmc->sources; psf; psf=psf->sf_next) { 2901da177e4SLinus Torvalds if (!is_in(pmc, psf, type, gdeleted, sdeleted)) 2911da177e4SLinus Torvalds continue; 2921da177e4SLinus Torvalds scount++; 2931da177e4SLinus Torvalds } 2941da177e4SLinus Torvalds return scount; 2951da177e4SLinus Torvalds } 2961da177e4SLinus Torvalds 29757e1ab6eSEric Dumazet #define igmp_skb_size(skb) (*(unsigned int *)((skb)->cb)) 29857e1ab6eSEric Dumazet 2991da177e4SLinus Torvalds static struct sk_buff *igmpv3_newpack(struct net_device *dev, int size) 3001da177e4SLinus Torvalds { 3011da177e4SLinus Torvalds struct sk_buff *skb; 3021da177e4SLinus Torvalds struct rtable *rt; 3031da177e4SLinus Torvalds struct iphdr *pip; 3041da177e4SLinus Torvalds struct igmpv3_report *pig; 305877acedcSDaniel Lezcano struct net *net = dev_net(dev); 30631e4543dSDavid S. Miller struct flowi4 fl4; 30766088243SHerbert Xu int hlen = LL_RESERVED_SPACE(dev); 30866088243SHerbert Xu int tlen = dev->needed_tailroom; 3091da177e4SLinus Torvalds 31057e1ab6eSEric Dumazet while (1) { 31166088243SHerbert Xu skb = alloc_skb(size + hlen + tlen, 31257e1ab6eSEric Dumazet GFP_ATOMIC | __GFP_NOWARN); 31357e1ab6eSEric Dumazet if (skb) 31457e1ab6eSEric Dumazet break; 31557e1ab6eSEric Dumazet size >>= 1; 31657e1ab6eSEric Dumazet if (size < 256) 3171da177e4SLinus Torvalds return NULL; 31857e1ab6eSEric Dumazet } 319*9d4a0314SHannes Frederic Sowa skb->priority = TC_PRIO_CONTROL; 32057e1ab6eSEric Dumazet igmp_skb_size(skb) = size; 3211da177e4SLinus Torvalds 32231e4543dSDavid S. Miller rt = ip_route_output_ports(net, &fl4, NULL, IGMPV3_ALL_MCR, 0, 32378fbfd8aSDavid S. Miller 0, 0, 32478fbfd8aSDavid S. Miller IPPROTO_IGMP, 0, dev->ifindex); 325b23dd4feSDavid S. Miller if (IS_ERR(rt)) { 3261da177e4SLinus Torvalds kfree_skb(skb); 3271da177e4SLinus Torvalds return NULL; 3281da177e4SLinus Torvalds } 3291da177e4SLinus Torvalds 330d8d1f30bSChangli Gao skb_dst_set(skb, &rt->dst); 3311da177e4SLinus Torvalds skb->dev = dev; 3321da177e4SLinus Torvalds 33366088243SHerbert Xu skb_reserve(skb, hlen); 3341da177e4SLinus Torvalds 3357e28ecc2SArnaldo Carvalho de Melo skb_reset_network_header(skb); 336eddc9ec5SArnaldo Carvalho de Melo pip = ip_hdr(skb); 3377e28ecc2SArnaldo Carvalho de Melo skb_put(skb, sizeof(struct iphdr) + 4); 3381da177e4SLinus Torvalds 3391da177e4SLinus Torvalds pip->version = 4; 3401da177e4SLinus Torvalds pip->ihl = (sizeof(struct iphdr)+4)>>2; 3411da177e4SLinus Torvalds pip->tos = 0xc0; 3421da177e4SLinus Torvalds pip->frag_off = htons(IP_DF); 3431da177e4SLinus Torvalds pip->ttl = 1; 344492f64ceSDavid S. Miller pip->daddr = fl4.daddr; 345492f64ceSDavid S. Miller pip->saddr = fl4.saddr; 3461da177e4SLinus Torvalds pip->protocol = IPPROTO_IGMP; 3471da177e4SLinus Torvalds pip->tot_len = 0; /* filled in later */ 348d8d1f30bSChangli Gao ip_select_ident(pip, &rt->dst, NULL); 3491da177e4SLinus Torvalds ((u8 *)&pip[1])[0] = IPOPT_RA; 3501da177e4SLinus Torvalds ((u8 *)&pip[1])[1] = 4; 3511da177e4SLinus Torvalds ((u8 *)&pip[1])[2] = 0; 3521da177e4SLinus Torvalds ((u8 *)&pip[1])[3] = 0; 3531da177e4SLinus Torvalds 354b0e380b1SArnaldo Carvalho de Melo skb->transport_header = skb->network_header + sizeof(struct iphdr) + 4; 355d10ba34bSArnaldo Carvalho de Melo skb_put(skb, sizeof(*pig)); 356d9edf9e2SArnaldo Carvalho de Melo pig = igmpv3_report_hdr(skb); 3571da177e4SLinus Torvalds pig->type = IGMPV3_HOST_MEMBERSHIP_REPORT; 3581da177e4SLinus Torvalds pig->resv1 = 0; 3591da177e4SLinus Torvalds pig->csum = 0; 3601da177e4SLinus Torvalds pig->resv2 = 0; 3611da177e4SLinus Torvalds pig->ngrec = 0; 3621da177e4SLinus Torvalds return skb; 3631da177e4SLinus Torvalds } 3641da177e4SLinus Torvalds 3651da177e4SLinus Torvalds static int igmpv3_sendpack(struct sk_buff *skb) 3661da177e4SLinus Torvalds { 367d9edf9e2SArnaldo Carvalho de Melo struct igmphdr *pig = igmp_hdr(skb); 368f7c0c2aeSSimon Horman const int igmplen = skb_tail_pointer(skb) - skb_transport_header(skb); 3691da177e4SLinus Torvalds 370d9edf9e2SArnaldo Carvalho de Melo pig->csum = ip_compute_csum(igmp_hdr(skb), igmplen); 3711da177e4SLinus Torvalds 372c439cb2eSHerbert Xu return ip_local_out(skb); 3731da177e4SLinus Torvalds } 3741da177e4SLinus Torvalds 3751da177e4SLinus Torvalds static int grec_size(struct ip_mc_list *pmc, int type, int gdel, int sdel) 3761da177e4SLinus Torvalds { 3771da177e4SLinus Torvalds return sizeof(struct igmpv3_grec) + 4*igmp_scount(pmc, type, gdel, sdel); 3781da177e4SLinus Torvalds } 3791da177e4SLinus Torvalds 3801da177e4SLinus Torvalds static struct sk_buff *add_grhead(struct sk_buff *skb, struct ip_mc_list *pmc, 3811da177e4SLinus Torvalds int type, struct igmpv3_grec **ppgr) 3821da177e4SLinus Torvalds { 3831da177e4SLinus Torvalds struct net_device *dev = pmc->interface->dev; 3841da177e4SLinus Torvalds struct igmpv3_report *pih; 3851da177e4SLinus Torvalds struct igmpv3_grec *pgr; 3861da177e4SLinus Torvalds 3871da177e4SLinus Torvalds if (!skb) 3881da177e4SLinus Torvalds skb = igmpv3_newpack(dev, dev->mtu); 3891da177e4SLinus Torvalds if (!skb) 3901da177e4SLinus Torvalds return NULL; 3911da177e4SLinus Torvalds pgr = (struct igmpv3_grec *)skb_put(skb, sizeof(struct igmpv3_grec)); 3921da177e4SLinus Torvalds pgr->grec_type = type; 3931da177e4SLinus Torvalds pgr->grec_auxwords = 0; 3941da177e4SLinus Torvalds pgr->grec_nsrcs = 0; 3951da177e4SLinus Torvalds pgr->grec_mca = pmc->multiaddr; 396d9edf9e2SArnaldo Carvalho de Melo pih = igmpv3_report_hdr(skb); 3971da177e4SLinus Torvalds pih->ngrec = htons(ntohs(pih->ngrec)+1); 3981da177e4SLinus Torvalds *ppgr = pgr; 3991da177e4SLinus Torvalds return skb; 4001da177e4SLinus Torvalds } 4011da177e4SLinus Torvalds 40257e1ab6eSEric Dumazet #define AVAILABLE(skb) ((skb) ? ((skb)->dev ? igmp_skb_size(skb) - (skb)->len : \ 4031da177e4SLinus Torvalds skb_tailroom(skb)) : 0) 4041da177e4SLinus Torvalds 4051da177e4SLinus Torvalds static struct sk_buff *add_grec(struct sk_buff *skb, struct ip_mc_list *pmc, 4061da177e4SLinus Torvalds int type, int gdeleted, int sdeleted) 4071da177e4SLinus Torvalds { 4081da177e4SLinus Torvalds struct net_device *dev = pmc->interface->dev; 4091da177e4SLinus Torvalds struct igmpv3_report *pih; 4101da177e4SLinus Torvalds struct igmpv3_grec *pgr = NULL; 4111da177e4SLinus Torvalds struct ip_sf_list *psf, *psf_next, *psf_prev, **psf_list; 412ad12583fSDavid L Stevens int scount, stotal, first, isquery, truncate; 4131da177e4SLinus Torvalds 4141da177e4SLinus Torvalds if (pmc->multiaddr == IGMP_ALL_HOSTS) 4151da177e4SLinus Torvalds return skb; 4161da177e4SLinus Torvalds 4171da177e4SLinus Torvalds isquery = type == IGMPV3_MODE_IS_INCLUDE || 4181da177e4SLinus Torvalds type == IGMPV3_MODE_IS_EXCLUDE; 4191da177e4SLinus Torvalds truncate = type == IGMPV3_MODE_IS_EXCLUDE || 4201da177e4SLinus Torvalds type == IGMPV3_CHANGE_TO_EXCLUDE; 4211da177e4SLinus Torvalds 422ad12583fSDavid L Stevens stotal = scount = 0; 423ad12583fSDavid L Stevens 4241da177e4SLinus Torvalds psf_list = sdeleted ? &pmc->tomb : &pmc->sources; 4251da177e4SLinus Torvalds 426ad12583fSDavid L Stevens if (!*psf_list) 427ad12583fSDavid L Stevens goto empty_source; 428ad12583fSDavid L Stevens 429d9edf9e2SArnaldo Carvalho de Melo pih = skb ? igmpv3_report_hdr(skb) : NULL; 4301da177e4SLinus Torvalds 4311da177e4SLinus Torvalds /* EX and TO_EX get a fresh packet, if needed */ 4321da177e4SLinus Torvalds if (truncate) { 4331da177e4SLinus Torvalds if (pih && pih->ngrec && 4341da177e4SLinus Torvalds AVAILABLE(skb) < grec_size(pmc, type, gdeleted, sdeleted)) { 4351da177e4SLinus Torvalds if (skb) 4361da177e4SLinus Torvalds igmpv3_sendpack(skb); 4371da177e4SLinus Torvalds skb = igmpv3_newpack(dev, dev->mtu); 4381da177e4SLinus Torvalds } 4391da177e4SLinus Torvalds } 4401da177e4SLinus Torvalds first = 1; 4411da177e4SLinus Torvalds psf_prev = NULL; 4421da177e4SLinus Torvalds for (psf=*psf_list; psf; psf=psf_next) { 443ea4d9e72SAl Viro __be32 *psrc; 4441da177e4SLinus Torvalds 4451da177e4SLinus Torvalds psf_next = psf->sf_next; 4461da177e4SLinus Torvalds 4471da177e4SLinus Torvalds if (!is_in(pmc, psf, type, gdeleted, sdeleted)) { 4481da177e4SLinus Torvalds psf_prev = psf; 4491da177e4SLinus Torvalds continue; 4501da177e4SLinus Torvalds } 4511da177e4SLinus Torvalds 4521da177e4SLinus Torvalds /* clear marks on query responses */ 4531da177e4SLinus Torvalds if (isquery) 4541da177e4SLinus Torvalds psf->sf_gsresp = 0; 4551da177e4SLinus Torvalds 45663007727SAl Viro if (AVAILABLE(skb) < sizeof(__be32) + 4571da177e4SLinus Torvalds first*sizeof(struct igmpv3_grec)) { 4581da177e4SLinus Torvalds if (truncate && !first) 4591da177e4SLinus Torvalds break; /* truncate these */ 4601da177e4SLinus Torvalds if (pgr) 4611da177e4SLinus Torvalds pgr->grec_nsrcs = htons(scount); 4621da177e4SLinus Torvalds if (skb) 4631da177e4SLinus Torvalds igmpv3_sendpack(skb); 4641da177e4SLinus Torvalds skb = igmpv3_newpack(dev, dev->mtu); 4651da177e4SLinus Torvalds first = 1; 4661da177e4SLinus Torvalds scount = 0; 4671da177e4SLinus Torvalds } 4681da177e4SLinus Torvalds if (first) { 4691da177e4SLinus Torvalds skb = add_grhead(skb, pmc, type, &pgr); 4701da177e4SLinus Torvalds first = 0; 4711da177e4SLinus Torvalds } 472cc63f70bSAlexey Dobriyan if (!skb) 473cc63f70bSAlexey Dobriyan return NULL; 47463007727SAl Viro psrc = (__be32 *)skb_put(skb, sizeof(__be32)); 4751da177e4SLinus Torvalds *psrc = psf->sf_inaddr; 476ad12583fSDavid L Stevens scount++; stotal++; 4771da177e4SLinus Torvalds if ((type == IGMPV3_ALLOW_NEW_SOURCES || 4781da177e4SLinus Torvalds type == IGMPV3_BLOCK_OLD_SOURCES) && psf->sf_crcount) { 4791da177e4SLinus Torvalds psf->sf_crcount--; 4801da177e4SLinus Torvalds if ((sdeleted || gdeleted) && psf->sf_crcount == 0) { 4811da177e4SLinus Torvalds if (psf_prev) 4821da177e4SLinus Torvalds psf_prev->sf_next = psf->sf_next; 4831da177e4SLinus Torvalds else 4841da177e4SLinus Torvalds *psf_list = psf->sf_next; 4851da177e4SLinus Torvalds kfree(psf); 4861da177e4SLinus Torvalds continue; 4871da177e4SLinus Torvalds } 4881da177e4SLinus Torvalds } 4891da177e4SLinus Torvalds psf_prev = psf; 4901da177e4SLinus Torvalds } 491ad12583fSDavid L Stevens 492ad12583fSDavid L Stevens empty_source: 493ad12583fSDavid L Stevens if (!stotal) { 494ad12583fSDavid L Stevens if (type == IGMPV3_ALLOW_NEW_SOURCES || 495ad12583fSDavid L Stevens type == IGMPV3_BLOCK_OLD_SOURCES) 496ad12583fSDavid L Stevens return skb; 497ad12583fSDavid L Stevens if (pmc->crcount || isquery) { 498ad12583fSDavid L Stevens /* make sure we have room for group header */ 499ad12583fSDavid L Stevens if (skb && AVAILABLE(skb)<sizeof(struct igmpv3_grec)) { 500ad12583fSDavid L Stevens igmpv3_sendpack(skb); 501ad12583fSDavid L Stevens skb = NULL; /* add_grhead will get a new one */ 502ad12583fSDavid L Stevens } 503ad12583fSDavid L Stevens skb = add_grhead(skb, pmc, type, &pgr); 504ad12583fSDavid L Stevens } 505ad12583fSDavid L Stevens } 5061da177e4SLinus Torvalds if (pgr) 5071da177e4SLinus Torvalds pgr->grec_nsrcs = htons(scount); 5081da177e4SLinus Torvalds 5091da177e4SLinus Torvalds if (isquery) 5101da177e4SLinus Torvalds pmc->gsquery = 0; /* clear query state on report */ 5111da177e4SLinus Torvalds return skb; 5121da177e4SLinus Torvalds } 5131da177e4SLinus Torvalds 5141da177e4SLinus Torvalds static int igmpv3_send_report(struct in_device *in_dev, struct ip_mc_list *pmc) 5151da177e4SLinus Torvalds { 5161da177e4SLinus Torvalds struct sk_buff *skb = NULL; 5171da177e4SLinus Torvalds int type; 5181da177e4SLinus Torvalds 5191da177e4SLinus Torvalds if (!pmc) { 5201d7138deSEric Dumazet rcu_read_lock(); 5211d7138deSEric Dumazet for_each_pmc_rcu(in_dev, pmc) { 5221da177e4SLinus Torvalds if (pmc->multiaddr == IGMP_ALL_HOSTS) 5231da177e4SLinus Torvalds continue; 5241da177e4SLinus Torvalds spin_lock_bh(&pmc->lock); 5251da177e4SLinus Torvalds if (pmc->sfcount[MCAST_EXCLUDE]) 5261da177e4SLinus Torvalds type = IGMPV3_MODE_IS_EXCLUDE; 5271da177e4SLinus Torvalds else 5281da177e4SLinus Torvalds type = IGMPV3_MODE_IS_INCLUDE; 5291da177e4SLinus Torvalds skb = add_grec(skb, pmc, type, 0, 0); 5301da177e4SLinus Torvalds spin_unlock_bh(&pmc->lock); 5311da177e4SLinus Torvalds } 5321d7138deSEric Dumazet rcu_read_unlock(); 5331da177e4SLinus Torvalds } else { 5341da177e4SLinus Torvalds spin_lock_bh(&pmc->lock); 5351da177e4SLinus Torvalds if (pmc->sfcount[MCAST_EXCLUDE]) 5361da177e4SLinus Torvalds type = IGMPV3_MODE_IS_EXCLUDE; 5371da177e4SLinus Torvalds else 5381da177e4SLinus Torvalds type = IGMPV3_MODE_IS_INCLUDE; 5391da177e4SLinus Torvalds skb = add_grec(skb, pmc, type, 0, 0); 5401da177e4SLinus Torvalds spin_unlock_bh(&pmc->lock); 5411da177e4SLinus Torvalds } 5421da177e4SLinus Torvalds if (!skb) 5431da177e4SLinus Torvalds return 0; 5441da177e4SLinus Torvalds return igmpv3_sendpack(skb); 5451da177e4SLinus Torvalds } 5461da177e4SLinus Torvalds 5471da177e4SLinus Torvalds /* 5481da177e4SLinus Torvalds * remove zero-count source records from a source filter list 5491da177e4SLinus Torvalds */ 5501da177e4SLinus Torvalds static void igmpv3_clear_zeros(struct ip_sf_list **ppsf) 5511da177e4SLinus Torvalds { 5521da177e4SLinus Torvalds struct ip_sf_list *psf_prev, *psf_next, *psf; 5531da177e4SLinus Torvalds 5541da177e4SLinus Torvalds psf_prev = NULL; 5551da177e4SLinus Torvalds for (psf=*ppsf; psf; psf = psf_next) { 5561da177e4SLinus Torvalds psf_next = psf->sf_next; 5571da177e4SLinus Torvalds if (psf->sf_crcount == 0) { 5581da177e4SLinus Torvalds if (psf_prev) 5591da177e4SLinus Torvalds psf_prev->sf_next = psf->sf_next; 5601da177e4SLinus Torvalds else 5611da177e4SLinus Torvalds *ppsf = psf->sf_next; 5621da177e4SLinus Torvalds kfree(psf); 5631da177e4SLinus Torvalds } else 5641da177e4SLinus Torvalds psf_prev = psf; 5651da177e4SLinus Torvalds } 5661da177e4SLinus Torvalds } 5671da177e4SLinus Torvalds 5681da177e4SLinus Torvalds static void igmpv3_send_cr(struct in_device *in_dev) 5691da177e4SLinus Torvalds { 5701da177e4SLinus Torvalds struct ip_mc_list *pmc, *pmc_prev, *pmc_next; 5711da177e4SLinus Torvalds struct sk_buff *skb = NULL; 5721da177e4SLinus Torvalds int type, dtype; 5731da177e4SLinus Torvalds 5741d7138deSEric Dumazet rcu_read_lock(); 5751da177e4SLinus Torvalds spin_lock_bh(&in_dev->mc_tomb_lock); 5761da177e4SLinus Torvalds 5771da177e4SLinus Torvalds /* deleted MCA's */ 5781da177e4SLinus Torvalds pmc_prev = NULL; 5791da177e4SLinus Torvalds for (pmc=in_dev->mc_tomb; pmc; pmc=pmc_next) { 5801da177e4SLinus Torvalds pmc_next = pmc->next; 5811da177e4SLinus Torvalds if (pmc->sfmode == MCAST_INCLUDE) { 5821da177e4SLinus Torvalds type = IGMPV3_BLOCK_OLD_SOURCES; 5831da177e4SLinus Torvalds dtype = IGMPV3_BLOCK_OLD_SOURCES; 5841da177e4SLinus Torvalds skb = add_grec(skb, pmc, type, 1, 0); 5851da177e4SLinus Torvalds skb = add_grec(skb, pmc, dtype, 1, 1); 5861da177e4SLinus Torvalds } 5871da177e4SLinus Torvalds if (pmc->crcount) { 5881da177e4SLinus Torvalds if (pmc->sfmode == MCAST_EXCLUDE) { 5891da177e4SLinus Torvalds type = IGMPV3_CHANGE_TO_INCLUDE; 5901da177e4SLinus Torvalds skb = add_grec(skb, pmc, type, 1, 0); 5911da177e4SLinus Torvalds } 592ad12583fSDavid L Stevens pmc->crcount--; 5931da177e4SLinus Torvalds if (pmc->crcount == 0) { 5941da177e4SLinus Torvalds igmpv3_clear_zeros(&pmc->tomb); 5951da177e4SLinus Torvalds igmpv3_clear_zeros(&pmc->sources); 5961da177e4SLinus Torvalds } 5971da177e4SLinus Torvalds } 5981da177e4SLinus Torvalds if (pmc->crcount == 0 && !pmc->tomb && !pmc->sources) { 5991da177e4SLinus Torvalds if (pmc_prev) 6001da177e4SLinus Torvalds pmc_prev->next = pmc_next; 6011da177e4SLinus Torvalds else 6021da177e4SLinus Torvalds in_dev->mc_tomb = pmc_next; 6031da177e4SLinus Torvalds in_dev_put(pmc->interface); 6041da177e4SLinus Torvalds kfree(pmc); 6051da177e4SLinus Torvalds } else 6061da177e4SLinus Torvalds pmc_prev = pmc; 6071da177e4SLinus Torvalds } 6081da177e4SLinus Torvalds spin_unlock_bh(&in_dev->mc_tomb_lock); 6091da177e4SLinus Torvalds 6101da177e4SLinus Torvalds /* change recs */ 6111d7138deSEric Dumazet for_each_pmc_rcu(in_dev, pmc) { 6121da177e4SLinus Torvalds spin_lock_bh(&pmc->lock); 6131da177e4SLinus Torvalds if (pmc->sfcount[MCAST_EXCLUDE]) { 6141da177e4SLinus Torvalds type = IGMPV3_BLOCK_OLD_SOURCES; 6151da177e4SLinus Torvalds dtype = IGMPV3_ALLOW_NEW_SOURCES; 6161da177e4SLinus Torvalds } else { 6171da177e4SLinus Torvalds type = IGMPV3_ALLOW_NEW_SOURCES; 6181da177e4SLinus Torvalds dtype = IGMPV3_BLOCK_OLD_SOURCES; 6191da177e4SLinus Torvalds } 6201da177e4SLinus Torvalds skb = add_grec(skb, pmc, type, 0, 0); 6211da177e4SLinus Torvalds skb = add_grec(skb, pmc, dtype, 0, 1); /* deleted sources */ 6221da177e4SLinus Torvalds 6231da177e4SLinus Torvalds /* filter mode changes */ 6241da177e4SLinus Torvalds if (pmc->crcount) { 6251da177e4SLinus Torvalds if (pmc->sfmode == MCAST_EXCLUDE) 6261da177e4SLinus Torvalds type = IGMPV3_CHANGE_TO_EXCLUDE; 6271da177e4SLinus Torvalds else 6281da177e4SLinus Torvalds type = IGMPV3_CHANGE_TO_INCLUDE; 6291da177e4SLinus Torvalds skb = add_grec(skb, pmc, type, 0, 0); 630ad12583fSDavid L Stevens pmc->crcount--; 6311da177e4SLinus Torvalds } 6321da177e4SLinus Torvalds spin_unlock_bh(&pmc->lock); 6331da177e4SLinus Torvalds } 6341d7138deSEric Dumazet rcu_read_unlock(); 6351da177e4SLinus Torvalds 6361da177e4SLinus Torvalds if (!skb) 6371da177e4SLinus Torvalds return; 6381da177e4SLinus Torvalds (void) igmpv3_sendpack(skb); 6391da177e4SLinus Torvalds } 6401da177e4SLinus Torvalds 6411da177e4SLinus Torvalds static int igmp_send_report(struct in_device *in_dev, struct ip_mc_list *pmc, 6421da177e4SLinus Torvalds int type) 6431da177e4SLinus Torvalds { 6441da177e4SLinus Torvalds struct sk_buff *skb; 6451da177e4SLinus Torvalds struct iphdr *iph; 6461da177e4SLinus Torvalds struct igmphdr *ih; 6471da177e4SLinus Torvalds struct rtable *rt; 6481da177e4SLinus Torvalds struct net_device *dev = in_dev->dev; 649877acedcSDaniel Lezcano struct net *net = dev_net(dev); 65063007727SAl Viro __be32 group = pmc ? pmc->multiaddr : 0; 65131e4543dSDavid S. Miller struct flowi4 fl4; 65263007727SAl Viro __be32 dst; 65366088243SHerbert Xu int hlen, tlen; 6541da177e4SLinus Torvalds 6551da177e4SLinus Torvalds if (type == IGMPV3_HOST_MEMBERSHIP_REPORT) 6561da177e4SLinus Torvalds return igmpv3_send_report(in_dev, pmc); 6571da177e4SLinus Torvalds else if (type == IGMP_HOST_LEAVE_MESSAGE) 6581da177e4SLinus Torvalds dst = IGMP_ALL_ROUTER; 6591da177e4SLinus Torvalds else 6601da177e4SLinus Torvalds dst = group; 6611da177e4SLinus Torvalds 66231e4543dSDavid S. Miller rt = ip_route_output_ports(net, &fl4, NULL, dst, 0, 66378fbfd8aSDavid S. Miller 0, 0, 66478fbfd8aSDavid S. Miller IPPROTO_IGMP, 0, dev->ifindex); 665b23dd4feSDavid S. Miller if (IS_ERR(rt)) 6661da177e4SLinus Torvalds return -1; 66778fbfd8aSDavid S. Miller 66866088243SHerbert Xu hlen = LL_RESERVED_SPACE(dev); 66966088243SHerbert Xu tlen = dev->needed_tailroom; 67066088243SHerbert Xu skb = alloc_skb(IGMP_SIZE + hlen + tlen, GFP_ATOMIC); 6711da177e4SLinus Torvalds if (skb == NULL) { 6721da177e4SLinus Torvalds ip_rt_put(rt); 6731da177e4SLinus Torvalds return -1; 6741da177e4SLinus Torvalds } 675*9d4a0314SHannes Frederic Sowa skb->priority = TC_PRIO_CONTROL; 6761da177e4SLinus Torvalds 677d8d1f30bSChangli Gao skb_dst_set(skb, &rt->dst); 6781da177e4SLinus Torvalds 67966088243SHerbert Xu skb_reserve(skb, hlen); 6801da177e4SLinus Torvalds 6817e28ecc2SArnaldo Carvalho de Melo skb_reset_network_header(skb); 682eddc9ec5SArnaldo Carvalho de Melo iph = ip_hdr(skb); 6837e28ecc2SArnaldo Carvalho de Melo skb_put(skb, sizeof(struct iphdr) + 4); 6841da177e4SLinus Torvalds 6851da177e4SLinus Torvalds iph->version = 4; 6861da177e4SLinus Torvalds iph->ihl = (sizeof(struct iphdr)+4)>>2; 6871da177e4SLinus Torvalds iph->tos = 0xc0; 6881da177e4SLinus Torvalds iph->frag_off = htons(IP_DF); 6891da177e4SLinus Torvalds iph->ttl = 1; 6901da177e4SLinus Torvalds iph->daddr = dst; 691492f64ceSDavid S. Miller iph->saddr = fl4.saddr; 6921da177e4SLinus Torvalds iph->protocol = IPPROTO_IGMP; 693d8d1f30bSChangli Gao ip_select_ident(iph, &rt->dst, NULL); 6941da177e4SLinus Torvalds ((u8 *)&iph[1])[0] = IPOPT_RA; 6951da177e4SLinus Torvalds ((u8 *)&iph[1])[1] = 4; 6961da177e4SLinus Torvalds ((u8 *)&iph[1])[2] = 0; 6971da177e4SLinus Torvalds ((u8 *)&iph[1])[3] = 0; 6981da177e4SLinus Torvalds 6991da177e4SLinus Torvalds ih = (struct igmphdr *)skb_put(skb, sizeof(struct igmphdr)); 7001da177e4SLinus Torvalds ih->type = type; 7011da177e4SLinus Torvalds ih->code = 0; 7021da177e4SLinus Torvalds ih->csum = 0; 7031da177e4SLinus Torvalds ih->group = group; 7041da177e4SLinus Torvalds ih->csum = ip_compute_csum((void *)ih, sizeof(struct igmphdr)); 7051da177e4SLinus Torvalds 706c439cb2eSHerbert Xu return ip_local_out(skb); 7071da177e4SLinus Torvalds } 7081da177e4SLinus Torvalds 7091da177e4SLinus Torvalds static void igmp_gq_timer_expire(unsigned long data) 7101da177e4SLinus Torvalds { 7111da177e4SLinus Torvalds struct in_device *in_dev = (struct in_device *)data; 7121da177e4SLinus Torvalds 7131da177e4SLinus Torvalds in_dev->mr_gq_running = 0; 7141da177e4SLinus Torvalds igmpv3_send_report(in_dev, NULL); 7151da177e4SLinus Torvalds __in_dev_put(in_dev); 7161da177e4SLinus Torvalds } 7171da177e4SLinus Torvalds 7181da177e4SLinus Torvalds static void igmp_ifc_timer_expire(unsigned long data) 7191da177e4SLinus Torvalds { 7201da177e4SLinus Torvalds struct in_device *in_dev = (struct in_device *)data; 7211da177e4SLinus Torvalds 7221da177e4SLinus Torvalds igmpv3_send_cr(in_dev); 7231da177e4SLinus Torvalds if (in_dev->mr_ifc_count) { 7241da177e4SLinus Torvalds in_dev->mr_ifc_count--; 7251da177e4SLinus Torvalds igmp_ifc_start_timer(in_dev, IGMP_Unsolicited_Report_Interval); 7261da177e4SLinus Torvalds } 7271da177e4SLinus Torvalds __in_dev_put(in_dev); 7281da177e4SLinus Torvalds } 7291da177e4SLinus Torvalds 7301da177e4SLinus Torvalds static void igmp_ifc_event(struct in_device *in_dev) 7311da177e4SLinus Torvalds { 7321da177e4SLinus Torvalds if (IGMP_V1_SEEN(in_dev) || IGMP_V2_SEEN(in_dev)) 7331da177e4SLinus Torvalds return; 7341da177e4SLinus Torvalds in_dev->mr_ifc_count = in_dev->mr_qrv ? in_dev->mr_qrv : 7351da177e4SLinus Torvalds IGMP_Unsolicited_Report_Count; 7361da177e4SLinus Torvalds igmp_ifc_start_timer(in_dev, 1); 7371da177e4SLinus Torvalds } 7381da177e4SLinus Torvalds 7391da177e4SLinus Torvalds 7401da177e4SLinus Torvalds static void igmp_timer_expire(unsigned long data) 7411da177e4SLinus Torvalds { 7421da177e4SLinus Torvalds struct ip_mc_list *im=(struct ip_mc_list *)data; 7431da177e4SLinus Torvalds struct in_device *in_dev = im->interface; 7441da177e4SLinus Torvalds 7451da177e4SLinus Torvalds spin_lock(&im->lock); 7461da177e4SLinus Torvalds im->tm_running = 0; 7471da177e4SLinus Torvalds 7481da177e4SLinus Torvalds if (im->unsolicit_count) { 7491da177e4SLinus Torvalds im->unsolicit_count--; 7501da177e4SLinus Torvalds igmp_start_timer(im, IGMP_Unsolicited_Report_Interval); 7511da177e4SLinus Torvalds } 7521da177e4SLinus Torvalds im->reporter = 1; 7531da177e4SLinus Torvalds spin_unlock(&im->lock); 7541da177e4SLinus Torvalds 7551da177e4SLinus Torvalds if (IGMP_V1_SEEN(in_dev)) 7561da177e4SLinus Torvalds igmp_send_report(in_dev, im, IGMP_HOST_MEMBERSHIP_REPORT); 7571da177e4SLinus Torvalds else if (IGMP_V2_SEEN(in_dev)) 7581da177e4SLinus Torvalds igmp_send_report(in_dev, im, IGMPV2_HOST_MEMBERSHIP_REPORT); 7591da177e4SLinus Torvalds else 7601da177e4SLinus Torvalds igmp_send_report(in_dev, im, IGMPV3_HOST_MEMBERSHIP_REPORT); 7611da177e4SLinus Torvalds 7621da177e4SLinus Torvalds ip_ma_put(im); 7631da177e4SLinus Torvalds } 7641da177e4SLinus Torvalds 765ad12583fSDavid L Stevens /* mark EXCLUDE-mode sources */ 766ea4d9e72SAl Viro static int igmp_xmarksources(struct ip_mc_list *pmc, int nsrcs, __be32 *srcs) 7671da177e4SLinus Torvalds { 7681da177e4SLinus Torvalds struct ip_sf_list *psf; 7691da177e4SLinus Torvalds int i, scount; 7701da177e4SLinus Torvalds 7711da177e4SLinus Torvalds scount = 0; 7721da177e4SLinus Torvalds for (psf=pmc->sources; psf; psf=psf->sf_next) { 7731da177e4SLinus Torvalds if (scount == nsrcs) 7741da177e4SLinus Torvalds break; 775ad12583fSDavid L Stevens for (i=0; i<nsrcs; i++) { 776ad12583fSDavid L Stevens /* skip inactive filters */ 777e05c4ad3SYan, Zheng if (psf->sf_count[MCAST_INCLUDE] || 778ad12583fSDavid L Stevens pmc->sfcount[MCAST_EXCLUDE] != 779ad12583fSDavid L Stevens psf->sf_count[MCAST_EXCLUDE]) 780ce713ee5SRongQing.Li break; 781ad12583fSDavid L Stevens if (srcs[i] == psf->sf_inaddr) { 782ad12583fSDavid L Stevens scount++; 783ad12583fSDavid L Stevens break; 784ad12583fSDavid L Stevens } 785ad12583fSDavid L Stevens } 786ad12583fSDavid L Stevens } 787ad12583fSDavid L Stevens pmc->gsquery = 0; 788ad12583fSDavid L Stevens if (scount == nsrcs) /* all sources excluded */ 789ad12583fSDavid L Stevens return 0; 790ad12583fSDavid L Stevens return 1; 791ad12583fSDavid L Stevens } 792ad12583fSDavid L Stevens 793ea4d9e72SAl Viro static int igmp_marksources(struct ip_mc_list *pmc, int nsrcs, __be32 *srcs) 794ad12583fSDavid L Stevens { 795ad12583fSDavid L Stevens struct ip_sf_list *psf; 796ad12583fSDavid L Stevens int i, scount; 797ad12583fSDavid L Stevens 798ad12583fSDavid L Stevens if (pmc->sfmode == MCAST_EXCLUDE) 799ad12583fSDavid L Stevens return igmp_xmarksources(pmc, nsrcs, srcs); 800ad12583fSDavid L Stevens 801ad12583fSDavid L Stevens /* mark INCLUDE-mode sources */ 802ad12583fSDavid L Stevens scount = 0; 803ad12583fSDavid L Stevens for (psf=pmc->sources; psf; psf=psf->sf_next) { 804ad12583fSDavid L Stevens if (scount == nsrcs) 805ad12583fSDavid L Stevens break; 8061da177e4SLinus Torvalds for (i=0; i<nsrcs; i++) 8071da177e4SLinus Torvalds if (srcs[i] == psf->sf_inaddr) { 8081da177e4SLinus Torvalds psf->sf_gsresp = 1; 8091da177e4SLinus Torvalds scount++; 8101da177e4SLinus Torvalds break; 8111da177e4SLinus Torvalds } 8121da177e4SLinus Torvalds } 813ad12583fSDavid L Stevens if (!scount) { 814ad12583fSDavid L Stevens pmc->gsquery = 0; 815ad12583fSDavid L Stevens return 0; 816ad12583fSDavid L Stevens } 817ad12583fSDavid L Stevens pmc->gsquery = 1; 818ad12583fSDavid L Stevens return 1; 8191da177e4SLinus Torvalds } 8201da177e4SLinus Torvalds 821d679c532SEric Dumazet /* return true if packet was dropped */ 822d679c532SEric Dumazet static bool igmp_heard_report(struct in_device *in_dev, __be32 group) 8231da177e4SLinus Torvalds { 8241da177e4SLinus Torvalds struct ip_mc_list *im; 8251da177e4SLinus Torvalds 8261da177e4SLinus Torvalds /* Timers are only set for non-local groups */ 8271da177e4SLinus Torvalds 8281da177e4SLinus Torvalds if (group == IGMP_ALL_HOSTS) 829d679c532SEric Dumazet return false; 8301da177e4SLinus Torvalds 8311d7138deSEric Dumazet rcu_read_lock(); 8321d7138deSEric Dumazet for_each_pmc_rcu(in_dev, im) { 8331da177e4SLinus Torvalds if (im->multiaddr == group) { 8341da177e4SLinus Torvalds igmp_stop_timer(im); 8351da177e4SLinus Torvalds break; 8361da177e4SLinus Torvalds } 8371da177e4SLinus Torvalds } 8381d7138deSEric Dumazet rcu_read_unlock(); 839d679c532SEric Dumazet return false; 8401da177e4SLinus Torvalds } 8411da177e4SLinus Torvalds 842d679c532SEric Dumazet /* return true if packet was dropped */ 843d679c532SEric Dumazet static bool igmp_heard_query(struct in_device *in_dev, struct sk_buff *skb, 8441da177e4SLinus Torvalds int len) 8451da177e4SLinus Torvalds { 846d9edf9e2SArnaldo Carvalho de Melo struct igmphdr *ih = igmp_hdr(skb); 847d9edf9e2SArnaldo Carvalho de Melo struct igmpv3_query *ih3 = igmpv3_query_hdr(skb); 8481da177e4SLinus Torvalds struct ip_mc_list *im; 84963007727SAl Viro __be32 group = ih->group; 8501da177e4SLinus Torvalds int max_delay; 8511da177e4SLinus Torvalds int mark = 0; 8521da177e4SLinus Torvalds 8531da177e4SLinus Torvalds 8545b7c8406SDavid Stevens if (len == 8) { 8551da177e4SLinus Torvalds if (ih->code == 0) { 8561da177e4SLinus Torvalds /* Alas, old v1 router presents here. */ 8571da177e4SLinus Torvalds 8581da177e4SLinus Torvalds max_delay = IGMP_Query_Response_Interval; 8591da177e4SLinus Torvalds in_dev->mr_v1_seen = jiffies + 8601da177e4SLinus Torvalds IGMP_V1_Router_Present_Timeout; 8611da177e4SLinus Torvalds group = 0; 8621da177e4SLinus Torvalds } else { 8631da177e4SLinus Torvalds /* v2 router present */ 8641da177e4SLinus Torvalds max_delay = ih->code*(HZ/IGMP_TIMER_SCALE); 8651da177e4SLinus Torvalds in_dev->mr_v2_seen = jiffies + 8661da177e4SLinus Torvalds IGMP_V2_Router_Present_Timeout; 8671da177e4SLinus Torvalds } 8681da177e4SLinus Torvalds /* cancel the interface change timer */ 8691da177e4SLinus Torvalds in_dev->mr_ifc_count = 0; 8701da177e4SLinus Torvalds if (del_timer(&in_dev->mr_ifc_timer)) 8711da177e4SLinus Torvalds __in_dev_put(in_dev); 8721da177e4SLinus Torvalds /* clear deleted report items */ 8731da177e4SLinus Torvalds igmpv3_clear_delrec(in_dev); 8741da177e4SLinus Torvalds } else if (len < 12) { 875d679c532SEric Dumazet return true; /* ignore bogus packet; freed by caller */ 8765b7c8406SDavid Stevens } else if (IGMP_V1_SEEN(in_dev)) { 8775b7c8406SDavid Stevens /* This is a v3 query with v1 queriers present */ 8785b7c8406SDavid Stevens max_delay = IGMP_Query_Response_Interval; 8795b7c8406SDavid Stevens group = 0; 8805b7c8406SDavid Stevens } else if (IGMP_V2_SEEN(in_dev)) { 8815b7c8406SDavid Stevens /* this is a v3 query with v2 queriers present; 8825b7c8406SDavid Stevens * Interpretation of the max_delay code is problematic here. 8835b7c8406SDavid Stevens * A real v2 host would use ih_code directly, while v3 has a 8845b7c8406SDavid Stevens * different encoding. We use the v3 encoding as more likely 8855b7c8406SDavid Stevens * to be intended in a v3 query. 8865b7c8406SDavid Stevens */ 8875b7c8406SDavid Stevens max_delay = IGMPV3_MRC(ih3->code)*(HZ/IGMP_TIMER_SCALE); 888a8c1f65cSBen Hutchings if (!max_delay) 889a8c1f65cSBen Hutchings max_delay = 1; /* can't mod w/ 0 */ 8901da177e4SLinus Torvalds } else { /* v3 */ 8911da177e4SLinus Torvalds if (!pskb_may_pull(skb, sizeof(struct igmpv3_query))) 892d679c532SEric Dumazet return true; 8931da177e4SLinus Torvalds 894d9edf9e2SArnaldo Carvalho de Melo ih3 = igmpv3_query_hdr(skb); 8951da177e4SLinus Torvalds if (ih3->nsrcs) { 8961da177e4SLinus Torvalds if (!pskb_may_pull(skb, sizeof(struct igmpv3_query) 89763007727SAl Viro + ntohs(ih3->nsrcs)*sizeof(__be32))) 898d679c532SEric Dumazet return true; 899d9edf9e2SArnaldo Carvalho de Melo ih3 = igmpv3_query_hdr(skb); 9001da177e4SLinus Torvalds } 9011da177e4SLinus Torvalds 9021da177e4SLinus Torvalds max_delay = IGMPV3_MRC(ih3->code)*(HZ/IGMP_TIMER_SCALE); 9031da177e4SLinus Torvalds if (!max_delay) 9041da177e4SLinus Torvalds max_delay = 1; /* can't mod w/ 0 */ 9051da177e4SLinus Torvalds in_dev->mr_maxdelay = max_delay; 9061da177e4SLinus Torvalds if (ih3->qrv) 9071da177e4SLinus Torvalds in_dev->mr_qrv = ih3->qrv; 9081da177e4SLinus Torvalds if (!group) { /* general query */ 9091da177e4SLinus Torvalds if (ih3->nsrcs) 910d679c532SEric Dumazet return false; /* no sources allowed */ 9111da177e4SLinus Torvalds igmp_gq_start_timer(in_dev); 912d679c532SEric Dumazet return false; 9131da177e4SLinus Torvalds } 9141da177e4SLinus Torvalds /* mark sources to include, if group & source-specific */ 9151da177e4SLinus Torvalds mark = ih3->nsrcs != 0; 9161da177e4SLinus Torvalds } 9171da177e4SLinus Torvalds 9181da177e4SLinus Torvalds /* 9191da177e4SLinus Torvalds * - Start the timers in all of our membership records 9201da177e4SLinus Torvalds * that the query applies to for the interface on 9211da177e4SLinus Torvalds * which the query arrived excl. those that belong 9221da177e4SLinus Torvalds * to a "local" group (224.0.0.X) 9231da177e4SLinus Torvalds * - For timers already running check if they need to 9241da177e4SLinus Torvalds * be reset. 9251da177e4SLinus Torvalds * - Use the igmp->igmp_code field as the maximum 9261da177e4SLinus Torvalds * delay possible 9271da177e4SLinus Torvalds */ 9281d7138deSEric Dumazet rcu_read_lock(); 9291d7138deSEric Dumazet for_each_pmc_rcu(in_dev, im) { 930ad12583fSDavid L Stevens int changed; 931ad12583fSDavid L Stevens 9321da177e4SLinus Torvalds if (group && group != im->multiaddr) 9331da177e4SLinus Torvalds continue; 9341da177e4SLinus Torvalds if (im->multiaddr == IGMP_ALL_HOSTS) 9351da177e4SLinus Torvalds continue; 9361da177e4SLinus Torvalds spin_lock_bh(&im->lock); 9371da177e4SLinus Torvalds if (im->tm_running) 9381da177e4SLinus Torvalds im->gsquery = im->gsquery && mark; 9391da177e4SLinus Torvalds else 9401da177e4SLinus Torvalds im->gsquery = mark; 941ad12583fSDavid L Stevens changed = !im->gsquery || 9421da177e4SLinus Torvalds igmp_marksources(im, ntohs(ih3->nsrcs), ih3->srcs); 9431da177e4SLinus Torvalds spin_unlock_bh(&im->lock); 944ad12583fSDavid L Stevens if (changed) 9451da177e4SLinus Torvalds igmp_mod_timer(im, max_delay); 9461da177e4SLinus Torvalds } 9471d7138deSEric Dumazet rcu_read_unlock(); 948d679c532SEric Dumazet return false; 9491da177e4SLinus Torvalds } 9501da177e4SLinus Torvalds 9519a57a9d2SEric Dumazet /* called in rcu_read_lock() section */ 9521da177e4SLinus Torvalds int igmp_rcv(struct sk_buff *skb) 9531da177e4SLinus Torvalds { 9541da177e4SLinus Torvalds /* This basically follows the spec line by line -- see RFC1112 */ 9551da177e4SLinus Torvalds struct igmphdr *ih; 9569a57a9d2SEric Dumazet struct in_device *in_dev = __in_dev_get_rcu(skb->dev); 9571da177e4SLinus Torvalds int len = skb->len; 958d679c532SEric Dumazet bool dropped = true; 9591da177e4SLinus Torvalds 960cd557bc1SDenis V. Lunev if (in_dev == NULL) 961cd557bc1SDenis V. Lunev goto drop; 9621da177e4SLinus Torvalds 963fb286bb2SHerbert Xu if (!pskb_may_pull(skb, sizeof(struct igmphdr))) 9649a57a9d2SEric Dumazet goto drop; 965fb286bb2SHerbert Xu 966fb286bb2SHerbert Xu switch (skb->ip_summed) { 96784fa7933SPatrick McHardy case CHECKSUM_COMPLETE: 968d3bc23e7SAl Viro if (!csum_fold(skb->csum)) 969fb286bb2SHerbert Xu break; 970fb286bb2SHerbert Xu /* fall through */ 971fb286bb2SHerbert Xu case CHECKSUM_NONE: 972fb286bb2SHerbert Xu skb->csum = 0; 973fb286bb2SHerbert Xu if (__skb_checksum_complete(skb)) 9749a57a9d2SEric Dumazet goto drop; 9751da177e4SLinus Torvalds } 9761da177e4SLinus Torvalds 977d9edf9e2SArnaldo Carvalho de Melo ih = igmp_hdr(skb); 9781da177e4SLinus Torvalds switch (ih->type) { 9791da177e4SLinus Torvalds case IGMP_HOST_MEMBERSHIP_QUERY: 980d679c532SEric Dumazet dropped = igmp_heard_query(in_dev, skb, len); 9811da177e4SLinus Torvalds break; 9821da177e4SLinus Torvalds case IGMP_HOST_MEMBERSHIP_REPORT: 9831da177e4SLinus Torvalds case IGMPV2_HOST_MEMBERSHIP_REPORT: 9841da177e4SLinus Torvalds /* Is it our report looped back? */ 985c7537967SDavid S. Miller if (rt_is_output_route(skb_rtable(skb))) 9861da177e4SLinus Torvalds break; 98724c69275SDavid Stevens /* don't rely on MC router hearing unicast reports */ 98824c69275SDavid Stevens if (skb->pkt_type == PACKET_MULTICAST || 98924c69275SDavid Stevens skb->pkt_type == PACKET_BROADCAST) 990d679c532SEric Dumazet dropped = igmp_heard_report(in_dev, ih->group); 9911da177e4SLinus Torvalds break; 9921da177e4SLinus Torvalds case IGMP_PIM: 9931da177e4SLinus Torvalds #ifdef CONFIG_IP_PIMSM_V1 9941da177e4SLinus Torvalds return pim_rcv_v1(skb); 9951da177e4SLinus Torvalds #endif 996c6b471e6SHerbert Xu case IGMPV3_HOST_MEMBERSHIP_REPORT: 9971da177e4SLinus Torvalds case IGMP_DVMRP: 9981da177e4SLinus Torvalds case IGMP_TRACE: 9991da177e4SLinus Torvalds case IGMP_HOST_LEAVE_MESSAGE: 10001da177e4SLinus Torvalds case IGMP_MTRACE: 10011da177e4SLinus Torvalds case IGMP_MTRACE_RESP: 10021da177e4SLinus Torvalds break; 10031da177e4SLinus Torvalds default: 1004dd1c1853SLinus Torvalds break; 10051da177e4SLinus Torvalds } 1006fb286bb2SHerbert Xu 1007cd557bc1SDenis V. Lunev drop: 1008d679c532SEric Dumazet if (dropped) 10091da177e4SLinus Torvalds kfree_skb(skb); 1010d679c532SEric Dumazet else 1011d679c532SEric Dumazet consume_skb(skb); 10121da177e4SLinus Torvalds return 0; 10131da177e4SLinus Torvalds } 10141da177e4SLinus Torvalds 10151da177e4SLinus Torvalds #endif 10161da177e4SLinus Torvalds 10171da177e4SLinus Torvalds 10181da177e4SLinus Torvalds /* 10191da177e4SLinus Torvalds * Add a filter to a device 10201da177e4SLinus Torvalds */ 10211da177e4SLinus Torvalds 102263007727SAl Viro static void ip_mc_filter_add(struct in_device *in_dev, __be32 addr) 10231da177e4SLinus Torvalds { 10241da177e4SLinus Torvalds char buf[MAX_ADDR_LEN]; 10251da177e4SLinus Torvalds struct net_device *dev = in_dev->dev; 10261da177e4SLinus Torvalds 10271da177e4SLinus Torvalds /* Checking for IFF_MULTICAST here is WRONG-WRONG-WRONG. 10281da177e4SLinus Torvalds We will get multicast token leakage, when IFF_MULTICAST 1029b81693d9SJiri Pirko is changed. This check should be done in ndo_set_rx_mode 10301da177e4SLinus Torvalds routine. Something sort of: 10311da177e4SLinus Torvalds if (dev->mc_list && dev->flags&IFF_MULTICAST) { do it; } 10321da177e4SLinus Torvalds --ANK 10331da177e4SLinus Torvalds */ 10341da177e4SLinus Torvalds if (arp_mc_map(addr, buf, dev, 0) == 0) 103522bedad3SJiri Pirko dev_mc_add(dev, buf); 10361da177e4SLinus Torvalds } 10371da177e4SLinus Torvalds 10381da177e4SLinus Torvalds /* 10391da177e4SLinus Torvalds * Remove a filter from a device 10401da177e4SLinus Torvalds */ 10411da177e4SLinus Torvalds 104263007727SAl Viro static void ip_mc_filter_del(struct in_device *in_dev, __be32 addr) 10431da177e4SLinus Torvalds { 10441da177e4SLinus Torvalds char buf[MAX_ADDR_LEN]; 10451da177e4SLinus Torvalds struct net_device *dev = in_dev->dev; 10461da177e4SLinus Torvalds 10471da177e4SLinus Torvalds if (arp_mc_map(addr, buf, dev, 0) == 0) 104822bedad3SJiri Pirko dev_mc_del(dev, buf); 10491da177e4SLinus Torvalds } 10501da177e4SLinus Torvalds 10511da177e4SLinus Torvalds #ifdef CONFIG_IP_MULTICAST 10521da177e4SLinus Torvalds /* 10531da177e4SLinus Torvalds * deleted ip_mc_list manipulation 10541da177e4SLinus Torvalds */ 10551da177e4SLinus Torvalds static void igmpv3_add_delrec(struct in_device *in_dev, struct ip_mc_list *im) 10561da177e4SLinus Torvalds { 10571da177e4SLinus Torvalds struct ip_mc_list *pmc; 10581da177e4SLinus Torvalds 10591da177e4SLinus Torvalds /* this is an "ip_mc_list" for convenience; only the fields below 10601da177e4SLinus Torvalds * are actually used. In particular, the refcnt and users are not 10611da177e4SLinus Torvalds * used for management of the delete list. Using the same structure 10621da177e4SLinus Torvalds * for deleted items allows change reports to use common code with 10631da177e4SLinus Torvalds * non-deleted or query-response MCA's. 10641da177e4SLinus Torvalds */ 10650da974f4SPanagiotis Issaris pmc = kzalloc(sizeof(*pmc), GFP_KERNEL); 10661da177e4SLinus Torvalds if (!pmc) 10671da177e4SLinus Torvalds return; 10681da177e4SLinus Torvalds spin_lock_bh(&im->lock); 10691da177e4SLinus Torvalds pmc->interface = im->interface; 10701da177e4SLinus Torvalds in_dev_hold(in_dev); 10711da177e4SLinus Torvalds pmc->multiaddr = im->multiaddr; 10721da177e4SLinus Torvalds pmc->crcount = in_dev->mr_qrv ? in_dev->mr_qrv : 10731da177e4SLinus Torvalds IGMP_Unsolicited_Report_Count; 10741da177e4SLinus Torvalds pmc->sfmode = im->sfmode; 10751da177e4SLinus Torvalds if (pmc->sfmode == MCAST_INCLUDE) { 10761da177e4SLinus Torvalds struct ip_sf_list *psf; 10771da177e4SLinus Torvalds 10781da177e4SLinus Torvalds pmc->tomb = im->tomb; 10791da177e4SLinus Torvalds pmc->sources = im->sources; 10801da177e4SLinus Torvalds im->tomb = im->sources = NULL; 10811da177e4SLinus Torvalds for (psf=pmc->sources; psf; psf=psf->sf_next) 10821da177e4SLinus Torvalds psf->sf_crcount = pmc->crcount; 10831da177e4SLinus Torvalds } 10841da177e4SLinus Torvalds spin_unlock_bh(&im->lock); 10851da177e4SLinus Torvalds 10861da177e4SLinus Torvalds spin_lock_bh(&in_dev->mc_tomb_lock); 10871da177e4SLinus Torvalds pmc->next = in_dev->mc_tomb; 10881da177e4SLinus Torvalds in_dev->mc_tomb = pmc; 10891da177e4SLinus Torvalds spin_unlock_bh(&in_dev->mc_tomb_lock); 10901da177e4SLinus Torvalds } 10911da177e4SLinus Torvalds 109263007727SAl Viro static void igmpv3_del_delrec(struct in_device *in_dev, __be32 multiaddr) 10931da177e4SLinus Torvalds { 10941da177e4SLinus Torvalds struct ip_mc_list *pmc, *pmc_prev; 10951da177e4SLinus Torvalds struct ip_sf_list *psf, *psf_next; 10961da177e4SLinus Torvalds 10971da177e4SLinus Torvalds spin_lock_bh(&in_dev->mc_tomb_lock); 10981da177e4SLinus Torvalds pmc_prev = NULL; 10991da177e4SLinus Torvalds for (pmc=in_dev->mc_tomb; pmc; pmc=pmc->next) { 11001da177e4SLinus Torvalds if (pmc->multiaddr == multiaddr) 11011da177e4SLinus Torvalds break; 11021da177e4SLinus Torvalds pmc_prev = pmc; 11031da177e4SLinus Torvalds } 11041da177e4SLinus Torvalds if (pmc) { 11051da177e4SLinus Torvalds if (pmc_prev) 11061da177e4SLinus Torvalds pmc_prev->next = pmc->next; 11071da177e4SLinus Torvalds else 11081da177e4SLinus Torvalds in_dev->mc_tomb = pmc->next; 11091da177e4SLinus Torvalds } 11101da177e4SLinus Torvalds spin_unlock_bh(&in_dev->mc_tomb_lock); 11111da177e4SLinus Torvalds if (pmc) { 11121da177e4SLinus Torvalds for (psf=pmc->tomb; psf; psf=psf_next) { 11131da177e4SLinus Torvalds psf_next = psf->sf_next; 11141da177e4SLinus Torvalds kfree(psf); 11151da177e4SLinus Torvalds } 11161da177e4SLinus Torvalds in_dev_put(pmc->interface); 11171da177e4SLinus Torvalds kfree(pmc); 11181da177e4SLinus Torvalds } 11191da177e4SLinus Torvalds } 11201da177e4SLinus Torvalds 11211da177e4SLinus Torvalds static void igmpv3_clear_delrec(struct in_device *in_dev) 11221da177e4SLinus Torvalds { 11231da177e4SLinus Torvalds struct ip_mc_list *pmc, *nextpmc; 11241da177e4SLinus Torvalds 11251da177e4SLinus Torvalds spin_lock_bh(&in_dev->mc_tomb_lock); 11261da177e4SLinus Torvalds pmc = in_dev->mc_tomb; 11271da177e4SLinus Torvalds in_dev->mc_tomb = NULL; 11281da177e4SLinus Torvalds spin_unlock_bh(&in_dev->mc_tomb_lock); 11291da177e4SLinus Torvalds 11301da177e4SLinus Torvalds for (; pmc; pmc = nextpmc) { 11311da177e4SLinus Torvalds nextpmc = pmc->next; 11321da177e4SLinus Torvalds ip_mc_clear_src(pmc); 11331da177e4SLinus Torvalds in_dev_put(pmc->interface); 11341da177e4SLinus Torvalds kfree(pmc); 11351da177e4SLinus Torvalds } 11361da177e4SLinus Torvalds /* clear dead sources, too */ 11371d7138deSEric Dumazet rcu_read_lock(); 11381d7138deSEric Dumazet for_each_pmc_rcu(in_dev, pmc) { 11391da177e4SLinus Torvalds struct ip_sf_list *psf, *psf_next; 11401da177e4SLinus Torvalds 11411da177e4SLinus Torvalds spin_lock_bh(&pmc->lock); 11421da177e4SLinus Torvalds psf = pmc->tomb; 11431da177e4SLinus Torvalds pmc->tomb = NULL; 11441da177e4SLinus Torvalds spin_unlock_bh(&pmc->lock); 11451da177e4SLinus Torvalds for (; psf; psf=psf_next) { 11461da177e4SLinus Torvalds psf_next = psf->sf_next; 11471da177e4SLinus Torvalds kfree(psf); 11481da177e4SLinus Torvalds } 11491da177e4SLinus Torvalds } 11501d7138deSEric Dumazet rcu_read_unlock(); 11511da177e4SLinus Torvalds } 11521da177e4SLinus Torvalds #endif 11531da177e4SLinus Torvalds 11541da177e4SLinus Torvalds static void igmp_group_dropped(struct ip_mc_list *im) 11551da177e4SLinus Torvalds { 11561da177e4SLinus Torvalds struct in_device *in_dev = im->interface; 11571da177e4SLinus Torvalds #ifdef CONFIG_IP_MULTICAST 11581da177e4SLinus Torvalds int reporter; 11591da177e4SLinus Torvalds #endif 11601da177e4SLinus Torvalds 11611da177e4SLinus Torvalds if (im->loaded) { 11621da177e4SLinus Torvalds im->loaded = 0; 11631da177e4SLinus Torvalds ip_mc_filter_del(in_dev, im->multiaddr); 11641da177e4SLinus Torvalds } 11651da177e4SLinus Torvalds 11661da177e4SLinus Torvalds #ifdef CONFIG_IP_MULTICAST 11671da177e4SLinus Torvalds if (im->multiaddr == IGMP_ALL_HOSTS) 11681da177e4SLinus Torvalds return; 11691da177e4SLinus Torvalds 11701da177e4SLinus Torvalds reporter = im->reporter; 11711da177e4SLinus Torvalds igmp_stop_timer(im); 11721da177e4SLinus Torvalds 11731da177e4SLinus Torvalds if (!in_dev->dead) { 11741da177e4SLinus Torvalds if (IGMP_V1_SEEN(in_dev)) 117524cf3af3SVeaceslav Falico return; 11761da177e4SLinus Torvalds if (IGMP_V2_SEEN(in_dev)) { 11771da177e4SLinus Torvalds if (reporter) 11781da177e4SLinus Torvalds igmp_send_report(in_dev, im, IGMP_HOST_LEAVE_MESSAGE); 117924cf3af3SVeaceslav Falico return; 11801da177e4SLinus Torvalds } 11811da177e4SLinus Torvalds /* IGMPv3 */ 11821da177e4SLinus Torvalds igmpv3_add_delrec(in_dev, im); 11831da177e4SLinus Torvalds 11841da177e4SLinus Torvalds igmp_ifc_event(in_dev); 11851da177e4SLinus Torvalds } 11861da177e4SLinus Torvalds #endif 11871da177e4SLinus Torvalds } 11881da177e4SLinus Torvalds 11891da177e4SLinus Torvalds static void igmp_group_added(struct ip_mc_list *im) 11901da177e4SLinus Torvalds { 11911da177e4SLinus Torvalds struct in_device *in_dev = im->interface; 11921da177e4SLinus Torvalds 11931da177e4SLinus Torvalds if (im->loaded == 0) { 11941da177e4SLinus Torvalds im->loaded = 1; 11951da177e4SLinus Torvalds ip_mc_filter_add(in_dev, im->multiaddr); 11961da177e4SLinus Torvalds } 11971da177e4SLinus Torvalds 11981da177e4SLinus Torvalds #ifdef CONFIG_IP_MULTICAST 11991da177e4SLinus Torvalds if (im->multiaddr == IGMP_ALL_HOSTS) 12001da177e4SLinus Torvalds return; 12011da177e4SLinus Torvalds 12021da177e4SLinus Torvalds if (in_dev->dead) 12031da177e4SLinus Torvalds return; 12041da177e4SLinus Torvalds if (IGMP_V1_SEEN(in_dev) || IGMP_V2_SEEN(in_dev)) { 12051da177e4SLinus Torvalds spin_lock_bh(&im->lock); 12061da177e4SLinus Torvalds igmp_start_timer(im, IGMP_Initial_Report_Delay); 12071da177e4SLinus Torvalds spin_unlock_bh(&im->lock); 12081da177e4SLinus Torvalds return; 12091da177e4SLinus Torvalds } 12101da177e4SLinus Torvalds /* else, v3 */ 12111da177e4SLinus Torvalds 12121da177e4SLinus Torvalds im->crcount = in_dev->mr_qrv ? in_dev->mr_qrv : 12131da177e4SLinus Torvalds IGMP_Unsolicited_Report_Count; 12141da177e4SLinus Torvalds igmp_ifc_event(in_dev); 12151da177e4SLinus Torvalds #endif 12161da177e4SLinus Torvalds } 12171da177e4SLinus Torvalds 12181da177e4SLinus Torvalds 12191da177e4SLinus Torvalds /* 12201da177e4SLinus Torvalds * Multicast list managers 12211da177e4SLinus Torvalds */ 12221da177e4SLinus Torvalds 1223e9897071SEric Dumazet static u32 ip_mc_hash(const struct ip_mc_list *im) 1224e9897071SEric Dumazet { 1225c70eba74SEric Dumazet return hash_32((__force u32)im->multiaddr, MC_HASH_SZ_LOG); 1226e9897071SEric Dumazet } 1227e9897071SEric Dumazet 1228e9897071SEric Dumazet static void ip_mc_hash_add(struct in_device *in_dev, 1229e9897071SEric Dumazet struct ip_mc_list *im) 1230e9897071SEric Dumazet { 1231e9897071SEric Dumazet struct ip_mc_list __rcu **mc_hash; 1232e9897071SEric Dumazet u32 hash; 1233e9897071SEric Dumazet 1234e9897071SEric Dumazet mc_hash = rtnl_dereference(in_dev->mc_hash); 1235e9897071SEric Dumazet if (mc_hash) { 1236e9897071SEric Dumazet hash = ip_mc_hash(im); 1237c70eba74SEric Dumazet im->next_hash = mc_hash[hash]; 1238e9897071SEric Dumazet rcu_assign_pointer(mc_hash[hash], im); 1239e9897071SEric Dumazet return; 1240e9897071SEric Dumazet } 1241e9897071SEric Dumazet 1242e9897071SEric Dumazet /* do not use a hash table for small number of items */ 1243e9897071SEric Dumazet if (in_dev->mc_count < 4) 1244e9897071SEric Dumazet return; 1245e9897071SEric Dumazet 1246e9897071SEric Dumazet mc_hash = kzalloc(sizeof(struct ip_mc_list *) << MC_HASH_SZ_LOG, 1247e9897071SEric Dumazet GFP_KERNEL); 1248e9897071SEric Dumazet if (!mc_hash) 1249e9897071SEric Dumazet return; 1250e9897071SEric Dumazet 1251e9897071SEric Dumazet for_each_pmc_rtnl(in_dev, im) { 1252e9897071SEric Dumazet hash = ip_mc_hash(im); 1253c70eba74SEric Dumazet im->next_hash = mc_hash[hash]; 1254e9897071SEric Dumazet RCU_INIT_POINTER(mc_hash[hash], im); 1255e9897071SEric Dumazet } 1256e9897071SEric Dumazet 1257e9897071SEric Dumazet rcu_assign_pointer(in_dev->mc_hash, mc_hash); 1258e9897071SEric Dumazet } 1259e9897071SEric Dumazet 1260e9897071SEric Dumazet static void ip_mc_hash_remove(struct in_device *in_dev, 1261e9897071SEric Dumazet struct ip_mc_list *im) 1262e9897071SEric Dumazet { 1263e9897071SEric Dumazet struct ip_mc_list __rcu **mc_hash = rtnl_dereference(in_dev->mc_hash); 1264e9897071SEric Dumazet struct ip_mc_list *aux; 1265e9897071SEric Dumazet 1266e9897071SEric Dumazet if (!mc_hash) 1267e9897071SEric Dumazet return; 1268e9897071SEric Dumazet mc_hash += ip_mc_hash(im); 1269e9897071SEric Dumazet while ((aux = rtnl_dereference(*mc_hash)) != im) 1270e9897071SEric Dumazet mc_hash = &aux->next_hash; 1271e9897071SEric Dumazet *mc_hash = im->next_hash; 1272e9897071SEric Dumazet } 1273e9897071SEric Dumazet 12741da177e4SLinus Torvalds 12751da177e4SLinus Torvalds /* 12761da177e4SLinus Torvalds * A socket has joined a multicast group on device dev. 12771da177e4SLinus Torvalds */ 12781da177e4SLinus Torvalds 12798f935bbdSAl Viro void ip_mc_inc_group(struct in_device *in_dev, __be32 addr) 12801da177e4SLinus Torvalds { 12811da177e4SLinus Torvalds struct ip_mc_list *im; 12821da177e4SLinus Torvalds 12831da177e4SLinus Torvalds ASSERT_RTNL(); 12841da177e4SLinus Torvalds 12851d7138deSEric Dumazet for_each_pmc_rtnl(in_dev, im) { 12861da177e4SLinus Torvalds if (im->multiaddr == addr) { 12871da177e4SLinus Torvalds im->users++; 12881da177e4SLinus Torvalds ip_mc_add_src(in_dev, &addr, MCAST_EXCLUDE, 0, NULL, 0); 12891da177e4SLinus Torvalds goto out; 12901da177e4SLinus Torvalds } 12911da177e4SLinus Torvalds } 12921da177e4SLinus Torvalds 12931d7138deSEric Dumazet im = kzalloc(sizeof(*im), GFP_KERNEL); 12941da177e4SLinus Torvalds if (!im) 12951da177e4SLinus Torvalds goto out; 12961da177e4SLinus Torvalds 12971da177e4SLinus Torvalds im->users = 1; 12981da177e4SLinus Torvalds im->interface = in_dev; 12991da177e4SLinus Torvalds in_dev_hold(in_dev); 13001da177e4SLinus Torvalds im->multiaddr = addr; 13011da177e4SLinus Torvalds /* initial mode is (EX, empty) */ 13021da177e4SLinus Torvalds im->sfmode = MCAST_EXCLUDE; 13031da177e4SLinus Torvalds im->sfcount[MCAST_EXCLUDE] = 1; 13041da177e4SLinus Torvalds atomic_set(&im->refcnt, 1); 13051da177e4SLinus Torvalds spin_lock_init(&im->lock); 13061da177e4SLinus Torvalds #ifdef CONFIG_IP_MULTICAST 1307b24b8a24SPavel Emelyanov setup_timer(&im->timer, &igmp_timer_expire, (unsigned long)im); 13081da177e4SLinus Torvalds im->unsolicit_count = IGMP_Unsolicited_Report_Count; 13091da177e4SLinus Torvalds #endif 13101d7138deSEric Dumazet 13111d7138deSEric Dumazet im->next_rcu = in_dev->mc_list; 1312b8bae41eSRami Rosen in_dev->mc_count++; 1313cf778b00SEric Dumazet rcu_assign_pointer(in_dev->mc_list, im); 13141d7138deSEric Dumazet 1315e9897071SEric Dumazet ip_mc_hash_add(in_dev, im); 1316e9897071SEric Dumazet 13171da177e4SLinus Torvalds #ifdef CONFIG_IP_MULTICAST 13181da177e4SLinus Torvalds igmpv3_del_delrec(in_dev, im->multiaddr); 13191da177e4SLinus Torvalds #endif 13201da177e4SLinus Torvalds igmp_group_added(im); 13211da177e4SLinus Torvalds if (!in_dev->dead) 13221da177e4SLinus Torvalds ip_rt_multicast_event(in_dev); 13231da177e4SLinus Torvalds out: 13241da177e4SLinus Torvalds return; 13251da177e4SLinus Torvalds } 13264bc2f18bSEric Dumazet EXPORT_SYMBOL(ip_mc_inc_group); 13271da177e4SLinus Torvalds 13281da177e4SLinus Torvalds /* 13294aa5dee4SJiri Pirko * Resend IGMP JOIN report; used by netdev notifier. 1330a816c7c7SJay Vosburgh */ 13314aa5dee4SJiri Pirko static void ip_mc_rejoin_groups(struct in_device *in_dev) 1332a816c7c7SJay Vosburgh { 133308882669SGeert Uytterhoeven #ifdef CONFIG_IP_MULTICAST 1334866f3b25SEric Dumazet struct ip_mc_list *im; 1335866f3b25SEric Dumazet int type; 1336a816c7c7SJay Vosburgh 13374aa5dee4SJiri Pirko ASSERT_RTNL(); 13384aa5dee4SJiri Pirko 13394aa5dee4SJiri Pirko for_each_pmc_rtnl(in_dev, im) { 1340a816c7c7SJay Vosburgh if (im->multiaddr == IGMP_ALL_HOSTS) 1341866f3b25SEric Dumazet continue; 1342a816c7c7SJay Vosburgh 1343e12b4539SFlavio Leitner /* a failover is happening and switches 1344866f3b25SEric Dumazet * must be notified immediately 1345866f3b25SEric Dumazet */ 1346e12b4539SFlavio Leitner if (IGMP_V1_SEEN(in_dev)) 1347866f3b25SEric Dumazet type = IGMP_HOST_MEMBERSHIP_REPORT; 1348e12b4539SFlavio Leitner else if (IGMP_V2_SEEN(in_dev)) 1349866f3b25SEric Dumazet type = IGMPV2_HOST_MEMBERSHIP_REPORT; 1350e12b4539SFlavio Leitner else 1351866f3b25SEric Dumazet type = IGMPV3_HOST_MEMBERSHIP_REPORT; 1352866f3b25SEric Dumazet igmp_send_report(in_dev, im, type); 1353866f3b25SEric Dumazet } 1354a816c7c7SJay Vosburgh #endif 1355a816c7c7SJay Vosburgh } 1356a816c7c7SJay Vosburgh 1357a816c7c7SJay Vosburgh /* 13581da177e4SLinus Torvalds * A socket has left a multicast group on device dev 13591da177e4SLinus Torvalds */ 13601da177e4SLinus Torvalds 13618f935bbdSAl Viro void ip_mc_dec_group(struct in_device *in_dev, __be32 addr) 13621da177e4SLinus Torvalds { 13631d7138deSEric Dumazet struct ip_mc_list *i; 13641d7138deSEric Dumazet struct ip_mc_list __rcu **ip; 13651da177e4SLinus Torvalds 13661da177e4SLinus Torvalds ASSERT_RTNL(); 13671da177e4SLinus Torvalds 13681d7138deSEric Dumazet for (ip = &in_dev->mc_list; 13691d7138deSEric Dumazet (i = rtnl_dereference(*ip)) != NULL; 13701d7138deSEric Dumazet ip = &i->next_rcu) { 13711da177e4SLinus Torvalds if (i->multiaddr == addr) { 13721da177e4SLinus Torvalds if (--i->users == 0) { 1373e9897071SEric Dumazet ip_mc_hash_remove(in_dev, i); 13741d7138deSEric Dumazet *ip = i->next_rcu; 1375b8bae41eSRami Rosen in_dev->mc_count--; 13761da177e4SLinus Torvalds igmp_group_dropped(i); 137724cf3af3SVeaceslav Falico ip_mc_clear_src(i); 13781da177e4SLinus Torvalds 13791da177e4SLinus Torvalds if (!in_dev->dead) 13801da177e4SLinus Torvalds ip_rt_multicast_event(in_dev); 13811da177e4SLinus Torvalds 13821da177e4SLinus Torvalds ip_ma_put(i); 13831da177e4SLinus Torvalds return; 13841da177e4SLinus Torvalds } 13851da177e4SLinus Torvalds break; 13861da177e4SLinus Torvalds } 13871da177e4SLinus Torvalds } 13881da177e4SLinus Torvalds } 13894bc2f18bSEric Dumazet EXPORT_SYMBOL(ip_mc_dec_group); 13901da177e4SLinus Torvalds 139175c78500SMoni Shoua /* Device changing type */ 139275c78500SMoni Shoua 139375c78500SMoni Shoua void ip_mc_unmap(struct in_device *in_dev) 139475c78500SMoni Shoua { 13951d7138deSEric Dumazet struct ip_mc_list *pmc; 139675c78500SMoni Shoua 139775c78500SMoni Shoua ASSERT_RTNL(); 139875c78500SMoni Shoua 13991d7138deSEric Dumazet for_each_pmc_rtnl(in_dev, pmc) 14001d7138deSEric Dumazet igmp_group_dropped(pmc); 140175c78500SMoni Shoua } 140275c78500SMoni Shoua 140375c78500SMoni Shoua void ip_mc_remap(struct in_device *in_dev) 140475c78500SMoni Shoua { 14051d7138deSEric Dumazet struct ip_mc_list *pmc; 140675c78500SMoni Shoua 140775c78500SMoni Shoua ASSERT_RTNL(); 140875c78500SMoni Shoua 14091d7138deSEric Dumazet for_each_pmc_rtnl(in_dev, pmc) 14101d7138deSEric Dumazet igmp_group_added(pmc); 141175c78500SMoni Shoua } 141275c78500SMoni Shoua 14131da177e4SLinus Torvalds /* Device going down */ 14141da177e4SLinus Torvalds 14151da177e4SLinus Torvalds void ip_mc_down(struct in_device *in_dev) 14161da177e4SLinus Torvalds { 14171d7138deSEric Dumazet struct ip_mc_list *pmc; 14181da177e4SLinus Torvalds 14191da177e4SLinus Torvalds ASSERT_RTNL(); 14201da177e4SLinus Torvalds 14211d7138deSEric Dumazet for_each_pmc_rtnl(in_dev, pmc) 14221d7138deSEric Dumazet igmp_group_dropped(pmc); 14231da177e4SLinus Torvalds 14241da177e4SLinus Torvalds #ifdef CONFIG_IP_MULTICAST 14251da177e4SLinus Torvalds in_dev->mr_ifc_count = 0; 14261da177e4SLinus Torvalds if (del_timer(&in_dev->mr_ifc_timer)) 14271da177e4SLinus Torvalds __in_dev_put(in_dev); 14281da177e4SLinus Torvalds in_dev->mr_gq_running = 0; 14291da177e4SLinus Torvalds if (del_timer(&in_dev->mr_gq_timer)) 14301da177e4SLinus Torvalds __in_dev_put(in_dev); 14311da177e4SLinus Torvalds igmpv3_clear_delrec(in_dev); 14321da177e4SLinus Torvalds #endif 14331da177e4SLinus Torvalds 14341da177e4SLinus Torvalds ip_mc_dec_group(in_dev, IGMP_ALL_HOSTS); 14351da177e4SLinus Torvalds } 14361da177e4SLinus Torvalds 14371da177e4SLinus Torvalds void ip_mc_init_dev(struct in_device *in_dev) 14381da177e4SLinus Torvalds { 14391da177e4SLinus Torvalds ASSERT_RTNL(); 14401da177e4SLinus Torvalds 14411da177e4SLinus Torvalds #ifdef CONFIG_IP_MULTICAST 1442b24b8a24SPavel Emelyanov setup_timer(&in_dev->mr_gq_timer, igmp_gq_timer_expire, 1443b24b8a24SPavel Emelyanov (unsigned long)in_dev); 1444b24b8a24SPavel Emelyanov setup_timer(&in_dev->mr_ifc_timer, igmp_ifc_timer_expire, 1445b24b8a24SPavel Emelyanov (unsigned long)in_dev); 14461da177e4SLinus Torvalds in_dev->mr_qrv = IGMP_Unsolicited_Report_Count; 14471da177e4SLinus Torvalds #endif 14481da177e4SLinus Torvalds 14491da177e4SLinus Torvalds spin_lock_init(&in_dev->mc_tomb_lock); 14501da177e4SLinus Torvalds } 14511da177e4SLinus Torvalds 14521da177e4SLinus Torvalds /* Device going up */ 14531da177e4SLinus Torvalds 14541da177e4SLinus Torvalds void ip_mc_up(struct in_device *in_dev) 14551da177e4SLinus Torvalds { 14561d7138deSEric Dumazet struct ip_mc_list *pmc; 14571da177e4SLinus Torvalds 14581da177e4SLinus Torvalds ASSERT_RTNL(); 14591da177e4SLinus Torvalds 14601da177e4SLinus Torvalds ip_mc_inc_group(in_dev, IGMP_ALL_HOSTS); 14611da177e4SLinus Torvalds 14621d7138deSEric Dumazet for_each_pmc_rtnl(in_dev, pmc) 14631d7138deSEric Dumazet igmp_group_added(pmc); 14641da177e4SLinus Torvalds } 14651da177e4SLinus Torvalds 14661da177e4SLinus Torvalds /* 14671da177e4SLinus Torvalds * Device is about to be destroyed: clean up. 14681da177e4SLinus Torvalds */ 14691da177e4SLinus Torvalds 14701da177e4SLinus Torvalds void ip_mc_destroy_dev(struct in_device *in_dev) 14711da177e4SLinus Torvalds { 14721da177e4SLinus Torvalds struct ip_mc_list *i; 14731da177e4SLinus Torvalds 14741da177e4SLinus Torvalds ASSERT_RTNL(); 14751da177e4SLinus Torvalds 14761da177e4SLinus Torvalds /* Deactivate timers */ 14771da177e4SLinus Torvalds ip_mc_down(in_dev); 14781da177e4SLinus Torvalds 14791d7138deSEric Dumazet while ((i = rtnl_dereference(in_dev->mc_list)) != NULL) { 14801d7138deSEric Dumazet in_dev->mc_list = i->next_rcu; 1481b8bae41eSRami Rosen in_dev->mc_count--; 14821d7138deSEric Dumazet 148324cf3af3SVeaceslav Falico /* We've dropped the groups in ip_mc_down already */ 148424cf3af3SVeaceslav Falico ip_mc_clear_src(i); 14851da177e4SLinus Torvalds ip_ma_put(i); 14861da177e4SLinus Torvalds } 14871da177e4SLinus Torvalds } 14881da177e4SLinus Torvalds 14899e917dcaSEric Dumazet /* RTNL is locked */ 1490877acedcSDaniel Lezcano static struct in_device *ip_mc_find_dev(struct net *net, struct ip_mreqn *imr) 14911da177e4SLinus Torvalds { 14921da177e4SLinus Torvalds struct net_device *dev = NULL; 14931da177e4SLinus Torvalds struct in_device *idev = NULL; 14941da177e4SLinus Torvalds 14951da177e4SLinus Torvalds if (imr->imr_ifindex) { 1496877acedcSDaniel Lezcano idev = inetdev_by_index(net, imr->imr_ifindex); 14971da177e4SLinus Torvalds return idev; 14981da177e4SLinus Torvalds } 14991da177e4SLinus Torvalds if (imr->imr_address.s_addr) { 15009e917dcaSEric Dumazet dev = __ip_dev_find(net, imr->imr_address.s_addr, false); 15011da177e4SLinus Torvalds if (!dev) 15021da177e4SLinus Torvalds return NULL; 15031da177e4SLinus Torvalds } 15041da177e4SLinus Torvalds 1505b23dd4feSDavid S. Miller if (!dev) { 150678fbfd8aSDavid S. Miller struct rtable *rt = ip_route_output(net, 150778fbfd8aSDavid S. Miller imr->imr_multiaddr.s_addr, 150878fbfd8aSDavid S. Miller 0, 0, 0); 1509b23dd4feSDavid S. Miller if (!IS_ERR(rt)) { 1510d8d1f30bSChangli Gao dev = rt->dst.dev; 15111da177e4SLinus Torvalds ip_rt_put(rt); 15121da177e4SLinus Torvalds } 1513b23dd4feSDavid S. Miller } 15141da177e4SLinus Torvalds if (dev) { 15151da177e4SLinus Torvalds imr->imr_ifindex = dev->ifindex; 1516e5ed6399SHerbert Xu idev = __in_dev_get_rtnl(dev); 15171da177e4SLinus Torvalds } 15181da177e4SLinus Torvalds return idev; 15191da177e4SLinus Torvalds } 15201da177e4SLinus Torvalds 15211da177e4SLinus Torvalds /* 15221da177e4SLinus Torvalds * Join a socket to a group 15231da177e4SLinus Torvalds */ 1524ab32ea5dSBrian Haley int sysctl_igmp_max_memberships __read_mostly = IP_MAX_MEMBERSHIPS; 1525ab32ea5dSBrian Haley int sysctl_igmp_max_msf __read_mostly = IP_MAX_MSF; 15261da177e4SLinus Torvalds 15271da177e4SLinus Torvalds 15281da177e4SLinus Torvalds static int ip_mc_del1_src(struct ip_mc_list *pmc, int sfmode, 15298f935bbdSAl Viro __be32 *psfsrc) 15301da177e4SLinus Torvalds { 15311da177e4SLinus Torvalds struct ip_sf_list *psf, *psf_prev; 15321da177e4SLinus Torvalds int rv = 0; 15331da177e4SLinus Torvalds 15341da177e4SLinus Torvalds psf_prev = NULL; 15351da177e4SLinus Torvalds for (psf=pmc->sources; psf; psf=psf->sf_next) { 15361da177e4SLinus Torvalds if (psf->sf_inaddr == *psfsrc) 15371da177e4SLinus Torvalds break; 15381da177e4SLinus Torvalds psf_prev = psf; 15391da177e4SLinus Torvalds } 15401da177e4SLinus Torvalds if (!psf || psf->sf_count[sfmode] == 0) { 15411da177e4SLinus Torvalds /* source filter not found, or count wrong => bug */ 15421da177e4SLinus Torvalds return -ESRCH; 15431da177e4SLinus Torvalds } 15441da177e4SLinus Torvalds psf->sf_count[sfmode]--; 15451da177e4SLinus Torvalds if (psf->sf_count[sfmode] == 0) { 15461da177e4SLinus Torvalds ip_rt_multicast_event(pmc->interface); 15471da177e4SLinus Torvalds } 15481da177e4SLinus Torvalds if (!psf->sf_count[MCAST_INCLUDE] && !psf->sf_count[MCAST_EXCLUDE]) { 15491da177e4SLinus Torvalds #ifdef CONFIG_IP_MULTICAST 15501da177e4SLinus Torvalds struct in_device *in_dev = pmc->interface; 15511da177e4SLinus Torvalds #endif 15521da177e4SLinus Torvalds 15531da177e4SLinus Torvalds /* no more filters for this source */ 15541da177e4SLinus Torvalds if (psf_prev) 15551da177e4SLinus Torvalds psf_prev->sf_next = psf->sf_next; 15561da177e4SLinus Torvalds else 15571da177e4SLinus Torvalds pmc->sources = psf->sf_next; 15581da177e4SLinus Torvalds #ifdef CONFIG_IP_MULTICAST 15591da177e4SLinus Torvalds if (psf->sf_oldin && 15601da177e4SLinus Torvalds !IGMP_V1_SEEN(in_dev) && !IGMP_V2_SEEN(in_dev)) { 15611da177e4SLinus Torvalds psf->sf_crcount = in_dev->mr_qrv ? in_dev->mr_qrv : 15621da177e4SLinus Torvalds IGMP_Unsolicited_Report_Count; 15631da177e4SLinus Torvalds psf->sf_next = pmc->tomb; 15641da177e4SLinus Torvalds pmc->tomb = psf; 15651da177e4SLinus Torvalds rv = 1; 15661da177e4SLinus Torvalds } else 15671da177e4SLinus Torvalds #endif 15681da177e4SLinus Torvalds kfree(psf); 15691da177e4SLinus Torvalds } 15701da177e4SLinus Torvalds return rv; 15711da177e4SLinus Torvalds } 15721da177e4SLinus Torvalds 15731da177e4SLinus Torvalds #ifndef CONFIG_IP_MULTICAST 15741da177e4SLinus Torvalds #define igmp_ifc_event(x) do { } while (0) 15751da177e4SLinus Torvalds #endif 15761da177e4SLinus Torvalds 15778f935bbdSAl Viro static int ip_mc_del_src(struct in_device *in_dev, __be32 *pmca, int sfmode, 15788f935bbdSAl Viro int sfcount, __be32 *psfsrc, int delta) 15791da177e4SLinus Torvalds { 15801da177e4SLinus Torvalds struct ip_mc_list *pmc; 15811da177e4SLinus Torvalds int changerec = 0; 15821da177e4SLinus Torvalds int i, err; 15831da177e4SLinus Torvalds 15841da177e4SLinus Torvalds if (!in_dev) 15851da177e4SLinus Torvalds return -ENODEV; 15861d7138deSEric Dumazet rcu_read_lock(); 15871d7138deSEric Dumazet for_each_pmc_rcu(in_dev, pmc) { 15881da177e4SLinus Torvalds if (*pmca == pmc->multiaddr) 15891da177e4SLinus Torvalds break; 15901da177e4SLinus Torvalds } 15911da177e4SLinus Torvalds if (!pmc) { 15921da177e4SLinus Torvalds /* MCA not found?? bug */ 15931d7138deSEric Dumazet rcu_read_unlock(); 15941da177e4SLinus Torvalds return -ESRCH; 15951da177e4SLinus Torvalds } 15961da177e4SLinus Torvalds spin_lock_bh(&pmc->lock); 15971d7138deSEric Dumazet rcu_read_unlock(); 15981da177e4SLinus Torvalds #ifdef CONFIG_IP_MULTICAST 15991da177e4SLinus Torvalds sf_markstate(pmc); 16001da177e4SLinus Torvalds #endif 16011da177e4SLinus Torvalds if (!delta) { 16021da177e4SLinus Torvalds err = -EINVAL; 16031da177e4SLinus Torvalds if (!pmc->sfcount[sfmode]) 16041da177e4SLinus Torvalds goto out_unlock; 16051da177e4SLinus Torvalds pmc->sfcount[sfmode]--; 16061da177e4SLinus Torvalds } 16071da177e4SLinus Torvalds err = 0; 16081da177e4SLinus Torvalds for (i=0; i<sfcount; i++) { 16091da177e4SLinus Torvalds int rv = ip_mc_del1_src(pmc, sfmode, &psfsrc[i]); 16101da177e4SLinus Torvalds 16111da177e4SLinus Torvalds changerec |= rv > 0; 16121da177e4SLinus Torvalds if (!err && rv < 0) 16131da177e4SLinus Torvalds err = rv; 16141da177e4SLinus Torvalds } 16151da177e4SLinus Torvalds if (pmc->sfmode == MCAST_EXCLUDE && 16161da177e4SLinus Torvalds pmc->sfcount[MCAST_EXCLUDE] == 0 && 16171da177e4SLinus Torvalds pmc->sfcount[MCAST_INCLUDE]) { 16181da177e4SLinus Torvalds #ifdef CONFIG_IP_MULTICAST 16191da177e4SLinus Torvalds struct ip_sf_list *psf; 16201da177e4SLinus Torvalds #endif 16211da177e4SLinus Torvalds 16221da177e4SLinus Torvalds /* filter mode change */ 16231da177e4SLinus Torvalds pmc->sfmode = MCAST_INCLUDE; 16241da177e4SLinus Torvalds #ifdef CONFIG_IP_MULTICAST 16251da177e4SLinus Torvalds pmc->crcount = in_dev->mr_qrv ? in_dev->mr_qrv : 16261da177e4SLinus Torvalds IGMP_Unsolicited_Report_Count; 16271da177e4SLinus Torvalds in_dev->mr_ifc_count = pmc->crcount; 16281da177e4SLinus Torvalds for (psf=pmc->sources; psf; psf = psf->sf_next) 16291da177e4SLinus Torvalds psf->sf_crcount = 0; 16301da177e4SLinus Torvalds igmp_ifc_event(pmc->interface); 16311da177e4SLinus Torvalds } else if (sf_setstate(pmc) || changerec) { 16321da177e4SLinus Torvalds igmp_ifc_event(pmc->interface); 16331da177e4SLinus Torvalds #endif 16341da177e4SLinus Torvalds } 16351da177e4SLinus Torvalds out_unlock: 16361da177e4SLinus Torvalds spin_unlock_bh(&pmc->lock); 16371da177e4SLinus Torvalds return err; 16381da177e4SLinus Torvalds } 16391da177e4SLinus Torvalds 16401da177e4SLinus Torvalds /* 16411da177e4SLinus Torvalds * Add multicast single-source filter to the interface list 16421da177e4SLinus Torvalds */ 16431da177e4SLinus Torvalds static int ip_mc_add1_src(struct ip_mc_list *pmc, int sfmode, 16445eb81e89SJun Zhao __be32 *psfsrc) 16451da177e4SLinus Torvalds { 16461da177e4SLinus Torvalds struct ip_sf_list *psf, *psf_prev; 16471da177e4SLinus Torvalds 16481da177e4SLinus Torvalds psf_prev = NULL; 16491da177e4SLinus Torvalds for (psf=pmc->sources; psf; psf=psf->sf_next) { 16501da177e4SLinus Torvalds if (psf->sf_inaddr == *psfsrc) 16511da177e4SLinus Torvalds break; 16521da177e4SLinus Torvalds psf_prev = psf; 16531da177e4SLinus Torvalds } 16541da177e4SLinus Torvalds if (!psf) { 16550da974f4SPanagiotis Issaris psf = kzalloc(sizeof(*psf), GFP_ATOMIC); 16561da177e4SLinus Torvalds if (!psf) 16571da177e4SLinus Torvalds return -ENOBUFS; 16581da177e4SLinus Torvalds psf->sf_inaddr = *psfsrc; 16591da177e4SLinus Torvalds if (psf_prev) { 16601da177e4SLinus Torvalds psf_prev->sf_next = psf; 16611da177e4SLinus Torvalds } else 16621da177e4SLinus Torvalds pmc->sources = psf; 16631da177e4SLinus Torvalds } 16641da177e4SLinus Torvalds psf->sf_count[sfmode]++; 16651da177e4SLinus Torvalds if (psf->sf_count[sfmode] == 1) { 16661da177e4SLinus Torvalds ip_rt_multicast_event(pmc->interface); 16671da177e4SLinus Torvalds } 16681da177e4SLinus Torvalds return 0; 16691da177e4SLinus Torvalds } 16701da177e4SLinus Torvalds 16711da177e4SLinus Torvalds #ifdef CONFIG_IP_MULTICAST 16721da177e4SLinus Torvalds static void sf_markstate(struct ip_mc_list *pmc) 16731da177e4SLinus Torvalds { 16741da177e4SLinus Torvalds struct ip_sf_list *psf; 16751da177e4SLinus Torvalds int mca_xcount = pmc->sfcount[MCAST_EXCLUDE]; 16761da177e4SLinus Torvalds 16771da177e4SLinus Torvalds for (psf=pmc->sources; psf; psf=psf->sf_next) 16781da177e4SLinus Torvalds if (pmc->sfcount[MCAST_EXCLUDE]) { 16791da177e4SLinus Torvalds psf->sf_oldin = mca_xcount == 16801da177e4SLinus Torvalds psf->sf_count[MCAST_EXCLUDE] && 16811da177e4SLinus Torvalds !psf->sf_count[MCAST_INCLUDE]; 16821da177e4SLinus Torvalds } else 16831da177e4SLinus Torvalds psf->sf_oldin = psf->sf_count[MCAST_INCLUDE] != 0; 16841da177e4SLinus Torvalds } 16851da177e4SLinus Torvalds 16861da177e4SLinus Torvalds static int sf_setstate(struct ip_mc_list *pmc) 16871da177e4SLinus Torvalds { 1688ad12583fSDavid L Stevens struct ip_sf_list *psf, *dpsf; 16891da177e4SLinus Torvalds int mca_xcount = pmc->sfcount[MCAST_EXCLUDE]; 16901da177e4SLinus Torvalds int qrv = pmc->interface->mr_qrv; 16911da177e4SLinus Torvalds int new_in, rv; 16921da177e4SLinus Torvalds 16931da177e4SLinus Torvalds rv = 0; 16941da177e4SLinus Torvalds for (psf=pmc->sources; psf; psf=psf->sf_next) { 16951da177e4SLinus Torvalds if (pmc->sfcount[MCAST_EXCLUDE]) { 16961da177e4SLinus Torvalds new_in = mca_xcount == psf->sf_count[MCAST_EXCLUDE] && 16971da177e4SLinus Torvalds !psf->sf_count[MCAST_INCLUDE]; 16981da177e4SLinus Torvalds } else 16991da177e4SLinus Torvalds new_in = psf->sf_count[MCAST_INCLUDE] != 0; 1700ad12583fSDavid L Stevens if (new_in) { 1701ad12583fSDavid L Stevens if (!psf->sf_oldin) { 170276edc605SAl Viro struct ip_sf_list *prev = NULL; 1703ad12583fSDavid L Stevens 1704ad12583fSDavid L Stevens for (dpsf=pmc->tomb; dpsf; dpsf=dpsf->sf_next) { 1705ad12583fSDavid L Stevens if (dpsf->sf_inaddr == psf->sf_inaddr) 1706ad12583fSDavid L Stevens break; 1707ad12583fSDavid L Stevens prev = dpsf; 1708ad12583fSDavid L Stevens } 1709ad12583fSDavid L Stevens if (dpsf) { 1710ad12583fSDavid L Stevens if (prev) 1711ad12583fSDavid L Stevens prev->sf_next = dpsf->sf_next; 1712ad12583fSDavid L Stevens else 1713ad12583fSDavid L Stevens pmc->tomb = dpsf->sf_next; 1714ad12583fSDavid L Stevens kfree(dpsf); 1715ad12583fSDavid L Stevens } 17161da177e4SLinus Torvalds psf->sf_crcount = qrv; 17171da177e4SLinus Torvalds rv++; 17181da177e4SLinus Torvalds } 1719ad12583fSDavid L Stevens } else if (psf->sf_oldin) { 1720ad12583fSDavid L Stevens 1721ad12583fSDavid L Stevens psf->sf_crcount = 0; 1722ad12583fSDavid L Stevens /* 1723ad12583fSDavid L Stevens * add or update "delete" records if an active filter 1724ad12583fSDavid L Stevens * is now inactive 1725ad12583fSDavid L Stevens */ 1726ad12583fSDavid L Stevens for (dpsf=pmc->tomb; dpsf; dpsf=dpsf->sf_next) 1727ad12583fSDavid L Stevens if (dpsf->sf_inaddr == psf->sf_inaddr) 1728ad12583fSDavid L Stevens break; 1729ad12583fSDavid L Stevens if (!dpsf) { 17303ed37a6fSJoe Perches dpsf = kmalloc(sizeof(*dpsf), GFP_ATOMIC); 1731ad12583fSDavid L Stevens if (!dpsf) 1732ad12583fSDavid L Stevens continue; 1733ad12583fSDavid L Stevens *dpsf = *psf; 1734ad12583fSDavid L Stevens /* pmc->lock held by callers */ 1735ad12583fSDavid L Stevens dpsf->sf_next = pmc->tomb; 1736ad12583fSDavid L Stevens pmc->tomb = dpsf; 1737ad12583fSDavid L Stevens } 1738ad12583fSDavid L Stevens dpsf->sf_crcount = qrv; 1739ad12583fSDavid L Stevens rv++; 1740ad12583fSDavid L Stevens } 17411da177e4SLinus Torvalds } 17421da177e4SLinus Torvalds return rv; 17431da177e4SLinus Torvalds } 17441da177e4SLinus Torvalds #endif 17451da177e4SLinus Torvalds 17461da177e4SLinus Torvalds /* 17471da177e4SLinus Torvalds * Add multicast source filter list to the interface list 17481da177e4SLinus Torvalds */ 17498f935bbdSAl Viro static int ip_mc_add_src(struct in_device *in_dev, __be32 *pmca, int sfmode, 17508f935bbdSAl Viro int sfcount, __be32 *psfsrc, int delta) 17511da177e4SLinus Torvalds { 17521da177e4SLinus Torvalds struct ip_mc_list *pmc; 17531da177e4SLinus Torvalds int isexclude; 17541da177e4SLinus Torvalds int i, err; 17551da177e4SLinus Torvalds 17561da177e4SLinus Torvalds if (!in_dev) 17571da177e4SLinus Torvalds return -ENODEV; 17581d7138deSEric Dumazet rcu_read_lock(); 17591d7138deSEric Dumazet for_each_pmc_rcu(in_dev, pmc) { 17601da177e4SLinus Torvalds if (*pmca == pmc->multiaddr) 17611da177e4SLinus Torvalds break; 17621da177e4SLinus Torvalds } 17631da177e4SLinus Torvalds if (!pmc) { 17641da177e4SLinus Torvalds /* MCA not found?? bug */ 17651d7138deSEric Dumazet rcu_read_unlock(); 17661da177e4SLinus Torvalds return -ESRCH; 17671da177e4SLinus Torvalds } 17681da177e4SLinus Torvalds spin_lock_bh(&pmc->lock); 17691d7138deSEric Dumazet rcu_read_unlock(); 17701da177e4SLinus Torvalds 17711da177e4SLinus Torvalds #ifdef CONFIG_IP_MULTICAST 17721da177e4SLinus Torvalds sf_markstate(pmc); 17731da177e4SLinus Torvalds #endif 17741da177e4SLinus Torvalds isexclude = pmc->sfmode == MCAST_EXCLUDE; 17751da177e4SLinus Torvalds if (!delta) 17761da177e4SLinus Torvalds pmc->sfcount[sfmode]++; 17771da177e4SLinus Torvalds err = 0; 17781da177e4SLinus Torvalds for (i=0; i<sfcount; i++) { 17795eb81e89SJun Zhao err = ip_mc_add1_src(pmc, sfmode, &psfsrc[i]); 17801da177e4SLinus Torvalds if (err) 17811da177e4SLinus Torvalds break; 17821da177e4SLinus Torvalds } 17831da177e4SLinus Torvalds if (err) { 17841da177e4SLinus Torvalds int j; 17851da177e4SLinus Torvalds 1786685f94e6SJun Zhao if (!delta) 17871da177e4SLinus Torvalds pmc->sfcount[sfmode]--; 17881da177e4SLinus Torvalds for (j=0; j<i; j++) 1789a1889c0dSJulia Lawall (void) ip_mc_del1_src(pmc, sfmode, &psfsrc[j]); 17901da177e4SLinus Torvalds } else if (isexclude != (pmc->sfcount[MCAST_EXCLUDE] != 0)) { 17911da177e4SLinus Torvalds #ifdef CONFIG_IP_MULTICAST 17921da177e4SLinus Torvalds struct ip_sf_list *psf; 1793cfcabdccSStephen Hemminger in_dev = pmc->interface; 17941da177e4SLinus Torvalds #endif 17951da177e4SLinus Torvalds 17961da177e4SLinus Torvalds /* filter mode change */ 17971da177e4SLinus Torvalds if (pmc->sfcount[MCAST_EXCLUDE]) 17981da177e4SLinus Torvalds pmc->sfmode = MCAST_EXCLUDE; 17991da177e4SLinus Torvalds else if (pmc->sfcount[MCAST_INCLUDE]) 18001da177e4SLinus Torvalds pmc->sfmode = MCAST_INCLUDE; 18011da177e4SLinus Torvalds #ifdef CONFIG_IP_MULTICAST 18021da177e4SLinus Torvalds /* else no filters; keep old mode for reports */ 18031da177e4SLinus Torvalds 18041da177e4SLinus Torvalds pmc->crcount = in_dev->mr_qrv ? in_dev->mr_qrv : 18051da177e4SLinus Torvalds IGMP_Unsolicited_Report_Count; 18061da177e4SLinus Torvalds in_dev->mr_ifc_count = pmc->crcount; 18071da177e4SLinus Torvalds for (psf=pmc->sources; psf; psf = psf->sf_next) 18081da177e4SLinus Torvalds psf->sf_crcount = 0; 18091da177e4SLinus Torvalds igmp_ifc_event(in_dev); 18101da177e4SLinus Torvalds } else if (sf_setstate(pmc)) { 18111da177e4SLinus Torvalds igmp_ifc_event(in_dev); 18121da177e4SLinus Torvalds #endif 18131da177e4SLinus Torvalds } 18141da177e4SLinus Torvalds spin_unlock_bh(&pmc->lock); 18151da177e4SLinus Torvalds return err; 18161da177e4SLinus Torvalds } 18171da177e4SLinus Torvalds 18181da177e4SLinus Torvalds static void ip_mc_clear_src(struct ip_mc_list *pmc) 18191da177e4SLinus Torvalds { 18201da177e4SLinus Torvalds struct ip_sf_list *psf, *nextpsf; 18211da177e4SLinus Torvalds 18221da177e4SLinus Torvalds for (psf=pmc->tomb; psf; psf=nextpsf) { 18231da177e4SLinus Torvalds nextpsf = psf->sf_next; 18241da177e4SLinus Torvalds kfree(psf); 18251da177e4SLinus Torvalds } 18261da177e4SLinus Torvalds pmc->tomb = NULL; 18271da177e4SLinus Torvalds for (psf=pmc->sources; psf; psf=nextpsf) { 18281da177e4SLinus Torvalds nextpsf = psf->sf_next; 18291da177e4SLinus Torvalds kfree(psf); 18301da177e4SLinus Torvalds } 18311da177e4SLinus Torvalds pmc->sources = NULL; 18321da177e4SLinus Torvalds pmc->sfmode = MCAST_EXCLUDE; 1833de9daad9SDenis Lukianov pmc->sfcount[MCAST_INCLUDE] = 0; 18341da177e4SLinus Torvalds pmc->sfcount[MCAST_EXCLUDE] = 1; 18351da177e4SLinus Torvalds } 18361da177e4SLinus Torvalds 18371da177e4SLinus Torvalds 18381da177e4SLinus Torvalds /* 18391da177e4SLinus Torvalds * Join a multicast group 18401da177e4SLinus Torvalds */ 18411da177e4SLinus Torvalds int ip_mc_join_group(struct sock *sk , struct ip_mreqn *imr) 18421da177e4SLinus Torvalds { 18431da177e4SLinus Torvalds int err; 18448f935bbdSAl Viro __be32 addr = imr->imr_multiaddr.s_addr; 1845ca9b907dSDavid L Stevens struct ip_mc_socklist *iml = NULL, *i; 18461da177e4SLinus Torvalds struct in_device *in_dev; 18471da177e4SLinus Torvalds struct inet_sock *inet = inet_sk(sk); 1848877acedcSDaniel Lezcano struct net *net = sock_net(sk); 1849ca9b907dSDavid L Stevens int ifindex; 18501da177e4SLinus Torvalds int count = 0; 18511da177e4SLinus Torvalds 1852f97c1e0cSJoe Perches if (!ipv4_is_multicast(addr)) 18531da177e4SLinus Torvalds return -EINVAL; 18541da177e4SLinus Torvalds 18556756ae4bSStephen Hemminger rtnl_lock(); 18561da177e4SLinus Torvalds 1857877acedcSDaniel Lezcano in_dev = ip_mc_find_dev(net, imr); 18581da177e4SLinus Torvalds 18591da177e4SLinus Torvalds if (!in_dev) { 18601da177e4SLinus Torvalds iml = NULL; 18611da177e4SLinus Torvalds err = -ENODEV; 18621da177e4SLinus Torvalds goto done; 18631da177e4SLinus Torvalds } 18641da177e4SLinus Torvalds 18651da177e4SLinus Torvalds err = -EADDRINUSE; 1866ca9b907dSDavid L Stevens ifindex = imr->imr_ifindex; 18671d7138deSEric Dumazet for_each_pmc_rtnl(inet, i) { 1868ca9b907dSDavid L Stevens if (i->multi.imr_multiaddr.s_addr == addr && 1869ca9b907dSDavid L Stevens i->multi.imr_ifindex == ifindex) 18701da177e4SLinus Torvalds goto done; 18711da177e4SLinus Torvalds count++; 18721da177e4SLinus Torvalds } 18731da177e4SLinus Torvalds err = -ENOBUFS; 1874ca9b907dSDavid L Stevens if (count >= sysctl_igmp_max_memberships) 18751da177e4SLinus Torvalds goto done; 18768b3a7005SKris Katterjohn iml = sock_kmalloc(sk, sizeof(*iml), GFP_KERNEL); 1877ca9b907dSDavid L Stevens if (iml == NULL) 1878ca9b907dSDavid L Stevens goto done; 1879ca9b907dSDavid L Stevens 18801da177e4SLinus Torvalds memcpy(&iml->multi, imr, sizeof(*imr)); 18811d7138deSEric Dumazet iml->next_rcu = inet->mc_list; 18821da177e4SLinus Torvalds iml->sflist = NULL; 18831da177e4SLinus Torvalds iml->sfmode = MCAST_EXCLUDE; 1884cf778b00SEric Dumazet rcu_assign_pointer(inet->mc_list, iml); 18851da177e4SLinus Torvalds ip_mc_inc_group(in_dev, addr); 18861da177e4SLinus Torvalds err = 0; 18871da177e4SLinus Torvalds done: 18886756ae4bSStephen Hemminger rtnl_unlock(); 18891da177e4SLinus Torvalds return err; 18901da177e4SLinus Torvalds } 18914bc2f18bSEric Dumazet EXPORT_SYMBOL(ip_mc_join_group); 18921da177e4SLinus Torvalds 18931da177e4SLinus Torvalds static int ip_mc_leave_src(struct sock *sk, struct ip_mc_socklist *iml, 18941da177e4SLinus Torvalds struct in_device *in_dev) 18951da177e4SLinus Torvalds { 18961d7138deSEric Dumazet struct ip_sf_socklist *psf = rtnl_dereference(iml->sflist); 18971da177e4SLinus Torvalds int err; 18981da177e4SLinus Torvalds 1899c85bb41eSFlavio Leitner if (psf == NULL) { 19001da177e4SLinus Torvalds /* any-source empty exclude case */ 19011da177e4SLinus Torvalds return ip_mc_del_src(in_dev, &iml->multi.imr_multiaddr.s_addr, 19021da177e4SLinus Torvalds iml->sfmode, 0, NULL, 0); 19031da177e4SLinus Torvalds } 19041da177e4SLinus Torvalds err = ip_mc_del_src(in_dev, &iml->multi.imr_multiaddr.s_addr, 1905c85bb41eSFlavio Leitner iml->sfmode, psf->sl_count, psf->sl_addr, 0); 1906a9b3cd7fSStephen Hemminger RCU_INIT_POINTER(iml->sflist, NULL); 1907c85bb41eSFlavio Leitner /* decrease mem now to avoid the memleak warning */ 1908c85bb41eSFlavio Leitner atomic_sub(IP_SFLSIZE(psf->sl_max), &sk->sk_omem_alloc); 19097519cce4SLai Jiangshan kfree_rcu(psf, rcu); 19101da177e4SLinus Torvalds return err; 19111da177e4SLinus Torvalds } 19121da177e4SLinus Torvalds 19131da177e4SLinus Torvalds /* 19141da177e4SLinus Torvalds * Ask a socket to leave a group. 19151da177e4SLinus Torvalds */ 19161da177e4SLinus Torvalds 19171da177e4SLinus Torvalds int ip_mc_leave_group(struct sock *sk, struct ip_mreqn *imr) 19181da177e4SLinus Torvalds { 19191da177e4SLinus Torvalds struct inet_sock *inet = inet_sk(sk); 19201d7138deSEric Dumazet struct ip_mc_socklist *iml; 19211d7138deSEric Dumazet struct ip_mc_socklist __rcu **imlp; 192284b42baeSDavid L Stevens struct in_device *in_dev; 1923877acedcSDaniel Lezcano struct net *net = sock_net(sk); 19248f935bbdSAl Viro __be32 group = imr->imr_multiaddr.s_addr; 192584b42baeSDavid L Stevens u32 ifindex; 1926acd6e00bSDavid L Stevens int ret = -EADDRNOTAVAIL; 19271da177e4SLinus Torvalds 19281da177e4SLinus Torvalds rtnl_lock(); 1929877acedcSDaniel Lezcano in_dev = ip_mc_find_dev(net, imr); 193084b42baeSDavid L Stevens ifindex = imr->imr_ifindex; 19311d7138deSEric Dumazet for (imlp = &inet->mc_list; 19321d7138deSEric Dumazet (iml = rtnl_dereference(*imlp)) != NULL; 19331d7138deSEric Dumazet imlp = &iml->next_rcu) { 1934acd6e00bSDavid L Stevens if (iml->multi.imr_multiaddr.s_addr != group) 1935acd6e00bSDavid L Stevens continue; 1936acd6e00bSDavid L Stevens if (ifindex) { 1937acd6e00bSDavid L Stevens if (iml->multi.imr_ifindex != ifindex) 1938acd6e00bSDavid L Stevens continue; 1939acd6e00bSDavid L Stevens } else if (imr->imr_address.s_addr && imr->imr_address.s_addr != 1940acd6e00bSDavid L Stevens iml->multi.imr_address.s_addr) 1941acd6e00bSDavid L Stevens continue; 1942acd6e00bSDavid L Stevens 19431da177e4SLinus Torvalds (void) ip_mc_leave_src(sk, iml, in_dev); 19441da177e4SLinus Torvalds 19451d7138deSEric Dumazet *imlp = iml->next_rcu; 19461da177e4SLinus Torvalds 1947acd6e00bSDavid L Stevens if (in_dev) 194884b42baeSDavid L Stevens ip_mc_dec_group(in_dev, group); 19491da177e4SLinus Torvalds rtnl_unlock(); 1950c85bb41eSFlavio Leitner /* decrease mem now to avoid the memleak warning */ 1951c85bb41eSFlavio Leitner atomic_sub(sizeof(*iml), &sk->sk_omem_alloc); 195210d50e74SLai Jiangshan kfree_rcu(iml, rcu); 19531da177e4SLinus Torvalds return 0; 19541da177e4SLinus Torvalds } 1955acd6e00bSDavid L Stevens if (!in_dev) 1956acd6e00bSDavid L Stevens ret = -ENODEV; 19571da177e4SLinus Torvalds rtnl_unlock(); 1958acd6e00bSDavid L Stevens return ret; 19591da177e4SLinus Torvalds } 1960193ba924Sstephen hemminger EXPORT_SYMBOL(ip_mc_leave_group); 19611da177e4SLinus Torvalds 19621da177e4SLinus Torvalds int ip_mc_source(int add, int omode, struct sock *sk, struct 19631da177e4SLinus Torvalds ip_mreq_source *mreqs, int ifindex) 19641da177e4SLinus Torvalds { 19651da177e4SLinus Torvalds int err; 19661da177e4SLinus Torvalds struct ip_mreqn imr; 196763007727SAl Viro __be32 addr = mreqs->imr_multiaddr; 19681da177e4SLinus Torvalds struct ip_mc_socklist *pmc; 19691da177e4SLinus Torvalds struct in_device *in_dev = NULL; 19701da177e4SLinus Torvalds struct inet_sock *inet = inet_sk(sk); 19711da177e4SLinus Torvalds struct ip_sf_socklist *psl; 1972877acedcSDaniel Lezcano struct net *net = sock_net(sk); 19738cdaaa15SDavid L Stevens int leavegroup = 0; 19741da177e4SLinus Torvalds int i, j, rv; 19751da177e4SLinus Torvalds 1976f97c1e0cSJoe Perches if (!ipv4_is_multicast(addr)) 19771da177e4SLinus Torvalds return -EINVAL; 19781da177e4SLinus Torvalds 19796756ae4bSStephen Hemminger rtnl_lock(); 19801da177e4SLinus Torvalds 19811da177e4SLinus Torvalds imr.imr_multiaddr.s_addr = mreqs->imr_multiaddr; 19821da177e4SLinus Torvalds imr.imr_address.s_addr = mreqs->imr_interface; 19831da177e4SLinus Torvalds imr.imr_ifindex = ifindex; 1984877acedcSDaniel Lezcano in_dev = ip_mc_find_dev(net, &imr); 19851da177e4SLinus Torvalds 19861da177e4SLinus Torvalds if (!in_dev) { 19871da177e4SLinus Torvalds err = -ENODEV; 19881da177e4SLinus Torvalds goto done; 19891da177e4SLinus Torvalds } 19901da177e4SLinus Torvalds err = -EADDRNOTAVAIL; 19911da177e4SLinus Torvalds 19921d7138deSEric Dumazet for_each_pmc_rtnl(inet, pmc) { 1993f64f9e71SJoe Perches if ((pmc->multi.imr_multiaddr.s_addr == 1994f64f9e71SJoe Perches imr.imr_multiaddr.s_addr) && 1995f64f9e71SJoe Perches (pmc->multi.imr_ifindex == imr.imr_ifindex)) 19961da177e4SLinus Torvalds break; 19971da177e4SLinus Torvalds } 1998917f2f10SDavid L Stevens if (!pmc) { /* must have a prior join */ 1999917f2f10SDavid L Stevens err = -EINVAL; 20001da177e4SLinus Torvalds goto done; 2001917f2f10SDavid L Stevens } 20021da177e4SLinus Torvalds /* if a source filter was set, must be the same mode as before */ 20031da177e4SLinus Torvalds if (pmc->sflist) { 2004917f2f10SDavid L Stevens if (pmc->sfmode != omode) { 2005917f2f10SDavid L Stevens err = -EINVAL; 20061da177e4SLinus Torvalds goto done; 2007917f2f10SDavid L Stevens } 20081da177e4SLinus Torvalds } else if (pmc->sfmode != omode) { 20091da177e4SLinus Torvalds /* allow mode switches for empty-set filters */ 20101da177e4SLinus Torvalds ip_mc_add_src(in_dev, &mreqs->imr_multiaddr, omode, 0, NULL, 0); 20111da177e4SLinus Torvalds ip_mc_del_src(in_dev, &mreqs->imr_multiaddr, pmc->sfmode, 0, 20121da177e4SLinus Torvalds NULL, 0); 20131da177e4SLinus Torvalds pmc->sfmode = omode; 20141da177e4SLinus Torvalds } 20151da177e4SLinus Torvalds 20161d7138deSEric Dumazet psl = rtnl_dereference(pmc->sflist); 20171da177e4SLinus Torvalds if (!add) { 20181da177e4SLinus Torvalds if (!psl) 2019917f2f10SDavid L Stevens goto done; /* err = -EADDRNOTAVAIL */ 20201da177e4SLinus Torvalds rv = !0; 20211da177e4SLinus Torvalds for (i=0; i<psl->sl_count; i++) { 20221da177e4SLinus Torvalds rv = memcmp(&psl->sl_addr[i], &mreqs->imr_sourceaddr, 202363007727SAl Viro sizeof(__be32)); 20241da177e4SLinus Torvalds if (rv == 0) 20251da177e4SLinus Torvalds break; 20261da177e4SLinus Torvalds } 20271da177e4SLinus Torvalds if (rv) /* source not found */ 2028917f2f10SDavid L Stevens goto done; /* err = -EADDRNOTAVAIL */ 20291da177e4SLinus Torvalds 20308cdaaa15SDavid L Stevens /* special case - (INCLUDE, empty) == LEAVE_GROUP */ 20318cdaaa15SDavid L Stevens if (psl->sl_count == 1 && omode == MCAST_INCLUDE) { 20328cdaaa15SDavid L Stevens leavegroup = 1; 20338cdaaa15SDavid L Stevens goto done; 20348cdaaa15SDavid L Stevens } 20358cdaaa15SDavid L Stevens 20361da177e4SLinus Torvalds /* update the interface filter */ 20371da177e4SLinus Torvalds ip_mc_del_src(in_dev, &mreqs->imr_multiaddr, omode, 1, 20381da177e4SLinus Torvalds &mreqs->imr_sourceaddr, 1); 20391da177e4SLinus Torvalds 20401da177e4SLinus Torvalds for (j=i+1; j<psl->sl_count; j++) 20411da177e4SLinus Torvalds psl->sl_addr[j-1] = psl->sl_addr[j]; 20421da177e4SLinus Torvalds psl->sl_count--; 20431da177e4SLinus Torvalds err = 0; 20441da177e4SLinus Torvalds goto done; 20451da177e4SLinus Torvalds } 20461da177e4SLinus Torvalds /* else, add a new source to the filter */ 20471da177e4SLinus Torvalds 20481da177e4SLinus Torvalds if (psl && psl->sl_count >= sysctl_igmp_max_msf) { 20491da177e4SLinus Torvalds err = -ENOBUFS; 20501da177e4SLinus Torvalds goto done; 20511da177e4SLinus Torvalds } 20521da177e4SLinus Torvalds if (!psl || psl->sl_count == psl->sl_max) { 20531da177e4SLinus Torvalds struct ip_sf_socklist *newpsl; 20541da177e4SLinus Torvalds int count = IP_SFBLOCK; 20551da177e4SLinus Torvalds 20561da177e4SLinus Torvalds if (psl) 20571da177e4SLinus Torvalds count += psl->sl_max; 20588b3a7005SKris Katterjohn newpsl = sock_kmalloc(sk, IP_SFLSIZE(count), GFP_KERNEL); 20591da177e4SLinus Torvalds if (!newpsl) { 20601da177e4SLinus Torvalds err = -ENOBUFS; 20611da177e4SLinus Torvalds goto done; 20621da177e4SLinus Torvalds } 20631da177e4SLinus Torvalds newpsl->sl_max = count; 20641da177e4SLinus Torvalds newpsl->sl_count = count - IP_SFBLOCK; 20651da177e4SLinus Torvalds if (psl) { 20661da177e4SLinus Torvalds for (i=0; i<psl->sl_count; i++) 20671da177e4SLinus Torvalds newpsl->sl_addr[i] = psl->sl_addr[i]; 2068c85bb41eSFlavio Leitner /* decrease mem now to avoid the memleak warning */ 2069c85bb41eSFlavio Leitner atomic_sub(IP_SFLSIZE(psl->sl_max), &sk->sk_omem_alloc); 20707519cce4SLai Jiangshan kfree_rcu(psl, rcu); 20711da177e4SLinus Torvalds } 2072cf778b00SEric Dumazet rcu_assign_pointer(pmc->sflist, newpsl); 2073c85bb41eSFlavio Leitner psl = newpsl; 20741da177e4SLinus Torvalds } 20751da177e4SLinus Torvalds rv = 1; /* > 0 for insert logic below if sl_count is 0 */ 20761da177e4SLinus Torvalds for (i=0; i<psl->sl_count; i++) { 20771da177e4SLinus Torvalds rv = memcmp(&psl->sl_addr[i], &mreqs->imr_sourceaddr, 207863007727SAl Viro sizeof(__be32)); 20791da177e4SLinus Torvalds if (rv == 0) 20801da177e4SLinus Torvalds break; 20811da177e4SLinus Torvalds } 20821da177e4SLinus Torvalds if (rv == 0) /* address already there is an error */ 20831da177e4SLinus Torvalds goto done; 20841da177e4SLinus Torvalds for (j=psl->sl_count-1; j>=i; j--) 20851da177e4SLinus Torvalds psl->sl_addr[j+1] = psl->sl_addr[j]; 20861da177e4SLinus Torvalds psl->sl_addr[i] = mreqs->imr_sourceaddr; 20871da177e4SLinus Torvalds psl->sl_count++; 20881da177e4SLinus Torvalds err = 0; 20891da177e4SLinus Torvalds /* update the interface list */ 20901da177e4SLinus Torvalds ip_mc_add_src(in_dev, &mreqs->imr_multiaddr, omode, 1, 20911da177e4SLinus Torvalds &mreqs->imr_sourceaddr, 1); 20921da177e4SLinus Torvalds done: 20936756ae4bSStephen Hemminger rtnl_unlock(); 20948cdaaa15SDavid L Stevens if (leavegroup) 20958cdaaa15SDavid L Stevens return ip_mc_leave_group(sk, &imr); 20961da177e4SLinus Torvalds return err; 20971da177e4SLinus Torvalds } 20981da177e4SLinus Torvalds 20991da177e4SLinus Torvalds int ip_mc_msfilter(struct sock *sk, struct ip_msfilter *msf, int ifindex) 21001da177e4SLinus Torvalds { 21019951f036SDavid L Stevens int err = 0; 21021da177e4SLinus Torvalds struct ip_mreqn imr; 210363007727SAl Viro __be32 addr = msf->imsf_multiaddr; 21041da177e4SLinus Torvalds struct ip_mc_socklist *pmc; 21051da177e4SLinus Torvalds struct in_device *in_dev; 21061da177e4SLinus Torvalds struct inet_sock *inet = inet_sk(sk); 21071da177e4SLinus Torvalds struct ip_sf_socklist *newpsl, *psl; 2108877acedcSDaniel Lezcano struct net *net = sock_net(sk); 21099951f036SDavid L Stevens int leavegroup = 0; 21101da177e4SLinus Torvalds 2111f97c1e0cSJoe Perches if (!ipv4_is_multicast(addr)) 21121da177e4SLinus Torvalds return -EINVAL; 21131da177e4SLinus Torvalds if (msf->imsf_fmode != MCAST_INCLUDE && 21141da177e4SLinus Torvalds msf->imsf_fmode != MCAST_EXCLUDE) 21151da177e4SLinus Torvalds return -EINVAL; 21161da177e4SLinus Torvalds 21176756ae4bSStephen Hemminger rtnl_lock(); 21181da177e4SLinus Torvalds 21191da177e4SLinus Torvalds imr.imr_multiaddr.s_addr = msf->imsf_multiaddr; 21201da177e4SLinus Torvalds imr.imr_address.s_addr = msf->imsf_interface; 21211da177e4SLinus Torvalds imr.imr_ifindex = ifindex; 2122877acedcSDaniel Lezcano in_dev = ip_mc_find_dev(net, &imr); 21231da177e4SLinus Torvalds 21241da177e4SLinus Torvalds if (!in_dev) { 21251da177e4SLinus Torvalds err = -ENODEV; 21261da177e4SLinus Torvalds goto done; 21271da177e4SLinus Torvalds } 21281da177e4SLinus Torvalds 21299951f036SDavid L Stevens /* special case - (INCLUDE, empty) == LEAVE_GROUP */ 21309951f036SDavid L Stevens if (msf->imsf_fmode == MCAST_INCLUDE && msf->imsf_numsrc == 0) { 21319951f036SDavid L Stevens leavegroup = 1; 21329951f036SDavid L Stevens goto done; 21339951f036SDavid L Stevens } 21349951f036SDavid L Stevens 21351d7138deSEric Dumazet for_each_pmc_rtnl(inet, pmc) { 21361da177e4SLinus Torvalds if (pmc->multi.imr_multiaddr.s_addr == msf->imsf_multiaddr && 21371da177e4SLinus Torvalds pmc->multi.imr_ifindex == imr.imr_ifindex) 21381da177e4SLinus Torvalds break; 21391da177e4SLinus Torvalds } 2140917f2f10SDavid L Stevens if (!pmc) { /* must have a prior join */ 2141917f2f10SDavid L Stevens err = -EINVAL; 21421da177e4SLinus Torvalds goto done; 2143917f2f10SDavid L Stevens } 21441da177e4SLinus Torvalds if (msf->imsf_numsrc) { 21458b3a7005SKris Katterjohn newpsl = sock_kmalloc(sk, IP_SFLSIZE(msf->imsf_numsrc), 21468b3a7005SKris Katterjohn GFP_KERNEL); 21471da177e4SLinus Torvalds if (!newpsl) { 21481da177e4SLinus Torvalds err = -ENOBUFS; 21491da177e4SLinus Torvalds goto done; 21501da177e4SLinus Torvalds } 21511da177e4SLinus Torvalds newpsl->sl_max = newpsl->sl_count = msf->imsf_numsrc; 21521da177e4SLinus Torvalds memcpy(newpsl->sl_addr, msf->imsf_slist, 21531da177e4SLinus Torvalds msf->imsf_numsrc * sizeof(msf->imsf_slist[0])); 21541da177e4SLinus Torvalds err = ip_mc_add_src(in_dev, &msf->imsf_multiaddr, 21551da177e4SLinus Torvalds msf->imsf_fmode, newpsl->sl_count, newpsl->sl_addr, 0); 21561da177e4SLinus Torvalds if (err) { 21571da177e4SLinus Torvalds sock_kfree_s(sk, newpsl, IP_SFLSIZE(newpsl->sl_max)); 21581da177e4SLinus Torvalds goto done; 21591da177e4SLinus Torvalds } 21608713dbf0SYan Zheng } else { 21611da177e4SLinus Torvalds newpsl = NULL; 21628713dbf0SYan Zheng (void) ip_mc_add_src(in_dev, &msf->imsf_multiaddr, 21638713dbf0SYan Zheng msf->imsf_fmode, 0, NULL, 0); 21648713dbf0SYan Zheng } 21651d7138deSEric Dumazet psl = rtnl_dereference(pmc->sflist); 21661da177e4SLinus Torvalds if (psl) { 21671da177e4SLinus Torvalds (void) ip_mc_del_src(in_dev, &msf->imsf_multiaddr, pmc->sfmode, 21681da177e4SLinus Torvalds psl->sl_count, psl->sl_addr, 0); 2169c85bb41eSFlavio Leitner /* decrease mem now to avoid the memleak warning */ 2170c85bb41eSFlavio Leitner atomic_sub(IP_SFLSIZE(psl->sl_max), &sk->sk_omem_alloc); 21717519cce4SLai Jiangshan kfree_rcu(psl, rcu); 21721da177e4SLinus Torvalds } else 21731da177e4SLinus Torvalds (void) ip_mc_del_src(in_dev, &msf->imsf_multiaddr, pmc->sfmode, 21741da177e4SLinus Torvalds 0, NULL, 0); 2175cf778b00SEric Dumazet rcu_assign_pointer(pmc->sflist, newpsl); 21761da177e4SLinus Torvalds pmc->sfmode = msf->imsf_fmode; 2177917f2f10SDavid L Stevens err = 0; 21781da177e4SLinus Torvalds done: 21796756ae4bSStephen Hemminger rtnl_unlock(); 21809951f036SDavid L Stevens if (leavegroup) 21819951f036SDavid L Stevens err = ip_mc_leave_group(sk, &imr); 21821da177e4SLinus Torvalds return err; 21831da177e4SLinus Torvalds } 21841da177e4SLinus Torvalds 21851da177e4SLinus Torvalds int ip_mc_msfget(struct sock *sk, struct ip_msfilter *msf, 21861da177e4SLinus Torvalds struct ip_msfilter __user *optval, int __user *optlen) 21871da177e4SLinus Torvalds { 21881da177e4SLinus Torvalds int err, len, count, copycount; 21891da177e4SLinus Torvalds struct ip_mreqn imr; 219063007727SAl Viro __be32 addr = msf->imsf_multiaddr; 21911da177e4SLinus Torvalds struct ip_mc_socklist *pmc; 21921da177e4SLinus Torvalds struct in_device *in_dev; 21931da177e4SLinus Torvalds struct inet_sock *inet = inet_sk(sk); 21941da177e4SLinus Torvalds struct ip_sf_socklist *psl; 2195877acedcSDaniel Lezcano struct net *net = sock_net(sk); 21961da177e4SLinus Torvalds 2197f97c1e0cSJoe Perches if (!ipv4_is_multicast(addr)) 21981da177e4SLinus Torvalds return -EINVAL; 21991da177e4SLinus Torvalds 22006756ae4bSStephen Hemminger rtnl_lock(); 22011da177e4SLinus Torvalds 22021da177e4SLinus Torvalds imr.imr_multiaddr.s_addr = msf->imsf_multiaddr; 22031da177e4SLinus Torvalds imr.imr_address.s_addr = msf->imsf_interface; 22041da177e4SLinus Torvalds imr.imr_ifindex = 0; 2205877acedcSDaniel Lezcano in_dev = ip_mc_find_dev(net, &imr); 22061da177e4SLinus Torvalds 22071da177e4SLinus Torvalds if (!in_dev) { 22081da177e4SLinus Torvalds err = -ENODEV; 22091da177e4SLinus Torvalds goto done; 22101da177e4SLinus Torvalds } 22111da177e4SLinus Torvalds err = -EADDRNOTAVAIL; 22121da177e4SLinus Torvalds 22131d7138deSEric Dumazet for_each_pmc_rtnl(inet, pmc) { 22141da177e4SLinus Torvalds if (pmc->multi.imr_multiaddr.s_addr == msf->imsf_multiaddr && 22151da177e4SLinus Torvalds pmc->multi.imr_ifindex == imr.imr_ifindex) 22161da177e4SLinus Torvalds break; 22171da177e4SLinus Torvalds } 22181da177e4SLinus Torvalds if (!pmc) /* must have a prior join */ 22191da177e4SLinus Torvalds goto done; 22201da177e4SLinus Torvalds msf->imsf_fmode = pmc->sfmode; 22211d7138deSEric Dumazet psl = rtnl_dereference(pmc->sflist); 22226756ae4bSStephen Hemminger rtnl_unlock(); 22231da177e4SLinus Torvalds if (!psl) { 22241da177e4SLinus Torvalds len = 0; 22251da177e4SLinus Torvalds count = 0; 22261da177e4SLinus Torvalds } else { 22271da177e4SLinus Torvalds count = psl->sl_count; 22281da177e4SLinus Torvalds } 22291da177e4SLinus Torvalds copycount = count < msf->imsf_numsrc ? count : msf->imsf_numsrc; 22301da177e4SLinus Torvalds len = copycount * sizeof(psl->sl_addr[0]); 22311da177e4SLinus Torvalds msf->imsf_numsrc = count; 22321da177e4SLinus Torvalds if (put_user(IP_MSFILTER_SIZE(copycount), optlen) || 22331da177e4SLinus Torvalds copy_to_user(optval, msf, IP_MSFILTER_SIZE(0))) { 22341da177e4SLinus Torvalds return -EFAULT; 22351da177e4SLinus Torvalds } 22361da177e4SLinus Torvalds if (len && 22371da177e4SLinus Torvalds copy_to_user(&optval->imsf_slist[0], psl->sl_addr, len)) 22381da177e4SLinus Torvalds return -EFAULT; 22391da177e4SLinus Torvalds return 0; 22401da177e4SLinus Torvalds done: 22416756ae4bSStephen Hemminger rtnl_unlock(); 22421da177e4SLinus Torvalds return err; 22431da177e4SLinus Torvalds } 22441da177e4SLinus Torvalds 22451da177e4SLinus Torvalds int ip_mc_gsfget(struct sock *sk, struct group_filter *gsf, 22461da177e4SLinus Torvalds struct group_filter __user *optval, int __user *optlen) 22471da177e4SLinus Torvalds { 22481da177e4SLinus Torvalds int err, i, count, copycount; 22491da177e4SLinus Torvalds struct sockaddr_in *psin; 225063007727SAl Viro __be32 addr; 22511da177e4SLinus Torvalds struct ip_mc_socklist *pmc; 22521da177e4SLinus Torvalds struct inet_sock *inet = inet_sk(sk); 22531da177e4SLinus Torvalds struct ip_sf_socklist *psl; 22541da177e4SLinus Torvalds 22551da177e4SLinus Torvalds psin = (struct sockaddr_in *)&gsf->gf_group; 22561da177e4SLinus Torvalds if (psin->sin_family != AF_INET) 22571da177e4SLinus Torvalds return -EINVAL; 22581da177e4SLinus Torvalds addr = psin->sin_addr.s_addr; 2259f97c1e0cSJoe Perches if (!ipv4_is_multicast(addr)) 22601da177e4SLinus Torvalds return -EINVAL; 22611da177e4SLinus Torvalds 22626756ae4bSStephen Hemminger rtnl_lock(); 22631da177e4SLinus Torvalds 22641da177e4SLinus Torvalds err = -EADDRNOTAVAIL; 22651da177e4SLinus Torvalds 22661d7138deSEric Dumazet for_each_pmc_rtnl(inet, pmc) { 22671da177e4SLinus Torvalds if (pmc->multi.imr_multiaddr.s_addr == addr && 22681da177e4SLinus Torvalds pmc->multi.imr_ifindex == gsf->gf_interface) 22691da177e4SLinus Torvalds break; 22701da177e4SLinus Torvalds } 22711da177e4SLinus Torvalds if (!pmc) /* must have a prior join */ 22721da177e4SLinus Torvalds goto done; 22731da177e4SLinus Torvalds gsf->gf_fmode = pmc->sfmode; 22741d7138deSEric Dumazet psl = rtnl_dereference(pmc->sflist); 22756756ae4bSStephen Hemminger rtnl_unlock(); 22761da177e4SLinus Torvalds count = psl ? psl->sl_count : 0; 22771da177e4SLinus Torvalds copycount = count < gsf->gf_numsrc ? count : gsf->gf_numsrc; 22781da177e4SLinus Torvalds gsf->gf_numsrc = count; 22791da177e4SLinus Torvalds if (put_user(GROUP_FILTER_SIZE(copycount), optlen) || 22801da177e4SLinus Torvalds copy_to_user(optval, gsf, GROUP_FILTER_SIZE(0))) { 22811da177e4SLinus Torvalds return -EFAULT; 22821da177e4SLinus Torvalds } 22831da177e4SLinus Torvalds for (i=0; i<copycount; i++) { 22841da177e4SLinus Torvalds struct sockaddr_storage ss; 22851da177e4SLinus Torvalds 22861da177e4SLinus Torvalds psin = (struct sockaddr_in *)&ss; 22871da177e4SLinus Torvalds memset(&ss, 0, sizeof(ss)); 22881da177e4SLinus Torvalds psin->sin_family = AF_INET; 22891da177e4SLinus Torvalds psin->sin_addr.s_addr = psl->sl_addr[i]; 22901da177e4SLinus Torvalds if (copy_to_user(&optval->gf_slist[i], &ss, sizeof(ss))) 22911da177e4SLinus Torvalds return -EFAULT; 22921da177e4SLinus Torvalds } 22931da177e4SLinus Torvalds return 0; 22941da177e4SLinus Torvalds done: 22956756ae4bSStephen Hemminger rtnl_unlock(); 22961da177e4SLinus Torvalds return err; 22971da177e4SLinus Torvalds } 22981da177e4SLinus Torvalds 22991da177e4SLinus Torvalds /* 23001da177e4SLinus Torvalds * check if a multicast source filter allows delivery for a given <src,dst,intf> 23011da177e4SLinus Torvalds */ 2302c0cda068SAl Viro int ip_mc_sf_allow(struct sock *sk, __be32 loc_addr, __be32 rmt_addr, int dif) 23031da177e4SLinus Torvalds { 23041da177e4SLinus Torvalds struct inet_sock *inet = inet_sk(sk); 23051da177e4SLinus Torvalds struct ip_mc_socklist *pmc; 23061da177e4SLinus Torvalds struct ip_sf_socklist *psl; 23071da177e4SLinus Torvalds int i; 2308c85bb41eSFlavio Leitner int ret; 23091da177e4SLinus Torvalds 2310c85bb41eSFlavio Leitner ret = 1; 2311f97c1e0cSJoe Perches if (!ipv4_is_multicast(loc_addr)) 2312c85bb41eSFlavio Leitner goto out; 23131da177e4SLinus Torvalds 2314c85bb41eSFlavio Leitner rcu_read_lock(); 23151d7138deSEric Dumazet for_each_pmc_rcu(inet, pmc) { 23161da177e4SLinus Torvalds if (pmc->multi.imr_multiaddr.s_addr == loc_addr && 23171da177e4SLinus Torvalds pmc->multi.imr_ifindex == dif) 23181da177e4SLinus Torvalds break; 23191da177e4SLinus Torvalds } 2320c85bb41eSFlavio Leitner ret = inet->mc_all; 23211da177e4SLinus Torvalds if (!pmc) 2322c85bb41eSFlavio Leitner goto unlock; 23231d7138deSEric Dumazet psl = rcu_dereference(pmc->sflist); 2324c85bb41eSFlavio Leitner ret = (pmc->sfmode == MCAST_EXCLUDE); 23251da177e4SLinus Torvalds if (!psl) 2326c85bb41eSFlavio Leitner goto unlock; 23271da177e4SLinus Torvalds 23281da177e4SLinus Torvalds for (i=0; i<psl->sl_count; i++) { 23291da177e4SLinus Torvalds if (psl->sl_addr[i] == rmt_addr) 23301da177e4SLinus Torvalds break; 23311da177e4SLinus Torvalds } 2332c85bb41eSFlavio Leitner ret = 0; 23331da177e4SLinus Torvalds if (pmc->sfmode == MCAST_INCLUDE && i >= psl->sl_count) 2334c85bb41eSFlavio Leitner goto unlock; 23351da177e4SLinus Torvalds if (pmc->sfmode == MCAST_EXCLUDE && i < psl->sl_count) 2336c85bb41eSFlavio Leitner goto unlock; 2337c85bb41eSFlavio Leitner ret = 1; 2338c85bb41eSFlavio Leitner unlock: 2339c85bb41eSFlavio Leitner rcu_read_unlock(); 2340c85bb41eSFlavio Leitner out: 2341c85bb41eSFlavio Leitner return ret; 23421da177e4SLinus Torvalds } 23431da177e4SLinus Torvalds 23441da177e4SLinus Torvalds /* 23451da177e4SLinus Torvalds * A socket is closing. 23461da177e4SLinus Torvalds */ 23471da177e4SLinus Torvalds 23481da177e4SLinus Torvalds void ip_mc_drop_socket(struct sock *sk) 23491da177e4SLinus Torvalds { 23501da177e4SLinus Torvalds struct inet_sock *inet = inet_sk(sk); 23511da177e4SLinus Torvalds struct ip_mc_socklist *iml; 2352877acedcSDaniel Lezcano struct net *net = sock_net(sk); 23531da177e4SLinus Torvalds 23541da177e4SLinus Torvalds if (inet->mc_list == NULL) 23551da177e4SLinus Torvalds return; 23561da177e4SLinus Torvalds 23571da177e4SLinus Torvalds rtnl_lock(); 23581d7138deSEric Dumazet while ((iml = rtnl_dereference(inet->mc_list)) != NULL) { 23591da177e4SLinus Torvalds struct in_device *in_dev; 23601da177e4SLinus Torvalds 23611d7138deSEric Dumazet inet->mc_list = iml->next_rcu; 2362877acedcSDaniel Lezcano in_dev = inetdev_by_index(net, iml->multi.imr_ifindex); 23631da177e4SLinus Torvalds (void) ip_mc_leave_src(sk, iml, in_dev); 236418943d29SEric Dumazet if (in_dev != NULL) 23651da177e4SLinus Torvalds ip_mc_dec_group(in_dev, iml->multi.imr_multiaddr.s_addr); 2366c85bb41eSFlavio Leitner /* decrease mem now to avoid the memleak warning */ 2367c85bb41eSFlavio Leitner atomic_sub(sizeof(*iml), &sk->sk_omem_alloc); 236810d50e74SLai Jiangshan kfree_rcu(iml, rcu); 23691da177e4SLinus Torvalds } 23701da177e4SLinus Torvalds rtnl_unlock(); 23711da177e4SLinus Torvalds } 23721da177e4SLinus Torvalds 2373dbdd9a52SDavid S. Miller /* called with rcu_read_lock() */ 2374dbdd9a52SDavid S. Miller int ip_check_mc_rcu(struct in_device *in_dev, __be32 mc_addr, __be32 src_addr, u16 proto) 23751da177e4SLinus Torvalds { 23761da177e4SLinus Torvalds struct ip_mc_list *im; 2377e9897071SEric Dumazet struct ip_mc_list __rcu **mc_hash; 23781da177e4SLinus Torvalds struct ip_sf_list *psf; 23791da177e4SLinus Torvalds int rv = 0; 23801da177e4SLinus Torvalds 2381e9897071SEric Dumazet mc_hash = rcu_dereference(in_dev->mc_hash); 2382e9897071SEric Dumazet if (mc_hash) { 2383c70eba74SEric Dumazet u32 hash = hash_32((__force u32)mc_addr, MC_HASH_SZ_LOG); 2384e9897071SEric Dumazet 2385e9897071SEric Dumazet for (im = rcu_dereference(mc_hash[hash]); 2386e9897071SEric Dumazet im != NULL; 2387e9897071SEric Dumazet im = rcu_dereference(im->next_hash)) { 2388e9897071SEric Dumazet if (im->multiaddr == mc_addr) 2389e9897071SEric Dumazet break; 2390e9897071SEric Dumazet } 2391e9897071SEric Dumazet } else { 23921d7138deSEric Dumazet for_each_pmc_rcu(in_dev, im) { 23931da177e4SLinus Torvalds if (im->multiaddr == mc_addr) 23941da177e4SLinus Torvalds break; 23951da177e4SLinus Torvalds } 2396e9897071SEric Dumazet } 23971da177e4SLinus Torvalds if (im && proto == IPPROTO_IGMP) { 23981da177e4SLinus Torvalds rv = 1; 23991da177e4SLinus Torvalds } else if (im) { 24001da177e4SLinus Torvalds if (src_addr) { 24011da177e4SLinus Torvalds for (psf=im->sources; psf; psf=psf->sf_next) { 24021da177e4SLinus Torvalds if (psf->sf_inaddr == src_addr) 24031da177e4SLinus Torvalds break; 24041da177e4SLinus Torvalds } 24051da177e4SLinus Torvalds if (psf) 24061da177e4SLinus Torvalds rv = psf->sf_count[MCAST_INCLUDE] || 24071da177e4SLinus Torvalds psf->sf_count[MCAST_EXCLUDE] != 24081da177e4SLinus Torvalds im->sfcount[MCAST_EXCLUDE]; 24091da177e4SLinus Torvalds else 24101da177e4SLinus Torvalds rv = im->sfcount[MCAST_EXCLUDE] != 0; 24111da177e4SLinus Torvalds } else 24121da177e4SLinus Torvalds rv = 1; /* unspecified source; tentatively allow */ 24131da177e4SLinus Torvalds } 24141da177e4SLinus Torvalds return rv; 24151da177e4SLinus Torvalds } 24161da177e4SLinus Torvalds 24171da177e4SLinus Torvalds #if defined(CONFIG_PROC_FS) 24181da177e4SLinus Torvalds struct igmp_mc_iter_state { 24197091e728SAlexey Dobriyan struct seq_net_private p; 24201da177e4SLinus Torvalds struct net_device *dev; 24211da177e4SLinus Torvalds struct in_device *in_dev; 24221da177e4SLinus Torvalds }; 24231da177e4SLinus Torvalds 24241da177e4SLinus Torvalds #define igmp_mc_seq_private(seq) ((struct igmp_mc_iter_state *)(seq)->private) 24251da177e4SLinus Torvalds 24261da177e4SLinus Torvalds static inline struct ip_mc_list *igmp_mc_get_first(struct seq_file *seq) 24271da177e4SLinus Torvalds { 24287091e728SAlexey Dobriyan struct net *net = seq_file_net(seq); 24291da177e4SLinus Torvalds struct ip_mc_list *im = NULL; 24301da177e4SLinus Torvalds struct igmp_mc_iter_state *state = igmp_mc_seq_private(seq); 24311da177e4SLinus Torvalds 24327562f876SPavel Emelianov state->in_dev = NULL; 243361fbab77Sstephen hemminger for_each_netdev_rcu(net, state->dev) { 24341da177e4SLinus Torvalds struct in_device *in_dev; 24356baff150SEric Dumazet 24366baff150SEric Dumazet in_dev = __in_dev_get_rcu(state->dev); 24371da177e4SLinus Torvalds if (!in_dev) 24381da177e4SLinus Torvalds continue; 24391d7138deSEric Dumazet im = rcu_dereference(in_dev->mc_list); 24401da177e4SLinus Torvalds if (im) { 24411da177e4SLinus Torvalds state->in_dev = in_dev; 24421da177e4SLinus Torvalds break; 24431da177e4SLinus Torvalds } 24441da177e4SLinus Torvalds } 24451da177e4SLinus Torvalds return im; 24461da177e4SLinus Torvalds } 24471da177e4SLinus Torvalds 24481da177e4SLinus Torvalds static struct ip_mc_list *igmp_mc_get_next(struct seq_file *seq, struct ip_mc_list *im) 24491da177e4SLinus Torvalds { 24501da177e4SLinus Torvalds struct igmp_mc_iter_state *state = igmp_mc_seq_private(seq); 24516baff150SEric Dumazet 24521d7138deSEric Dumazet im = rcu_dereference(im->next_rcu); 24531d7138deSEric Dumazet while (!im) { 24546baff150SEric Dumazet state->dev = next_net_device_rcu(state->dev); 24551da177e4SLinus Torvalds if (!state->dev) { 24561da177e4SLinus Torvalds state->in_dev = NULL; 24571da177e4SLinus Torvalds break; 24581da177e4SLinus Torvalds } 24596baff150SEric Dumazet state->in_dev = __in_dev_get_rcu(state->dev); 24601da177e4SLinus Torvalds if (!state->in_dev) 24611da177e4SLinus Torvalds continue; 24621d7138deSEric Dumazet im = rcu_dereference(state->in_dev->mc_list); 24631da177e4SLinus Torvalds } 24641da177e4SLinus Torvalds return im; 24651da177e4SLinus Torvalds } 24661da177e4SLinus Torvalds 24671da177e4SLinus Torvalds static struct ip_mc_list *igmp_mc_get_idx(struct seq_file *seq, loff_t pos) 24681da177e4SLinus Torvalds { 24691da177e4SLinus Torvalds struct ip_mc_list *im = igmp_mc_get_first(seq); 24701da177e4SLinus Torvalds if (im) 24711da177e4SLinus Torvalds while (pos && (im = igmp_mc_get_next(seq, im)) != NULL) 24721da177e4SLinus Torvalds --pos; 24731da177e4SLinus Torvalds return pos ? NULL : im; 24741da177e4SLinus Torvalds } 24751da177e4SLinus Torvalds 24761da177e4SLinus Torvalds static void *igmp_mc_seq_start(struct seq_file *seq, loff_t *pos) 247761fbab77Sstephen hemminger __acquires(rcu) 24781da177e4SLinus Torvalds { 247961fbab77Sstephen hemminger rcu_read_lock(); 24801da177e4SLinus Torvalds return *pos ? igmp_mc_get_idx(seq, *pos - 1) : SEQ_START_TOKEN; 24811da177e4SLinus Torvalds } 24821da177e4SLinus Torvalds 24831da177e4SLinus Torvalds static void *igmp_mc_seq_next(struct seq_file *seq, void *v, loff_t *pos) 24841da177e4SLinus Torvalds { 24851da177e4SLinus Torvalds struct ip_mc_list *im; 24861da177e4SLinus Torvalds if (v == SEQ_START_TOKEN) 24871da177e4SLinus Torvalds im = igmp_mc_get_first(seq); 24881da177e4SLinus Torvalds else 24891da177e4SLinus Torvalds im = igmp_mc_get_next(seq, v); 24901da177e4SLinus Torvalds ++*pos; 24911da177e4SLinus Torvalds return im; 24921da177e4SLinus Torvalds } 24931da177e4SLinus Torvalds 24941da177e4SLinus Torvalds static void igmp_mc_seq_stop(struct seq_file *seq, void *v) 249561fbab77Sstephen hemminger __releases(rcu) 24961da177e4SLinus Torvalds { 24971da177e4SLinus Torvalds struct igmp_mc_iter_state *state = igmp_mc_seq_private(seq); 24981d7138deSEric Dumazet 24991da177e4SLinus Torvalds state->in_dev = NULL; 25001da177e4SLinus Torvalds state->dev = NULL; 250161fbab77Sstephen hemminger rcu_read_unlock(); 25021da177e4SLinus Torvalds } 25031da177e4SLinus Torvalds 25041da177e4SLinus Torvalds static int igmp_mc_seq_show(struct seq_file *seq, void *v) 25051da177e4SLinus Torvalds { 25061da177e4SLinus Torvalds if (v == SEQ_START_TOKEN) 25071da177e4SLinus Torvalds seq_puts(seq, 25081da177e4SLinus Torvalds "Idx\tDevice : Count Querier\tGroup Users Timer\tReporter\n"); 25091da177e4SLinus Torvalds else { 25101da177e4SLinus Torvalds struct ip_mc_list *im = (struct ip_mc_list *)v; 25111da177e4SLinus Torvalds struct igmp_mc_iter_state *state = igmp_mc_seq_private(seq); 25121da177e4SLinus Torvalds char *querier; 2513a399a805SEric Dumazet long delta; 2514a399a805SEric Dumazet 25151da177e4SLinus Torvalds #ifdef CONFIG_IP_MULTICAST 25161da177e4SLinus Torvalds querier = IGMP_V1_SEEN(state->in_dev) ? "V1" : 25171da177e4SLinus Torvalds IGMP_V2_SEEN(state->in_dev) ? "V2" : 25181da177e4SLinus Torvalds "V3"; 25191da177e4SLinus Torvalds #else 25201da177e4SLinus Torvalds querier = "NONE"; 25211da177e4SLinus Torvalds #endif 25221da177e4SLinus Torvalds 25231d7138deSEric Dumazet if (rcu_dereference(state->in_dev->mc_list) == im) { 25241da177e4SLinus Torvalds seq_printf(seq, "%d\t%-10s: %5d %7s\n", 2525b8bae41eSRami Rosen state->dev->ifindex, state->dev->name, state->in_dev->mc_count, querier); 25261da177e4SLinus Torvalds } 25271da177e4SLinus Torvalds 2528a399a805SEric Dumazet delta = im->timer.expires - jiffies; 25291da177e4SLinus Torvalds seq_printf(seq, 2530338fcf98SAlexey Dobriyan "\t\t\t\t%08X %5d %d:%08lX\t\t%d\n", 25311da177e4SLinus Torvalds im->multiaddr, im->users, 2532a399a805SEric Dumazet im->tm_running, 2533a399a805SEric Dumazet im->tm_running ? jiffies_delta_to_clock_t(delta) : 0, 25341da177e4SLinus Torvalds im->reporter); 25351da177e4SLinus Torvalds } 25361da177e4SLinus Torvalds return 0; 25371da177e4SLinus Torvalds } 25381da177e4SLinus Torvalds 2539f690808eSStephen Hemminger static const struct seq_operations igmp_mc_seq_ops = { 25401da177e4SLinus Torvalds .start = igmp_mc_seq_start, 25411da177e4SLinus Torvalds .next = igmp_mc_seq_next, 25421da177e4SLinus Torvalds .stop = igmp_mc_seq_stop, 25431da177e4SLinus Torvalds .show = igmp_mc_seq_show, 25441da177e4SLinus Torvalds }; 25451da177e4SLinus Torvalds 25461da177e4SLinus Torvalds static int igmp_mc_seq_open(struct inode *inode, struct file *file) 25471da177e4SLinus Torvalds { 25487091e728SAlexey Dobriyan return seq_open_net(inode, file, &igmp_mc_seq_ops, 2549cf7732e4SPavel Emelyanov sizeof(struct igmp_mc_iter_state)); 25501da177e4SLinus Torvalds } 25511da177e4SLinus Torvalds 25529a32144eSArjan van de Ven static const struct file_operations igmp_mc_seq_fops = { 25531da177e4SLinus Torvalds .owner = THIS_MODULE, 25541da177e4SLinus Torvalds .open = igmp_mc_seq_open, 25551da177e4SLinus Torvalds .read = seq_read, 25561da177e4SLinus Torvalds .llseek = seq_lseek, 25577091e728SAlexey Dobriyan .release = seq_release_net, 25581da177e4SLinus Torvalds }; 25591da177e4SLinus Torvalds 25601da177e4SLinus Torvalds struct igmp_mcf_iter_state { 25617091e728SAlexey Dobriyan struct seq_net_private p; 25621da177e4SLinus Torvalds struct net_device *dev; 25631da177e4SLinus Torvalds struct in_device *idev; 25641da177e4SLinus Torvalds struct ip_mc_list *im; 25651da177e4SLinus Torvalds }; 25661da177e4SLinus Torvalds 25671da177e4SLinus Torvalds #define igmp_mcf_seq_private(seq) ((struct igmp_mcf_iter_state *)(seq)->private) 25681da177e4SLinus Torvalds 25691da177e4SLinus Torvalds static inline struct ip_sf_list *igmp_mcf_get_first(struct seq_file *seq) 25701da177e4SLinus Torvalds { 25717091e728SAlexey Dobriyan struct net *net = seq_file_net(seq); 25721da177e4SLinus Torvalds struct ip_sf_list *psf = NULL; 25731da177e4SLinus Torvalds struct ip_mc_list *im = NULL; 25741da177e4SLinus Torvalds struct igmp_mcf_iter_state *state = igmp_mcf_seq_private(seq); 25751da177e4SLinus Torvalds 25767562f876SPavel Emelianov state->idev = NULL; 25777562f876SPavel Emelianov state->im = NULL; 257861fbab77Sstephen hemminger for_each_netdev_rcu(net, state->dev) { 25791da177e4SLinus Torvalds struct in_device *idev; 25806baff150SEric Dumazet idev = __in_dev_get_rcu(state->dev); 25811da177e4SLinus Torvalds if (unlikely(idev == NULL)) 25821da177e4SLinus Torvalds continue; 25831d7138deSEric Dumazet im = rcu_dereference(idev->mc_list); 25841da177e4SLinus Torvalds if (likely(im != NULL)) { 25851da177e4SLinus Torvalds spin_lock_bh(&im->lock); 25861da177e4SLinus Torvalds psf = im->sources; 25871da177e4SLinus Torvalds if (likely(psf != NULL)) { 25881da177e4SLinus Torvalds state->im = im; 25891da177e4SLinus Torvalds state->idev = idev; 25901da177e4SLinus Torvalds break; 25911da177e4SLinus Torvalds } 25921da177e4SLinus Torvalds spin_unlock_bh(&im->lock); 25931da177e4SLinus Torvalds } 25941da177e4SLinus Torvalds } 25951da177e4SLinus Torvalds return psf; 25961da177e4SLinus Torvalds } 25971da177e4SLinus Torvalds 25981da177e4SLinus Torvalds static struct ip_sf_list *igmp_mcf_get_next(struct seq_file *seq, struct ip_sf_list *psf) 25991da177e4SLinus Torvalds { 26001da177e4SLinus Torvalds struct igmp_mcf_iter_state *state = igmp_mcf_seq_private(seq); 26011da177e4SLinus Torvalds 26021da177e4SLinus Torvalds psf = psf->sf_next; 26031da177e4SLinus Torvalds while (!psf) { 26041da177e4SLinus Torvalds spin_unlock_bh(&state->im->lock); 26051da177e4SLinus Torvalds state->im = state->im->next; 26061da177e4SLinus Torvalds while (!state->im) { 26076baff150SEric Dumazet state->dev = next_net_device_rcu(state->dev); 26081da177e4SLinus Torvalds if (!state->dev) { 26091da177e4SLinus Torvalds state->idev = NULL; 26101da177e4SLinus Torvalds goto out; 26111da177e4SLinus Torvalds } 26126baff150SEric Dumazet state->idev = __in_dev_get_rcu(state->dev); 26131da177e4SLinus Torvalds if (!state->idev) 26141da177e4SLinus Torvalds continue; 26151d7138deSEric Dumazet state->im = rcu_dereference(state->idev->mc_list); 26161da177e4SLinus Torvalds } 26171da177e4SLinus Torvalds if (!state->im) 26181da177e4SLinus Torvalds break; 26191da177e4SLinus Torvalds spin_lock_bh(&state->im->lock); 26201da177e4SLinus Torvalds psf = state->im->sources; 26211da177e4SLinus Torvalds } 26221da177e4SLinus Torvalds out: 26231da177e4SLinus Torvalds return psf; 26241da177e4SLinus Torvalds } 26251da177e4SLinus Torvalds 26261da177e4SLinus Torvalds static struct ip_sf_list *igmp_mcf_get_idx(struct seq_file *seq, loff_t pos) 26271da177e4SLinus Torvalds { 26281da177e4SLinus Torvalds struct ip_sf_list *psf = igmp_mcf_get_first(seq); 26291da177e4SLinus Torvalds if (psf) 26301da177e4SLinus Torvalds while (pos && (psf = igmp_mcf_get_next(seq, psf)) != NULL) 26311da177e4SLinus Torvalds --pos; 26321da177e4SLinus Torvalds return pos ? NULL : psf; 26331da177e4SLinus Torvalds } 26341da177e4SLinus Torvalds 26351da177e4SLinus Torvalds static void *igmp_mcf_seq_start(struct seq_file *seq, loff_t *pos) 263661fbab77Sstephen hemminger __acquires(rcu) 26371da177e4SLinus Torvalds { 263861fbab77Sstephen hemminger rcu_read_lock(); 26391da177e4SLinus Torvalds return *pos ? igmp_mcf_get_idx(seq, *pos - 1) : SEQ_START_TOKEN; 26401da177e4SLinus Torvalds } 26411da177e4SLinus Torvalds 26421da177e4SLinus Torvalds static void *igmp_mcf_seq_next(struct seq_file *seq, void *v, loff_t *pos) 26431da177e4SLinus Torvalds { 26441da177e4SLinus Torvalds struct ip_sf_list *psf; 26451da177e4SLinus Torvalds if (v == SEQ_START_TOKEN) 26461da177e4SLinus Torvalds psf = igmp_mcf_get_first(seq); 26471da177e4SLinus Torvalds else 26481da177e4SLinus Torvalds psf = igmp_mcf_get_next(seq, v); 26491da177e4SLinus Torvalds ++*pos; 26501da177e4SLinus Torvalds return psf; 26511da177e4SLinus Torvalds } 26521da177e4SLinus Torvalds 26531da177e4SLinus Torvalds static void igmp_mcf_seq_stop(struct seq_file *seq, void *v) 265461fbab77Sstephen hemminger __releases(rcu) 26551da177e4SLinus Torvalds { 26561da177e4SLinus Torvalds struct igmp_mcf_iter_state *state = igmp_mcf_seq_private(seq); 26571da177e4SLinus Torvalds if (likely(state->im != NULL)) { 26581da177e4SLinus Torvalds spin_unlock_bh(&state->im->lock); 26591da177e4SLinus Torvalds state->im = NULL; 26601da177e4SLinus Torvalds } 26611da177e4SLinus Torvalds state->idev = NULL; 26621da177e4SLinus Torvalds state->dev = NULL; 266361fbab77Sstephen hemminger rcu_read_unlock(); 26641da177e4SLinus Torvalds } 26651da177e4SLinus Torvalds 26661da177e4SLinus Torvalds static int igmp_mcf_seq_show(struct seq_file *seq, void *v) 26671da177e4SLinus Torvalds { 26681da177e4SLinus Torvalds struct ip_sf_list *psf = (struct ip_sf_list *)v; 26691da177e4SLinus Torvalds struct igmp_mcf_iter_state *state = igmp_mcf_seq_private(seq); 26701da177e4SLinus Torvalds 26711da177e4SLinus Torvalds if (v == SEQ_START_TOKEN) { 26721da177e4SLinus Torvalds seq_printf(seq, 26731da177e4SLinus Torvalds "%3s %6s " 26741da177e4SLinus Torvalds "%10s %10s %6s %6s\n", "Idx", 26751da177e4SLinus Torvalds "Device", "MCA", 26761da177e4SLinus Torvalds "SRC", "INC", "EXC"); 26771da177e4SLinus Torvalds } else { 26781da177e4SLinus Torvalds seq_printf(seq, 26791da177e4SLinus Torvalds "%3d %6.6s 0x%08x " 26801da177e4SLinus Torvalds "0x%08x %6lu %6lu\n", 26811da177e4SLinus Torvalds state->dev->ifindex, state->dev->name, 26821da177e4SLinus Torvalds ntohl(state->im->multiaddr), 26831da177e4SLinus Torvalds ntohl(psf->sf_inaddr), 26841da177e4SLinus Torvalds psf->sf_count[MCAST_INCLUDE], 26851da177e4SLinus Torvalds psf->sf_count[MCAST_EXCLUDE]); 26861da177e4SLinus Torvalds } 26871da177e4SLinus Torvalds return 0; 26881da177e4SLinus Torvalds } 26891da177e4SLinus Torvalds 2690f690808eSStephen Hemminger static const struct seq_operations igmp_mcf_seq_ops = { 26911da177e4SLinus Torvalds .start = igmp_mcf_seq_start, 26921da177e4SLinus Torvalds .next = igmp_mcf_seq_next, 26931da177e4SLinus Torvalds .stop = igmp_mcf_seq_stop, 26941da177e4SLinus Torvalds .show = igmp_mcf_seq_show, 26951da177e4SLinus Torvalds }; 26961da177e4SLinus Torvalds 26971da177e4SLinus Torvalds static int igmp_mcf_seq_open(struct inode *inode, struct file *file) 26981da177e4SLinus Torvalds { 26997091e728SAlexey Dobriyan return seq_open_net(inode, file, &igmp_mcf_seq_ops, 2700cf7732e4SPavel Emelyanov sizeof(struct igmp_mcf_iter_state)); 27011da177e4SLinus Torvalds } 27021da177e4SLinus Torvalds 27039a32144eSArjan van de Ven static const struct file_operations igmp_mcf_seq_fops = { 27041da177e4SLinus Torvalds .owner = THIS_MODULE, 27051da177e4SLinus Torvalds .open = igmp_mcf_seq_open, 27061da177e4SLinus Torvalds .read = seq_read, 27071da177e4SLinus Torvalds .llseek = seq_lseek, 27087091e728SAlexey Dobriyan .release = seq_release_net, 27097091e728SAlexey Dobriyan }; 27107091e728SAlexey Dobriyan 27112c8c1e72SAlexey Dobriyan static int __net_init igmp_net_init(struct net *net) 27127091e728SAlexey Dobriyan { 27137091e728SAlexey Dobriyan struct proc_dir_entry *pde; 27147091e728SAlexey Dobriyan 2715d4beaa66SGao feng pde = proc_create("igmp", S_IRUGO, net->proc_net, &igmp_mc_seq_fops); 27167091e728SAlexey Dobriyan if (!pde) 27177091e728SAlexey Dobriyan goto out_igmp; 2718d4beaa66SGao feng pde = proc_create("mcfilter", S_IRUGO, net->proc_net, 2719d4beaa66SGao feng &igmp_mcf_seq_fops); 27207091e728SAlexey Dobriyan if (!pde) 27217091e728SAlexey Dobriyan goto out_mcfilter; 27227091e728SAlexey Dobriyan return 0; 27237091e728SAlexey Dobriyan 27247091e728SAlexey Dobriyan out_mcfilter: 2725ece31ffdSGao feng remove_proc_entry("igmp", net->proc_net); 27267091e728SAlexey Dobriyan out_igmp: 27277091e728SAlexey Dobriyan return -ENOMEM; 27287091e728SAlexey Dobriyan } 27297091e728SAlexey Dobriyan 27302c8c1e72SAlexey Dobriyan static void __net_exit igmp_net_exit(struct net *net) 27317091e728SAlexey Dobriyan { 2732ece31ffdSGao feng remove_proc_entry("mcfilter", net->proc_net); 2733ece31ffdSGao feng remove_proc_entry("igmp", net->proc_net); 27347091e728SAlexey Dobriyan } 27357091e728SAlexey Dobriyan 27367091e728SAlexey Dobriyan static struct pernet_operations igmp_net_ops = { 27377091e728SAlexey Dobriyan .init = igmp_net_init, 27387091e728SAlexey Dobriyan .exit = igmp_net_exit, 27391da177e4SLinus Torvalds }; 27401da177e4SLinus Torvalds 27414aa5dee4SJiri Pirko static int igmp_netdev_event(struct notifier_block *this, 27424aa5dee4SJiri Pirko unsigned long event, void *ptr) 27434aa5dee4SJiri Pirko { 27444aa5dee4SJiri Pirko struct net_device *dev = netdev_notifier_info_to_dev(ptr); 27454aa5dee4SJiri Pirko struct in_device *in_dev; 27464aa5dee4SJiri Pirko 27474aa5dee4SJiri Pirko switch (event) { 27484aa5dee4SJiri Pirko case NETDEV_RESEND_IGMP: 27494aa5dee4SJiri Pirko in_dev = __in_dev_get_rtnl(dev); 27504aa5dee4SJiri Pirko if (in_dev) 27514aa5dee4SJiri Pirko ip_mc_rejoin_groups(in_dev); 27524aa5dee4SJiri Pirko break; 27534aa5dee4SJiri Pirko default: 27544aa5dee4SJiri Pirko break; 27554aa5dee4SJiri Pirko } 27564aa5dee4SJiri Pirko return NOTIFY_DONE; 27574aa5dee4SJiri Pirko } 27584aa5dee4SJiri Pirko 27594aa5dee4SJiri Pirko static struct notifier_block igmp_notifier = { 27604aa5dee4SJiri Pirko .notifier_call = igmp_netdev_event, 27614aa5dee4SJiri Pirko }; 27624aa5dee4SJiri Pirko 27631da177e4SLinus Torvalds int __init igmp_mc_proc_init(void) 27641da177e4SLinus Torvalds { 27654aa5dee4SJiri Pirko int err; 27664aa5dee4SJiri Pirko 27674aa5dee4SJiri Pirko err = register_pernet_subsys(&igmp_net_ops); 27684aa5dee4SJiri Pirko if (err) 27694aa5dee4SJiri Pirko return err; 27704aa5dee4SJiri Pirko err = register_netdevice_notifier(&igmp_notifier); 27714aa5dee4SJiri Pirko if (err) 27724aa5dee4SJiri Pirko goto reg_notif_fail; 27734aa5dee4SJiri Pirko return 0; 27744aa5dee4SJiri Pirko 27754aa5dee4SJiri Pirko reg_notif_fail: 27764aa5dee4SJiri Pirko unregister_pernet_subsys(&igmp_net_ops); 27774aa5dee4SJiri Pirko return err; 27781da177e4SLinus Torvalds } 27791da177e4SLinus Torvalds #endif 2780