added thread api for rust

Author: rdbo

bindings/rust/libmem/src/process.rs

@@ -70,11 +70,11 @@ impl fmt::Display for Process {
 }
 
 unsafe extern "C" fn enum_processes_callback(
-    process: *mut lm_process_t,
+    raw_process: *mut lm_process_t,
     arg: *mut lm_void_t,
 ) -> lm_bool_t {
     let processes = arg as *mut Vec<Process>;
-    unsafe { (*processes).push((*process).into()) };
+    unsafe { (*processes).push((*raw_process).into()) };
     LM_TRUE
 }
 
@@ -96,10 +96,10 @@ pub fn enum_processes() -> Option<Vec<Process>> {
 
 /// Retrieves information about the current process
 pub fn get_process() -> Option<Process> {
-    let mut process: MaybeUninit<lm_process_t> = MaybeUninit::uninit();
+    let mut raw_process: MaybeUninit<lm_process_t> = MaybeUninit::uninit();
     unsafe {
-        if libmem_sys::LM_GetProcess(process.as_mut_ptr()) == LM_TRUE {
-            Some(process.assume_init().into())
+        if libmem_sys::LM_GetProcess(raw_process.as_mut_ptr()) == LM_TRUE {
+            Some(raw_process.assume_init().into())
         } else {
             None
         }
@@ -108,10 +108,10 @@ pub fn get_process() -> Option<Process> {
 
 /// Retrieves information about a specific process identified by its process ID
 pub fn get_process_ex(pid: Pid) -> Option<Process> {
-    let mut process: MaybeUninit<lm_process_t> = MaybeUninit::uninit();
+    let mut raw_process: MaybeUninit<lm_process_t> = MaybeUninit::uninit();
     unsafe {
-        if libmem_sys::LM_GetProcessEx(pid, process.as_mut_ptr()) == LM_TRUE {
-            Some(process.assume_init().into())
+        if libmem_sys::LM_GetProcessEx(pid, raw_process.as_mut_ptr()) == LM_TRUE {
+            Some(raw_process.assume_init().into())
         } else {
             None
         }
@@ -120,11 +120,11 @@ pub fn get_process_ex(pid: Pid) -> Option<Process> {
 
 /// Searches for a process by its name
 pub fn find_process(name: &str) -> Option<Process> {
-    let mut process: MaybeUninit<lm_process_t> = MaybeUninit::uninit();
+    let mut raw_process: MaybeUninit<lm_process_t> = MaybeUninit::uninit();
     let process_name = CString::new(name).ok()?;
     unsafe {
-        if libmem_sys::LM_FindProcess(process_name.as_ptr(), process.as_mut_ptr()) == LM_TRUE {
-            Some(process.assume_init().into())
+        if libmem_sys::LM_FindProcess(process_name.as_ptr(), raw_process.as_mut_ptr()) == LM_TRUE {
+            Some(raw_process.assume_init().into())
         } else {
             None
         }

bindings/rust/libmem/src/thread.rs

@@ -1,3 +1,5 @@
+use std::mem::MaybeUninit;
+
 use libmem_sys::{lm_bool_t, lm_process_t, lm_thread_t, lm_void_t, LM_TRUE};
 
 use crate::{Pid, Process, Tid};
@@ -69,19 +71,48 @@ pub fn enum_threads_ex(process: &Process) -> Option<Vec<Thread>> {
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
+/// Gets the current thread it's running from
+pub fn get_thread() -> Option<Thread> {
+    let mut raw_thread: MaybeUninit<lm_thread_t> = MaybeUninit::uninit();
+    unsafe {
+        if libmem_sys::LM_GetThread(raw_thread.as_mut_ptr() as *mut lm_thread_t) == LM_TRUE {
+            Some(raw_thread.assume_init().into())
+        } else {
+            None
+        }
+    }
+}
 
-    #[test]
-    fn test_enum_threads() {
-        let threads = enum_threads().expect("Failed to enumerate threads in the current process");
-        assert!(threads.len() > 0);
+/// Gets a thread from a specified remote process
+pub fn get_thread_ex(process: &Process) -> Option<Thread> {
+    let mut raw_thread: MaybeUninit<lm_thread_t> = MaybeUninit::uninit();
+    let raw_process: lm_process_t = process.to_owned().into();
+    unsafe {
+        if libmem_sys::LM_GetThreadEx(
+            &raw_process as *const lm_process_t,
+            raw_thread.as_mut_ptr() as *mut lm_thread_t,
+        ) == LM_TRUE
+        {
+            Some(raw_thread.assume_init().into())
+        } else {
+            None
+        }
     }
+}
 
-    #[test]
-    fn test_enum_threads_ex() {
-        let threads = enum_threads().expect("Failed to enumerate threads in the current process");
-        assert!(threads.len() > 0);
+/// Gets the process that owns a specified thread
+pub fn get_thread_process(thread: &Thread) -> Option<Process> {
+    let mut raw_process: MaybeUninit<lm_process_t> = MaybeUninit::uninit();
+    let raw_thread: lm_thread_t = thread.to_owned().into();
+    unsafe {
+        if libmem_sys::LM_GetThreadProcess(
+            &raw_thread as *const lm_thread_t,
+            raw_process.as_mut_ptr() as *mut lm_process_t,
+        ) == LM_TRUE
+        {
+            Some(raw_process.assume_init().into())
+        } else {
+            None
+        }
     }
 }

bindings/rust/libmem/tests/common.rs

@@ -1,5 +1,5 @@
-use libmem::Process;
-use libmem_sys::LM_PID_BAD;
+use libmem::{Process, Thread};
+use libmem_sys::{LM_PID_BAD, LM_TID_BAD};
 
 pub fn check_process(process: &Process) -> bool {
     process.pid != LM_PID_BAD
@@ -9,3 +9,7 @@ pub fn check_process(process: &Process) -> bool {
         && process.path.len() > 0
         && process.name.len() > 0
 }
+
+pub fn check_thread(thread: &Thread) -> bool {
+    thread.tid != LM_TID_BAD && thread.owner_pid != LM_PID_BAD
+}

bindings/rust/libmem/tests/local.rs

@@ -1,10 +1,10 @@
 mod common;
 
-use common::check_process;
+use common::{check_process, check_thread};
 use libmem::*;
 
 #[test]
-fn test_local_process() {
+fn test_get_process() {
     let process = get_process().expect("Failed to get current process");
     eprintln!("Current process: {}", process);
     assert!(check_process(&process));
@@ -20,3 +20,15 @@ fn test_get_system_bits() {
     let bits = get_system_bits();
     assert!(bits == 32 || bits == 64);
 }
+
+#[test]
+fn test_enum_threads() {
+    let threads = enum_threads().expect("Failed to enumerate threads in the current process");
+    assert!(threads.len() > 0);
+}
+
+#[test]
+fn test_get_thread() {
+    let thread = get_thread().expect("Failed to get current thread");
+    assert!(check_thread(&thread));
+}

bindings/rust/libmem/tests/remote.rs

@@ -3,11 +3,30 @@ mod common;
 use common::check_process;
 use libmem::*;
 
+use crate::common::check_thread;
+
 #[test]
 fn test_remote_process() {
     let process = find_process("cargo").expect("Failed to find remote process");
     eprintln!("Found process: {}", process);
     assert!(check_process(&process));
 
     assert!(is_process_alive(&process));
+
+    assert_eq!(
+        process,
+        get_process_ex(process.pid).expect("Failed to get process by PID")
+    );
+
+    let threads =
+        enum_threads_ex(&process).expect("Failed to enumerate threads in the current process");
+    assert!(threads.len() > 0);
+
+    let thread = get_thread_ex(&process).expect("Failed to get remote process thread");
+    assert!(check_thread(&thread));
+
+    assert_eq!(
+        get_thread_process(&thread).expect("Failed to get thread's owner process"),
+        process
+    );
 }