wasmtime 9.0.4 → 10.0.1

data/ext/cargo-vendor/wasmtime-wasi-10.0.1/src/preview2/filesystem.rs

@@ -0,0 +1,269 @@
+use crate::preview2::{InputStream, OutputStream, Table, TableError};
+use std::any::Any;
+use std::sync::Arc;
+
+bitflags::bitflags! {
+    pub struct FilePerms: usize {
+        const READ = 0b1;
+        const WRITE = 0b10;
+    }
+}
+
+pub(crate) struct File {
+    pub file: Arc<cap_std::fs::File>,
+    pub perms: FilePerms,
+}
+
+impl File {
+    pub fn new(file: cap_std::fs::File, perms: FilePerms) -> Self {
+        Self {
+            file: Arc::new(file),
+            perms,
+        }
+    }
+}
+pub(crate) trait TableFsExt {
+    fn push_file(&mut self, file: File) -> Result<u32, TableError>;
+    fn delete_file(&mut self, fd: u32) -> Result<File, TableError>;
+    fn is_file(&self, fd: u32) -> bool;
+    fn get_file(&self, fd: u32) -> Result<&File, TableError>;
+
+    fn push_dir(&mut self, dir: Dir) -> Result<u32, TableError>;
+    fn delete_dir(&mut self, fd: u32) -> Result<Dir, TableError>;
+    fn is_dir(&self, fd: u32) -> bool;
+    fn get_dir(&self, fd: u32) -> Result<&Dir, TableError>;
+}
+
+impl TableFsExt for Table {
+    fn push_file(&mut self, file: File) -> Result<u32, TableError> {
+        self.push(Box::new(file))
+    }
+    fn delete_file(&mut self, fd: u32) -> Result<File, TableError> {
+        self.delete(fd)
+    }
+    fn is_file(&self, fd: u32) -> bool {
+        self.is::<File>(fd)
+    }
+    fn get_file(&self, fd: u32) -> Result<&File, TableError> {
+        self.get(fd)
+    }
+
+    fn push_dir(&mut self, dir: Dir) -> Result<u32, TableError> {
+        self.push(Box::new(dir))
+    }
+    fn delete_dir(&mut self, fd: u32) -> Result<Dir, TableError> {
+        self.delete(fd)
+    }
+    fn is_dir(&self, fd: u32) -> bool {
+        self.is::<Dir>(fd)
+    }
+    fn get_dir(&self, fd: u32) -> Result<&Dir, TableError> {
+        self.get(fd)
+    }
+}
+
+bitflags::bitflags! {
+    pub struct DirPerms: usize {
+        const READ = 0b1;
+        const MUTATE = 0b10;
+    }
+}
+
+pub(crate) struct Dir {
+    pub dir: cap_std::fs::Dir,
+    pub perms: DirPerms,
+    pub file_perms: FilePerms,
+}
+
+impl Dir {
+    pub fn new(dir: cap_std::fs::Dir, perms: DirPerms, file_perms: FilePerms) -> Self {
+        Dir {
+            dir,
+            perms,
+            file_perms,
+        }
+    }
+}
+
+pub(crate) struct FileInputStream {
+    file: Arc<cap_std::fs::File>,
+    position: u64,
+}
+impl FileInputStream {
+    pub fn new(file: Arc<cap_std::fs::File>, position: u64) -> Self {
+        Self { file, position }
+    }
+}
+
+#[async_trait::async_trait]
+impl InputStream for FileInputStream {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+    #[cfg(unix)]
+    fn pollable_read(&self) -> Option<rustix::fd::BorrowedFd> {
+        use cap_std::io_lifetimes::AsFd;
+        Some(self.file.as_fd())
+    }
+    #[cfg(windows)]
+    fn pollable_read(&self) -> Option<io_extras::os::windows::BorrowedHandleOrSocket> {
+        use io_extras::os::windows::AsHandleOrSocket;
+        Some(self.file.as_handle_or_socket())
+    }
+    async fn read(&mut self, buf: &mut [u8]) -> anyhow::Result<(u64, bool)> {
+        use system_interface::fs::FileIoExt;
+        let (n, end) = read_result(self.file.read_at(buf, self.position))?;
+        self.position = self.position.wrapping_add(n);
+        Ok((n, end))
+    }
+    async fn read_vectored<'a>(
+        &mut self,
+        bufs: &mut [std::io::IoSliceMut<'a>],
+    ) -> anyhow::Result<(u64, bool)> {
+        use system_interface::fs::FileIoExt;
+        let (n, end) = read_result(self.file.read_vectored_at(bufs, self.position))?;
+        self.position = self.position.wrapping_add(n);
+        Ok((n, end))
+    }
+    fn is_read_vectored(&self) -> bool {
+        use system_interface::fs::FileIoExt;
+        self.file.is_read_vectored_at()
+    }
+    async fn num_ready_bytes(&self) -> anyhow::Result<u64> {
+        // FIXME we ought to be able to do better than this
+        Ok(0)
+    }
+    async fn readable(&self) -> anyhow::Result<()> {
+        // FIXME is this the spot to perform the permission check?
+        Ok(())
+    }
+}
+
+pub(crate) fn read_result(r: Result<usize, std::io::Error>) -> Result<(u64, bool), std::io::Error> {
+    match r {
+        Ok(0) => Ok((0, true)),
+        Ok(n) => Ok((n as u64, false)),
+        Err(e) if e.kind() == std::io::ErrorKind::Interrupted => Ok((0, false)),
+        Err(e) => Err(e),
+    }
+}
+
+pub(crate) struct FileOutputStream {
+    file: Arc<cap_std::fs::File>,
+    position: u64,
+}
+impl FileOutputStream {
+    pub fn new(file: Arc<cap_std::fs::File>, position: u64) -> Self {
+        Self { file, position }
+    }
+}
+
+#[async_trait::async_trait]
+impl OutputStream for FileOutputStream {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    /// If this stream is writing from a host file descriptor, return it so
+    /// that it can be polled with a host poll.
+    #[cfg(unix)]
+    fn pollable_write(&self) -> Option<rustix::fd::BorrowedFd> {
+        use cap_std::io_lifetimes::AsFd;
+        Some(self.file.as_fd())
+    }
+
+    /// If this stream is writing from a host file descriptor, return it so
+    /// that it can be polled with a host poll.
+    #[cfg(windows)]
+    fn pollable_write(&self) -> Option<io_extras::os::windows::BorrowedHandleOrSocket> {
+        use io_extras::os::windows::AsHandleOrSocket;
+        Some(self.file.as_handle_or_socket())
+    }
+
+    /// Write bytes. On success, returns the number of bytes written.
+    async fn write(&mut self, buf: &[u8]) -> anyhow::Result<u64> {
+        use system_interface::fs::FileIoExt;
+        let n = self.file.write_at(buf, self.position)? as i64 as u64;
+        self.position = self.position.wrapping_add(n);
+        Ok(n)
+    }
+
+    /// Vectored-I/O form of `write`.
+    async fn write_vectored<'a>(&mut self, bufs: &[std::io::IoSlice<'a>]) -> anyhow::Result<u64> {
+        use system_interface::fs::FileIoExt;
+        let n = self.file.write_vectored_at(bufs, self.position)? as i64 as u64;
+        self.position = self.position.wrapping_add(n);
+        Ok(n)
+    }
+
+    /// Test whether vectored I/O writes are known to be optimized in the
+    /// underlying implementation.
+    fn is_write_vectored(&self) -> bool {
+        use system_interface::fs::FileIoExt;
+        self.file.is_write_vectored_at()
+    }
+
+    /// Test whether this stream is writable.
+    async fn writable(&self) -> anyhow::Result<()> {
+        // FIXME perm check?
+        Ok(())
+    }
+}
+
+pub(crate) struct FileAppendStream {
+    file: Arc<cap_std::fs::File>,
+}
+impl FileAppendStream {
+    pub fn new(file: Arc<cap_std::fs::File>) -> Self {
+        Self { file }
+    }
+}
+
+#[async_trait::async_trait]
+impl OutputStream for FileAppendStream {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    /// If this stream is writing from a host file descriptor, return it so
+    /// that it can be polled with a host poll.
+    #[cfg(unix)]
+    fn pollable_write(&self) -> Option<rustix::fd::BorrowedFd> {
+        use cap_std::io_lifetimes::AsFd;
+        Some(self.file.as_fd())
+    }
+
+    /// If this stream is writing from a host file descriptor, return it so
+    /// that it can be polled with a host poll.
+    #[cfg(windows)]
+    fn pollable_write(&self) -> Option<io_extras::os::windows::BorrowedHandleOrSocket> {
+        use io_extras::os::windows::AsHandleOrSocket;
+        Some(self.file.as_handle_or_socket())
+    }
+
+    /// Write bytes. On success, returns the number of bytes written.
+    async fn write(&mut self, buf: &[u8]) -> anyhow::Result<u64> {
+        use system_interface::fs::FileIoExt;
+        Ok(self.file.append(buf)? as i64 as u64)
+    }
+
+    /// Vectored-I/O form of `write`.
+    async fn write_vectored<'a>(&mut self, bufs: &[std::io::IoSlice<'a>]) -> anyhow::Result<u64> {
+        use system_interface::fs::FileIoExt;
+        let n = self.file.append_vectored(bufs)? as i64 as u64;
+        Ok(n)
+    }
+
+    /// Test whether vectored I/O writes are known to be optimized in the
+    /// underlying implementation.
+    fn is_write_vectored(&self) -> bool {
+        use system_interface::fs::FileIoExt;
+        self.file.is_write_vectored_at()
+    }
+
+    /// Test whether this stream is writable.
+    async fn writable(&self) -> anyhow::Result<()> {
+        // FIXME perm check?
+        Ok(())
+    }
+}

