Prevent SIGPIPE from killing the test process on peer reset

BasicFuncTests.teardownDuringInFlightUpload_ShutsDownCleanly intermittently
killed the whole test runner on macOS/iOS CI: the process exited with signal
SIGPIPE (exit 141) and no crash backtrace, which XCTest reports as an
unexpected exit/restart and a ~24s timeout rather than a test failure.

Cause: the test HTTP server writes responses from the reactor thread via
::send() with no SIGPIPE protection. That test deliberately cancels an upload
that is still in flight against the /slow/ endpoint, so NSURLSession resets the
connection while the server is mid-response. ::send() then fails with EPIPE and
raises SIGPIPE; the test process installs no handler, so the default
disposition terminates it. The race is timing-dependent, which is why it looks
flaky and only shows up on the slower Apple CI runners.

Fix (test infrastructure only, no SDK behavior change):
- Add Socket::setNoSigPipe() and apply SO_NOSIGPIPE to every accepted
  connection (Apple/BSD, where the option is per-socket).
- Pass MSG_NOSIGNAL from Socket::send() on Linux, which has no SO_NOSIGPIPE.
Both make a write to a reset peer return EPIPE, which the reactor already
handles by closing the connection.

Files changed: tests/common/SocketTools.hpp

Validated locally on macOS (arm64, Debug): the test reproduced at ~30% (5/15
runs exited 141) before the fix and passed 30/30 after; the full FuncTests
suite passes 40/40.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Author: bmehta001

tests/common/SocketTools.hpp

@@ -288,6 +288,33 @@ class Socket
         return (::setsockopt(m_sock, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast<char*>(&value), sizeof(value)) == 0);
     }
 
+    /**
+     * Suppress SIGPIPE when writing to a socket whose peer has already gone away.
+     *
+     * The test HTTP server writes responses on the reactor thread. When a client
+     * (e.g. NSURLSession on Apple) cancels an in-flight upload during teardown, the
+     * connection can be reset before the response is flushed, so ::send() fails with
+     * EPIPE and raises SIGPIPE. The test process installs no SIGPIPE handler, so the
+     * default disposition terminates it - which surfaces as a silent, backtrace-less
+     * test-runner exit/restart rather than a normal test failure.
+     *
+     * Apple/BSD only supports this per-socket via SO_NOSIGPIPE; Linux uses the
+     * MSG_NOSIGNAL send() flag instead (see send() below).
+     */
+    bool setNoSigPipe()
+    {
+#ifdef SO_NOSIGPIPE
+        if (m_sock == Invalid)
+        {
+            return false;
+        }
+        int value = 1;
+        return (::setsockopt(m_sock, SOL_SOCKET, SO_NOSIGPIPE, &value, sizeof(value)) == 0);
+#else
+        return true;
+#endif
+    }
+
     bool setNoDelay()
     {
         assert(m_sock != Invalid);
@@ -326,7 +353,14 @@ class Socket
     int send(void const* buffer, unsigned size)
     {
         assert(m_sock != Invalid);
-        return static_cast<int>(::send(m_sock, reinterpret_cast<char const*>(buffer), size, 0));
+#if defined(MSG_NOSIGNAL)
+        // Linux: ask the kernel to return EPIPE instead of raising SIGPIPE.
+        int flags = MSG_NOSIGNAL;
+#else
+        // Apple/Windows: handled by SO_NOSIGPIPE / not applicable.
+        int flags = 0;
+#endif
+        return static_cast<int>(::send(m_sock, reinterpret_cast<char const*>(buffer), size, flags));
     }
 
     bool bind(SocketAddr const& addr)
@@ -361,6 +395,12 @@ class Socket
         socklen_t addrlen = sizeof(caddr);
 #endif
         csock = ::accept(m_sock, caddr, &addrlen);
+        if (!csock.invalid())
+        {
+            // Accepted connections are written to from the reactor thread; a peer
+            // that resets mid-response must not kill the test process via SIGPIPE.
+            csock.setNoSigPipe();
+        }
         return !csock.invalid();
     }