next-rust-server 0.1.11

The Next Rust runtime: HTTP server, request pipeline, SSR/streaming, ISR, middleware, static files and server actions.
Documentation
//! WebSockets (feature `websocket`).
//!
//! ```ignore
//! // app/api/chat/route.rs
//! pub async fn GET(req: Request) -> Response {
//!     upgrade(req, |mut socket| async move {
//!         while let Some(Ok(msg)) = socket.recv().await {
//!             if let Message::Text(t) = msg { let _ = socket.send(Message::Text(t)).await; }
//!         }
//!     })
//! }
//! ```

use std::future::Future;

use futures_util::{SinkExt, StreamExt};
use hyper_util::rt::TokioIo;
use tokio_tungstenite::WebSocketStream;
pub use tokio_tungstenite::tungstenite::Message;
use tokio_tungstenite::tungstenite::handshake::derive_accept_key;
use tokio_tungstenite::tungstenite::protocol::Role;

use crate::request::Request;
use crate::response::Response;

/// An upgraded WebSocket connection.
pub struct WebSocket {
    inner: WebSocketStream<TokioIo<hyper::upgrade::Upgraded>>,
}

impl WebSocket {
    /// Next message; `None` when the connection closed.
    pub async fn recv(&mut self) -> Option<Result<Message, crate::Error>> {
        self.inner.next().await.map(|r| r.map_err(crate::Error::from))
    }

    pub async fn send(&mut self, msg: Message) -> Result<(), crate::Error> {
        self.inner.send(msg).await.map_err(crate::Error::from)
    }

    pub async fn close(mut self) -> Result<(), crate::Error> {
        self.inner.close(None).await.map_err(crate::Error::from)
    }
}

/// Upgrade the request and run `handler` on the connection.
///
/// A browser upgrade from another site is refused with 403 (WebSockets are
/// not covered by the same-origin policy, and the connection would carry the
/// visitor's cookies); see [`Request::same_origin`].
pub fn upgrade<H, Fut>(mut req: Request, handler: H) -> Response
where
    H: FnOnce(WebSocket) -> Fut + Send + 'static,
    Fut: Future<Output = ()> + Send + 'static,
{
    let valid = req.is_websocket_upgrade()
        && req.header("connection").is_some_and(|c| c.to_ascii_lowercase().contains("upgrade"))
        && req.header("sec-websocket-version") == Some("13");
    let Some(key) = req.header("sec-websocket-key").map(str::to_owned).filter(|_| valid) else {
        return Response::text("expected a WebSocket upgrade request")
            .with_status(426)
            .with_header("upgrade", "websocket");
    };
    if !req.same_origin() {
        return Response::text("cross-site WebSocket refused").with_status(403);
    }
    let Some(on_upgrade) = req.parts_mut().extensions.remove::<hyper::upgrade::OnUpgrade>() else {
        return Response::text("connection cannot be upgraded").with_status(400);
    };
    tokio::spawn(async move {
        match on_upgrade.await {
            Ok(upgraded) => {
                let stream = WebSocketStream::from_raw_socket(TokioIo::new(upgraded), Role::Server, None).await;
                handler(WebSocket { inner: stream }).await;
            }
            Err(e) => crate::log::warn(&format!("websocket upgrade failed: {e}")),
        }
    });
    Response::status(101)
        .with_header("upgrade", "websocket")
        .with_header("connection", "upgrade")
        .with_header("sec-websocket-accept", &derive_accept_key(key.as_bytes()))
}

#[cfg(test)]
mod tests {
    use super::*;

    fn upgrade_request(origin: &str) -> Request {
        let req = http::Request::get("/ws")
            .header("host", "app.example")
            .header("origin", origin)
            .header("upgrade", "websocket")
            .header("connection", "Upgrade")
            .header("sec-websocket-version", "13")
            .header("sec-websocket-key", "dGhlIHNhbXBsZSBub25jZQ==")
            .body(bytes::Bytes::new())
            .unwrap();
        Request::from_http(req)
    }

    #[test]
    fn cross_site_upgrades_are_refused() {
        let res = upgrade(upgrade_request("https://evil.example"), |_socket| async {});
        assert_eq!(res.status.as_u16(), 403);
        // Same site: passes the origin check (the test request has no
        // connection to upgrade, so it stops at the next step).
        let res = upgrade(upgrade_request("https://app.example"), |_socket| async {});
        assert_eq!(res.status.as_u16(), 400);
    }
}