Annotation of embedaddon/quagga/pimd/pim_igmpv3.c, revision 1.1
1.1 ! misho 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: #include "log.h"
! 25: #include "memory.h"
! 26:
! 27: #include "pimd.h"
! 28: #include "pim_iface.h"
! 29: #include "pim_igmp.h"
! 30: #include "pim_igmpv3.h"
! 31: #include "pim_str.h"
! 32: #include "pim_util.h"
! 33: #include "pim_time.h"
! 34: #include "pim_zebra.h"
! 35: #include "pim_oil.h"
! 36:
! 37: static void group_retransmit_timer_on(struct igmp_group *group);
! 38: static long igmp_group_timer_remain_msec(struct igmp_group *group);
! 39: static long igmp_source_timer_remain_msec(struct igmp_source *source);
! 40: static void group_query_send(struct igmp_group *group);
! 41: static void source_query_send_by_flag(struct igmp_group *group,
! 42: int num_sources_tosend);
! 43:
! 44: static void on_trace(const char *label,
! 45: struct interface *ifp, struct in_addr from,
! 46: struct in_addr group_addr,
! 47: int num_sources, struct in_addr *sources)
! 48: {
! 49: if (PIM_DEBUG_IGMP_TRACE) {
! 50: char from_str[100];
! 51: char group_str[100];
! 52:
! 53: pim_inet4_dump("<from?>", from, from_str, sizeof(from_str));
! 54: pim_inet4_dump("<group?>", group_addr, group_str, sizeof(group_str));
! 55:
! 56: zlog_debug("%s: from %s on %s: group=%s sources=%d",
! 57: label, from_str, ifp->name, group_str, num_sources);
! 58: }
! 59: }
! 60:
! 61: int igmp_group_compat_mode(const struct igmp_sock *igmp,
! 62: const struct igmp_group *group)
! 63: {
! 64: struct pim_interface *pim_ifp;
! 65: int64_t now_dsec;
! 66: long older_host_present_interval_dsec;
! 67:
! 68: zassert(igmp);
! 69: zassert(igmp->interface);
! 70: zassert(igmp->interface->info);
! 71:
! 72: pim_ifp = igmp->interface->info;
! 73:
! 74: /*
! 75: RFC 3376: 8.13. Older Host Present Interval
! 76:
! 77: This value MUST be ((the Robustness Variable) times (the Query
! 78: Interval)) plus (one Query Response Interval).
! 79:
! 80: older_host_present_interval_dsec = \
! 81: igmp->querier_robustness_variable * \
! 82: 10 * igmp->querier_query_interval + \
! 83: pim_ifp->query_max_response_time_dsec;
! 84: */
! 85: older_host_present_interval_dsec =
! 86: PIM_IGMP_OHPI_DSEC(igmp->querier_robustness_variable,
! 87: igmp->querier_query_interval,
! 88: pim_ifp->igmp_query_max_response_time_dsec);
! 89:
! 90: now_dsec = pim_time_monotonic_dsec();
! 91: if (now_dsec < 1) {
! 92: /* broken timer logged by pim_time_monotonic_dsec() */
! 93: return 3;
! 94: }
! 95:
! 96: if ((now_dsec - group->last_igmp_v1_report_dsec) < older_host_present_interval_dsec)
! 97: return 1; /* IGMPv1 */
! 98:
! 99: if ((now_dsec - group->last_igmp_v2_report_dsec) < older_host_present_interval_dsec)
! 100: return 2; /* IGMPv2 */
! 101:
! 102: return 3; /* IGMPv3 */
! 103: }
! 104:
! 105: void igmp_group_reset_gmi(struct igmp_group *group)
! 106: {
! 107: long group_membership_interval_msec;
! 108: struct pim_interface *pim_ifp;
! 109: struct igmp_sock *igmp;
! 110: struct interface *ifp;
! 111:
! 112: igmp = group->group_igmp_sock;
! 113: ifp = igmp->interface;
! 114: pim_ifp = ifp->info;
! 115:
! 116: /*
! 117: RFC 3376: 8.4. Group Membership Interval
! 118:
! 119: The Group Membership Interval is the amount of time that must pass
! 120: before a multicast router decides there are no more members of a
! 121: group or a particular source on a network.
! 122:
! 123: This value MUST be ((the Robustness Variable) times (the Query
! 124: Interval)) plus (one Query Response Interval).
! 125:
! 126: group_membership_interval_msec = querier_robustness_variable *
! 127: (1000 * querier_query_interval) +
! 128: 100 * query_response_interval_dsec;
! 129: */
! 130: group_membership_interval_msec =
! 131: PIM_IGMP_GMI_MSEC(igmp->querier_robustness_variable,
! 132: igmp->querier_query_interval,
! 133: pim_ifp->igmp_query_max_response_time_dsec);
! 134:
! 135: if (PIM_DEBUG_IGMP_TRACE) {
! 136: char group_str[100];
! 137: pim_inet4_dump("<group?>", group->group_addr, group_str, sizeof(group_str));
! 138: zlog_debug("Resetting group %s timer to GMI=%ld.%03ld sec on %s",
! 139: group_str,
! 140: group_membership_interval_msec / 1000,
! 141: group_membership_interval_msec % 1000,
! 142: ifp->name);
! 143: }
! 144:
! 145: /*
! 146: RFC 3376: 6.2.2. Definition of Group Timers
! 147:
! 148: The group timer is only used when a group is in EXCLUDE mode and
! 149: it represents the time for the *filter-mode* of the group to
! 150: expire and switch to INCLUDE mode.
! 151: */
! 152: zassert(group->group_filtermode_isexcl);
! 153:
! 154: igmp_group_timer_on(group, group_membership_interval_msec, ifp->name);
! 155: }
! 156:
! 157: static int igmp_source_timer(struct thread *t)
! 158: {
! 159: struct igmp_source *source;
! 160: struct igmp_group *group;
! 161:
! 162: zassert(t);
! 163: source = THREAD_ARG(t);
! 164: zassert(source);
! 165:
! 166: group = source->source_group;
! 167:
! 168: if (PIM_DEBUG_IGMP_TRACE) {
! 169: char group_str[100];
! 170: char source_str[100];
! 171: pim_inet4_dump("<group?>", group->group_addr, group_str, sizeof(group_str));
! 172: pim_inet4_dump("<source?>", source->source_addr, source_str, sizeof(source_str));
! 173: zlog_debug("%s: Source timer expired for group %s source %s on %s",
! 174: __PRETTY_FUNCTION__,
! 175: group_str, source_str,
! 176: group->group_igmp_sock->interface->name);
! 177: }
! 178:
! 179: zassert(source->t_source_timer);
! 180: source->t_source_timer = 0;
! 181:
! 182: /*
! 183: RFC 3376: 6.3. IGMPv3 Source-Specific Forwarding Rules
! 184:
! 185: Group
! 186: Filter-Mode Source Timer Value Action
! 187: ----------- ------------------ ------
! 188: INCLUDE TIMER == 0 Suggest to stop forwarding
! 189: traffic from source and
! 190: remove source record. If
! 191: there are no more source
! 192: records for the group, delete
! 193: group record.
! 194:
! 195: EXCLUDE TIMER == 0 Suggest to not forward
! 196: traffic from source
! 197: (DO NOT remove record)
! 198:
! 199: Source timer switched from (T > 0) to (T == 0): disable forwarding.
! 200: */
! 201:
! 202: zassert(!source->t_source_timer);
! 203:
! 204: if (group->group_filtermode_isexcl) {
! 205: /* EXCLUDE mode */
! 206:
! 207: igmp_source_forward_stop(source);
! 208: }
! 209: else {
! 210: /* INCLUDE mode */
! 211:
! 212: /* igmp_source_delete() will stop forwarding source */
! 213: igmp_source_delete(source);
! 214:
! 215: /*
! 216: If there are no more source records for the group, delete group
! 217: record.
! 218: */
! 219: if (!listcount(group->group_source_list)) {
! 220: igmp_group_delete_empty_include(group);
! 221: }
! 222: }
! 223:
! 224: return 0;
! 225: }
! 226:
! 227: static void source_timer_off(struct igmp_group *group,
! 228: struct igmp_source *source)
! 229: {
! 230: if (!source->t_source_timer)
! 231: return;
! 232:
! 233: if (PIM_DEBUG_IGMP_TRACE) {
! 234: char group_str[100];
! 235: char source_str[100];
! 236: pim_inet4_dump("<group?>", group->group_addr, group_str, sizeof(group_str));
! 237: pim_inet4_dump("<source?>", source->source_addr, source_str, sizeof(source_str));
! 238: zlog_debug("Cancelling TIMER event for group %s source %s on %s",
! 239: group_str, source_str,
! 240: group->group_igmp_sock->interface->name);
! 241: }
! 242:
! 243: THREAD_OFF(source->t_source_timer);
! 244: zassert(!source->t_source_timer);
! 245: }
! 246:
! 247: static void igmp_source_timer_on(struct igmp_group *group,
! 248: struct igmp_source *source,
! 249: long interval_msec)
! 250: {
! 251: source_timer_off(group, source);
! 252:
! 253: if (PIM_DEBUG_IGMP_EVENTS) {
! 254: char group_str[100];
! 255: char source_str[100];
! 256: pim_inet4_dump("<group?>", group->group_addr, group_str, sizeof(group_str));
! 257: pim_inet4_dump("<source?>", source->source_addr, source_str, sizeof(source_str));
! 258: zlog_debug("Scheduling %ld.%03ld sec TIMER event for group %s source %s on %s",
! 259: interval_msec / 1000,
! 260: interval_msec % 1000,
! 261: group_str, source_str,
! 262: group->group_igmp_sock->interface->name);
! 263: }
! 264:
! 265: THREAD_TIMER_MSEC_ON(master, source->t_source_timer,
! 266: igmp_source_timer,
! 267: source, interval_msec);
! 268: zassert(source->t_source_timer);
! 269:
! 270: /*
! 271: RFC 3376: 6.3. IGMPv3 Source-Specific Forwarding Rules
! 272:
! 273: Source timer switched from (T == 0) to (T > 0): enable forwarding.
! 274: */
! 275: igmp_source_forward_start(source);
! 276: }
! 277:
! 278: void igmp_source_reset_gmi(struct igmp_sock *igmp,
! 279: struct igmp_group *group,
! 280: struct igmp_source *source)
! 281: {
! 282: long group_membership_interval_msec;
! 283: struct pim_interface *pim_ifp;
! 284: struct interface *ifp;
! 285:
! 286: ifp = igmp->interface;
! 287: pim_ifp = ifp->info;
! 288:
! 289: group_membership_interval_msec =
! 290: PIM_IGMP_GMI_MSEC(igmp->querier_robustness_variable,
! 291: igmp->querier_query_interval,
! 292: pim_ifp->igmp_query_max_response_time_dsec);
! 293:
! 294: if (PIM_DEBUG_IGMP_TRACE) {
! 295: char group_str[100];
! 296: char source_str[100];
! 297:
! 298: pim_inet4_dump("<group?>", group->group_addr, group_str, sizeof(group_str));
! 299: pim_inet4_dump("<source?>", source->source_addr, source_str, sizeof(source_str));
! 300:
! 301: zlog_debug("Resetting source %s timer to GMI=%ld.%03ld sec for group %s on %s",
! 302: source_str,
! 303: group_membership_interval_msec / 1000,
! 304: group_membership_interval_msec % 1000,
! 305: group_str,
! 306: ifp->name);
! 307: }
! 308:
! 309: igmp_source_timer_on(group, source,
! 310: group_membership_interval_msec);
! 311: }
! 312:
! 313: static void source_mark_delete_flag(struct list *source_list)
! 314: {
! 315: struct listnode *src_node;
! 316: struct igmp_source *src;
! 317:
! 318: for (ALL_LIST_ELEMENTS_RO(source_list, src_node, src)) {
! 319: IGMP_SOURCE_DO_DELETE(src->source_flags);
! 320: }
! 321: }
! 322:
! 323: static void source_mark_send_flag(struct list *source_list)
! 324: {
! 325: struct listnode *src_node;
! 326: struct igmp_source *src;
! 327:
! 328: for (ALL_LIST_ELEMENTS_RO(source_list, src_node, src)) {
! 329: IGMP_SOURCE_DO_SEND(src->source_flags);
! 330: }
! 331: }
! 332:
! 333: static int source_mark_send_flag_by_timer(struct list *source_list)
! 334: {
! 335: struct listnode *src_node;
! 336: struct igmp_source *src;
! 337: int num_marked_sources = 0;
! 338:
! 339: for (ALL_LIST_ELEMENTS_RO(source_list, src_node, src)) {
! 340: /* Is source timer running? */
! 341: if (src->t_source_timer) {
! 342: IGMP_SOURCE_DO_SEND(src->source_flags);
! 343: ++num_marked_sources;
! 344: }
! 345: else {
! 346: IGMP_SOURCE_DONT_SEND(src->source_flags);
! 347: }
! 348: }
! 349:
! 350: return num_marked_sources;
! 351: }
! 352:
! 353: static void source_clear_send_flag(struct list *source_list)
! 354: {
! 355: struct listnode *src_node;
! 356: struct igmp_source *src;
! 357:
! 358: for (ALL_LIST_ELEMENTS_RO(source_list, src_node, src)) {
! 359: IGMP_SOURCE_DONT_SEND(src->source_flags);
! 360: }
! 361: }
! 362:
! 363: /*
! 364: Any source (*,G) is forwarded only if mode is EXCLUDE {empty}
! 365: */
! 366: static void group_exclude_fwd_anysrc_ifempty(struct igmp_group *group)
! 367: {
! 368: zassert(group->group_filtermode_isexcl);
! 369:
! 370: if (listcount(group->group_source_list) < 1) {
! 371: igmp_anysource_forward_start(group);
! 372: }
! 373: }
! 374:
! 375: void igmp_source_free(struct igmp_source *source)
! 376: {
! 377: /* make sure there is no source timer running */
! 378: zassert(!source->t_source_timer);
! 379:
! 380: XFREE(MTYPE_PIM_IGMP_GROUP_SOURCE, source);
! 381: }
! 382:
! 383: static void source_channel_oil_detach(struct igmp_source *source)
! 384: {
! 385: if (source->source_channel_oil) {
! 386: pim_channel_oil_del(source->source_channel_oil);
! 387: source->source_channel_oil = 0;
! 388: }
! 389: }
! 390:
! 391: /*
! 392: igmp_source_delete: stop fowarding, and delete the source
! 393: igmp_source_forward_stop: stop fowarding, but keep the source
! 394: */
! 395: void igmp_source_delete(struct igmp_source *source)
! 396: {
! 397: struct igmp_group *group;
! 398:
! 399: group = source->source_group;
! 400:
! 401: if (PIM_DEBUG_IGMP_TRACE) {
! 402: char group_str[100];
! 403: char source_str[100];
! 404: pim_inet4_dump("<group?>", group->group_addr, group_str, sizeof(group_str));
! 405: pim_inet4_dump("<source?>", source->source_addr, source_str, sizeof(source_str));
! 406: zlog_debug("Deleting IGMP source %s for group %s from socket %d interface %s",
! 407: source_str, group_str,
! 408: group->group_igmp_sock->fd,
! 409: group->group_igmp_sock->interface->name);
! 410: }
! 411:
! 412: source_timer_off(group, source);
! 413: igmp_source_forward_stop(source);
! 414:
! 415: /* sanity check that forwarding has been disabled */
! 416: if (IGMP_SOURCE_TEST_FORWARDING(source->source_flags)) {
! 417: char group_str[100];
! 418: char source_str[100];
! 419: pim_inet4_dump("<group?>", group->group_addr, group_str, sizeof(group_str));
! 420: pim_inet4_dump("<source?>", source->source_addr, source_str, sizeof(source_str));
! 421: zlog_warn("%s: forwarding=ON(!) IGMP source %s for group %s from socket %d interface %s",
! 422: __PRETTY_FUNCTION__,
! 423: source_str, group_str,
! 424: group->group_igmp_sock->fd,
! 425: group->group_igmp_sock->interface->name);
! 426: /* warning only */
! 427: }
! 428:
! 429: source_channel_oil_detach(source);
! 430:
! 431: /*
! 432: notice that listnode_delete() can't be moved
! 433: into igmp_source_free() because the later is
! 434: called by list_delete_all_node()
! 435: */
! 436: listnode_delete(group->group_source_list, source);
! 437:
! 438: igmp_source_free(source);
! 439:
! 440: if (group->group_filtermode_isexcl) {
! 441: group_exclude_fwd_anysrc_ifempty(group);
! 442: }
! 443: }
! 444:
! 445: static void source_delete_by_flag(struct list *source_list)
! 446: {
! 447: struct listnode *src_node;
! 448: struct listnode *src_nextnode;
! 449: struct igmp_source *src;
! 450:
! 451: for (ALL_LIST_ELEMENTS(source_list, src_node, src_nextnode, src))
! 452: if (IGMP_SOURCE_TEST_DELETE(src->source_flags))
! 453: igmp_source_delete(src);
! 454: }
! 455:
! 456: void igmp_source_delete_expired(struct list *source_list)
! 457: {
! 458: struct listnode *src_node;
! 459: struct listnode *src_nextnode;
! 460: struct igmp_source *src;
! 461:
! 462: for (ALL_LIST_ELEMENTS(source_list, src_node, src_nextnode, src))
! 463: if (!src->t_source_timer)
! 464: igmp_source_delete(src);
! 465: }
! 466:
! 467: struct igmp_source *igmp_find_source_by_addr(struct igmp_group *group,
! 468: struct in_addr src_addr)
! 469: {
! 470: struct listnode *src_node;
! 471: struct igmp_source *src;
! 472:
! 473: for (ALL_LIST_ELEMENTS_RO(group->group_source_list, src_node, src))
! 474: if (src_addr.s_addr == src->source_addr.s_addr)
! 475: return src;
! 476:
! 477: return 0;
! 478: }
! 479:
! 480: static struct igmp_source *source_new(struct igmp_group *group,
! 481: struct in_addr src_addr,
! 482: const char *ifname)
! 483: {
! 484: struct igmp_source *src;
! 485:
! 486: if (PIM_DEBUG_IGMP_TRACE) {
! 487: char group_str[100];
! 488: char source_str[100];
! 489: pim_inet4_dump("<group?>", group->group_addr, group_str, sizeof(group_str));
! 490: pim_inet4_dump("<source?>", src_addr, source_str, sizeof(source_str));
! 491: zlog_debug("Creating new IGMP source %s for group %s on socket %d interface %s",
! 492: source_str, group_str,
! 493: group->group_igmp_sock->fd,
! 494: ifname);
! 495: }
! 496:
! 497: src = XMALLOC(MTYPE_PIM_IGMP_GROUP_SOURCE, sizeof(*src));
! 498: if (!src) {
! 499: zlog_warn("%s %s: XMALLOC() failure",
! 500: __FILE__, __PRETTY_FUNCTION__);
! 501: return 0; /* error, not found, could not create */
! 502: }
! 503:
! 504: src->t_source_timer = 0;
! 505: src->source_group = group; /* back pointer */
! 506: src->source_addr = src_addr;
! 507: src->source_creation = pim_time_monotonic_sec();
! 508: src->source_flags = 0;
! 509: src->source_query_retransmit_count = 0;
! 510: src->source_channel_oil = 0;
! 511:
! 512: listnode_add(group->group_source_list, src);
! 513:
! 514: zassert(!src->t_source_timer); /* source timer == 0 */
! 515:
! 516: /* Any source (*,G) is forwarded only if mode is EXCLUDE {empty} */
! 517: igmp_anysource_forward_stop(group);
! 518:
! 519: return src;
! 520: }
! 521:
! 522: static struct igmp_source *add_source_by_addr(struct igmp_sock *igmp,
! 523: struct igmp_group *group,
! 524: struct in_addr src_addr,
! 525: const char *ifname)
! 526: {
! 527: struct igmp_source *src;
! 528:
! 529: src = igmp_find_source_by_addr(group, src_addr);
! 530: if (src) {
! 531: return src;
! 532: }
! 533:
! 534: src = source_new(group, src_addr, ifname);
! 535: if (!src) {
! 536: return 0;
! 537: }
! 538:
! 539: return src;
! 540: }
! 541:
! 542: static void allow(struct igmp_sock *igmp, struct in_addr from,
! 543: struct in_addr group_addr,
! 544: int num_sources, struct in_addr *sources)
! 545: {
! 546: struct interface *ifp = igmp->interface;
! 547: struct igmp_group *group;
! 548: int i;
! 549:
! 550: /* non-existant group is created as INCLUDE {empty} */
! 551: group = igmp_add_group_by_addr(igmp, group_addr, ifp->name);
! 552: if (!group) {
! 553: return;
! 554: }
! 555:
! 556: /* scan received sources */
! 557: for (i = 0; i < num_sources; ++i) {
! 558: struct igmp_source *source;
! 559: struct in_addr *src_addr;
! 560:
! 561: src_addr = sources + i;
! 562:
! 563: source = add_source_by_addr(igmp, group, *src_addr, ifp->name);
! 564: if (!source) {
! 565: continue;
! 566: }
! 567:
! 568: /*
! 569: RFC 3376: 6.4.1. Reception of Current-State Records
! 570:
! 571: When receiving IS_IN reports for groups in EXCLUDE mode is
! 572: sources should be moved from set with (timers = 0) to set with
! 573: (timers > 0).
! 574:
! 575: igmp_source_reset_gmi() below, resetting the source timers to
! 576: GMI, accomplishes this.
! 577: */
! 578: igmp_source_reset_gmi(igmp, group, source);
! 579:
! 580: } /* scan received sources */
! 581: }
! 582:
! 583: void igmpv3_report_isin(struct igmp_sock *igmp, struct in_addr from,
! 584: struct in_addr group_addr,
! 585: int num_sources, struct in_addr *sources)
! 586: {
! 587: on_trace(__PRETTY_FUNCTION__,
! 588: igmp->interface, from, group_addr, num_sources, sources);
! 589:
! 590: allow(igmp, from, group_addr, num_sources, sources);
! 591: }
! 592:
! 593: static void isex_excl(struct igmp_group *group,
! 594: int num_sources, struct in_addr *sources)
! 595: {
! 596: int i;
! 597:
! 598: /* EXCLUDE mode */
! 599: zassert(group->group_filtermode_isexcl);
! 600:
! 601: /* E.1: set deletion flag for known sources (X,Y) */
! 602: source_mark_delete_flag(group->group_source_list);
! 603:
! 604: /* scan received sources (A) */
! 605: for (i = 0; i < num_sources; ++i) {
! 606: struct igmp_source *source;
! 607: struct in_addr *src_addr;
! 608:
! 609: src_addr = sources + i;
! 610:
! 611: /* E.2: lookup reported source from (A) in (X,Y) */
! 612: source = igmp_find_source_by_addr(group, *src_addr);
! 613: if (source) {
! 614: /* E.3: if found, clear deletion flag: (X*A) or (Y*A) */
! 615: IGMP_SOURCE_DONT_DELETE(source->source_flags);
! 616: }
! 617: else {
! 618: /* E.4: if not found, create source with timer=GMI: (A-X-Y) */
! 619: source = source_new(group, *src_addr,
! 620: group->group_igmp_sock->interface->name);
! 621: if (!source) {
! 622: /* ugh, internal malloc failure, skip source */
! 623: continue;
! 624: }
! 625: zassert(!source->t_source_timer); /* timer == 0 */
! 626: igmp_source_reset_gmi(group->group_igmp_sock, group, source);
! 627: zassert(source->t_source_timer); /* (A-X-Y) timer > 0 */
! 628: }
! 629:
! 630: } /* scan received sources */
! 631:
! 632: /* E.5: delete all sources marked with deletion flag: (X-A) and (Y-A) */
! 633: source_delete_by_flag(group->group_source_list);
! 634: }
! 635:
! 636: static void isex_incl(struct igmp_group *group,
! 637: int num_sources, struct in_addr *sources)
! 638: {
! 639: int i;
! 640:
! 641: /* INCLUDE mode */
! 642: zassert(!group->group_filtermode_isexcl);
! 643:
! 644: /* I.1: set deletion flag for known sources (A) */
! 645: source_mark_delete_flag(group->group_source_list);
! 646:
! 647: /* scan received sources (B) */
! 648: for (i = 0; i < num_sources; ++i) {
! 649: struct igmp_source *source;
! 650: struct in_addr *src_addr;
! 651:
! 652: src_addr = sources + i;
! 653:
! 654: /* I.2: lookup reported source (B) */
! 655: source = igmp_find_source_by_addr(group, *src_addr);
! 656: if (source) {
! 657: /* I.3: if found, clear deletion flag (A*B) */
! 658: IGMP_SOURCE_DONT_DELETE(source->source_flags);
! 659: }
! 660: else {
! 661: /* I.4: if not found, create source with timer=0 (B-A) */
! 662: source = source_new(group, *src_addr,
! 663: group->group_igmp_sock->interface->name);
! 664: if (!source) {
! 665: /* ugh, internal malloc failure, skip source */
! 666: continue;
! 667: }
! 668: zassert(!source->t_source_timer); /* (B-A) timer=0 */
! 669: }
! 670:
! 671: } /* scan received sources */
! 672:
! 673: /* I.5: delete all sources marked with deletion flag (A-B) */
! 674: source_delete_by_flag(group->group_source_list);
! 675:
! 676: group->group_filtermode_isexcl = 1; /* boolean=true */
! 677:
! 678: zassert(group->group_filtermode_isexcl);
! 679:
! 680: group_exclude_fwd_anysrc_ifempty(group);
! 681: }
! 682:
! 683: void igmpv3_report_isex(struct igmp_sock *igmp, struct in_addr from,
! 684: struct in_addr group_addr,
! 685: int num_sources, struct in_addr *sources)
! 686: {
! 687: struct interface *ifp = igmp->interface;
! 688: struct igmp_group *group;
! 689:
! 690: on_trace(__PRETTY_FUNCTION__,
! 691: ifp, from, group_addr, num_sources, sources);
! 692:
! 693: /* non-existant group is created as INCLUDE {empty} */
! 694: group = igmp_add_group_by_addr(igmp, group_addr, ifp->name);
! 695: if (!group) {
! 696: return;
! 697: }
! 698:
! 699: if (group->group_filtermode_isexcl) {
! 700: /* EXCLUDE mode */
! 701: isex_excl(group, num_sources, sources);
! 702: }
! 703: else {
! 704: /* INCLUDE mode */
! 705: isex_incl(group, num_sources, sources);
! 706: zassert(group->group_filtermode_isexcl);
! 707: }
! 708:
! 709: zassert(group->group_filtermode_isexcl);
! 710:
! 711: igmp_group_reset_gmi(group);
! 712: }
! 713:
! 714: static void toin_incl(struct igmp_group *group,
! 715: int num_sources, struct in_addr *sources)
! 716: {
! 717: struct igmp_sock *igmp = group->group_igmp_sock;
! 718: int num_sources_tosend = listcount(group->group_source_list);
! 719: int i;
! 720:
! 721: /* Set SEND flag for all known sources (A) */
! 722: source_mark_send_flag(group->group_source_list);
! 723:
! 724: /* Scan received sources (B) */
! 725: for (i = 0; i < num_sources; ++i) {
! 726: struct igmp_source *source;
! 727: struct in_addr *src_addr;
! 728:
! 729: src_addr = sources + i;
! 730:
! 731: /* Lookup reported source (B) */
! 732: source = igmp_find_source_by_addr(group, *src_addr);
! 733: if (source) {
! 734: /* If found, clear SEND flag (A*B) */
! 735: IGMP_SOURCE_DONT_SEND(source->source_flags);
! 736: --num_sources_tosend;
! 737: }
! 738: else {
! 739: /* If not found, create new source */
! 740: source = source_new(group, *src_addr,
! 741: group->group_igmp_sock->interface->name);
! 742: if (!source) {
! 743: /* ugh, internal malloc failure, skip source */
! 744: continue;
! 745: }
! 746: }
! 747:
! 748: /* (B)=GMI */
! 749: igmp_source_reset_gmi(igmp, group, source);
! 750: }
! 751:
! 752: /* Send sources marked with SEND flag: Q(G,A-B) */
! 753: if (num_sources_tosend > 0) {
! 754: source_query_send_by_flag(group, num_sources_tosend);
! 755: }
! 756: }
! 757:
! 758: static void toin_excl(struct igmp_group *group,
! 759: int num_sources, struct in_addr *sources)
! 760: {
! 761: struct igmp_sock *igmp = group->group_igmp_sock;
! 762: int num_sources_tosend;
! 763: int i;
! 764:
! 765: /* Set SEND flag for X (sources with timer > 0) */
! 766: num_sources_tosend = source_mark_send_flag_by_timer(group->group_source_list);
! 767:
! 768: /* Scan received sources (A) */
! 769: for (i = 0; i < num_sources; ++i) {
! 770: struct igmp_source *source;
! 771: struct in_addr *src_addr;
! 772:
! 773: src_addr = sources + i;
! 774:
! 775: /* Lookup reported source (A) */
! 776: source = igmp_find_source_by_addr(group, *src_addr);
! 777: if (source) {
! 778: if (source->t_source_timer) {
! 779: /* If found and timer running, clear SEND flag (X*A) */
! 780: IGMP_SOURCE_DONT_SEND(source->source_flags);
! 781: --num_sources_tosend;
! 782: }
! 783: }
! 784: else {
! 785: /* If not found, create new source */
! 786: source = source_new(group, *src_addr,
! 787: group->group_igmp_sock->interface->name);
! 788: if (!source) {
! 789: /* ugh, internal malloc failure, skip source */
! 790: continue;
! 791: }
! 792: }
! 793:
! 794: /* (A)=GMI */
! 795: igmp_source_reset_gmi(igmp, group, source);
! 796: }
! 797:
! 798: /* Send sources marked with SEND flag: Q(G,X-A) */
! 799: if (num_sources_tosend > 0) {
! 800: source_query_send_by_flag(group, num_sources_tosend);
! 801: }
! 802:
! 803: /* Send Q(G) */
! 804: group_query_send(group);
! 805: }
! 806:
! 807: void igmpv3_report_toin(struct igmp_sock *igmp, struct in_addr from,
! 808: struct in_addr group_addr,
! 809: int num_sources, struct in_addr *sources)
! 810: {
! 811: struct interface *ifp = igmp->interface;
! 812: struct igmp_group *group;
! 813:
! 814: on_trace(__PRETTY_FUNCTION__,
! 815: ifp, from, group_addr, num_sources, sources);
! 816:
! 817: /* non-existant group is created as INCLUDE {empty} */
! 818: group = igmp_add_group_by_addr(igmp, group_addr, ifp->name);
! 819: if (!group) {
! 820: return;
! 821: }
! 822:
! 823: if (group->group_filtermode_isexcl) {
! 824: /* EXCLUDE mode */
! 825: toin_excl(group, num_sources, sources);
! 826: }
! 827: else {
! 828: /* INCLUDE mode */
! 829: toin_incl(group, num_sources, sources);
! 830: }
! 831: }
! 832:
! 833: static void toex_incl(struct igmp_group *group,
! 834: int num_sources, struct in_addr *sources)
! 835: {
! 836: int num_sources_tosend = 0;
! 837: int i;
! 838:
! 839: zassert(!group->group_filtermode_isexcl);
! 840:
! 841: /* Set DELETE flag for all known sources (A) */
! 842: source_mark_delete_flag(group->group_source_list);
! 843:
! 844: /* Clear off SEND flag from all known sources (A) */
! 845: source_clear_send_flag(group->group_source_list);
! 846:
! 847: /* Scan received sources (B) */
! 848: for (i = 0; i < num_sources; ++i) {
! 849: struct igmp_source *source;
! 850: struct in_addr *src_addr;
! 851:
! 852: src_addr = sources + i;
! 853:
! 854: /* Lookup reported source (B) */
! 855: source = igmp_find_source_by_addr(group, *src_addr);
! 856: if (source) {
! 857: /* If found, clear deletion flag: (A*B) */
! 858: IGMP_SOURCE_DONT_DELETE(source->source_flags);
! 859: /* and set SEND flag (A*B) */
! 860: IGMP_SOURCE_DO_SEND(source->source_flags);
! 861: ++num_sources_tosend;
! 862: }
! 863: else {
! 864: /* If source not found, create source with timer=0: (B-A)=0 */
! 865: source = source_new(group, *src_addr,
! 866: group->group_igmp_sock->interface->name);
! 867: if (!source) {
! 868: /* ugh, internal malloc failure, skip source */
! 869: continue;
! 870: }
! 871: zassert(!source->t_source_timer); /* (B-A) timer=0 */
! 872: }
! 873:
! 874: } /* Scan received sources (B) */
! 875:
! 876: group->group_filtermode_isexcl = 1; /* boolean=true */
! 877:
! 878: /* Delete all sources marked with DELETE flag (A-B) */
! 879: source_delete_by_flag(group->group_source_list);
! 880:
! 881: /* Send sources marked with SEND flag: Q(G,A*B) */
! 882: if (num_sources_tosend > 0) {
! 883: source_query_send_by_flag(group, num_sources_tosend);
! 884: }
! 885:
! 886: zassert(group->group_filtermode_isexcl);
! 887:
! 888: group_exclude_fwd_anysrc_ifempty(group);
! 889: }
! 890:
! 891: static void toex_excl(struct igmp_group *group,
! 892: int num_sources, struct in_addr *sources)
! 893: {
! 894: int num_sources_tosend = 0;
! 895: int i;
! 896:
! 897: /* set DELETE flag for all known sources (X,Y) */
! 898: source_mark_delete_flag(group->group_source_list);
! 899:
! 900: /* clear off SEND flag from all known sources (X,Y) */
! 901: source_clear_send_flag(group->group_source_list);
! 902:
! 903: /* scan received sources (A) */
! 904: for (i = 0; i < num_sources; ++i) {
! 905: struct igmp_source *source;
! 906: struct in_addr *src_addr;
! 907:
! 908: src_addr = sources + i;
! 909:
! 910: /* lookup reported source (A) in known sources (X,Y) */
! 911: source = igmp_find_source_by_addr(group, *src_addr);
! 912: if (source) {
! 913: /* if found, clear off DELETE flag from reported source (A) */
! 914: IGMP_SOURCE_DONT_DELETE(source->source_flags);
! 915: }
! 916: else {
! 917: /* if not found, create source with Group Timer: (A-X-Y)=Group Timer */
! 918: long group_timer_msec;
! 919: source = source_new(group, *src_addr,
! 920: group->group_igmp_sock->interface->name);
! 921: if (!source) {
! 922: /* ugh, internal malloc failure, skip source */
! 923: continue;
! 924: }
! 925:
! 926: zassert(!source->t_source_timer); /* timer == 0 */
! 927: group_timer_msec = igmp_group_timer_remain_msec(group);
! 928: igmp_source_timer_on(group, source, group_timer_msec);
! 929: zassert(source->t_source_timer); /* (A-X-Y) timer > 0 */
! 930:
! 931: /* make sure source is created with DELETE flag unset */
! 932: zassert(!IGMP_SOURCE_TEST_DELETE(source->source_flags));
! 933: }
! 934:
! 935: /* make sure reported source has DELETE flag unset */
! 936: zassert(!IGMP_SOURCE_TEST_DELETE(source->source_flags));
! 937:
! 938: if (source->t_source_timer) {
! 939: /* if source timer>0 mark SEND flag: Q(G,A-Y) */
! 940: IGMP_SOURCE_DO_SEND(source->source_flags);
! 941: ++num_sources_tosend;
! 942: }
! 943:
! 944: } /* scan received sources (A) */
! 945:
! 946: /*
! 947: delete all sources marked with DELETE flag:
! 948: Delete (X-A)
! 949: Delete (Y-A)
! 950: */
! 951: source_delete_by_flag(group->group_source_list);
! 952:
! 953: /* send sources marked with SEND flag: Q(G,A-Y) */
! 954: if (num_sources_tosend > 0) {
! 955: source_query_send_by_flag(group, num_sources_tosend);
! 956: }
! 957: }
! 958:
! 959: void igmpv3_report_toex(struct igmp_sock *igmp, struct in_addr from,
! 960: struct in_addr group_addr,
! 961: int num_sources, struct in_addr *sources)
! 962: {
! 963: struct interface *ifp = igmp->interface;
! 964: struct igmp_group *group;
! 965:
! 966: on_trace(__PRETTY_FUNCTION__,
! 967: ifp, from, group_addr, num_sources, sources);
! 968:
! 969: /* non-existant group is created as INCLUDE {empty} */
! 970: group = igmp_add_group_by_addr(igmp, group_addr, ifp->name);
! 971: if (!group) {
! 972: return;
! 973: }
! 974:
! 975: if (group->group_filtermode_isexcl) {
! 976: /* EXCLUDE mode */
! 977: toex_excl(group, num_sources, sources);
! 978: }
! 979: else {
! 980: /* INCLUDE mode */
! 981: toex_incl(group, num_sources, sources);
! 982: zassert(group->group_filtermode_isexcl);
! 983: }
! 984: zassert(group->group_filtermode_isexcl);
! 985:
! 986: /* Group Timer=GMI */
! 987: igmp_group_reset_gmi(group);
! 988: }
! 989:
! 990: void igmpv3_report_allow(struct igmp_sock *igmp, struct in_addr from,
! 991: struct in_addr group_addr,
! 992: int num_sources, struct in_addr *sources)
! 993: {
! 994: on_trace(__PRETTY_FUNCTION__,
! 995: igmp->interface, from, group_addr, num_sources, sources);
! 996:
! 997: allow(igmp, from, group_addr, num_sources, sources);
! 998: }
! 999:
! 1000: /*
! 1001: RFC3376: 6.6.3.1. Building and Sending Group Specific Queries
! 1002:
! 1003: When transmitting a group specific query, if the group timer is
! 1004: larger than LMQT, the "Suppress Router-Side Processing" bit is set
! 1005: in the query message.
! 1006: */
! 1007: static void group_retransmit_group(struct igmp_group *group)
! 1008: {
! 1009: char query_buf[PIM_IGMP_BUFSIZE_WRITE];
! 1010: struct igmp_sock *igmp;
! 1011: struct pim_interface *pim_ifp;
! 1012: long lmqc; /* Last Member Query Count */
! 1013: long lmqi_msec; /* Last Member Query Interval */
! 1014: long lmqt_msec; /* Last Member Query Time */
! 1015: int s_flag;
! 1016:
! 1017: igmp = group->group_igmp_sock;
! 1018: pim_ifp = igmp->interface->info;
! 1019:
! 1020: lmqc = igmp->querier_robustness_variable;
! 1021: lmqi_msec = 100 * pim_ifp->igmp_specific_query_max_response_time_dsec;
! 1022: lmqt_msec = lmqc * lmqi_msec;
! 1023:
! 1024: /*
! 1025: RFC3376: 6.6.3.1. Building and Sending Group Specific Queries
! 1026:
! 1027: When transmitting a group specific query, if the group timer is
! 1028: larger than LMQT, the "Suppress Router-Side Processing" bit is set
! 1029: in the query message.
! 1030: */
! 1031: s_flag = igmp_group_timer_remain_msec(group) > lmqt_msec;
! 1032:
! 1033: if (PIM_DEBUG_IGMP_TRACE) {
! 1034: char group_str[100];
! 1035: pim_inet4_dump("<group?>", group->group_addr, group_str, sizeof(group_str));
! 1036: zlog_debug("retransmit_group_specific_query: group %s on %s: s_flag=%d count=%d",
! 1037: group_str, igmp->interface->name, s_flag,
! 1038: group->group_specific_query_retransmit_count);
! 1039: }
! 1040:
! 1041: /*
! 1042: RFC3376: 4.1.12. IP Destination Addresses for Queries
! 1043:
! 1044: Group-Specific and Group-and-Source-Specific Queries are sent with
! 1045: an IP destination address equal to the multicast address of
! 1046: interest.
! 1047: */
! 1048:
! 1049: pim_igmp_send_membership_query(group,
! 1050: igmp->fd,
! 1051: igmp->interface->name,
! 1052: query_buf,
! 1053: sizeof(query_buf),
! 1054: 0 /* num_sources_tosend */,
! 1055: group->group_addr /* dst_addr */,
! 1056: group->group_addr /* group_addr */,
! 1057: pim_ifp->igmp_specific_query_max_response_time_dsec,
! 1058: s_flag,
! 1059: igmp->querier_robustness_variable,
! 1060: igmp->querier_query_interval);
! 1061: }
! 1062:
! 1063: /*
! 1064: RFC3376: 6.6.3.2. Building and Sending Group and Source Specific Queries
! 1065:
! 1066: When building a group and source specific query for a group G, two
! 1067: separate query messages are sent for the group. The first one has
! 1068: the "Suppress Router-Side Processing" bit set and contains all the
! 1069: sources with retransmission state and timers greater than LMQT. The
! 1070: second has the "Suppress Router-Side Processing" bit clear and
! 1071: contains all the sources with retransmission state and timers lower
! 1072: or equal to LMQT. If either of the two calculated messages does not
! 1073: contain any sources, then its transmission is suppressed.
! 1074: */
! 1075: static int group_retransmit_sources(struct igmp_group *group,
! 1076: int send_with_sflag_set)
! 1077: {
! 1078: struct igmp_sock *igmp;
! 1079: struct pim_interface *pim_ifp;
! 1080: long lmqc; /* Last Member Query Count */
! 1081: long lmqi_msec; /* Last Member Query Interval */
! 1082: long lmqt_msec; /* Last Member Query Time */
! 1083: char query_buf1[PIM_IGMP_BUFSIZE_WRITE]; /* 1 = with s_flag set */
! 1084: char query_buf2[PIM_IGMP_BUFSIZE_WRITE]; /* 2 = with s_flag clear */
! 1085: int query_buf1_max_sources;
! 1086: int query_buf2_max_sources;
! 1087: struct in_addr *source_addr1;
! 1088: struct in_addr *source_addr2;
! 1089: int num_sources_tosend1;
! 1090: int num_sources_tosend2;
! 1091: struct listnode *src_node;
! 1092: struct igmp_source *src;
! 1093: int num_retransmit_sources_left = 0;
! 1094:
! 1095: query_buf1_max_sources = (sizeof(query_buf1) - IGMP_V3_SOURCES_OFFSET) >> 2;
! 1096: query_buf2_max_sources = (sizeof(query_buf2) - IGMP_V3_SOURCES_OFFSET) >> 2;
! 1097:
! 1098: source_addr1 = (struct in_addr *)(query_buf1 + IGMP_V3_SOURCES_OFFSET);
! 1099: source_addr2 = (struct in_addr *)(query_buf2 + IGMP_V3_SOURCES_OFFSET);
! 1100:
! 1101: igmp = group->group_igmp_sock;
! 1102: pim_ifp = igmp->interface->info;
! 1103:
! 1104: lmqc = igmp->querier_robustness_variable;
! 1105: lmqi_msec = 100 * pim_ifp->igmp_specific_query_max_response_time_dsec;
! 1106: lmqt_msec = lmqc * lmqi_msec;
! 1107:
! 1108: /* Scan all group sources */
! 1109: for (ALL_LIST_ELEMENTS_RO(group->group_source_list, src_node, src)) {
! 1110:
! 1111: /* Source has retransmission state? */
! 1112: if (src->source_query_retransmit_count < 1)
! 1113: continue;
! 1114:
! 1115: if (--src->source_query_retransmit_count > 0) {
! 1116: ++num_retransmit_sources_left;
! 1117: }
! 1118:
! 1119: /* Copy source address into appropriate query buffer */
! 1120: if (igmp_source_timer_remain_msec(src) > lmqt_msec) {
! 1121: *source_addr1 = src->source_addr;
! 1122: ++source_addr1;
! 1123: }
! 1124: else {
! 1125: *source_addr2 = src->source_addr;
! 1126: ++source_addr2;
! 1127: }
! 1128:
! 1129: }
! 1130:
! 1131: num_sources_tosend1 = source_addr1 - (struct in_addr *)(query_buf1 + IGMP_V3_SOURCES_OFFSET);
! 1132: num_sources_tosend2 = source_addr2 - (struct in_addr *)(query_buf2 + IGMP_V3_SOURCES_OFFSET);
! 1133:
! 1134: if (PIM_DEBUG_IGMP_TRACE) {
! 1135: char group_str[100];
! 1136: pim_inet4_dump("<group?>", group->group_addr, group_str, sizeof(group_str));
! 1137: zlog_debug("retransmit_grp&src_specific_query: group %s on %s: srcs_with_sflag=%d srcs_wo_sflag=%d will_send_sflag=%d retransmit_src_left=%d",
! 1138: group_str, igmp->interface->name,
! 1139: num_sources_tosend1,
! 1140: num_sources_tosend2,
! 1141: send_with_sflag_set,
! 1142: num_retransmit_sources_left);
! 1143: }
! 1144:
! 1145: if (num_sources_tosend1 > 0) {
! 1146: /*
! 1147: Send group-and-source-specific query with s_flag set and all
! 1148: sources with timers greater than LMQT.
! 1149: */
! 1150:
! 1151: if (send_with_sflag_set) {
! 1152:
! 1153: query_buf1_max_sources = (sizeof(query_buf1) - IGMP_V3_SOURCES_OFFSET) >> 2;
! 1154: if (num_sources_tosend1 > query_buf1_max_sources) {
! 1155: char group_str[100];
! 1156: pim_inet4_dump("<group?>", group->group_addr, group_str, sizeof(group_str));
! 1157: zlog_warn("%s: group %s on %s: s_flag=1 unable to fit %d sources into buf_size=%zu (max_sources=%d)",
! 1158: __PRETTY_FUNCTION__, group_str, igmp->interface->name,
! 1159: num_sources_tosend1, sizeof(query_buf1), query_buf1_max_sources);
! 1160: }
! 1161: else {
! 1162: /*
! 1163: RFC3376: 4.1.12. IP Destination Addresses for Queries
! 1164:
! 1165: Group-Specific and Group-and-Source-Specific Queries are sent with
! 1166: an IP destination address equal to the multicast address of
! 1167: interest.
! 1168: */
! 1169:
! 1170: pim_igmp_send_membership_query(group,
! 1171: igmp->fd,
! 1172: igmp->interface->name,
! 1173: query_buf1,
! 1174: sizeof(query_buf1),
! 1175: num_sources_tosend1,
! 1176: group->group_addr,
! 1177: group->group_addr,
! 1178: pim_ifp->igmp_specific_query_max_response_time_dsec,
! 1179: 1 /* s_flag */,
! 1180: igmp->querier_robustness_variable,
! 1181: igmp->querier_query_interval);
! 1182:
! 1183: }
! 1184:
! 1185: } /* send_with_sflag_set */
! 1186:
! 1187: }
! 1188:
! 1189: if (num_sources_tosend2 > 0) {
! 1190: /*
! 1191: Send group-and-source-specific query with s_flag clear and all
! 1192: sources with timers lower or equal to LMQT.
! 1193: */
! 1194:
! 1195: query_buf2_max_sources = (sizeof(query_buf2) - IGMP_V3_SOURCES_OFFSET) >> 2;
! 1196: if (num_sources_tosend2 > query_buf2_max_sources) {
! 1197: char group_str[100];
! 1198: pim_inet4_dump("<group?>", group->group_addr, group_str, sizeof(group_str));
! 1199: zlog_warn("%s: group %s on %s: s_flag=0 unable to fit %d sources into buf_size=%zu (max_sources=%d)",
! 1200: __PRETTY_FUNCTION__, group_str, igmp->interface->name,
! 1201: num_sources_tosend2, sizeof(query_buf2), query_buf2_max_sources);
! 1202: }
! 1203: else {
! 1204: /*
! 1205: RFC3376: 4.1.12. IP Destination Addresses for Queries
! 1206:
! 1207: Group-Specific and Group-and-Source-Specific Queries are sent with
! 1208: an IP destination address equal to the multicast address of
! 1209: interest.
! 1210: */
! 1211:
! 1212: pim_igmp_send_membership_query(group,
! 1213: igmp->fd,
! 1214: igmp->interface->name,
! 1215: query_buf2,
! 1216: sizeof(query_buf2),
! 1217: num_sources_tosend2,
! 1218: group->group_addr,
! 1219: group->group_addr,
! 1220: pim_ifp->igmp_specific_query_max_response_time_dsec,
! 1221: 0 /* s_flag */,
! 1222: igmp->querier_robustness_variable,
! 1223: igmp->querier_query_interval);
! 1224:
! 1225: }
! 1226: }
! 1227:
! 1228: return num_retransmit_sources_left;
! 1229: }
! 1230:
! 1231: static int igmp_group_retransmit(struct thread *t)
! 1232: {
! 1233: struct igmp_group *group;
! 1234: int num_retransmit_sources_left;
! 1235: int send_with_sflag_set; /* boolean */
! 1236:
! 1237: zassert(t);
! 1238: group = THREAD_ARG(t);
! 1239: zassert(group);
! 1240:
! 1241: if (PIM_DEBUG_IGMP_TRACE) {
! 1242: char group_str[100];
! 1243: pim_inet4_dump("<group?>", group->group_addr, group_str, sizeof(group_str));
! 1244: zlog_debug("group_retransmit_timer: group %s on %s",
! 1245: group_str, group->group_igmp_sock->interface->name);
! 1246: }
! 1247:
! 1248: /* Retransmit group-specific queries? (RFC3376: 6.6.3.1) */
! 1249: if (group->group_specific_query_retransmit_count > 0) {
! 1250:
! 1251: /* Retransmit group-specific queries (RFC3376: 6.6.3.1) */
! 1252: group_retransmit_group(group);
! 1253: --group->group_specific_query_retransmit_count;
! 1254:
! 1255: /*
! 1256: RFC3376: 6.6.3.2
! 1257: If a group specific query is scheduled to be transmitted at the
! 1258: same time as a group and source specific query for the same group,
! 1259: then transmission of the group and source specific message with the
! 1260: "Suppress Router-Side Processing" bit set may be suppressed.
! 1261: */
! 1262: send_with_sflag_set = 0; /* boolean=false */
! 1263: }
! 1264: else {
! 1265: send_with_sflag_set = 1; /* boolean=true */
! 1266: }
! 1267:
! 1268: /* Retransmit group-and-source-specific queries (RFC3376: 6.6.3.2) */
! 1269: num_retransmit_sources_left = group_retransmit_sources(group,
! 1270: send_with_sflag_set);
! 1271:
! 1272: group->t_group_query_retransmit_timer = 0;
! 1273:
! 1274: /*
! 1275: Keep group retransmit timer running if there is any retransmit
! 1276: counter pending
! 1277: */
! 1278: if ((num_retransmit_sources_left > 0) ||
! 1279: (group->group_specific_query_retransmit_count > 0)) {
! 1280: group_retransmit_timer_on(group);
! 1281: }
! 1282:
! 1283: return 0;
! 1284: }
! 1285:
! 1286: /*
! 1287: group_retransmit_timer_on:
! 1288: if group retransmit timer isn't running, starts it;
! 1289: otherwise, do nothing
! 1290: */
! 1291: static void group_retransmit_timer_on(struct igmp_group *group)
! 1292: {
! 1293: struct igmp_sock *igmp;
! 1294: struct pim_interface *pim_ifp;
! 1295: long lmqi_msec; /* Last Member Query Interval */
! 1296:
! 1297: /* if group retransmit timer is running, do nothing */
! 1298: if (group->t_group_query_retransmit_timer) {
! 1299: return;
! 1300: }
! 1301:
! 1302: igmp = group->group_igmp_sock;
! 1303: pim_ifp = igmp->interface->info;
! 1304:
! 1305: lmqi_msec = 100 * pim_ifp->igmp_specific_query_max_response_time_dsec;
! 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("Scheduling %ld.%03ld sec retransmit timer for group %s on %s",
! 1311: lmqi_msec / 1000,
! 1312: lmqi_msec % 1000,
! 1313: group_str,
! 1314: igmp->interface->name);
! 1315: }
! 1316:
! 1317: THREAD_TIMER_MSEC_ON(master, group->t_group_query_retransmit_timer,
! 1318: igmp_group_retransmit,
! 1319: group, lmqi_msec);
! 1320: }
! 1321:
! 1322: static long igmp_group_timer_remain_msec(struct igmp_group *group)
! 1323: {
! 1324: return pim_time_timer_remain_msec(group->t_group_timer);
! 1325: }
! 1326:
! 1327: static long igmp_source_timer_remain_msec(struct igmp_source *source)
! 1328: {
! 1329: return pim_time_timer_remain_msec(source->t_source_timer);
! 1330: }
! 1331:
! 1332: /*
! 1333: RFC3376: 6.6.3.1. Building and Sending Group Specific Queries
! 1334: */
! 1335: static void group_query_send(struct igmp_group *group)
! 1336: {
! 1337: long lmqc; /* Last Member Query Count */
! 1338:
! 1339: lmqc = group->group_igmp_sock->querier_robustness_variable;
! 1340:
! 1341: /* lower group timer to lmqt */
! 1342: igmp_group_timer_lower_to_lmqt(group);
! 1343:
! 1344: /* reset retransmission counter */
! 1345: group->group_specific_query_retransmit_count = lmqc;
! 1346:
! 1347: /* immediately send group specific query (decrease retransmit counter by 1)*/
! 1348: group_retransmit_group(group);
! 1349:
! 1350: /* make sure group retransmit timer is running */
! 1351: group_retransmit_timer_on(group);
! 1352: }
! 1353:
! 1354: /*
! 1355: RFC3376: 6.6.3.2. Building and Sending Group and Source Specific Queries
! 1356: */
! 1357: static void source_query_send_by_flag(struct igmp_group *group,
! 1358: int num_sources_tosend)
! 1359: {
! 1360: struct igmp_sock *igmp;
! 1361: struct pim_interface *pim_ifp;
! 1362: struct listnode *src_node;
! 1363: struct igmp_source *src;
! 1364: long lmqc; /* Last Member Query Count */
! 1365: long lmqi_msec; /* Last Member Query Interval */
! 1366: long lmqt_msec; /* Last Member Query Time */
! 1367:
! 1368: zassert(num_sources_tosend > 0);
! 1369:
! 1370: igmp = group->group_igmp_sock;
! 1371: pim_ifp = igmp->interface->info;
! 1372:
! 1373: lmqc = igmp->querier_robustness_variable;
! 1374: lmqi_msec = 100 * pim_ifp->igmp_specific_query_max_response_time_dsec;
! 1375: lmqt_msec = lmqc * lmqi_msec;
! 1376:
! 1377: /*
! 1378: RFC3376: 6.6.3.2. Building and Sending Group and Source Specific Queries
! 1379:
! 1380: (...) for each of the sources in X of group G, with source timer larger
! 1381: than LMQT:
! 1382: o Set number of retransmissions for each source to [Last Member
! 1383: Query Count].
! 1384: o Lower source timer to LMQT.
! 1385: */
! 1386: for (ALL_LIST_ELEMENTS_RO(group->group_source_list, src_node, src)) {
! 1387: if (IGMP_SOURCE_TEST_SEND(src->source_flags)) {
! 1388: /* source "src" in X of group G */
! 1389: if (igmp_source_timer_remain_msec(src) > lmqt_msec) {
! 1390: src->source_query_retransmit_count = lmqc;
! 1391: igmp_source_timer_lower_to_lmqt(src);
! 1392: }
! 1393: }
! 1394: }
! 1395:
! 1396: /* send group-and-source specific queries */
! 1397: group_retransmit_sources(group, 1 /* send_with_sflag_set=true */);
! 1398:
! 1399: /* make sure group retransmit timer is running */
! 1400: group_retransmit_timer_on(group);
! 1401: }
! 1402:
! 1403: static void block_excl(struct igmp_group *group,
! 1404: int num_sources, struct in_addr *sources)
! 1405: {
! 1406: int num_sources_tosend = 0;
! 1407: int i;
! 1408:
! 1409: /* 1. clear off SEND flag from all known sources (X,Y) */
! 1410: source_clear_send_flag(group->group_source_list);
! 1411:
! 1412: /* 2. scan received sources (A) */
! 1413: for (i = 0; i < num_sources; ++i) {
! 1414: struct igmp_source *source;
! 1415: struct in_addr *src_addr;
! 1416:
! 1417: src_addr = sources + i;
! 1418:
! 1419: /* lookup reported source (A) in known sources (X,Y) */
! 1420: source = igmp_find_source_by_addr(group, *src_addr);
! 1421: if (!source) {
! 1422: /* 3: if not found, create source with Group Timer: (A-X-Y)=Group Timer */
! 1423: long group_timer_msec;
! 1424: source = source_new(group, *src_addr,
! 1425: group->group_igmp_sock->interface->name);
! 1426: if (!source) {
! 1427: /* ugh, internal malloc failure, skip source */
! 1428: continue;
! 1429: }
! 1430:
! 1431: zassert(!source->t_source_timer); /* timer == 0 */
! 1432: group_timer_msec = igmp_group_timer_remain_msec(group);
! 1433: igmp_source_timer_on(group, source, group_timer_msec);
! 1434: zassert(source->t_source_timer); /* (A-X-Y) timer > 0 */
! 1435: }
! 1436:
! 1437: if (source->t_source_timer) {
! 1438: /* 4. if source timer>0 mark SEND flag: Q(G,A-Y) */
! 1439: IGMP_SOURCE_DO_SEND(source->source_flags);
! 1440: ++num_sources_tosend;
! 1441: }
! 1442: }
! 1443:
! 1444: /* 5. send sources marked with SEND flag: Q(G,A-Y) */
! 1445: if (num_sources_tosend > 0) {
! 1446: source_query_send_by_flag(group, num_sources_tosend);
! 1447: }
! 1448: }
! 1449:
! 1450: static void block_incl(struct igmp_group *group,
! 1451: int num_sources, struct in_addr *sources)
! 1452: {
! 1453: int num_sources_tosend = 0;
! 1454: int i;
! 1455:
! 1456: /* 1. clear off SEND flag from all known sources (B) */
! 1457: source_clear_send_flag(group->group_source_list);
! 1458:
! 1459: /* 2. scan received sources (A) */
! 1460: for (i = 0; i < num_sources; ++i) {
! 1461: struct igmp_source *source;
! 1462: struct in_addr *src_addr;
! 1463:
! 1464: src_addr = sources + i;
! 1465:
! 1466: /* lookup reported source (A) in known sources (B) */
! 1467: source = igmp_find_source_by_addr(group, *src_addr);
! 1468: if (source) {
! 1469: /* 3. if found (A*B), mark SEND flag: Q(G,A*B) */
! 1470: IGMP_SOURCE_DO_SEND(source->source_flags);
! 1471: ++num_sources_tosend;
! 1472: }
! 1473: }
! 1474:
! 1475: /* 4. send sources marked with SEND flag: Q(G,A*B) */
! 1476: if (num_sources_tosend > 0) {
! 1477: source_query_send_by_flag(group, num_sources_tosend);
! 1478: }
! 1479: }
! 1480:
! 1481: void igmpv3_report_block(struct igmp_sock *igmp, struct in_addr from,
! 1482: struct in_addr group_addr,
! 1483: int num_sources, struct in_addr *sources)
! 1484: {
! 1485: struct interface *ifp = igmp->interface;
! 1486: struct igmp_group *group;
! 1487:
! 1488: on_trace(__PRETTY_FUNCTION__,
! 1489: ifp, from, group_addr, num_sources, sources);
! 1490:
! 1491: /* non-existant group is created as INCLUDE {empty} */
! 1492: group = igmp_add_group_by_addr(igmp, group_addr, ifp->name);
! 1493: if (!group) {
! 1494: return;
! 1495: }
! 1496:
! 1497: if (group->group_filtermode_isexcl) {
! 1498: /* EXCLUDE mode */
! 1499: block_excl(group, num_sources, sources);
! 1500: }
! 1501: else {
! 1502: /* INCLUDE mode */
! 1503: block_incl(group, num_sources, sources);
! 1504: }
! 1505: }
! 1506:
! 1507: void igmp_group_timer_lower_to_lmqt(struct igmp_group *group)
! 1508: {
! 1509: struct igmp_sock *igmp;
! 1510: struct interface *ifp;
! 1511: struct pim_interface *pim_ifp;
! 1512: char *ifname;
! 1513: int lmqi_dsec; /* Last Member Query Interval */
! 1514: int lmqc; /* Last Member Query Count */
! 1515: int lmqt_msec; /* Last Member Query Time */
! 1516:
! 1517: /*
! 1518: RFC 3376: 6.2.2. Definition of Group Timers
! 1519:
! 1520: The group timer is only used when a group is in EXCLUDE mode and
! 1521: it represents the time for the *filter-mode* of the group to
! 1522: expire and switch to INCLUDE mode.
! 1523: */
! 1524: if (!group->group_filtermode_isexcl) {
! 1525: return;
! 1526: }
! 1527:
! 1528: igmp = group->group_igmp_sock;
! 1529: ifp = igmp->interface;
! 1530: pim_ifp = ifp->info;
! 1531: ifname = ifp->name;
! 1532:
! 1533: lmqi_dsec = pim_ifp->igmp_specific_query_max_response_time_dsec;
! 1534: lmqc = igmp->querier_robustness_variable;
! 1535: lmqt_msec = PIM_IGMP_LMQT_MSEC(lmqi_dsec, lmqc); /* lmqt_msec = (100 * lmqi_dsec) * lmqc */
! 1536:
! 1537: if (PIM_DEBUG_IGMP_TRACE) {
! 1538: char group_str[100];
! 1539: pim_inet4_dump("<group?>", group->group_addr, group_str, sizeof(group_str));
! 1540: zlog_debug("%s: group %s on %s: LMQC=%d LMQI=%d dsec LMQT=%d msec",
! 1541: __PRETTY_FUNCTION__,
! 1542: group_str, ifname,
! 1543: lmqc, lmqi_dsec, lmqt_msec);
! 1544: }
! 1545:
! 1546: zassert(group->group_filtermode_isexcl);
! 1547:
! 1548: igmp_group_timer_on(group, lmqt_msec, ifname);
! 1549: }
! 1550:
! 1551: void igmp_source_timer_lower_to_lmqt(struct igmp_source *source)
! 1552: {
! 1553: struct igmp_group *group;
! 1554: struct igmp_sock *igmp;
! 1555: struct interface *ifp;
! 1556: struct pim_interface *pim_ifp;
! 1557: char *ifname;
! 1558: int lmqi_dsec; /* Last Member Query Interval */
! 1559: int lmqc; /* Last Member Query Count */
! 1560: int lmqt_msec; /* Last Member Query Time */
! 1561:
! 1562: group = source->source_group;
! 1563: igmp = group->group_igmp_sock;
! 1564: ifp = igmp->interface;
! 1565: pim_ifp = ifp->info;
! 1566: ifname = ifp->name;
! 1567:
! 1568: lmqi_dsec = pim_ifp->igmp_specific_query_max_response_time_dsec;
! 1569: lmqc = igmp->querier_robustness_variable;
! 1570: lmqt_msec = PIM_IGMP_LMQT_MSEC(lmqi_dsec, lmqc); /* lmqt_msec = (100 * lmqi_dsec) * lmqc */
! 1571:
! 1572: if (PIM_DEBUG_IGMP_TRACE) {
! 1573: char group_str[100];
! 1574: char source_str[100];
! 1575: pim_inet4_dump("<group?>", group->group_addr, group_str, sizeof(group_str));
! 1576: pim_inet4_dump("<source?>", source->source_addr, source_str, sizeof(source_str));
! 1577: zlog_debug("%s: group %s source %s on %s: LMQC=%d LMQI=%d dsec LMQT=%d msec",
! 1578: __PRETTY_FUNCTION__,
! 1579: group_str, source_str, ifname,
! 1580: lmqc, lmqi_dsec, lmqt_msec);
! 1581: }
! 1582:
! 1583: igmp_source_timer_on(group, source, lmqt_msec);
! 1584: }
! 1585:
! 1586: /*
! 1587: Copy sources to message:
! 1588:
! 1589: struct in_addr *sources = (struct in_addr *)(query_buf + IGMP_V3_SOURCES_OFFSET);
! 1590: if (num_sources > 0) {
! 1591: struct listnode *node;
! 1592: struct igmp_source *src;
! 1593: int i = 0;
! 1594:
! 1595: for (ALL_LIST_ELEMENTS_RO(source_list, node, src)) {
! 1596: sources[i++] = src->source_addr;
! 1597: }
! 1598: }
! 1599: */
! 1600: void pim_igmp_send_membership_query(struct igmp_group *group,
! 1601: int fd,
! 1602: const char *ifname,
! 1603: char *query_buf,
! 1604: int query_buf_size,
! 1605: int num_sources,
! 1606: struct in_addr dst_addr,
! 1607: struct in_addr group_addr,
! 1608: int query_max_response_time_dsec,
! 1609: uint8_t s_flag,
! 1610: uint8_t querier_robustness_variable,
! 1611: uint16_t querier_query_interval)
! 1612: {
! 1613: ssize_t msg_size;
! 1614: uint8_t max_resp_code;
! 1615: uint8_t qqic;
! 1616: ssize_t sent;
! 1617: struct sockaddr_in to;
! 1618: socklen_t tolen;
! 1619: uint16_t checksum;
! 1620:
! 1621: zassert(num_sources >= 0);
! 1622:
! 1623: msg_size = IGMP_V3_SOURCES_OFFSET + (num_sources << 2);
! 1624: if (msg_size > query_buf_size) {
! 1625: zlog_err("%s %s: unable to send: msg_size=%zd larger than query_buf_size=%d",
! 1626: __FILE__, __PRETTY_FUNCTION__,
! 1627: msg_size, query_buf_size);
! 1628: return;
! 1629: }
! 1630:
! 1631: s_flag = PIM_FORCE_BOOLEAN(s_flag);
! 1632: zassert((s_flag == 0) || (s_flag == 1));
! 1633:
! 1634: max_resp_code = igmp_msg_encode16to8(query_max_response_time_dsec);
! 1635: qqic = igmp_msg_encode16to8(querier_query_interval);
! 1636:
! 1637: /*
! 1638: RFC 3376: 4.1.6. QRV (Querier's Robustness Variable)
! 1639:
! 1640: If non-zero, the QRV field contains the [Robustness Variable]
! 1641: value used by the querier, i.e., the sender of the Query. If the
! 1642: querier's [Robustness Variable] exceeds 7, the maximum value of
! 1643: the QRV field, the QRV is set to zero.
! 1644: */
! 1645: if (querier_robustness_variable > 7) {
! 1646: querier_robustness_variable = 0;
! 1647: }
! 1648:
! 1649: query_buf[0] = PIM_IGMP_MEMBERSHIP_QUERY;
! 1650: query_buf[1] = max_resp_code;
! 1651: *(uint16_t *)(query_buf + IGMP_V3_CHECKSUM_OFFSET) = 0; /* for computing checksum */
! 1652: memcpy(query_buf+4, &group_addr, sizeof(struct in_addr));
! 1653:
! 1654: query_buf[8] = (s_flag << 3) | querier_robustness_variable;
! 1655: query_buf[9] = qqic;
! 1656: *(uint16_t *)(query_buf + IGMP_V3_NUMSOURCES_OFFSET) = htons(num_sources);
! 1657:
! 1658: checksum = in_cksum(query_buf, msg_size);
! 1659: *(uint16_t *)(query_buf + IGMP_V3_CHECKSUM_OFFSET) = checksum;
! 1660:
! 1661: if (PIM_DEBUG_IGMP_PACKETS) {
! 1662: char dst_str[100];
! 1663: char group_str[100];
! 1664: pim_inet4_dump("<dst?>", dst_addr, dst_str, sizeof(dst_str));
! 1665: pim_inet4_dump("<group?>", group_addr, group_str, sizeof(group_str));
! 1666: zlog_debug("%s: to %s on %s: group=%s sources=%d msg_size=%zd s_flag=%x QRV=%u QQI=%u QQIC=%02x checksum=%x",
! 1667: __PRETTY_FUNCTION__,
! 1668: dst_str, ifname, group_str, num_sources,
! 1669: msg_size, s_flag, querier_robustness_variable,
! 1670: querier_query_interval, qqic, checksum);
! 1671: }
! 1672:
! 1673: #if 0
! 1674: memset(&to, 0, sizeof(to));
! 1675: #endif
! 1676: to.sin_family = AF_INET;
! 1677: to.sin_addr = dst_addr;
! 1678: #if 0
! 1679: to.sin_port = htons(0);
! 1680: #endif
! 1681: tolen = sizeof(to);
! 1682:
! 1683: sent = sendto(fd, query_buf, msg_size, MSG_DONTWAIT,
! 1684: (struct sockaddr *)&to, tolen);
! 1685: if (sent != (ssize_t) msg_size) {
! 1686: int e = errno;
! 1687: char dst_str[100];
! 1688: char group_str[100];
! 1689: pim_inet4_dump("<dst?>", dst_addr, dst_str, sizeof(dst_str));
! 1690: pim_inet4_dump("<group?>", group_addr, group_str, sizeof(group_str));
! 1691: if (sent < 0) {
! 1692: zlog_warn("%s: sendto() failure to %s on %s: group=%s msg_size=%zd: errno=%d: %s",
! 1693: __PRETTY_FUNCTION__,
! 1694: dst_str, ifname, group_str, msg_size,
! 1695: e, safe_strerror(e));
! 1696: }
! 1697: else {
! 1698: zlog_warn("%s: sendto() partial to %s on %s: group=%s msg_size=%zd: sent=%zd",
! 1699: __PRETTY_FUNCTION__,
! 1700: dst_str, ifname, group_str,
! 1701: msg_size, sent);
! 1702: }
! 1703: return;
! 1704: }
! 1705:
! 1706: /*
! 1707: s_flag sanity test: s_flag must be set for general queries
! 1708:
! 1709: RFC 3376: 6.6.1. Timer Updates
! 1710:
! 1711: When a router sends or receives a query with a clear Suppress
! 1712: Router-Side Processing flag, it must update its timers to reflect
! 1713: the correct timeout values for the group or sources being queried.
! 1714:
! 1715: General queries don't trigger timer update.
! 1716: */
! 1717: if (!s_flag) {
! 1718: /* general query? */
! 1719: if (PIM_INADDR_IS_ANY(group_addr)) {
! 1720: char dst_str[100];
! 1721: char group_str[100];
! 1722: pim_inet4_dump("<dst?>", dst_addr, dst_str, sizeof(dst_str));
! 1723: pim_inet4_dump("<group?>", group_addr, group_str, sizeof(group_str));
! 1724: zlog_warn("%s: to %s on %s: group=%s sources=%d: s_flag is clear for general query!",
! 1725: __PRETTY_FUNCTION__,
! 1726: dst_str, ifname, group_str, num_sources);
! 1727: }
! 1728: }
! 1729:
! 1730: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to pim_igmpv3.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