igmp.c 62.4 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11
/*
 *	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:
12
 *		Alan Cox <alan@lxorguk.ukuu.org.uk>
L
Linus Torvalds 已提交
13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
 *
 *	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
36
 *					The enhancements are mainly based on Steve Deering's
L
Linus Torvalds 已提交
37 38 39 40 41 42 43 44 45 46 47 48 49
 * 					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
50 51
 *					memberships but was being deleted,
 *					which caused a "del_timer() called
L
Linus Torvalds 已提交
52 53
 *					from %p with timer not initialized\n"
 *					message (960131).
54
 *		Christian Daudt :	removed del_timer from
L
Linus Torvalds 已提交
55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
 *					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>
74
#include <linux/slab.h>
L
Linus Torvalds 已提交
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91
#include <asm/uaccess.h>
#include <asm/system.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>
92

93
#include <net/net_namespace.h>
94
#include <net/arp.h>
L
Linus Torvalds 已提交
95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130
#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.
 */

131
#define IGMP_V1_SEEN(in_dev) \
132
	(IPV4_DEVCONF_ALL(dev_net(in_dev->dev), FORCE_IGMP_VERSION) == 1 || \
133 134 135 136
	 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) \
137
	(IPV4_DEVCONF_ALL(dev_net(in_dev->dev), FORCE_IGMP_VERSION) == 2 || \
138 139 140
	 IN_DEV_CONF_GET((in_dev), FORCE_IGMP_VERSION) == 2 || \
	 ((in_dev)->mr_v2_seen && \
	  time_before(jiffies, (in_dev)->mr_v2_seen)))
L
Linus Torvalds 已提交
141 142

static void igmpv3_add_delrec(struct in_device *in_dev, struct ip_mc_list *im);
A
Al Viro 已提交
143
static void igmpv3_del_delrec(struct in_device *in_dev, __be32 multiaddr);
L
Linus Torvalds 已提交
144 145 146 147 148
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);
149 150
static int ip_mc_add_src(struct in_device *in_dev, __be32 *pmca, int sfmode,
			 int sfcount, __be32 *psfsrc, int delta);
L
Linus Torvalds 已提交
151 152 153 154 155

static void ip_ma_put(struct ip_mc_list *im)
{
	if (atomic_dec_and_test(&im->refcnt)) {
		in_dev_put(im->interface);
156
		kfree_rcu(im, rcu);
L
Linus Torvalds 已提交
157 158 159
	}
}

160 161 162 163 164 165 166 167 168 169
#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))

L
Linus Torvalds 已提交
170 171 172 173 174 175
#ifdef CONFIG_IP_MULTICAST

/*
 *	Timer management
 */

176
static void igmp_stop_timer(struct ip_mc_list *im)
L
Linus Torvalds 已提交
177 178 179 180
{
	spin_lock_bh(&im->lock);
	if (del_timer(&im->timer))
		atomic_dec(&im->refcnt);
J
Jianjun Kong 已提交
181
	im->tm_running = 0;
L
Linus Torvalds 已提交
182 183 184 185 186 187 188 189
	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)
{
J
Jianjun Kong 已提交
190
	int tv = net_random() % max_delay;
L
Linus Torvalds 已提交
191

J
Jianjun Kong 已提交
192
	im->tm_running = 1;
L
Linus Torvalds 已提交
193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220
	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);
J
Jianjun Kong 已提交
221
			im->tm_running = 1;
L
Linus Torvalds 已提交
222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246
			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;
247 248 249 250 251 252 253 254 255 256 257 258
		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;
L
Linus Torvalds 已提交
259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296
	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;
}

E
Eric Dumazet 已提交
297 298
#define igmp_skb_size(skb) (*(unsigned int *)((skb)->cb))

L
Linus Torvalds 已提交
299 300 301 302 303 304
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;
305
	struct net *net = dev_net(dev);
306
	struct flowi4 fl4;
L
Linus Torvalds 已提交
307

E
Eric Dumazet 已提交
308 309 310 311 312 313 314 315 316 317
	while (1) {
		skb = alloc_skb(size + LL_ALLOCATED_SPACE(dev),
				GFP_ATOMIC | __GFP_NOWARN);
		if (skb)
			break;
		size >>= 1;
		if (size < 256)
			return NULL;
	}
	igmp_skb_size(skb) = size;
L
Linus Torvalds 已提交
318

319
	rt = ip_route_output_ports(net, &fl4, NULL, IGMPV3_ALL_MCR, 0,
320 321 322 323 324
				   0, 0,
				   IPPROTO_IGMP, 0, dev->ifindex);
	if (IS_ERR(rt)) {
		kfree_skb(skb);
		return NULL;
L
Linus Torvalds 已提交
325 326
	}

327
	skb_dst_set(skb, &rt->dst);
L
Linus Torvalds 已提交
328 329 330 331
	skb->dev = dev;

	skb_reserve(skb, LL_RESERVED_SPACE(dev));

332
	skb_reset_network_header(skb);
333
	pip = ip_hdr(skb);
334
	skb_put(skb, sizeof(struct iphdr) + 4);
L
Linus Torvalds 已提交
335 336 337 338 339 340

	pip->version  = 4;
	pip->ihl      = (sizeof(struct iphdr)+4)>>2;
	pip->tos      = 0xc0;
	pip->frag_off = htons(IP_DF);
	pip->ttl      = 1;
341 342
	pip->daddr    = fl4.daddr;
	pip->saddr    = fl4.saddr;
L
Linus Torvalds 已提交
343 344
	pip->protocol = IPPROTO_IGMP;
	pip->tot_len  = 0;	/* filled in later */
345
	ip_select_ident(pip, &rt->dst, NULL);
L
Linus Torvalds 已提交
346 347 348 349 350
	((u8*)&pip[1])[0] = IPOPT_RA;
	((u8*)&pip[1])[1] = 4;
	((u8*)&pip[1])[2] = 0;
	((u8*)&pip[1])[3] = 0;

351
	skb->transport_header = skb->network_header + sizeof(struct iphdr) + 4;
352
	skb_put(skb, sizeof(*pig));
353
	pig = igmpv3_report_hdr(skb);
L
Linus Torvalds 已提交
354 355 356 357 358 359 360 361 362 363
	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)
{
364
	struct igmphdr *pig = igmp_hdr(skb);
365
	const int igmplen = skb->tail - skb->transport_header;
L
Linus Torvalds 已提交
366

367
	pig->csum = ip_compute_csum(igmp_hdr(skb), igmplen);
L
Linus Torvalds 已提交
368

H
Herbert Xu 已提交
369
	return ip_local_out(skb);
L
Linus Torvalds 已提交
370 371 372 373
}

static int grec_size(struct ip_mc_list *pmc, int type, int gdel, int sdel)
{
J
Jianjun Kong 已提交
374
	return sizeof(struct igmpv3_grec) + 4*igmp_scount(pmc, type, gdel, sdel);
L
Linus Torvalds 已提交
375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392
}

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;
393
	pih = igmpv3_report_hdr(skb);
L
Linus Torvalds 已提交
394 395 396 397 398
	pih->ngrec = htons(ntohs(pih->ngrec)+1);
	*ppgr = pgr;
	return skb;
}

E
Eric Dumazet 已提交
399
#define AVAILABLE(skb) ((skb) ? ((skb)->dev ? igmp_skb_size(skb) - (skb)->len : \
L
Linus Torvalds 已提交
400 401 402 403 404 405 406 407 408
	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;
409
	int scount, stotal, first, isquery, truncate;
L
Linus Torvalds 已提交
410 411 412 413 414 415 416 417 418

	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;

419 420
	stotal = scount = 0;

L
Linus Torvalds 已提交
421 422
	psf_list = sdeleted ? &pmc->tomb : &pmc->sources;

423 424 425
	if (!*psf_list)
		goto empty_source;

426
	pih = skb ? igmpv3_report_hdr(skb) : NULL;
