use core::fmt::Debug; use core::mem; use crate::elf; use crate::endian; use crate::pod::Pod; use crate::read::util; use crate::read::{self, Bytes, Error, ReadError}; use super::FileHeader; /// An iterator over the notes in an ELF section or segment. #[derive(Debug)] pub struct NoteIterator<'data, Elf> where Elf: FileHeader, { endian: Elf::Endian, align: usize, data: Bytes<'data>, } impl<'data, Elf> NoteIterator<'data, Elf> where Elf: FileHeader, { /// Returns `Err` if `align` is invalid. pub(super) fn new( endian: Elf::Endian, align: Elf::Word, data: &'data [u8], ) -> read::Result { let align = match align.into() { 0u64..=4 => 4, 8 => 8, _ => return Err(Error("Invalid ELF note alignment")), }; // TODO: check data alignment? Ok(NoteIterator { endian, align, data: Bytes(data), }) } /// Returns the next note. pub fn next(&mut self) -> read::Result>> { let mut data = self.data; if data.is_empty() { return Ok(None); } let header = data .read_at::(0) .read_error("ELF note is too short")?; // The name has no alignment requirement. let offset = mem::size_of::(); let namesz = header.n_namesz(self.endian) as usize; let name = data .read_bytes_at(offset, namesz) .read_error("Invalid ELF note namesz")? .0; // The descriptor must be aligned. let offset = util::align(offset + namesz, self.align); let descsz = header.n_descsz(self.endian) as usize; let desc = data .read_bytes_at(offset, descsz) .read_error("Invalid ELF note descsz")? .0; // The next note (if any) must be aligned. let offset = util::align(offset + descsz, self.align); if data.skip(offset).is_err() { data = Bytes(&[]); } self.data = data; Ok(Some(Note { header, name, desc })) } } /// A parsed `NoteHeader`. #[derive(Debug)] pub struct Note<'data, Elf> where Elf: FileHeader, { header: &'data Elf::NoteHeader, name: &'data [u8], desc: &'data [u8], } impl<'data, Elf: FileHeader> Note<'data, Elf> { /// Return the `n_type` field of the `NoteHeader`. /// /// The meaning of this field is determined by `name`. pub fn n_type(&self, endian: Elf::Endian) -> u32 { self.header.n_type(endian) } /// Return the `n_namesz` field of the `NoteHeader`. pub fn n_namesz(&self, endian: Elf::Endian) -> u32 { self.header.n_namesz(endian) } /// Return the `n_descsz` field of the `NoteHeader`. pub fn n_descsz(&self, endian: Elf::Endian) -> u32 { self.header.n_descsz(endian) } /// Return the bytes for the name field following the `NoteHeader`, /// excluding any null terminator. /// /// This field is usually a string including a null terminator /// (but it is not required to be). /// /// The length of this field (including any null terminator) is given by /// `n_namesz`. pub fn name(&self) -> &'data [u8] { if let Some((last, name)) = self.name.split_last() { if *last == 0 { return name; } } self.name } /// Return the bytes for the desc field following the `NoteHeader`. /// /// The length of this field is given by `n_descsz`. The meaning /// of this field is determined by `name` and `n_type`. pub fn desc(&self) -> &'data [u8] { self.desc } } /// A trait for generic access to `NoteHeader32` and `NoteHeader64`. #[allow(missing_docs)] pub trait NoteHeader: Debug + Pod { type Endian: endian::Endian; fn n_namesz(&self, endian: Self::Endian) -> u32; fn n_descsz(&self, endian: Self::Endian) -> u32; fn n_type(&self, endian: Self::Endian) -> u32; } impl NoteHeader for elf::NoteHeader32 { type Endian = Endian; #[inline] fn n_namesz(&self, endian: Self::Endian) -> u32 { self.n_namesz.get(endian) } #[inline] fn n_descsz(&self, endian: Self::Endian) -> u32 { self.n_descsz.get(endian) } #[inline] fn n_type(&self, endian: Self::Endian) -> u32 { self.n_type.get(endian) } } impl NoteHeader for elf::NoteHeader64 { type Endian = Endian; #[inline] fn n_namesz(&self, endian: Self::Endian) -> u32 { self.n_namesz.get(endian) } #[inline] fn n_descsz(&self, endian: Self::Endian) -> u32 { self.n_descsz.get(endian) } #[inline] fn n_type(&self, endian: Self::Endian) -> u32 { self.n_type.get(endian) } }