use futures::{SinkExt, StreamExt};
use rustf::prelude::*;
use std::net::SocketAddr;
use std::time::Duration;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpStream;
use tokio_tungstenite::tungstenite::client::IntoClientRequest;
use tokio_tungstenite::tungstenite::protocol::frame::coding::CloseCode;
use tokio_tungstenite::tungstenite::Message as ClientMessage;
type ClientItem = std::result::Result<ClientMessage, tokio_tungstenite::tungstenite::Error>;
async fn echo(ctx: &mut Context) -> rustf::Result<()> {
ctx.websocket(|mut socket| async move {
while let Some(message) = socket.recv().await {
socket.send(message?).await?;
}
Ok(())
})
}
async fn greet(ctx: &mut Context) -> rustf::Result<()> {
let name = ctx.param_str("name").unwrap_or_default();
ctx.websocket(move |mut socket| async move {
socket.send_text(format!("hello {name}")).await?;
while socket.recv().await.is_some() {}
Ok(())
})
}
async fn guarded(ctx: &mut Context) -> rustf::Result<()> {
ctx.require_auth()?;
ctx.websocket(|mut socket| async move {
while socket.recv().await.is_some() {}
Ok(())
})
}
async fn json_only(ctx: &mut Context) -> rustf::Result<()> {
ctx.websocket(|mut socket| async move {
while let Some(message) = socket.recv().await {
socket.send(message?).await?;
}
Ok(())
})
}
async fn small(ctx: &mut Context) -> rustf::Result<()> {
ctx.websocket(|mut socket| async move {
while let Some(message) = socket.recv().await {
socket.send(message?).await?;
}
Ok(())
})
}
async fn not_a_socket(ctx: &mut Context) -> rustf::Result<()> {
ctx.websocket(|mut socket| async move {
while socket.recv().await.is_some() {}
Ok(())
})
}
async fn page(ctx: &mut Context) -> rustf::Result<()> {
ctx.plain("chat page")
}
fn install_routes() -> Vec<Route> {
routes![
GET "/chat" => page,
GET "/mistake" => not_a_socket,
SOCKET "/echo" => echo,
SOCKET "/greet/{name}" => greet,
SOCKET "/guarded" => guarded,
SOCKET "/json" => json_only, [json],
SOCKET "/small" => small, [max = 64],
]
}
async fn http_get(addr: SocketAddr, path: &str, extra_headers: &str) -> String {
let mut stream = TcpStream::connect(addr).await.unwrap();
let request = format!("GET {path} HTTP/1.1\r\nHost: {addr}\r\n{extra_headers}\r\n");
stream.write_all(request.as_bytes()).await.unwrap();
let mut response = Vec::new();
let mut byte = [0u8; 1];
let read = async {
loop {
match stream.read(&mut byte).await.unwrap() {
0 => break,
_ => {
response.push(byte[0]);
if response.ends_with(b"\r\n\r\n") {
break;
}
}
}
}
};
tokio::time::timeout(Duration::from_secs(5), read)
.await
.unwrap_or_else(|_| panic!("timed out reading the response head for {path}"));
String::from_utf8_lossy(&response).into_owned()
}
fn status_line(response: &str) -> &str {
response.lines().next().unwrap_or("")
}
async fn connect(
addr: SocketAddr,
path: &str,
) -> tokio_tungstenite::WebSocketStream<tokio_tungstenite::MaybeTlsStream<TcpStream>> {
let (socket, _) = tokio_tungstenite::connect_async(format!("ws://{addr}{path}"))
.await
.unwrap_or_else(|e| panic!("connecting to {path} failed: {e}"));
socket
}
async fn next_message<S>(socket: &mut S) -> Option<ClientMessage>
where
S: StreamExt<Item = ClientItem> + Unpin,
{
match tokio::time::timeout(Duration::from_secs(5), socket.next()).await {
Ok(Some(Ok(message))) => Some(message),
Ok(Some(Err(error))) => panic!("socket error: {error}"),
Ok(None) => None,
Err(_) => panic!("timed out waiting for a message"),
}
}
async fn close_code<S>(socket: &mut S) -> Option<CloseCode>
where
S: StreamExt<Item = ClientItem> + Unpin,
{
let mut code = None;
loop {
match tokio::time::timeout(Duration::from_secs(5), socket.next()).await {
Ok(Some(Ok(ClientMessage::Close(frame)))) => {
code = frame.map(|f| f.code);
continue;
}
Ok(Some(Ok(_))) => continue,
Ok(Some(Err(_))) | Ok(None) => return code,
Err(_) => panic!("timed out waiting for a close frame"),
}
}
}
#[tokio::test]
async fn websocket_routes_behave_correctly_on_the_wire() {
let app = RustF::new().controllers(install_routes());
let running = app.serve_with_handle("127.0.0.1:0").await.unwrap();
let addr = running.local_addr;
let response = http_get(addr, "/chat", "").await;
assert!(
status_line(&response).starts_with("HTTP/1.1 200"),
"{response}"
);
let response = http_get(addr, "/echo", "").await;
assert!(
status_line(&response).starts_with("HTTP/1.1 426"),
"a non-handshake GET on a SOCKET route must be 426: {response}"
);
assert!(
response.to_lowercase().contains("upgrade: websocket"),
"426 must advertise the protocol to switch to: {response}"
);
assert!(
response
.to_lowercase()
.contains("sec-websocket-version: 13"),
"426 must advertise the supported version: {response}"
);
let response = http_get(
addr,
"/echo",
"Upgrade: websocket\r\nConnection: Upgrade\r\n\
Sec-WebSocket-Version: 8\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n",
)
.await;
assert!(
status_line(&response).starts_with("HTTP/1.1 426"),
"an unsupported version must be refused: {response}"
);
let response = http_get(
addr,
"/echo",
"Upgrade: websocket\r\nConnection: Upgrade\r\n\
Sec-WebSocket-Version: 13\r\nSec-WebSocket-Key: nope\r\n",
)
.await;
assert!(
status_line(&response).starts_with("HTTP/1.1 400"),
"a malformed Sec-WebSocket-Key must be refused: {response}"
);
let response = http_get(
addr,
"/echo",
"Upgrade: websocket\r\nConnection: Upgrade\r\n\
Sec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n\
Origin: http://evil.example\r\n",
)
.await;
assert!(
status_line(&response).starts_with("HTTP/1.1 403"),
"a cross-origin handshake must be refused: {response}"
);
let response = http_get(
addr,
"/echo",
&format!(
"Upgrade: websocket\r\nConnection: Upgrade\r\n\
Sec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n\
Origin: http://{addr}\r\n"
),
)
.await;
assert!(
status_line(&response).starts_with("HTTP/1.1 101"),
"a same-origin handshake must be accepted: {response}"
);
assert!(
response.contains("s3pPLMBiTxaQ9kYGzzhZRbK+xOo="),
"the 101 must carry the RFC-derived Sec-WebSocket-Accept: {response}"
);
let response = http_get(
addr,
"/guarded",
"Upgrade: websocket\r\nConnection: Upgrade\r\n\
Sec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n",
)
.await;
assert!(
status_line(&response).starts_with("HTTP/1.1 401"),
"an auth check must reject before the upgrade: {response}"
);
let response = http_get(
addr,
"/echo",
"Upgrade: websocket\r\nConnection: Upgrade\r\n\
Sec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n\
Origin: http://evil.example\r\nOrigin: http://example.com\r\n",
)
.await;
assert!(
status_line(&response).starts_with("HTTP/1.1 400"),
"a duplicated Origin must be refused, not silently resolved: {response}"
);
let response = http_get(
addr,
"/echo",
"Upgrade: websocket\r\nConnection: Upgrade\r\n\
Sec-WebSocket-Version: 13\r\n\
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n\
Sec-WebSocket-Key: AAAAAAAAAAAAAAAAAAAAAA==\r\n",
)
.await;
assert!(
status_line(&response).starts_with("HTTP/1.1 400"),
"a duplicated Sec-WebSocket-Key must be refused: {response}"
);
let response = http_get(
addr,
"/mistake",
"Upgrade: websocket\r\nConnection: Upgrade\r\n\
Sec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n",
)
.await;
assert!(
status_line(&response).starts_with("HTTP/1.1 500"),
"asking for a socket from a GET route must fail loudly: {response}"
);
let mut socket = connect(addr, "/echo").await;
socket
.send(ClientMessage::Text("hello".into()))
.await
.unwrap();
assert_eq!(
next_message(&mut socket).await,
Some(ClientMessage::Text("hello".into()))
);
socket
.send(ClientMessage::Binary(vec![1, 2, 3].into()))
.await
.unwrap();
match next_message(&mut socket).await {
Some(ClientMessage::Binary(bytes)) => assert_eq!(&bytes[..], &[1, 2, 3]),
other => panic!("expected the binary frame back, got {other:?}"),
}
socket.close(None).await.unwrap();
while next_message(&mut socket).await.is_some() {}
let mut socket = connect(addr, "/greet/morle").await;
assert_eq!(
next_message(&mut socket).await,
Some(ClientMessage::Text("hello morle".into()))
);
socket.close(None).await.unwrap();
let mut socket = connect(addr, "/json").await;
socket
.send(ClientMessage::Text(r#"{"a":1}"#.into()))
.await
.unwrap();
assert_eq!(
next_message(&mut socket).await,
Some(ClientMessage::Text(r#"{"a":1}"#.into()))
);
socket
.send(ClientMessage::Text("not json".into()))
.await
.unwrap();
assert_eq!(
close_code(&mut socket).await,
Some(CloseCode::Unsupported),
"non-JSON text on a [json] route must close with 1003"
);
let mut socket = connect(addr, "/small").await;
socket
.send(ClientMessage::Text("x".repeat(16).into()))
.await
.unwrap();
assert_eq!(
next_message(&mut socket).await,
Some(ClientMessage::Text("x".repeat(16).into())),
"a message within the cap must still be echoed"
);
socket
.send(ClientMessage::Text("x".repeat(256).into()))
.await
.unwrap();
assert_eq!(
close_code(&mut socket).await,
Some(CloseCode::Size),
"a message over the route's [max] must close with 1009"
);
assert_handshake_response_is_correct(addr).await;
running.handle.shutdown().await.unwrap();
}
async fn assert_handshake_response_is_correct(addr: SocketAddr) {
use base64::Engine as _;
use sha1::Digest as _;
let request = format!("ws://{addr}/echo").into_client_request().unwrap();
assert_eq!(
request.headers().get("sec-websocket-version").unwrap(),
"13",
"a client must ask for version 13"
);
let key = request
.headers()
.get("sec-websocket-key")
.expect("a client must send a key")
.to_str()
.unwrap()
.to_string();
let mut hasher = sha1::Sha1::new();
hasher.update(key.as_bytes());
hasher.update(b"258EAFA5-E914-47DA-95CA-C5AB0DC85B11");
let expected = base64::engine::general_purpose::STANDARD.encode(hasher.finalize());
let response = http_get(
addr,
"/echo",
&format!(
"Upgrade: websocket\r\nConnection: Upgrade\r\n\
Sec-WebSocket-Version: 13\r\nSec-WebSocket-Key: {key}\r\n"
),
)
.await;
assert!(
status_line(&response).starts_with("HTTP/1.1 101"),
"a well-formed handshake must be accepted: {response}"
);
let lower = response.to_lowercase();
assert!(lower.contains("upgrade: websocket"), "{response}");
assert!(lower.contains("connection: upgrade"), "{response}");
assert!(
response.contains(&expected),
"the 101 must carry the accept key derived from this client's key: {response}"
);
assert!(
!lower.contains("sec-websocket-extensions"),
"nothing negotiated an extension: {response}"
);
}