L
Linus Torvalds 已提交
427 428 429 430 431 432 433 434 435 436 437 438 439

	/* 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) {
440
		__be32 *psrc;
L
Linus Torvalds 已提交
441 442 443 444 445 446 447 448 449 450 451 452

		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;

A
Al Viro 已提交
453
		if (AVAILABLE(skb) < sizeof(__be32) +
L
Linus Torvalds 已提交
454 455 456 457 458 459 460 461 462 463 464 465 466 467 468
		    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;
		}
469 470
		if (!skb)
			return NULL;
A
Al Viro 已提交
471
		psrc = (__be32 *)skb_put(skb, sizeof(__be32));
L
Linus Torvalds 已提交
472
		*psrc = psf->sf_inaddr;
473
		scount++; stotal++;
L
Linus Torvalds 已提交
474 475 476 477 478 479 480 481 482 483 484 485 486 487
		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;
	}
488 489 490 491 492 493 494 495 496 497 498 499 500 501 502

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);
		}
	}
L
Linus Torvalds 已提交
503 504 505 506 507 508 509 510 511 512 513 514 515 516
	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) {
517 518
		rcu_read_lock();
		for_each_pmc_rcu(in_dev, pmc) {
L
Linus Torvalds 已提交
519 520 521 522 523 524 525 526 527 528
			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);
		}
529
		rcu_read_unlock();
L
Linus Torvalds 已提交
530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570
	} 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;

571
	rcu_read_lock();
L
Linus Torvalds 已提交
572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588
	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);
			}
589
			pmc->crcount--;
L
Linus Torvalds 已提交
590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607
			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 */
608
	for_each_pmc_rcu(in_dev, pmc) {
L
Linus Torvalds 已提交
609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626
		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);
627
			pmc->crcount--;
L
Linus Torvalds 已提交
628 629 630
		}
		spin_unlock_bh(&pmc->lock);
	}
631
	rcu_read_unlock();
L
Linus Torvalds 已提交
632 633 634 635 636 637 638 639 640 641 642 643 644 645

	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;
646
	struct net *net = dev_net(dev);
A
Al Viro 已提交
647
	__be32	group = pmc ? pmc->multiaddr : 0;
648
	struct flowi4 fl4;
A
Al Viro 已提交
649
	__be32	dst;
L
Linus Torvalds 已提交
650 651 652 653 654 655 656 657

	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;

658
	rt = ip_route_output_ports(net, &fl4, NULL, dst, 0,
659 660 661 662 663
				   0, 0,
				   IPPROTO_IGMP, 0, dev->ifindex);
	if (IS_ERR(rt))
		return -1;

J
Jianjun Kong 已提交
664
	skb = alloc_skb(IGMP_SIZE+LL_ALLOCATED_SPACE(dev), GFP_ATOMIC);
L
Linus Torvalds 已提交
665 666 667 668 669
	if (skb == NULL) {
		ip_rt_put(rt);
		return -1;
	}

670
	skb_dst_set(skb, &rt->dst);
L
Linus Torvalds 已提交
671 672 673

	skb_reserve(skb, LL_RESERVED_SPACE(dev));

674
	skb_reset_network_header(skb);
675
	iph = ip_hdr(skb);
676
	skb_put(skb, sizeof(struct iphdr) + 4);
L
Linus Torvalds 已提交
677 678 679 680 681 682 683

	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;
684
	iph->saddr    = fl4.saddr;
L
Linus Torvalds 已提交
685
	iph->protocol = IPPROTO_IGMP;
686
	ip_select_ident(iph, &rt->dst, NULL);
L
Linus Torvalds 已提交
687 688 689 690 691 692
	((u8*)&iph[1])[0] = IPOPT_RA;
	((u8*)&iph[1])[1] = 4;
	((u8*)&iph[1])[2] = 0;
	((u8*)&iph[1])[3] = 0;

	ih = (struct igmphdr *)skb_put(skb, sizeof(struct igmphdr));
J
Jianjun Kong 已提交
693 694 695 696 697
	ih->type = type;
	ih->code = 0;
	ih->csum = 0;
	ih->group = group;
	ih->csum = ip_compute_csum((void *)ih, sizeof(struct igmphdr));
L
Linus Torvalds 已提交
698

H
Herbert Xu 已提交
699
	return ip_local_out(skb);
L
Linus Torvalds 已提交
700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726
}

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;
727
	in_dev->mr_ifc_count = in_dev->mr_qrv ? in_dev->mr_qrv :
L
Linus Torvalds 已提交
728 729 730 731 732 733 734 735 736 737 738
		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);
J
Jianjun Kong 已提交
739
	im->tm_running = 0;
L
Linus Torvalds 已提交
740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757

	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);
}

758
/* mark EXCLUDE-mode sources */
759
static int igmp_xmarksources(struct ip_mc_list *pmc, int nsrcs, __be32 *srcs)
L
Linus Torvalds 已提交
760 761 762 763
{
	struct ip_sf_list *psf;
	int i, scount;

764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785
	scount = 0;
	for (psf=pmc->sources; psf; psf=psf->sf_next) {
		if (scount == nsrcs)
			break;
		for (i=0; i<nsrcs; i++) {
			/* skip inactive filters */
			if (pmc->sfcount[MCAST_INCLUDE] ||
			    pmc->sfcount[MCAST_EXCLUDE] !=
			    psf->sf_count[MCAST_EXCLUDE])
				continue;
			if (srcs[i] == psf->sf_inaddr) {
				scount++;
				break;
			}
		}
	}
	pmc->gsquery = 0;
	if (scount == nsrcs)	/* all sources excluded */
		return 0;
	return 1;
}

786
static int igmp_marksources(struct ip_mc_list *pmc, int nsrcs, __be32 *srcs)
787 788 789 790 791 792 793 794
{
	struct ip_sf_list *psf;
	int i, scount;

	if (pmc->sfmode == MCAST_EXCLUDE)
		return igmp_xmarksources(pmc, nsrcs, srcs);

	/* mark INCLUDE-mode sources */
L
Linus Torvalds 已提交
795 796 797 798 799 800 801 802 803 804 805
	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;
			}
	}
806 807 808 809 810 811
	if (!scount) {
		pmc->gsquery = 0;
		return 0;
	}
	pmc->gsquery = 1;
	return 1;
L
Linus Torvalds 已提交
812 813
}

A
Al Viro 已提交
814
static void igmp_heard_report(struct in_device *in_dev, __be32 group)
L
Linus Torvalds 已提交
815 816 817 818 819 820 821 822
{
	struct ip_mc_list *im;

	/* Timers are only set for non-local groups */

	if (group == IGMP_ALL_HOSTS)
		return;

823 824
	rcu_read_lock();
	for_each_pmc_rcu(in_dev, im) {
L
Linus Torvalds 已提交
825 826 827 828 829
		if (im->multiaddr == group) {
			igmp_stop_timer(im);
			break;
		}
	}
830
	rcu_read_unlock();
L
Linus Torvalds 已提交
831 832 833 834 835
}

