Struct mem_rs::process::Process

pub struct Process { /* private fields */ }

Implementations

impl Process

pub fn new(name: &str) -> Self

Create a new process where name is the name of the executable

pub fn is_attached(&self) -> bool

pub fn scan_abs(
    &self,
    error_name: &str,
    pattern: &str,
    scan_offset: usize,
    pointer_offsets: Vec<usize>
) -> Result<Pointer, String>

pub fn scan_rel(
    &self,
    error_name: &str,
    pattern: &str,
    scan_offset: usize,
    instruction_size: usize,
    pointer_offsets: Vec<usize>
) -> Result<Pointer, String>

pub fn inject_dll(&self, dll_path: &str)

pub fn refresh(&mut self) -> Result<(), String>

Cling to a running process

pub fn get_current_process_name() -> Result<String, ()>

pub fn get_running_process_names() -> Vec<String>

Trait Implementations

impl BaseReadWrite for Process

fn read_memory_rel(&self, offset: Option<usize>, buffer: &mut [u8]) -> bool

Read memory relative to the object’s location in memory

fn write_memory_rel(&self, offset: Option<usize>, buffer: &[u8]) -> bool

Write memory relative to the object’s location in memory

fn read_memory_abs(&self, address: usize, buffer: &mut [u8]) -> bool

Read memory at absolute address

fn write_memory_abs(&self, address: usize, buffer: &[u8]) -> bool

Write memory at absolute address

fn read_with_handle(
    &self,
    handle: HANDLE,
    address: usize,
    buffer: &mut [u8]
) -> bool

Read memory into a buffer from a process handle

fn write_with_handle(&self, handle: HANDLE, address: usize, buffer: &[u8]) -> bool

Write from a buffer ino memory from a process handle

impl ReadWrite for Process

fn read_i8_rel(&self, address: Option<usize>) -> i8

================================================================================================================================================================== Reading Read an i8 from the given address

fn read_i32_rel(&self, address: Option<usize>) -> i32

Read an i32 from the given address

fn read_i64_rel(&self, address: Option<usize>) -> i64

Read an i64 from the given address

fn read_u8_rel(&self, address: Option<usize>) -> u8

Read an u8 from the given address

fn read_u32_rel(&self, address: Option<usize>) -> u32

Read an u32 from the given address

fn read_u64_rel(&self, address: Option<usize>) -> u64

Read an u64 from the given address

fn read_f32_rel(&self, address: Option<usize>) -> f32

Read an f32 from the given address

fn read_f64_rel(&self, address: Option<usize>) -> f64

Read an f64 from the given address

fn read_bool_rel(&self, address: Option<usize>) -> bool

Read a bool from the given address

fn write_i8_rel(&self, address: Option<usize>, value: i8)

================================================================================================================================================================== Writing Write an i8 to the given address

fn write_i32_rel(&self, address: Option<usize>, value: i32)

Write an i32 to the given address

fn write_i64_rel(&self, address: Option<usize>, value: i64)

Write an i64 to the given address

fn write_u8_rel(&self, address: Option<usize>, value: u8)

Write an u8 to the given address

fn write_u32_rel(&self, address: Option<usize>, value: u32)

Write an u32 to the given address

fn write_u64_rel(&self, address: Option<usize>, value: u64)

Write an u64 to the given address

fn write_f32_rel(&self, address: Option<usize>, value: f32)

Write an f32 to the given address

fn write_f64_rel(&self, address: Option<usize>, value: f64)

Write an f64 to the given address