ext4fs 0.1.0

Rust implementation of ext4 file system used in user space
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

use std::io::{Read, Seek};

use super::{entry::DirEntryEnum, errors::ExtfsError, extent::Extent};

pub struct ReadDir<R> {
    reader: R,
    extents: Vec<Extent>,
    idx: usize,
    extent_offset: u64,

    block_size: u64,
    feature_incompat_filetype: bool,
}

impl<R: Read + Seek> ReadDir<R> {
    pub fn new(
        reader: R,
        extents: Vec<Extent>,
        block_size: u64,
        feature_incompat_filetype: bool,
    ) -> Self {
        Self {
            reader,
            extents,
            idx: 0,
            extent_offset: 0,
            block_size,
            feature_incompat_filetype,
        }
    }
}

impl<R: Read + Seek> Iterator for ReadDir<R> {
    type Item = Result<DirEntryEnum, ExtfsError>;

    fn next(&mut self) -> Option<Self::Item> {
        loop {
            let extent = self.extents.get(self.idx)?;
            match extent.read_entry(
                self.block_size,
                self.feature_incompat_filetype,
                &mut self.reader,
                self.extent_offset,
            ) {
                Ok(Some((e, offset))) => {
                    if extent.len as u64 >= offset {
                        self.extent_offset = 0;
                        self.idx += 1;
                    } else {
                        self.extent_offset = offset;
                    }

                    return Some(Ok(e));
                }
                // reach the end of the extent
                Ok(None) => {
                    self.extent_offset = 0;
                    self.idx += 1;
                    continue;
                }
                Err(e) => {
                    return Some(Err(e));
                }
            }
        }
    }
}