#include <net_node.h>

Inheritance diagram for nodetool::node_server< t_payload_net_handler >:

Collaboration diagram for nodetool::node_server< t_payload_net_handler >:

Classes
struct	by_conn_id
struct	by_peer_id
struct	by_addr
struct	config_t
struct	network_zone

Public Types
typedef t_payload_net_handler	payload_net_handler

Public Member Functions
	node_server (t_payload_net_handler &payload_handler)
virtual	~node_server ()
bool	run ()
network_zone &	add_zone (epee::net_utils::zone zone)
bool	init (const boost::program_options::variables_map &vm, const std::string &proxy={}, bool proxy_dns_leaks_allowed={})
bool	deinit ()
bool	send_stop_signal ()
uint32_t	get_this_peer_port ()
t_payload_net_handler &	get_payload_object ()
bool	log_peerlist ()
bool	log_connections ()
virtual uint64_t	get_public_connections_count ()
size_t	get_public_outgoing_connections_count ()
size_t	get_public_white_peers_count ()
size_t	get_public_gray_peers_count ()
void	get_public_peerlist (std::vector< peerlist_entry > &gray, std::vector< peerlist_entry > &white)
void	get_peerlist (std::vector< peerlist_entry > &gray, std::vector< peerlist_entry > &white)
void	change_max_out_public_peers (size_t count)
uint32_t	get_max_out_public_peers () const
void	change_max_in_public_peers (size_t count)
uint32_t	get_max_in_public_peers () const
virtual bool	block_host (epee::net_utils::network_address address, time_t seconds=P2P_IP_BLOCKTIME, bool add_only=false)
virtual bool	unblock_host (const epee::net_utils::network_address &address)
virtual bool	block_subnet (const epee::net_utils::ipv4_network_subnet &subnet, time_t seconds=P2P_IP_BLOCKTIME)
virtual bool	unblock_subnet (const epee::net_utils::ipv4_network_subnet &subnet)
virtual bool	is_host_blocked (const epee::net_utils::network_address &address, time_t *seconds)
virtual std::map< std::string, time_t >	get_blocked_hosts ()
virtual std::map< epee::net_utils::ipv4_network_subnet, time_t >	get_blocked_subnets ()
virtual void	add_used_stripe_peer (const typename t_payload_net_handler::connection_context &context)
virtual void	remove_used_stripe_peer (const typename t_payload_net_handler::connection_context &context)
virtual void	clear_used_stripe_peers ()
void	set_rpc_port (uint16_t rpc_port)
void	set_rpc_credits_per_hash (uint32_t rpc_credits_per_hash)
Public Member Functions inherited from epee::levin::levin_commands_handler< p2p_connection_context_t< t_payload_net_handler::connection_context > >
virtual int	invoke (int command, const epee::span< const uint8_t > in_buff, byte_stream &buff_out, p2p_connection_context_t< t_payload_net_handler::connection_context > &context)=0
virtual int	notify (int command, const epee::span< const uint8_t > in_buff, p2p_connection_context_t< t_payload_net_handler::connection_context > &context)=0
virtual void	callback (p2p_connection_context_t< t_payload_net_handler::connection_context > &context)
virtual void	on_connection_new (p2p_connection_context_t< t_payload_net_handler::connection_context > &context)
virtual void	on_connection_close (p2p_connection_context_t< t_payload_net_handler::connection_context > &context)
virtual	~levin_commands_handler ()
Public Member Functions inherited from nodetool::i_p2p_endpoint< t_payload_net_handler::connection_context >
virtual void	for_each_connection (std::function< bool(t_payload_net_handler::connection_context &, peerid_type, uint32_t)> f)=0
virtual bool	for_connection (const boost::uuids::uuid &, std::function< bool(t_payload_net_handler::connection_context &, peerid_type, uint32_t)> f)=0
virtual void	add_used_stripe_peer (const t_payload_net_handler::connection_context &context)=0
virtual void	remove_used_stripe_peer (const t_payload_net_handler::connection_context &context)=0

Static Public Member Functions
static void	init_options (boost::program_options::options_description &desc)

Private Types
enum	igd_t { no_igd , igd , delayed_igd }
enum	PeerType { anchor = 0 , white , gray }
typedef p2p_connection_context_t< typename t_payload_net_handler::connection_context >	p2p_connection_context
typedef COMMAND_HANDSHAKE_T< typename t_payload_net_handler::payload_type >	COMMAND_HANDSHAKE
typedef COMMAND_TIMED_SYNC_T< typename t_payload_net_handler::payload_type >	COMMAND_TIMED_SYNC
typedef epee::net_utils::boosted_tcp_server< epee::levin::async_protocol_handler< p2p_connection_context > >	net_server
using	connect_func = boost::optional<p2p_connection_context>(network_zone&, epee::net_utils::network_address const&, epee::net_utils::ssl_support_t)
typedef epee::misc_utils::struct_init< config_t >	config

Private Member Functions
	CHAIN_LEVIN_INVOKE_MAP2 (p2p_connection_context)
	CHAIN_LEVIN_NOTIFY_MAP2 (p2p_connection_context)
	if (is_filtered_command(context.m_remote_address, command)) return LEVIN_ERROR_CONNECTION_HANDLER_NOT_DEFINED