data/ext/cargo-vendor/wasmtime-wasi-10.0.1/src/preview2/mod.rs

@@ -0,0 +1,44 @@
+//! # Wasmtime's WASI Preview 2 Implementation
+//!
+//! Welcome to the (new!) WASI implementation from the Wasmtime team. The goal
+//! of this implementation is to support WASI Preview 2 via the Component
+//! Model, as well as to provide legacy Preview 1 host support with an adapter
+//! that is implemented in terms of the Preview 2 interfaces.
+//!
+//! Presently, this crate is experimental. We don't yet recommend you use it
+//! in production. Specifically:
+//! * it does not yet support a synchronous rust embedding
+//! * polling and streams need a redesign. IO that currently should be
+//! non-blocking may be blocking. poll probably doesn't work at all.
+//! * its internal organization could use some love
+//! * the wit files in tree describing preview 2 are not faithful to the
+//! standards repos
+//!
+//! Once these issues are resolved, we expect to move this namespace up to the
+//! root of the wasmtime-wasi crate, and move its other exports underneath a
+//! `pub mod legacy` with an off-by-default feature flag, and after 2
+//! releases, retire and remove that code from our tree.
+
+pub mod clocks;
+mod ctx;
+mod error;
+pub(crate) mod filesystem;
+pub mod pipe;
+#[cfg(feature = "preview1-on-preview2")]
+pub mod preview1;
+pub mod preview2;
+pub mod random;
+mod sched;
+pub mod stdio;
+pub mod stream;
+pub mod table;
+pub mod wasi;
+
+pub use cap_fs_ext::SystemTimeSpec;
+pub use cap_rand::RngCore;
+pub use clocks::{WasiClocks, WasiMonotonicClock, WasiWallClock};
+pub use ctx::{WasiCtx, WasiCtxBuilder, WasiView};
+pub use error::I32Exit;
+pub use filesystem::{DirPerms, FilePerms};
+pub use stream::{InputStream, OutputStream};
+pub use table::{Table, TableError};

