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): separate handshake validation and event delivery

ldm0c1c936b338d7
diff --git a/moli-websocket/src/connection.rs b/moli-websocket/src/connection.rs
index a72a30df3..c828ef0d9 100644
--- a/moli-websocket/src/connection.rs
+++ b/moli-websocket/src/connection.rs
@@ -6,7 +6,7 @@ use tokio_tungstenite::tungstenite::protocol::{CloseFrame, Message};
use crate::{
Command, ConnectOptions, Event, FrameOpcode,
- events::{EventSender, send_error_and_close, send_event},
+ events::{EventResult, EventSender, send_error_and_close, send_event},
handle::AbortOnDrop,
headers::header_map_entries,
limits::{acquire_pending_websocket_handshake_slot, acquire_websocket_connection_slot},
@@ -21,22 +21,22 @@ pub(crate) async fn run_websocket_connection(
context: ConnectOptions,
mut command_rx: mpsc::UnboundedReceiver<Command>,
event_tx: EventSender,
-) {
+) -> EventResult {
let Some(_connection_slot) = acquire_websocket_connection_slot() else {
send_error_and_close(
&event_tx,
socket_id,
"WebSocket connection failed: insufficient resources".to_owned(),
)
- .await;
- return;
+ .await?;
+ return Ok(());
};
let request = match build_websocket_request(&url, &protocols, &context) {
Ok(request) => request,
Err(error) => {
- send_error_and_close(&event_tx, socket_id, error).await;
- return;
+ send_error_and_close(&event_tx, socket_id, error).await?;
+ return Ok(());
}
};
@@ -47,8 +47,8 @@ pub(crate) async fn run_websocket_connection(
socket_id,
"WebSocket connection failed: too many pending handshakes".to_owned(),
)
- .await;
- return;
+ .await?;
+ return Ok(());
};
let handshake = open_websocket_stream(request, &context);
tokio::pin!(handshake);
@@ -64,8 +64,8 @@ pub(crate) async fn run_websocket_connection(
socket_id,
"WebSocket connection closed before opening".to_owned(),
)
- .await;
- return;
+ .await?;
+ return Ok(());
}
Some(Command::SendText(_))
| Some(Command::SendBinary(_))
@@ -77,7 +77,7 @@ pub(crate) async fn run_websocket_connection(
// queueing frames before the opening handshake has succeeded.
}
Some(Command::ContinueOpen { .. }) | Some(Command::FailOpen(_)) => {}
- None => return,
+ None => return Ok(()),
}
}
connected = &mut handshake => {
@@ -93,8 +93,8 @@ pub(crate) async fn run_websocket_connection(
socket_id,
format!("WebSocket connection failed: {error}"),
)
- .await;
- return;
+ .await?;
+ return Ok(());
}
}
}
@@ -104,7 +104,7 @@ pub(crate) async fn run_websocket_connection(
let mut response_status = response.status().as_u16();
let mut response_headers = header_map_entries(response.headers());
if context.pause_after_handshake {
- let _ = send_event(
+ send_event(
&event_tx,
Event::HandshakeResponse {
socket_id,
@@ -119,7 +119,7 @@ pub(crate) async fn run_websocket_connection(
response_headers: response_headers.clone(),
},
)
- .await;
+ .await?;
loop {
match command_rx.recv().await {
Some(Command::ContinueOpen {
@@ -135,8 +135,8 @@ pub(crate) async fn run_websocket_connection(
break;
}
Some(Command::FailOpen(message)) => {
- send_error_and_close(&event_tx, socket_id, message).await;
- return;
+ send_error_and_close(&event_tx, socket_id, message).await?;
+ return Ok(());
}
Some(Command::Close { .. }) => {
send_error_and_close(
@@ -144,8 +144,8 @@ pub(crate) async fn run_websocket_connection(
socket_id,
"WebSocket connection closed before opening".to_owned(),
)
- .await;
- return;
+ .await?;
+ return Ok(());
}
Some(Command::SendText(_))
| Some(Command::SendBinary(_))
@@ -155,7 +155,7 @@ pub(crate) async fn run_websocket_connection(
// Browser-visible `send()` throws until the open event, so crate users
// cannot enqueue application data while a response-stage pause is active.
}
- None => return,
+ None => return Ok(()),
}
}
}
@@ -165,7 +165,7 @@ pub(crate) async fn run_websocket_connection(
let extensions = response_header(&response_headers, "sec-websocket-extensions")
.unwrap_or_default()
.to_owned();
- let _ = send_event(
+ send_event(
&event_tx,
Event::Open {
socket_id,
@@ -176,9 +176,9 @@ pub(crate) async fn run_websocket_connection(
response_headers,
},
)
- .await;
+ .await?;
- run_open_websocket_connection(socket_id, stream, command_rx, event_tx).await;
+ run_open_websocket_connection(socket_id, stream, command_rx, event_tx).await
}
async fn run_open_websocket_connection(
@@ -188,7 +188,7 @@ async fn run_open_websocket_connection(
>,
command_rx: mpsc::UnboundedReceiver<Command>,
event_tx: EventSender,
-) {
+) -> EventResult {
let (write, mut read) = stream.split();
let (writer_event_tx, mut writer_event_rx) = mpsc::unbounded_channel();
let (writer_control_tx, writer_control_rx) = mpsc::unbounded_channel();
@@ -215,12 +215,12 @@ async fn run_open_websocket_connection(
socket_id,
&mut pending_buffered_amount,
)
- .await;
- let _ = send_event(&event_tx, Event::TextMessage {
+ .await?;
+ send_event(&event_tx, Event::TextMessage {
socket_id,
data: text.to_string(),
})
- .await;
+ .await?;
}
Some(Ok(Message::Binary(data))) => {
send_next_buffered_amount(
@@ -228,12 +228,12 @@ async fn run_open_websocket_connection(
socket_id,
&mut pending_buffered_amount,
)
- .await;
- let _ = send_event(&event_tx, Event::BinaryMessage {
+ .await?;
+ send_event(&event_tx, Event::BinaryMessage {
socket_id,
data: data.to_vec(),
})
- .await;
+ .await?;
}
Some(Ok(Message::Close(frame))) => {
flush_pending_buffered_amount(
@@ -241,11 +241,11 @@ async fn run_open_websocket_connection(
socket_id,
&mut pending_buffered_amount,
)
- .await;
+ .await?;
let (code, reason) = frame
.map(|frame| (u16::from(frame.code), frame.reason.to_string()))
.unwrap_or((1005, String::new()));
- let _ = send_event(
+ send_event(
&event_tx,
Event::Close {
socket_id,
@@ -254,7 +254,7 @@ async fn run_open_websocket_connection(
was_clean: true,
},
)
- .await;
+ .await?;
break;
}
Some(Ok(Message::Ping(payload))) => {
@@ -283,7 +283,7 @@ async fn run_open_websocket_connection(
&mut pending_buffered_amount,
&mut writer_done,
)
- .await,
+ .await?,
WriterEventOutcome::Terminate
) {
// The drain itself surfaced a writer `Error` and
@@ -301,8 +301,8 @@ async fn run_open_websocket_connection(
socket_id,
&mut pending_buffered_amount,
)
- .await;
- let _ = send_event(
+ .await?;
+ send_event(
&event_tx,
Event::Close {
socket_id,
@@ -311,20 +311,20 @@ async fn run_open_websocket_connection(
was_clean: true,
},
)
- .await;
+ .await?;
} else {
flush_pending_buffered_amount(
&event_tx,
socket_id,
&mut pending_buffered_amount,
)
- .await;
+ .await?;
send_error_and_close(
&event_tx,
socket_id,
format!("WebSocket receive failed: {error}"),
)
- .await;
+ .await?;
}
break;
}
@@ -342,7 +342,7 @@ async fn run_open_websocket_connection(
&mut pending_buffered_amount,
&mut writer_done,
)
- .await,
+ .await?,
WriterEventOutcome::Terminate
) {
break;
@@ -352,12 +352,12 @@ async fn run_open_websocket_connection(
socket_id,
&mut pending_buffered_amount,
)
- .await;
+ .await?;
let (code, reason, was_clean) = sent_close
.clone()
.map(|(code, reason)| (code, reason, true))
.unwrap_or((1006, String::new(), false));
- let _ = send_event(
+ send_event(
&event_tx,
Event::Close {
socket_id,
@@ -366,7 +366,7 @@ async fn run_open_websocket_connection(
was_clean,
},
)
- .await;
+ .await?;
break;
}
}
@@ -385,7 +385,7 @@ async fn run_open_websocket_connection(
&mut pending_buffered_amount,
&mut writer_done,
)
- .await,
+ .await?,
WriterEventOutcome::Terminate
) {
break;
@@ -393,6 +393,7 @@ async fn run_open_websocket_connection(
}
}
}
+ Ok(())
}
enum WebSocketWriterEvent {
@@ -536,25 +537,26 @@ async fn send_next_buffered_amount(
event_tx: &EventSender,
socket_id: u64,
pending_buffered_amount: &mut VecDeque<usize>,
-) {
+) -> EventResult {
let Some(amount) = pending_buffered_amount.pop_front() else {
- return;
+ return Ok(());
};
- let _ = send_event(
+ send_event(
event_tx,
Event::BufferedAmountConsumed { socket_id, amount },
)
- .await;
+ .await
}
async fn flush_pending_buffered_amount(
event_tx: &EventSender,
socket_id: u64,
pending_buffered_amount: &mut VecDeque<usize>,
-) {
+) -> EventResult {
while !pending_buffered_amount.is_empty() {
- send_next_buffered_amount(event_tx, socket_id, pending_buffered_amount).await;
+ send_next_buffered_amount(event_tx, socket_id, pending_buffered_amount).await?;
}
+ Ok(())
}
/// Outcome of processing a single `WebSocketWriterEvent`. `Terminate` means
@@ -580,13 +582,13 @@ async fn handle_writer_event(
sent_close: &mut Option<(u16, String)>,
pending_buffered_amount: &mut VecDeque<usize>,
writer_done: &mut bool,
-) -> WriterEventOutcome {
+) -> EventResult<WriterEventOutcome> {
match writer_event {
WebSocketWriterEvent::FrameSent {
opcode,
payload_length,
} => {
- let _ = send_event(
+ send_event(
event_tx,
Event::FrameSent {
socket_id,
@@ -594,24 +596,24 @@ async fn handle_writer_event(
payload_length,
},
)
- .await;
+ .await?;
pending_buffered_amount.push_back(payload_length);
- WriterEventOutcome::Continue
+ Ok(WriterEventOutcome::Continue)
}
WebSocketWriterEvent::Closing { code, reason } => {
*sent_close = Some((code, reason));
- let _ = send_event(event_tx, Event::Closing { socket_id }).await;
- flush_pending_buffered_amount(event_tx, socket_id, pending_buffered_amount).await;
- WriterEventOutcome::Continue
+ send_event(event_tx, Event::Closing { socket_id }).await?;
+ flush_pending_buffered_amount(event_tx, socket_id, pending_buffered_amount).await?;
+ Ok(WriterEventOutcome::Continue)
}
WebSocketWriterEvent::Error(message) => {
- flush_pending_buffered_amount(event_tx, socket_id, pending_buffered_amount).await;
- send_error_and_close(event_tx, socket_id, message).await;
- WriterEventOutcome::Terminate
+ flush_pending_buffered_amount(event_tx, socket_id, pending_buffered_amount).await?;
+ send_error_and_close(event_tx, socket_id, message).await?;
+ Ok(WriterEventOutcome::Terminate)
}
WebSocketWriterEvent::Done => {
*writer_done = true;
- WriterEventOutcome::Continue
+ Ok(WriterEventOutcome::Continue)
}
}
}
@@ -637,7 +639,7 @@ async fn drain_pending_writer_events(
sent_close: &mut Option<(u16, String)>,
pending_buffered_amount: &mut VecDeque<usize>,
writer_done: &mut bool,
-) -> WriterEventOutcome {
+) -> EventResult<WriterEventOutcome> {
while let Ok(writer_event) = writer_event_rx.try_recv() {
if matches!(
handle_writer_event(
@@ -648,11 +650,11 @@ async fn drain_pending_writer_events(
pending_buffered_amount,
writer_done,
)
- .await,
+ .await?,
WriterEventOutcome::Terminate
) {
- return WriterEventOutcome::Terminate;
+ return Ok(WriterEventOutcome::Terminate);
}
}
- WriterEventOutcome::Continue
+ Ok(WriterEventOutcome::Continue)
}
diff --git a/moli-websocket/src/events.rs b/moli-websocket/src/events.rs
index 80c782ba8..c0de69db2 100644
--- a/moli-websocket/src/events.rs
+++ b/moli-websocket/src/events.rs
@@ -98,15 +98,26 @@ impl std::fmt::Debug for EventSender {
}
}
-pub(crate) async fn send_event(event_tx: &EventSender, event: Event) -> bool {
- event_tx.send(event).await
+#[derive(Debug)]
+pub(crate) struct EventSinkClosed;
+
+pub(crate) type EventResult<T = ()> = Result<T, EventSinkClosed>;
+
+pub(crate) async fn send_event(event_tx: &EventSender, event: Event) -> EventResult {
+ event_tx
+ .send(event)
+ .await
+ .then_some(())
+ .ok_or(EventSinkClosed)
}
-pub(crate) async fn send_error_and_close(event_tx: &EventSender, socket_id: u64, message: String) {
- if !send_event(event_tx, Event::Error { socket_id, message }).await {
- return;
- }
- let _ = send_event(
+pub(crate) async fn send_error_and_close(
+ event_tx: &EventSender,
+ socket_id: u64,
+ message: String,
+) -> EventResult {
+ send_event(event_tx, Event::Error { socket_id, message }).await?;
+ send_event(
event_tx,
Event::Close {
socket_id,
@@ -115,5 +126,5 @@ pub(crate) async fn send_error_and_close(event_tx: &EventSender, socket_id: u64,
was_clean: false,
},
)
- .await;
+ .await
}
diff --git a/moli-websocket/src/handshake.rs b/moli-websocket/src/handshake.rs
index c87452dfc..935c66fc8 100644
--- a/moli-websocket/src/handshake.rs
+++ b/moli-websocket/src/handshake.rs
@@ -1,87 +1,9 @@
-use tokio::{
- io::{AsyncReadExt, AsyncWriteExt},
- net::TcpStream,
-};
-use tokio_tungstenite::{
- MaybeTlsStream, WebSocketStream,
- tungstenite::{
- handshake::{client::Response, derive_accept_key},
- protocol::Role,
- },
-};
+//! Browser handshake validation, independent of the socket transport.
+use tokio_tungstenite::tungstenite::handshake::derive_accept_key;
-const MAX_WEBSOCKET_HANDSHAKE_RESPONSE_SIZE: usize = 64 * 1024;
+pub(crate) type HandshakeResponse = http::Response<()>;
-pub(crate) async fn browser_client_handshake(
- request: http::Request<()>,
- mut stream: MaybeTlsStream<TcpStream>,
-) -> Result<(WebSocketStream<MaybeTlsStream<TcpStream>>, Response), String> {
- write_handshake_request(&mut stream, &request).await?;
- let (response, tail) = read_handshake_response(&mut stream).await?;
- validate_handshake_response(&request, &response)?;
- let stream = WebSocketStream::from_partially_read(stream, tail, Role::Client, None).await;
- Ok((stream, response))
-}
-
-async fn write_handshake_request(
- stream: &mut MaybeTlsStream<TcpStream>,
- request: &http::Request<()>,
-) -> Result<(), String> {
- let request_target = request
- .uri()
- .path_and_query()
- .map(|path| path.as_str())
- .unwrap_or("/");
- let mut raw = format!("GET {request_target} HTTP/1.1\r\n").into_bytes();
- for (name, value) in request.headers() {
- raw.extend_from_slice(name.as_str().as_bytes());
- raw.extend_from_slice(b": ");
- raw.extend_from_slice(value.as_bytes());
- raw.extend_from_slice(b"\r\n");
- }
- raw.extend_from_slice(b"\r\n");
- stream
- .write_all(&raw)
- .await
- .map_err(|error| format!("failed to write WebSocket handshake request: {error}"))?;
- stream
- .flush()
- .await
- .map_err(|error| format!("failed to flush WebSocket handshake request: {error}"))
-}
-
-async fn read_handshake_response(
- stream: &mut MaybeTlsStream<TcpStream>,
-) -> Result<(Response, Vec<u8>), String> {
- let mut raw = Vec::new();
- let mut chunk = [0_u8; 512];
- loop {
- let count = stream
- .read(&mut chunk)
- .await
- .map_err(|error| format!("failed to read WebSocket handshake response: {error}"))?;
- if count == 0 {
- return Err("WebSocket server closed during handshake".to_owned());
- }
- raw.extend_from_slice(&chunk[..count]);
- if let Some(header_end) = find_header_end(&raw) {
- let tail = raw[header_end..].to_vec();
- let response = parse_handshake_response(&raw[..header_end - 4])?;
- return Ok((response, tail));
- }
- if raw.len() > MAX_WEBSOCKET_HANDSHAKE_RESPONSE_SIZE {
- return Err("WebSocket handshake response is too large".to_owned());
- }
- }
-}
-
-fn find_header_end(raw: &[u8]) -> Option<usize> {
- raw.windows(4)
- .position(|window| window == b"\r\n\r\n")
- .map(|position| position + 4)
-}
-
-fn parse_handshake_response(raw_headers: &[u8]) -> Result<Response, String> {
+pub(crate) fn parse_handshake_response(raw_headers: &[u8]) -> Result<HandshakeResponse, String> {
let headers = std::str::from_utf8(raw_headers)
.map_err(|error| format!("WebSocket handshake response is not UTF-8: {error}"))?;
let mut lines = headers.split("\r\n");
@@ -100,7 +22,7 @@ fn parse_handshake_response(raw_headers: &[u8]) -> Result<Response, String> {
.ok_or_else(|| "WebSocket handshake response is missing status code".to_owned())?
.parse::<u16>()
.map_err(|error| format!("WebSocket handshake response has invalid status: {error}"))?;
- let mut response = Response::new(None);
+ let mut response = HandshakeResponse::new(());
*response.status_mut() = http::StatusCode::from_u16(status)
.map_err(|error| format!("WebSocket handshake response has invalid status: {error}"))?;
@@ -126,9 +48,9 @@ fn parse_handshake_response(raw_headers: &[u8]) -> Result<Response, String> {
Ok(response)
}
-fn validate_handshake_response(
+pub(crate) fn validate_handshake_response(
request: &http::Request<()>,
- response: &Response,
+ response: &HandshakeResponse,
) -> Result<(), String> {
if response.status() != http::StatusCode::SWITCHING_PROTOCOLS {
return Err(format!(
@@ -176,7 +98,7 @@ fn header_values_contain_token(
fn validate_response_subprotocol(
request: &http::Request<()>,
- response: &Response,
+ response: &HandshakeResponse,
) -> Result<(), String> {
let selected_protocols = response
.headers()
diff --git a/moli-websocket/src/runtime.rs b/moli-websocket/src/runtime.rs
index ee855ce7c..f6480b7cf 100644
--- a/moli-websocket/src/runtime.rs
+++ b/moli-websocket/src/runtime.rs
@@ -18,7 +18,8 @@ pub fn spawn_connection(
let event_tx = event_tx.into();
let (command_tx, command_rx) = mpsc::unbounded_channel();
let task = websocket_runtime().spawn(async move {
- run_websocket_connection(socket_id, url, protocols, context, command_rx, event_tx).await;
+ let _ = run_websocket_connection(socket_id, url, protocols, context, command_rx, event_tx)
+ .await;
});
ConnectionHandle::new(command_tx, task.abort_handle())
}
@@ -31,7 +32,7 @@ pub fn spawn_failed_connection(
let event_tx = event_tx.into();
let (command_tx, _command_rx) = mpsc::unbounded_channel();
let task = websocket_runtime().spawn(async move {
- send_error_and_close(&event_tx, socket_id, message).await;
+ let _ = send_error_and_close(&event_tx, socket_id, message).await;
});
ConnectionHandle::new(command_tx, task.abort_handle())
}
@@ -46,7 +47,7 @@ pub fn spawn_synthetic_connection(
let event_tx = event_tx.into();
let (command_tx, command_rx) = mpsc::unbounded_channel();
let task = websocket_runtime().spawn(async move {
- run_synthetic_websocket_connection(
+ let _ = run_synthetic_websocket_connection(
socket_id,
command_rx,
event_tx,
diff --git a/moli-websocket/src/stream.rs b/moli-websocket/src/stream.rs
index 61877f0cb..36b7d3326 100644
--- a/moli-websocket/src/stream.rs
+++ b/moli-websocket/src/stream.rs
@@ -1,11 +1,12 @@
use tokio::net::TcpStream;
-use tokio_tungstenite::{
- MaybeTlsStream, WebSocketStream, tungstenite::handshake::client::Response,
-};
+use tokio_tungstenite::{MaybeTlsStream, WebSocketStream};
+
+mod handshake;
+use handshake::browser_client_handshake;
use crate::{
ConnectOptions,
- handshake::browser_client_handshake,
+ handshake::HandshakeResponse,
proxy::{
connect_websocket_via_http_proxy_tunnel, websocket_proxy_url, websocket_target_authority,
},
@@ -15,7 +16,13 @@ use crate::{
pub(crate) async fn open_websocket_stream(
request: http::Request<()>,
context: &ConnectOptions,
-) -> Result<(WebSocketStream<MaybeTlsStream<TcpStream>>, Response), String> {
+) -> Result<
+ (
+ WebSocketStream<MaybeTlsStream<TcpStream>>,
+ HandshakeResponse,
+ ),
+ String,
+> {
let proxy_url = websocket_proxy_url(request.uri(), context)?;
let tcp_stream = match proxy_url {
Some(proxy_url) => {
diff --git a/moli-websocket/src/stream/handshake.rs b/moli-websocket/src/stream/handshake.rs
new file mode 100644
index 000000000..e5ae8a339
--- /dev/null
+++ b/moli-websocket/src/stream/handshake.rs
@@ -0,0 +1,83 @@
+use crate::handshake::{HandshakeResponse, parse_handshake_response, validate_handshake_response};
+use tokio::{
+ io::{AsyncReadExt, AsyncWriteExt},
+ net::TcpStream,
+};
+use tokio_tungstenite::{MaybeTlsStream, WebSocketStream, tungstenite::protocol::Role};
+
+const MAX_WEBSOCKET_HANDSHAKE_RESPONSE_SIZE: usize = 64 * 1024;
+
+pub(crate) async fn browser_client_handshake(
+ request: http::Request<()>,
+ mut stream: MaybeTlsStream<TcpStream>,
+) -> Result<
+ (
+ WebSocketStream<MaybeTlsStream<TcpStream>>,
+ HandshakeResponse,
+ ),
+ String,
+> {
+ write_handshake_request(&mut stream, &request).await?;
+ let (response, tail) = read_handshake_response(&mut stream).await?;
+ validate_handshake_response(&request, &response)?;
+ let stream = WebSocketStream::from_partially_read(stream, tail, Role::Client, None).await;
+ Ok((stream, response))
+}
+
+async fn write_handshake_request(
+ stream: &mut MaybeTlsStream<TcpStream>,
+ request: &http::Request<()>,
+) -> Result<(), String> {
+ let request_target = request
+ .uri()
+ .path_and_query()
+ .map(|path| path.as_str())
+ .unwrap_or("/");
+ let mut raw = format!("GET {request_target} HTTP/1.1\r\n").into_bytes();
+ for (name, value) in request.headers() {
+ raw.extend_from_slice(name.as_str().as_bytes());
+ raw.extend_from_slice(b": ");
+ raw.extend_from_slice(value.as_bytes());
+ raw.extend_from_slice(b"\r\n");
+ }
+ raw.extend_from_slice(b"\r\n");
+ stream
+ .write_all(&raw)
+ .await
+ .map_err(|error| format!("failed to write WebSocket handshake request: {error}"))?;
+ stream
+ .flush()
+ .await
+ .map_err(|error| format!("failed to flush WebSocket handshake request: {error}"))
+}
+
+async fn read_handshake_response(
+ stream: &mut MaybeTlsStream<TcpStream>,
+) -> Result<(HandshakeResponse, Vec<u8>), String> {
+ let mut raw = Vec::new();
+ let mut chunk = [0_u8; 512];
+ loop {
+ let count = stream
+ .read(&mut chunk)
+ .await
+ .map_err(|error| format!("failed to read WebSocket handshake response: {error}"))?;
+ if count == 0 {
+ return Err("WebSocket server closed during handshake".to_owned());
+ }
+ raw.extend_from_slice(&chunk[..count]);
+ if let Some(header_end) = find_header_end(&raw) {
+ let tail = raw[header_end..].to_vec();
+ let response = parse_handshake_response(&raw[..header_end - 4])?;
+ return Ok((response, tail));
+ }
+ if raw.len() > MAX_WEBSOCKET_HANDSHAKE_RESPONSE_SIZE {
+ return Err("WebSocket handshake response is too large".to_owned());
+ }
+ }
+}
+
+fn find_header_end(raw: &[u8]) -> Option<usize> {
+ raw.windows(4)
+ .position(|window| window == b"\r\n\r\n")
+ .map(|position| position + 4)
+}
diff --git a/moli-websocket/src/synthetic.rs b/moli-websocket/src/synthetic.rs
index 9a414e5c9..d9da639dd 100644
--- a/moli-websocket/src/synthetic.rs
+++ b/moli-websocket/src/synthetic.rs
@@ -2,7 +2,7 @@ use tokio::sync::mpsc;
use crate::{
Command, Event, FrameOpcode,
- events::{EventSender, send_error_and_close, send_event},
+ events::{EventResult, EventSender, send_error_and_close, send_event},
limits::acquire_websocket_connection_slot,
};
@@ -13,15 +13,15 @@ pub(crate) async fn run_synthetic_websocket_connection(
request_headers: Vec<(String, String)>,
response_status: u16,
response_headers: Vec<(String, String)>,
-) {
+) -> EventResult {
let Some(_connection_slot) = acquire_websocket_connection_slot() else {
send_error_and_close(
&event_tx,
socket_id,
"WebSocket connection failed: insufficient resources".to_owned(),
)
- .await;
- return;
+ .await?;
+ return Ok(());
};
let protocol = response_header(&response_headers, "sec-websocket-protocol")
@@ -30,7 +30,7 @@ pub(crate) async fn run_synthetic_websocket_connection(
let extensions = response_header(&response_headers, "sec-websocket-extensions")
.unwrap_or_default()
.to_owned();
- let _ = send_event(
+ send_event(
&event_tx,
Event::Open {
socket_id,
@@ -41,13 +41,13 @@ pub(crate) async fn run_synthetic_websocket_connection(
response_headers,
},
)
- .await;
+ .await?;
while let Some(command) = command_rx.recv().await {
match command {
Command::SendText(text) => {
let amount = text.len();
- let _ = send_event(
+ send_event(
&event_tx,
Event::FrameSent {
socket_id,
@@ -55,16 +55,16 @@ pub(crate) async fn run_synthetic_websocket_connection(
payload_length: amount,
},
)
- .await;
- let _ = send_event(
+ .await?;
+ send_event(
&event_tx,
Event::BufferedAmountConsumed { socket_id, amount },
)
- .await;
+ .await?;
}
Command::SendBinary(bytes) => {
let amount = bytes.len();
- let _ = send_event(
+ send_event(
&event_tx,
Event::FrameSent {
socket_id,
@@ -72,23 +72,23 @@ pub(crate) async fn run_synthetic_websocket_connection(
payload_length: amount,
},
)
- .await;
- let _ = send_event(
+ .await?;
+ send_event(
&event_tx,
Event::BufferedAmountConsumed { socket_id, amount },
)
- .await;
+ .await?;
}
Command::ReceiveText(data) => {
- let _ = send_event(&event_tx, Event::TextMessage { socket_id, data }).await;
+ send_event(&event_tx, Event::TextMessage { socket_id, data }).await?;
}
Command::ReceiveBinary(data) => {
- let _ = send_event(&event_tx, Event::BinaryMessage { socket_id, data }).await;
+ send_event(&event_tx, Event::BinaryMessage { socket_id, data }).await?;
}
Command::ServerClose { code, reason } => {
let close_event_code = code.unwrap_or(1005);
let close_event_reason = code.map(|_| reason).unwrap_or_default();
- let _ = send_event(
+ send_event(
&event_tx,
Event::Close {
socket_id,
@@ -97,14 +97,14 @@ pub(crate) async fn run_synthetic_websocket_connection(
was_clean: true,
},
)
- .await;
- return;
+ .await?;
+ return Ok(());
}
Command::Close { code, reason } => {
let close_event_code = code.unwrap_or(1005);
let close_event_reason = code.map(|_| reason).unwrap_or_default();
- let _ = send_event(&event_tx, Event::Closing { socket_id }).await;
- let _ = send_event(
+ send_event(&event_tx, Event::Closing { socket_id }).await?;
+ send_event(
&event_tx,
Event::Close {
socket_id,
@@ -113,18 +113,18 @@ pub(crate) async fn run_synthetic_websocket_connection(
was_clean: true,
},
)
- .await;
- return;
+ .await?;
+ return Ok(());
}
Command::ContinueOpen { .. } => {}
Command::FailOpen(message) => {
- send_error_and_close(&event_tx, socket_id, message).await;
- return;
+ send_error_and_close(&event_tx, socket_id, message).await?;
+ return Ok(());
}
}
}
- let _ = send_event(
+ send_event(
&event_tx,
Event::Close {
socket_id,
@@ -133,7 +133,7 @@ pub(crate) async fn run_synthetic_websocket_connection(
was_clean: false,
},
)
- .await;
+ .await
}
fn response_header<'a>(headers: &'a [(String, String)], name: &str) -> Option<&'a str> {
diff --git a/moli-websocket/src/tests.rs b/moli-websocket/src/tests.rs
index 843e6f7b8..468170fd7 100644
--- a/moli-websocket/src/tests.rs
+++ b/moli-websocket/src/tests.rs
@@ -487,6 +487,119 @@ impl Drop for WebSocketSinkDropSignal {
}
}
+#[tokio::test]
+async fn websocket_rejected_handshake_or_open_event_releases_transport() {
+ use futures_util::StreamExt;
+
+ for pause_after_handshake in [false, true] {
+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+ let url = format!("ws://{}/closed-sink", listener.local_addr().unwrap());
+ let (command_tx, command_rx) = mpsc::unbounded_channel();
+ let mut context = test_websocket_context();
+ context.pause_after_handshake = pause_after_handshake;
+ let server = async move {
+ let (stream, _) = listener.accept().await.unwrap();
+ let mut socket = tokio_tungstenite::accept_async(stream).await.unwrap();
+ let terminal = socket.next().await;
+ assert!(terminal.is_none() || terminal.is_some_and(|result| result.is_err()));
+ };
+ let client = crate::connection::run_websocket_connection(
+ 64,
+ url,
+ Vec::new(),
+ context,
+ command_rx,
+ EventSender::closed(),
+ );
+ let (result, ()) = timeout(Duration::from_secs(3), async {
+ tokio::join!(client, server)
+ })
+ .await
+ .expect("a closed sink must release the connection before waiting for commands");
+ result.expect_err("delivery should report the unavailable sink");
+ assert!(command_tx.is_closed());
+ }
+}
+
+#[tokio::test]
+async fn websocket_rejected_message_event_releases_transport_and_writer() {
+ use futures_util::{SinkExt, StreamExt};
+
+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+ let url = format!(
+ "ws://{}/closed-message-sink",
+ listener.local_addr().unwrap()
+ );
+ let (command_tx, command_rx) = mpsc::unbounded_channel();
+ let sink =
+ EventSender::with_async_sink(
+ |event| async move { !matches!(event, Event::TextMessage { .. }) },
+ );
+ let server = async move {
+ let (stream, _) = listener.accept().await.unwrap();
+ let mut socket = tokio_tungstenite::accept_async(stream).await.unwrap();
+ socket.send("reject delivery".into()).await.unwrap();
+ let terminal = socket.next().await;
+ assert!(terminal.is_none() || terminal.is_some_and(|result| result.is_err()));
+ };
+ let client = crate::connection::run_websocket_connection(
+ 65,
+ url,
+ Vec::new(),
+ test_websocket_context(),
+ command_rx,
+ sink,
+ );
+ let (result, ()) = timeout(Duration::from_secs(3), async {
+ tokio::join!(client, server)
+ })
+ .await
+ .expect("message delivery rejection must stop both transport tasks");
+ result.expect_err("message sink is closed");
+ assert!(command_tx.is_closed());
+}
+
+#[tokio::test]
+async fn websocket_synthetic_delivery_stops_after_first_rejected_event() {
+ let (command_tx, command_rx) = mpsc::unbounded_channel();
+ command_tx
+ .send(Command::SendText("hello".to_owned()))
+ .unwrap();
+ let (observed_tx, mut observed_rx) = mpsc::unbounded_channel();
+ let sink = EventSender::with_async_sink(move |event| {
+ let observed_tx = observed_tx.clone();
+ async move {
+ let accept = matches!(event, Event::Open { .. });
+ observed_tx.send(event).unwrap();
+ accept
+ }
+ });
+ timeout(
+ Duration::from_secs(3),
+ crate::synthetic::run_synthetic_websocket_connection(
+ 66,
+ command_rx,
+ sink,
+ Vec::new(),
+ 101,
+ Vec::new(),
+ ),
+ )
+ .await
+ .expect("synthetic producer must stop when FrameSent is rejected")
+ .expect_err("synthetic event sink is closed");
+ assert!(command_tx.is_closed());
+ assert!(matches!(observed_rx.try_recv(), Ok(Event::Open { .. })));
+ assert!(matches!(
+ observed_rx.try_recv(),
+ Ok(Event::FrameSent { .. })
+ ));
+ assert!(
+ observed_rx.try_recv().is_err(),
+ "no further delivery attempts after rejection"
+ );
+}
+
#[tokio::test]
async fn websocket_cancel_releases_blocked_sink_and_open_writer() {
use futures_util::{SinkExt, StreamExt};