websocketpp::transport::asio::connection< config > Class Template Reference

Asio based connection transport component. More...

#include <connection.hpp>

Inheritance diagram for websocketpp::transport::asio::connection< config >:

Collaboration diagram for websocketpp::transport::asio::connection< config >:

Public Types
typedef connection< config >	type
	Type of this connection transport component.
typedef lib::shared_ptr< type >	ptr
	Type of a shared pointer to this connection transport component.
typedef config::socket_type::socket_con_type	socket_con_type
	Type of the socket connection component.
typedef socket_con_type::ptr	socket_con_ptr
	Type of a shared pointer to the socket connection component.
typedef config::alog_type	alog_type
	Type of this transport's access logging policy.
typedef config::elog_type	elog_type
	Type of this transport's error logging policy.
typedef config::request_type	request_type
typedef request_type::ptr	request_ptr
typedef config::response_type	response_type
typedef response_type::ptr	response_ptr
typedef lib::asio::io_service *	io_service_ptr
	Type of a pointer to the Asio io_service being used.
typedef lib::shared_ptr< lib::asio::io_service::strand >	strand_ptr
	Type of a pointer to the Asio io_service::strand being used.
typedef lib::shared_ptr< lib::asio::steady_timer >	timer_ptr
	Type of a pointer to the Asio timer class.

Public Member Functions
	connection (bool is_server, alog_type &alog, elog_type &elog)
ptr	get_shared ()
	Get a shared pointer to this component.
bool	is_secure () const
void	set_uri (uri_ptr u)
	Set uri hook.
void	set_tcp_pre_init_handler (tcp_init_handler h)
	Sets the tcp pre init handler.
void	set_tcp_init_handler (tcp_init_handler h)
	Sets the tcp pre init handler (deprecated)
void	set_tcp_post_init_handler (tcp_init_handler h)
	Sets the tcp post init handler.
void	set_proxy (std::string const &uri, lib::error_code &ec)
	Set the proxy to connect through (exception free)
void	set_proxy (std::string const &uri)
	Set the proxy to connect through (exception)
void	set_proxy_basic_auth (std::string const &username, std::string const &password, lib::error_code &ec)
	Set the basic auth credentials to use (exception free)
void	set_proxy_basic_auth (std::string const &username, std::string const &password)
	Set the basic auth credentials to use (exception)
void	set_proxy_timeout (long duration, lib::error_code &ec)
	Set the proxy timeout duration (exception free)
void	set_proxy_timeout (long duration)
	Set the proxy timeout duration (exception)
std::string const &	get_proxy () const
std::string	get_remote_endpoint () const
	Get the remote endpoint address.
connection_hdl	get_handle () const
	Get the connection handle.
timer_ptr	set_timer (long duration, timer_handler callback)
	Call back a function after a period of time.
void	handle_timer (timer_ptr, timer_handler callback, lib::asio::error_code const &ec)
	Timer callback.
strand_ptr	get_strand ()
	Get a pointer to this connection's strand.
lib::asio::error_code	get_transport_ec () const
	Get the internal transport error code for a closed/failed connection.

Protected Member Functions
void	init (init_handler callback)
	Initialize transport for reading.
lib::error_code	proxy_init (std::string const &authority)
	initialize the proxy buffers and http parsers
lib::error_code	init_asio (io_service_ptr io_service)
	Finish constructing the transport.
void	handle_pre_init (init_handler callback, lib::error_code const &ec)
void	post_init (init_handler callback)
void	handle_post_init_timeout (timer_ptr, init_handler callback, lib::error_code const &ec)
	Post init timeout callback.
void	handle_post_init (timer_ptr post_timer, init_handler callback, lib::error_code const &ec)
	Post init timeout callback.
void	proxy_write (init_handler callback)
void	handle_proxy_timeout (init_handler callback, lib::error_code const &ec)
void	handle_proxy_write (init_handler callback, lib::asio::error_code const &ec)
void	proxy_read (init_handler callback)
void	handle_proxy_read (init_handler callback, lib::asio::error_code const &ec, size_t)
	Proxy read callback.
void	async_read_at_least (size_t num_bytes, char *buf, size_t len, read_handler handler)
	read at least num_bytes bytes into buf and then call handler.
void	handle_async_read (read_handler handler, lib::asio::error_code const &ec, size_t bytes_transferred)
void	async_write (const char *buf, size_t len, write_handler handler)
	Initiate a potentially asyncronous write of the given buffer.
void	async_write (std::vector< buffer > const &bufs, write_handler handler)
	Initiate a potentially asyncronous write of the given buffers.
void	handle_async_write (write_handler handler, lib::asio::error_code const &ec, size_t)
	Async write callback.
void	set_handle (connection_hdl hdl)
	Set Connection Handle.
lib::error_code	interrupt (interrupt_handler handler)
	Trigger the on_interrupt handler.
lib::error_code	dispatch (dispatch_handler handler)
void	async_shutdown (shutdown_handler callback)
	close and clean up the underlying socket
void	handle_async_shutdown_timeout (timer_ptr, init_handler callback, lib::error_code const &ec)
	Async shutdown timeout handler.
void	handle_async_shutdown (timer_ptr shutdown_timer, shutdown_handler callback, lib::asio::error_code const &ec)
void	cancel_socket_checked ()
	Cancel the underlying socket and log any errors.

