epee::net_utils::http::http_simple_client_template< net_client_type > Class Template Reference

#include <http_client.h>

Inheritance diagram for epee::net_utils::http::http_simple_client_template< net_client_type >:

Collaboration diagram for epee::net_utils::http::http_simple_client_template< net_client_type >:

Public Member Functions
	http_simple_client_template ()
const std::string &	get_host () const
const std::string &	get_port () const
bool	set_server (const std::string &address, boost::optional< login > user, ssl_options_t ssl_options=ssl_support_t::e_ssl_support_autodetect)
void	set_server (std::string host, std::string port, boost::optional< login > user, ssl_options_t ssl_options=ssl_support_t::e_ssl_support_autodetect)
void	set_auto_connect (bool auto_connect)
template<typename F>
void	set_connector (F connector)
bool	connect (std::chrono::milliseconds timeout)
bool	disconnect ()
bool	is_connected (bool *ssl=NULL)
virtual bool	handle_target_data (std::string &piece_of_transfer)
virtual bool	on_header (const http_response_info &headers)
bool	invoke_get (const boost::string_ref uri, std::chrono::milliseconds timeout, const std::string &body=std::string(), const http_response_info **ppresponse_info=NULL, const fields_list &additional_params=fields_list())
bool	invoke (const boost::string_ref uri, const boost::string_ref method, const std::string &body, std::chrono::milliseconds timeout, const http_response_info **ppresponse_info=NULL, const fields_list &additional_params=fields_list())
bool	invoke_post (const boost::string_ref uri, const std::string &body, std::chrono::milliseconds timeout, const http_response_info **ppresponse_info=NULL, const fields_list &additional_params=fields_list())
bool	test (const std::string &s, std::chrono::milliseconds timeout)
uint64_t	get_bytes_sent () const
uint64_t	get_bytes_received () const
Public Member Functions inherited from epee::net_utils::i_target_handler
virtual	~i_target_handler ()

Detailed Description

template<typename net_client_type>
class epee::net_utils::http::http_simple_client_template< net_client_type >

Definition at line 241 of file http_client.h.

Constructor & Destructor Documentation

http_simple_client_template()

template<typename net_client_type>

epee::net_utils::http::http_simple_client_template< net_client_type >::http_simple_client_template ( )

inlineexplicit

Definition at line 281 of file http_client.h.

                : i_target_handler()
                , m_net_client()
                , m_host_buff()
                , m_port()
                , m_auth()
                , m_header_cache()
                , m_response_info()
                , m_len_in_summary(0)
                , m_len_in_remain(0)
                , m_pcontent_encoding_handler(nullptr)
                , m_state()
                , m_chunked_state()
                , m_chunked_cache()
                , m_auto_connect(true)
                , m_lock()
            {}

Member Function Documentation

connect()

template<typename net_client_type>

bool epee::net_utils::http::http_simple_client_template< net_client_type >::connect ( std::chrono::milliseconds timeout )

inline

Definition at line 333 of file http_client.h.

      {
        CRITICAL_REGION_LOCAL(m_lock);
        return m_net_client.connect(m_host_buff, m_port, timeout);
      }

Here is the caller graph for this function:

disconnect()

template<typename net_client_type>

bool epee::net_utils::http::http_simple_client_template< net_client_type >::disconnect ( )

inline

Definition at line 339 of file http_client.h.

            {
                CRITICAL_REGION_LOCAL(m_lock);
                return m_net_client.disconnect();
            }

Here is the caller graph for this function:

get_bytes_received()

template<typename net_client_type>

uint64_t epee::net_utils::http::http_simple_client_template< net_client_type >::get_bytes_received ( ) const

inline

Definition at line 464 of file http_client.h.

            {
                return m_net_client.get_bytes_received();
            }

get_bytes_sent()

template<typename net_client_type>

uint64_t epee::net_utils::http::http_simple_client_template< net_client_type >::get_bytes_sent ( ) const

