apply review

youknowone · youknowone · commit 92ebf634ae2f · 2026-01-26T14:34:30.000+09:00
diff --git a/crates/stdlib/src/openssl.rs b/crates/stdlib/src/openssl.rs
@@ -2851,10 +2851,18 @@ mod _ssl {
                     }
                     // Wait briefly for peer's close_notify before retrying
                     match socket_stream.select(SslNeeds::Read, &deadline) {
-                        SelectRet::TimedOut => break, // Timeout waiting for peer
-                        SelectRet::Closed => break,   // Socket closed
+                        SelectRet::TimedOut => {
+                            return Err(vm.new_exception_msg(
+                                vm.ctx.exceptions.timeout_error.to_owned(),
+                                "The read operation timed out".to_owned(),
+                            ));
+                        }
+                        SelectRet::Closed => {
+                            return Err(socket_closed_error(vm));
+                        }
                         SelectRet::Nonblocking => {
-                            // Non-blocking, just continue
+                            // Non-blocking socket: return SSLWantReadError
+                            return Err(create_ssl_want_read_error(vm).upcast());
                         }
                         SelectRet::Ok => {
                             // Data available, continue to retry
diff --git a/crates/stdlib/src/ssl.rs b/crates/stdlib/src/ssl.rs
@@ -4124,7 +4124,16 @@ mod _ssl {
                             // Non-blocking: return immediately after sending close_notify.
                             // Don't wait for peer's close_notify to avoid blocking.
                             drop(conn_guard);
-                            let _ = self.flush_pending_tls_output(vm, None);
+                            // Best-effort flush; WouldBlock is expected in non-blocking mode.
+                            // Other errors indicate close_notify may not have been sent,
+                            // but we still complete shutdown to avoid inconsistent state.
+                            if let Err(e) = self.flush_pending_tls_output(vm, None) {
+                                if !is_blocking_io_error(&e, vm) {
+                                    // Unexpected error - close_notify may not have been sent.
+                                    // Still complete shutdown to avoid leaving socket in
+                                    // inconsistent state.
+                                }
+                            }
                             *self.shutdown_state.lock() = ShutdownState::Completed;
                             *self.connection.lock() = None;
                             return Ok(self.sock.clone());
