#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_addr

struct	by_conn_id

struct	by_peer_id

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)

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)

size_t	get_zone_count () const

void	change_max_out_public_peers (size_t count)

void	change_max_in_public_peers (size_t count)

virtual bool	block_host (const epee::net_utils::network_address &adress, time_t seconds=P2P_IP_BLOCKTIME)

virtual bool	unblock_host (const epee::net_utils::network_address &address)

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

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_save_graph (bool save_graph)

void	set_rpc_port (uint16_t rpc_port)

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	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

typedef COMMAND_REQUEST_STAT_INFO_T< typename t_payload_net_handler::stat_info >	COMMAND_REQUEST_STAT_INFO

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 ()

bool	check_trust (const proof_of_trust &tr, epee::net_utils::zone zone_type)

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, const epee::span< const uint8_t > data_buff, std::vector< std::pair< epee::net_utils::zone, boost::uuids::uuid >> connections)

virtual bool	invoke_command_to_peer (int command, const epee::span< const uint8_t > req_buff, std::string &resp_buff, const epee::net_utils::connection_context_base &context)

virtual bool	invoke_notify_to_peer (int command, const epee::span< const uint8_t > req_buff, const epee::net_utils::connection_context_base &context)

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)

virtual bool	is_remote_host_allowed (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, time_t local_time, const epee::net_utils::connection_context_base &context)

bool	get_local_node_data (basic_node_data &node_data, const network_zone &zone)

bool	merge_peerlist_with_local (const std::vector< peerlist_entry > &bs)

bool	fix_time_delta (std::vector< peerlist_entry > &local_peerlist, time_t local_time, int64_t &delta)

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	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 (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	cache_connect_fail_info (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_seed_nodes (cryptonote::network_type nettype) const

bool	connect_to_seed ()

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)

uint64_t	get_connections_count ()

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_external_port

uint16_t	m_rpc_port

bool	m_allow_local_ip

bool	m_hide_my_port

bool	m_no_igd

bool	m_offline

std::atomic< bool >	m_save_graph

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

std::list< epee::net_utils::network_address >	m_priority_peers

std::vector< epee::net_utils::network_address >	m_exclusive_peers

std::vector< epee::net_utils::network_address >	m_seed_nodes

bool	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< epee::net_utils::network_address, 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

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

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_REQUEST_STAT_INFO

template<class t_payload_net_handler >

typedef COMMAND_REQUEST_STAT_INFO_T<typename t_payload_net_handler::stat_info> nodetool::node_server< t_payload_net_handler >::COMMAND_REQUEST_STAT_INFO

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

◆ 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 )

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 )

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	(	const epee::net_utils::network_address &	adress,
		time_t	seconds = `P2P_IP_BLOCKTIME`
	)

virtual

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

◆ cache_connect_fail_info()

template<class t_payload_net_handler >

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

private

◆ 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

◆ check_trust()

template<class t_payload_net_handler >

bool nodetool::node_server< t_payload_net_handler >::check_trust	(	const proof_of_trust &	tr,
		epee::net_utils::zone	zone_type
	)

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

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

◆ 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 >.

◆ fix_time_delta()

template<class t_payload_net_handler >

bool nodetool::node_server< t_payload_net_handler >::fix_time_delta	(	std::vector< peerlist_entry > &	local_peerlist,
		time_t	local_time,
		int64_t &	delta
	)

private

◆ 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_connections_count()

template<class t_payload_net_handler >

uint64_t nodetool::node_server< t_payload_net_handler >::get_connections_count

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_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_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_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 ( cryptonote::network_type nettype ) const

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

◆ get_zone_count()

template<class t_payload_net_handler >

size_t nodetool::node_server< t_payload_net_handler >::get_zone_count ( ) const

inlinevirtual

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

◆ 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,
		time_t	local_time,
		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 )

◆ 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_command_to_peer()

template<class t_payload_net_handler >

