wasmtime 16.0.0 → 17.0.1

data/ext/cargo-vendor/wasmtime-wasi-17.0.1/src/preview2/ctx.rs

@@ -0,0 +1,333 @@
+use crate::preview2::{
+    clocks::{
+        host::{monotonic_clock, wall_clock},
+        HostMonotonicClock, HostWallClock,
+    },
+    filesystem::Dir,
+    network::{SocketAddrCheck, SocketAddrUse},
+    pipe, random, stdio,
+    stdio::{StdinStream, StdoutStream},
+    DirPerms, FilePerms,
+};
+use cap_rand::{Rng, RngCore, SeedableRng};
+use std::sync::Arc;
+use std::{mem, net::SocketAddr};
+use wasmtime::component::ResourceTable;
+
+pub struct WasiCtxBuilder {
+    stdin: Box<dyn StdinStream>,
+    stdout: Box<dyn StdoutStream>,
+    stderr: Box<dyn StdoutStream>,
+    env: Vec<(String, String)>,
+    args: Vec<String>,
+    preopens: Vec<(Dir, String)>,
+    socket_addr_check: SocketAddrCheck,
+    random: Box<dyn RngCore + Send + Sync>,
+    insecure_random: Box<dyn RngCore + Send + Sync>,
+    insecure_random_seed: u128,
+    wall_clock: Box<dyn HostWallClock + Send + Sync>,
+    monotonic_clock: Box<dyn HostMonotonicClock + Send + Sync>,
+    allowed_network_uses: AllowedNetworkUses,
+    built: bool,
+}
+
+impl WasiCtxBuilder {
+    /// Creates a builder for a new context with default parameters set.
+    ///
+    /// The current defaults are:
+    ///
+    /// * stdin is closed
+    /// * stdout and stderr eat all input but it doesn't go anywhere
+    /// * no env vars
+    /// * no arguments
+    /// * no preopens
+    /// * clocks use the host implementation of wall/monotonic clocks
+    /// * RNGs are all initialized with random state and suitable generator
+    ///   quality to satisfy the requirements of WASI APIs.
+    ///
+    /// These defaults can all be updated via the various builder configuration
+    /// methods below.
+    ///
+    /// Note that each builder can only be used once to produce a [`WasiCtx`].
+    /// Invoking the [`build`](WasiCtxBuilder::build) method will panic on the
+    /// second attempt.
+    pub fn new() -> Self {
+        // For the insecure random API, use `SmallRng`, which is fast. It's
+        // also insecure, but that's the deal here.
+        let insecure_random = Box::new(
+            cap_rand::rngs::SmallRng::from_rng(cap_rand::thread_rng(cap_rand::ambient_authority()))
+                .unwrap(),
+        );
+
+        // For the insecure random seed, use a `u128` generated from
+        // `thread_rng()`, so that it's not guessable from the insecure_random
+        // API.
+        let insecure_random_seed =
+            cap_rand::thread_rng(cap_rand::ambient_authority()).gen::<u128>();
+        Self {
+            stdin: Box::new(pipe::ClosedInputStream),
+            stdout: Box::new(pipe::SinkOutputStream),
+            stderr: Box::new(pipe::SinkOutputStream),
+            env: Vec::new(),
+            args: Vec::new(),
+            preopens: Vec::new(),
+            socket_addr_check: SocketAddrCheck::default(),
+            random: random::thread_rng(),
+            insecure_random,
+            insecure_random_seed,
+            wall_clock: wall_clock(),
+            monotonic_clock: monotonic_clock(),
+            allowed_network_uses: AllowedNetworkUses::default(),
+            built: false,
+        }
+    }
+
+    pub fn stdin(&mut self, stdin: impl StdinStream + 'static) -> &mut Self {
+        self.stdin = Box::new(stdin);
+        self
+    }
+
+    pub fn stdout(&mut self, stdout: impl StdoutStream + 'static) -> &mut Self {
+        self.stdout = Box::new(stdout);
+        self
+    }
+
+    pub fn stderr(&mut self, stderr: impl StdoutStream + 'static) -> &mut Self {
+        self.stderr = Box::new(stderr);
+        self
+    }
+
+    pub fn inherit_stdin(&mut self) -> &mut Self {
+        self.stdin(stdio::stdin())
+    }
+
+    pub fn inherit_stdout(&mut self) -> &mut Self {
+        self.stdout(stdio::stdout())
+    }
+
+    pub fn inherit_stderr(&mut self) -> &mut Self {
+        self.stderr(stdio::stderr())
+    }
+
+    pub fn inherit_stdio(&mut self) -> &mut Self {
+        self.inherit_stdin().inherit_stdout().inherit_stderr()
+    }
+
+    pub fn envs(&mut self, env: &[(impl AsRef<str>, impl AsRef<str>)]) -> &mut Self {
+        self.env.extend(
+            env.iter()
+                .map(|(k, v)| (k.as_ref().to_owned(), v.as_ref().to_owned())),
+        );
+        self
+    }
+
+    pub fn env(&mut self, k: impl AsRef<str>, v: impl AsRef<str>) -> &mut Self {
+        self.env
+            .push((k.as_ref().to_owned(), v.as_ref().to_owned()));
+        self
+    }
+
+    pub fn args(&mut self, args: &[impl AsRef<str>]) -> &mut Self {
+        self.args.extend(args.iter().map(|a| a.as_ref().to_owned()));
+        self
+    }
+
+    pub fn arg(&mut self, arg: impl AsRef<str>) -> &mut Self {
+        self.args.push(arg.as_ref().to_owned());
+        self
+    }
+
+    pub fn preopened_dir(
+        &mut self,
+        dir: cap_std::fs::Dir,
+        perms: DirPerms,
+        file_perms: FilePerms,
+        path: impl AsRef<str>,
+    ) -> &mut Self {
+        self.preopens
+            .push((Dir::new(dir, perms, file_perms), path.as_ref().to_owned()));
+        self
+    }
+
+    /// Set the generator for the secure random number generator to the custom
+    /// generator specified.
+    ///
+    /// Note that contexts have a default RNG configured which is a suitable
+    /// generator for WASI and is configured with a random seed per-context.
+    ///
+    /// Guest code may rely on this random number generator to produce fresh
+    /// unpredictable random data in order to maintain its security invariants,
+    /// and ideally should use the insecure random API otherwise, so using any
+    /// prerecorded or otherwise predictable data may compromise security.
+    pub fn secure_random(&mut self, random: impl RngCore + Send + Sync + 'static) -> &mut Self {
+        self.random = Box::new(random);
+        self
+    }
+
+    pub fn insecure_random(
+        &mut self,
+        insecure_random: impl RngCore + Send + Sync + 'static,
+    ) -> &mut Self {
+        self.insecure_random = Box::new(insecure_random);
+        self
+    }
+
+    pub fn insecure_random_seed(&mut self, insecure_random_seed: u128) -> &mut Self {
+        self.insecure_random_seed = insecure_random_seed;
+        self
+    }
+
+    pub fn wall_clock(&mut self, clock: impl HostWallClock + 'static) -> &mut Self {
+        self.wall_clock = Box::new(clock);
+        self
+    }
+
+    pub fn monotonic_clock(&mut self, clock: impl HostMonotonicClock + 'static) -> &mut Self {
+        self.monotonic_clock = Box::new(clock);
+        self
+    }
+
+    /// Allow all network addresses accessible to the host
+    pub fn inherit_network(&mut self) -> &mut Self {
+        self.socket_addr_check(|_, _| true)
+    }
+
+    /// A check that will be called for each socket address that is used.
+    ///
+    /// Returning `true` will permit socket connections to the `SocketAddr`,
+    /// while returning `false` will reject the connection.
+    pub fn socket_addr_check<F>(&mut self, check: F) -> &mut Self
+    where
+        F: Fn(&SocketAddr, SocketAddrUse) -> bool + Send + Sync + 'static,
+    {
+        self.socket_addr_check = SocketAddrCheck(Arc::new(check));
+        self
+    }
+
+    /// Allow usage of `wasi:sockets/ip-name-lookup`
+    pub fn allow_ip_name_lookup(&mut self, enable: bool) -> &mut Self {
+        self.allowed_network_uses.ip_name_lookup = enable;
+        self
+    }
+
+    /// Allow usage of UDP
+    pub fn allow_udp(&mut self, enable: bool) -> &mut Self {
+        self.allowed_network_uses.udp = enable;
+        self
+    }
+
+    /// Allow usage of TCP
+    pub fn allow_tcp(&mut self, enable: bool) -> &mut Self {
+        self.allowed_network_uses.tcp = enable;
+        self
+    }
+
+    /// Uses the configured context so far to construct the final `WasiCtx`.
+    ///
+    /// Note that each `WasiCtxBuilder` can only be used to "build" once, and
+    /// calling this method twice will panic.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this method is called twice.
+    pub fn build(&mut self) -> WasiCtx {
+        assert!(!self.built);
+
+        let Self {
+            stdin,
+            stdout,
+            stderr,
+            env,
+            args,
+            preopens,
+            socket_addr_check,
+            random,
+            insecure_random,
+            insecure_random_seed,
+            wall_clock,
+            monotonic_clock,
+            allowed_network_uses,
+            built: _,
+        } = mem::replace(self, Self::new());
+        self.built = true;
+
+        WasiCtx {
+            stdin,
+            stdout,
+            stderr,
+            env,
+            args,
+            preopens,
+            socket_addr_check,
+            random,
+            insecure_random,
+            insecure_random_seed,
+            wall_clock,
+            monotonic_clock,
+            allowed_network_uses,
+        }
+    }
+}
+
+pub trait WasiView: Send {
+    fn table(&self) -> &ResourceTable;
+    fn table_mut(&mut self) -> &mut ResourceTable;
+    fn ctx(&self) -> &WasiCtx;
+    fn ctx_mut(&mut self) -> &mut WasiCtx;
+}
+
+pub struct WasiCtx {
+    pub(crate) random: Box<dyn RngCore + Send + Sync>,
+    pub(crate) insecure_random: Box<dyn RngCore + Send + Sync>,
+    pub(crate) insecure_random_seed: u128,
+    pub(crate) wall_clock: Box<dyn HostWallClock + Send + Sync>,
+    pub(crate) monotonic_clock: Box<dyn HostMonotonicClock + Send + Sync>,
+    pub(crate) env: Vec<(String, String)>,
+    pub(crate) args: Vec<String>,
+    pub(crate) preopens: Vec<(Dir, String)>,
+    pub(crate) stdin: Box<dyn StdinStream>,
+    pub(crate) stdout: Box<dyn StdoutStream>,
+    pub(crate) stderr: Box<dyn StdoutStream>,
+    pub(crate) socket_addr_check: SocketAddrCheck,
+    pub(crate) allowed_network_uses: AllowedNetworkUses,
+}
+
+pub struct AllowedNetworkUses {
+    pub ip_name_lookup: bool,
+    pub udp: bool,
+    pub tcp: bool,
+}
+
+impl Default for AllowedNetworkUses {
+    fn default() -> Self {
+        Self {
+            ip_name_lookup: false,
+            udp: true,
+            tcp: true,
+        }
+    }
+}
+
+impl AllowedNetworkUses {
+    pub(crate) fn check_allowed_udp(&self) -> std::io::Result<()> {
+        if !self.udp {
+            return Err(std::io::Error::new(
+                std::io::ErrorKind::PermissionDenied,
+                "UDP is not allowed",
+            ));
+        }
+
+        Ok(())
+    }
+
+    pub(crate) fn check_allowed_tcp(&self) -> std::io::Result<()> {
+        if !self.tcp {
+            return Err(std::io::Error::new(
+                std::io::ErrorKind::PermissionDenied,
+                "TCP is not allowed",
+            ));
+        }
+
+        Ok(())
+    }
+}

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

