Import the cap-primitives crate

Copy the entire contents of this crate into
`crates/wasi/src/filesystem/primitives` for future modifications to get
it building.

Author: alexcrichton

crates/wasi/Cargo.toml

@@ -49,11 +49,23 @@ env_logger = { workspace = true }
 
 [target.'cfg(unix)'.dependencies]
 rustix = { workspace = true, features = ["event", "fs", "net"] }
+rustix-linux-procfs = "0.1.1"
 
 [target.'cfg(windows)'.dependencies]
 io-extras = { workspace = true }
-windows-sys = { workspace = true }
 rustix = { workspace = true, features = ["event", "net"] }
+winx = "0.36.0"
+
+[target.'cfg(windows)'.dependencies.windows-sys]
+workspace = true
+features = [
+  "Wdk_Storage_FileSystem",
+  "Win32_Foundation",
+  "Win32_Storage_FileSystem",
+  "Win32_System_IO",
+  "Win32_System_Ioctl",
+  "Win32_System_Performance",
+]
 
 [features]
 default = ["preview1"]

crates/wasi/src/ctx.rs

@@ -298,7 +298,8 @@ impl WasiCtxBuilder {
         dir_perms: DirPerms,
         file_perms: FilePerms,
     ) -> Result<&mut Self> {
-        let dir = cap_std::fs::Dir::open_ambient_dir(host_path.as_ref(), ambient_authority())?;
+        let dir = crate::filesystem::primitives::open_ambient_dir(host_path.as_ref())?;
+        let dir = cap_std::fs::Dir::from_std_file(dir);
         let mut open_mode = OpenMode::empty();
         if dir_perms.contains(DirPerms::READ) {
             open_mode |= OpenMode::READ;

crates/wasi/src/filesystem/primitives/create_dir.rs

@@ -0,0 +1,14 @@
+//! This defines `create_dir`, the primary entrypoint to sandboxed directory
+//! creation.
+
+use crate::filesystem::primitives::{DirOptions, create_dir_impl};
+use std::path::Path;
+use std::{fs, io};
+
+/// Perform a `mkdirat`-like operation, ensuring that the resolution of the
+/// path never escapes the directory tree rooted at `start`.
+#[inline]
+pub fn create_dir(start: &fs::File, path: &Path, options: &DirOptions) -> io::Result<()> {
+    // Call the underlying implementation.
+    create_dir_impl(start, path, options)
+}

crates/wasi/src/filesystem/primitives/dir_entry.rs

@@ -0,0 +1,67 @@
+use crate::filesystem::primitives::{DirEntryInner, Metadata};
+#[cfg(not(windows))]
+use rustix::fs::DirEntryExt;
+use std::ffi::OsString;
+use std::{fmt, io};
+
+/// Entries returned by the `ReadDir` iterator.
+///
+/// This corresponds to [`std::fs::DirEntry`].
+///
+/// Unlike `std::fs::DirEntry`, this API has no `DirEntry::path`, because
+/// absolute paths don't interoperate well with the capability model.
+///
+/// There is a `file_name` function, however there are also `open`,
+/// `open_with`, `open_dir`, `remove_file`, and `remove_dir` functions for
+/// opening or removing the entry directly, which can be more efficient and
+/// convenient.
+///
+/// There is no `from_std` method, as `std::fs::DirEntry` doesn't provide a way
+/// to construct a `DirEntry` without opening directories by ambient paths.
+pub struct DirEntry {
+    pub(crate) inner: DirEntryInner,
+}
+
+impl DirEntry {
+    /// Returns the metadata for the file that this entry points at.
+    ///
+    /// This corresponds to [`std::fs::DirEntry::metadata`].
+    ///
+    /// # Platform-specific behavior
+    ///
+    /// On Windows, this produces a `Metadata` object which does not contain
+    /// the optional values returned by [`MetadataExt`]. Use
+    /// [`cap_fs_ext::DirEntryExt::full_metadata`] to obtain a `Metadata` with
+    /// the values filled in.
+    ///
+    /// [`MetadataExt`]: https://doc.rust-lang.org/std/os/windows/fs/trait.MetadataExt.html
+    /// [`cap_fs_ext::DirEntryExt::full_metadata`]: https://docs.rs/cap-fs-ext/latest/cap_fs_ext/trait.DirEntryExt.html#tymethod.full_metadata
+    #[inline]
+    pub fn metadata(&self) -> io::Result<Metadata> {
+        self.inner.metadata()
+    }
+
+    /// Returns the bare file name of this directory entry without any other
+    /// leading path component.
+    ///
+    /// This corresponds to [`std::fs::DirEntry::file_name`].
+    #[inline]
+    pub fn file_name(&self) -> OsString {
+        self.inner.file_name()
+    }
+}
+
+#[cfg(not(windows))]
+impl DirEntryExt for DirEntry {
+    #[inline]
+    fn ino(&self) -> u64 {
+        self.inner.ino()
+    }
+}
+
+impl fmt::Debug for DirEntry {
+    // Like libstd's version, but doesn't print the path.
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.inner.fmt(f)
+    }
+}

crates/wasi/src/filesystem/primitives/dir_options.rs

@@ -0,0 +1,34 @@
+#[cfg(not(target_os = "wasi"))]
+use crate::filesystem::primitives::DirOptionsExt;
+
+/// Options and flags which can be used to configure how a directory is
+/// created.
+///
+/// This is to `create_dir` what to `OpenOptions` is to `open`.
+#[derive(Debug, Clone)]
+pub struct DirOptions {
+    #[cfg(not(target_os = "wasi"))]
+    #[allow(dead_code)]
+    pub(crate) ext: DirOptionsExt,
+}
+
+impl DirOptions {
+    /// Creates a blank new set of options ready for configuration.
+    #[allow(clippy::new_without_default)]
+    #[inline]
+    pub const fn new() -> Self {
+        Self {
+            #[cfg(not(target_os = "wasi"))]
+            ext: DirOptionsExt::new(),
+        }
+    }
+}
+
+#[cfg(target_os = "vxworks")]
+impl crate::fs::DirBuilderExt for DirOptions {
+    #[inline]
+    fn mode(&mut self, mode: u32) -> &mut Self {
+        self.ext.mode(mode);
+        self
+    }
+}

crates/wasi/src/filesystem/primitives/errors.rs

@@ -0,0 +1,14 @@
+use std::io;
+
+#[cfg(not(windows))]
+pub(crate) use crate::filesystem::primitives::rustix::fs::errors::*;
+#[cfg(windows)]
+pub(crate) use crate::filesystem::primitives::windows::fs::errors::*;
+
+#[cold]
+pub(crate) fn escape_attempt() -> io::Error {
+    io::Error::new(
+        io::ErrorKind::PermissionDenied,
+        "a path led outside of the filesystem",
+    )
+}

crates/wasi/src/filesystem/primitives/file_type.rs

@@ -0,0 +1,123 @@
+//! The `FileType` struct.
+
+use crate::filesystem::primitives::ImplFileTypeExt;
+
+/// `FileType`'s inner state.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+enum Inner {
+    /// A directory.
+    Dir,
+
+    /// A file.
+    File,
+
+    /// An unknown entity.
+    Unknown,
+
+    /// A `FileTypeExt` type.
+    Ext(ImplFileTypeExt),
+}
+
+/// A structure representing a type of file with accessors for each file type.
+///
+/// This corresponds to [`std::fs::FileType`].
+///
+/// <details>
+/// We need to define our own version because the libstd `FileType` doesn't
+/// have a public constructor that we can use.
+/// </details>
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+#[repr(transparent)]
+pub struct FileType(Inner);
+
+impl FileType {
+    /// Creates a `FileType` for which `is_dir()` returns `true`.
+    #[inline]
+    pub const fn dir() -> Self {
+        Self(Inner::Dir)
+    }
+
+    /// Creates a `FileType` for which `is_file()` returns `true`.
+    #[inline]
+    pub const fn file() -> Self {
+        Self(Inner::File)
+    }
+
+    /// Creates a `FileType` for which `is_unknown()` returns `true`.
+    #[inline]
+    pub const fn unknown() -> Self {
+        Self(Inner::Unknown)
+    }
+
+    /// Creates a `FileType` from extension type.
+    #[inline]
+    pub(crate) const fn ext(ext: ImplFileTypeExt) -> Self {
+        Self(Inner::Ext(ext))
+    }
+
+    /// Tests whether this file type represents a directory.
+    ///
+    /// This corresponds to [`std::fs::FileType::is_dir`].
+    #[inline]
+    pub fn is_dir(&self) -> bool {
+        self.0 == Inner::Dir
+    }
+
+    /// Tests whether this file type represents a regular file.
+    ///
+    /// This corresponds to [`std::fs::FileType::is_file`].
+    #[inline]
+    pub fn is_file(&self) -> bool {
+        self.0 == Inner::File
+    }
+
+    /// Tests whether this file type represents a symbolic link.
+    ///
+    /// This corresponds to [`std::fs::FileType::is_symlink`].
+    #[inline]
+    pub fn is_symlink(&self) -> bool {
+        if let Inner::Ext(ext) = self.0 {
+            ext.is_symlink()
+        } else {
+            false
+        }
+    }
+}
+
+/// Unix-specific extensions for [`FileType`].
+///
+/// This corresponds to [`std::os::unix::fs::FileTypeExt`].
+#[cfg(any(unix, target_os = "vxworks"))]
+pub trait FileTypeExt {
+    /// Returns `true` if this file type is a block device.
+    fn is_block_device(&self) -> bool;
+    /// Returns `true` if this file type is a character device.
+    fn is_char_device(&self) -> bool;
+}
+
+#[cfg(any(unix, target_os = "vxworks"))]
+impl FileTypeExt for FileType {
+    #[inline]
+    fn is_block_device(&self) -> bool {
+        self.0 == Inner::Ext(ImplFileTypeExt::block_device())
+    }
+
+    #[inline]
+    fn is_char_device(&self) -> bool {
+        self.0 == Inner::Ext(ImplFileTypeExt::char_device())
+    }
+}
+
+/// Extension trait to allow `is_block_device` etc. to be exposed by
+/// the `cap-fs-ext` crate.
+///
+/// This is hidden from the main API since this functionality isn't present in
+/// `std`. Use `cap_fs_ext::FileTypeExt` instead of calling this directly.
+#[cfg(windows)]
+#[doc(hidden)]
+pub trait _WindowsFileTypeExt {
+    fn is_block_device(&self) -> bool;
+    fn is_char_device(&self) -> bool;
+    fn is_fifo(&self) -> bool;
+    fn is_socket(&self) -> bool;
+}

