epee::net_utils Namespace Reference

Namespaces
namespace	http
namespace	jsonrpc2
namespace	munin
namespace	smtp

Classes
class	content_encoding_gzip
class	soket_sender
class	abstract_tcp_server
struct	i_connection_filter
class	connection
	Represents a single connection from a client. More...
class	boosted_tcp_server
class	cp_server_impl
class	buffer
class	connection_basic_shared_state
class	connection_basic
struct	i_sub_handler
struct	i_target_handler
class	do_nothing_sub_handler
struct	direct_connect
class	blocked_mode_client
class	async_blocked_mode_client
struct	ssl_authentication_t
class	ssl_options_t
class	ipv4_network_address
class	network_address
struct	connection_context_base
struct	i_service_endpoint
class	network_throttle
struct	network_throttle_bw
struct	calculate_times_struct
class	network_throttle_manager
class	i_network_throttle
struct	protocl_switcher_config
struct	i_protocol_handler
class	t_protocol_handler
class	protocol_switcher
class	connection_basic_pimpl

Typedefs
typedef std::map< SOCKET, boost::shared_ptr< connection< TProtocol > > >	connections_container
typedef cp_server_impl< http::simple_http_connection_handler >	cp_http_server_file_system
typedef cp_server_impl< http::http_custom_handler >	cp_http_server_custum_handling
typedef boosted_tcp_server< http::simple_http_connection_handler<> >	boosted_http_server_file_system
typedef boosted_tcp_server< http::http_custom_handler<> >	boosted_http_server_custum_handling
typedef abstract_tcp_server< http::simple_http_connection_handler >	mt_http_server_file_system
typedef abstract_tcp_server< http::http_custom_handler >	mt_http_server_custum_handling
typedef levin::levin_client_impl	levin_client
typedef levin::levin_client_impl2	levin_client2
typedef cp_server_impl< levin::protocol_handler >	cp_levin_server
typedef boosted_tcp_server< levin::protocol_handler<> >	boosted_levin_server
typedef boosted_tcp_server< levin::async_protocol_handler<> >	boosted_levin_async_server
typedef boosted_tcp_server< net_utils::protocol_switcher >	boosted_multiprotocol_server
typedef double	network_speed_kbps
typedef double	network_speed_bps
typedef double	network_time_seconds
typedef double	network_MB
typedef calculate_times_struct	calculate_times_struct

Enumerations
enum	t_connection_type { e_connection_type_NET = 0 , e_connection_type_RPC = 1 , e_connection_type_P2P = 2 }
enum class	address_type : std::uint8_t {   invalid = 0 , ipv4 = 1 , ipv6 = 2 , i2p = 3 ,   tor = 4 }
enum class	zone : std::uint8_t { invalid = 0 , public_ = 1 , i2p = 2 , tor = 3 }
enum class	ssl_support_t : uint8_t { e_ssl_support_disabled , e_ssl_support_enabled , e_ssl_support_autodetect }
enum class	ssl_verification_t : uint8_t { none = 0 , system_ca , user_certificates , user_ca }

Functions
PRAGMA_WARNING_POP bool	worker_thread_member ()
bool	add_new_connection (SOCKET new_sock, long ip_from, int port_from)
bool	shutdown_connection (connection< TProtocol > *pconn)
std::string	to_string (t_connection_type type)
const char *	zone_to_string (zone value) noexcept
zone	zone_from_string (boost::string_ref value) noexcept
bool	http_ssl_invoke (const std::string &url, const std::string usr, const std::string psw, std::string &http_response_body, bool use_post=false)
bool	is_ip_local (uint32_t ip)
bool	is_ip_loopback (uint32_t ip)
bool	parse_uri_query (const std::string &query, std::list< std::pair< std::string, std::string > > &params)
bool	parse_uri (const std::string uri, http::uri_content &content)
bool	parse_url (const std::string url_str, http::url_content &content)
constexpr size_t	get_ssl_magic_size ()
bool	is_ssl (const unsigned char *data, size_t len)
bool	ssl_support_from_string (ssl_support_t &ssl, boost::string_ref s)
bool	create_ec_ssl_certificate (EVP_PKEY *&pkey, X509 *&cert)
bool	create_rsa_ssl_certificate (EVP_PKEY *&pkey, X509 *&cert)
bool	operator== (const ipv4_network_address &lhs, const ipv4_network_address &rhs) noexcept
bool	operator!= (const ipv4_network_address &lhs, const ipv4_network_address &rhs) noexcept
bool	operator< (const ipv4_network_address &lhs, const ipv4_network_address &rhs) noexcept
bool	operator<= (const ipv4_network_address &lhs, const ipv4_network_address &rhs) noexcept
bool	operator> (const ipv4_network_address &lhs, const ipv4_network_address &rhs) noexcept
bool	operator>= (const ipv4_network_address &lhs, const ipv4_network_address &rhs) noexcept
bool	operator== (const network_address &lhs, const network_address &rhs)
bool	operator!= (const network_address &lhs, const network_address &rhs)
bool	operator< (const network_address &lhs, const network_address &rhs)
bool	operator<= (const network_address &lhs, const network_address &rhs)
bool	operator> (const network_address &lhs, const network_address &rhs)
bool	operator>= (const network_address &lhs, const network_address &rhs)
std::string	print_connection_context (const connection_context_base &ctx)
std::string	print_connection_context_short (const connection_context_base &ctx)
	MAKE_LOGGABLE (connection_context_base, ct, os)
