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