static void igmp_heard_query(struct in_device *in_dev, struct sk_buff *skb,
	int len)
{
836 837
	struct igmphdr 		*ih = igmp_hdr(skb);
	struct igmpv3_query *ih3 = igmpv3_query_hdr(skb);
L
Linus Torvalds 已提交
838
	struct ip_mc_list	*im;
A
Al Viro 已提交
839
	__be32			group = ih->group;
L
Linus Torvalds 已提交
840 841 842 843
	int			max_delay;
	int			mark = 0;


844
	if (len == 8) {
L
Linus Torvalds 已提交
845 846
		if (ih->code == 0) {
			/* Alas, old v1 router presents here. */
847

L
Linus Torvalds 已提交
848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865
			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 */
866 867 868 869 870 871 872 873 874 875 876 877
	} 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);
L
Linus Torvalds 已提交
878 879 880
	} else { /* v3 */
		if (!pskb_may_pull(skb, sizeof(struct igmpv3_query)))
			return;
881

882
		ih3 = igmpv3_query_hdr(skb);
L
Linus Torvalds 已提交
883
		if (ih3->nsrcs) {
884
			if (!pskb_may_pull(skb, sizeof(struct igmpv3_query)
A
Al Viro 已提交
885
					   + ntohs(ih3->nsrcs)*sizeof(__be32)))
L
Linus Torvalds 已提交
886
				return;
887
			ih3 = igmpv3_query_hdr(skb);
L
Linus Torvalds 已提交
888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915
		}

		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
	 */
916 917
	rcu_read_lock();
	for_each_pmc_rcu(in_dev, im) {
918 919
		int changed;

L
Linus Torvalds 已提交
920 921 922 923 924 925 926 927 928
		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;
929
		changed = !im->gsquery ||
930
			igmp_marksources(im, ntohs(ih3->nsrcs), ih3->srcs);
L
Linus Torvalds 已提交
931
		spin_unlock_bh(&im->lock);
932 933
		if (changed)
			igmp_mod_timer(im, max_delay);
L
Linus Torvalds 已提交
934
	}
935
	rcu_read_unlock();
L
Linus Torvalds 已提交
936 937
}

938
/* called in rcu_read_lock() section */
L
Linus Torvalds 已提交
939 940 941 942
int igmp_rcv(struct sk_buff *skb)
{
	/* This basically follows the spec line by line -- see RFC1112 */
	struct igmphdr *ih;
943
	struct in_device *in_dev = __in_dev_get_rcu(skb->dev);
L
Linus Torvalds 已提交
944 945
	int len = skb->len;

946 947
	if (in_dev == NULL)
		goto drop;
L
Linus Torvalds 已提交
948

949
	if (!pskb_may_pull(skb, sizeof(struct igmphdr)))
950
		goto drop;
951 952

	switch (skb->ip_summed) {
953
	case CHECKSUM_COMPLETE:
954
		if (!csum_fold(skb->csum))
955 956 957 958 959
			break;
		/* fall through */
	case CHECKSUM_NONE:
		skb->csum = 0;
		if (__skb_checksum_complete(skb))
960
			goto drop;
L
Linus Torvalds 已提交
961 962
	}

963
	ih = igmp_hdr(skb);
L
Linus Torvalds 已提交
964 965 966 967 968 969 970
	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? */
971
		if (rt_is_output_route(skb_rtable(skb)))
L
Linus Torvalds 已提交
972
			break;
973 974 975 976
		/* 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);
L
Linus Torvalds 已提交
977 978 979 980 981
		break;
	case IGMP_PIM:
#ifdef CONFIG_IP_PIMSM_V1
		return pim_rcv_v1(skb);
#endif
982
	case IGMPV3_HOST_MEMBERSHIP_REPORT:
L
Linus Torvalds 已提交
983 984 985 986 987 988 989
	case IGMP_DVMRP:
	case IGMP_TRACE:
	case IGMP_HOST_LEAVE_MESSAGE:
	case IGMP_MTRACE:
	case IGMP_MTRACE_RESP:
		break;
	default:
990
		break;
L
Linus Torvalds 已提交
991
	}
992

993
drop:
L
Linus Torvalds 已提交
994 995 996 997 998 999 1000 1001 1002 1003 1004
	kfree_skb(skb);
	return 0;
}

#endif


/*
 *	Add a filter to a device
 */

A
Al Viro 已提交
1005
static void ip_mc_filter_add(struct in_device *in_dev, __be32 addr)
L
Linus Torvalds 已提交
1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017
{
	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
	   is changed. This check should be done in dev->set_multicast_list
	   routine. Something sort of:
	   if (dev->mc_list && dev->flags&IFF_MULTICAST) { do it; }
	   --ANK
	   */
	if (arp_mc_map(addr, buf, dev, 0) == 0)
1018
		dev_mc_add(dev, buf);
L
Linus Torvalds 已提交
1019 1020 1021 1022 1023 1024
}

/*
 *	Remove a filter from a device
 */

A
Al Viro 已提交
1025
static void ip_mc_filter_del(struct in_device *in_dev, __be32 addr)
L
Linus Torvalds 已提交
1026 1027 1028 1029 1030
{
	char buf[MAX_ADDR_LEN];
	struct net_device *dev = in_dev->dev;

	if (arp_mc_map(addr, buf, dev, 0) == 0)
1031
		dev_mc_del(dev, buf);
L
Linus Torvalds 已提交
1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047
}

#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.
	 */
1048
	pmc = kzalloc(sizeof(*pmc), GFP_KERNEL);
L
Linus Torvalds 已提交
1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074
	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);
}

A
Al Viro 已提交
1075
static void igmpv3_del_delrec(struct in_device *in_dev, __be32 multiaddr)
L
Linus Torvalds 已提交
1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119
{
	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 */
1120 1121
	rcu_read_lock();
	for_each_pmc_rcu(in_dev, pmc) {
L
Linus Torvalds 已提交
1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132
		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);
		}
	}
1133
	rcu_read_unlock();
L
Linus Torvalds 已提交
1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157
}
#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))
1158
			return;
L
Linus Torvalds 已提交
1159 1160 1161
		if (IGMP_V2_SEEN(in_dev)) {
			if (reporter)
				igmp_send_report(in_dev, im, IGMP_HOST_LEAVE_MESSAGE);
1162
			return;
L
Linus Torvalds 已提交
1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210
		}
		/* 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.
 */

