Crate soket[−][src]

An implementation of the RFC 6455 websocket protocol.

To begin a websocket connection one first needs to perform a handshake, either as client or server, in order to upgrade from HTTP. Once successful, the client or server can transition to a connection, i.e. a Sender/Receiver pair and send and receive textual or binary data.

Note: While it is possible to only receive websocket messages it is not possible to only send websocket messages. Receiving data is required in order to react to control frames such as PING or CLOSE. While those will be answered transparently they have to be received in the first place, so calling connection::Receiver::receive is imperative.

Note: None of the async methods are safe to cancel so their Futures must not be dropped unless they return Poll::Ready.

Client example

use soket::handshake::{Client, ServerResponse};

// First, we need to establish a TCP connection.
let socket = tokio::net::TcpStream::connect("...").await?;

// Then we configure the client handshake.
let mut client = Client::new(socket.compat(), "...", "/");

// And finally we perform the handshake and handle the result.
let (mut sender, mut receiver) = match client.handshake().await? {
    ServerResponse::Accepted { .. } => client.into_builder().finish(),
    ServerResponse::Redirect { status_code, location } => unimplemented!("follow location URL"),
    ServerResponse::Rejected { status_code } => unimplemented!("handle failure")
};

// Over the established websocket connection we can send
sender.send_text("some text").await?;
sender.send_text("some more text").await?;
sender.flush().await?;

// ... and receive data.
let mut data = Vec::new();
receiver.receive_data(&mut data).await?;

Server example

use soket::{handshake::{Server, ClientRequest, server::Response}};

// First, we listen for incoming connections.
let mut listener = tokio::net::TcpListener::bind("...").await?;
let mut incoming = listener.incoming();

while let Some(socket) = incoming.next().await {
    // For each incoming connection we perform a handshake.
    let mut server = Server::new(socket?.compat());

    let websocket_key = {
        let req = server.receive_request().await?;
        req.into_key()
    };

    // Here we accept the client unconditionally.
    let accept = Response::Accept { key: &websocket_key, protocol: None };
    server.send_response(&accept).await?;

    // And we can finally transition to a websocket connection.
    let (mut sender, mut receiver) = server.into_builder().finish();

    let mut data = Vec::new();
    let data_type = receiver.receive_data(&mut data).await?;

    if data_type.is_text() {
        sender.send_text(std::str::from_utf8(&data)?).await?
    } else {
        sender.send_binary(&data).await?
    }

    sender.close().await?
}

Re-exports

pub use connection::Mode;

pub use connection::Receiver;

pub use connection::Sender;

pub use data::Data;

pub use data::Incoming;

Modules

base	A websocket base frame codec.
connection	A persistent websocket connection after the handshake phase, represented as a `Sender` and `Receiver` pair.
data	Types describing various forms of payload data.
extension	Websocket extensions as per RFC 6455.
handshake	Websocket handshakes.

Enums

Parsing	A parsing result.
Storage	A buffer type used for implementing `Extension`s.

Type Definitions

BoxedError