Fix race condition and improve robustness during socket I/O

Fixes to make socket I/O more resilient during connection teardown.

1. BufferedWriter's write(): Added error handling to ignore common
   socket errors (e.g., ECONNRESET, EPIPE, ENOTCONN, EBADF) that occur
   when the underlying connection has been unexpectedly closed by the
   client or OS. This prevents a crash when attempting to write to a defunct socket.
2. BufferedWriters's close(): Made idempotent, allowing safe repeated
   calls without raising exceptions.
3. Needed to add explicit handling of WINDOWS environments as these are
   seen to throw Windows specific WSAENOTSOCK errors.

Includes new unit tests to cover the idempotency and graceful handling of already closed underlying buffers.

Author: julianz-

cheroot/errors.py

@@ -4,6 +4,12 @@
 import sys
 
 
+try:
+    from OpenSSL.SSL import SysCallError as _OpenSSL_SysCallError
+except ImportError:
+    _OpenSSL_SysCallError = None
+
+
 class MaxSizeExceeded(Exception):
     """Exception raised when a client sends more data then allowed under limit.
 
@@ -66,6 +72,7 @@ def plat_specific_errors(*errnames):
 
 
 acceptable_sock_shutdown_error_codes = {
+    errno.EBADF,
     errno.ENOTCONN,
     errno.EPIPE,
     errno.ESHUTDOWN,  # corresponds to BrokenPipeError in Python 3
@@ -87,4 +94,8 @@ def plat_specific_errors(*errnames):
 * https://docs.microsoft.com/windows/win32/api/winsock/nf-winsock-shutdown
 """
 
-acceptable_sock_shutdown_exceptions = (BrokenPipeError, ConnectionResetError)
+acceptable_sock_shutdown_exceptions = (
+    BrokenPipeError,
+    ConnectionResetError,
+    _OpenSSL_SysCallError,
+)

cheroot/makefile.py

@@ -2,8 +2,30 @@
 
 # prefer slower Python-based io module
 import _pyio as io
+import errno
 import socket
+import sys
 
+from OpenSSL.SSL import SysCallError
+
+
+# Define a variable to hold the platform-specific "not a socket" error.
+_not_a_socket_err = None
+
+if sys.platform == 'win32':
+    # On Windows, try to get the named constant from the socket module.
+    # If that fails, fall back to the known numeric value.
+    try:
+        _not_a_socket_err = socket.WSAENOTSOCK
+    except AttributeError:
+        _not_a_socket_err = 10038
+else:
+    # On other platforms, the relevant error is EBADF (Bad file descriptor),
+    # which is already in your list of handled errors.
+    pass
+
+# Expose the error constant for use in the module's public API if needed.
+WSAENOTSOCK = _not_a_socket_err
 
 # Write only 16K at a time to sockets
 SOCK_WRITE_BLOCKSIZE = 16384
@@ -30,10 +52,59 @@ def _flush_unlocked(self):
                 # ssl sockets only except 'bytes', not bytearrays
                 # so perhaps we should conditionally wrap this for perf?
                 n = self.raw.write(bytes(self._write_buf))
-            except io.BlockingIOError as e:
-                n = e.characters_written
+            except (io.BlockingIOError, OSError, SysCallError) as e:
+                # Check for a different error attribute depending
+                # on the exception type
+                if isinstance(e, io.BlockingIOError):
+                    n = e.characters_written
+                else:
+                    error_code = (
+                        e.errno if isinstance(e, OSError) else e.args[0]
+                    )
+                    if error_code in {
+                        errno.EBADF,
+                        errno.ENOTCONN,
+                        errno.EPIPE,
+                        WSAENOTSOCK,  # Windows-specific error
+                    }:
+                        # The socket is gone, so just ignore this error.
+                        return
+                    raise
+            else:
+                # The 'try' block completed without an exception
+                if n is None:
+                    # This could happen with non-blocking write
+                    # when nothing was written
+                    break
+
             del self._write_buf[:n]
 
+    def close(self):
+        """
+        Close the stream and its underlying file object.
+
+        This method is designed to be idempotent (it can be called multiple
+        times without side effects). It gracefully handles a race condition
+        where the underlying socket may have already been closed by the remote
+        client or another thread.
+
+        A SysCallError or OSError with errno.EBADF or errno.ENOTCONN is caught
+        and ignored, as these indicate a normal, expected connection teardown.
+        Other exceptions are re-raised.
+        """
+        if self.closed:  # pylint: disable=W0125
+            return
+
+        try:
+            super().close()
+        except (OSError, SysCallError) as e:
+            error_code = e.errno if isinstance(e, OSError) else e.args[0]
+            if error_code in {errno.EBADF, errno.ENOTCONN}:
+                # The socket is already closed, which is expected during
+                # a race condition.
+                return
+            raise
+
 
 class StreamReader(io.BufferedReader):
     """Socket stream reader."""

cheroot/makefile.pyi

@@ -1,5 +1,11 @@
 import io
 
+# this variable is only needed in Windows environments
+# and is an int in those cases
+# but mypy stubtest fails when adding a guard such as
+# if sys.platform == 'win32' or setting is as int
+WSAENOTSOCK: None
+
 SOCK_WRITE_BLOCKSIZE: int
 
 class BufferedWriter(io.BufferedWriter):

