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