fix(multi_stream): join multicast group on EVERY local IPv4 interface

Replaces the single INADDR_ANY join in `_create_socket()` with an
explicit join on every UP IPv4 interface, via SIOCGIFADDR enumeration.

With INADDR_ANY the kernel selects one interface based on the routing
table (typically the default-route eth/ens0).  That works for the
common case where radiod is remote and packets arrive over the
network — but on a co-located radiod (TTL=0) the packets emerge on
`lo` and never get delivered to a socket joined only on ens0.  The
3.14.0 per-(client, radiod) multicast destinations exposed this
because the legacy "everyone shares one group" path happens to be
joined on multiple interfaces by other listeners on the same host.

Symptom that motivated this fix (B4-100, 2026-05-13):
  * wspr-recorder, after upgrading to ka9q-python 3.14.0 and passing
    client_id="wspr-recorder", saw zero RTP packets.
  * `ip maddr show` showed the per-client group joined only on ens18.
  * `tcpdump -i lo` confirmed radiod was sending the packets, but
    they never reached the recorder.
  * Joining on lo + ens18 (both interfaces) immediately restored
    sample flow; all 13 WSPR bands resumed cleanly (1,440,000 samples
    per cycle, 0 gaps).

The same pattern matters for multi-homed stations: a single
MultiStream consumer should receive radiod output regardless of
which interface the producer's packets arrive on.  Joining on every
local IPv4 interface makes that transparent.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: rrobinett

ka9q/multi_stream.py

@@ -39,6 +39,7 @@
     multi.stop()
 """
 
+import fcntl
 import logging
 import socket
 import struct
@@ -59,6 +60,75 @@
 logger = logging.getLogger(__name__)
 
 
+# Linux SIOCGIFADDR — fetch IPv4 of an interface by name.  Used to enumerate
+# every UP IPv4 interface so the multicast group join can be made on each
+# of them.  Without this, joining with INADDR_ANY lets the kernel pick a
+# single interface (typically the default-route one), which misses:
+#
+#   * Loopback-only multicast emitted by a co-located radiod with TTL=0
+#     (packets sit on `lo`; the kernel won't deliver them to a socket
+#     joined on `ens0`).
+#   * Multi-homed stations where one radiod streams on lo and another
+#     on eth: a single MultiStream should consume both.
+#
+# Joining on EVERY local IPv4 interface lets one socket receive from any
+# radiod source on any path.
+_SIOCGIFADDR = 0x8915
+
+
+def _iter_local_ipv4_interfaces():
+    """Yield (ifname, ipv4_addr_str) for every local interface with an IPv4.
+
+    Order is `socket.if_nameindex()` order — typically 'lo' first, then
+    ens0/eth0/wlan0/etc.  Interfaces without an IPv4 (IPv6-only, or
+    freshly-created with no addr) are skipped silently.  Stays
+    stdlib-only on Linux (no netifaces/psutil dependency).
+    """
+    try:
+        names = socket.if_nameindex()
+    except OSError:
+        return
+    probe = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    try:
+        for _idx, ifname in names:
+            try:
+                raw = fcntl.ioctl(
+                    probe.fileno(),
+                    _SIOCGIFADDR,
+                    struct.pack("256s", ifname.encode()[:15]),
+                )
+                addr = socket.inet_ntoa(raw[20:24])
+            except OSError:
+                continue
+            yield ifname, addr
+    finally:
+        probe.close()
+
+
+def _join_multicast_all_interfaces(sock: socket.socket,
+                                   multicast_address: str) -> List[str]:
+    """Join `multicast_address` on every local IPv4 interface.
+
+    Returns the list of interface names where the join succeeded.  Empty
+    list means no interface was usable (extremely rare — even a freshly-
+    booted box has `lo`).  Per-interface failures are logged at DEBUG
+    and skipped (e.g., a virtual interface without an IPv4).
+    """
+    joined: List[str] = []
+    group = socket.inet_aton(multicast_address)
+    for ifname, ifaddr in _iter_local_ipv4_interfaces():
+        mreq = struct.pack("=4s4s", group, socket.inet_aton(ifaddr))
+        try:
+            sock.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)
+            joined.append(ifname)
+        except OSError as exc:
+            logger.debug(
+                "multicast join on %s (%s) failed: %s",
+                ifname, ifaddr, exc,
+            )
+    return joined
+
+
 @dataclass
 class _ChannelSlot:
     """Per-SSRC state within a MultiStream."""
@@ -322,12 +392,25 @@ def _create_socket(self) -> socket.socket:
 
         sock.bind(("0.0.0.0", self._port))
 
-        mreq = struct.pack(
-            "=4s4s",
-            socket.inet_aton(self._multicast_address),
-            socket.inet_aton("0.0.0.0"),
+        # Join the multicast group on EVERY local IPv4 interface, not
+        # via INADDR_ANY (which lets the kernel pick a single interface
+        # — typically the default route — and silently misses radiod
+        # outputs on other paths, e.g. TTL=0 loopback packets from a
+        # co-located radiod).
+        joined = _join_multicast_all_interfaces(
+            sock, self._multicast_address,
         )
-        sock.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)
+        if not joined:
+            logger.warning(
+                "MultiStream: no interface accepted the multicast "
+                "join for %s — recvfrom() will return nothing",
+                self._multicast_address,
+            )
+        else:
+            logger.debug(
+                "MultiStream: joined %s on interfaces: %s",
+                self._multicast_address, ", ".join(joined),
+            )
         sock.settimeout(1.0)
         return sock