1: /*
2: PIM for Quagga
3: Copyright (C) 2008 Everton da Silva Marques
4:
5: This program is free software; you can redistribute it and/or modify
6: it under the terms of the GNU General Public License as published by
7: the Free Software Foundation; either version 2 of the License, or
8: (at your option) any later version.
9:
10: This program is distributed in the hope that it will be useful, but
11: WITHOUT ANY WARRANTY; without even the implied warranty of
12: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13: General Public License for more details.
14:
15: You should have received a copy of the GNU General Public License
16: along with this program; see the file COPYING; if not, write to the
17: Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
18: MA 02110-1301 USA
19:
20: $QuaggaId: $Format:%an, %ai, %h$ $
21: */
22:
23: #include <zebra.h>
24:
25: #include "memory.h"
26:
27: #include "pimd.h"
28: #include "pim_igmp.h"
29: #include "pim_igmpv3.h"
30: #include "pim_iface.h"
31: #include "pim_sock.h"
32: #include "pim_mroute.h"
33: #include "pim_str.h"
34: #include "pim_util.h"
35: #include "pim_time.h"
36: #include "pim_zebra.h"
37:
38: #define IGMP_GRP_REC_TYPE_MODE_IS_INCLUDE (1)
39: #define IGMP_GRP_REC_TYPE_MODE_IS_EXCLUDE (2)
40: #define IGMP_GRP_REC_TYPE_CHANGE_TO_INCLUDE_MODE (3)
41: #define IGMP_GRP_REC_TYPE_CHANGE_TO_EXCLUDE_MODE (4)
42: #define IGMP_GRP_REC_TYPE_ALLOW_NEW_SOURCES (5)
43: #define IGMP_GRP_REC_TYPE_BLOCK_OLD_SOURCES (6)
44:
45: static void group_timer_off(struct igmp_group *group);
46:
47: static struct igmp_group *find_group_by_addr(struct igmp_sock *igmp,
48: struct in_addr group_addr);
49:
50: static int igmp_sock_open(struct in_addr ifaddr, ifindex_t ifindex,
51: uint32_t pim_options)
52: {
53: int fd;
54: int join = 0;
55: struct in_addr group;
56:
57: fd = pim_socket_mcast(IPPROTO_IGMP, ifaddr, 1 /* loop=true */);
58: if (fd < 0)
59: return -1;
60:
61: if (PIM_IF_TEST_IGMP_LISTEN_ALLROUTERS(pim_options)) {
62: if (inet_aton(PIM_ALL_ROUTERS, &group)) {
63: if (!pim_socket_join(fd, group, ifaddr, ifindex))
64: ++join;
65: }
66: else {
67: zlog_warn("%s %s: IGMP socket fd=%d interface %s: could not solve %s to group address: errno=%d: %s",
68: __FILE__, __PRETTY_FUNCTION__, fd, inet_ntoa(ifaddr),
69: PIM_ALL_ROUTERS, errno, safe_strerror(errno));
70: }
71: }
72:
73: /*
74: IGMP routers periodically send IGMP general queries to AllSystems=224.0.0.1
75: IGMP routers must receive general queries for querier election.
76: */
77: if (inet_aton(PIM_ALL_SYSTEMS, &group)) {
78: if (!pim_socket_join(fd, group, ifaddr, ifindex))
79: ++join;
80: }
81: else {
82: zlog_warn("%s %s: IGMP socket fd=%d interface %s: could not solve %s to group address: errno=%d: %s",
83: __FILE__, __PRETTY_FUNCTION__, fd, inet_ntoa(ifaddr),
84: PIM_ALL_SYSTEMS, errno, safe_strerror(errno));
85: }
86:
87: if (inet_aton(PIM_ALL_IGMP_ROUTERS, &group)) {
88: if (!pim_socket_join(fd, group, ifaddr, ifindex)) {
89: ++join;
90: }
91: }
92: else {
93: zlog_warn("%s %s: IGMP socket fd=%d interface %s: could not solve %s to group address: errno=%d: %s",
94: __FILE__, __PRETTY_FUNCTION__, fd, inet_ntoa(ifaddr),
95: PIM_ALL_IGMP_ROUTERS, errno, safe_strerror(errno));
96: }
97:
98: if (!join) {
99: zlog_err("IGMP socket fd=%d could not join any group on interface address %s",
100: fd, inet_ntoa(ifaddr));
101: close(fd);
102: fd = -1;
103: }
104:
105: return fd;
106: }
107:
108: #undef IGMP_SOCK_DUMP
109:
110: #ifdef IGMP_SOCK_DUMP
111: static void igmp_sock_dump(array_t *igmp_sock_array)
112: {
113: int size = array_size(igmp_sock_array);
114: for (int i = 0; i < size; ++i) {
115:
116: struct igmp_sock *igmp = array_get(igmp_sock_array, i);
117:
118: zlog_debug("%s %s: [%d/%d] igmp_addr=%s fd=%d",
119: __FILE__, __PRETTY_FUNCTION__,
120: i, size,
121: inet_ntoa(igmp->ifaddr),
122: igmp->fd);
123: }
124: }
125: #endif
126:
127: struct igmp_sock *pim_igmp_sock_lookup_ifaddr(struct list *igmp_sock_list,
128: struct in_addr ifaddr)
129: {
130: struct listnode *sock_node;
131: struct igmp_sock *igmp;
132:
133: #ifdef IGMP_SOCK_DUMP
134: igmp_sock_dump(igmp_sock_list);
135: #endif
136:
137: for (ALL_LIST_ELEMENTS_RO(igmp_sock_list, sock_node, igmp))
138: if (ifaddr.s_addr == igmp->ifaddr.s_addr)
139: return igmp;
140:
141: return 0;
142: }
143:
144: struct igmp_sock *igmp_sock_lookup_by_fd(struct list *igmp_sock_list,
145: int fd)
146: {
147: struct listnode *sock_node;
148: struct igmp_sock *igmp;
149:
150: for (ALL_LIST_ELEMENTS_RO(igmp_sock_list, sock_node, igmp))
151: if (fd == igmp->fd)
152: return igmp;
153:
154: return 0;
155: }
156:
157: static int pim_igmp_other_querier_expire(struct thread *t)
158: {
159: struct igmp_sock *igmp;
160:
161: zassert(t);
162: igmp = THREAD_ARG(t);
163: zassert(igmp);
164:
165: zassert(igmp->t_other_querier_timer);
166: zassert(!igmp->t_igmp_query_timer);
167:
168: if (PIM_DEBUG_IGMP_TRACE) {
169: char ifaddr_str[100];
170: pim_inet4_dump("<ifaddr?>", igmp->ifaddr, ifaddr_str, sizeof(ifaddr_str));
171: zlog_debug("%s: Querier %s resuming",
172: __PRETTY_FUNCTION__,
173: ifaddr_str);
174: }
175:
176: igmp->t_other_querier_timer = 0;
177:
178: /*
179: We are the current querier, then
180: re-start sending general queries.
181: */
182: pim_igmp_general_query_on(igmp);
183:
184: return 0;
185: }
186:
187: void pim_igmp_other_querier_timer_on(struct igmp_sock *igmp)
188: {
189: long other_querier_present_interval_msec;
190: struct pim_interface *pim_ifp;
191:
192: zassert(igmp);
193: zassert(igmp->interface);
194: zassert(igmp->interface->info);
195:
196: pim_ifp = igmp->interface->info;
197:
198: if (igmp->t_other_querier_timer) {
199: /*
200: There is other querier present already,
201: then reset the other-querier-present timer.
202: */
203:
204: if (PIM_DEBUG_IGMP_TRACE) {
205: char ifaddr_str[100];
206: pim_inet4_dump("<ifaddr?>", igmp->ifaddr, ifaddr_str, sizeof(ifaddr_str));
207: zlog_debug("Querier %s resetting TIMER event for Other-Querier-Present",
208: ifaddr_str);
209: }
210:
211: THREAD_OFF(igmp->t_other_querier_timer);
212: zassert(!igmp->t_other_querier_timer);
213: }
214: else {
215: /*
216: We are the current querier, then stop sending general queries:
217: igmp->t_igmp_query_timer = 0;
218: */
219: pim_igmp_general_query_off(igmp);
220: }
221:
222: /*
223: Since this socket is starting the other-querier-present timer,
224: there should not be periodic query timer for this socket.
225: */
226: zassert(!igmp->t_igmp_query_timer);
227:
228: /*
229: RFC 3376: 8.5. Other Querier Present Interval
230:
231: The Other Querier Present Interval is the length of time that must
232: pass before a multicast router decides that there is no longer
233: another multicast router which should be the querier. This value
234: MUST be ((the Robustness Variable) times (the Query Interval)) plus
235: (one half of one Query Response Interval).
236:
237: other_querier_present_interval_msec = \
238: igmp->querier_robustness_variable * \
239: 1000 * igmp->querier_query_interval + \
240: 100 * (pim_ifp->query_max_response_time_dsec >> 1);
241: */
242: other_querier_present_interval_msec =
243: PIM_IGMP_OQPI_MSEC(igmp->querier_robustness_variable,
244: igmp->querier_query_interval,
245: pim_ifp->igmp_query_max_response_time_dsec);
246:
247: if (PIM_DEBUG_IGMP_TRACE) {
248: char ifaddr_str[100];
249: pim_inet4_dump("<ifaddr?>", igmp->ifaddr, ifaddr_str, sizeof(ifaddr_str));
250: zlog_debug("Querier %s scheduling %ld.%03ld sec TIMER event for Other-Querier-Present",
251: ifaddr_str,
252: other_querier_present_interval_msec / 1000,
253: other_querier_present_interval_msec % 1000);
254: }
255:
256: THREAD_TIMER_MSEC_ON(master, igmp->t_other_querier_timer,
257: pim_igmp_other_querier_expire,
258: igmp, other_querier_present_interval_msec);
259: }
260:
261: void pim_igmp_other_querier_timer_off(struct igmp_sock *igmp)
262: {
263: zassert(igmp);
264:
265: if (PIM_DEBUG_IGMP_TRACE) {
266: if (igmp->t_other_querier_timer) {
267: char ifaddr_str[100];
268: pim_inet4_dump("<ifaddr?>", igmp->ifaddr, ifaddr_str, sizeof(ifaddr_str));
269: zlog_debug("IGMP querier %s fd=%d cancelling other-querier-present TIMER event on %s",
270: ifaddr_str, igmp->fd, igmp->interface->name);
271: }
272: }
273: THREAD_OFF(igmp->t_other_querier_timer);
274: zassert(!igmp->t_other_querier_timer);
275: }
276:
277: static int recv_igmp_query(struct igmp_sock *igmp, int query_version,
278: int max_resp_code,
279: struct in_addr from, const char *from_str,
280: char *igmp_msg, int igmp_msg_len)
281: {
282: struct interface *ifp;
283: struct pim_interface *pim_ifp;
284: uint8_t resv_s_qrv = 0;
285: uint8_t s_flag = 0;
286: uint8_t qrv = 0;
287: struct in_addr group_addr;
288: uint16_t recv_checksum;
289: uint16_t checksum;
290: int i;
291:
292: //group_addr = *(struct in_addr *)(igmp_msg + 4);
293: memcpy(&group_addr, igmp_msg + 4, sizeof(struct in_addr));
294:
295: ifp = igmp->interface;
296: pim_ifp = ifp->info;
297:
298: recv_checksum = *(uint16_t *) (igmp_msg + IGMP_V3_CHECKSUM_OFFSET);
299:
300: /* for computing checksum */
301: *(uint16_t *) (igmp_msg + IGMP_V3_CHECKSUM_OFFSET) = 0;
302:
303: checksum = in_cksum(igmp_msg, igmp_msg_len);
304: if (checksum != recv_checksum) {
305: zlog_warn("Recv IGMP query v%d from %s on %s: checksum mismatch: received=%x computed=%x",
306: query_version, from_str, ifp->name, recv_checksum, checksum);
307: return -1;
308: }
309:
310: if (PIM_DEBUG_IGMP_PACKETS) {
311: char group_str[100];
312: pim_inet4_dump("<group?>", group_addr, group_str, sizeof(group_str));
313: zlog_debug("Recv IGMP query v%d from %s on %s: size=%d checksum=%x group=%s",
314: query_version, from_str, ifp->name,
315: igmp_msg_len, checksum, group_str);
316: }
317:
318: /*
319: RFC 3376: 6.6.2. Querier Election
320:
321: When a router receives a query with a lower IP address, it sets
322: the Other-Querier-Present timer to Other Querier Present Interval
323: and ceases to send queries on the network if it was the previously
324: elected querier.
325: */
326: if (ntohl(from.s_addr) < ntohl(igmp->ifaddr.s_addr)) {
327:
328: if (PIM_DEBUG_IGMP_TRACE) {
329: char ifaddr_str[100];
330: pim_inet4_dump("<ifaddr?>", igmp->ifaddr, ifaddr_str, sizeof(ifaddr_str));
331: zlog_debug("%s: local address %s (%u) lost querier election to %s (%u)",
332: ifp->name,
333: ifaddr_str, ntohl(igmp->ifaddr.s_addr),
334: from_str, ntohl(from.s_addr));
335: }
336:
337: pim_igmp_other_querier_timer_on(igmp);
338: }
339:
340: if (query_version == 3) {
341: /*
342: RFC 3376: 4.1.6. QRV (Querier's Robustness Variable)
343:
344: Routers adopt the QRV value from the most recently received Query
345: as their own [Robustness Variable] value, unless that most
346: recently received QRV was zero, in which case the receivers use
347: the default [Robustness Variable] value specified in section 8.1
348: or a statically configured value.
349: */
350: resv_s_qrv = igmp_msg[8];
351: qrv = 7 & resv_s_qrv;
352: igmp->querier_robustness_variable = qrv ? qrv : pim_ifp->igmp_default_robustness_variable;
353: }
354:
355: /*
356: RFC 3376: 4.1.7. QQIC (Querier's Query Interval Code)
357:
358: Multicast routers that are not the current querier adopt the QQI
359: value from the most recently received Query as their own [Query
360: Interval] value, unless that most recently received QQI was zero,
361: in which case the receiving routers use the default.
362: */
363: if (igmp->t_other_querier_timer && query_version == 3) {
364: /* other querier present */
365: uint8_t qqic;
366: uint16_t qqi;
367: qqic = igmp_msg[9];
368: qqi = igmp_msg_decode8to16(qqic);
369: igmp->querier_query_interval = qqi ? qqi : pim_ifp->igmp_default_query_interval;
370:
371: if (PIM_DEBUG_IGMP_TRACE) {
372: char ifaddr_str[100];
373: pim_inet4_dump("<ifaddr?>", igmp->ifaddr, ifaddr_str, sizeof(ifaddr_str));
374: zlog_debug("Querier %s new query interval is %s QQI=%u sec (recv QQIC=%02x from %s)",
375: ifaddr_str,
376: qqi ? "recv-non-default" : "default",
377: igmp->querier_query_interval,
378: qqic,
379: from_str);
380: }
381: }
382:
383: /*
384: RFC 3376: 6.6.1. Timer Updates
385:
386: When a router sends or receives a query with a clear Suppress
387: Router-Side Processing flag, it must update its timers to reflect
388: the correct timeout values for the group or sources being queried.
389:
390: General queries don't trigger timer update.
391: */
392: if (query_version == 3) {
393: s_flag = (1 << 3) & resv_s_qrv;
394: }
395: else {
396: /* Neither V1 nor V2 have this field. Pimd should really go into
397: * a compatibility mode here and run as V2 (or V1) but it doesn't
398: * so for now, lets just set the flag to suppress these timer updates.
399: */
400: s_flag = 1;
401: }
402:
403: if (!s_flag) {
404: /* s_flag is clear */
405:
406: if (PIM_INADDR_IS_ANY(group_addr)) {
407: /* this is a general query */
408:
409: /* log that general query should have the s_flag set */
410: zlog_warn("General IGMP query v%d from %s on %s: Suppress Router-Side Processing flag is clear",
411: query_version, from_str, ifp->name);
412: }
413: else {
414: struct igmp_group *group;
415:
416: /* this is a non-general query: perform timer updates */
417:
418: group = find_group_by_addr(igmp, group_addr);
419: if (group) {
420: int recv_num_sources = ntohs(*(uint16_t *)(igmp_msg + IGMP_V3_NUMSOURCES_OFFSET));
421:
422: /*
423: RFC 3376: 6.6.1. Timer Updates
424: Query Q(G,A): Source Timer for sources in A are lowered to LMQT
425: Query Q(G): Group Timer is lowered to LMQT
426: */
427: if (recv_num_sources < 1) {
428: /* Query Q(G): Group Timer is lowered to LMQT */
429:
430: igmp_group_timer_lower_to_lmqt(group);
431: }
432: else {
433: /* Query Q(G,A): Source Timer for sources in A are lowered to LMQT */
434:
435: /* Scan sources in query and lower their timers to LMQT */
436: struct in_addr *sources = (struct in_addr *)(igmp_msg + IGMP_V3_SOURCES_OFFSET);
437: for (i = 0; i < recv_num_sources; ++i) {
438: //struct in_addr src_addr = sources[i];
439: //struct igmp_source *src = igmp_find_source_by_addr(group, src_addr);
440: struct in_addr src_addr;
441: struct igmp_source *src;
442: memcpy(&src_addr, sources + i, sizeof(struct in_addr));
443: src = igmp_find_source_by_addr(group, src_addr);
444: if (src) {
445: igmp_source_timer_lower_to_lmqt(src);
446: }
447: }
448: }
449:
450: }
451: else {
452: char group_str[100];
453: pim_inet4_dump("<group?>", group_addr, group_str, sizeof(group_str));
454: zlog_warn("IGMP query v%d from %s on %s: could not find group %s for timer update",
455: query_version, from_str, ifp->name, group_str);
456: }
457: }
458: } /* s_flag is clear: timer updates */
459:
460: return 0;
461: }
462:
463: static int igmp_v3_report(struct igmp_sock *igmp,
464: struct in_addr from, const char *from_str,
465: char *igmp_msg, int igmp_msg_len)
466: {
467: uint16_t recv_checksum;
468: uint16_t checksum;
469: int num_groups;
470: uint8_t *group_record;
471: uint8_t *report_pastend = (uint8_t *) igmp_msg + igmp_msg_len;
472: struct interface *ifp = igmp->interface;
473: int i;
474:
475: if (igmp_msg_len < IGMP_V3_MSG_MIN_SIZE) {
476: zlog_warn("Recv IGMP report v3 from %s on %s: size=%d shorter than minimum=%d",
477: from_str, ifp->name, igmp_msg_len, IGMP_V3_MSG_MIN_SIZE);
478: return -1;
479: }
480:
481: recv_checksum = *(uint16_t *) (igmp_msg + IGMP_V3_CHECKSUM_OFFSET);
482:
483: /* for computing checksum */
484: *(uint16_t *) (igmp_msg + IGMP_V3_CHECKSUM_OFFSET) = 0;
485:
486: checksum = in_cksum(igmp_msg, igmp_msg_len);
487: if (checksum != recv_checksum) {
488: zlog_warn("Recv IGMP report v3 from %s on %s: checksum mismatch: received=%x computed=%x",
489: from_str, ifp->name, recv_checksum, checksum);
490: return -1;
491: }
492:
493: num_groups = ntohs(*(uint16_t *) (igmp_msg + IGMP_V3_REPORT_NUMGROUPS_OFFSET));
494: if (num_groups < 1) {
495: zlog_warn("Recv IGMP report v3 from %s on %s: missing group records",
496: from_str, ifp->name);
497: return -1;
498: }
499:
500: if (PIM_DEBUG_IGMP_PACKETS) {
501: zlog_debug("Recv IGMP report v3 from %s on %s: size=%d checksum=%x groups=%d",
502: from_str, ifp->name, igmp_msg_len, checksum, num_groups);
503: }
504:
505: group_record = (uint8_t *) igmp_msg + IGMP_V3_REPORT_GROUPPRECORD_OFFSET;
506:
507: /* Scan groups */
508: for (i = 0; i < num_groups; ++i) {
509: struct in_addr rec_group;
510: uint8_t *sources;
511: uint8_t *src;
512: int rec_type;
513: int rec_auxdatalen;
514: int rec_num_sources;
515: int j;
516:
517: if ((group_record + IGMP_V3_GROUP_RECORD_MIN_SIZE) > report_pastend) {
518: zlog_warn("Recv IGMP report v3 from %s on %s: group record beyond report end",
519: from_str, ifp->name);
520: return -1;
521: }
522:
523: rec_type = group_record[IGMP_V3_GROUP_RECORD_TYPE_OFFSET];
524: rec_auxdatalen = group_record[IGMP_V3_GROUP_RECORD_AUXDATALEN_OFFSET];
525: rec_num_sources = ntohs(* (uint16_t *) (group_record + IGMP_V3_GROUP_RECORD_NUMSOURCES_OFFSET));
526:
527: //rec_group = *(struct in_addr *)(group_record + IGMP_V3_GROUP_RECORD_GROUP_OFFSET);
528: memcpy(&rec_group, group_record + IGMP_V3_GROUP_RECORD_GROUP_OFFSET, sizeof(struct in_addr));
529:
530: if (PIM_DEBUG_IGMP_PACKETS) {
531: zlog_debug("Recv IGMP report v3 from %s on %s: record=%d type=%d auxdatalen=%d sources=%d group=%s",
532: from_str, ifp->name, i, rec_type, rec_auxdatalen, rec_num_sources, inet_ntoa(rec_group));
533: }
534:
535: /* Scan sources */
536:
537: sources = group_record + IGMP_V3_GROUP_RECORD_SOURCE_OFFSET;
538:
539: for (j = 0, src = sources; j < rec_num_sources; ++j, src += 4) {
540:
541: if ((src + 4) > report_pastend) {
542: zlog_warn("Recv IGMP report v3 from %s on %s: group source beyond report end",
543: from_str, ifp->name);
544: return -1;
545: }
546:
547: if (PIM_DEBUG_IGMP_PACKETS) {
548: char src_str[200];
549:
550: if (!inet_ntop(AF_INET, src, src_str , sizeof(src_str)))
551: sprintf(src_str, "<source?>");
552:
553: zlog_debug("Recv IGMP report v3 from %s on %s: record=%d group=%s source=%s",
554: from_str, ifp->name, i, inet_ntoa(rec_group), src_str);
555: }
556: } /* for (sources) */
557:
558: switch (rec_type) {
559: case IGMP_GRP_REC_TYPE_MODE_IS_INCLUDE:
560: igmpv3_report_isin(igmp, from, rec_group, rec_num_sources, (struct in_addr *) sources);
561: break;
562: case IGMP_GRP_REC_TYPE_MODE_IS_EXCLUDE:
563: igmpv3_report_isex(igmp, from, rec_group, rec_num_sources, (struct in_addr *) sources);
564: break;
565: case IGMP_GRP_REC_TYPE_CHANGE_TO_INCLUDE_MODE:
566: igmpv3_report_toin(igmp, from, rec_group, rec_num_sources, (struct in_addr *) sources);
567: break;
568: case IGMP_GRP_REC_TYPE_CHANGE_TO_EXCLUDE_MODE:
569: igmpv3_report_toex(igmp, from, rec_group, rec_num_sources, (struct in_addr *) sources);
570: break;
571: case IGMP_GRP_REC_TYPE_ALLOW_NEW_SOURCES:
572: igmpv3_report_allow(igmp, from, rec_group, rec_num_sources, (struct in_addr *) sources);
573: break;
574: case IGMP_GRP_REC_TYPE_BLOCK_OLD_SOURCES:
575: igmpv3_report_block(igmp, from, rec_group, rec_num_sources, (struct in_addr *) sources);
576: break;
577: default:
578: zlog_warn("Recv IGMP report v3 from %s on %s: unknown record type: type=%d",
579: from_str, ifp->name, rec_type);
580: }
581:
582: group_record += 8 + (rec_num_sources << 2) + (rec_auxdatalen << 2);
583:
584: } /* for (group records) */
585:
586: return 0;
587: }
588:
589: static void on_trace(const char *label,
590: struct interface *ifp, struct in_addr from)
591: {
592: if (PIM_DEBUG_IGMP_TRACE) {
593: char from_str[100];
594: pim_inet4_dump("<from?>", from, from_str, sizeof(from_str));
595: zlog_debug("%s: from %s on %s",
596: label, from_str, ifp->name);
597: }
598: }
599:
600: static int igmp_v2_report(struct igmp_sock *igmp,
601: struct in_addr from, const char *from_str,
602: char *igmp_msg, int igmp_msg_len)
603: {
604: struct interface *ifp = igmp->interface;
605: struct igmp_group *group;
606: struct in_addr group_addr;
607:
608: on_trace(__PRETTY_FUNCTION__, igmp->interface, from);
609:
610: if (igmp_msg_len != IGMP_V12_MSG_SIZE) {
611: zlog_warn("Recv IGMP report v2 from %s on %s: size=%d other than correct=%d",
612: from_str, ifp->name, igmp_msg_len, IGMP_V12_MSG_SIZE);
613: return -1;
614: }
615:
616: if (PIM_DEBUG_IGMP_TRACE) {
617: zlog_warn("%s %s: FIXME WRITEME",
618: __FILE__, __PRETTY_FUNCTION__);
619: }
620:
621: //group_addr = *(struct in_addr *)(igmp_msg + 4);
622: memcpy(&group_addr, igmp_msg + 4, sizeof(struct in_addr));
623:
624: /* non-existant group is created as INCLUDE {empty} */
625: group = igmp_add_group_by_addr(igmp, group_addr, ifp->name);
626: if (!group) {
627: return -1;
628: }
629:
630: group->last_igmp_v2_report_dsec = pim_time_monotonic_dsec();
631:
632: return 0;
633: }
634:
635: static int igmp_v2_leave(struct igmp_sock *igmp,
636: struct in_addr from, const char *from_str,
637: char *igmp_msg, int igmp_msg_len)
638: {
639: struct interface *ifp = igmp->interface;
640:
641: on_trace(__PRETTY_FUNCTION__, igmp->interface, from);
642:
643: if (igmp_msg_len != IGMP_V12_MSG_SIZE) {
644: zlog_warn("Recv IGMP leave v2 from %s on %s: size=%d other than correct=%d",
645: from_str, ifp->name, igmp_msg_len, IGMP_V12_MSG_SIZE);
646: return -1;
647: }
648:
649: if (PIM_DEBUG_IGMP_TRACE) {
650: zlog_warn("%s %s: FIXME WRITEME",
651: __FILE__, __PRETTY_FUNCTION__);
652: }
653:
654: return 0;
655: }
656:
657: static int igmp_v1_report(struct igmp_sock *igmp,
658: struct in_addr from, const char *from_str,
659: char *igmp_msg, int igmp_msg_len)
660: {
661: struct interface *ifp = igmp->interface;
662: struct igmp_group *group;
663: struct in_addr group_addr;
664:
665: on_trace(__PRETTY_FUNCTION__, igmp->interface, from);
666:
667: if (igmp_msg_len != IGMP_V12_MSG_SIZE) {
668: zlog_warn("Recv IGMP report v1 from %s on %s: size=%d other than correct=%d",
669: from_str, ifp->name, igmp_msg_len, IGMP_V12_MSG_SIZE);
670: return -1;
671: }
672:
673: if (PIM_DEBUG_IGMP_TRACE) {
674: zlog_warn("%s %s: FIXME WRITEME",
675: __FILE__, __PRETTY_FUNCTION__);
676: }
677:
678: //group_addr = *(struct in_addr *)(igmp_msg + 4);
679: memcpy(&group_addr, igmp_msg + 4, sizeof(struct in_addr));
680:
681: /* non-existant group is created as INCLUDE {empty} */
682: group = igmp_add_group_by_addr(igmp, group_addr, ifp->name);
683: if (!group) {
684: return -1;
685: }
686:
687: group->last_igmp_v1_report_dsec = pim_time_monotonic_dsec();
688:
689: return 0;
690: }
691:
692: int pim_igmp_packet(struct igmp_sock *igmp, char *buf, size_t len)
693: {
694: struct ip *ip_hdr;
695: size_t ip_hlen; /* ip header length in bytes */
696: char *igmp_msg;
697: int igmp_msg_len;
698: int msg_type;
699: char from_str[100];
700: char to_str[100];
701:
702: if (len < sizeof(*ip_hdr)) {
703: zlog_warn("IGMP packet size=%zu shorter than minimum=%zu",
704: len, sizeof(*ip_hdr));
705: return -1;
706: }
707:
708: ip_hdr = (struct ip *) buf;
709:
710: pim_inet4_dump("<src?>", ip_hdr->ip_src, from_str , sizeof(from_str));
711: pim_inet4_dump("<dst?>", ip_hdr->ip_dst, to_str , sizeof(to_str));
712:
713: ip_hlen = ip_hdr->ip_hl << 2; /* ip_hl gives length in 4-byte words */
714:
715: if (PIM_DEBUG_IGMP_PACKETS) {
716: zlog_debug("Recv IP packet from %s to %s on %s: size=%zu ip_header_size=%zu ip_proto=%d",
717: from_str, to_str, igmp->interface->name, len, ip_hlen, ip_hdr->ip_p);
718: }
719:
720: if (ip_hdr->ip_p != PIM_IP_PROTO_IGMP) {
721: zlog_warn("IP packet protocol=%d is not IGMP=%d",
722: ip_hdr->ip_p, PIM_IP_PROTO_IGMP);
723: return -1;
724: }
725:
726: if (ip_hlen < PIM_IP_HEADER_MIN_LEN) {
727: zlog_warn("IP packet header size=%zu shorter than minimum=%d",
728: ip_hlen, PIM_IP_HEADER_MIN_LEN);
729: return -1;
730: }
731: if (ip_hlen > PIM_IP_HEADER_MAX_LEN) {
732: zlog_warn("IP packet header size=%zu greater than maximum=%d",
733: ip_hlen, PIM_IP_HEADER_MAX_LEN);
734: return -1;
735: }
736:
737: igmp_msg = buf + ip_hlen;
738: msg_type = *igmp_msg;
739: igmp_msg_len = len - ip_hlen;
740:
741: if (PIM_DEBUG_IGMP_PACKETS) {
742: zlog_debug("Recv IGMP packet from %s to %s on %s: ttl=%d msg_type=%d msg_size=%d",
743: from_str, to_str, igmp->interface->name, ip_hdr->ip_ttl, msg_type,
744: igmp_msg_len);
745: }
746:
747: if (igmp_msg_len < PIM_IGMP_MIN_LEN) {
748: zlog_warn("IGMP message size=%d shorter than minimum=%d",
749: igmp_msg_len, PIM_IGMP_MIN_LEN);
750: return -1;
751: }
752:
753: switch (msg_type) {
754: case PIM_IGMP_MEMBERSHIP_QUERY:
755: {
756: int max_resp_code = igmp_msg[1];
757: int query_version;
758:
759: /*
760: RFC 3376: 7.1. Query Version Distinctions
761: IGMPv1 Query: length = 8 octets AND Max Resp Code field is zero
762: IGMPv2 Query: length = 8 octets AND Max Resp Code field is non-zero
763: IGMPv3 Query: length >= 12 octets
764: */
765:
766: if (igmp_msg_len == 8) {
767: query_version = max_resp_code ? 2 : 1;
768: }
769: else if (igmp_msg_len >= 12) {
770: query_version = 3;
771: }
772: else {
773: zlog_warn("Unknown IGMP query version");
774: return -1;
775: }
776:
777: return recv_igmp_query(igmp, query_version, max_resp_code,
778: ip_hdr->ip_src, from_str,
779: igmp_msg, igmp_msg_len);
780: }
781:
782: case PIM_IGMP_V3_MEMBERSHIP_REPORT:
783: return igmp_v3_report(igmp, ip_hdr->ip_src, from_str,
784: igmp_msg, igmp_msg_len);
785:
786: case PIM_IGMP_V2_MEMBERSHIP_REPORT:
787: return igmp_v2_report(igmp, ip_hdr->ip_src, from_str,
788: igmp_msg, igmp_msg_len);
789:
790: case PIM_IGMP_V1_MEMBERSHIP_REPORT:
791: return igmp_v1_report(igmp, ip_hdr->ip_src, from_str,
792: igmp_msg, igmp_msg_len);
793:
794: case PIM_IGMP_V2_LEAVE_GROUP:
795: return igmp_v2_leave(igmp, ip_hdr->ip_src, from_str,
796: igmp_msg, igmp_msg_len);
797: }
798:
799: zlog_warn("Ignoring unsupported IGMP message type: %d", msg_type);
800:
801: return -1;
802: }
803:
804: static int pim_igmp_general_query(struct thread *t);
805:
806: void pim_igmp_general_query_on(struct igmp_sock *igmp)
807: {
808: struct pim_interface *pim_ifp;
809: int startup_mode;
810: int query_interval;
811:
812: zassert(igmp);
813: zassert(igmp->interface);
814:
815: /*
816: Since this socket is starting as querier,
817: there should not exist a timer for other-querier-present.
818: */
819: zassert(!igmp->t_other_querier_timer);
820: pim_ifp = igmp->interface->info;
821: zassert(pim_ifp);
822:
823: /*
824: RFC 3376: 8.6. Startup Query Interval
825:
826: The Startup Query Interval is the interval between General Queries
827: sent by a Querier on startup. Default: 1/4 the Query Interval.
828: */
829: startup_mode = igmp->startup_query_count > 0;
830: if (startup_mode) {
831: --igmp->startup_query_count;
832:
833: /* query_interval = pim_ifp->igmp_default_query_interval >> 2; */
834: query_interval = PIM_IGMP_SQI(pim_ifp->igmp_default_query_interval);
835: }
836: else {
837: query_interval = igmp->querier_query_interval;
838: }
839:
840: if (PIM_DEBUG_IGMP_TRACE) {
841: char ifaddr_str[100];
842: pim_inet4_dump("<ifaddr?>", igmp->ifaddr, ifaddr_str, sizeof(ifaddr_str));
843: zlog_debug("Querier %s scheduling %d-second (%s) TIMER event for IGMP query on fd=%d",
844: ifaddr_str,
845: query_interval,
846: startup_mode ? "startup" : "non-startup",
847: igmp->fd);
848: }
849: igmp->t_igmp_query_timer = 0;
850: zassert(!igmp->t_igmp_query_timer);
851: THREAD_TIMER_ON(master, igmp->t_igmp_query_timer,
852: pim_igmp_general_query,
853: igmp, query_interval);
854: }
855:
856: void pim_igmp_general_query_off(struct igmp_sock *igmp)
857: {
858: zassert(igmp);
859:
860: if (PIM_DEBUG_IGMP_TRACE) {
861: if (igmp->t_igmp_query_timer) {
862: char ifaddr_str[100];
863: pim_inet4_dump("<ifaddr?>", igmp->ifaddr, ifaddr_str, sizeof(ifaddr_str));
864: zlog_debug("IGMP querier %s fd=%d cancelling query TIMER event on %s",
865: ifaddr_str, igmp->fd, igmp->interface->name);
866: }
867: }
868: THREAD_OFF(igmp->t_igmp_query_timer);
869: zassert(!igmp->t_igmp_query_timer);
870: }
871:
872: /* Issue IGMP general query */
873: static int pim_igmp_general_query(struct thread *t)
874: {
875: char query_buf[PIM_IGMP_BUFSIZE_WRITE];
876: struct igmp_sock *igmp;
877: struct in_addr dst_addr;
878: struct in_addr group_addr;
879: struct pim_interface *pim_ifp;
880:
881: zassert(t);
882:
883: igmp = THREAD_ARG(t);
884:
885: zassert(igmp);
886: zassert(igmp->interface);
887: zassert(igmp->interface->info);
888:
889: pim_ifp = igmp->interface->info;
890:
891: /*
892: RFC3376: 4.1.12. IP Destination Addresses for Queries
893:
894: In IGMPv3, General Queries are sent with an IP destination address
895: of 224.0.0.1, the all-systems multicast address. Group-Specific
896: and Group-and-Source-Specific Queries are sent with an IP
897: destination address equal to the multicast address of interest.
898: */
899:
900: dst_addr.s_addr = htonl(INADDR_ALLHOSTS_GROUP);
901: group_addr.s_addr = PIM_NET_INADDR_ANY;
902:
903: if (PIM_DEBUG_IGMP_TRACE) {
904: char querier_str[100];
905: char dst_str[100];
906: pim_inet4_dump("<querier?>", igmp->ifaddr, querier_str,
907: sizeof(querier_str));
908: pim_inet4_dump("<dst?>", dst_addr, dst_str, sizeof(dst_str));
909: zlog_debug("Querier %s issuing IGMP general query to %s on %s",
910: querier_str, dst_str, igmp->interface->name);
911: }
912:
913: pim_igmp_send_membership_query(0 /* igmp_group */,
914: igmp->fd,
915: igmp->interface->name,
916: query_buf,
917: sizeof(query_buf),
918: 0 /* num_sources */,
919: dst_addr,
920: group_addr,
921: pim_ifp->igmp_query_max_response_time_dsec,
922: 1 /* s_flag: always set for general queries */,
923: igmp->querier_robustness_variable,
924: igmp->querier_query_interval);
925:
926: pim_igmp_general_query_on(igmp);
927:
928: return 0;
929: }
930:
931: static int pim_igmp_read(struct thread *t);
932:
933: static void igmp_read_on(struct igmp_sock *igmp)
934: {
935: zassert(igmp);
936:
937: if (PIM_DEBUG_IGMP_TRACE) {
938: zlog_debug("Scheduling READ event on IGMP socket fd=%d",
939: igmp->fd);
940: }
941: igmp->t_igmp_read = 0;
942: zassert(!igmp->t_igmp_read);
943: THREAD_READ_ON(master, igmp->t_igmp_read, pim_igmp_read, igmp, igmp->fd);
944: }
945:
946: static int pim_igmp_read(struct thread *t)
947: {
948: struct igmp_sock *igmp;
949: int fd;
950: struct sockaddr_in from;
951: struct sockaddr_in to;
952: socklen_t fromlen = sizeof(from);
953: socklen_t tolen = sizeof(to);
954: uint8_t buf[PIM_IGMP_BUFSIZE_READ];
955: int len;
956: ifindex_t ifindex = -1;
957: int result = -1; /* defaults to bad */
958:
959: zassert(t);
960:
961: igmp = THREAD_ARG(t);
962:
963: zassert(igmp);
964:
965: fd = THREAD_FD(t);
966:
967: zassert(fd == igmp->fd);
968:
969: len = pim_socket_recvfromto(fd, buf, sizeof(buf),
970: &from, &fromlen,
971: &to, &tolen,
972: &ifindex);
973: if (len < 0) {
974: zlog_warn("Failure receiving IP IGMP packet on fd=%d: errno=%d: %s",
975: fd, errno, safe_strerror(errno));
976: goto done;
977: }
978:
979: if (PIM_DEBUG_IGMP_PACKETS) {
980: char from_str[100];
981: char to_str[100];
982:
983: if (!inet_ntop(AF_INET, &from.sin_addr, from_str, sizeof(from_str)))
984: sprintf(from_str, "<from?>");
985: if (!inet_ntop(AF_INET, &to.sin_addr, to_str, sizeof(to_str)))
986: sprintf(to_str, "<to?>");
987:
988: zlog_debug("Recv IP IGMP pkt size=%d from %s to %s on fd=%d on ifindex=%d (sock_ifindex=%d)",
989: len, from_str, to_str, fd, ifindex, igmp->interface->ifindex);
990: }
991:
992: #ifdef PIM_CHECK_RECV_IFINDEX_SANITY
993: /* ifindex sanity check */
994: if (ifindex != (int) igmp->interface->ifindex) {
995: char from_str[100];
996: char to_str[100];
997: struct interface *ifp;
998:
999: if (!inet_ntop(AF_INET, &from.sin_addr, from_str , sizeof(from_str)))
1000: sprintf(from_str, "<from?>");
1001: if (!inet_ntop(AF_INET, &to.sin_addr, to_str , sizeof(to_str)))
1002: sprintf(to_str, "<to?>");
1003:
1004: ifp = if_lookup_by_index(ifindex);
1005: if (ifp) {
1006: zassert(ifindex == (int) ifp->ifindex);
1007: }
1008:
1009: #ifdef PIM_REPORT_RECV_IFINDEX_MISMATCH
1010: zlog_warn("Interface mismatch: recv IGMP pkt from %s to %s on fd=%d: recv_ifindex=%d (%s) sock_ifindex=%d (%s)",
1011: from_str, to_str, fd,
1012: ifindex, ifp ? ifp->name : "<if-notfound>",
1013: igmp->interface->ifindex, igmp->interface->name);
1014: #endif
1015: goto done;
1016: }
1017: #endif
1018:
1019: if (pim_igmp_packet(igmp, (char *)buf, len)) {
1020: goto done;
1021: }
1022:
1023: result = 0; /* good */
1024:
1025: done:
1026: igmp_read_on(igmp);
1027:
1028: return result;
1029: }
1030:
1031: static void sock_close(struct igmp_sock *igmp)
1032: {
1033: pim_igmp_other_querier_timer_off(igmp);
1034: pim_igmp_general_query_off(igmp);
1035:
1036: if (PIM_DEBUG_IGMP_TRACE) {
1037: if (igmp->t_igmp_read) {
1038: zlog_debug("Cancelling READ event on IGMP socket %s fd=%d on interface %s",
1039: inet_ntoa(igmp->ifaddr), igmp->fd,
1040: igmp->interface->name);
1041: }
1042: }
1043: THREAD_OFF(igmp->t_igmp_read);
1044: zassert(!igmp->t_igmp_read);
1045:
1046: if (close(igmp->fd)) {
1047: zlog_err("Failure closing IGMP socket %s fd=%d on interface %s: errno=%d: %s",
1048: inet_ntoa(igmp->ifaddr), igmp->fd, igmp->interface->name,
1049: errno, safe_strerror(errno));
1050: }
1051:
1052: if (PIM_DEBUG_IGMP_TRACE) {
1053: zlog_debug("Deleted IGMP socket %s fd=%d on interface %s",
1054: inet_ntoa(igmp->ifaddr), igmp->fd, igmp->interface->name);
1055: }
1056: }
1057:
1058: void igmp_startup_mode_on(struct igmp_sock *igmp)
1059: {
1060: struct pim_interface *pim_ifp;
1061:
1062: pim_ifp = igmp->interface->info;
1063:
1064: /*
1065: RFC 3376: 8.7. Startup Query Count
1066:
1067: The Startup Query Count is the number of Queries sent out on
1068: startup, separated by the Startup Query Interval. Default: the
1069: Robustness Variable.
1070: */
1071: igmp->startup_query_count = igmp->querier_robustness_variable;
1072:
1073: /*
1074: Since we're (re)starting, reset QQI to default Query Interval
1075: */
1076: igmp->querier_query_interval = pim_ifp->igmp_default_query_interval;
1077: }
1078:
1079: static void igmp_group_free(struct igmp_group *group)
1080: {
1081: zassert(!group->t_group_query_retransmit_timer);
1082: zassert(!group->t_group_timer);
1083: zassert(group->group_source_list);
1084: zassert(!listcount(group->group_source_list));
1085:
1086: list_free(group->group_source_list);
1087:
1088: XFREE(MTYPE_PIM_IGMP_GROUP, group);
1089: }
1090:
1091: static void igmp_group_delete(struct igmp_group *group)
1092: {
1093: struct listnode *src_node;
1094: struct listnode *src_nextnode;
1095: struct igmp_source *src;
1096:
1097: if (PIM_DEBUG_IGMP_TRACE) {
1098: char group_str[100];
1099: pim_inet4_dump("<group?>", group->group_addr, group_str, sizeof(group_str));
1100: zlog_debug("Deleting IGMP group %s from socket %d interface %s",
1101: group_str,
1102: group->group_igmp_sock->fd,
1103: group->group_igmp_sock->interface->name);
1104: }
1105:
1106: for (ALL_LIST_ELEMENTS(group->group_source_list, src_node, src_nextnode, src)) {
1107: igmp_source_delete(src);
1108: }
1109:
1110: if (group->t_group_query_retransmit_timer) {
1111: THREAD_OFF(group->t_group_query_retransmit_timer);
1112: zassert(!group->t_group_query_retransmit_timer);
1113: }
1114:
1115: group_timer_off(group);
1116: listnode_delete(group->group_igmp_sock->igmp_group_list, group);
1117: igmp_group_free(group);
1118: }
1119:
1120: void igmp_group_delete_empty_include(struct igmp_group *group)
1121: {
1122: zassert(!group->group_filtermode_isexcl);
1123: zassert(!listcount(group->group_source_list));
1124:
1125: igmp_group_delete(group);
1126: }
1127:
1128: void igmp_sock_free(struct igmp_sock *igmp)
1129: {
1130: zassert(!igmp->t_igmp_read);
1131: zassert(!igmp->t_igmp_query_timer);
1132: zassert(!igmp->t_other_querier_timer);
1133: zassert(igmp->igmp_group_list);
1134: zassert(!listcount(igmp->igmp_group_list));
1135:
1136: list_free(igmp->igmp_group_list);
1137:
1138: XFREE(MTYPE_PIM_IGMP_SOCKET, igmp);
1139: }
1140:
1141: void igmp_sock_delete(struct igmp_sock *igmp)
1142: {
1143: struct pim_interface *pim_ifp;
1144: struct listnode *grp_node;
1145: struct listnode *grp_nextnode;
1146: struct igmp_group *grp;
1147:
1148: for (ALL_LIST_ELEMENTS(igmp->igmp_group_list, grp_node, grp_nextnode, grp)) {
1149: igmp_group_delete(grp);
1150: }
1151:
1152: sock_close(igmp);
1153:
1154: pim_ifp = igmp->interface->info;
1155:
1156: listnode_delete(pim_ifp->igmp_socket_list, igmp);
1157:
1158: igmp_sock_free(igmp);
1159: }
1160:
1161: static struct igmp_sock *igmp_sock_new(int fd,
1162: struct in_addr ifaddr,
1163: struct interface *ifp)
1164: {
1165: struct pim_interface *pim_ifp;
1166: struct igmp_sock *igmp;
1167:
1168: pim_ifp = ifp->info;
1169:
1170: if (PIM_DEBUG_IGMP_TRACE) {
1171: zlog_debug("Creating IGMP socket fd=%d for address %s on interface %s",
1172: fd, inet_ntoa(ifaddr), ifp->name);
1173: }
1174:
1175: igmp = XMALLOC(MTYPE_PIM_IGMP_SOCKET, sizeof(*igmp));
1176: if (!igmp) {
1177: zlog_warn("%s %s: XMALLOC() failure",
1178: __FILE__, __PRETTY_FUNCTION__);
1179: return 0;
1180: }
1181:
1182: igmp->igmp_group_list = list_new();
1183: if (!igmp->igmp_group_list) {
1184: zlog_err("%s %s: failure: igmp_group_list = list_new()",
1185: __FILE__, __PRETTY_FUNCTION__);
1186: return 0;
1187: }
1188: igmp->igmp_group_list->del = (void (*)(void *)) igmp_group_free;
1189:
1190: igmp->fd = fd;
1191: igmp->interface = ifp;
1192: igmp->ifaddr = ifaddr;
1193: igmp->t_igmp_read = 0;
1194: igmp->t_igmp_query_timer = 0;
1195: igmp->t_other_querier_timer = 0; /* no other querier present */
1196: igmp->querier_robustness_variable = pim_ifp->igmp_default_robustness_variable;
1197: igmp->sock_creation = pim_time_monotonic_sec();
1198:
1199: /*
1200: igmp_startup_mode_on() will reset QQI:
1201:
1202: igmp->querier_query_interval = pim_ifp->igmp_default_query_interval;
1203: */
1204: igmp_startup_mode_on(igmp);
1205:
1206: igmp_read_on(igmp);
1207: pim_igmp_general_query_on(igmp);
1208:
1209: return igmp;
1210: }
1211:
1212: struct igmp_sock *pim_igmp_sock_add(struct list *igmp_sock_list,
1213: struct in_addr ifaddr,
1214: struct interface *ifp)
1215: {
1216: struct pim_interface *pim_ifp;
1217: struct igmp_sock *igmp;
1218: int fd;
1219:
1220: pim_ifp = ifp->info;
1221:
1222: fd = igmp_sock_open(ifaddr, ifp->ifindex, pim_ifp->options);
1223: if (fd < 0) {
1224: zlog_warn("Could not open IGMP socket for %s on %s",
1225: inet_ntoa(ifaddr), ifp->name);
1226: return 0;
1227: }
1228:
1229: igmp = igmp_sock_new(fd, ifaddr, ifp);
1230: if (!igmp) {
1231: zlog_err("%s %s: igmp_sock_new() failure",
1232: __FILE__, __PRETTY_FUNCTION__);
1233: close(fd);
1234: return 0;
1235: }
1236:
1237: listnode_add(igmp_sock_list, igmp);
1238:
1239: #ifdef IGMP_SOCK_DUMP
1240: igmp_sock_dump(igmp_sock_array);
1241: #endif
1242:
1243: return igmp;
1244: }
1245:
1246: /*
1247: RFC 3376: 6.5. Switching Router Filter-Modes
1248:
1249: When a router's filter-mode for a group is EXCLUDE and the group
1250: timer expires, the router filter-mode for the group transitions to
1251: INCLUDE.
1252:
1253: A router uses source records with running source timers as its state
1254: for the switch to a filter-mode of INCLUDE. If there are any source
1255: records with source timers greater than zero (i.e., requested to be
1256: forwarded), a router switches to filter-mode of INCLUDE using those
1257: source records. Source records whose timers are zero (from the
1258: previous EXCLUDE mode) are deleted.
1259: */
1260: static int igmp_group_timer(struct thread *t)
1261: {
1262: struct igmp_group *group;
1263:
1264: zassert(t);
1265: group = THREAD_ARG(t);
1266: zassert(group);
1267:
1268: if (PIM_DEBUG_IGMP_TRACE) {
1269: char group_str[100];
1270: pim_inet4_dump("<group?>", group->group_addr, group_str, sizeof(group_str));
1271: zlog_debug("%s: Timer for group %s on interface %s",
1272: __PRETTY_FUNCTION__,
1273: group_str, group->group_igmp_sock->interface->name);
1274: }
1275:
1276: zassert(group->group_filtermode_isexcl);
1277:
1278: group->t_group_timer = 0;
1279: group->group_filtermode_isexcl = 0;
1280:
1281: /* Any source (*,G) is forwarded only if mode is EXCLUDE {empty} */
1282: igmp_anysource_forward_stop(group);
1283:
1284: igmp_source_delete_expired(group->group_source_list);
1285:
1286: zassert(!group->t_group_timer);
1287: zassert(!group->group_filtermode_isexcl);
1288:
1289: /*
1290: RFC 3376: 6.2.2. Definition of Group Timers
1291:
1292: If there are no more source records for the group, delete group
1293: record.
1294: */
1295: if (listcount(group->group_source_list) < 1) {
1296: igmp_group_delete_empty_include(group);
1297: }
1298:
1299: return 0;
1300: }
1301:
1302: static void group_timer_off(struct igmp_group *group)
1303: {
1304: if (!group->t_group_timer)
1305: return;
1306:
1307: if (PIM_DEBUG_IGMP_TRACE) {
1308: char group_str[100];
1309: pim_inet4_dump("<group?>", group->group_addr, group_str, sizeof(group_str));
1310: zlog_debug("Cancelling TIMER event for group %s on %s",
1311: group_str, group->group_igmp_sock->interface->name);
1312: }
1313:
1314: THREAD_OFF(group->t_group_timer);
1315: zassert(!group->t_group_timer);
1316: }
1317:
1318: void igmp_group_timer_on(struct igmp_group *group,
1319: long interval_msec, const char *ifname)
1320: {
1321: group_timer_off(group);
1322:
1323: if (PIM_DEBUG_IGMP_EVENTS) {
1324: char group_str[100];
1325: pim_inet4_dump("<group?>", group->group_addr, group_str, sizeof(group_str));
1326: zlog_debug("Scheduling %ld.%03ld sec TIMER event for group %s on %s",
1327: interval_msec / 1000,
1328: interval_msec % 1000,
1329: group_str, ifname);
1330: }
1331:
1332: /*
1333: RFC 3376: 6.2.2. Definition of Group Timers
1334:
1335: The group timer is only used when a group is in EXCLUDE mode and
1336: it represents the time for the *filter-mode* of the group to
1337: expire and switch to INCLUDE mode.
1338: */
1339: zassert(group->group_filtermode_isexcl);
1340:
1341: THREAD_TIMER_MSEC_ON(master, group->t_group_timer,
1342: igmp_group_timer,
1343: group, interval_msec);
1344: }
1345:
1346: static struct igmp_group *find_group_by_addr(struct igmp_sock *igmp,
1347: struct in_addr group_addr)
1348: {
1349: struct igmp_group *group;
1350: struct listnode *node;
1351:
1352: for (ALL_LIST_ELEMENTS_RO(igmp->igmp_group_list, node, group))
1353: if (group_addr.s_addr == group->group_addr.s_addr)
1354: return group;
1355:
1356: return 0;
1357: }
1358:
1359: struct igmp_group *igmp_add_group_by_addr(struct igmp_sock *igmp,
1360: struct in_addr group_addr,
1361: const char *ifname)
1362: {
1363: struct igmp_group *group;
1364:
1365: group = find_group_by_addr(igmp, group_addr);
1366: if (group) {
1367: return group;
1368: }
1369:
1370: /*
1371: Non-existant group is created as INCLUDE {empty}:
1372:
1373: RFC 3376 - 5.1. Action on Change of Interface State
1374:
1375: If no interface state existed for that multicast address before
1376: the change (i.e., the change consisted of creating a new
1377: per-interface record), or if no state exists after the change
1378: (i.e., the change consisted of deleting a per-interface record),
1379: then the "non-existent" state is considered to have a filter mode
1380: of INCLUDE and an empty source list.
1381: */
1382:
1383: group = XMALLOC(MTYPE_PIM_IGMP_GROUP, sizeof(*group));
1384: if (!group) {
1385: zlog_warn("%s %s: XMALLOC() failure",
1386: __FILE__, __PRETTY_FUNCTION__);
1387: return 0; /* error, not found, could not create */
1388: }
1389:
1390: group->group_source_list = list_new();
1391: if (!group->group_source_list) {
1392: zlog_warn("%s %s: list_new() failure",
1393: __FILE__, __PRETTY_FUNCTION__);
1394: XFREE(MTYPE_PIM_IGMP_GROUP, group); /* discard group */
1395: return 0; /* error, not found, could not initialize */
1396: }
1397: group->group_source_list->del = (void (*)(void *)) igmp_source_free;
1398:
1399: group->t_group_timer = 0;
1400: group->t_group_query_retransmit_timer = 0;
1401: group->group_specific_query_retransmit_count = 0;
1402: group->group_addr = group_addr;
1403: group->group_igmp_sock = igmp;
1404: group->last_igmp_v1_report_dsec = -1;
1405: group->last_igmp_v2_report_dsec = -1;
1406: group->group_creation = pim_time_monotonic_sec();
1407:
1408: /* initialize new group as INCLUDE {empty} */
1409: group->group_filtermode_isexcl = 0; /* 0=INCLUDE, 1=EXCLUDE */
1410:
1411: listnode_add(igmp->igmp_group_list, group);
1412:
1413: if (PIM_DEBUG_IGMP_TRACE) {
1414: char group_str[100];
1415: pim_inet4_dump("<group?>", group->group_addr, group_str, sizeof(group_str));
1416: zlog_debug("Creating new IGMP group %s on socket %d interface %s",
1417: group_str, group->group_igmp_sock->fd, ifname);
1418: }
1419:
1420: /*
1421: RFC 3376: 6.2.2. Definition of Group Timers
1422:
1423: The group timer is only used when a group is in EXCLUDE mode and
1424: it represents the time for the *filter-mode* of the group to
1425: expire and switch to INCLUDE mode.
1426: */
1427: zassert(!group->group_filtermode_isexcl); /* INCLUDE mode */
1428: zassert(!group->t_group_timer); /* group timer == 0 */
1429:
1430: /* Any source (*,G) is forwarded only if mode is EXCLUDE {empty} */
1431: igmp_anysource_forward_stop(group);
1432:
1433: return group;
1434: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to pim_igmp.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / pimd