From 0f9fc6a501f676a6138692e86d26a1046d2f00a4 Mon Sep 17 00:00:00 2001 From: 5 <93879550+tydavid5@users.noreply.github.com> Date: Thu, 19 Nov 2026 14:16:30 +0100 Subject: [PATCH 1/2] gh-162256: Do not set SO_REUSEADDR when binding port 0 SO_REUSEADDR is only useful when rebinding a fixed port that may still have connections in TIME_WAIT. For port 0 the kernel only hands out ports that are not in use, so setting it just lets another process claim the port between bind() and listen(), and then our listen() fails with EADDRINUSE. TCPServer.server_bind() now skips the option for AF_INET and AF_INET6 when the requested port is 0, matching the family check already used for SO_REUSEPORT. A fixed port still gets the option, and servers that set allow_reuse_address to False are unchanged. The fix also covers HTTPServer and SimpleXMLRPCServer, which both set allow_reuse_address and are commonly started on port 0. Fixes gh-162256. Adds a regression test covering the port 0 case for AF_INET and AF_INET6 plus the fixed port control, and a news entry. --- Lib/socketserver.py | 8 ++- Lib/test/test_socketserver.py | 52 +++++++++++++++++++ ...-11-19-13-10-12.gh-issue-162256.T2IaLA.rst | 4 ++ 3 files changed, 63 insertions(+), 1 deletion(-) create mode 100644 Misc/NEWS.d/next/Library/2026-11-19-13-10-12.gh-issue-162256.T2IaLA.rst diff --git a/Lib/socketserver.py b/Lib/socketserver.py index ec389457ef5b1c..f07488897586da 100644 --- a/Lib/socketserver.py +++ b/Lib/socketserver.py @@ -463,7 +463,13 @@ def server_bind(self): May be overridden. """ - if self.allow_reuse_address and hasattr(socket, "SO_REUSEADDR"): + # SO_REUSEADDR is only useful when rebinding a fixed port that may + # still have connections in TIME_WAIT. For port 0 the kernel only + # hands out ports that are not in use, so setting it just lets + # another process claim the port between bind() and listen(). + if (self.allow_reuse_address and hasattr(socket, "SO_REUSEADDR") + and not (self.address_family in (socket.AF_INET, socket.AF_INET6) + and self.server_address[1] == 0)): self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # Since Linux 6.12.9, SO_REUSEPORT is not allowed # on other address families than AF_INET/AF_INET6. diff --git a/Lib/test/test_socketserver.py b/Lib/test/test_socketserver.py index 4f2ed7140a749b..25b30105f16d3f 100644 --- a/Lib/test/test_socketserver.py +++ b/Lib/test/test_socketserver.py @@ -289,6 +289,58 @@ def test_tcpserver_bind_leak(self): socketserver.TCPServer((HOST, -1), socketserver.StreamRequestHandler) + def test_port_zero_no_reuse_address(self): + # gh-162256: binding port 0 must not set SO_REUSEADDR, or another + # process could claim the port between bind() and listen(). + class MyServer(socketserver.TCPServer): + allow_reuse_address = True + + server = MyServer((HOST, 0), socketserver.StreamRequestHandler, + bind_and_activate=False) + try: + server.server_bind() + self.assertEqual(server.socket.getsockopt(socket.SOL_SOCKET, + socket.SO_REUSEADDR), 0) + port = server.server_address[1] + other = socket.socket() + try: + other.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + with self.assertRaises(OSError): + other.bind((HOST, port)) + finally: + other.close() + server.server_activate() + finally: + server.server_close() + + if socket_helper.IPV6_ENABLED: + class MyServer6(socketserver.TCPServer): + address_family = socket.AF_INET6 + allow_reuse_address = True + + server = MyServer6(('::1', 0), socketserver.StreamRequestHandler, + bind_and_activate=False) + try: + server.server_bind() + self.assertEqual(server.socket.getsockopt( + socket.SOL_SOCKET, socket.SO_REUSEADDR), 0) + server.server_activate() + finally: + server.server_close() + + # A fixed port still gets SO_REUSEADDR. + server = MyServer((HOST, 0), socketserver.StreamRequestHandler) + port = server.server_address[1] + server.server_close() + server = MyServer((HOST, port), socketserver.StreamRequestHandler, + bind_and_activate=False) + try: + server.server_bind() + self.assertEqual(server.socket.getsockopt(socket.SOL_SOCKET, + socket.SO_REUSEADDR), 1) + finally: + server.server_close() + def test_context_manager(self): with socketserver.TCPServer((HOST, 0), socketserver.StreamRequestHandler) as server: diff --git a/Misc/NEWS.d/next/Library/2026-11-19-13-10-12.gh-issue-162256.T2IaLA.rst b/Misc/NEWS.d/next/Library/2026-11-19-13-10-12.gh-issue-162256.T2IaLA.rst new file mode 100644 index 00000000000000..c3395e79cc6c08 --- /dev/null +++ b/Misc/NEWS.d/next/Library/2026-11-19-13-10-12.gh-issue-162256.T2IaLA.rst @@ -0,0 +1,4 @@ +:mod:`socketserver` servers no longer set ``SO_REUSEADDR`` when binding +port 0, so another process cannot claim the port between ``bind()`` and +``listen()``. This fixes :class:`http.server.HTTPServer` failing with +``EADDRINUSE`` when started on port 0. From d426b350beceff6d9bb11a549994e39130dd2c67 Mon Sep 17 00:00:00 2001 From: 5 <93879550+tydavid5@users.noreply.github.com> Date: Thu, 19 Nov 2026 15:13:41 +0100 Subject: [PATCH 2/2] gh-162256: Do not assert getsockopt(SO_REUSEADDR) equals 1 in the test On macOS getsockopt returns the raw flag value 4 for a set SO_REUSEADDR, not 1, so the fixed-port control failed on macOS with 4 != 1. Check for non-zero instead, matching the convention in test_socket.py. --- Lib/test/test_socketserver.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/Lib/test/test_socketserver.py b/Lib/test/test_socketserver.py index 25b30105f16d3f..7ad31c2cb73952 100644 --- a/Lib/test/test_socketserver.py +++ b/Lib/test/test_socketserver.py @@ -328,7 +328,8 @@ class MyServer6(socketserver.TCPServer): finally: server.server_close() - # A fixed port still gets SO_REUSEADDR. + # A fixed port still gets SO_REUSEADDR. Check for non-zero rather + # than 1: on macOS getsockopt returns the raw flag value 4. server = MyServer((HOST, 0), socketserver.StreamRequestHandler) port = server.server_address[1] server.server_close() @@ -336,8 +337,8 @@ class MyServer6(socketserver.TCPServer): bind_and_activate=False) try: server.server_bind() - self.assertEqual(server.socket.getsockopt(socket.SOL_SOCKET, - socket.SO_REUSEADDR), 1) + self.assertNotEqual(server.socket.getsockopt(socket.SOL_SOCKET, + socket.SO_REUSEADDR), 0) finally: server.server_close()