wasmtime 12.0.1 → 13.0.0

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

@@ -0,0 +1,351 @@
+use super::clocks::host::{monotonic_clock, wall_clock};
+use crate::preview2::{
+    clocks::{self, HostMonotonicClock, HostWallClock},
+    filesystem::{Dir, TableFsExt},
+    pipe, random, stdio,
+    stdio::{StdioInput, StdioOutput},
+    stream::{HostInputStream, HostOutputStream, TableStreamExt},
+    DirPerms, FilePerms, IsATTY, Table,
+};
+use cap_rand::{Rng, RngCore, SeedableRng};
+use cap_std::ipnet::{self, IpNet};
+use cap_std::net::Pool;
+use cap_std::{ambient_authority, AmbientAuthority};
+use std::mem;
+use std::net::{Ipv4Addr, Ipv6Addr};
+
+pub struct WasiCtxBuilder {
+    stdin: (Box<dyn HostInputStream>, IsATTY),
+    stdout: (Box<dyn HostOutputStream>, IsATTY),
+    stderr: (Box<dyn HostOutputStream>, IsATTY),
+    env: Vec<(String, String)>,
+    args: Vec<String>,
+    preopens: Vec<(Dir, String)>,
+
+    pool: Pool,
+    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>,
+    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_entropy());
+
+        // 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), IsATTY::No),
+            stdout: (Box::new(pipe::SinkOutputStream), IsATTY::No),
+            stderr: (Box::new(pipe::SinkOutputStream), IsATTY::No),
+            env: Vec::new(),
+            args: Vec::new(),
+            preopens: Vec::new(),
+            pool: Pool::new(),
+            random: random::thread_rng(),
+            insecure_random,
+            insecure_random_seed,
+            wall_clock: wall_clock(),
+            monotonic_clock: monotonic_clock(),
+            built: false,
+        }
+    }
+
+    pub fn stdin(&mut self, stdin: impl HostInputStream + 'static, isatty: IsATTY) -> &mut Self {
+        self.stdin = (Box::new(stdin), isatty);
+        self
+    }
+
+    pub fn stdout(&mut self, stdout: impl HostOutputStream + 'static, isatty: IsATTY) -> &mut Self {
+        self.stdout = (Box::new(stdout), isatty);
+        self
+    }
+
+    pub fn stderr(&mut self, stderr: impl HostOutputStream + 'static, isatty: IsATTY) -> &mut Self {
+        self.stderr = (Box::new(stderr), isatty);
+        self
+    }
+
+    pub fn inherit_stdin(&mut self) -> &mut Self {
+        use is_terminal::IsTerminal;
+        let inherited = stdio::stdin();
+        let isatty = if inherited.is_terminal() {
+            IsATTY::Yes
+        } else {
+            IsATTY::No
+        };
+        self.stdin(inherited, isatty)
+    }
+
+    pub fn inherit_stdout(&mut self) -> &mut Self {
+        use is_terminal::IsTerminal;
+        let inherited = stdio::stdout();
+        let isatty = if inherited.is_terminal() {
+            IsATTY::Yes
+        } else {
+            IsATTY::No
+        };
+        self.stdout(inherited, isatty)
+    }
+
+    pub fn inherit_stderr(&mut self) -> &mut Self {
+        use is_terminal::IsTerminal;
+        let inherited = stdio::stderr();
+        let isatty = if inherited.is_terminal() {
+            IsATTY::Yes
+        } else {
+            IsATTY::No
+        };
+        self.stderr(inherited, isatty)
+    }
+
+    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 clocks::HostWallClock + 'static) -> &mut Self {
+        self.wall_clock = Box::new(clock);
+        self
+    }
+
+    pub fn monotonic_clock(
+        &mut self,
+        clock: impl clocks::HostMonotonicClock + 'static,
+    ) -> &mut Self {
+        self.monotonic_clock = Box::new(clock);
+        self
+    }
+
+    /// Add all network addresses accessable to the host to the pool.
+    pub fn inherit_network(&mut self, ambient_authority: AmbientAuthority) -> &mut Self {
+        self.pool.insert_ip_net_port_any(
+            IpNet::new(Ipv4Addr::UNSPECIFIED.into(), 0).unwrap(),
+            ambient_authority,
+        );
+        self.pool.insert_ip_net_port_any(
+            IpNet::new(Ipv6Addr::UNSPECIFIED.into(), 0).unwrap(),
+            ambient_authority,
+        );
+        self
+    }
+
+    /// Add network addresses to the pool.
+    pub fn insert_addr<A: cap_std::net::ToSocketAddrs>(&mut self, addrs: A) -> std::io::Result<()> {
+        self.pool.insert(addrs, ambient_authority())
+    }
+
+    /// Add a specific [`cap_std::net::SocketAddr`] to the pool.
+    pub fn insert_socket_addr(&mut self, addr: cap_std::net::SocketAddr) {
+        self.pool.insert_socket_addr(addr, ambient_authority());
+    }
+
+    /// Add a range of network addresses, accepting any port, to the pool.
+    ///
+    /// Unlike `insert_ip_net`, this function grants access to any requested port.
+    pub fn insert_ip_net_port_any(&mut self, ip_net: ipnet::IpNet) {
+        self.pool
+            .insert_ip_net_port_any(ip_net, ambient_authority())
+    }
+
+    /// Add a range of network addresses, accepting a range of ports, to
+    /// per-instance networks.
+    ///
+    /// This grants access to the port range starting at `ports_start` and, if
+    /// `ports_end` is provided, ending before `ports_end`.
+    pub fn insert_ip_net_port_range(
+        &mut self,
+        ip_net: ipnet::IpNet,
+        ports_start: u16,
+        ports_end: Option<u16>,
+    ) {
+        self.pool
+            .insert_ip_net_port_range(ip_net, ports_start, ports_end, ambient_authority())
+    }
+
+    /// Add a range of network addresses with a specific port to the pool.
+    pub fn insert_ip_net(&mut self, ip_net: ipnet::IpNet, port: u16) {
+        self.pool.insert_ip_net(ip_net, port, ambient_authority())
+    }
+
+    /// Uses the configured context so far to construct the final `WasiCtx`.
+    ///
+    /// This will insert resources into the provided `table`.
+    ///
+    /// 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, table: &mut Table) -> Result<WasiCtx, anyhow::Error> {
+        assert!(!self.built);
+
+        use anyhow::Context;
+        let Self {
+            stdin,
+            stdout,
+            stderr,
+            env,
+            args,
+            preopens,
+            pool,
+            random,
+            insecure_random,
+            insecure_random_seed,
+            wall_clock,
+            monotonic_clock,
+            built: _,
+        } = mem::replace(self, Self::new());
+        self.built = true;
+
+        let stdin_ix = table.push_input_stream(stdin.0).context("stdin")?;
+        let stdout_ix = table.push_output_stream(stdout.0).context("stdout")?;
+        let stderr_ix = table.push_output_stream(stderr.0).context("stderr")?;
+
+        let preopens = preopens
+            .into_iter()
+            .map(|(dir, path)| {
+                let dirfd = table
+                    .push_dir(dir)
+                    .with_context(|| format!("preopen {path:?}"))?;
+                Ok((dirfd, path))
+            })
+            .collect::<anyhow::Result<Vec<_>>>()?;
+
+        Ok(WasiCtx {
+            stdin: StdioInput {
+                input_stream: stdin_ix,
+                isatty: stdin.1,
+            },
+            stdout: StdioOutput {
+                output_stream: stdout_ix,
+                isatty: stdout.1,
+            },
+            stderr: StdioOutput {
+                output_stream: stderr_ix,
+                isatty: stderr.1,
+            },
+            env,
+            args,
+            preopens,
+            pool,
+            random,
+            insecure_random,
+            insecure_random_seed,
+            wall_clock,
+            monotonic_clock,
+        })
+    }
+}
+
+pub trait WasiView: Send {
+    fn table(&self) -> &Table;
+    fn table_mut(&mut self) -> &mut Table;
+    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<(u32, String)>,
+    pub(crate) stdin: StdioInput,
+    pub(crate) stdout: StdioOutput,
+    pub(crate) stderr: StdioOutput,
+    pub(crate) pool: Pool,
+}

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

