Refactor some code out of open_manually.rs into separate files.

Author: sunfishcode

cap-primitives/src/fs/cow_component.rs

@@ -0,0 +1,32 @@
+use std::{borrow::Cow, ffi::OsStr, path::Component};
+
+/// Like `std::path::Component` except we combine `Prefix` and `RootDir` since
+/// we don't support absolute paths, and `Normal` has a `Cow` instead of a plain
+/// `OsStr` reference, so it can optionally own its own string.
+#[derive(Debug)]
+pub(super) enum CowComponent<'borrow> {
+    PrefixOrRootDir,
+    CurDir,
+    ParentDir,
+    Normal(Cow<'borrow, OsStr>),
+}
+
+/// Convert a `Component` into a `CowComponent` which borrows strings.
+pub(super) fn to_borrowed_component(component: Component) -> CowComponent {
+    match component {
+        Component::Prefix(_) | Component::RootDir => CowComponent::PrefixOrRootDir,
+        Component::CurDir => CowComponent::CurDir,
+        Component::ParentDir => CowComponent::ParentDir,
+        Component::Normal(os_str) => CowComponent::Normal(os_str.into()),
+    }
+}
+
+/// Convert a `Component` into a `CowComponent` which owns strings.
+pub(super) fn to_owned_component<'borrow>(component: Component) -> CowComponent<'borrow> {
+    match component {
+        Component::Prefix(_) | Component::RootDir => CowComponent::PrefixOrRootDir,
+        Component::CurDir => CowComponent::CurDir,
+        Component::ParentDir => CowComponent::ParentDir,
+        Component::Normal(os_str) => CowComponent::Normal(os_str.to_os_string().into()),
+    }
+}

cap-primitives/src/fs/mod.rs

@@ -3,6 +3,7 @@
 mod canonicalize;
 mod canonicalize_manually;
 mod copy;
+mod cow_component;
 mod dir_builder;
 mod dir_entry;
 mod dir_options;
@@ -24,6 +25,7 @@ mod open_entry_manually;
 mod open_manually;
 mod open_options;
 mod open_parent;
+mod open_unchecked_error;
 mod permissions;
 mod read_dir;
 mod readlink;
@@ -48,6 +50,8 @@ mod unlink_via_parent;
 
 pub(crate) mod errors;
 
+use cow_component::*;
+
 pub(crate) use canonicalize_manually::*;
 #[cfg(not(feature = "no_racy_asserts"))]
 pub(crate) use get_path::*;
@@ -58,6 +62,7 @@ pub(crate) use mkdir_via_parent::*;
 pub(crate) use open_entry_manually::*;
 pub(crate) use open_manually::*;
 pub(crate) use open_parent::*;
+pub(crate) use open_unchecked_error::*;
 pub(crate) use readlink_one::*;
 #[cfg(not(windows))] // doesn't work on windows; use a windows-specific impl
 pub(crate) use readlink_via_parent::*;

cap-primitives/src/fs/open_manually.rs

@@ -4,47 +4,16 @@
 #[cfg(not(feature = "no_racy_asserts"))]
 use crate::fs::is_same_file;
 use crate::fs::{
-    dir_options, errors, open_unchecked, path_requires_dir, readlink_one, FollowSymlinks,
-    MaybeOwnedFile, OpenOptions,
+    dir_options, errors, open_unchecked, path_requires_dir, readlink_one, to_borrowed_component,
+    to_owned_component, CowComponent, FollowSymlinks, MaybeOwnedFile, OpenOptions,
+    OpenUncheckedError,
 };
 use std::{
-    borrow::Cow,
     ffi::OsStr,
     fs, io,
     path::{Component, Path, PathBuf},
 };
 
