websocketpp::processor::hybi13< config > Class Template Reference

Processor for Hybi version 13 (RFC6455) More...

#include <hybi13.hpp>

Inheritance diagram for websocketpp::processor::hybi13< config >:

Collaboration diagram for websocketpp::processor::hybi13< config >:

Classes
struct	msg_metadata

Public Types
typedef processor< config >	base
typedef config::request_type	request_type
typedef config::response_type	response_type
typedef config::message_type	message_type
typedef message_type::ptr	message_ptr
typedef config::con_msg_manager_type	msg_manager_type
typedef msg_manager_type::ptr	msg_manager_ptr
typedef config::rng_type	rng_type
typedef config::permessage_deflate_type	permessage_deflate_type
typedef std::pair< lib::error_code, std::string >	err_str_pair
Public Types inherited from websocketpp::processor::processor< config >
typedef processor< config >	type
typedef config::request_type	request_type
typedef config::response_type	response_type
typedef config::message_type::ptr	message_ptr
typedef std::pair< lib::error_code, std::string >	err_str_pair

Public Member Functions
	hybi13 (bool secure, bool p_is_server, msg_manager_ptr manager, rng_type &rng)
int	get_version () const
	Get the protocol version of this processor.
bool	has_permessage_deflate () const
err_str_pair	negotiate_extensions (request_type const &request)
	Initializes extensions based on the Sec-WebSocket-Extensions header.
err_str_pair	negotiate_extensions (response_type const &response)
	Initializes extensions based on the Sec-WebSocket-Extensions header.
template<typename header_type >
err_str_pair	negotiate_extensions_helper (header_type const &header)
	Extension negotiation helper function.
lib::error_code	validate_handshake (request_type const &r) const
	validate a WebSocket handshake request for this version
lib::error_code	process_handshake (request_type const &request, std::string const &subprotocol, response_type &response) const
	Calculate the appropriate response for this websocket request.
lib::error_code	client_handshake_request (request_type &req, uri_ptr uri, std::vector< std::string > const &subprotocols) const
	Fill in a set of request headers for a client connection request.
lib::error_code	validate_server_handshake_response (request_type const &req, response_type &res) const
	Validate the server's response to an outgoing handshake request.
std::string	get_raw (response_type const &res) const
	Given a completed response, get the raw bytes to put on the wire.
std::string const &	get_origin (request_type const &r) const
	Return the value of the header containing the CORS origin.
lib::error_code	extract_subprotocols (request_type const &req, std::vector< std::string > &subprotocol_list)
	Extracts requested subprotocols from a handshake request.
uri_ptr	get_uri (request_type const &request) const
	Extracts client uri from a handshake request.
size_t	consume (uint8_t *buf, size_t len, lib::error_code &ec)
	Process new websocket connection bytes.
lib::error_code	finalize_message ()
	Perform any finalization actions on an incoming message.
void	reset_headers ()
bool	ready () const
	Test whether or not the processor has a message ready.
message_ptr	get_message ()
	Retrieves the most recently processed message.
bool	get_error () const
	Test whether or not the processor is in a fatal error state.
size_t	get_bytes_needed () const
virtual lib::error_code	prepare_data_frame (message_ptr in, message_ptr out)
	Prepare a user data message for writing.
lib::error_code	prepare_ping (std::string const &in, message_ptr out) const
	Get URI.
lib::error_code	prepare_pong (std::string const &in, message_ptr out) const
virtual lib::error_code	prepare_close (close::status::value code, std::string const &reason, message_ptr out) const
Public Member Functions inherited from websocketpp::processor::processor< config >
	processor (bool secure, bool p_is_server)
virtual	~processor ()
size_t	get_max_message_size () const
	Get maximum message size.
void	set_max_message_size (size_t new_value)
	Set maximum message size.
virtual bool	has_permessage_compress () const
	Returns whether or not the permessage_compress extension is implemented.
virtual lib::error_code	prepare_data_frame (message_ptr in, message_ptr out)=0
	Prepare a data message for writing.
virtual lib::error_code	prepare_ping (std::string const &in, message_ptr out) const =0
	Prepare a ping frame.
virtual lib::error_code	prepare_pong (std::string const &in, message_ptr out) const =0
	Prepare a pong frame.
virtual lib::error_code	prepare_close (close::status::value code, std::string const &reason, message_ptr out) const =0
	Prepare a close frame.

Protected Types
enum	state {   HEADER_BASIC = 0 , HEADER_EXTENDED = 1 , EXTENSION = 2 , APPLICATION = 3 ,   READY = 4 , FATAL_ERROR = 5 }

Protected Member Functions
lib::error_code	process_handshake_key (std::string &key) const
	Convert a client handshake key into a server response key in place.
size_t	copy_basic_header_bytes (uint8_t const *buf, size_t len)
	Reads bytes from buf into m_basic_header.
size_t	copy_extended_header_bytes (uint8_t const *buf, size_t len)
	Reads bytes from buf into m_extended_header.
size_t	process_payload_bytes (uint8_t *buf, size_t len, lib::error_code &ec)
	Reads bytes from buf into message payload.
lib::error_code	validate_incoming_basic_header (frame::basic_header const &h, bool is_server, bool new_msg) const
	Validate an incoming basic header.
lib::error_code	validate_incoming_extended_header (frame::basic_header h, frame::extended_header e) const
	Validate an incoming extended header.
void	masked_copy (std::string const &i, std::string &o, frame::masking_key_type key) const
	Copy and mask/unmask in one operation.
lib::error_code	prepare_control (frame::opcode::value op, std::string const &payload, message_ptr out) const
	Generic prepare control frame with opcode and payload.

