epee::net_utils::blocked_mode_client Class Reference

#include <net_helper.h>

Inheritance diagram for epee::net_utils::blocked_mode_client:

Collaboration diagram for epee::net_utils::blocked_mode_client:

Public Types
using	connect_func = boost::unique_future<boost::asio::ip::tcp::socket>(const std::string&, const std::string&, boost::asio::steady_timer&)

Public Member Functions
	blocked_mode_client ()
	~blocked_mode_client ()
void	set_ssl (ssl_options_t ssl_options)
bool	connect (const std::string &addr, int port, std::chrono::milliseconds timeout)
try_connect_result_t	try_connect (const std::string &addr, const std::string &port, std::chrono::milliseconds timeout, epee::net_utils::ssl_support_t ssl_support)
bool	connect (const std::string &addr, const std::string &port, std::chrono::milliseconds timeout)
void	set_connector (std::function< connect_func > connector)
	Change the connection routine (proxy, etc.).
bool	disconnect ()
bool	send (const std::string &buff, std::chrono::milliseconds timeout)
bool	send (const void *data, size_t sz)
bool	is_connected (bool *ssl=NULL)
bool	recv (std::string &buff, std::chrono::milliseconds timeout)
bool	recv_n (std::string &buff, int64_t sz, std::chrono::milliseconds timeout)
bool	shutdown ()
boost::asio::io_service &	get_io_service ()
boost::asio::ip::tcp::socket &	get_socket ()
uint64_t	get_bytes_sent () const
uint64_t	get_bytes_received () const

Protected Member Functions
bool	write (const void *data, size_t sz, boost::system::error_code &ec)
void	async_write (const void *data, size_t sz, boost::system::error_code &ec)
void	async_read (char *buff, size_t sz, boost::asio::detail::transfer_at_least_t transfer_at_least, handler_obj &hndlr)

Protected Attributes
boost::asio::io_service	m_io_service
boost::asio::ssl::context	m_ctx
std::shared_ptr< boost::asio::ssl::stream< boost::asio::ip::tcp::socket > >	m_ssl_socket
std::function< connect_func >	m_connector
ssl_options_t	m_ssl_options
bool	m_initialized
bool	m_connected
boost::asio::steady_timer	m_deadline
volatile uint32_t	m_shutdowned
std::atomic< uint64_t >	m_bytes_sent
std::atomic< uint64_t >	m_bytes_received

Detailed Description

Definition at line 70 of file net_helper.h.

Member Typedef Documentation

connect_func

using epee::net_utils::blocked_mode_client::connect_func = boost::unique_future<boost::asio::ip::tcp::socket>(const std::string&, const std::string&, boost::asio::steady_timer&)

The first/second parameters are host/port respectively. The third parameter is for setting the timeout callback - the timer is already set by the caller, the callee only needs to set the behavior.

Additional asynchronous operations should be queued using the io_service from the timer. The implementation should assume multi-threaded I/O processing.

If the callee cannot start an asynchronous operation, an exception should be thrown to signal an immediate failure.

The return value is a future to a connected socket. Asynchronous failures should use the set_exception method.

Definition at line 131 of file net_helper.h.

Constructor & Destructor Documentation

blocked_mode_client()

epee::net_utils::blocked_mode_client::blocked_mode_client ( )

inline

Definition at line 102 of file net_helper.h.

                                  :
                m_io_service(),
                m_ctx(boost::asio::ssl::context::tlsv12),
                m_connector(direct_connect{}),
                m_ssl_socket(new boost::asio::ssl::stream<boost::asio::ip::tcp::socket>(m_io_service, m_ctx)),
                m_ssl_options(epee::net_utils::ssl_support_t::e_ssl_support_autodetect),
                m_initialized(true),
                m_connected(false),
                m_deadline(m_io_service),
                m_shutdowned(0),
                m_bytes_sent(0),
                m_bytes_received(0)
        {
        }

Here is the caller graph for this function:

~blocked_mode_client()

