nodetool Namespace Reference

Classes
struct	proxy
struct	anonymous_inbound
struct	p2p_connection_context_t
class	node_server
struct	i_p2p_endpoint
struct	p2p_endpoint_stub
struct	peerlist_join
struct	peerlist_types
class	peerlist_storage
class	peerlist_manager
struct	network_address_old
struct	peerlist_entry_base
struct	anchor_peerlist_entry_base
struct	connection_entry_base
struct	network_config
struct	basic_node_data
struct	COMMAND_HANDSHAKE_T
struct	COMMAND_TIMED_SYNC_T
struct	COMMAND_PING

Typedefs
typedef boost::uuids::uuid	uuid
typedef boost::uuids::uuid	net_connection_id
typedef uint64_t	peerid_type
typedef peerlist_entry_base< epee::net_utils::network_address >	peerlist_entry
typedef anchor_peerlist_entry_base< epee::net_utils::network_address >	anchor_peerlist_entry
typedef connection_entry_base< epee::net_utils::network_address >	connection_entry

Functions
boost::optional< std::vector< proxy > >	get_proxies (boost::program_options::variables_map const &vm)
boost::optional< std::vector< anonymous_inbound > >	get_anonymous_inbounds (boost::program_options::variables_map const &vm)
bool	is_filtered_command (const epee::net_utils::network_address &address, int command)
boost::optional< boost::asio::ip::tcp::socket >	socks_connect_internal (const std::atomic< bool > &stop_signal, boost::asio::io_service &service, const boost::asio::ip::tcp::endpoint &proxy, const epee::net_utils::network_address &remote)
template<typename Archive>
void	serialize (Archive &a, peerlist_types &elem, unsigned ver)
template<typename Archive>
void	serialize (Archive &a, peerlist_join elem, unsigned ver)
std::string	print_peerlist_to_string (const std::vector< peerlist_entry > &pl)
crypto::hash	get_proof_of_trust_hash (const nodetool::proof_of_trust &pot)

Variables
const command_line::arg_descriptor< std::string >	arg_p2p_bind_ip = {"p2p-bind-ip", "Interface for p2p network protocol", "0.0.0.0"}
const command_line::arg_descriptor< std::string, false, true, 2 >	arg_p2p_bind_port
const command_line::arg_descriptor< uint32_t >	arg_p2p_external_port = {"p2p-external-port", "External port for p2p network protocol (if port forwarding used with NAT)", 0}
const command_line::arg_descriptor< bool >	arg_p2p_allow_local_ip = {"allow-local-ip", "Allow local ip add to peer list, mostly in debug purposes"}
const command_line::arg_descriptor< std::vector< std::string > >	arg_p2p_add_peer = {"add-peer", "Manually add peer to local peerlist"}
const command_line::arg_descriptor< std::vector< std::string > >	arg_p2p_add_priority_node = {"add-priority-node", "Specify list of peers to connect to and attempt to keep the connection open"}
const command_line::arg_descriptor< std::vector< std::string > >	arg_p2p_add_exclusive_node
const command_line::arg_descriptor< std::vector< std::string > >	arg_p2p_seed_node = {"seed-node", "Connect to a node to retrieve peer addresses, and disconnect"}
const command_line::arg_descriptor< std::vector< std::string > >	arg_proxy = {"proxy", "<network-type>,<socks-ip:port>[,max_connections] i.e. \"tor,127.0.0.1:9050,100\""}
const command_line::arg_descriptor< std::vector< std::string > >	arg_anonymous_inbound = {"anonymous-inbound", "<hidden-service-address>,<[bind-ip:]port>[,max_connections] i.e. \"x.onion,127.0.0.1:18083,100\""}
const command_line::arg_descriptor< bool >	arg_p2p_hide_my_port = {"hide-my-port", "Do not announce yourself as peerlist candidate", false, true}
const command_line::arg_descriptor< bool >	arg_no_sync = {"no-sync", "Don't synchronize the blockchain with other peers", false}
const command_line::arg_descriptor< bool >	arg_no_igd = {"no-igd", "Disable UPnP port mapping"}
const command_line::arg_descriptor< int64_t >	arg_out_peers = {"out-peers", "set max number of out peers", -1}
const command_line::arg_descriptor< int64_t >	arg_in_peers = {"in-peers", "set max number of in peers", -1}
const command_line::arg_descriptor< int >	arg_tos_flag = {"tos-flag", "set TOS flag", -1}
const command_line::arg_descriptor< int64_t >	arg_limit_rate_up = {"limit-rate-up", "set limit-rate-up [kB/s]", P2P_DEFAULT_LIMIT_RATE_UP}
const command_line::arg_descriptor< int64_t >	arg_limit_rate_down = {"limit-rate-down", "set limit-rate-down [kB/s]", P2P_DEFAULT_LIMIT_RATE_DOWN}
const command_line::arg_descriptor< int64_t >	arg_limit_rate = {"limit-rate", "set limit-rate [kB/s]", -1}
const command_line::arg_descriptor< bool >	arg_save_graph = {"save-graph", "Save data for dr electroneum", false}
const int64_t	default_limit_up = P2P_DEFAULT_LIMIT_RATE_UP
const int64_t	default_limit_down = P2P_DEFAULT_LIMIT_RATE_DOWN
const command_line::arg_descriptor< bool >	arg_offline

