Skip to content

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.yml
index 2703041bff..fee22950f5 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -429,6 +429,8 @@ jobs:
- name: wasmtime-wasi-tls
checks: |
-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 openssl
diff --git a/Cargo.lock b/Cargo.lock
index 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.toml
index 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.sh
index 2904bd3ae9..5880d81ed2 100755
--- a/ci/vendor-wit.sh
+++ b/ci/vendor-wit.sh
@@ -10,27 +10,29 @@ set -ex
cache_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=$1
local tag=$2
local 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 ]]; then
mkdir -p $cached_extracted_dir
curl --retry 5 --retry-all-errors -sLO https://github.com/WebAssembly/$repo/archive/$tag.tar.gz
tar xzf $tag.tar.gz --strip-components=1 -C $cached_extracted_dir
rm $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/deps
wkg 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/deps
mkdir -p crates/wasi-config/wit/deps
get_github wasi-config v0.2.0-rc.1 crates/wasi-config/wit/deps/config
diff --git a/crates/test-programs/artifacts/build.rs b/crates/test-programs/artifacts/build.rs
index 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 add
diff --git a/crates/test-programs/src/bin/tls_sample_application.rs b/crates/test-programs/src/bin/p2_tls_sample_application.rs
similarity index 100%
rename from crates/test-programs/src/bin/tls_sample_application.rs
rename to crates/test-programs/src/bin/p2_tls_sample_application.rs
diff --git a/crates/test-programs/src/bin/p3_tls_sample_application.rs b/crates/test-programs/src/bin/p3_tls_sample_application.rs
new file mode 100644
index 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.rs
index 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.toml
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
similarity index 61%
rename from crates/wasi-tls/src/bindings.rs
rename to crates/wasi-tls/src/p2/bindings.rs
index 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.rs
similarity index 96%
rename from crates/wasi-tls/src/host.rs
rename to crates/wasi-tls/src/p2/host.rs
index 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 stream
pub 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.rs
similarity index 98%
rename from crates/wasi-tls/src/io.rs
rename to crates/wasi-tls/src/p2/io.rs
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.wit
new file mode 100644
index 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.wit
new file mode 100644
index 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.wit
new file mode 100644
index 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.wit
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
index 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;