use alloc::vec::Vec;
use core::ops::{Deref, DerefMut};
use crate::elf::ElfImage;
use crate::error::Result;
use crate::reader::{ReadAt, SliceReader};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ElfFile {
image: ElfImage,
trailing: Vec<u8>,
}
impl ElfFile {
pub fn parse(data: &[u8]) -> Result<Self> {
Self::read_from(&SliceReader::new(data))
}
pub fn read_from<R: ReadAt>(reader: &R) -> Result<Self> {
let image = ElfImage::read_from(reader, 0, crate::elf::Layout::File)?;
let file_end = last_structure_end(&image);
let trailing = reader
.size()
.and_then(|size| {
let remaining = size.checked_sub(file_end)?;
let len = usize::try_from(remaining).ok()?;
reader.read_bytes_at(file_end, len).ok()
})
.unwrap_or_default();
Ok(Self { image, trailing })
}
#[must_use]
pub const fn new(image: ElfImage) -> Self {
Self {
image,
trailing: Vec::new(),
}
}
#[cfg(feature = "std")]
pub fn from_file(path: impl AsRef<std::path::Path>) -> Result<Self> {
Self::read_from(&crate::reader::FileReader::open(path)?)
}
#[must_use]
pub const fn image(&self) -> &ElfImage {
&self.image
}
pub fn image_mut(&mut self) -> &mut ElfImage {
&mut self.image
}
#[must_use]
pub fn into_image(self) -> ElfImage {
self.image
}
#[must_use]
pub fn trailing(&self) -> &[u8] {
&self.trailing
}
pub fn try_build(&self) -> Result<Vec<u8>> {
let mut bytes = self.image.try_build()?;
bytes.extend_from_slice(&self.trailing);
Ok(bytes)
}
}
impl Deref for ElfFile {
type Target = ElfImage;
fn deref(&self) -> &Self::Target {
&self.image
}
}
impl DerefMut for ElfFile {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.image
}
}
fn last_structure_end(image: &ElfImage) -> u64 {
let mut end: u64 = 0;
let class = image.ident().class;
let ehsize = crate::header::ElfHeader::size(class);
end = end.max(ehsize);
let phentsize = crate::program::ProgramHeader::size(class);
let phdr_end = image
.header()
.phoff
.checked_add(u64::from(image.header().phnum) * phentsize)
.unwrap_or(end);
end = end.max(phdr_end);
for segment in image.segments() {
if segment.header.filesz > 0 {
let seg_end = segment
.header
.offset
.checked_add(segment.header.filesz)
.unwrap_or(end);
end = end.max(seg_end);
}
}
for section in image.sections() {
if !section.header.is_nobits() && section.header.size > 0 {
let sec_end = section
.header
.offset
.checked_add(section.header.size)
.unwrap_or(end);
end = end.max(sec_end);
}
}
let shentsize = crate::section::SectionHeader::size(class);
let shdr_end = image
.header()
.shoff
.checked_add(u64::from(image.header().shnum) * shentsize)
.unwrap_or(end);
end = end.max(shdr_end);
end
}