fix: make rescan resilient to a transient empty set and per-interface bind failure

bdraco · bdraco · commit 423f8752e972 · 2026-06-22T10:45:09.000-05:00
normalize_interface_choice raises RuntimeError for an All/Default instance
that transiently resolves to zero addresses during adapter churn; catch it as
a logged no-op so a momentary down state doesn't crash a caller's
adapter-change handler. Make a per-interface endpoint-creation failure roll
back and skip (log_warning_once) rather than abort the whole reconcile, so
other interfaces still come up and get re-announced, matching the documented
best-effort contract. Log a non-Windows IPV6_MULTICAST_IF read failure at
warning (Windows WSAEINVAL stays debug) since a wrong-index leave leaks the
membership.
diff --git a/src/zeroconf/_engine.py b/src/zeroconf/_engine.py
@@ -211,7 +211,16 @@ async def async_update_interfaces(
         added, so the caller can skip re-announcing when nothing appeared.
         """
         assert self.loop is not None
-        normalized = normalize_interface_choice(interfaces, ip_version)
+        try:
+            normalized = normalize_interface_choice(interfaces, ip_version)
+        except RuntimeError as exc:
+            # An All/Default instance can transiently resolve to zero addresses
+            # during adapter churn, where normalize_interface_choice raises
+            # instead of returning an empty set. Treat that as a logged no-op so
+            # a momentary down state doesn't crash a caller's adapter-change
+            # handler (best-effort contract); the next rescan reconciles.
+            log.warning("Skipping interface update; no interfaces available: %s", exc)
+            return False
         desired = {_interface_key(interface): interface for interface in normalized}
         current = {wrapped.interface_key: wrapped for wrapped in self.senders}
         listen_transport = self._listen_transport
@@ -291,13 +300,16 @@ async def _async_add_interface(
             return False
         try:
             await self._async_wrap_socket(respond_socket, is_sender=True)
-        except Exception:
+        except Exception as exc:
             # Endpoint creation failed after the join/socket succeeded; roll
-            # this interface back so it leaves no dangling group membership.
+            # this interface back so it leaves no dangling group membership, then
+            # log and skip rather than abort the whole reconcile so the other
+            # interfaces still come up (best-effort bring-up).
             respond_socket.close()
             if listen_socket is not None:
                 drop_multicast_member(listen_socket, interface)
-            raise
+            self.zc.log_warning_once(f"Interface {interface!r} not added: {exc}")
+            return False
         return True
 
     def _async_remove_transport(self, transport: asyncio.DatagramTransport) -> None:
diff --git a/src/zeroconf/_transport.py b/src/zeroconf/_transport.py
@@ -23,7 +23,9 @@
 from __future__ import annotations
 
 import asyncio
+import logging
 import socket
+import sys
 from typing import cast
 
 from ._logger import log
@@ -111,7 +113,12 @@ def make_wrapped_transport(transport: asyncio.DatagramTransport) -> _WrappedTran
         try:
             multicast_index = sock.getsockopt(socket.IPPROTO_IPV6, socket.IPV6_MULTICAST_IF)
         except OSError as exc:
-            log.debug("Unable to read IPV6_MULTICAST_IF, using default index 0: %s", exc)
+            # Windows rejects this read (WSAEINVAL) for every v6 socket, so it is
+            # expected and benign there; keep it at debug. Elsewhere a failure is
+            # unexpected and means a later group leave uses the wrong index (a
+            # benign no-op that leaks the membership), so surface it at warning.
+            level = logging.DEBUG if sys.platform == "win32" else logging.WARNING
+            log.log(level, "Unable to read IPV6_MULTICAST_IF, using default index 0: %s", exc)
     return _WrappedTransport(
         transport=transport,
         is_ipv6=is_ipv6,
diff --git a/tests/test_interface_update.py b/tests/test_interface_update.py
@@ -10,7 +10,7 @@
 
 import pytest
 
-from zeroconf import IPVersion, ServiceInfo, Zeroconf, _engine, _listener
+from zeroconf import InterfaceChoice, IPVersion, ServiceInfo, Zeroconf, _engine, _listener
 from zeroconf._engine import _interface_key, _listen_socket_supports
 from zeroconf._transport import _strip_zone, _WrappedTransport, make_wrapped_transport
 from zeroconf.asyncio import AsyncZeroconf
@@ -432,6 +432,34 @@ async def fake_wrap(sock: object, is_sender: bool) -> _WrappedTransport:
     assert engine.senders[0].interface_key == ("10.0.0.9", 0)
 
 
+@pytest.mark.asyncio
+async def test_update_interfaces_transient_empty_set_is_noop(
+    aiozc_loopback: AsyncZeroconf, caplog: pytest.LogCaptureFixture
+) -> None:
+    """An All instance that transiently resolves to zero interfaces logs and no-ops."""
+    zc = aiozc_loopback.zeroconf
+    await zc.async_wait_for_start()
+    engine = zc.engine
+    before = (len(engine.senders), len(engine.readers), len(engine.protocols))
+
+    # normalize_interface_choice raises for an All instance with no addresses
+    # (adapter churn); the rescan must not crash the caller's handler.
+    with (
+        patch.object(
+            _engine,
+            "normalize_interface_choice",
+            side_effect=RuntimeError("No interfaces to listen on"),
+        ),
+        caplog.at_level(logging.WARNING),
+    ):
+        added = await engine.async_update_interfaces(InterfaceChoice.All, IPVersion.All, False)
+
+    assert added is False
+    assert "Skipping interface update; no interfaces available" in caplog.text
+    # Current sockets are left intact rather than torn down.
+    assert (len(engine.senders), len(engine.readers), len(engine.protocols)) == before
+
+
 @pytest.mark.asyncio
 async def test_update_interfaces_add_failure_adds_no_sender(aiozc_loopback: AsyncZeroconf) -> None:
     """An interface that fails to come up adds no responder socket."""
@@ -450,7 +478,7 @@ async def test_update_interfaces_add_failure_adds_no_sender(aiozc_loopback: Asyn
 async def test_update_interfaces_rolls_back_membership_on_wrap_failure(
     aiozc_loopback: AsyncZeroconf,
 ) -> None:
-    """If endpoint creation raises, the interface's join and socket are rolled back."""
+    """Endpoint creation failing rolls the interface back and is skipped, not raised."""
     zc = aiozc_loopback.zeroconf
     await zc.async_wait_for_start()
     await aiozc_loopback.async_update_interfaces([])
@@ -462,15 +490,14 @@ async def test_update_interfaces_rolls_back_membership_on_wrap_failure(
         patch.object(_engine, "add_interface", return_value=fake_socket),
         patch.object(_engine, "drop_multicast_member") as mock_drop,
         patch.object(_engine.AsyncEngine, "_async_wrap_socket", new=AsyncMock(side_effect=OSError("boom"))),
-        pytest.raises(OSError),
     ):
+        # Best-effort: the failure is logged and skipped, not propagated.
         await aiozc_loopback.async_update_interfaces(["127.0.0.1"])
 
-    # The just-joined membership was dropped, the socket closed, and the
-    # failed reconcile left the retained config unchanged.
+    # The just-joined membership was dropped, the socket closed, no sender added.
     mock_drop.assert_called_once()
     fake_socket.close.assert_called_once()
-    assert zc._interfaces == []
+    assert zc.engine.senders == []
 
 
 @pytest.mark.asyncio
@@ -484,10 +511,10 @@ async def test_add_interface_rollback_without_listen_socket(aiozc_loopback: Asyn
         patch.object(_engine, "add_interface", return_value=fake_socket),
         patch.object(_engine, "drop_multicast_member") as mock_drop,
         patch.object(_engine.AsyncEngine, "_async_wrap_socket", new=AsyncMock(side_effect=OSError("boom"))),
-        pytest.raises(OSError),
     ):
-        await engine._async_add_interface("127.0.0.1", None, False)
+        added = await engine._async_add_interface("127.0.0.1", None, False)
 
+    assert added is False
     fake_socket.close.assert_called_once()
     mock_drop.assert_not_called()
 
