xref: /openbmc/linux/net/ipv6/mcast.c (revision 545e4006)
1 /*
2  *	Multicast support for IPv6
3  *	Linux INET6 implementation
4  *
5  *	Authors:
6  *	Pedro Roque		<roque@di.fc.ul.pt>
7  *
8  *	Based on linux/ipv4/igmp.c and linux/ipv4/ip_sockglue.c
9  *
10  *	This program is free software; you can redistribute it and/or
11  *      modify it under the terms of the GNU General Public License
12  *      as published by the Free Software Foundation; either version
13  *      2 of the License, or (at your option) any later version.
14  */
15 
16 /* Changes:
17  *
18  *	yoshfuji	: fix format of router-alert option
19  *	YOSHIFUJI Hideaki @USAGI:
20  *		Fixed source address for MLD message based on
21  *		<draft-ietf-magma-mld-source-05.txt>.
22  *	YOSHIFUJI Hideaki @USAGI:
23  *		- Ignore Queries for invalid addresses.
24  *		- MLD for link-local addresses.
25  *	David L Stevens <dlstevens@us.ibm.com>:
26  *		- MLDv2 support
27  */
28 
29 #include <linux/module.h>
30 #include <linux/errno.h>
31 #include <linux/types.h>
32 #include <linux/string.h>
33 #include <linux/socket.h>
34 #include <linux/sockios.h>
35 #include <linux/jiffies.h>
36 #include <linux/times.h>
37 #include <linux/net.h>
38 #include <linux/in.h>
39 #include <linux/in6.h>
40 #include <linux/netdevice.h>
41 #include <linux/if_arp.h>
42 #include <linux/route.h>
43 #include <linux/init.h>
44 #include <linux/proc_fs.h>
45 #include <linux/seq_file.h>
46 
47 #include <linux/netfilter.h>
48 #include <linux/netfilter_ipv6.h>
49 
50 #include <net/net_namespace.h>
51 #include <net/sock.h>
52 #include <net/snmp.h>
53 
54 #include <net/ipv6.h>
55 #include <net/protocol.h>
56 #include <net/if_inet6.h>
57 #include <net/ndisc.h>
58 #include <net/addrconf.h>
59 #include <net/ip6_route.h>
60 #include <net/inet_common.h>
61 
62 #include <net/ip6_checksum.h>
63 
64 /* Set to 3 to get tracing... */
65 #define MCAST_DEBUG 2
66 
67 #if MCAST_DEBUG >= 3
68 #define MDBG(x) printk x
69 #else
70 #define MDBG(x)
71 #endif
72 
73 /*
74  *  These header formats should be in a separate include file, but icmpv6.h
75  *  doesn't have in6_addr defined in all cases, there is no __u128, and no
76  *  other files reference these.
77  *
78  *  			+-DLS 4/14/03
79  */
80 
81 /* Multicast Listener Discovery version 2 headers */
82 
83 struct mld2_grec {
84 	__u8		grec_type;
85 	__u8		grec_auxwords;
86 	__be16		grec_nsrcs;
87 	struct in6_addr	grec_mca;
88 	struct in6_addr	grec_src[0];
89 };
90 
91 struct mld2_report {
92 	__u8	type;
93 	__u8	resv1;
94 	__sum16	csum;
95 	__be16	resv2;
96 	__be16	ngrec;
97 	struct mld2_grec grec[0];
98 };
99 
100 struct mld2_query {
101 	__u8 type;
102 	__u8 code;
103 	__sum16 csum;
104 	__be16 mrc;
105 	__be16 resv1;
106 	struct in6_addr mca;
107 #if defined(__LITTLE_ENDIAN_BITFIELD)
108 	__u8 qrv:3,
109 	     suppress:1,
110 	     resv2:4;
111 #elif defined(__BIG_ENDIAN_BITFIELD)
112 	__u8 resv2:4,
113 	     suppress:1,
114 	     qrv:3;
115 #else
116 #error "Please fix <asm/byteorder.h>"
117 #endif
118 	__u8 qqic;
119 	__be16 nsrcs;
120 	struct in6_addr srcs[0];
121 };
122 
123 static struct in6_addr mld2_all_mcr = MLD2_ALL_MCR_INIT;
124 
125 /* Big mc list lock for all the sockets */
126 static DEFINE_RWLOCK(ipv6_sk_mc_lock);
127 
128 static void igmp6_join_group(struct ifmcaddr6 *ma);
129 static void igmp6_leave_group(struct ifmcaddr6 *ma);
130 static void igmp6_timer_handler(unsigned long data);
131 
132 static void mld_gq_timer_expire(unsigned long data);
133 static void mld_ifc_timer_expire(unsigned long data);
134 static void mld_ifc_event(struct inet6_dev *idev);
135 static void mld_add_delrec(struct inet6_dev *idev, struct ifmcaddr6 *pmc);
136 static void mld_del_delrec(struct inet6_dev *idev, struct in6_addr *addr);
137 static void mld_clear_delrec(struct inet6_dev *idev);
138 static int sf_setstate(struct ifmcaddr6 *pmc);
139 static void sf_markstate(struct ifmcaddr6 *pmc);
140 static void ip6_mc_clear_src(struct ifmcaddr6 *pmc);
141 static int ip6_mc_del_src(struct inet6_dev *idev, struct in6_addr *pmca,
142 			  int sfmode, int sfcount, struct in6_addr *psfsrc,
143 			  int delta);
144 static int ip6_mc_add_src(struct inet6_dev *idev, struct in6_addr *pmca,
145 			  int sfmode, int sfcount, struct in6_addr *psfsrc,
146 			  int delta);
147 static int ip6_mc_leave_src(struct sock *sk, struct ipv6_mc_socklist *iml,
148 			    struct inet6_dev *idev);
149 
150 
151 #define IGMP6_UNSOLICITED_IVAL	(10*HZ)
152 #define MLD_QRV_DEFAULT		2
153 
154 #define MLD_V1_SEEN(idev) (dev_net((idev)->dev)->ipv6.devconf_all->force_mld_version == 1 || \
155 		(idev)->cnf.force_mld_version == 1 || \
156 		((idev)->mc_v1_seen && \
157 		time_before(jiffies, (idev)->mc_v1_seen)))
158 
159 #define MLDV2_MASK(value, nb) ((nb)>=32 ? (value) : ((1<<(nb))-1) & (value))
160 #define MLDV2_EXP(thresh, nbmant, nbexp, value) \
161 	((value) < (thresh) ? (value) : \
162 	((MLDV2_MASK(value, nbmant) | (1<<(nbmant))) << \
163 	(MLDV2_MASK((value) >> (nbmant), nbexp) + (nbexp))))
164 
165 #define MLDV2_MRC(value) MLDV2_EXP(0x8000, 12, 3, value)
166 
167 #define IPV6_MLD_MAX_MSF	64
168 
169 int sysctl_mld_max_msf __read_mostly = IPV6_MLD_MAX_MSF;
170 
171 /*
172  *	socket join on multicast group
173  */
174 
175 int ipv6_sock_mc_join(struct sock *sk, int ifindex, const struct in6_addr *addr)
176 {
177 	struct net_device *dev = NULL;
178 	struct ipv6_mc_socklist *mc_lst;
179 	struct ipv6_pinfo *np = inet6_sk(sk);
180 	struct net *net = sock_net(sk);
181 	int err;
182 
183 	if (!ipv6_addr_is_multicast(addr))
184 		return -EINVAL;
185 
186 	read_lock_bh(&ipv6_sk_mc_lock);
187 	for (mc_lst=np->ipv6_mc_list; mc_lst; mc_lst=mc_lst->next) {
188 		if ((ifindex == 0 || mc_lst->ifindex == ifindex) &&
189 		    ipv6_addr_equal(&mc_lst->addr, addr)) {
190 			read_unlock_bh(&ipv6_sk_mc_lock);
191 			return -EADDRINUSE;
192 		}
193 	}
194 	read_unlock_bh(&ipv6_sk_mc_lock);
195 
196 	mc_lst = sock_kmalloc(sk, sizeof(struct ipv6_mc_socklist), GFP_KERNEL);
197 
198 	if (mc_lst == NULL)
199 		return -ENOMEM;
200 
201 	mc_lst->next = NULL;
202 	ipv6_addr_copy(&mc_lst->addr, addr);
203 
204 	if (ifindex == 0) {
205 		struct rt6_info *rt;
206 		rt = rt6_lookup(net, addr, NULL, 0, 0);
207 		if (rt) {
208 			dev = rt->rt6i_dev;
209 			dev_hold(dev);
210 			dst_release(&rt->u.dst);
211 		}
212 	} else
213 		dev = dev_get_by_index(net, ifindex);
214 
215 	if (dev == NULL) {
216 		sock_kfree_s(sk, mc_lst, sizeof(*mc_lst));
217 		return -ENODEV;
218 	}
219 
220 	mc_lst->ifindex = dev->ifindex;
221 	mc_lst->sfmode = MCAST_EXCLUDE;
222 	rwlock_init(&mc_lst->sflock);
223 	mc_lst->sflist = NULL;
224 
225 	/*
226 	 *	now add/increase the group membership on the device
227 	 */
228 
229 	err = ipv6_dev_mc_inc(dev, addr);
230 
231 	if (err) {
232 		sock_kfree_s(sk, mc_lst, sizeof(*mc_lst));
233 		dev_put(dev);
234 		return err;
235 	}
236 
237 	write_lock_bh(&ipv6_sk_mc_lock);
238 	mc_lst->next = np->ipv6_mc_list;
239 	np->ipv6_mc_list = mc_lst;
240 	write_unlock_bh(&ipv6_sk_mc_lock);
241 
242 	dev_put(dev);
243 
244 	return 0;
245 }
246 
247 /*
248  *	socket leave on multicast group
249  */
250 int ipv6_sock_mc_drop(struct sock *sk, int ifindex, const struct in6_addr *addr)
251 {
252 	struct ipv6_pinfo *np = inet6_sk(sk);
253 	struct ipv6_mc_socklist *mc_lst, **lnk;
254 	struct net *net = sock_net(sk);
255 
256 	write_lock_bh(&ipv6_sk_mc_lock);
257 	for (lnk = &np->ipv6_mc_list; (mc_lst = *lnk) !=NULL ; lnk = &mc_lst->next) {
258 		if ((ifindex == 0 || mc_lst->ifindex == ifindex) &&
259 		    ipv6_addr_equal(&mc_lst->addr, addr)) {
260 			struct net_device *dev;
261 
262 			*lnk = mc_lst->next;
263 			write_unlock_bh(&ipv6_sk_mc_lock);
264 
265 			dev = dev_get_by_index(net, mc_lst->ifindex);
266 			if (dev != NULL) {
267 				struct inet6_dev *idev = in6_dev_get(dev);
268 
269 				(void) ip6_mc_leave_src(sk, mc_lst, idev);
270 				if (idev) {
271 					__ipv6_dev_mc_dec(idev, &mc_lst->addr);
272 					in6_dev_put(idev);
273 				}
274 				dev_put(dev);
275 			} else
276 				(void) ip6_mc_leave_src(sk, mc_lst, NULL);
277 			sock_kfree_s(sk, mc_lst, sizeof(*mc_lst));
278 			return 0;
279 		}
280 	}
281 	write_unlock_bh(&ipv6_sk_mc_lock);
282 
283 	return -EADDRNOTAVAIL;
284 }
285 
286 static struct inet6_dev *ip6_mc_find_dev(struct net *net,
287 					 struct in6_addr *group,
288 					 int ifindex)
289 {
290 	struct net_device *dev = NULL;
291 	struct inet6_dev *idev = NULL;
292 
293 	if (ifindex == 0) {
294 		struct rt6_info *rt;
295 
296 		rt = rt6_lookup(net, group, NULL, 0, 0);
297 		if (rt) {
298 			dev = rt->rt6i_dev;
299 			dev_hold(dev);
300 			dst_release(&rt->u.dst);
301 		}
302 	} else
303 		dev = dev_get_by_index(net, ifindex);
304 
305 	if (!dev)
306 		return NULL;
307 	idev = in6_dev_get(dev);
308 	if (!idev) {
309 		dev_put(dev);
310 		return NULL;
311 	}
312 	read_lock_bh(&idev->lock);
313 	if (idev->dead) {
314 		read_unlock_bh(&idev->lock);
315 		in6_dev_put(idev);
316 		dev_put(dev);
317 		return NULL;
318 	}
319 	return idev;
320 }
321 
322 void ipv6_sock_mc_close(struct sock *sk)
323 {
324 	struct ipv6_pinfo *np = inet6_sk(sk);
325 	struct ipv6_mc_socklist *mc_lst;
326 	struct net *net = sock_net(sk);
327 
328 	write_lock_bh(&ipv6_sk_mc_lock);
329 	while ((mc_lst = np->ipv6_mc_list) != NULL) {
330 		struct net_device *dev;
331 
332 		np->ipv6_mc_list = mc_lst->next;
333 		write_unlock_bh(&ipv6_sk_mc_lock);
334 
335 		dev = dev_get_by_index(net, mc_lst->ifindex);
336 		if (dev) {
337 			struct inet6_dev *idev = in6_dev_get(dev);
338 
339 			(void) ip6_mc_leave_src(sk, mc_lst, idev);
340 			if (idev) {
341 				__ipv6_dev_mc_dec(idev, &mc_lst->addr);
342 				in6_dev_put(idev);
343 			}
344 			dev_put(dev);
345 		} else
346 			(void) ip6_mc_leave_src(sk, mc_lst, NULL);
347 
348 		sock_kfree_s(sk, mc_lst, sizeof(*mc_lst));
349 
350 		write_lock_bh(&ipv6_sk_mc_lock);
351 	}
352 	write_unlock_bh(&ipv6_sk_mc_lock);
353 }
354 
355 int ip6_mc_source(int add, int omode, struct sock *sk,
356 	struct group_source_req *pgsr)
357 {
358 	struct in6_addr *source, *group;
359 	struct ipv6_mc_socklist *pmc;
360 	struct net_device *dev;
361 	struct inet6_dev *idev;
362 	struct ipv6_pinfo *inet6 = inet6_sk(sk);
363 	struct ip6_sf_socklist *psl;
364 	struct net *net = sock_net(sk);
365 	int i, j, rv;
366 	int leavegroup = 0;
367 	int pmclocked = 0;
368 	int err;
369 
370 	source = &((struct sockaddr_in6 *)&pgsr->gsr_source)->sin6_addr;
371 	group = &((struct sockaddr_in6 *)&pgsr->gsr_group)->sin6_addr;
372 
373 	if (!ipv6_addr_is_multicast(group))
374 		return -EINVAL;
375 
376 	idev = ip6_mc_find_dev(net, group, pgsr->gsr_interface);
377 	if (!idev)
378 		return -ENODEV;
379 	dev = idev->dev;
380 
381 	err = -EADDRNOTAVAIL;
382 
383 	read_lock_bh(&ipv6_sk_mc_lock);
384 	for (pmc=inet6->ipv6_mc_list; pmc; pmc=pmc->next) {
385 		if (pgsr->gsr_interface && pmc->ifindex != pgsr->gsr_interface)
386 			continue;
387 		if (ipv6_addr_equal(&pmc->addr, group))
388 			break;
389 	}
390 	if (!pmc) {		/* must have a prior join */
391 		err = -EINVAL;
392 		goto done;
393 	}
394 	/* if a source filter was set, must be the same mode as before */
395 	if (pmc->sflist) {
396 		if (pmc->sfmode != omode) {
397 			err = -EINVAL;
398 			goto done;
399 		}
400 	} else if (pmc->sfmode != omode) {
401 		/* allow mode switches for empty-set filters */
402 		ip6_mc_add_src(idev, group, omode, 0, NULL, 0);
403 		ip6_mc_del_src(idev, group, pmc->sfmode, 0, NULL, 0);
404 		pmc->sfmode = omode;
405 	}
406 
407 	write_lock_bh(&pmc->sflock);
408 	pmclocked = 1;
409 
410 	psl = pmc->sflist;
411 	if (!add) {
412 		if (!psl)
413 			goto done;	/* err = -EADDRNOTAVAIL */
414 		rv = !0;
415 		for (i=0; i<psl->sl_count; i++) {
416 			rv = memcmp(&psl->sl_addr[i], source,
417 				sizeof(struct in6_addr));
418 			if (rv == 0)
419 				break;
420 		}
421 		if (rv)		/* source not found */
422 			goto done;	/* err = -EADDRNOTAVAIL */
423 
424 		/* special case - (INCLUDE, empty) == LEAVE_GROUP */
425 		if (psl->sl_count == 1 && omode == MCAST_INCLUDE) {
426 			leavegroup = 1;
427 			goto done;
428 		}
429 
430 		/* update the interface filter */
431 		ip6_mc_del_src(idev, group, omode, 1, source, 1);
432 
433 		for (j=i+1; j<psl->sl_count; j++)
434 			psl->sl_addr[j-1] = psl->sl_addr[j];
435 		psl->sl_count--;
436 		err = 0;
437 		goto done;
438 	}
439 	/* else, add a new source to the filter */
440 
441 	if (psl && psl->sl_count >= sysctl_mld_max_msf) {
442 		err = -ENOBUFS;
443 		goto done;
444 	}
445 	if (!psl || psl->sl_count == psl->sl_max) {
446 		struct ip6_sf_socklist *newpsl;
447 		int count = IP6_SFBLOCK;
448 
449 		if (psl)
450 			count += psl->sl_max;
451 		newpsl = sock_kmalloc(sk, IP6_SFLSIZE(count), GFP_ATOMIC);
452 		if (!newpsl) {
453 			err = -ENOBUFS;
454 			goto done;
455 		}
456 		newpsl->sl_max = count;
457 		newpsl->sl_count = count - IP6_SFBLOCK;
458 		if (psl) {
459 			for (i=0; i<psl->sl_count; i++)
460 				newpsl->sl_addr[i] = psl->sl_addr[i];
461 			sock_kfree_s(sk, psl, IP6_SFLSIZE(psl->sl_max));
462 		}
463 		pmc->sflist = psl = newpsl;
464 	}
465 	rv = 1;	/* > 0 for insert logic below if sl_count is 0 */
466 	for (i=0; i<psl->sl_count; i++) {
467 		rv = memcmp(&psl->sl_addr[i], source, sizeof(struct in6_addr));
468 		if (rv == 0)
469 			break;
470 	}
471 	if (rv == 0)		/* address already there is an error */
472 		goto done;
473 	for (j=psl->sl_count-1; j>=i; j--)
474 		psl->sl_addr[j+1] = psl->sl_addr[j];
475 	psl->sl_addr[i] = *source;
476 	psl->sl_count++;
477 	err = 0;
478 	/* update the interface list */
479 	ip6_mc_add_src(idev, group, omode, 1, source, 1);
480 done:
481 	if (pmclocked)
482 		write_unlock_bh(&pmc->sflock);
483 	read_unlock_bh(&ipv6_sk_mc_lock);
484 	read_unlock_bh(&idev->lock);
485 	in6_dev_put(idev);
486 	dev_put(dev);
487 	if (leavegroup)
488 		return ipv6_sock_mc_drop(sk, pgsr->gsr_interface, group);
489 	return err;
490 }
491 
492 int ip6_mc_msfilter(struct sock *sk, struct group_filter *gsf)
493 {
494 	struct in6_addr *group;
495 	struct ipv6_mc_socklist *pmc;
496 	struct net_device *dev;
497 	struct inet6_dev *idev;
498 	struct ipv6_pinfo *inet6 = inet6_sk(sk);
499 	struct ip6_sf_socklist *newpsl, *psl;
500 	struct net *net = sock_net(sk);
501 	int leavegroup = 0;
502 	int i, err;
503 
504 	group = &((struct sockaddr_in6 *)&gsf->gf_group)->sin6_addr;
505 
506 	if (!ipv6_addr_is_multicast(group))
507 		return -EINVAL;
508 	if (gsf->gf_fmode != MCAST_INCLUDE &&
509 	    gsf->gf_fmode != MCAST_EXCLUDE)
510 		return -EINVAL;
511 
512 	idev = ip6_mc_find_dev(net, group, gsf->gf_interface);
513 
514 	if (!idev)
515 		return -ENODEV;
516 	dev = idev->dev;
517 
518 	err = 0;
519 	read_lock_bh(&ipv6_sk_mc_lock);
520 
521 	if (gsf->gf_fmode == MCAST_INCLUDE && gsf->gf_numsrc == 0) {
522 		leavegroup = 1;
523 		goto done;
524 	}
525 
526 	for (pmc=inet6->ipv6_mc_list; pmc; pmc=pmc->next) {
527 		if (pmc->ifindex != gsf->gf_interface)
528 			continue;
529 		if (ipv6_addr_equal(&pmc->addr, group))
530 			break;
531 	}
532 	if (!pmc) {		/* must have a prior join */
533 		err = -EINVAL;
534 		goto done;
535 	}
536 	if (gsf->gf_numsrc) {
537 		newpsl = sock_kmalloc(sk, IP6_SFLSIZE(gsf->gf_numsrc),
538 							  GFP_ATOMIC);
539 		if (!newpsl) {
540 			err = -ENOBUFS;
541 			goto done;
542 		}
543 		newpsl->sl_max = newpsl->sl_count = gsf->gf_numsrc;
544 		for (i=0; i<newpsl->sl_count; ++i) {
545 			struct sockaddr_in6 *psin6;
546 
547 			psin6 = (struct sockaddr_in6 *)&gsf->gf_slist[i];
548 			newpsl->sl_addr[i] = psin6->sin6_addr;
549 		}
550 		err = ip6_mc_add_src(idev, group, gsf->gf_fmode,
551 			newpsl->sl_count, newpsl->sl_addr, 0);
552 		if (err) {
553 			sock_kfree_s(sk, newpsl, IP6_SFLSIZE(newpsl->sl_max));
554 			goto done;
555 		}
556 	} else {
557 		newpsl = NULL;
558 		(void) ip6_mc_add_src(idev, group, gsf->gf_fmode, 0, NULL, 0);
559 	}
560 
561 	write_lock_bh(&pmc->sflock);
562 	psl = pmc->sflist;
563 	if (psl) {
564 		(void) ip6_mc_del_src(idev, group, pmc->sfmode,
565 			psl->sl_count, psl->sl_addr, 0);
566 		sock_kfree_s(sk, psl, IP6_SFLSIZE(psl->sl_max));
567 	} else
568 		(void) ip6_mc_del_src(idev, group, pmc->sfmode, 0, NULL, 0);
569 	pmc->sflist = newpsl;
570 	pmc->sfmode = gsf->gf_fmode;
571 	write_unlock_bh(&pmc->sflock);
572 	err = 0;
573 done:
574 	read_unlock_bh(&ipv6_sk_mc_lock);
575 	read_unlock_bh(&idev->lock);
576 	in6_dev_put(idev);
577 	dev_put(dev);
578 	if (leavegroup)
579 		err = ipv6_sock_mc_drop(sk, gsf->gf_interface, group);
580 	return err;
581 }
582 
583 int ip6_mc_msfget(struct sock *sk, struct group_filter *gsf,
584 	struct group_filter __user *optval, int __user *optlen)
585 {
586 	int err, i, count, copycount;
587 	struct in6_addr *group;
588 	struct ipv6_mc_socklist *pmc;
589 	struct inet6_dev *idev;
590 	struct net_device *dev;
591 	struct ipv6_pinfo *inet6 = inet6_sk(sk);
592 	struct ip6_sf_socklist *psl;
593 	struct net *net = sock_net(sk);
594 
595 	group = &((struct sockaddr_in6 *)&gsf->gf_group)->sin6_addr;
596 
597 	if (!ipv6_addr_is_multicast(group))
598 		return -EINVAL;
599 
600 	idev = ip6_mc_find_dev(net, group, gsf->gf_interface);
601 
602 	if (!idev)
603 		return -ENODEV;
604 
605 	dev = idev->dev;
606 
607 	err = -EADDRNOTAVAIL;
608 	/*
609 	 * changes to the ipv6_mc_list require the socket lock and
610 	 * a read lock on ip6_sk_mc_lock. We have the socket lock,
611 	 * so reading the list is safe.
612 	 */
613 
614 	for (pmc=inet6->ipv6_mc_list; pmc; pmc=pmc->next) {
615 		if (pmc->ifindex != gsf->gf_interface)
616 			continue;
617 		if (ipv6_addr_equal(group, &pmc->addr))
618 			break;
619 	}
620 	if (!pmc)		/* must have a prior join */
621 		goto done;
622 	gsf->gf_fmode = pmc->sfmode;
623 	psl = pmc->sflist;
624 	count = psl ? psl->sl_count : 0;
625 	read_unlock_bh(&idev->lock);
626 	in6_dev_put(idev);
627 	dev_put(dev);
628 
629 	copycount = count < gsf->gf_numsrc ? count : gsf->gf_numsrc;
630 	gsf->gf_numsrc = count;
631 	if (put_user(GROUP_FILTER_SIZE(copycount), optlen) ||
632 	    copy_to_user(optval, gsf, GROUP_FILTER_SIZE(0))) {
633 		return -EFAULT;
634 	}
635 	/* changes to psl require the socket lock, a read lock on
636 	 * on ipv6_sk_mc_lock and a write lock on pmc->sflock. We
637 	 * have the socket lock, so reading here is safe.
638 	 */
639 	for (i=0; i<copycount; i++) {
640 		struct sockaddr_in6 *psin6;
641 		struct sockaddr_storage ss;
642 
643 		psin6 = (struct sockaddr_in6 *)&ss;
644 		memset(&ss, 0, sizeof(ss));
645 		psin6->sin6_family = AF_INET6;
646 		psin6->sin6_addr = psl->sl_addr[i];
647 		if (copy_to_user(&optval->gf_slist[i], &ss, sizeof(ss)))
648 			return -EFAULT;
649 	}
650 	return 0;
651 done:
652 	read_unlock_bh(&idev->lock);
653 	in6_dev_put(idev);
654 	dev_put(dev);
655 	return err;
656 }
657 
658 int inet6_mc_check(struct sock *sk, const struct in6_addr *mc_addr,
659 		   const struct in6_addr *src_addr)
660 {
661 	struct ipv6_pinfo *np = inet6_sk(sk);
662 	struct ipv6_mc_socklist *mc;
663 	struct ip6_sf_socklist *psl;
664 	int rv = 1;
665 
666 	read_lock(&ipv6_sk_mc_lock);
667 	for (mc = np->ipv6_mc_list; mc; mc = mc->next) {
668 		if (ipv6_addr_equal(&mc->addr, mc_addr))
669 			break;
670 	}
671 	if (!mc) {
672 		read_unlock(&ipv6_sk_mc_lock);
673 		return 1;
674 	}
675 	read_lock(&mc->sflock);
676 	psl = mc->sflist;
677 	if (!psl) {
678 		rv = mc->sfmode == MCAST_EXCLUDE;
679 	} else {
680 		int i;
681 
682 		for (i=0; i<psl->sl_count; i++) {
683 			if (ipv6_addr_equal(&psl->sl_addr[i], src_addr))
684 				break;
685 		}
686 		if (mc->sfmode == MCAST_INCLUDE && i >= psl->sl_count)
687 			rv = 0;
688 		if (mc->sfmode == MCAST_EXCLUDE && i < psl->sl_count)
689 			rv = 0;
690 	}
691 	read_unlock(&mc->sflock);
692 	read_unlock(&ipv6_sk_mc_lock);
693 
694 	return rv;
695 }
696 
697 static void ma_put(struct ifmcaddr6 *mc)
698 {
699 	if (atomic_dec_and_test(&mc->mca_refcnt)) {
700 		in6_dev_put(mc->idev);
701 		kfree(mc);
702 	}
703 }
704 
705 static void igmp6_group_added(struct ifmcaddr6 *mc)
706 {
707 	struct net_device *dev = mc->idev->dev;
708 	char buf[MAX_ADDR_LEN];
709 
710 	spin_lock_bh(&mc->mca_lock);
711 	if (!(mc->mca_flags&MAF_LOADED)) {
712 		mc->mca_flags |= MAF_LOADED;
713 		if (ndisc_mc_map(&mc->mca_addr, buf, dev, 0) == 0)
714 			dev_mc_add(dev, buf, dev->addr_len, 0);
715 	}
716 	spin_unlock_bh(&mc->mca_lock);
717 
718 	if (!(dev->flags & IFF_UP) || (mc->mca_flags & MAF_NOREPORT))
719 		return;
720 
721 	if (MLD_V1_SEEN(mc->idev)) {
722 		igmp6_join_group(mc);
723 		return;
724 	}
725 	/* else v2 */
726 
727 	mc->mca_crcount = mc->idev->mc_qrv;
728 	mld_ifc_event(mc->idev);
729 }
730 
731 static void igmp6_group_dropped(struct ifmcaddr6 *mc)
732 {
733 	struct net_device *dev = mc->idev->dev;
734 	char buf[MAX_ADDR_LEN];
735 
736 	spin_lock_bh(&mc->mca_lock);
737 	if (mc->mca_flags&MAF_LOADED) {
738 		mc->mca_flags &= ~MAF_LOADED;
739 		if (ndisc_mc_map(&mc->mca_addr, buf, dev, 0) == 0)
740 			dev_mc_delete(dev, buf, dev->addr_len, 0);
741 	}
742 
743 	if (mc->mca_flags & MAF_NOREPORT)
744 		goto done;
745 	spin_unlock_bh(&mc->mca_lock);
746 
747 	if (!mc->idev->dead)
748 		igmp6_leave_group(mc);
749 
750 	spin_lock_bh(&mc->mca_lock);
751 	if (del_timer(&mc->mca_timer))
752 		atomic_dec(&mc->mca_refcnt);
753 done:
754 	ip6_mc_clear_src(mc);
755 	spin_unlock_bh(&mc->mca_lock);
756 }
757 
758 /*
759  * deleted ifmcaddr6 manipulation
760  */
761 static void mld_add_delrec(struct inet6_dev *idev, struct ifmcaddr6 *im)
762 {
763 	struct ifmcaddr6 *pmc;
764 
765 	/* this is an "ifmcaddr6" for convenience; only the fields below
766 	 * are actually used. In particular, the refcnt and users are not
767 	 * used for management of the delete list. Using the same structure
768 	 * for deleted items allows change reports to use common code with
769 	 * non-deleted or query-response MCA's.
770 	 */
771 	pmc = kzalloc(sizeof(*pmc), GFP_ATOMIC);
772 	if (!pmc)
773 		return;
774 
775 	spin_lock_bh(&im->mca_lock);
776 	spin_lock_init(&pmc->mca_lock);
777 	pmc->idev = im->idev;
778 	in6_dev_hold(idev);
779 	pmc->mca_addr = im->mca_addr;
780 	pmc->mca_crcount = idev->mc_qrv;
781 	pmc->mca_sfmode = im->mca_sfmode;
782 	if (pmc->mca_sfmode == MCAST_INCLUDE) {
783 		struct ip6_sf_list *psf;
784 
785 		pmc->mca_tomb = im->mca_tomb;
786 		pmc->mca_sources = im->mca_sources;
787 		im->mca_tomb = im->mca_sources = NULL;
788 		for (psf=pmc->mca_sources; psf; psf=psf->sf_next)
789 			psf->sf_crcount = pmc->mca_crcount;
790 	}
791 	spin_unlock_bh(&im->mca_lock);
792 
793 	write_lock_bh(&idev->mc_lock);
794 	pmc->next = idev->mc_tomb;
795 	idev->mc_tomb = pmc;
796 	write_unlock_bh(&idev->mc_lock);
797 }
798 
799 static void mld_del_delrec(struct inet6_dev *idev, struct in6_addr *pmca)
800 {
801 	struct ifmcaddr6 *pmc, *pmc_prev;
802 	struct ip6_sf_list *psf, *psf_next;
803 
804 	write_lock_bh(&idev->mc_lock);
805 	pmc_prev = NULL;
806 	for (pmc=idev->mc_tomb; pmc; pmc=pmc->next) {
807 		if (ipv6_addr_equal(&pmc->mca_addr, pmca))
808 			break;
809 		pmc_prev = pmc;
810 	}
811 	if (pmc) {
812 		if (pmc_prev)
813 			pmc_prev->next = pmc->next;
814 		else
815 			idev->mc_tomb = pmc->next;
816 	}
817 	write_unlock_bh(&idev->mc_lock);
818 	if (pmc) {
819 		for (psf=pmc->mca_tomb; psf; psf=psf_next) {
820 			psf_next = psf->sf_next;
821 			kfree(psf);
822 		}
823 		in6_dev_put(pmc->idev);
824 		kfree(pmc);
825 	}
826 }
827 
828 static void mld_clear_delrec(struct inet6_dev *idev)
829 {
830 	struct ifmcaddr6 *pmc, *nextpmc;
831 
832 	write_lock_bh(&idev->mc_lock);
833 	pmc = idev->mc_tomb;
834 	idev->mc_tomb = NULL;
835 	write_unlock_bh(&idev->mc_lock);
836 
837 	for (; pmc; pmc = nextpmc) {
838 		nextpmc = pmc->next;
839 		ip6_mc_clear_src(pmc);
840 		in6_dev_put(pmc->idev);
841 		kfree(pmc);
842 	}
843 
844 	/* clear dead sources, too */
845 	read_lock_bh(&idev->lock);
846 	for (pmc=idev->mc_list; pmc; pmc=pmc->next) {
847 		struct ip6_sf_list *psf, *psf_next;
848 
849 		spin_lock_bh(&pmc->mca_lock);
850 		psf = pmc->mca_tomb;
851 		pmc->mca_tomb = NULL;
852 		spin_unlock_bh(&pmc->mca_lock);
853 		for (; psf; psf=psf_next) {
854 			psf_next = psf->sf_next;
855 			kfree(psf);
856 		}
857 	}
858 	read_unlock_bh(&idev->lock);
859 }
860 
861 
862 /*
863  *	device multicast group inc (add if not found)
864  */
865 int ipv6_dev_mc_inc(struct net_device *dev, const struct in6_addr *addr)
866 {
867 	struct ifmcaddr6 *mc;
868 	struct inet6_dev *idev;
869 
870 	idev = in6_dev_get(dev);
871 
872 	if (idev == NULL)
873 		return -EINVAL;
874 
875 	write_lock_bh(&idev->lock);
876 	if (idev->dead) {
877 		write_unlock_bh(&idev->lock);
878 		in6_dev_put(idev);
879 		return -ENODEV;
880 	}
881 
882 	for (mc = idev->mc_list; mc; mc = mc->next) {
883 		if (ipv6_addr_equal(&mc->mca_addr, addr)) {
884 			mc->mca_users++;
885 			write_unlock_bh(&idev->lock);
886 			ip6_mc_add_src(idev, &mc->mca_addr, MCAST_EXCLUDE, 0,
887 				NULL, 0);
888 			in6_dev_put(idev);
889 			return 0;
890 		}
891 	}
892 
893 	/*
894 	 *	not found: create a new one.
895 	 */
896 
897 	mc = kzalloc(sizeof(struct ifmcaddr6), GFP_ATOMIC);
898 
899 	if (mc == NULL) {
900 		write_unlock_bh(&idev->lock);
901 		in6_dev_put(idev);
902 		return -ENOMEM;
903 	}
904 
905 	setup_timer(&mc->mca_timer, igmp6_timer_handler, (unsigned long)mc);
906 
907 	ipv6_addr_copy(&mc->mca_addr, addr);
908 	mc->idev = idev;
909 	mc->mca_users = 1;
910 	/* mca_stamp should be updated upon changes */
911 	mc->mca_cstamp = mc->mca_tstamp = jiffies;
912 	atomic_set(&mc->mca_refcnt, 2);
913 	spin_lock_init(&mc->mca_lock);
914 
915 	/* initial mode is (EX, empty) */
916 	mc->mca_sfmode = MCAST_EXCLUDE;
917 	mc->mca_sfcount[MCAST_EXCLUDE] = 1;
918 
919 	if (ipv6_addr_is_ll_all_nodes(&mc->mca_addr) ||
920 	    IPV6_ADDR_MC_SCOPE(&mc->mca_addr) < IPV6_ADDR_SCOPE_LINKLOCAL)
921 		mc->mca_flags |= MAF_NOREPORT;
922 
923 	mc->next = idev->mc_list;
924 	idev->mc_list = mc;
925 	write_unlock_bh(&idev->lock);
926 
927 	mld_del_delrec(idev, &mc->mca_addr);
928 	igmp6_group_added(mc);
929 	ma_put(mc);
930 	return 0;
931 }
932 
933 /*
934  *	device multicast group del
935  */
936 int __ipv6_dev_mc_dec(struct inet6_dev *idev, const struct in6_addr *addr)
937 {
938 	struct ifmcaddr6 *ma, **map;
939 
940 	write_lock_bh(&idev->lock);
941 	for (map = &idev->mc_list; (ma=*map) != NULL; map = &ma->next) {
942 		if (ipv6_addr_equal(&ma->mca_addr, addr)) {
943 			if (--ma->mca_users == 0) {
944 				*map = ma->next;
945 				write_unlock_bh(&idev->lock);
946 
947 				igmp6_group_dropped(ma);
948 
949 				ma_put(ma);
950 				return 0;
951 			}
952 			write_unlock_bh(&idev->lock);
953 			return 0;
954 		}
955 	}
956 	write_unlock_bh(&idev->lock);
957 
958 	return -ENOENT;
959 }
960 
961 int ipv6_dev_mc_dec(struct net_device *dev, const struct in6_addr *addr)
962 {
963 	struct inet6_dev *idev = in6_dev_get(dev);
964 	int err;
965 
966 	if (!idev)
967 		return -ENODEV;
968 
969 	err = __ipv6_dev_mc_dec(idev, addr);
970 
971 	in6_dev_put(idev);
972 
973 	return err;
974 }
975 
976 /*
977  * identify MLD packets for MLD filter exceptions
978  */
979 int ipv6_is_mld(struct sk_buff *skb, int nexthdr)
980 {
981 	struct icmp6hdr *pic;
982 
983 	if (nexthdr != IPPROTO_ICMPV6)
984 		return 0;
985 
986 	if (!pskb_may_pull(skb, sizeof(struct icmp6hdr)))
987 		return 0;
988 
989 	pic = icmp6_hdr(skb);
990 
991 	switch (pic->icmp6_type) {
992 	case ICMPV6_MGM_QUERY:
993 	case ICMPV6_MGM_REPORT:
994 	case ICMPV6_MGM_REDUCTION:
995 	case ICMPV6_MLD2_REPORT:
996 		return 1;
997 	default:
998 		break;
999 	}
1000 	return 0;
1001 }
1002 
1003 /*
1004  *	check if the interface/address pair is valid
1005  */
1006 int ipv6_chk_mcast_addr(struct net_device *dev, const struct in6_addr *group,
1007 			const struct in6_addr *src_addr)
1008 {
1009 	struct inet6_dev *idev;
1010 	struct ifmcaddr6 *mc;
1011 	int rv = 0;
1012 
1013 	idev = in6_dev_get(dev);
1014 	if (idev) {
1015 		read_lock_bh(&idev->lock);
1016 		for (mc = idev->mc_list; mc; mc=mc->next) {
1017 			if (ipv6_addr_equal(&mc->mca_addr, group))
1018 				break;
1019 		}
1020 		if (mc) {
1021 			if (src_addr && !ipv6_addr_any(src_addr)) {
1022 				struct ip6_sf_list *psf;
1023 
1024 				spin_lock_bh(&mc->mca_lock);
1025 				for (psf=mc->mca_sources;psf;psf=psf->sf_next) {
1026 					if (ipv6_addr_equal(&psf->sf_addr, src_addr))
1027 						break;
1028 				}
1029 				if (psf)
1030 					rv = psf->sf_count[MCAST_INCLUDE] ||
1031 						psf->sf_count[MCAST_EXCLUDE] !=
1032 						mc->mca_sfcount[MCAST_EXCLUDE];
1033 				else
1034 					rv = mc->mca_sfcount[MCAST_EXCLUDE] !=0;
1035 				spin_unlock_bh(&mc->mca_lock);
1036 			} else
1037 				rv = 1; /* don't filter unspecified source */
1038 		}
1039 		read_unlock_bh(&idev->lock);
1040 		in6_dev_put(idev);
1041 	}
1042 	return rv;
1043 }
1044 
1045 static void mld_gq_start_timer(struct inet6_dev *idev)
1046 {
1047 	int tv = net_random() % idev->mc_maxdelay;
1048 
1049 	idev->mc_gq_running = 1;
1050 	if (!mod_timer(&idev->mc_gq_timer, jiffies+tv+2))
1051 		in6_dev_hold(idev);
1052 }
1053 
1054 static void mld_ifc_start_timer(struct inet6_dev *idev, int delay)
1055 {
1056 	int tv = net_random() % delay;
1057 
1058 	if (!mod_timer(&idev->mc_ifc_timer, jiffies+tv+2))
1059 		in6_dev_hold(idev);
1060 }
1061 
1062 /*
1063  *	IGMP handling (alias multicast ICMPv6 messages)
1064  */
1065 
1066 static void igmp6_group_queried(struct ifmcaddr6 *ma, unsigned long resptime)
1067 {
1068 	unsigned long delay = resptime;
1069 
1070 	/* Do not start timer for these addresses */
1071 	if (ipv6_addr_is_ll_all_nodes(&ma->mca_addr) ||
1072 	    IPV6_ADDR_MC_SCOPE(&ma->mca_addr) < IPV6_ADDR_SCOPE_LINKLOCAL)
1073 		return;
1074 
1075 	if (del_timer(&ma->mca_timer)) {
1076 		atomic_dec(&ma->mca_refcnt);
1077 		delay = ma->mca_timer.expires - jiffies;
1078 	}
1079 
1080 	if (delay >= resptime) {
1081 		if (resptime)
1082 			delay = net_random() % resptime;
1083 		else
1084 			delay = 1;
1085 	}
1086 	ma->mca_timer.expires = jiffies + delay;
1087 	if (!mod_timer(&ma->mca_timer, jiffies + delay))
1088 		atomic_inc(&ma->mca_refcnt);
1089 	ma->mca_flags |= MAF_TIMER_RUNNING;
1090 }
1091 
1092 /* mark EXCLUDE-mode sources */
1093 static int mld_xmarksources(struct ifmcaddr6 *pmc, int nsrcs,
1094 	struct in6_addr *srcs)
1095 {
1096 	struct ip6_sf_list *psf;
1097 	int i, scount;
1098 
1099 	scount = 0;
1100 	for (psf=pmc->mca_sources; psf; psf=psf->sf_next) {
1101 		if (scount == nsrcs)
1102 			break;
1103 		for (i=0; i<nsrcs; i++) {
1104 			/* skip inactive filters */
1105 			if (pmc->mca_sfcount[MCAST_INCLUDE] ||
1106 			    pmc->mca_sfcount[MCAST_EXCLUDE] !=
1107 			    psf->sf_count[MCAST_EXCLUDE])
1108 				continue;
1109 			if (ipv6_addr_equal(&srcs[i], &psf->sf_addr)) {
1110 				scount++;
1111 				break;
1112 			}
1113 		}
1114 	}
1115 	pmc->mca_flags &= ~MAF_GSQUERY;
1116 	if (scount == nsrcs)	/* all sources excluded */
1117 		return 0;
1118 	return 1;
1119 }
1120 
1121 static int mld_marksources(struct ifmcaddr6 *pmc, int nsrcs,
1122 	struct in6_addr *srcs)
1123 {
1124 	struct ip6_sf_list *psf;
1125 	int i, scount;
1126 
1127 	if (pmc->mca_sfmode == MCAST_EXCLUDE)
1128 		return mld_xmarksources(pmc, nsrcs, srcs);
1129 
1130 	/* mark INCLUDE-mode sources */
1131 
1132 	scount = 0;
1133 	for (psf=pmc->mca_sources; psf; psf=psf->sf_next) {
1134 		if (scount == nsrcs)
1135 			break;
1136 		for (i=0; i<nsrcs; i++) {
1137 			if (ipv6_addr_equal(&srcs[i], &psf->sf_addr)) {
1138 				psf->sf_gsresp = 1;
1139 				scount++;
1140 				break;
1141 			}
1142 		}
1143 	}
1144 	if (!scount) {
1145 		pmc->mca_flags &= ~MAF_GSQUERY;
1146 		return 0;
1147 	}
1148 	pmc->mca_flags |= MAF_GSQUERY;
1149 	return 1;
1150 }
1151 
1152 int igmp6_event_query(struct sk_buff *skb)
1153 {
1154 	struct mld2_query *mlh2 = NULL;
1155 	struct ifmcaddr6 *ma;
1156 	struct in6_addr *group;
1157 	unsigned long max_delay;
1158 	struct inet6_dev *idev;
1159 	struct icmp6hdr *hdr;
1160 	int group_type;
1161 	int mark = 0;
1162 	int len;
1163 
1164 	if (!pskb_may_pull(skb, sizeof(struct in6_addr)))
1165 		return -EINVAL;
1166 
1167 	/* compute payload length excluding extension headers */
1168 	len = ntohs(ipv6_hdr(skb)->payload_len) + sizeof(struct ipv6hdr);
1169 	len -= skb_network_header_len(skb);
1170 
1171 	/* Drop queries with not link local source */
1172 	if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL))
1173 		return -EINVAL;
1174 
1175 	idev = in6_dev_get(skb->dev);
1176 
1177 	if (idev == NULL)
1178 		return 0;
1179 
1180 	hdr = icmp6_hdr(skb);
1181 	group = (struct in6_addr *) (hdr + 1);
1182 	group_type = ipv6_addr_type(group);
1183 
1184 	if (group_type != IPV6_ADDR_ANY &&
1185 	    !(group_type&IPV6_ADDR_MULTICAST)) {
1186 		in6_dev_put(idev);
1187 		return -EINVAL;
1188 	}
1189 
1190 	if (len == 24) {
1191 		int switchback;
1192 		/* MLDv1 router present */
1193 
1194 		/* Translate milliseconds to jiffies */
1195 		max_delay = (ntohs(hdr->icmp6_maxdelay)*HZ)/1000;
1196 
1197 		switchback = (idev->mc_qrv + 1) * max_delay;
1198 		idev->mc_v1_seen = jiffies + switchback;
1199 
1200 		/* cancel the interface change timer */
1201 		idev->mc_ifc_count = 0;
1202 		if (del_timer(&idev->mc_ifc_timer))
1203 			__in6_dev_put(idev);
1204 		/* clear deleted report items */
1205 		mld_clear_delrec(idev);
1206 	} else if (len >= 28) {
1207 		int srcs_offset = sizeof(struct mld2_query) -
1208 				  sizeof(struct icmp6hdr);
1209 		if (!pskb_may_pull(skb, srcs_offset)) {
1210 			in6_dev_put(idev);
1211 			return -EINVAL;
1212 		}
1213 		mlh2 = (struct mld2_query *)skb_transport_header(skb);
1214 		max_delay = (MLDV2_MRC(ntohs(mlh2->mrc))*HZ)/1000;
1215 		if (!max_delay)
1216 			max_delay = 1;
1217 		idev->mc_maxdelay = max_delay;
1218 		if (mlh2->qrv)
1219 			idev->mc_qrv = mlh2->qrv;
1220 		if (group_type == IPV6_ADDR_ANY) { /* general query */
1221 			if (mlh2->nsrcs) {
1222 				in6_dev_put(idev);
1223 				return -EINVAL; /* no sources allowed */
1224 			}
1225 			mld_gq_start_timer(idev);
1226 			in6_dev_put(idev);
1227 			return 0;
1228 		}
1229 		/* mark sources to include, if group & source-specific */
1230 		if (mlh2->nsrcs != 0) {
1231 			if (!pskb_may_pull(skb, srcs_offset +
1232 			    ntohs(mlh2->nsrcs) * sizeof(struct in6_addr))) {
1233 				in6_dev_put(idev);
1234 				return -EINVAL;
1235 			}
1236 			mlh2 = (struct mld2_query *)skb_transport_header(skb);
1237 			mark = 1;
1238 		}
1239 	} else {
1240 		in6_dev_put(idev);
1241 		return -EINVAL;
1242 	}
1243 
1244 	read_lock_bh(&idev->lock);
1245 	if (group_type == IPV6_ADDR_ANY) {
1246 		for (ma = idev->mc_list; ma; ma=ma->next) {
1247 			spin_lock_bh(&ma->mca_lock);
1248 			igmp6_group_queried(ma, max_delay);
1249 			spin_unlock_bh(&ma->mca_lock);
1250 		}
1251 	} else {
1252 		for (ma = idev->mc_list; ma; ma=ma->next) {
1253 			if (!ipv6_addr_equal(group, &ma->mca_addr))
1254 				continue;
1255 			spin_lock_bh(&ma->mca_lock);
1256 			if (ma->mca_flags & MAF_TIMER_RUNNING) {
1257 				/* gsquery <- gsquery && mark */
1258 				if (!mark)
1259 					ma->mca_flags &= ~MAF_GSQUERY;
1260 			} else {
1261 				/* gsquery <- mark */
1262 				if (mark)
1263 					ma->mca_flags |= MAF_GSQUERY;
1264 				else
1265 					ma->mca_flags &= ~MAF_GSQUERY;
1266 			}
1267 			if (!(ma->mca_flags & MAF_GSQUERY) ||
1268 			    mld_marksources(ma, ntohs(mlh2->nsrcs), mlh2->srcs))
1269 				igmp6_group_queried(ma, max_delay);
1270 			spin_unlock_bh(&ma->mca_lock);
1271 			break;
1272 		}
1273 	}
1274 	read_unlock_bh(&idev->lock);
1275 	in6_dev_put(idev);
1276 
1277 	return 0;
1278 }
1279 
1280 
1281 int igmp6_event_report(struct sk_buff *skb)
1282 {
1283 	struct ifmcaddr6 *ma;
1284 	struct in6_addr *addrp;
1285 	struct inet6_dev *idev;
1286 	struct icmp6hdr *hdr;
1287 	int addr_type;
1288 
1289 	/* Our own report looped back. Ignore it. */
1290 	if (skb->pkt_type == PACKET_LOOPBACK)
1291 		return 0;
1292 
1293 	/* send our report if the MC router may not have heard this report */
1294 	if (skb->pkt_type != PACKET_MULTICAST &&
1295 	    skb->pkt_type != PACKET_BROADCAST)
1296 		return 0;
1297 
1298 	if (!pskb_may_pull(skb, sizeof(struct in6_addr)))
1299 		return -EINVAL;
1300 
1301 	hdr = icmp6_hdr(skb);
1302 
1303 	/* Drop reports with not link local source */
1304 	addr_type = ipv6_addr_type(&ipv6_hdr(skb)->saddr);
1305 	if (addr_type != IPV6_ADDR_ANY &&
1306 	    !(addr_type&IPV6_ADDR_LINKLOCAL))
1307 		return -EINVAL;
1308 
1309 	addrp = (struct in6_addr *) (hdr + 1);
1310 
1311 	idev = in6_dev_get(skb->dev);
1312 	if (idev == NULL)
1313 		return -ENODEV;
1314 
1315 	/*
1316 	 *	Cancel the timer for this group
1317 	 */
1318 
1319 	read_lock_bh(&idev->lock);
1320 	for (ma = idev->mc_list; ma; ma=ma->next) {
1321 		if (ipv6_addr_equal(&ma->mca_addr, addrp)) {
1322 			spin_lock(&ma->mca_lock);
1323 			if (del_timer(&ma->mca_timer))
1324 				atomic_dec(&ma->mca_refcnt);
1325 			ma->mca_flags &= ~(MAF_LAST_REPORTER|MAF_TIMER_RUNNING);
1326 			spin_unlock(&ma->mca_lock);
1327 			break;
1328 		}
1329 	}
1330 	read_unlock_bh(&idev->lock);
1331 	in6_dev_put(idev);
1332 	return 0;
1333 }
1334 
1335 static int is_in(struct ifmcaddr6 *pmc, struct ip6_sf_list *psf, int type,
1336 	int gdeleted, int sdeleted)
1337 {
1338 	switch (type) {
1339 	case MLD2_MODE_IS_INCLUDE:
1340 	case MLD2_MODE_IS_EXCLUDE:
1341 		if (gdeleted || sdeleted)
1342 			return 0;
1343 		if (!((pmc->mca_flags & MAF_GSQUERY) && !psf->sf_gsresp)) {
1344 			if (pmc->mca_sfmode == MCAST_INCLUDE)
1345 				return 1;
1346 			/* don't include if this source is excluded
1347 			 * in all filters
1348 			 */
1349 			if (psf->sf_count[MCAST_INCLUDE])
1350 				return type == MLD2_MODE_IS_INCLUDE;
1351 			return pmc->mca_sfcount[MCAST_EXCLUDE] ==
1352 				psf->sf_count[MCAST_EXCLUDE];
1353 		}
1354 		return 0;
1355 	case MLD2_CHANGE_TO_INCLUDE:
1356 		if (gdeleted || sdeleted)
1357 			return 0;
1358 		return psf->sf_count[MCAST_INCLUDE] != 0;
1359 	case MLD2_CHANGE_TO_EXCLUDE:
1360 		if (gdeleted || sdeleted)
1361 			return 0;
1362 		if (pmc->mca_sfcount[MCAST_EXCLUDE] == 0 ||
1363 		    psf->sf_count[MCAST_INCLUDE])
1364 			return 0;
1365 		return pmc->mca_sfcount[MCAST_EXCLUDE] ==
1366 			psf->sf_count[MCAST_EXCLUDE];
1367 	case MLD2_ALLOW_NEW_SOURCES:
1368 		if (gdeleted || !psf->sf_crcount)
1369 			return 0;
1370 		return (pmc->mca_sfmode == MCAST_INCLUDE) ^ sdeleted;
1371 	case MLD2_BLOCK_OLD_SOURCES:
1372 		if (pmc->mca_sfmode == MCAST_INCLUDE)
1373 			return gdeleted || (psf->sf_crcount && sdeleted);
1374 		return psf->sf_crcount && !gdeleted && !sdeleted;
1375 	}
1376 	return 0;
1377 }
1378 
1379 static int
1380 mld_scount(struct ifmcaddr6 *pmc, int type, int gdeleted, int sdeleted)
1381 {
1382 	struct ip6_sf_list *psf;
1383 	int scount = 0;
1384 
1385 	for (psf=pmc->mca_sources; psf; psf=psf->sf_next) {
1386 		if (!is_in(pmc, psf, type, gdeleted, sdeleted))
1387 			continue;
1388 		scount++;
1389 	}
1390 	return scount;
1391 }
1392 
1393 static struct sk_buff *mld_newpack(struct net_device *dev, int size)
1394 {
1395 	struct net *net = dev_net(dev);
1396 	struct sock *sk = net->ipv6.igmp_sk;
1397 	struct sk_buff *skb;
1398 	struct mld2_report *pmr;
1399 	struct in6_addr addr_buf;
1400 	const struct in6_addr *saddr;
1401 	int err;
1402 	u8 ra[8] = { IPPROTO_ICMPV6, 0,
1403 		     IPV6_TLV_ROUTERALERT, 2, 0, 0,
1404 		     IPV6_TLV_PADN, 0 };
1405 
1406 	/* we assume size > sizeof(ra) here */
1407 	skb = sock_alloc_send_skb(sk, size + LL_ALLOCATED_SPACE(dev), 1, &err);
1408 
1409 	if (!skb)
1410 		return NULL;
1411 
1412 	skb_reserve(skb, LL_RESERVED_SPACE(dev));
1413 
1414 	if (ipv6_get_lladdr(dev, &addr_buf, IFA_F_TENTATIVE)) {
1415 		/* <draft-ietf-magma-mld-source-05.txt>:
1416 		 * use unspecified address as the source address
1417 		 * when a valid link-local address is not available.
1418 		 */
1419 		saddr = &in6addr_any;
1420 	} else
1421 		saddr = &addr_buf;
1422 
1423 	ip6_nd_hdr(sk, skb, dev, saddr, &mld2_all_mcr, NEXTHDR_HOP, 0);
1424 
1425 	memcpy(skb_put(skb, sizeof(ra)), ra, sizeof(ra));
1426 
1427 	skb_set_transport_header(skb, skb_tail_pointer(skb) - skb->data);
1428 	skb_put(skb, sizeof(*pmr));
1429 	pmr = (struct mld2_report *)skb_transport_header(skb);
1430 	pmr->type = ICMPV6_MLD2_REPORT;
1431 	pmr->resv1 = 0;
1432 	pmr->csum = 0;
1433 	pmr->resv2 = 0;
1434 	pmr->ngrec = 0;
1435 	return skb;
1436 }
1437 
1438 static void mld_sendpack(struct sk_buff *skb)
1439 {
1440 	struct ipv6hdr *pip6 = ipv6_hdr(skb);
1441 	struct mld2_report *pmr =
1442 			      (struct mld2_report *)skb_transport_header(skb);
1443 	int payload_len, mldlen;
1444 	struct inet6_dev *idev = in6_dev_get(skb->dev);
1445 	struct net *net = dev_net(skb->dev);
1446 	int err;
1447 	struct flowi fl;
1448 
1449 	IP6_INC_STATS(idev, IPSTATS_MIB_OUTREQUESTS);
1450 	payload_len = (skb->tail - skb->network_header) - sizeof(*pip6);
1451 	mldlen = skb->tail - skb->transport_header;
1452 	pip6->payload_len = htons(payload_len);
1453 
1454 	pmr->csum = csum_ipv6_magic(&pip6->saddr, &pip6->daddr, mldlen,
1455 		IPPROTO_ICMPV6, csum_partial(skb_transport_header(skb),
1456 					     mldlen, 0));
1457 
1458 	skb->dst = icmp6_dst_alloc(skb->dev, NULL, &ipv6_hdr(skb)->daddr);
1459 
1460 	if (!skb->dst) {
1461 		err = -ENOMEM;
1462 		goto err_out;
1463 	}
1464 
1465 	icmpv6_flow_init(net->ipv6.igmp_sk, &fl, ICMPV6_MLD2_REPORT,
1466 			 &ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr,
1467 			 skb->dev->ifindex);
1468 
1469 	err = xfrm_lookup(&skb->dst, &fl, NULL, 0);
1470 	if (err)
1471 		goto err_out;
1472 
1473 	err = NF_HOOK(PF_INET6, NF_INET_LOCAL_OUT, skb, NULL, skb->dev,
1474 		      dst_output);
1475 out:
1476 	if (!err) {
1477 		ICMP6MSGOUT_INC_STATS_BH(idev, ICMPV6_MLD2_REPORT);
1478 		ICMP6_INC_STATS_BH(idev, ICMP6_MIB_OUTMSGS);
1479 		IP6_INC_STATS_BH(idev, IPSTATS_MIB_OUTMCASTPKTS);
1480 	} else
1481 		IP6_INC_STATS_BH(idev, IPSTATS_MIB_OUTDISCARDS);
1482 
1483 	if (likely(idev != NULL))
1484 		in6_dev_put(idev);
1485 	return;
1486 
1487 err_out:
1488 	kfree_skb(skb);
1489 	goto out;
1490 }
1491 
1492 static int grec_size(struct ifmcaddr6 *pmc, int type, int gdel, int sdel)
1493 {
1494 	return sizeof(struct mld2_grec) + 16 * mld_scount(pmc,type,gdel,sdel);
1495 }
1496 
1497 static struct sk_buff *add_grhead(struct sk_buff *skb, struct ifmcaddr6 *pmc,
1498 	int type, struct mld2_grec **ppgr)
1499 {
1500 	struct net_device *dev = pmc->idev->dev;
1501 	struct mld2_report *pmr;
1502 	struct mld2_grec *pgr;
1503 
1504 	if (!skb)
1505 		skb = mld_newpack(dev, dev->mtu);
1506 	if (!skb)
1507 		return NULL;
1508 	pgr = (struct mld2_grec *)skb_put(skb, sizeof(struct mld2_grec));
1509 	pgr->grec_type = type;
1510 	pgr->grec_auxwords = 0;
1511 	pgr->grec_nsrcs = 0;
1512 	pgr->grec_mca = pmc->mca_addr;	/* structure copy */
1513 	pmr = (struct mld2_report *)skb_transport_header(skb);
1514 	pmr->ngrec = htons(ntohs(pmr->ngrec)+1);
1515 	*ppgr = pgr;
1516 	return skb;
1517 }
1518 
1519 #define AVAILABLE(skb) ((skb) ? ((skb)->dev ? (skb)->dev->mtu - (skb)->len : \
1520 	skb_tailroom(skb)) : 0)
1521 
1522 static struct sk_buff *add_grec(struct sk_buff *skb, struct ifmcaddr6 *pmc,
1523 	int type, int gdeleted, int sdeleted)
1524 {
1525 	struct net_device *dev = pmc->idev->dev;
1526 	struct mld2_report *pmr;
1527 	struct mld2_grec *pgr = NULL;
1528 	struct ip6_sf_list *psf, *psf_next, *psf_prev, **psf_list;
1529 	int scount, stotal, first, isquery, truncate;
1530 
1531 	if (pmc->mca_flags & MAF_NOREPORT)
1532 		return skb;
1533 
1534 	isquery = type == MLD2_MODE_IS_INCLUDE ||
1535 		  type == MLD2_MODE_IS_EXCLUDE;
1536 	truncate = type == MLD2_MODE_IS_EXCLUDE ||
1537 		    type == MLD2_CHANGE_TO_EXCLUDE;
1538 
1539 	stotal = scount = 0;
1540 
1541 	psf_list = sdeleted ? &pmc->mca_tomb : &pmc->mca_sources;
1542 
1543 	if (!*psf_list)
1544 		goto empty_source;
1545 
1546 	pmr = skb ? (struct mld2_report *)skb_transport_header(skb) : NULL;
1547 
1548 	/* EX and TO_EX get a fresh packet, if needed */
1549 	if (truncate) {
1550 		if (pmr && pmr->ngrec &&
1551 		    AVAILABLE(skb) < grec_size(pmc, type, gdeleted, sdeleted)) {
1552 			if (skb)
1553 				mld_sendpack(skb);
1554 			skb = mld_newpack(dev, dev->mtu);
1555 		}
1556 	}
1557 	first = 1;
1558 	psf_prev = NULL;
1559 	for (psf=*psf_list; psf; psf=psf_next) {
1560 		struct in6_addr *psrc;
1561 
1562 		psf_next = psf->sf_next;
1563 
1564 		if (!is_in(pmc, psf, type, gdeleted, sdeleted)) {
1565 			psf_prev = psf;
1566 			continue;
1567 		}
1568 
1569 		/* clear marks on query responses */
1570 		if (isquery)
1571 			psf->sf_gsresp = 0;
1572 
1573 		if (AVAILABLE(skb) < sizeof(*psrc) +
1574 		    first*sizeof(struct mld2_grec)) {
1575 			if (truncate && !first)
1576 				break;	 /* truncate these */
1577 			if (pgr)
1578 				pgr->grec_nsrcs = htons(scount);
1579 			if (skb)
1580 				mld_sendpack(skb);
1581 			skb = mld_newpack(dev, dev->mtu);
1582 			first = 1;
1583 			scount = 0;
1584 		}
1585 		if (first) {
1586 			skb = add_grhead(skb, pmc, type, &pgr);
1587 			first = 0;
1588 		}
1589 		if (!skb)
1590 			return NULL;
1591 		psrc = (struct in6_addr *)skb_put(skb, sizeof(*psrc));
1592 		*psrc = psf->sf_addr;
1593 		scount++; stotal++;
1594 		if ((type == MLD2_ALLOW_NEW_SOURCES ||
1595 		     type == MLD2_BLOCK_OLD_SOURCES) && psf->sf_crcount) {
1596 			psf->sf_crcount--;
1597 			if ((sdeleted || gdeleted) && psf->sf_crcount == 0) {
1598 				if (psf_prev)
1599 					psf_prev->sf_next = psf->sf_next;
1600 				else
1601 					*psf_list = psf->sf_next;
1602 				kfree(psf);
1603 				continue;
1604 			}
1605 		}
1606 		psf_prev = psf;
1607 	}
1608 
1609 empty_source:
1610 	if (!stotal) {
1611 		if (type == MLD2_ALLOW_NEW_SOURCES ||
1612 		    type == MLD2_BLOCK_OLD_SOURCES)
1613 			return skb;
1614 		if (pmc->mca_crcount || isquery) {
1615 			/* make sure we have room for group header */
1616 			if (skb && AVAILABLE(skb) < sizeof(struct mld2_grec)) {
1617 				mld_sendpack(skb);
1618 				skb = NULL; /* add_grhead will get a new one */
1619 			}
1620 			skb = add_grhead(skb, pmc, type, &pgr);
1621 		}
1622 	}
1623 	if (pgr)
1624 		pgr->grec_nsrcs = htons(scount);
1625 
1626 	if (isquery)
1627 		pmc->mca_flags &= ~MAF_GSQUERY;	/* clear query state */
1628 	return skb;
1629 }
1630 
1631 static void mld_send_report(struct inet6_dev *idev, struct ifmcaddr6 *pmc)
1632 {
1633 	struct sk_buff *skb = NULL;
1634 	int type;
1635 
1636 	if (!pmc) {
1637 		read_lock_bh(&idev->lock);
1638 		for (pmc=idev->mc_list; pmc; pmc=pmc->next) {
1639 			if (pmc->mca_flags & MAF_NOREPORT)
1640 				continue;
1641 			spin_lock_bh(&pmc->mca_lock);
1642 			if (pmc->mca_sfcount[MCAST_EXCLUDE])
1643 				type = MLD2_MODE_IS_EXCLUDE;
1644 			else
1645 				type = MLD2_MODE_IS_INCLUDE;
1646 			skb = add_grec(skb, pmc, type, 0, 0);
1647 			spin_unlock_bh(&pmc->mca_lock);
1648 		}
1649 		read_unlock_bh(&idev->lock);
1650 	} else {
1651 		spin_lock_bh(&pmc->mca_lock);
1652 		if (pmc->mca_sfcount[MCAST_EXCLUDE])
1653 			type = MLD2_MODE_IS_EXCLUDE;
1654 		else
1655 			type = MLD2_MODE_IS_INCLUDE;
1656 		skb = add_grec(skb, pmc, type, 0, 0);
1657 		spin_unlock_bh(&pmc->mca_lock);
1658 	}
1659 	if (skb)
1660 		mld_sendpack(skb);
1661 }
1662 
1663 /*
1664  * remove zero-count source records from a source filter list
1665  */
1666 static void mld_clear_zeros(struct ip6_sf_list **ppsf)
1667 {
1668 	struct ip6_sf_list *psf_prev, *psf_next, *psf;
1669 
1670 	psf_prev = NULL;
1671 	for (psf=*ppsf; psf; psf = psf_next) {
1672 		psf_next = psf->sf_next;
1673 		if (psf->sf_crcount == 0) {
1674 			if (psf_prev)
1675 				psf_prev->sf_next = psf->sf_next;
1676 			else
1677 				*ppsf = psf->sf_next;
1678 			kfree(psf);
1679 		} else
1680 			psf_prev = psf;
1681 	}
1682 }
1683 
1684 static void mld_send_cr(struct inet6_dev *idev)
1685 {
1686 	struct ifmcaddr6 *pmc, *pmc_prev, *pmc_next;
1687 	struct sk_buff *skb = NULL;
1688 	int type, dtype;
1689 
1690 	read_lock_bh(&idev->lock);
1691 	write_lock_bh(&idev->mc_lock);
1692 
1693 	/* deleted MCA's */
1694 	pmc_prev = NULL;
1695 	for (pmc=idev->mc_tomb; pmc; pmc=pmc_next) {
1696 		pmc_next = pmc->next;
1697 		if (pmc->mca_sfmode == MCAST_INCLUDE) {
1698 			type = MLD2_BLOCK_OLD_SOURCES;
1699 			dtype = MLD2_BLOCK_OLD_SOURCES;
1700 			skb = add_grec(skb, pmc, type, 1, 0);
1701 			skb = add_grec(skb, pmc, dtype, 1, 1);
1702 		}
1703 		if (pmc->mca_crcount) {
1704 			if (pmc->mca_sfmode == MCAST_EXCLUDE) {
1705 				type = MLD2_CHANGE_TO_INCLUDE;
1706 				skb = add_grec(skb, pmc, type, 1, 0);
1707 			}
1708 			pmc->mca_crcount--;
1709 			if (pmc->mca_crcount == 0) {
1710 				mld_clear_zeros(&pmc->mca_tomb);
1711 				mld_clear_zeros(&pmc->mca_sources);
1712 			}
1713 		}
1714 		if (pmc->mca_crcount == 0 && !pmc->mca_tomb &&
1715 		    !pmc->mca_sources) {
1716 			if (pmc_prev)
1717 				pmc_prev->next = pmc_next;
1718 			else
1719 				idev->mc_tomb = pmc_next;
1720 			in6_dev_put(pmc->idev);
1721 			kfree(pmc);
1722 		} else
1723 			pmc_prev = pmc;
1724 	}
1725 	write_unlock_bh(&idev->mc_lock);
1726 
1727 	/* change recs */
1728 	for (pmc=idev->mc_list; pmc; pmc=pmc->next) {
1729 		spin_lock_bh(&pmc->mca_lock);
1730 		if (pmc->mca_sfcount[MCAST_EXCLUDE]) {
1731 			type = MLD2_BLOCK_OLD_SOURCES;
1732 			dtype = MLD2_ALLOW_NEW_SOURCES;
1733 		} else {
1734 			type = MLD2_ALLOW_NEW_SOURCES;
1735 			dtype = MLD2_BLOCK_OLD_SOURCES;
1736 		}
1737 		skb = add_grec(skb, pmc, type, 0, 0);
1738 		skb = add_grec(skb, pmc, dtype, 0, 1);	/* deleted sources */
1739 
1740 		/* filter mode changes */
1741 		if (pmc->mca_crcount) {
1742 			if (pmc->mca_sfmode == MCAST_EXCLUDE)
1743 				type = MLD2_CHANGE_TO_EXCLUDE;
1744 			else
1745 				type = MLD2_CHANGE_TO_INCLUDE;
1746 			skb = add_grec(skb, pmc, type, 0, 0);
1747 			pmc->mca_crcount--;
1748 		}
1749 		spin_unlock_bh(&pmc->mca_lock);
1750 	}
1751 	read_unlock_bh(&idev->lock);
1752 	if (!skb)
1753 		return;
1754 	(void) mld_sendpack(skb);
1755 }
1756 
1757 static void igmp6_send(struct in6_addr *addr, struct net_device *dev, int type)
1758 {
1759 	struct net *net = dev_net(dev);
1760 	struct sock *sk = net->ipv6.igmp_sk;
1761 	struct inet6_dev *idev;
1762 	struct sk_buff *skb;
1763 	struct icmp6hdr *hdr;
1764 	const struct in6_addr *snd_addr, *saddr;
1765 	struct in6_addr *addrp;
1766 	struct in6_addr addr_buf;
1767 	int err, len, payload_len, full_len;
1768 	u8 ra[8] = { IPPROTO_ICMPV6, 0,
1769 		     IPV6_TLV_ROUTERALERT, 2, 0, 0,
1770 		     IPV6_TLV_PADN, 0 };
1771 	struct flowi fl;
1772 
1773 	rcu_read_lock();
1774 	IP6_INC_STATS(__in6_dev_get(dev),
1775 		      IPSTATS_MIB_OUTREQUESTS);
1776 	rcu_read_unlock();
1777 	if (type == ICMPV6_MGM_REDUCTION)
1778 		snd_addr = &in6addr_linklocal_allrouters;
1779 	else
1780 		snd_addr = addr;
1781 
1782 	len = sizeof(struct icmp6hdr) + sizeof(struct in6_addr);
1783 	payload_len = len + sizeof(ra);
1784 	full_len = sizeof(struct ipv6hdr) + payload_len;
1785 
1786 	skb = sock_alloc_send_skb(sk, LL_ALLOCATED_SPACE(dev) + full_len, 1, &err);
1787 
1788 	if (skb == NULL) {
1789 		rcu_read_lock();
1790 		IP6_INC_STATS(__in6_dev_get(dev),
1791 			      IPSTATS_MIB_OUTDISCARDS);
1792 		rcu_read_unlock();
1793 		return;
1794 	}
1795 
1796 	skb_reserve(skb, LL_RESERVED_SPACE(dev));
1797 
1798 	if (ipv6_get_lladdr(dev, &addr_buf, IFA_F_TENTATIVE)) {
1799 		/* <draft-ietf-magma-mld-source-05.txt>:
1800 		 * use unspecified address as the source address
1801 		 * when a valid link-local address is not available.
1802 		 */
1803 		saddr = &in6addr_any;
1804 	} else
1805 		saddr = &addr_buf;
1806 
1807 	ip6_nd_hdr(sk, skb, dev, saddr, snd_addr, NEXTHDR_HOP, payload_len);
1808 
1809 	memcpy(skb_put(skb, sizeof(ra)), ra, sizeof(ra));
1810 
1811 	hdr = (struct icmp6hdr *) skb_put(skb, sizeof(struct icmp6hdr));
1812 	memset(hdr, 0, sizeof(struct icmp6hdr));
1813 	hdr->icmp6_type = type;
1814 
1815 	addrp = (struct in6_addr *) skb_put(skb, sizeof(struct in6_addr));
1816 	ipv6_addr_copy(addrp, addr);
1817 
1818 	hdr->icmp6_cksum = csum_ipv6_magic(saddr, snd_addr, len,
1819 					   IPPROTO_ICMPV6,
1820 					   csum_partial((__u8 *) hdr, len, 0));
1821 
1822 	idev = in6_dev_get(skb->dev);
1823 
1824 	skb->dst = icmp6_dst_alloc(skb->dev, NULL, &ipv6_hdr(skb)->daddr);
1825 	if (!skb->dst) {
1826 		err = -ENOMEM;
1827 		goto err_out;
1828 	}
1829 
1830 	icmpv6_flow_init(sk, &fl, type,
1831 			 &ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr,
1832 			 skb->dev->ifindex);
1833 
1834 	err = xfrm_lookup(&skb->dst, &fl, NULL, 0);
1835 	if (err)
1836 		goto err_out;
1837 
1838 	err = NF_HOOK(PF_INET6, NF_INET_LOCAL_OUT, skb, NULL, skb->dev,
1839 		      dst_output);
1840 out:
1841 	if (!err) {
1842 		ICMP6MSGOUT_INC_STATS(idev, type);
1843 		ICMP6_INC_STATS(idev, ICMP6_MIB_OUTMSGS);
1844 		IP6_INC_STATS(idev, IPSTATS_MIB_OUTMCASTPKTS);
1845 	} else
1846 		IP6_INC_STATS(idev, IPSTATS_MIB_OUTDISCARDS);
1847 
1848 	if (likely(idev != NULL))
1849 		in6_dev_put(idev);
1850 	return;
1851 
1852 err_out:
1853 	kfree_skb(skb);
1854 	goto out;
1855 }
1856 
1857 static int ip6_mc_del1_src(struct ifmcaddr6 *pmc, int sfmode,
1858 	struct in6_addr *psfsrc)
1859 {
1860 	struct ip6_sf_list *psf, *psf_prev;
1861 	int rv = 0;
1862 
1863 	psf_prev = NULL;
1864 	for (psf=pmc->mca_sources; psf; psf=psf->sf_next) {
1865 		if (ipv6_addr_equal(&psf->sf_addr, psfsrc))
1866 			break;
1867 		psf_prev = psf;
1868 	}
1869 	if (!psf || psf->sf_count[sfmode] == 0) {
1870 		/* source filter not found, or count wrong =>  bug */
1871 		return -ESRCH;
1872 	}
1873 	psf->sf_count[sfmode]--;
1874 	if (!psf->sf_count[MCAST_INCLUDE] && !psf->sf_count[MCAST_EXCLUDE]) {
1875 		struct inet6_dev *idev = pmc->idev;
1876 
1877 		/* no more filters for this source */
1878 		if (psf_prev)
1879 			psf_prev->sf_next = psf->sf_next;
1880 		else
1881 			pmc->mca_sources = psf->sf_next;
1882 		if (psf->sf_oldin && !(pmc->mca_flags & MAF_NOREPORT) &&
1883 		    !MLD_V1_SEEN(idev)) {
1884 			psf->sf_crcount = idev->mc_qrv;
1885 			psf->sf_next = pmc->mca_tomb;
1886 			pmc->mca_tomb = psf;
1887 			rv = 1;
1888 		} else
1889 			kfree(psf);
1890 	}
1891 	return rv;
1892 }
1893 
1894 static int ip6_mc_del_src(struct inet6_dev *idev, struct in6_addr *pmca,
1895 			  int sfmode, int sfcount, struct in6_addr *psfsrc,
1896 			  int delta)
1897 {
1898 	struct ifmcaddr6 *pmc;
1899 	int	changerec = 0;
1900 	int	i, err;
1901 
1902 	if (!idev)
1903 		return -ENODEV;
1904 	read_lock_bh(&idev->lock);
1905 	for (pmc=idev->mc_list; pmc; pmc=pmc->next) {
1906 		if (ipv6_addr_equal(pmca, &pmc->mca_addr))
1907 			break;
1908 	}
1909 	if (!pmc) {
1910 		/* MCA not found?? bug */
1911 		read_unlock_bh(&idev->lock);
1912 		return -ESRCH;
1913 	}
1914 	spin_lock_bh(&pmc->mca_lock);
1915 	sf_markstate(pmc);
1916 	if (!delta) {
1917 		if (!pmc->mca_sfcount[sfmode]) {
1918 			spin_unlock_bh(&pmc->mca_lock);
1919 			read_unlock_bh(&idev->lock);
1920 			return -EINVAL;
1921 		}
1922 		pmc->mca_sfcount[sfmode]--;
1923 	}
1924 	err = 0;
1925 	for (i=0; i<sfcount; i++) {
1926 		int rv = ip6_mc_del1_src(pmc, sfmode, &psfsrc[i]);
1927 
1928 		changerec |= rv > 0;
1929 		if (!err && rv < 0)
1930 			err = rv;
1931 	}
1932 	if (pmc->mca_sfmode == MCAST_EXCLUDE &&
1933 	    pmc->mca_sfcount[MCAST_EXCLUDE] == 0 &&
1934 	    pmc->mca_sfcount[MCAST_INCLUDE]) {
1935 		struct ip6_sf_list *psf;
1936 
1937 		/* filter mode change */
1938 		pmc->mca_sfmode = MCAST_INCLUDE;
1939 		pmc->mca_crcount = idev->mc_qrv;
1940 		idev->mc_ifc_count = pmc->mca_crcount;
1941 		for (psf=pmc->mca_sources; psf; psf = psf->sf_next)
1942 			psf->sf_crcount = 0;
1943 		mld_ifc_event(pmc->idev);
1944 	} else if (sf_setstate(pmc) || changerec)
1945 		mld_ifc_event(pmc->idev);
1946 	spin_unlock_bh(&pmc->mca_lock);
1947 	read_unlock_bh(&idev->lock);
1948 	return err;
1949 }
1950 
1951 /*
1952  * Add multicast single-source filter to the interface list
1953  */
1954 static int ip6_mc_add1_src(struct ifmcaddr6 *pmc, int sfmode,
1955 	struct in6_addr *psfsrc, int delta)
1956 {
1957 	struct ip6_sf_list *psf, *psf_prev;
1958 
1959 	psf_prev = NULL;
1960 	for (psf=pmc->mca_sources; psf; psf=psf->sf_next) {
1961 		if (ipv6_addr_equal(&psf->sf_addr, psfsrc))
1962 			break;
1963 		psf_prev = psf;
1964 	}
1965 	if (!psf) {
1966 		psf = kzalloc(sizeof(*psf), GFP_ATOMIC);
1967 		if (!psf)
1968 			return -ENOBUFS;
1969 
1970 		psf->sf_addr = *psfsrc;
1971 		if (psf_prev) {
1972 			psf_prev->sf_next = psf;
1973 		} else
1974 			pmc->mca_sources = psf;
1975 	}
1976 	psf->sf_count[sfmode]++;
1977 	return 0;
1978 }
1979 
1980 static void sf_markstate(struct ifmcaddr6 *pmc)
1981 {
1982 	struct ip6_sf_list *psf;
1983 	int mca_xcount = pmc->mca_sfcount[MCAST_EXCLUDE];
1984 
1985 	for (psf=pmc->mca_sources; psf; psf=psf->sf_next)
1986 		if (pmc->mca_sfcount[MCAST_EXCLUDE]) {
1987 			psf->sf_oldin = mca_xcount ==
1988 				psf->sf_count[MCAST_EXCLUDE] &&
1989 				!psf->sf_count[MCAST_INCLUDE];
1990 		} else
1991 			psf->sf_oldin = psf->sf_count[MCAST_INCLUDE] != 0;
1992 }
1993 
1994 static int sf_setstate(struct ifmcaddr6 *pmc)
1995 {
1996 	struct ip6_sf_list *psf, *dpsf;
1997 	int mca_xcount = pmc->mca_sfcount[MCAST_EXCLUDE];
1998 	int qrv = pmc->idev->mc_qrv;
1999 	int new_in, rv;
2000 
2001 	rv = 0;
2002 	for (psf=pmc->mca_sources; psf; psf=psf->sf_next) {
2003 		if (pmc->mca_sfcount[MCAST_EXCLUDE]) {
2004 			new_in = mca_xcount == psf->sf_count[MCAST_EXCLUDE] &&
2005 				!psf->sf_count[MCAST_INCLUDE];
2006 		} else
2007 			new_in = psf->sf_count[MCAST_INCLUDE] != 0;
2008 		if (new_in) {
2009 			if (!psf->sf_oldin) {
2010 				struct ip6_sf_list *prev = NULL;
2011 
2012 				for (dpsf=pmc->mca_tomb; dpsf;
2013 				     dpsf=dpsf->sf_next) {
2014 					if (ipv6_addr_equal(&dpsf->sf_addr,
2015 					    &psf->sf_addr))
2016 						break;
2017 					prev = dpsf;
2018 				}
2019 				if (dpsf) {
2020 					if (prev)
2021 						prev->sf_next = dpsf->sf_next;
2022 					else
2023 						pmc->mca_tomb = dpsf->sf_next;
2024 					kfree(dpsf);
2025 				}
2026 				psf->sf_crcount = qrv;
2027 				rv++;
2028 			}
2029 		} else if (psf->sf_oldin) {
2030 			psf->sf_crcount = 0;
2031 			/*
2032 			 * add or update "delete" records if an active filter
2033 			 * is now inactive
2034 			 */
2035 			for (dpsf=pmc->mca_tomb; dpsf; dpsf=dpsf->sf_next)
2036 				if (ipv6_addr_equal(&dpsf->sf_addr,
2037 				    &psf->sf_addr))
2038 					break;
2039 			if (!dpsf) {
2040 				dpsf = (struct ip6_sf_list *)
2041 					kmalloc(sizeof(*dpsf), GFP_ATOMIC);
2042 				if (!dpsf)
2043 					continue;
2044 				*dpsf = *psf;
2045 				/* pmc->mca_lock held by callers */
2046 				dpsf->sf_next = pmc->mca_tomb;
2047 				pmc->mca_tomb = dpsf;
2048 			}
2049 			dpsf->sf_crcount = qrv;
2050 			rv++;
2051 		}
2052 	}
2053 	return rv;
2054 }
2055 
2056 /*
2057  * Add multicast source filter list to the interface list
2058  */
2059 static int ip6_mc_add_src(struct inet6_dev *idev, struct in6_addr *pmca,
2060 			  int sfmode, int sfcount, struct in6_addr *psfsrc,
2061 			  int delta)
2062 {
2063 	struct ifmcaddr6 *pmc;
2064 	int	isexclude;
2065 	int	i, err;
2066 
2067 	if (!idev)
2068 		return -ENODEV;
2069 	read_lock_bh(&idev->lock);
2070 	for (pmc=idev->mc_list; pmc; pmc=pmc->next) {
2071 		if (ipv6_addr_equal(pmca, &pmc->mca_addr))
2072 			break;
2073 	}
2074 	if (!pmc) {
2075 		/* MCA not found?? bug */
2076 		read_unlock_bh(&idev->lock);
2077 		return -ESRCH;
2078 	}
2079 	spin_lock_bh(&pmc->mca_lock);
2080 
2081 	sf_markstate(pmc);
2082 	isexclude = pmc->mca_sfmode == MCAST_EXCLUDE;
2083 	if (!delta)
2084 		pmc->mca_sfcount[sfmode]++;
2085 	err = 0;
2086 	for (i=0; i<sfcount; i++) {
2087 		err = ip6_mc_add1_src(pmc, sfmode, &psfsrc[i], delta);
2088 		if (err)
2089 			break;
2090 	}
2091 	if (err) {
2092 		int j;
2093 
2094 		if (!delta)
2095 			pmc->mca_sfcount[sfmode]--;
2096 		for (j=0; j<i; j++)
2097 			(void) ip6_mc_del1_src(pmc, sfmode, &psfsrc[i]);
2098 	} else if (isexclude != (pmc->mca_sfcount[MCAST_EXCLUDE] != 0)) {
2099 		struct inet6_dev *idev = pmc->idev;
2100 		struct ip6_sf_list *psf;
2101 
2102 		/* filter mode change */
2103 		if (pmc->mca_sfcount[MCAST_EXCLUDE])
2104 			pmc->mca_sfmode = MCAST_EXCLUDE;
2105 		else if (pmc->mca_sfcount[MCAST_INCLUDE])
2106 			pmc->mca_sfmode = MCAST_INCLUDE;
2107 		/* else no filters; keep old mode for reports */
2108 
2109 		pmc->mca_crcount = idev->mc_qrv;
2110 		idev->mc_ifc_count = pmc->mca_crcount;
2111 		for (psf=pmc->mca_sources; psf; psf = psf->sf_next)
2112 			psf->sf_crcount = 0;
2113 		mld_ifc_event(idev);
2114 	} else if (sf_setstate(pmc))
2115 		mld_ifc_event(idev);
2116 	spin_unlock_bh(&pmc->mca_lock);
2117 	read_unlock_bh(&idev->lock);
2118 	return err;
2119 }
2120 
2121 static void ip6_mc_clear_src(struct ifmcaddr6 *pmc)
2122 {
2123 	struct ip6_sf_list *psf, *nextpsf;
2124 
2125 	for (psf=pmc->mca_tomb; psf; psf=nextpsf) {
2126 		nextpsf = psf->sf_next;
2127 		kfree(psf);
2128 	}
2129 	pmc->mca_tomb = NULL;
2130 	for (psf=pmc->mca_sources; psf; psf=nextpsf) {
2131 		nextpsf = psf->sf_next;
2132 		kfree(psf);
2133 	}
2134 	pmc->mca_sources = NULL;
2135 	pmc->mca_sfmode = MCAST_EXCLUDE;
2136 	pmc->mca_sfcount[MCAST_INCLUDE] = 0;
2137 	pmc->mca_sfcount[MCAST_EXCLUDE] = 1;
2138 }
2139 
2140 
2141 static void igmp6_join_group(struct ifmcaddr6 *ma)
2142 {
2143 	unsigned long delay;
2144 
2145 	if (ma->mca_flags & MAF_NOREPORT)
2146 		return;
2147 
2148 	igmp6_send(&ma->mca_addr, ma->idev->dev, ICMPV6_MGM_REPORT);
2149 
2150 	delay = net_random() % IGMP6_UNSOLICITED_IVAL;
2151 
2152 	spin_lock_bh(&ma->mca_lock);
2153 	if (del_timer(&ma->mca_timer)) {
2154 		atomic_dec(&ma->mca_refcnt);
2155 		delay = ma->mca_timer.expires - jiffies;
2156 	}
2157 
2158 	if (!mod_timer(&ma->mca_timer, jiffies + delay))
2159 		atomic_inc(&ma->mca_refcnt);
2160 	ma->mca_flags |= MAF_TIMER_RUNNING | MAF_LAST_REPORTER;
2161 	spin_unlock_bh(&ma->mca_lock);
2162 }
2163 
2164 static int ip6_mc_leave_src(struct sock *sk, struct ipv6_mc_socklist *iml,
2165 			    struct inet6_dev *idev)
2166 {
2167 	int err;
2168 
2169 	/* callers have the socket lock and a write lock on ipv6_sk_mc_lock,
2170 	 * so no other readers or writers of iml or its sflist
2171 	 */
2172 	if (!iml->sflist) {
2173 		/* any-source empty exclude case */
2174 		return ip6_mc_del_src(idev, &iml->addr, iml->sfmode, 0, NULL, 0);
2175 	}
2176 	err = ip6_mc_del_src(idev, &iml->addr, iml->sfmode,
2177 		iml->sflist->sl_count, iml->sflist->sl_addr, 0);
2178 	sock_kfree_s(sk, iml->sflist, IP6_SFLSIZE(iml->sflist->sl_max));
2179 	iml->sflist = NULL;
2180 	return err;
2181 }
2182 
2183 static void igmp6_leave_group(struct ifmcaddr6 *ma)
2184 {
2185 	if (MLD_V1_SEEN(ma->idev)) {
2186 		if (ma->mca_flags & MAF_LAST_REPORTER)
2187 			igmp6_send(&ma->mca_addr, ma->idev->dev,
2188 				ICMPV6_MGM_REDUCTION);
2189 	} else {
2190 		mld_add_delrec(ma->idev, ma);
2191 		mld_ifc_event(ma->idev);
2192 	}
2193 }
2194 
2195 static void mld_gq_timer_expire(unsigned long data)
2196 {
2197 	struct inet6_dev *idev = (struct inet6_dev *)data;
2198 
2199 	idev->mc_gq_running = 0;
2200 	mld_send_report(idev, NULL);
2201 	__in6_dev_put(idev);
2202 }
2203 
2204 static void mld_ifc_timer_expire(unsigned long data)
2205 {
2206 	struct inet6_dev *idev = (struct inet6_dev *)data;
2207 
2208 	mld_send_cr(idev);
2209 	if (idev->mc_ifc_count) {
2210 		idev->mc_ifc_count--;
2211 		if (idev->mc_ifc_count)
2212 			mld_ifc_start_timer(idev, idev->mc_maxdelay);
2213 	}
2214 	__in6_dev_put(idev);
2215 }
2216 
2217 static void mld_ifc_event(struct inet6_dev *idev)
2218 {
2219 	if (MLD_V1_SEEN(idev))
2220 		return;
2221 	idev->mc_ifc_count = idev->mc_qrv;
2222 	mld_ifc_start_timer(idev, 1);
2223 }
2224 
2225 
2226 static void igmp6_timer_handler(unsigned long data)
2227 {
2228 	struct ifmcaddr6 *ma = (struct ifmcaddr6 *) data;
2229 
2230 	if (MLD_V1_SEEN(ma->idev))
2231 		igmp6_send(&ma->mca_addr, ma->idev->dev, ICMPV6_MGM_REPORT);
2232 	else
2233 		mld_send_report(ma->idev, ma);
2234 
2235 	spin_lock(&ma->mca_lock);
2236 	ma->mca_flags |=  MAF_LAST_REPORTER;
2237 	ma->mca_flags &= ~MAF_TIMER_RUNNING;
2238 	spin_unlock(&ma->mca_lock);
2239 	ma_put(ma);
2240 }
2241 
2242 /* Device going down */
2243 
2244 void ipv6_mc_down(struct inet6_dev *idev)
2245 {
2246 	struct ifmcaddr6 *i;
2247 
2248 	/* Withdraw multicast list */
2249 
2250 	read_lock_bh(&idev->lock);
2251 	idev->mc_ifc_count = 0;
2252 	if (del_timer(&idev->mc_ifc_timer))
2253 		__in6_dev_put(idev);
2254 	idev->mc_gq_running = 0;
2255 	if (del_timer(&idev->mc_gq_timer))
2256 		__in6_dev_put(idev);
2257 
2258 	for (i = idev->mc_list; i; i=i->next)
2259 		igmp6_group_dropped(i);
2260 	read_unlock_bh(&idev->lock);
2261 
2262 	mld_clear_delrec(idev);
2263 }
2264 
2265 
2266 /* Device going up */
2267 
2268 void ipv6_mc_up(struct inet6_dev *idev)
2269 {
2270 	struct ifmcaddr6 *i;
2271 
2272 	/* Install multicast list, except for all-nodes (already installed) */
2273 
2274 	read_lock_bh(&idev->lock);
2275 	for (i = idev->mc_list; i; i=i->next)
2276 		igmp6_group_added(i);
2277 	read_unlock_bh(&idev->lock);
2278 }
2279 
2280 /* IPv6 device initialization. */
2281 
2282 void ipv6_mc_init_dev(struct inet6_dev *idev)
2283 {
2284 	write_lock_bh(&idev->lock);
2285 	rwlock_init(&idev->mc_lock);
2286 	idev->mc_gq_running = 0;
2287 	setup_timer(&idev->mc_gq_timer, mld_gq_timer_expire,
2288 			(unsigned long)idev);
2289 	idev->mc_tomb = NULL;
2290 	idev->mc_ifc_count = 0;
2291 	setup_timer(&idev->mc_ifc_timer, mld_ifc_timer_expire,
2292 			(unsigned long)idev);
2293 	idev->mc_qrv = MLD_QRV_DEFAULT;
2294 	idev->mc_maxdelay = IGMP6_UNSOLICITED_IVAL;
2295 	idev->mc_v1_seen = 0;
2296 	write_unlock_bh(&idev->lock);
2297 }
2298 
2299 /*
2300  *	Device is about to be destroyed: clean up.
2301  */
2302 
2303 void ipv6_mc_destroy_dev(struct inet6_dev *idev)
2304 {
2305 	struct ifmcaddr6 *i;
2306 
2307 	/* Deactivate timers */
2308 	ipv6_mc_down(idev);
2309 
2310 	/* Delete all-nodes address. */
2311 	/* We cannot call ipv6_dev_mc_dec() directly, our caller in
2312 	 * addrconf.c has NULL'd out dev->ip6_ptr so in6_dev_get() will
2313 	 * fail.
2314 	 */
2315 	__ipv6_dev_mc_dec(idev, &in6addr_linklocal_allnodes);
2316 
2317 	if (idev->cnf.forwarding)
2318 		__ipv6_dev_mc_dec(idev, &in6addr_linklocal_allrouters);
2319 
2320 	write_lock_bh(&idev->lock);
2321 	while ((i = idev->mc_list) != NULL) {
2322 		idev->mc_list = i->next;
2323 		write_unlock_bh(&idev->lock);
2324 
2325 		igmp6_group_dropped(i);
2326 		ma_put(i);
2327 
2328 		write_lock_bh(&idev->lock);
2329 	}
2330 	write_unlock_bh(&idev->lock);
2331 }
2332 
2333 #ifdef CONFIG_PROC_FS
2334 struct igmp6_mc_iter_state {
2335 	struct seq_net_private p;
2336 	struct net_device *dev;
2337 	struct inet6_dev *idev;
2338 };
2339 
2340 #define igmp6_mc_seq_private(seq)	((struct igmp6_mc_iter_state *)(seq)->private)
2341 
2342 static inline struct ifmcaddr6 *igmp6_mc_get_first(struct seq_file *seq)
2343 {
2344 	struct ifmcaddr6 *im = NULL;
2345 	struct igmp6_mc_iter_state *state = igmp6_mc_seq_private(seq);
2346 	struct net *net = seq_file_net(seq);
2347 
2348 	state->idev = NULL;
2349 	for_each_netdev(net, state->dev) {
2350 		struct inet6_dev *idev;
2351 		idev = in6_dev_get(state->dev);
2352 		if (!idev)
2353 			continue;
2354 		read_lock_bh(&idev->lock);
2355 		im = idev->mc_list;
2356 		if (im) {
2357 			state->idev = idev;
2358 			break;
2359 		}
2360 		read_unlock_bh(&idev->lock);
2361 		in6_dev_put(idev);
2362 	}
2363 	return im;
2364 }
2365 
2366 static struct ifmcaddr6 *igmp6_mc_get_next(struct seq_file *seq, struct ifmcaddr6 *im)
2367 {
2368 	struct igmp6_mc_iter_state *state = igmp6_mc_seq_private(seq);
2369 
2370 	im = im->next;
2371 	while (!im) {
2372 		if (likely(state->idev != NULL)) {
2373 			read_unlock_bh(&state->idev->lock);
2374 			in6_dev_put(state->idev);
2375 		}
2376 		state->dev = next_net_device(state->dev);
2377 		if (!state->dev) {
2378 			state->idev = NULL;
2379 			break;
2380 		}
2381 		state->idev = in6_dev_get(state->dev);
2382 		if (!state->idev)
2383 			continue;
2384 		read_lock_bh(&state->idev->lock);
2385 		im = state->idev->mc_list;
2386 	}
2387 	return im;
2388 }
2389 
2390 static struct ifmcaddr6 *igmp6_mc_get_idx(struct seq_file *seq, loff_t pos)
2391 {
2392 	struct ifmcaddr6 *im = igmp6_mc_get_first(seq);
2393 	if (im)
2394 		while (pos && (im = igmp6_mc_get_next(seq, im)) != NULL)
2395 			--pos;
2396 	return pos ? NULL : im;
2397 }
2398 
2399 static void *igmp6_mc_seq_start(struct seq_file *seq, loff_t *pos)
2400 	__acquires(dev_base_lock)
2401 {
2402 	read_lock(&dev_base_lock);
2403 	return igmp6_mc_get_idx(seq, *pos);
2404 }
2405 
2406 static void *igmp6_mc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2407 {
2408 	struct ifmcaddr6 *im;
2409 	im = igmp6_mc_get_next(seq, v);
2410 	++*pos;
2411 	return im;
2412 }
2413 
2414 static void igmp6_mc_seq_stop(struct seq_file *seq, void *v)
2415 	__releases(dev_base_lock)
2416 {
2417 	struct igmp6_mc_iter_state *state = igmp6_mc_seq_private(seq);
2418 	if (likely(state->idev != NULL)) {
2419 		read_unlock_bh(&state->idev->lock);
2420 		in6_dev_put(state->idev);
2421 		state->idev = NULL;
2422 	}
2423 	state->dev = NULL;
2424 	read_unlock(&dev_base_lock);
2425 }
2426 
2427 static int igmp6_mc_seq_show(struct seq_file *seq, void *v)
2428 {
2429 	struct ifmcaddr6 *im = (struct ifmcaddr6 *)v;
2430 	struct igmp6_mc_iter_state *state = igmp6_mc_seq_private(seq);
2431 
2432 	seq_printf(seq,
2433 		   "%-4d %-15s " NIP6_SEQFMT " %5d %08X %ld\n",
2434 		   state->dev->ifindex, state->dev->name,
2435 		   NIP6(im->mca_addr),
2436 		   im->mca_users, im->mca_flags,
2437 		   (im->mca_flags&MAF_TIMER_RUNNING) ?
2438 		   jiffies_to_clock_t(im->mca_timer.expires-jiffies) : 0);
2439 	return 0;
2440 }
2441 
2442 static const struct seq_operations igmp6_mc_seq_ops = {
2443 	.start	=	igmp6_mc_seq_start,
2444 	.next	=	igmp6_mc_seq_next,
2445 	.stop	=	igmp6_mc_seq_stop,
2446 	.show	=	igmp6_mc_seq_show,
2447 };
2448 
2449 static int igmp6_mc_seq_open(struct inode *inode, struct file *file)
2450 {
2451 	return seq_open_net(inode, file, &igmp6_mc_seq_ops,
2452 			    sizeof(struct igmp6_mc_iter_state));
2453 }
2454 
2455 static const struct file_operations igmp6_mc_seq_fops = {
2456 	.owner		=	THIS_MODULE,
2457 	.open		=	igmp6_mc_seq_open,
2458 	.read		=	seq_read,
2459 	.llseek		=	seq_lseek,
2460 	.release	=	seq_release_net,
2461 };
2462 
2463 struct igmp6_mcf_iter_state {
2464 	struct seq_net_private p;
2465 	struct net_device *dev;
2466 	struct inet6_dev *idev;
2467 	struct ifmcaddr6 *im;
2468 };
2469 
2470 #define igmp6_mcf_seq_private(seq)	((struct igmp6_mcf_iter_state *)(seq)->private)
2471 
2472 static inline struct ip6_sf_list *igmp6_mcf_get_first(struct seq_file *seq)
2473 {
2474 	struct ip6_sf_list *psf = NULL;
2475 	struct ifmcaddr6 *im = NULL;
2476 	struct igmp6_mcf_iter_state *state = igmp6_mcf_seq_private(seq);
2477 	struct net *net = seq_file_net(seq);
2478 
2479 	state->idev = NULL;
2480 	state->im = NULL;
2481 	for_each_netdev(net, state->dev) {
2482 		struct inet6_dev *idev;
2483 		idev = in6_dev_get(state->dev);
2484 		if (unlikely(idev == NULL))
2485 			continue;
2486 		read_lock_bh(&idev->lock);
2487 		im = idev->mc_list;
2488 		if (likely(im != NULL)) {
2489 			spin_lock_bh(&im->mca_lock);
2490 			psf = im->mca_sources;
2491 			if (likely(psf != NULL)) {
2492 				state->im = im;
2493 				state->idev = idev;
2494 				break;
2495 			}
2496 			spin_unlock_bh(&im->mca_lock);
2497 		}
2498 		read_unlock_bh(&idev->lock);
2499 		in6_dev_put(idev);
2500 	}
2501 	return psf;
2502 }
2503 
2504 static struct ip6_sf_list *igmp6_mcf_get_next(struct seq_file *seq, struct ip6_sf_list *psf)
2505 {
2506 	struct igmp6_mcf_iter_state *state = igmp6_mcf_seq_private(seq);
2507 
2508 	psf = psf->sf_next;
2509 	while (!psf) {
2510 		spin_unlock_bh(&state->im->mca_lock);
2511 		state->im = state->im->next;
2512 		while (!state->im) {
2513 			if (likely(state->idev != NULL)) {
2514 				read_unlock_bh(&state->idev->lock);
2515 				in6_dev_put(state->idev);
2516 			}
2517 			state->dev = next_net_device(state->dev);
2518 			if (!state->dev) {
2519 				state->idev = NULL;
2520 				goto out;
2521 			}
2522 			state->idev = in6_dev_get(state->dev);
2523 			if (!state->idev)
2524 				continue;
2525 			read_lock_bh(&state->idev->lock);
2526 			state->im = state->idev->mc_list;
2527 		}
2528 		if (!state->im)
2529 			break;
2530 		spin_lock_bh(&state->im->mca_lock);
2531 		psf = state->im->mca_sources;
2532 	}
2533 out:
2534 	return psf;
2535 }
2536 
2537 static struct ip6_sf_list *igmp6_mcf_get_idx(struct seq_file *seq, loff_t pos)
2538 {
2539 	struct ip6_sf_list *psf = igmp6_mcf_get_first(seq);
2540 	if (psf)
2541 		while (pos && (psf = igmp6_mcf_get_next(seq, psf)) != NULL)
2542 			--pos;
2543 	return pos ? NULL : psf;
2544 }
2545 
2546 static void *igmp6_mcf_seq_start(struct seq_file *seq, loff_t *pos)
2547 	__acquires(dev_base_lock)
2548 {
2549 	read_lock(&dev_base_lock);
2550 	return *pos ? igmp6_mcf_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
2551 }
2552 
2553 static void *igmp6_mcf_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2554 {
2555 	struct ip6_sf_list *psf;
2556 	if (v == SEQ_START_TOKEN)
2557 		psf = igmp6_mcf_get_first(seq);
2558 	else
2559 		psf = igmp6_mcf_get_next(seq, v);
2560 	++*pos;
2561 	return psf;
2562 }
2563 
2564 static void igmp6_mcf_seq_stop(struct seq_file *seq, void *v)
2565 	__releases(dev_base_lock)
2566 {
2567 	struct igmp6_mcf_iter_state *state = igmp6_mcf_seq_private(seq);
2568 	if (likely(state->im != NULL)) {
2569 		spin_unlock_bh(&state->im->mca_lock);
2570 		state->im = NULL;
2571 	}
2572 	if (likely(state->idev != NULL)) {
2573 		read_unlock_bh(&state->idev->lock);
2574 		in6_dev_put(state->idev);
2575 		state->idev = NULL;
2576 	}
2577 	state->dev = NULL;
2578 	read_unlock(&dev_base_lock);
2579 }
2580 
2581 static int igmp6_mcf_seq_show(struct seq_file *seq, void *v)
2582 {
2583 	struct ip6_sf_list *psf = (struct ip6_sf_list *)v;
2584 	struct igmp6_mcf_iter_state *state = igmp6_mcf_seq_private(seq);
2585 
2586 	if (v == SEQ_START_TOKEN) {
2587 		seq_printf(seq,
2588 			   "%3s %6s "
2589 			   "%32s %32s %6s %6s\n", "Idx",
2590 			   "Device", "Multicast Address",
2591 			   "Source Address", "INC", "EXC");
2592 	} else {
2593 		seq_printf(seq,
2594 			   "%3d %6.6s " NIP6_SEQFMT " " NIP6_SEQFMT " %6lu %6lu\n",
2595 			   state->dev->ifindex, state->dev->name,
2596 			   NIP6(state->im->mca_addr),
2597 			   NIP6(psf->sf_addr),
2598 			   psf->sf_count[MCAST_INCLUDE],
2599 			   psf->sf_count[MCAST_EXCLUDE]);
2600 	}
2601 	return 0;
2602 }
2603 
2604 static const struct seq_operations igmp6_mcf_seq_ops = {
2605 	.start	=	igmp6_mcf_seq_start,
2606 	.next	=	igmp6_mcf_seq_next,
2607 	.stop	=	igmp6_mcf_seq_stop,
2608 	.show	=	igmp6_mcf_seq_show,
2609 };
2610 
2611 static int igmp6_mcf_seq_open(struct inode *inode, struct file *file)
2612 {
2613 	return seq_open_net(inode, file, &igmp6_mcf_seq_ops,
2614 			    sizeof(struct igmp6_mcf_iter_state));
2615 }
2616 
2617 static const struct file_operations igmp6_mcf_seq_fops = {
2618 	.owner		=	THIS_MODULE,
2619 	.open		=	igmp6_mcf_seq_open,
2620 	.read		=	seq_read,
2621 	.llseek		=	seq_lseek,
2622 	.release	=	seq_release_net,
2623 };
2624 
2625 static int igmp6_proc_init(struct net *net)
2626 {
2627 	int err;
2628 
2629 	err = -ENOMEM;
2630 	if (!proc_net_fops_create(net, "igmp6", S_IRUGO, &igmp6_mc_seq_fops))
2631 		goto out;
2632 	if (!proc_net_fops_create(net, "mcfilter6", S_IRUGO,
2633 				  &igmp6_mcf_seq_fops))
2634 		goto out_proc_net_igmp6;
2635 
2636 	err = 0;
2637 out:
2638 	return err;
2639 
2640 out_proc_net_igmp6:
2641 	proc_net_remove(net, "igmp6");
2642 	goto out;
2643 }
2644 
2645 static void igmp6_proc_exit(struct net *net)
2646 {
2647 	proc_net_remove(net, "mcfilter6");
2648 	proc_net_remove(net, "igmp6");
2649 }
2650 #else
2651 static int igmp6_proc_init(struct net *net)
2652 {
2653 	return 0;
2654 }
2655 static void igmp6_proc_exit(struct net *net)
2656 {
2657 	;
2658 }
2659 #endif
2660 
2661 static int igmp6_net_init(struct net *net)
2662 {
2663 	int err;
2664 
2665 	err = inet_ctl_sock_create(&net->ipv6.igmp_sk, PF_INET6,
2666 				   SOCK_RAW, IPPROTO_ICMPV6, net);
2667 	if (err < 0) {
2668 		printk(KERN_ERR
2669 		       "Failed to initialize the IGMP6 control socket (err %d).\n",
2670 		       err);
2671 		goto out;
2672 	}
2673 
2674 	inet6_sk(net->ipv6.igmp_sk)->hop_limit = 1;
2675 
2676 	err = igmp6_proc_init(net);
2677 	if (err)
2678 		goto out_sock_create;
2679 out:
2680 	return err;
2681 
2682 out_sock_create:
2683 	inet_ctl_sock_destroy(net->ipv6.igmp_sk);
2684 	goto out;
2685 }
2686 
2687 static void igmp6_net_exit(struct net *net)
2688 {
2689 	inet_ctl_sock_destroy(net->ipv6.igmp_sk);
2690 	igmp6_proc_exit(net);
2691 }
2692 
2693 static struct pernet_operations igmp6_net_ops = {
2694 	.init = igmp6_net_init,
2695 	.exit = igmp6_net_exit,
2696 };
2697 
2698 int __init igmp6_init(void)
2699 {
2700 	return register_pernet_subsys(&igmp6_net_ops);
2701 }
2702 
2703 void igmp6_cleanup(void)
2704 {
2705 	unregister_pernet_subsys(&igmp6_net_ops);
2706 }
2707