Port from winapi to windows-sys.

Author: sunfishcode

Cargo.toml

@@ -11,10 +11,11 @@ repository = "https://github.com/sunfishcode/io-lifetimes"
 exclude = ["/.github"]
 
 [dependencies]
-# io-lifetimes only depends on libc/winapi for the ability to close
-# fds/handles/sockets. The following are just optional dependencies to add
-# foreign-type impls for the traits. In the future, we'll prefer to have
-# crates provide their own impls; this is just a temporary measure.
+# io-lifetimes only depends on libc/windows-sys for the ability to close
+# and duplicate fds/handles/sockets. The following are just optional
+# dependencies to add foreign-type impls for the traits. In the future,
+# we'll prefer to have crates provide their own impls; this is just a
+# temporary measure.
 
 # Optionally depend on async-std just to provide impls for its types for now.
 #
@@ -37,9 +38,18 @@ os_pipe = { version = "1.0.0", optional = true }
 [target.'cfg(not(windows))'.dependencies]
 libc = { version = "0.2.96", optional = true }
 
-[target.'cfg(windows)'.dependencies]
-winapi = { version = "0.3.9", optional = true, features = ["handleapi", "std", "winsock2"] }
+[target.'cfg(windows)'.dependencies.windows-sys]
+version = "0.35.0"
+optional = true
+features = [
+    "Win32_Foundation",
+    "Win32_Storage_FileSystem",
+    "Win32_Networking_WinSock",
+    "Win32_Security",
+    "Win32_System_IO",
+    "Win32_System_Threading",
+]
 
 [features]
 default = ["close"]
-close = ["libc", "winapi"]
+close = ["libc", "windows-sys"]

examples/hello.rs

@@ -18,7 +18,7 @@ use io_lifetimes::{AsFd, FromFd, OwnedFd};
 #[cfg(windows)]
 use io_lifetimes::{AsHandle, FromHandle, OwnedHandle};
 #[cfg(windows)]
