M-Labs/rust-fatfs
3
0
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add .editorconfig file and fix whitespaces in existing files. (#4)

Browse Source
This commit is contained in:
Rafał 2017-10-25 17:20:27 +02:00 committed by GitHub
parent cffa875d34
commit 529d717e30
8 changed files with 112 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
.editorconfig Normal file
View File

@ -0,0 +1,14 @@
# EditorConfig helps developers define and maintain consistent
# coding styles between different editors and IDEs
# http://editorconfig.org
root = true
[*.rs]
end_of_line = lf
charset = utf-8
trim_trailing_whitespace = true
insert_final_newline = true
indent_style = space
indent_size = 4
max_line_length = 120

92
src/dir.rs
View File

@ -104,13 +104,13 @@ impl DirFileEntryData {
let n = ((self.first_cluster_hi as u32) << 16) | self.first_cluster_lo as u32; let n = ((self.first_cluster_hi as u32) << 16) | self.first_cluster_lo as u32;
if n == 0 { None } else { Some(n) } if n == 0 { None } else { Some(n) }
} }
pub(crate) fn set_first_cluster(&mut self, cluster: Option<u32>) { pub(crate) fn set_first_cluster(&mut self, cluster: Option<u32>) {
let n = cluster.unwrap_or(0); let n = cluster.unwrap_or(0);
self.first_cluster_hi = (n >> 16) as u16; self.first_cluster_hi = (n >> 16) as u16;
self.first_cluster_lo = (n & 0xFFFF) as u16; self.first_cluster_lo = (n & 0xFFFF) as u16;
} }
pub(crate) fn size(&self) -> Option<u32> { pub(crate) fn size(&self) -> Option<u32> {
if self.is_file() { if self.is_file() {
Some(self.size) Some(self.size)
@ -118,24 +118,24 @@ impl DirFileEntryData {
None None
} }
} }
pub(crate) fn set_size(&mut self, size: u32) { pub(crate) fn set_size(&mut self, size: u32) {
self.size = size; self.size = size;
} }
pub fn is_dir(&self) -> bool { pub fn is_dir(&self) -> bool {
self.attrs.contains(FileAttributes::DIRECTORY) self.attrs.contains(FileAttributes::DIRECTORY)
} }
pub fn is_file(&self) -> bool { pub fn is_file(&self) -> bool {
!self.is_dir() !self.is_dir()
} }
pub(crate) fn set_modified(&mut self, date_time: DateTime) { pub(crate) fn set_modified(&mut self, date_time: DateTime) {
self.modify_date = date_time.date.to_u16(); self.modify_date = date_time.date.to_u16();
self.modify_time = date_time.time.to_u16(); self.modify_time = date_time.time.to_u16();
} }
pub(crate) fn serialize(&self, wrt: &mut Write) -> io::Result<()> { pub(crate) fn serialize(&self, wrt: &mut Write) -> io::Result<()> {
wrt.write_all(&self.name)?; wrt.write_all(&self.name)?;
wrt.write_u8(self.attrs.bits())?; wrt.write_u8(self.attrs.bits())?;
@ -151,11 +151,11 @@ impl DirFileEntryData {
wrt.write_u32::<LittleEndian>(self.size)?; wrt.write_u32::<LittleEndian>(self.size)?;
Ok(()) Ok(())
} }
fn is_free(&self) -> bool { fn is_free(&self) -> bool {
self.name[0] == DIR_ENTRY_FREE_FLAG self.name[0] == DIR_ENTRY_FREE_FLAG
} }
fn is_end(&self) -> bool { fn is_end(&self) -> bool {
self.name[0] == 0 self.name[0] == 0
} }
@ -192,11 +192,11 @@ impl DirLfnEntryData {
} }
Ok(()) Ok(())
} }
fn is_free(&self) -> bool { fn is_free(&self) -> bool {
self.order == DIR_ENTRY_FREE_FLAG self.order == DIR_ENTRY_FREE_FLAG
} }
fn is_end(&self) -> bool { fn is_end(&self) -> bool {
self.order == 0 self.order == 0
} }
@ -215,7 +215,7 @@ impl DirEntryData {
&mut DirEntryData::Lfn(ref mut lfn) => lfn.serialize(wrt), &mut DirEntryData::Lfn(ref mut lfn) => lfn.serialize(wrt),
} }
} }
fn deserialize(rdr: &mut Read) -> io::Result<DirEntryData> { fn deserialize(rdr: &mut Read) -> io::Result<DirEntryData> {
let mut name = [0; 11]; let mut name = [0; 11];
rdr.read_exact(&mut name)?; rdr.read_exact(&mut name)?;
@ -251,14 +251,14 @@ impl DirEntryData {
Ok(DirEntryData::File(data)) Ok(DirEntryData::File(data))
} }
} }
fn is_free(&self) -> bool { fn is_free(&self) -> bool {
match self { match self {
&DirEntryData::File(ref file) => file.is_free(), &DirEntryData::File(ref file) => file.is_free(),
&DirEntryData::Lfn(ref lfn) => lfn.is_free(), &DirEntryData::Lfn(ref lfn) => lfn.is_free(),
} }
} }
fn is_end(&self) -> bool { fn is_end(&self) -> bool {
match self { match self {
&DirEntryData::File(ref file) => file.is_end(), &DirEntryData::File(ref file) => file.is_end(),
@ -280,7 +280,7 @@ impl Date {
let (year, month, day) = ((dos_date >> 9) + 1980, (dos_date >> 5) & 0xF, dos_date & 0x1F); let (year, month, day) = ((dos_date >> 9) + 1980, (dos_date >> 5) & 0xF, dos_date & 0x1F);
Date { year, month, day } Date { year, month, day }
} }
fn to_u16(&self) -> u16 { fn to_u16(&self) -> u16 {
((self.year - 1980) << 9) | (self.month << 5) | self.day ((self.year - 1980) << 9) | (self.month << 5) | self.day
} }
@ -299,7 +299,7 @@ impl Time {
let (hour, min, sec) = (dos_time >> 11, (dos_time >> 5) & 0x3F, (dos_time & 0x1F) * 2); let (hour, min, sec) = (dos_time >> 11, (dos_time >> 5) & 0x3F, (dos_time & 0x1F) * 2);
Time { hour, min, sec } Time { hour, min, sec }
} }
fn to_u16(&self) -> u16 { fn to_u16(&self) -> u16 {
(self.hour << 11) | (self.min << 5) | (self.sec / 2) (self.hour << 11) | (self.min << 5) | (self.sec / 2)
} }
@ -375,7 +375,7 @@ impl <'a, 'b> DirEntry<'a, 'b> {
format!("{}.{}", name_trimmed, ext_trimmed) format!("{}.{}", name_trimmed, ext_trimmed)
} }
} }
/// Returns long file name or if it doesn't exist fallbacks to short file name. /// Returns long file name or if it doesn't exist fallbacks to short file name.
pub fn file_name(&self) -> String { pub fn file_name(&self) -> String {
if self.lfn.len() > 0 { if self.lfn.len() > 0 {
@ -384,33 +384,33 @@ impl <'a, 'b> DirEntry<'a, 'b> {
self.short_file_name() self.short_file_name()
} }
} }
/// Returns file attributes /// Returns file attributes
pub fn attributes(&self) -> FileAttributes { pub fn attributes(&self) -> FileAttributes {
self.data.attrs self.data.attrs
} }
/// Checks if entry belongs to directory. /// Checks if entry belongs to directory.
pub fn is_dir(&self) -> bool { pub fn is_dir(&self) -> bool {
self.data.is_dir() self.data.is_dir()
} }
/// Checks if entry belongs to regular file. /// Checks if entry belongs to regular file.
pub fn is_file(&self) -> bool { pub fn is_file(&self) -> bool {
self.data.is_file() self.data.is_file()
} }
pub(crate) fn first_cluster(&self) -> Option<u32> { pub(crate) fn first_cluster(&self) -> Option<u32> {
self.data.first_cluster() self.data.first_cluster()
} }
fn entry_info(&self) -> FileEntryInfo { fn entry_info(&self) -> FileEntryInfo {
FileEntryInfo { FileEntryInfo {
data: self.data.clone(), data: self.data.clone(),
pos: self.entry_pos, pos: self.entry_pos,
} }
} }
/// Returns File struct for this entry. /// Returns File struct for this entry.
/// ///
/// Panics if this is not a file. /// Panics if this is not a file.
@ -418,7 +418,7 @@ impl <'a, 'b> DirEntry<'a, 'b> {
assert!(!self.is_dir(), "Not a file entry"); assert!(!self.is_dir(), "Not a file entry");
File::new(self.first_cluster(), Some(self.entry_info()), self.fs) File::new(self.first_cluster(), Some(self.entry_info()), self.fs)
} }
/// Returns Dir struct for this entry. /// Returns Dir struct for this entry.
/// ///
/// Panics if this is not a directory. /// Panics if this is not a directory.
@ -432,22 +432,22 @@ impl <'a, 'b> DirEntry<'a, 'b> {
None => self.fs.root_dir(), None => self.fs.root_dir(),
} }
} }
/// Returns file size or 0 for directory. /// Returns file size or 0 for directory.
pub fn len(&self) -> u64 { pub fn len(&self) -> u64 {
self.data.size as u64 self.data.size as u64
} }
/// Returns file creation date and time. /// Returns file creation date and time.
pub fn created(&self) -> DateTime { pub fn created(&self) -> DateTime {
DateTime::from_u16(self.data.create_date, self.data.create_time_1) DateTime::from_u16(self.data.create_date, self.data.create_time_1)
} }
/// Returns file last access date. /// Returns file last access date.
pub fn accessed(&self) -> Date { pub fn accessed(&self) -> Date {
Date::from_u16(self.data.access_date) Date::from_u16(self.data.access_date)
} }
/// Returns file last modification date and time. /// Returns file last modification date and time.
pub fn modified(&self) -> DateTime { pub fn modified(&self) -> DateTime {
DateTime::from_u16(self.data.modify_date, self.data.modify_time) DateTime::from_u16(self.data.modify_date, self.data.modify_time)
@ -468,11 +468,11 @@ pub struct Dir<'a, 'b: 'a> {
} }
impl <'a, 'b> Dir<'a, 'b> { impl <'a, 'b> Dir<'a, 'b> {
pub(crate) fn new(stream: DirRawStream<'a, 'b>, fs: FileSystemRef<'a, 'b>) -> Dir<'a, 'b> { pub(crate) fn new(stream: DirRawStream<'a, 'b>, fs: FileSystemRef<'a, 'b>) -> Dir<'a, 'b> {
Dir { stream, fs } Dir { stream, fs }
} }
/// Creates directory entries iterator /// Creates directory entries iterator
pub fn iter(&self) -> DirIter<'a, 'b> { pub fn iter(&self) -> DirIter<'a, 'b> {
DirIter { DirIter {
@ -481,14 +481,14 @@ impl <'a, 'b> Dir<'a, 'b> {
err: false, err: false,
} }
} }
fn split_path<'c>(path: &'c str) -> (&'c str, Option<&'c str>) { fn split_path<'c>(path: &'c str) -> (&'c str, Option<&'c str>) {
let mut path_split = path.trim_matches('/').splitn(2, "/"); let mut path_split = path.trim_matches('/').splitn(2, "/");
let comp = path_split.next().unwrap(); // safe unwrap - splitn always returns at least one element let comp = path_split.next().unwrap(); // safe unwrap - splitn always returns at least one element
let rest_opt = path_split.next(); let rest_opt = path_split.next();
(comp, rest_opt) (comp, rest_opt)
} }
fn find_entry(&mut self, name: &str) -> io::Result<DirEntry<'a, 'b>> { fn find_entry(&mut self, name: &str) -> io::Result<DirEntry<'a, 'b>> {
for r in self.iter() { for r in self.iter() {
let e = r?; let e = r?;
@ -498,7 +498,7 @@ impl <'a, 'b> Dir<'a, 'b> {
} }
Err(io::Error::new(ErrorKind::NotFound, "file not found")) Err(io::Error::new(ErrorKind::NotFound, "file not found"))
} }
/// Opens existing directory /// Opens existing directory
pub fn open_dir(&mut self, path: &str) -> io::Result<Dir<'a, 'b>> { pub fn open_dir(&mut self, path: &str) -> io::Result<Dir<'a, 'b>> {
let (name, rest_opt) = Self::split_path(path); let (name, rest_opt) = Self::split_path(path);
@ -508,7 +508,7 @@ impl <'a, 'b> Dir<'a, 'b> {
None => Ok(e.to_dir()) None => Ok(e.to_dir())
} }
} }
/// Opens existing file. /// Opens existing file.
pub fn open_file(&mut self, path: &str) -> io::Result<File<'a, 'b>> { pub fn open_file(&mut self, path: &str) -> io::Result<File<'a, 'b>> {
let (name, rest_opt) = Self::split_path(path); let (name, rest_opt) = Self::split_path(path);
@ -518,7 +518,7 @@ impl <'a, 'b> Dir<'a, 'b> {
None => Ok(e.to_file()) None => Ok(e.to_file())
} }
} }
/// Creates new file or opens existing. /// Creates new file or opens existing.
pub fn create_file(&mut self, path: &str) -> io::Result<File<'a, 'b>> { pub fn create_file(&mut self, path: &str) -> io::Result<File<'a, 'b>> {
let (name, rest_opt) = Self::split_path(path); let (name, rest_opt) = Self::split_path(path);
@ -533,7 +533,7 @@ impl <'a, 'b> Dir<'a, 'b> {
} }
} }
} }
fn is_empty(&mut self) -> io::Result<bool> { fn is_empty(&mut self) -> io::Result<bool> {
for r in self.iter() { for r in self.iter() {
let e = r?; let e = r?;
@ -544,7 +544,7 @@ impl <'a, 'b> Dir<'a, 'b> {
} }
Ok(true) Ok(true)
} }
/// Removes existing file or directory. /// Removes existing file or directory.
/// ///
/// Make sure there is no reference to this file (no File instance) or filesystem corruption /// Make sure there is no reference to this file (no File instance) or filesystem corruption
@ -581,7 +581,7 @@ impl <'a, 'b> Dir<'a, 'b> {
} }
} }
} }
fn find_free_entries(&mut self, num_entries: usize) -> io::Result<DirRawStream<'a, 'b>> { fn find_free_entries(&mut self, num_entries: usize) -> io::Result<DirRawStream<'a, 'b>> {
let mut stream = self.stream.clone(); let mut stream = self.stream.clone();
let mut first_free = 0; let mut first_free = 0;
@ -611,7 +611,7 @@ impl <'a, 'b> Dir<'a, 'b> {
i += 1; i += 1;
} }
} }
fn gen_short_name(name: &str) -> [u8;11] { fn gen_short_name(name: &str) -> [u8;11] {
// short name is always uppercase // short name is always uppercase
let mut name_upper = name.to_uppercase(); let mut name_upper = name.to_uppercase();
@ -634,7 +634,7 @@ impl <'a, 'b> Dir<'a, 'b> {
// FIXME: make sure short name is unique... // FIXME: make sure short name is unique...
short_name short_name
} }
fn create_file_entry(&mut self, name: &str) -> io::Result<DirEntry<'a, 'b>> { fn create_file_entry(&mut self, name: &str) -> io::Result<DirEntry<'a, 'b>> {
if name.len() > 255 { if name.len() > 255 {
return Err(io::Error::new(ErrorKind::InvalidInput, "filename too long")); return Err(io::Error::new(ErrorKind::InvalidInput, "filename too long"));
@ -700,7 +700,7 @@ impl <'a, 'b> DirIter<'a, 'b> {
fn read_dir_entry_raw_data(&mut self) -> io::Result<DirEntryData> { fn read_dir_entry_raw_data(&mut self) -> io::Result<DirEntryData> {
DirEntryData::deserialize(&mut self.stream) DirEntryData::deserialize(&mut self.stream)
} }
fn read_dir_entry(&mut self) -> io::Result<Option<DirEntry<'a, 'b>>> { fn read_dir_entry(&mut self) -> io::Result<Option<DirEntry<'a, 'b>>> {
let mut lfn_buf = LongNameBuilder::new(); let mut lfn_buf = LongNameBuilder::new();
let mut offset = self.stream.seek(SeekFrom::Current(0))?; let mut offset = self.stream.seek(SeekFrom::Current(0))?;
@ -788,12 +788,12 @@ impl LongNameBuilder {
index: 0, index: 0,
} }
} }
fn clear(&mut self) { fn clear(&mut self) {
self.buf.clear(); self.buf.clear();
self.index = 0; self.index = 0;
} }
fn to_vec(mut self) -> Vec<u16> { fn to_vec(mut self) -> Vec<u16> {
if self.index == 1 { if self.index == 1 {
self.truncate(); self.truncate();
@ -803,7 +803,7 @@ impl LongNameBuilder {
Vec::<u16>::new() Vec::<u16>::new()
} }
} }
fn truncate(&mut self) { fn truncate(&mut self) {
// Truncate 0 and 0xFFFF characters from LFN buffer // Truncate 0 and 0xFFFF characters from LFN buffer
let mut lfn_len = self.buf.len(); let mut lfn_len = self.buf.len();
@ -818,7 +818,7 @@ impl LongNameBuilder {
} }
self.buf.truncate(lfn_len); self.buf.truncate(lfn_len);
} }
fn process(&mut self, data: &DirLfnEntryData) { fn process(&mut self, data: &DirLfnEntryData) {
let is_last = (data.order & LFN_ENTRY_LAST_FLAG) != 0; let is_last = (data.order & LFN_ENTRY_LAST_FLAG) != 0;
let index = data.order & 0x1F; let index = data.order & 0x1F;
@ -848,7 +848,7 @@ impl LongNameBuilder {
self.buf[pos+5..pos+11].copy_from_slice(&data.name_1); self.buf[pos+5..pos+11].copy_from_slice(&data.name_1);
self.buf[pos+11..pos+13].copy_from_slice(&data.name_2); self.buf[pos+11..pos+13].copy_from_slice(&data.name_2);
} }
fn validate_chksum(&mut self, short_name: &[u8]) { fn validate_chksum(&mut self, short_name: &[u8]) {
let chksum = lfn_checksum(short_name); let chksum = lfn_checksum(short_name);
if chksum != self.chksum { if chksum != self.chksum {

18
src/file.rs
View File

@ -31,7 +31,7 @@ impl <'a, 'b> File<'a, 'b> {
entry_dirty: false, entry_dirty: false,
} }
} }
fn update_size(&mut self) { fn update_size(&mut self) {
let offset = self.offset; let offset = self.offset;
match self.entry { match self.entry {
@ -44,7 +44,7 @@ impl <'a, 'b> File<'a, 'b> {
_ => {}, _ => {},
} }
} }
/// Truncate file to current position. /// Truncate file to current position.
pub fn truncate(&mut self) -> io::Result<()> { pub fn truncate(&mut self) -> io::Result<()> {
let offset = self.offset; let offset = self.offset;
@ -53,7 +53,7 @@ impl <'a, 'b> File<'a, 'b> {
if e.data.size().map_or(false, |s| offset == s) { if e.data.size().map_or(false, |s| offset == s) {
return Ok(()); return Ok(());
} }
e.data.set_size(self.offset); e.data.set_size(self.offset);
if self.offset == 0 { if self.offset == 0 {
e.data.set_first_cluster(None); e.data.set_first_cluster(None);
@ -75,7 +75,7 @@ impl <'a, 'b> File<'a, 'b> {
Ok(()) Ok(())
} }
} }
pub(crate) fn abs_pos(&self) -> Option<u64> { pub(crate) fn abs_pos(&self) -> Option<u64> {
// Returns current position relative to filesystem start // Returns current position relative to filesystem start
// Note: when between clusters it returns position after previous cluster // Note: when between clusters it returns position after previous cluster
@ -89,7 +89,7 @@ impl <'a, 'b> File<'a, 'b> {
None => None, None => None,
} }
} }
pub(crate) fn flush_dir_entry(&self) -> io::Result<()> { pub(crate) fn flush_dir_entry(&self) -> io::Result<()> {
if self.entry_dirty { if self.entry_dirty {
match self.entry { match self.entry {
@ -99,7 +99,7 @@ impl <'a, 'b> File<'a, 'b> {
} }
Ok(()) Ok(())
} }
/// Set date and time of last modification for this file. /// Set date and time of last modification for this file.
/// ///
/// Note: this library doesn't know current time so changing timestamp must be done manually. /// Note: this library doesn't know current time so changing timestamp must be done manually.
@ -112,14 +112,14 @@ impl <'a, 'b> File<'a, 'b> {
_ => {}, _ => {},
} }
} }
fn bytes_left_in_file(&self) -> Option<usize> { fn bytes_left_in_file(&self) -> Option<usize> {
match self.entry { match self.entry {
Some(ref e) => e.data.size().map(|s| (s - self.offset) as usize), Some(ref e) => e.data.size().map(|s| (s - self.offset) as usize),
None => None, None => None,
} }
} }
fn set_first_cluster(&mut self, cluster: u32) { fn set_first_cluster(&mut self, cluster: u32) {
self.first_cluster = Some(cluster); self.first_cluster = Some(cluster);
match self.entry { match self.entry {
@ -241,7 +241,7 @@ impl<'a, 'b> Write for File<'a, 'b> {
self.update_size(); self.update_size();
Ok(written_bytes) Ok(written_bytes)
} }
fn flush(&mut self) -> io::Result<()> { fn flush(&mut self) -> io::Result<()> {
self.flush_dir_entry()?; self.flush_dir_entry()?;
let mut disk = self.fs.disk.borrow_mut(); let mut disk = self.fs.disk.borrow_mut();

48
src/fs.rs
View File

@ -39,7 +39,7 @@ pub(crate) struct BiosParameterBlock {
heads: u16, heads: u16,
hidden_sectors: u32, hidden_sectors: u32,
total_sectors_32: u32, total_sectors_32: u32,
// Extended BIOS Parameter Block // Extended BIOS Parameter Block
sectors_per_fat_32: u32, sectors_per_fat_32: u32,
extended_flags: u16, extended_flags: u16,
@ -66,7 +66,7 @@ pub(crate) struct BootRecord {
} }
impl Default for BootRecord { impl Default for BootRecord {
fn default() -> BootRecord { fn default() -> BootRecord {
BootRecord { BootRecord {
bootjmp: Default::default(), bootjmp: Default::default(),
oem_name: Default::default(), oem_name: Default::default(),
@ -98,7 +98,7 @@ impl <'a> FileSystem<'a> {
if boot.boot_sig != [0x55, 0xAA] { if boot.boot_sig != [0x55, 0xAA] {
return Err(Error::new(ErrorKind::Other, "invalid signature")); return Err(Error::new(ErrorKind::Other, "invalid signature"));
} }
let total_sectors = if boot.bpb.total_sectors_16 == 0 { boot.bpb.total_sectors_32 } else { boot.bpb.total_sectors_16 as u32 }; let total_sectors = if boot.bpb.total_sectors_16 == 0 { boot.bpb.total_sectors_32 } else { boot.bpb.total_sectors_16 as u32 };
let sectors_per_fat = if boot.bpb.sectors_per_fat_16 == 0 { boot.bpb.sectors_per_fat_32 } else { boot.bpb.sectors_per_fat_16 as u32 }; let sectors_per_fat = if boot.bpb.sectors_per_fat_16 == 0 { boot.bpb.sectors_per_fat_32 } else { boot.bpb.sectors_per_fat_16 as u32 };
let root_dir_sectors = (((boot.bpb.root_entries * 32) + (boot.bpb.bytes_per_sector - 1)) / boot.bpb.bytes_per_sector) as u32; let root_dir_sectors = (((boot.bpb.root_entries * 32) + (boot.bpb.bytes_per_sector - 1)) / boot.bpb.bytes_per_sector) as u32;
@ -106,7 +106,7 @@ impl <'a> FileSystem<'a> {
let data_sectors = total_sectors - (boot.bpb.reserved_sectors as u32 + (boot.bpb.fats as u32 * sectors_per_fat) + root_dir_sectors as u32); let data_sectors = total_sectors - (boot.bpb.reserved_sectors as u32 + (boot.bpb.fats as u32 * sectors_per_fat) + root_dir_sectors as u32);
let total_clusters = data_sectors / boot.bpb.sectors_per_cluster as u32; let total_clusters = data_sectors / boot.bpb.sectors_per_cluster as u32;
let fat_type = Self::fat_type_from_clusters(total_clusters); let fat_type = Self::fat_type_from_clusters(total_clusters);
Ok(FileSystem { Ok(FileSystem {
disk: RefCell::new(disk), disk: RefCell::new(disk),
fat_type, fat_type,
@ -115,17 +115,17 @@ impl <'a> FileSystem<'a> {
root_dir_sectors, root_dir_sectors,
}) })
} }
/// Returns type of used File Allocation Table (FAT). /// Returns type of used File Allocation Table (FAT).
pub fn fat_type(&self) -> FatType { pub fn fat_type(&self) -> FatType {
self.fat_type self.fat_type
} }
/// Returns volume identifier read from BPB in Boot Sector. /// Returns volume identifier read from BPB in Boot Sector.
pub fn volume_id(&self) -> u32 { pub fn volume_id(&self) -> u32 {
self.boot.bpb.volume_id self.boot.bpb.volume_id
} }
/// Returns volume label from BPB in Boot Sector. /// Returns volume label from BPB in Boot Sector.
/// ///
/// Note: File with VOLUME_ID attribute in root directory is ignored by this library. /// Note: File with VOLUME_ID attribute in root directory is ignored by this library.
@ -133,7 +133,7 @@ impl <'a> FileSystem<'a> {
pub fn volume_label(&self) -> String { pub fn volume_label(&self) -> String {
String::from_utf8_lossy(&self.boot.bpb.volume_label).trim_right().to_string() String::from_utf8_lossy(&self.boot.bpb.volume_label).trim_right().to_string()
} }
/// Returns root directory object allowing futher penetration of filesystem structure. /// Returns root directory object allowing futher penetration of filesystem structure.
pub fn root_dir<'b>(&'b self) -> Dir<'b, 'a> { pub fn root_dir<'b>(&'b self) -> Dir<'b, 'a> {
let root_rdr = { let root_rdr = {
@ -145,7 +145,7 @@ impl <'a> FileSystem<'a> {
}; };
Dir::new(root_rdr, self) Dir::new(root_rdr, self)
} }
fn read_bpb(rdr: &mut Read) -> io::Result<BiosParameterBlock> { fn read_bpb(rdr: &mut Read) -> io::Result<BiosParameterBlock> {
let mut bpb: BiosParameterBlock = Default::default(); let mut bpb: BiosParameterBlock = Default::default();
bpb.bytes_per_sector = rdr.read_u16::<LittleEndian>()?; bpb.bytes_per_sector = rdr.read_u16::<LittleEndian>()?;
@ -160,7 +160,7 @@ impl <'a> FileSystem<'a> {
bpb.heads = rdr.read_u16::<LittleEndian>()?; bpb.heads = rdr.read_u16::<LittleEndian>()?;
bpb.hidden_sectors = rdr.read_u32::<LittleEndian>()?; bpb.hidden_sectors = rdr.read_u32::<LittleEndian>()?;
bpb.total_sectors_32 = rdr.read_u32::<LittleEndian>()?; bpb.total_sectors_32 = rdr.read_u32::<LittleEndian>()?;
// sanity checks // sanity checks
if bpb.bytes_per_sector < 512 { if bpb.bytes_per_sector < 512 {
return Err(Error::new(ErrorKind::Other, "invalid bytes_per_sector value in BPB")); return Err(Error::new(ErrorKind::Other, "invalid bytes_per_sector value in BPB"));
@ -174,7 +174,7 @@ impl <'a> FileSystem<'a> {
if bpb.fats == 0 { if bpb.fats == 0 {
return Err(Error::new(ErrorKind::Other, "invalid fats value in BPB")); return Err(Error::new(ErrorKind::Other, "invalid fats value in BPB"));
} }
if bpb.sectors_per_fat_16 == 0 { if bpb.sectors_per_fat_16 == 0 {
bpb.sectors_per_fat_32 = rdr.read_u32::<LittleEndian>()?; bpb.sectors_per_fat_32 = rdr.read_u32::<LittleEndian>()?;
bpb.extended_flags = rdr.read_u16::<LittleEndian>()?; bpb.extended_flags = rdr.read_u16::<LittleEndian>()?;
@ -199,7 +199,7 @@ impl <'a> FileSystem<'a> {
} }
Ok(bpb) Ok(bpb)
} }
fn fat_type_from_clusters(total_clusters: u32) -> FatType { fn fat_type_from_clusters(total_clusters: u32) -> FatType {
if total_clusters < 4085 { if total_clusters < 4085 {
FatType::Fat12 FatType::Fat12
@ -209,13 +209,13 @@ impl <'a> FileSystem<'a> {
FatType::Fat32 FatType::Fat32
} }
} }
fn read_boot_record(rdr: &mut Read) -> io::Result<BootRecord> { fn read_boot_record(rdr: &mut Read) -> io::Result<BootRecord> {
let mut boot: BootRecord = Default::default(); let mut boot: BootRecord = Default::default();
rdr.read_exact(&mut boot.bootjmp)?; rdr.read_exact(&mut boot.bootjmp)?;
rdr.read_exact(&mut boot.oem_name)?; rdr.read_exact(&mut boot.oem_name)?;
boot.bpb = Self::read_bpb(rdr)?; boot.bpb = Self::read_bpb(rdr)?;
if boot.bpb.sectors_per_fat_16 == 0 { if boot.bpb.sectors_per_fat_16 == 0 {
rdr.read_exact(&mut boot.boot_code[0..420])?; rdr.read_exact(&mut boot.boot_code[0..420])?;
} else { } else {
@ -224,23 +224,23 @@ impl <'a> FileSystem<'a> {
rdr.read_exact(&mut boot.boot_sig)?; rdr.read_exact(&mut boot.boot_sig)?;
Ok(boot) Ok(boot)
} }
pub(crate) fn offset_from_sector(&self, sector: u32) -> u64 { pub(crate) fn offset_from_sector(&self, sector: u32) -> u64 {
(sector as u64) * self.boot.bpb.bytes_per_sector as u64 (sector as u64) * self.boot.bpb.bytes_per_sector as u64
} }
pub(crate) fn sector_from_cluster(&self, cluster: u32) -> u32 { pub(crate) fn sector_from_cluster(&self, cluster: u32) -> u32 {
((cluster - 2) * self.boot.bpb.sectors_per_cluster as u32) + self.first_data_sector ((cluster - 2) * self.boot.bpb.sectors_per_cluster as u32) + self.first_data_sector
} }
pub(crate) fn get_cluster_size(&self) -> u32 { pub(crate) fn get_cluster_size(&self) -> u32 {
self.boot.bpb.sectors_per_cluster as u32 * self.boot.bpb.bytes_per_sector as u32 self.boot.bpb.sectors_per_cluster as u32 * self.boot.bpb.bytes_per_sector as u32
} }
pub(crate) fn offset_from_cluster(&self, cluser: u32) -> u64 { pub(crate) fn offset_from_cluster(&self, cluser: u32) -> u64 {
self.offset_from_sector(self.sector_from_cluster(cluser)) self.offset_from_sector(self.sector_from_cluster(cluser))
} }
fn fat_slice<'b>(&'b self) -> DiskSlice<'b, 'a> { fn fat_slice<'b>(&'b self) -> DiskSlice<'b, 'a> {
let sectors_per_fat = let sectors_per_fat =
if self.boot.bpb.sectors_per_fat_16 == 0 { self.boot.bpb.sectors_per_fat_32 } if self.boot.bpb.sectors_per_fat_16 == 0 { self.boot.bpb.sectors_per_fat_32 }
@ -255,12 +255,12 @@ impl <'a> FileSystem<'a> {
}; };
DiskSlice::from_sectors(fat_first_sector, sectors_per_fat, mirrors, self) DiskSlice::from_sectors(fat_first_sector, sectors_per_fat, mirrors, self)
} }
pub(crate) fn cluster_iter<'b>(&'b self, cluster: u32) -> ClusterIterator<'b, 'a> { pub(crate) fn cluster_iter<'b>(&'b self, cluster: u32) -> ClusterIterator<'b, 'a> {
let disk_slice = self.fat_slice(); let disk_slice = self.fat_slice();
ClusterIterator::new(disk_slice, self.fat_type, cluster) ClusterIterator::new(disk_slice, self.fat_type, cluster)
} }
pub(crate) fn alloc_cluster(&self, prev_cluster: Option<u32>) -> io::Result<u32> { pub(crate) fn alloc_cluster(&self, prev_cluster: Option<u32>) -> io::Result<u32> {
let mut disk_slice = self.fat_slice(); let mut disk_slice = self.fat_slice();
alloc_cluster(&mut disk_slice, self.fat_type, prev_cluster) alloc_cluster(&mut disk_slice, self.fat_type, prev_cluster)
@ -280,12 +280,12 @@ impl <'a, 'b> DiskSlice<'a, 'b> {
pub(crate) fn new(begin: u64, size: u64, mirrors: u8, fs: FileSystemRef<'a, 'b>) -> Self { pub(crate) fn new(begin: u64, size: u64, mirrors: u8, fs: FileSystemRef<'a, 'b>) -> Self {
DiskSlice { begin, size, mirrors, fs, offset: 0 } DiskSlice { begin, size, mirrors, fs, offset: 0 }
} }
pub(crate) fn from_sectors(first_sector: u32, sector_count: u32, mirrors: u8, fs: FileSystemRef<'a, 'b>) -> Self { pub(crate) fn from_sectors(first_sector: u32, sector_count: u32, mirrors: u8, fs: FileSystemRef<'a, 'b>) -> Self {
let bytes_per_sector = fs.boot.bpb.bytes_per_sector as u64; let bytes_per_sector = fs.boot.bpb.bytes_per_sector as u64;
Self::new(first_sector as u64 * bytes_per_sector, sector_count as u64 * bytes_per_sector, mirrors, fs) Self::new(first_sector as u64 * bytes_per_sector, sector_count as u64 * bytes_per_sector, mirrors, fs)
} }
pub(crate) fn abs_pos(&self) -> u64 { pub(crate) fn abs_pos(&self) -> u64 {
self.begin + self.offset self.begin + self.offset
} }
@ -315,7 +315,7 @@ impl <'a, 'b> Write for DiskSlice<'a, 'b> {
self.offset += write_size as u64; self.offset += write_size as u64;
Ok(write_size) Ok(write_size)
} }
fn flush(&mut self) -> io::Result<()> { fn flush(&mut self) -> io::Result<()> {
let mut disk = self.fs.disk.borrow_mut(); let mut disk = self.fs.disk.borrow_mut();
disk.flush() disk.flush()

14
src/table.rs
View File

@ -85,7 +85,7 @@ impl FatTrait for Fat12 {
n => FatValue::Data(n as u32), n => FatValue::Data(n as u32),
}) })
} }
fn set(fat: &mut DiskSlice, cluster: u32, value: FatValue) -> io::Result<()> { fn set(fat: &mut DiskSlice, cluster: u32, value: FatValue) -> io::Result<()> {
let raw_val = match value { let raw_val = match value {
FatValue::Free => 0, FatValue::Free => 0,
@ -141,7 +141,7 @@ impl FatTrait for Fat16 {
n => FatValue::Data(n as u32), n => FatValue::Data(n as u32),
}) })
} }
fn set(fat: &mut DiskSlice, cluster: u32, value: FatValue) -> io::Result<()> { fn set(fat: &mut DiskSlice, cluster: u32, value: FatValue) -> io::Result<()> {
fat.seek(io::SeekFrom::Start((cluster*2) as u64))?; fat.seek(io::SeekFrom::Start((cluster*2) as u64))?;
let raw_val = match value { let raw_val = match value {
@ -153,7 +153,7 @@ impl FatTrait for Fat16 {
fat.write_u16::<LittleEndian>(raw_val)?; fat.write_u16::<LittleEndian>(raw_val)?;
Ok(()) Ok(())
} }
fn find_free(fat: &mut ReadSeek, hint_cluster: u32) -> io::Result<u32> { fn find_free(fat: &mut ReadSeek, hint_cluster: u32) -> io::Result<u32> {
let mut cluster = hint_cluster; let mut cluster = hint_cluster;
fat.seek(io::SeekFrom::Start((cluster*2) as u64))?; fat.seek(io::SeekFrom::Start((cluster*2) as u64))?;
@ -178,7 +178,7 @@ impl FatTrait for Fat32 {
n => FatValue::Data(n as u32), n => FatValue::Data(n as u32),
}) })
} }
fn set(fat: &mut DiskSlice, cluster: u32, value: FatValue) -> io::Result<()> { fn set(fat: &mut DiskSlice, cluster: u32, value: FatValue) -> io::Result<()> {
fat.seek(io::SeekFrom::Start((cluster*4) as u64))?; fat.seek(io::SeekFrom::Start((cluster*4) as u64))?;
let raw_val = match value { let raw_val = match value {
@ -190,7 +190,7 @@ impl FatTrait for Fat32 {
fat.write_u32::<LittleEndian>(raw_val)?; fat.write_u32::<LittleEndian>(raw_val)?;
Ok(()) Ok(())
} }
fn find_free(fat: &mut ReadSeek, hint_cluster: u32) -> io::Result<u32> { fn find_free(fat: &mut ReadSeek, hint_cluster: u32) -> io::Result<u32> {
let mut cluster = hint_cluster; let mut cluster = hint_cluster;
fat.seek(io::SeekFrom::Start((cluster*4) as u64))?; fat.seek(io::SeekFrom::Start((cluster*4) as u64))?;
@ -221,7 +221,7 @@ impl <'a, 'b> ClusterIterator<'a, 'b> {
err: false, err: false,
} }
} }
pub(crate) fn truncate(&mut self) -> io::Result<()> { pub(crate) fn truncate(&mut self) -> io::Result<()> {
match self.cluster { match self.cluster {
Some(n) => { Some(n) => {
@ -232,7 +232,7 @@ impl <'a, 'b> ClusterIterator<'a, 'b> {
None => Ok(()), None => Ok(()),
} }
} }
pub(crate) fn free(&mut self) -> io::Result<()> { pub(crate) fn free(&mut self) -> io::Result<()> {
loop { loop {
let prev = self.cluster; let prev = self.cluster;

10
src/utils.rs
View File

@ -32,7 +32,7 @@ impl<T: Read+Write+Seek> BufStream<T> {
write: false, write: false,
} }
} }
fn flush_buf(&mut self) -> io::Result<()> { fn flush_buf(&mut self) -> io::Result<()> {
if self.write { if self.write {
self.inner.write_all(&self.buf[..self.pos])?; self.inner.write_all(&self.buf[..self.pos])?;
@ -40,7 +40,7 @@ impl<T: Read+Write+Seek> BufStream<T> {
} }
Ok(()) Ok(())
} }
fn make_reader(&mut self) -> io::Result<()> { fn make_reader(&mut self) -> io::Result<()> {
if self.write { if self.write {
self.flush_buf()?; self.flush_buf()?;
@ -50,7 +50,7 @@ impl<T: Read+Write+Seek> BufStream<T> {
} }
Ok(()) Ok(())
} }
fn make_writter(&mut self) -> io::Result<()> { fn make_writter(&mut self) -> io::Result<()> {
if !self.write { if !self.write {
self.inner.seek(io::SeekFrom::Current(-(self.len as i64 - self.pos as i64)))?; self.inner.seek(io::SeekFrom::Current(-(self.len as i64 - self.pos as i64)))?;
@ -71,7 +71,7 @@ impl<T: Read+Write+Seek> BufRead for BufStream<T> {
} }
Ok(&self.buf[self.pos..self.len]) Ok(&self.buf[self.pos..self.len])
} }
fn consume(&mut self, amt: usize) { fn consume(&mut self, amt: usize) {
self.pos = cmp::min(self.pos + amt, self.len); self.pos = cmp::min(self.pos + amt, self.len);
} }
@ -108,7 +108,7 @@ impl<T: Read+Write+Seek> Write for BufStream<T> {
self.pos += written; self.pos += written;
Ok(written) Ok(written)
} }
fn flush(&mut self) -> io::Result<()> { fn flush(&mut self) -> io::Result<()> {
self.flush_buf()?; self.flush_buf()?;
self.inner.flush() self.inner.flush()

12
tests/read.rs
View File

@ -54,12 +54,12 @@ fn test_read_seek_short_file(fs: FileSystem) {
let mut buf = Vec::new(); let mut buf = Vec::new();
short_file.read_to_end(&mut buf).unwrap(); short_file.read_to_end(&mut buf).unwrap();
assert_eq!(str::from_utf8(&buf).unwrap(), TEST_TEXT); assert_eq!(str::from_utf8(&buf).unwrap(), TEST_TEXT);
assert_eq!(short_file.seek(SeekFrom::Start(5)).unwrap(), 5); assert_eq!(short_file.seek(SeekFrom::Start(5)).unwrap(), 5);
let mut buf2 = [0; 5]; let mut buf2 = [0; 5];
short_file.read_exact(&mut buf2).unwrap(); short_file.read_exact(&mut buf2).unwrap();
assert_eq!(str::from_utf8(&buf2).unwrap(), &TEST_TEXT[5..10]); assert_eq!(str::from_utf8(&buf2).unwrap(), &TEST_TEXT[5..10]);
assert_eq!(short_file.seek(SeekFrom::Start(1000)).unwrap(), TEST_TEXT.len() as u64); assert_eq!(short_file.seek(SeekFrom::Start(1000)).unwrap(), TEST_TEXT.len() as u64);
let mut buf2 = [0; 5]; let mut buf2 = [0; 5];
assert_eq!(short_file.read(&mut buf2).unwrap(), 0); assert_eq!(short_file.read(&mut buf2).unwrap(), 0);
@ -86,7 +86,7 @@ fn test_read_long_file(fs: FileSystem) {
let mut buf = Vec::new(); let mut buf = Vec::new();
long_file.read_to_end(&mut buf).unwrap(); long_file.read_to_end(&mut buf).unwrap();
assert_eq!(str::from_utf8(&buf).unwrap(), TEST_TEXT.repeat(1000)); assert_eq!(str::from_utf8(&buf).unwrap(), TEST_TEXT.repeat(1000));
assert_eq!(long_file.seek(SeekFrom::Start(2017)).unwrap(), 2017); assert_eq!(long_file.seek(SeekFrom::Start(2017)).unwrap(), 2017);
buf.clear(); buf.clear();
let mut buf2 = [0; 10]; let mut buf2 = [0; 10];
@ -114,11 +114,11 @@ fn test_get_dir_by_path(fs: FileSystem) {
let dir = root_dir.open_dir("very/long/path/").unwrap(); let dir = root_dir.open_dir("very/long/path/").unwrap();
let names = dir.iter().map(|r| r.unwrap().file_name()).collect::<Vec<String>>(); let names = dir.iter().map(|r| r.unwrap().file_name()).collect::<Vec<String>>();
assert_eq!(names, [".", "..", "test.txt"]); assert_eq!(names, [".", "..", "test.txt"]);
let dir2 = root_dir.open_dir("very/long/path/././.").unwrap(); let dir2 = root_dir.open_dir("very/long/path/././.").unwrap();
let names2 = dir2.iter().map(|r| r.unwrap().file_name()).collect::<Vec<String>>(); let names2 = dir2.iter().map(|r| r.unwrap().file_name()).collect::<Vec<String>>();
assert_eq!(names2, [".", "..", "test.txt"]); assert_eq!(names2, [".", "..", "test.txt"]);
let root_dir2 = root_dir.open_dir("very/long/path/../../..").unwrap(); let root_dir2 = root_dir.open_dir("very/long/path/../../..").unwrap();
let root_names = root_dir2.iter().map(|r| r.unwrap().file_name()).collect::<Vec<String>>(); let root_names = root_dir2.iter().map(|r| r.unwrap().file_name()).collect::<Vec<String>>();
let root_names2 = root_dir.iter().map(|r| r.unwrap().file_name()).collect::<Vec<String>>(); let root_names2 = root_dir.iter().map(|r| r.unwrap().file_name()).collect::<Vec<String>>();
@ -146,7 +146,7 @@ fn test_get_file_by_path(fs: FileSystem) {
let mut buf = Vec::new(); let mut buf = Vec::new();
file.read_to_end(&mut buf).unwrap(); file.read_to_end(&mut buf).unwrap();
assert_eq!(str::from_utf8(&buf).unwrap(), TEST_TEXT); assert_eq!(str::from_utf8(&buf).unwrap(), TEST_TEXT);
// let mut file = root_dir.open_file("very-long-dir-name/very-long-file-name.txt").unwrap(); // let mut file = root_dir.open_file("very-long-dir-name/very-long-file-name.txt").unwrap();
// let mut buf = Vec::new(); // let mut buf = Vec::new();
// file.read_to_end(&mut buf).unwrap(); // file.read_to_end(&mut buf).unwrap();

2
tests/write.rs
View File

@ -100,7 +100,7 @@ fn test_remove(fs: FileSystem) {
names = dir.iter().map(|r| r.unwrap().file_name()).collect::<Vec<String>>(); names = dir.iter().map(|r| r.unwrap().file_name()).collect::<Vec<String>>();
assert_eq!(names, [".", ".."]); assert_eq!(names, [".", ".."]);
assert!(root_dir.remove("very/long/path").is_ok()); assert!(root_dir.remove("very/long/path").is_ok());
names = root_dir.iter().map(|r| r.unwrap().file_name()).collect::<Vec<String>>(); names = root_dir.iter().map(|r| r.unwrap().file_name()).collect::<Vec<String>>();
assert_eq!(names, ["long.txt", "short.txt", "very", "very-long-dir-name"]); assert_eq!(names, ["long.txt", "short.txt", "very", "very-long-dir-name"]);
root_dir.remove("long.txt").unwrap(); root_dir.remove("long.txt").unwrap();