embedded_sdmmc/fat/
ondiskdirentry.rs

1//! Directory Entry as stored on-disk
2
3use crate::{fat::FatType, Attributes, BlockIdx, ClusterId, DirEntry, ShortFileName, Timestamp};
4use byteorder::{ByteOrder, LittleEndian};
5
6/// A 32-byte directory entry as stored on-disk in a directory file.
7///
8/// This is the same for FAT16 and FAT32 (except FAT16 doesn't use
9/// first_cluster_hi).
10pub struct OnDiskDirEntry<'a> {
11    data: &'a [u8],
12}
13
14impl<'a> core::fmt::Debug for OnDiskDirEntry<'a> {
15    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
16        write!(f, "OnDiskDirEntry<")?;
17        write!(f, "raw_attr = {}", self.raw_attr())?;
18        write!(f, ", create_time = {}", self.create_time())?;
19        write!(f, ", create_date = {}", self.create_date())?;
20        write!(f, ", last_access_data = {}", self.last_access_data())?;
21        write!(f, ", first_cluster_hi = {}", self.first_cluster_hi())?;
22        write!(f, ", write_time = {}", self.write_time())?;
23        write!(f, ", write_date = {}", self.write_date())?;
24        write!(f, ", first_cluster_lo = {}", self.first_cluster_lo())?;
25        write!(f, ", file_size = {}", self.file_size())?;
26        write!(f, ", is_end = {}", self.is_end())?;
27        write!(f, ", is_valid = {}", self.is_valid())?;
28        write!(f, ", is_lfn = {}", self.is_lfn())?;
29        write!(
30            f,
31            ", first_cluster_fat32 = {:?}",
32            self.first_cluster_fat32()
33        )?;
34        write!(
35            f,
36            ", first_cluster_fat16 = {:?}",
37            self.first_cluster_fat16()
38        )?;
39        write!(f, ">")?;
40        Ok(())
41    }
42}
43
44impl<'a> OnDiskDirEntry<'a> {
45    pub(crate) const LEN: usize = 32;
46    pub(crate) const LEN_U32: u32 = 32;
47
48    define_field!(raw_attr, u8, 11);
49    define_field!(create_time, u16, 14);
50    define_field!(create_date, u16, 16);
51    define_field!(last_access_data, u16, 18);
52    define_field!(first_cluster_hi, u16, 20);
53    define_field!(write_time, u16, 22);
54    define_field!(write_date, u16, 24);
55    define_field!(first_cluster_lo, u16, 26);
56    define_field!(file_size, u32, 28);
57
58    /// Create a new on-disk directory entry from a block of 32 bytes read
59    /// from a directory file.
60    pub fn new(data: &[u8]) -> OnDiskDirEntry {
61        OnDiskDirEntry { data }
62    }
63
64    /// Is this the last entry in the directory?
65    pub fn is_end(&self) -> bool {
66        self.data[0] == 0x00
67    }
68
69    /// Is this a valid entry?
70    pub fn is_valid(&self) -> bool {
71        !self.is_end() && (self.data[0] != 0xE5)
72    }
73
74    /// Is this a Long Filename entry?
75    pub fn is_lfn(&self) -> bool {
76        let attributes = Attributes::create_from_fat(self.raw_attr());
77        attributes.is_lfn()
78    }
79
80    /// If this is an LFN, get the contents so we can re-assemble the filename.
81    pub fn lfn_contents(&self) -> Option<(bool, u8, [char; 13])> {
82        if self.is_lfn() {
83            let mut buffer = [' '; 13];
84            let is_start = (self.data[0] & 0x40) != 0;
85            let sequence = self.data[0] & 0x1F;
86            // LFNs store UCS-2, so we can map from 16-bit char to 32-bit char without problem.
87            buffer[0] =
88                core::char::from_u32(u32::from(LittleEndian::read_u16(&self.data[1..=2]))).unwrap();
89            buffer[1] =
90                core::char::from_u32(u32::from(LittleEndian::read_u16(&self.data[3..=4]))).unwrap();
91            buffer[2] =
92                core::char::from_u32(u32::from(LittleEndian::read_u16(&self.data[5..=6]))).unwrap();
93            buffer[3] =
94                core::char::from_u32(u32::from(LittleEndian::read_u16(&self.data[7..=8]))).unwrap();
95            buffer[4] = core::char::from_u32(u32::from(LittleEndian::read_u16(&self.data[9..=10])))
96                .unwrap();
97            buffer[5] =
98                core::char::from_u32(u32::from(LittleEndian::read_u16(&self.data[14..=15])))
99                    .unwrap();
100            buffer[6] =
101                core::char::from_u32(u32::from(LittleEndian::read_u16(&self.data[16..=17])))
102                    .unwrap();
103            buffer[7] =
104                core::char::from_u32(u32::from(LittleEndian::read_u16(&self.data[18..=19])))
105                    .unwrap();
106            buffer[8] =
107                core::char::from_u32(u32::from(LittleEndian::read_u16(&self.data[20..=21])))
108                    .unwrap();
109            buffer[9] =
110                core::char::from_u32(u32::from(LittleEndian::read_u16(&self.data[22..=23])))
111                    .unwrap();
112            buffer[10] =
113                core::char::from_u32(u32::from(LittleEndian::read_u16(&self.data[24..=25])))
114                    .unwrap();
115            buffer[11] =
116                core::char::from_u32(u32::from(LittleEndian::read_u16(&self.data[28..=29])))
117                    .unwrap();
118            buffer[12] =
119                core::char::from_u32(u32::from(LittleEndian::read_u16(&self.data[30..=31])))
120                    .unwrap();
121            Some((is_start, sequence, buffer))
122        } else {
123            None
124        }
125    }
126
127    /// Does this on-disk entry match the given filename?
128    pub fn matches(&self, sfn: &ShortFileName) -> bool {
129        self.data[0..11] == sfn.contents
130    }
131
132    /// Which cluster, if any, does this file start at? Assumes this is from a FAT32 volume.
133    pub fn first_cluster_fat32(&self) -> ClusterId {
134        let cluster_no =
135            (u32::from(self.first_cluster_hi()) << 16) | u32::from(self.first_cluster_lo());
136        ClusterId(cluster_no)
137    }
138
139    /// Which cluster, if any, does this file start at? Assumes this is from a FAT16 volume.
140    fn first_cluster_fat16(&self) -> ClusterId {
141        let cluster_no = u32::from(self.first_cluster_lo());
142        ClusterId(cluster_no)
143    }
144
145    /// Convert the on-disk format into a DirEntry
146    pub fn get_entry(
147        &self,
148        fat_type: FatType,
149        entry_block: BlockIdx,
150        entry_offset: u32,
151    ) -> DirEntry {
152        let attributes = Attributes::create_from_fat(self.raw_attr());
153        let mut result = DirEntry {
154            name: ShortFileName {
155                contents: [0u8; 11],
156            },
157            mtime: Timestamp::from_fat(self.write_date(), self.write_time()),
158            ctime: Timestamp::from_fat(self.create_date(), self.create_time()),
159            attributes,
160            cluster: {
161                let cluster = if fat_type == FatType::Fat32 {
162                    self.first_cluster_fat32()
163                } else {
164                    self.first_cluster_fat16()
165                };
166                if cluster == ClusterId::EMPTY && attributes.is_directory() {
167                    // FAT16/FAT32 uses a cluster ID of `0` in the ".." entry to mean 'root directory'
168                    ClusterId::ROOT_DIR
169                } else {
170                    cluster
171                }
172            },
173            size: self.file_size(),
174            entry_block,
175            entry_offset,
176        };
177        result.name.contents.copy_from_slice(&self.data[0..11]);
178        result
179    }
180}
181
182// ****************************************************************************
183//
184// End Of File
185//
186// ****************************************************************************
embedded_sdmmc/fat/ondiskdirentry.rs

embedded_sdmmc/fat/
ondiskdirentry.rs
