Branch data Line data Source code
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>
18 : : #include <node/protocol_version.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 : :
41 : : using node::NodeContext;
42 : : using util::Join;
43 : : using util::TrimString;
44 : :
45 : : const 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 : :
54 : : const 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 : :
60 : 2174 : static RPCHelpMan getconnectioncount()
61 : : {
62 : 2174 : return RPCHelpMan{
63 : : "getconnectioncount",
64 : : "Returns the number of connections to other nodes.\n",
65 : : {},
66 : 0 : RPCResult{
67 : : RPCResult::Type::NUM, "", "The connection count"
68 [ + - + - : 4348 : },
+ - ]
69 : 2174 : RPCExamples{
70 [ + - + - : 4348 : HelpExampleCli("getconnectioncount", "")
+ - ]
71 [ + - + - : 8696 : + HelpExampleRpc("getconnectioncount", "")
+ - + - ]
72 [ + - ]: 2174 : },
73 : 6 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
74 : : {
75 : 6 : NodeContext& node = EnsureAnyNodeContext(request.context);
76 : 6 : const CConnman& connman = EnsureConnman(node);
77 : :
78 : 6 : return connman.GetNodeCount(ConnectionDirection::Both);
79 : : },
80 [ + - + - : 13044 : };
+ - + - ]
81 : : }
82 : :
83 : 2171 : static RPCHelpMan ping()
84 : : {
85 : 2171 : 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 : : {},
91 [ + - + - : 4342 : RPCResult{RPCResult::Type::NONE, "", ""},
+ - ]
92 : 2171 : RPCExamples{
93 [ + - + - : 4342 : HelpExampleCli("ping", "")
+ - ]
94 [ + - + - : 8684 : + HelpExampleRpc("ping", "")
+ - + - ]
95 [ + - ]: 2171 : },
96 : 3 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
97 : : {
98 : 3 : NodeContext& node = EnsureAnyNodeContext(request.context);
99 : 3 : PeerManager& peerman = EnsurePeerman(node);
100 : :
101 : : // Request that each node send a ping during next message processing pass
102 : 3 : peerman.SendPings();
103 : 3 : return UniValue::VNULL;
104 : : },
105 [ + - + - : 13026 : };
+ - + - ]
106 : : }
107 : :
108 : : /** Returns, given services flags, a list of humanly readable (known) network services */
109 : 11623 : static UniValue GetServicesNames(ServiceFlags services)
110 : : {
111 : 11623 : UniValue servicesNames(UniValue::VARR);
112 : :
113 [ + - + + ]: 43176 : for (const auto& flag : serviceFlagsToStr(services)) {
114 [ + - + - ]: 31553 : servicesNames.push_back(flag);
115 : 11623 : }
116 : :
117 : 11623 : return servicesNames;
118 : 0 : }
119 : :
120 : 8290 : static RPCHelpMan getpeerinfo()
121 : : {
122 : 8290 : return RPCHelpMan{
123 : : "getpeerinfo",
124 : : "Returns data about each connected network peer as a json array of objects.",
125 : : {},
126 : 0 : 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 [ + - + - : 16580 : {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 [ + - ]: 16580 : {RPCResult::Type::NUM_TIME, "lastsend", "The " + UNIX_EPOCH_TIME + " of the last send"},
146 [ + - ]: 16580 : {RPCResult::Type::NUM_TIME, "lastrecv", "The " + UNIX_EPOCH_TIME + " of the last receive"},
147 [ + - ]: 16580 : {RPCResult::Type::NUM_TIME, "last_transaction", "The " + UNIX_EPOCH_TIME + " of the last valid transaction received from this peer"},
148 [ + - ]: 16580 : {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 [ + - ]: 16580 : {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 [ + - ]: 16580 : {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 [ + - ]: 16580 : "of unknown message types are listed under '"+NET_MESSAGE_TYPE_OTHER+"'."}
189 : : }},
190 [ + - + - ]: 16580 : {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 : 8290 : "best capture connection behaviors."},
193 [ + - + - ]: 16580 : {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 [ + - + - : 613460 : },
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ + + + +
+ + + + +
+ + + + -
- - - - -
- - - - -
- - - ]
198 : 8290 : RPCExamples{
199 [ + - + - : 16580 : HelpExampleCli("getpeerinfo", "")
+ - ]
200 [ + - + - : 33160 : + HelpExampleRpc("getpeerinfo", "")
+ - + - ]
201 [ + - ]: 8290 : },
202 : 6120 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
203 : : {
204 : 6120 : NodeContext& node = EnsureAnyNodeContext(request.context);
205 : 6120 : const CConnman& connman = EnsureConnman(node);
206 : 6120 : const PeerManager& peerman = EnsurePeerman(node);
207 : :
208 : 6120 : std::vector<CNodeStats> vstats;
209 [ + - ]: 6120 : connman.GetNodeStats(vstats);
210 : :
211 : 6120 : UniValue ret(UniValue::VARR);
212 : :
213 [ + + ]: 16794 : for (const CNodeStats& stats : vstats) {
214 : 10674 : UniValue obj(UniValue::VOBJ);
215 [ + - ]: 10674 : CNodeStateStats statestats;
216 [ + - ]: 10674 : 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 [ + + ]: 10674 : if (!fStateStats) {
223 : 8 : continue;
224 : : }
225 [ + - + - : 21332 : obj.pushKV("id", stats.nodeid);
+ - ]
226 [ + - + - : 21332 : obj.pushKV("addr", stats.m_addr_name);
+ - ]
227 [ + - + + ]: 10666 : if (stats.addrBind.IsValid()) {
228 [ + - + - : 21320 : obj.pushKV("addrbind", stats.addrBind.ToStringAddrPort());
+ - + - ]
229 : : }
230 [ + + ]: 10666 : if (!(stats.addrLocal.empty())) {
231 [ + - + - : 4402 : obj.pushKV("addrlocal", stats.addrLocal);
+ - ]
232 : : }
233 [ + - + - : 21332 : obj.pushKV("network", GetNetworkName(stats.m_network));
+ - + - ]
234 [ - + ]: 10666 : if (stats.m_mapped_as != 0) {
235 [ # # # # : 0 : obj.pushKV("mapped_as", uint64_t(stats.m_mapped_as));
# # ]
236 : : }
237 : 10666 : ServiceFlags services{statestats.their_services};
238 [ + - + - : 21332 : obj.pushKV("services", strprintf("%016x", services));
+ - + - ]
239 [ + - + - : 21332 : obj.pushKV("servicesnames", GetServicesNames(services));
+ - ]
240 [ + - + - : 21332 : obj.pushKV("relaytxes", statestats.m_relay_txs);
+ - ]
241 [ + - + - : 21332 : obj.pushKV("lastsend", count_seconds(stats.m_last_send));
+ - ]
242 [ + - + - : 21332 : obj.pushKV("lastrecv", count_seconds(stats.m_last_recv));
+ - ]
243 [ + - + - : 21332 : obj.pushKV("last_transaction", count_seconds(stats.m_last_tx_time));
+ - ]
244 [ + - + - : 21332 : obj.pushKV("last_block", count_seconds(stats.m_last_block_time));
+ - ]
245 [ + - + - : 21332 : obj.pushKV("bytessent", stats.nSendBytes);
+ - ]
246 [ + - + - : 21332 : obj.pushKV("bytesrecv", stats.nRecvBytes);
+ - ]
247 [ + - + - : 21332 : obj.pushKV("conntime", count_seconds(stats.m_connected));
+ - ]
248 [ + - + - : 21332 : obj.pushKV("timeoffset", Ticks<std::chrono::seconds>(statestats.time_offset));
+ - ]
249 [ + + ]: 10666 : if (stats.m_last_ping_time > 0us) {
250 [ + - + - : 18686 : obj.pushKV("pingtime", Ticks<SecondsDouble>(stats.m_last_ping_time));
+ - ]
251 : : }
252 [ + + ]: 10666 : if (stats.m_min_ping_time < std::chrono::microseconds::max()) {
253 [ + - + - : 19754 : obj.pushKV("minping", Ticks<SecondsDouble>(stats.m_min_ping_time));
+ - ]
254 : : }
255 [ + + ]: 10666 : if (statestats.m_ping_wait > 0s) {
256 [ + - + - : 82 : obj.pushKV("pingwait", Ticks<SecondsDouble>(statestats.m_ping_wait));
+ - ]
257 : : }
258 [ + - + - : 21332 : 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 [ + - + - : 21332 : obj.pushKV("subver", stats.cleanSubVer);
+ - ]
263 [ + - + - : 21332 : obj.pushKV("inbound", stats.fInbound);
+ - ]
264 [ + - + - : 21332 : obj.pushKV("bip152_hb_to", stats.m_bip152_highbandwidth_to);
+ - ]
265 [ + - + - : 21332 : obj.pushKV("bip152_hb_from", stats.m_bip152_highbandwidth_from);
+ - ]
266 [ + - + - : 21332 : obj.pushKV("startingheight", statestats.m_starting_height);
+ - ]
267 [ + - + - : 21332 : obj.pushKV("presynced_headers", statestats.presync_height);
+ - ]
268 [ + - + - : 21332 : obj.pushKV("synced_headers", statestats.nSyncHeight);
+ - ]
269 [ + - + - : 21332 : obj.pushKV("synced_blocks", statestats.nCommonHeight);
+ - ]
270 : 10666 : UniValue heights(UniValue::VARR);
271 [ + + ]: 15404 : for (const int height : statestats.vHeightInFlight) {
272 [ + - + - ]: 4738 : heights.push_back(height);
273 : : }
274 [ + - + - ]: 21332 : obj.pushKV("inflight", std::move(heights));
275 [ + - + - : 21332 : obj.pushKV("addr_relay_enabled", statestats.m_addr_relay_enabled);
+ - ]
276 [ + - + - : 21332 : obj.pushKV("addr_processed", statestats.m_addr_processed);
+ - ]
277 [ + - + - : 21332 : obj.pushKV("addr_rate_limited", statestats.m_addr_rate_limited);
+ - ]
278 : 10666 : UniValue permissions(UniValue::VARR);
279 [ + - + + ]: 15181 : for (const auto& permission : NetPermissions::ToStrings(stats.m_permission_flags)) {
280 [ + - + - ]: 4515 : permissions.push_back(permission);
281 : 10666 : }
282 [ + - + - ]: 21332 : obj.pushKV("permissions", std::move(permissions));
283 [ + - + - : 21332 : obj.pushKV("minfeefilter", ValueFromAmount(statestats.m_fee_filter_received));
+ - ]
284 : :
285 : 10666 : UniValue sendPerMsgType(UniValue::VOBJ);
286 [ + + ]: 129822 : for (const auto& i : stats.mapSendBytesPerMsgType) {
287 [ + - ]: 119156 : if (i.second > 0)
288 [ + - + - : 238312 : sendPerMsgType.pushKV(i.first, i.second);
+ - ]
289 : : }
290 [ + - + - ]: 21332 : obj.pushKV("bytessent_per_msg", std::move(sendPerMsgType));
291 : :
292 : 10666 : UniValue recvPerMsgType(UniValue::VOBJ);
293 [ + + ]: 394642 : for (const auto& i : stats.mapRecvBytesPerMsgType) {
294 [ + + ]: 383976 : if (i.second > 0)
295 [ + - + - : 219776 : recvPerMsgType.pushKV(i.first, i.second);
+ - ]
296 : : }
297 [ + - + - ]: 21332 : obj.pushKV("bytesrecv_per_msg", std::move(recvPerMsgType));
298 [ + - + - : 21332 : obj.pushKV("connection_type", ConnectionTypeAsString(stats.m_conn_type));
+ - + - ]
299 [ + - + - : 21332 : obj.pushKV("transport_protocol_type", TransportTypeAsString(stats.m_transport_type));
+ - + - ]
300 [ + - + - : 21332 : obj.pushKV("session_id", stats.m_session_id);
+ - ]
301 : :
302 [ + - ]: 10666 : ret.push_back(std::move(obj));
303 : 10674 : }
304 : :
305 : 6120 : return ret;
306 : 6120 : },
307 [ + - + - : 49740 : };
+ - + - ]
308 [ + - + - : 389630 : }
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
- - ]
309 : :
310 : 2628 : static RPCHelpMan addnode()
311 : : {
312 : 2628 : 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 : 2628 : "full nodes/support SegWit as other outbound peers are (though such peers will not be synced from).\n" +
318 [ + - + - ]: 7884 : strprintf("Addnode connections are limited to %u at a time", MAX_ADDNODE_CONNECTIONS) +
319 : 2628 : " and are counted separately from the -maxconnections limit.\n",
320 : : {
321 [ + - ]: 2628 : {"node", RPCArg::Type::STR, RPCArg::Optional::NO, "The address of the peer to connect to"},
322 [ + - ]: 2628 : {"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 [ + - ]: 5256 : {"v2transport", RPCArg::Type::BOOL, RPCArg::DefaultHint{"set by -v2transport"}, "Attempt to connect using BIP324 v2 transport protocol (ignored for 'remove' command)"},
324 : : },
325 [ + - + - : 5256 : RPCResult{RPCResult::Type::NONE, "", ""},
+ - ]
326 : 2628 : RPCExamples{
327 [ + - + - : 5256 : HelpExampleCli("addnode", "\"192.168.0.6:8333\" \"onetry\" true")
+ - ]
328 [ + - + - : 10512 : + HelpExampleRpc("addnode", "\"192.168.0.6:8333\", \"onetry\" true")
+ - + - ]
329 [ + - ]: 2628 : },
330 : 460 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
331 : : {
332 : 460 : const auto command{self.Arg<std::string>("command")};
333 [ + + + + : 460 : if (command != "onetry" && command != "add" && command != "remove") {
+ + ]
334 : 2 : throw std::runtime_error(
335 [ + - + - ]: 4 : self.ToString());
336 : : }
337 : :
338 [ + - ]: 458 : NodeContext& node = EnsureAnyNodeContext(request.context);
339 [ + - ]: 458 : CConnman& connman = EnsureConnman(node);
340 : :
341 [ + - ]: 458 : const auto node_arg{self.Arg<std::string>("node")};
342 [ + - ]: 458 : bool node_v2transport = connman.GetLocalServices() & NODE_P2P_V2;
343 [ + - ]: 458 : bool use_v2transport = self.MaybeArg<bool>("v2transport").value_or(node_v2transport);
344 : :
345 [ + + + + ]: 458 : if (use_v2transport && !node_v2transport) {
346 [ + - + - ]: 2 : throw JSONRPCError(RPC_INVALID_PARAMETER, "Error: v2transport requested but not enabled (see -v2transport)");
347 : : }
348 : :
349 [ + + ]: 457 : if (command == "onetry")
350 : : {
351 [ + - ]: 445 : CAddress addr;
352 [ + - ]: 445 : connman.OpenNetworkConnection(addr, /*fCountFailure=*/false, /*grant_outbound=*/{}, node_arg.c_str(), ConnectionType::MANUAL, use_v2transport);
353 : 445 : return UniValue::VNULL;
354 : 445 : }
355 : :
356 [ + + ]: 12 : if (command == "add")
357 : : {
358 [ + + ]: 8 : if (!connman.AddNode({node_arg, use_v2transport})) {
359 [ + - + - ]: 8 : throw JSONRPCError(RPC_CLIENT_NODE_ALREADY_ADDED, "Error: Node already added");
360 : : }
361 : : }
362 [ + - ]: 4 : else if (command == "remove")
363 : : {
364 [ + - + + ]: 4 : if (!connman.RemoveAddedNode(node_arg)) {
365 [ + - + - ]: 4 : throw JSONRPCError(RPC_CLIENT_NODE_NOT_ADDED, "Error: Node could not be removed. It has not been added previously.");
366 : : }
367 : : }
368 : :
369 : 6 : return UniValue::VNULL;
370 [ + - + - ]: 466 : },
371 [ + - + - : 49932 : };
+ - + - +
- + - + -
+ - + - +
+ - - ]
372 [ + - + - : 18396 : }
+ - + - -
- ]
373 : :
374 : 2303 : static RPCHelpMan addconnection()
375 : : {
376 : 2303 : return RPCHelpMan{
377 : : "addconnection",
378 : : "Open an outbound connection to a specified node. This RPC is for testing only.\n",
379 : : {
380 [ + - ]: 2303 : {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The IP address and port to attempt connecting to."},
381 [ + - ]: 2303 : {"connection_type", RPCArg::Type::STR, RPCArg::Optional::NO, "Type of connection to open (\"outbound-full-relay\", \"block-relay-only\", \"addr-fetch\" or \"feeler\")."},
382 [ + - ]: 2303 : {"v2transport", RPCArg::Type::BOOL, RPCArg::Optional::NO, "Attempt to connect using BIP324 v2 transport protocol"},
383 : : },
384 : 0 : 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 [ + - + - : 9212 : }},
+ - + - +
- + - + -
+ - + - +
- + + -
- ]
390 : 2303 : RPCExamples{
391 [ + - + - : 4606 : HelpExampleCli("addconnection", "\"192.168.0.6:8333\" \"outbound-full-relay\" true")
+ - ]
392 [ + - + - : 9212 : + HelpExampleRpc("addconnection", "\"192.168.0.6:8333\" \"outbound-full-relay\" true")
+ - + - ]
393 [ + - ]: 2303 : },
394 : 144 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
395 : : {
396 [ - + ]: 144 : if (Params().GetChainType() != ChainType::REGTEST) {
397 [ # # ]: 0 : throw std::runtime_error("addconnection is for regression testing (-regtest mode) only.");
398 : : }
399 : :
400 : 144 : const std::string address = request.params[0].get_str();
401 [ + - + - : 144 : const std::string conn_type_in{TrimString(request.params[1].get_str())};
+ - ]
402 : 144 : ConnectionType conn_type{};
403 [ + + ]: 144 : if (conn_type_in == "outbound-full-relay") {
404 : : conn_type = ConnectionType::OUTBOUND_FULL_RELAY;
405 [ + + ]: 54 : } else if (conn_type_in == "block-relay-only") {
406 : : conn_type = ConnectionType::BLOCK_RELAY;
407 [ + + ]: 19 : } else if (conn_type_in == "addr-fetch") {
408 : : conn_type = ConnectionType::ADDR_FETCH;
409 [ - + ]: 4 : } else if (conn_type_in == "feeler") {
410 : : conn_type = ConnectionType::FEELER;
411 : : } else {
412 [ # # # # ]: 0 : throw JSONRPCError(RPC_INVALID_PARAMETER, self.ToString());
413 : : }
414 [ + - ]: 144 : bool use_v2transport{self.Arg<bool>("v2transport")};
415 : :
416 [ + - ]: 144 : NodeContext& node = EnsureAnyNodeContext(request.context);
417 [ + - ]: 144 : CConnman& connman = EnsureConnman(node);
418 : :
419 [ + + + - : 144 : if (use_v2transport && !(connman.GetLocalServices() & NODE_P2P_V2)) {
- + ]
420 [ # # # # ]: 0 : throw JSONRPCError(RPC_INVALID_PARAMETER, "Error: Adding v2transport connections requires -v2transport init flag to be set.");
421 : : }
422 : :
423 [ + - ]: 144 : const bool success = connman.AddConnection(address, conn_type, use_v2transport);
424 [ - + ]: 144 : if (!success) {
425 [ # # # # ]: 0 : throw JSONRPCError(RPC_CLIENT_NODE_CAPACITY_REACHED, "Error: Already at capacity for specified connection type.");
426 : : }
427 : :
428 : 144 : UniValue info(UniValue::VOBJ);
429 [ + - + - : 288 : info.pushKV("address", address);
+ - ]
430 [ + - + - : 288 : info.pushKV("connection_type", conn_type_in);
+ - ]
431 : :
432 : 144 : return info;
433 : 144 : },
434 [ + - + - : 34545 : };
+ - + - +
- + - + -
+ - + - +
- + + -
- ]
435 [ + - + - : 23030 : }
+ - + - +
- + - + -
- - - - ]
436 : :
437 : 2295 : static RPCHelpMan disconnectnode()
438 : : {
439 : 2295 : 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 [ + - ]: 4590 : {"address", RPCArg::Type::STR, RPCArg::DefaultHint{"fallback to nodeid"}, "The IP address/port of the node"},
446 [ + - ]: 4590 : {"nodeid", RPCArg::Type::NUM, RPCArg::DefaultHint{"fallback to address"}, "The node ID (see getpeerinfo for node IDs)"},
447 : : },
448 [ + - + - : 4590 : RPCResult{RPCResult::Type::NONE, "", ""},
+ - ]
449 : 2295 : RPCExamples{
450 [ + - + - : 4590 : HelpExampleCli("disconnectnode", "\"192.168.0.6:8333\"")
+ - ]
451 [ + - + - : 9180 : + HelpExampleCli("disconnectnode", "\"\" 1")
+ - + - ]
452 [ + - + - : 9180 : + HelpExampleRpc("disconnectnode", "\"192.168.0.6:8333\"")
+ - + - ]
453 [ + - + - : 9180 : + HelpExampleRpc("disconnectnode", "\"\", 1")
+ - + - ]
454 [ + - ]: 2295 : },
455 : 127 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
456 : : {
457 : 127 : NodeContext& node = EnsureAnyNodeContext(request.context);
458 : 127 : CConnman& connman = EnsureConnman(node);
459 : :
460 : 127 : bool success;
461 : 127 : const UniValue &address_arg = request.params[0];
462 : 127 : const UniValue &id_arg = request.params[1];
463 : :
464 [ + + + + ]: 127 : if (!address_arg.isNull() && id_arg.isNull()) {
465 : : /* handle disconnect-by-address */
466 : 4 : success = connman.DisconnectNode(address_arg.get_str());
467 [ + - + + : 123 : } else if (!id_arg.isNull() && (address_arg.isNull() || (address_arg.isStr() && address_arg.get_str().empty()))) {
+ - - + ]
468 : : /* handle disconnect-by-id */
469 : 121 : NodeId nodeid = (NodeId) id_arg.getInt<int64_t>();
470 : 121 : success = connman.DisconnectNode(nodeid);
471 : : } else {
472 [ + - + - ]: 4 : throw JSONRPCError(RPC_INVALID_PARAMS, "Only one of address and nodeid should be provided.");
473 : : }
474 : :
475 [ + + ]: 125 : if (!success) {
476 [ + - + - ]: 4 : throw JSONRPCError(RPC_CLIENT_NODE_NOT_CONNECTED, "Node not found in connected nodes");
477 : : }
478 : :
479 : 123 : return UniValue::VNULL;
480 : : },
481 [ + - + - : 36720 : };
+ - + - +
- + - + -
+ - + + -
- ]
482 [ + - + - : 11475 : }
+ - - - ]
483 : :
484 : 2180 : static RPCHelpMan getaddednodeinfo()
485 : : {
486 : 2180 : 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 [ + - ]: 4360 : {"node", RPCArg::Type::STR, RPCArg::DefaultHint{"all nodes"}, "If provided, return information about this specific node, otherwise all nodes are returned."},
492 : : },
493 : 0 : 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 [ + - + - : 26160 : },
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + + + +
+ + + + -
- - - - -
- - ]
511 : 2180 : RPCExamples{
512 [ + - + - : 4360 : HelpExampleCli("getaddednodeinfo", "\"192.168.0.201\"")
+ - ]
513 [ + - + - : 8720 : + HelpExampleRpc("getaddednodeinfo", "\"192.168.0.201\"")
+ - + - ]
514 [ + - ]: 2180 : },
515 : 12 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
516 : : {
517 : 12 : NodeContext& node = EnsureAnyNodeContext(request.context);
518 : 12 : const CConnman& connman = EnsureConnman(node);
519 : :
520 : 12 : std::vector<AddedNodeInfo> vInfo = connman.GetAddedNodeInfo(/*include_connected=*/true);
521 : :
522 [ + - + + ]: 12 : if (!request.params[0].isNull()) {
523 : 4 : bool found = false;
524 [ + + ]: 6 : for (const AddedNodeInfo& info : vInfo) {
525 [ + - + - : 4 : if (info.m_params.m_added_node == request.params[0].get_str()) {
+ + ]
526 [ + - ]: 2 : vInfo.assign(1, info);
527 : : found = true;
528 : : break;
529 : : }
530 : : }
531 : 2 : if (!found) {
532 [ + - + - ]: 4 : throw JSONRPCError(RPC_CLIENT_NODE_NOT_ADDED, "Error: Node has not been added.");
533 : : }
534 : : }
535 : :
536 : 10 : UniValue ret(UniValue::VARR);
537 : :
538 [ + + ]: 20 : for (const AddedNodeInfo& info : vInfo) {
539 : 10 : UniValue obj(UniValue::VOBJ);
540 [ + - + - : 20 : obj.pushKV("addednode", info.m_params.m_added_node);
+ - ]
541 [ + - + - : 20 : obj.pushKV("connected", info.fConnected);
+ - ]
542 : 10 : UniValue addresses(UniValue::VARR);
543 [ - + ]: 10 : if (info.fConnected) {
544 : 0 : UniValue address(UniValue::VOBJ);
545 [ # # # # : 0 : address.pushKV("address", info.resolvedAddress.ToStringAddrPort());
# # # # ]
546 [ # # # # : 0 : address.pushKV("connected", info.fInbound ? "inbound" : "outbound");
# # # # ]
547 [ # # ]: 0 : addresses.push_back(std::move(address));
548 : 0 : }
549 [ + - + - ]: 20 : obj.pushKV("addresses", std::move(addresses));
550 [ + - ]: 10 : ret.push_back(std::move(obj));
551 : 10 : }
552 : :
553 : 10 : return ret;
554 : 12 : },
555 [ + - + - : 23980 : };
+ - + - +
- + - + +
- - ]
556 [ + - + - : 23980 : }
+ - + - +
- + - + -
+ - + - +
- - - -
- ]
557 : :
558 : 2185 : static RPCHelpMan getnettotals()
559 : : {
560 : 2185 : return RPCHelpMan{"getnettotals",
561 : : "Returns information about network traffic, including bytes in, bytes out,\n"
562 : : "and current system time.",
563 : : {},
564 : 0 : RPCResult{
565 : : RPCResult::Type::OBJ, "", "",
566 : : {
567 : : {RPCResult::Type::NUM, "totalbytesrecv", "Total bytes received"},
568 : : {RPCResult::Type::NUM, "totalbytessent", "Total bytes sent"},
569 [ + - ]: 4370 : {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 [ + - + - : 32775 : },
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + + +
+ - - -
- ]
581 : 2185 : RPCExamples{
582 [ + - + - : 4370 : HelpExampleCli("getnettotals", "")
+ - ]
583 [ + - + - : 8740 : + HelpExampleRpc("getnettotals", "")
+ - + - ]
584 [ + - ]: 2185 : },
585 : 17 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
586 : : {
587 : 17 : NodeContext& node = EnsureAnyNodeContext(request.context);
588 : 17 : const CConnman& connman = EnsureConnman(node);
589 : :
590 : 17 : UniValue obj(UniValue::VOBJ);
591 [ + - + - : 34 : obj.pushKV("totalbytesrecv", connman.GetTotalBytesRecv());
+ - + - ]
592 [ + - + - : 34 : obj.pushKV("totalbytessent", connman.GetTotalBytesSent());
+ - + - ]
593 [ + - + - : 34 : obj.pushKV("timemillis", TicksSinceEpoch<std::chrono::milliseconds>(SystemClock::now()));
+ - ]
594 : :
595 : 17 : UniValue outboundLimit(UniValue::VOBJ);
596 [ + - + - : 34 : outboundLimit.pushKV("timeframe", count_seconds(connman.GetMaxOutboundTimeframe()));
+ - + - ]
597 [ + - + - : 34 : outboundLimit.pushKV("target", connman.GetMaxOutboundTarget());
+ - + - ]
598 [ + - + - : 34 : outboundLimit.pushKV("target_reached", connman.OutboundTargetReached(false));
+ - + - ]
599 [ + - + - : 34 : outboundLimit.pushKV("serve_historical_blocks", !connman.OutboundTargetReached(true));
+ - + - ]
600 [ + - + - : 34 : outboundLimit.pushKV("bytes_left_in_cycle", connman.GetOutboundTargetBytesLeft());
+ - + - ]
601 [ + - + - : 34 : outboundLimit.pushKV("time_left_in_cycle", count_seconds(connman.GetMaxOutboundTimeLeftInCycle()));
+ - + - ]
602 [ + - + - ]: 34 : obj.pushKV("uploadtarget", std::move(outboundLimit));
603 : 17 : return obj;
604 : 17 : },
605 [ + - + - : 13110 : };
+ - + - ]
606 [ + - + - : 24035 : }
+ - + - +
- + - + -
+ - + - +
- + - - -
- - ]
607 : :
608 : 957 : static UniValue GetNetworksInfo()
609 : : {
610 : 957 : UniValue networks(UniValue::VARR);
611 [ + + ]: 7656 : for (int n = 0; n < NET_MAX; ++n) {
612 : 6699 : enum Network network = static_cast<enum Network>(n);
613 [ + + ]: 6699 : if (network == NET_UNROUTABLE || network == NET_INTERNAL) continue;
614 [ + - ]: 4785 : Proxy proxy;
615 : 4785 : UniValue obj(UniValue::VOBJ);
616 [ + - ]: 4785 : GetProxy(network, proxy);
617 [ + - + - : 9570 : obj.pushKV("name", GetNetworkName(network));
+ - + - ]
618 [ + - + - : 9570 : obj.pushKV("limited", !g_reachable_nets.Contains(network));
+ - + - ]
619 [ + - + - : 9570 : obj.pushKV("reachable", g_reachable_nets.Contains(network));
+ - + - ]
620 [ + - + + : 9570 : obj.pushKV("proxy", proxy.IsValid() ? proxy.ToString() : std::string());
+ - + - +
- + - ]
621 [ + - + - : 9570 : obj.pushKV("proxy_randomize_credentials", proxy.m_tor_stream_isolation);
+ - ]
622 [ + - ]: 4785 : networks.push_back(std::move(obj));
623 : 9570 : }
624 : 957 : return networks;
625 : 0 : }
626 : :
627 : 3127 : static RPCHelpMan getnetworkinfo()
628 : : {
629 : 3127 : return RPCHelpMan{"getnetworkinfo",
630 : : "Returns an object containing various state info regarding P2P networking.\n",
631 : : {},
632 : 0 : 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 [ + - + - : 6254 : {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 [ + - ]: 6254 : {RPCResult::Type::NUM, "relayfee", "minimum relay fee rate for transactions in " + CURRENCY_UNIT + "/kvB"},
661 [ + - ]: 6254 : {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 [ + - + - : 3127 : (IsDeprecatedRPCEnabled("warnings") ?
- + ]
672 [ - - - - : 3127 : 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 [ + - + - : 25016 : }
+ - + - +
- + - + -
+ - + + +
- + - + -
+ - + - -
- - - - -
- - - - -
- - - -
- ]
678 : : ),
679 : : }
680 [ + - + - : 128207 : },
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
+ + + + +
+ + + + +
+ - - - -
- - - - -
- - - ]
681 : 3127 : RPCExamples{
682 [ + - + - : 6254 : HelpExampleCli("getnetworkinfo", "")
+ - ]
683 [ + - + - : 12508 : + HelpExampleRpc("getnetworkinfo", "")
+ - + - ]
684 [ + - ]: 3127 : },
685 : 957 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
686 : : {
687 : 957 : LOCK(cs_main);
688 : 957 : UniValue obj(UniValue::VOBJ);
689 [ + - + - : 1914 : obj.pushKV("version", CLIENT_VERSION);
+ - ]
690 [ + - + - : 1914 : obj.pushKV("subversion", strSubVersion);
+ - ]
691 [ + - + - : 1914 : obj.pushKV("protocolversion",PROTOCOL_VERSION);
+ - ]
692 [ + - ]: 957 : NodeContext& node = EnsureAnyNodeContext(request.context);
693 [ + - ]: 957 : if (node.connman) {
694 [ + - ]: 957 : ServiceFlags services = node.connman->GetLocalServices();
695 [ + - + - : 1914 : obj.pushKV("localservices", strprintf("%016x", services));
+ - + - ]
696 [ + - + - : 1914 : obj.pushKV("localservicesnames", GetServicesNames(services));
+ - ]
697 : : }
698 [ + - ]: 957 : if (node.peerman) {
699 [ + - ]: 957 : auto peerman_info{node.peerman->GetInfo()};
700 [ + - + - : 1914 : obj.pushKV("localrelay", !peerman_info.ignores_incoming_txs);
+ - ]
701 [ + - + - : 1914 : obj.pushKV("timeoffset", Ticks<std::chrono::seconds>(peerman_info.median_outbound_time_offset));
+ - ]
702 : : }
703 [ + - ]: 957 : if (node.connman) {
704 [ + - + - : 1914 : obj.pushKV("networkactive", node.connman->GetNetworkActive());
+ - ]
705 [ + - + - : 1914 : obj.pushKV("connections", node.connman->GetNodeCount(ConnectionDirection::Both));
+ - + - ]
706 [ + - + - : 1914 : obj.pushKV("connections_in", node.connman->GetNodeCount(ConnectionDirection::In));
+ - + - ]
707 [ + - + - : 1914 : obj.pushKV("connections_out", node.connman->GetNodeCount(ConnectionDirection::Out));
+ - + - ]
708 : : }
709 [ + - + - : 1914 : obj.pushKV("networks", GetNetworksInfo());
+ - ]
710 [ + - ]: 957 : if (node.mempool) {
711 : : // Those fields can be deprecated, to be replaced by the getmempoolinfo fields
712 [ + - + - : 1914 : obj.pushKV("relayfee", ValueFromAmount(node.mempool->m_opts.min_relay_feerate.GetFeePerK()));
+ - ]
713 [ + - + - : 1914 : obj.pushKV("incrementalfee", ValueFromAmount(node.mempool->m_opts.incremental_relay_feerate.GetFeePerK()));
+ - ]
714 : : }
715 : 957 : UniValue localAddresses(UniValue::VARR);
716 : 957 : {
717 [ + - ]: 957 : LOCK(g_maplocalhost_mutex);
718 [ - + ]: 957 : for (const std::pair<const CNetAddr, LocalServiceInfo> &item : mapLocalHost)
719 : : {
720 : 0 : UniValue rec(UniValue::VOBJ);
721 [ # # # # : 0 : rec.pushKV("address", item.first.ToStringAddr());
# # # # ]
722 [ # # # # : 0 : rec.pushKV("port", item.second.nPort);
# # ]
723 [ # # # # : 0 : rec.pushKV("score", item.second.nScore);
# # ]
724 [ # # ]: 0 : localAddresses.push_back(std::move(rec));
725 : 0 : }
726 : 0 : }
727 [ + - + - ]: 1914 : obj.pushKV("localaddresses", std::move(localAddresses));
728 [ + - + - : 1914 : obj.pushKV("warnings", node::GetWarningsForRpc(*CHECK_NONFATAL(node.warnings), IsDeprecatedRPCEnabled("warnings")));
+ - + - +
- + - ]
729 : 1914 : return obj;
730 [ + - ]: 1914 : },
731 [ + - + - : 18762 : };
+ - + - ]
732 [ + - + - : 90683 : }
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
- - + - +
- - - - -
- - ]
733 : :
734 : 2217 : static RPCHelpMan setban()
735 : : {
736 : 2217 : return RPCHelpMan{
737 : : "setban",
738 : : "Attempts to add or remove an IP/Subnet from the banned list.\n",
739 : : {
740 [ + - ]: 2217 : {"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 [ + - ]: 2217 : {"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 [ + - ]: 4434 : {"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 [ + - ]: 6651 : {"absolute", RPCArg::Type::BOOL, RPCArg::Default{false}, "If set, the bantime must be an absolute timestamp expressed in " + UNIX_EPOCH_TIME},
744 : : },
745 [ + - + - : 4434 : RPCResult{RPCResult::Type::NONE, "", ""},
+ - ]
746 : 2217 : RPCExamples{
747 [ + - + - : 4434 : HelpExampleCli("setban", "\"192.168.0.6\" \"add\" 86400")
+ - ]
748 [ + - + - : 8868 : + HelpExampleCli("setban", "\"192.168.0.0/24\" \"add\"")
+ - + - ]
749 [ + - + - : 8868 : + HelpExampleRpc("setban", "\"192.168.0.6\", \"add\", 86400")
+ - + - ]
750 [ + - ]: 2217 : },
751 : 48 : [&](const RPCHelpMan& help, const JSONRPCRequest& request) -> UniValue
752 : : {
753 [ + - ]: 48 : std::string strCommand;
754 [ + - + - ]: 48 : if (!request.params[1].isNull())
755 [ + - + - : 48 : strCommand = request.params[1].get_str();
+ - ]
756 [ + + - + ]: 48 : if (strCommand != "add" && strCommand != "remove") {
757 [ # # # # ]: 0 : throw std::runtime_error(help.ToString());
758 : : }
759 [ + - ]: 48 : NodeContext& node = EnsureAnyNodeContext(request.context);
760 [ + - ]: 48 : BanMan& banman = EnsureBanman(node);
761 : :
762 [ + - ]: 48 : CSubNet subNet;
763 [ + - ]: 48 : CNetAddr netAddr;
764 : 48 : bool isSubnet = false;
765 : :
766 [ + - + - : 48 : if (request.params[0].get_str().find('/') != std::string::npos)
+ + ]
767 : 18 : isSubnet = true;
768 : :
769 : 48 : if (!isSubnet) {
770 [ + - + - : 30 : const std::optional<CNetAddr> addr{LookupHost(request.params[0].get_str(), false)};
+ - + - ]
771 [ + + ]: 30 : if (addr.has_value()) {
772 [ + - + - ]: 29 : netAddr = static_cast<CNetAddr>(MaybeFlipIPv6toCJDNS(CService{addr.value(), /*port=*/0}));
773 : : }
774 : 30 : }
775 : : else
776 [ + - + - : 18 : subNet = LookupSubNet(request.params[0].get_str());
+ - ]
777 : :
778 [ + + + - : 48 : if (! (isSubnet ? subNet.IsValid() : netAddr.IsValid()) )
+ - + + ]
779 [ + - + - ]: 6 : throw JSONRPCError(RPC_CLIENT_INVALID_IP_OR_SUBNET, "Error: Invalid IP/Subnet");
780 : :
781 [ + + ]: 45 : if (strCommand == "add")
782 : : {
783 [ + + + - : 35 : if (isSubnet ? banman.IsBanned(subNet) : banman.IsBanned(netAddr)) {
+ - + + ]
784 [ + - + - ]: 8 : throw JSONRPCError(RPC_CLIENT_NODE_ALREADY_ADDED, "Error: IP/Subnet already banned");
785 : : }
786 : :
787 : 31 : int64_t banTime = 0; //use standard bantime if not specified
788 [ + - + + ]: 31 : if (!request.params[2].isNull())
789 [ + - + - ]: 10 : banTime = request.params[2].getInt<int64_t>();
790 : :
791 [ + - + + : 31 : const bool absolute{request.params[3].isNull() ? false : request.params[3].get_bool()};
+ - + - ]
792 : :
793 [ + - + - : 5 : if (absolute && banTime < GetTime()) {
+ + ]
794 [ + - + - ]: 4 : throw JSONRPCError(RPC_INVALID_PARAMETER, "Error: Absolute timestamp is in the past");
795 : : }
796 : :
797 [ + + ]: 29 : if (isSubnet) {
798 [ + - ]: 13 : banman.Ban(subNet, banTime, absolute);
799 [ + - ]: 13 : if (node.connman) {
800 [ + - ]: 13 : node.connman->DisconnectNode(subNet);
801 : : }
802 : : } else {
803 [ + - ]: 16 : banman.Ban(netAddr, banTime, absolute);
804 [ + - ]: 16 : if (node.connman) {
805 [ + - ]: 16 : node.connman->DisconnectNode(netAddr);
806 : : }
807 : : }
808 : : }
809 [ + - ]: 10 : else if(strCommand == "remove")
810 : : {
811 [ + + + - : 10 : if (!( isSubnet ? banman.Unban(subNet) : banman.Unban(netAddr) )) {
+ - + + ]
812 [ + - + - ]: 4 : throw JSONRPCError(RPC_CLIENT_INVALID_IP_OR_SUBNET, "Error: Unban failed. Requested address/subnet was not previously manually banned.");
813 : : }
814 : : }
815 : 37 : return UniValue::VNULL;
816 : 59 : },
817 [ + - + - : 48774 : };
+ - + - +
- + - + -
+ - + - +
- + - + -
+ + - - ]
818 [ + - + - : 19953 : }
+ - + - +
- - - ]
819 : :
820 : 2215 : static RPCHelpMan listbanned()
821 : : {
822 : 2215 : return RPCHelpMan{
823 : : "listbanned",
824 : : "List all manually banned IPs/Subnets.\n",
825 : : {},
826 : 0 : RPCResult{RPCResult::Type::ARR, "", "",
827 : : {
828 : : {RPCResult::Type::OBJ, "", "",
829 : : {
830 : : {RPCResult::Type::STR, "address", "The IP/Subnet of the banned node"},
831 [ + - ]: 4430 : {RPCResult::Type::NUM_TIME, "ban_created", "The " + UNIX_EPOCH_TIME + " the ban was created"},
832 [ + - ]: 4430 : {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 [ + - + - : 28795 : }},
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + + + +
- - - - ]
837 : 2215 : RPCExamples{
838 [ + - + - : 4430 : HelpExampleCli("listbanned", "")
+ - ]
839 [ + - + - : 8860 : + HelpExampleRpc("listbanned", "")
+ - + - ]
840 [ + - ]: 2215 : },
841 : 47 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
842 : : {
843 : 47 : BanMan& banman = EnsureAnyBanman(request.context);
844 : :
845 [ + - ]: 47 : banmap_t banMap;
846 [ + - ]: 47 : banman.GetBanned(banMap);
847 [ + - ]: 47 : const int64_t current_time{GetTime()};
848 : :
849 : 47 : UniValue bannedAddresses(UniValue::VARR);
850 [ + + ]: 107 : for (const auto& entry : banMap)
851 : : {
852 : 60 : const CBanEntry& banEntry = entry.second;
853 : 60 : UniValue rec(UniValue::VOBJ);
854 [ + - + - : 120 : rec.pushKV("address", entry.first.ToString());
+ - + - ]
855 [ + - + - : 120 : rec.pushKV("ban_created", banEntry.nCreateTime);
+ - ]
856 [ + - + - : 120 : rec.pushKV("banned_until", banEntry.nBanUntil);
+ - ]
857 [ + - + - : 120 : rec.pushKV("ban_duration", (banEntry.nBanUntil - banEntry.nCreateTime));
+ - ]
858 [ + - + - : 120 : rec.pushKV("time_remaining", (banEntry.nBanUntil - current_time));
+ - ]
859 : :
860 [ + - ]: 60 : bannedAddresses.push_back(std::move(rec));
861 : 60 : }
862 : :
863 : 47 : return bannedAddresses;
864 : 47 : },
865 [ + - + - : 13290 : };
+ - + - ]
866 [ + - + - : 15505 : }
+ - + - +
- + - + -
- - ]
867 : :
868 : 2179 : static RPCHelpMan clearbanned()
869 : : {
870 : 2179 : return RPCHelpMan{
871 : : "clearbanned",
872 : : "Clear all banned IPs.\n",
873 : : {},
874 [ + - + - : 4358 : RPCResult{RPCResult::Type::NONE, "", ""},
+ - ]
875 : 2179 : RPCExamples{
876 [ + - + - : 4358 : HelpExampleCli("clearbanned", "")
+ - ]
877 [ + - + - : 8716 : + HelpExampleRpc("clearbanned", "")
+ - + - ]
878 [ + - ]: 2179 : },
879 : 11 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
880 : : {
881 : 11 : BanMan& banman = EnsureAnyBanman(request.context);
882 : :
883 : 11 : banman.ClearBanned();
884 : :
885 : 11 : return UniValue::VNULL;
886 : : },
887 [ + - + - : 13074 : };
+ - + - ]
888 : : }
889 : :
890 : 2181 : static RPCHelpMan setnetworkactive()
891 : : {
892 : 2181 : return RPCHelpMan{
893 : : "setnetworkactive",
894 : : "Disable/enable all p2p network activity.\n",
895 : : {
896 [ + - ]: 2181 : {"state", RPCArg::Type::BOOL, RPCArg::Optional::NO, "true to enable networking, false to disable"},
897 : : },
898 [ + - + - : 4362 : RPCResult{RPCResult::Type::BOOL, "", "The value that was passed in"},
+ - ]
899 [ + - + - ]: 6543 : RPCExamples{""},
900 : 13 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
901 : : {
902 : 13 : NodeContext& node = EnsureAnyNodeContext(request.context);
903 : 13 : CConnman& connman = EnsureConnman(node);
904 : :
905 : 13 : connman.SetNetworkActive(request.params[0].get_bool());
906 : :
907 : 13 : return connman.GetNetworkActive();
908 : : },
909 [ + - + - : 19629 : };
+ - + - +
- + - + +
- - ]
910 [ + - + - ]: 6543 : }
911 : :
912 : 2205 : static RPCHelpMan getnodeaddresses()
913 : : {
914 : 2205 : 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 [ + - ]: 4410 : {"count", RPCArg::Type::NUM, RPCArg::Default{1}, "The maximum number of addresses to return. Specify 0 to return all known addresses."},
920 [ + - + - : 8820 : {"network", RPCArg::Type::STR, RPCArg::DefaultHint{"all networks"}, "Return only addresses of the specified network. Can be one of: " + Join(GetNetworkNames(), ", ") + "."},
+ - ]
921 : : },
922 : 0 : RPCResult{
923 : : RPCResult::Type::ARR, "", "",
924 : : {
925 : : {RPCResult::Type::OBJ, "", "",
926 : : {
927 [ + - ]: 4410 : {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 [ + - + - : 4410 : {RPCResult::Type::STR, "network", "The network (" + Join(GetNetworkNames(), ", ") + ") the node connected through"},
+ - ]
932 : : }},
933 : : }
934 [ + - + - : 28665 : },
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + + + +
- - - - ]
935 : 2205 : RPCExamples{
936 [ + - + - : 4410 : HelpExampleCli("getnodeaddresses", "8")
+ - ]
937 [ + - + - : 8820 : + HelpExampleCli("getnodeaddresses", "4 \"i2p\"")
+ - + - ]
938 [ + - + - : 8820 : + HelpExampleCli("-named getnodeaddresses", "network=onion count=12")
+ - + - ]
939 [ + - + - : 8820 : + HelpExampleRpc("getnodeaddresses", "8")
+ - + - ]
940 [ + - + - : 8820 : + HelpExampleRpc("getnodeaddresses", "4, \"i2p\"")
+ - + - ]
941 [ + - ]: 2205 : },
942 : 37 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
943 : : {
944 : 37 : NodeContext& node = EnsureAnyNodeContext(request.context);
945 : 37 : const CConnman& connman = EnsureConnman(node);
946 : :
947 [ + + ]: 37 : const int count{request.params[0].isNull() ? 1 : request.params[0].getInt<int>()};
948 [ + + + - : 33 : if (count < 0) throw JSONRPCError(RPC_INVALID_PARAMETER, "Address count out of range");
+ - ]
949 : :
950 [ + + ]: 35 : const std::optional<Network> network{request.params[1].isNull() ? std::nullopt : std::optional<Network>{ParseNetwork(request.params[1].get_str())}};
951 [ + + ]: 35 : if (network == NET_UNROUTABLE) {
952 [ + - + - : 4 : 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 : 33 : const std::vector<CAddress> vAddr{connman.GetAddresses(count, /*max_pct=*/0, network)};
957 : 33 : UniValue ret(UniValue::VARR);
958 : :
959 [ + + ]: 27697 : for (const CAddress& addr : vAddr) {
960 : 27664 : UniValue obj(UniValue::VOBJ);
961 [ + - + - : 55328 : obj.pushKV("time", int64_t{TicksSinceEpoch<std::chrono::seconds>(addr.nTime)});
+ - ]
962 [ + - + - : 55328 : obj.pushKV("services", (uint64_t)addr.nServices);
+ - ]
963 [ + - + - : 55328 : obj.pushKV("address", addr.ToStringAddr());
+ - + - ]
964 [ + - + - : 55328 : obj.pushKV("port", addr.GetPort());
+ - + - ]
965 [ + - + - : 55328 : obj.pushKV("network", GetNetworkName(addr.GetNetClass()));
+ - + - +
- ]
966 [ + - ]: 27664 : ret.push_back(std::move(obj));
967 : 27664 : }
968 : 33 : return ret;
969 : 33 : },
970 [ + - + - : 35280 : };
+ - + - +
- + - + -
+ - + + -
- ]
971 [ + - + - : 26460 : }
+ - + - +
- + - + -
+ - + - +
- - - -
- ]
972 : :
973 : 34341 : static RPCHelpMan addpeeraddress()
974 : : {
975 : 34341 : return RPCHelpMan{"addpeeraddress",
976 : : "Add the address of a potential peer to an address manager table. This RPC is for testing only.",
977 : : {
978 [ + - ]: 34341 : {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The IP address of the peer"},
979 [ + - ]: 34341 : {"port", RPCArg::Type::NUM, RPCArg::Optional::NO, "The port of the peer"},
980 [ + - ]: 68682 : {"tried", RPCArg::Type::BOOL, RPCArg::Default{false}, "If true, attempt to add the peer to the tried addresses table"},
981 : : },
982 : 0 : 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 [ + - + - : 137364 : },
+ - + - +
- + - + -
+ - + - +
- + + -
- ]
989 : 34341 : RPCExamples{
990 [ + - + - : 68682 : HelpExampleCli("addpeeraddress", "\"1.2.3.4\" 8333 true")
+ - ]
991 [ + - + - : 137364 : + HelpExampleRpc("addpeeraddress", "\"1.2.3.4\", 8333, true")
+ - + - ]
992 [ + - ]: 34341 : },
993 : 32178 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
994 : : {
995 : 32178 : AddrMan& addrman = EnsureAnyAddrman(request.context);
996 : :
997 : 32178 : const std::string& addr_string{request.params[0].get_str()};
998 : 32178 : const auto port{request.params[1].getInt<uint16_t>()};
999 [ + + ]: 32174 : const bool tried{request.params[2].isNull() ? false : request.params[2].get_bool()};
1000 : :
1001 : 32174 : UniValue obj(UniValue::VOBJ);
1002 [ + - + - ]: 32174 : std::optional<CNetAddr> net_addr{LookupHost(addr_string, false)};
1003 : 32174 : bool success{false};
1004 : :
1005 [ + + ]: 32174 : if (net_addr.has_value()) {
1006 [ + - ]: 32172 : CService service{net_addr.value(), port};
1007 [ + - ]: 32172 : CAddress address{MaybeFlipIPv6toCJDNS(service), ServiceFlags{NODE_NETWORK | NODE_WITNESS}};
1008 : 32172 : address.nTime = Now<NodeSeconds>();
1009 : : // The source address is set equal to the address. This is equivalent to the peer
1010 : : // announcing itself.
1011 [ + - + - : 64344 : if (addrman.Add({address}, address)) {
+ + + + -
- ]
1012 : 28417 : success = true;
1013 [ + + ]: 28417 : if (tried) {
1014 : : // Attempt to move the address to the tried addresses table.
1015 [ + - + + ]: 22 : if (!addrman.Good(address)) {
1016 : 2 : success = false;
1017 [ + - + - : 4 : obj.pushKV("error", "failed-adding-to-tried");
+ - ]
1018 : : }
1019 : : }
1020 : : } else {
1021 [ + - + - : 7510 : obj.pushKV("error", "failed-adding-to-new");
+ - ]
1022 : : }
1023 : 32172 : }
1024 : :
1025 [ + - + - : 64348 : obj.pushKV("success", success);
+ - ]
1026 : 32174 : return obj;
1027 : 64346 : },
1028 [ + - + - : 583797 : };
+ - + - +
- + - + -
+ - + - +
- + + -
- ]
1029 [ + - + - : 343410 : }
+ - + - +
- + - + -
- - - - ]
1030 : :
1031 : 2177 : static RPCHelpMan sendmsgtopeer()
1032 : : {
1033 : 2177 : 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 [ + - ]: 2177 : {"peer_id", RPCArg::Type::NUM, RPCArg::Optional::NO, "The peer to send the message to."},
1040 [ + - ]: 4354 : {"msg_type", RPCArg::Type::STR, RPCArg::Optional::NO, strprintf("The message type (maximum length %i)", CMessageHeader::MESSAGE_TYPE_SIZE)},
1041 [ + - ]: 2177 : {"msg", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The serialized message body to send, in hex, without a message header"},
1042 : : },
1043 [ + - + - : 4354 : RPCResult{RPCResult::Type::OBJ, "", "", std::vector<RPCResult>{}},
+ - ]
1044 : 2177 : RPCExamples{
1045 [ + - + - : 6531 : HelpExampleCli("sendmsgtopeer", "0 \"addr\" \"ffffff\"") + HelpExampleRpc("sendmsgtopeer", "0 \"addr\" \"ffffff\"")},
+ - + - +
- + - + -
+ - ]
1046 : 18 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue {
1047 : 18 : const NodeId peer_id{request.params[0].getInt<int64_t>()};
1048 : 18 : const std::string& msg_type{request.params[1].get_str()};
1049 [ + + ]: 18 : if (msg_type.size() > CMessageHeader::MESSAGE_TYPE_SIZE) {
1050 [ + - + - ]: 4 : throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Error: msg_type too long, max length is %i", CMessageHeader::MESSAGE_TYPE_SIZE));
1051 : : }
1052 : 16 : auto msg{TryParseHex<unsigned char>(request.params[2].get_str())};
1053 [ - + ]: 16 : if (!msg.has_value()) {
1054 [ # # # # ]: 0 : throw JSONRPCError(RPC_INVALID_PARAMETER, "Error parsing input for msg");
1055 : : }
1056 : :
1057 [ + - ]: 16 : NodeContext& node = EnsureAnyNodeContext(request.context);
1058 [ + - ]: 16 : CConnman& connman = EnsureConnman(node);
1059 : :
1060 [ + - ]: 16 : CSerializedNetMsg msg_ser;
1061 [ + - + - ]: 16 : msg_ser.data = msg.value();
1062 [ + - ]: 16 : msg_ser.m_type = msg_type;
1063 : :
1064 [ + - ]: 16 : bool success = connman.ForNode(peer_id, [&](CNode* node) {
1065 : 14 : connman.PushMessage(node, std::move(msg_ser));
1066 : 14 : return true;
1067 : : });
1068 : :
1069 [ + + ]: 16 : if (!success) {
1070 [ + - + - ]: 4 : throw JSONRPCError(RPC_MISC_ERROR, "Error: Could not send message to peer");
1071 : : }
1072 : :
1073 : 14 : UniValue ret{UniValue::VOBJ};
1074 : 14 : return ret;
1075 : 16 : },
1076 [ + - + - : 32655 : };
+ - + - +
- + - + -
+ - + - +
- + + -
- ]
1077 [ + - + - : 15239 : }
+ - + - -
- ]
1078 : :
1079 : 2176 : static RPCHelpMan getaddrmaninfo()
1080 : : {
1081 : 2176 : 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 : 0 : RPCResult{
1087 : : RPCResult::Type::OBJ_DYN, "", "json object with network type as keys", {
1088 [ + - + - : 4352 : {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 [ + - + - : 19584 : }},
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + + + +
- - - - ]
1094 [ + - + - : 6528 : RPCExamples{HelpExampleCli("getaddrmaninfo", "") + HelpExampleRpc("getaddrmaninfo", "")},
+ - + - +
- + - + -
+ - ]
1095 : 8 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue {
1096 : 8 : AddrMan& addrman = EnsureAnyAddrman(request.context);
1097 : :
1098 : 8 : UniValue ret(UniValue::VOBJ);
1099 [ + + ]: 64 : for (int n = 0; n < NET_MAX; ++n) {
1100 : 56 : enum Network network = static_cast<enum Network>(n);
1101 [ + + ]: 56 : if (network == NET_UNROUTABLE || network == NET_INTERNAL) continue;
1102 : 40 : UniValue obj(UniValue::VOBJ);
1103 [ + - + - : 80 : obj.pushKV("new", addrman.Size(network, true));
+ - + - ]
1104 [ + - + - : 80 : obj.pushKV("tried", addrman.Size(network, false));
+ - + - ]
1105 [ + - + - : 80 : obj.pushKV("total", addrman.Size(network));
+ - + - ]
1106 [ + - + - ]: 80 : ret.pushKV(GetNetworkName(network), std::move(obj));
1107 : 40 : }
1108 : 8 : UniValue obj(UniValue::VOBJ);
1109 [ + - + - : 16 : obj.pushKV("new", addrman.Size(std::nullopt, true));
+ - + - ]
1110 [ + - + - : 16 : obj.pushKV("tried", addrman.Size(std::nullopt, false));
+ - + - ]
1111 [ + - + - : 16 : obj.pushKV("total", addrman.Size());
+ - + - ]
1112 [ + - + - ]: 16 : ret.pushKV("all_networks", std::move(obj));
1113 : 8 : return ret;
1114 : 8 : },
1115 [ + - + - : 13056 : };
+ - + - ]
1116 [ + - + - : 10880 : }
+ - + - +
- - - ]
1117 : :
1118 : 26 : UniValue AddrmanEntryToJSON(const AddrInfo& info, const CConnman& connman)
1119 : : {
1120 : 26 : UniValue ret(UniValue::VOBJ);
1121 [ + - + - : 52 : ret.pushKV("address", info.ToStringAddr());
+ - + - ]
1122 [ + - ]: 26 : const uint32_t mapped_as{connman.GetMappedAS(info)};
1123 [ + + ]: 26 : if (mapped_as) {
1124 [ + - + - : 8 : ret.pushKV("mapped_as", mapped_as);
+ - ]
1125 : : }
1126 [ + - + - : 52 : ret.pushKV("port", info.GetPort());
+ - + - ]
1127 [ + - + - : 52 : ret.pushKV("services", (uint64_t)info.nServices);
+ - ]
1128 [ + - + - : 52 : ret.pushKV("time", int64_t{TicksSinceEpoch<std::chrono::seconds>(info.nTime)});
+ - ]
1129 [ + - + - : 52 : ret.pushKV("network", GetNetworkName(info.GetNetClass()));
+ - + - +
- ]
1130 [ + - + - : 52 : ret.pushKV("source", info.source.ToStringAddr());
+ - + - ]
1131 [ + - + - : 52 : ret.pushKV("source_network", GetNetworkName(info.source.GetNetClass()));
+ - + - +
- ]
1132 [ + - ]: 26 : const uint32_t source_mapped_as{connman.GetMappedAS(info.source)};
1133 [ + + ]: 26 : if (source_mapped_as) {
1134 [ + - + - : 8 : ret.pushKV("source_mapped_as", source_mapped_as);
+ - ]
1135 : : }
1136 : 26 : return ret;
1137 : 0 : }
1138 : :
1139 : 14 : UniValue AddrmanTableToJSON(const std::vector<std::pair<AddrInfo, AddressPosition>>& tableInfos, const CConnman& connman)
1140 : : {
1141 : 14 : UniValue table(UniValue::VOBJ);
1142 [ + + ]: 40 : for (const auto& e : tableInfos) {
1143 : 26 : AddrInfo info = e.first;
1144 : 26 : AddressPosition location = e.second;
1145 [ + - ]: 26 : std::ostringstream key;
1146 [ + - + - : 26 : 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 [ + - + - ]: 78 : table.pushKVEnd(key.str(), AddrmanEntryToJSON(info, connman));
1151 : 52 : }
1152 : 14 : return table;
1153 : 0 : }
1154 : :
1155 : 2168 : static RPCHelpMan getrawaddrman()
1156 : : {
1157 : 2168 : 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 : 0 : 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 [ + - + - : 4336 : {RPCResult::Type::STR, "network", "The network (" + Join(GetNetworkNames(), ", ") + ") of the address"},
+ - ]
1169 : : {RPCResult::Type::NUM, "services", "The services offered by the node"},
1170 [ + - ]: 4336 : {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 [ + - + - : 4336 : {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 [ + - + - : 45528 : },
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
+ + + + +
- - - - -
- ]
1178 : 2168 : RPCExamples{
1179 [ + - + - : 4336 : HelpExampleCli("getrawaddrman", "")
+ - ]
1180 [ + - + - : 8672 : + HelpExampleRpc("getrawaddrman", "")
+ - + - ]
1181 [ + - ]: 2168 : },
1182 : 7 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue {
1183 : 7 : AddrMan& addrman = EnsureAnyAddrman(request.context);
1184 : 7 : NodeContext& node_context = EnsureAnyNodeContext(request.context);
1185 : 7 : CConnman& connman = EnsureConnman(node_context);
1186 : :
1187 : 7 : UniValue ret(UniValue::VOBJ);
1188 [ + - + - : 14 : ret.pushKV("new", AddrmanTableToJSON(addrman.GetEntries(false), connman));
+ - + - ]
1189 [ + - + - : 14 : ret.pushKV("tried", AddrmanTableToJSON(addrman.GetEntries(true), connman));
+ - + - ]
1190 : 7 : return ret;
1191 : 0 : },
1192 [ + - + - : 13008 : };
+ - + - ]
1193 [ + - + - : 26016 : }
+ - + - +
- + - + -
+ - + - +
- + - + -
- - ]
1194 : :
1195 : 1209 : void RegisterNetRPCCommands(CRPCTable& t)
1196 : : {
1197 : 1209 : 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 [ + + + - : 1209 : };
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - - - ]
1217 [ + + ]: 22971 : for (const auto& c : commands) {
1218 : 21762 : t.appendCommand(c.name, &c);
1219 : : }
1220 : 1209 : }
|
