Add fallback for IO internals (pipe, handle):

- Add two fallback implementations in stdio redirection:

  - Add fallback when 'modern' anonymous pipe creation with async io is not available (pre-Vista)

  - Add fallback for when named pipes are not available (9x/ME, NT before 4.0)

    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/fs/windows.rs

@@ -342,7 +342,7 @@ impl File {
         Self::open_native(&path, opts)
     }
 
-    fn open_native(path: &WCStr, opts: &OpenOptions) -> io::Result<File> {
+    pub(crate) fn open_native(path: &WCStr, opts: &OpenOptions) -> io::Result<File> {
         let creation = opts.get_creation_mode()?;
         let sa = c::SECURITY_ATTRIBUTES {
             nLength: size_of::<c::SECURITY_ATTRIBUTES>() as u32,

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

@@ -113,22 +113,50 @@ unsafe extern "system" {
     pub fn ProcessPrng(pbdata: *mut u8, cbdata: usize) -> BOOL;
 }
 
-windows_link::link!("ntdll.dll" "system" fn NtCreateNamedPipeFile(
-    filehandle: *mut HANDLE,
-    desiredaccess: FILE_ACCESS_RIGHTS,
-    objectattributes: *const OBJECT_ATTRIBUTES,
-    iostatusblock: *mut IO_STATUS_BLOCK,
-    shareaccess: FILE_SHARE_MODE,
-    createdisposition: NTCREATEFILE_CREATE_DISPOSITION,
-    createoptions: NTCREATEFILE_CREATE_OPTIONS,
-    namedpipetype: u32,
-    readmode: u32,
-    completionmode: u32,
-    maximuminstances: u32,
-    inboundquota: u32,
-    outboundquota: u32,
-    defaulttimeout: *const u64,
-) -> NTSTATUS);
+cfg_select! {
+    target_family = "rust9x" => {
+        compat_fn_with_fallback! {
+            pub static NTDLL: &CStr = c"ntdll" => { load: false, unicows: false };
+            // NT only (duh)
+            pub fn NtCreateNamedPipeFile(
+                filehandle: *mut HANDLE,
+                desiredaccess: FILE_ACCESS_RIGHTS,
+                objectattributes: *const OBJECT_ATTRIBUTES,
+                iostatusblock: *mut IO_STATUS_BLOCK,
+                shareaccess: FILE_SHARE_MODE,
+                createdisposition: NTCREATEFILE_CREATE_DISPOSITION,
+                createoptions: NTCREATEFILE_CREATE_OPTIONS,
+                namedpipetype: u32,
+                readmode: u32,
+                completionmode: u32,
+                maximuminstances: u32,
+                inboundquota: u32,
+                outboundquota: u32,
+                defaulttimeout: *const u64,
+            ) -> NTSTATUS {
+                rtabort!("unimplemented")
+            }
+        }
+    }
+    _ => {
+        windows_link::link!("ntdll.dll" "system" fn NtCreateNamedPipeFile(
+            filehandle: *mut HANDLE,
+            desiredaccess: FILE_ACCESS_RIGHTS,
+            objectattributes: *const OBJECT_ATTRIBUTES,
+            iostatusblock: *mut IO_STATUS_BLOCK,
+            shareaccess: FILE_SHARE_MODE,
+            createdisposition: NTCREATEFILE_CREATE_DISPOSITION,
+            createoptions: NTCREATEFILE_CREATE_OPTIONS,
+            namedpipetype: u32,
+            readmode: u32,
+            completionmode: u32,
+            maximuminstances: u32,
+            inboundquota: u32,
+            outboundquota: u32,
+            defaulttimeout: *const u64,
+        ) -> NTSTATUS);
+    }
+}
 
 // Functions that aren't available on every version of Windows that we support,
 // but we still use them and just provide some form of a fallback implementation.
@@ -259,6 +287,67 @@ cfg_select! {
         windows_link::link_raw_dylib!("ntdll.dll" "system" fn NtWriteFile(filehandle : HANDLE, event : HANDLE, apcroutine : PIO_APC_ROUTINE, apccontext : *const core::ffi::c_void, iostatusblock : *mut IO_STATUS_BLOCK, buffer : *const core::ffi::c_void, length : u32, byteoffset : *const i64, key : *const u32) -> NTSTATUS);
         windows_link::link_raw_dylib!("ntdll.dll" "system" fn RtlNtStatusToDosError(status : NTSTATUS) -> u32);
     }
+    target_family = "rust9x" => {
+        compat_fn_with_fallback! {
+            pub static NTDLL: &CStr = c"ntdll" => { load: false, unicows: false };
+
+            pub fn NtCreateFile(
+                filehandle: *mut HANDLE,
+                desiredaccess: FILE_ACCESS_RIGHTS,
+                objectattributes: *const OBJECT_ATTRIBUTES,
+                iostatusblock: *mut IO_STATUS_BLOCK,
+                allocationsize: *const i64,
+                fileattributes: FILE_FLAGS_AND_ATTRIBUTES,
+                shareaccess: FILE_SHARE_MODE,
+                createdisposition: NTCREATEFILE_CREATE_DISPOSITION,
+                createoptions: NTCREATEFILE_CREATE_OPTIONS,
+                eabuffer: *const core::ffi::c_void,
+                ealength: u32
+            ) -> NTSTATUS {
+                STATUS_NOT_IMPLEMENTED
+            }
+
+            pub fn NtReadFile(
+                filehandle: HANDLE,
+                event: HANDLE,
+                apcroutine: PIO_APC_ROUTINE,
+                apccontext: *const c_void,
+                iostatusblock: *mut IO_STATUS_BLOCK,
+                buffer: *mut c_void,
+                length: u32,
+                byteoffset: *const i64,
+                key: *const u32
+            ) -> NTSTATUS {
+                STATUS_NOT_IMPLEMENTED
+            }
+            pub fn NtWriteFile(
+                filehandle: HANDLE,
+                event: HANDLE,
+                apcroutine: PIO_APC_ROUTINE,
+                apccontext: *const c_void,
+                iostatusblock: *mut IO_STATUS_BLOCK,
+                buffer: *const c_void,
+                length: u32,
+                byteoffset: *const i64,
+                key: *const u32
+            ) -> NTSTATUS {
+                STATUS_NOT_IMPLEMENTED
+            }
+            pub fn RtlNtStatusToDosError(Status: NTSTATUS) -> u32 {
+                ERROR_CALL_NOT_IMPLEMENTED
+            }
+            pub fn NtOpenFile(
+                filehandle: *mut HANDLE,
+                desiredaccess: u32,
+                objectattributes: *const OBJECT_ATTRIBUTES,
+                iostatusblock: *mut IO_STATUS_BLOCK,
+                shareaccess: u32,
+                openoptions: u32
+            ) -> NTSTATUS {
+                STATUS_NOT_IMPLEMENTED
+            }
+        }
+    }
     _ => {}
 }
 
@@ -643,3 +732,13 @@ compat_fn_with_fallback! {
         rtabort!("unimplemented")
     }
 }
+
+#[cfg(target_family = "rust9x")]
+compat_fn_with_fallback! {
+    pub static KERNEL32: &CStr = c"kernel32" => { load: false, unicows: false };
+    // >= 98+, NT4.0
+    // https://learn.microsoft.com/en-us/windows/win32/api/stringapiset/nf-stringapiset-comparestringordinal
+    pub fn CancelIo(hfile: HANDLE) -> BOOL {
+        rtabort!("unimplemented")
+    }
+}

library/std/src/sys/pal/windows/c/bindings.txt

@@ -2556,6 +2556,7 @@ WINSOCK_SOCKET_TYPE
 WRITE_DAC
 WRITE_OWNER
 WriteConsoleW
+WriteFile
 WriteFileEx
 WSA_E_CANCELLED
 WSA_E_NO_MORE

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

@@ -152,6 +152,7 @@ windows_link::link!("kernel32.dll" "system" fn WakeAllConditionVariable(conditio
 windows_link::link!("kernel32.dll" "system" fn WakeConditionVariable(conditionvariable : *mut CONDITION_VARIABLE));
 windows_link::link!("kernel32.dll" "system" fn WideCharToMultiByte(codepage : u32, dwflags : u32, lpwidecharstr : PCWSTR, cchwidechar : i32, lpmultibytestr : PSTR, cbmultibyte : i32, lpdefaultchar : PCSTR, lpuseddefaultchar : *mut BOOL) -> i32);
 windows_link::link!("kernel32.dll" "system" fn WriteConsoleW(hconsoleoutput : HANDLE, lpbuffer : PCWSTR, nnumberofcharstowrite : u32, lpnumberofcharswritten : *mut u32, lpreserved : *const core::ffi::c_void) -> BOOL);
+windows_link::link!("kernel32.dll" "system" fn WriteFile(hfile : HANDLE, lpbuffer : *const u8, nnumberofbytestowrite : u32, lpnumberofbyteswritten : *mut u32, lpoverlapped : *mut OVERLAPPED) -> BOOL);
 windows_link::link!("kernel32.dll" "system" fn WriteFileEx(hfile : HANDLE, lpbuffer : *const u8, nnumberofbytestowrite : u32, lpoverlapped : *mut OVERLAPPED, lpcompletionroutine : LPOVERLAPPED_COMPLETION_ROUTINE) -> BOOL);
 windows_link::link!("ws2_32.dll" "system" fn accept(s : SOCKET, addr : *mut SOCKADDR, addrlen : *mut i32) -> SOCKET);
 windows_link::link!("ws2_32.dll" "system" fn bind(s : SOCKET, name : *const SOCKADDR, namelen : i32) -> i32);

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

@@ -16,6 +16,23 @@ pub fn is_windows_nt() -> bool {
     true // let me know once someone ported 9x to 64bit LOL
 }
 
+#[inline(always)]
+pub fn supports_async_io() -> bool {
+    unsafe { SUPPORTS_ASYNC_IO }
+}
+
+/// Whether the new way (just opening \??\PIPE\ / \Device\NamedPipe without a file/pipe name creates
+/// an anon pipe) is supported.
+///
+/// Prior to Vista (NT 6), kernel32's `CreatePipe` would create a pipe with a unique name via
+/// `_sprintf(Buffer, "\\Device\\NamedPipe\\Win32Pipes.%08x.%08x", process_id, global_counter)`;
+///
+/// see https://github.com/rust-lang/rust/pull/142517
+#[inline(always)]
+pub fn supports_anon_pipe_autoname() -> bool {
+    unsafe { SUPPORTS_ANON_PIPE_AUTONAME }
+}
+
 pub fn init_rust9x_checks() {
     // DO NOT do anything interesting or complicated in this function! DO NOT call
     // any Rust functions or CRT functions if those functions touch any global state,
@@ -26,11 +43,18 @@ pub fn init_rust9x_checks() {
     init_mutex_kind_check();
 }
 
-static mut IS_NT: bool = true;
+static mut IS_NT: bool = false;
+static mut SUPPORTS_ASYNC_IO: bool = false;
+static mut SUPPORTS_ANON_PIPE_AUTONAME: bool = false;
 
 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 {
+        let version = c::GetVersion();
+        IS_NT = version < 0x8000_0000;
+        SUPPORTS_ASYNC_IO = IS_NT && c::CancelIo::available().is_some();
+        SUPPORTS_ANON_PIPE_AUTONAME = IS_NT && version & 0xFF >= 0x06; // Vista+/NT6+
+    };
 }
 
 #[derive(Clone, Copy, PartialEq)]

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

@@ -254,6 +254,32 @@ impl Handle {
 
         // The length is clamped at u32::MAX.
         let len = cmp::min(len, u32::MAX as usize) as u32;
+
+        #[cfg(target_family = "rust9x")]
+        if !crate::sys::compat::checks::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_read = 0;
+                cvt(c::ReadFile(
+                    self.as_raw_handle(),
+                    buf.cast(),
+                    len,
+                    &mut bytes_read,
+                    ptr::null_mut(),
+                ))?;
+
+                return Ok(bytes_read as usize);
+            }
+        }
+
         // SAFETY: It's up to the caller to ensure `buf` is writeable up to
         // the provided `len`.
         let status = unsafe {
@@ -306,6 +332,32 @@ impl Handle {
 
         // The length is clamped at u32::MAX.
         let len = cmp::min(buf.len(), u32::MAX as usize) as u32;
+
+        #[cfg(target_family = "rust9x")]
+        if !crate::sys::compat::checks::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 status = unsafe {
             c::NtWriteFile(
                 self.as_raw_handle(),