Add fallback for io internals

Add fallback implementation in stdio redirection for when named pipes are not available

    Since Windows 9X/ME does not support creating named pipes (only
    connecting to remote pipes created on NT), we'll have to make do with
    anonymous pipes, without overlapped I/O. In particular, this means that
    we'll have to spawn another thread in the case where both stdout and
    stderr are being piped and read from (`read2`).

    We also use the fallback implementation on NT before 4.0, as the `Drop`
    impl of `AsyncPipe` needs to be able to cancel I/O via `CancelIo`.

Add fallbacks for `NtReadFile` and `NtWriteFile` in `synchronous_{read, write}`

  These might be unsound for handles that _can_ be asynchronous on 9x/ME.
  See rust-lang#95469 for more info

Author: seritools

library/std/src/sys/windows/c.rs

@@ -474,6 +474,8 @@ compat_fn_lazy! {
         cchcount2: i32,
         bignorecase: BOOL,
     ) -> COMPARESTRING_RESULT;
+
+    pub fn CancelIo(hfile: HANDLE) -> BOOL;
 }
 
 compat_fn_optional! {

library/std/src/sys/windows/c/windows_sys.lst

@@ -2631,3 +2631,8 @@ Windows.Win32.System.SystemInformation.GetVersion
 Windows.Win32.Storage.FileSystem.CopyFileW
 Windows.Win32.Storage.FileSystem.GetFileSize
 Windows.Win32.Storage.FileSystem.INVALID_FILE_SIZE
+
+// async io fallbacks
+Windows.Win32.System.IO.CancelIo
+Windows.Win32.System.Pipes.CreatePipe
+Windows.Win32.Storage.FileSystem.WriteFile

library/std/src/sys/windows/c/windows_sys.rs

@@ -142,6 +142,15 @@ extern "system" {
     ) -> HANDLE;
 }
 #[link(name = "kernel32")]