epee::net_utils::blocked_mode_client::~blocked_mode_client ( )

inline

Definition at line 134 of file net_helper.h.

        {
            //profile_tools::local_coast lc("~blocked_mode_client()", 3);
            try { shutdown(); }
            catch(...) { /* ignore */ }
        }

Here is the call graph for this function:

Member Function Documentation

async_read()

void epee::net_utils::blocked_mode_client::async_read ( char * buff, size_t sz, boost::asio::detail::transfer_at_least_t transfer_at_least, handler_obj & hndlr )

inlineprotected

Definition at line 667 of file net_helper.h.

        {
            if(m_ssl_options.support == ssl_support_t::e_ssl_support_disabled)
                boost::asio::async_read(m_ssl_socket->next_layer(), boost::asio::buffer(buff, sz), transfer_at_least, hndlr);
            else
                boost::asio::async_read(*m_ssl_socket, boost::asio::buffer(buff, sz), transfer_at_least, hndlr);
            
        }

Here is the caller graph for this function:

async_write()

void epee::net_utils::blocked_mode_client::async_write ( const void * data, size_t sz, boost::system::error_code & ec )

inlineprotected

Definition at line 659 of file net_helper.h.

        {
            if(m_ssl_options.support != ssl_support_t::e_ssl_support_disabled)
                boost::asio::async_write(*m_ssl_socket, boost::asio::buffer(data, sz), boost::lambda::var(ec) = boost::lambda::_1);
            else
                boost::asio::async_write(m_ssl_socket->next_layer(), boost::asio::buffer(data, sz), boost::lambda::var(ec) = boost::lambda::_1);
        }

Here is the caller graph for this function:

connect() [1/2]

bool epee::net_utils::blocked_mode_client::connect ( const std::string & addr, const std::string & port, std::chrono::milliseconds timeout )

inline

Definition at line 207 of file net_helper.h.

        {
            m_connected = false;
            try
            {
                m_ssl_socket->next_layer().close();
 
                // Set SSL options
                // disable sslv2
                m_ssl_socket.reset(new boost::asio::ssl::stream<boost::asio::ip::tcp::socket>(m_io_service, m_ctx));
 
                // Get a list of endpoints corresponding to the server name.
 
                try_connect_result_t try_connect_result = try_connect(addr, port, timeout, m_ssl_options.support);
                if (try_connect_result == CONNECT_FAILURE)
                    return false;
                if (m_ssl_options.support == epee::net_utils::ssl_support_t::e_ssl_support_autodetect)
                {
                    if (try_connect_result == CONNECT_NO_SSL)
                    {
                        MERROR("SSL handshake failed on an autodetect connection, reconnecting without SSL");
                        m_ssl_options.support = epee::net_utils::ssl_support_t::e_ssl_support_disabled;
                        if (try_connect(addr, port, timeout, m_ssl_options.support) != CONNECT_SUCCESS)
                            return false;
                    }
                }
            }
            catch(const boost::system::system_error& er)
            {
                MDEBUG("Some problems at connect, message: " << er.what());
                return false;
            }
            catch(...)
            {
                MDEBUG("Some fatal problems.");
                return false;
            }
 
            return true;
        }

Here is the call graph for this function:

connect() [2/2]

bool epee::net_utils::blocked_mode_client::connect ( const std::string & addr, int port, std::chrono::milliseconds timeout )

inline

