10#include <chainparams.h>
29#include <validation.h>
42 "Returns the number of connections to other nodes.\n",
60 "Requests that a ping be sent to all other nodes, to measure ping "
62 "Results provided in getpeerinfo, pingtime and pingwait fields are "
64 "Ping command is handled in queue with all other commands, so it "
65 "measures processing backlog, not just network ping.\n",
85 "Returns data about each connected network node as a json array of "
99 "(host:port) The IP address and port of the peer"},
101 "(ip:port) Bind address of the connection to the peer"},
103 "(ip:port) Local address as reported by the peer"},
105 "The total number of addresses processed, excluding those "
106 "dropped due to rate limiting"},
108 "The total number of addresses dropped due to rate "
116 "The AS in the BGP route to the peer used for "
118 "peer selection (only available if the asmap config flag "
121 "The services offered"},
124 "the services offered, in human-readable form",
126 "the service name if it is recognised"}}},
128 "Whether peer has asked us to relay transactions to it"},
135 " of the last valid transaction received from this "
139 " of the last block received from this peer"},
142 "The total bytes received"},
146 "The time offset in seconds"},
148 "ping time (if available)"},
150 "minimum observed ping time (if any at all)"},
152 "ping wait (if non-zero)"},
154 "The peer version, such as 70001"},
157 "Inbound (true) or Outbound (false)"},
159 "Whether we selected peer as (compact blocks) "
160 "high-bandwidth peer"},
162 "Whether peer selected us as (compact blocks) "
163 "high-bandwidth peer"},
165 "Type of connection: \n" +
168 "The starting height (block) of the peer"},
171 "The current height of header pre-synchronization with "
172 "this peer, or -1 if no low-work sync is in progress"},
174 "The last header we have in common with this peer"},
176 "The last block we have in common with this peer"},
182 "The heights of blocks we're currently asking from "
186 "Whether we participate in address relay with this peer"},
188 "The minimum fee rate for transactions this peer accepts"},
193 "The total bytes sent aggregated by message type\n"
194 "When a message type is not listed in this json object, "
195 "the bytes sent are 0.\n"
196 "Only known message types can appear as keys in the "
202 "The total bytes received aggregated by message type\n"
203 "When a message type is not listed in this json object, "
204 "the bytes received are 0.\n"
205 "Only known message types can appear as keys in the "
206 "object and all bytes received\n"
207 "of unknown message types are listed under '" +
210 "Avalanche availability score of this node (if any)"},
222 std::vector<CNodeStats> vstats;
232 obj.
pushKV(
"id", stats.nodeid);
233 obj.
pushKV(
"addr", stats.m_addr_name);
234 if (stats.addrBind.IsValid()) {
235 obj.
pushKV(
"addrbind", stats.addrBind.ToString());
237 if (!(stats.addrLocal.empty())) {
238 obj.
pushKV(
"addrlocal", stats.addrLocal);
241 if (stats.m_mapped_as != 0) {
242 obj.
pushKV(
"mapped_as", uint64_t(stats.m_mapped_as));
250 obj.
pushKV(
"last_transaction",
252 if (
node.avalanche) {
258 obj.
pushKV(
"bytessent", stats.nSendBytes);
259 obj.
pushKV(
"bytesrecv", stats.nRecvBytes);
261 obj.
pushKV(
"timeoffset", stats.nTimeOffset);
262 if (stats.m_last_ping_time > 0us) {
266 if (stats.m_min_ping_time < std::chrono::microseconds::max()) {
274 obj.
pushKV(
"version", stats.nVersion);
278 obj.
pushKV(
"subver", stats.cleanSubVer);
279 obj.
pushKV(
"inbound", stats.fInbound);
280 obj.
pushKV(
"bip152_hb_to", stats.m_bip152_highbandwidth_to);
281 obj.
pushKV(
"bip152_hb_from", stats.m_bip152_highbandwidth_from);
291 obj.
pushKV(
"inflight", heights);
293 obj.
pushKV(
"minfeefilter",
295 obj.
pushKV(
"addr_relay_enabled",
298 obj.
pushKV(
"addr_rate_limited",
302 for (
const auto &permission :
306 obj.
pushKV(
"permissions", permissions);
309 for (
const auto &i : stats.mapSendBytesPerMsgCmd) {
311 sendPerMsgCmd.
pushKV(i.first, i.second);
314 obj.
pushKV(
"bytessent_per_msg", sendPerMsgCmd);
317 for (
const auto &i : stats.mapRecvBytesPerMsgCmd) {
319 recvPerMsgCmd.
pushKV(i.first, i.second);
322 obj.
pushKV(
"bytesrecv_per_msg", recvPerMsgCmd);
323 obj.
pushKV(
"connection_type",
326 if (stats.m_availabilityScore) {
327 obj.
pushKV(
"availability_score",
328 *stats.m_availabilityScore);
342 "Attempts to add or remove a node from the addnode list.\n"
343 "Or try a connection to a node once.\n"
344 "Nodes added using addnode (or -connect) are protected from "
345 "DoS disconnection and are not required to be\n"
346 "full nodes as other outbound peers are (though such peers "
347 "will not be synced from).\n",
350 "The node (see getpeerinfo for nodes)"},
352 "'add' to add a node to the list, 'remove' to remove a "
353 "node from the list, 'onetry' to try a connection to the "
362 std::string strCommand;
363 if (!request.params[1].isNull()) {
364 strCommand = request.params[1].
get_str();
367 if (strCommand !=
"onetry" && strCommand !=
"add" &&
368 strCommand !=
"remove") {
369 throw std::runtime_error(self.
ToString());
375 std::string strNode = request.params[0].get_str();
377 if (strCommand ==
"onetry") {
385 if ((strCommand ==
"add") && (!connman.
AddNode(strNode))) {
387 "Error: Node already added");
388 }
else if ((strCommand ==
"remove") &&
392 "Error: Node could not be removed. It has not been "
393 "added previously.");
404 "\nOpen an outbound connection to a specified node. This RPC is for "
408 "The IP address and port to attempt connecting to."},
410 "Type of connection to open (\"outbound-full-relay\", "
411 "\"block-relay-only\", \"addr-fetch\", \"feeler\" or "
419 "Address of newly added connection."},
421 "Type of connection opened."},
425 "\"192.168.0.6:8333\" \"outbound-full-relay\"") +
427 "\"192.168.0.6:8333\" \"outbound-full-relay\"")},
430 if (config.GetChainParams().NetworkIDString() !=
432 throw std::runtime_error(
"addconnection is for regression "
433 "testing (-regtest mode) only.");
438 const std::string address = request.params[0].get_str();
439 const std::string conn_type_in{
442 if (conn_type_in ==
"outbound-full-relay") {
444 }
else if (conn_type_in ==
"block-relay-only") {
446 }
else if (conn_type_in ==
"addr-fetch") {
448 }
else if (conn_type_in ==
"feeler") {
450 }
else if (conn_type_in ==
"avalanche") {
451 if (!
node.avalanche) {
453 "Error: avalanche outbound requested "
454 "but avalanche is not enabled.");
463 const bool success = connman.
AddConnection(address, conn_type);
466 "Error: Already at capacity for specified "
471 info.
pushKV(
"address", address);
472 info.
pushKV(
"connection_type", conn_type_in);
482 "Immediately disconnects from the specified peer node.\n"
483 "\nStrictly one out of 'address' and 'nodeid' can be provided to "
484 "identify the node.\n"
485 "\nTo disconnect by nodeid, either set 'address' to the empty string, "
486 "or call using the named 'nodeid' argument only.\n",
490 "The IP address/port of the node"},
493 "The node ID (see getpeerinfo for node IDs)"},
506 const UniValue &address_arg = request.params[0];
507 const UniValue &id_arg = request.params[1];
513 (address_arg.
isStr() &&
514 address_arg.
get_str().empty()))) {
521 "Only one of address and nodeid should be provided.");
526 "Node not found in connected nodes");
537 "Returns information about the given added node, or all added nodes\n"
538 "(note that onetry addnodes are not listed here)\n",
541 "If provided, return information about this specific node, "
542 "otherwise all nodes are returned."},
554 "The node IP address or name (as provided to addnode)"},
558 "Only when connected = true",
565 "The bitcoin server IP and port we're "
568 "connection, inbound or outbound"},
582 if (!request.params[0].isNull()) {
585 if (info.strAddedNode == request.params[0].get_str()) {
586 vInfo.assign(1, info);
593 "Error: Node has not been added.");
601 obj.
pushKV(
"addednode", info.strAddedNode);
602 obj.
pushKV(
"connected", info.fConnected);
604 if (info.fConnected) {
606 address.
pushKV(
"address", info.resolvedAddress.ToString());
607 address.
pushKV(
"connected",
608 info.fInbound ?
"inbound" :
"outbound");
611 obj.
pushKV(
"addresses", addresses);
623 "Returns information about network traffic, including bytes in, "
625 "and current time.\n",
633 "Total bytes received"},
642 "Length of the measuring timeframe in seconds"},
645 "True if target is reached"},
647 "True if serving historical blocks"},
649 "Bytes left in current time cycle"},
651 "Seconds left in current time cycle"},
670 outboundLimit.
pushKV(
"target_reached",
672 outboundLimit.
pushKV(
"serve_historical_blocks",
674 outboundLimit.
pushKV(
"bytes_left_in_cycle",
677 "time_left_in_cycle",
679 obj.
pushKV(
"uploadtarget", outboundLimit);
687 for (
int n = 0; n <
NET_MAX; ++n) {
711 "Returns an object containing various state info regarding P2P "
721 "the server subversion string"},
723 "the protocol version"},
725 "the services we offer to the network"},
727 "localservicesnames",
728 "the services we offer to the network, in human-readable form",
733 "true if transaction relay is requested from peers"},
736 "the total number of connections"},
738 "the number of inbound connections"},
740 "the number of outbound connections"},
742 "whether p2p networking is enabled"},
745 "information per network",
754 "is the network limited using -onlynet?"},
756 "is the network reachable?"},
758 "(\"host:port\") the proxy that is used for this "
759 "network, or empty if none"},
761 "Whether randomized credentials are used"},
765 "minimum relay fee for transactions in " + ticker +
"/kB"},
768 "list of local addresses",
780 "any network and blockchain warnings"},
798 obj.
pushKV(
"localrelay", !
node.peerman->IgnoresIncomingTxs());
802 obj.
pushKV(
"networkactive",
node.connman->GetNetworkActive());
803 obj.
pushKV(
"connections",
node.connman->GetNodeCount(
805 obj.
pushKV(
"connections_in",
807 obj.
pushKV(
"connections_out",
node.connman->GetNodeCount(
815 node.mempool->m_min_relay_feerate.GetFeePerK());
820 for (
const std::pair<const CNetAddr, LocalServiceInfo> &item :
823 rec.
pushKV(
"address", item.first.ToString());
824 rec.
pushKV(
"port", item.second.nPort);
825 rec.
pushKV(
"score", item.second.nScore);
829 obj.
pushKV(
"localaddresses", localAddresses);
839 "Attempts to add or remove an IP/Subnet from the banned list.\n",
842 "The IP/Subnet (see getpeerinfo for nodes IP) with an optional "
843 "netmask (default is /32 = single IP)"},
845 "'add' to add an IP/Subnet to the list, 'remove' to remove an "
846 "IP/Subnet from the list"},
848 "time in seconds how long (or until when if [absolute] is set) "
849 "the IP is banned (0 or empty means using the default time of 24h "
850 "which can also be overwritten by the -bantime startup argument)"},
852 "If set, the bantime must be an absolute timestamp expressed in " +
862 std::string strCommand;
863 if (!request.params[1].isNull()) {
864 strCommand = request.params[1].
get_str();
867 if (strCommand !=
"add" && strCommand !=
"remove") {
874 "Error: Ban database not loaded");
879 bool isSubnet =
false;
881 if (request.params[0].get_str().find(
'/') != std::string::npos) {
887 LookupHost(request.params[0].get_str(), resolved,
false);
895 "Error: Invalid IP/Subnet");
898 if (strCommand ==
"add") {
899 if (isSubnet ?
node.banman->IsBanned(subNet)
900 :
node.banman->IsBanned(netAddr)) {
902 "Error: IP/Subnet already banned");
907 if (!request.params[2].isNull()) {
908 banTime = request.params[2].getInt<int64_t>();
912 if (request.params[3].isTrue()) {
919 node.connman->DisconnectNode(subNet);
924 node.connman->DisconnectNode(netAddr);
927 }
else if (strCommand ==
"remove") {
928 if (!(isSubnet ?
node.banman->Unban(subNet)
929 :
node.banman->Unban(netAddr))) {
932 "Error: Unban failed. Requested address/subnet "
933 "was not previously manually banned.");
944 "List all manually banned IPs/Subnets.\n",
967 "Error: Ban database not loaded");
971 node.banman->GetBanned(banMap);
974 for (
const auto &entry : banMap) {
975 const CBanEntry &banEntry = entry.second;
977 rec.
pushKV(
"address", entry.first.ToString());
984 return bannedAddresses;
992 "Clear all banned IPs.\n",
1003 "Error: Peer-to-peer functionality missing or disabled");
1006 node.banman->ClearBanned();
1016 "Disable/enable all p2p network activity.\n",
1019 "true to enable networking, false to disable"},
1038 "Return known addresses, which can potentially be used to find new "
1039 "nodes in the network.\n",
1042 "The maximum number of addresses to return. Specify 0 to return "
1043 "all known addresses."},
1045 "Return only addresses of the specified network. Can be one of: " +
1058 " when the node was last seen"},
1060 "The services offered by the node"},
1062 "The address of the node"},
1064 "The port number of the node"},
1067 ") the node connected through"},
1073 "network=onion count=12") +
1081 const int count{request.params[0].isNull()
1083 : request.params[0].getInt<
int>()};
1086 "Address count out of range");
1089 const std::optional<Network> network{
1090 request.params[1].isNull()
1092 : std::optional<Network>{
1097 request.params[1].get_str()));
1100 const std::vector<CAddress> vAddr{
1104 for (
const CAddress &addr : vAddr) {
1108 int64_t{TicksSinceEpoch<std::chrono::seconds>(addr.nTime)});
1109 obj.
pushKV(
"services", uint64_t(addr.nServices));
1110 obj.
pushKV(
"address", addr.ToStringIP());
1111 obj.
pushKV(
"port", addr.GetPort());
1123 "Add the address of a potential peer to the address manager. This "
1124 "RPC is for testing only.\n",
1127 "The IP address of the peer"},
1129 "The port of the peer"},
1131 "If true, attempt to add the peer to the tried addresses table"},
1139 "whether the peer address was successfully added to the "
1149 if (!
node.addrman) {
1152 "Error: Address manager functionality missing or disabled");
1155 const std::string &addr_string{request.params[0].get_str()};
1156 const uint16_t port{
1157 static_cast<uint16_t
>(request.params[1].getInt<
int>())};
1158 const bool tried{request.params[2].isTrue()};
1162 bool success{
false};
1164 if (
LookupHost(addr_string, net_addr,
false)) {
1166 address.nTime = Now<NodeSeconds>();
1169 if (
node.addrman->Add({address}, address)) {
1174 node.addrman->Good(address);
1179 obj.
pushKV(
"success", success);
1188 "Send a p2p message to a peer specified by id.\n"
1189 "The message type and body must be provided, the message header will "
1191 "This RPC is for testing only.",
1194 "The peer to send the message to."},
1196 strprintf(
"The message type (maximum length %i)",
1199 "The serialized message body to send, in hex, without a message "
1207 const NodeId peer_id{request.params[0].
getInt<int64_t>()};
1208 const std::string &msg_type{request.params[1].get_str()};
1212 strprintf(
"Error: msg_type too long, max length is %i",
1215 auto msg{TryParseHex<uint8_t>(request.params[2].get_str())};
1216 if (!msg.has_value()) {
1218 "Error parsing input for msg");
1225 msg_ser.
data = msg.value();
1226 msg_ser.
m_type = msg_type;
1235 "Error: Could not send message to peer");
1250 {
"network",
ping, },
1267 for (
const auto &c : commands) {
A CService with information about it as peer.
static const std::string REGTEST
std::chrono::seconds GetMaxOutboundTimeLeftInCycle() const
returns the time in second left in the current max outbound cycle in case of no limit,...
bool OutboundTargetReached(bool historicalBlockServingLimit) const
check if the outbound target is reached.
bool ForNode(NodeId id, std::function< bool(CNode *pnode)> func)
bool AddConnection(const std::string &address, ConnectionType conn_type)
Attempts to open a connection.
bool RemoveAddedNode(const std::string &node) EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex)
bool GetNetworkActive() const
uint64_t GetOutboundTargetBytesLeft() const
response the bytes left in the current max outbound cycle in case of no limit, it will always respons...
std::chrono::seconds GetMaxOutboundTimeframe() const
bool DisconnectNode(const std::string &node)
uint64_t GetMaxOutboundTarget() const
size_t GetNodeCount(ConnectionDirection) const
void GetNodeStats(std::vector< CNodeStats > &vstats) const
std::vector< AddedNodeInfo > GetAddedNodeInfo() const EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex)
uint64_t GetTotalBytesRecv() const
std::vector< CAddress > GetAddresses(size_t max_addresses, size_t max_pct, std::optional< Network > network) const
Return all or many randomly selected addresses, optionally by network.
void SetNetworkActive(bool active)
void OpenNetworkConnection(const CAddress &addrConnect, bool fCountFailure, CSemaphoreGrant *grantOutbound, const char *strDest, ConnectionType conn_type)
bool AddNode(const std::string &node) EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex)
void PushMessage(CNode *pnode, CSerializedNetMsg &&msg)
uint64_t GetTotalBytesSent() const
Information about a peer.
void appendCommand(const std::string &name, const CRPCCommand *pcmd)
Appends a CRPCCommand to the dispatch table.
std::string ToStringIPPort() const
static std::vector< std::string > ToStrings(NetPermissionFlags flags)
virtual void SendPings()=0
Send ping message to all peers.
virtual bool GetNodeStateStats(NodeId nodeid, CNodeStateStats &stats) const =0
Get statistics from node state.
std::string ToString() const
void push_back(UniValue val)
const std::string & get_str() const
void pushKV(std::string key, UniValue val)
bool randomize_credentials
static constexpr int CLIENT_VERSION
bitcoind-res.rc includes this file, but it cannot cope with real c++ code.
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
static path absolute(const path &p)
const std::string NET_MESSAGE_COMMAND_OTHER
GlobalMutex g_maplocalhost_mutex
std::string ConnectionTypeAsString(ConnectionType conn_type)
Convert ConnectionType enum to a string value.
std::string userAgent(const Config &config)
bool IsReachable(enum Network net)
const std::vector< std::string > CONNECTION_TYPE_DOC
ConnectionType
Different types of connections to a peer.
@ BLOCK_RELAY
We use block-relay-only connections to help prevent against partition attacks.
@ MANUAL
We open manual connections to addresses that users explicitly inputted via the addnode RPC,...
@ OUTBOUND_FULL_RELAY
These are the default connections that we use to connect with the network.
@ FEELER
Feeler connections are short-lived connections made to check that a node is alive.
@ AVALANCHE_OUTBOUND
Special case of connection to a full relay outbound with avalanche service enabled.
@ ADDR_FETCH
AddrFetch connections are short lived connections used to solicit addresses from peers.
std::map< CSubNet, CBanEntry > banmap_t
@ NET_MAX
Dummy value to indicate the number of NET_* constants.
@ NET_UNROUTABLE
Addresses from these networks are not publicly routable on the global Internet.
@ NET_INTERNAL
A set of addresses that represent the hash of a string or FQDN.
std::string GetNetworkName(enum Network net)
bool GetProxy(enum Network net, proxyType &proxyInfoOut)
bool LookupSubNet(const std::string &strSubnet, CSubNet &ret, DNSLookupFn dns_lookup_function)
Parse and resolve a specified subnet string into the appropriate internal representation.
enum Network ParseNetwork(const std::string &net_in)
bool LookupHost(const std::string &name, std::vector< CNetAddr > &vIP, unsigned int nMaxSolutions, bool fAllowLookup, DNSLookupFn dns_lookup_function)
Resolve a host string to its corresponding network addresses.
std::vector< std::string > GetNetworkNames(bool append_unroutable)
Return a vector of publicly routable Network names; optionally append NET_UNROUTABLE.
ServiceFlags
nServices flags.
UniValue JSONRPCError(int code, const std::string &message)
void RegisterNetRPCCommands(CRPCTable &t)
Register P2P networking RPC commands.
static RPCHelpMan getnetworkinfo()
static RPCHelpMan addconnection()
static RPCHelpMan getaddednodeinfo()
static RPCHelpMan clearbanned()
static RPCHelpMan getnettotals()
static RPCHelpMan addnode()
static RPCHelpMan getnodeaddresses()
static RPCHelpMan setban()
static UniValue GetNetworksInfo()
static RPCHelpMan getconnectioncount()
static RPCHelpMan disconnectnode()
static RPCHelpMan listbanned()
static RPCHelpMan setnetworkactive()
static RPCHelpMan addpeeraddress()
static RPCHelpMan getpeerinfo()
static RPCHelpMan sendmsgtopeer()
@ RPC_CLIENT_NODE_NOT_CONNECTED
Node to disconnect not found in connected nodes.
@ RPC_CLIENT_INVALID_IP_OR_SUBNET
Invalid IP/Subnet.
@ RPC_MISC_ERROR
General application defined errors std::exception thrown in command handling.
@ RPC_CLIENT_NODE_ALREADY_ADDED
Node is already added.
@ RPC_INVALID_PARAMETER
Invalid, missing or duplicate parameter.
@ RPC_DATABASE_ERROR
Database error.
@ RPC_CLIENT_NODE_NOT_ADDED
Node has not been added before.
@ RPC_CLIENT_NODE_CAPACITY_REACHED
Max number of outbound or block-relay connections already open.
@ RPC_CLIENT_P2P_DISABLED
No valid connection manager instance found.
std::string HelpExampleCli(const std::string &methodname, const std::string &args)
UniValue GetServicesNames(ServiceFlags services)
Returns, given services flags, a list of humanly readable (known) network services.
std::string HelpExampleRpc(const std::string &methodname, const std::string &args)
const std::string UNIX_EPOCH_TIME
String used to describe UNIX epoch time in documentation, factored out to a constant for consistency.
NodeContext & EnsureAnyNodeContext(const std::any &context)
PeerManager & EnsurePeerman(const NodeContext &node)
CConnman & EnsureConnman(const NodeContext &node)
auto Join(const std::vector< T > &list, const BaseType &separator, UnaryOp unary_op) -> decltype(unary_op(list.at(0)))
Join a list of items.
std::string TrimString(std::string_view str, std::string_view pattern=" \f\n\r\t\v")
std::chrono::microseconds m_ping_wait
Amount m_fee_filter_received
std::vector< int > vHeightInFlight
bool m_addr_relay_enabled
uint64_t m_addr_rate_limited
uint64_t m_addr_processed
ServiceFlags their_services
POD that contains various stats about a node.
std::vector< uint8_t > data
static const Currency & get()
@ STR_HEX
Special type that is a STR with only hex chars.
std::string DefaultHint
Hint for default value.
@ NUM_TIME
Special numeric to denote unix epoch time.
@ OBJ_DYN
Special dictionary with keys that are not literals.
@ STR_HEX
Special string with only hex chars.
NodeContext struct containing references to chain state and connection state.
int64_t GetTimeMillis()
Returns the system time (not mockable)
constexpr int64_t count_seconds(std::chrono::seconds t)
double CountSecondsDouble(SecondsDouble t)
Helper to count the seconds in any std::chrono::duration type.
int64_t GetTimeOffset()
"Never go to sea with two chronometers; take one or three." Our three time sources are:
const UniValue NullUniValue
static const int PROTOCOL_VERSION
network protocol versioning
bilingual_str GetWarnings(bool verbose)
Format a string that describes several potential problems detected by the core.