1211
void ip_mc_inc_group(struct in_device *in_dev, __be32 addr)
L
Linus Torvalds 已提交
1212 1213 1214 1215 1216
{
	struct ip_mc_list *im;

	ASSERT_RTNL();

1217
	for_each_pmc_rtnl(in_dev, im) {
L
Linus Torvalds 已提交
1218 1219 1220 1221 1222 1223 1224
		if (im->multiaddr == addr) {
			im->users++;
			ip_mc_add_src(in_dev, &addr, MCAST_EXCLUDE, 0, NULL, 0);
			goto out;
		}
	}

1225
	im = kzalloc(sizeof(*im), GFP_KERNEL);
L
Linus Torvalds 已提交
1226 1227 1228
	if (!im)
		goto out;

J
Jianjun Kong 已提交
1229 1230
	im->users = 1;
	im->interface = in_dev;
L
Linus Torvalds 已提交
1231
	in_dev_hold(in_dev);
J
Jianjun Kong 已提交
1232
	im->multiaddr = addr;
L
Linus Torvalds 已提交
1233 1234 1235 1236 1237 1238
	/* 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
1239
	setup_timer(&im->timer, &igmp_timer_expire, (unsigned long)im);
L
Linus Torvalds 已提交
1240 1241
	im->unsolicit_count = IGMP_Unsolicited_Report_Count;
#endif
1242 1243

	im->next_rcu = in_dev->mc_list;
R
Rami Rosen 已提交
1244
	in_dev->mc_count++;
1245 1246
	rcu_assign_pointer(in_dev->mc_list, im);

L
Linus Torvalds 已提交
1247 1248 1249 1250 1251 1252 1253 1254 1255
#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;
}
E
Eric Dumazet 已提交
1256
EXPORT_SYMBOL(ip_mc_inc_group);
L
Linus Torvalds 已提交
1257

1258 1259
/*
 *	Resend IGMP JOIN report; used for bonding.
E
Eric Dumazet 已提交
1260
 *	Called with rcu_read_lock()
1261
 */
E
Eric Dumazet 已提交
1262
void ip_mc_rejoin_groups(struct in_device *in_dev)
1263
{
1264
#ifdef CONFIG_IP_MULTICAST
E
Eric Dumazet 已提交
1265 1266
	struct ip_mc_list *im;
	int type;
1267

E
Eric Dumazet 已提交
1268 1269 1270
	for_each_pmc_rcu(in_dev, im) {
		if (im->multiaddr == IGMP_ALL_HOSTS)
			continue;
1271

E
Eric Dumazet 已提交
1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282
		/* 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);
	}
1283 1284
#endif
}
E
Eric Dumazet 已提交
1285
EXPORT_SYMBOL(ip_mc_rejoin_groups);
1286

L
Linus Torvalds 已提交
1287 1288 1289 1290
/*
 *	A socket has left a multicast group on device dev
 */

1291
void ip_mc_dec_group(struct in_device *in_dev, __be32 addr)
L
Linus Torvalds 已提交
1292
{
1293 1294
	struct ip_mc_list *i;
	struct ip_mc_list __rcu **ip;
1295

L
Linus Torvalds 已提交
1296
	ASSERT_RTNL();
1297

1298 1299 1300
	for (ip = &in_dev->mc_list;
	     (i = rtnl_dereference(*ip)) != NULL;
	     ip = &i->next_rcu) {
J
Jianjun Kong 已提交
1301
		if (i->multiaddr == addr) {
L
Linus Torvalds 已提交
1302
			if (--i->users == 0) {
1303
				*ip = i->next_rcu;
R
Rami Rosen 已提交
1304
				in_dev->mc_count--;
L
Linus Torvalds 已提交
1305
				igmp_group_dropped(i);
1306
				ip_mc_clear_src(i);
L
Linus Torvalds 已提交
1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317

				if (!in_dev->dead)
					ip_rt_multicast_event(in_dev);

				ip_ma_put(i);
				return;
			}
			break;
		}
	}
}
E
Eric Dumazet 已提交
1318
EXPORT_SYMBOL(ip_mc_dec_group);
L
Linus Torvalds 已提交
1319

1320 1321 1322 1323
/* Device changing type */

void ip_mc_unmap(struct in_device *in_dev)
{
1324
	struct ip_mc_list *pmc;
1325 1326 1327

	ASSERT_RTNL();

1328 1329
	for_each_pmc_rtnl(in_dev, pmc)
		igmp_group_dropped(pmc);
1330 1331 1332 1333
}

void ip_mc_remap(struct in_device *in_dev)
{
1334
	struct ip_mc_list *pmc;
1335 1336 1337

	ASSERT_RTNL();

1338 1339
	for_each_pmc_rtnl(in_dev, pmc)
		igmp_group_added(pmc);
1340 1341
}

L
Linus Torvalds 已提交
1342 1343 1344 1345
/* Device going down */

void ip_mc_down(struct in_device *in_dev)
{
1346
	struct ip_mc_list *pmc;
L
Linus Torvalds 已提交
1347 1348 1349

	ASSERT_RTNL();

1350 1351
	for_each_pmc_rtnl(in_dev, pmc)
		igmp_group_dropped(pmc);
L
Linus Torvalds 已提交
1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372

#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;
1373 1374
	setup_timer(&in_dev->mr_gq_timer, igmp_gq_timer_expire,
			(unsigned long)in_dev);
L
Linus Torvalds 已提交
1375
	in_dev->mr_ifc_count = 0;
R
Rami Rosen 已提交
1376
	in_dev->mc_count     = 0;
1377 1378
	setup_timer(&in_dev->mr_ifc_timer, igmp_ifc_timer_expire,
			(unsigned long)in_dev);
L
Linus Torvalds 已提交
1379 1380 1381 1382 1383 1384 1385 1386 1387 1388
	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)
{
1389
	struct ip_mc_list *pmc;
L
Linus Torvalds 已提交
1390 1391 1392 1393 1394

	ASSERT_RTNL();

	ip_mc_inc_group(in_dev, IGMP_ALL_HOSTS);

1395 1396
	for_each_pmc_rtnl(in_dev, pmc)
		igmp_group_added(pmc);
L
Linus Torvalds 已提交
1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411
}

/*
 *	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);

1412 1413
	while ((i = rtnl_dereference(in_dev->mc_list)) != NULL) {
		in_dev->mc_list = i->next_rcu;
R
Rami Rosen 已提交
1414
		in_dev->mc_count--;
1415

1416 1417
		/* We've dropped the groups in ip_mc_down already */
		ip_mc_clear_src(i);
L
Linus Torvalds 已提交
1418 1419 1420 1421
		ip_ma_put(i);
	}
}

1422
/* RTNL is locked */
1423
static struct in_device *ip_mc_find_dev(struct net *net, struct ip_mreqn *imr)
L
Linus Torvalds 已提交
1424 1425 1426 1427 1428
{
	struct net_device *dev = NULL;
	struct in_device *idev = NULL;

	if (imr->imr_ifindex) {
1429
		idev = inetdev_by_index(net, imr->imr_ifindex);
L
Linus Torvalds 已提交
1430 1431 1432
		return idev;
	}
	if (imr->imr_address.s_addr) {
1433
		dev = __ip_dev_find(net, imr->imr_address.s_addr, false);
L
Linus Torvalds 已提交
1434 1435 1436 1437
		if (!dev)
			return NULL;
	}

1438
	if (!dev) {
1439 1440 1441
		struct rtable *rt = ip_route_output(net,
						    imr->imr_multiaddr.s_addr,
						    0, 0, 0);
1442 1443 1444 1445
		if (!IS_ERR(rt)) {
			dev = rt->dst.dev;
			ip_rt_put(rt);
		}
L
Linus Torvalds 已提交
1446 1447 1448
	}
	if (dev) {
		imr->imr_ifindex = dev->ifindex;
1449
		idev = __in_dev_get_rtnl(dev);
L
Linus Torvalds 已提交
1450 1451 1452 1453 1454 1455 1456
	}
	return idev;
}

/*
 *	Join a socket to a group
 */
1457 1458
int sysctl_igmp_max_memberships __read_mostly = IP_MAX_MEMBERSHIPS;
int sysctl_igmp_max_msf __read_mostly = IP_MAX_MSF;
L
Linus Torvalds 已提交
1459 1460 1461


static int ip_mc_del1_src(struct ip_mc_list *pmc, int sfmode,
1462
	__be32 *psfsrc)
L
Linus Torvalds 已提交
1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493
{
	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)) {
1494
			psf->sf_crcount = in_dev->mr_qrv ? in_dev->mr_qrv :
L
Linus Torvalds 已提交
1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509
				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

1510 1511
static int ip_mc_del_src(struct in_device *in_dev, __be32 *pmca, int sfmode,
			 int sfcount, __be32 *psfsrc, int delta)
L
Linus Torvalds 已提交
1512 1513 1514 1515 1516 1517 1518
{
	struct ip_mc_list *pmc;
	int	changerec = 0;
	int	i, err;

	if (!in_dev)
		return -ENODEV;
1519 1520
	rcu_read_lock();
	for_each_pmc_rcu(in_dev, pmc) {
L
Linus Torvalds 已提交
1521 1522 1523 1524 1525
		if (*pmca == pmc->multiaddr)
			break;
	}
	if (!pmc) {
		/* MCA not found?? bug */
1526
		rcu_read_unlock();
L
Linus Torvalds 已提交
1527 1528 1529
		return -ESRCH;
	}
	spin_lock_bh(&pmc->lock);
1530
	rcu_read_unlock();
L
Linus Torvalds 已提交
1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557
#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
1558
		pmc->crcount = in_dev->mr_qrv ? in_dev->mr_qrv :
L
Linus Torvalds 已提交
1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576
			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,
1577
	__be32 *psfsrc, int delta)
L
Linus Torvalds 已提交
1578 1579 1580 1581 1582 1583 1584 1585 1586 1587
{
	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) {
1588
		psf = kzalloc(sizeof(*psf), GFP_ATOMIC);
L
Linus Torvalds 已提交
1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620
		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)
{
1621
	struct ip_sf_list *psf, *dpsf;
L
Linus Torvalds 已提交
1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632
	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;
1633 1634
		if (new_in) {
			if (!psf->sf_oldin) {
A
Al Viro 已提交
1635
				struct ip_sf_list *prev = NULL;
1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662

				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) {
1663
				dpsf = kmalloc(sizeof(*dpsf), GFP_ATOMIC);
1664 1665 1666 1667 1668 1669 1670 1671
				if (!dpsf)
					continue;
				*dpsf = *psf;
				/* pmc->lock held by callers */
				dpsf->sf_next = pmc->tomb;
				pmc->tomb = dpsf;
			}
			dpsf->sf_crcount = qrv;
L
Linus Torvalds 已提交
1672 1673 1674 1675 1676 1677 1678 1679 1680 1681
			rv++;
		}
	}
	return rv;
}
#endif

