feat: implement IGMPv2 and IGMPv3 report sending for multicast rejoining

Enhance the rejoin_mcast_group function to send both IGMPv2 and IGMPv3 reports via raw sockets. This ensures that upstream devices refresh their membership state even when the kernel suppresses joins due to existing memberships. Additionally, update the multicast.h documentation to reflect these changes.

Author: stackia

src/multicast.c

@@ -12,7 +12,8 @@
 #include <sys/socket.h>
 #include <unistd.h>
 
-/* IGMPv3 Protocol Definitions */
+/* IGMPv2/IGMPv3 Protocol Definitions */
+#define IGMP_V2_MEMBERSHIP_REPORT 0x16
 #define IGMP_V3_MEMBERSHIP_REPORT 0x22
 #define IGMPV3_MODE_IS_INCLUDE 1
 #define IGMPV3_MODE_IS_EXCLUDE 2
@@ -21,6 +22,14 @@
 #define IGMPV3_ALLOW_NEW_SOURCES 5
 #define IGMPV3_BLOCK_OLD_SOURCES 6
 
+/* IGMPv2 Membership Report structure */
+struct igmpv2_report {
+  uint8_t type;
+  uint8_t max_resp_time;
+  uint16_t csum;
+  uint32_t group_addr;
+} __attribute__((packed));
+
 /* IGMPv3 Membership Report structures */
 struct igmpv3_grec {
   uint8_t grec_type;
@@ -59,6 +68,53 @@ static uint16_t calculate_checksum(const void *data, size_t len) {
   return ~sum;
 }
 
+static int create_igmp_raw_socket(void) {
+  int raw_sock;
+  const char *upstream_if = get_upstream_interface_for_multicast();
+
+  raw_sock = socket(AF_INET, SOCK_RAW, IPPROTO_IGMP);
+  if (raw_sock < 0) {
+    logger(LOG_ERROR, "Failed to create raw IGMP socket: %s (need root?)",
+           strerror(errno));
+    return -1;
+  }
+
+  if (connection_set_nonblocking(raw_sock) < 0) {
+    logger(LOG_ERROR, "Failed to set raw IGMP socket non-blocking: %s",
+           strerror(errno));
+    close(raw_sock);
+    return -1;
+  }
+
+  bind_to_upstream_interface(raw_sock, upstream_if);
+
+  int hdrincl = 0;
+  if (setsockopt(raw_sock, IPPROTO_IP, IP_HDRINCL, &hdrincl, sizeof(hdrincl)) <
+      0) {
+    logger(LOG_WARN, "Failed to set IP_HDRINCL: %s", strerror(errno));
+  }
+
+  int router_alert = 1;
+  if (setsockopt(raw_sock, IPPROTO_IP, IP_ROUTER_ALERT, &router_alert,
+                 sizeof(router_alert)) < 0) {
+    logger(LOG_ERROR, "Failed to set IP_ROUTER_ALERT: %s", strerror(errno));
+    close(raw_sock);
+    return -1;
+  }
+
+  if (upstream_if && upstream_if[0] != '\0') {
+    struct ip_mreqn mreq;
+    memset(&mreq, 0, sizeof(mreq));
+    mreq.imr_ifindex = if_nametoindex(upstream_if);
+    if (setsockopt(raw_sock, IPPROTO_IP, IP_MULTICAST_IF, &mreq, sizeof(mreq)) <
+        0) {
+      logger(LOG_WARN, "Failed to set IP_MULTICAST_IF: %s", strerror(errno));
+    }
+  }
+
+  return raw_sock;
+}
+
 void bind_to_upstream_interface(int sock, const char *ifname) {
   if (ifname && ifname[0] != '\0') {
     struct ifreq ifr;
@@ -312,202 +368,130 @@ int join_mcast_group(service_t *service) {
   return sock;
 }
 
-/*
- * Rejoin multicast group by sending IGMPv3 Membership Report via raw socket
- *
- * Background:
- * In our multi-process architecture, each client connection maintains its own
- * multicast socket. When multiple clients are playing the same multicast
- * source, the kernel maintains a reference count for that multicast group
- * membership.
- *
- * Problem:
- * The traditional leave/join approach (MCAST_LEAVE_GROUP + MCAST_JOIN_GROUP)
- * will NOT trigger an IGMP Report in this scenario because:
- * 1. When we call MCAST_LEAVE_GROUP, the kernel decrements the reference count
- * 2. If other sockets still have membership (refcount > 0), no IGMP Leave is
- * sent
- * 3. When we call MCAST_JOIN_GROUP again, the kernel sees the group already
- * exists
- * 4. No IGMP Report is sent because the interface is still a member of the
- * group
- *
- * Solution:
- * We manually construct and send an IGMPv3 Membership Report packet using a
- * raw socket. This bypasses the kernel's membership tracking and ensures that
- * the upstream router receives periodic membership reports, preventing it from
- * timing out and stopping the multicast stream delivery.
- *
- * This is particularly important when:
- * - The upstream router requires periodic IGMP Reports (typical timeout: 3
- * minutes)
- * - We want to ensure we become the "Reporter" for the group
- * - Multiple worker processes are serving the same multicast stream
- *
- * @param service Service structure containing multicast group and optional
- * source
- * @return 0 on success, -1 on failure
- */
 int rejoin_mcast_group(service_t *service) {
   int raw_sock;
-  struct sockaddr_in dest;
-  struct igmpv3_report *report;
-  struct igmpv3_grec *grec;
-  uint8_t packet[sizeof(struct igmpv3_report) + sizeof(struct igmpv3_grec) +
-                 sizeof(uint32_t)];
-  size_t packet_len;
-  int r;
-  const char *upstream_if;
   struct sockaddr_in *mcast_addr;
   struct sockaddr_in *source_addr = NULL;
+  struct sockaddr_in dest;
+  struct igmpv2_report report_v2;
+  struct igmpv3_report *report_v3;
+  struct igmpv3_grec *grec;
+  uint8_t packet_v3[sizeof(struct igmpv3_report) + sizeof(struct igmpv3_grec) +
+                    sizeof(uint32_t)];
+  size_t packet_len_v3 = 0;
   uint32_t group_addr;
   uint16_t nsrcs = 0;
   int is_ssm = 0;
+  int result = -1;
+  int sent_v2 = 0;
+  int sent_v3 = 0;
 
-  /* Only support IPv4 for now */
   if (service->addr->ai_family != AF_INET) {
-    logger(LOG_ERROR, "IGMPv3 raw socket rejoin only supports IPv4");
+    logger(LOG_ERROR, "IGMP raw socket rejoin only supports IPv4");
     return -1;
   }
 
   mcast_addr = (struct sockaddr_in *)service->addr->ai_addr;
   group_addr = mcast_addr->sin_addr.s_addr;
 
-  /* Check if this is Source-Specific Multicast (SSM) */
   if (service->msrc != NULL && strcmp(service->msrc, "") != 0 &&
       service->msrc_addr != NULL) {
     if (service->msrc_addr->ai_family != AF_INET) {
-      logger(LOG_ERROR,
-             "IGMPv3 raw socket rejoin: source address must be IPv4");
+      logger(LOG_ERROR, "IGMP raw socket rejoin: source address must be IPv4");
       return -1;
     }
     source_addr = (struct sockaddr_in *)service->msrc_addr->ai_addr;
     is_ssm = 1;
     nsrcs = 1;
   }
 
-  /* Create raw socket for IGMP */
-  raw_sock = socket(AF_INET, SOCK_RAW, IPPROTO_IGMP);
+  raw_sock = create_igmp_raw_socket();
   if (raw_sock < 0) {
-    logger(LOG_ERROR, "Failed to create raw IGMP socket: %s (need root?)",
-           strerror(errno));
-    return -1;
-  }
-
-  /* Set socket to non-blocking mode to avoid blocking on sendto */
-  if (connection_set_nonblocking(raw_sock) < 0) {
-    logger(LOG_ERROR, "Failed to set raw IGMP socket non-blocking: %s",
-           strerror(errno));
-    close(raw_sock);
     return -1;
   }
 
-  /* Bind to upstream interface if specified */
-  upstream_if = get_upstream_interface_for_multicast();
-  bind_to_upstream_interface(raw_sock, upstream_if);
+  if (!is_ssm) {
+    memset(&report_v2, 0, sizeof(report_v2));
+    report_v2.type = IGMP_V2_MEMBERSHIP_REPORT;
+    report_v2.group_addr = group_addr;
+    report_v2.csum = calculate_checksum(&report_v2, sizeof(report_v2));
 
-  /* Set IP_HDRINCL to 0 - kernel will add IP header */
-  int hdrincl = 0;
-  if (setsockopt(raw_sock, IPPROTO_IP, IP_HDRINCL, &hdrincl, sizeof(hdrincl)) <
-      0) {
-    logger(LOG_WARN, "Failed to set IP_HDRINCL: %s", strerror(errno));
-  }
-
-  /* Set Router Alert option - required for IGMP packets (RFC 3376) */
-  int router_alert = 1;
-  if (setsockopt(raw_sock, IPPROTO_IP, IP_ROUTER_ALERT, &router_alert,
-                 sizeof(router_alert)) < 0) {
-    logger(LOG_ERROR, "Failed to set IP_ROUTER_ALERT: %s", strerror(errno));
-    close(raw_sock);
-    return -1;
-  }
+    memset(&dest, 0, sizeof(dest));
+    dest.sin_family = AF_INET;
+    dest.sin_addr.s_addr = inet_addr("224.0.0.2");
 
-  /* Set IP_MULTICAST_IF to send from correct interface */
-  if (upstream_if && upstream_if[0] != '\0') {
-    struct ip_mreqn mreq;
-    memset(&mreq, 0, sizeof(mreq));
-    mreq.imr_ifindex = if_nametoindex(upstream_if);
-    if (setsockopt(raw_sock, IPPROTO_IP, IP_MULTICAST_IF, &mreq, sizeof(mreq)) <
-        0) {
-      logger(LOG_WARN, "Failed to set IP_MULTICAST_IF: %s", strerror(errno));
+    if (sendto(raw_sock, &report_v2, sizeof(report_v2), 0,
+               (struct sockaddr *)&dest, sizeof(dest)) < 0) {
+      logger(LOG_ERROR, "Failed to send IGMPv2 Report: %s", strerror(errno));
+    } else {
+      sent_v2 = 1;
+      char group_str[INET_ADDRSTRLEN];
+      inet_ntop(AF_INET, &mcast_addr->sin_addr, group_str, sizeof(group_str));
+      logger(LOG_DEBUG,
+             "Multicast: Sent IGMPv2 Report for ASM group %s via raw socket",
+             group_str);
     }
+  } else {
+    logger(LOG_DEBUG, "Skipping IGMPv2 report for SSM subscription");
   }
 
-  /* Construct IGMPv3 Membership Report packet */
-  memset(packet, 0, sizeof(packet));
-
-  report = (struct igmpv3_report *)packet;
-  report->type = IGMP_V3_MEMBERSHIP_REPORT;
-  report->resv1 = 0;
-  report->csum = 0; /* Will calculate later */
-  report->resv2 = 0;
-  report->ngrec = htons(1); /* One group record */
+  memset(packet_v3, 0, sizeof(packet_v3));
+  report_v3 = (struct igmpv3_report *)packet_v3;
+  report_v3->type = IGMP_V3_MEMBERSHIP_REPORT;
+  report_v3->ngrec = htons(1);
 
-  /* Group Record */
-  grec = (struct igmpv3_grec *)(packet + sizeof(struct igmpv3_report));
+  grec = (struct igmpv3_grec *)(packet_v3 + sizeof(struct igmpv3_report));
 
   if (is_ssm) {
-    /* Source-Specific Multicast: MODE_IS_INCLUDE with source list */
     grec->grec_type = IGMPV3_MODE_IS_INCLUDE;
-    grec->grec_auxwords = 0;
     grec->grec_nsrcs = htons(nsrcs);
     grec->grec_mca = group_addr;
-
-    /* Add source address to the source list */
     uint32_t *src_list =
         (uint32_t *)((uint8_t *)grec + sizeof(struct igmpv3_grec));
     src_list[0] = source_addr->sin_addr.s_addr;
-
-    packet_len = sizeof(struct igmpv3_report) + sizeof(struct igmpv3_grec) +
-                 sizeof(uint32_t);
+    packet_len_v3 = sizeof(struct igmpv3_report) + sizeof(struct igmpv3_grec) +
+                    sizeof(uint32_t);
   } else {
-    /* Any-Source Multicast (ASM): MODE_IS_EXCLUDE with empty source list */
-    grec->grec_type = IGMPV3_MODE_IS_EXCLUDE; /* Exclude mode = join group,
-                                                 receive all sources */
-    grec->grec_auxwords = 0;
-    grec->grec_nsrcs =
-        htons(0); /* No source list in exclude mode = receive from any source */
-    grec->grec_mca = group_addr; /* Multicast group address (already in network
-                                    byte order) */
-
-    packet_len = sizeof(struct igmpv3_report) + sizeof(struct igmpv3_grec);
+    grec->grec_type = IGMPV3_MODE_IS_EXCLUDE;
+    grec->grec_mca = group_addr;
+    packet_len_v3 = sizeof(struct igmpv3_report) + sizeof(struct igmpv3_grec);
   }
 
-  /* Calculate checksum */
-  report->csum = calculate_checksum(packet, packet_len);
+  report_v3->csum = calculate_checksum(packet_v3, packet_len_v3);
 
-  /* Destination: 224.0.0.22 (IGMPv3 reports destination) */
   memset(&dest, 0, sizeof(dest));
   dest.sin_family = AF_INET;
   dest.sin_addr.s_addr = inet_addr("224.0.0.22");
 
-  /* Send the IGMPv3 Report */
-  r = sendto(raw_sock, packet, packet_len, 0, (struct sockaddr *)&dest,
-             sizeof(dest));
-
-  if (r < 0) {
+  if (sendto(raw_sock, packet_v3, packet_len_v3, 0, (struct sockaddr *)&dest,
+             sizeof(dest)) < 0) {
     logger(LOG_ERROR, "Failed to send IGMPv3 Report: %s", strerror(errno));
-    close(raw_sock);
-    return -1;
+  } else {
+    sent_v3 = 1;
+    char group_str[INET_ADDRSTRLEN];
+    inet_ntop(AF_INET, &mcast_addr->sin_addr, group_str, sizeof(group_str));
+    if (is_ssm) {
+      char source_str[INET_ADDRSTRLEN];
+      inet_ntop(AF_INET, &source_addr->sin_addr, source_str,
+                sizeof(source_str));
+      logger(LOG_DEBUG,
+             "Multicast: Sent IGMPv3 Report for SSM group %s source %s via raw "
+             "socket",
+             group_str, source_str);
+    } else {
+      logger(LOG_DEBUG,
+             "Multicast: Sent IGMPv3 Report for ASM group %s via raw socket",
+             group_str);
+    }
   }
 
   close(raw_sock);
 
-  char group_str[INET_ADDRSTRLEN];
-  inet_ntop(AF_INET, &mcast_addr->sin_addr, group_str, sizeof(group_str));
-
-  if (is_ssm) {
-    char source_str[INET_ADDRSTRLEN];
-    inet_ntop(AF_INET, &source_addr->sin_addr, source_str, sizeof(source_str));
-    logger(LOG_DEBUG,
-           "Multicast: Sent IGMPv3 Report for SSM group %s source %s via raw "
-           "socket",
-           group_str, source_str);
+  if (sent_v2 || sent_v3) {
+    result = 0;
   } else {
-    logger(LOG_DEBUG,
-           "Multicast: Sent IGMPv3 Report for ASM group %s via raw socket",
-           group_str);
+    logger(LOG_ERROR, "Multicast: Failed to send IGMPv2 and IGMPv3 reports");
   }
 
-  return 0;
+  return result;
 }

src/multicast.h

@@ -56,12 +56,12 @@ uint32_t get_local_ip_for_fcc(void);
 int join_mcast_group(service_t *service);
 
 /**
- * Rejoin a multicast group on an existing socket
- * This performs MCAST_LEAVE_GROUP followed by MCAST_JOIN_GROUP to force
- * the kernel to send a new IGMP Report message, refreshing membership.
+ * Rejoin a multicast group by sending both IGMPv2 and IGMPv3 reports via raw
+ * sockets. Ensures upstream devices refresh membership state even when the
+ * kernel suppresses joins due to existing memberships.
  *
  * @param service Service structure containing multicast address info
- * @return 0 on success, -1 on failure
+ * @return 0 on success, -1 if both IGMP versions fail
  */
 int rejoin_mcast_group(service_t *service);