crates/vm/src/stdlib/winapi.rs (2)

1555-1577: ⚠️ Potential issue | 🟠 Major

Fix off-by-one error in SIGINT event detection.

WaitForMultipleObjects returns WAIT_OBJECT_0 + index where index is 0-based. Since the sigint_event is appended as the last item at index len - 1, the condition should compare against WAIT_OBJECT_0 + (len - 1), not WAIT_OBJECT_0 + len. The current code will never detect the interrupt.

Proposed fix

-            } else if sigint_event.is_some()
-                && result == WAIT_OBJECT_0 + thread_handles_raw.len() as u32
+            } else if sigint_event.is_some()
+                && result == WAIT_OBJECT_0 + (thread_handles_raw.len() as u32 - 1)
             {
                 Some(windows_sys::Win32::Foundation::ERROR_CONTROL_C_EXIT)
             } else {

---

1010-1035: ⚠️ Potential issue | 🟠 Major

Handle ConnectNamedPipe success in overlapped mode; current code ignores the return value.

For overlapped ConnectNamedPipe, a nonzero return indicates immediate success and requires signaling the event. The current code discards the return value and unconditionally calls GetLastError(), which treats successful synchronous completion as an error. The synchronous path (lines 45–50) correctly checks the return value first; apply the same pattern to the overlapped path.

Proposed fix

-            let _ret = {
+            let ret = {
                 let mut inner = ov.inner.lock();
                 unsafe {
                     windows_sys::Win32::System::Pipes::ConnectNamedPipe(
                         handle.0,
                         &mut inner.overlapped,
                     )
                 }
             };
 
-            let err = unsafe { GetLastError() };
-            match err {
-                ERROR_IO_PENDING => {
-                    let mut inner = ov.inner.lock();
-                    inner.pending = true;
-                }
-                ERROR_PIPE_CONNECTED => {
-                    let inner = ov.inner.lock();
-                    unsafe {
-                        windows_sys::Win32::System::Threading::SetEvent(inner.overlapped.hEvent);
-                    }
-                }
-                _ => {
-                    return Err(std::io::Error::from_raw_os_error(err as i32).to_pyexception(vm));
-                }
-            }
+            if ret != 0 {
+                let inner = ov.inner.lock();
+                unsafe {
+                    windows_sys::Win32::System::Threading::SetEvent(inner.overlapped.hEvent);
+                }
+            } else {
+                let err = unsafe { GetLastError() };
+                match err {
+                    ERROR_IO_PENDING => {
+                        let mut inner = ov.inner.lock();
+                        inner.pending = true;
+                    }
+                    ERROR_PIPE_CONNECTED => {
+                        let inner = ov.inner.lock();
+                        unsafe {
+                            windows_sys::Win32::System::Threading::SetEvent(
+                                inner.overlapped.hEvent
+                            );
+                        }
+                    }
+                    _ => {
+                        return Err(std::io::Error::from_raw_os_error(err as i32).to_pyexception(vm));
+                    }
+                }
+            }