1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Linux NET3: Internet Group Management Protocol [IGMP]
5 * This code implements the IGMP protocol as defined in RFC1112. There has
6 * been a further revision of this protocol since which is now supported.
8 * If you have trouble with this module be careful what gcc you have used,
9 * the older version didn't come out right using gcc 2.5.8, the newer one
10 * seems to fall out with gcc 2.6.2.
13 * Alan Cox <alan@lxorguk.ukuu.org.uk>
17 * Alan Cox : Added lots of __inline__ to optimise
18 * the memory usage of all the tiny little
20 * Alan Cox : Dumped the header building experiment.
21 * Alan Cox : Minor tweaks ready for multicast routing
22 * and extended IGMP protocol.
23 * Alan Cox : Removed a load of inline directives. Gcc 2.5.8
24 * writes utterly bogus code otherwise (sigh)
25 * fixed IGMP loopback to behave in the manner
26 * desired by mrouted, fixed the fact it has been
27 * broken since 1.3.6 and cleaned up a few minor
30 * Chih-Jen Chang : Tried to revise IGMP to Version 2
31 * Tsu-Sheng Tsao E-mail: chihjenc@scf.usc.edu and tsusheng@scf.usc.edu
32 * The enhancements are mainly based on Steve Deering's
33 * ipmulti-3.5 source code.
34 * Chih-Jen Chang : Added the igmp_get_mrouter_info and
35 * Tsu-Sheng Tsao igmp_set_mrouter_info to keep track of
36 * the mrouted version on that device.
37 * Chih-Jen Chang : Added the max_resp_time parameter to
38 * Tsu-Sheng Tsao igmp_heard_query(). Using this parameter
39 * to identify the multicast router version
40 * and do what the IGMP version 2 specified.
41 * Chih-Jen Chang : Added a timer to revert to IGMP V2 router
42 * Tsu-Sheng Tsao if the specified time expired.
43 * Alan Cox : Stop IGMP from 0.0.0.0 being accepted.
44 * Alan Cox : Use GFP_ATOMIC in the right places.
45 * Christian Daudt : igmp timer wasn't set for local group
46 * memberships but was being deleted,
47 * which caused a "del_timer() called
48 * from %p with timer not initialized\n"
50 * Christian Daudt : removed del_timer from
51 * igmp_timer_expire function (960205).
52 * Christian Daudt : igmp_heard_report now only calls
53 * igmp_timer_expire if tm->running is
55 * Malcolm Beattie : ttl comparison wrong in igmp_rcv made
56 * igmp_heard_query never trigger. Expiry
57 * miscalculation fixed in igmp_heard_query
58 * and random() made to return unsigned to
59 * prevent negative expiry times.
60 * Alexey Kuznetsov: Wrong group leaving behaviour, backport
61 * fix from pending 2.1.x patches.
62 * Alan Cox: Forget to enable FDDI support earlier.
63 * Alexey Kuznetsov: Fixed leaving groups on device down.
64 * Alexey Kuznetsov: Accordance to igmp-v2-06 draft.
65 * David L Stevens: IGMPv3 support, with help from
69 #include <linux/module.h>
70 #include <linux/slab.h>
71 #include <linux/uaccess.h>
72 #include <linux/types.h>
73 #include <linux/kernel.h>
74 #include <linux/jiffies.h>
75 #include <linux/string.h>
76 #include <linux/socket.h>
77 #include <linux/sockios.h>
79 #include <linux/inet.h>
80 #include <linux/netdevice.h>
81 #include <linux/skbuff.h>
82 #include <linux/inetdevice.h>
83 #include <linux/igmp.h>
84 #include <linux/if_arp.h>
85 #include <linux/rtnetlink.h>
86 #include <linux/times.h>
87 #include <linux/pkt_sched.h>
88 #include <linux/byteorder/generic.h>
90 #include <net/net_namespace.h>
93 #include <net/protocol.h>
94 #include <net/route.h>
96 #include <net/checksum.h>
97 #include <net/inet_common.h>
98 #include <linux/netfilter_ipv4.h>
99 #ifdef CONFIG_IP_MROUTE
100 #include <linux/mroute.h>
102 #ifdef CONFIG_PROC_FS
103 #include <linux/proc_fs.h>
104 #include <linux/seq_file.h>
107 #ifdef CONFIG_IP_MULTICAST
108 /* Parameter names and values are taken from igmp-v2-06 draft */
110 #define IGMP_QUERY_INTERVAL (125*HZ)
111 #define IGMP_QUERY_RESPONSE_INTERVAL (10*HZ)
113 #define IGMP_INITIAL_REPORT_DELAY (1)
115 /* IGMP_INITIAL_REPORT_DELAY is not from IGMP specs!
116 * IGMP specs require to report membership immediately after
117 * joining a group, but we delay the first report by a
118 * small interval. It seems more natural and still does not
119 * contradict to specs provided this delay is small enough.
122 #define IGMP_V1_SEEN(in_dev) \
123 (IPV4_DEVCONF_ALL(dev_net(in_dev->dev), FORCE_IGMP_VERSION) == 1 || \
124 IN_DEV_CONF_GET((in_dev), FORCE_IGMP_VERSION) == 1 || \
125 ((in_dev)->mr_v1_seen && \
126 time_before(jiffies, (in_dev)->mr_v1_seen)))
127 #define IGMP_V2_SEEN(in_dev) \
128 (IPV4_DEVCONF_ALL(dev_net(in_dev->dev), FORCE_IGMP_VERSION) == 2 || \
129 IN_DEV_CONF_GET((in_dev), FORCE_IGMP_VERSION) == 2 || \
130 ((in_dev)->mr_v2_seen && \
131 time_before(jiffies, (in_dev)->mr_v2_seen)))
133 static int unsolicited_report_interval(struct in_device
*in_dev
)
135 int interval_ms
, interval_jiffies
;
137 if (IGMP_V1_SEEN(in_dev
) || IGMP_V2_SEEN(in_dev
))
138 interval_ms
= IN_DEV_CONF_GET(
140 IGMPV2_UNSOLICITED_REPORT_INTERVAL
);
142 interval_ms
= IN_DEV_CONF_GET(
144 IGMPV3_UNSOLICITED_REPORT_INTERVAL
);
146 interval_jiffies
= msecs_to_jiffies(interval_ms
);
148 /* _timer functions can't handle a delay of 0 jiffies so ensure
149 * we always return a positive value.
151 if (interval_jiffies
<= 0)
152 interval_jiffies
= 1;
153 return interval_jiffies
;
156 static void igmpv3_add_delrec(struct in_device
*in_dev
, struct ip_mc_list
*im
,
158 static void igmpv3_del_delrec(struct in_device
*in_dev
, struct ip_mc_list
*im
);
159 static void igmpv3_clear_delrec(struct in_device
*in_dev
);
160 static int sf_setstate(struct ip_mc_list
*pmc
);
161 static void sf_markstate(struct ip_mc_list
*pmc
);
163 static void ip_mc_clear_src(struct ip_mc_list
*pmc
);
164 static int ip_mc_add_src(struct in_device
*in_dev
, __be32
*pmca
, int sfmode
,
165 int sfcount
, __be32
*psfsrc
, int delta
);
167 static void ip_ma_put(struct ip_mc_list
*im
)
169 if (refcount_dec_and_test(&im
->refcnt
)) {
170 in_dev_put(im
->interface
);
175 #define for_each_pmc_rcu(in_dev, pmc) \
176 for (pmc = rcu_dereference(in_dev->mc_list); \
178 pmc = rcu_dereference(pmc->next_rcu))
180 #define for_each_pmc_rtnl(in_dev, pmc) \
181 for (pmc = rtnl_dereference(in_dev->mc_list); \
183 pmc = rtnl_dereference(pmc->next_rcu))
185 static void ip_sf_list_clear_all(struct ip_sf_list
*psf
)
187 struct ip_sf_list
*next
;
196 #ifdef CONFIG_IP_MULTICAST
202 static void igmp_stop_timer(struct ip_mc_list
*im
)
204 spin_lock_bh(&im
->lock
);
205 if (del_timer(&im
->timer
))
206 refcount_dec(&im
->refcnt
);
209 im
->unsolicit_count
= 0;
210 spin_unlock_bh(&im
->lock
);
213 /* It must be called with locked im->lock */
214 static void igmp_start_timer(struct ip_mc_list
*im
, int max_delay
)
216 int tv
= prandom_u32() % max_delay
;
219 if (!mod_timer(&im
->timer
, jiffies
+tv
+2))
220 refcount_inc(&im
->refcnt
);
223 static void igmp_gq_start_timer(struct in_device
*in_dev
)
225 int tv
= prandom_u32() % in_dev
->mr_maxdelay
;
226 unsigned long exp
= jiffies
+ tv
+ 2;
228 if (in_dev
->mr_gq_running
&&
229 time_after_eq(exp
, (in_dev
->mr_gq_timer
).expires
))
232 in_dev
->mr_gq_running
= 1;
233 if (!mod_timer(&in_dev
->mr_gq_timer
, exp
))
237 static void igmp_ifc_start_timer(struct in_device
*in_dev
, int delay
)
239 int tv
= prandom_u32() % delay
;
241 if (!mod_timer(&in_dev
->mr_ifc_timer
, jiffies
+tv
+2))
245 static void igmp_mod_timer(struct ip_mc_list
*im
, int max_delay
)
247 spin_lock_bh(&im
->lock
);
248 im
->unsolicit_count
= 0;
249 if (del_timer(&im
->timer
)) {
250 if ((long)(im
->timer
.expires
-jiffies
) < max_delay
) {
251 add_timer(&im
->timer
);
253 spin_unlock_bh(&im
->lock
);
256 refcount_dec(&im
->refcnt
);
258 igmp_start_timer(im
, max_delay
);
259 spin_unlock_bh(&im
->lock
);
264 * Send an IGMP report.
267 #define IGMP_SIZE (sizeof(struct igmphdr)+sizeof(struct iphdr)+4)
270 static int is_in(struct ip_mc_list
*pmc
, struct ip_sf_list
*psf
, int type
,
271 int gdeleted
, int sdeleted
)
274 case IGMPV3_MODE_IS_INCLUDE
:
275 case IGMPV3_MODE_IS_EXCLUDE
:
276 if (gdeleted
|| sdeleted
)
278 if (!(pmc
->gsquery
&& !psf
->sf_gsresp
)) {
279 if (pmc
->sfmode
== MCAST_INCLUDE
)
281 /* don't include if this source is excluded
284 if (psf
->sf_count
[MCAST_INCLUDE
])
285 return type
== IGMPV3_MODE_IS_INCLUDE
;
286 return pmc
->sfcount
[MCAST_EXCLUDE
] ==
287 psf
->sf_count
[MCAST_EXCLUDE
];
290 case IGMPV3_CHANGE_TO_INCLUDE
:
291 if (gdeleted
|| sdeleted
)
293 return psf
->sf_count
[MCAST_INCLUDE
] != 0;
294 case IGMPV3_CHANGE_TO_EXCLUDE
:
295 if (gdeleted
|| sdeleted
)
297 if (pmc
->sfcount
[MCAST_EXCLUDE
] == 0 ||
298 psf
->sf_count
[MCAST_INCLUDE
])
300 return pmc
->sfcount
[MCAST_EXCLUDE
] ==
301 psf
->sf_count
[MCAST_EXCLUDE
];
302 case IGMPV3_ALLOW_NEW_SOURCES
:
303 if (gdeleted
|| !psf
->sf_crcount
)
305 return (pmc
->sfmode
== MCAST_INCLUDE
) ^ sdeleted
;
306 case IGMPV3_BLOCK_OLD_SOURCES
:
307 if (pmc
->sfmode
== MCAST_INCLUDE
)
308 return gdeleted
|| (psf
->sf_crcount
&& sdeleted
);
309 return psf
->sf_crcount
&& !gdeleted
&& !sdeleted
;
315 igmp_scount(struct ip_mc_list
*pmc
, int type
, int gdeleted
, int sdeleted
)
317 struct ip_sf_list
*psf
;
320 for (psf
= pmc
->sources
; psf
; psf
= psf
->sf_next
) {
321 if (!is_in(pmc
, psf
, type
, gdeleted
, sdeleted
))
328 /* source address selection per RFC 3376 section 4.2.13 */
329 static __be32
igmpv3_get_srcaddr(struct net_device
*dev
,
330 const struct flowi4
*fl4
)
332 struct in_device
*in_dev
= __in_dev_get_rcu(dev
);
333 const struct in_ifaddr
*ifa
;
336 return htonl(INADDR_ANY
);
338 in_dev_for_each_ifa_rcu(ifa
, in_dev
) {
339 if (fl4
->saddr
== ifa
->ifa_local
)
343 return htonl(INADDR_ANY
);
346 static struct sk_buff
*igmpv3_newpack(struct net_device
*dev
, unsigned int mtu
)
351 struct igmpv3_report
*pig
;
352 struct net
*net
= dev_net(dev
);
354 int hlen
= LL_RESERVED_SPACE(dev
);
355 int tlen
= dev
->needed_tailroom
;
356 unsigned int size
= mtu
;
359 skb
= alloc_skb(size
+ hlen
+ tlen
,
360 GFP_ATOMIC
| __GFP_NOWARN
);
367 skb
->priority
= TC_PRIO_CONTROL
;
369 rt
= ip_route_output_ports(net
, &fl4
, NULL
, IGMPV3_ALL_MCR
, 0,
371 IPPROTO_IGMP
, 0, dev
->ifindex
);
377 skb_dst_set(skb
, &rt
->dst
);
380 skb_reserve(skb
, hlen
);
381 skb_tailroom_reserve(skb
, mtu
, tlen
);
383 skb_reset_network_header(skb
);
385 skb_put(skb
, sizeof(struct iphdr
) + 4);
388 pip
->ihl
= (sizeof(struct iphdr
)+4)>>2;
390 pip
->frag_off
= htons(IP_DF
);
392 pip
->daddr
= fl4
.daddr
;
395 pip
->saddr
= igmpv3_get_srcaddr(dev
, &fl4
);
398 pip
->protocol
= IPPROTO_IGMP
;
399 pip
->tot_len
= 0; /* filled in later */
400 ip_select_ident(net
, skb
, NULL
);
401 ((u8
*)&pip
[1])[0] = IPOPT_RA
;
402 ((u8
*)&pip
[1])[1] = 4;
403 ((u8
*)&pip
[1])[2] = 0;
404 ((u8
*)&pip
[1])[3] = 0;
406 skb
->transport_header
= skb
->network_header
+ sizeof(struct iphdr
) + 4;
407 skb_put(skb
, sizeof(*pig
));
408 pig
= igmpv3_report_hdr(skb
);
409 pig
->type
= IGMPV3_HOST_MEMBERSHIP_REPORT
;
417 static int igmpv3_sendpack(struct sk_buff
*skb
)
419 struct igmphdr
*pig
= igmp_hdr(skb
);
420 const int igmplen
= skb_tail_pointer(skb
) - skb_transport_header(skb
);
422 pig
->csum
= ip_compute_csum(igmp_hdr(skb
), igmplen
);
424 return ip_local_out(dev_net(skb_dst(skb
)->dev
), skb
->sk
, skb
);
427 static int grec_size(struct ip_mc_list
*pmc
, int type
, int gdel
, int sdel
)
429 return sizeof(struct igmpv3_grec
) + 4*igmp_scount(pmc
, type
, gdel
, sdel
);
432 static struct sk_buff
*add_grhead(struct sk_buff
*skb
, struct ip_mc_list
*pmc
,
433 int type
, struct igmpv3_grec
**ppgr
, unsigned int mtu
)
435 struct net_device
*dev
= pmc
->interface
->dev
;
436 struct igmpv3_report
*pih
;
437 struct igmpv3_grec
*pgr
;
440 skb
= igmpv3_newpack(dev
, mtu
);
444 pgr
= skb_put(skb
, sizeof(struct igmpv3_grec
));
445 pgr
->grec_type
= type
;
446 pgr
->grec_auxwords
= 0;
448 pgr
->grec_mca
= pmc
->multiaddr
;
449 pih
= igmpv3_report_hdr(skb
);
450 pih
->ngrec
= htons(ntohs(pih
->ngrec
)+1);
455 #define AVAILABLE(skb) ((skb) ? skb_availroom(skb) : 0)
457 static struct sk_buff
*add_grec(struct sk_buff
*skb
, struct ip_mc_list
*pmc
,
458 int type
, int gdeleted
, int sdeleted
)
460 struct net_device
*dev
= pmc
->interface
->dev
;
461 struct net
*net
= dev_net(dev
);
462 struct igmpv3_report
*pih
;
463 struct igmpv3_grec
*pgr
= NULL
;
464 struct ip_sf_list
*psf
, *psf_next
, *psf_prev
, **psf_list
;
465 int scount
, stotal
, first
, isquery
, truncate
;
468 if (pmc
->multiaddr
== IGMP_ALL_HOSTS
)
470 if (ipv4_is_local_multicast(pmc
->multiaddr
) && !net
->ipv4
.sysctl_igmp_llm_reports
)
473 mtu
= READ_ONCE(dev
->mtu
);
474 if (mtu
< IPV4_MIN_MTU
)
477 isquery
= type
== IGMPV3_MODE_IS_INCLUDE
||
478 type
== IGMPV3_MODE_IS_EXCLUDE
;
479 truncate
= type
== IGMPV3_MODE_IS_EXCLUDE
||
480 type
== IGMPV3_CHANGE_TO_EXCLUDE
;
484 psf_list
= sdeleted
? &pmc
->tomb
: &pmc
->sources
;
489 pih
= skb
? igmpv3_report_hdr(skb
) : NULL
;
491 /* EX and TO_EX get a fresh packet, if needed */
493 if (pih
&& pih
->ngrec
&&
494 AVAILABLE(skb
) < grec_size(pmc
, type
, gdeleted
, sdeleted
)) {
496 igmpv3_sendpack(skb
);
497 skb
= igmpv3_newpack(dev
, mtu
);
502 for (psf
= *psf_list
; psf
; psf
= psf_next
) {
505 psf_next
= psf
->sf_next
;
507 if (!is_in(pmc
, psf
, type
, gdeleted
, sdeleted
)) {
512 /* Based on RFC3376 5.1. Should not send source-list change
513 * records when there is a filter mode change.
515 if (((gdeleted
&& pmc
->sfmode
== MCAST_EXCLUDE
) ||
516 (!gdeleted
&& pmc
->crcount
)) &&
517 (type
== IGMPV3_ALLOW_NEW_SOURCES
||
518 type
== IGMPV3_BLOCK_OLD_SOURCES
) && psf
->sf_crcount
)
519 goto decrease_sf_crcount
;
521 /* clear marks on query responses */
525 if (AVAILABLE(skb
) < sizeof(__be32
) +
526 first
*sizeof(struct igmpv3_grec
)) {
527 if (truncate
&& !first
)
528 break; /* truncate these */
530 pgr
->grec_nsrcs
= htons(scount
);
532 igmpv3_sendpack(skb
);
533 skb
= igmpv3_newpack(dev
, mtu
);
538 skb
= add_grhead(skb
, pmc
, type
, &pgr
, mtu
);
543 psrc
= skb_put(skb
, sizeof(__be32
));
544 *psrc
= psf
->sf_inaddr
;
546 if ((type
== IGMPV3_ALLOW_NEW_SOURCES
||
547 type
== IGMPV3_BLOCK_OLD_SOURCES
) && psf
->sf_crcount
) {
550 if ((sdeleted
|| gdeleted
) && psf
->sf_crcount
== 0) {
552 psf_prev
->sf_next
= psf
->sf_next
;
554 *psf_list
= psf
->sf_next
;
564 if (type
== IGMPV3_ALLOW_NEW_SOURCES
||
565 type
== IGMPV3_BLOCK_OLD_SOURCES
)
567 if (pmc
->crcount
|| isquery
) {
568 /* make sure we have room for group header */
569 if (skb
&& AVAILABLE(skb
) < sizeof(struct igmpv3_grec
)) {
570 igmpv3_sendpack(skb
);
571 skb
= NULL
; /* add_grhead will get a new one */
573 skb
= add_grhead(skb
, pmc
, type
, &pgr
, mtu
);
577 pgr
->grec_nsrcs
= htons(scount
);
580 pmc
->gsquery
= 0; /* clear query state on report */
584 static int igmpv3_send_report(struct in_device
*in_dev
, struct ip_mc_list
*pmc
)
586 struct sk_buff
*skb
= NULL
;
587 struct net
*net
= dev_net(in_dev
->dev
);
592 for_each_pmc_rcu(in_dev
, pmc
) {
593 if (pmc
->multiaddr
== IGMP_ALL_HOSTS
)
595 if (ipv4_is_local_multicast(pmc
->multiaddr
) &&
596 !net
->ipv4
.sysctl_igmp_llm_reports
)
598 spin_lock_bh(&pmc
->lock
);
599 if (pmc
->sfcount
[MCAST_EXCLUDE
])
600 type
= IGMPV3_MODE_IS_EXCLUDE
;
602 type
= IGMPV3_MODE_IS_INCLUDE
;
603 skb
= add_grec(skb
, pmc
, type
, 0, 0);
604 spin_unlock_bh(&pmc
->lock
);
608 spin_lock_bh(&pmc
->lock
);
609 if (pmc
->sfcount
[MCAST_EXCLUDE
])
610 type
= IGMPV3_MODE_IS_EXCLUDE
;
612 type
= IGMPV3_MODE_IS_INCLUDE
;
613 skb
= add_grec(skb
, pmc
, type
, 0, 0);
614 spin_unlock_bh(&pmc
->lock
);
618 return igmpv3_sendpack(skb
);
622 * remove zero-count source records from a source filter list
624 static void igmpv3_clear_zeros(struct ip_sf_list
**ppsf
)
626 struct ip_sf_list
*psf_prev
, *psf_next
, *psf
;
629 for (psf
= *ppsf
; psf
; psf
= psf_next
) {
630 psf_next
= psf
->sf_next
;
631 if (psf
->sf_crcount
== 0) {
633 psf_prev
->sf_next
= psf
->sf_next
;
635 *ppsf
= psf
->sf_next
;
642 static void kfree_pmc(struct ip_mc_list
*pmc
)
644 ip_sf_list_clear_all(pmc
->sources
);
645 ip_sf_list_clear_all(pmc
->tomb
);
649 static void igmpv3_send_cr(struct in_device
*in_dev
)
651 struct ip_mc_list
*pmc
, *pmc_prev
, *pmc_next
;
652 struct sk_buff
*skb
= NULL
;
656 spin_lock_bh(&in_dev
->mc_tomb_lock
);
660 for (pmc
= in_dev
->mc_tomb
; pmc
; pmc
= pmc_next
) {
661 pmc_next
= pmc
->next
;
662 if (pmc
->sfmode
== MCAST_INCLUDE
) {
663 type
= IGMPV3_BLOCK_OLD_SOURCES
;
664 dtype
= IGMPV3_BLOCK_OLD_SOURCES
;
665 skb
= add_grec(skb
, pmc
, type
, 1, 0);
666 skb
= add_grec(skb
, pmc
, dtype
, 1, 1);
669 if (pmc
->sfmode
== MCAST_EXCLUDE
) {
670 type
= IGMPV3_CHANGE_TO_INCLUDE
;
671 skb
= add_grec(skb
, pmc
, type
, 1, 0);
674 if (pmc
->crcount
== 0) {
675 igmpv3_clear_zeros(&pmc
->tomb
);
676 igmpv3_clear_zeros(&pmc
->sources
);
679 if (pmc
->crcount
== 0 && !pmc
->tomb
&& !pmc
->sources
) {
681 pmc_prev
->next
= pmc_next
;
683 in_dev
->mc_tomb
= pmc_next
;
684 in_dev_put(pmc
->interface
);
689 spin_unlock_bh(&in_dev
->mc_tomb_lock
);
692 for_each_pmc_rcu(in_dev
, pmc
) {
693 spin_lock_bh(&pmc
->lock
);
694 if (pmc
->sfcount
[MCAST_EXCLUDE
]) {
695 type
= IGMPV3_BLOCK_OLD_SOURCES
;
696 dtype
= IGMPV3_ALLOW_NEW_SOURCES
;
698 type
= IGMPV3_ALLOW_NEW_SOURCES
;
699 dtype
= IGMPV3_BLOCK_OLD_SOURCES
;
701 skb
= add_grec(skb
, pmc
, type
, 0, 0);
702 skb
= add_grec(skb
, pmc
, dtype
, 0, 1); /* deleted sources */
704 /* filter mode changes */
706 if (pmc
->sfmode
== MCAST_EXCLUDE
)
707 type
= IGMPV3_CHANGE_TO_EXCLUDE
;
709 type
= IGMPV3_CHANGE_TO_INCLUDE
;
710 skb
= add_grec(skb
, pmc
, type
, 0, 0);
713 spin_unlock_bh(&pmc
->lock
);
719 (void) igmpv3_sendpack(skb
);
722 static int igmp_send_report(struct in_device
*in_dev
, struct ip_mc_list
*pmc
,
729 struct net_device
*dev
= in_dev
->dev
;
730 struct net
*net
= dev_net(dev
);
731 __be32 group
= pmc
? pmc
->multiaddr
: 0;
736 if (type
== IGMPV3_HOST_MEMBERSHIP_REPORT
)
737 return igmpv3_send_report(in_dev
, pmc
);
739 if (ipv4_is_local_multicast(group
) && !net
->ipv4
.sysctl_igmp_llm_reports
)
742 if (type
== IGMP_HOST_LEAVE_MESSAGE
)
743 dst
= IGMP_ALL_ROUTER
;
747 rt
= ip_route_output_ports(net
, &fl4
, NULL
, dst
, 0,
749 IPPROTO_IGMP
, 0, dev
->ifindex
);
753 hlen
= LL_RESERVED_SPACE(dev
);
754 tlen
= dev
->needed_tailroom
;
755 skb
= alloc_skb(IGMP_SIZE
+ hlen
+ tlen
, GFP_ATOMIC
);
760 skb
->priority
= TC_PRIO_CONTROL
;
762 skb_dst_set(skb
, &rt
->dst
);
764 skb_reserve(skb
, hlen
);
766 skb_reset_network_header(skb
);
768 skb_put(skb
, sizeof(struct iphdr
) + 4);
771 iph
->ihl
= (sizeof(struct iphdr
)+4)>>2;
773 iph
->frag_off
= htons(IP_DF
);
776 iph
->saddr
= fl4
.saddr
;
777 iph
->protocol
= IPPROTO_IGMP
;
778 ip_select_ident(net
, skb
, NULL
);
779 ((u8
*)&iph
[1])[0] = IPOPT_RA
;
780 ((u8
*)&iph
[1])[1] = 4;
781 ((u8
*)&iph
[1])[2] = 0;
782 ((u8
*)&iph
[1])[3] = 0;
784 ih
= skb_put(skb
, sizeof(struct igmphdr
));
789 ih
->csum
= ip_compute_csum((void *)ih
, sizeof(struct igmphdr
));
791 return ip_local_out(net
, skb
->sk
, skb
);
794 static void igmp_gq_timer_expire(struct timer_list
*t
)
796 struct in_device
*in_dev
= from_timer(in_dev
, t
, mr_gq_timer
);
798 in_dev
->mr_gq_running
= 0;
799 igmpv3_send_report(in_dev
, NULL
);
803 static void igmp_ifc_timer_expire(struct timer_list
*t
)
805 struct in_device
*in_dev
= from_timer(in_dev
, t
, mr_ifc_timer
);
808 igmpv3_send_cr(in_dev
);
810 mr_ifc_count
= READ_ONCE(in_dev
->mr_ifc_count
);
813 if (cmpxchg(&in_dev
->mr_ifc_count
,
815 mr_ifc_count
- 1) != mr_ifc_count
)
817 igmp_ifc_start_timer(in_dev
,
818 unsolicited_report_interval(in_dev
));
823 static void igmp_ifc_event(struct in_device
*in_dev
)
825 struct net
*net
= dev_net(in_dev
->dev
);
826 if (IGMP_V1_SEEN(in_dev
) || IGMP_V2_SEEN(in_dev
))
828 WRITE_ONCE(in_dev
->mr_ifc_count
, in_dev
->mr_qrv
?: net
->ipv4
.sysctl_igmp_qrv
);
829 igmp_ifc_start_timer(in_dev
, 1);
833 static void igmp_timer_expire(struct timer_list
*t
)
835 struct ip_mc_list
*im
= from_timer(im
, t
, timer
);
836 struct in_device
*in_dev
= im
->interface
;
838 spin_lock(&im
->lock
);
841 if (im
->unsolicit_count
&& --im
->unsolicit_count
)
842 igmp_start_timer(im
, unsolicited_report_interval(in_dev
));
845 spin_unlock(&im
->lock
);
847 if (IGMP_V1_SEEN(in_dev
))
848 igmp_send_report(in_dev
, im
, IGMP_HOST_MEMBERSHIP_REPORT
);
849 else if (IGMP_V2_SEEN(in_dev
))
850 igmp_send_report(in_dev
, im
, IGMPV2_HOST_MEMBERSHIP_REPORT
);
852 igmp_send_report(in_dev
, im
, IGMPV3_HOST_MEMBERSHIP_REPORT
);
857 /* mark EXCLUDE-mode sources */
858 static int igmp_xmarksources(struct ip_mc_list
*pmc
, int nsrcs
, __be32
*srcs
)
860 struct ip_sf_list
*psf
;
864 for (psf
= pmc
->sources
; psf
; psf
= psf
->sf_next
) {
867 for (i
= 0; i
< nsrcs
; i
++) {
868 /* skip inactive filters */
869 if (psf
->sf_count
[MCAST_INCLUDE
] ||
870 pmc
->sfcount
[MCAST_EXCLUDE
] !=
871 psf
->sf_count
[MCAST_EXCLUDE
])
873 if (srcs
[i
] == psf
->sf_inaddr
) {
880 if (scount
== nsrcs
) /* all sources excluded */
885 static int igmp_marksources(struct ip_mc_list
*pmc
, int nsrcs
, __be32
*srcs
)
887 struct ip_sf_list
*psf
;
890 if (pmc
->sfmode
== MCAST_EXCLUDE
)
891 return igmp_xmarksources(pmc
, nsrcs
, srcs
);
893 /* mark INCLUDE-mode sources */
895 for (psf
= pmc
->sources
; psf
; psf
= psf
->sf_next
) {
898 for (i
= 0; i
< nsrcs
; i
++)
899 if (srcs
[i
] == psf
->sf_inaddr
) {
913 /* return true if packet was dropped */
914 static bool igmp_heard_report(struct in_device
*in_dev
, __be32 group
)
916 struct ip_mc_list
*im
;
917 struct net
*net
= dev_net(in_dev
->dev
);
919 /* Timers are only set for non-local groups */
921 if (group
== IGMP_ALL_HOSTS
)
923 if (ipv4_is_local_multicast(group
) && !net
->ipv4
.sysctl_igmp_llm_reports
)
927 for_each_pmc_rcu(in_dev
, im
) {
928 if (im
->multiaddr
== group
) {
937 /* return true if packet was dropped */
938 static bool igmp_heard_query(struct in_device
*in_dev
, struct sk_buff
*skb
,
941 struct igmphdr
*ih
= igmp_hdr(skb
);
942 struct igmpv3_query
*ih3
= igmpv3_query_hdr(skb
);
943 struct ip_mc_list
*im
;
944 __be32 group
= ih
->group
;
947 struct net
*net
= dev_net(in_dev
->dev
);
952 /* Alas, old v1 router presents here. */
954 max_delay
= IGMP_QUERY_RESPONSE_INTERVAL
;
955 in_dev
->mr_v1_seen
= jiffies
+
956 (in_dev
->mr_qrv
* in_dev
->mr_qi
) +
960 /* v2 router present */
961 max_delay
= ih
->code
*(HZ
/IGMP_TIMER_SCALE
);
962 in_dev
->mr_v2_seen
= jiffies
+
963 (in_dev
->mr_qrv
* in_dev
->mr_qi
) +
966 /* cancel the interface change timer */
967 WRITE_ONCE(in_dev
->mr_ifc_count
, 0);
968 if (del_timer(&in_dev
->mr_ifc_timer
))
969 __in_dev_put(in_dev
);
970 /* clear deleted report items */
971 igmpv3_clear_delrec(in_dev
);
972 } else if (len
< 12) {
973 return true; /* ignore bogus packet; freed by caller */
974 } else if (IGMP_V1_SEEN(in_dev
)) {
975 /* This is a v3 query with v1 queriers present */
976 max_delay
= IGMP_QUERY_RESPONSE_INTERVAL
;
978 } else if (IGMP_V2_SEEN(in_dev
)) {
979 /* this is a v3 query with v2 queriers present;
980 * Interpretation of the max_delay code is problematic here.
981 * A real v2 host would use ih_code directly, while v3 has a
982 * different encoding. We use the v3 encoding as more likely
983 * to be intended in a v3 query.
985 max_delay
= IGMPV3_MRC(ih3
->code
)*(HZ
/IGMP_TIMER_SCALE
);
987 max_delay
= 1; /* can't mod w/ 0 */
989 if (!pskb_may_pull(skb
, sizeof(struct igmpv3_query
)))
992 ih3
= igmpv3_query_hdr(skb
);
994 if (!pskb_may_pull(skb
, sizeof(struct igmpv3_query
)
995 + ntohs(ih3
->nsrcs
)*sizeof(__be32
)))
997 ih3
= igmpv3_query_hdr(skb
);
1000 max_delay
= IGMPV3_MRC(ih3
->code
)*(HZ
/IGMP_TIMER_SCALE
);
1002 max_delay
= 1; /* can't mod w/ 0 */
1003 in_dev
->mr_maxdelay
= max_delay
;
1005 /* RFC3376, 4.1.6. QRV and 4.1.7. QQIC, when the most recently
1006 * received value was zero, use the default or statically
1009 in_dev
->mr_qrv
= ih3
->qrv
?: net
->ipv4
.sysctl_igmp_qrv
;
1010 in_dev
->mr_qi
= IGMPV3_QQIC(ih3
->qqic
)*HZ
?: IGMP_QUERY_INTERVAL
;
1012 /* RFC3376, 8.3. Query Response Interval:
1013 * The number of seconds represented by the [Query Response
1014 * Interval] must be less than the [Query Interval].
1016 if (in_dev
->mr_qri
>= in_dev
->mr_qi
)
1017 in_dev
->mr_qri
= (in_dev
->mr_qi
/HZ
- 1)*HZ
;
1019 if (!group
) { /* general query */
1021 return true; /* no sources allowed */
1022 igmp_gq_start_timer(in_dev
);
1025 /* mark sources to include, if group & source-specific */
1026 mark
= ih3
->nsrcs
!= 0;
1030 * - Start the timers in all of our membership records
1031 * that the query applies to for the interface on
1032 * which the query arrived excl. those that belong
1033 * to a "local" group (224.0.0.X)
1034 * - For timers already running check if they need to
1036 * - Use the igmp->igmp_code field as the maximum
1040 for_each_pmc_rcu(in_dev
, im
) {
1043 if (group
&& group
!= im
->multiaddr
)
1045 if (im
->multiaddr
== IGMP_ALL_HOSTS
)
1047 if (ipv4_is_local_multicast(im
->multiaddr
) &&
1048 !net
->ipv4
.sysctl_igmp_llm_reports
)
1050 spin_lock_bh(&im
->lock
);
1052 im
->gsquery
= im
->gsquery
&& mark
;
1055 changed
= !im
->gsquery
||
1056 igmp_marksources(im
, ntohs(ih3
->nsrcs
), ih3
->srcs
);
1057 spin_unlock_bh(&im
->lock
);
1059 igmp_mod_timer(im
, max_delay
);
1065 /* called in rcu_read_lock() section */
1066 int igmp_rcv(struct sk_buff
*skb
)
1068 /* This basically follows the spec line by line -- see RFC1112 */
1070 struct net_device
*dev
= skb
->dev
;
1071 struct in_device
*in_dev
;
1073 bool dropped
= true;
1075 if (netif_is_l3_master(dev
)) {
1076 dev
= dev_get_by_index_rcu(dev_net(dev
), IPCB(skb
)->iif
);
1081 in_dev
= __in_dev_get_rcu(dev
);
1085 if (!pskb_may_pull(skb
, sizeof(struct igmphdr
)))
1088 if (skb_checksum_simple_validate(skb
))
1093 case IGMP_HOST_MEMBERSHIP_QUERY
:
1094 dropped
= igmp_heard_query(in_dev
, skb
, len
);
1096 case IGMP_HOST_MEMBERSHIP_REPORT
:
1097 case IGMPV2_HOST_MEMBERSHIP_REPORT
:
1098 /* Is it our report looped back? */
1099 if (rt_is_output_route(skb_rtable(skb
)))
1101 /* don't rely on MC router hearing unicast reports */
1102 if (skb
->pkt_type
== PACKET_MULTICAST
||
1103 skb
->pkt_type
== PACKET_BROADCAST
)
1104 dropped
= igmp_heard_report(in_dev
, ih
->group
);
1107 #ifdef CONFIG_IP_PIMSM_V1
1108 return pim_rcv_v1(skb
);
1110 case IGMPV3_HOST_MEMBERSHIP_REPORT
:
1113 case IGMP_HOST_LEAVE_MESSAGE
:
1115 case IGMP_MTRACE_RESP
:
1133 * Add a filter to a device
1136 static void ip_mc_filter_add(struct in_device
*in_dev
, __be32 addr
)
1138 char buf
[MAX_ADDR_LEN
];
1139 struct net_device
*dev
= in_dev
->dev
;
1141 /* Checking for IFF_MULTICAST here is WRONG-WRONG-WRONG.
1142 We will get multicast token leakage, when IFF_MULTICAST
1143 is changed. This check should be done in ndo_set_rx_mode
1144 routine. Something sort of:
1145 if (dev->mc_list && dev->flags&IFF_MULTICAST) { do it; }
1148 if (arp_mc_map(addr
, buf
, dev
, 0) == 0)
1149 dev_mc_add(dev
, buf
);
1153 * Remove a filter from a device
1156 static void ip_mc_filter_del(struct in_device
*in_dev
, __be32 addr
)
1158 char buf
[MAX_ADDR_LEN
];
1159 struct net_device
*dev
= in_dev
->dev
;
1161 if (arp_mc_map(addr
, buf
, dev
, 0) == 0)
1162 dev_mc_del(dev
, buf
);
1165 #ifdef CONFIG_IP_MULTICAST
1167 * deleted ip_mc_list manipulation
1169 static void igmpv3_add_delrec(struct in_device
*in_dev
, struct ip_mc_list
*im
,
1172 struct ip_mc_list
*pmc
;
1173 struct net
*net
= dev_net(in_dev
->dev
);
1175 /* this is an "ip_mc_list" for convenience; only the fields below
1176 * are actually used. In particular, the refcnt and users are not
1177 * used for management of the delete list. Using the same structure
1178 * for deleted items allows change reports to use common code with
1179 * non-deleted or query-response MCA's.
1181 pmc
= kzalloc(sizeof(*pmc
), gfp
);
1184 spin_lock_init(&pmc
->lock
);
1185 spin_lock_bh(&im
->lock
);
1186 pmc
->interface
= im
->interface
;
1187 in_dev_hold(in_dev
);
1188 pmc
->multiaddr
= im
->multiaddr
;
1189 pmc
->crcount
= in_dev
->mr_qrv
?: net
->ipv4
.sysctl_igmp_qrv
;
1190 pmc
->sfmode
= im
->sfmode
;
1191 if (pmc
->sfmode
== MCAST_INCLUDE
) {
1192 struct ip_sf_list
*psf
;
1194 pmc
->tomb
= im
->tomb
;
1195 pmc
->sources
= im
->sources
;
1196 im
->tomb
= im
->sources
= NULL
;
1197 for (psf
= pmc
->sources
; psf
; psf
= psf
->sf_next
)
1198 psf
->sf_crcount
= pmc
->crcount
;
1200 spin_unlock_bh(&im
->lock
);
1202 spin_lock_bh(&in_dev
->mc_tomb_lock
);
1203 pmc
->next
= in_dev
->mc_tomb
;
1204 in_dev
->mc_tomb
= pmc
;
1205 spin_unlock_bh(&in_dev
->mc_tomb_lock
);
1209 * restore ip_mc_list deleted records
1211 static void igmpv3_del_delrec(struct in_device
*in_dev
, struct ip_mc_list
*im
)
1213 struct ip_mc_list
*pmc
, *pmc_prev
;
1214 struct ip_sf_list
*psf
;
1215 struct net
*net
= dev_net(in_dev
->dev
);
1216 __be32 multiaddr
= im
->multiaddr
;
1218 spin_lock_bh(&in_dev
->mc_tomb_lock
);
1220 for (pmc
= in_dev
->mc_tomb
; pmc
; pmc
= pmc
->next
) {
1221 if (pmc
->multiaddr
== multiaddr
)
1227 pmc_prev
->next
= pmc
->next
;
1229 in_dev
->mc_tomb
= pmc
->next
;
1231 spin_unlock_bh(&in_dev
->mc_tomb_lock
);
1233 spin_lock_bh(&im
->lock
);
1235 im
->interface
= pmc
->interface
;
1236 if (im
->sfmode
== MCAST_INCLUDE
) {
1237 swap(im
->tomb
, pmc
->tomb
);
1238 swap(im
->sources
, pmc
->sources
);
1239 for (psf
= im
->sources
; psf
; psf
= psf
->sf_next
)
1240 psf
->sf_crcount
= in_dev
->mr_qrv
?: net
->ipv4
.sysctl_igmp_qrv
;
1242 im
->crcount
= in_dev
->mr_qrv
?: net
->ipv4
.sysctl_igmp_qrv
;
1244 in_dev_put(pmc
->interface
);
1247 spin_unlock_bh(&im
->lock
);
1251 * flush ip_mc_list deleted records
1253 static void igmpv3_clear_delrec(struct in_device
*in_dev
)
1255 struct ip_mc_list
*pmc
, *nextpmc
;
1257 spin_lock_bh(&in_dev
->mc_tomb_lock
);
1258 pmc
= in_dev
->mc_tomb
;
1259 in_dev
->mc_tomb
= NULL
;
1260 spin_unlock_bh(&in_dev
->mc_tomb_lock
);
1262 for (; pmc
; pmc
= nextpmc
) {
1263 nextpmc
= pmc
->next
;
1264 ip_mc_clear_src(pmc
);
1265 in_dev_put(pmc
->interface
);
1268 /* clear dead sources, too */
1270 for_each_pmc_rcu(in_dev
, pmc
) {
1271 struct ip_sf_list
*psf
;
1273 spin_lock_bh(&pmc
->lock
);
1276 spin_unlock_bh(&pmc
->lock
);
1277 ip_sf_list_clear_all(psf
);
1283 static void __igmp_group_dropped(struct ip_mc_list
*im
, gfp_t gfp
)
1285 struct in_device
*in_dev
= im
->interface
;
1286 #ifdef CONFIG_IP_MULTICAST
1287 struct net
*net
= dev_net(in_dev
->dev
);
1293 ip_mc_filter_del(in_dev
, im
->multiaddr
);
1296 #ifdef CONFIG_IP_MULTICAST
1297 if (im
->multiaddr
== IGMP_ALL_HOSTS
)
1299 if (ipv4_is_local_multicast(im
->multiaddr
) && !net
->ipv4
.sysctl_igmp_llm_reports
)
1302 reporter
= im
->reporter
;
1303 igmp_stop_timer(im
);
1305 if (!in_dev
->dead
) {
1306 if (IGMP_V1_SEEN(in_dev
))
1308 if (IGMP_V2_SEEN(in_dev
)) {
1310 igmp_send_report(in_dev
, im
, IGMP_HOST_LEAVE_MESSAGE
);
1314 igmpv3_add_delrec(in_dev
, im
, gfp
);
1316 igmp_ifc_event(in_dev
);
1321 static void igmp_group_dropped(struct ip_mc_list
*im
)
1323 __igmp_group_dropped(im
, GFP_KERNEL
);
1326 static void igmp_group_added(struct ip_mc_list
*im
)
1328 struct in_device
*in_dev
= im
->interface
;
1329 #ifdef CONFIG_IP_MULTICAST
1330 struct net
*net
= dev_net(in_dev
->dev
);
1333 if (im
->loaded
== 0) {
1335 ip_mc_filter_add(in_dev
, im
->multiaddr
);
1338 #ifdef CONFIG_IP_MULTICAST
1339 if (im
->multiaddr
== IGMP_ALL_HOSTS
)
1341 if (ipv4_is_local_multicast(im
->multiaddr
) && !net
->ipv4
.sysctl_igmp_llm_reports
)
1347 im
->unsolicit_count
= net
->ipv4
.sysctl_igmp_qrv
;
1348 if (IGMP_V1_SEEN(in_dev
) || IGMP_V2_SEEN(in_dev
)) {
1349 spin_lock_bh(&im
->lock
);
1350 igmp_start_timer(im
, IGMP_INITIAL_REPORT_DELAY
);
1351 spin_unlock_bh(&im
->lock
);
1356 /* Based on RFC3376 5.1, for newly added INCLUDE SSM, we should
1357 * not send filter-mode change record as the mode should be from
1360 if (im
->sfmode
== MCAST_EXCLUDE
)
1361 im
->crcount
= in_dev
->mr_qrv
?: net
->ipv4
.sysctl_igmp_qrv
;
1363 igmp_ifc_event(in_dev
);
1369 * Multicast list managers
1372 static u32
ip_mc_hash(const struct ip_mc_list
*im
)
1374 return hash_32((__force u32
)im
->multiaddr
, MC_HASH_SZ_LOG
);
1377 static void ip_mc_hash_add(struct in_device
*in_dev
,
1378 struct ip_mc_list
*im
)
1380 struct ip_mc_list __rcu
**mc_hash
;
1383 mc_hash
= rtnl_dereference(in_dev
->mc_hash
);
1385 hash
= ip_mc_hash(im
);
1386 im
->next_hash
= mc_hash
[hash
];
1387 rcu_assign_pointer(mc_hash
[hash
], im
);
1391 /* do not use a hash table for small number of items */
1392 if (in_dev
->mc_count
< 4)
1395 mc_hash
= kzalloc(sizeof(struct ip_mc_list
*) << MC_HASH_SZ_LOG
,
1400 for_each_pmc_rtnl(in_dev
, im
) {
1401 hash
= ip_mc_hash(im
);
1402 im
->next_hash
= mc_hash
[hash
];
1403 RCU_INIT_POINTER(mc_hash
[hash
], im
);
1406 rcu_assign_pointer(in_dev
->mc_hash
, mc_hash
);
1409 static void ip_mc_hash_remove(struct in_device
*in_dev
,
1410 struct ip_mc_list
*im
)
1412 struct ip_mc_list __rcu
**mc_hash
= rtnl_dereference(in_dev
->mc_hash
);
1413 struct ip_mc_list
*aux
;
1417 mc_hash
+= ip_mc_hash(im
);
1418 while ((aux
= rtnl_dereference(*mc_hash
)) != im
)
1419 mc_hash
= &aux
->next_hash
;
1420 *mc_hash
= im
->next_hash
;
1425 * A socket has joined a multicast group on device dev.
1427 static void ____ip_mc_inc_group(struct in_device
*in_dev
, __be32 addr
,
1428 unsigned int mode
, gfp_t gfp
)
1430 struct ip_mc_list
*im
;
1434 for_each_pmc_rtnl(in_dev
, im
) {
1435 if (im
->multiaddr
== addr
) {
1437 ip_mc_add_src(in_dev
, &addr
, mode
, 0, NULL
, 0);
1442 im
= kzalloc(sizeof(*im
), gfp
);
1447 im
->interface
= in_dev
;
1448 in_dev_hold(in_dev
);
1449 im
->multiaddr
= addr
;
1450 /* initial mode is (EX, empty) */
1452 im
->sfcount
[mode
] = 1;
1453 refcount_set(&im
->refcnt
, 1);
1454 spin_lock_init(&im
->lock
);
1455 #ifdef CONFIG_IP_MULTICAST
1456 timer_setup(&im
->timer
, igmp_timer_expire
, 0);
1459 im
->next_rcu
= in_dev
->mc_list
;
1461 rcu_assign_pointer(in_dev
->mc_list
, im
);
1463 ip_mc_hash_add(in_dev
, im
);
1465 #ifdef CONFIG_IP_MULTICAST
1466 igmpv3_del_delrec(in_dev
, im
);
1468 igmp_group_added(im
);
1470 ip_rt_multicast_event(in_dev
);
1475 void __ip_mc_inc_group(struct in_device
*in_dev
, __be32 addr
, gfp_t gfp
)
1477 ____ip_mc_inc_group(in_dev
, addr
, MCAST_EXCLUDE
, gfp
);
1479 EXPORT_SYMBOL(__ip_mc_inc_group
);
1481 void ip_mc_inc_group(struct in_device
*in_dev
, __be32 addr
)
1483 __ip_mc_inc_group(in_dev
, addr
, GFP_KERNEL
);
1485 EXPORT_SYMBOL(ip_mc_inc_group
);
1487 static int ip_mc_check_iphdr(struct sk_buff
*skb
)
1489 const struct iphdr
*iph
;
1491 unsigned int offset
= skb_network_offset(skb
) + sizeof(*iph
);
1493 if (!pskb_may_pull(skb
, offset
))
1498 if (iph
->version
!= 4 || ip_hdrlen(skb
) < sizeof(*iph
))
1501 offset
+= ip_hdrlen(skb
) - sizeof(*iph
);
1503 if (!pskb_may_pull(skb
, offset
))
1508 if (unlikely(ip_fast_csum((u8
*)iph
, iph
->ihl
)))
1511 len
= skb_network_offset(skb
) + ntohs(iph
->tot_len
);
1512 if (skb
->len
< len
|| len
< offset
)
1515 skb_set_transport_header(skb
, offset
);
1520 static int ip_mc_check_igmp_reportv3(struct sk_buff
*skb
)
1522 unsigned int len
= skb_transport_offset(skb
);
1524 len
+= sizeof(struct igmpv3_report
);
1526 return ip_mc_may_pull(skb
, len
) ? 0 : -EINVAL
;
1529 static int ip_mc_check_igmp_query(struct sk_buff
*skb
)
1531 unsigned int transport_len
= ip_transport_len(skb
);
1535 if (transport_len
!= sizeof(struct igmphdr
)) {
1537 if (transport_len
< sizeof(struct igmpv3_query
))
1540 len
= skb_transport_offset(skb
) + sizeof(struct igmpv3_query
);
1541 if (!ip_mc_may_pull(skb
, len
))
1545 /* RFC2236+RFC3376 (IGMPv2+IGMPv3) require the multicast link layer
1546 * all-systems destination addresses (224.0.0.1) for general queries
1548 if (!igmp_hdr(skb
)->group
&&
1549 ip_hdr(skb
)->daddr
!= htonl(INADDR_ALLHOSTS_GROUP
))
1555 static int ip_mc_check_igmp_msg(struct sk_buff
*skb
)
1557 switch (igmp_hdr(skb
)->type
) {
1558 case IGMP_HOST_LEAVE_MESSAGE
:
1559 case IGMP_HOST_MEMBERSHIP_REPORT
:
1560 case IGMPV2_HOST_MEMBERSHIP_REPORT
:
1562 case IGMPV3_HOST_MEMBERSHIP_REPORT
:
1563 return ip_mc_check_igmp_reportv3(skb
);
1564 case IGMP_HOST_MEMBERSHIP_QUERY
:
1565 return ip_mc_check_igmp_query(skb
);
1571 static __sum16
ip_mc_validate_checksum(struct sk_buff
*skb
)
1573 return skb_checksum_simple_validate(skb
);
1576 static int ip_mc_check_igmp_csum(struct sk_buff
*skb
)
1578 unsigned int len
= skb_transport_offset(skb
) + sizeof(struct igmphdr
);
1579 unsigned int transport_len
= ip_transport_len(skb
);
1580 struct sk_buff
*skb_chk
;
1582 if (!ip_mc_may_pull(skb
, len
))
1585 skb_chk
= skb_checksum_trimmed(skb
, transport_len
,
1586 ip_mc_validate_checksum
);
1597 * ip_mc_check_igmp - checks whether this is a sane IGMP packet
1598 * @skb: the skb to validate
1600 * Checks whether an IPv4 packet is a valid IGMP packet. If so sets
1601 * skb transport header accordingly and returns zero.
1603 * -EINVAL: A broken packet was detected, i.e. it violates some internet
1605 * -ENOMSG: IP header validation succeeded but it is not an IGMP packet.
1606 * -ENOMEM: A memory allocation failure happened.
1608 * Caller needs to set the skb network header and free any returned skb if it
1609 * differs from the provided skb.
1611 int ip_mc_check_igmp(struct sk_buff
*skb
)
1613 int ret
= ip_mc_check_iphdr(skb
);
1618 if (ip_hdr(skb
)->protocol
!= IPPROTO_IGMP
)
1621 ret
= ip_mc_check_igmp_csum(skb
);
1625 return ip_mc_check_igmp_msg(skb
);
1627 EXPORT_SYMBOL(ip_mc_check_igmp
);
1630 * Resend IGMP JOIN report; used by netdev notifier.
1632 static void ip_mc_rejoin_groups(struct in_device
*in_dev
)
1634 #ifdef CONFIG_IP_MULTICAST
1635 struct ip_mc_list
*im
;
1637 struct net
*net
= dev_net(in_dev
->dev
);
1641 for_each_pmc_rtnl(in_dev
, im
) {
1642 if (im
->multiaddr
== IGMP_ALL_HOSTS
)
1644 if (ipv4_is_local_multicast(im
->multiaddr
) &&
1645 !net
->ipv4
.sysctl_igmp_llm_reports
)
1648 /* a failover is happening and switches
1649 * must be notified immediately
1651 if (IGMP_V1_SEEN(in_dev
))
1652 type
= IGMP_HOST_MEMBERSHIP_REPORT
;
1653 else if (IGMP_V2_SEEN(in_dev
))
1654 type
= IGMPV2_HOST_MEMBERSHIP_REPORT
;
1656 type
= IGMPV3_HOST_MEMBERSHIP_REPORT
;
1657 igmp_send_report(in_dev
, im
, type
);
1663 * A socket has left a multicast group on device dev
1666 void __ip_mc_dec_group(struct in_device
*in_dev
, __be32 addr
, gfp_t gfp
)
1668 struct ip_mc_list
*i
;
1669 struct ip_mc_list __rcu
**ip
;
1673 for (ip
= &in_dev
->mc_list
;
1674 (i
= rtnl_dereference(*ip
)) != NULL
;
1675 ip
= &i
->next_rcu
) {
1676 if (i
->multiaddr
== addr
) {
1677 if (--i
->users
== 0) {
1678 ip_mc_hash_remove(in_dev
, i
);
1681 __igmp_group_dropped(i
, gfp
);
1685 ip_rt_multicast_event(in_dev
);
1694 EXPORT_SYMBOL(__ip_mc_dec_group
);
1696 /* Device changing type */
1698 void ip_mc_unmap(struct in_device
*in_dev
)
1700 struct ip_mc_list
*pmc
;
1704 for_each_pmc_rtnl(in_dev
, pmc
)
1705 igmp_group_dropped(pmc
);
1708 void ip_mc_remap(struct in_device
*in_dev
)
1710 struct ip_mc_list
*pmc
;
1714 for_each_pmc_rtnl(in_dev
, pmc
) {
1715 #ifdef CONFIG_IP_MULTICAST
1716 igmpv3_del_delrec(in_dev
, pmc
);
1718 igmp_group_added(pmc
);
1722 /* Device going down */
1724 void ip_mc_down(struct in_device
*in_dev
)
1726 struct ip_mc_list
*pmc
;
1730 for_each_pmc_rtnl(in_dev
, pmc
)
1731 igmp_group_dropped(pmc
);
1733 #ifdef CONFIG_IP_MULTICAST
1734 WRITE_ONCE(in_dev
->mr_ifc_count
, 0);
1735 if (del_timer(&in_dev
->mr_ifc_timer
))
1736 __in_dev_put(in_dev
);
1737 in_dev
->mr_gq_running
= 0;
1738 if (del_timer(&in_dev
->mr_gq_timer
))
1739 __in_dev_put(in_dev
);
1742 ip_mc_dec_group(in_dev
, IGMP_ALL_HOSTS
);
1745 #ifdef CONFIG_IP_MULTICAST
1746 static void ip_mc_reset(struct in_device
*in_dev
)
1748 struct net
*net
= dev_net(in_dev
->dev
);
1750 in_dev
->mr_qi
= IGMP_QUERY_INTERVAL
;
1751 in_dev
->mr_qri
= IGMP_QUERY_RESPONSE_INTERVAL
;
1752 in_dev
->mr_qrv
= net
->ipv4
.sysctl_igmp_qrv
;
1755 static void ip_mc_reset(struct in_device
*in_dev
)
1760 void ip_mc_init_dev(struct in_device
*in_dev
)
1764 #ifdef CONFIG_IP_MULTICAST
1765 timer_setup(&in_dev
->mr_gq_timer
, igmp_gq_timer_expire
, 0);
1766 timer_setup(&in_dev
->mr_ifc_timer
, igmp_ifc_timer_expire
, 0);
1768 ip_mc_reset(in_dev
);
1770 spin_lock_init(&in_dev
->mc_tomb_lock
);
1773 /* Device going up */
1775 void ip_mc_up(struct in_device
*in_dev
)
1777 struct ip_mc_list
*pmc
;
1781 ip_mc_reset(in_dev
);
1782 ip_mc_inc_group(in_dev
, IGMP_ALL_HOSTS
);
1784 for_each_pmc_rtnl(in_dev
, pmc
) {
1785 #ifdef CONFIG_IP_MULTICAST
1786 igmpv3_del_delrec(in_dev
, pmc
);
1788 igmp_group_added(pmc
);
1793 * Device is about to be destroyed: clean up.
1796 void ip_mc_destroy_dev(struct in_device
*in_dev
)
1798 struct ip_mc_list
*i
;
1802 /* Deactivate timers */
1804 #ifdef CONFIG_IP_MULTICAST
1805 igmpv3_clear_delrec(in_dev
);
1808 while ((i
= rtnl_dereference(in_dev
->mc_list
)) != NULL
) {
1809 in_dev
->mc_list
= i
->next_rcu
;
1816 /* RTNL is locked */
1817 static struct in_device
*ip_mc_find_dev(struct net
*net
, struct ip_mreqn
*imr
)
1819 struct net_device
*dev
= NULL
;
1820 struct in_device
*idev
= NULL
;
1822 if (imr
->imr_ifindex
) {
1823 idev
= inetdev_by_index(net
, imr
->imr_ifindex
);
1826 if (imr
->imr_address
.s_addr
) {
1827 dev
= __ip_dev_find(net
, imr
->imr_address
.s_addr
, false);
1833 struct rtable
*rt
= ip_route_output(net
,
1834 imr
->imr_multiaddr
.s_addr
,
1842 imr
->imr_ifindex
= dev
->ifindex
;
1843 idev
= __in_dev_get_rtnl(dev
);
1849 * Join a socket to a group
1852 static int ip_mc_del1_src(struct ip_mc_list
*pmc
, int sfmode
,
1855 struct ip_sf_list
*psf
, *psf_prev
;
1859 for (psf
= pmc
->sources
; psf
; psf
= psf
->sf_next
) {
1860 if (psf
->sf_inaddr
== *psfsrc
)
1864 if (!psf
|| psf
->sf_count
[sfmode
] == 0) {
1865 /* source filter not found, or count wrong => bug */
1868 psf
->sf_count
[sfmode
]--;
1869 if (psf
->sf_count
[sfmode
] == 0) {
1870 ip_rt_multicast_event(pmc
->interface
);
1872 if (!psf
->sf_count
[MCAST_INCLUDE
] && !psf
->sf_count
[MCAST_EXCLUDE
]) {
1873 #ifdef CONFIG_IP_MULTICAST
1874 struct in_device
*in_dev
= pmc
->interface
;
1875 struct net
*net
= dev_net(in_dev
->dev
);
1878 /* no more filters for this source */
1880 psf_prev
->sf_next
= psf
->sf_next
;
1882 pmc
->sources
= psf
->sf_next
;
1883 #ifdef CONFIG_IP_MULTICAST
1884 if (psf
->sf_oldin
&&
1885 !IGMP_V1_SEEN(in_dev
) && !IGMP_V2_SEEN(in_dev
)) {
1886 psf
->sf_crcount
= in_dev
->mr_qrv
?: net
->ipv4
.sysctl_igmp_qrv
;
1887 psf
->sf_next
= pmc
->tomb
;
1897 #ifndef CONFIG_IP_MULTICAST
1898 #define igmp_ifc_event(x) do { } while (0)
1901 static int ip_mc_del_src(struct in_device
*in_dev
, __be32
*pmca
, int sfmode
,
1902 int sfcount
, __be32
*psfsrc
, int delta
)
1904 struct ip_mc_list
*pmc
;
1911 for_each_pmc_rcu(in_dev
, pmc
) {
1912 if (*pmca
== pmc
->multiaddr
)
1916 /* MCA not found?? bug */
1920 spin_lock_bh(&pmc
->lock
);
1922 #ifdef CONFIG_IP_MULTICAST
1927 if (!pmc
->sfcount
[sfmode
])
1929 pmc
->sfcount
[sfmode
]--;
1932 for (i
= 0; i
< sfcount
; i
++) {
1933 int rv
= ip_mc_del1_src(pmc
, sfmode
, &psfsrc
[i
]);
1935 changerec
|= rv
> 0;
1939 if (pmc
->sfmode
== MCAST_EXCLUDE
&&
1940 pmc
->sfcount
[MCAST_EXCLUDE
] == 0 &&
1941 pmc
->sfcount
[MCAST_INCLUDE
]) {
1942 #ifdef CONFIG_IP_MULTICAST
1943 struct ip_sf_list
*psf
;
1944 struct net
*net
= dev_net(in_dev
->dev
);
1947 /* filter mode change */
1948 pmc
->sfmode
= MCAST_INCLUDE
;
1949 #ifdef CONFIG_IP_MULTICAST
1950 pmc
->crcount
= in_dev
->mr_qrv
?: net
->ipv4
.sysctl_igmp_qrv
;
1951 WRITE_ONCE(in_dev
->mr_ifc_count
, pmc
->crcount
);
1952 for (psf
= pmc
->sources
; psf
; psf
= psf
->sf_next
)
1953 psf
->sf_crcount
= 0;
1954 igmp_ifc_event(pmc
->interface
);
1955 } else if (sf_setstate(pmc
) || changerec
) {
1956 igmp_ifc_event(pmc
->interface
);
1960 spin_unlock_bh(&pmc
->lock
);
1965 * Add multicast single-source filter to the interface list
1967 static int ip_mc_add1_src(struct ip_mc_list
*pmc
, int sfmode
,
1970 struct ip_sf_list
*psf
, *psf_prev
;
1973 for (psf
= pmc
->sources
; psf
; psf
= psf
->sf_next
) {
1974 if (psf
->sf_inaddr
== *psfsrc
)
1979 psf
= kzalloc(sizeof(*psf
), GFP_ATOMIC
);
1982 psf
->sf_inaddr
= *psfsrc
;
1984 psf_prev
->sf_next
= psf
;
1988 psf
->sf_count
[sfmode
]++;
1989 if (psf
->sf_count
[sfmode
] == 1) {
1990 ip_rt_multicast_event(pmc
->interface
);
1995 #ifdef CONFIG_IP_MULTICAST
1996 static void sf_markstate(struct ip_mc_list
*pmc
)
1998 struct ip_sf_list
*psf
;
1999 int mca_xcount
= pmc
->sfcount
[MCAST_EXCLUDE
];
2001 for (psf
= pmc
->sources
; psf
; psf
= psf
->sf_next
)
2002 if (pmc
->sfcount
[MCAST_EXCLUDE
]) {
2003 psf
->sf_oldin
= mca_xcount
==
2004 psf
->sf_count
[MCAST_EXCLUDE
] &&
2005 !psf
->sf_count
[MCAST_INCLUDE
];
2007 psf
->sf_oldin
= psf
->sf_count
[MCAST_INCLUDE
] != 0;
2010 static int sf_setstate(struct ip_mc_list
*pmc
)
2012 struct ip_sf_list
*psf
, *dpsf
;
2013 int mca_xcount
= pmc
->sfcount
[MCAST_EXCLUDE
];
2014 int qrv
= pmc
->interface
->mr_qrv
;
2018 for (psf
= pmc
->sources
; psf
; psf
= psf
->sf_next
) {
2019 if (pmc
->sfcount
[MCAST_EXCLUDE
]) {
2020 new_in
= mca_xcount
== psf
->sf_count
[MCAST_EXCLUDE
] &&
2021 !psf
->sf_count
[MCAST_INCLUDE
];
2023 new_in
= psf
->sf_count
[MCAST_INCLUDE
] != 0;
2025 if (!psf
->sf_oldin
) {
2026 struct ip_sf_list
*prev
= NULL
;
2028 for (dpsf
= pmc
->tomb
; dpsf
; dpsf
= dpsf
->sf_next
) {
2029 if (dpsf
->sf_inaddr
== psf
->sf_inaddr
)
2035 prev
->sf_next
= dpsf
->sf_next
;
2037 pmc
->tomb
= dpsf
->sf_next
;
2040 psf
->sf_crcount
= qrv
;
2043 } else if (psf
->sf_oldin
) {
2045 psf
->sf_crcount
= 0;
2047 * add or update "delete" records if an active filter
2050 for (dpsf
= pmc
->tomb
; dpsf
; dpsf
= dpsf
->sf_next
)
2051 if (dpsf
->sf_inaddr
== psf
->sf_inaddr
)
2054 dpsf
= kmalloc(sizeof(*dpsf
), GFP_ATOMIC
);
2058 /* pmc->lock held by callers */
2059 dpsf
->sf_next
= pmc
->tomb
;
2062 dpsf
->sf_crcount
= qrv
;
2071 * Add multicast source filter list to the interface list
2073 static int ip_mc_add_src(struct in_device
*in_dev
, __be32
*pmca
, int sfmode
,
2074 int sfcount
, __be32
*psfsrc
, int delta
)
2076 struct ip_mc_list
*pmc
;
2083 for_each_pmc_rcu(in_dev
, pmc
) {
2084 if (*pmca
== pmc
->multiaddr
)
2088 /* MCA not found?? bug */
2092 spin_lock_bh(&pmc
->lock
);
2095 #ifdef CONFIG_IP_MULTICAST
2098 isexclude
= pmc
->sfmode
== MCAST_EXCLUDE
;
2100 pmc
->sfcount
[sfmode
]++;
2102 for (i
= 0; i
< sfcount
; i
++) {
2103 err
= ip_mc_add1_src(pmc
, sfmode
, &psfsrc
[i
]);
2111 pmc
->sfcount
[sfmode
]--;
2112 for (j
= 0; j
< i
; j
++)
2113 (void) ip_mc_del1_src(pmc
, sfmode
, &psfsrc
[j
]);
2114 } else if (isexclude
!= (pmc
->sfcount
[MCAST_EXCLUDE
] != 0)) {
2115 #ifdef CONFIG_IP_MULTICAST
2116 struct ip_sf_list
*psf
;
2117 struct net
*net
= dev_net(pmc
->interface
->dev
);
2118 in_dev
= pmc
->interface
;
2121 /* filter mode change */
2122 if (pmc
->sfcount
[MCAST_EXCLUDE
])
2123 pmc
->sfmode
= MCAST_EXCLUDE
;
2124 else if (pmc
->sfcount
[MCAST_INCLUDE
])
2125 pmc
->sfmode
= MCAST_INCLUDE
;
2126 #ifdef CONFIG_IP_MULTICAST
2127 /* else no filters; keep old mode for reports */
2129 pmc
->crcount
= in_dev
->mr_qrv
?: net
->ipv4
.sysctl_igmp_qrv
;
2130 WRITE_ONCE(in_dev
->mr_ifc_count
, pmc
->crcount
);
2131 for (psf
= pmc
->sources
; psf
; psf
= psf
->sf_next
)
2132 psf
->sf_crcount
= 0;
2133 igmp_ifc_event(in_dev
);
2134 } else if (sf_setstate(pmc
)) {
2135 igmp_ifc_event(in_dev
);
2138 spin_unlock_bh(&pmc
->lock
);
2142 static void ip_mc_clear_src(struct ip_mc_list
*pmc
)
2144 struct ip_sf_list
*tomb
, *sources
;
2146 spin_lock_bh(&pmc
->lock
);
2149 sources
= pmc
->sources
;
2150 pmc
->sources
= NULL
;
2151 pmc
->sfmode
= MCAST_EXCLUDE
;
2152 pmc
->sfcount
[MCAST_INCLUDE
] = 0;
2153 pmc
->sfcount
[MCAST_EXCLUDE
] = 1;
2154 spin_unlock_bh(&pmc
->lock
);
2156 ip_sf_list_clear_all(tomb
);
2157 ip_sf_list_clear_all(sources
);
2160 /* Join a multicast group
2162 static int __ip_mc_join_group(struct sock
*sk
, struct ip_mreqn
*imr
,
2165 __be32 addr
= imr
->imr_multiaddr
.s_addr
;
2166 struct ip_mc_socklist
*iml
, *i
;
2167 struct in_device
*in_dev
;
2168 struct inet_sock
*inet
= inet_sk(sk
);
2169 struct net
*net
= sock_net(sk
);
2176 if (!ipv4_is_multicast(addr
))
2179 in_dev
= ip_mc_find_dev(net
, imr
);
2187 ifindex
= imr
->imr_ifindex
;
2188 for_each_pmc_rtnl(inet
, i
) {
2189 if (i
->multi
.imr_multiaddr
.s_addr
== addr
&&
2190 i
->multi
.imr_ifindex
== ifindex
)
2195 if (count
>= net
->ipv4
.sysctl_igmp_max_memberships
)
2197 iml
= sock_kmalloc(sk
, sizeof(*iml
), GFP_KERNEL
);
2201 memcpy(&iml
->multi
, imr
, sizeof(*imr
));
2202 iml
->next_rcu
= inet
->mc_list
;
2205 rcu_assign_pointer(inet
->mc_list
, iml
);
2206 ____ip_mc_inc_group(in_dev
, addr
, mode
, GFP_KERNEL
);
2212 /* Join ASM (Any-Source Multicast) group
2214 int ip_mc_join_group(struct sock
*sk
, struct ip_mreqn
*imr
)
2216 return __ip_mc_join_group(sk
, imr
, MCAST_EXCLUDE
);
2218 EXPORT_SYMBOL(ip_mc_join_group
);
2220 /* Join SSM (Source-Specific Multicast) group
2222 int ip_mc_join_group_ssm(struct sock
*sk
, struct ip_mreqn
*imr
,
2225 return __ip_mc_join_group(sk
, imr
, mode
);
2228 static int ip_mc_leave_src(struct sock
*sk
, struct ip_mc_socklist
*iml
,
2229 struct in_device
*in_dev
)
2231 struct ip_sf_socklist
*psf
= rtnl_dereference(iml
->sflist
);
2235 /* any-source empty exclude case */
2236 return ip_mc_del_src(in_dev
, &iml
->multi
.imr_multiaddr
.s_addr
,
2237 iml
->sfmode
, 0, NULL
, 0);
2239 err
= ip_mc_del_src(in_dev
, &iml
->multi
.imr_multiaddr
.s_addr
,
2240 iml
->sfmode
, psf
->sl_count
, psf
->sl_addr
, 0);
2241 RCU_INIT_POINTER(iml
->sflist
, NULL
);
2242 /* decrease mem now to avoid the memleak warning */
2243 atomic_sub(struct_size(psf
, sl_addr
, psf
->sl_max
), &sk
->sk_omem_alloc
);
2244 kfree_rcu(psf
, rcu
);
2248 int ip_mc_leave_group(struct sock
*sk
, struct ip_mreqn
*imr
)
2250 struct inet_sock
*inet
= inet_sk(sk
);
2251 struct ip_mc_socklist
*iml
;
2252 struct ip_mc_socklist __rcu
**imlp
;
2253 struct in_device
*in_dev
;
2254 struct net
*net
= sock_net(sk
);
2255 __be32 group
= imr
->imr_multiaddr
.s_addr
;
2257 int ret
= -EADDRNOTAVAIL
;
2261 in_dev
= ip_mc_find_dev(net
, imr
);
2262 if (!imr
->imr_ifindex
&& !imr
->imr_address
.s_addr
&& !in_dev
) {
2266 ifindex
= imr
->imr_ifindex
;
2267 for (imlp
= &inet
->mc_list
;
2268 (iml
= rtnl_dereference(*imlp
)) != NULL
;
2269 imlp
= &iml
->next_rcu
) {
2270 if (iml
->multi
.imr_multiaddr
.s_addr
!= group
)
2273 if (iml
->multi
.imr_ifindex
!= ifindex
)
2275 } else if (imr
->imr_address
.s_addr
&& imr
->imr_address
.s_addr
!=
2276 iml
->multi
.imr_address
.s_addr
)
2279 (void) ip_mc_leave_src(sk
, iml
, in_dev
);
2281 *imlp
= iml
->next_rcu
;
2284 ip_mc_dec_group(in_dev
, group
);
2286 /* decrease mem now to avoid the memleak warning */
2287 atomic_sub(sizeof(*iml
), &sk
->sk_omem_alloc
);
2288 kfree_rcu(iml
, rcu
);
2294 EXPORT_SYMBOL(ip_mc_leave_group
);
2296 int ip_mc_source(int add
, int omode
, struct sock
*sk
, struct
2297 ip_mreq_source
*mreqs
, int ifindex
)
2300 struct ip_mreqn imr
;
2301 __be32 addr
= mreqs
->imr_multiaddr
;
2302 struct ip_mc_socklist
*pmc
;
2303 struct in_device
*in_dev
= NULL
;
2304 struct inet_sock
*inet
= inet_sk(sk
);
2305 struct ip_sf_socklist
*psl
;
2306 struct net
*net
= sock_net(sk
);
2310 if (!ipv4_is_multicast(addr
))
2315 imr
.imr_multiaddr
.s_addr
= mreqs
->imr_multiaddr
;
2316 imr
.imr_address
.s_addr
= mreqs
->imr_interface
;
2317 imr
.imr_ifindex
= ifindex
;
2318 in_dev
= ip_mc_find_dev(net
, &imr
);
2324 err
= -EADDRNOTAVAIL
;
2326 for_each_pmc_rtnl(inet
, pmc
) {
2327 if ((pmc
->multi
.imr_multiaddr
.s_addr
==
2328 imr
.imr_multiaddr
.s_addr
) &&
2329 (pmc
->multi
.imr_ifindex
== imr
.imr_ifindex
))
2332 if (!pmc
) { /* must have a prior join */
2336 /* if a source filter was set, must be the same mode as before */
2338 if (pmc
->sfmode
!= omode
) {
2342 } else if (pmc
->sfmode
!= omode
) {
2343 /* allow mode switches for empty-set filters */
2344 ip_mc_add_src(in_dev
, &mreqs
->imr_multiaddr
, omode
, 0, NULL
, 0);
2345 ip_mc_del_src(in_dev
, &mreqs
->imr_multiaddr
, pmc
->sfmode
, 0,
2347 pmc
->sfmode
= omode
;
2350 psl
= rtnl_dereference(pmc
->sflist
);
2353 goto done
; /* err = -EADDRNOTAVAIL */
2355 for (i
= 0; i
< psl
->sl_count
; i
++) {
2356 rv
= memcmp(&psl
->sl_addr
[i
], &mreqs
->imr_sourceaddr
,
2361 if (rv
) /* source not found */
2362 goto done
; /* err = -EADDRNOTAVAIL */
2364 /* special case - (INCLUDE, empty) == LEAVE_GROUP */
2365 if (psl
->sl_count
== 1 && omode
== MCAST_INCLUDE
) {
2370 /* update the interface filter */
2371 ip_mc_del_src(in_dev
, &mreqs
->imr_multiaddr
, omode
, 1,
2372 &mreqs
->imr_sourceaddr
, 1);
2374 for (j
= i
+1; j
< psl
->sl_count
; j
++)
2375 psl
->sl_addr
[j
-1] = psl
->sl_addr
[j
];
2380 /* else, add a new source to the filter */
2382 if (psl
&& psl
->sl_count
>= net
->ipv4
.sysctl_igmp_max_msf
) {
2386 if (!psl
|| psl
->sl_count
== psl
->sl_max
) {
2387 struct ip_sf_socklist
*newpsl
;
2388 int count
= IP_SFBLOCK
;
2391 count
+= psl
->sl_max
;
2392 newpsl
= sock_kmalloc(sk
, struct_size(newpsl
, sl_addr
, count
),
2398 newpsl
->sl_max
= count
;
2399 newpsl
->sl_count
= count
- IP_SFBLOCK
;
2401 for (i
= 0; i
< psl
->sl_count
; i
++)
2402 newpsl
->sl_addr
[i
] = psl
->sl_addr
[i
];
2403 /* decrease mem now to avoid the memleak warning */
2404 atomic_sub(struct_size(psl
, sl_addr
, psl
->sl_max
),
2405 &sk
->sk_omem_alloc
);
2406 kfree_rcu(psl
, rcu
);
2408 rcu_assign_pointer(pmc
->sflist
, newpsl
);
2411 rv
= 1; /* > 0 for insert logic below if sl_count is 0 */
2412 for (i
= 0; i
< psl
->sl_count
; i
++) {
2413 rv
= memcmp(&psl
->sl_addr
[i
], &mreqs
->imr_sourceaddr
,
2418 if (rv
== 0) /* address already there is an error */
2420 for (j
= psl
->sl_count
-1; j
>= i
; j
--)
2421 psl
->sl_addr
[j
+1] = psl
->sl_addr
[j
];
2422 psl
->sl_addr
[i
] = mreqs
->imr_sourceaddr
;
2425 /* update the interface list */
2426 ip_mc_add_src(in_dev
, &mreqs
->imr_multiaddr
, omode
, 1,
2427 &mreqs
->imr_sourceaddr
, 1);
2430 err
= ip_mc_leave_group(sk
, &imr
);
2434 int ip_mc_msfilter(struct sock
*sk
, struct ip_msfilter
*msf
, int ifindex
)
2437 struct ip_mreqn imr
;
2438 __be32 addr
= msf
->imsf_multiaddr
;
2439 struct ip_mc_socklist
*pmc
;
2440 struct in_device
*in_dev
;
2441 struct inet_sock
*inet
= inet_sk(sk
);
2442 struct ip_sf_socklist
*newpsl
, *psl
;
2443 struct net
*net
= sock_net(sk
);
2446 if (!ipv4_is_multicast(addr
))
2448 if (msf
->imsf_fmode
!= MCAST_INCLUDE
&&
2449 msf
->imsf_fmode
!= MCAST_EXCLUDE
)
2454 imr
.imr_multiaddr
.s_addr
= msf
->imsf_multiaddr
;
2455 imr
.imr_address
.s_addr
= msf
->imsf_interface
;
2456 imr
.imr_ifindex
= ifindex
;
2457 in_dev
= ip_mc_find_dev(net
, &imr
);
2464 /* special case - (INCLUDE, empty) == LEAVE_GROUP */
2465 if (msf
->imsf_fmode
== MCAST_INCLUDE
&& msf
->imsf_numsrc
== 0) {
2470 for_each_pmc_rtnl(inet
, pmc
) {
2471 if (pmc
->multi
.imr_multiaddr
.s_addr
== msf
->imsf_multiaddr
&&
2472 pmc
->multi
.imr_ifindex
== imr
.imr_ifindex
)
2475 if (!pmc
) { /* must have a prior join */
2479 if (msf
->imsf_numsrc
) {
2480 newpsl
= sock_kmalloc(sk
, struct_size(newpsl
, sl_addr
,
2487 newpsl
->sl_max
= newpsl
->sl_count
= msf
->imsf_numsrc
;
2488 memcpy(newpsl
->sl_addr
, msf
->imsf_slist_flex
,
2489 flex_array_size(msf
, imsf_slist_flex
, msf
->imsf_numsrc
));
2490 err
= ip_mc_add_src(in_dev
, &msf
->imsf_multiaddr
,
2491 msf
->imsf_fmode
, newpsl
->sl_count
, newpsl
->sl_addr
, 0);
2493 sock_kfree_s(sk
, newpsl
,
2494 struct_size(newpsl
, sl_addr
,
2500 (void) ip_mc_add_src(in_dev
, &msf
->imsf_multiaddr
,
2501 msf
->imsf_fmode
, 0, NULL
, 0);
2503 psl
= rtnl_dereference(pmc
->sflist
);
2505 (void) ip_mc_del_src(in_dev
, &msf
->imsf_multiaddr
, pmc
->sfmode
,
2506 psl
->sl_count
, psl
->sl_addr
, 0);
2507 /* decrease mem now to avoid the memleak warning */
2508 atomic_sub(struct_size(psl
, sl_addr
, psl
->sl_max
),
2509 &sk
->sk_omem_alloc
);
2510 kfree_rcu(psl
, rcu
);
2512 (void) ip_mc_del_src(in_dev
, &msf
->imsf_multiaddr
, pmc
->sfmode
,
2514 rcu_assign_pointer(pmc
->sflist
, newpsl
);
2515 pmc
->sfmode
= msf
->imsf_fmode
;
2519 err
= ip_mc_leave_group(sk
, &imr
);
2523 int ip_mc_msfget(struct sock
*sk
, struct ip_msfilter
*msf
,
2524 struct ip_msfilter __user
*optval
, int __user
*optlen
)
2526 int err
, len
, count
, copycount
;
2527 struct ip_mreqn imr
;
2528 __be32 addr
= msf
->imsf_multiaddr
;
2529 struct ip_mc_socklist
*pmc
;
2530 struct in_device
*in_dev
;
2531 struct inet_sock
*inet
= inet_sk(sk
);
2532 struct ip_sf_socklist
*psl
;
2533 struct net
*net
= sock_net(sk
);
2537 if (!ipv4_is_multicast(addr
))
2540 imr
.imr_multiaddr
.s_addr
= msf
->imsf_multiaddr
;
2541 imr
.imr_address
.s_addr
= msf
->imsf_interface
;
2542 imr
.imr_ifindex
= 0;
2543 in_dev
= ip_mc_find_dev(net
, &imr
);
2549 err
= -EADDRNOTAVAIL
;
2551 for_each_pmc_rtnl(inet
, pmc
) {
2552 if (pmc
->multi
.imr_multiaddr
.s_addr
== msf
->imsf_multiaddr
&&
2553 pmc
->multi
.imr_ifindex
== imr
.imr_ifindex
)
2556 if (!pmc
) /* must have a prior join */
2558 msf
->imsf_fmode
= pmc
->sfmode
;
2559 psl
= rtnl_dereference(pmc
->sflist
);
2564 count
= psl
->sl_count
;
2566 copycount
= count
< msf
->imsf_numsrc
? count
: msf
->imsf_numsrc
;
2567 len
= flex_array_size(psl
, sl_addr
, copycount
);
2568 msf
->imsf_numsrc
= count
;
2569 if (put_user(IP_MSFILTER_SIZE(copycount
), optlen
) ||
2570 copy_to_user(optval
, msf
, IP_MSFILTER_SIZE(0))) {
2574 copy_to_user(&optval
->imsf_slist_flex
[0], psl
->sl_addr
, len
))
2581 int ip_mc_gsfget(struct sock
*sk
, struct group_filter
*gsf
,
2582 struct sockaddr_storage __user
*p
)
2584 int i
, count
, copycount
;
2585 struct sockaddr_in
*psin
;
2587 struct ip_mc_socklist
*pmc
;
2588 struct inet_sock
*inet
= inet_sk(sk
);
2589 struct ip_sf_socklist
*psl
;
2593 psin
= (struct sockaddr_in
*)&gsf
->gf_group
;
2594 if (psin
->sin_family
!= AF_INET
)
2596 addr
= psin
->sin_addr
.s_addr
;
2597 if (!ipv4_is_multicast(addr
))
2600 for_each_pmc_rtnl(inet
, pmc
) {
2601 if (pmc
->multi
.imr_multiaddr
.s_addr
== addr
&&
2602 pmc
->multi
.imr_ifindex
== gsf
->gf_interface
)
2605 if (!pmc
) /* must have a prior join */
2606 return -EADDRNOTAVAIL
;
2607 gsf
->gf_fmode
= pmc
->sfmode
;
2608 psl
= rtnl_dereference(pmc
->sflist
);
2609 count
= psl
? psl
->sl_count
: 0;
2610 copycount
= count
< gsf
->gf_numsrc
? count
: gsf
->gf_numsrc
;
2611 gsf
->gf_numsrc
= count
;
2612 for (i
= 0; i
< copycount
; i
++, p
++) {
2613 struct sockaddr_storage ss
;
2615 psin
= (struct sockaddr_in
*)&ss
;
2616 memset(&ss
, 0, sizeof(ss
));
2617 psin
->sin_family
= AF_INET
;
2618 psin
->sin_addr
.s_addr
= psl
->sl_addr
[i
];
2619 if (copy_to_user(p
, &ss
, sizeof(ss
)))
2626 * check if a multicast source filter allows delivery for a given <src,dst,intf>
2628 int ip_mc_sf_allow(struct sock
*sk
, __be32 loc_addr
, __be32 rmt_addr
,
2631 struct inet_sock
*inet
= inet_sk(sk
);
2632 struct ip_mc_socklist
*pmc
;
2633 struct ip_sf_socklist
*psl
;
2638 if (!ipv4_is_multicast(loc_addr
))
2642 for_each_pmc_rcu(inet
, pmc
) {
2643 if (pmc
->multi
.imr_multiaddr
.s_addr
== loc_addr
&&
2644 (pmc
->multi
.imr_ifindex
== dif
||
2645 (sdif
&& pmc
->multi
.imr_ifindex
== sdif
)))
2651 psl
= rcu_dereference(pmc
->sflist
);
2652 ret
= (pmc
->sfmode
== MCAST_EXCLUDE
);
2656 for (i
= 0; i
< psl
->sl_count
; i
++) {
2657 if (psl
->sl_addr
[i
] == rmt_addr
)
2661 if (pmc
->sfmode
== MCAST_INCLUDE
&& i
>= psl
->sl_count
)
2663 if (pmc
->sfmode
== MCAST_EXCLUDE
&& i
< psl
->sl_count
)
2673 * A socket is closing.
2676 void ip_mc_drop_socket(struct sock
*sk
)
2678 struct inet_sock
*inet
= inet_sk(sk
);
2679 struct ip_mc_socklist
*iml
;
2680 struct net
*net
= sock_net(sk
);
2686 while ((iml
= rtnl_dereference(inet
->mc_list
)) != NULL
) {
2687 struct in_device
*in_dev
;
2689 inet
->mc_list
= iml
->next_rcu
;
2690 in_dev
= inetdev_by_index(net
, iml
->multi
.imr_ifindex
);
2691 (void) ip_mc_leave_src(sk
, iml
, in_dev
);
2693 ip_mc_dec_group(in_dev
, iml
->multi
.imr_multiaddr
.s_addr
);
2694 /* decrease mem now to avoid the memleak warning */
2695 atomic_sub(sizeof(*iml
), &sk
->sk_omem_alloc
);
2696 kfree_rcu(iml
, rcu
);
2701 /* called with rcu_read_lock() */
2702 int ip_check_mc_rcu(struct in_device
*in_dev
, __be32 mc_addr
, __be32 src_addr
, u8 proto
)
2704 struct ip_mc_list
*im
;
2705 struct ip_mc_list __rcu
**mc_hash
;
2706 struct ip_sf_list
*psf
;
2709 mc_hash
= rcu_dereference(in_dev
->mc_hash
);
2711 u32 hash
= hash_32((__force u32
)mc_addr
, MC_HASH_SZ_LOG
);
2713 for (im
= rcu_dereference(mc_hash
[hash
]);
2715 im
= rcu_dereference(im
->next_hash
)) {
2716 if (im
->multiaddr
== mc_addr
)
2720 for_each_pmc_rcu(in_dev
, im
) {
2721 if (im
->multiaddr
== mc_addr
)
2725 if (im
&& proto
== IPPROTO_IGMP
) {
2729 spin_lock_bh(&im
->lock
);
2730 for (psf
= im
->sources
; psf
; psf
= psf
->sf_next
) {
2731 if (psf
->sf_inaddr
== src_addr
)
2735 rv
= psf
->sf_count
[MCAST_INCLUDE
] ||
2736 psf
->sf_count
[MCAST_EXCLUDE
] !=
2737 im
->sfcount
[MCAST_EXCLUDE
];
2739 rv
= im
->sfcount
[MCAST_EXCLUDE
] != 0;
2740 spin_unlock_bh(&im
->lock
);
2742 rv
= 1; /* unspecified source; tentatively allow */
2747 #if defined(CONFIG_PROC_FS)
2748 struct igmp_mc_iter_state
{
2749 struct seq_net_private p
;
2750 struct net_device
*dev
;
2751 struct in_device
*in_dev
;
2754 #define igmp_mc_seq_private(seq) ((struct igmp_mc_iter_state *)(seq)->private)
2756 static inline struct ip_mc_list
*igmp_mc_get_first(struct seq_file
*seq
)
2758 struct net
*net
= seq_file_net(seq
);
2759 struct ip_mc_list
*im
= NULL
;
2760 struct igmp_mc_iter_state
*state
= igmp_mc_seq_private(seq
);
2762 state
->in_dev
= NULL
;
2763 for_each_netdev_rcu(net
, state
->dev
) {
2764 struct in_device
*in_dev
;
2766 in_dev
= __in_dev_get_rcu(state
->dev
);
2769 im
= rcu_dereference(in_dev
->mc_list
);
2771 state
->in_dev
= in_dev
;
2778 static struct ip_mc_list
*igmp_mc_get_next(struct seq_file
*seq
, struct ip_mc_list
*im
)
2780 struct igmp_mc_iter_state
*state
= igmp_mc_seq_private(seq
);
2782 im
= rcu_dereference(im
->next_rcu
);
2784 state
->dev
= next_net_device_rcu(state
->dev
);
2786 state
->in_dev
= NULL
;
2789 state
->in_dev
= __in_dev_get_rcu(state
->dev
);
2792 im
= rcu_dereference(state
->in_dev
->mc_list
);
2797 static struct ip_mc_list
*igmp_mc_get_idx(struct seq_file
*seq
, loff_t pos
)
2799 struct ip_mc_list
*im
= igmp_mc_get_first(seq
);
2801 while (pos
&& (im
= igmp_mc_get_next(seq
, im
)) != NULL
)
2803 return pos
? NULL
: im
;
2806 static void *igmp_mc_seq_start(struct seq_file
*seq
, loff_t
*pos
)
2810 return *pos
? igmp_mc_get_idx(seq
, *pos
- 1) : SEQ_START_TOKEN
;
2813 static void *igmp_mc_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
2815 struct ip_mc_list
*im
;
2816 if (v
== SEQ_START_TOKEN
)
2817 im
= igmp_mc_get_first(seq
);
2819 im
= igmp_mc_get_next(seq
, v
);
2824 static void igmp_mc_seq_stop(struct seq_file
*seq
, void *v
)
2827 struct igmp_mc_iter_state
*state
= igmp_mc_seq_private(seq
);
2829 state
->in_dev
= NULL
;
2834 static int igmp_mc_seq_show(struct seq_file
*seq
, void *v
)
2836 if (v
== SEQ_START_TOKEN
)
2838 "Idx\tDevice : Count Querier\tGroup Users Timer\tReporter\n");
2840 struct ip_mc_list
*im
= (struct ip_mc_list
*)v
;
2841 struct igmp_mc_iter_state
*state
= igmp_mc_seq_private(seq
);
2845 #ifdef CONFIG_IP_MULTICAST
2846 querier
= IGMP_V1_SEEN(state
->in_dev
) ? "V1" :
2847 IGMP_V2_SEEN(state
->in_dev
) ? "V2" :
2853 if (rcu_access_pointer(state
->in_dev
->mc_list
) == im
) {
2854 seq_printf(seq
, "%d\t%-10s: %5d %7s\n",
2855 state
->dev
->ifindex
, state
->dev
->name
, state
->in_dev
->mc_count
, querier
);
2858 delta
= im
->timer
.expires
- jiffies
;
2860 "\t\t\t\t%08X %5d %d:%08lX\t\t%d\n",
2861 im
->multiaddr
, im
->users
,
2863 im
->tm_running
? jiffies_delta_to_clock_t(delta
) : 0,
2869 static const struct seq_operations igmp_mc_seq_ops
= {
2870 .start
= igmp_mc_seq_start
,
2871 .next
= igmp_mc_seq_next
,
2872 .stop
= igmp_mc_seq_stop
,
2873 .show
= igmp_mc_seq_show
,
2876 struct igmp_mcf_iter_state
{
2877 struct seq_net_private p
;
2878 struct net_device
*dev
;
2879 struct in_device
*idev
;
2880 struct ip_mc_list
*im
;
2883 #define igmp_mcf_seq_private(seq) ((struct igmp_mcf_iter_state *)(seq)->private)
2885 static inline struct ip_sf_list
*igmp_mcf_get_first(struct seq_file
*seq
)
2887 struct net
*net
= seq_file_net(seq
);
2888 struct ip_sf_list
*psf
= NULL
;
2889 struct ip_mc_list
*im
= NULL
;
2890 struct igmp_mcf_iter_state
*state
= igmp_mcf_seq_private(seq
);
2894 for_each_netdev_rcu(net
, state
->dev
) {
2895 struct in_device
*idev
;
2896 idev
= __in_dev_get_rcu(state
->dev
);
2897 if (unlikely(!idev
))
2899 im
= rcu_dereference(idev
->mc_list
);
2901 spin_lock_bh(&im
->lock
);
2908 spin_unlock_bh(&im
->lock
);
2914 static struct ip_sf_list
*igmp_mcf_get_next(struct seq_file
*seq
, struct ip_sf_list
*psf
)
2916 struct igmp_mcf_iter_state
*state
= igmp_mcf_seq_private(seq
);
2920 spin_unlock_bh(&state
->im
->lock
);
2921 state
->im
= state
->im
->next
;
2922 while (!state
->im
) {
2923 state
->dev
= next_net_device_rcu(state
->dev
);
2928 state
->idev
= __in_dev_get_rcu(state
->dev
);
2931 state
->im
= rcu_dereference(state
->idev
->mc_list
);
2935 spin_lock_bh(&state
->im
->lock
);
2936 psf
= state
->im
->sources
;
2942 static struct ip_sf_list
*igmp_mcf_get_idx(struct seq_file
*seq
, loff_t pos
)
2944 struct ip_sf_list
*psf
= igmp_mcf_get_first(seq
);
2946 while (pos
&& (psf
= igmp_mcf_get_next(seq
, psf
)) != NULL
)
2948 return pos
? NULL
: psf
;
2951 static void *igmp_mcf_seq_start(struct seq_file
*seq
, loff_t
*pos
)
2955 return *pos
? igmp_mcf_get_idx(seq
, *pos
- 1) : SEQ_START_TOKEN
;
2958 static void *igmp_mcf_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
2960 struct ip_sf_list
*psf
;
2961 if (v
== SEQ_START_TOKEN
)
2962 psf
= igmp_mcf_get_first(seq
);
2964 psf
= igmp_mcf_get_next(seq
, v
);
2969 static void igmp_mcf_seq_stop(struct seq_file
*seq
, void *v
)
2972 struct igmp_mcf_iter_state
*state
= igmp_mcf_seq_private(seq
);
2973 if (likely(state
->im
)) {
2974 spin_unlock_bh(&state
->im
->lock
);
2982 static int igmp_mcf_seq_show(struct seq_file
*seq
, void *v
)
2984 struct ip_sf_list
*psf
= (struct ip_sf_list
*)v
;
2985 struct igmp_mcf_iter_state
*state
= igmp_mcf_seq_private(seq
);
2987 if (v
== SEQ_START_TOKEN
) {
2988 seq_puts(seq
, "Idx Device MCA SRC INC EXC\n");
2992 "0x%08x %6lu %6lu\n",
2993 state
->dev
->ifindex
, state
->dev
->name
,
2994 ntohl(state
->im
->multiaddr
),
2995 ntohl(psf
->sf_inaddr
),
2996 psf
->sf_count
[MCAST_INCLUDE
],
2997 psf
->sf_count
[MCAST_EXCLUDE
]);
3002 static const struct seq_operations igmp_mcf_seq_ops
= {
3003 .start
= igmp_mcf_seq_start
,
3004 .next
= igmp_mcf_seq_next
,
3005 .stop
= igmp_mcf_seq_stop
,
3006 .show
= igmp_mcf_seq_show
,
3009 static int __net_init
igmp_net_init(struct net
*net
)
3011 struct proc_dir_entry
*pde
;
3014 pde
= proc_create_net("igmp", 0444, net
->proc_net
, &igmp_mc_seq_ops
,
3015 sizeof(struct igmp_mc_iter_state
));
3018 pde
= proc_create_net("mcfilter", 0444, net
->proc_net
,
3019 &igmp_mcf_seq_ops
, sizeof(struct igmp_mcf_iter_state
));
3022 err
= inet_ctl_sock_create(&net
->ipv4
.mc_autojoin_sk
, AF_INET
,
3023 SOCK_DGRAM
, 0, net
);
3025 pr_err("Failed to initialize the IGMP autojoin socket (err %d)\n",
3033 remove_proc_entry("mcfilter", net
->proc_net
);
3035 remove_proc_entry("igmp", net
->proc_net
);
3040 static void __net_exit
igmp_net_exit(struct net
*net
)
3042 remove_proc_entry("mcfilter", net
->proc_net
);
3043 remove_proc_entry("igmp", net
->proc_net
);
3044 inet_ctl_sock_destroy(net
->ipv4
.mc_autojoin_sk
);
3047 static struct pernet_operations igmp_net_ops
= {
3048 .init
= igmp_net_init
,
3049 .exit
= igmp_net_exit
,
3053 static int igmp_netdev_event(struct notifier_block
*this,
3054 unsigned long event
, void *ptr
)
3056 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
3057 struct in_device
*in_dev
;
3060 case NETDEV_RESEND_IGMP
:
3061 in_dev
= __in_dev_get_rtnl(dev
);
3063 ip_mc_rejoin_groups(in_dev
);
3071 static struct notifier_block igmp_notifier
= {
3072 .notifier_call
= igmp_netdev_event
,
3075 int __init
igmp_mc_init(void)
3077 #if defined(CONFIG_PROC_FS)
3080 err
= register_pernet_subsys(&igmp_net_ops
);
3083 err
= register_netdevice_notifier(&igmp_notifier
);
3085 goto reg_notif_fail
;
3089 unregister_pernet_subsys(&igmp_net_ops
);
3092 return register_netdevice_notifier(&igmp_notifier
);