Auto merge of #11656 - attila-lin:dev/windows, r=epage

Replace `winapi` with `windows-sys` crate.

### What does this PR try to resolve?

replace `winapi` with `windows-sys` crate.

It's officially maintained.

### How should we test and review this PR?

I just do the replacement of API. I think it is quite clear.

And I found a `cfg` for `windows` may miss checked error.

### Additional information

No one.

Author: bors

Cargo.toml

@@ -84,25 +84,16 @@ rustc-workspace-hack = "1.0.0"
 [target.'cfg(windows)'.dependencies]
 fwdansi = "1.1.0"
 
-[target.'cfg(windows)'.dependencies.winapi]
-version = "0.3"
+[target.'cfg(windows)'.dependencies.windows-sys]
+version = "0.45"
 features = [
-  "basetsd",
-  "handleapi",
-  "jobapi",
-  "jobapi2",
-  "memoryapi",
-  "minwindef",
-  "ntdef",
-  "ntstatus",
-  "processenv",
-  "processthreadsapi",
-  "psapi",
-  "synchapi",
-  "winerror",
-  "winbase",
-  "wincon",
-  "winnt",
+  "Win32_Foundation",
+  "Win32_Storage_FileSystem",
+  "Win32_System_IO",
+  "Win32_System_Threading",
+  "Win32_System_JobObjects",
+  "Win32_Security",
+  "Win32_System_SystemServices"
 ]
 
 [dev-dependencies]

crates/cargo-test-support/Cargo.toml

@@ -29,7 +29,7 @@ toml_edit = { version = "0.15.0", features = ["serde", "easy", "perf"] }
 url = "2.2.2"
 
 [target.'cfg(windows)'.dependencies]
-winapi = "0.3"
+windows-sys = { version = "0.45.0", features = ["Win32_Storage_FileSystem"] }
 
 [features]
 deny-warnings = []

crates/cargo-test-support/src/paths.rs

