Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

refactor(websocket): prepare native handshake inputs and results

ldm0af1c22df4553
diff --git a/moli-websocket/src/connection.rs b/moli-websocket/src/connection.rs
index 11f520e79..04cf286b1 100644
--- a/moli-websocket/src/connection.rs
+++ b/moli-websocket/src/connection.rs
@@ -5,8 +5,8 @@ use crate::{
handle::HandshakeDecision,
headers::header_map_entries,
limits::{acquire_pending_websocket_handshake_slot, acquire_websocket_connection_slot},
- request::build_websocket_request,
- transport::open_websocket_stream,
+ request::prepare_websocket_request,
+ transport::{OpenedConnection, open_websocket_connection},
};
pub(crate) async fn run_websocket_connection(
@@ -28,7 +28,7 @@ pub(crate) async fn run_websocket_connection(
return Ok(());
};
- let request = match build_websocket_request(&url, &protocols, &context) {
+ let request = match prepare_websocket_request(&url, &protocols, &context) {
Ok(request) => request,
Err(error) => {
send_error_and_close(&event_tx, socket_id, error).await?;
@@ -45,9 +45,12 @@ pub(crate) async fn run_websocket_connection(
.await?;
return Ok(());
};
- let handshake = open_websocket_stream(request, &context);
+ let handshake = open_websocket_connection(request, &context);
tokio::pin!(handshake);
- let (stream, response, request_headers) = loop {
+ let OpenedConnection {
+ connection,
+ handshake,
+ } = loop {
tokio::select! {
biased;
command = command_rx.recv() => {
@@ -100,8 +103,9 @@ pub(crate) async fn run_websocket_connection(
}
};
- let mut response_status = response.status().as_u16();
- let mut response_headers = header_map_entries(response.headers());
+ let request_headers = header_map_entries(&handshake.request_headers);
+ let mut response_status = handshake.response.status().as_u16();
+ let mut response_headers = header_map_entries(handshake.response.headers());
if let Some(mut decision) = decision {
send_event(
&event_tx,
@@ -126,12 +130,12 @@ pub(crate) async fn run_websocket_connection(
command = command_rx.recv() => {
match command.map(|queued| queued.command) {
Some(Command::Fail(message)) => {
- drop(stream);
+ drop(connection);
send_error_and_close(&event_tx, socket_id, message).await?;
return Ok(());
}
Some(Command::Close { .. }) => {
- drop(stream);
+ drop(connection);
send_error_and_close(
&event_tx, socket_id,
"WebSocket connection closed before opening".to_owned(),
@@ -153,7 +157,7 @@ pub(crate) async fn run_websocket_connection(
break;
}
HandshakeDecision::Fail(message) => {
- drop(stream);
+ drop(connection);
send_error_and_close(&event_tx, socket_id, message).await?;
return Ok(());
}
@@ -181,7 +185,7 @@ pub(crate) async fn run_websocket_connection(
)
.await?;
- crate::session::run_open_session(socket_id, stream, command_rx, event_tx).await
+ crate::session::run_open_session(socket_id, connection, command_rx, event_tx).await
}
fn response_header<'a>(headers: &'a [(String, String)], name: &str) -> Option<&'a str> {
diff --git a/moli-websocket/src/handshake.rs b/moli-websocket/src/handshake.rs
index f56c0d6c7..192b9a87a 100644
--- a/moli-websocket/src/handshake.rs
+++ b/moli-websocket/src/handshake.rs
@@ -55,7 +55,7 @@ pub(crate) fn parse_handshake_response(raw_headers: &[u8]) -> Result<HandshakeRe
}
pub(crate) fn validate_handshake_response(
- request: &http::Request<()>,
+ request: &http::HeaderMap,
response: &HandshakeResponse,
) -> Result<(), String> {
if response.status() != http::StatusCode::SWITCHING_PROTOCOLS {
@@ -71,7 +71,6 @@ pub(crate) fn validate_handshake_response(
return Err("WebSocket handshake response is missing `Connection: Upgrade`".to_owned());
}
let key = request
- .headers()
.get(http::header::SEC_WEBSOCKET_KEY)
.and_then(|value| value.to_str().ok())
.ok_or_else(|| "WebSocket request is missing Sec-WebSocket-Key".to_owned())?;
@@ -118,7 +117,7 @@ fn header_values_contain_token(
}
fn validate_response_subprotocol(
- request: &http::Request<()>,
+ request: &http::HeaderMap,
response: &HandshakeResponse,
) -> Result<(), String> {
let selected_protocols = response
@@ -156,13 +155,9 @@ fn validate_response_subprotocol(
}
}
-fn requested_subprotocols(request: &http::Request<()>) -> Result<Vec<String>, String> {
+fn requested_subprotocols(request: &http::HeaderMap) -> Result<Vec<String>, String> {
let mut protocols = Vec::new();
- for value in request
- .headers()
- .get_all(http::header::SEC_WEBSOCKET_PROTOCOL)
- .iter()
- {
+ for value in request.get_all(http::header::SEC_WEBSOCKET_PROTOCOL).iter() {
let value = value
.to_str()
.map_err(|error| format!("WebSocket request protocol is invalid: {error}"))?;
diff --git a/moli-websocket/src/headers.rs b/moli-websocket/src/headers.rs
index 367a1ccd6..b9858b0ad 100644
--- a/moli-websocket/src/headers.rs
+++ b/moli-websocket/src/headers.rs
@@ -1,7 +1,7 @@
use crate::ConnectOptions;
pub(crate) fn apply_connect_context_headers(
- request: &mut http::Request<()>,
+ headers: &mut http::HeaderMap,
context: &ConnectOptions,
) -> Result<(), http::header::InvalidHeaderValue> {
// Embedding-provided headers may intentionally override browser defaults
@@ -13,10 +13,10 @@ pub(crate) fn apply_connect_context_headers(
let Ok(name) = http::header::HeaderName::from_bytes(name.as_bytes()) else {
continue;
};
- request.headers_mut().insert(name, value.parse()?);
+ headers.insert(name, value.parse()?);
}
- insert_header_if_absent(request, http::header::ORIGIN, &context.origin)?;
- insert_header_if_absent(request, http::header::USER_AGENT, &context.user_agent)?;
+ insert_header_if_absent(headers, http::header::ORIGIN, &context.origin)?;
+ insert_header_if_absent(headers, http::header::USER_AGENT, &context.user_agent)?;
Ok(())
}
@@ -33,12 +33,12 @@ pub(crate) fn header_map_entries(headers: &http::HeaderMap) -> Vec<(String, Stri
}
pub(crate) fn insert_header_if_absent(
- request: &mut http::Request<()>,
+ headers: &mut http::HeaderMap,
name: http::header::HeaderName,
value: &str,
) -> Result<(), http::header::InvalidHeaderValue> {
- if !request.headers().contains_key(&name) {
- request.headers_mut().insert(name, value.parse()?);
+ if !headers.contains_key(&name) {
+ headers.insert(name, value.parse()?);
}
Ok(())
}
diff --git a/moli-websocket/src/proxy.rs b/moli-websocket/src/proxy.rs
index 4f84ca82d..60fd1f2c8 100644
--- a/moli-websocket/src/proxy.rs
+++ b/moli-websocket/src/proxy.rs
@@ -3,33 +3,33 @@ use url::Url;
use crate::ConnectOptions;
pub(crate) fn websocket_proxy_url(
- uri: &http::Uri,
+ url: &Url,
context: &ConnectOptions,
) -> Result<Option<Url>, String> {
- websocket_proxy_url_with_env(uri, context, |name| std::env::var(name).ok())
+ websocket_proxy_url_with_env(url, context, |name| std::env::var(name).ok())
}
pub(crate) fn websocket_proxy_url_with_env(
- uri: &http::Uri,
+ url: &Url,
context: &ConnectOptions,
mut env: impl FnMut(&str) -> Option<String>,
) -> Result<Option<Url>, String> {
let proxy = match context.http_proxy.as_deref() {
Some("") => return Ok(None),
Some(proxy) => Some(proxy.to_owned()),
- None => websocket_env_proxy_for_scheme(uri.scheme_str(), &mut env),
+ None => websocket_env_proxy_for_scheme(url.scheme(), &mut env),
};
let Some(proxy) = proxy.filter(|proxy| !proxy.is_empty()) else {
return Ok(None);
};
- let host = uri
- .host()
+ let host = url
+ .host_str()
.ok_or_else(|| "WebSocket URL is missing host".to_owned())?;
let no_proxy = match context.http_no_proxy.as_deref() {
Some(no_proxy) => Some(no_proxy.to_owned()),
None => websocket_env_no_proxy(&mut env),
};
- if no_proxy_matches(host, uri.port_u16(), no_proxy.as_deref()) {
+ if no_proxy_matches(host, url.port(), no_proxy.as_deref()) {
return Ok(None);
}
let proxy_url = Url::parse(&proxy)
@@ -47,12 +47,12 @@ pub(crate) fn websocket_proxy_url_with_env(
}
fn websocket_env_proxy_for_scheme(
- scheme: Option<&str>,
+ scheme: &str,
env: &mut impl FnMut(&str) -> Option<String>,
) -> Option<String> {
let mut names: &[&str] = match scheme {
- Some("ws") => &["http_proxy"],
- Some("wss") => &["https_proxy", "HTTPS_PROXY"],
+ "ws" => &["http_proxy"],
+ "wss" => &["https_proxy", "HTTPS_PROXY"],
_ => &[],
};
for name in names {
diff --git a/moli-websocket/src/request.rs b/moli-websocket/src/request.rs
index 6c448467a..d0c07a3e1 100644
--- a/moli-websocket/src/request.rs
+++ b/moli-websocket/src/request.rs
@@ -7,43 +7,38 @@ use crate::{
validate_subprotocols,
};
-pub(crate) fn build_websocket_request(
+/// Browser connection intent. Libcurl generates the HTTP upgrade fields.
+#[derive(Debug)]
+pub(crate) struct PreparedWebSocketRequest {
+ pub url: Url,
+ pub headers: http::HeaderMap,
+}
+
+pub(crate) fn prepare_websocket_request(
url: &str,
protocols: &[String],
context: &ConnectOptions,
-) -> Result<http::Request<()>, String> {
- reject_blocked_websocket_port(url)?;
- let mut parsed =
+) -> Result<PreparedWebSocketRequest, String> {
+ let mut url =
Url::parse(url).map_err(|error| format!("failed to parse WebSocket URL: {error}"))?;
- if !matches!(parsed.scheme(), "ws" | "wss") || parsed.host_str().is_none() {
+ if !matches!(url.scheme(), "ws" | "wss") || url.host_str().is_none() {
return Err("WebSocket URL must use ws or wss and include a host".to_owned());
}
- let authority = parsed[url::Position::BeforeHost..url::Position::AfterPort].to_owned();
- let _ = parsed.set_username("");
- let _ = parsed.set_password(None);
- parsed.set_fragment(None);
- let mut nonce = [0; 16];
- moli_crypto::fill_secure_random(&mut nonce)
- .map_err(|error| format!("WebSocket nonce generation failed: {error}"))?;
- let mut request = http::Request::builder()
- .uri(parsed.as_str())
- .header(http::header::HOST, authority)
- .header(http::header::CONNECTION, "Upgrade")
- .header(http::header::UPGRADE, "websocket")
- .header(http::header::SEC_WEBSOCKET_VERSION, "13")
- .header(http::header::SEC_WEBSOCKET_KEY, STANDARD.encode(nonce))
- .body(())
- .map_err(|error| format!("failed to build WebSocket request: {error}"))?;
- apply_connect_context_headers(&mut request, context)
+ reject_blocked_websocket_port(&url)?;
+ let mut headers = http::HeaderMap::new();
+ apply_connect_context_headers(&mut headers, context)
.map_err(|error| format!("failed to build WebSocket handshake headers: {error}"))?;
- apply_subprotocol_header(&mut request, protocols)?;
- apply_basic_auth_header(&mut request, url)?;
- apply_cookie_header(&mut request, context)?;
- Ok(request)
+ apply_subprotocol_header(&mut headers, protocols)?;
+ apply_basic_auth_header(&mut headers, &url)?;
+ apply_cookie_header(&mut headers, context)?;
+ let _ = url.set_username("");
+ let _ = url.set_password(None);
+ url.set_fragment(None);
+ Ok(PreparedWebSocketRequest { url, headers })
}
fn apply_subprotocol_header(
- request: &mut http::Request<()>,
+ headers: &mut http::HeaderMap,
protocols: &[String],
) -> Result<(), String> {
if protocols.is_empty() {
@@ -55,25 +50,22 @@ fn apply_subprotocol_header(
let value = value
.parse()
.map_err(|error| format!("failed to build WebSocket subprotocol header: {error}"))?;
- request
- .headers_mut()
- .insert(http::header::SEC_WEBSOCKET_PROTOCOL, value);
+ headers.insert(http::header::SEC_WEBSOCKET_PROTOCOL, value);
Ok(())
}
fn apply_cookie_header(
- request: &mut http::Request<()>,
+ headers: &mut http::HeaderMap,
context: &ConnectOptions,
) -> Result<(), String> {
let Some(cookie_header) = context.cookie_header.as_deref() else {
return Ok(());
};
- insert_header_if_absent(request, http::header::COOKIE, cookie_header)
+ insert_header_if_absent(headers, http::header::COOKIE, cookie_header)
.map_err(|error| format!("failed to build WebSocket cookie header: {error}"))
}
-fn apply_basic_auth_header(request: &mut http::Request<()>, url: &str) -> Result<(), String> {
- let url = Url::parse(url).map_err(|error| format!("failed to parse WebSocket URL: {error}"))?;
+fn apply_basic_auth_header(headers: &mut http::HeaderMap, url: &Url) -> Result<(), String> {
if url.username().is_empty() && url.password().is_none() {
return Ok(());
}
@@ -83,12 +75,11 @@ fn apply_basic_auth_header(request: &mut http::Request<()>, url: &str) -> Result
.map(percent_decode_userinfo_component)
.unwrap_or_default();
let value = format!("Basic {}", encode_basic_auth(&username, &password));
- insert_header_if_absent(request, http::header::AUTHORIZATION, &value)
+ insert_header_if_absent(headers, http::header::AUTHORIZATION, &value)
.map_err(|error| format!("failed to build WebSocket basic auth header: {error}"))
}
-fn reject_blocked_websocket_port(url: &str) -> Result<(), String> {
- let url = Url::parse(url).map_err(|error| format!("failed to parse WebSocket URL: {error}"))?;
+fn reject_blocked_websocket_port(url: &Url) -> Result<(), String> {
let Some(port) = url.port_or_known_default() else {
return Ok(());
};
@@ -127,29 +118,7 @@ fn hex_value(byte: u8) -> Option<u8> {
}
fn encode_basic_auth(username: &str, password: &str) -> String {
- const BASE64: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
- let input = format!("{username}:{password}");
- let bytes = input.as_bytes();
- let mut out = String::with_capacity(bytes.len().div_ceil(3) * 4);
- for chunk in bytes.chunks(3) {
- let b0 = chunk[0];
- let b1 = *chunk.get(1).unwrap_or(&0);
- let b2 = *chunk.get(2).unwrap_or(&0);
- let word = ((b0 as u32) << 16) | ((b1 as u32) << 8) | (b2 as u32);
- out.push(BASE64[((word >> 18) & 0x3f) as usize] as char);
- out.push(BASE64[((word >> 12) & 0x3f) as usize] as char);
- out.push(if chunk.len() > 1 {
- BASE64[((word >> 6) & 0x3f) as usize] as char
- } else {
- '='
- });
- out.push(if chunk.len() > 2 {
- BASE64[(word & 0x3f) as usize] as char
- } else {
- '='
- });
- }
- out
+ STANDARD.encode(format!("{username}:{password}"))
}
fn is_blocked_websocket_port(port: u16) -> bool {
diff --git a/moli-websocket/src/test_support.rs b/moli-websocket/src/test_support.rs
index 084ecccff..c6ded99c5 100644
--- a/moli-websocket/src/test_support.rs
+++ b/moli-websocket/src/test_support.rs
@@ -44,11 +44,11 @@ pub fn test_websocket_context() -> ConnectOptions {
}
pub fn test_websocket_proxy_url_with_env(
- uri: &http::Uri,
+ url: &url::Url,
context: &ConnectOptions,
env: &[(&str, &str)],
) -> Option<String> {
- websocket_proxy_url_with_env(uri, context, |name| {
+ websocket_proxy_url_with_env(url, context, |name| {
env.iter()
.find_map(|(env_name, value)| (*env_name == name).then(|| (*value).to_owned()))
})
diff --git a/moli-websocket/src/tests.rs b/moli-websocket/src/tests.rs
index 67ea94f47..c52da93e1 100644
--- a/moli-websocket/src/tests.rs
+++ b/moli-websocket/src/tests.rs
@@ -7,7 +7,7 @@ use crate::{
acquire_limited_websocket_slot,
},
proxy::{append_proxy_connect_header, no_proxy_matches},
- request::build_websocket_request,
+ request::prepare_websocket_request,
test_support::*,
};
use tokio::{
@@ -184,9 +184,9 @@ fn websocket_potentially_trustworthy_url_matches_loopback_policy() {
}
#[test]
-fn websocket_request_builder_rejects_invalid_subprotocol_defensively() {
+fn websocket_request_preparation_rejects_invalid_subprotocol_defensively() {
let context = test_websocket_context();
- let error = build_websocket_request(
+ let error = prepare_websocket_request(
"ws://example.com/socket",
&["chat".to_owned(), "CHAT".to_owned()],
&context,
@@ -197,13 +197,13 @@ fn websocket_request_builder_rejects_invalid_subprotocol_defensively() {
}
#[test]
-fn websocket_request_builder_rejects_blocked_ports() {
+fn websocket_request_preparation_rejects_blocked_ports() {
let context = test_websocket_context();
- let error = build_websocket_request("ws://127.0.0.1:25/socket", &[], &context)
+ let error = prepare_websocket_request("ws://127.0.0.1:25/socket", &[], &context)
.expect_err("blocked port should fail");
assert!(error.contains("port `25` is blocked"));
- assert!(build_websocket_request("ws://127.0.0.1:43210/socket", &[], &context).is_ok());
+ assert!(prepare_websocket_request("ws://127.0.0.1:43210/socket", &[], &context).is_ok());
}
#[test]
@@ -326,7 +326,7 @@ fn websocket_proxy_connect_header_rejects_newline_values() {
}
#[test]
-fn websocket_request_builder_applies_context_protocols_and_cookie() {
+fn websocket_request_preparation_applies_context_protocols_and_cookie() {
let mut context = test_websocket_context();
context.extra_headers = vec![
("X-Moli-Trace".to_owned(), "socket".to_owned()),
@@ -334,45 +334,45 @@ fn websocket_request_builder_applies_context_protocols_and_cookie() {
];
context.cookie_header = Some("sid=server".to_owned());
- let request = build_websocket_request(
+ let request = prepare_websocket_request(
"ws://example.com/socket",
&["chat".to_owned(), "superchat".to_owned()],
&context,
)
.expect("websocket request should build");
- assert_eq!(request.uri(), "ws://example.com/socket");
+ assert_eq!(request.url.as_str(), "ws://example.com/socket");
assert_eq!(
request
- .headers()
+ .headers
.get(http::header::ORIGIN)
.and_then(|value| value.to_str().ok()),
Some("https://example.com")
);
assert_eq!(
request
- .headers()
+ .headers
.get(http::header::SEC_WEBSOCKET_PROTOCOL)
.and_then(|value| value.to_str().ok()),
Some("chat, superchat")
);
assert_eq!(
request
- .headers()
+ .headers
.get(http::header::SEC_WEBSOCKET_VERSION)
.and_then(|value| value.to_str().ok()),
- Some("13")
+ None
);
assert_eq!(
request
- .headers()
+ .headers
.get(http::header::COOKIE)
.and_then(|value| value.to_str().ok()),
Some("sid=server")
);
assert_eq!(
request
- .headers()
+ .headers
.get("x-moli-trace")
.and_then(|value| value.to_str().ok()),
Some("socket")
@@ -380,15 +380,15 @@ fn websocket_request_builder_applies_context_protocols_and_cookie() {
}
#[test]
-fn websocket_request_builder_converts_url_userinfo_to_basic_auth() {
+fn websocket_request_preparation_converts_url_userinfo_to_basic_auth() {
let context = test_websocket_context();
- let request = build_websocket_request("ws://foo:[email protected]/socket", &[], &context)
+ let request = prepare_websocket_request("ws://foo:[email protected]/socket", &[], &context)
.expect("websocket request should build");
assert_eq!(
request
- .headers()
+ .headers
.get(http::header::AUTHORIZATION)
.and_then(|value| value.to_str().ok()),
Some("Basic Zm9vOmJhcg==")
@@ -396,16 +396,16 @@ fn websocket_request_builder_converts_url_userinfo_to_basic_auth() {
}
#[test]
-fn websocket_request_builder_decodes_percent_encoded_userinfo_for_basic_auth() {
+fn websocket_request_preparation_decodes_percent_encoded_userinfo_for_basic_auth() {
let context = test_websocket_context();
let request =
- build_websocket_request("ws://foo%20bar:p%[email protected]/socket", &[], &context)
+ prepare_websocket_request("ws://foo%20bar:p%[email protected]/socket", &[], &context)
.expect("websocket request should build");
assert_eq!(
request
- .headers()
+ .headers
.get(http::header::AUTHORIZATION)
.and_then(|value| value.to_str().ok()),
Some("Basic Zm9vIGJhcjpwQHNz")
@@ -906,7 +906,7 @@ async fn websocket_transport_handshake_applies_context_headers_and_preserves_con
let mut context = test_websocket_context();
context.extra_headers = vec![
("X-Moli-Trace".to_owned(), "socket".to_owned()),
- // Protocol control headers are generated by tungstenite and should not
+ // Protocol control headers are generated by libcurl and should not
// be overridden by embedding-layer extra headers.
("Sec-WebSocket-Version".to_owned(), "999".to_owned()),
];
@@ -1428,3 +1428,67 @@ async fn websocket_queued_close_precedes_handshake_continuation() {
.unwrap()
.unwrap();
}
+
+#[tokio::test]
+async fn websocket_native_handshake_generates_keys_and_reports_actual_headers() {
+ use base64::{Engine, engine::general_purpose::STANDARD};
+ let mut previous_key = None;
+ for socket_id in 98..100 {
+ let (url, captured, server) = spawn_header_capture_websocket_server().await;
+ let (events, mut receiver) = mpsc::channel(8);
+ let mut context = test_websocket_context();
+ context
+ .extra_headers
+ .push(("Sec-WebSocket-Key".to_owned(), "injected".to_owned()));
+ let prepared = prepare_websocket_request(&url, &[], &context).unwrap();
+ for header in [
+ "host",
+ "connection",
+ "upgrade",
+ "sec-websocket-version",
+ "sec-websocket-key",
+ ] {
+ assert!(
+ !prepared.headers.contains_key(header),
+ "{header} belongs to native handshake generation"
+ );
+ }
+ let connection = spawn_connection(socket_id, url, Vec::new(), context, events);
+ let actual = timeout(Duration::from_secs(3), captured)
+ .await
+ .unwrap()
+ .unwrap();
+ let key = header_value(&actual, "sec-websocket-key").unwrap();
+ assert_eq!(STANDARD.decode(&key).unwrap().len(), 16);
+ assert_ne!(previous_key.as_ref(), Some(&key));
+ previous_key = Some(key.clone());
+ match timeout(Duration::from_secs(3), receiver.recv())
+ .await
+ .unwrap()
+ .unwrap()
+ {
+ Event::Open {
+ request_headers, ..
+ } => {
+ assert_eq!(
+ header_value(&request_headers, "sec-websocket-key"),
+ Some(key)
+ );
+ assert_eq!(
+ header_value(&request_headers, "host"),
+ header_value(&actual, "host")
+ );
+ assert_eq!(
+ header_value(&request_headers, "sec-websocket-version").as_deref(),
+ Some("13")
+ );
+ }
+ event => panic!("expected Open with actual handshake headers, got {event:?}"),
+ }
+ let _ = connection.close(Some(1000), String::new());
+ timeout(Duration::from_secs(3), server)
+ .await
+ .unwrap()
+ .unwrap();
+ }
+}
diff --git a/moli-websocket/src/transport.rs b/moli-websocket/src/transport.rs
index 5548966bf..df9b07095 100644
--- a/moli-websocket/src/transport.rs
+++ b/moli-websocket/src/transport.rs
@@ -3,6 +3,7 @@ use crate::{
handshake::{HandshakeResponse, parse_handshake_response, validate_handshake_response},
headers::header_map_entries,
proxy::{append_proxy_connect_header, websocket_proxy_url},
+ request::PreparedWebSocketRequest,
};
use moli_curl::{
CurlDnsResolution,
@@ -13,24 +14,23 @@ use moli_curl::{
use moli_dns_resolver::DnsTarget;
use std::sync::OnceLock;
-pub(crate) async fn open_websocket_stream(
- mut request: http::Request<()>,
+pub(crate) struct HandshakeInfo {
+ pub request_headers: http::HeaderMap,
+ pub response: HandshakeResponse,
+}
+
+pub(crate) struct OpenedConnection {
+ pub connection: CurlWebSocketConnection,
+ pub handshake: HandshakeInfo,
+}
+
+pub(crate) async fn open_websocket_connection(
+ request: PreparedWebSocketRequest,
context: &ConnectOptions,
-) -> Result<
- (
- CurlWebSocketConnection,
- HandshakeResponse,
- Vec<(String, String)>,
- ),
- String,
-> {
- let proxy = websocket_proxy_url(request.uri(), context)?;
- let mut native = CurlWebSocketRequest::new(request.uri().to_string());
- native.headers = header_map_entries(request.headers());
- // libcurl appends the Upgrade token itself for a native WS request.
- native
- .headers
- .retain(|(name, _)| !name.eq_ignore_ascii_case("connection"));
+) -> Result<OpenedConnection, String> {
+ let proxy = websocket_proxy_url(&request.url, context)?;
+ let mut native = CurlWebSocketRequest::new(request.url.to_string());
+ native.headers = header_map_entries(&request.headers);
native.proxy = proxy.map(|url| url.to_string());
// WebSocket opening handshakes use credentials=include, including across
// origins: https://websockets.spec.whatwg.org/#opening-handshake
@@ -49,7 +49,7 @@ pub(crate) async fn open_websocket_stream(
.push(("Proxy-Authorization".to_owned(), value));
}
} else {
- let url = url::Url::parse(&native.url).map_err(|error| error.to_string())?;
+ let url = &request.url;
if let Some(url::Host::Domain(host)) = url.host() {
native.dns_resolution = CurlDnsResolution::resolve_origin(
DnsTarget::new(
@@ -79,11 +79,16 @@ pub(crate) async fn open_websocket_stream(
.unwrap_or_else(|| "WebSocket handshake response is empty".to_owned()));
}
let response = parse_handshake_response(&response)?;
- *request.headers_mut() = actual_request_headers(&actual)?;
- validate_handshake_response(&request, &response)?;
+ let request_headers = actual_request_headers(&actual)?;
+ validate_handshake_response(&request_headers, &response)?;
result?;
- let headers = header_map_entries(request.headers());
- Ok((connection, response, headers))
+ Ok(OpenedConnection {
+ connection,
+ handshake: HandshakeInfo {
+ request_headers,
+ response,
+ },
+ })
}
Some(CurlWebSocketEvent::Closed { result }) => Err(result
.err()