int	handle_handshake (int command, typename COMMAND_HANDSHAKE::request &arg, typename COMMAND_HANDSHAKE::response &rsp, p2p_connection_context &context)
int	handle_timed_sync (int command, typename COMMAND_TIMED_SYNC::request &arg, typename COMMAND_TIMED_SYNC::response &rsp, p2p_connection_context &context)
int	handle_ping (int command, COMMAND_PING::request &arg, COMMAND_PING::response &rsp, p2p_connection_context &context)
int	handle_get_support_flags (int command, COMMAND_REQUEST_SUPPORT_FLAGS::request &arg, COMMAND_REQUEST_SUPPORT_FLAGS::response &rsp, p2p_connection_context &context)
bool	init_config ()
bool	make_default_peer_id ()
bool	make_default_config ()
bool	store_config ()
virtual void	on_connection_new (p2p_connection_context &context)
virtual void	on_connection_close (p2p_connection_context &context)
virtual void	callback (p2p_connection_context &context)
virtual bool	relay_notify_to_list (int command, epee::levin::message_writer message, std::vector< std::pair< epee::net_utils::zone, boost::uuids::uuid > > connections) final
virtual epee::net_utils::zone	send_txs (std::vector< cryptonote::blobdata > txs, const epee::net_utils::zone origin, const boost::uuids::uuid &source, cryptonote::relay_method tx_relay)
virtual bool	invoke_notify_to_peer (int command, epee::levin::message_writer message, const epee::net_utils::connection_context_base &context) final
virtual bool	drop_connection (const epee::net_utils::connection_context_base &context)
virtual void	request_callback (const epee::net_utils::connection_context_base &context)
virtual void	for_each_connection (std::function< bool(typename t_payload_net_handler::connection_context &, peerid_type, uint32_t)> f)
virtual bool	for_connection (const boost::uuids::uuid &, std::function< bool(typename t_payload_net_handler::connection_context &, peerid_type, uint32_t)> f)
virtual bool	add_host_fail (const epee::net_utils::network_address &address, unsigned int score=1)
virtual bool	is_remote_host_allowed (const epee::net_utils::network_address &address, time_t *t=NULL)
virtual bool	is_host_limit (const epee::net_utils::network_address &address)
bool	parse_peer_from_string (epee::net_utils::network_address &pe, const std::string &node_addr, uint16_t default_port=0)
bool	handle_command_line (const boost::program_options::variables_map &vm)
bool	idle_worker ()
bool	handle_remote_peerlist (const std::vector< peerlist_entry > &peerlist, const epee::net_utils::connection_context_base &context)
bool	get_local_node_data (basic_node_data &node_data, const network_zone &zone)
bool	sanitize_peerlist (std::vector< peerlist_entry > &local_peerlist)
bool	connections_maker ()
bool	peer_sync_idle_maker ()
bool	do_handshake_with_peer (peerid_type &pi, p2p_connection_context &context, bool just_take_peerlist=false)
bool	do_peer_timed_sync (const epee::net_utils::connection_context_base &context, peerid_type peer_id)
bool	update_dns_blocklist ()
bool	make_new_connection_from_anchor_peerlist (const std::vector< anchor_peerlist_entry > &anchor_peerlist)
bool	make_new_connection_from_peerlist (network_zone &zone, bool use_white_list)
bool	try_to_connect_and_handshake_with_new_peer (const epee::net_utils::network_address &na, bool just_take_peerlist=false, uint64_t last_seen_stamp=0, PeerType peer_type=white, uint64_t first_seen_stamp=0)
size_t	get_random_index_with_fixed_probability (size_t max_index)
bool	is_peer_used (const peerlist_entry &peer)
bool	is_peer_used (const anchor_peerlist_entry &peer)
bool	is_addr_connected (const epee::net_utils::network_address &peer)
void	add_upnp_port_mapping_impl (uint32_t port, bool ipv6=false)
void	add_upnp_port_mapping_v4 (uint32_t port)
void	add_upnp_port_mapping_v6 (uint32_t port)
void	add_upnp_port_mapping (uint32_t port, bool ipv4=true, bool ipv6=false)
void	delete_upnp_port_mapping_impl (uint32_t port, bool ipv6=false)
void	delete_upnp_port_mapping_v4 (uint32_t port)
void	delete_upnp_port_mapping_v6 (uint32_t port)
void	delete_upnp_port_mapping (uint32_t port)
template<class t_callback>
bool	try_ping (basic_node_data &node_data, p2p_connection_context &context, const t_callback &cb)
bool	try_get_support_flags (const p2p_connection_context &context, std::function< void(p2p_connection_context &, const uint32_t &)> f)
bool	make_expected_connections_count (network_zone &zone, PeerType peer_type, size_t expected_connections)
void	record_addr_failed (const epee::net_utils::network_address &addr)
bool	is_addr_recently_failed (const epee::net_utils::network_address &addr)
bool	is_priority_node (const epee::net_utils::network_address &na)
std::set< std::string >	get_ip_seed_nodes () const
std::set< std::string >	get_dns_seed_nodes ()
std::set< std::string >	get_seed_nodes (epee::net_utils::zone)
bool	connect_to_seed (epee::net_utils::zone)
template<class Container>
bool	connect_to_peerlist (const Container &peers)
template<class Container>
bool	parse_peers_and_add_to_container (const boost::program_options::variables_map &vm, const command_line::arg_descriptor< std::vector< std::string > > &arg, Container &container)
bool	set_max_out_peers (network_zone &zone, int64_t max)
bool	set_max_in_peers (network_zone &zone, int64_t max)
bool	set_tos_flag (const boost::program_options::variables_map &vm, int limit)
bool	set_rate_up_limit (const boost::program_options::variables_map &vm, int64_t limit)
bool	set_rate_down_limit (const boost::program_options::variables_map &vm, int64_t limit)
bool	set_rate_limit (const boost::program_options::variables_map &vm, int64_t limit)
bool	has_too_many_connections (const epee::net_utils::network_address &address)
size_t	get_incoming_connections_count ()
size_t	get_incoming_connections_count (network_zone &)
size_t	get_outgoing_connections_count ()
size_t	get_outgoing_connections_count (network_zone &)
bool	check_connection_and_handshake_with_peer (const epee::net_utils::network_address &na, uint64_t last_seen_stamp)
bool	gray_peerlist_housekeeping ()
bool	check_incoming_connections ()
void	kill ()
std::string	print_connections_container ()

Static Private Member Functions
static boost::optional< p2p_connection_context >	public_connect (network_zone &, epee::net_utils::network_address const &, epee::net_utils::ssl_support_t)
static boost::optional< p2p_connection_context >	socks_connect (network_zone &, epee::net_utils::network_address const &, epee::net_utils::ssl_support_t)