-use std::{convert::TryInto, ptr::null_mut};
+use std::{convert::TryInto, os::windows::io::RawHandle, ptr::null_mut};
 
 #[cfg(all(rustc_attrs, unix, feature = "close"))]
 fn main() -> io::Result<()> {
@@ -71,7 +71,7 @@ fn main() -> io::Result<()> {
             null_mut(),
             OPEN_EXISTING,
             FILE_ATTRIBUTE_NORMAL,
-            null_mut(),
+            null_mut() as RawHandle as HANDLE,
         )
         .try_into()
         .map_err(|()| io::Error::last_os_error())?;
@@ -86,7 +86,7 @@ fn main() -> io::Result<()> {
             null_mut(),
         );
         match (result, number_of_bytes_written) {
-            (FALSE, _) => return Err(io::Error::last_os_error()),
+            (0, _) => return Err(io::Error::last_os_error()),
             (_, 13) => (),
             (_, _) => return Err(io::Error::new(io::ErrorKind::Other, "short write")),
         }
@@ -109,7 +109,7 @@ fn main() -> io::Result<()> {
             null_mut(),
         );
         match (result, number_of_bytes_written) {
-            (FALSE, _) => return Err(io::Error::last_os_error()),
+            (0, _) => return Err(io::Error::last_os_error()),
             (_, 5) => (),
             (_, _) => return Err(io::Error::new(io::ErrorKind::Other, "short write")),
         }

src/example_ffi.rs

@@ -11,10 +11,15 @@ use crate::{BorrowedHandle, HandleOrInvalid, OwnedHandle};
 #[cfg(any(unix, target_os = "wasi"))]
 use libc::{c_char, c_int, c_void, size_t, ssize_t};
 #[cfg(windows)]
-use winapi::{
-    shared::minwindef::{BOOL, DWORD, LPCVOID, LPDWORD, LPVOID},
-    shared::ntdef::{HANDLE, LPCWSTR},
-    um::minwinbase::{LPOVERLAPPED, LPSECURITY_ATTRIBUTES},
+use {
+    core::ffi::c_void,
+    windows_sys::core::PCWSTR,
+    windows_sys::Win32::Foundation::BOOL,
+    windows_sys::Win32::Security::SECURITY_ATTRIBUTES,
+    windows_sys::Win32::Storage::FileSystem::{
+        FILE_ACCESS_FLAGS, FILE_CREATION_DISPOSITION, FILE_FLAGS_AND_ATTRIBUTES, FILE_SHARE_MODE,
+    },
+    windows_sys::Win32::System::IO::OVERLAPPED,
 };
 
 // Declare a few FFI functions ourselves, to show off the FFI ergonomics.
@@ -36,32 +41,35 @@ pub use libc::{O_CLOEXEC, O_CREAT, O_RDONLY, O_RDWR, O_TRUNC, O_WRONLY};
 #[cfg(windows)]
 extern "system" {
     pub fn CreateFileW(
-        lpFileName: LPCWSTR,
-        dwDesiredAccess: DWORD,
-        dwShareMode: DWORD,
-        lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
-        dwCreationDisposition: DWORD,
-        dwFlagsAndAttributes: DWORD,
-        hTemplateFile: HANDLE,
+        lpfilename: PCWSTR,
+        dwdesiredaccess: FILE_ACCESS_FLAGS,
+        dwsharemode: FILE_SHARE_MODE,
+        lpsecurityattributes: *const SECURITY_ATTRIBUTES,
+        dwcreationdisposition: FILE_CREATION_DISPOSITION,
+        dwflagsandattributes: FILE_FLAGS_AND_ATTRIBUTES,
+        htemplatefile: HANDLE,
     ) -> HandleOrInvalid;
     pub fn ReadFile(
-        hFile: BorrowedHandle<'_>,
-        lpBuffer: LPVOID,
-        nNumberOfBytesToRead: DWORD,
-        lpNumberOfBytesRead: LPDWORD,
-        lpOverlapped: LPOVERLAPPED,
+        hfile: BorrowedHandle<'_>,
+        lpbuffer: *mut c_void,
+        nnumberofbytestoread: u32,
+        lpnumberofbytesread: *mut u32,
+        lpoverlapped: *mut OVERLAPPED,
     ) -> BOOL;
     pub fn WriteFile(
-        hFile: BorrowedHandle<'_>,
-        lpBuffer: LPCVOID,
-        nNumberOfBytesToWrite: DWORD,
-        lpNumberOfBytesWritten: LPDWORD,
-        lpOverlapped: LPOVERLAPPED,
+        hfile: BorrowedHandle<'_>,
+        lpbuffer: *const c_void,
+        nnumberofbytestowrite: u32,
+        lpnumberofbyteswritten: *mut u32,
+        lpoverlapped: *mut OVERLAPPED,
     ) -> BOOL;
 }
+
 #[cfg(windows)]
-pub use winapi::{
-    shared::minwindef::{FALSE, TRUE},
-    um::fileapi::{CREATE_ALWAYS, CREATE_NEW, OPEN_EXISTING},
-    um::winnt::{FILE_ATTRIBUTE_NORMAL, FILE_GENERIC_READ, FILE_GENERIC_WRITE},
+pub use {
+    windows_sys::Win32::Foundation::HANDLE,
+    windows_sys::Win32::Storage::FileSystem::{
+        CREATE_ALWAYS, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, FILE_GENERIC_READ, FILE_GENERIC_WRITE,
+        OPEN_EXISTING,
+    },
 };

src/types.rs

@@ -14,31 +14,24 @@ use std::{
     },
 };
 #[cfg(all(windows, feature = "close"))]
-use winapi::{
-    shared::minwindef::{BOOL, DWORD},
-    shared::ntdef::HANDLE,
-    um::handleapi::DuplicateHandle,
-    um::handleapi::SetHandleInformation,
-    um::handleapi::INVALID_HANDLE_VALUE,
-    um::processthreadsapi::GetCurrentProcess,
-    um::processthreadsapi::GetCurrentProcessId,
-    um::winbase::HANDLE_FLAG_INHERIT,
-    um::winnt::DUPLICATE_SAME_ACCESS,
-    um::winsock2::WSADuplicateSocketW,
-    um::winsock2::WSAGetLastError,
-    um::winsock2::WSASocketW,
-    um::winsock2::INVALID_SOCKET,
-    um::winsock2::SOCKET_ERROR,
-    um::winsock2::WSAEINVAL,
-    um::winsock2::WSAEPROTOTYPE,
-    um::winsock2::WSAPROTOCOL_INFOW,
-    um::winsock2::WSA_FLAG_NO_HANDLE_INHERIT,
-    um::winsock2::WSA_FLAG_OVERLAPPED,
+use {
+    windows_sys::Win32::Foundation::{
+        CloseHandle, DuplicateHandle, SetHandleInformation, BOOL, DUPLICATE_HANDLE_OPTIONS,
+        DUPLICATE_SAME_ACCESS, HANDLE, HANDLE_FLAG_INHERIT, INVALID_HANDLE_VALUE,
+    },
+    windows_sys::Win32::Networking::WinSock::{
+        closesocket, WSADuplicateSocketW, WSAGetLastError, WSASocketW, INVALID_SOCKET, SOCKET,
+        SOCKET_ERROR, WSAEINVAL, WSAEPROTOTYPE, WSAPROTOCOL_INFOW, WSA_FLAG_NO_HANDLE_INHERIT,
+        WSA_FLAG_OVERLAPPED,
+    },
+    windows_sys::Win32::System::Threading::{GetCurrentProcess, GetCurrentProcessId},
 };
 
-#[cfg(all(windows, not(feature = "winapi")))]
-const INVALID_HANDLE_VALUE: *mut core::ffi::c_void = !0 as _;
-#[cfg(all(windows, not(feature = "winapi")))]
+#[cfg(all(windows, not(feature = "close")))]
+type HANDLE = isize;
+#[cfg(all(windows, not(feature = "close")))]
+const INVALID_HANDLE_VALUE: HANDLE = !0 as _;
+#[cfg(all(windows, not(feature = "close")))]
 const INVALID_SOCKET: usize = !0 as _;
 
 /// A borrowed file descriptor.
@@ -235,16 +228,16 @@ impl OwnedHandle {
     #[cfg(feature = "close")]
     pub(crate) fn duplicate(
         &self,
-        access: DWORD,
+        access: u32,
         inherit: bool,
-        options: DWORD,
+        options: DUPLICATE_HANDLE_OPTIONS,
     ) -> std::io::Result<Self> {
         let mut ret = 0 as HANDLE;
         match unsafe {
             let cur_proc = GetCurrentProcess();
             DuplicateHandle(
                 cur_proc,
-                self.as_raw_handle(),
+                self.as_raw_handle() as HANDLE,
                 cur_proc,
                 &mut ret,
                 access,
@@ -255,7 +248,7 @@ impl OwnedHandle {
             0 => return Err(std::io::Error::last_os_error()),
             _ => (),
         }
-        unsafe { Ok(Self::from_raw_handle(ret)) }
+        unsafe { Ok(Self::from_raw_handle(ret as RawHandle)) }
     }
 }
 
@@ -496,7 +489,7 @@ impl TryFrom<HandleOrInvalid> for OwnedHandle {
     #[inline]
     fn try_from(handle_or_invalid: HandleOrInvalid) -> Result<Self, ()> {
         let raw = handle_or_invalid.0;
-        if raw == INVALID_HANDLE_VALUE {
+        if raw as HANDLE == INVALID_HANDLE_VALUE {
             // Don't call `CloseHandle`; it'd be harmless, except that it could
             // overwrite the `GetLastError` error.
             forget(handle_or_invalid);
@@ -706,7 +699,7 @@ impl Drop for OwnedHandle {
     fn drop(&mut self) {
         #[cfg(feature = "close")]
         unsafe {
-            let _ = winapi::um::handleapi::CloseHandle(self.handle);
+            let _ = CloseHandle(self.handle as HANDLE);
         }
 
         // If the `close` feature is disabled, we expect users to avoid letting
@@ -724,7 +717,7 @@ impl Drop for HandleOrInvalid {
     fn drop(&mut self) {
         #[cfg(feature = "close")]
         unsafe {
-            let _ = winapi::um::handleapi::CloseHandle(self.0);
+            let _ = CloseHandle(self.0 as HANDLE);
         }
 
         // If the `close` feature is disabled, we expect users to avoid letting
@@ -742,7 +735,7 @@ impl Drop for HandleOrNull {
     fn drop(&mut self) {
         #[cfg(feature = "close")]
         unsafe {
-            let _ = winapi::um::handleapi::CloseHandle(self.0);
+            let _ = CloseHandle(self.0 as HANDLE);
         }
 
         // If the `close` feature is disabled, we expect users to avoid letting
@@ -760,7 +753,7 @@ impl Drop for OwnedSocket {
     fn drop(&mut self) {
         #[cfg(feature = "close")]
         unsafe {
-            let _ = winapi::um::winsock2::closesocket(self.socket as winapi::um::winsock2::SOCKET);
+            let _ = closesocket(self.socket as SOCKET);
         }
 
         // If the `close` feature is disabled, we expect users to avoid letting

tests/assumptions.rs

@@ -28,12 +28,18 @@ fn test_assumptions() {
 fn test_assumptions() {
     assert_eq!(
         size_of::<std::os::windows::io::RawSocket>(),
-        size_of::<winapi::um::winsock2::SOCKET>()
+        size_of::<windows_sys::Win32::Networking::WinSock::SOCKET>()
+    );
+    assert_eq!(
+        size_of::<std::os::windows::io::RawHandle>(),
+        size_of::<windows_sys::Win32::Foundation::HANDLE>()
+    );
+    assert_eq!(
+        windows_sys::Win32::Networking::WinSock::INVALID_SOCKET,
+        usize::MAX
     );
-    assert_eq!(winapi::um::winsock2::INVALID_SOCKET, usize::MAX);
-
     assert_ne!(
-        winapi::um::handleapi::INVALID_HANDLE_VALUE,
-        std::ptr::null_mut()
+        windows_sys::Win32::Foundation::INVALID_HANDLE_VALUE,
+        std::ptr::null_mut() as std::os::windows::io::RawHandle as _
     );
 }

tests/ffi.rs

@@ -7,11 +7,10 @@ use io_lifetimes::example_ffi::*;
 #[cfg(windows)]
 use io_lifetimes::OwnedHandle;
 #[cfg(windows)]
-use std::{convert::TryInto, ptr::null_mut};
+use std::{convert::TryInto, os::windows::io::RawHandle, ptr::null_mut};
 #[cfg(windows)]
-use winapi::{
-    um::fileapi::OPEN_EXISTING,
-    um::winnt::{FILE_ATTRIBUTE_NORMAL, FILE_GENERIC_READ},
+use windows_sys::Win32::Storage::FileSystem::{
+    FILE_ATTRIBUTE_NORMAL, FILE_GENERIC_READ, OPEN_EXISTING,
 };
 
 #[cfg(all(rustc_attrs, unix))]
@@ -41,7 +40,7 @@ fn test_file_not_found() {
             null_mut(),
             OPEN_EXISTING,
             FILE_ATTRIBUTE_NORMAL,
-            null_mut(),
+            null_mut() as RawHandle as HANDLE,
         )
     }
     .try_into();
@@ -73,7 +72,7 @@ fn test_file_found() {
             null_mut(),
             OPEN_EXISTING,
             FILE_ATTRIBUTE_NORMAL,
-            null_mut(),
+            null_mut() as RawHandle as HANDLE,
         )
     }
     .try_into();