Protected Attributes
frame::basic_header	m_basic_header
msg_manager_ptr	m_msg_manager
size_t	m_bytes_needed
size_t	m_cursor
msg_metadata	m_data_msg
msg_metadata	m_control_msg
msg_metadata *	m_current_msg
frame::extended_header	m_extended_header
rng_type &	m_rng
state	m_state
permessage_deflate_type	m_permessage_deflate
Protected Attributes inherited from websocketpp::processor::processor< config >
bool const	m_secure
bool const	m_server
size_t	m_max_message_size

Detailed Description

template<typename config>
class websocketpp::processor::hybi13< config >

Definition at line 54 of file hybi13.hpp.

Member Typedef Documentation

base

template<typename config >

processor<config> websocketpp::processor::hybi13< config >::base

Definition at line 56 of file hybi13.hpp.

err_str_pair

template<typename config >

std::pair<lib::error_code,std::string> websocketpp::processor::hybi13< config >::err_str_pair

Definition at line 70 of file hybi13.hpp.

message_ptr

template<typename config >

message_type::ptr websocketpp::processor::hybi13< config >::message_ptr

Definition at line 62 of file hybi13.hpp.

message_type

template<typename config >

config::message_type websocketpp::processor::hybi13< config >::message_type

Definition at line 61 of file hybi13.hpp.

msg_manager_ptr

template<typename config >

msg_manager_type::ptr websocketpp::processor::hybi13< config >::msg_manager_ptr

Definition at line 65 of file hybi13.hpp.

msg_manager_type

template<typename config >

config::con_msg_manager_type websocketpp::processor::hybi13< config >::msg_manager_type

Definition at line 64 of file hybi13.hpp.

permessage_deflate_type

template<typename config >

config::permessage_deflate_type websocketpp::processor::hybi13< config >::permessage_deflate_type

Definition at line 68 of file hybi13.hpp.

request_type

template<typename config >

config::request_type websocketpp::processor::hybi13< config >::request_type

Definition at line 58 of file hybi13.hpp.

response_type

template<typename config >

config::response_type websocketpp::processor::hybi13< config >::response_type

Definition at line 59 of file hybi13.hpp.

rng_type

template<typename config >

config::rng_type websocketpp::processor::hybi13< config >::rng_type

Definition at line 66 of file hybi13.hpp.

Member Enumeration Documentation

state

template<typename config >

enum websocketpp::processor::hybi13::state

protected

Enumerator
HEADER_BASIC
HEADER_EXTENDED
EXTENSION
APPLICATION
READY
FATAL_ERROR

Definition at line 997 of file hybi13.hpp.

               {
        HEADER_BASIC = 0,
        HEADER_EXTENDED = 1,
        EXTENSION = 2,
        APPLICATION = 3,
        READY = 4,
        FATAL_ERROR = 5
    };

Constructor & Destructor Documentation

hybi13()

template<typename config >

websocketpp::processor::hybi13< config >::hybi13 ( bool secure, bool p_is_server, msg_manager_ptr manager, rng_type & rng )

inlineexplicit

Definition at line 72 of file hybi13.hpp.

      : processor<config>(secure, p_is_server)
      , m_msg_manager(manager)
      , m_rng(rng)
    {
        reset_headers();
    }

Here is the call graph for this function:

Member Function Documentation

client_handshake_request()

template<typename config >

lib::error_code websocketpp::processor::hybi13< config >::client_handshake_request ( request_type & req, uri_ptr uri, std::vector< std::string > const & subprotocols ) const

inlinevirtual

Parameters

[out]	req	Set of headers to fill in
[in]	uri	The uri being connected to
[in]	subprotocols	The list of subprotocols to request

Implements websocketpp::processor::processor< config >.

Definition at line 215 of file hybi13.hpp.

    {
        req.set_method("GET");
        req.set_uri(uri->get_resource());
        req.set_version("HTTP/1.1");
 
        req.append_header("Upgrade","websocket");
        req.append_header("Connection","Upgrade");
        req.replace_header("Sec-WebSocket-Version","13");
        req.replace_header("Host",uri->get_host_port());
 
        if (!subprotocols.empty()) {
            std::ostringstream result;
            std::vector<std::string>::const_iterator it = subprotocols.begin();
            result << *it++;
            while (it != subprotocols.end()) {
                result << ", " << *it++;
            }
 
            req.replace_header("Sec-WebSocket-Protocol",result.str());
        }
 
        // Generate handshake key
        frame::uint32_converter conv;
        unsigned char raw_key[16];
 
        for (int i = 0; i < 4; i++) {
            conv.i = m_rng();
            std::copy(conv.c,conv.c+4,&raw_key[i*4]);
        }
 
        req.replace_header("Sec-WebSocket-Key",base64_encode(raw_key, 16));
 
        if (m_permessage_deflate.is_implemented()) {
            std::string offer = m_permessage_deflate.generate_offer();
            if (!offer.empty()) {
                req.replace_header("Sec-WebSocket-Extensions",offer);
            }
        }
 
        return lib::error_code();
    }

Here is the call graph for this function:

consume()

template<typename config >

size_t websocketpp::processor::hybi13< config >::consume ( uint8_t * buf, size_t len, lib::error_code & ec )

inlinevirtual

Hybi 13 data streams represent a series of variable length frames. Each frame is made up of a series of fixed length fields. The lengths of later fields are contained in earlier fields. The first field length is fixed by the spec.

This processor represents a state machine that keeps track of what field is presently being read and how many more bytes are needed to complete it