Typedef Documentation

anchor_peerlist_entry

typedef anchor_peerlist_entry_base<epee::net_utils::network_address> nodetool::anchor_peerlist_entry

Definition at line 106 of file p2p_protocol_defs.h.

connection_entry

typedef connection_entry_base<epee::net_utils::network_address> nodetool::connection_entry

Definition at line 121 of file p2p_protocol_defs.h.

net_connection_id

typedef boost::uuids::uuid nodetool::net_connection_id

Definition at line 44 of file net_node_common.h.

peerid_type

typedef uint64_t nodetool::peerid_type

Definition at line 51 of file p2p_protocol_defs.h.

peerlist_entry

typedef peerlist_entry_base<epee::net_utils::network_address> nodetool::peerlist_entry

Definition at line 91 of file p2p_protocol_defs.h.

uuid

typedef boost::uuids::uuid nodetool::uuid

Definition at line 43 of file net_node_common.h.

Function Documentation

get_anonymous_inbounds()

boost::optional< std::vector< anonymous_inbound > > nodetool::get_anonymous_inbounds

(

boost::program_options::variables_map const &

vm

)

Definition at line 206 of file net_node.cpp.

    {
        std::vector<anonymous_inbound> inbounds{};
 
        const std::vector<std::string> args = command_line::get_arg(vm, arg_anonymous_inbound);
        inbounds.reserve(args.size());
 
        for (const boost::string_ref arg : args)
        {
            inbounds.emplace_back();
 
            auto next = boost::algorithm::make_split_iterator(arg, boost::algorithm::first_finder(","));
            CHECK_AND_ASSERT_MES(!next.eof() && !next->empty(), boost::none, "No inbound address for --" << arg_anonymous_inbound.name);
            const boost::string_ref address{next->begin(), next->size()};
 
            ++next;
            CHECK_AND_ASSERT_MES(!next.eof() && !next->empty(), boost::none, "No local ipv4:port given for --" << arg_anonymous_inbound.name);
            const boost::string_ref bind{next->begin(), next->size()};
 
            const std::size_t colon = bind.find_first_of(':');
            CHECK_AND_ASSERT_MES(colon < bind.size(), boost::none, "No local port given for --" << arg_anonymous_inbound.name);
 
            ++next;
            if (!next.eof())
            {
                inbounds.back().max_connections = get_max_connections(*next);
                if (inbounds.back().max_connections == 0)
                {
                    MERROR("Invalid max connections given to --" << arg_proxy.name);
                    return boost::none;
                }
            }
 
            expect<epee::net_utils::network_address> our_address = net::get_network_address(address, 0);
            switch (our_address ? our_address->get_type_id() : epee::net_utils::address_type::invalid)
            {
            case net::tor_address::get_type_id():
                inbounds.back().our_address = std::move(*our_address);
                inbounds.back().default_remote = net::tor_address::unknown();
                break;
            case net::i2p_address::get_type_id():
                inbounds.back().our_address = std::move(*our_address);
                inbounds.back().default_remote = net::i2p_address::unknown();
                break;
            default:
                MERROR("Invalid inbound address (" << address << ") for --" << arg_anonymous_inbound.name << ": " << (our_address ? "invalid type" : our_address.error().message()));
                return boost::none;
            }
 
            // get_address returns default constructed address on error
            if (inbounds.back().our_address == epee::net_utils::network_address{})
                return boost::none;
 
            std::uint32_t ip = 0;
            std::uint16_t port = 0;
            if (!epee::string_tools::parse_peer_from_string(ip, port, std::string{bind}))
            {
                MERROR("Invalid ipv4:port given for --" << arg_anonymous_inbound.name);
                return boost::none;
            }
            inbounds.back().local_ip = std::string{bind.substr(0, colon)};
            inbounds.back().local_port = std::string{bind.substr(colon + 1)};
        }
 
        return inbounds;
    }