/*
 * Add multicast source filter list to the interface list
 */
1682 1683
static int ip_mc_add_src(struct in_device *in_dev, __be32 *pmca, int sfmode,
			 int sfcount, __be32 *psfsrc, int delta)
L
Linus Torvalds 已提交
1684 1685 1686 1687 1688 1689 1690
{
	struct ip_mc_list *pmc;
	int	isexclude;
	int	i, err;

	if (!in_dev)
		return -ENODEV;
1691 1692
	rcu_read_lock();
	for_each_pmc_rcu(in_dev, pmc) {
L
Linus Torvalds 已提交
1693 1694 1695 1696 1697
		if (*pmca == pmc->multiaddr)
			break;
	}
	if (!pmc) {
		/* MCA not found?? bug */
1698
		rcu_read_unlock();
L
Linus Torvalds 已提交
1699 1700 1701
		return -ESRCH;
	}
	spin_lock_bh(&pmc->lock);
1702
	rcu_read_unlock();
L
Linus Torvalds 已提交
1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724

#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++) {
		err = ip_mc_add1_src(pmc, sfmode, &psfsrc[i], delta);
		if (err)
			break;
	}
	if (err) {
		int j;

		pmc->sfcount[sfmode]--;
		for (j=0; j<i; j++)
			(void) ip_mc_del1_src(pmc, sfmode, &psfsrc[i]);
	} else if (isexclude != (pmc->sfcount[MCAST_EXCLUDE] != 0)) {
#ifdef CONFIG_IP_MULTICAST
		struct ip_sf_list *psf;
S
Stephen Hemminger 已提交
1725
		in_dev = pmc->interface;
L
Linus Torvalds 已提交
1726 1727 1728 1729 1730 1731 1732 1733 1734 1735
#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 */

1736
		pmc->crcount = in_dev->mr_qrv ? in_dev->mr_qrv :
L
Linus Torvalds 已提交
1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764
			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;
1765
	pmc->sfcount[MCAST_INCLUDE] = 0;
L
Linus Torvalds 已提交
1766 1767 1768 1769 1770 1771 1772 1773 1774 1775
	pmc->sfcount[MCAST_EXCLUDE] = 1;
}


/*
 * Join a multicast group
 */
int ip_mc_join_group(struct sock *sk , struct ip_mreqn *imr)
{
	int err;
1776
	__be32 addr = imr->imr_multiaddr.s_addr;
J
Jianjun Kong 已提交
1777
	struct ip_mc_socklist *iml = NULL, *i;
L
Linus Torvalds 已提交
1778 1779
	struct in_device *in_dev;
	struct inet_sock *inet = inet_sk(sk);
1780
	struct net *net = sock_net(sk);
1781
	int ifindex;
L
Linus Torvalds 已提交
1782 1783
	int count = 0;

1784
	if (!ipv4_is_multicast(addr))
L
Linus Torvalds 已提交
1785 1786
		return -EINVAL;

1787
	rtnl_lock();
L
Linus Torvalds 已提交
1788

1789
	in_dev = ip_mc_find_dev(net, imr);
L
Linus Torvalds 已提交
1790 1791 1792 1793 1794 1795 1796 1797

	if (!in_dev) {
		iml = NULL;
		err = -ENODEV;
		goto done;
	}

	err = -EADDRINUSE;
1798
	ifindex = imr->imr_ifindex;
1799
	for_each_pmc_rtnl(inet, i) {
1800 1801
		if (i->multi.imr_multiaddr.s_addr == addr &&
		    i->multi.imr_ifindex == ifindex)
L
Linus Torvalds 已提交
1802 1803 1804 1805
			goto done;
		count++;
	}
	err = -ENOBUFS;
1806 1807
	if (count >= sysctl_igmp_max_memberships)
		goto done;
J
Jianjun Kong 已提交
1808
	iml = sock_kmalloc(sk, sizeof(*iml), GFP_KERNEL);
1809
	if (iml == NULL)
L
Linus Torvalds 已提交
1810
		goto done;
1811

L
Linus Torvalds 已提交
1812
	memcpy(&iml->multi, imr, sizeof(*imr));
1813
	iml->next_rcu = inet->mc_list;
L
Linus Torvalds 已提交
1814 1815
	iml->sflist = NULL;
	iml->sfmode = MCAST_EXCLUDE;
1816
	rcu_assign_pointer(inet->mc_list, iml);
L
Linus Torvalds 已提交
1817 1818 1819
	ip_mc_inc_group(in_dev, addr);
	err = 0;
done:
1820
	rtnl_unlock();
L
Linus Torvalds 已提交
1821 1822
	return err;
}
E
Eric Dumazet 已提交
1823
EXPORT_SYMBOL(ip_mc_join_group);
L
Linus Torvalds 已提交
1824 1825 1826 1827

static int ip_mc_leave_src(struct sock *sk, struct ip_mc_socklist *iml,
			   struct in_device *in_dev)
{
1828
	struct ip_sf_socklist *psf = rtnl_dereference(iml->sflist);
L
Linus Torvalds 已提交
1829 1830
	int err;

1831
	if (psf == NULL) {
L
Linus Torvalds 已提交
1832 1833 1834 1835 1836
		/* 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,
1837 1838 1839 1840
			iml->sfmode, psf->sl_count, psf->sl_addr, 0);
	rcu_assign_pointer(iml->sflist, NULL);
	/* decrease mem now to avoid the memleak warning */
	atomic_sub(IP_SFLSIZE(psf->sl_max), &sk->sk_omem_alloc);
1841
	kfree_rcu(psf, rcu);
L
Linus Torvalds 已提交
1842 1843 1844 1845 1846 1847 1848 1849 1850 1851
	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);
1852 1853
	struct ip_mc_socklist *iml;
	struct ip_mc_socklist __rcu **imlp;
1854
	struct in_device *in_dev;
1855
	struct net *net = sock_net(sk);
1856
	__be32 group = imr->imr_multiaddr.s_addr;
1857
	u32 ifindex;
1858
	int ret = -EADDRNOTAVAIL;
L
Linus Torvalds 已提交
1859 1860

	rtnl_lock();
1861
	in_dev = ip_mc_find_dev(net, imr);
1862
	ifindex = imr->imr_ifindex;
1863 1864 1865
	for (imlp = &inet->mc_list;
	     (iml = rtnl_dereference(*imlp)) != NULL;
	     imlp = &iml->next_rcu) {
1866 1867 1868 1869 1870 1871 1872 1873
		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;
L
Linus Torvalds 已提交
1874

1875
		(void) ip_mc_leave_src(sk, iml, in_dev);
L
Linus Torvalds 已提交
1876

1877
		*imlp = iml->next_rcu;
1878 1879

		if (in_dev)
1880
			ip_mc_dec_group(in_dev, group);
1881
		rtnl_unlock();
1882 1883
		/* decrease mem now to avoid the memleak warning */
		atomic_sub(sizeof(*iml), &sk->sk_omem_alloc);
1884
		kfree_rcu(iml, rcu);
1885
		return 0;
L
Linus Torvalds 已提交
1886
	}
1887 1888
	if (!in_dev)
		ret = -ENODEV;
L
Linus Torvalds 已提交
1889
	rtnl_unlock();
1890
	return ret;
L
Linus Torvalds 已提交
1891 1892 1893 1894 1895 1896 1897
}