template<class t_request, class t_response, class t_transport>
bool	invoke_http_json (const boost::string_ref uri, const t_request &out_struct, t_response &result_struct, t_transport &transport, std::chrono::milliseconds timeout=std::chrono::seconds(15), const boost::string_ref method="GET")
template<class t_response, class t_transport>
bool	get_http_json (const boost::string_ref uri, t_response &result_struct, t_transport &transport, std::chrono::milliseconds timeout=std::chrono::seconds(15), const boost::string_ref method="GET")
template<class t_request, class t_response, class t_transport>
bool	invoke_http_bin (const boost::string_ref uri, const t_request &out_struct, t_response &result_struct, t_transport &transport, std::chrono::milliseconds timeout=std::chrono::seconds(15), const boost::string_ref method="GET")
template<class t_request, class t_response, class t_transport>
bool	invoke_http_json_rpc (const boost::string_ref uri, std::string method_name, const t_request &out_struct, t_response &result_struct, t_transport &transport, std::chrono::milliseconds timeout=std::chrono::seconds(15), const boost::string_ref http_method="GET", const std::string &req_id="0")
template<class t_command, class t_transport>
bool	invoke_http_json_rpc (const boost::string_ref uri, typename t_command::request &out_struct, typename t_command::response &result_struct, t_transport &transport, std::chrono::milliseconds timeout=std::chrono::seconds(15), const boost::string_ref http_method="GET", const std::string &req_id="0")
template<class t_arg, class t_result, class t_transport>
bool	invoke_remote_command2 (int command, const t_arg &out_struct, t_result &result_struct, t_transport &transport)
template<class t_arg, class t_transport>
bool	notify_remote_command2 (int command, const t_arg &out_struct, t_transport &transport)
template<class t_arg, class t_result, class t_transport>
bool	invoke_remote_command2 (boost::uuids::uuid conn_id, int command, const t_arg &out_struct, t_result &result_struct, t_transport &transport)
template<class t_result, class t_arg, class callback_t, class t_transport>
bool	async_invoke_remote_command2 (boost::uuids::uuid conn_id, int command, const t_arg &out_struct, t_transport &transport, const callback_t &cb, size_t inv_timeout=LEVIN_DEFAULT_TIMEOUT_PRECONFIGURED)
template<class t_arg, class t_transport>
bool	notify_remote_command2 (boost::uuids::uuid conn_id, int command, const t_arg &out_struct, t_transport &transport)
template<class t_owner, class t_in_type, class t_out_type, class t_context, class callback_t>
int	buff_to_t_adapter (int command, const epee::span< const uint8_t > in_buff, std::string &buff_out, callback_t cb, t_context &context)
template<class t_owner, class t_in_type, class t_context, class callback_t>
int	buff_to_t_adapter (t_owner *powner, int command, const epee::span< const uint8_t > in_buff, callback_t cb, t_context &context)
bool	create_ec_ssl_certificate (EVP_PKEY *&pkey, X509 *&cert, int type)

Variables
SOCKET	m_listen_socket
HANDLE	m_completion_port
connections_container	m_connections
critical_section	m_connections_lock
int	m_port
volatile LONG	m_stop
bool	m_initialized
volatile LONG	m_worker_thread_counter
TProtocol::config_type	m_config

Typedef Documentation

boosted_http_server_custum_handling

typedef boosted_tcp_server<http::http_custom_handler<> > epee::net_utils::boosted_http_server_custum_handling

Definition at line 44 of file http_server_cp2.h.

boosted_http_server_file_system

typedef boosted_tcp_server<http::simple_http_connection_handler<> > epee::net_utils::boosted_http_server_file_system

Definition at line 43 of file http_server_cp2.h.

boosted_levin_async_server

typedef boosted_tcp_server<levin::async_protocol_handler<> > epee::net_utils::boosted_levin_async_server

Definition at line 41 of file levin_server_cp2.h.

boosted_levin_server

typedef boosted_tcp_server<levin::protocol_handler<> > epee::net_utils::boosted_levin_server

Definition at line 40 of file levin_server_cp2.h.

boosted_multiprotocol_server

typedef boosted_tcp_server<net_utils::protocol_switcher> epee::net_utils::boosted_multiprotocol_server

Definition at line 41 of file multiprotocols_server.h.

calculate_times_struct

typedef calculate_times_struct epee::net_utils::calculate_times_struct

Definition at line 100 of file network_throttle.hpp.

connections_container

typedef std::map<SOCKET, boost::shared_ptr<connection<TProtocol> > > epee::net_utils::connections_container

Definition at line 219 of file abstract_tcp_server_cp.h.

cp_http_server_custum_handling

typedef cp_server_impl<http::http_custom_handler> epee::net_utils::cp_http_server_custum_handling

Definition at line 44 of file http_server_cp.h.

cp_http_server_file_system

typedef cp_server_impl<http::simple_http_connection_handler> epee::net_utils::cp_http_server_file_system

Definition at line 43 of file http_server_cp.h.

cp_levin_server

typedef cp_server_impl<levin::protocol_handler> epee::net_utils::cp_levin_server

Definition at line 39 of file levin_server_cp.h.

levin_client

typedef levin::levin_client_impl epee::net_utils::levin_client

Definition at line 82 of file levin_client.h.

levin_client2

typedef levin::levin_client_impl2 epee::net_utils::levin_client2

Definition at line 83 of file levin_client.h.

mt_http_server_custum_handling

typedef abstract_tcp_server<http::http_custom_handler> epee::net_utils::mt_http_server_custum_handling

Definition at line 40 of file http_server_thread_per_connect.h.

mt_http_server_file_system

typedef abstract_tcp_server<http::simple_http_connection_handler> epee::net_utils::mt_http_server_file_system

Definition at line 39 of file http_server_thread_per_connect.h.

network_MB

typedef double epee::net_utils::network_MB

Definition at line 87 of file network_throttle.hpp.

network_speed_bps

typedef double epee::net_utils::network_speed_bps

Definition at line 85 of file network_throttle.hpp.

network_speed_kbps

typedef double epee::net_utils::network_speed_kbps

Definition at line 84 of file network_throttle.hpp.

network_time_seconds

typedef double epee::net_utils::network_time_seconds

Definition at line 86 of file network_throttle.hpp.

Enumeration Type Documentation

address_type

enum class epee::net_utils::address_type : std::uint8_t

strong

Enumerator
invalid
ipv4
ipv6
i2p
tor

Definition at line 38 of file enums.h.

    {
        // Do not change values, this will break serialization
        invalid = 0,
        ipv4 = 1,
        ipv6 = 2,
        i2p = 3,
        tor = 4
    };

ssl_support_t

enum class epee::net_utils::ssl_support_t : uint8_t

strong

Enumerator
e_ssl_support_disabled
e_ssl_support_enabled
e_ssl_support_autodetect

Definition at line 46 of file net_ssl.h.

                            : uint8_t {
        e_ssl_support_disabled,
        e_ssl_support_enabled,
        e_ssl_support_autodetect,
    };

ssl_verification_t

enum class epee::net_utils::ssl_verification_t : uint8_t

strong

Enumerator
none	Do not verify peer.
system_ca	Verify peer via system ca only (do not inspect user certificates).
user_certificates	Verify peer via specific (non-chain) certificate(s) only.
user_ca	Verify peer via specific (possibly chain) certificate(s) only.

Definition at line 52 of file net_ssl.h.

  {
    none = 0,         
    system_ca,        
    user_certificates,
    user_ca           
  };

t_connection_type

enum epee::net_utils::t_connection_type

Enumerator
e_connection_type_NET
e_connection_type_RPC
e_connection_type_P2P

Definition at line 93 of file connection_basic.hpp.

                         { // type of the connection (of this server), e.g. so that we will know how to limit it
      e_connection_type_NET = 0, // default (not used?)
      e_connection_type_RPC = 1, // the rpc commands  (probably not rate limited, not chunked, etc)
      e_connection_type_P2P = 2  // to other p2p node (probably limited)
  };

