use crate::error::{Error, Result};
use crate::pe::{self, MappedImage};
use crate::slot::ImportSlot;
use crate::sys;
use core::ffi::c_void;
#[derive(Debug, Clone)]
pub struct Module {
base: usize,
size: usize,
path: String,
}
impl Module {
pub unsafe fn from_handle(handle: *mut c_void) -> Result<Self> {
if handle.is_null() {
return Err(Error::ModuleNotFound {
reason: "null handle",
os_error: 0,
});
}
Self::from_base(handle as usize)
}
pub unsafe fn from_address(address: *const c_void) -> Result<Self> {
let base = sys::module_from_address(address)?;
Self::from_base(base)
}
pub fn from_name(name: &str) -> Result<Self> {
let base = sys::module_from_name(name)?;
Self::from_base(base)
}
pub fn enumerate() -> Result<Vec<Self>> {
Ok(sys::enumerate_modules()?
.into_iter()
.filter_map(|base| Self::from_base(base).ok())
.collect())
}
fn from_base(base: usize) -> Result<Self> {
let size = sys::image_size(base)?;
let image = unsafe { MappedImage::from_loaded(base, size) };
pe::validate(&image)?;
Ok(Self {
base,
size,
path: sys::module_path(base),
})
}
#[must_use]
pub fn name(&self) -> &str {
let bytes = self.path.as_bytes();
match bytes.iter().rposition(|&b| b == b'\\' || b == b'/') {
Some(pos) => self.path.get(pos + 1..).unwrap_or(&self.path),
None => &self.path,
}
}
#[must_use]
pub fn path(&self) -> &str {
&self.path
}
#[must_use]
pub fn base(&self) -> *const c_void {
self.base as *const c_void
}
#[must_use]
pub fn size(&self) -> usize {
self.size
}
pub(crate) fn base_addr(&self) -> usize {
self.base
}
pub fn imports(&self) -> Result<Vec<ImportSlot>> {
let image = unsafe { MappedImage::from_loaded(self.base, self.size) };
Ok(pe::parse_imports(&image)?
.into_iter()
.map(|raw| ImportSlot::from_raw(self.base, raw))
.collect())
}
}