fstool 0.4.12

Build disk images and filesystems (ext2/3/4, MBR, GPT) from a directory tree and TOML spec, in the spirit of genext2fs.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

//! Unix `ar` archives (`!<arch>\n`) as an fstool filesystem.
//!
//! `ar` is the flat archive behind static libraries (`.a`) and Debian
//! packages (`.deb`). It has **no directories, symlinks, or device
//! nodes** — just a sequence of named members, each a regular file.
//!
//! - **Read:** the common GNU/SysV layout (`name/` short names, a `//`
//!   string table for long names referenced as `/<offset>`, a `/`
//!   symbol table that is skipped) plus the BSD layout (`#1/<len>` with
//!   the name stored inline ahead of the data, `__.SYMDEF` skipped).
//! - **Write:** GNU format. Members are stored uncompressed; long names
//!   go through the `//` table. Because `ar` is flat, writing a nested
//!   tree is refused with a message pointing at tar/zip/cpio.

mod scan;
mod write;

use crate::Result;
use crate::block::BlockDevice;
use crate::fs::archive::ArchiveFs;

/// 8-byte global header.
pub const MAGIC: &[u8; 8] = b"!<arch>\n";

/// Format options for `ar` (none today).
#[derive(Debug, Clone, Default)]
pub struct ArFormatOpts;

impl ArFormatOpts {
    pub fn apply_options(&mut self, _bag: &mut crate::format_opts::OptionMap) -> Result<()> {
        Ok(())
    }
}

/// `ar` filesystem handle.
pub struct ArFs(pub ArchiveFs);

impl ArFs {
    pub fn open(dev: &mut dyn BlockDevice) -> Result<Self> {
        Ok(Self(ArchiveFs::from_index(scan::scan(dev)?)))
    }

    pub fn format(dev: &mut dyn BlockDevice, _opts: &ArFormatOpts) -> Result<Self> {
        Ok(Self(ArchiveFs::writer(
            "ar",
            Box::new(write::ArWriter::new(dev)),
        )))
    }
}

impl crate::fs::FilesystemFactory for ArFs {
    type FormatOpts = ArFormatOpts;
    fn format(dev: &mut dyn BlockDevice, opts: &Self::FormatOpts) -> Result<Self> {
        Self::format(dev, opts)
    }
    fn open(dev: &mut dyn BlockDevice) -> Result<Self> {
        Self::open(dev)
    }
}

crate::impl_archive_fs_filesystem!(ArFs);