Friends
class	endpoint< config >
template<typename T >
class	local_endpoint

Detailed Description

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

transport::asio::connection implements a connection transport component using Asio that works with the transport::asio::endpoint endpoint transport component.

Definition at line 67 of file connection.hpp.

Member Typedef Documentation

alog_type

template<typename config >

config::alog_type websocketpp::transport::asio::connection< config >::alog_type

Definition at line 79 of file connection.hpp.

elog_type

template<typename config >

config::elog_type websocketpp::transport::asio::connection< config >::elog_type

Definition at line 81 of file connection.hpp.

io_service_ptr

template<typename config >

lib::asio::io_service* websocketpp::transport::asio::connection< config >::io_service_ptr

Definition at line 89 of file connection.hpp.

ptr

template<typename config >

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

Definition at line 72 of file connection.hpp.

request_ptr

template<typename config >

request_type::ptr websocketpp::transport::asio::connection< config >::request_ptr

Definition at line 84 of file connection.hpp.

request_type

template<typename config >

config::request_type websocketpp::transport::asio::connection< config >::request_type

Definition at line 83 of file connection.hpp.

response_ptr

template<typename config >

response_type::ptr websocketpp::transport::asio::connection< config >::response_ptr

Definition at line 86 of file connection.hpp.

response_type

template<typename config >

config::response_type websocketpp::transport::asio::connection< config >::response_type

Definition at line 85 of file connection.hpp.

socket_con_ptr

template<typename config >

socket_con_type::ptr websocketpp::transport::asio::connection< config >::socket_con_ptr

Definition at line 77 of file connection.hpp.

socket_con_type

template<typename config >

config::socket_type::socket_con_type websocketpp::transport::asio::connection< config >::socket_con_type

Definition at line 75 of file connection.hpp.

strand_ptr

template<typename config >

lib::shared_ptr<lib::asio::io_service::strand> websocketpp::transport::asio::connection< config >::strand_ptr

Definition at line 91 of file connection.hpp.

timer_ptr

template<typename config >

lib::shared_ptr<lib::asio::steady_timer> websocketpp::transport::asio::connection< config >::timer_ptr

Definition at line 93 of file connection.hpp.

type

template<typename config >

connection<config> websocketpp::transport::asio::connection< config >::type

Definition at line 70 of file connection.hpp.

Constructor & Destructor Documentation

connection()

template<typename config >

websocketpp::transport::asio::connection< config >::connection ( bool is_server, alog_type & alog, elog_type & elog )

inlineexplicit

Definition at line 102 of file connection.hpp.

      : m_is_server(is_server)
      , m_alog(alog)
      , m_elog(elog)
    {
        m_alog.write(log::alevel::devel,"asio con transport constructor");
    }

Member Function Documentation

async_read_at_least()

template<typename config >

void websocketpp::transport::asio::connection< config >::async_read_at_least ( size_t num_bytes, char * buf, size_t len, read_handler handler )

inlineprotected

Definition at line 820 of file connection.hpp.

    {
        if (m_alog.static_test(log::alevel::devel)) {
            std::stringstream s;
            s << "asio async_read_at_least: " << num_bytes;
            m_alog.write(log::alevel::devel,s.str());
        }
 
        // TODO: safety vs speed ?
        // maybe move into an if devel block
        /*if (num_bytes > len) {
            m_elog.write(log::elevel::devel,
                "asio async_read_at_least error::invalid_num_bytes");
            handler(make_error_code(transport::error::invalid_num_bytes),
                size_t(0));
            return;
        }*/
 
        if (config::enable_multithreading) {
            lib::asio::async_read(
                socket_con_type::get_socket(),
                lib::asio::buffer(buf,len),
                lib::asio::transfer_at_least(num_bytes),
                m_strand->wrap(make_custom_alloc_handler(
                    m_read_handler_allocator,
                    lib::bind(
                        &type::handle_async_read, get_shared(),
                        handler,
                        lib::placeholders::_1, lib::placeholders::_2
                    )
                ))
            );
        } else {
            lib::asio::async_read(
                socket_con_type::get_socket(),
                lib::asio::buffer(buf,len),
                lib::asio::transfer_at_least(num_bytes),
                make_custom_alloc_handler(
                    m_read_handler_allocator,
                    lib::bind(
                        &type::handle_async_read, get_shared(),
                        handler,
                        lib::placeholders::_1, lib::placeholders::_2
                    )
                )
            );    
        }
        
    }

Here is the call graph for this function:

async_shutdown()

template<typename config >

void websocketpp::transport::asio::connection< config >::async_shutdown ( shutdown_handler callback )

inlineprotected

Definition at line 1036 of file connection.hpp.

                                                   {
        if (m_alog.static_test(log::alevel::devel)) {
            m_alog.write(log::alevel::devel,"asio connection async_shutdown");
        }
 
        timer_ptr shutdown_timer;
        shutdown_timer = set_timer(
            config::timeout_socket_shutdown,
            lib::bind(
                &type::handle_async_shutdown_timeout,
                get_shared(),
                shutdown_timer,
                callback,
                lib::placeholders::_1
            )
        );
 
        socket_con_type::async_shutdown(
            lib::bind(
                &type::handle_async_shutdown,
                get_shared(),
                shutdown_timer,
                callback,
                lib::placeholders::_1
            )
        );
    }

Here is the call graph for this function:

async_write() [1/2]