Private Attributes
const std::vector< std::string >	m_seed_nodes_list
bool	islimitup =false
bool	islimitdown =false
std::string	m_config_folder
bool	m_have_address
bool	m_first_connection_maker_call
uint32_t	m_listening_port
uint32_t	m_listening_port_ipv6
uint32_t	m_external_port
uint16_t	m_rpc_port
uint32_t	m_rpc_credits_per_hash
bool	m_allow_local_ip
bool	m_hide_my_port
igd_t	m_igd
bool	m_offline
bool	m_use_ipv6
bool	m_require_ipv4
std::atomic< bool >	is_closing
std::unique_ptr< boost::thread >	mPeersLoggerThread
t_payload_net_handler &	m_payload_handler
peerlist_storage	m_peerlist_storage
epee::math_helper::once_a_time_seconds< P2P_DEFAULT_HANDSHAKE_INTERVAL >	m_peer_handshake_idle_maker_interval
epee::math_helper::once_a_time_seconds< 1 >	m_connections_maker_interval
epee::math_helper::once_a_time_seconds< 60 *30, false >	m_peerlist_store_interval
epee::math_helper::once_a_time_seconds< 60 >	m_gray_peerlist_housekeeping_interval
epee::math_helper::once_a_time_seconds< 3600, false >	m_incoming_connections_interval
epee::math_helper::once_a_time_seconds< 7000 >	m_dns_blocklist_interval
std::list< epee::net_utils::network_address >	m_priority_peers
std::vector< epee::net_utils::network_address >	m_exclusive_peers
std::atomic_flag	m_fallback_seed_nodes_added
std::vector< nodetool::peerlist_entry >	m_command_line_peers
uint64_t	m_peer_livetime
std::map< epee::net_utils::zone, network_zone >	m_network_zones
std::map< std::string, time_t >	m_conn_fails_cache
epee::critical_section	m_conn_fails_cache_lock
epee::critical_section	m_blocked_hosts_lock
std::map< std::string, time_t >	m_blocked_hosts
std::map< epee::net_utils::ipv4_network_subnet, time_t >	m_blocked_subnets
epee::critical_section	m_host_fails_score_lock
std::map< std::string, uint64_t >	m_host_fails_score
boost::mutex	m_used_stripe_peers_mutex
std::array< std::list< epee::net_utils::network_address >, 1<< CRYPTONOTE_PRUNING_LOG_STRIPES >	m_used_stripe_peers
boost::uuids::uuid	m_network_id
cryptonote::network_type	m_nettype
epee::net_utils::ssl_support_t	m_ssl_support
bool	m_enable_dns_seed_nodes
bool	m_enable_dns_blocklist
uint32_t	max_connections

Additional Inherited Members
Protected Member Functions inherited from epee::net_utils::i_connection_filter
virtual	~i_connection_filter ()
Protected Member Functions inherited from epee::net_utils::i_connection_limit
virtual	~i_connection_limit ()

Member Typedef Documentation

◆ COMMAND_HANDSHAKE

template<class t_payload_net_handler>

typedef COMMAND_HANDSHAKE_T<typename t_payload_net_handler::payload_type> nodetool::node_server< t_payload_net_handler >::COMMAND_HANDSHAKE

private

◆ COMMAND_TIMED_SYNC

template<class t_payload_net_handler>

typedef COMMAND_TIMED_SYNC_T<typename t_payload_net_handler::payload_type> nodetool::node_server< t_payload_net_handler >::COMMAND_TIMED_SYNC

private

◆ config

template<class t_payload_net_handler>

typedef epee::misc_utils::struct_init<config_t> nodetool::node_server< t_payload_net_handler >::config

private

◆ connect_func

template<class t_payload_net_handler>

using nodetool::node_server< t_payload_net_handler >::connect_func = boost::optional<p2p_connection_context>(network_zone&, epee::net_utils::network_address const&, epee::net_utils::ssl_support_t)

private

◆ net_server

template<class t_payload_net_handler>

typedef epee::net_utils::boosted_tcp_server<epee::levin::async_protocol_handler<p2p_connection_context> > nodetool::node_server< t_payload_net_handler >::net_server

private

◆ p2p_connection_context

template<class t_payload_net_handler>

typedef p2p_connection_context_t<typename t_payload_net_handler::connection_context> nodetool::node_server< t_payload_net_handler >::p2p_connection_context

private

◆ payload_net_handler

template<class t_payload_net_handler>

typedef t_payload_net_handler nodetool::node_server< t_payload_net_handler >::payload_net_handler

Member Enumeration Documentation

◆ igd_t

template<class t_payload_net_handler>

enum nodetool::node_server::igd_t

private

Enumerator
no_igd
igd
delayed_igd

◆ PeerType

template<class t_payload_net_handler>

enum nodetool::node_server::PeerType

private

Enumerator
anchor
white
gray

Constructor & Destructor Documentation

◆ node_server()

template<class t_payload_net_handler>

nodetool::node_server< t_payload_net_handler >::node_server ( t_payload_net_handler & payload_handler )

inline

◆ ~node_server()

template<class t_payload_net_handler>

nodetool::node_server< t_payload_net_handler >::~node_server ( )

virtual

Member Function Documentation

◆ add_host_fail()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::add_host_fail	(	const epee::net_utils::network_address &	address,
		unsigned int	score = 1 )

privatevirtual

Implements nodetool::i_p2p_endpoint< t_payload_net_handler::connection_context >.

◆ add_upnp_port_mapping()

template<class t_payload_net_handler>

void nodetool::node_server< t_payload_net_handler >::add_upnp_port_mapping	(	uint32_t	port,
		bool	ipv4 = true,
		bool	ipv6 = false )

private

◆ add_upnp_port_mapping_impl()

template<class t_payload_net_handler>

void nodetool::node_server< t_payload_net_handler >::add_upnp_port_mapping_impl	(	uint32_t	port,
		bool	ipv6 = false )

private

◆ add_upnp_port_mapping_v4()

template<class t_payload_net_handler>

void nodetool::node_server< t_payload_net_handler >::add_upnp_port_mapping_v4 ( uint32_t port )

