Bitcoin Core 29.99.0
P2P Digital Currency
net.cpp
Go to the documentation of this file.
1// Copyright (c) 2009-present The Bitcoin Core developers
2// Distributed under the MIT software license, see the accompanying
3// file COPYING or http://www.opensource.org/licenses/mit-license.php.
4
5#include <rpc/server.h>
6
7#include <addrman.h>
8#include <addrman_impl.h>
9#include <banman.h>
10#include <chainparams.h>
11#include <clientversion.h>
12#include <core_io.h>
13#include <net_permissions.h>
14#include <net_processing.h>
15#include <net_types.h>
16#include <netbase.h>
17#include <node/context.h>
19#include <node/warnings.h>
20#include <policy/settings.h>
21#include <protocol.h>
22#include <rpc/blockchain.h>
23#include <rpc/protocol.h>
24#include <rpc/server_util.h>
25#include <rpc/util.h>
26#include <sync.h>
27#include <univalue.h>
28#include <util/chaintype.h>
29#include <util/strencodings.h>
30#include <util/string.h>
31#include <util/time.h>
32#include <util/translation.h>
33#include <validation.h>
34
35#include <chrono>
36#include <optional>
37#include <stdexcept>
38#include <string>
39#include <vector>
40
42using util::Join;
44
45const std::vector<std::string> CONNECTION_TYPE_DOC{
46 "outbound-full-relay (default automatic connections)",
47 "block-relay-only (does not relay transactions or addresses)",
48 "inbound (initiated by the peer)",
49 "manual (added via addnode RPC or -addnode/-connect configuration options)",
50 "addr-fetch (short-lived automatic connection for soliciting addresses)",
51 "feeler (short-lived automatic connection for testing addresses)"
52};
53
54const std::vector<std::string> TRANSPORT_TYPE_DOC{
55 "detecting (peer could be v1 or v2)",
56 "v1 (plaintext transport protocol)",
57 "v2 (BIP324 encrypted transport protocol)"
58};
59
61{
62 return RPCHelpMan{
63 "getconnectioncount",
64 "Returns the number of connections to other nodes.\n",
65 {},
67 RPCResult::Type::NUM, "", "The connection count"
68 },
70 HelpExampleCli("getconnectioncount", "")
71 + HelpExampleRpc("getconnectioncount", "")
72 },
73 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
74{
75 NodeContext& node = EnsureAnyNodeContext(request.context);
76 const CConnman& connman = EnsureConnman(node);
77
79},
80 };
81}
82
84{
85 return RPCHelpMan{
86 "ping",
87 "Requests that a ping be sent to all other nodes, to measure ping time.\n"
88 "Results provided in getpeerinfo, pingtime and pingwait fields are decimal seconds.\n"
89 "Ping command is handled in queue with all other commands, so it measures processing backlog, not just network ping.\n",
90 {},
93 HelpExampleCli("ping", "")
94 + HelpExampleRpc("ping", "")
95 },
96 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
97{
98 NodeContext& node = EnsureAnyNodeContext(request.context);
99 PeerManager& peerman = EnsurePeerman(node);
100
101 // Request that each node send a ping during next message processing pass
102 peerman.SendPings();
103 return UniValue::VNULL;
104},
105 };
106}
107
110{
111 UniValue servicesNames(UniValue::VARR);
112
113 for (const auto& flag : serviceFlagsToStr(services)) {
114 servicesNames.push_back(flag);
115 }
116
117 return servicesNames;
118}
119
121{
122 return RPCHelpMan{
123 "getpeerinfo",
124 "Returns data about each connected network peer as a json array of objects.",
125 {},
126 RPCResult{
127 RPCResult::Type::ARR, "", "",
128 {
129 {RPCResult::Type::OBJ, "", "",
130 {
131 {
132 {RPCResult::Type::NUM, "id", "Peer index"},
133 {RPCResult::Type::STR, "addr", "(host:port) The IP address and port of the peer"},
134 {RPCResult::Type::STR, "addrbind", /*optional=*/true, "(ip:port) Bind address of the connection to the peer"},
135 {RPCResult::Type::STR, "addrlocal", /*optional=*/true, "(ip:port) Local address as reported by the peer"},
136 {RPCResult::Type::STR, "network", "Network (" + Join(GetNetworkNames(/*append_unroutable=*/true), ", ") + ")"},
137 {RPCResult::Type::NUM, "mapped_as", /*optional=*/true, "Mapped AS (Autonomous System) number at the end of the BGP route to the peer, used for diversifying\n"
138 "peer selection (only displayed if the -asmap config option is set)"},
139 {RPCResult::Type::STR_HEX, "services", "The services offered"},
140 {RPCResult::Type::ARR, "servicesnames", "the services offered, in human-readable form",
141 {
142 {RPCResult::Type::STR, "SERVICE_NAME", "the service name if it is recognised"}
143 }},
144 {RPCResult::Type::BOOL, "relaytxes", "Whether we relay transactions to this peer"},
145 {RPCResult::Type::NUM_TIME, "lastsend", "The " + UNIX_EPOCH_TIME + " of the last send"},
146 {RPCResult::Type::NUM_TIME, "lastrecv", "The " + UNIX_EPOCH_TIME + " of the last receive"},
147 {RPCResult::Type::NUM_TIME, "last_transaction", "The " + UNIX_EPOCH_TIME + " of the last valid transaction received from this peer"},
148 {RPCResult::Type::NUM_TIME, "last_block", "The " + UNIX_EPOCH_TIME + " of the last block received from this peer"},
149 {RPCResult::Type::NUM, "bytessent", "The total bytes sent"},
150 {RPCResult::Type::NUM, "bytesrecv", "The total bytes received"},
151 {RPCResult::Type::NUM_TIME, "conntime", "The " + UNIX_EPOCH_TIME + " of the connection"},
152 {RPCResult::Type::NUM, "timeoffset", "The time offset in seconds"},
153 {RPCResult::Type::NUM, "pingtime", /*optional=*/true, "The last ping time in milliseconds (ms), if any"},
154 {RPCResult::Type::NUM, "minping", /*optional=*/true, "The minimum observed ping time in milliseconds (ms), if any"},
155 {RPCResult::Type::NUM, "pingwait", /*optional=*/true, "The duration in milliseconds (ms) of an outstanding ping (if non-zero)"},
156 {RPCResult::Type::NUM, "version", "The peer version, such as 70001"},
157 {RPCResult::Type::STR, "subver", "The string version"},
158 {RPCResult::Type::BOOL, "inbound", "Inbound (true) or Outbound (false)"},
159 {RPCResult::Type::BOOL, "bip152_hb_to", "Whether we selected peer as (compact blocks) high-bandwidth peer"},
160 {RPCResult::Type::BOOL, "bip152_hb_from", "Whether peer selected us as (compact blocks) high-bandwidth peer"},
161 {RPCResult::Type::NUM, "startingheight", "The starting height (block) of the peer"},
162 {RPCResult::Type::NUM, "presynced_headers", "The current height of header pre-synchronization with this peer, or -1 if no low-work sync is in progress"},
163 {RPCResult::Type::NUM, "synced_headers", "The last header we have in common with this peer"},
164 {RPCResult::Type::NUM, "synced_blocks", "The last block we have in common with this peer"},
165 {RPCResult::Type::ARR, "inflight", "",
166 {
167 {RPCResult::Type::NUM, "n", "The heights of blocks we're currently asking from this peer"},
168 }},
169 {RPCResult::Type::BOOL, "addr_relay_enabled", "Whether we participate in address relay with this peer"},
170 {RPCResult::Type::NUM, "addr_processed", "The total number of addresses processed, excluding those dropped due to rate limiting"},
171 {RPCResult::Type::NUM, "addr_rate_limited", "The total number of addresses dropped due to rate limiting"},
172 {RPCResult::Type::ARR, "permissions", "Any special permissions that have been granted to this peer",
173 {
174 {RPCResult::Type::STR, "permission_type", Join(NET_PERMISSIONS_DOC, ",\n") + ".\n"},
175 }},
176 {RPCResult::Type::NUM, "minfeefilter", "The minimum fee rate for transactions this peer accepts"},
177 {RPCResult::Type::OBJ_DYN, "bytessent_per_msg", "",
178 {
179 {RPCResult::Type::NUM, "msg", "The total bytes sent aggregated by message type\n"
180 "When a message type is not listed in this json object, the bytes sent are 0.\n"
181 "Only known message types can appear as keys in the object."}
182 }},
183 {RPCResult::Type::OBJ_DYN, "bytesrecv_per_msg", "",
184 {
185 {RPCResult::Type::NUM, "msg", "The total bytes received aggregated by message type\n"
186 "When a message type is not listed in this json object, the bytes received are 0.\n"
187 "Only known message types can appear as keys in the object and all bytes received\n"
188 "of unknown message types are listed under '"+NET_MESSAGE_TYPE_OTHER+"'."}
189 }},
190 {RPCResult::Type::STR, "connection_type", "Type of connection: \n" + Join(CONNECTION_TYPE_DOC, ",\n") + ".\n"
191 "Please note this output is unlikely to be stable in upcoming releases as we iterate to\n"
192 "best capture connection behaviors."},
193 {RPCResult::Type::STR, "transport_protocol_type", "Type of transport protocol: \n" + Join(TRANSPORT_TYPE_DOC, ",\n") + ".\n"},
194 {RPCResult::Type::STR, "session_id", "The session ID for this connection, or \"\" if there is none (\"v2\" transport protocol only).\n"},
195 }},
196 }},
197 },
199 HelpExampleCli("getpeerinfo", "")
200 + HelpExampleRpc("getpeerinfo", "")
201 },
202 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
203{
204 NodeContext& node = EnsureAnyNodeContext(request.context);
205 const CConnman& connman = EnsureConnman(node);
206 const PeerManager& peerman = EnsurePeerman(node);
207
208 std::vector<CNodeStats> vstats;
209 connman.GetNodeStats(vstats);
210
212
213 for (const CNodeStats& stats : vstats) {
215 CNodeStateStats statestats;
216 bool fStateStats = peerman.GetNodeStateStats(stats.nodeid, statestats);
217 // GetNodeStateStats() requires the existence of a CNodeState and a Peer object
218 // to succeed for this peer. These are created at connection initialisation and
219 // exist for the duration of the connection - except if there is a race where the
220 // peer got disconnected in between the GetNodeStats() and the GetNodeStateStats()
221 // calls. In this case, the peer doesn't need to be reported here.
222 if (!fStateStats) {
223 continue;
224 }
225 obj.pushKV("id", stats.nodeid);
226 obj.pushKV("addr", stats.m_addr_name);
227 if (stats.addrBind.IsValid()) {
228 obj.pushKV("addrbind", stats.addrBind.ToStringAddrPort());
229 }
230 if (!(stats.addrLocal.empty())) {
231 obj.pushKV("addrlocal", stats.addrLocal);
232 }
233 obj.pushKV("network", GetNetworkName(stats.m_network));
234 if (stats.m_mapped_as != 0) {
235 obj.pushKV("mapped_as", uint64_t(stats.m_mapped_as));
236 }
237 ServiceFlags services{statestats.their_services};
238 obj.pushKV("services", strprintf("%016x", services));
239 obj.pushKV("servicesnames", GetServicesNames(services));
240 obj.pushKV("relaytxes", statestats.m_relay_txs);
241 obj.pushKV("lastsend", count_seconds(stats.m_last_send));
242 obj.pushKV("lastrecv", count_seconds(stats.m_last_recv));
243 obj.pushKV("last_transaction", count_seconds(stats.m_last_tx_time));
244 obj.pushKV("last_block", count_seconds(stats.m_last_block_time));
245 obj.pushKV("bytessent", stats.nSendBytes);
246 obj.pushKV("bytesrecv", stats.nRecvBytes);
247 obj.pushKV("conntime", count_seconds(stats.m_connected));
248 obj.pushKV("timeoffset", Ticks<std::chrono::seconds>(statestats.time_offset));
249 if (stats.m_last_ping_time > 0us) {
250 obj.pushKV("pingtime", Ticks<SecondsDouble>(stats.m_last_ping_time));
251 }
252 if (stats.m_min_ping_time < std::chrono::microseconds::max()) {
253 obj.pushKV("minping", Ticks<SecondsDouble>(stats.m_min_ping_time));
254 }
255 if (statestats.m_ping_wait > 0s) {
256 obj.pushKV("pingwait", Ticks<SecondsDouble>(statestats.m_ping_wait));
257 }
258 obj.pushKV("version", stats.nVersion);
259 // Use the sanitized form of subver here, to avoid tricksy remote peers from
260 // corrupting or modifying the JSON output by putting special characters in
261 // their ver message.
262 obj.pushKV("subver", stats.cleanSubVer);
263 obj.pushKV("inbound", stats.fInbound);
264 obj.pushKV("bip152_hb_to", stats.m_bip152_highbandwidth_to);
265 obj.pushKV("bip152_hb_from", stats.m_bip152_highbandwidth_from);
266 obj.pushKV("startingheight", statestats.m_starting_height);
267 obj.pushKV("presynced_headers", statestats.presync_height);
268 obj.pushKV("synced_headers", statestats.nSyncHeight);
269 obj.pushKV("synced_blocks", statestats.nCommonHeight);
270 UniValue heights(UniValue::VARR);
271 for (const int height : statestats.vHeightInFlight) {
272 heights.push_back(height);
273 }
274 obj.pushKV("inflight", std::move(heights));
275 obj.pushKV("addr_relay_enabled", statestats.m_addr_relay_enabled);
276 obj.pushKV("addr_processed", statestats.m_addr_processed);
277 obj.pushKV("addr_rate_limited", statestats.m_addr_rate_limited);
278 UniValue permissions(UniValue::VARR);
279 for (const auto& permission : NetPermissions::ToStrings(stats.m_permission_flags)) {
280 permissions.push_back(permission);
281 }
282 obj.pushKV("permissions", std::move(permissions));
283 obj.pushKV("minfeefilter", ValueFromAmount(statestats.m_fee_filter_received));
284
285 UniValue sendPerMsgType(UniValue::VOBJ);
286 for (const auto& i : stats.mapSendBytesPerMsgType) {
287 if (i.second > 0)
288 sendPerMsgType.pushKV(i.first, i.second);
289 }
290 obj.pushKV("bytessent_per_msg", std::move(sendPerMsgType));
291
292 UniValue recvPerMsgType(UniValue::VOBJ);
293 for (const auto& i : stats.mapRecvBytesPerMsgType) {
294 if (i.second > 0)
295 recvPerMsgType.pushKV(i.first, i.second);
296 }
297 obj.pushKV("bytesrecv_per_msg", std::move(recvPerMsgType));
298 obj.pushKV("connection_type", ConnectionTypeAsString(stats.m_conn_type));
299 obj.pushKV("transport_protocol_type", TransportTypeAsString(stats.m_transport_type));
300 obj.pushKV("session_id", stats.m_session_id);
301
302 ret.push_back(std::move(obj));
303 }
304
305 return ret;
306},
307 };
308}
309
311{
312 return RPCHelpMan{
313 "addnode",
314 "Attempts to add or remove a node from the addnode list.\n"
315 "Or try a connection to a node once.\n"
316 "Nodes added using addnode (or -connect) are protected from DoS disconnection and are not required to be\n"
317 "full nodes/support SegWit as other outbound peers are (though such peers will not be synced from).\n" +
318 strprintf("Addnode connections are limited to %u at a time", MAX_ADDNODE_CONNECTIONS) +
319 " and are counted separately from the -maxconnections limit.\n",
320 {
321 {"node", RPCArg::Type::STR, RPCArg::Optional::NO, "The address of the peer to connect to"},
322 {"command", RPCArg::Type::STR, RPCArg::Optional::NO, "'add' to add a node to the list, 'remove' to remove a node from the list, 'onetry' to try a connection to the node once"},
323 {"v2transport", RPCArg::Type::BOOL, RPCArg::DefaultHint{"set by -v2transport"}, "Attempt to connect using BIP324 v2 transport protocol (ignored for 'remove' command)"},
324 },
327 HelpExampleCli("addnode", "\"192.168.0.6:8333\" \"onetry\" true")
328 + HelpExampleRpc("addnode", "\"192.168.0.6:8333\", \"onetry\" true")
329 },
330 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
331{
332 const auto command{self.Arg<std::string>("command")};
333 if (command != "onetry" && command != "add" && command != "remove") {
334 throw std::runtime_error(
335 self.ToString());
336 }
337
338 NodeContext& node = EnsureAnyNodeContext(request.context);
339 CConnman& connman = EnsureConnman(node);
340
341 const auto node_arg{self.Arg<std::string>("node")};
342 bool node_v2transport = connman.GetLocalServices() & NODE_P2P_V2;
343 bool use_v2transport = self.MaybeArg<bool>("v2transport").value_or(node_v2transport);
344
345 if (use_v2transport && !node_v2transport) {
346 throw JSONRPCError(RPC_INVALID_PARAMETER, "Error: v2transport requested but not enabled (see -v2transport)");
347 }
348
349 if (command == "onetry")
350 {
351 CAddress addr;
352 connman.OpenNetworkConnection(addr, /*fCountFailure=*/false, /*grant_outbound=*/{}, node_arg.c_str(), ConnectionType::MANUAL, use_v2transport);
353 return UniValue::VNULL;
354 }
355
356 if (command == "add")
357 {
358 if (!connman.AddNode({node_arg, use_v2transport})) {
359 throw JSONRPCError(RPC_CLIENT_NODE_ALREADY_ADDED, "Error: Node already added");
360 }
361 }
362 else if (command == "remove")
363 {
364 if (!connman.RemoveAddedNode(node_arg)) {
365 throw JSONRPCError(RPC_CLIENT_NODE_NOT_ADDED, "Error: Node could not be removed. It has not been added previously.");
366 }
367 }
368
369 return UniValue::VNULL;
370},
371 };
372}
373
375{
376 return RPCHelpMan{
377 "addconnection",
378 "Open an outbound connection to a specified node. This RPC is for testing only.\n",
379 {
380 {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The IP address and port to attempt connecting to."},
381 {"connection_type", RPCArg::Type::STR, RPCArg::Optional::NO, "Type of connection to open (\"outbound-full-relay\", \"block-relay-only\", \"addr-fetch\" or \"feeler\")."},
382 {"v2transport", RPCArg::Type::BOOL, RPCArg::Optional::NO, "Attempt to connect using BIP324 v2 transport protocol"},
383 },
384 RPCResult{
385 RPCResult::Type::OBJ, "", "",
386 {
387 { RPCResult::Type::STR, "address", "Address of newly added connection." },
388 { RPCResult::Type::STR, "connection_type", "Type of connection opened." },
389 }},
391 HelpExampleCli("addconnection", "\"192.168.0.6:8333\" \"outbound-full-relay\" true")
392 + HelpExampleRpc("addconnection", "\"192.168.0.6:8333\" \"outbound-full-relay\" true")
393 },
394 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
395{
397 throw std::runtime_error("addconnection is for regression testing (-regtest mode) only.");
398 }
399
400 const std::string address = request.params[0].get_str();
401 const std::string conn_type_in{TrimString(request.params[1].get_str())};
402 ConnectionType conn_type{};
403 if (conn_type_in == "outbound-full-relay") {
405 } else if (conn_type_in == "block-relay-only") {
406 conn_type = ConnectionType::BLOCK_RELAY;
407 } else if (conn_type_in == "addr-fetch") {
408 conn_type = ConnectionType::ADDR_FETCH;
409 } else if (conn_type_in == "feeler") {
410 conn_type = ConnectionType::FEELER;
411 } else {
413 }
414 bool use_v2transport{self.Arg<bool>("v2transport")};
415
416 NodeContext& node = EnsureAnyNodeContext(request.context);
417 CConnman& connman = EnsureConnman(node);
418
419 if (use_v2transport && !(connman.GetLocalServices() & NODE_P2P_V2)) {
420 throw JSONRPCError(RPC_INVALID_PARAMETER, "Error: Adding v2transport connections requires -v2transport init flag to be set.");
421 }
422
423 const bool success = connman.AddConnection(address, conn_type, use_v2transport);
424 if (!success) {
425 throw JSONRPCError(RPC_CLIENT_NODE_CAPACITY_REACHED, "Error: Already at capacity for specified connection type.");
426 }
427
429 info.pushKV("address", address);
430 info.pushKV("connection_type", conn_type_in);
431
432 return info;
433},
434 };
435}
436
438{
439 return RPCHelpMan{
440 "disconnectnode",
441 "Immediately disconnects from the specified peer node.\n"
442 "\nStrictly one out of 'address' and 'nodeid' can be provided to identify the node.\n"
443 "\nTo disconnect by nodeid, either set 'address' to the empty string, or call using the named 'nodeid' argument only.\n",
444 {
445 {"address", RPCArg::Type::STR, RPCArg::DefaultHint{"fallback to nodeid"}, "The IP address/port of the node"},
446 {"nodeid", RPCArg::Type::NUM, RPCArg::DefaultHint{"fallback to address"}, "The node ID (see getpeerinfo for node IDs)"},
447 },
450 HelpExampleCli("disconnectnode", "\"192.168.0.6:8333\"")
451 + HelpExampleCli("disconnectnode", "\"\" 1")
452 + HelpExampleRpc("disconnectnode", "\"192.168.0.6:8333\"")
453 + HelpExampleRpc("disconnectnode", "\"\", 1")
454 },
455 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
456{
457 NodeContext& node = EnsureAnyNodeContext(request.context);
458 CConnman& connman = EnsureConnman(node);
459
460 bool success;
461 const UniValue &address_arg = request.params[0];
462 const UniValue &id_arg = request.params[1];
463
464 if (!address_arg.isNull() && id_arg.isNull()) {
465 /* handle disconnect-by-address */
466 success = connman.DisconnectNode(address_arg.get_str());
467 } else if (!id_arg.isNull() && (address_arg.isNull() || (address_arg.isStr() && address_arg.get_str().empty()))) {
468 /* handle disconnect-by-id */
469 NodeId nodeid = (NodeId) id_arg.getInt<int64_t>();
470 success = connman.DisconnectNode(nodeid);
471 } else {
472 throw JSONRPCError(RPC_INVALID_PARAMS, "Only one of address and nodeid should be provided.");
473 }
474
475 if (!success) {
476 throw JSONRPCError(RPC_CLIENT_NODE_NOT_CONNECTED, "Node not found in connected nodes");
477 }
478
479 return UniValue::VNULL;
480},
481 };
482}
483
485{
486 return RPCHelpMan{
487 "getaddednodeinfo",
488 "Returns information about the given added node, or all added nodes\n"
489 "(note that onetry addnodes are not listed here)\n",
490 {
491 {"node", RPCArg::Type::STR, RPCArg::DefaultHint{"all nodes"}, "If provided, return information about this specific node, otherwise all nodes are returned."},
492 },
493 RPCResult{
494 RPCResult::Type::ARR, "", "",
495 {
496 {RPCResult::Type::OBJ, "", "",
497 {
498 {RPCResult::Type::STR, "addednode", "The node IP address or name (as provided to addnode)"},
499 {RPCResult::Type::BOOL, "connected", "If connected"},
500 {RPCResult::Type::ARR, "addresses", "Only when connected = true",
501 {
502 {RPCResult::Type::OBJ, "", "",
503 {
504 {RPCResult::Type::STR, "address", "The bitcoin server IP and port we're connected to"},
505 {RPCResult::Type::STR, "connected", "connection, inbound or outbound"},
506 }},
507 }},
508 }},
509 }
510 },
512 HelpExampleCli("getaddednodeinfo", "\"192.168.0.201\"")
513 + HelpExampleRpc("getaddednodeinfo", "\"192.168.0.201\"")
514 },
515 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
516{
517 NodeContext& node = EnsureAnyNodeContext(request.context);
518 const CConnman& connman = EnsureConnman(node);
519
520 std::vector<AddedNodeInfo> vInfo = connman.GetAddedNodeInfo(/*include_connected=*/true);
521
522 if (!request.params[0].isNull()) {
523 bool found = false;
524 for (const AddedNodeInfo& info : vInfo) {
525 if (info.m_params.m_added_node == request.params[0].get_str()) {
526 vInfo.assign(1, info);
527 found = true;
528 break;
529 }
530 }
531 if (!found) {
532 throw JSONRPCError(RPC_CLIENT_NODE_NOT_ADDED, "Error: Node has not been added.");
533 }
534 }
535
537
538 for (const AddedNodeInfo& info : vInfo) {
540 obj.pushKV("addednode", info.m_params.m_added_node);
541 obj.pushKV("connected", info.fConnected);
542 UniValue addresses(UniValue::VARR);
543 if (info.fConnected) {
544 UniValue address(UniValue::VOBJ);
545 address.pushKV("address", info.resolvedAddress.ToStringAddrPort());
546 address.pushKV("connected", info.fInbound ? "inbound" : "outbound");
547 addresses.push_back(std::move(address));
548 }
549 obj.pushKV("addresses", std::move(addresses));
550 ret.push_back(std::move(obj));
551 }
552
553 return ret;
554},
555 };
556}
557
559{
560 return RPCHelpMan{"getnettotals",
561 "Returns information about network traffic, including bytes in, bytes out,\n"
562 "and current system time.",
563 {},
564 RPCResult{
565 RPCResult::Type::OBJ, "", "",
566 {
567 {RPCResult::Type::NUM, "totalbytesrecv", "Total bytes received"},
568 {RPCResult::Type::NUM, "totalbytessent", "Total bytes sent"},
569 {RPCResult::Type::NUM_TIME, "timemillis", "Current system " + UNIX_EPOCH_TIME + " in milliseconds"},
570 {RPCResult::Type::OBJ, "uploadtarget", "",
571 {
572 {RPCResult::Type::NUM, "timeframe", "Length of the measuring timeframe in seconds"},
573 {RPCResult::Type::NUM, "target", "Target in bytes"},
574 {RPCResult::Type::BOOL, "target_reached", "True if target is reached"},
575 {RPCResult::Type::BOOL, "serve_historical_blocks", "True if serving historical blocks"},
576 {RPCResult::Type::NUM, "bytes_left_in_cycle", "Bytes left in current time cycle"},
577 {RPCResult::Type::NUM, "time_left_in_cycle", "Seconds left in current time cycle"},
578 }},
579 }
580 },
582 HelpExampleCli("getnettotals", "")
583 + HelpExampleRpc("getnettotals", "")
584 },
585 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
586{
587 NodeContext& node = EnsureAnyNodeContext(request.context);
588 const CConnman& connman = EnsureConnman(node);
589
591 obj.pushKV("totalbytesrecv", connman.GetTotalBytesRecv());
592 obj.pushKV("totalbytessent", connman.GetTotalBytesSent());
593 obj.pushKV("timemillis", TicksSinceEpoch<std::chrono::milliseconds>(SystemClock::now()));
594
595 UniValue outboundLimit(UniValue::VOBJ);
596 outboundLimit.pushKV("timeframe", count_seconds(connman.GetMaxOutboundTimeframe()));
597 outboundLimit.pushKV("target", connman.GetMaxOutboundTarget());
598 outboundLimit.pushKV("target_reached", connman.OutboundTargetReached(false));
599 outboundLimit.pushKV("serve_historical_blocks", !connman.OutboundTargetReached(true));
600 outboundLimit.pushKV("bytes_left_in_cycle", connman.GetOutboundTargetBytesLeft());
601 outboundLimit.pushKV("time_left_in_cycle", count_seconds(connman.GetMaxOutboundTimeLeftInCycle()));
602 obj.pushKV("uploadtarget", std::move(outboundLimit));
603 return obj;
604},
605 };
606}
607
609{
610 UniValue networks(UniValue::VARR);
611 for (int n = 0; n < NET_MAX; ++n) {
612 enum Network network = static_cast<enum Network>(n);
613 if (network == NET_UNROUTABLE || network == NET_INTERNAL) continue;
614 Proxy proxy;
616 GetProxy(network, proxy);
617 obj.pushKV("name", GetNetworkName(network));
618 obj.pushKV("limited", !g_reachable_nets.Contains(network));
619 obj.pushKV("reachable", g_reachable_nets.Contains(network));
620 obj.pushKV("proxy", proxy.IsValid() ? proxy.ToString() : std::string());
621 obj.pushKV("proxy_randomize_credentials", proxy.m_tor_stream_isolation);
622 networks.push_back(std::move(obj));
623 }
624 return networks;
625}
626
628{
629 return RPCHelpMan{"getnetworkinfo",
630 "Returns an object containing various state info regarding P2P networking.\n",
631 {},
632 RPCResult{
633 RPCResult::Type::OBJ, "", "",
634 {
635 {RPCResult::Type::NUM, "version", "the server version"},
636 {RPCResult::Type::STR, "subversion", "the server subversion string"},
637 {RPCResult::Type::NUM, "protocolversion", "the protocol version"},
638 {RPCResult::Type::STR_HEX, "localservices", "the services we offer to the network"},
639 {RPCResult::Type::ARR, "localservicesnames", "the services we offer to the network, in human-readable form",
640 {
641 {RPCResult::Type::STR, "SERVICE_NAME", "the service name"},
642 }},
643 {RPCResult::Type::BOOL, "localrelay", "true if transaction relay is requested from peers"},
644 {RPCResult::Type::NUM, "timeoffset", "the time offset"},
645 {RPCResult::Type::NUM, "connections", "the total number of connections"},
646 {RPCResult::Type::NUM, "connections_in", "the number of inbound connections"},
647 {RPCResult::Type::NUM, "connections_out", "the number of outbound connections"},
648 {RPCResult::Type::BOOL, "networkactive", "whether p2p networking is enabled"},
649 {RPCResult::Type::ARR, "networks", "information per network",
650 {
651 {RPCResult::Type::OBJ, "", "",
652 {
653 {RPCResult::Type::STR, "name", "network (" + Join(GetNetworkNames(), ", ") + ")"},
654 {RPCResult::Type::BOOL, "limited", "is the network limited using -onlynet?"},
655 {RPCResult::Type::BOOL, "reachable", "is the network reachable?"},
656 {RPCResult::Type::STR, "proxy", "(\"host:port\") the proxy that is used for this network, or empty if none"},
657 {RPCResult::Type::BOOL, "proxy_randomize_credentials", "Whether randomized credentials are used"},
658 }},
659 }},
660 {RPCResult::Type::NUM, "relayfee", "minimum relay fee rate for transactions in " + CURRENCY_UNIT + "/kvB"},
661 {RPCResult::Type::NUM, "incrementalfee", "minimum fee rate increment for mempool limiting or replacement in " + CURRENCY_UNIT + "/kvB"},
662 {RPCResult::Type::ARR, "localaddresses", "list of local addresses",
663 {
664 {RPCResult::Type::OBJ, "", "",
665 {
666 {RPCResult::Type::STR, "address", "network address"},
667 {RPCResult::Type::NUM, "port", "network port"},
668 {RPCResult::Type::NUM, "score", "relative score"},
669 }},
670 }},
671 (IsDeprecatedRPCEnabled("warnings") ?
672 RPCResult{RPCResult::Type::STR, "warnings", "any network and blockchain warnings (DEPRECATED)"} :
673 RPCResult{RPCResult::Type::ARR, "warnings", "any network and blockchain warnings (run with `-deprecatedrpc=warnings` to return the latest warning as a single string)",
674 {
675 {RPCResult::Type::STR, "", "warning"},
676 }
677 }
678 ),
679 }
680 },
682 HelpExampleCli("getnetworkinfo", "")
683 + HelpExampleRpc("getnetworkinfo", "")
684 },
685 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
686{
687 LOCK(cs_main);
689 obj.pushKV("version", CLIENT_VERSION);
690 obj.pushKV("subversion", strSubVersion);
691 obj.pushKV("protocolversion",PROTOCOL_VERSION);
692 NodeContext& node = EnsureAnyNodeContext(request.context);
693 if (node.connman) {
694 ServiceFlags services = node.connman->GetLocalServices();
695 obj.pushKV("localservices", strprintf("%016x", services));
696 obj.pushKV("localservicesnames", GetServicesNames(services));
697 }
698 if (node.peerman) {
699 auto peerman_info{node.peerman->GetInfo()};
700 obj.pushKV("localrelay", !peerman_info.ignores_incoming_txs);
701 obj.pushKV("timeoffset", Ticks<std::chrono::seconds>(peerman_info.median_outbound_time_offset));
702 }
703 if (node.connman) {
704 obj.pushKV("networkactive", node.connman->GetNetworkActive());
705 obj.pushKV("connections", node.connman->GetNodeCount(ConnectionDirection::Both));
706 obj.pushKV("connections_in", node.connman->GetNodeCount(ConnectionDirection::In));
707 obj.pushKV("connections_out", node.connman->GetNodeCount(ConnectionDirection::Out));
708 }
709 obj.pushKV("networks", GetNetworksInfo());
710 if (node.mempool) {
711 // Those fields can be deprecated, to be replaced by the getmempoolinfo fields
712 obj.pushKV("relayfee", ValueFromAmount(node.mempool->m_opts.min_relay_feerate.GetFeePerK()));
713 obj.pushKV("incrementalfee", ValueFromAmount(node.mempool->m_opts.incremental_relay_feerate.GetFeePerK()));
714 }
715 UniValue localAddresses(UniValue::VARR);
716 {
718 for (const std::pair<const CNetAddr, LocalServiceInfo> &item : mapLocalHost)
719 {
721 rec.pushKV("address", item.first.ToStringAddr());
722 rec.pushKV("port", item.second.nPort);
723 rec.pushKV("score", item.second.nScore);
724 localAddresses.push_back(std::move(rec));
725 }
726 }
727 obj.pushKV("localaddresses", std::move(localAddresses));
728 obj.pushKV("warnings", node::GetWarningsForRpc(*CHECK_NONFATAL(node.warnings), IsDeprecatedRPCEnabled("warnings")));
729 return obj;
730},
731 };
732}
733
735{
736 return RPCHelpMan{
737 "setban",
738 "Attempts to add or remove an IP/Subnet from the banned list.\n",
739 {
740 {"subnet", RPCArg::Type::STR, RPCArg::Optional::NO, "The IP/Subnet (see getpeerinfo for nodes IP) with an optional netmask (default is /32 = single IP)"},
741 {"command", RPCArg::Type::STR, RPCArg::Optional::NO, "'add' to add an IP/Subnet to the list, 'remove' to remove an IP/Subnet from the list"},
742 {"bantime", RPCArg::Type::NUM, RPCArg::Default{0}, "time in seconds how long (or until when if [absolute] is set) the IP is banned (0 or empty means using the default time of 24h which can also be overwritten by the -bantime startup argument)"},
743 {"absolute", RPCArg::Type::BOOL, RPCArg::Default{false}, "If set, the bantime must be an absolute timestamp expressed in " + UNIX_EPOCH_TIME},
744 },
747 HelpExampleCli("setban", "\"192.168.0.6\" \"add\" 86400")
748 + HelpExampleCli("setban", "\"192.168.0.0/24\" \"add\"")
749 + HelpExampleRpc("setban", "\"192.168.0.6\", \"add\", 86400")
750 },
751 [&](const RPCHelpMan& help, const JSONRPCRequest& request) -> UniValue
752{
753 std::string strCommand;
754 if (!request.params[1].isNull())
755 strCommand = request.params[1].get_str();
756 if (strCommand != "add" && strCommand != "remove") {
757 throw std::runtime_error(help.ToString());
758 }
759 NodeContext& node = EnsureAnyNodeContext(request.context);
760 BanMan& banman = EnsureBanman(node);
761
762 CSubNet subNet;
763 CNetAddr netAddr;
764 bool isSubnet = false;
765
766 if (request.params[0].get_str().find('/') != std::string::npos)
767 isSubnet = true;
768
769 if (!isSubnet) {
770 const std::optional<CNetAddr> addr{LookupHost(request.params[0].get_str(), false)};
771 if (addr.has_value()) {
772 netAddr = static_cast<CNetAddr>(MaybeFlipIPv6toCJDNS(CService{addr.value(), /*port=*/0}));
773 }
774 }
775 else
776 subNet = LookupSubNet(request.params[0].get_str());
777
778 if (! (isSubnet ? subNet.IsValid() : netAddr.IsValid()) )
779 throw JSONRPCError(RPC_CLIENT_INVALID_IP_OR_SUBNET, "Error: Invalid IP/Subnet");
780
781 if (strCommand == "add")
782 {
783 if (isSubnet ? banman.IsBanned(subNet) : banman.IsBanned(netAddr)) {
784 throw JSONRPCError(RPC_CLIENT_NODE_ALREADY_ADDED, "Error: IP/Subnet already banned");
785 }
786
787 int64_t banTime = 0; //use standard bantime if not specified
788 if (!request.params[2].isNull())
789 banTime = request.params[2].getInt<int64_t>();
790
791 const bool absolute{request.params[3].isNull() ? false : request.params[3].get_bool()};
792
793 if (absolute && banTime < GetTime()) {
794 throw JSONRPCError(RPC_INVALID_PARAMETER, "Error: Absolute timestamp is in the past");
795 }
796
797 if (isSubnet) {
798 banman.Ban(subNet, banTime, absolute);
799 if (node.connman) {
800 node.connman->DisconnectNode(subNet);
801 }
802 } else {
803 banman.Ban(netAddr, banTime, absolute);
804 if (node.connman) {
805 node.connman->DisconnectNode(netAddr);
806 }
807 }
808 }
809 else if(strCommand == "remove")
810 {
811 if (!( isSubnet ? banman.Unban(subNet) : banman.Unban(netAddr) )) {
812 throw JSONRPCError(RPC_CLIENT_INVALID_IP_OR_SUBNET, "Error: Unban failed. Requested address/subnet was not previously manually banned.");
813 }
814 }
815 return UniValue::VNULL;
816},
817 };
818}
819
821{
822 return RPCHelpMan{
823 "listbanned",
824 "List all manually banned IPs/Subnets.\n",
825 {},
827 {
828 {RPCResult::Type::OBJ, "", "",
829 {
830 {RPCResult::Type::STR, "address", "The IP/Subnet of the banned node"},
831 {RPCResult::Type::NUM_TIME, "ban_created", "The " + UNIX_EPOCH_TIME + " the ban was created"},
832 {RPCResult::Type::NUM_TIME, "banned_until", "The " + UNIX_EPOCH_TIME + " the ban expires"},
833 {RPCResult::Type::NUM_TIME, "ban_duration", "The ban duration, in seconds"},
834 {RPCResult::Type::NUM_TIME, "time_remaining", "The time remaining until the ban expires, in seconds"},
835 }},
836 }},
838 HelpExampleCli("listbanned", "")
839 + HelpExampleRpc("listbanned", "")
840 },
841 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
842{
843 BanMan& banman = EnsureAnyBanman(request.context);
844
845 banmap_t banMap;
846 banman.GetBanned(banMap);
847 const int64_t current_time{GetTime()};
848
849 UniValue bannedAddresses(UniValue::VARR);
850 for (const auto& entry : banMap)
851 {
852 const CBanEntry& banEntry = entry.second;
854 rec.pushKV("address", entry.first.ToString());
855 rec.pushKV("ban_created", banEntry.nCreateTime);
856 rec.pushKV("banned_until", banEntry.nBanUntil);
857 rec.pushKV("ban_duration", (banEntry.nBanUntil - banEntry.nCreateTime));
858 rec.pushKV("time_remaining", (banEntry.nBanUntil - current_time));
859
860 bannedAddresses.push_back(std::move(rec));
861 }
862
863 return bannedAddresses;
864},
865 };
866}
867
869{
870 return RPCHelpMan{
871 "clearbanned",
872 "Clear all banned IPs.\n",
873 {},
876 HelpExampleCli("clearbanned", "")
877 + HelpExampleRpc("clearbanned", "")
878 },
879 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
880{
881 BanMan& banman = EnsureAnyBanman(request.context);
882
883 banman.ClearBanned();
884
885 return UniValue::VNULL;
886},
887 };
888}
889
891{
892 return RPCHelpMan{
893 "setnetworkactive",
894 "Disable/enable all p2p network activity.\n",
895 {
896 {"state", RPCArg::Type::BOOL, RPCArg::Optional::NO, "true to enable networking, false to disable"},
897 },
898 RPCResult{RPCResult::Type::BOOL, "", "The value that was passed in"},
899 RPCExamples{""},
900 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
901{
902 NodeContext& node = EnsureAnyNodeContext(request.context);
903 CConnman& connman = EnsureConnman(node);
904
905 connman.SetNetworkActive(request.params[0].get_bool());
906
907 return connman.GetNetworkActive();
908},
909 };
910}
911
913{
914 return RPCHelpMan{"getnodeaddresses",
915 "Return known addresses, after filtering for quality and recency.\n"
916 "These can potentially be used to find new peers in the network.\n"
917 "The total number of addresses known to the node may be higher.",
918 {
919 {"count", RPCArg::Type::NUM, RPCArg::Default{1}, "The maximum number of addresses to return. Specify 0 to return all known addresses."},
920 {"network", RPCArg::Type::STR, RPCArg::DefaultHint{"all networks"}, "Return only addresses of the specified network. Can be one of: " + Join(GetNetworkNames(), ", ") + "."},
921 },
922 RPCResult{
923 RPCResult::Type::ARR, "", "",
924 {
925 {RPCResult::Type::OBJ, "", "",
926 {
927 {RPCResult::Type::NUM_TIME, "time", "The " + UNIX_EPOCH_TIME + " when the node was last seen"},
928 {RPCResult::Type::NUM, "services", "The services offered by the node"},
929 {RPCResult::Type::STR, "address", "The address of the node"},
930 {RPCResult::Type::NUM, "port", "The port number of the node"},
931 {RPCResult::Type::STR, "network", "The network (" + Join(GetNetworkNames(), ", ") + ") the node connected through"},
932 }},
933 }
934 },
936 HelpExampleCli("getnodeaddresses", "8")
937 + HelpExampleCli("getnodeaddresses", "4 \"i2p\"")
938 + HelpExampleCli("-named getnodeaddresses", "network=onion count=12")
939 + HelpExampleRpc("getnodeaddresses", "8")
940 + HelpExampleRpc("getnodeaddresses", "4, \"i2p\"")
941 },
942 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
943{
944 NodeContext& node = EnsureAnyNodeContext(request.context);
945 const CConnman& connman = EnsureConnman(node);
946
947 const int count{request.params[0].isNull() ? 1 : request.params[0].getInt<int>()};
948 if (count < 0) throw JSONRPCError(RPC_INVALID_PARAMETER, "Address count out of range");
949
950 const std::optional<Network> network{request.params[1].isNull() ? std::nullopt : std::optional<Network>{ParseNetwork(request.params[1].get_str())}};
951 if (network == NET_UNROUTABLE) {
952 throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Network not recognized: %s", request.params[1].get_str()));
953 }
954
955 // returns a shuffled list of CAddress
956 const std::vector<CAddress> vAddr{connman.GetAddresses(count, /*max_pct=*/0, network)};
958
959 for (const CAddress& addr : vAddr) {
961 obj.pushKV("time", int64_t{TicksSinceEpoch<std::chrono::seconds>(addr.nTime)});
962 obj.pushKV("services", (uint64_t)addr.nServices);
963 obj.pushKV("address", addr.ToStringAddr());
964 obj.pushKV("port", addr.GetPort());
965 obj.pushKV("network", GetNetworkName(addr.GetNetClass()));
966 ret.push_back(std::move(obj));
967 }
968 return ret;
969},
970 };
971}
972
974{
975 return RPCHelpMan{"addpeeraddress",
976 "Add the address of a potential peer to an address manager table. This RPC is for testing only.",
977 {
978 {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The IP address of the peer"},
979 {"port", RPCArg::Type::NUM, RPCArg::Optional::NO, "The port of the peer"},
980 {"tried", RPCArg::Type::BOOL, RPCArg::Default{false}, "If true, attempt to add the peer to the tried addresses table"},
981 },
982 RPCResult{
983 RPCResult::Type::OBJ, "", "",
984 {
985 {RPCResult::Type::BOOL, "success", "whether the peer address was successfully added to the address manager table"},
986 {RPCResult::Type::STR, "error", /*optional=*/true, "error description, if the address could not be added"},
987 },
988 },
990 HelpExampleCli("addpeeraddress", "\"1.2.3.4\" 8333 true")
991 + HelpExampleRpc("addpeeraddress", "\"1.2.3.4\", 8333, true")
992 },
993 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
994{
995 AddrMan& addrman = EnsureAnyAddrman(request.context);
996
997 const std::string& addr_string{request.params[0].get_str()};
998 const auto port{request.params[1].getInt<uint16_t>()};
999 const bool tried{request.params[2].isNull() ? false : request.params[2].get_bool()};
1000
1002 std::optional<CNetAddr> net_addr{LookupHost(addr_string, false)};
1003 bool success{false};
1004
1005 if (net_addr.has_value()) {
1006 CService service{net_addr.value(), port};
1008 address.nTime = Now<NodeSeconds>();
1009 // The source address is set equal to the address. This is equivalent to the peer
1010 // announcing itself.
1011 if (addrman.Add({address}, address)) {
1012 success = true;
1013 if (tried) {
1014 // Attempt to move the address to the tried addresses table.
1015 if (!addrman.Good(address)) {
1016 success = false;
1017 obj.pushKV("error", "failed-adding-to-tried");
1018 }
1019 }
1020 } else {
1021 obj.pushKV("error", "failed-adding-to-new");
1022 }
1023 }
1024
1025 obj.pushKV("success", success);
1026 return obj;
1027},
1028 };
1029}
1030
1032{
1033 return RPCHelpMan{
1034 "sendmsgtopeer",
1035 "Send a p2p message to a peer specified by id.\n"
1036 "The message type and body must be provided, the message header will be generated.\n"
1037 "This RPC is for testing only.",
1038 {
1039 {"peer_id", RPCArg::Type::NUM, RPCArg::Optional::NO, "The peer to send the message to."},
1040 {"msg_type", RPCArg::Type::STR, RPCArg::Optional::NO, strprintf("The message type (maximum length %i)", CMessageHeader::MESSAGE_TYPE_SIZE)},
1041 {"msg", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The serialized message body to send, in hex, without a message header"},
1042 },
1043 RPCResult{RPCResult::Type::OBJ, "", "", std::vector<RPCResult>{}},
1045 HelpExampleCli("sendmsgtopeer", "0 \"addr\" \"ffffff\"") + HelpExampleRpc("sendmsgtopeer", "0 \"addr\" \"ffffff\"")},
1046 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue {
1047 const NodeId peer_id{request.params[0].getInt<int64_t>()};
1048 const std::string& msg_type{request.params[1].get_str()};
1049 if (msg_type.size() > CMessageHeader::MESSAGE_TYPE_SIZE) {
1050 throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Error: msg_type too long, max length is %i", CMessageHeader::MESSAGE_TYPE_SIZE));
1051 }
1052 auto msg{TryParseHex<unsigned char>(request.params[2].get_str())};
1053 if (!msg.has_value()) {
1054 throw JSONRPCError(RPC_INVALID_PARAMETER, "Error parsing input for msg");
1055 }
1056
1057 NodeContext& node = EnsureAnyNodeContext(request.context);
1058 CConnman& connman = EnsureConnman(node);
1059
1060 CSerializedNetMsg msg_ser;
1061 msg_ser.data = msg.value();
1062 msg_ser.m_type = msg_type;
1063
1064 bool success = connman.ForNode(peer_id, [&](CNode* node) {
1065 connman.PushMessage(node, std::move(msg_ser));
1066 return true;
1067 });
1068
1069 if (!success) {
1070 throw JSONRPCError(RPC_MISC_ERROR, "Error: Could not send message to peer");
1071 }
1072
1074 return ret;
1075 },
1076 };
1077}
1078
1080{
1081 return RPCHelpMan{
1082 "getaddrmaninfo",
1083 "Provides information about the node's address manager by returning the number of "
1084 "addresses in the `new` and `tried` tables and their sum for all networks.\n",
1085 {},
1086 RPCResult{
1087 RPCResult::Type::OBJ_DYN, "", "json object with network type as keys", {
1088 {RPCResult::Type::OBJ, "network", "the network (" + Join(GetNetworkNames(), ", ") + ", all_networks)", {
1089 {RPCResult::Type::NUM, "new", "number of addresses in the new table, which represent potential peers the node has discovered but hasn't yet successfully connected to."},
1090 {RPCResult::Type::NUM, "tried", "number of addresses in the tried table, which represent peers the node has successfully connected to in the past."},
1091 {RPCResult::Type::NUM, "total", "total number of addresses in both new/tried tables"},
1092 }},
1093 }},
1094 RPCExamples{HelpExampleCli("getaddrmaninfo", "") + HelpExampleRpc("getaddrmaninfo", "")},
1095 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue {
1096 AddrMan& addrman = EnsureAnyAddrman(request.context);
1097
1099 for (int n = 0; n < NET_MAX; ++n) {
1100 enum Network network = static_cast<enum Network>(n);
1101 if (network == NET_UNROUTABLE || network == NET_INTERNAL) continue;
1103 obj.pushKV("new", addrman.Size(network, true));
1104 obj.pushKV("tried", addrman.Size(network, false));
1105 obj.pushKV("total", addrman.Size(network));
1106 ret.pushKV(GetNetworkName(network), std::move(obj));
1107 }
1109 obj.pushKV("new", addrman.Size(std::nullopt, true));
1110 obj.pushKV("tried", addrman.Size(std::nullopt, false));
1111 obj.pushKV("total", addrman.Size());
1112 ret.pushKV("all_networks", std::move(obj));
1113 return ret;
1114 },
1115 };
1116}
1117
1118UniValue AddrmanEntryToJSON(const AddrInfo& info, const CConnman& connman)
1119{
1121 ret.pushKV("address", info.ToStringAddr());
1122 const uint32_t mapped_as{connman.GetMappedAS(info)};
1123 if (mapped_as) {
1124 ret.pushKV("mapped_as", mapped_as);
1125 }
1126 ret.pushKV("port", info.GetPort());
1127 ret.pushKV("services", (uint64_t)info.nServices);
1128 ret.pushKV("time", int64_t{TicksSinceEpoch<std::chrono::seconds>(info.nTime)});
1129 ret.pushKV("network", GetNetworkName(info.GetNetClass()));
1130 ret.pushKV("source", info.source.ToStringAddr());
1131 ret.pushKV("source_network", GetNetworkName(info.source.GetNetClass()));
1132 const uint32_t source_mapped_as{connman.GetMappedAS(info.source)};
1133 if (source_mapped_as) {
1134 ret.pushKV("source_mapped_as", source_mapped_as);
1135 }
1136 return ret;
1137}
1138
1139UniValue AddrmanTableToJSON(const std::vector<std::pair<AddrInfo, AddressPosition>>& tableInfos, const CConnman& connman)
1140{
1141 UniValue table(UniValue::VOBJ);
1142 for (const auto& e : tableInfos) {
1143 AddrInfo info = e.first;
1144 AddressPosition location = e.second;
1145 std::ostringstream key;
1146 key << location.bucket << "/" << location.position;
1147 // Address manager tables have unique entries so there is no advantage
1148 // in using UniValue::pushKV, which checks if the key already exists
1149 // in O(N). UniValue::pushKVEnd is used instead which currently is O(1).
1150 table.pushKVEnd(key.str(), AddrmanEntryToJSON(info, connman));
1151 }
1152 return table;
1153}
1154
1156{
1157 return RPCHelpMan{"getrawaddrman",
1158 "EXPERIMENTAL warning: this call may be changed in future releases.\n"
1159 "\nReturns information on all address manager entries for the new and tried tables.\n",
1160 {},
1161 RPCResult{
1162 RPCResult::Type::OBJ_DYN, "", "", {
1163 {RPCResult::Type::OBJ_DYN, "table", "buckets with addresses in the address manager table ( new, tried )", {
1164 {RPCResult::Type::OBJ, "bucket/position", "the location in the address manager table (<bucket>/<position>)", {
1165 {RPCResult::Type::STR, "address", "The address of the node"},
1166 {RPCResult::Type::NUM, "mapped_as", /*optional=*/true, "Mapped AS (Autonomous System) number at the end of the BGP route to the peer, used for diversifying peer selection (only displayed if the -asmap config option is set)"},
1167 {RPCResult::Type::NUM, "port", "The port number of the node"},
1168 {RPCResult::Type::STR, "network", "The network (" + Join(GetNetworkNames(), ", ") + ") of the address"},
1169 {RPCResult::Type::NUM, "services", "The services offered by the node"},
1170 {RPCResult::Type::NUM_TIME, "time", "The " + UNIX_EPOCH_TIME + " when the node was last seen"},
1171 {RPCResult::Type::STR, "source", "The address that relayed the address to us"},
1172 {RPCResult::Type::STR, "source_network", "The network (" + Join(GetNetworkNames(), ", ") + ") of the source address"},
1173 {RPCResult::Type::NUM, "source_mapped_as", /*optional=*/true, "Mapped AS (Autonomous System) number at the end of the BGP route to the source, used for diversifying peer selection (only displayed if the -asmap config option is set)"}
1174 }}
1175 }}
1176 }
1177 },
1179 HelpExampleCli("getrawaddrman", "")
1180 + HelpExampleRpc("getrawaddrman", "")
1181 },
1182 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue {
1183 AddrMan& addrman = EnsureAnyAddrman(request.context);
1184 NodeContext& node_context = EnsureAnyNodeContext(request.context);
1185 CConnman& connman = EnsureConnman(node_context);
1186
1188 ret.pushKV("new", AddrmanTableToJSON(addrman.GetEntries(false), connman));
1189 ret.pushKV("tried", AddrmanTableToJSON(addrman.GetEntries(true), connman));
1190 return ret;
1191 },
1192 };
1193}
1194
1196{
1197 static const CRPCCommand commands[]{
1198 {"network", &getconnectioncount},
1199 {"network", &ping},
1200 {"network", &getpeerinfo},
1201 {"network", &addnode},
1202 {"network", &disconnectnode},
1203 {"network", &getaddednodeinfo},
1204 {"network", &getnettotals},
1205 {"network", &getnetworkinfo},
1206 {"network", &setban},
1207 {"network", &listbanned},
1208 {"network", &clearbanned},
1209 {"network", &setnetworkactive},
1210 {"network", &getnodeaddresses},
1211 {"network", &getaddrmaninfo},
1212 {"hidden", &addconnection},
1213 {"hidden", &addpeeraddress},
1214 {"hidden", &sendmsgtopeer},
1215 {"hidden", &getrawaddrman},
1216 };
1217 for (const auto& c : commands) {
1218 t.appendCommand(c.name, &c);
1219 }
1220}
int ret
const auto command
const CChainParams & Params()
Return the currently selected parameters.
#define CHECK_NONFATAL(condition)
Identity function.
Definition: check.h:102
Extended statistics about a CAddress.
Definition: addrman_impl.h:46
CNetAddr source
where knowledge about this address first came from
Definition: addrman_impl.h:55
Stochastic address manager.
Definition: addrman.h:89
size_t Size(std::optional< Network > net=std::nullopt, std::optional< bool > in_new=std::nullopt) const
Return size information about addrman.
Definition: addrman.cpp:1297
std::vector< std::pair< AddrInfo, AddressPosition > > GetEntries(bool from_tried) const
Returns an information-location pair for all addresses in the selected addrman table.
Definition: addrman.cpp:1337
bool Good(const CService &addr, NodeSeconds time=Now< NodeSeconds >())
Mark an address record as accessible and attempt to move it to addrman's tried table.
Definition: addrman.cpp:1307
bool Add(const std::vector< CAddress > &vAddr, const CNetAddr &source, std::chrono::seconds time_penalty=0s)
Attempt to add one or more addresses to addrman's new table.
Definition: addrman.cpp:1302
Definition: banman.h:64
void Ban(const CNetAddr &net_addr, int64_t ban_time_offset=0, bool since_unix_epoch=false) EXCLUSIVE_LOCKS_REQUIRED(!m_banned_mutex)
Definition: banman.cpp:118
bool IsBanned(const CNetAddr &net_addr) EXCLUSIVE_LOCKS_REQUIRED(!m_banned_mutex)
Return whether net_addr is banned.
Definition: banman.cpp:89
void GetBanned(banmap_t &banmap) EXCLUSIVE_LOCKS_REQUIRED(!m_banned_mutex)
Definition: banman.cpp:174
void ClearBanned() EXCLUSIVE_LOCKS_REQUIRED(!m_banned_mutex)
Definition: banman.cpp:72
bool Unban(const CNetAddr &net_addr) EXCLUSIVE_LOCKS_REQUIRED(!m_banned_mutex)
Definition: banman.cpp:156
A CService with information about it as peer.
Definition: protocol.h:367
ServiceFlags nServices
Serialized as uint64_t in V1, and as CompactSize in V2.
Definition: protocol.h:459
NodeSeconds nTime
Always included in serialization. The behavior is unspecified if the value is not representable as ui...
Definition: protocol.h:457
Definition: net_types.h:15
int64_t nCreateTime
Definition: net_types.h:19
int64_t nBanUntil
Definition: net_types.h:20
ChainType GetChainType() const
Return the chain type.
Definition: chainparams.h:103
Definition: net.h:1053
bool ForNode(NodeId id, std::function< bool(CNode *pnode)> func)
Definition: net.cpp:3913
bool RemoveAddedNode(const std::string &node) EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex)
Definition: net.cpp:3569
bool GetNetworkActive() const
Definition: net.h:1137
bool OutboundTargetReached(bool historicalBlockServingLimit) const EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex)
check if the outbound target is reached if param historicalBlockServingLimit is set true,...
Definition: net.cpp:3732
uint64_t GetMaxOutboundTarget() const EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex)
Definition: net.cpp:3698
std::chrono::seconds GetMaxOutboundTimeframe() const
Definition: net.cpp:3705
ServiceFlags GetLocalServices() const
Used to convey which local services we are offering peers during node connection.
Definition: net.cpp:3775
bool AddNode(const AddedNodeParams &add) EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex)
Definition: net.cpp:3555
bool DisconnectNode(const std::string &node)
Definition: net.cpp:3632
bool AddConnection(const std::string &address, ConnectionType conn_type, bool use_v2transport) EXCLUSIVE_LOCKS_REQUIRED(!m_unused_i2p_sessions_mutex)
Attempts to open a connection.
Definition: net.cpp:1859
std::vector< AddedNodeInfo > GetAddedNodeInfo(bool include_connected) const EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex)
Definition: net.cpp:2891
size_t GetNodeCount(ConnectionDirection) const
Definition: net.cpp:3592
uint32_t GetMappedAS(const CNetAddr &addr) const
Definition: net.cpp:3615
void GetNodeStats(std::vector< CNodeStats > &vstats) const
Definition: net.cpp:3620
uint64_t GetTotalBytesRecv() const
Definition: net.cpp:3763
void SetNetworkActive(bool active)
Definition: net.cpp:3190
std::chrono::seconds GetMaxOutboundTimeLeftInCycle() const EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex)
Definition: net.cpp:3710
std::vector< CAddress > GetAddresses(size_t max_addresses, size_t max_pct, std::optional< Network > network, const bool filtered=true) const
Return all or many randomly selected addresses, optionally by network.
Definition: net.cpp:3499
uint64_t GetTotalBytesSent() const EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex)
Definition: net.cpp:3768
uint64_t GetOutboundTargetBytesLeft() const EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex)
response the bytes left in the current max outbound cycle in case of no limit, it will always respons...
Definition: net.cpp:3753
void PushMessage(CNode *pnode, CSerializedNetMsg &&msg) EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex)
Definition: net.cpp:3866
void OpenNetworkConnection(const CAddress &addrConnect, bool fCountFailure, CountingSemaphoreGrant<> &&grant_outbound, const char *strDest, ConnectionType conn_type, bool use_v2transport) EXCLUSIVE_LOCKS_REQUIRED(!m_unused_i2p_sessions_mutex)
Definition: net.cpp:2981
static constexpr size_t MESSAGE_TYPE_SIZE
Definition: protocol.h:31
Network address.
Definition: netaddress.h:112
Network GetNetClass() const
Definition: netaddress.cpp:678
std::string ToStringAddr() const
Definition: netaddress.cpp:584
bool IsValid() const
Definition: netaddress.cpp:428
Information about a peer.
Definition: net.h:674
RPC command dispatcher.
Definition: server.h:127
A combination of a network address (CNetAddr) and a (TCP) port.
Definition: netaddress.h:531
uint16_t GetPort() const
Definition: netaddress.cpp:839
bool IsValid() 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.
Definition: netbase.h:59
std::string ToString() const
Definition: netbase.h:82
bool IsValid() const
Definition: netbase.h:70
bool m_tor_stream_isolation
Definition: netbase.h:68
std::string ToString() const
Definition: util.cpp:773
auto Arg(std::string_view key) const
Helper to get a required or default-valued request argument.
Definition: util.h:440
auto MaybeArg(std::string_view key) const
Helper to get an optional request argument.
Definition: util.h:472
bool Contains(Network net) const EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
Definition: netbase.h:124
void push_back(UniValue val)
Definition: univalue.cpp:104
const std::string & get_str() const
@ VNULL
Definition: univalue.h:24
@ VOBJ
Definition: univalue.h:24
@ VARR
Definition: univalue.h:24
bool isNull() const
Definition: univalue.h:79
void pushKVEnd(std::string key, UniValue val)
Definition: univalue.cpp:118
bool isStr() const
Definition: univalue.h:83
Int getInt() const
Definition: univalue.h:138
void pushKV(std::string key, UniValue val)
Definition: univalue.cpp:126
static const int CLIENT_VERSION
Definition: clientversion.h:26
std::string TransportTypeAsString(TransportProtocolType transport_type)
Convert TransportProtocolType enum to a string value.
std::string ConnectionTypeAsString(ConnectionType conn_type)
Convert ConnectionType enum to a string value.
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 requested via the addnode RPC or the -a...
@ 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.
@ ADDR_FETCH
AddrFetch connections are short lived connections used to solicit addresses from peers.
UniValue ValueFromAmount(const CAmount amount)
Definition: core_write.cpp:26
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
Definition: cs_main.cpp:8
const std::string CURRENCY_UNIT
Definition: feerate.h:17
Definition: messages.h:20
UniValue GetWarningsForRpc(const Warnings &warnings, bool use_deprecated)
RPC helper function that wraps warnings.GetMessages().
Definition: warnings.cpp:54
std::string TrimString(std::string_view str, std::string_view pattern=" \f\n\r\t\v")
Definition: string.h:156
auto Join(const C &container, const S &separator, UnaryOp unary_op)
Join all container items.
Definition: string.h:192
std::string strSubVersion
Subversion as sent to the P2P network in version messages.
Definition: net.cpp:119
const std::string NET_MESSAGE_TYPE_OTHER
Definition: net.cpp:107
GlobalMutex g_maplocalhost_mutex
Definition: net.cpp:117
static const int MAX_ADDNODE_CONNECTIONS
Maximum number of addnode outgoing nodes.
Definition: net.h:70
int64_t NodeId
Definition: net.h:98
const std::vector< std::string > NET_PERMISSIONS_DOC
std::map< CSubNet, CBanEntry > banmap_t
Definition: net_types.h:41
Network
A network type.
Definition: netaddress.h:32
@ NET_MAX
Dummy value to indicate the number of NET_* constants.
Definition: netaddress.h:56
@ NET_UNROUTABLE
Addresses from these networks are not publicly routable on the global Internet.
Definition: netaddress.h:34
@ NET_INTERNAL
A set of addresses that represent the hash of a string or FQDN.
Definition: netaddress.h:53
CSubNet LookupSubNet(const std::string &subnet_str)
Parse and resolve a specified subnet string into the appropriate internal representation.
Definition: netbase.cpp:816
std::vector< CNetAddr > LookupHost(const std::string &name, unsigned int nMaxSolutions, bool fAllowLookup, DNSLookupFn dns_lookup_function)
Resolve a host string to its corresponding network addresses.
Definition: netbase.cpp:177
std::string GetNetworkName(enum Network net)
Definition: netbase.cpp:118
enum Network ParseNetwork(const std::string &net_in)
Definition: netbase.cpp:100
CService MaybeFlipIPv6toCJDNS(const CService &service)
If an IPv6 address belongs to the address range used by the CJDNS network and the CJDNS network is re...
Definition: netbase.cpp:941
ReachableNets g_reachable_nets
Definition: netbase.cpp:43
bool GetProxy(enum Network net, Proxy &proxyInfoOut)
Definition: netbase.cpp:713
std::vector< std::string > GetNetworkNames(bool append_unroutable)
Return a vector of publicly routable Network names; optionally append NET_UNROUTABLE.
Definition: netbase.cpp:134
std::vector< std::string > serviceFlagsToStr(uint64_t flags)
Convert service flags (a bitmask of NODE_*) to human readable strings.
Definition: protocol.cpp:108
ServiceFlags
nServices flags
Definition: protocol.h:309
@ NODE_P2P_V2
Definition: protocol.h:330
@ NODE_WITNESS
Definition: protocol.h:320
@ NODE_NETWORK
Definition: protocol.h:315
static const int PROTOCOL_VERSION
network protocol versioning
UniValue JSONRPCError(int code, const std::string &message)
Definition: request.cpp:70
const std::vector< std::string > CONNECTION_TYPE_DOC
Definition: net.cpp:45
void RegisterNetRPCCommands(CRPCTable &t)
Definition: net.cpp:1195
static RPCHelpMan getnetworkinfo()
Definition: net.cpp:627
static RPCHelpMan addconnection()
Definition: net.cpp:374
static RPCHelpMan getaddednodeinfo()
Definition: net.cpp:484
static RPCHelpMan clearbanned()
Definition: net.cpp:868
static RPCHelpMan getnettotals()
Definition: net.cpp:558
static RPCHelpMan getaddrmaninfo()
Definition: net.cpp:1079
static RPCHelpMan addnode()
Definition: net.cpp:310
static RPCHelpMan getnodeaddresses()
Definition: net.cpp:912
static RPCHelpMan setban()
Definition: net.cpp:734
static RPCHelpMan getrawaddrman()
Definition: net.cpp:1155
static UniValue GetNetworksInfo()
Definition: net.cpp:608
static RPCHelpMan ping()
Definition: net.cpp:83
UniValue AddrmanTableToJSON(const std::vector< std::pair< AddrInfo, AddressPosition > > &tableInfos, const CConnman &connman)
Definition: net.cpp:1139
static RPCHelpMan getconnectioncount()
Definition: net.cpp:60
static RPCHelpMan disconnectnode()
Definition: net.cpp:437
static RPCHelpMan listbanned()
Definition: net.cpp:820
const std::vector< std::string > TRANSPORT_TYPE_DOC
Definition: net.cpp:54
static UniValue GetServicesNames(ServiceFlags services)
Returns, given services flags, a list of humanly readable (known) network services.
Definition: net.cpp:109
static RPCHelpMan setnetworkactive()
Definition: net.cpp:890
static RPCHelpMan addpeeraddress()
Definition: net.cpp:973
static RPCHelpMan getpeerinfo()
Definition: net.cpp:120
UniValue AddrmanEntryToJSON(const AddrInfo &info, const CConnman &connman)
Definition: net.cpp:1118
static RPCHelpMan sendmsgtopeer()
Definition: net.cpp:1031
@ RPC_CLIENT_NODE_NOT_CONNECTED
Node to disconnect not found in connected nodes.
Definition: protocol.h:62
@ RPC_CLIENT_INVALID_IP_OR_SUBNET
Invalid IP/Subnet.
Definition: protocol.h:63
@ RPC_MISC_ERROR
General application defined errors.
Definition: protocol.h:40
@ RPC_CLIENT_NODE_ALREADY_ADDED
Node is already added.
Definition: protocol.h:60
@ RPC_INVALID_PARAMS
Definition: protocol.h:33
@ RPC_INVALID_PARAMETER
Invalid, missing or duplicate parameter.
Definition: protocol.h:44
@ RPC_CLIENT_NODE_NOT_ADDED
Node has not been added before.
Definition: protocol.h:61
@ RPC_CLIENT_NODE_CAPACITY_REACHED
Max number of outbound or block-relay connections already open.
Definition: protocol.h:65
std::string HelpExampleCli(const std::string &methodname, const std::string &args)
Definition: util.cpp:186
std::string HelpExampleRpc(const std::string &methodname, const std::string &args)
Definition: util.cpp:204
const std::string UNIX_EPOCH_TIME
String used to describe UNIX epoch time in documentation, factored out to a constant for consistency.
Definition: util.cpp:46
bool IsDeprecatedRPCEnabled(const std::string &method)
Definition: server.cpp:345
static RPCHelpMan help()
Definition: server.cpp:127
BanMan & EnsureBanman(const NodeContext &node)
Definition: server_util.cpp:48
AddrMan & EnsureAnyAddrman(const std::any &context)
NodeContext & EnsureAnyNodeContext(const std::any &context)
Definition: server_util.cpp:25
BanMan & EnsureAnyBanman(const std::any &context)
Definition: server_util.cpp:56
PeerManager & EnsurePeerman(const NodeContext &node)
CConnman & EnsureConnman(const NodeContext &node)
Location information for an address in AddrMan.
Definition: addrman.h:35
const int bucket
Definition: addrman.h:48
const int position
Definition: addrman.h:49
std::chrono::microseconds m_ping_wait
std::vector< int > vHeightInFlight
CAmount m_fee_filter_received
std::chrono::seconds time_offset
uint64_t m_addr_rate_limited
uint64_t m_addr_processed
int64_t presync_height
ServiceFlags their_services
std::string m_type
Definition: net.h:132
std::vector< unsigned char > data
Definition: net.h:131
@ STR_HEX
Special type that is a STR with only hex chars.
std::string DefaultHint
Hint for default value.
Definition: util.h:216
@ NO
Required arg.
@ 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.
Definition: context.h:56
#define LOCK(cs)
Definition: sync.h:257
static int count
#define strprintf
Format arguments and return the string or write to given std::ostream (see tinyformat::format doc for...
Definition: tinyformat.h:1172
int64_t GetTime()
DEPRECATED Use either ClockType::now() or Now<TimePointType>() if a cast is needed.
Definition: time.cpp:76
constexpr int64_t count_seconds(std::chrono::seconds t)
Definition: time.h:82