crates/wasi/src/filesystem/primitives/follow_symlinks.rs

@@ -0,0 +1,16 @@
+/// Should symlinks be followed in the last component of a path?
+///
+/// This doesn't affect path components other than the last. So for example in
+/// "foo/bar/baz", if "foo" or "bar" are symlinks, they will always be
+/// followed. This enum value only determines whether "baz" is followed.
+///
+/// Instead of passing bare `bool`s as parameters, pass a distinct enum so that
+/// the intent is clear.
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum FollowSymlinks {
+    /// Yes, do follow symlinks in the last component of a path.
+    Yes,
+
+    /// No, do not follow symlinks in the last component of a path.
+    No,
+}

crates/wasi/src/filesystem/primitives/hard_link.rs

@@ -0,0 +1,19 @@
+//! This defines `hard_link`, the primary entrypoint to sandboxed hard-link
+//! creation.
+
+use crate::filesystem::primitives::hard_link_impl;
+use std::path::Path;
+use std::{fs, io};
+
+/// Perform a `linkat`-like operation, ensuring that the resolution of the path
+/// never escapes the directory tree rooted at `start`.
+#[inline]
+pub fn hard_link(
+    old_start: &fs::File,
+    old_path: &Path,
+    new_start: &fs::File,
+    new_path: &Path,
+) -> io::Result<()> {
+    // Call the underlying implementation.
+    hard_link_impl(old_start, old_path, new_start, new_path)
+}