Read two header bytes Extract full frame length. Read extra header bytes Validate frame header (including extension validate) Read extension data into extension message state object Read payload data into payload

Parameters

buf	Input buffer
len	Length of input buffer

Returns

Number of bytes processed or zero on error

Implements websocketpp::processor::processor< config >.

Definition at line 360 of file hybi13.hpp.

                                                                  {
        size_t p = 0;
 
        ec = lib::error_code();
 
        //std::cout << "consume: " << utility::to_hex(buf,len) << std::endl;
 
        // Loop while we don't have a message ready and we still have bytes
        // left to process.
        while (m_state != READY && m_state != FATAL_ERROR &&
               (p < len || m_bytes_needed == 0))
        {
            if (m_state == HEADER_BASIC) {
                p += this->copy_basic_header_bytes(buf+p,len-p);
 
                if (m_bytes_needed > 0) {
                    continue;
                }
 
                ec = this->validate_incoming_basic_header(
                    m_basic_header, base::m_server, !m_data_msg.msg_ptr
                );
                if (ec) {break;}
 
                // extract full header size and adjust consume state accordingly
                m_state = HEADER_EXTENDED;
                m_cursor = 0;
                m_bytes_needed = frame::get_header_len(m_basic_header) -
                    frame::BASIC_HEADER_LENGTH;
            } else if (m_state == HEADER_EXTENDED) {
                p += this->copy_extended_header_bytes(buf+p,len-p);
 
                if (m_bytes_needed > 0) {
                    continue;
                }
 
                ec = validate_incoming_extended_header(m_basic_header,m_extended_header);
                if (ec){break;}
 
                m_state = APPLICATION;
                m_bytes_needed = static_cast<size_t>(get_payload_size(m_basic_header,m_extended_header));
 
                // check if this frame is the start of a new message and set up
                // the appropriate message metadata.
                frame::opcode::value op = frame::get_opcode(m_basic_header);
 
                // TODO: get_message failure conditions
 
                if (frame::opcode::is_control(op)) {
                    m_control_msg = msg_metadata(
                        m_msg_manager->get_message(op,m_bytes_needed),
                        frame::get_masking_key(m_basic_header,m_extended_header)
                    );
 
                    m_current_msg = &m_control_msg;
                } else {
                    if (!m_data_msg.msg_ptr) {
                        if (m_bytes_needed > base::m_max_message_size) {
                            ec = make_error_code(error::message_too_big);
                            break;
                        }
                        
                        m_data_msg = msg_metadata(
                            m_msg_manager->get_message(op,m_bytes_needed),
                            frame::get_masking_key(m_basic_header,m_extended_header)
                        );
                        
                        if (m_permessage_deflate.is_enabled()) {
                            m_data_msg.msg_ptr->set_compressed(frame::get_rsv1(m_basic_header));
                        }
                    } else {
                        // Fetch the underlying payload buffer from the data message we
                        // are writing into.
                        std::string & out = m_data_msg.msg_ptr->get_raw_payload();
                        
                        if (out.size() + m_bytes_needed > base::m_max_message_size) {
                            ec = make_error_code(error::message_too_big);
                            break;
                        }
                        
                        // Each frame starts a new masking key. All other state
                        // remains between frames.
                        m_data_msg.prepared_key = prepare_masking_key(
                            frame::get_masking_key(
                                m_basic_header,
                                m_extended_header
                            )
                        );
                        
                        out.reserve(out.size() + m_bytes_needed);
                    }
                    m_current_msg = &m_data_msg;
                }
            } else if (m_state == EXTENSION) {
                m_state = APPLICATION;
            } else if (m_state == APPLICATION) {
                size_t bytes_to_process = (std::min)(m_bytes_needed,len-p);
 
                if (bytes_to_process > 0) {
                    p += this->process_payload_bytes(buf+p,bytes_to_process,ec);
 
                    if (ec) {break;}
                }
 
                if (m_bytes_needed > 0) {
                    continue;
                }
 
                // If this was the last frame in the message set the ready flag.
                // Otherwise, reset processor state to read additional frames.
                if (frame::get_fin(m_basic_header)) {
                    ec = finalize_message();
                    if (ec) {
                        break;
                    }
                } else {
                    this->reset_headers();
                }
            } else {
                // shouldn't be here
                ec = make_error_code(error::general);
                return 0;
            }
        }
 
        return p;
    }

Here is the call graph for this function:

copy_basic_header_bytes()

template<typename config >

size_t websocketpp::processor::hybi13< config >::copy_basic_header_bytes ( uint8_t const * buf, size_t len )

inlineprotected

Definition at line 722 of file hybi13.hpp.

                                                                    {
        if (len == 0 || m_bytes_needed == 0) {
            return 0;
        }
 
        if (len > 1) {
            // have at least two bytes
            if (m_bytes_needed == 2) {
                m_basic_header.b0 = buf[0];
                m_basic_header.b1 = buf[1];
                m_bytes_needed -= 2;
                return 2;
            } else {
                m_basic_header.b1 = buf[0];
                m_bytes_needed--;
                return 1;
            }
        } else {
            // have exactly one byte
            if (m_bytes_needed == 2) {
                m_basic_header.b0 = buf[0];
                m_bytes_needed--;
                return 1;
            } else {
                m_basic_header.b1 = buf[0];
                m_bytes_needed--;
                return 1;
            }
        }
    }

Here is the caller graph for this function:

copy_extended_header_bytes()

template<typename config >

size_t websocketpp::processor::hybi13< config >::copy_extended_header_bytes ( uint8_t const * buf, size_t len )

inlineprotected

