A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
use anyhow::{Context, Result};
use test_programs::wasi::http::types::{
Headers, IncomingRequest, Method, OutgoingBody, OutgoingResponse, ResponseOutparam,
};
struct T;
test_programs::proxy::export!(T);
impl test_programs::proxy::exports::wasi::http::incoming_handler::Guest for T {
fn handle(request: IncomingRequest, outparam: ResponseOutparam) {
assert!(request.scheme().is_some());
assert!(request.authority().is_some());
assert!(request.path_with_query().is_some());
test_filesystem();
match (request.method(), request.path_with_query().as_deref()) {
(Method::Get, Some("/early_drop")) => {
// Ignore all the errors for this endpoint.
let resp = OutgoingResponse::new(Headers::new());
let body = resp.body().expect("outgoing response");
ResponseOutparam::set(outparam, Ok(resp));
let _ = body.write().and_then(|out| {
let _ = out.blocking_write_and_flush(b"hello, world!");
drop(out);
Ok(())
});
let _ = OutgoingBody::finish(body, None);
return;
}
(Method::Get, Some(p)) if p.starts_with("/modify_fields/") => {
let r = modify_fields_handler(request);
response_for(r, outparam);
return;
}
(Method::Get, Some(p)) if p.starts_with("/new_fields/") => {
let r = new_fields_handler(request);
response_for(r, outparam);
return;
}
_ => {}
}
let header = String::from("custom-forbidden-header");
let req_hdrs = request.headers();
assert!(
!req_hdrs.has(&header),
"forbidden `custom-forbidden-header` found in request"
);
assert!(req_hdrs.delete(&header).is_err());
assert!(req_hdrs.append(&header, b"no".as_ref()).is_err());
assert!(
!req_hdrs.has(&header),
"append of forbidden header succeeded"
);
assert!(
!req_hdrs.has("host"),
"forbidden host header present in incoming request"
);
let hdrs = Headers::new();
let resp = OutgoingResponse::new(hdrs);
let body = resp.body().expect("outgoing response");
ResponseOutparam::set(outparam, Ok(resp));
let out = body.write().expect("outgoing stream");
out.blocking_write_and_flush(b"hello, world!")
.expect("writing response");
drop(out);
OutgoingBody::finish(body, None).expect("outgoing-body.finish");
}
}
fn response_for(r: Result<()>, outparam: ResponseOutparam) {
let resp = OutgoingResponse::new(Headers::new());
resp.set_status_code(if r.is_ok() { 200 } else { 500 })
.unwrap();
let body = resp.body().expect("outgoing response");
ResponseOutparam::set(outparam, Ok(resp));
let _ = body.write().and_then(|out| {
let _ = out.blocking_write_and_flush(format!("{r:?}").as_bytes());
drop(out);
Ok(())
});
let _ = OutgoingBody::finish(body, None);
}
// Technically this should not be here for a proxy, but given the current
// framework for tests it's required since this file is built as a `bin`
fn main() {}
fn test_filesystem() {
assert!(std::fs::File::open(".").is_err());
}
fn add_bytes_to_headers(headers: Headers, size: usize) {
if size == 0 {
return;
} else if size < 10 {
headers.append("k", &b"abcdefghi"[0..size - 1]).unwrap()
} else {
for chunk in 0..(size / 10) {
let k = format!("g{chunk:04}");
let mut v = format!("h{chunk:04}");
if chunk == 0 {
for _ in 0..(size % 10) {
v.push('#');
}
}
headers.append(k.as_str(), v.as_bytes()).unwrap()
}
}
}
fn modify_fields_handler(request: IncomingRequest) -> Result<()> {
let path = request.path_with_query().unwrap();
let rest = path.trim_start_matches("/modify_fields/");
let added_field_bytes: usize = rest
.parse()
.context("expect remainder of url to parse as number")?;
add_bytes_to_headers(request.headers().clone(), added_field_bytes);
Ok(())
}
fn new_fields_handler(request: IncomingRequest) -> Result<()> {
let path = request.path_with_query().unwrap();
let rest = path.trim_start_matches("/new_fields/");
let added_field_bytes: usize = rest
.parse()
.context("expect remainder of url to parse as number")?;
add_bytes_to_headers(Headers::new(), added_field_bytes);
Ok(())
}