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 <string_view>
40 : : #include <vector>
41 : :
42 : : using node::NodeContext;
43 : : using util::Join;
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 : : "private-broadcast (short-lived automatic connection for broadcasting privacy-sensitive transactions)"
53 : : };
54 : :
55 : : const std::vector<std::string> TRANSPORT_TYPE_DOC{
56 : : "detecting (peer could be v1 or v2)",
57 : : "v1 (plaintext transport protocol)",
58 : : "v2 (BIP324 encrypted transport protocol)"
59 : : };
60 : :
61 : 2397 : static RPCHelpMan getconnectioncount()
62 : : {
63 : 2397 : return RPCHelpMan{
64 : 2397 : "getconnectioncount",
65 [ + - ]: 4794 : "Returns the number of connections to other nodes.\n",
66 : : {},
67 [ + - ]: 4794 : RPCResult{
68 [ + - ]: 4794 : RPCResult::Type::NUM, "", "The connection count"
69 [ + - ]: 4794 : },
70 : 2397 : RPCExamples{
71 [ + - + - : 4794 : HelpExampleCli("getconnectioncount", "")
+ - ]
72 [ + - + - : 9588 : + HelpExampleRpc("getconnectioncount", "")
+ - + - ]
73 [ + - ]: 2397 : },
74 : 2397 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
75 : : {
76 : 6 : NodeContext& node = EnsureAnyNodeContext(request.context);
77 : 6 : const CConnman& connman = EnsureConnman(node);
78 : :
79 : 6 : return connman.GetNodeCount(ConnectionDirection::Both);
80 : : },
81 [ + - + - ]: 9588 : };
82 : : }
83 : :
84 : 2396 : static RPCHelpMan ping()
85 : : {
86 : 2396 : return RPCHelpMan{
87 : 2396 : "ping",
88 [ + - ]: 4792 : "Requests that a ping be sent to all other nodes, to measure ping time.\n"
89 : : "Results are provided in getpeerinfo.\n"
90 : : "Ping command is handled in queue with all other commands, so it measures processing backlog, not just network ping.\n",
91 : : {},
92 [ + - + - : 4792 : RPCResult{RPCResult::Type::NONE, "", ""},
+ - ]
93 : 2396 : RPCExamples{
94 [ + - + - : 4792 : HelpExampleCli("ping", "")
+ - ]
95 [ + - + - : 9584 : + HelpExampleRpc("ping", "")
+ - + - ]
96 [ + - ]: 2396 : },
97 : 2396 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
98 : : {
99 : 5 : NodeContext& node = EnsureAnyNodeContext(request.context);
100 : 5 : PeerManager& peerman = EnsurePeerman(node);
101 : :
102 : : // Request that each node send a ping during next message processing pass
103 : 5 : peerman.SendPings();
104 : 5 : return UniValue::VNULL;
105 : : },
106 [ + - + - ]: 9584 : };
107 : : }
108 : :
109 : : /** Returns, given services flags, a list of humanly readable (known) network services */
110 : 14041 : static UniValue GetServicesNames(ServiceFlags services)
111 : : {
112 : 14041 : UniValue servicesNames(UniValue::VARR);
113 : :
114 [ + - + + ]: 50397 : for (const auto& flag : serviceFlagsToStr(services)) {
115 [ + - + - ]: 36356 : servicesNames.push_back(flag);
116 : 14041 : }
117 : :
118 : 14041 : return servicesNames;
119 : 0 : }
120 : :
121 : 8561 : static RPCHelpMan getpeerinfo()
122 : : {
123 : 8561 : return RPCHelpMan{
124 : 8561 : "getpeerinfo",
125 [ + - ]: 17122 : "Returns data about each connected network peer as a json array of objects.",
126 : : {},
127 [ + - ]: 17122 : RPCResult{
128 [ + - ]: 17122 : RPCResult::Type::ARR, "", "",
129 : : {
130 [ + - + - ]: 17122 : {RPCResult::Type::OBJ, "", "",
131 : : {
132 : : {
133 [ + - + - ]: 17122 : {RPCResult::Type::NUM, "id", "Peer index"},
134 [ + - + - ]: 17122 : {RPCResult::Type::STR, "addr", "(host:port) The IP address/hostname optionally followed by :port of the peer"},
135 [ + - + - ]: 17122 : {RPCResult::Type::STR, "addrbind", /*optional=*/true, "(ip:port) Bind address of the connection to the peer"},
136 [ + - + - ]: 17122 : {RPCResult::Type::STR, "addrlocal", /*optional=*/true, "(ip:port) Local address as reported by the peer"},
137 [ + - + - : 17122 : {RPCResult::Type::STR, "network", "Network (" + Join(GetNetworkNames(/*append_unroutable=*/true), ", ") + ")"},
+ - + - ]
138 [ + - + - ]: 17122 : {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"
139 : : "peer selection (only displayed if the -asmap config option is set)"},
140 [ + - + - ]: 17122 : {RPCResult::Type::STR_HEX, "services", "The services offered"},
141 [ + - + - ]: 17122 : {RPCResult::Type::ARR, "servicesnames", "the services offered, in human-readable form",
142 : : {
143 [ + - + - ]: 17122 : {RPCResult::Type::STR, "SERVICE_NAME", "the service name if it is recognised"}
144 : : }},
145 [ + - + - ]: 17122 : {RPCResult::Type::BOOL, "relaytxes", "Whether we relay transactions to this peer"},
146 [ + - + - ]: 17122 : {RPCResult::Type::NUM, "last_inv_sequence", "Mempool sequence number of this peer's last INV"},
147 [ + - + - ]: 17122 : {RPCResult::Type::NUM, "inv_to_send", "How many txs we have queued to announce to this peer"},
148 [ + - + - ]: 17122 : {RPCResult::Type::NUM_TIME, "lastsend", "The " + UNIX_EPOCH_TIME + " of the last send"},
149 [ + - + - ]: 17122 : {RPCResult::Type::NUM_TIME, "lastrecv", "The " + UNIX_EPOCH_TIME + " of the last receive"},
150 [ + - + - ]: 17122 : {RPCResult::Type::NUM_TIME, "last_transaction", "The " + UNIX_EPOCH_TIME + " of the last valid transaction received from this peer"},
151 [ + - + - ]: 17122 : {RPCResult::Type::NUM_TIME, "last_block", "The " + UNIX_EPOCH_TIME + " of the last block received from this peer"},
152 [ + - + - ]: 17122 : {RPCResult::Type::NUM, "bytessent", "The total bytes sent"},
153 [ + - + - ]: 17122 : {RPCResult::Type::NUM, "bytesrecv", "The total bytes received"},
154 [ + - + - ]: 17122 : {RPCResult::Type::NUM_TIME, "conntime", "The " + UNIX_EPOCH_TIME + " of the connection"},
155 [ + - + - ]: 17122 : {RPCResult::Type::NUM, "timeoffset", "The time offset in seconds"},
156 [ + - + - ]: 17122 : {RPCResult::Type::NUM, "pingtime", /*optional=*/true, "The last ping time in seconds, if any"},
157 [ + - + - ]: 17122 : {RPCResult::Type::NUM, "minping", /*optional=*/true, "The minimum observed ping time in seconds, if any"},
158 [ + - + - ]: 17122 : {RPCResult::Type::NUM, "pingwait", /*optional=*/true, "The duration in seconds of an outstanding ping (if non-zero)"},
159 [ + - + - ]: 17122 : {RPCResult::Type::NUM, "version", "The peer version, such as 70001"},
160 [ + - + - ]: 17122 : {RPCResult::Type::STR, "subver", "The string version"},
161 [ + - + - ]: 17122 : {RPCResult::Type::BOOL, "inbound", "Inbound (true) or Outbound (false)"},
162 [ + - + - ]: 17122 : {RPCResult::Type::BOOL, "bip152_hb_to", "Whether we selected peer as (compact blocks) high-bandwidth peer"},
163 [ + - + - ]: 17122 : {RPCResult::Type::BOOL, "bip152_hb_from", "Whether peer selected us as (compact blocks) high-bandwidth peer"},
164 [ + - + - ]: 17122 : {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"},
165 [ + - + - ]: 17122 : {RPCResult::Type::NUM, "synced_headers", "The last header we have in common with this peer"},
166 [ + - + - ]: 17122 : {RPCResult::Type::NUM, "synced_blocks", "The last block we have in common with this peer"},
167 [ + - + - ]: 17122 : {RPCResult::Type::ARR, "inflight", "",
168 : : {
169 [ + - + - ]: 17122 : {RPCResult::Type::NUM, "n", "The heights of blocks we're currently asking from this peer"},
170 : : }},
171 [ + - + - ]: 17122 : {RPCResult::Type::BOOL, "addr_relay_enabled", "Whether we participate in address relay with this peer"},
172 [ + - + - ]: 17122 : {RPCResult::Type::NUM, "addr_processed", "The total number of addresses processed, excluding those dropped due to rate limiting"},
173 [ + - + - ]: 17122 : {RPCResult::Type::NUM, "addr_rate_limited", "The total number of addresses dropped due to rate limiting"},
174 [ + - + - ]: 17122 : {RPCResult::Type::ARR, "permissions", "Any special permissions that have been granted to this peer",
175 : : {
176 [ + - + - ]: 17122 : {RPCResult::Type::STR, "permission_type", Join(NET_PERMISSIONS_DOC, ",\n") + ".\n"},
177 : : }},
178 [ + - + - ]: 17122 : {RPCResult::Type::NUM, "minfeefilter", "The minimum fee rate for transactions this peer accepts"},
179 [ + - + - ]: 17122 : {RPCResult::Type::OBJ_DYN, "bytessent_per_msg", "",
180 : : {
181 [ + - + - ]: 17122 : {RPCResult::Type::NUM, "msg", "The total bytes sent aggregated by message type\n"
182 : : "When a message type is not listed in this json object, the bytes sent are 0.\n"
183 : : "Only known message types can appear as keys in the object."}
184 : : }},
185 [ + - + - ]: 17122 : {RPCResult::Type::OBJ_DYN, "bytesrecv_per_msg", "",
186 : : {
187 [ + - ]: 17122 : {RPCResult::Type::NUM, "msg", "The total bytes received aggregated by message type\n"
188 : : "When a message type is not listed in this json object, the bytes received are 0.\n"
189 : : "Only known message types can appear as keys in the object and all bytes received\n"
190 [ + - ]: 17122 : "of unknown message types are listed under '"+NET_MESSAGE_TYPE_OTHER+"'."}
191 : : }},
192 [ + - + - : 17122 : {RPCResult::Type::STR, "connection_type", "Type of connection: \n" + Join(CONNECTION_TYPE_DOC, ",\n") + ".\n"
+ - ]
193 : : "Please note this output is unlikely to be stable in upcoming releases as we iterate to\n"
194 : 8561 : "best capture connection behaviors."},
195 [ + - + - : 17122 : {RPCResult::Type::STR, "transport_protocol_type", "Type of transport protocol: \n" + Join(TRANSPORT_TYPE_DOC, ",\n") + ".\n"},
+ - ]
196 [ + - + - ]: 17122 : {RPCResult::Type::STR, "session_id", "The session ID for this connection, or \"\" if there is none (\"v2\" transport protocol only).\n"},
197 : : }},
198 : : }},
199 [ + - + - : 813295 : },
+ - + - +
- + - + -
+ - + + +
+ + + + +
+ + + + +
+ - - - -
- - - - -
- - - -
- ]
200 : 8561 : RPCExamples{
201 [ + - + - : 17122 : HelpExampleCli("getpeerinfo", "")
+ - ]
202 [ + - + - : 34244 : + HelpExampleRpc("getpeerinfo", "")
+ - + - ]
203 [ + - ]: 8561 : },
204 : 8561 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
205 : : {
206 : 6168 : NodeContext& node = EnsureAnyNodeContext(request.context);
207 : 6168 : const CConnman& connman = EnsureConnman(node);
208 : 6168 : const PeerManager& peerman = EnsurePeerman(node);
209 : :
210 : 6168 : std::vector<CNodeStats> vstats;
211 [ + - ]: 6168 : connman.GetNodeStats(vstats);
212 : :
213 : 6168 : UniValue ret(UniValue::VARR);
214 : :
215 [ + + ]: 19227 : for (const CNodeStats& stats : vstats) {
216 : 13059 : UniValue obj(UniValue::VOBJ);
217 [ + - ]: 13059 : CNodeStateStats statestats;
218 [ + - ]: 13059 : bool fStateStats = peerman.GetNodeStateStats(stats.nodeid, statestats);
219 : : // GetNodeStateStats() requires the existence of a CNodeState and a Peer object
220 : : // to succeed for this peer. These are created at connection initialisation and
221 : : // exist for the duration of the connection - except if there is a race where the
222 : : // peer got disconnected in between the GetNodeStats() and the GetNodeStateStats()
223 : : // calls. In this case, the peer doesn't need to be reported here.
224 [ + + ]: 13059 : if (!fStateStats) {
225 : 7 : continue;
226 : : }
227 [ + - + - : 26104 : obj.pushKV("id", stats.nodeid);
+ - ]
228 [ + - + - : 26104 : obj.pushKV("addr", stats.m_addr_name);
+ - ]
229 [ + - + + ]: 13052 : if (stats.addrBind.IsValid()) {
230 [ + - + - : 26096 : obj.pushKV("addrbind", stats.addrBind.ToStringAddrPort());
+ - + - ]
231 : : }
232 [ + + ]: 13052 : if (!(stats.addrLocal.empty())) {
233 [ + - + - : 9162 : obj.pushKV("addrlocal", stats.addrLocal);
+ - ]
234 : : }
235 [ + - + - : 26104 : obj.pushKV("network", GetNetworkName(stats.m_network));
+ - + - ]
236 [ - + ]: 13052 : if (stats.m_mapped_as != 0) {
237 [ # # # # : 0 : obj.pushKV("mapped_as", stats.m_mapped_as);
# # ]
238 : : }
239 : 13052 : ServiceFlags services{statestats.their_services};
240 [ + - + - : 26104 : obj.pushKV("services", strprintf("%016x", services));
+ - + - ]
241 [ + - + - : 26104 : obj.pushKV("servicesnames", GetServicesNames(services));
+ - ]
242 [ + - + - : 26104 : obj.pushKV("relaytxes", statestats.m_relay_txs);
+ - ]
243 [ + - + - : 26104 : obj.pushKV("last_inv_sequence", statestats.m_last_inv_seq);
+ - ]
244 [ + - + - : 26104 : obj.pushKV("inv_to_send", statestats.m_inv_to_send);
+ - ]
245 [ + - + - : 26104 : obj.pushKV("lastsend", count_seconds(stats.m_last_send));
+ - ]
246 [ + - + - : 26104 : obj.pushKV("lastrecv", count_seconds(stats.m_last_recv));
+ - ]
247 [ + - + - : 26104 : obj.pushKV("last_transaction", count_seconds(stats.m_last_tx_time));
+ - ]
248 [ + - + - : 26104 : obj.pushKV("last_block", count_seconds(stats.m_last_block_time));
+ - ]
249 [ + - + - : 26104 : obj.pushKV("bytessent", stats.nSendBytes);
+ - ]
250 [ + - + - : 26104 : obj.pushKV("bytesrecv", stats.nRecvBytes);
+ - ]
251 [ + - + - : 26104 : obj.pushKV("conntime", count_seconds(stats.m_connected));
+ - ]
252 [ + - + - : 26104 : obj.pushKV("timeoffset", Ticks<std::chrono::seconds>(statestats.time_offset));
+ - ]
253 [ + + ]: 13052 : if (stats.m_last_ping_time > 0us) {
254 [ + - + - : 18420 : obj.pushKV("pingtime", Ticks<SecondsDouble>(stats.m_last_ping_time));
+ - ]
255 : : }
256 [ + + ]: 13052 : if (stats.m_min_ping_time < std::chrono::microseconds::max()) {
257 [ + - + - : 24456 : obj.pushKV("minping", Ticks<SecondsDouble>(stats.m_min_ping_time));
+ - ]
258 : : }
259 [ + + ]: 13052 : if (statestats.m_ping_wait > 0s) {
260 [ + - + - : 124 : obj.pushKV("pingwait", Ticks<SecondsDouble>(statestats.m_ping_wait));
+ - ]
261 : : }
262 [ + - + - : 26104 : obj.pushKV("version", stats.nVersion);
+ - ]
263 : : // Use the sanitized form of subver here, to avoid tricksy remote peers from
264 : : // corrupting or modifying the JSON output by putting special characters in
265 : : // their ver message.
266 [ + - + - : 26104 : obj.pushKV("subver", stats.cleanSubVer);
+ - ]
267 [ + - + - : 26104 : obj.pushKV("inbound", stats.fInbound);
+ - ]
268 [ + - + - : 26104 : obj.pushKV("bip152_hb_to", stats.m_bip152_highbandwidth_to);
+ - ]
269 [ + - + - : 26104 : obj.pushKV("bip152_hb_from", stats.m_bip152_highbandwidth_from);
+ - ]
270 [ + - + - : 26104 : obj.pushKV("presynced_headers", statestats.presync_height);
+ - ]
271 [ + - + - : 26104 : obj.pushKV("synced_headers", statestats.nSyncHeight);
+ - ]
272 [ + - + - : 26104 : obj.pushKV("synced_blocks", statestats.nCommonHeight);
+ - ]
273 : 13052 : UniValue heights(UniValue::VARR);
274 [ + + ]: 17713 : for (const int height : statestats.vHeightInFlight) {
275 [ + - + - ]: 4661 : heights.push_back(height);
276 : : }
277 [ + - + - ]: 26104 : obj.pushKV("inflight", std::move(heights));
278 [ + - + - : 26104 : obj.pushKV("addr_relay_enabled", statestats.m_addr_relay_enabled);
+ - ]
279 [ + - + - : 26104 : obj.pushKV("addr_processed", statestats.m_addr_processed);
+ - ]
280 [ + - + - : 26104 : obj.pushKV("addr_rate_limited", statestats.m_addr_rate_limited);
+ - ]
281 : 13052 : UniValue permissions(UniValue::VARR);
282 [ + - + + ]: 17795 : for (const auto& permission : NetPermissions::ToStrings(stats.m_permission_flags)) {
283 [ + - + - ]: 4743 : permissions.push_back(permission);
284 : 13052 : }
285 [ + - + - ]: 26104 : obj.pushKV("permissions", std::move(permissions));
286 [ + - + - : 26104 : obj.pushKV("minfeefilter", ValueFromAmount(statestats.m_fee_filter_received));
+ - ]
287 : :
288 : 13052 : UniValue sendPerMsgType(UniValue::VOBJ);
289 [ + + ]: 154574 : for (const auto& i : stats.mapSendBytesPerMsgType) {
290 [ + - ]: 141522 : if (i.second > 0)
291 [ + - - + : 424566 : sendPerMsgType.pushKV(i.first, i.second);
+ - ]
292 : : }
293 [ + - + - ]: 26104 : obj.pushKV("bytessent_per_msg", std::move(sendPerMsgType));
294 : :
295 : 13052 : UniValue recvPerMsgType(UniValue::VOBJ);
296 [ + + ]: 482924 : for (const auto& i : stats.mapRecvBytesPerMsgType) {
297 [ + + ]: 469872 : if (i.second > 0)
298 [ + - - + : 373917 : recvPerMsgType.pushKV(i.first, i.second);
+ - ]
299 : : }
300 [ + - + - ]: 26104 : obj.pushKV("bytesrecv_per_msg", std::move(recvPerMsgType));
301 [ + - + - : 26104 : obj.pushKV("connection_type", ConnectionTypeAsString(stats.m_conn_type));
+ - + - ]
302 [ + - + - : 26104 : obj.pushKV("transport_protocol_type", TransportTypeAsString(stats.m_transport_type));
+ - + - ]
303 [ + - + - : 26104 : obj.pushKV("session_id", stats.m_session_id);
+ - ]
304 : :
305 [ + - ]: 13052 : ret.push_back(std::move(obj));
306 : 13059 : }
307 : :
308 : 6168 : return ret;
309 : 6168 : },
310 [ + - + - ]: 34244 : };
311 [ + - + - : 402367 : }
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
- - ]
312 : :
313 : 2860 : static RPCHelpMan addnode()
314 : : {
315 : 2860 : return RPCHelpMan{
316 : 2860 : "addnode",
317 : : "Attempts to add or remove a node from the addnode list.\n"
318 : : "Or try a connection to a node once.\n"
319 : : "Nodes added using addnode (or -connect) are protected from DoS disconnection and are not required to be\n"
320 : 2860 : "full nodes/support SegWit as other outbound peers are (though such peers will not be synced from).\n" +
321 [ + - + - ]: 8580 : strprintf("Addnode connections are limited to %u at a time", MAX_ADDNODE_CONNECTIONS) +
322 : 2860 : " and are counted separately from the -maxconnections limit.\n",
323 : : {
324 [ + - + - ]: 5720 : {"node", RPCArg::Type::STR, RPCArg::Optional::NO, "The IP address/hostname optionally followed by :port of the peer to connect to"},
325 [ + - + - ]: 5720 : {"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"},
326 [ + - + - : 8580 : {"v2transport", RPCArg::Type::BOOL, RPCArg::DefaultHint{"set by -v2transport"}, "Attempt to connect using BIP324 v2 transport protocol (ignored for 'remove' command)"},
+ - ]
327 : : },
328 [ + - + - : 5720 : RPCResult{RPCResult::Type::NONE, "", ""},
+ - + - ]
329 : 2860 : RPCExamples{
330 [ + - + - : 5720 : HelpExampleCli("addnode", "\"192.168.0.6:8333\" \"onetry\" true")
+ - ]
331 [ + - + - : 11440 : + HelpExampleRpc("addnode", "\"192.168.0.6:8333\", \"onetry\" true")
+ - + - ]
332 [ + - ]: 2860 : },
333 : 2860 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
334 : : {
335 : 469 : const auto command{self.Arg<std::string_view>("command")};
336 [ + + + + : 469 : if (command != "onetry" && command != "add" && command != "remove") {
+ + ]
337 : 2 : throw std::runtime_error(
338 [ + - + - ]: 4 : self.ToString());
339 : : }
340 : :
341 : 467 : NodeContext& node = EnsureAnyNodeContext(request.context);
342 : 467 : CConnman& connman = EnsureConnman(node);
343 : :
344 : 467 : const auto node_arg{self.Arg<std::string_view>("node")};
345 : 467 : bool node_v2transport = connman.GetLocalServices() & NODE_P2P_V2;
346 [ + + ]: 467 : bool use_v2transport = self.MaybeArg<bool>("v2transport").value_or(node_v2transport);
347 : :
348 [ + + + + ]: 467 : if (use_v2transport && !node_v2transport) {
349 [ + - + - ]: 2 : throw JSONRPCError(RPC_INVALID_PARAMETER, "Error: v2transport requested but not enabled (see -v2transport)");
350 : : }
351 : :
352 [ + + ]: 466 : if (command == "onetry")
353 : : {
354 : 454 : CAddress addr;
355 [ + - + - : 908 : connman.OpenNetworkConnection(addr, /*fCountFailure=*/false, /*grant_outbound=*/{}, std::string{node_arg}.c_str(), ConnectionType::MANUAL, use_v2transport);
- + ]
356 : 454 : return UniValue::VNULL;
357 : 454 : }
358 : :
359 [ + + ]: 12 : if (command == "add")
360 : : {
361 [ + + ]: 8 : if (!connman.AddNode({std::string{node_arg}, use_v2transport})) {
362 [ + - + - ]: 8 : throw JSONRPCError(RPC_CLIENT_NODE_ALREADY_ADDED, "Error: Node already added");
363 : : }
364 : : }
365 [ + - ]: 4 : else if (command == "remove")
366 : : {
367 [ + + ]: 4 : if (!connman.RemoveAddedNode(node_arg)) {
368 [ + - + - ]: 4 : throw JSONRPCError(RPC_CLIENT_NODE_NOT_ADDED, "Error: Node could not be removed. It has not been added previously.");
369 : : }
370 : : }
371 : :
372 : 6 : return UniValue::VNULL;
373 [ + - ]: 8 : },
374 [ + - + - : 20020 : };
+ + - - ]
375 [ + - + - : 17160 : }
+ - - - ]
376 : :
377 : 2532 : static RPCHelpMan addconnection()
378 : : {
379 : 2532 : return RPCHelpMan{
380 : 2532 : "addconnection",
381 [ + - ]: 5064 : "Open an outbound connection to a specified node. This RPC is for testing only.\n",
382 : : {
383 [ + - + - ]: 5064 : {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The IP address and port to attempt connecting to."},
384 [ + - + - ]: 5064 : {"connection_type", RPCArg::Type::STR, RPCArg::Optional::NO, "Type of connection to open (\"outbound-full-relay\", \"block-relay-only\", \"addr-fetch\" or \"feeler\")."},
385 [ + - + - ]: 5064 : {"v2transport", RPCArg::Type::BOOL, RPCArg::Optional::NO, "Attempt to connect using BIP324 v2 transport protocol"},
386 : : },
387 [ + - ]: 5064 : RPCResult{
388 [ + - + - ]: 5064 : RPCResult::Type::OBJ, "", "",
389 : : {
390 [ + - + - ]: 5064 : { RPCResult::Type::STR, "address", "Address of newly added connection." },
391 [ + - + - ]: 5064 : { RPCResult::Type::STR, "connection_type", "Type of connection opened." },
392 [ + - + - : 12660 : }},
+ + - - ]
393 : 2532 : RPCExamples{
394 [ + - + - : 5064 : HelpExampleCli("addconnection", "\"192.168.0.6:8333\" \"outbound-full-relay\" true")
+ - ]
395 [ + - + - : 10128 : + HelpExampleRpc("addconnection", "\"192.168.0.6:8333\" \"outbound-full-relay\" true")
+ - + - ]
396 [ + - ]: 2532 : },
397 : 2532 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
398 : : {
399 [ - + ]: 150 : if (Params().GetChainType() != ChainType::REGTEST) {
400 [ # # ]: 0 : throw std::runtime_error("addconnection is for regression testing (-regtest mode) only.");
401 : : }
402 : :
403 [ - + ]: 150 : const std::string address = request.params[0].get_str();
404 [ + - + - ]: 150 : auto conn_type_in{util::TrimStringView(self.Arg<std::string_view>("connection_type"))};
405 : 150 : ConnectionType conn_type{};
406 [ + + ]: 150 : if (conn_type_in == "outbound-full-relay") {
407 : : conn_type = ConnectionType::OUTBOUND_FULL_RELAY;
408 [ + + ]: 54 : } else if (conn_type_in == "block-relay-only") {
409 : : conn_type = ConnectionType::BLOCK_RELAY;
410 [ + + ]: 19 : } else if (conn_type_in == "addr-fetch") {
411 : : conn_type = ConnectionType::ADDR_FETCH;
412 [ - + ]: 4 : } else if (conn_type_in == "feeler") {
413 : : conn_type = ConnectionType::FEELER;
414 : : } else {
415 [ # # # # ]: 0 : throw JSONRPCError(RPC_INVALID_PARAMETER, self.ToString());
416 : : }
417 [ + - ]: 150 : bool use_v2transport{self.Arg<bool>("v2transport")};
418 : :
419 [ + - ]: 150 : NodeContext& node = EnsureAnyNodeContext(request.context);
420 [ + - ]: 150 : CConnman& connman = EnsureConnman(node);
421 : :
422 [ + + + - : 150 : if (use_v2transport && !(connman.GetLocalServices() & NODE_P2P_V2)) {
- + ]
423 [ # # # # ]: 0 : throw JSONRPCError(RPC_INVALID_PARAMETER, "Error: Adding v2transport connections requires -v2transport init flag to be set.");
424 : : }
425 : :
426 [ + - ]: 150 : const bool success = connman.AddConnection(address, conn_type, use_v2transport);
427 [ - + ]: 150 : if (!success) {
428 [ # # # # ]: 0 : throw JSONRPCError(RPC_CLIENT_NODE_CAPACITY_REACHED, "Error: Already at capacity for specified connection type.");
429 : : }
430 : :
431 : 150 : UniValue info(UniValue::VOBJ);
432 [ + - + - : 300 : info.pushKV("address", address);
+ - ]
433 [ + - + - : 300 : info.pushKV("connection_type", conn_type_in);
+ - ]
434 : :
435 : 150 : return info;
436 : 150 : },
437 [ + - + - : 17724 : };
+ + - - ]
438 [ + - + - : 20256 : }
+ - + - +
- - - -
- ]
439 : :
440 : 2519 : static RPCHelpMan disconnectnode()
441 : : {
442 : 2519 : return RPCHelpMan{
443 : 2519 : "disconnectnode",
444 [ + - ]: 5038 : "Immediately disconnects from the specified peer node.\n"
445 : : "\nStrictly one out of 'address' and 'nodeid' can be provided to identify the node.\n"
446 : : "\nTo disconnect by nodeid, either set 'address' to the empty string, or call using the named 'nodeid' argument only.\n",
447 : : {
448 [ + - + - : 7557 : {"address", RPCArg::Type::STR, RPCArg::DefaultHint{"fallback to nodeid"}, "The IP address/port of the node"},
+ - ]
449 [ + - + - : 7557 : {"nodeid", RPCArg::Type::NUM, RPCArg::DefaultHint{"fallback to address"}, "The node ID (see getpeerinfo for node IDs)"},
+ - ]
450 : : },
451 [ + - + - : 5038 : RPCResult{RPCResult::Type::NONE, "", ""},
+ - + - ]
452 : 2519 : RPCExamples{
453 [ + - + - : 5038 : HelpExampleCli("disconnectnode", "\"192.168.0.6:8333\"")
+ - ]
454 [ + - + - : 10076 : + HelpExampleCli("disconnectnode", "\"\" 1")
+ - + - ]
455 [ + - + - : 10076 : + HelpExampleRpc("disconnectnode", "\"192.168.0.6:8333\"")
+ - + - ]
456 [ + - + - : 10076 : + HelpExampleRpc("disconnectnode", "\"\", 1")
+ - + - ]
457 [ + - ]: 2519 : },
458 : 2519 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
459 : : {
460 : 128 : NodeContext& node = EnsureAnyNodeContext(request.context);
461 : 128 : CConnman& connman = EnsureConnman(node);
462 : :
463 : 128 : bool success;
464 : 128 : auto address{self.MaybeArg<std::string_view>("address")};
465 : 128 : auto node_id{self.MaybeArg<int64_t>("nodeid")};
466 : :
467 [ + + + + ]: 128 : if (address && !node_id) {
468 : : /* handle disconnect-by-address */
469 : 4 : success = connman.DisconnectNode(*address);
470 [ + - + + : 124 : } else if (node_id && (!address || address->empty())) {
- + ]
471 : : /* handle disconnect-by-id */
472 : 122 : success = connman.DisconnectNode(*node_id);
473 : : } else {
474 [ + - + - ]: 4 : throw JSONRPCError(RPC_INVALID_PARAMS, "Only one of address and nodeid should be provided.");
475 : : }
476 : :
477 [ + + ]: 126 : if (!success) {
478 [ + - + - ]: 4 : throw JSONRPCError(RPC_CLIENT_NODE_NOT_CONNECTED, "Node not found in connected nodes");
479 : : }
480 : :
481 : 124 : return UniValue::VNULL;
482 : : },
483 [ + - + - : 15114 : };
+ + - - ]
484 [ + - + - : 10076 : }
- - ]
485 : :
486 : 2403 : static RPCHelpMan getaddednodeinfo()
487 : : {
488 : 2403 : return RPCHelpMan{
489 : 2403 : "getaddednodeinfo",
490 [ + - ]: 4806 : "Returns information about the given added node, or all added nodes\n"
491 : : "(note that onetry addnodes are not listed here)\n",
492 : : {
493 [ + - + - : 7209 : {"node", RPCArg::Type::STR, RPCArg::DefaultHint{"all nodes"}, "If provided, return information about this specific node, otherwise all nodes are returned."},
+ - ]
494 : : },
495 [ + - ]: 4806 : RPCResult{
496 [ + - + - ]: 4806 : RPCResult::Type::ARR, "", "",
497 : : {
498 [ + - + - ]: 4806 : {RPCResult::Type::OBJ, "", "",
499 : : {
500 [ + - + - ]: 4806 : {RPCResult::Type::STR, "addednode", "The node IP address or name (as provided to addnode)"},
501 [ + - + - ]: 4806 : {RPCResult::Type::BOOL, "connected", "If connected"},
502 [ + - + - ]: 4806 : {RPCResult::Type::ARR, "addresses", "Only when connected = true",
503 : : {
504 [ + - + - ]: 4806 : {RPCResult::Type::OBJ, "", "",
505 : : {
506 [ + - + - ]: 4806 : {RPCResult::Type::STR, "address", "The bitcoin server IP and port we're connected to"},
507 [ + - + - ]: 4806 : {RPCResult::Type::STR, "connected", "connection, inbound or outbound"},
508 : : }},
509 : : }},
510 : : }},
511 : : }
512 [ + - + - : 36045 : },
+ - + - +
- + + + +
+ + + + -
- - - - -
- - ]
513 : 2403 : RPCExamples{
514 [ + - + - : 4806 : HelpExampleCli("getaddednodeinfo", "\"192.168.0.201\"")
+ - ]
515 [ + - + - : 9612 : + HelpExampleRpc("getaddednodeinfo", "\"192.168.0.201\"")
+ - + - ]
516 [ + - ]: 2403 : },
517 : 2403 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
518 : : {
519 : 12 : NodeContext& node = EnsureAnyNodeContext(request.context);
520 : 12 : const CConnman& connman = EnsureConnman(node);
521 : :
522 : 12 : std::vector<AddedNodeInfo> vInfo = connman.GetAddedNodeInfo(/*include_connected=*/true);
523 : :
524 [ + - + + ]: 12 : if (auto node{self.MaybeArg<std::string_view>("node")}) {
525 : 4 : bool found = false;
526 [ + + ]: 6 : for (const AddedNodeInfo& info : vInfo) {
527 [ - + + + ]: 4 : if (info.m_params.m_added_node == *node) {
528 [ + - ]: 2 : vInfo.assign(1, info);
529 : : found = true;
530 : : break;
531 : : }
532 : : }
533 : 2 : if (!found) {
534 [ + - + - ]: 4 : throw JSONRPCError(RPC_CLIENT_NODE_NOT_ADDED, "Error: Node has not been added.");
535 : : }
536 : : }
537 : :
538 : 10 : UniValue ret(UniValue::VARR);
539 : :
540 [ + + ]: 20 : for (const AddedNodeInfo& info : vInfo) {
541 : 10 : UniValue obj(UniValue::VOBJ);
542 [ + - + - : 20 : obj.pushKV("addednode", info.m_params.m_added_node);
+ - ]
543 [ + - + - : 20 : obj.pushKV("connected", info.fConnected);
+ - ]
544 : 10 : UniValue addresses(UniValue::VARR);
545 [ - + ]: 10 : if (info.fConnected) {
546 : 0 : UniValue address(UniValue::VOBJ);
547 [ # # # # : 0 : address.pushKV("address", info.resolvedAddress.ToStringAddrPort());
# # # # ]
548 [ # # # # : 0 : address.pushKV("connected", info.fInbound ? "inbound" : "outbound");
# # # # ]
549 [ # # ]: 0 : addresses.push_back(std::move(address));
550 : 0 : }
551 [ + - + - ]: 20 : obj.pushKV("addresses", std::move(addresses));
552 [ + - ]: 10 : ret.push_back(std::move(obj));
553 : 10 : }
554 : :
555 : 10 : return ret;
556 : 12 : },
557 [ + - + - : 12015 : };
+ + - - ]
558 [ + - + - : 21627 : }
+ - + - +
- + - + -
+ - - - -
- ]
559 : :
560 : 2408 : static RPCHelpMan getnettotals()
561 : : {
562 : 2408 : return RPCHelpMan{"getnettotals",
563 [ + - ]: 4816 : "Returns information about network traffic, including bytes in, bytes out,\n"
564 : : "and current system time.",
565 : : {},
566 [ + - ]: 4816 : RPCResult{
567 [ + - ]: 4816 : RPCResult::Type::OBJ, "", "",
568 : : {
569 [ + - + - ]: 4816 : {RPCResult::Type::NUM, "totalbytesrecv", "Total bytes received"},
570 [ + - + - ]: 4816 : {RPCResult::Type::NUM, "totalbytessent", "Total bytes sent"},
571 [ + - + - ]: 4816 : {RPCResult::Type::NUM_TIME, "timemillis", "Current system " + UNIX_EPOCH_TIME + " in milliseconds"},
572 [ + - + - ]: 4816 : {RPCResult::Type::OBJ, "uploadtarget", "",
573 : : {
574 [ + - + - ]: 4816 : {RPCResult::Type::NUM, "timeframe", "Length of the measuring timeframe in seconds"},
575 [ + - + - ]: 4816 : {RPCResult::Type::NUM, "target", "Target in bytes"},
576 [ + - + - ]: 4816 : {RPCResult::Type::BOOL, "target_reached", "True if target is reached"},
577 [ + - + - ]: 4816 : {RPCResult::Type::BOOL, "serve_historical_blocks", "True if serving historical blocks"},
578 [ + - + - ]: 4816 : {RPCResult::Type::NUM, "bytes_left_in_cycle", "Bytes left in current time cycle"},
579 [ + - + - ]: 4816 : {RPCResult::Type::NUM, "time_left_in_cycle", "Seconds left in current time cycle"},
580 : : }},
581 : : }
582 [ + - + - : 50568 : },
+ - + + +
+ - - -
- ]
583 : 2408 : RPCExamples{
584 [ + - + - : 4816 : HelpExampleCli("getnettotals", "")
+ - ]
585 [ + - + - : 9632 : + HelpExampleRpc("getnettotals", "")
+ - + - ]
586 [ + - ]: 2408 : },
587 : 2408 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
588 : : {
589 : 17 : NodeContext& node = EnsureAnyNodeContext(request.context);
590 : 17 : const CConnman& connman = EnsureConnman(node);
591 : :
592 : 17 : UniValue obj(UniValue::VOBJ);
593 [ + - + - : 34 : obj.pushKV("totalbytesrecv", connman.GetTotalBytesRecv());
+ - + - ]
594 [ + - + - : 34 : obj.pushKV("totalbytessent", connman.GetTotalBytesSent());
+ - + - ]
595 [ + - + - : 34 : obj.pushKV("timemillis", TicksSinceEpoch<std::chrono::milliseconds>(SystemClock::now()));
+ - ]
596 : :
597 : 17 : UniValue outboundLimit(UniValue::VOBJ);
598 [ + - + - : 34 : outboundLimit.pushKV("timeframe", count_seconds(connman.GetMaxOutboundTimeframe()));
+ - + - ]
599 [ + - + - : 34 : outboundLimit.pushKV("target", connman.GetMaxOutboundTarget());
+ - + - ]
600 [ + - + - : 34 : outboundLimit.pushKV("target_reached", connman.OutboundTargetReached(false));
+ - + - ]
601 [ + - + - : 34 : outboundLimit.pushKV("serve_historical_blocks", !connman.OutboundTargetReached(true));
+ - + - ]
602 [ + - + - : 34 : outboundLimit.pushKV("bytes_left_in_cycle", connman.GetOutboundTargetBytesLeft());
+ - + - ]
603 [ + - + - : 34 : outboundLimit.pushKV("time_left_in_cycle", count_seconds(connman.GetMaxOutboundTimeLeftInCycle()));
+ - + - ]
604 [ + - + - ]: 34 : obj.pushKV("uploadtarget", std::move(outboundLimit));
605 : 17 : return obj;
606 : 17 : },
607 [ + - + - ]: 9632 : };
608 [ + - + - : 24080 : }
+ - + - +
- + - + -
+ - + - +
- - - -
- ]
609 : :
610 : 989 : static UniValue GetNetworksInfo()
611 : : {
612 : 989 : UniValue networks(UniValue::VARR);
613 [ + + ]: 7912 : for (int n = 0; n < NET_MAX; ++n) {
614 : 6923 : enum Network network = static_cast<enum Network>(n);
615 [ + + ]: 6923 : if (network == NET_UNROUTABLE || network == NET_INTERNAL) continue;
616 [ + - ]: 4945 : Proxy proxy;
617 : 4945 : UniValue obj(UniValue::VOBJ);
618 [ + - ]: 4945 : GetProxy(network, proxy);
619 [ + - + - : 9890 : obj.pushKV("name", GetNetworkName(network));
+ - + - ]
620 [ + - + - : 9890 : obj.pushKV("limited", !g_reachable_nets.Contains(network));
+ - + - ]
621 [ + - + - : 9890 : obj.pushKV("reachable", g_reachable_nets.Contains(network));
+ - + - ]
622 [ + - + + : 9890 : obj.pushKV("proxy", proxy.IsValid() ? proxy.ToString() : std::string());
+ - + - +
- + - ]
623 [ + - + - : 9890 : obj.pushKV("proxy_randomize_credentials", proxy.m_tor_stream_isolation);
+ - ]
624 [ + - ]: 4945 : networks.push_back(std::move(obj));
625 : 9890 : }
626 : 989 : return networks;
627 : 0 : }
628 : :
629 : 3382 : static RPCHelpMan getnetworkinfo()
630 : : {
631 : 3382 : return RPCHelpMan{"getnetworkinfo",
632 [ + - ]: 6764 : "Returns an object containing various state info regarding P2P networking.\n",
633 : : {},
634 [ + - ]: 6764 : RPCResult{
635 [ + - ]: 6764 : RPCResult::Type::OBJ, "", "",
636 : : {
637 [ + - + - ]: 6764 : {RPCResult::Type::NUM, "version", "the server version"},
638 [ + - + - ]: 6764 : {RPCResult::Type::STR, "subversion", "the server subversion string"},
639 [ + - + - ]: 6764 : {RPCResult::Type::NUM, "protocolversion", "the protocol version"},
640 [ + - + - ]: 6764 : {RPCResult::Type::STR_HEX, "localservices", "the services we offer to the network"},
641 [ + - + - ]: 6764 : {RPCResult::Type::ARR, "localservicesnames", "the services we offer to the network, in human-readable form",
642 : : {
643 [ + - + - ]: 6764 : {RPCResult::Type::STR, "SERVICE_NAME", "the service name"},
644 : : }},
645 [ + - + - ]: 6764 : {RPCResult::Type::BOOL, "localrelay", "true if transaction relay is requested from peers"},
646 [ + - + - ]: 6764 : {RPCResult::Type::NUM, "timeoffset", "the time offset"},
647 [ + - + - ]: 6764 : {RPCResult::Type::NUM, "connections", "the total number of connections"},
648 [ + - + - ]: 6764 : {RPCResult::Type::NUM, "connections_in", "the number of inbound connections"},
649 [ + - + - ]: 6764 : {RPCResult::Type::NUM, "connections_out", "the number of outbound connections"},
650 [ + - + - ]: 6764 : {RPCResult::Type::BOOL, "networkactive", "whether p2p networking is enabled"},
651 [ + - + - ]: 6764 : {RPCResult::Type::ARR, "networks", "information per network",
652 : : {
653 [ + - + - ]: 6764 : {RPCResult::Type::OBJ, "", "",
654 : : {
655 [ + - + - : 6764 : {RPCResult::Type::STR, "name", "network (" + Join(GetNetworkNames(), ", ") + ")"},
+ - + - ]
656 [ + - + - ]: 6764 : {RPCResult::Type::BOOL, "limited", "is the network limited using -onlynet?"},
657 [ + - + - ]: 6764 : {RPCResult::Type::BOOL, "reachable", "is the network reachable?"},
658 [ + - + - ]: 6764 : {RPCResult::Type::STR, "proxy", "(\"host:port\") the proxy that is used for this network, or empty if none"},
659 [ + - + - ]: 6764 : {RPCResult::Type::BOOL, "proxy_randomize_credentials", "Whether randomized credentials are used"},
660 : : }},
661 : : }},
662 [ + - + - ]: 6764 : {RPCResult::Type::NUM, "relayfee", "minimum relay fee rate for transactions in " + CURRENCY_UNIT + "/kvB"},
663 [ + - + - ]: 6764 : {RPCResult::Type::NUM, "incrementalfee", "minimum fee rate increment for mempool limiting or replacement in " + CURRENCY_UNIT + "/kvB"},
664 [ + - + - ]: 6764 : {RPCResult::Type::ARR, "localaddresses", "list of local addresses",
665 : : {
666 [ + - + - ]: 6764 : {RPCResult::Type::OBJ, "", "",
667 : : {
668 [ + - + - ]: 6764 : {RPCResult::Type::STR, "address", "network address"},
669 [ + - + - ]: 6764 : {RPCResult::Type::NUM, "port", "network port"},
670 [ + - + - ]: 6764 : {RPCResult::Type::NUM, "score", "relative score"},
671 : : }},
672 : : }},
673 [ + - + - : 3382 : (IsDeprecatedRPCEnabled("warnings") ?
- + ]
674 [ - - - - : 3382 : RPCResult{RPCResult::Type::STR, "warnings", "any network and blockchain warnings (DEPRECATED)"} :
- + - + -
+ - - - -
- - ]
675 [ + - + - : 13528 : RPCResult{RPCResult::Type::ARR, "warnings", "any network and blockchain warnings (run with `-deprecatedrpc=warnings` to return the latest warning as a single string)",
+ - + - -
- - - ]
676 : : {
677 [ + - + - : 13528 : {RPCResult::Type::STR, "", "warning"},
+ - + - -
- - - ]
678 : : }
679 [ + - + - : 13528 : }
+ - + + +
- - - - -
- - - - ]
680 : : ),
681 : : }
682 [ + - + - : 186010 : },
+ - + - +
- + - + -
+ + + + +
+ + + + +
+ + - - -
- - - - -
- - - - ]
683 : 3382 : RPCExamples{
684 [ + - + - : 6764 : HelpExampleCli("getnetworkinfo", "")
+ - ]
685 [ + - + - : 13528 : + HelpExampleRpc("getnetworkinfo", "")
+ - + - ]
686 [ + - ]: 3382 : },
687 : 3382 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
688 : : {
689 : 989 : LOCK(cs_main);
690 : 989 : UniValue obj(UniValue::VOBJ);
691 [ + - + - : 1978 : obj.pushKV("version", CLIENT_VERSION);
+ - ]
692 [ + - + - : 1978 : obj.pushKV("subversion", strSubVersion);
+ - ]
693 [ + - + - : 1978 : obj.pushKV("protocolversion",PROTOCOL_VERSION);
+ - ]
694 [ + - ]: 989 : NodeContext& node = EnsureAnyNodeContext(request.context);
695 [ + - ]: 989 : if (node.connman) {
696 [ + - ]: 989 : ServiceFlags services = node.connman->GetLocalServices();
697 [ + - + - : 1978 : obj.pushKV("localservices", strprintf("%016x", services));
+ - + - ]
698 [ + - + - : 1978 : obj.pushKV("localservicesnames", GetServicesNames(services));
+ - ]
699 : : }
700 [ + - ]: 989 : if (node.peerman) {
701 [ + - ]: 989 : auto peerman_info{node.peerman->GetInfo()};
702 [ + - + - : 1978 : obj.pushKV("localrelay", !peerman_info.ignores_incoming_txs);
+ - ]
703 [ + - + - : 1978 : obj.pushKV("timeoffset", Ticks<std::chrono::seconds>(peerman_info.median_outbound_time_offset));
+ - ]
704 : : }
705 [ + - ]: 989 : if (node.connman) {
706 [ + - + - : 1978 : obj.pushKV("networkactive", node.connman->GetNetworkActive());
+ - ]
707 [ + - + - : 1978 : obj.pushKV("connections", node.connman->GetNodeCount(ConnectionDirection::Both));
+ - + - ]
708 [ + - + - : 1978 : obj.pushKV("connections_in", node.connman->GetNodeCount(ConnectionDirection::In));
+ - + - ]
709 [ + - + - : 1978 : obj.pushKV("connections_out", node.connman->GetNodeCount(ConnectionDirection::Out));
+ - + - ]
710 : : }
711 [ + - + - : 1978 : obj.pushKV("networks", GetNetworksInfo());
+ - ]
712 [ + - ]: 989 : if (node.mempool) {
713 : : // Those fields can be deprecated, to be replaced by the getmempoolinfo fields
714 [ + - + - : 1978 : obj.pushKV("relayfee", ValueFromAmount(node.mempool->m_opts.min_relay_feerate.GetFeePerK()));
+ - ]
715 [ + - + - : 1978 : obj.pushKV("incrementalfee", ValueFromAmount(node.mempool->m_opts.incremental_relay_feerate.GetFeePerK()));
+ - ]
716 : : }
717 : 989 : UniValue localAddresses(UniValue::VARR);
718 : 989 : {
719 [ + - ]: 989 : LOCK(g_maplocalhost_mutex);
720 [ + + ]: 993 : for (const std::pair<const CNetAddr, LocalServiceInfo> &item : mapLocalHost)
721 : : {
722 : 4 : UniValue rec(UniValue::VOBJ);
723 [ + - + - : 8 : rec.pushKV("address", item.first.ToStringAddr());
+ - + - ]
724 [ + - + - : 8 : rec.pushKV("port", item.second.nPort);
+ - ]
725 [ + - + - : 8 : rec.pushKV("score", item.second.nScore);
+ - ]
726 [ + - ]: 4 : localAddresses.push_back(std::move(rec));
727 : 4 : }
728 : 0 : }
729 [ + - + - ]: 1978 : obj.pushKV("localaddresses", std::move(localAddresses));
730 [ + - + - : 1978 : obj.pushKV("warnings", node::GetWarningsForRpc(*CHECK_NONFATAL(node.warnings), IsDeprecatedRPCEnabled("warnings")));
+ - + - +
- + - ]
731 : 1978 : return obj;
732 [ + - ]: 1978 : },
733 [ + - + - ]: 13528 : };
734 [ + - + - : 94696 : }
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - - -
+ - + - -
- - - -
- ]
735 : :
736 : 2440 : static RPCHelpMan setban()
737 : : {
738 : 2440 : return RPCHelpMan{
739 : 2440 : "setban",
740 [ + - ]: 4880 : "Attempts to add or remove an IP/Subnet from the banned list.\n",
741 : : {
742 [ + - + - ]: 4880 : {"subnet", RPCArg::Type::STR, RPCArg::Optional::NO, "The IP/Subnet (see getpeerinfo for nodes IP) with an optional netmask (default is /32 = single IP)"},
743 [ + - + - ]: 4880 : {"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"},
744 [ + - + - : 7320 : {"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)"},
+ - ]
745 [ + - + - : 7320 : {"absolute", RPCArg::Type::BOOL, RPCArg::Default{false}, "If set, the bantime must be an absolute timestamp expressed in " + UNIX_EPOCH_TIME},
+ - ]
746 : : },
747 [ + - + - : 4880 : RPCResult{RPCResult::Type::NONE, "", ""},
+ - + - ]
748 : 2440 : RPCExamples{
749 [ + - + - : 4880 : HelpExampleCli("setban", "\"192.168.0.6\" \"add\" 86400")
+ - ]
750 [ + - + - : 9760 : + HelpExampleCli("setban", "\"192.168.0.0/24\" \"add\"")
+ - + - ]
751 [ + - + - : 9760 : + HelpExampleRpc("setban", "\"192.168.0.6\", \"add\", 86400")
+ - + - ]
752 [ + - ]: 2440 : },
753 : 2440 : [&](const RPCHelpMan& help, const JSONRPCRequest& request) -> UniValue
754 : : {
755 : 48 : auto command{help.Arg<std::string_view>("command")};
756 [ + + - + ]: 48 : if (command != "add" && command != "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 : std::string subnet_arg{help.Arg<std::string_view>("subnet")};
765 : 48 : const bool isSubnet{subnet_arg.find('/') != subnet_arg.npos};
766 : :
767 [ + + ]: 48 : if (!isSubnet) {
768 [ + - + - ]: 30 : const std::optional<CNetAddr> addr{LookupHost(subnet_arg, false)};
769 [ + + ]: 30 : if (addr.has_value()) {
770 [ + - + - ]: 29 : netAddr = static_cast<CNetAddr>(MaybeFlipIPv6toCJDNS(CService{addr.value(), /*port=*/0}));
771 : : }
772 : 30 : } else {
773 [ + - ]: 18 : subNet = LookupSubNet(subnet_arg);
774 : : }
775 : :
776 [ + + + - : 48 : if (! (isSubnet ? subNet.IsValid() : netAddr.IsValid()) ) {
+ - + + ]
777 [ + - + - ]: 6 : throw JSONRPCError(RPC_CLIENT_INVALID_IP_OR_SUBNET, "Error: Invalid IP/Subnet");
778 : : }
779 : :
780 [ + + ]: 45 : if (command == "add") {
781 [ + + + - : 35 : if (isSubnet ? banman.IsBanned(subNet) : banman.IsBanned(netAddr)) {
+ - + + ]
782 [ + - + - ]: 8 : throw JSONRPCError(RPC_CLIENT_NODE_ALREADY_ADDED, "Error: IP/Subnet already banned");
783 : : }
784 : :
785 : 31 : int64_t banTime = 0; //use standard bantime if not specified
786 [ + - + + ]: 31 : if (!request.params[2].isNull())
787 [ + - + - ]: 10 : banTime = request.params[2].getInt<int64_t>();
788 : :
789 [ + - + + : 31 : const bool absolute{request.params[3].isNull() ? false : request.params[3].get_bool()};
+ - + - ]
790 : :
791 [ + - + - : 5 : if (absolute && banTime < GetTime()) {
+ + ]
792 [ + - + - ]: 4 : throw JSONRPCError(RPC_INVALID_PARAMETER, "Error: Absolute timestamp is in the past");
793 : : }
794 : :
795 [ + + ]: 29 : if (isSubnet) {
796 [ + - ]: 13 : banman.Ban(subNet, banTime, absolute);
797 [ + - ]: 13 : if (node.connman) {
798 [ + - ]: 13 : node.connman->DisconnectNode(subNet);
799 : : }
800 : : } else {
801 [ + - ]: 16 : banman.Ban(netAddr, banTime, absolute);
802 [ + - ]: 16 : if (node.connman) {
803 [ + - ]: 16 : node.connman->DisconnectNode(netAddr);
804 : : }
805 : : }
806 [ + - ]: 10 : } else if(command == "remove") {
807 [ + + + - : 10 : if (!( isSubnet ? banman.Unban(subNet) : banman.Unban(netAddr) )) {
+ - + + ]
808 [ + - + - ]: 4 : throw JSONRPCError(RPC_CLIENT_INVALID_IP_OR_SUBNET, "Error: Unban failed. Requested address/subnet was not previously manually banned.");
809 : : }
810 : : }
811 : 37 : return UniValue::VNULL;
812 : 59 : },
813 [ + - + - : 19520 : };
+ + - - ]
814 [ + - + - : 19520 : }
+ - + - -
- ]
815 : :
816 : 2438 : static RPCHelpMan listbanned()
817 : : {
818 : 2438 : return RPCHelpMan{
819 : 2438 : "listbanned",
820 [ + - ]: 4876 : "List all manually banned IPs/Subnets.\n",
821 : : {},
822 [ + - + - ]: 9752 : RPCResult{RPCResult::Type::ARR, "", "",
823 : : {
824 [ + - + - ]: 4876 : {RPCResult::Type::OBJ, "", "",
825 : : {
826 [ + - + - ]: 4876 : {RPCResult::Type::STR, "address", "The IP/Subnet of the banned node"},
827 [ + - + - ]: 4876 : {RPCResult::Type::NUM_TIME, "ban_created", "The " + UNIX_EPOCH_TIME + " the ban was created"},
828 [ + - + - ]: 4876 : {RPCResult::Type::NUM_TIME, "banned_until", "The " + UNIX_EPOCH_TIME + " the ban expires"},
829 [ + - + - ]: 4876 : {RPCResult::Type::NUM_TIME, "ban_duration", "The ban duration, in seconds"},
830 [ + - + - ]: 4876 : {RPCResult::Type::NUM_TIME, "time_remaining", "The time remaining until the ban expires, in seconds"},
831 : : }},
832 [ + - + - : 31694 : }},
+ - + + +
+ - - -
- ]
833 : 2438 : RPCExamples{
834 [ + - + - : 4876 : HelpExampleCli("listbanned", "")
+ - ]
835 [ + - + - : 9752 : + HelpExampleRpc("listbanned", "")
+ - + - ]
836 [ + - ]: 2438 : },
837 : 2438 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
838 : : {
839 : 47 : BanMan& banman = EnsureAnyBanman(request.context);
840 : :
841 [ + - ]: 47 : banmap_t banMap;
842 [ + - ]: 47 : banman.GetBanned(banMap);
843 [ + - ]: 47 : const int64_t current_time{GetTime()};
844 : :
845 : 47 : UniValue bannedAddresses(UniValue::VARR);
846 [ + + ]: 107 : for (const auto& entry : banMap)
847 : : {
848 : 60 : const CBanEntry& banEntry = entry.second;
849 : 60 : UniValue rec(UniValue::VOBJ);
850 [ + - + - : 120 : rec.pushKV("address", entry.first.ToString());
+ - + - ]
851 [ + - + - : 120 : rec.pushKV("ban_created", banEntry.nCreateTime);
+ - ]
852 [ + - + - : 120 : rec.pushKV("banned_until", banEntry.nBanUntil);
+ - ]
853 [ + - + - : 120 : rec.pushKV("ban_duration", (banEntry.nBanUntil - banEntry.nCreateTime));
+ - ]
854 [ + - + - : 120 : rec.pushKV("time_remaining", (banEntry.nBanUntil - current_time));
+ - ]
855 : :
856 [ + - ]: 60 : bannedAddresses.push_back(std::move(rec));
857 : 60 : }
858 : :
859 : 47 : return bannedAddresses;
860 : 47 : },
861 [ + - + - ]: 9752 : };
862 [ + - + - : 14628 : }
+ - + - +
- + - -
- ]
863 : :
864 : 2402 : static RPCHelpMan clearbanned()
865 : : {
866 : 2402 : return RPCHelpMan{
867 : 2402 : "clearbanned",
868 [ + - ]: 4804 : "Clear all banned IPs.\n",
869 : : {},
870 [ + - + - : 4804 : RPCResult{RPCResult::Type::NONE, "", ""},
+ - ]
871 : 2402 : RPCExamples{
872 [ + - + - : 4804 : HelpExampleCli("clearbanned", "")
+ - ]
873 [ + - + - : 9608 : + HelpExampleRpc("clearbanned", "")
+ - + - ]
874 [ + - ]: 2402 : },
875 : 2402 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
876 : : {
877 : 11 : BanMan& banman = EnsureAnyBanman(request.context);
878 : :
879 : 11 : banman.ClearBanned();
880 : :
881 : 11 : return UniValue::VNULL;
882 : : },
883 [ + - + - ]: 9608 : };
884 : : }
885 : :
886 : 2404 : static RPCHelpMan setnetworkactive()
887 : : {
888 : 2404 : return RPCHelpMan{
889 : 2404 : "setnetworkactive",
890 [ + - ]: 4808 : "Disable/enable all p2p network activity.\n",
891 : : {
892 [ + - + - ]: 4808 : {"state", RPCArg::Type::BOOL, RPCArg::Optional::NO, "true to enable networking, false to disable"},
893 : : },
894 [ + - + - : 4808 : RPCResult{RPCResult::Type::BOOL, "", "The value that was passed in"},
+ - + - ]
895 [ + - + - ]: 9616 : RPCExamples{""},
896 : 2404 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
897 : : {
898 : 13 : NodeContext& node = EnsureAnyNodeContext(request.context);
899 : 13 : CConnman& connman = EnsureConnman(node);
900 : :
901 : 13 : connman.SetNetworkActive(request.params[0].get_bool());
902 : :
903 : 13 : return connman.GetNetworkActive();
904 : : },
905 [ + - + - : 12020 : };
+ + - - ]
906 [ + - ]: 4808 : }
907 : :
908 : 2428 : static RPCHelpMan getnodeaddresses()
909 : : {
910 : 2428 : return RPCHelpMan{"getnodeaddresses",
911 [ + - ]: 4856 : "Return known addresses, after filtering for quality and recency.\n"
912 : : "These can potentially be used to find new peers in the network.\n"
913 : : "The total number of addresses known to the node may be higher.",
914 : : {
915 [ + - + - : 7284 : {"count", RPCArg::Type::NUM, RPCArg::Default{1}, "The maximum number of addresses to return. Specify 0 to return all known addresses."},
+ - ]
916 [ + - + - : 7284 : {"network", RPCArg::Type::STR, RPCArg::DefaultHint{"all networks"}, "Return only addresses of the specified network. Can be one of: " + Join(GetNetworkNames(), ", ") + "."},
+ - + - +
- ]
917 : : },
918 [ + - ]: 4856 : RPCResult{
919 [ + - + - ]: 4856 : RPCResult::Type::ARR, "", "",
920 : : {
921 [ + - + - ]: 4856 : {RPCResult::Type::OBJ, "", "",
922 : : {
923 [ + - + - ]: 4856 : {RPCResult::Type::NUM_TIME, "time", "The " + UNIX_EPOCH_TIME + " when the node was last seen"},
924 [ + - + - ]: 4856 : {RPCResult::Type::NUM, "services", "The services offered by the node"},
925 [ + - + - ]: 4856 : {RPCResult::Type::STR, "address", "The address of the node"},
926 [ + - + - ]: 4856 : {RPCResult::Type::NUM, "port", "The port number of the node"},
927 [ + - + - : 4856 : {RPCResult::Type::STR, "network", "The network (" + Join(GetNetworkNames(), ", ") + ") the node connected through"},
+ - + - ]
928 : : }},
929 : : }
930 [ + - + - : 31564 : },
+ - + + +
+ - - -
- ]
931 : 2428 : RPCExamples{
932 [ + - + - : 4856 : HelpExampleCli("getnodeaddresses", "8")
+ - ]
933 [ + - + - : 9712 : + HelpExampleCli("getnodeaddresses", "4 \"i2p\"")
+ - + - ]
934 [ + - + - : 9712 : + HelpExampleCli("-named getnodeaddresses", "network=onion count=12")
+ - + - ]
935 [ + - + - : 9712 : + HelpExampleRpc("getnodeaddresses", "8")
+ - + - ]
936 [ + - + - : 9712 : + HelpExampleRpc("getnodeaddresses", "4, \"i2p\"")
+ - + - ]
937 [ + - ]: 2428 : },
938 : 2428 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
939 : : {
940 : 37 : NodeContext& node = EnsureAnyNodeContext(request.context);
941 : 37 : const CConnman& connman = EnsureConnman(node);
942 : :
943 [ + + ]: 37 : const int count{request.params[0].isNull() ? 1 : request.params[0].getInt<int>()};
944 [ + + + - : 33 : if (count < 0) throw JSONRPCError(RPC_INVALID_PARAMETER, "Address count out of range");
+ - ]
945 : :
946 [ + + ]: 35 : const std::optional<Network> network{request.params[1].isNull() ? std::nullopt : std::optional<Network>{ParseNetwork(request.params[1].get_str())}};
947 [ + + ]: 35 : if (network == NET_UNROUTABLE) {
948 [ + - + - : 4 : throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Network not recognized: %s", request.params[1].get_str()));
+ - + - ]
949 : : }
950 : :
951 : : // returns a shuffled list of CAddress
952 : 33 : const std::vector<CAddress> vAddr{connman.GetAddressesUnsafe(count, /*max_pct=*/0, network)};
953 : 33 : UniValue ret(UniValue::VARR);
954 : :
955 [ + + ]: 27714 : for (const CAddress& addr : vAddr) {
956 : 27681 : UniValue obj(UniValue::VOBJ);
957 [ + - + - : 55362 : obj.pushKV("time", TicksSinceEpoch<std::chrono::seconds>(addr.nTime));
+ - ]
958 [ + - + - : 55362 : obj.pushKV("services", static_cast<std::underlying_type_t<decltype(addr.nServices)>>(addr.nServices));
+ - ]
959 [ + - + - : 55362 : obj.pushKV("address", addr.ToStringAddr());
+ - + - ]
960 [ + - + - : 55362 : obj.pushKV("port", addr.GetPort());
+ - + - ]
961 [ + - + - : 55362 : obj.pushKV("network", GetNetworkName(addr.GetNetClass()));
+ - + - +
- ]
962 [ + - ]: 27681 : ret.push_back(std::move(obj));
963 : 27681 : }
964 : 33 : return ret;
965 : 33 : },
966 [ + - + - : 14568 : };
+ + - - ]
967 [ + - + - : 24280 : }
+ - + - +
- + - + -
+ - - - -
- ]
968 : :
969 : 34716 : static RPCHelpMan addpeeraddress()
970 : : {
971 : 34716 : return RPCHelpMan{"addpeeraddress",
972 [ + - ]: 69432 : "Add the address of a potential peer to an address manager table. This RPC is for testing only.",
973 : : {
974 [ + - + - ]: 69432 : {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The IP address of the peer"},
975 [ + - + - ]: 69432 : {"port", RPCArg::Type::NUM, RPCArg::Optional::NO, "The port of the peer"},
976 [ + - + - : 104148 : {"tried", RPCArg::Type::BOOL, RPCArg::Default{false}, "If true, attempt to add the peer to the tried addresses table"},
+ - ]
977 : : },
978 [ + - ]: 69432 : RPCResult{
979 [ + - + - ]: 69432 : RPCResult::Type::OBJ, "", "",
980 : : {
981 [ + - + - ]: 69432 : {RPCResult::Type::BOOL, "success", "whether the peer address was successfully added to the address manager table"},
982 [ + - + - ]: 69432 : {RPCResult::Type::STR, "error", /*optional=*/true, "error description, if the address could not be added"},
983 : : },
984 [ + - + - : 173580 : },
+ + - - ]
985 : 34716 : RPCExamples{
986 [ + - + - : 69432 : HelpExampleCli("addpeeraddress", "\"1.2.3.4\" 8333 true")
+ - ]
987 [ + - + - : 138864 : + HelpExampleRpc("addpeeraddress", "\"1.2.3.4\", 8333, true")
+ - + - ]
988 [ + - ]: 34716 : },
989 : 34716 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
990 : : {
991 : 32330 : AddrMan& addrman = EnsureAnyAddrman(request.context);
992 : :
993 : 32330 : const std::string& addr_string{request.params[0].get_str()};
994 : 32330 : const auto port{request.params[1].getInt<uint16_t>()};
995 [ + + ]: 32326 : const bool tried{request.params[2].isNull() ? false : request.params[2].get_bool()};
996 : :
997 : 32326 : UniValue obj(UniValue::VOBJ);
998 [ + - + - ]: 32326 : std::optional<CNetAddr> net_addr{LookupHost(addr_string, false)};
999 [ + + ]: 32326 : if (!net_addr.has_value()) {
1000 [ + - + - ]: 8 : throw JSONRPCError(RPC_CLIENT_INVALID_IP_OR_SUBNET, "Invalid IP address");
1001 : : }
1002 : :
1003 : 32322 : bool success{false};
1004 : :
1005 [ + - ]: 32322 : CService service{net_addr.value(), port};
1006 [ + - ]: 64644 : CAddress address{MaybeFlipIPv6toCJDNS(service), ServiceFlags{NODE_NETWORK | NODE_WITNESS}};
1007 : 32322 : address.nTime = Now<NodeSeconds>();
1008 : : // The source address is set equal to the address. This is equivalent to the peer
1009 : : // announcing itself.
1010 [ + - + - : 64644 : if (addrman.Add({address}, address)) {
+ + + + -
- ]
1011 : 28579 : success = true;
1012 [ + + ]: 28579 : if (tried) {
1013 : : // Attempt to move the address to the tried addresses table.
1014 [ + - + + ]: 22 : if (!addrman.Good(address)) {
1015 : 2 : success = false;
1016 [ + - + - : 4 : obj.pushKV("error", "failed-adding-to-tried");
+ - ]
1017 : : }
1018 : : }
1019 : : } else {
1020 [ + - + - : 7486 : obj.pushKV("error", "failed-adding-to-new");
+ - ]
1021 : : }
1022 : :
1023 [ + - + - : 64644 : obj.pushKV("success", success);
+ - ]
1024 : 32322 : return obj;
1025 : 64648 : },
1026 [ + - + - : 243012 : };
+ + - - ]
1027 [ + - + - : 277728 : }
+ - + - +
- - - -
- ]
1028 : :
1029 : 2400 : static RPCHelpMan sendmsgtopeer()
1030 : : {
1031 : 2400 : return RPCHelpMan{
1032 : 2400 : "sendmsgtopeer",
1033 [ + - ]: 4800 : "Send a p2p message to a peer specified by id.\n"
1034 : : "The message type and body must be provided, the message header will be generated.\n"
1035 : : "This RPC is for testing only.",
1036 : : {
1037 [ + - + - ]: 4800 : {"peer_id", RPCArg::Type::NUM, RPCArg::Optional::NO, "The peer to send the message to."},
1038 [ + - + - ]: 4800 : {"msg_type", RPCArg::Type::STR, RPCArg::Optional::NO, strprintf("The message type (maximum length %i)", CMessageHeader::MESSAGE_TYPE_SIZE)},
1039 [ + - + - ]: 4800 : {"msg", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The serialized message body to send, in hex, without a message header"},
1040 : : },
1041 [ + - + - : 4800 : RPCResult{RPCResult::Type::OBJ, "", "", std::vector<RPCResult>{}},
+ - + - ]
1042 : 2400 : RPCExamples{
1043 [ + - + - : 7200 : HelpExampleCli("sendmsgtopeer", "0 \"addr\" \"ffffff\"") + HelpExampleRpc("sendmsgtopeer", "0 \"addr\" \"ffffff\"")},
+ - + - +
- + - + -
+ - ]
1044 : 2400 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue {
1045 : 18 : const NodeId peer_id{request.params[0].getInt<int64_t>()};
1046 : 18 : const auto msg_type{self.Arg<std::string_view>("msg_type")};
1047 [ + + ]: 18 : if (msg_type.size() > CMessageHeader::MESSAGE_TYPE_SIZE) {
1048 [ + - + - ]: 4 : throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Error: msg_type too long, max length is %i", CMessageHeader::MESSAGE_TYPE_SIZE));
1049 : : }
1050 : 16 : auto msg{TryParseHex<unsigned char>(self.Arg<std::string_view>("msg"))};
1051 [ - + ]: 16 : if (!msg.has_value()) {
1052 [ # # # # ]: 0 : throw JSONRPCError(RPC_INVALID_PARAMETER, "Error parsing input for msg");
1053 : : }
1054 : :
1055 [ + - ]: 16 : NodeContext& node = EnsureAnyNodeContext(request.context);
1056 [ + - ]: 16 : CConnman& connman = EnsureConnman(node);
1057 : :
1058 [ + - ]: 16 : CSerializedNetMsg msg_ser;
1059 [ + - + - ]: 16 : msg_ser.data = msg.value();
1060 [ + - ]: 16 : msg_ser.m_type = msg_type;
1061 : :
1062 [ + - ]: 16 : bool success = connman.ForNode(peer_id, [&](CNode* node) {
1063 : 14 : connman.PushMessage(node, std::move(msg_ser));
1064 : 14 : return true;
1065 : : });
1066 : :
1067 [ + + ]: 16 : if (!success) {
1068 [ + - + - ]: 4 : throw JSONRPCError(RPC_MISC_ERROR, "Error: Could not send message to peer");
1069 : : }
1070 : :
1071 : 14 : UniValue ret{UniValue::VOBJ};
1072 : 14 : return ret;
1073 : 16 : },
1074 [ + - + - : 16800 : };
+ + - - ]
1075 [ + - + - : 14400 : }
+ - - - ]
1076 : :
1077 : 2399 : static RPCHelpMan getaddrmaninfo()
1078 : : {
1079 : 2399 : return RPCHelpMan{
1080 : 2399 : "getaddrmaninfo",
1081 [ + - ]: 4798 : "Provides information about the node's address manager by returning the number of "
1082 : : "addresses in the `new` and `tried` tables and their sum for all networks.\n",
1083 : : {},
1084 [ + - ]: 4798 : RPCResult{
1085 [ + - ]: 4798 : RPCResult::Type::OBJ_DYN, "", "json object with network type as keys", {
1086 [ + - + - : 4798 : {RPCResult::Type::OBJ, "network", "the network (" + Join(GetNetworkNames(), ", ") + ", all_networks)", {
+ - + - ]
1087 [ + - + - ]: 4798 : {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."},
1088 [ + - + - ]: 4798 : {RPCResult::Type::NUM, "tried", "number of addresses in the tried table, which represent peers the node has successfully connected to in the past."},
1089 [ + - + - ]: 4798 : {RPCResult::Type::NUM, "total", "total number of addresses in both new/tried tables"},
1090 : : }},
1091 [ + - + - : 21591 : }},
+ - + + +
+ - - -
- ]
1092 [ + - + - : 7197 : RPCExamples{HelpExampleCli("getaddrmaninfo", "") + HelpExampleRpc("getaddrmaninfo", "")},
+ - + - +
- + - + -
+ - ]
1093 : 2399 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue {
1094 : 8 : AddrMan& addrman = EnsureAnyAddrman(request.context);
1095 : :
1096 : 8 : UniValue ret(UniValue::VOBJ);
1097 [ + + ]: 64 : for (int n = 0; n < NET_MAX; ++n) {
1098 : 56 : enum Network network = static_cast<enum Network>(n);
1099 [ + + ]: 56 : if (network == NET_UNROUTABLE || network == NET_INTERNAL) continue;
1100 : 40 : UniValue obj(UniValue::VOBJ);
1101 [ + - + - : 80 : obj.pushKV("new", addrman.Size(network, true));
+ - + - ]
1102 [ + - + - : 80 : obj.pushKV("tried", addrman.Size(network, false));
+ - + - ]
1103 [ + - + - : 80 : obj.pushKV("total", addrman.Size(network));
+ - + - ]
1104 [ + - + - ]: 80 : ret.pushKV(GetNetworkName(network), std::move(obj));
1105 : 40 : }
1106 : 8 : UniValue obj(UniValue::VOBJ);
1107 [ + - + - : 16 : obj.pushKV("new", addrman.Size(std::nullopt, true));
+ - + - ]
1108 [ + - + - : 16 : obj.pushKV("tried", addrman.Size(std::nullopt, false));
+ - + - ]
1109 [ + - + - : 16 : obj.pushKV("total", addrman.Size());
+ - + - ]
1110 [ + - + - ]: 16 : ret.pushKV("all_networks", std::move(obj));
1111 : 8 : return ret;
1112 : 8 : },
1113 [ + - + - ]: 9596 : };
1114 [ + - + - : 9596 : }
+ - + - -
- ]
1115 : :
1116 : 26 : UniValue AddrmanEntryToJSON(const AddrInfo& info, const CConnman& connman)
1117 : : {
1118 : 26 : UniValue ret(UniValue::VOBJ);
1119 [ + - + - : 52 : ret.pushKV("address", info.ToStringAddr());
+ - + - ]
1120 [ + - ]: 26 : const uint32_t mapped_as{connman.GetMappedAS(info)};
1121 [ + + ]: 26 : if (mapped_as) {
1122 [ + - + - : 8 : ret.pushKV("mapped_as", mapped_as);
+ - ]
1123 : : }
1124 [ + - + - : 52 : ret.pushKV("port", info.GetPort());
+ - + - ]
1125 [ + - + - : 52 : ret.pushKV("services", static_cast<std::underlying_type_t<decltype(info.nServices)>>(info.nServices));
+ - ]
1126 [ + - + - : 52 : ret.pushKV("time", TicksSinceEpoch<std::chrono::seconds>(info.nTime));
+ - ]
1127 [ + - + - : 52 : ret.pushKV("network", GetNetworkName(info.GetNetClass()));
+ - + - +
- ]
1128 [ + - + - : 52 : ret.pushKV("source", info.source.ToStringAddr());
+ - + - ]
1129 [ + - + - : 52 : ret.pushKV("source_network", GetNetworkName(info.source.GetNetClass()));
+ - + - +
- ]
1130 [ + - ]: 26 : const uint32_t source_mapped_as{connman.GetMappedAS(info.source)};
1131 [ + + ]: 26 : if (source_mapped_as) {
1132 [ + - + - : 8 : ret.pushKV("source_mapped_as", source_mapped_as);
+ - ]
1133 : : }
1134 : 26 : return ret;
1135 : 0 : }
1136 : :
1137 : 14 : UniValue AddrmanTableToJSON(const std::vector<std::pair<AddrInfo, AddressPosition>>& tableInfos, const CConnman& connman)
1138 : : {
1139 : 14 : UniValue table(UniValue::VOBJ);
1140 [ + + ]: 40 : for (const auto& e : tableInfos) {
1141 : 26 : AddrInfo info = e.first;
1142 : 26 : AddressPosition location = e.second;
1143 [ + - ]: 26 : std::ostringstream key;
1144 [ + - + - : 26 : key << location.bucket << "/" << location.position;
+ - ]
1145 : : // Address manager tables have unique entries so there is no advantage
1146 : : // in using UniValue::pushKV, which checks if the key already exists
1147 : : // in O(N). UniValue::pushKVEnd is used instead which currently is O(1).
1148 [ + - + - ]: 78 : table.pushKVEnd(key.str(), AddrmanEntryToJSON(info, connman));
1149 : 52 : }
1150 : 14 : return table;
1151 : 0 : }
1152 : :
1153 : 2391 : static RPCHelpMan getrawaddrman()
1154 : : {
1155 : 2391 : return RPCHelpMan{"getrawaddrman",
1156 [ + - ]: 4782 : "EXPERIMENTAL warning: this call may be changed in future releases.\n"
1157 : : "\nReturns information on all address manager entries for the new and tried tables.\n",
1158 : : {},
1159 [ + - ]: 4782 : RPCResult{
1160 [ + - ]: 4782 : RPCResult::Type::OBJ_DYN, "", "", {
1161 [ + - + - ]: 4782 : {RPCResult::Type::OBJ_DYN, "table", "buckets with addresses in the address manager table ( new, tried )", {
1162 [ + - + - ]: 4782 : {RPCResult::Type::OBJ, "bucket/position", "the location in the address manager table (<bucket>/<position>)", {
1163 [ + - + - ]: 4782 : {RPCResult::Type::STR, "address", "The address of the node"},
1164 [ + - + - ]: 4782 : {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)"},
1165 [ + - + - ]: 4782 : {RPCResult::Type::NUM, "port", "The port number of the node"},
1166 [ + - + - : 4782 : {RPCResult::Type::STR, "network", "The network (" + Join(GetNetworkNames(), ", ") + ") of the address"},
+ - + - ]
1167 [ + - + - ]: 4782 : {RPCResult::Type::NUM, "services", "The services offered by the node"},
1168 [ + - + - ]: 4782 : {RPCResult::Type::NUM_TIME, "time", "The " + UNIX_EPOCH_TIME + " when the node was last seen"},
1169 [ + - + - ]: 4782 : {RPCResult::Type::STR, "source", "The address that relayed the address to us"},
1170 [ + - + - : 4782 : {RPCResult::Type::STR, "source_network", "The network (" + Join(GetNetworkNames(), ", ") + ") of the source address"},
+ - + - ]
1171 [ + - + - ]: 4782 : {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)"}
1172 : : }}
1173 : : }}
1174 : : }
1175 [ + - + - : 54993 : },
+ - + - +
+ + + + +
- - - - -
- ]
1176 : 2391 : RPCExamples{
1177 [ + - + - : 4782 : HelpExampleCli("getrawaddrman", "")
+ - ]
1178 [ + - + - : 9564 : + HelpExampleRpc("getrawaddrman", "")
+ - + - ]
1179 [ + - ]: 2391 : },
1180 : 2391 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue {
1181 : 7 : AddrMan& addrman = EnsureAnyAddrman(request.context);
1182 : 7 : NodeContext& node_context = EnsureAnyNodeContext(request.context);
1183 : 7 : CConnman& connman = EnsureConnman(node_context);
1184 : :
1185 : 7 : UniValue ret(UniValue::VOBJ);
1186 [ + - + - : 14 : ret.pushKV("new", AddrmanTableToJSON(addrman.GetEntries(false), connman));
+ - + - ]
1187 [ + - + - : 14 : ret.pushKV("tried", AddrmanTableToJSON(addrman.GetEntries(true), connman));
+ - + - ]
1188 : 7 : return ret;
1189 : 0 : },
1190 [ + - + - ]: 9564 : };
1191 [ + - + - : 26301 : }
+ - + - +
- + - + -
+ - + - +
- + - -
- ]
1192 : :
1193 : 1326 : void RegisterNetRPCCommands(CRPCTable& t)
1194 : : {
1195 : 1326 : static const CRPCCommand commands[]{
1196 [ + - ]: 2380 : {"network", &getconnectioncount},
1197 [ + - ]: 2380 : {"network", &ping},
1198 [ + - ]: 2380 : {"network", &getpeerinfo},
1199 [ + - ]: 2380 : {"network", &addnode},
1200 [ + - ]: 2380 : {"network", &disconnectnode},
1201 [ + - ]: 2380 : {"network", &getaddednodeinfo},
1202 [ + - ]: 2380 : {"network", &getnettotals},
1203 [ + - ]: 2380 : {"network", &getnetworkinfo},
1204 [ + - ]: 2380 : {"network", &setban},
1205 [ + - ]: 2380 : {"network", &listbanned},
1206 [ + - ]: 2380 : {"network", &clearbanned},
1207 [ + - ]: 2380 : {"network", &setnetworkactive},
1208 [ + - ]: 2380 : {"network", &getnodeaddresses},
1209 [ + - ]: 2380 : {"network", &getaddrmaninfo},
1210 [ + - ]: 2380 : {"hidden", &addconnection},
1211 [ + - ]: 2380 : {"hidden", &addpeeraddress},
1212 [ + - ]: 2380 : {"hidden", &sendmsgtopeer},
1213 [ + - ]: 2380 : {"hidden", &getrawaddrman},
1214 [ + + + - : 22746 : };
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- - - ]
1215 [ + + ]: 25194 : for (const auto& c : commands) {
1216 : 23868 : t.appendCommand(c.name, &c);
1217 : : }
1218 : 1326 : }
|
