Tools for relative path handling.

* Converting "" to a ShortFileName, gives you ShortFileName::this_dir() or ".<10 spaces>", which is the special entry at the top of every directory.
* You can open the same directory multiple times. This is required if you want to walk a path, but also hold open a directory in that path.
* Lets you open "." and get a duplicate handle to a directory
* Lets you mutate a Directory object to point at a child, without having to make a new Directory object and drop the old one.

Author: thejpster

src/filesystem/directory.rs

@@ -121,6 +121,19 @@ where
         Ok(d.to_directory(self.volume_mgr))
     }
 
+    /// Change to a directory, mutating this object.
+    ///
+    /// You can then read the directory entries with `iterate_dir` and `open_file_in_dir`.
+    pub fn change_dir<N>(&mut self, name: N) -> Result<(), Error<D::Error>>
+    where
+        N: ToShortFileName,
+    {
+        let d = self.volume_mgr.open_dir(self.raw_directory, name)?;
+        self.volume_mgr.close_dir(self.raw_directory).unwrap();
+        self.raw_directory = d;
+        Ok(())
+    }
+
     /// Look in a directory for a named file.
     pub fn find_directory_entry<N>(&mut self, name: N) -> Result<DirEntry, Error<D::Error>>
     where
@@ -161,6 +174,14 @@ where
         self.volume_mgr.delete_file_in_dir(self.raw_directory, name)
     }
 
