epee::net_utils::connection_basic Class Reference

#include <connection_basic.hpp>

Inheritance diagram for epee::net_utils::connection_basic:

Collaboration diagram for epee::net_utils::connection_basic:

Public Member Functions
	connection_basic (boost::asio::ip::tcp::socket &&socket, boost::shared_ptr< connection_basic_shared_state > state, ssl_support_t ssl_support)
	connection_basic (boost::asio::io_service &io_service, boost::shared_ptr< connection_basic_shared_state > state, ssl_support_t ssl_support)
virtual	~connection_basic () noexcept(false)
connection_basic_shared_state &	get_state () noexcept
	connection_basic (boost::asio::io_service &io_service, std::atomic< long > &ref_sock_count, std::atomic< long > &sock_number, ssl_support_t ssl)
boost::asio::ip::tcp::socket &	socket ()
ssl_support_t	get_ssl_support () const
void	disable_ssl ()
bool	handshake (boost::asio::ssl::stream_base::handshake_type type)
template<typename MutableBufferSequence , typename ReadHandler >
void	async_read_some (const MutableBufferSequence &buffers, ReadHandler &&handler)
template<typename ConstBufferSequence , typename WriteHandler >
void	async_write_some (const ConstBufferSequence &buffers, WriteHandler &&handler)
template<typename ConstBufferSequence , typename WriteHandler >
void	async_write (const ConstBufferSequence &buffers, WriteHandler &&handler)
void	do_send_handler_write (const void *ptr, size_t cb)
void	do_send_handler_write_from_queue (const boost::system::error_code &e, size_t cb, int q_len)
void	logger_handle_net_write (size_t size)
void	logger_handle_net_read (size_t size)
void	sleep_before_packet (size_t packet_size, int phase, int q_len)

Static Public Member Functions
static void	set_rate_up_limit (uint64_t limit)
static void	set_rate_down_limit (uint64_t limit)
static uint64_t	get_rate_up_limit ()
static uint64_t	get_rate_down_limit ()
static void	set_tos_flag (int tos)
static int	get_tos_flag ()
static void	save_limit_to_file (int limit)
	for dr-electroneum More...
static double	get_sleep_time (size_t cb)
static void	set_save_graph (bool save_graph)

Public Attributes
std::unique_ptr< connection_basic_pimpl >	mI
volatile uint32_t	m_want_close_connection
std::atomic< bool >	m_was_shutdown
critical_section	m_send_que_lock
std::list< std::string >	m_send_que
volatile bool	m_is_multithreaded
boost::asio::io_service::strand	strand_
	Strand to ensure the connection's handlers are not called concurrently. More...
boost::asio::ssl::stream< boost::asio::ip::tcp::socket >	socket_
	Socket for the connection. More...
ssl_support_t	m_ssl_support

Detailed Description

Definition at line 101 of file connection_basic.hpp.

Constructor & Destructor Documentation

connection_basic() [1/3]

epee::net_utils::connection_basic::connection_basic	(	boost::asio::ip::tcp::socket &&	socket,
		boost::shared_ptr< connection_basic_shared_state >	state,
		ssl_support_t	ssl_support
	)

Definition at line 132 of file connection_basic.cpp.

    :
    m_state(std::move(state)),
    mI( new connection_basic_pimpl("peer") ),
    strand_(GET_IO_SERVICE(sock)),
    socket_(GET_IO_SERVICE(sock), get_context(m_state.get())),
    m_want_close_connection(false),
    m_was_shutdown(false),
    m_ssl_support(ssl_support)
{
    // add nullptr checks if removed
    assert(m_state != nullptr); // release runtime check in get_context
 
        socket_.next_layer() = std::move(sock);
 
    ++(m_state->sock_count); // increase the global counter
    mI->m_peer_number = m_state->sock_number.fetch_add(1); // use, and increase the generated number
 
    std::string remote_addr_str = "?";
    try { boost::system::error_code e; remote_addr_str = socket().remote_endpoint(e).address().to_string(); } catch(...){} ;
 
    _note("Spawned connection #"<<mI->m_peer_number<<" to " << remote_addr_str << " currently we have sockets count:" << m_state->sock_count);
}

Here is the call graph for this function:

connection_basic() [2/3]

