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