crates/wasi/src/filesystem/primitives/manually/canonical_path.rs

@@ -0,0 +1,55 @@
+use std::ffi::OsStr;
+use std::path::{Component, PathBuf};
+
+/// Utility for collecting the canonical path components.
+pub(super) struct CanonicalPath<'path_buf> {
+    /// If the user requested a canonical path, a reference to the `PathBuf` to
+    /// write it to.
+    path: Option<&'path_buf mut PathBuf>,
+}
+
+impl<'path_buf> CanonicalPath<'path_buf> {
+    pub(super) fn new(path: Option<&'path_buf mut PathBuf>) -> Self {
+        Self { path }
+    }
+
+    pub(super) fn push(&mut self, one: &OsStr) {
+        if let Some(path) = &mut self.path {
+            path.push(one)
+        }
+    }
+
+    pub(super) fn pop(&mut self) -> bool {
+        if let Some(path) = &mut self.path {
+            path.pop()
+        } else {
+            true
+        }
+    }
+
+    /// The complete canonical path has been scanned. Set `path` to `None`
+    /// so that it isn't cleared when `self` is dropped.
+    pub(super) fn complete(&mut self) {
+        // Replace "" with ".", since "" as a relative path is interpreted as
+        // an error.
+        if let Some(path) = &mut self.path {
+            if path.as_os_str().is_empty() {
+                path.push(Component::CurDir);
+            }
+            self.path = None;
+        }
+    }
+}
+
+impl<'path_buf> Drop for CanonicalPath<'path_buf> {
+    fn drop(&mut self) {
+        // If `self.path` is still `Some` here, it means that we haven't called
+        // `complete()` yet, meaning the `CanonicalPath` is being dropped
+        // before the complete path has been processed. In that case, clear
+        // `path` to indicate that we weren't able to obtain a complete path.
+        if let Some(path) = &mut self.path {
+            path.clear();
+            self.path = None;
+        }
+    }
+}