websocketpp::connection< config > Class Template Reference

Represents an individual WebSocket connection. More...

#include <connection.hpp>

Inheritance diagram for websocketpp::connection< config >:

Collaboration diagram for websocketpp::connection< config >:

Public Types
typedef connection< config >	type
	Type of this connection.
typedef lib::shared_ptr< type >	ptr
	Type of a shared pointer to this connection.
typedef lib::weak_ptr< type >	weak_ptr
	Type of a weak pointer to this connection.
typedef config::concurrency_type	concurrency_type
	Type of the concurrency component of this connection.
typedef config::alog_type	alog_type
	Type of the access logging policy.
typedef config::elog_type	elog_type
	Type of the error logging policy.
typedef config::transport_type::transport_con_type	transport_con_type
	Type of the transport component of this connection.
typedef transport_con_type::ptr	transport_con_ptr
	Type of a shared pointer to the transport component of this connection.
typedef lib::function< void(ptr)>	termination_handler
typedef concurrency_type::scoped_lock_type	scoped_lock_type
typedef concurrency_type::mutex_type	mutex_type
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	con_msg_manager_type
typedef con_msg_manager_type::ptr	con_msg_manager_ptr
typedef config::rng_type	rng_type
	Type of RNG.
typedef processor::processor< config >	processor_type
typedef lib::shared_ptr< processor_type >	processor_ptr
typedef lib::function< void(connection_hdl, message_ptr)>	message_handler
typedef transport_con_type::timer_ptr	timer_ptr
	Type of a pointer to a transport timer handle.
typedef session::internal_state::value	istate_type

Public Member Functions
	connection (bool p_is_server, std::string const &ua, alog_type &alog, elog_type &elog, rng_type &rng)
ptr	get_shared ()
	Get a shared pointer to this component.
void	set_open_handler (open_handler h)
	Set open handler.
void	set_close_handler (close_handler h)
	Set close handler.
void	set_fail_handler (fail_handler h)
	Set fail handler.
void	set_ping_handler (ping_handler h)
	Set ping handler.
void	set_pong_handler (pong_handler h)
	Set pong handler.
void	set_pong_timeout_handler (pong_timeout_handler h)
	Set pong timeout handler.
void	set_interrupt_handler (interrupt_handler h)
	Set interrupt handler.
void	set_http_handler (http_handler h)
	Set http handler.
void	set_validate_handler (validate_handler h)
	Set validate handler.
void	set_message_handler (message_handler h)
	Set message handler.
void	set_open_handshake_timeout (long dur)
	Set open handshake timeout.
void	set_close_handshake_timeout (long dur)
	Set close handshake timeout.
void	set_pong_timeout (long dur)
	Set pong timeout.
size_t	get_max_message_size () const
	Get maximum message size.
void	set_max_message_size (size_t new_value)
	Set maximum message size.
size_t	get_max_http_body_size () const
	Get maximum HTTP message body size.
void	set_max_http_body_size (size_t new_value)
	Set maximum HTTP message body size.
size_t	get_buffered_amount () const
	Get the size of the outgoing write buffer (in payload bytes)
size_t	buffered_amount () const
	Get the size of the outgoing write buffer (in payload bytes)
lib::error_code	send (std::string const &payload, frame::opcode::value op=frame::opcode::text)
	Create a message and then add it to the outgoing send queue.
lib::error_code	send (void const *payload, size_t len, frame::opcode::value op=frame::opcode::binary)
	Send a message (raw array overload)
lib::error_code	send (message_ptr msg)
	Add a message to the outgoing send queue.
lib::error_code	interrupt ()
	Asyncronously invoke handler::on_inturrupt.
void	handle_interrupt ()
	Transport inturrupt callback.
lib::error_code	pause_reading ()
	Pause reading of new data.
void	handle_pause_reading ()
	Pause reading callback.
lib::error_code	resume_reading ()
	Resume reading of new data.
void	handle_resume_reading ()
	Resume reading callback.
void	ping (std::string const &payload)
	Send a ping.
void	ping (std::string const &payload, lib::error_code &ec)
	exception free variant of ping
void	handle_pong_timeout (std::string payload, lib::error_code const &ec)
	Utility method that gets called back when the ping timer expires.
void	pong (std::string const &payload)
	Send a pong.
void	pong (std::string const &payload, lib::error_code &ec)
	exception free variant of pong
void	close (close::status::value const code, std::string const &reason)
	Close the connection.
void	close (close::status::value const code, std::string const &reason, lib::error_code &ec)
	exception free variant of close
bool	get_secure () const
	Returns the secure flag from the connection URI.
std::string const &	get_host () const
	Returns the host component of the connection URI.
std::string const &	get_resource () const
	Returns the resource component of the connection URI.
uint16_t	get_port () const
	Returns the port component of the connection URI.
uri_ptr	get_uri () const
	Gets the connection URI.
void	set_uri (uri_ptr uri)
	Sets the connection URI.
std::string const &	get_subprotocol () const
	Gets the negotated subprotocol.
std::vector< std::string > const &	get_requested_subprotocols () const
	Gets all of the subprotocols requested by the client.
void	add_subprotocol (std::string const &request, lib::error_code &ec)
	Adds the given subprotocol string to the request list (exception free)
void	add_subprotocol (std::string const &request)
	Adds the given subprotocol string to the request list.
void	select_subprotocol (std::string const &value, lib::error_code &ec)
	Select a subprotocol to use (exception free)
void	select_subprotocol (std::string const &value)
	Select a subprotocol to use.
std::string const &	get_request_header (std::string const &key) const
	Retrieve a request header.
std::string const &	get_request_body () const
	Retrieve a request body.
std::string const &	get_response_header (std::string const &key) const
	Retrieve a response header.
http::status_code::value	get_response_code () const
	Get response HTTP status code.
std::string const &	get_response_msg () const
	Get response HTTP status message.
void	set_status (http::status_code::value code)
	Set response status code and message.
void	set_status (http::status_code::value code, std::string const &msg)
	Set response status code and message.
void	set_body (std::string const &value)
	Set response body content.
void	set_body (std::string &&value)
void	append_header (std::string const &key, std::string const &val)
	Append a header.
void	replace_header (std::string const &key, std::string const &val)
	Replace a header.
void	remove_header (std::string const &key)
	Remove a header.
request_type const &	get_request () const
	Get request object.
response_type const &	get_response () const
	Get response object.
lib::error_code	defer_http_response ()
	Defer HTTP Response until later (Exception free)
void	send_http_response (lib::error_code &ec)
	Send deferred HTTP Response (exception free)
void	send_http_response ()
	Send deferred HTTP Response.
connection_hdl	get_handle () const
	Get Connection Handle.
bool	is_server () const
	Get whether or not this connection is part of a server or client.
std::string const &	get_origin () const
	Return the same origin policy origin value from the opening request.
session::state::value	get_state () const
	Return the connection state.
close::status::value	get_local_close_code () const
	Get the WebSocket close code sent by this endpoint.
std::string const &	get_local_close_reason () const
	Get the WebSocket close reason sent by this endpoint.
close::status::value	get_remote_close_code () const
	Get the WebSocket close code sent by the remote endpoint.
std::string const &	get_remote_close_reason () const
	Get the WebSocket close reason sent by the remote endpoint.
lib::error_code	get_ec () const
	Get the internal error code for a closed/failed connection.
message_ptr	get_message (websocketpp::frame::opcode::value op, size_t size) const
	Get a message buffer.
void	read_handshake (size_t num_bytes)
void	handle_read_handshake (lib::error_code const &ec, size_t bytes_transferred)
void	handle_read_http_response (lib::error_code const &ec, size_t bytes_transferred)
void	handle_write_http_response (lib::error_code const &ec)
void	handle_send_http_request (lib::error_code const &ec)
void	handle_open_handshake_timeout (lib::error_code const &ec)
void	handle_close_handshake_timeout (lib::error_code const &ec)
void	handle_read_frame (lib::error_code const &ec, size_t bytes_transferred)
void	read_frame ()
	Issue a new transport read unless reading is paused.
std::vector< int > const &	get_supported_versions () const
	Get array of WebSocket protocol versions that this connection supports.
void	set_termination_handler (termination_handler new_handler)
void	terminate (lib::error_code const &ec)
void	handle_terminate (terminate_status tstat, lib::error_code const &ec)
void	write_frame ()
	Checks if there are frames in the send queue and if there are sends one.
void	handle_write_frame (lib::error_code const &ec)
	Process the results of a frame write operation and start the next write.
void	start ()
	Start the connection state machine.
void	set_handle (connection_hdl hdl)
	Set Connection Handle.

Protected Member Functions
void	handle_transport_init (lib::error_code const &ec)
lib::error_code	initialize_processor ()
lib::error_code	process_handshake_request ()

Detailed Description

template<typename config>
class websocketpp::connection< config >

Definition at line 235 of file connection.hpp.

Member Typedef Documentation

alog_type

template<typename config >

config::alog_type websocketpp::connection< config >::alog_type

Definition at line 250 of file connection.hpp.

con_msg_manager_ptr

template<typename config >

con_msg_manager_type::ptr websocketpp::connection< config >::con_msg_manager_ptr

Definition at line 272 of file connection.hpp.

con_msg_manager_type

template<typename config >

config::con_msg_manager_type websocketpp::connection< config >::con_msg_manager_type

Definition at line 271 of file connection.hpp.

concurrency_type

template<typename config >

config::concurrency_type websocketpp::connection< config >::concurrency_type

Definition at line 248 of file connection.hpp.

elog_type

template<typename config >

config::elog_type websocketpp::connection< config >::elog_type

Definition at line 252 of file connection.hpp.

istate_type

template<typename config >

session::internal_state::value websocketpp::connection< config >::istate_type

Definition at line 287 of file connection.hpp.

message_handler

template<typename config >

lib::function<void(connection_hdl,message_ptr)> websocketpp::connection< config >::message_handler

Definition at line 281 of file connection.hpp.

message_ptr

template<typename config >

message_type::ptr websocketpp::connection< config >::message_ptr

Definition at line 269 of file connection.hpp.

message_type

template<typename config >

config::message_type websocketpp::connection< config >::message_type

Definition at line 268 of file connection.hpp.

mutex_type

template<typename config >

concurrency_type::mutex_type websocketpp::connection< config >::mutex_type

Definition at line 263 of file connection.hpp.

processor_ptr

template<typename config >

lib::shared_ptr<processor_type> websocketpp::connection< config >::processor_ptr

Definition at line 278 of file connection.hpp.

processor_type

template<typename config >

processor::processor<config> websocketpp::connection< config >::processor_type

Definition at line 277 of file connection.hpp.

ptr

template<typename config >

lib::shared_ptr<type> websocketpp::connection< config >::ptr

Definition at line 243 of file connection.hpp.

request_type

template<typename config >

config::request_type websocketpp::connection< config >::request_type

Definition at line 265 of file connection.hpp.

response_type

template<typename config >

config::response_type websocketpp::connection< config >::response_type

Definition at line 266 of file connection.hpp.

rng_type

template<typename config >

config::rng_type websocketpp::connection< config >::rng_type

Definition at line 275 of file connection.hpp.

scoped_lock_type

template<typename config >

concurrency_type::scoped_lock_type websocketpp::connection< config >::scoped_lock_type

Definition at line 262 of file connection.hpp.

termination_handler

template<typename config >

lib::function<void(ptr)> websocketpp::connection< config >::termination_handler