private

◆ add_upnp_port_mapping_v6()

template<class t_payload_net_handler>

void nodetool::node_server< t_payload_net_handler >::add_upnp_port_mapping_v6 ( uint32_t port )

private

◆ add_used_stripe_peer()

template<class t_payload_net_handler>

void nodetool::node_server< t_payload_net_handler >::add_used_stripe_peer ( const typename t_payload_net_handler::connection_context & context )

virtual

◆ add_zone()

template<class t_payload_net_handler>

node_server< t_payload_net_handler >::network_zone & nodetool::node_server< t_payload_net_handler >::add_zone ( epee::net_utils::zone zone )

◆ block_host()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::block_host	(	epee::net_utils::network_address	address,
		time_t	seconds = P2P_IP_BLOCKTIME,
		bool	add_only = false )

virtual

Implements nodetool::i_p2p_endpoint< t_payload_net_handler::connection_context >.

◆ block_subnet()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::block_subnet	(	const epee::net_utils::ipv4_network_subnet &	subnet,
		time_t	seconds = P2P_IP_BLOCKTIME )

virtual

◆ callback()

template<class t_payload_net_handler>

void nodetool::node_server< t_payload_net_handler >::callback ( p2p_connection_context & context )

privatevirtual

◆ CHAIN_LEVIN_INVOKE_MAP2()

template<class t_payload_net_handler>

nodetool::node_server< t_payload_net_handler >::CHAIN_LEVIN_INVOKE_MAP2 ( p2p_connection_context )

private

◆ CHAIN_LEVIN_NOTIFY_MAP2()

template<class t_payload_net_handler>

nodetool::node_server< t_payload_net_handler >::CHAIN_LEVIN_NOTIFY_MAP2 ( p2p_connection_context )

private

◆ change_max_in_public_peers()

template<class t_payload_net_handler>

void nodetool::node_server< t_payload_net_handler >::change_max_in_public_peers ( size_t count )

◆ change_max_out_public_peers()

template<class t_payload_net_handler>

void nodetool::node_server< t_payload_net_handler >::change_max_out_public_peers ( size_t count )

◆ check_connection_and_handshake_with_peer()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::check_connection_and_handshake_with_peer	(	const epee::net_utils::network_address &	na,
		uint64_t	last_seen_stamp )

private

◆ check_incoming_connections()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::check_incoming_connections ( )

private

◆ clear_used_stripe_peers()

template<class t_payload_net_handler>

void nodetool::node_server< t_payload_net_handler >::clear_used_stripe_peers ( )

virtual

Implements nodetool::i_p2p_endpoint< t_payload_net_handler::connection_context >.

◆ connect_to_peerlist()

template<class t_payload_net_handler>

template<class Container>

bool nodetool::node_server< t_payload_net_handler >::connect_to_peerlist ( const Container & peers )

private

◆ connect_to_seed()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::connect_to_seed ( epee::net_utils::zone zone )

private

◆ connections_maker()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::connections_maker ( )

private

◆ deinit()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::deinit ( )

◆ delete_upnp_port_mapping()

template<class t_payload_net_handler>

void nodetool::node_server< t_payload_net_handler >::delete_upnp_port_mapping ( uint32_t port )

private

◆ delete_upnp_port_mapping_impl()

template<class t_payload_net_handler>

void nodetool::node_server< t_payload_net_handler >::delete_upnp_port_mapping_impl	(	uint32_t	port,
		bool	ipv6 = false )

private

◆ delete_upnp_port_mapping_v4()

template<class t_payload_net_handler>

void nodetool::node_server< t_payload_net_handler >::delete_upnp_port_mapping_v4 ( uint32_t port )

private

◆ delete_upnp_port_mapping_v6()

template<class t_payload_net_handler>

void nodetool::node_server< t_payload_net_handler >::delete_upnp_port_mapping_v6 ( uint32_t port )

private

◆ do_handshake_with_peer()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::do_handshake_with_peer	(	peerid_type &	pi,
		p2p_connection_context &	context,
		bool	just_take_peerlist = false )

private

◆ do_peer_timed_sync()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::do_peer_timed_sync	(	const epee::net_utils::connection_context_base &	context,
		peerid_type	peer_id )

private

◆ drop_connection()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::drop_connection ( const epee::net_utils::connection_context_base & context )

privatevirtual

Implements nodetool::i_p2p_endpoint< t_payload_net_handler::connection_context >.

◆ for_connection()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::for_connection	(	const boost::uuids::uuid &	connection_id,
		std::function< bool(typename t_payload_net_handler::connection_context &, peerid_type, uint32_t)>	f )

privatevirtual

◆ for_each_connection()

template<class t_payload_net_handler>

void nodetool::node_server< t_payload_net_handler >::for_each_connection ( std::function< bool(typename t_payload_net_handler::connection_context &, peerid_type, uint32_t)> f )

privatevirtual

◆ get_blocked_hosts()

template<class t_payload_net_handler>

virtual std::map< std::string, time_t > nodetool::node_server< t_payload_net_handler >::get_blocked_hosts ( )

inlinevirtual

Implements nodetool::i_p2p_endpoint< t_payload_net_handler::connection_context >.

◆ get_blocked_subnets()

template<class t_payload_net_handler>

virtual std::map< epee::net_utils::ipv4_network_subnet, time_t > nodetool::node_server< t_payload_net_handler >::get_blocked_subnets ( )

inlinevirtual

Implements nodetool::i_p2p_endpoint< t_payload_net_handler::connection_context >.

◆ get_dns_seed_nodes()

template<class t_payload_net_handler>

std::set< std::string > nodetool::node_server< t_payload_net_handler >::get_dns_seed_nodes ( )

private

◆ get_incoming_connections_count() [1/2]

template<class t_payload_net_handler>

size_t nodetool::node_server< t_payload_net_handler >::get_incoming_connections_count ( )

private

◆ get_incoming_connections_count() [2/2]

template<class t_payload_net_handler>

