Move crt_fd to common

Author: coolreader18

Cargo.lock

@@ -24,3 +24,6 @@ radium = "0.7"
 libc = "0.2.101"
 ascii = "1.0"
 unic-ucd-category = "0.9"
+
+[target.'cfg(windows)'.dependencies]
+widestring = "0.5.1"

common/Cargo.toml

@@ -1,8 +1,7 @@
 //! A module implementing an io type backed by the C runtime's file descriptors, i.e. what's
 //! returned from libc::open, even on windows.
 
-use crate::suppress_iph;
-use std::{cmp, ffi, fs, io, mem};
+use std::{cmp, ffi, io};
 
 #[cfg(windows)]
 use libc::commit as fsync;
@@ -21,10 +20,31 @@ pub type Offset = libc::off_t;
 #[cfg(windows)]
 pub type Offset = libc::c_longlong;
 
+// copied from stdlib::os
+#[cfg(windows)]
+fn errno() -> 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) {
+        extern "C" {
+            fn _get_errno(pValue: *mut i32) -> i32;
+        }
+        let mut e = 0;
+        unsafe { suppress_iph!(_get_errno(&mut e)) };
+        io::Error::from_raw_os_error(e)
+    } else {
+        err
+    }
+}
+#[cfg(not(windows))]
+fn errno() -> io::Error {
+    io::Error::last_os_error()
+}
+
 #[inline]
 fn cvt<T, I: num_traits::PrimInt>(ret: I, f: impl FnOnce(I) -> T) -> io::Result<T> {
     if ret < I::zero() {
-        Err(crate::stdlib::os::errno())
+        Err(errno())
     } else {
         Ok(f(ret))
     }
@@ -73,50 +93,16 @@ impl Fd {
         cvt(unsafe { suppress_iph!(ftruncate(self.0, len)) }, drop)
     }
 
-    /// NOTE: it's not recommended to use ManuallyDrop::into_inner() to drop the file - it won't
-    /// work on all platforms, and will swallow any errors you might want to handle.
-    #[allow(unused)] // only used on windows atm
-    pub(crate) fn as_rust_file(&self) -> io::Result<mem::ManuallyDrop<fs::File>> {
-        #[cfg(windows)]
-        let file = {
-            use std::os::windows::io::FromRawHandle;
-            let handle = self.to_raw_handle()?;
-            unsafe { fs::File::from_raw_handle(handle) }
-        };
-        #[cfg(unix)]
-        let file = {
-            let fd = self.0;
-            use std::os::unix::io::FromRawFd;
-            if fd < 0 {
-                return Err(io::Error::from_raw_os_error(libc::EBADF));
-            }
-            unsafe { fs::File::from_raw_fd(fd) }
-        };
-        #[cfg(target_os = "wasi")]
-        let file = {
-            let fd = self.0;
-            if fd < 0 {
-                return Err(io::Error::from_raw_os_error(libc::EBADF));
-            }
-            // SAFETY: as of now, File is a wrapper around WasiFd, which is a wrapper around
-            // wasi::Fd (u32). This isn't likely to change, and if it does change to a different
-            // sized integer, mem::transmute will fail.
-            unsafe { mem::transmute::<u32, fs::File>(fd as u32) }
-        };
-        Ok(mem::ManuallyDrop::new(file))
-    }
-
     #[cfg(windows)]
-    pub(crate) fn to_raw_handle(&self) -> io::Result<std::os::windows::io::RawHandle> {
-        use winapi::um::{handleapi::INVALID_HANDLE_VALUE, winnt::HANDLE};
+    pub fn to_raw_handle(&self) -> io::Result<std::os::windows::io::RawHandle> {
         extern "C" {
             fn _get_osfhandle(fd: i32) -> libc::intptr_t;
         }
-        let handle = unsafe { suppress_iph!(_get_osfhandle(self.0)) } as HANDLE;
-        if handle == INVALID_HANDLE_VALUE {
+        let handle = unsafe { suppress_iph!(_get_osfhandle(self.0)) };
+        if handle == -1 {
             Err(io::Error::last_os_error())
         } else {
-            Ok(handle)
+            Ok(handle as _)
         }
     }
 }

vm/src/crt_fd.rs renamed to common/src/crt_fd.rs

@@ -1,11 +1,17 @@
 //! A crate to hold types and functions common to all rustpython components.
 
+#[macro_use]
+mod macros;
+pub use macros::*;
+
 pub mod atomic;
 pub mod borrow;
 pub mod boxvec;
 pub mod bytes;
 pub mod char;
 pub mod cmp;
+#[cfg(any(unix, windows, target_os = "wasi"))]
+pub mod crt_fd;
 pub mod encodings;
 pub mod float_ops;
 pub mod hash;

common/src/lib.rs

@@ -0,0 +1,59 @@
+/// Suppress the MSVC invalid parameter handler, which by default crashes the process. Does nothing
+/// on non-MSVC targets.
+#[macro_export]
+macro_rules! suppress_iph {
+    ($e:expr) => {
+        $crate::__suppress_iph_impl!($e)
+    };
+}
+
+#[macro_export]
+#[doc(hidden)]
+#[cfg(all(windows, target_env = "msvc"))]
+macro_rules! __suppress_iph_impl {
+    ($e:expr) => {{
+        let old = $crate::__macro_private::_set_thread_local_invalid_parameter_handler(
+            $crate::__macro_private::silent_iph_handler,
+        );
+        let ret = $e;
+        $crate::__macro_private::_set_thread_local_invalid_parameter_handler(old);
+        ret
+    }};
+}
+
+#[cfg(not(all(windows, target_env = "msvc")))]
+#[macro_export]
+#[doc(hidden)]
+macro_rules! __suppress_iph_impl {
+    ($e:expr) => {
+        $e
+    };
+}
+
+#[doc(hidden)]
+pub mod __macro_private {
+    #[cfg(target_env = "msvc")]
+    type InvalidParamHandler = extern "C" fn(
+        *const libc::wchar_t,
+        *const libc::wchar_t,
+        *const libc::wchar_t,
+        libc::c_uint,
+        libc::uintptr_t,
+    );
+    #[cfg(target_env = "msvc")]
+    extern "C" {
+        pub fn _set_thread_local_invalid_parameter_handler(
+            pNew: InvalidParamHandler,
+        ) -> InvalidParamHandler;
+    }
+
+    #[cfg(target_env = "msvc")]
+    pub extern "C" fn silent_iph_handler(
+        _: *const libc::wchar_t,
+        _: *const libc::wchar_t,
+        _: *const libc::wchar_t,
+        _: libc::c_uint,
+        _: libc::uintptr_t,
+    ) {
+    }
+}

common/src/macros.rs

@@ -47,8 +47,6 @@ pub mod class;
 mod codecs;
 pub mod convert;
 mod coroutine;
-#[cfg(any(unix, windows, target_os = "wasi"))]
-mod crt_fd;
 mod dictdatatype;
 #[cfg(feature = "rustpython-compiler")]
 pub mod eval;

vm/src/lib.rs

@@ -3,7 +3,7 @@
  */
 cfg_if::cfg_if! {
     if #[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))] {
-        use crate::crt_fd::Offset;
+        use crate::common::crt_fd::Offset;
     } else {
         type Offset = i64;
     }
@@ -3695,8 +3695,8 @@ mod fileio {
     use super::{Offset, _io::*};
     use crate::{
         builtins::{PyStr, PyStrRef},
+        common::crt_fd::Fd,
         convert::ToPyException,
-        crt_fd::Fd,
         function::{ArgBytesLike, ArgMemoryBuffer, OptionalArg, OptionalOption},
         stdlib::os,
         types::{DefaultConstructor, Initializer},

vm/src/stdlib/io.rs

@@ -4,8 +4,9 @@ pub use msvcrt::*;
 mod msvcrt {
     use crate::{
         builtins::{PyBytes, PyStrRef},
+        common::suppress_iph,
         stdlib::os::errno_err,
-        suppress_iph, PyRef, PyResult, VirtualMachine,
+        PyRef, PyResult, VirtualMachine,
     };
     use itertools::Itertools;
     use winapi::{

vm/src/stdlib/msvcrt.rs

@@ -12,15 +12,15 @@ pub(crate) fn make_module(vm: &VirtualMachine) -> PyObjectRef {
 pub(crate) mod module {
     use crate::{
         builtins::{PyStrRef, PyTupleRef},
+        common::{crt_fd::Fd, suppress_iph},
         convert::ToPyException,
-        crt_fd::Fd,
         function::Either,
         function::OptionalArg,
         stdlib::os::{
             errno_err, DirFd, FollowSymlinks, PyPathLike, SupportFunc, TargetIsDirectory, _os,
             errno,
         },
-        suppress_iph, PyResult, TryFromObject, VirtualMachine,
+        PyResult, TryFromObject, VirtualMachine,
     };
     use std::{env, fs, io};
 
@@ -191,33 +191,6 @@ pub(crate) mod module {
         Ok(_os::PyTerminalSize { columns, lines })
     }
 
-    #[cfg(target_env = "msvc")]
-    type InvalidParamHandler = extern "C" fn(
-        *const libc::wchar_t,
-        *const libc::wchar_t,
-        *const libc::wchar_t,
-        libc::c_uint,
-        libc::uintptr_t,
-    );
-    #[cfg(target_env = "msvc")]
-    extern "C" {
-        #[doc(hidden)]
-        pub fn _set_thread_local_invalid_parameter_handler(
-            pNew: InvalidParamHandler,
-        ) -> InvalidParamHandler;
-    }
-
-    #[cfg(target_env = "msvc")]
-    #[doc(hidden)]
-    pub extern "C" fn silent_iph_handler(
-        _: *const libc::wchar_t,
-        _: *const libc::wchar_t,
-        _: *const libc::wchar_t,
-        _: libc::c_uint,
-        _: libc::uintptr_t,
-    ) {
-    }
-
     #[cfg(target_env = "msvc")]
     extern "C" {
         fn _wexecv(cmdname: *const u16, argv: *const *const u16) -> intptr_t;
@@ -409,19 +382,6 @@ pub(crate) mod module {
     }
 }
 
-#[cfg(all(windows, target_env = "msvc"))]
-#[macro_export]
-macro_rules! suppress_iph {
-    ($e:expr) => {{
-        let old = $crate::stdlib::nt::module::_set_thread_local_invalid_parameter_handler(
-            $crate::stdlib::nt::module::silent_iph_handler,
-        );
-        let ret = $e;
-        $crate::stdlib::nt::module::_set_thread_local_invalid_parameter_handler(old);
-        ret
-    }};
-}
-
 pub fn init_winsock() {
     static WSA_INIT: parking_lot::Once = parking_lot::Once::new();
     WSA_INIT.call_once(|| unsafe {

vm/src/stdlib/nt.rs

@@ -1,7 +1,7 @@
 use crate::{
     builtins::{PyBaseExceptionRef, PyBytes, PyBytesRef, PyInt, PySet, PyStr, PyStrRef},
+    common::crt_fd::Fd,
     convert::{ToPyException, ToPyObject},
-    crt_fd::Fd,
     function::{ArgumentError, FromArgs, FuncArgs},
     protocol::PyBuffer,
     AsObject, PyObject, PyObjectRef, PyPayload, PyResult, TryFromBorrowedObject, TryFromObject,
@@ -408,13 +408,13 @@ pub(super) mod _os {
         builtins::{
             PyBytesRef, PyGenericAlias, PyIntRef, PyStrRef, PyTuple, PyTupleRef, PyTypeRef,
         },
+        common::crt_fd::{Fd, Offset},
+        common::suppress_iph,
         convert::{ToPyException, ToPyObject},
-        crt_fd::{Fd, Offset},
         function::Either,
         function::{ArgBytesLike, FuncArgs, OptionalArg},
         protocol::PyIterReturn,
         recursion::ReprGuard,
-        suppress_iph,
         types::{IterNext, IterNextIterable, PyStructSequence},
         vm::VirtualMachine,
         AsObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject,
@@ -1123,7 +1123,13 @@ pub(super) mod _os {
         let [] = dir_fd.0;
         let meta = match file {
             PathOrFd::Path(path) => super::fs_metadata(&path, follow_symlinks.0)?,
-            PathOrFd::Fd(fno) => Fd(fno).as_rust_file()?.metadata()?,
+            PathOrFd::Fd(fno) => {
+                use std::os::windows::io::FromRawHandle;
+                let handle = Fd(fno).to_raw_handle()?;
+                let file =
+                    std::mem::ManuallyDrop::new(unsafe { std::fs::File::from_raw_handle(handle) });
+                file.metadata()?
+            }
         };
         meta_to_stat(&meta).map(Some)
     }
@@ -1825,11 +1831,3 @@ use super::posix as platform;
 use super::nt as platform;
 
 pub(crate) use platform::module::MODULE_NAME;
-
-#[cfg(not(all(windows, target_env = "msvc")))]
-#[macro_export]
-macro_rules! suppress_iph {
-    ($e:expr) => {
-        $e
-    };
-}

vm/src/stdlib/os.rs

@@ -1897,7 +1897,7 @@ pub mod module {
     struct SendFileArgs {
         out_fd: i32,
         in_fd: i32,
-        offset: crate::crt_fd::Offset,
+        offset: crate::common::crt_fd::Offset,
         count: i64,
         #[cfg(target_os = "macos")]
         #[pyarg(any, optional)]