zone

enum class epee::net_utils::zone : std::uint8_t

strong

Enumerator
invalid
public_
i2p
tor

Definition at line 48 of file enums.h.

    {
        invalid = 0,
        public_ = 1, // public is keyword
        i2p = 2,
        tor = 3
    };

Function Documentation

add_new_connection()

bool epee::net_utils::add_new_connection	(	SOCKET	new_sock,
		long	ip_from,
		int	port_from )

async_invoke_remote_command2()

template<class t_result, class t_arg, class callback_t, class t_transport>

bool epee::net_utils::async_invoke_remote_command2	(	boost::uuids::uuid	conn_id,
		int	command,
		const t_arg &	out_struct,
		t_transport &	transport,
		const callback_t &	cb,
		size_t	inv_timeout = LEVIN_DEFAULT_TIMEOUT_PRECONFIGURED )

Definition at line 113 of file levin_abstract_invoke2.h.

    {
      typename serialization::portable_storage stg;
      const_cast<t_arg&>(out_struct).store(stg);//TODO: add true const support to searilzation
      std::string buff_to_send;
      stg.store_to_binary(buff_to_send);
      int res = transport.invoke_async(command, epee::strspan<uint8_t>(buff_to_send), conn_id, [cb, command](int code, const epee::span<const uint8_t> buff, typename t_transport::connection_context& context)->bool 
      {
        t_result result_struct = AUTO_VAL_INIT(result_struct);
        if( code <=0 )
        {
          LOG_PRINT_L1("Failed to invoke command " << command << " return code " << code);
          cb(code, result_struct, context);
          return false;
        }
        serialization::portable_storage stg_ret;
        if(!stg_ret.load_from_binary(buff))
        {
          LOG_ERROR("Failed to load_from_binary on command " << command);
          cb(LEVIN_ERROR_FORMAT, result_struct, context);
          return false;
        }
        if (!result_struct.load(stg_ret))
        {
          LOG_ERROR("Failed to load result struct on command " << command);
          cb(LEVIN_ERROR_FORMAT, result_struct, context);
          return false;
        }
        cb(code, result_struct, context);
        return true;
      }, inv_timeout);
      if( res <=0 )
      {
        LOG_PRINT_L1("Failed to invoke command " << command << " return code " << res);
        return false;
      }
      return true;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

buff_to_t_adapter() [1/2]

template<class t_owner, class t_in_type, class t_out_type, class t_context, class callback_t>

int epee::net_utils::buff_to_t_adapter	(	int	command,
		const epee::span< const uint8_t >	in_buff,
		std::string &	buff_out,
		callback_t	cb,
		t_context &	context )

Definition at line 172 of file levin_abstract_invoke2.h.

    {
      serialization::portable_storage strg;
      if(!strg.load_from_binary(in_buff))
      {
        LOG_ERROR("Failed to load_from_binary in command " << command);
        return -1;
      }
      boost::value_initialized<t_in_type> in_struct;
      boost::value_initialized<t_out_type> out_struct;
 
      if (!static_cast<t_in_type&>(in_struct).load(strg))
      {
        LOG_ERROR("Failed to load in_struct in command " << command);
        return -1;
      }
      int res = cb(command, static_cast<t_in_type&>(in_struct), static_cast<t_out_type&>(out_struct), context);
      serialization::portable_storage strg_out;
      static_cast<t_out_type&>(out_struct).store(strg_out);
 
      if(!strg_out.store_to_binary(buff_out))
      {
        LOG_ERROR("Failed to store_to_binary in command" << command);
        return -1;
      }
 
      return res;
    }

Here is the call graph for this function:

buff_to_t_adapter() [2/2]

template<class t_owner, class t_in_type, class t_context, class callback_t>

int epee::net_utils::buff_to_t_adapter	(	t_owner *	powner,
		int	command,
		const epee::span< const uint8_t >	in_buff,
		callback_t	cb,
		t_context &	context )

Definition at line 202 of file levin_abstract_invoke2.h.

    {
      serialization::portable_storage strg;
      if(!strg.load_from_binary(in_buff))
      {
        LOG_ERROR("Failed to load_from_binary in notify " << command);
        return -1;
      }
      boost::value_initialized<t_in_type> in_struct;
      if (!static_cast<t_in_type&>(in_struct).load(strg))
      {
        LOG_ERROR("Failed to load in_struct in notify " << command);
        return -1;
      }
      return cb(command, in_struct, context);
    }

Here is the call graph for this function:

create_ec_ssl_certificate() [1/2]

bool epee::net_utils::create_ec_ssl_certificate	(	EVP_PKEY *&	pkey,
		X509 *&	cert )

Here is the caller graph for this function:

create_ec_ssl_certificate() [2/2]

bool epee::net_utils::create_ec_ssl_certificate	(	EVP_PKEY *&	pkey,
		X509 *&	cert,
		int	type )

Definition at line 192 of file net_ssl.cpp.

{
  MGINFO("Generating SSL certificate");
  pkey = EVP_PKEY_new();
  if (!pkey)
  {
    MERROR("Failed to create new private key");
    return false;
  }
 
  openssl_pkey pkey_deleter{pkey};
  openssl_ec_key ec_key{EC_KEY_new()};
  if (!ec_key)
  {
    MERROR("Error allocating EC private key");
    return false;
  }
 
  EC_GROUP *group = EC_GROUP_new_by_curve_name(type);
  if (!group)
  {
    MERROR("Error getting EC group " << type);
    return false;
  }
  openssl_group group_deleter{group};
 
  EC_GROUP_set_asn1_flag(group, OPENSSL_EC_NAMED_CURVE); 
  EC_GROUP_set_point_conversion_form(group, POINT_CONVERSION_UNCOMPRESSED);
 
  if (!EC_GROUP_check(group, NULL))
  {
    MERROR("Group failed check: " << ERR_reason_error_string(ERR_get_error()));
    return false;
  }
  if (EC_KEY_set_group(ec_key.get(), group) != 1)
  {
    MERROR("Error setting EC group");
    return false;
  }
  if (EC_KEY_generate_key(ec_key.get()) != 1)
  {
    MERROR("Error generating EC private key");
    return false;
  }
  if (EVP_PKEY_assign_EC_KEY(pkey, ec_key.get()) <= 0)
  {
    MERROR("Error assigning EC private key");
    return false;
  }
 
  // the key is now managed by the EVP_PKEY structure
  (void)ec_key.release();
 
  cert = X509_new();
  if (!cert)
  {
    MERROR("Failed to create new X509 certificate");
    return false;
  }
  ASN1_INTEGER_set(X509_get_serialNumber(cert), 1);
  X509_gmtime_adj(X509_get_notBefore(cert), 0);
  X509_gmtime_adj(X509_get_notAfter(cert), 3600 * 24 * 182); // half a year
  if (!X509_set_pubkey(cert, pkey))
  {
    MERROR("Error setting pubkey on certificate");
    X509_free(cert);
    return false;
  }
  X509_NAME *name = X509_get_subject_name(cert);
  X509_set_issuer_name(cert, name);
 
  if (X509_sign(cert, pkey, EVP_sha256()) == 0)
  {
    MERROR("Error signing certificate");
    X509_free(cert);
    return false;
  }
  (void)pkey_deleter.release();
  return true;
}

create_rsa_ssl_certificate()

bool epee::net_utils::create_rsa_ssl_certificate	(	EVP_PKEY *&	pkey,
		X509 *&	cert )

Definition at line 122 of file net_ssl.cpp.

{
  MGINFO("Generating SSL certificate");
  pkey = EVP_PKEY_new();
  if (!pkey)
  {
    MERROR("Failed to create new private key");
    return false;
  }
 
  openssl_pkey pkey_deleter{pkey};
  openssl_rsa rsa{RSA_new()};
  if (!rsa)
  {
    MERROR("Error allocating RSA private key");
    return false;
  }
 
  openssl_bignum exponent{BN_new()};
  if (!exponent)
  {
    MERROR("Error allocating exponent");
    return false;
  }
 
  BN_set_word(exponent.get(), RSA_F4);
 
  if (RSA_generate_key_ex(rsa.get(), 4096, exponent.get(), nullptr) != 1)
  {
    MERROR("Error generating RSA private key");
    return false;
  }
 
  if (EVP_PKEY_assign_RSA(pkey, rsa.get()) <= 0)
  {
    MERROR("Error assigning RSA private key");
    return false;
  }
 
  // the RSA key is now managed by the EVP_PKEY structure
  (void)rsa.release();
 
  cert = X509_new();
  if (!cert)
  {
    MERROR("Failed to create new X509 certificate");
    return false;
  }
  ASN1_INTEGER_set(X509_get_serialNumber(cert), 1);
  X509_gmtime_adj(X509_get_notBefore(cert), 0);
  X509_gmtime_adj(X509_get_notAfter(cert), 3600 * 24 * 182); // half a year
  if (!X509_set_pubkey(cert, pkey))
  {
    MERROR("Error setting pubkey on certificate");
    X509_free(cert);
    return false;
  }
  X509_NAME *name = X509_get_subject_name(cert);
  X509_set_issuer_name(cert, name);
 
  if (X509_sign(cert, pkey, EVP_sha256()) == 0)
  {
    MERROR("Error signing certificate");
    X509_free(cert);
    return false;
  }
  (void)pkey_deleter.release();
  return true;
}

Here is the caller graph for this function:

get_http_json()

template<class t_response, class t_transport>

bool epee::net_utils::get_http_json	(	const boost::string_ref	uri,
		t_response &	result_struct,
		t_transport &	transport,
		std::chrono::milliseconds	timeout = std::chrono::seconds(15),
		const boost::string_ref	method = "GET" )

Definition at line 73 of file http_abstract_invoke.h.

                                                                                                                                                                                             {
 
      const http::http_response_info* pri = NULL;
      int retryCount = 0;
      const int MAX_RETRY_COUNT = 10;
 
      //Boost asio read can be temperemental
      while(!transport.invoke(uri, method, "", timeout, std::addressof(pri)) && retryCount < MAX_RETRY_COUNT) {
        misc_utils::sleep_no_w(200);
        ++retryCount;
        LOG_PRINT_L1("Failed to invoke http request. Retrying (" << retryCount << "/" << MAX_RETRY_COUNT << ").");
      }
 
      if(retryCount == MAX_RETRY_COUNT) //Max retries reached
      {
        LOG_PRINT_L1("Failed to invoke http request to  " << uri);
        return false;
      }
 
      if(!pri)
      {
        LOG_PRINT_L1("Failed to invoke http request to  " << uri << ", internal error (null response ptr)");
        return false;
      }
 
      if(pri->m_response_code != 200)
      {
        LOG_PRINT_L1("Failed to invoke http request to  " << uri << ", wrong response code: " << pri->m_response_code);
        return false;
      }
 
      return serialization::load_t_from_json(result_struct, pri->m_body);
    }

Here is the call graph for this function:

get_ssl_magic_size()

size_t epee::net_utils::get_ssl_magic_size ( )

constexpr

Definition at line 135 of file net_ssl.h.

{ return 9; }

Here is the caller graph for this function:

http_ssl_invoke()

bool epee::net_utils::http_ssl_invoke ( const std::string & url, const std::string usr, const std::string psw, std::string & http_response_body, bool use_post = false )

inline

Definition at line 43 of file http_client_via_api_helper.h.

    {
        bool final_res = false;
 
        ATL::CUrl url_obj;
        BOOL crack_rss = url_obj.CrackUrl(string_encoding::convert_to_t<std::basic_string<TCHAR> >(url).c_str());
 
        HINTERNET hinet = ::InternetOpenA(SHARED_JOBSCOMMON_HTTP_AGENT, INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);
        if(!hinet)
        {
            int err = ::GetLastError();
            LOG_PRINT("Failed to call InternetOpenA, \nError: " << err << " " << log_space::get_win32_err_descr(err), LOG_LEVEL_0);
            return false;
        }
 
        DWORD dwFlags = 0;
        DWORD dwBuffLen = sizeof(dwFlags);
 
        if(usr.size())
        {
            dwFlags |=  INTERNET_FLAG_IGNORE_CERT_CN_INVALID|INTERNET_FLAG_IGNORE_CERT_DATE_INVALID|
                INTERNET_FLAG_PRAGMA_NOCACHE | SECURITY_FLAG_IGNORE_UNKNOWN_CA|INTERNET_FLAG_SECURE; 
        }else
        {
            dwFlags |=  INTERNET_FLAG_PRAGMA_NOCACHE; 
        }
 
 
        int port = url_obj.GetPortNumber();
        BOOL res = FALSE;
 
        HINTERNET hsession = ::InternetConnectA(hinet, string_encoding::convert_to_ansii(url_obj.GetHostName()).c_str(), port/*INTERNET_DEFAULT_HTTPS_PORT*/, usr.c_str(), psw.c_str(), INTERNET_SERVICE_HTTP, dwFlags, NULL);
        if(hsession)
        {
            const std::string uri = string_encoding::convert_to_ansii(url_obj.GetUrlPath()) + string_encoding::convert_to_ansii(url_obj.GetExtraInfo());
 
            HINTERNET hrequest = ::HttpOpenRequestA(hsession, use_post?"POST":NULL, uri.c_str(), NULL, NULL,NULL, dwFlags, NULL);
            if(hrequest)
            {
                while(true)
                {
                    res = ::HttpSendRequestA(hrequest, NULL, 0, NULL, 0);
                    if(!res)
                    {
                        //ERROR_INTERNET_INVALID_CA 45
                        //ERROR_INTERNET_INVALID_URL              (INTERNET_ERROR_BASE + 5)
                        int err = ::GetLastError();
                        LOG_PRINT("Failed to call HttpSendRequestA, \nError: " << log_space::get_win32_err_descr(err), LOG_LEVEL_0);
                        break;
                    }
 
                    DWORD code = 0;
                    DWORD buf_len = sizeof(code);
                    DWORD index = 0;
                    res = ::HttpQueryInfo(hrequest,  HTTP_QUERY_FLAG_NUMBER|HTTP_QUERY_STATUS_CODE, &code, &buf_len, &index);
                    if(!res)
                    {
                        //ERROR_INTERNET_INVALID_CA 45
                        //ERROR_INTERNET_INVALID_URL              (INTERNET_ERROR_BASE + 5)
                        int err = ::GetLastError();
                        LOG_PRINT("Failed to call HttpQueryInfo, \nError: " << log_space::get_win32_err_descr(err), LOG_LEVEL_0);
                        break;
                    }
                    if(code < 200 || code > 299)
                    {
                        LOG_PRINT("Wrong server response, HttpQueryInfo returned statuse code" << code , LOG_LEVEL_0);
                        break;
                    }
 
 
                    char buff[100000] = {0};
                    DWORD readed = 0;
                    while(true)
                    {
                        res = ::InternetReadFile(hrequest, buff, sizeof(buff), &readed);
                        if(!res)
                        {
                            int err = ::GetLastError();
                            LOG_PRINT("Failed to call InternetReadFile, \nError: " << log_space::get_win32_err_descr(err), LOG_LEVEL_0);
                            break;
                        }
                        if(readed)
                        {
                            http_response_body.append(buff, readed);
                        }
                        else
                            break;
                    }
 
                    if(!res)
                        break;
 
 
                    //we success
                    final_res = true;
 
                    res = ::InternetCloseHandle(hrequest);
                    if(!res)
                    {
                        int err = ::GetLastError();
                        LOG_PRINT("Failed to call InternetCloseHandle, \nError: " << log_space::get_win32_err_descr(err), LOG_LEVEL_0);
                    }
 
                    break;
                }
            }
            else
            {
                //ERROR_INTERNET_INVALID_CA
                int err = ::GetLastError();
                LOG_PRINT("Failed to call InternetOpenUrlA, \nError: " << log_space::get_win32_err_descr(err), LOG_LEVEL_0);
                return false;
            }
 
            res = ::InternetCloseHandle(hsession);
            if(!res)
            {
                int err = ::GetLastError();
                LOG_PRINT("Failed to call InternetCloseHandle, \nError: " << log_space::get_win32_err_descr(err), LOG_LEVEL_0);
            }
        }else
        {
            int err = ::GetLastError();
            LOG_PRINT("Failed to call InternetConnectA(" << string_encoding::convert_to_ansii(url_obj.GetHostName()) << ", port " << port << " \nError: " << log_space::get_win32_err_descr(err), LOG_LEVEL_0);
        }
 
 
 
        res = ::InternetCloseHandle(hinet);
        if(!res)
        {
            int err = ::GetLastError();
            LOG_PRINT("Failed to call InternetCloseHandle, \nError: " << log_space::get_win32_err_descr(err), LOG_LEVEL_0);
        }
        return final_res;
    }

Here is the call graph for this function:

invoke_http_bin()

template<class t_request, class t_response, class t_transport>

bool epee::net_utils::invoke_http_bin	(	const boost::string_ref	uri,
		const t_request &	out_struct,
		t_response &	result_struct,
		t_transport &	transport,
		std::chrono::milliseconds	timeout = std::chrono::seconds(15),
		const boost::string_ref	method = "GET" )

Definition at line 109 of file http_abstract_invoke.h.

    {
      std::string req_param;
      if(!serialization::store_t_to_binary(out_struct, req_param))
        return false;
 
      const http::http_response_info* pri = NULL;
      if(!transport.invoke(uri, method, req_param, timeout, std::addressof(pri)))
      {
        LOG_PRINT_L1("Failed to invoke http request to  " << uri);
        return false;
      }
 
      if(!pri)
      {
        LOG_PRINT_L1("Failed to invoke http request to  " << uri << ", internal error (null response ptr)");
        return false;
      }
 
      if(pri->m_response_code != 200)
      {
        LOG_PRINT_L1("Failed to invoke http request to  " << uri << ", wrong response code: " << pri->m_response_code);
        return false;
      }
 
      return serialization::load_t_from_binary(result_struct, epee::strspan<uint8_t>(pri->m_body));
    }

Here is the call graph for this function:

Here is the caller graph for this function:

invoke_http_json()

template<class t_request, class t_response, class t_transport>

bool epee::net_utils::invoke_http_json	(	const boost::string_ref	uri,
		const t_request &	out_struct,
		t_response &	result_struct,
		t_transport &	transport,
		std::chrono::milliseconds	timeout = std::chrono::seconds(15),
		const boost::string_ref	method = "GET" )

Definition at line 41 of file http_abstract_invoke.h.

    {
      std::string req_param;
      if(!serialization::store_t_to_json(out_struct, req_param))
        return false;
 
      http::fields_list additional_params;
      additional_params.push_back(std::make_pair("Content-Type","application/json; charset=utf-8"));
 
      const http::http_response_info* pri = NULL;
      if(!transport.invoke(uri, method, req_param, timeout, std::addressof(pri), std::move(additional_params)))
      {
        LOG_PRINT_L1("Failed to invoke http request to  " << uri);
        return false;
      }
 
      if(!pri)
      {
        LOG_PRINT_L1("Failed to invoke http request to  " << uri << ", internal error (null response ptr)");
        return false;
      }
 
      if(pri->m_response_code != 200)
      {
        LOG_PRINT_L1("Failed to invoke http request to  " << uri << ", wrong response code: " << pri->m_response_code);
        return false;
      }
 
      return serialization::load_t_from_json(result_struct, pri->m_body);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

invoke_http_json_rpc() [1/2]

template<class t_request, class t_response, class t_transport>

bool epee::net_utils::invoke_http_json_rpc	(	const boost::string_ref	uri,
		std::string	method_name,
		const t_request &	out_struct,
		t_response &	result_struct,
		t_transport &	transport,
		std::chrono::milliseconds	timeout = std::chrono::seconds(15),
		const boost::string_ref	http_method = "GET",
		const std::string &	req_id = "0" )

Definition at line 138 of file http_abstract_invoke.h.

    {
      epee::json_rpc::request<t_request> req_t = AUTO_VAL_INIT(req_t);
      req_t.jsonrpc = "2.0";
      req_t.id = req_id;
      req_t.method = std::move(method_name);
      req_t.params = out_struct;
      epee::json_rpc::response<t_response, epee::json_rpc::error> resp_t = AUTO_VAL_INIT(resp_t);
      if(!epee::net_utils::invoke_http_json(uri, req_t, resp_t, transport, timeout, http_method))
      {
        return false;
      }
      if(resp_t.error.code || resp_t.error.message.size())
      {
        LOG_ERROR("RPC call of \"" << req_t.method << "\" returned error: " << resp_t.error.code << ", message: " << resp_t.error.message);
        return false;
      }
      result_struct = resp_t.result;
      return true;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

invoke_http_json_rpc() [2/2]

template<class t_command, class t_transport>

bool epee::net_utils::invoke_http_json_rpc	(	const boost::string_ref	uri,
		typename t_command::request &	out_struct,
		typename t_command::response &	result_struct,
		t_transport &	transport,
		std::chrono::milliseconds	timeout = std::chrono::seconds(15),
		const boost::string_ref	http_method = "GET",
		const std::string &	req_id = "0" )

Definition at line 160 of file http_abstract_invoke.h.

    {
      return invoke_http_json_rpc(uri, t_command::methodname(), out_struct, result_struct, transport, timeout, http_method, req_id);
    }

Here is the call graph for this function:

invoke_remote_command2() [1/2]

template<class t_arg, class t_result, class t_transport>

bool epee::net_utils::invoke_remote_command2	(	boost::uuids::uuid	conn_id,
		int	command,
		const t_arg &	out_struct,
		t_result &	result_struct,
		t_transport &	transport )

Definition at line 89 of file levin_abstract_invoke2.h.

    {
 
      typename serialization::portable_storage stg;
      out_struct.store(stg);
      std::string buff_to_send, buff_to_recv;
      stg.store_to_binary(buff_to_send);
 
      int res = transport.invoke(command, buff_to_send, buff_to_recv, conn_id);
      if( res <=0 )
      {
        LOG_PRINT_L1("Failed to invoke command " << command << " return code " << res);
        return false;
      }
      typename serialization::portable_storage stg_ret;
      if(!stg_ret.load_from_binary(buff_to_recv))
      {
        LOG_ERROR("Failed to load_from_binary on command " << command);
        return false;
      }
      return result_struct.load(stg_ret);
    }

Here is the call graph for this function:

invoke_remote_command2() [2/2]

template<class t_arg, class t_result, class t_transport>

bool epee::net_utils::invoke_remote_command2	(	int	command,
		const t_arg &	out_struct,
		t_result &	result_struct,
		t_transport &	transport )

Definition at line 43 of file levin_abstract_invoke2.h.

    {
      if(!transport.is_connected())
        return false;
 
      serialization::portable_storage stg;
      out_struct.store(stg);
      std::string buff_to_send, buff_to_recv;
      stg.store_to_binary(buff_to_send);
 
      int res = transport.invoke(command, buff_to_send, buff_to_recv);
      if( res <=0 )
      {
        MERROR("Failed to invoke command " << command << " return code " << res);
        return false;
      }
      serialization::portable_storage stg_ret;
      if(!stg_ret.load_from_binary(buff_to_recv))
      {
        LOG_ERROR("Failed to load_from_binary on command " << command);
        return false;
      }
      return result_struct.load(stg_ret);
    }

Here is the call graph for this function:

is_ip_local()

bool epee::net_utils::is_ip_local ( uint32_t ip )

inline

Definition at line 35 of file local_ip.h.

    {
      /*
      local ip area
      10.0.0.0 — 10.255.255.255 
      172.16.0.0 — 172.31.255.255 
      192.168.0.0 — 192.168.255.255 
      */
      if( (ip | 0xffffff00) == 0xffffff0a)
        return true;
 
      if( (ip | 0xffff0000) == 0xffffa8c0)
        return true;
 
      if( (ip | 0xffffff00) == 0xffffffac)
      {
        uint32_t second_num = (ip >> 8) & 0xff;
        if(second_num >= 16 && second_num <= 31 )
          return true;
      }
      return false;
    }

Here is the caller graph for this function:

is_ip_loopback()

bool epee::net_utils::is_ip_loopback ( uint32_t ip )

inline

Definition at line 58 of file local_ip.h.

    {
      if( (ip | 0xffffff00) == 0xffffff7f)
        return true;
      //MAKE_IP
      /*
      loopback ip
      127.0.0.0 — 127.255.255.255 
      */
      return false;
    }

Here is the caller graph for this function:

is_ssl()

bool epee::net_utils::is_ssl	(	const unsigned char *	data,
		size_t	len )

Definition at line 382 of file net_ssl.cpp.

{
  if (len < get_ssl_magic_size())
    return false;
 
  // https://security.stackexchange.com/questions/34780/checking-client-hello-for-https-classification
  MDEBUG("SSL detection buffer, " << len << " bytes: "
    << (unsigned)(unsigned char)data[0] << " " << (unsigned)(unsigned char)data[1] << " "
    << (unsigned)(unsigned char)data[2] << " " << (unsigned)(unsigned char)data[3] << " "
    << (unsigned)(unsigned char)data[4] << " " << (unsigned)(unsigned char)data[5] << " "
    << (unsigned)(unsigned char)data[6] << " " << (unsigned)(unsigned char)data[7] << " "
    << (unsigned)(unsigned char)data[8]);
  if (data[0] == 0x16) // record
  if (data[1] == 3) // major version
  if (data[5] == 1) // ClientHello
  if (data[6] == 0 && data[3]*256 + data[4] == data[7]*256 + data[8] + 4) // length check
    return true;
  return false;
}

Here is the call graph for this function:

MAKE_LOGGABLE()

epee::net_utils::MAKE_LOGGABLE ( connection_context_base , ct , os  )

inline

Definition at line 344 of file net_utils_base.h.

{
  os << "[" << epee::net_utils::print_connection_context_short(ct) << "] ";
  return os;
}

Here is the call graph for this function:

notify_remote_command2() [1/2]

template<class t_arg, class t_transport>

bool epee::net_utils::notify_remote_command2	(	boost::uuids::uuid	conn_id,
		int	command,
		const t_arg &	out_struct,
		t_transport &	transport )

Definition at line 153 of file levin_abstract_invoke2.h.

    {
 
      serialization::portable_storage stg;
      out_struct.store(stg);
      std::string buff_to_send;
      stg.store_to_binary(buff_to_send);
 
      int res = transport.notify(command, epee::strspan<uint8_t>(buff_to_send), conn_id);
      if(res <=0 )
      {
        MERROR("Failed to notify command " << command << " return code " << res);
        return false;
      }
      return true;
    }

Here is the call graph for this function:

notify_remote_command2() [2/2]

template<class t_arg, class t_transport>

bool epee::net_utils::notify_remote_command2	(	int	command,
		const t_arg &	out_struct,
		t_transport &	transport )

Definition at line 69 of file levin_abstract_invoke2.h.

    {
      if(!transport.is_connected())
        return false;
 
      serialization::portable_storage stg;
      out_struct.store(&stg);
      std::string buff_to_send;
      stg.store_to_binary(buff_to_send);
 
      int res = transport.notify(command, buff_to_send);
      if(res <=0 )
      {
        LOG_ERROR("Failed to notify command " << command << " return code " << res);
        return false;
      }
      return true;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

operator!=() [1/2]

bool epee::net_utils::operator!= ( const ipv4_network_address & lhs, const ipv4_network_address & rhs )

inlinenoexcept

Definition at line 99 of file net_utils_base.h.

    { return !lhs.equal(rhs); }

operator!=() [2/2]

bool epee::net_utils::operator!= ( const network_address & lhs, const network_address & rhs )

inline

Definition at line 233 of file net_utils_base.h.

    { return !lhs.equal(rhs); }

Here is the call graph for this function:

operator<() [1/2]

bool epee::net_utils::operator< ( const ipv4_network_address & lhs, const ipv4_network_address & rhs )

inlinenoexcept

Definition at line 101 of file net_utils_base.h.

    { return lhs.less(rhs); }

operator<() [2/2]

bool epee::net_utils::operator< ( const network_address & lhs, const network_address & rhs )

inline

Definition at line 235 of file net_utils_base.h.

    { return lhs.less(rhs); }

Here is the call graph for this function:

operator<=() [1/2]

bool epee::net_utils::operator<= ( const ipv4_network_address & lhs, const ipv4_network_address & rhs )

inlinenoexcept

Definition at line 103 of file net_utils_base.h.

    { return !rhs.less(lhs); }

operator<=() [2/2]

bool epee::net_utils::operator<= ( const network_address & lhs, const network_address & rhs )

inline

Definition at line 237 of file net_utils_base.h.

    { return !rhs.less(lhs); }

Here is the call graph for this function:

operator==() [1/2]

bool epee::net_utils::operator== ( const ipv4_network_address & lhs, const ipv4_network_address & rhs )

inlinenoexcept

Definition at line 97 of file net_utils_base.h.

    { return lhs.equal(rhs); }

operator==() [2/2]

bool epee::net_utils::operator== ( const network_address & lhs, const network_address & rhs )

inline

Definition at line 231 of file net_utils_base.h.

    { return lhs.equal(rhs); }

Here is the call graph for this function:

operator>() [1/2]

bool epee::net_utils::operator> ( const ipv4_network_address & lhs, const ipv4_network_address & rhs )

inlinenoexcept

Definition at line 105 of file net_utils_base.h.

    { return rhs.less(lhs); }

operator>() [2/2]

bool epee::net_utils::operator> ( const network_address & lhs, const network_address & rhs )

inline

Definition at line 239 of file net_utils_base.h.

    { return rhs.less(lhs); }

Here is the call graph for this function:

operator>=() [1/2]

bool epee::net_utils::operator>= ( const ipv4_network_address & lhs, const ipv4_network_address & rhs )

inlinenoexcept

Definition at line 107 of file net_utils_base.h.

    { return !lhs.less(rhs); }

operator>=() [2/2]

bool epee::net_utils::operator>= ( const network_address & lhs, const network_address & rhs )

inline

Definition at line 241 of file net_utils_base.h.

    { return !lhs.less(rhs); }

Here is the call graph for this function:

parse_uri()

bool epee::net_utils::parse_uri ( const std::string uri, http::uri_content & content )

inline

iframe_test.html?api_url=http://api.vk.com/api.php&api_id=3289090&api_settings=1&viewer_id=562964060&viewer_type=0&sid=0aad8d1c5713130f9ca0076f2b7b47e532877424961367d81e7fa92455f069be7e21bc3193cbd0be11895&secret=368ebbc0ef&access_token=668bc03f43981d883f73876ffff4aa8564254b359cc745dfa1b3cde7bdab2e94105d8f6d8250717569c0a7&user_id=0&group_id=0&is_app_user=1&auth_key=d2f7a895ca5ff3fdb2a2a8ae23fe679a&language=0&parent_language=0&ad_info=ElsdCQBaQlxiAQRdFUVUXiN2AVBzBx5pU1BXIgZUJlIEAWcgAUoLQg==&referrer=unknown&lc_name=9834b6a3&hash=

Definition at line 98 of file net_parse_helpers.h.

  {

    content.m_query_params.clear();
    STATIC_REGEXP_EXPR_1(rexp_match_uri, "^([^?#]*)(\\?([^#]*))?(#(.*))?", boost::regex::icase | boost::regex::normal);
 
    boost::smatch result;   
    if(!(boost::regex_search(uri, result, rexp_match_uri, boost::match_default) && result[0].matched))
    {
      LOG_PRINT_L1("[PARSE URI] regex not matched for uri: " << uri);
      content.m_path = uri;
      return true;
    }
    if(result[1].matched)
    {
      content.m_path = result[1];
    }
    if(result[3].matched)
    {
      content.m_query = result[3];
    }
    if(result[5].matched)
    {
      content.m_fragment = result[5];
    }
    if(content.m_query.size())
    {
      parse_uri_query(content.m_query, content.m_query_params);
    }
    return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

parse_uri_query()

bool epee::net_utils::parse_uri_query ( const std::string & query, std::list< std::pair< std::string, std::string > > & params )

inline

Definition at line 42 of file net_parse_helpers.h.

  { 
    enum state
    {
      st_param_name, 
      st_param_val
    };
    state st = st_param_name;
    std::string::const_iterator start_it = query.begin();
    std::pair<std::string, std::string> e;
    for(std::string::const_iterator it = query.begin(); it != query.end(); it++)
    {
      switch(st)
      {
      case st_param_name:
        if(*it == '=')
        {
          e.first.assign(start_it, it);
          start_it = it;++start_it;
          st = st_param_val;
        }
        break;
      case st_param_val:
        if(*it == '&')
        {
          e.second.assign(start_it, it);
          start_it = it;++start_it;
          params.push_back(e);
          e.first.clear();e.second.clear();
          st = st_param_name;
        }
        break;
      default:
        LOG_ERROR("Unknown state " << (int)st);
        return false;
      }
    }
    if(st == st_param_name)
    {
      if(start_it != query.end())
      {
        e.first.assign(start_it, query.end());
        params.push_back(e);
      }
    }else
    {
      if(start_it != query.end())
        e.second.assign(start_it, query.end());
 
      if(e.first.size())
        params.push_back(e);
    }
    return true;
  }

Here is the caller graph for this function:

parse_url()

bool epee::net_utils::parse_url ( const std::string url_str, http::url_content & content )

inline

iframe_test.html?api_url=http://api.vk.com/api.php&api_id=3289090&api_settings=1&viewer_id=562964060&viewer_type=0&sid=0aad8d1c5713130f9ca0076f2b7b47e532877424961367d81e7fa92455f069be7e21bc3193cbd0be11895&secret=368ebbc0ef&access_token=668bc03f43981d883f73876ffff4aa8564254b359cc745dfa1b3cde7bdab2e94105d8f6d8250717569c0a7&user_id=0&group_id=0&is_app_user=1&auth_key=d2f7a895ca5ff3fdb2a2a8ae23fe679a&language=0&parent_language=0&ad_info=ElsdCQBaQlxiAQRdFUVUXiN2AVBzBx5pU1BXIgZUJlIEAWcgAUoLQg==&referrer=unknown&lc_name=9834b6a3&hash=

Definition at line 133 of file net_parse_helpers.h.

  {

    //STATIC_REGEXP_EXPR_1(rexp_match_uri, "^([^?#]*)(\\?([^#]*))?(#(.*))?", boost::regex::icase | boost::regex::normal);
    STATIC_REGEXP_EXPR_1(rexp_match_uri, "^((.*?)://)?(([^/:]*)(:(\\d+))?)(.*)?", boost::regex::icase | boost::regex::normal);
    //                                     12         34      5 6        7
    content.port = 0;
    boost::smatch result;   
    if(!(boost::regex_search(url_str, result, rexp_match_uri, boost::match_default) && result[0].matched))
    {
      LOG_PRINT_L1("[PARSE URI] regex not matched for uri: " << rexp_match_uri);
      //content.m_path = uri;
      return true;
    }
    if(result[2].matched)
    {
      content.schema = result[2];
    }
    if(result[4].matched)
    {
      content.host = result[4];
    }
    if(result[6].matched)
    {
      content.port = boost::lexical_cast<uint64_t>(result[6]);
    }
    if(result[7].matched)
    {
      content.uri = result[7];
      return parse_uri(result[7], content.m_uri_content);
    }
    
    return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

print_connection_context()

std::string epee::net_utils::print_connection_context

(

const connection_context_base &

ctx

)

Definition at line 59 of file net_utils_base.cpp.

  {
    std::stringstream ss;
    ss << ctx.m_remote_address.str() << " " << ctx.m_connection_id << (ctx.m_is_income ? " INC":" OUT");
    return ss.str();
  }

Here is the call graph for this function:

print_connection_context_short()

std::string epee::net_utils::print_connection_context_short

(

const connection_context_base &

ctx

)

Definition at line 66 of file net_utils_base.cpp.

  {
    std::stringstream ss;
    ss << ctx.m_remote_address.str() << (ctx.m_is_income ? " INC":" OUT");
    return ss.str();
  }

Here is the call graph for this function:

Here is the caller graph for this function:

shutdown_connection()

bool epee::net_utils::shutdown_connection

(

connection< TProtocol > *

pconn

)

ssl_support_from_string()

bool epee::net_utils::ssl_support_from_string	(	ssl_support_t &	ssl,
		boost::string_ref	s )

Definition at line 516 of file net_ssl.cpp.

{
  if (s == "enabled")
    ssl = epee::net_utils::ssl_support_t::e_ssl_support_enabled;
  else if (s == "disabled")
    ssl = epee::net_utils::ssl_support_t::e_ssl_support_disabled;
  else if (s == "autodetect")
    ssl = epee::net_utils::ssl_support_t::e_ssl_support_autodetect;
  else
    return false;
  return true;
}

to_string()

std::string epee::net_utils::to_string

(

t_connection_type

type

)

Definition at line 78 of file connection_basic.cpp.

  {
      if (type == e_connection_type_NET)
        return std::string("NET");
      else if (type == e_connection_type_RPC)
        return std::string("RPC");
      else if (type == e_connection_type_P2P)
        return std::string("P2P");
      
      return std::string("UNKNOWN");
  }

worker_thread_member()

PRAGMA_WARNING_POP bool epee::net_utils::worker_thread_member

(

)

zone_from_string()

zone epee::net_utils::zone_from_string ( boost::string_ref value )

noexcept

Returns

zone enum of value or zone::invalid on error.

Definition at line 89 of file net_utils_base.cpp.

  {
    if (value == "public")
      return zone::public_;
    if (value == "i2p")
      return zone::i2p;
    if (value == "tor")
      return zone::tor;
    return zone::invalid;
  }

Here is the caller graph for this function:

zone_to_string()

const char * epee::net_utils::zone_to_string ( zone value )

noexcept

Returns

String name of zone or "invalid" on error.

Definition at line 73 of file net_utils_base.cpp.

  {
    switch (value)
    {
    case zone::public_:
      return "public";
    case zone::i2p:
      return "i2p";
    case zone::tor:
      return "tor";
    default:
      break;
    }
    return "invalid";
  }

Variable Documentation

m_completion_port

HANDLE epee::net_utils::m_completion_port

Definition at line 221 of file abstract_tcp_server_cp.h.

m_config

TProtocol::config_type epee::net_utils::m_config

Definition at line 229 of file abstract_tcp_server_cp.h.

m_connections

connections_container epee::net_utils::m_connections

Definition at line 222 of file abstract_tcp_server_cp.h.

m_connections_lock

critical_section epee::net_utils::m_connections_lock

Definition at line 223 of file abstract_tcp_server_cp.h.

m_initialized

bool epee::net_utils::m_initialized

Definition at line 227 of file abstract_tcp_server_cp.h.

m_listen_socket

SOCKET epee::net_utils::m_listen_socket

Definition at line 220 of file abstract_tcp_server_cp.h.

m_port

int epee::net_utils::m_port

Definition at line 224 of file abstract_tcp_server_cp.h.

m_stop

volatile LONG epee::net_utils::m_stop

Definition at line 225 of file abstract_tcp_server_cp.h.

m_worker_thread_counter

volatile LONG epee::net_utils::m_worker_thread_counter

Definition at line 228 of file abstract_tcp_server_cp.h.