exfat 0.1.0

Pure Rust implementation of exFAT file system
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

use crate::cluster::ClustersReader;
use crate::entries::{ClusterAllocation, EntriesReader, EntryType, FileEntry, StreamEntry};
use crate::file::File;
use crate::image::Image;
use std::io::{Read, Seek};
use std::ops::DerefMut;
use std::sync::Arc;
use thiserror::Error;

/// Represents a directory in the exFAT.
pub struct Directory<I: Read + Seek> {
    image: Arc<Image<I>>,
    name: String,
    stream: StreamEntry,
}

impl<I: Read + Seek> Directory<I> {
    pub(crate) fn new(image: Arc<Image<I>>, name: String, stream: StreamEntry) -> Self {
        Self {
            image,
            name,
            stream,
        }
    }

    pub fn name(&self) -> &str {
        self.name.as_ref()
    }

    pub fn open(&self) -> Result<Vec<Item<I>>, OpenError> {
        // Create an entries reader.
        let params = self.image.params();
        let fat = self.image.fat();
        let mut image = self.image.reader();
        let alloc = self.stream.allocation();
        let mut reader = match ClustersReader::new(
            params,
            fat,
            image.deref_mut(),
            alloc.first_cluster(),
            Some(alloc.data_length()),
            Some(self.stream.no_fat_chain()),
        ) {
            Ok(v) => EntriesReader::new(v),
            Err(e) => return Err(OpenError::CreateClustersReaderFailed(alloc.clone(), e)),
        };

        // Read file entries.
        let mut items: Vec<Item<I>> = Vec::new();

        loop {
            // Read primary entry.
            let entry = match reader.read() {
                Ok(v) => v,
                Err(e) => return Err(OpenError::ReadEntryFailed(e)),
            };

            // Check entry type.
            let ty = entry.ty();

            if !ty.is_regular() {
                break;
            } else if ty.type_category() != EntryType::PRIMARY {
                return Err(OpenError::NotPrimaryEntry(entry.index(), entry.cluster()));
            } else if ty.type_importance() != EntryType::CRITICAL || ty.type_code() != 5 {
                return Err(OpenError::NotFileEntry(entry.index(), entry.cluster()));
            }

            // Parse file entry.
            let file = match FileEntry::load(entry, &mut reader) {
                Ok(v) => v,
                Err(e) => return Err(OpenError::LoadFileEntryFailed(e)),
            };

            // Construct item.
            let name = file.name;
            let attrs = file.attributes;
            let stream = file.stream;

            let item = if attrs.is_directory() {
                Item::Directory(Directory::new(self.image.clone(), name, stream))
            } else {
                Item::File(File::new(self.image.clone(), name, stream))
            };

            items.push(item);
        }

        Ok(items)
    }
}

/// Represents an item in the directory.
pub enum Item<I: Read + Seek> {
    Directory(Directory<I>),
    File(File<I>),
}

/// Represents an error for [`open()`][Directory::open].
#[derive(Debug, Error)]
pub enum OpenError {
    #[error("cannot create a clusters reader for allocation {0}")]
    CreateClustersReaderFailed(ClusterAllocation, #[source] crate::cluster::NewError),

    #[error("cannot read an entry")]
    ReadEntryFailed(#[source] crate::entries::ReaderError),

    #[error("entry #{0} on cluster #{1} is not a primary entry")]
    NotPrimaryEntry(usize, usize),

    #[error("entry #{0} on cluster #{1} is not a file entry")]
    NotFileEntry(usize, usize),

    #[error("cannot load file entry")]
    LoadFileEntryFailed(#[source] crate::entries::FileEntryError),
}