Definition at line 151 of file net_helper.h.

    {
      return connect(addr, std::to_string(port), timeout);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

disconnect()

bool epee::net_utils::blocked_mode_client::disconnect ( )

inline

Definition at line 254 of file net_helper.h.

        {
            try
            {   
                if(m_connected)
                {
                    m_connected = false;
                    if(m_ssl_options)
                        shutdown_ssl();
                    m_ssl_socket->next_layer().shutdown(boost::asio::ip::tcp::socket::shutdown_both);
                }
            }
            catch(const boost::system::system_error& /*er*/)
            {
                //LOG_ERROR("Some problems at disconnect, message: " << er.what());
                return false;
            }
            catch(...)
            {
                //LOG_ERROR("Some fatal problems.");
                return false;
            }
            return true;
        }

get_bytes_received()

uint64_t epee::net_utils::blocked_mode_client::get_bytes_received ( ) const

inline

Definition at line 596 of file net_helper.h.

        {
            return m_bytes_received;
        }

get_bytes_sent()

uint64_t epee::net_utils::blocked_mode_client::get_bytes_sent ( ) const

inline

Definition at line 591 of file net_helper.h.

        {
            return m_bytes_sent;
        }

get_io_service()

boost::asio::io_service & epee::net_utils::blocked_mode_client::get_io_service ( )

inline

Definition at line 581 of file net_helper.h.

        {
            return m_io_service;
        }

get_socket()

boost::asio::ip::tcp::socket & epee::net_utils::blocked_mode_client::get_socket ( )

inline

Definition at line 586 of file net_helper.h.

        {
            return m_ssl_socket->next_layer();
        }

is_connected()

bool epee::net_utils::blocked_mode_client::is_connected ( bool * ssl = NULL )

inline

Definition at line 392 of file net_helper.h.

        {
            if (!m_connected || !m_ssl_socket->next_layer().is_open())
                return false;
            if (ssl)
                *ssl = m_ssl_options.support != ssl_support_t::e_ssl_support_disabled;
            return true;
        }

recv()

bool epee::net_utils::blocked_mode_client::recv ( std::string & buff, std::chrono::milliseconds timeout )

inline

Definition at line 402 of file net_helper.h.

        {
 
            try
            {
                // Set a deadline for the asynchronous operation. Since this function uses
                // a composed operation (async_read_until), the deadline applies to the
                // entire operation, rather than individual reads from the socket.
                m_deadline.expires_from_now(timeout);
 
                // Set up the variable that receives the result of the asynchronous
                // operation. The error code is set to would_block to signal that the
                // operation is incomplete. Asio guarantees that its asynchronous
                // operations will never fail with would_block, so any other value in
                // ec indicates completion.
                //boost::system::error_code ec = boost::asio::error::would_block;
 
                // Start the asynchronous operation itself. The boost::lambda function
                // object is used as a callback and will update the ec variable when the
                // operation completes. The blocking_udp_client.cpp example shows how you
                // can use boost::bind rather than boost::lambda.
 
                boost::system::error_code ec = boost::asio::error::would_block;
                size_t bytes_transfered = 0;
            
                handler_obj hndlr(ec, bytes_transfered);
 
                static const size_t max_size = 16384;
                buff.resize(max_size);
                
                async_read(&buff[0], max_size, boost::asio::transfer_at_least(1), hndlr);
 
                // Block until the asynchronous operation has completed.
                while (ec == boost::asio::error::would_block && !boost::interprocess::ipcdetail::atomic_read32(&m_shutdowned))
                {
                    m_io_service.reset();
                    m_io_service.run_one(); 
                }
 
 
                if (ec)
                {
                    MTRACE("READ ENDS: Connection err_code " << ec.value());
                    if(ec == boost::asio::error::eof)
                    {
                      MTRACE("Connection err_code eof.");
                      //connection closed there, empty
                      buff.clear();
                      return true;
                    }
 
                    MDEBUG("Problems at read: " << ec.message());
                    m_connected = false;
                    return false;
                }else
                {
                    MTRACE("READ ENDS: Success. bytes_tr: " << bytes_transfered);
                    m_deadline.expires_at(std::chrono::steady_clock::time_point::max());
                }
 
                /*if(!bytes_transfered)
                    return false;*/
 
                m_bytes_received += bytes_transfered;
                buff.resize(bytes_transfered);
                return true;
            }
 
            catch(const boost::system::system_error& er)
            {
                LOG_ERROR("Some problems at read, message: " << er.what());
        m_connected = false;
                return false;
            }
            catch(...)
            {
                LOG_ERROR("Some fatal problems at read.");
                return false;
            }
 
 
 
            return false;
 
        }

Here is the call graph for this function:

recv_n()

bool epee::net_utils::blocked_mode_client::recv_n ( std::string & buff, int64_t sz, std::chrono::milliseconds timeout )

inline

Definition at line 488 of file net_helper.h.

        {
 
            try
            {
                // Set a deadline for the asynchronous operation. Since this function uses
                // a composed operation (async_read_until), the deadline applies to the
                // entire operation, rather than individual reads from the socket.
                m_deadline.expires_from_now(timeout);
 
                // Set up the variable that receives the result of the asynchronous
                // operation. The error code is set to would_block to signal that the
                // operation is incomplete. Asio guarantees that its asynchronous
                // operations will never fail with would_block, so any other value in
                // ec indicates completion.
                //boost::system::error_code ec = boost::asio::error::would_block;
 
                // Start the asynchronous operation itself. The boost::lambda function
                // object is used as a callback and will update the ec variable when the
                // operation completes. The blocking_udp_client.cpp example shows how you
                // can use boost::bind rather than boost::lambda.
 
                buff.resize(static_cast<size_t>(sz));
                boost::system::error_code ec = boost::asio::error::would_block;
                size_t bytes_transfered = 0;
 
                
                handler_obj hndlr(ec, bytes_transfered);
                async_read((char*)buff.data(), buff.size(), boost::asio::transfer_at_least(buff.size()), hndlr);
                
                // Block until the asynchronous operation has completed.
                while (ec == boost::asio::error::would_block && !boost::interprocess::ipcdetail::atomic_read32(&m_shutdowned))
                {
                    m_io_service.run_one(); 
                }
 
                if (ec)
                {
                    LOG_PRINT_L3("Problems at read: " << ec.message());
          m_connected = false;
                    return false;
                }else
                {
                    m_deadline.expires_at(std::chrono::steady_clock::time_point::max());
                }
 
                m_bytes_received += bytes_transfered;
                if(bytes_transfered != buff.size())
                {
                    LOG_ERROR("Transferred mismatch with transfer_at_least value: m_bytes_transferred=" << bytes_transfered << " at_least value=" << buff.size());
                    return false;
                }
 
                return true;
            }
 
            catch(const boost::system::system_error& er)
            {
                LOG_ERROR("Some problems at read, message: " << er.what());
        m_connected = false;
                return false;
            }
            catch(...)
            {
                LOG_ERROR("Some fatal problems at read.");
                return false;
            }
 
 
 
            return false;
        }

Here is the call graph for this function:

send() [1/2]

bool epee::net_utils::blocked_mode_client::send ( const std::string & buff, std::chrono::milliseconds timeout )

inline

Definition at line 281 of file net_helper.h.

        {
 
            try
            {
                m_deadline.expires_from_now(timeout);
 
                // Set up the variable that receives the result of the asynchronous
                // operation. The error code is set to would_block to signal that the
                // operation is incomplete. Asio guarantees that its asynchronous
                // operations will never fail with would_block, so any other value in
                // ec indicates completion.
                boost::system::error_code ec = boost::asio::error::would_block;
 
                // Start the asynchronous operation itself. The boost::lambda function
                // object is used as a callback and will update the ec variable when the
                // operation completes. The blocking_udp_client.cpp example shows how you
                // can use boost::bind rather than boost::lambda.
                async_write(buff.c_str(), buff.size(), ec);
 
                // Block until the asynchronous operation has completed.
                while (ec == boost::asio::error::would_block)
                {
                    m_io_service.reset();
                    m_io_service.run_one(); 
                }
 
                if (ec)
                {
                    LOG_PRINT_L3("Problems at write: " << ec.message());
          m_connected = false;
                    return false;
                }else
                {
                    m_deadline.expires_at(std::chrono::steady_clock::time_point::max());
                    m_bytes_sent += buff.size();
                }
            }
 
            catch(const boost::system::system_error& er)
            {
                LOG_ERROR("Some problems at connect, message: " << er.what());
                return false;
            }
            catch(...)
            {
                LOG_ERROR("Some fatal problems.");
                return false;
            }
 
            return true;
        }

Here is the call graph for this function:

send() [2/2]

bool epee::net_utils::blocked_mode_client::send ( const void * data, size_t sz )

inline

Definition at line 335 of file net_helper.h.

        {
            try
            {
                /*
                m_deadline.expires_from_now(boost::posix_time::milliseconds(m_reciev_timeout));
 
                // Set up the variable that receives the result of the asynchronous
                // operation. The error code is set to would_block to signal that the
                // operation is incomplete. Asio guarantees that its asynchronous
                // operations will never fail with would_block, so any other value in
                // ec indicates completion.
                boost::system::error_code ec = boost::asio::error::would_block;
 
                // Start the asynchronous operation itself. The boost::lambda function
                // object is used as a callback and will update the ec variable when the
                // operation completes. The blocking_udp_client.cpp example shows how you
                // can use boost::bind rather than boost::lambda.
                boost::asio::async_write(m_socket, boost::asio::buffer(data, sz), boost::lambda::var(ec) = boost::lambda::_1);
 
                // Block until the asynchronous operation has completed.
                while (ec == boost::asio::error::would_block)
                {
                    m_io_service.run_one();
                }
                */
                boost::system::error_code ec;
 
                size_t writen = write(data, sz, ec);
 
                if (!writen || ec)
                {
                    LOG_PRINT_L3("Problems at write: " << ec.message());
          m_connected = false;
                    return false;
                }else
                {
                    m_deadline.expires_at(std::chrono::steady_clock::time_point::max());
                    m_bytes_sent += sz;
                }
            }
 
            catch(const boost::system::system_error& er)
            {
                LOG_ERROR("Some problems at send, message: " << er.what());
        m_connected = false;
                return false;
            }
            catch(...)
            {
                LOG_ERROR("Some fatal problems.");
                return false;
            }
 
            return true;
        }

Here is the call graph for this function:

set_connector()

void epee::net_utils::blocked_mode_client::set_connector ( std::function< connect_func > connector )

inline

Change the connection routine (proxy, etc.).

Definition at line 248 of file net_helper.h.

        {
            m_connector = std::move(connector);
        }

set_ssl()

void epee::net_utils::blocked_mode_client::set_ssl ( ssl_options_t ssl_options )

inline

Definition at line 141 of file net_helper.h.

        {
            if (ssl_options)
                m_ctx = ssl_options.create_context();
            else
                m_ctx = boost::asio::ssl::context(boost::asio::ssl::context::tlsv12);
            m_ssl_options = std::move(ssl_options);
        }

Here is the call graph for this function:

shutdown()

bool epee::net_utils::blocked_mode_client::shutdown ( )

inline

Definition at line 561 of file net_helper.h.

        {
            m_deadline.cancel();
            boost::system::error_code ec;
            if(m_ssl_options.support != ssl_support_t::e_ssl_support_disabled)
                shutdown_ssl();
            m_ssl_socket->next_layer().cancel(ec);
            if(ec)
                MDEBUG("Problems at cancel: " << ec.message());
            m_ssl_socket->next_layer().shutdown(boost::asio::ip::tcp::socket::shutdown_both, ec);
            if(ec)
                MDEBUG("Problems at shutdown: " << ec.message());
            m_ssl_socket->next_layer().close(ec);
            if(ec)
                MDEBUG("Problems at close: " << ec.message());
            boost::interprocess::ipcdetail::atomic_write32(&m_shutdowned, 1);
      m_connected = false;
            return true;
        }

Here is the caller graph for this function:

try_connect()

try_connect_result_t epee::net_utils::blocked_mode_client::try_connect ( const std::string & addr, const std::string & port, std::chrono::milliseconds timeout, epee::net_utils::ssl_support_t ssl_support )

inline

Definition at line 157 of file net_helper.h.

        {
                m_deadline.expires_from_now(timeout);
                boost::unique_future<boost::asio::ip::tcp::socket> connection = m_connector(addr, port, m_deadline);
                for (;;)
                {
                    m_io_service.reset();
                    m_io_service.run_one();
 
                    if (connection.is_ready())
                        break;
                }
 
                m_ssl_socket->next_layer() = connection.get();
                m_deadline.cancel();
                if (m_ssl_socket->next_layer().is_open())
                {
                    m_connected = true;
                    m_deadline.expires_at(std::chrono::steady_clock::time_point::max());
                    // SSL Options
                    if (ssl_support == epee::net_utils::ssl_support_t::e_ssl_support_enabled || ssl_support == epee::net_utils::ssl_support_t::e_ssl_support_autodetect)
                    {
                        if (!m_ssl_options.handshake(*m_ssl_socket, boost::asio::ssl::stream_base::client, addr))
                        {
                            if (ssl_support == epee::net_utils::ssl_support_t::e_ssl_support_autodetect)
                            {
                                boost::system::error_code ignored_ec;
                                m_ssl_socket->next_layer().shutdown(boost::asio::ip::tcp::socket::shutdown_both, ignored_ec);
                                m_ssl_socket->next_layer().close();
                                m_connected = false;
                                return CONNECT_NO_SSL;
                            }
                            else
                            {
                                MWARNING("Failed to establish SSL connection");
                                m_connected = false;
                                return CONNECT_FAILURE;
                            }
                        }
                    }
                    return CONNECT_SUCCESS;
                }else
                {
                    MWARNING("Some problems at connect, expected open socket");
                    return CONNECT_FAILURE;
                }
 
        }

Here is the caller graph for this function:

write()

bool epee::net_utils::blocked_mode_client::write ( const void * data, size_t sz, boost::system::error_code & ec )

inlineprotected

Definition at line 649 of file net_helper.h.

        {
            bool success;
            if(m_ssl_options.support != ssl_support_t::e_ssl_support_disabled)
                success = boost::asio::write(*m_ssl_socket, boost::asio::buffer(data, sz), ec);
            else
                success = boost::asio::write(m_ssl_socket->next_layer(), boost::asio::buffer(data, sz), ec);
            return success;
        }

Here is the caller graph for this function:

Member Data Documentation

m_bytes_received

std::atomic<uint64_t> epee::net_utils::blocked_mode_client::m_bytes_received

protected

Definition at line 687 of file net_helper.h.

m_bytes_sent

std::atomic<uint64_t> epee::net_utils::blocked_mode_client::m_bytes_sent

protected

Definition at line 686 of file net_helper.h.

m_connected

bool epee::net_utils::blocked_mode_client::m_connected

protected

Definition at line 683 of file net_helper.h.

m_connector

std::function<connect_func> epee::net_utils::blocked_mode_client::m_connector

protected

Definition at line 680 of file net_helper.h.

m_ctx

boost::asio::ssl::context epee::net_utils::blocked_mode_client::m_ctx

protected

Definition at line 678 of file net_helper.h.

m_deadline

boost::asio::steady_timer epee::net_utils::blocked_mode_client::m_deadline

protected

Definition at line 684 of file net_helper.h.

m_initialized

bool epee::net_utils::blocked_mode_client::m_initialized

protected

Definition at line 682 of file net_helper.h.

m_io_service

boost::asio::io_service epee::net_utils::blocked_mode_client::m_io_service

protected

Definition at line 677 of file net_helper.h.

m_shutdowned

volatile uint32_t epee::net_utils::blocked_mode_client::m_shutdowned

protected

Definition at line 685 of file net_helper.h.

m_ssl_options

ssl_options_t epee::net_utils::blocked_mode_client::m_ssl_options

protected

Definition at line 681 of file net_helper.h.

m_ssl_socket

std::shared_ptr<boost::asio::ssl::stream<boost::asio::ip::tcp::socket> > epee::net_utils::blocked_mode_client::m_ssl_socket

protected

Definition at line 679 of file net_helper.h.

---

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

• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/contrib/epee/include/net/net_helper.h