Struct FilesystemWriter 

pub struct FilesystemWriter<'a, 'b, 'c> { /* private fields */ }

Representation of SquashFS filesystem to be written back to an image

• Use Self::from_fs_reader to write with the data from a previous SquashFS image
• Use Self::default to create an empty SquashFS image without an original image. For example:

// Add empty default FilesytemWriter
let mut fs = FilesystemWriter::default();
fs.set_current_time();
fs.set_block_size(DEFAULT_BLOCK_SIZE);
fs.set_only_root_id();
fs.set_kind(Kind::from_const(kind::LE_V4_0).unwrap());

// set root image permissions
let header = NodeHeader {
    permissions: 0o755,
    ..NodeHeader::default()
};
fs.set_root_mode(0o777);

// set extra compression options
let mut xz_extra = ExtraXz::default();
xz_extra.level(9).unwrap();
let extra = CompressionExtra::Xz(xz_extra);
let mut compressor = FilesystemCompressor::new(Compressor::Xz, None).unwrap();
compressor.extra(extra).unwrap();
fs.set_compressor(compressor);

// push some dirs and a file
fs.push_dir("usr", header);
fs.push_dir("usr/bin", header);
fs.push_file(std::io::Cursor::new(vec![0x00, 0x01]), "usr/bin/file", header);

Implementations

impl<'a, 'b, 'c> FilesystemWriter<'a, 'b, 'c>

pub fn set_block_size(&mut self, block_size: u32)

Set block size

Panics

If invalid, must be MIN_BLOCK_SIZE > block_size < MAX_BLOCK_SIZE

pub fn set_time(&mut self, mod_time: u32)

Set time of image as mod_time

Example: Set to Wed Oct 19 01:26:15 2022

let mut fs = FilesystemWriter::default();
fs.set_time(0x634f_5237);

pub fn set_current_time(&mut self)

Set time of image as current time

pub fn set_kind(&mut self, kind: Kind)

Set kind as kind

Example: Set kind to default V4.0

let mut fs = FilesystemWriter::default();
fs.set_kind(Kind::from_const(kind::LE_V4_0).unwrap());

pub fn set_root_mode(&mut self, mode: u16)

Set root mode as mode

Example

 let mut fs = FilesystemWriter::default();
 fs.set_root_mode(0o777);

pub fn set_root_uid(&mut self, uid: u32)

Set root uid as uid

pub fn set_root_gid(&mut self, gid: u32)

Set root gid as gid

pub fn set_compressor(&mut self, compressor: FilesystemCompressor)

Set compressor as compressor

 let mut compressor = FilesystemCompressor::new(Compressor::Xz, None).unwrap();

pub fn set_only_root_id(&mut self)

Set id_table to Id::root, removing old entries

pub fn set_kib_padding(&mut self, pad_kib: u32)

Set padding(zero bytes) added to the end of the image after calling write.

For example, if given pad_kib of 8; a 8K padding will be added to the end of the image.

Default: DEFAULT_PAD_LEN

pub fn set_no_padding(&mut self)

Set no padding(zero bytes) added to the end of the image after calling write.

pub fn set_no_duplicate_files(&mut self, value: bool)

Set if we perform duplicate file checking, on by default

pub fn set_emit_compression_options(&mut self, value: bool)

Set if compression options are written

pub fn from_fs_reader( reader: &'a FilesystemReader<'b>, ) -> Result<Self, BackhandError>

Inherit filesystem structure and properties from reader

