Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
refactor(websocket): prepare native handshake inputs and results
ldm0af1c22df4553
diff --git a/moli-websocket/src/connection.rs b/moli-websocket/src/connection.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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_conlet 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.rsindex 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()