Bitcoin ABC 0.30.5
P2P Digital Currency
net.cpp
Go to the documentation of this file.
1// Copyright (c) 2009-2019 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>
9#include <banman.h>
10#include <chainparams.h>
11#include <clientversion.h>
12#include <config.h>
13#include <net_permissions.h>
14#include <net_processing.h>
15#include <net_types.h> // For banmap_t
16#include <netbase.h>
17#include <node/context.h>
18#include <policy/settings.h>
19#include <rpc/blockchain.h>
20#include <rpc/protocol.h>
21#include <rpc/server_util.h>
22#include <rpc/util.h>
23#include <sync.h>
24#include <timedata.h>
25#include <util/strencodings.h>
26#include <util/string.h>
27#include <util/time.h>
28#include <util/translation.h>
29#include <validation.h>
30#include <version.h>
31#include <warnings.h>
32
33#include <optional>
34
35#include <univalue.h>
36
38
40 return RPCHelpMan{
41 "getconnectioncount",
42 "Returns the number of connections to other nodes.\n",
43 {},
44 RPCResult{RPCResult::Type::NUM, "", "The connection count"},
45 RPCExamples{HelpExampleCli("getconnectioncount", "") +
46 HelpExampleRpc("getconnectioncount", "")},
47 [&](const RPCHelpMan &self, const Config &config,
48 const JSONRPCRequest &request) -> UniValue {
49 NodeContext &node = EnsureAnyNodeContext(request.context);
50 const CConnman &connman = EnsureConnman(node);
51
53 },
54 };
55}
56
57static RPCHelpMan ping() {
58 return RPCHelpMan{
59 "ping",
60 "Requests that a ping be sent to all other nodes, to measure ping "
61 "time.\n"
62 "Results provided in getpeerinfo, pingtime and pingwait fields are "
63 "decimal seconds.\n"
64 "Ping command is handled in queue with all other commands, so it "
65 "measures processing backlog, not just network ping.\n",
66 {},
68 RPCExamples{HelpExampleCli("ping", "") + HelpExampleRpc("ping", "")},
69 [&](const RPCHelpMan &self, const Config &config,
70 const JSONRPCRequest &request) -> UniValue {
71 NodeContext &node = EnsureAnyNodeContext(request.context);
72 PeerManager &peerman = EnsurePeerman(node);
73
74 // Request that each node send a ping during next message processing
75 // pass
76 peerman.SendPings();
77 return NullUniValue;
78 },
79 };
80}
81
83 return RPCHelpMan{
84 "getpeerinfo",
85 "Returns data about each connected network node as a json array of "
86 "objects.\n",
87 {},
90 "",
91 "",
92 {{
94 "",
95 "",
96 {{
97 {RPCResult::Type::NUM, "id", "Peer index"},
98 {RPCResult::Type::STR, "addr",
99 "(host:port) The IP address and port of the peer"},
100 {RPCResult::Type::STR, "addrbind",
101 "(ip:port) Bind address of the connection to the peer"},
102 {RPCResult::Type::STR, "addrlocal",
103 "(ip:port) Local address as reported by the peer"},
104 {RPCResult::Type::NUM, "addr_processed",
105 "The total number of addresses processed, excluding those "
106 "dropped due to rate limiting"},
107 {RPCResult::Type::NUM, "addr_rate_limited",
108 "The total number of addresses dropped due to rate "
109 "limiting"},
110 {RPCResult::Type::STR, "network",
111 "Network (" +
112 Join(GetNetworkNames(/* append_unroutable */ true),
113 ", ") +
114 ")"},
115 {RPCResult::Type::NUM, "mapped_as",
116 "The AS in the BGP route to the peer used for "
117 "diversifying\n"
118 "peer selection (only available if the asmap config flag "
119 "is set)\n"},
120 {RPCResult::Type::STR_HEX, "services",
121 "The services offered"},
123 "servicesnames",
124 "the services offered, in human-readable form",
125 {{RPCResult::Type::STR, "SERVICE_NAME",
126 "the service name if it is recognised"}}},
127 {RPCResult::Type::BOOL, "relaytxes",
128 "Whether peer has asked us to relay transactions to it"},
129 {RPCResult::Type::NUM_TIME, "lastsend",
130 "The " + UNIX_EPOCH_TIME + " of the last send"},
131 {RPCResult::Type::NUM_TIME, "lastrecv",
132 "The " + UNIX_EPOCH_TIME + " of the last receive"},
133 {RPCResult::Type::NUM_TIME, "last_transaction",
134 "The " + UNIX_EPOCH_TIME +
135 " of the last valid transaction received from this "
136 "peer"},
137 {RPCResult::Type::NUM_TIME, "last_block",
138 "The " + UNIX_EPOCH_TIME +
139 " of the last block received from this peer"},
140 {RPCResult::Type::NUM, "bytessent", "The total bytes sent"},
141 {RPCResult::Type::NUM, "bytesrecv",
142 "The total bytes received"},
143 {RPCResult::Type::NUM_TIME, "conntime",
144 "The " + UNIX_EPOCH_TIME + " of the connection"},
145 {RPCResult::Type::NUM, "timeoffset",
146 "The time offset in seconds"},
147 {RPCResult::Type::NUM, "pingtime",
148 "ping time (if available)"},
149 {RPCResult::Type::NUM, "minping",
150 "minimum observed ping time (if any at all)"},
151 {RPCResult::Type::NUM, "pingwait",
152 "ping wait (if non-zero)"},
153 {RPCResult::Type::NUM, "version",
154 "The peer version, such as 70001"},
155 {RPCResult::Type::STR, "subver", "The string version"},
156 {RPCResult::Type::BOOL, "inbound",
157 "Inbound (true) or Outbound (false)"},
158 {RPCResult::Type::BOOL, "bip152_hb_to",
159 "Whether we selected peer as (compact blocks) "
160 "high-bandwidth peer"},
161 {RPCResult::Type::BOOL, "bip152_hb_from",
162 "Whether peer selected us as (compact blocks) "
163 "high-bandwidth peer"},
164 {RPCResult::Type::STR, "connection_type",
165 "Type of connection: \n" +
166 Join(CONNECTION_TYPE_DOC, ",\n") + "."},
167 {RPCResult::Type::NUM, "startingheight",
168 "The starting height (block) of the peer"},
169 {RPCResult::Type::NUM, "presynced_headers",
170 /*optional=*/true,
171 "The current height of header pre-synchronization with "
172 "this peer, or -1 if no low-work sync is in progress"},
173 {RPCResult::Type::NUM, "synced_headers",
174 "The last header we have in common with this peer"},
175 {RPCResult::Type::NUM, "synced_blocks",
176 "The last block we have in common with this peer"},
178 "inflight",
179 "",
180 {
182 "The heights of blocks we're currently asking from "
183 "this peer"},
184 }},
185 {RPCResult::Type::BOOL, "addr_relay_enabled",
186 "Whether we participate in address relay with this peer"},
187 {RPCResult::Type::NUM, "minfeefilter",
188 "The minimum fee rate for transactions this peer accepts"},
190 "bytessent_per_msg",
191 "",
192 {{RPCResult::Type::NUM, "msg",
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 "
197 "object."}}},
199 "bytesrecv_per_msg",
200 "",
201 {{RPCResult::Type::NUM, "msg",
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 '" +
209 {RPCResult::Type::NUM, "availability_score",
210 "Avalanche availability score of this node (if any)"},
211 }},
212 }},
213 },
214 RPCExamples{HelpExampleCli("getpeerinfo", "") +
215 HelpExampleRpc("getpeerinfo", "")},
216 [&](const RPCHelpMan &self, const Config &config,
217 const JSONRPCRequest &request) -> UniValue {
218 NodeContext &node = EnsureAnyNodeContext(request.context);
219 const CConnman &connman = EnsureConnman(node);
220 const PeerManager &peerman = EnsurePeerman(node);
221
222 std::vector<CNodeStats> vstats;
223 connman.GetNodeStats(vstats);
224
226
227 for (const CNodeStats &stats : vstats) {
229 CNodeStateStats statestats;
230 bool fStateStats =
231 peerman.GetNodeStateStats(stats.nodeid, statestats);
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());
236 }
237 if (!(stats.addrLocal.empty())) {
238 obj.pushKV("addrlocal", stats.addrLocal);
239 }
240 obj.pushKV("network", GetNetworkName(stats.m_network));
241 if (stats.m_mapped_as != 0) {
242 obj.pushKV("mapped_as", uint64_t(stats.m_mapped_as));
243 }
244 ServiceFlags services{fStateStats ? statestats.their_services
246 obj.pushKV("services", strprintf("%016x", services));
247 obj.pushKV("servicesnames", GetServicesNames(services));
248 obj.pushKV("lastsend", count_seconds(stats.m_last_send));
249 obj.pushKV("lastrecv", count_seconds(stats.m_last_recv));
250 obj.pushKV("last_transaction",
251 count_seconds(stats.m_last_tx_time));
252 if (node.avalanche) {
253 obj.pushKV("last_proof",
254 count_seconds(stats.m_last_proof_time));
255 }
256 obj.pushKV("last_block",
257 count_seconds(stats.m_last_block_time));
258 obj.pushKV("bytessent", stats.nSendBytes);
259 obj.pushKV("bytesrecv", stats.nRecvBytes);
260 obj.pushKV("conntime", count_seconds(stats.m_connected));
261 obj.pushKV("timeoffset", stats.nTimeOffset);
262 if (stats.m_last_ping_time > 0us) {
263 obj.pushKV("pingtime",
264 CountSecondsDouble(stats.m_last_ping_time));
265 }
266 if (stats.m_min_ping_time < std::chrono::microseconds::max()) {
267 obj.pushKV("minping",
268 CountSecondsDouble(stats.m_min_ping_time));
269 }
270 if (fStateStats && statestats.m_ping_wait > 0s) {
271 obj.pushKV("pingwait",
272 CountSecondsDouble(statestats.m_ping_wait));
273 }
274 obj.pushKV("version", stats.nVersion);
275 // Use the sanitized form of subver here, to avoid tricksy
276 // remote peers from corrupting or modifying the JSON output by
277 // putting special characters in their ver message.
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);
282 if (fStateStats) {
283 obj.pushKV("startingheight", statestats.m_starting_height);
284 obj.pushKV("presynced_headers", statestats.presync_height);
285 obj.pushKV("synced_headers", statestats.nSyncHeight);
286 obj.pushKV("synced_blocks", statestats.nCommonHeight);
287 UniValue heights(UniValue::VARR);
288 for (const int height : statestats.vHeightInFlight) {
289 heights.push_back(height);
290 }
291 obj.pushKV("inflight", heights);
292 obj.pushKV("relaytxes", statestats.m_relay_txs);
293 obj.pushKV("minfeefilter",
294 statestats.m_fee_filter_received);
295 obj.pushKV("addr_relay_enabled",
296 statestats.m_addr_relay_enabled);
297 obj.pushKV("addr_processed", statestats.m_addr_processed);
298 obj.pushKV("addr_rate_limited",
299 statestats.m_addr_rate_limited);
300 }
301 UniValue permissions(UniValue::VARR);
302 for (const auto &permission :
303 NetPermissions::ToStrings(stats.m_permission_flags)) {
304 permissions.push_back(permission);
305 }
306 obj.pushKV("permissions", permissions);
307
308 UniValue sendPerMsgCmd(UniValue::VOBJ);
309 for (const auto &i : stats.mapSendBytesPerMsgCmd) {
310 if (i.second > 0) {
311 sendPerMsgCmd.pushKV(i.first, i.second);
312 }
313 }
314 obj.pushKV("bytessent_per_msg", sendPerMsgCmd);
315
316 UniValue recvPerMsgCmd(UniValue::VOBJ);
317 for (const auto &i : stats.mapRecvBytesPerMsgCmd) {
318 if (i.second > 0) {
319 recvPerMsgCmd.pushKV(i.first, i.second);
320 }
321 }
322 obj.pushKV("bytesrecv_per_msg", recvPerMsgCmd);
323 obj.pushKV("connection_type",
324 ConnectionTypeAsString(stats.m_conn_type));
325
326 if (stats.m_availabilityScore) {
327 obj.pushKV("availability_score",
328 *stats.m_availabilityScore);
329 }
330
331 ret.push_back(obj);
332 }
333
334 return ret;
335 },
336 };
337}
338
340 return RPCHelpMan{
341 "addnode",
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",
348 {
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 "
354 "node once"},
355 },
358 HelpExampleCli("addnode", "\"192.168.0.6:8333\" \"onetry\"") +
359 HelpExampleRpc("addnode", "\"192.168.0.6:8333\", \"onetry\"")},
360 [&](const RPCHelpMan &self, const Config &config,
361 const JSONRPCRequest &request) -> UniValue {
362 std::string strCommand;
363 if (!request.params[1].isNull()) {
364 strCommand = request.params[1].get_str();
365 }
366
367 if (strCommand != "onetry" && strCommand != "add" &&
368 strCommand != "remove") {
369 throw std::runtime_error(self.ToString());
370 }
371
372 NodeContext &node = EnsureAnyNodeContext(request.context);
373 CConnman &connman = EnsureConnman(node);
374
375 std::string strNode = request.params[0].get_str();
376
377 if (strCommand == "onetry") {
378 CAddress addr;
379 connman.OpenNetworkConnection(addr, false, nullptr,
380 strNode.c_str(),
382 return NullUniValue;
383 }
384
385 if ((strCommand == "add") && (!connman.AddNode(strNode))) {
387 "Error: Node already added");
388 } else if ((strCommand == "remove") &&
389 (!connman.RemoveAddedNode(strNode))) {
390 throw JSONRPCError(
392 "Error: Node could not be removed. It has not been "
393 "added previously.");
394 }
395
396 return NullUniValue;
397 },
398 };
399}
400
402 return RPCHelpMan{
403 "addconnection",
404 "\nOpen an outbound connection to a specified node. This RPC is for "
405 "testing only.\n",
406 {
408 "The IP address and port to attempt connecting to."},
409 {"connection_type", RPCArg::Type::STR, RPCArg::Optional::NO,
410 "Type of connection to open (\"outbound-full-relay\", "
411 "\"block-relay-only\", \"addr-fetch\", \"feeler\" or "
412 "\"avalanche\")."},
413 },
415 "",
416 "",
417 {
418 {RPCResult::Type::STR, "address",
419 "Address of newly added connection."},
420 {RPCResult::Type::STR, "connection_type",
421 "Type of connection opened."},
422 }},
424 HelpExampleCli("addconnection",
425 "\"192.168.0.6:8333\" \"outbound-full-relay\"") +
426 HelpExampleRpc("addconnection",
427 "\"192.168.0.6:8333\" \"outbound-full-relay\"")},
428 [&](const RPCHelpMan &self, const Config &config,
429 const JSONRPCRequest &request) -> UniValue {
430 if (config.GetChainParams().NetworkIDString() !=
432 throw std::runtime_error("addconnection is for regression "
433 "testing (-regtest mode) only.");
434 }
435
436 NodeContext &node = EnsureAnyNodeContext(request.context);
437
438 const std::string address = request.params[0].get_str();
439 const std::string conn_type_in{
440 TrimString(request.params[1].get_str())};
441 ConnectionType conn_type{};
442 if (conn_type_in == "outbound-full-relay") {
444 } else if (conn_type_in == "block-relay-only") {
445 conn_type = ConnectionType::BLOCK_RELAY;
446 } else if (conn_type_in == "addr-fetch") {
447 conn_type = ConnectionType::ADDR_FETCH;
448 } else if (conn_type_in == "feeler") {
449 conn_type = ConnectionType::FEELER;
450 } else if (conn_type_in == "avalanche") {
451 if (!node.avalanche) {
453 "Error: avalanche outbound requested "
454 "but avalanche is not enabled.");
455 }
457 } else {
459 }
460
461 CConnman &connman = EnsureConnman(node);
462
463 const bool success = connman.AddConnection(address, conn_type);
464 if (!success) {
466 "Error: Already at capacity for specified "
467 "connection type.");
468 }
469
471 info.pushKV("address", address);
472 info.pushKV("connection_type", conn_type_in);
473
474 return info;
475 },
476 };
477}
478
480 return RPCHelpMan{
481 "disconnectnode",
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",
487 {
488 {"address", RPCArg::Type::STR,
489 RPCArg::DefaultHint{"fallback to nodeid"},
490 "The IP address/port of the node"},
491 {"nodeid", RPCArg::Type::NUM,
492 RPCArg::DefaultHint{"fallback to address"},
493 "The node ID (see getpeerinfo for node IDs)"},
494 },
496 RPCExamples{HelpExampleCli("disconnectnode", "\"192.168.0.6:8333\"") +
497 HelpExampleCli("disconnectnode", "\"\" 1") +
498 HelpExampleRpc("disconnectnode", "\"192.168.0.6:8333\"") +
499 HelpExampleRpc("disconnectnode", "\"\", 1")},
500 [&](const RPCHelpMan &self, const Config &config,
501 const JSONRPCRequest &request) -> UniValue {
502 NodeContext &node = EnsureAnyNodeContext(request.context);
503 CConnman &connman = EnsureConnman(node);
504
505 bool success;
506 const UniValue &address_arg = request.params[0];
507 const UniValue &id_arg = request.params[1];
508
509 if (!address_arg.isNull() && id_arg.isNull()) {
510 /* handle disconnect-by-address */
511 success = connman.DisconnectNode(address_arg.get_str());
512 } else if (!id_arg.isNull() && (address_arg.isNull() ||
513 (address_arg.isStr() &&
514 address_arg.get_str().empty()))) {
515 /* handle disconnect-by-id */
516 NodeId nodeid = (NodeId)id_arg.getInt<int64_t>();
517 success = connman.DisconnectNode(nodeid);
518 } else {
519 throw JSONRPCError(
521 "Only one of address and nodeid should be provided.");
522 }
523
524 if (!success) {
526 "Node not found in connected nodes");
527 }
528
529 return NullUniValue;
530 },
531 };
532}
533
535 return RPCHelpMan{
536 "getaddednodeinfo",
537 "Returns information about the given added node, or all added nodes\n"
538 "(note that onetry addnodes are not listed here)\n",
539 {
540 {"node", RPCArg::Type::STR, RPCArg::DefaultHint{"all nodes"},
541 "If provided, return information about this specific node, "
542 "otherwise all nodes are returned."},
543 },
544 RPCResult{
546 "",
547 "",
548 {
550 "",
551 "",
552 {
553 {RPCResult::Type::STR, "addednode",
554 "The node IP address or name (as provided to addnode)"},
555 {RPCResult::Type::BOOL, "connected", "If connected"},
557 "addresses",
558 "Only when connected = true",
559 {
561 "",
562 "",
563 {
564 {RPCResult::Type::STR, "address",
565 "The bitcoin server IP and port we're "
566 "connected to"},
567 {RPCResult::Type::STR, "connected",
568 "connection, inbound or outbound"},
569 }},
570 }},
571 }},
572 }},
573 RPCExamples{HelpExampleCli("getaddednodeinfo", "\"192.168.0.201\"") +
574 HelpExampleRpc("getaddednodeinfo", "\"192.168.0.201\"")},
575 [&](const RPCHelpMan &self, const Config &config,
576 const JSONRPCRequest &request) -> UniValue {
577 NodeContext &node = EnsureAnyNodeContext(request.context);
578 const CConnman &connman = EnsureConnman(node);
579
580 std::vector<AddedNodeInfo> vInfo = connman.GetAddedNodeInfo();
581
582 if (!request.params[0].isNull()) {
583 bool found = false;
584 for (const AddedNodeInfo &info : vInfo) {
585 if (info.strAddedNode == request.params[0].get_str()) {
586 vInfo.assign(1, info);
587 found = true;
588 break;
589 }
590 }
591 if (!found) {
593 "Error: Node has not been added.");
594 }
595 }
596
598
599 for (const AddedNodeInfo &info : vInfo) {
601 obj.pushKV("addednode", info.strAddedNode);
602 obj.pushKV("connected", info.fConnected);
603 UniValue addresses(UniValue::VARR);
604 if (info.fConnected) {
605 UniValue address(UniValue::VOBJ);
606 address.pushKV("address", info.resolvedAddress.ToString());
607 address.pushKV("connected",
608 info.fInbound ? "inbound" : "outbound");
609 addresses.push_back(address);
610 }
611 obj.pushKV("addresses", addresses);
612 ret.push_back(obj);
613 }
614
615 return ret;
616 },
617 };
618}
619
621 return RPCHelpMan{
622 "getnettotals",
623 "Returns information about network traffic, including bytes in, "
624 "bytes out,\n"
625 "and current time.\n",
626 {},
627 RPCResult{
629 "",
630 "",
631 {
632 {RPCResult::Type::NUM, "totalbytesrecv",
633 "Total bytes received"},
634 {RPCResult::Type::NUM, "totalbytessent", "Total bytes sent"},
635 {RPCResult::Type::NUM_TIME, "timemillis",
636 "Current " + UNIX_EPOCH_TIME + " in milliseconds"},
638 "uploadtarget",
639 "",
640 {
641 {RPCResult::Type::NUM, "timeframe",
642 "Length of the measuring timeframe in seconds"},
643 {RPCResult::Type::NUM, "target", "Target in bytes"},
644 {RPCResult::Type::BOOL, "target_reached",
645 "True if target is reached"},
646 {RPCResult::Type::BOOL, "serve_historical_blocks",
647 "True if serving historical blocks"},
648 {RPCResult::Type::NUM, "bytes_left_in_cycle",
649 "Bytes left in current time cycle"},
650 {RPCResult::Type::NUM, "time_left_in_cycle",
651 "Seconds left in current time cycle"},
652 }},
653 }},
654 RPCExamples{HelpExampleCli("getnettotals", "") +
655 HelpExampleRpc("getnettotals", "")},
656 [&](const RPCHelpMan &self, const Config &config,
657 const JSONRPCRequest &request) -> UniValue {
658 NodeContext &node = EnsureAnyNodeContext(request.context);
659 const CConnman &connman = EnsureConnman(node);
660
662 obj.pushKV("totalbytesrecv", connman.GetTotalBytesRecv());
663 obj.pushKV("totalbytessent", connman.GetTotalBytesSent());
664 obj.pushKV("timemillis", GetTimeMillis());
665
666 UniValue outboundLimit(UniValue::VOBJ);
667 outboundLimit.pushKV(
668 "timeframe", count_seconds(connman.GetMaxOutboundTimeframe()));
669 outboundLimit.pushKV("target", connman.GetMaxOutboundTarget());
670 outboundLimit.pushKV("target_reached",
671 connman.OutboundTargetReached(false));
672 outboundLimit.pushKV("serve_historical_blocks",
673 !connman.OutboundTargetReached(true));
674 outboundLimit.pushKV("bytes_left_in_cycle",
676 outboundLimit.pushKV(
677 "time_left_in_cycle",
679 obj.pushKV("uploadtarget", outboundLimit);
680 return obj;
681 },
682 };
683}
684
686 UniValue networks(UniValue::VARR);
687 for (int n = 0; n < NET_MAX; ++n) {
688 enum Network network = static_cast<enum Network>(n);
689 if (network == NET_UNROUTABLE || network == NET_CJDNS ||
690 network == NET_INTERNAL) {
691 continue;
692 }
693 proxyType proxy;
695 GetProxy(network, proxy);
696 obj.pushKV("name", GetNetworkName(network));
697 obj.pushKV("limited", !IsReachable(network));
698 obj.pushKV("reachable", IsReachable(network));
699 obj.pushKV("proxy", proxy.IsValid() ? proxy.proxy.ToStringIPPort()
700 : std::string());
701 obj.pushKV("proxy_randomize_credentials", proxy.randomize_credentials);
702 networks.push_back(obj);
703 }
704 return networks;
705}
706
708 const auto &ticker = Currency::get().ticker;
709 return RPCHelpMan{
710 "getnetworkinfo",
711 "Returns an object containing various state info regarding P2P "
712 "networking.\n",
713 {},
714 RPCResult{
716 "",
717 "",
718 {
719 {RPCResult::Type::NUM, "version", "the server version"},
720 {RPCResult::Type::STR, "subversion",
721 "the server subversion string"},
722 {RPCResult::Type::NUM, "protocolversion",
723 "the protocol version"},
724 {RPCResult::Type::STR_HEX, "localservices",
725 "the services we offer to the network"},
727 "localservicesnames",
728 "the services we offer to the network, in human-readable form",
729 {
730 {RPCResult::Type::STR, "SERVICE_NAME", "the service name"},
731 }},
732 {RPCResult::Type::BOOL, "localrelay",
733 "true if transaction relay is requested from peers"},
734 {RPCResult::Type::NUM, "timeoffset", "the time offset"},
735 {RPCResult::Type::NUM, "connections",
736 "the total number of connections"},
737 {RPCResult::Type::NUM, "connections_in",
738 "the number of inbound connections"},
739 {RPCResult::Type::NUM, "connections_out",
740 "the number of outbound connections"},
741 {RPCResult::Type::BOOL, "networkactive",
742 "whether p2p networking is enabled"},
744 "networks",
745 "information per network",
746 {
748 "",
749 "",
750 {
751 {RPCResult::Type::STR, "name",
752 "network (" + Join(GetNetworkNames(), ", ") + ")"},
753 {RPCResult::Type::BOOL, "limited",
754 "is the network limited using -onlynet?"},
755 {RPCResult::Type::BOOL, "reachable",
756 "is the network reachable?"},
757 {RPCResult::Type::STR, "proxy",
758 "(\"host:port\") the proxy that is used for this "
759 "network, or empty if none"},
760 {RPCResult::Type::BOOL, "proxy_randomize_credentials",
761 "Whether randomized credentials are used"},
762 }},
763 }},
764 {RPCResult::Type::NUM, "relayfee",
765 "minimum relay fee for transactions in " + ticker + "/kB"},
767 "localaddresses",
768 "list of local addresses",
769 {
771 "",
772 "",
773 {
774 {RPCResult::Type::STR, "address", "network address"},
775 {RPCResult::Type::NUM, "port", "network port"},
776 {RPCResult::Type::NUM, "score", "relative score"},
777 }},
778 }},
779 {RPCResult::Type::STR, "warnings",
780 "any network and blockchain warnings"},
781 }},
782 RPCExamples{HelpExampleCli("getnetworkinfo", "") +
783 HelpExampleRpc("getnetworkinfo", "")},
784 [&](const RPCHelpMan &self, const Config &config,
785 const JSONRPCRequest &request) -> UniValue {
786 LOCK(cs_main);
788 obj.pushKV("version", CLIENT_VERSION);
789 obj.pushKV("subversion", userAgent(config));
790 obj.pushKV("protocolversion", PROTOCOL_VERSION);
791 NodeContext &node = EnsureAnyNodeContext(request.context);
792 if (node.connman) {
793 ServiceFlags services = node.connman->GetLocalServices();
794 obj.pushKV("localservices", strprintf("%016x", services));
795 obj.pushKV("localservicesnames", GetServicesNames(services));
796 }
797 if (node.peerman) {
798 obj.pushKV("localrelay", !node.peerman->IgnoresIncomingTxs());
799 }
800 obj.pushKV("timeoffset", GetTimeOffset());
801 if (node.connman) {
802 obj.pushKV("networkactive", node.connman->GetNetworkActive());
803 obj.pushKV("connections", node.connman->GetNodeCount(
805 obj.pushKV("connections_in",
806 node.connman->GetNodeCount(ConnectionDirection::In));
807 obj.pushKV("connections_out", node.connman->GetNodeCount(
809 }
810 obj.pushKV("networks", GetNetworksInfo());
811 if (node.mempool) {
812 // This field can be deprecated, to be replaced by the
813 // getmempoolinfo fields
814 obj.pushKV("relayfee",
815 node.mempool->m_min_relay_feerate.GetFeePerK());
816 }
817 UniValue localAddresses(UniValue::VARR);
818 {
820 for (const std::pair<const CNetAddr, LocalServiceInfo> &item :
821 mapLocalHost) {
823 rec.pushKV("address", item.first.ToString());
824 rec.pushKV("port", item.second.nPort);
825 rec.pushKV("score", item.second.nScore);
826 localAddresses.push_back(rec);
827 }
828 }
829 obj.pushKV("localaddresses", localAddresses);
830 obj.pushKV("warnings", GetWarnings(false).original);
831 return obj;
832 },
833 };
834}
835
837 return RPCHelpMan{
838 "setban",
839 "Attempts to add or remove an IP/Subnet from the banned list.\n",
840 {
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"},
847 {"bantime", RPCArg::Type::NUM, RPCArg::Default{0},
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)"},
851 {"absolute", RPCArg::Type::BOOL, RPCArg::Default{false},
852 "If set, the bantime must be an absolute timestamp expressed in " +
854 },
857 HelpExampleCli("setban", "\"192.168.0.6\" \"add\" 86400") +
858 HelpExampleCli("setban", "\"192.168.0.0/24\" \"add\"") +
859 HelpExampleRpc("setban", "\"192.168.0.6\", \"add\", 86400")},
860 [&](const RPCHelpMan &help, const Config &config,
861 const JSONRPCRequest &request) -> UniValue {
862 std::string strCommand;
863 if (!request.params[1].isNull()) {
864 strCommand = request.params[1].get_str();
865 }
866
867 if (strCommand != "add" && strCommand != "remove") {
868 throw std::runtime_error(help.ToString());
869 }
870
871 NodeContext &node = EnsureAnyNodeContext(request.context);
872 if (!node.banman) {
874 "Error: Ban database not loaded");
875 }
876
877 CSubNet subNet;
878 CNetAddr netAddr;
879 bool isSubnet = false;
880
881 if (request.params[0].get_str().find('/') != std::string::npos) {
882 isSubnet = true;
883 }
884
885 if (!isSubnet) {
886 CNetAddr resolved;
887 LookupHost(request.params[0].get_str(), resolved, false);
888 netAddr = resolved;
889 } else {
890 LookupSubNet(request.params[0].get_str(), subNet);
891 }
892
893 if (!(isSubnet ? subNet.IsValid() : netAddr.IsValid())) {
895 "Error: Invalid IP/Subnet");
896 }
897
898 if (strCommand == "add") {
899 if (isSubnet ? node.banman->IsBanned(subNet)
900 : node.banman->IsBanned(netAddr)) {
902 "Error: IP/Subnet already banned");
903 }
904
905 // Use standard bantime if not specified.
906 int64_t banTime = 0;
907 if (!request.params[2].isNull()) {
908 banTime = request.params[2].getInt<int64_t>();
909 }
910
911 bool absolute = false;
912 if (request.params[3].isTrue()) {
913 absolute = true;
914 }
915
916 if (isSubnet) {
917 node.banman->Ban(subNet, banTime, absolute);
918 if (node.connman) {
919 node.connman->DisconnectNode(subNet);
920 }
921 } else {
922 node.banman->Ban(netAddr, banTime, absolute);
923 if (node.connman) {
924 node.connman->DisconnectNode(netAddr);
925 }
926 }
927 } else if (strCommand == "remove") {
928 if (!(isSubnet ? node.banman->Unban(subNet)
929 : node.banman->Unban(netAddr))) {
930 throw JSONRPCError(
932 "Error: Unban failed. Requested address/subnet "
933 "was not previously manually banned.");
934 }
935 }
936 return NullUniValue;
937 },
938 };
939}
940
942 return RPCHelpMan{
943 "listbanned",
944 "List all manually banned IPs/Subnets.\n",
945 {},
947 "",
948 "",
949 {
951 "",
952 "",
953 {
954 {RPCResult::Type::STR, "address", ""},
955 {RPCResult::Type::NUM_TIME, "banned_until", ""},
956 {RPCResult::Type::NUM_TIME, "ban_created", ""},
957 {RPCResult::Type::STR, "ban_reason", ""},
958 }},
959 }},
960 RPCExamples{HelpExampleCli("listbanned", "") +
961 HelpExampleRpc("listbanned", "")},
962 [&](const RPCHelpMan &self, const Config &config,
963 const JSONRPCRequest &request) -> UniValue {
964 NodeContext &node = EnsureAnyNodeContext(request.context);
965 if (!node.banman) {
967 "Error: Ban database not loaded");
968 }
969
970 banmap_t banMap;
971 node.banman->GetBanned(banMap);
972
973 UniValue bannedAddresses(UniValue::VARR);
974 for (const auto &entry : banMap) {
975 const CBanEntry &banEntry = entry.second;
977 rec.pushKV("address", entry.first.ToString());
978 rec.pushKV("banned_until", banEntry.nBanUntil);
979 rec.pushKV("ban_created", banEntry.nCreateTime);
980
981 bannedAddresses.push_back(rec);
982 }
983
984 return bannedAddresses;
985 },
986 };
987}
988
990 return RPCHelpMan{
991 "clearbanned",
992 "Clear all banned IPs.\n",
993 {},
995 RPCExamples{HelpExampleCli("clearbanned", "") +
996 HelpExampleRpc("clearbanned", "")},
997 [&](const RPCHelpMan &self, const Config &config,
998 const JSONRPCRequest &request) -> UniValue {
999 NodeContext &node = EnsureAnyNodeContext(request.context);
1000 if (!node.banman) {
1001 throw JSONRPCError(
1003 "Error: Peer-to-peer functionality missing or disabled");
1004 }
1005
1006 node.banman->ClearBanned();
1007
1008 return NullUniValue;
1009 },
1010 };
1011}
1012
1014 return RPCHelpMan{
1015 "setnetworkactive",
1016 "Disable/enable all p2p network activity.\n",
1017 {
1019 "true to enable networking, false to disable"},
1020 },
1021 RPCResult{RPCResult::Type::BOOL, "", "The value that was passed in"},
1022 RPCExamples{""},
1023 [&](const RPCHelpMan &self, const Config &config,
1024 const JSONRPCRequest &request) -> UniValue {
1025 NodeContext &node = EnsureAnyNodeContext(request.context);
1026 CConnman &connman = EnsureConnman(node);
1027
1028 connman.SetNetworkActive(request.params[0].get_bool());
1029
1030 return connman.GetNetworkActive();
1031 },
1032 };
1033}
1034
1036 return RPCHelpMan{
1037 "getnodeaddresses",
1038 "Return known addresses, which can potentially be used to find new "
1039 "nodes in the network.\n",
1040 {
1041 {"count", RPCArg::Type::NUM, RPCArg::Default{1},
1042 "The maximum number of addresses to return. Specify 0 to return "
1043 "all known addresses."},
1044 {"network", RPCArg::Type::STR, RPCArg::DefaultHint{"all networks"},
1045 "Return only addresses of the specified network. Can be one of: " +
1046 Join(GetNetworkNames(), ", ") + "."},
1047 },
1049 "",
1050 "",
1051 {
1053 "",
1054 "",
1055 {
1057 "The " + UNIX_EPOCH_TIME +
1058 " when the node was last seen"},
1059 {RPCResult::Type::NUM, "services",
1060 "The services offered by the node"},
1061 {RPCResult::Type::STR, "address",
1062 "The address of the node"},
1063 {RPCResult::Type::NUM, "port",
1064 "The port number of the node"},
1065 {RPCResult::Type::STR, "network",
1066 "The network (" + Join(GetNetworkNames(), ", ") +
1067 ") the node connected through"},
1068 }},
1069 }},
1070 RPCExamples{HelpExampleCli("getnodeaddresses", "8") +
1071 HelpExampleCli("getnodeaddresses", "4 \"i2p\"") +
1072 HelpExampleCli("-named getnodeaddresses",
1073 "network=onion count=12") +
1074 HelpExampleRpc("getnodeaddresses", "8") +
1075 HelpExampleRpc("getnodeaddresses", "4, \"i2p\"")},
1076 [&](const RPCHelpMan &self, const Config &config,
1077 const JSONRPCRequest &request) -> UniValue {
1078 NodeContext &node = EnsureAnyNodeContext(request.context);
1079 const CConnman &connman = EnsureConnman(node);
1080
1081 const int count{request.params[0].isNull()
1082 ? 1
1083 : request.params[0].getInt<int>()};
1084 if (count < 0) {
1086 "Address count out of range");
1087 }
1088
1089 const std::optional<Network> network{
1090 request.params[1].isNull()
1091 ? std::nullopt
1092 : std::optional<Network>{
1093 ParseNetwork(request.params[1].get_str())}};
1094 if (network == NET_UNROUTABLE) {
1096 strprintf("Network not recognized: %s",
1097 request.params[1].get_str()));
1098 }
1099 // returns a shuffled list of CAddress
1100 const std::vector<CAddress> vAddr{
1101 connman.GetAddresses(count, /* max_pct */ 0, network)};
1103
1104 for (const CAddress &addr : vAddr) {
1106 obj.pushKV(
1107 "time",
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());
1112 obj.pushKV("network", GetNetworkName(addr.GetNetClass()));
1113 ret.push_back(obj);
1114 }
1115 return ret;
1116 },
1117 };
1118}
1119
1121 return RPCHelpMan{
1122 "addpeeraddress",
1123 "Add the address of a potential peer to the address manager. This "
1124 "RPC is for testing only.\n",
1125 {
1127 "The IP address of the peer"},
1129 "The port of the peer"},
1130 {"tried", RPCArg::Type::BOOL, RPCArg::Default{false},
1131 "If true, attempt to add the peer to the tried addresses table"},
1132 },
1133 RPCResult{
1135 "",
1136 "",
1137 {
1138 {RPCResult::Type::BOOL, "success",
1139 "whether the peer address was successfully added to the "
1140 "address manager"},
1141 },
1142 },
1144 HelpExampleCli("addpeeraddress", "\"1.2.3.4\" 8333 true") +
1145 HelpExampleRpc("addpeeraddress", "\"1.2.3.4\", 8333, true")},
1146 [&](const RPCHelpMan &self, const Config &config,
1147 const JSONRPCRequest &request) -> UniValue {
1148 NodeContext &node = EnsureAnyNodeContext(request.context);
1149 if (!node.addrman) {
1150 throw JSONRPCError(
1152 "Error: Address manager functionality missing or disabled");
1153 }
1154
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()};
1159
1161 CNetAddr net_addr;
1162 bool success{false};
1163
1164 if (LookupHost(addr_string, net_addr, false)) {
1165 CAddress address{{net_addr, port}, ServiceFlags(NODE_NETWORK)};
1166 address.nTime = Now<NodeSeconds>();
1167 // The source address is set equal to the address. This is
1168 // equivalent to the peer announcing itself.
1169 if (node.addrman->Add({address}, address)) {
1170 success = true;
1171 if (tried) {
1172 // Attempt to move the address to the tried addresses
1173 // table.
1174 node.addrman->Good(address);
1175 }
1176 }
1177 }
1178
1179 obj.pushKV("success", success);
1180 return obj;
1181 },
1182 };
1183}
1184
1186 return RPCHelpMan{
1187 "sendmsgtopeer",
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 "
1190 "be generated.\n"
1191 "This RPC is for testing only.",
1192 {
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 "
1200 "header"},
1201 },
1202 RPCResult{RPCResult::Type::OBJ, "", "", std::vector<RPCResult>{}},
1203 RPCExamples{HelpExampleCli("sendmsgtopeer", "0 \"addr\" \"ffffff\"") +
1204 HelpExampleRpc("sendmsgtopeer", "0 \"addr\" \"ffffff\"")},
1205 [&](const RPCHelpMan &self, const Config &config,
1206 const JSONRPCRequest &request) -> UniValue {
1207 const NodeId peer_id{request.params[0].getInt<int64_t>()};
1208 const std::string &msg_type{request.params[1].get_str()};
1209 if (msg_type.size() > CMessageHeader::COMMAND_SIZE) {
1210 throw JSONRPCError(
1212 strprintf("Error: msg_type too long, max length is %i",
1214 }
1215 auto msg{TryParseHex<uint8_t>(request.params[2].get_str())};
1216 if (!msg.has_value()) {
1218 "Error parsing input for msg");
1219 }
1220
1221 NodeContext &node = EnsureAnyNodeContext(request.context);
1222 CConnman &connman = EnsureConnman(node);
1223
1224 CSerializedNetMsg msg_ser;
1225 msg_ser.data = msg.value();
1226 msg_ser.m_type = msg_type;
1227
1228 bool success = connman.ForNode(peer_id, [&](CNode *node) {
1229 connman.PushMessage(node, std::move(msg_ser));
1230 return true;
1231 });
1232
1233 if (!success) {
1235 "Error: Could not send message to peer");
1236 }
1237
1239 return ret;
1240 },
1241 };
1242}
1243
1245 // clang-format off
1246 static const CRPCCommand commands[] = {
1247 // category actor (function)
1248 // ------------------ ----------------------
1249 { "network", getconnectioncount, },
1250 { "network", ping, },
1251 { "network", getpeerinfo, },
1252 { "network", addnode, },
1253 { "network", disconnectnode, },
1254 { "network", getaddednodeinfo, },
1255 { "network", getnettotals, },
1256 { "network", getnetworkinfo, },
1257 { "network", setban, },
1258 { "network", listbanned, },
1259 { "network", clearbanned, },
1260 { "network", setnetworkactive, },
1261 { "network", getnodeaddresses, },
1262 { "hidden", addconnection, },
1263 { "hidden", addpeeraddress, },
1264 { "hidden", sendmsgtopeer },
1265 };
1266 // clang-format on
1267 for (const auto &c : commands) {
1268 t.appendCommand(c.name, &c);
1269 }
1270}
A CService with information about it as peer.
Definition: protocol.h:442
Definition: addrdb.h:30
int64_t nCreateTime
Definition: addrdb.h:34
int64_t nBanUntil
Definition: addrdb.h:35
static const std::string REGTEST
Definition: net.h:856
std::chrono::seconds GetMaxOutboundTimeLeftInCycle() const
returns the time in second left in the current max outbound cycle in case of no limit,...
Definition: net.cpp:3186
bool OutboundTargetReached(bool historicalBlockServingLimit) const
check if the outbound target is reached.
Definition: net.cpp:3202
bool ForNode(NodeId id, std::function< bool(CNode *pnode)> func)
Definition: net.cpp:3371
bool AddConnection(const std::string &address, ConnectionType conn_type)
Attempts to open a connection.
Definition: net.cpp:1412
bool RemoveAddedNode(const std::string &node) EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex)
Definition: net.cpp:3072
bool GetNetworkActive() const
Definition: net.h:948
uint64_t GetOutboundTargetBytesLeft() const
response the bytes left in the current max outbound cycle in case of no limit, it will always respons...
Definition: net.cpp:3225
std::chrono::seconds GetMaxOutboundTimeframe() const
Definition: net.cpp:3182
bool DisconnectNode(const std::string &node)
Definition: net.cpp:3113
uint64_t GetMaxOutboundTarget() const
Definition: net.cpp:3177
size_t GetNodeCount(ConnectionDirection) const
Definition: net.cpp:3084
void GetNodeStats(std::vector< CNodeStats > &vstats) const
Definition: net.cpp:3102
std::vector< AddedNodeInfo > GetAddedNodeInfo() const EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex)
Definition: net.cpp:2332
uint64_t GetTotalBytesRecv() const
Definition: net.cpp:3236
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.
Definition: net.cpp:2994
void SetNetworkActive(bool active)
Definition: net.cpp:2687
void OpenNetworkConnection(const CAddress &addrConnect, bool fCountFailure, CSemaphoreGrant *grantOutbound, const char *strDest, ConnectionType conn_type)
Definition: net.cpp:2421
bool AddNode(const std::string &node) EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex)
Definition: net.cpp:3060
void PushMessage(CNode *pnode, CSerializedNetMsg &&msg)
Definition: net.cpp:3325
uint64_t GetTotalBytesSent() const
Definition: net.cpp:3240
static constexpr size_t COMMAND_SIZE
Definition: protocol.h:37
Network address.
Definition: netaddress.h:121
bool IsValid() const
Definition: netaddress.cpp:477
Information about a peer.
Definition: net.h:460
RPC command dispatcher.
Definition: server.h:194
void appendCommand(const std::string &name, const CRPCCommand *pcmd)
Appends a CRPCCommand to the dispatch table.
Definition: server.cpp:327
std::string ToStringIPPort() const
bool IsValid() const
Definition: config.h:19
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
Definition: util.cpp:664
void push_back(UniValue val)
Definition: univalue.cpp:96
const std::string & get_str() const
@ VOBJ
Definition: univalue.h:31
@ VARR
Definition: univalue.h:32
bool isNull() const
Definition: univalue.h:104
bool isStr() const
Definition: univalue.h:108
Int getInt() const
Definition: univalue.h:157
void pushKV(std::string key, UniValue val)
Definition: univalue.cpp:115
bool IsValid() const
Definition: netbase.h:58
CService proxy
Definition: netbase.h:60
bool randomize_credentials
Definition: netbase.h:61
static constexpr int CLIENT_VERSION
bitcoind-res.rc includes this file, but it cannot cope with real c++ code.
Definition: clientversion.h:38
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
Definition: cs_main.cpp:7
static path absolute(const path &p)
Definition: fs.h:96
Definition: init.h:28
const std::string NET_MESSAGE_COMMAND_OTHER
Definition: net.cpp:112
GlobalMutex g_maplocalhost_mutex
Definition: net.cpp:127
std::string ConnectionTypeAsString(ConnectionType conn_type)
Convert ConnectionType enum to a string value.
Definition: net.cpp:597
std::string userAgent(const Config &config)
Definition: net.cpp:3423
bool IsReachable(enum Network net)
Definition: net.cpp:325
const std::vector< std::string > CONNECTION_TYPE_DOC
Definition: net.h:135
ConnectionType
Different types of connections to a peer.
Definition: net.h:148
@ 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
Definition: net_types.h:13
Network
A network type.
Definition: netaddress.h:44
@ NET_CJDNS
CJDNS.
Definition: netaddress.h:62
@ NET_MAX
Dummy value to indicate the number of NET_* constants.
Definition: netaddress.h:69
@ NET_UNROUTABLE
Addresses from these networks are not publicly routable on the global Internet.
Definition: netaddress.h:47
@ NET_INTERNAL
A set of addresses that represent the hash of a string or FQDN.
Definition: netaddress.h:66
std::string GetNetworkName(enum Network net)
Definition: netbase.cpp:114
bool GetProxy(enum Network net, proxyType &proxyInfoOut)
Definition: netbase.cpp:715
bool LookupSubNet(const std::string &strSubnet, CSubNet &ret, DNSLookupFn dns_lookup_function)
Parse and resolve a specified subnet string into the appropriate internal representation.
Definition: netbase.cpp:781
enum Network ParseNetwork(const std::string &net_in)
Definition: netbase.cpp:92
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.
Definition: netbase.cpp:191
std::vector< std::string > GetNetworkNames(bool append_unroutable)
Return a vector of publicly routable Network names; optionally append NET_UNROUTABLE.
Definition: netbase.cpp:137
int64_t NodeId
Definition: nodeid.h:10
ServiceFlags
nServices flags.
Definition: protocol.h:335
@ NODE_NONE
Definition: protocol.h:338
@ NODE_NETWORK
Definition: protocol.h:342
UniValue JSONRPCError(int code, const std::string &message)
Definition: request.cpp:58
void RegisterNetRPCCommands(CRPCTable &t)
Register P2P networking RPC commands.
Definition: net.cpp:1244
static RPCHelpMan getnetworkinfo()
Definition: net.cpp:707
static RPCHelpMan addconnection()
Definition: net.cpp:401
static RPCHelpMan getaddednodeinfo()
Definition: net.cpp:534
static RPCHelpMan clearbanned()
Definition: net.cpp:989
static RPCHelpMan getnettotals()
Definition: net.cpp:620
static RPCHelpMan addnode()
Definition: net.cpp:339
static RPCHelpMan getnodeaddresses()
Definition: net.cpp:1035
static RPCHelpMan setban()
Definition: net.cpp:836
static UniValue GetNetworksInfo()
Definition: net.cpp:685
static RPCHelpMan ping()
Definition: net.cpp:57
static RPCHelpMan getconnectioncount()
Definition: net.cpp:39
static RPCHelpMan disconnectnode()
Definition: net.cpp:479
static RPCHelpMan listbanned()
Definition: net.cpp:941
static RPCHelpMan setnetworkactive()
Definition: net.cpp:1013
static RPCHelpMan addpeeraddress()
Definition: net.cpp:1120
static RPCHelpMan getpeerinfo()
Definition: net.cpp:82
static RPCHelpMan sendmsgtopeer()
Definition: net.cpp:1185
@ RPC_CLIENT_NODE_NOT_CONNECTED
Node to disconnect not found in connected nodes.
Definition: protocol.h:77
@ RPC_CLIENT_INVALID_IP_OR_SUBNET
Invalid IP/Subnet.
Definition: protocol.h:79
@ RPC_MISC_ERROR
General application defined errors std::exception thrown in command handling.
Definition: protocol.h:38
@ RPC_CLIENT_NODE_ALREADY_ADDED
Node is already added.
Definition: protocol.h:73
@ RPC_INVALID_PARAMS
Definition: protocol.h:30
@ RPC_INVALID_PARAMETER
Invalid, missing or duplicate parameter.
Definition: protocol.h:46
@ RPC_DATABASE_ERROR
Database error.
Definition: protocol.h:48
@ RPC_CLIENT_NODE_NOT_ADDED
Node has not been added before.
Definition: protocol.h:75
@ RPC_CLIENT_NODE_CAPACITY_REACHED
Max number of outbound or block-relay connections already open.
Definition: protocol.h:83
@ RPC_CLIENT_P2P_DISABLED
No valid connection manager instance found.
Definition: protocol.h:81
std::string HelpExampleCli(const std::string &methodname, const std::string &args)
Definition: util.cpp:150
UniValue GetServicesNames(ServiceFlags services)
Returns, given services flags, a list of humanly readable (known) network services.
Definition: util.cpp:1337
std::string HelpExampleRpc(const std::string &methodname, const std::string &args)
Definition: util.cpp:167
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:22
static RPCHelpMan help()
Definition: server.cpp:182
NodeContext & EnsureAnyNodeContext(const std::any &context)
Definition: server_util.cpp:21
PeerManager & EnsurePeerman(const NodeContext &node)
Definition: server_util.cpp:72
CConnman & EnsureConnman(const NodeContext &node)
Definition: server_util.cpp:63
auto Join(const std::vector< T > &list, const BaseType &separator, UnaryOp unary_op) -> decltype(unary_op(list.at(0)))
Join a list of items.
Definition: string.h:63
std::string TrimString(std::string_view str, std::string_view pattern=" \f\n\r\t\v")
Definition: string.h:38
std::chrono::microseconds m_ping_wait
Amount m_fee_filter_received
std::vector< int > vHeightInFlight
uint64_t m_addr_rate_limited
uint64_t m_addr_processed
int64_t presync_height
ServiceFlags their_services
POD that contains various stats about a node.
Definition: net.h:287
std::vector< uint8_t > data
Definition: net.h:131
std::string m_type
Definition: net.h:132
static const Currency & get()
Definition: amount.cpp:18
std::string ticker
Definition: amount.h:150
@ STR_HEX
Special type that is a STR with only hex chars.
std::string DefaultHint
Hint for default value.
Definition: util.h:195
@ 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:43
#define LOCK(cs)
Definition: sync.h:306
static int count
Definition: tests.c:31
int64_t GetTimeMillis()
Returns the system time (not mockable)
Definition: time.cpp:101
constexpr int64_t count_seconds(std::chrono::seconds t)
Definition: time.h:55
double CountSecondsDouble(SecondsDouble t)
Helper to count the seconds in any std::chrono::duration type.
Definition: time.h:72
int64_t GetTimeOffset()
"Never go to sea with two chronometers; take one or three." Our three time sources are:
Definition: timedata.cpp:30
#define strprintf
Format arguments and return the string or write to given std::ostream (see tinyformat::format doc for...
Definition: tinyformat.h:1202
const UniValue NullUniValue
Definition: univalue.cpp:16
static const int PROTOCOL_VERSION
network protocol versioning
Definition: version.h:11
bilingual_str GetWarnings(bool verbose)
Format a string that describes several potential problems detected by the core.
Definition: warnings.cpp:41