last crt error

Author: youknowone

crates/common/src/crt_fd.rs

@@ -35,7 +35,15 @@ pub type Raw = i32;
 #[inline]
 fn cvt<I: num_traits::PrimInt>(ret: I) -> io::Result<I> {
     if ret < I::zero() {
-        Err(crate::os::last_os_error())
+        // CRT functions set errno, not GetLastError(), so use last_crt_error on Windows
+        #[cfg(windows)]
+        {
+            Err(crate::os::last_crt_error())
+        }
+        #[cfg(not(windows))]
+        {
+            Err(crate::os::last_os_error())
+        }
     } else {
         Ok(ret)
     }
@@ -345,7 +353,8 @@ pub fn as_handle(fd: Borrowed<'_>) -> io::Result<BorrowedHandle<'_>> {
     }
     let handle = unsafe { suppress_iph!(_get_osfhandle(fd)) };
     if handle as HANDLE == INVALID_HANDLE_VALUE {
-        Err(crate::os::last_os_error())
+        // _get_osfhandle is a CRT function that sets errno, not GetLastError()
+        Err(crate::os::last_crt_error())
     } else {
         Ok(unsafe { BorrowedHandle::borrow_raw(handle as _) })
     }

crates/common/src/os.rs

@@ -24,18 +24,25 @@ pub fn last_os_error() -> io::Error {
     let err = io::Error::last_os_error();
     // FIXME: probably not ideal, we need a bigger dichotomy between GetLastError and errno
     if err.raw_os_error() == Some(0) {
-        unsafe extern "C" {
-            fn _get_errno(pValue: *mut i32) -> i32;
-        }
-        let mut errno = 0;
-        unsafe { suppress_iph!(_get_errno(&mut errno)) };
-        let errno = errno_to_winerror(errno);
-        io::Error::from_raw_os_error(errno)
+        last_crt_error()
     } else {
         err
     }
 }
 
+/// Get the last error from C runtime library functions (like _dup, _dup2, _fstat, etc.)
+/// CRT functions set errno, not GetLastError(), so we need to read errno directly.
+#[cfg(windows)]
+pub fn last_crt_error() -> io::Error {
+    unsafe extern "C" {
+        fn _get_errno(pValue: *mut i32) -> i32;
+    }
+    let mut errno = 0;
+    unsafe { suppress_iph!(_get_errno(&mut errno)) };
+    let winerror = errno_to_winerror(errno);
+    io::Error::from_raw_os_error(winerror)
+}
+
 #[cfg(not(windows))]
 pub fn last_os_error() -> io::Error {
     io::Error::last_os_error()

crates/vm/src/stdlib/nt.rs

@@ -21,6 +21,13 @@ pub(crate) mod module {
         ospath::OsPath,
         stdlib::os::{_os, DirFd, FollowSymlinks, SupportFunc, TargetIsDirectory, errno_err},
     };
+
+    /// Convert the error stored in the C runtime `errno` variable into an Exception.
+    /// Use this for CRT functions like _dup, _dup2, _fstat, etc. which set errno, not GetLastError().
+    #[inline]
+    fn crt_err(vm: &VirtualMachine) -> crate::builtins::PyBaseExceptionRef {
+        crate::common::os::last_crt_error().to_pyexception(vm)
+    }
     use libc::intptr_t;
     use std::os::windows::io::AsRawHandle;
     use std::{
@@ -876,7 +883,7 @@ pub(crate) mod module {
     fn dup(fd: i32, vm: &VirtualMachine) -> PyResult<i32> {
         let fd2 = unsafe { suppress_iph!(_dup(fd)) };
         if fd2 < 0 {
-            return Err(errno_err(vm));
+            return Err(crt_err(vm));
         }
         // Set the new fd as non-inheritable
         let borrowed = unsafe { crt_fd::Borrowed::borrow_raw(fd2) };
@@ -900,7 +907,7 @@ pub(crate) mod module {
     fn dup2(args: Dup2Args, vm: &VirtualMachine) -> PyResult<i32> {
         let result = unsafe { suppress_iph!(_dup2(args.fd, args.fd2)) };
         if result < 0 {
-            return Err(errno_err(vm));
+            return Err(crt_err(vm));
         }
         if !args.inheritable {
             let borrowed = unsafe { crt_fd::Borrowed::borrow_raw(args.fd2) };