Here is the call graph for this function:

get_proof_of_trust_hash()

crypto::hash nodetool::get_proof_of_trust_hash ( const nodetool::proof_of_trust & pot )

inline

Definition at line 485 of file p2p_protocol_defs.h.

  {
    std::string s;
    s.append(reinterpret_cast<const char*>(&pot.peer_id), sizeof(pot.peer_id));
    s.append(reinterpret_cast<const char*>(&pot.time), sizeof(pot.time));
    return crypto::cn_fast_hash(s.data(), s.size());
  }

Here is the call graph for this function:

Here is the caller graph for this function:

get_proxies()

boost::optional< std::vector< proxy > > nodetool::get_proxies

(

boost::program_options::variables_map const &

vm

)

Definition at line 148 of file net_node.cpp.

    {
    namespace ip = boost::asio::ip;
 
        std::vector<proxy> proxies{};
 
        const std::vector<std::string> args = command_line::get_arg(vm, arg_proxy);
        proxies.reserve(args.size());
 
        for (const boost::string_ref arg : args)
        {
            proxies.emplace_back();
 
            auto next = boost::algorithm::make_split_iterator(arg, boost::algorithm::first_finder(","));
            CHECK_AND_ASSERT_MES(!next.eof() && !next->empty(), boost::none, "No network type for --" << arg_proxy.name);
            const boost::string_ref zone{next->begin(), next->size()};
 
            ++next;
            CHECK_AND_ASSERT_MES(!next.eof() && !next->empty(), boost::none, "No ipv4:port given for --" << arg_proxy.name);
            const boost::string_ref proxy{next->begin(), next->size()};
 
            ++next;
            if (!next.eof())
            {
                proxies.back().max_connections = get_max_connections(*next);
                if (proxies.back().max_connections == 0)
                {
                    MERROR("Invalid max connections given to --" << arg_proxy.name);
                    return boost::none;
                }
            }
 
            switch (epee::net_utils::zone_from_string(zone))
            {
            case epee::net_utils::zone::tor:
                proxies.back().zone = epee::net_utils::zone::tor;
                break;
            case epee::net_utils::zone::i2p:
                proxies.back().zone = epee::net_utils::zone::i2p;
                break;
            default:
                MERROR("Invalid network for --" << arg_proxy.name);
                return boost::none;
            }
 
            std::uint32_t ip = 0;
            std::uint16_t port = 0;
            if (!epee::string_tools::parse_peer_from_string(ip, port, std::string{proxy}) || port == 0)
            {
                MERROR("Invalid ipv4:port given for --" << arg_proxy.name);
                return boost::none;
            }
            proxies.back().address = ip::tcp::endpoint{ip::address_v4{boost::endian::native_to_big(ip)}, port};
    }
 
        return proxies;
    }

Here is the call graph for this function:

is_filtered_command()

bool nodetool::is_filtered_command	(	epee::net_utils::network_address const &	address,
		int	command )

Returns

True if commnd is filtered (ignored/dropped) for address

Definition at line 273 of file net_node.cpp.

    {
        switch (command)
        {
        case nodetool::COMMAND_HANDSHAKE_T<cryptonote::CORE_SYNC_DATA>::ID:
        case nodetool::COMMAND_TIMED_SYNC_T<cryptonote::CORE_SYNC_DATA>::ID:
        case cryptonote::NOTIFY_NEW_TRANSACTIONS::ID:
            return false;
        default:
            break;
        }
 
        if (address.get_zone() == epee::net_utils::zone::public_)
            return false;
 
        MWARNING("Filtered command (#" << command << ") to/from " << address.str());
        return true;
    }