int ip_mc_source(int add, int omode, struct sock *sk, struct
	ip_mreq_source *mreqs, int ifindex)
{
	int err;
	struct ip_mreqn imr;
A
Al Viro 已提交
1898
	__be32 addr = mreqs->imr_multiaddr;
L
Linus Torvalds 已提交
1899 1900 1901 1902
	struct ip_mc_socklist *pmc;
	struct in_device *in_dev = NULL;
	struct inet_sock *inet = inet_sk(sk);
	struct ip_sf_socklist *psl;
1903
	struct net *net = sock_net(sk);
1904
	int leavegroup = 0;
L
Linus Torvalds 已提交
1905 1906
	int i, j, rv;

1907
	if (!ipv4_is_multicast(addr))
L
Linus Torvalds 已提交
1908 1909
		return -EINVAL;

1910
	rtnl_lock();
L
Linus Torvalds 已提交
1911 1912 1913 1914

	imr.imr_multiaddr.s_addr = mreqs->imr_multiaddr;
	imr.imr_address.s_addr = mreqs->imr_interface;
	imr.imr_ifindex = ifindex;
1915
	in_dev = ip_mc_find_dev(net, &imr);
L
Linus Torvalds 已提交
1916 1917 1918 1919 1920 1921 1922

	if (!in_dev) {
		err = -ENODEV;
		goto done;
	}
	err = -EADDRNOTAVAIL;

1923
	for_each_pmc_rtnl(inet, pmc) {
1924 1925 1926
		if ((pmc->multi.imr_multiaddr.s_addr ==
		     imr.imr_multiaddr.s_addr) &&
		    (pmc->multi.imr_ifindex == imr.imr_ifindex))
L
Linus Torvalds 已提交
1927 1928
			break;
	}
1929 1930
	if (!pmc) {		/* must have a prior join */
		err = -EINVAL;
L
Linus Torvalds 已提交
1931
		goto done;
1932
	}
L
Linus Torvalds 已提交
1933 1934
	/* if a source filter was set, must be the same mode as before */
	if (pmc->sflist) {
1935 1936
		if (pmc->sfmode != omode) {
			err = -EINVAL;
L
Linus Torvalds 已提交
1937
			goto done;
1938
		}
L
Linus Torvalds 已提交
1939 1940 1941
	} 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);
1942
		ip_mc_del_src(in_dev, &mreqs->imr_multiaddr, pmc->sfmode, 0,
L
Linus Torvalds 已提交
1943 1944 1945 1946
			NULL, 0);
		pmc->sfmode = omode;
	}

1947
	psl = rtnl_dereference(pmc->sflist);
L
Linus Torvalds 已提交
1948 1949
	if (!add) {
		if (!psl)
1950
			goto done;	/* err = -EADDRNOTAVAIL */
L
Linus Torvalds 已提交
1951 1952 1953
		rv = !0;
		for (i=0; i<psl->sl_count; i++) {
			rv = memcmp(&psl->sl_addr[i], &mreqs->imr_sourceaddr,
A
Al Viro 已提交
1954
				sizeof(__be32));
L
Linus Torvalds 已提交
1955 1956 1957 1958
			if (rv == 0)
				break;
		}
		if (rv)		/* source not found */
1959
			goto done;	/* err = -EADDRNOTAVAIL */
L
Linus Torvalds 已提交
1960

1961 1962 1963 1964 1965 1966
		/* special case - (INCLUDE, empty) == LEAVE_GROUP */
		if (psl->sl_count == 1 && omode == MCAST_INCLUDE) {
			leavegroup = 1;
			goto done;
		}

L
Linus Torvalds 已提交
1967
		/* update the interface filter */
1968
		ip_mc_del_src(in_dev, &mreqs->imr_multiaddr, omode, 1,
L
Linus Torvalds 已提交
1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988
			&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;
1989
		newpsl = sock_kmalloc(sk, IP_SFLSIZE(count), GFP_KERNEL);
L
Linus Torvalds 已提交
1990 1991 1992 1993 1994 1995 1996 1997 1998
		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];
1999 2000
			/* decrease mem now to avoid the memleak warning */
			atomic_sub(IP_SFLSIZE(psl->sl_max), &sk->sk_omem_alloc);
2001
			kfree_rcu(psl, rcu);
L
Linus Torvalds 已提交
2002
		}
2003 2004
		rcu_assign_pointer(pmc->sflist, newpsl);
		psl = newpsl;
L
Linus Torvalds 已提交
2005 2006 2007 2008
	}
	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,
A
Al Viro 已提交
2009
			sizeof(__be32));
L
Linus Torvalds 已提交
2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020
		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 */
2021
	ip_mc_add_src(in_dev, &mreqs->imr_multiaddr, omode, 1,
L
Linus Torvalds 已提交
2022 2023
		&mreqs->imr_sourceaddr, 1);
done:
2024
	rtnl_unlock();
2025 2026
	if (leavegroup)
		return ip_mc_leave_group(sk, &imr);
L
Linus Torvalds 已提交
2027 2028 2029 2030 2031
	return err;
}

int ip_mc_msfilter(struct sock *sk, struct ip_msfilter *msf, int ifindex)
{
2032
	int err = 0;
L
Linus Torvalds 已提交
2033
	struct ip_mreqn	imr;
A
Al Viro 已提交
2034
	__be32 addr = msf->imsf_multiaddr;
L
Linus Torvalds 已提交
2035 2036 2037 2038
	struct ip_mc_socklist *pmc;
	struct in_device *in_dev;
	struct inet_sock *inet = inet_sk(sk);
	struct ip_sf_socklist *newpsl, *psl;
2039
	struct net *net = sock_net(sk);
2040
	int leavegroup = 0;
L
Linus Torvalds 已提交
2041

2042
	if (!ipv4_is_multicast(addr))
L
Linus Torvalds 已提交
2043 2044 2045 2046 2047
		return -EINVAL;
	if (msf->imsf_fmode != MCAST_INCLUDE &&
	    msf->imsf_fmode != MCAST_EXCLUDE)
		return -EINVAL;

2048
	rtnl_lock();
L
Linus Torvalds 已提交
2049 2050 2051 2052

	imr.imr_multiaddr.s_addr = msf->imsf_multiaddr;
	imr.imr_address.s_addr = msf->imsf_interface;
	imr.imr_ifindex = ifindex;
2053
	in_dev = ip_mc_find_dev(net, &imr);
L
Linus Torvalds 已提交
2054 2055 2056 2057 2058 2059

	if (!in_dev) {
		err = -ENODEV;
		goto done;
	}

2060 2061 2062 2063 2064 2065
	/* special case - (INCLUDE, empty) == LEAVE_GROUP */
	if (msf->imsf_fmode == MCAST_INCLUDE && msf->imsf_numsrc == 0) {
		leavegroup = 1;
		goto done;
	}

2066
	for_each_pmc_rtnl(inet, pmc) {
L
Linus Torvalds 已提交
2067 2068 2069 2070
		if (pmc->multi.imr_multiaddr.s_addr == msf->imsf_multiaddr &&
		    pmc->multi.imr_ifindex == imr.imr_ifindex)
			break;
	}
2071 2072
	if (!pmc) {		/* must have a prior join */
		err = -EINVAL;
L
Linus Torvalds 已提交
2073
		goto done;
2074
	}
L
Linus Torvalds 已提交
2075
	if (msf->imsf_numsrc) {
2076 2077
		newpsl = sock_kmalloc(sk, IP_SFLSIZE(msf->imsf_numsrc),
							   GFP_KERNEL);
L
Linus Torvalds 已提交
2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090
		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;
		}
2091
	} else {
L
Linus Torvalds 已提交
2092
		newpsl = NULL;
2093 2094 2095
		(void) ip_mc_add_src(in_dev, &msf->imsf_multiaddr,
				     msf->imsf_fmode, 0, NULL, 0);
	}
2096
	psl = rtnl_dereference(pmc->sflist);