template<typename config >

void websocketpp::transport::asio::connection< config >::async_write ( const char * buf, size_t len, write_handler handler )

inlineprotected

Definition at line 906 of file connection.hpp.

                                                                         {
        m_bufs.push_back(lib::asio::buffer(buf,len));
 
        if (config::enable_multithreading) {
            lib::asio::async_write(
                socket_con_type::get_socket(),
                m_bufs,
                m_strand->wrap(make_custom_alloc_handler(
                    m_write_handler_allocator,
                    lib::bind(
                        &type::handle_async_write, get_shared(),
                        handler,
                        lib::placeholders::_1, lib::placeholders::_2
                    )
                ))
            );
        } else {
            lib::asio::async_write(
                socket_con_type::get_socket(),
                m_bufs,
                make_custom_alloc_handler(
                    m_write_handler_allocator,
                    lib::bind(
                        &type::handle_async_write, get_shared(),
                        handler,
                        lib::placeholders::_1, lib::placeholders::_2
                    )
                )
            );
        }
    }

Here is the call graph for this function:

async_write() [2/2]

template<typename config >

void websocketpp::transport::asio::connection< config >::async_write ( std::vector< buffer > const & bufs, write_handler handler )

inlineprotected

Definition at line 939 of file connection.hpp.

                                                                            {
        std::vector<buffer>::const_iterator it;
 
        for (it = bufs.begin(); it != bufs.end(); ++it) {
            m_bufs.push_back(lib::asio::buffer((*it).buf,(*it).len));
        }
 
        if (config::enable_multithreading) {
            lib::asio::async_write(
                socket_con_type::get_socket(),
                m_bufs,
                m_strand->wrap(make_custom_alloc_handler(
                    m_write_handler_allocator,
                    lib::bind(
                        &type::handle_async_write, get_shared(),
                        handler,
                        lib::placeholders::_1, lib::placeholders::_2
                    )
                ))
            );
        } else {
            lib::asio::async_write(
                socket_con_type::get_socket(),
                m_bufs,
                make_custom_alloc_handler(
                    m_write_handler_allocator,
                    lib::bind(
                        &type::handle_async_write, get_shared(),
                        handler,
                        lib::placeholders::_1, lib::placeholders::_2
                    )
                )
            );
        }
    }

Here is the call graph for this function:

cancel_socket_checked()

template<typename config >

void websocketpp::transport::asio::connection< config >::cancel_socket_checked ( )

inlineprotected

Definition at line 1141 of file connection.hpp.

                                 {
        lib::asio::error_code cec = socket_con_type::cancel_socket();
        if (cec) {
            if (cec == lib::asio::error::operation_not_supported) {
                // cancel not supported on this OS, ignore and log at dev level
                m_alog.write(log::alevel::devel, "socket cancel not supported");
            } else {
                log_err(log::elevel::warn, "socket cancel failed", cec);
            }
        }
    }

Here is the caller graph for this function:

dispatch()

template<typename config >

lib::error_code websocketpp::transport::asio::connection< config >::dispatch ( dispatch_handler handler )

inlineprotected

Definition at line 1022 of file connection.hpp.

                                                     {
        if (config::enable_multithreading) {
            m_io_service->post(m_strand->wrap(handler));
        } else {
            m_io_service->post(handler);
        }
        return lib::error_code();
    }

get_handle()

template<typename config >

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

inline

Definition at line 296 of file connection.hpp.

                                      {
        return m_connection_hdl;
    }

get_proxy()

template<typename config >

std::string const & websocketpp::transport::asio::connection< config >::get_proxy ( ) const

inline

Definition at line 268 of file connection.hpp.

                                        {
        return m_proxy;
    }

get_remote_endpoint()

template<typename config >

std::string websocketpp::transport::asio::connection< config >::get_remote_endpoint ( ) const

inline

The iostream transport has no information about the ultimate remote endpoint. It will return the string "iostream transport". To indicate this.

TODO: allow user settable remote endpoint addresses if this seems useful

Returns

A string identifying the address of the remote endpoint

Definition at line 282 of file connection.hpp.

                                          {
        lib::error_code ec;
 
        std::string ret = socket_con_type::get_remote_endpoint(ec);
 
        if (ec) {
            m_elog.write(log::elevel::info,ret);
            return "Unknown";
        } else {
            return ret;
        }
    }

get_shared()

template<typename config >

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

inline

Definition at line 111 of file connection.hpp.

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

Here is the caller graph for this function:

get_strand()

template<typename config >

strand_ptr websocketpp::transport::asio::connection< config >::get_strand ( )

inline

Definition at line 366 of file connection.hpp.

                            {
        return m_strand;
    }

get_transport_ec()

template<typename config >

lib::asio::error_code websocketpp::transport::asio::connection< config >::get_transport_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.

Primarily used if you are using mismatched asio / system_error implementations such as boost::asio with std::system_error. In these cases the transport error type is different than the library error type and some WebSocket++ functions that return transport errors via the library error code type will be coerced into a catch all pass_through or tls_error error. This method will return the original machine readable transport error in the native type.

Since

0.7.0

Returns

Error code indicating the reason the connection was closed or failed

Definition at line 389 of file connection.hpp.

                                               {
        return m_tec;
    }

handle_async_read()

template<typename config >

void websocketpp::transport::asio::connection< config >::handle_async_read ( read_handler handler, lib::asio::error_code const & ec, size_t bytes_transferred )