Definition at line 260 of file connection.hpp.

timer_ptr

template<typename config >

transport_con_type::timer_ptr websocketpp::connection< config >::timer_ptr

Definition at line 284 of file connection.hpp.

transport_con_ptr

template<typename config >

transport_con_type::ptr websocketpp::connection< config >::transport_con_ptr

Definition at line 258 of file connection.hpp.

transport_con_type

template<typename config >

config::transport_type::transport_con_type websocketpp::connection< config >::transport_con_type

Definition at line 256 of file connection.hpp.

type

template<typename config >

connection<config> websocketpp::connection< config >::type

Definition at line 241 of file connection.hpp.

weak_ptr

template<typename config >

lib::weak_ptr<type> websocketpp::connection< config >::weak_ptr

Definition at line 245 of file connection.hpp.

Constructor & Destructor Documentation

connection()

template<typename config >

websocketpp::connection< config >::connection ( bool p_is_server, std::string const & ua, alog_type & alog, elog_type & elog, rng_type & rng )

inlineexplicit

Definition at line 297 of file connection.hpp.

      : transport_con_type(p_is_server, alog, elog)
      , m_handle_read_frame(lib::bind(
            &type::handle_read_frame,
            this,
            lib::placeholders::_1,
            lib::placeholders::_2
        ))
      , m_write_frame_handler(lib::bind(
            &type::handle_write_frame,
            this,
            lib::placeholders::_1
        ))
      , m_user_agent(ua)
      , m_open_handshake_timeout_dur(config::timeout_open_handshake)
      , m_close_handshake_timeout_dur(config::timeout_close_handshake)
      , m_pong_timeout_dur(config::timeout_pong)
      , m_max_message_size(config::max_message_size)
      , m_state(session::state::connecting)
      , m_internal_state(session::internal_state::USER_INIT)
      , m_msg_manager(new con_msg_manager_type())
      , m_send_buffer_size(0)
      , m_write_flag(false)
      , m_read_flag(true)
      , m_is_server(p_is_server)
      , m_alog(alog)
      , m_elog(elog)
      , m_rng(rng)
      , m_local_close_code(close::status::abnormal_close)
      , m_remote_close_code(close::status::abnormal_close)
      , m_is_http(false)
      , m_http_state(session::http_state::init)
      , m_was_clean(false)
    {
        m_alog.write(log::alevel::devel,"connection constructor");
    }

Here is the call graph for this function:

Member Function Documentation

add_subprotocol() [1/2]

template<typename config >

void websocketpp::connection< config >::add_subprotocol

(

std::string const &

request

)

Adds a subprotocol to the list to send with the opening handshake. This may be called multiple times to request more than one. If the server supports one of these, it may choose one. If so, it will return it in it's handshake reponse and the value will be available via get_subprotocol(). Subprotocol requests should be added in order of preference.

Parameters

request

The subprotocol to request

Definition at line 478 of file connection_impl.hpp.

                                                                {
    lib::error_code ec;
    this->add_subprotocol(value,ec);
    if (ec) {
        throw exception(ec);
    }
}

add_subprotocol() [2/2]

template<typename config >

void websocketpp::connection< config >::add_subprotocol	(	std::string const &	request,
		lib::error_code &	ec )

Adds a subprotocol to the list to send with the opening handshake. This may be called multiple times to request more than one. If the server supports one of these, it may choose one. If so, it will return it in it's handshake reponse and the value will be available via get_subprotocol(). Subprotocol requests should be added in order of preference.

Parameters

request	The subprotocol to request
ec	A reference to an error code that will be filled in the case of errors

Definition at line 458 of file connection_impl.hpp.

{
    if (m_is_server) {
        ec = error::make_error_code(error::client_only);
        return;
    }
 
    // If the value is empty or has a non-RFC2616 token character it is invalid.
    if (value.empty() || std::find_if(value.begin(),value.end(),
                                      http::is_not_token_char) != value.end())
    {
        ec = error::make_error_code(error::invalid_subprotocol);
        return;
    }
 
    m_requested_subprotocols.push_back(value);
}

Here is the call graph for this function:

append_header()

template<typename config >

void websocketpp::connection< config >::append_header	(	std::string const &	key,
		std::string const &	val )

If a header with this name already exists the value will be appended to the existing header to form a comma separated list of values. Use connection::replace_header to overwrite existing values.

This member function is valid only from the http() and validate() handler callbacks, or to a client connection before connect has been called.

Parameters

key	Name of the header to set
val	Value to add

See also

replace_header

websocketpp::http::parser::append_header

Definition at line 590 of file connection_impl.hpp.

{
    if (m_is_server) {
        if (m_internal_state == istate::PROCESS_HTTP_REQUEST) {
            // we are setting response headers for an incoming server connection
            m_response.append_header(key,val);
        } else {
            throw exception("Call to append_header from invalid state",
                      error::make_error_code(error::invalid_state));
        }
    } else {
        if (m_internal_state == istate::USER_INIT) {
            // we are setting initial headers for an outgoing client connection
            m_request.append_header(key,val);
        } else {
            throw exception("Call to append_header from invalid state",
                      error::make_error_code(error::invalid_state));
        }
    }
}

Here is the call graph for this function:

buffered_amount()

template<typename config >

size_t websocketpp::connection< config >::buffered_amount ( ) const

inline

Deprecated

use get_buffered_amount instead

Definition at line 635 of file connection.hpp.

                                   {
        return get_buffered_amount();
    }

Here is the call graph for this function:

close() [1/2]

template<typename config >

void websocketpp::connection< config >::close	(	close::status::value const	code,
		std::string const &	reason )

Initiates the close handshake process.

If close returns successfully the connection will be in the closing state and no additional messages may be sent. All messages sent prior to calling close will be written out before the connection is closed.

If no reason is specified none will be sent. If no code is specified then no code will be sent.

The handler's on_close callback will be called once the close handshake is complete.

Reasons will be automatically truncated to the maximum length (123 bytes) if necessary.

Parameters

code	The close code to send
reason	The close reason to send

Definition at line 326 of file connection_impl.hpp.

