bug(sandbox): mediated nonblocking TCP connect returns 0 instead of EINPROGRESS, breaking Microsoft.Data.SqlClient #4980

diff --git a/crates/openshell-sandbox/src/network_broker.rs b/crates/openshell-sandbox/src/network_broker.rs
index faaff92..95753ba 100644
--- a/crates/openshell-sandbox/src/network_broker.rs
+++ b/crates/openshell-sandbox/src/network_broker.rs
@@ -1016,10 +1016,19 @@ fn connect_socket(
                             destination,
                         )
                     }) {
-                        Ok(stream) => {
-                            let result = worker_listener
-                                .respond_value(notification.id, 0)
-                                .map(|()| stream);
+                        Ok((stream, nonblocking)) => {
+                            // A nonblocking connect reports what the kernel
+                            // reports for a TCP handshake: EINPROGRESS, with
+                            // the socket already connected and writable.
+                            // Clients such as Microsoft.Data.SqlClient treat
+                            // an immediate success on a nonblocking socket as
+                            // an error.
+                            let reply = if nonblocking {
+                                worker_listener.respond_errno(notification.id, libc::EINPROGRESS)
+                            } else {
+                                worker_listener.respond_value(notification.id, 0)
+                            };
+                            let result = reply.map(|()| stream);
                             let _ = relay_tx.send(result);
                         }
                         Err(error) => {
@@ -1200,32 +1209,44 @@ fn ensure_dns_source_bound(fd: RawFd, family: InetFamily) -> io::Result<SocketAd
     Ok(address)
 }
 
+/// Connect the workload's socket to a fresh loopback relay and accept it.
+/// Returns the relay stream and whether the workload's open file was
+/// nonblocking when its connect was mediated: O_NONBLOCK is an OFD flag the
+/// workload may set after socket(2) (fcntl), so the socket metadata recorded at
+/// creation cannot tell.
 fn establish_relay(
     registry: &Mutex<SocketRegistry>,
     tid: u32,
     fd: RawFd,
     expected_socket: SocketIdentity,
     destination: SocketAddr,
-) -> io::Result<TcpStream> {
+) -> io::Result<(TcpStream, bool)> {
     let relay = TcpListener::bind(match destination {
         SocketAddr::V4(_) => SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), 0),
         SocketAddr::V6(_) => SocketAddr::new(IpAddr::V6(Ipv6Addr::LOCALHOST), 0),
     })?;
     relay.set_nonblocking(false)?;
     let relay_address = relay.local_addr()?;
-    let expected_peer = {
+    let (expected_peer, nonblocking) = {
         let mut registry = lock(registry);
         let entry = registry.resolve_mut(tid, fd)?;
         if entry.identity() != expected_socket {
             return Err(io::Error::from_raw_os_error(libc::EBADF));
         }
+        // Read before connect_exact, which sets O_NONBLOCK on the shared open
+        // file for its bounded attempt and then restores the workload's value.
+        // SAFETY: F_GETFL reads the flags of the live retained socket OFD.
+        let flags = unsafe { libc::fcntl(entry.retained_preconnect()?.as_raw_fd(), libc::F_GETFL) };
+        if flags < 0 {
+            return Err(io::Error::last_os_error());
+        }
         connect_exact(entry.retained_preconnect()?.as_raw_fd(), relay_address)?;
         let expected_peer = socket_local_addr(entry.retained_preconnect()?.as_raw_fd())?;
         entry.set_state(SocketState::Connected {
             original_peer: destination,
         });
         entry.release_preconnect();
-        expected_peer
+        (expected_peer, flags & libc::O_NONBLOCK != 0)
     };
     relay.set_nonblocking(true)?;
     let deadline = Instant::now() + RELAY_CONNECT_TIMEOUT;
@@ -1255,7 +1276,7 @@ fn establish_relay(
         }
     };
     stream.set_nodelay(true)?;
-    Ok(stream)
+    Ok((stream, nonblocking))
 }
 
 fn bind_socket(
@@ -2982,6 +3003,82 @@ mod tests {
         client.join().expect("join client").expect("client relay");
     }
 
+    #[test]
+    fn nonblocking_external_connect_reports_in_progress_like_the_kernel() {
+        let (launcher, listener) =
+            crate::linux::workload_launcher::start().expect("start workload launcher");
+        let broker = NetworkBroker::start_for_test(listener).expect("start network broker");
+        let client = std::thread::spawn(move || {
+            launcher
+                .execute(|| -> io::Result<()> {
+                    // Blocking at socket(2), nonblocking by fcntl afterwards,
+                    // as .NET's Socket.Blocking = false does.
+                    let socket = socket2::Socket::new(
+                        socket2::Domain::IPV4,
+                        socket2::Type::STREAM,
+                        None,
+                    )?;
+                    socket.set_nonblocking(true)?;
+                    let address: SocketAddr = "203.0.113.7:443".parse().unwrap();
+                    let started = socket.connect(&address.into());
+                    if started.as_ref().err().and_then(io::Error::raw_os_error)
+                        != Some(libc::EINPROGRESS)
+                    {
+                        return Err(io::Error::other(format!(
+                            "nonblocking connect returned {started:?}, not EINPROGRESS"
+                        )));
+                    }
+                    let mut poll = libc::pollfd {
+                        fd: socket.as_raw_fd(),
+                        events: libc::POLLOUT,
+                        revents: 0,
+                    };
+                    // SAFETY: poll points to one live pollfd.
+                    if unsafe { libc::poll(&raw mut poll, 1, 5_000) } != 1
+                        || poll.revents & libc::POLLOUT == 0
+                    {
+                        return Err(io::Error::other("socket never became writable"));
+                    }
+                    if let Some(error) = socket.take_error()? {
+                        return Err(error);
+                    }
+                    // A repeated connect reports the completed handshake.
+                    if socket.connect(&address.into()).err().and_then(|e| e.raw_os_error())
+                        != Some(libc::EISCONN)
+                    {
+                        return Err(io::Error::other("repeated connect did not report EISCONN"));
+                    }
+                    socket.set_nonblocking(false)?;
+                    let mut stream: TcpStream = socket.into();
+                    stream.write_all(b"request")?;
+                    let mut response = [0_u8; 8];
+                    stream.read_exact(&mut response)?;
+                    if &response != b"response" {
+                        return Err(io::Error::other("relay returned wrong response"));
+                    }
+                    Ok(())
+                })
+                .expect("launcher result")
+        });
+
+        let runtime = tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .expect("test runtime");
+        let pending = runtime.block_on(broker.accept()).expect("pending TCP open");
+        let mut relay = runtime
+            .block_on(pending.complete(TcpOpenDecision::RelayReady))
+            .expect("complete relay")
+            .expect("authorized relay stream");
+        let mut request = [0_u8; 7];
+        relay
+            .read_exact(&mut request)
+            .expect("read relayed request");
+        assert_eq!(&request, b"request");
+        relay.write_all(b"response").expect("write relay response");
+        client.join().expect("join client").expect("client relay");
+    }
+
     #[test]
     fn denied_external_connect_keeps_socket_unconnected() {
         let (launcher, listener) =