pub fn push_file<P>( &mut self, reader: impl Read + 'c, path: P, header: NodeHeader, ) -> Result<(), BackhandError>

where P: AsRef<Path>,

Insert reader into filesystem with path and metadata header.

The reader is kept until Self::write is called. For a file on disk, use Self::push_file_from_path instead, which keeps only the path and thus does not use an open file descriptor for each file.

The uid and gid in header are added to FilesystemWriters id’s

pub fn push_file_from_path<S, P>( &mut self, source: S, path: P, header: NodeHeader, ) -> Result<(), BackhandError>

where S: Into<PathBuf>, P: AsRef<Path>,

Insert the file at source into filesystem with path and metadata header.

The file is opened when Self::write is called, not now. Use this instead of Self::push_file for files on disk: Self::push_file holds the reader, and thus an open file descriptor, until the write. The source file must still exist at the time of the write.

The uid and gid in header are added to FilesystemWriters id’s

pub fn mut_file<S>( &mut self, find_path: S, ) -> Option<&mut SquashfsFileWriter<'a, 'b, 'c>>

where S: AsRef<Path>,

Take a mutable reference to existing file at find_path

pub fn replace_file<S>( &mut self, find_path: S, reader: impl Read + 'c, ) -> Result<(), BackhandError>

where S: AsRef<Path>,

Replace an existing file

pub fn replace_file_from_path<S, P>( &mut self, find_path: S, source: P, ) -> Result<(), BackhandError>

where S: AsRef<Path>, P: Into<PathBuf>,

Replace an existing file with the file at source, which is opened at write time

See Self::push_file_from_path.

pub fn push_symlink<P, S>( &mut self, link: S, path: P, header: NodeHeader, ) -> Result<(), BackhandError>

where P: AsRef<Path>, S: Into<PathBuf>,

Insert symlink path -> link

The uid and gid in header are added to FilesystemWriters id’s

pub fn push_dir<P>( &mut self, path: P, header: NodeHeader, ) -> Result<(), BackhandError>

where P: AsRef<Path>,

Insert empty dir at path

The uid and gid in header are added to FilesystemWriters id’s

pub fn push_dir_all<P>( &mut self, path: P, header: NodeHeader, ) -> Result<(), BackhandError>

where P: AsRef<Path>,

Recursively create an empty directory and all of its parent components if they are missing.

The uid and gid in header are added to FilesystemWriters id’s

pub fn push_char_device<P>( &mut self, device_number: u32, path: P, header: NodeHeader, ) -> Result<(), BackhandError>

where P: AsRef<Path>,

Insert character device with device_number at path

The uid and gid in header are added to FilesystemWriters id’s

pub fn push_block_device<P>( &mut self, device_number: u32, path: P, header: NodeHeader, ) -> Result<(), BackhandError>

where P: AsRef<Path>,

Insert block device with device_number at path

The uid and gid in header are added to FilesystemWriters id’s

pub fn push_fifo<P>( &mut self, path: P, header: NodeHeader, ) -> Result<(), BackhandError>

where P: AsRef<Path>,

Insert FIFO (named pipe)

The uid and gid in header are added to FilesystemWriters id’s

pub fn push_socket<P>( &mut self, path: P, header: NodeHeader, ) -> Result<(), BackhandError>

where P: AsRef<Path>,

Insert Socket (UNIX domain socket)

The uid and gid in header are added to FilesystemWriters id’s

pub fn write_with_offset<W>( &mut self, w: W, offset: u64, ) -> Result<(SuperBlock, u64), BackhandError>

where W: Write + Seek,

Same as Self::write, but seek’ing to offset in w before reading. This offset is treated as the base image offset.

pub fn write<W: Write + Seek>( &mut self, w: W, ) -> Result<(SuperBlock, u64), BackhandError>

Generate and write the resulting squashfs image to w

Returns

(written populated SuperBlock, total amount of bytes written including padding)

Trait Implementations

impl<'a, 'b, 'c> Debug for FilesystemWriter<'a, 'b, 'c>

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

Formats the value using the given formatter.

impl Default for FilesystemWriter<'_, '_, '_>

fn default() -> Self

Create default FilesystemWriter

block_size: DEFAULT_BLOCK_SIZE, compressor: default XZ compression, no nodes, kind: LE_V4_0, and mod_time: 0.