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

Processor for Hybi Draft version 00. More...

#include <hybi00.hpp>

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

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

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::ptr	msg_manager_ptr
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
	hybi00 (bool secure, bool p_is_server, msg_manager_ptr manager)
int	get_version () const
	Get the protocol version of this processor.
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 &req, std::string const &subprotocol, response_type &res) const
	Calculate the appropriate response for this websocket request.
lib::error_code	client_handshake_request (request_type &, uri_ptr, std::vector< std::string > const &) const
	Fill in a set of request headers for a client connection request.
lib::error_code	validate_server_handshake_response (request_type const &, response_type &) 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.
std::string	get_key3 () const
	Get hybi00 handshake key3.
size_t	consume (uint8_t *buf, size_t len, lib::error_code &ec)
	Process new websocket connection bytes.
bool	ready () const
	Checks if there is a message ready.
bool	get_error () const
	Tests whether the processor is in a fatal error state.
message_ptr	get_message ()
	Retrieves the most recently processed message.
virtual lib::error_code	prepare_data_frame (message_ptr in, message_ptr out)
	Prepare a message for writing.
lib::error_code	prepare_ping (std::string const &, message_ptr) const
	Prepare a ping frame.
lib::error_code	prepare_pong (std::string const &, message_ptr) const
	Prepare a pong frame.
lib::error_code	prepare_close (close::status::value, std::string const &, message_ptr out) const
	Prepare a close frame.
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 err_str_pair	negotiate_extensions (request_type const &)
	Initializes extensions based on the Sec-WebSocket-Extensions header.
virtual err_str_pair	negotiate_extensions (response_type const &)
	Initializes extensions based on the Sec-WebSocket-Extensions header.
virtual size_t	get_bytes_needed () const
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.

Additional Inherited Members
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::hybi00< config >

There are many differences between Hybi 00 and Hybi 13

Definition at line 54 of file hybi00.hpp.

Member Typedef Documentation

base

template<typename config >

processor<config> websocketpp::processor::hybi00< config >::base

Definition at line 56 of file hybi00.hpp.

message_ptr

template<typename config >

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

Definition at line 62 of file hybi00.hpp.

message_type

template<typename config >

config::message_type websocketpp::processor::hybi00< config >::message_type

Definition at line 61 of file hybi00.hpp.

msg_manager_ptr

template<typename config >

config::con_msg_manager_type::ptr websocketpp::processor::hybi00< config >::msg_manager_ptr

Definition at line 64 of file hybi00.hpp.

request_type

template<typename config >

config::request_type websocketpp::processor::hybi00< config >::request_type

Definition at line 58 of file hybi00.hpp.

response_type

template<typename config >

config::response_type websocketpp::processor::hybi00< config >::response_type

Definition at line 59 of file hybi00.hpp.

Constructor & Destructor Documentation

hybi00()

template<typename config >

websocketpp::processor::hybi00< config >::hybi00 ( bool secure, bool p_is_server, msg_manager_ptr manager )

inlineexplicit

Definition at line 66 of file hybi00.hpp.

      : processor<config>(secure, p_is_server)
      , msg_hdr(0x00)
      , msg_ftr(0xff)
      , m_state(HEADER)
      , m_msg_manager(manager) {}

Member Function Documentation

client_handshake_request()

template<typename config >

lib::error_code websocketpp::processor::hybi00< config >::client_handshake_request ( request_type & , uri_ptr , std::vector< std::string > const &  ) const

inlinevirtual