bool nodetool::node_server< t_payload_net_handler >::invoke_command_to_peer	(	int	command,
		const epee::span< const uint8_t >	req_buff,
		std::string &	resp_buff,
		const epee::net_utils::connection_context_base &	context
	)

privatevirtual

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

◆ invoke_notify_to_peer()

template<class t_payload_net_handler >

bool nodetool::node_server< t_payload_net_handler >::invoke_notify_to_peer	(	int	command,
		const epee::span< const uint8_t >	req_buff,
		const epee::net_utils::connection_context_base &	context
	)

privatevirtual

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_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 )

privatevirtual

◆ 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

◆ merge_peerlist_with_local()

template<class t_payload_net_handler >

bool nodetool::node_server< t_payload_net_handler >::merge_peerlist_with_local ( const std::vector< peerlist_entry > & bs )

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

◆ relay_notify_to_list()

template<class t_payload_net_handler >

bool nodetool::node_server< t_payload_net_handler >::relay_notify_to_list	(	int	command,
		const epee::span< const uint8_t >	data_buff,
		std::vector< std::pair< epee::net_utils::zone, boost::uuids::uuid >>	connections
	)

privatevirtual

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

◆ send_stop_signal()

template<class t_payload_net_handler >

bool nodetool::node_server< t_payload_net_handler >::send_stop_signal

◆ 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_port()

template<class t_payload_net_handler >

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

inline

◆ set_save_graph()

template<class t_payload_net_handler >

void nodetool::node_server< t_payload_net_handler >::set_save_graph ( bool save_graph )

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 >.

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_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<epee::net_utils::network_address, 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_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 >

bool 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_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_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_no_igd

template<class t_payload_net_handler >

bool nodetool::node_server< t_payload_net_handler >::m_no_igd

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_rpc_port

template<class t_payload_net_handler >

uint16_t nodetool::node_server< t_payload_net_handler >::m_rpc_port

private

◆ m_save_graph

template<class t_payload_net_handler >

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

private

◆ m_seed_nodes

template<class t_payload_net_handler >

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

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.electroneumseed.com",
      "seeds.electroneumseed.info",
      "seeds.electroneumseed.org",
      "seeds.electroneumseed.net",
    }

◆ 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_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

◆ 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

Member Typedef Documentation

◆ COMMAND_HANDSHAKE

◆ COMMAND_REQUEST_STAT_INFO

◆ COMMAND_TIMED_SYNC

◆ config

◆ connect_func

◆ net_server

◆ p2p_connection_context

◆ payload_net_handler

Member Enumeration Documentation

◆ PeerType

Constructor & Destructor Documentation

◆ node_server()

◆ ~node_server()

Member Function Documentation

◆ add_host_fail()

◆ add_upnp_port_mapping()

◆ add_used_stripe_peer()

◆ add_zone()

◆ block_host()

◆ cache_connect_fail_info()

◆ 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()

◆ check_trust()

◆ clear_used_stripe_peers()

◆ connect_to_peerlist()

◆ connect_to_seed()

◆ connections_maker()

◆ deinit()

◆ delete_upnp_port_mapping()

◆ do_handshake_with_peer()

◆ do_peer_timed_sync()

◆ drop_connection()

◆ fix_time_delta()

◆ for_connection()

◆ for_each_connection()

◆ get_blocked_hosts()

◆ get_connections_count()

◆ get_incoming_connections_count() [1/2]

◆ get_incoming_connections_count() [2/2]

◆ get_local_node_data()

◆ get_outgoing_connections_count() [1/2]

◆ get_outgoing_connections_count() [2/2]

◆ get_payload_object()

◆ 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()

◆ get_zone_count()

◆ gray_peerlist_housekeeping()

◆ handle_command_line()

◆ handle_get_support_flags()

◆ handle_handshake()

◆ handle_ping()

◆ handle_remote_peerlist()

◆ handle_timed_sync()

◆ has_too_many_connections()

◆ idle_worker()

◆ if()

◆ init()

◆ init_config()

◆ init_options()

◆ invoke_command_to_peer()