epee::net_utils::connection_basic::connection_basic	(	boost::asio::io_service &	io_service,
		boost::shared_ptr< connection_basic_shared_state >	state,
		ssl_support_t	ssl_support
	)

Definition at line 156 of file connection_basic.cpp.

    :
    m_state(std::move(state)),
    mI( new connection_basic_pimpl("peer") ),
    strand_(io_service),
    socket_(io_service, get_context(m_state.get())),
    m_want_close_connection(false),
    m_was_shutdown(false),
    m_ssl_support(ssl_support)
{
    // add nullptr checks if removed
    assert(m_state != nullptr); // release runtime check in get_context
 
    ++(m_state->sock_count); // increase the global counter
    mI->m_peer_number = m_state->sock_number.fetch_add(1); // use, and increase the generated number
 
    std::string remote_addr_str = "?";
    try { boost::system::error_code e; remote_addr_str = socket().remote_endpoint(e).address().to_string(); } catch(...){} ;
 
    _note("Spawned connection #"<<mI->m_peer_number<<" to " << remote_addr_str << " currently we have sockets count:" << m_state->sock_count);
}

Here is the call graph for this function:

~connection_basic()

epee::net_utils::connection_basic::~connection_basic ( )

virtualnoexcept

Definition at line 178 of file connection_basic.cpp.

                                                    {
    --(m_state->sock_count);
 
    std::string remote_addr_str = "?";
    try { boost::system::error_code e; remote_addr_str = socket().remote_endpoint(e).address().to_string(); } catch(...){} ;
    _note("Destructing connection #"<<mI->m_peer_number << " to " << remote_addr_str);
}

Here is the call graph for this function:

connection_basic() [3/3]

epee::net_utils::connection_basic::connection_basic	(	boost::asio::io_service &	io_service,
		std::atomic< long > &	ref_sock_count,
		std::atomic< long > &	sock_number,
		ssl_support_t	ssl
	)

Member Function Documentation

async_read_some()

template<typename MutableBufferSequence , typename ReadHandler >

void epee::net_utils::connection_basic::async_read_some ( const MutableBufferSequence &  buffers, ReadHandler &&  handler  )

inline

Definition at line 142 of file connection_basic.hpp.

        {
            if (m_ssl_support == epee::net_utils::ssl_support_t::e_ssl_support_enabled)
                socket_.async_read_some(buffers, std::forward<ReadHandler>(handler));
            else
                socket().async_read_some(buffers, std::forward<ReadHandler>(handler));
        }

Here is the call graph for this function:

async_write()

template<typename ConstBufferSequence , typename WriteHandler >

void epee::net_utils::connection_basic::async_write ( const ConstBufferSequence &  buffers, WriteHandler &&  handler  )

inline

Definition at line 160 of file connection_basic.hpp.

        {
            if (m_ssl_support == epee::net_utils::ssl_support_t::e_ssl_support_enabled)
                boost::asio::async_write(socket_, buffers, std::forward<WriteHandler>(handler));
            else
                boost::asio::async_write(socket(), buffers, std::forward<WriteHandler>(handler));
        }

Here is the call graph for this function:

async_write_some()

template<typename ConstBufferSequence , typename WriteHandler >

void epee::net_utils::connection_basic::async_write_some ( const ConstBufferSequence &  buffers, WriteHandler &&  handler  )

inline

Definition at line 151 of file connection_basic.hpp.

        {
            if (m_ssl_support == epee::net_utils::ssl_support_t::e_ssl_support_enabled)
                socket_.async_write_some(buffers, std::forward<WriteHandler>(handler));
            else
                socket().async_write_some(buffers, std::forward<WriteHandler>(handler));
        }

Here is the call graph for this function:

disable_ssl()

void epee::net_utils::connection_basic::disable_ssl ( )

inline

Definition at line 133 of file connection_basic.hpp.

{ m_ssl_support = epee::net_utils::ssl_support_t::e_ssl_support_disabled; }

do_send_handler_write()

void epee::net_utils::connection_basic::do_send_handler_write	(	const void *	ptr,
		size_t	cb
	)

Definition at line 266 of file connection_basic.cpp.

                                                                         {
        // No sleeping here; sleeping is done once and for all in connection<t_protocol_handler>::handle_write
    MTRACE("handler_write (direct) - before ASIO write, for packet="<<cb<<" B (after sleep)");
}

