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