size_t nodetool::node_server< t_payload_net_handler >::get_incoming_connections_count ( network_zone & zone )

private

◆ get_ip_seed_nodes()

template<class t_payload_net_handler>

std::set< std::string > nodetool::node_server< t_payload_net_handler >::get_ip_seed_nodes ( ) const

private

◆ get_local_node_data()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::get_local_node_data	(	basic_node_data &	node_data,
		const network_zone &	zone )

private

◆ get_max_in_public_peers()

template<class t_payload_net_handler>

uint32_t nodetool::node_server< t_payload_net_handler >::get_max_in_public_peers ( ) const

◆ get_max_out_public_peers()

template<class t_payload_net_handler>

uint32_t nodetool::node_server< t_payload_net_handler >::get_max_out_public_peers ( ) const

◆ get_outgoing_connections_count() [1/2]

template<class t_payload_net_handler>

size_t nodetool::node_server< t_payload_net_handler >::get_outgoing_connections_count ( )

private

◆ get_outgoing_connections_count() [2/2]

template<class t_payload_net_handler>

size_t nodetool::node_server< t_payload_net_handler >::get_outgoing_connections_count ( network_zone & zone )

private

◆ get_payload_object()

template<class t_payload_net_handler>

node_server< t_payload_net_handler >::payload_net_handler & nodetool::node_server< t_payload_net_handler >::get_payload_object ( )

◆ get_peerlist()

template<class t_payload_net_handler>

void nodetool::node_server< t_payload_net_handler >::get_peerlist	(	std::vector< peerlist_entry > &	gray,
		std::vector< peerlist_entry > &	white )

◆ get_public_connections_count()

template<class t_payload_net_handler>

uint64_t nodetool::node_server< t_payload_net_handler >::get_public_connections_count ( )

virtual

Implements nodetool::i_p2p_endpoint< t_payload_net_handler::connection_context >.

◆ get_public_gray_peers_count()

template<class t_payload_net_handler>

size_t nodetool::node_server< t_payload_net_handler >::get_public_gray_peers_count ( )

◆ get_public_outgoing_connections_count()

template<class t_payload_net_handler>

size_t nodetool::node_server< t_payload_net_handler >::get_public_outgoing_connections_count ( )

◆ get_public_peerlist()

template<class t_payload_net_handler>

void nodetool::node_server< t_payload_net_handler >::get_public_peerlist	(	std::vector< peerlist_entry > &	gray,
		std::vector< peerlist_entry > &	white )

◆ get_public_white_peers_count()

template<class t_payload_net_handler>

size_t nodetool::node_server< t_payload_net_handler >::get_public_white_peers_count ( )

◆ get_random_index_with_fixed_probability()

template<class t_payload_net_handler>

size_t nodetool::node_server< t_payload_net_handler >::get_random_index_with_fixed_probability ( size_t max_index )

private

◆ get_seed_nodes()

template<class t_payload_net_handler>

std::set< std::string > nodetool::node_server< t_payload_net_handler >::get_seed_nodes ( epee::net_utils::zone zone )

private

◆ get_this_peer_port()

template<class t_payload_net_handler>

uint32_t nodetool::node_server< t_payload_net_handler >::get_this_peer_port ( )

inline

◆ gray_peerlist_housekeeping()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::gray_peerlist_housekeeping ( )

private

◆ handle_command_line()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::handle_command_line ( const boost::program_options::variables_map & vm )

private

◆ handle_get_support_flags()

template<class t_payload_net_handler>

int nodetool::node_server< t_payload_net_handler >::handle_get_support_flags	(	int	command,
		COMMAND_REQUEST_SUPPORT_FLAGS::request &	arg,
		COMMAND_REQUEST_SUPPORT_FLAGS::response &	rsp,
		p2p_connection_context &	context )

private

◆ handle_handshake()

template<class t_payload_net_handler>

int nodetool::node_server< t_payload_net_handler >::handle_handshake	(	int	command,
		typename COMMAND_HANDSHAKE::request &	arg,
		typename COMMAND_HANDSHAKE::response &	rsp,
		p2p_connection_context &	context )

private

◆ handle_ping()

template<class t_payload_net_handler>

int nodetool::node_server< t_payload_net_handler >::handle_ping	(	int	command,
		COMMAND_PING::request &	arg,
		COMMAND_PING::response &	rsp,
		p2p_connection_context &	context )

private

◆ handle_remote_peerlist()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::handle_remote_peerlist	(	const std::vector< peerlist_entry > &	peerlist,
		const epee::net_utils::connection_context_base &	context )

private

◆ handle_timed_sync()

template<class t_payload_net_handler>

int nodetool::node_server< t_payload_net_handler >::handle_timed_sync	(	int	command,
		typename COMMAND_TIMED_SYNC::request &	arg,
		typename COMMAND_TIMED_SYNC::response &	rsp,
		p2p_connection_context &	context )

private

◆ has_too_many_connections()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::has_too_many_connections ( const epee::net_utils::network_address & address )

private

◆ idle_worker()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::idle_worker ( )

private

◆ if()

template<class t_payload_net_handler>

nodetool::node_server< t_payload_net_handler >::if ( is_filtered_command(context.m_remote_address, command) )

private

◆ init()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::init	(	const boost::program_options::variables_map &	vm,
		const std::string &	proxy = {},
		bool	proxy_dns_leaks_allowed = {} )

◆ init_config()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::init_config ( )

private

◆ init_options()

template<class t_payload_net_handler>

void nodetool::node_server< t_payload_net_handler >::init_options ( boost::program_options::options_description & desc )

static

◆ invoke_notify_to_peer()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::invoke_notify_to_peer	(	int	command,
		epee::levin::message_writer	message,
		const epee::net_utils::connection_context_base &	context )

finalprivatevirtual

Implements nodetool::i_p2p_endpoint< t_payload_net_handler::connection_context >.

◆ is_addr_connected()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::is_addr_connected ( const epee::net_utils::network_address & peer )

private

◆ is_addr_recently_failed()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::is_addr_recently_failed ( const epee::net_utils::network_address & addr )

