LCOV - code coverage report
Current view: top level - src/rpc - net.cpp (source / functions) Coverage Total Hit
Test: test_bitcoin_coverage.info Lines: 49.3 % 675 333
Test Date: 2025-06-01 05:54:06 Functions: 63.4 % 41 26
Branches: 36.0 % 3418 1232

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

Generated by: LCOV version 2.0-1