Definition at line 754 of file hybi13.hpp.

                                                                       {
        size_t bytes_to_read = (std::min)(m_bytes_needed,len);
 
        std::copy(buf,buf+bytes_to_read,m_extended_header.bytes+m_cursor);
        m_cursor += bytes_to_read;
        m_bytes_needed -= bytes_to_read;
 
        return bytes_to_read;
    }

Here is the caller graph for this function:

extract_subprotocols()

template<typename config >

lib::error_code websocketpp::processor::hybi13< config >::extract_subprotocols ( request_type const & req, std::vector< std::string > & subprotocol_list )

inlinevirtual

Extracts a list of all subprotocols that the client has requested in the given opening handshake request.

Parameters

[in]	req	The request to extract from
[out]	subprotocol_list	A reference to a vector of strings to store the results in.

Implements websocketpp::processor::processor< config >.

Definition at line 310 of file hybi13.hpp.

    {
        if (!req.get_header("Sec-WebSocket-Protocol").empty()) {
            http::parameter_list p;
 
             if (!req.get_header_as_plist("Sec-WebSocket-Protocol",p)) {
                 http::parameter_list::const_iterator it;
 
                 for (it = p.begin(); it != p.end(); ++it) {
                     subprotocol_list.push_back(it->first);
                 }
             } else {
                 return error::make_error_code(error::subprotocol_parse_error);
             }
        }
        return lib::error_code();
    }

Here is the call graph for this function:

finalize_message()

template<typename config >

lib::error_code websocketpp::processor::hybi13< config >::finalize_message ( )

inline

Called after the full message is received. Provides the opportunity for extensions to complete any data post processing as well as final UTF8 validation checks for text messages.

Returns

A code indicating errors, if any

