Struct AffsReader 

pub struct AffsReader<'a, D: BlockDevice> { /* private fields */ }

Main AFFS filesystem reader.

Provides read-only access to an AFFS/OFS filesystem image.

Example

use affs_read::{AffsReader, BlockDevice};

struct MyDevice { data: Vec<u8> }

impl BlockDevice for MyDevice {
    fn read_block(&self, block: u32, buf: &mut [u8; 512]) -> Result<(), ()> {
        let offset = block as usize * 512;
        buf.copy_from_slice(&self.data[offset..offset + 512]);
        Ok(())
    }
}

let device = MyDevice { data: adf_data };
let reader = AffsReader::new(&device)?;

// Get disk info
println!("Disk: {:?}", reader.disk_name());
println!("Type: {:?}", reader.fs_type());

// List root directory
for entry in reader.read_dir(reader.root_block())? {
    let entry = entry?;
    println!("{:?}: {} bytes", entry.name(), entry.size);
}

Implementations

impl<'a, D: BlockDevice> AffsReader<'a, D>

pub fn new(device: &'a D) -> Result<Self, AffsError>

Create a new AFFS reader for a standard DD floppy (880KB).

pub fn new_hd(device: &'a D) -> Result<Self, AffsError>

Create a new AFFS reader for an HD floppy (1.76MB).

pub fn with_size(device: &'a D, total_blocks: u32) -> Result<Self, AffsError>

Create a new AFFS reader with a specific block count.

pub const fn fs_type(&self) -> FsType

Get the filesystem type (OFS or FFS).

pub const fn fs_flags(&self) -> FsFlags

Get filesystem flags.

pub const fn is_intl(&self) -> bool

Check if international mode is enabled.

pub const fn root_block(&self) -> u32

Get the root block number.

pub const fn total_blocks(&self) -> u32

Get the total number of blocks.

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

Get the disk name as bytes.

pub fn disk_name_str(&self) -> Option<&str>

Get the disk name as a string (if valid UTF-8).

pub const fn bitmap_valid(&self) -> bool

Check if the bitmap is valid.

pub fn root_hash_table(&self) -> &[u32; 72]

Get the root directory hash table.

pub const fn device(&self) -> &'a D

Get a reference to the block device.

pub fn read_root_dir(&self) -> DirIter<'_, D>

Iterate over entries in the root directory.

pub fn read_dir(&self, block: u32) -> Result<DirIter<'_, D>, AffsError>

Iterate over entries in a directory.

Arguments

• block - Block number of the directory entry

pub fn find_entry( &self, dir_block: u32, name: &[u8], ) -> Result<DirEntry, AffsError>

Find an entry by name in a directory.

Arguments

• dir_block - Block number of the directory
• name - Name to search for

pub fn find_path(&self, path: &[u8]) -> Result<DirEntry, AffsError>

Find an entry by path from the root.

Path components are separated by ‘/’.

pub fn read_file(&self, block: u32) -> Result<FileReader<'_, D>, AffsError>

Read a file’s contents.

Arguments

• block - Block number of the file header

pub fn read_entry(&self, block: u32) -> Result<EntryBlock, AffsError>

Read an entry block.

pub fn root_entry(&self) -> DirEntry

Get a DirEntry for the root directory.