`BrokenResourceError` is the wrong error for a temporary Windows UDP reset

[graingert]

Things to check first

• I have searched the existing issues and didn't find my bug already reported there

• I have checked that my bug is still present in the latest release

AnyIO version

4.14.2

Python version

3.14

What happened?

On Windows, sending a UDP datagram to an address with nothing bound to it can cause a
later receive on the same socket to observe WSAECONNRESET (WinError 10054).

however after this error

• the socket still works
• a later receive() can still time out normally
• once a real peer starts sending, the same socket can still receive datagrams

That means this is a temporary per-datagram condition, not a terminal resource
failure. Raising anyio.BrokenResourceError is therefore misleading, because
BrokenResourceError implies the resource is no longer usable.

How can we reproduce the bug?

import socket

import anyio
from anyio.abc import SocketAttribute


async def main() -> None:
    errors = []
    async with await anyio.create_udp_socket(
        family=socket.AF_INET, local_host="127.0.0.1"
    ) as udp:
        # An address on loopback with nothing bound to it.
        probe = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        probe.bind(("127.0.0.1", 0))
        dead_host, dead_port = probe.getsockname()
        probe.close()

        # Provokes an ICMP port-unreachable back to `udp` on Windows.
        await udp.sendto(b"ping", dead_host, dead_port)

        # Windows + trio:    raises anyio.BrokenResourceError (WinError 10054),
        #                    even though `udp` is still perfectly usable.
        # Windows + asyncio: no error; this times out waiting for real data.
        try:
            with anyio.fail_after(2):
                await udp.receive()
        except TimeoutError:
            print("timeout out correctly 1")
        except anyio.BrokenResourceError as e:
            errors.append(e)
        else:
            errors.append(AssertionError("did not timeout"))

        try:
            with anyio.fail_after(2):
                await udp.receive()
        except TimeoutError:
            print("timeout out correctly 2")
        except anyio.BrokenResourceError as e:
            errors.append(e)
        else:
            errors.append(AssertionError("did not timeout"))

        local_host, local_port = udp.extra(SocketAttribute.local_address)

        server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        try:
            server.bind((dead_host, dead_port))
            server.sendto(b"pong", (local_host, local_port))
        finally:
            server.close()

        try:
            data, addr = await udp.receive()
        except Exception as e:
            errors.append(e)
        else:
            print(f"recieved {data}")
            if data != b"pong":
                errors.append(AssertionError(f"unexpected payload: {data!r}"))
            if addr != (dead_host, dead_port):
                errors.append(AssertionError(f"unexpected peer: {addr!r}"))

    if errors:
        raise ExceptionGroup("socket errors", errors)


anyio.run(main, backend="trio")   # vs. backend="asyncio"

on windows prints:

timeout out correctly 2
recieved b'pong'

then raises the BrokenResourceError in an ExceptionGroup

[agronholm]

Shouldn't an equivalent error be triggered on other operating systems too? What should be done about it then?

[graingert]

A similar issue happens on Linux:

import socket

import anyio
from anyio.abc import SocketAttribute, TaskStatus


async def echo_server(
    port: int,
    *,
    task_status: TaskStatus[None] = anyio.TASK_STATUS_IGNORED,
) -> None:
    async with await anyio.create_udp_socket(
        family=socket.AF_INET,
        local_host="127.0.0.1",
        local_port=port,
    ) as server:
        print(f"Server listening on 127.0.0.1:{port}")
        task_status.started()

        data, address = await server.receive()
        print(f"Server received {data!r} from {address}")

        await server.send((b"echo: " + data, address))
        print("Server sent reply")


async def main() -> None:
    # Bind an ephemeral UDP port, record it, and close the socket.
    # Sending to this now-closed port should cause an ICMP Port Unreachable.
    async with await anyio.create_udp_socket(
        family=socket.AF_INET,
        local_host="127.0.0.1",
        local_port=0,
    ) as probe:
        local_address = probe.extra(SocketAttribute.local_address)
        port = local_address[1]

    print(f"Reserved and closed UDP port {port}")

    # Create one connected UDP socket and keep using the same socket
    # throughout the entire demonstration.
    async with await anyio.create_connected_udp_socket(
        remote_host="127.0.0.1",
        remote_port=port,
        family=socket.AF_INET,
    ) as client:
        print(f"Sending first message to closed port {port}")
        await client.send(b"first message")

        try:
            with anyio.fail_after(2):
                data = await client.receive()
            print(f"Unexpectedly received {data!r}")
        except anyio.BrokenResourceError as exc:
            print(f"Got expected BrokenResourceError: {exc!r}")
        except TimeoutError:
            print(
                "Timed out waiting for BrokenResourceError; "
                "the platform did not report the ICMP error"
            )
            return

        print("Attempting receive again after BrokenResourceError")

        # There is currently no server, so this receive should remain pending.
        # Start the server shortly afterwards, send another message using the
        # same client socket, and let the pending receive collect its reply.
        async with anyio.create_task_group() as task_group:
            await task_group.start(echo_server, port)

            print("Sending second message using the same client socket")
            await client.send(b"second message")

            with anyio.fail_after(2):
                response = await client.receive()

            print(f"Client received after BrokenResourceError: {response!r}")

            task_group.cancel_scope.cancel()


anyio.run(main, backend="trio")

~ $ python demo.py
Reserved and closed UDP port 36241
Sending first message to closed port 36241
Got expected BrokenResourceError: BrokenResourceError()
Attempting receive again after BrokenResourceError
Server listening on 127.0.0.1:36241
Sending second message using the same client socket
Server received b'second message' from ('127.0.0.1', 60466)
Client received after BrokenResourceError: b'echo: second message'
Server sent reply

[graingert]

It should behave the same on asyncio but error_recieved doesn't wake the reader:

https://github.com/agronholm/anyio/blob/master/src/anyio/_backends/_asyncio.py#L1312

def error_received(self, exc: Exception) -> None:
    self.exception = exc
    self.read_event.set()