refactor: extract bounded TC-deferral fire-time into a cdef helper

bluetoothbot · bluetoothbot · commit 2cad649dfe64 · 2026-05-20T00:31:50.000Z
diff --git a/src/zeroconf/_listener.pxd b/src/zeroconf/_listener.pxd
@@ -39,7 +39,10 @@ cdef class AsyncListener:
 
     cdef _cancel_any_timers_for_addr(self, object addr)
 
-    @cython.locals(incoming=DNSIncoming, deferred=list, now=double, delay=double, deadline=object, fire_at=double)
+    @cython.locals(deadline=object, fire_at=double)
+    cdef double _compute_deferred_fire_at(self, object addr, double now, double delay)
+
+    @cython.locals(incoming=DNSIncoming, deferred=list, now=double, delay=double, fire_at=double)
     cpdef handle_query_or_defer(
         self,
         DNSIncoming msg,
diff --git a/src/zeroconf/_listener.py b/src/zeroconf/_listener.py
@@ -209,18 +209,9 @@ def handle_query_or_defer(
         assert loop is not None
         now = loop.time()
         delay = millis_to_seconds(random.randint(*_TC_DELAY_RANDOM_INTERVAL))  # noqa: S311
-        # Bound the assembly window to first_arrival + max delay so a peer
-        # streaming TC packets cannot keep deferring the flush indefinitely.
-        deadline = self._deferred_deadlines.get(addr)
-        if deadline is None:
-            deadline = now + millis_to_seconds(_TC_DELAY_RANDOM_INTERVAL[1])
-            self._deferred_deadlines[addr] = deadline
-        fire_at = now + delay
-        if fire_at >= deadline:
-            # Existing timer (if any) already fires at or before the deadline.
-            if addr in self._timers:
-                return
-            fire_at = deadline
+        fire_at = self._compute_deferred_fire_at(addr, now, delay)
+        if fire_at < 0.0:
+            return
         self._cancel_any_timers_for_addr(addr)
         self._timers[addr] = loop.call_at(
             fire_at,
@@ -232,6 +223,21 @@ def handle_query_or_defer(
             v6_flow_scope,
         )
 
+    def _compute_deferred_fire_at(self, addr: _str, now: _float, delay: _float) -> _float:
+        """Return the bounded call_at time for a TC-deferred flush, or -1.0 to keep the existing timer."""
+        # RFC 6762 §18.5 frames the random delay as a fixed reassembly budget
+        # starting at first arrival, not a sliding heartbeat.
+        deadline = self._deferred_deadlines.get(addr)
+        if deadline is None:
+            deadline = now + millis_to_seconds(_TC_DELAY_RANDOM_INTERVAL[1])
+            self._deferred_deadlines[addr] = deadline
+        fire_at = now + delay
+        if fire_at >= deadline:
+            if addr in self._timers:
+                return -1.0
+            return deadline
+        return fire_at
+
     def _cancel_any_timers_for_addr(self, addr: _str) -> None:
         """Cancel any future truncated packet timers for the address."""
         if addr in self._timers:
diff --git a/tests/test_core.py b/tests/test_core.py
@@ -20,7 +20,7 @@
 
 import zeroconf as r
 from zeroconf import NotRunningException, Zeroconf, const, current_time_millis
-from zeroconf._listener import AsyncListener, _WrappedTransport
+from zeroconf._listener import _TC_DELAY_RANDOM_INTERVAL, AsyncListener, _WrappedTransport
 from zeroconf._protocol.incoming import DNSIncoming
 from zeroconf.asyncio import AsyncZeroconf
 
@@ -776,7 +776,8 @@ def test_tc_bit_defer_window_is_bounded():
 
     # Pin the per-packet delay at its maximum so any subsequent reset would
     # land past the deadline established by the first packet.
-    with patch("zeroconf._listener.random.randint", return_value=500):
+    max_delay_ms = _TC_DELAY_RANDOM_INTERVAL[1]
+    with patch("zeroconf._listener.random.randint", return_value=max_delay_ms):
         threadsafe_query(zc, protocol, r.DNSIncoming(packets[0]), source_ip, const._MDNS_PORT, Mock(), ())
         first_when = protocol._timers[source_ip].when()
 
