libpfs3 0.1.1

Pure Rust PFS3 (Amiga) filesystem library — read, write, format, and check
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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

//! Directory block reading and entry iteration.
//!
//! Directories are stored as chains of dirblocks (id='DB').
//! Each dirblock contains packed variable-length direntries.

use crate::anode::AnodeReader;
use crate::cache::BlockCache;
use crate::error::{Error, Result};
use crate::io::BlockDevice;
use crate::ondisk::*;
use crate::util;

/// List all entries in a directory given its anode number.
pub fn list_entries(
    dir_anode: u32,
    anodes: &AnodeReader,
    dev: &dyn BlockDevice,
    cache: &mut BlockCache,
    reserved_blksize: u16,
) -> Result<Vec<DirEntry>> {
    let chain = anodes.get_chain(dir_anode, dev, cache)?;
    let mut entries = Vec::new();

    for an in &chain {
        for i in 0..an.clustersize {
            let blk = an.blocknr as u64 + i as u64;
            let data = cache.read_reserved(dev, blk, reserved_blksize)?;
            if data.len() < DIR_BLOCK_HEADER_SIZE + 1 {
                continue;
            }
            let id = u16::from_be_bytes(data[0..2].try_into().unwrap());
            if id != DBLKID {
                continue;
            }
            parse_dirblock_entries(data, &mut entries);
        }
    }
    Ok(entries)
}

/// Parse all direntries from a dirblock's entry area.
fn parse_dirblock_entries(data: &[u8], entries: &mut Vec<DirEntry>) {
    let mut offset = DIR_BLOCK_HEADER_SIZE;
    while offset < data.len() {
        match DirEntry::parse(data, offset) {
            Some((entry, next)) => {
                entries.push(entry);
                offset = next;
            }
            None => break,
        }
    }
}

/// Look up a single name in a directory (case-insensitive).
pub fn lookup(
    dir_anode: u32,
    name: &str,
    anodes: &AnodeReader,
    dev: &dyn BlockDevice,
    cache: &mut BlockCache,
    reserved_blksize: u16,
) -> Result<DirEntry> {
    let entries = list_entries(dir_anode, anodes, dev, cache, reserved_blksize)?;
    entries
        .into_iter()
        .find(|e| util::name_eq_ci(&e.name, name))
        .ok_or_else(|| Error::NotFound(name.to_string()))
}

/// Resolve a '/'-separated path to a DirEntry.
/// Returns None for the root directory itself.
pub fn resolve_path(
    path: &str,
    anodes: &AnodeReader,
    dev: &dyn BlockDevice,
    cache: &mut BlockCache,
    reserved_blksize: u16,
) -> Result<Option<DirEntry>> {
    let parts: Vec<&str> = path.split('/').filter(|s| !s.is_empty()).collect();
    if parts.is_empty() {
        return Ok(None); // root
    }

    let mut dir_anode = ANODE_ROOTDIR;
    for (i, part) in parts.iter().enumerate() {
        let entry = lookup(dir_anode, part, anodes, dev, cache, reserved_blksize)?;
        if i < parts.len() - 1 {
            if !entry.is_dir() {
                return Err(Error::NotADirectory);
            }
            dir_anode = entry.anode;
        } else {
            return Ok(Some(entry));
        }
    }
    Ok(None)
}

/// Resolve a path to a directory anode number.
pub fn resolve_dir_path(
    path: &str,
    anodes: &AnodeReader,
    dev: &dyn BlockDevice,
    cache: &mut BlockCache,
    reserved_blksize: u16,
) -> Result<u32> {
    let parts: Vec<&str> = path.split('/').filter(|s| !s.is_empty()).collect();
    if parts.is_empty() {
        return Ok(ANODE_ROOTDIR);
    }

    let mut dir_anode = ANODE_ROOTDIR;
    for part in &parts {
        let entry = lookup(dir_anode, part, anodes, dev, cache, reserved_blksize)?;
        if !entry.is_dir() {
            return Err(Error::NotADirectory);
        }
        dir_anode = entry.anode;
    }
    Ok(dir_anode)
}