-/// Like `std::path::Component` except we combine `Prefix` and `RootDir` since
-/// we don't support absolute paths, and `Normal` has a `Cow` instead of a plain
-/// `OsStr` reference, so it can optionally own its own string.
-#[derive(Debug)]
-enum CowComponent<'borrow> {
-    PrefixOrRootDir,
-    CurDir,
-    ParentDir,
-    Normal(Cow<'borrow, OsStr>),
-}
-
-/// Convert a `Component` into a `CowComponent` which borrows strings.
-fn to_borrowed_component(component: Component) -> CowComponent {
-    match component {
-        Component::Prefix(_) | Component::RootDir => CowComponent::PrefixOrRootDir,
-        Component::CurDir => CowComponent::CurDir,
-        Component::ParentDir => CowComponent::ParentDir,
-        Component::Normal(os_str) => CowComponent::Normal(os_str.into()),
-    }
-}
-
-/// Convert a `Component` into a `CowComponent` which owns strings.
-fn to_owned_component<'borrow>(component: Component) -> CowComponent<'borrow> {
-    match component {
-        Component::Prefix(_) | Component::RootDir => CowComponent::PrefixOrRootDir,
-        Component::CurDir => CowComponent::CurDir,
-        Component::ParentDir => CowComponent::ParentDir,
-        Component::Normal(os_str) => CowComponent::Normal(os_str.to_os_string().into()),
-    }
-}
-
 /// Utility for collecting the canonical path components.
 struct CanonicalPath<'path_buf> {
     /// If the user requested a canonical path, a reference to the `PathBuf` to
@@ -122,8 +91,8 @@ pub(crate) fn open_manually_wrapper(
 ) -> io::Result<fs::File> {
     let mut symlink_count = 0;
     let start = MaybeOwnedFile::borrowed(start);
-    open_manually(start, path, options, &mut symlink_count, None)
-        .and_then(|maybe_owned| maybe_owned.into_file(options))
+    let maybe_owned = open_manually(start, path, options, &mut symlink_count, None)?;
+    maybe_owned.into_file(options)
 }
 
 /// Implement `open` by breaking up the path into components, resolving each
@@ -171,7 +140,7 @@ pub(crate) fn open_manually<'start>(
         match c {
             CowComponent::PrefixOrRootDir => return Err(errors::escape_attempt()),
             CowComponent::CurDir => {
-                // If the path ends in `.` and we want write access, fail.
+                // If the path ends in `.` and we can't open a directory, fail.
                 if components.is_empty() {
                     if dir_precluded {
                         return Err(errors::is_directory());
@@ -204,7 +173,7 @@ pub(crate) fn open_manually<'start>(
                 assert!(canonical_path.pop());
             }
             CowComponent::Normal(one) => {
-                // If the path requires a directory and we'd open it for writing, fail.
+                // If the path requires a directory and we can't open a directory, fail.
                 if components.is_empty() && dir_required && dir_precluded {
                     return Err(errors::is_directory());
                 }
@@ -275,7 +244,7 @@ pub(crate) fn open_manually<'start>(
     }
 
     #[cfg(not(feature = "no_racy_asserts"))]
-    check_open(&start_clone, path, options, &canonical_path, &base);
+    check_open_manually(&start_clone, path, options, &canonical_path, &base);
 
     canonical_path.complete();
     Ok(base)
@@ -290,7 +259,7 @@ fn should_emulate_o_path(use_options: &OpenOptions) -> bool {
 }
 
 #[cfg(not(feature = "no_racy_asserts"))]
-fn check_open(
+fn check_open_manually(
     start: &fs::File,
     path: &Path,
     options: &OpenOptions,
@@ -332,20 +301,3 @@ fn check_open(
         }
     }
 }
-
-#[derive(Debug)]
-pub(crate) enum OpenUncheckedError {
-    Other(io::Error),
-    Symlink(io::Error),
-    NotFound(io::Error),
-}
-
-impl From<OpenUncheckedError> for io::Error {
-    fn from(error: OpenUncheckedError) -> Self {
-        match error {
-            OpenUncheckedError::Other(err)
-            | OpenUncheckedError::Symlink(err)
-            | OpenUncheckedError::NotFound(err) => err,
-        }
-    }
-}

cap-primitives/src/fs/open_unchecked_error.rs

@@ -0,0 +1,18 @@
+use std::io;
+
+#[derive(Debug)]
+pub(crate) enum OpenUncheckedError {
+    Other(io::Error),
+    Symlink(io::Error),
+    NotFound(io::Error),
+}
+
+impl From<OpenUncheckedError> for io::Error {
+    fn from(error: OpenUncheckedError) -> Self {
+        match error {
+            OpenUncheckedError::Other(err)
+            | OpenUncheckedError::Symlink(err)
+            | OpenUncheckedError::NotFound(err) => err,
+        }
+    }
+}