use alloc::vec::Vec;
use crate::error::Result;
use crate::ident::{ElfClass, Endian};
use crate::reader::ReadAt;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct SegmentType(pub u32);
impl SegmentType {
pub const NULL: Self = Self(0);
pub const LOAD: Self = Self(1);
pub const DYNAMIC: Self = Self(2);
pub const INTERP: Self = Self(3);
pub const NOTE: Self = Self(4);
pub const SHLIB: Self = Self(5);
pub const PHDR: Self = Self(6);
pub const TLS: Self = Self(7);
pub const GNU_EH_FRAME: Self = Self(0x6474_e550);
pub const GNU_STACK: Self = Self(0x6474_e551);
pub const GNU_RELRO: Self = Self(0x6474_e552);
#[must_use]
pub const fn value(self) -> u32 {
self.0
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct SegmentFlags(pub u32);
impl SegmentFlags {
pub const EXECUTE: u32 = 1;
pub const WRITE: u32 = 2;
pub const READ: u32 = 4;
#[must_use]
pub const fn value(self) -> u32 {
self.0
}
#[must_use]
pub const fn is_executable(self) -> bool {
self.0 & Self::EXECUTE != 0
}
#[must_use]
pub const fn is_writable(self) -> bool {
self.0 & Self::WRITE != 0
}
#[must_use]
pub const fn is_readable(self) -> bool {
self.0 & Self::READ != 0
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct ProgramHeader {
pub r#type: SegmentType,
pub flags: SegmentFlags,
pub offset: u64,
pub vaddr: u64,
pub paddr: u64,
pub filesz: u64,
pub memsz: u64,
pub align: u64,
}
impl ProgramHeader {
#[must_use]
pub const fn size(class: ElfClass) -> u64 {
match class {
ElfClass::Elf32 => 32,
ElfClass::Elf64 => 56,
}
}
pub fn parse<R: ReadAt>(
reader: &R,
offset: u64,
endian: Endian,
class: ElfClass,
) -> Result<Self> {
match class {
ElfClass::Elf64 => Ok(Self {
r#type: SegmentType(reader.read_u32_at(offset, endian)?),
flags: SegmentFlags(reader.read_u32_at(offset + 4, endian)?),
offset: reader.read_u64_at(offset + 8, endian)?,
vaddr: reader.read_u64_at(offset + 16, endian)?,
paddr: reader.read_u64_at(offset + 24, endian)?,
filesz: reader.read_u64_at(offset + 32, endian)?,
memsz: reader.read_u64_at(offset + 40, endian)?,
align: reader.read_u64_at(offset + 48, endian)?,
}),
ElfClass::Elf32 => Ok(Self {
r#type: SegmentType(reader.read_u32_at(offset, endian)?),
offset: u64::from(reader.read_u32_at(offset + 4, endian)?),
vaddr: u64::from(reader.read_u32_at(offset + 8, endian)?),
paddr: u64::from(reader.read_u32_at(offset + 12, endian)?),
filesz: u64::from(reader.read_u32_at(offset + 16, endian)?),
memsz: u64::from(reader.read_u32_at(offset + 20, endian)?),
flags: SegmentFlags(reader.read_u32_at(offset + 24, endian)?),
align: u64::from(reader.read_u32_at(offset + 28, endian)?),
}),
}
}
pub fn write(&self, out: &mut Vec<u8>, endian: Endian, class: ElfClass) {
match class {
ElfClass::Elf64 => {
out.extend_from_slice(&endian.u32_bytes(self.r#type.0));
out.extend_from_slice(&endian.u32_bytes(self.flags.0));
out.extend_from_slice(&endian.u64_bytes(self.offset));
out.extend_from_slice(&endian.u64_bytes(self.vaddr));
out.extend_from_slice(&endian.u64_bytes(self.paddr));
out.extend_from_slice(&endian.u64_bytes(self.filesz));
out.extend_from_slice(&endian.u64_bytes(self.memsz));
out.extend_from_slice(&endian.u64_bytes(self.align));
}
ElfClass::Elf32 => {
out.extend_from_slice(&endian.u32_bytes(self.r#type.0));
out.extend_from_slice(&endian.u32_bytes(crate::low32(self.offset)));
out.extend_from_slice(&endian.u32_bytes(crate::low32(self.vaddr)));
out.extend_from_slice(&endian.u32_bytes(crate::low32(self.paddr)));
out.extend_from_slice(&endian.u32_bytes(crate::low32(self.filesz)));
out.extend_from_slice(&endian.u32_bytes(crate::low32(self.memsz)));
out.extend_from_slice(&endian.u32_bytes(self.flags.0));
out.extend_from_slice(&endian.u32_bytes(crate::low32(self.align)));
}
}
}
#[must_use]
pub const fn is_load(&self) -> bool {
self.r#type.0 == SegmentType::LOAD.0
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Segment {
pub header: ProgramHeader,
pub data: Vec<u8>,
}
impl Segment {
#[must_use]
pub const fn new(header: ProgramHeader, data: Vec<u8>) -> Self {
Self { header, data }
}
#[must_use]
pub const fn flags(&self) -> SegmentFlags {
self.header.flags
}
#[must_use]
pub const fn segment_type(&self) -> SegmentType {
self.header.r#type
}
#[must_use]
pub const fn contains_vaddr(&self, vaddr: u64) -> bool {
vaddr >= self.header.vaddr && vaddr < self.header.vaddr.saturating_add(self.header.memsz)
}
#[must_use]
pub fn data_at_vaddr(&self, vaddr: u64, len: usize) -> Option<&[u8]> {
if !self.contains_vaddr(vaddr) {
return None;
}
let start = usize::try_from(vaddr - self.header.vaddr).ok()?;
let available = self.data.get(start..)?;
Some(&available[..len.min(available.len())])
}
}