2 * Linux NET3: Internet Group Management Protocol [IGMP]
4 * This code implements the IGMP protocol as defined in RFC1112. There has
5 * been a further revision of this protocol since which is now supported.
7 * If you have trouble with this module be careful what gcc you have used,
8 * the older version didn't come out right using gcc 2.5.8, the newer one
9 * seems to fall out with gcc 2.6.2.
11 * Version: $Id: igmp.c,v 1.47 2002/02/01 22:01:03 davem Exp $
14 * Alan Cox <Alan.Cox@linux.org>
16 * This program is free software; you can redistribute it and/or
17 * modify it under the terms of the GNU General Public License
18 * as published by the Free Software Foundation; either version
19 * 2 of the License, or (at your option) any later version.
23 * Alan Cox : Added lots of __inline__ to optimise
24 * the memory usage of all the tiny little
26 * Alan Cox : Dumped the header building experiment.
27 * Alan Cox : Minor tweaks ready for multicast routing
28 * and extended IGMP protocol.
29 * Alan Cox : Removed a load of inline directives. Gcc 2.5.8
30 * writes utterly bogus code otherwise (sigh)
31 * fixed IGMP loopback to behave in the manner
32 * desired by mrouted, fixed the fact it has been
33 * broken since 1.3.6 and cleaned up a few minor
36 * Chih-Jen Chang : Tried to revise IGMP to Version 2
37 * Tsu-Sheng Tsao E-mail: chihjenc@scf.usc.edu and tsusheng@scf.usc.edu
38 * The enhancements are mainly based on Steve Deering's
39 * ipmulti-3.5 source code.
40 * Chih-Jen Chang : Added the igmp_get_mrouter_info and
41 * Tsu-Sheng Tsao igmp_set_mrouter_info to keep track of
42 * the mrouted version on that device.
43 * Chih-Jen Chang : Added the max_resp_time parameter to
44 * Tsu-Sheng Tsao igmp_heard_query(). Using this parameter
45 * to identify the multicast router version
46 * and do what the IGMP version 2 specified.
47 * Chih-Jen Chang : Added a timer to revert to IGMP V2 router
48 * Tsu-Sheng Tsao if the specified time expired.
49 * Alan Cox : Stop IGMP from 0.0.0.0 being accepted.
50 * Alan Cox : Use GFP_ATOMIC in the right places.
51 * Christian Daudt : igmp timer wasn't set for local group
52 * memberships but was being deleted,
53 * which caused a "del_timer() called
54 * from %p with timer not initialized\n"
56 * Christian Daudt : removed del_timer from
57 * igmp_timer_expire function (960205).
58 * Christian Daudt : igmp_heard_report now only calls
59 * igmp_timer_expire if tm->running is
61 * Malcolm Beattie : ttl comparison wrong in igmp_rcv made
62 * igmp_heard_query never trigger. Expiry
63 * miscalculation fixed in igmp_heard_query
64 * and random() made to return unsigned to
65 * prevent negative expiry times.
66 * Alexey Kuznetsov: Wrong group leaving behaviour, backport
67 * fix from pending 2.1.x patches.
68 * Alan Cox: Forget to enable FDDI support earlier.
69 * Alexey Kuznetsov: Fixed leaving groups on device down.
70 * Alexey Kuznetsov: Accordance to igmp-v2-06 draft.
71 * David L Stevens: IGMPv3 support, with help from
75 #include <linux/module.h>
76 #include <asm/uaccess.h>
77 #include <asm/system.h>
78 #include <linux/types.h>
79 #include <linux/kernel.h>
80 #include <linux/jiffies.h>
81 #include <linux/string.h>
82 #include <linux/socket.h>
83 #include <linux/sockios.h>
85 #include <linux/inet.h>
86 #include <linux/netdevice.h>
87 #include <linux/skbuff.h>
88 #include <linux/inetdevice.h>
89 #include <linux/igmp.h>
90 #include <linux/if_arp.h>
91 #include <linux/rtnetlink.h>
92 #include <linux/times.h>
94 #include <net/net_namespace.h>
97 #include <net/protocol.h>
98 #include <net/route.h>
100 #include <net/checksum.h>
101 #include <linux/netfilter_ipv4.h>
102 #ifdef CONFIG_IP_MROUTE
103 #include <linux/mroute.h>
105 #ifdef CONFIG_PROC_FS
106 #include <linux/proc_fs.h>
107 #include <linux/seq_file.h>
110 #define IP_MAX_MEMBERSHIPS 20
111 #define IP_MAX_MSF 10
113 #ifdef CONFIG_IP_MULTICAST
114 /* Parameter names and values are taken from igmp-v2-06 draft */
116 #define IGMP_V1_Router_Present_Timeout (400*HZ)
117 #define IGMP_V2_Router_Present_Timeout (400*HZ)
118 #define IGMP_Unsolicited_Report_Interval (10*HZ)
119 #define IGMP_Query_Response_Interval (10*HZ)
120 #define IGMP_Unsolicited_Report_Count 2
123 #define IGMP_Initial_Report_Delay (1)
125 /* IGMP_Initial_Report_Delay is not from IGMP specs!
126 * IGMP specs require to report membership immediately after
127 * joining a group, but we delay the first report by a
128 * small interval. It seems more natural and still does not
129 * contradict to specs provided this delay is small enough.
132 #define IGMP_V1_SEEN(in_dev) \
133 (IPV4_DEVCONF_ALL(in_dev->dev->nd_net, FORCE_IGMP_VERSION) == 1 || \
134 IN_DEV_CONF_GET((in_dev), FORCE_IGMP_VERSION) == 1 || \
135 ((in_dev)->mr_v1_seen && \
136 time_before(jiffies, (in_dev)->mr_v1_seen)))
137 #define IGMP_V2_SEEN(in_dev) \
138 (IPV4_DEVCONF_ALL(in_dev->dev->nd_net, FORCE_IGMP_VERSION) == 2 || \
139 IN_DEV_CONF_GET((in_dev), FORCE_IGMP_VERSION) == 2 || \
140 ((in_dev)->mr_v2_seen && \
141 time_before(jiffies, (in_dev)->mr_v2_seen)))
143 static void igmpv3_add_delrec(struct in_device
*in_dev
, struct ip_mc_list
*im
);
144 static void igmpv3_del_delrec(struct in_device
*in_dev
, __be32 multiaddr
);
145 static void igmpv3_clear_delrec(struct in_device
*in_dev
);
146 static int sf_setstate(struct ip_mc_list
*pmc
);
147 static void sf_markstate(struct ip_mc_list
*pmc
);
149 static void ip_mc_clear_src(struct ip_mc_list
*pmc
);
150 static int ip_mc_add_src(struct in_device
*in_dev
, __be32
*pmca
, int sfmode
,
151 int sfcount
, __be32
*psfsrc
, int delta
);
153 static void ip_ma_put(struct ip_mc_list
*im
)
155 if (atomic_dec_and_test(&im
->refcnt
)) {
156 in_dev_put(im
->interface
);
161 #ifdef CONFIG_IP_MULTICAST
167 static __inline__
void igmp_stop_timer(struct ip_mc_list
*im
)
169 spin_lock_bh(&im
->lock
);
170 if (del_timer(&im
->timer
))
171 atomic_dec(&im
->refcnt
);
174 im
->unsolicit_count
= 0;
175 spin_unlock_bh(&im
->lock
);
178 /* It must be called with locked im->lock */
179 static void igmp_start_timer(struct ip_mc_list
*im
, int max_delay
)
181 int tv
=net_random() % max_delay
;
184 if (!mod_timer(&im
->timer
, jiffies
+tv
+2))
185 atomic_inc(&im
->refcnt
);
188 static void igmp_gq_start_timer(struct in_device
*in_dev
)
190 int tv
= net_random() % in_dev
->mr_maxdelay
;
192 in_dev
->mr_gq_running
= 1;
193 if (!mod_timer(&in_dev
->mr_gq_timer
, jiffies
+tv
+2))
197 static void igmp_ifc_start_timer(struct in_device
*in_dev
, int delay
)
199 int tv
= net_random() % delay
;
201 if (!mod_timer(&in_dev
->mr_ifc_timer
, jiffies
+tv
+2))
205 static void igmp_mod_timer(struct ip_mc_list
*im
, int max_delay
)
207 spin_lock_bh(&im
->lock
);
208 im
->unsolicit_count
= 0;
209 if (del_timer(&im
->timer
)) {
210 if ((long)(im
->timer
.expires
-jiffies
) < max_delay
) {
211 add_timer(&im
->timer
);
213 spin_unlock_bh(&im
->lock
);
216 atomic_dec(&im
->refcnt
);
218 igmp_start_timer(im
, max_delay
);
219 spin_unlock_bh(&im
->lock
);
224 * Send an IGMP report.
227 #define IGMP_SIZE (sizeof(struct igmphdr)+sizeof(struct iphdr)+4)
230 static int is_in(struct ip_mc_list
*pmc
, struct ip_sf_list
*psf
, int type
,
231 int gdeleted
, int sdeleted
)
234 case IGMPV3_MODE_IS_INCLUDE
:
235 case IGMPV3_MODE_IS_EXCLUDE
:
236 if (gdeleted
|| sdeleted
)
238 if (!(pmc
->gsquery
&& !psf
->sf_gsresp
)) {
239 if (pmc
->sfmode
== MCAST_INCLUDE
)
241 /* don't include if this source is excluded
244 if (psf
->sf_count
[MCAST_INCLUDE
])
245 return type
== IGMPV3_MODE_IS_INCLUDE
;
246 return pmc
->sfcount
[MCAST_EXCLUDE
] ==
247 psf
->sf_count
[MCAST_EXCLUDE
];
250 case IGMPV3_CHANGE_TO_INCLUDE
:
251 if (gdeleted
|| sdeleted
)
253 return psf
->sf_count
[MCAST_INCLUDE
] != 0;
254 case IGMPV3_CHANGE_TO_EXCLUDE
:
255 if (gdeleted
|| sdeleted
)
257 if (pmc
->sfcount
[MCAST_EXCLUDE
] == 0 ||
258 psf
->sf_count
[MCAST_INCLUDE
])
260 return pmc
->sfcount
[MCAST_EXCLUDE
] ==
261 psf
->sf_count
[MCAST_EXCLUDE
];
262 case IGMPV3_ALLOW_NEW_SOURCES
:
263 if (gdeleted
|| !psf
->sf_crcount
)
265 return (pmc
->sfmode
== MCAST_INCLUDE
) ^ sdeleted
;
266 case IGMPV3_BLOCK_OLD_SOURCES
:
267 if (pmc
->sfmode
== MCAST_INCLUDE
)
268 return gdeleted
|| (psf
->sf_crcount
&& sdeleted
);
269 return psf
->sf_crcount
&& !gdeleted
&& !sdeleted
;
275 igmp_scount(struct ip_mc_list
*pmc
, int type
, int gdeleted
, int sdeleted
)
277 struct ip_sf_list
*psf
;
280 for (psf
=pmc
->sources
; psf
; psf
=psf
->sf_next
) {
281 if (!is_in(pmc
, psf
, type
, gdeleted
, sdeleted
))
288 static struct sk_buff
*igmpv3_newpack(struct net_device
*dev
, int size
)
293 struct igmpv3_report
*pig
;
295 skb
= alloc_skb(size
+ LL_RESERVED_SPACE(dev
), GFP_ATOMIC
);
300 struct flowi fl
= { .oif
= dev
->ifindex
,
302 .daddr
= IGMPV3_ALL_MCR
} },
303 .proto
= IPPROTO_IGMP
};
304 if (ip_route_output_key(&rt
, &fl
)) {
309 if (rt
->rt_src
== 0) {
315 skb
->dst
= &rt
->u
.dst
;
318 skb_reserve(skb
, LL_RESERVED_SPACE(dev
));
320 skb_reset_network_header(skb
);
322 skb_put(skb
, sizeof(struct iphdr
) + 4);
325 pip
->ihl
= (sizeof(struct iphdr
)+4)>>2;
327 pip
->frag_off
= htons(IP_DF
);
329 pip
->daddr
= rt
->rt_dst
;
330 pip
->saddr
= rt
->rt_src
;
331 pip
->protocol
= IPPROTO_IGMP
;
332 pip
->tot_len
= 0; /* filled in later */
333 ip_select_ident(pip
, &rt
->u
.dst
, NULL
);
334 ((u8
*)&pip
[1])[0] = IPOPT_RA
;
335 ((u8
*)&pip
[1])[1] = 4;
336 ((u8
*)&pip
[1])[2] = 0;
337 ((u8
*)&pip
[1])[3] = 0;
339 skb
->transport_header
= skb
->network_header
+ sizeof(struct iphdr
) + 4;
340 skb_put(skb
, sizeof(*pig
));
341 pig
= igmpv3_report_hdr(skb
);
342 pig
->type
= IGMPV3_HOST_MEMBERSHIP_REPORT
;
350 static int igmpv3_sendpack(struct sk_buff
*skb
)
352 struct igmphdr
*pig
= igmp_hdr(skb
);
353 const int igmplen
= skb
->tail
- skb
->transport_header
;
355 pig
->csum
= ip_compute_csum(igmp_hdr(skb
), igmplen
);
357 return ip_local_out(skb
);
360 static int grec_size(struct ip_mc_list
*pmc
, int type
, int gdel
, int sdel
)
362 return sizeof(struct igmpv3_grec
) + 4*igmp_scount(pmc
,type
,gdel
,sdel
);
365 static struct sk_buff
*add_grhead(struct sk_buff
*skb
, struct ip_mc_list
*pmc
,
366 int type
, struct igmpv3_grec
**ppgr
)
368 struct net_device
*dev
= pmc
->interface
->dev
;
369 struct igmpv3_report
*pih
;
370 struct igmpv3_grec
*pgr
;
373 skb
= igmpv3_newpack(dev
, dev
->mtu
);
376 pgr
= (struct igmpv3_grec
*)skb_put(skb
, sizeof(struct igmpv3_grec
));
377 pgr
->grec_type
= type
;
378 pgr
->grec_auxwords
= 0;
380 pgr
->grec_mca
= pmc
->multiaddr
;
381 pih
= igmpv3_report_hdr(skb
);
382 pih
->ngrec
= htons(ntohs(pih
->ngrec
)+1);
387 #define AVAILABLE(skb) ((skb) ? ((skb)->dev ? (skb)->dev->mtu - (skb)->len : \
388 skb_tailroom(skb)) : 0)
390 static struct sk_buff
*add_grec(struct sk_buff
*skb
, struct ip_mc_list
*pmc
,
391 int type
, int gdeleted
, int sdeleted
)
393 struct net_device
*dev
= pmc
->interface
->dev
;
394 struct igmpv3_report
*pih
;
395 struct igmpv3_grec
*pgr
= NULL
;
396 struct ip_sf_list
*psf
, *psf_next
, *psf_prev
, **psf_list
;
397 int scount
, stotal
, first
, isquery
, truncate
;
399 if (pmc
->multiaddr
== IGMP_ALL_HOSTS
)
402 isquery
= type
== IGMPV3_MODE_IS_INCLUDE
||
403 type
== IGMPV3_MODE_IS_EXCLUDE
;
404 truncate
= type
== IGMPV3_MODE_IS_EXCLUDE
||
405 type
== IGMPV3_CHANGE_TO_EXCLUDE
;
409 psf_list
= sdeleted
? &pmc
->tomb
: &pmc
->sources
;
414 pih
= skb
? igmpv3_report_hdr(skb
) : NULL
;
416 /* EX and TO_EX get a fresh packet, if needed */
418 if (pih
&& pih
->ngrec
&&
419 AVAILABLE(skb
) < grec_size(pmc
, type
, gdeleted
, sdeleted
)) {
421 igmpv3_sendpack(skb
);
422 skb
= igmpv3_newpack(dev
, dev
->mtu
);
427 for (psf
=*psf_list
; psf
; psf
=psf_next
) {
430 psf_next
= psf
->sf_next
;
432 if (!is_in(pmc
, psf
, type
, gdeleted
, sdeleted
)) {
437 /* clear marks on query responses */
441 if (AVAILABLE(skb
) < sizeof(__be32
) +
442 first
*sizeof(struct igmpv3_grec
)) {
443 if (truncate
&& !first
)
444 break; /* truncate these */
446 pgr
->grec_nsrcs
= htons(scount
);
448 igmpv3_sendpack(skb
);
449 skb
= igmpv3_newpack(dev
, dev
->mtu
);
454 skb
= add_grhead(skb
, pmc
, type
, &pgr
);
459 psrc
= (__be32
*)skb_put(skb
, sizeof(__be32
));
460 *psrc
= psf
->sf_inaddr
;
462 if ((type
== IGMPV3_ALLOW_NEW_SOURCES
||
463 type
== IGMPV3_BLOCK_OLD_SOURCES
) && psf
->sf_crcount
) {
465 if ((sdeleted
|| gdeleted
) && psf
->sf_crcount
== 0) {
467 psf_prev
->sf_next
= psf
->sf_next
;
469 *psf_list
= psf
->sf_next
;
479 if (type
== IGMPV3_ALLOW_NEW_SOURCES
||
480 type
== IGMPV3_BLOCK_OLD_SOURCES
)
482 if (pmc
->crcount
|| isquery
) {
483 /* make sure we have room for group header */
484 if (skb
&& AVAILABLE(skb
)<sizeof(struct igmpv3_grec
)) {
485 igmpv3_sendpack(skb
);
486 skb
= NULL
; /* add_grhead will get a new one */
488 skb
= add_grhead(skb
, pmc
, type
, &pgr
);
492 pgr
->grec_nsrcs
= htons(scount
);
495 pmc
->gsquery
= 0; /* clear query state on report */
499 static int igmpv3_send_report(struct in_device
*in_dev
, struct ip_mc_list
*pmc
)
501 struct sk_buff
*skb
= NULL
;
505 read_lock(&in_dev
->mc_list_lock
);
506 for (pmc
=in_dev
->mc_list
; pmc
; pmc
=pmc
->next
) {
507 if (pmc
->multiaddr
== IGMP_ALL_HOSTS
)
509 spin_lock_bh(&pmc
->lock
);
510 if (pmc
->sfcount
[MCAST_EXCLUDE
])
511 type
= IGMPV3_MODE_IS_EXCLUDE
;
513 type
= IGMPV3_MODE_IS_INCLUDE
;
514 skb
= add_grec(skb
, pmc
, type
, 0, 0);
515 spin_unlock_bh(&pmc
->lock
);
517 read_unlock(&in_dev
->mc_list_lock
);
519 spin_lock_bh(&pmc
->lock
);
520 if (pmc
->sfcount
[MCAST_EXCLUDE
])
521 type
= IGMPV3_MODE_IS_EXCLUDE
;
523 type
= IGMPV3_MODE_IS_INCLUDE
;
524 skb
= add_grec(skb
, pmc
, type
, 0, 0);
525 spin_unlock_bh(&pmc
->lock
);
529 return igmpv3_sendpack(skb
);
533 * remove zero-count source records from a source filter list
535 static void igmpv3_clear_zeros(struct ip_sf_list
**ppsf
)
537 struct ip_sf_list
*psf_prev
, *psf_next
, *psf
;
540 for (psf
=*ppsf
; psf
; psf
= psf_next
) {
541 psf_next
= psf
->sf_next
;
542 if (psf
->sf_crcount
== 0) {
544 psf_prev
->sf_next
= psf
->sf_next
;
546 *ppsf
= psf
->sf_next
;
553 static void igmpv3_send_cr(struct in_device
*in_dev
)
555 struct ip_mc_list
*pmc
, *pmc_prev
, *pmc_next
;
556 struct sk_buff
*skb
= NULL
;
559 read_lock(&in_dev
->mc_list_lock
);
560 spin_lock_bh(&in_dev
->mc_tomb_lock
);
564 for (pmc
=in_dev
->mc_tomb
; pmc
; pmc
=pmc_next
) {
565 pmc_next
= pmc
->next
;
566 if (pmc
->sfmode
== MCAST_INCLUDE
) {
567 type
= IGMPV3_BLOCK_OLD_SOURCES
;
568 dtype
= IGMPV3_BLOCK_OLD_SOURCES
;
569 skb
= add_grec(skb
, pmc
, type
, 1, 0);
570 skb
= add_grec(skb
, pmc
, dtype
, 1, 1);
573 if (pmc
->sfmode
== MCAST_EXCLUDE
) {
574 type
= IGMPV3_CHANGE_TO_INCLUDE
;
575 skb
= add_grec(skb
, pmc
, type
, 1, 0);
578 if (pmc
->crcount
== 0) {
579 igmpv3_clear_zeros(&pmc
->tomb
);
580 igmpv3_clear_zeros(&pmc
->sources
);
583 if (pmc
->crcount
== 0 && !pmc
->tomb
&& !pmc
->sources
) {
585 pmc_prev
->next
= pmc_next
;
587 in_dev
->mc_tomb
= pmc_next
;
588 in_dev_put(pmc
->interface
);
593 spin_unlock_bh(&in_dev
->mc_tomb_lock
);
596 for (pmc
=in_dev
->mc_list
; pmc
; pmc
=pmc
->next
) {
597 spin_lock_bh(&pmc
->lock
);
598 if (pmc
->sfcount
[MCAST_EXCLUDE
]) {
599 type
= IGMPV3_BLOCK_OLD_SOURCES
;
600 dtype
= IGMPV3_ALLOW_NEW_SOURCES
;
602 type
= IGMPV3_ALLOW_NEW_SOURCES
;
603 dtype
= IGMPV3_BLOCK_OLD_SOURCES
;
605 skb
= add_grec(skb
, pmc
, type
, 0, 0);
606 skb
= add_grec(skb
, pmc
, dtype
, 0, 1); /* deleted sources */
608 /* filter mode changes */
610 if (pmc
->sfmode
== MCAST_EXCLUDE
)
611 type
= IGMPV3_CHANGE_TO_EXCLUDE
;
613 type
= IGMPV3_CHANGE_TO_INCLUDE
;
614 skb
= add_grec(skb
, pmc
, type
, 0, 0);
617 spin_unlock_bh(&pmc
->lock
);
619 read_unlock(&in_dev
->mc_list_lock
);
623 (void) igmpv3_sendpack(skb
);
626 static int igmp_send_report(struct in_device
*in_dev
, struct ip_mc_list
*pmc
,
633 struct net_device
*dev
= in_dev
->dev
;
634 __be32 group
= pmc
? pmc
->multiaddr
: 0;
637 if (type
== IGMPV3_HOST_MEMBERSHIP_REPORT
)
638 return igmpv3_send_report(in_dev
, pmc
);
639 else if (type
== IGMP_HOST_LEAVE_MESSAGE
)
640 dst
= IGMP_ALL_ROUTER
;
645 struct flowi fl
= { .oif
= dev
->ifindex
,
646 .nl_u
= { .ip4_u
= { .daddr
= dst
} },
647 .proto
= IPPROTO_IGMP
};
648 if (ip_route_output_key(&rt
, &fl
))
651 if (rt
->rt_src
== 0) {
656 skb
=alloc_skb(IGMP_SIZE
+LL_RESERVED_SPACE(dev
), GFP_ATOMIC
);
662 skb
->dst
= &rt
->u
.dst
;
664 skb_reserve(skb
, LL_RESERVED_SPACE(dev
));
666 skb_reset_network_header(skb
);
668 skb_put(skb
, sizeof(struct iphdr
) + 4);
671 iph
->ihl
= (sizeof(struct iphdr
)+4)>>2;
673 iph
->frag_off
= htons(IP_DF
);
676 iph
->saddr
= rt
->rt_src
;
677 iph
->protocol
= IPPROTO_IGMP
;
678 ip_select_ident(iph
, &rt
->u
.dst
, NULL
);
679 ((u8
*)&iph
[1])[0] = IPOPT_RA
;
680 ((u8
*)&iph
[1])[1] = 4;
681 ((u8
*)&iph
[1])[2] = 0;
682 ((u8
*)&iph
[1])[3] = 0;
684 ih
= (struct igmphdr
*)skb_put(skb
, sizeof(struct igmphdr
));
689 ih
->csum
=ip_compute_csum((void *)ih
, sizeof(struct igmphdr
));
691 return ip_local_out(skb
);
694 static void igmp_gq_timer_expire(unsigned long data
)
696 struct in_device
*in_dev
= (struct in_device
*)data
;
698 in_dev
->mr_gq_running
= 0;
699 igmpv3_send_report(in_dev
, NULL
);
700 __in_dev_put(in_dev
);
703 static void igmp_ifc_timer_expire(unsigned long data
)
705 struct in_device
*in_dev
= (struct in_device
*)data
;
707 igmpv3_send_cr(in_dev
);
708 if (in_dev
->mr_ifc_count
) {
709 in_dev
->mr_ifc_count
--;
710 igmp_ifc_start_timer(in_dev
, IGMP_Unsolicited_Report_Interval
);
712 __in_dev_put(in_dev
);
715 static void igmp_ifc_event(struct in_device
*in_dev
)
717 if (IGMP_V1_SEEN(in_dev
) || IGMP_V2_SEEN(in_dev
))
719 in_dev
->mr_ifc_count
= in_dev
->mr_qrv
? in_dev
->mr_qrv
:
720 IGMP_Unsolicited_Report_Count
;
721 igmp_ifc_start_timer(in_dev
, 1);
725 static void igmp_timer_expire(unsigned long data
)
727 struct ip_mc_list
*im
=(struct ip_mc_list
*)data
;
728 struct in_device
*in_dev
= im
->interface
;
730 spin_lock(&im
->lock
);
733 if (im
->unsolicit_count
) {
734 im
->unsolicit_count
--;
735 igmp_start_timer(im
, IGMP_Unsolicited_Report_Interval
);
738 spin_unlock(&im
->lock
);
740 if (IGMP_V1_SEEN(in_dev
))
741 igmp_send_report(in_dev
, im
, IGMP_HOST_MEMBERSHIP_REPORT
);
742 else if (IGMP_V2_SEEN(in_dev
))
743 igmp_send_report(in_dev
, im
, IGMPV2_HOST_MEMBERSHIP_REPORT
);
745 igmp_send_report(in_dev
, im
, IGMPV3_HOST_MEMBERSHIP_REPORT
);
750 /* mark EXCLUDE-mode sources */
751 static int igmp_xmarksources(struct ip_mc_list
*pmc
, int nsrcs
, __be32
*srcs
)
753 struct ip_sf_list
*psf
;
757 for (psf
=pmc
->sources
; psf
; psf
=psf
->sf_next
) {
760 for (i
=0; i
<nsrcs
; i
++) {
761 /* skip inactive filters */
762 if (pmc
->sfcount
[MCAST_INCLUDE
] ||
763 pmc
->sfcount
[MCAST_EXCLUDE
] !=
764 psf
->sf_count
[MCAST_EXCLUDE
])
766 if (srcs
[i
] == psf
->sf_inaddr
) {
773 if (scount
== nsrcs
) /* all sources excluded */
778 static int igmp_marksources(struct ip_mc_list
*pmc
, int nsrcs
, __be32
*srcs
)
780 struct ip_sf_list
*psf
;
783 if (pmc
->sfmode
== MCAST_EXCLUDE
)
784 return igmp_xmarksources(pmc
, nsrcs
, srcs
);
786 /* mark INCLUDE-mode sources */
788 for (psf
=pmc
->sources
; psf
; psf
=psf
->sf_next
) {
791 for (i
=0; i
<nsrcs
; i
++)
792 if (srcs
[i
] == psf
->sf_inaddr
) {
806 static void igmp_heard_report(struct in_device
*in_dev
, __be32 group
)
808 struct ip_mc_list
*im
;
810 /* Timers are only set for non-local groups */
812 if (group
== IGMP_ALL_HOSTS
)
815 read_lock(&in_dev
->mc_list_lock
);
816 for (im
=in_dev
->mc_list
; im
!=NULL
; im
=im
->next
) {
817 if (im
->multiaddr
== group
) {
822 read_unlock(&in_dev
->mc_list_lock
);
825 static void igmp_heard_query(struct in_device
*in_dev
, struct sk_buff
*skb
,
828 struct igmphdr
*ih
= igmp_hdr(skb
);
829 struct igmpv3_query
*ih3
= igmpv3_query_hdr(skb
);
830 struct ip_mc_list
*im
;
831 __be32 group
= ih
->group
;
838 /* Alas, old v1 router presents here. */
840 max_delay
= IGMP_Query_Response_Interval
;
841 in_dev
->mr_v1_seen
= jiffies
+
842 IGMP_V1_Router_Present_Timeout
;
845 /* v2 router present */
846 max_delay
= ih
->code
*(HZ
/IGMP_TIMER_SCALE
);
847 in_dev
->mr_v2_seen
= jiffies
+
848 IGMP_V2_Router_Present_Timeout
;
850 /* cancel the interface change timer */
851 in_dev
->mr_ifc_count
= 0;
852 if (del_timer(&in_dev
->mr_ifc_timer
))
853 __in_dev_put(in_dev
);
854 /* clear deleted report items */
855 igmpv3_clear_delrec(in_dev
);
856 } else if (len
< 12) {
857 return; /* ignore bogus packet; freed by caller */
859 if (!pskb_may_pull(skb
, sizeof(struct igmpv3_query
)))
862 ih3
= igmpv3_query_hdr(skb
);
864 if (!pskb_may_pull(skb
, sizeof(struct igmpv3_query
)
865 + ntohs(ih3
->nsrcs
)*sizeof(__be32
)))
867 ih3
= igmpv3_query_hdr(skb
);
870 max_delay
= IGMPV3_MRC(ih3
->code
)*(HZ
/IGMP_TIMER_SCALE
);
872 max_delay
= 1; /* can't mod w/ 0 */
873 in_dev
->mr_maxdelay
= max_delay
;
875 in_dev
->mr_qrv
= ih3
->qrv
;
876 if (!group
) { /* general query */
878 return; /* no sources allowed */
879 igmp_gq_start_timer(in_dev
);
882 /* mark sources to include, if group & source-specific */
883 mark
= ih3
->nsrcs
!= 0;
887 * - Start the timers in all of our membership records
888 * that the query applies to for the interface on
889 * which the query arrived excl. those that belong
890 * to a "local" group (224.0.0.X)
891 * - For timers already running check if they need to
893 * - Use the igmp->igmp_code field as the maximum
896 read_lock(&in_dev
->mc_list_lock
);
897 for (im
=in_dev
->mc_list
; im
!=NULL
; im
=im
->next
) {
900 if (group
&& group
!= im
->multiaddr
)
902 if (im
->multiaddr
== IGMP_ALL_HOSTS
)
904 spin_lock_bh(&im
->lock
);
906 im
->gsquery
= im
->gsquery
&& mark
;
909 changed
= !im
->gsquery
||
910 igmp_marksources(im
, ntohs(ih3
->nsrcs
), ih3
->srcs
);
911 spin_unlock_bh(&im
->lock
);
913 igmp_mod_timer(im
, max_delay
);
915 read_unlock(&in_dev
->mc_list_lock
);
918 int igmp_rcv(struct sk_buff
*skb
)
920 /* This basically follows the spec line by line -- see RFC1112 */
922 struct in_device
*in_dev
= in_dev_get(skb
->dev
);
930 if (!pskb_may_pull(skb
, sizeof(struct igmphdr
)))
933 switch (skb
->ip_summed
) {
934 case CHECKSUM_COMPLETE
:
935 if (!csum_fold(skb
->csum
))
940 if (__skb_checksum_complete(skb
))
946 case IGMP_HOST_MEMBERSHIP_QUERY
:
947 igmp_heard_query(in_dev
, skb
, len
);
949 case IGMP_HOST_MEMBERSHIP_REPORT
:
950 case IGMPV2_HOST_MEMBERSHIP_REPORT
:
951 case IGMPV3_HOST_MEMBERSHIP_REPORT
:
952 /* Is it our report looped back? */
953 if (((struct rtable
*)skb
->dst
)->fl
.iif
== 0)
955 /* don't rely on MC router hearing unicast reports */
956 if (skb
->pkt_type
== PACKET_MULTICAST
||
957 skb
->pkt_type
== PACKET_BROADCAST
)
958 igmp_heard_report(in_dev
, ih
->group
);
961 #ifdef CONFIG_IP_PIMSM_V1
963 return pim_rcv_v1(skb
);
967 case IGMP_HOST_LEAVE_MESSAGE
:
969 case IGMP_MTRACE_RESP
:
985 * Add a filter to a device
988 static void ip_mc_filter_add(struct in_device
*in_dev
, __be32 addr
)
990 char buf
[MAX_ADDR_LEN
];
991 struct net_device
*dev
= in_dev
->dev
;
993 /* Checking for IFF_MULTICAST here is WRONG-WRONG-WRONG.
994 We will get multicast token leakage, when IFF_MULTICAST
995 is changed. This check should be done in dev->set_multicast_list
996 routine. Something sort of:
997 if (dev->mc_list && dev->flags&IFF_MULTICAST) { do it; }
1000 if (arp_mc_map(addr
, buf
, dev
, 0) == 0)
1001 dev_mc_add(dev
,buf
,dev
->addr_len
,0);
1005 * Remove a filter from a device
1008 static void ip_mc_filter_del(struct in_device
*in_dev
, __be32 addr
)
1010 char buf
[MAX_ADDR_LEN
];
1011 struct net_device
*dev
= in_dev
->dev
;
1013 if (arp_mc_map(addr
, buf
, dev
, 0) == 0)
1014 dev_mc_delete(dev
,buf
,dev
->addr_len
,0);
1017 #ifdef CONFIG_IP_MULTICAST
1019 * deleted ip_mc_list manipulation
1021 static void igmpv3_add_delrec(struct in_device
*in_dev
, struct ip_mc_list
*im
)
1023 struct ip_mc_list
*pmc
;
1025 /* this is an "ip_mc_list" for convenience; only the fields below
1026 * are actually used. In particular, the refcnt and users are not
1027 * used for management of the delete list. Using the same structure
1028 * for deleted items allows change reports to use common code with
1029 * non-deleted or query-response MCA's.
1031 pmc
= kzalloc(sizeof(*pmc
), GFP_KERNEL
);
1034 spin_lock_bh(&im
->lock
);
1035 pmc
->interface
= im
->interface
;
1036 in_dev_hold(in_dev
);
1037 pmc
->multiaddr
= im
->multiaddr
;
1038 pmc
->crcount
= in_dev
->mr_qrv
? in_dev
->mr_qrv
:
1039 IGMP_Unsolicited_Report_Count
;
1040 pmc
->sfmode
= im
->sfmode
;
1041 if (pmc
->sfmode
== MCAST_INCLUDE
) {
1042 struct ip_sf_list
*psf
;
1044 pmc
->tomb
= im
->tomb
;
1045 pmc
->sources
= im
->sources
;
1046 im
->tomb
= im
->sources
= NULL
;
1047 for (psf
=pmc
->sources
; psf
; psf
=psf
->sf_next
)
1048 psf
->sf_crcount
= pmc
->crcount
;
1050 spin_unlock_bh(&im
->lock
);
1052 spin_lock_bh(&in_dev
->mc_tomb_lock
);
1053 pmc
->next
= in_dev
->mc_tomb
;
1054 in_dev
->mc_tomb
= pmc
;
1055 spin_unlock_bh(&in_dev
->mc_tomb_lock
);
1058 static void igmpv3_del_delrec(struct in_device
*in_dev
, __be32 multiaddr
)
1060 struct ip_mc_list
*pmc
, *pmc_prev
;
1061 struct ip_sf_list
*psf
, *psf_next
;
1063 spin_lock_bh(&in_dev
->mc_tomb_lock
);
1065 for (pmc
=in_dev
->mc_tomb
; pmc
; pmc
=pmc
->next
) {
1066 if (pmc
->multiaddr
== multiaddr
)
1072 pmc_prev
->next
= pmc
->next
;
1074 in_dev
->mc_tomb
= pmc
->next
;
1076 spin_unlock_bh(&in_dev
->mc_tomb_lock
);
1078 for (psf
=pmc
->tomb
; psf
; psf
=psf_next
) {
1079 psf_next
= psf
->sf_next
;
1082 in_dev_put(pmc
->interface
);
1087 static void igmpv3_clear_delrec(struct in_device
*in_dev
)
1089 struct ip_mc_list
*pmc
, *nextpmc
;
1091 spin_lock_bh(&in_dev
->mc_tomb_lock
);
1092 pmc
= in_dev
->mc_tomb
;
1093 in_dev
->mc_tomb
= NULL
;
1094 spin_unlock_bh(&in_dev
->mc_tomb_lock
);
1096 for (; pmc
; pmc
= nextpmc
) {
1097 nextpmc
= pmc
->next
;
1098 ip_mc_clear_src(pmc
);
1099 in_dev_put(pmc
->interface
);
1102 /* clear dead sources, too */
1103 read_lock(&in_dev
->mc_list_lock
);
1104 for (pmc
=in_dev
->mc_list
; pmc
; pmc
=pmc
->next
) {
1105 struct ip_sf_list
*psf
, *psf_next
;
1107 spin_lock_bh(&pmc
->lock
);
1110 spin_unlock_bh(&pmc
->lock
);
1111 for (; psf
; psf
=psf_next
) {
1112 psf_next
= psf
->sf_next
;
1116 read_unlock(&in_dev
->mc_list_lock
);
1120 static void igmp_group_dropped(struct ip_mc_list
*im
)
1122 struct in_device
*in_dev
= im
->interface
;
1123 #ifdef CONFIG_IP_MULTICAST
1129 ip_mc_filter_del(in_dev
, im
->multiaddr
);
1132 #ifdef CONFIG_IP_MULTICAST
1133 if (im
->multiaddr
== IGMP_ALL_HOSTS
)
1136 reporter
= im
->reporter
;
1137 igmp_stop_timer(im
);
1139 if (!in_dev
->dead
) {
1140 if (IGMP_V1_SEEN(in_dev
))
1142 if (IGMP_V2_SEEN(in_dev
)) {
1144 igmp_send_report(in_dev
, im
, IGMP_HOST_LEAVE_MESSAGE
);
1148 igmpv3_add_delrec(in_dev
, im
);
1150 igmp_ifc_event(in_dev
);
1154 ip_mc_clear_src(im
);
1157 static void igmp_group_added(struct ip_mc_list
*im
)
1159 struct in_device
*in_dev
= im
->interface
;
1161 if (im
->loaded
== 0) {
1163 ip_mc_filter_add(in_dev
, im
->multiaddr
);
1166 #ifdef CONFIG_IP_MULTICAST
1167 if (im
->multiaddr
== IGMP_ALL_HOSTS
)
1172 if (IGMP_V1_SEEN(in_dev
) || IGMP_V2_SEEN(in_dev
)) {
1173 spin_lock_bh(&im
->lock
);
1174 igmp_start_timer(im
, IGMP_Initial_Report_Delay
);
1175 spin_unlock_bh(&im
->lock
);
1180 im
->crcount
= in_dev
->mr_qrv
? in_dev
->mr_qrv
:
1181 IGMP_Unsolicited_Report_Count
;
1182 igmp_ifc_event(in_dev
);
1188 * Multicast list managers
1193 * A socket has joined a multicast group on device dev.
1196 void ip_mc_inc_group(struct in_device
*in_dev
, __be32 addr
)
1198 struct ip_mc_list
*im
;
1202 for (im
=in_dev
->mc_list
; im
; im
=im
->next
) {
1203 if (im
->multiaddr
== addr
) {
1205 ip_mc_add_src(in_dev
, &addr
, MCAST_EXCLUDE
, 0, NULL
, 0);
1210 im
= kmalloc(sizeof(*im
), GFP_KERNEL
);
1215 im
->interface
=in_dev
;
1216 in_dev_hold(in_dev
);
1218 /* initial mode is (EX, empty) */
1219 im
->sfmode
= MCAST_EXCLUDE
;
1220 im
->sfcount
[MCAST_INCLUDE
] = 0;
1221 im
->sfcount
[MCAST_EXCLUDE
] = 1;
1225 atomic_set(&im
->refcnt
, 1);
1226 spin_lock_init(&im
->lock
);
1227 #ifdef CONFIG_IP_MULTICAST
1229 setup_timer(&im
->timer
, &igmp_timer_expire
, (unsigned long)im
);
1230 im
->unsolicit_count
= IGMP_Unsolicited_Report_Count
;
1235 write_lock_bh(&in_dev
->mc_list_lock
);
1236 im
->next
=in_dev
->mc_list
;
1238 write_unlock_bh(&in_dev
->mc_list_lock
);
1239 #ifdef CONFIG_IP_MULTICAST
1240 igmpv3_del_delrec(in_dev
, im
->multiaddr
);
1242 igmp_group_added(im
);
1244 ip_rt_multicast_event(in_dev
);
1250 * Resend IGMP JOIN report; used for bonding.
1252 void ip_mc_rejoin_group(struct ip_mc_list
*im
)
1254 #ifdef CONFIG_IP_MULTICAST
1255 struct in_device
*in_dev
= im
->interface
;
1257 if (im
->multiaddr
== IGMP_ALL_HOSTS
)
1260 if (IGMP_V1_SEEN(in_dev
) || IGMP_V2_SEEN(in_dev
)) {
1261 igmp_mod_timer(im
, IGMP_Initial_Report_Delay
);
1265 im
->crcount
= in_dev
->mr_qrv
? in_dev
->mr_qrv
:
1266 IGMP_Unsolicited_Report_Count
;
1267 igmp_ifc_event(in_dev
);
1272 * A socket has left a multicast group on device dev
1275 void ip_mc_dec_group(struct in_device
*in_dev
, __be32 addr
)
1277 struct ip_mc_list
*i
, **ip
;
1281 for (ip
=&in_dev
->mc_list
; (i
=*ip
)!=NULL
; ip
=&i
->next
) {
1282 if (i
->multiaddr
==addr
) {
1283 if (--i
->users
== 0) {
1284 write_lock_bh(&in_dev
->mc_list_lock
);
1286 write_unlock_bh(&in_dev
->mc_list_lock
);
1287 igmp_group_dropped(i
);
1290 ip_rt_multicast_event(in_dev
);
1300 /* Device going down */
1302 void ip_mc_down(struct in_device
*in_dev
)
1304 struct ip_mc_list
*i
;
1308 for (i
=in_dev
->mc_list
; i
; i
=i
->next
)
1309 igmp_group_dropped(i
);
1311 #ifdef CONFIG_IP_MULTICAST
1312 in_dev
->mr_ifc_count
= 0;
1313 if (del_timer(&in_dev
->mr_ifc_timer
))
1314 __in_dev_put(in_dev
);
1315 in_dev
->mr_gq_running
= 0;
1316 if (del_timer(&in_dev
->mr_gq_timer
))
1317 __in_dev_put(in_dev
);
1318 igmpv3_clear_delrec(in_dev
);
1321 ip_mc_dec_group(in_dev
, IGMP_ALL_HOSTS
);
1324 void ip_mc_init_dev(struct in_device
*in_dev
)
1328 in_dev
->mc_tomb
= NULL
;
1329 #ifdef CONFIG_IP_MULTICAST
1330 in_dev
->mr_gq_running
= 0;
1331 setup_timer(&in_dev
->mr_gq_timer
, igmp_gq_timer_expire
,
1332 (unsigned long)in_dev
);
1333 in_dev
->mr_ifc_count
= 0;
1334 setup_timer(&in_dev
->mr_ifc_timer
, igmp_ifc_timer_expire
,
1335 (unsigned long)in_dev
);
1336 in_dev
->mr_qrv
= IGMP_Unsolicited_Report_Count
;
1339 rwlock_init(&in_dev
->mc_list_lock
);
1340 spin_lock_init(&in_dev
->mc_tomb_lock
);
1343 /* Device going up */
1345 void ip_mc_up(struct in_device
*in_dev
)
1347 struct ip_mc_list
*i
;
1351 ip_mc_inc_group(in_dev
, IGMP_ALL_HOSTS
);
1353 for (i
=in_dev
->mc_list
; i
; i
=i
->next
)
1354 igmp_group_added(i
);
1358 * Device is about to be destroyed: clean up.
1361 void ip_mc_destroy_dev(struct in_device
*in_dev
)
1363 struct ip_mc_list
*i
;
1367 /* Deactivate timers */
1370 write_lock_bh(&in_dev
->mc_list_lock
);
1371 while ((i
= in_dev
->mc_list
) != NULL
) {
1372 in_dev
->mc_list
= i
->next
;
1373 write_unlock_bh(&in_dev
->mc_list_lock
);
1375 igmp_group_dropped(i
);
1378 write_lock_bh(&in_dev
->mc_list_lock
);
1380 write_unlock_bh(&in_dev
->mc_list_lock
);
1383 static struct in_device
* ip_mc_find_dev(struct ip_mreqn
*imr
)
1385 struct flowi fl
= { .nl_u
= { .ip4_u
=
1386 { .daddr
= imr
->imr_multiaddr
.s_addr
} } };
1388 struct net_device
*dev
= NULL
;
1389 struct in_device
*idev
= NULL
;
1391 if (imr
->imr_ifindex
) {
1392 idev
= inetdev_by_index(imr
->imr_ifindex
);
1397 if (imr
->imr_address
.s_addr
) {
1398 dev
= ip_dev_find(imr
->imr_address
.s_addr
);
1404 if (!dev
&& !ip_route_output_key(&rt
, &fl
)) {
1405 dev
= rt
->u
.dst
.dev
;
1409 imr
->imr_ifindex
= dev
->ifindex
;
1410 idev
= __in_dev_get_rtnl(dev
);
1416 * Join a socket to a group
1418 int sysctl_igmp_max_memberships __read_mostly
= IP_MAX_MEMBERSHIPS
;
1419 int sysctl_igmp_max_msf __read_mostly
= IP_MAX_MSF
;
1422 static int ip_mc_del1_src(struct ip_mc_list
*pmc
, int sfmode
,
1425 struct ip_sf_list
*psf
, *psf_prev
;
1429 for (psf
=pmc
->sources
; psf
; psf
=psf
->sf_next
) {
1430 if (psf
->sf_inaddr
== *psfsrc
)
1434 if (!psf
|| psf
->sf_count
[sfmode
] == 0) {
1435 /* source filter not found, or count wrong => bug */
1438 psf
->sf_count
[sfmode
]--;
1439 if (psf
->sf_count
[sfmode
] == 0) {
1440 ip_rt_multicast_event(pmc
->interface
);
1442 if (!psf
->sf_count
[MCAST_INCLUDE
] && !psf
->sf_count
[MCAST_EXCLUDE
]) {
1443 #ifdef CONFIG_IP_MULTICAST
1444 struct in_device
*in_dev
= pmc
->interface
;
1447 /* no more filters for this source */
1449 psf_prev
->sf_next
= psf
->sf_next
;
1451 pmc
->sources
= psf
->sf_next
;
1452 #ifdef CONFIG_IP_MULTICAST
1453 if (psf
->sf_oldin
&&
1454 !IGMP_V1_SEEN(in_dev
) && !IGMP_V2_SEEN(in_dev
)) {
1455 psf
->sf_crcount
= in_dev
->mr_qrv
? in_dev
->mr_qrv
:
1456 IGMP_Unsolicited_Report_Count
;
1457 psf
->sf_next
= pmc
->tomb
;
1467 #ifndef CONFIG_IP_MULTICAST
1468 #define igmp_ifc_event(x) do { } while (0)
1471 static int ip_mc_del_src(struct in_device
*in_dev
, __be32
*pmca
, int sfmode
,
1472 int sfcount
, __be32
*psfsrc
, int delta
)
1474 struct ip_mc_list
*pmc
;
1480 read_lock(&in_dev
->mc_list_lock
);
1481 for (pmc
=in_dev
->mc_list
; pmc
; pmc
=pmc
->next
) {
1482 if (*pmca
== pmc
->multiaddr
)
1486 /* MCA not found?? bug */
1487 read_unlock(&in_dev
->mc_list_lock
);
1490 spin_lock_bh(&pmc
->lock
);
1491 read_unlock(&in_dev
->mc_list_lock
);
1492 #ifdef CONFIG_IP_MULTICAST
1497 if (!pmc
->sfcount
[sfmode
])
1499 pmc
->sfcount
[sfmode
]--;
1502 for (i
=0; i
<sfcount
; i
++) {
1503 int rv
= ip_mc_del1_src(pmc
, sfmode
, &psfsrc
[i
]);
1505 changerec
|= rv
> 0;
1509 if (pmc
->sfmode
== MCAST_EXCLUDE
&&
1510 pmc
->sfcount
[MCAST_EXCLUDE
] == 0 &&
1511 pmc
->sfcount
[MCAST_INCLUDE
]) {
1512 #ifdef CONFIG_IP_MULTICAST
1513 struct ip_sf_list
*psf
;
1516 /* filter mode change */
1517 pmc
->sfmode
= MCAST_INCLUDE
;
1518 #ifdef CONFIG_IP_MULTICAST
1519 pmc
->crcount
= in_dev
->mr_qrv
? in_dev
->mr_qrv
:
1520 IGMP_Unsolicited_Report_Count
;
1521 in_dev
->mr_ifc_count
= pmc
->crcount
;
1522 for (psf
=pmc
->sources
; psf
; psf
= psf
->sf_next
)
1523 psf
->sf_crcount
= 0;
1524 igmp_ifc_event(pmc
->interface
);
1525 } else if (sf_setstate(pmc
) || changerec
) {
1526 igmp_ifc_event(pmc
->interface
);
1530 spin_unlock_bh(&pmc
->lock
);
1535 * Add multicast single-source filter to the interface list
1537 static int ip_mc_add1_src(struct ip_mc_list
*pmc
, int sfmode
,
1538 __be32
*psfsrc
, int delta
)
1540 struct ip_sf_list
*psf
, *psf_prev
;
1543 for (psf
=pmc
->sources
; psf
; psf
=psf
->sf_next
) {
1544 if (psf
->sf_inaddr
== *psfsrc
)
1549 psf
= kzalloc(sizeof(*psf
), GFP_ATOMIC
);
1552 psf
->sf_inaddr
= *psfsrc
;
1554 psf_prev
->sf_next
= psf
;
1558 psf
->sf_count
[sfmode
]++;
1559 if (psf
->sf_count
[sfmode
] == 1) {
1560 ip_rt_multicast_event(pmc
->interface
);
1565 #ifdef CONFIG_IP_MULTICAST
1566 static void sf_markstate(struct ip_mc_list
*pmc
)
1568 struct ip_sf_list
*psf
;
1569 int mca_xcount
= pmc
->sfcount
[MCAST_EXCLUDE
];
1571 for (psf
=pmc
->sources
; psf
; psf
=psf
->sf_next
)
1572 if (pmc
->sfcount
[MCAST_EXCLUDE
]) {
1573 psf
->sf_oldin
= mca_xcount
==
1574 psf
->sf_count
[MCAST_EXCLUDE
] &&
1575 !psf
->sf_count
[MCAST_INCLUDE
];
1577 psf
->sf_oldin
= psf
->sf_count
[MCAST_INCLUDE
] != 0;
1580 static int sf_setstate(struct ip_mc_list
*pmc
)
1582 struct ip_sf_list
*psf
, *dpsf
;
1583 int mca_xcount
= pmc
->sfcount
[MCAST_EXCLUDE
];
1584 int qrv
= pmc
->interface
->mr_qrv
;
1588 for (psf
=pmc
->sources
; psf
; psf
=psf
->sf_next
) {
1589 if (pmc
->sfcount
[MCAST_EXCLUDE
]) {
1590 new_in
= mca_xcount
== psf
->sf_count
[MCAST_EXCLUDE
] &&
1591 !psf
->sf_count
[MCAST_INCLUDE
];
1593 new_in
= psf
->sf_count
[MCAST_INCLUDE
] != 0;
1595 if (!psf
->sf_oldin
) {
1596 struct ip_sf_list
*prev
= NULL
;
1598 for (dpsf
=pmc
->tomb
; dpsf
; dpsf
=dpsf
->sf_next
) {
1599 if (dpsf
->sf_inaddr
== psf
->sf_inaddr
)
1605 prev
->sf_next
= dpsf
->sf_next
;
1607 pmc
->tomb
= dpsf
->sf_next
;
1610 psf
->sf_crcount
= qrv
;
1613 } else if (psf
->sf_oldin
) {
1615 psf
->sf_crcount
= 0;
1617 * add or update "delete" records if an active filter
1620 for (dpsf
=pmc
->tomb
; dpsf
; dpsf
=dpsf
->sf_next
)
1621 if (dpsf
->sf_inaddr
== psf
->sf_inaddr
)
1624 dpsf
= (struct ip_sf_list
*)
1625 kmalloc(sizeof(*dpsf
), GFP_ATOMIC
);
1629 /* pmc->lock held by callers */
1630 dpsf
->sf_next
= pmc
->tomb
;
1633 dpsf
->sf_crcount
= qrv
;
1642 * Add multicast source filter list to the interface list
1644 static int ip_mc_add_src(struct in_device
*in_dev
, __be32
*pmca
, int sfmode
,
1645 int sfcount
, __be32
*psfsrc
, int delta
)
1647 struct ip_mc_list
*pmc
;
1653 read_lock(&in_dev
->mc_list_lock
);
1654 for (pmc
=in_dev
->mc_list
; pmc
; pmc
=pmc
->next
) {
1655 if (*pmca
== pmc
->multiaddr
)
1659 /* MCA not found?? bug */
1660 read_unlock(&in_dev
->mc_list_lock
);
1663 spin_lock_bh(&pmc
->lock
);
1664 read_unlock(&in_dev
->mc_list_lock
);
1666 #ifdef CONFIG_IP_MULTICAST
1669 isexclude
= pmc
->sfmode
== MCAST_EXCLUDE
;
1671 pmc
->sfcount
[sfmode
]++;
1673 for (i
=0; i
<sfcount
; i
++) {
1674 err
= ip_mc_add1_src(pmc
, sfmode
, &psfsrc
[i
], delta
);
1681 pmc
->sfcount
[sfmode
]--;
1683 (void) ip_mc_del1_src(pmc
, sfmode
, &psfsrc
[i
]);
1684 } else if (isexclude
!= (pmc
->sfcount
[MCAST_EXCLUDE
] != 0)) {
1685 #ifdef CONFIG_IP_MULTICAST
1686 struct ip_sf_list
*psf
;
1687 in_dev
= pmc
->interface
;
1690 /* filter mode change */
1691 if (pmc
->sfcount
[MCAST_EXCLUDE
])
1692 pmc
->sfmode
= MCAST_EXCLUDE
;
1693 else if (pmc
->sfcount
[MCAST_INCLUDE
])
1694 pmc
->sfmode
= MCAST_INCLUDE
;
1695 #ifdef CONFIG_IP_MULTICAST
1696 /* else no filters; keep old mode for reports */
1698 pmc
->crcount
= in_dev
->mr_qrv
? in_dev
->mr_qrv
:
1699 IGMP_Unsolicited_Report_Count
;
1700 in_dev
->mr_ifc_count
= pmc
->crcount
;
1701 for (psf
=pmc
->sources
; psf
; psf
= psf
->sf_next
)
1702 psf
->sf_crcount
= 0;
1703 igmp_ifc_event(in_dev
);
1704 } else if (sf_setstate(pmc
)) {
1705 igmp_ifc_event(in_dev
);
1708 spin_unlock_bh(&pmc
->lock
);
1712 static void ip_mc_clear_src(struct ip_mc_list
*pmc
)
1714 struct ip_sf_list
*psf
, *nextpsf
;
1716 for (psf
=pmc
->tomb
; psf
; psf
=nextpsf
) {
1717 nextpsf
= psf
->sf_next
;
1721 for (psf
=pmc
->sources
; psf
; psf
=nextpsf
) {
1722 nextpsf
= psf
->sf_next
;
1725 pmc
->sources
= NULL
;
1726 pmc
->sfmode
= MCAST_EXCLUDE
;
1727 pmc
->sfcount
[MCAST_INCLUDE
] = 0;
1728 pmc
->sfcount
[MCAST_EXCLUDE
] = 1;
1733 * Join a multicast group
1735 int ip_mc_join_group(struct sock
*sk
, struct ip_mreqn
*imr
)
1738 __be32 addr
= imr
->imr_multiaddr
.s_addr
;
1739 struct ip_mc_socklist
*iml
=NULL
, *i
;
1740 struct in_device
*in_dev
;
1741 struct inet_sock
*inet
= inet_sk(sk
);
1745 if (!ipv4_is_multicast(addr
))
1750 in_dev
= ip_mc_find_dev(imr
);
1759 ifindex
= imr
->imr_ifindex
;
1760 for (i
= inet
->mc_list
; i
; i
= i
->next
) {
1761 if (i
->multi
.imr_multiaddr
.s_addr
== addr
&&
1762 i
->multi
.imr_ifindex
== ifindex
)
1767 if (count
>= sysctl_igmp_max_memberships
)
1769 iml
= sock_kmalloc(sk
,sizeof(*iml
),GFP_KERNEL
);
1773 memcpy(&iml
->multi
, imr
, sizeof(*imr
));
1774 iml
->next
= inet
->mc_list
;
1776 iml
->sfmode
= MCAST_EXCLUDE
;
1777 inet
->mc_list
= iml
;
1778 ip_mc_inc_group(in_dev
, addr
);
1785 static int ip_mc_leave_src(struct sock
*sk
, struct ip_mc_socklist
*iml
,
1786 struct in_device
*in_dev
)
1790 if (iml
->sflist
== NULL
) {
1791 /* any-source empty exclude case */
1792 return ip_mc_del_src(in_dev
, &iml
->multi
.imr_multiaddr
.s_addr
,
1793 iml
->sfmode
, 0, NULL
, 0);
1795 err
= ip_mc_del_src(in_dev
, &iml
->multi
.imr_multiaddr
.s_addr
,
1796 iml
->sfmode
, iml
->sflist
->sl_count
,
1797 iml
->sflist
->sl_addr
, 0);
1798 sock_kfree_s(sk
, iml
->sflist
, IP_SFLSIZE(iml
->sflist
->sl_max
));
1804 * Ask a socket to leave a group.
1807 int ip_mc_leave_group(struct sock
*sk
, struct ip_mreqn
*imr
)
1809 struct inet_sock
*inet
= inet_sk(sk
);
1810 struct ip_mc_socklist
*iml
, **imlp
;
1811 struct in_device
*in_dev
;
1812 __be32 group
= imr
->imr_multiaddr
.s_addr
;
1814 int ret
= -EADDRNOTAVAIL
;
1817 in_dev
= ip_mc_find_dev(imr
);
1818 ifindex
= imr
->imr_ifindex
;
1819 for (imlp
= &inet
->mc_list
; (iml
= *imlp
) != NULL
; imlp
= &iml
->next
) {
1820 if (iml
->multi
.imr_multiaddr
.s_addr
!= group
)
1823 if (iml
->multi
.imr_ifindex
!= ifindex
)
1825 } else if (imr
->imr_address
.s_addr
&& imr
->imr_address
.s_addr
!=
1826 iml
->multi
.imr_address
.s_addr
)
1829 (void) ip_mc_leave_src(sk
, iml
, in_dev
);
1834 ip_mc_dec_group(in_dev
, group
);
1836 sock_kfree_s(sk
, iml
, sizeof(*iml
));
1845 int ip_mc_source(int add
, int omode
, struct sock
*sk
, struct
1846 ip_mreq_source
*mreqs
, int ifindex
)
1849 struct ip_mreqn imr
;
1850 __be32 addr
= mreqs
->imr_multiaddr
;
1851 struct ip_mc_socklist
*pmc
;
1852 struct in_device
*in_dev
= NULL
;
1853 struct inet_sock
*inet
= inet_sk(sk
);
1854 struct ip_sf_socklist
*psl
;
1858 if (!ipv4_is_multicast(addr
))
1863 imr
.imr_multiaddr
.s_addr
= mreqs
->imr_multiaddr
;
1864 imr
.imr_address
.s_addr
= mreqs
->imr_interface
;
1865 imr
.imr_ifindex
= ifindex
;
1866 in_dev
= ip_mc_find_dev(&imr
);
1872 err
= -EADDRNOTAVAIL
;
1874 for (pmc
=inet
->mc_list
; pmc
; pmc
=pmc
->next
) {
1875 if (pmc
->multi
.imr_multiaddr
.s_addr
== imr
.imr_multiaddr
.s_addr
1876 && pmc
->multi
.imr_ifindex
== imr
.imr_ifindex
)
1879 if (!pmc
) { /* must have a prior join */
1883 /* if a source filter was set, must be the same mode as before */
1885 if (pmc
->sfmode
!= omode
) {
1889 } else if (pmc
->sfmode
!= omode
) {
1890 /* allow mode switches for empty-set filters */
1891 ip_mc_add_src(in_dev
, &mreqs
->imr_multiaddr
, omode
, 0, NULL
, 0);
1892 ip_mc_del_src(in_dev
, &mreqs
->imr_multiaddr
, pmc
->sfmode
, 0,
1894 pmc
->sfmode
= omode
;
1900 goto done
; /* err = -EADDRNOTAVAIL */
1902 for (i
=0; i
<psl
->sl_count
; i
++) {
1903 rv
= memcmp(&psl
->sl_addr
[i
], &mreqs
->imr_sourceaddr
,
1908 if (rv
) /* source not found */
1909 goto done
; /* err = -EADDRNOTAVAIL */
1911 /* special case - (INCLUDE, empty) == LEAVE_GROUP */
1912 if (psl
->sl_count
== 1 && omode
== MCAST_INCLUDE
) {
1917 /* update the interface filter */
1918 ip_mc_del_src(in_dev
, &mreqs
->imr_multiaddr
, omode
, 1,
1919 &mreqs
->imr_sourceaddr
, 1);
1921 for (j
=i
+1; j
<psl
->sl_count
; j
++)
1922 psl
->sl_addr
[j
-1] = psl
->sl_addr
[j
];
1927 /* else, add a new source to the filter */
1929 if (psl
&& psl
->sl_count
>= sysctl_igmp_max_msf
) {
1933 if (!psl
|| psl
->sl_count
== psl
->sl_max
) {
1934 struct ip_sf_socklist
*newpsl
;
1935 int count
= IP_SFBLOCK
;
1938 count
+= psl
->sl_max
;
1939 newpsl
= sock_kmalloc(sk
, IP_SFLSIZE(count
), GFP_KERNEL
);
1944 newpsl
->sl_max
= count
;
1945 newpsl
->sl_count
= count
- IP_SFBLOCK
;
1947 for (i
=0; i
<psl
->sl_count
; i
++)
1948 newpsl
->sl_addr
[i
] = psl
->sl_addr
[i
];
1949 sock_kfree_s(sk
, psl
, IP_SFLSIZE(psl
->sl_max
));
1951 pmc
->sflist
= psl
= newpsl
;
1953 rv
= 1; /* > 0 for insert logic below if sl_count is 0 */
1954 for (i
=0; i
<psl
->sl_count
; i
++) {
1955 rv
= memcmp(&psl
->sl_addr
[i
], &mreqs
->imr_sourceaddr
,
1960 if (rv
== 0) /* address already there is an error */
1962 for (j
=psl
->sl_count
-1; j
>=i
; j
--)
1963 psl
->sl_addr
[j
+1] = psl
->sl_addr
[j
];
1964 psl
->sl_addr
[i
] = mreqs
->imr_sourceaddr
;
1967 /* update the interface list */
1968 ip_mc_add_src(in_dev
, &mreqs
->imr_multiaddr
, omode
, 1,
1969 &mreqs
->imr_sourceaddr
, 1);
1973 return ip_mc_leave_group(sk
, &imr
);
1977 int ip_mc_msfilter(struct sock
*sk
, struct ip_msfilter
*msf
, int ifindex
)
1980 struct ip_mreqn imr
;
1981 __be32 addr
= msf
->imsf_multiaddr
;
1982 struct ip_mc_socklist
*pmc
;
1983 struct in_device
*in_dev
;
1984 struct inet_sock
*inet
= inet_sk(sk
);
1985 struct ip_sf_socklist
*newpsl
, *psl
;
1988 if (!ipv4_is_multicast(addr
))
1990 if (msf
->imsf_fmode
!= MCAST_INCLUDE
&&
1991 msf
->imsf_fmode
!= MCAST_EXCLUDE
)
1996 imr
.imr_multiaddr
.s_addr
= msf
->imsf_multiaddr
;
1997 imr
.imr_address
.s_addr
= msf
->imsf_interface
;
1998 imr
.imr_ifindex
= ifindex
;
1999 in_dev
= ip_mc_find_dev(&imr
);
2006 /* special case - (INCLUDE, empty) == LEAVE_GROUP */
2007 if (msf
->imsf_fmode
== MCAST_INCLUDE
&& msf
->imsf_numsrc
== 0) {
2012 for (pmc
=inet
->mc_list
; pmc
; pmc
=pmc
->next
) {
2013 if (pmc
->multi
.imr_multiaddr
.s_addr
== msf
->imsf_multiaddr
&&
2014 pmc
->multi
.imr_ifindex
== imr
.imr_ifindex
)
2017 if (!pmc
) { /* must have a prior join */
2021 if (msf
->imsf_numsrc
) {
2022 newpsl
= sock_kmalloc(sk
, IP_SFLSIZE(msf
->imsf_numsrc
),
2028 newpsl
->sl_max
= newpsl
->sl_count
= msf
->imsf_numsrc
;
2029 memcpy(newpsl
->sl_addr
, msf
->imsf_slist
,
2030 msf
->imsf_numsrc
* sizeof(msf
->imsf_slist
[0]));
2031 err
= ip_mc_add_src(in_dev
, &msf
->imsf_multiaddr
,
2032 msf
->imsf_fmode
, newpsl
->sl_count
, newpsl
->sl_addr
, 0);
2034 sock_kfree_s(sk
, newpsl
, IP_SFLSIZE(newpsl
->sl_max
));
2039 (void) ip_mc_add_src(in_dev
, &msf
->imsf_multiaddr
,
2040 msf
->imsf_fmode
, 0, NULL
, 0);
2044 (void) ip_mc_del_src(in_dev
, &msf
->imsf_multiaddr
, pmc
->sfmode
,
2045 psl
->sl_count
, psl
->sl_addr
, 0);
2046 sock_kfree_s(sk
, psl
, IP_SFLSIZE(psl
->sl_max
));
2048 (void) ip_mc_del_src(in_dev
, &msf
->imsf_multiaddr
, pmc
->sfmode
,
2050 pmc
->sflist
= newpsl
;
2051 pmc
->sfmode
= msf
->imsf_fmode
;
2056 err
= ip_mc_leave_group(sk
, &imr
);
2060 int ip_mc_msfget(struct sock
*sk
, struct ip_msfilter
*msf
,
2061 struct ip_msfilter __user
*optval
, int __user
*optlen
)
2063 int err
, len
, count
, copycount
;
2064 struct ip_mreqn imr
;
2065 __be32 addr
= msf
->imsf_multiaddr
;
2066 struct ip_mc_socklist
*pmc
;
2067 struct in_device
*in_dev
;
2068 struct inet_sock
*inet
= inet_sk(sk
);
2069 struct ip_sf_socklist
*psl
;
2071 if (!ipv4_is_multicast(addr
))
2076 imr
.imr_multiaddr
.s_addr
= msf
->imsf_multiaddr
;
2077 imr
.imr_address
.s_addr
= msf
->imsf_interface
;
2078 imr
.imr_ifindex
= 0;
2079 in_dev
= ip_mc_find_dev(&imr
);
2085 err
= -EADDRNOTAVAIL
;
2087 for (pmc
=inet
->mc_list
; pmc
; pmc
=pmc
->next
) {
2088 if (pmc
->multi
.imr_multiaddr
.s_addr
== msf
->imsf_multiaddr
&&
2089 pmc
->multi
.imr_ifindex
== imr
.imr_ifindex
)
2092 if (!pmc
) /* must have a prior join */
2094 msf
->imsf_fmode
= pmc
->sfmode
;
2101 count
= psl
->sl_count
;
2103 copycount
= count
< msf
->imsf_numsrc
? count
: msf
->imsf_numsrc
;
2104 len
= copycount
* sizeof(psl
->sl_addr
[0]);
2105 msf
->imsf_numsrc
= count
;
2106 if (put_user(IP_MSFILTER_SIZE(copycount
), optlen
) ||
2107 copy_to_user(optval
, msf
, IP_MSFILTER_SIZE(0))) {
2111 copy_to_user(&optval
->imsf_slist
[0], psl
->sl_addr
, len
))
2119 int ip_mc_gsfget(struct sock
*sk
, struct group_filter
*gsf
,
2120 struct group_filter __user
*optval
, int __user
*optlen
)
2122 int err
, i
, count
, copycount
;
2123 struct sockaddr_in
*psin
;
2125 struct ip_mc_socklist
*pmc
;
2126 struct inet_sock
*inet
= inet_sk(sk
);
2127 struct ip_sf_socklist
*psl
;
2129 psin
= (struct sockaddr_in
*)&gsf
->gf_group
;
2130 if (psin
->sin_family
!= AF_INET
)
2132 addr
= psin
->sin_addr
.s_addr
;
2133 if (!ipv4_is_multicast(addr
))
2138 err
= -EADDRNOTAVAIL
;
2140 for (pmc
=inet
->mc_list
; pmc
; pmc
=pmc
->next
) {
2141 if (pmc
->multi
.imr_multiaddr
.s_addr
== addr
&&
2142 pmc
->multi
.imr_ifindex
== gsf
->gf_interface
)
2145 if (!pmc
) /* must have a prior join */
2147 gsf
->gf_fmode
= pmc
->sfmode
;
2150 count
= psl
? psl
->sl_count
: 0;
2151 copycount
= count
< gsf
->gf_numsrc
? count
: gsf
->gf_numsrc
;
2152 gsf
->gf_numsrc
= count
;
2153 if (put_user(GROUP_FILTER_SIZE(copycount
), optlen
) ||
2154 copy_to_user(optval
, gsf
, GROUP_FILTER_SIZE(0))) {
2157 for (i
=0; i
<copycount
; i
++) {
2158 struct sockaddr_storage ss
;
2160 psin
= (struct sockaddr_in
*)&ss
;
2161 memset(&ss
, 0, sizeof(ss
));
2162 psin
->sin_family
= AF_INET
;
2163 psin
->sin_addr
.s_addr
= psl
->sl_addr
[i
];
2164 if (copy_to_user(&optval
->gf_slist
[i
], &ss
, sizeof(ss
)))
2174 * check if a multicast source filter allows delivery for a given <src,dst,intf>
2176 int ip_mc_sf_allow(struct sock
*sk
, __be32 loc_addr
, __be32 rmt_addr
, int dif
)
2178 struct inet_sock
*inet
= inet_sk(sk
);
2179 struct ip_mc_socklist
*pmc
;
2180 struct ip_sf_socklist
*psl
;
2183 if (!ipv4_is_multicast(loc_addr
))
2186 for (pmc
=inet
->mc_list
; pmc
; pmc
=pmc
->next
) {
2187 if (pmc
->multi
.imr_multiaddr
.s_addr
== loc_addr
&&
2188 pmc
->multi
.imr_ifindex
== dif
)
2195 return pmc
->sfmode
== MCAST_EXCLUDE
;
2197 for (i
=0; i
<psl
->sl_count
; i
++) {
2198 if (psl
->sl_addr
[i
] == rmt_addr
)
2201 if (pmc
->sfmode
== MCAST_INCLUDE
&& i
>= psl
->sl_count
)
2203 if (pmc
->sfmode
== MCAST_EXCLUDE
&& i
< psl
->sl_count
)
2209 * A socket is closing.
2212 void ip_mc_drop_socket(struct sock
*sk
)
2214 struct inet_sock
*inet
= inet_sk(sk
);
2215 struct ip_mc_socklist
*iml
;
2217 if (inet
->mc_list
== NULL
)
2221 while ((iml
= inet
->mc_list
) != NULL
) {
2222 struct in_device
*in_dev
;
2223 inet
->mc_list
= iml
->next
;
2225 in_dev
= inetdev_by_index(iml
->multi
.imr_ifindex
);
2226 (void) ip_mc_leave_src(sk
, iml
, in_dev
);
2227 if (in_dev
!= NULL
) {
2228 ip_mc_dec_group(in_dev
, iml
->multi
.imr_multiaddr
.s_addr
);
2231 sock_kfree_s(sk
, iml
, sizeof(*iml
));
2236 int ip_check_mc(struct in_device
*in_dev
, __be32 mc_addr
, __be32 src_addr
, u16 proto
)
2238 struct ip_mc_list
*im
;
2239 struct ip_sf_list
*psf
;
2242 read_lock(&in_dev
->mc_list_lock
);
2243 for (im
=in_dev
->mc_list
; im
; im
=im
->next
) {
2244 if (im
->multiaddr
== mc_addr
)
2247 if (im
&& proto
== IPPROTO_IGMP
) {
2251 for (psf
=im
->sources
; psf
; psf
=psf
->sf_next
) {
2252 if (psf
->sf_inaddr
== src_addr
)
2256 rv
= psf
->sf_count
[MCAST_INCLUDE
] ||
2257 psf
->sf_count
[MCAST_EXCLUDE
] !=
2258 im
->sfcount
[MCAST_EXCLUDE
];
2260 rv
= im
->sfcount
[MCAST_EXCLUDE
] != 0;
2262 rv
= 1; /* unspecified source; tentatively allow */
2264 read_unlock(&in_dev
->mc_list_lock
);
2268 #if defined(CONFIG_PROC_FS)
2269 struct igmp_mc_iter_state
{
2270 struct net_device
*dev
;
2271 struct in_device
*in_dev
;
2274 #define igmp_mc_seq_private(seq) ((struct igmp_mc_iter_state *)(seq)->private)
2276 static inline struct ip_mc_list
*igmp_mc_get_first(struct seq_file
*seq
)
2278 struct ip_mc_list
*im
= NULL
;
2279 struct igmp_mc_iter_state
*state
= igmp_mc_seq_private(seq
);
2281 state
->in_dev
= NULL
;
2282 for_each_netdev(&init_net
, state
->dev
) {
2283 struct in_device
*in_dev
;
2284 in_dev
= in_dev_get(state
->dev
);
2287 read_lock(&in_dev
->mc_list_lock
);
2288 im
= in_dev
->mc_list
;
2290 state
->in_dev
= in_dev
;
2293 read_unlock(&in_dev
->mc_list_lock
);
2299 static struct ip_mc_list
*igmp_mc_get_next(struct seq_file
*seq
, struct ip_mc_list
*im
)
2301 struct igmp_mc_iter_state
*state
= igmp_mc_seq_private(seq
);
2304 if (likely(state
->in_dev
!= NULL
)) {
2305 read_unlock(&state
->in_dev
->mc_list_lock
);
2306 in_dev_put(state
->in_dev
);
2308 state
->dev
= next_net_device(state
->dev
);
2310 state
->in_dev
= NULL
;
2313 state
->in_dev
= in_dev_get(state
->dev
);
2316 read_lock(&state
->in_dev
->mc_list_lock
);
2317 im
= state
->in_dev
->mc_list
;
2322 static struct ip_mc_list
*igmp_mc_get_idx(struct seq_file
*seq
, loff_t pos
)
2324 struct ip_mc_list
*im
= igmp_mc_get_first(seq
);
2326 while (pos
&& (im
= igmp_mc_get_next(seq
, im
)) != NULL
)
2328 return pos
? NULL
: im
;
2331 static void *igmp_mc_seq_start(struct seq_file
*seq
, loff_t
*pos
)
2333 read_lock(&dev_base_lock
);
2334 return *pos
? igmp_mc_get_idx(seq
, *pos
- 1) : SEQ_START_TOKEN
;
2337 static void *igmp_mc_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
2339 struct ip_mc_list
*im
;
2340 if (v
== SEQ_START_TOKEN
)
2341 im
= igmp_mc_get_first(seq
);
2343 im
= igmp_mc_get_next(seq
, v
);
2348 static void igmp_mc_seq_stop(struct seq_file
*seq
, void *v
)
2350 struct igmp_mc_iter_state
*state
= igmp_mc_seq_private(seq
);
2351 if (likely(state
->in_dev
!= NULL
)) {
2352 read_unlock(&state
->in_dev
->mc_list_lock
);
2353 in_dev_put(state
->in_dev
);
2354 state
->in_dev
= NULL
;
2357 read_unlock(&dev_base_lock
);
2360 static int igmp_mc_seq_show(struct seq_file
*seq
, void *v
)
2362 if (v
== SEQ_START_TOKEN
)
2364 "Idx\tDevice : Count Querier\tGroup Users Timer\tReporter\n");
2366 struct ip_mc_list
*im
= (struct ip_mc_list
*)v
;
2367 struct igmp_mc_iter_state
*state
= igmp_mc_seq_private(seq
);
2369 #ifdef CONFIG_IP_MULTICAST
2370 querier
= IGMP_V1_SEEN(state
->in_dev
) ? "V1" :
2371 IGMP_V2_SEEN(state
->in_dev
) ? "V2" :
2377 if (state
->in_dev
->mc_list
== im
) {
2378 seq_printf(seq
, "%d\t%-10s: %5d %7s\n",
2379 state
->dev
->ifindex
, state
->dev
->name
, state
->dev
->mc_count
, querier
);
2383 "\t\t\t\t%08X %5d %d:%08lX\t\t%d\n",
2384 im
->multiaddr
, im
->users
,
2385 im
->tm_running
, im
->tm_running
?
2386 jiffies_to_clock_t(im
->timer
.expires
-jiffies
) : 0,
2392 static const struct seq_operations igmp_mc_seq_ops
= {
2393 .start
= igmp_mc_seq_start
,
2394 .next
= igmp_mc_seq_next
,
2395 .stop
= igmp_mc_seq_stop
,
2396 .show
= igmp_mc_seq_show
,
2399 static int igmp_mc_seq_open(struct inode
*inode
, struct file
*file
)
2401 return seq_open_private(file
, &igmp_mc_seq_ops
,
2402 sizeof(struct igmp_mc_iter_state
));
2405 static const struct file_operations igmp_mc_seq_fops
= {
2406 .owner
= THIS_MODULE
,
2407 .open
= igmp_mc_seq_open
,
2409 .llseek
= seq_lseek
,
2410 .release
= seq_release_private
,
2413 struct igmp_mcf_iter_state
{
2414 struct net_device
*dev
;
2415 struct in_device
*idev
;
2416 struct ip_mc_list
*im
;
2419 #define igmp_mcf_seq_private(seq) ((struct igmp_mcf_iter_state *)(seq)->private)
2421 static inline struct ip_sf_list
*igmp_mcf_get_first(struct seq_file
*seq
)
2423 struct ip_sf_list
*psf
= NULL
;
2424 struct ip_mc_list
*im
= NULL
;
2425 struct igmp_mcf_iter_state
*state
= igmp_mcf_seq_private(seq
);
2429 for_each_netdev(&init_net
, state
->dev
) {
2430 struct in_device
*idev
;
2431 idev
= in_dev_get(state
->dev
);
2432 if (unlikely(idev
== NULL
))
2434 read_lock(&idev
->mc_list_lock
);
2436 if (likely(im
!= NULL
)) {
2437 spin_lock_bh(&im
->lock
);
2439 if (likely(psf
!= NULL
)) {
2444 spin_unlock_bh(&im
->lock
);
2446 read_unlock(&idev
->mc_list_lock
);
2452 static struct ip_sf_list
*igmp_mcf_get_next(struct seq_file
*seq
, struct ip_sf_list
*psf
)
2454 struct igmp_mcf_iter_state
*state
= igmp_mcf_seq_private(seq
);
2458 spin_unlock_bh(&state
->im
->lock
);
2459 state
->im
= state
->im
->next
;
2460 while (!state
->im
) {
2461 if (likely(state
->idev
!= NULL
)) {
2462 read_unlock(&state
->idev
->mc_list_lock
);
2463 in_dev_put(state
->idev
);
2465 state
->dev
= next_net_device(state
->dev
);
2470 state
->idev
= in_dev_get(state
->dev
);
2473 read_lock(&state
->idev
->mc_list_lock
);
2474 state
->im
= state
->idev
->mc_list
;
2478 spin_lock_bh(&state
->im
->lock
);
2479 psf
= state
->im
->sources
;
2485 static struct ip_sf_list
*igmp_mcf_get_idx(struct seq_file
*seq
, loff_t pos
)
2487 struct ip_sf_list
*psf
= igmp_mcf_get_first(seq
);
2489 while (pos
&& (psf
= igmp_mcf_get_next(seq
, psf
)) != NULL
)
2491 return pos
? NULL
: psf
;
2494 static void *igmp_mcf_seq_start(struct seq_file
*seq
, loff_t
*pos
)
2496 read_lock(&dev_base_lock
);
2497 return *pos
? igmp_mcf_get_idx(seq
, *pos
- 1) : SEQ_START_TOKEN
;
2500 static void *igmp_mcf_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
2502 struct ip_sf_list
*psf
;
2503 if (v
== SEQ_START_TOKEN
)
2504 psf
= igmp_mcf_get_first(seq
);
2506 psf
= igmp_mcf_get_next(seq
, v
);
2511 static void igmp_mcf_seq_stop(struct seq_file
*seq
, void *v
)
2513 struct igmp_mcf_iter_state
*state
= igmp_mcf_seq_private(seq
);
2514 if (likely(state
->im
!= NULL
)) {
2515 spin_unlock_bh(&state
->im
->lock
);
2518 if (likely(state
->idev
!= NULL
)) {
2519 read_unlock(&state
->idev
->mc_list_lock
);
2520 in_dev_put(state
->idev
);
2524 read_unlock(&dev_base_lock
);
2527 static int igmp_mcf_seq_show(struct seq_file
*seq
, void *v
)
2529 struct ip_sf_list
*psf
= (struct ip_sf_list
*)v
;
2530 struct igmp_mcf_iter_state
*state
= igmp_mcf_seq_private(seq
);
2532 if (v
== SEQ_START_TOKEN
) {
2535 "%10s %10s %6s %6s\n", "Idx",
2537 "SRC", "INC", "EXC");
2541 "0x%08x %6lu %6lu\n",
2542 state
->dev
->ifindex
, state
->dev
->name
,
2543 ntohl(state
->im
->multiaddr
),
2544 ntohl(psf
->sf_inaddr
),
2545 psf
->sf_count
[MCAST_INCLUDE
],
2546 psf
->sf_count
[MCAST_EXCLUDE
]);
2551 static const struct seq_operations igmp_mcf_seq_ops
= {
2552 .start
= igmp_mcf_seq_start
,
2553 .next
= igmp_mcf_seq_next
,
2554 .stop
= igmp_mcf_seq_stop
,
2555 .show
= igmp_mcf_seq_show
,
2558 static int igmp_mcf_seq_open(struct inode
*inode
, struct file
*file
)
2560 return seq_open_private(file
, &igmp_mcf_seq_ops
,
2561 sizeof(struct igmp_mcf_iter_state
));
2564 static const struct file_operations igmp_mcf_seq_fops
= {
2565 .owner
= THIS_MODULE
,
2566 .open
= igmp_mcf_seq_open
,
2568 .llseek
= seq_lseek
,
2569 .release
= seq_release_private
,
2572 int __init
igmp_mc_proc_init(void)
2574 proc_net_fops_create(&init_net
, "igmp", S_IRUGO
, &igmp_mc_seq_fops
);
2575 proc_net_fops_create(&init_net
, "mcfilter", S_IRUGO
, &igmp_mcf_seq_fops
);
2580 EXPORT_SYMBOL(ip_mc_dec_group
);
2581 EXPORT_SYMBOL(ip_mc_inc_group
);
2582 EXPORT_SYMBOL(ip_mc_join_group
);
2583 EXPORT_SYMBOL(ip_mc_rejoin_group
);