@@ -305,7 +305,7 @@ pub fn windows_reserved_names_are_allowed() -> bool {
     use std::ffi::OsStr;
     use std::os::windows::ffi::OsStrExt;
     use std::ptr;
-    use winapi::um::fileapi::GetFullPathNameW;
+    use windows_sys::Win32::Storage::FileSystem::GetFullPathNameW;
 
     let test_file_name: Vec<_> = OsStr::new("aux.rs").encode_wide().collect();
 

crates/cargo-util/Cargo.toml

@@ -25,4 +25,4 @@ core-foundation = { version = "0.9.0", features = ["mac_os_10_7_support"] }
 
 [target.'cfg(windows)'.dependencies]
 miow = "0.5.0"
-winapi = { version = "0.3.9", features = ["consoleapi", "minwindef"] }
+windows-sys = { version = "0.45.0", features = ["Win32_Storage_FileSystem", "Win32_Foundation", "Win32_System_Console"] }

crates/cargo-util/src/paths.rs

@@ -701,8 +701,9 @@ fn exclude_from_content_indexing(path: &Path) {
     {
         use std::iter::once;
         use std::os::windows::prelude::OsStrExt;
-        use winapi::um::fileapi::{GetFileAttributesW, SetFileAttributesW};
-        use winapi::um::winnt::FILE_ATTRIBUTE_NOT_CONTENT_INDEXED;
+        use windows_sys::Win32::Storage::FileSystem::{
+            GetFileAttributesW, SetFileAttributesW, FILE_ATTRIBUTE_NOT_CONTENT_INDEXED,
+        };
 
         let path: Vec<u16> = path.as_os_str().encode_wide().chain(once(0)).collect();
         unsafe {

crates/cargo-util/src/process_builder.rs

@@ -606,10 +606,10 @@ mod imp {
     use super::{ProcessBuilder, ProcessError};
     use anyhow::Result;
     use std::io;
-    use winapi::shared::minwindef::{BOOL, DWORD, FALSE, TRUE};
-    use winapi::um::consoleapi::SetConsoleCtrlHandler;
+    use windows_sys::Win32::Foundation::{BOOL, FALSE, TRUE};
+    use windows_sys::Win32::System::Console::SetConsoleCtrlHandler;
 
-    unsafe extern "system" fn ctrlc_handler(_: DWORD) -> BOOL {
+    unsafe extern "system" fn ctrlc_handler(_: u32) -> BOOL {
         // Do nothing; let the child process handle it.
         TRUE
     }
@@ -626,7 +626,7 @@ mod imp {
     }
 
     pub fn command_line_too_big(err: &io::Error) -> bool {
-        use winapi::shared::winerror::ERROR_FILENAME_EXCED_RANGE;
+        use windows_sys::Win32::Foundation::ERROR_FILENAME_EXCED_RANGE;
         err.raw_os_error() == Some(ERROR_FILENAME_EXCED_RANGE as i32)
     }
 }

crates/cargo-util/src/process_error.rs

@@ -140,11 +140,10 @@ pub fn exit_status_to_string(status: ExitStatus) -> String {
 
     #[cfg(windows)]
     fn status_to_string(status: ExitStatus) -> String {
-        use winapi::shared::minwindef::DWORD;
-        use winapi::um::winnt::*;
+        use windows_sys::Win32::Foundation::*;
 
         let mut base = status.to_string();
-        let extra = match status.code().unwrap() as DWORD {
+        let extra = match status.code().unwrap() as i32 {
             STATUS_ACCESS_VIOLATION => "STATUS_ACCESS_VIOLATION",
             STATUS_IN_PAGE_ERROR => "STATUS_IN_PAGE_ERROR",
             STATUS_INVALID_HANDLE => "STATUS_INVALID_HANDLE",

crates/cargo-util/src/read2.rs

@@ -84,7 +84,7 @@ mod imp {
     use miow::iocp::{CompletionPort, CompletionStatus};
     use miow::pipe::NamedPipe;
     use miow::Overlapped;
-    use winapi::shared::winerror::ERROR_BROKEN_PIPE;
+    use windows_sys::Win32::Foundation::ERROR_BROKEN_PIPE;
 
     struct Pipe<'a> {
         dst: &'a mut Vec<u8>,

crates/credential/cargo-credential-wincred/Cargo.toml

@@ -8,4 +8,4 @@ description = "A Cargo credential process that stores tokens with Windows Creden
 
 [dependencies]
 cargo-credential = { version = "0.2.0", path = "../cargo-credential" }
-winapi = { version = "0.3.9", features = ["wincred", "winerror", "impl-default"] }
+windows-sys = { version = "0.45", features = ["Win32_Foundation", "Win32_Security_Credentials"] }

crates/credential/cargo-credential-wincred/src/main.rs

@@ -3,10 +3,17 @@
 use cargo_credential::{Credential, Error};
 use std::ffi::OsStr;
 use std::os::windows::ffi::OsStrExt;
-use winapi::shared::minwindef::{DWORD, FILETIME, LPBYTE, TRUE};
-use winapi::shared::winerror;
-use winapi::um::wincred;
-use winapi::um::winnt::LPWSTR;
+
+use windows_sys::core::PWSTR;
+use windows_sys::Win32::Foundation::ERROR_NOT_FOUND;
+use windows_sys::Win32::Foundation::FILETIME;
+use windows_sys::Win32::Foundation::TRUE;
+use windows_sys::Win32::Security::Credentials::CredDeleteW;
+use windows_sys::Win32::Security::Credentials::CredReadW;
+use windows_sys::Win32::Security::Credentials::CredWriteW;
+use windows_sys::Win32::Security::Credentials::CREDENTIALW;
+use windows_sys::Win32::Security::Credentials::CRED_PERSIST_LOCAL_MACHINE;
+use windows_sys::Win32::Security::Credentials::CRED_TYPE_GENERIC;
 
 struct WindowsCredential;
 
@@ -31,13 +38,13 @@ impl Credential for WindowsCredential {
 
     fn get(&self, index_url: &str) -> Result<String, Error> {
         let target_name = target_name(index_url);
-        let mut p_credential: wincred::PCREDENTIALW = std::ptr::null_mut();
+        let p_credential: *mut CREDENTIALW = std::ptr::null_mut() as *mut _;
         unsafe {
-            if wincred::CredReadW(
+            if CredReadW(
                 target_name.as_ptr(),
-                wincred::CRED_TYPE_GENERIC,
+                CRED_TYPE_GENERIC,
                 0,
-                &mut p_credential,
+                p_credential as *mut _ as *mut _,
             ) != TRUE
             {
                 return Err(
@@ -59,21 +66,24 @@ impl Credential for WindowsCredential {
             Some(name) => wstr(&format!("Cargo registry token for {}", name)),
             None => wstr("Cargo registry token"),
         };
-        let mut credential = wincred::CREDENTIALW {
+        let mut credential = CREDENTIALW {
             Flags: 0,
-            Type: wincred::CRED_TYPE_GENERIC,
-            TargetName: target_name.as_ptr() as LPWSTR,
-            Comment: comment.as_ptr() as LPWSTR,
-            LastWritten: FILETIME::default(),
-            CredentialBlobSize: token.len() as DWORD,
-            CredentialBlob: token.as_ptr() as LPBYTE,
-            Persist: wincred::CRED_PERSIST_LOCAL_MACHINE,
+            Type: CRED_TYPE_GENERIC,
+            TargetName: target_name.as_ptr() as PWSTR,
+            Comment: comment.as_ptr() as PWSTR,
+            LastWritten: FILETIME {
+                dwLowDateTime: 0,
+                dwHighDateTime: 0,
+            },
+            CredentialBlobSize: token.len() as u32,
+            CredentialBlob: token.as_ptr() as *mut u8,
+            Persist: CRED_PERSIST_LOCAL_MACHINE,
             AttributeCount: 0,
             Attributes: std::ptr::null_mut(),
             TargetAlias: std::ptr::null_mut(),
             UserName: std::ptr::null_mut(),
         };
-        let result = unsafe { wincred::CredWriteW(&mut credential, 0) };
+        let result = unsafe { CredWriteW(&mut credential, 0) };
         if result != TRUE {
             let err = std::io::Error::last_os_error();
             return Err(format!("failed to store token: {}", err).into());
@@ -83,11 +93,10 @@ impl Credential for WindowsCredential {
 
     fn erase(&self, index_url: &str) -> Result<(), Error> {
         let target_name = target_name(index_url);
-        let result =
-            unsafe { wincred::CredDeleteW(target_name.as_ptr(), wincred::CRED_TYPE_GENERIC, 0) };
+        let result = unsafe { CredDeleteW(target_name.as_ptr(), CRED_TYPE_GENERIC, 0) };
         if result != TRUE {
             let err = std::io::Error::last_os_error();
-            if err.raw_os_error() == Some(winerror::ERROR_NOT_FOUND as i32) {
+            if err.raw_os_error() == Some(ERROR_NOT_FOUND as i32) {
                 eprintln!("not currently logged in to `{}`", index_url);
                 return Ok(());
             }