Struct evzht9h3nznqzwl::server::upgrade::WsUpgrade

pub struct WsUpgrade<S, B> where
    S: Stream,  {
    pub headers: Headers,
    pub stream: S,
    pub request: Request,
    pub buffer: B,
}

Intermediate representation of a half created websocket session. Should be used to examine the client's handshake accept the protocols requested, route the path, etc.

Users should then call accept or reject to complete the handshake and start a session. Note: if the stream in use is AsyncRead + AsyncWrite, then asynchronous functions will be available when completing the handshake. Otherwise if the stream is simply Read + Write blocking functions will be available to complete the handshake.

Fields

headers: Headers

The headers that will be used in the handshake response.

stream: S

The stream that will be used to read from / write to.

request: Request

The handshake request, filled with useful metadata.

buffer: B

Some buffered data from the stream, if it exists.

Methods

impl<S> WsUpgrade<S, Option<Buffer>> where
    S: Stream, 

These methods are the synchronous ways of accepting and rejecting a websocket handshake.

fn accept(self) -> Result<Client<S>, (S, Error)>

Accept the handshake request and send a response, if nothing goes wrong a client will be created.

fn accept_with(self, custom_headers: &Headers) -> Result<Client<S>, (S, Error)>

Accept the handshake request and send a response while adding on a few headers. These headers are added before the required headers are, so some might be overwritten.

fn reject(self) -> Result<S, (S, Error)>

Reject the client's request to make a websocket connection.

fn reject_with(self, headers: &Headers) -> Result<S, (S, Error)>

Reject the client's request to make a websocket connection and send extra headers.

impl<S, B> WsUpgrade<S, B> where
    S: Stream + AsTcpStream, 

fn tcp_stream(&self) -> &TcpStream

Get a handle to the underlying TCP stream, useful to be able to set TCP options, etc.

impl<S, B> WsUpgrade<S, B> where
    S: Stream, 

fn use_protocol<P>(self, protocol: P) -> Self where
    P: Into<String>, 

Select a protocol to use in the handshake response.

fn use_extension(self, extension: Extension) -> Self

Select an extension to use in the handshake response.

fn use_extensions<I>(self, extensions: I) -> Self where
    I: IntoIterator<Item = Extension>, 

Select multiple extensions to use in the connection

fn drop(self)

Drop the connection without saying anything.

fn protocols(&self) -> &[String]

A list of protocols requested from the client.

fn extensions(&self) -> &[Extension]

A list of extensions requested from the client.

fn key(&self) -> Option<&[u8; 16]>

The client's websocket accept key.

fn version(&self) -> Option<&WebSocketVersion>

The client's websocket version.

fn origin(&self) -> Option<&str>

Origin of the client