private

◆ is_host_blocked()

template<class t_payload_net_handler>

virtual bool nodetool::node_server< t_payload_net_handler >::is_host_blocked	(	const epee::net_utils::network_address &	address,
		time_t *	seconds )

inlinevirtual

◆ is_host_limit()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::is_host_limit ( const epee::net_utils::network_address & address )

privatevirtual

Implements epee::net_utils::i_connection_limit.

◆ is_peer_used() [1/2]

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::is_peer_used ( const anchor_peerlist_entry & peer )

private

◆ is_peer_used() [2/2]

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::is_peer_used ( const peerlist_entry & peer )

private

◆ is_priority_node()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::is_priority_node ( const epee::net_utils::network_address & na )

private

◆ is_remote_host_allowed()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::is_remote_host_allowed	(	const epee::net_utils::network_address &	address,
		time_t *	t = NULL )

privatevirtual

Implements epee::net_utils::i_connection_filter.

◆ kill()

template<class t_payload_net_handler>

void nodetool::node_server< t_payload_net_handler >::kill ( )

inlineprivate

< will be called e.g. from deinit()

◆ log_connections()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::log_connections ( )

◆ log_peerlist()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::log_peerlist ( )

◆ make_default_config()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::make_default_config ( )

private

◆ make_default_peer_id()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::make_default_peer_id ( )

private

◆ make_expected_connections_count()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::make_expected_connections_count	(	network_zone &	zone,
		PeerType	peer_type,
		size_t	expected_connections )

private

◆ make_new_connection_from_anchor_peerlist()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::make_new_connection_from_anchor_peerlist ( const std::vector< anchor_peerlist_entry > & anchor_peerlist )

private

◆ make_new_connection_from_peerlist()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::make_new_connection_from_peerlist	(	network_zone &	zone,
		bool	use_white_list )

private

◆ on_connection_close()

template<class t_payload_net_handler>

void nodetool::node_server< t_payload_net_handler >::on_connection_close ( p2p_connection_context & context )

privatevirtual

◆ on_connection_new()

template<class t_payload_net_handler>

void nodetool::node_server< t_payload_net_handler >::on_connection_new ( p2p_connection_context & context )

privatevirtual

◆ parse_peer_from_string()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::parse_peer_from_string	(	epee::net_utils::network_address &	pe,
		const std::string &	node_addr,
		uint16_t	default_port = 0 )

private

◆ parse_peers_and_add_to_container()

template<class t_payload_net_handler>

template<class Container>

bool nodetool::node_server< t_payload_net_handler >::parse_peers_and_add_to_container	(	const boost::program_options::variables_map &	vm,
		const command_line::arg_descriptor< std::vector< std::string > > &	arg,
		Container &	container )

private

◆ peer_sync_idle_maker()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::peer_sync_idle_maker ( )

private

◆ print_connections_container()

template<class t_payload_net_handler>

std::string nodetool::node_server< t_payload_net_handler >::print_connections_container ( )

private

◆ public_connect()

template<typename t_payload_net_handler>

boost::optional< p2p_connection_context_t< typename t_payload_net_handler::connection_context > > nodetool::node_server< t_payload_net_handler >::public_connect	(	network_zone &	zone,
		epee::net_utils::network_address const &	na,
		epee::net_utils::ssl_support_t	ssl_support )

staticprivate

◆ record_addr_failed()

template<class t_payload_net_handler>

void nodetool::node_server< t_payload_net_handler >::record_addr_failed ( const epee::net_utils::network_address & addr )

private

◆ relay_notify_to_list()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::relay_notify_to_list	(	int	command,
		epee::levin::message_writer	message,
		std::vector< std::pair< epee::net_utils::zone, boost::uuids::uuid > >	connections )

finalprivatevirtual

Implements nodetool::i_p2p_endpoint< t_payload_net_handler::connection_context >.

◆ remove_used_stripe_peer()

template<class t_payload_net_handler>

void nodetool::node_server< t_payload_net_handler >::remove_used_stripe_peer ( const typename t_payload_net_handler::connection_context & context )

virtual

◆ request_callback()

template<class t_payload_net_handler>

void nodetool::node_server< t_payload_net_handler >::request_callback ( const epee::net_utils::connection_context_base & context )

privatevirtual

Implements nodetool::i_p2p_endpoint< t_payload_net_handler::connection_context >.

◆ run()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::run ( )

◆ sanitize_peerlist()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::sanitize_peerlist ( std::vector< peerlist_entry > & local_peerlist )

private

◆ send_stop_signal()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::send_stop_signal ( )

◆ send_txs()

template<class t_payload_net_handler>

epee::net_utils::zone nodetool::node_server< t_payload_net_handler >::send_txs	(	std::vector< cryptonote::blobdata >	txs,
		const epee::net_utils::zone	origin,
		const boost::uuids::uuid &	source,
		cryptonote::relay_method	tx_relay )

privatevirtual

Implements nodetool::i_p2p_endpoint< t_payload_net_handler::connection_context >.

◆ set_max_in_peers()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::set_max_in_peers	(	network_zone &	zone,
		int64_t	max )

private

◆ set_max_out_peers()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::set_max_out_peers	(	network_zone &	zone,
		int64_t	max )

private

◆ set_rate_down_limit()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::set_rate_down_limit	(	const boost::program_options::variables_map &	vm,
		int64_t	limit )

private

◆ set_rate_limit()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::set_rate_limit	(	const boost::program_options::variables_map &	vm,
		int64_t	limit )

private

◆ set_rate_up_limit()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::set_rate_up_limit	(	const boost::program_options::variables_map &	vm,
		int64_t	limit )

private

◆ set_rpc_credits_per_hash()

template<class t_payload_net_handler>

void nodetool::node_server< t_payload_net_handler >::set_rpc_credits_per_hash ( uint32_t rpc_credits_per_hash )

inline

◆ set_rpc_port()

template<class t_payload_net_handler>

void nodetool::node_server< t_payload_net_handler >::set_rpc_port ( uint16_t rpc_port )