inlineprotected

Definition at line 871 of file connection.hpp.

    {
        m_alog.write(log::alevel::devel, "asio con handle_async_read");
 
        // translate asio error codes into more lib::error_codes
        lib::error_code tec;
        if (ec == lib::asio::error::eof) {
            tec = make_error_code(transport::error::eof);
        } else if (ec) {
            // We don't know much more about the error at this point. As our
            // socket/security policy if it knows more:
            tec = socket_con_type::translate_ec(ec);
            m_tec = ec;
 
            if (tec == transport::error::tls_error ||
                tec == transport::error::pass_through)
            {
                // These are aggregate/catch all errors. Log some human readable
                // information to the info channel to give library users some
                // more details about why the upstream method may have failed.
                log_err(log::elevel::info,"asio async_read_at_least",ec);
            }
        }
        if (handler) {
            handler(tec,bytes_transferred);
        } else {
            // This can happen in cases where the connection is terminated while
            // the transport is waiting on a read.
            m_alog.write(log::alevel::devel,
                "handle_async_read called with null read handler");
        }
    }

Here is the caller graph for this function:

handle_async_shutdown()

template<typename config >

void websocketpp::transport::asio::connection< config >::handle_async_shutdown ( timer_ptr shutdown_timer, shutdown_handler callback, lib::asio::error_code const & ec )

inlineprotected