print_peerlist_to_string()

std::string nodetool::print_peerlist_to_string ( const std::vector< peerlist_entry > & pl )

inline

Definition at line 126 of file p2p_protocol_defs.h.

  {
    time_t now_time = 0;
    time(&now_time);
    std::stringstream ss;
    ss << std::setfill ('0') << std::setw (8) << std::hex << std::noshowbase;
    for(const peerlist_entry& pe: pl)
    {
      ss << pe.id << "\t" << pe.adr.str() 
        << " \trpc port " << (pe.rpc_port > 0 ? std::to_string(pe.rpc_port) : "-")
        << " \tpruning seed " << pe.pruning_seed 
        << " \tlast_seen: " << (pe.last_seen == 0 ? std::string("never") : epee::misc_utils::get_time_interval_string(now_time - pe.last_seen))
        << std::endl;
    }
    return ss.str();
  }

Here is the call graph for this function:

serialize() [1/2]

template<typename Archive>

void nodetool::serialize	(	Archive &	a,
		peerlist_join	elem,
		unsigned	ver )

Definition at line 154 of file net_peerlist.cpp.

  {
    save_peers(a, boost::range::join(elem.ours.white, elem.other.white));
    save_peers(a, boost::range::join(elem.ours.gray, elem.other.gray));
    save_peers(a, boost::range::join(elem.ours.anchor, elem.other.anchor));
  }

serialize() [2/2]

template<typename Archive>

void nodetool::serialize	(	Archive &	a,
		peerlist_types &	elem,
		unsigned	ver )

Definition at line 139 of file net_peerlist.cpp.

  {
    elem.white = load_peers<peerlist_entry>(a, ver);
    elem.gray = load_peers<peerlist_entry>(a, ver);
    elem.anchor = load_peers<anchor_peerlist_entry>(a, ver);
 
    if (ver == 0)
    {
      // from v1, we do not store the peer id anymore
      peerid_type peer_id{};
      a & peer_id;
    }
  }

socks_connect_internal()

boost::optional< boost::asio::ip::tcp::socket > nodetool::socks_connect_internal	(	const std::atomic< bool > &	stop_signal,
		boost::asio::io_service &	service,
		const boost::asio::ip::tcp::endpoint &	proxy,
		const epee::net_utils::network_address &	remote )

Definition at line 293 of file net_node.cpp.

    {
        using socket_type = net::socks::client::stream_type::socket;
        using client_result = std::pair<boost::system::error_code, socket_type>;
 
        struct notify
        {
            boost::promise<client_result> socks_promise;
 
            void operator()(boost::system::error_code error, socket_type&& sock)
            {
                socks_promise.set_value(std::make_pair(error, std::move(sock)));
            }
        };
 
        boost::unique_future<client_result> socks_result{};
        {
            boost::promise<client_result> socks_promise{};
            socks_result = socks_promise.get_future();
 
            auto client = net::socks::make_connect_client(
                boost::asio::ip::tcp::socket{service}, net::socks::version::v4a, notify{std::move(socks_promise)}
             );
            if (!start_socks(std::move(client), proxy, remote))
                return boost::none;
        }
 
        const auto start = std::chrono::steady_clock::now();
        while (socks_result.wait_for(future_poll_interval) == boost::future_status::timeout)
        {
            if (socks_connect_timeout < std::chrono::steady_clock::now() - start)
            {
                MERROR("Timeout on socks connect (" << proxy << " to " << remote.str() << ")");
                return boost::none;
            }
 
            if (stop_signal)
                return boost::none;
        }
 
        try
        {
            auto result = socks_result.get();
            if (!result.first)
                return {std::move(result.second)};
 
            MERROR("Failed to make socks connection to " << remote.str() << " (via " << proxy << "): " << result.first.message());
        }
        catch (boost::broken_promise const&)
        {}
 
        return boost::none;
    }

Here is the call graph for this function:

Variable Documentation

arg_anonymous_inbound