L
Linus Torvalds 已提交
2097 2098 2099
	if (psl) {
		(void) ip_mc_del_src(in_dev, &msf->imsf_multiaddr, pmc->sfmode,
			psl->sl_count, psl->sl_addr, 0);
2100 2101
		/* decrease mem now to avoid the memleak warning */
		atomic_sub(IP_SFLSIZE(psl->sl_max), &sk->sk_omem_alloc);
2102
		kfree_rcu(psl, rcu);
L
Linus Torvalds 已提交
2103 2104 2105
	} else
		(void) ip_mc_del_src(in_dev, &msf->imsf_multiaddr, pmc->sfmode,
			0, NULL, 0);
2106
	rcu_assign_pointer(pmc->sflist, newpsl);
L
Linus Torvalds 已提交
2107
	pmc->sfmode = msf->imsf_fmode;
2108
	err = 0;
L
Linus Torvalds 已提交
2109
done:
2110
	rtnl_unlock();
2111 2112
	if (leavegroup)
		err = ip_mc_leave_group(sk, &imr);
L
Linus Torvalds 已提交
2113 2114 2115 2116 2117 2118 2119 2120
	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;
A
Al Viro 已提交
2121
	__be32 addr = msf->imsf_multiaddr;
L
Linus Torvalds 已提交
2122 2123 2124 2125
	struct ip_mc_socklist *pmc;
	struct in_device *in_dev;
	struct inet_sock *inet = inet_sk(sk);
	struct ip_sf_socklist *psl;
2126
	struct net *net = sock_net(sk);
L
Linus Torvalds 已提交
2127

2128
	if (!ipv4_is_multicast(addr))
L
Linus Torvalds 已提交
2129 2130
		return -EINVAL;

2131
	rtnl_lock();
L
Linus Torvalds 已提交
2132 2133 2134 2135

	imr.imr_multiaddr.s_addr = msf->imsf_multiaddr;
	imr.imr_address.s_addr = msf->imsf_interface;
	imr.imr_ifindex = 0;
2136
	in_dev = ip_mc_find_dev(net, &imr);
L
Linus Torvalds 已提交
2137 2138 2139 2140 2141 2142 2143

	if (!in_dev) {
		err = -ENODEV;
		goto done;
	}
	err = -EADDRNOTAVAIL;

