use crate::core::{char, cmp, num, str};
#[cfg(feature = "lfn")]
use crate::core::{iter, slice};
use crate::io;
use crate::io::prelude::*;
use crate::io::{ErrorKind, SeekFrom};
#[cfg(all(not(feature = "std"), feature = "alloc", feature = "lfn"))]
use alloc::vec::Vec;
use crate::dir_entry::{
DirEntry, DirEntryData, DirEntryEditor, DirFileEntryData, DirLfnEntryData, FileAttributes,
ShortName, DIR_ENTRY_SIZE,
};
#[cfg(feature = "lfn")]
use crate::dir_entry::{LFN_ENTRY_LAST_FLAG, LFN_PART_LEN};
use crate::dir_entry::{SFN_PADDING, SFN_SIZE};
use crate::error::FatfsError;
use crate::file::File;
use crate::fs::{DiskSlice, FileSystem, FsIoAdapter, OemCpConverter, ReadWriteSeek};
use crate::time::{Date, DateTime, TimeProvider};
use std::cell::{RefCell, RefMut};
pub(crate) enum DirRawStream<'fs, IO: ReadWriteSeek, TP, OCC> {
File(Option<File<'fs, IO, TP, OCC>>),
Root(DiskSlice<FsIoAdapter<'fs, IO, TP, OCC>>),
}
impl<IO: ReadWriteSeek, TP, OCC> DirRawStream<'_, IO, TP, OCC> {
fn abs_pos(&self) -> Result<Option<u64>, FatfsError> {
match self {
DirRawStream::File(file) => {
if let Some(ref file) = file {
Ok(file.abs_pos()?)
} else {
Ok(None)
}
}
DirRawStream::Root(slice) => Ok(Some(slice.abs_pos())),
}
}
fn first_cluster(&self) -> Option<u32> {
match self {
DirRawStream::File(file) => file.as_ref().and_then(|f| f.first_cluster()),
DirRawStream::Root(_) => None,
}
}
fn entry_mut(&mut self) -> Option<&mut DirEntryEditor> {
match self {
DirRawStream::File(file) => file.as_mut().and_then(|f| f.editor_mut()),
DirRawStream::Root(_) => None,
}
}
fn entry(&self) -> Option<&DirEntryEditor> {
match self {
DirRawStream::File(file) => file.as_ref().and_then(|f| f.editor()),
DirRawStream::Root(_) => None,
}
}
fn is_deleted(&self) -> bool {
match self {
DirRawStream::File(file) => file.as_ref().map_or(true, |f| f.is_deleted()),
DirRawStream::Root(_) => false,
}
}
}
impl<IO: ReadWriteSeek, TP: TimeProvider, OCC> Read for DirRawStream<'_, IO, TP, OCC> {
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
match self {
DirRawStream::File(Some(file)) => file.read(buf),
DirRawStream::File(None) => {
Err(io::Error::new(ErrorKind::NotFound, "Directory has been deleted"))
}
DirRawStream::Root(raw) => raw.read(buf),
}
}
}
impl<IO: ReadWriteSeek, TP: TimeProvider, OCC> Write for DirRawStream<'_, IO, TP, OCC> {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
match self {
DirRawStream::File(Some(file)) => file.write(buf),
DirRawStream::File(None) => {
Err(io::Error::new(ErrorKind::NotFound, "Directory has been deleted"))
}
DirRawStream::Root(raw) => raw.write(buf),
}
}
fn flush(&mut self) -> io::Result<()> {
match self {
DirRawStream::File(Some(file)) => file.flush(),
DirRawStream::File(None) => {
Err(io::Error::new(ErrorKind::NotFound, "Directory has been deleted"))
}
DirRawStream::Root(raw) => raw.flush(),
}
}
}
impl<IO: ReadWriteSeek, TP, OCC> Seek for DirRawStream<'_, IO, TP, OCC> {
fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
match self {
DirRawStream::File(Some(file)) => file.seek(pos),
DirRawStream::File(None) => {
Err(io::Error::new(ErrorKind::NotFound, "Directory has been deleted"))
}
DirRawStream::Root(raw) => raw.seek(pos),
}
}
}
pub fn validate_filename<'a>(name: &'a str) -> io::Result<()> {
if name == "." || name == ".." {
return Ok(());
}
if name.ends_with(&['.', ' '][..]) || name.is_empty() {
return Err(io::Error::new(ErrorKind::InvalidInput, "Illegal filename"));
}
Ok(())
}
fn split_path<'a>(path: &'a str) -> io::Result<(&'a str, Option<&'a str>)> {
let mut path_split = path.trim_matches('/').splitn(2, '/');
let comp = path_split.next().unwrap(); validate_filename(comp)?;
let rest_opt = path_split.next();
Ok((comp, rest_opt))
}
enum DirEntryOrShortName<'fs, IO: ReadWriteSeek, TP, OCC> {
DirEntry(DirEntry<'fs, IO, TP, OCC>),
ShortName([u8; SFN_SIZE]),
}
pub struct Dir<'fs, IO: ReadWriteSeek, TP, OCC> {
stream: RefCell<DirRawStream<'fs, IO, TP, OCC>>,
fs: &'fs FileSystem<IO, TP, OCC>,
is_root: bool,
}
impl<'fs, IO: ReadWriteSeek, TP, OCC> Dir<'fs, IO, TP, OCC> {
pub(crate) fn new(
stream: DirRawStream<'fs, IO, TP, OCC>,
fs: &'fs FileSystem<IO, TP, OCC>,
is_root: bool,
) -> Self {
Dir { stream: RefCell::new(stream), fs, is_root }
}
pub fn iter<'a>(&'a self) -> DirIter<'a, 'fs, IO, TP, OCC> {
DirIter::new(&self.stream, self.fs, true)
}
}
impl<'fs, IO: ReadWriteSeek, TP: TimeProvider, OCC: OemCpConverter> Dir<'fs, IO, TP, OCC> {
fn find_entry(
&self,
name: &str,
is_dir: Option<bool>,
mut short_name_gen: Option<&mut ShortNameGenerator>,
) -> io::Result<DirEntry<'fs, IO, TP, OCC>> {
for r in self.iter() {
let e = r?;
if e.eq_name(name) {
if is_dir.is_some() && Some(e.is_dir()) != is_dir {
let error =
if e.is_dir() { FatfsError::IsDirectory } else { FatfsError::NotDirectory };
return Err(io::Error::new(ErrorKind::Other, error));
}
return Ok(e);
}
if let Some(ref mut gen) = short_name_gen {
gen.add_existing(e.raw_short_name());
}
}
Err(io::Error::new(ErrorKind::NotFound, "No such file or directory"))
}
pub(crate) fn find_volume_entry(&self) -> io::Result<Option<DirEntry<'fs, IO, TP, OCC>>> {
for r in DirIter::new(&self.stream, self.fs, false) {
let e = r?;
if e.data.is_volume() {
return Ok(Some(e));
}
}
Ok(None)
}
fn check_for_existence(
&self,
name: &str,
is_dir: Option<bool>,
) -> io::Result<DirEntryOrShortName<'fs, IO, TP, OCC>> {
let mut short_name_gen = ShortNameGenerator::new(name);
loop {
let r = self.find_entry(name, is_dir, Some(&mut short_name_gen));
match r {
Err(ref err) if err.kind() == ErrorKind::NotFound => {}
Err(err) => return Err(err),
Ok(e) => return Ok(DirEntryOrShortName::DirEntry(e)),
};
if let Ok(name) = short_name_gen.generate() {
return Ok(DirEntryOrShortName::ShortName(name));
}
short_name_gen.next_iteration();
}
}
pub fn set_created(&mut self, date_time: DateTime) {
match self.stream.borrow_mut().entry_mut() {
Some(e) => e.set_created(date_time),
None => {}
}
}
pub fn set_accessed(&mut self, date: Date) {
match self.stream.borrow_mut().entry_mut() {
Some(e) => e.set_accessed(date),
None => {}
}
}
pub fn set_modified(&mut self, date_time: DateTime) {
match self.stream.borrow_mut().entry_mut() {
Some(e) => e.set_modified(date_time),
None => {}
}
}
pub fn accessed(&self) -> Date {
match self.stream.borrow().entry() {
Some(ref e) => e.inner().accessed(),
None => Date::epoch(),
}
}
pub fn created(&self) -> DateTime {
match self.stream.borrow().entry() {
Some(ref e) => e.inner().created(),
None => DateTime::epoch(),
}
}
pub fn modified(&self) -> DateTime {
match self.stream.borrow().entry() {
Some(ref e) => e.inner().modified(),
None => DateTime::epoch(),
}
}
pub fn open_dir(&self, path: &str) -> io::Result<Self> {
trace!("open_dir {}", path);
let (name, rest_opt) = split_path(path)?;
let e = self.find_entry(name, Some(true), None)?;
match rest_opt {
Some(rest) => e.to_dir().open_dir(rest),
None => Ok(e.to_dir()),
}
}
pub fn open_file(&self, path: &str) -> io::Result<File<'fs, IO, TP, OCC>> {
trace!("open_file {}", path);
let (name, rest_opt) = split_path(path)?;
if let Some(rest) = rest_opt {
let e = self.find_entry(name, Some(true), None)?;
return e.to_dir().open_file(rest);
}
let e = self.find_entry(name, Some(false), None)?;
Ok(e.to_file())
}
pub fn create_file(&self, path: &str) -> io::Result<File<'fs, IO, TP, OCC>> {
trace!("create_file {}", path);
let (name, rest_opt) = split_path(path)?;
if let Some(rest) = rest_opt {
return self.find_entry(name, Some(true), None)?.to_dir().create_file(rest);
}
if self.stream.borrow().is_deleted() {
return Err(io::Error::new(ErrorKind::NotFound, "Directory has been deleted"));
}
let r = self.check_for_existence(name, Some(false))?;
match r {
DirEntryOrShortName::ShortName(short_name) => {
let sfn_entry =
self.create_sfn_entry(short_name, FileAttributes::from_bits_truncate(0), None);
Ok(self.write_entry(name, sfn_entry)?.to_file())
}
DirEntryOrShortName::DirEntry(e) => Ok(e.to_file()),
}
}
pub fn create_dir(&self, path: &str) -> io::Result<Self> {
trace!("create_dir {}", path);
let (name, rest_opt) = split_path(path)?;
if let Some(rest) = rest_opt {
return self.find_entry(name, Some(true), None)?.to_dir().create_dir(rest);
}
if self.stream.borrow().is_deleted() {
return Err(io::Error::new(ErrorKind::NotFound, "Directory has been deleted"));
}
let r = self.check_for_existence(name, Some(true))?;
match r {
DirEntryOrShortName::ShortName(short_name) => {
let transaction = self.fs.begin_transaction().unwrap();
let cluster = self.fs.alloc_cluster(None, true)?;
let sfn_entry =
self.create_sfn_entry(short_name, FileAttributes::DIRECTORY, Some(cluster));
let entry = self.write_entry(name, sfn_entry)?;
let dir = entry.to_dir();
let dot_sfn = ShortNameGenerator::generate_dot();
let sfn_entry = self.create_sfn_entry(
dot_sfn,
FileAttributes::DIRECTORY,
entry.first_cluster(),
);
dir.write_entry(".", sfn_entry)?;
let dotdot_sfn = ShortNameGenerator::generate_dotdot();
let sfn_entry = self.create_sfn_entry(
dotdot_sfn,
FileAttributes::DIRECTORY,
self.cluster_for_child_dotdot_entry(),
);
dir.write_entry("..", sfn_entry)?;
self.fs.commit(transaction)?;
Ok(dir)
}
DirEntryOrShortName::DirEntry(e) => Ok(e.to_dir()),
}
}
pub fn is_empty(&self) -> io::Result<bool> {
trace!("is_empty");
for r in self.iter() {
let e = r?;
let name = e.short_file_name_as_bytes();
if name != b"." && name != b".." {
return Ok(false);
}
}
Ok(true)
}
pub fn remove(&self, path: &str) -> io::Result<()> {
trace!("remove {}", path);
let (name, rest_opt) = split_path(path)?;
if let Some(rest) = rest_opt {
let e = self.find_entry(name, Some(true), None)?;
return e.to_dir().remove(rest);
}
let e = self.find_entry(name, None, None)?;
if e.is_dir() && !e.to_dir().is_empty()? {
return Err(io::Error::new(ErrorKind::Other, FatfsError::DirectoryNotEmpty));
}
if let Some(n) = e.first_cluster() {
self.fs.free_cluster_chain(n)?;
}
let mut stream = self.stream.borrow_mut();
stream.seek(SeekFrom::Start(e.offset_range.0 as u64))?;
let num = (e.offset_range.1 - e.offset_range.0) as usize / DIR_ENTRY_SIZE as usize;
for _ in 0..num {
let mut data = DirEntryData::deserialize(&mut *stream)?;
trace!("removing dir entry {:?}", data);
data.set_deleted();
stream.seek(SeekFrom::Current(-(DIR_ENTRY_SIZE as i64)))?;
data.serialize(&mut *stream)?;
}
Ok(())
}
fn unlink_file_on_disk(&self, offset_range: (u64, u64)) -> io::Result<()> {
let mut stream = self.stream.borrow_mut();
stream.seek(io::SeekFrom::Start(offset_range.0))?;
let num = (offset_range.1 - offset_range.0) as usize / DIR_ENTRY_SIZE as usize;
for _ in 0..num {
let mut data = DirEntryData::deserialize(&mut *stream)?;
trace!("removing dir entry {:?}", data);
data.set_deleted();
stream.seek(SeekFrom::Current(-(DIR_ENTRY_SIZE as i64)))?;
data.serialize(&mut *stream)?;
}
Ok(())
}
pub fn unlink_file(&self, file: &mut File<IO, TP, OCC>) -> io::Result<()> {
let entry = file
.editor()
.ok_or(io::Error::new(ErrorKind::InvalidInput, "Can't delete file with no dirent"))?;
self.unlink_file_on_disk(entry.offset_range)?;
file.mark_deleted();
Ok(())
}
pub fn unlink_dir(&self, dir: &mut Dir<IO, TP, OCC>) -> io::Result<()> {
if !dir.is_empty()? {
return Err(io::Error::new(ErrorKind::Other, FatfsError::DirectoryNotEmpty));
}
match &mut *dir.stream.borrow_mut() {
DirRawStream::File(ref mut option) => {
if let Some(mut file) = option.take() {
self.unlink_file(&mut file)?;
file.purge()
} else {
return Err(io::Error::new(ErrorKind::NotFound, "Not found"));
}
}
DirRawStream::Root(_) => Err(io::Error::new(
ErrorKind::InvalidInput,
"Root directory is not child of any directory",
)),
}
}
pub fn rename(
&self,
src_path: &str,
dst_dir: &Dir<IO, TP, OCC>,
dst_path: &str,
) -> io::Result<()> {
trace!("rename {} {}", src_path, dst_path);
let (name, rest_opt) = split_path(src_path)?;
if let Some(rest) = rest_opt {
let e = self.find_entry(name, Some(true), None)?;
return e.to_dir().rename(rest, dst_dir, dst_path);
}
let (name, rest_opt) = split_path(dst_path)?;
if let Some(rest) = rest_opt {
let e = dst_dir.find_entry(name, Some(true), None)?;
return self.rename(src_path, &e.to_dir(), rest);
}
self.rename_internal(src_path, dst_dir, dst_path)
}
pub fn rename_over_file(
&self,
src_path: &str,
dst_dir: &Dir<IO, TP, OCC>,
dst_path: &str,
file: &mut File<IO, TP, OCC>,
) -> io::Result<()> {
let transaction = self.fs.begin_transaction().unwrap();
let entry = file
.editor()
.ok_or(io::Error::new(ErrorKind::InvalidInput, "Can't delete file with no dirent"))?;
dst_dir.unlink_file_on_disk(entry.offset_range)?;
self.rename(src_path, dst_dir, dst_path)?;
self.fs.commit(transaction)?;
file.mark_deleted();
Ok(())
}
pub fn rename_over_dir(
&self,
src_path: &str,
dst_dir: &Dir<IO, TP, OCC>,
dst_path: &str,
dir: &mut Dir<IO, TP, OCC>,
) -> io::Result<()> {
let transaction = self.fs.begin_transaction().unwrap();
if !dir.is_empty()? {
return Err(io::Error::new(ErrorKind::Other, FatfsError::DirectoryNotEmpty));
}
let file;
let mut stream = dir.stream.borrow_mut();
match &mut *stream {
DirRawStream::File(ref mut option) => {
file = option.as_mut().ok_or(io::Error::new(ErrorKind::NotFound, "Not found"))?;
let entry = file.editor().ok_or(io::Error::new(
ErrorKind::InvalidInput,
"Can't delete file with no dirent",
))?;
dst_dir.unlink_file_on_disk(entry.offset_range)?;
if let Some(cluster) = file.first_cluster() {
self.fs.free_cluster_chain(cluster)?;
}
}
DirRawStream::Root(_) => {
return Err(io::Error::new(
ErrorKind::InvalidInput,
"Root directory is not child of any directory",
))
}
};
self.rename(src_path, dst_dir, dst_path)?;
self.fs.commit(transaction)?;
file.mark_deleted_and_purged();
Ok(())
}
fn rename_internal(
&self,
src_name: &str,
dst_dir: &Dir<IO, TP, OCC>,
dst_name: &str,
) -> io::Result<()> {
trace!("rename_internal {} {}", src_name, dst_name);
if dst_dir.stream.borrow().is_deleted() {
return Err(io::Error::new(
ErrorKind::NotFound,
"Destination directory has been deleted",
));
}
let e = self.find_entry(src_name, None, None)?;
let r = dst_dir.check_for_existence(dst_name, None)?;
let short_name = match r {
DirEntryOrShortName::DirEntry(ref dst_e) => {
if !e.is_same_entry(dst_e) {
return Err(io::Error::new(
ErrorKind::AlreadyExists,
"Destination file already exists",
));
}
if src_name == dst_name {
return Ok(());
}
dst_e.raw_short_name().clone()
}
DirEntryOrShortName::ShortName(short_name) => short_name,
};
{
let mut stream = self.stream.borrow_mut();
stream.seek(SeekFrom::Start(e.offset_range.0 as u64))?;
let num = (e.offset_range.1 - e.offset_range.0) as usize / DIR_ENTRY_SIZE as usize;
for _ in 0..num {
let mut data = DirEntryData::deserialize(&mut *stream)?;
trace!("removing LFN entry {:?}", data);
data.set_deleted();
stream.seek(SeekFrom::Current(-(DIR_ENTRY_SIZE as i64)))?;
data.serialize(&mut *stream)?;
}
}
let sfn_entry = e.data.renamed(short_name);
let dir_entry = dst_dir.write_entry(dst_name, sfn_entry)?;
if dir_entry.is_dir()
&& self.cluster_for_child_dotdot_entry() != dst_dir.cluster_for_child_dotdot_entry()
{
let dir = dir_entry.to_dir();
let mut iter = dir.iter();
let error = || io::Error::new(ErrorKind::Other, "Missing expected .. entry");
let _ = iter.next().ok_or_else(error)??;
let entry = iter.next().ok_or_else(error)??;
if entry.short_file_name_as_bytes() != b".." {
return Err(error());
}
let mut editor = entry.editor();
editor.set_first_cluster(dst_dir.cluster_for_child_dotdot_entry(), self.fs.fat_type());
editor.flush(self.fs)?;
}
Ok(())
}
fn find_free_entries(
&self,
num_entries: usize,
) -> io::Result<RefMut<'_, DirRawStream<'fs, IO, TP, OCC>>> {
let mut stream = self.stream.borrow_mut();
stream.seek(io::SeekFrom::Start(0))?;
let mut first_free = 0;
let mut num_free = 0;
let mut i = 0;
loop {
let raw_entry = DirEntryData::deserialize(&mut *stream)?;
if raw_entry.is_end() {
if num_free == 0 {
first_free = i;
}
stream.seek(io::SeekFrom::Start(first_free as u64 * DIR_ENTRY_SIZE))?;
return Ok(stream);
} else if raw_entry.is_deleted() {
if num_free == 0 {
first_free = i;
}
num_free += 1;
if num_free == num_entries {
stream.seek(io::SeekFrom::Start(first_free as u64 * DIR_ENTRY_SIZE))?;
return Ok(stream);
}
} else {
num_free = 0;
}
i += 1;
}
}
fn create_sfn_entry(
&self,
short_name: [u8; SFN_SIZE],
attrs: FileAttributes,
first_cluster: Option<u32>,
) -> DirFileEntryData {
let mut raw_entry = DirFileEntryData::new(short_name, attrs);
raw_entry.set_first_cluster(first_cluster, self.fs.fat_type());
let now = self.fs.options.time_provider.get_current_date_time();
raw_entry.set_created(now);
raw_entry.set_accessed(now.date);
raw_entry.set_modified(now);
raw_entry
}
#[cfg(feature = "lfn")]
fn encode_lfn_utf16(name: &str) -> LfnBuffer {
LfnBuffer::from_ucs2_units(name.encode_utf16())
}
#[cfg(not(feature = "lfn"))]
fn encode_lfn_utf16(_name: &str) -> LfnBuffer {
LfnBuffer {}
}
fn alloc_and_write_lfn_entries(
&self,
lfn_utf16: &LfnBuffer,
short_name: &[u8; SFN_SIZE],
) -> io::Result<(RefMut<'_, DirRawStream<'fs, IO, TP, OCC>>, u64)> {
let lfn_chsum = lfn_checksum(short_name);
let lfn_iter = LfnEntriesGenerator::new(lfn_utf16.as_ucs2_units(), lfn_chsum);
let num_entries = lfn_iter.len() + 1;
let mut stream = self.find_free_entries(num_entries)?;
let start_pos = stream.seek(io::SeekFrom::Current(0))?;
for lfn_entry in lfn_iter {
lfn_entry.serialize(&mut *stream)?;
}
Ok((stream, start_pos))
}
fn write_entry(
&self,
name: &str,
raw_entry: DirFileEntryData,
) -> io::Result<DirEntry<'fs, IO, TP, OCC>> {
trace!("write_entry {}", name);
let long_name_required = validate_long_name(name, raw_entry.name())?;
let transaction = self.fs.begin_transaction();
let (mut stream, start_pos, lfn_utf16) = if long_name_required {
let lfn_utf16 = Self::encode_lfn_utf16(name);
let (stream, start_pos) =
self.alloc_and_write_lfn_entries(&lfn_utf16, raw_entry.name())?;
(stream, start_pos, lfn_utf16)
} else {
let mut stream = self.find_free_entries(1)?;
let start_pos = stream.seek(io::SeekFrom::Current(0))?;
(stream, start_pos, LfnBuffer::new())
};
raw_entry.serialize(&mut *stream)?;
if let Some(transaction) = transaction {
self.fs.commit(transaction)?;
}
let end_pos = stream.seek(io::SeekFrom::Current(0))?;
let abs_pos = stream.abs_pos()?.map(|p| p - DIR_ENTRY_SIZE);
let short_name = ShortName::new(raw_entry.name());
Ok(DirEntry {
data: raw_entry,
short_name,
#[cfg(feature = "lfn")]
lfn_utf16,
fs: self.fs,
entry_pos: abs_pos.unwrap(), offset_range: (start_pos, end_pos),
})
}
fn cluster_for_child_dotdot_entry(&self) -> Option<u32> {
if self.is_root {
None
} else {
self.stream.borrow().first_cluster()
}
}
pub fn flush_dir_entry(&mut self) -> std::io::Result<()> {
match &mut *self.stream.borrow_mut() {
DirRawStream::File(Some(file)) => file.flush_dir_entry(),
DirRawStream::File(None) => {
Err(io::Error::new(ErrorKind::NotFound, "Directory has been deleted"))
}
DirRawStream::Root(_) => {
Err(io::Error::new(ErrorKind::Other, "Cannot flush root directroy entry"))
}
}
}
}
pub struct DirIter<'a, 'fs, IO: ReadWriteSeek, TP, OCC> {
stream: &'a RefCell<DirRawStream<'fs, IO, TP, OCC>>,
fs: &'fs FileSystem<IO, TP, OCC>,
skip_volume: bool,
err: bool,
}
impl<'a, 'fs, IO: ReadWriteSeek, TP, OCC> DirIter<'a, 'fs, IO, TP, OCC> {
fn new(
stream: &'a RefCell<DirRawStream<'fs, IO, TP, OCC>>,
fs: &'fs FileSystem<IO, TP, OCC>,
skip_volume: bool,
) -> Self {
stream.borrow_mut().seek(SeekFrom::Start(0)).unwrap();
DirIter { stream, fs, skip_volume, err: false }
}
}
impl<'fs, IO: ReadWriteSeek, TP: TimeProvider, OCC> DirIter<'_, 'fs, IO, TP, OCC> {
fn should_skip_entry(&self, raw_entry: &DirEntryData) -> bool {
if raw_entry.is_deleted() {
return true;
}
match raw_entry {
DirEntryData::File(sfn_entry) => self.skip_volume && sfn_entry.is_volume(),
_ => false,
}
}
fn read_dir_entry(&mut self) -> io::Result<Option<DirEntry<'fs, IO, TP, OCC>>> {
trace!("read_dir_entry");
let mut lfn_builder = LongNameBuilder::new();
let mut stream = self.stream.borrow_mut();
let mut offset = stream.seek(SeekFrom::Current(0))?;
let mut begin_offset = offset;
loop {
let raw_entry = DirEntryData::deserialize(&mut *stream)?;
offset += DIR_ENTRY_SIZE;
if raw_entry.is_end() {
return Ok(None);
}
if self.should_skip_entry(&raw_entry) {
trace!("skip entry");
lfn_builder.clear();
begin_offset = offset;
continue;
}
match raw_entry {
DirEntryData::File(data) => {
let abs_pos = stream.abs_pos()?.map(|p| p - DIR_ENTRY_SIZE);
lfn_builder.validate_chksum(data.name());
let short_name = ShortName::new(data.name());
trace!("file entry {:?}", data.name());
return Ok(Some(DirEntry {
data,
short_name,
#[cfg(feature = "lfn")]
lfn_utf16: lfn_builder.into_buf(),
fs: self.fs,
entry_pos: abs_pos.unwrap(), offset_range: (begin_offset, offset),
}));
}
DirEntryData::Lfn(data) => {
trace!("lfn entry");
lfn_builder.process(&data);
}
}
}
}
}
impl<'b, IO: ReadWriteSeek, TP: TimeProvider, OCC> Iterator for DirIter<'_, 'b, IO, TP, OCC> {
type Item = io::Result<DirEntry<'b, IO, TP, OCC>>;
fn next(&mut self) -> Option<Self::Item> {
if self.err {
return None;
}
let r = self.read_dir_entry();
match r {
Ok(Some(e)) => Some(Ok(e)),
Ok(None) => None,
Err(err) => {
self.err = true;
Some(Err(err))
}
}
}
}
fn validate_long_name(name: &str, short_name: &[u8; SFN_SIZE]) -> io::Result<bool> {
if name.is_empty() {
return Err(io::Error::new(ErrorKind::Other, FatfsError::FileNameEmpty));
}
if name.len() > 255 {
return Err(io::Error::new(ErrorKind::Other, FatfsError::FileNameTooLong));
}
let mut long_name_required = name.len() > 12;
let mut short_name_index: usize = 0;
for c in name.chars() {
match c {
'A'..='Z' | '0'..='9' => {}
'$' | '%' | '\'' | '-' | '_' | '@' | '~' | '`' | '!' | '(' | ')' | '{' | '}' | '^'
| '#' | '&' | '.' => {}
'a'..='z' | '\u{80}'..='\u{10FFFF}' | ' ' | '+' | ',' | ';' | '=' | '[' | ']' => {
long_name_required = true
}
_ => return Err(io::Error::new(ErrorKind::Other, FatfsError::FileNameBadCharacter)),
}
if !long_name_required {
long_name_required = match short_name_index {
0..=7 => {
if c as u8 == short_name[short_name_index] {
short_name_index += 1;
false
} else if c == '.' {
short_name_index = 9;
false
} else {
true
}
}
8 => {
short_name_index = 9;
c != '.'
}
9..=11 => {
short_name_index += 1;
c as u8 != short_name[short_name_index - 2]
}
_ => true,
};
}
}
Ok(long_name_required)
}
fn lfn_checksum(short_name: &[u8; SFN_SIZE]) -> u8 {
let mut chksum = num::Wrapping(0u8);
for b in short_name {
chksum = (chksum << 7) + (chksum >> 1) + num::Wrapping(*b);
}
chksum.0
}
#[cfg(all(feature = "lfn", feature = "alloc"))]
#[derive(Clone)]
pub(crate) struct LfnBuffer {
ucs2_units: Vec<u16>,
}
#[cfg(not(feature = "alloc"))]
const MAX_LFN_LEN: usize = 256;
#[cfg(all(feature = "lfn", not(feature = "alloc")))]
#[derive(Clone)]
pub(crate) struct LfnBuffer {
ucs2_units: [u16; MAX_LFN_LEN],
len: usize,
}
#[cfg(all(feature = "lfn", feature = "alloc"))]
impl LfnBuffer {
fn new() -> Self {
LfnBuffer { ucs2_units: Vec::<u16>::new() }
}
fn from_ucs2_units<I>(usc2_units: I) -> Self
where
I: Iterator<Item = u16>,
{
LfnBuffer { ucs2_units: usc2_units.collect() }
}
fn clear(&mut self) {
self.ucs2_units.clear();
}
pub(crate) fn len(&self) -> usize {
self.ucs2_units.len()
}
fn set_len(&mut self, len: usize) {
self.ucs2_units.resize(len, 0u16);
}
pub(crate) fn as_ucs2_units(&self) -> &[u16] {
&self.ucs2_units
}
}
#[cfg(all(feature = "lfn", not(feature = "alloc")))]
impl LfnBuffer {
fn new() -> Self {
LfnBuffer { ucs2_units: [0u16; MAX_LFN_LEN], len: 0 }
}
fn from_ucs2_units<I>(usc2_units: I) -> Self
where
I: Iterator<Item = u16>,
{
let mut lfn = LfnBuffer { ucs2_units: [0u16; MAX_LFN_LEN], len: 0 };
for (i, usc2_unit) in usc2_units.enumerate() {
lfn.ucs2_units[i] = usc2_unit;
}
lfn
}
fn clear(&mut self) {
self.ucs2_units = [0u16; MAX_LFN_LEN];
self.len = 0;
}
pub(crate) fn len(&self) -> usize {
self.len
}
fn set_len(&mut self, len: usize) {
self.len = len;
}
pub(crate) fn as_ucs2_units(&self) -> &[u16] {
&self.ucs2_units
}
}
#[cfg(not(feature = "lfn"))]
#[derive(Clone)]
pub(crate) struct LfnBuffer {}
#[cfg(not(feature = "lfn"))]
impl LfnBuffer {
fn new() -> Self {
LfnBuffer {}
}
pub(crate) fn as_ucs2_units(&self) -> &[u16] {
&[]
}
}
#[cfg(feature = "lfn")]
struct LongNameBuilder {
buf: LfnBuffer,
chksum: u8,
index: u8,
}
#[cfg(feature = "lfn")]
impl LongNameBuilder {
fn new() -> Self {
LongNameBuilder { buf: LfnBuffer::new(), chksum: 0, index: 0 }
}
fn clear(&mut self) {
self.buf.clear();
self.index = 0;
}
fn into_buf(mut self) -> LfnBuffer {
if self.index == 1 {
self.truncate();
} else if !self.is_empty() {
warn!("unfinished LFN sequence {}", self.index);
self.clear();
}
self.buf
}
fn truncate(&mut self) {
let mut lfn_len = self.buf.len();
while lfn_len > 0 {
match self.buf.ucs2_units[lfn_len - 1] {
0xFFFF | 0 => lfn_len -= 1,
_ => break,
}
}
self.buf.set_len(lfn_len);
}
fn is_empty(&self) -> bool {
self.index == 0
}
fn process(&mut self, data: &DirLfnEntryData) {
let is_last = (data.order() & LFN_ENTRY_LAST_FLAG) != 0;
let index = data.order() & 0x1F;
if index == 0 {
warn!("corrupted lfn entry! {:x}", data.order());
self.clear();
return;
}
if is_last {
self.index = index;
self.chksum = data.checksum();
self.buf.set_len(index as usize * LFN_PART_LEN);
} else if self.index == 0 || index != self.index - 1 || data.checksum() != self.chksum {
warn!(
"corrupted lfn entry! {:x} {:x} {:x} {:x}",
data.order(),
self.index,
data.checksum(),
self.chksum
);
self.clear();
return;
} else {
self.index -= 1;
}
let pos = LFN_PART_LEN * (index - 1) as usize;
data.copy_name_to_slice(&mut self.buf.ucs2_units[pos..pos + 13]);
}
fn validate_chksum(&mut self, short_name: &[u8; SFN_SIZE]) {
if self.is_empty() {
return;
}
let chksum = lfn_checksum(short_name);
if chksum != self.chksum {
warn!("checksum mismatch {:x} {:x} {:?}", chksum, self.chksum, short_name);
self.clear();
}
}
}
#[cfg(not(feature = "lfn"))]
struct LongNameBuilder {}
#[cfg(not(feature = "lfn"))]
impl LongNameBuilder {
fn new() -> Self {
LongNameBuilder {}
}
fn clear(&mut self) {}
fn into_vec(self) {}
fn truncate(&mut self) {}
fn process(&mut self, _data: &DirLfnEntryData) {}
fn validate_chksum(&mut self, _short_name: &[u8; SFN_SIZE]) {}
}
#[cfg(feature = "lfn")]
struct LfnEntriesGenerator<'a> {
name_parts_iter: iter::Rev<slice::Chunks<'a, u16>>,
checksum: u8,
index: usize,
num: usize,
ended: bool,
}
#[cfg(feature = "lfn")]
impl<'a> LfnEntriesGenerator<'a> {
fn new(name_utf16: &'a [u16], checksum: u8) -> Self {
let num_entries = (name_utf16.len() + LFN_PART_LEN - 1) / LFN_PART_LEN;
LfnEntriesGenerator {
checksum,
name_parts_iter: name_utf16.chunks(LFN_PART_LEN).rev(),
index: 0,
num: num_entries,
ended: false,
}
}
}
#[cfg(feature = "lfn")]
impl Iterator for LfnEntriesGenerator<'_> {
type Item = DirLfnEntryData;
fn next(&mut self) -> Option<Self::Item> {
if self.ended {
return None;
}
match self.name_parts_iter.next() {
Some(ref name_part) => {
let lfn_index = self.num - self.index;
let mut order = lfn_index as u8;
if self.index == 0 {
order |= LFN_ENTRY_LAST_FLAG;
}
debug_assert!(order > 0);
const LFN_PADDING: u16 = 0xFFFF;
let mut lfn_part = [LFN_PADDING; LFN_PART_LEN];
lfn_part[..name_part.len()].copy_from_slice(&name_part);
if name_part.len() < LFN_PART_LEN {
lfn_part[name_part.len()] = 0;
}
let mut lfn_entry = DirLfnEntryData::new(order, self.checksum);
lfn_entry.copy_name_from_slice(&lfn_part);
self.index += 1;
Some(lfn_entry)
}
None => {
self.ended = true;
None
}
}
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.name_parts_iter.size_hint()
}
}
#[cfg(feature = "lfn")]
impl ExactSizeIterator for LfnEntriesGenerator<'_> {}
#[cfg(not(feature = "lfn"))]
struct LfnEntriesGenerator {}
#[cfg(not(feature = "lfn"))]
impl LfnEntriesGenerator {
fn new(_name_utf16: &[u16], _checksum: u8) -> Self {
LfnEntriesGenerator {}
}
}
#[cfg(not(feature = "lfn"))]
impl Iterator for LfnEntriesGenerator {
type Item = DirLfnEntryData;
fn next(&mut self) -> Option<Self::Item> {
None
}
fn size_hint(&self) -> (usize, Option<usize>) {
(0, Some(0))
}
}
#[cfg(not(feature = "lfn"))]
impl ExactSizeIterator for LfnEntriesGenerator {}
#[derive(Default, Debug, Clone)]
struct ShortNameGenerator {
chksum: u16,
long_prefix_bitmap: u16,
prefix_chksum_bitmap: u16,
name_fits: bool,
lossy_conv: bool,
exact_match: bool,
basename_len: u8,
short_name: [u8; SFN_SIZE],
}
impl ShortNameGenerator {
fn new(name: &str) -> Self {
let mut short_name = [SFN_PADDING; SFN_SIZE];
let (basename_len, name_fits, lossy_conv) = match name.rfind('.') {
Some(0) | None => {
let (basename_len, basename_fits, basename_lossy) =
Self::copy_short_name_part(&mut short_name[0..8], &name);
(basename_len, basename_fits, basename_lossy)
}
Some(dot_index) => {
let (basename_len, basename_fits, basename_lossy) =
Self::copy_short_name_part(&mut short_name[0..8], &name[..dot_index]);
let (_, ext_fits, ext_lossy) =
Self::copy_short_name_part(&mut short_name[8..11], &name[dot_index + 1..]);
(basename_len, basename_fits && ext_fits, basename_lossy || ext_lossy)
}
};
let chksum = Self::checksum(&name);
Self {
short_name,
chksum,
name_fits,
lossy_conv,
basename_len: basename_len as u8,
..Default::default()
}
}
fn generate_dot() -> [u8; SFN_SIZE] {
let mut short_name = [SFN_PADDING; SFN_SIZE];
short_name[0] = b'.';
short_name
}
fn generate_dotdot() -> [u8; SFN_SIZE] {
let mut short_name = [SFN_PADDING; SFN_SIZE];
short_name[0] = b'.';
short_name[1] = b'.';
short_name
}
fn copy_short_name_part(dst: &mut [u8], src: &str) -> (usize, bool, bool) {
let mut dst_pos = 0;
let mut lossy_conv = false;
for c in src.chars() {
if dst_pos == dst.len() {
return (dst_pos, false, lossy_conv);
}
let fixed_c = match c {
' ' | '.' => {
lossy_conv = true;
continue;
}
'A'..='Z' | 'a'..='z' | '0'..='9' => c,
'!' | '#' | '$' | '%' | '&' | '\'' | '(' | ')' | '-' | '@' | '^' | '_' | '`'
| '{' | '}' | '~' => c,
_ => '_',
};
lossy_conv = lossy_conv || (fixed_c != c);
let upper = fixed_c.to_ascii_uppercase();
dst[dst_pos] = upper as u8; dst_pos += 1;
}
(dst_pos, true, lossy_conv)
}
fn add_existing(&mut self, short_name: &[u8; SFN_SIZE]) {
if short_name == &self.short_name {
self.exact_match = true;
}
let long_prefix_len = cmp::min(self.basename_len, 6) as usize;
let num_suffix = if short_name[long_prefix_len] == b'~' {
(short_name[long_prefix_len + 1] as char).to_digit(10)
} else {
None
};
let long_prefix_matches =
short_name[..long_prefix_len] == self.short_name[..long_prefix_len];
let ext_matches = short_name[8..] == self.short_name[8..];
if long_prefix_matches && num_suffix.is_some() && ext_matches {
let num = num_suffix.unwrap(); self.long_prefix_bitmap |= 1 << num;
}
let short_prefix_len = cmp::min(self.basename_len, 2) as usize;
let num_suffix = if short_name[short_prefix_len + 4] == b'~' {
(short_name[short_prefix_len + 4 + 1] as char).to_digit(10)
} else {
None
};
let short_prefix_matches =
short_name[..short_prefix_len] == self.short_name[..short_prefix_len];
if short_prefix_matches && num_suffix.is_some() && ext_matches {
let chksum_res = str::from_utf8(&short_name[short_prefix_len..short_prefix_len + 4])
.map(|s| u16::from_str_radix(s, 16));
if chksum_res == Ok(Ok(self.chksum)) {
let num = num_suffix.unwrap(); self.prefix_chksum_bitmap |= 1 << num;
}
}
}
fn checksum(name: &str) -> u16 {
let mut chksum = num::Wrapping(0u16);
for c in name.chars() {
chksum = (chksum >> 1) + (chksum << 15) + num::Wrapping(c as u16);
}
chksum.0
}
fn generate(&self) -> io::Result<[u8; SFN_SIZE]> {
if !self.lossy_conv && self.name_fits && !self.exact_match {
return Ok(self.short_name);
}
for i in 1..5 {
if self.long_prefix_bitmap & (1 << i) == 0 {
return Ok(self.build_prefixed_name(i, false));
}
}
for i in 1..10 {
if self.prefix_chksum_bitmap & (1 << i) == 0 {
return Ok(self.build_prefixed_name(i, true));
}
}
Err(io::Error::new(ErrorKind::AlreadyExists, "short name already exists"))
}
fn next_iteration(&mut self) {
self.chksum = (num::Wrapping(self.chksum) + num::Wrapping(1)).0;
self.long_prefix_bitmap = 0;
self.prefix_chksum_bitmap = 0;
}
fn build_prefixed_name(&self, num: u32, with_chksum: bool) -> [u8; SFN_SIZE] {
let mut buf = [SFN_PADDING; SFN_SIZE];
let prefix_len = if with_chksum {
let prefix_len = cmp::min(self.basename_len as usize, 2);
buf[..prefix_len].copy_from_slice(&self.short_name[..prefix_len]);
buf[prefix_len..prefix_len + 4].copy_from_slice(&Self::u16_to_u8_array(self.chksum));
prefix_len + 4
} else {
let prefix_len = cmp::min(self.basename_len as usize, 6);
buf[..prefix_len].copy_from_slice(&self.short_name[..prefix_len]);
prefix_len
};
buf[prefix_len] = b'~';
buf[prefix_len + 1] = char::from_digit(num, 10).unwrap() as u8; buf[8..].copy_from_slice(&self.short_name[8..]);
buf
}
fn u16_to_u8_array(x: u16) -> [u8; 4] {
let c1 = char::from_digit((x as u32 >> 12) & 0xF, 16).unwrap().to_ascii_uppercase() as u8;
let c2 = char::from_digit((x as u32 >> 8) & 0xF, 16).unwrap().to_ascii_uppercase() as u8;
let c3 = char::from_digit((x as u32 >> 4) & 0xF, 16).unwrap().to_ascii_uppercase() as u8;
let c4 = char::from_digit((x as u32 >> 0) & 0xF, 16).unwrap().to_ascii_uppercase() as u8;
[c1, c2, c3, c4]
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_split_path() {
assert_eq!(split_path("aaa/bbb/ccc"), Ok(("aaa", Some("bbb/ccc"))));
assert_eq!(split_path("aaa/bbb"), Ok(("aaa", Some("bbb"))));
assert_eq!(split_path("aaa"), Ok(("aaa", None)));
}
#[test]
fn test_generate_short_name() {
assert_eq!(&ShortNameGenerator::new("Foo").generate().unwrap(), b"FOO ");
assert_eq!(&ShortNameGenerator::new("Foo.b").generate().unwrap(), b"FOO B ");
assert_eq!(&ShortNameGenerator::new("Foo.baR").generate().unwrap(), b"FOO BAR");
assert_eq!(&ShortNameGenerator::new("Foo+1.baR").generate().unwrap(), b"FOO_1~1 BAR");
assert_eq!(&ShortNameGenerator::new("ver +1.2.text").generate().unwrap(), b"VER_12~1TEX");
assert_eq!(&ShortNameGenerator::new(".bashrc.swp").generate().unwrap(), b"BASHRC~1SWP");
assert_eq!(&ShortNameGenerator::new(".foo").generate().unwrap(), b"FOO~1 ");
}
#[test]
fn test_short_name_checksum_overflow() {
ShortNameGenerator::checksum("\u{FF5A}\u{FF5A}\u{FF5A}\u{FF5A}");
}
#[test]
fn test_lfn_checksum_overflow() {
lfn_checksum(&[
0xFFu8, 0xFFu8, 0xFFu8, 0xFFu8, 0xFFu8, 0xFFu8, 0xFFu8, 0xFFu8, 0xFFu8, 0xFFu8, 0xFFu8,
]);
}
#[test]
fn test_generate_short_name_collisions_long() {
let mut buf: [u8; SFN_SIZE];
let mut gen = ShortNameGenerator::new("TextFile.Mine.txt");
buf = gen.generate().unwrap();
assert_eq!(&buf, b"TEXTFI~1TXT");
gen.add_existing(&buf);
buf = gen.generate().unwrap();
assert_eq!(&buf, b"TEXTFI~2TXT");
gen.add_existing(&buf);
buf = gen.generate().unwrap();
assert_eq!(&buf, b"TEXTFI~3TXT");
gen.add_existing(&buf);
buf = gen.generate().unwrap();
assert_eq!(&buf, b"TEXTFI~4TXT");
gen.add_existing(&buf);
buf = gen.generate().unwrap();
assert_eq!(&buf, b"TE527D~1TXT");
gen.add_existing(&buf);
buf = gen.generate().unwrap();
assert_eq!(&buf, b"TE527D~2TXT");
for i in 3..10 {
gen.add_existing(&buf);
buf = gen.generate().unwrap();
assert_eq!(&buf, format!("TE527D~{}TXT", i).as_bytes());
}
gen.add_existing(&buf);
assert!(gen.generate().is_err());
gen.next_iteration();
for _i in 0..4 {
buf = gen.generate().unwrap();
gen.add_existing(&buf);
}
buf = gen.generate().unwrap();
assert_eq!(&buf, b"TE527E~1TXT");
}
#[test]
fn test_generate_short_name_collisions_short() {
let mut buf: [u8; SFN_SIZE];
let mut gen = ShortNameGenerator::new("x.txt");
buf = gen.generate().unwrap();
assert_eq!(&buf, b"X TXT");
gen.add_existing(&buf);
buf = gen.generate().unwrap();
assert_eq!(&buf, b"X~1 TXT");
gen.add_existing(&buf);
buf = gen.generate().unwrap();
assert_eq!(&buf, b"X~2 TXT");
gen.add_existing(&buf);
buf = gen.generate().unwrap();
assert_eq!(&buf, b"X~3 TXT");
gen.add_existing(&buf);
buf = gen.generate().unwrap();
assert_eq!(&buf, b"X~4 TXT");
gen.add_existing(&buf);
buf = gen.generate().unwrap();
assert_eq!(&buf, b"X40DA~1 TXT");
gen.add_existing(&buf);
buf = gen.generate().unwrap();
assert_eq!(&buf, b"X40DA~2 TXT");
}
#[test]
fn test_long_name_requires_long_name() {
assert_eq!(
validate_long_name("01234567.1234", b"01234567123").expect("should be valid"),
true
);
}
#[test]
fn test_dot_and_dotdot_does_not_require_long_name() {
assert_eq!(validate_long_name(".", b". ").expect("should be valid"), false);
assert_eq!(validate_long_name("..", b".. ").expect("should be valid"), false);
}
#[test]
fn test_lowercase_and_special_requires_long_name() {
assert_eq!(validate_long_name("abc", b"abc ").expect("should be valid"), true);
assert_eq!(validate_long_name(",", b", ").expect("should be valid"), true);
assert_eq!(
validate_long_name("FOO\u{100}", b"FOO ").expect("should be valid"),
true
);
}
#[test]
fn test_name_with_extension_does_not_require_long_name() {
assert_eq!(validate_long_name("NAME.EXT", b"NAME EXT").expect("should be valid"), false);
}
#[test]
fn test_name_with_long_extension_does_require_long_name() {
assert_eq!(validate_long_name("NAME.EXT1", b"NAME EXT").expect("should be valid"), true);
}
}