Upgrade to windows-sys 0.62

Author: djc

Cargo.lock

@@ -20,7 +20,7 @@ include = ["/src", "LICENSE"]
 default-target = "x86_64-pc-windows-msvc"
 
 [dependencies]
-windows = { version = "0.44.0", features = [
+windows = { version = "0.62.2", features = [
     "Win32_System_Diagnostics_Etw",
     "Win32_Foundation",
     "Win32_System_Time",

Cargo.toml

@@ -13,6 +13,7 @@ use windows::Win32::Foundation::{
     CloseHandle, GetLastError, ERROR_SUCCESS, ERROR_WMI_INSTANCE_NOT_FOUND, HANDLE,
     INVALID_HANDLE_VALUE, WIN32_ERROR,
 };
+use windows::Win32::Security::SE_SYSTEM_PROFILE_NAME;
 use windows::Win32::Security::{
     AdjustTokenPrivileges, LookupPrivilegeValueW, SE_PRIVILEGE_ENABLED, TOKEN_ADJUST_PRIVILEGES,
     TOKEN_PRIVILEGES,
@@ -30,7 +31,6 @@ use windows::Win32::System::Diagnostics::Etw::{
     WNODE_FLAG_TRACED_GUID,
 };
 use windows::Win32::System::SystemInformation::{GetVersionExA, OSVERSIONINFOA};
-use windows::Win32::System::SystemServices::SE_SYSTEM_PROFILE_NAME;
 use windows::Win32::System::Threading::{
     GetCurrentProcess, GetCurrentThread, OpenProcess, OpenProcessToken, SetThreadPriority,
     WaitForSingleObject, CREATE_SUSPENDED, PROCESS_ALL_ACCESS, THREAD_PRIORITY_TIME_CRITICAL,
@@ -88,9 +88,12 @@ impl Drop for TraceContext {
     fn drop(&mut self) {
         // SAFETY: TraceContext invariants ensure these are valid
         unsafe {
-            let ret = CloseHandle(self.target_process_handle);
-            if ret.0 == 0 {
-                panic!("TraceContext::CloseHandle error:{:?}", get_last_error(""));
+            if let Err(error) = CloseHandle(self.target_process_handle) {
+                panic!(
+                    "TraceContext::CloseHandle error: {:?} ({})",
+                    error.message(),
+                    error.code()
+                );
             }
         }
     }
@@ -112,43 +115,27 @@ pub enum Error {
     /// Error waiting for child, timed out
     WaitOnChildErrTimeout,
     /// A call to a windows API function returned an error and we didn't know how to handle it
-    Other(WIN32_ERROR, String, &'static str),
+    Other(windows_core::Error),
     /// We require Windows 7 or greater
     UnsupportedOsVersion,
     /// This should never happen
     UnknownError,
 }
+
 type Result<T> = std::result::Result<T, Error>;
+
+impl From<windows_core::Error> for Error {
+    fn from(err: windows_core::Error) -> Self {
+        Error::Other(err)
+    }
+}
+
 impl From<std::io::Error> for Error {
     fn from(err: std::io::Error) -> Self {
         Error::Write(err)
     }
 }
 
-fn get_last_error(extra: &'static str) -> Error {
-    const BUF_LEN: usize = 1024;
-    let mut buf = [0u8; BUF_LEN];
-    let code = unsafe { GetLastError() };
-    let chars_written = unsafe {
-        FormatMessageA(
-            FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
-            None,
-            code.0,
-            0,
-            PSTR(buf.as_mut_ptr()),
-            BUF_LEN as u32,
-            None,
-        )
-    };
-    assert!(chars_written != 0);
-    let code_str = unsafe {
-        std::ffi::CStr::from_ptr(buf.as_ptr().cast())
-            .to_str()
-            .unwrap_or("Invalid utf8 in error")
-    };
-    Error::Other(code, code_str.to_string(), extra)
-}
-
 /// A wrapper around `OpenProcess` that returns a handle with all access rights
 unsafe fn handle_from_process_id(process_id: u32) -> Result<HANDLE> {
     match OpenProcess(PROCESS_ALL_ACCESS, false, process_id) {
@@ -171,33 +158,24 @@ fn acquire_privileges() -> Result<()> {
     let mut privs = TOKEN_PRIVILEGES::default();
     privs.PrivilegeCount = 1;
     privs.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
-    if unsafe {
-        LookupPrivilegeValueW(None, SE_SYSTEM_PROFILE_NAME, &mut privs.Privileges[0].Luid).0 == 0
-    } {
-        return Err(get_last_error("acquire_privileges LookupPrivilegeValueA"));
-    }
+    unsafe { LookupPrivilegeValueW(None, SE_SYSTEM_PROFILE_NAME, &mut privs.Privileges[0].Luid) }?;
     let mut pt = HANDLE::default();
-    if unsafe { OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &mut pt).0 == 0 } {
-        return Err(get_last_error("OpenProcessToken"));
-    }
+    unsafe { OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &mut pt) }?;
     let adjust = unsafe { AdjustTokenPrivileges(pt, false, Some(addr_of!(privs)), 0, None, None) };
-    if adjust.0 == 0 {
-        let err = Err(get_last_error("AdjustTokenPrivileges"));
+    if let Err(err) = adjust {
         unsafe {
             CloseHandle(pt);
         }
-        return err;
-    }
-    let ret = unsafe { CloseHandle(pt) };
-    if ret.0 == 0 {
-        return Err(get_last_error("acquire_privileges CloseHandle"));
+        return Err(err);
     }
+    let ret = unsafe { CloseHandle(pt) }?;
     let status = unsafe { GetLastError() };
     if status != ERROR_SUCCESS {
         return Err(Error::NotAnAdmin);
     }
     Ok(())
 }
+
 /// SAFETY: is_suspended must only be true if `target_process` is suspended
 unsafe fn trace_from_process_id(
     target_process_id: u32,
@@ -206,10 +184,8 @@ unsafe fn trace_from_process_id(
 ) -> Result<TraceContext> {
     let mut winver_info = OSVERSIONINFOA::default();
     winver_info.dwOSVersionInfoSize = size_of::<OSVERSIONINFOA>() as u32;
-    let ret = GetVersionExA(&mut winver_info);
-    if ret.0 == 0 {
-        return Err(get_last_error("TraceSetInformation interval"));
-    }
+    GetVersionExA(&mut winver_info)?;
+
     // If we're not win7 or more, return unsupported
     // https://docs.microsoft.com/en-us/windows/win32/sysinfo/operating-system-version
     if winver_info.dwMajorVersion < 6
@@ -228,7 +204,7 @@ unsafe fn trace_from_process_id(
         // TODO: Parameter?
         interval.Interval = (1000000000 / 8000) / 100;
         let ret = TraceSetInformation(
-            None,
+            CONTROLTRACE_HANDLE::default(),
             // The value is supported on Windows 8, Windows Server 2012, and later.
             TraceSampledProfileIntervalInfo,
             addr_of!(interval).cast(),
@@ -298,7 +274,7 @@ unsafe fn trace_from_process_id(
     {
         let mut event_trace_props_copy = event_trace_props.clone();
         let control_stop_retcode = ControlTraceA(
-            None,
+            CONTROLTRACE_HANDLE::default(),
             kernel_logger_name_with_nul_pcstr,
             addr_of_mut!(event_trace_props_copy) as *mut _,
             EVENT_TRACE_CONTROL_STOP,
@@ -484,7 +460,7 @@ unsafe fn trace_from_process_id(
     log.Anonymous2.EventRecordCallback = Some(event_record_callback);
 
     let trace_processing_handle = OpenTraceA(&mut log);
-    if trace_processing_handle.0 == INVALID_HANDLE_VALUE.0 as u64 {
+    if trace_processing_handle == INVALID_HANDLE_VALUE {
         return Err(get_last_error("OpenTraceA processing"));
     }