+    /// Make a directory inside this directory
+    pub fn make_dir_in_dir<N>(&mut self, name: N) -> Result<(), Error<D::Error>>
+    where
+        N: ToShortFileName,
+    {
+        self.volume_mgr.make_dir_in_dir(self.raw_directory, name)
+    }
+
     /// Convert back to a raw directory
     pub fn to_raw_directory(self) -> RawDirectory {
         let d = self.raw_directory;

src/filesystem/filename.rs

@@ -91,6 +91,11 @@ impl ShortFileName {
             return Ok(ShortFileName::parent_dir());
         }
 
+        // Special case `.` (or blank), which means "this directory".
+        if name.is_empty() || name == "." {
+            return Ok(ShortFileName::this_dir());
+        }
+
         let mut idx = 0;
         let mut seen_dot = false;
         for ch in name.bytes() {
@@ -318,9 +323,16 @@ mod test {
         assert_eq!(sfn, ShortFileName::create_from_str("1.C").unwrap());
     }
 
+    #[test]
+    fn filename_empty() {
+        assert_eq!(
+            ShortFileName::create_from_str("").unwrap(),
+            ShortFileName::this_dir()
+        );
+    }
+
     #[test]
     fn filename_bad() {
-        assert!(ShortFileName::create_from_str("").is_err());
         assert!(ShortFileName::create_from_str(" ").is_err());
         assert!(ShortFileName::create_from_str("123456789").is_err());
         assert!(ShortFileName::create_from_str("12345678.ABCD").is_err());

src/volume_mgr.rs

@@ -12,9 +12,9 @@ use crate::filesystem::{
     SearchIdGenerator, TimeSource, ToShortFileName, MAX_FILE_SIZE,
 };
 use crate::{
-    debug, Block, BlockCount, BlockDevice, BlockIdx, Error, RawVolume, Volume, VolumeIdx,
-    VolumeInfo, VolumeType, PARTITION_ID_FAT16, PARTITION_ID_FAT16_LBA, PARTITION_ID_FAT32_CHS_LBA,
-    PARTITION_ID_FAT32_LBA,
+    debug, Block, BlockCount, BlockDevice, BlockIdx, Error, RawVolume, ShortFileName, Volume,
+    VolumeIdx, VolumeInfo, VolumeType, PARTITION_ID_FAT16, PARTITION_ID_FAT16_LBA,
+    PARTITION_ID_FAT32_CHS_LBA, PARTITION_ID_FAT32_LBA,
 };
 use heapless::Vec;
 
@@ -206,11 +206,7 @@ where
     /// You can then read the directory entries with `iterate_dir`, or you can
     /// use `open_file_in_dir`.
     pub fn open_root_dir(&mut self, volume: RawVolume) -> Result<RawDirectory, Error<D::Error>> {
-        for dir in self.open_dirs.iter() {
-            if dir.cluster == ClusterId::ROOT_DIR && dir.volume_id == volume {
-                return Err(Error::DirAlreadyOpen);
-            }
-        }
+        // Opening a root directory twice is OK
 
         let directory_id = RawDirectory(self.id_generator.get());
         let dir_info = DirectoryInfo {
@@ -229,6 +225,8 @@ where
     /// Open a directory.
     ///
     /// You can then read the directory entries with `iterate_dir` and `open_file_in_dir`.
+    ///
+    /// Passing "." as the name results in opening the `parent_dir` a second time.
     pub fn open_dir<N>(
         &mut self,
         parent_dir: RawDirectory,
@@ -245,9 +243,25 @@ where
         let parent_dir_idx = self.get_dir_by_id(parent_dir)?;
         let volume_idx = self.get_volume_by_id(self.open_dirs[parent_dir_idx].volume_id)?;
         let short_file_name = name.to_short_filename().map_err(Error::FilenameError)?;
+        let parent_dir_info = &self.open_dirs[parent_dir_idx];
 
         // Open the directory
-        let parent_dir_info = &self.open_dirs[parent_dir_idx];
+        if short_file_name == ShortFileName::this_dir() {
+            // short-cut (root dir doesn't have ".")
+            let directory_id = RawDirectory(self.id_generator.get());
+            let dir_info = DirectoryInfo {
+                directory_id,
+                volume_id: self.open_volumes[volume_idx].volume_id,
+                cluster: parent_dir_info.cluster,
+            };
+
+            self.open_dirs
+                .push(dir_info)
+                .map_err(|_| Error::TooManyOpenDirs)?;
+
+            return Ok(directory_id);
+        }
+
         let dir_entry = match &self.open_volumes[volume_idx].volume_type {
             VolumeType::Fat(fat) => {
                 fat.find_directory_entry(&self.block_device, parent_dir_info, &short_file_name)?
@@ -260,14 +274,8 @@ where
             return Err(Error::OpenedFileAsDir);
         }
 
-        // Check it's not already open
-        for d in self.open_dirs.iter() {
-            if d.volume_id == self.open_volumes[volume_idx].volume_id
-                && d.cluster == dir_entry.cluster
-            {
-                return Err(Error::DirAlreadyOpen);
-            }
-        }
+        // We don't check if the directory is already open - directories hold
+        // no cached state and so opening a directory twice is allowable.
 
         // Remember this open directory.
         let directory_id = RawDirectory(self.id_generator.get());

tests/directories.rs

@@ -237,10 +237,9 @@ fn open_dir_twice() {
         .open_root_dir(fat32_volume)
         .expect("open root dir");
 
-    assert!(matches!(
-        volume_mgr.open_root_dir(fat32_volume),
-        Err(embedded_sdmmc::Error::DirAlreadyOpen)
-    ));
+    let root_dir2 = volume_mgr
+        .open_root_dir(fat32_volume)
+        .expect("open it again");
 
     assert!(matches!(
         volume_mgr.open_dir(root_dir, "README.TXT"),
@@ -251,13 +250,12 @@ fn open_dir_twice() {
         .open_dir(root_dir, "TEST")
         .expect("open test dir");
 
-    assert!(matches!(
-        volume_mgr.open_dir(root_dir, "TEST"),
-        Err(embedded_sdmmc::Error::DirAlreadyOpen)
-    ));
+    let test_dir2 = volume_mgr.open_dir(root_dir, "TEST").unwrap();
 
     volume_mgr.close_dir(root_dir).expect("close root dir");
     volume_mgr.close_dir(test_dir).expect("close test dir");
+    volume_mgr.close_dir(test_dir2).expect("close test dir");
+    volume_mgr.close_dir(root_dir2).expect("close test dir");
 
     assert!(matches!(
         volume_mgr.close_dir(test_dir),