Skip to content

A lightweight WebAssembly runtime that is fast, secure, and standards-compliant

wasi-http: fill in scheme and authority for p3 serve requests (#14898)

Xia Chaofda11bca86cc
diff --git a/crates/test-programs/src/bin/p3_cli_serve_authority_and_scheme.rs b/crates/test-programs/src/bin/p3_cli_serve_authority_and_scheme.rs
new file mode 100644
index 0000000000..4c0360cc64
--- /dev/null
+++ b/crates/test-programs/src/bin/p3_cli_serve_authority_and_scheme.rs
@@ -0,0 +1,31 @@
+//! Checks that `serve` fills in the scheme and authority of an incoming request.
+use test_programs::p3::wasi::http::types::{ErrorCode, Fields, Request, Response, Scheme};
+use test_programs::p3::{service, wit_future};
+
+struct T;
+
+service::export!(T);
+
+impl service::exports::wasi::http::handler::Guest for T {
+ async fn handle(request: Request) -> Result<Response, ErrorCode> {
+ assert_eq!(
+ request.get_authority().as_deref(),
+ Some("localhost"),
+ "unexpected authority"
+ );
+ assert!(
+ matches!(request.get_scheme(), Some(Scheme::Http)),
+ "unexpected scheme: {:?}",
+ request.get_scheme()
+ );
+
+ let (body_result_tx, body_result_rx) = wit_future::new(|| Ok(None));
+ let (response, _result) = Response::new(Fields::new(), None, body_result_rx);
+ drop(body_result_tx);
+ Ok(response)
+ }
+}
+
+fn main() {
+ unreachable!()
+}
diff --git a/crates/wasi-http/src/handler.rs b/crates/wasi-http/src/handler.rs
index 0619d11aeb..96eb1e6eff 100644
--- a/crates/wasi-http/src/handler.rs
+++ b/crates/wasi-http/src/handler.rs
@@ -1004,10 +1004,45 @@ impl<'a, T: Send> Prepared<'a, T> {
match proxy {
#[cfg(feature = "p3")]
Proxy::P3(guest) => {
- let (request, body) = request.into_parts();
- let request = http::Request::from_parts(request, body);
+ use http::header::HOST;
+ use http::uri::Authority;
+
+ let (parts, body) = request.into_parts();
+ let http::request::Parts {
+ method,
+ uri,
+ headers: request_headers,
+ ..
+ } = parts;
+ let http::uri::Parts {
+ scheme,
+ authority,
+ path_and_query,
+ ..
+ } = uri.into_parts();
+ // HTTP/1.1 requires an authority in the request target or the
+ // `Host` header (RFC 9112 section 3.2.2), so fall back to the latter.
+ let authority = match authority {
+ Some(authority) => Some(authority),
+ None => request_headers
+ .get(HOST)
+ .and_then(|host| host.to_str().ok())
+ .and_then(|host| host.parse::<Authority>().ok()),
+ };
let hooks = view(store.data_mut()).hooks;
- let (request, request_io_result) = p3::Request::from_http(hooks, request);
+ let headers = crate::FieldMap::new_immutable(hooks, request_headers);
+ // `serve` speaks plaintext HTTP, so that is the scheme of a
+ // request which does not name one.
+ let scheme = scheme.unwrap_or(http::uri::Scheme::HTTP);
+ let (request, request_io_result) = p3::Request::new(
+ method,
+ Some(scheme),
+ authority,
+ path_and_query,
+ headers,
+ None,
+ body,
+ );
let request = view(store.data_mut()).table.push(request)?;
Ok(Prepared::P3 {
diff --git a/tests/all/cli_tests.rs b/tests/all/cli_tests.rs
index f0fd50fd75..7f65b9f3b2 100644
--- a/tests/all/cli_tests.rs
+++ b/tests/all/cli_tests.rs
@@ -2249,6 +2249,27 @@ start a print 1234
Ok(())
}
+ #[tokio::test]
+ async fn p3_cli_serve_authority_and_scheme() -> Result<()> {
+ let server = WasmtimeServe::new(P3_CLI_SERVE_AUTHORITY_AND_SCHEME_COMPONENT, |cmd| {
+ cmd.arg("-Wcomponent-model-async");
+ cmd.arg("-Sp3,cli");
+ })?;
+
+ let resp = server
+ .send_request(
+ hyper::Request::builder()
+ .uri("/")
+ .header("Host", "localhost")
+ .body(String::new())
+ .context("failed to make request")?,
+ )
+ .await?;
+ assert!(resp.status().is_success());
+
+ Ok(())
+ }
+
// A body can fail to parse after the guest read part of it.
// `future-trailers` must report an error, not a successful body.
#[tokio::test]