inline

◆ set_tos_flag()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::set_tos_flag	(	const boost::program_options::variables_map &	vm,
		int	limit )

private

◆ socks_connect()

template<typename t_payload_net_handler>

boost::optional< p2p_connection_context_t< typename t_payload_net_handler::connection_context > > nodetool::node_server< t_payload_net_handler >::socks_connect	(	network_zone &	zone,
		epee::net_utils::network_address const &	remote,
		epee::net_utils::ssl_support_t	ssl_support )

staticprivate

◆ store_config()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::store_config ( )

private

◆ try_get_support_flags()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::try_get_support_flags	(	const p2p_connection_context &	context,
		std::function< void(p2p_connection_context &, const uint32_t &)>	f )

private

◆ try_ping()

template<class t_payload_net_handler>

template<class t_callback>

bool nodetool::node_server< t_payload_net_handler >::try_ping	(	basic_node_data &	node_data,
		p2p_connection_context &	context,
		const t_callback &	cb )

private

◆ try_to_connect_and_handshake_with_new_peer()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::try_to_connect_and_handshake_with_new_peer	(	const epee::net_utils::network_address &	na,
		bool	just_take_peerlist = false,
		uint64_t	last_seen_stamp = 0,
		PeerType	peer_type = white,
		uint64_t	first_seen_stamp = 0 )

private

◆ unblock_host()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::unblock_host ( const epee::net_utils::network_address & address )

virtual

Implements nodetool::i_p2p_endpoint< t_payload_net_handler::connection_context >.

◆ unblock_subnet()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::unblock_subnet ( const epee::net_utils::ipv4_network_subnet & subnet )

virtual

◆ update_dns_blocklist()

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::update_dns_blocklist ( )

private

Member Data Documentation

◆ is_closing

template<class t_payload_net_handler>

std::atomic<bool> nodetool::node_server< t_payload_net_handler >::is_closing

private

◆ islimitdown

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::islimitdown =false

private

◆ islimitup

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::islimitup =false

private

◆ m_allow_local_ip

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::m_allow_local_ip

private

◆ m_blocked_hosts

template<class t_payload_net_handler>

std::map<std::string, time_t> nodetool::node_server< t_payload_net_handler >::m_blocked_hosts

private

◆ m_blocked_hosts_lock

template<class t_payload_net_handler>

epee::critical_section nodetool::node_server< t_payload_net_handler >::m_blocked_hosts_lock

private

◆ m_blocked_subnets

template<class t_payload_net_handler>

std::map<epee::net_utils::ipv4_network_subnet, time_t> nodetool::node_server< t_payload_net_handler >::m_blocked_subnets

private

◆ m_command_line_peers

template<class t_payload_net_handler>

std::vector<nodetool::peerlist_entry> nodetool::node_server< t_payload_net_handler >::m_command_line_peers

private

◆ m_config_folder

template<class t_payload_net_handler>

std::string nodetool::node_server< t_payload_net_handler >::m_config_folder

private

◆ m_conn_fails_cache

template<class t_payload_net_handler>

std::map<std::string, time_t> nodetool::node_server< t_payload_net_handler >::m_conn_fails_cache

private

◆ m_conn_fails_cache_lock

template<class t_payload_net_handler>

epee::critical_section nodetool::node_server< t_payload_net_handler >::m_conn_fails_cache_lock

private

◆ m_connections_maker_interval

template<class t_payload_net_handler>

epee::math_helper::once_a_time_seconds<1> nodetool::node_server< t_payload_net_handler >::m_connections_maker_interval

private

◆ m_dns_blocklist_interval

template<class t_payload_net_handler>

epee::math_helper::once_a_time_seconds<7000> nodetool::node_server< t_payload_net_handler >::m_dns_blocklist_interval

private

◆ m_enable_dns_blocklist

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::m_enable_dns_blocklist

private

◆ m_enable_dns_seed_nodes

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::m_enable_dns_seed_nodes

private

◆ m_exclusive_peers

template<class t_payload_net_handler>

std::vector<epee::net_utils::network_address> nodetool::node_server< t_payload_net_handler >::m_exclusive_peers

private

◆ m_external_port

template<class t_payload_net_handler>

uint32_t nodetool::node_server< t_payload_net_handler >::m_external_port

private

◆ m_fallback_seed_nodes_added

template<class t_payload_net_handler>

std::atomic_flag nodetool::node_server< t_payload_net_handler >::m_fallback_seed_nodes_added

private

◆ m_first_connection_maker_call

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::m_first_connection_maker_call

private

◆ m_gray_peerlist_housekeeping_interval

template<class t_payload_net_handler>

epee::math_helper::once_a_time_seconds<60> nodetool::node_server< t_payload_net_handler >::m_gray_peerlist_housekeeping_interval

private

◆ m_have_address

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::m_have_address

private

◆ m_hide_my_port

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::m_hide_my_port

private

◆ m_host_fails_score

template<class t_payload_net_handler>

std::map<std::string, uint64_t> nodetool::node_server< t_payload_net_handler >::m_host_fails_score

private

◆ m_host_fails_score_lock

template<class t_payload_net_handler>

epee::critical_section nodetool::node_server< t_payload_net_handler >::m_host_fails_score_lock

private

◆ m_igd

template<class t_payload_net_handler>

igd_t nodetool::node_server< t_payload_net_handler >::m_igd

private

◆ m_incoming_connections_interval

template<class t_payload_net_handler>

epee::math_helper::once_a_time_seconds<3600, false> nodetool::node_server< t_payload_net_handler >::m_incoming_connections_interval

private

◆ m_listening_port

template<class t_payload_net_handler>

uint32_t nodetool::node_server< t_payload_net_handler >::m_listening_port

private

◆ m_listening_port_ipv6

template<class t_payload_net_handler>

uint32_t nodetool::node_server< t_payload_net_handler >::m_listening_port_ipv6

private

◆ m_nettype

template<class t_payload_net_handler>

cryptonote::network_type nodetool::node_server< t_payload_net_handler >::m_nettype

private

