Bring async receive_udp ignore_errors in line with the sync one (#1297)

ignore_errors means "discard the datagram and keep listening for a valid
response", but dns.asyncquery.receive_udp() passed continue_on_error to
from_wire(), so a datagram with a valid header and an unparsable body was
returned with its errors recorded instead of being skipped.

Also removes the ignore_errors parameter added to
dns.asyncquery.receive_tcp() at the same time; dns.query.receive_tcp()
has no such parameter and nothing passes it.

Co-authored-by: Dylan Pulver <dylanpulver@users.noreply.github.com>

Author: dylanpulver

dns/asyncquery.py

@@ -160,7 +160,6 @@ async def receive_udp(
                 one_rr_per_rrset=one_rr_per_rrset,
                 ignore_trailing=ignore_trailing,
                 raise_on_truncation=raise_on_truncation,
-                continue_on_error=ignore_errors,
             )
         except dns.message.Truncated as e:
             # See the comment in query.py for details.
@@ -363,7 +362,6 @@ async def receive_tcp(
     keyring: dict[dns.name.Name, dns.tsig.Key] | None = None,
     request_mac: bytes | None = b"",
     ignore_trailing: bool = False,
-    ignore_errors: bool = False,
 ) -> tuple[dns.message.Message, float]:
     """Read a DNS message from a TCP socket.
 
@@ -384,7 +382,6 @@ async def receive_tcp(
         request_mac=request_mac,
         one_rr_per_rrset=one_rr_per_rrset,
         ignore_trailing=ignore_trailing,
-        continue_on_error=ignore_errors,
     )
     return (r, received_time)
 

doc/whatsnew.rst

@@ -60,6 +60,13 @@ TBD
 
 * The async `zone_from_name()` function now behaves the same as the sync version.
 
+* `dns.asyncquery.receive_udp()` with ``ignore_errors`` set again discards a datagram
+  that fails to parse and keeps listening for a valid response, matching
+  `dns.query.receive_udp()`.  It had been returning the unparsable datagram with its
+  errors recorded on the message.  The unused ``ignore_errors`` parameter added to
+  `dns.asyncquery.receive_tcp()` at the same time has been removed, as the sync
+  version has no such parameter.
+
 * Documentation has been augmented and modernized.
 
 * The HHIT and BRID rdata types are now supported, and the NXNAME metatype is defined.

tests/test_async.py

@@ -972,6 +972,31 @@ async def run():
 
         self.async_run(run)
 
+    def test_unparsable_wire_is_skipped_not_salvaged(self):
+        # ignore_errors means "keep listening for a valid response", so a
+        # datagram that fails to parse must be discarded rather than returned
+        # with its parse errors recorded.  The first datagram below has a
+        # valid header and a different rcode, so returning it instead of the
+        # second one is detectable.
+        async def run():
+            bad_r = dns.message.make_response(self.q)
+            bad_r.set_rcode(dns.rcode.SERVFAIL)
+            bad_r_wire = bad_r.to_wire() + b"abcd"
+            s = MockSock(
+                bad_r_wire, ("127.0.0.1", 53), self.good_r_wire, ("127.0.0.1", 53)
+            )
+            r, _, _ = await dns.asyncquery.receive_udp(
+                s,
+                ("127.0.0.1", 53),
+                time.time() + 2,
+                ignore_errors=True,
+                query=self.q,
+            )
+            self.assertEqual(r, self.good_r)
+            self.assertEqual(r.errors, [])
+
+        self.async_run(run)
+
     def test_trailing_wire_not_ignored(self):
         wire = self.good_r_wire + b"abcd"
 

tests/test_query.py

@@ -864,6 +864,30 @@ def test_trailing_wire(self):
         wire = self.good_r_wire + b"abcd"
         self.mock_receive(wire, ("127.0.0.1", 53), self.good_r_wire, ("127.0.0.1", 53))
 
+    def test_unparsable_wire_is_skipped_not_salvaged(self):
+        # The twin of the dns.asyncquery test of the same name.  The first
+        # datagram has a valid header and a different rcode, so returning it
+        # instead of the second one is detectable.
+        bad_r = dns.message.make_response(self.q)
+        bad_r.set_rcode(dns.rcode.SERVFAIL)
+        bad_r_wire = bad_r.to_wire() + b"abcd"
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        try:
+            with mock_udp_recv(
+                bad_r_wire, ("127.0.0.1", 53), self.good_r_wire, ("127.0.0.1", 53)
+            ):
+                r, _ = dns.query.receive_udp(
+                    s,
+                    ("127.0.0.1", 53),
+                    time.time() + 2,
+                    ignore_errors=True,
+                    query=self.q,
+                )
+                self.assertEqual(r, self.good_r)
+                self.assertEqual(r.errors, [])
+        finally:
+            s.close()
+
     def test_trailing_wire_not_ignored(self):
         wire = self.good_r_wire + b"abcd"