Struct FilesystemReader 

pub struct FilesystemReader<'b> {
    pub kind: Kind,
    pub block_size: u32,
    pub block_log: u16,
    pub compressor: Option<Compressor>,
    pub mod_time: u32,
    pub id_table: Vec<Id>,
    pub fragments: Option<Vec<Fragment>>,
    pub root: Nodes<SquashfsFileReader>,
    /* private fields */
}

Available on crate feature v3 only.

Representation of SquashFS filesystem after read from image

• Use Self::from_reader to read into Self from a reader

Read direct into Self

Usual workflow, reading from image into a default squashfs Self. See InnerNode for more details for .nodes.

// Read into filesystem
let file = BufReader::new(File::open("image.squashfs").unwrap());
let filesystem = FilesystemReader::from_reader(file).unwrap();

// Iterate through nodes
// (See src/bin/unsquashfs.rs for more examples on extraction)
for node in filesystem.files() {
    // extract
    match &node.inner {
        InnerNode::File(_) => (),
        InnerNode::Symlink(_) => (),
        InnerNode::Dir(_) => (),
        InnerNode::CharacterDevice(_) => (),
        InnerNode::BlockDevice(_) => (),
        InnerNode::NamedPipe => (),
        InnerNode::Socket => (),
    }
}

Read from Squashfs

Performance wise, you may want to read into a Squashfs first, if for instance you are optionally not extracting and only listing some Superblock fields.

// Read into Squashfs
let file = BufReader::new(File::open("image.squashfs").unwrap());
let squashfs = Squashfs::from_reader_with_offset(file, 0).unwrap();

// Display the Superblock info
let superblock = squashfs.superblock;
println!("{superblock:#08x?}");

// Now read into filesystem
let filesystem = squashfs.into_filesystem_reader().unwrap();

Fields

kind: Kind

block_size: u32

The size of a data block in bytes. Must be a power of two between 4096 (4k) and 1048576 (1 MiB).

block_log: u16

The log2 of the block size. If the two fields do not agree, the archive is considered corrupted.

compressor: Option<Compressor>

Compressor used for data (Always None for v3.)

mod_time: u32

Last modification time of the archive. Count seconds since 00:00, Jan 1st 1970 UTC (not counting leap seconds). This is unsigned, so it expires in the year 2106 (as opposed to 2038).

id_table: Vec<Id>

ID’s stored for gui(s) and uid(s)

fragments: Option<Vec<Fragment>>

Fragments Lookup Table

root: Nodes<SquashfsFileReader>

All files and directories in filesystem

Implementations

impl<'b> FilesystemReader<'b>

pub fn from_reader<R>(reader: R) -> Result<Self, BackhandError>

where R: BufReadSeek + 'b,

Call Squashfs::from_reader, then Squashfs::into_filesystem_reader

With default kind: crate::kind::LE_V4_0 and offset 0.

pub fn from_reader_with_offset<R>( reader: R, offset: u64, ) -> Result<Self, BackhandError>

where R: BufReadSeek + 'b,

Same as Self::from_reader, but seek’ing to offset in reader before reading

pub fn from_reader_with_offset_and_kind<R>( reader: R, offset: u64, kind: Kind, ) -> Result<Self, BackhandError>

where R: BufReadSeek + 'b,

Same as Self::from_reader_with_offset, but setting custom kind

pub fn file<'a>( &'a self, file: &'a SquashfsFileReader, ) -> FilesystemReaderFile<'a, 'b>

Return a file handler for this file

pub fn files(&self) -> impl Iterator<Item = &Node<SquashfsFileReader>>

Iterator of all files, including the root

Example

Used when extracting a file from the image, for example using FilesystemReaderFile:

// [snip: creating FilesystemReader]

for node in filesystem.files() {
    // extract
    match &node.inner {
        InnerNode::File(file) => {
            let mut reader = filesystem
                .file(&file)
                .reader();
            // Then, do something with the reader
        },
        _ => (),
    }
}

Trait Implementations

impl<'b> FilesystemReaderTrait for FilesystemReader<'b>

fn files(&self) -> Box<dyn Iterator<Item = BackhandNode> + '_>

Get an iterator over all files

fn file_data( &self, file: &BackhandSquashfsFileReader, ) -> Result<Vec<u8>, BackhandError>

Read a file’s full contents

fn file_data_to_writer( &self, file: &BackhandSquashfsFileReader, writer: &mut dyn Write, ) -> Result<u64, BackhandError>

Stream a file’s contents into writer, without holding it all in memory