◆ m_network_id

template<class t_payload_net_handler>

boost::uuids::uuid nodetool::node_server< t_payload_net_handler >::m_network_id

private

◆ m_network_zones

template<class t_payload_net_handler>

std::map<epee::net_utils::zone, network_zone> nodetool::node_server< t_payload_net_handler >::m_network_zones

private

◆ m_offline

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::m_offline

private

◆ m_payload_handler

template<class t_payload_net_handler>

t_payload_net_handler& nodetool::node_server< t_payload_net_handler >::m_payload_handler

private

◆ m_peer_handshake_idle_maker_interval

template<class t_payload_net_handler>

epee::math_helper::once_a_time_seconds<P2P_DEFAULT_HANDSHAKE_INTERVAL> nodetool::node_server< t_payload_net_handler >::m_peer_handshake_idle_maker_interval

private

◆ m_peer_livetime

template<class t_payload_net_handler>

uint64_t nodetool::node_server< t_payload_net_handler >::m_peer_livetime

private

◆ m_peerlist_storage

template<class t_payload_net_handler>

peerlist_storage nodetool::node_server< t_payload_net_handler >::m_peerlist_storage

private

◆ m_peerlist_store_interval

template<class t_payload_net_handler>

epee::math_helper::once_a_time_seconds<60*30, false> nodetool::node_server< t_payload_net_handler >::m_peerlist_store_interval

private

◆ m_priority_peers

template<class t_payload_net_handler>

std::list<epee::net_utils::network_address> nodetool::node_server< t_payload_net_handler >::m_priority_peers

private

◆ m_require_ipv4

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::m_require_ipv4

private

◆ m_rpc_credits_per_hash

template<class t_payload_net_handler>

uint32_t nodetool::node_server< t_payload_net_handler >::m_rpc_credits_per_hash

private

◆ m_rpc_port

template<class t_payload_net_handler>

uint16_t nodetool::node_server< t_payload_net_handler >::m_rpc_port

private

◆ m_seed_nodes_list

template<class t_payload_net_handler>

const std::vector<std::string> nodetool::node_server< t_payload_net_handler >::m_seed_nodes_list

private

Initial value:

                                    =
{ "seeds.moneroseeds.se"
, "seeds.moneroseeds.ae.org"
, "seeds.moneroseeds.ch"
, "seeds.moneroseeds.li"
}

◆ m_ssl_support

template<class t_payload_net_handler>

epee::net_utils::ssl_support_t nodetool::node_server< t_payload_net_handler >::m_ssl_support

private

◆ m_use_ipv6

template<class t_payload_net_handler>

bool nodetool::node_server< t_payload_net_handler >::m_use_ipv6

private

◆ m_used_stripe_peers

template<class t_payload_net_handler>

std::array<std::list<epee::net_utils::network_address>, 1 << CRYPTONOTE_PRUNING_LOG_STRIPES> nodetool::node_server< t_payload_net_handler >::m_used_stripe_peers

private

◆ m_used_stripe_peers_mutex

template<class t_payload_net_handler>

boost::mutex nodetool::node_server< t_payload_net_handler >::m_used_stripe_peers_mutex

private

◆ max_connections

template<class t_payload_net_handler>

uint32_t nodetool::node_server< t_payload_net_handler >::max_connections

private

◆ mPeersLoggerThread

template<class t_payload_net_handler>

std::unique_ptr<boost::thread> nodetool::node_server< t_payload_net_handler >::mPeersLoggerThread

private

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

src/p2p/net_node.h
src/p2p/net_node.inl

Classes

Public Types

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Member Typedef Documentation

◆ COMMAND_HANDSHAKE

◆ COMMAND_TIMED_SYNC

◆ config

◆ connect_func

◆ net_server

◆ p2p_connection_context

◆ payload_net_handler

Member Enumeration Documentation

◆ igd_t

◆ PeerType

Constructor & Destructor Documentation

◆ node_server()

◆ ~node_server()

Member Function Documentation

◆ add_host_fail()

◆ add_upnp_port_mapping()

◆ add_upnp_port_mapping_impl()

◆ add_upnp_port_mapping_v4()

◆ add_upnp_port_mapping_v6()

◆ add_used_stripe_peer()

◆ add_zone()

◆ block_host()

◆ block_subnet()

◆ callback()

◆ CHAIN_LEVIN_INVOKE_MAP2()

◆ CHAIN_LEVIN_NOTIFY_MAP2()

◆ change_max_in_public_peers()

◆ change_max_out_public_peers()

◆ check_connection_and_handshake_with_peer()

◆ check_incoming_connections()

◆ clear_used_stripe_peers()

◆ connect_to_peerlist()

◆ connect_to_seed()

◆ connections_maker()

◆ deinit()

◆ delete_upnp_port_mapping()

◆ delete_upnp_port_mapping_impl()

◆ delete_upnp_port_mapping_v4()

◆ delete_upnp_port_mapping_v6()

◆ do_handshake_with_peer()

◆ do_peer_timed_sync()

◆ drop_connection()

◆ for_connection()

◆ for_each_connection()

◆ get_blocked_hosts()

◆ get_blocked_subnets()

◆ get_dns_seed_nodes()

◆ get_incoming_connections_count() [1/2]

◆ get_incoming_connections_count() [2/2]

◆ get_ip_seed_nodes()

◆ get_local_node_data()

◆ get_max_in_public_peers()

◆ get_max_out_public_peers()

◆ get_outgoing_connections_count() [1/2]

◆ get_outgoing_connections_count() [2/2]

◆ get_payload_object()

◆ get_peerlist()

◆ get_public_connections_count()

◆ get_public_gray_peers_count()

◆ get_public_outgoing_connections_count()

◆ get_public_peerlist()

◆ get_public_white_peers_count()

◆ get_random_index_with_fixed_probability()

◆ get_seed_nodes()

◆ get_this_peer_port()

◆ gray_peerlist_housekeeping()

◆ handle_command_line()

◆ handle_get_support_flags()

◆ handle_handshake()

◆ handle_ping()