Update/replace deps (darfink#22)

* Replace lazy_static with once_cell

* Replace winapi with windows crate

* update all deps

* fix `_reserved` param type

Author: Hpmason

Cargo.toml

@@ -16,17 +16,16 @@ edition = "2018"
 
 [dependencies]
 cfg-if = "1.0.0"
-generic-array = "0.14.1"
-lazy_static = "1.4"
-libc = "0.2.45"
-mmap = { package = "mmap-fixed-fixed", version = "0.1.0" }
+generic-array = "0.14.7"
+once_cell = "1.18.0"
+libc = "0.2.145"
+mmap = { package = "mmap-fixed-fixed", version = "0.1.3" }
 region = "3.0.0"
 slice-pool = "0.4.1"
 
 [dev-dependencies]
 matches = "0.1.10"
-ctor = "0.2.0"
-once_cell = "1.17.1"
+ctor = "0.2.2"
 
 [features]
 default = ["nightly"]
@@ -47,5 +46,6 @@ crate-type = ["cdylib"]
 [target."cfg(any(target_arch = \"x86\", target_arch = \"x86_64\"))".dependencies]
 udis = { package = "libudis86-sys", version = "0.2.1" }
 
-[target."cfg(windows)".dev-dependencies]
-winapi = { version = "0.3.9", features = ["minwindef", "windef", "winnt", "libloaderapi"] }
+[target."cfg(windows)".dev-dependencies.windows]
+version = "0.48"
+features = ["Win32_Foundation", "Win32_System_LibraryLoader", "Win32_System_SystemServices"]

examples/cat_detour.rs

@@ -1,9 +1,9 @@
 #![cfg(all(not(windows), feature = "nightly"))]
 
+use retour::static_detour;
 use std::ffi::CString;
 use std::os::raw::c_char;
 use std::os::raw::c_int;
-use retour::static_detour;
 
 extern "C" {
   fn open(pathname: *const c_char, flags: c_int) -> c_int;
@@ -22,8 +22,8 @@ fn definitely_open(_: *const c_char, _: c_int) -> c_int {
 
 #[ctor::ctor]
 fn main() {
-    unsafe {
-        Opentour.initialize(open, definitely_open).unwrap();
-        Opentour.enable().unwrap();
-    }
+  unsafe {
+    Opentour.initialize(open, definitely_open).unwrap();
+    Opentour.enable().unwrap();
+  }
 }

examples/kernel32_detour.rs

@@ -1,70 +1,59 @@
 #![cfg(windows)]
 #![allow(non_upper_case_globals, non_snake_case, non_camel_case_types)]
 
+use std::{ffi::CStr, os::raw::c_void};
+
 use once_cell::sync::Lazy;
 use retour::GenericDetour;
-use winapi::um::libloaderapi::{GetProcAddress, LoadLibraryA};
-use winapi::shared::minwindef::DWORD;
-use winapi::shared::minwindef::HMODULE;
-use winapi::shared::minwindef::HINSTANCE;
-use winapi::shared::minwindef::LPVOID;
-use winapi::shared::minwindef::BOOL;
-use winapi::shared::ntdef::TRUE;
-use winapi::shared::ntdef::LPCSTR;
-use winapi::um::winnt::{DLL_PROCESS_ATTACH, DLL_PROCESS_DETACH, DLL_THREAD_ATTACH, DLL_THREAD_DETACH};
-
-type fn_LoadLibraryA = extern "system" fn(LPCSTR) -> HMODULE;
+use windows::{
+  core::PCSTR,
+  Win32::{
+    Foundation::{BOOL, HANDLE, HMODULE},
+    System::{
+      LibraryLoader::{GetProcAddress, LoadLibraryA},
+      SystemServices::{
+        DLL_PROCESS_ATTACH, DLL_PROCESS_DETACH, DLL_THREAD_ATTACH, DLL_THREAD_DETACH,
+      },
+    },
+  },
+};
+type fn_LoadLibraryA = extern "system" fn(PCSTR) -> HMODULE;
 
 static hook_LoadLibraryA: Lazy<GenericDetour<fn_LoadLibraryA>> = Lazy::new(|| {
-  let library_handle = unsafe { LoadLibraryA("kernel32.dll\0".as_ptr() as _) };
-  let address = unsafe { GetProcAddress(library_handle, "LoadLibraryA\0".as_ptr() as _) };
+  let library_handle = unsafe { LoadLibraryA(PCSTR(b"kernel32.dll\0".as_ptr() as _)) }.unwrap();
+  let address = unsafe { GetProcAddress(library_handle, PCSTR(b"LoadLibraryA\0".as_ptr() as _)) };
   let ori: fn_LoadLibraryA = unsafe { std::mem::transmute(address) };
-  return unsafe { 
-    GenericDetour::new(ori, our_LoadLibraryA).unwrap()
-  };
+  return unsafe { GenericDetour::new(ori, our_LoadLibraryA).unwrap() };
 });
 
-fn strlen(s: *const i8) -> usize {
-  let mut i = 0;
-  unsafe {
-      while *s.offset(i) != 0 {
-          i += 1;
-      }
-  }
-  i as usize
-}
-
-fn lpcstr_to_rust_string(input: LPCSTR) -> String {
-  if input.is_null() {
-    return String::from("(null)");
-  }
-  let length = strlen(input);
-  let slice: &[u8] = unsafe { std::slice::from_raw_parts(input as *const u8, length) };
-  return String::from_utf8(slice.to_vec()).unwrap();
-}
-
-extern "system" fn our_LoadLibraryA(lpFileName: LPCSTR) -> HMODULE {
-  println!("our_LoadLibraryA lpFileName = {}", lpcstr_to_rust_string(lpFileName));
+extern "system" fn our_LoadLibraryA(lpFileName: PCSTR) -> HMODULE {
+  let file_name = unsafe { CStr::from_ptr(lpFileName.as_ptr() as _) };
+  println!("our_LoadLibraryA lpFileName = {:?}", file_name);
   unsafe { hook_LoadLibraryA.disable().unwrap() };
   let ret_val = hook_LoadLibraryA.call(lpFileName);
-  println!("our_LoadLibraryA lpFileName = {} ret_val = {:p}", lpcstr_to_rust_string(lpFileName), ret_val);
+  println!(
+    "our_LoadLibraryA lpFileName = {:?} ret_val = {:#X}",
+    file_name, ret_val.0
+  );
   unsafe { hook_LoadLibraryA.enable().unwrap() };
   return ret_val;
 }
 
 #[no_mangle]
-unsafe extern "system" fn DllMain(_hinst: HINSTANCE, reason: DWORD, _reserved: LPVOID) -> BOOL {
+unsafe extern "system" fn DllMain(_hinst: HANDLE, reason: u32, _reserved: *mut c_void) -> BOOL {
   match reason {
     DLL_PROCESS_ATTACH => {
       println!("attaching");
-      unsafe { hook_LoadLibraryA.enable().unwrap(); }
-    }
+      unsafe {
+        hook_LoadLibraryA.enable().unwrap();
+      }
+    },
     DLL_PROCESS_DETACH => {
       println!("detaching");
-    }
-    DLL_THREAD_ATTACH => {}
-    DLL_THREAD_DETACH => {}
-    _ => {}
+    },
+    DLL_THREAD_ATTACH => {},
+    DLL_THREAD_DETACH => {},
+    _ => {},
   };
-  return TRUE as BOOL;
+  return BOOL::from(true);
 }

examples/messageboxw_detour.rs

@@ -4,19 +4,23 @@
 //! Ensure the crate is compiled as a 'cdylib' library to allow C interop.
 use retour::static_detour;
 use std::error::Error;
+use std::ffi::c_int;
+use std::os::raw::c_void;
 use std::{ffi::CString, iter, mem};
-use winapi::ctypes::c_int;
-use winapi::shared::minwindef::{BOOL, DWORD, HINSTANCE, LPVOID, TRUE, UINT};
-use winapi::shared::windef::HWND;
-use winapi::um::libloaderapi::{GetModuleHandleW, GetProcAddress};
-use winapi::um::winnt::{DLL_PROCESS_ATTACH, LPCWSTR};
+use windows::core::{PCSTR, PCWSTR};
+use windows::w;
+use windows::Win32::Foundation::{BOOL, HANDLE, HWND};
+use windows::Win32::System::LibraryLoader::{GetModuleHandleW, GetProcAddress};
+use windows::Win32::System::SystemServices::{
+  DLL_PROCESS_ATTACH, DLL_PROCESS_DETACH, DLL_THREAD_ATTACH, DLL_THREAD_DETACH,
+};
 
 static_detour! {
-  static MessageBoxWHook: unsafe extern "system" fn(HWND, LPCWSTR, LPCWSTR, UINT) -> c_int;
+  static MessageBoxWHook: unsafe extern "system" fn(HWND, PCWSTR, PCWSTR, u32) -> c_int;
 }
 
 // A type alias for `MessageBoxW` (makes the transmute easy on the eyes)
-type FnMessageBoxW = unsafe extern "system" fn(HWND, LPCWSTR, LPCWSTR, UINT) -> c_int;
+type FnMessageBoxW = unsafe extern "system" fn(HWND, PCWSTR, PCWSTR, u32) -> c_int;
 
 /// Called when the DLL is attached to the process.
 unsafe fn main() -> Result<(), Box<dyn Error>> {
@@ -37,10 +41,10 @@ unsafe fn main() -> Result<(), Box<dyn Error>> {
 }
 
 /// Called whenever `MessageBoxW` is invoked in the process.
-fn messageboxw_detour(hwnd: HWND, text: LPCWSTR, _caption: LPCWSTR, u_type: UINT) -> c_int {
+fn messageboxw_detour(hwnd: HWND, text: PCWSTR, _caption: PCWSTR, msgbox_style: u32) -> c_int {
   // Call the original `MessageBoxW`, but replace the caption
-  let replaced_caption = "Detoured!\0".encode_utf16().collect::<Vec<u16>>();
-  unsafe { MessageBoxWHook.call(hwnd, text, replaced_caption.as_ptr() as _, u_type) }
+  let replaced_caption = w!("Detoured!");
+  unsafe { MessageBoxWHook.call(hwnd, text, replaced_caption, msgbox_style) }
 }
 
 /// Returns a module symbol's absolute address.
@@ -51,29 +55,27 @@ fn get_module_symbol_address(module: &str, symbol: &str) -> Option<usize> {
     .collect::<Vec<u16>>();
   let symbol = CString::new(symbol).unwrap();
   unsafe {
-    let handle = GetModuleHandleW(module.as_ptr());
-    match GetProcAddress(handle, symbol.as_ptr()) as usize {
-      0 => None,
-      n => Some(n),
+    let handle = GetModuleHandleW(PCWSTR(module.as_ptr() as _)).unwrap();
+    match GetProcAddress(handle, PCSTR(symbol.as_ptr() as _)) {
+      Some(func) => Some(func as usize),
+      None => None,
     }
   }
 }
 
 #[no_mangle]
-#[allow(non_snake_case)]
-pub unsafe extern "system" fn DllMain(
-  _module: HINSTANCE,
-  call_reason: DWORD,
-  _reserved: LPVOID,
-) -> BOOL {
-  if call_reason == DLL_PROCESS_ATTACH {
-    // A console may be useful for printing to 'stdout'
-    // winapi::um::consoleapi::AllocConsole();
-
-    // Preferably a thread should be created here instead, since as few
-    // operations as possible should be performed within `DllMain`.
-    main().is_ok() as BOOL
-  } else {
-    TRUE
-  }
+unsafe extern "system" fn DllMain(_hinst: HANDLE, reason: u32, _reserved: *mut c_void) -> BOOL {
+  match reason {
+    DLL_PROCESS_ATTACH => {
+      println!("attaching");
+      unsafe { main().unwrap() }
+    },
+    DLL_PROCESS_DETACH => {
+      println!("detaching");
+    },
+    DLL_THREAD_ATTACH => {},
+    DLL_THREAD_DETACH => {},
+    _ => {},
+  };
+  return BOOL::from(true);
 }

src/arch/memory.rs

@@ -1,14 +1,13 @@
+use once_cell::sync::Lazy;
+
 use crate::{alloc, arch, error::Result, pic};
-use lazy_static::lazy_static;
 use std::sync::Mutex;
 
-lazy_static! {
-  /// Shared allocator for all detours.
-  pub static ref POOL: Mutex<alloc::ThreadAllocator> = {
-    // Use a range of +/- 2 GB for seeking a memory block
-    Mutex::new(alloc::ThreadAllocator::new(arch::meta::DETOUR_RANGE))
-  };
-}
+/// Shared allocator for all detours.
+pub static POOL: Lazy<Mutex<alloc::ThreadAllocator>> = Lazy::new(|| {
+  // Use a range of +/- 2 GB for seeking a memory block
+  Mutex::new(alloc::ThreadAllocator::new(arch::meta::DETOUR_RANGE))
+});
 
 /// Allocates PIC code at the specified address.
 pub fn allocate_pic(