fs/path: Added Path and PathBuf

Author: phip1611

uefi/src/data_types/strs.rs

@@ -175,7 +175,7 @@ impl<'a> TryFrom<&'a CStr> for &'a CStr8 {
     }
 }
 
-/// An UCS-2 null-terminated string.
+/// An UCS-2 null-terminated string slice.
 ///
 /// This type is largely inspired by [`core::ffi::CStr`] with the exception that all characters are
 /// guaranteed to be 16 bit long.
@@ -423,6 +423,12 @@ impl<StrType: AsRef<str> + ?Sized> EqStrUntilNul<StrType> for CStr16 {
     }
 }
 
+impl AsRef<CStr16> for CStr16 {
+    fn as_ref(&self) -> &CStr16 {
+        self
+    }
+}
+
 /// An iterator over the [`Char16`]s in a [`CStr16`].
 #[derive(Debug)]
 pub struct CStr16Iter<'a> {

uefi/src/fs/file_system.rs

@@ -1,6 +1,8 @@
 //! Module for [`FileSystem`].
 
 use super::*;
+use crate::fs;
+use crate::fs::path::validation::{validate_path, PathError};
 use crate::proto::media::file::{FileAttribute, FileInfo, FileType};
 use crate::table::boot::ScopedProtocol;
 use alloc::boxed::Box;
@@ -12,6 +14,7 @@ use core::fmt::{Debug, Formatter};
 use core::ops::Deref;
 use derive_more::Display;
 use log::info;
+use uefi::Char16;
 
 /// All errors that can happen when working with the [`FileSystem`].
 #[derive(Debug, Clone, Display, PartialEq, Eq)]
@@ -40,12 +43,26 @@ pub enum FileSystemError {
     ReadFailure,
     /// Can't parse file content as UTF-8.
     Utf8Error(FromUtf8Error),
-    /// Could not open the given path.
-    OpenError(String),
+    /// Could not open the given path. Carries the path that could not be opened
+    /// and the underlying UEFI error.
+    #[display(fmt = "{path:?}")]
+    OpenError {
+        path: String,
+        error: crate::Error<>
+    },
 }
 
 #[cfg(feature = "unstable")]
