added unfinished unloading of the plugin

Torwent · Torwent · commit e8ef519524c7 · 2025-05-22T21:20:38.000+02:00
diff --git a/src/client/hooks.rs b/src/client/hooks.rs
@@ -39,7 +39,7 @@ use super::graphics::{
 };
 use crate::shared::{
     memory::{MemoryManager, MEMORY_MANAGER},
-    windows::{WI_CONSOLE, WI_MODIFIERS, WI_REMAP},
+    windows::{unload_self_dll, WI_CONSOLE, WI_DETACH, WI_MODIFIERS, WI_REMAP},
 };
 
 lazy_static! {
@@ -48,6 +48,7 @@ lazy_static! {
 }
 
 pub unsafe extern "system" fn start_thread(lparam: *mut c_void) -> u32 {
+    open_client_console();
     hook_wndproc(lparam as u64);
     hook_wgl_swap_buffers();
     0
@@ -192,6 +193,11 @@ unsafe extern "system" fn hooked_wndproc(
 
             return LRESULT(0);
         }
+        WI_DETACH => {
+            println!("unloading\r\n");
+            //unload_self_dll();
+            return LRESULT(0);
+        }
         WM_KEYDOWN => {
             let mut modifiers = KEYBOARD_MODIFIERS.lock().unwrap();
             let (shift, ctrl, alt) = &mut *modifiers;
diff --git a/src/lib.rs b/src/lib.rs
@@ -3,7 +3,7 @@ use std::os::raw::c_char;
 use std::sync::Mutex;
 
 use shared::windows::{get_jagrenderview, inject, is_input_enabled, open_console, toggle_input};
-use simba::target::{SimbaTarget, TARGET};
+use simba::target::TARGET;
 
 mod client;
 mod shared;
@@ -59,7 +59,8 @@ pub extern "C" fn Inject(path: *const c_char, pid: u32) -> bool {
     };
 
     let mut target = TARGET.lock().unwrap();
-    *target = SimbaTarget { pid, hwnd };
+    target.pid = pid;
+    target.hwnd = hwnd;
 
     unsafe { inject(module_path, pid, hwnd) }
 }
diff --git a/src/shared/windows.rs b/src/shared/windows.rs
@@ -1,24 +1,29 @@
 use std::{
     cell::RefCell,
-    ffi::{c_char, c_int, c_void},
+    ffi::{c_char, c_int, c_void, OsStr},
     mem::transmute,
+    os::windows::ffi::OsStrExt,
     ptr::null_mut,
     slice::from_raw_parts,
+    sync::OnceLock,
     thread::sleep,
     time::Duration,
 };
 
 use windows::{
-    core::{s, BOOL, PCSTR},
+    core::{s, BOOL, PCSTR, PCWSTR},
     Win32::{
         Foundation::{
-            CloseHandle, FALSE, HINSTANCE, HMODULE, HWND, LPARAM, POINT, TRUE, WAIT_OBJECT_0,
-            WAIT_TIMEOUT, WPARAM,
+            CloseHandle, FreeLibrary, FALSE, HINSTANCE, HMODULE, HWND, LPARAM, POINT, TRUE,
+            WAIT_OBJECT_0, WAIT_TIMEOUT, WPARAM,
         },
         Graphics::Gdi::ScreenToClient,
         System::{
             Diagnostics::Debug::WriteProcessMemory,
-            LibraryLoader::{DisableThreadLibraryCalls, GetModuleHandleA, GetProcAddress},
+            LibraryLoader::{
+                DisableThreadLibraryCalls, GetModuleFileNameW, GetModuleHandleA, GetModuleHandleW,
+                GetProcAddress,
+            },
             Memory::{
                 VirtualAllocEx, VirtualFreeEx, MEM_COMMIT, MEM_RELEASE, MEM_RESERVE, PAGE_READWRITE,
             },
@@ -40,40 +45,36 @@ use windows::{
     },
 };
 
-use crate::client::hooks::{start_thread, unhook_wgl_swap_buffers, unhook_wndproc};
+use crate::{
+    client::hooks::{start_thread, unhook_wgl_swap_buffers, unhook_wndproc},
+    simba::target::TARGET,
+};
 
 use super::memory::{MemoryManager, MEMORY_MANAGER};
 
 pub const WI_CONSOLE: u32 = WM_USER + 1;
 pub const WI_REMAP: u32 = WM_USER + 2;
 pub const WI_MODIFIERS: u32 = WM_USER + 3;
+pub const WI_DETACH: u32 = WM_USER + 4;
 
 #[no_mangle]
 pub static mut MODULE: HMODULE = HMODULE(null_mut());
 
-#[no_mangle]
-pub extern "system" fn DllMain(
-    hinst_dll: HINSTANCE,
-    fdw_reason: u32,
-    _lpv_reserved: *mut c_void,
-) -> BOOL {
-    unsafe { MODULE = HMODULE(hinst_dll.0) };
-
-    let pid = unsafe { GetCurrentProcessId() };
-    let hwnd = match get_jagrenderview(pid) {
-        Some(hwnd) => hwnd,
-        None => return TRUE,
-    };
-
-    match fdw_reason {
+fn client_main(hinst_dll: HINSTANCE, pid: u32, hwnd: HWND, reason: u32) -> BOOL {
+    match reason {
         1 => unsafe {
             let _ = DisableThreadLibraryCalls(hinst_dll.into());
+            let mut buffer = [0u16; 260]; // MAX_PATH
+            let len = GetModuleFileNameW(Some(HMODULE::from(hinst_dll)), &mut buffer);
 
-            let mem_manager = MEMORY_MANAGER.lock().unwrap();
+            if len > 0 {
+                let path = String::from_utf16_lossy(&buffer[..len as usize]);
+                let _ = DLL_NAME.set(path);
+            }
 
+            let mem_manager = MEMORY_MANAGER.lock().unwrap();
             if mem_manager.is_mapped() {
                 println!("[WaspInput]: Console attached. PID: {:?}\r\n", pid);
-
                 let _ = CreateThread(
                     Some(null_mut()),
                     0,
@@ -82,7 +83,9 @@ pub extern "system" fn DllMain(
                     THREAD_CREATION_FLAGS(0),
                     Some(null_mut()),
                 );
+                return TRUE;
             }
+            FALSE
         },
         0 => {
             println!("[WaspInput]: Detached.\r\n");
@@ -94,11 +97,67 @@ pub extern "system" fn DllMain(
                     mem_manager.close_map();
                 }
             };
+            TRUE
+        }
+        _ => FALSE,
+    }
+}
+
+pub static DLL_NAME: OnceLock<String> = OnceLock::new();
+
+fn simba_main(hinst_dll: HINSTANCE, reason: u32) -> BOOL {
+    match reason {
+        1 => {
+            let _ = unsafe { DisableThreadLibraryCalls(hinst_dll.into()) };
+            TRUE
+        }
+        0 => {
+            let target = TARGET.lock().unwrap();
+            let hwnd = HWND(target.hwnd as *mut c_void);
+            let _ = unsafe { PostMessageW(Some(hwnd), WI_DETACH, WPARAM(0), LPARAM(0)) };
+            TRUE
         }
-        _ => (),
+        _ => FALSE,
     }
+}
 
-    TRUE
+#[no_mangle]
+pub extern "system" fn DllMain(
+    hinst_dll: HINSTANCE,
+    fdw_reason: u32,
+    _lpv_reserved: *mut c_void,
+) -> BOOL {
+    unsafe { MODULE = HMODULE(hinst_dll.0) };
+
+    let pid = unsafe { GetCurrentProcessId() };
+    match get_jagrenderview(pid) {
+        Some(hwnd) => client_main(hinst_dll, pid, hwnd, fdw_reason),
+        None => simba_main(hinst_dll, fdw_reason),
+    }
+}
+
+fn get_hmodule_from_path(path: &str) -> Option<HMODULE> {
+    let wide: Vec<u16> = OsStr::new(path)
+        .encode_wide()
+        .chain(std::iter::once(0)) // null-terminate
+        .collect();
+
+    unsafe { GetModuleHandleW(PCWSTR::from_raw(wide.as_ptr())).ok() }
+}
+
+pub fn unload_self_dll() -> bool {
+    if let Some(path) = DLL_NAME.get() {
+        if let Some(hmodule) = get_hmodule_from_path(path) {
+            let _ = unsafe { FreeLibrary(hmodule) };
+            true
+        } else {
+            eprintln!("Could not get HMODULE for path: {path}");
+            false
+        }
+    } else {
+        eprintln!("DLL path not initialized.");
+        false
+    }
 }
 
 pub unsafe fn get_proc_address(name: *const c_char) -> *mut c_void {
diff --git a/src/simba/target.rs b/src/simba/target.rs
@@ -23,13 +23,17 @@ use super::plugin::PLUGIN_SIMBA_METHODS;
 pub struct SimbaTarget {
     pub pid: u32,
     pub hwnd: u64,
+    pub keyboard: [bool; 255],
+    pub mouse: [bool; 3],
 }
 
 lazy_static! {
-    pub static ref TARGET: Mutex<SimbaTarget> = Mutex::new(SimbaTarget { pid: 0, hwnd: 0 });
-    pub static ref MOUSE_POSITION: Mutex<POINT> = Mutex::new(POINT { x: -1, y: -1 });
-    static ref KEYBOARD_STATE: Mutex<[bool; 255]> = Mutex::new([false; 255]);
-    static ref MOUSE_STATE: Mutex<[bool; 3]> = Mutex::new([false; 3]);
+    pub static ref TARGET: Mutex<SimbaTarget> = Mutex::new(SimbaTarget {
+        pid: 0,
+        hwnd: 0,
+        keyboard: [false; 255],
+        mouse: [false; 3],
+    });
 }
 
 pub fn get_mouse_pos(hwnd: u64) -> POINT {
@@ -69,7 +73,8 @@ pub extern "C" fn SimbaPluginTarget_Request(args: *const c_char) -> *mut SimbaTa
         return &mut *target as *mut SimbaTarget;
     }
 
-    *target = SimbaTarget { pid, hwnd };
+    target.pid = pid;
+    target.hwnd = hwnd;
 
     return &mut *target as *mut SimbaTarget;
 }
@@ -121,7 +126,12 @@ pub extern "C" fn SimbaPluginTarget_Release(target: *mut SimbaTarget) {
     );
 
     let mut target = TARGET.lock().unwrap();
-    *target = SimbaTarget { pid: 0, hwnd: 0 };
+    *target = SimbaTarget {
+        pid: 0,
+        hwnd: 0,
+        keyboard: [false; 255],
+        mouse: [false; 3],
+    };
 }
 
 #[no_mangle]
@@ -190,11 +200,11 @@ pub extern "C" fn SimbaPluginTarget_MousePressed(
         return false;
     }
 
-    let state = MOUSE_STATE.lock().unwrap();
+    let target = TARGET.lock().unwrap();
     match mouse_button {
-        1 => state[0],
-        2 | 4 | 5 => state[1],
-        3 => state[2],
+        1 => target.keyboard[0],
+        2 | 4 | 5 => target.keyboard[1],
+        3 => target.keyboard[2],
         _ => {
             println!("[WaspInput]: Unknown mouse button: {}\r\n", mouse_button);
             false
@@ -231,8 +241,6 @@ pub extern "C" fn SimbaPluginTarget_MouseTeleport(target: *mut SimbaTarget, x: c
 
     let target = TARGET.lock().unwrap();
     mouse_move(target.hwnd, x, y);
-    let mut lock = MOUSE_POSITION.lock().unwrap();
-    *lock = POINT { x: x, y: y };
 }
 
 #[no_mangle]
@@ -242,22 +250,21 @@ pub extern "C" fn SimbaPluginTarget_MouseUp(target: *mut SimbaTarget, mouse_butt
         return;
     }
 
-    let target = TARGET.lock().unwrap();
+    let mut target = TARGET.lock().unwrap();
 
     let pt = get_mouse_pos(target.hwnd);
-    let mut state = MOUSE_STATE.lock().unwrap();
     match mouse_button {
         1 => {
             lbutton(target.hwnd, false, pt.x, pt.y);
-            state[0] = false;
+            target.mouse[0] = false;
         }
         2 | 4 | 5 => {
             mbutton(target.hwnd, false, pt.x, pt.y);
-            state[1] = false;
+            target.mouse[1] = false;
         }
         3 => {
             rbutton(target.hwnd, false, pt.x, pt.y);
-            state[2] = false;
+            target.mouse[2] = false;
         }
         _ => {
             println!("[WaspInput]: Unknown mouse button: {}\r\n", mouse_button);
@@ -273,22 +280,21 @@ pub extern "C" fn SimbaPluginTarget_MouseDown(target: *mut SimbaTarget, mouse_bu
         return;
     }
 
-    let target = TARGET.lock().unwrap();
-
+    let mut target = TARGET.lock().unwrap();
     let pt = get_mouse_pos(target.hwnd);
-    let mut state = MOUSE_STATE.lock().unwrap();
+
     match mouse_button {
         1 => {
             lbutton(target.hwnd, true, pt.x, pt.y);
-            state[0] = true;
+            target.mouse[0] = true;
         }
         2 | 4 | 5 => {
             mbutton(target.hwnd, true, pt.x, pt.y);
-            state[1] = true;
+            target.mouse[1] = true;
         }
         3 => {
             rbutton(target.hwnd, true, pt.x, pt.y);
-            state[2] = true;
+            target.mouse[2] = true;
         }
         _ => {
             println!("[WaspInput]: Unknown mouse button: {}\r\n", mouse_button);
@@ -317,11 +323,9 @@ pub extern "C" fn SimbaPluginTarget_KeyDown(target: *mut SimbaTarget, key: c_int
         return;
     }
 
-    let target = TARGET.lock().unwrap();
+    let mut target = TARGET.lock().unwrap();
     key_down(target.hwnd, key);
-
-    let mut state = KEYBOARD_STATE.lock().unwrap();
-    state[key as usize] = true;
+    target.keyboard[key as usize] = true;
 }
 
 #[no_mangle]
@@ -331,10 +335,9 @@ pub extern "C" fn SimbaPluginTarget_KeyUp(target: *mut SimbaTarget, key: c_int)
         return;
     }
 
-    let target = TARGET.lock().unwrap();
+    let mut target = TARGET.lock().unwrap();
     key_up(target.hwnd, key);
-    let mut state = KEYBOARD_STATE.lock().unwrap();
-    state[key as usize] = false;
+    target.keyboard[key as usize] = false;
 }
 
 #[no_mangle]
@@ -365,6 +368,6 @@ pub extern "C" fn SimbaPluginTarget_KeySend(
 
 #[no_mangle]
 pub extern "C" fn SimbaPluginTarget_KeyPressed(_target: *mut SimbaTarget, key: c_int) -> bool {
-    let state = KEYBOARD_STATE.lock().unwrap();
-    state[key as usize]
+    let target = TARGET.lock().unwrap();
+    target.keyboard[key as usize]
 }