data/ext/cargo-vendor/wasmtime-wasi-10.0.1/src/preview2/pipe.rs

@@ -0,0 +1,233 @@
+//! Virtual pipes.
+//!
+//! These types provide easy implementations of `WasiFile` that mimic much of the behavior of Unix
+//! pipes. These are particularly helpful for redirecting WASI stdio handles to destinations other
+//! than OS files.
+//!
+//! Some convenience constructors are included for common backing types like `Vec<u8>` and `String`,
+//! but the virtual pipes can be instantiated with any `Read` or `Write` type.
+//!
+use crate::preview2::stream::{InputStream, OutputStream};
+use anyhow::Error;
+use std::any::Any;
+use std::convert::TryInto;
+use std::io::{self, Read, Write};
+use std::sync::{Arc, RwLock};
+use system_interface::io::ReadReady;
+
+/// A virtual pipe read end.
+///
+/// This reads from a source that implements the [`Read`] trait. It
+/// also requires the [`ReadReady`] trait, which is implemented for many
+/// popular `Read`-implementing types and is easy to implemented for new
+/// types.
+///
+/// A variety of `From` impls are provided so that common pipe types are
+/// easy to create. For example:
+///
+/// ```
+/// use wasmtime_wasi::preview2::{pipe::ReadPipe, WasiCtx};
+/// let stdin = ReadPipe::from("hello from stdin!");
+/// let builder = WasiCtx::builder().set_stdin(stdin);
+/// ```
+#[derive(Debug)]
+pub struct ReadPipe<R: Read + ReadReady> {
+    reader: Arc<RwLock<R>>,
+}
+
+impl<R: Read + ReadReady> Clone for ReadPipe<R> {
+    fn clone(&self) -> Self {
+        Self {
+            reader: self.reader.clone(),
+        }
+    }
+}
+
+impl<R: Read + ReadReady> ReadPipe<R> {
+    /// Create a new pipe from a `Read` type.
+    ///
+    /// All `Handle` read operations delegate to reading from this underlying reader.
+    pub fn new(r: R) -> Self {
+        Self::from_shared(Arc::new(RwLock::new(r)))
+    }
+
+    /// Create a new pipe from a shareable `Read` type.
+    ///
+    /// All `Handle` read operations delegate to reading from this underlying reader.
+    pub fn from_shared(reader: Arc<RwLock<R>>) -> Self {
+        Self { reader }
+    }
+
+    /// Try to convert this `ReadPipe<R>` back to the underlying `R` type.
+    ///
+    /// This will fail with `Err(self)` if multiple references to the underlying `R` exist.
+    pub fn try_into_inner(mut self) -> Result<R, Self> {
+        match Arc::try_unwrap(self.reader) {
+            Ok(rc) => Ok(RwLock::into_inner(rc).unwrap()),
+            Err(reader) => {
+                self.reader = reader;
+                Err(self)
+            }
+        }
+    }
+    fn borrow(&self) -> std::sync::RwLockWriteGuard<R> {
+        RwLock::write(&self.reader).unwrap()
+    }
+}
+
+impl From<Vec<u8>> for ReadPipe<io::Cursor<Vec<u8>>> {
+    fn from(r: Vec<u8>) -> Self {
+        Self::new(io::Cursor::new(r))
+    }
+}
+
+impl From<&[u8]> for ReadPipe<io::Cursor<Vec<u8>>> {
+    fn from(r: &[u8]) -> Self {
+        Self::from(r.to_vec())
+    }
+}
+
+impl From<String> for ReadPipe<io::Cursor<String>> {
+    fn from(r: String) -> Self {
+        Self::new(io::Cursor::new(r))
+    }
+}
+
+impl From<&str> for ReadPipe<io::Cursor<String>> {
+    fn from(r: &str) -> Self {
+        Self::from(r.to_string())
+    }
+}
+
+#[async_trait::async_trait]
+impl<R: Read + ReadReady + Any + Send + Sync> InputStream for ReadPipe<R> {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    async fn num_ready_bytes(&self) -> Result<u64, Error> {
+        Ok(self.borrow().num_ready_bytes()?)
+    }
+
+    async fn read(&mut self, buf: &mut [u8]) -> Result<(u64, bool), Error> {
+        match self.borrow().read(buf) {
+            Ok(0) => Ok((0, true)),
+            Ok(n) => Ok((n.try_into()?, false)),
+            Err(e) if e.kind() == io::ErrorKind::Interrupted => Ok((0, false)),
+            Err(e) => Err(e.into()),
+        }
+    }
+
+    async fn skip(&mut self, nelem: u64) -> Result<(u64, bool), Error> {
+        let num = io::copy(
+            &mut io::Read::take(&mut *self.borrow(), nelem),
+            &mut io::sink(),
+        )?;
+        Ok((num, num < nelem))
+    }
+
+    async fn readable(&self) -> Result<(), Error> {
+        Ok(())
+    }
+}
+
+/// A virtual pipe write end.
+///
+/// ```no_run
+/// use wasmtime_wasi::preview2::{pipe::WritePipe, WasiCtx, Table};
+/// let mut table = Table::new();
+/// let stdout = WritePipe::new_in_memory();
+/// let mut ctx = WasiCtx::builder().set_stdout(stdout.clone()).build(&mut table).unwrap();
+/// // use ctx and table in an instance, then make sure it is dropped:
+/// drop(ctx);
+/// drop(table);
+/// let contents: Vec<u8> = stdout.try_into_inner().expect("sole remaining reference to WritePipe").into_inner();
+/// println!("contents of stdout: {:?}", contents);
+/// ```
+#[derive(Debug)]
+pub struct WritePipe<W: Write> {
+    writer: Arc<RwLock<W>>,
+}
+
+impl<W: Write> Clone for WritePipe<W> {
+    fn clone(&self) -> Self {
+        Self {
+            writer: self.writer.clone(),
+        }
+    }
+}
+
+impl<W: Write> WritePipe<W> {
+    /// Create a new pipe from a `Write` type.
+    ///
+    /// All `Handle` write operations delegate to writing to this underlying writer.
+    pub fn new(w: W) -> Self {
+        Self::from_shared(Arc::new(RwLock::new(w)))
+    }
+
+    /// Create a new pipe from a shareable `Write` type.
+    ///
+    /// All `Handle` write operations delegate to writing to this underlying writer.
+    pub fn from_shared(writer: Arc<RwLock<W>>) -> Self {
+        Self { writer }
+    }
+
+    /// Try to convert this `WritePipe<W>` back to the underlying `W` type.
+    ///
+    /// This will fail with `Err(self)` if multiple references to the underlying `W` exist.
+    pub fn try_into_inner(mut self) -> Result<W, Self> {
+        match Arc::try_unwrap(self.writer) {
+            Ok(rc) => Ok(RwLock::into_inner(rc).unwrap()),
+            Err(writer) => {
+                self.writer = writer;
+                Err(self)
+            }
+        }
+    }
+
+    fn borrow(&self) -> std::sync::RwLockWriteGuard<W> {
+        RwLock::write(&self.writer).unwrap()
+    }
+}
+
+impl WritePipe<io::Cursor<Vec<u8>>> {
+    /// Create a new writable virtual pipe backed by a `Vec<u8>` buffer.
+    pub fn new_in_memory() -> Self {
+        Self::new(io::Cursor::new(vec![]))
+    }
+}
+
+#[async_trait::async_trait]
+impl<W: Write + Any + Send + Sync> OutputStream for WritePipe<W> {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    async fn write(&mut self, buf: &[u8]) -> Result<u64, Error> {
+        let n = self.borrow().write(buf)?;
+        Ok(n.try_into()?)
+    }
+
+    // TODO: Optimize for pipes.
+    /*
+    async fn splice(
+        &mut self,
+        src: &mut dyn InputStream,
+        nelem: u64,
+    ) -> Result<u64, Error> {
+        todo!()
+    }
+    */
+
+    async fn write_zeroes(&mut self, nelem: u64) -> Result<u64, Error> {
+        let num = io::copy(
+            &mut io::Read::take(io::repeat(0), nelem),
+            &mut *self.borrow(),
+        )?;
+        Ok(num)
+    }
+
+    async fn writable(&self) -> Result<(), Error> {
+        Ok(())
+    }
+}