+extern "system" {
+    pub fn CreatePipe(
+        hreadpipe: *mut HANDLE,
+        hwritepipe: *mut HANDLE,
+        lppipeattributes: *const SECURITY_ATTRIBUTES,
+        nsize: u32,
+    ) -> BOOL;
+}
+#[link(name = "kernel32")]
 extern "system" {
     pub fn CreateProcessW(
         lpapplicationname: PCWSTR,
@@ -724,6 +733,16 @@ extern "system" {
     ) -> BOOL;
 }
 #[link(name = "kernel32")]
+extern "system" {
+    pub fn WriteFile(
+        hfile: HANDLE,
+        lpbuffer: *const u8,
+        nnumberofbytestowrite: u32,
+        lpnumberofbyteswritten: *mut u32,
+        lpoverlapped: *mut OVERLAPPED,
+    ) -> BOOL;
+}
+#[link(name = "kernel32")]
 extern "system" {
     pub fn WriteFileEx(
         hfile: HANDLE,

library/std/src/sys/windows/compat.rs

@@ -25,7 +25,7 @@ use crate::sync::atomic::Ordering;
 use crate::sys::c;
 
 mod version;
-pub use version::is_windows_nt;
+pub use version::{is_windows_nt, supports_async_io};
 
 // This uses a static initializer to preload some imported functions.
 // The CRT (C runtime) executes static initializers before `main`

library/std/src/sys/windows/compat/version.rs

@@ -1,10 +1,14 @@
 use crate::sys::c;
 
 static mut IS_NT: bool = true;
+static mut SUPPORTS_ASYNC_IO: bool = true;
 
 pub fn init_windows_version_check() {
     // according to old MSDN info, the high-order bit is set only on 95/98/ME.
-    unsafe { IS_NT = c::GetVersion() < 0x8000_0000 };
+    unsafe {
+        IS_NT = c::GetVersion() < 0x8000_0000;
+        SUPPORTS_ASYNC_IO = IS_NT && c::CancelIo::option().is_some();
+    };
 }
 
 /// Returns true if we are running on a Windows NT-based system. Only use this for APIs where the
@@ -13,3 +17,8 @@ pub fn init_windows_version_check() {
 pub fn is_windows_nt() -> bool {
     unsafe { IS_NT }
 }
+
+#[inline(always)]
+pub fn supports_async_io() -> bool {
+    unsafe { SUPPORTS_ASYNC_IO }
+}

library/std/src/sys/windows/handle.rs

@@ -3,6 +3,7 @@
 #[cfg(test)]
 mod tests;
 
+use super::compat;
 use crate::cmp;
 use crate::io::{self, BorrowedCursor, ErrorKind, IoSlice, IoSliceMut, Read};
 use crate::mem;
@@ -230,10 +231,32 @@ impl Handle {
         len: usize,
         offset: Option<u64>,
     ) -> io::Result<usize> {
-        let mut io_status = c::IO_STATUS_BLOCK::PENDING;
-
         // The length is clamped at u32::MAX.
         let len = cmp::min(len, c::DWORD::MAX as usize) as c::DWORD;
+
+        if !compat::supports_async_io() {
+            if let Some(offset) = offset {
+                cvt(c::SetFilePointerEx(
+                    self.as_raw_handle(),
+                    offset as i64,
+                    ptr::null_mut(),
+                    c::FILE_BEGIN,
+                ))?;
+            }
+
+            let mut bytes_read = 0;
+            cvt(c::ReadFile(
+                self.as_raw_handle(),
+                buf.cast(),
+                len,
+                &mut bytes_read,
+                ptr::null_mut(),
+            ))?;
+
+            return Ok(bytes_read as usize);
+        }
+
+        let mut io_status = c::IO_STATUS_BLOCK::PENDING;
         let status = c::NtReadFile(
             self.as_handle(),
             ptr::null_mut(),
@@ -278,10 +301,34 @@ impl Handle {
     ///
     /// If `offset` is `None` then the current file position is used.
     fn synchronous_write(&self, buf: &[u8], offset: Option<u64>) -> io::Result<usize> {
-        let mut io_status = c::IO_STATUS_BLOCK::PENDING;
-
         // The length is clamped at u32::MAX.
         let len = cmp::min(buf.len(), c::DWORD::MAX as usize) as c::DWORD;
+
+        if !compat::supports_async_io() {
+            unsafe {
+                if let Some(offset) = offset {
+                    cvt(c::SetFilePointerEx(
+                        self.as_raw_handle(),
+                        offset as i64,
+                        ptr::null_mut(),
+                        c::FILE_BEGIN,
+                    ))?;
+                }
+
+                let mut bytes_written = 0;
+                cvt(c::WriteFile(
+                    self.as_raw_handle(),
+                    buf.as_ptr(),
+                    len,
+                    &mut bytes_written,
+                    ptr::null_mut(),
+                ))?;
+
+                return Ok(bytes_written as usize);
+            }
+        }
+
+        let mut io_status = c::IO_STATUS_BLOCK::PENDING;
         let status = unsafe {
             c::NtWriteFile(
                 self.as_handle(),

library/std/src/sys/windows/pipe.rs

@@ -62,6 +62,60 @@ pub fn anon_pipe(ours_readable: bool, their_handle_inheritable: bool) -> io::Res
     // A 64kb pipe capacity is the same as a typical Linux default.
     const PIPE_BUFFER_CAPACITY: u32 = 64 * 1024;
 
+    // Since Windows 9X/ME does not support creating named pipes (only connecting to remote pipes
+    // created on NT), we'll have to make do with anonymous pipes, without overlapped I/O. In
+    // particular, this means that we'll have to do reading from two threads in the case where both
+    // stdout and stderr being piped (see `read2`).
+
+    // 9X/ME *does* have a kernel32 export entry for `CreateNamedPipe`, so an availability check
+    // would not work. We're just gonna check the bit that's only set on non-unicode Windows
+    // versions instead...
+
+    // The `AnonPipe` impl used in `read2` below needs to be able to cancel the overlapped i/o
+    // operation, so we also have to check for `CancelIo` being available. This means that the
+    // "modern" path is taken only for NT4+.
+    if !crate::sys::compat::supports_async_io() {
+        let size = mem::size_of::<c::SECURITY_ATTRIBUTES>();
+        let mut sa = c::SECURITY_ATTRIBUTES {
+            nLength: size as c::DWORD,
+            lpSecurityDescriptor: ptr::null_mut(),
+            // We follow the old "Creating a Child Process with Redirected Input and Output" MSDN
+            // entry (pre-`SetHandleInformation`) here, duplicating the handle that is not being
+            // sent to the child process as non-inheritable and then closing the inheritable one.
+            // Usually, this would be racy, but this function is only called in `Stdio::to_handle`,
+            // which is in turn only called form `process::spawn`, which acquires a lock on process
+            // spawning because of this.
+            bInheritHandle: c::TRUE,
+        };
+
+        unsafe {
+            let mut read_pipe = mem::zeroed();
+            let mut write_pipe = mem::zeroed();
+            crate::sys::cvt(c::CreatePipe(
+                &mut read_pipe,
+                &mut write_pipe,
+                &mut sa,
+                PIPE_BUFFER_CAPACITY,
+            ))?;
+            let read_pipe = Handle::from_raw_handle(read_pipe);
+            let write_pipe = Handle::from_raw_handle(write_pipe);
+
+            let (ours_inheritable, theirs) =
+                if ours_readable { (read_pipe, write_pipe) } else { (write_pipe, read_pipe) };
+
+            // Make `ours` non-inheritable by duplicating it with the approriate setting
+            let ours = ours_inheritable.duplicate(0, false, c::DUPLICATE_SAME_ACCESS)?;
+
+            // close the old, inheritable handle to the pipe end that is ours
+            drop(ours_inheritable);
+
+            return Ok(Pipes {
+                ours: AnonPipe { inner: ours },
+                theirs: AnonPipe { inner: theirs },
+            });
+        }
+    }
+
     // Note that we specifically do *not* use `CreatePipe` here because
     // unfortunately the anonymous pipes returned do not support overlapped
     // operations. Instead, we create a "hopefully unique" name and create a
@@ -243,6 +297,10 @@ impl AnonPipe {
     }
 
     pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
+        if !crate::sys::compat::supports_async_io() {
+            return self.inner.read(buf);
+        }
+
         let result = unsafe {
             let len = crate::cmp::min(buf.len(), c::DWORD::MAX as usize) as c::DWORD;
             self.alertable_io_internal(c::ReadFileEx, buf.as_mut_ptr() as _, len)
@@ -259,6 +317,10 @@ impl AnonPipe {
     }
 
     pub fn read_buf(&self, mut buf: BorrowedCursor<'_>) -> io::Result<()> {
+        if !crate::sys::compat::supports_async_io() {
+            return self.inner.read_buf(buf);
+        }
+
         let result = unsafe {
             let len = crate::cmp::min(buf.capacity(), c::DWORD::MAX as usize) as c::DWORD;
             self.alertable_io_internal(c::ReadFileEx, buf.as_mut().as_mut_ptr() as _, len)
@@ -294,6 +356,10 @@ impl AnonPipe {
     }
 
     pub fn write(&self, buf: &[u8]) -> io::Result<usize> {
+        if !crate::sys::compat::supports_async_io() {
+            return self.inner.write(buf);
+        }
+
         unsafe {
             let len = crate::cmp::min(buf.len(), c::DWORD::MAX as usize) as c::DWORD;
             self.alertable_io_internal(c::WriteFileEx, buf.as_ptr() as _, len)
@@ -408,6 +474,25 @@ pub fn read2(p1: AnonPipe, v1: &mut Vec<u8>, p2: AnonPipe, v2: &mut Vec<u8>) ->
     let p1 = p1.into_handle();
     let p2 = p2.into_handle();
 
+    if !crate::sys::compat::supports_async_io() {
+        use crate::io::Read;
+
+        // Since we are using anonymous pipes (= without overlapped I/O support) here, we can't do
+        // async waiting on both stdout and stderr at the same time on one thread, so we have to
+        // spawn an additional thread to do the waiting for the second pipe.
+
+        // See https://github.com/rust-lang/rust/pull/31618, where this was removed initially.
+        let second_pipe = crate::thread::spawn(move || {
+            let mut ret = Vec::new();
+            (&p2).read_to_end(&mut ret).map(|_| ret)
+        });
+
+        (&p1).read_to_end(v1)?;
+        *v2 = second_pipe.join().unwrap()?;
+
+        return Ok(());
+    }
+
     let mut p1 = AsyncPipe::new(p1, v1)?;
     let mut p2 = AsyncPipe::new(p2, v2)?;
     let objs = [p1.event.as_raw_handle(), p2.event.as_raw_handle()];