The Hybi 00 processor only implements incoming connections so this will always return an error.

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 158 of file hybi00.hpp.

    {
        return error::make_error_code(error::no_protocol_support);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

consume()

template<typename config >

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

inlinevirtual

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

Definition at line 252 of file hybi00.hpp.

                                                                  {
        // if in state header we are expecting a 0x00 byte, if we don't get one
        // it is a fatal error
        size_t p = 0; // bytes processed
        size_t l = 0;
 
        ec = lib::error_code();
 
        while (p < len) {
            if (m_state == HEADER) {
                if (buf[p] == msg_hdr) {
                    p++;
                    m_msg_ptr = m_msg_manager->get_message(frame::opcode::text,1);
 
                    if (!m_msg_ptr) {
                        ec = make_error_code(websocketpp::error::no_incoming_buffers);
                        m_state = FATAL_ERROR;
                    } else {
                        m_state = PAYLOAD;
                    }
                } else {
                    ec = make_error_code(error::protocol_violation);
                    m_state = FATAL_ERROR;
                }
            } else if (m_state == PAYLOAD) {
                uint8_t *it = std::find(buf+p,buf+len,msg_ftr);
 
                // 0    1    2    3    4    5
                // 0x00 0x23 0x23 0x23 0xff 0xXX
 
                // Copy payload bytes into message
                l = static_cast<size_t>(it-(buf+p));
                m_msg_ptr->append_payload(buf+p,l);
                p += l;
 
                if (it != buf+len) {
                    // message is done, copy it and the trailing
                    p++;
                    // TODO: validation
                    m_state = READY;
                }
            } else {
                // TODO
                break;
            }
        }
        // If we get one, we create a new message and move to application state
 
        // if in state application we are copying bytes into the output message
        // and validating them for UTF8 until we hit a 0xff byte. Once we hit
        // 0x00, the message is complete and is dispatched. Then we go back to
        // header state.
 
        //ec = make_error_code(error::not_implemented);
        return p;
    }

Here is the caller graph for this function:

extract_subprotocols()

template<typename config >

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

inlinevirtual

hybi00 does support subprotocols https://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-00#section-1.9

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 198 of file hybi00.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:

Here is the caller graph for this function:

get_error()

template<typename config >

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

inlinevirtual

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

Definition at line 313 of file hybi00.hpp.

                           {
        return false;
    }

get_key3()

template<typename config >

std::string websocketpp::processor::hybi00< config >::get_key3 ( ) const

inline

Todo

This doesn't appear to be used anymore. It might be able to be removed

Definition at line 247 of file hybi00.hpp.

                               {
        return "";
    }

get_message()

template<typename config >

message_ptr websocketpp::processor::hybi00< 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 317 of file hybi00.hpp.

                              {
        message_ptr ret = m_msg_ptr;
        m_msg_ptr = message_ptr();
        m_state = HEADER;
        return ret;
    }

Here is the caller graph for this function:

get_origin()

template<typename config >

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

inlinevirtual

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

Definition at line 185 of file hybi00.hpp.

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

get_raw()

template<typename config >

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

inlinevirtual

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

Definition at line 179 of file hybi00.hpp.

                                                       {
        response_type temp = res;
        temp.remove_header("Sec-WebSocket-Key3");
        return temp.raw() + res.get_header("Sec-WebSocket-Key3");
    }

get_uri()

template<typename config >

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

inlinevirtual

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

Definition at line 217 of file hybi00.hpp.

                                                        {
        std::string h = request.get_header("Host");
 
        size_t last_colon = h.rfind(":");
        size_t last_sbrace = h.rfind("]");
 
        // no : = hostname with no port
        // last : before ] = ipv6 literal with no port
        // : with no ] = hostname with port
        // : after ] = ipv6 literal with port
 
        if (last_colon == std::string::npos ||
            (last_sbrace != std::string::npos && last_sbrace > last_colon))
        {
            return lib::make_shared<uri>(base::m_secure, h, request.get_uri());
        } else {
            return lib::make_shared<uri>(base::m_secure,
                                   h.substr(0,last_colon),
                                   h.substr(last_colon+1),
                                   request.get_uri());
        }
 
        // TODO: check if get_uri is a full uri
    }

Here is the caller graph for this function:

get_version()

template<typename config >

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

inlinevirtual

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

Definition at line 73 of file hybi00.hpp.

                            {
        return 0;
    }

Here is the caller graph for this function:

prepare_close()

template<typename config >

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

inline

Hybi 00 doesn't support the close code or reason so these parameters are ignored.

Parameters

code	The close code to send
reason	The reason string to send
out	The message buffer to prepare the fame in

Returns

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

Definition at line 401 of file hybi00.hpp.

    {
        if (!out) {
            return lib::error_code(error::invalid_arguments);
        }
 
        std::string val;
        val.append(1,'\xff');
        val.append(1,'\x00');
        out->set_payload(val);
        out->set_prepared(true);
 
        return lib::error_code();
    }

prepare_data_frame()

template<typename config >

virtual lib::error_code websocketpp::processor::hybi00< 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

Definition at line 329 of file hybi00.hpp.

    {
        if (!in || !out) {
            return make_error_code(error::invalid_arguments);
        }
 
        // TODO: check if the message is prepared already
 
        // validate opcode
        if (in->get_opcode() != frame::opcode::text) {
            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 (!utf8_validator::validate(i)) {
            return make_error_code(error::invalid_payload);
        }
 
        // generate header
        out->set_header(std::string(reinterpret_cast<char const *>(&msg_hdr),1));
 
        // process payload
        out->set_payload(i);
        out->append_payload(std::string(reinterpret_cast<char const *>(&msg_ftr),1));
 
        // hybi00 doesn't support compression
        // hybi00 doesn't have masking
 
        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_ping()

template<typename config >

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

inline

Hybi 00 doesn't support pings so this will always return an error

Parameters

in	The string to use for the ping payload
out	The message buffer to prepare the ping in.

Returns

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

Definition at line 373 of file hybi00.hpp.

    {
        return lib::error_code(error::no_protocol_support);
    }

prepare_pong()

template<typename config >

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

inline

Hybi 00 doesn't support pongs so this will always return an error

Parameters

in	The string to use for the pong payload
out	The message buffer to prepare the pong in.

Returns

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

Definition at line 386 of file hybi00.hpp.

    {
        return lib::error_code(error::no_protocol_support);
    }

process_handshake()

template<typename config >

lib::error_code websocketpp::processor::hybi00< 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 100 of file hybi00.hpp.

    {
        char key_final[16];
 
        // copy key1 into final key
        decode_client_key(req.get_header("Sec-WebSocket-Key1"), &key_final[0]);
 
        // copy key2 into final key
        decode_client_key(req.get_header("Sec-WebSocket-Key2"), &key_final[4]);
 
        // copy key3 into final key
        // key3 should be exactly 8 bytes. If it is more it will be truncated
        // if it is less the final key will almost certainly be wrong.
        // TODO: decide if it is best to silently fail here or produce some sort
        //       of warning or exception.
        std::string const & key3 = req.get_header("Sec-WebSocket-Key3");
        std::copy(key3.c_str(),
                  key3.c_str()+(std::min)(static_cast<size_t>(8), key3.size()),
                  &key_final[8]);
 
        res.append_header(
            "Sec-WebSocket-Key3",
            md5::md5_hash_string(std::string(key_final,16))
        );
 
        res.append_header("Upgrade","WebSocket");
        res.append_header("Connection","Upgrade");
 
        // Echo back client's origin unless our local application set a
        // more restrictive one.
        if (res.get_header("Sec-WebSocket-Origin").empty()) {
            res.append_header("Sec-WebSocket-Origin",req.get_header("Origin"));
        }
 
        // Echo back the client's request host unless our local application
        // set a different one.
        if (res.get_header("Sec-WebSocket-Location").empty()) {
            uri_ptr uri = get_uri(req);
            res.append_header("Sec-WebSocket-Location",uri->str());
        }
 
        if (!subprotocol.empty()) {
            res.replace_header("Sec-WebSocket-Protocol",subprotocol);
        }
 
        return lib::error_code();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

ready()

template<typename config >

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

inlinevirtual

Checks if the most recent consume operation processed enough bytes to complete a new WebSocket message. The message can be retrieved by calling get_message() which will reset the internal state to not-ready and allow consume to read more bytes.

Returns

Whether or not a message is ready.

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

Definition at line 309 of file hybi00.hpp.

                       {
        return (m_state == READY);
    }

Here is the caller graph for this function:

validate_handshake()

template<typename config >

lib::error_code websocketpp::processor::hybi00< 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 77 of file hybi00.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-Key1").empty() ||
            r.get_header("Sec-WebSocket-Key2").empty() ||
            r.get_header("Sec-WebSocket-Key3").empty())
        {
            return make_error_code(error::missing_required_header);
        }
 
        return lib::error_code();
    }

Here is the caller graph for this function:

validate_server_handshake_response()

template<typename config >

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

inlinevirtual

The Hybi 00 processor only implements incoming connections so this will always return an error.

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 173 of file hybi00.hpp.

    {
        return error::make_error_code(error::no_protocol_support);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

---

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

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