Struct WebSocket 

pub struct WebSocket;

Available on non-WebAssembly only.

WebSocket protocol utilities.

Implementations

impl WebSocket

pub fn upgrade<F>(request: &Request, handler: F) -> Response

where F: FnOnce(WebSocketConnection) + Send + 'static,

Answer a WebSocket upgrade request: returns the 101 response to return from the handler, and runs handler with the connection once it’s sent. A request that isn’t a valid upgrade (or comes over HTTP/2 or HTTP/3) gets 426 Upgrade Required and handler never runs.

use rust_web_server::app::App;
use rust_web_server::websocket::{Message, WebSocket};

let app = App::with_state(()).get("/echo", |request, _params, _conn, _state| {
    WebSocket::upgrade(request, |mut ws| {
        while let Ok(Some(message)) = ws.recv() {
            let _ = match message {
                Message::Text(text) => ws.send_text(&text),
                Message::Binary(data) => ws.send_binary(&data),
            };
        }
    })
});

impl WebSocket

pub const MAX_FRAME_PAYLOAD: u64

The largest frame payload WebSocket::read_frame accepts (16 MiB); a frame claiming more is an error. Use WebSocket::read_frame_limited for another limit.

pub fn is_upgrade_request(request: &Request) -> bool

Returns true if request is a valid WebSocket upgrade request (has Upgrade: websocket, Connection: upgrade, and Sec-WebSocket-Key).

pub fn handshake_response(request: &Request) -> Result<Response, String>

Build the HTTP 101 Switching Protocols response for a WebSocket opening handshake. Returns an error if Sec-WebSocket-Key is absent.

Write the raw bytes from Response::generate_response to the stream, then transition to frame-level I/O with WebSocket::read_frame / WebSocket::write_frame.

pub fn accept_key(client_key: &str) -> String

Compute the Sec-WebSocket-Accept value from the client’s Sec-WebSocket-Key using SHA-1 and base64 as specified in RFC 6455.

pub fn read_frame(stream: &mut impl Read) -> Result<Frame, String>

Read one WebSocket frame from stream.

Handles client-to-server masking automatically. Returns an error if the stream closes unexpectedly or contains a protocol violation.

A frame whose declared payload exceeds WebSocket::MAX_FRAME_PAYLOAD is refused before any of it is read: the length comes from the peer, and allocating it up front (up to 2^64 − 1 bytes) aborted the process.

pub fn read_frame_limited( stream: &mut impl Read, max_payload: u64, ) -> Result<Frame, String>

WebSocket::read_frame with max_payload bytes as the limit. The payload is read as it arrives, so memory follows what the peer actually sends, not what it claims.

pub fn write_frame(stream: &mut impl Write, frame: Frame) -> Result<(), String>

Write a WebSocket frame to stream (server→client, unmasked).

pub fn send_text(stream: &mut impl Write, text: &str) -> Result<(), String>

Convenience: send a text message.

pub fn send_close( stream: &mut impl Write, code: u16, reason: &str, ) -> Result<(), String>

Convenience: send a close frame with a status code and reason.

pub fn send_pong( stream: &mut impl Write, payload: Vec<u8>, ) -> Result<(), String>

Convenience: reply to a ping with a pong carrying the same payload.