inline

Definition at line 459 of file http_client.h.

            {
                return m_net_client.get_bytes_sent();
            }

get_host()

template<typename net_client_type>

const std::string & epee::net_utils::http::http_simple_client_template< net_client_type >::get_host ( ) const

inline

Definition at line 299 of file http_client.h.

{ return m_host_buff; };

get_port()

template<typename net_client_type>

const std::string & epee::net_utils::http::http_simple_client_template< net_client_type >::get_port ( ) const

inline

Definition at line 300 of file http_client.h.

{ return m_port; };

handle_target_data()

template<typename net_client_type>

virtual bool epee::net_utils::http::http_simple_client_template< net_client_type >::handle_target_data ( std::string & piece_of_transfer )

inlinevirtual

Implements epee::net_utils::i_target_handler.

Definition at line 351 of file http_client.h.

            {
                CRITICAL_REGION_LOCAL(m_lock);
                m_response_info.m_body += piece_of_transfer;
        piece_of_transfer.clear();
                return true;
            }

invoke()

template<typename net_client_type>

bool epee::net_utils::http::http_simple_client_template< net_client_type >::invoke ( const boost::string_ref uri, const boost::string_ref method, const std::string & body, std::chrono::milliseconds timeout, const http_response_info ** ppresponse_info = NULL, const fields_list & additional_params = fields_list() )

inline

Definition at line 372 of file http_client.h.

            {
                CRITICAL_REGION_LOCAL(m_lock);
                if(!is_connected())
                {
                    if (!m_auto_connect)
                    {
                        MWARNING("Auto connect attempt to " << m_host_buff << ":" << m_port << " disabled");
                        return false;
                    }
                    MDEBUG("Reconnecting...");
                    if(!connect(timeout))
                    {
                        MDEBUG("Failed to connect to " << m_host_buff << ":" << m_port);
                        return false;
                    }
                }
 
                std::string req_buff{};
                req_buff.reserve(2048);
                req_buff.append(method.data(), method.size()).append(" ").append(uri.data(), uri.size()).append(" HTTP/1.1\r\n");
                add_field(req_buff, "Host", m_host_buff);
                add_field(req_buff, "Content-Length", std::to_string(body.size()));
 
                //handle "additional_params"
                for(const auto& field : additional_params)
                    add_field(req_buff, field);
 
                for (unsigned sends = 0; sends < 2; ++sends)
                {
                    const std::size_t initial_size = req_buff.size();
                    const auto auth = m_auth.get_auth_field(method, uri);
                    if (auth)
                        add_field(req_buff, *auth);
 
                    req_buff += "\r\n";
                    //--
 
                    bool res = m_net_client.send(req_buff, timeout);
                    CHECK_AND_NO_ASSERT_MES_L(res, false, 1, "HTTP_CLIENT: Failed to SEND");
                    if(body.size())
                        res = m_net_client.send(body, timeout);
                    CHECK_AND_ASSERT_MES(res, false, "HTTP_CLIENT: Failed to SEND");
 
                    m_response_info.clear();
                    m_state = reciev_machine_state_header;
                    if (!handle_reciev(timeout))
                        return false;
                    if (m_response_info.m_response_code != 401)
                    {
                        if(ppresponse_info)
                            *ppresponse_info = std::addressof(m_response_info);
                        return true;
                    }
 
                    switch (m_auth.handle_401(m_response_info))
                    {
                    case http_client_auth::kSuccess:
                        break;
                    case http_client_auth::kBadPassword:
                                                sends = 2;
                        break;
                    default:
                    case http_client_auth::kParseFailure:
                        LOG_ERROR("Bad server response for authentication");
                        return false;
                    }
                    req_buff.resize(initial_size); // rollback for new auth generation
                }
                LOG_ERROR("Client has incorrect username/password for server requiring authentication");
                return false;
            }

Here is the caller graph for this function:

invoke_get()

template<typename net_client_type>