@@ -0,0 +1,325 @@
+use crate::preview2::bindings::filesystem::types;
+use crate::preview2::{
+    spawn_blocking, AbortOnDropJoinHandle, HostOutputStream, StreamError, Subscribe, TrappableError,
+};
+use anyhow::anyhow;
+use bytes::{Bytes, BytesMut};
+use std::io;
+use std::mem;
+use std::sync::Arc;
+
+pub type FsResult<T> = Result<T, FsError>;
+
+pub type FsError = TrappableError<types::ErrorCode>;
+
+impl From<wasmtime::component::ResourceTableError> for FsError {
+    fn from(error: wasmtime::component::ResourceTableError) -> Self {
+        Self::trap(error)
+    }
+}
+
+impl From<io::Error> for FsError {
+    fn from(error: io::Error) -> Self {
+        types::ErrorCode::from(error).into()
+    }
+}
+
+pub enum Descriptor {
+    File(File),
+    Dir(Dir),
+}
+
+impl Descriptor {
+    pub fn file(&self) -> Result<&File, types::ErrorCode> {
+        match self {
+            Descriptor::File(f) => Ok(f),
+            Descriptor::Dir(_) => Err(types::ErrorCode::BadDescriptor),
+        }
+    }
+
+    pub fn dir(&self) -> Result<&Dir, types::ErrorCode> {
+        match self {
+            Descriptor::Dir(d) => Ok(d),
+            Descriptor::File(_) => Err(types::ErrorCode::NotDirectory),
+        }
+    }
+
+    pub fn is_file(&self) -> bool {
+        match self {
+            Descriptor::File(_) => true,
+            Descriptor::Dir(_) => false,
+        }
+    }
+
+    pub fn is_dir(&self) -> bool {
+        match self {
+            Descriptor::File(_) => false,
+            Descriptor::Dir(_) => true,
+        }
+    }
+}
+
+bitflags::bitflags! {
+    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
+    pub struct FilePerms: usize {
+        const READ = 0b1;
+        const WRITE = 0b10;
+    }
+}
+
+pub struct File {
+    /// Wrapped in an Arc because the same underlying file is used for
+    /// implementing the stream types. Also needed for [`spawn_blocking`].
+    ///
+    /// [`spawn_blocking`]: Self::spawn_blocking
+    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,
+        }
+    }
+
+    /// Spawn a task on tokio's blocking thread for performing blocking
+    /// syscalls on the underlying [`cap_std::fs::File`].
+    pub(crate) async fn spawn_blocking<F, R>(&self, body: F) -> R
+    where
+        F: FnOnce(&cap_std::fs::File) -> R + Send + 'static,
+        R: Send + 'static,
+    {
+        let f = self.file.clone();
+        spawn_blocking(move || body(&f)).await
+    }
+}
+
+bitflags::bitflags! {
+    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
+    pub struct DirPerms: usize {
+        const READ = 0b1;
+        const MUTATE = 0b10;
+    }
+}
+
+#[derive(Clone)]
+pub struct Dir {
+    pub dir: Arc<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: Arc::new(dir),
+            perms,
+            file_perms,
+        }
+    }
+
+    /// Spawn a task on tokio's blocking thread for performing blocking
+    /// syscalls on the underlying [`cap_std::fs::Dir`].
+    pub(crate) async fn spawn_blocking<F, R>(&self, body: F) -> R
+    where
+        F: FnOnce(&cap_std::fs::Dir) -> R + Send + 'static,
+        R: Send + 'static,
+    {
+        let d = self.dir.clone();
+        spawn_blocking(move || body(&d)).await
+    }
+}
+
+pub 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 }
+    }
+
+    pub async fn read(&mut self, size: usize) -> Result<Bytes, StreamError> {
+        use system_interface::fs::FileIoExt;
+        let f = Arc::clone(&self.file);
+        let p = self.position;
+        let (r, mut buf) = spawn_blocking(move || {
+            let mut buf = BytesMut::zeroed(size);
+            let r = f.read_at(&mut buf, p);
+            (r, buf)
+        })
+        .await;
+        let n = read_result(r)?;
+        buf.truncate(n);
+        self.position += n as u64;
+        Ok(buf.freeze())
+    }
+
+    pub async fn skip(&mut self, nelem: usize) -> Result<usize, StreamError> {
+        let bs = self.read(nelem).await?;
+        Ok(bs.len())
+    }
+}
+
+fn read_result(r: io::Result<usize>) -> Result<usize, StreamError> {
+    match r {
+        Ok(0) => Err(StreamError::Closed),
+        Ok(n) => Ok(n),
+        Err(e) if e.kind() == std::io::ErrorKind::Interrupted => Ok(0),
+        Err(e) => Err(StreamError::LastOperationFailed(e.into())),
+    }
+}
+
+#[derive(Clone, Copy)]
+pub(crate) enum FileOutputMode {
+    Position(u64),
+    Append,
+}
+
+pub(crate) struct FileOutputStream {
+    file: Arc<cap_std::fs::File>,
+    mode: FileOutputMode,
+    state: OutputState,
+}
+
+enum OutputState {
+    Ready,
+    /// Allows join future to be awaited in a cancellable manner. Gone variant indicates
+    /// no task is currently outstanding.
+    Waiting(AbortOnDropJoinHandle<io::Result<usize>>),
+    /// The last I/O operation failed with this error.
+    Error(io::Error),
+    Closed,
+}
+
+impl FileOutputStream {
+    pub fn write_at(file: Arc<cap_std::fs::File>, position: u64) -> Self {
+        Self {
+            file,
+            mode: FileOutputMode::Position(position),
+            state: OutputState::Ready,
+        }
+    }
+    pub fn append(file: Arc<cap_std::fs::File>) -> Self {
+        Self {
+            file,
+            mode: FileOutputMode::Append,
+            state: OutputState::Ready,
+        }
+    }
+}
+
+// FIXME: configurable? determine from how much space left in file?
+const FILE_WRITE_CAPACITY: usize = 1024 * 1024;
+
+impl HostOutputStream for FileOutputStream {
+    fn write(&mut self, buf: Bytes) -> Result<(), StreamError> {
+        use system_interface::fs::FileIoExt;
+        match self.state {
+            OutputState::Ready => {}
+            OutputState::Closed => return Err(StreamError::Closed),
+            OutputState::Waiting(_) | OutputState::Error(_) => {
+                // a write is pending - this call was not permitted
+                return Err(StreamError::Trap(anyhow!(
+                    "write not permitted: check_write not called first"
+                )));
+            }
+        }
+
+        let f = Arc::clone(&self.file);
+        let m = self.mode;
+        let task = spawn_blocking(move || match m {
+            FileOutputMode::Position(mut p) => {
+                let mut total = 0;
+                let mut buf = buf;
+                while !buf.is_empty() {
+                    let nwritten = f.write_at(buf.as_ref(), p)?;
+                    // afterwards buf contains [nwritten, len):
+                    let _ = buf.split_to(nwritten);
+                    p += nwritten as u64;
+                    total += nwritten;
+                }
+                Ok(total)
+            }
+            FileOutputMode::Append => {
+                let mut total = 0;
+                let mut buf = buf;
+                while !buf.is_empty() {
+                    let nwritten = f.append(buf.as_ref())?;
+                    let _ = buf.split_to(nwritten);
+                    total += nwritten;
+                }
+                Ok(total)
+            }
+        });
+        self.state = OutputState::Waiting(task);
+        Ok(())
+    }
+    fn flush(&mut self) -> Result<(), StreamError> {
+        match self.state {
+            // Only userland buffering of file writes is in the blocking task,
+            // so there's nothing extra that needs to be done to request a
+            // flush.
+            OutputState::Ready | OutputState::Waiting(_) => Ok(()),
+            OutputState::Closed => Err(StreamError::Closed),
+            OutputState::Error(_) => match mem::replace(&mut self.state, OutputState::Closed) {
+                OutputState::Error(e) => Err(StreamError::LastOperationFailed(e.into())),
+                _ => unreachable!(),
+            },
+        }
+    }
+    fn check_write(&mut self) -> Result<usize, StreamError> {
+        match self.state {
+            OutputState::Ready => Ok(FILE_WRITE_CAPACITY),
+            OutputState::Closed => Err(StreamError::Closed),
+            OutputState::Error(_) => match mem::replace(&mut self.state, OutputState::Closed) {
+                OutputState::Error(e) => Err(StreamError::LastOperationFailed(e.into())),
+                _ => unreachable!(),
+            },
+            OutputState::Waiting(_) => Ok(0),
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl Subscribe for FileOutputStream {
+    async fn ready(&mut self) {
+        if let OutputState::Waiting(task) = &mut self.state {
+            self.state = match task.await {
+                Ok(nwritten) => {
+                    if let FileOutputMode::Position(ref mut p) = &mut self.mode {
+                        *p += nwritten as u64;
+                    }
+                    OutputState::Ready
+                }
+                Err(e) => OutputState::Error(e),
+            };
+        }
+    }
+}
+
+pub struct ReaddirIterator(
+    std::sync::Mutex<Box<dyn Iterator<Item = FsResult<types::DirectoryEntry>> + Send + 'static>>,
+);
+
+impl ReaddirIterator {
+    pub(crate) fn new(
+        i: impl Iterator<Item = FsResult<types::DirectoryEntry>> + Send + 'static,
+    ) -> Self {
+        ReaddirIterator(std::sync::Mutex::new(Box::new(i)))
+    }
+    pub(crate) fn next(&self) -> FsResult<Option<types::DirectoryEntry>> {
+        self.0.lock().unwrap().next().transpose()
+    }
+}
+
+impl IntoIterator for ReaddirIterator {
+    type Item = FsResult<types::DirectoryEntry>;
+    type IntoIter = Box<dyn Iterator<Item = Self::Item> + Send>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.into_inner().unwrap()
+    }
+}