A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
Vendor the cap-primitives crate within the `wasmtime-wasi` crate (#14219)
Alex Crichtoneb5a7cfa360a
diff --git a/Cargo.lock b/Cargo.lockindex 2202f6137d..182b5286a4 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -346,18 +346,6 @@ dependencies = ["serde",]-[[package]]-name = "cap-fs-ext"-version = "4.0.3"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "56ff379b70af8e08307a8f65e7040c7301cb4a572538ade16b4984f0da77847f"-dependencies = [- "cap-primitives",- "cap-std",- "io-lifetimes 3.0.1",- "windows-sys 0.61.2",-]-[[package]]name = "cap-primitives"version = "4.0.3"@@ -376,18 +364,6 @@ dependencies = ["winx",]-[[package]]-name = "cap-std"-version = "4.0.3"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "c1ec78e242cfa2cfe276807ac2ecc00315a6c97786977414bcd1c3963b6c91b8"-dependencies = [- "cap-primitives",- "io-extras",- "io-lifetimes 3.0.1",- "rustix 1.1.4",-]-[[package]]name = "capstone"version = "0.14.0"@@ -5165,12 +5141,12 @@ dependencies = ["async-trait","bitflags 2.11.1","bytes",- "cap-fs-ext","cap-primitives","env_logger 0.11.5","futures","rand 0.10.1","rustix 1.1.4",+ "rustix-linux-procfs","tempfile","test-log","test-programs-artifacts",@@ -5184,6 +5160,7 @@ dependencies = ["wasmtime-wasi-io","wiggle","windows-sys 0.61.2",+ "winx",][[package]]diff --git a/Cargo.toml b/Cargo.tomlindex 8af2632f61..3c6425c6a2 100644--- a/Cargo.toml+++ b/Cargo.toml@@ -364,12 +364,7 @@ regalloc2 = "0.15.2"wasip1 = { version = "1.0.0", default-features = false }# cap-std family:-#-# Note that `cap-fs-ext` should be avoided where possible to use-# `cap-primitives` instead.target-lexicon = "0.13.5"-cap-primitives = "4.0.3"-cap-fs-ext-avoid-using-this = { version = "4.0.3", package = 'cap-fs-ext' }rustix = "1.1.4"# wit-bindgen:wit-bindgen = { version = "0.61.1", default-features = false }diff --git a/crates/wasi/Cargo.toml b/crates/wasi/Cargo.tomlindex 48775b62c5..fcf250429f 100644--- a/crates/wasi/Cargo.toml+++ b/crates/wasi/Cargo.toml@@ -26,8 +26,7 @@ tokio = { workspace = true, features = ["time", "sync", "io-std", "io-util", "rbytes = { workspace = true }thiserror = { workspace = true }tracing = { workspace = true, features = ["std", "attributes"] }-cap-primitives = { workspace = true }-cap-fs-ext-avoid-using-this = { workspace = true }+public-cap-primitives = { version = "4.0.3", package = 'cap-primitives' }bitflags = { workspace = true }async-trait = { workspace = true }futures = { workspace = true }@@ -46,9 +45,11 @@ 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]rustix = { workspace = true, features = ["event", "net"] }+winx = "0.36.0"[target.'cfg(windows)'.dependencies.windows-sys]workspace = true@@ -57,6 +58,7 @@ features = ["Win32_Foundation","Win32_Storage_FileSystem","Win32_System_IO",+ "Win32_System_Ioctl","Win32_System_Performance",]diff --git a/crates/wasi/src/ctx.rs b/crates/wasi/src/ctx.rsindex 99a8c71c3a..a54ed070af 100644--- a/crates/wasi/src/ctx.rs+++ b/crates/wasi/src/ctx.rs@@ -4,7 +4,6 @@ use crate::filesystem::{Dir, WasiFilesystemCtx};use crate::random::WasiRandomCtx;use crate::sockets::{SocketAddrCheck, SocketAddrUse, WasiSocketsCtx};use crate::{FsPerms, OpenMode};-use cap_primitives::ambient_authority;use rand::Rng;use std::future::Future;use std::mem;@@ -300,7 +299,7 @@ impl WasiCtxBuilder {guest_path: impl AsRef<str>,perms: FsPerms,) -> Result<&mut Self> {- let dir = cap_primitives::fs::open_ambient_dir(host_path.as_ref(), ambient_authority())?;+ let dir = crate::filesystem::primitives::open_ambient_dir(host_path.as_ref())?;let open_mode = match perms {FsPerms::ReadOnly => OpenMode::READ,FsPerms::ReadWrite => OpenMode::READ | OpenMode::WRITE,diff --git a/crates/wasi/src/filesystem.rs b/crates/wasi/src/filesystem.rsindex e7b9190bb6..f74621ad03 100644--- a/crates/wasi/src/filesystem.rs+++ b/crates/wasi/src/filesystem.rs@@ -1,6 +1,6 @@use crate::clocks::Datetime;+use crate::filesystem::primitives::{DirOptions, FollowSymlinks, Metadata, OpenOptions};use crate::runtime::{AbortOnDropJoinHandle, spawn_blocking};-use cap_primitives::fs::{DirOptions, FollowSymlinks, Metadata, OpenOptions, SystemTimeSpec};use std::collections::hash_map;use std::sync::Arc;use std::time::SystemTime;@@ -17,6 +17,8 @@ pub(crate) mod windows;#[cfg(windows)]pub(crate) use windows as sys;+pub(crate) mod primitives;+/// A helper struct which implements [`HasData`] for the `wasi:filesystem` APIs.////// This can be useful when directly calling `add_to_linker` functions directly,@@ -274,8 +276,8 @@ pub(crate) enum DescriptorType {RegularFile,}-impl From<cap_primitives::fs::FileType> for DescriptorType {- fn from(ft: cap_primitives::fs::FileType) -> Self {+impl From<crate::filesystem::primitives::FileType> for DescriptorType {+ fn from(ft: crate::filesystem::primitives::FileType) -> Self {if ft.is_dir() {DescriptorType::Directory} else if ft.is_symlink() {@@ -327,15 +329,12 @@ impl DescriptorStat {data_access_timestamp: meta.accessed().ok()- .and_then(|t| Datetime::try_from(t.into_std()).ok()),+ .and_then(|t| Datetime::try_from(t).ok()),data_modification_timestamp: meta.modified().ok()- .and_then(|t| Datetime::try_from(t.into_std()).ok()),- status_change_timestamp: meta- .created()- .ok()- .and_then(|t| Datetime::try_from(t.into_std()).ok()),+ .and_then(|t| Datetime::try_from(t).ok()),+ status_change_timestamp: meta.created().ok().and_then(|t| Datetime::try_from(t).ok()),}}}@@ -524,7 +523,7 @@ impl Descriptor {}Self::Dir(d) => {d.run_blocking(|d| {- let d = cap_primitives::fs::open(+ let d = crate::filesystem::primitives::open(d,std::path::Component::CurDir.as_ref(),OpenOptions::new().read(true),@@ -622,7 +621,7 @@ impl Descriptor {}Self::Dir(d) => {d.run_blocking(|d| {- let d = cap_primitives::fs::open(+ let d = crate::filesystem::primitives::open(d,std::path::Component::CurDir.as_ref(),OpenOptions::new().read(true),@@ -855,7 +854,7 @@ impl Dir {return Err(ErrorCode::NotPermitted);}self.run_blocking(move |d| {- cap_primitives::fs::create_dir(d, path.as_ref(), &DirOptions::new())+ crate::filesystem::primitives::create_dir(d, path.as_ref(), &DirOptions::new())}).await?;Ok(())@@ -887,16 +886,14 @@ impl Dir {if self.perms.write_not_permitted() {return Err(ErrorCode::NotPermitted);}- let atim =- atim.map(|t| SystemTimeSpec::Absolute(cap_primitives::time::SystemTime::from_std(t)));- let mtim =- mtim.map(|t| SystemTimeSpec::Absolute(cap_primitives::time::SystemTime::from_std(t)));if path_flags.contains(PathFlags::SYMLINK_FOLLOW) {- self.run_blocking(move |d| cap_primitives::fs::set_times(d, path.as_ref(), atim, mtim))- .await?;+ self.run_blocking(move |d| {+ crate::filesystem::primitives::set_times(d, path.as_ref(), atim, mtim)+ })+ .await?;} else {self.run_blocking(move |d| {- cap_primitives::fs::set_times_nofollow(d, path.as_ref(), atim, mtim)+ crate::filesystem::primitives::set_times_nofollow(d, path.as_ref(), atim, mtim)}).await?;}@@ -924,7 +921,12 @@ impl Dir {}let new_dir_handle = Arc::clone(&new_dir.dir);self.run_blocking(move |d| {- cap_primitives::fs::hard_link(d, old_path.as_ref(), &new_dir_handle, new_path.as_ref())+ crate::filesystem::primitives::hard_link(+ d,+ old_path.as_ref(),+ &new_dir_handle,+ new_path.as_ref(),+ )}).await?;Ok(())@@ -975,17 +977,10 @@ impl Dir {open_mode |= OpenMode::READ;}- // Note that this is intentionally scoped to a separate block to- // minimize the surface area that is depended on by cap-fs-ext. Ideally- // the underlying functionality in `cap-primitives` would get exposed,- // but that'll require an upstream PR.- {- use cap_fs_ext_avoid_using_this::OpenOptionsFollowExt;- if path_flags.contains(PathFlags::SYMLINK_FOLLOW) {- opts.follow(FollowSymlinks::Yes);- } else {- opts.follow(FollowSymlinks::No);- }+ if path_flags.contains(PathFlags::SYMLINK_FOLLOW) {+ opts.follow(FollowSymlinks::Yes);+ } else {+ opts.follow(FollowSymlinks::No);}// These flags are not yet supported in cap-primitives:@@ -1024,7 +1019,7 @@ impl Dir {let opened = self.run_blocking::<_, std::io::Result<OpenResult>>(move |d| {- let opened = cap_primitives::fs::open(d, path.as_ref(), &opts)?;+ let opened = crate::filesystem::primitives::open(d, path.as_ref(), &opts)?;if Metadata::from_file(&opened)?.is_dir() {Ok(OpenResult::Dir(opened))} else if oflags.contains(OpenFlags::DIRECTORY) {@@ -1064,7 +1059,7 @@ impl Dir {pub(crate) async fn readlink_at(&self, path: String) -> Result<String, ErrorCode> {let link = self- .run_blocking(move |d| cap_primitives::fs::read_link(d, path.as_ref()))+ .run_blocking(move |d| crate::filesystem::primitives::read_link(d, path.as_ref())).await?;link.into_os_string().into_string()@@ -1075,7 +1070,7 @@ impl Dir {if self.perms.write_not_permitted() {return Err(ErrorCode::NotPermitted);}- self.run_blocking(move |d| cap_primitives::fs::remove_dir(d, path.as_ref()))+ self.run_blocking(move |d| crate::filesystem::primitives::remove_dir(d, path.as_ref())).await?;Ok(())}@@ -1097,7 +1092,12 @@ impl Dir {}let new_dir_handle = Arc::clone(&new_dir.dir);self.run_blocking(move |d| {- cap_primitives::fs::rename(d, old_path.as_ref(), &new_dir_handle, new_path.as_ref())+ crate::filesystem::primitives::rename(+ d,+ old_path.as_ref(),+ &new_dir_handle,+ new_path.as_ref(),+ )}).await?;Ok(())diff --git a/crates/wasi/src/filesystem/primitives/create_dir.rs b/crates/wasi/src/filesystem/primitives/create_dir.rsnew file mode 100644index 0000000000..0d33961817--- /dev/null+++ b/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)+}diff --git a/crates/wasi/src/filesystem/primitives/dir_entry.rs b/crates/wasi/src/filesystem/primitives/dir_entry.rsnew file mode 100644index 0000000000..013880d489--- /dev/null+++ b/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)+ }+}diff --git a/crates/wasi/src/filesystem/primitives/dir_options.rs b/crates/wasi/src/filesystem/primitives/dir_options.rsnew file mode 100644index 0000000000..096bfa4469--- /dev/null+++ b/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+ }+}diff --git a/crates/wasi/src/filesystem/primitives/errors.rs b/crates/wasi/src/filesystem/primitives/errors.rsnew file mode 100644index 0000000000..d0dcc94911--- /dev/null+++ b/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",+ )+}diff --git a/crates/wasi/src/filesystem/primitives/file_type.rs b/crates/wasi/src/filesystem/primitives/file_type.rsnew file mode 100644index 0000000000..20ebf31f2b--- /dev/null+++ b/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;+}diff --git a/crates/wasi/src/filesystem/primitives/follow_symlinks.rs b/crates/wasi/src/filesystem/primitives/follow_symlinks.rsnew file mode 100644index 0000000000..55774d4ae7--- /dev/null+++ b/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,+}diff --git a/crates/wasi/src/filesystem/primitives/hard_link.rs b/crates/wasi/src/filesystem/primitives/hard_link.rsnew file mode 100644index 0000000000..e46bd3c7b1--- /dev/null+++ b/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)+}diff --git a/crates/wasi/src/filesystem/primitives/manually/canonical_path.rs b/crates/wasi/src/filesystem/primitives/manually/canonical_path.rsnew file mode 100644index 0000000000..b843cb703b--- /dev/null+++ b/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;+ }+ }+}diff --git a/crates/wasi/src/filesystem/primitives/manually/cow_component.rs b/crates/wasi/src/filesystem/primitives/manually/cow_component.rsnew file mode 100644index 0000000000..0cf454ffd2--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/manually/cow_component.rs@@ -0,0 +1,44 @@+use std::borrow::Cow;+use std::ffi::OsStr;+use std::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.+pub(super) enum CowComponent<'borrow> {+ PrefixOrRootDir,+ CurDir,+ ParentDir,+ Normal(Cow<'borrow, OsStr>),+}++impl<'borrow> CowComponent<'borrow> {+ /// Convert a `Component` into a `CowComponent` which borrows strings.+ pub(super) fn borrowed(component: Component<'borrow>) -> Self {+ match component {+ Component::Prefix(_) | Component::RootDir => Self::PrefixOrRootDir,+ Component::CurDir => Self::CurDir,+ Component::ParentDir => Self::ParentDir,+ Component::Normal(os_str) => Self::Normal(os_str.into()),+ }+ }++ /// Convert a `Component` into a `CowComponent` which owns strings.+ pub(super) fn owned(component: Component) -> Self {+ match component {+ Component::Prefix(_) | Component::RootDir => Self::PrefixOrRootDir,+ Component::CurDir => Self::CurDir,+ Component::ParentDir => Self::ParentDir,+ Component::Normal(os_str) => Self::Normal(os_str.to_os_string().into()),+ }+ }++ /// Test whether `self` is `Component::Normal`.+ #[cfg(windows)]+ pub(super) fn is_normal(&self) -> bool {+ match self {+ CowComponent::Normal(_) => true,+ _ => false,+ }+ }+}diff --git a/crates/wasi/src/filesystem/primitives/manually/mod.rs b/crates/wasi/src/filesystem/primitives/manually/mod.rsnew file mode 100644index 0000000000..3712e9abaf--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/manually/mod.rs@@ -0,0 +1,13 @@+//! Functions that perform path lookup manually, one component+//! at a time, with manual symlink resolution.++mod canonical_path;+mod cow_component;+mod open;+mod read_link_one;++use canonical_path::CanonicalPath;+use cow_component::CowComponent;+use read_link_one::read_link_one;++pub(crate) use open::{open, stat};diff --git a/crates/wasi/src/filesystem/primitives/manually/open.rs b/crates/wasi/src/filesystem/primitives/manually/open.rsnew file mode 100644index 0000000000..06bef1aba9--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/manually/open.rs@@ -0,0 +1,510 @@+//! Manual path resolution, one component at a time, with manual symlink+//! resolution, in order to enforce sandboxing.++use super::{CanonicalPath, CowComponent, read_link_one};+use crate::filesystem::primitives::{+ FollowSymlinks, MaybeOwnedFile, Metadata, OpenOptions, OpenUncheckedError, dir_options, errors,+ open_unchecked, path_has_trailing_dot, path_has_trailing_slash, stat_unchecked,+};+#[cfg(any(target_os = "android", target_os = "linux", target_os = "freebsd"))]+use rustix::fs::OFlags;+use std::ffi::OsStr;+use std::path::{Component, Path, PathBuf};+use std::{fs, io, mem};+#[cfg(windows)]+use {+ crate::filesystem::primitives::{+ SymlinkKind, open_dir_unchecked, path_really_has_trailing_dot,+ },+ windows_sys::Win32::Storage::FileSystem::FILE_ATTRIBUTE_DIRECTORY,+};++/// Implement `open` by breaking up the path into components, resolving each+/// component individually, and resolving symbolic links manually.+pub(crate) fn open(start: &fs::File, path: &Path, options: &OpenOptions) -> io::Result<fs::File> {+ let mut symlink_count = 0;+ let start = MaybeOwnedFile::borrowed(start);+ let maybe_owned = internal_open(start, path, options, &mut symlink_count, None)?;+ maybe_owned.into_file(options)+}++/// Context for performing manual component-at-a-time path resolution.+struct Context<'start> {+ /// The current base directory handle for path lookups.+ base: MaybeOwnedFile<'start>,++ /// The stack of directory handles below the base.+ dirs: Vec<MaybeOwnedFile<'start>>,++ /// The current worklist stack of path components to process.+ components: Vec<CowComponent<'start>>,++ /// If requested, the canonical path is constructed here.+ canonical_path: CanonicalPath<'start>,++ /// Does the path end in `/` or similar, so it requires a directory?+ dir_required: bool,++ /// Are we requesting write permissions, so we can't open a directory?+ dir_precluded: bool,++ /// Where there a trailing slash on the path?+ trailing_slash: bool,++ /// If a path ends in `.`, `..`, or `/`, including after expanding+ /// symlinks, we need to follow path resolution by opening `.` so that we+ /// obtain a full `dir_options` file descriptor and confirm that we have+ /// search rights in the last component.+ follow_with_dot: bool,++ /// A `PathBuf` that we reuse for calling `read_link_one` to minimize+ /// allocations.+ reuse: PathBuf,+}++impl<'start> Context<'start> {+ /// Construct a new instance of `Self`.+ fn new(+ start: MaybeOwnedFile<'start>,+ path: &'start Path,+ _options: &OpenOptions,+ canonical_path: Option<&'start mut PathBuf>,+ ) -> Self {+ let trailing_slash = path_has_trailing_slash(path);+ let trailing_dot = path_has_trailing_dot(path);+ let trailing_dotdot = path.ends_with(Component::ParentDir);++ let mut components: Vec<CowComponent> = Vec::new();++ #[cfg(windows)]+ {+ // Windows resolves `..` before doing filesystem lookups.+ for component in path.components().map(CowComponent::borrowed) {+ match component {+ CowComponent::ParentDir+ if !components.is_empty() && components.last().unwrap().is_normal() =>+ {+ let _ = components.pop();+ }+ _ => components.push(component),+ }+ }+ components.reverse();+ }++ #[cfg(not(windows))]+ {+ // Add the path components to the worklist. Rust's `Path`+ // normalizes away `.` components, however a trailing `.` affects+ // path lookup, so special-case it here.+ if trailing_dot {+ components.push(CowComponent::CurDir);+ }+ components.extend(path.components().rev().map(CowComponent::borrowed));+ }++ Self {+ base: start,+ dirs: Vec::with_capacity(components.len()),+ components,+ canonical_path: CanonicalPath::new(canonical_path),+ dir_required: trailing_slash,++ #[cfg(not(windows))]+ dir_precluded: _options.write || _options.append,++ #[cfg(windows)]+ dir_precluded: false,++ trailing_slash,++ follow_with_dot: trailing_dot | trailing_dotdot,++ reuse: PathBuf::new(),+ }+ }++ fn check_dot_access(&self) -> io::Result<()> {+ // Manually check that we have permissions to search `self.base` to+ // search for `.` in it, since we otherwise resolve `.` and `..`+ // ourselves by just manipulating the `dirs` stack.+ #[cfg(not(windows))]+ {+ // Use `faccess` with `AT_EACCESS`. `AT_EACCESS` is not often the+ // right tool for the job; in POSIX, it's better to ask for errno+ // than to ask for permission. But we use `check_dot_access` to+ // check access for opening `.` and `..` in situations where we+ // already have open handles to them, and now we're accessing them+ // through different paths, and we need to check whether these+ // paths allow us access.+ //+ // Android and Emscripten lack `AT_EACCESS`.+ // <https://android.googlesource.com/platform/bionic/+/master/libc/bionic/faccessat.cpp>+ #[cfg(any(target_os = "emscripten", target_os = "android"))]+ let at_flags = rustix::fs::AtFlags::empty();+ #[cfg(not(any(target_os = "emscripten", target_os = "android")))]+ let at_flags = rustix::fs::AtFlags::EACCESS;++ // Always use `CurDir`, even though this code is used to check+ // permissions for both `.` and `..`, because in both cases we+ // already know we can access the referenced directory, and we+ // just need to check for the ability to search for `.` or `..`+ // within `self.base`, which should always be the same. And+ // using `.` means we avoid asking the OS to access a `..` path+ // for us.+ Ok(rustix::fs::accessat(+ &*self.base,+ Component::CurDir.as_os_str(),+ rustix::fs::Access::EXEC_OK,+ at_flags,+ )?)+ }+ #[cfg(windows)]+ open_dir_unchecked(&self.base, Component::CurDir.as_ref()).map(|_| ())+ }++ /// Handle a "." path component.+ fn cur_dir(&mut self) -> io::Result<()> {+ // This is a no-op. If this occurs at the end of the path, it does+ // imply that we need search access to the directory, and it requires+ // we open a directory, however we'll handle that in the+ // `follow_with_dot` check.+ Ok(())+ }++ /// Handle a ".." path component.+ fn parent_dir(&mut self) -> io::Result<()> {+ // We hold onto all the parent directory descriptors so that we+ // don't have to re-open anything when we encounter a `..`. This+ // way, even if the directory is concurrently moved, we don't have+ // to worry about `..` leaving the sandbox.+ match self.dirs.pop() {+ Some(dir) => {+ // Check that we have permission to look up `..`.+ self.check_dot_access()?;++ // Looks good.+ self.base = dir;+ }+ None => return Err(errors::escape_attempt()),+ }+ assert!(self.canonical_path.pop());++ Ok(())+ }++ /// Handle a "normal" path component.+ fn normal(+ &mut self,+ one: &OsStr,+ options: &OpenOptions,+ symlink_count: &mut u8,+ ) -> io::Result<()> {+ // If there are more named components left, this will be a base+ // directory from which to open subsequent components, so use "path"+ // options (`O_PATH` on Linux).+ let use_options = if self.components.is_empty() {+ options.clone()+ } else {+ dir_options()+ };++ let dir_required = self.dir_required || use_options.dir_required;++ #[allow(clippy::redundant_clone)]+ match open_unchecked(+ &self.base,+ one.as_ref(),+ use_options+ .clone()+ .follow(FollowSymlinks::No)+ .dir_required(dir_required),+ ) {+ Ok(file) => {+ // Emulate `O_PATH` + `FollowSymlinks::Yes` on Linux. If `file`+ // is a symlink, follow it.+ #[cfg(any(target_os = "android", target_os = "linux", target_os = "freebsd"))]+ if should_emulate_o_path(&use_options) {+ match read_link_one(+ &file,+ Default::default(),+ symlink_count,+ mem::take(&mut self.reuse),+ ) {+ Ok(destination) => {+ return self.push_symlink_destination(destination);+ }+ // If it isn't a symlink, handle it as normal.+ // `readlinkat` returns `ENOENT` if the file isn't a+ // symlink in this situation.+ Err(err) if err.kind() == io::ErrorKind::NotFound => (),+ // If `readlinkat` fails any other way, pass it on.+ Err(err) => return Err(err),+ }+ }++ // Normal case+ let prev_base = self.base.descend_to(MaybeOwnedFile::owned(file));+ self.dirs.push(prev_base);+ self.canonical_path.push(one);++ Ok(())+ }+ #[cfg(not(windows))]+ Err(OpenUncheckedError::Symlink(err, ())) => {+ self.maybe_last_component_symlink(one, symlink_count, options.follow, err)+ }+ #[cfg(windows)]+ Err(OpenUncheckedError::Symlink(err, SymlinkKind::Dir)) => {+ // If this is a Windows directory symlink, require a directory.+ self.dir_required |= self.components.is_empty();+ self.maybe_last_component_symlink(one, symlink_count, options.follow, err)+ }+ #[cfg(windows)]+ Err(OpenUncheckedError::Symlink(err, SymlinkKind::File)) => {+ // If this is a Windows file symlink, preclude a directory.+ self.dir_precluded = true;+ self.maybe_last_component_symlink(one, symlink_count, options.follow, err)+ }+ Err(OpenUncheckedError::NotFound(err)) => Err(err),+ Err(OpenUncheckedError::Other(err)) => {+ // An error occurred. If this was the last component, and the+ // error wasn't due to invalid inputs (eg. the path has an+ // embedded NUL), record it as the last component of the+ // canonical path, even if we couldn't open it.+ if self.components.is_empty() && err.kind() != io::ErrorKind::InvalidInput {+ self.canonical_path.push(one);+ self.canonical_path.complete();+ }+ Err(err)+ }+ }+ }++ /// Dereference one symlink level.+ fn symlink(&mut self, one: &OsStr, symlink_count: &mut u8) -> io::Result<()> {+ let destination =+ read_link_one(&self.base, one, symlink_count, mem::take(&mut self.reuse))?;+ self.push_symlink_destination(destination)+ }++ /// Push the components of `destination` onto the worklist stack.+ fn push_symlink_destination(&mut self, destination: PathBuf) -> io::Result<()> {+ let at_end = self.components.is_empty();+ let trailing_slash = path_has_trailing_slash(&destination);+ let trailing_dot = path_has_trailing_dot(&destination);+ let trailing_dotdot = destination.ends_with(Component::ParentDir);++ #[cfg(windows)]+ {+ // `path_has_trailing_dot` returns false so that we don't open `.`+ // at the end of path resolution. But for determining the Windows+ // symlink restrictions, we need to know whether the path really+ // ends in a `.`.+ let trailing_dot_really = path_really_has_trailing_dot(&destination);++ // Windows appears to disallow symlinks to paths with trailing+ // slashes, slashdots, or slashdotdots.+ if trailing_slash+ || (trailing_dot_really && destination.as_os_str() != Component::CurDir.as_os_str())+ || (trailing_dotdot && destination.as_os_str() != Component::ParentDir.as_os_str())+ {+ return Err(io::Error::from_raw_os_error(123));+ }++ // Windows resolves `..` before doing filesystem lookups.+ let mut components: Vec<CowComponent> = Vec::new();+ for component in destination.components().map(CowComponent::owned) {+ match component {+ CowComponent::ParentDir+ if !components.is_empty() && components.last().unwrap().is_normal() =>+ {+ let _ = components.pop();+ }+ _ => components.push(component),+ }+ }+ self.components.extend(components.into_iter().rev());+ }++ #[cfg(not(windows))]+ {+ // Rust's `Path` hides a trailing dot, so handle it manually.+ if trailing_dot {+ self.components.push(CowComponent::CurDir);+ }+ self.components+ .extend(destination.components().rev().map(CowComponent::owned));+ }++ // Record whether the new components ended with a path that implies+ // an open of `.` at the end of path resolution.+ if at_end {+ self.follow_with_dot |= trailing_dot | trailing_dotdot;+ self.trailing_slash |= trailing_slash;+ self.dir_required |= trailing_slash;+ }++ // As an optimization, hold onto the `PathBuf` buffer for later reuse.+ self.reuse = destination;++ Ok(())+ }++ /// Check whether this is the last component and we don't need+ /// to dereference; otherwise call `Self::symlink`.+ fn maybe_last_component_symlink(+ &mut self,+ one: &OsStr,+ symlink_count: &mut u8,+ follow: FollowSymlinks,+ err: io::Error,+ ) -> io::Result<()> {+ if follow == FollowSymlinks::No && !self.trailing_slash && self.components.is_empty() {+ self.canonical_path.push(one);+ self.canonical_path.complete();+ return Err(err);+ }++ self.symlink(one, symlink_count)+ }+}++/// Internal implementation of manual `open`, exposing some additional+/// parameters.+///+/// Callers can request the canonical path by passing `Some` to+/// `canonical_path`. If the complete canonical path is processed, it will be+/// stored in the provided `&mut PathBuf`, even if the actual open fails. If+/// a failure occurs before the complete canonical path is processed, the+/// provided `&mut PathBuf` is cleared to empty.+///+/// A note on lifetimes: `path` and `canonical_path` here don't strictly+/// need `'start`, but using them makes it easier to store them in the+/// `Context` struct.+pub(super) fn internal_open<'start>(+ start: MaybeOwnedFile<'start>,+ path: &'start Path,+ options: &OpenOptions,+ symlink_count: &mut u8,+ canonical_path: Option<&'start mut PathBuf>,+) -> io::Result<MaybeOwnedFile<'start>> {+ // POSIX returns `ENOENT` on an empty path. TODO: On Windows, we should+ // be compatible with what Windows does instead.+ if path.as_os_str().is_empty() {+ return Err(errors::no_such_file_or_directory());+ }++ let mut ctx = Context::new(start, path, options, canonical_path);++ while let Some(c) = ctx.components.pop() {+ match c {+ CowComponent::PrefixOrRootDir => return Err(errors::escape_attempt()),+ CowComponent::CurDir => ctx.cur_dir()?,+ CowComponent::ParentDir => ctx.parent_dir()?,+ CowComponent::Normal(one) => ctx.normal(&one, options, symlink_count)?,+ }+ }++ // We've now finished all the path components other than any trailing `.`s,+ // so we have the complete canonical path.+ ctx.canonical_path.complete();++ // If the path ended in `.` (explicit or implied) or `..`, we may have+ // opened the directory with eg. `O_PATH` on Linux, or we may have skipped+ // checking for search access to `.`, so re-open it.+ if ctx.follow_with_dot {+ if ctx.dir_precluded {+ return Err(errors::is_directory());+ }+ ctx.base = MaybeOwnedFile::owned(open_unchecked(+ &ctx.base,+ Component::CurDir.as_ref(),+ options,+ )?);+ }++ Ok(ctx.base)+}++/// Implement manual `stat` in a similar manner as manual `open`.+pub(crate) fn stat(start: &fs::File, path: &Path, follow: FollowSymlinks) -> io::Result<Metadata> {+ // POSIX returns `ENOENT` on an empty path. TODO: On Windows, we should+ // be compatible with what Windows does instead.+ if path.as_os_str().is_empty() {+ return Err(errors::no_such_file_or_directory());+ }++ let mut options = OpenOptions::new();+ options.follow(follow);+ let mut symlink_count = 0;+ let mut ctx = Context::new(MaybeOwnedFile::borrowed(start), path, &options, None);+ assert!(!ctx.dir_precluded);++ while let Some(c) = ctx.components.pop() {+ match c {+ CowComponent::PrefixOrRootDir => return Err(errors::escape_attempt()),+ CowComponent::CurDir => ctx.cur_dir()?,+ CowComponent::ParentDir => ctx.parent_dir()?,+ CowComponent::Normal(one) => {+ if ctx.components.is_empty() {+ // If this is the last component, do a non-following+ // `stat_unchecked` on it.+ let stat = stat_unchecked(&ctx.base, one.as_ref(), FollowSymlinks::No)?;++ // If we weren't asked to follow symlinks, or it wasn't a+ // symlink, we're done.+ if options.follow == FollowSymlinks::No || !stat.file_type().is_symlink() {+ if stat.is_dir() {+ if ctx.dir_precluded {+ return Err(errors::is_directory());+ }+ } else if ctx.dir_required {+ return Err(errors::is_not_directory());+ }+ return Ok(stat);+ }++ // On Windows, symlinks know whether they are a file or+ // directory.+ #[cfg(windows)]+ if stat.file_attributes() & FILE_ATTRIBUTE_DIRECTORY != 0 {+ ctx.dir_required = true;+ } else {+ ctx.dir_precluded = true;+ }++ // If it was a symlink and we're asked to follow symlinks,+ // dereference it.+ ctx.symlink(&one, &mut symlink_count)?+ } else {+ // Otherwise open the path component normally.+ ctx.normal(&one, &options, &mut symlink_count)?+ }+ }+ }+ }++ // If the path ended in `.` (explicit or implied) or `..`, we may have+ // opened the directory with eg. `O_PATH` on Linux, or we may have skipped+ // checking for search access to `.`, so re-check it.+ if ctx.follow_with_dot {+ if ctx.dir_precluded {+ return Err(errors::is_directory());+ }++ ctx.check_dot_access()?;+ }++ // If the path ended in `.` or `..`, we already have it open, so just do+ // `.metadata()` on it.+ Metadata::from_file(&ctx.base)+}++/// Test whether the given options imply that we should treat an open file as+/// potentially being a symlink we need to follow, due to use of `O_PATH`.+#[cfg(any(target_os = "android", target_os = "linux", target_os = "freebsd"))]+fn should_emulate_o_path(use_options: &OpenOptions) -> bool {+ (use_options.ext.custom_flags & (OFlags::PATH.bits() as i32)) == (OFlags::PATH.bits() as i32)+ && use_options.follow == FollowSymlinks::Yes+}diff --git a/crates/wasi/src/filesystem/primitives/manually/read_link_one.rs b/crates/wasi/src/filesystem/primitives/manually/read_link_one.rsnew file mode 100644index 0000000000..9f54f58bdc--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/manually/read_link_one.rs@@ -0,0 +1,36 @@+use crate::filesystem::primitives::{MAX_SYMLINK_EXPANSIONS, errors, read_link_unchecked};+use std::ffi::OsStr;+use std::path::{Path, PathBuf};+use std::{fs, io};++/// This is a wrapper around `read_link_unchecked` which performs a single+/// symlink expansion on a single path component, and which enforces the+/// recursion limit.+pub(super) fn read_link_one(+ base: &fs::File,+ name: &OsStr,+ symlink_count: &mut u8,+ reuse: PathBuf,+) -> io::Result<PathBuf> {+ let name: &Path = name.as_ref();+ assert!(+ name.as_os_str().is_empty() || name.file_name().is_some(),+ "read_link_one expects a single normal path component, got '{}'",+ name.display()+ );+ assert!(+ name.as_os_str().is_empty() || name.parent().unwrap().as_os_str().is_empty(),+ "read_link_one expects a single normal path component, got '{}'",+ name.display()+ );++ if *symlink_count == MAX_SYMLINK_EXPANSIONS {+ return Err(errors::too_many_symlinks());+ }++ let destination = read_link_unchecked(base, name, reuse)?;++ *symlink_count += 1;++ Ok(destination)+}diff --git a/crates/wasi/src/filesystem/primitives/maybe_owned_file.rs b/crates/wasi/src/filesystem/primitives/maybe_owned_file.rsnew file mode 100644index 0000000000..aba86dd0c9--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/maybe_owned_file.rs@@ -0,0 +1,75 @@+use crate::filesystem::primitives::{OpenOptions, open_unchecked};+use std::ops::Deref;+use std::path::Component;+use std::{fmt, fs, io, mem};++/// Several places in the code need to be able to handle either owned or+/// borrowed [`std::fs::File]`s. Cloning a `File` to let them always have an+/// owned `File` is expensive and fallible, so use this `struct` to hold either+/// one, and implement [`Deref`] to allow them to be handled in a uniform way.+///+/// This is similar to [`Cow`], except without the copy-on-write part ;-).+/// `Cow` requires a `Clone` implementation, which `File` doesn't have, and+/// most users of this type don't need copy-on-write behavior.+///+/// And, this type has the special `descend_to`, which just does an assignment,+/// but also some useful assertion checks.+///+/// [`Deref`]: std::ops::Deref+/// [`Cow`]: std::borrow::Cow+pub(super) enum MaybeOwnedFile<'borrow> {+ Borrowed(&'borrow fs::File),+ Owned(fs::File),+}++impl<'borrow> MaybeOwnedFile<'borrow> {+ /// Constructs a new `MaybeOwnedFile` which is not owned.+ pub(super) fn borrowed(file: &'borrow fs::File) -> Self {+ Self::Borrowed(file)+ }++ /// Constructs a new `MaybeOwnedFile` which is owned.+ pub(super) fn owned(file: fs::File) -> Self {+ Self::Owned(file)+ }++ /// Set this `MaybeOwnedFile` to a new owned file which is from a subtree+ /// of the current file. Return a `MaybeOwnedFile` representing the+ /// previous state.+ pub(super) fn descend_to(&mut self, to: MaybeOwnedFile<'borrow>) -> Self {+ mem::replace(self, to)+ }++ /// Produce an owned `File`. This uses `open` on "." if needed to convert a+ /// borrowed `File` to an owned one.+ #[cfg_attr(windows, allow(dead_code))]+ pub(super) fn into_file(self, options: &OpenOptions) -> io::Result<fs::File> {+ match self {+ Self::Owned(file) => Ok(file),+ Self::Borrowed(file) => {+ // The only situation in which we'd be asked to produce an owned+ // `File` is when there's a need to open "." within a directory+ // to obtain a new handle.+ open_unchecked(file, Component::CurDir.as_ref(), options).map_err(Into::into)+ }+ }+ }+}++impl<'borrow> Deref for MaybeOwnedFile<'borrow> {+ type Target = fs::File;++ #[inline]+ fn deref(&self) -> &Self::Target {+ match self {+ Self::Borrowed(file) => file,+ Self::Owned(file) => file,+ }+ }+}++impl<'borrow> fmt::Debug for MaybeOwnedFile<'borrow> {+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {+ self.deref().fmt(f)+ }+}diff --git a/crates/wasi/src/filesystem/primitives/metadata.rs b/crates/wasi/src/filesystem/primitives/metadata.rsnew file mode 100644index 0000000000..ee2d9d770c--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/metadata.rs@@ -0,0 +1,241 @@+use crate::filesystem::primitives::{FileType, ImplFileTypeExt, ImplMetadataExt};+use std::time::SystemTime;+use std::{fs, io};++/// Metadata information about a file.+///+/// This corresponds to [`std::fs::Metadata`].+///+/// <details>+/// We need to define our own version because the libstd `Metadata` doesn't+/// have a public constructor that we can use.+/// </details>+#[derive(Debug, Clone)]+pub struct Metadata {+ pub(crate) file_type: FileType,+ pub(crate) len: u64,+ pub(crate) modified: Option<SystemTime>,+ pub(crate) accessed: Option<SystemTime>,+ pub(crate) created: Option<SystemTime>,+ pub(crate) ext: ImplMetadataExt,+}++#[allow(clippy::len_without_is_empty)]+impl Metadata {+ /// Constructs a new instance of `Self` from the given [`std::fs::File`].+ #[inline]+ pub fn from_file(file: &fs::File) -> io::Result<Self> {+ let std = file.metadata()?;+ let ext = ImplMetadataExt::from(file, &std)?;+ let file_type = ImplFileTypeExt::from(file, &std)?;+ Ok(Self::from_parts(std, ext, file_type))+ }++ /// Constructs a new instance of `Self` from the given+ /// [`std::fs::Metadata`].+ ///+ /// As with the comments in [`std::fs::Metadata::volume_serial_number`] and+ /// nearby functions, some fields of the resulting metadata will be `None`.+ ///+ /// [`std::fs::Metadata::volume_serial_number`]: https://doc.rust-lang.org/std/os/windows/fs/trait.MetadataExt.html#tymethod.volume_serial_number+ #[cfg(windows)]+ #[inline]+ pub fn from_just_metadata(std: fs::Metadata) -> Self {+ let ext = ImplMetadataExt::from_just_metadata(&std);+ let file_type = ImplFileTypeExt::from_just_metadata(&std);+ Self::from_parts(std, ext, file_type)+ }++ #[inline]+ fn from_parts(std: fs::Metadata, ext: ImplMetadataExt, file_type: FileType) -> Self {+ Self {+ file_type,+ len: std.len(),+ modified: std.modified().ok(),+ accessed: std.accessed().ok(),+ created: std.created().ok(),+ ext,+ }+ }++ /// Returns the file type for this metadata.+ ///+ /// This corresponds to [`std::fs::Metadata::file_type`].+ #[inline]+ pub const fn file_type(&self) -> FileType {+ self.file_type+ }++ /// Returns `true` if this metadata is for a directory.+ ///+ /// This corresponds to [`std::fs::Metadata::is_dir`].+ #[inline]+ pub fn is_dir(&self) -> bool {+ self.file_type.is_dir()+ }++ /// Returns the size of the file, in bytes, this metadata is for.+ ///+ /// This corresponds to [`std::fs::Metadata::len`].+ #[inline]+ pub const fn len(&self) -> u64 {+ self.len+ }++ /// Returns the last modification time listed in this metadata.+ ///+ /// This corresponds to [`std::fs::Metadata::modified`].+ #[inline]+ pub fn modified(&self) -> io::Result<SystemTime> {+ self.modified.ok_or_else(|| {+ io::Error::new(+ io::ErrorKind::Other,+ "modified time metadata not available on this platform",+ )+ })+ }++ /// Returns the last access time of this metadata.+ ///+ /// This corresponds to [`std::fs::Metadata::accessed`].+ #[inline]+ pub fn accessed(&self) -> io::Result<SystemTime> {+ self.accessed.ok_or_else(|| {+ io::Error::new(+ io::ErrorKind::Other,+ "accessed time metadata not available on this platform",+ )+ })+ }++ /// Returns the creation time listed in this metadata.+ ///+ /// This corresponds to [`std::fs::Metadata::created`].+ #[inline]+ pub fn created(&self) -> io::Result<SystemTime> {+ self.created.ok_or_else(|| {+ io::Error::new(+ io::ErrorKind::Other,+ "created time metadata not available on this platform",+ )+ })+ }++ /// `MetadataExt` requires nightly to be implemented, but we sometimes+ /// just need the file attributes.+ #[cfg(windows)]+ #[inline]+ pub(crate) fn file_attributes(&self) -> u32 {+ self.ext.file_attributes()+ }+}++/// Unix-specific extensions for [`MetadataExt`].+///+/// This corresponds to [`std::os::unix::fs::MetadataExt`].+#[cfg(any(unix, target_os = "vxworks"))]+pub trait MetadataExt {+ /// Returns the ID of the device containing the file.+ fn dev(&self) -> u64;+ /// Returns the inode number.+ fn ino(&self) -> u64;+ /// Returns the number of hard links pointing to this file.+ fn nlink(&self) -> u64;+ #[cfg(target_os = "vxworks")]+ fn attrib(&self) -> u8;+}++/// WASI-specific extensions for [`MetadataExt`].+///+/// This corresponds to [`std::os::wasi::fs::MetadataExt`].+#[cfg(target_os = "wasi")]+pub trait MetadataExt {+ /// Returns the ID of the device containing the file.+ fn dev(&self) -> u64;+ /// Returns the inode number.+ fn ino(&self) -> u64;+ /// Returns the number of hard links pointing to this file.+ fn nlink(&self) -> u64;+}++/// Windows-specific extensions to [`Metadata`].+///+/// This corresponds to [`std::os::windows::fs::MetadataExt`].+#[cfg(windows)]+pub trait MetadataExt {+ /// Returns the value of the `dwFileAttributes` field of this metadata.+ fn file_attributes(&self) -> u32;+}++#[cfg(unix)]+impl MetadataExt for Metadata {+ #[inline]+ fn dev(&self) -> u64 {+ crate::filesystem::primitives::MetadataExt::dev(&self.ext)+ }++ #[inline]+ fn ino(&self) -> u64 {+ crate::filesystem::primitives::MetadataExt::ino(&self.ext)+ }++ #[inline]+ fn nlink(&self) -> u64 {+ crate::filesystem::primitives::MetadataExt::nlink(&self.ext)+ }+}++#[cfg(target_os = "wasi")]+impl MetadataExt for Metadata {+ #[inline]+ fn dev(&self) -> u64 {+ crate::filesystem::primitives::MetadataExt::dev(&self.ext)+ }++ #[inline]+ fn ino(&self) -> u64 {+ crate::filesystem::primitives::MetadataExt::ino(&self.ext)+ }++ #[inline]+ fn nlink(&self) -> u64 {+ crate::filesystem::primitives::MetadataExt::nlink(&self.ext)+ }+}++#[cfg(target_os = "vxworks")]+impl MetadataExt for Metadata {+ #[inline]+ fn dev(&self) -> u64 {+ self.ext.dev()+ }++ #[inline]+ fn ino(&self) -> u64 {+ self.ext.ino()+ }++ #[inline]+ fn nlink(&self) -> u64 {+ self.ext.nlink()+ }+}++#[cfg(windows)]+impl MetadataExt for Metadata {+ #[inline]+ fn file_attributes(&self) -> u32 {+ self.ext.file_attributes()+ }+}++/// Extension trait to allow `volume_serial_number` 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::MetadataExt` instead of calling this directly.+#[cfg(windows)]+#[doc(hidden)]+pub trait _WindowsByHandle {+ fn number_of_links(&self) -> Option<u32>;+}diff --git a/crates/wasi/src/filesystem/primitives/mod.rs b/crates/wasi/src/filesystem/primitives/mod.rsnew file mode 100644index 0000000000..6ce84fb66e--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/mod.rs@@ -0,0 +1,86 @@+//! Filesystem utilities.++#![allow(+ trivial_numeric_casts,+ reason = "preexisting from when cap-primitives was imported"+)]+#![allow(+ unsafe_op_in_unsafe_fn,+ reason = "preexisting from when cap-primitives was imported"+)]+#![allow(+ clippy::unnecessary_fallible_conversions,+ reason = "platform-agnostic code can't always take advantage of this"+)]+#![allow(+ clippy::allow_attributes_without_reason,+ reason = "preexisting from when cap-primitives was imported"+)]++mod create_dir;+mod dir_entry;+mod dir_options;+mod file_type;+mod follow_symlinks;+mod hard_link;+mod maybe_owned_file;+mod metadata;+mod open;+mod open_dir;+mod open_options;+mod open_unchecked_error;+mod read_dir;+mod read_link;+mod remove_dir;+mod remove_file;+mod rename;+mod set_times;+mod stat;+mod symlink;++pub(crate) mod errors;+pub(crate) mod manually;+pub(crate) mod via_parent;++use maybe_owned_file::MaybeOwnedFile;++pub(crate) use open_unchecked_error::*;++#[cfg(not(windows))]+mod rustix;+#[cfg(not(windows))]+pub(crate) use self::rustix::fs::*;+#[cfg(windows)]+mod windows;+#[cfg(windows)]+pub(crate) use self::windows::fs::*;++pub use create_dir::create_dir;+pub use dir_entry::DirEntry;+pub use dir_options::DirOptions;+#[cfg(windows)]+pub use file_type::_WindowsFileTypeExt;+pub use file_type::FileType;+#[cfg(any(unix, target_os = "vxworks"))]+pub use file_type::FileTypeExt;+pub use follow_symlinks::FollowSymlinks;+pub use hard_link::hard_link;+#[cfg(windows)]+pub use metadata::_WindowsByHandle;+pub use metadata::{Metadata, MetadataExt};+pub use open::open;+pub use open_dir::*;+pub use open_options::*;+pub use read_dir::read_base_dir;+pub use read_link::read_link;+pub use remove_dir::remove_dir;+pub use remove_file::remove_file;+pub use rename::rename;+pub use set_times::{set_times, set_times_nofollow};+pub use stat::stat;+#[cfg(not(windows))]+pub use symlink::symlink;+#[cfg(windows)]+pub use symlink::{symlink_dir, symlink_file};+#[cfg(test)]+mod tests;diff --git a/crates/wasi/src/filesystem/primitives/open.rs b/crates/wasi/src/filesystem/primitives/open.rsnew file mode 100644index 0000000000..5fc94be9eb--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/open.rs@@ -0,0 +1,14 @@+//! This defines `open`, the primary entrypoint to sandboxed file and directory+//! opening.++use crate::filesystem::primitives::{OpenOptions, open_impl};+use std::path::Path;+use std::{fs, io};++/// Perform an `openat`-like operation, ensuring that the resolution of the+/// path never escapes the directory tree rooted at `start`.+#[inline]+pub fn open(start: &fs::File, path: &Path, options: &OpenOptions) -> io::Result<fs::File> {+ // Call the underlying implementation.+ open_impl(start, path, options)+}diff --git a/crates/wasi/src/filesystem/primitives/open_dir.rs b/crates/wasi/src/filesystem/primitives/open_dir.rsnew file mode 100644index 0000000000..351b57af1a--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/open_dir.rs@@ -0,0 +1,49 @@+//! This defines `open_dir`, a wrapper around `open` which can be used to open+//! path as a directory.++#[allow(unused_imports)]+use crate::filesystem::primitives::open_unchecked;+use crate::filesystem::primitives::{+ FollowSymlinks, dir_options, open, open_ambient_dir_impl, readdir_options,+};+use std::path::Path;+use std::{fs, io};++/// Open a directory by performing an `openat`-like operation,+/// ensuring that the resolution of the path never escapes+/// the directory tree rooted at `start`.+#[inline]+pub fn open_dir(start: &fs::File, path: &Path) -> io::Result<fs::File> {+ open(start, path, &dir_options())+}++/// Open a directory by performing an unsandboxed `openat`-like operation.+#[inline]+#[allow(dead_code)]+pub(crate) fn open_dir_unchecked(start: &fs::File, path: &Path) -> io::Result<fs::File> {+ open_unchecked(start, path, &dir_options()).map_err(Into::into)+}++/// Like `open_dir_unchecked`, but additionally request the ability to read the+/// directory entries.+#[inline]+#[allow(dead_code)]+pub(crate) fn open_dir_for_reading_unchecked(+ start: &fs::File,+ path: &Path,+ follow: FollowSymlinks,+) -> io::Result<fs::File> {+ open_unchecked(start, path, readdir_options().follow(follow)).map_err(Into::into)+}++/// Open a directory named by a bare path, using the host process' ambient+/// authority.+///+/// # Ambient Authority+///+/// This function is not sandboxed and may trivially access any path that the+/// host process has access to.+#[inline]+pub fn open_ambient_dir(path: &Path) -> io::Result<fs::File> {+ open_ambient_dir_impl(path)+}diff --git a/crates/wasi/src/filesystem/primitives/open_options.rs b/crates/wasi/src/filesystem/primitives/open_options.rsnew file mode 100644index 0000000000..73b43e2ef2--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/open_options.rs@@ -0,0 +1,327 @@+use crate::filesystem::primitives::{FollowSymlinks, ImplOpenOptionsExt};++/// Options and flags which can be used to configure how a file is opened.+///+/// This corresponds to [`std::fs::OpenOptions`].+///+/// This `OpenOptions` has no `open` method. To open a file with an+/// `OptionOptions`, first obtain a [`Dir`] containing the path, and then call+/// [`Dir::open_with`].+///+/// [`Dir`]: https://docs.rs/cap-std/latest/cap_std/fs/struct.Dir.html+/// [`Dir::open_with`]: https://docs.rs/cap-std/latest/cap_std/fs/struct.Dir.html#method.open_with+///+/// <details>+/// We need to define our own version because the libstd `OpenOptions` doesn't+/// have public accessors that we can use.+/// </details>+#[derive(Debug, Clone)]+pub struct OpenOptions {+ pub(crate) read: bool,+ pub(crate) write: bool,+ pub(crate) append: bool,+ pub(crate) truncate: bool,+ pub(crate) create: bool,+ pub(crate) create_new: bool,+ pub(crate) dir_required: bool,+ #[cfg(windows)]+ pub(crate) maybe_dir: bool,+ pub(crate) sync: bool,+ pub(crate) dsync: bool,+ #[cfg(not(any(+ target_os = "ios",+ target_os = "macos",+ target_os = "tvos",+ target_os = "watchos",+ target_os = "visionos",+ target_os = "freebsd",+ target_os = "fuchsia",+ windows,+ )))]+ pub(crate) rsync: bool,+ #[cfg(not(windows))]+ pub(crate) nonblock: bool,+ pub(crate) readdir_required: bool,+ pub(crate) follow: FollowSymlinks,++ #[cfg(any(unix, windows, target_os = "vxworks"))]+ pub(crate) ext: ImplOpenOptionsExt,+}++impl OpenOptions {+ /// Creates a blank new set of options ready for configuration.+ ///+ /// This corresponds to [`std::fs::OpenOptions::new`].+ #[allow(clippy::new_without_default)]+ #[inline]+ pub const fn new() -> Self {+ Self {+ read: false,+ write: false,+ append: false,+ truncate: false,+ create: false,+ create_new: false,+ dir_required: false,+ #[cfg(windows)]+ maybe_dir: false,+ sync: false,+ dsync: false,+ #[cfg(not(any(+ target_os = "ios",+ target_os = "macos",+ target_os = "tvos",+ target_os = "watchos",+ target_os = "visionos",+ target_os = "freebsd",+ target_os = "fuchsia",+ windows,+ )))]+ rsync: false,+ #[cfg(not(windows))]+ nonblock: false,+ readdir_required: false,+ follow: FollowSymlinks::Yes,++ #[cfg(any(unix, windows, target_os = "vxworks"))]+ ext: ImplOpenOptionsExt::new(),+ }+ }++ /// Sets the option for read access.+ ///+ /// This corresponds to [`std::fs::OpenOptions::read`].+ #[inline]+ pub fn read(&mut self, read: bool) -> &mut Self {+ self.read = read;+ self+ }++ /// Sets the option for write access.+ ///+ /// This corresponds to [`std::fs::OpenOptions::write`].+ #[inline]+ pub fn write(&mut self, write: bool) -> &mut Self {+ self.write = write;+ self+ }++ /// Sets the option for truncating a previous file.+ ///+ /// This corresponds to [`std::fs::OpenOptions::truncate`].+ #[inline]+ pub fn truncate(&mut self, truncate: bool) -> &mut Self {+ self.truncate = truncate;+ self+ }++ /// Sets the option to create a new file.+ ///+ /// This corresponds to [`std::fs::OpenOptions::create`].+ #[inline]+ pub fn create(&mut self, create: bool) -> &mut Self {+ self.create = create;+ self+ }++ /// Sets the option to always create a new file.+ ///+ /// This corresponds to [`std::fs::OpenOptions::create_new`].+ #[inline]+ pub fn create_new(&mut self, create_new: bool) -> &mut Self {+ self.create_new = create_new;+ self+ }++ /// Sets the option to enable or suppress following of symlinks.+ #[inline]+ pub(crate) fn follow(&mut self, follow: FollowSymlinks) -> &mut Self {+ self.follow = follow;+ self+ }++ /// Sets the option to enable an error if the opened object is not a+ /// directory.+ #[inline]+ pub(crate) fn dir_required(&mut self, dir_required: bool) -> &mut Self {+ self.dir_required = dir_required;+ self+ }++ /// Sets the option to request the ability to read directory entries.+ #[inline]+ pub(crate) fn readdir_required(&mut self, readdir_required: bool) -> &mut Self {+ self.readdir_required = readdir_required;+ self+ }++ /// Wrapper to allow `follow` 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::OpenOptionsFollowExt` instead of calling+ /// this directly.+ #[doc(hidden)]+ #[inline]+ pub fn _cap_fs_ext_follow(&mut self, follow: FollowSymlinks) -> &mut Self {+ self.follow(follow)+ }+}++/// Unix-specific extensions to [`fs::OpenOptions`].+#[cfg(any(target_os = "linux", target_os = "android"))]+pub trait OpenOptionsExt {+ /// Pass custom flags to the `flags` argument of `open`.+ fn custom_flags(&mut self, flags: i32) -> &mut Self;+}++/// WASI-specific extensions to [`fs::OpenOptions`].+#[cfg(target_os = "wasi")]+pub trait OpenOptionsExt {+ /// Pass custom `dirflags` argument to `path_open`.+ fn lookup_flags(&mut self, flags: u32) -> &mut Self;++ /// Indicates whether `OpenOptions` must open a directory or not.+ fn directory(&mut self, dir: bool) -> &mut Self;++ /// Indicates whether `__WASI_FDFLAG_DSYNC` is passed in the `fs_flags`+ /// field of `path_open`.+ fn dsync(&mut self, dsync: bool) -> &mut Self;++ /// Indicates whether `__WASI_FDFLAG_NONBLOCK` is passed in the `fs_flags`+ /// field of `path_open`.+ fn nonblock(&mut self, nonblock: bool) -> &mut Self;++ /// Indicates whether `__WASI_FDFLAG_RSYNC` is passed in the `fs_flags`+ /// field of `path_open`.+ fn rsync(&mut self, rsync: bool) -> &mut Self;++ /// Indicates whether `__WASI_FDFLAG_SYNC` is passed in the `fs_flags`+ /// field of `path_open`.+ fn sync(&mut self, sync: bool) -> &mut Self;++ /// Indicates the value that should be passed in for the `fs_rights_base`+ /// parameter of `path_open`.+ fn fs_rights_base(&mut self, rights: u64) -> &mut Self;++ /// Indicates the value that should be passed in for the+ /// `fs_rights_inheriting` parameter of `path_open`.+ fn fs_rights_inheriting(&mut self, rights: u64) -> &mut Self;++ /// Open a file or directory.+ fn open_at<P: AsRef<std::path::Path>>(+ &self,+ file: &std::fs::File,+ path: P,+ ) -> std::io::Result<std::fs::File>;+}++/// Windows-specific extensions to [`fs::OpenOptions`].+#[cfg(windows)]+pub trait OpenOptionsExt {+ /// Overrides the `dwDesiredAccess` argument to the call to [`CreateFile`]+ /// with the specified value.+ fn access_mode(&mut self, access: u32) -> &mut Self;++ /// Overrides the `dwShareMode` argument to the call to [`CreateFile`] with+ /// the specified value.+ fn share_mode(&mut self, val: u32) -> &mut Self;++ /// Sets extra flags for the `dwFileFlags` argument to the call to+ /// [`CreateFile2`] to the specified value (or combines it with+ /// `attributes` and `security_qos_flags` to set the `dwFlagsAndAttributes`+ /// for [`CreateFile`]).+ ///+ /// [`CreateFile`]: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilea+ /// [`CreateFile2`]: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfile2+ fn custom_flags(&mut self, flags: u32) -> &mut Self;+}++#[cfg(any(target_os = "linux", target_os = "android"))]+impl OpenOptionsExt for OpenOptions {+ #[inline]+ fn custom_flags(&mut self, flags: i32) -> &mut Self {+ self.ext.custom_flags(flags);+ self+ }+}++#[cfg(target_os = "wasi")]+impl OpenOptionsExt for OpenOptions {+ fn lookup_flags(&mut self, _: u32) -> &mut Self {+ todo!()+ }++ fn directory(&mut self, dir_required: bool) -> &mut Self {+ self.dir_required = dir_required;+ self+ }++ fn dsync(&mut self, _: bool) -> &mut Self {+ todo!()+ }++ fn nonblock(&mut self, _: bool) -> &mut Self {+ todo!()+ }++ fn rsync(&mut self, _: bool) -> &mut Self {+ todo!()+ }++ fn sync(&mut self, _: bool) -> &mut Self {+ todo!()+ }++ fn fs_rights_base(&mut self, _: u64) -> &mut Self {+ todo!()+ }++ fn fs_rights_inheriting(&mut self, _: u64) -> &mut Self {+ todo!()+ }++ fn open_at<P>(&self, dirfd: &std::fs::File, path: P) -> Result<std::fs::File, std::io::Error>+ where+ P: AsRef<std::path::Path>,+ {+ crate::fs::open(dirfd, path.as_ref(), self)+ }+}++#[cfg(target_os = "vxworks")]+impl OpenOptionsExt for OpenOptions {+ #[inline]+ fn mode(&mut self, mode: u32) -> &mut Self {+ self.ext.mode(mode);+ self+ }++ #[inline]+ fn custom_flags(&mut self, flags: i32) -> &mut Self {+ self.ext.custom_flags(flags);+ self+ }+}++#[cfg(windows)]+impl OpenOptionsExt for OpenOptions {+ #[inline]+ fn access_mode(&mut self, access: u32) -> &mut Self {+ self.ext.access_mode(access);+ self+ }++ /// To prevent race conditions on Windows, handles for directories must be+ /// opened without `FILE_SHARE_DELETE`.+ #[inline]+ fn share_mode(&mut self, val: u32) -> &mut Self {+ self.ext.share_mode(val);+ self+ }++ #[inline]+ fn custom_flags(&mut self, flags: u32) -> &mut Self {+ self.ext.custom_flags(flags);+ self+ }+}diff --git a/crates/wasi/src/filesystem/primitives/open_unchecked_error.rs b/crates/wasi/src/filesystem/primitives/open_unchecked_error.rsnew file mode 100644index 0000000000..09ad9a6fca--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/open_unchecked_error.rs@@ -0,0 +1,37 @@+use std::io;++#[derive(Debug)]+pub(crate) enum OpenUncheckedError {+ Other(io::Error),+ Symlink(io::Error, SymlinkKind),+ NotFound(io::Error),+}++#[cfg(not(windows))]+pub(crate) type SymlinkKind = ();++#[cfg(windows)]+#[derive(Debug)]+pub(crate) enum SymlinkKind {+ File,+ Dir,+}++impl OpenUncheckedError {+ #[allow(dead_code)]+ pub(crate) fn kind(&self) -> io::ErrorKind {+ match self {+ Self::Other(err) | Self::Symlink(err, _) | Self::NotFound(err) => err.kind(),+ }+ }+}++impl From<OpenUncheckedError> for io::Error {+ fn from(error: OpenUncheckedError) -> Self {+ match error {+ OpenUncheckedError::Other(err)+ | OpenUncheckedError::Symlink(err, _)+ | OpenUncheckedError::NotFound(err) => err,+ }+ }+}diff --git a/crates/wasi/src/filesystem/primitives/read_dir.rs b/crates/wasi/src/filesystem/primitives/read_dir.rsnew file mode 100644index 0000000000..dd6fd0c07f--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/read_dir.rs@@ -0,0 +1,38 @@+use crate::filesystem::primitives::{DirEntry, ReadDirInner};+use std::{fmt, fs, io};++/// Like `read_dir` but operates on the base directory itself, rather than+/// on a path based on it.+#[inline]+pub fn read_base_dir(start: &fs::File) -> io::Result<ReadDir> {+ Ok(ReadDir {+ inner: ReadDirInner::read_base_dir(start)?,+ })+}++/// Iterator over the entries in a directory.+///+/// This corresponds to [`std::fs::ReadDir`].+///+/// There is no `from_std` method, as `std::fs::ReadDir` doesn't provide a way+/// to construct a `ReadDir` without opening directories by ambient paths.+pub struct ReadDir {+ pub(crate) inner: ReadDirInner,+}++impl Iterator for ReadDir {+ type Item = io::Result<DirEntry>;++ #[inline]+ fn next(&mut self) -> Option<Self::Item> {+ self.inner+ .next()+ .map(|inner| inner.map(|inner| DirEntry { inner }))+ }+}++impl fmt::Debug for ReadDir {+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {+ self.inner.fmt(f)+ }+}diff --git a/crates/wasi/src/filesystem/primitives/read_link.rs b/crates/wasi/src/filesystem/primitives/read_link.rsnew file mode 100644index 0000000000..9678ea08e1--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/read_link.rs@@ -0,0 +1,36 @@+//! This defines `read_link`, the primary entrypoint to sandboxed symbolic link+//! dereferencing.++use crate::filesystem::primitives::{errors, read_link_impl};+use std::path::{Path, PathBuf};+use std::{fs, io};++/// Perform a `readlinkat`-like operation, ensuring that the resolution of the+/// link path never escapes the directory tree rooted at `start`.+#[inline]+pub fn read_link_contents(start: &fs::File, path: &Path) -> io::Result<PathBuf> {+ // Call the underlying implementation.+ read_link_impl(start, path)+}++/// Perform a `readlinkat`-like operation, ensuring that the resolution of the+/// path never escapes the directory tree rooted at `start`, and also verifies+/// that the link target is not absolute.+#[inline]+pub fn read_link(start: &fs::File, path: &Path) -> io::Result<PathBuf> {+ // Call the underlying implementation.+ let result = read_link_contents(start, path);++ // Don't allow reading symlinks to absolute paths. This isn't strictly+ // necessary to preserve the sandbox, since `open` will refuse to follow+ // absolute paths in any case. However, it is useful to enforce this+ // restriction to avoid leaking information about the host filesystem+ // outside the sandbox.+ if let Ok(path) = &result {+ if path.has_root() {+ return Err(errors::escape_attempt());+ }+ }++ result+}diff --git a/crates/wasi/src/filesystem/primitives/remove_dir.rs b/crates/wasi/src/filesystem/primitives/remove_dir.rsnew file mode 100644index 0000000000..adb98caea2--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/remove_dir.rs@@ -0,0 +1,14 @@+//! This defines `remove_dir`, the primary entrypoint to sandboxed file+//! removal.++use crate::filesystem::primitives::remove_dir_impl;+use std::path::Path;+use std::{fs, io};++/// Perform a `rmdirat`-like operation, ensuring that the resolution of the+/// path never escapes the directory tree rooted at `start`.+#[inline]+pub fn remove_dir(start: &fs::File, path: &Path) -> io::Result<()> {+ // Call the underlying implementation.+ remove_dir_impl(start, path)+}diff --git a/crates/wasi/src/filesystem/primitives/remove_file.rs b/crates/wasi/src/filesystem/primitives/remove_file.rsnew file mode 100644index 0000000000..a678ea039b--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/remove_file.rs@@ -0,0 +1,14 @@+//! This defines `remove_file`, the primary entrypoint to sandboxed file+//! removal.++use crate::filesystem::primitives::remove_file_impl;+use std::path::Path;+use std::{fs, io};++/// Perform a `remove_fileat`-like operation, ensuring that the resolution of+/// the path never escapes the directory tree rooted at `start`.+#[inline]+pub fn remove_file(start: &fs::File, path: &Path) -> io::Result<()> {+ // Call the underlying implementation.+ remove_file_impl(start, path)+}diff --git a/crates/wasi/src/filesystem/primitives/rename.rs b/crates/wasi/src/filesystem/primitives/rename.rsnew file mode 100644index 0000000000..18ce6930c5--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rename.rs@@ -0,0 +1,19 @@+//! This defines `rename`, the primary entrypoint to sandboxed renaming.++use crate::filesystem::primitives::rename_impl;+use std::path::Path;+use std::{fs, io};++/// Perform a `renameat`-like operation, ensuring that the resolution of both+/// the old and new paths never escape the directory tree rooted at their+/// respective starts.+#[inline]+pub fn rename(+ old_start: &fs::File,+ old_path: &Path,+ new_start: &fs::File,+ new_path: &Path,+) -> io::Result<()> {+ // Call the underlying implementation.+ rename_impl(old_start, old_path, new_start, new_path)+}diff --git a/crates/wasi/src/filesystem/primitives/rustix/freebsd/fs/check.rs b/crates/wasi/src/filesystem/primitives/rustix/freebsd/fs/check.rsnew file mode 100644index 0000000000..6e7c706051--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/freebsd/fs/check.rs@@ -0,0 +1,40 @@+use rustix::cstr;+use rustix::fs::{AtFlags, CWD, Mode, OFlags, openat, statat};+use rustix::io::Errno;+use std::sync::atomic::{AtomicBool, Ordering::Relaxed};++static WORKING: AtomicBool = AtomicBool::new(false);+static CHECKED: AtomicBool = AtomicBool::new(false);++#[inline]+pub(crate) fn beneath_supported() -> bool {+ if WORKING.load(Relaxed) {+ return true;+ }+ if CHECKED.load(Relaxed) {+ return false;+ }+ check_beneath_supported()+}++#[cold]+fn check_beneath_supported() -> bool {+ // `RESOLVE_BENEATH` was introduced in FreeBSD 13, but opening `..` within+ // the root directory re-opened the root directory. In FreeBSD 14, it fails+ // as cap-std expects.+ if let Ok(root) = openat(+ CWD,+ cstr!("/"),+ OFlags::RDONLY | OFlags::CLOEXEC,+ Mode::empty(),+ ) {+ // Unknown O_ flags get ignored but AT_ flags have strict checks, so we use that.+ if let Err(Errno::NOTCAPABLE) = statat(root, cstr!(".."), AtFlags::RESOLVE_BENEATH) {+ WORKING.store(true, Relaxed);+ return true;+ }+ }++ CHECKED.store(true, Relaxed);+ false+}diff --git a/crates/wasi/src/filesystem/primitives/rustix/freebsd/fs/mod.rs b/crates/wasi/src/filesystem/primitives/rustix/freebsd/fs/mod.rsnew file mode 100644index 0000000000..dd8fcfc547--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/freebsd/fs/mod.rs@@ -0,0 +1,13 @@+mod check;+mod open_impl;+mod remove_dir_impl;+mod remove_file_impl;+mod set_times_impl;+mod stat_impl;++pub(crate) use check::beneath_supported;+pub(crate) use open_impl::open_impl;+pub(crate) use remove_dir_impl::remove_dir_impl;+pub(crate) use remove_file_impl::remove_file_impl;+pub(crate) use set_times_impl::{set_times_impl, set_times_nofollow_impl};+pub(crate) use stat_impl::stat_impl;diff --git a/crates/wasi/src/filesystem/primitives/rustix/freebsd/fs/open_impl.rs b/crates/wasi/src/filesystem/primitives/rustix/freebsd/fs/open_impl.rsnew file mode 100644index 0000000000..d29ce5b9f1--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/freebsd/fs/open_impl.rs@@ -0,0 +1,29 @@+use super::super::super::fs::compute_oflags;+use crate::filesystem::primitives::{OpenOptions, errors, manually};+use rustix::fs::{Mode, OFlags, RawMode, openat};+use std::path::Path;+use std::{fs, io};++pub(crate) fn open_impl(+ start: &fs::File,+ path: &Path,+ options: &OpenOptions,+) -> io::Result<fs::File> {+ if !super::beneath_supported() {+ return manually::open(start, path, options);+ }++ let oflags = compute_oflags(options)? | OFlags::RESOLVE_BENEATH;++ let mode = if oflags.contains(OFlags::CREATE) {+ Mode::from_bits((options.ext.mode & 0o7777) as RawMode).unwrap()+ } else {+ Mode::empty()+ };++ match openat(start, path, oflags, mode) {+ Ok(file) => Ok(file.into()),+ Err(rustix::io::Errno::NOTCAPABLE) => Err(errors::escape_attempt()),+ Err(err) => Err(err.into()),+ }+}diff --git a/crates/wasi/src/filesystem/primitives/rustix/freebsd/fs/remove_dir_impl.rs b/crates/wasi/src/filesystem/primitives/rustix/freebsd/fs/remove_dir_impl.rsnew file mode 100644index 0000000000..e4a440dbfb--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/freebsd/fs/remove_dir_impl.rs@@ -0,0 +1,16 @@+use crate::filesystem::primitives::via_parent;+use rustix::fs::{AtFlags, unlinkat};+use std::path::Path;+use std::{fs, io};++pub(crate) fn remove_dir_impl(start: &fs::File, path: &Path) -> io::Result<()> {+ if !super::beneath_supported() {+ return via_parent::remove_dir(start, path);+ }++ Ok(unlinkat(+ start,+ path,+ AtFlags::RESOLVE_BENEATH | AtFlags::REMOVEDIR,+ )?)+}diff --git a/crates/wasi/src/filesystem/primitives/rustix/freebsd/fs/remove_file_impl.rs b/crates/wasi/src/filesystem/primitives/rustix/freebsd/fs/remove_file_impl.rsnew file mode 100644index 0000000000..5c50e64097--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/freebsd/fs/remove_file_impl.rs@@ -0,0 +1,12 @@+use crate::filesystem::primitives::via_parent;+use rustix::fs::{AtFlags, unlinkat};+use std::path::Path;+use std::{fs, io};++pub(crate) fn remove_file_impl(start: &fs::File, path: &Path) -> io::Result<()> {+ if !super::beneath_supported() {+ return via_parent::remove_file(start, path);+ }++ Ok(unlinkat(start, path, AtFlags::RESOLVE_BENEATH)?)+}diff --git a/crates/wasi/src/filesystem/primitives/rustix/freebsd/fs/set_times_impl.rs b/crates/wasi/src/filesystem/primitives/rustix/freebsd/fs/set_times_impl.rsnew file mode 100644index 0000000000..d11303eb11--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/freebsd/fs/set_times_impl.rs@@ -0,0 +1,46 @@+use crate::filesystem::primitives::{to_timespec, via_parent};+use rustix::fs::{AtFlags, Timestamps, utimensat};+use std::path::Path;+use std::time::SystemTime;+use std::{fs, io};++pub(crate) fn set_times_impl(+ start: &fs::File,+ path: &Path,+ atime: Option<SystemTime>,+ mtime: Option<SystemTime>,+) -> io::Result<()> {+ if !super::beneath_supported() {+ return super::super::super::fs::set_times_manually(start, path, atime, mtime);+ }++ let times = Timestamps {+ last_access: to_timespec(atime)?,+ last_modification: to_timespec(mtime)?,+ };++ Ok(utimensat(start, path, ×, AtFlags::RESOLVE_BENEATH)?)+}++pub(crate) fn set_times_nofollow_impl(+ start: &fs::File,+ path: &Path,+ atime: Option<SystemTime>,+ mtime: Option<SystemTime>,+) -> io::Result<()> {+ if !super::beneath_supported() {+ return via_parent::set_times_nofollow(start, path, atime, mtime);+ }++ let times = Timestamps {+ last_access: to_timespec(atime)?,+ last_modification: to_timespec(mtime)?,+ };++ Ok(utimensat(+ start,+ path,+ ×,+ AtFlags::RESOLVE_BENEATH | AtFlags::SYMLINK_NOFOLLOW,+ )?)+}diff --git a/crates/wasi/src/filesystem/primitives/rustix/freebsd/fs/stat_impl.rs b/crates/wasi/src/filesystem/primitives/rustix/freebsd/fs/stat_impl.rsnew file mode 100644index 0000000000..1299360118--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/freebsd/fs/stat_impl.rs@@ -0,0 +1,22 @@+use crate::filesystem::primitives::{FollowSymlinks, ImplMetadataExt, Metadata, manually};+use rustix::fs::{AtFlags, statat};+use std::path::Path;+use std::{fs, io};++pub(crate) fn stat_impl(+ start: &fs::File,+ path: &Path,+ follow: FollowSymlinks,+) -> io::Result<Metadata> {+ if !super::beneath_supported() {+ return manually::stat(start, path, follow);+ }++ let flags = AtFlags::RESOLVE_BENEATH+ | if follow == FollowSymlinks::Yes {+ AtFlags::empty()+ } else {+ AtFlags::SYMLINK_NOFOLLOW+ };+ Ok(ImplMetadataExt::from_rustix(statat(start, path, flags)?))+}diff --git a/crates/wasi/src/filesystem/primitives/rustix/freebsd/mod.rs b/crates/wasi/src/filesystem/primitives/rustix/freebsd/mod.rsnew file mode 100644index 0000000000..aabc2afc5a--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/freebsd/mod.rs@@ -0,0 +1 @@+pub(crate) mod fs;diff --git a/crates/wasi/src/filesystem/primitives/rustix/fs/create_dir_unchecked.rs b/crates/wasi/src/filesystem/primitives/rustix/fs/create_dir_unchecked.rsnew file mode 100644index 0000000000..246bed20da--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/fs/create_dir_unchecked.rs@@ -0,0 +1,19 @@+use crate::filesystem::primitives::DirOptions;+use rustix::fs::{Mode, RawMode, mkdirat};+use std::path::Path;+use std::{fs, io};++/// *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,+) -> io::Result<()> {+ #[cfg(not(target_os = "wasi"))]+ let raw_mode = options.ext.mode as RawMode;+ #[cfg(target_os = "wasi")]+ let raw_mode = 0;++ Ok(mkdirat(start, path, Mode::from_bits(raw_mode).unwrap())?)+}diff --git a/crates/wasi/src/filesystem/primitives/rustix/fs/cvt.rs b/crates/wasi/src/filesystem/primitives/rustix/fs/cvt.rsnew file mode 100644index 0000000000..a6aa15b35f--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/fs/cvt.rs@@ -0,0 +1,19 @@+use std::io;++#[allow(dead_code)]+pub(crate) fn cvt_i32(t: i32) -> io::Result<i32> {+ if t == -1 {+ Err(io::Error::last_os_error())+ } else {+ Ok(t)+ }+}++#[allow(dead_code)]+pub(crate) fn cvt_i64(t: i64) -> io::Result<i64> {+ if t == -1 {+ Err(io::Error::last_os_error())+ } else {+ Ok(t)+ }+}diff --git a/crates/wasi/src/filesystem/primitives/rustix/fs/dir_entry_inner.rs b/crates/wasi/src/filesystem/primitives/rustix/fs/dir_entry_inner.rsnew file mode 100644index 0000000000..450f6df688--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/fs/dir_entry_inner.rs@@ -0,0 +1,41 @@+use crate::filesystem::primitives::{Metadata, ReadDirInner};+use rustix::fs::DirEntry;+use std::ffi::{OsStr, OsString};+#[cfg(unix)]+use std::os::unix::ffi::OsStrExt;+#[cfg(target_os = "wasi")]+use std::os::wasi::ffi::OsStrExt;+use std::{fmt, io};++pub(crate) struct DirEntryInner {+ pub(super) rustix: DirEntry,+ pub(super) read_dir: ReadDirInner,+}++impl DirEntryInner {+ #[inline]+ pub(crate) fn metadata(&self) -> io::Result<Metadata> {+ self.read_dir.metadata(self.file_name_bytes())+ }++ #[inline]+ pub(crate) fn file_name(&self) -> OsString {+ self.file_name_bytes().to_os_string()+ }++ #[inline]+ pub(crate) fn ino(&self) -> u64 {+ self.rustix.ino()+ }++ fn file_name_bytes(&self) -> &OsStr {+ OsStr::from_bytes(self.rustix.file_name().to_bytes())+ }+}++impl fmt::Debug for DirEntryInner {+ // Like libstd's version, but doesn't print the path.+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {+ f.debug_tuple("DirEntry").field(&self.file_name()).finish()+ }+}diff --git a/crates/wasi/src/filesystem/primitives/rustix/fs/dir_options_ext.rs b/crates/wasi/src/filesystem/primitives/rustix/fs/dir_options_ext.rsnew file mode 100644index 0000000000..474d6aea40--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/fs/dir_options_ext.rs@@ -0,0 +1,14 @@+#[derive(Debug, Clone)]+pub(crate) struct DirOptionsExt {+ pub(super) mode: u32,+}++impl DirOptionsExt {+ pub(crate) const fn new() -> Self {+ Self {+ // The default value; see+ // <https://doc.rust-lang.org/std/os/unix/fs/trait.DirBuilderExt.html#tymethod.mode>+ mode: 0o777,+ }+ }+}diff --git a/crates/wasi/src/filesystem/primitives/rustix/fs/dir_utils.rs b/crates/wasi/src/filesystem/primitives/rustix/fs/dir_utils.rsnew file mode 100644index 0000000000..078b7042f2--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/fs/dir_utils.rs@@ -0,0 +1,212 @@+use crate::filesystem::primitives::OpenOptions;+use rustix::fs::OFlags;+use std::ffi::{OsStr, OsString};+use std::ops::Deref;+#[cfg(unix)]+use std::os::unix::{+ ffi::{OsStrExt, OsStringExt},+ fs::OpenOptionsExt,+};+#[cfg(target_os = "wasi")]+use std::os::wasi::{+ ffi::{OsStrExt, OsStringExt},+ fs::OpenOptionsExt,+};+use std::path::{Path, PathBuf};+use std::{fs, io};++/// Rust's `Path` implicitly strips redundant slashes, however they aren't+/// redundant in one case: at the end of a path they indicate that a path is+/// expected to name a directory.+pub(crate) fn path_requires_dir(path: &Path) -> bool {+ let bytes = path.as_os_str().as_bytes();++ // If a path ends with '/' or '.', it's a directory. These aren't the only+ // cases, but they are the only cases that Rust's `Path` implicitly+ // normalizes away.+ bytes.ends_with(b"/") || bytes.ends_with(b"/.")+}++/// Rust's `Path` implicitly strips trailing `.` components, however they+/// aren't redundant in one case: at the end of a path they are the final path+/// component, which has different path lookup behavior.+pub(crate) fn path_has_trailing_dot(path: &Path) -> bool {+ let mut bytes = path.as_os_str().as_bytes();++ // If a path ends with '.' followed by any number of '/'s, it's a trailing dot.+ while let Some((last, rest)) = bytes.split_last() {+ if *last == b'/' {+ bytes = rest;+ } else {+ break;+ }+ }++ bytes.ends_with(b"/.") || bytes == b"."+}++/// Rust's `Path` implicitly strips trailing `/`s, however they aren't+/// redundant in one case: at the end of a path they are the final path+/// component, which has different path lookup behavior.+pub(crate) fn path_has_trailing_slash(path: &Path) -> bool {+ let bytes = path.as_os_str().as_bytes();++ bytes.ends_with(b"/")+}++/// Append a trailing `/`. This can be used to require that the given `path`+/// names a directory.+pub(crate) fn append_dir_suffix(path: PathBuf) -> PathBuf {+ let mut bytes = path.into_os_string().into_vec();+ bytes.push(b'/');+ OsString::from_vec(bytes).into()+}++/// Strip trailing `/`s, unless this reduces `path` to `/` itself. This is+/// 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();+ while bytes.len() > 1 && *bytes.last().unwrap() == b'/' {+ bytes = &bytes[..bytes.len() - 1];+ }+ OsStr::from_bytes(bytes).as_ref()+}++/// Return an `OpenOptions` for opening directories.+pub(crate) fn dir_options() -> OpenOptions {+ OpenOptions::new().read(true).dir_required(true).clone()+}++/// Like `dir_options`, but additionally request the ability to read the+/// directory entries.+pub(crate) fn readdir_options() -> OpenOptions {+ OpenOptions::new()+ .read(true)+ .dir_required(true)+ .readdir_required(true)+ .clone()+}++/// Open a directory named by a bare path, using the host process' ambient+/// authority.+///+/// # Ambient Authority+///+/// This function is not sandboxed and may trivially access any path that the+/// host process has access to.+pub(crate) fn open_ambient_dir_impl(path: &Path) -> io::Result<fs::File> {+ let mut options = fs::OpenOptions::new();+ options.read(true);++ // This is for `std::fs`, so we don't have `dir_required`, so set+ // `O_DIRECTORY` manually.+ options.custom_flags((OFlags::DIRECTORY | target_o_path()).bits() as i32);++ options.open(path)+}++/// Use `O_PATH` on platforms which have it, or none otherwise.+#[inline]+pub(crate) const fn target_o_path() -> OFlags {+ #[cfg(any(+ target_os = "android",+ target_os = "emscripten",+ target_os = "freebsd",+ target_os = "fuchsia",+ target_os = "linux",+ target_os = "redox",+ ))]+ {+ OFlags::PATH+ }++ #[cfg(any(+ target_os = "dragonfly",+ target_os = "ios",+ target_os = "macos",+ target_os = "tvos",+ target_os = "watchos",+ target_os = "visionos",+ target_os = "netbsd",+ target_os = "openbsd",+ target_os = "wasi",+ target_os = "illumos",+ target_os = "solaris",+ ))]+ {+ OFlags::empty()+ }+}++#[test]+fn strip_dir_suffix_tests() {+ assert_eq!(&*strip_dir_suffix(Path::new("/foo//")), Path::new("/foo"));+ assert_eq!(&*strip_dir_suffix(Path::new("/foo/")), Path::new("/foo"));+ assert_eq!(&*strip_dir_suffix(Path::new("foo/")), Path::new("foo"));+ assert_eq!(&*strip_dir_suffix(Path::new("foo")), Path::new("foo"));+ assert_eq!(&*strip_dir_suffix(Path::new("/")), Path::new("/"));+ assert_eq!(&*strip_dir_suffix(Path::new("//")), Path::new("/"));+ assert_eq!(&*strip_dir_suffix(Path::new("/.")), Path::new("/."));+ assert_eq!(&*strip_dir_suffix(Path::new("//.")), Path::new("/."));+ assert_eq!(&*strip_dir_suffix(Path::new(".")), Path::new("."));+ assert_eq!(&*strip_dir_suffix(Path::new("foo/.")), Path::new("foo/."));+}++#[test]+fn test_path_requires_dir() {+ assert!(!path_requires_dir(Path::new(".")));+ assert!(path_requires_dir(Path::new("/")));+ assert!(path_requires_dir(Path::new("//")));+ assert!(path_requires_dir(Path::new("/./.")));+ assert!(path_requires_dir(Path::new("foo/")));+ assert!(path_requires_dir(Path::new("foo//")));+ assert!(path_requires_dir(Path::new("foo//.")));+ assert!(path_requires_dir(Path::new("foo/./.")));+ assert!(path_requires_dir(Path::new("foo/./")));+ assert!(path_requires_dir(Path::new("foo/.//")));+}++#[test]+fn test_path_has_trailing_dot() {+ assert!(!path_has_trailing_dot(Path::new("foo")));+ assert!(!path_has_trailing_dot(Path::new("foo.")));++ assert!(!path_has_trailing_dot(Path::new("/./foo")));+ assert!(!path_has_trailing_dot(Path::new("..")));+ assert!(!path_has_trailing_dot(Path::new("/..")));++ assert!(!path_has_trailing_dot(Path::new("/")));+ assert!(!path_has_trailing_dot(Path::new("//")));+ assert!(!path_has_trailing_dot(Path::new("foo//")));+ assert!(!path_has_trailing_dot(Path::new("foo/")));++ assert!(path_has_trailing_dot(Path::new(".")));++ assert!(path_has_trailing_dot(Path::new("/./.")));+ assert!(path_has_trailing_dot(Path::new("foo//.")));+ assert!(path_has_trailing_dot(Path::new("foo/./.")));+ assert!(path_has_trailing_dot(Path::new("foo/./")));+ assert!(path_has_trailing_dot(Path::new("foo/.//")));+}++#[test]+fn test_path_has_trailing_slash() {+ assert!(path_has_trailing_slash(Path::new("/")));+ assert!(path_has_trailing_slash(Path::new("//")));+ assert!(path_has_trailing_slash(Path::new("foo//")));+ assert!(path_has_trailing_slash(Path::new("foo/")));+ assert!(path_has_trailing_slash(Path::new("foo/./")));+ assert!(path_has_trailing_slash(Path::new("foo/.//")));++ assert!(!path_has_trailing_slash(Path::new("foo")));+ assert!(!path_has_trailing_slash(Path::new("foo.")));+ assert!(!path_has_trailing_slash(Path::new("/./foo")));+ assert!(!path_has_trailing_slash(Path::new("..")));+ assert!(!path_has_trailing_slash(Path::new("/..")));+ assert!(!path_has_trailing_slash(Path::new(".")));+ assert!(!path_has_trailing_slash(Path::new("/./.")));+ assert!(!path_has_trailing_slash(Path::new("foo//.")));+ assert!(!path_has_trailing_slash(Path::new("foo/./.")));+}diff --git a/crates/wasi/src/filesystem/primitives/rustix/fs/errors.rs b/crates/wasi/src/filesystem/primitives/rustix/fs/errors.rsnew file mode 100644index 0000000000..203fa11496--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/fs/errors.rs@@ -0,0 +1,21 @@+use std::io;++#[cold]+pub(crate) fn no_such_file_or_directory() -> io::Error {+ rustix::io::Errno::NOENT.into()+}++#[cold]+pub(crate) fn is_directory() -> io::Error {+ rustix::io::Errno::ISDIR.into()+}++#[cold]+pub(crate) fn is_not_directory() -> io::Error {+ rustix::io::Errno::NOTDIR.into()+}++#[cold]+pub(crate) fn too_many_symlinks() -> io::Error {+ rustix::io::Errno::LOOP.into()+}diff --git a/crates/wasi/src/filesystem/primitives/rustix/fs/file_type_ext.rs b/crates/wasi/src/filesystem/primitives/rustix/fs/file_type_ext.rsnew file mode 100644index 0000000000..72504cc1b4--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/fs/file_type_ext.rs@@ -0,0 +1,114 @@+use crate::filesystem::primitives::FileType;+use rustix::fs::RawMode;+use std::{fs, io};++/// A type that implements `FileTypeExt` for this platform.+#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]+pub(crate) enum ImplFileTypeExt {+ Symlink,+ BlockDevice,+ CharDevice,+ Fifo,+ Socket,+}++impl ImplFileTypeExt {+ /// Constructs a new instance of `FileType` from the given+ /// [`std::fs::File`] and [`std::fs::FileType`].+ #[inline]+ #[allow(clippy::unnecessary_wraps)]+ pub(crate) fn from(_file: &fs::File, metadata: &fs::Metadata) -> io::Result<FileType> {+ // On `rustix`-style platforms, the `Metadata` has everything we need.+ Ok(Self::from_just_metadata(metadata))+ }++ /// Constructs a new instance of `FileType` from the given+ /// [`std::fs::Metadata`].+ #[inline]+ pub(crate) fn from_just_metadata(metadata: &fs::Metadata) -> FileType {+ let std = metadata.file_type();+ Self::from_std(std)+ }++ /// Constructs a new instance of `Self` from the given+ /// [`std::fs::FileType`].+ #[inline]+ pub(crate) fn from_std(std: fs::FileType) -> FileType {+ use rustix::fs::FileTypeExt;+ if std.is_file() {+ FileType::file()+ } else if std.is_dir() {+ FileType::dir()+ } else if std.is_symlink() {+ FileType::ext(Self::Symlink)+ } else if std.is_block_device() {+ FileType::ext(Self::BlockDevice)+ } else if std.is_char_device() {+ FileType::ext(Self::CharDevice)+ } else {+ #[cfg(not(target_os = "wasi"))]+ if std.is_fifo() {+ return FileType::ext(Self::Fifo);+ }+ #[cfg(not(target_os = "wasi"))]+ if std.is_socket() {+ return FileType::ext(Self::Socket);+ }+ FileType::unknown()+ }+ }++ /// Constructs a new instance of `FileType` from the given+ /// [`RawMode`].+ #[inline]+ pub(crate) const fn from_raw_mode(mode: RawMode) -> FileType {+ match rustix::fs::FileType::from_raw_mode(mode) {+ rustix::fs::FileType::RegularFile => FileType::file(),+ rustix::fs::FileType::Directory => FileType::dir(),+ rustix::fs::FileType::Symlink => FileType::ext(Self::symlink()),+ #[cfg(not(target_os = "wasi"))]+ rustix::fs::FileType::Fifo => FileType::ext(Self::fifo()),+ rustix::fs::FileType::CharacterDevice => FileType::ext(Self::char_device()),+ rustix::fs::FileType::BlockDevice => FileType::ext(Self::block_device()),+ #[cfg(not(target_os = "wasi"))]+ rustix::fs::FileType::Socket => FileType::ext(Self::socket()),+ _ => FileType::unknown(),+ }+ }++ /// Creates a `FileType` for which `is_symlink()` returns `true`.+ #[inline]+ pub(crate) const fn symlink() -> Self {+ Self::Symlink+ }++ /// Creates a `FileType` for which `is_block_device()` returns `true`.+ #[inline]+ pub(crate) const fn block_device() -> Self {+ Self::BlockDevice+ }++ /// Creates a `FileType` for which `is_char_device()` returns `true`.+ #[inline]+ pub(crate) const fn char_device() -> Self {+ Self::CharDevice+ }++ /// Creates a `FileType` for which `is_fifo()` returns `true`.+ #[inline]+ pub(crate) const fn fifo() -> Self {+ Self::Fifo+ }++ /// Creates a `FileType` for which `is_socket()` returns `true`.+ #[inline]+ pub(crate) const fn socket() -> Self {+ Self::Socket+ }++ /// Tests whether this file type represents a symbolic link.+ #[inline]+ pub(crate) fn is_symlink(&self) -> bool {+ *self == Self::Symlink+ }+}diff --git a/crates/wasi/src/filesystem/primitives/rustix/fs/hard_link_unchecked.rs b/crates/wasi/src/filesystem/primitives/rustix/fs/hard_link_unchecked.rsnew file mode 100644index 0000000000..7b280797b9--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/fs/hard_link_unchecked.rs@@ -0,0 +1,24 @@+use rustix::fs::{AtFlags, linkat};+use std::path::Path;+use std::{fs, io};++/// *Unsandboxed* function similar to `hard_link`, but which does not perform+/// sandboxing.+///+/// Even though POSIX `linkat` has the ability to follow symlinks in+/// `old_path`, using `AT_SYMLINK_FOLLOW`, Rust's `hard_link` doesn't need+/// that, so we don't expose it here.+pub(crate) fn hard_link_unchecked(+ old_start: &fs::File,+ old_path: &Path,+ new_start: &fs::File,+ new_path: &Path,+) -> io::Result<()> {+ Ok(linkat(+ old_start,+ old_path,+ new_start,+ new_path,+ AtFlags::empty(),+ )?)+}diff --git a/crates/wasi/src/filesystem/primitives/rustix/fs/is_same_file.rs b/crates/wasi/src/filesystem/primitives/rustix/fs/is_same_file.rsnew file mode 100644index 0000000000..dc74f1d99c--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/fs/is_same_file.rs@@ -0,0 +1,33 @@+use crate::filesystem::primitives::{Metadata, MetadataExt};+use std::{fs, io};++/// Determine if `a` and `b` refer to the same inode on the same device.+pub(crate) fn is_same_file(a: &fs::File, b: &fs::File) -> io::Result<bool> {+ let a_metadata = Metadata::from_file(a)?;+ let b_metadata = Metadata::from_file(b)?;+ is_same_file_metadata(&a_metadata, &b_metadata)+}++/// Determine if `a` and `b` are metadata for the same inode on the same+/// device.+pub(crate) fn is_same_file_metadata(a: &Metadata, b: &Metadata) -> io::Result<bool> {+ Ok(a.dev() == b.dev() && a.ino() == b.ino())+}++/// Determine if `a` and `b` definitely refer to different inodes.+///+/// This is similar to `is_same_file`, but is conservative, and doesn't depend+/// on nightly-only features.+#[allow(dead_code)]+pub(crate) fn is_different_file(a: &fs::File, b: &fs::File) -> io::Result<bool> {+ is_same_file(a, b).map(|same| !same)+}++/// Determine if `a` and `b` are metadata for definitely different inodes.+///+/// This is similar to `is_same_file_metadata`, but is conservative, and+/// doesn't depend on nightly-only features.+#[allow(dead_code)]+pub(crate) fn is_different_file_metadata(a: &Metadata, b: &Metadata) -> io::Result<bool> {+ is_same_file_metadata(a, b).map(|same| !same)+}diff --git a/crates/wasi/src/filesystem/primitives/rustix/fs/metadata_ext.rs b/crates/wasi/src/filesystem/primitives/rustix/fs/metadata_ext.rsnew file mode 100644index 0000000000..8e4400ebf9--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/fs/metadata_ext.rs@@ -0,0 +1,181 @@+#![allow(clippy::useless_conversion)]++use crate::filesystem::primitives::{ImplFileTypeExt, Metadata};+use rustix::fs::{RawMode, Stat};+#[cfg(target_os = "linux")]+use rustix::fs::{Statx, StatxFlags, makedev};+use std::time::{Duration, SystemTime};+use std::{fs, io};++#[derive(Debug, Clone)]+pub(crate) struct ImplMetadataExt {+ dev: u64,+ ino: u64,+ nlink: u64,+}++impl ImplMetadataExt {+ /// Constructs a new instance of `Self` from the given [`std::fs::File`]+ /// and [`std::fs::Metadata`].+ #[inline]+ #[allow(clippy::unnecessary_wraps)]+ pub(crate) fn from(_file: &fs::File, std: &fs::Metadata) -> io::Result<Self> {+ // On `rustix`-style platforms, the `Metadata` has everything we need.+ Ok(Self::from_just_metadata(std))+ }++ /// Constructs a new instance of `Self` from the given+ /// [`std::fs::Metadata`].+ #[inline]+ pub(crate) fn from_just_metadata(std: &fs::Metadata) -> Self {+ use rustix::fs::MetadataExt;+ Self {+ dev: std.dev(),+ ino: std.ino(),+ nlink: std.nlink(),+ }+ }++ /// Constructs a new instance of `Metadata` from the given `Stat`.+ #[inline]+ #[allow(unused_comparisons)] // NB: rust-lang/rust#115823 requires this here instead of on `st_dev` processing below+ pub(crate) fn from_rustix(stat: Stat) -> Metadata {+ Metadata {+ file_type: ImplFileTypeExt::from_raw_mode(stat.st_mode as RawMode),+ len: u64::try_from(stat.st_size).unwrap(),++ #[cfg(not(target_os = "wasi"))]+ modified: system_time_from_rustix(+ stat.st_mtime.try_into().unwrap(),+ stat.st_mtime_nsec as _,+ ),+ #[cfg(not(target_os = "wasi"))]+ accessed: system_time_from_rustix(+ stat.st_atime.try_into().unwrap(),+ stat.st_atime_nsec as _,+ ),++ #[cfg(target_os = "wasi")]+ modified: system_time_from_rustix(stat.st_mtim.tv_sec, stat.st_mtim.tv_nsec as _),+ #[cfg(target_os = "wasi")]+ accessed: system_time_from_rustix(stat.st_atim.tv_sec, stat.st_atim.tv_nsec as _),++ #[cfg(any(+ target_os = "freebsd",+ target_os = "openbsd",+ target_os = "netbsd",+ target_os = "macos",+ target_os = "ios",+ target_os = "tvos",+ target_os = "watchos",+ target_os = "visionos",+ ))]+ created: system_time_from_rustix(+ stat.st_birthtime.try_into().unwrap(),+ stat.st_birthtime_nsec as _,+ ),++ // `stat.st_ctime` is the latest status change; we want the creation.+ #[cfg(not(any(+ target_os = "freebsd",+ target_os = "openbsd",+ target_os = "macos",+ target_os = "ios",+ target_os = "tvos",+ target_os = "watchos",+ target_os = "visionos",+ target_os = "netbsd"+ )))]+ created: None,++ ext: Self {+ // The type of `st_dev` is `dev_t` which is signed on some+ // platforms and unsigned on other platforms. A `u64` is enough+ // to work for all unsigned platforms, and for signed platforms+ // perform a sign extension to `i64` and then view that as an+ // unsigned 64-bit number instead.+ //+ // Note that the `unused_comparisons` is ignored here for+ // platforms where it's unsigned since the first branch here+ // will never be taken.+ dev: if stat.st_dev < 0 {+ i64::try_from(stat.st_dev).unwrap() as u64+ } else {+ u64::try_from(stat.st_dev).unwrap()+ },+ ino: stat.st_ino.into(),+ nlink: u64::from(stat.st_nlink),+ },+ }+ }++ /// Constructs a new instance of `Metadata` from the given `Statx`.+ #[cfg(target_os = "linux")]+ #[inline]+ pub(crate) fn from_rustix_statx(statx: Statx) -> Metadata {+ Metadata {+ file_type: ImplFileTypeExt::from_raw_mode(RawMode::from(statx.stx_mode)),+ len: u64::try_from(statx.stx_size).unwrap(),+ modified: if statx.stx_mask & StatxFlags::MTIME.bits() != 0 {+ system_time_from_rustix(statx.stx_mtime.tv_sec, statx.stx_mtime.tv_nsec as _)+ } else {+ None+ },+ accessed: if statx.stx_mask & StatxFlags::ATIME.bits() != 0 {+ system_time_from_rustix(statx.stx_atime.tv_sec, statx.stx_atime.tv_nsec as _)+ } else {+ None+ },+ created: if statx.stx_mask & StatxFlags::BTIME.bits() != 0 {+ system_time_from_rustix(statx.stx_btime.tv_sec, statx.stx_btime.tv_nsec as _)+ } else {+ None+ },++ ext: Self {+ dev: makedev(statx.stx_dev_major, statx.stx_dev_minor),+ ino: statx.stx_ino.into(),+ nlink: u64::from(statx.stx_nlink),+ },+ }+ }+}++#[allow(clippy::similar_names)]+fn system_time_from_rustix(sec: i64, nsec: u64) -> Option<SystemTime> {+ if sec >= 0 {+ SystemTime::UNIX_EPOCH.checked_add(Duration::new(u64::try_from(sec).unwrap(), nsec as _))+ } else {+ SystemTime::UNIX_EPOCH+ .checked_sub(Duration::new(sec.unsigned_abs(), 0))+ .map(|t| t.checked_add(Duration::new(0, nsec as u32)))+ .flatten()+ }+}++impl crate::filesystem::primitives::MetadataExt for ImplMetadataExt {+ #[inline]+ fn dev(&self) -> u64 {+ self.dev+ }++ #[inline]+ fn ino(&self) -> u64 {+ self.ino+ }++ #[inline]+ fn nlink(&self) -> u64 {+ self.nlink+ }+}++/// It should be possible to represent times before the Epoch.+/// https://github.com/bytecodealliance/cap-std/issues/328+#[test]+fn negative_time() {+ let system_time = system_time_from_rustix(-1, 1).unwrap();+ let d = SystemTime::UNIX_EPOCH.duration_since(system_time).unwrap();+ assert_eq!(d.as_secs(), 0);+ assert_eq!(d.subsec_nanos(), 999999999);+}diff --git a/crates/wasi/src/filesystem/primitives/rustix/fs/mod.rs b/crates/wasi/src/filesystem/primitives/rustix/fs/mod.rsnew file mode 100644index 0000000000..df34362c94--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/fs/mod.rs@@ -0,0 +1,87 @@+mod create_dir_unchecked;+mod dir_entry_inner;+#[cfg(not(target_os = "wasi"))]+mod dir_options_ext;+mod dir_utils;+mod file_type_ext;+mod hard_link_unchecked;+mod is_same_file;+mod metadata_ext;+mod oflags;+mod open_options_ext;+mod open_unchecked;+mod read_dir_inner;+mod read_link_unchecked;+mod remove_dir_unchecked;+mod remove_file_unchecked;+mod rename_unchecked;+#[cfg(not(any(target_os = "android", target_os = "linux")))]+mod set_times_impl;+mod stat_unchecked;+mod symlink_unchecked;+mod times;++pub(crate) mod errors;++// On Linux, use optimized implementations based on+// `openat2` and `O_PATH` when available.+//+// On FreeBSD, use optimized implementations based on+// `O_RESOLVE_BENEATH`/`AT_RESOLVE_BENEATH` and `O_PATH` when available.+#[cfg(target_os = "freebsd")]+pub(crate) use crate::filesystem::primitives::rustix::freebsd::fs::*;+#[cfg(any(target_os = "android", target_os = "linux"))]+pub(crate) use crate::filesystem::primitives::rustix::linux::fs::*;+#[cfg(not(any(target_os = "android", target_os = "linux", target_os = "freebsd")))]+#[rustfmt::skip]+pub(crate) use crate::filesystem::primitives::{+ manually::open as open_impl,+ manually::stat as stat_impl,+ via_parent::set_times_nofollow as set_times_nofollow_impl,+};+#[cfg(not(any(target_os = "android", target_os = "linux", target_os = "freebsd")))]+pub(crate) use set_times_impl::set_times_impl;+#[cfg(target_os = "freebsd")]+pub(crate) use set_times_impl::set_times_impl as set_times_manually;+#[rustfmt::skip]+pub(crate) use crate::filesystem::primitives::{+ via_parent::hard_link as hard_link_impl,+ via_parent::create_dir as create_dir_impl,+ via_parent::read_link as read_link_impl,+ via_parent::rename as rename_impl,+ via_parent::symlink as symlink_impl,+};+#[cfg(not(target_os = "freebsd"))]+#[rustfmt::skip]+pub(crate) use crate::filesystem::primitives::{+ via_parent::remove_dir as remove_dir_impl,+ via_parent::remove_file as remove_file_impl,+};++pub(crate) use create_dir_unchecked::create_dir_unchecked;+pub(crate) use dir_entry_inner::DirEntryInner;+#[cfg(not(target_os = "wasi"))]+pub(crate) use dir_options_ext::DirOptionsExt;+pub(crate) use dir_utils::*;+pub(crate) use file_type_ext::ImplFileTypeExt;+pub(crate) use hard_link_unchecked::hard_link_unchecked;+#[allow(unused_imports)]+pub(crate) use is_same_file::{is_different_file, is_different_file_metadata, is_same_file};+pub(crate) use metadata_ext::ImplMetadataExt;+pub(crate) use open_options_ext::ImplOpenOptionsExt;+pub(crate) use open_unchecked::open_unchecked;+pub(crate) use read_dir_inner::ReadDirInner;+pub(crate) use read_link_unchecked::read_link_unchecked;+pub(crate) use remove_dir_unchecked::remove_dir_unchecked;+pub(crate) use remove_file_unchecked::remove_file_unchecked;+pub(crate) use rename_unchecked::rename_unchecked;+pub(crate) use stat_unchecked::stat_unchecked;+pub(crate) use symlink_unchecked::symlink_unchecked;+#[allow(unused_imports)]+pub(crate) use times::{set_times_follow_unchecked, set_times_nofollow_unchecked, to_timespec};++// On Linux, there is a limit of 40 symlink expansions.+// Source: <https://man7.org/linux/man-pages/man7/path_resolution.7.html>+pub(crate) const MAX_SYMLINK_EXPANSIONS: u8 = 40;++pub(super) use oflags::*;diff --git a/crates/wasi/src/filesystem/primitives/rustix/fs/oflags.rs b/crates/wasi/src/filesystem/primitives/rustix/fs/oflags.rsnew file mode 100644index 0000000000..9953d015b9--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/fs/oflags.rs@@ -0,0 +1,101 @@+use crate::filesystem::primitives::{FollowSymlinks, OpenOptions, target_o_path};+use rustix::fs::OFlags;+use std::io;++pub(in super::super) fn compute_oflags(options: &OpenOptions) -> io::Result<OFlags> {+ let mut oflags = OFlags::CLOEXEC;+ oflags |= get_access_mode(options)?;+ oflags |= get_creation_mode(options)?;+ if options.follow == FollowSymlinks::No {+ oflags |= OFlags::NOFOLLOW;+ }+ if options.sync {+ oflags |= OFlags::SYNC;+ }+ if options.dsync {+ #[cfg(not(target_os = "freebsd"))]+ {+ oflags |= OFlags::DSYNC;+ }++ // Where needed, approximate `DSYNC` with `SYNC`.+ #[cfg(target_os = "freebsd")]+ {+ oflags |= OFlags::SYNC;+ }+ }+ #[cfg(not(any(+ target_os = "ios",+ target_os = "macos",+ target_os = "tvos",+ target_os = "watchos",+ target_os = "visionos",+ target_os = "freebsd",+ target_os = "fuchsia"+ )))]+ if options.rsync {+ oflags |= OFlags::RSYNC;+ }+ if options.nonblock {+ oflags |= OFlags::NONBLOCK;+ }+ if options.dir_required {+ oflags |= OFlags::DIRECTORY;++ // If the target has `O_PATH`, we don't need to read the directory+ // entries, and we're not requesting write access (which need to+ // fail on a directory), use it.+ if !options.readdir_required && !options.write && !options.append {+ oflags |= target_o_path();+ }+ }+ // Use `RWMODE` here instead of `ACCMODE` so that we preserve the `O_PATH`+ // flag.+ #[cfg(not(target_os = "wasi"))]+ {+ oflags |= OFlags::from_bits(options.ext.custom_flags as _).expect("unrecognized OFlags")+ & !OFlags::RWMODE;+ }+ Ok(oflags)+}++// `OpenOptions` translation code derived from Rust's+// library/std/src/sys/unix/fs.rs at revision+// 108e90ca78f052c0c1c49c42a22c85620be19712.++pub(crate) fn get_access_mode(options: &OpenOptions) -> io::Result<OFlags> {+ match (options.read, options.write, options.append) {+ (true, false, false) => Ok(OFlags::RDONLY),+ (false, true, false) => Ok(OFlags::WRONLY),+ (true, true, false) => Ok(OFlags::RDWR),+ (false, _, true) => Ok(OFlags::WRONLY | OFlags::APPEND),+ (true, _, true) => Ok(OFlags::RDWR | OFlags::APPEND),+ (false, false, false) => Err(rustix::io::Errno::INVAL.into()),+ }+}++pub(crate) fn get_creation_mode(options: &OpenOptions) -> io::Result<OFlags> {+ match (options.write, options.append) {+ (true, false) => {}+ (false, false) => {+ if options.truncate || options.create || options.create_new {+ return Err(rustix::io::Errno::INVAL.into());+ }+ }+ (_, true) => {+ if options.truncate && !options.create_new {+ return Err(rustix::io::Errno::INVAL.into());+ }+ }+ }++ Ok(+ match (options.create, options.truncate, options.create_new) {+ (false, false, false) => OFlags::empty(),+ (true, false, false) => OFlags::CREATE,+ (false, true, false) => OFlags::TRUNC,+ (true, true, false) => OFlags::CREATE | OFlags::TRUNC,+ (_, _, true) => OFlags::CREATE | OFlags::EXCL,+ },+ )+}diff --git a/crates/wasi/src/filesystem/primitives/rustix/fs/open_options_ext.rs b/crates/wasi/src/filesystem/primitives/rustix/fs/open_options_ext.rsnew file mode 100644index 0000000000..dc457f11e4--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/fs/open_options_ext.rs@@ -0,0 +1,20 @@+#[derive(Debug, Clone)]+pub(crate) struct ImplOpenOptionsExt {+ pub(crate) mode: u32,+ pub(crate) custom_flags: i32,+}++impl ImplOpenOptionsExt {+ pub(crate) const fn new() -> Self {+ Self {+ mode: 0o666,+ custom_flags: 0,+ }+ }++ #[cfg(any(target_os = "linux", target_os = "android"))]+ pub(crate) fn custom_flags(&mut self, flags: i32) -> &mut Self {+ self.custom_flags = flags;+ self+ }+}diff --git a/crates/wasi/src/filesystem/primitives/rustix/fs/open_unchecked.rs b/crates/wasi/src/filesystem/primitives/rustix/fs/open_unchecked.rsnew file mode 100644index 0000000000..5e429f8c3d--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/fs/open_unchecked.rs@@ -0,0 +1,57 @@+use super::compute_oflags;+use crate::filesystem::primitives::{OpenOptions, OpenUncheckedError, stat_unchecked};+use rustix::fs::{Mode, openat};+use rustix::io;+use std::fs;+use std::path::Path;++/// *Unsandboxed* function similar to `open`, but which does not perform+/// sandboxing.+pub(crate) fn open_unchecked(+ start: &fs::File,+ path: &Path,+ options: &OpenOptions,+) -> Result<fs::File, OpenUncheckedError> {+ let oflags = compute_oflags(options).map_err(OpenUncheckedError::Other)?;++ #[allow(clippy::useless_conversion)]+ #[cfg(not(target_os = "wasi"))]+ let mode = Mode::from_bits_truncate(options.ext.mode as _);+ #[cfg(target_os = "wasi")]+ let mode = Mode::empty();++ let err = match openat(start, path, oflags, mode) {+ Ok(file) => {+ return Ok(fs::File::from(file));+ }+ Err(err) => err,+ };+ match err {+ // `ELOOP` is the POSIX standard and most widely used error code to+ // indicate that a symlink was found when `O_NOFOLLOW` was set.+ #[cfg(not(any(target_os = "freebsd", target_os = "dragonfly", target_os = "netbsd")))]+ io::Errno::LOOP => Err(OpenUncheckedError::Symlink(err.into(), ())),++ // FreeBSD and similar (but not Darwin) use `EMLINK`.+ #[cfg(any(target_os = "freebsd", target_os = "dragonfly"))]+ io::Errno::MLINK => Err(OpenUncheckedError::Symlink(err.into(), ())),++ // NetBSD uses `EFTYPE`.+ #[cfg(target_os = "netbsd")]+ io::Errno::FTYPE => Err(OpenUncheckedError::Symlink(err.into(), ())),++ io::Errno::NOENT => Err(OpenUncheckedError::NotFound(err.into())),+ io::Errno::NOTDIR => {+ if options.dir_required+ && stat_unchecked(start, path, options.follow)+ .map(|m| m.file_type().is_symlink())+ .unwrap_or(false)+ {+ Err(OpenUncheckedError::Symlink(err.into(), ()))+ } else {+ Err(OpenUncheckedError::NotFound(err.into()))+ }+ }+ _ => Err(OpenUncheckedError::Other(err.into())),+ }+}diff --git a/crates/wasi/src/filesystem/primitives/rustix/fs/read_dir_inner.rs b/crates/wasi/src/filesystem/primitives/rustix/fs/read_dir_inner.rsnew file mode 100644index 0000000000..558189b2c9--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/fs/read_dir_inner.rs@@ -0,0 +1,87 @@+use crate::filesystem::primitives::{+ DirEntryInner, FollowSymlinks, Metadata, open_dir_for_reading_unchecked, stat_unchecked,+};+use rustix::fd::{AsFd, OwnedFd};+use rustix::fs::Dir;+use std::ffi::OsStr;+use std::mem::ManuallyDrop;+use std::os::fd::{AsRawFd, FromRawFd, RawFd};+#[cfg(unix)]+use std::os::unix::ffi::OsStrExt;+#[cfg(target_os = "wasi")]+use std::os::wasi::ffi::OsStrExt;+use std::path::Component;+use std::sync::{Arc, Mutex};+use std::{fmt, fs, io};++pub(crate) struct ReadDirInner {+ raw_fd: RawFd,++ // `Dir` doesn't implement `AsFd`, because libc `fdopendir` has UB if the+ // file descriptor is used in almost any way, so we hold a separate+ // `OwnedFd` that we can do `as_fd()` on.+ rustix: Arc<Mutex<(Dir, OwnedFd)>>,+}++impl ReadDirInner {+ pub(crate) fn read_base_dir(start: &fs::File) -> io::Result<Self> {+ // Open ".", to obtain a new independent file descriptor. Don't use+ // `dup` since in that case the resulting file descriptor would share+ // a current position with the original, and `read_dir` calls after+ // the first `read_dir` call wouldn't start from the beginning.+ let fd =+ open_dir_for_reading_unchecked(start, Component::CurDir.as_ref(), FollowSymlinks::No)?;+ let dir = Dir::read_from(fd.as_fd())?;+ Ok(Self {+ raw_fd: fd.as_fd().as_raw_fd(),+ rustix: Arc::new(Mutex::new((dir, fd.into()))),+ })+ }++ pub(super) fn metadata(&self, file_name: &OsStr) -> io::Result<Metadata> {+ stat_unchecked(&self.as_file_view(), file_name.as_ref(), FollowSymlinks::No)+ }++ #[allow(unsafe_code)]+ fn as_file_view(&self) -> ManuallyDrop<fs::File> {+ // Safety: `self.rustix` owns the file descriptor. We just hold a+ // copy outside so that we can read it without taking a lock.+ ManuallyDrop::new(unsafe { fs::File::from_raw_fd(self.raw_fd) })+ }+}++impl Iterator for ReadDirInner {+ type Item = io::Result<DirEntryInner>;++ fn next(&mut self) -> Option<Self::Item> {+ loop {+ let entry = self.rustix.lock().unwrap().0.read()?;+ let entry = match entry {+ Ok(entry) => entry,+ Err(e) => return Some(Err(e.into())),+ };+ let file_name = entry.file_name().to_bytes();+ if file_name != Component::CurDir.as_os_str().as_bytes()+ && file_name != Component::ParentDir.as_os_str().as_bytes()+ {+ let clone = Arc::clone(&self.rustix);+ return Some(Ok(DirEntryInner {+ rustix: entry,+ read_dir: Self {+ raw_fd: self.raw_fd,+ rustix: clone,+ },+ }));+ }+ }+ }+}++impl fmt::Debug for ReadDirInner {+ // Like libstd's version, but doesn't print the path.+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {+ let mut b = f.debug_struct("ReadDir");+ b.field("raw_fd", &self.raw_fd);+ b.finish()+ }+}diff --git a/crates/wasi/src/filesystem/primitives/rustix/fs/read_link_unchecked.rs b/crates/wasi/src/filesystem/primitives/rustix/fs/read_link_unchecked.rsnew file mode 100644index 0000000000..08ef42dac1--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/fs/read_link_unchecked.rs@@ -0,0 +1,19 @@+use rustix::fs::readlinkat;+use std::ffi::OsString;+#[cfg(unix)]+use std::os::unix::ffi::OsStringExt;+#[cfg(target_os = "wasi")]+use std::os::wasi::ffi::OsStringExt;+use std::path::{Path, PathBuf};+use std::{fs, io};++/// *Unsandboxed* function similar to `read_link`, but which does not perform+/// sandboxing.+pub(crate) fn read_link_unchecked(+ start: &fs::File,+ path: &Path,+ reuse: PathBuf,+) -> io::Result<PathBuf> {+ Ok(readlinkat(start, path, reuse.into_os_string().into_vec())+ .map(|path| OsString::from_vec(path.into_bytes()).into())?)+}diff --git a/crates/wasi/src/filesystem/primitives/rustix/fs/remove_dir_unchecked.rs b/crates/wasi/src/filesystem/primitives/rustix/fs/remove_dir_unchecked.rsnew file mode 100644index 0000000000..6106566847--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/fs/remove_dir_unchecked.rs@@ -0,0 +1,9 @@+use rustix::fs::{AtFlags, unlinkat};+use std::path::Path;+use std::{fs, io};++/// *Unsandboxed* function similar to `remove_dir`, but which does not perform+/// sandboxing.+pub(crate) fn remove_dir_unchecked(start: &fs::File, path: &Path) -> io::Result<()> {+ Ok(unlinkat(start, path, AtFlags::REMOVEDIR)?)+}diff --git a/crates/wasi/src/filesystem/primitives/rustix/fs/remove_file_unchecked.rs b/crates/wasi/src/filesystem/primitives/rustix/fs/remove_file_unchecked.rsnew file mode 100644index 0000000000..3b1adaa1a0--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/fs/remove_file_unchecked.rs@@ -0,0 +1,9 @@+use rustix::fs::{AtFlags, unlinkat};+use std::path::Path;+use std::{fs, io};++/// *Unsandboxed* function similar to `remove_file`, but which does not perform+/// sandboxing.+pub(crate) fn remove_file_unchecked(start: &fs::File, path: &Path) -> io::Result<()> {+ Ok(unlinkat(start, path, AtFlags::empty())?)+}diff --git a/crates/wasi/src/filesystem/primitives/rustix/fs/rename_unchecked.rs b/crates/wasi/src/filesystem/primitives/rustix/fs/rename_unchecked.rsnew file mode 100644index 0000000000..a929ebb1ad--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/fs/rename_unchecked.rs@@ -0,0 +1,14 @@+use rustix::fs::renameat;+use std::path::Path;+use std::{fs, io};++/// *Unsandboxed* function similar to `rename`, but which does not perform+/// sandboxing.+pub(crate) fn rename_unchecked(+ old_start: &fs::File,+ old_path: &Path,+ new_start: &fs::File,+ new_path: &Path,+) -> io::Result<()> {+ Ok(renameat(old_start, old_path, new_start, new_path)?)+}diff --git a/crates/wasi/src/filesystem/primitives/rustix/fs/set_times_impl.rs b/crates/wasi/src/filesystem/primitives/rustix/fs/set_times_impl.rsnew file mode 100644index 0000000000..4e7363c50d--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/fs/set_times_impl.rs@@ -0,0 +1,52 @@+//! This module consists of helper types and functions for dealing+//! with setting the file times.++use crate::filesystem::primitives::{OpenOptions, open};+use rustix::io::Errno;+use std::path::Path;+use std::time::SystemTime;+use std::{fs, io};++pub(crate) fn set_times_impl(+ start: &fs::File,+ path: &Path,+ atime: Option<SystemTime>,+ mtime: Option<SystemTime>,+) -> io::Result<()> {+ let mut times = fs::FileTimes::new();+ if let Some(atime) = atime {+ times = times.set_accessed(atime);+ }+ if let Some(mtime) = mtime {+ times = times.set_modified(mtime);+ }+ // Try `futimens` with a normal handle. Normal handles need some kind of+ // access, so first try write.+ match open(start, path, OpenOptions::new().write(true)) {+ Ok(file) => return fs::File::from(file).set_times(times),+ Err(err) => match Errno::from_io_error(&err) {+ Some(Errno::ACCESS) | Some(Errno::ISDIR) => (),+ _ => return Err(err),+ },+ }++ // Next try read.+ match open(start, path, OpenOptions::new().read(true)) {+ Ok(file) => return fs::File::from(file).set_times(times),+ Err(err) => match Errno::from_io_error(&err) {+ Some(Errno::ACCESS) => (),+ _ => return Err(err),+ },+ }++ // It's not possible to do anything else with generic POSIX. Plain+ // `utimensat` has two options:+ // - Follow symlinks, which would open up a race in which a concurrent+ // modification of the symlink could point outside the sandbox and we+ // wouldn't be able to detect it, or+ // - Don't follow symlinks, which would modify the timestamp of the symlink+ // instead of the file we're trying to get to.+ //+ // So neither does what we need.+ Err(Errno::NOTSUP.into())+}diff --git a/crates/wasi/src/filesystem/primitives/rustix/fs/stat_unchecked.rs b/crates/wasi/src/filesystem/primitives/rustix/fs/stat_unchecked.rsnew file mode 100644index 0000000000..25bf59a620--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/fs/stat_unchecked.rs@@ -0,0 +1,79 @@+use crate::filesystem::primitives::{FollowSymlinks, ImplMetadataExt, Metadata};+use rustix::fs::{AtFlags, statat};+use std::path::Path;+use std::{fs, io};++#[cfg(target_os = "linux")]+use rustix::fs::{StatxFlags, statx};+#[cfg(target_os = "linux")]+use std::sync::atomic::{AtomicU8, Ordering};++/// *Unsandboxed* function similar to `stat`, but which does not perform+/// sandboxing.+pub(crate) fn stat_unchecked(+ start: &fs::File,+ path: &Path,+ follow: FollowSymlinks,+) -> io::Result<Metadata> {+ let atflags = match follow {+ FollowSymlinks::Yes => AtFlags::empty(),+ FollowSymlinks::No => AtFlags::SYMLINK_NOFOLLOW,+ };++ // `statx` is preferred on regular Linux because it can return creation+ // times. Linux kernels prior to 4.11 don't have `statx` and return+ // `ENOSYS`. Older versions of Docker/seccomp would return `EPERM` for+ // `statx`; see <https://github.com/rust-lang/rust/pull/65685/>. We store+ // the availability in a global to avoid unnecessary syscalls.+ //+ // On Android, the [seccomp policy] prevents us from even+ // detecting whether `statx` is supported, so don't even try.+ //+ // [seccomp policy]: https://android-developers.googleblog.com/2017/07/seccomp-filter-in-android-o.html+ #[cfg(target_os = "linux")]+ {+ // 0: Unknown+ // 1: Not available+ // 2: Available+ static STATX_STATE: AtomicU8 = AtomicU8::new(0);+ let state = STATX_STATE.load(Ordering::Relaxed);++ if state != 1 {+ let statx_result = statx(+ start,+ path,+ atflags,+ StatxFlags::BASIC_STATS | StatxFlags::BTIME,+ );+ match statx_result {+ Ok(statx) => {+ if state == 0 {+ STATX_STATE.store(2, Ordering::Relaxed);+ }+ return Ok(ImplMetadataExt::from_rustix_statx(statx));+ }+ Err(rustix::io::Errno::NOSYS) => STATX_STATE.store(1, Ordering::Relaxed),+ Err(rustix::io::Errno::PERM) if state == 0 => {+ // This is an unlikely case, as `statx` doesn't normally+ // return `PERM` errors. One way this can happen is when+ // running on old versions of seccomp/Docker. If `statx` on+ // the current working directory returns a similar error,+ // then stop using `statx`.+ if let Err(rustix::io::Errno::PERM) = statx(+ rustix::fs::CWD,+ "",+ AtFlags::EMPTY_PATH,+ StatxFlags::empty(),+ ) {+ STATX_STATE.store(1, Ordering::Relaxed);+ } else {+ return Err(rustix::io::Errno::PERM.into());+ }+ }+ Err(e) => return Err(e.into()),+ }+ }+ }++ Ok(statat(start, path, atflags).map(ImplMetadataExt::from_rustix)?)+}diff --git a/crates/wasi/src/filesystem/primitives/rustix/fs/symlink_unchecked.rs b/crates/wasi/src/filesystem/primitives/rustix/fs/symlink_unchecked.rsnew file mode 100644index 0000000000..bdd9141289--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/fs/symlink_unchecked.rs@@ -0,0 +1,13 @@+use rustix::fs::symlinkat;+use std::path::Path;+use std::{fs, io};++/// *Unsandboxed* function similar to `symlink`, but which does not perform+/// sandboxing.+pub(crate) fn symlink_unchecked(+ old_path: &Path,+ new_start: &fs::File,+ new_path: &Path,+) -> io::Result<()> {+ Ok(symlinkat(old_path, new_start, new_path)?)+}diff --git a/crates/wasi/src/filesystem/primitives/rustix/fs/times.rs b/crates/wasi/src/filesystem/primitives/rustix/fs/times.rsnew file mode 100644index 0000000000..b3253e94c4--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/fs/times.rs@@ -0,0 +1,57 @@+use rustix::fs::{AtFlags, Timestamps, UTIME_NOW, UTIME_OMIT, utimensat};+use rustix::time::Timespec;+use std::os::fd::BorrowedFd;+use std::path::Path;+use std::time::SystemTime;+use std::{fs, io};++#[allow(clippy::useless_conversion)]+pub(crate) fn to_timespec(ft: Option<SystemTime>) -> io::Result<Timespec> {+ Ok(match ft {+ None => Timespec {+ tv_sec: 0,+ tv_nsec: UTIME_OMIT.into(),+ },+ Some(ft) => {+ let duration = ft.duration_since(SystemTime::UNIX_EPOCH).unwrap();+ let nanoseconds = duration.subsec_nanos();+ assert_ne!(i64::from(nanoseconds), i64::from(UTIME_OMIT));+ assert_ne!(i64::from(nanoseconds), i64::from(UTIME_NOW));+ Timespec {+ tv_sec: duration+ .as_secs()+ .try_into()+ .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?,+ tv_nsec: nanoseconds.try_into().unwrap(),+ }+ }+ })+}++#[allow(dead_code)]+pub(crate) fn set_times_nofollow_unchecked(+ start: &fs::File,+ path: &Path,+ atime: Option<SystemTime>,+ mtime: Option<SystemTime>,+) -> io::Result<()> {+ let times = Timestamps {+ last_access: to_timespec(atime)?,+ last_modification: to_timespec(mtime)?,+ };+ Ok(utimensat(start, path, ×, AtFlags::SYMLINK_NOFOLLOW)?)+}++#[allow(dead_code)]+pub(crate) fn set_times_follow_unchecked(+ start: BorrowedFd<'_>,+ path: &Path,+ atime: Option<SystemTime>,+ mtime: Option<SystemTime>,+) -> io::Result<()> {+ let times = Timestamps {+ last_access: to_timespec(atime)?,+ last_modification: to_timespec(mtime)?,+ };+ Ok(utimensat(start, path, ×, AtFlags::empty())?)+}diff --git a/crates/wasi/src/filesystem/primitives/rustix/linux/fs/file_metadata.rs b/crates/wasi/src/filesystem/primitives/rustix/linux/fs/file_metadata.rsnew file mode 100644index 0000000000..b02b95c3b7--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/linux/fs/file_metadata.rs@@ -0,0 +1,27 @@+use crate::filesystem::primitives::{ImplMetadataExt, Metadata};+use rustix::fs::{AtFlags, statat};+use std::sync::atomic::AtomicBool;+use std::sync::atomic::Ordering::Relaxed;+use std::{fs, io};++/// Like `file.metadata()`, but works with `O_PATH` descriptors on old (pre+/// 3.6) versions of Linux too.+pub(super) fn file_metadata(file: &fs::File) -> io::Result<Metadata> {+ // Record whether we've seen an `EBADF` from an `fstat` on an `O_PATH`+ // file descriptor, meaning we're on a Linux that doesn't support it.+ static FSTAT_PATH_BADF: AtomicBool = AtomicBool::new(false);++ if !FSTAT_PATH_BADF.load(Relaxed) {+ match Metadata::from_file(file) {+ Ok(metadata) => return Ok(metadata),+ Err(err) => match rustix::io::Errno::from_io_error(&err) {+ // Before Linux 3.6, `fstat` with `O_PATH` returned `EBADF`.+ Some(rustix::io::Errno::BADF) => FSTAT_PATH_BADF.store(true, Relaxed),+ _ => return Err(err),+ },+ }+ }++ // If `fstat` with `O_PATH` isn't supported, use `statat` with `AT_EMPTY_PATH`.+ Ok(statat(file, "", AtFlags::EMPTY_PATH).map(ImplMetadataExt::from_rustix)?)+}diff --git a/crates/wasi/src/filesystem/primitives/rustix/linux/fs/mod.rs b/crates/wasi/src/filesystem/primitives/rustix/linux/fs/mod.rsnew file mode 100644index 0000000000..300e5a7714--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/linux/fs/mod.rs@@ -0,0 +1,21 @@+#[cfg(target_os = "linux")]+mod file_metadata;+mod open_impl;+mod procfs;+mod set_times_impl;+#[cfg(target_os = "linux")]+mod stat_impl;++#[cfg(target_os = "android")]+pub(crate) use crate::filesystem::primitives::manually::stat as stat_impl;+pub(crate) use crate::filesystem::primitives::via_parent::set_times_nofollow as set_times_nofollow_impl;+#[cfg(target_os = "linux")]+pub(crate) use open_impl::open_beneath;+pub(crate) use open_impl::open_impl;+pub(crate) use set_times_impl::set_times_impl;+#[cfg(target_os = "linux")]+pub(crate) use stat_impl::stat_impl;++// In theory we could optimize `link` using `openat2` with `O_PATH` and+// `linkat` with `AT_EMPTY_PATH`, however that requires `CAP_DAC_READ_SEARCH`,+// so it isn't very widely applicable.diff --git a/crates/wasi/src/filesystem/primitives/rustix/linux/fs/open_impl.rs b/crates/wasi/src/filesystem/primitives/rustix/linux/fs/open_impl.rsnew file mode 100644index 0000000000..0cd20cdde9--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/linux/fs/open_impl.rs@@ -0,0 +1,126 @@+//! Linux 5.6 and later have a syscall `openat2`, with flags that allow it to+//! enforce the sandboxing property we want. See the [LWN article] for an+//! overview and the [`openat2` documentation] for details.+//!+//! [LWN article]: https://lwn.net/Articles/796868/+//! [`openat2` documentation]: https://man7.org/linux/man-pages/man2/openat2.2.html+//!+//! On older Linux, fall back to `manually::open`.++use crate::filesystem::primitives::{OpenOptions, manually};+use std::path::Path;+use std::{fs, io};+#[cfg(target_os = "linux")]+use {+ super::super::super::fs::compute_oflags,+ crate::filesystem::primitives::errors,+ rustix::fs::{Mode, OFlags, RawMode, ResolveFlags, openat2},+ rustix::path::Arg,+ std::sync::atomic::AtomicBool,+ std::sync::atomic::Ordering::Relaxed,+};++/// Call the `openat2` system call, or use a fallback if that's unavailable.+pub(crate) fn open_impl(+ start: &fs::File,+ path: &Path,+ options: &OpenOptions,+) -> io::Result<fs::File> {+ // On regular Linux, attempt to use `openat2` to accelerate sandboxed+ // lookups. On Android, the [seccomp policy] prevents us from even+ // detecting whether `openat2` is supported, so don't even try.+ //+ // [seccomp policy]: https://android-developers.googleblog.com/2017/07/seccomp-filter-in-android-o.html+ #[cfg(target_os = "linux")]+ {+ let result = open_beneath(start, path, options);++ // If we got anything other than a `ENOSYS` error, that's our result.+ match result {+ Err(err) if err.raw_os_error() == Some(rustix::io::Errno::NOSYS.raw_os_error()) => {}+ Err(err) => return Err(err),+ Ok(fd) => return Ok(fd),+ }+ }++ manually::open(start, path, options)+}++/// Call the `openat2` system call with `RESOLVE_BENEATH`. If the syscall is+/// unavailable, mark it so for future calls. If `openat2` is unavailable+/// either permanently or temporarily, return `ENOSYS`.+#[cfg(target_os = "linux")]+pub(crate) fn open_beneath(+ start: &fs::File,+ path: &Path,+ options: &OpenOptions,+) -> io::Result<fs::File> {+ static INVALID: AtomicBool = AtomicBool::new(false);+ if INVALID.load(Relaxed) {+ // `openat2` is permanently unavailable.+ return Err(rustix::io::Errno::NOSYS.into());+ }++ let oflags = compute_oflags(options)?;++ // Do two `contains` checks because `TMPFILE` may be represented with+ // multiple flags and we need to ensure they're all set.+ let mode = if oflags.contains(OFlags::CREATE) || oflags.contains(OFlags::TMPFILE) {+ Mode::from_bits((options.ext.mode & 0o7777) as RawMode).unwrap()+ } else {+ Mode::empty()+ };++ // We know `openat2` needs a `&CStr` internally; to avoid allocating on+ // each iteration of the loop below, allocate the `CString` now.+ path.into_with_c_str(|path_c_str| {+ // `openat2` fails with `EAGAIN` if a rename happens anywhere on the host+ // while it's running, so use a loop to retry it a few times. But not too many+ // times, because there's no limit on how often this can happen. The actual+ // number here is currently an arbitrarily chosen guess.+ for _ in 0..4 {+ match openat2(+ start,+ path_c_str,+ oflags,+ mode,+ ResolveFlags::BENEATH | ResolveFlags::NO_MAGICLINKS,+ ) {+ Ok(file) => {+ let file = fs::File::from(file);++ return Ok(file);+ }+ Err(err) => match err {+ // A rename or similar happened. Try again.+ rustix::io::Errno::AGAIN => continue,++ // `EPERM` is used by some `seccomp` sandboxes to indicate+ // that `openat2` is unimplemented:+ // <https://github.com/systemd/systemd/blob/e2357b1c8a87b610066b8b2a59517bcfb20b832e/src/shared/seccomp-util.c#L2066>+ //+ // However, `EPERM` may also indicate a failed `O_NOATIME`+ // or a file seal prevented the operation, and it's complex+ // to detect those cases, so exit the loop and use the+ // fallback.+ rustix::io::Errno::PERM => break,++ // `ENOSYS` means `openat2` is permanently unavailable;+ // mark it so and exit the loop.+ rustix::io::Errno::NOSYS => {+ INVALID.store(true, Relaxed);+ break;+ }++ _ => return Err(err),+ },+ }+ }++ Err(rustix::io::Errno::NOSYS)+ })+ .map_err(|err| match err {+ rustix::io::Errno::XDEV => errors::escape_attempt(),+ err => err.into(),+ })+}diff --git a/crates/wasi/src/filesystem/primitives/rustix/linux/fs/procfs.rs b/crates/wasi/src/filesystem/primitives/rustix/linux/fs/procfs.rsnew file mode 100644index 0000000000..3fba32fadf--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/linux/fs/procfs.rs@@ -0,0 +1,43 @@+//! Utilities for working with `/proc`, where Linux's `procfs` is typically+//! mounted. `/proc` serves as an adjunct to Linux's main syscall surface area,+//! providing additional features with an awkward interface.+//!+//! This module does a considerable amount of work to determine whether `/proc`+//! is mounted, with actual `procfs`, and without any additional mount points+//! on top of the paths we open.++use crate::filesystem::primitives::OpenOptionsExt;+use crate::filesystem::primitives::{OpenOptions, open, set_times_follow_unchecked};+use rustix::fd::AsFd;+use rustix::fs::OFlags;+use rustix::path::DecInt;+use rustix_linux_procfs::proc_self_fd;+use std::path::Path;+use std::time::SystemTime;+use std::{fs, io};++pub(crate) fn set_times_through_proc_self_fd(+ start: &fs::File,+ path: &Path,+ atime: Option<SystemTime>,+ mtime: Option<SystemTime>,+) -> io::Result<()> {+ let opath = open(+ start,+ path,+ OpenOptions::new()+ .read(true)+ .custom_flags(OFlags::PATH.bits() as i32),+ )?;++ // Don't pass `AT_SYMLINK_NOFOLLOW`, because we do actually want to follow+ // the first symlink. We don't want to follow any subsequent symlinks, but+ // omitting `O_NOFOLLOW` above ensures that the destination of the link+ // isn't a symlink.+ set_times_follow_unchecked(+ proc_self_fd()?.as_fd(),+ DecInt::from_fd(&opath).as_ref(),+ atime,+ mtime,+ )+}diff --git a/crates/wasi/src/filesystem/primitives/rustix/linux/fs/set_times_impl.rs b/crates/wasi/src/filesystem/primitives/rustix/linux/fs/set_times_impl.rsnew file mode 100644index 0000000000..9372ce2353--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/linux/fs/set_times_impl.rs@@ -0,0 +1,44 @@+//! This module consists of helper types and functions for dealing+//! with setting the file times specific to Linux.++use super::procfs::set_times_through_proc_self_fd;+use crate::filesystem::primitives::{OpenOptions, open};+use std::path::Path;+use std::time::SystemTime;+use std::{fs, io};++pub(crate) fn set_times_impl(+ start: &fs::File,+ path: &Path,+ atime: Option<SystemTime>,+ mtime: Option<SystemTime>,+) -> io::Result<()> {+ let mut times = fs::FileTimes::new();+ if let Some(atime) = atime {+ times = times.set_accessed(atime);+ }+ if let Some(mtime) = mtime {+ times = times.set_modified(mtime);+ }+ // Try `futimens` with a normal handle. Normal handles need some kind of+ // access, so first try write.+ match open(start, path, OpenOptions::new().write(true)) {+ Ok(file) => return file.set_times(times),+ Err(err) => match rustix::io::Errno::from_io_error(&err) {+ Some(rustix::io::Errno::ACCESS) | Some(rustix::io::Errno::ISDIR) => (),+ _ => return Err(err),+ },+ }++ // Next try read.+ match open(start, path, OpenOptions::new().read(true)) {+ Ok(file) => return file.set_times(times),+ Err(err) => match rustix::io::Errno::from_io_error(&err) {+ Some(rustix::io::Errno::ACCESS) => (),+ _ => return Err(err),+ },+ }++ // If neither of those worked, turn to `/proc`.+ set_times_through_proc_self_fd(start, path, atime, mtime)+}diff --git a/crates/wasi/src/filesystem/primitives/rustix/linux/fs/stat_impl.rs b/crates/wasi/src/filesystem/primitives/rustix/linux/fs/stat_impl.rsnew file mode 100644index 0000000000..01a6e09a5f--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/linux/fs/stat_impl.rs@@ -0,0 +1,58 @@+//! Linux has an `O_PATH` flag which allows opening a file without necessary+//! having read or write access to it; we can use that with `openat2` and+//! `fstat` to perform a fast sandboxed `stat`.++use super::file_metadata::file_metadata;+use crate::filesystem::primitives::{+ FollowSymlinks, Metadata, OpenOptions, manually, open_beneath,+};+use rustix::fs::OFlags;+use std::path::Path;+use std::{fs, io};++/// Use `openat2` with `O_PATH` and `fstat`. If that's not available, fallback+/// to `manually::stat`.+pub(crate) fn stat_impl(+ start: &fs::File,+ path: &Path,+ follow: FollowSymlinks,+) -> io::Result<Metadata> {+ use crate::filesystem::primitives::{OpenOptionsExt, stat_unchecked};+ use std::path::Component;++ // Optimization: if path has exactly one component and it's not ".." or+ // anything non-normal and we're not following symlinks we can go straight+ // to `stat_unchecked`, which is faster than doing an open with a separate+ // `fstat`.+ if follow == FollowSymlinks::No {+ let mut components = path.components();+ if let Some(Component::Normal(component)) = components.next() {+ if components.next().is_none() {+ return stat_unchecked(start, component.as_ref(), FollowSymlinks::No);+ }+ }+ }++ // Open the path with `O_PATH`. Use `read(true)` even though we don't need+ // `read` permissions, because Rust's libstd requires an access mode, and+ // Linux ignores `O_RDONLY` with `O_PATH`.+ let result = open_beneath(+ start,+ path,+ OpenOptions::new()+ .read(true)+ .follow(follow)+ .custom_flags(OFlags::PATH.bits() as i32),+ );++ // If that worked, call `fstat`.+ match result {+ Ok(file) => file_metadata(&file),+ Err(err) => match rustix::io::Errno::from_io_error(&err) {+ // `ENOSYS` from `open_beneath` means `openat2` is unavailable+ // and we should use a fallback.+ Some(rustix::io::Errno::NOSYS) => manually::stat(start, path, follow),+ _ => Err(err),+ },+ }+}diff --git a/crates/wasi/src/filesystem/primitives/rustix/linux/mod.rs b/crates/wasi/src/filesystem/primitives/rustix/linux/mod.rsnew file mode 100644index 0000000000..3ddb2c3266--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/linux/mod.rs@@ -0,0 +1,6 @@+//! Following [`std`], we don't carry workarounds for Linux versions+//! older than 2.6.32.+//!+//! [`std`]: https://github.com/rust-lang/rust/pull/74163++pub(crate) mod fs;diff --git a/crates/wasi/src/filesystem/primitives/rustix/mod.rs b/crates/wasi/src/filesystem/primitives/rustix/mod.rsnew file mode 100644index 0000000000..94e6b2f297--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/rustix/mod.rs@@ -0,0 +1,9 @@+//! The `rustix` module contains code specific to the Posix-ish platforms+//! supported by the `rustix` crate.++pub(crate) mod fs;++#[cfg(target_os = "freebsd")]+mod freebsd;+#[cfg(any(target_os = "android", target_os = "linux"))]+mod linux;diff --git a/crates/wasi/src/filesystem/primitives/set_times.rs b/crates/wasi/src/filesystem/primitives/set_times.rsnew file mode 100644index 0000000000..f1aff11552--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/set_times.rs@@ -0,0 +1,33 @@+//! This defines `set_times`, the primary entrypoint to sandboxed+//! filesystem times modification.+//!+//! TODO: `check_set_times` etc.++use crate::filesystem::primitives::{set_times_impl, set_times_nofollow_impl};+use std::path::Path;+use std::time::SystemTime;+use std::{fs, io};++/// Perform a `utimensat`-like operation, ensuring that the resolution of the+/// path never escapes the directory tree rooted at `start`. This function+/// follows symlinks.+#[inline]+pub fn set_times(+ start: &fs::File,+ path: &Path,+ atime: Option<SystemTime>,+ mtime: Option<SystemTime>,+) -> io::Result<()> {+ set_times_impl(start, path, atime, mtime)+}++/// Like `set_times`, but never follows symlinks.+#[inline]+pub fn set_times_nofollow(+ start: &fs::File,+ path: &Path,+ atime: Option<SystemTime>,+ mtime: Option<SystemTime>,+) -> io::Result<()> {+ set_times_nofollow_impl(start, path, atime, mtime)+}diff --git a/crates/wasi/src/filesystem/primitives/stat.rs b/crates/wasi/src/filesystem/primitives/stat.rsnew file mode 100644index 0000000000..f5ef803795--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/stat.rs@@ -0,0 +1,13 @@+//! This defines `stat`, the primary entrypoint to sandboxed metadata querying.++use crate::filesystem::primitives::{FollowSymlinks, Metadata, stat_impl};+use std::path::Path;+use std::{fs, io};++/// Perform an `fstatat`-like operation, ensuring that the resolution of the+/// path never escapes the directory tree rooted at `start`.+#[inline]+pub fn stat(start: &fs::File, path: &Path, follow: FollowSymlinks) -> io::Result<Metadata> {+ // Call the underlying implementation.+ stat_impl(start, path, follow)+}diff --git a/crates/wasi/src/filesystem/primitives/symlink.rs b/crates/wasi/src/filesystem/primitives/symlink.rsnew file mode 100644index 0000000000..e297dcb399--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/symlink.rs@@ -0,0 +1,64 @@+//! This defines `symlink`, the primary entrypoint to sandboxed symlink+//! creation.++use crate::filesystem::primitives::errors;+use std::path::Path;+use std::{fs, io};++/// Perform a `symlinkat`-like operation, ensuring that the resolution of the+/// path never escapes the directory tree rooted at `start`. An error is+/// returned if the target path is absolute.+#[cfg(not(windows))]+#[inline]+pub fn symlink(old_path: &Path, new_start: &fs::File, new_path: &Path) -> io::Result<()> {+ // Don't allow creating symlinks to absolute paths. This isn't strictly+ // necessary to preserve the sandbox, since `open` will refuse to follow+ // absolute symlinks in any case. However, it is useful to enforce this+ // restriction so that a WASI program can't trick some other non-WASI+ // program into following an absolute path.+ if old_path.has_root() {+ return Err(errors::escape_attempt());+ }++ write_symlink_impl(old_path, new_start, new_path)+}++#[cfg(not(windows))]+fn write_symlink_impl(old_path: &Path, new_start: &fs::File, new_path: &Path) -> io::Result<()> {+ use crate::filesystem::primitives::symlink_impl;++ // Call the underlying implementation.+ symlink_impl(old_path, new_start, new_path)+}++/// Perform a `symlink_file`-like operation, ensuring that the resolution of+/// the path never escapes the directory tree rooted at `start`.+#[cfg(windows)]+#[inline]+pub fn symlink_file(old_path: &Path, new_start: &fs::File, new_path: &Path) -> io::Result<()> {+ use crate::filesystem::primitives::symlink_file_impl;++ // As above, don't allow creating symlinks to absolute paths.+ if old_path.has_root() {+ return Err(errors::escape_attempt());+ }++ // Call the underlying implementation.+ symlink_file_impl(old_path, new_start, new_path)+}++/// Perform a `symlink_dir`-like operation, ensuring that the resolution of the+/// path never escapes the directory tree rooted at `start`.+#[cfg(windows)]+#[inline]+pub fn symlink_dir(old_path: &Path, new_start: &fs::File, new_path: &Path) -> io::Result<()> {+ use crate::filesystem::primitives::symlink_dir_impl;++ // As above, don't allow creating symlinks to absolute paths.+ if old_path.has_root() {+ return Err(errors::escape_attempt());+ }++ // Call the underlying implementation.+ symlink_dir_impl(old_path, new_start, new_path)+}diff --git a/crates/wasi/src/filesystem/primitives/tests/cap_basics.rs b/crates/wasi/src/filesystem/primitives/tests/cap_basics.rsnew file mode 100644index 0000000000..3d9388f7f1--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/tests/cap_basics.rs@@ -0,0 +1,244 @@+use super::helpers as h;+use super::sys_common::io::tmpdir;+#[allow(unused_imports)]+use super::sys_common::symlink_supported;+use crate::filesystem::primitives as p;++use std::path::Path;++#[test]+fn cap_smoke_test() {+ let tmpdir = tmpdir();+ let dir = h::dir_of(&tmpdir);+ check!(h::create_dir_all(&dir, "dir/inner"));+ check!(h::write(&dir, "red.txt", b"hello world\n"));+ check!(h::write(&dir, "dir/green.txt", b"goodmight moon\n"));+ check!(h::write(&dir, "dir/inner/blue.txt", b"hey mars\n"));++ let inner = check!(p::open_dir(&dir, Path::new("dir/inner")));++ check!(h::open(&dir, "red.txt"));++ #[cfg(not(windows))]+ error!(h::open(&dir, "blue.txt"), "No such file");+ #[cfg(windows)]+ error!(h::open(&dir, "blue.txt"), 2);++ #[cfg(not(windows))]+ error!(h::open(&dir, "green.txt"), "No such file");+ #[cfg(windows)]+ error!(h::open(&dir, "green.txt"), 2);++ check!(h::open(&dir, "./red.txt"));++ #[cfg(not(windows))]+ error!(h::open(&dir, "./blue.txt"), "No such file");+ #[cfg(windows)]+ error!(h::open(&dir, "./blue.txt"), 2);++ #[cfg(not(windows))]+ error!(h::open(&dir, "./green.txt"), "No such file");+ #[cfg(windows)]+ error!(h::open(&dir, "./green.txt"), 2);++ #[cfg(not(windows))]+ error!(h::open(&dir, "dir/red.txt"), "No such file");+ #[cfg(windows)]+ error!(h::open(&dir, "dir/red.txt"), 2);++ check!(h::open(&dir, "dir/green.txt"));++ #[cfg(not(windows))]+ error!(h::open(&dir, "dir/blue.txt"), "No such file");+ #[cfg(windows)]+ error!(h::open(&dir, "dir/blue.txt"), 2);++ #[cfg(not(windows))]+ error!(h::open(&dir, "dir/inner/red.txt"), "No such file");+ #[cfg(windows)]+ error!(h::open(&dir, "dir/inner/red.txt"), 2);++ #[cfg(not(windows))]+ error!(h::open(&dir, "dir/inner/green.txt"), "No such file");+ #[cfg(windows)]+ error!(h::open(&dir, "dir/inner/green.txt"), 2);++ check!(h::open(&dir, "dir/inner/blue.txt"));++ check!(h::open(&dir, "dir/../red.txt"));+ check!(h::open(&dir, "dir/inner/../../red.txt"));+ check!(h::open(&dir, "dir/inner/../inner/../../red.txt"));++ #[cfg(not(windows))]+ error!(h::open(&inner, "red.txt"), "No such file");+ #[cfg(windows)]+ error!(h::open(&inner, "red.txt"), 2);++ #[cfg(not(windows))]+ error!(h::open(&inner, "green.txt"), "No such file");+ #[cfg(windows)]+ error!(h::open(&inner, "green.txt"), 2);++ error_contains!(+ h::open(&inner, "../inner/blue.txt"),+ "a path led outside of the filesystem"+ );+ error_contains!(+ h::open(&inner, "../inner/red.txt"),+ "a path led outside of the filesystem"+ );++ #[cfg(not(windows))]+ error!(p::open_dir(&inner, Path::new("")), "No such file");+ #[cfg(windows)]+ error!(p::open_dir(&inner, Path::new("")), 2);++ error_contains!(+ p::open_dir(&inner, Path::new("/")),+ "a path led outside of the filesystem"+ );+ error_contains!(+ p::open_dir(&inner, Path::new("/etc/services")),+ "a path led outside of the filesystem"+ );+ check!(p::open_dir(&inner, Path::new(".")));+ check!(p::open_dir(&inner, Path::new("./")));+ check!(p::open_dir(&inner, Path::new("./.")));+ error_contains!(+ p::open_dir(&inner, Path::new("..")),+ "a path led outside of the filesystem"+ );+ error_contains!(+ p::open_dir(&inner, Path::new("../")),+ "a path led outside of the filesystem"+ );+ error_contains!(+ p::open_dir(&inner, Path::new("../.")),+ "a path led outside of the filesystem"+ );+ error_contains!(+ p::open_dir(&inner, Path::new("./..")),+ "a path led outside of the filesystem"+ );+}++#[test]+fn symlinks() {+ #[cfg(windows)]+ if !symlink_supported() {+ return;+ }++ let tmpdir = tmpdir();++ let dir = h::dir_of(&tmpdir);+ check!(h::create_dir_all(&dir, "dir/inner"));+ check!(h::write(&dir, "red.txt", b"hello world\n"));+ check!(h::write(&dir, "dir/green.txt", b"goodmight moon\n"));+ check!(h::write(&dir, "dir/inner/blue.txt", b"hey mars\n"));++ let inner = check!(p::open_dir(&dir, Path::new("dir/inner")));++ check!(h::symlink(&dir, "dir", "link"));+ #[cfg(not(windows))]+ check!(h::symlink(&dir, "does_not_exist", "badlink"));++ check!(h::open(&dir, "link/../red.txt"));+ check!(h::open(&dir, "link/green.txt"));+ check!(h::open(&dir, "link/inner/blue.txt"));+ #[cfg(not(windows))]+ {+ error_contains!(h::open(&dir, "link/red.txt"), "No such file");+ error_contains!(h::open(&dir, "link/../green.txt"), "No such file");+ }+ #[cfg(windows)]+ {+ error_contains!(+ h::open(&dir, "link/red.txt"),+ "The system cannot find the file specified."+ );+ error_contains!(+ h::open(&dir, "link/../green.txt"),+ "The system cannot find the file specified."+ );+ }++ check!(h::open(&dir, "./dir/.././/link/..///./red.txt"));+ check!(h::open(&dir, "link/inner/../inner/../../red.txt"));+ error_contains!(+ h::open(&inner, "../inner/../inner/../../link/other.txt"),+ "a path led outside of the filesystem"+ );+ #[cfg(not(windows))]+ {+ error_contains!(+ h::open(&dir, "./dir/.././/link/..///./not.txt"),+ "No such file"+ );+ error_contains!(h::open(&dir, "link/other.txt"), "No such file");+ error_contains!(h::open(&dir, "badlink/../red.txt"), "No such file");+ }+ #[cfg(windows)]+ {+ error_contains!(+ h::open(&dir, "./dir/.././/link/..///./not.txt"),+ "The system cannot find the file specified."+ );+ error_contains!(+ h::open(&dir, "link/other.txt"),+ "The system cannot find the file specified."+ );+ }+}++#[test]+#[cfg(not(windows))]+fn symlink_loop() {+ let tmpdir = tmpdir();++ let dir = h::dir_of(&tmpdir);+ check!(h::symlink(&dir, "link", "link"));+ // TODO: Check the error message+ error_contains!(h::open(&dir, "link"), "");+}++#[test]+fn symlink_loop_from_rename() {+ #[cfg(windows)]+ if !symlink_supported() {+ return;+ }++ let tmpdir = tmpdir();++ let dir = h::dir_of(&tmpdir);+ check!(h::create(&dir, "file"));+ check!(h::symlink(&dir, "file", "link"));+ check!(h::open(&dir, "link"));+ check!(p::rename(+ &dir,+ Path::new("file"),+ &dir,+ Path::new("renamed")+ ));+ error_contains!(h::open(&dir, "link"), "");+ check!(p::rename(&dir, Path::new("link"), &dir, Path::new("file")));+ error_contains!(h::open(&dir, "file"), "");+ check!(p::rename(&dir, Path::new("file"), &dir, Path::new("link")));+ error_contains!(h::open(&dir, "link"), "");+ check!(p::rename(+ &dir,+ Path::new("renamed"),+ &dir,+ Path::new("file")+ ));+ check!(h::open(&dir, "link"));+}++#[cfg(target_os = "linux")]+#[test]+fn proc_self_fd() {+ let dir = check!(std::fs::File::open("/proc/self/fd"));+ // This should fail with "too many levels of symbolic links".+ h::open(&dir, "0").unwrap_err();+}diff --git a/crates/wasi/src/filesystem/primitives/tests/file_type_ext.rs b/crates/wasi/src/filesystem/primitives/tests/file_type_ext.rsnew file mode 100644index 0000000000..d61114e75a--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/tests/file_type_ext.rs@@ -0,0 +1,39 @@+// This file contains tests for `FileTypeExt`.++use super::sys_common::io::tmpdir;+#[cfg(unix)]+use crate::filesystem::primitives::FileTypeExt;+use crate::filesystem::primitives::{Metadata, OpenOptions, open, open_ambient_dir};+use std::path::Path;++#[test]+fn test_file_type_ext() {+ let tmpdir = tmpdir();+ let dir = check!(open_ambient_dir(tmpdir.path(),));+ let a = check!(open(+ &dir,+ Path::new("a"),+ OpenOptions::new().write(true).create(true).truncate(true)+ ));++ let tmpdir_metadata = check!(Metadata::from_file(&dir));+ let a_metadata = check!(Metadata::from_file(&a));++ #[cfg(unix)]+ {+ assert!(!tmpdir_metadata.file_type().is_char_device());+ assert!(!a_metadata.file_type().is_char_device());++ assert!(!tmpdir_metadata.file_type().is_block_device());+ assert!(!a_metadata.file_type().is_block_device());+ }++ assert!(tmpdir_metadata.file_type().is_dir());+ assert!(!a_metadata.file_type().is_dir());++ assert!(!tmpdir_metadata.file_type().is_file());+ assert!(a_metadata.file_type().is_file());++ assert!(!tmpdir_metadata.file_type().is_symlink());+ assert!(!a_metadata.file_type().is_symlink());+}diff --git a/crates/wasi/src/filesystem/primitives/tests/fs.rs b/crates/wasi/src/filesystem/primitives/tests/fs.rsnew file mode 100644index 0000000000..10f16ed9e9--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/tests/fs.rs@@ -0,0 +1,1239 @@+// This file is derived from Rust's library/std/src/fs/tests.rs at revision+// e4b1d5841494d6eb7f4944c91a057e16b0f0a9ea.++use super::helpers as h;+use super::sys_common::io::tmpdir;+use super::sys_common::symlink_junction;+use crate::filesystem::primitives as p;+use rand::Rng;+use std::fs::File;+use std::io::prelude::*;+use std::io::{ErrorKind, SeekFrom};+#[cfg(unix)]+use std::os::unix::fs::FileExt;+use std::path::{Path, PathBuf};+use std::str;+use std::thread;++// Several test fail on windows if the user does not have permission to+// create symlinks (the `SeCreateSymbolicLinkPrivilege`). Instead of+// disabling these test on Windows, use this function to test whether we+// have permission, and return otherwise. This way, we still don't run these+// tests most of the time, but at least we do if the user has the right+// permissions.+pub fn got_symlink_permission(tmpdir: &File) -> bool {+ if cfg!(unix) {+ return true;+ }+ let link = "some_hopefully_unique_link_name";++ match h::symlink_file(tmpdir, r"nonexisting_target", link) {+ // ERROR_PRIVILEGE_NOT_HELD = 1314+ Err(ref err) if err.raw_os_error() == Some(1314) => false,+ Ok(_) | Err(_) => true,+ }+}++fn able_to_not_follow_symlinks_while_hard_linking() -> bool {+ return true;+}++#[test]+fn open_directory_with_truncate_is_error() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ let mut options = p::OpenOptions::new();+ // The `maybe_dir` part of this test is gone along with the option itself.+ options.truncate(true).read(true).write(true);+ p::create_dir(&start, Path::new("test"), &p::DirOptions::new()).unwrap();+ assert!(p::open(&start, Path::new("test"), &options).is_err());+}++#[test]+fn dir_entry_methods() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);++ h::create_dir_all(&start, "a").unwrap();+ h::create(&start, "b").unwrap();++ // `DirEntry::file_type` is gone; the metadata checks still cover this.+ for file in h::read_dir(&start, ".").unwrap().map(|f| f.unwrap()) {+ let fname = file.file_name();+ match fname.to_str() {+ Some("a") => {+ assert!(file.metadata().unwrap().is_dir());+ }+ Some("b") => {+ assert!(file.metadata().unwrap().file_type().is_file());+ }+ f => panic!("unknown file name: {f:?}"),+ }+ }+}++#[test]+fn open_flavors() {+ use crate::filesystem::primitives::OpenOptions as OO;+ fn c<T: Clone>(t: &T) -> T {+ t.clone()+ }++ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);++ let mut r = OO::new();+ r.read(true);+ let mut w = OO::new();+ w.write(true);+ let mut rw = OO::new();+ rw.read(true).write(true);++ #[cfg(windows)]+ let invalid_options = 87; // ERROR_INVALID_PARAMETER+ #[cfg(any(all(unix, not(target_os = "vxworks")), target_os = "wasi"))]+ let invalid_options = "Invalid argument";+ #[cfg(target_os = "vxworks")]+ let invalid_options = "invalid argument";++ // Test various combinations of creation modes and access modes.+ //+ // Allowed:+ // creation mode | read | write | read-write |+ // | :-----------------------|:-----:|:-----:|:----------:|+ // not set (open existing) | X | X | X |+ // create | | X | X |+ // truncate | | X | X |+ // create and truncate | | X | X |+ // create_new | | X | X |+ //+ // tested in reverse order, so 'create_new' creates the file, and 'open+ // existing' opens it.+ //+ // The append and read-append rows are not covered: `OpenOptions::append`+ // was dropped in this vendoring.++ // write-only+ check!(p::open(&start, Path::new("a"), c(&w).create_new(true)));+ check!(p::open(+ &start,+ Path::new("a"),+ c(&w).create(true).truncate(true)+ ));+ check!(p::open(&start, Path::new("a"), c(&w).truncate(true)));+ check!(p::open(&start, Path::new("a"), c(&w).create(true)));+ check!(p::open(&start, Path::new("a"), &c(&w)));++ // read-only+ error!(+ p::open(&start, Path::new("b"), c(&r).create_new(true)),+ invalid_options+ );+ error!(+ p::open(&start, Path::new("b"), c(&r).create(true).truncate(true)),+ invalid_options+ );+ error!(+ p::open(&start, Path::new("b"), c(&r).truncate(true)),+ invalid_options+ );+ error!(+ p::open(&start, Path::new("b"), c(&r).create(true)),+ invalid_options+ );+ check!(p::open(&start, Path::new("a"), &c(&r))); // try opening the file created with write_only++ // read-write+ check!(p::open(&start, Path::new("c"), c(&rw).create_new(true)));+ check!(p::open(+ &start,+ Path::new("c"),+ c(&rw).create(true).truncate(true)+ ));+ check!(p::open(&start, Path::new("c"), c(&rw).truncate(true)));+ check!(p::open(&start, Path::new("c"), c(&rw).create(true)));+ check!(p::open(&start, Path::new("c"), &c(&rw)));++ // Test opening a file without setting an access mode+ let mut blank = OO::new();+ error!(+ p::open(&start, Path::new("f"), blank.create(true)),+ invalid_options+ );++ // Test write works+ check!(check!(h::create(&start, "h")).write("foobar".as_bytes()));++ // Test write fails for read-only+ check!(p::open(&start, Path::new("h"), &r));+ {+ let mut f = check!(p::open(&start, Path::new("h"), &r));+ assert!(f.write("wut".as_bytes()).is_err());+ }++ // Test write overwrites+ {+ let mut f = check!(p::open(&start, Path::new("h"), &c(&w)));+ check!(f.write("baz".as_bytes()));+ }+ {+ let mut f = check!(p::open(&start, Path::new("h"), &c(&r)));+ let mut b = vec![0; 6];+ check!(f.read(&mut b));+ assert_eq!(b, "bazbar".as_bytes());+ }++ // Test truncate works+ {+ let mut f = check!(p::open(&start, Path::new("h"), c(&w).truncate(true)));+ check!(f.write("foo".as_bytes()));+ }+ assert_eq!(check!(h::metadata(&start, "h")).len(), 3);+}++#[test]+fn file_test_io_smoke_test() {+ let message = "it's alright. have a good time";+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ let filename = "file_rt_io_file_test.txt";+ {+ let mut write_stream = check!(h::create(&start, filename));+ check!(write_stream.write(message.as_bytes()));+ }+ {+ let mut read_stream = check!(h::open(&start, filename));+ let mut read_buf = [0; 1028];+ let read_str = match check!(read_stream.read(&mut read_buf)) {+ 0 => panic!("shouldn't happen"),+ n => str::from_utf8(&read_buf[..n]).unwrap().to_string(),+ };+ assert_eq!(read_str, message);+ }+ check!(p::remove_file(&start, Path::new(filename)));+}++#[test]+fn invalid_path_raises() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ let filename = "file_that_does_not_exist.txt";+ let result = h::open(&start, filename);++ #[cfg(any(all(unix, not(target_os = "vxworks")), target_os = "wasi"))]+ error!(result, "No such file or directory");+ #[cfg(target_os = "vxworks")]+ error!(result, "no such file or directory");+ #[cfg(windows)]+ error!(result, 2); // ERROR_FILE_NOT_FOUND+}++#[test]+fn file_test_iounlinking_invalid_path_should_raise_condition() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ let filename = "file_another_file_that_does_not_exist.txt";++ let result = p::remove_file(&start, Path::new(filename));++ #[cfg(any(all(unix, not(target_os = "vxworks")), target_os = "wasi"))]+ error!(result, "No such file or directory");+ #[cfg(target_os = "vxworks")]+ error!(result, "no such file or directory");+ #[cfg(windows)]+ error!(result, 2); // ERROR_FILE_NOT_FOUND+}++#[test]+fn file_test_io_non_positional_read() {+ let message: &str = "ten-four";+ let mut read_mem = [0; 8];+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ let filename = "file_rt_io_file_test_positional.txt";+ {+ let mut rw_stream = check!(h::create(&start, filename));+ check!(rw_stream.write(message.as_bytes()));+ }+ {+ let mut read_stream = check!(h::open(&start, filename));+ {+ let read_buf = &mut read_mem[0..4];+ check!(read_stream.read(read_buf));+ }+ {+ let read_buf = &mut read_mem[4..8];+ check!(read_stream.read(read_buf));+ }+ }+ check!(p::remove_file(&start, Path::new(filename)));+ let read_str = str::from_utf8(&read_mem).unwrap();+ assert_eq!(read_str, message);+}++#[test]+fn file_test_io_seek_and_tell_smoke_test() {+ let message = "ten-four";+ let mut read_mem = [0; 4];+ let set_cursor = 4_u64;+ let tell_pos_pre_read;+ let tell_pos_post_read;+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ let filename = "file_rt_io_file_test_seeking.txt";+ {+ let mut rw_stream = check!(h::create(&start, filename));+ check!(rw_stream.write(message.as_bytes()));+ }+ {+ let mut read_stream = check!(h::open(&start, filename));+ check!(read_stream.seek(SeekFrom::Start(set_cursor)));+ tell_pos_pre_read = check!(read_stream.seek(SeekFrom::Current(0)));+ check!(read_stream.read(&mut read_mem));+ tell_pos_post_read = check!(read_stream.seek(SeekFrom::Current(0)));+ }+ check!(p::remove_file(&start, Path::new(filename)));+ let read_str = str::from_utf8(&read_mem).unwrap();+ assert_eq!(read_str, &message[4..8]);+ assert_eq!(tell_pos_pre_read, set_cursor);+ assert_eq!(tell_pos_post_read, message.len() as u64);+}++#[test]+fn file_test_io_seek_and_write() {+ let initial_msg = "food-is-yummy";+ let overwrite_msg = "-the-bar!!";+ let final_msg = "foo-the-bar!!";+ let seek_idx = 3;+ let mut read_mem = [0; 13];+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ let filename = "file_rt_io_file_test_seek_and_write.txt";+ {+ let mut rw_stream = check!(h::create(&start, filename));+ check!(rw_stream.write(initial_msg.as_bytes()));+ check!(rw_stream.seek(SeekFrom::Start(seek_idx)));+ check!(rw_stream.write(overwrite_msg.as_bytes()));+ }+ {+ let mut read_stream = check!(h::open(&start, filename));+ check!(read_stream.read(&mut read_mem));+ }+ check!(p::remove_file(&start, Path::new(filename)));+ let read_str = str::from_utf8(&read_mem).unwrap();+ assert!(read_str == final_msg);+}++#[test]+fn file_test_io_seek_shakedown() {+ // 01234567890123+ let initial_msg = "qwer-asdf-zxcv";+ let chunk_one: &str = "qwer";+ let chunk_two: &str = "asdf";+ let chunk_three: &str = "zxcv";+ let mut read_mem = [0; 4];+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ let filename = "file_rt_io_file_test_seek_shakedown.txt";+ {+ let mut rw_stream = check!(h::create(&start, filename));+ check!(rw_stream.write(initial_msg.as_bytes()));+ }+ {+ let mut read_stream = check!(h::open(&start, filename));++ check!(read_stream.seek(SeekFrom::End(-4)));+ check!(read_stream.read(&mut read_mem));+ assert_eq!(str::from_utf8(&read_mem).unwrap(), chunk_three);++ check!(read_stream.seek(SeekFrom::Current(-9)));+ check!(read_stream.read(&mut read_mem));+ assert_eq!(str::from_utf8(&read_mem).unwrap(), chunk_two);++ check!(read_stream.seek(SeekFrom::Start(0)));+ check!(read_stream.read(&mut read_mem));+ assert_eq!(str::from_utf8(&read_mem).unwrap(), chunk_one);+ }+ check!(p::remove_file(&start, Path::new(filename)));+}++#[test]+fn file_test_io_eof() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ let filename = "file_rt_io_file_test_eof.txt";+ let mut buf = [0; 256];+ {+ let oo = p::OpenOptions::new()+ .create_new(true)+ .write(true)+ .read(true)+ .clone();+ let mut rw = check!(p::open(&start, Path::new(filename), &oo));+ assert_eq!(check!(rw.read(&mut buf)), 0);+ assert_eq!(check!(rw.read(&mut buf)), 0);+ }+ check!(p::remove_file(&start, Path::new(filename)));+}++#[test]+#[cfg(unix)]+fn file_test_io_read_write_at() {+ let tmpdir = tmpdir();++ let start = h::dir_of(&tmpdir);+ let filename = "file_rt_io_file_test_read_write_at.txt";+ let mut buf = [0; 256];+ let write1 = "asdf";+ let write2 = "qwer-";+ let write3 = "-zxcv";+ let content = "qwer-asdf-zxcv";+ {+ let oo = p::OpenOptions::new()+ .create_new(true)+ .write(true)+ .read(true)+ .clone();+ let mut rw = check!(p::open(&start, Path::new(filename), &oo));+ assert_eq!(check!(rw.write_at(write1.as_bytes(), 5)), write1.len());+ assert_eq!(check!(rw.seek(SeekFrom::Current(0))), 0);+ assert_eq!(check!(rw.read_at(&mut buf, 5)), write1.len());+ assert_eq!(str::from_utf8(&buf[..write1.len()]), Ok(write1));+ assert_eq!(check!(rw.seek(SeekFrom::Current(0))), 0);+ assert_eq!(+ check!(rw.read_at(&mut buf[..write2.len()], 0)),+ write2.len()+ );+ assert_eq!(str::from_utf8(&buf[..write2.len()]), Ok("\0\0\0\0\0"));+ assert_eq!(check!(rw.seek(SeekFrom::Current(0))), 0);+ assert_eq!(check!(rw.write(write2.as_bytes())), write2.len());+ assert_eq!(check!(rw.seek(SeekFrom::Current(0))), 5);+ assert_eq!(check!(rw.read(&mut buf)), write1.len());+ assert_eq!(str::from_utf8(&buf[..write1.len()]), Ok(write1));+ assert_eq!(check!(rw.seek(SeekFrom::Current(0))), 9);+ assert_eq!(+ check!(rw.read_at(&mut buf[..write2.len()], 0)),+ write2.len()+ );+ assert_eq!(str::from_utf8(&buf[..write2.len()]), Ok(write2));+ assert_eq!(check!(rw.seek(SeekFrom::Current(0))), 9);+ assert_eq!(check!(rw.write_at(write3.as_bytes(), 9)), write3.len());+ assert_eq!(check!(rw.seek(SeekFrom::Current(0))), 9);+ }+ {+ let mut read = check!(h::open(&start, filename));+ assert_eq!(check!(read.read_at(&mut buf, 0)), content.len());+ assert_eq!(str::from_utf8(&buf[..content.len()]), Ok(content));+ assert_eq!(check!(read.seek(SeekFrom::Current(0))), 0);+ assert_eq!(check!(read.seek(SeekFrom::End(-5))), 9);+ assert_eq!(check!(read.read_at(&mut buf, 0)), content.len());+ assert_eq!(str::from_utf8(&buf[..content.len()]), Ok(content));+ assert_eq!(check!(read.seek(SeekFrom::Current(0))), 9);+ assert_eq!(check!(read.read(&mut buf)), write3.len());+ assert_eq!(str::from_utf8(&buf[..write3.len()]), Ok(write3));+ assert_eq!(check!(read.seek(SeekFrom::Current(0))), 14);+ assert_eq!(check!(read.read_at(&mut buf, 0)), content.len());+ assert_eq!(str::from_utf8(&buf[..content.len()]), Ok(content));+ assert_eq!(check!(read.seek(SeekFrom::Current(0))), 14);+ assert_eq!(check!(read.read_at(&mut buf, 14)), 0);+ assert_eq!(check!(read.read_at(&mut buf, 15)), 0);+ assert_eq!(check!(read.seek(SeekFrom::Current(0))), 14);+ }+ check!(p::remove_file(&start, Path::new(filename)));+}++// Darwin doesn't have a way to change the permissions on a file, relative+// to a directory handle, with no read or write access, without blindly+// following symlinks.+#[test]+#[cfg(unix)]+#[cfg_attr(+ any(+ target_os = "macos",+ target_os = "ios",+ target_os = "tvos",+ target_os = "watchos",+ target_os = "visionos",+ ),+ ignore+)]+#[test]+#[cfg(windows)]+fn file_test_io_seek_read_write() {+ let tmpdir = tmpdir();++ let start = h::dir_of(&tmpdir);+ let filename = "file_rt_io_file_test_seek_read_write.txt";+ let mut buf = [0; 256];+ let write1 = "asdf";+ let write2 = "qwer-";+ let write3 = "-zxcv";+ let content = "qwer-asdf-zxcv";+ {+ let oo = p::OpenOptions::new()+ .create_new(true)+ .write(true)+ .read(true)+ .clone();+ let mut rw = check!(p::open(&start, Path::new(filename), &oo));+ assert_eq!(check!(rw.seek_write(write1.as_bytes(), 5)), write1.len());+ assert_eq!(check!(rw.seek(SeekFrom::Current(0))), 9);+ assert_eq!(check!(rw.seek_read(&mut buf, 5)), write1.len());+ assert_eq!(str::from_utf8(&buf[..write1.len()]), Ok(write1));+ assert_eq!(check!(rw.seek(SeekFrom::Current(0))), 9);+ assert_eq!(check!(rw.seek(SeekFrom::Start(0))), 0);+ assert_eq!(check!(rw.write(write2.as_bytes())), write2.len());+ assert_eq!(check!(rw.seek(SeekFrom::Current(0))), 5);+ assert_eq!(check!(rw.read(&mut buf)), write1.len());+ assert_eq!(str::from_utf8(&buf[..write1.len()]), Ok(write1));+ assert_eq!(check!(rw.seek(SeekFrom::Current(0))), 9);+ assert_eq!(+ check!(rw.seek_read(&mut buf[..write2.len()], 0)),+ write2.len()+ );+ assert_eq!(str::from_utf8(&buf[..write2.len()]), Ok(write2));+ assert_eq!(check!(rw.seek(SeekFrom::Current(0))), 5);+ assert_eq!(check!(rw.seek_write(write3.as_bytes(), 9)), write3.len());+ assert_eq!(check!(rw.seek(SeekFrom::Current(0))), 14);+ }+ {+ let mut read = check!(h::open(&start, filename));+ assert_eq!(check!(read.seek_read(&mut buf, 0)), content.len());+ assert_eq!(str::from_utf8(&buf[..content.len()]), Ok(content));+ assert_eq!(check!(read.seek(SeekFrom::Current(0))), 14);+ assert_eq!(check!(read.seek(SeekFrom::End(-5))), 9);+ assert_eq!(check!(read.seek_read(&mut buf, 0)), content.len());+ assert_eq!(str::from_utf8(&buf[..content.len()]), Ok(content));+ assert_eq!(check!(read.seek(SeekFrom::Current(0))), 14);+ assert_eq!(check!(read.seek(SeekFrom::End(-5))), 9);+ assert_eq!(check!(read.read(&mut buf)), write3.len());+ assert_eq!(str::from_utf8(&buf[..write3.len()]), Ok(write3));+ assert_eq!(check!(read.seek(SeekFrom::Current(0))), 14);+ assert_eq!(check!(read.seek_read(&mut buf, 0)), content.len());+ assert_eq!(str::from_utf8(&buf[..content.len()]), Ok(content));+ assert_eq!(check!(read.seek(SeekFrom::Current(0))), 14);+ assert_eq!(check!(read.seek_read(&mut buf, 14)), 0);+ assert_eq!(check!(read.seek_read(&mut buf, 15)), 0);+ }+ check!(p::remove_file(&start, Path::new(filename)));+}++#[test]+fn file_test_stat_is_correct_on_is_file() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ let filename = "file_stat_correct_on_is_file.txt";+ {+ let mut opts = p::OpenOptions::new();+ let mut fs = check!(p::open(+ &start,+ Path::new(filename),+ opts.read(true).write(true).create(true)+ ));+ let msg = "hw";+ fs.write(msg.as_bytes()).unwrap();++ let fstat_res = check!(fs.metadata());+ assert!(fstat_res.is_file());+ }+ let stat_res_fn = check!(h::metadata(&start, filename));+ assert!(stat_res_fn.file_type().is_file());+ check!(p::remove_file(&start, Path::new(filename)));+}++#[test]+fn file_test_stat_is_correct_on_is_dir() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ let filename = "file_stat_correct_on_is_dir";+ check!(h::create_dir(&start, filename));+ let stat_res_fn = check!(h::metadata(&start, filename));+ assert!(stat_res_fn.is_dir());+ check!(p::remove_dir(&start, Path::new(filename)));+}++#[test]+fn file_test_fileinfo_false_when_checking_is_file_on_a_directory() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ let dir = "fileinfo_false_on_dir";+ check!(h::create_dir(&start, dir));+ assert!(!h::is_file(&start, dir));+ check!(p::remove_dir(&start, Path::new(dir)));+}++#[test]+fn file_test_fileinfo_check_exists_before_and_after_file_creation() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ let file = "fileinfo_check_exists_b_and_a.txt";+ check!(check!(h::create(&start, file)).write(b"foo"));+ assert!(h::exists(&start, file));+ check!(p::remove_file(&start, Path::new(file)));+ assert!(!h::exists(&start, file));+}++#[test]+fn file_test_directoryinfo_check_exists_before_and_after_mkdir() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ let dir = "before_and_after_dir";+ assert!(!h::exists(&start, dir));+ check!(h::create_dir(&start, dir));+ assert!(h::exists(&start, dir));+ assert!(h::is_dir(&start, dir));+ check!(p::remove_dir(&start, Path::new(dir)));+ assert!(!h::exists(&start, dir));+}++#[test]+fn file_test_directoryinfo_readdir() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ let dir = "di_readdir";+ check!(h::create_dir(&start, dir));+ let prefix = "foo";+ for n in 0..3 {+ let f = format!("{n}.txt");+ let mut w = check!(h::create(&start, &f));+ let msg_str = format!("{}{}", prefix, n.to_string());+ let msg = msg_str.as_bytes();+ check!(w.write(msg));+ }+ let files = check!(h::read_dir(&start, dir));+ let mut mem = [0; 4];+ for f in files {+ let f = f.unwrap().file_name();+ {+ check!(check!(h::open(&start, &f)).read(&mut mem));+ let read_str = str::from_utf8(&mem).unwrap();+ let expected = format!("{}{}", prefix, f.to_str().unwrap());+ assert_eq!(expected, read_str);+ }+ check!(p::remove_file(&start, Path::new(&f)));+ }+ check!(p::remove_dir(&start, Path::new(dir)));+}++#[test]+fn file_create_new_already_exists_error() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ let file = "file_create_new_error_exists";+ check!(h::create(&start, file));+ let e = p::open(+ &start,+ Path::new(file),+ p::OpenOptions::new().write(true).create_new(true),+ )+ .unwrap_err();+ assert_eq!(e.kind(), ErrorKind::AlreadyExists);+}++#[test]+fn mkdir_path_already_exists_error() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ let dir = "mkdir_error_twice";+ check!(h::create_dir(&start, dir));+ let e = h::create_dir(&start, dir).unwrap_err();+ assert_eq!(e.kind(), ErrorKind::AlreadyExists);+}++#[test]+fn recursive_mkdir() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ let dir = "d1/d2";+ check!(h::create_dir_all(&start, dir));+ assert!(h::is_dir(&start, dir));+}++#[test]+fn concurrent_recursive_mkdir() {+ for _ in 0..100 {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ let mut name = PathBuf::from("a");+ for _ in 0..40 {+ name = name.join("a");+ }+ let mut join = vec![];+ for _ in 0..8 {+ let dir = check!(start.try_clone());+ let name = name.clone();+ join.push(thread::spawn(move || {+ check!(h::create_dir_all(&dir, &name));+ }))+ }++ // No `Display` on result of `join()`+ join.drain(..).map(|join| join.join().unwrap()).count();+ }+}++#[test]+fn recursive_mkdir_slash() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ error_contains!(+ h::create_dir_all(&start, Path::new("/")),+ "a path led outside of the filesystem"+ );+}++#[test]+fn recursive_mkdir_dot() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ check!(h::create_dir_all(&start, Path::new(".")));+}++#[test]+fn recursive_mkdir_empty() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ check!(h::create_dir_all(&start, Path::new("")));+}++#[test]+fn unicode_path_is_dir() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);++ assert!(h::is_dir(&start, Path::new(".")));+ assert!(!h::is_dir(&start, Path::new("test/stdtest/fs.rs")));++ let mut dirpath = PathBuf::new();+ dirpath.push("test-가一ー你好");+ check!(h::create_dir(&start, &dirpath));+ assert!(h::is_dir(&start, &dirpath));++ let mut filepath = dirpath;+ filepath.push("unicode-file-\u{ac00}\u{4e00}\u{30fc}\u{4f60}\u{597d}.rs");+ check!(h::create(&start, &filepath)); // ignore return; touch only+ assert!(!h::is_dir(&start, &filepath));+ assert!(h::exists(&start, filepath));+}++#[test]+fn unicode_path_exists() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);++ assert!(h::exists(&start, Path::new(".")));+ assert!(!h::exists(&start, Path::new("test/nonexistent-bogus-path")));++ let unicode = PathBuf::new();+ let unicode = unicode.join("test-각丁ー再见");+ check!(h::create_dir(&start, &unicode));+ assert!(h::exists(&start, unicode));+ assert!(!h::exists(+ &start,+ Path::new("test/unicode-bogus-path-각丁ー再见")+ ));+}++#[test]+fn symlinks_work() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ if !got_symlink_permission(&start) {+ return;+ };++ let input = "in.txt";+ let out = "out.txt";++ check!(check!(h::create(&start, &input)).write("foobar".as_bytes()));+ check!(h::symlink_file(&start, &input, &out));+ assert!(+ check!(h::symlink_metadata(&start, out))+ .file_type()+ .is_symlink()+ );+ assert_eq!(+ check!(h::metadata(&start, &out)).len(),+ check!(h::metadata(&start, &input)).len()+ );+ let mut v = Vec::new();+ check!(check!(h::open(&start, &out)).read_to_end(&mut v));+ assert_eq!(v, b"foobar".to_vec());+}++#[test]+fn symlink_noexist() {+ // Symlinks can point to things that don't exist+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ if !got_symlink_permission(&start) {+ return;+ };++ // Use a relative path for testing. Symlinks get normalized by Windows,+ // so we might not get the same path back for absolute paths+ check!(h::symlink_file(&start, &"foo", "bar"));+ assert_eq!(+ check!(p::read_link(&start, Path::new("bar")))+ .to_str()+ .unwrap(),+ "foo"+ );+}++#[test]+fn read_link() {+ if cfg!(windows) {+ // directory symlink+ let root = h::open_ambient_dir(r"C:\").unwrap();+ error_contains!(+ p::read_link(&root, Path::new(r"Users\All Users")),+ "a path led outside of the filesystem"+ );+ // junction+ error_contains!(+ p::read_link(&root, Path::new(r"Users\Default User")),+ "a path led outside of the filesystem"+ );+ // junction with special permissions+ error_contains!(+ p::read_link(&root, Path::new(r"Documents and Settings\")),+ "a path led outside of the filesystem"+ );+ }+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ let link = "link";+ if !got_symlink_permission(&start) {+ return;+ };+ check!(h::symlink_file(&start, &"foo", &link));+ assert_eq!(+ check!(p::read_link(&start, Path::new(&link)))+ .to_str()+ .unwrap(),+ "foo"+ );+}++#[test]+fn readlink_not_symlink() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ match p::read_link(&start, Path::new(".")) {+ Ok(..) => panic!("wanted a failure"),+ Err(..) => {}+ }+}++#[cfg(not(windows))]+#[test]+fn read_link_contents() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ let link = "link";+ if !got_symlink_permission(&start) {+ return;+ };+ check!(h::symlink_file(&start, &"foo", &link));+ assert_eq!(+ check!(super::super::read_link::read_link_contents(+ &start,+ Path::new(link)+ ))+ .to_str()+ .unwrap(),+ "foo"+ );+}++#[cfg(not(windows))]+#[test]+fn read_link_contents_absolute() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ let link = "link";+ if !got_symlink_permission(&start) {+ return;+ };+ check!(std::os::unix::fs::symlink("/foo", tmpdir.path().join(link)));+ assert_eq!(+ check!(super::super::read_link::read_link_contents(+ &start,+ Path::new(link)+ ))+ .to_str()+ .unwrap(),+ "/foo"+ );+}++#[test]+fn links_work() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ let input = "in.txt";+ let out = "out.txt";++ check!(check!(h::create(&start, &input)).write("foobar".as_bytes()));+ check!(p::hard_link(+ &start,+ Path::new(&input),+ &start,+ Path::new(&out)+ ));+ assert_eq!(+ check!(h::metadata(&start, &out)).len(),+ check!(h::metadata(&start, &input)).len()+ );+ assert_eq!(+ check!(h::metadata(&start, &out)).len(),+ check!(h::metadata(&start, input)).len()+ );+ let mut v = Vec::new();+ check!(check!(h::open(&start, &out)).read_to_end(&mut v));+ assert_eq!(v, b"foobar".to_vec());++ // can't link to yourself+ match p::hard_link(&start, Path::new(&input), &start, Path::new(&input)) {+ Ok(..) => panic!("wanted a failure"),+ Err(..) => {}+ }+ // can't link to something that doesn't exist+ match p::hard_link(&start, Path::new("foo"), &start, Path::new("bar")) {+ Ok(..) => panic!("wanted a failure"),+ Err(..) => {}+ }+}++#[test]+fn sync_doesnt_kill_anything() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ let path = "in.txt";++ let mut file = check!(h::create(&start, &path));+ check!(file.sync_all());+ check!(file.sync_data());+ check!(file.write(b"foo"));+ check!(file.sync_all());+ check!(file.sync_data());+}++#[test]+fn truncate_works() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ let path = "in.txt";++ let mut file = check!(h::create(&start, &path));+ check!(file.write(b"foo"));+ check!(file.sync_all());++ // Do some simple things with truncation+ assert_eq!(check!(file.metadata()).len(), 3);+ check!(file.set_len(10));+ assert_eq!(check!(file.metadata()).len(), 10);+ check!(file.write(b"bar"));+ check!(file.sync_all());+ assert_eq!(check!(file.metadata()).len(), 10);++ let mut v = Vec::new();+ check!(check!(h::open(&start, &path)).read_to_end(&mut v));+ assert_eq!(v, b"foobar\0\0\0\0".to_vec());++ // Truncate to a smaller length, don't seek, and then write something.+ // Ensure that the intermediate zeroes are all filled in (we have `seek`ed+ // past the end of the file).+ check!(file.set_len(2));+ assert_eq!(check!(file.metadata()).len(), 2);+ check!(file.write(b"wut"));+ check!(file.sync_all());+ assert_eq!(check!(file.metadata()).len(), 9);+ let mut v = Vec::new();+ check!(check!(h::open(&start, &path)).read_to_end(&mut v));+ assert_eq!(v, b"fo\0\0\0\0wut".to_vec());+}++#[test]+fn _assert_send_sync() {+ fn _assert_send_sync<T: Send + Sync>() {}+ _assert_send_sync::<p::OpenOptions>();+}++#[test]+fn binary_file() {+ let mut bytes = [0; 1024];+ rand::rng().fill_bytes(&mut bytes);++ let tmpdir = tmpdir();++ let start = h::dir_of(&tmpdir);++ check!(check!(h::create(&start, "test")).write(&bytes));+ let mut v = Vec::new();+ check!(check!(h::open(&start, "test")).read_to_end(&mut v));+ assert!(v == &bytes[..]);+}++#[test]+fn write_then_read() {+ let mut bytes = [0; 1024];+ rand::rng().fill_bytes(&mut bytes);++ let tmpdir = tmpdir();++ let start = h::dir_of(&tmpdir);++ check!(h::write(&start, "test", &bytes[..]));+ let v = check!(h::read(&start, "test"));+ assert!(v == &bytes[..]);++ check!(h::write(&start, "not-utf8", &[0xFF]));+ error_contains!(+ h::read_to_string(&start, "not-utf8"),+ "stream did not contain valid UTF-8"+ );++ let s = "𐁁𐀓𐀠𐀴𐀍";+ check!(h::write(&start, "utf8", s.as_bytes()));+ let string = check!(h::read_to_string(&start, "utf8"));+ assert_eq!(string, s);+}++#[test]+fn file_try_clone() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);++ let mut f1 = check!(p::open(+ &start,+ Path::new("test"),+ p::OpenOptions::new().read(true).write(true).create(true)+ ));+ let mut f2 = check!(f1.try_clone());++ check!(f1.write_all(b"hello world"));+ check!(f1.seek(SeekFrom::Start(2)));++ let mut buf = vec![];+ check!(f2.read_to_end(&mut buf));+ assert_eq!(buf, b"llo world");+ drop(f2);++ check!(f1.write_all(b"!"));+}++#[test]+fn mkdir_trailing_slash() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ let path = PathBuf::from("file");+ check!(h::create_dir_all(&start, &path.join("a/")));+}++#[test]+fn dir_entry_debug() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ h::create(&start, "b").unwrap();+ let mut read_dir = h::read_dir(&start, ".").unwrap();+ let dir_entry = read_dir.next().unwrap().unwrap();+ let actual = format!("{dir_entry:?}");+ let expected = format!("DirEntry({:?})", dir_entry.file_name());+ assert_eq!(actual, expected);+}++#[test]+fn read_dir_not_found() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ let res = h::read_dir(&start, "path/that/does/not/exist");+ assert_eq!(res.err().unwrap().kind(), ErrorKind::NotFound);+}++// On Windows, `symlink_junction` somehow creates a symlink where `read_link`+// returns a relative path prefixed with "\\\\?\\", which `std::path::Path`+// parses as a `Prefix`, making cap-std think it's an absolute path and+// therefore a sandbox escape attempt. This only seems to happen with+// `symlink_junction`, and not symlinks created with standard library APIs. I+// don't know what the right thing to do here is. For now, disable these tests.+#[cfg_attr(windows, ignore)]+#[test]+fn create_dir_all_with_junctions() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ let target = "target";++ let junction = PathBuf::from("junction");+ let b = junction.join("a/b");++ let link = PathBuf::from("link");+ let d = link.join("c/d");++ h::create_dir(&start, &target).unwrap();++ check!(symlink_junction(&target, &start, &junction));+ check!(h::create_dir_all(&start, &b));+ // the junction itself is not a directory, but `is_dir()` on a Path+ // follows links+ assert!(h::is_dir(&start, junction));+ assert!(h::exists(&start, b));++ if !got_symlink_permission(&start) {+ return;+ };+ check!(h::symlink_dir(&start, &target, &link));+ check!(h::create_dir_all(&start, &d));+ assert!(h::is_dir(&start, link));+ assert!(h::exists(&start, d));+}++#[test]+fn metadata_access_times() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);++ let b = "b";+ h::create(&start, &b).unwrap();++ let a = check!(h::metadata(&start, "."));+ let b = check!(h::metadata(&start, &b));++ assert_eq!(check!(a.accessed()), check!(a.accessed()));+ assert_eq!(check!(a.modified()), check!(a.modified()));+ // This assert from std's testsuite is racy.+ //assert_eq!(check!(b.accessed()), check!(b.modified()));++ if cfg!(target_os = "macos") || cfg!(target_os = "windows") {+ check!(a.created());+ check!(b.created());+ }++ if cfg!(any(target_os = "android", target_os = "linux")) {+ // Not always available+ match (a.created(), b.created()) {+ (Ok(t1), Ok(t2)) => assert!(t1 <= t2),+ (Err(e1), Err(e2))+ if e1.kind() == ErrorKind::Other && e2.kind() == ErrorKind::Other => {}+ (a, b) => {+ panic!("creation time must be always supported or not supported: {a:?} {b:?}",)+ }+ }+ }+}++/// Test creating hard links to symlinks.+#[test]+fn symlink_hard_link() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ if !got_symlink_permission(&start) {+ return;+ }+ if !able_to_not_follow_symlinks_while_hard_linking() {+ return;+ }++ // Create "file", a file.+ check!(h::create(&start, "file"));++ // Create "symlink", a symlink to "file".+ check!(h::symlink_file(&start, "file", "symlink"));++ // Create "hard_link", a hard link to "symlink".+ check!(p::hard_link(+ &start,+ Path::new("symlink"),+ &start,+ Path::new("hard_link")+ ));++ // "hard_link" should appear as a symlink.+ assert!(+ check!(h::symlink_metadata(&start, "hard_link"))+ .file_type()+ .is_symlink()+ );++ // We sould be able to open "file" via any of the above names.+ let _ = check!(h::open(&start, "file"));+ assert!(h::open(&start, "file.renamed").is_err());+ let _ = check!(h::open(&start, "symlink"));+ let _ = check!(h::open(&start, "hard_link"));++ // Rename "file" to "file.renamed".+ check!(p::rename(+ &start,+ Path::new("file"),+ &start,+ Path::new("file.renamed")+ ));++ // Now, the symlink and the hard link should be dangling.+ assert!(h::open(&start, "file").is_err());+ let _ = check!(h::open(&start, "file.renamed"));+ assert!(h::open(&start, "symlink").is_err());+ assert!(h::open(&start, "hard_link").is_err());++ // The symlink and the hard link should both still point to "file".+ assert!(p::read_link(&start, Path::new("file")).is_err());+ assert!(p::read_link(&start, Path::new("file.renamed")).is_err());+ assert_eq!(+ check!(p::read_link(&start, Path::new("symlink"))),+ Path::new("file")+ );+ assert_eq!(+ check!(p::read_link(&start, Path::new("hard_link"))),+ Path::new("file")+ );++ // Remove "file.renamed".+ check!(p::remove_file(&start, Path::new("file.renamed")));++ // Now, we can't open the file by any name.+ assert!(h::open(&start, "file").is_err());+ assert!(h::open(&start, "file.renamed").is_err());+ assert!(h::open(&start, "symlink").is_err());+ assert!(h::open(&start, "hard_link").is_err());++ // "hard_link" should still appear as a symlink.+ assert!(+ check!(h::symlink_metadata(&start, "hard_link"))+ .file_type()+ .is_symlink()+ );+}++/// Ensure `fs::create_dir` works on Windows with longer paths.+#[test]+#[cfg(windows)]+fn create_dir_long_paths() {+ use std::ffi::OsStr;+ use std::iter;+ use std::os::windows::ffi::OsStrExt;+ const PATH_LEN: usize = 247;++ let tmpdir = tmpdir();++ let start = h::dir_of(&tmpdir);+ let mut path = PathBuf::new();+ path.push("a");+ let mut path = path.into_os_string();++ let utf16_len = path.encode_wide().count();+ if utf16_len >= PATH_LEN {+ // Skip the test in the unlikely event the local user has a long temp directory+ // path. This should not affect CI.+ return;+ }+ // Increase the length of the path.+ path.extend(iter::repeat(OsStr::new("a")).take(PATH_LEN - utf16_len));++ // This should succeed.+ h::create_dir(&start, &path).unwrap();++ // This will fail if the path isn't converted to verbatim.+ path.push("a");+ h::create_dir(&start, &path).unwrap();+}diff --git a/crates/wasi/src/filesystem/primitives/tests/fs_additional.rs b/crates/wasi/src/filesystem/primitives/tests/fs_additional.rsnew file mode 100644index 0000000000..d804538ac6--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/tests/fs_additional.rs@@ -0,0 +1,1360 @@+// This file contains additional fs tests that didn't make it into `fs.rs`.+// The reason for additional module to contain those is so that `fs.rs` mirrors+// Rust's libstd tests.+use super::helpers as h;+use super::sys_common::io::tmpdir;+use super::sys_common::symlink_supported;+use crate::filesystem::primitives as p;+use std::io::{Read, Write};+use std::path::Path;+use std::str;++#[test]+#[cfg_attr(windows, ignore)] // TODO investigate why this one is failing+fn dir_writable() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ check!(h::create_dir(&start, "dir"));+ #[cfg(not(windows))]+ error_contains!(h::create(&start, "dir"), "Is a directory");+ #[cfg(windows)]+ error!(h::create(&start, "dir"), 5);+ error_contains!(+ p::open(&start, Path::new("dir"), p::OpenOptions::new().write(true)),+ "Is a directory"+ );++ error_contains!(h::create(&start, "dir/."), "Is a directory");+ error_contains!(+ p::open(+ &start,+ Path::new("dir/."),+ p::OpenOptions::new().write(true)+ ),+ "Is a directory"+ );++ error_contains!(h::create(&start, "dir/.."), "Is a directory");+ error_contains!(+ p::open(+ &start,+ Path::new("dir/.."),+ p::OpenOptions::new().write(true)+ ),+ "Is a directory"+ );+}++#[test]+fn readdir_write() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ check!(h::create_dir(&start, "dir"));+ assert!(p::open(&start, Path::new("dir"), p::OpenOptions::new().write(true)).is_err());+ assert!(p::open(&start, Path::new("dir/"), p::OpenOptions::new().write(true)).is_err());++ #[cfg(any(target_os = "android", target_os = "linux"))]+ {+ use crate::filesystem::primitives::OpenOptionsExt;+ assert!(+ p::open(+ &start,+ Path::new("dir"),+ p::OpenOptions::new()+ .write(true)+ .custom_flags(rustix::fs::OFlags::DIRECTORY.bits() as i32)+ )+ .is_err()+ );+ }+}++#[test]+fn maybe_dir() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ check!(h::create_dir(&start, "dir"));++ // Opening directories works on non-Windows platforms.+ #[cfg(not(windows))]+ check!(h::open(&start, "dir"));++ // Opening directories fails on Windows.+ #[cfg(windows)]+ assert!(h::open(&start, "dir").is_err());+}++#[test]+fn optionally_recursive_mkdir() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ let dir = "d1/d2";+ check!(h::create_dir_all(&start, dir));+ assert!(h::is_dir(&start, dir));+}++#[test]+fn optionally_nonrecursive_mkdir() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ let dir = "d1/d2";+ #[cfg(not(windows))]+ error!(+ p::create_dir(&start, Path::new(dir), &p::DirOptions::new()),+ "No such file"+ );+ #[cfg(windows)]+ error!(+ p::create_dir(&start, Path::new(dir), &p::DirOptions::new()),+ 2+ );++ assert!(!h::exists(&start, dir));+}++#[test]+fn dotdot_at_end_of_symlink() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);++ let foo = b"foo";+ check!(h::write(&start, "target", foo));+ check!(h::create_dir(&start, "b"));+ let b = check!(p::open_dir(&start, Path::new("b")));+ check!(h::symlink_dir(&b, "..", "up"));++ // Do some things with `path` that might break with an `O_PATH` fd.+ // The `permissions` part of this test is gone with `set_permissions`, but+ // the `read_dir` part is the part that exercises the `O_PATH` fd.+ let path = "b/up";++ check!(h::metadata(&start, path));++ let contents = check!(h::read_dir(&start, path));+ for entry in contents {+ let _entry = check!(entry);+ }+}++#[test]+fn dotdot_at_end_of_symlink_all_inside_dir() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);++ let foo = b"foo";+ check!(h::create_dir(&start, "dir"));+ check!(h::write(&start, "dir/target", foo));+ check!(h::create_dir(&start, "dir/b"));+ let b = check!(p::open_dir(&start, Path::new("dir/b")));+ check!(h::symlink_dir(&b, "..", "up"));++ // Do some things with `path` that might break with an `O_PATH` fd.+ // The `permissions` part of this test is gone with `set_permissions`, but+ // the `read_dir` part is the part that exercises the `O_PATH` fd.+ let path = "dir/b/up";++ check!(h::metadata(&start, path));++ let contents = check!(h::read_dir(&start, path));+ for entry in contents {+ let _entry = check!(entry);+ }+}++#[test]+#[cfg_attr(windows, ignore)]+fn dotdot_slashdot_at_end_of_symlink() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);++ let foo = b"foo";+ check!(h::write(&start, "target", foo));+ check!(h::create_dir(&start, "b"));+ let b = check!(p::open_dir(&start, Path::new("b")));+ check!(h::symlink_dir(&b, "../.", "up"));++ // Do some things with `path` that might break with an `O_PATH` fd.+ // The `permissions` part of this test is gone with `set_permissions`, but+ // the `read_dir` part is the part that exercises the `O_PATH` fd.+ let path = "b/up";++ check!(h::metadata(&start, path));++ let contents = check!(h::read_dir(&start, path));+ for entry in contents {+ let _entry = check!(entry);+ }+}++#[test]+#[cfg_attr(windows, ignore)]+fn dotdot_slashdot_at_end_of_symlink_all_inside_dir() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);++ let foo = b"foo";+ check!(h::create_dir(&start, "dir"));+ check!(h::write(&start, "dir/target", foo));+ check!(h::create_dir(&start, "dir/b"));+ let b = check!(p::open_dir(&start, Path::new("dir/b")));+ check!(h::symlink_dir(&b, "../.", "up"));++ // Do some things with `path` that might break with an `O_PATH` fd.+ // The `permissions` part of this test is gone with `set_permissions`, but+ // the `read_dir` part is the part that exercises the `O_PATH` fd.+ let path = "dir/b/up";++ check!(h::metadata(&start, path));++ let contents = check!(h::read_dir(&start, path));+ for entry in contents {+ let _entry = check!(entry);+ }+}++#[test]+fn recursive_mkdir() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ let dir = "d1/d2";+ check!(h::create_dir_all(&start, dir));+ assert!(h::is_dir(&start, "d1"));+ let dir = check!(p::open_dir(&start, Path::new("d1")));+ assert!(h::is_dir(&dir, "d2"));+ assert!(h::is_dir(&start, "d1/d2"));+}++#[test]+#[cfg_attr(windows, ignore)] // TODO investigate why this one is failing+fn open_various() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ #[cfg(not(windows))]+ error!(h::create(&start, ""), "No such file");+ #[cfg(windows)]+ error!(h::create(&start, ""), 2);++ #[cfg(not(windows))]+ error!(h::create(&start, "."), "Is a directory");+ #[cfg(windows)]+ error!(h::create(&start, "."), 2);+}++#[test]+fn trailing_slash() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ check!(h::create(&start, "file"));++ #[cfg(not(windows))]+ {+ error!(h::open(&start, "file/../file"), "Not a directory");+ error!(h::open(&start, "file/.."), "Not a directory");+ error!(h::open(&start, "file/."), "Not a directory");+ error!(h::open(&start, "file/../file/"), "Not a directory");+ error!(h::open(&start, "file/"), "Not a directory");+ error!(+ p::open_dir(&start, Path::new("file/../file/")),+ "Not a directory"+ );+ error!(+ p::open_dir(&start, Path::new("file/../file")),+ "Not a directory"+ );+ error!(p::open_dir(&start, Path::new("file/..")), "Not a directory");+ error!(p::open_dir(&start, Path::new("file/.")), "Not a directory");+ error!(p::open_dir(&start, Path::new("file/")), "Not a directory");+ }++ #[cfg(windows)]+ {+ assert!(check!(check!(h::open(&start, "file/../file")).metadata()).is_file());+ assert!(+ check!(p::Metadata::from_file(&check!(p::open_dir(+ &start,+ Path::new("file/..")+ ))))+ .is_dir()+ );+ assert!(check!(check!(h::open(&start, "file/.")).metadata()).is_file());+ assert!(p::open_dir(&start, Path::new("file/../file/")).is_err());+ assert!(p::open_dir(&start, Path::new("file/./")).is_err());+ assert!(p::open_dir(&start, Path::new("file//")).is_err());+ assert!(p::open_dir(&start, Path::new("file/../file")).is_err());+ assert!(p::open_dir(&start, Path::new("file/.")).is_err());+ assert!(p::open_dir(&start, Path::new("file/")).is_err());+ }+}++#[test]+fn trailing_slash_in_dir() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ check!(h::create_dir(&start, "dir"));+ check!(h::create(&start, "dir/file"));++ #[cfg(not(windows))]+ {+ error!(h::open(&start, "dir/file/../file"), "Not a directory");+ error!(h::open(&start, "dir/file/.."), "Not a directory");+ error!(h::open(&start, "dir/file/."), "Not a directory");+ error!(h::open(&start, "dir/file/../file/"), "Not a directory");+ error!(h::open(&start, "dir/file/"), "Not a directory");+ error!(+ p::open_dir(&start, Path::new("dir/file/../file/")),+ "Not a directory"+ );+ error!(+ p::open_dir(&start, Path::new("dir/file/../file")),+ "Not a directory"+ );+ error!(+ p::open_dir(&start, Path::new("dir/file/..")),+ "Not a directory"+ );+ error!(+ p::open_dir(&start, Path::new("dir/file/.")),+ "Not a directory"+ );+ error!(+ p::open_dir(&start, Path::new("dir/file/")),+ "Not a directory"+ );+ }++ #[cfg(windows)]+ {+ assert!(check!(check!(h::open(&start, "dir/file/../file")).metadata()).is_file());+ assert!(+ check!(p::Metadata::from_file(&check!(p::open_dir(+ &start,+ Path::new("dir/file/..")+ ))))+ .is_dir()+ );+ assert!(check!(check!(h::open(&start, "dir/file/.")).metadata()).is_file());+ assert!(h::open(&start, "dir/file/../file/").is_err());+ let _ = check!(h::open(&start, "dir/file/../file/."));+ assert!(h::open(&start, "dir/file/../file/./").is_err());+ assert!(h::open(&start, "dir/file/").is_err());+ let _ = check!(h::open(&start, "dir/file/."));+ let _ = check!(h::open(&start, "dir/file/../file/."));+ assert!(h::open(&start, "dir/file/../file/./").is_err());+ assert!(h::open(&start, "dir/file/").is_err());+ let _ = check!(h::open(&start, "dir/file/."));+ assert!(h::open(&start, "dir/file/./").is_err());+ assert!(p::open_dir(&start, Path::new("dir/file/../file/")).is_err());+ assert!(p::open_dir(&start, Path::new("dir/file/../file/.")).is_err());+ assert!(p::open_dir(&start, Path::new("dir/file/../file/./")).is_err());+ assert!(p::open_dir(&start, Path::new("dir/file/../file")).is_err());+ assert!(p::open_dir(&start, Path::new("dir/file/.")).is_err());+ assert!(p::open_dir(&start, Path::new("dir/file/./")).is_err());+ assert!(p::open_dir(&start, Path::new("dir/file/")).is_err());+ }+}++#[test]+#[cfg_attr(windows, ignore)] // TODO investigate why this one is failing+fn rename_slashdots() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ check!(h::create_dir(&start, "dir"));+ check!(p::rename(+ &start,+ Path::new("dir"),+ &start,+ Path::new("dir")+ ));+ check!(p::rename(+ &start,+ Path::new("dir"),+ &start,+ Path::new("dir/")+ ));+ check!(p::rename(+ &start,+ Path::new("dir/"),+ &start,+ Path::new("dir")+ ));+ check!(p::rename(+ &start,+ Path::new("dir/"),+ &start,+ Path::new("dir/")+ ));++ // TODO: Platform-specific error code.+ error_contains!(+ p::rename(&start, Path::new("dir"), &start, Path::new("dir/.")),+ ""+ );+ error_contains!(+ p::rename(&start, Path::new("dir/."), &start, Path::new("dir")),+ ""+ );+}++#[test]+#[cfg_attr(windows, ignore)] // TODO investigate why this one is failing+fn rename_slashdots_ambient() {+ let dir = tempfile::tempdir().unwrap();++ check!(std::fs::create_dir_all(dir.path().join("dir")));+ check!(std::fs::rename(+ dir.path().join("dir"),+ dir.path().join("dir")+ ));+ check!(std::fs::rename(+ dir.path().join("dir"),+ dir.path().join("dir/")+ ));+ check!(std::fs::rename(+ dir.path().join("dir/"),+ dir.path().join("dir")+ ));+ check!(std::fs::rename(+ dir.path().join("dir/"),+ dir.path().join("dir/")+ ));++ // TODO: Platform-specific error code.+ error_contains!(+ std::fs::rename(dir.path().join("dir"), dir.path().join("dir/.")),+ ""+ );+ error_contains!(+ std::fs::rename(dir.path().join("dir/."), dir.path().join("dir")),+ ""+ );+}++#[test]+fn try_exists() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ assert_eq!(h::exists(&start, "somefile"), false);+ let dir = Path::new("d1/d2");+ let parent = dir.parent().unwrap();+ assert_eq!(h::exists(&start, parent), false);+ assert_eq!(h::exists(&start, dir), false);+ check!(h::create_dir(&start, parent));+ assert_eq!(h::exists(&start, parent), true);+ assert_eq!(h::exists(&start, dir), false);+ check!(h::create_dir(&start, dir));+ assert_eq!(h::exists(&start, dir), true);+}++#[test]+fn file_test_directoryinfo_readdir() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ let dir = "di_readdir";+ check!(h::create_dir(&start, dir));+ let prefix = "foo";+ for n in 0..3 {+ let f = format!("{n}.txt");+ let mut w = check!(h::create(&start, &f));+ let msg_str = format!("{}{}", prefix, n.to_string());+ let msg = msg_str.as_bytes();+ check!(w.write(msg));+ }+ let sub = check!(p::open_dir(&start, Path::new(dir)));+ let files = check!(p::read_base_dir(&sub));+ let mut mem = [0; 4];+ for f in files {+ let f = f.unwrap();+ {+ check!(check!(h::open(&sub, f.file_name())).read(&mut mem));+ let read_str = str::from_utf8(&mem).unwrap();+ let expected = format!("{}{}", prefix, f.file_name().to_str().unwrap());+ assert_eq!(expected, read_str);+ }+ check!(p::remove_file(&sub, Path::new(&f.file_name())));+ }+ drop(sub);+ check!(p::remove_dir(&start, Path::new(dir)));+}++#[test]+fn follow_dotdot_symlink() {+ if !symlink_supported() {+ return;+ }++ let tmpdir = tmpdir();++ let start = h::dir_of(&tmpdir);+ check!(h::create_dir_all(&start, "a/b"));+ check!(h::symlink_dir(&start, "..", "a/b/c"));+ check!(h::symlink_dir(&start, "../..", "a/b/d"));+ check!(h::symlink_dir(&start, "../../..", "a/b/e"));+ check!(h::symlink_dir(&start, "../../../..", "a/b/f"));++ check!(p::open_dir(&start, Path::new("a/b/c")));+ assert!(check!(h::metadata(&start, "a/b/c")).is_dir());++ #[cfg(windows)]+ {+ error!(p::open_dir(&start, Path::new("a/b/d")), 123);+ error!(h::metadata(&start, "a/b/d"), 123);++ error!(p::open_dir(&start, Path::new("a/b/e")), 123);+ error!(h::metadata(&start, "a/b/e"), 123);++ error!(p::open_dir(&start, Path::new("a/b/f")), 123);+ error!(h::metadata(&start, "a/b/f"), 123);+ }++ #[cfg(not(windows))]+ {+ check!(p::open_dir(&start, Path::new("a/b/d")));+ assert!(check!(h::metadata(&start, "a/b/d")).is_dir());++ assert!(p::open_dir(&start, Path::new("a/b/e")).is_err());+ assert!(h::metadata(&start, "a/b/e").is_err());++ assert!(p::open_dir(&start, Path::new("a/b/f")).is_err());+ assert!(h::metadata(&start, "a/b/f").is_err());+ }+}++#[test]+fn follow_dotdot_symlink_ambient() {+ #[cfg(unix)]+ use std::os::unix::fs::symlink as symlink_dir;+ #[cfg(windows)]+ use std::os::windows::fs::symlink_dir;++ if !symlink_supported() {+ return;+ }++ let dir = tempfile::tempdir().unwrap();+ check!(std::fs::create_dir_all(dir.path().join("a/b")));+ check!(symlink_dir("..", dir.path().join("a/b/c")));+ check!(symlink_dir("../..", dir.path().join("a/b/d")));+ check!(symlink_dir("../../..", dir.path().join("a/b/e")));+ check!(symlink_dir("../../../..", dir.path().join("a/b/f")));++ check!(h::open_ambient_dir(dir.path().join("a/b/c")));+ assert!(check!(std::fs::metadata(dir.path().join("a/b/c"))).is_dir());++ #[cfg(windows)]+ {+ error!(h::open_ambient_dir(dir.path().join("a/b/d")), 123);+ error!(std::fs::metadata(dir.path().join("a/b/d")), 123);++ error!(h::open_ambient_dir(dir.path().join("a/b/e")), 123);+ error!(std::fs::metadata(dir.path().join("a/b/e")), 123);++ error!(h::open_ambient_dir(dir.path().join("a/b/f")), 123);+ error!(std::fs::metadata(dir.path().join("a/b/f")), 123);+ }++ #[cfg(not(windows))]+ {+ check!(h::open_ambient_dir(dir.path().join("a/b/d")));+ assert!(check!(std::fs::metadata(dir.path().join("a/b/d"))).is_dir());++ check!(h::open_ambient_dir(dir.path().join("a/b/e")));+ assert!(check!(std::fs::metadata(dir.path().join("a/b/e"))).is_dir());++ check!(h::open_ambient_dir(dir.path().join("a/b/f")));+ assert!(check!(std::fs::metadata(dir.path().join("a/b/f"))).is_dir());+ }+}++#[test]+fn follow_file_symlink() {+ if !symlink_supported() {+ return;+ }++ let tmpdir = tmpdir();++ let start = h::dir_of(&tmpdir);++ check!(h::create(&start, "file"));++ check!(h::symlink_file(&start, "file", "link"));+ check!(h::symlink_dir(&start, "file/", "link_slash"));+ check!(h::symlink_file(&start, "file/.", "link_slashdot"));+ check!(h::symlink_dir(&start, "file/..", "link_slashdotdot"));++ check!(h::open(&start, "link"));+ assert!(h::open(&start, "link_slash").is_err());++ #[cfg(windows)]+ {+ error!(h::open(&start, "link_slashdot"), 123);+ error!(p::open_dir(&start, Path::new("link_slashdotdot")), 123);+ }+ #[cfg(not(windows))]+ {+ assert!(h::open(&start, "link_slash").is_err());+ assert!(h::open(&start, "link_slashdot").is_err());+ assert!(p::open_dir(&start, Path::new("link_slashdotdot")).is_err());+ }+}++/// This test is the same as `check_dot_access` but uses `std::fs`'+/// ambient API instead of `cap_std`. The purpose of this test is to+/// confirm fundamentally OS-specific differences.+#[cfg(unix)]+#[test]+fn check_dot_access_ambient() {+ use std::fs;+ use std::os::unix::fs::DirBuilderExt;++ let dir = tempfile::tempdir().unwrap();++ let mut options = std::fs::DirBuilder::new();+ options.mode(0o477);+ check!(options.create(dir.path().join("dir")));++ check!(fs::metadata(dir.path().join(".")));+ check!(fs::metadata(dir.path().join("dir")));+ check!(fs::metadata(dir.path().join("dir/")));+ check!(fs::metadata(dir.path().join("dir//")));++ if !cfg!(target_os = "freebsd") {+ assert!(fs::metadata(dir.path().join("dir/.")).is_err());+ assert!(fs::metadata(dir.path().join("dir/./")).is_err());+ assert!(fs::metadata(dir.path().join("dir/.//")).is_err());+ assert!(fs::metadata(dir.path().join("dir/./.")).is_err());+ assert!(fs::metadata(dir.path().join("dir/.//.")).is_err());+ assert!(fs::metadata(dir.path().join("dir/..")).is_err());+ assert!(fs::metadata(dir.path().join("dir/../")).is_err());+ assert!(fs::metadata(dir.path().join("dir/..//")).is_err());+ assert!(fs::metadata(dir.path().join("dir/../.")).is_err());+ assert!(fs::metadata(dir.path().join("dir/..//.")).is_err());+ }+}++// Windows allows one to open "file/." and "file/.." and similar, however it+// doesn't allow "file/" or similar.+#[cfg(windows)]+#[test]+fn file_with_trailing_slashdot() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ check!(h::create(&start, "file"));+ check!(h::open(&start, "file"));+ check!(h::open(&start, "file\\."));+ check!(h::open(&start, "file/."));+ check!(h::open(&start, "file\\.\\."));+ check!(h::open(&start, "file/./."));+ assert!(h::open(&start, "file\\").is_err());+ assert!(h::open(&start, "file/").is_err());+ assert!(h::open(&start, "file\\.\\").is_err());+ assert!(h::open(&start, "file/./").is_err());+ check!(p::open_dir(&start, Path::new("file\\..")));+ check!(p::open_dir(&start, Path::new("file/..")));+ check!(p::open_dir(&start, Path::new("file\\.\\..")));+ check!(p::open_dir(&start, Path::new("file/./..")));+ check!(p::open_dir(&start, Path::new("file\\..\\.")));+ check!(p::open_dir(&start, Path::new("file/../.")));+ check!(p::open_dir(&start, Path::new("file\\..\\")));+ check!(p::open_dir(&start, Path::new("file/../")));+ assert!(p::open_dir(&start, Path::new("file\\...")).is_err());+ assert!(p::open_dir(&start, Path::new("file/...")).is_err());+}++/// This is just to confirm that Windows really does allow one to open "file/."+/// and "file/..", and similar, however it doesn't allow "file/" or similar.+#[cfg(windows)]+#[test]+fn file_with_trailing_slashdot_ambient() {+ let dir = tempfile::tempdir().unwrap();+ check!(std::fs::File::create(dir.path().join("file")));+ check!(std::fs::File::open(dir.path().join("file")));+ check!(std::fs::File::open(dir.path().join("file\\.")));+ check!(std::fs::File::open(dir.path().join("file/.")));+ check!(std::fs::File::open(dir.path().join("file\\.\\.")));+ check!(std::fs::File::open(dir.path().join("file/./.")));+ assert!(std::fs::File::open(dir.path().join("file\\")).is_err());+ assert!(std::fs::File::open(dir.path().join("file/")).is_err());+ assert!(std::fs::File::open(dir.path().join("file\\.\\")).is_err());+ assert!(std::fs::File::open(dir.path().join("file/./")).is_err());+ check!(h::open_ambient_dir(dir.path().join("file/..")));+ check!(h::open_ambient_dir(dir.path().join("file\\.\\..")));+ check!(h::open_ambient_dir(dir.path().join("file/./..")));+ check!(h::open_ambient_dir(dir.path().join("file\\..\\.")));+ check!(h::open_ambient_dir(dir.path().join("file/../.")));+ check!(h::open_ambient_dir(dir.path().join("file\\..\\")));+ check!(h::open_ambient_dir(dir.path().join("file/../")));+ assert!(h::open_ambient_dir(dir.path().join("file\\...")).is_err());+ assert!(h::open_ambient_dir(dir.path().join("file/...")).is_err());+}++#[cfg(all(+ unix,+ not(any(+ target_os = "ios",+ target_os = "macos",+ target_os = "tvos",+ target_os = "watchos",+ target_os = "visionos",+ ))+))]++/// This test is the same as `dir_searchable_unreadable` but uses `std::fs`'+/// ambient API instead of `cap_std`. The purpose of this test is to+/// confirm fundamentally OS-specific differences.+#[cfg(all(+ unix,+ not(any(+ target_os = "ios",+ target_os = "macos",+ target_os = "tvos",+ target_os = "watchos",+ target_os = "visionos",+ ))+))]+#[test]+fn dir_searchable_unreadable_ambient() {+ use std::fs;+ use std::os::unix::fs::DirBuilderExt;++ let dir = tempfile::tempdir().unwrap();++ let mut options = std::fs::DirBuilder::new();+ options.mode(0o333);+ check!(options.create(dir.path().join("dir")));+ check!(options.create(dir.path().join("dir/writeable_subdir")));+ options.mode(0o111);+ check!(options.create(dir.path().join("dir/subdir")));++ assert!(check!(fs::metadata(dir.path().join("dir/."))).is_dir());+ assert!(check!(fs::metadata(dir.path().join("dir/subdir"))).is_dir());+ assert!(check!(fs::metadata(dir.path().join("dir/subdir/."))).is_dir());+}++/// On Darwin, we don't have a race-free way to create a subdirectory within+/// a directory that we don't have read access to.+#[cfg(any(+ target_os = "ios",+ target_os = "macos",+ target_os = "tvos",+ target_os = "watchos",+ target_os = "visionos",+))]++/// Like `dir_unsearchable_unreadable`, but uses ambient-authority APIs+/// to test underlying host functionality.+#[cfg(unix)]+#[test]+fn dir_unsearchable_unreadable_ambient() {+ use std::fs::DirBuilder;+ use std::os::unix::fs::DirBuilderExt;++ let dir = tempfile::tempdir().unwrap();++ let mut options = DirBuilder::new();+ options.mode(0o000);+ check!(options.create(dir.path().join("dir")));++ if cfg!(any(+ target_os = "android",+ target_os = "linux",+ target_os = "redox",+ )) {+ assert!(std::fs::File::open(dir.path().join("dir")).is_err());+ assert!(std::fs::read_dir(dir.path().join("dir")).is_err());+ assert!(std::fs::File::open(dir.path().join("dir/.")).is_err());+ }+}++/// This test is the same as `symlink_hard_link` but uses `std::fs`'+/// ambient API instead of `cap_std`. The purpose of this test is to+/// confirm fundamentally OS-specific behaviors.+#[test]+fn symlink_hard_link_ambient() {+ #[cfg(unix)]+ use std::os::unix::fs::symlink;+ #[cfg(windows)]+ use std::os::windows::fs::symlink_file;++ if !symlink_supported() {+ return;+ }++ let dir = tempfile::tempdir().unwrap();++ check!(std::fs::File::create(dir.path().join("file")));+ #[cfg(not(windows))]+ check!(symlink("file", dir.path().join("symlink")));+ #[cfg(windows)]+ check!(symlink_file("file", dir.path().join("symlink")));+ check!(std::fs::hard_link(+ dir.path().join("symlink"),+ dir.path().join("hard_link")+ ));+ assert!(+ check!(std::fs::symlink_metadata(dir.path().join("hard_link")))+ .file_type()+ .is_symlink()+ );+ let _ = check!(std::fs::File::open(dir.path().join("file")));+ assert!(std::fs::File::open(dir.path().join("file.renamed")).is_err());+ let _ = check!(std::fs::File::open(dir.path().join("symlink")));+ let _ = check!(std::fs::File::open(dir.path().join("hard_link")));+ check!(std::fs::rename(+ dir.path().join("file"),+ dir.path().join("file.renamed")+ ));+ assert!(std::fs::File::open(dir.path().join("file")).is_err());+ let _ = check!(std::fs::File::open(dir.path().join("file.renamed")));+ assert!(std::fs::File::open(dir.path().join("symlink")).is_err());+ assert!(std::fs::File::open(dir.path().join("hard_link")).is_err());+ assert!(std::fs::read_link(dir.path().join("file")).is_err());+ assert!(std::fs::read_link(dir.path().join("file.renamed")).is_err());+ assert_eq!(+ check!(std::fs::read_link(dir.path().join("symlink"))),+ Path::new("file")+ );+ assert_eq!(+ check!(std::fs::read_link(dir.path().join("hard_link"))),+ Path::new("file")+ );+ check!(std::fs::remove_file(dir.path().join("file.renamed")));+ assert!(std::fs::File::open(dir.path().join("file")).is_err());+ assert!(std::fs::File::open(dir.path().join("file.renamed")).is_err());+ assert!(std::fs::File::open(dir.path().join("symlink")).is_err());+ assert!(std::fs::File::open(dir.path().join("hard_link")).is_err());+ assert!(+ check!(std::fs::symlink_metadata(dir.path().join("hard_link")))+ .file_type()+ .is_symlink()+ );+}++/// POSIX says that whether or not `link` follows symlinks in the `old`+/// path is implementation-defined. We want `hard_link` to not follow+/// symbolic links.+#[test]+fn symlink_hard_link() {+ if !symlink_supported() {+ return;+ }++ let tmpdir = tmpdir();++ let start = h::dir_of(&tmpdir);++ check!(h::create(&start, "file"));+ check!(h::symlink_file(&start, "file", "symlink"));+ check!(p::hard_link(+ &start,+ Path::new("symlink"),+ &start,+ Path::new("hard_link")+ ));+ assert!(+ check!(h::symlink_metadata(&start, "hard_link"))+ .file_type()+ .is_symlink()+ );+ let _ = check!(h::open(&start, "file"));+ assert!(h::open(&start, "file.renamed").is_err());+ let _ = check!(h::open(&start, "symlink"));+ let _ = check!(h::open(&start, "hard_link"));+ check!(p::rename(+ &start,+ Path::new("file"),+ &start,+ Path::new("file.renamed")+ ));+ assert!(h::open(&start, "file").is_err());+ let _ = check!(h::open(&start, "file.renamed"));+ assert!(h::open(&start, "symlink").is_err());+ assert!(h::open(&start, "hard_link").is_err());+ assert!(p::read_link(&start, Path::new("file")).is_err());+ assert!(p::read_link(&start, Path::new("file.renamed")).is_err());+ assert_eq!(+ check!(p::read_link(&start, Path::new("symlink"))),+ Path::new("file")+ );+ assert_eq!(+ check!(p::read_link(&start, Path::new("hard_link"))),+ Path::new("file")+ );+ check!(p::remove_file(&start, Path::new("file.renamed")));+ assert!(h::open(&start, "file").is_err());+ assert!(h::open(&start, "file.renamed").is_err());+ assert!(h::open(&start, "symlink").is_err());+ assert!(h::open(&start, "hard_link").is_err());+ assert!(+ check!(h::symlink_metadata(&start, "hard_link"))+ .file_type()+ .is_symlink()+ );+}++#[test]+fn readdir_with_trailing_slashdot() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ check!(h::create_dir(&start, "dir"));+ check!(h::create(&start, "dir/red"));+ check!(h::create(&start, "dir/green"));+ check!(h::create(&start, "dir/blue"));++ assert_eq!(check!(h::read_dir(&start, "dir")).count(), 3);+ assert_eq!(check!(h::read_dir(&start, "dir/")).count(), 3);+ assert_eq!(check!(h::read_dir(&start, "dir/.")).count(), 3);+}++#[test]+fn metadata_vs_std_fs() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ check!(h::create_dir(&start, "dir"));+ let dir = check!(p::open_dir(&start, Path::new("dir")));+ let file = check!(h::create(&dir, "file"));++ let cap_std_dir = check!(p::Metadata::from_file(&dir));+ let cap_std_file = check!(p::Metadata::from_file(&file));+ let cap_std_dir_entry = {+ let mut entries = check!(p::read_base_dir(&dir));+ let entry = check!(entries.next().unwrap());+ assert_eq!(entry.file_name(), "file");+ assert!(entries.next().is_none(), "unexpected dir entry");+ check!(entry.metadata())+ };++ let std_dir = check!(dir.metadata());+ let std_file = check!(file.metadata());++ match std_dir.created() {+ Ok(_) => println!("std::fs supports file created times"),+ Err(e) => println!("std::fs doesn't support file created times: {e}"),+ }++ check_metadata(&std_dir, &cap_std_dir);+ check_metadata(&std_file, &cap_std_file);+ check_metadata(&std_file, &cap_std_dir_entry);+}++fn check_metadata(std: &std::fs::Metadata, cap: &p::Metadata) {+ assert_eq!(std.is_dir(), cap.is_dir());+ assert_eq!(std.is_file(), cap.file_type().is_file());+ assert_eq!(std.is_symlink(), cap.file_type().is_symlink());+ assert_eq!(std.file_type().is_dir(), cap.file_type().is_dir());+ assert_eq!(std.file_type().is_file(), cap.file_type().is_file());+ assert_eq!(std.file_type().is_symlink(), cap.file_type().is_symlink());+ #[cfg(unix)]+ {+ assert_eq!(+ std::os::unix::fs::FileTypeExt::is_block_device(&std.file_type()),+ p::FileTypeExt::is_block_device(&cap.file_type())+ );+ assert_eq!(+ std::os::unix::fs::FileTypeExt::is_char_device(&std.file_type()),+ p::FileTypeExt::is_char_device(&cap.file_type())+ );+ }++ assert_eq!(std.len(), cap.len());++ // If the standard library supports file modified/accessed/created times,+ // then the primitives should too.+ match std.modified() {+ Ok(expected) => assert_eq!(expected, check!(cap.modified())),+ Err(e) => assert!(+ cap.modified().is_err(),+ "modified time should be error ({}), got {:#?}",+ e,+ cap.modified()+ ),+ }+ // The access times might be a little different due to either our own+ // or concurrent accesses.+ const ACCESS_TOLERANCE_SEC: u32 = 60;+ match std.accessed() {+ Ok(expected) => {+ let access_tolerance = std::time::Duration::from_secs(ACCESS_TOLERANCE_SEC.into());+ assert!(+ ((expected - access_tolerance)..(expected + access_tolerance))+ .contains(&check!(cap.accessed())),+ "std accessed {:#?}, cap accessed {:#?}",+ expected,+ cap.accessed()+ );+ }+ Err(e) => assert!(+ cap.accessed().is_err(),+ "accessed time should be error ({}), got {:#?}",+ e,+ cap.accessed()+ ),+ }+ match std.created() {+ Ok(expected) => assert_eq!(expected, check!(cap.created())),+ Err(e) => {+ // An earlier bug returned the Unix epoch instead of `None` when+ // created times were unavailable. This tries to catch such errors,+ // while also allowing some targets to return valid created times+ // even when std doesn't.+ if let Ok(actual) = cap.created() {+ println!("std returned error for created time ({e}) but got {actual:#?}");+ assert_ne!(actual, std::time::SystemTime::UNIX_EPOCH);+ }+ }+ }++ #[cfg(unix)]+ {+ use std::os::unix::fs::MetadataExt;+ assert_eq!(std.dev(), p::MetadataExt::dev(cap));+ assert_eq!(std.ino(), p::MetadataExt::ino(cap));+ assert_eq!(std.nlink(), p::MetadataExt::nlink(cap));+ }+}++/// Test that a symlink in the middle of a path containing ".." doesn't cause+/// the path to be treated as if it ends with "..".+#[test]+fn dotdot_in_middle_of_symlink() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);++ let foo = b"foo";+ check!(h::write(&start, "target", foo));+ check!(h::create_dir(&start, "b"));+ let b = check!(p::open_dir(&start, Path::new("b")));+ check!(h::symlink_dir(&b, "..", "up"));++ let path = "b/up/target";+ let mut file = check!(h::open(&start, path));+ let mut data = Vec::new();+ check!(file.read_to_end(&mut data));+ assert_eq!(data, foo);+}++/// Like `dotdot_in_middle_of_symlink` but with a `/.` at the end.+///+/// Windows doesn't appear to like symlinks that end with `/.`.+#[test]+#[cfg_attr(windows, ignore)]+fn dotdot_slashdot_in_middle_of_symlink() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);++ let foo = b"foo";+ check!(h::write(&start, "target", foo));+ check!(h::create_dir(&start, "b"));+ let b = check!(p::open_dir(&start, Path::new("b")));+ check!(h::symlink_dir(&b, "../.", "up"));++ let path = "b/up/target";+ let mut file = check!(h::open(&start, path));+ let mut data = Vec::new();+ check!(file.read_to_end(&mut data));+ assert_eq!(data, foo);+}++/// Same as `dotdot_in_middle_of_symlink`, but use two levels of `..`.+///+/// Windows doesn't appear to like symlinks that end with `/..`.+#[test]+#[cfg_attr(windows, ignore)]+fn dotdot_more_in_middle_of_symlink() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);++ let foo = b"foo";+ check!(h::write(&start, "target", foo));+ check!(h::create_dir_all(&start, "b/c"));+ let b = check!(p::open_dir(&start, Path::new("b")));+ check!(h::symlink_dir(&b, "c/../..", "up"));++ let path = "b/up/target";+ let mut file = check!(h::open(&start, path));+ let mut data = Vec::new();+ check!(file.read_to_end(&mut data));+ assert_eq!(data, foo);+}++/// Like `dotdot_more_in_middle_of_symlink`, but with a `/.` at the end.+///+/// Windows doesn't appear to like symlinks that end with `/.`.+#[test]+#[cfg_attr(windows, ignore)]+fn dotdot_slashdot_more_in_middle_of_symlink() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);++ let foo = b"foo";+ check!(h::write(&start, "target", foo));+ check!(h::create_dir_all(&start, "b/c"));+ let b = check!(p::open_dir(&start, Path::new("b")));+ check!(h::symlink_dir(&b, "c/../../.", "up"));++ let path = "b/up/target";+ let mut file = check!(h::open(&start, path));+ let mut data = Vec::new();+ check!(file.read_to_end(&mut data));+ assert_eq!(data, foo);+}++/// Same as `dotdot_more_in_middle_of_symlink`, but the symlink doesn't+/// include `c`.+///+/// Windows doesn't appear to like symlinks that end with `/..`.+#[test]+#[cfg_attr(windows, ignore)]+fn dotdot_other_in_middle_of_symlink() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);++ let foo = b"foo";+ check!(h::write(&start, "target", foo));+ check!(h::create_dir_all(&start, "b/c"));+ let c = check!(p::open_dir(&start, Path::new("b/c")));+ check!(h::symlink_dir(&c, "../..", "up"));++ let path = "b/c/up/target";+ let mut file = check!(h::open(&start, path));+ let mut data = Vec::new();+ check!(file.read_to_end(&mut data));+ assert_eq!(data, foo);+}++/// Like `dotdot_other_in_middle_of_symlink`, but with `/.` at the end.+///+/// Windows doesn't appear to like symlinks that end with `/.`.+#[test]+#[cfg_attr(windows, ignore)]+fn dotdot_slashdot_other_in_middle_of_symlink() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);++ let foo = b"foo";+ check!(h::write(&start, "target", foo));+ check!(h::create_dir_all(&start, "b/c"));+ let c = check!(p::open_dir(&start, Path::new("b/c")));+ check!(h::symlink_dir(&c, "../../.", "up"));++ let path = "b/c/up/target";+ let mut file = check!(h::open(&start, path));+ let mut data = Vec::new();+ check!(file.read_to_end(&mut data));+ assert_eq!(data, foo);+}++/// Same as `dotdot_more_in_middle_of_symlink`, but use a symlink that+/// doesn't end with `..`.+#[test]+fn dotdot_even_more_in_middle_of_symlink() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);++ let foo = b"foo";+ check!(h::create_dir_all(&start, "b/c"));+ check!(h::write(&start, "b/target", foo));+ let b = check!(p::open_dir(&start, Path::new("b")));+ check!(h::symlink_dir(&b, "c/../../b", "up"));++ let path = "b/up/target";+ let mut file = check!(h::open(&start, path));+ let mut data = Vec::new();+ check!(file.read_to_end(&mut data));+ assert_eq!(data, foo);+}++/// Like `dotdot_even_more_in_middle_of_symlink`, but with a `/.` at the end.+///+/// Windows doesn't appear to like symlinks that end with `/.`.+#[test]+#[cfg_attr(windows, ignore)]+fn dotdot_slashdot_even_more_in_middle_of_symlink() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);++ let foo = b"foo";+ check!(h::create_dir_all(&start, "b/c"));+ check!(h::write(&start, "b/target", foo));+ let b = check!(p::open_dir(&start, Path::new("b")));+ check!(h::symlink_dir(&b, "c/../../b/.", "up"));++ let path = "b/up/target";+ let mut file = check!(h::open(&start, path));+ let mut data = Vec::new();+ check!(file.read_to_end(&mut data));+ assert_eq!(data, foo);+}++/// Same as `dotdot_even_more_in_middle_of_symlink`, but the symlink doesn't+/// include `c`.+#[test]+fn dotdot_even_other_in_middle_of_symlink() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);++ let foo = b"foo";+ check!(h::create_dir_all(&start, "b/c"));+ check!(h::write(&start, "b/target", foo));+ let c = check!(p::open_dir(&start, Path::new("b/c")));+ check!(h::symlink_dir(&c, "../../b", "up"));++ let path = "b/c/up/target";+ let mut file = check!(h::open(&start, path));+ let mut data = Vec::new();+ check!(file.read_to_end(&mut data));+ assert_eq!(data, foo);+}++/// Like `dotdot_even_other_in_middle_of_symlink`, but with a `/.` at the end.+///+/// Windows doesn't appear to like symlinks that end with `/.`.+#[test]+#[cfg_attr(windows, ignore)]+fn dotdot_slashdot_even_other_in_middle_of_symlink() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);++ let foo = b"foo";+ check!(h::create_dir_all(&start, "b/c"));+ check!(h::write(&start, "b/target", foo));+ let c = check!(p::open_dir(&start, Path::new("b/c")));+ check!(h::symlink_dir(&c, "../../b/.", "up"));++ let path = "b/c/up/target";+ let mut file = check!(h::open(&start, path));+ let mut data = Vec::new();+ check!(file.read_to_end(&mut data));+ assert_eq!(data, foo);+}++/// Ensure that a path of "/" is rejected.+#[test]+fn statat_slash() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);++ // FreeBSD 14+ uses `O_RESOLVE_BENEATH` which issues different errors.+ #[cfg(target_os = "freebsd")]+ {+ error_contains!(h::metadata(&start, "/"), "Capabilities insufficient");+ error_contains!(h::metadata(&start, "/foo"), "Capabilities insufficient");+ error_contains!(+ h::symlink_metadata(&start, "/"),+ "Capabilities insufficient"+ );+ error_contains!(+ h::symlink_metadata(&start, "/foo"),+ "Capabilities insufficient"+ );+ }++ #[cfg(not(target_os = "freebsd"))]+ {+ error_contains!(+ h::metadata(&start, "/"),+ "a path led outside of the filesystem"+ );+ error_contains!(+ h::metadata(&start, "/foo"),+ "a path led outside of the filesystem"+ );+ error_contains!(+ h::symlink_metadata(&start, "/"),+ "a path led outside of the filesyste"+ );+ error_contains!(+ h::symlink_metadata(&start, "/foo"),+ "a path led outside of the filesyste"+ );+ }+}++/// Test interactions between symlinks and trailing slashes.+#[test]+fn trailing_slash_symlink() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);++ check!(h::create_dir(&start, "sandbox"));+ check!(h::symlink_dir(&start, "../outside", "sandbox/hidden"));+ check!(h::symlink_dir(&start, "hidden/", "sandbox/indirect"));++ let sandbox = check!(p::open_dir(&start, Path::new("sandbox")));++ for path in ["hidden", "hidden/", "indirect", "indirect/"] {+ let open_dir = p::open_dir(&sandbox, Path::new(path));+ let read_dir = h::read_dir(&sandbox, path);+ assert!(open_dir.is_err());+ assert!(read_dir.is_err());+ if cfg!(unix) {+ error_contains!(open_dir, "a path led outside of the filesystem");+ error_contains!(read_dir, "a path led outside of the filesystem");+ }+ }+}++/// Similar to `trailing_slash_symlink`, but populates the test directory+/// outside the sandbox, so it can cover more cases.+#[test]+fn trailing_slash_symlink_more() {+ let tmpdir = tempfile::tempdir().unwrap();++ check!(std::fs::create_dir(tmpdir.path().join("sandbox")));+ #[cfg(unix)]+ {+ check!(std::os::unix::fs::symlink(+ "../outside",+ tmpdir.path().join("sandbox/hidden")+ ));+ check!(std::os::unix::fs::symlink(+ "hidden/",+ tmpdir.path().join("sandbox/indirect")+ ));+ check!(std::os::unix::fs::symlink(+ "/.",+ tmpdir.path().join("sandbox/root_link")+ ));+ }+ #[cfg(windows)]+ {+ check!(std::os::windows::fs::symlink_dir(+ "../outside",+ tmpdir.path().join("sandbox/hidden")+ ));+ check!(std::os::windows::fs::symlink_dir(+ "hidden/",+ tmpdir.path().join("sandbox/indirect")+ ));+ check!(std::os::windows::fs::symlink_dir(+ "/.",+ tmpdir.path().join("sandbox/root_link")+ ));+ }+ #[cfg(not(any(unix, windows)))]+ {+ compile_error!("not implemented yet");+ }++ let start = check!(h::open_ambient_dir(tmpdir.path()));++ let sandbox = check!(p::open_dir(&start, Path::new("sandbox")));++ for path in [+ "hidden",+ "hidden/",+ "indirect",+ "indirect/",+ "root_link",+ "root_link/",+ ] {+ let open_dir = p::open_dir(&sandbox, Path::new(path));+ let read_dir = h::read_dir(&sandbox, path);+ assert!(open_dir.is_err());+ assert!(read_dir.is_err());+ if cfg!(unix) {+ error_contains!(open_dir, "a path led outside of the filesystem");+ error_contains!(read_dir, "a path led outside of the filesystem");+ }+ }+}diff --git a/crates/wasi/src/filesystem/primitives/tests/helpers/mod.rs b/crates/wasi/src/filesystem/primitives/tests/helpers/mod.rsnew file mode 100644index 0000000000..22a36c6a00--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/tests/helpers/mod.rs@@ -0,0 +1,152 @@+//! Shared helpers for the tests imported from `cap-std`.+//!+//! These tests were written against `cap_std::fs::Dir`, whose methods bundle up+//! several `crate::filesystem::primitives` calls. Anything that is a bare+//! forward to a primitive is called as `p::foo(..)` directly at the call site;+//! only the operations that add options, flags, or logic live here.++use crate::filesystem::primitives as p;+use std::fs::File;+use std::io;+use std::path::{Path, PathBuf};+use tempfile::TempDir;++/// Open a temporary directory as a start-directory handle.+pub fn dir_of(t: &TempDir) -> File {+ p::open_ambient_dir(t.path()).unwrap()+}++/// `open_ambient_dir` with the ambient authority supplied.+pub fn open_ambient_dir(path: impl AsRef<Path>) -> io::Result<File> {+ p::open_ambient_dir(path.as_ref())+}++/// `Dir::create`: open for writing, creating and truncating.+pub fn create(d: &File, path: impl AsRef<Path>) -> io::Result<File> {+ p::open(+ d,+ path.as_ref(),+ p::OpenOptions::new()+ .write(true)+ .create(true)+ .truncate(true),+ )+}++/// `Dir::open`: open for reading.+pub fn open(d: &File, path: impl AsRef<Path>) -> io::Result<File> {+ p::open(d, path.as_ref(), p::OpenOptions::new().read(true))+}++/// `Dir::create_dir`, with the default `DirOptions`.+pub fn create_dir(d: &File, path: impl AsRef<Path>) -> io::Result<()> {+ p::create_dir(d, path.as_ref(), &p::DirOptions::new())+}++/// `Dir::create_dir_all`, in terms of the single-level `create_dir`.+pub fn create_dir_all(d: &File, path: impl AsRef<Path>) -> io::Result<()> {+ let mut acc = PathBuf::new();+ for component in path.as_ref().components() {+ acc.push(component);+ match p::create_dir(d, &acc, &p::DirOptions::new()) {+ Ok(()) => {}+ Err(e) if e.kind() == io::ErrorKind::AlreadyExists => {}+ Err(e) => return Err(e),+ }+ }+ Ok(())+}++/// `Dir::metadata`: stat, following symlinks.+pub fn metadata(d: &File, path: impl AsRef<Path>) -> io::Result<p::Metadata> {+ p::stat(d, path.as_ref(), p::FollowSymlinks::Yes)+}++/// `Dir::symlink_metadata`: stat, without following symlinks.+pub fn symlink_metadata(d: &File, path: impl AsRef<Path>) -> io::Result<p::Metadata> {+ p::stat(d, path.as_ref(), p::FollowSymlinks::No)+}++/// `DirExt::open_dir_nofollow`.+pub fn open_dir_nofollow(d: &File, path: impl AsRef<Path>) -> io::Result<File> {+ p::open(+ d,+ path.as_ref(),+ p::dir_options().follow(p::FollowSymlinks::No),+ )+}++/// `Dir::read_dir`: open the subdirectory, then read its entries.+pub fn read_dir(d: &File, path: impl AsRef<Path>) -> io::Result<super::super::read_dir::ReadDir> {+ p::read_base_dir(&p::open_dir(d, path.as_ref())?)+}++pub fn exists(d: &File, path: impl AsRef<Path>) -> bool {+ metadata(d, path).is_ok()+}++pub fn is_dir(d: &File, path: impl AsRef<Path>) -> bool {+ metadata(d, path).map(|m| m.is_dir()).unwrap_or(false)+}++pub fn is_file(d: &File, path: impl AsRef<Path>) -> bool {+ metadata(d, path)+ .map(|m| m.file_type().is_file())+ .unwrap_or(false)+}++pub fn write(d: &File, path: impl AsRef<Path>, contents: impl AsRef<[u8]>) -> io::Result<()> {+ use std::io::Write;+ let mut f = create(d, path)?;+ f.write_all(contents.as_ref())+}++pub fn read(d: &File, path: impl AsRef<Path>) -> io::Result<Vec<u8>> {+ use std::io::Read;+ let mut f = open(d, path)?;+ let mut v = Vec::new();+ f.read_to_end(&mut v)?;+ Ok(v)+}++pub fn read_to_string(d: &File, path: impl AsRef<Path>) -> io::Result<String> {+ use std::io::Read;+ let mut f = open(d, path)?;+ let mut s = String::new();+ f.read_to_string(&mut s)?;+ Ok(s)+}++#[cfg(not(windows))]+pub fn symlink(d: &File, src: impl AsRef<Path>, dst: impl AsRef<Path>) -> io::Result<()> {+ p::symlink(src.as_ref(), d, dst.as_ref())+}++#[cfg(windows)]+pub fn symlink(d: &File, src: impl AsRef<Path>, dst: impl AsRef<Path>) -> io::Result<()> {+ if is_dir(d, src.as_ref()) {+ p::symlink_dir(src.as_ref(), d, dst.as_ref())+ } else {+ p::symlink_file(src.as_ref(), d, dst.as_ref())+ }+}++#[cfg(not(windows))]+pub fn symlink_file(d: &File, src: impl AsRef<Path>, dst: impl AsRef<Path>) -> io::Result<()> {+ p::symlink(src.as_ref(), d, dst.as_ref())+}++#[cfg(windows)]+pub fn symlink_file(d: &File, src: impl AsRef<Path>, dst: impl AsRef<Path>) -> io::Result<()> {+ p::symlink_file(src.as_ref(), d, dst.as_ref())+}++#[cfg(not(windows))]+pub fn symlink_dir(d: &File, src: impl AsRef<Path>, dst: impl AsRef<Path>) -> io::Result<()> {+ p::symlink(src.as_ref(), d, dst.as_ref())+}++#[cfg(windows)]+pub fn symlink_dir(d: &File, src: impl AsRef<Path>, dst: impl AsRef<Path>) -> io::Result<()> {+ p::symlink_dir(src.as_ref(), d, dst.as_ref())+}diff --git a/crates/wasi/src/filesystem/primitives/tests/metadata_ext.rs b/crates/wasi/src/filesystem/primitives/tests/metadata_ext.rsnew file mode 100644index 0000000000..6d4fae861f--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/tests/metadata_ext.rs@@ -0,0 +1,90 @@+// This file contains tests for `MetadataExt`.+//+// `dev`/`ino`/`nlink` are only on the Unix `MetadataExt`.+#![cfg(unix)]++use super::helpers as h;+use super::sys_common::io::tmpdir;+use super::sys_common::symlink_supported;+use crate::filesystem::primitives::{+ FollowSymlinks, Metadata, MetadataExt, hard_link, open_ambient_dir, stat,+};+use std::path::Path;++#[test]+fn test_metadata_ext() {+ let tmpdir = tmpdir();+ let dir = check!(open_ambient_dir(tmpdir.path(),));+ let a = check!(h::create(&dir, "a"));+ let b = check!(h::create(&dir, "b"));+ let tmpdir_metadata = check!(Metadata::from_file(&dir));+ let a_metadata = check!(Metadata::from_file(&a));+ let b_metadata = check!(Metadata::from_file(&b));+ let a_dir_metadata = check!(stat(&dir, Path::new("a"), FollowSymlinks::Yes));+ let b_dir_metadata = check!(stat(&dir, Path::new("b"), FollowSymlinks::Yes));+ let a_symlink_metadata = check!(stat(&dir, Path::new("a"), FollowSymlinks::No));+ let b_symlink_metadata = check!(stat(&dir, Path::new("b"), FollowSymlinks::No));++ // The directory and files inside it should be on the same device.+ assert_eq!(tmpdir_metadata.dev(), a_metadata.dev());+ assert_eq!(a_metadata.dev(), b_metadata.dev());++ // They should all have distinct inodes.+ assert_ne!(tmpdir_metadata.ino(), a_metadata.ino());+ assert_ne!(tmpdir_metadata.ino(), b_metadata.ino());+ assert_ne!(a_metadata.ino(), b_metadata.ino());++ // The files should start with just one link.+ assert_eq!(a_metadata.nlink(), 1);+ assert_eq!(b_metadata.nlink(), 1);++ // Add another link and check for it.+ check!(hard_link(&dir, Path::new("b"), &dir, Path::new("c")));+ let b_metadata = check!(Metadata::from_file(&b));+ assert_eq!(b_metadata.nlink(), 2);++ // Check that the metadata has dev/nlink/ino.+ tmpdir_metadata.dev();+ tmpdir_metadata.nlink();+ tmpdir_metadata.ino();+ a_metadata.dev();+ a_metadata.nlink();+ a_metadata.ino();+ b_metadata.dev();+ b_metadata.nlink();+ b_metadata.ino();+ a_dir_metadata.dev();+ a_dir_metadata.nlink();+ a_dir_metadata.ino();+ b_dir_metadata.dev();+ b_dir_metadata.nlink();+ b_dir_metadata.ino();+ a_symlink_metadata.dev();+ a_symlink_metadata.nlink();+ a_symlink_metadata.ino();+ b_symlink_metadata.dev();+ b_symlink_metadata.nlink();+ b_symlink_metadata.ino();++ if symlink_supported() {+ check!(h::symlink_file(&dir, "b", "d"));+ let d_metadata = check!(stat(&dir, Path::new("d"), FollowSymlinks::Yes));+ let d_symlink_metadata = check!(stat(&dir, Path::new("d"), FollowSymlinks::No));++ d_metadata.dev();+ d_metadata.nlink();+ d_metadata.ino();+ d_symlink_metadata.dev();+ d_symlink_metadata.nlink();+ d_symlink_metadata.ino();++ assert_ne!(+ (d_symlink_metadata.ino(), d_symlink_metadata.dev()),+ (b_metadata.ino(), b_metadata.dev())+ );+ assert_eq!(+ (d_metadata.ino(), d_metadata.dev()),+ (b_metadata.ino(), b_metadata.dev())+ );+ }+}diff --git a/crates/wasi/src/filesystem/primitives/tests/mod.rs b/crates/wasi/src/filesystem/primitives/tests/mod.rsnew file mode 100644index 0000000000..85545e17df--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/tests/mod.rs@@ -0,0 +1,19 @@+#[macro_use]+mod sys_common;++mod helpers;++mod cap_basics;+mod file_type_ext;+mod fs;+mod fs_additional;+mod metadata_ext;+mod paths_containing_nul;+mod readdir;+mod rename;+mod rename_directory;+mod reopendir;+mod set_times;+mod symlinks;+mod windows_open;+mod windows_symlinks;diff --git a/crates/wasi/src/filesystem/primitives/tests/paths_containing_nul.rs b/crates/wasi/src/filesystem/primitives/tests/paths_containing_nul.rsnew file mode 100644index 0000000000..4c9247ab19--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/tests/paths_containing_nul.rs@@ -0,0 +1,77 @@+// This test module derived from Rust's src/test/ui/paths-containing-nul.rs+// at revision 108e90ca78f052c0c1c49c42a22c85620be19712.++// run-pass++#![allow(deprecated)]+// ignore-cloudabi no files or I/O+// ignore-wasm32-bare no files or I/O+// ignore-emscripten no files+// ignore-sgx no files++use super::sys_common::io::tmpdir;+use crate::filesystem::primitives::{+ DirOptions, FollowSymlinks, OpenOptions, create_dir, hard_link, open, open_ambient_dir,+ read_link, remove_dir, remove_file, rename, stat,+};+use std::io;+use std::path::Path;++fn assert_invalid_input<T>(on: &str, result: io::Result<T>) {+ fn inner(on: &str, result: io::Result<()>) {+ match result {+ Ok(()) => panic!("{on} didn't return an error on a path with NUL"),+ Err(_e) => {+ // TODO: Re-enable this assertion once the `io_error_more`+ // feature is available.+ /*+ assert_eq!(+ e.kind(),+ io::ErrorKind::InvalidInput || io::ErrorKind::InvalidFilename,+ "{} returned a strange {:?} on a path with NUL",+ on,+ e+ );+ */+ }+ }+ }+ inner(on, result.map(drop))+}++#[test]+fn paths_containing_nul() {+ let tmpdir = tmpdir();+ let dir = open_ambient_dir(tmpdir.path()).unwrap();+ let nul = Path::new("\0");++ assert_invalid_input("open", open(&dir, nul, OpenOptions::new().read(true)));+ assert_invalid_input(+ "create",+ open(+ &dir,+ nul,+ OpenOptions::new().write(true).create(true).truncate(true),+ ),+ );+ assert_invalid_input("remove_file", remove_file(&dir, nul));+ assert_invalid_input("metadata", stat(&dir, nul, FollowSymlinks::Yes));+ assert_invalid_input("symlink_metadata", stat(&dir, nul, FollowSymlinks::No));++ // Create a file inside the sandbox.+ let dummy_file = Path::new("dummy_file");+ open(+ &dir,+ dummy_file,+ OpenOptions::new().write(true).create(true).truncate(true),+ )+ .expect("creating dummy_file");++ assert_invalid_input("rename1", rename(&dir, nul, &dir, Path::new("a")));+ assert_invalid_input("rename2", rename(&dir, dummy_file, &dir, nul));+ assert_invalid_input("hard_link1", hard_link(&dir, nul, &dir, Path::new("a")));+ assert_invalid_input("hard_link2", hard_link(&dir, dummy_file, &dir, nul));+ assert_invalid_input("read_link", read_link(&dir, nul));+ assert_invalid_input("create_dir", create_dir(&dir, nul, &DirOptions::new()));+ assert_invalid_input("remove_dir", remove_dir(&dir, nul));+}diff --git a/crates/wasi/src/filesystem/primitives/tests/readdir.rs b/crates/wasi/src/filesystem/primitives/tests/readdir.rsnew file mode 100644index 0000000000..8ceea29fae--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/tests/readdir.rs@@ -0,0 +1,79 @@+use crate::filesystem::primitives::{DirEntry, open_ambient_dir, read_base_dir};+use std::collections::HashMap;+use std::fs::File;+use std::path::Path;++#[test]+fn test_dir_entries() {+ let tmpdir = tempfile::tempdir().expect("construct tempdir");++ let entries = dir_entries(&tmpdir.path());+ assert_eq!(entries.len(), 0, "empty dir");++ let _f1 = std::fs::File::create(tmpdir.path().join("file1")).expect("create file1");++ let entries = dir_entries(&tmpdir.path());+ assert!(+ entries.get("file1").is_some(),+ "directory contains `file1`: {entries:?}"+ );+ assert_eq!(entries.len(), 1);++ let _f2 = std::fs::File::create(tmpdir.path().join("file2")).expect("create file1");+ let entries = dir_entries(&tmpdir.path());+ assert!(+ entries.get("file1").is_some(),+ "directory contains `file1`: {entries:?}"+ );+ assert!(+ entries.get("file2").is_some(),+ "directory contains `file2`: {entries:?}"+ );+ assert_eq!(entries.len(), 2);+}++#[test]+fn test_reread_entries() {+ let tmpdir = tempfile::tempdir().expect("construct tempdir");+ let dir = open_ambient_dir(tmpdir.path()).unwrap();++ let entries = read_entries(&dir);+ assert_eq!(entries.len(), 0, "empty dir");++ let _f1 = std::fs::File::create(tmpdir.path().join("file1")).expect("create file1");++ let entries = read_entries(&dir);+ assert!(+ entries.get("file1").is_some(),+ "directory contains `file1`: {entries:?}"+ );+ assert_eq!(entries.len(), 1);++ let _f2 = std::fs::File::create(tmpdir.path().join("file2")).expect("create file1");+ let entries = read_entries(&dir);+ assert!(+ entries.get("file1").is_some(),+ "directory contains `file1`: {entries:?}"+ );+ assert!(+ entries.get("file2").is_some(),+ "directory contains `file2`: {entries:?}"+ );+ assert_eq!(entries.len(), 2);+}++fn dir_entries(path: &Path) -> HashMap<String, DirEntry> {+ let dir = open_ambient_dir(path).unwrap();+ read_entries(&dir)+}++fn read_entries(dir: &File) -> HashMap<String, DirEntry> {+ let mut out = HashMap::new();+ for e in read_base_dir(dir).unwrap() {+ let e = e.expect("non-error entry");+ let name = e.file_name().to_str().expect("utf8 filename").to_owned();+ assert!(out.get(&name).is_none(), "name already read: {name}");+ out.insert(name, e);+ }+ out+}diff --git a/crates/wasi/src/filesystem/primitives/tests/rename.rs b/crates/wasi/src/filesystem/primitives/tests/rename.rsnew file mode 100644index 0000000000..ca371eb6f7--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/tests/rename.rs@@ -0,0 +1,238 @@+use super::helpers as h;+use super::sys_common::io::tmpdir;+use crate::filesystem::primitives as p;++use std::path::Path;++/*+#[cfg(not(windows))]+fn rename_path_in_use() -> String {+ rustix::io::Errno::BUSY.into().to_string()+}+#[cfg(windows)]+fn rename_path_in_use() -> String {+ todo!("work out error for rename_path_in_use condition")+}+*/++#[cfg(not(windows))]+fn no_such_file_or_directory() -> String {+ rustix::io::Errno::NOENT.to_string()+}+#[cfg(windows)]+fn no_such_file_or_directory() -> String {+ std::io::Error::from_raw_os_error(windows_sys::Win32::Foundation::ERROR_FILE_NOT_FOUND as i32)+ .to_string()+}++/* // TODO: Platform-specific error code.+cfg_if::cfg_if! {+ if #[cfg(any(+ target_os = "macos",+ target_os = "netbsd",+ target_os = "freebsd",+ target_os = "openbsd",+ target_os = "ios",+ target_os = "tvos",+ target_os = "watchos",+ target_os = "visionos",+ target_os = "dragonfly"+ ))] {+ fn rename_file_over_dir() -> String {+ rustix::io::Errno::ISDIR.into().to_string()+ }++ fn rename_file_over_dot() -> String {+ rename_file_over_dir()+ }++ fn rename_dot_over_file() -> String {+ rustix::io::Errno::INVAL.into().to_string()+ }+ } else {+ fn rename_file_over_dir() -> String {+ rustix::io::Errno::NOTEMPTY.into().to_string()+ }++ fn rename_file_over_dot() -> String {+ rename_path_in_use()+ }++ fn rename_dot_over_file() -> String {+ rename_path_in_use()+ }+ }+}+*/++#[test]+#[cfg_attr(windows, ignore)] // TODO: Blocked on error message discrepancies+fn rename_basics() {+ let tmpdir = tmpdir();+ let dir = h::dir_of(&tmpdir);++ check!(h::create_dir_all(&dir, "foo/bar"));+ check!(h::create(&dir, "foo/bar/file.txt"));++ check!(p::rename(+ &dir,+ Path::new("foo/bar/file.txt"),+ &dir,+ Path::new("foo/bar/renamed.txt")+ ));+ assert!(!h::exists(&dir, "foo/bar/file.txt"));+ assert!(h::exists(&dir, "foo/bar/renamed.txt"));++ check!(p::rename(+ &dir,+ Path::new("foo/bar/renamed.txt"),+ &dir,+ Path::new("foo/bar/renamed.txt")+ ));+ error_contains!(+ p::rename(+ &dir,+ Path::new("foo/bar/renamed.txt"),+ &dir,+ Path::new("..")+ ),+ "a path led outside of the filesystem"+ );+ error_contains!(+ p::rename(+ &dir,+ Path::new("foo/bar/renamed.txt"),+ &dir,+ Path::new("foo/../..")+ ),+ "a path led outside of the filesystem"+ );+ error_contains!(+ p::rename(+ &dir,+ Path::new("foo/bar/renamed.txt"),+ &dir,+ Path::new("/tmp")+ ),+ "a path led outside of the filesystem"+ );+ error_contains!(+ p::rename(+ &dir,+ Path::new("foo/bar/renamed.txt"),+ &dir,+ Path::new("foo/bar/baz/..")+ ),+ &no_such_file_or_directory()+ );+ /* // TODO: Platform-specific error code.+ error!(+ p::rename(&dir, Path::new("foo/bar/renamed.txt"), &dir, Path::new("foo/bar")),+ &rename_file_over_dir()+ );+ */+ check!(p::rename(+ &dir,+ Path::new("foo/bar"),+ &dir,+ Path::new("foo/bar")+ ));+ check!(p::rename(+ &dir,+ Path::new("foo/bar/renamed.txt"),+ &dir,+ Path::new("file.txt")+ ));+ assert!(!h::exists(&dir, "foo/bar/renamed.txt"));+ assert!(h::exists(&dir, "file.txt"));++ /* // TODO: Platform-specific error code.+ error_contains!(+ p::rename(&dir, Path::new("file.txt"), &dir, Path::new("foo/..")),+ &rename_path_in_use()+ );+ error_contains!(+ p::rename(&dir, Path::new("file.txt"), &dir, Path::new("foo/.")),+ &rename_path_in_use()+ );+ error_contains!(+ p::rename(&dir, Path::new("file.txt"), &dir, Path::new("foo/bar/../..")),+ &rename_path_in_use()+ );+ */+ error_contains!(+ p::rename(+ &dir,+ Path::new("file.txt"),+ &dir,+ Path::new("foo/bar/../../..")+ ),+ "a path led outside of the filesystem"+ );+ error_contains!(+ p::rename(+ &dir,+ Path::new("file.txt"),+ &dir,+ Path::new("foo/bar/../../../something")+ ),+ "a path led outside of the filesystem"+ );+ error_contains!(+ p::rename(&dir, Path::new("file.txt"), &dir, Path::new("")),+ "No such file"+ );+ error_contains!(+ p::rename(&dir, Path::new("file.txt"), &dir, Path::new("/")),+ "a path led outside of the filesystem"+ );+ error_contains!(+ p::rename(&dir, Path::new("file.txt"), &dir, Path::new("/.")),+ "a path led outside of the filesystem"+ );+ error_contains!(+ p::rename(&dir, Path::new("file.txt"), &dir, Path::new("/..")),+ "a path led outside of the filesystem"+ );+ error_contains!(+ p::rename(&dir, Path::new("/"), &dir, Path::new("nope.txt")),+ "a path led outside of the filesystem"+ );+ error_contains!(+ p::rename(&dir, Path::new("/.."), &dir, Path::new("nope.txt")),+ "a path led outside of the filesystem"+ );+ error_contains!(+ p::rename(&dir, Path::new("file.txt/"), &dir, Path::new("nope.txt")),+ "Not a directory"+ );++ /* // TODO: Platform-specific error code.+ error!(+ p::rename(&dir, Path::new("file.txt"), &dir, Path::new(".")),+ &rename_file_over_dot()+ );+ error!(+ p::rename(&dir, Path::new("file.txt"), &dir, Path::new("..")),+ &rename_path_in_use()+ );+ error!(+ p::rename(&dir, Path::new(".."), &dir, Path::new("nope.txt")),+ &rename_path_in_use()+ );+ error!(+ p::rename(&dir, Path::new("."), &dir, Path::new("nope.txt")),+ &rename_dot_over_file()+ );+ */++ check!(h::create(&dir, "existing.txt"));+ check!(p::rename(+ &dir,+ Path::new("file.txt"),+ &dir,+ Path::new("existing.txt")+ ));+ assert!(!h::exists(&dir, "file.txt"));+ assert!(h::exists(&dir, "existing.txt"));+}diff --git a/crates/wasi/src/filesystem/primitives/tests/rename_directory.rs b/crates/wasi/src/filesystem/primitives/tests/rename_directory.rsnew file mode 100644index 0000000000..a9e208994a--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/tests/rename_directory.rs@@ -0,0 +1,33 @@+// This test module derived from Rust's+// src/test/ui-fulldeps/rename-directory.rs at revision+// 108e90ca78f052c0c1c49c42a22c85620be19712.++// run-pass++#![allow(unused_must_use)]+// This test can't be a unit test in std,+// because it needs `TempDir`, which is in extra++// ignore-cross-compile++use super::helpers as h;+use super::sys_common::io::tmpdir;+use crate::filesystem::primitives::rename;+use std::path::Path;++#[test]+fn rename_directory() {+ let tmpdir = tmpdir();+ let dir = h::dir_of(&tmpdir);+ let old_path = Path::new("foo/bar/baz");+ h::create_dir_all(&dir, &old_path).unwrap();+ let test_file = &old_path.join("temp.txt");++ h::create(&dir, test_file).unwrap();++ let new_path = Path::new("quux/blat");+ h::create_dir_all(&dir, &new_path).unwrap();+ rename(&dir, &old_path, &dir, &new_path.join("newdir"));+ assert!(h::is_dir(&dir, &new_path.join("newdir")));+ assert!(h::exists(&dir, &new_path.join("newdir/temp.txt")));+}diff --git a/crates/wasi/src/filesystem/primitives/tests/reopendir.rs b/crates/wasi/src/filesystem/primitives/tests/reopendir.rsnew file mode 100644index 0000000000..3ce310a03f--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/tests/reopendir.rs@@ -0,0 +1,72 @@+//! Tests for various forms of reopening a directory handle.++use super::helpers as h;+use super::sys_common::io::tmpdir;+use crate::filesystem::primitives::open_dir;+use std::path::Path;++#[test]+fn reopendir_a() {+ let tmpdir = tmpdir();+ let dir = h::dir_of(&tmpdir);+ check!(h::create_dir_all(&dir, "dir/inner"));++ let inner = check!(open_dir(&dir, Path::new("dir/inner")));++ check!(open_dir(&inner, Path::new(".")));+}++#[test]+fn reopendir_b() {+ let tmpdir = tmpdir();+ let dir = h::dir_of(&tmpdir);+ check!(h::create_dir_all(&dir, "dir/inner"));++ let inner = check!(open_dir(&dir, Path::new("dir/inner")));++ check!(open_dir(&inner, Path::new("./")));+}++#[test]+fn reopendir_c() {+ let tmpdir = tmpdir();+ let dir = h::dir_of(&tmpdir);+ check!(h::create_dir_all(&dir, "dir/inner"));++ let inner = check!(open_dir(&dir, Path::new("dir/inner")));++ check!(open_dir(&inner, Path::new("./.")));+}++#[test]+fn reopendir_d() {+ let tmpdir = tmpdir();+ let dir = h::dir_of(&tmpdir);+ check!(h::create_dir_all(&dir, "dir/inner"));++ let _inner = check!(open_dir(&dir, Path::new("dir/inner")));++ check!(open_dir(&dir, Path::new("dir/inner")));+}++#[test]+fn reopendir_e() {+ let tmpdir = tmpdir();+ let dir = h::dir_of(&tmpdir);+ check!(h::create_dir_all(&dir, "dir/inner"));++ let _inner = check!(open_dir(&dir, Path::new("dir/inner")));++ check!(open_dir(&dir, Path::new("dir/inner/.")));+}++#[test]+fn reopendir_f() {+ let tmpdir = tmpdir();+ let dir = h::dir_of(&tmpdir);+ check!(h::create_dir_all(&dir, "dir/inner"));++ let _inner = check!(open_dir(&dir, Path::new("dir/inner")));++ check!(open_dir(&dir, Path::new("dir/inner/")));+}diff --git a/crates/wasi/src/filesystem/primitives/tests/set_times.rs b/crates/wasi/src/filesystem/primitives/tests/set_times.rsnew file mode 100644index 0000000000..836b8d95fa--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/tests/set_times.rs@@ -0,0 +1,156 @@+use super::helpers as h;+use super::sys_common::io::tmpdir;+use super::sys_common::symlink_supported;+use crate::filesystem::primitives::{Metadata, set_times, set_times_nofollow};+use std::path::Path;+use std::time::SystemTime;++fn modified_time(meta: Metadata) -> SystemTime {+ meta.modified().unwrap()+}++#[test]+fn basic_times() {+ let test_symlinks = symlink_supported();++ let tmpdir = tmpdir();+ let dir = h::dir_of(&tmpdir);+ check!(h::create(&dir, "file"));+ check!(h::create_dir(&dir, "dir"));+ if test_symlinks {+ check!(h::symlink_file(&dir, "file", "file_symlink_file"));+ check!(h::symlink_dir(&dir, "dir", "dir_symlink_dir"));+ }++ let file_time = SystemTime::UNIX_EPOCH;+ check!(set_times(&dir, Path::new("file"), None, Some(file_time)));+ assert_eq!(modified_time(check!(h::metadata(&dir, "file"))), file_time);+ if test_symlinks {+ assert_eq!(+ modified_time(check!(h::metadata(&dir, "file_symlink_file"))),+ file_time+ );+ }++ let dir_time = SystemTime::UNIX_EPOCH;+ check!(set_times(&dir, Path::new("dir"), None, Some(dir_time)));+ assert_eq!(modified_time(check!(h::metadata(&dir, "dir"))), dir_time);+ if test_symlinks {+ assert_eq!(+ modified_time(check!(h::metadata(&dir, "dir_symlink_dir"))),+ dir_time+ );+ }+}++#[test]+fn symlink_times() {+ if !symlink_supported() {+ return;+ }++ let tmpdir = tmpdir();+ let dir = h::dir_of(&tmpdir);+ check!(h::create(&dir, "file"));+ check!(h::create_dir(&dir, "dir"));+ check!(h::symlink_file(&dir, "file", "file_symlink_file"));+ check!(h::symlink_dir(&dir, "dir", "dir_symlink_dir"));++ let file_time = SystemTime::UNIX_EPOCH;+ check!(set_times(+ &dir,+ Path::new("file_symlink_file"),+ None,+ Some(file_time)+ ));+ assert_eq!(modified_time(check!(h::metadata(&dir, "file"))), file_time);+ assert_eq!(+ modified_time(check!(h::metadata(&dir, "file_symlink_file"))),+ file_time+ );+ assert_eq!(+ modified_time(check!(h::symlink_metadata(&dir, "file"))),+ file_time+ );+ assert_ne!(+ modified_time(check!(h::symlink_metadata(&dir, "file_symlink_file"))),+ file_time+ );++ let dir_time = SystemTime::UNIX_EPOCH;+ check!(set_times(+ &dir,+ Path::new("dir_symlink_dir"),+ None,+ Some(file_time)+ ));+ assert_eq!(modified_time(check!(h::metadata(&dir, "dir"))), dir_time);+ assert_eq!(+ modified_time(check!(h::metadata(&dir, "dir_symlink_dir"))),+ dir_time+ );+ assert_eq!(+ modified_time(check!(h::symlink_metadata(&dir, "dir"))),+ dir_time+ );+ assert_ne!(+ modified_time(check!(h::symlink_metadata(&dir, "dir_symlink_dir"))),+ dir_time+ );+}++#[test]+fn symlink_itself_times() {+ if !symlink_supported() {+ return;+ }++ let tmpdir = tmpdir();+ let dir = h::dir_of(&tmpdir);+ check!(h::create(&dir, "file"));+ check!(h::create_dir(&dir, "dir"));+ check!(h::symlink_file(&dir, "file", "file_symlink_file"));+ check!(h::symlink_dir(&dir, "dir", "dir_symlink_dir"));++ let file_time = SystemTime::UNIX_EPOCH;+ check!(set_times_nofollow(+ &dir,+ Path::new("file_symlink_file"),+ None,+ Some(file_time)+ ));+ assert_ne!(modified_time(check!(h::metadata(&dir, "file"))), file_time);+ assert_ne!(+ modified_time(check!(h::metadata(&dir, "file_symlink_file"))),+ file_time+ );+ assert_ne!(+ modified_time(check!(h::symlink_metadata(&dir, "file"))),+ file_time+ );+ assert_eq!(+ modified_time(check!(h::symlink_metadata(&dir, "file_symlink_file"))),+ file_time+ );++ let dir_time = SystemTime::UNIX_EPOCH;+ check!(set_times_nofollow(+ &dir,+ Path::new("dir_symlink_dir"),+ None,+ Some(file_time)+ ));+ assert_ne!(modified_time(check!(h::metadata(&dir, "dir"))), dir_time);+ assert_ne!(+ modified_time(check!(h::metadata(&dir, "dir_symlink_dir"))),+ dir_time+ );+ assert_ne!(+ modified_time(check!(h::symlink_metadata(&dir, "dir"))),+ dir_time+ );+ assert_eq!(+ modified_time(check!(h::symlink_metadata(&dir, "dir_symlink_dir"))),+ dir_time+ );+}diff --git a/crates/wasi/src/filesystem/primitives/tests/symlinks.rs b/crates/wasi/src/filesystem/primitives/tests/symlinks.rsnew file mode 100644index 0000000000..3c2e7d9ec2--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/tests/symlinks.rs@@ -0,0 +1,568 @@+use super::helpers as h;+use super::sys_common::io::tmpdir;+use super::sys_common::symlink_supported;+use crate::filesystem::primitives as p;++use std::path::Path;++#[test]+fn basic_symlinks() {+ if !symlink_supported() {+ return;+ }++ let tmpdir = tmpdir();++ let dir = h::dir_of(&tmpdir);++ check!(h::create(&dir, "file"));+ check!(h::create_dir(&dir, "dir"));+ assert!(check!(h::metadata(&dir, "file")).file_type().is_file());+ assert!(!check!(h::metadata(&dir, "file")).is_dir());+ assert!(check!(h::metadata(&dir, "dir")).is_dir());+ assert!(!check!(h::metadata(&dir, "dir")).file_type().is_file());+ assert!(!check!(h::metadata(&dir, "file")).file_type().is_symlink());+ assert!(!check!(h::metadata(&dir, "dir")).file_type().is_symlink());++ check!(h::symlink_file(&dir, "file", "file_symlink_file"));+ check!(h::symlink_dir(&dir, "dir", "dir_symlink_dir"));+ check!(h::symlink(&dir, "file", "file_symlink"));+ check!(h::symlink(&dir, "dir", "dir_symlink"));++ assert!(+ check!(h::metadata(&dir, "file_symlink_file"))+ .file_type()+ .is_file()+ );+ assert!(check!(h::metadata(&dir, "dir_symlink_dir")).is_dir());+ assert!(+ check!(h::metadata(&dir, "file_symlink"))+ .file_type()+ .is_file()+ );+ assert!(check!(h::metadata(&dir, "dir_symlink")).is_dir());++ assert!(+ !check!(h::metadata(&dir, "file_symlink_file"))+ .file_type()+ .is_symlink()+ );+ assert!(+ !check!(h::metadata(&dir, "dir_symlink_dir"))+ .file_type()+ .is_symlink()+ );+ assert!(+ !check!(h::metadata(&dir, "file_symlink"))+ .file_type()+ .is_symlink()+ );+ assert!(+ !check!(h::metadata(&dir, "dir_symlink"))+ .file_type()+ .is_symlink()+ );++ assert!(+ check!(h::symlink_metadata(&dir, "file_symlink_file"))+ .file_type()+ .is_symlink()+ );+ assert!(+ check!(h::symlink_metadata(&dir, "dir_symlink_dir"))+ .file_type()+ .is_symlink()+ );+ assert!(+ check!(h::symlink_metadata(&dir, "file_symlink"))+ .file_type()+ .is_symlink()+ );+ assert!(+ check!(h::symlink_metadata(&dir, "dir_symlink"))+ .file_type()+ .is_symlink()+ );++ assert!(+ !check!(h::metadata(&dir, "file_symlink_file"))+ .file_type()+ .is_symlink()+ );+ assert!(+ !check!(h::metadata(&dir, "dir_symlink_dir"))+ .file_type()+ .is_symlink()+ );+ assert!(+ !check!(h::metadata(&dir, "file_symlink"))+ .file_type()+ .is_symlink()+ );+ assert!(+ !check!(h::metadata(&dir, "dir_symlink"))+ .file_type()+ .is_symlink()+ );++ assert!(+ check!(h::symlink_metadata(&dir, "file_symlink_file"))+ .file_type()+ .is_symlink()+ );+ assert!(+ check!(h::symlink_metadata(&dir, "dir_symlink_dir"))+ .file_type()+ .is_symlink()+ );+ assert!(+ check!(h::symlink_metadata(&dir, "file_symlink"))+ .file_type()+ .is_symlink()+ );+ assert!(+ check!(h::symlink_metadata(&dir, "dir_symlink"))+ .file_type()+ .is_symlink()+ );+}++#[test]+fn symlink_absolute() {+ let tmpdir = tmpdir();+ let dir = h::dir_of(&tmpdir);++ error_contains!(+ h::symlink(&dir, "/thing", "thing_symlink_file"),+ "a path led outside of the filesystem"+ );+ error_contains!(+ h::symlink_file(&dir, "/file", "file_symlink_file"),+ "a path led outside of the filesystem"+ );+ error_contains!(+ h::symlink_dir(&dir, "/dir", "dir_symlink_dir"),+ "a path led outside of the filesystem"+ );+}++#[test]+fn readlink_absolute() {+ if !symlink_supported() {+ return;+ }++ let dir = tempfile::tempdir().unwrap();++ #[cfg(not(windows))]+ check!(std::os::unix::fs::symlink(+ "/thing",+ dir.path().join("thing_symlink")+ ));+ #[cfg(windows)]+ check!(std::os::windows::fs::symlink_file(+ "/file",+ dir.path().join("file_symlink_file")+ ));+ #[cfg(windows)]+ check!(std::os::windows::fs::symlink_dir(+ "/dir",+ dir.path().join("dir_symlink_dir")+ ));++ let dir = check!(h::open_ambient_dir(dir.path()));++ #[cfg(not(windows))]+ error_contains!(+ p::read_link(&dir, Path::new("thing_symlink")),+ "a path led outside of the filesystem"+ );+ #[cfg(windows)]+ error_contains!(+ p::read_link(&dir, Path::new("file_symlink_file")),+ "a path led outside of the filesystem"+ );+ #[cfg(windows)]+ error_contains!(+ p::read_link(&dir, Path::new("dir_symlink_dir")),+ "a path led outside of the filesystem"+ );+}++/// Opening directories without following symlinks.+#[test]+fn open_dir_nofollow() {+ if !symlink_supported() {+ return;+ }++ let tmpdir = tmpdir();++ let dir = h::dir_of(&tmpdir);++ check!(h::create(&dir, "file"));+ check!(h::create_dir(&dir, "dir"));+ check!(h::symlink_file(&dir, "file", "symlink_file"));+ check!(h::symlink_dir(&dir, "dir", "symlink_dir"));+ check!(h::symlink_dir(&dir, "dir/", "symlink_dir_slash"));+ check!(h::symlink_dir(&dir, "dir/.", "symlink_dir_slashdot"));+ check!(h::symlink_dir(&dir, "dir/..", "symlink_dir_slashdotdot"));+ check!(h::symlink_dir(+ &dir,+ "dir/../",+ "symlink_dir_slashdotdotslash"+ ));+ check!(h::symlink_dir(&dir, ".", "symlink_dot"));+ check!(h::symlink_dir(&dir, "./", "symlink_dotslash"));++ // First try without `nofollow`. The "symlink_dir" case should succeed.+ assert!(p::open_dir(&dir, Path::new("file")).is_err());+ assert!(p::open_dir(&dir, Path::new("symlink_file")).is_err());+ check!(p::open_dir(&dir, Path::new("symlink_dir")));+ #[cfg(windows)]+ check!(p::open_dir(&dir, Path::new("symlink_dir\\")));+ check!(p::open_dir(&dir, Path::new("symlink_dir/")));+ #[cfg(windows)]+ {+ error!(p::open_dir(&dir, Path::new("symlink_dir_slash")), 123);+ error!(p::open_dir(&dir, Path::new("symlink_dir_slashdotdot")), 123);+ error!(+ p::open_dir(&dir, Path::new("symlink_dir_slashdotdotslash")),+ 123+ );+ error!(p::open_dir(&dir, Path::new("symlink_dotslash")), 123);+ error!(p::open_dir(&dir, Path::new("symlink_dir_slashdot")), 123);+ }+ #[cfg(not(windows))]+ {+ check!(p::open_dir(&dir, Path::new("symlink_dir_slash")));+ check!(p::open_dir(&dir, Path::new("symlink_dir_slashdotdot")));+ check!(p::open_dir(&dir, Path::new("symlink_dir_slashdotdotslash")));+ check!(p::open_dir(&dir, Path::new("symlink_dotslash")));+ check!(p::open_dir(&dir, Path::new("symlink_dir_slashdot")));+ }+ check!(p::open_dir(&dir, Path::new("symlink_dot")));+ check!(p::open_dir(&dir, Path::new("dir")));++ // Next try with `nofollow`. The "symlink_dir" case should fail.+ assert!(h::open_dir_nofollow(&dir, "file").is_err());+ assert!(h::open_dir_nofollow(&dir, "symlink_file").is_err());+ assert!(h::open_dir_nofollow(&dir, "symlink_dir").is_err());+ assert!(h::open_dir_nofollow(&dir, "symlink_dir_slash").is_err());+ assert!(h::open_dir_nofollow(&dir, "symlink_dir_slashdot").is_err());+ assert!(h::open_dir_nofollow(&dir, "symlink_dir_slashdotdot").is_err());+ assert!(h::open_dir_nofollow(&dir, "symlink_dir_slashdotdotslash").is_err());+ assert!(h::open_dir_nofollow(&dir, "symlink_dot").is_err());+ assert!(h::open_dir_nofollow(&dir, "symlink_dotslash").is_err());+ check!(h::open_dir_nofollow(&dir, "dir"));++ // Check various ways of spelling `dir/../symlink_dir`.+ for dir_name in &["dir", "symlink_dir"] {+ let name = format!("{dir_name}/../symlink_dir");+ check!(p::open_dir(&dir, Path::new(&name)));+ assert!(h::open_dir_nofollow(&dir, &name).is_err());+ }++ // Check various paths which end with a symlink (even though the symlink+ // expansion may end with `/` or a non-symlink).+ for suffix in &[""] {+ for symlink_dir in &["symlink_dot"] {+ let name = format!("{symlink_dir}{suffix}");+ check!(p::open_dir(&dir, Path::new(&name)));+ assert!(h::open_dir_nofollow(&dir, &name).is_err());+ for dir_name in &["dir", "symlink_dir"] {+ let name = format!("{dir_name}/../{name}");+ check!(p::open_dir(&dir, Path::new(&name)));+ assert!(h::open_dir_nofollow(&dir, &name).is_err());+ }+ }+ }++ // Check more paths which end with a symlink. On Windows, these fail due to+ // the symlink-to-path-ending-in-trailing-slash error.+ for suffix in &[""] {+ for symlink_dir in &[+ "symlink_dir_slashdotdot",+ "symlink_dir_slashdot",+ "symlink_dir_slash",+ "symlink_dir_slashdotdotslash",+ "symlink_dotslash",+ ] {+ let name = format!("{symlink_dir}{suffix}");+ #[cfg(windows)]+ {+ error!(p::open_dir(&dir, Path::new(&name)), 123);+ }+ #[cfg(not(windows))]+ {+ check!(p::open_dir(&dir, Path::new(&name)));+ }+ assert!(h::open_dir_nofollow(&dir, &name).is_err());+ for dir_name in &["dir", "symlink_dir"] {+ let name = format!("{dir_name}/../{name}");+ #[cfg(windows)]+ {+ error!(p::open_dir(&dir, Path::new(&name)), 123);+ }+ #[cfg(not(windows))]+ {+ check!(p::open_dir(&dir, Path::new(&name)));+ }+ assert!(h::open_dir_nofollow(&dir, &name).is_err());+ }+ }+ }++ // Check those same paths, but with various suffixes appended, so that+ // `open_dir_nofollow` can open them.+ for suffix in &["/", "/.", "/./"] {+ for symlink_dir in &["symlink_dir", "symlink_dot"] {+ let name = format!("{symlink_dir}{suffix}");+ check!(p::open_dir(&dir, Path::new(&name)));+ // On Windows, a trailing dot is stripped early.+ if cfg!(not(windows)) || suffix != &"/." {+ check!(h::open_dir_nofollow(&dir, &name));+ } else {+ assert!(h::open_dir_nofollow(&dir, &name).is_err());+ }+ for dir_name in &["dir", "symlink_dir"] {+ let name = format!("{dir_name}/../{name}");+ check!(p::open_dir(&dir, Path::new(&name)));+ // On Windows, a trailing dot is stripped early.+ if cfg!(not(windows)) || suffix != &"/." {+ check!(h::open_dir_nofollow(&dir, &name));+ } else {+ assert!(h::open_dir_nofollow(&dir, &name).is_err());+ }+ }+ }+ }++ // Check those same paths, but with various suffixes appended. On+ // Windows, these fail due to the symlink-to-path-ending-in-trailing-slash+ // error.+ for suffix in &["/", "/.", "/./"] {+ for symlink_dir in &[+ "symlink_dir_slash",+ "symlink_dir_slashdot",+ "symlink_dir_slashdotdot",+ "symlink_dir_slashdotdotslash",+ "symlink_dotslash",+ ] {+ let name = format!("{symlink_dir}{suffix}");+ #[cfg(windows)]+ {+ error!(p::open_dir(&dir, Path::new(&name)), 123);+ assert!(h::open_dir_nofollow(&dir, &name).is_err());+ }+ #[cfg(not(windows))]+ {+ check!(p::open_dir(&dir, Path::new(&name)));+ check!(h::open_dir_nofollow(&dir, &name));+ }+ for dir_name in &["dir", "symlink_dir"] {+ let name = format!("{dir_name}/../{name}");+ #[cfg(windows)]+ {+ error!(p::open_dir(&dir, Path::new(&name)), 123);+ assert!(h::open_dir_nofollow(&dir, &name).is_err());+ }+ #[cfg(not(windows))]+ {+ check!(p::open_dir(&dir, Path::new(&name)));+ check!(h::open_dir_nofollow(&dir, &name));+ }+ }+ }+ }++ // Check various ways of spelling `.`.+ for cur_dir in &["dir/..", "dir/../", ".", "./"] {+ check!(p::open_dir(&dir, Path::new(cur_dir)));+ check!(h::open_dir_nofollow(&dir, cur_dir));+ }+}++/// This test is the same as `open_dir_nofollow` but uses ambient APIs instead+/// of `cap_std`. The purpose of this test is to confirm fundamentally+/// OS-specific behaviors.+#[test]+fn open_dir_nofollow_ambient() {+ #[cfg(unix)]+ use std::os::unix::fs::{symlink as symlink_file, symlink as symlink_dir};+ #[cfg(windows)]+ use std::os::windows::fs::{symlink_dir, symlink_file};++ if !symlink_supported() {+ return;+ }++ let dir = tempfile::tempdir().unwrap();++ check!(std::fs::File::create(dir.path().join("file")));+ check!(std::fs::create_dir(dir.path().join("dir")));+ check!(symlink_file("file", dir.path().join("symlink_file")));+ check!(symlink_dir("dir", dir.path().join("symlink_dir")));+ check!(symlink_dir("dir/", dir.path().join("symlink_dir_slash")));+ check!(symlink_dir(+ "dir/.",+ dir.path().join("symlink_dir_slashdot")+ ));+ check!(symlink_dir(+ "dir/..",+ dir.path().join("symlink_dir_slashdotdot")+ ));+ check!(symlink_dir(+ "dir/../",+ dir.path().join("symlink_dir_slashdotdotslash")+ ));+ check!(symlink_dir("./", dir.path().join("symlink_dotslash")));+ check!(symlink_dir(".", dir.path().join("symlink_dot")));++ assert!(h::open_ambient_dir(dir.path().join("file")).is_err());+ assert!(h::open_ambient_dir(dir.path().join("symlink_file")).is_err());+ check!(h::open_ambient_dir(dir.path().join("symlink_dir")));+ #[cfg(windows)]+ check!(h::open_ambient_dir(dir.path().join("symlink_dir\\")));+ check!(h::open_ambient_dir(dir.path().join("symlink_dir/")));+ #[cfg(windows)]+ {+ error!(+ h::open_ambient_dir(dir.path().join("symlink_dir_slash")),+ 123+ );+ error!(+ h::open_ambient_dir(dir.path().join("symlink_dir_slashdotdot")),+ 123+ );+ error!(+ h::open_ambient_dir(dir.path().join("symlink_dir_slashdotdotslash")),+ 123+ );+ error!(+ h::open_ambient_dir(dir.path().join("symlink_dotslash")),+ 123+ );+ error!(+ h::open_ambient_dir(dir.path().join("symlink_dir_slashdot")),+ 123+ );+ }+ #[cfg(not(windows))]+ {+ check!(h::open_ambient_dir(dir.path().join("symlink_dir_slash")));+ check!(h::open_ambient_dir(+ dir.path().join("symlink_dir_slashdotdot")+ ));+ check!(h::open_ambient_dir(+ dir.path().join("symlink_dir_slashdotdotslash")+ ));+ check!(h::open_ambient_dir(dir.path().join("symlink_dotslash")));+ check!(h::open_ambient_dir(dir.path().join("symlink_dir_slashdot")));+ }+ check!(h::open_ambient_dir(dir.path().join("symlink_dot")));+ check!(h::open_ambient_dir(dir.path().join("dir")));++ // Check various ways of spelling `dir/../symlink_dir`.+ for dir_name in &["dir", "symlink_dir"] {+ let name = format!("{dir_name}/../symlink_dir");+ check!(h::open_ambient_dir(dir.path().join(&name)));+ }++ // Check various paths which end with a symlink (even though the symlink+ // expansion may end with `/` or a non-symlink).+ for suffix in &[""] {+ for symlink_dir in &["symlink_dot"] {+ let name = format!("{symlink_dir}{suffix}");+ check!(h::open_ambient_dir(dir.path().join(&name)));+ for dir_name in &["dir", "symlink_dir"] {+ let name = format!("{dir_name}/../{name}");+ check!(h::open_ambient_dir(dir.path().join(&name)));+ }+ }+ }++ // Check more paths which end with a symlink. On Windows, these fail due to+ // the symlink-to-path-ending-in-trailing-slash error.+ for suffix in &[""] {+ for symlink_dir in &[+ "symlink_dir_slashdotdot",+ "symlink_dir_slashdot",+ "symlink_dir_slash",+ "symlink_dir_slashdotdotslash",+ "symlink_dotslash",+ ] {+ let name = format!("{symlink_dir}{suffix}");+ #[cfg(windows)]+ {+ error!(h::open_ambient_dir(dir.path().join(&name)), 123);+ }+ #[cfg(not(windows))]+ {+ check!(h::open_ambient_dir(dir.path().join(&name)));+ }+ for dir_name in &["dir", "symlink_dir"] {+ let name = format!("{dir_name}/../{name}");+ #[cfg(windows)]+ {+ error!(h::open_ambient_dir(dir.path().join(&name)), 123);+ }+ #[cfg(not(windows))]+ {+ check!(h::open_ambient_dir(dir.path().join(&name)));+ }+ }+ }+ }++ // Check those same paths, but with various suffixes appended.+ for suffix in &["/", "/.", "/./"] {+ for symlink_dir in &["symlink_dir", "symlink_dot"] {+ let name = format!("{symlink_dir}{suffix}");+ check!(h::open_ambient_dir(dir.path().join(&name)));+ for dir_name in &["dir", "symlink_dir"] {+ let name = format!("{dir_name}/../{name}");+ check!(h::open_ambient_dir(dir.path().join(&name)));+ }+ }+ }++ // Check those same paths, but with various suffixes appended. On+ // Windows, these fail due to the+ // symlink-to-path-ending-in-trailing-slash error.+ for suffix in &["/", "/.", "/./"] {+ for symlink_dir in &[+ "symlink_dir_slash",+ "symlink_dir_slashdot",+ "symlink_dir_slashdotdot",+ "symlink_dir_slashdotdotslash",+ "symlink_dotslash",+ ] {+ let name = format!("{symlink_dir}{suffix}");+ #[cfg(windows)]+ {+ error!(h::open_ambient_dir(dir.path().join(&name)), 123);+ }+ #[cfg(not(windows))]+ {+ check!(h::open_ambient_dir(dir.path().join(&name)));+ }+ for dir_name in &["dir", "symlink_dir"] {+ let name = format!("{dir_name}/../{name}");+ #[cfg(windows)]+ {+ error!(h::open_ambient_dir(dir.path().join(&name)), 123);+ }+ #[cfg(not(windows))]+ {+ check!(h::open_ambient_dir(dir.path().join(&name)));+ }+ }+ }+ }++ // Check various ways of spelling `.`.+ for cur_dir in &["dir/..", "dir/../", ".", "./"] {+ check!(h::open_ambient_dir(dir.path().join(cur_dir)));+ }+}diff --git a/crates/wasi/src/filesystem/primitives/tests/sys_common/io.rs b/crates/wasi/src/filesystem/primitives/tests/sys_common/io.rsnew file mode 100644index 0000000000..e0dc74003a--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/tests/sys_common/io.rs@@ -0,0 +1,6 @@+pub use tempfile::TempDir;++#[allow(unused)]+pub fn tmpdir() -> TempDir {+ tempfile::tempdir().expect("expected to be able to create a temporary directory")+}diff --git a/crates/wasi/src/filesystem/primitives/tests/sys_common/mod.rs b/crates/wasi/src/filesystem/primitives/tests/sys_common/mod.rsnew file mode 100644index 0000000000..d13e417d64--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/tests/sys_common/mod.rs@@ -0,0 +1,96 @@+#![allow(unused_imports)]++mod symlink_junction;++pub mod io;++pub use symlink_junction::*;++#[allow(unused)]+macro_rules! check {+ ($e:expr) => {+ match $e {+ Ok(t) => t,+ Err(e) => panic!("{} failed with: {}", stringify!($e), e),+ }+ };+}++#[cfg(windows)]+#[allow(unused)]+macro_rules! error {+ ($e:expr, $s:expr) => {+ match $e {+ Ok(_) => panic!("Unexpected success. Should've been: {:?}", $s),+ Err(ref err) => {+ assert!(+ err.raw_os_error() == Some($s),+ "`{}` did not have a code of `{}`",+ err,+ $s+ )+ }+ }+ };+}++#[cfg(any(unix, target_os = "wasi"))]+#[allow(unused)]+macro_rules! error {+ ($e:expr, $s:expr) => {+ error_contains!($e, $s)+ };+}++#[allow(unused)]+macro_rules! error_contains {+ ($e:expr, $s:expr) => {+ match $e {+ Ok(_) => panic!("Unexpected success. Should've been: {:?}", $s),+ Err(ref err) => {+ assert!(+ err.to_string().contains($s),+ "`{}` did not contain `{}`",+ err,+ $s+ )+ }+ }+ };+}++// The following is derived from Rust's+// src/tools/cargo/crates/cargo-test-support/src/lib.rs at revision+// a78a62fc996ba16f7a111c99520b23f77029f4eb.++#[cfg(windows)]+#[allow(dead_code)]+pub fn symlink_supported() -> bool {+ let dir = tempfile::tempdir().unwrap();++ let src = dir.path().join("symlink_src");+ std::fs::write(&src, "").unwrap();+ let dst = dir.path().join("symlink_dst");+ let result = match std::os::windows::fs::symlink_file(&src, &dst) {+ Ok(_) => {+ std::fs::remove_file(&dst).unwrap();+ true+ }+ Err(e) => {+ eprintln!(+ "symlinks not supported: {:?}\n\+ Windows 10 users should enable developer mode.",+ e+ );+ false+ }+ };+ std::fs::remove_file(&src).unwrap();+ return result;+}++#[cfg(not(windows))]+#[allow(dead_code)]+pub fn symlink_supported() -> bool {+ true+}diff --git a/crates/wasi/src/filesystem/primitives/tests/sys_common/symlink_junction.rs b/crates/wasi/src/filesystem/primitives/tests/sys_common/symlink_junction.rsnew file mode 100644index 0000000000..840dd8fd14--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/tests/sys_common/symlink_junction.rs@@ -0,0 +1,144 @@+// Implementation derived from `symlink_junction` and related code in Rust's+// library/std/src/sys/windows/fs.rs at revision+// 3ffb27ff89db780e88abe829783565a7122be1c5.++use std::path::Path;+use std::{fs, io};++#[cfg(not(windows))]+#[allow(dead_code)]+pub fn symlink_junction<P: AsRef<Path>, Q: AsRef<Path>>(+ src: P,+ dst_dir: &fs::File,+ dst: Q,+) -> io::Result<()> {+ crate::filesystem::primitives::symlink(src.as_ref(), dst_dir, dst.as_ref())+}++#[cfg(windows)]+#[allow(dead_code)]+pub fn symlink_junction<P: AsRef<Path>, Q: AsRef<Path>>(+ src: P,+ dst_dir: &fs::File,+ dst: Q,+) -> io::Result<()> {+ symlink_junction_inner(src.as_ref(), dst_dir, dst.as_ref())+}++/// Align the inner value to 8 bytes.+///+/// This is enough for almost all of the buffers we're likely to work with in+/// the Windows APIs we use.+#[cfg(windows)]+#[repr(C, align(8))]+#[derive(Copy, Clone)]+struct Align8<T: ?Sized>(pub T);++#[cfg(windows)]+#[allow(dead_code)]+#[allow(non_snake_case)]+#[repr(C)]+pub struct REPARSE_MOUNTPOINT_DATA_BUFFER {+ pub ReparseTag: u32,+ pub ReparseDataLength: u32,+ pub Reserved: u16,+ pub ReparseTargetLength: u16,+ pub ReparseTargetMaximumLength: u16,+ pub Reserved1: u16,+ pub ReparseTarget: u16,+}++#[cfg(windows)]+#[allow(dead_code)]+pub fn cvt(i: windows_sys::core::BOOL) -> io::Result<windows_sys::core::BOOL> {+ if i == 0 {+ Err(io::Error::last_os_error())+ } else {+ Ok(i)+ }+}++// Creating a directory junction on windows involves dealing with reparse+// points and the `DeviceIoControl` function, and this code is a skeleton of+// what can be found here:+//+// http://www.flexhex.com/docs/articles/hard-links.phtml+#[cfg(windows)]+#[allow(dead_code)]+fn symlink_junction_inner(original: &Path, dir: &fs::File, junction: &Path) -> io::Result<()> {+ use crate::filesystem::primitives::{+ DirOptions, OpenOptions, OpenOptionsExt, create_dir, open,+ };+ use std::mem::MaybeUninit;+ use std::os::windows::ffi::OsStrExt;+ use std::os::windows::io::AsRawHandle;+ use std::{mem, ptr};+ use windows_sys::Win32::Storage::FileSystem::MAXIMUM_REPARSE_DATA_BUFFER_SIZE;++ create_dir(dir, junction, &DirOptions::new())?;++ let mut opts = OpenOptions::new();+ opts.write(true);+ opts.custom_flags(+ windows_sys::Win32::Storage::FileSystem::FILE_FLAG_OPEN_REPARSE_POINT+ | windows_sys::Win32::Storage::FileSystem::FILE_FLAG_BACKUP_SEMANTICS,+ );+ let f = open(dir, junction, &opts)?;+ let h = f.as_raw_handle();+ unsafe {+ let mut data =+ Align8([MaybeUninit::<u8>::uninit(); MAXIMUM_REPARSE_DATA_BUFFER_SIZE as usize]);+ let data_ptr = data.0.as_mut_ptr();+ let data_end = data_ptr.add(MAXIMUM_REPARSE_DATA_BUFFER_SIZE as usize);+ let db = data_ptr.cast::<REPARSE_MOUNTPOINT_DATA_BUFFER>();+ // Zero the header to ensure it's fully initialized, including reserved parameters.+ *db = mem::zeroed();+ let reparse_target_slice = {+ let buf_start = ptr::addr_of_mut!((*db).ReparseTarget).cast::<u16>();+ // Compute offset in bytes and then divide so that we round down+ // rather than hit any UB (admittedly this arithmetic should work+ // out so that this isn't necessary)+ // TODO: use `byte_offfset_from` when pointer_byte_offsets is stable+ // let buf_len_bytes = usize::try_from(data_end.byte_offset_from(buf_start)).unwrap();+ let buf_len_bytes =+ usize::try_from(data_end.cast::<u8>().offset_from(buf_start.cast::<u8>())).unwrap();+ let buf_len_wchars = buf_len_bytes / core::mem::size_of::<u16>();+ core::slice::from_raw_parts_mut(buf_start, buf_len_wchars)+ };+ // FIXME: this conversion is very hacky+ let iter = br"\??\"+ .iter()+ .map(|x| *x as u16)+ .chain(original.as_os_str().encode_wide())+ .chain(core::iter::once(0));+ let mut i = 0;+ for c in iter {+ if i >= reparse_target_slice.len() {+ return Err(io::Error::new(+ // TODO: use io::ErrorKind::InvalidFilename when io_error_more is stabilized+ io::ErrorKind::Other,+ "Input filename is too long",+ ));+ }+ reparse_target_slice[i] = c;+ i += 1;+ }+ (*db).ReparseTag = windows_sys::Win32::System::SystemServices::IO_REPARSE_TAG_MOUNT_POINT;+ (*db).ReparseTargetMaximumLength = (i * 2) as u16;+ (*db).ReparseTargetLength = ((i - 1) * 2) as u16;+ (*db).ReparseDataLength = (*db).ReparseTargetLength as u32 + 12;++ let mut ret = 0;+ cvt(windows_sys::Win32::System::IO::DeviceIoControl(+ h as _,+ windows_sys::Win32::System::Ioctl::FSCTL_SET_REPARSE_POINT,+ data_ptr.cast(),+ (*db).ReparseDataLength + 8,+ ptr::null_mut(),+ 0,+ &mut ret,+ ptr::null_mut(),+ ))+ .map(drop)+ }+}diff --git a/crates/wasi/src/filesystem/primitives/tests/windows_open.rs b/crates/wasi/src/filesystem/primitives/tests/windows_open.rsnew file mode 100644index 0000000000..d449e4a838--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/tests/windows_open.rs@@ -0,0 +1,208 @@+//! On Windows, cap-std uses the technique of looking up absolute paths for+//! directory handles. This would be racy, except that cap-std uses Windows'+//! sharing modes to prevent open directories from being removed or renamed.+//! Test that this works.++#![cfg(windows)]++use super::helpers as h;+use super::sys_common::io::tmpdir;+use crate::filesystem::primitives as p;+use std::path::Path;++#[test]+fn windows_open_one() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ check!(h::create_dir(&start, "aaa"));++ let dir = check!(p::open_dir(&start, Path::new("aaa")));++ // Attempts to remove or rename the open directory should fail.+ p::remove_dir(&start, Path::new("aaa")).unwrap_err();+ p::rename(&start, Path::new("aaa"), &start, Path::new("zzz")).unwrap_err();++ drop(dir);++ // Now that we've dropped the handle, the same operations should succeed.+ check!(p::rename(+ &start,+ Path::new("aaa"),+ &start,+ Path::new("xxx")+ ));+ check!(p::remove_dir(&start, Path::new("xxx")));+}++#[test]+fn windows_open_multiple() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ check!(h::create_dir_all(&start, "aaa/bbb"));++ let dir = check!(p::open_dir(&start, Path::new("aaa/bbb")));++ // Attempts to remove or rename any component of the open directory should+ // fail.+ p::remove_dir(&start, Path::new("aaa/bbb")).unwrap_err();+ p::remove_dir(&start, Path::new("aaa")).unwrap_err();+ p::rename(&start, Path::new("aaa/bbb"), &start, Path::new("aaa/yyy")).unwrap_err();+ p::rename(&start, Path::new("aaa"), &start, Path::new("zzz")).unwrap_err();++ drop(dir);++ // Now that we've dropped the handle, the same operations should succeed.+ check!(p::rename(+ &start,+ Path::new("aaa/bbb"),+ &start,+ Path::new("aaa/www")+ ));+ check!(p::rename(+ &start,+ Path::new("aaa"),+ &start,+ Path::new("xxx")+ ));+ check!(p::remove_dir(&start, Path::new("xxx/www")));+ check!(p::remove_dir(&start, Path::new("xxx")));+}++/// Like `windows_open_multiple`, but does so within a directory that we+/// can close and then independently mutate.+#[test]+fn windows_open_tricky() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);+ check!(h::create_dir(&start, "qqq"));++ let qqq = check!(p::open_dir(&start, Path::new("qqq")));+ check!(h::create_dir_all(&qqq, "aaa/bbb"));++ let dir = check!(p::open_dir(&qqq, Path::new("aaa/bbb")));++ // Now drop `qqq`.+ drop(qqq);++ // Attempts to remove or rename any component of the open directory should+ // fail.+ p::remove_dir(&dir, Path::new("aaa/bbb")).unwrap_err();+ p::remove_dir(&dir, Path::new("aaa")).unwrap_err();+ p::rename(&dir, Path::new("aaa/bbb"), &dir, Path::new("aaa/yyy")).unwrap_err();+ p::rename(&dir, Path::new("aaa"), &dir, Path::new("zzz")).unwrap_err();+ p::remove_dir(&start, Path::new("qqq/aaa/bbb")).unwrap_err();+ p::remove_dir(&start, Path::new("qqq/aaa")).unwrap_err();+ p::remove_dir(&start, Path::new("qqq")).unwrap_err();+ p::rename(+ &dir,+ Path::new("qqq/aaa/bbb"),+ &dir,+ Path::new("qqq/aaa/yyy"),+ )+ .unwrap_err();+ p::rename(&start, Path::new("qqq/aaa"), &start, Path::new("qqq/zzz")).unwrap_err();+ p::rename(&start, Path::new("qqq"), &start, Path::new("vvv")).unwrap_err();++ drop(dir);++ // Now that we've dropped the handle, the same operations should succeed.+ check!(p::rename(+ &start,+ Path::new("qqq/aaa/bbb"),+ &start,+ Path::new("qqq/aaa/www")+ ));+ check!(p::rename(+ &start,+ Path::new("qqq/aaa"),+ &start,+ Path::new("qqq/xxx")+ ));+ check!(p::rename(+ &start,+ Path::new("qqq"),+ &start,+ Path::new("uuu")+ ));+ check!(p::remove_dir(&start, Path::new("uuu/xxx/www")));+ check!(p::remove_dir(&start, Path::new("uuu/xxx")));+ check!(p::remove_dir(&start, Path::new("uuu")));+}++/// Like `windows_open_one` but uses `open_ambient_dir` instead of `open_dir`.+#[test]+fn windows_open_ambient() {+ let ambient_dir = tempfile::tempdir().unwrap();++ let start = check!(h::open_ambient_dir(ambient_dir.path()));+ check!(h::create_dir(&start, "aaa"));++ let dir = check!(h::open_ambient_dir(ambient_dir.path().join("aaa")));++ // Attempts to remove or rename the open directory should fail.+ p::remove_dir(&start, Path::new("aaa")).unwrap_err();+ p::rename(&start, Path::new("aaa"), &start, Path::new("zzz")).unwrap_err();++ drop(dir);++ // Now that we've dropped the handle, the same operations should succeed.+ check!(p::rename(+ &start,+ Path::new("aaa"),+ &start,+ Path::new("xxx")+ ));+ check!(p::remove_dir(&start, Path::new("xxx")));+}++#[test]+fn windows_open_special() {+ let tmpdir = tmpdir();+ let start = h::dir_of(&tmpdir);++ // Opening any of these should fail.+ for device in &[+ "CON", "PRN", "AUX", "NUL", "COM0", "COM1", "COM2", "COM3", "COM4", "COM5", "COM6", "COM7",+ "COM8", "COM9", "COM¹", "COM²", "COM³", "LPT0", "LPT1", "LPT2", "LPT3", "LPT4", "LPT5",+ "LPT6", "LPT7", "LPT8", "LPT9", "LPT¹", "LPT²", "LPT³",+ ] {+ for suffix in &[+ "",+ " ",+ ".",+ ". ",+ ".ext",+ ".ext.",+ ".ext. ",+ ".ext ",+ ".ext.more",+ ".ext.more.",+ ".ext.more ",+ ".ext.more. ",+ ".ext.more .",+ ] {+ let name = format!("{}{}", device, suffix);+ eprintln!("testing '{}'", name);++ match h::open(&start, &name).unwrap_err().kind() {+ std::io::ErrorKind::NotFound | std::io::ErrorKind::PermissionDenied => {}+ kind => panic!("unexpected error: {:?}", kind),+ }++ let mut options = p::OpenOptions::new();+ options.write(true);+ match p::open(&start, Path::new(&name), &options)+ .unwrap_err()+ .kind()+ {+ std::io::ErrorKind::NotFound | std::io::ErrorKind::PermissionDenied => {}+ kind => panic!("unexpected error: {:?}", kind),+ }++ match h::create(&start, &name).unwrap_err().kind() {+ std::io::ErrorKind::NotFound | std::io::ErrorKind::PermissionDenied => {}+ kind => panic!("unexpected error: {:?}", kind),+ }+ }+ }+}diff --git a/crates/wasi/src/filesystem/primitives/tests/windows_symlinks.rs b/crates/wasi/src/filesystem/primitives/tests/windows_symlinks.rsnew file mode 100644index 0000000000..3a8c88b783--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/tests/windows_symlinks.rs@@ -0,0 +1,84 @@+#![cfg(windows)]++use super::helpers as h;+use super::sys_common::io::tmpdir;+use super::sys_common::symlink_supported;+use crate::filesystem::primitives as p;++use std::path::Path;++#[test]+fn windows_symlinks() {+ if !symlink_supported() {+ return;+ }++ let tmpdir = tmpdir();++ let start = h::dir_of(&tmpdir);++ check!(h::create(&start, "file"));+ check!(h::create_dir(&start, "dir"));++ // Windows lets these succeed.+ check!(h::symlink_dir(&start, "file", "file_symlink_dir"));+ check!(h::symlink_file(&start, "dir", "dir_symlink_file"));++ // But accessing them fails.+ assert!(h::open(&start, "dir_symlink_file").is_err());+ assert!(h::open(&start, "file_symlink_dir").is_err());+ assert!(p::open_dir(&start, Path::new("dir_symlink_file")).is_err());+ assert!(p::open_dir(&start, Path::new("file_symlink_dir")).is_err());+ assert!(h::metadata(&start, "dir_symlink_file").is_err());+ assert!(h::metadata(&start, "file_symlink_dir").is_err());++ assert!(+ check!(h::symlink_metadata(&start, "file_symlink_dir"))+ .file_type()+ .is_symlink()+ );+ assert!(+ check!(h::symlink_metadata(&start, "dir_symlink_file"))+ .file_type()+ .is_symlink()+ );+}++#[test]+fn windows_symlinks_ambient() {+ use std::fs;+ use std::os::windows::fs::{symlink_dir, symlink_file};++ if !symlink_supported() {+ return;+ }++ let dir = tempfile::tempdir().unwrap();++ check!(fs::File::create(dir.path().join("file")));+ check!(fs::create_dir(dir.path().join("dir")));++ // Windows lets these succeed.+ check!(symlink_dir("file", dir.path().join("file_symlink_dir")));+ check!(symlink_file("dir", dir.path().join("dir_symlink_file")));++ // But accessing them fails.+ assert!(fs::File::open(dir.path().join("dir_symlink_file")).is_err());+ assert!(fs::File::open(dir.path().join("file_symlink_dir")).is_err());++ assert!(h::open_ambient_dir(dir.path().join("dir_symlink_file")).is_err());+ assert!(h::open_ambient_dir(dir.path().join("file_symlink_dir")).is_err());+ assert!(fs::metadata(dir.path().join("dir_symlink_file")).is_err());+ assert!(fs::metadata(dir.path().join("file_symlink_dir")).is_err());++ assert!(+ check!(fs::symlink_metadata(dir.path().join("file_symlink_dir")))+ .file_type()+ .is_symlink()+ );+ assert!(+ check!(fs::symlink_metadata(dir.path().join("dir_symlink_file")))+ .file_type()+ .is_symlink()+ );+}diff --git a/crates/wasi/src/filesystem/primitives/via_parent/create_dir.rs b/crates/wasi/src/filesystem/primitives/via_parent/create_dir.rsnew file mode 100644index 0000000000..900420de1e--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/via_parent/create_dir.rs@@ -0,0 +1,21 @@+use super::open_parent;+use crate::filesystem::primitives::{+ DirOptions, MaybeOwnedFile, create_dir_unchecked, strip_dir_suffix,+};+use std::path::Path;+use std::{fs, io};++/// 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)+}diff --git a/crates/wasi/src/filesystem/primitives/via_parent/hard_link.rs b/crates/wasi/src/filesystem/primitives/via_parent/hard_link.rsnew file mode 100644index 0000000000..b725ca7f6f--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/via_parent/hard_link.rs@@ -0,0 +1,26 @@+use super::open_parent;+use crate::filesystem::primitives::{MaybeOwnedFile, hard_link_unchecked};+use std::path::Path;+use std::{fs, io};++/// Implement `hard_link` by `open`ing up the parent component of the path and+/// then calling `hard_link_unchecked` on the last component.+pub(crate) fn hard_link(+ old_start: &fs::File,+ old_path: &Path,+ new_start: &fs::File,+ new_path: &Path,+) -> io::Result<()> {+ let old_start = MaybeOwnedFile::borrowed(old_start);+ let new_start = MaybeOwnedFile::borrowed(new_start);++ let (old_dir, old_basename) = open_parent(old_start, old_path)?;+ let (new_dir, new_basename) = open_parent(new_start, new_path)?;++ hard_link_unchecked(+ &old_dir,+ old_basename.as_ref(),+ &new_dir,+ new_basename.as_ref(),+ )+}diff --git a/crates/wasi/src/filesystem/primitives/via_parent/mod.rs b/crates/wasi/src/filesystem/primitives/via_parent/mod.rsnew file mode 100644index 0000000000..5c6241e7f2--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/via_parent/mod.rs@@ -0,0 +1,31 @@+//! In many operations, the last component of a path is special. For example,+//! 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 open_parent;+#[cfg(not(windows))] // doesn't work on windows; use a windows-specific impl+mod read_link;+mod remove_dir;+mod remove_file;+mod rename;+#[cfg(not(windows))]+mod set_times_nofollow;+mod symlink;++use open_parent::open_parent;++pub(crate) use create_dir::create_dir;+pub(crate) use hard_link::hard_link;+#[cfg(not(windows))] // doesn't work on windows; use a windows-specific impl+pub(crate) use read_link::read_link;+pub(crate) use remove_dir::remove_dir;+pub(crate) use remove_file::remove_file;+pub(crate) use rename::rename;+#[cfg(not(windows))]+pub(crate) use set_times_nofollow::set_times_nofollow;+#[cfg(not(windows))]+pub(crate) use symlink::symlink;+#[cfg(windows)]+pub(crate) use symlink::{symlink_dir, symlink_file};diff --git a/crates/wasi/src/filesystem/primitives/via_parent/open_parent.rs b/crates/wasi/src/filesystem/primitives/via_parent/open_parent.rsnew file mode 100644index 0000000000..974e4ebfd5--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/via_parent/open_parent.rs@@ -0,0 +1,126 @@+/// `open_parent` is the key building block in all `via_parent` functions.+/// It opens the parent directory of the given path, and returns the basename,+/// so that all the `via_parent` functions need to do is make sure they+/// don't follow symlinks in the basename.+use crate::filesystem::primitives::{MaybeOwnedFile, errors, open_dir, path_requires_dir};+use std::ffi::OsStr;+use std::io;+use std::path::{Component, Path};++/// Open the "parent" of `path`, relative to `start`. The return value on+/// success is a tuple of the newly opened directory and an `OsStr` referencing+/// the single remaining path component. This last component will not be `..`,+/// though it may be `.` or a symbolic link to anywhere (possibly+/// including `..` or an absolute path).+pub(super) fn open_parent<'path, 'borrow>(+ start: MaybeOwnedFile<'borrow>,+ path: &'path Path,+) -> io::Result<(MaybeOwnedFile<'borrow>, &'path OsStr)> {+ let (dirname, basename) = split_parent(path).ok_or_else(errors::no_such_file_or_directory)?;++ let dir = if dirname.as_os_str().is_empty() {+ start+ } else {+ MaybeOwnedFile::owned(open_dir(&start, dirname)?)+ };++ Ok((dir, basename.as_os_str()))+}++/// Split `path` into parent and basename parts. Return `None` if `path`+/// is empty.+///+/// This differs from `path.parent()` and `path.file_name()` in several+/// respects:+/// - Treat paths ending in `/` or `/.` as implying a directory.+/// - Treat the path `.` as a normal component rather than a parent.+/// - Append a `.` to a path with a trailing `..` to avoid requiring our+/// callers to special-case `..`.+/// - Bare absolute paths are ok.+fn split_parent(path: &Path) -> Option<(&Path, Component<'_>)> {+ if path.as_os_str().is_empty() {+ return None;+ }++ if !path_requires_dir(path) {+ let mut comps = path.components();+ if let Some(p) = comps.next_back() {+ match p {+ Component::Normal(_) | Component::CurDir => return Some((comps.as_path(), p)),+ _ => (),+ }+ }+ }++ Some((path, Component::CurDir))+}++#[test]+fn split_parent_basics() {+ assert_eq!(+ split_parent(Path::new("foo/bar/qux")).unwrap(),+ (+ Path::new("foo/bar"),+ Component::Normal(Path::new("qux").as_ref())+ )+ );+ assert_eq!(+ split_parent(Path::new("foo/bar")).unwrap(),+ (+ Path::new("foo"),+ Component::Normal(Path::new("bar").as_ref())+ )+ );+ assert_eq!(+ split_parent(Path::new("foo")).unwrap(),+ (Path::new(""), Component::Normal(Path::new("foo").as_ref()))+ );+}++#[test]+fn split_parent_special_cases() {+ assert!(split_parent(Path::new("")).is_none());+ assert_eq!(+ split_parent(Path::new("foo/")).unwrap(),+ (Path::new("foo"), Component::CurDir)+ );+ assert_eq!(+ split_parent(Path::new("foo/.")).unwrap(),+ (Path::new("foo"), Component::CurDir)+ );+ assert_eq!(+ split_parent(Path::new(".")).unwrap(),+ (Path::new(""), Component::CurDir)+ );+ assert_eq!(+ split_parent(Path::new("..")).unwrap(),+ (Path::new(".."), Component::CurDir)+ );+ assert_eq!(+ split_parent(Path::new("../..")).unwrap(),+ (Path::new("../.."), Component::CurDir)+ );+ assert_eq!(+ split_parent(Path::new("../foo")).unwrap(),+ (+ Path::new(".."),+ Component::Normal(Path::new("foo").as_ref())+ )+ );+ assert_eq!(+ split_parent(Path::new("foo/..")).unwrap(),+ (Path::new("foo/.."), Component::CurDir)+ );+ assert_eq!(+ split_parent(Path::new("/foo")).unwrap(),+ (Path::new("/"), Component::Normal(Path::new("foo").as_ref()))+ );+ assert_eq!(+ split_parent(Path::new("/foo/")).unwrap(),+ (Path::new("/foo"), Component::CurDir)+ );+ assert_eq!(+ split_parent(Path::new("/")).unwrap(),+ (Path::new("/"), Component::CurDir)+ );+}diff --git a/crates/wasi/src/filesystem/primitives/via_parent/read_link.rs b/crates/wasi/src/filesystem/primitives/via_parent/read_link.rsnew file mode 100644index 0000000000..edd03a4baf--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/via_parent/read_link.rs@@ -0,0 +1,21 @@+use super::open_parent;+use crate::filesystem::primitives::{MaybeOwnedFile, read_link_unchecked};+use std::path::{Path, PathBuf};+use std::{fs, io};++/// Implement `read_link` by `open`ing up the parent component of the path and+/// then calling `read_link_unchecked` on the last component.+///+/// This technique doesn't work in all cases on Windows. In particular, a+/// directory symlink such as `C:\Documents and Settings` may not grant any+/// access other than what is needed to resolve the symlink, so `open_parent`'s+/// technique of returning a relative path of `.` from that point doesn't work,+/// because opening `.` within such a directory is denied. Consequently, we use+/// a different implementation on Windows.+pub(crate) fn read_link(start: &fs::File, path: &Path) -> io::Result<PathBuf> {+ let start = MaybeOwnedFile::borrowed(start);++ let (dir, basename) = open_parent(start, path)?;++ read_link_unchecked(&dir, basename.as_ref(), PathBuf::new())+}diff --git a/crates/wasi/src/filesystem/primitives/via_parent/remove_dir.rs b/crates/wasi/src/filesystem/primitives/via_parent/remove_dir.rsnew file mode 100644index 0000000000..9a46149df7--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/via_parent/remove_dir.rs@@ -0,0 +1,14 @@+use super::open_parent;+use crate::filesystem::primitives::{MaybeOwnedFile, remove_dir_unchecked};+use std::path::Path;+use std::{fs, io};++/// Implement `remove_dir` by `open`ing up the parent component of the path and+/// then calling `remove_dir_unchecked` on the last component.+pub(crate) fn remove_dir(start: &fs::File, path: &Path) -> io::Result<()> {+ let start = MaybeOwnedFile::borrowed(start);++ let (dir, basename) = open_parent(start, path)?;++ remove_dir_unchecked(&dir, basename.as_ref())+}diff --git a/crates/wasi/src/filesystem/primitives/via_parent/remove_file.rs b/crates/wasi/src/filesystem/primitives/via_parent/remove_file.rsnew file mode 100644index 0000000000..7b06f727e4--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/via_parent/remove_file.rs@@ -0,0 +1,14 @@+use super::open_parent;+use crate::filesystem::primitives::{MaybeOwnedFile, remove_file_unchecked};+use std::path::Path;+use std::{fs, io};++/// Implement `remove_file` by `open`ing up the parent component of the path+/// and then calling `remove_file_unchecked` on the last component.+pub(crate) fn remove_file(start: &fs::File, path: &Path) -> io::Result<()> {+ let start = MaybeOwnedFile::borrowed(start);++ let (dir, basename) = open_parent(start, path)?;++ remove_file_unchecked(&dir, basename.as_ref())+}diff --git a/crates/wasi/src/filesystem/primitives/via_parent/rename.rs b/crates/wasi/src/filesystem/primitives/via_parent/rename.rsnew file mode 100644index 0000000000..0e62eb3625--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/via_parent/rename.rs@@ -0,0 +1,50 @@+use super::open_parent;+use crate::filesystem::primitives::{MaybeOwnedFile, rename_unchecked, strip_dir_suffix};+#[cfg(unix)]+use crate::filesystem::primitives::{append_dir_suffix, path_has_trailing_slash};+use std::path::Path;+use std::{fs, io};++/// Implement `rename` by `open`ing up the parent component of the path and+/// then calling `rename_unchecked` on the last component.+pub(crate) fn rename(+ old_start: &fs::File,+ old_path: &Path,+ new_start: &fs::File,+ new_path: &Path,+) -> io::Result<()> {+ let old_start = MaybeOwnedFile::borrowed(old_start);+ let new_start = MaybeOwnedFile::borrowed(new_start);++ // As a special case, `rename` ignores a trailing slash rather than treating+ // it as equivalent to a trailing slash-dot, so strip any trailing slashes+ // for the purposes of `open_parent`.+ //+ // And on Unix, remember whether the source started with a slash so that we+ // can still fail if it is and the source is a regular file.+ #[cfg(unix)]+ let old_starts_with_slash = path_has_trailing_slash(old_path);+ let old_path = strip_dir_suffix(old_path);+ let new_path = strip_dir_suffix(new_path);++ let (old_dir, old_basename) = open_parent(old_start, &old_path)?;+ let (new_dir, new_basename) = open_parent(new_start, &new_path)?;++ // On Unix, re-append a slash if needed.+ #[cfg(unix)]+ let concat;+ #[cfg(unix)]+ let old_basename = if old_starts_with_slash {+ concat = append_dir_suffix(old_basename.to_owned().into());+ concat.as_os_str()+ } else {+ old_basename+ };++ rename_unchecked(+ &old_dir,+ old_basename.as_ref(),+ &new_dir,+ new_basename.as_ref(),+ )+}diff --git a/crates/wasi/src/filesystem/primitives/via_parent/set_times_nofollow.rs b/crates/wasi/src/filesystem/primitives/via_parent/set_times_nofollow.rsnew file mode 100644index 0000000000..8a4146e0af--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/via_parent/set_times_nofollow.rs@@ -0,0 +1,19 @@+use super::open_parent;+use crate::filesystem::primitives::{MaybeOwnedFile, set_times_nofollow_unchecked};+use std::path::Path;+use std::time::SystemTime;+use std::{fs, io};++#[inline]+pub(crate) fn set_times_nofollow(+ start: &fs::File,+ path: &Path,+ atime: Option<SystemTime>,+ mtime: Option<SystemTime>,+) -> io::Result<()> {+ let start = MaybeOwnedFile::borrowed(start);++ let (dir, basename) = open_parent(start, path)?;++ set_times_nofollow_unchecked(&dir, basename.as_ref(), atime, mtime)+}diff --git a/crates/wasi/src/filesystem/primitives/via_parent/symlink.rs b/crates/wasi/src/filesystem/primitives/via_parent/symlink.rsnew file mode 100644index 0000000000..6ea53afc8f--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/via_parent/symlink.rs@@ -0,0 +1,48 @@+use super::open_parent;+use crate::filesystem::primitives::MaybeOwnedFile;+use std::path::Path;+use std::{fs, io};++/// Implement `symlink` by `open`ing up the parent component of the path and+/// then calling `symlink_unchecked` on the last component.+#[cfg(not(windows))]+pub(crate) fn symlink(old_path: &Path, new_start: &fs::File, new_path: &Path) -> io::Result<()> {+ use crate::filesystem::primitives::symlink_unchecked;+ let new_start = MaybeOwnedFile::borrowed(new_start);++ let (new_dir, new_basename) = open_parent(new_start, new_path)?;++ symlink_unchecked(old_path, &new_dir, new_basename.as_ref())+}++/// Implement `symlink_file` by `open`ing up the parent component of the path+/// and then calling `symlink_file` on the last component.+#[cfg(windows)]+pub(crate) fn symlink_file(+ old_path: &Path,+ new_start: &fs::File,+ new_path: &Path,+) -> io::Result<()> {+ use crate::filesystem::primitives::symlink_file_unchecked;+ let new_start = MaybeOwnedFile::borrowed(new_start);++ let (new_dir, new_basename) = open_parent(new_start, new_path)?;++ symlink_file_unchecked(old_path, &new_dir, new_basename.as_ref())+}++/// Implement `symlink_dir` by `open`ing up the parent component of the path+/// and then calling `symlink_dir` on the last component.+#[cfg(windows)]+pub(crate) fn symlink_dir(+ old_path: &Path,+ new_start: &fs::File,+ new_path: &Path,+) -> io::Result<()> {+ use crate::filesystem::primitives::symlink_dir_unchecked;+ let new_start = MaybeOwnedFile::borrowed(new_start);++ let (new_dir, new_basename) = open_parent(new_start, new_path)?;++ symlink_dir_unchecked(old_path, &new_dir, new_basename.as_ref())+}diff --git a/crates/wasi/src/filesystem/primitives/windows/fs/create_dir_unchecked.rs b/crates/wasi/src/filesystem/primitives/windows/fs/create_dir_unchecked.rsnew file mode 100644index 0000000000..442b389169--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/windows/fs/create_dir_unchecked.rs@@ -0,0 +1,18 @@+use super::get_path::concatenate;+use crate::filesystem::primitives::DirOptions;+use std::path::Path;+use std::{fs, io};++/// *Unsandboxed* function similar to `create_dir`, but which does not perform+/// sandboxing.+///+/// Windows doesn't have any extra flags in `DirOptions`, so the `options`+/// parameter is ignored.+pub(crate) fn create_dir_unchecked(+ start: &fs::File,+ path: &Path,+ _options: &DirOptions,+) -> io::Result<()> {+ let out_path = concatenate(start, path)?;+ fs::create_dir(out_path)+}diff --git a/crates/wasi/src/filesystem/primitives/windows/fs/create_file_at_w.rs b/crates/wasi/src/filesystem/primitives/windows/fs/create_file_at_w.rsnew file mode 100644index 0000000000..be0b7c6649--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/windows/fs/create_file_at_w.rs@@ -0,0 +1,280 @@+#![allow(unsafe_code)]++use std::mem;+use std::os::windows::io::HandleOrInvalid;+use std::ptr::null_mut;+use windows_sys::Wdk::Foundation::OBJECT_ATTRIBUTES;+use windows_sys::Wdk::Storage::FileSystem::{+ FILE_CREATE, FILE_DELETE_ON_CLOSE, FILE_NO_INTERMEDIATE_BUFFERING, FILE_NON_DIRECTORY_FILE,+ FILE_OPEN, FILE_OPEN_FOR_BACKUP_INTENT, FILE_OPEN_IF, FILE_OPEN_REPARSE_POINT, FILE_OVERWRITE,+ FILE_OVERWRITE_IF, FILE_RANDOM_ACCESS, FILE_SEQUENTIAL_ONLY, FILE_SYNCHRONOUS_IO_NONALERT,+ FILE_WRITE_THROUGH, NtCreateFile,+};+use windows_sys::Win32::Foundation::{+ ERROR_ALREADY_EXISTS, ERROR_FILE_EXISTS, ERROR_INVALID_NAME, ERROR_INVALID_PARAMETER,+ ERROR_NOT_SUPPORTED, GENERIC_ALL, GENERIC_READ, GENERIC_WRITE, HANDLE, INVALID_HANDLE_VALUE,+ RtlNtStatusToDosError, STATUS_OBJECT_NAME_COLLISION, STATUS_PENDING, STATUS_SUCCESS, SUCCESS,+ SetLastError, UNICODE_STRING,+};+use windows_sys::Win32::Foundation::{OBJ_CASE_INSENSITIVE, OBJ_INHERIT};+use windows_sys::Win32::Security::{+ SECURITY_ATTRIBUTES, SECURITY_DESCRIPTOR, SECURITY_DYNAMIC_TRACKING,+ SECURITY_QUALITY_OF_SERVICE, SECURITY_STATIC_TRACKING,+};+use windows_sys::Win32::Storage::FileSystem::{+ CREATE_ALWAYS, CREATE_NEW, DELETE, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_COMPRESSED,+ FILE_ATTRIBUTE_DEVICE, FILE_ATTRIBUTE_DIRECTORY, FILE_ATTRIBUTE_EA, FILE_ATTRIBUTE_ENCRYPTED,+ FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_INTEGRITY_STREAM, FILE_ATTRIBUTE_NO_SCRUB_DATA,+ FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_NOT_CONTENT_INDEXED, FILE_ATTRIBUTE_OFFLINE,+ FILE_ATTRIBUTE_PINNED, FILE_ATTRIBUTE_READONLY, FILE_ATTRIBUTE_RECALL_ON_DATA_ACCESS,+ FILE_ATTRIBUTE_RECALL_ON_OPEN, FILE_ATTRIBUTE_REPARSE_POINT, FILE_ATTRIBUTE_SPARSE_FILE,+ FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_TEMPORARY, FILE_ATTRIBUTE_UNPINNED,+ FILE_ATTRIBUTE_VIRTUAL, FILE_CREATION_DISPOSITION, FILE_FLAG_BACKUP_SEMANTICS,+ FILE_FLAG_DELETE_ON_CLOSE, FILE_FLAG_NO_BUFFERING, FILE_FLAG_OPEN_NO_RECALL,+ FILE_FLAG_OPEN_REPARSE_POINT, FILE_FLAG_OVERLAPPED, FILE_FLAG_POSIX_SEMANTICS,+ FILE_FLAG_RANDOM_ACCESS, FILE_FLAG_SEQUENTIAL_SCAN, FILE_FLAG_SESSION_AWARE,+ FILE_FLAG_WRITE_THROUGH, FILE_FLAGS_AND_ATTRIBUTES, FILE_READ_ATTRIBUTES, FILE_SHARE_MODE,+ OPEN_ALWAYS, OPEN_EXISTING, SECURITY_CONTEXT_TRACKING, SECURITY_EFFECTIVE_ONLY,+ SECURITY_SQOS_PRESENT, SYNCHRONIZE, TRUNCATE_EXISTING,+};+use windows_sys::Win32::System::IO::IO_STATUS_BLOCK;+use windows_sys::Win32::System::WindowsProgramming::{+ FILE_OPEN_NO_RECALL, FILE_OPEN_REMOTE_INSTANCE, FILE_OPENED, FILE_OVERWRITTEN,+};++// All currently known `FILE_ATTRIBUTE_*` constants, according to+// windows-sys' documentation.+const FILE_ATTRIBUTE_VALID_FLAGS: FILE_FLAGS_AND_ATTRIBUTES = FILE_ATTRIBUTE_EA+ | FILE_ATTRIBUTE_DEVICE+ | FILE_ATTRIBUTE_HIDDEN+ | FILE_ATTRIBUTE_NORMAL+ | FILE_ATTRIBUTE_PINNED+ | FILE_ATTRIBUTE_SYSTEM+ | FILE_ATTRIBUTE_ARCHIVE+ | FILE_ATTRIBUTE_OFFLINE+ | FILE_ATTRIBUTE_VIRTUAL+ | FILE_ATTRIBUTE_READONLY+ | FILE_ATTRIBUTE_UNPINNED+ | FILE_ATTRIBUTE_DIRECTORY+ | FILE_ATTRIBUTE_ENCRYPTED+ | FILE_ATTRIBUTE_TEMPORARY+ | FILE_ATTRIBUTE_COMPRESSED+ | FILE_ATTRIBUTE_SPARSE_FILE+ | FILE_ATTRIBUTE_NO_SCRUB_DATA+ | FILE_ATTRIBUTE_REPARSE_POINT+ | FILE_ATTRIBUTE_RECALL_ON_OPEN+ | FILE_ATTRIBUTE_INTEGRITY_STREAM+ | FILE_ATTRIBUTE_NOT_CONTENT_INDEXED+ | FILE_ATTRIBUTE_RECALL_ON_DATA_ACCESS;++/// Like Windows' `CreateFileW`, but takes a `dir` argument to use as the+/// root directory.+///+/// Also, the `lpfilename` is a Rust slice instead of a C-style NUL-terminated+/// array, because that's what our callers have and it's closer to what+/// `NtCreatePath` takes.+#[allow(non_snake_case)]+pub unsafe fn CreateFileAtW(+ dir: HANDLE,+ lpfilename: &[u16],+ dwdesiredaccess: u32,+ dwsharemode: FILE_SHARE_MODE,+ lpsecurityattributes: *const SECURITY_ATTRIBUTES,+ dwcreationdisposition: FILE_CREATION_DISPOSITION,+ dwflagsandattributes: FILE_FLAGS_AND_ATTRIBUTES,+ htemplatefile: HANDLE,+) -> HandleOrInvalid {+ // Absolute paths are not yet implemented here.+ //+ // It seems like `NtCreatePath` needs the apparently NT-internal `\??\`+ // prefix prepended to absolute paths. It's possible it needs other+ // path transforms as well. `RtlDosPathNameToNtPathName_U` may be a+ // function that does these things, though it's not available in+ // windows-sys and not documented, though one can find+ // [unofficial blog posts], though even they say things like "I`m+ // sorry that I cannot give more details on these functions".+ //+ // [unofficial blog posts]: https://mecanik.dev/en/posts/convert-dos-and-nt-paths-using-rtl-functions/+ assert!(dir != 0 as HANDLE);++ // Extended attributes are not implemented yet.+ if htemplatefile != 0 as HANDLE {+ SetLastError(ERROR_NOT_SUPPORTED);+ return HandleOrInvalid::from_raw_handle(INVALID_HANDLE_VALUE as _);+ }++ // Convert `dwcreationdisposition` to the `createdisposition` argument+ // to `NtCreateFile`. Do this before converting `lpfilename` so that+ // we can return early on failure.+ let createdisposition = match dwcreationdisposition {+ CREATE_NEW => FILE_CREATE,+ CREATE_ALWAYS => FILE_OVERWRITE_IF,+ OPEN_EXISTING => FILE_OPEN,+ OPEN_ALWAYS => FILE_OPEN_IF,+ TRUNCATE_EXISTING => FILE_OVERWRITE,+ _ => {+ SetLastError(ERROR_INVALID_PARAMETER);+ return HandleOrInvalid::from_raw_handle(INVALID_HANDLE_VALUE as _);+ }+ };++ // Convert `lpfilename` to a `UNICODE_STRING`.+ let byte_length = lpfilename.len() * mem::size_of::<u16>();+ let length: u16 = match byte_length.try_into() {+ Ok(length) => length,+ Err(_) => {+ SetLastError(ERROR_INVALID_NAME);+ return HandleOrInvalid::from_raw_handle(INVALID_HANDLE_VALUE as _);+ }+ };+ let mut unicode_string = UNICODE_STRING {+ Buffer: lpfilename.as_ptr() as *mut u16,+ Length: length,+ MaximumLength: length,+ };++ let mut handle = INVALID_HANDLE_VALUE;++ // Convert `dwdesiredaccess` and `dwflagsandattributes` to the+ // `desiredaccess` argument to `NtCreateFile`.+ let mut desiredaccess = dwdesiredaccess | SYNCHRONIZE | FILE_READ_ATTRIBUTES;+ if dwflagsandattributes & FILE_FLAG_DELETE_ON_CLOSE != 0 {+ desiredaccess |= DELETE;+ }++ // Compute `objectattributes`' `Attributes` field. Case-insensitive is+ // the expected behavior on Windows.+ let mut attributes = 0;+ if dwflagsandattributes & FILE_FLAG_POSIX_SEMANTICS != 0 {+ attributes |= OBJ_CASE_INSENSITIVE as u32;+ };+ if !lpsecurityattributes.is_null() && (*lpsecurityattributes).bInheritHandle != 0 {+ attributes |= OBJ_INHERIT as u32;+ }++ // Compute the `objectattributes` argument to `NtCreateFile`.+ let mut objectattributes = mem::zeroed::<OBJECT_ATTRIBUTES>();+ objectattributes.Length = mem::size_of::<OBJECT_ATTRIBUTES>() as _;+ objectattributes.RootDirectory = dir;+ objectattributes.ObjectName = &mut unicode_string;+ objectattributes.Attributes = attributes;+ if !lpsecurityattributes.is_null() {+ objectattributes.SecurityDescriptor = (*lpsecurityattributes)+ .lpSecurityDescriptor+ .cast::<SECURITY_DESCRIPTOR>();+ }++ // If needed, set `objectattributes`' `SecurityQualityOfService` field.+ let mut qos;+ if dwflagsandattributes & SECURITY_SQOS_PRESENT != 0 {+ qos = mem::zeroed::<SECURITY_QUALITY_OF_SERVICE>();+ qos.Length = mem::size_of::<SECURITY_QUALITY_OF_SERVICE>() as _;+ qos.ImpersonationLevel = ((dwflagsandattributes >> 16) & 0x3) as _;+ qos.ContextTrackingMode = if dwflagsandattributes & SECURITY_CONTEXT_TRACKING != 0 {+ SECURITY_DYNAMIC_TRACKING+ } else {+ SECURITY_STATIC_TRACKING+ } as u8;+ qos.EffectiveOnly = ((dwflagsandattributes & SECURITY_EFFECTIVE_ONLY) != 0) as _;++ objectattributes.SecurityQualityOfService =+ (&mut qos as *mut SECURITY_QUALITY_OF_SERVICE).cast();+ }++ let mut iostatusblock = mem::zeroed::<IO_STATUS_BLOCK>();+ iostatusblock.Anonymous.Status = STATUS_PENDING;++ // Compute the `fileattributes` argument to `NtCreateFile`. Mask off+ // unrecognized flags.+ let mut fileattributes = dwflagsandattributes & FILE_ATTRIBUTE_VALID_FLAGS;+ if fileattributes == 0 {+ fileattributes = FILE_ATTRIBUTE_NORMAL;+ }++ // Compute the `createoptions` argument to `NtCreateFile`.+ let mut createoptions = 0;+ if dwflagsandattributes & FILE_FLAG_BACKUP_SEMANTICS == 0 {+ createoptions |= FILE_NON_DIRECTORY_FILE;+ } else {+ if dwdesiredaccess & GENERIC_ALL != 0 {+ createoptions |= FILE_OPEN_FOR_BACKUP_INTENT | FILE_OPEN_REMOTE_INSTANCE;+ } else {+ if dwdesiredaccess & GENERIC_READ != 0 {+ createoptions |= FILE_OPEN_FOR_BACKUP_INTENT;+ }+ if dwdesiredaccess & GENERIC_WRITE != 0 {+ createoptions |= FILE_OPEN_REMOTE_INSTANCE;+ }+ }+ }+ if dwflagsandattributes & FILE_FLAG_DELETE_ON_CLOSE != 0 {+ createoptions |= FILE_DELETE_ON_CLOSE;+ }+ if dwflagsandattributes & FILE_FLAG_NO_BUFFERING != 0 {+ createoptions |= FILE_NO_INTERMEDIATE_BUFFERING;+ }+ if dwflagsandattributes & FILE_FLAG_OPEN_NO_RECALL != 0 {+ createoptions |= FILE_OPEN_NO_RECALL;+ }+ if dwflagsandattributes & FILE_FLAG_OPEN_REPARSE_POINT != 0 {+ createoptions |= FILE_OPEN_REPARSE_POINT;+ }+ if dwflagsandattributes & FILE_FLAG_OVERLAPPED == 0 {+ createoptions |= FILE_SYNCHRONOUS_IO_NONALERT;+ }+ // FILE_FLAG_POSIX_SEMANTICS is handled above.+ if dwflagsandattributes & FILE_FLAG_RANDOM_ACCESS != 0 {+ createoptions |= FILE_RANDOM_ACCESS;+ }+ if dwflagsandattributes & FILE_FLAG_SESSION_AWARE != 0 {+ // TODO: How should we handle FILE_FLAG_SESSION_AWARE?+ SetLastError(ERROR_NOT_SUPPORTED);+ return HandleOrInvalid::from_raw_handle(INVALID_HANDLE_VALUE as _);+ }+ if dwflagsandattributes & FILE_FLAG_SEQUENTIAL_SCAN != 0 {+ createoptions |= FILE_SEQUENTIAL_ONLY;+ }+ if dwflagsandattributes & FILE_FLAG_WRITE_THROUGH != 0 {+ createoptions |= FILE_WRITE_THROUGH;+ }++ // Ok, we have what we need to call `NtCreateFile` now!+ let status = NtCreateFile(+ &mut handle,+ desiredaccess,+ &mut objectattributes,+ &mut iostatusblock,+ null_mut(),+ fileattributes,+ dwsharemode,+ createdisposition,+ createoptions,+ null_mut(),+ 0,+ );++ // Check for errors.+ if status != STATUS_SUCCESS {+ handle = INVALID_HANDLE_VALUE;+ if status == STATUS_OBJECT_NAME_COLLISION {+ SetLastError(ERROR_FILE_EXISTS);+ } else {+ SetLastError(RtlNtStatusToDosError(status));+ }+ } else if (dwcreationdisposition == CREATE_ALWAYS+ && iostatusblock.Information == FILE_OVERWRITTEN as usize)+ || (dwcreationdisposition == OPEN_ALWAYS+ && iostatusblock.Information == FILE_OPENED as usize)+ {+ // Set `ERROR_ALREADY_EXISTS` according to the table for+ // `dwCreationDisposition` in the [`CreateFileW` docs].+ //+ // [`CreateFileW` docs]: https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilew+ SetLastError(ERROR_ALREADY_EXISTS);+ } else {+ // Otherwise indicate that we succeeded.+ SetLastError(SUCCESS);+ }++ HandleOrInvalid::from_raw_handle(handle as _)+}diff --git a/crates/wasi/src/filesystem/primitives/windows/fs/dir_entry_inner.rs b/crates/wasi/src/filesystem/primitives/windows/fs/dir_entry_inner.rsnew file mode 100644index 0000000000..c70104683f--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/windows/fs/dir_entry_inner.rs@@ -0,0 +1,31 @@+use crate::filesystem::primitives::Metadata;+use std::ffi::OsString;+use std::{fmt, fs, io};++pub(crate) struct DirEntryInner {+ std: fs::DirEntry,+}++impl DirEntryInner {+ #[inline]+ pub(crate) fn metadata(&self) -> io::Result<Metadata> {+ self.std.metadata().map(Metadata::from_just_metadata)+ }++ #[inline]+ pub(crate) fn file_name(&self) -> OsString {+ self.std.file_name()+ }++ #[inline]+ pub(super) fn from_std(std: fs::DirEntry) -> Self {+ Self { std }+ }+}++impl fmt::Debug for DirEntryInner {+ // Like libstd's version, but doesn't print the path.+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {+ f.debug_tuple("DirEntry").field(&self.file_name()).finish()+ }+}diff --git a/crates/wasi/src/filesystem/primitives/windows/fs/dir_options_ext.rs b/crates/wasi/src/filesystem/primitives/windows/fs/dir_options_ext.rsnew file mode 100644index 0000000000..728f59629b--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/windows/fs/dir_options_ext.rs@@ -0,0 +1,8 @@+#[derive(Debug, Clone)]+pub(crate) struct DirOptionsExt {}++impl DirOptionsExt {+ pub(crate) const fn new() -> Self {+ Self {}+ }+}diff --git a/crates/wasi/src/filesystem/primitives/windows/fs/dir_utils.rs b/crates/wasi/src/filesystem/primitives/windows/fs/dir_utils.rsnew file mode 100644index 0000000000..e4b8c28a44--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/windows/fs/dir_utils.rs@@ -0,0 +1,190 @@+use crate::filesystem::primitives::OpenOptionsExt;+use crate::filesystem::primitives::{OpenOptions, errors};+use std::ffi::OsString;+use std::ops::Deref;+use std::os::windows::ffi::{OsStrExt, OsStringExt};+use std::path::{Path, PathBuf};+use std::{fs, io};+use windows_sys::Win32::Storage::FileSystem::{+ FILE_FLAG_BACKUP_SEMANTICS, FILE_SHARE_READ, FILE_SHARE_WRITE,+};++/// Rust's `Path` implicitly strips redundant slashes, however they aren't+/// redundant in one case: at the end of a path they indicate that a path is+/// expected to name a directory.+pub(crate) fn path_requires_dir(path: &Path) -> bool {+ let wide: Vec<u16> = path.as_os_str().encode_wide().collect();+ wide.ends_with(&['/' as u16])+ || wide.ends_with(&['/' as u16, '.' as _])+ || wide.ends_with(&['\\' as u16])+ || wide.ends_with(&['\\' as u16, '.' as _])+}++/// Windows treats `foo/.` as equivalent to `foo` even if `foo` does not+/// exist or is not a directory. So we don't do the special trailing-dot+/// handling that we do on Posix-ish platforms.+pub(crate) fn path_has_trailing_dot(_path: &Path) -> bool {+ false+}++/// For the purposes of emulating Windows symlink resolution, we sometimes+/// need to know whether a path really does end in a trailing dot though.+pub(crate) fn path_really_has_trailing_dot(path: &Path) -> bool {+ let wide: Vec<u16> = path.as_os_str().encode_wide().collect();++ wide.ends_with(&['/' as u16, '.' as u16]) || wide.ends_with(&['\\' as u16, '.' as u16])+}++/// Rust's `Path` implicitly strips trailing `/`s, however they aren't+/// redundant in one case: at the end of a path they are the final path+/// component, which has different path lookup behavior.+pub(crate) fn path_has_trailing_slash(path: &Path) -> bool {+ let wide: Vec<u16> = path.as_os_str().encode_wide().collect();++ wide.ends_with(&['/' as u16]) || wide.ends_with(&['\\' as u16])+}++/// Strip trailing `/`s, unless this reduces `path` to `/` itself. This is+/// used by `create_dir` and others to prevent paths like `foo/` from+/// canonicalizing to `foo/.` since these syscalls treat these differently.+pub(crate) fn strip_dir_suffix(path: &Path) -> impl Deref<Target = Path> + '_ {+ let mut wide: Vec<u16> = path.as_os_str().encode_wide().collect();+ while wide.len() > 1+ && (*wide.last().unwrap() == '/' as u16 || *wide.last().unwrap() == '\\' as u16)+ {+ wide.pop();+ }+ PathBuf::from(OsString::from_wide(&wide))+}++/// Return an `OpenOptions` for opening directories.+pub(crate) fn dir_options() -> OpenOptions {+ // Set `FILE_FLAG_BACKUP_SEMANTICS` so that we can open directories. Unset+ // `FILE_SHARE_DELETE` so that directories can't be renamed or deleted+ // underneath us, since we use paths to implement many directory operations.+ OpenOptions::new()+ .read(true)+ .dir_required(true)+ .custom_flags(FILE_FLAG_BACKUP_SEMANTICS)+ .share_mode(FILE_SHARE_READ | FILE_SHARE_WRITE)+ .clone()+}++/// Like `dir_options`, but additionally request the ability to read the+/// directory entries.+pub(crate) fn readdir_options() -> OpenOptions {+ dir_options().readdir_required(true).clone()+}++/// Open a directory named by a bare path, using the host process' ambient+/// authority.+///+/// # Ambient Authority+///+/// This function is not sandboxed and may trivially access any path that the+/// host process has access to.+pub(crate) fn open_ambient_dir_impl(path: &Path) -> io::Result<fs::File> {+ use std::os::windows::fs::OpenOptionsExt;++ // Set `FILE_FLAG_BACKUP_SEMANTICS` so that we can open directories. Unset+ // `FILE_SHARE_DELETE` so that directories can't be renamed or deleted+ // underneath us, since we use paths to implement many directory operations.+ let dir = fs::OpenOptions::new()+ .read(true)+ .custom_flags(FILE_FLAG_BACKUP_SEMANTICS)+ .share_mode(FILE_SHARE_READ | FILE_SHARE_WRITE)+ .open(path)?;++ // Require a directory. It may seem possible to eliminate this `metadata()`+ // call by appending a slash to the path before opening it so that the OS+ // requires a directory for us, however on Windows in some circumstances+ // this leads to "The filename, directory name, or volume label syntax is+ // incorrect." errors.+ if !dir.metadata()?.is_dir() {+ return Err(errors::is_not_directory());+ }++ Ok(dir)+}++#[test]+fn strip_dir_suffix_tests() {+ assert_eq!(&*strip_dir_suffix(Path::new("/foo//")), Path::new("/foo"));+ assert_eq!(&*strip_dir_suffix(Path::new("/foo/")), Path::new("/foo"));+ assert_eq!(&*strip_dir_suffix(Path::new("foo/")), Path::new("foo"));+ assert_eq!(&*strip_dir_suffix(Path::new("foo")), Path::new("foo"));+ assert_eq!(&*strip_dir_suffix(Path::new("/")), Path::new("/"));+ assert_eq!(&*strip_dir_suffix(Path::new("//")), Path::new("/"));++ assert_eq!(+ &*strip_dir_suffix(Path::new("\\foo\\\\")),+ Path::new("\\foo")+ );+ assert_eq!(&*strip_dir_suffix(Path::new("\\foo\\")), Path::new("\\foo"));+ assert_eq!(&*strip_dir_suffix(Path::new("foo\\")), Path::new("foo"));+ assert_eq!(&*strip_dir_suffix(Path::new("foo")), Path::new("foo"));+ assert_eq!(&*strip_dir_suffix(Path::new("\\")), Path::new("\\"));+ assert_eq!(&*strip_dir_suffix(Path::new("\\\\")), Path::new("\\"));+}++#[test]+fn test_path_requires_dir() {+ assert!(!path_requires_dir(Path::new(".")));+ assert!(path_requires_dir(Path::new("/")));+ assert!(path_requires_dir(Path::new("//")));+ assert!(path_requires_dir(Path::new("/./.")));+ assert!(path_requires_dir(Path::new("foo/")));+ assert!(path_requires_dir(Path::new("foo//")));+ assert!(path_requires_dir(Path::new("foo//.")));+ assert!(path_requires_dir(Path::new("foo/./.")));+ assert!(path_requires_dir(Path::new("foo/./")));+ assert!(path_requires_dir(Path::new("foo/.//")));++ assert!(path_requires_dir(Path::new("\\")));+ assert!(path_requires_dir(Path::new("\\\\")));+ assert!(path_requires_dir(Path::new("\\.\\.")));+ assert!(path_requires_dir(Path::new("foo\\")));+ assert!(path_requires_dir(Path::new("foo\\\\")));+ assert!(path_requires_dir(Path::new("foo\\\\.")));+ assert!(path_requires_dir(Path::new("foo\\.\\.")));+ assert!(path_requires_dir(Path::new("foo\\.\\")));+ assert!(path_requires_dir(Path::new("foo\\.\\\\")));+}++#[test]+fn test_path_has_trailing_slash() {+ assert!(path_has_trailing_slash(Path::new("/")));+ assert!(path_has_trailing_slash(Path::new("//")));+ assert!(path_has_trailing_slash(Path::new("foo/")));+ assert!(path_has_trailing_slash(Path::new("foo//")));+ assert!(path_has_trailing_slash(Path::new("foo/./")));+ assert!(path_has_trailing_slash(Path::new("foo/.//")));++ assert!(path_has_trailing_slash(Path::new("\\")));+ assert!(path_has_trailing_slash(Path::new("\\\\")));+ assert!(path_has_trailing_slash(Path::new("foo\\")));+ assert!(path_has_trailing_slash(Path::new("foo\\\\")));+ assert!(path_has_trailing_slash(Path::new("foo\\.\\")));+ assert!(path_has_trailing_slash(Path::new("foo\\.\\\\")));++ assert!(!path_has_trailing_slash(Path::new("foo")));+ assert!(!path_has_trailing_slash(Path::new("foo.")));++ assert!(!path_has_trailing_slash(Path::new("/./foo")));+ assert!(!path_has_trailing_slash(Path::new("..")));+ assert!(!path_has_trailing_slash(Path::new("/..")));++ assert!(!path_has_trailing_slash(Path::new("\\.\\foo")));+ assert!(!path_has_trailing_slash(Path::new("..")));+ assert!(!path_has_trailing_slash(Path::new("\\..")));++ assert!(!path_has_trailing_slash(Path::new("/./.")));+ assert!(!path_has_trailing_slash(Path::new("foo//.")));+ assert!(!path_has_trailing_slash(Path::new("foo/./.")));++ assert!(!path_has_trailing_slash(Path::new(".")));++ assert!(!path_has_trailing_slash(Path::new("\\.\\.")));+ assert!(!path_has_trailing_slash(Path::new("foo\\\\.")));+ assert!(!path_has_trailing_slash(Path::new("foo\\.\\.")));+}diff --git a/crates/wasi/src/filesystem/primitives/windows/fs/errors.rs b/crates/wasi/src/filesystem/primitives/windows/fs/errors.rsnew file mode 100644index 0000000000..f4bffc9868--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/windows/fs/errors.rs@@ -0,0 +1,22 @@+use std::io;+use windows_sys::Win32::Foundation;++#[cold]+pub(crate) fn no_such_file_or_directory() -> io::Error {+ io::Error::from_raw_os_error(Foundation::ERROR_FILE_NOT_FOUND as i32)+}++#[cold]+pub(crate) fn is_directory() -> io::Error {+ io::Error::from_raw_os_error(Foundation::ERROR_DIRECTORY_NOT_SUPPORTED as i32)+}++#[cold]+pub(crate) fn is_not_directory() -> io::Error {+ io::Error::from_raw_os_error(Foundation::ERROR_DIRECTORY as i32)+}++#[cold]+pub(crate) fn too_many_symlinks() -> io::Error {+ io::Error::from_raw_os_error(Foundation::ERROR_TOO_MANY_LINKS as i32)+}diff --git a/crates/wasi/src/filesystem/primitives/windows/fs/file_type_ext.rs b/crates/wasi/src/filesystem/primitives/windows/fs/file_type_ext.rsnew file mode 100644index 0000000000..084b805dc1--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/windows/fs/file_type_ext.rs@@ -0,0 +1,92 @@+use crate::filesystem::primitives::FileType;+use std::{fs, io};++/// A type that implements `FileTypeExt` for this platform.+#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]+pub(crate) enum ImplFileTypeExt {+ CharacterDevice,+ Fifo,+ SymlinkUnknown,+}++impl ImplFileTypeExt {+ /// Constructs a new instance of `Self` from the given [`std::fs::File`]+ /// and [`std::fs::Metadata`].+ pub(crate) fn from(file: &fs::File, metadata: &fs::Metadata) -> io::Result<FileType> {+ // Check for the things we can do with just metadata.+ let file_type = Self::from_just_metadata(metadata);+ if file_type != FileType::unknown() {+ return Ok(file_type);+ }++ // Use the open file to check for one of the exotic file types.+ let file_type = winx::winapi_util::file::typ(file)?;+ if file_type.is_char() {+ return Ok(FileType::ext(ImplFileTypeExt::CharacterDevice));+ }+ if file_type.is_pipe() {+ return Ok(FileType::ext(ImplFileTypeExt::Fifo));+ }++ Ok(FileType::unknown())+ }++ /// Constructs a new instance of `Self` from the given+ /// [`std::fs::Metadata`].+ #[inline]+ pub(crate) fn from_just_metadata(metadata: &fs::Metadata) -> FileType {+ let std = metadata.file_type();+ Self::from_std(std)+ }++ /// Constructs a new instance of `Self` from the given+ /// [`std::fs::FileType`].+ #[inline]+ pub(crate) fn from_std(std: fs::FileType) -> FileType {+ if std.is_file() {+ return FileType::file();+ }+ if std.is_dir() {+ return FileType::dir();+ }++ if std.is_symlink() {+ return FileType::ext(Self::SymlinkUnknown);+ }++ FileType::unknown()+ }++ #[inline]+ pub(crate) fn is_symlink(&self) -> bool {+ match self {+ Self::SymlinkUnknown => true,+ _ => false,+ }+ }+}++#[doc(hidden)]+impl crate::filesystem::primitives::_WindowsFileTypeExt+ for crate::filesystem::primitives::FileType+{+ #[inline]+ fn is_block_device(&self) -> bool {+ false+ }++ #[inline]+ fn is_char_device(&self) -> bool {+ *self == FileType::ext(ImplFileTypeExt::CharacterDevice)+ }++ #[inline]+ fn is_fifo(&self) -> bool {+ *self == FileType::ext(ImplFileTypeExt::Fifo)+ }++ #[inline]+ fn is_socket(&self) -> bool {+ false+ }+}diff --git a/crates/wasi/src/filesystem/primitives/windows/fs/get_path.rs b/crates/wasi/src/filesystem/primitives/windows/fs/get_path.rsnew file mode 100644index 0000000000..c2b44ad883--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/windows/fs/get_path.rs@@ -0,0 +1,31 @@+use std::ffi::OsString;+use std::os::windows::ffi::{OsStrExt, OsStringExt};+use std::path::{Path, PathBuf};+use std::{fs, io};++/// Calculates system path of `file`.+///+/// This function will automatically strip the extended prefix from the+/// resultant path to allow for joining this resultant path with relative+/// components.+pub(crate) fn get_path(file: &fs::File) -> io::Result<PathBuf> {+ // get system path to the handle+ let path = winx::file::get_file_path(file)?;++ // strip extended prefix; otherwise we will error out on any relative+ // components with `out_path`+ let wide: Vec<_> = path.as_os_str().encode_wide().collect();+ let wide_final = if wide.starts_with(&['\\' as u16, '\\' as _, '?' as _, '\\' as _]) {+ &wide[4..]+ } else {+ &wide+ };+ Ok(PathBuf::from(OsString::from_wide(wide_final)))+}++/// Convenience function for calling `get_path` and concatenating the result+/// with `path`.+pub(super) fn concatenate(file: &fs::File, path: &Path) -> io::Result<PathBuf> {+ let file_path = get_path(file)?;+ Ok(file_path.join(path))+}diff --git a/crates/wasi/src/filesystem/primitives/windows/fs/hard_link_unchecked.rs b/crates/wasi/src/filesystem/primitives/windows/fs/hard_link_unchecked.rsnew file mode 100644index 0000000000..68408d06c0--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/windows/fs/hard_link_unchecked.rs@@ -0,0 +1,16 @@+use super::get_path::concatenate;+use std::path::Path;+use std::{fs, io};++/// *Unsandboxed* function similar to `hard_link`, but which does not perform+/// sandboxing.+pub(crate) fn hard_link_unchecked(+ old_start: &fs::File,+ old_path: &Path,+ new_start: &fs::File,+ new_path: &Path,+) -> io::Result<()> {+ let old_full_path = concatenate(old_start, old_path)?;+ let new_full_path = concatenate(new_start, new_path)?;+ fs::hard_link(old_full_path, new_full_path)+}diff --git a/crates/wasi/src/filesystem/primitives/windows/fs/metadata_ext.rs b/crates/wasi/src/filesystem/primitives/windows/fs/metadata_ext.rsnew file mode 100644index 0000000000..4aaf4cb0f5--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/windows/fs/metadata_ext.rs@@ -0,0 +1,65 @@+#![allow(clippy::useless_conversion)]++use crate::filesystem::primitives::MetadataExt;+use std::{fs, io};++#[derive(Debug, Clone)]+pub(crate) struct ImplMetadataExt {+ file_attributes: u32,+ number_of_links: Option<u32>,+}++impl ImplMetadataExt {+ /// Constructs a new instance of `Self` from the given [`std::fs::File`]+ /// and [`std::fs::Metadata`].+ #[inline]+ pub(crate) fn from(file: &fs::File, std: &fs::Metadata) -> io::Result<Self> {+ let fileinfo = winx::winapi_util::file::information(file)?;+ let t64: u64 = fileinfo.number_of_links();+ let t32: u32 = t64.try_into().unwrap();++ Ok(Self::from_parts(std, Some(t32)))+ }++ /// Constructs a new instance of `Self` from the given+ /// [`std::fs::Metadata`].+ ///+ /// As with the comments in [`std::fs::Metadata::volume_serial_number`] and+ /// nearby functions, some fields of the resulting metadata will be `None`.+ ///+ /// [`std::fs::Metadata::volume_serial_number`]: https://doc.rust-lang.org/std/os/windows/fs/trait.MetadataExt.html#tymethod.volume_serial_number+ #[inline]+ pub(crate) fn from_just_metadata(std: &fs::Metadata) -> Self {+ Self::from_parts(std, None)+ }++ #[inline]+ fn from_parts(std: &fs::Metadata, number_of_links: Option<u32>) -> Self {+ use std::os::windows::fs::MetadataExt;+ Self {+ file_attributes: std.file_attributes(),+ number_of_links,+ }+ }++ /// `MetadataExt` requires nightly to be implemented, but we sometimes+ /// just need the file attributes.+ #[inline]+ pub(crate) fn file_attributes(&self) -> u32 {+ self.file_attributes+ }+}++impl MetadataExt for ImplMetadataExt {+ fn file_attributes(&self) -> u32 {+ self.file_attributes+ }+}++#[doc(hidden)]+impl crate::filesystem::primitives::_WindowsByHandle for crate::filesystem::primitives::Metadata {+ #[inline]+ fn number_of_links(&self) -> Option<u32> {+ self.ext.number_of_links+ }+}diff --git a/crates/wasi/src/filesystem/primitives/windows/fs/mod.rs b/crates/wasi/src/filesystem/primitives/windows/fs/mod.rsnew file mode 100644index 0000000000..75ff00fbe8--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/windows/fs/mod.rs@@ -0,0 +1,66 @@+mod create_dir_unchecked;+mod create_file_at_w;+mod dir_entry_inner;+mod dir_options_ext;+mod dir_utils;+mod file_type_ext;+mod get_path;+mod hard_link_unchecked;+mod metadata_ext;+mod oflags;+mod open_impl;+mod open_options_ext;+mod open_unchecked;+mod read_dir_inner;+mod read_link_impl;+mod read_link_unchecked;+mod remove_dir_unchecked;+mod remove_file_unchecked;+mod rename_unchecked;+mod set_times_impl;+mod stat_unchecked;+mod symlink_unchecked;++pub(crate) mod errors;++#[rustfmt::skip]+pub(crate) use crate::filesystem::primitives::{+ via_parent::hard_link as hard_link_impl,+ via_parent::create_dir as create_dir_impl,+ via_parent::rename as rename_impl,+ via_parent::remove_dir as remove_dir_impl,+ manually::stat as stat_impl,+ via_parent::symlink_dir as symlink_dir_impl,+ via_parent::symlink_file as symlink_file_impl,+ via_parent::remove_file as remove_file_impl,+};++pub(crate) use create_dir_unchecked::*;+pub(crate) use dir_entry_inner::*;+pub(crate) use dir_options_ext::*;+pub(crate) use dir_utils::*;+pub(crate) use file_type_ext::*;+pub(crate) use hard_link_unchecked::*;+pub(crate) use metadata_ext::*;+pub(crate) use open_impl::open_impl;+pub(crate) use open_options_ext::*;+pub(crate) use open_unchecked::*;+pub(crate) use read_dir_inner::*;+pub(crate) use read_link_impl::*;+pub(crate) use read_link_unchecked::*;+pub(crate) use remove_dir_unchecked::*;+pub(crate) use remove_file_unchecked::*;+pub(crate) use rename_unchecked::*;+pub(crate) use set_times_impl::*;+pub(crate) use stat_unchecked::*;+pub(crate) use symlink_unchecked::*;++// On Windows, there is a limit of 63 reparse points on any given path.+// <https://docs.microsoft.com/en-us/windows/win32/fileio/reparse-points>+pub(crate) const MAX_SYMLINK_EXPANSIONS: u8 = 63;++pub(crate) fn file_path(file: &std::fs::File) -> Option<std::path::PathBuf> {+ get_path::get_path(file).ok()+}++pub(super) use oflags::*;diff --git a/crates/wasi/src/filesystem/primitives/windows/fs/oflags.rs b/crates/wasi/src/filesystem/primitives/windows/fs/oflags.rsnew file mode 100644index 0000000000..30d8019745--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/windows/fs/oflags.rs@@ -0,0 +1,48 @@+use crate::filesystem::primitives::{FollowSymlinks, OpenOptions, OpenOptionsExt};+use windows_sys::Win32::Storage::FileSystem::{+ FILE_FLAG_BACKUP_SEMANTICS, FILE_FLAG_OPEN_REPARSE_POINT, FILE_FLAG_WRITE_THROUGH,+ FILE_SHARE_DELETE,+};++/// Adjust an `OpenOptions` after all the flags are set, in preparation+/// for the to call a Windows API `open` function. Also return a bool+/// indicating that the `trunc` flag was requested but could not be set,+/// so the file should be truncated manually after opening.+pub(in super::super) fn prepare_open_options_for_open(opts: &mut OpenOptions) -> bool {+ let mut trunc = opts.truncate;+ let mut manually_trunc = false;++ let mut custom_flags = match opts.follow {+ FollowSymlinks::Yes => opts.ext.custom_flags,+ FollowSymlinks::No => {+ if trunc && !opts.create_new && !opts.append && opts.write {+ // On Windows, truncating overwrites a symlink with a+ // non-symlink.+ manually_trunc = true;+ trunc = false;+ }+ opts.ext.custom_flags | FILE_FLAG_OPEN_REPARSE_POINT+ }+ };+ let mut share_mode = opts.ext.share_mode;+ if opts.maybe_dir {+ custom_flags |= FILE_FLAG_BACKUP_SEMANTICS;++ // Only allow `FILE_SHARE_READ` and `FILE_SHARE_WRITE`; this mirrors+ // the values in `dir_options()` and is done to prevent directories+ // from being deleted or renamed underneath cap-std's sandboxed path+ // lookups on Windows.+ share_mode &= !FILE_SHARE_DELETE;+ }+ // This matches system-interface's `set_fd_flags` interpretation of these+ // flags on Windows.+ if opts.sync || opts.dsync {+ custom_flags |= FILE_FLAG_WRITE_THROUGH;+ }++ opts.truncate(trunc)+ .share_mode(share_mode)+ .custom_flags(custom_flags);++ manually_trunc+}diff --git a/crates/wasi/src/filesystem/primitives/windows/fs/open_impl.rs b/crates/wasi/src/filesystem/primitives/windows/fs/open_impl.rsnew file mode 100644index 0000000000..95c94f710a--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/windows/fs/open_impl.rs@@ -0,0 +1,66 @@+use crate::filesystem::primitives::{OpenOptions, manually};+use std::ffi::OsStr;+use std::path::Path;+use std::{fs, io};+use windows_sys::Win32::Foundation::ERROR_FILE_NOT_FOUND;++pub(crate) fn open_impl(+ start: &fs::File,+ path: &Path,+ options: &OpenOptions,+) -> io::Result<fs::File> {+ // Windows reserves several special device paths. Disallow opening any+ // of them.+ // See: https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file#naming-conventions+ if let Some(stem) = file_prefix(path) {+ if let Some(stemstr) = stem.to_str() {+ match stemstr.trim_end().to_uppercase().as_str() {+ "CON" | "PRN" | "AUX" | "NUL" | "COM0" | "COM1" | "COM2" | "COM3" | "COM4"+ | "COM5" | "COM6" | "COM7" | "COM8" | "COM9" | "COM¹" | "COM²" | "COM³"+ | "LPT0" | "LPT1" | "LPT2" | "LPT3" | "LPT4" | "LPT5" | "LPT6" | "LPT7"+ | "LPT8" | "LPT9" | "LPT¹" | "LPT²" | "LPT³" => {+ return Err(io::Error::from_raw_os_error(ERROR_FILE_NOT_FOUND as i32));+ }+ _ => {}+ }+ }+ }++ manually::open(start, path, options)+}++// TODO: Replace this with `Path::file_prefix` once that's stable. For now,+// we use a copy of the code. This code is derived from+// https://github.com/rust-lang/rust/blob/9fe9041cc8eddaed402d17aa4facb2ce8f222e95/library/std/src/path.rs#L2648+fn file_prefix(path: &Path) -> Option<&OsStr> {+ path.file_name()+ .map(split_file_at_dot)+ .and_then(|(before, _after)| Some(before))+}++// This code is derived from+// https://github.com/rust-lang/rust/blob/9fe9041cc8eddaed402d17aa4facb2ce8f222e95/library/std/src/path.rs#L340+#[allow(unsafe_code)]+fn split_file_at_dot(file: &OsStr) -> (&OsStr, Option<&OsStr>) {+ let slice = file.as_encoded_bytes();+ if slice == b".." {+ return (file, None);+ }++ // The unsafety here stems from converting between &OsStr and &[u8]+ // and back. This is safe to do because (1) we only look at ASCII+ // contents of the encoding and (2) new &OsStr values are produced+ // only from ASCII-bounded slices of existing &OsStr values.+ let i = match slice[1..].iter().position(|b| *b == b'.') {+ Some(i) => i + 1,+ None => return (file, None),+ };+ let before = &slice[..i];+ let after = &slice[i + 1..];+ unsafe {+ (+ OsStr::from_encoded_bytes_unchecked(before),+ Some(OsStr::from_encoded_bytes_unchecked(after)),+ )+ }+}diff --git a/crates/wasi/src/filesystem/primitives/windows/fs/open_options_ext.rs b/crates/wasi/src/filesystem/primitives/windows/fs/open_options_ext.rsnew file mode 100644index 0000000000..af8361d463--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/windows/fs/open_options_ext.rs@@ -0,0 +1,111 @@+#![allow(unsafe_code)]++use crate::filesystem::primitives::OpenOptions;+use std::io;+use std::ptr::null_mut;+use windows_sys::Win32::Foundation::{ERROR_INVALID_PARAMETER, GENERIC_READ, GENERIC_WRITE};+use windows_sys::Win32::Security::SECURITY_ATTRIBUTES;+use windows_sys::Win32::Storage::FileSystem::{+ CREATE_ALWAYS, CREATE_NEW, FILE_FLAG_OPEN_REPARSE_POINT, FILE_GENERIC_WRITE, FILE_SHARE_DELETE,+ FILE_SHARE_READ, FILE_SHARE_WRITE, FILE_WRITE_DATA, OPEN_ALWAYS, OPEN_EXISTING,+ TRUNCATE_EXISTING,+};++#[derive(Debug, Clone)]+pub(crate) struct ImplOpenOptionsExt {+ pub(super) access_mode: Option<u32>,+ pub(super) share_mode: u32,+ pub(super) custom_flags: u32,+ pub(super) attributes: u32,+ pub(super) security_attributes: *mut SECURITY_ATTRIBUTES,+ pub(super) security_qos_flags: u32,+}++unsafe impl Send for ImplOpenOptionsExt {}+unsafe impl Sync for ImplOpenOptionsExt {}++impl ImplOpenOptionsExt {+ pub(crate) const fn new() -> Self {+ Self {+ access_mode: None,+ share_mode: FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,+ custom_flags: 0,+ attributes: 0,+ security_attributes: null_mut(),+ security_qos_flags: 0,+ }+ }++ pub(crate) fn access_mode(&mut self, mode: u32) -> &mut Self {+ self.access_mode = Some(mode);+ self+ }++ pub(crate) fn share_mode(&mut self, share: u32) -> &mut Self {+ self.share_mode = share;+ self+ }++ pub(crate) fn custom_flags(&mut self, flags: u32) -> &mut Self {+ self.custom_flags = flags;+ self+ }+}++pub(crate) fn get_access_mode(options: &OpenOptions) -> io::Result<u32> {+ match (+ options.read,+ options.write,+ options.append,+ options.ext.access_mode,+ ) {+ (.., Some(mode)) => Ok(mode),+ (true, false, false, None) => Ok(GENERIC_READ),+ (false, true, false, None) => Ok(GENERIC_WRITE),+ (true, true, false, None) => Ok(GENERIC_READ | GENERIC_WRITE),+ (false, _, true, None) => Ok(FILE_GENERIC_WRITE & !FILE_WRITE_DATA),+ (true, _, true, None) => Ok(GENERIC_READ | (FILE_GENERIC_WRITE & !FILE_WRITE_DATA)),+ (false, false, false, None) => {+ Err(io::Error::from_raw_os_error(ERROR_INVALID_PARAMETER as i32))+ }+ }+}++pub(crate) fn get_flags_and_attributes(options: &OpenOptions) -> u32 {+ options.ext.custom_flags+ | options.ext.attributes+ | options.ext.security_qos_flags+ | if options.create_new {+ FILE_FLAG_OPEN_REPARSE_POINT+ } else {+ 0+ }+}++pub(crate) fn get_creation_mode(options: &OpenOptions) -> io::Result<u32> {+ const ERROR_INVALID_PARAMETER: i32 = 87;++ match (options.write, options.append) {+ (true, false) => {}+ (false, false) => {+ if options.truncate || options.create || options.create_new {+ return Err(io::Error::from_raw_os_error(ERROR_INVALID_PARAMETER));+ }+ }+ (_, true) => {+ if options.truncate && !options.create_new {+ return Err(io::Error::from_raw_os_error(ERROR_INVALID_PARAMETER));+ }+ }+ }++ Ok(+ match (options.create, options.truncate, options.create_new) {+ (false, false, false) => OPEN_EXISTING,+ (true, false, false) => OPEN_ALWAYS,+ (false, true, false) => TRUNCATE_EXISTING,+ (true, true, false) => CREATE_ALWAYS,+ (_, _, true) => CREATE_NEW,+ },+ )+}diff --git a/crates/wasi/src/filesystem/primitives/windows/fs/open_unchecked.rs b/crates/wasi/src/filesystem/primitives/windows/fs/open_unchecked.rsnew file mode 100644index 0000000000..9adb1ec848--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/windows/fs/open_unchecked.rs@@ -0,0 +1,215 @@+//! Windows implementation of `openat` functionality.++#![allow(unsafe_code)]++use super::create_file_at_w::CreateFileAtW;+use super::prepare_open_options_for_open;+use crate::filesystem::primitives::{+ FollowSymlinks, OpenOptions, OpenUncheckedError, SymlinkKind, errors, file_path,+ get_access_mode, get_creation_mode, get_flags_and_attributes,+};+use std::ffi::OsStr;+use std::os::windows::ffi::OsStrExt;+use std::os::windows::fs::MetadataExt;+use std::os::windows::io::{AsRawHandle, FromRawHandle, OwnedHandle};+use std::path::{Component, Path, PathBuf};+use std::{fs, io};+use windows_sys::Win32::Foundation::{self, ERROR_ACCESS_DENIED, HANDLE, INVALID_HANDLE_VALUE};+use windows_sys::Win32::Storage::FileSystem::{+ CreateFileW, FILE_ATTRIBUTE_DIRECTORY, FILE_FLAG_OPEN_REPARSE_POINT,+};++/// *Unsandboxed* function similar to `open`, but which does not perform+/// sandboxing.+pub(crate) fn open_unchecked(+ start: &fs::File,+ path: &Path,+ options: &OpenOptions,+) -> Result<fs::File, OpenUncheckedError> {+ // We have the final `OpenOptions`; now prepare it for an `open`.+ let mut prepared_opts = options.clone();+ let manually_trunc = prepare_open_options_for_open(&mut prepared_opts);++ handle_open_result(+ open_at(start, path, &prepared_opts),+ options,+ manually_trunc,+ )+}++// The following is derived from Rust's library/std/src/sys/windows/fs.rs+// at revision 56888c1e9b4135b511abd2d8e907099003d12281, except with a+// directory `start` parameter added and using `CreateFileAtW` instead of+// `CreateFileW`.++fn open_at(start: &fs::File, path: &Path, opts: &OpenOptions) -> io::Result<fs::File> {+ let mut dir = start.as_raw_handle() as HANDLE;++ // `PathCchCanonicalizeEx` and friends don't seem to work with relative+ // paths. Or at least, when I tried it, they canonicalized "a" to "",+ // which isn't what we want. So we manually canonicalize `..` and `.`.+ // Hopefully there aren't other mysterious Windows path conventions that+ // we're missing here.+ let mut rebuilt = PathBuf::new();+ for component in path.components() {+ match component {+ Component::Prefix(_) | Component::RootDir => {+ rebuilt.push(component);+ dir = 0 as HANDLE;+ }+ Component::Normal(_) => {+ rebuilt.push(component);+ }+ Component::ParentDir => {+ if !rebuilt.pop() {+ // We popped past the beginning of `path`. Substitute in+ // the path of `start` and convert this to an ambient+ // path by dropping the directory base. It's ok to do+ // this because we're not sandboxing at this level of the+ // code.+ if dir == 0 as HANDLE {+ return Err(io::Error::from_raw_os_error(ERROR_ACCESS_DENIED as _));+ }+ rebuilt = match file_path(start) {+ Some(path) => path,+ None => {+ return Err(io::Error::from_raw_os_error(ERROR_ACCESS_DENIED as _));+ }+ };+ dir = 0 as HANDLE;+ // And then pop the last component of that.+ let _ = rebuilt.pop();+ }+ }+ Component::CurDir => (),+ }+ }++ let mut wide = OsStr::encode_wide(rebuilt.as_os_str()).collect::<Vec<u16>>();++ // If we ended up re-rooting, use Windows' `CreateFileW` instead of our+ // own `CreateFileAtW` so that it does the requisite magic for absolute+ // paths.+ if dir == 0 as HANDLE {+ // We're calling the windows-sys `CreateFileW` which expects a+ // NUL-terminated filename, so add a NUL terminator.+ wide.push(0);++ let handle = unsafe {+ CreateFileW(+ wide.as_ptr(),+ get_access_mode(opts)?,+ opts.ext.share_mode,+ opts.ext.security_attributes,+ get_creation_mode(opts)?,+ get_flags_and_attributes(opts),+ 0 as HANDLE,+ )+ };+ if handle != INVALID_HANDLE_VALUE {+ Ok(unsafe { fs::File::from_raw_handle(handle as _) })+ } else {+ Err(io::Error::last_os_error())+ }+ } else {+ // Our own `CreateFileAtW` is similar to `CreateFileW` except it+ // takes the filename as a Rust slice directly, so we can skip+ // the NUL terminator.+ let handle = unsafe {+ CreateFileAtW(+ dir,+ &wide,+ get_access_mode(opts)?,+ opts.ext.share_mode,+ opts.ext.security_attributes,+ get_creation_mode(opts)?,+ get_flags_and_attributes(opts),+ 0 as HANDLE,+ )+ };++ if let Ok(handle) = handle.try_into() {+ Ok(<fs::File as From<OwnedHandle>>::from(handle))+ } else {+ Err(io::Error::last_os_error())+ }+ }+}++fn handle_open_result(+ result: io::Result<fs::File>,+ options: &OpenOptions,+ manually_trunc: bool,+) -> Result<fs::File, OpenUncheckedError> {+ match result {+ Ok(f) => {+ let enforce_dir = options.dir_required;+ let enforce_nofollow = options.follow == FollowSymlinks::No+ && (options.ext.custom_flags & FILE_FLAG_OPEN_REPARSE_POINT) == 0;++ if enforce_dir || enforce_nofollow {+ let metadata = f.metadata().map_err(OpenUncheckedError::Other)?;++ if enforce_dir {+ // Require a directory. It may seem possible to eliminate+ // this `metadata()` call by appending a slash to the path+ // before opening it so that the OS requires a directory+ // for us, however on Windows in some circumstances this+ // leads to "The filename, directory name, or volume label+ // syntax is incorrect." errors.+ //+ // We check `file_attributes()` instead of using `is_dir()`+ // since the latter returns false if we're looking at a+ // directory symlink.+ if metadata.file_attributes() & FILE_ATTRIBUTE_DIRECTORY == 0 {+ return Err(OpenUncheckedError::Other(errors::is_not_directory()));+ }+ }++ if enforce_nofollow {+ // Windows doesn't have a way to return errors like+ // `O_NOFOLLOW`, so if we're not following symlinks and+ // we're not using `FILE_FLAG_OPEN_REPARSE_POINT` manually+ // to open a symlink itself, check for symlinks and report+ // them as a distinct error.+ if metadata.file_type().is_symlink() {+ return Err(OpenUncheckedError::Symlink(+ io::Error::from_raw_os_error(+ Foundation::ERROR_STOPPED_ON_SYMLINK as i32,+ ),+ if metadata.file_attributes() & FILE_ATTRIBUTE_DIRECTORY+ == FILE_ATTRIBUTE_DIRECTORY+ {+ SymlinkKind::Dir+ } else {+ SymlinkKind::File+ },+ ));+ }+ }+ }++ // Windows truncates symlinks into normal files, so truncation+ // may be disabled above; do it manually if needed. Note that this+ // is expected to always succeed for normal files, but this will+ // fail if a directory was opened as directories don't support+ // truncation.+ if manually_trunc {+ if let Err(e) = f.set_len(0) {+ return Err(OpenUncheckedError::Other(e));+ }+ }+ Ok(f)+ }+ Err(e) if e.kind() == io::ErrorKind::NotFound => Err(OpenUncheckedError::NotFound(e)),+ Err(e) => match e.raw_os_error() {+ Some(code) => match code as u32 {+ Foundation::ERROR_FILE_NOT_FOUND | Foundation::ERROR_PATH_NOT_FOUND => {+ Err(OpenUncheckedError::NotFound(e))+ }+ _ => Err(OpenUncheckedError::Other(e)),+ },+ None => Err(OpenUncheckedError::Other(e)),+ },+ }+}diff --git a/crates/wasi/src/filesystem/primitives/windows/fs/read_dir_inner.rs b/crates/wasi/src/filesystem/primitives/windows/fs/read_dir_inner.rsnew file mode 100644index 0000000000..5d8941804c--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/windows/fs/read_dir_inner.rs@@ -0,0 +1,41 @@+use super::get_path::concatenate;+use crate::filesystem::primitives::DirEntryInner;+use std::path::{Component, Path};+use std::{fmt, fs, io};++pub(crate) struct ReadDirInner {+ std: fs::ReadDir,+}++impl ReadDirInner {+ pub(crate) fn read_base_dir(start: &fs::File) -> io::Result<Self> {+ Self::new_unchecked(&start, Component::CurDir.as_ref())+ }++ pub(crate) fn new_unchecked(start: &fs::File, path: &Path) -> io::Result<Self> {+ let full_path = concatenate(start, path)?;+ Ok(Self {+ std: fs::read_dir(full_path)?,+ })+ }+}++impl Iterator for ReadDirInner {+ type Item = io::Result<DirEntryInner>;++ fn next(&mut self) -> Option<Self::Item> {+ self.std+ .next()+ .map(|result| result.map(DirEntryInner::from_std))+ }+}++impl fmt::Debug for ReadDirInner {+ // Like libstd's version, but doesn't print the path.+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {+ let mut b = f.debug_struct("ReadDir");+ // `fs::ReadDir`'s `Debug` just prints the path, and since we're not+ // printing that, we don't have anything else to print.+ b.finish()+ }+}diff --git a/crates/wasi/src/filesystem/primitives/windows/fs/read_link_impl.rs b/crates/wasi/src/filesystem/primitives/windows/fs/read_link_impl.rsnew file mode 100644index 0000000000..b93086268a--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/windows/fs/read_link_impl.rs@@ -0,0 +1,20 @@+use crate::filesystem::primitives::{FollowSymlinks, OpenOptions, OpenOptionsExt, open};+use std::path::{Path, PathBuf};+use std::{fs, io};+use windows_sys::Win32::Storage::FileSystem::{+ FILE_FLAG_BACKUP_SEMANTICS, FILE_FLAG_OPEN_REPARSE_POINT,+};++/// *Unsandboxed* function similar to `read_link`, but which does not perform+/// sandboxing.+pub(crate) fn read_link_impl(start: &fs::File, path: &Path) -> io::Result<PathBuf> {+ // Open the link with no access mode, instead of generic read.+ // By default FILE_LIST_DIRECTORY is denied for the junction "C:\Documents and+ // Settings", so this is needed for a common case.+ let mut opts = OpenOptions::new();+ opts.access_mode(0);+ opts.custom_flags(FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS);+ opts.follow(FollowSymlinks::No);+ let file = open(start, path, &opts)?;+ winx::file::read_link(&file)+}diff --git a/crates/wasi/src/filesystem/primitives/windows/fs/read_link_unchecked.rs b/crates/wasi/src/filesystem/primitives/windows/fs/read_link_unchecked.rsnew file mode 100644index 0000000000..5d5bf218f1--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/windows/fs/read_link_unchecked.rs@@ -0,0 +1,14 @@+use super::get_path::concatenate;+use std::path::{Path, PathBuf};+use std::{fs, io};++/// *Unsandboxed* function similar to `read_link`, but which does not perform+/// sandboxing.+pub(crate) fn read_link_unchecked(+ start: &fs::File,+ path: &Path,+ _reuse: PathBuf,+) -> io::Result<PathBuf> {+ let full_path = concatenate(start, path)?;+ fs::read_link(full_path)+}diff --git a/crates/wasi/src/filesystem/primitives/windows/fs/remove_dir_unchecked.rs b/crates/wasi/src/filesystem/primitives/windows/fs/remove_dir_unchecked.rsnew file mode 100644index 0000000000..3b80cac3e9--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/windows/fs/remove_dir_unchecked.rs@@ -0,0 +1,10 @@+use super::get_path::concatenate;+use std::path::Path;+use std::{fs, io};++/// *Unsandboxed* function similar to `remove_dir`, but which does not perform+/// sandboxing.+pub(crate) fn remove_dir_unchecked(start: &fs::File, path: &Path) -> io::Result<()> {+ let full_path = concatenate(start, path)?;+ fs::remove_dir(full_path)+}diff --git a/crates/wasi/src/filesystem/primitives/windows/fs/remove_file_unchecked.rs b/crates/wasi/src/filesystem/primitives/windows/fs/remove_file_unchecked.rsnew file mode 100644index 0000000000..9486e8d5e3--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/windows/fs/remove_file_unchecked.rs@@ -0,0 +1,10 @@+use super::get_path::concatenate;+use std::path::Path;+use std::{fs, io};++/// *Unsandboxed* function similar to `remove_file`, but which does not perform+/// sandboxing.+pub(crate) fn remove_file_unchecked(start: &fs::File, path: &Path) -> io::Result<()> {+ let full_path = concatenate(start, path)?;+ fs::remove_file(full_path)+}diff --git a/crates/wasi/src/filesystem/primitives/windows/fs/rename_unchecked.rs b/crates/wasi/src/filesystem/primitives/windows/fs/rename_unchecked.rsnew file mode 100644index 0000000000..5afbdb5c5b--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/windows/fs/rename_unchecked.rs@@ -0,0 +1,16 @@+use super::get_path::concatenate;+use std::path::Path;+use std::{fs, io};++/// *Unsandboxed* function similar to `rename`, but which does not perform+/// sandboxing.+pub(crate) fn rename_unchecked(+ old_start: &fs::File,+ old_path: &Path,+ new_start: &fs::File,+ new_path: &Path,+) -> io::Result<()> {+ let old_full_path = concatenate(old_start, old_path)?;+ let new_full_path = concatenate(new_start, new_path)?;+ fs::rename(old_full_path, new_full_path)+}diff --git a/crates/wasi/src/filesystem/primitives/windows/fs/set_times_impl.rs b/crates/wasi/src/filesystem/primitives/windows/fs/set_times_impl.rsnew file mode 100644index 0000000000..c0acd4c9cc--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/windows/fs/set_times_impl.rs@@ -0,0 +1,52 @@+use crate::filesystem::primitives::{OpenOptions, OpenOptionsExt, open};+use std::path::Path;+use std::time::SystemTime;+use std::{fs, io};+use windows_sys::Win32::Storage::FileSystem::{+ FILE_FLAG_BACKUP_SEMANTICS, FILE_FLAG_OPEN_REPARSE_POINT,+};++#[inline]+pub(crate) fn set_times_impl(+ start: &fs::File,+ path: &Path,+ atime: Option<SystemTime>,+ mtime: Option<SystemTime>,+) -> io::Result<()> {+ set_times_inner(start, path, atime, mtime, 0)+}++#[inline]+pub(crate) fn set_times_nofollow_impl(+ start: &fs::File,+ path: &Path,+ atime: Option<SystemTime>,+ mtime: Option<SystemTime>,+) -> io::Result<()> {+ set_times_inner(start, path, atime, mtime, FILE_FLAG_OPEN_REPARSE_POINT)+}++fn set_times_inner(+ start: &fs::File,+ path: &Path,+ atime: Option<SystemTime>,+ mtime: Option<SystemTime>,+ custom_flags: u32,+) -> io::Result<()> {+ let custom_flags = custom_flags | FILE_FLAG_BACKUP_SEMANTICS;++ // On Windows, `set_times` requires write permissions.+ let file = open(+ start,+ path,+ OpenOptions::new().write(true).custom_flags(custom_flags),+ )?;+ let mut times = fs::FileTimes::new();+ if let Some(atime) = atime {+ times = times.set_accessed(atime);+ }+ if let Some(mtime) = mtime {+ times = times.set_modified(mtime);+ }+ file.set_times(times)+}diff --git a/crates/wasi/src/filesystem/primitives/windows/fs/stat_unchecked.rs b/crates/wasi/src/filesystem/primitives/windows/fs/stat_unchecked.rsnew file mode 100644index 0000000000..b39ce5a44d--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/windows/fs/stat_unchecked.rs@@ -0,0 +1,36 @@+use crate::filesystem::primitives::OpenOptionsExt;+use crate::filesystem::primitives::{FollowSymlinks, Metadata, OpenOptions, open_unchecked};+use std::path::Path;+use std::{fs, io};+use windows_sys::Win32::Storage::FileSystem::{+ FILE_FLAG_BACKUP_SEMANTICS, FILE_FLAG_OPEN_REPARSE_POINT,+};++/// *Unsandboxed* function similar to `stat`, but which does not perform+/// sandboxing.+pub(crate) fn stat_unchecked(+ start: &fs::File,+ path: &Path,+ follow: FollowSymlinks,+) -> io::Result<Metadata> {+ // Attempt to open the file to get the metadata that way, as that gives+ // us all the info.+ let mut opts = OpenOptions::new();++ // Explicitly request no access, because we're just querying metadata.+ opts.access_mode(0);++ match follow {+ FollowSymlinks::Yes => {+ opts.custom_flags(FILE_FLAG_BACKUP_SEMANTICS);+ opts.follow(FollowSymlinks::Yes);+ }+ FollowSymlinks::No => {+ opts.custom_flags(FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS);+ opts.follow(FollowSymlinks::No);+ }+ }++ let file = open_unchecked(start, path, &opts)?;+ Metadata::from_file(&file)+}diff --git a/crates/wasi/src/filesystem/primitives/windows/fs/symlink_unchecked.rs b/crates/wasi/src/filesystem/primitives/windows/fs/symlink_unchecked.rsnew file mode 100644index 0000000000..73c6794da3--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/windows/fs/symlink_unchecked.rs@@ -0,0 +1,25 @@+use super::get_path::concatenate;+use std::path::Path;+use std::{fs, io};++/// *Unsandboxed* function similar to `symlink_file`, but which does not+/// perform sandboxing.+pub(crate) fn symlink_file_unchecked(+ old_path: &Path,+ new_start: &fs::File,+ new_path: &Path,+) -> io::Result<()> {+ let new_full_path = concatenate(new_start, new_path)?;+ std::os::windows::fs::symlink_file(old_path, new_full_path)+}++/// *Unsandboxed* function similar to `symlink_dir`, but which does not perform+/// sandboxing.+pub(crate) fn symlink_dir_unchecked(+ old_path: &Path,+ new_start: &fs::File,+ new_path: &Path,+) -> io::Result<()> {+ let new_full_path = concatenate(new_start, new_path)?;+ std::os::windows::fs::symlink_dir(old_path, new_full_path)+}diff --git a/crates/wasi/src/filesystem/primitives/windows/mod.rs b/crates/wasi/src/filesystem/primitives/windows/mod.rsnew file mode 100644index 0000000000..5553d02ec5--- /dev/null+++ b/crates/wasi/src/filesystem/primitives/windows/mod.rs@@ -0,0 +1,4 @@+//! The `winx` module contains code specific to Windows, supported by the+//! `winx` crate.++pub(crate) mod fs;diff --git a/crates/wasi/src/filesystem/unix.rs b/crates/wasi/src/filesystem/unix.rsindex ade351c2a6..9a14680d5c 100644--- a/crates/wasi/src/filesystem/unix.rs+++ b/crates/wasi/src/filesystem/unix.rs@@ -1,9 +1,9 @@+use crate::filesystem::primitives::{+ FileType, FileTypeExt, FollowSymlinks, Metadata, MetadataExt, OpenOptions,+};use crate::filesystem::{Advice, DescriptorFlags, DescriptorStat, DescriptorType, MetadataHashValue,};-use cap_primitives::fs::{- FileType, FileTypeExt, FollowSymlinks, Metadata, MetadataExt, OpenOptions,-};use rustix::fs::{OFlags, fcntl_getfl, fcntl_setfl};use rustix::io::write;use std::fs::File;@@ -11,8 +11,8 @@ use std::io;use std::os::unix::fs::FileExt;use std::path::Path;-pub use cap_primitives::fs::remove_file as remove_file_or_symlink;-pub use cap_primitives::fs::symlink;+pub use crate::filesystem::primitives::remove_file as remove_file_or_symlink;+pub use crate::filesystem::primitives::symlink;pub(crate) fn get_flags(file: &File) -> io::Result<DescriptorFlags> {let flags = fcntl_getfl(file)?;@@ -122,7 +122,7 @@ pub(crate) fn metadata_hash_at(path: &Path,follow: FollowSymlinks,) -> io::Result<MetadataHashValue> {- let meta = cap_primitives::fs::stat(start, path, follow)?;+ let meta = crate::filesystem::primitives::stat(start, path, follow)?;Ok(MetadataHashValue::new(meta_identity(&meta)))}@@ -140,7 +140,7 @@ pub(crate) fn stat_at(path: &Path,follow: FollowSymlinks,) -> io::Result<DescriptorStat> {- let meta = cap_primitives::fs::stat(start, path, follow)?;+ let meta = crate::filesystem::primitives::stat(start, path, follow)?;Ok(DescriptorStat::new(&meta, meta.nlink()))}diff --git a/crates/wasi/src/filesystem/windows.rs b/crates/wasi/src/filesystem/windows.rsindex f0760d85c9..ab5d9209b7 100644--- a/crates/wasi/src/filesystem/windows.rs+++ b/crates/wasi/src/filesystem/windows.rs@@ -1,7 +1,9 @@+use crate::filesystem::primitives::{+ FileType, FollowSymlinks, Metadata, OpenOptions, OpenOptionsExt,+};use crate::filesystem::{Advice, DescriptorFlags, DescriptorStat, DescriptorType, MetadataHashValue,};-use cap_primitives::fs::{FileType, FollowSymlinks, Metadata, OpenOptions, OpenOptionsExt};use std::fs::File;use std::io::{self, Write};use std::mem::{self, MaybeUninit};@@ -122,18 +124,15 @@ fn open_metadata_handle(start: &File, path: &Path, follow: FollowSymlinks) -> ioopts.custom_flags(FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT);}}- cap_primitives::fs::open(start, path, &opts)+ crate::filesystem::primitives::open(start, path, &opts)}pub(crate) fn stat(f: &std::fs::File) -> io::Result<DescriptorStat> {let meta = Metadata::from_file(f)?;- // Note that this is intentionally scoped to a separate block to- // minimize the surface area that is depended on by cap-fs-ext.- let link_count = {- use cap_fs_ext_avoid_using_this::MetadataExt;- meta.nlink()- };+ let link_count = crate::filesystem::primitives::_WindowsByHandle::number_of_links(&meta)+ .unwrap()+ .into();Ok(DescriptorStat::new(&meta, link_count))}@@ -179,10 +178,10 @@ fn is_char_device(ft: FileType) -> bool {}pub(crate) fn symlink(original: &Path, start: &File, link: &Path) -> io::Result<()> {- if cap_primitives::fs::stat(start, original, FollowSymlinks::Yes)?.is_dir() {- cap_primitives::fs::symlink_dir(original, start, link)+ if crate::filesystem::primitives::stat(start, original, FollowSymlinks::Yes)?.is_dir() {+ crate::filesystem::primitives::symlink_dir(original, start, link)} else {- cap_primitives::fs::symlink_file(original, start, link)+ crate::filesystem::primitives::symlink_file(original, start, link)}}@@ -193,16 +192,17 @@ pub(crate) fn remove_file_or_symlink(start: &File, path: &Path) -> io::Result<()let mut opts = OpenOptions::new();opts.access_mode(DELETE);opts.custom_flags(FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS);- let file = cap_primitives::fs::open(start, path, &opts)?;+ let file = crate::filesystem::primitives::open(start, path, &opts)?;let meta = Metadata::from_file(&file)?;if meta.file_type().is_symlink()- && cap_primitives::fs::MetadataExt::file_attributes(&meta) & FILE_ATTRIBUTE_DIRECTORY+ && crate::filesystem::primitives::MetadataExt::file_attributes(&meta)+ & FILE_ATTRIBUTE_DIRECTORY== FILE_ATTRIBUTE_DIRECTORY{- cap_primitives::fs::remove_dir(start, path)?;+ crate::filesystem::primitives::remove_dir(start, path)?;} else {- cap_primitives::fs::remove_file(start, path)?;+ crate::filesystem::primitives::remove_file(start, path)?;}// Drop the file after calling `remove_file` or `remove_dir`, sincediff --git a/crates/wasi/src/lib.rs b/crates/wasi/src/lib.rsindex 6dfd0b83d6..005d8155d5 100644--- a/crates/wasi/src/lib.rs+++ b/crates/wasi/src/lib.rs@@ -2,10 +2,10 @@//! # Wasmtime's WASI Implementation//!-//! This crate provides a Wasmtime host implementations of different versions of WASI.-//! WASI is implemented with the Rust crates [`tokio`] and-//! [`cap-primitives`](cap_primitives) primarily, meaning that operations are-//! implemented in terms of their native platform equivalents by default.+//! This crate provides a Wasmtime host implementations of different versions of+//! WASI. WASI is implemented with the Rust crate [`tokio`] combined with custom+//! implementations in this crate, and operations are implemented in terms of+//! their native platform equivalents by default.//!//! For components and WASIp2, see [`p2`].//! For WASIp1 and core modules, see the [`p1`] module documentation.@@ -59,7 +59,7 @@ pub use self::view::{WasiCtxView, WasiView};#[doc(no_inline)]pub use async_trait::async_trait;#[doc(no_inline)]-pub use cap_primitives::fs::SystemTimeSpec;+pub use public_cap_primitives::fs::SystemTimeSpec;#[doc(no_inline)]pub use rand::Rng;#[doc(no_inline)]diff --git a/crates/wasi/src/p2/host/filesystem.rs b/crates/wasi/src/p2/host/filesystem.rsindex 579c74129a..7f5ef8aec7 100644--- a/crates/wasi/src/p2/host/filesystem.rs+++ b/crates/wasi/src/p2/host/filesystem.rs@@ -171,7 +171,7 @@ impl HostDescriptor for WasiFilesystemCtxView<'_> {// within this `block` call, rather than delay calculating the metadata// for entries when they're demanded later in the iterator chain.Ok::<_, std::io::Error>(- cap_primitives::fs::read_base_dir(d)?+ crate::filesystem::primitives::read_base_dir(d)?.map(|entry| {let entry = entry?;let meta = entry.metadata()?;@@ -713,7 +713,7 @@ impl From<std::num::TryFromIntError> for ErrorCode {}}-fn descriptortype_from(ft: cap_primitives::fs::FileType) -> types::DescriptorType {+fn descriptortype_from(ft: crate::filesystem::primitives::FileType) -> types::DescriptorType {crate::filesystem::DescriptorType::from(ft).into()}diff --git a/crates/wasi/src/p3/filesystem/host.rs b/crates/wasi/src/p3/filesystem/host.rsindex f71e61d810..6ea173bbe4 100644--- a/crates/wasi/src/p3/filesystem/host.rs+++ b/crates/wasi/src/p3/filesystem/host.rs@@ -243,7 +243,7 @@ impl<D> StreamProducer<D> for ReadStreamProducer {}fn map_dir_entry(- entry: std::io::Result<cap_primitives::fs::DirEntry>,+ entry: std::io::Result<crate::filesystem::primitives::DirEntry>,) -> Result<Option<DirectoryEntry>, ErrorCode> {match entry {Ok(entry) => {@@ -289,7 +289,7 @@ impl ReadDirStream {let (tx, rx) = mpsc::channel(1);ReadDirStream {task: spawn_blocking(move || {- let entries = cap_primitives::fs::read_base_dir(&dir)?;+ let entries = crate::filesystem::primitives::read_base_dir(&dir)?;for entry in entries {if let Some(entry) = map_dir_entry(entry)? {if let Err(_) = tx.blocking_send(entry) {@@ -676,7 +676,7 @@ impl<U> types::HostDescriptorWithStore<U> for WasiFilesystem {let allow_blocking_current_thread = dir.allow_blocking_current_thread;let dir = Arc::clone(dir.as_dir());if allow_blocking_current_thread {- match cap_primitives::fs::read_base_dir(&dir) {+ match crate::filesystem::primitives::read_base_dir(&dir) {Ok(readdir) => StreamReader::new(&mut store,FallibleIteratorProducer::new(diff --git a/crates/wasi/src/p3/filesystem/mod.rs b/crates/wasi/src/p3/filesystem/mod.rsindex 11816c12ea..31ccb52ed6 100644--- a/crates/wasi/src/p3/filesystem/mod.rs+++ b/crates/wasi/src/p3/filesystem/mod.rs@@ -265,8 +265,8 @@ impl From<crate::filesystem::DescriptorType> for types::DescriptorType {}}-impl From<cap_primitives::fs::FileType> for types::DescriptorType {- fn from(ft: cap_primitives::fs::FileType) -> Self {+impl From<crate::filesystem::primitives::FileType> for types::DescriptorType {+ fn from(ft: crate::filesystem::primitives::FileType) -> Self {crate::filesystem::DescriptorType::from(ft).into()}}diff --git a/supply-chain/imports.lock b/supply-chain/imports.lockindex 2f8b2855d6..5532c77ffa 100644--- a/supply-chain/imports.lock+++ b/supply-chain/imports.lock@@ -340,13 +340,6 @@ user-id = 1user-login = "alexcrichton"user-name = "Alex Crichton"-[[publisher.cap-fs-ext]]-version = "4.0.3"-when = "2026-08-20"-user-id = 6825-user-login = "sunfishcode"-user-name = "Dan Gohman"-[[publisher.cap-primitives]]version = "4.0.3"when = "2026-08-20"@@ -354,13 +347,6 @@ user-id = 6825user-login = "sunfishcode"user-name = "Dan Gohman"-[[publisher.cap-std]]-version = "4.0.3"-when = "2026-08-20"-user-id = 6825-user-login = "sunfishcode"-user-name = "Dan Gohman"-[[publisher.cc]]version = "1.0.89"when = "2024-03-04"