const command_line::arg_descriptor< std::vector< std::string > > nodetool::arg_anonymous_inbound = {"anonymous-inbound", "<hidden-service-address>,<[bind-ip:]port>[,max_connections] i.e. \"x.onion,127.0.0.1:18083,100\""}

Definition at line 133 of file net_node.cpp.

{"anonymous-inbound", "<hidden-service-address>,<[bind-ip:]port>[,max_connections] i.e. \"x.onion,127.0.0.1:18083,100\""};

arg_in_peers

const command_line::arg_descriptor< int64_t > nodetool::arg_in_peers = {"in-peers", "set max number of in peers", -1}

Definition at line 139 of file net_node.cpp.

{"in-peers", "set max number of in peers", -1};

arg_limit_rate

const command_line::arg_descriptor< int64_t > nodetool::arg_limit_rate = {"limit-rate", "set limit-rate [kB/s]", -1}

Definition at line 144 of file net_node.cpp.

{"limit-rate", "set limit-rate [kB/s]", -1};

arg_limit_rate_down

const command_line::arg_descriptor< int64_t > nodetool::arg_limit_rate_down = {"limit-rate-down", "set limit-rate-down [kB/s]", P2P_DEFAULT_LIMIT_RATE_DOWN}

Definition at line 143 of file net_node.cpp.

{"limit-rate-down", "set limit-rate-down [kB/s]", P2P_DEFAULT_LIMIT_RATE_DOWN};

arg_limit_rate_up

const command_line::arg_descriptor< int64_t > nodetool::arg_limit_rate_up = {"limit-rate-up", "set limit-rate-up [kB/s]", P2P_DEFAULT_LIMIT_RATE_UP}

Definition at line 142 of file net_node.cpp.

{"limit-rate-up", "set limit-rate-up [kB/s]", P2P_DEFAULT_LIMIT_RATE_UP};

arg_no_igd

const command_line::arg_descriptor< bool > nodetool::arg_no_igd = {"no-igd", "Disable UPnP port mapping"}

Definition at line 137 of file net_node.cpp.

{"no-igd", "Disable UPnP port mapping"};

arg_no_sync

const command_line::arg_descriptor< bool > nodetool::arg_no_sync = {"no-sync", "Don't synchronize the blockchain with other peers", false}

Definition at line 135 of file net_node.cpp.

{"no-sync", "Don't synchronize the blockchain with other peers", false};

arg_offline

const command_line::arg_descriptor<bool> nodetool::arg_offline

extern

arg_out_peers

const command_line::arg_descriptor< int64_t > nodetool::arg_out_peers = {"out-peers", "set max number of out peers", -1}

Definition at line 138 of file net_node.cpp.

{"out-peers", "set max number of out peers", -1};

arg_p2p_add_exclusive_node

const command_line::arg_descriptor< std::vector< std::string > > nodetool::arg_p2p_add_exclusive_node

Initial value:

= {"add-exclusive-node", "Specify list of peers to connect to only."
                              " If this option is given the options add-priority-node and seed-node are ignored"}

Definition at line 129 of file net_node.cpp.

                                                                                         {"add-exclusive-node", "Specify list of peers to connect to only."
                                                                                                  " If this option is given the options add-priority-node and seed-node are ignored"};

arg_p2p_add_peer

const command_line::arg_descriptor< std::vector< std::string > > nodetool::arg_p2p_add_peer = {"add-peer", "Manually add peer to local peerlist"}

Definition at line 127 of file net_node.cpp.

{"add-peer", "Manually add peer to local peerlist"};

arg_p2p_add_priority_node

const command_line::arg_descriptor< std::vector< std::string > > nodetool::arg_p2p_add_priority_node = {"add-priority-node", "Specify list of peers to connect to and attempt to keep the connection open"}

Definition at line 128 of file net_node.cpp.

{"add-priority-node", "Specify list of peers to connect to and attempt to keep the connection open"};

arg_p2p_allow_local_ip

const command_line::arg_descriptor< bool > nodetool::arg_p2p_allow_local_ip = {"allow-local-ip", "Allow local ip add to peer list, mostly in debug purposes"}

Definition at line 126 of file net_node.cpp.

