AnyIOStream.start_tls leaves the TCP socket open when the TLS handshake is cancelled

[kkyrian]

If a request is cancelled during the TLS handshake, httpcore does not close the TCP socket. The socket stays open until the server closes it. This is not the proxy-tunnel case in #905 and #921, but a direct connection.

Versions

httpcore 1.0.9 (the code is the same on master), anyio 4.14.2 and 4.15.1, Python 3.14.6, asyncio.

Reproduction

A server that accepts the TCP connection but never answers the TLS handshake, and a request cancelled during the handshake:

import asyncio, gc, socket, httpx

async def main():
    listener = socket.socket(); listener.bind(("127.0.0.1", 0)); listener.listen(); listener.setblocking(False)
    async with httpx.AsyncClient() as client:
        task = asyncio.create_task(client.get(f"https://127.0.0.1:{listener.getsockname()[1]}/"))
        await asyncio.sleep(0.2)            # the TCP connect is done; the handshake waits for a reply that never comes
        task.cancel()
        await asyncio.gather(task, return_exceptions=True)
        del task; gc.collect(); await asyncio.sleep(0.1)
        server_side, _ = listener.accept(); server_side.setblocking(False)
        try:
            while server_side.recv(1 << 16):   # read the ClientHello
                pass
            print("closed")
        except BlockingIOError:
            print("open")
        print(len(asyncio.get_running_loop()._selector.get_map()))  # sockets the event loop still watches

asyncio.run(main())

Expected

closed and 1: the socket is closed once the cancelled request returns.

Actual

open and 2: the socket is still open and still watched by the event loop, so garbage collection does not close it either.

Cause

AnyIOStream.start_tls (httpcore/_backends/anyio.py) closes the stream only on Exception:

            except Exception as exc:  # pragma: nocover
                await self.aclose()
                raise exc

A cancellation raises CancelledError, which is a BaseException, so this branch does not run. TrioStream.start_tls (httpcore/_backends/trio.py) has the same except Exception.

Suggested fix

In both backends, catch BaseException and close with aclose_forcefully, as anyio's own connect_tcp does for its TLS branch (except BaseException: await aclose_forcefully(connected_stream)). aclose_forcefully completes even while the task is being cancelled. With this change in the anyio backend, the reproduction prints closed and 1.

[Zhassulan1]

I ran into this too and confirmed it on httpcore 1.0.9 with both the asyncio and trio backends: after the cancel the socket stays open, and on asyncio it is still registered with the event loop.

Changing except Exception to except BaseException in start_tls in both backends is enough. The existing await self.aclose() closes the socket before its first checkpoint (anyio aborts the transport, trio closes the socket), so it still works inside a cancelled scope. aclose_forcefully does not add anything here, since it hits the same cancel.

The change with a test is on my fork: Zhassulan1@e520b33

The test fails on master on both backends and passes with the change. The full test suite passes with 100% coverage on Python 3.8 to 3.14.

Pull request creation is limited to collaborators at the moment, so I could not open a PR. Happy to open one if that becomes possible, or feel free to take the commit as is.