cheroot/server.py

@@ -67,6 +67,7 @@
 
 import contextlib
 import email.utils
+import errno
 import io
 import logging
 import os
@@ -81,6 +82,8 @@
 import urllib.parse
 from functools import lru_cache
 
+from OpenSSL.SSL import SysCallError
+
 from . import __version__, connections, errors
 from ._compat import IS_PPC, bton
 from .makefile import MakeFile, StreamWriter
@@ -1186,12 +1189,25 @@ def ensure_headers_sent(self):
 
     def write(self, chunk):
         """Write unbuffered data to the client."""
-        if self.chunked_write and chunk:
-            chunk_size_hex = hex(len(chunk))[2:].encode('ascii')
-            buf = [chunk_size_hex, CRLF, chunk, CRLF]
-            self.conn.wfile.write(EMPTY.join(buf))
-        else:
-            self.conn.wfile.write(chunk)
+        try:
+            if self.chunked_write and chunk:
+                chunk_size_hex = hex(len(chunk))[2:].encode('ascii')
+                buf = [chunk_size_hex, CRLF, chunk, CRLF]
+                self.conn.wfile.write(EMPTY.join(buf))
+            else:
+                self.conn.wfile.write(chunk)
+        except (SysCallError, ConnectionError, OSError) as e:
+            error_code = e.errno if isinstance(e, OSError) else e.args[0]
+            if error_code in {
+                errno.ECONNRESET,
+                errno.EPIPE,
+                errno.ENOTCONN,
+                errno.EBADF,
+            }:
+                # The socket is gone, so just ignore this error.
+                return
+
+            raise
 
     def send_headers(self):  # noqa: C901  # FIXME
         """Assert, process, and send the HTTP response message-headers.
@@ -1285,7 +1301,27 @@ def send_headers(self):  # noqa: C901  # FIXME
         for k, v in self.outheaders:
             buf.append(k + COLON + SPACE + v + CRLF)
         buf.append(CRLF)
-        self.conn.wfile.write(EMPTY.join(buf))
+        try:
+            self.conn.wfile.write(EMPTY.join(buf))
+        except (SysCallError, ConnectionError, OSError) as e:
+            # We explicitly ignore these errors because they indicate the
+            # client has already closed the connection, which is a normal
+            # occurrence during a race condition.
+
+            # The .errno attribute is only available on OSError
+            # The .args[0] attribute is available on SysCallError
+            # Check for both cases to handle different exception types
+            error_code = e.errno if isinstance(e, OSError) else e.args[0]
+            if error_code in {
+                errno.ECONNRESET,
+                errno.EPIPE,
+                errno.ENOTCONN,
+                errno.EBADF,
+            }:
+                self.close_connection = True
+                self.conn.close()
+                return
+            raise
 
 
 class HTTPConnection:
@@ -1541,9 +1577,10 @@ def _close_kernel_socket(self):
             self.socket.shutdown,
         )
 
+        acceptable_exceptions = errors.acceptable_sock_shutdown_exceptions
         try:
             shutdown(socket.SHUT_RDWR)  # actually send a TCP FIN
-        except errors.acceptable_sock_shutdown_exceptions:
+        except acceptable_exceptions:  # pylint: disable=E0712
             pass
         except socket.error as e:
             if e.errno not in errors.acceptable_sock_shutdown_error_codes:

cheroot/test/test_conn.py

@@ -17,6 +17,7 @@
 
 import cheroot.server
 from cheroot._compat import IS_CI, IS_MACOS, IS_PYPY, IS_WINDOWS
+from cheroot.makefile import BufferedWriter
 from cheroot.test import helper, webtest
 
 
@@ -1637,3 +1638,33 @@ def test_invalid_selected_connection(test_client, monkeypatch):
     time.sleep(test_client.server_instance.expiration_interval * 2)
     assert faux_select.os_error_triggered
     assert faux_get_map.conn_closed
+
+
+class TestBufferedWriter:
+    """Test cases for BufferedWriter close() method race condition handling."""
+
+    def test_close_is_idempotent(self):
+        """Test that close() can be called multiple times safely."""
+        import io
+
+        raw_buffer = io.BytesIO()
+        buffered_writer = BufferedWriter(raw_buffer)
+
+        # Should not raise any exceptions
+        buffered_writer.close()
+        buffered_writer.close()  # Second call should be safe
+
+        assert buffered_writer.closed
+
+    def test_close_handles_already_closed_buffer(self):
+        """Test that close() handles already closed underlying buffer."""
+        import io
+
+        raw_buffer = io.BytesIO()
+        buffered_writer = BufferedWriter(raw_buffer)
+
+        # Close the underlying buffer first
+        raw_buffer.close()
+
+        # This should not raise an exception
+        buffered_writer.close()

docs/spelling_wordlist.txt

@@ -13,7 +13,10 @@ chunked
 dev
 docstrings
 downstreams
+EBADF
+ENOTCONN
 environ
+errno
 errored
 Faux
 fd
@@ -57,12 +60,14 @@ signalling
 Sigstore
 ssl
 stdout
+stubtest
 subclasses
 submodules
 subpackages
 symlinked
 syscall
 systemd
+teardown
 threadpool
 Tidelift
 TLS