directory: Add _opt helpers

This is like https://docs.rs/cap-std-ext/latest/cap_std_ext/dirext/trait.CapStdExtDirExt.html#tymethod.open_dir_optional
etc.

The rationale here is that it's really common for filesystem
operations to want to handle "not found" and that maps
most cleanly to `Option`. We only have one use right now
but there could easily be more.

Signed-off-by: Colin Walters <[email protected]>

Author: cgwalters

src/selabel.rs

@@ -13,7 +13,7 @@ use regex_automata::{hybrid::dfa, util::syntax, Anchored, Input};
 use crate::{
     fsverity::FsVerityHashValue,
     repository::Repository,
-    tree::{Directory, FileSystem, ImageError, Inode, Leaf, LeafContent, RegularFile, Stat},
+    tree::{Directory, FileSystem, Inode, Leaf, LeafContent, RegularFile, Stat},
 };
 
 /* We build the entire SELinux policy into a single "lazy DFA" such that:
@@ -106,16 +106,18 @@ struct Policy {
     contexts: Vec<String>,
 }
 
+/// Open a file in the composefs store, handling inline vs external files.
 pub fn openat<'a, H: FsVerityHashValue>(
     dir: &'a Directory<H>,
     filename: impl AsRef<OsStr>,
     repo: &Repository<H>,
 ) -> Result<Option<Box<dyn Read + 'a>>> {
-    match dir.get_file(filename.as_ref()) {
-        Ok(RegularFile::Inline(data)) => Ok(Some(Box::new(&**data))),
-        Ok(RegularFile::External(id, ..)) => Ok(Some(Box::new(File::from(repo.open_object(id)?)))),
-        Err(ImageError::NotFound(..)) => Ok(None),
-        Err(other) => Err(other)?,
+    match dir.get_file_opt(filename.as_ref())? {
+        Some(file) => match file {
+            RegularFile::Inline(data) => Ok(Some(Box::new(&**data))),
+            RegularFile::External(id, ..) => Ok(Some(Box::new(File::from(repo.open_object(id)?)))),
+        },
+        None => Ok(None),
     }
 }
 
@@ -248,10 +250,9 @@ fn parse_config(file: impl Read) -> Result<Option<String>> {
 
 pub fn selabel<H: FsVerityHashValue>(fs: &mut FileSystem<H>, repo: &Repository<H>) -> Result<()> {
     // if /etc/selinux/config doesn't exist then it's not an error
-    let etc_selinux = match fs.root.get_directory("etc/selinux".as_ref()) {
-        Err(ImageError::NotFound(..)) => return Ok(()),
-        other => other,
-    }?;
+    let Some(etc_selinux) = fs.root.get_directory_opt("etc/selinux".as_ref())? else {
+        return Ok(());
+    };
 
     let Some(etc_selinux_config) = openat(etc_selinux, "config", repo)? else {
         return Ok(());

src/tree.rs

@@ -152,6 +152,17 @@ impl<ObjectID: FsVerityHashValue> Directory<ObjectID> {
     ///
     /// On failure, can return any number of errors from ImageError.
     pub fn get_directory(&self, pathname: &OsStr) -> Result<&Directory<ObjectID>, ImageError> {
+        match self.get_directory_opt(pathname)? {
+            Some(r) => Ok(r),
+            None => Err(ImageError::NotFound(Box::from(pathname))),
+        }
+    }
+
+    /// Like [`Self::get_directory()`] but maps [`ImageError::NotFound`] to [`Option`].
+    pub fn get_directory_opt(
+        &self,
+        pathname: &OsStr,
+    ) -> Result<Option<&Directory<ObjectID>>, ImageError> {
         let path = Path::new(pathname);
         let mut dir = self;
 
@@ -164,12 +175,12 @@ impl<ObjectID: FsVerityHashValue> Directory<ObjectID> {
                 Component::Normal(filename) => match dir.entries.get(filename) {
                     Some(Inode::Directory(subdir)) => subdir,
                     Some(_) => return Err(ImageError::NotADirectory(filename.into())),
-                    None => return Err(ImageError::NotFound(filename.into())),
+                    None => return Ok(None),
                 },
             }
         }
 
-        Ok(dir)
+        Ok(Some(dir))
     }
 
     /// Gets a mutable reference to a subdirectory of this directory.
@@ -301,13 +312,22 @@ impl<ObjectID: FsVerityHashValue> Directory<ObjectID> {
         &'a self,
         filename: &OsStr,
     ) -> Result<&'a RegularFile<ObjectID>, ImageError> {
+        self.get_file_opt(filename)?
+            .ok_or_else(|| ImageError::NotFound(Box::from(filename)))
+    }
+
+    /// Like [`Self::get_file()`] but maps [`ImageError::NotFound`] to [`Option`].
+    pub fn get_file_opt<'a>(
+        &'a self,
+        filename: &OsStr,
+    ) -> Result<Option<&'a RegularFile<ObjectID>>, ImageError> {
         match self.entries.get(filename) {
             Some(Inode::Leaf(leaf)) => match &leaf.content {
-                LeafContent::Regular(file) => Ok(file),
+                LeafContent::Regular(file) => Ok(Some(file)),
                 _ => Err(ImageError::IsNotRegular(filename.into())),
             },
             Some(Inode::Directory(..)) => Err(ImageError::IsADirectory(filename.into())),
-            None => Err(ImageError::NotFound(filename.into())),
+            None => Ok(None),
         }
     }