2144
	for_each_pmc_rtnl(inet, pmc) {
L
Linus Torvalds 已提交
2145 2146 2147 2148 2149 2150 2151
		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;
2152
	psl = rtnl_dereference(pmc->sflist);
2153
	rtnl_unlock();
L
Linus Torvalds 已提交
2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171
	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:
2172
	rtnl_unlock();
L
Linus Torvalds 已提交
2173 2174 2175 2176 2177 2178 2179 2180
	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;
A
Al Viro 已提交
2181
	__be32 addr;
L
Linus Torvalds 已提交
2182 2183 2184 2185 2186 2187 2188 2189
	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;
2190
	if (!ipv4_is_multicast(addr))
L
Linus Torvalds 已提交
2191 2192
		return -EINVAL;

2193
	rtnl_lock();
L
Linus Torvalds 已提交
2194 2195 2196

	err = -EADDRNOTAVAIL;

2197
	for_each_pmc_rtnl(inet, pmc) {
L
Linus Torvalds 已提交
2198 2199 2200 2201 2202 2203 2204
		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;
2205
	psl = rtnl_dereference(pmc->sflist);
2206
	rtnl_unlock();
L
Linus Torvalds 已提交
2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225
	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:
2226
	rtnl_unlock();
L
Linus Torvalds 已提交
2227 2228 2229 2230 2231 2232
	return err;
}

/*
 * check if a multicast source filter allows delivery for a given <src,dst,intf>
 */
A
Al Viro 已提交
2233
int ip_mc_sf_allow(struct sock *sk, __be32 loc_addr, __be32 rmt_addr, int dif)
L
Linus Torvalds 已提交
2234 2235 2236 2237 2238
{
	struct inet_sock *inet = inet_sk(sk);
	struct ip_mc_socklist *pmc;
	struct ip_sf_socklist *psl;
	int i;
2239
	int ret;
L
Linus Torvalds 已提交
2240

2241
	ret = 1;
2242
	if (!ipv4_is_multicast(loc_addr))
2243
		goto out;
L
Linus Torvalds 已提交
2244

2245
	rcu_read_lock();
2246
	for_each_pmc_rcu(inet, pmc) {
L
Linus Torvalds 已提交
2247 2248 2249 2250
		if (pmc->multi.imr_multiaddr.s_addr == loc_addr &&
		    pmc->multi.imr_ifindex == dif)
			break;
	}
2251
	ret = inet->mc_all;
L
Linus Torvalds 已提交
2252
	if (!pmc)
2253
		goto unlock;
2254
	psl = rcu_dereference(pmc->sflist);
2255
	ret = (pmc->sfmode == MCAST_EXCLUDE);
L
Linus Torvalds 已提交
2256
	if (!psl)
2257
		goto unlock;
L
Linus Torvalds 已提交
2258 2259 2260 2261 2262

	for (i=0; i<psl->sl_count; i++) {
		if (psl->sl_addr[i] == rmt_addr)
			break;
	}
2263
	ret = 0;
L
Linus Torvalds 已提交
2264
	if (pmc->sfmode == MCAST_INCLUDE && i >= psl->sl_count)
2265
		goto unlock;
L
Linus Torvalds 已提交
2266
	if (pmc->sfmode == MCAST_EXCLUDE && i < psl->sl_count)
2267 2268 2269 2270 2271 2272
		goto unlock;
	ret = 1;
unlock:
	rcu_read_unlock();
out:
	return ret;
L
Linus Torvalds 已提交
2273 2274 2275 2276 2277 2278 2279 2280 2281 2282
}

/*
 *	A socket is closing.
 */

void ip_mc_drop_socket(struct sock *sk)
{
	struct inet_sock *inet = inet_sk(sk);
	struct ip_mc_socklist *iml;
2283
	struct net *net = sock_net(sk);
L
Linus Torvalds 已提交
2284 2285 2286 2287 2288

	if (inet->mc_list == NULL)
		return;

	rtnl_lock();
2289
	while ((iml = rtnl_dereference(inet->mc_list)) != NULL) {
L
Linus Torvalds 已提交
2290 2291
		struct in_device *in_dev;

2292
		inet->mc_list = iml->next_rcu;
2293
		in_dev = inetdev_by_index(net, iml->multi.imr_ifindex);
2294
		(void) ip_mc_leave_src(sk, iml, in_dev);
E
Eric Dumazet 已提交
2295
		if (in_dev != NULL)
L
Linus Torvalds 已提交
2296
			ip_mc_dec_group(in_dev, iml->multi.imr_multiaddr.s_addr);
2297 2298
		/* decrease mem now to avoid the memleak warning */
		atomic_sub(sizeof(*iml), &sk->sk_omem_alloc);
2299
		kfree_rcu(iml, rcu);
L
Linus Torvalds 已提交
2300 2301 2302 2303
	}
	rtnl_unlock();
}

2304 2305
/* called with rcu_read_lock() */
int ip_check_mc_rcu(struct in_device *in_dev, __be32 mc_addr, __be32 src_addr, u16 proto)
L
Linus Torvalds 已提交
2306 2307 2308 2309 2310
{
	struct ip_mc_list *im;
	struct ip_sf_list *psf;
	int rv = 0;

2311
	for_each_pmc_rcu(in_dev, im) {
L
Linus Torvalds 已提交
2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336
		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 {
2337
	struct seq_net_private p;
L
Linus Torvalds 已提交
2338 2339 2340 2341 2342 2343 2344 2345
	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)
{
2346
	struct net *net = seq_file_net(seq);
L
Linus Torvalds 已提交
2347 2348 2349
	struct ip_mc_list *im = NULL;
	struct igmp_mc_iter_state *state = igmp_mc_seq_private(seq);

2350
	state->in_dev = NULL;
2351
	for_each_netdev_rcu(net, state->dev) {
L
Linus Torvalds 已提交
2352
		struct in_device *in_dev;
E
Eric Dumazet 已提交
2353 2354

		in_dev = __in_dev_get_rcu(state->dev);
L
Linus Torvalds 已提交
2355 2356
		if (!in_dev)
			continue;
2357
		im = rcu_dereference(in_dev->mc_list);
L
Linus Torvalds 已提交
2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368
		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);
E
Eric Dumazet 已提交
2369

2370 2371
	im = rcu_dereference(im->next_rcu);
	while (!im) {
E
Eric Dumazet 已提交
2372
		state->dev = next_net_device_rcu(state->dev);
L
Linus Torvalds 已提交
2373 2374 2375 2376
		if (!state->dev) {
			state->in_dev = NULL;
			break;
		}
E
Eric Dumazet 已提交
2377
		state->in_dev = __in_dev_get_rcu(state->dev);
L
Linus Torvalds 已提交
2378 2379
		if (!state->in_dev)
			continue;
2380
		im = rcu_dereference(state->in_dev->mc_list);
L
Linus Torvalds 已提交
2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394
	}
	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)
2395
	__acquires(rcu)
L
Linus Torvalds 已提交
2396
{
2397
	rcu_read_lock();
L
Linus Torvalds 已提交
2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412
	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)
2413
	__releases(rcu)
L
Linus Torvalds 已提交
2414 2415
{
	struct igmp_mc_iter_state *state = igmp_mc_seq_private(seq);
2416 2417

	state->in_dev = NULL;
L
Linus Torvalds 已提交
2418
	state->dev = NULL;
2419
	rcu_read_unlock();
L
Linus Torvalds 已提交
2420 2421 2422 2423 2424
}

static int igmp_mc_seq_show(struct seq_file *seq, void *v)
{
	if (v == SEQ_START_TOKEN)
2425
		seq_puts(seq,
L
Linus Torvalds 已提交
2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438
			 "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

2439
		if (rcu_dereference(state->in_dev->mc_list) == im) {
L
Linus Torvalds 已提交
2440
			seq_printf(seq, "%d\t%-10s: %5d %7s\n",
R
Rami Rosen 已提交
2441
				   state->dev->ifindex, state->dev->name, state->in_dev->mc_count, querier);
L
Linus Torvalds 已提交
2442 2443 2444
		}

		seq_printf(seq,
2445
			   "\t\t\t\t%08X %5d %d:%08lX\t\t%d\n",
L
Linus Torvalds 已提交
2446 2447 2448 2449 2450 2451 2452 2453
			   im->multiaddr, im->users,
			   im->tm_running, im->tm_running ?
			   jiffies_to_clock_t(im->timer.expires-jiffies) : 0,
			   im->reporter);
	}
	return 0;
}

2454
static const struct seq_operations igmp_mc_seq_ops = {
L
Linus Torvalds 已提交
2455 2456 2457 2458 2459 2460 2461 2462
	.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)
{
2463
	return seq_open_net(inode, file, &igmp_mc_seq_ops,
2464
			sizeof(struct igmp_mc_iter_state));
L
Linus Torvalds 已提交
2465 2466
}

2467
static const struct file_operations igmp_mc_seq_fops = {
L
Linus Torvalds 已提交
2468 2469 2470 2471
	.owner		=	THIS_MODULE,
	.open		=	igmp_mc_seq_open,
	.read		=	seq_read,
	.llseek		=	seq_lseek,
2472
	.release	=	seq_release_net,
L
Linus Torvalds 已提交
2473 2474 2475
};

struct igmp_mcf_iter_state {
2476
	struct seq_net_private p;
L
Linus Torvalds 已提交
2477 2478 2479 2480 2481 2482 2483 2484 2485
	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)
{
2486
	struct net *net = seq_file_net(seq);
L
Linus Torvalds 已提交
2487 2488 2489 2490
	struct ip_sf_list *psf = NULL;
	struct ip_mc_list *im = NULL;
	struct igmp_mcf_iter_state *state = igmp_mcf_seq_private(seq);

2491 2492
	state->idev = NULL;
	state->im = NULL;
2493
	for_each_netdev_rcu(net, state->dev) {
L
Linus Torvalds 已提交
2494
		struct in_device *idev;
E
Eric Dumazet 已提交
2495
		idev = __in_dev_get_rcu(state->dev);
L
Linus Torvalds 已提交
2496 2497
		if (unlikely(idev == NULL))
			continue;
2498
		im = rcu_dereference(idev->mc_list);
L
Linus Torvalds 已提交
2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521
		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) {
E
Eric Dumazet 已提交
2522
			state->dev = next_net_device_rcu(state->dev);
L
Linus Torvalds 已提交
2523 2524 2525 2526
			if (!state->dev) {
				state->idev = NULL;
				goto out;
			}
E
Eric Dumazet 已提交
2527
			state->idev = __in_dev_get_rcu(state->dev);
L
Linus Torvalds 已提交
2528 2529
			if (!state->idev)
				continue;
2530
			state->im = rcu_dereference(state->idev->mc_list);
L
Linus Torvalds 已提交
2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550
		}
		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)
2551
	__acquires(rcu)
L
Linus Torvalds 已提交
2552
{
2553
	rcu_read_lock();
L
Linus Torvalds 已提交
2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568
	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)
2569
	__releases(rcu)
L
Linus Torvalds 已提交
2570 2571 2572 2573 2574 2575
{
	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;
	}
2576
	state->idev = NULL;
L
Linus Torvalds 已提交
2577
	state->dev = NULL;
2578
	rcu_read_unlock();
L
Linus Torvalds 已提交
2579 2580 2581 2582 2583 2584 2585 2586
}

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) {
2587
		seq_printf(seq,
L
Linus Torvalds 已提交
2588 2589 2590 2591 2592 2593 2594
			   "%3s %6s "
			   "%10s %10s %6s %6s\n", "Idx",
			   "Device", "MCA",
			   "SRC", "INC", "EXC");
	} else {
		seq_printf(seq,
			   "%3d %6.6s 0x%08x "
2595 2596
			   "0x%08x %6lu %6lu\n",
			   state->dev->ifindex, state->dev->name,
L
Linus Torvalds 已提交
2597 2598 2599 2600 2601 2602 2603 2604
			   ntohl(state->im->multiaddr),
			   ntohl(psf->sf_inaddr),
			   psf->sf_count[MCAST_INCLUDE],
			   psf->sf_count[MCAST_EXCLUDE]);
	}
	return 0;
}

2605
static const struct seq_operations igmp_mcf_seq_ops = {
L
Linus Torvalds 已提交
2606 2607 2608 2609 2610 2611 2612 2613
	.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)
{
2614
	return seq_open_net(inode, file, &igmp_mcf_seq_ops,
2615
			sizeof(struct igmp_mcf_iter_state));
L
Linus Torvalds 已提交
2616 2617
}

2618
static const struct file_operations igmp_mcf_seq_fops = {
L
Linus Torvalds 已提交
2619 2620 2621 2622
	.owner		=	THIS_MODULE,
	.open		=	igmp_mcf_seq_open,
	.read		=	seq_read,
	.llseek		=	seq_lseek,
2623
	.release	=	seq_release_net,
L
Linus Torvalds 已提交
2624 2625
};

2626
static int __net_init igmp_net_init(struct net *net)
L
Linus Torvalds 已提交
2627
{
2628 2629 2630 2631 2632 2633 2634 2635
	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;
L
Linus Torvalds 已提交
2636
	return 0;
2637 2638 2639 2640 2641 2642 2643

out_mcfilter:
	proc_net_remove(net, "igmp");
out_igmp:
	return -ENOMEM;
}

2644
static void __net_exit igmp_net_exit(struct net *net)
2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657
{
	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);
L
Linus Torvalds 已提交
2658 2659
}
#endif