2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Linux NET3: Internet Group Management Protocol [IGMP]
|
|
|
|
*
|
|
|
|
* This code implements the IGMP protocol as defined in RFC1112. There has
|
|
|
|
* been a further revision of this protocol since which is now supported.
|
|
|
|
*
|
|
|
|
* If you have trouble with this module be careful what gcc you have used,
|
|
|
|
* the older version didn't come out right using gcc 2.5.8, the newer one
|
|
|
|
* seems to fall out with gcc 2.6.2.
|
|
|
|
*
|
|
|
|
* Authors:
|
2008-10-13 20:01:08 -06:00
|
|
|
* Alan Cox <alan@lxorguk.ukuu.org.uk>
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version
|
|
|
|
* 2 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* Fixes:
|
|
|
|
*
|
|
|
|
* Alan Cox : Added lots of __inline__ to optimise
|
|
|
|
* the memory usage of all the tiny little
|
|
|
|
* functions.
|
|
|
|
* Alan Cox : Dumped the header building experiment.
|
|
|
|
* Alan Cox : Minor tweaks ready for multicast routing
|
|
|
|
* and extended IGMP protocol.
|
|
|
|
* Alan Cox : Removed a load of inline directives. Gcc 2.5.8
|
|
|
|
* writes utterly bogus code otherwise (sigh)
|
|
|
|
* fixed IGMP loopback to behave in the manner
|
|
|
|
* desired by mrouted, fixed the fact it has been
|
|
|
|
* broken since 1.3.6 and cleaned up a few minor
|
|
|
|
* points.
|
|
|
|
*
|
|
|
|
* Chih-Jen Chang : Tried to revise IGMP to Version 2
|
|
|
|
* Tsu-Sheng Tsao E-mail: chihjenc@scf.usc.edu and tsusheng@scf.usc.edu
|
2007-02-09 07:24:47 -07:00
|
|
|
* The enhancements are mainly based on Steve Deering's
|
2005-04-16 16:20:36 -06:00
|
|
|
* ipmulti-3.5 source code.
|
|
|
|
* Chih-Jen Chang : Added the igmp_get_mrouter_info and
|
|
|
|
* Tsu-Sheng Tsao igmp_set_mrouter_info to keep track of
|
|
|
|
* the mrouted version on that device.
|
|
|
|
* Chih-Jen Chang : Added the max_resp_time parameter to
|
|
|
|
* Tsu-Sheng Tsao igmp_heard_query(). Using this parameter
|
|
|
|
* to identify the multicast router version
|
|
|
|
* and do what the IGMP version 2 specified.
|
|
|
|
* Chih-Jen Chang : Added a timer to revert to IGMP V2 router
|
|
|
|
* Tsu-Sheng Tsao if the specified time expired.
|
|
|
|
* Alan Cox : Stop IGMP from 0.0.0.0 being accepted.
|
|
|
|
* Alan Cox : Use GFP_ATOMIC in the right places.
|
|
|
|
* Christian Daudt : igmp timer wasn't set for local group
|
2007-02-09 07:24:47 -07:00
|
|
|
* memberships but was being deleted,
|
|
|
|
* which caused a "del_timer() called
|
2005-04-16 16:20:36 -06:00
|
|
|
* from %p with timer not initialized\n"
|
|
|
|
* message (960131).
|
2007-02-09 07:24:47 -07:00
|
|
|
* Christian Daudt : removed del_timer from
|
2005-04-16 16:20:36 -06:00
|
|
|
* igmp_timer_expire function (960205).
|
|
|
|
* Christian Daudt : igmp_heard_report now only calls
|
|
|
|
* igmp_timer_expire if tm->running is
|
|
|
|
* true (960216).
|
|
|
|
* Malcolm Beattie : ttl comparison wrong in igmp_rcv made
|
|
|
|
* igmp_heard_query never trigger. Expiry
|
|
|
|
* miscalculation fixed in igmp_heard_query
|
|
|
|
* and random() made to return unsigned to
|
|
|
|
* prevent negative expiry times.
|
|
|
|
* Alexey Kuznetsov: Wrong group leaving behaviour, backport
|
|
|
|
* fix from pending 2.1.x patches.
|
|
|
|
* Alan Cox: Forget to enable FDDI support earlier.
|
|
|
|
* Alexey Kuznetsov: Fixed leaving groups on device down.
|
|
|
|
* Alexey Kuznetsov: Accordance to igmp-v2-06 draft.
|
|
|
|
* David L Stevens: IGMPv3 support, with help from
|
|
|
|
* Vinay Kulkarni
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/jiffies.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/socket.h>
|
|
|
|
#include <linux/sockios.h>
|
|
|
|
#include <linux/in.h>
|
|
|
|
#include <linux/inet.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <linux/inetdevice.h>
|
|
|
|
#include <linux/igmp.h>
|
|
|
|
#include <linux/if_arp.h>
|
|
|
|
#include <linux/rtnetlink.h>
|
|
|
|
#include <linux/times.h>
|
2005-12-26 21:43:12 -07:00
|
|
|
|
2007-09-12 04:01:34 -06:00
|
|
|
#include <net/net_namespace.h>
|
2005-12-26 21:43:12 -07:00
|
|
|
#include <net/arp.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <net/ip.h>
|
|
|
|
#include <net/protocol.h>
|
|
|
|
#include <net/route.h>
|
|
|
|
#include <net/sock.h>
|
|
|
|
#include <net/checksum.h>
|
|
|
|
#include <linux/netfilter_ipv4.h>
|
|
|
|
#ifdef CONFIG_IP_MROUTE
|
|
|
|
#include <linux/mroute.h>
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_PROC_FS
|
|
|
|
#include <linux/proc_fs.h>
|
|
|
|
#include <linux/seq_file.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#define IP_MAX_MEMBERSHIPS 20
|
|
|
|
#define IP_MAX_MSF 10
|
|
|
|
|
|
|
|
#ifdef CONFIG_IP_MULTICAST
|
|
|
|
/* Parameter names and values are taken from igmp-v2-06 draft */
|
|
|
|
|
|
|
|
#define IGMP_V1_Router_Present_Timeout (400*HZ)
|
|
|
|
#define IGMP_V2_Router_Present_Timeout (400*HZ)
|
|
|
|
#define IGMP_Unsolicited_Report_Interval (10*HZ)
|
|
|
|
#define IGMP_Query_Response_Interval (10*HZ)
|
|
|
|
#define IGMP_Unsolicited_Report_Count 2
|
|
|
|
|
|
|
|
|
|
|
|
#define IGMP_Initial_Report_Delay (1)
|
|
|
|
|
|
|
|
/* IGMP_Initial_Report_Delay is not from IGMP specs!
|
|
|
|
* IGMP specs require to report membership immediately after
|
|
|
|
* joining a group, but we delay the first report by a
|
|
|
|
* small interval. It seems more natural and still does not
|
|
|
|
* contradict to specs provided this delay is small enough.
|
|
|
|
*/
|
|
|
|
|
2007-06-05 00:34:44 -06:00
|
|
|
#define IGMP_V1_SEEN(in_dev) \
|
2008-03-25 06:47:49 -06:00
|
|
|
(IPV4_DEVCONF_ALL(dev_net(in_dev->dev), FORCE_IGMP_VERSION) == 1 || \
|
2007-06-05 00:34:44 -06:00
|
|
|
IN_DEV_CONF_GET((in_dev), FORCE_IGMP_VERSION) == 1 || \
|
|
|
|
((in_dev)->mr_v1_seen && \
|
|
|
|
time_before(jiffies, (in_dev)->mr_v1_seen)))
|
|
|
|
#define IGMP_V2_SEEN(in_dev) \
|
2008-03-25 06:47:49 -06:00
|
|
|
(IPV4_DEVCONF_ALL(dev_net(in_dev->dev), FORCE_IGMP_VERSION) == 2 || \
|
2007-06-05 00:34:44 -06:00
|
|
|
IN_DEV_CONF_GET((in_dev), FORCE_IGMP_VERSION) == 2 || \
|
|
|
|
((in_dev)->mr_v2_seen && \
|
|
|
|
time_before(jiffies, (in_dev)->mr_v2_seen)))
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
static void igmpv3_add_delrec(struct in_device *in_dev, struct ip_mc_list *im);
|
2006-09-27 19:31:32 -06:00
|
|
|
static void igmpv3_del_delrec(struct in_device *in_dev, __be32 multiaddr);
|
2005-04-16 16:20:36 -06:00
|
|
|
static void igmpv3_clear_delrec(struct in_device *in_dev);
|
|
|
|
static int sf_setstate(struct ip_mc_list *pmc);
|
|
|
|
static void sf_markstate(struct ip_mc_list *pmc);
|
|
|
|
#endif
|
|
|
|
static void ip_mc_clear_src(struct ip_mc_list *pmc);
|
2006-09-27 19:30:07 -06:00
|
|
|
static int ip_mc_add_src(struct in_device *in_dev, __be32 *pmca, int sfmode,
|
|
|
|
int sfcount, __be32 *psfsrc, int delta);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
static void ip_ma_put(struct ip_mc_list *im)
|
|
|
|
{
|
|
|
|
if (atomic_dec_and_test(&im->refcnt)) {
|
|
|
|
in_dev_put(im->interface);
|
2011-03-17 21:44:08 -06:00
|
|
|
kfree_rcu(im, rcu);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-11-15 09:52:02 -07:00
|
|
|
#define for_each_pmc_rcu(in_dev, pmc) \
|
|
|
|
for (pmc = rcu_dereference(in_dev->mc_list); \
|
|
|
|
pmc != NULL; \
|
|
|
|
pmc = rcu_dereference(pmc->next_rcu))
|
|
|
|
|
|
|
|
#define for_each_pmc_rtnl(in_dev, pmc) \
|
|
|
|
for (pmc = rtnl_dereference(in_dev->mc_list); \
|
|
|
|
pmc != NULL; \
|
|
|
|
pmc = rtnl_dereference(pmc->next_rcu))
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef CONFIG_IP_MULTICAST
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Timer management
|
|
|
|
*/
|
|
|
|
|
2010-11-11 22:46:50 -07:00
|
|
|
static void igmp_stop_timer(struct ip_mc_list *im)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
spin_lock_bh(&im->lock);
|
|
|
|
if (del_timer(&im->timer))
|
|
|
|
atomic_dec(&im->refcnt);
|
2008-11-03 01:26:09 -07:00
|
|
|
im->tm_running = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
im->reporter = 0;
|
|
|
|
im->unsolicit_count = 0;
|
|
|
|
spin_unlock_bh(&im->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* It must be called with locked im->lock */
|
|
|
|
static void igmp_start_timer(struct ip_mc_list *im, int max_delay)
|
|
|
|
{
|
2008-11-03 01:26:09 -07:00
|
|
|
int tv = net_random() % max_delay;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-11-03 01:26:09 -07:00
|
|
|
im->tm_running = 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!mod_timer(&im->timer, jiffies+tv+2))
|
|
|
|
atomic_inc(&im->refcnt);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void igmp_gq_start_timer(struct in_device *in_dev)
|
|
|
|
{
|
|
|
|
int tv = net_random() % in_dev->mr_maxdelay;
|
|
|
|
|
|
|
|
in_dev->mr_gq_running = 1;
|
|
|
|
if (!mod_timer(&in_dev->mr_gq_timer, jiffies+tv+2))
|
|
|
|
in_dev_hold(in_dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void igmp_ifc_start_timer(struct in_device *in_dev, int delay)
|
|
|
|
{
|
|
|
|
int tv = net_random() % delay;
|
|
|
|
|
|
|
|
if (!mod_timer(&in_dev->mr_ifc_timer, jiffies+tv+2))
|
|
|
|
in_dev_hold(in_dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void igmp_mod_timer(struct ip_mc_list *im, int max_delay)
|
|
|
|
{
|
|
|
|
spin_lock_bh(&im->lock);
|
|
|
|
im->unsolicit_count = 0;
|
|
|
|
if (del_timer(&im->timer)) {
|
|
|
|
if ((long)(im->timer.expires-jiffies) < max_delay) {
|
|
|
|
add_timer(&im->timer);
|
2008-11-03 01:26:09 -07:00
|
|
|
im->tm_running = 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
spin_unlock_bh(&im->lock);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
atomic_dec(&im->refcnt);
|
|
|
|
}
|
|
|
|
igmp_start_timer(im, max_delay);
|
|
|
|
spin_unlock_bh(&im->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Send an IGMP report.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define IGMP_SIZE (sizeof(struct igmphdr)+sizeof(struct iphdr)+4)
|
|
|
|
|
|
|
|
|
|
|
|
static int is_in(struct ip_mc_list *pmc, struct ip_sf_list *psf, int type,
|
|
|
|
int gdeleted, int sdeleted)
|
|
|
|
{
|
|
|
|
switch (type) {
|
|
|
|
case IGMPV3_MODE_IS_INCLUDE:
|
|
|
|
case IGMPV3_MODE_IS_EXCLUDE:
|
|
|
|
if (gdeleted || sdeleted)
|
|
|
|
return 0;
|
2006-01-18 15:20:56 -07:00
|
|
|
if (!(pmc->gsquery && !psf->sf_gsresp)) {
|
|
|
|
if (pmc->sfmode == MCAST_INCLUDE)
|
|
|
|
return 1;
|
|
|
|
/* don't include if this source is excluded
|
|
|
|
* in all filters
|
|
|
|
*/
|
|
|
|
if (psf->sf_count[MCAST_INCLUDE])
|
|
|
|
return type == IGMPV3_MODE_IS_INCLUDE;
|
|
|
|
return pmc->sfcount[MCAST_EXCLUDE] ==
|
|
|
|
psf->sf_count[MCAST_EXCLUDE];
|
|
|
|
}
|
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
case IGMPV3_CHANGE_TO_INCLUDE:
|
|
|
|
if (gdeleted || sdeleted)
|
|
|
|
return 0;
|
|
|
|
return psf->sf_count[MCAST_INCLUDE] != 0;
|
|
|
|
case IGMPV3_CHANGE_TO_EXCLUDE:
|
|
|
|
if (gdeleted || sdeleted)
|
|
|
|
return 0;
|
|
|
|
if (pmc->sfcount[MCAST_EXCLUDE] == 0 ||
|
|
|
|
psf->sf_count[MCAST_INCLUDE])
|
|
|
|
return 0;
|
|
|
|
return pmc->sfcount[MCAST_EXCLUDE] ==
|
|
|
|
psf->sf_count[MCAST_EXCLUDE];
|
|
|
|
case IGMPV3_ALLOW_NEW_SOURCES:
|
|
|
|
if (gdeleted || !psf->sf_crcount)
|
|
|
|
return 0;
|
|
|
|
return (pmc->sfmode == MCAST_INCLUDE) ^ sdeleted;
|
|
|
|
case IGMPV3_BLOCK_OLD_SOURCES:
|
|
|
|
if (pmc->sfmode == MCAST_INCLUDE)
|
|
|
|
return gdeleted || (psf->sf_crcount && sdeleted);
|
|
|
|
return psf->sf_crcount && !gdeleted && !sdeleted;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
igmp_scount(struct ip_mc_list *pmc, int type, int gdeleted, int sdeleted)
|
|
|
|
{
|
|
|
|
struct ip_sf_list *psf;
|
|
|
|
int scount = 0;
|
|
|
|
|
|
|
|
for (psf=pmc->sources; psf; psf=psf->sf_next) {
|
|
|
|
if (!is_in(pmc, psf, type, gdeleted, sdeleted))
|
|
|
|
continue;
|
|
|
|
scount++;
|
|
|
|
}
|
|
|
|
return scount;
|
|
|
|
}
|
|
|
|
|
2010-11-16 13:36:42 -07:00
|
|
|
#define igmp_skb_size(skb) (*(unsigned int *)((skb)->cb))
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static struct sk_buff *igmpv3_newpack(struct net_device *dev, int size)
|
|
|
|
{
|
|
|
|
struct sk_buff *skb;
|
|
|
|
struct rtable *rt;
|
|
|
|
struct iphdr *pip;
|
|
|
|
struct igmpv3_report *pig;
|
2008-08-13 17:15:57 -06:00
|
|
|
struct net *net = dev_net(dev);
|
2011-05-03 21:25:42 -06:00
|
|
|
struct flowi4 fl4;
|
2011-11-17 19:20:04 -07:00
|
|
|
int hlen = LL_RESERVED_SPACE(dev);
|
|
|
|
int tlen = dev->needed_tailroom;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-11-16 13:36:42 -07:00
|
|
|
while (1) {
|
2011-11-17 19:20:04 -07:00
|
|
|
skb = alloc_skb(size + hlen + tlen,
|
2010-11-16 13:36:42 -07:00
|
|
|
GFP_ATOMIC | __GFP_NOWARN);
|
|
|
|
if (skb)
|
|
|
|
break;
|
|
|
|
size >>= 1;
|
|
|
|
if (size < 256)
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
igmp_skb_size(skb) = size;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-05-03 21:25:42 -06:00
|
|
|
rt = ip_route_output_ports(net, &fl4, NULL, IGMPV3_ALL_MCR, 0,
|
2011-03-11 22:00:52 -07:00
|
|
|
0, 0,
|
|
|
|
IPPROTO_IGMP, 0, dev->ifindex);
|
|
|
|
if (IS_ERR(rt)) {
|
|
|
|
kfree_skb(skb);
|
|
|
|
return NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2010-06-11 00:31:35 -06:00
|
|
|
skb_dst_set(skb, &rt->dst);
|
2005-04-16 16:20:36 -06:00
|
|
|
skb->dev = dev;
|
|
|
|
|
2011-11-17 19:20:04 -07:00
|
|
|
skb_reserve(skb, hlen);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-03-10 14:40:59 -07:00
|
|
|
skb_reset_network_header(skb);
|
2007-04-20 23:47:35 -06:00
|
|
|
pip = ip_hdr(skb);
|
2007-03-10 14:40:59 -07:00
|
|
|
skb_put(skb, sizeof(struct iphdr) + 4);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
pip->version = 4;
|
|
|
|
pip->ihl = (sizeof(struct iphdr)+4)>>2;
|
|
|
|
pip->tos = 0xc0;
|
|
|
|
pip->frag_off = htons(IP_DF);
|
|
|
|
pip->ttl = 1;
|
2011-05-03 21:53:12 -06:00
|
|
|
pip->daddr = fl4.daddr;
|
|
|
|
pip->saddr = fl4.saddr;
|
2005-04-16 16:20:36 -06:00
|
|
|
pip->protocol = IPPROTO_IGMP;
|
|
|
|
pip->tot_len = 0; /* filled in later */
|
2010-06-11 00:31:35 -06:00
|
|
|
ip_select_ident(pip, &rt->dst, NULL);
|
2012-04-14 19:34:41 -06:00
|
|
|
((u8 *)&pip[1])[0] = IPOPT_RA;
|
|
|
|
((u8 *)&pip[1])[1] = 4;
|
|
|
|
((u8 *)&pip[1])[2] = 0;
|
|
|
|
((u8 *)&pip[1])[3] = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-04-10 22:21:55 -06:00
|
|
|
skb->transport_header = skb->network_header + sizeof(struct iphdr) + 4;
|
2007-03-14 18:05:37 -06:00
|
|
|
skb_put(skb, sizeof(*pig));
|
2007-03-13 11:19:23 -06:00
|
|
|
pig = igmpv3_report_hdr(skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
pig->type = IGMPV3_HOST_MEMBERSHIP_REPORT;
|
|
|
|
pig->resv1 = 0;
|
|
|
|
pig->csum = 0;
|
|
|
|
pig->resv2 = 0;
|
|
|
|
pig->ngrec = 0;
|
|
|
|
return skb;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int igmpv3_sendpack(struct sk_buff *skb)
|
|
|
|
{
|
2007-03-13 11:19:23 -06:00
|
|
|
struct igmphdr *pig = igmp_hdr(skb);
|
2007-04-19 21:29:13 -06:00
|
|
|
const int igmplen = skb->tail - skb->transport_header;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-03-13 11:19:23 -06:00
|
|
|
pig->csum = ip_compute_csum(igmp_hdr(skb), igmplen);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-01-11 20:14:00 -07:00
|
|
|
return ip_local_out(skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int grec_size(struct ip_mc_list *pmc, int type, int gdel, int sdel)
|
|
|
|
{
|
2008-11-03 01:26:09 -07:00
|
|
|
return sizeof(struct igmpv3_grec) + 4*igmp_scount(pmc, type, gdel, sdel);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct sk_buff *add_grhead(struct sk_buff *skb, struct ip_mc_list *pmc,
|
|
|
|
int type, struct igmpv3_grec **ppgr)
|
|
|
|
{
|
|
|
|
struct net_device *dev = pmc->interface->dev;
|
|
|
|
struct igmpv3_report *pih;
|
|
|
|
struct igmpv3_grec *pgr;
|
|
|
|
|
|
|
|
if (!skb)
|
|
|
|
skb = igmpv3_newpack(dev, dev->mtu);
|
|
|
|
if (!skb)
|
|
|
|
return NULL;
|
|
|
|
pgr = (struct igmpv3_grec *)skb_put(skb, sizeof(struct igmpv3_grec));
|
|
|
|
pgr->grec_type = type;
|
|
|
|
pgr->grec_auxwords = 0;
|
|
|
|
pgr->grec_nsrcs = 0;
|
|
|
|
pgr->grec_mca = pmc->multiaddr;
|
2007-03-13 11:19:23 -06:00
|
|
|
pih = igmpv3_report_hdr(skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
pih->ngrec = htons(ntohs(pih->ngrec)+1);
|
|
|
|
*ppgr = pgr;
|
|
|
|
return skb;
|
|
|
|
}
|
|
|
|
|
2010-11-16 13:36:42 -07:00
|
|
|
#define AVAILABLE(skb) ((skb) ? ((skb)->dev ? igmp_skb_size(skb) - (skb)->len : \
|
2005-04-16 16:20:36 -06:00
|
|
|
skb_tailroom(skb)) : 0)
|
|
|
|
|
|
|
|
static struct sk_buff *add_grec(struct sk_buff *skb, struct ip_mc_list *pmc,
|
|
|
|
int type, int gdeleted, int sdeleted)
|
|
|
|
{
|
|
|
|
struct net_device *dev = pmc->interface->dev;
|
|
|
|
struct igmpv3_report *pih;
|
|
|
|
struct igmpv3_grec *pgr = NULL;
|
|
|
|
struct ip_sf_list *psf, *psf_next, *psf_prev, **psf_list;
|
2006-01-18 15:20:56 -07:00
|
|
|
int scount, stotal, first, isquery, truncate;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (pmc->multiaddr == IGMP_ALL_HOSTS)
|
|
|
|
return skb;
|
|
|
|
|
|
|
|
isquery = type == IGMPV3_MODE_IS_INCLUDE ||
|
|
|
|
type == IGMPV3_MODE_IS_EXCLUDE;
|
|
|
|
truncate = type == IGMPV3_MODE_IS_EXCLUDE ||
|
|
|
|
type == IGMPV3_CHANGE_TO_EXCLUDE;
|
|
|
|
|
2006-01-18 15:20:56 -07:00
|
|
|
stotal = scount = 0;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
psf_list = sdeleted ? &pmc->tomb : &pmc->sources;
|
|
|
|
|
2006-01-18 15:20:56 -07:00
|
|
|
if (!*psf_list)
|
|
|
|
goto empty_source;
|
|
|
|
|
2007-03-13 11:19:23 -06:00
|
|
|
pih = skb ? igmpv3_report_hdr(skb) : NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* EX and TO_EX get a fresh packet, if needed */
|
|
|
|
if (truncate) {
|
|
|
|
if (pih && pih->ngrec &&
|
|
|
|
AVAILABLE(skb) < grec_size(pmc, type, gdeleted, sdeleted)) {
|
|
|
|
if (skb)
|
|
|
|
igmpv3_sendpack(skb);
|
|
|
|
skb = igmpv3_newpack(dev, dev->mtu);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
first = 1;
|
|
|
|
psf_prev = NULL;
|
|
|
|
for (psf=*psf_list; psf; psf=psf_next) {
|
2006-09-27 19:30:52 -06:00
|
|
|
__be32 *psrc;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
psf_next = psf->sf_next;
|
|
|
|
|
|
|
|
if (!is_in(pmc, psf, type, gdeleted, sdeleted)) {
|
|
|
|
psf_prev = psf;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* clear marks on query responses */
|
|
|
|
if (isquery)
|
|
|
|
psf->sf_gsresp = 0;
|
|
|
|
|
2006-09-27 19:31:32 -06:00
|
|
|
if (AVAILABLE(skb) < sizeof(__be32) +
|
2005-04-16 16:20:36 -06:00
|
|
|
first*sizeof(struct igmpv3_grec)) {
|
|
|
|
if (truncate && !first)
|
|
|
|
break; /* truncate these */
|
|
|
|
if (pgr)
|
|
|
|
pgr->grec_nsrcs = htons(scount);
|
|
|
|
if (skb)
|
|
|
|
igmpv3_sendpack(skb);
|
|
|
|
skb = igmpv3_newpack(dev, dev->mtu);
|
|
|
|
first = 1;
|
|
|
|
scount = 0;
|
|
|
|
}
|
|
|
|
if (first) {
|
|
|
|
skb = add_grhead(skb, pmc, type, &pgr);
|
|
|
|
first = 0;
|
|
|
|
}
|
2007-02-06 15:35:25 -07:00
|
|
|
if (!skb)
|
|
|
|
return NULL;
|
2006-09-27 19:31:32 -06:00
|
|
|
psrc = (__be32 *)skb_put(skb, sizeof(__be32));
|
2005-04-16 16:20:36 -06:00
|
|
|
*psrc = psf->sf_inaddr;
|
2006-01-18 15:20:56 -07:00
|
|
|
scount++; stotal++;
|
2005-04-16 16:20:36 -06:00
|
|
|
if ((type == IGMPV3_ALLOW_NEW_SOURCES ||
|
|
|
|
type == IGMPV3_BLOCK_OLD_SOURCES) && psf->sf_crcount) {
|
|
|
|
psf->sf_crcount--;
|
|
|
|
if ((sdeleted || gdeleted) && psf->sf_crcount == 0) {
|
|
|
|
if (psf_prev)
|
|
|
|
psf_prev->sf_next = psf->sf_next;
|
|
|
|
else
|
|
|
|
*psf_list = psf->sf_next;
|
|
|
|
kfree(psf);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
psf_prev = psf;
|
|
|
|
}
|
2006-01-18 15:20:56 -07:00
|
|
|
|
|
|
|
empty_source:
|
|
|
|
if (!stotal) {
|
|
|
|
if (type == IGMPV3_ALLOW_NEW_SOURCES ||
|
|
|
|
type == IGMPV3_BLOCK_OLD_SOURCES)
|
|
|
|
return skb;
|
|
|
|
if (pmc->crcount || isquery) {
|
|
|
|
/* make sure we have room for group header */
|
|
|
|
if (skb && AVAILABLE(skb)<sizeof(struct igmpv3_grec)) {
|
|
|
|
igmpv3_sendpack(skb);
|
|
|
|
skb = NULL; /* add_grhead will get a new one */
|
|
|
|
}
|
|
|
|
skb = add_grhead(skb, pmc, type, &pgr);
|
|
|
|
}
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
if (pgr)
|
|
|
|
pgr->grec_nsrcs = htons(scount);
|
|
|
|
|
|
|
|
if (isquery)
|
|
|
|
pmc->gsquery = 0; /* clear query state on report */
|
|
|
|
return skb;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int igmpv3_send_report(struct in_device *in_dev, struct ip_mc_list *pmc)
|
|
|
|
{
|
|
|
|
struct sk_buff *skb = NULL;
|
|
|
|
int type;
|
|
|
|
|
|
|
|
if (!pmc) {
|
2010-11-11 22:46:50 -07:00
|
|
|
rcu_read_lock();
|
|
|
|
for_each_pmc_rcu(in_dev, pmc) {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (pmc->multiaddr == IGMP_ALL_HOSTS)
|
|
|
|
continue;
|
|
|
|
spin_lock_bh(&pmc->lock);
|
|
|
|
if (pmc->sfcount[MCAST_EXCLUDE])
|
|
|
|
type = IGMPV3_MODE_IS_EXCLUDE;
|
|
|
|
else
|
|
|
|
type = IGMPV3_MODE_IS_INCLUDE;
|
|
|
|
skb = add_grec(skb, pmc, type, 0, 0);
|
|
|
|
spin_unlock_bh(&pmc->lock);
|
|
|
|
}
|
2010-11-11 22:46:50 -07:00
|
|
|
rcu_read_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
spin_lock_bh(&pmc->lock);
|
|
|
|
if (pmc->sfcount[MCAST_EXCLUDE])
|
|
|
|
type = IGMPV3_MODE_IS_EXCLUDE;
|
|
|
|
else
|
|
|
|
type = IGMPV3_MODE_IS_INCLUDE;
|
|
|
|
skb = add_grec(skb, pmc, type, 0, 0);
|
|
|
|
spin_unlock_bh(&pmc->lock);
|
|
|
|
}
|
|
|
|
if (!skb)
|
|
|
|
return 0;
|
|
|
|
return igmpv3_sendpack(skb);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* remove zero-count source records from a source filter list
|
|
|
|
*/
|
|
|
|
static void igmpv3_clear_zeros(struct ip_sf_list **ppsf)
|
|
|
|
{
|
|
|
|
struct ip_sf_list *psf_prev, *psf_next, *psf;
|
|
|
|
|
|
|
|
psf_prev = NULL;
|
|
|
|
for (psf=*ppsf; psf; psf = psf_next) {
|
|
|
|
psf_next = psf->sf_next;
|
|
|
|
if (psf->sf_crcount == 0) {
|
|
|
|
if (psf_prev)
|
|
|
|
psf_prev->sf_next = psf->sf_next;
|
|
|
|
else
|
|
|
|
*ppsf = psf->sf_next;
|
|
|
|
kfree(psf);
|
|
|
|
} else
|
|
|
|
psf_prev = psf;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void igmpv3_send_cr(struct in_device *in_dev)
|
|
|
|
{
|
|
|
|
struct ip_mc_list *pmc, *pmc_prev, *pmc_next;
|
|
|
|
struct sk_buff *skb = NULL;
|
|
|
|
int type, dtype;
|
|
|
|
|
2010-11-11 22:46:50 -07:00
|
|
|
rcu_read_lock();
|
2005-04-16 16:20:36 -06:00
|
|
|
spin_lock_bh(&in_dev->mc_tomb_lock);
|
|
|
|
|
|
|
|
/* deleted MCA's */
|
|
|
|
pmc_prev = NULL;
|
|
|
|
for (pmc=in_dev->mc_tomb; pmc; pmc=pmc_next) {
|
|
|
|
pmc_next = pmc->next;
|
|
|
|
if (pmc->sfmode == MCAST_INCLUDE) {
|
|
|
|
type = IGMPV3_BLOCK_OLD_SOURCES;
|
|
|
|
dtype = IGMPV3_BLOCK_OLD_SOURCES;
|
|
|
|
skb = add_grec(skb, pmc, type, 1, 0);
|
|
|
|
skb = add_grec(skb, pmc, dtype, 1, 1);
|
|
|
|
}
|
|
|
|
if (pmc->crcount) {
|
|
|
|
if (pmc->sfmode == MCAST_EXCLUDE) {
|
|
|
|
type = IGMPV3_CHANGE_TO_INCLUDE;
|
|
|
|
skb = add_grec(skb, pmc, type, 1, 0);
|
|
|
|
}
|
2006-01-18 15:20:56 -07:00
|
|
|
pmc->crcount--;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (pmc->crcount == 0) {
|
|
|
|
igmpv3_clear_zeros(&pmc->tomb);
|
|
|
|
igmpv3_clear_zeros(&pmc->sources);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (pmc->crcount == 0 && !pmc->tomb && !pmc->sources) {
|
|
|
|
if (pmc_prev)
|
|
|
|
pmc_prev->next = pmc_next;
|
|
|
|
else
|
|
|
|
in_dev->mc_tomb = pmc_next;
|
|
|
|
in_dev_put(pmc->interface);
|
|
|
|
kfree(pmc);
|
|
|
|
} else
|
|
|
|
pmc_prev = pmc;
|
|
|
|
}
|
|
|
|
spin_unlock_bh(&in_dev->mc_tomb_lock);
|
|
|
|
|
|
|
|
/* change recs */
|
2010-11-11 22:46:50 -07:00
|
|
|
for_each_pmc_rcu(in_dev, pmc) {
|
2005-04-16 16:20:36 -06:00
|
|
|
spin_lock_bh(&pmc->lock);
|
|
|
|
if (pmc->sfcount[MCAST_EXCLUDE]) {
|
|
|
|
type = IGMPV3_BLOCK_OLD_SOURCES;
|
|
|
|
dtype = IGMPV3_ALLOW_NEW_SOURCES;
|
|
|
|
} else {
|
|
|
|
type = IGMPV3_ALLOW_NEW_SOURCES;
|
|
|
|
dtype = IGMPV3_BLOCK_OLD_SOURCES;
|
|
|
|
}
|
|
|
|
skb = add_grec(skb, pmc, type, 0, 0);
|
|
|
|
skb = add_grec(skb, pmc, dtype, 0, 1); /* deleted sources */
|
|
|
|
|
|
|
|
/* filter mode changes */
|
|
|
|
if (pmc->crcount) {
|
|
|
|
if (pmc->sfmode == MCAST_EXCLUDE)
|
|
|
|
type = IGMPV3_CHANGE_TO_EXCLUDE;
|
|
|
|
else
|
|
|
|
type = IGMPV3_CHANGE_TO_INCLUDE;
|
|
|
|
skb = add_grec(skb, pmc, type, 0, 0);
|
2006-01-18 15:20:56 -07:00
|
|
|
pmc->crcount--;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
spin_unlock_bh(&pmc->lock);
|
|
|
|
}
|
2010-11-11 22:46:50 -07:00
|
|
|
rcu_read_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!skb)
|
|
|
|
return;
|
|
|
|
(void) igmpv3_sendpack(skb);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int igmp_send_report(struct in_device *in_dev, struct ip_mc_list *pmc,
|
|
|
|
int type)
|
|
|
|
{
|
|
|
|
struct sk_buff *skb;
|
|
|
|
struct iphdr *iph;
|
|
|
|
struct igmphdr *ih;
|
|
|
|
struct rtable *rt;
|
|
|
|
struct net_device *dev = in_dev->dev;
|
2008-08-13 17:15:57 -06:00
|
|
|
struct net *net = dev_net(dev);
|
2006-09-27 19:31:32 -06:00
|
|
|
__be32 group = pmc ? pmc->multiaddr : 0;
|
2011-05-03 21:25:42 -06:00
|
|
|
struct flowi4 fl4;
|
2006-09-27 19:31:32 -06:00
|
|
|
__be32 dst;
|
2011-11-17 19:20:04 -07:00
|
|
|
int hlen, tlen;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (type == IGMPV3_HOST_MEMBERSHIP_REPORT)
|
|
|
|
return igmpv3_send_report(in_dev, pmc);
|
|
|
|
else if (type == IGMP_HOST_LEAVE_MESSAGE)
|
|
|
|
dst = IGMP_ALL_ROUTER;
|
|
|
|
else
|
|
|
|
dst = group;
|
|
|
|
|
2011-05-03 21:25:42 -06:00
|
|
|
rt = ip_route_output_ports(net, &fl4, NULL, dst, 0,
|
2011-03-11 22:00:52 -07:00
|
|
|
0, 0,
|
|
|
|
IPPROTO_IGMP, 0, dev->ifindex);
|
|
|
|
if (IS_ERR(rt))
|
|
|
|
return -1;
|
|
|
|
|
2011-11-17 19:20:04 -07:00
|
|
|
hlen = LL_RESERVED_SPACE(dev);
|
|
|
|
tlen = dev->needed_tailroom;
|
|
|
|
skb = alloc_skb(IGMP_SIZE + hlen + tlen, GFP_ATOMIC);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (skb == NULL) {
|
|
|
|
ip_rt_put(rt);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2010-06-11 00:31:35 -06:00
|
|
|
skb_dst_set(skb, &rt->dst);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-11-17 19:20:04 -07:00
|
|
|
skb_reserve(skb, hlen);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-03-10 14:40:59 -07:00
|
|
|
skb_reset_network_header(skb);
|
2007-04-20 23:47:35 -06:00
|
|
|
iph = ip_hdr(skb);
|
2007-03-10 14:40:59 -07:00
|
|
|
skb_put(skb, sizeof(struct iphdr) + 4);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
iph->version = 4;
|
|
|
|
iph->ihl = (sizeof(struct iphdr)+4)>>2;
|
|
|
|
iph->tos = 0xc0;
|
|
|
|
iph->frag_off = htons(IP_DF);
|
|
|
|
iph->ttl = 1;
|
|
|
|
iph->daddr = dst;
|
2011-05-03 21:53:12 -06:00
|
|
|
iph->saddr = fl4.saddr;
|
2005-04-16 16:20:36 -06:00
|
|
|
iph->protocol = IPPROTO_IGMP;
|
2010-06-11 00:31:35 -06:00
|
|
|
ip_select_ident(iph, &rt->dst, NULL);
|
2012-04-14 19:34:41 -06:00
|
|
|
((u8 *)&iph[1])[0] = IPOPT_RA;
|
|
|
|
((u8 *)&iph[1])[1] = 4;
|
|
|
|
((u8 *)&iph[1])[2] = 0;
|
|
|
|
((u8 *)&iph[1])[3] = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
ih = (struct igmphdr *)skb_put(skb, sizeof(struct igmphdr));
|
2008-11-03 01:26:09 -07:00
|
|
|
ih->type = type;
|
|
|
|
ih->code = 0;
|
|
|
|
ih->csum = 0;
|
|
|
|
ih->group = group;
|
|
|
|
ih->csum = ip_compute_csum((void *)ih, sizeof(struct igmphdr));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-01-11 20:14:00 -07:00
|
|
|
return ip_local_out(skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void igmp_gq_timer_expire(unsigned long data)
|
|
|
|
{
|
|
|
|
struct in_device *in_dev = (struct in_device *)data;
|
|
|
|
|
|
|
|
in_dev->mr_gq_running = 0;
|
|
|
|
igmpv3_send_report(in_dev, NULL);
|
|
|
|
__in_dev_put(in_dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void igmp_ifc_timer_expire(unsigned long data)
|
|
|
|
{
|
|
|
|
struct in_device *in_dev = (struct in_device *)data;
|
|
|
|
|
|
|
|
igmpv3_send_cr(in_dev);
|
|
|
|
if (in_dev->mr_ifc_count) {
|
|
|
|
in_dev->mr_ifc_count--;
|
|
|
|
igmp_ifc_start_timer(in_dev, IGMP_Unsolicited_Report_Interval);
|
|
|
|
}
|
|
|
|
__in_dev_put(in_dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void igmp_ifc_event(struct in_device *in_dev)
|
|
|
|
{
|
|
|
|
if (IGMP_V1_SEEN(in_dev) || IGMP_V2_SEEN(in_dev))
|
|
|
|
return;
|
2007-02-09 07:24:47 -07:00
|
|
|
in_dev->mr_ifc_count = in_dev->mr_qrv ? in_dev->mr_qrv :
|
2005-04-16 16:20:36 -06:00
|
|
|
IGMP_Unsolicited_Report_Count;
|
|
|
|
igmp_ifc_start_timer(in_dev, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void igmp_timer_expire(unsigned long data)
|
|
|
|
{
|
|
|
|
struct ip_mc_list *im=(struct ip_mc_list *)data;
|
|
|
|
struct in_device *in_dev = im->interface;
|
|
|
|
|
|
|
|
spin_lock(&im->lock);
|
2008-11-03 01:26:09 -07:00
|
|
|
im->tm_running = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (im->unsolicit_count) {
|
|
|
|
im->unsolicit_count--;
|
|
|
|
igmp_start_timer(im, IGMP_Unsolicited_Report_Interval);
|
|
|
|
}
|
|
|
|
im->reporter = 1;
|
|
|
|
spin_unlock(&im->lock);
|
|
|
|
|
|
|
|
if (IGMP_V1_SEEN(in_dev))
|
|
|
|
igmp_send_report(in_dev, im, IGMP_HOST_MEMBERSHIP_REPORT);
|
|
|
|
else if (IGMP_V2_SEEN(in_dev))
|
|
|
|
igmp_send_report(in_dev, im, IGMPV2_HOST_MEMBERSHIP_REPORT);
|
|
|
|
else
|
|
|
|
igmp_send_report(in_dev, im, IGMPV3_HOST_MEMBERSHIP_REPORT);
|
|
|
|
|
|
|
|
ip_ma_put(im);
|
|
|
|
}
|
|
|
|
|
2006-01-18 15:20:56 -07:00
|
|
|
/* mark EXCLUDE-mode sources */
|
2006-09-27 19:30:52 -06:00
|
|
|
static int igmp_xmarksources(struct ip_mc_list *pmc, int nsrcs, __be32 *srcs)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct ip_sf_list *psf;
|
|
|
|
int i, scount;
|
|
|
|
|
2006-01-18 15:20:56 -07:00
|
|
|
scount = 0;
|
|
|
|
for (psf=pmc->sources; psf; psf=psf->sf_next) {
|
|
|
|
if (scount == nsrcs)
|
|
|
|
break;
|
|
|
|
for (i=0; i<nsrcs; i++) {
|
|
|
|
/* skip inactive filters */
|
2011-08-23 16:54:37 -06:00
|
|
|
if (psf->sf_count[MCAST_INCLUDE] ||
|
2006-01-18 15:20:56 -07:00
|
|
|
pmc->sfcount[MCAST_EXCLUDE] !=
|
|
|
|
psf->sf_count[MCAST_EXCLUDE])
|
2012-04-05 03:36:29 -06:00
|
|
|
break;
|
2006-01-18 15:20:56 -07:00
|
|
|
if (srcs[i] == psf->sf_inaddr) {
|
|
|
|
scount++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pmc->gsquery = 0;
|
|
|
|
if (scount == nsrcs) /* all sources excluded */
|
|
|
|
return 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2006-09-27 19:30:52 -06:00
|
|
|
static int igmp_marksources(struct ip_mc_list *pmc, int nsrcs, __be32 *srcs)
|
2006-01-18 15:20:56 -07:00
|
|
|
{
|
|
|
|
struct ip_sf_list *psf;
|
|
|
|
int i, scount;
|
|
|
|
|
|
|
|
if (pmc->sfmode == MCAST_EXCLUDE)
|
|
|
|
return igmp_xmarksources(pmc, nsrcs, srcs);
|
|
|
|
|
|
|
|
/* mark INCLUDE-mode sources */
|
2005-04-16 16:20:36 -06:00
|
|
|
scount = 0;
|
|
|
|
for (psf=pmc->sources; psf; psf=psf->sf_next) {
|
|
|
|
if (scount == nsrcs)
|
|
|
|
break;
|
|
|
|
for (i=0; i<nsrcs; i++)
|
|
|
|
if (srcs[i] == psf->sf_inaddr) {
|
|
|
|
psf->sf_gsresp = 1;
|
|
|
|
scount++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2006-01-18 15:20:56 -07:00
|
|
|
if (!scount) {
|
|
|
|
pmc->gsquery = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
pmc->gsquery = 1;
|
|
|
|
return 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-09-27 19:31:32 -06:00
|
|
|
static void igmp_heard_report(struct in_device *in_dev, __be32 group)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct ip_mc_list *im;
|
|
|
|
|
|
|
|
/* Timers are only set for non-local groups */
|
|
|
|
|
|
|
|
if (group == IGMP_ALL_HOSTS)
|
|
|
|
return;
|
|
|
|
|
2010-11-11 22:46:50 -07:00
|
|
|
rcu_read_lock();
|
|
|
|
for_each_pmc_rcu(in_dev, im) {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (im->multiaddr == group) {
|
|
|
|
igmp_stop_timer(im);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2010-11-11 22:46:50 -07:00
|
|
|
rcu_read_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void igmp_heard_query(struct in_device *in_dev, struct sk_buff *skb,
|
|
|
|
int len)
|
|
|
|
{
|
2007-03-13 11:19:23 -06:00
|
|
|
struct igmphdr *ih = igmp_hdr(skb);
|
|
|
|
struct igmpv3_query *ih3 = igmpv3_query_hdr(skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
struct ip_mc_list *im;
|
2006-09-27 19:31:32 -06:00
|
|
|
__be32 group = ih->group;
|
2005-04-16 16:20:36 -06:00
|
|
|
int max_delay;
|
|
|
|
int mark = 0;
|
|
|
|
|
|
|
|
|
2010-09-30 08:29:40 -06:00
|
|
|
if (len == 8) {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (ih->code == 0) {
|
|
|
|
/* Alas, old v1 router presents here. */
|
2007-02-09 07:24:47 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
max_delay = IGMP_Query_Response_Interval;
|
|
|
|
in_dev->mr_v1_seen = jiffies +
|
|
|
|
IGMP_V1_Router_Present_Timeout;
|
|
|
|
group = 0;
|
|
|
|
} else {
|
|
|
|
/* v2 router present */
|
|
|
|
max_delay = ih->code*(HZ/IGMP_TIMER_SCALE);
|
|
|
|
in_dev->mr_v2_seen = jiffies +
|
|
|
|
IGMP_V2_Router_Present_Timeout;
|
|
|
|
}
|
|
|
|
/* cancel the interface change timer */
|
|
|
|
in_dev->mr_ifc_count = 0;
|
|
|
|
if (del_timer(&in_dev->mr_ifc_timer))
|
|
|
|
__in_dev_put(in_dev);
|
|
|
|
/* clear deleted report items */
|
|
|
|
igmpv3_clear_delrec(in_dev);
|
|
|
|
} else if (len < 12) {
|
|
|
|
return; /* ignore bogus packet; freed by caller */
|
2010-09-30 08:29:40 -06:00
|
|
|
} else if (IGMP_V1_SEEN(in_dev)) {
|
|
|
|
/* This is a v3 query with v1 queriers present */
|
|
|
|
max_delay = IGMP_Query_Response_Interval;
|
|
|
|
group = 0;
|
|
|
|
} else if (IGMP_V2_SEEN(in_dev)) {
|
|
|
|
/* this is a v3 query with v2 queriers present;
|
|
|
|
* Interpretation of the max_delay code is problematic here.
|
|
|
|
* A real v2 host would use ih_code directly, while v3 has a
|
|
|
|
* different encoding. We use the v3 encoding as more likely
|
|
|
|
* to be intended in a v3 query.
|
|
|
|
*/
|
|
|
|
max_delay = IGMPV3_MRC(ih3->code)*(HZ/IGMP_TIMER_SCALE);
|
2012-01-09 15:06:46 -07:00
|
|
|
if (!max_delay)
|
|
|
|
max_delay = 1; /* can't mod w/ 0 */
|
2005-04-16 16:20:36 -06:00
|
|
|
} else { /* v3 */
|
|
|
|
if (!pskb_may_pull(skb, sizeof(struct igmpv3_query)))
|
|
|
|
return;
|
2007-02-09 07:24:47 -07:00
|
|
|
|
2007-03-13 11:19:23 -06:00
|
|
|
ih3 = igmpv3_query_hdr(skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (ih3->nsrcs) {
|
2007-02-09 07:24:47 -07:00
|
|
|
if (!pskb_may_pull(skb, sizeof(struct igmpv3_query)
|
2006-09-27 19:31:32 -06:00
|
|
|
+ ntohs(ih3->nsrcs)*sizeof(__be32)))
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
2007-03-13 11:19:23 -06:00
|
|
|
ih3 = igmpv3_query_hdr(skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
max_delay = IGMPV3_MRC(ih3->code)*(HZ/IGMP_TIMER_SCALE);
|
|
|
|
if (!max_delay)
|
|
|
|
max_delay = 1; /* can't mod w/ 0 */
|
|
|
|
in_dev->mr_maxdelay = max_delay;
|
|
|
|
if (ih3->qrv)
|
|
|
|
in_dev->mr_qrv = ih3->qrv;
|
|
|
|
if (!group) { /* general query */
|
|
|
|
if (ih3->nsrcs)
|
|
|
|
return; /* no sources allowed */
|
|
|
|
igmp_gq_start_timer(in_dev);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* mark sources to include, if group & source-specific */
|
|
|
|
mark = ih3->nsrcs != 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* - Start the timers in all of our membership records
|
|
|
|
* that the query applies to for the interface on
|
|
|
|
* which the query arrived excl. those that belong
|
|
|
|
* to a "local" group (224.0.0.X)
|
|
|
|
* - For timers already running check if they need to
|
|
|
|
* be reset.
|
|
|
|
* - Use the igmp->igmp_code field as the maximum
|
|
|
|
* delay possible
|
|
|
|
*/
|
2010-11-11 22:46:50 -07:00
|
|
|
rcu_read_lock();
|
|
|
|
for_each_pmc_rcu(in_dev, im) {
|
2006-01-18 15:20:56 -07:00
|
|
|
int changed;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (group && group != im->multiaddr)
|
|
|
|
continue;
|
|
|
|
if (im->multiaddr == IGMP_ALL_HOSTS)
|
|
|
|
continue;
|
|
|
|
spin_lock_bh(&im->lock);
|
|
|
|
if (im->tm_running)
|
|
|
|
im->gsquery = im->gsquery && mark;
|
|
|
|
else
|
|
|
|
im->gsquery = mark;
|
2006-01-18 15:20:56 -07:00
|
|
|
changed = !im->gsquery ||
|
2007-02-09 07:24:47 -07:00
|
|
|
igmp_marksources(im, ntohs(ih3->nsrcs), ih3->srcs);
|
2005-04-16 16:20:36 -06:00
|
|
|
spin_unlock_bh(&im->lock);
|
2006-01-18 15:20:56 -07:00
|
|
|
if (changed)
|
|
|
|
igmp_mod_timer(im, max_delay);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2010-11-11 22:46:50 -07:00
|
|
|
rcu_read_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2010-06-06 21:17:10 -06:00
|
|
|
/* called in rcu_read_lock() section */
|
2005-04-16 16:20:36 -06:00
|
|
|
int igmp_rcv(struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
/* This basically follows the spec line by line -- see RFC1112 */
|
|
|
|
struct igmphdr *ih;
|
2010-06-06 21:17:10 -06:00
|
|
|
struct in_device *in_dev = __in_dev_get_rcu(skb->dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
int len = skb->len;
|
|
|
|
|
2008-02-10 00:22:26 -07:00
|
|
|
if (in_dev == NULL)
|
|
|
|
goto drop;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-11-10 14:01:24 -07:00
|
|
|
if (!pskb_may_pull(skb, sizeof(struct igmphdr)))
|
2010-06-06 21:17:10 -06:00
|
|
|
goto drop;
|
2005-11-10 14:01:24 -07:00
|
|
|
|
|
|
|
switch (skb->ip_summed) {
|
2006-08-29 17:44:56 -06:00
|
|
|
case CHECKSUM_COMPLETE:
|
2006-11-14 22:24:49 -07:00
|
|
|
if (!csum_fold(skb->csum))
|
2005-11-10 14:01:24 -07:00
|
|
|
break;
|
|
|
|
/* fall through */
|
|
|
|
case CHECKSUM_NONE:
|
|
|
|
skb->csum = 0;
|
|
|
|
if (__skb_checksum_complete(skb))
|
2010-06-06 21:17:10 -06:00
|
|
|
goto drop;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-03-13 11:19:23 -06:00
|
|
|
ih = igmp_hdr(skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
switch (ih->type) {
|
|
|
|
case IGMP_HOST_MEMBERSHIP_QUERY:
|
|
|
|
igmp_heard_query(in_dev, skb, len);
|
|
|
|
break;
|
|
|
|
case IGMP_HOST_MEMBERSHIP_REPORT:
|
|
|
|
case IGMPV2_HOST_MEMBERSHIP_REPORT:
|
|
|
|
/* Is it our report looped back? */
|
2010-11-11 18:07:48 -07:00
|
|
|
if (rt_is_output_route(skb_rtable(skb)))
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
2005-12-02 21:32:59 -07:00
|
|
|
/* don't rely on MC router hearing unicast reports */
|
|
|
|
if (skb->pkt_type == PACKET_MULTICAST ||
|
|
|
|
skb->pkt_type == PACKET_BROADCAST)
|
|
|
|
igmp_heard_report(in_dev, ih->group);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case IGMP_PIM:
|
|
|
|
#ifdef CONFIG_IP_PIMSM_V1
|
|
|
|
return pim_rcv_v1(skb);
|
|
|
|
#endif
|
2010-02-07 10:26:30 -07:00
|
|
|
case IGMPV3_HOST_MEMBERSHIP_REPORT:
|
2005-04-16 16:20:36 -06:00
|
|
|
case IGMP_DVMRP:
|
|
|
|
case IGMP_TRACE:
|
|
|
|
case IGMP_HOST_LEAVE_MESSAGE:
|
|
|
|
case IGMP_MTRACE:
|
|
|
|
case IGMP_MTRACE_RESP:
|
|
|
|
break;
|
|
|
|
default:
|
2006-01-31 14:11:41 -07:00
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2005-11-10 14:01:24 -07:00
|
|
|
|
2008-02-10 00:22:26 -07:00
|
|
|
drop:
|
2005-04-16 16:20:36 -06:00
|
|
|
kfree_skb(skb);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add a filter to a device
|
|
|
|
*/
|
|
|
|
|
2006-09-27 19:31:32 -06:00
|
|
|
static void ip_mc_filter_add(struct in_device *in_dev, __be32 addr)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
char buf[MAX_ADDR_LEN];
|
|
|
|
struct net_device *dev = in_dev->dev;
|
|
|
|
|
|
|
|
/* Checking for IFF_MULTICAST here is WRONG-WRONG-WRONG.
|
|
|
|
We will get multicast token leakage, when IFF_MULTICAST
|
2011-08-16 00:29:02 -06:00
|
|
|
is changed. This check should be done in ndo_set_rx_mode
|
2005-04-16 16:20:36 -06:00
|
|
|
routine. Something sort of:
|
|
|
|
if (dev->mc_list && dev->flags&IFF_MULTICAST) { do it; }
|
|
|
|
--ANK
|
|
|
|
*/
|
|
|
|
if (arp_mc_map(addr, buf, dev, 0) == 0)
|
2010-04-01 15:22:57 -06:00
|
|
|
dev_mc_add(dev, buf);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Remove a filter from a device
|
|
|
|
*/
|
|
|
|
|
2006-09-27 19:31:32 -06:00
|
|
|
static void ip_mc_filter_del(struct in_device *in_dev, __be32 addr)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
char buf[MAX_ADDR_LEN];
|
|
|
|
struct net_device *dev = in_dev->dev;
|
|
|
|
|
|
|
|
if (arp_mc_map(addr, buf, dev, 0) == 0)
|
2010-04-01 15:22:57 -06:00
|
|
|
dev_mc_del(dev, buf);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_IP_MULTICAST
|
|
|
|
/*
|
|
|
|
* deleted ip_mc_list manipulation
|
|
|
|
*/
|
|
|
|
static void igmpv3_add_delrec(struct in_device *in_dev, struct ip_mc_list *im)
|
|
|
|
{
|
|
|
|
struct ip_mc_list *pmc;
|
|
|
|
|
|
|
|
/* this is an "ip_mc_list" for convenience; only the fields below
|
|
|
|
* are actually used. In particular, the refcnt and users are not
|
|
|
|
* used for management of the delete list. Using the same structure
|
|
|
|
* for deleted items allows change reports to use common code with
|
|
|
|
* non-deleted or query-response MCA's.
|
|
|
|
*/
|
2006-07-21 15:51:30 -06:00
|
|
|
pmc = kzalloc(sizeof(*pmc), GFP_KERNEL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!pmc)
|
|
|
|
return;
|
|
|
|
spin_lock_bh(&im->lock);
|
|
|
|
pmc->interface = im->interface;
|
|
|
|
in_dev_hold(in_dev);
|
|
|
|
pmc->multiaddr = im->multiaddr;
|
|
|
|
pmc->crcount = in_dev->mr_qrv ? in_dev->mr_qrv :
|
|
|
|
IGMP_Unsolicited_Report_Count;
|
|
|
|
pmc->sfmode = im->sfmode;
|
|
|
|
if (pmc->sfmode == MCAST_INCLUDE) {
|
|
|
|
struct ip_sf_list *psf;
|
|
|
|
|
|
|
|
pmc->tomb = im->tomb;
|
|
|
|
pmc->sources = im->sources;
|
|
|
|
im->tomb = im->sources = NULL;
|
|
|
|
for (psf=pmc->sources; psf; psf=psf->sf_next)
|
|
|
|
psf->sf_crcount = pmc->crcount;
|
|
|
|
}
|
|
|
|
spin_unlock_bh(&im->lock);
|
|
|
|
|
|
|
|
spin_lock_bh(&in_dev->mc_tomb_lock);
|
|
|
|
pmc->next = in_dev->mc_tomb;
|
|
|
|
in_dev->mc_tomb = pmc;
|
|
|
|
spin_unlock_bh(&in_dev->mc_tomb_lock);
|
|
|
|
}
|
|
|
|
|
2006-09-27 19:31:32 -06:00
|
|
|
static void igmpv3_del_delrec(struct in_device *in_dev, __be32 multiaddr)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct ip_mc_list *pmc, *pmc_prev;
|
|
|
|
struct ip_sf_list *psf, *psf_next;
|
|
|
|
|
|
|
|
spin_lock_bh(&in_dev->mc_tomb_lock);
|
|
|
|
pmc_prev = NULL;
|
|
|
|
for (pmc=in_dev->mc_tomb; pmc; pmc=pmc->next) {
|
|
|
|
if (pmc->multiaddr == multiaddr)
|
|
|
|
break;
|
|
|
|
pmc_prev = pmc;
|
|
|
|
}
|
|
|
|
if (pmc) {
|
|
|
|
if (pmc_prev)
|
|
|
|
pmc_prev->next = pmc->next;
|
|
|
|
else
|
|
|
|
in_dev->mc_tomb = pmc->next;
|
|
|
|
}
|
|
|
|
spin_unlock_bh(&in_dev->mc_tomb_lock);
|
|
|
|
if (pmc) {
|
|
|
|
for (psf=pmc->tomb; psf; psf=psf_next) {
|
|
|
|
psf_next = psf->sf_next;
|
|
|
|
kfree(psf);
|
|
|
|
}
|
|
|
|
in_dev_put(pmc->interface);
|
|
|
|
kfree(pmc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void igmpv3_clear_delrec(struct in_device *in_dev)
|
|
|
|
{
|
|
|
|
struct ip_mc_list *pmc, *nextpmc;
|
|
|
|
|
|
|
|
spin_lock_bh(&in_dev->mc_tomb_lock);
|
|
|
|
pmc = in_dev->mc_tomb;
|
|
|
|
in_dev->mc_tomb = NULL;
|
|
|
|
spin_unlock_bh(&in_dev->mc_tomb_lock);
|
|
|
|
|
|
|
|
for (; pmc; pmc = nextpmc) {
|
|
|
|
nextpmc = pmc->next;
|
|
|
|
ip_mc_clear_src(pmc);
|
|
|
|
in_dev_put(pmc->interface);
|
|
|
|
kfree(pmc);
|
|
|
|
}
|
|
|
|
/* clear dead sources, too */
|
2010-11-11 22:46:50 -07:00
|
|
|
rcu_read_lock();
|
|
|
|
for_each_pmc_rcu(in_dev, pmc) {
|
2005-04-16 16:20:36 -06:00
|
|
|
struct ip_sf_list *psf, *psf_next;
|
|
|
|
|
|
|
|
spin_lock_bh(&pmc->lock);
|
|
|
|
psf = pmc->tomb;
|
|
|
|
pmc->tomb = NULL;
|
|
|
|
spin_unlock_bh(&pmc->lock);
|
|
|
|
for (; psf; psf=psf_next) {
|
|
|
|
psf_next = psf->sf_next;
|
|
|
|
kfree(psf);
|
|
|
|
}
|
|
|
|
}
|
2010-11-11 22:46:50 -07:00
|
|
|
rcu_read_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static void igmp_group_dropped(struct ip_mc_list *im)
|
|
|
|
{
|
|
|
|
struct in_device *in_dev = im->interface;
|
|
|
|
#ifdef CONFIG_IP_MULTICAST
|
|
|
|
int reporter;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (im->loaded) {
|
|
|
|
im->loaded = 0;
|
|
|
|
ip_mc_filter_del(in_dev, im->multiaddr);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_IP_MULTICAST
|
|
|
|
if (im->multiaddr == IGMP_ALL_HOSTS)
|
|
|
|
return;
|
|
|
|
|
|
|
|
reporter = im->reporter;
|
|
|
|
igmp_stop_timer(im);
|
|
|
|
|
|
|
|
if (!in_dev->dead) {
|
|
|
|
if (IGMP_V1_SEEN(in_dev))
|
2011-05-23 17:15:05 -06:00
|
|
|
return;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (IGMP_V2_SEEN(in_dev)) {
|
|
|
|
if (reporter)
|
|
|
|
igmp_send_report(in_dev, im, IGMP_HOST_LEAVE_MESSAGE);
|
2011-05-23 17:15:05 -06:00
|
|
|
return;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
/* IGMPv3 */
|
|
|
|
igmpv3_add_delrec(in_dev, im);
|
|
|
|
|
|
|
|
igmp_ifc_event(in_dev);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
static void igmp_group_added(struct ip_mc_list *im)
|
|
|
|
{
|
|
|
|
struct in_device *in_dev = im->interface;
|
|
|
|
|
|
|
|
if (im->loaded == 0) {
|
|
|
|
im->loaded = 1;
|
|
|
|
ip_mc_filter_add(in_dev, im->multiaddr);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_IP_MULTICAST
|
|
|
|
if (im->multiaddr == IGMP_ALL_HOSTS)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (in_dev->dead)
|
|
|
|
return;
|
|
|
|
if (IGMP_V1_SEEN(in_dev) || IGMP_V2_SEEN(in_dev)) {
|
|
|
|
spin_lock_bh(&im->lock);
|
|
|
|
igmp_start_timer(im, IGMP_Initial_Report_Delay);
|
|
|
|
spin_unlock_bh(&im->lock);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* else, v3 */
|
|
|
|
|
|
|
|
im->crcount = in_dev->mr_qrv ? in_dev->mr_qrv :
|
|
|
|
IGMP_Unsolicited_Report_Count;
|
|
|
|
igmp_ifc_event(in_dev);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Multicast list managers
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* A socket has joined a multicast group on device dev.
|
|
|
|
*/
|
|
|
|
|
2006-09-27 19:30:07 -06:00
|
|
|
void ip_mc_inc_group(struct in_device *in_dev, __be32 addr)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct ip_mc_list *im;
|
|
|
|
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
2010-11-11 22:46:50 -07:00
|
|
|
for_each_pmc_rtnl(in_dev, im) {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (im->multiaddr == addr) {
|
|
|
|
im->users++;
|
|
|
|
ip_mc_add_src(in_dev, &addr, MCAST_EXCLUDE, 0, NULL, 0);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-11-11 22:46:50 -07:00
|
|
|
im = kzalloc(sizeof(*im), GFP_KERNEL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!im)
|
|
|
|
goto out;
|
|
|
|
|
2008-11-03 01:26:09 -07:00
|
|
|
im->users = 1;
|
|
|
|
im->interface = in_dev;
|
2005-04-16 16:20:36 -06:00
|
|
|
in_dev_hold(in_dev);
|
2008-11-03 01:26:09 -07:00
|
|
|
im->multiaddr = addr;
|
2005-04-16 16:20:36 -06:00
|
|
|
/* initial mode is (EX, empty) */
|
|
|
|
im->sfmode = MCAST_EXCLUDE;
|
|
|
|
im->sfcount[MCAST_EXCLUDE] = 1;
|
|
|
|
atomic_set(&im->refcnt, 1);
|
|
|
|
spin_lock_init(&im->lock);
|
|
|
|
#ifdef CONFIG_IP_MULTICAST
|
2008-01-23 22:20:07 -07:00
|
|
|
setup_timer(&im->timer, &igmp_timer_expire, (unsigned long)im);
|
2005-04-16 16:20:36 -06:00
|
|
|
im->unsolicit_count = IGMP_Unsolicited_Report_Count;
|
|
|
|
#endif
|
2010-11-11 22:46:50 -07:00
|
|
|
|
|
|
|
im->next_rcu = in_dev->mc_list;
|
2008-10-07 16:34:37 -06:00
|
|
|
in_dev->mc_count++;
|
2012-01-11 21:41:32 -07:00
|
|
|
rcu_assign_pointer(in_dev->mc_list, im);
|
2010-11-11 22:46:50 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef CONFIG_IP_MULTICAST
|
|
|
|
igmpv3_del_delrec(in_dev, im->multiaddr);
|
|
|
|
#endif
|
|
|
|
igmp_group_added(im);
|
|
|
|
if (!in_dev->dead)
|
|
|
|
ip_rt_multicast_event(in_dev);
|
|
|
|
out:
|
|
|
|
return;
|
|
|
|
}
|
2010-07-09 15:22:10 -06:00
|
|
|
EXPORT_SYMBOL(ip_mc_inc_group);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
bonding: Improve IGMP join processing
In active-backup mode, the current bonding code duplicates IGMP
traffic to all slaves, so that switches are up to date in case of a
failover from an active to a backup interface. If bonding then fails
back to the original active interface, it is likely that the "active
slave" switch's IGMP forwarding for the port will be out of date until
some event occurs to refresh the switch (e.g., a membership query).
This patch alters the behavior of bonding to no longer flood
IGMP to all ports, and to issue IGMP JOINs to the newly active port at
the time of a failover. This insures that switches are kept up to date
for all cases.
"GOELLESCH Niels" <niels.goellesch@eurocontrol.int> originally
reported this problem, and included a patch. His original patch was
modified by Jay Vosburgh to additionally remove the existing IGMP flood
behavior, use RCU, streamline code paths, fix trailing white space, and
adjust for style.
Signed-off-by: Jay Vosburgh <fubar@us.ibm.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-02-28 18:03:37 -07:00
|
|
|
/*
|
|
|
|
* Resend IGMP JOIN report; used for bonding.
|
2010-11-18 10:33:19 -07:00
|
|
|
* Called with rcu_read_lock()
|
bonding: Improve IGMP join processing
In active-backup mode, the current bonding code duplicates IGMP
traffic to all slaves, so that switches are up to date in case of a
failover from an active to a backup interface. If bonding then fails
back to the original active interface, it is likely that the "active
slave" switch's IGMP forwarding for the port will be out of date until
some event occurs to refresh the switch (e.g., a membership query).
This patch alters the behavior of bonding to no longer flood
IGMP to all ports, and to issue IGMP JOINs to the newly active port at
the time of a failover. This insures that switches are kept up to date
for all cases.
"GOELLESCH Niels" <niels.goellesch@eurocontrol.int> originally
reported this problem, and included a patch. His original patch was
modified by Jay Vosburgh to additionally remove the existing IGMP flood
behavior, use RCU, streamline code paths, fix trailing white space, and
adjust for style.
Signed-off-by: Jay Vosburgh <fubar@us.ibm.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-02-28 18:03:37 -07:00
|
|
|
*/
|
2010-11-18 10:33:19 -07:00
|
|
|
void ip_mc_rejoin_groups(struct in_device *in_dev)
|
bonding: Improve IGMP join processing
In active-backup mode, the current bonding code duplicates IGMP
traffic to all slaves, so that switches are up to date in case of a
failover from an active to a backup interface. If bonding then fails
back to the original active interface, it is likely that the "active
slave" switch's IGMP forwarding for the port will be out of date until
some event occurs to refresh the switch (e.g., a membership query).
This patch alters the behavior of bonding to no longer flood
IGMP to all ports, and to issue IGMP JOINs to the newly active port at
the time of a failover. This insures that switches are kept up to date
for all cases.
"GOELLESCH Niels" <niels.goellesch@eurocontrol.int> originally
reported this problem, and included a patch. His original patch was
modified by Jay Vosburgh to additionally remove the existing IGMP flood
behavior, use RCU, streamline code paths, fix trailing white space, and
adjust for style.
Signed-off-by: Jay Vosburgh <fubar@us.ibm.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-02-28 18:03:37 -07:00
|
|
|
{
|
2007-03-12 18:02:37 -06:00
|
|
|
#ifdef CONFIG_IP_MULTICAST
|
2010-11-18 10:33:19 -07:00
|
|
|
struct ip_mc_list *im;
|
|
|
|
int type;
|
bonding: Improve IGMP join processing
In active-backup mode, the current bonding code duplicates IGMP
traffic to all slaves, so that switches are up to date in case of a
failover from an active to a backup interface. If bonding then fails
back to the original active interface, it is likely that the "active
slave" switch's IGMP forwarding for the port will be out of date until
some event occurs to refresh the switch (e.g., a membership query).
This patch alters the behavior of bonding to no longer flood
IGMP to all ports, and to issue IGMP JOINs to the newly active port at
the time of a failover. This insures that switches are kept up to date
for all cases.
"GOELLESCH Niels" <niels.goellesch@eurocontrol.int> originally
reported this problem, and included a patch. His original patch was
modified by Jay Vosburgh to additionally remove the existing IGMP flood
behavior, use RCU, streamline code paths, fix trailing white space, and
adjust for style.
Signed-off-by: Jay Vosburgh <fubar@us.ibm.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-02-28 18:03:37 -07:00
|
|
|
|
2010-11-18 10:33:19 -07:00
|
|
|
for_each_pmc_rcu(in_dev, im) {
|
|
|
|
if (im->multiaddr == IGMP_ALL_HOSTS)
|
|
|
|
continue;
|
bonding: Improve IGMP join processing
In active-backup mode, the current bonding code duplicates IGMP
traffic to all slaves, so that switches are up to date in case of a
failover from an active to a backup interface. If bonding then fails
back to the original active interface, it is likely that the "active
slave" switch's IGMP forwarding for the port will be out of date until
some event occurs to refresh the switch (e.g., a membership query).
This patch alters the behavior of bonding to no longer flood
IGMP to all ports, and to issue IGMP JOINs to the newly active port at
the time of a failover. This insures that switches are kept up to date
for all cases.
"GOELLESCH Niels" <niels.goellesch@eurocontrol.int> originally
reported this problem, and included a patch. His original patch was
modified by Jay Vosburgh to additionally remove the existing IGMP flood
behavior, use RCU, streamline code paths, fix trailing white space, and
adjust for style.
Signed-off-by: Jay Vosburgh <fubar@us.ibm.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-02-28 18:03:37 -07:00
|
|
|
|
2010-11-18 10:33:19 -07:00
|
|
|
/* a failover is happening and switches
|
|
|
|
* must be notified immediately
|
|
|
|
*/
|
|
|
|
if (IGMP_V1_SEEN(in_dev))
|
|
|
|
type = IGMP_HOST_MEMBERSHIP_REPORT;
|
|
|
|
else if (IGMP_V2_SEEN(in_dev))
|
|
|
|
type = IGMPV2_HOST_MEMBERSHIP_REPORT;
|
|
|
|
else
|
|
|
|
type = IGMPV3_HOST_MEMBERSHIP_REPORT;
|
|
|
|
igmp_send_report(in_dev, im, type);
|
|
|
|
}
|
bonding: Improve IGMP join processing
In active-backup mode, the current bonding code duplicates IGMP
traffic to all slaves, so that switches are up to date in case of a
failover from an active to a backup interface. If bonding then fails
back to the original active interface, it is likely that the "active
slave" switch's IGMP forwarding for the port will be out of date until
some event occurs to refresh the switch (e.g., a membership query).
This patch alters the behavior of bonding to no longer flood
IGMP to all ports, and to issue IGMP JOINs to the newly active port at
the time of a failover. This insures that switches are kept up to date
for all cases.
"GOELLESCH Niels" <niels.goellesch@eurocontrol.int> originally
reported this problem, and included a patch. His original patch was
modified by Jay Vosburgh to additionally remove the existing IGMP flood
behavior, use RCU, streamline code paths, fix trailing white space, and
adjust for style.
Signed-off-by: Jay Vosburgh <fubar@us.ibm.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-02-28 18:03:37 -07:00
|
|
|
#endif
|
|
|
|
}
|
2010-11-18 10:33:19 -07:00
|
|
|
EXPORT_SYMBOL(ip_mc_rejoin_groups);
|
bonding: Improve IGMP join processing
In active-backup mode, the current bonding code duplicates IGMP
traffic to all slaves, so that switches are up to date in case of a
failover from an active to a backup interface. If bonding then fails
back to the original active interface, it is likely that the "active
slave" switch's IGMP forwarding for the port will be out of date until
some event occurs to refresh the switch (e.g., a membership query).
This patch alters the behavior of bonding to no longer flood
IGMP to all ports, and to issue IGMP JOINs to the newly active port at
the time of a failover. This insures that switches are kept up to date
for all cases.
"GOELLESCH Niels" <niels.goellesch@eurocontrol.int> originally
reported this problem, and included a patch. His original patch was
modified by Jay Vosburgh to additionally remove the existing IGMP flood
behavior, use RCU, streamline code paths, fix trailing white space, and
adjust for style.
Signed-off-by: Jay Vosburgh <fubar@us.ibm.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-02-28 18:03:37 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* A socket has left a multicast group on device dev
|
|
|
|
*/
|
|
|
|
|
2006-09-27 19:30:07 -06:00
|
|
|
void ip_mc_dec_group(struct in_device *in_dev, __be32 addr)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-11-11 22:46:50 -07:00
|
|
|
struct ip_mc_list *i;
|
|
|
|
struct ip_mc_list __rcu **ip;
|
2007-02-09 07:24:47 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
ASSERT_RTNL();
|
2007-02-09 07:24:47 -07:00
|
|
|
|
2010-11-11 22:46:50 -07:00
|
|
|
for (ip = &in_dev->mc_list;
|
|
|
|
(i = rtnl_dereference(*ip)) != NULL;
|
|
|
|
ip = &i->next_rcu) {
|
2008-11-03 01:26:09 -07:00
|
|
|
if (i->multiaddr == addr) {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (--i->users == 0) {
|
2010-11-11 22:46:50 -07:00
|
|
|
*ip = i->next_rcu;
|
2008-10-07 16:34:37 -06:00
|
|
|
in_dev->mc_count--;
|
2005-04-16 16:20:36 -06:00
|
|
|
igmp_group_dropped(i);
|
2011-05-23 17:15:05 -06:00
|
|
|
ip_mc_clear_src(i);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!in_dev->dead)
|
|
|
|
ip_rt_multicast_event(in_dev);
|
|
|
|
|
|
|
|
ip_ma_put(i);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2010-07-09 15:22:10 -06:00
|
|
|
EXPORT_SYMBOL(ip_mc_dec_group);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-09-15 03:37:40 -06:00
|
|
|
/* Device changing type */
|
|
|
|
|
|
|
|
void ip_mc_unmap(struct in_device *in_dev)
|
|
|
|
{
|
2010-11-11 22:46:50 -07:00
|
|
|
struct ip_mc_list *pmc;
|
2009-09-15 03:37:40 -06:00
|
|
|
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
2010-11-11 22:46:50 -07:00
|
|
|
for_each_pmc_rtnl(in_dev, pmc)
|
|
|
|
igmp_group_dropped(pmc);
|
2009-09-15 03:37:40 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
void ip_mc_remap(struct in_device *in_dev)
|
|
|
|
{
|
2010-11-11 22:46:50 -07:00
|
|
|
struct ip_mc_list *pmc;
|
2009-09-15 03:37:40 -06:00
|
|
|
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
2010-11-11 22:46:50 -07:00
|
|
|
for_each_pmc_rtnl(in_dev, pmc)
|
|
|
|
igmp_group_added(pmc);
|
2009-09-15 03:37:40 -06:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Device going down */
|
|
|
|
|
|
|
|
void ip_mc_down(struct in_device *in_dev)
|
|
|
|
{
|
2010-11-11 22:46:50 -07:00
|
|
|
struct ip_mc_list *pmc;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
2010-11-11 22:46:50 -07:00
|
|
|
for_each_pmc_rtnl(in_dev, pmc)
|
|
|
|
igmp_group_dropped(pmc);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#ifdef CONFIG_IP_MULTICAST
|
|
|
|
in_dev->mr_ifc_count = 0;
|
|
|
|
if (del_timer(&in_dev->mr_ifc_timer))
|
|
|
|
__in_dev_put(in_dev);
|
|
|
|
in_dev->mr_gq_running = 0;
|
|
|
|
if (del_timer(&in_dev->mr_gq_timer))
|
|
|
|
__in_dev_put(in_dev);
|
|
|
|
igmpv3_clear_delrec(in_dev);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
ip_mc_dec_group(in_dev, IGMP_ALL_HOSTS);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ip_mc_init_dev(struct in_device *in_dev)
|
|
|
|
{
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
|
|
|
in_dev->mc_tomb = NULL;
|
|
|
|
#ifdef CONFIG_IP_MULTICAST
|
|
|
|
in_dev->mr_gq_running = 0;
|
2008-01-23 22:20:07 -07:00
|
|
|
setup_timer(&in_dev->mr_gq_timer, igmp_gq_timer_expire,
|
|
|
|
(unsigned long)in_dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
in_dev->mr_ifc_count = 0;
|
2008-10-07 16:34:37 -06:00
|
|
|
in_dev->mc_count = 0;
|
2008-01-23 22:20:07 -07:00
|
|
|
setup_timer(&in_dev->mr_ifc_timer, igmp_ifc_timer_expire,
|
|
|
|
(unsigned long)in_dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
in_dev->mr_qrv = IGMP_Unsolicited_Report_Count;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
spin_lock_init(&in_dev->mc_tomb_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Device going up */
|
|
|
|
|
|
|
|
void ip_mc_up(struct in_device *in_dev)
|
|
|
|
{
|
2010-11-11 22:46:50 -07:00
|
|
|
struct ip_mc_list *pmc;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
|
|
|
ip_mc_inc_group(in_dev, IGMP_ALL_HOSTS);
|
|
|
|
|
2010-11-11 22:46:50 -07:00
|
|
|
for_each_pmc_rtnl(in_dev, pmc)
|
|
|
|
igmp_group_added(pmc);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Device is about to be destroyed: clean up.
|
|
|
|
*/
|
|
|
|
|
|
|
|
void ip_mc_destroy_dev(struct in_device *in_dev)
|
|
|
|
{
|
|
|
|
struct ip_mc_list *i;
|
|
|
|
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
|
|
|
/* Deactivate timers */
|
|
|
|
ip_mc_down(in_dev);
|
|
|
|
|
2010-11-11 22:46:50 -07:00
|
|
|
while ((i = rtnl_dereference(in_dev->mc_list)) != NULL) {
|
|
|
|
in_dev->mc_list = i->next_rcu;
|
2008-10-07 16:34:37 -06:00
|
|
|
in_dev->mc_count--;
|
2010-11-11 22:46:50 -07:00
|
|
|
|
2011-05-23 17:15:05 -06:00
|
|
|
/* We've dropped the groups in ip_mc_down already */
|
|
|
|
ip_mc_clear_src(i);
|
2005-04-16 16:20:36 -06:00
|
|
|
ip_ma_put(i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-10-18 18:39:18 -06:00
|
|
|
/* RTNL is locked */
|
2008-08-13 17:15:57 -06:00
|
|
|
static struct in_device *ip_mc_find_dev(struct net *net, struct ip_mreqn *imr)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct net_device *dev = NULL;
|
|
|
|
struct in_device *idev = NULL;
|
|
|
|
|
|
|
|
if (imr->imr_ifindex) {
|
2008-08-13 17:15:57 -06:00
|
|
|
idev = inetdev_by_index(net, imr->imr_ifindex);
|
2005-04-16 16:20:36 -06:00
|
|
|
return idev;
|
|
|
|
}
|
|
|
|
if (imr->imr_address.s_addr) {
|
2010-10-18 18:39:18 -06:00
|
|
|
dev = __ip_dev_find(net, imr->imr_address.s_addr, false);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!dev)
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2011-03-02 15:31:35 -07:00
|
|
|
if (!dev) {
|
2011-03-11 22:00:52 -07:00
|
|
|
struct rtable *rt = ip_route_output(net,
|
|
|
|
imr->imr_multiaddr.s_addr,
|
|
|
|
0, 0, 0);
|
2011-03-02 15:31:35 -07:00
|
|
|
if (!IS_ERR(rt)) {
|
|
|
|
dev = rt->dst.dev;
|
|
|
|
ip_rt_put(rt);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
if (dev) {
|
|
|
|
imr->imr_ifindex = dev->ifindex;
|
2005-10-03 15:35:55 -06:00
|
|
|
idev = __in_dev_get_rtnl(dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
return idev;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Join a socket to a group
|
|
|
|
*/
|
2006-09-22 15:15:41 -06:00
|
|
|
int sysctl_igmp_max_memberships __read_mostly = IP_MAX_MEMBERSHIPS;
|
|
|
|
int sysctl_igmp_max_msf __read_mostly = IP_MAX_MSF;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
|
|
static int ip_mc_del1_src(struct ip_mc_list *pmc, int sfmode,
|
2006-09-27 19:30:07 -06:00
|
|
|
__be32 *psfsrc)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct ip_sf_list *psf, *psf_prev;
|
|
|
|
int rv = 0;
|
|
|
|
|
|
|
|
psf_prev = NULL;
|
|
|
|
for (psf=pmc->sources; psf; psf=psf->sf_next) {
|
|
|
|
if (psf->sf_inaddr == *psfsrc)
|
|
|
|
break;
|
|
|
|
psf_prev = psf;
|
|
|
|
}
|
|
|
|
if (!psf || psf->sf_count[sfmode] == 0) {
|
|
|
|
/* source filter not found, or count wrong => bug */
|
|
|
|
return -ESRCH;
|
|
|
|
}
|
|
|
|
psf->sf_count[sfmode]--;
|
|
|
|
if (psf->sf_count[sfmode] == 0) {
|
|
|
|
ip_rt_multicast_event(pmc->interface);
|
|
|
|
}
|
|
|
|
if (!psf->sf_count[MCAST_INCLUDE] && !psf->sf_count[MCAST_EXCLUDE]) {
|
|
|
|
#ifdef CONFIG_IP_MULTICAST
|
|
|
|
struct in_device *in_dev = pmc->interface;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* no more filters for this source */
|
|
|
|
if (psf_prev)
|
|
|
|
psf_prev->sf_next = psf->sf_next;
|
|
|
|
else
|
|
|
|
pmc->sources = psf->sf_next;
|
|
|
|
#ifdef CONFIG_IP_MULTICAST
|
|
|
|
if (psf->sf_oldin &&
|
|
|
|
!IGMP_V1_SEEN(in_dev) && !IGMP_V2_SEEN(in_dev)) {
|
2007-02-09 07:24:47 -07:00
|
|
|
psf->sf_crcount = in_dev->mr_qrv ? in_dev->mr_qrv :
|
2005-04-16 16:20:36 -06:00
|
|
|
IGMP_Unsolicited_Report_Count;
|
|
|
|
psf->sf_next = pmc->tomb;
|
|
|
|
pmc->tomb = psf;
|
|
|
|
rv = 1;
|
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
kfree(psf);
|
|
|
|
}
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifndef CONFIG_IP_MULTICAST
|
|
|
|
#define igmp_ifc_event(x) do { } while (0)
|
|
|
|
#endif
|
|
|
|
|
2006-09-27 19:30:07 -06:00
|
|
|
static int ip_mc_del_src(struct in_device *in_dev, __be32 *pmca, int sfmode,
|
|
|
|
int sfcount, __be32 *psfsrc, int delta)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct ip_mc_list *pmc;
|
|
|
|
int changerec = 0;
|
|
|
|
int i, err;
|
|
|
|
|
|
|
|
if (!in_dev)
|
|
|
|
return -ENODEV;
|
2010-11-11 22:46:50 -07:00
|
|
|
rcu_read_lock();
|
|
|
|
for_each_pmc_rcu(in_dev, pmc) {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (*pmca == pmc->multiaddr)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!pmc) {
|
|
|
|
/* MCA not found?? bug */
|
2010-11-11 22:46:50 -07:00
|
|
|
rcu_read_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ESRCH;
|
|
|
|
}
|
|
|
|
spin_lock_bh(&pmc->lock);
|
2010-11-11 22:46:50 -07:00
|
|
|
rcu_read_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef CONFIG_IP_MULTICAST
|
|
|
|
sf_markstate(pmc);
|
|
|
|
#endif
|
|
|
|
if (!delta) {
|
|
|
|
err = -EINVAL;
|
|
|
|
if (!pmc->sfcount[sfmode])
|
|
|
|
goto out_unlock;
|
|
|
|
pmc->sfcount[sfmode]--;
|
|
|
|
}
|
|
|
|
err = 0;
|
|
|
|
for (i=0; i<sfcount; i++) {
|
|
|
|
int rv = ip_mc_del1_src(pmc, sfmode, &psfsrc[i]);
|
|
|
|
|
|
|
|
changerec |= rv > 0;
|
|
|
|
if (!err && rv < 0)
|
|
|
|
err = rv;
|
|
|
|
}
|
|
|
|
if (pmc->sfmode == MCAST_EXCLUDE &&
|
|
|
|
pmc->sfcount[MCAST_EXCLUDE] == 0 &&
|
|
|
|
pmc->sfcount[MCAST_INCLUDE]) {
|
|
|
|
#ifdef CONFIG_IP_MULTICAST
|
|
|
|
struct ip_sf_list *psf;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* filter mode change */
|
|
|
|
pmc->sfmode = MCAST_INCLUDE;
|
|
|
|
#ifdef CONFIG_IP_MULTICAST
|
2007-02-09 07:24:47 -07:00
|
|
|
pmc->crcount = in_dev->mr_qrv ? in_dev->mr_qrv :
|
2005-04-16 16:20:36 -06:00
|
|
|
IGMP_Unsolicited_Report_Count;
|
|
|
|
in_dev->mr_ifc_count = pmc->crcount;
|
|
|
|
for (psf=pmc->sources; psf; psf = psf->sf_next)
|
|
|
|
psf->sf_crcount = 0;
|
|
|
|
igmp_ifc_event(pmc->interface);
|
|
|
|
} else if (sf_setstate(pmc) || changerec) {
|
|
|
|
igmp_ifc_event(pmc->interface);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
out_unlock:
|
|
|
|
spin_unlock_bh(&pmc->lock);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add multicast single-source filter to the interface list
|
|
|
|
*/
|
|
|
|
static int ip_mc_add1_src(struct ip_mc_list *pmc, int sfmode,
|
2011-11-29 23:21:04 -07:00
|
|
|
__be32 *psfsrc)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct ip_sf_list *psf, *psf_prev;
|
|
|
|
|
|
|
|
psf_prev = NULL;
|
|
|
|
for (psf=pmc->sources; psf; psf=psf->sf_next) {
|
|
|
|
if (psf->sf_inaddr == *psfsrc)
|
|
|
|
break;
|
|
|
|
psf_prev = psf;
|
|
|
|
}
|
|
|
|
if (!psf) {
|
2006-07-21 15:51:30 -06:00
|
|
|
psf = kzalloc(sizeof(*psf), GFP_ATOMIC);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!psf)
|
|
|
|
return -ENOBUFS;
|
|
|
|
psf->sf_inaddr = *psfsrc;
|
|
|
|
if (psf_prev) {
|
|
|
|
psf_prev->sf_next = psf;
|
|
|
|
} else
|
|
|
|
pmc->sources = psf;
|
|
|
|
}
|
|
|
|
psf->sf_count[sfmode]++;
|
|
|
|
if (psf->sf_count[sfmode] == 1) {
|
|
|
|
ip_rt_multicast_event(pmc->interface);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_IP_MULTICAST
|
|
|
|
static void sf_markstate(struct ip_mc_list *pmc)
|
|
|
|
{
|
|
|
|
struct ip_sf_list *psf;
|
|
|
|
int mca_xcount = pmc->sfcount[MCAST_EXCLUDE];
|
|
|
|
|
|
|
|
for (psf=pmc->sources; psf; psf=psf->sf_next)
|
|
|
|
if (pmc->sfcount[MCAST_EXCLUDE]) {
|
|
|
|
psf->sf_oldin = mca_xcount ==
|
|
|
|
psf->sf_count[MCAST_EXCLUDE] &&
|
|
|
|
!psf->sf_count[MCAST_INCLUDE];
|
|
|
|
} else
|
|
|
|
psf->sf_oldin = psf->sf_count[MCAST_INCLUDE] != 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sf_setstate(struct ip_mc_list *pmc)
|
|
|
|
{
|
2006-01-18 15:20:56 -07:00
|
|
|
struct ip_sf_list *psf, *dpsf;
|
2005-04-16 16:20:36 -06:00
|
|
|
int mca_xcount = pmc->sfcount[MCAST_EXCLUDE];
|
|
|
|
int qrv = pmc->interface->mr_qrv;
|
|
|
|
int new_in, rv;
|
|
|
|
|
|
|
|
rv = 0;
|
|
|
|
for (psf=pmc->sources; psf; psf=psf->sf_next) {
|
|
|
|
if (pmc->sfcount[MCAST_EXCLUDE]) {
|
|
|
|
new_in = mca_xcount == psf->sf_count[MCAST_EXCLUDE] &&
|
|
|
|
!psf->sf_count[MCAST_INCLUDE];
|
|
|
|
} else
|
|
|
|
new_in = psf->sf_count[MCAST_INCLUDE] != 0;
|
2006-01-18 15:20:56 -07:00
|
|
|
if (new_in) {
|
|
|
|
if (!psf->sf_oldin) {
|
2006-02-01 03:54:35 -07:00
|
|
|
struct ip_sf_list *prev = NULL;
|
2006-01-18 15:20:56 -07:00
|
|
|
|
|
|
|
for (dpsf=pmc->tomb; dpsf; dpsf=dpsf->sf_next) {
|
|
|
|
if (dpsf->sf_inaddr == psf->sf_inaddr)
|
|
|
|
break;
|
|
|
|
prev = dpsf;
|
|
|
|
}
|
|
|
|
if (dpsf) {
|
|
|
|
if (prev)
|
|
|
|
prev->sf_next = dpsf->sf_next;
|
|
|
|
else
|
|
|
|
pmc->tomb = dpsf->sf_next;
|
|
|
|
kfree(dpsf);
|
|
|
|
}
|
|
|
|
psf->sf_crcount = qrv;
|
|
|
|
rv++;
|
|
|
|
}
|
|
|
|
} else if (psf->sf_oldin) {
|
|
|
|
|
|
|
|
psf->sf_crcount = 0;
|
|
|
|
/*
|
|
|
|
* add or update "delete" records if an active filter
|
|
|
|
* is now inactive
|
|
|
|
*/
|
|
|
|
for (dpsf=pmc->tomb; dpsf; dpsf=dpsf->sf_next)
|
|
|
|
if (dpsf->sf_inaddr == psf->sf_inaddr)
|
|
|
|
break;
|
|
|
|
if (!dpsf) {
|
2010-05-31 11:23:21 -06:00
|
|
|
dpsf = kmalloc(sizeof(*dpsf), GFP_ATOMIC);
|
2006-01-18 15:20:56 -07:00
|
|
|
if (!dpsf)
|
|
|
|
continue;
|
|
|
|
*dpsf = *psf;
|
|
|
|
/* pmc->lock held by callers */
|
|
|
|
dpsf->sf_next = pmc->tomb;
|
|
|
|
pmc->tomb = dpsf;
|
|
|
|
}
|
|
|
|
dpsf->sf_crcount = qrv;
|
2005-04-16 16:20:36 -06:00
|
|
|
rv++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add multicast source filter list to the interface list
|
|
|
|
*/
|
2006-09-27 19:30:07 -06:00
|
|
|
static int ip_mc_add_src(struct in_device *in_dev, __be32 *pmca, int sfmode,
|
|
|
|
int sfcount, __be32 *psfsrc, int delta)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct ip_mc_list *pmc;
|
|
|
|
int isexclude;
|
|
|
|
int i, err;
|
|
|
|
|
|
|
|
if (!in_dev)
|
|
|
|
return -ENODEV;
|
2010-11-11 22:46:50 -07:00
|
|
|
rcu_read_lock();
|
|
|
|
for_each_pmc_rcu(in_dev, pmc) {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (*pmca == pmc->multiaddr)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!pmc) {
|
|
|
|
/* MCA not found?? bug */
|
2010-11-11 22:46:50 -07:00
|
|
|
rcu_read_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ESRCH;
|
|
|
|
}
|
|
|
|
spin_lock_bh(&pmc->lock);
|
2010-11-11 22:46:50 -07:00
|
|
|
rcu_read_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#ifdef CONFIG_IP_MULTICAST
|
|
|
|
sf_markstate(pmc);
|
|
|
|
#endif
|
|
|
|
isexclude = pmc->sfmode == MCAST_EXCLUDE;
|
|
|
|
if (!delta)
|
|
|
|
pmc->sfcount[sfmode]++;
|
|
|
|
err = 0;
|
|
|
|
for (i=0; i<sfcount; i++) {
|
2011-11-29 23:21:04 -07:00
|
|
|
err = ip_mc_add1_src(pmc, sfmode, &psfsrc[i]);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (err)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (err) {
|
|
|
|
int j;
|
|
|
|
|
2011-11-22 10:19:03 -07:00
|
|
|
if (!delta)
|
|
|
|
pmc->sfcount[sfmode]--;
|
2005-04-16 16:20:36 -06:00
|
|
|
for (j=0; j<i; j++)
|
2011-07-27 20:46:01 -06:00
|
|
|
(void) ip_mc_del1_src(pmc, sfmode, &psfsrc[j]);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else if (isexclude != (pmc->sfcount[MCAST_EXCLUDE] != 0)) {
|
|
|
|
#ifdef CONFIG_IP_MULTICAST
|
|
|
|
struct ip_sf_list *psf;
|
2007-10-09 02:59:42 -06:00
|
|
|
in_dev = pmc->interface;
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/* filter mode change */
|
|
|
|
if (pmc->sfcount[MCAST_EXCLUDE])
|
|
|
|
pmc->sfmode = MCAST_EXCLUDE;
|
|
|
|
else if (pmc->sfcount[MCAST_INCLUDE])
|
|
|
|
pmc->sfmode = MCAST_INCLUDE;
|
|
|
|
#ifdef CONFIG_IP_MULTICAST
|
|
|
|
/* else no filters; keep old mode for reports */
|
|
|
|
|
2007-02-09 07:24:47 -07:00
|
|
|
pmc->crcount = in_dev->mr_qrv ? in_dev->mr_qrv :
|
2005-04-16 16:20:36 -06:00
|
|
|
IGMP_Unsolicited_Report_Count;
|
|
|
|
in_dev->mr_ifc_count = pmc->crcount;
|
|
|
|
for (psf=pmc->sources; psf; psf = psf->sf_next)
|
|
|
|
psf->sf_crcount = 0;
|
|
|
|
igmp_ifc_event(in_dev);
|
|
|
|
} else if (sf_setstate(pmc)) {
|
|
|
|
igmp_ifc_event(in_dev);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
spin_unlock_bh(&pmc->lock);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ip_mc_clear_src(struct ip_mc_list *pmc)
|
|
|
|
{
|
|
|
|
struct ip_sf_list *psf, *nextpsf;
|
|
|
|
|
|
|
|
for (psf=pmc->tomb; psf; psf=nextpsf) {
|
|
|
|
nextpsf = psf->sf_next;
|
|
|
|
kfree(psf);
|
|
|
|
}
|
|
|
|
pmc->tomb = NULL;
|
|
|
|
for (psf=pmc->sources; psf; psf=nextpsf) {
|
|
|
|
nextpsf = psf->sf_next;
|
|
|
|
kfree(psf);
|
|
|
|
}
|
|
|
|
pmc->sources = NULL;
|
|
|
|
pmc->sfmode = MCAST_EXCLUDE;
|
2005-09-14 21:53:42 -06:00
|
|
|
pmc->sfcount[MCAST_INCLUDE] = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
pmc->sfcount[MCAST_EXCLUDE] = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Join a multicast group
|
|
|
|
*/
|
|
|
|
int ip_mc_join_group(struct sock *sk , struct ip_mreqn *imr)
|
|
|
|
{
|
|
|
|
int err;
|
2006-09-27 19:30:07 -06:00
|
|
|
__be32 addr = imr->imr_multiaddr.s_addr;
|
2008-11-03 01:26:09 -07:00
|
|
|
struct ip_mc_socklist *iml = NULL, *i;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct in_device *in_dev;
|
|
|
|
struct inet_sock *inet = inet_sk(sk);
|
2008-08-13 17:15:57 -06:00
|
|
|
struct net *net = sock_net(sk);
|
2005-07-08 18:38:07 -06:00
|
|
|
int ifindex;
|
2005-04-16 16:20:36 -06:00
|
|
|
int count = 0;
|
|
|
|
|
2007-12-16 14:45:43 -07:00
|
|
|
if (!ipv4_is_multicast(addr))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
2006-03-20 23:23:58 -07:00
|
|
|
rtnl_lock();
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-08-13 17:15:57 -06:00
|
|
|
in_dev = ip_mc_find_dev(net, imr);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!in_dev) {
|
|
|
|
iml = NULL;
|
|
|
|
err = -ENODEV;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = -EADDRINUSE;
|
2005-07-08 18:38:07 -06:00
|
|
|
ifindex = imr->imr_ifindex;
|
2010-11-11 22:46:50 -07:00
|
|
|
for_each_pmc_rtnl(inet, i) {
|
2005-07-08 18:38:07 -06:00
|
|
|
if (i->multi.imr_multiaddr.s_addr == addr &&
|
|
|
|
i->multi.imr_ifindex == ifindex)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto done;
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
err = -ENOBUFS;
|
2005-07-08 18:38:07 -06:00
|
|
|
if (count >= sysctl_igmp_max_memberships)
|
|
|
|
goto done;
|
2008-11-03 01:26:09 -07:00
|
|
|
iml = sock_kmalloc(sk, sizeof(*iml), GFP_KERNEL);
|
2005-07-08 18:38:07 -06:00
|
|
|
if (iml == NULL)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto done;
|
2005-07-08 18:38:07 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
memcpy(&iml->multi, imr, sizeof(*imr));
|
2010-11-11 22:46:50 -07:00
|
|
|
iml->next_rcu = inet->mc_list;
|
2005-04-16 16:20:36 -06:00
|
|
|
iml->sflist = NULL;
|
|
|
|
iml->sfmode = MCAST_EXCLUDE;
|
2012-01-11 21:41:32 -07:00
|
|
|
rcu_assign_pointer(inet->mc_list, iml);
|
2005-04-16 16:20:36 -06:00
|
|
|
ip_mc_inc_group(in_dev, addr);
|
|
|
|
err = 0;
|
|
|
|
done:
|
2006-03-20 23:23:58 -07:00
|
|
|
rtnl_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
return err;
|
|
|
|
}
|
2010-07-09 15:22:10 -06:00
|
|
|
EXPORT_SYMBOL(ip_mc_join_group);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
static int ip_mc_leave_src(struct sock *sk, struct ip_mc_socklist *iml,
|
|
|
|
struct in_device *in_dev)
|
|
|
|
{
|
2010-11-11 22:46:50 -07:00
|
|
|
struct ip_sf_socklist *psf = rtnl_dereference(iml->sflist);
|
2005-04-16 16:20:36 -06:00
|
|
|
int err;
|
|
|
|
|
2010-02-02 08:32:29 -07:00
|
|
|
if (psf == NULL) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/* any-source empty exclude case */
|
|
|
|
return ip_mc_del_src(in_dev, &iml->multi.imr_multiaddr.s_addr,
|
|
|
|
iml->sfmode, 0, NULL, 0);
|
|
|
|
}
|
|
|
|
err = ip_mc_del_src(in_dev, &iml->multi.imr_multiaddr.s_addr,
|
2010-02-02 08:32:29 -07:00
|
|
|
iml->sfmode, psf->sl_count, psf->sl_addr, 0);
|
2011-08-01 10:19:00 -06:00
|
|
|
RCU_INIT_POINTER(iml->sflist, NULL);
|
2010-02-02 08:32:29 -07:00
|
|
|
/* decrease mem now to avoid the memleak warning */
|
|
|
|
atomic_sub(IP_SFLSIZE(psf->sl_max), &sk->sk_omem_alloc);
|
2011-03-17 21:44:46 -06:00
|
|
|
kfree_rcu(psf, rcu);
|
2005-04-16 16:20:36 -06:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Ask a socket to leave a group.
|
|
|
|
*/
|
|
|
|
|
|
|
|
int ip_mc_leave_group(struct sock *sk, struct ip_mreqn *imr)
|
|
|
|
{
|
|
|
|
struct inet_sock *inet = inet_sk(sk);
|
2010-11-11 22:46:50 -07:00
|
|
|
struct ip_mc_socklist *iml;
|
|
|
|
struct ip_mc_socklist __rcu **imlp;
|
2005-07-08 18:48:38 -06:00
|
|
|
struct in_device *in_dev;
|
2008-08-13 17:15:57 -06:00
|
|
|
struct net *net = sock_net(sk);
|
2006-09-27 19:30:07 -06:00
|
|
|
__be32 group = imr->imr_multiaddr.s_addr;
|
2005-07-08 18:48:38 -06:00
|
|
|
u32 ifindex;
|
2006-08-17 17:27:39 -06:00
|
|
|
int ret = -EADDRNOTAVAIL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
rtnl_lock();
|
2008-08-13 17:15:57 -06:00
|
|
|
in_dev = ip_mc_find_dev(net, imr);
|
2005-07-08 18:48:38 -06:00
|
|
|
ifindex = imr->imr_ifindex;
|
2010-11-11 22:46:50 -07:00
|
|
|
for (imlp = &inet->mc_list;
|
|
|
|
(iml = rtnl_dereference(*imlp)) != NULL;
|
|
|
|
imlp = &iml->next_rcu) {
|
2006-08-17 17:27:39 -06:00
|
|
|
if (iml->multi.imr_multiaddr.s_addr != group)
|
|
|
|
continue;
|
|
|
|
if (ifindex) {
|
|
|
|
if (iml->multi.imr_ifindex != ifindex)
|
|
|
|
continue;
|
|
|
|
} else if (imr->imr_address.s_addr && imr->imr_address.s_addr !=
|
|
|
|
iml->multi.imr_address.s_addr)
|
|
|
|
continue;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-08-17 17:27:39 -06:00
|
|
|
(void) ip_mc_leave_src(sk, iml, in_dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-11-11 22:46:50 -07:00
|
|
|
*imlp = iml->next_rcu;
|
2006-08-17 17:27:39 -06:00
|
|
|
|
|
|
|
if (in_dev)
|
2005-07-08 18:48:38 -06:00
|
|
|
ip_mc_dec_group(in_dev, group);
|
2006-08-17 17:27:39 -06:00
|
|
|
rtnl_unlock();
|
2010-02-02 08:32:29 -07:00
|
|
|
/* decrease mem now to avoid the memleak warning */
|
|
|
|
atomic_sub(sizeof(*iml), &sk->sk_omem_alloc);
|
2011-03-17 21:45:08 -06:00
|
|
|
kfree_rcu(iml, rcu);
|
2006-08-17 17:27:39 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2006-08-17 17:27:39 -06:00
|
|
|
if (!in_dev)
|
|
|
|
ret = -ENODEV;
|
2005-04-16 16:20:36 -06:00
|
|
|
rtnl_unlock();
|
2006-08-17 17:27:39 -06:00
|
|
|
return ret;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
int ip_mc_source(int add, int omode, struct sock *sk, struct
|
|
|
|
ip_mreq_source *mreqs, int ifindex)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
struct ip_mreqn imr;
|
2006-09-27 19:31:32 -06:00
|
|
|
__be32 addr = mreqs->imr_multiaddr;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct ip_mc_socklist *pmc;
|
|
|
|
struct in_device *in_dev = NULL;
|
|
|
|
struct inet_sock *inet = inet_sk(sk);
|
|
|
|
struct ip_sf_socklist *psl;
|
2008-08-13 17:15:57 -06:00
|
|
|
struct net *net = sock_net(sk);
|
2005-07-08 18:39:23 -06:00
|
|
|
int leavegroup = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
int i, j, rv;
|
|
|
|
|
2007-12-16 14:45:43 -07:00
|
|
|
if (!ipv4_is_multicast(addr))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
2006-03-20 23:23:58 -07:00
|
|
|
rtnl_lock();
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
imr.imr_multiaddr.s_addr = mreqs->imr_multiaddr;
|
|
|
|
imr.imr_address.s_addr = mreqs->imr_interface;
|
|
|
|
imr.imr_ifindex = ifindex;
|
2008-08-13 17:15:57 -06:00
|
|
|
in_dev = ip_mc_find_dev(net, &imr);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!in_dev) {
|
|
|
|
err = -ENODEV;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
err = -EADDRNOTAVAIL;
|
|
|
|
|
2010-11-11 22:46:50 -07:00
|
|
|
for_each_pmc_rtnl(inet, pmc) {
|
2009-11-29 17:55:45 -07:00
|
|
|
if ((pmc->multi.imr_multiaddr.s_addr ==
|
|
|
|
imr.imr_multiaddr.s_addr) &&
|
|
|
|
(pmc->multi.imr_ifindex == imr.imr_ifindex))
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
}
|
2005-07-08 18:45:16 -06:00
|
|
|
if (!pmc) { /* must have a prior join */
|
|
|
|
err = -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
goto done;
|
2005-07-08 18:45:16 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
/* if a source filter was set, must be the same mode as before */
|
|
|
|
if (pmc->sflist) {
|
2005-07-08 18:45:16 -06:00
|
|
|
if (pmc->sfmode != omode) {
|
|
|
|
err = -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
goto done;
|
2005-07-08 18:45:16 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
} else if (pmc->sfmode != omode) {
|
|
|
|
/* allow mode switches for empty-set filters */
|
|
|
|
ip_mc_add_src(in_dev, &mreqs->imr_multiaddr, omode, 0, NULL, 0);
|
2007-02-09 07:24:47 -07:00
|
|
|
ip_mc_del_src(in_dev, &mreqs->imr_multiaddr, pmc->sfmode, 0,
|
2005-04-16 16:20:36 -06:00
|
|
|
NULL, 0);
|
|
|
|
pmc->sfmode = omode;
|
|
|
|
}
|
|
|
|
|
2010-11-11 22:46:50 -07:00
|
|
|
psl = rtnl_dereference(pmc->sflist);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!add) {
|
|
|
|
if (!psl)
|
2005-07-08 18:45:16 -06:00
|
|
|
goto done; /* err = -EADDRNOTAVAIL */
|
2005-04-16 16:20:36 -06:00
|
|
|
rv = !0;
|
|
|
|
for (i=0; i<psl->sl_count; i++) {
|
|
|
|
rv = memcmp(&psl->sl_addr[i], &mreqs->imr_sourceaddr,
|
2006-09-27 19:31:32 -06:00
|
|
|
sizeof(__be32));
|
2005-04-16 16:20:36 -06:00
|
|
|
if (rv == 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (rv) /* source not found */
|
2005-07-08 18:45:16 -06:00
|
|
|
goto done; /* err = -EADDRNOTAVAIL */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-07-08 18:39:23 -06:00
|
|
|
/* special case - (INCLUDE, empty) == LEAVE_GROUP */
|
|
|
|
if (psl->sl_count == 1 && omode == MCAST_INCLUDE) {
|
|
|
|
leavegroup = 1;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* update the interface filter */
|
2007-02-09 07:24:47 -07:00
|
|
|
ip_mc_del_src(in_dev, &mreqs->imr_multiaddr, omode, 1,
|
2005-04-16 16:20:36 -06:00
|
|
|
&mreqs->imr_sourceaddr, 1);
|
|
|
|
|
|
|
|
for (j=i+1; j<psl->sl_count; j++)
|
|
|
|
psl->sl_addr[j-1] = psl->sl_addr[j];
|
|
|
|
psl->sl_count--;
|
|
|
|
err = 0;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
/* else, add a new source to the filter */
|
|
|
|
|
|
|
|
if (psl && psl->sl_count >= sysctl_igmp_max_msf) {
|
|
|
|
err = -ENOBUFS;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
if (!psl || psl->sl_count == psl->sl_max) {
|
|
|
|
struct ip_sf_socklist *newpsl;
|
|
|
|
int count = IP_SFBLOCK;
|
|
|
|
|
|
|
|
if (psl)
|
|
|
|
count += psl->sl_max;
|
2006-01-11 16:56:43 -07:00
|
|
|
newpsl = sock_kmalloc(sk, IP_SFLSIZE(count), GFP_KERNEL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!newpsl) {
|
|
|
|
err = -ENOBUFS;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
newpsl->sl_max = count;
|
|
|
|
newpsl->sl_count = count - IP_SFBLOCK;
|
|
|
|
if (psl) {
|
|
|
|
for (i=0; i<psl->sl_count; i++)
|
|
|
|
newpsl->sl_addr[i] = psl->sl_addr[i];
|
2010-02-02 08:32:29 -07:00
|
|
|
/* decrease mem now to avoid the memleak warning */
|
|
|
|
atomic_sub(IP_SFLSIZE(psl->sl_max), &sk->sk_omem_alloc);
|
2011-03-17 21:44:46 -06:00
|
|
|
kfree_rcu(psl, rcu);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2012-01-11 21:41:32 -07:00
|
|
|
rcu_assign_pointer(pmc->sflist, newpsl);
|
2010-02-02 08:32:29 -07:00
|
|
|
psl = newpsl;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
rv = 1; /* > 0 for insert logic below if sl_count is 0 */
|
|
|
|
for (i=0; i<psl->sl_count; i++) {
|
|
|
|
rv = memcmp(&psl->sl_addr[i], &mreqs->imr_sourceaddr,
|
2006-09-27 19:31:32 -06:00
|
|
|
sizeof(__be32));
|
2005-04-16 16:20:36 -06:00
|
|
|
if (rv == 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (rv == 0) /* address already there is an error */
|
|
|
|
goto done;
|
|
|
|
for (j=psl->sl_count-1; j>=i; j--)
|
|
|
|
psl->sl_addr[j+1] = psl->sl_addr[j];
|
|
|
|
psl->sl_addr[i] = mreqs->imr_sourceaddr;
|
|
|
|
psl->sl_count++;
|
|
|
|
err = 0;
|
|
|
|
/* update the interface list */
|
2007-02-09 07:24:47 -07:00
|
|
|
ip_mc_add_src(in_dev, &mreqs->imr_multiaddr, omode, 1,
|
2005-04-16 16:20:36 -06:00
|
|
|
&mreqs->imr_sourceaddr, 1);
|
|
|
|
done:
|
2006-03-20 23:23:58 -07:00
|
|
|
rtnl_unlock();
|
2005-07-08 18:39:23 -06:00
|
|
|
if (leavegroup)
|
|
|
|
return ip_mc_leave_group(sk, &imr);
|
2005-04-16 16:20:36 -06:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
int ip_mc_msfilter(struct sock *sk, struct ip_msfilter *msf, int ifindex)
|
|
|
|
{
|
2005-07-08 18:47:28 -06:00
|
|
|
int err = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct ip_mreqn imr;
|
2006-09-27 19:31:32 -06:00
|
|
|
__be32 addr = msf->imsf_multiaddr;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct ip_mc_socklist *pmc;
|
|
|
|
struct in_device *in_dev;
|
|
|
|
struct inet_sock *inet = inet_sk(sk);
|
|
|
|
struct ip_sf_socklist *newpsl, *psl;
|
2008-08-13 17:15:57 -06:00
|
|
|
struct net *net = sock_net(sk);
|
2005-07-08 18:47:28 -06:00
|
|
|
int leavegroup = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-12-16 14:45:43 -07:00
|
|
|
if (!ipv4_is_multicast(addr))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
if (msf->imsf_fmode != MCAST_INCLUDE &&
|
|
|
|
msf->imsf_fmode != MCAST_EXCLUDE)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2006-03-20 23:23:58 -07:00
|
|
|
rtnl_lock();
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
imr.imr_multiaddr.s_addr = msf->imsf_multiaddr;
|
|
|
|
imr.imr_address.s_addr = msf->imsf_interface;
|
|
|
|
imr.imr_ifindex = ifindex;
|
2008-08-13 17:15:57 -06:00
|
|
|
in_dev = ip_mc_find_dev(net, &imr);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!in_dev) {
|
|
|
|
err = -ENODEV;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2005-07-08 18:47:28 -06:00
|
|
|
/* special case - (INCLUDE, empty) == LEAVE_GROUP */
|
|
|
|
if (msf->imsf_fmode == MCAST_INCLUDE && msf->imsf_numsrc == 0) {
|
|
|
|
leavegroup = 1;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2010-11-11 22:46:50 -07:00
|
|
|
for_each_pmc_rtnl(inet, pmc) {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (pmc->multi.imr_multiaddr.s_addr == msf->imsf_multiaddr &&
|
|
|
|
pmc->multi.imr_ifindex == imr.imr_ifindex)
|
|
|
|
break;
|
|
|
|
}
|
2005-07-08 18:45:16 -06:00
|
|
|
if (!pmc) { /* must have a prior join */
|
|
|
|
err = -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
goto done;
|
2005-07-08 18:45:16 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
if (msf->imsf_numsrc) {
|
2006-01-11 16:56:43 -07:00
|
|
|
newpsl = sock_kmalloc(sk, IP_SFLSIZE(msf->imsf_numsrc),
|
|
|
|
GFP_KERNEL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!newpsl) {
|
|
|
|
err = -ENOBUFS;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
newpsl->sl_max = newpsl->sl_count = msf->imsf_numsrc;
|
|
|
|
memcpy(newpsl->sl_addr, msf->imsf_slist,
|
|
|
|
msf->imsf_numsrc * sizeof(msf->imsf_slist[0]));
|
|
|
|
err = ip_mc_add_src(in_dev, &msf->imsf_multiaddr,
|
|
|
|
msf->imsf_fmode, newpsl->sl_count, newpsl->sl_addr, 0);
|
|
|
|
if (err) {
|
|
|
|
sock_kfree_s(sk, newpsl, IP_SFLSIZE(newpsl->sl_max));
|
|
|
|
goto done;
|
|
|
|
}
|
2005-10-27 18:02:08 -06:00
|
|
|
} else {
|
2005-04-16 16:20:36 -06:00
|
|
|
newpsl = NULL;
|
2005-10-27 18:02:08 -06:00
|
|
|
(void) ip_mc_add_src(in_dev, &msf->imsf_multiaddr,
|
|
|
|
msf->imsf_fmode, 0, NULL, 0);
|
|
|
|
}
|
2010-11-11 22:46:50 -07:00
|
|
|
psl = rtnl_dereference(pmc->sflist);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (psl) {
|
|
|
|
(void) ip_mc_del_src(in_dev, &msf->imsf_multiaddr, pmc->sfmode,
|
|
|
|
psl->sl_count, psl->sl_addr, 0);
|
2010-02-02 08:32:29 -07:00
|
|
|
/* decrease mem now to avoid the memleak warning */
|
|
|
|
atomic_sub(IP_SFLSIZE(psl->sl_max), &sk->sk_omem_alloc);
|
2011-03-17 21:44:46 -06:00
|
|
|
kfree_rcu(psl, rcu);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else
|
|
|
|
(void) ip_mc_del_src(in_dev, &msf->imsf_multiaddr, pmc->sfmode,
|
|
|
|
0, NULL, 0);
|
2012-01-11 21:41:32 -07:00
|
|
|
rcu_assign_pointer(pmc->sflist, newpsl);
|
2005-04-16 16:20:36 -06:00
|
|
|
pmc->sfmode = msf->imsf_fmode;
|
2005-07-08 18:45:16 -06:00
|
|
|
err = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
done:
|
2006-03-20 23:23:58 -07:00
|
|
|
rtnl_unlock();
|
2005-07-08 18:47:28 -06:00
|
|
|
if (leavegroup)
|
|
|
|
err = ip_mc_leave_group(sk, &imr);
|
2005-04-16 16:20:36 -06:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
int ip_mc_msfget(struct sock *sk, struct ip_msfilter *msf,
|
|
|
|
struct ip_msfilter __user *optval, int __user *optlen)
|
|
|
|
{
|
|
|
|
int err, len, count, copycount;
|
|
|
|
struct ip_mreqn imr;
|
2006-09-27 19:31:32 -06:00
|
|
|
__be32 addr = msf->imsf_multiaddr;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct ip_mc_socklist *pmc;
|
|
|
|
struct in_device *in_dev;
|
|
|
|
struct inet_sock *inet = inet_sk(sk);
|
|
|
|
struct ip_sf_socklist *psl;
|
2008-08-13 17:15:57 -06:00
|
|
|
struct net *net = sock_net(sk);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-12-16 14:45:43 -07:00
|
|
|
if (!ipv4_is_multicast(addr))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
2006-03-20 23:23:58 -07:00
|
|
|
rtnl_lock();
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
imr.imr_multiaddr.s_addr = msf->imsf_multiaddr;
|
|
|
|
imr.imr_address.s_addr = msf->imsf_interface;
|
|
|
|
imr.imr_ifindex = 0;
|
2008-08-13 17:15:57 -06:00
|
|
|
in_dev = ip_mc_find_dev(net, &imr);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!in_dev) {
|
|
|
|
err = -ENODEV;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
err = -EADDRNOTAVAIL;
|
|
|
|
|
2010-11-11 22:46:50 -07:00
|
|
|
for_each_pmc_rtnl(inet, pmc) {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (pmc->multi.imr_multiaddr.s_addr == msf->imsf_multiaddr &&
|
|
|
|
pmc->multi.imr_ifindex == imr.imr_ifindex)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!pmc) /* must have a prior join */
|
|
|
|
goto done;
|
|
|
|
msf->imsf_fmode = pmc->sfmode;
|
2010-11-11 22:46:50 -07:00
|
|
|
psl = rtnl_dereference(pmc->sflist);
|
2006-03-20 23:23:58 -07:00
|
|
|
rtnl_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!psl) {
|
|
|
|
len = 0;
|
|
|
|
count = 0;
|
|
|
|
} else {
|
|
|
|
count = psl->sl_count;
|
|
|
|
}
|
|
|
|
copycount = count < msf->imsf_numsrc ? count : msf->imsf_numsrc;
|
|
|
|
len = copycount * sizeof(psl->sl_addr[0]);
|
|
|
|
msf->imsf_numsrc = count;
|
|
|
|
if (put_user(IP_MSFILTER_SIZE(copycount), optlen) ||
|
|
|
|
copy_to_user(optval, msf, IP_MSFILTER_SIZE(0))) {
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
if (len &&
|
|
|
|
copy_to_user(&optval->imsf_slist[0], psl->sl_addr, len))
|
|
|
|
return -EFAULT;
|
|
|
|
return 0;
|
|
|
|
done:
|
2006-03-20 23:23:58 -07:00
|
|
|
rtnl_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
int ip_mc_gsfget(struct sock *sk, struct group_filter *gsf,
|
|
|
|
struct group_filter __user *optval, int __user *optlen)
|
|
|
|
{
|
|
|
|
int err, i, count, copycount;
|
|
|
|
struct sockaddr_in *psin;
|
2006-09-27 19:31:32 -06:00
|
|
|
__be32 addr;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct ip_mc_socklist *pmc;
|
|
|
|
struct inet_sock *inet = inet_sk(sk);
|
|
|
|
struct ip_sf_socklist *psl;
|
|
|
|
|
|
|
|
psin = (struct sockaddr_in *)&gsf->gf_group;
|
|
|
|
if (psin->sin_family != AF_INET)
|
|
|
|
return -EINVAL;
|
|
|
|
addr = psin->sin_addr.s_addr;
|
2007-12-16 14:45:43 -07:00
|
|
|
if (!ipv4_is_multicast(addr))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
2006-03-20 23:23:58 -07:00
|
|
|
rtnl_lock();
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
err = -EADDRNOTAVAIL;
|
|
|
|
|
2010-11-11 22:46:50 -07:00
|
|
|
for_each_pmc_rtnl(inet, pmc) {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (pmc->multi.imr_multiaddr.s_addr == addr &&
|
|
|
|
pmc->multi.imr_ifindex == gsf->gf_interface)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!pmc) /* must have a prior join */
|
|
|
|
goto done;
|
|
|
|
gsf->gf_fmode = pmc->sfmode;
|
2010-11-11 22:46:50 -07:00
|
|
|
psl = rtnl_dereference(pmc->sflist);
|
2006-03-20 23:23:58 -07:00
|
|
|
rtnl_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
count = psl ? psl->sl_count : 0;
|
|
|
|
copycount = count < gsf->gf_numsrc ? count : gsf->gf_numsrc;
|
|
|
|
gsf->gf_numsrc = count;
|
|
|
|
if (put_user(GROUP_FILTER_SIZE(copycount), optlen) ||
|
|
|
|
copy_to_user(optval, gsf, GROUP_FILTER_SIZE(0))) {
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
for (i=0; i<copycount; i++) {
|
|
|
|
struct sockaddr_storage ss;
|
|
|
|
|
|
|
|
psin = (struct sockaddr_in *)&ss;
|
|
|
|
memset(&ss, 0, sizeof(ss));
|
|
|
|
psin->sin_family = AF_INET;
|
|
|
|
psin->sin_addr.s_addr = psl->sl_addr[i];
|
|
|
|
if (copy_to_user(&optval->gf_slist[i], &ss, sizeof(ss)))
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
done:
|
2006-03-20 23:23:58 -07:00
|
|
|
rtnl_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* check if a multicast source filter allows delivery for a given <src,dst,intf>
|
|
|
|
*/
|
2006-09-27 19:31:10 -06:00
|
|
|
int ip_mc_sf_allow(struct sock *sk, __be32 loc_addr, __be32 rmt_addr, int dif)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct inet_sock *inet = inet_sk(sk);
|
|
|
|
struct ip_mc_socklist *pmc;
|
|
|
|
struct ip_sf_socklist *psl;
|
|
|
|
int i;
|
2010-02-02 08:32:29 -07:00
|
|
|
int ret;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-02-02 08:32:29 -07:00
|
|
|
ret = 1;
|
2007-12-16 14:45:43 -07:00
|
|
|
if (!ipv4_is_multicast(loc_addr))
|
2010-02-02 08:32:29 -07:00
|
|
|
goto out;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-02-02 08:32:29 -07:00
|
|
|
rcu_read_lock();
|
2010-11-11 22:46:50 -07:00
|
|
|
for_each_pmc_rcu(inet, pmc) {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (pmc->multi.imr_multiaddr.s_addr == loc_addr &&
|
|
|
|
pmc->multi.imr_ifindex == dif)
|
|
|
|
break;
|
|
|
|
}
|
2010-02-02 08:32:29 -07:00
|
|
|
ret = inet->mc_all;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!pmc)
|
2010-02-02 08:32:29 -07:00
|
|
|
goto unlock;
|
2010-11-11 22:46:50 -07:00
|
|
|
psl = rcu_dereference(pmc->sflist);
|
2010-02-02 08:32:29 -07:00
|
|
|
ret = (pmc->sfmode == MCAST_EXCLUDE);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!psl)
|
2010-02-02 08:32:29 -07:00
|
|
|
goto unlock;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
for (i=0; i<psl->sl_count; i++) {
|
|
|
|
if (psl->sl_addr[i] == rmt_addr)
|
|
|
|
break;
|
|
|
|
}
|
2010-02-02 08:32:29 -07:00
|
|
|
ret = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (pmc->sfmode == MCAST_INCLUDE && i >= psl->sl_count)
|
2010-02-02 08:32:29 -07:00
|
|
|
goto unlock;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (pmc->sfmode == MCAST_EXCLUDE && i < psl->sl_count)
|
2010-02-02 08:32:29 -07:00
|
|
|
goto unlock;
|
|
|
|
ret = 1;
|
|
|
|
unlock:
|
|
|
|
rcu_read_unlock();
|
|
|
|
out:
|
|
|
|
return ret;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* A socket is closing.
|
|
|
|
*/
|
|
|
|
|
|
|
|
void ip_mc_drop_socket(struct sock *sk)
|
|
|
|
{
|
|
|
|
struct inet_sock *inet = inet_sk(sk);
|
|
|
|
struct ip_mc_socklist *iml;
|
2008-08-13 17:15:57 -06:00
|
|
|
struct net *net = sock_net(sk);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (inet->mc_list == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
rtnl_lock();
|
2010-11-11 22:46:50 -07:00
|
|
|
while ((iml = rtnl_dereference(inet->mc_list)) != NULL) {
|
2005-04-16 16:20:36 -06:00
|
|
|
struct in_device *in_dev;
|
|
|
|
|
2010-11-11 22:46:50 -07:00
|
|
|
inet->mc_list = iml->next_rcu;
|
2008-08-13 17:15:57 -06:00
|
|
|
in_dev = inetdev_by_index(net, iml->multi.imr_ifindex);
|
2006-08-15 01:20:17 -06:00
|
|
|
(void) ip_mc_leave_src(sk, iml, in_dev);
|
2010-11-08 04:15:54 -07:00
|
|
|
if (in_dev != NULL)
|
2005-04-16 16:20:36 -06:00
|
|
|
ip_mc_dec_group(in_dev, iml->multi.imr_multiaddr.s_addr);
|
2010-02-02 08:32:29 -07:00
|
|
|
/* decrease mem now to avoid the memleak warning */
|
|
|
|
atomic_sub(sizeof(*iml), &sk->sk_omem_alloc);
|
2011-03-17 21:45:08 -06:00
|
|
|
kfree_rcu(iml, rcu);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
rtnl_unlock();
|
|
|
|
}
|
|
|
|
|
2011-03-10 17:34:38 -07:00
|
|
|
/* called with rcu_read_lock() */
|
|
|
|
int ip_check_mc_rcu(struct in_device *in_dev, __be32 mc_addr, __be32 src_addr, u16 proto)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct ip_mc_list *im;
|
|
|
|
struct ip_sf_list *psf;
|
|
|
|
int rv = 0;
|
|
|
|
|
2010-11-11 22:46:50 -07:00
|
|
|
for_each_pmc_rcu(in_dev, im) {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (im->multiaddr == mc_addr)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (im && proto == IPPROTO_IGMP) {
|
|
|
|
rv = 1;
|
|
|
|
} else if (im) {
|
|
|
|
if (src_addr) {
|
|
|
|
for (psf=im->sources; psf; psf=psf->sf_next) {
|
|
|
|
if (psf->sf_inaddr == src_addr)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (psf)
|
|
|
|
rv = psf->sf_count[MCAST_INCLUDE] ||
|
|
|
|
psf->sf_count[MCAST_EXCLUDE] !=
|
|
|
|
im->sfcount[MCAST_EXCLUDE];
|
|
|
|
else
|
|
|
|
rv = im->sfcount[MCAST_EXCLUDE] != 0;
|
|
|
|
} else
|
|
|
|
rv = 1; /* unspecified source; tentatively allow */
|
|
|
|
}
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if defined(CONFIG_PROC_FS)
|
|
|
|
struct igmp_mc_iter_state {
|
2008-12-25 17:42:51 -07:00
|
|
|
struct seq_net_private p;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct net_device *dev;
|
|
|
|
struct in_device *in_dev;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define igmp_mc_seq_private(seq) ((struct igmp_mc_iter_state *)(seq)->private)
|
|
|
|
|
|
|
|
static inline struct ip_mc_list *igmp_mc_get_first(struct seq_file *seq)
|
|
|
|
{
|
2008-12-25 17:42:51 -07:00
|
|
|
struct net *net = seq_file_net(seq);
|
2005-04-16 16:20:36 -06:00
|
|
|
struct ip_mc_list *im = NULL;
|
|
|
|
struct igmp_mc_iter_state *state = igmp_mc_seq_private(seq);
|
|
|
|
|
2007-05-03 16:13:45 -06:00
|
|
|
state->in_dev = NULL;
|
2009-11-10 00:54:55 -07:00
|
|
|
for_each_netdev_rcu(net, state->dev) {
|
2005-04-16 16:20:36 -06:00
|
|
|
struct in_device *in_dev;
|
2009-11-11 10:48:52 -07:00
|
|
|
|
|
|
|
in_dev = __in_dev_get_rcu(state->dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!in_dev)
|
|
|
|
continue;
|
2010-11-11 22:46:50 -07:00
|
|
|
im = rcu_dereference(in_dev->mc_list);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (im) {
|
|
|
|
state->in_dev = in_dev;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return im;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct ip_mc_list *igmp_mc_get_next(struct seq_file *seq, struct ip_mc_list *im)
|
|
|
|
{
|
|
|
|
struct igmp_mc_iter_state *state = igmp_mc_seq_private(seq);
|
2009-11-11 10:48:52 -07:00
|
|
|
|
2010-11-11 22:46:50 -07:00
|
|
|
im = rcu_dereference(im->next_rcu);
|
|
|
|
while (!im) {
|
2009-11-11 10:48:52 -07:00
|
|
|
state->dev = next_net_device_rcu(state->dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!state->dev) {
|
|
|
|
state->in_dev = NULL;
|
|
|
|
break;
|
|
|
|
}
|
2009-11-11 10:48:52 -07:00
|
|
|
state->in_dev = __in_dev_get_rcu(state->dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!state->in_dev)
|
|
|
|
continue;
|
2010-11-11 22:46:50 -07:00
|
|
|
im = rcu_dereference(state->in_dev->mc_list);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
return im;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct ip_mc_list *igmp_mc_get_idx(struct seq_file *seq, loff_t pos)
|
|
|
|
{
|
|
|
|
struct ip_mc_list *im = igmp_mc_get_first(seq);
|
|
|
|
if (im)
|
|
|
|
while (pos && (im = igmp_mc_get_next(seq, im)) != NULL)
|
|
|
|
--pos;
|
|
|
|
return pos ? NULL : im;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *igmp_mc_seq_start(struct seq_file *seq, loff_t *pos)
|
2009-11-10 00:54:55 -07:00
|
|
|
__acquires(rcu)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2009-11-10 00:54:55 -07:00
|
|
|
rcu_read_lock();
|
2005-04-16 16:20:36 -06:00
|
|
|
return *pos ? igmp_mc_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *igmp_mc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
|
|
|
|
{
|
|
|
|
struct ip_mc_list *im;
|
|
|
|
if (v == SEQ_START_TOKEN)
|
|
|
|
im = igmp_mc_get_first(seq);
|
|
|
|
else
|
|
|
|
im = igmp_mc_get_next(seq, v);
|
|
|
|
++*pos;
|
|
|
|
return im;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void igmp_mc_seq_stop(struct seq_file *seq, void *v)
|
2009-11-10 00:54:55 -07:00
|
|
|
__releases(rcu)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct igmp_mc_iter_state *state = igmp_mc_seq_private(seq);
|
2010-11-11 22:46:50 -07:00
|
|
|
|
|
|
|
state->in_dev = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
state->dev = NULL;
|
2009-11-10 00:54:55 -07:00
|
|
|
rcu_read_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int igmp_mc_seq_show(struct seq_file *seq, void *v)
|
|
|
|
{
|
|
|
|
if (v == SEQ_START_TOKEN)
|
2007-02-09 07:24:47 -07:00
|
|
|
seq_puts(seq,
|
2005-04-16 16:20:36 -06:00
|
|
|
"Idx\tDevice : Count Querier\tGroup Users Timer\tReporter\n");
|
|
|
|
else {
|
|
|
|
struct ip_mc_list *im = (struct ip_mc_list *)v;
|
|
|
|
struct igmp_mc_iter_state *state = igmp_mc_seq_private(seq);
|
|
|
|
char *querier;
|
|
|
|
#ifdef CONFIG_IP_MULTICAST
|
|
|
|
querier = IGMP_V1_SEEN(state->in_dev) ? "V1" :
|
|
|
|
IGMP_V2_SEEN(state->in_dev) ? "V2" :
|
|
|
|
"V3";
|
|
|
|
#else
|
|
|
|
querier = "NONE";
|
|
|
|
#endif
|
|
|
|
|
2010-11-11 22:46:50 -07:00
|
|
|
if (rcu_dereference(state->in_dev->mc_list) == im) {
|
2005-04-16 16:20:36 -06:00
|
|
|
seq_printf(seq, "%d\t%-10s: %5d %7s\n",
|
2008-10-07 16:34:37 -06:00
|
|
|
state->dev->ifindex, state->dev->name, state->in_dev->mc_count, querier);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
seq_printf(seq,
|
2006-06-05 22:04:39 -06:00
|
|
|
"\t\t\t\t%08X %5d %d:%08lX\t\t%d\n",
|
2005-04-16 16:20:36 -06:00
|
|
|
im->multiaddr, im->users,
|
|
|
|
im->tm_running, im->tm_running ?
|
|
|
|
jiffies_to_clock_t(im->timer.expires-jiffies) : 0,
|
|
|
|
im->reporter);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-03-12 15:34:29 -06:00
|
|
|
static const struct seq_operations igmp_mc_seq_ops = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.start = igmp_mc_seq_start,
|
|
|
|
.next = igmp_mc_seq_next,
|
|
|
|
.stop = igmp_mc_seq_stop,
|
|
|
|
.show = igmp_mc_seq_show,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int igmp_mc_seq_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
2008-12-25 17:42:51 -07:00
|
|
|
return seq_open_net(inode, file, &igmp_mc_seq_ops,
|
2007-10-10 03:29:29 -06:00
|
|
|
sizeof(struct igmp_mc_iter_state));
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-02-12 01:55:35 -07:00
|
|
|
static const struct file_operations igmp_mc_seq_fops = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = igmp_mc_seq_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
2008-12-25 17:42:51 -07:00
|
|
|
.release = seq_release_net,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
struct igmp_mcf_iter_state {
|
2008-12-25 17:42:51 -07:00
|
|
|
struct seq_net_private p;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct net_device *dev;
|
|
|
|
struct in_device *idev;
|
|
|
|
struct ip_mc_list *im;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define igmp_mcf_seq_private(seq) ((struct igmp_mcf_iter_state *)(seq)->private)
|
|
|
|
|
|
|
|
static inline struct ip_sf_list *igmp_mcf_get_first(struct seq_file *seq)
|
|
|
|
{
|
2008-12-25 17:42:51 -07:00
|
|
|
struct net *net = seq_file_net(seq);
|
2005-04-16 16:20:36 -06:00
|
|
|
struct ip_sf_list *psf = NULL;
|
|
|
|
struct ip_mc_list *im = NULL;
|
|
|
|
struct igmp_mcf_iter_state *state = igmp_mcf_seq_private(seq);
|
|
|
|
|
2007-05-03 16:13:45 -06:00
|
|
|
state->idev = NULL;
|
|
|
|
state->im = NULL;
|
2009-11-10 00:54:55 -07:00
|
|
|
for_each_netdev_rcu(net, state->dev) {
|
2005-04-16 16:20:36 -06:00
|
|
|
struct in_device *idev;
|
2009-11-11 10:48:52 -07:00
|
|
|
idev = __in_dev_get_rcu(state->dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (unlikely(idev == NULL))
|
|
|
|
continue;
|
2010-11-11 22:46:50 -07:00
|
|
|
im = rcu_dereference(idev->mc_list);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (likely(im != NULL)) {
|
|
|
|
spin_lock_bh(&im->lock);
|
|
|
|
psf = im->sources;
|
|
|
|
if (likely(psf != NULL)) {
|
|
|
|
state->im = im;
|
|
|
|
state->idev = idev;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
spin_unlock_bh(&im->lock);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return psf;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct ip_sf_list *igmp_mcf_get_next(struct seq_file *seq, struct ip_sf_list *psf)
|
|
|
|
{
|
|
|
|
struct igmp_mcf_iter_state *state = igmp_mcf_seq_private(seq);
|
|
|
|
|
|
|
|
psf = psf->sf_next;
|
|
|
|
while (!psf) {
|
|
|
|
spin_unlock_bh(&state->im->lock);
|
|
|
|
state->im = state->im->next;
|
|
|
|
while (!state->im) {
|
2009-11-11 10:48:52 -07:00
|
|
|
state->dev = next_net_device_rcu(state->dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!state->dev) {
|
|
|
|
state->idev = NULL;
|
|
|
|
goto out;
|
|
|
|
}
|
2009-11-11 10:48:52 -07:00
|
|
|
state->idev = __in_dev_get_rcu(state->dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!state->idev)
|
|
|
|
continue;
|
2010-11-11 22:46:50 -07:00
|
|
|
state->im = rcu_dereference(state->idev->mc_list);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
if (!state->im)
|
|
|
|
break;
|
|
|
|
spin_lock_bh(&state->im->lock);
|
|
|
|
psf = state->im->sources;
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
return psf;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct ip_sf_list *igmp_mcf_get_idx(struct seq_file *seq, loff_t pos)
|
|
|
|
{
|
|
|
|
struct ip_sf_list *psf = igmp_mcf_get_first(seq);
|
|
|
|
if (psf)
|
|
|
|
while (pos && (psf = igmp_mcf_get_next(seq, psf)) != NULL)
|
|
|
|
--pos;
|
|
|
|
return pos ? NULL : psf;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *igmp_mcf_seq_start(struct seq_file *seq, loff_t *pos)
|
2009-11-10 00:54:55 -07:00
|
|
|
__acquires(rcu)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2009-11-10 00:54:55 -07:00
|
|
|
rcu_read_lock();
|
2005-04-16 16:20:36 -06:00
|
|
|
return *pos ? igmp_mcf_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *igmp_mcf_seq_next(struct seq_file *seq, void *v, loff_t *pos)
|
|
|
|
{
|
|
|
|
struct ip_sf_list *psf;
|
|
|
|
if (v == SEQ_START_TOKEN)
|
|
|
|
psf = igmp_mcf_get_first(seq);
|
|
|
|
else
|
|
|
|
psf = igmp_mcf_get_next(seq, v);
|
|
|
|
++*pos;
|
|
|
|
return psf;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void igmp_mcf_seq_stop(struct seq_file *seq, void *v)
|
2009-11-10 00:54:55 -07:00
|
|
|
__releases(rcu)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct igmp_mcf_iter_state *state = igmp_mcf_seq_private(seq);
|
|
|
|
if (likely(state->im != NULL)) {
|
|
|
|
spin_unlock_bh(&state->im->lock);
|
|
|
|
state->im = NULL;
|
|
|
|
}
|
2010-11-11 22:46:50 -07:00
|
|
|
state->idev = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
state->dev = NULL;
|
2009-11-10 00:54:55 -07:00
|
|
|
rcu_read_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int igmp_mcf_seq_show(struct seq_file *seq, void *v)
|
|
|
|
{
|
|
|
|
struct ip_sf_list *psf = (struct ip_sf_list *)v;
|
|
|
|
struct igmp_mcf_iter_state *state = igmp_mcf_seq_private(seq);
|
|
|
|
|
|
|
|
if (v == SEQ_START_TOKEN) {
|
2007-02-09 07:24:47 -07:00
|
|
|
seq_printf(seq,
|
2005-04-16 16:20:36 -06:00
|
|
|
"%3s %6s "
|
|
|
|
"%10s %10s %6s %6s\n", "Idx",
|
|
|
|
"Device", "MCA",
|
|
|
|
"SRC", "INC", "EXC");
|
|
|
|
} else {
|
|
|
|
seq_printf(seq,
|
|
|
|
"%3d %6.6s 0x%08x "
|
2007-02-09 07:24:47 -07:00
|
|
|
"0x%08x %6lu %6lu\n",
|
|
|
|
state->dev->ifindex, state->dev->name,
|
2005-04-16 16:20:36 -06:00
|
|
|
ntohl(state->im->multiaddr),
|
|
|
|
ntohl(psf->sf_inaddr),
|
|
|
|
psf->sf_count[MCAST_INCLUDE],
|
|
|
|
psf->sf_count[MCAST_EXCLUDE]);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-03-12 15:34:29 -06:00
|
|
|
static const struct seq_operations igmp_mcf_seq_ops = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.start = igmp_mcf_seq_start,
|
|
|
|
.next = igmp_mcf_seq_next,
|
|
|
|
.stop = igmp_mcf_seq_stop,
|
|
|
|
.show = igmp_mcf_seq_show,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int igmp_mcf_seq_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
2008-12-25 17:42:51 -07:00
|
|
|
return seq_open_net(inode, file, &igmp_mcf_seq_ops,
|
2007-10-10 03:29:29 -06:00
|
|
|
sizeof(struct igmp_mcf_iter_state));
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-02-12 01:55:35 -07:00
|
|
|
static const struct file_operations igmp_mcf_seq_fops = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = igmp_mcf_seq_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
2008-12-25 17:42:51 -07:00
|
|
|
.release = seq_release_net,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2010-01-16 20:35:32 -07:00
|
|
|
static int __net_init igmp_net_init(struct net *net)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-12-25 17:42:51 -07:00
|
|
|
struct proc_dir_entry *pde;
|
|
|
|
|
|
|
|
pde = proc_net_fops_create(net, "igmp", S_IRUGO, &igmp_mc_seq_fops);
|
|
|
|
if (!pde)
|
|
|
|
goto out_igmp;
|
|
|
|
pde = proc_net_fops_create(net, "mcfilter", S_IRUGO, &igmp_mcf_seq_fops);
|
|
|
|
if (!pde)
|
|
|
|
goto out_mcfilter;
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
2008-12-25 17:42:51 -07:00
|
|
|
|
|
|
|
out_mcfilter:
|
|
|
|
proc_net_remove(net, "igmp");
|
|
|
|
out_igmp:
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2010-01-16 20:35:32 -07:00
|
|
|
static void __net_exit igmp_net_exit(struct net *net)
|
2008-12-25 17:42:51 -07:00
|
|
|
{
|
|
|
|
proc_net_remove(net, "mcfilter");
|
|
|
|
proc_net_remove(net, "igmp");
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct pernet_operations igmp_net_ops = {
|
|
|
|
.init = igmp_net_init,
|
|
|
|
.exit = igmp_net_exit,
|
|
|
|
};
|
|
|
|
|
|
|
|
int __init igmp_mc_proc_init(void)
|
|
|
|
{
|
|
|
|
return register_pernet_subsys(&igmp_net_ops);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
#endif
|