do_send_handler_write_from_queue()

void epee::net_utils::connection_basic::do_send_handler_write_from_queue	(	const boost::system::error_code &	e,
		size_t	cb,
		int	q_len
	)

Definition at line 271 of file connection_basic.cpp.

                                                                                                              {
        // No sleeping here; sleeping is done once and for all in connection<t_protocol_handler>::handle_write
    MTRACE("handler_write (after write, from queue="<<q_len<<") - before ASIO write, for packet="<<cb<<" B (after sleep)");
}

get_rate_down_limit()

uint64_t epee::net_utils::connection_basic::get_rate_down_limit ( )

static

Definition at line 216 of file connection_basic.cpp.

                                               {
    uint64_t limit;
    {
         CRITICAL_REGION_LOCAL( network_throttle_manager::m_lock_get_global_throttle_in );
         limit = network_throttle_manager::get_global_throttle_in().get_target_speed();
    }
    return limit;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_rate_up_limit()

uint64_t epee::net_utils::connection_basic::get_rate_up_limit ( )

static

Definition at line 207 of file connection_basic.cpp.

                                             {
    uint64_t limit;
    {
         CRITICAL_REGION_LOCAL( network_throttle_manager::m_lock_get_global_throttle_out );
         limit = network_throttle_manager::get_global_throttle_out().get_target_speed();
    }
    return limit;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_sleep_time()

double epee::net_utils::connection_basic::get_sleep_time ( size_t  cb )

static

Definition at line 282 of file connection_basic.cpp.

                                                 {
    CRITICAL_REGION_LOCAL(epee::net_utils::network_throttle_manager::network_throttle_manager::m_lock_get_global_throttle_out);
    auto t = network_throttle_manager::get_global_throttle_out().get_sleep_time(cb);
    return t;
}

Here is the call graph for this function:

get_ssl_support()

ssl_support_t epee::net_utils::connection_basic::get_ssl_support ( ) const

inline

Definition at line 132 of file connection_basic.hpp.

{ return m_ssl_support; }

get_state()

connection_basic_shared_state& epee::net_utils::connection_basic::get_state ( )

inlinenoexcept

Returns

shared_state object passed in construction (ptr never changes).

Definition at line 128 of file connection_basic.hpp.

{ return *m_state; /* verified in constructor */ }

get_tos_flag()

int epee::net_utils::connection_basic::get_tos_flag ( )

static

Definition at line 232 of file connection_basic.cpp.

                                   {
    return connection_basic_pimpl::m_default_tos;
}

handshake()

bool epee::net_utils::connection_basic::handshake ( boost::asio::ssl::stream_base::handshake_type  type )

inline

Definition at line 135 of file connection_basic.hpp.

        {
            //m_state != nullptr verified in constructor
            return m_state->ssl_options().handshake(socket_, type);
        }

logger_handle_net_read()

void epee::net_utils::connection_basic::logger_handle_net_read

(

size_t

size

)

Definition at line 276 of file connection_basic.cpp.

                                                         { // network data read
}

logger_handle_net_write()

void epee::net_utils::connection_basic::logger_handle_net_write

(

size_t

size

)

Definition at line 279 of file connection_basic.cpp.

                                                          {
}

save_limit_to_file()

void epee::net_utils::connection_basic::save_limit_to_file ( int  limit )

static

for dr-electroneum

Definition at line 225 of file connection_basic.cpp.

                                                   {
}

Here is the caller graph for this function:

set_rate_down_limit()

void epee::net_utils::connection_basic::set_rate_down_limit ( uint64_t  limit )

static

Definition at line 194 of file connection_basic.cpp.

                                                         {
    {
      CRITICAL_REGION_LOCAL(    network_throttle_manager::m_lock_get_global_throttle_in );
        network_throttle_manager::get_global_throttle_in().set_target_speed(limit);
    }
 
    {
      CRITICAL_REGION_LOCAL(    network_throttle_manager::m_lock_get_global_throttle_inreq );
        network_throttle_manager::get_global_throttle_inreq().set_target_speed(limit);
    }
    save_limit_to_file(limit);
}

Here is the call graph for this function:

Here is the caller graph for this function:

set_rate_up_limit()

void epee::net_utils::connection_basic::set_rate_up_limit ( uint64_t  limit )

static

Definition at line 186 of file connection_basic.cpp.

                                                       {
    {
        CRITICAL_REGION_LOCAL(  network_throttle_manager::m_lock_get_global_throttle_out );
        network_throttle_manager::get_global_throttle_out().set_target_speed(limit);
    }
    save_limit_to_file(limit);
}

Here is the call graph for this function:

Here is the caller graph for this function:

set_save_graph()

void epee::net_utils::connection_basic::set_save_graph ( bool  save_graph )

static

Definition at line 288 of file connection_basic.cpp.

                                                     {
}

Here is the caller graph for this function:

set_tos_flag()

void epee::net_utils::connection_basic::set_tos_flag ( int  tos )

static

Definition at line 228 of file connection_basic.cpp.

                                           {
    connection_basic_pimpl::m_default_tos = tos;
}

sleep_before_packet()

void epee::net_utils::connection_basic::sleep_before_packet	(	size_t	packet_size,
		int	phase,
		int	q_len
	)

Definition at line 236 of file connection_basic.cpp.

                                                                                    {
    double delay=0; // will be calculated
    do
    { // rate limiting
        if (m_was_shutdown) { 
            _dbg2("m_was_shutdown - so abort sleep");
            return;
        }
 
        { 
            CRITICAL_REGION_LOCAL(  network_throttle_manager::m_lock_get_global_throttle_out );
            delay = network_throttle_manager::get_global_throttle_out().get_sleep_time_after_tick( packet_size );
        }
 
        delay *= 0.50;
        if (delay > 0) {
            long int ms = (long int)(delay * 1000);
            MTRACE("Sleeping in " << __FUNCTION__ << " for " << ms << " ms before packet_size="<<packet_size); // debug sleep
            boost::this_thread::sleep(boost::posix_time::milliseconds( ms ) );
        }
    } while(delay > 0);
 
// XXX LATER XXX
    {
      CRITICAL_REGION_LOCAL(    network_throttle_manager::m_lock_get_global_throttle_out );
        network_throttle_manager::get_global_throttle_out().handle_trafic_exact( packet_size ); // increase counter - global
    }
 
}

Here is the call graph for this function:

socket()

boost::asio::ip::tcp::socket& epee::net_utils::connection_basic::socket ( )

inline

Definition at line 131 of file connection_basic.hpp.

{ return socket_.next_layer(); }

Here is the caller graph for this function:

Member Data Documentation

m_is_multithreaded

volatile bool epee::net_utils::connection_basic::m_is_multithreaded

Definition at line 113 of file connection_basic.hpp.

m_send_que

std::list<std::string> epee::net_utils::connection_basic::m_send_que

Definition at line 112 of file connection_basic.hpp.

m_send_que_lock

critical_section epee::net_utils::connection_basic::m_send_que_lock

Definition at line 111 of file connection_basic.hpp.

m_ssl_support

ssl_support_t epee::net_utils::connection_basic::m_ssl_support

Definition at line 118 of file connection_basic.hpp.

m_want_close_connection

volatile uint32_t epee::net_utils::connection_basic::m_want_close_connection

Definition at line 109 of file connection_basic.hpp.

m_was_shutdown

std::atomic<bool> epee::net_utils::connection_basic::m_was_shutdown

Definition at line 110 of file connection_basic.hpp.

mI

std::unique_ptr< connection_basic_pimpl > epee::net_utils::connection_basic::mI

Definition at line 106 of file connection_basic.hpp.

socket_

boost::asio::ssl::stream<boost::asio::ip::tcp::socket> epee::net_utils::connection_basic::socket_

Socket for the connection.

Definition at line 117 of file connection_basic.hpp.

strand_

boost::asio::io_service::strand epee::net_utils::connection_basic::strand_

Strand to ensure the connection's handlers are not called concurrently.

Definition at line 115 of file connection_basic.hpp.

---

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

• /home/abuild/rpmbuild/BUILD/electroneum-4.0.0.0/contrib/epee/include/net/connection_basic.hpp
• /home/abuild/rpmbuild/BUILD/electroneum-4.0.0.0/contrib/epee/src/connection_basic.cpp