Rename cap-primitives' mkdir to create_dir.

Author: sunfishcode

cap-async-std/src/fs/dir.rs

@@ -6,9 +6,9 @@ use async_std::os::wasi::{
 };
 use async_std::{fs, io};
 use cap_primitives::fs::{
-    canonicalize, copy, hard_link, mkdir, open, open_ambient_dir, open_dir, read_dir, readlink,
-    remove_dir_all, remove_open_dir, remove_open_dir_all, rename, rmdir, set_permissions, stat,
-    unlink, DirOptions, FollowSymlinks, Permissions,
+    canonicalize, copy, create_dir, hard_link, open, open_ambient_dir, open_dir, read_dir,
+    readlink, remove_dir_all, remove_open_dir, remove_open_dir_all, rename, rmdir, set_permissions,
+    stat, unlink, DirOptions, FollowSymlinks, Permissions,
 };
 use std::{
     fmt,
@@ -144,7 +144,7 @@ impl Dir {
 
     fn _create_dir_one(&self, path: &Path, dir_options: &DirOptions) -> io::Result<()> {
         let file = unsafe { as_sync(&self.std_file) };
-        mkdir(&file, path, dir_options)
+        create_dir(&file, path, dir_options)
     }
 
     fn _create_dir_all(&self, path: &Path, dir_options: &DirOptions) -> io::Result<()> {

cap-primitives/src/fs/mkdir.rs renamed to cap-primitives/src/fs/create_dir.rs

@@ -1,35 +1,35 @@
-//! This defines `mkdir`, the primary entrypoint to sandboxed directory creation.
+//! This defines `create_dir`, the primary entrypoint to sandboxed directory creation.
 
 #[cfg(racy_asserts)]
 use crate::fs::{
-    canonicalize, map_result, mkdir_unchecked, stat_unchecked, FollowSymlinks, Metadata,
+    canonicalize, create_dir_unchecked, map_result, stat_unchecked, FollowSymlinks, Metadata,
 };
-use crate::fs::{mkdir_impl, DirOptions};
+use crate::fs::{create_dir_impl, DirOptions};
 use std::{fs, io, path::Path};
 
 /// Perform a `mkdirat`-like operation, ensuring that the resolution of the path
 /// never escapes the directory tree rooted at `start`.
 #[cfg_attr(not(racy_asserts), allow(clippy::let_and_return))]
 #[inline]
-pub fn mkdir(start: &fs::File, path: &Path, options: &DirOptions) -> io::Result<()> {
+pub fn create_dir(start: &fs::File, path: &Path, options: &DirOptions) -> io::Result<()> {
     #[cfg(racy_asserts)]
     let stat_before = stat_unchecked(start, path, FollowSymlinks::No);
 
     // Call the underlying implementation.
-    let result = mkdir_impl(start, path, options);
+    let result = create_dir_impl(start, path, options);
 
     #[cfg(racy_asserts)]
     let stat_after = stat_unchecked(start, path, FollowSymlinks::No);
 
     #[cfg(racy_asserts)]
-    check_mkdir(start, path, options, &stat_before, &result, &stat_after);
+    check_create_dir(start, path, options, &stat_before, &result, &stat_after);
 
     result
 }
 
 #[cfg(racy_asserts)]
 #[allow(clippy::enum_glob_use)]
-fn check_mkdir(
+fn check_create_dir(
     start: &fs::File,
     path: &Path,
     options: &DirOptions,
@@ -62,12 +62,12 @@ fn check_mkdir(
         }
 
         (_, Err((kind, message)), _) => match map_result(&canonicalize(start, path)) {
-            Ok(canon) => match map_result(&mkdir_unchecked(start, &canon, options)) {
+            Ok(canon) => match map_result(&create_dir_unchecked(start, &canon, options)) {
                 Err((unchecked_kind, unchecked_message)) => {
                     assert_eq!(
                         kind,
                         unchecked_kind,
-                        "unexpected error kind from mkdir start='{:?}', \
+                        "unexpected error kind from create_dir start='{:?}', \
                          path='{}':\nstat_before={:#?}\nresult={:#?}\nstat_after={:#?}",
                         start,
                         path.display(),
@@ -77,7 +77,7 @@ fn check_mkdir(
                     );
                     assert_eq!(message, unchecked_message);
                 }
-                _ => panic!("unsandboxed mkdir success"),
+                _ => panic!("unsandboxed create_dir success"),
             },
             Err((_canon_kind, _canon_message)) => {
                 /* TODO: Check error messages
@@ -88,7 +88,7 @@ fn check_mkdir(
         },
 
         other => panic!(
-            "inconsistent mkdir checks: start='{:?}' path='{}':\n{:#?}",
+            "inconsistent create_dir checks: start='{:?}' path='{}':\n{:#?}",
             start,
             path.display(),
             other,

cap-primitives/src/fs/mod.rs

@@ -6,6 +6,7 @@ pub(crate) mod assert_same_file;
 
 mod canonicalize;
 mod copy;
+mod create_dir;
 mod dir_builder;
 mod dir_entry;
 mod dir_options;
@@ -18,7 +19,6 @@ mod hard_link;
 mod is_read_write;
 mod maybe_owned_file;
 mod metadata;
-mod mkdir;
 mod open;
 mod open_dir;
 mod open_options;
@@ -55,6 +55,7 @@ pub(crate) use super::winx::fs::*;
 
 pub use canonicalize::*;
 pub use copy::*;
+pub use create_dir::*;
 pub use dir_builder::*;
 pub use dir_entry::*;
 pub use dir_options::*;
@@ -63,7 +64,6 @@ pub use follow_symlinks::*;
 pub use hard_link::*;
 pub use is_read_write::is_read_write;
 pub use metadata::*;
-pub use mkdir::*;
 pub use open::*;
 pub use open_dir::*;
 pub use open_options::*;

cap-primitives/src/fs/via_parent/create_dir.rs

@@ -0,0 +1,17 @@
+use super::open_parent;
+use crate::fs::{create_dir_unchecked, strip_dir_suffix, DirOptions, MaybeOwnedFile};
+use std::{fs, io, path::Path};
+
+/// Implement `create_dir` by `open`ing up the parent component of the path and
+/// then calling `create_dir_unchecked` on the last component.
+pub(crate) fn create_dir(start: &fs::File, path: &Path, options: &DirOptions) -> io::Result<()> {
+    let start = MaybeOwnedFile::borrowed(start);
+
+    // As a special case, `create_dir` ignores a trailing slash rather than treating
+    // it as equivalent to a trailing slash-dot, so strip any trailing slashes.
+    let path = strip_dir_suffix(path);
+
+    let (dir, basename) = open_parent(start, &path)?;
+
+    create_dir_unchecked(&dir, basename.as_ref(), options)
+}

cap-primitives/src/fs/via_parent/mkdir.rs

@@ -1,9 +1,9 @@
 //! In many operations, the last component of a path is special. For example,
-//! in `mkdir`, the last component names the path to be created, while the
+//! in `create_dir`, the last component names the path to be created, while the
 //! rest of the components just name the place to create it in.
 
+mod create_dir;
 mod hard_link;
-mod mkdir;
 mod open_parent;
 #[cfg(not(windows))] // doesn't work on windows; use a windows-specific impl
 mod readlink;
@@ -18,8 +18,8 @@ mod unlink;
 
 use open_parent::open_parent;
 
+pub(crate) use create_dir::create_dir;
 pub(crate) use hard_link::hard_link;
-pub(crate) use mkdir::mkdir;
 #[cfg(not(windows))] // doesn't work on windows; use a windows-specific impl
 pub(crate) use readlink::readlink;
 pub(crate) use rename::rename;

cap-primitives/src/fs/via_parent/mod.rs

@@ -2,8 +2,8 @@ use crate::fs::DirOptions;
 use posish::fs::{mkdirat, Mode};
 use std::{fs, io, path::Path};
 
-/// *Unsandboxed* function similar to `mkdir`, but which does not perform sandboxing.
-pub(crate) fn mkdir_unchecked(
+/// *Unsandboxed* function similar to `create_dir`, but which does not perform sandboxing.
+pub(crate) fn create_dir_unchecked(
     start: &fs::File,
     path: &Path,
     options: &DirOptions,

cap-primitives/src/posish/fs/mkdir_unchecked.rs renamed to cap-primitives/src/posish/fs/create_dir_unchecked.rs

@@ -52,8 +52,8 @@ pub(crate) fn append_dir_suffix(path: PathBuf) -> PathBuf {
 }
 
 /// Strip trailing `/`s, unless this reduces `path` to `/` itself. This is
-/// used by `mkdir` and others to prevent paths like `foo/` from canonicalizing
-/// to `foo/.` since these syscalls treat these differently.
+/// used by `create_dir` and others to prevent paths like `foo/` from
+/// canonicalizing to `foo/.` since these syscalls treat these differently.
 #[allow(clippy::indexing_slicing)]
 pub(crate) fn strip_dir_suffix(path: &Path) -> impl Deref<Target = Path> + '_ {
     let mut bytes = path.as_os_str().as_bytes();

cap-primitives/src/posish/fs/dir_utils.rs

@@ -1,5 +1,6 @@
 mod c_str;
 mod copy;
+mod create_dir_unchecked;
 mod dir_entry_inner;
 mod dir_options_ext;
 mod dir_utils;
@@ -10,7 +11,6 @@ mod is_root_dir;
 #[cfg(racy_asserts)]
 mod is_same_file;
 mod metadata_ext;
-mod mkdir_unchecked;
 mod oflags;
 mod open_options_ext;
 mod open_unchecked;
@@ -63,7 +63,7 @@ pub(crate) use {set_permissions_impl::set_permissions_impl, set_times_impl::set_
 #[rustfmt::skip]
 pub(crate) use crate::fs::{
     via_parent::hard_link as hard_link_impl,
-    via_parent::mkdir as mkdir_impl,
+    via_parent::create_dir as create_dir_impl,
     via_parent::readlink as readlink_impl,
     via_parent::rename as rename_impl,
     via_parent::rmdir as rmdir_impl,
@@ -75,6 +75,7 @@ pub(crate) use crate::fs::{
 #[allow(unused_imports)]
 pub(crate) use c_str::c_str;
 pub(crate) use copy::*;
+pub(crate) use create_dir_unchecked::*;
 pub(crate) use dir_entry_inner::*;
 pub(crate) use dir_options_ext::*;
 pub(crate) use dir_utils::*;
@@ -85,7 +86,6 @@ pub(crate) use is_root_dir::*;
 #[cfg(racy_asserts)]
 pub(crate) use is_same_file::*;
 pub(crate) use metadata_ext::*;
-pub(crate) use mkdir_unchecked::*;
 pub(crate) use open_options_ext::*;
 pub(crate) use open_unchecked::*;
 pub(crate) use permissions_ext::*;

cap-primitives/src/posish/fs/mod.rs

@@ -2,11 +2,11 @@ use super::get_path::concatenate_or_return_absolute;
 use crate::fs::DirOptions;
 use std::{fs, io, path::Path};
 
-/// *Unsandboxed* function similar to `mkdir`, but which does not perform sandboxing.
+/// *Unsandboxed* function similar to `create_dir`, but which does not perform sandboxing.
 ///
 /// Note that Windows doesn't have any extra flags in `DirOptions`, so the
 /// `options` parameter is ignored.
-pub(crate) fn mkdir_unchecked(
+pub(crate) fn create_dir_unchecked(
     start: &fs::File,
     path: &Path,
     _options: &DirOptions,