Definition at line 1094 of file connection.hpp.

    {
        if (ec == lib::asio::error::operation_aborted ||
            lib::asio::is_neg(shutdown_timer->expires_from_now()))
        {
            m_alog.write(log::alevel::devel,"async_shutdown cancelled");
            return;
        }
 
        shutdown_timer->cancel();
 
        lib::error_code tec;
        if (ec) {
            if (ec == lib::asio::error::not_connected) {
                // The socket was already closed when we tried to close it. This
                // happens periodically (usually if a read or write fails
                // earlier and if it is a real error will be caught at another
                // level of the stack.
            } else {
                // We don't know anything more about this error, give our
                // socket/security policy a crack at it.
                tec = socket_con_type::translate_ec(ec);
                m_tec = ec;
 
                if (tec == transport::error::tls_short_read) {
                    // TLS short read at this point is somewhat expected if both
                    // sides try and end the connection at the same time or if
                    // SSLv2 is being used. In general there is nothing that can
                    // be done here other than a low level development log.
                } else {
                    // all other errors are effectively pass through errors of
                    // some sort so print some detail on the info channel for
                    // library users to look up if needed.
                    log_err(log::elevel::info,"asio async_shutdown",ec);
                }
            }
        } else {
            if (m_alog.static_test(log::alevel::devel)) {
                m_alog.write(log::alevel::devel,
                    "asio con handle_async_shutdown");
            }
        }
        callback(tec);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

handle_async_shutdown_timeout()

template<typename config >

void websocketpp::transport::asio::connection< config >::handle_async_shutdown_timeout ( timer_ptr , init_handler callback, lib::error_code const & ec )

inlineprotected

Parameters

shutdown_timer	A pointer to the timer to keep it in scope
callback	The function to call back
ec	The status code

Definition at line 1070 of file connection.hpp.

    {
        lib::error_code ret_ec;
 
        if (ec) {
            if (ec == transport::error::operation_aborted) {
                m_alog.write(log::alevel::devel,
                    "asio socket shutdown timer cancelled");
                return;
            }
 
            log_err(log::elevel::devel,"asio handle_async_shutdown_timeout",ec);
            ret_ec = ec;
        } else {
            ret_ec = make_error_code(transport::error::timeout);
        }
 
        m_alog.write(log::alevel::devel,
            "Asio transport socket shutdown timed out");
        cancel_socket_checked();
        callback(ret_ec);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

handle_async_write()

template<typename config >

void websocketpp::transport::asio::connection< config >::handle_async_write ( write_handler handler, lib::asio::error_code const & ec, size_t  )

inlineprotected

Parameters

ec	The status code
bytes_transferred	The number of bytes read

Definition at line 980 of file connection.hpp.

                                                                                         {
        m_bufs.clear();
        lib::error_code tec;
        if (ec) {
            log_err(log::elevel::info,"asio async_write",ec);
            tec = ec;
        }
        if (handler) {
            handler(tec);
        } else {
            // This can happen in cases where the connection is terminated while
            // the transport is waiting on a read.
            m_alog.write(log::alevel::devel,
                "handle_async_write called with null write handler");
        }
    }

Here is the caller graph for this function:

handle_post_init()

template<typename config >

void websocketpp::transport::asio::connection< config >::handle_post_init ( timer_ptr post_timer, init_handler callback, lib::error_code const & ec )

inlineprotected

The timer pointer is included to ensure the timer isn't destroyed until after it has expired.

Parameters

post_timer	Pointer to the timer in question
callback	The function to call back
ec	The status code

Definition at line 572 of file connection.hpp.

    {
        if (ec == transport::error::operation_aborted ||
            (post_timer && lib::asio::is_neg(post_timer->expires_from_now())))
        {
            m_alog.write(log::alevel::devel,"post_init cancelled");
            return;
        }
 
        if (post_timer) {
            post_timer->cancel();
        }
 
        if (m_alog.static_test(log::alevel::devel)) {
            m_alog.write(log::alevel::devel,"asio connection handle_post_init");
        }
 
        if (m_tcp_post_init_handler) {
            m_tcp_post_init_handler(m_connection_hdl);
        }
 
        callback(ec);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

handle_post_init_timeout()

template<typename config >

void websocketpp::transport::asio::connection< config >::handle_post_init_timeout ( timer_ptr , init_handler callback, lib::error_code const & ec )

inlineprotected

The timer pointer is included to ensure the timer isn't destroyed until after it has expired.

Parameters

post_timer	Pointer to the timer in question
callback	The function to call back
ec	The status code

Definition at line 536 of file connection.hpp.

    {
        lib::error_code ret_ec;
 
        if (ec) {
            if (ec == transport::error::operation_aborted) {
                m_alog.write(log::alevel::devel,
                    "asio post init timer cancelled");
                return;
            }
 
            log_err(log::elevel::devel,"asio handle_post_init_timeout",ec);
            ret_ec = ec;
        } else {
            if (socket_con_type::get_ec()) {
                ret_ec = socket_con_type::get_ec();
            } else {
                ret_ec = make_error_code(transport::error::timeout);
            }
        }
 
        m_alog.write(log::alevel::devel, "Asio transport post-init timed out");
        cancel_socket_checked();
        callback(ret_ec);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

handle_pre_init()

template<typename config >

void websocketpp::transport::asio::connection< config >::handle_pre_init ( init_handler callback, lib::error_code const & ec )

inlineprotected

Definition at line 474 of file connection.hpp.

                                                                          {
        if (m_alog.static_test(log::alevel::devel)) {
            m_alog.write(log::alevel::devel,"asio connection handle pre_init");
        }
 
        if (m_tcp_pre_init_handler) {
            m_tcp_pre_init_handler(m_connection_hdl);
        }
 
        if (ec) {
            callback(ec);
        }
 
        // If we have a proxy set issue a proxy connect, otherwise skip to
        // post_init
        if (!m_proxy.empty()) {
            proxy_write(callback);
        } else {
            post_init(callback);
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

handle_proxy_read()

template<typename config >

void websocketpp::transport::asio::connection< config >::handle_proxy_read ( init_handler callback, lib::asio::error_code const & ec, size_t  )

inlineprotected

Parameters

init_handler	The function to call back
ec	The status code
bytes_transferred	The number of bytes read

Definition at line 742 of file connection.hpp.

    {
        if (m_alog.static_test(log::alevel::devel)) {
            m_alog.write(log::alevel::devel,
                "asio connection handle_proxy_read");
        }
 
        // Timer expired or the operation was aborted for some reason.
        // Whatever aborted it will be issuing the callback so we are safe to
        // return
        if (ec == lib::asio::error::operation_aborted ||
            lib::asio::is_neg(m_proxy_data->timer->expires_from_now()))
        {
            m_elog.write(log::elevel::devel,"read operation aborted");
            return;
        }
 
        // At this point there is no need to wait for the timer anymore
        m_proxy_data->timer->cancel();
 
        if (ec) {
            m_elog.write(log::elevel::info,
                "asio handle_proxy_read error: "+ec.message());
            callback(ec);
        } else {
            if (!m_proxy_data) {
                m_elog.write(log::elevel::library,
                    "assertion failed: !m_proxy_data in asio::connection::handle_proxy_read");
                callback(make_error_code(error::general));
                return;
            }
 
            std::istream input(&m_proxy_data->read_buf);
 
            m_proxy_data->res.consume(input);
 
            if (!m_proxy_data->res.headers_ready()) {
                // we read until the headers were done in theory but apparently
                // they aren't. Internal endpoint error.
                callback(make_error_code(error::general));
                return;
            }
 
            m_alog.write(log::alevel::devel,m_proxy_data->res.raw());
 
            if (m_proxy_data->res.get_status_code() != http::status_code::ok) {
                // got an error response back
                // TODO: expose this error in a programmatically accessible way?
                // if so, see below for an option on how to do this.
                std::stringstream s;
                s << "Proxy connection error: "
                  << m_proxy_data->res.get_status_code()
                  << " ("
                  << m_proxy_data->res.get_status_msg()
                  << ")";
                m_elog.write(log::elevel::info,s.str());
                callback(make_error_code(error::proxy_failed));
                return;
            }
 
            // we have successfully established a connection to the proxy, now
            // we can continue and the proxy will transparently forward the
            // WebSocket connection.
 
            // TODO: decide if we want an on_proxy callback that would allow
            // access to the proxy response.
 
            // free the proxy buffers and req/res objects as they aren't needed
            // anymore
            m_proxy_data.reset();
 
            // Continue with post proxy initialization
            post_init(callback);
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

handle_proxy_timeout()

template<typename config >

void websocketpp::transport::asio::connection< config >::handle_proxy_timeout ( init_handler callback, lib::error_code const & ec )

inlineprotected

Definition at line 651 of file connection.hpp.

    {
        if (ec == transport::error::operation_aborted) {
            m_alog.write(log::alevel::devel,
                "asio handle_proxy_write timer cancelled");
            return;
        } else if (ec) {
            log_err(log::elevel::devel,"asio handle_proxy_write",ec);
            callback(ec);
        } else {
            m_alog.write(log::alevel::devel,
                "asio handle_proxy_write timer expired");
            cancel_socket_checked();
            callback(make_error_code(transport::error::timeout));
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

handle_proxy_write()

template<typename config >

void websocketpp::transport::asio::connection< config >::handle_proxy_write ( init_handler callback, lib::asio::error_code const & ec )

inlineprotected

Definition at line 668 of file connection.hpp.

    {
        if (m_alog.static_test(log::alevel::devel)) {
            m_alog.write(log::alevel::devel,
                "asio connection handle_proxy_write");
        }
 
        m_bufs.clear();
 
        // Timer expired or the operation was aborted for some reason.
        // Whatever aborted it will be issuing the callback so we are safe to
        // return
        if (ec == lib::asio::error::operation_aborted ||
            lib::asio::is_neg(m_proxy_data->timer->expires_from_now()))
        {
            m_elog.write(log::elevel::devel,"write operation aborted");
            return;
        }
 
        if (ec) {
            log_err(log::elevel::info,"asio handle_proxy_write",ec);
            m_proxy_data->timer->cancel();
            callback(ec);
            return;
        }
 
        proxy_read(callback);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

handle_timer()

template<typename config >

void websocketpp::transport::asio::connection< config >::handle_timer ( timer_ptr , timer_handler callback, lib::asio::error_code const & ec )

inline

The timer pointer is included to ensure the timer isn't destroyed until after it has expired.

TODO: candidate for protected status

Parameters

post_timer	Pointer to the timer in question
callback	The function to call back
ec	The status code

Definition at line 350 of file connection.hpp.

    {
        if (ec) {
            if (ec == lib::asio::error::operation_aborted) {
                callback(make_error_code(transport::error::operation_aborted));
            } else {
                log_err(log::elevel::info,"asio handle_timer",ec);
                callback(ec);
            }
        } else {
            callback(lib::error_code());
        }
    }

Here is the caller graph for this function:

init()

template<typename config >

void websocketpp::transport::asio::connection< config >::init ( init_handler callback )

inlineprotected

init_asio is called once immediately after construction to initialize Asio components to the io_service

The transport initialization sequence consists of the following steps:

• Pre-init: the underlying socket is initialized to the point where bytes may be written. No bytes are actually written in this stage
• Proxy negotiation: if a proxy is set, a request is made to it to start a tunnel to the final destination. This stage ends when the proxy is ready to forward the next byte to the remote endpoint.
• Post-init: Perform any i/o with the remote endpoint, such as setting up tunnels for encryption. This stage ends when the connection is ready to read or write the WebSocket handshakes. At this point the original callback function is called.

Definition at line 411 of file connection.hpp.

                                     {
        if (m_alog.static_test(log::alevel::devel)) {
            m_alog.write(log::alevel::devel,"asio connection init");
        }
 
        // TODO: pre-init timeout. Right now no implemented socket policies
        // actually have an asyncronous pre-init
 
        socket_con_type::pre_init(
            lib::bind(
                &type::handle_pre_init,
                get_shared(),
                callback,
                lib::placeholders::_1
            )
        );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

init_asio()

template<typename config >

lib::error_code websocketpp::transport::asio::connection< config >::init_asio ( io_service_ptr io_service )

inlineprotected

init_asio is called once immediately after construction to initialize Asio components to the io_service.

Parameters

io_service

A pointer to the io_service to register with this connection

Returns

Status code for the success or failure of the initialization

Definition at line 461 of file connection.hpp.

                                                        {
        m_io_service = io_service;
 
        if (config::enable_multithreading) {
            m_strand = lib::make_shared<lib::asio::io_service::strand>(*io_service);
        }
 
        lib::error_code ec = socket_con_type::init_asio(io_service, m_strand,
            m_is_server);
 
        return ec;
    }

interrupt()

template<typename config >

lib::error_code websocketpp::transport::asio::connection< config >::interrupt ( interrupt_handler handler )

inlineprotected

This needs to be thread safe

Definition at line 1013 of file connection.hpp.

                                                       {
        if (config::enable_multithreading) {
            m_io_service->post(m_strand->wrap(handler));
        } else {
            m_io_service->post(handler);
        }
        return lib::error_code();
    }

is_secure()

template<typename config >

bool websocketpp::transport::asio::connection< config >::is_secure ( ) const

inline

Definition at line 115 of file connection.hpp.

                           {
        return socket_con_type::is_secure();
    }

post_init()

template<typename config >

void websocketpp::transport::asio::connection< config >::post_init ( init_handler callback )

inlineprotected

Definition at line 496 of file connection.hpp.

                                          {
        if (m_alog.static_test(log::alevel::devel)) {
            m_alog.write(log::alevel::devel,"asio connection post_init");
        }
 
        timer_ptr post_timer;
        
        if (config::timeout_socket_post_init > 0) {
            post_timer = set_timer(
                config::timeout_socket_post_init,
                lib::bind(
                    &type::handle_post_init_timeout,
                    get_shared(),
                    post_timer,
                    callback,
                    lib::placeholders::_1
                )
            );
        }
 
        socket_con_type::post_init(
            lib::bind(
                &type::handle_post_init,
                get_shared(),
                post_timer,
                callback,
                lib::placeholders::_1
            )
        );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

proxy_init()

template<typename config >

lib::error_code websocketpp::transport::asio::connection< config >::proxy_init ( std::string const & authority )

inlineprotected

Parameters

authority

The address of the server we want the proxy to tunnel to in the format of a URI authority (host:port)

Returns

Status code indicating what errors occurred, if any

Definition at line 437 of file connection.hpp.

                                                          {
        if (!m_proxy_data) {
            return websocketpp::error::make_error_code(
                websocketpp::error::invalid_state);
        }
        m_proxy_data->req.set_version("HTTP/1.1");
        m_proxy_data->req.set_method("CONNECT");
 
        m_proxy_data->req.set_uri(authority);
        m_proxy_data->req.replace_header("Host",authority);
 
        return lib::error_code();
    }

Here is the call graph for this function:

proxy_read()

template<typename config >

void websocketpp::transport::asio::connection< config >::proxy_read ( init_handler callback )

inlineprotected

Definition at line 698 of file connection.hpp.

                                           {
        if (m_alog.static_test(log::alevel::devel)) {
            m_alog.write(log::alevel::devel,"asio connection proxy_read");
        }
 
        if (!m_proxy_data) {
            m_elog.write(log::elevel::library,
                "assertion failed: !m_proxy_data in asio::connection::proxy_read");
            m_proxy_data->timer->cancel();
            callback(make_error_code(error::general));
            return;
        }
 
        if (config::enable_multithreading) {
            lib::asio::async_read_until(
                socket_con_type::get_next_layer(),
                m_proxy_data->read_buf,
                "\r\n\r\n",
                m_strand->wrap(lib::bind(
                    &type::handle_proxy_read, get_shared(),
                    callback,
                    lib::placeholders::_1, lib::placeholders::_2
                ))
            );
        } else {
            lib::asio::async_read_until(
                socket_con_type::get_next_layer(),
                m_proxy_data->read_buf,
                "\r\n\r\n",
                lib::bind(
                    &type::handle_proxy_read, get_shared(),
                    callback,
                    lib::placeholders::_1, lib::placeholders::_2
                )
            );
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

proxy_write()

template<typename config >

void websocketpp::transport::asio::connection< config >::proxy_write ( init_handler callback )

inlineprotected

Definition at line 597 of file connection.hpp.

                                            {
        if (m_alog.static_test(log::alevel::devel)) {
            m_alog.write(log::alevel::devel,"asio connection proxy_write");
        }
 
        if (!m_proxy_data) {
            m_elog.write(log::elevel::library,
                "assertion failed: !m_proxy_data in asio::connection::proxy_write");
            callback(make_error_code(error::general));
            return;
        }
 
        m_proxy_data->write_buf = m_proxy_data->req.raw();
 
        m_bufs.push_back(lib::asio::buffer(m_proxy_data->write_buf.data(),
                                           m_proxy_data->write_buf.size()));
 
        m_alog.write(log::alevel::devel,m_proxy_data->write_buf);
 
        // Set a timer so we don't wait forever for the proxy to respond
        m_proxy_data->timer = this->set_timer(
            m_proxy_data->timeout_proxy,
            lib::bind(
                &type::handle_proxy_timeout,
                get_shared(),
                callback,
                lib::placeholders::_1
            )
        );
 
        // Send proxy request
        if (config::enable_multithreading) {
            lib::asio::async_write(
                socket_con_type::get_next_layer(),
                m_bufs,
                m_strand->wrap(lib::bind(
                    &type::handle_proxy_write, get_shared(),
                    callback,
                    lib::placeholders::_1
                ))
            );
        } else {
            lib::asio::async_write(
                socket_con_type::get_next_layer(),
                m_bufs,
                lib::bind(
                    &type::handle_proxy_write, get_shared(),
                    callback,
                    lib::placeholders::_1
                )
            );
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

set_handle()

template<typename config >

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

inlineprotected

See common/connection_hdl.hpp for information

Parameters

hdl	A connection_hdl that the transport will use to refer to itself

Definition at line 1004 of file connection.hpp.

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

set_proxy() [1/2]

template<typename config >

void websocketpp::transport::asio::connection< config >::set_proxy ( std::string const & uri )

inline

Definition at line 199 of file connection.hpp.

                                          {
        lib::error_code ec;
        set_proxy(uri,ec);
        if (ec) { throw exception(ec); }
    }

Here is the call graph for this function:

set_proxy() [2/2]

template<typename config >

void websocketpp::transport::asio::connection< config >::set_proxy ( std::string const & uri, lib::error_code & ec )

inline

The URI passed should be a complete URI including scheme. For example: http://proxy.example.com:8080/

The proxy must be set up as an explicit (CONNECT) proxy allowed to connect to the port you specify. Traffic to the proxy is not encrypted.

Parameters

uri	The full URI of the proxy to connect to.
ec	A status value

Definition at line 190 of file connection.hpp.

                                                              {
        // TODO: return errors for illegal URIs here?
        // TODO: should https urls be illegal for the moment?
        m_proxy = uri;
        m_proxy_data = lib::make_shared<proxy_data>();
        ec = lib::error_code();
    }

Here is the caller graph for this function:

set_proxy_basic_auth() [1/2]

template<typename config >

void websocketpp::transport::asio::connection< config >::set_proxy_basic_auth ( std::string const & username, std::string const & password )

inline

Definition at line 233 of file connection.hpp.

    {
        lib::error_code ec;
        set_proxy_basic_auth(username,password,ec);
        if (ec) { throw exception(ec); }
    }

Here is the call graph for this function:

set_proxy_basic_auth() [2/2]

template<typename config >

void websocketpp::transport::asio::connection< config >::set_proxy_basic_auth ( std::string const & username, std::string const & password, lib::error_code & ec )

inline

The URI passed should be a complete URI including scheme. For example: http://proxy.example.com:8080/

The proxy must be set up as an explicit proxy

Parameters

username	The username to send
password	The password to send
ec	A status value

Definition at line 218 of file connection.hpp.

    {
        if (!m_proxy_data) {
            ec = make_error_code(websocketpp::error::invalid_state);
            return;
        }
 
        // TODO: username can't contain ':'
        std::string val = "Basic "+base64_encode(username + ":" + password);
        m_proxy_data->req.replace_header("Proxy-Authorization",val);
        ec = lib::error_code();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

set_proxy_timeout() [1/2]

template<typename config >

void websocketpp::transport::asio::connection< config >::set_proxy_timeout ( long duration )

inline

Definition at line 262 of file connection.hpp.

                                          {
        lib::error_code ec;
        set_proxy_timeout(duration,ec);
        if (ec) { throw exception(ec); }
    }

Here is the call graph for this function:

set_proxy_timeout() [2/2]

template<typename config >

void websocketpp::transport::asio::connection< config >::set_proxy_timeout ( long duration, lib::error_code & ec )

inline

Duration is in milliseconds. Default value is based on the transport config

Parameters

duration	The number of milliseconds to wait before aborting the proxy connection.
ec	A status value

Definition at line 251 of file connection.hpp.

                                                              {
        if (!m_proxy_data) {
            ec = make_error_code(websocketpp::error::invalid_state);
            return;
        }
 
        m_proxy_data->timeout_proxy = duration;
        ec = lib::error_code();
    }

Here is the caller graph for this function:

set_tcp_init_handler()

template<typename config >

void websocketpp::transport::asio::connection< config >::set_tcp_init_handler ( tcp_init_handler h )

inline

The tcp pre init handler is called after the raw tcp connection has been established but before any additional wrappers (proxy connects, TLS handshakes, etc) have been performed.

Deprecated

Use set_tcp_pre_init_handler instead

Parameters

h	The handler to call on tcp pre init.

Definition at line 159 of file connection.hpp.

                                                  {
        set_tcp_pre_init_handler(h);
    }

Here is the call graph for this function:

set_tcp_post_init_handler()

template<typename config >

void websocketpp::transport::asio::connection< config >::set_tcp_post_init_handler ( tcp_init_handler h )

inline

The tcp post init handler is called after the tcp connection has been established and all additional wrappers (proxy connects, TLS handshakes, etc have been performed. This is fired before any bytes are read or any WebSocket specific handshake logic has been performed.

Since

0.3.0

Parameters

h	The handler to call on tcp post init.

Definition at line 174 of file connection.hpp.

                                                       {
        m_tcp_post_init_handler = h;
    }

set_tcp_pre_init_handler()

template<typename config >

void websocketpp::transport::asio::connection< config >::set_tcp_pre_init_handler ( tcp_init_handler h )

inline

The tcp pre init handler is called after the raw tcp connection has been established but before any additional wrappers (proxy connects, TLS handshakes, etc) have been performed.

Since

0.3.0

Parameters

h	The handler to call on tcp pre init.

Definition at line 145 of file connection.hpp.

                                                      {
        m_tcp_pre_init_handler = h;
    }

Here is the caller graph for this function:

set_timer()

template<typename config >

timer_ptr websocketpp::transport::asio::connection< config >::set_timer ( long duration, timer_handler callback )

inline

Sets a timer that calls back a function after the specified period of milliseconds. Returns a handle that can be used to cancel the timer. A cancelled timer will return the error code error::operation_aborted A timer that expired will return no error.

Parameters

duration	Length of time to wait in milliseconds
callback	The function to call back when the timer has expired

Returns

A handle that can be used to cancel the timer if it is no longer needed.

Definition at line 314 of file connection.hpp.

                                                               {
        timer_ptr new_timer = lib::make_shared<lib::asio::steady_timer>(
            *m_io_service,
            lib::asio::milliseconds(duration)
        );
 
        if (config::enable_multithreading) {
            new_timer->async_wait(m_strand->wrap(lib::bind(
                &type::handle_timer, get_shared(),
                new_timer,
                callback,
                lib::placeholders::_1
            )));
        } else {
            new_timer->async_wait(lib::bind(
                &type::handle_timer, get_shared(),
                new_timer,
                callback,
                lib::placeholders::_1
            ));
        }
 
        return new_timer;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

set_uri()

template<typename config >

void websocketpp::transport::asio::connection< config >::set_uri ( uri_ptr u )

inline

Called by the endpoint as a connection is being established to provide the uri being connected to to the transport layer.

This transport policy doesn't use the uri except to forward it to the socket layer.

Since

0.6.0

Parameters

u	The uri to set

Definition at line 131 of file connection.hpp.

                            {
        socket_con_type::set_uri(u);
    }

Friends And Related Symbol Documentation

endpoint< config >

template<typename config >

friend class endpoint< config >

friend

Definition at line 93 of file connection.hpp.

local_endpoint

template<typename config >

template<typename T >

friend class local_endpoint

friend

Definition at line 99 of file connection.hpp.

---

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

• libraries/fc/vendor/websocketpp/websocketpp/transport/asio/connection.hpp