Switch to windows-bindgen

Author: djc

Cargo.lock

@@ -26,11 +26,15 @@ cfg-if = "^1.0"
 libc = "^0.2"
 
 [target.'cfg(target_os = "windows")'.dependencies]
-windows = { version = "^0.52", features = ["Win32_Foundation", "Win32_System_SystemInformation"] }
+windows-link = "0.1.1"
 
 [dev-dependencies]
 version-sync = "0.9"
 
+[target.'cfg(target_os = "windows")'.dev-dependencies]
+windows-bindgen = { version = "0.61" }
+similar-asserts = { version = "1.6.1" }
+
 [package.metadata.docs.rs]
 features = ["set"]
 rustdoc-args = ["--cfg", "docsrs"]

Cargo.toml

@@ -0,0 +1,15 @@
+#![allow(
+    non_snake_case,
+    non_upper_case_globals,
+    non_camel_case_types,
+    dead_code,
+    clippy::all
+)]
+
+windows_link::link!("kernel32.dll" "system" fn GetComputerNameExW(nametype : COMPUTER_NAME_FORMAT, lpbuffer : PWSTR, nsize : *mut u32) -> BOOL);
+windows_link::link!("kernel32.dll" "system" fn SetComputerNameExW(nametype : COMPUTER_NAME_FORMAT, lpbuffer : PCWSTR) -> BOOL);
+pub type BOOL = i32;
+pub type COMPUTER_NAME_FORMAT = i32;
+pub const ComputerNamePhysicalDnsHostname: COMPUTER_NAME_FORMAT = 5i32;
+pub type PCWSTR = *const u16;
+pub type PWSTR = *mut u16;

src/windows/bindings.rs

@@ -5,58 +5,60 @@ use std::io;
 #[cfg(feature = "set")]
 use std::os::windows::ffi::OsStrExt;
 use std::os::windows::ffi::OsStringExt;
+use std::ptr;
 
-use windows::core::PWSTR;
-use windows::Win32::System::SystemInformation::{
-    ComputerNamePhysicalDnsHostname, GetComputerNameExW,
-};
+mod bindings;
+use bindings::{ComputerNamePhysicalDnsHostname, GetComputerNameExW, PWSTR};
 
 pub fn get() -> io::Result<OsString> {
     let mut size = 0;
     unsafe {
         // Don't care much about the result here,
         // it is guaranteed to return an error,
         // since we passed the NULL pointer as a buffer
-        let result = GetComputerNameExW(ComputerNamePhysicalDnsHostname, PWSTR::null(), &mut size);
-        debug_assert!(result.is_err());
+        let result =
+            GetComputerNameExW(ComputerNamePhysicalDnsHostname, ptr::null_mut(), &mut size);
+        debug_assert_eq!(result, 0);
     };
 
     let mut buffer = Vec::with_capacity(size as usize);
 
     let result = unsafe {
         GetComputerNameExW(
             ComputerNamePhysicalDnsHostname,
-            PWSTR::from_raw(buffer.as_mut_ptr()),
+            PWSTR::from(buffer.as_mut_ptr()),
             &mut size,
         )
     };
 
     match result {
-        Ok(_) => {
+        0 => Err(io::Error::last_os_error()),
+        _ => {
             unsafe {
                 buffer.set_len(size as usize);
             }
 
             Ok(OsString::from_wide(&buffer))
         }
-        Err(e) => Err(io::Error::from_raw_os_error(e.code().0)),
     }
 }
 
 #[cfg(feature = "set")]
 pub fn set(hostname: &OsStr) -> io::Result<()> {
-    use windows::core::PCWSTR;
-    use windows::Win32::System::SystemInformation::SetComputerNameExW;
+    use bindings::{SetComputerNameExW, PCWSTR};
 
     let mut buffer = hostname.encode_wide().collect::<Vec<_>>();
     buffer.push(0x00); // Appending the null terminator
 
     let result = unsafe {
         SetComputerNameExW(
             ComputerNamePhysicalDnsHostname,
-            PCWSTR::from_raw(buffer.as_ptr()),
+            PCWSTR::from(buffer.as_ptr()),
         )
     };
 
-    result.map_err(|e| io::Error::from_raw_os_error(e.code().0))
+    match result {
+        0 => Err(io::Error::last_os_error()),
+        _ => Ok(()),
+    }
 }

src/windows.rs renamed to src/windows/mod.rs

@@ -0,0 +1,6 @@
+--out src/windows/bindings.rs
+--flat --sys --no-comment
+--filter
+    ComputerNamePhysicalDnsHostname
+    GetComputerNameExW
+    SetComputerNameExW

tests/bindings.txt

@@ -0,0 +1,36 @@
+#![cfg(windows)]
+
+use std::fs;
+use std::process::Command;
+
+use windows_bindgen::bindgen;
+
+#[test]
+fn gen_bindings() {
+    let output = "src/windows/bindings.rs";
+    let existing = fs::read_to_string(output).unwrap();
+
+    bindgen(["--no-deps", "--etc", "tests/bindings.txt"]);
+    let out = Command::new("rustfmt")
+        .arg("--edition=2021")
+        .arg(output)
+        .output()
+        .unwrap();
+
+    dbg!(String::from_utf8(out.stdout));
+
+    // Check the output is the same as before.
+    // Depending on the git configuration the file may have been checked out with `\r\n` newlines or
+    // with `\n`. Compare line-by-line to ignore this difference.
+    let mut new = fs::read_to_string(output).unwrap();
+    if existing.contains("\r\n") && !new.contains("\r\n") {
+        new = new.replace("\n", "\r\n");
+    } else if !existing.contains("\r\n") && new.contains("\r\n") {
+        new = new.replace("\r\n", "\n");
+    }
+
+    similar_asserts::assert_eq!(existing, new);
+    if !new.lines().eq(existing.lines()) {
+        panic!("generated file `{}` is changed.", output);
+    }
+}