Struct File

#[repr(packed(1))]
pub struct File {
    pub magic: [u8; 8],
    pub len: Be32,
    pub kind: Be32,
    pub checksum: Be32,
    pub offset: Be32,
}

Fields

magic: [u8; 8]

len: Be32

kind: Be32

checksum: Be32

offset: Be32

Implementations

impl File

pub fn name(&self) -> &[u8]

Examples found in repository

examples/file.rs (line 40)

fn inner(path: &str) -> io::Result<()> {
    let data = fs::read(path)?;
    let rom = Rom::new(&data);

    if let Some(fmap) = rom.fmap() {
        let mut name = String::new();
        for &b in fmap.name.iter() {
            if b == 0 {
                break;
            }
            name.push(b as char);
        }

        eprintln!("  {}", name);

        for i in 0..fmap.nareas {
            let area = fmap.area(i);

            let mut name = String::new();
            for &b in area.name.iter() {
                if b == 0 {
                    break;
                }
                name.push(b as char);
            }

            eprintln!("    {}: {}", i, name);
        }
    }

    if let Some(header) = rom.header() {
        eprintln!("  CBFS");

        let align = u32::from(header.align) as usize;
        let mut offset = u32::from(header.offset) as usize;
        while let Some(file) = rom.file(offset) {
            let name_bytes = file.name();

            let mut name = String::new();
            for &b in name_bytes.iter() {
                if b == 0 {
                    break;
                }
                name.push(b as char);
            }

            eprintln!("    {:#X}: {}", offset, name);

            let file_offset = u32::from(file.offset) as usize;
            let file_len = u32::from(file.len) as usize;
            offset = ((offset + file_offset + file_len + align - 1) / align) * align;
        }
    } else {
        eprintln!("coreboot header not found");
    }

    Ok(())
}

pub fn data(&self) -> &[u8]

Trait Implementations

impl Clone for File

fn clone(&self) -> File

Returns a duplicate of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for File

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

Formats the value using the given formatter.

impl Plain for File

fn from_bytes(bytes: &[u8]) -> Result<&Self, Error>

where Self: Sized,

fn slice_from_bytes(bytes: &[u8]) -> Result<&[Self], Error>

where Self: Sized,

fn slice_from_bytes_len(bytes: &[u8], len: usize) -> Result<&[Self], Error>

where Self: Sized,

fn from_mut_bytes(bytes: &mut [u8]) -> Result<&mut Self, Error>

where Self: Sized,

fn slice_from_mut_bytes(bytes: &mut [u8]) -> Result<&mut [Self], Error>

where Self: Sized,

fn slice_from_mut_bytes_len( bytes: &mut [u8], len: usize, ) -> Result<&mut [Self], Error>

where Self: Sized,

fn copy_from_bytes(&mut self, bytes: &[u8]) -> Result<(), Error>

impl Copy for File