{"allow-local-ip", "Allow local ip add to peer list, mostly in debug purposes"};

arg_p2p_bind_ip

const command_line::arg_descriptor< std::string > nodetool::arg_p2p_bind_ip = {"p2p-bind-ip", "Interface for p2p network protocol", "0.0.0.0"}

Definition at line 111 of file net_node.cpp.

{"p2p-bind-ip", "Interface for p2p network protocol", "0.0.0.0"};

arg_p2p_bind_port

const command_line::arg_descriptor< std::string, false, true, 2 > nodetool::arg_p2p_bind_port

Initial value:

                                                   = {
  "p2p-bind-port"
, "Port for p2p network protocol"
, std::to_string(config::P2P_DEFAULT_PORT)
, {{ &cryptonote::arg_testnet_on, &cryptonote::arg_stagenet_on }}
, [](std::array<bool, 2> testnet_stagenet, bool defaulted, std::string val)->std::string {
    if (testnet_stagenet[0] && defaulted)
      return std::to_string(config::testnet::P2P_DEFAULT_PORT);
    else if (testnet_stagenet[1] && defaulted)
      return std::to_string(config::stagenet::P2P_DEFAULT_PORT);
    return val;
  }
}

Definition at line 112 of file net_node.cpp.

                                                                                  {
        "p2p-bind-port"
      , "Port for p2p network protocol"
      , std::to_string(config::P2P_DEFAULT_PORT)
      , {{ &cryptonote::arg_testnet_on, &cryptonote::arg_stagenet_on }}
      , [](std::array<bool, 2> testnet_stagenet, bool defaulted, std::string val)->std::string {
          if (testnet_stagenet[0] && defaulted)
            return std::to_string(config::testnet::P2P_DEFAULT_PORT);
          else if (testnet_stagenet[1] && defaulted)
            return std::to_string(config::stagenet::P2P_DEFAULT_PORT);
          return val;
        }
      };

arg_p2p_external_port

const command_line::arg_descriptor< uint32_t > nodetool::arg_p2p_external_port = {"p2p-external-port", "External port for p2p network protocol (if port forwarding used with NAT)", 0}

Definition at line 125 of file net_node.cpp.

{"p2p-external-port", "External port for p2p network protocol (if port forwarding used with NAT)", 0};

arg_p2p_hide_my_port

const command_line::arg_descriptor< bool > nodetool::arg_p2p_hide_my_port = {"hide-my-port", "Do not announce yourself as peerlist candidate", false, true}

Definition at line 134 of file net_node.cpp.

{"hide-my-port", "Do not announce yourself as peerlist candidate", false, true};

arg_p2p_seed_node

const command_line::arg_descriptor< std::vector< std::string > > nodetool::arg_p2p_seed_node = {"seed-node", "Connect to a node to retrieve peer addresses, and disconnect"}

Definition at line 131 of file net_node.cpp.

{"seed-node", "Connect to a node to retrieve peer addresses, and disconnect"};

arg_proxy

const command_line::arg_descriptor< std::vector< std::string > > nodetool::arg_proxy = {"proxy", "<network-type>,<socks-ip:port>[,max_connections] i.e. \"tor,127.0.0.1:9050,100\""}

Definition at line 132 of file net_node.cpp.

{"proxy", "<network-type>,<socks-ip:port>[,max_connections] i.e. \"tor,127.0.0.1:9050,100\""};

arg_save_graph

const command_line::arg_descriptor< bool > nodetool::arg_save_graph = {"save-graph", "Save data for dr electroneum", false}

Definition at line 146 of file net_node.cpp.

{"save-graph", "Save data for dr electroneum", false};

arg_tos_flag

const command_line::arg_descriptor< int > nodetool::arg_tos_flag = {"tos-flag", "set TOS flag", -1}

Definition at line 140 of file net_node.cpp.

{"tos-flag", "set TOS flag", -1};

default_limit_down

const int64_t nodetool::default_limit_down = P2P_DEFAULT_LIMIT_RATE_DOWN

Definition at line 482 of file net_node.h.

default_limit_up

const int64_t nodetool::default_limit_up = P2P_DEFAULT_LIMIT_RATE_UP

Definition at line 481 of file net_node.h.