@@ -0,0 +1,277 @@
+use crate::preview2::{
+    AbortOnDropJoinHandle, HostOutputStream, OutputStreamError, StreamRuntimeError, StreamState,
+    Table, TableError,
+};
+use anyhow::anyhow;
+use bytes::{Bytes, BytesMut};
+use futures::future::{maybe_done, MaybeDone};
+use std::sync::Arc;
+
+bitflags::bitflags! {
+    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
+    pub struct FilePerms: usize {
+        const READ = 0b1;
+        const WRITE = 0b10;
+    }
+}
+
+pub(crate) 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();
+        tokio::task::spawn_blocking(move || body(&f)).await.unwrap()
+    }
+}
+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! {
+    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
+    pub struct DirPerms: usize {
+        const READ = 0b1;
+        const MUTATE = 0b10;
+    }
+}
+
+pub(crate) 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();
+        tokio::task::spawn_blocking(move || body(&d)).await.unwrap()
+    }
+}
+
+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 }
+    }
+
+    pub async fn read(&mut self, size: usize) -> anyhow::Result<(Bytes, StreamState)> {
+        use system_interface::fs::FileIoExt;
+        let f = Arc::clone(&self.file);
+        let p = self.position;
+        let (r, mut buf) = tokio::task::spawn_blocking(move || {
+            let mut buf = BytesMut::zeroed(size);
+            let r = f.read_at(&mut buf, p);
+            (r, buf)
+        })
+        .await
+        .unwrap();
+        let (n, state) = read_result(r)?;
+        buf.truncate(n);
+        self.position += n as u64;
+        Ok((buf.freeze(), state))
+    }
+
+    pub async fn skip(&mut self, nelem: usize) -> anyhow::Result<(usize, StreamState)> {
+        let mut nread = 0;
+        let mut state = StreamState::Open;
+
+        let (bs, read_state) = self.read(nelem).await?;
+        // TODO: handle the case where `bs.len()` is less than `nelem`
+        nread += bs.len();
+        if read_state.is_closed() {
+            state = read_state;
+        }
+
+        Ok((nread, state))
+    }
+}
+
+fn read_result(r: Result<usize, std::io::Error>) -> Result<(usize, StreamState), anyhow::Error> {
+    match r {
+        Ok(0) => Ok((0, StreamState::Closed)),
+        Ok(n) => Ok((n, StreamState::Open)),
+        Err(e) if e.kind() == std::io::ErrorKind::Interrupted => Ok((0, StreamState::Open)),
+        Err(e) => Err(StreamRuntimeError::from(anyhow!(e)).into()),
+    }
+}
+
+#[derive(Clone, Copy)]
+pub(crate) enum FileOutputMode {
+    Position(u64),
+    Append,
+}
+
+pub(crate) struct FileOutputStream {
+    file: Arc<cap_std::fs::File>,
+    mode: FileOutputMode,
+    // Allows join future to be awaited in a cancellable manner. Gone variant indicates
+    // no task is currently outstanding.
+    task: MaybeDone<AbortOnDropJoinHandle<Result<(), std::io::Error>>>,
+    closed: bool,
+}
+impl FileOutputStream {
+    pub fn write_at(file: Arc<cap_std::fs::File>, position: u64) -> Self {
+        Self {
+            file,
+            mode: FileOutputMode::Position(position),
+            task: MaybeDone::Gone,
+            closed: false,
+        }
+    }
+    pub fn append(file: Arc<cap_std::fs::File>) -> Self {
+        Self {
+            file,
+            mode: FileOutputMode::Append,
+            task: MaybeDone::Gone,
+            closed: false,
+        }
+    }
+}
+
+// FIXME: configurable? determine from how much space left in file?
+const FILE_WRITE_CAPACITY: usize = 1024 * 1024;
+
+#[async_trait::async_trait]
+impl HostOutputStream for FileOutputStream {
+    fn write(&mut self, buf: Bytes) -> Result<(), OutputStreamError> {
+        use system_interface::fs::FileIoExt;
+
+        if self.closed {
+            return Err(OutputStreamError::Closed);
+        }
+        if !matches!(self.task, MaybeDone::Gone) {
+            // a write is pending - this call was not permitted
+            return Err(OutputStreamError::Trap(anyhow!(
+                "write not permitted: FileOutputStream write pending"
+            )));
+        }
+        let f = Arc::clone(&self.file);
+        let m = self.mode;
+        self.task = maybe_done(AbortOnDropJoinHandle::from(tokio::task::spawn_blocking(
+            move || match m {
+                FileOutputMode::Position(mut p) => {
+                    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;
+                    }
+                    Ok(())
+                }
+                FileOutputMode::Append => {
+                    let mut buf = buf;
+                    while !buf.is_empty() {
+                        let nwritten = f.append(buf.as_ref())?;
+                        let _ = buf.split_to(nwritten);
+                    }
+                    Ok(())
+                }
+            },
+        )));
+        Ok(())
+    }
+    fn flush(&mut self) -> Result<(), OutputStreamError> {
+        if self.closed {
+            return Err(OutputStreamError::Closed);
+        }
+        // Only userland buffering of file writes is in the blocking task.
+        Ok(())
+    }
+    async fn write_ready(&mut self) -> Result<usize, OutputStreamError> {
+        if self.closed {
+            return Err(OutputStreamError::Closed);
+        }
+        // If there is no outstanding task, accept more input:
+        if matches!(self.task, MaybeDone::Gone) {
+            return Ok(FILE_WRITE_CAPACITY);
+        }
+        // Wait for outstanding task:
+        std::pin::Pin::new(&mut self.task).await;
+
+        // Mark task as finished, and handle output:
+        match std::pin::Pin::new(&mut self.task)
+            .take_output()
+            .expect("just awaited for MaybeDone completion")
+        {
+            Ok(()) => Ok(FILE_WRITE_CAPACITY),
+            Err(e) => {
+                self.closed = true;
+                Err(OutputStreamError::LastOperationFailed(e.into()))
+            }
+        }
+    }
+}