-impl core::error::Error for FileSystemError {}
+impl core::error::Error for FileSystemError {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        match self {
+            FileSystemError::IllegalPath(e) => Some(e),
+            FileSystemError::Utf8Error(e) => Some(e),
+            FileSystemError::OpenError(_path, e) => Some(e),
+            _ => None,
+        }
+    }
+}
 
 impl From<PathError> for FileSystemError {
     fn from(err: PathError) -> Self {
@@ -90,16 +107,13 @@ impl<'a> FileSystem<'a> {
         let path = path.as_ref();
         self.open(path, UefiFileMode::CreateReadWrite, true)
             .map(|_| ())
-            .map_err(|err| {
-                log::debug!("failed to fetch file info: {err:#?}");
-                FileSystemError::OpenError(path.to_string())
-            })
     }
 
     /// Recursively create a directory and all of its parent components if they
     /// are missing.
     pub fn create_dir_all(&mut self, path: impl AsRef<Path>) -> FileSystemResult<()> {
-        let path = path.as_ref();
+        todo!()
+        /*let path = path.as_ref();
 
         let normalized_path = NormalizedPath::new("\\", path)?;
         let normalized_path_string = normalized_path.to_string();
@@ -115,19 +129,21 @@ impl<'a> FileSystem<'a> {
                 info!("path_acc: {path_acc}, component: {component}");
                 Some((component, path_acc.clone()))
             })
-            .try_for_each(|(_component, full_path)| self.create_dir(full_path.as_str()))
+            .try_for_each(|(_component, full_path)| self.create_dir(full_path.to_cstr16()))*/
     }
 
     /// Given a path, query the file system to get information about a file,
     /// directory, etc. Returns [`UefiFileInfo`].
     pub fn metadata(&mut self, path: impl AsRef<Path>) -> FileSystemResult<Box<UefiFileInfo>> {
         let path = path.as_ref();
         let file = self.open(path, UefiFileMode::Read, false)?;
-        log::debug!("{:#?}", &file.into_type().unwrap());
         let mut file = self.open(path, UefiFileMode::Read, false)?;
         file.get_boxed_info().map_err(|err| {
             log::debug!("failed to fetch file info: {err:#?}");
-            FileSystemError::OpenError(path.to_string())
+            FileSystemError::OpenError {
+                path: path.to_cstr16().to_string(),
+                error: err
+            }
         })
     }
 
@@ -138,10 +154,12 @@ impl<'a> FileSystem<'a> {
         let mut file = self
             .open(path, UefiFileMode::Read, false)?
             .into_regular_file()
-            .ok_or(FileSystemError::NotAFile(path.as_str().to_string()))?;
-        let info = file.get_boxed_info::<FileInfo>().map_err(|e| {
-            log::error!("get info failed: {e:?}");
-            FileSystemError::OpenError(path.as_str().to_string())
+            .ok_or(FileSystemError::NotAFile(path.to_cstr16().to_string()))?;
+        let info = file.get_boxed_info::<FileInfo>().map_err(|err| {
+            FileSystemError::OpenError {
+                path: path.to_cstr16().to_string(),
+                error: err
+            }
         })?;
 
         let mut vec = vec![0; info.file_size() as usize];
@@ -164,7 +182,7 @@ impl<'a> FileSystem<'a> {
         let dir = self
             .open(path, UefiFileMode::Read, false)?
             .into_directory()
-            .ok_or(FileSystemError::NotADirectory(path.as_str().to_string()))?;
+            .ok_or(FileSystemError::NotADirectory(path.to_cstr16().to_string()))?;
         Ok(UefiDirectoryIter::new(dir))
     }
 
@@ -185,9 +203,9 @@ impl<'a> FileSystem<'a> {
         match file {
             FileType::Dir(dir) => dir.delete().map_err(|e| {
                 log::error!("error removing dir: {e:?}");
-                FileSystemError::CantDeleteDirectory(path.as_str().to_string())
+                FileSystemError::CantDeleteDirectory(path.to_cstr16().to_string())
             }),
-            FileType::Regular(_) => Err(FileSystemError::NotADirectory(path.as_str().to_string())),
+            FileType::Regular(_) => Err(FileSystemError::NotADirectory(path.to_cstr16().to_string())),
         }
     }
 
@@ -209,9 +227,9 @@ impl<'a> FileSystem<'a> {
         match file {
             FileType::Regular(file) => file.delete().map_err(|e| {
                 log::error!("error removing file: {e:?}");
-                FileSystemError::CantDeleteFile(path.as_str().to_string())
+                FileSystemError::CantDeleteFile(path.to_cstr16().to_string())
             }),
-            FileType::Dir(_) => Err(FileSystemError::NotAFile(path.as_str().to_string())),
+            FileType::Dir(_) => Err(FileSystemError::NotAFile(path.to_cstr16().to_string())),
         }
     }
 
@@ -278,19 +296,24 @@ impl<'a> FileSystem<'a> {
         mode: UefiFileMode,
         is_dir: bool,
     ) -> FileSystemResult<UefiFileHandle> {
-        let path = NormalizedPath::new("\\", path)?;
-        log::debug!("normalized path: {path}");
+        validate_path(path)?;
+        log::trace!("open validated path: {path}");
 
         let attr = if mode == UefiFileMode::CreateReadWrite && is_dir {
             FileAttribute::DIRECTORY
         } else {
             FileAttribute::empty()
         };
 
-        self.open_root()?.open(&path, mode, attr).map_err(|x| {
-            log::trace!("Can't open file {path}: {x:?}");
-            FileSystemError::OpenError(path.to_string())
-        })
+        self.open_root()?
+            .open(path.to_cstr16(), mode, attr)
+            .map_err(|err| {
+                log::trace!("Can't open file {path}: {err:?}");
+                FileSystemError::OpenError {
+                    path: path.to_cstr16().to_string(),
+                    error: err
+                }
+            })
     }
 }
 

uefi/src/fs/mod.rs

@@ -31,14 +31,11 @@
 
 mod dir_entry_iter;
 mod file_system;
-mod normalized_path;
-mod path;
 mod uefi_types;
+mod path;
 
 pub use file_system::{FileSystem, FileSystemError, FileSystemResult};
-pub use normalized_path::{PathError, SEPARATOR, SEPARATOR_STR};
+pub use path::*;
 
 use dir_entry_iter::*;
-use normalized_path::*;
-use path::*;
 use uefi_types::*;