A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
feat(p3): implement wasi:tls (#12834)
Dave Bakker694e553be30c
diff --git a/.github/workflows/main.yml b/.github/workflows/main.ymlindex 2703041bff..fee22950f5 100644--- a/.github/workflows/main.yml+++ b/.github/workflows/main.yml@@ -429,6 +429,8 @@ jobs:- name: wasmtime-wasi-tlschecks: |-p wasmtime-wasi-tls --no-default-features+ -p wasmtime-wasi-tls --no-default-features --features p2+ -p wasmtime-wasi-tls --no-default-features --features p3-p wasmtime-wasi-tls --no-default-features --features rustls-p wasmtime-wasi-tls --no-default-features --features nativetls-p wasmtime-wasi-tls --no-default-features --features openssldiff --git a/Cargo.lock b/Cargo.lockindex 00443db0ae..168a83dc72 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -5301,6 +5301,7 @@ dependencies = ["tokio-native-tls","tokio-openssl","tokio-rustls",+ "tracing","wasmtime","wasmtime-wasi","webpki-roots",diff --git a/Cargo.toml b/Cargo.tomlindex 62912c3fac..771adfe303 100644--- a/Cargo.toml+++ b/Cargo.toml@@ -528,6 +528,7 @@ component-model-async = ["component-model","wasmtime-wasi?/p3","wasmtime-wasi-http?/p3",+ "wasmtime-wasi-tls?/p3","dep:futures",]rr = ["wasmtime/rr", "component-model", "wasmtime-cli-flags/rr", "run"]diff --git a/ci/vendor-wit.sh b/ci/vendor-wit.shindex 2904bd3ae9..5880d81ed2 100755--- a/ci/vendor-wit.sh+++ b/ci/vendor-wit.sh@@ -10,27 +10,29 @@ set -excache_dir=$(mktemp -d)trap "rm -rf $cache_dir" EXIT-# Helper to download the `WebAssembly/$repo` dir at the `$tag` (or rev)-# specified. The `wit/*.wit` files are placed in `$path`.+# Helper to download content from `WebAssembly/$repo` at the `$tag` (or rev)+# specified. By default `wit/*` is copied into `$path`, or a different+# subdirectory can be specified with the optional fourth argument.get_github() {local repo=$1local tag=$2local path=$3+ local prefix=${4:-wit}rm -rf "$path"mkdir -p "$path"- cached_extracted_dir="$cache_dir/$repo-$tag"+ cached_extracted_dir="$cache_dir/$prefix/$repo-$tag"if [[ ! -d $cached_extracted_dir ]]; thenmkdir -p $cached_extracted_dircurl --retry 5 --retry-all-errors -sLO https://github.com/WebAssembly/$repo/archive/$tag.tar.gztar xzf $tag.tar.gz --strip-components=1 -C $cached_extracted_dirrm $tag.tar.gz- rm -rf $cached_extracted_dir/wit/deps*+ rm -rf $cached_extracted_dir/${prefix}/deps*fi- cp -r $cached_extracted_dir/wit/* $path+ cp -r $cached_extracted_dir/${prefix}/* $path}p2=0.2.6@@ -65,6 +67,10 @@ mkdir -p crates/wasi-tls/wit/depswkg get --format wit --overwrite "wasi:io@$p2" -o "crates/wasi-tls/wit/deps/io.wit"get_github wasi-tls v0.2.0-draft+505fc98 crates/wasi-tls/wit/deps/tls+rm -rf crates/wasi-tls/src/p3/wit/deps+mkdir -p crates/wasi-tls/src/p3/wit/deps+get_github wasi-tls 6781ae2 crates/wasi-tls/src/p3/wit/deps/tls wit-0.3.0-draft+rm -rf crates/wasi-config/wit/depsmkdir -p crates/wasi-config/wit/depsget_github wasi-config v0.2.0-rc.1 crates/wasi-config/wit/deps/configdiff --git a/crates/test-programs/artifacts/build.rs b/crates/test-programs/artifacts/build.rsindex 294b123230..cb9467aa88 100644--- a/crates/test-programs/artifacts/build.rs+++ b/crates/test-programs/artifacts/build.rs@@ -87,9 +87,11 @@ impl Artifacts {s if s.starts_with("p1_") => "p1",s if s.starts_with("p2_http_") => "p2_http",s if s.starts_with("p2_api_") => "p2_api",+ s if s.starts_with("p2_tls_") => "p2_tls",s if s.starts_with("p2_") => "p2",s if s.starts_with("p3_http_") => "p3_http",s if s.starts_with("p3_api_") => "p3_api",+ s if s.starts_with("p3_tls_") => "p3_tls",s if s.starts_with("p3_") => "p3",s if s.starts_with("nn_") => "nn",s if s.starts_with("piped_") => "piped",@@ -98,7 +100,6 @@ impl Artifacts {s if s.starts_with("dwarf_") => "dwarf",s if s.starts_with("config_") => "config",s if s.starts_with("keyvalue_") => "keyvalue",- s if s.starts_with("tls_") => "tls",s if s.starts_with("async_") => "async",s if s.starts_with("fuzz_") => "fuzz",// If you're reading this because you hit this panic, either adddiff --git a/crates/test-programs/src/bin/tls_sample_application.rs b/crates/test-programs/src/bin/p2_tls_sample_application.rssimilarity index 100%rename from crates/test-programs/src/bin/tls_sample_application.rsrename to crates/test-programs/src/bin/p2_tls_sample_application.rsdiff --git a/crates/test-programs/src/bin/p3_tls_sample_application.rs b/crates/test-programs/src/bin/p3_tls_sample_application.rsnew file mode 100644index 0000000000..b5063cb86b--- /dev/null+++ b/crates/test-programs/src/bin/p3_tls_sample_application.rs@@ -0,0 +1,130 @@+use anyhow::{Context as _, Result, anyhow};+use core::future::Future;+use test_programs::p3::wasi::sockets::ip_name_lookup::resolve_addresses;+use test_programs::p3::wasi::sockets::types::{IpAddress, IpSocketAddress, TcpSocket};+use test_programs::p3::wasi::tls::client::Connector;+use test_programs::p3::wit_stream;++struct Component;++test_programs::p3::export!(Component);++const PORT: u16 = 443;++async fn test_tls_sample_application(domain: &str, ip: IpAddress) -> Result<()> {+ let request = format!(+ "GET / HTTP/1.1\r\nHost: {domain}\r\nUser-Agent: wasmtime-wasi-rust\r\nConnection: close\r\n\r\n"+ );++ let sock = TcpSocket::create(ip.family()).unwrap();+ sock.connect(IpSocketAddress::new(ip, PORT))+ .await+ .context("tcp connect failed")?;++ let conn = Connector::new();++ let (sock_rx, sock_rx_fut) = sock.receive();+ let (tls_rx, tls_rx_fut) = conn.receive(sock_rx);++ let (mut data_tx, data_rx) = wit_stream::new();+ let (tls_tx, tls_tx_err_fut) = conn.send(data_rx);+ let sock_tx_fut = sock.send(tls_tx);++ Connector::connect(conn, domain.into())+ .await+ .context("tls handshake failed")?;+ let buf = data_tx.write_all(request.into()).await;+ assert!(buf.is_empty());++ let response = tls_rx.collect().await;+ let response = String::from_utf8(response)?;+ if !response.contains("HTTP/1.1 200 OK") {+ return Err(anyhow!("server did not respond with 200 OK: {response}"));+ }+ drop(data_tx);+ sock_rx_fut.await.context("tcp recv")?;+ sock_tx_fut.await.context("tcp send")?;+ tls_rx_fut.await.context("tls recv")?;+ tls_tx_err_fut.await.context("tls send")?;++ Ok(())+}++/// This test sets up a TCP connection using one domain, and then attempts to+/// perform a TLS handshake using another unrelated domain. This should result+/// in a handshake error.+async fn test_tls_invalid_certificate(_domain: &str, ip: IpAddress) -> Result<()> {+ const BAD_DOMAIN: &str = "wrongdomain.localhost";++ let sock = TcpSocket::create(ip.family()).unwrap();+ sock.connect(IpSocketAddress::new(ip, PORT))+ .await+ .context("tcp connect failed")?;++ let (_, data_rx) = wit_stream::new();+ let conn = Connector::new();++ conn.receive(sock.receive().0);+ sock.send(conn.send(data_rx).0);++ match Connector::connect(conn, BAD_DOMAIN.into()).await {+ Err(e) => {+ let debug_string = e.to_debug_string();+ // We're expecting an error regarding certificates in some form or+ // another. When we add more TLS backends this naive check will+ // likely need to be revisited/expanded:+ if debug_string.contains("certificate") || debug_string.contains("HandshakeFailure") {+ return Ok(());+ }+ Err(anyhow!(debug_string))+ }+ Ok(_) => panic!("expecting server name mismatch"),+ }+}++async fn try_live_endpoints<'a, Fut>(test: impl Fn(&'a str, IpAddress) -> Fut)+where+ Fut: Future<Output = Result<()>> + 'a,+{+ // since this is testing remote endpoints to ensure system cert store works+ // the test uses a couple different endpoints to reduce the number of flakes+ const DOMAINS: &[&str] = &[+ "example.com",+ "api.github.com",+ "docs.wasmtime.dev",+ "bytecodealliance.org",+ "www.rust-lang.org",+ ];++ for &domain in DOMAINS {+ let result = (|| async {+ let ip = resolve_addresses(domain.into())+ .await?+ .first()+ .map(|a| a.to_owned())+ .ok_or_else(|| anyhow!("DNS lookup failed."))?;+ test(domain, ip).await+ })();++ match result.await {+ Ok(()) => return,+ Err(e) => {+ eprintln!("test for {domain} failed: {e:#}");+ }+ }+ }++ panic!("all tests failed");+}++impl test_programs::p3::exports::wasi::cli::run::Guest for Component {+ async fn run() -> Result<(), ()> {+ println!("sample app");+ try_live_endpoints(test_tls_sample_application).await;+ println!("invalid cert");+ try_live_endpoints(test_tls_invalid_certificate).await;+ Ok(())+ }+}++fn main() {}diff --git a/crates/test-programs/src/p3/mod.rs b/crates/test-programs/src/p3/mod.rsindex edb65c425a..9e49bb1c19 100644--- a/crates/test-programs/src/p3/mod.rs+++ b/crates/test-programs/src/p3/mod.rs@@ -7,6 +7,7 @@ wit_bindgen::generate!({world testp3 {include wasi:cli/[email protected];+ include wasi:tls/[email protected];import wasi:http/[email protected];import wasi:http/[email protected];import wasi:http/[email protected];@@ -14,7 +15,10 @@ wit_bindgen::generate!({export wasi:cli/[email protected];}",- path: "../wasi-http/src/p3/wit",+ path: [+ "../wasi-http/src/p3/wit",+ "../wasi-tls/src/p3/wit",+ ],world: "wasmtime:test/testp3",default_bindings_module: "test_programs::p3",pub_export_macro: true,@@ -44,3 +48,11 @@ pub mod service {},});}++impl std::fmt::Display for wasi::tls::types::Error {+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {+ f.write_str(&self.to_debug_string())+ }+}++impl std::error::Error for wasi::tls::types::Error {}diff --git a/crates/wasi-tls/Cargo.toml b/crates/wasi-tls/Cargo.tomlindex bacec6072d..2034e798e0 100644--- a/crates/wasi-tls/Cargo.toml+++ b/crates/wasi-tls/Cargo.toml@@ -12,7 +12,9 @@ description = "Wasmtime implementation of the wasi-tls API"workspace = true[features]-default = ["rustls"]+default = ["p2", "rustls"]+p2 = ["wasmtime-wasi/p2"]+p3 = ["wasmtime-wasi/p3", "wasmtime/component-model-async", "tracing"]rustls = ["dep:rustls", "dep:tokio-rustls", "dep:webpki-roots"]nativetls = ["dep:native-tls", "dep:tokio-native-tls"]openssl = ["dep:openssl", "dep:tokio-openssl"]@@ -27,6 +29,7 @@ tokio = { workspace = true, features = [] }wasmtime = { workspace = true, features = ["runtime", "component-model"] }wasmtime-wasi = { workspace = true }+tracing = { workspace = true, optional = true }cfg-if = { workspace = true }tokio-rustls = { workspace = true, optional = true }rustls = { workspace = true, optional = true }diff --git a/crates/wasi-tls/src/error.rs b/crates/wasi-tls/src/error.rsnew file mode 100644index 0000000000..d37ee22154--- /dev/null+++ b/crates/wasi-tls/src/error.rs@@ -0,0 +1,44 @@+use std::sync::Arc;++/// TLS error+pub struct Error(Arc<String>);++impl Error {+ /// Creates a new error with the given message.+ pub fn msg<M>(message: M) -> Self+ where+ M: ToString,+ {+ Self(Arc::new(message.to_string()))+ }+}+impl Clone for Error {+ fn clone(&self) -> Self {+ Self(Arc::clone(&self.0))+ }+}+impl std::fmt::Debug for Error {+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {+ std::fmt::Debug::fmt(&self.0, f)+ }+}+impl std::fmt::Display for Error {+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {+ std::fmt::Display::fmt(&self.0, f)+ }+}+impl std::error::Error for Error {}+impl From<std::io::Error> for Error {+ fn from(err: std::io::Error) -> Self {+ // Try to recover the original error:+ match err.downcast::<Error>() {+ Ok(e) => e,+ Err(io_err) => Self::msg(io_err),+ }+ }+}+impl From<Error> for std::io::Error {+ fn from(err: Error) -> Self {+ std::io::Error::other(err)+ }+}diff --git a/crates/wasi-tls/src/lib.rs b/crates/wasi-tls/src/lib.rsindex 7c1222b8b6..cb19252e3c 100644--- a/crates/wasi-tls/src/lib.rs+++ b/crates/wasi-tls/src/lib.rs@@ -13,7 +13,8 @@//! component::{Linker, ResourceTable},//! Store, Engine, Result,//! };-//! use wasmtime_wasi_tls::{LinkOptions, WasiTls, WasiTlsCtx, WasiTlsCtxBuilder};+//! use wasmtime_wasi_tls::{WasiTlsCtx, WasiTlsCtxBuilder};+//! use wasmtime_wasi_tls::p2::{LinkOptions, WasiTls};//!//! struct Ctx {//! table: ResourceTable,@@ -54,7 +55,7 @@//! // Add wasi-tls types and turn on the feature in linker//! let mut opts = LinkOptions::default();//! opts.tls(true);-//! wasmtime_wasi_tls::add_to_linker(&mut linker, &mut opts, |h: &mut Ctx| {+//! wasmtime_wasi_tls::p2::add_to_linker(&mut linker, &mut opts, |h: &mut Ctx| {//! WasiTls::new(&h.wasi_tls_ctx, &mut h.table)//! })?;//!@@ -71,50 +72,26 @@#![doc(test(attr(allow(dead_code, unused_variables, unused_mut))))]use tokio::io::{AsyncRead, AsyncWrite};-use wasmtime::component::{HasData, ResourceTable};-pub mod bindings;-mod host;-mod io;+mod error;mod providers;-pub use bindings::types::LinkOptions;-pub use host::{HostClientConnection, HostClientHandshake, HostFutureClientStreams};-pub use providers::*;--/// Capture the state necessary for use in the `wasi-tls` API implementation.-pub struct WasiTls<'a> {- ctx: &'a WasiTlsCtx,- table: &'a mut ResourceTable,-}--impl<'a> WasiTls<'a> {- /// Create a new Wasi TLS context- pub fn new(ctx: &'a WasiTlsCtx, table: &'a mut ResourceTable) -> Self {- Self { ctx, table }- }-}+/// WASIp2 (`wasi:[email protected]`) host implementation.+#[cfg(feature = "p2")]+pub mod p2;+/// WASIp3 (`wasi:[email protected]`) host implementation.+#[cfg(feature = "p3")]+pub mod p3;-/// Add the `wasi-tls` world's types to a [`wasmtime::component::Linker`].-pub fn add_to_linker<T: Send + 'static>(- l: &mut wasmtime::component::Linker<T>,- opts: &mut LinkOptions,- f: fn(&mut T) -> WasiTls<'_>,-) -> wasmtime::Result<()> {- bindings::types::add_to_linker::<_, HasWasiTls>(l, &opts, f)?;- Ok(())-}--struct HasWasiTls;-impl HasData for HasWasiTls {- type Data<'a> = WasiTls<'a>;-}+pub use error::Error;+pub use providers::*;/// Builder-style structure used to create a [`WasiTlsCtx`].+#[cfg(any(feature = "p2", feature = "p3"))]pub struct WasiTlsCtxBuilder {provider: Box<dyn TlsProvider>,}-+#[cfg(any(feature = "p2", feature = "p3"))]impl WasiTlsCtxBuilder {/// Creates a builder for a new context with default parameters set.pub fn new() -> Self {@@ -139,6 +116,7 @@ impl WasiTlsCtxBuilder {}}}+#[cfg(any(feature = "p2", feature = "p3"))]impl Default for WasiTlsCtxBuilder {fn default() -> Self {Self {@@ -148,6 +126,7 @@ impl Default for WasiTlsCtxBuilder {}/// Wasi TLS context needed for internal `wasi-tls` state.+#[cfg(any(feature = "p2", feature = "p3"))]pub struct WasiTlsCtx {pub(crate) provider: Box<dyn TlsProvider>,}@@ -163,11 +142,8 @@ pub trait TlsStream: AsyncRead + AsyncWrite + Send + Unpin + 'static {}/// A TLS implementation.pub trait TlsProvider: Send + Sync + 'static {/// Set up a client TLS connection using the provided `server_name` and `transport`.- fn connect(- &self,- server_name: String,- transport: Box<dyn TlsTransport>,- ) -> BoxFuture<std::io::Result<Box<dyn TlsStream>>>;+ fn connect(&self, server_name: String, transport: Box<dyn TlsTransport>) -> BoxFutureTlsStream;}-pub(crate) type BoxFuture<T> = std::pin::Pin<Box<dyn Future<Output = T> + Send>>;+pub(crate) type BoxFutureTlsStream =+ std::pin::Pin<Box<dyn Future<Output = Result<Box<dyn TlsStream>, Error>> + Send>>;diff --git a/crates/wasi-tls/src/bindings.rs b/crates/wasi-tls/src/p2/bindings.rssimilarity index 61%rename from crates/wasi-tls/src/bindings.rsrename to crates/wasi-tls/src/p2/bindings.rsindex e6de19e967..ce4c0c2cb1 100644--- a/crates/wasi-tls/src/bindings.rs+++ b/crates/wasi-tls/src/p2/bindings.rs@@ -7,9 +7,9 @@ mod generated {world: "wasi:tls/imports",with: {"wasi:io": wasmtime_wasi::p2::bindings::io,- "wasi:tls/types.client-connection": crate::HostClientConnection,- "wasi:tls/types.client-handshake": crate::HostClientHandshake,- "wasi:tls/types.future-client-streams": crate::HostFutureClientStreams,+ "wasi:tls/types.client-connection": crate::p2::HostClientConnection,+ "wasi:tls/types.client-handshake": crate::p2::HostClientHandshake,+ "wasi:tls/types.future-client-streams": crate::p2::HostFutureClientStreams,},imports: { default: trappable },require_store_data_send: true,diff --git a/crates/wasi-tls/src/host.rs b/crates/wasi-tls/src/p2/host.rssimilarity index 96%rename from crates/wasi-tls/src/host.rsrename to crates/wasi-tls/src/p2/host.rsindex 517813ccde..e4aa506414 100644--- a/crates/wasi-tls/src/host.rs+++ b/crates/wasi-tls/src/p2/host.rs@@ -4,13 +4,14 @@ use wasmtime_wasi::async_trait;use wasmtime_wasi::p2::Pollable;use wasmtime_wasi::p2::{DynInputStream, DynOutputStream, DynPollable, IoError};-use crate::{- TlsStream, TlsTransport, WasiTls, bindings,+use crate::p2::{+ WasiTls, bindings,io::{AsyncReadStream, AsyncWriteStream, FutureOutput, WasiFuture, WasiStreamReader,WasiStreamWriter,},};+use crate::{TlsStream, TlsTransport};impl<'a> bindings::types::Host for WasiTls<'a> {}@@ -141,7 +142,7 @@ impl<'a> bindings::types::HostFutureClientStreams for WasiTls<'a> {/// Represents the client connection and used to shut down the tls streampub struct HostClientConnection(- crate::io::AsyncWriteStream<tokio::io::WriteHalf<Box<dyn TlsStream>>>,+ crate::p2::io::AsyncWriteStream<tokio::io::WriteHalf<Box<dyn TlsStream>>>,);impl<'a> bindings::types::HostClientConnection for WasiTls<'a> {diff --git a/crates/wasi-tls/src/io.rs b/crates/wasi-tls/src/p2/io.rssimilarity index 98%rename from crates/wasi-tls/src/io.rsrename to crates/wasi-tls/src/p2/io.rsindex 798b654338..7edbc315cd 100644--- a/crates/wasi-tls/src/io.rs+++ b/crates/wasi-tls/src/p2/io.rs@@ -163,7 +163,10 @@ impl AsyncWrite for WasiStreamWriter {}Ok(count) => {let count = count.min(buf.len());- return match output.write(Bytes::copy_from_slice(&buf[..count])) {+ return match OutputStream::write(+ &mut **output,+ Bytes::copy_from_slice(&buf[..count]),+ ) {Ok(()) => Poll::Ready(Ok(count)),Err(StreamError::Closed) => Poll::Ready(Ok(0)),Err(e) => Poll::Ready(Err(std::io::Error::other(e))),diff --git a/crates/wasi-tls/src/p2/mod.rs b/crates/wasi-tls/src/p2/mod.rsnew file mode 100644index 0000000000..33e22d9d30--- /dev/null+++ b/crates/wasi-tls/src/p2/mod.rs@@ -0,0 +1,38 @@+use wasmtime::component::{HasData, ResourceTable};++use crate::WasiTlsCtx;++pub mod bindings;+mod host;+mod io;++pub use bindings::types::LinkOptions;+pub use host::{HostClientConnection, HostClientHandshake, HostFutureClientStreams};++/// Capture the state necessary for use in the `wasi-tls` API implementation.+pub struct WasiTls<'a> {+ pub(crate) ctx: &'a WasiTlsCtx,+ pub(crate) table: &'a mut ResourceTable,+}++impl<'a> WasiTls<'a> {+ /// Create a new Wasi TLS context.+ pub fn new(ctx: &'a WasiTlsCtx, table: &'a mut ResourceTable) -> Self {+ Self { ctx, table }+ }+}++/// Add the `wasi-tls` world's types to a [`wasmtime::component::Linker`].+pub fn add_to_linker<T: Send + 'static>(+ l: &mut wasmtime::component::Linker<T>,+ opts: &mut LinkOptions,+ f: fn(&mut T) -> WasiTls<'_>,+) -> wasmtime::Result<()> {+ bindings::types::add_to_linker::<_, HasWasiTls>(l, &opts, f)?;+ Ok(())+}++struct HasWasiTls;+impl HasData for HasWasiTls {+ type Data<'a> = WasiTls<'a>;+}diff --git a/crates/wasi-tls/src/p3/bindings.rs b/crates/wasi-tls/src/p3/bindings.rsnew file mode 100644index 0000000000..5f263ea8a2--- /dev/null+++ b/crates/wasi-tls/src/p3/bindings.rs@@ -0,0 +1,21 @@+//! Raw bindings to the `wasi:tls` package.++#[expect(missing_docs, reason = "generated code")]+mod generated {+ wasmtime::component::bindgen!({+ path: "src/p3/wit",+ world: "wasi:tls/imports",+ imports: {+ "wasi:tls/client.[method]connector.send": store | trappable | tracing,+ "wasi:tls/client.[method]connector.receive": store | trappable | tracing,+ default: trappable | tracing,+ },+ with: {+ "wasi:tls/client.connector": crate::p3::host::Connector,+ "wasi:tls/types.error": crate::Error,+ },+ require_store_data_send: true,+ });+}++pub use self::generated::wasi::*;diff --git a/crates/wasi-tls/src/p3/host.rs b/crates/wasi-tls/src/p3/host.rsnew file mode 100644index 0000000000..e34aa0c308--- /dev/null+++ b/crates/wasi-tls/src/p3/host.rs@@ -0,0 +1,290 @@+//! p3 host implementation for `wasi:tls`.++use crate::p3::util::{AsyncReadProducer, AsyncWriteConsumer, Closed, Deferred, Shared, pipe};+use crate::p3::{WasiTls, WasiTlsCtxView, bindings};+use crate::{BoxFutureTlsStream, Error, TlsStream};+use std::pin::Pin;+use std::task::{Context, Poll};+use tokio::{io::AsyncWriteExt as _, sync::oneshot};+use wasmtime::StoreContextMut;+use wasmtime::component::{+ Access, Accessor, AccessorTask, FutureProducer, FutureReader, HasData, Resource, StreamReader,+};++/// Host-side state stored for `wasi:tls/client` `connector` resources.+pub struct Connector {+ connection: Shared<Deferred<Box<dyn TlsStream>>>,+ send: Option<pipe::Writer>,+ recv: Option<pipe::Reader>,+}++impl<'a> bindings::tls::client::Host for WasiTlsCtxView<'a> {}+impl<'a> bindings::tls::types::Host for WasiTlsCtxView<'a> {}++impl<'a> bindings::tls::types::HostError for WasiTlsCtxView<'a> {+ fn to_debug_string(&mut self, this: Resource<Error>) -> wasmtime::Result<String> {+ Ok(self.table.get(&this)?.to_string())+ }++ fn drop(&mut self, rep: Resource<Error>) -> wasmtime::Result<()> {+ self.table.delete(rep)?;+ Ok(())+ }+}++impl<'a> bindings::tls::client::HostConnector for WasiTlsCtxView<'a> {+ fn new(&mut self) -> wasmtime::Result<Resource<Connector>> {+ Ok(self.table.push(Connector {+ connection: Shared::new(Deferred::pending()),+ send: None,+ recv: None,+ })?)+ }++ fn drop(&mut self, rep: Resource<Connector>) -> wasmtime::Result<()> {+ self.table.delete(rep)?;+ Ok(())+ }+}++impl bindings::tls::client::HostConnectorWithStore for WasiTls {+ fn send<T: 'static>(+ mut store: Access<'_, T, Self>,+ this: Resource<Connector>,+ mut cleartext: StreamReader<u8>,+ ) -> wasmtime::Result<(StreamReader<u8>, FutureReader<Result<(), Resource<Error>>>)> {+ let getter = store.getter();++ {+ let ctx = store.get();+ let connector = ctx.table.get(&this)?;+ if connector.send.is_some() {+ cleartext.close(&mut store)?;++ let err = Error::msg("send already configured");+ let ciphertext = Closed(err.clone());+ let result = ResultProducer::ready(getter, Err(err));++ return Ok((+ StreamReader::new(&mut store, ciphertext)?,+ FutureReader::new(&mut store, result)?,+ ));+ }+ }++ let (ciphertext_reader, ciphertext_writer) = pipe::pipe();+ let (ciphertext_result_tx, ciphertext_result_rx) = oneshot::channel();+ let (cleartext_result_tx, cleartext_result_rx) = oneshot::channel();+ let (send_result_tx, send_result_rx) = oneshot::channel();++ let connection = {+ let ctx = store.get();+ let connector = ctx.table.get_mut(&this)?;+ connector.send = Some(ciphertext_writer);+ connector.connection.clone()+ };++ cleartext.pipe(+ &mut store,+ AsyncWriteConsumer::new(connection, cleartext_result_tx),+ )?;++ let ciphertext = AsyncReadProducer::new(ciphertext_reader, ciphertext_result_tx);+ store.spawn(FnTask(async move || {+ let cleartext_result = match cleartext_result_rx.await? {+ Ok(mut inner) => inner.shutdown().await, // Drive the close_notify sequence+ Err(e) => Err(e),+ };+ let ciphertext_result = ciphertext_result_rx.await?.map(drop);+ let combined_result = cleartext_result+ .and(ciphertext_result)+ .map_err(|e| Error::from(e));+ _ = send_result_tx.send(combined_result);+ Ok(())+ }));+ let result = ResultProducer::new(getter, send_result_rx);++ Ok((+ StreamReader::new(&mut store, ciphertext)?,+ FutureReader::new(&mut store, result)?,+ ))+ }++ fn receive<T: 'static>(+ mut store: Access<'_, T, Self>,+ this: Resource<Connector>,+ mut ciphertext: StreamReader<u8>,+ ) -> wasmtime::Result<(StreamReader<u8>, FutureReader<Result<(), Resource<Error>>>)> {+ let getter = store.getter();++ {+ let ctx = store.get();+ let connector = ctx.table.get(&this)?;+ if connector.recv.is_some() {+ ciphertext.close(&mut store)?;++ let err = Error::msg("receive already configured");+ let cleartext = Closed(err.clone());+ let result = ResultProducer::ready(getter, Err(err));++ return Ok((+ StreamReader::new(&mut store, cleartext)?,+ FutureReader::new(&mut store, result)?,+ ));+ }+ }++ let (ciphertext_reader, ciphertext_writer) = pipe::pipe();+ let (ciphertext_result_tx, ciphertext_result_rx) = oneshot::channel();+ let (cleartext_result_tx, cleartext_result_rx) = oneshot::channel();+ let (recv_result_tx, recv_result_rx) = oneshot::channel();++ let connection = {+ let ctx = store.get();+ let connector = ctx.table.get_mut(&this)?;+ connector.recv = Some(ciphertext_reader);+ connector.connection.clone()+ };++ ciphertext.pipe(+ &mut store,+ AsyncWriteConsumer::new(ciphertext_writer, ciphertext_result_tx),+ )?;++ let cleartext = AsyncReadProducer::new(connection, cleartext_result_tx);+ store.spawn(FnTask(async move || {+ let ciphertext_result = match ciphertext_result_rx.await? {+ // Let the TLS implementation know the transport is closed.+ // Most likely, `shutdown` will be entirely synchronous and+ // complete immediately, but awaiting it anyway to adhere to+ // the AsyncWrite contract:+ Ok(mut inner) => inner.shutdown().await,+ Err(e) => Err(e),+ };+ let cleartext_result = cleartext_result_rx.await?.map(drop);+ let combined_result = cleartext_result+ .and(ciphertext_result)+ .map_err(|e| Error::from(e));+ _ = recv_result_tx.send(combined_result);+ Ok(())+ }));+ let result = ResultProducer::new(getter, recv_result_rx);++ Ok((+ StreamReader::new(&mut store, cleartext)?,+ FutureReader::new(&mut store, result)?,+ ))+ }++ async fn connect<T: Send>(+ accessor: &Accessor<T, Self>,+ this: Resource<Connector>,+ server_name: String,+ ) -> wasmtime::Result<Result<(), Resource<Error>>> {+ fn connect_err(msg: &'static str) -> BoxFutureTlsStream {+ Box::pin(async move { Err(Error::msg(msg)) })+ }+ let (fut, connection) = accessor.with(+ move |mut access| -> wasmtime::Result<(BoxFutureTlsStream, _)> {+ let WasiTlsCtxView { table, ctx } = access.get();+ let connector = table.delete(this)?;+ let connection = connector.connection;++ let Some(ciphertext_writer) = connector.send else {+ return Ok((+ connect_err("send() must be called before connect()"),+ connection,+ ));+ };+ let Some(ciphertext_reader) = connector.recv else {+ return Ok((+ connect_err("receive() must be called before connect()"),+ connection,+ ));+ };++ let transport = Box::new(tokio::io::join(ciphertext_reader, ciphertext_writer));+ let fut = ctx.provider.connect(server_name, transport);++ Ok((fut, connection))+ },+ )?;++ match fut.await {+ Ok(tls_stream) => {+ connection.lock().resolve(tls_stream);+ Ok(Ok(()))+ }+ Err(e) => {+ connection.lock().resolve(Box::new(Closed(e.clone())));+ let resource = accessor.with(|mut access| access.get().table.push(e))?;+ Ok(Err(resource))+ }+ }+ }+}++pub(crate) struct FnTask<Fn>(pub(crate) Fn);+impl<Fn, Fut, T, D> AccessorTask<T, D> for FnTask<Fn>+where+ Fn: FnOnce() -> Fut + Send + 'static,+ Fut: Future<Output = wasmtime::Result<()>> + Send + 'static,+ D: HasData + ?Sized,+{+ fn run(+ self,+ _accessor: &wasmtime::component::Accessor<T, D>,+ ) -> impl Future<Output = wasmtime::Result<()>> + Send {+ self.0()+ }+}++pub(crate) struct ResultProducer<D> {+ result: oneshot::Receiver<Result<(), Error>>,+ getter: for<'a> fn(&'a mut D) -> WasiTlsCtxView<'a>,+}+impl<D> ResultProducer<D> {+ pub(crate) fn new(+ getter: for<'a> fn(&'a mut D) -> WasiTlsCtxView<'a>,+ result: oneshot::Receiver<Result<(), Error>>,+ ) -> Self {+ Self { result, getter }+ }++ pub(crate) fn ready(+ getter: for<'a> fn(&'a mut D) -> WasiTlsCtxView<'a>,+ result: Result<(), Error>,+ ) -> Self {+ let (sender, receiver) = oneshot::channel();+ sender.send(result).expect("receiver dropped");+ Self {+ result: receiver,+ getter,+ }+ }+}+impl<D> FutureProducer<D> for ResultProducer<D>+where+ D: 'static,+{+ type Item = Result<(), Resource<Error>>;++ fn poll_produce(+ mut self: Pin<&mut Self>,+ cx: &mut Context<'_>,+ mut store: StoreContextMut<D>,+ finish: bool,+ ) -> Poll<wasmtime::error::Result<Option<Self::Item>>> {+ match Pin::new(&mut self.result).poll(cx) {+ Poll::Ready(Ok(Ok(()))) => Poll::Ready(Ok(Some(Ok(())))),+ Poll::Ready(Ok(Err(err))) => {+ let WasiTlsCtxView { table, .. } = (self.getter)(store.data_mut());+ let err = table.push(err)?;+ Poll::Ready(Ok(Some(Err(err))))+ }+ Poll::Ready(Err(_)) => Poll::Ready(Err(wasmtime::format_err!("sender dropped"))),+ Poll::Pending if finish => Poll::Ready(Ok(None)),+ Poll::Pending => Poll::Pending,+ }+ }+}diff --git a/crates/wasi-tls/src/p3/mod.rs b/crates/wasi-tls/src/p3/mod.rsnew file mode 100644index 0000000000..90b69b3071--- /dev/null+++ b/crates/wasi-tls/src/p3/mod.rs@@ -0,0 +1,49 @@+//! Experimental, unstable and incomplete implementation of wasip3 version of `wasi:tls`.+//!+//! This module is under heavy development.+//! It is not compliant with semver and is not ready+//! for production use.+//!+//! Bug and security fixes limited to wasip3 will not be given patch releases.+//!+//! Documentation of this module may be incorrect or out-of-sync with the implementation.++pub mod bindings;+pub mod host;+pub(crate) mod util;++use crate::WasiTlsCtx;+use bindings::tls::{client, types};+use wasmtime::component::{HasData, Linker, ResourceTable};++/// The type for which this crate implements the `wasi:tls` interfaces.+pub struct WasiTls;++impl HasData for WasiTls {+ type Data<'a> = WasiTlsCtxView<'a>;+}++/// View into [`WasiTlsCtx`] implementation and [`ResourceTable`].+pub struct WasiTlsCtxView<'a> {+ /// Mutable reference to table used to manage resources.+ pub table: &'a mut ResourceTable,++ /// Mutable reference to the WASI TLS context.+ pub ctx: &'a mut WasiTlsCtx,+}++/// A trait which provides internal WASI TLS state.+pub trait WasiTlsView: Send {+ /// Return a [`WasiTlsCtxView`] from mutable reference to self.+ fn tls(&mut self) -> WasiTlsCtxView<'_>;+}++/// Add all interfaces from this module into the `linker` provided.+pub fn add_to_linker<T>(linker: &mut Linker<T>) -> wasmtime::Result<()>+where+ T: WasiTlsView + 'static,+{+ client::add_to_linker::<_, WasiTls>(linker, T::tls)?;+ types::add_to_linker::<_, WasiTls>(linker, T::tls)?;+ Ok(())+}diff --git a/crates/wasi-tls/src/p3/util/closed.rs b/crates/wasi-tls/src/p3/util/closed.rsnew file mode 100644index 0000000000..3e4e5e2fc8--- /dev/null+++ b/crates/wasi-tls/src/p3/util/closed.rs@@ -0,0 +1,65 @@+use crate::Error;+use bytes::BytesMut;+use std::io::Cursor;+use std::pin::Pin;+use std::task::{Context, Poll};+use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};+use wasmtime::StoreContextMut;+use wasmtime::component::{Destination, Source, StreamConsumer, StreamProducer, StreamResult};++/// A stream which is closed and returns an error on all operations.+pub(crate) struct Closed(pub(crate) Error);+impl crate::TlsStream for Closed {}+impl AsyncRead for Closed {+ fn poll_read(+ self: Pin<&mut Self>,+ _cx: &mut Context<'_>,+ _buf: &mut ReadBuf<'_>,+ ) -> Poll<std::io::Result<()>> {+ Poll::Ready(Err(self.0.clone().into()))+ }+}+impl AsyncWrite for Closed {+ fn poll_write(+ self: Pin<&mut Self>,+ _cx: &mut Context<'_>,+ _buf: &[u8],+ ) -> Poll<std::io::Result<usize>> {+ Poll::Ready(Err(self.0.clone().into()))+ }++ fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {+ Poll::Ready(Err(self.0.clone().into()))+ }++ fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {+ Poll::Ready(Err(self.0.clone().into()))+ }+}+impl<D> StreamProducer<D> for Closed {+ type Item = u8;+ type Buffer = Cursor<BytesMut>;++ fn poll_produce<'a>(+ self: Pin<&mut Self>,+ _cx: &mut Context<'_>,+ _store: StoreContextMut<'a, D>,+ _dst: Destination<'a, Self::Item, Self::Buffer>,+ _finish: bool,+ ) -> Poll<wasmtime::Result<StreamResult>> {+ Poll::Ready(Ok(StreamResult::Dropped))+ }+}+impl<D> StreamConsumer<D> for Closed {+ type Item = u8;++ fn poll_consume(+ self: Pin<&mut Self>,+ _cx: &mut Context<'_>,+ _store: StoreContextMut<D>,+ _src: Source<'_, Self::Item>,+ _finish: bool,+ ) -> Poll<wasmtime::Result<StreamResult>> {+ Poll::Ready(Ok(StreamResult::Dropped))+ }+}diff --git a/crates/wasi-tls/src/p3/util/deferred.rs b/crates/wasi-tls/src/p3/util/deferred.rsnew file mode 100644index 0000000000..1b9a5db517--- /dev/null+++ b/crates/wasi-tls/src/p3/util/deferred.rs@@ -0,0 +1,261 @@+use std::pin::Pin;+use std::task::{Context, Poll, Waker};+use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};++/// A stream whose underlying IO implementation will come later.+///+/// The stream starts out idle. All IO operations during this time will return+/// `Poll::Pending` and store the waker. Once the underlying IO is installed via+/// `resolve()`, the wakers will be fired and all IO operations will be+/// delegated to the inner IO.+pub(crate) enum Deferred<IO> {+ Pending {+ read_waker: Waker,+ write_waker: Waker,+ },+ Ready(IO),+}+impl<IO> Deferred<IO> {+ /// Creates an idle stream.+ pub(crate) fn pending() -> Self {+ let noop = Waker::noop();+ Deferred::Pending {+ read_waker: noop.clone(),+ write_waker: noop.clone(),+ }+ }++ /// Install the inner IO and wake any stored wakers.+ pub(crate) fn resolve(&mut self, io: IO) {+ match std::mem::replace(self, Deferred::Ready(io)) {+ Deferred::Pending {+ read_waker,+ write_waker,+ } => {+ read_waker.wake();+ write_waker.wake();+ }+ Deferred::Ready(_) => unreachable!("Deferred should only be made ready once"),+ }+ }++ fn poll_read_io<T>(+ &mut self,+ cx: &mut Context<'_>,+ f: impl FnOnce(Pin<&mut IO>, &mut Context<'_>) -> Poll<T>,+ ) -> Poll<T>+ where+ IO: Unpin,+ {+ match self {+ Deferred::Pending { read_waker, .. } => {+ *read_waker = cx.waker().clone();+ Poll::Pending+ }+ Deferred::Ready(io) => f(Pin::new(io), cx),+ }+ }++ fn poll_write_io<T>(+ &mut self,+ cx: &mut Context<'_>,+ f: impl FnOnce(Pin<&mut IO>, &mut Context<'_>) -> Poll<T>,+ ) -> Poll<T>+ where+ IO: Unpin,+ {+ match self {+ Deferred::Pending { write_waker, .. } => {+ *write_waker = cx.waker().clone();+ Poll::Pending+ }+ Deferred::Ready(io) => f(Pin::new(io), cx),+ }+ }+}++impl<IO: AsyncRead + Unpin> AsyncRead for Deferred<IO> {+ fn poll_read(+ mut self: Pin<&mut Self>,+ cx: &mut Context<'_>,+ buf: &mut ReadBuf<'_>,+ ) -> Poll<std::io::Result<()>> {+ self.poll_read_io(cx, |io, cx| io.poll_read(cx, buf))+ }+}++impl<IO: AsyncWrite + Unpin> AsyncWrite for Deferred<IO> {+ fn poll_write(+ mut self: Pin<&mut Self>,+ cx: &mut Context<'_>,+ buf: &[u8],+ ) -> Poll<std::io::Result<usize>> {+ self.poll_write_io(cx, |io, cx| io.poll_write(cx, buf))+ }++ fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {+ self.poll_write_io(cx, |io, cx| io.poll_flush(cx))+ }++ fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {+ self.poll_write_io(cx, |io, cx| io.poll_shutdown(cx))+ }+}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::p3::util::pipe;+ use std::sync::Arc;+ use std::sync::atomic::{AtomicBool, Ordering};+ use std::task::Wake;+ use tokio::io::{AsyncReadExt, AsyncWriteExt, DuplexStream};++ struct BoolWaker(AtomicBool);+ impl BoolWaker {+ fn new() -> Arc<Self> {+ Arc::new(Self(AtomicBool::new(false)))+ }+ fn waker(self: &Arc<Self>) -> Waker {+ Waker::from(self.clone())+ }+ fn is_set(&self) -> bool {+ self.0.load(Ordering::SeqCst)+ }+ }+ impl Wake for BoolWaker {+ fn wake(self: Arc<Self>) {+ self.0.store(true, Ordering::SeqCst);+ }+ }++ /// Core lifecycle: pending → Poll::Pending (read waker stored) → resolve+ /// wakes it → IO is then delegated to the inner reader.+ #[tokio::test]+ async fn read_lifecycle() {+ let read_flag = BoolWaker::new();+ let read_waker = read_flag.waker();+ let mut cx = Context::from_waker(&read_waker);++ let (pipe_reader, mut pipe_writer) = pipe::pipe();+ pipe_writer.write_all(b"hello").await.unwrap();+ drop(pipe_writer);+ let mut deferred: Deferred<pipe::Reader> = Deferred::pending();++ let mut buf = [0u8; 8];+ assert!(+ Pin::new(&mut deferred)+ .poll_read(&mut cx, &mut ReadBuf::new(&mut buf))+ .is_pending()+ );+ assert!(+ !read_flag.is_set(),+ "read waker must not fire before resolve"+ );++ deferred.resolve(pipe_reader);+ assert!(+ read_flag.is_set(),+ "resolve must wake the stored read waker"+ );++ let mut out = Vec::new();+ deferred.read_to_end(&mut out).await.unwrap();+ assert_eq!(&out, b"hello");+ }++ /// Write-side lifecycle: pending → Poll::Pending (write waker stored) →+ /// resolve wakes it → IO is then delegated to the inner writer.+ #[tokio::test]+ async fn write_lifecycle() {+ let write_flag = BoolWaker::new();+ let write_waker = write_flag.waker();+ let mut cx = Context::from_waker(&write_waker);++ let (mut pipe_reader, pipe_writer) = pipe::pipe();+ let mut deferred: Deferred<pipe::Writer> = Deferred::pending();++ // Poll write while still pending — write waker must be stored.+ assert!(+ Pin::new(&mut deferred)+ .poll_write(&mut cx, b"world")+ .is_pending()+ );+ assert!(+ !write_flag.is_set(),+ "write waker must not fire before resolve"+ );++ deferred.resolve(pipe_writer);+ assert!(+ write_flag.is_set(),+ "resolve must wake the stored write waker"+ );++ deferred.write_all(b"world").await.unwrap();+ deferred.shutdown().await.unwrap();++ let mut out = Vec::new();+ pipe_reader.read_to_end(&mut out).await.unwrap();+ assert_eq!(&out, b"world");+ }++ /// resolve() wakes both the read and write wakers on the *same* Deferred.+ /// Uses DuplexStream which implements both AsyncRead and AsyncWrite, so a+ /// single Deferred<DuplexStream> can have distinct wakers registered on+ /// each side before the IO is available.+ #[tokio::test]+ async fn resolve_wakes_both() {+ let read_flag = BoolWaker::new();+ let write_flag = BoolWaker::new();++ let (duplex, _other) = tokio::io::duplex(64);+ let mut deferred: Deferred<DuplexStream> = Deferred::pending();++ let read_waker = read_flag.waker();+ let write_waker = write_flag.waker();+ let mut read_cx = Context::from_waker(&read_waker);+ let mut write_cx = Context::from_waker(&write_waker);++ // Register different wakers on each side of the same Deferred.+ let mut buf = [0u8; 4];+ assert!(+ Pin::new(&mut deferred)+ .poll_read(&mut read_cx, &mut ReadBuf::new(&mut buf))+ .is_pending()+ );+ assert!(+ Pin::new(&mut deferred)+ .poll_write(&mut write_cx, b"bye")+ .is_pending()+ );+ assert!(+ !read_flag.is_set(),+ "read waker must not fire before resolve"+ );+ assert!(+ !write_flag.is_set(),+ "write waker must not fire before resolve"+ );++ deferred.resolve(duplex);++ assert!(read_flag.is_set(), "resolve must wake the read waker");+ assert!(write_flag.is_set(), "resolve must wake the write waker");+ }++ /// resolve() before any poll is fine; the noop waker is woken harmlessly.+ #[tokio::test]+ async fn resolve_before_poll() {+ let (pipe_reader, mut pipe_writer) = pipe::pipe();+ pipe_writer.write_all(b"eager").await.unwrap();+ drop(pipe_writer);++ let mut deferred: Deferred<pipe::Reader> = Deferred::pending();+ deferred.resolve(pipe_reader);++ let mut out = Vec::new();+ deferred.read_to_end(&mut out).await.unwrap();+ assert_eq!(&out, b"eager");+ }+}diff --git a/crates/wasi-tls/src/p3/util/mod.rs b/crates/wasi-tls/src/p3/util/mod.rsnew file mode 100644index 0000000000..84a10c2455--- /dev/null+++ b/crates/wasi-tls/src/p3/util/mod.rs@@ -0,0 +1,10 @@+mod closed;+mod deferred;+pub(crate) mod pipe;+mod shared;+mod tokio_streams;++pub(crate) use closed::Closed;+pub(crate) use deferred::Deferred;+pub(crate) use shared::Shared;+pub(crate) use tokio_streams::{AsyncReadProducer, AsyncWriteConsumer};diff --git a/crates/wasi-tls/src/p3/util/pipe.rs b/crates/wasi-tls/src/p3/util/pipe.rsnew file mode 100644index 0000000000..fd67ab2c5f--- /dev/null+++ b/crates/wasi-tls/src/p3/util/pipe.rs@@ -0,0 +1,87 @@+use std::pin::Pin;+use std::task::{Context, Poll};+use tokio::io::{AsyncRead, AsyncWrite, DuplexStream, ReadBuf};++pub(crate) const CAPACITY: usize = 16 * 1024;++/// A unidirectional in-memory pipe.+///+/// Data written to the `Writer` can be read from the `Reader`.+/// Closing the `Writer` will cause the `Reader` to see EOF, and+/// closing the `Reader` will cause the `Writer` to see a broken pipe error.+///+/// Naively one would reach for `tokio::io::simplex`, but that does not+/// communicate EOF or broken pipe when the other side is dropped.+pub(crate) fn pipe() -> (Reader, Writer) {+ let (r, w) = tokio::io::duplex(CAPACITY);+ (Reader(r), Writer(w))+}+pub(crate) struct Reader(DuplexStream);+pub(crate) struct Writer(DuplexStream);++impl AsyncRead for Reader {+ fn poll_read(+ mut self: Pin<&mut Self>,+ cx: &mut Context<'_>,+ buf: &mut ReadBuf<'_>,+ ) -> Poll<std::io::Result<()>> {+ Pin::new(&mut self.0).poll_read(cx, buf)+ }+}++impl AsyncWrite for Writer {+ fn poll_write(+ mut self: Pin<&mut Self>,+ cx: &mut Context<'_>,+ buf: &[u8],+ ) -> Poll<std::io::Result<usize>> {+ Pin::new(&mut self.0).poll_write(cx, buf)+ }++ fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {+ Pin::new(&mut self.0).poll_flush(cx)+ }++ fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {+ Pin::new(&mut self.0).poll_shutdown(cx)+ }+}++#[cfg(test)]+mod tests {+ use super::*;+ use tokio::io::{AsyncReadExt, AsyncWriteExt};++ #[tokio::test]+ async fn basic_functionality() {+ let (mut r, mut w) = pipe();+ w.write_all(b"hello, world").await.unwrap();+ let mut buf = vec![0u8; 12];+ r.read_exact(&mut buf).await.unwrap();+ assert_eq!(&buf, b"hello, world");+ }++ #[tokio::test]+ async fn reader_eof_on_writer_drop() {+ let (mut r, w) = pipe();+ drop(w);+ let n = r.read(&mut vec![0u8; 16]).await.unwrap();+ assert_eq!(n, 0, "expected EOF after writer drop");+ }++ #[tokio::test]+ async fn reader_eof_on_writer_shutdown() {+ let (mut r, mut w) = pipe();+ w.shutdown().await.unwrap();+ let n = r.read(&mut vec![0u8; 16]).await.unwrap();+ assert_eq!(n, 0, "expected EOF after writer shutdown");+ }++ #[tokio::test]+ async fn writer_broken_pipe_on_reader_drop() {+ let (r, mut w) = pipe();+ drop(r);+ let err = w.write_all(b"hello").await.unwrap_err();+ assert_eq!(err.kind(), std::io::ErrorKind::BrokenPipe);+ }+}diff --git a/crates/wasi-tls/src/p3/util/shared.rs b/crates/wasi-tls/src/p3/util/shared.rsnew file mode 100644index 0000000000..d1b9c6dc46--- /dev/null+++ b/crates/wasi-tls/src/p3/util/shared.rs@@ -0,0 +1,48 @@+use std::pin::Pin;+use std::sync::{Arc, Mutex, MutexGuard};+use std::task::{Context, Poll};+use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};++/// An `Arc<Mutex<IO>>` wrapper.+///+/// Implements `AsyncRead` and `AsyncWrite` if the inner `IO` does so too.+pub(crate) struct Shared<IO>(Arc<Mutex<IO>>);+impl<IO> Shared<IO> {+ pub(crate) fn new(io: IO) -> Self {+ Self(Arc::new(Mutex::new(io)))+ }+ pub(crate) fn lock(&self) -> MutexGuard<'_, IO> {+ self.0.lock().expect("other thread panicked")+ }+}+impl<IO> Clone for Shared<IO> {+ fn clone(&self) -> Self {+ Self(Arc::clone(&self.0))+ }+}+impl<IO: AsyncRead + Unpin> AsyncRead for Shared<IO> {+ fn poll_read(+ self: Pin<&mut Self>,+ cx: &mut Context<'_>,+ buf: &mut ReadBuf<'_>,+ ) -> Poll<std::io::Result<()>> {+ Pin::new(&mut *self.lock()).poll_read(cx, buf)+ }+}+impl<IO: AsyncWrite + Unpin> AsyncWrite for Shared<IO> {+ fn poll_write(+ self: Pin<&mut Self>,+ cx: &mut Context<'_>,+ buf: &[u8],+ ) -> Poll<std::io::Result<usize>> {+ Pin::new(&mut *self.lock()).poll_write(cx, buf)+ }++ fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {+ Pin::new(&mut *self.lock()).poll_flush(cx)+ }++ fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {+ Pin::new(&mut *self.lock()).poll_shutdown(cx)+ }+}diff --git a/crates/wasi-tls/src/p3/util/tokio_streams.rs b/crates/wasi-tls/src/p3/util/tokio_streams.rsnew file mode 100644index 0000000000..14331792fc--- /dev/null+++ b/crates/wasi-tls/src/p3/util/tokio_streams.rs@@ -0,0 +1,161 @@+use bytes::BytesMut;+use std::io::Cursor;+use std::pin::Pin;+use std::task::{Context, Poll};+use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};+use tokio::sync::oneshot;+use wasmtime::StoreContextMut;+use wasmtime::component::{Destination, Source, StreamConsumer, StreamProducer, StreamResult};++use crate::p3::util::pipe;++/// A [StreamProducer] for an [AsyncRead] stream.+///+/// Once the inner `AsyncRead` returns EOF or an error, the producer will be+/// dropped and the final result is submitted to the `dropped` channel.+pub(crate) struct AsyncReadProducer<IO>(Option<(IO, oneshot::Sender<std::io::Result<IO>>)>);+impl<IO> AsyncReadProducer<IO> {+ pub(crate) fn new(io: IO, dropped: oneshot::Sender<std::io::Result<IO>>) -> Self {+ Self(Some((io, dropped)))+ }+ fn io(&mut self) -> Option<&mut IO> {+ self.0.as_mut().map(|(io, _)| io)+ }+ fn notify_dropped(&mut self, result: std::io::Result<()>) {+ if let Some((io, dropped)) = self.0.take() {+ let _ = dropped.send(result.map(|()| io));+ }+ }+}+impl<IO> Drop for AsyncReadProducer<IO> {+ fn drop(&mut self) {+ self.notify_dropped(Ok(()));+ }+}+impl<D, IO> StreamProducer<D> for AsyncReadProducer<IO>+where+ IO: AsyncRead + Send + Unpin + 'static,+{+ type Item = u8;+ type Buffer = Cursor<BytesMut>;++ fn poll_produce<'a>(+ mut self: Pin<&mut Self>,+ cx: &mut Context<'_>,+ store: StoreContextMut<'a, D>,+ dst: Destination<'a, Self::Item, Self::Buffer>,+ finish: bool,+ ) -> Poll<wasmtime::Result<StreamResult>> {+ let Some(io) = self.io() else {+ return Poll::Ready(Ok(StreamResult::Dropped));+ };++ let mut dst = dst.as_direct(store, pipe::CAPACITY);+ let remaining = dst.remaining();++ // A zero-remaining destination means the guest is waiting for+ // readiness rather than requesting data. AsyncRead has no+ // separate readiness API, so we lie and say "ready" here; the+ // next actual poll will read data.+ //+ // See WebAssembly/component-model#561 for background.+ if remaining.is_empty() {+ return Poll::Ready(Ok(StreamResult::Completed));+ }++ let mut buf = ReadBuf::new(remaining);+ match Pin::new(io).poll_read(cx, &mut buf) {+ Poll::Ready(Ok(())) if buf.filled().is_empty() => {+ // EOF — signal clean completion.+ self.notify_dropped(Ok(()));+ Poll::Ready(Ok(StreamResult::Dropped))+ }+ Poll::Ready(Ok(())) => {+ let n = buf.filled().len();+ dst.mark_written(n);+ Poll::Ready(Ok(StreamResult::Completed))+ }+ Poll::Ready(Err(e)) => {+ self.notify_dropped(Err(e));+ Poll::Ready(Ok(StreamResult::Dropped))+ }+ Poll::Pending if finish => Poll::Ready(Ok(StreamResult::Cancelled)),+ Poll::Pending => Poll::Pending,+ }+ }+}++/// A [StreamConsumer] for an [AsyncWrite] stream.+///+/// Once the inner `AsyncWrite` returns an error, the consumer will be dropped+/// and the final result is submitted to the `dropped` channel.+pub(crate) struct AsyncWriteConsumer<IO>(Option<(IO, oneshot::Sender<std::io::Result<IO>>)>);+impl<IO> AsyncWriteConsumer<IO> {+ pub(crate) fn new(io: IO, dropped: oneshot::Sender<std::io::Result<IO>>) -> Self {+ Self(Some((io, dropped)))+ }+ fn io(&mut self) -> Option<&mut IO> {+ self.0.as_mut().map(|(io, _)| io)+ }+ fn notify_dropped(&mut self, result: std::io::Result<()>) {+ if let Some((io, dropped)) = self.0.take() {+ let _ = dropped.send(result.map(|()| io));+ }+ }+}+impl<IO> Drop for AsyncWriteConsumer<IO> {+ fn drop(&mut self) {+ self.notify_dropped(Ok(()));+ }+}+impl<D, IO> StreamConsumer<D> for AsyncWriteConsumer<IO>+where+ IO: AsyncWrite + Send + Unpin + 'static,+{+ type Item = u8;++ fn poll_consume(+ mut self: Pin<&mut Self>,+ cx: &mut Context<'_>,+ store: StoreContextMut<D>,+ src: Source<'_, Self::Item>,+ finish: bool,+ ) -> Poll<wasmtime::Result<StreamResult>> {+ let Some(io) = self.io() else {+ return Poll::Ready(Ok(StreamResult::Dropped));+ };++ let mut src = src.as_direct(store);+ let remaining = src.remaining();++ if remaining.is_empty() {+ // Zero-length consume = readiness check. AsyncWrite has no+ // dedicated readiness API so we report ready; the next poll will+ // perform the actual write.+ //+ // See WebAssembly/component-model#561 for background.+ return Poll::Ready(Ok(if finish {+ StreamResult::Cancelled+ } else {+ StreamResult::Completed+ }));+ }++ match Pin::new(io).poll_write(cx, remaining) {+ Poll::Ready(Ok(0)) => {+ self.notify_dropped(Err(std::io::ErrorKind::WriteZero.into()));+ Poll::Ready(Ok(StreamResult::Dropped))+ }+ Poll::Ready(Ok(n)) => {+ src.mark_read(n);+ Poll::Ready(Ok(StreamResult::Completed))+ }+ Poll::Ready(Err(e)) => {+ self.notify_dropped(Err(e));+ Poll::Ready(Ok(StreamResult::Dropped))+ }+ Poll::Pending if finish => Poll::Ready(Ok(StreamResult::Cancelled)),+ Poll::Pending => Poll::Pending,+ }+ }+}diff --git a/crates/wasi-tls/src/p3/wit/deps/tls/client.wit b/crates/wasi-tls/src/p3/wit/deps/tls/client.witnew file mode 100644index 0000000000..8f282dbe8e--- /dev/null+++ b/crates/wasi-tls/src/p3/wit/deps/tls/client.wit@@ -0,0 +1,22 @@+interface client {+ use types.{error};++ resource connector {+ constructor();++ /// Set up the encryption stream transform.+ /// This takes an unprotected `cleartext` application data stream and+ /// returns an encrypted data stream, ready to be sent out over the network.+ /// Closing the `cleartext` stream will cause a `close_notify` packet to be emitted on the returned output stream.+ send: func(cleartext: stream<u8>) -> tuple<stream<u8>, future<result<_, error>>>;++ /// Set up the decryption stream transform.+ /// This takes an encrypted data stream, as received via e.g. the network,+ /// and returns a decrypted application data stream.+ receive: func(ciphertext: stream<u8>) -> tuple<stream<u8>, future<result<_, error>>>;++ /// Perform the handshake.+ /// The `send` & `receive` streams must be set up before calling this method.+ connect: static async func(this: connector, server-name: string) -> result<_, error>;+ }+}diff --git a/crates/wasi-tls/src/p3/wit/deps/tls/types.wit b/crates/wasi-tls/src/p3/wit/deps/tls/types.witnew file mode 100644index 0000000000..fc6c4b103e--- /dev/null+++ b/crates/wasi-tls/src/p3/wit/deps/tls/types.wit@@ -0,0 +1,5 @@+interface types {+ resource error {+ to-debug-string: func() -> string;+ }+}diff --git a/crates/wasi-tls/src/p3/wit/deps/tls/world.wit b/crates/wasi-tls/src/p3/wit/deps/tls/world.witnew file mode 100644index 0000000000..599d49688a--- /dev/null+++ b/crates/wasi-tls/src/p3/wit/deps/tls/world.wit@@ -0,0 +1,6 @@+package wasi:[email protected];++world imports {+ import client;+ import types;+}diff --git a/crates/wasi-tls/src/p3/wit/world.wit b/crates/wasi-tls/src/p3/wit/world.witnew file mode 100644index 0000000000..51e0e7e8cc--- /dev/null+++ b/crates/wasi-tls/src/p3/wit/world.wit@@ -0,0 +1,2 @@+// We actually don't use this; it's just to let bindgen! find the corresponding world in wit/deps.+package wasmtime:wasi-tls;diff --git a/crates/wasi-tls/src/providers/nativetls.rs b/crates/wasi-tls/src/providers/nativetls.rsindex c548289797..8691a97fa6 100644--- a/crates/wasi-tls/src/providers/nativetls.rs+++ b/crates/wasi-tls/src/providers/nativetls.rs@@ -1,10 +1,9 @@//! The `native_tls` provider.-use std::{io, pin::pin};--use crate::{TlsProvider, TlsStream, TlsTransport};--type BoxFuture<T> = std::pin::Pin<Box<dyn Future<Output = T> + Send>>;+use crate::{BoxFutureTlsStream, Error, TlsProvider, TlsStream, TlsTransport};+use std::io;+use std::pin::{Pin, pin};+use std::task::Poll;/// The `native_tls` provider.pub struct NativeTlsProvider {@@ -12,27 +11,13 @@ pub struct NativeTlsProvider {}impl TlsProvider for NativeTlsProvider {- fn connect(- &self,- server_name: String,- transport: Box<dyn TlsTransport>,- ) -> BoxFuture<io::Result<Box<dyn TlsStream>>> {- async fn connect_impl(- server_name: String,- transport: Box<dyn TlsTransport>,- ) -> Result<NativeTlsStream, native_tls::Error> {+ fn connect(&self, server_name: String, transport: Box<dyn TlsTransport>) -> BoxFutureTlsStream {+ Box::pin(async move {let connector = native_tls::TlsConnector::new()?;let stream = tokio_native_tls::TlsConnector::from(connector).connect(&server_name, transport).await?;- Ok(NativeTlsStream(stream))- }-- Box::pin(async move {- let stream = connect_impl(server_name, transport)- .await- .map_err(|e| io::Error::other(e))?;- Ok(Box::new(stream) as Box<dyn TlsStream>)+ Ok(Box::new(NativeTlsStream(stream)) as Box<dyn TlsStream>)})}}@@ -52,7 +37,7 @@ impl tokio::io::AsyncRead for NativeTlsStream {mut self: std::pin::Pin<&mut Self>,cx: &mut std::task::Context<'_>,buf: &mut tokio::io::ReadBuf<'_>,- ) -> std::task::Poll<io::Result<()>> {+ ) -> Poll<io::Result<()>> {pin!(&mut self.as_mut().0).poll_read(cx, buf)}}@@ -62,21 +47,36 @@ impl tokio::io::AsyncWrite for NativeTlsStream {mut self: std::pin::Pin<&mut Self>,cx: &mut std::task::Context<'_>,buf: &[u8],- ) -> std::task::Poll<io::Result<usize>> {+ ) -> Poll<io::Result<usize>> {pin!(&mut self.as_mut().0).poll_write(cx, buf)}fn poll_flush(mut self: std::pin::Pin<&mut Self>,cx: &mut std::task::Context<'_>,- ) -> std::task::Poll<Result<(), io::Error>> {+ ) -> Poll<Result<(), io::Error>> {pin!(&mut self.as_mut().0).poll_flush(cx)}fn poll_shutdown(mut self: std::pin::Pin<&mut Self>,cx: &mut std::task::Context<'_>,- ) -> std::task::Poll<Result<(), io::Error>> {- pin!(&mut self.as_mut().0).poll_shutdown(cx)+ ) -> Poll<Result<(), io::Error>> {+ match pin!(&mut self.as_mut().0).poll_shutdown(cx) {+ Poll::Ready(Ok(())) => {}+ Poll::Ready(Err(e)) => return Poll::Ready(Err(e)),+ Poll::Pending => return Poll::Pending,+ }++ // `tokio-rustls` & `tokio-openssl` shut down the underlying transport,+ // but `tokio-native-tls` does not, so we need to do that ourselves:+ let inner = self.0.get_mut().get_mut().get_mut();+ Pin::new(inner).poll_shutdown(cx)+ }+}++impl From<native_tls::Error> for Error {+ fn from(e: native_tls::Error) -> Self {+ Error::msg(e.to_string())}}diff --git a/crates/wasi-tls/src/providers/openssl.rs b/crates/wasi-tls/src/providers/openssl.rsindex 5175c7fa88..c17b1dc081 100644--- a/crates/wasi-tls/src/providers/openssl.rs+++ b/crates/wasi-tls/src/providers/openssl.rs@@ -1,13 +1,9 @@//! The `openssl` provider.-use crate::{TlsProvider, TlsStream, TlsTransport};+use crate::{BoxFutureTlsStream, Error, TlsProvider, TlsStream, TlsTransport};use openssl::ssl::{SslConnector, SslMethod};-use std::{- io,- pin::{Pin, pin},-};--type BoxFuture<T> = std::pin::Pin<Box<dyn Future<Output = T> + Send>>;+use std::io;+use std::pin::{Pin, pin};/// The `openssl` provider.pub struct OpenSslProvider {@@ -15,15 +11,8 @@ pub struct OpenSslProvider {}impl TlsProvider for OpenSslProvider {- fn connect(- &self,- server_name: String,- transport: Box<dyn TlsTransport>,- ) -> BoxFuture<io::Result<Box<dyn TlsStream>>> {- async fn connect_impl(- server_name: String,- transport: Box<dyn TlsTransport>,- ) -> Result<OpenSslStream, openssl::ssl::Error> {+ fn connect(&self, server_name: String, transport: Box<dyn TlsTransport>) -> BoxFutureTlsStream {+ Box::pin(async move {// Per the `openssl` crate's recommendation, we're using the// `SslConnector` to set up a Ssl object with secure defaults://@@ -37,14 +26,7 @@ impl TlsProvider for OpenSslProvider {let ssl = config.into_ssl(&server_name)?;let mut stream = tokio_openssl::SslStream::new(ssl, transport)?;Pin::new(&mut stream).connect().await?;- Ok(OpenSslStream(stream))- }-- Box::pin(async move {- let stream = connect_impl(server_name, transport)- .await- .map_err(|e| io::Error::other(e))?;- Ok(Box::new(stream) as Box<dyn TlsStream>)+ Ok(Box::new(OpenSslStream(stream)) as Box<dyn TlsStream>)})}}@@ -92,3 +74,14 @@ impl tokio::io::AsyncWrite for OpenSslStream {pin!(&mut self.as_mut().0).poll_shutdown(cx)}}++impl From<openssl::ssl::Error> for Error {+ fn from(e: openssl::ssl::Error) -> Self {+ Error::msg(e.to_string())+ }+}+impl From<openssl::error::ErrorStack> for Error {+ fn from(e: openssl::error::ErrorStack) -> Self {+ openssl::ssl::Error::from(e).into()+ }+}diff --git a/crates/wasi-tls/src/providers/rustls.rs b/crates/wasi-tls/src/providers/rustls.rsindex 0d8fcd2cf2..7003a84db6 100644--- a/crates/wasi-tls/src/providers/rustls.rs+++ b/crates/wasi-tls/src/providers/rustls.rs@@ -1,11 +1,9 @@//! The `rustls` provider.+use crate::{BoxFutureTlsStream, Error, TlsProvider, TlsStream, TlsTransport};use rustls::pki_types::ServerName;-use std::io;use std::sync::{Arc, LazyLock};-use crate::{BoxFuture, TlsProvider, TlsStream, TlsTransport};-impl crate::TlsStream for tokio_rustls::client::TlsStream<Box<dyn TlsTransport>> {}/// The `rustls` provider.@@ -14,19 +12,16 @@ pub struct RustlsProvider {}impl TlsProvider for RustlsProvider {- fn connect(- &self,- server_name: String,- transport: Box<dyn TlsTransport>,- ) -> BoxFuture<io::Result<Box<dyn TlsStream>>> {+ fn connect(&self, server_name: String, transport: Box<dyn TlsTransport>) -> BoxFutureTlsStream {let client_config = Arc::clone(&self.client_config);Box::pin(async move {- let domain = ServerName::try_from(server_name)- .map_err(|_| io::Error::other("invalid server name"))?;+ let domain =+ ServerName::try_from(server_name).map_err(|_| Error::msg("invalid server name"))?;let stream = tokio_rustls::TlsConnector::from(client_config).connect(domain, transport)- .await?;+ .await+ .map_err(rustls_to_wasi_error)?;Ok(Box::new(stream) as Box<dyn TlsStream>)})}@@ -49,3 +44,16 @@ impl Default for RustlsProvider {}}}++impl From<rustls::Error> for Error {+ fn from(e: rustls::Error) -> Self {+ Error::msg(e.to_string())+ }+}++fn rustls_to_wasi_error(e: std::io::Error) -> Error {+ match e.downcast::<rustls::Error>() {+ Ok(e) => e.into(),+ Err(io_err) => Error::msg(io_err),+ }+}diff --git a/crates/wasi-tls/src/providers/unsupported.rs b/crates/wasi-tls/src/providers/unsupported.rsindex b6a502688a..93ac6fa519 100644--- a/crates/wasi-tls/src/providers/unsupported.rs+++ b/crates/wasi-tls/src/providers/unsupported.rs@@ -1,7 +1,6 @@//! The `unsupported` provider.-use crate::{BoxFuture, TlsProvider, TlsStream, TlsTransport};-use std::io;+use crate::{BoxFutureTlsStream, Error, TlsProvider, TlsTransport};/// A pseudo TLS provider that returns an error for all operations. This is the/// default provider when no real TLS providers were enabled at compile time.@@ -15,10 +14,9 @@ impl TlsProvider for UnsupportedProvider {&self,_server_name: String,_transport: Box<dyn TlsTransport>,- ) -> BoxFuture<io::Result<Box<dyn TlsStream>>> {+ ) -> BoxFutureTlsStream {Box::pin(async move {- Err(io::Error::new(- io::ErrorKind::Unsupported,+ Err(Error::msg("no TLS provider enabled; recompile with a TLS provider feature",))})diff --git a/crates/wasi-tls/tests/main.rs b/crates/wasi-tls/tests/main.rsindex 70f5b11c01..a1f886eb33 100644--- a/crates/wasi-tls/tests/main.rs+++ b/crates/wasi-tls/tests/main.rs@@ -1,106 +1,6 @@#![cfg(any(feature = "rustls", feature = "openssl", feature = "nativetls"))]-use wasmtime::{- Result, Store,- component::{Component, Linker, ResourceTable},- format_err,-};-use wasmtime_wasi::{WasiCtx, WasiCtxView, WasiView, p2::bindings::Command};-use wasmtime_wasi_tls::{LinkOptions, TlsProvider, WasiTls, WasiTlsCtx, WasiTlsCtxBuilder};--struct Ctx {- table: ResourceTable,- wasi_ctx: WasiCtx,- wasi_tls_ctx: WasiTlsCtx,-}--impl WasiView for Ctx {- fn ctx(&mut self) -> WasiCtxView<'_> {- WasiCtxView {- ctx: &mut self.wasi_ctx,- table: &mut self.table,- }- }-}--async fn run_test(provider: Box<dyn TlsProvider>, path: &str) -> Result<()> {- let ctx = Ctx {- table: ResourceTable::new(),- wasi_ctx: WasiCtx::builder()- .inherit_stdout()- .inherit_stderr()- .inherit_network()- .allow_ip_name_lookup(true)- .build(),- wasi_tls_ctx: WasiTlsCtxBuilder::new().provider(provider).build(),- };-- let engine = test_programs_artifacts::engine(|_config| {});- let mut store = Store::new(&engine, ctx);- let component = Component::from_file(&engine, path)?;-- let mut linker = Linker::new(&engine);- wasmtime_wasi::p2::add_to_linker_async(&mut linker)?;- let mut opts = LinkOptions::default();- opts.tls(true);- wasmtime_wasi_tls::add_to_linker(&mut linker, &mut opts, |h: &mut Ctx| {- WasiTls::new(&h.wasi_tls_ctx, &mut h.table)- })?;-- let command = Command::instantiate_async(&mut store, &component, &linker).await?;- command- .wasi_cli_run()- .call_run(&mut store)- .await?- .map_err(|()| format_err!("command returned with failing exit status"))-}--macro_rules! test_case {- ($provider:ident, $name:ident) => {- #[tokio::test(flavor = "multi_thread")]- async fn $name() -> wasmtime::Result<()> {- super::$name(Box::new(wasmtime_wasi_tls::$provider::default())).await- }- };-}--#[cfg(feature = "rustls")]-mod rustls {- macro_rules! rustls_test_case {- ($name:ident) => {- test_case!(RustlsProvider, $name);- };- }-- test_programs_artifacts::foreach_tls!(rustls_test_case);-}--#[cfg(feature = "openssl")]-mod openssl {- macro_rules! openssl_test_case {- ($name:ident) => {- test_case!(OpenSslProvider, $name);- };- }-- test_programs_artifacts::foreach_tls!(openssl_test_case);-}--#[cfg(feature = "nativetls")]-mod nativetls {- macro_rules! nativetls_test_case {- ($name:ident) => {- test_case!(NativeTlsProvider, $name);- };- }-- test_programs_artifacts::foreach_tls!(nativetls_test_case);-}--async fn tls_sample_application(provider: Box<dyn TlsProvider>) -> Result<()> {- run_test(- provider,- test_programs_artifacts::TLS_SAMPLE_APPLICATION_COMPONENT,- )- .await-}+#[cfg(feature = "p2")]+mod p2;+#[cfg(feature = "p3")]+mod p3;diff --git a/crates/wasi-tls/tests/p2/mod.rs b/crates/wasi-tls/tests/p2/mod.rsnew file mode 100644index 0000000000..3263c7445a--- /dev/null+++ b/crates/wasi-tls/tests/p2/mod.rs@@ -0,0 +1,104 @@+use wasmtime::{+ Result, Store,+ component::{Component, Linker, ResourceTable},+ format_err,+};+use wasmtime_wasi::{WasiCtx, WasiCtxView, WasiView, p2::bindings::Command};+use wasmtime_wasi_tls::{TlsProvider, WasiTlsCtx, WasiTlsCtxBuilder, p2};++struct Ctx {+ table: ResourceTable,+ wasi_ctx: WasiCtx,+ wasi_tls_ctx: WasiTlsCtx,+}++impl WasiView for Ctx {+ fn ctx(&mut self) -> WasiCtxView<'_> {+ WasiCtxView {+ ctx: &mut self.wasi_ctx,+ table: &mut self.table,+ }+ }+}++async fn run_test(provider: Box<dyn TlsProvider>, path: &str) -> Result<()> {+ let ctx = Ctx {+ table: ResourceTable::new(),+ wasi_ctx: WasiCtx::builder()+ .inherit_stdout()+ .inherit_stderr()+ .inherit_network()+ .allow_ip_name_lookup(true)+ .build(),+ wasi_tls_ctx: WasiTlsCtxBuilder::new().provider(provider).build(),+ };++ let engine = test_programs_artifacts::engine(|_config| {});+ let mut store = Store::new(&engine, ctx);+ let component = Component::from_file(&engine, path)?;++ let mut linker = Linker::new(&engine);+ wasmtime_wasi::p2::add_to_linker_async(&mut linker)?;+ let mut opts = p2::LinkOptions::default();+ opts.tls(true);+ p2::add_to_linker(&mut linker, &mut opts, |h: &mut Ctx| {+ p2::WasiTls::new(&h.wasi_tls_ctx, &mut h.table)+ })?;++ let command = Command::instantiate_async(&mut store, &component, &linker).await?;+ command+ .wasi_cli_run()+ .call_run(&mut store)+ .await?+ .map_err(|()| format_err!("command returned with failing exit status"))+}++macro_rules! test_case {+ ($provider:ident, $name:ident) => {+ #[tokio::test(flavor = "multi_thread")]+ async fn $name() -> wasmtime::Result<()> {+ super::$name(Box::new(wasmtime_wasi_tls::$provider::default())).await+ }+ };+}++#[cfg(feature = "rustls")]+mod rustls {+ macro_rules! rustls_test_case {+ ($name:ident) => {+ test_case!(RustlsProvider, $name);+ };+ }++ test_programs_artifacts::foreach_p2_tls!(rustls_test_case);+}++#[cfg(feature = "openssl")]+mod openssl {+ macro_rules! openssl_test_case {+ ($name:ident) => {+ test_case!(OpenSslProvider, $name);+ };+ }++ test_programs_artifacts::foreach_p2_tls!(openssl_test_case);+}++#[cfg(feature = "nativetls")]+mod nativetls {+ macro_rules! nativetls_test_case {+ ($name:ident) => {+ test_case!(NativeTlsProvider, $name);+ };+ }++ test_programs_artifacts::foreach_p2_tls!(nativetls_test_case);+}++async fn p2_tls_sample_application(provider: Box<dyn TlsProvider>) -> Result<()> {+ run_test(+ provider,+ test_programs_artifacts::P2_TLS_SAMPLE_APPLICATION_COMPONENT,+ )+ .await+}diff --git a/crates/wasi-tls/tests/p3/mod.rs b/crates/wasi-tls/tests/p3/mod.rsnew file mode 100644index 0000000000..d1a751b5de--- /dev/null+++ b/crates/wasi-tls/tests/p3/mod.rs@@ -0,0 +1,115 @@+use wasmtime::{+ Result, Store,+ component::{Component, Linker, ResourceTable},+ format_err,+};+use wasmtime_wasi::{WasiCtx, WasiCtxView, WasiView, p3::bindings::Command};+use wasmtime_wasi_tls::{+ TlsProvider, WasiTlsCtx, WasiTlsCtxBuilder,+ p3::{WasiTlsCtxView, WasiTlsView},+};++struct Ctx {+ table: ResourceTable,+ wasi_ctx: WasiCtx,+ wasi_tls_ctx: WasiTlsCtx,+}++impl WasiView for Ctx {+ fn ctx(&mut self) -> WasiCtxView<'_> {+ WasiCtxView {+ ctx: &mut self.wasi_ctx,+ table: &mut self.table,+ }+ }+}++impl WasiTlsView for Ctx {+ fn tls(&mut self) -> WasiTlsCtxView<'_> {+ WasiTlsCtxView {+ ctx: &mut self.wasi_tls_ctx,+ table: &mut self.table,+ }+ }+}++async fn run_test(provider: Box<dyn TlsProvider>, path: &str) -> Result<()> {+ let ctx = Ctx {+ table: ResourceTable::new(),+ wasi_ctx: WasiCtx::builder()+ .inherit_stdout()+ .inherit_stderr()+ .inherit_network()+ .allow_ip_name_lookup(true)+ .build(),+ wasi_tls_ctx: WasiTlsCtxBuilder::new().provider(provider).build(),+ };++ let engine = test_programs_artifacts::engine(|config| {+ config.wasm_component_model_async(true);+ });+ let mut store = Store::new(&engine, ctx);+ let component = Component::from_file(&engine, path)?;++ let mut linker = Linker::new(&engine);+ // TODO: Remove p2 once test components are not built for `wasm32-wasip1`+ wasmtime_wasi::p2::add_to_linker_async(&mut linker)?;+ wasmtime_wasi::p3::add_to_linker(&mut linker)?;+ wasmtime_wasi_tls::p3::add_to_linker(&mut linker)?;++ let command = Command::instantiate_async(&mut store, &component, &linker).await?;+ store+ .run_concurrent(async move |store| command.wasi_cli_run().call_run(store).await)+ .await??+ .map_err(|()| format_err!("command returned with failing exit status"))+}++macro_rules! test_case {+ ($provider:ident, $name:ident) => {+ #[tokio::test(flavor = "multi_thread")]+ async fn $name() -> wasmtime::Result<()> {+ super::$name(Box::new(wasmtime_wasi_tls::$provider::default())).await+ }+ };+}++#[cfg(feature = "rustls")]+mod rustls {+ macro_rules! rustls_test_case {+ ($name:ident) => {+ test_case!(RustlsProvider, $name);+ };+ }++ test_programs_artifacts::foreach_p3_tls!(rustls_test_case);+}++#[cfg(feature = "openssl")]+mod openssl {+ macro_rules! openssl_test_case {+ ($name:ident) => {+ test_case!(OpenSslProvider, $name);+ };+ }++ test_programs_artifacts::foreach_p3_tls!(openssl_test_case);+}++#[cfg(feature = "nativetls")]+mod nativetls {+ macro_rules! nativetls_test_case {+ ($name:ident) => {+ test_case!(NativeTlsProvider, $name);+ };+ }++ test_programs_artifacts::foreach_p3_tls!(nativetls_test_case);+}++async fn p3_tls_sample_application(provider: Box<dyn TlsProvider>) -> Result<()> {+ run_test(+ provider,+ test_programs_artifacts::P3_TLS_SAMPLE_APPLICATION_COMPONENT,+ )+ .await+}diff --git a/src/commands/run.rs b/src/commands/run.rsindex fdc4111a32..65184059d6 100644--- a/src/commands/run.rs+++ b/src/commands/run.rs@@ -31,7 +31,7 @@ use wasmtime_wasi_nn::wit::WasiNnView;#[cfg(feature = "wasi-threads")]use wasmtime_wasi_threads::WasiThreadsCtx;#[cfg(feature = "wasi-tls")]-use wasmtime_wasi_tls::{WasiTls, WasiTlsCtx};+use wasmtime_wasi_tls::{WasiTlsCtx, p2::WasiTls};fn parse_preloads(s: &str) -> Result<(String, PathBuf)> {let parts: Vec<&str> = s.splitn(2, '=').collect();@@ -1317,9 +1317,9 @@ impl RunCommand {bail!("Cannot enable wasi-tls for core wasm modules");}CliLinker::Component(linker) => {- let mut opts = wasmtime_wasi_tls::LinkOptions::default();+ let mut opts = wasmtime_wasi_tls::p2::LinkOptions::default();opts.tls(true);- wasmtime_wasi_tls::add_to_linker(linker, &mut opts, |h| {+ wasmtime_wasi_tls::p2::add_to_linker(linker, &mut opts, |h| {let ctx = h.wasip1_ctx.as_mut().expect("wasi is not configured");let ctx = Arc::get_mut(ctx).unwrap().get_mut().unwrap();WasiTls::new(@@ -1328,6 +1328,11 @@ impl RunCommand {)})?;+ #[cfg(feature = "component-model-async")]+ if self.run.common.wasi.p3.unwrap_or(crate::common::P3_DEFAULT) {+ wasmtime_wasi_tls::p3::add_to_linker(linker)?;+ }+let ctx = wasmtime_wasi_tls::WasiTlsCtxBuilder::new().build();store.data_mut().wasi_tls = Some(Arc::new(ctx));}@@ -1546,6 +1551,16 @@ impl wasmtime_wasi_http::p3::WasiHttpView for Host {}}+#[cfg(all(feature = "wasi-tls", feature = "component-model-async"))]+impl wasmtime_wasi_tls::p3::WasiTlsView for Host {+ fn tls(&mut self) -> wasmtime_wasi_tls::p3::WasiTlsCtxView<'_> {+ wasmtime_wasi_tls::p3::WasiTlsCtxView {+ table: WasiView::ctx(unwrap_singlethread_context(&mut self.wasip1_ctx)).table,+ ctx: Arc::get_mut(self.wasi_tls.as_mut().unwrap()).unwrap(),+ }+ }+}+fn ctx_set_listenfd(mut num_fd: usize, builder: &mut WasiCtxBuilder) -> Result<usize> {let _ = &mut num_fd;let _ = &mut *builder;