Definition at line 496 of file hybi13.hpp.

                                     {
        std::string & out = m_current_msg->msg_ptr->get_raw_payload();
 
        // if the frame is compressed, append the compression
        // trailer and flush the compression buffer.
        if (m_permessage_deflate.is_enabled()
            && m_current_msg->msg_ptr->get_compressed())
        {
            uint8_t trailer[4] = {0x00, 0x00, 0xff, 0xff};
 
            // Decompress current buffer into the message buffer
            lib::error_code ec;
            ec = m_permessage_deflate.decompress(trailer,4,out);
            if (ec) {
                return ec;
            }
        }
 
        // ensure that text messages end on a valid UTF8 code point
        if (frame::get_opcode(m_basic_header) == frame::opcode::TEXT) {
            if (!m_current_msg->validator.complete()) {
                return make_error_code(error::invalid_utf8);
            }
        }
 
        m_state = READY;
 
        return lib::error_code();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

get_bytes_needed()

template<typename config >

size_t websocketpp::processor::hybi13< config >::get_bytes_needed ( ) const

inlinevirtual

Retrieves the number of bytes presently needed by the processor This value may be used as a hint to the transport layer as to how many bytes to wait for before running consume again.

Reimplemented from websocketpp::processor::processor< config >.

Definition at line 568 of file hybi13.hpp.

                                    {
        return m_bytes_needed;
    }

get_error()

template<typename config >

bool websocketpp::processor::hybi13< config >::get_error ( ) const

inlinevirtual

Implements websocketpp::processor::processor< config >.

Definition at line 564 of file hybi13.hpp.

                           {
        return m_state == FATAL_ERROR;
    }

get_message()

template<typename config >

message_ptr websocketpp::processor::hybi13< config >::get_message ( )

inlinevirtual

Retrieves a shared pointer to the recently completed message if there is one. If ready() returns true then there is a message available. Retrieving the message with get_message will reset the state of ready. As such, each new message may be retrieved only once. Calling get_message when there is no message available will result in a null pointer being returned.

Returns

A pointer to the most recently processed message or a null shared pointer.

Implements websocketpp::processor::processor< config >.

Definition at line 545 of file hybi13.hpp.

                              {
        if (!ready()) {
            return message_ptr();
        }
        message_ptr ret = m_current_msg->msg_ptr;
        m_current_msg->msg_ptr.reset();
 
        if (frame::opcode::is_control(ret->get_opcode())) {
            m_control_msg.msg_ptr.reset();
        } else {
            m_data_msg.msg_ptr.reset();
        }
 
        this->reset_headers();
 
        return ret;
    }

Here is the call graph for this function:

get_origin()

template<typename config >

std::string const & websocketpp::processor::hybi13< config >::get_origin ( request_type const & request ) const

inlinevirtual

Implements websocketpp::processor::processor< config >.

Definition at line 306 of file hybi13.hpp.

                                                               {
        return r.get_header("Origin");
    }

get_raw()

template<typename config >

std::string websocketpp::processor::hybi13< config >::get_raw ( response_type const & request ) const

inlinevirtual

Implements websocketpp::processor::processor< config >.

Definition at line 302 of file hybi13.hpp.

                                                       {
        return res.raw();
    }

get_uri()

template<typename config >

uri_ptr websocketpp::processor::hybi13< config >::get_uri ( request_type const & request ) const

inlinevirtual

Implements websocketpp::processor::processor< config >.

Definition at line 329 of file hybi13.hpp.

                                                        {
        return get_uri_from_host(request,(base::m_secure ? "wss" : "ws"));
    }

Here is the call graph for this function:

get_version()

template<typename config >

int websocketpp::processor::hybi13< config >::get_version ( ) const

inlinevirtual

Implements websocketpp::processor::processor< config >.

Definition at line 80 of file hybi13.hpp.

                            {
        return 13;
    }

has_permessage_deflate()

template<typename config >

bool websocketpp::processor::hybi13< config >::has_permessage_deflate ( ) const

inline

Definition at line 84 of file hybi13.hpp.

                                        {
        return m_permessage_deflate.is_implemented();
    }

masked_copy()

template<typename config >

void websocketpp::processor::hybi13< config >::masked_copy ( std::string const & i, std::string & o, frame::masking_key_type key ) const

inlineprotected

Reads input from one string and writes unmasked output to another.

Parameters

[in]	i	The input string.
[out]	o	The output string.
[in]	key	The masking key to use for masking/unmasking

Definition at line 939 of file hybi13.hpp.

    {
        frame::byte_mask(i.begin(),i.end(),o.begin(),key);
        // TODO: SIMD masking
    }

Here is the call graph for this function:

Here is the caller graph for this function:

negotiate_extensions() [1/2]

template<typename config >

err_str_pair websocketpp::processor::hybi13< config >::negotiate_extensions ( request_type const & )

inlinevirtual

Reads the Sec-WebSocket-Extensions header and determines if any of the requested extensions are supported by this processor. If they are their settings data is initialized and an extension string to send to the is returned.

Parameters

request

The request or response headers to look at.

Reimplemented from websocketpp::processor::processor< config >.

Definition at line 88 of file hybi13.hpp.

                                                                    {
        return negotiate_extensions_helper(request);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

negotiate_extensions() [2/2]

template<typename config >

err_str_pair websocketpp::processor::hybi13< config >::negotiate_extensions ( response_type const & )

inlinevirtual

Reads the Sec-WebSocket-Extensions header and determines if any of the requested extensions were accepted by the server. If they are their settings data is initialized. If they are not a list of required extensions (if any) is returned. This list may be sent back to the server as a part of the 1010/Extension required close code.

Parameters

response

The request or response headers to look at.

Reimplemented from websocketpp::processor::processor< config >.

Definition at line 92 of file hybi13.hpp.

                                                                      {
        return negotiate_extensions_helper(response);
    }

Here is the call graph for this function:

negotiate_extensions_helper()

template<typename config >

template<typename header_type >

err_str_pair websocketpp::processor::hybi13< config >::negotiate_extensions_helper ( header_type const & header )

inline

This exists mostly because the code for requests and responses is identical and I can't have virtual template methods.

Definition at line 102 of file hybi13.hpp.

                                                                         {
        err_str_pair ret;
 
        // Respect blanket disabling of all extensions and don't even parse
        // the extension header
        if (!config::enable_extensions) {
            ret.first = make_error_code(error::extensions_disabled);
            return ret;
        }
 
        http::parameter_list p;
 
        bool error = header.get_header_as_plist("Sec-WebSocket-Extensions",p);
 
        if (error) {
            ret.first = make_error_code(error::extension_parse_error);
            return ret;
        }
 
        // If there are no extensions parsed then we are done!
        if (p.size() == 0) {
            return ret;
        }
 
        http::parameter_list::const_iterator it;
 
        if (m_permessage_deflate.is_implemented()) {
            err_str_pair neg_ret;
            for (it = p.begin(); it != p.end(); ++it) {
                // look through each extension, if the key is permessage-deflate
                if (it->first == "permessage-deflate") {
                    // if we have already successfully negotiated this extension
                    // then skip any other requests to negotiate the same one
                    // with different parameters 
                    if (m_permessage_deflate.is_enabled()) {
                        continue;
                    }
                    
                    
                    neg_ret = m_permessage_deflate.negotiate(it->second);
 
                    if (neg_ret.first) {
                        // Figure out if this is an error that should halt all
                        // extension negotiations or simply cause negotiation of
                        // this specific extension to fail.
                        //std::cout << "permessage-compress negotiation failed: "
                        //          << neg_ret.first.message() << std::endl;
                    } else {
                        // Note: this list will need commas if WebSocket++ ever
                        // supports more than one extension
                        ret.second += neg_ret.second;
                        m_permessage_deflate.init(base::m_server);
                        continue;
                    }
                }
            }
        }
 
        return ret;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

prepare_close()

template<typename config >

virtual lib::error_code websocketpp::processor::hybi13< config >::prepare_close ( close::status::value code, std::string const & reason, message_ptr out ) const

inlinevirtual

Definition at line 674 of file hybi13.hpp.

    {
        if (close::status::reserved(code)) {
            return make_error_code(error::reserved_close_code);
        }
 
        if (close::status::invalid(code) && code != close::status::no_status) {
            return make_error_code(error::invalid_close_code);
        }
 
        if (code == close::status::no_status && reason.size() > 0) {
            return make_error_code(error::reason_requires_code);
        }
 
        if (reason.size() > frame:: limits::payload_size_basic-2) {
            return make_error_code(error::control_too_big);
        }
 
        std::string payload;
 
        if (code != close::status::no_status) {
            close::code_converter val;
            val.i = htons(code);
 
            payload.resize(reason.size()+2);
 
            payload[0] = val.c[0];
            payload[1] = val.c[1];
 
            std::copy(reason.begin(),reason.end(),payload.begin()+2);
        }
 
        return this->prepare_control(frame::opcode::CLOSE,payload,out);
    }

Here is the call graph for this function:

prepare_control()

template<typename config >

lib::error_code websocketpp::processor::hybi13< config >::prepare_control ( frame::opcode::value op, std::string const & payload, message_ptr out ) const

inlineprotected

Internal control frame building method. Handles validation, masking, etc

Parameters

op	The control opcode to use
payload	The payload to use
out	The message buffer to store the prepared frame in

Returns

Status code, zero on success, non-zero on error

Definition at line 955 of file hybi13.hpp.

    {
        if (!out) {
            return make_error_code(error::invalid_arguments);
        }
 
        if (!frame::opcode::is_control(op)) {
            return make_error_code(error::invalid_opcode);
        }
 
        if (payload.size() > frame::limits::payload_size_basic) {
            return make_error_code(error::control_too_big);
        }
 
        frame::masking_key_type key;
        bool masked = !base::m_server;
 
        frame::basic_header h(op,payload.size(),true,masked);
 
        std::string & o = out->get_raw_payload();
        o.resize(payload.size());
 
        if (masked) {
            // Generate masking key.
            key.i = m_rng();
 
            frame::extended_header e(payload.size(),key.i);
            out->set_header(frame::prepare_header(h,e));
            this->masked_copy(payload,o,key);
        } else {
            frame::extended_header e(payload.size());
            out->set_header(frame::prepare_header(h,e));
            std::copy(payload.begin(),payload.end(),o.begin());
        }
    
        out->set_opcode(op);
        out->set_prepared(true);
 
        return lib::error_code();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

prepare_data_frame()

template<typename config >

virtual lib::error_code websocketpp::processor::hybi13< config >::prepare_data_frame ( message_ptr in, message_ptr out )

inlinevirtual

Performs validation, masking, compression, etc. will return an error if there was an error, otherwise msg will be ready to be written

TODO: tests

Parameters

in	An unprepared message to prepare
out	A message to be overwritten with the prepared message

Returns

error code

Definition at line 583 of file hybi13.hpp.

    {
        if (!in || !out) {
            return make_error_code(error::invalid_arguments);
        }
 
        frame::opcode::value op = in->get_opcode();
 
        // validate opcode: only regular data frames
        if (frame::opcode::is_control(op)) {
            return make_error_code(error::invalid_opcode);
        }
 
        std::string& i = in->get_raw_payload();
        std::string& o = out->get_raw_payload();
 
        // validate payload utf8
        if (op == frame::opcode::TEXT && !utf8_validator::validate(i)) {
            return make_error_code(error::invalid_payload);
        }
 
        frame::masking_key_type key;
        bool masked = !base::m_server;
        bool compressed = m_permessage_deflate.is_enabled()
                          && in->get_compressed();
        bool fin = in->get_fin();
 
        if (masked) {
            // Generate masking key.
            key.i = m_rng();
        } else {
            key.i = 0;
        }
 
        // prepare payload
        if (compressed) {
            // compress and store in o after header.
            m_permessage_deflate.compress(i,o);
 
            if (o.size() < 4) {
                return make_error_code(error::general);
            }
 
            // Strip trailing 4 0x00 0x00 0xff 0xff bytes before writing to the
            // wire
            o.resize(o.size()-4);
 
            // mask in place if necessary
            if (masked) {
                this->masked_copy(o,o,key);
            }
        } else {
            // no compression, just copy data into the output buffer
            o.resize(i.size());
 
            // if we are masked, have the masking function write to the output
            // buffer directly to avoid another copy. If not masked, copy
            // directly without masking.
            if (masked) {
                this->masked_copy(i,o,key);
            } else {
                std::copy(i.begin(),i.end(),o.begin());
            }
        }
 
        // generate header
        frame::basic_header h(op,o.size(),fin,masked,compressed);
 
        if (masked) {
            frame::extended_header e(o.size(),key.i);
            out->set_header(frame::prepare_header(h,e));
        } else {
            frame::extended_header e(o.size());
            out->set_header(frame::prepare_header(h,e));
        }
 
        out->set_prepared(true);
        out->set_opcode(op);
 
        return lib::error_code();
    }

Here is the call graph for this function:

prepare_ping()

template<typename config >

lib::error_code websocketpp::processor::hybi13< config >::prepare_ping ( std::string const & in, message_ptr out ) const

inline

Definition at line 666 of file hybi13.hpp.

                                                                            {
        return this->prepare_control(frame::opcode::PING,in,out);
    }

Here is the call graph for this function:

prepare_pong()

template<typename config >

lib::error_code websocketpp::processor::hybi13< config >::prepare_pong ( std::string const & in, message_ptr out ) const

inline

Definition at line 670 of file hybi13.hpp.

                                                                            {
        return this->prepare_control(frame::opcode::PONG,in,out);
    }

Here is the call graph for this function:

process_handshake()

template<typename config >

lib::error_code websocketpp::processor::hybi13< config >::process_handshake ( request_type const & req, std::string const & subprotocol, response_type & res ) const

inlinevirtual

Parameters

req	The request to process
subprotocol	The subprotocol in use
res	The response to store the processed response in

Returns

An error code, 0 on success, non-zero for other errors

Implements websocketpp::processor::processor< config >.

Definition at line 187 of file hybi13.hpp.

    {
        std::string server_key = request.get_header("Sec-WebSocket-Key");
 
        lib::error_code ec = process_handshake_key(server_key);
 
        if (ec) {
            return ec;
        }
 
        response.replace_header("Sec-WebSocket-Accept",server_key);
        response.append_header("Upgrade",constants::upgrade_token);
        response.append_header("Connection",constants::connection_token);
 
        if (!subprotocol.empty()) {
            response.replace_header("Sec-WebSocket-Protocol",subprotocol);
        }
 
        return lib::error_code();
    }

Here is the call graph for this function:

process_handshake_key()

template<typename config >

lib::error_code websocketpp::processor::hybi13< config >::process_handshake_key ( std::string & key ) const

inlineprotected

Definition at line 711 of file hybi13.hpp.

                                                               {
        key.append(constants::handshake_guid);
 
        unsigned char message_digest[20];
        sha1::calc(key.c_str(),key.length(),message_digest);
        key = base64_encode(message_digest,20);
 
        return lib::error_code();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

process_payload_bytes()

template<typename config >

size_t websocketpp::processor::hybi13< config >::process_payload_bytes ( uint8_t * buf, size_t len, lib::error_code & ec )

inlineprotected

This function performs unmasking and uncompression, validates the decoded bytes, and writes them to the appropriate message buffer.

This member function will use the input buffer as stratch space for its work. The raw input bytes will not be preserved. This applies only to the bytes actually needed. At most min(m_bytes_needed,len) will be processed.

Parameters

buf	Input/working buffer
len	Length of buf

Returns

Number of bytes processed or zero in case of an error

Definition at line 777 of file hybi13.hpp.

    {
        // unmask if masked
        if (frame::get_masked(m_basic_header)) {
            m_current_msg->prepared_key = frame::byte_mask_circ(
                buf, len, m_current_msg->prepared_key);
            // TODO: SIMD masking
        }
 
        std::string & out = m_current_msg->msg_ptr->get_raw_payload();
        size_t offset = out.size();
 
        // decompress message if needed.
        if (m_permessage_deflate.is_enabled()
            && m_current_msg->msg_ptr->get_compressed())
        {
            // Decompress current buffer into the message buffer
            ec = m_permessage_deflate.decompress(buf,len,out);
            if (ec) {
                return 0;
            }
        } else {
            // No compression, straight copy
            out.append(reinterpret_cast<char *>(buf),len);
        }
 
        // validate unmasked, decompressed values
        if (m_current_msg->msg_ptr->get_opcode() == frame::opcode::TEXT) {
            if (!m_current_msg->validator.decode(out.begin()+offset,out.end())) {
                ec = make_error_code(error::invalid_utf8);
                return 0;
            }
        }
 
        m_bytes_needed -= len;
 
        return len;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

ready()

template<typename config >

bool websocketpp::processor::hybi13< config >::ready ( ) const

inlinevirtual

Implements websocketpp::processor::processor< config >.

Definition at line 541 of file hybi13.hpp.

                       {
        return (m_state == READY);
    }

Here is the caller graph for this function:

reset_headers()

template<typename config >

void websocketpp::processor::hybi13< config >::reset_headers ( )

inline

Definition at line 526 of file hybi13.hpp.

                         {
        m_state = HEADER_BASIC;
        m_bytes_needed = frame::BASIC_HEADER_LENGTH;
 
        m_basic_header.b0 = 0x00;
        m_basic_header.b1 = 0x00;
 
        std::fill_n(
            m_extended_header.bytes,
            frame::MAX_EXTENDED_HEADER_LENGTH,
            0x00
        );
    }

Here is the caller graph for this function:

validate_handshake()

template<typename config >

lib::error_code websocketpp::processor::hybi13< config >::validate_handshake ( request_type const & request ) const

inlinevirtual

Parameters

request

The WebSocket handshake request to validate. is_websocket_handshake(request) must be true and get_websocket_version(request) must equal this->get_version().

Returns

A status code, 0 on success, non-zero for specific sorts of failure

Implements websocketpp::processor::processor< config >.

Definition at line 163 of file hybi13.hpp.

                                                                   {
        if (r.get_method() != "GET") {
            return make_error_code(error::invalid_http_method);
        }
 
        if (r.get_version() != "HTTP/1.1") {
            return make_error_code(error::invalid_http_version);
        }
 
        // required headers
        // Host is required by HTTP/1.1
        // Connection is required by is_websocket_handshake
        // Upgrade is required by is_websocket_handshake
        if (r.get_header("Sec-WebSocket-Key").empty()) {
            return make_error_code(error::missing_required_header);
        }
 
        return lib::error_code();
    }

validate_incoming_basic_header()

template<typename config >

lib::error_code websocketpp::processor::hybi13< config >::validate_incoming_basic_header ( frame::basic_header const & h, bool is_server, bool new_msg ) const

inlineprotected

Validates an incoming hybi13 basic header.

Parameters

h	The basic header to validate
is_server	Whether or not the endpoint that received this frame is a server.
new_msg	Whether or not this is the first frame of the message

Returns

0 on success or a non-zero error code on failure

Definition at line 826 of file hybi13.hpp.

    {
        frame::opcode::value op = frame::get_opcode(h);
 
        // Check control frame size limit
        if (frame::opcode::is_control(op) &&
            frame::get_basic_size(h) > frame::limits::payload_size_basic)
        {
            return make_error_code(error::control_too_big);
        }
 
        // Check that RSV bits are clear
        // The only RSV bits allowed are rsv1 if the permessage_compress
        // extension is enabled for this connection and the message is not
        // a control message.
        //
        // TODO: unit tests for this
        if (frame::get_rsv1(h) && (!m_permessage_deflate.is_enabled()
                || frame::opcode::is_control(op)))
        {
            return make_error_code(error::invalid_rsv_bit);
        }
 
        if (frame::get_rsv2(h) || frame::get_rsv3(h)) {
            return make_error_code(error::invalid_rsv_bit);
        }
 
        // Check for reserved opcodes
        if (frame::opcode::reserved(op)) {
            return make_error_code(error::invalid_opcode);
        }
 
        // Check for invalid opcodes
        // TODO: unit tests for this?
        if (frame::opcode::invalid(op)) {
            return make_error_code(error::invalid_opcode);
        }
 
        // Check for fragmented control message
        if (frame::opcode::is_control(op) && !frame::get_fin(h)) {
            return make_error_code(error::fragmented_control);
        }
 
        // Check for continuation without an active message
        if (new_msg && op == frame::opcode::CONTINUATION) {
            return make_error_code(error::invalid_continuation);
        }
 
        // Check for new data frame when expecting continuation
        if (!new_msg && !frame::opcode::is_control(op) &&
            op != frame::opcode::CONTINUATION)
        {
            return make_error_code(error::invalid_continuation);
        }
 
        // Servers should reject any unmasked frames from clients.
        // Clients should reject any masked frames from servers.
        if (is_server && !frame::get_masked(h)) {
            return make_error_code(error::masking_required);
        } else if (!is_server && frame::get_masked(h)) {
            return make_error_code(error::masking_forbidden);
        }
 
        return lib::error_code();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

validate_incoming_extended_header()

template<typename config >

lib::error_code websocketpp::processor::hybi13< config >::validate_incoming_extended_header ( frame::basic_header h, frame::extended_header e ) const

inlineprotected

Validates an incoming hybi13 full header.

Todo

unit test for the >32 bit frames on 32 bit systems case

Parameters

h	The basic header to validate
e	The extended header to validate

Returns

An error_code, non-zero values indicate why the validation failed

Definition at line 904 of file hybi13.hpp.

    {
        uint8_t basic_size = frame::get_basic_size(h);
        uint64_t payload_size = frame::get_payload_size(h,e);
 
        // Check for non-minimally encoded payloads
        if (basic_size == frame::payload_size_code_16bit &&
            payload_size <= frame::limits::payload_size_basic)
        {
            return make_error_code(error::non_minimal_encoding);
        }
 
        if (basic_size == frame::payload_size_code_64bit &&
            payload_size <= frame::limits::payload_size_extended)
        {
            return make_error_code(error::non_minimal_encoding);
        }
 
        // Check for >32bit frames on 32 bit systems
        if (sizeof(size_t) == 4 && (payload_size >> 32)) {
            return make_error_code(error::requires_64bit);
        }
 
        return lib::error_code();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

validate_server_handshake_response()

template<typename config >

lib::error_code websocketpp::processor::hybi13< config >::validate_server_handshake_response ( request_type const & req, response_type & res ) const

inlinevirtual

Parameters

req	The original request sent
res	The reponse to generate

Returns

An error code, 0 on success, non-zero for other errors

Implements websocketpp::processor::processor< config >.

Definition at line 265 of file hybi13.hpp.

    {
        // A valid response has an HTTP 101 switching protocols code
        if (res.get_status_code() != http::status_code::switching_protocols) {
            return error::make_error_code(error::invalid_http_status);
        }
 
        // And the upgrade token in an upgrade header
        std::string const & upgrade_header = res.get_header("Upgrade");
        if (utility::ci_find_substr(upgrade_header, constants::upgrade_token,
            sizeof(constants::upgrade_token)-1) == upgrade_header.end())
        {
            return error::make_error_code(error::missing_required_header);
        }
 
        // And the websocket token in the connection header
        std::string const & con_header = res.get_header("Connection");
        if (utility::ci_find_substr(con_header, constants::connection_token,
            sizeof(constants::connection_token)-1) == con_header.end())
        {
            return error::make_error_code(error::missing_required_header);
        }
 
        // And has a valid Sec-WebSocket-Accept value
        std::string key = req.get_header("Sec-WebSocket-Key");
        lib::error_code ec = process_handshake_key(key);
 
        if (ec || key != res.get_header("Sec-WebSocket-Accept")) {
            return error::make_error_code(error::missing_required_header);
        }
 
        // check extensions
 
        return lib::error_code();
    }

Here is the call graph for this function:

Member Data Documentation

m_basic_header

template<typename config >

frame::basic_header websocketpp::processor::hybi13< config >::m_basic_header

protected

Definition at line 1022 of file hybi13.hpp.

m_bytes_needed

template<typename config >

size_t websocketpp::processor::hybi13< config >::m_bytes_needed

protected

Definition at line 1028 of file hybi13.hpp.

m_control_msg

template<typename config >

msg_metadata websocketpp::processor::hybi13< config >::m_control_msg

protected

Definition at line 1036 of file hybi13.hpp.

m_current_msg

template<typename config >

msg_metadata* websocketpp::processor::hybi13< config >::m_current_msg

protected

Definition at line 1039 of file hybi13.hpp.

m_cursor

template<typename config >

size_t websocketpp::processor::hybi13< config >::m_cursor

protected

Definition at line 1031 of file hybi13.hpp.

m_data_msg

template<typename config >

msg_metadata websocketpp::processor::hybi13< config >::m_data_msg

protected

Definition at line 1034 of file hybi13.hpp.

m_extended_header

template<typename config >

frame::extended_header websocketpp::processor::hybi13< config >::m_extended_header

protected

Definition at line 1042 of file hybi13.hpp.

m_msg_manager

template<typename config >

msg_manager_ptr websocketpp::processor::hybi13< config >::m_msg_manager

protected

Definition at line 1025 of file hybi13.hpp.

m_permessage_deflate

template<typename config >

permessage_deflate_type websocketpp::processor::hybi13< config >::m_permessage_deflate

protected

Definition at line 1050 of file hybi13.hpp.

m_rng

template<typename config >

rng_type& websocketpp::processor::hybi13< config >::m_rng

protected

Definition at line 1044 of file hybi13.hpp.

m_state

template<typename config >

state websocketpp::processor::hybi13< config >::m_state

protected

Definition at line 1047 of file hybi13.hpp.

---

The documentation for this class was generated from the following file:

• libraries/fc/vendor/websocketpp/websocketpp/processors/hybi13.hpp