Struct metagoblin::strtab::Strtab

pub struct Strtab<'a> { /* private fields */ }

A common string table format which is indexed by byte offsets (and not member index). Constructed using parse with your choice of delimiter. Please be careful.

Implementations

impl<'a> Strtab<'a>

pub fn new(bytes: &'a [u8], delim: u8) -> Strtab<'a>

Creates a Strtab with bytes as the backing string table, using delim as the delimiter between entries.

NB: this does not preparse the string table, which can have non-optimal access patterns. See https://github.com/m4b/goblin/pull/275

pub fn len(&self) -> usize

Returns the length of this Strtab in bytes

pub fn from_slice_unparsed( bytes: &'a [u8], offset: usize, len: usize, delim: u8 ) -> Strtab<'a>

Creates a Strtab directly without bounds check and without parsing it.

This is potentially unsafe and should only be used if feature = "alloc" is disabled.

pub fn get_unsafe(&self, offset: usize) -> Option<&'a str>

Gets a str reference from the backing bytes starting at byte offset.

If the index is out of bounds, None is returned. Panics if bytes are invalid UTF-8. Use this method if the Strtab was created using from_slice_unparsed().

pub fn parse( bytes: &'a [u8], offset: usize, len: usize, delim: u8 ) -> Result<Strtab<'a>, Error>

Parses a Strtab from bytes at offset with len size as the backing string table, using delim as the delimiter.

Errors if bytes are invalid UTF-8. Requires feature = "alloc"

pub fn new_preparsed(bytes: &'a [u8], delim: u8) -> Result<Strtab<'a>, Error>

Parses a Strtab with bytes as the backing string table, using delim as the delimiter between entries.

Requires feature = "alloc"

pub fn to_vec(&self) -> Result<Vec<&'a str>, Error>

Converts the string table to a vector of parsed strings.

Note: This method is used to check the parsed contents of strtab. If you want to get the correct contents of strtab as Vec, use the following example.

Examples

use goblin::error::Error;

pub fn show_shdr_strtab(bytes: &[u8]) -> Result<(), Error> {
    let elf = goblin::elf::Elf::parse(&bytes)?;

    for section in elf.section_headers {
        println!("{}", elf.shdr_strtab.get_at(section.sh_name).unwrap_or(""));
    }

    Ok(())
}

Requires feature = "alloc"

pub fn get_at(&self, offset: usize) -> Option<&'a str>

Safely gets a str reference from the parsed table starting at byte offset.

If the index is out of bounds, None is returned. Requires feature = "alloc"

pub unsafe fn from_raw(ptr: *const u8, len: usize, delim: u8) -> Strtab<'a>

👎Deprecated since 0.4.2: Use from_slice_unparsed() instead

Construct a strtab from a ptr, and a size, using delim as the delimiter

Safety

This function creates a Strtab directly from a raw pointer and size

pub fn get(&self, offset: usize) -> Option<Result<&'a str, Error>>

👎Deprecated since 0.4.2: Bad performance, use get_at() instead

Parses a str reference from the parsed table starting at byte offset.

If the index is out of bounds, None is returned. Requires feature = "alloc"

Trait Implementations

impl<'a> Debug for Strtab<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'a> Default for Strtab<'a>

fn default() -> Strtab<'a>

Returns the “default value” for a type.

impl<'a> Index<usize> for Strtab<'a>

fn index(&self, offset: usize) -> &<Strtab<'a> as Index<usize>>::Output

Gets str reference at starting at byte offset. NB: this will panic if the underlying bytes are not valid utf8, or the offset is invalid

type Output = str

The returned type after indexing.