use crate::error::{Error, Result};
use crate::websocket::message::{CloseCode, Message};
use futures::{SinkExt, StreamExt};
use hyper::upgrade::Upgraded;
use hyper_util::rt::TokioIo;
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::Arc;
use std::time::Duration;
use tokio::time::{interval_at, Instant, Interval};
use tokio_tungstenite::tungstenite::error::ProtocolError;
use tokio_tungstenite::tungstenite::protocol::frame::CloseFrame;
use tokio_tungstenite::tungstenite::Error as TungError;
use tokio_tungstenite::tungstenite::protocol::{Role, WebSocketConfig};
use tokio_tungstenite::tungstenite::Message as TungMessage;
use tokio_tungstenite::WebSocketStream;
pub(crate) type UpgradedStream = WebSocketStream<TokioIo<Upgraded>>;
#[derive(Clone, Default)]
pub(crate) struct PeerActivity(Arc<AtomicU64>);
impl PeerActivity {
fn record(&self) {
self.0.fetch_add(1, Ordering::Relaxed);
}
pub(crate) fn mark(&self) -> u64 {
self.0.load(Ordering::Relaxed)
}
}
#[derive(Clone, Default)]
pub(crate) struct ReaderBusy(Arc<std::sync::atomic::AtomicBool>);
impl ReaderBusy {
pub(crate) fn is_busy(&self) -> bool {
self.0.load(Ordering::Acquire)
}
pub(crate) fn enter(&self) -> ReaderBusyGuard<'_> {
self.0.store(true, Ordering::Release);
ReaderBusyGuard(self)
}
}
pub(crate) struct ReaderBusyGuard<'a>(&'a ReaderBusy);
impl Drop for ReaderBusyGuard<'_> {
fn drop(&mut self) {
self.0 .0.store(false, Ordering::Release);
}
}
pub(crate) fn map_ws_error(error: tokio_tungstenite::tungstenite::Error) -> Error {
Error::WebSocket(error.to_string())
}
pub(crate) const CLOSE_HANDSHAKE_TIMEOUT: Duration = Duration::from_secs(5);
pub(crate) fn close_frame(code: CloseCode, reason: &str) -> CloseFrame {
use tokio_tungstenite::tungstenite::protocol::frame::coding::CloseCode as TungCode;
const MAX_REASON_BYTES: usize = 123;
let code = if TungCode::from(code.as_u16()).is_allowed() {
code
} else {
log::warn!("WebSocket close code {code} may not be sent on the wire; using 1000 instead");
CloseCode::NORMAL
};
let reason = if reason.len() > MAX_REASON_BYTES {
let mut end = MAX_REASON_BYTES;
while end > 0 && !reason.is_char_boundary(end) {
end -= 1;
}
&reason[..end]
} else {
reason
};
CloseFrame {
code: code.into(),
reason: reason.to_string().into(),
}
}
#[derive(Debug)]
pub(crate) enum Received {
Message(Message),
Closed(Option<CloseCode>),
Eof,
Failed(Error, CloseCode),
}
pub(crate) fn close_code_for(error: &TungError) -> CloseCode {
match error {
TungError::Capacity(_) => CloseCode::MESSAGE_TOO_BIG,
TungError::Utf8(_) => CloseCode::INVALID_PAYLOAD,
TungError::Protocol(ProtocolError::ResetWithoutClosingHandshake) => {
CloseCode::from_u16(1006)
}
TungError::Protocol(_) => CloseCode::PROTOCOL_ERROR,
TungError::Io(_) | TungError::ConnectionClosed | TungError::AlreadyClosed => {
CloseCode::from_u16(1006)
}
_ => CloseCode::INTERNAL_ERROR,
}
}
async fn close_for_error(stream: &mut UpgradedStream, error: &TungError) {
if matches!(
error,
TungError::ConnectionClosed | TungError::AlreadyClosed | TungError::Io(_)
) {
return;
}
let code = close_code_for(error);
send_close(stream, code, reason_for(code)).await;
}
async fn reject_non_json(stream: &mut UpgradedStream) {
if send_close(
stream,
CloseCode::UNSUPPORTED_DATA,
"this endpoint accepts JSON only",
)
.await
{
await_close_reply(stream).await;
}
}
pub(crate) async fn send_close(
stream: &mut UpgradedStream,
code: CloseCode,
reason: &str,
) -> bool {
let write = async {
let _ = stream
.send(TungMessage::Close(Some(close_frame(code, reason))))
.await;
let _ = SinkExt::flush(stream).await;
};
if tokio::time::timeout(CLOSE_HANDSHAKE_TIMEOUT, write).await.is_err() {
log::debug!("peer is not reading; abandoning the close frame");
return false;
}
true
}
pub(crate) async fn await_close_reply(stream: &mut UpgradedStream) {
let wait = async {
while let Some(frame) = stream.next().await {
match frame {
Ok(TungMessage::Close(_)) | Err(_) => break,
Ok(_) => continue,
}
}
};
if tokio::time::timeout(CLOSE_HANDSHAKE_TIMEOUT, wait).await.is_err() {
log::debug!("peer did not answer the close handshake within the timeout");
}
}
fn reason_for(code: CloseCode) -> &'static str {
match code {
CloseCode::MESSAGE_TOO_BIG => "message exceeds the configured limit",
CloseCode::INVALID_PAYLOAD => "text frame was not valid UTF-8",
CloseCode::PROTOCOL_ERROR => "WebSocket protocol violation",
_ => "internal error",
}
}
pub struct WebSocket {
stream: UpgradedStream,
ping: Option<Interval>,
json_only: bool,
activity: PeerActivity,
awaiting_pong: Option<u64>,
}
impl WebSocket {
pub(crate) async fn from_upgraded(
upgraded: Upgraded,
config: WebSocketConfig,
ping_interval: Option<Duration>,
json_only: bool,
) -> Self {
Self {
json_only,
activity: PeerActivity::default(),
awaiting_pong: None,
stream: WebSocketStream::from_raw_socket(
TokioIo::new(upgraded),
Role::Server,
Some(config),
)
.await,
ping: ping_interval.filter(|d| !d.is_zero()).map(|period| {
interval_at(Instant::now() + period, period)
}),
}
}
pub async fn recv(&mut self) -> Option<Result<Message>> {
let Self {
stream,
ping,
json_only,
activity,
awaiting_pong,
} = self;
let json_only = *json_only;
loop {
let message = match ping {
Some(interval) => {
tokio::select! {
biased;
message = stream.next() => message,
_ = interval.tick() => {
let mark = activity.mark();
if *awaiting_pong == Some(mark) {
log::debug!(
"WebSocket peer stopped answering keepalive pings; closing"
);
send_close(
stream,
CloseCode::GOING_AWAY,
"no response to keepalive",
)
.await;
return None;
}
if stream.send(TungMessage::Ping(Vec::new().into())).await.is_err() {
return None;
}
*awaiting_pong = Some(mark);
continue;
}
}
}
None => stream.next().await,
};
let message = message?;
activity.record();
match message {
Ok(TungMessage::Text(text)) => {
let message = Message::Text(text.as_str().to_string());
if json_only && !is_json(&message) {
reject_non_json(stream).await;
return None;
}
return Some(Ok(message));
}
Ok(TungMessage::Binary(bytes)) => {
let message = Message::Binary(bytes);
if json_only && !is_json(&message) {
reject_non_json(stream).await;
return None;
}
return Some(Ok(message));
}
Ok(TungMessage::Ping(_)) | Ok(TungMessage::Pong(_)) => continue,
Ok(TungMessage::Close(_)) => {
let _ = SinkExt::flush(stream).await;
return None;
}
Ok(TungMessage::Frame(_)) => continue,
Err(error) => {
close_for_error(stream, &error).await;
return Some(Err(map_ws_error(error)));
}
}
}
}
pub async fn send(&mut self, message: Message) -> Result<()> {
self.stream
.send(message.into())
.await
.map_err(map_ws_error)
}
pub async fn send_text<S: Into<String>>(&mut self, text: S) -> Result<()> {
self.send(Message::text(text)).await
}
pub async fn send_binary<B: Into<bytes::Bytes>>(&mut self, bytes: B) -> Result<()> {
self.send(Message::binary(bytes)).await
}
pub async fn send_json<T: serde::Serialize + ?Sized>(&mut self, value: &T) -> Result<()> {
self.send(Message::json(value)?).await
}
pub async fn close(mut self, code: CloseCode, reason: &str) -> Result<()> {
let send = async {
let result = self
.stream
.send(TungMessage::Close(Some(close_frame(code, reason))))
.await;
match result {
Ok(()) => match SinkExt::flush(&mut self.stream).await {
Ok(())
| Err(TungError::ConnectionClosed)
| Err(TungError::AlreadyClosed) => Some(Ok(())),
Err(error) => Some(Err(map_ws_error(error))),
},
Err(TungError::ConnectionClosed) | Err(TungError::AlreadyClosed) => None,
Err(TungError::Protocol(ProtocolError::SendAfterClosing)) => {
let _ = SinkExt::flush(&mut self.stream).await;
None
}
Err(error) => Some(Err(map_ws_error(error))),
}
};
let outcome = match tokio::time::timeout(CLOSE_HANDSHAKE_TIMEOUT, send).await {
Ok(Some(result)) => result,
Ok(None) => return Ok(()),
Err(_) => {
log::debug!("peer is not reading; abandoning the close frame");
return Ok(());
}
};
await_close_reply(&mut self.stream).await;
outcome
}
pub fn split(self) -> (WebSocketSender, WebSocketReceiver) {
let (sink, stream) = self.stream.split();
(
WebSocketSender {
sink,
activity: self.activity.clone(),
awaiting_pong: None,
},
WebSocketReceiver {
stream,
activity: self.activity,
},
)
}
}
pub struct WebSocketSender {
sink: futures::stream::SplitSink<UpgradedStream, TungMessage>,
activity: PeerActivity,
awaiting_pong: Option<u64>,
}
impl WebSocketSender {
pub async fn send(&mut self, message: Message) -> Result<()> {
self.sink.send(message.into()).await.map_err(map_ws_error)
}
pub async fn send_text<S: Into<String>>(&mut self, text: S) -> Result<()> {
self.send(Message::text(text)).await
}
pub async fn send_binary<B: Into<bytes::Bytes>>(&mut self, bytes: B) -> Result<()> {
self.send(Message::binary(bytes)).await
}
pub async fn send_json<T: serde::Serialize + ?Sized>(&mut self, value: &T) -> Result<()> {
self.send(Message::json(value)?).await
}
pub(crate) async fn ping_and_check(&mut self, reader_busy: &ReaderBusy) -> Result<bool> {
let mark = self.activity.mark();
if reader_busy.is_busy() {
self.awaiting_pong = None;
} else if let Some(previous) = self.awaiting_pong {
if previous == mark {
return Ok(false);
}
}
self.sink
.send(TungMessage::Ping(bytes::Bytes::new()))
.await
.map_err(map_ws_error)?;
self.awaiting_pong = Some(mark);
Ok(true)
}
pub async fn close(&mut self, code: CloseCode, reason: &str) -> Result<()> {
let result = self
.sink
.send(TungMessage::Close(Some(close_frame(code, reason))))
.await;
match result {
Ok(()) => match SinkExt::flush(&mut self.sink).await {
Ok(()) | Err(TungError::ConnectionClosed) | Err(TungError::AlreadyClosed) => Ok(()),
Err(error) => Err(map_ws_error(error)),
},
Err(TungError::ConnectionClosed) | Err(TungError::AlreadyClosed) => Ok(()),
Err(TungError::Protocol(ProtocolError::SendAfterClosing)) => {
let _ = SinkExt::flush(&mut self.sink).await;
Ok(())
}
Err(error) => Err(map_ws_error(error)),
}
}
}
pub struct WebSocketReceiver {
stream: futures::stream::SplitStream<UpgradedStream>,
activity: PeerActivity,
}
impl WebSocketReceiver {
pub async fn recv(&mut self) -> Option<Result<Message>> {
match self.receive().await {
Received::Message(message) => Some(Ok(message)),
Received::Failed(error, _) => Some(Err(error)),
Received::Closed(_) | Received::Eof => None,
}
}
pub(crate) async fn receive(&mut self) -> Received {
loop {
let Some(next) = self.stream.next().await else {
return Received::Eof;
};
self.activity.record();
match next {
Ok(TungMessage::Text(text)) => {
return Received::Message(Message::Text(text.as_str().to_string()))
}
Ok(TungMessage::Binary(bytes)) => {
return Received::Message(Message::Binary(bytes))
}
Ok(TungMessage::Ping(_)) | Ok(TungMessage::Pong(_)) => continue,
Ok(TungMessage::Close(frame)) => {
return Received::Closed(frame.map(|frame| frame.code.into()))
}
Ok(TungMessage::Frame(_)) => continue,
Err(TungError::ConnectionClosed) | Err(TungError::AlreadyClosed) => {
return Received::Eof
}
Err(error) => {
let code = close_code_for(&error);
return Received::Failed(map_ws_error(error), code);
}
}
}
}
}
pub(crate) fn is_json(message: &Message) -> bool {
serde_json::from_slice::<serde_json::Value>(message.as_bytes()).is_ok()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_reason_longer_than_the_control_frame_allows_is_truncated() {
let frame = close_frame(CloseCode::NORMAL, &"x".repeat(500));
assert_eq!(frame.reason.as_str().len(), 123);
}
#[test]
fn truncation_lands_on_a_character_boundary() {
let reason = "é".repeat(62);
let frame = close_frame(CloseCode::NORMAL, &reason);
assert_eq!(frame.reason.as_str().len(), 122);
assert!(frame.reason.as_str().chars().all(|c| c == 'é'));
}
#[test]
fn a_short_reason_is_left_alone() {
let frame = close_frame(CloseCode::GOING_AWAY, "server shutting down");
assert_eq!(frame.reason.as_str(), "server shutting down");
assert_eq!(u16::from(frame.code), 1001);
}
#[test]
fn codes_that_may_not_be_sent_become_1000() {
for reserved in [1005u16, 1006, 1015] {
let frame = close_frame(CloseCode::from_u16(reserved), "");
assert_eq!(
u16::from(frame.code),
1000,
"{reserved} must not be sent as-is"
);
}
}
#[test]
fn application_close_codes_pass_through() {
let frame = close_frame(CloseCode::from_u16(4001), "app specific");
assert_eq!(u16::from(frame.code), 4001);
}
#[test]
fn json_detection_covers_both_frame_types() {
assert!(is_json(&Message::text(r#"{"a":1}"#)));
assert!(is_json(&Message::binary(br#"[1,2]"#.to_vec())));
assert!(!is_json(&Message::text("not json")));
assert!(!is_json(&Message::binary(vec![0xff, 0xfe])));
}
#[test]
fn peer_activity_changes_only_when_something_arrives() {
let activity = PeerActivity::default();
let before = activity.mark();
assert_eq!(activity.mark(), before, "reading must not count as activity");
activity.record();
assert_ne!(activity.mark(), before);
}
}