bool epee::net_utils::http::http_simple_client_template< net_client_type >::invoke_get ( const boost::string_ref uri, std::chrono::milliseconds timeout, const std::string & body = std::string(), const http_response_info ** ppresponse_info = NULL, const fields_list & additional_params = fields_list() )

inline

Definition at line 365 of file http_client.h.

            {
                    CRITICAL_REGION_LOCAL(m_lock);
                    return invoke(uri, "GET", body, timeout, ppresponse_info, additional_params);
            }

invoke_post()

template<typename net_client_type>

bool epee::net_utils::http::http_simple_client_template< net_client_type >::invoke_post ( const boost::string_ref uri, const std::string & body, std::chrono::milliseconds timeout, const http_response_info ** ppresponse_info = NULL, const fields_list & additional_params = fields_list() )

inline

Definition at line 445 of file http_client.h.

            {
                CRITICAL_REGION_LOCAL(m_lock);
                return invoke(uri, "POST", body, timeout, ppresponse_info, additional_params);
            }

is_connected()

template<typename net_client_type>

bool epee::net_utils::http::http_simple_client_template< net_client_type >::is_connected ( bool * ssl = NULL )

inline

Definition at line 345 of file http_client.h.

            {
                CRITICAL_REGION_LOCAL(m_lock);
                return m_net_client.is_connected(ssl);
            }

Here is the caller graph for this function:

on_header()

template<typename net_client_type>

virtual bool epee::net_utils::http::http_simple_client_template< net_client_type >::on_header ( const http_response_info & headers )

inlinevirtual

Definition at line 359 of file http_client.h.

      {
        return true;
      }

set_auto_connect()

template<typename net_client_type>

void epee::net_utils::http::http_simple_client_template< net_client_type >::set_auto_connect ( bool auto_connect )

inline

Definition at line 321 of file http_client.h.

            {
                m_auto_connect = auto_connect;
            }

set_connector()

template<typename net_client_type>

template<typename F>

void epee::net_utils::http::http_simple_client_template< net_client_type >::set_connector ( F connector )

inline

Definition at line 327 of file http_client.h.

            {
                CRITICAL_REGION_LOCAL(m_lock);
                m_net_client.set_connector(std::move(connector));
            }

set_server() [1/2]

template<typename net_client_type>

bool epee::net_utils::http::http_simple_client_template< net_client_type >::set_server ( const std::string & address, boost::optional< login > user, ssl_options_t ssl_options = ssl_support_t::e_ssl_support_autodetect )

inline

Definition at line 302 of file http_client.h.

            {
                http::url_content parsed{};
                const bool r = parse_url(address, parsed);
                CHECK_AND_ASSERT_MES(r, false, "failed to parse url: " << address);
                set_server(std::move(parsed.host), std::to_string(parsed.port), std::move(user), std::move(ssl_options));
                return true;
            }

Here is the caller graph for this function:

set_server() [2/2]

template<typename net_client_type>

void epee::net_utils::http::http_simple_client_template< net_client_type >::set_server ( std::string host, std::string port, boost::optional< login > user, ssl_options_t ssl_options = ssl_support_t::e_ssl_support_autodetect )

inline

Definition at line 311 of file http_client.h.

            {
                CRITICAL_REGION_LOCAL(m_lock);
                disconnect();
                m_host_buff = std::move(host);
                m_port = std::move(port);
                                m_auth = user ? http_client_auth{std::move(*user)} : http_client_auth{};
                m_net_client.set_ssl(std::move(ssl_options));
            }

test()

template<typename net_client_type>

bool epee::net_utils::http::http_simple_client_template< net_client_type >::test ( const std::string & s, std::chrono::milliseconds timeout )

inline

Definition at line 451 of file http_client.h.

            {
                CRITICAL_REGION_LOCAL(m_lock);
                m_net_client.set_test_data(s);
                m_state = reciev_machine_state_header;
                return handle_reciev(timeout);
            }

---

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/http_client.h