Merge pull request RustPython#3658 from coolreader18/move-crt_fd

Move crt_fd to common

Author: youknowone

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;
@@ -24,7 +23,7 @@ pub type Offset = libc::c_longlong;
 #[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(crate::os::errno())
     } else {
         Ok(f(ret))
     }
@@ -73,50 +72,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 common/src/crt_fd.rsvm/src/crt_fd.rs renamed to common/src/crt_fd.rs

@@ -1,16 +1,23 @@
 //! 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;
 pub mod linked_list;
 pub mod lock;
+pub mod os;
 pub mod rc;
 pub mod refcount;
 pub mod static_cell;

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

@@ -0,0 +1,23 @@
+// TODO: we can move more os-specific bindings/interfaces from stdlib::{os, posix, nt} to here
+
+use std::io;
+
+#[cfg(windows)]
+pub 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))]
+pub fn errno() -> io::Error {
+    io::Error::last_os_error()
+}

common/src/os.rs

@@ -1927,7 +1927,7 @@ mod _socket {
         use winapi::um::winsock2::closesocket as close;
         let ret = unsafe { close(x as _) };
         if ret < 0 {
-            let err = crate::vm::stdlib::os::errno();
+            let err = crate::common::os::errno();
             if err.raw_os_error() != Some(errcode!(ECONNRESET)) {
                 return Err(err.to_pyexception(vm));
             }

stdlib/src/socket.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::{