use crate::dlpi::{self, Object};
use crate::elf::{self, ElfView, Segment};
use crate::error::{Error, Result};
use crate::slot::ImportSlot;
use core::ffi::{c_char, c_void};
#[repr(C)]
struct LinkMapHead {
l_addr: usize,
}
#[derive(Debug, Clone)]
pub struct Module {
base: usize,
loads: Vec<Segment>,
machine: u16,
dynamic_addr: u64,
span: (usize, usize),
path: String,
}
fn read_live(base: usize, loads: &[Segment], cursor: u64, buf: &mut [u8]) -> Result<()> {
let len = buf.len() as u64;
let vaddr = cursor
.checked_sub(base as u64)
.ok_or(Error::Malformed("address below load base"))?;
if !vaddr_in_load(loads, vaddr, len) {
return Err(Error::Malformed("read outside loadable segments"));
}
let addr = usize::try_from(cursor).map_err(|_| Error::Malformed("address overflow"))?;
unsafe {
core::ptr::copy_nonoverlapping(addr as *const u8, buf.as_mut_ptr(), buf.len());
}
Ok(())
}
fn vaddr_in_load(loads: &[Segment], vaddr: u64, len: u64) -> bool {
loads.iter().any(|seg| {
let end = seg.vaddr.saturating_add(seg.memsz);
vaddr >= seg.vaddr && vaddr.checked_add(len).is_some_and(|hi| hi <= end)
})
}
impl ElfView for Module {
fn machine(&self) -> u16 {
self.machine
}
fn dynamic_cursor(&self) -> u64 {
self.dynamic_addr
}
fn dynptr_cursor(&self, d_ptr: u64) -> Result<u64> {
let vaddr = d_ptr
.checked_sub(self.base as u64)
.ok_or(Error::Malformed("dynamic pointer below load base"))?;
if !vaddr_in_load(&self.loads, vaddr, 1) {
return Err(Error::Malformed(
"dynamic pointer outside loadable segments",
));
}
Ok(d_ptr)
}
fn vaddr_cursor(&self, vaddr: u64) -> Result<u64> {
if !vaddr_in_load(&self.loads, vaddr, 1) {
return Err(Error::Malformed(
"version-table vaddr outside loadable segments",
));
}
(self.base as u64)
.checked_add(vaddr)
.ok_or(Error::Malformed("version-table address overflow"))
}
fn read(&self, cursor: u64, buf: &mut [u8]) -> Result<()> {
read_live(self.base, &self.loads, cursor, buf)
}
fn slot_address(&self, r_offset: u64) -> Result<u64> {
let addr = (self.base as u64)
.checked_add(r_offset)
.ok_or(Error::Malformed("slot address overflow"))?;
if !vaddr_in_load(&self.loads, r_offset, crate::arch::PTR_SIZE as u64) {
return Err(Error::Malformed(
"relocation offset outside loadable segments",
));
}
if !addr.is_multiple_of(core::mem::align_of::<usize>() as u64) {
return Err(Error::Malformed("relocation slot is not pointer-aligned"));
}
Ok(addr)
}
}
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,
});
}
let mut lmap: *mut LinkMapHead = core::ptr::null_mut();
let rc = unsafe {
libc::dlinfo(
handle,
libc::RTLD_DI_LINKMAP,
(&raw mut lmap).cast::<c_void>(),
)
};
if rc != 0 || lmap.is_null() {
return Err(Error::ModuleNotFound {
reason: "dlinfo handle",
os_error: 0,
});
}
let base = unsafe { (*lmap).l_addr };
Self::from_base(base)
}
pub unsafe fn from_address(address: *const c_void) -> Result<Self> {
let target = address as usize;
let found = dlpi::for_each(|obj| obj.contains_address(target).then(|| obj.clone()));
match found {
Some(obj) => Self::from_raw(&obj),
None => Err(Error::ModuleNotFound {
reason: "address",
os_error: 0,
}),
}
}
pub fn from_name(name: &str) -> Result<Self> {
let mut c_name: Vec<u8> = name.as_bytes().to_vec();
c_name.push(0);
let handle = unsafe {
libc::dlopen(
c_name.as_ptr().cast::<c_char>(),
libc::RTLD_LAZY | libc::RTLD_NOLOAD,
)
};
if handle.is_null() {
return Err(Error::ModuleNotFound {
reason: "name",
os_error: 0,
});
}
let module = unsafe { Self::from_handle(handle) };
unsafe { libc::dlclose(handle) };
module
}
pub fn enumerate() -> Result<Vec<Self>> {
let mut out = Vec::new();
dlpi::for_each(|obj| -> Option<()> {
if let Ok(module) = Self::from_raw(obj) {
out.push(module);
}
None
});
Ok(out)
}
fn from_base(base: usize) -> Result<Self> {
let obj = dlpi::find_base(base).ok_or(Error::ModuleNotFound {
reason: "base",
os_error: 0,
})?;
Self::from_raw(&obj)
}
fn from_raw(obj: &Object) -> Result<Self> {
let ph = elf::parse_program_headers(&obj.phdrs, obj.phnum)?;
let dyn_vaddr = ph
.dynamic_vaddr
.ok_or(Error::Malformed("object has no PT_DYNAMIC"))?;
let bias = obj.base as u64;
let ehdr_addr = bias
.checked_add(ph.ehdr_vaddr)
.ok_or(Error::Malformed("ELF header address overflow"))?;
let mut ehdr = [0u8; 64];
read_live(obj.base, &ph.loads, ehdr_addr, &mut ehdr)?;
let machine = elf::validate_ehdr(&ehdr)?;
let dynamic_addr = bias
.checked_add(dyn_vaddr)
.ok_or(Error::Malformed("dynamic table address overflow"))?;
let (lo, hi) = span_of(obj.base, &ph.loads);
Ok(Self {
base: obj.base,
loads: ph.loads,
machine,
dynamic_addr,
span: (lo, hi),
path: obj.name.clone(),
})
}
#[must_use]
pub fn name(&self) -> &str {
match self.path.rfind('/') {
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.span.1.saturating_sub(self.span.0)
}
pub(crate) fn base_addr(&self) -> usize {
self.base
}
pub fn imports(&self) -> Result<Vec<ImportSlot>> {
Ok(elf::parse_imports(self)?
.into_iter()
.map(|raw| ImportSlot::from_raw(self.base, raw))
.collect())
}
}
fn span_of(base: usize, loads: &[Segment]) -> (usize, usize) {
let mut lo = usize::MAX;
let mut hi = 0usize;
for seg in loads {
let vaddr = usize::try_from(seg.vaddr).unwrap_or(usize::MAX);
let memsz = usize::try_from(seg.memsz).unwrap_or(0);
let start = base.wrapping_add(vaddr);
let end = start.wrapping_add(memsz);
lo = lo.min(start);
hi = hi.max(end);
}
if lo == usize::MAX {
(base, base)
} else {
(lo, hi)
}
}