{
    lib::error_code ec;
    close(code,reason,ec);
    if (ec) {
        throw exception(ec);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

close() [2/2]

template<typename config >

void websocketpp::connection< config >::close	(	close::status::value const	code,
		std::string const &	reason,
		lib::error_code &	ec )

Definition at line 304 of file connection_impl.hpp.

{
    if (m_alog.static_test(log::alevel::devel)) {
        m_alog.write(log::alevel::devel,"connection close");
    }
 
    // Truncate reason to maximum size allowable in a close frame.
    std::string tr(reason,0,std::min<size_t>(reason.size(),
        frame::limits::close_reason_size));
 
    scoped_lock_type lock(m_connection_state_lock);
 
    if (m_state != session::state::open) {
       ec = error::make_error_code(error::invalid_state);
       return;
    }
 
    ec = this->send_close_frame(code,tr,false,close::status::terminal(code));
}

Here is the call graph for this function:

defer_http_response()

template<typename config >

lib::error_code websocketpp::connection< config >::defer_http_response

(

)

Defer HTTP Response until later.

Used in the http handler to defer the HTTP response for this connection until later. Handshake timers will be canceled and the connection will be left open until send_http_response or an equivalent is called.

Warning: deferred connections won't time out and as a result can tie up resources.

Since

0.6.0

Returns

A status code, zero on success, non-zero otherwise

Used in the http handler to defer the HTTP response for this connection until later. Handshake timers will be canceled and the connection will be left open until send_http_response or an equivalent is called.

Warning: deferred connections won't time out and as a result can tie up resources.

Returns

A status code, zero on success, non-zero otherwise

Definition at line 671 of file connection_impl.hpp.

                                                      {
    // Cancel handshake timer, otherwise the connection will time out and we'll
    // close the connection before the app has a chance to send a response.
    if (m_handshake_timer) {
        m_handshake_timer->cancel();
        m_handshake_timer.reset();
    }
    
    // Do something to signal deferral
    m_http_state = session::http_state::deferred;
    
    return lib::error_code();
}

get_buffered_amount()

template<typename config >

size_t websocketpp::connection< config >::get_buffered_amount

(

)

const

Retrieves the number of bytes in the outgoing write buffer that have not already been dispatched to the transport layer. This represents the bytes that are presently cancelable without uncleanly ending the websocket connection

This method invokes the m_write_lock mutex

Returns

The current number of bytes in the outgoing send buffer.

Definition at line 71 of file connection_impl.hpp.

                                                     {
    //scoped_lock_type lock(m_connection_state_lock);
    return m_send_buffer_size;
}

Here is the caller graph for this function:

get_ec()

template<typename config >

lib::error_code websocketpp::connection< config >::get_ec ( ) const

inline

Retrieves a machine readable detailed error code indicating the reason that the connection was closed or failed. Valid only after the close or fail handler is called.

Returns

Error code indicating the reason the connection was closed or failed

Definition at line 1255 of file connection.hpp.

                                 {
        return m_ec;
    }

get_handle()

template<typename config >

connection_hdl websocketpp::connection< config >::get_handle ( ) const

inline

The connection handle is a token that can be shared outside the WebSocket++ core for the purposes of identifying a connection and sending it messages.

Returns

A handle to the connection

Definition at line 1184 of file connection.hpp.

                                      {
        return m_connection_hdl;
    }

get_host()

template<typename config >

std::string const & websocketpp::connection< config >::get_host

(

)

const

This value is available after the HTTP request has been fully read and may be called from any thread.

Returns

The host component of the connection URI

Definition at line 412 of file connection_impl.hpp.

                                                     {
    //scoped_lock_type lock(m_connection_state_lock);
    return m_uri->get_host();
}

get_local_close_code()

template<typename config >

close::status::value websocketpp::connection< config >::get_local_close_code ( ) const

inline

Returns

The WebSocket close code sent by this endpoint.

Definition at line 1218 of file connection.hpp.

                                                  {
        return m_local_close_code;
    }

get_local_close_reason()

template<typename config >

std::string const & websocketpp::connection< config >::get_local_close_reason ( ) const

inline

Returns

The WebSocket close reason sent by this endpoint.

Definition at line 1226 of file connection.hpp.

                                                     {
        return m_local_close_reason;
    }

get_max_http_body_size()

template<typename config >

size_t websocketpp::connection< config >::get_max_http_body_size ( ) const

inline

Get maximum HTTP message body size. Maximum message body size determines the point at which the connection will stop reading an HTTP request whose body is too large.

The default is set by the endpoint that creates the connection.

Since

0.5.0

Returns

The maximum HTTP message body size

Definition at line 594 of file connection.hpp.

                                          {
        return m_request.get_max_body_size();
    }

get_max_message_size()

template<typename config >

size_t websocketpp::connection< config >::get_max_message_size ( ) const

inline

Get maximum message size. Maximum message size determines the point at which the connection will fail with the message_too_big protocol error.

The default is set by the endpoint that creates the connection.

Since

0.3.0

Definition at line 559 of file connection.hpp.

                                        {
        return m_max_message_size;
    }

get_message()

template<typename config >

message_ptr websocketpp::connection< config >::get_message ( websocketpp::frame::opcode::value op, size_t size ) const

inline

Warning: The API related to directly sending message buffers may change before the 1.0 release. If you plan to use it, please keep an eye on any breaking changes notifications in future release notes. Also if you have any feedback about usage and capabilities now is a great time to provide it.

Message buffers are used to store message payloads and other message metadata.

The size parameter is a hint only. Your final payload does not need to match it. There may be some performance benefits if the initial size guess is equal to or slightly higher than the final payload size.

Parameters

op	The opcode for the new message
size	A hint to optimize the initial allocation of payload space.

Returns

A new message buffer

Definition at line 1278 of file connection.hpp.

    {
        return m_msg_manager->get_message(op, size);
    }

get_origin()

template<typename config >

std::string const & websocketpp::connection< config >::get_origin

(

)

const

This value is available after the HTTP request has been fully read and may be called from any thread.

Returns

The connection's origin value from the opening handshake.

Definition at line 65 of file connection_impl.hpp.

                                                       {
    //scoped_lock_type lock(m_connection_state_lock);
    return m_processor->get_origin(m_request);
}

get_port()

template<typename config >

uint16_t websocketpp::connection< config >::get_port

(

)

const

This value is available after the HTTP request has been fully read and may be called from any thread.

Returns

The port component of the connection URI

Definition at line 424 of file connection_impl.hpp.

                                            {
    //scoped_lock_type lock(m_connection_state_lock);
    return m_uri->get_port();
}

get_remote_close_code()

template<typename config >

close::status::value websocketpp::connection< config >::get_remote_close_code ( ) const

inline

Returns

The WebSocket close code sent by the remote endpoint.

Definition at line 1234 of file connection.hpp.

                                                   {
        return m_remote_close_code;
    }

get_remote_close_reason()

template<typename config >

std::string const & websocketpp::connection< config >::get_remote_close_reason ( ) const

inline

Returns

The WebSocket close reason sent by the remote endpoint.

Definition at line 1242 of file connection.hpp.

                                                      {
        return m_remote_close_reason;
    }

get_request()

template<typename config >

request_type const & websocketpp::connection< config >::get_request ( ) const

inline

Direct access to request object. This can be used to call methods of the request object that are not part of the standard request API that connection wraps.

Note use of this method involves using behavior specific to the configured HTTP policy. Such behavior may not work with alternate HTTP policies.

Since

0.3.0-alpha3

Returns

A const reference to the raw request object

Definition at line 1103 of file connection.hpp.

                                             {
        return m_request;
    }

get_request_body()

template<typename config >

std::string const & websocketpp::connection< config >::get_request_body

(

)

const

Retrieve the value of the request body. This value is typically used with PUT and POST requests to upload files or other data. Only HTTP connections will ever have bodies. WebSocket connection's will always have blank bodies.

Returns

The value of the request body.

Definition at line 533 of file connection_impl.hpp.

                                           {
    return m_request.get_body();
}

get_request_header()

template<typename config >

std::string const & websocketpp::connection< config >::get_request_header

(

std::string const &

key

)

const

Retrieve the value of a header from the handshake HTTP request.

Parameters

key	Name of the header to get

Returns

The value of the header

Definition at line 527 of file connection_impl.hpp.

                                                                  {
    return m_request.get_header(key);
}

get_requested_subprotocols()

template<typename config >

std::vector< std::string > const & websocketpp::connection< config >::get_requested_subprotocols

(

)

const

Retrieves the subprotocols that were requested during the handshake. This method is valid in the validate handler and later.

Returns

A vector of the requested subprotocol

Definition at line 453 of file connection_impl.hpp.

                                                     {
    return m_requested_subprotocols;
}

get_resource()

template<typename config >

std::string const & websocketpp::connection< config >::get_resource

(

)

const

This value is available after the HTTP request has been fully read and may be called from any thread.

Returns

The resource component of the connection URI

Definition at line 418 of file connection_impl.hpp.

                                                         {
    //scoped_lock_type lock(m_connection_state_lock);
    return m_uri->get_resource();
}

get_response()

template<typename config >

response_type const & websocketpp::connection< config >::get_response ( ) const

inline

Direct access to the HTTP response sent or received as a part of the opening handshake. This can be used to call methods of the response object that are not part of the standard request API that connection wraps.

Note use of this method involves using behavior specific to the configured HTTP policy. Such behavior may not work with alternate HTTP policies.

Since

0.7.0

Returns

A const reference to the raw response object

Definition at line 1122 of file connection.hpp.

                                               {
        return m_response;
    }

get_response_code()

template<typename config >

http::status_code::value websocketpp::connection< config >::get_response_code ( ) const

inline

Gets the response status code

Since

0.7.0

Returns

The response status code sent

Definition at line 983 of file connection.hpp.

                                                   {
        return m_response.get_status_code();
    }

get_response_header()

template<typename config >

std::string const & websocketpp::connection< config >::get_response_header

(

std::string const &

key

)

const

Retrieve the value of a header from the handshake HTTP request.

Parameters

key	Name of the header to get

Returns

The value of the header

Definition at line 539 of file connection_impl.hpp.

                                                                   {
    return m_response.get_header(key);
}

get_response_msg()

template<typename config >

std::string const & websocketpp::connection< config >::get_response_msg ( ) const

inline

Gets the response status message

Since

0.7.0

Returns

The response status message sent

Definition at line 995 of file connection.hpp.

                                               {
        return m_response.get_status_msg();
    }

get_secure()

template<typename config >

bool websocketpp::connection< config >::get_secure

(

)

const

This value is available after the HTTP request has been fully read and may be called from any thread.

Returns

Whether or not the connection URI is flagged secure.

Definition at line 406 of file connection_impl.hpp.

                                          {
    //scoped_lock_type lock(m_connection_state_lock);
    return m_uri->get_secure();
}

get_shared()

template<typename config >

ptr websocketpp::connection< config >::get_shared ( )

inline

Definition at line 336 of file connection.hpp.

                     {
        return lib::static_pointer_cast<type>(transport_con_type::get_shared());
    }

get_state()

template<typename config >

session::state::value websocketpp::connection< config >::get_state

(

)

const

Values can be connecting, open, closing, and closed

Returns

The connection's current state.

Definition at line 77 of file connection_impl.hpp.

                                                      {
    //scoped_lock_type lock(m_connection_state_lock);
    return m_state;
}

get_subprotocol()

template<typename config >

std::string const & websocketpp::connection< config >::get_subprotocol

(

)

const

Retrieves the subprotocol that was negotiated during the handshake. This method is valid in the open handler and later.

Returns

The negotiated subprotocol

Definition at line 447 of file connection_impl.hpp.

                                                            {
    return m_subprotocol;
}

get_supported_versions()

template<typename config >

std::vector< int > const & websocketpp::connection< config >::get_supported_versions

(

)

const

Definition at line 1940 of file connection_impl.hpp.

{
    return versions_supported;
}

get_uri()

template<typename config >

uri_ptr websocketpp::connection< config >::get_uri

(

)

const

This should really only be called by internal library methods unless you really know what you are doing.

Returns

A pointer to the connection's URI

Definition at line 430 of file connection_impl.hpp.

                                          {
    //scoped_lock_type lock(m_connection_state_lock);
    return m_uri;
}

handle_close_handshake_timeout()

template<typename config >

void websocketpp::connection< config >::handle_close_handshake_timeout

(

lib::error_code const &

ec

)

Definition at line 1691 of file connection_impl.hpp.

{
    if (ec == transport::error::operation_aborted) {
        m_alog.write(log::alevel::devel,"asio close handshake timer cancelled");
    } else if (ec) {
        m_alog.write(log::alevel::devel,
            "asio open handle_close_handshake_timeout error: "+ec.message());
        // TODO: ignore or fail here?
    } else {
        m_alog.write(log::alevel::devel, "asio close handshake timer expired");
        terminate(make_error_code(error::close_handshake_timeout));
    }
}

handle_interrupt()

template<typename config >

void websocketpp::connection< config >::handle_interrupt

(

)

Definition at line 353 of file connection_impl.hpp.

                                          {
    if (m_interrupt_handler) {
        m_interrupt_handler(m_connection_hdl);
    }
}

handle_open_handshake_timeout()

template<typename config >

void websocketpp::connection< config >::handle_open_handshake_timeout

(

lib::error_code const &

ec

)

Definition at line 1675 of file connection_impl.hpp.

{
    if (ec == transport::error::operation_aborted) {
        m_alog.write(log::alevel::devel,"open handshake timer cancelled");
    } else if (ec) {
        m_alog.write(log::alevel::devel,
            "open handle_open_handshake_timeout error: "+ec.message());
        // TODO: ignore or fail here?
    } else {
        m_alog.write(log::alevel::devel,"open handshake timer expired");
        terminate(make_error_code(error::open_handshake_timeout));
    }
}

handle_pause_reading()

template<typename config >

void websocketpp::connection< config >::handle_pause_reading

(

)

Pause reading handler. Not safe to call directly.

Definition at line 372 of file connection_impl.hpp.

                                              {
    m_alog.write(log::alevel::devel,"connection connection::handle_pause_reading");
    m_read_flag = false;
}

handle_pong_timeout()

template<typename config >

void websocketpp::connection< config >::handle_pong_timeout	(	std::string	payload,
		lib::error_code const &	ec )

Definition at line 233 of file connection_impl.hpp.

{
    if (ec) {
        if (ec == transport::error::operation_aborted) {
            // ignore, this is expected
            return;
        }
 
        m_elog.write(log::elevel::devel,"pong_timeout error: "+ec.message());
        return;
    }
 
    if (m_pong_timeout_handler) {
        m_pong_timeout_handler(m_connection_hdl,payload);
    }
}

handle_read_frame()

template<typename config >

void websocketpp::connection< config >::handle_read_frame	(	lib::error_code const &	ec,
		size_t	bytes_transferred )

Definition at line 975 of file connection_impl.hpp.

{
    //m_alog.write(log::alevel::devel,"connection handle_read_frame");
 
    lib::error_code ecm = ec;
 
    if (!ecm && m_internal_state != istate::PROCESS_CONNECTION) {
        ecm = error::make_error_code(error::invalid_state);
    }
 
    if (ecm) {
        log::level echannel = log::elevel::rerror;
        
        if (ecm == transport::error::eof) {
            if (m_state == session::state::closed) {
                // we expect to get eof if the connection is closed already
                // just ignore it
                m_alog.write(log::alevel::devel,"got eof from closed con");
                return;
            } else if (m_state == session::state::closing && !m_is_server) {
                // If we are a client we expect to get eof in the closing state,
                // this is a signal to terminate our end of the connection after
                // the closing handshake
                terminate(lib::error_code());
                return;
            }
        } else if (ecm == error::invalid_state) {
            // In general, invalid state errors in the closed state are the
            // result of handlers that were in the system already when the state
            // changed and should be ignored as they pose no problems and there
            // is nothing useful that we can do about them.
            if (m_state == session::state::closed) {
                m_alog.write(log::alevel::devel,
                    "handle_read_frame: got invalid istate in closed state");
                return;
            }
        } else if (ecm == transport::error::tls_short_read) {
            if (m_state == session::state::closed) {
                // We expect to get a TLS short read if we try to read after the
                // connection is closed. If this happens ignore and exit the
                // read frame path.
                terminate(lib::error_code());
                return;
            }
            echannel = log::elevel::rerror;
        } else if (ecm == transport::error::action_after_shutdown) {
            echannel = log::elevel::info;
        }
        
        log_err(echannel, "handle_read_frame", ecm);
        this->terminate(ecm);
        return;
    }
 
    // Boundaries checking. TODO: How much of this should be done?
    /*if (bytes_transferred > config::connection_read_buffer_size) {
        m_elog.write(log::elevel::fatal,"Fatal boundaries checking error");
        this->terminate(make_error_code(error::general));
        return;
    }*/
 
    size_t p = 0;
 
    if (m_alog.static_test(log::alevel::devel)) {
        std::stringstream s;
        s << "p = " << p << " bytes transferred = " << bytes_transferred;
        m_alog.write(log::alevel::devel,s.str());
    }
 
    while (p < bytes_transferred) {
        if (m_alog.static_test(log::alevel::devel)) {
            std::stringstream s;
            s << "calling consume with " << bytes_transferred-p << " bytes";
            m_alog.write(log::alevel::devel,s.str());
        }
 
        lib::error_code consume_ec;
 
        if (m_alog.static_test(log::alevel::devel)) {
            std::stringstream s;
            s << "Processing Bytes: " << utility::to_hex(reinterpret_cast<uint8_t*>(m_buf)+p,bytes_transferred-p);
            m_alog.write(log::alevel::devel,s.str());
        }
 
        p += m_processor->consume(
            reinterpret_cast<uint8_t*>(m_buf)+p,
            bytes_transferred-p,
            consume_ec
        );
 
        if (m_alog.static_test(log::alevel::devel)) {
            std::stringstream s;
            s << "bytes left after consume: " << bytes_transferred-p;
            m_alog.write(log::alevel::devel,s.str());
        }
        if (consume_ec) {
            log_err(log::elevel::rerror, "consume", consume_ec);
 
            if (config::drop_on_protocol_error) {
                this->terminate(consume_ec);
                return;
            } else {
                lib::error_code close_ec;
                this->close(
                    processor::error::to_ws(consume_ec),
                    consume_ec.message(),
                    close_ec
                );
 
                if (close_ec) {
                    log_err(log::elevel::fatal, "Protocol error close frame ", close_ec);
                    this->terminate(close_ec);
                    return;
                }
            }
            return;
        }
 
        if (m_processor->ready()) {
            if (m_alog.static_test(log::alevel::devel)) {
                std::stringstream s;
                s << "Complete message received. Dispatching";
                m_alog.write(log::alevel::devel,s.str());
            }
 
            message_ptr msg = m_processor->get_message();
 
            if (!msg) {
                m_alog.write(log::alevel::devel, "null message from m_processor");
            } else if (!is_control(msg->get_opcode())) {
                // data message, dispatch to user
                if (m_state != session::state::open) {
                    m_elog.write(log::elevel::warn, "got non-close frame while closing");
                } else if (m_message_handler) {
                    m_message_handler(m_connection_hdl, msg);
                }
            } else {
                process_control_frame(msg);
            }
        }
    }
 
    read_frame();
}

Here is the call graph for this function:

handle_read_handshake()

template<typename config >

void websocketpp::connection< config >::handle_read_handshake	(	lib::error_code const &	ec,
		size_t	bytes_transferred )

Definition at line 814 of file connection_impl.hpp.

{
    m_alog.write(log::alevel::devel,"connection handle_read_handshake");
 
    lib::error_code ecm = ec;
 
    if (!ecm) {
        scoped_lock_type lock(m_connection_state_lock);
        
        if (m_state == session::state::connecting) {
             if (m_internal_state != istate::READ_HTTP_REQUEST) {
                ecm = error::make_error_code(error::invalid_state);
             }
        } else if (m_state == session::state::closed) {
            // The connection was canceled while the response was being sent,
            // usually by the handshake timer. This is basically expected
            // (though hopefully rare) and there is nothing we can do so ignore.
            m_alog.write(log::alevel::devel,
                "handle_read_handshake invoked after connection was closed");
            return;
        } else {
            ecm = error::make_error_code(error::invalid_state);
        }
    }
 
    if (ecm) {
        if (ecm == transport::error::eof && m_state == session::state::closed) {
            // we expect to get eof if the connection is closed already
            m_alog.write(log::alevel::devel,
                    "got (expected) eof/state error from closed con");
            return;
        }
        
        log_err(log::elevel::rerror,"handle_read_handshake",ecm);
        this->terminate(ecm);
        return;
    }
 
    // Boundaries checking. TODO: How much of this should be done?
    if (bytes_transferred > config::connection_read_buffer_size) {
        m_elog.write(log::elevel::fatal,"Fatal boundaries checking error.");
        this->terminate(make_error_code(error::general));
        return;
    }
 
    size_t bytes_processed = 0;
    try {
        bytes_processed = m_request.consume(m_buf,bytes_transferred);
    } catch (http::exception &e) {
        // All HTTP exceptions will result in this request failing and an error
        // response being returned. No more bytes will be read in this con.
        m_response.set_status(e.m_error_code,e.m_error_msg);
        this->write_http_response_error(error::make_error_code(error::http_parse_error));
        return;
    }
 
    // More paranoid boundaries checking.
    // TODO: Is this overkill?
    if (bytes_processed > bytes_transferred) {
        m_elog.write(log::elevel::fatal,"Fatal boundaries checking error.");
        this->terminate(make_error_code(error::general));
        return;
    }
 
    if (m_alog.static_test(log::alevel::devel)) {
        std::stringstream s;
        s << "bytes_transferred: " << bytes_transferred
          << " bytes, bytes processed: " << bytes_processed << " bytes";
        m_alog.write(log::alevel::devel,s.str());
    }
 
    if (m_request.ready()) {
        lib::error_code processor_ec = this->initialize_processor();
        if (processor_ec) {
            this->write_http_response_error(processor_ec);
            return;
        }
 
        if (m_processor && m_processor->get_version() == 0) {
            // Version 00 has an extra requirement to read some bytes after the
            // handshake
            if (bytes_transferred-bytes_processed >= 8) {
                m_request.replace_header(
                    "Sec-WebSocket-Key3",
                    std::string(m_buf+bytes_processed,m_buf+bytes_processed+8)
                );
                bytes_processed += 8;
            } else {
                // TODO: need more bytes
                m_alog.write(log::alevel::devel,"short key3 read");
                m_response.set_status(http::status_code::internal_server_error);
                this->write_http_response_error(processor::error::make_error_code(processor::error::short_key3));
                return;
            }
        }
 
        if (m_alog.static_test(log::alevel::devel)) {
            m_alog.write(log::alevel::devel,m_request.raw());
            if (!m_request.get_header("Sec-WebSocket-Key3").empty()) {
                m_alog.write(log::alevel::devel,
                    utility::to_hex(m_request.get_header("Sec-WebSocket-Key3")));
            }
        }
 
        // The remaining bytes in m_buf are frame data. Copy them to the
        // beginning of the buffer and note the length. They will be read after
        // the handshake completes and before more bytes are read.
        std::copy(m_buf+bytes_processed,m_buf+bytes_transferred,m_buf);
        m_buf_cursor = bytes_transferred-bytes_processed;
 
 
        m_internal_state = istate::PROCESS_HTTP_REQUEST;
        
        // We have the complete request. Process it.
        lib::error_code handshake_ec = this->process_handshake_request();
        
        // Write a response if this is a websocket connection or if it is an
        // HTTP connection for which the response has not been deferred or
        // started yet by a different system (i.e. still in init state).
        if (!m_is_http || m_http_state == session::http_state::init) {
            this->write_http_response(handshake_ec);
        }
    } else {
        // read at least 1 more byte
        transport_con_type::async_read_at_least(
            1,
            m_buf,
            config::connection_read_buffer_size,
            lib::bind(
                &type::handle_read_handshake,
                type::get_shared(),
                lib::placeholders::_1,
                lib::placeholders::_2
            )
        );
    }
}

handle_read_http_response()

template<typename config >

void websocketpp::connection< config >::handle_read_http_response	(	lib::error_code const &	ec,
		size_t	bytes_transferred )

Definition at line 1555 of file connection_impl.hpp.

{
    m_alog.write(log::alevel::devel,"handle_read_http_response");
 
    lib::error_code ecm = ec;
 
    if (!ecm) {
        scoped_lock_type lock(m_connection_state_lock);
        
        if (m_state == session::state::connecting) {
            if (m_internal_state != istate::READ_HTTP_RESPONSE) {
                ecm = error::make_error_code(error::invalid_state);
            }
        } else if (m_state == session::state::closed) {
            // The connection was canceled while the response was being sent,
            // usually by the handshake timer. This is basically expected
            // (though hopefully rare) and there is nothing we can do so ignore.
            m_alog.write(log::alevel::devel,
                "handle_read_http_response invoked after connection was closed");
            return;
        } else {
            ecm = error::make_error_code(error::invalid_state);
        }
    }
 
    if (ecm) {
        if (ecm == transport::error::eof && m_state == session::state::closed) {
            // we expect to get eof if the connection is closed already
            m_alog.write(log::alevel::devel,
                    "got (expected) eof/state error from closed con");
            return;
        }
        
        log_err(log::elevel::rerror,"handle_read_http_response",ecm);
        this->terminate(ecm);
        return;
    }
    
    size_t bytes_processed = 0;
    // TODO: refactor this to use error codes rather than exceptions
    try {
        bytes_processed = m_response.consume(m_buf,bytes_transferred);
    } catch (http::exception & e) {
        m_elog.write(log::elevel::rerror,
            std::string("error in handle_read_http_response: ")+e.what());
        this->terminate(make_error_code(error::general));
        return;
    }
 
    m_alog.write(log::alevel::devel,std::string("Raw response: ")+m_response.raw());
 
    if (m_response.headers_ready()) {
        if (m_handshake_timer) {
            m_handshake_timer->cancel();
            m_handshake_timer.reset();
        }
 
        lib::error_code validate_ec = m_processor->validate_server_handshake_response(
            m_request,
            m_response
        );
        if (validate_ec) {
            log_err(log::elevel::rerror,"Server handshake response",validate_ec);
            this->terminate(validate_ec);
            return;
        }
 
        // Read extension parameters and set up values necessary for the end
        // user to complete extension negotiation.
        std::pair<lib::error_code,std::string> neg_results;
        neg_results = m_processor->negotiate_extensions(m_response);
 
        if (neg_results.first) {
            // There was a fatal error in extension negotiation. For the moment
            // kill all connections that fail extension negotiation.
            
            // TODO: deal with cases where the response is well formed but 
            // doesn't match the options requested by the client. Its possible
            // that the best behavior in this cases is to log and continue with
            // an unextended connection.
            m_alog.write(log::alevel::devel, "Extension negotiation failed: " 
                + neg_results.first.message());
            this->terminate(make_error_code(error::extension_neg_failed));
            // TODO: close connection with reason 1010 (and list extensions)
        }
 
        // response is valid, connection can now be assumed to be open      
        m_internal_state = istate::PROCESS_CONNECTION;
        m_state = session::state::open;
 
        this->log_open_result();
 
        if (m_open_handler) {
            m_open_handler(m_connection_hdl);
        }
 
        // The remaining bytes in m_buf are frame data. Copy them to the
        // beginning of the buffer and note the length. They will be read after
        // the handshake completes and before more bytes are read.
        std::copy(m_buf+bytes_processed,m_buf+bytes_transferred,m_buf);
        m_buf_cursor = bytes_transferred-bytes_processed;
 
        this->handle_read_frame(lib::error_code(), m_buf_cursor);
    } else {
        transport_con_type::async_read_at_least(
            1,
            m_buf,
            config::connection_read_buffer_size,
            lib::bind(
                &type::handle_read_http_response,
                type::get_shared(),
                lib::placeholders::_1,
                lib::placeholders::_2
            )
        );
    }
}

Here is the call graph for this function:

handle_resume_reading()

template<typename config >

void websocketpp::connection< config >::handle_resume_reading

(

)

Resume reading helper method. Not safe to call directly.

Definition at line 390 of file connection_impl.hpp.

                                               {
   m_read_flag = true;
   read_frame();
}

handle_send_http_request()

template<typename config >

void websocketpp::connection< config >::handle_send_http_request

(

lib::error_code const &

ec

)

Definition at line 1502 of file connection_impl.hpp.

                                                                          {
    m_alog.write(log::alevel::devel,"handle_send_http_request");
 
    lib::error_code ecm = ec;
 
    if (!ecm) {
        scoped_lock_type lock(m_connection_state_lock);
        
        if (m_state == session::state::connecting) {
             if (m_internal_state != istate::WRITE_HTTP_REQUEST) {
                ecm = error::make_error_code(error::invalid_state);
             } else {
                m_internal_state = istate::READ_HTTP_RESPONSE;
             }
        } else if (m_state == session::state::closed) {
            // The connection was canceled while the response was being sent,
            // usually by the handshake timer. This is basically expected
            // (though hopefully rare) and there is nothing we can do so ignore.
            m_alog.write(log::alevel::devel,
                "handle_send_http_request invoked after connection was closed");
            return;
        } else {
            ecm = error::make_error_code(error::invalid_state);
        }
    }
 
    if (ecm) {
        if (ecm == transport::error::eof && m_state == session::state::closed) {
            // we expect to get eof if the connection is closed already
            m_alog.write(log::alevel::devel,
                    "got (expected) eof/state error from closed con");
            return;
        }
        
        log_err(log::elevel::rerror,"handle_send_http_request",ecm);
        this->terminate(ecm);
        return;
    }
 
    transport_con_type::async_read_at_least(
        1,
        m_buf,
        config::connection_read_buffer_size,
        lib::bind(
            &type::handle_read_http_response,
            type::get_shared(),
            lib::placeholders::_1,
            lib::placeholders::_2
        )
    );
}

Here is the call graph for this function:

handle_terminate()

template<typename config >

void websocketpp::connection< config >::handle_terminate	(	terminate_status	tstat,
		lib::error_code const &	ec )

Definition at line 1760 of file connection_impl.hpp.

{
    if (m_alog.static_test(log::alevel::devel)) {
        m_alog.write(log::alevel::devel,"connection handle_terminate");
    }
 
    if (ec) {
        // there was an error actually shutting down the connection
        log_err(log::elevel::devel,"handle_terminate",ec);
    }
 
    // clean shutdown
    if (tstat == failed) {
        if (m_ec != error::http_connection_ended) {
            if (m_fail_handler) {
                m_fail_handler(m_connection_hdl);
            }
        }
    } else if (tstat == closed) {
        if (m_close_handler) {
            m_close_handler(m_connection_hdl);
        }
        log_close_result();
    } else {
        m_elog.write(log::elevel::rerror,"Unknown terminate_status");
    }
 
    // call the termination handler if it exists
    // if it exists it might (but shouldn't) refer to a bad memory location.
    // If it does, we don't care and should catch and ignore it.
    if (m_termination_handler) {
        try {
            m_termination_handler(type::get_shared());
        } catch (std::exception const & e) {
            m_elog.write(log::elevel::warn,
                std::string("termination_handler call failed. Reason was: ")+e.what());
        }
    }
}

handle_transport_init()

template<typename config >

void websocketpp::connection< config >::handle_transport_init ( lib::error_code const & ec )

protected

Definition at line 750 of file connection_impl.hpp.

                                                                       {
    m_alog.write(log::alevel::devel,"connection handle_transport_init");
 
    lib::error_code ecm = ec;
 
    if (m_internal_state != istate::TRANSPORT_INIT) {
        m_alog.write(log::alevel::devel,
          "handle_transport_init must be called from transport init state");
        ecm = error::make_error_code(error::invalid_state);
    }
 
    if (ecm) {
        std::stringstream s;
        s << "handle_transport_init received error: "<< ecm.message();
        m_elog.write(log::elevel::rerror,s.str());
 
        this->terminate(ecm);
        return;
    }
 
    // At this point the transport is ready to read and write bytes.
    if (m_is_server) {
        m_internal_state = istate::READ_HTTP_REQUEST;
        this->read_handshake(1);
    } else {
        // We are a client. Set the processor to the version specified in the
        // config file and send a handshake request.
        m_internal_state = istate::WRITE_HTTP_REQUEST;
        m_processor = get_processor(config::client_version);
        this->send_http_request();
    }
}

handle_write_frame()

template<typename config >

void websocketpp::connection< config >::handle_write_frame

(

lib::error_code const &

ec

)

Todo

unit tests

This method locks the m_write_lock mutex

Parameters

terminate	Whether or not to terminate the connection upon completion of this write.
ec	A status code from the transport layer, zero on success, non-zero otherwise.

Definition at line 1898 of file connection_impl.hpp.

{
    if (m_alog.static_test(log::alevel::devel)) {
        m_alog.write(log::alevel::devel,"connection handle_write_frame");
    }
 
    bool terminal = m_current_msgs.back()->get_terminal();
 
    m_send_buffer.clear();
    m_current_msgs.clear();
    // TODO: recycle instead of deleting
 
    if (ec) {
        log_err(log::elevel::fatal,"handle_write_frame",ec);
        this->terminate(ec);
        return;
    }
 
    if (terminal) {
        this->terminate(lib::error_code());
        return;
    }
 
    bool needs_writing = false;
    {
        scoped_lock_type lock(m_write_lock);
 
        // release write flag
        m_write_flag = false;
 
        needs_writing = !m_send_queue.empty();
    }
 
    if (needs_writing) {
        transport_con_type::dispatch(lib::bind(
            &type::write_frame,
            type::get_shared()
        ));
    }
}

Here is the call graph for this function:

handle_write_http_response()

template<typename config >

void websocketpp::connection< config >::handle_write_http_response

(

lib::error_code const &

ec

)

Definition at line 1360 of file connection_impl.hpp.

                                                                            {
    m_alog.write(log::alevel::devel,"handle_write_http_response");
 
    lib::error_code ecm = ec;
 
    if (!ecm) {
        scoped_lock_type lock(m_connection_state_lock);
        
        if (m_state == session::state::connecting) {
             if (m_internal_state != istate::PROCESS_HTTP_REQUEST) {
                ecm = error::make_error_code(error::invalid_state);
             }
        } else if (m_state == session::state::closed) {
            // The connection was canceled while the response was being sent,
            // usually by the handshake timer. This is basically expected
            // (though hopefully rare) and there is nothing we can do so ignore.
            m_alog.write(log::alevel::devel,
                "handle_write_http_response invoked after connection was closed");
            return;
        } else {
            ecm = error::make_error_code(error::invalid_state);
        }
    }
 
    if (ecm) {
        if (ecm == transport::error::eof && m_state == session::state::closed) {
            // we expect to get eof if the connection is closed already
            m_alog.write(log::alevel::devel,
                    "got (expected) eof/state error from closed con");
            return;
        }
        
        log_err(log::elevel::rerror,"handle_write_http_response",ecm);
        this->terminate(ecm);
        return;
    }
 
    if (m_handshake_timer) {
        m_handshake_timer->cancel();
        m_handshake_timer.reset();
    }
 
    if (m_response.get_status_code() != http::status_code::switching_protocols)
    {
        /*if (m_processor || m_ec == error::http_parse_error || 
            m_ec == error::invalid_version || m_ec == error::unsupported_version
            || m_ec == error::upgrade_required)
        {*/
        if (!m_is_http) {
            std::stringstream s;
            s << "Handshake ended with HTTP error: "
              << m_response.get_status_code();
            m_elog.write(log::elevel::rerror,s.str());
        } else {
            // if this was not a websocket connection, we have written
            // the expected response and the connection can be closed.
            
            this->log_http_result();
            
            if (m_ec) {
                m_alog.write(log::alevel::devel,
                    "got to writing HTTP results with m_ec set: "+m_ec.message());
            }
            m_ec = make_error_code(error::http_connection_ended);
        }        
        
        this->terminate(m_ec);
        return;
    }
 
    this->log_open_result();
 
    m_internal_state = istate::PROCESS_CONNECTION;
    m_state = session::state::open;
 
    if (m_open_handler) {
        m_open_handler(m_connection_hdl);
    }
 
    this->handle_read_frame(lib::error_code(), m_buf_cursor);
}

initialize_processor()

template<typename config >

lib::error_code websocketpp::connection< config >::initialize_processor ( )

protected

Set m_processor based on information in m_request. Set m_response status and return an error code indicating status.

Definition at line 1144 of file connection_impl.hpp.

                                                       {
    m_alog.write(log::alevel::devel,"initialize_processor");
 
    // if it isn't a websocket handshake nothing to do.
    if (!processor::is_websocket_handshake(m_request)) {
        return lib::error_code();
    }
 
    int version = processor::get_websocket_version(m_request);
 
    if (version < 0) {
        m_alog.write(log::alevel::devel, "BAD REQUEST: can't determine version");
        m_response.set_status(http::status_code::bad_request);
        return error::make_error_code(error::invalid_version);
    }
 
    m_processor = get_processor(version);
 
    // if the processor is not null we are done
    if (m_processor) {
        return lib::error_code();
    }
 
    // We don't have a processor for this version. Return bad request
    // with Sec-WebSocket-Version header filled with values we do accept
    m_alog.write(log::alevel::devel, "BAD REQUEST: no processor for version");
    m_response.set_status(http::status_code::bad_request);
 
    std::stringstream ss;
    std::string sep;
    std::vector<int>::const_iterator it;
    for (it = versions_supported.begin(); it != versions_supported.end(); it++)
    {
        ss << sep << *it;
        sep = ",";
    }
 
    m_response.replace_header("Sec-WebSocket-Version",ss.str());
    return error::make_error_code(error::unsupported_version);
}

Here is the call graph for this function:

interrupt()

template<typename config >

lib::error_code websocketpp::connection< config >::interrupt

(

)

Trigger the on_interrupt handler.

Signals to the connection to asyncronously invoke the on_inturrupt callback for this connection's handler once it is safe to do so.

When the on_inturrupt handler callback is called it will be from within the transport event loop with all the thread safety features guaranteed by the transport to regular handlers

Multiple inturrupt signals can be active at once on the same connection

Returns

An error code

This is thread safe if the transport is thread safe

Definition at line 341 of file connection_impl.hpp.

                                            {
    m_alog.write(log::alevel::devel,"connection connection::interrupt");
    return transport_con_type::interrupt(
        lib::bind(
            &type::handle_interrupt,
            type::get_shared()
        )
    );
}

is_server()

template<typename config >

bool websocketpp::connection< config >::is_server ( ) const

inline

Returns

whether or not the connection is attached to a server endpoint

Definition at line 1192 of file connection.hpp.

                           {
        return m_is_server;
    }

Here is the caller graph for this function:

pause_reading()

template<typename config >

lib::error_code websocketpp::connection< config >::pause_reading

(

)

Signals to the connection to halt reading of new data. While reading is paused, the connection will stop reading from its associated socket. In turn this will result in TCP based flow control kicking in and slowing data flow from the remote endpoint.

This is useful for applications that push new requests to a queue to be processed by another thread and need a way to signal when their request queue is full without blocking the network processing thread.

Use resume_reading() to resume.

If supported by the transport this is done asynchronously. As such reading may not stop until the current read operation completes. Typically you can expect to receive no more bytes after initiating a read pause than the size of the read buffer.

If reading is paused for this connection already nothing is changed.

Definition at line 360 of file connection_impl.hpp.

                                                {
    m_alog.write(log::alevel::devel,"connection connection::pause_reading");
    return transport_con_type::dispatch(
        lib::bind(
            &type::handle_pause_reading,
            type::get_shared()
        )
    );
}

ping() [1/2]

template<typename config >

void websocketpp::connection< config >::ping

(

std::string const &

payload

)

Initiates a ping with the given payload/

There is no feedback directly from ping except in cases of immediately detectable errors. Feedback will be provided via on_pong or on_pong_timeout callbacks.

Ping locks the m_write_lock mutex

Parameters

payload

Payload to be used for the ping

Definition at line 224 of file connection_impl.hpp.

                                                       {
    lib::error_code ec;
    ping(payload,ec);
    if (ec) {
        throw exception(ec);
    }
}

ping() [2/2]

template<typename config >

void websocketpp::connection< config >::ping	(	std::string const &	payload,
		lib::error_code &	ec )

Definition at line 155 of file connection_impl.hpp.

                                                                         {
    if (m_alog.static_test(log::alevel::devel)) {
        m_alog.write(log::alevel::devel,"connection ping");
    }
 
    {
        scoped_lock_type lock(m_connection_state_lock);
        if (m_state != session::state::open) {
            std::stringstream ss;
            ss << "connection::ping called from invalid state " << m_state;
            m_alog.write(log::alevel::devel,ss.str());
            ec = error::make_error_code(error::invalid_state);
            return;
        }
    }
 
    message_ptr msg = m_msg_manager->get_message();
    if (!msg) {
        ec = error::make_error_code(error::no_outgoing_buffers);
        return;
    }
 
    ec = m_processor->prepare_ping(payload,msg);
    if (ec) {return;}
 
    // set ping timer if we are listening for one
    if (m_pong_timeout_handler) {
        // Cancel any existing timers
        if (m_ping_timer) {
            m_ping_timer->cancel();
        }
 
        if (m_pong_timeout_dur > 0) {
            m_ping_timer = transport_con_type::set_timer(
                m_pong_timeout_dur,
                lib::bind(
                    &type::handle_pong_timeout,
                    type::get_shared(),
                    payload,
                    lib::placeholders::_1
                )
            );
        }
 
        if (!m_ping_timer) {
            // Our transport doesn't support timers
            m_elog.write(log::elevel::warn,"Warning: a pong_timeout_handler is \
                set but the transport in use does not support timeouts.");
        }
    }
 
    bool needs_writing = false;
    {
        scoped_lock_type lock(m_write_lock);
        write_push(msg);
        needs_writing = !m_write_flag && !m_send_queue.empty();
    }
 
    if (needs_writing) {
        transport_con_type::dispatch(lib::bind(
            &type::write_frame,
            type::get_shared()
        ));
    }
 
    ec = lib::error_code();
}

Here is the call graph for this function:

pong() [1/2]

template<typename config >

void websocketpp::connection< config >::pong

(

std::string const &

payload

)

Initiates a pong with the given payload.

There is no feedback from a pong once sent.

Pong locks the m_write_lock mutex

Parameters

payload

Payload to be used for the pong

Definition at line 295 of file connection_impl.hpp.

                                                       {
    lib::error_code ec;
    pong(payload,ec);
    if (ec) {
        throw exception(ec);
    }
}

pong() [2/2]

template<typename config >

void websocketpp::connection< config >::pong	(	std::string const &	payload,
		lib::error_code &	ec )

Definition at line 252 of file connection_impl.hpp.

                                                                         {
    if (m_alog.static_test(log::alevel::devel)) {
        m_alog.write(log::alevel::devel,"connection pong");
    }
 
    {
        scoped_lock_type lock(m_connection_state_lock);
        if (m_state != session::state::open) {
            std::stringstream ss;
            ss << "connection::pong called from invalid state " << m_state;
            m_alog.write(log::alevel::devel,ss.str());
            ec = error::make_error_code(error::invalid_state);
            return;
        }
    }
 
    message_ptr msg = m_msg_manager->get_message();
    if (!msg) {
        ec = error::make_error_code(error::no_outgoing_buffers);
        return;
    }
 
    ec = m_processor->prepare_pong(payload,msg);
    if (ec) {return;}
 
    bool needs_writing = false;
    {
        scoped_lock_type lock(m_write_lock);
        write_push(msg);
        needs_writing = !m_write_flag && !m_send_queue.empty();
    }
 
    if (needs_writing) {
        transport_con_type::dispatch(lib::bind(
            &type::write_frame,
            type::get_shared()
        ));
    }
 
    ec = lib::error_code();
}

Here is the call graph for this function:

process_handshake_request()

template<typename config >

lib::error_code websocketpp::connection< config >::process_handshake_request ( )

protected

Perform WebSocket handshake validation of m_request using m_processor. set m_response and return an error code indicating status.

Definition at line 1186 of file connection_impl.hpp.

                                                            {
    m_alog.write(log::alevel::devel,"process handshake request");
 
    if (!processor::is_websocket_handshake(m_request)) {
        // this is not a websocket handshake. Process as plain HTTP
        m_alog.write(log::alevel::devel,"HTTP REQUEST");
 
        // extract URI from request
        m_uri = processor::get_uri_from_host(
            m_request,
            (transport_con_type::is_secure() ? "https" : "http")
        );
 
        if (!m_uri->get_valid()) {
            m_alog.write(log::alevel::devel, "Bad request: failed to parse uri");
            m_response.set_status(http::status_code::bad_request);
            return error::make_error_code(error::invalid_uri);
        }
 
        if (m_http_handler) {
            m_is_http = true;
            m_http_handler(m_connection_hdl);
            
            if (m_state == session::state::closed) {
                return error::make_error_code(error::http_connection_ended);
            }
        } else {
            set_status(http::status_code::upgrade_required);
            return error::make_error_code(error::upgrade_required);
        }
 
        return lib::error_code();
    }
 
    lib::error_code ec = m_processor->validate_handshake(m_request);
 
    // Validate: make sure all required elements are present.
    if (ec){
        // Not a valid handshake request
        m_alog.write(log::alevel::devel, "Bad request " + ec.message());
        m_response.set_status(http::status_code::bad_request);
        return ec;
    }
 
    // Read extension parameters and set up values necessary for the end user
    // to complete extension negotiation.
    std::pair<lib::error_code,std::string> neg_results;
    neg_results = m_processor->negotiate_extensions(m_request);
 
    if (neg_results.first) {
        // There was a fatal error in extension parsing that should result in
        // a failed connection attempt.
        m_alog.write(log::alevel::devel, "Bad request: " + neg_results.first.message());
        m_response.set_status(http::status_code::bad_request);
        return neg_results.first;
    } else {
        // extension negotiation succeeded, set response header accordingly
        // we don't send an empty extensions header because it breaks many
        // clients.
        if (neg_results.second.size() > 0) {
            m_response.replace_header("Sec-WebSocket-Extensions",
                neg_results.second);
        }
    }
 
    // extract URI from request
    m_uri = m_processor->get_uri(m_request);
 
 
    if (!m_uri->get_valid()) {
        m_alog.write(log::alevel::devel, "Bad request: failed to parse uri");
        m_response.set_status(http::status_code::bad_request);
        return error::make_error_code(error::invalid_uri);
    }
 
    // extract subprotocols
    lib::error_code subp_ec = m_processor->extract_subprotocols(m_request,
        m_requested_subprotocols);
 
    if (subp_ec) {
        // should we do anything?
    }
 
    // Ask application to validate the connection
    if (!m_validate_handler || m_validate_handler(m_connection_hdl)) {
        m_response.set_status(http::status_code::switching_protocols);
 
        // Write the appropriate response headers based on request and
        // processor version
        ec = m_processor->process_handshake(m_request,m_subprotocol,m_response);
 
        if (ec) {
            std::stringstream s;
            s << "Processing error: " << ec << "(" << ec.message() << ")";
            m_alog.write(log::alevel::devel, s.str());
 
            m_response.set_status(http::status_code::internal_server_error);
            return ec;
        }
    } else {
        // User application has rejected the handshake
        m_alog.write(log::alevel::devel, "USER REJECT");
 
        // Use Bad Request if the user handler did not provide a more
        // specific http response error code.
        // TODO: is there a better default?
        if (m_response.get_status_code() == http::status_code::uninitialized) {
            m_response.set_status(http::status_code::bad_request);
        }
        
        return error::make_error_code(error::rejected);
    }
 
    return lib::error_code();
}

Here is the call graph for this function:

read_frame()

template<typename config >

void websocketpp::connection< config >::read_frame

(

)

Definition at line 1123 of file connection_impl.hpp.

                                    {
    if (!m_read_flag) {
        return;
    }
    
    transport_con_type::async_read_at_least(
        // std::min wont work with undefined static const values.
        // TODO: is there a more elegant way to do this?
        // Need to determine if requesting 1 byte or the exact number of bytes
        // is better here. 1 byte lets us be a bit more responsive at a
        // potential expense of additional runs through handle_read_frame
        /*(m_processor->get_bytes_needed() > config::connection_read_buffer_size ?
         config::connection_read_buffer_size : m_processor->get_bytes_needed())*/
        1,
        m_buf,
        config::connection_read_buffer_size,
        m_handle_read_frame
    );
}

read_handshake()

template<typename config >

void websocketpp::connection< config >::read_handshake

(

size_t

num_bytes

)

Definition at line 784 of file connection_impl.hpp.

                                                        {
    m_alog.write(log::alevel::devel,"connection read_handshake");
 
    if (m_open_handshake_timeout_dur > 0) {
        m_handshake_timer = transport_con_type::set_timer(
            m_open_handshake_timeout_dur,
            lib::bind(
                &type::handle_open_handshake_timeout,
                type::get_shared(),
                lib::placeholders::_1
            )
        );
    }
 
    transport_con_type::async_read_at_least(
        num_bytes,
        m_buf,
        config::connection_read_buffer_size,
        lib::bind(
            &type::handle_read_handshake,
            type::get_shared(),
            lib::placeholders::_1,
            lib::placeholders::_2
        )
    );
}

remove_header()

template<typename config >

void websocketpp::connection< config >::remove_header

(

std::string const &

key

)

Removes a header from the response.

This member function is valid only from the http() and validate() handler callbacks, or to a client connection before connect has been called.

Parameters

key	The name of the header to remove

See also

websocketpp::http::parser::remove_header

Definition at line 638 of file connection_impl.hpp.

{
    if (m_is_server) {
        if (m_internal_state == istate::PROCESS_HTTP_REQUEST) {
            // we are setting response headers for an incoming server connection
            m_response.remove_header(key);
        } else {
            throw exception("Call to remove_header from invalid state",
                        error::make_error_code(error::invalid_state));
        }
    } else {
        if (m_internal_state == istate::USER_INIT) {
            // we are setting initial headers for an outgoing client connection
            m_request.remove_header(key);
        } else {
            throw exception("Call to remove_header from invalid state",
                        error::make_error_code(error::invalid_state));
        }
    }
}

Here is the call graph for this function:

replace_header()

template<typename config >

void websocketpp::connection< config >::replace_header	(	std::string const &	key,
		std::string const &	val )

If a header with this name already exists the old value will be replaced Use connection::append_header to append to a list of existing values.

This member function is valid only from the http() and validate() handler callbacks, or to a client connection before connect has been called.

Parameters

key	Name of the header to set
val	Value to set

See also

append_header

websocketpp::http::parser::replace_header

Definition at line 614 of file connection_impl.hpp.

{
    if (m_is_server) {
        if (m_internal_state == istate::PROCESS_HTTP_REQUEST) {
            // we are setting response headers for an incoming server connection
            m_response.replace_header(key,val);
        } else {
            throw exception("Call to replace_header from invalid state",
                        error::make_error_code(error::invalid_state));
        }
    } else {
        if (m_internal_state == istate::USER_INIT) {
            // we are setting initial headers for an outgoing client connection
            m_request.replace_header(key,val);
        } else {
            throw exception("Call to replace_header from invalid state",
                        error::make_error_code(error::invalid_state));
        }
    }
}

Here is the call graph for this function:

resume_reading()

template<typename config >

lib::error_code websocketpp::connection< config >::resume_reading

(

)

Signals to the connection to resume reading of new data after it was paused by pause_reading().

If reading is not paused for this connection already nothing is changed.

Definition at line 378 of file connection_impl.hpp.

                                                 {
    m_alog.write(log::alevel::devel,"connection connection::resume_reading");
    return transport_con_type::dispatch(
        lib::bind(
            &type::handle_resume_reading,
            type::get_shared()
        )
    );
}

select_subprotocol() [1/2]

template<typename config >

void websocketpp::connection< config >::select_subprotocol

(

std::string const &

value

)

Indicates which subprotocol should be used for this connection. Valid only during the validate handler callback. Subprotocol selected must have been requested by the client. Consult get_requested_subprotocols() for a list of valid subprotocols.

This member function is valid on server endpoints/connections only

Parameters

value

The subprotocol to select

Definition at line 516 of file connection_impl.hpp.

                                                                   {
    lib::error_code ec;
    this->select_subprotocol(value,ec);
    if (ec) {
        throw exception(ec);
    }
}

select_subprotocol() [2/2]

template<typename config >

void websocketpp::connection< config >::select_subprotocol	(	std::string const &	value,
		lib::error_code &	ec )

Indicates which subprotocol should be used for this connection. Valid only during the validate handler callback. Subprotocol selected must have been requested by the client. Consult get_requested_subprotocols() for a list of valid subprotocols.

This member function is valid on server endpoints/connections only

Parameters

value	The subprotocol to select
ec	A reference to an error code that will be filled in the case of errors

Definition at line 488 of file connection_impl.hpp.

{
    if (!m_is_server) {
        ec = error::make_error_code(error::server_only);
        return;
    }
 
    if (value.empty()) {
        ec = lib::error_code();
        return;
    }
 
    std::vector<std::string>::iterator it;
 
    it = std::find(m_requested_subprotocols.begin(),
                   m_requested_subprotocols.end(),
                   value);
 
    if (it == m_requested_subprotocols.end()) {
        ec = error::make_error_code(error::unrequested_subprotocol);
        return;
    }
 
    m_subprotocol = value;
}

Here is the call graph for this function:

send() [1/3]

template<typename config >

lib::error_code websocketpp::connection< config >::send

(

message_ptr

msg

)

If presented with a prepared message it is added without validation or framing. If presented with an unprepared message it is validated, framed, and then added

Errors are returned via an exception

Todo

make exception system_error rather than error_code

This method invokes the m_write_lock mutex

Parameters

msg	A message_ptr to the message to send.

Here is the call graph for this function:

send() [2/3]

template<typename config >

lib::error_code websocketpp::connection< config >::send	(	std::string const &	payload,
		frame::opcode::value	op = frame::opcode::text )

Convenience method to send a message given a payload string and optionally an opcode. Default opcode is utf8 text.

This method locks the m_write_lock mutex

Parameters

payload	The payload string to generated the message with
op	The opcode to generated the message with. Default is frame::opcode::text

Definition at line 83 of file connection_impl.hpp.

{
    message_ptr msg = m_msg_manager->get_message(op,payload.size());
    msg->append_payload(payload);
    msg->set_compressed(true);
 
    return send(msg);
}

send() [3/3]

template<typename config >

lib::error_code websocketpp::connection< config >::send	(	void const *	payload,
		size_t	len,
		frame::opcode::value	op = frame::opcode::binary )

Convenience method to send a message given a raw array and optionally an opcode. Default opcode is binary.

This method locks the m_write_lock mutex

Parameters

payload	A pointer to the array containing the bytes to send.
len	Length of the array.
op	The opcode to generated the message with. Default is frame::opcode::binary

Definition at line 94 of file connection_impl.hpp.

{
    message_ptr msg = m_msg_manager->get_message(op,len);
    msg->append_payload(payload,len);
 
    return send(msg);
}

send_http_response() [1/2]

template<typename config >

void websocketpp::connection< config >::send_http_response

(

)

Definition at line 712 of file connection_impl.hpp.

                                            {
    lib::error_code ec;
    this->send_http_response(ec);
    if (ec) {
        throw exception(ec);
    }
}

send_http_response() [2/2]

template<typename config >

void websocketpp::connection< config >::send_http_response

(

lib::error_code &

ec

)

Sends an http response to an HTTP connection that was deferred. This will send a complete response including all headers, status line, and body text. The connection will be closed afterwards.

Since

0.6.0

Parameters

ec	A status code, zero on success, non-zero otherwise

Definition at line 696 of file connection_impl.hpp.

                                                              {
    {
        scoped_lock_type lock(m_connection_state_lock);
        if (m_http_state != session::http_state::deferred) {
            ec = error::make_error_code(error::invalid_state);
            return;
        }
    
        m_http_state = session::http_state::body_written;
    }
    
    this->write_http_response(lib::error_code());
    ec = lib::error_code();
}

Here is the call graph for this function:

set_body() [1/2]

template<typename config >

void websocketpp::connection< config >::set_body

(

std::string &&

value

)

Definition at line 579 of file connection_impl.hpp.

                                                   {
    if (m_internal_state != istate::PROCESS_HTTP_REQUEST) {
        throw exception("Call to set_status from invalid state",
                      error::make_error_code(error::invalid_state));
    }
 
    m_response.set_body(std::move(value));
}

Here is the call graph for this function:

set_body() [2/2]

template<typename config >

void websocketpp::connection< config >::set_body

(

std::string const &

value

)

Set the body content of the HTTP response to the parameter string. Note set_body will also set the Content-Length HTTP header to the appropriate value. If you want the Content-Length header to be something else set it to something else after calling set_body

This member function is valid only from the http() and validate() handler callbacks.

Parameters

value

String data to include as the body content.

See also

websocketpp::http::response::set_body

Definition at line 569 of file connection_impl.hpp.

                                                         {
    if (m_internal_state != istate::PROCESS_HTTP_REQUEST) {
        throw exception("Call to set_status from invalid state",
                      error::make_error_code(error::invalid_state));
    }
 
    m_response.set_body(value);
}

Here is the call graph for this function:

set_close_handler()

template<typename config >

void websocketpp::connection< config >::set_close_handler ( close_handler h )

inline

The close handler is called immediately after the connection is closed.

Parameters

h	The new close_handler

Definition at line 361 of file connection.hpp.

                                            {
        m_close_handler = h;
    }

set_close_handshake_timeout()

template<typename config >

void websocketpp::connection< config >::set_close_handshake_timeout ( long dur )

inline

Sets the length of time the library will wait after a closing handshake has been initiated before cancelling it. This can be used to prevent excessive wait times for outgoing clients or excessive resource usage from broken clients or DoS attacks on servers.

Connections that time out will have their close handlers called with the close_handshake_timeout error code.

The default value is specified via the compile time config value 'timeout_close_handshake'. The default value in the core config is 5000ms. A value of 0 will disable the timer entirely.

To be effective, the transport you are using must support timers. See the documentation for your transport policy for details about its timer support.

Parameters

dur	The length of the close handshake timeout in ms

Definition at line 525 of file connection.hpp.

                                               {
        m_close_handshake_timeout_dur = dur;
    }

set_fail_handler()

template<typename config >

void websocketpp::connection< config >::set_fail_handler ( fail_handler h )

inline

The fail handler is called whenever the connection fails while the handshake is bring processed.

Parameters

h	The new fail_handler

Definition at line 372 of file connection.hpp.

                                          {
        m_fail_handler = h;
    }

set_handle()

template<typename config >

void websocketpp::connection< config >::set_handle ( connection_hdl hdl )

inline

The connection handle is a token that can be shared outside the WebSocket++ core for the purposes of identifying a connection and sending it messages.

Parameters

hdl	A connection_hdl that the connection will use to refer to itself.

Definition at line 1357 of file connection.hpp.

                                        {
        m_connection_hdl = hdl;
        transport_con_type::set_handle(hdl);
    }

set_http_handler()

template<typename config >

void websocketpp::connection< config >::set_http_handler ( http_handler h )

inline

The http handler is called after an HTTP request other than a WebSocket upgrade request is received. It allows a WebSocket++ server to respond to regular HTTP requests on the same port as it processes WebSocket connections. This can be useful for hosting error messages, flash policy files, status pages, and other simple HTTP responses. It is not intended to be used as a primary web server.

Parameters

h	The new http_handler

Definition at line 447 of file connection.hpp.

                                          {
        m_http_handler = h;
    }

set_interrupt_handler()

template<typename config >

void websocketpp::connection< config >::set_interrupt_handler ( interrupt_handler h )

inline

The interrupt handler is called whenever the connection is manually interrupted by the application.

Parameters

h	The new interrupt_handler

Definition at line 432 of file connection.hpp.

                                                    {
        m_interrupt_handler = h;
    }

set_max_http_body_size()

template<typename config >

void websocketpp::connection< config >::set_max_http_body_size ( size_t new_value )

inline

Set maximum HTTP message body size. Maximum message body size determines the point at which the connection will stop reading an HTTP request whose body is too large.

The default is set by the endpoint that creates the connection.

Since

0.5.0

Parameters

new_value

The value to set as the maximum message size.

Definition at line 610 of file connection.hpp.

                                                  {
        m_request.set_max_body_size(new_value);
    }

set_max_message_size()

template<typename config >

void websocketpp::connection< config >::set_max_message_size ( size_t new_value )

inline

Set maximum message size. Maximum message size determines the point at which the connection will fail with the message_too_big protocol error. This value may be changed during the connection.

The default is set by the endpoint that creates the connection.

Since

0.3.0

Parameters

new_value

The value to set as the maximum message size.

Definition at line 575 of file connection.hpp.

                                                {
        m_max_message_size = new_value;
        if (m_processor) {
            m_processor->set_max_message_size(new_value);
        }
    }

set_message_handler()

template<typename config >

void websocketpp::connection< config >::set_message_handler ( message_handler h )

inline

The message handler is called after a new message has been received.

Parameters

h	The new message_handler

Definition at line 473 of file connection.hpp.

                                                {
        m_message_handler = h;
    }

set_open_handler()

template<typename config >

void websocketpp::connection< config >::set_open_handler ( open_handler h )

inline

The open handler is called after the WebSocket handshake is complete and the connection is considered OPEN.

Parameters

h	The new open_handler

Definition at line 351 of file connection.hpp.

                                          {
        m_open_handler = h;
    }

set_open_handshake_timeout()

template<typename config >

void websocketpp::connection< config >::set_open_handshake_timeout ( long dur )

inline

Sets the length of time the library will wait after an opening handshake has been initiated before cancelling it. This can be used to prevent excessive wait times for outgoing clients or excessive resource usage from broken clients or DoS attacks on servers.

Connections that time out will have their fail handlers called with the open_handshake_timeout error code.

The default value is specified via the compile time config value 'timeout_open_handshake'. The default value in the core config is 5000ms. A value of 0 will disable the timer entirely.

To be effective, the transport you are using must support timers. See the documentation for your transport policy for details about its timer support.

Parameters

dur	The length of the open handshake timeout in ms

Definition at line 501 of file connection.hpp.

                                              {
        m_open_handshake_timeout_dur = dur;
    }

set_ping_handler()

template<typename config >

void websocketpp::connection< config >::set_ping_handler ( ping_handler h )

inline

The ping handler is called whenever the connection receives a ping control frame. The ping payload is included.

The ping handler's return time controls whether or not a pong is sent in response to this ping. Returning false will suppress the return pong. If no ping handler is set a pong will be sent.

Parameters

h	The new ping_handler

Definition at line 387 of file connection.hpp.

                                          {
        m_ping_handler = h;
    }

set_pong_handler()

template<typename config >

void websocketpp::connection< config >::set_pong_handler ( pong_handler h )

inline

The pong handler is called whenever the connection receives a pong control frame. The pong payload is included.

Parameters

h	The new pong_handler

Definition at line 398 of file connection.hpp.

                                          {
        m_pong_handler = h;
    }

set_pong_timeout()

template<typename config >

void websocketpp::connection< config >::set_pong_timeout ( long dur )

inline

Sets the length of time the library will wait for a pong response to a ping. This can be used as a keepalive or to detect broken connections.

Pong responses that time out will have the pong timeout handler called.

The default value is specified via the compile time config value 'timeout_pong'. The default value in the core config is 5000ms. A value of 0 will disable the timer entirely.

To be effective, the transport you are using must support timers. See the documentation for your transport policy for details about its timer support.

Parameters

dur	The length of the pong timeout in ms

Definition at line 546 of file connection.hpp.

                                    {
        m_pong_timeout_dur = dur;
    }

set_pong_timeout_handler()

template<typename config >

void websocketpp::connection< config >::set_pong_timeout_handler ( pong_timeout_handler h )

inline

If the transport component being used supports timers, the pong timeout handler is called whenever a pong control frame is not received with the configured timeout period after the application sends a ping.

The config setting timeout_pong controls the length of the timeout period. It is specified in milliseconds.

This can be used to probe the health of the remote endpoint's WebSocket implementation. This does not guarantee that the remote application itself is still healthy but can be a useful diagnostic.

Note: receipt of this callback doesn't mean the pong will never come. This functionality will not suppress delivery of the pong in question should it arrive after the timeout.

Parameters

h	The new pong_timeout_handler

Definition at line 421 of file connection.hpp.

                                                          {
        m_pong_timeout_handler = h;
    }

set_status() [1/2]

template<typename config >

void websocketpp::connection< config >::set_status

(

http::status_code::value

code

)

Sets the response status code to code and looks up the corresponding message for standard codes. Non-standard codes will be entered as Unknown use set_status(status_code::value,std::string) overload to set both values explicitly.

This member function is valid only from the http() and validate() handler callbacks.

Parameters

code	Code to set
msg	Message to set

See also

websocketpp::http::response::set_status

Definition at line 545 of file connection_impl.hpp.

{
    if (m_internal_state != istate::PROCESS_HTTP_REQUEST) {
        throw exception("Call to set_status from invalid state",
                      error::make_error_code(error::invalid_state));
    }
    m_response.set_status(code);
}

Here is the call graph for this function:

set_status() [2/2]

template<typename config >

void websocketpp::connection< config >::set_status	(	http::status_code::value	code,
		std::string const &	msg )

Sets the response status code and message to independent custom values. use set_status(status_code::value) to set the code and have the standard message be automatically set.

This member function is valid only from the http() and validate() handler callbacks.

Parameters

code	Code to set
msg	Message to set

See also

websocketpp::http::response::set_status

Definition at line 556 of file connection_impl.hpp.

{
    if (m_internal_state != istate::PROCESS_HTTP_REQUEST) {
        throw exception("Call to set_status from invalid state",
                      error::make_error_code(error::invalid_state));
    }
 
    m_response.set_status(code,msg);
}

Here is the call graph for this function:

set_termination_handler()

template<typename config >

void websocketpp::connection< config >::set_termination_handler

(

termination_handler

new_handler

)

Sets the handler for a terminating connection. Should only be used internally by the endpoint class.

Definition at line 53 of file connection_impl.hpp.

{
    m_alog.write(log::alevel::devel,
        "connection set_termination_handler");
 
    //scoped_lock_type lock(m_connection_state_lock);
 
    m_termination_handler = new_handler;
}

set_uri()

template<typename config >

void websocketpp::connection< config >::set_uri

(

uri_ptr

uri

)

This should really only be called by internal library methods unless you really know what you are doing.

Parameters

uri	The new URI to set

Definition at line 436 of file connection_impl.hpp.

                                            {
    //scoped_lock_type lock(m_connection_state_lock);
    m_uri = uri;
}

set_validate_handler()

template<typename config >

void websocketpp::connection< config >::set_validate_handler ( validate_handler h )

inline

The validate handler is called after a WebSocket handshake has been parsed but before a response is returned. It provides the application a chance to examine the request and determine whether or not it wants to accept the connection.

Returning false from the validate handler will reject the connection. If no validate handler is present, all connections will be allowed.

Parameters

h	The new validate_handler

Definition at line 463 of file connection.hpp.

                                                  {
        m_validate_handler = h;
    }

start()

template<typename config >

void websocketpp::connection< config >::start

(

)

Definition at line 726 of file connection_impl.hpp.

                               {
    m_alog.write(log::alevel::devel,"connection start");
 
    if (m_internal_state != istate::USER_INIT) {
        m_alog.write(log::alevel::devel,"Start called in invalid state");
        this->terminate(error::make_error_code(error::invalid_state));
        return;
    }
 
    m_internal_state = istate::TRANSPORT_INIT;
 
    // Depending on how the transport implements init this function may return
    // immediately and call handle_transport_init later or call
    // handle_transport_init from this function.
    transport_con_type::init(
        lib::bind(
            &type::handle_transport_init,
            type::get_shared(),
            lib::placeholders::_1
        )
    );
}

terminate()

template<typename config >

void websocketpp::connection< config >::terminate

(

lib::error_code const &

ec

)

Definition at line 1707 of file connection_impl.hpp.

                                                           {
    if (m_alog.static_test(log::alevel::devel)) {
        m_alog.write(log::alevel::devel,"connection terminate");
    }
 
    // Cancel close handshake timer
    if (m_handshake_timer) {
        m_handshake_timer->cancel();
        m_handshake_timer.reset();
    }
 
    terminate_status tstat = unknown;
    if (ec) {
        m_ec = ec;
        m_local_close_code = close::status::abnormal_close;
        m_local_close_reason = ec.message();
    }
 
    // TODO: does any of this need a mutex?
    if (m_is_http) {
        m_http_state = session::http_state::closed;
    }
    if (m_state == session::state::connecting) {
        m_state = session::state::closed;
        tstat = failed;
        
        // Log fail result here before socket is shut down and we can't get
        // the remote address, etc anymore
        if (m_ec != error::http_connection_ended) {
            log_fail_result();
        }
    } else if (m_state != session::state::closed) {
        m_state = session::state::closed;
        tstat = closed;
    } else {
        m_alog.write(log::alevel::devel,
            "terminate called on connection that was already terminated");
        return;
    }
 
    // TODO: choose between shutdown and close based on error code sent
 
    transport_con_type::async_shutdown(
        lib::bind(
            &type::handle_terminate,
            type::get_shared(),
            tstat,
            lib::placeholders::_1
        )
    );
}

write_frame()

template<typename config >

void websocketpp::connection< config >::write_frame

(

)

Todo

unit tests

This method locks the m_write_lock mutex

Definition at line 1802 of file connection_impl.hpp.

                                     {
    //m_alog.write(log::alevel::devel,"connection write_frame");
 
    {
        scoped_lock_type lock(m_write_lock);
 
        // Check the write flag. If true, there is an outstanding transport
        // write already. In this case we just return. The write handler will
        // start a new write if the write queue isn't empty. If false, we set
        // the write flag and proceed to initiate a transport write.
        if (m_write_flag) {
            return;
        }
 
        // pull off all the messages that are ready to write.
        // stop if we get a message marked terminal
        message_ptr next_message = write_pop();
        while (next_message) {
            m_current_msgs.push_back(next_message);
            if (!next_message->get_terminal()) {
                next_message = write_pop();
            } else {
                next_message = message_ptr();
            }
        }
        
        if (m_current_msgs.empty()) {
            // there was nothing to send
            return;
        } else {
            // At this point we own the next messages to be sent and are
            // responsible for holding the write flag until they are 
            // successfully sent or there is some error
            m_write_flag = true;
        }
    }
 
    typename std::vector<message_ptr>::iterator it;
    for (it = m_current_msgs.begin(); it != m_current_msgs.end(); ++it) {
        std::string const & header = (*it)->get_header();
        std::string const & payload = (*it)->get_payload();
 
        m_send_buffer.push_back(transport::buffer(header.c_str(),header.size()));
        m_send_buffer.push_back(transport::buffer(payload.c_str(),payload.size()));   
    }
 
    // Print detailed send stats if those log levels are enabled
    if (m_alog.static_test(log::alevel::frame_header)) {
    if (m_alog.dynamic_test(log::alevel::frame_header)) {
        std::stringstream general,header,payload;
        
        general << "Dispatching write containing " << m_current_msgs.size()
                <<" message(s) containing ";
        header << "Header Bytes: \n";
        payload << "Payload Bytes: \n";
        
        size_t hbytes = 0;
        size_t pbytes = 0;
        
        for (size_t i = 0; i < m_current_msgs.size(); i++) {
            hbytes += m_current_msgs[i]->get_header().size();
            pbytes += m_current_msgs[i]->get_payload().size();
 
            
            header << "[" << i << "] (" 
                   << m_current_msgs[i]->get_header().size() << ") " 
                   << utility::to_hex(m_current_msgs[i]->get_header()) << "\n";
 
            if (m_alog.static_test(log::alevel::frame_payload)) {
            if (m_alog.dynamic_test(log::alevel::frame_payload)) {
                payload << "[" << i << "] (" 
                        << m_current_msgs[i]->get_payload().size() << ") ["<<m_current_msgs[i]->get_opcode()<<"] "
                        << (m_current_msgs[i]->get_opcode() == frame::opcode::text ? 
                                m_current_msgs[i]->get_payload() : 
                                utility::to_hex(m_current_msgs[i]->get_payload())
                           ) 
                        << "\n";
            }
            }  
        }
        
        general << hbytes << " header bytes and " << pbytes << " payload bytes";
        
        m_alog.write(log::alevel::frame_header,general.str());
        m_alog.write(log::alevel::frame_header,header.str());
        m_alog.write(log::alevel::frame_payload,payload.str());
    }
    }
 
    transport_con_type::async_write(
        m_send_buffer,
        m_write_frame_handler
    );
}

Here is the call graph for this function:

---

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

• libraries/fc/vendor/websocketpp/websocketpp/connection.hpp
• libraries/fc/vendor/websocketpp/websocketpp/impl/connection_impl.hpp