LCOV - code coverage report
Current view: top level - src - net.cpp (source / functions) Coverage Total Hit
Test: total_coverage.info Lines: 89.5 % 2076 1858
Test Date: 2025-03-28 05:06:44 Functions: 96.2 % 159 153
Branches: 56.4 % 2785 1572

             Branch data     Line data    Source code
       1                 :             : // Copyright (c) 2009-2010 Satoshi Nakamoto
       2                 :             : // Copyright (c) 2009-present The Bitcoin Core developers
       3                 :             : // Distributed under the MIT software license, see the accompanying
       4                 :             : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       5                 :             : 
       6                 :             : #include <bitcoin-build-config.h> // IWYU pragma: keep
       7                 :             : 
       8                 :             : #include <net.h>
       9                 :             : 
      10                 :             : #include <addrdb.h>
      11                 :             : #include <addrman.h>
      12                 :             : #include <banman.h>
      13                 :             : #include <clientversion.h>
      14                 :             : #include <common/args.h>
      15                 :             : #include <common/netif.h>
      16                 :             : #include <compat/compat.h>
      17                 :             : #include <consensus/consensus.h>
      18                 :             : #include <crypto/sha256.h>
      19                 :             : #include <i2p.h>
      20                 :             : #include <key.h>
      21                 :             : #include <logging.h>
      22                 :             : #include <memusage.h>
      23                 :             : #include <net_permissions.h>
      24                 :             : #include <netaddress.h>
      25                 :             : #include <netbase.h>
      26                 :             : #include <node/eviction.h>
      27                 :             : #include <node/interface_ui.h>
      28                 :             : #include <protocol.h>
      29                 :             : #include <random.h>
      30                 :             : #include <scheduler.h>
      31                 :             : #include <util/fs.h>
      32                 :             : #include <util/sock.h>
      33                 :             : #include <util/strencodings.h>
      34                 :             : #include <util/thread.h>
      35                 :             : #include <util/threadinterrupt.h>
      36                 :             : #include <util/trace.h>
      37                 :             : #include <util/translation.h>
      38                 :             : #include <util/vector.h>
      39                 :             : 
      40                 :             : #ifdef WIN32
      41                 :             : #include <string.h>
      42                 :             : #endif
      43                 :             : 
      44                 :             : #if HAVE_DECL_GETIFADDRS && HAVE_DECL_FREEIFADDRS
      45                 :             : #include <ifaddrs.h>
      46                 :             : #endif
      47                 :             : 
      48                 :             : #include <algorithm>
      49                 :             : #include <array>
      50                 :             : #include <cmath>
      51                 :             : #include <cstdint>
      52                 :             : #include <functional>
      53                 :             : #include <optional>
      54                 :             : #include <unordered_map>
      55                 :             : 
      56                 :             : TRACEPOINT_SEMAPHORE(net, closed_connection);
      57                 :             : TRACEPOINT_SEMAPHORE(net, evicted_inbound_connection);
      58                 :             : TRACEPOINT_SEMAPHORE(net, inbound_connection);
      59                 :             : TRACEPOINT_SEMAPHORE(net, outbound_connection);
      60                 :             : TRACEPOINT_SEMAPHORE(net, outbound_message);
      61                 :             : 
      62                 :             : /** Maximum number of block-relay-only anchor connections */
      63                 :             : static constexpr size_t MAX_BLOCK_RELAY_ONLY_ANCHORS = 2;
      64                 :             : static_assert (MAX_BLOCK_RELAY_ONLY_ANCHORS <= static_cast<size_t>(MAX_BLOCK_RELAY_ONLY_CONNECTIONS), "MAX_BLOCK_RELAY_ONLY_ANCHORS must not exceed MAX_BLOCK_RELAY_ONLY_CONNECTIONS.");
      65                 :             : /** Anchor IP address database file name */
      66                 :             : const char* const ANCHORS_DATABASE_FILENAME = "anchors.dat";
      67                 :             : 
      68                 :             : // How often to dump addresses to peers.dat
      69                 :             : static constexpr std::chrono::minutes DUMP_PEERS_INTERVAL{15};
      70                 :             : 
      71                 :             : /** Number of DNS seeds to query when the number of connections is low. */
      72                 :             : static constexpr int DNSSEEDS_TO_QUERY_AT_ONCE = 3;
      73                 :             : 
      74                 :             : /** Minimum number of outbound connections under which we will keep fetching our address seeds. */
      75                 :             : static constexpr int SEED_OUTBOUND_CONNECTION_THRESHOLD = 2;
      76                 :             : 
      77                 :             : /** How long to delay before querying DNS seeds
      78                 :             :  *
      79                 :             :  * If we have more than THRESHOLD entries in addrman, then it's likely
      80                 :             :  * that we got those addresses from having previously connected to the P2P
      81                 :             :  * network, and that we'll be able to successfully reconnect to the P2P
      82                 :             :  * network via contacting one of them. So if that's the case, spend a
      83                 :             :  * little longer trying to connect to known peers before querying the
      84                 :             :  * DNS seeds.
      85                 :             :  */
      86                 :             : static constexpr std::chrono::seconds DNSSEEDS_DELAY_FEW_PEERS{11};
      87                 :             : static constexpr std::chrono::minutes DNSSEEDS_DELAY_MANY_PEERS{5};
      88                 :             : static constexpr int DNSSEEDS_DELAY_PEER_THRESHOLD = 1000; // "many" vs "few" peers
      89                 :             : 
      90                 :             : /** The default timeframe for -maxuploadtarget. 1 day. */
      91                 :             : static constexpr std::chrono::seconds MAX_UPLOAD_TIMEFRAME{60 * 60 * 24};
      92                 :             : 
      93                 :             : // A random time period (0 to 1 seconds) is added to feeler connections to prevent synchronization.
      94                 :             : static constexpr auto FEELER_SLEEP_WINDOW{1s};
      95                 :             : 
      96                 :             : /** Frequency to attempt extra connections to reachable networks we're not connected to yet **/
      97                 :             : static constexpr auto EXTRA_NETWORK_PEER_INTERVAL{5min};
      98                 :             : 
      99                 :             : /** Used to pass flags to the Bind() function */
     100                 :             : enum BindFlags {
     101                 :             :     BF_NONE         = 0,
     102                 :             :     BF_REPORT_ERROR = (1U << 0),
     103                 :             :     /**
     104                 :             :      * Do not call AddLocal() for our special addresses, e.g., for incoming
     105                 :             :      * Tor connections, to prevent gossiping them over the network.
     106                 :             :      */
     107                 :             :     BF_DONT_ADVERTISE = (1U << 1),
     108                 :             : };
     109                 :             : 
     110                 :             : // The set of sockets cannot be modified while waiting
     111                 :             : // The sleep time needs to be small to avoid new sockets stalling
     112                 :             : static const uint64_t SELECT_TIMEOUT_MILLISECONDS = 50;
     113                 :             : 
     114                 :             : const std::string NET_MESSAGE_TYPE_OTHER = "*other*";
     115                 :             : 
     116                 :             : static const uint64_t RANDOMIZER_ID_NETGROUP = 0x6c0edd8036ef4036ULL; // SHA256("netgroup")[0:8]
     117                 :             : static const uint64_t RANDOMIZER_ID_LOCALHOSTNONCE = 0xd93e69e2bbfa5735ULL; // SHA256("localhostnonce")[0:8]
     118                 :             : static const uint64_t RANDOMIZER_ID_ADDRCACHE = 0x1cf2e4ddd306dda9ULL; // SHA256("addrcache")[0:8]
     119                 :             : //
     120                 :             : // Global state variables
     121                 :             : //
     122                 :             : bool fDiscover = true;
     123                 :             : bool fListen = true;
     124                 :             : GlobalMutex g_maplocalhost_mutex;
     125                 :             : std::map<CNetAddr, LocalServiceInfo> mapLocalHost GUARDED_BY(g_maplocalhost_mutex);
     126                 :             : std::string strSubVersion;
     127                 :             : 
     128                 :      660064 : size_t CSerializedNetMsg::GetMemoryUsage() const noexcept
     129                 :             : {
     130         [ +  + ]:      660064 :     return sizeof(*this) + memusage::DynamicUsage(m_type) + memusage::DynamicUsage(data);
     131                 :             : }
     132                 :             : 
     133                 :      323662 : size_t CNetMessage::GetMemoryUsage() const noexcept
     134                 :             : {
     135                 :      323662 :     return sizeof(*this) + memusage::DynamicUsage(m_type) + m_recv.GetMemoryUsage();
     136                 :             : }
     137                 :             : 
     138                 :          11 : void CConnman::AddAddrFetch(const std::string& strDest)
     139                 :             : {
     140                 :          11 :     LOCK(m_addr_fetches_mutex);
     141         [ +  - ]:          11 :     m_addr_fetches.push_back(strDest);
     142                 :          11 : }
     143                 :             : 
     144                 :        1561 : uint16_t GetListenPort()
     145                 :             : {
     146                 :             :     // If -bind= is provided with ":port" part, use that (first one if multiple are provided).
     147   [ +  -  +  + ]:        3178 :     for (const std::string& bind_arg : gArgs.GetArgs("-bind")) {
     148                 :        1620 :         constexpr uint16_t dummy_port = 0;
     149                 :             : 
     150   [ +  -  +  - ]:        1620 :         const std::optional<CService> bind_addr{Lookup(bind_arg, dummy_port, /*fAllowLookup=*/false)};
     151   [ +  +  +  -  :        1620 :         if (bind_addr.has_value() && bind_addr->GetPort() != dummy_port) return bind_addr->GetPort();
             +  +  +  - ]
     152                 :        3178 :     }
     153                 :             : 
     154                 :             :     // Otherwise, if -whitebind= without NetPermissionFlags::NoBan is provided, use that
     155                 :             :     // (-whitebind= is required to have ":port").
     156   [ +  -  +  + ]:        1558 :     for (const std::string& whitebind_arg : gArgs.GetArgs("-whitebind")) {
     157         [ +  - ]:           1 :         NetWhitebindPermissions whitebind;
     158         [ +  - ]:           1 :         bilingual_str error;
     159   [ +  -  +  - ]:           1 :         if (NetWhitebindPermissions::TryParse(whitebind_arg, whitebind, error)) {
     160         [ +  - ]:           1 :             if (!NetPermissions::HasFlag(whitebind.m_flags, NetPermissionFlags::NoBan)) {
     161         [ +  - ]:           1 :                 return whitebind.m_service.GetPort();
     162                 :             :             }
     163                 :             :         }
     164                 :        1558 :     }
     165                 :             : 
     166                 :             :     // Otherwise, if -port= is provided, use that. Otherwise use the default port.
     167         [ +  - ]:        1557 :     return static_cast<uint16_t>(gArgs.GetIntArg("-port", Params().GetDefaultPort()));
     168                 :             : }
     169                 :             : 
     170                 :             : // Determine the "best" local address for a particular peer.
     171                 :        1555 : [[nodiscard]] static std::optional<CService> GetLocal(const CNode& peer)
     172                 :             : {
     173         [ -  + ]:        1555 :     if (!fListen) return std::nullopt;
     174                 :             : 
     175                 :        1555 :     std::optional<CService> addr;
     176                 :        1555 :     int nBestScore = -1;
     177                 :        1555 :     int nBestReachability = -1;
     178                 :        1555 :     {
     179         [ +  - ]:        1555 :         LOCK(g_maplocalhost_mutex);
     180   [ +  -  +  + ]:        1626 :         for (const auto& [local_addr, local_service_info] : mapLocalHost) {
     181                 :             :             // For privacy reasons, don't advertise our privacy-network address
     182                 :             :             // to other networks and don't advertise our other-network address
     183                 :             :             // to privacy networks.
     184   [ +  -  +  - ]:          71 :             if (local_addr.GetNetwork() != peer.ConnectedThroughNetwork()
     185   [ +  +  +  -  :         104 :                 && (local_addr.IsPrivacyNet() || peer.IsConnectedThroughPrivacyNet())) {
                   +  + ]
     186                 :          36 :                 continue;
     187                 :             :             }
     188                 :          35 :             const int nScore{local_service_info.nScore};
     189         [ +  - ]:          35 :             const int nReachability{local_addr.GetReachabilityFrom(peer.addr)};
     190   [ +  +  -  + ]:          35 :             if (nReachability > nBestReachability || (nReachability == nBestReachability && nScore > nBestScore)) {
     191         [ +  - ]:          18 :                 addr.emplace(CService{local_addr, local_service_info.nPort});
     192                 :          18 :                 nBestReachability = nReachability;
     193                 :          18 :                 nBestScore = nScore;
     194                 :             :             }
     195                 :             :         }
     196                 :           0 :     }
     197         [ +  + ]:        1570 :     return addr;
     198                 :        1555 : }
     199                 :             : 
     200                 :             : //! Convert the serialized seeds into usable address objects.
     201                 :           3 : static std::vector<CAddress> ConvertSeeds(const std::vector<uint8_t> &vSeedsIn)
     202                 :             : {
     203                 :             :     // It'll only connect to one or two seed nodes because once it connects,
     204                 :             :     // it'll get a pile of addresses with newer timestamps.
     205                 :             :     // Seed nodes are given a random 'last seen time' of between one and two
     206                 :             :     // weeks ago.
     207                 :           3 :     const auto one_week{7 * 24h};
     208                 :           3 :     std::vector<CAddress> vSeedsOut;
     209                 :           3 :     FastRandomContext rng;
     210         [ +  - ]:           3 :     ParamsStream s{DataStream{vSeedsIn}, CAddress::V2_NETWORK};
     211         [ -  + ]:           3 :     while (!s.eof()) {
     212         [ #  # ]:           0 :         CService endpoint;
     213         [ #  # ]:           0 :         s >> endpoint;
     214                 :           0 :         CAddress addr{endpoint, SeedsServiceFlags()};
     215                 :           0 :         addr.nTime = rng.rand_uniform_delay(Now<NodeSeconds>() - one_week, -one_week);
     216   [ #  #  #  #  :           0 :         LogDebug(BCLog::NET, "Added hardcoded seed: %s\n", addr.ToStringAddrPort());
             #  #  #  # ]
     217         [ #  # ]:           0 :         vSeedsOut.push_back(addr);
     218                 :           0 :     }
     219                 :           3 :     return vSeedsOut;
     220                 :           3 : }
     221                 :             : 
     222                 :             : // Determine the "best" local address for a particular peer.
     223                 :             : // If none, return the unroutable 0.0.0.0 but filled in with
     224                 :             : // the normal parameters, since the IP may be changed to a useful
     225                 :             : // one by discovery.
     226                 :        1555 : CService GetLocalAddress(const CNode& peer)
     227                 :             : {
     228   [ +  -  +  -  :        1555 :     return GetLocal(peer).value_or(CService{CNetAddr(), GetListenPort()});
                   +  - ]
     229                 :             : }
     230                 :             : 
     231                 :           0 : static int GetnScore(const CService& addr)
     232                 :             : {
     233                 :           0 :     LOCK(g_maplocalhost_mutex);
     234         [ #  # ]:           0 :     const auto it = mapLocalHost.find(addr);
     235   [ #  #  #  # ]:           0 :     return (it != mapLocalHost.end()) ? it->second.nScore : 0;
     236                 :           0 : }
     237                 :             : 
     238                 :             : // Is our peer's addrLocal potentially useful as an external IP source?
     239                 :        1534 : [[nodiscard]] static bool IsPeerAddrLocalGood(CNode *pnode)
     240                 :             : {
     241                 :        1534 :     CService addrLocal = pnode->GetAddrLocal();
     242   [ +  +  +  -  :        1538 :     return fDiscover && pnode->addr.IsRoutable() && addrLocal.IsRoutable() &&
          +  -  +  -  +  
                -  -  + ]
     243         [ +  - ]:        1538 :            g_reachable_nets.Contains(addrLocal);
     244                 :        1534 : }
     245                 :             : 
     246                 :        1534 : std::optional<CService> GetLocalAddrForPeer(CNode& node)
     247                 :             : {
     248                 :        1534 :     CService addrLocal{GetLocalAddress(node)};
     249                 :             :     // If discovery is enabled, sometimes give our peer the address it
     250                 :             :     // tells us that it sees us as in case it has a better idea of our
     251                 :             :     // address than we do.
     252                 :        1534 :     FastRandomContext rng;
     253   [ +  -  +  +  :        1534 :     if (IsPeerAddrLocalGood(&node) && (!addrLocal.IsRoutable() ||
          +  -  -  +  -  
                      - ]
     254   [ #  #  #  # ]:           0 :          rng.randbits((GetnScore(addrLocal) > LOCAL_MANUAL) ? 3 : 1) == 0))
     255                 :             :     {
     256         [ +  + ]:           4 :         if (node.IsInboundConn()) {
     257                 :             :             // For inbound connections, assume both the address and the port
     258                 :             :             // as seen from the peer.
     259         [ +  - ]:           2 :             addrLocal = CService{node.GetAddrLocal()};
     260                 :             :         } else {
     261                 :             :             // For outbound connections, assume just the address as seen from
     262                 :             :             // the peer and leave the port in `addrLocal` as returned by
     263                 :             :             // `GetLocalAddress()` above. The peer has no way to observe our
     264                 :             :             // listening port when we have initiated the connection.
     265   [ +  -  +  - ]:           6 :             addrLocal.SetIP(node.GetAddrLocal());
     266                 :             :         }
     267                 :             :     }
     268   [ +  -  +  + ]:        1534 :     if (addrLocal.IsRoutable()) {
     269   [ +  -  +  -  :           8 :         LogDebug(BCLog::NET, "Advertising address %s to peer=%d\n", addrLocal.ToStringAddrPort(), node.GetId());
             +  -  +  - ]
     270                 :           4 :         return addrLocal;
     271                 :             :     }
     272                 :             :     // Address is unroutable. Don't advertise.
     273                 :        1530 :     return std::nullopt;
     274                 :        1534 : }
     275                 :             : 
     276                 :             : // learn a new local address
     277                 :          11 : bool AddLocal(const CService& addr_, int nScore)
     278                 :             : {
     279                 :          11 :     CService addr{MaybeFlipIPv6toCJDNS(addr_)};
     280                 :             : 
     281   [ +  -  +  - ]:          11 :     if (!addr.IsRoutable())
     282                 :             :         return false;
     283                 :             : 
     284   [ -  +  -  - ]:          11 :     if (!fDiscover && nScore < LOCAL_MANUAL)
     285                 :             :         return false;
     286                 :             : 
     287   [ +  -  +  - ]:          11 :     if (!g_reachable_nets.Contains(addr))
     288                 :             :         return false;
     289                 :             : 
     290   [ +  -  +  - ]:          11 :     LogPrintf("AddLocal(%s,%i)\n", addr.ToStringAddrPort(), nScore);
     291                 :             : 
     292                 :          11 :     {
     293         [ +  - ]:          11 :         LOCK(g_maplocalhost_mutex);
     294   [ +  -  -  + ]:          11 :         const auto [it, is_newly_added] = mapLocalHost.emplace(addr, LocalServiceInfo());
     295         [ -  + ]:          11 :         LocalServiceInfo &info = it->second;
     296   [ -  +  -  - ]:          11 :         if (is_newly_added || nScore >= info.nScore) {
     297         [ -  + ]:          11 :             info.nScore = nScore + (is_newly_added ? 0 : 1);
     298         [ +  - ]:          11 :             info.nPort = addr.GetPort();
     299                 :             :         }
     300                 :           0 :     }
     301                 :             : 
     302                 :          11 :     return true;
     303                 :          11 : }
     304                 :             : 
     305                 :           0 : bool AddLocal(const CNetAddr &addr, int nScore)
     306                 :             : {
     307         [ #  # ]:           0 :     return AddLocal(CService(addr, GetListenPort()), nScore);
     308                 :             : }
     309                 :             : 
     310                 :          11 : void RemoveLocal(const CService& addr)
     311                 :             : {
     312                 :          11 :     LOCK(g_maplocalhost_mutex);
     313   [ +  -  +  - ]:          11 :     LogPrintf("RemoveLocal(%s)\n", addr.ToStringAddrPort());
     314   [ +  -  +  - ]:          11 :     mapLocalHost.erase(addr);
     315                 :          11 : }
     316                 :             : 
     317                 :             : /** vote for a local address */
     318                 :           0 : bool SeenLocal(const CService& addr)
     319                 :             : {
     320                 :           0 :     LOCK(g_maplocalhost_mutex);
     321         [ #  # ]:           0 :     const auto it = mapLocalHost.find(addr);
     322         [ #  # ]:           0 :     if (it == mapLocalHost.end()) return false;
     323                 :           0 :     ++it->second.nScore;
     324                 :           0 :     return true;
     325                 :           0 : }
     326                 :             : 
     327                 :             : 
     328                 :             : /** check whether a given address is potentially local */
     329                 :          12 : bool IsLocal(const CService& addr)
     330                 :             : {
     331                 :          12 :     LOCK(g_maplocalhost_mutex);
     332   [ +  -  +  - ]:          12 :     return mapLocalHost.count(addr) > 0;
     333                 :          12 : }
     334                 :             : 
     335                 :           9 : CNode* CConnman::FindNode(const CNetAddr& ip)
     336                 :             : {
     337                 :           9 :     LOCK(m_nodes_mutex);
     338         [ +  + ]:          24 :     for (CNode* pnode : m_nodes) {
     339   [ +  -  +  + ]:          21 :       if (static_cast<CNetAddr>(pnode->addr) == ip) {
     340                 :             :             return pnode;
     341                 :             :         }
     342                 :             :     }
     343                 :             :     return nullptr;
     344                 :           9 : }
     345                 :             : 
     346                 :         613 : CNode* CConnman::FindNode(const std::string& addrName)
     347                 :             : {
     348                 :         613 :     LOCK(m_nodes_mutex);
     349         [ +  + ]:        1157 :     for (CNode* pnode : m_nodes) {
     350         [ +  + ]:         546 :         if (pnode->m_addr_name == addrName) {
     351                 :             :             return pnode;
     352                 :             :         }
     353                 :             :     }
     354                 :             :     return nullptr;
     355                 :         613 : }
     356                 :             : 
     357                 :         604 : CNode* CConnman::FindNode(const CService& addr)
     358                 :             : {
     359                 :         604 :     LOCK(m_nodes_mutex);
     360         [ +  + ]:        1127 :     for (CNode* pnode : m_nodes) {
     361   [ +  -  +  + ]:         533 :         if (static_cast<CService>(pnode->addr) == addr) {
     362                 :             :             return pnode;
     363                 :             :         }
     364                 :             :     }
     365                 :             :     return nullptr;
     366                 :         604 : }
     367                 :             : 
     368                 :           9 : bool CConnman::AlreadyConnectedToAddress(const CAddress& addr)
     369                 :             : {
     370   [ +  -  +  +  :          21 :     return FindNode(static_cast<CNetAddr>(addr)) || FindNode(addr.ToStringAddrPort());
          +  -  +  -  +  
                      - ]
     371                 :             : }
     372                 :             : 
     373                 :         942 : bool CConnman::CheckIncomingNonce(uint64_t nonce)
     374                 :             : {
     375                 :         942 :     LOCK(m_nodes_mutex);
     376         [ +  + ]:        3563 :     for (const CNode* pnode : m_nodes) {
     377   [ +  +  +  +  :        2623 :         if (!pnode->fSuccessfullyConnected && !pnode->IsInboundConn() && pnode->GetLocalNonce() == nonce)
                   -  + ]
     378                 :             :             return false;
     379                 :             :     }
     380                 :             :     return true;
     381                 :         942 : }
     382                 :             : 
     383                 :             : /** Get the bind address for a socket as CService. */
     384                 :        1550 : static CService GetBindAddress(const Sock& sock)
     385                 :             : {
     386                 :        1550 :     CService addr_bind;
     387                 :        1550 :     struct sockaddr_storage sockaddr_bind;
     388                 :        1550 :     socklen_t sockaddr_bind_len = sizeof(sockaddr_bind);
     389   [ +  -  +  - ]:        1550 :     if (!sock.GetSockName((struct sockaddr*)&sockaddr_bind, &sockaddr_bind_len)) {
     390         [ +  - ]:        1550 :         addr_bind.SetSockAddr((const struct sockaddr*)&sockaddr_bind, sockaddr_bind_len);
     391                 :             :     } else {
     392   [ #  #  #  #  :           0 :         LogPrintLevel(BCLog::NET, BCLog::Level::Warning, "getsockname failed\n");
                   #  # ]
     393                 :             :     }
     394                 :        1550 :     return addr_bind;
     395                 :           0 : }
     396                 :             : 
     397                 :         619 : CNode* CConnman::ConnectNode(CAddress addrConnect, const char *pszDest, bool fCountFailure, ConnectionType conn_type, bool use_v2transport)
     398                 :             : {
     399                 :         619 :     AssertLockNotHeld(m_unused_i2p_sessions_mutex);
     400         [ -  + ]:         619 :     assert(conn_type != ConnectionType::INBOUND);
     401                 :             : 
     402         [ +  + ]:         619 :     if (pszDest == nullptr) {
     403         [ +  - ]:           3 :         if (IsLocal(addrConnect))
     404                 :             :             return nullptr;
     405                 :             : 
     406                 :             :         // Look for an existing connection
     407         [ +  - ]:           3 :         CNode* pnode = FindNode(static_cast<CService>(addrConnect));
     408         [ -  + ]:           3 :         if (pnode)
     409                 :             :         {
     410                 :           0 :             LogPrintf("Failed to open new connection, already connected\n");
     411                 :           0 :             return nullptr;
     412                 :             :         }
     413                 :             :     }
     414                 :             : 
     415   [ +  -  +  +  :        1763 :     LogPrintLevel(BCLog::NET, BCLog::Level::Debug, "trying %s connection %s lastseen=%.1fhrs\n",
          +  +  +  +  +  
                      - ]
     416                 :             :         use_v2transport ? "v2" : "v1",
     417                 :             :         pszDest ? pszDest : addrConnect.ToStringAddrPort(),
     418                 :             :         Ticks<HoursDouble>(pszDest ? 0h : Now<NodeSeconds>() - addrConnect.nTime));
     419                 :             : 
     420                 :             :     // Resolve
     421   [ +  +  +  - ]:        1235 :     const uint16_t default_port{pszDest != nullptr ? GetDefaultPort(pszDest) :
     422                 :         619 :                                                      m_params.GetDefaultPort()};
     423                 :             : 
     424                 :             :     // Collection of addresses to try to connect to: either all dns resolved addresses if a domain name (pszDest) is provided, or addrConnect otherwise.
     425                 :         619 :     std::vector<CAddress> connect_to{};
     426         [ +  + ]:         619 :     if (pszDest) {
     427   [ +  -  +  -  :        1280 :         std::vector<CService> resolved{Lookup(pszDest, default_port, fNameLookup && !HaveNameProxy(), 256)};
          +  -  +  +  +  
                -  +  - ]
     428         [ +  + ]:         616 :         if (!resolved.empty()) {
     429                 :         603 :             std::shuffle(resolved.begin(), resolved.end(), FastRandomContext());
     430                 :             :             // If the connection is made by name, it can be the case that the name resolves to more than one address.
     431                 :             :             // We don't want to connect any more of them if we are already connected to one
     432         [ +  + ]:        1194 :             for (const auto& r : resolved) {
     433         [ +  - ]:         603 :                 addrConnect = CAddress{MaybeFlipIPv6toCJDNS(r), NODE_NONE};
     434   [ +  -  +  + ]:         603 :                 if (!addrConnect.IsValid()) {
     435   [ +  -  +  -  :           4 :                     LogDebug(BCLog::NET, "Resolver returned invalid address %s for %s\n", addrConnect.ToStringAddrPort(), pszDest);
             +  -  +  - ]
     436                 :           2 :                     return nullptr;
     437                 :             :                 }
     438                 :             :                 // It is possible that we already have a connection to the IP/port pszDest resolved to.
     439                 :             :                 // In that case, drop the connection that was just created.
     440         [ +  - ]:         601 :                 LOCK(m_nodes_mutex);
     441         [ +  - ]:         601 :                 CNode* pnode = FindNode(static_cast<CService>(addrConnect));
     442         [ +  + ]:         601 :                 if (pnode) {
     443   [ +  -  +  - ]:          10 :                     LogPrintf("Not opening a connection to %s, already connected to %s\n", pszDest, addrConnect.ToStringAddrPort());
     444         [ +  - ]:          10 :                     return nullptr;
     445                 :             :                 }
     446                 :             :                 // Add the address to the resolved addresses vector so we can try to connect to it later on
     447         [ +  - ]:         591 :                 connect_to.push_back(addrConnect);
     448                 :         601 :             }
     449                 :             :         } else {
     450                 :             :             // For resolution via proxy
     451         [ +  - ]:          13 :             connect_to.push_back(addrConnect);
     452                 :             :         }
     453                 :         616 :     } else {
     454                 :             :         // Connect via addrConnect directly
     455         [ +  - ]:           3 :         connect_to.push_back(addrConnect);
     456                 :             :     }
     457                 :             : 
     458                 :             :     // Connect
     459                 :         607 :     std::unique_ptr<Sock> sock;
     460         [ +  - ]:         607 :     Proxy proxy;
     461         [ +  - ]:         607 :     CService addr_bind;
     462   [ +  -  -  + ]:         607 :     assert(!addr_bind.IsValid());
     463                 :         607 :     std::unique_ptr<i2p::sam::Session> i2p_transient_session;
     464                 :             : 
     465         [ +  + ]:         626 :     for (auto& target_addr: connect_to) {
     466   [ +  -  +  + ]:         607 :         if (target_addr.IsValid()) {
     467   [ +  -  +  - ]:         594 :             const bool use_proxy{GetProxy(target_addr.GetNetwork(), proxy)};
     468                 :         594 :             bool proxyConnectionFailed = false;
     469                 :             : 
     470   [ +  +  -  + ]:         594 :             if (target_addr.IsI2P() && use_proxy) {
     471         [ +  - ]:           4 :                 i2p::Connection conn;
     472                 :           4 :                 bool connected{false};
     473                 :             : 
     474         [ +  + ]:           4 :                 if (m_i2p_sam_session) {
     475         [ +  - ]:           3 :                     connected = m_i2p_sam_session->Connect(target_addr, conn, proxyConnectionFailed);
     476                 :             :                 } else {
     477                 :           1 :                     {
     478         [ +  - ]:           1 :                         LOCK(m_unused_i2p_sessions_mutex);
     479         [ +  - ]:           1 :                         if (m_unused_i2p_sessions.empty()) {
     480                 :           1 :                             i2p_transient_session =
     481         [ +  - ]:           2 :                                 std::make_unique<i2p::sam::Session>(proxy, &interruptNet);
     482                 :             :                         } else {
     483                 :           0 :                             i2p_transient_session.swap(m_unused_i2p_sessions.front());
     484                 :           0 :                             m_unused_i2p_sessions.pop();
     485                 :             :                         }
     486                 :           0 :                     }
     487         [ +  - ]:           1 :                     connected = i2p_transient_session->Connect(target_addr, conn, proxyConnectionFailed);
     488         [ +  - ]:           1 :                     if (!connected) {
     489         [ +  - ]:           1 :                         LOCK(m_unused_i2p_sessions_mutex);
     490         [ +  - ]:           1 :                         if (m_unused_i2p_sessions.size() < MAX_UNUSED_I2P_SESSIONS_SIZE) {
     491   [ +  -  +  - ]:           1 :                             m_unused_i2p_sessions.emplace(i2p_transient_session.release());
     492                 :             :                         }
     493                 :           1 :                     }
     494                 :             :                 }
     495                 :             : 
     496         [ -  + ]:           4 :                 if (connected) {
     497                 :           0 :                     sock = std::move(conn.sock);
     498                 :           0 :                     addr_bind = conn.me;
     499                 :             :                 }
     500         [ +  + ]:         594 :             } else if (use_proxy) {
     501   [ +  -  +  -  :          38 :                 LogPrintLevel(BCLog::PROXY, BCLog::Level::Debug, "Using proxy: %s to connect to %s\n", proxy.ToString(), target_addr.ToStringAddrPort());
          +  -  +  -  +  
                      - ]
     502   [ +  -  +  -  :          38 :                 sock = ConnectThroughProxy(proxy, target_addr.ToStringAddr(), target_addr.GetPort(), proxyConnectionFailed);
                   +  - ]
     503                 :             :             } else {
     504                 :             :                 // no proxy needed (none set for target network)
     505         [ +  - ]:        1142 :                 sock = ConnectDirectly(target_addr, conn_type == ConnectionType::MANUAL);
     506                 :             :             }
     507         [ +  + ]:         594 :             if (!proxyConnectionFailed) {
     508                 :             :                 // If a connection to the node was attempted, and failure (if any) is not caused by a problem connecting to
     509                 :             :                 // the proxy, mark this as an attempt.
     510         [ +  - ]:         585 :                 addrman.Attempt(target_addr, fCountFailure);
     511                 :             :             }
     512   [ +  -  +  -  :          13 :         } else if (pszDest && GetNameProxy(proxy)) {
                   +  - ]
     513         [ +  - ]:          13 :             std::string host;
     514                 :          13 :             uint16_t port{default_port};
     515   [ +  -  +  - ]:          13 :             SplitHostPort(std::string(pszDest), port, host);
     516                 :          13 :             bool proxyConnectionFailed;
     517         [ +  - ]:          26 :             sock = ConnectThroughProxy(proxy, host, port, proxyConnectionFailed);
     518                 :          13 :         }
     519                 :             :         // Check any other resolved address (if any) if we fail to connect
     520         [ +  + ]:         607 :         if (!sock) {
     521                 :          19 :             continue;
     522                 :             :         }
     523                 :             : 
     524                 :         588 :         NetPermissionFlags permission_flags = NetPermissionFlags::None;
     525   [ +  +  +  - ]:         588 :         std::vector<NetWhitelistPermissions> whitelist_permissions = conn_type == ConnectionType::MANUAL ? vWhitelistedRangeOutgoing : std::vector<NetWhitelistPermissions>{};
     526         [ +  - ]:         588 :         AddWhitelistPermissionFlags(permission_flags, target_addr, whitelist_permissions);
     527                 :             : 
     528                 :             :         // Add node
     529         [ +  - ]:         588 :         NodeId id = GetNewNodeId();
     530   [ +  -  +  -  :         588 :         uint64_t nonce = GetDeterministicRandomizer(RANDOMIZER_ID_LOCALHOSTNONCE).Write(id).Finalize();
                   +  - ]
     531   [ +  -  +  - ]:         588 :         if (!addr_bind.IsValid()) {
     532         [ +  - ]:        1176 :             addr_bind = GetBindAddress(*sock);
     533                 :             :         }
     534                 :         588 :         CNode* pnode = new CNode(id,
     535                 :             :                                 std::move(sock),
     536                 :             :                                 target_addr,
     537                 :             :                                 CalculateKeyedNetGroup(target_addr),
     538                 :             :                                 nonce,
     539                 :             :                                 addr_bind,
     540                 :         588 :                                 pszDest ? pszDest : "",
     541                 :             :                                 conn_type,
     542                 :             :                                 /*inbound_onion=*/false,
     543         [ +  - ]:         588 :                                 CNodeOptions{
     544                 :             :                                     .permission_flags = permission_flags,
     545                 :             :                                     .i2p_sam_session = std::move(i2p_transient_session),
     546         [ +  - ]:         588 :                                     .recv_flood_size = nReceiveFloodSize,
     547                 :             :                                     .use_v2transport = use_v2transport,
     548   [ +  -  +  -  :        1764 :                                 });
          +  -  +  -  +  
             -  +  -  +  
                      - ]
     549                 :         588 :         pnode->AddRef();
     550                 :             : 
     551                 :             :         // We're making a new connection, harvest entropy from the time (and our peer count)
     552                 :         588 :         RandAddEvent((uint32_t)id);
     553                 :             : 
     554                 :         588 :         return pnode;
     555                 :         588 :     }
     556                 :             : 
     557                 :             :     return nullptr;
     558                 :        1226 : }
     559                 :             : 
     560                 :        2016 : void CNode::CloseSocketDisconnect()
     561                 :             : {
     562                 :        2016 :     fDisconnect = true;
     563                 :        2016 :     LOCK(m_sock_mutex);
     564         [ +  + ]:        2016 :     if (m_sock) {
     565   [ +  -  +  -  :        3094 :         LogDebug(BCLog::NET, "Resetting socket for peer=%d%s", GetId(), LogIP(fLogIPs));
             +  -  +  - ]
     566                 :        1547 :         m_sock.reset();
     567                 :             : 
     568                 :             :         TRACEPOINT(net, closed_connection,
     569                 :             :             GetId(),
     570                 :             :             m_addr_name.c_str(),
     571                 :             :             ConnectionTypeAsString().c_str(),
     572                 :             :             ConnectedThroughNetwork(),
     573                 :        1547 :             Ticks<std::chrono::seconds>(m_connected));
     574                 :             :     }
     575   [ -  +  +  - ]:        2016 :     m_i2p_sam_session.reset();
     576                 :        2016 : }
     577                 :             : 
     578                 :        1550 : void CConnman::AddWhitelistPermissionFlags(NetPermissionFlags& flags, const CNetAddr &addr, const std::vector<NetWhitelistPermissions>& ranges) const {
     579         [ +  + ]:        1836 :     for (const auto& subnet : ranges) {
     580         [ +  - ]:         286 :         if (subnet.m_subnet.Match(addr)) {
     581                 :         286 :             NetPermissions::AddFlag(flags, subnet.m_flags);
     582                 :             :         }
     583                 :             :     }
     584         [ +  + ]:        1550 :     if (NetPermissions::HasFlag(flags, NetPermissionFlags::Implicit)) {
     585         [ +  + ]:           5 :         NetPermissions::ClearFlag(flags, NetPermissionFlags::Implicit);
     586         [ +  + ]:           5 :         if (whitelist_forcerelay) NetPermissions::AddFlag(flags, NetPermissionFlags::ForceRelay);
     587         [ +  + ]:           5 :         if (whitelist_relay) NetPermissions::AddFlag(flags, NetPermissionFlags::Relay);
     588                 :           5 :         NetPermissions::AddFlag(flags, NetPermissionFlags::Mempool);
     589                 :           5 :         NetPermissions::AddFlag(flags, NetPermissionFlags::NoBan);
     590                 :             :     }
     591                 :        1550 : }
     592                 :             : 
     593                 :       12053 : CService CNode::GetAddrLocal() const
     594                 :             : {
     595                 :       12053 :     AssertLockNotHeld(m_addr_local_mutex);
     596                 :       12053 :     LOCK(m_addr_local_mutex);
     597         [ +  - ]:       12053 :     return m_addr_local;
     598                 :       12053 : }
     599                 :             : 
     600                 :        1485 : void CNode::SetAddrLocal(const CService& addrLocalIn) {
     601                 :        1485 :     AssertLockNotHeld(m_addr_local_mutex);
     602                 :        1485 :     LOCK(m_addr_local_mutex);
     603   [ +  -  +  - ]:        1485 :     if (Assume(!m_addr_local.IsValid())) { // Addr local can only be set once during version msg processing
     604                 :        1485 :         m_addr_local = addrLocalIn;
     605                 :             :     }
     606                 :        1485 : }
     607                 :             : 
     608                 :       11503 : Network CNode::ConnectedThroughNetwork() const
     609                 :             : {
     610         [ +  + ]:       11503 :     return m_inbound_onion ? NET_ONION : addr.GetNetClass();
     611                 :             : }
     612                 :             : 
     613                 :          33 : bool CNode::IsConnectedThroughPrivacyNet() const
     614                 :             : {
     615   [ +  -  +  + ]:          33 :     return m_inbound_onion || addr.IsPrivacyNet();
     616                 :             : }
     617                 :             : 
     618                 :             : #undef X
     619                 :             : #define X(name) stats.name = name
     620                 :       10515 : void CNode::CopyStats(CNodeStats& stats)
     621                 :             : {
     622                 :       10515 :     stats.nodeid = this->GetId();
     623                 :       10515 :     X(addr);
     624                 :       10515 :     X(addrBind);
     625                 :       10515 :     stats.m_network = ConnectedThroughNetwork();
     626                 :       10515 :     X(m_last_send);
     627                 :       10515 :     X(m_last_recv);
     628                 :       10515 :     X(m_last_tx_time);
     629                 :       10515 :     X(m_last_block_time);
     630                 :       10515 :     X(m_connected);
     631                 :       10515 :     X(m_addr_name);
     632                 :       10515 :     X(nVersion);
     633                 :       10515 :     {
     634                 :       10515 :         LOCK(m_subver_mutex);
     635   [ +  -  +  - ]:       21030 :         X(cleanSubVer);
     636                 :           0 :     }
     637                 :       10515 :     stats.fInbound = IsInboundConn();
     638                 :       10515 :     X(m_bip152_highbandwidth_to);
     639                 :       10515 :     X(m_bip152_highbandwidth_from);
     640                 :       10515 :     {
     641                 :       10515 :         LOCK(cs_vSend);
     642         [ +  - ]:       10515 :         X(mapSendBytesPerMsgType);
     643         [ +  - ]:       10515 :         X(nSendBytes);
     644                 :           0 :     }
     645                 :       10515 :     {
     646                 :       10515 :         LOCK(cs_vRecv);
     647         [ +  - ]:       10515 :         X(mapRecvBytesPerMsgType);
     648                 :       10515 :         X(nRecvBytes);
     649                 :       10515 :         Transport::Info info = m_transport->GetInfo();
     650                 :       10515 :         stats.m_transport_type = info.transport_type;
     651   [ +  +  +  - ]:       10515 :         if (info.session_id) stats.m_session_id = HexStr(*info.session_id);
     652                 :           0 :     }
     653                 :       10515 :     X(m_permission_flags);
     654                 :             : 
     655                 :       10515 :     X(m_last_ping_time);
     656                 :       10515 :     X(m_min_ping_time);
     657                 :             : 
     658                 :             :     // Leave string empty if addrLocal invalid (not filled in yet)
     659                 :       10515 :     CService addrLocalUnlocked = GetAddrLocal();
     660   [ +  -  +  +  :       10515 :     stats.addrLocal = addrLocalUnlocked.IsValid() ? addrLocalUnlocked.ToStringAddrPort() : "";
             +  -  +  - ]
     661                 :             : 
     662                 :       10515 :     X(m_conn_type);
     663                 :       10515 : }
     664                 :             : #undef X
     665                 :             : 
     666                 :      231158 : bool CNode::ReceiveMsgBytes(std::span<const uint8_t> msg_bytes, bool& complete)
     667                 :             : {
     668                 :      231158 :     complete = false;
     669                 :      231158 :     const auto time = GetTime<std::chrono::microseconds>();
     670                 :      231158 :     LOCK(cs_vRecv);
     671                 :      231158 :     m_last_recv = std::chrono::duration_cast<std::chrono::seconds>(time);
     672                 :      231158 :     nRecvBytes += msg_bytes.size();
     673         [ +  + ]:      874898 :     while (msg_bytes.size() > 0) {
     674                 :             :         // absorb network data
     675   [ +  -  +  + ]:      412592 :         if (!m_transport->ReceivedBytes(msg_bytes)) {
     676                 :             :             // Serious transport problem, disconnect from the peer.
     677                 :             :             return false;
     678                 :             :         }
     679                 :             : 
     680   [ +  -  +  + ]:      412582 :         if (m_transport->ReceivedMessageComplete()) {
     681                 :             :             // decompose a transport agnostic CNetMessage from the deserializer
     682                 :      163804 :             bool reject_message{false};
     683         [ +  - ]:      163804 :             CNetMessage msg = m_transport->GetReceivedMessage(time, reject_message);
     684         [ +  + ]:      163804 :             if (reject_message) {
     685                 :             :                 // Message deserialization failed. Drop the message but don't disconnect the peer.
     686                 :             :                 // store the size of the corrupt message
     687         [ +  - ]:          82 :                 mapRecvBytesPerMsgType.at(NET_MESSAGE_TYPE_OTHER) += msg.m_raw_message_size;
     688                 :          82 :                 continue;
     689                 :             :             }
     690                 :             : 
     691                 :             :             // Store received bytes per message type.
     692                 :             :             // To prevent a memory DOS, only allow known message types.
     693                 :      163722 :             auto i = mapRecvBytesPerMsgType.find(msg.m_type);
     694         [ +  + ]:      163722 :             if (i == mapRecvBytesPerMsgType.end()) {
     695                 :           6 :                 i = mapRecvBytesPerMsgType.find(NET_MESSAGE_TYPE_OTHER);
     696                 :             :             }
     697         [ -  + ]:      163722 :             assert(i != mapRecvBytesPerMsgType.end());
     698         [ +  - ]:      163722 :             i->second += msg.m_raw_message_size;
     699                 :             : 
     700                 :             :             // push the message to the process queue,
     701         [ +  - ]:      163722 :             vRecvMsg.push_back(std::move(msg));
     702                 :             : 
     703                 :      163722 :             complete = true;
     704                 :      163804 :         }
     705                 :             :     }
     706                 :             : 
     707                 :             :     return true;
     708                 :      231158 : }
     709                 :             : 
     710                 :        5923 : std::string CNode::LogIP(bool log_ip) const
     711                 :             : {
     712   [ +  +  +  -  :        5931 :     return log_ip ? strprintf(" peeraddr=%s", addr.ToStringAddrPort()) : "";
          +  -  +  -  -  
                      - ]
     713                 :             : }
     714                 :             : 
     715                 :        1426 : std::string CNode::DisconnectMsg(bool log_ip) const
     716                 :             : {
     717                 :        1426 :     return strprintf("disconnecting peer=%d%s",
     718         [ +  - ]:        1426 :                      GetId(),
     719         [ +  - ]:        2852 :                      LogIP(log_ip));
     720                 :             : }
     721                 :             : 
     722                 :        1662 : V1Transport::V1Transport(const NodeId node_id) noexcept
     723                 :        1662 :     : m_magic_bytes{Params().MessageStart()}, m_node_id{node_id}
     724                 :             : {
     725                 :        1662 :     LOCK(m_recv_mutex);
     726         [ +  - ]:        1662 :     Reset();
     727                 :        1662 : }
     728                 :             : 
     729                 :       10144 : Transport::Info V1Transport::GetInfo() const noexcept
     730                 :             : {
     731                 :       10144 :     return {.transport_type = TransportProtocolType::V1, .session_id = {}};
     732                 :             : }
     733                 :             : 
     734                 :      156016 : int V1Transport::readHeader(std::span<const uint8_t> msg_bytes)
     735                 :             : {
     736                 :      156016 :     AssertLockHeld(m_recv_mutex);
     737                 :             :     // copy data to temporary parsing buffer
     738                 :      156016 :     unsigned int nRemaining = CMessageHeader::HEADER_SIZE - nHdrPos;
     739         [ +  + ]:      156016 :     unsigned int nCopy = std::min<unsigned int>(nRemaining, msg_bytes.size());
     740                 :             : 
     741         [ +  + ]:      156016 :     memcpy(&hdrbuf[nHdrPos], msg_bytes.data(), nCopy);
     742                 :      156016 :     nHdrPos += nCopy;
     743                 :             : 
     744                 :             :     // if header incomplete, exit
     745         [ +  + ]:      156016 :     if (nHdrPos < CMessageHeader::HEADER_SIZE)
     746                 :          10 :         return nCopy;
     747                 :             : 
     748                 :             :     // deserialize to CMessageHeader
     749                 :      156006 :     try {
     750         [ +  - ]:      156006 :         hdrbuf >> hdr;
     751                 :             :     }
     752         [ -  - ]:           0 :     catch (const std::exception&) {
     753   [ -  -  -  -  :           0 :         LogDebug(BCLog::NET, "Header error: Unable to deserialize, peer=%d\n", m_node_id);
                   -  - ]
     754                 :           0 :         return -1;
     755                 :           0 :     }
     756                 :             : 
     757                 :             :     // Check start string, network magic
     758         [ +  + ]:      156006 :     if (hdr.pchMessageStart != m_magic_bytes) {
     759   [ +  -  +  - ]:           4 :         LogDebug(BCLog::NET, "Header error: Wrong MessageStart %s received, peer=%d\n", HexStr(hdr.pchMessageStart), m_node_id);
     760                 :           2 :         return -1;
     761                 :             :     }
     762                 :             : 
     763                 :             :     // reject messages larger than MAX_SIZE or MAX_PROTOCOL_MESSAGE_LENGTH
     764                 :             :     // NOTE: failing to perform this check previously allowed a malicious peer to make us allocate 32MiB of memory per
     765                 :             :     // connection. See https://bitcoincore.org/en/2024/07/03/disclose_receive_buffer_oom.
     766         [ +  + ]:      156004 :     if (hdr.nMessageSize > MAX_SIZE || hdr.nMessageSize > MAX_PROTOCOL_MESSAGE_LENGTH) {
     767   [ +  -  +  -  :           6 :         LogDebug(BCLog::NET, "Header error: Size too large (%s, %u bytes), peer=%d\n", SanitizeString(hdr.GetMessageType()), hdr.nMessageSize, m_node_id);
                   +  - ]
     768                 :           3 :         return -1;
     769                 :             :     }
     770                 :             : 
     771                 :             :     // switch state to reading message data
     772                 :      156001 :     in_data = true;
     773                 :             : 
     774                 :      156001 :     return nCopy;
     775                 :             : }
     776                 :             : 
     777                 :      248192 : int V1Transport::readData(std::span<const uint8_t> msg_bytes)
     778                 :             : {
     779                 :      248192 :     AssertLockHeld(m_recv_mutex);
     780                 :      248192 :     unsigned int nRemaining = hdr.nMessageSize - nDataPos;
     781         [ +  + ]:      248192 :     unsigned int nCopy = std::min<unsigned int>(nRemaining, msg_bytes.size());
     782                 :             : 
     783         [ +  + ]:      248192 :     if (vRecv.size() < nDataPos + nCopy) {
     784                 :             :         // Allocate up to 256 KiB ahead, but never more than the total message size.
     785         [ +  + ]:      317860 :         vRecv.resize(std::min(hdr.nMessageSize, nDataPos + nCopy + 256 * 1024));
     786                 :             :     }
     787                 :             : 
     788                 :      248192 :     hasher.Write(msg_bytes.first(nCopy));
     789                 :      248192 :     memcpy(&vRecv[nDataPos], msg_bytes.data(), nCopy);
     790                 :      248192 :     nDataPos += nCopy;
     791                 :             : 
     792                 :      248192 :     return nCopy;
     793                 :             : }
     794                 :             : 
     795                 :      156000 : const uint256& V1Transport::GetMessageHash() const
     796                 :             : {
     797                 :      156000 :     AssertLockHeld(m_recv_mutex);
     798   [ +  -  -  + ]:      156000 :     assert(CompleteInternal());
     799         [ +  - ]:      156000 :     if (data_hash.IsNull())
     800                 :      156000 :         hasher.Finalize(data_hash);
     801                 :      156000 :     return data_hash;
     802                 :             : }
     803                 :             : 
     804                 :      156000 : CNetMessage V1Transport::GetReceivedMessage(const std::chrono::microseconds time, bool& reject_message)
     805                 :             : {
     806                 :      156000 :     AssertLockNotHeld(m_recv_mutex);
     807                 :             :     // Initialize out parameter
     808                 :      156000 :     reject_message = false;
     809                 :             :     // decompose a single CNetMessage from the TransportDeserializer
     810                 :      156000 :     LOCK(m_recv_mutex);
     811         [ +  - ]:      156000 :     CNetMessage msg(std::move(vRecv));
     812                 :             : 
     813                 :             :     // store message type string, time, and sizes
     814         [ +  - ]:      156000 :     msg.m_type = hdr.GetMessageType();
     815                 :      156000 :     msg.m_time = time;
     816                 :      156000 :     msg.m_message_size = hdr.nMessageSize;
     817                 :      156000 :     msg.m_raw_message_size = hdr.nMessageSize + CMessageHeader::HEADER_SIZE;
     818                 :             : 
     819         [ +  - ]:      156000 :     uint256 hash = GetMessageHash();
     820                 :             : 
     821                 :             :     // We just received a message off the wire, harvest entropy from the time (and the message checksum)
     822                 :      156000 :     RandAddEvent(ReadLE32(hash.begin()));
     823                 :             : 
     824                 :             :     // Check checksum and header message type string
     825         [ +  + ]:      156000 :     if (memcmp(hash.begin(), hdr.pchChecksum, CMessageHeader::CHECKSUM_SIZE) != 0) {
     826   [ +  -  +  -  :           2 :         LogDebug(BCLog::NET, "Header error: Wrong checksum (%s, %u bytes), expected %s was %s, peer=%d\n",
          +  -  +  -  +  
                -  +  - ]
     827                 :             :                  SanitizeString(msg.m_type), msg.m_message_size,
     828                 :             :                  HexStr(std::span{hash}.first(CMessageHeader::CHECKSUM_SIZE)),
     829                 :             :                  HexStr(hdr.pchChecksum),
     830                 :             :                  m_node_id);
     831                 :           1 :         reject_message = true;
     832   [ +  -  +  + ]:      155999 :     } else if (!hdr.IsMessageTypeValid()) {
     833   [ +  -  +  -  :         162 :         LogDebug(BCLog::NET, "Header error: Invalid message type (%s, %u bytes), peer=%d\n",
          +  -  +  -  +  
                      - ]
     834                 :             :                  SanitizeString(hdr.GetMessageType()), msg.m_message_size, m_node_id);
     835                 :          81 :         reject_message = true;
     836                 :             :     }
     837                 :             : 
     838                 :             :     // Always reset the network deserializer (prepare for the next message)
     839         [ +  - ]:      156000 :     Reset();
     840         [ +  - ]:      156000 :     return msg;
     841                 :      156000 : }
     842                 :             : 
     843                 :      161014 : bool V1Transport::SetMessageToSend(CSerializedNetMsg& msg) noexcept
     844                 :             : {
     845                 :      161014 :     AssertLockNotHeld(m_send_mutex);
     846                 :             :     // Determine whether a new message can be set.
     847                 :      161014 :     LOCK(m_send_mutex);
     848   [ +  -  +  + ]:      161014 :     if (m_sending_header || m_bytes_sent < m_message_to_send.data.size()) return false;
     849                 :             : 
     850                 :             :     // create dbl-sha256 checksum
     851                 :      160613 :     uint256 hash = Hash(msg.data);
     852                 :             : 
     853                 :             :     // create header
     854                 :      160613 :     CMessageHeader hdr(m_magic_bytes, msg.m_type.c_str(), msg.data.size());
     855         [ +  + ]:      160613 :     memcpy(hdr.pchChecksum, hash.begin(), CMessageHeader::CHECKSUM_SIZE);
     856                 :             : 
     857                 :             :     // serialize header
     858         [ +  + ]:      160613 :     m_header_to_send.clear();
     859                 :      160613 :     VectorWriter{m_header_to_send, 0, hdr};
     860                 :             : 
     861                 :             :     // update state
     862                 :      160613 :     m_message_to_send = std::move(msg);
     863                 :      160613 :     m_sending_header = true;
     864                 :      160613 :     m_bytes_sent = 0;
     865                 :      160613 :     return true;
     866                 :      161014 : }
     867                 :             : 
     868                 :     1239382 : Transport::BytesToSend V1Transport::GetBytesToSend(bool have_next_message) const noexcept
     869                 :             : {
     870                 :     1239382 :     AssertLockNotHeld(m_send_mutex);
     871                 :     1239382 :     LOCK(m_send_mutex);
     872         [ +  + ]:     1239382 :     if (m_sending_header) {
     873         [ +  + ]:      160634 :         return {std::span{m_header_to_send}.subspan(m_bytes_sent),
     874                 :             :                 // We have more to send after the header if the message has payload, or if there
     875                 :             :                 // is a next message after that.
     876   [ +  +  +  + ]:      160634 :                 have_next_message || !m_message_to_send.data.empty(),
     877                 :      160634 :                 m_message_to_send.m_type
     878                 :      160634 :                };
     879                 :             :     } else {
     880                 :     1078748 :         return {std::span{m_message_to_send.data}.subspan(m_bytes_sent),
     881                 :             :                 // We only have more to send after this message's payload if there is another
     882                 :             :                 // message.
     883                 :             :                 have_next_message,
     884                 :     1078748 :                 m_message_to_send.m_type
     885                 :     1078748 :                };
     886                 :             :     }
     887                 :     1239382 : }
     888                 :             : 
     889                 :      316584 : void V1Transport::MarkBytesSent(size_t bytes_sent) noexcept
     890                 :             : {
     891                 :      316584 :     AssertLockNotHeld(m_send_mutex);
     892                 :      316584 :     LOCK(m_send_mutex);
     893                 :      316584 :     m_bytes_sent += bytes_sent;
     894   [ +  +  +  - ]:      316584 :     if (m_sending_header && m_bytes_sent == m_header_to_send.size()) {
     895                 :             :         // We're done sending a message's header. Switch to sending its data bytes.
     896                 :      160610 :         m_sending_header = false;
     897                 :      160610 :         m_bytes_sent = 0;
     898   [ +  -  +  + ]:      155974 :     } else if (!m_sending_header && m_bytes_sent == m_message_to_send.data.size()) {
     899                 :             :         // We're done sending a message's data. Wipe the data vector to reduce memory consumption.
     900                 :      155538 :         ClearShrink(m_message_to_send.data);
     901                 :      155538 :         m_bytes_sent = 0;
     902                 :             :     }
     903                 :      316584 : }
     904                 :             : 
     905                 :      321272 : size_t V1Transport::GetSendMemoryUsage() const noexcept
     906                 :             : {
     907                 :      321272 :     AssertLockNotHeld(m_send_mutex);
     908                 :      321272 :     LOCK(m_send_mutex);
     909                 :             :     // Don't count sending-side fields besides m_message_to_send, as they're all small and bounded.
     910         [ +  - ]:      321272 :     return m_message_to_send.GetMemoryUsage();
     911                 :      321272 : }
     912                 :             : 
     913                 :             : namespace {
     914                 :             : 
     915                 :             : /** List of short messages as defined in BIP324, in order.
     916                 :             :  *
     917                 :             :  * Only message types that are actually implemented in this codebase need to be listed, as other
     918                 :             :  * messages get ignored anyway - whether we know how to decode them or not.
     919                 :             :  */
     920                 :             : const std::array<std::string, 33> V2_MESSAGE_IDS = {
     921                 :             :     "", // 12 bytes follow encoding the message type like in V1
     922                 :             :     NetMsgType::ADDR,
     923                 :             :     NetMsgType::BLOCK,
     924                 :             :     NetMsgType::BLOCKTXN,
     925                 :             :     NetMsgType::CMPCTBLOCK,
     926                 :             :     NetMsgType::FEEFILTER,
     927                 :             :     NetMsgType::FILTERADD,
     928                 :             :     NetMsgType::FILTERCLEAR,
     929                 :             :     NetMsgType::FILTERLOAD,
     930                 :             :     NetMsgType::GETBLOCKS,
     931                 :             :     NetMsgType::GETBLOCKTXN,
     932                 :             :     NetMsgType::GETDATA,
     933                 :             :     NetMsgType::GETHEADERS,
     934                 :             :     NetMsgType::HEADERS,
     935                 :             :     NetMsgType::INV,
     936                 :             :     NetMsgType::MEMPOOL,
     937                 :             :     NetMsgType::MERKLEBLOCK,
     938                 :             :     NetMsgType::NOTFOUND,
     939                 :             :     NetMsgType::PING,
     940                 :             :     NetMsgType::PONG,
     941                 :             :     NetMsgType::SENDCMPCT,
     942                 :             :     NetMsgType::TX,
     943                 :             :     NetMsgType::GETCFILTERS,
     944                 :             :     NetMsgType::CFILTER,
     945                 :             :     NetMsgType::GETCFHEADERS,
     946                 :             :     NetMsgType::CFHEADERS,
     947                 :             :     NetMsgType::GETCFCHECKPT,
     948                 :             :     NetMsgType::CFCHECKPT,
     949                 :             :     NetMsgType::ADDRV2,
     950                 :             :     // Unimplemented message types that are assigned in BIP324:
     951                 :             :     "",
     952                 :             :     "",
     953                 :             :     "",
     954                 :             :     ""
     955                 :             : };
     956                 :             : 
     957                 :             : class V2MessageMap
     958                 :             : {
     959                 :             :     std::unordered_map<std::string, uint8_t> m_map;
     960                 :             : 
     961                 :             : public:
     962                 :        1234 :     V2MessageMap() noexcept
     963                 :        1234 :     {
     964         [ +  + ]:       40722 :         for (size_t i = 1; i < std::size(V2_MESSAGE_IDS); ++i) {
     965                 :       39488 :             m_map.emplace(V2_MESSAGE_IDS[i], i);
     966                 :             :         }
     967                 :        1234 :     }
     968                 :             : 
     969                 :        8593 :     std::optional<uint8_t> operator()(const std::string& message_name) const noexcept
     970                 :             :     {
     971                 :        8593 :         auto it = m_map.find(message_name);
     972         [ +  + ]:        8593 :         if (it == m_map.end()) return std::nullopt;
     973                 :        7698 :         return it->second;
     974                 :             :     }
     975                 :             : };
     976                 :             : 
     977                 :             : const V2MessageMap V2_MESSAGE_MAP;
     978                 :             : 
     979                 :         275 : std::vector<uint8_t> GenerateRandomGarbage() noexcept
     980                 :             : {
     981                 :         275 :     std::vector<uint8_t> ret;
     982                 :         275 :     FastRandomContext rng;
     983                 :         550 :     ret.resize(rng.randrange(V2Transport::MAX_GARBAGE_LEN + 1));
     984                 :         275 :     rng.fillrand(MakeWritableByteSpan(ret));
     985                 :         275 :     return ret;
     986                 :         275 : }
     987                 :             : 
     988                 :             : } // namespace
     989                 :             : 
     990                 :         269 : void V2Transport::StartSendingHandshake() noexcept
     991                 :             : {
     992                 :         269 :     AssertLockHeld(m_send_mutex);
     993                 :         269 :     Assume(m_send_state == SendState::AWAITING_KEY);
     994                 :         269 :     Assume(m_send_buffer.empty());
     995                 :             :     // Initialize the send buffer with ellswift pubkey + provided garbage.
     996                 :         269 :     m_send_buffer.resize(EllSwiftPubKey::size() + m_send_garbage.size());
     997                 :         269 :     std::copy(std::begin(m_cipher.GetOurPubKey()), std::end(m_cipher.GetOurPubKey()), MakeWritableByteSpan(m_send_buffer).begin());
     998                 :         269 :     std::copy(m_send_garbage.begin(), m_send_garbage.end(), m_send_buffer.begin() + EllSwiftPubKey::size());
     999                 :             :     // We cannot wipe m_send_garbage as it will still be used as AAD later in the handshake.
    1000                 :         269 : }
    1001                 :             : 
    1002                 :         275 : V2Transport::V2Transport(NodeId nodeid, bool initiating, const CKey& key, std::span<const std::byte> ent32, std::vector<uint8_t> garbage) noexcept
    1003                 :         275 :     : m_cipher{key, ent32}, m_initiating{initiating}, m_nodeid{nodeid},
    1004                 :         275 :       m_v1_fallback{nodeid},
    1005         [ +  + ]:         275 :       m_recv_state{initiating ? RecvState::KEY : RecvState::KEY_MAYBE_V1},
    1006         [ +  + ]:         275 :       m_send_garbage{std::move(garbage)},
    1007   [ +  +  +  + ]:         700 :       m_send_state{initiating ? SendState::AWAITING_KEY : SendState::MAYBE_V1}
    1008                 :             : {
    1009         [ +  + ]:         275 :     Assume(m_send_garbage.size() <= MAX_GARBAGE_LEN);
    1010                 :             :     // Start sending immediately if we're the initiator of the connection.
    1011         [ +  + ]:         275 :     if (initiating) {
    1012                 :         125 :         LOCK(m_send_mutex);
    1013         [ +  - ]:         125 :         StartSendingHandshake();
    1014                 :         125 :     }
    1015                 :         275 : }
    1016                 :             : 
    1017                 :         275 : V2Transport::V2Transport(NodeId nodeid, bool initiating) noexcept
    1018                 :         550 :     : V2Transport{nodeid, initiating, GenerateRandomKey(),
    1019                 :         550 :                   MakeByteSpan(GetRandHash()), GenerateRandomGarbage()} {}
    1020                 :             : 
    1021                 :       17040 : void V2Transport::SetReceiveState(RecvState recv_state) noexcept
    1022                 :             : {
    1023                 :       17040 :     AssertLockHeld(m_recv_mutex);
    1024                 :             :     // Enforce allowed state transitions.
    1025                 :       17040 :     switch (m_recv_state) {
    1026                 :             :     case RecvState::KEY_MAYBE_V1:
    1027                 :             :         Assume(recv_state == RecvState::KEY || recv_state == RecvState::V1);
    1028                 :             :         break;
    1029                 :             :     case RecvState::KEY:
    1030                 :             :         Assume(recv_state == RecvState::GARB_GARBTERM);
    1031                 :             :         break;
    1032                 :             :     case RecvState::GARB_GARBTERM:
    1033                 :             :         Assume(recv_state == RecvState::VERSION);
    1034                 :             :         break;
    1035                 :             :     case RecvState::VERSION:
    1036                 :             :         Assume(recv_state == RecvState::APP);
    1037                 :             :         break;
    1038                 :             :     case RecvState::APP:
    1039                 :             :         Assume(recv_state == RecvState::APP_READY);
    1040                 :             :         break;
    1041                 :             :     case RecvState::APP_READY:
    1042                 :             :         Assume(recv_state == RecvState::APP);
    1043                 :             :         break;
    1044                 :       17040 :     case RecvState::V1:
    1045                 :       17040 :         Assume(false); // V1 state cannot be left
    1046                 :       17040 :         break;
    1047                 :             :     }
    1048                 :             :     // Change state.
    1049                 :       17040 :     m_recv_state = recv_state;
    1050                 :       17040 : }
    1051                 :             : 
    1052                 :         414 : void V2Transport::SetSendState(SendState send_state) noexcept
    1053                 :             : {
    1054                 :         414 :     AssertLockHeld(m_send_mutex);
    1055                 :             :     // Enforce allowed state transitions.
    1056                 :         414 :     switch (m_send_state) {
    1057                 :             :     case SendState::MAYBE_V1:
    1058                 :             :         Assume(send_state == SendState::V1 || send_state == SendState::AWAITING_KEY);
    1059                 :             :         break;
    1060                 :             :     case SendState::AWAITING_KEY:
    1061                 :             :         Assume(send_state == SendState::READY);
    1062                 :             :         break;
    1063                 :         414 :     case SendState::READY:
    1064                 :         414 :     case SendState::V1:
    1065                 :         414 :         Assume(false); // Final states
    1066                 :         414 :         break;
    1067                 :             :     }
    1068                 :             :     // Change state.
    1069                 :         414 :     m_send_state = send_state;
    1070                 :         414 : }
    1071                 :             : 
    1072                 :       11717 : bool V2Transport::ReceivedMessageComplete() const noexcept
    1073                 :             : {
    1074                 :       11717 :     AssertLockNotHeld(m_recv_mutex);
    1075                 :       11717 :     LOCK(m_recv_mutex);
    1076         [ +  + ]:       11717 :     if (m_recv_state == RecvState::V1) return m_v1_fallback.ReceivedMessageComplete();
    1077                 :             : 
    1078                 :       11298 :     return m_recv_state == RecvState::APP_READY;
    1079                 :       11717 : }
    1080                 :             : 
    1081                 :         152 : void V2Transport::ProcessReceivedMaybeV1Bytes() noexcept
    1082                 :             : {
    1083                 :         152 :     AssertLockHeld(m_recv_mutex);
    1084                 :         152 :     AssertLockNotHeld(m_send_mutex);
    1085                 :         152 :     Assume(m_recv_state == RecvState::KEY_MAYBE_V1);
    1086                 :             :     // We still have to determine if this is a v1 or v2 connection. The bytes being received could
    1087                 :             :     // be the beginning of either a v1 packet (network magic + "version\x00\x00\x00\x00\x00"), or
    1088                 :             :     // of a v2 public key. BIP324 specifies that a mismatch with this 16-byte string should trigger
    1089                 :             :     // sending of the key.
    1090                 :         152 :     std::array<uint8_t, V1_PREFIX_LEN> v1_prefix = {0, 0, 0, 0, 'v', 'e', 'r', 's', 'i', 'o', 'n', 0, 0, 0, 0, 0};
    1091                 :         152 :     std::copy(std::begin(Params().MessageStart()), std::end(Params().MessageStart()), v1_prefix.begin());
    1092                 :         152 :     Assume(m_recv_buffer.size() <= v1_prefix.size());
    1093         [ +  + ]:         152 :     if (!std::equal(m_recv_buffer.begin(), m_recv_buffer.end(), v1_prefix.begin())) {
    1094                 :             :         // Mismatch with v1 prefix, so we can assume a v2 connection.
    1095                 :         144 :         SetReceiveState(RecvState::KEY); // Convert to KEY state, leaving received bytes around.
    1096                 :             :         // Transition the sender to AWAITING_KEY state and start sending.
    1097                 :         144 :         LOCK(m_send_mutex);
    1098                 :         144 :         SetSendState(SendState::AWAITING_KEY);
    1099         [ +  - ]:         144 :         StartSendingHandshake();
    1100         [ +  + ]:         152 :     } else if (m_recv_buffer.size() == v1_prefix.size()) {
    1101                 :             :         // Full match with the v1 prefix, so fall back to v1 behavior.
    1102                 :           6 :         LOCK(m_send_mutex);
    1103                 :           6 :         std::span<const uint8_t> feedback{m_recv_buffer};
    1104                 :             :         // Feed already received bytes to v1 transport. It should always accept these, because it's
    1105                 :             :         // less than the size of a v1 header, and these are the first bytes fed to m_v1_fallback.
    1106                 :           6 :         bool ret = m_v1_fallback.ReceivedBytes(feedback);
    1107                 :           6 :         Assume(feedback.empty());
    1108                 :           6 :         Assume(ret);
    1109                 :           6 :         SetReceiveState(RecvState::V1);
    1110                 :           6 :         SetSendState(SendState::V1);
    1111                 :             :         // Reset v2 transport buffers to save memory.
    1112                 :           6 :         ClearShrink(m_recv_buffer);
    1113         [ +  - ]:           6 :         ClearShrink(m_send_buffer);
    1114                 :           6 :     } else {
    1115                 :             :         // We have not received enough to distinguish v1 from v2 yet. Wait until more bytes come.
    1116                 :             :     }
    1117                 :         152 : }
    1118                 :             : 
    1119                 :         321 : bool V2Transport::ProcessReceivedKeyBytes() noexcept
    1120                 :             : {
    1121                 :         321 :     AssertLockHeld(m_recv_mutex);
    1122                 :         321 :     AssertLockNotHeld(m_send_mutex);
    1123                 :         321 :     Assume(m_recv_state == RecvState::KEY);
    1124                 :         321 :     Assume(m_recv_buffer.size() <= EllSwiftPubKey::size());
    1125                 :             : 
    1126                 :             :     // As a special exception, if bytes 4-16 of the key on a responder connection match the
    1127                 :             :     // corresponding bytes of a V1 version message, but bytes 0-4 don't match the network magic
    1128                 :             :     // (if they did, we'd have switched to V1 state already), assume this is a peer from
    1129                 :             :     // another network, and disconnect them. They will almost certainly disconnect us too when
    1130                 :             :     // they receive our uniformly random key and garbage, but detecting this case specially
    1131                 :             :     // means we can log it.
    1132                 :         321 :     static constexpr std::array<uint8_t, 12> MATCH = {'v', 'e', 'r', 's', 'i', 'o', 'n', 0, 0, 0, 0, 0};
    1133                 :         321 :     static constexpr size_t OFFSET = std::tuple_size_v<MessageStartChars>;
    1134   [ +  +  +  + ]:         321 :     if (!m_initiating && m_recv_buffer.size() >= OFFSET + MATCH.size()) {
    1135         [ +  + ]:         176 :         if (std::equal(MATCH.begin(), MATCH.end(), m_recv_buffer.begin() + OFFSET)) {
    1136         [ +  - ]:           2 :             LogDebug(BCLog::NET, "V2 transport error: V1 peer with wrong MessageStart %s\n",
    1137                 :             :                      HexStr(std::span(m_recv_buffer).first(OFFSET)));
    1138                 :           2 :             return false;
    1139                 :             :         }
    1140                 :             :     }
    1141                 :             : 
    1142         [ +  + ]:         319 :     if (m_recv_buffer.size() == EllSwiftPubKey::size()) {
    1143                 :             :         // Other side's key has been fully received, and can now be Diffie-Hellman combined with
    1144                 :             :         // our key to initialize the encryption ciphers.
    1145                 :             : 
    1146                 :             :         // Initialize the ciphers.
    1147                 :         264 :         EllSwiftPubKey ellswift(MakeByteSpan(m_recv_buffer));
    1148                 :         264 :         LOCK(m_send_mutex);
    1149                 :         264 :         m_cipher.Initialize(ellswift, m_initiating);
    1150                 :             : 
    1151                 :             :         // Switch receiver state to GARB_GARBTERM.
    1152                 :         264 :         SetReceiveState(RecvState::GARB_GARBTERM);
    1153         [ +  - ]:         264 :         m_recv_buffer.clear();
    1154                 :             : 
    1155                 :             :         // Switch sender state to READY.
    1156                 :         264 :         SetSendState(SendState::READY);
    1157                 :             : 
    1158                 :             :         // Append the garbage terminator to the send buffer.
    1159                 :         264 :         m_send_buffer.resize(m_send_buffer.size() + BIP324Cipher::GARBAGE_TERMINATOR_LEN);
    1160                 :         264 :         std::copy(m_cipher.GetSendGarbageTerminator().begin(),
    1161                 :         264 :                   m_cipher.GetSendGarbageTerminator().end(),
    1162                 :         264 :                   MakeWritableByteSpan(m_send_buffer).last(BIP324Cipher::GARBAGE_TERMINATOR_LEN).begin());
    1163                 :             : 
    1164                 :             :         // Construct version packet in the send buffer, with the sent garbage data as AAD.
    1165                 :         264 :         m_send_buffer.resize(m_send_buffer.size() + BIP324Cipher::EXPANSION + VERSION_CONTENTS.size());
    1166                 :         264 :         m_cipher.Encrypt(
    1167                 :             :             /*contents=*/VERSION_CONTENTS,
    1168                 :         264 :             /*aad=*/MakeByteSpan(m_send_garbage),
    1169                 :             :             /*ignore=*/false,
    1170                 :         264 :             /*output=*/MakeWritableByteSpan(m_send_buffer).last(BIP324Cipher::EXPANSION + VERSION_CONTENTS.size()));
    1171                 :             :         // We no longer need the garbage.
    1172         [ +  - ]:         264 :         ClearShrink(m_send_garbage);
    1173                 :         264 :     } else {
    1174                 :             :         // We still have to receive more key bytes.
    1175                 :             :     }
    1176                 :             :     return true;
    1177                 :             : }
    1178                 :             : 
    1179                 :      575437 : bool V2Transport::ProcessReceivedGarbageBytes() noexcept
    1180                 :             : {
    1181                 :      575437 :     AssertLockHeld(m_recv_mutex);
    1182                 :      575437 :     Assume(m_recv_state == RecvState::GARB_GARBTERM);
    1183                 :      575437 :     Assume(m_recv_buffer.size() <= MAX_GARBAGE_LEN + BIP324Cipher::GARBAGE_TERMINATOR_LEN);
    1184         [ +  + ]:      575437 :     if (m_recv_buffer.size() >= BIP324Cipher::GARBAGE_TERMINATOR_LEN) {
    1185         [ +  + ]:      571477 :         if (std::ranges::equal(MakeByteSpan(m_recv_buffer).last(BIP324Cipher::GARBAGE_TERMINATOR_LEN), m_cipher.GetReceiveGarbageTerminator())) {
    1186                 :             :             // Garbage terminator received. Store garbage to authenticate it as AAD later.
    1187                 :         258 :             m_recv_aad = std::move(m_recv_buffer);
    1188                 :         258 :             m_recv_aad.resize(m_recv_aad.size() - BIP324Cipher::GARBAGE_TERMINATOR_LEN);
    1189         [ -  + ]:         258 :             m_recv_buffer.clear();
    1190                 :         258 :             SetReceiveState(RecvState::VERSION);
    1191         [ +  + ]:      571219 :         } else if (m_recv_buffer.size() == MAX_GARBAGE_LEN + BIP324Cipher::GARBAGE_TERMINATOR_LEN) {
    1192                 :             :             // We've reached the maximum length for garbage + garbage terminator, and the
    1193                 :             :             // terminator still does not match. Abort.
    1194         [ +  - ]:           4 :             LogDebug(BCLog::NET, "V2 transport error: missing garbage terminator, peer=%d\n", m_nodeid);
    1195                 :           4 :             return false;
    1196                 :             :         } else {
    1197                 :             :             // We still need to receive more garbage and/or garbage terminator bytes.
    1198                 :             :         }
    1199                 :             :     } else {
    1200                 :             :         // We have less than GARBAGE_TERMINATOR_LEN (16) bytes, so we certainly need to receive
    1201                 :             :         // more first.
    1202                 :             :     }
    1203                 :             :     return true;
    1204                 :             : }
    1205                 :             : 
    1206                 :      113786 : bool V2Transport::ProcessReceivedPacketBytes() noexcept
    1207                 :             : {
    1208                 :      113786 :     AssertLockHeld(m_recv_mutex);
    1209                 :      113786 :     Assume(m_recv_state == RecvState::VERSION || m_recv_state == RecvState::APP);
    1210                 :             : 
    1211                 :             :     // The maximum permitted contents length for a packet, consisting of:
    1212                 :             :     // - 0x00 byte: indicating long message type encoding
    1213                 :             :     // - 12 bytes of message type
    1214                 :             :     // - payload
    1215                 :      113786 :     static constexpr size_t MAX_CONTENTS_LEN =
    1216                 :             :         1 + CMessageHeader::MESSAGE_TYPE_SIZE +
    1217                 :             :         std::min<size_t>(MAX_SIZE, MAX_PROTOCOL_MESSAGE_LENGTH);
    1218                 :             : 
    1219         [ +  + ]:      113786 :     if (m_recv_buffer.size() == BIP324Cipher::LENGTH_LEN) {
    1220                 :             :         // Length descriptor received.
    1221                 :       56160 :         m_recv_len = m_cipher.DecryptLength(MakeByteSpan(m_recv_buffer));
    1222         [ +  + ]:       56160 :         if (m_recv_len > MAX_CONTENTS_LEN) {
    1223         [ +  - ]:          10 :             LogDebug(BCLog::NET, "V2 transport error: packet too large (%u bytes), peer=%d\n", m_recv_len, m_nodeid);
    1224                 :          10 :             return false;
    1225                 :             :         }
    1226   [ +  +  +  + ]:       57626 :     } else if (m_recv_buffer.size() > BIP324Cipher::LENGTH_LEN && m_recv_buffer.size() == m_recv_len + BIP324Cipher::EXPANSION) {
    1227                 :             :         // Ciphertext received, decrypt it into m_recv_decode_buffer.
    1228                 :             :         // Note that it is impossible to reach this branch without hitting the branch above first,
    1229                 :             :         // as GetMaxBytesToProcess only allows up to LENGTH_LEN into the buffer before that point.
    1230                 :       56150 :         m_recv_decode_buffer.resize(m_recv_len);
    1231                 :       56150 :         bool ignore{false};
    1232                 :      112300 :         bool ret = m_cipher.Decrypt(
    1233                 :       56150 :             /*input=*/MakeByteSpan(m_recv_buffer).subspan(BIP324Cipher::LENGTH_LEN),
    1234                 :       56150 :             /*aad=*/MakeByteSpan(m_recv_aad),
    1235                 :             :             /*ignore=*/ignore,
    1236                 :             :             /*contents=*/MakeWritableByteSpan(m_recv_decode_buffer));
    1237         [ +  + ]:       56150 :         if (!ret) {
    1238         [ +  - ]:          12 :             LogDebug(BCLog::NET, "V2 transport error: packet decryption failure (%u bytes), peer=%d\n", m_recv_len, m_nodeid);
    1239                 :          12 :             return false;
    1240                 :             :         }
    1241                 :             :         // We have decrypted a valid packet with the AAD we expected, so clear the expected AAD.
    1242                 :       56138 :         ClearShrink(m_recv_aad);
    1243                 :             :         // Feed the last 4 bytes of the Poly1305 authentication tag (and its timing) into our RNG.
    1244                 :       56138 :         RandAddEvent(ReadLE32(m_recv_buffer.data() + m_recv_buffer.size() - 4));
    1245                 :             : 
    1246                 :             :         // At this point we have a valid packet decrypted into m_recv_decode_buffer. If it's not a
    1247                 :             :         // decoy, which we simply ignore, use the current state to decide what to do with it.
    1248         [ +  + ]:       56138 :         if (!ignore) {
    1249      [ +  +  - ]:        8312 :             switch (m_recv_state) {
    1250                 :         256 :             case RecvState::VERSION:
    1251                 :             :                 // Version message received; transition to application phase. The contents is
    1252                 :             :                 // ignored, but can be used for future extensions.
    1253                 :         256 :                 SetReceiveState(RecvState::APP);
    1254                 :         256 :                 break;
    1255                 :        8056 :             case RecvState::APP:
    1256                 :             :                 // Application message decrypted correctly. It can be extracted using GetMessage().
    1257                 :        8056 :                 SetReceiveState(RecvState::APP_READY);
    1258                 :        8056 :                 break;
    1259                 :             :             default:
    1260                 :             :                 // Any other state is invalid (this function should not have been called).
    1261                 :             :                 Assume(false);
    1262                 :             :             }
    1263                 :             :         }
    1264                 :             :         // Wipe the receive buffer where the next packet will be received into.
    1265                 :       56138 :         ClearShrink(m_recv_buffer);
    1266                 :             :         // In all but APP_READY state, we can wipe the decoded contents.
    1267         [ +  + ]:       56138 :         if (m_recv_state != RecvState::APP_READY) ClearShrink(m_recv_decode_buffer);
    1268                 :             :     } else {
    1269                 :             :         // We either have less than 3 bytes, so we don't know the packet's length yet, or more
    1270                 :             :         // than 3 bytes but less than the packet's full ciphertext. Wait until those arrive.
    1271                 :             :     }
    1272                 :             :     return true;
    1273                 :             : }
    1274                 :             : 
    1275                 :      691834 : size_t V2Transport::GetMaxBytesToProcess() noexcept
    1276                 :             : {
    1277                 :      691834 :     AssertLockHeld(m_recv_mutex);
    1278   [ +  +  +  +  :      691834 :     switch (m_recv_state) {
                -  -  + ]
    1279                 :         152 :     case RecvState::KEY_MAYBE_V1:
    1280                 :             :         // During the KEY_MAYBE_V1 state we do not allow more than the length of v1 prefix into the
    1281                 :             :         // receive buffer.
    1282                 :         152 :         Assume(m_recv_buffer.size() <= V1_PREFIX_LEN);
    1283                 :             :         // As long as we're not sure if this is a v1 or v2 connection, don't receive more than what
    1284                 :             :         // is strictly necessary to distinguish the two (16 bytes). If we permitted more than
    1285                 :             :         // the v1 header size (24 bytes), we may not be able to feed the already-received bytes
    1286                 :             :         // back into the m_v1_fallback V1 transport.
    1287                 :         152 :         return V1_PREFIX_LEN - m_recv_buffer.size();
    1288                 :         321 :     case RecvState::KEY:
    1289                 :             :         // During the KEY state, we only allow the 64-byte key into the receive buffer.
    1290                 :         321 :         Assume(m_recv_buffer.size() <= EllSwiftPubKey::size());
    1291                 :             :         // As long as we have not received the other side's public key, don't receive more than
    1292                 :             :         // that (64 bytes), as garbage follows, and locating the garbage terminator requires the
    1293                 :             :         // key exchange first.
    1294                 :         321 :         return EllSwiftPubKey::size() - m_recv_buffer.size();
    1295                 :             :     case RecvState::GARB_GARBTERM:
    1296                 :             :         // Process garbage bytes one by one (because terminator may appear anywhere).
    1297                 :             :         return 1;
    1298                 :      113786 :     case RecvState::VERSION:
    1299                 :      113786 :     case RecvState::APP:
    1300                 :             :         // These three states all involve decoding a packet. Process the length descriptor first,
    1301                 :             :         // so that we know where the current packet ends (and we don't process bytes from the next
    1302                 :             :         // packet or decoy yet). Then, process the ciphertext bytes of the current packet.
    1303         [ +  + ]:      113786 :         if (m_recv_buffer.size() < BIP324Cipher::LENGTH_LEN) {
    1304                 :       56172 :             return BIP324Cipher::LENGTH_LEN - m_recv_buffer.size();
    1305                 :             :         } else {
    1306                 :             :             // Note that BIP324Cipher::EXPANSION is the total difference between contents size
    1307                 :             :             // and encoded packet size, which includes the 3 bytes due to the packet length.
    1308                 :             :             // When transitioning from receiving the packet length to receiving its ciphertext,
    1309                 :             :             // the encrypted packet length is left in the receive buffer.
    1310                 :       57614 :             return BIP324Cipher::EXPANSION + m_recv_len - m_recv_buffer.size();
    1311                 :             :         }
    1312                 :        2138 :     case RecvState::APP_READY:
    1313                 :             :         // No bytes can be processed until GetMessage() is called.
    1314                 :        2138 :         return 0;
    1315                 :           0 :     case RecvState::V1:
    1316                 :             :         // Not allowed (must be dealt with by the caller).
    1317                 :           0 :         Assume(false);
    1318                 :           0 :         return 0;
    1319                 :             :     }
    1320                 :           0 :     Assume(false); // unreachable
    1321                 :           0 :     return 0;
    1322                 :             : }
    1323                 :             : 
    1324                 :       11035 : bool V2Transport::ReceivedBytes(std::span<const uint8_t>& msg_bytes) noexcept
    1325                 :             : {
    1326                 :       11035 :     AssertLockNotHeld(m_recv_mutex);
    1327                 :             :     /** How many bytes to allocate in the receive buffer at most above what is received so far. */
    1328                 :       11035 :     static constexpr size_t MAX_RESERVE_AHEAD = 256 * 1024;
    1329                 :             : 
    1330                 :       11035 :     LOCK(m_recv_mutex);
    1331         [ +  + ]:       11035 :     if (m_recv_state == RecvState::V1) return m_v1_fallback.ReceivedBytes(msg_bytes);
    1332                 :             : 
    1333                 :             :     // Process the provided bytes in msg_bytes in a loop. In each iteration a nonzero number of
    1334                 :             :     // bytes (decided by GetMaxBytesToProcess) are taken from the beginning om msg_bytes, and
    1335                 :             :     // appended to m_recv_buffer. Then, depending on the receiver state, one of the
    1336                 :             :     // ProcessReceived*Bytes functions is called to process the bytes in that buffer.
    1337         [ +  + ]:      700284 :     while (!msg_bytes.empty()) {
    1338                 :             :         // Decide how many bytes to copy from msg_bytes to m_recv_buffer.
    1339                 :      691834 :         size_t max_read = GetMaxBytesToProcess();
    1340                 :             : 
    1341                 :             :         // Reserve space in the buffer if there is not enough.
    1342   [ +  +  +  + ]:      700300 :         if (m_recv_buffer.size() + std::min(msg_bytes.size(), max_read) > m_recv_buffer.capacity()) {
    1343      [ +  +  - ]:      112664 :             switch (m_recv_state) {
    1344                 :         272 :             case RecvState::KEY_MAYBE_V1:
    1345                 :         272 :             case RecvState::KEY:
    1346                 :         272 :             case RecvState::GARB_GARBTERM:
    1347                 :             :                 // During the initial states (key/garbage), allocate once to fit the maximum (4111
    1348                 :             :                 // bytes).
    1349                 :         272 :                 m_recv_buffer.reserve(MAX_GARBAGE_LEN + BIP324Cipher::GARBAGE_TERMINATOR_LEN);
    1350                 :         272 :                 break;
    1351                 :      112392 :             case RecvState::VERSION:
    1352                 :      112392 :             case RecvState::APP: {
    1353                 :             :                 // During states where a packet is being received, as much as is expected but never
    1354                 :             :                 // more than MAX_RESERVE_AHEAD bytes in addition to what is received so far.
    1355                 :             :                 // This means attackers that want to cause us to waste allocated memory are limited
    1356                 :             :                 // to MAX_RESERVE_AHEAD above the largest allowed message contents size, and to
    1357                 :             :                 // MAX_RESERVE_AHEAD more than they've actually sent us.
    1358         [ +  + ]:      112392 :                 size_t alloc_add = std::min(max_read, msg_bytes.size() + MAX_RESERVE_AHEAD);
    1359                 :      112392 :                 m_recv_buffer.reserve(m_recv_buffer.size() + alloc_add);
    1360                 :      112392 :                 break;
    1361                 :             :             }
    1362                 :             :             case RecvState::APP_READY:
    1363                 :             :                 // The buffer is empty in this state.
    1364                 :             :                 Assume(m_recv_buffer.empty());
    1365                 :             :                 break;
    1366                 :             :             case RecvState::V1:
    1367                 :             :                 // Should have bailed out above.
    1368                 :             :                 Assume(false);
    1369                 :             :                 break;
    1370                 :             :             }
    1371                 :             :         }
    1372                 :             : 
    1373                 :             :         // Can't read more than provided input.
    1374         [ +  + ]:      691834 :         max_read = std::min(msg_bytes.size(), max_read);
    1375                 :             :         // Copy data to buffer.
    1376                 :      691834 :         m_recv_buffer.insert(m_recv_buffer.end(), UCharCast(msg_bytes.data()), UCharCast(msg_bytes.data() + max_read));
    1377   [ +  +  +  +  :      691834 :         msg_bytes = msg_bytes.subspan(max_read);
                   -  + ]
    1378                 :             : 
    1379                 :             :         // Process data in the buffer.
    1380   [ +  +  +  +  :      691834 :         switch (m_recv_state) {
                   -  + ]
    1381                 :         152 :         case RecvState::KEY_MAYBE_V1:
    1382                 :         152 :             ProcessReceivedMaybeV1Bytes();
    1383         [ +  + ]:         152 :             if (m_recv_state == RecvState::V1) return true;
    1384                 :             :             break;
    1385                 :             : 
    1386                 :         321 :         case RecvState::KEY:
    1387         [ +  + ]:         321 :             if (!ProcessReceivedKeyBytes()) return false;
    1388                 :             :             break;
    1389                 :             : 
    1390                 :      575437 :         case RecvState::GARB_GARBTERM:
    1391         [ +  + ]:      575437 :             if (!ProcessReceivedGarbageBytes()) return false;
    1392                 :             :             break;
    1393                 :             : 
    1394                 :      113786 :         case RecvState::VERSION:
    1395                 :      113786 :         case RecvState::APP:
    1396         [ +  + ]:      113786 :             if (!ProcessReceivedPacketBytes()) return false;
    1397                 :             :             break;
    1398                 :             : 
    1399                 :             :         case RecvState::APP_READY:
    1400                 :             :             return true;
    1401                 :             : 
    1402                 :             :         case RecvState::V1:
    1403                 :             :             // We should have bailed out before.
    1404                 :             :             Assume(false);
    1405                 :             :             break;
    1406                 :             :         }
    1407                 :             :         // Make sure we have made progress before continuing.
    1408                 :             :         Assume(max_read > 0);
    1409                 :             :     }
    1410                 :             : 
    1411                 :             :     return true;
    1412                 :       11035 : }
    1413                 :             : 
    1414                 :        8056 : std::optional<std::string> V2Transport::GetMessageType(std::span<const uint8_t>& contents) noexcept
    1415                 :             : {
    1416         [ -  + ]:        8056 :     if (contents.size() == 0) return std::nullopt; // Empty contents
    1417         [ +  + ]:        8056 :     uint8_t first_byte = contents[0];
    1418         [ +  + ]:        8056 :     contents = contents.subspan(1); // Strip first byte.
    1419                 :             : 
    1420         [ +  + ]:        8056 :     if (first_byte != 0) {
    1421                 :             :         // Short (1 byte) encoding.
    1422         [ +  + ]:        7101 :         if (first_byte < std::size(V2_MESSAGE_IDS)) {
    1423                 :             :             // Valid short message id.
    1424                 :        7100 :             return V2_MESSAGE_IDS[first_byte];
    1425                 :             :         } else {
    1426                 :             :             // Unknown short message id.
    1427                 :           1 :             return std::nullopt;
    1428                 :             :         }
    1429                 :             :     }
    1430                 :             : 
    1431         [ +  + ]:         955 :     if (contents.size() < CMessageHeader::MESSAGE_TYPE_SIZE) {
    1432                 :          10 :         return std::nullopt; // Long encoding needs 12 message type bytes.
    1433                 :             :     }
    1434                 :             : 
    1435                 :             :     size_t msg_type_len{0};
    1436   [ +  -  +  + ]:        8539 :     while (msg_type_len < CMessageHeader::MESSAGE_TYPE_SIZE && contents[msg_type_len] != 0) {
    1437                 :             :         // Verify that message type bytes before the first 0x00 are in range.
    1438   [ -  +  +  - ]:        7594 :         if (contents[msg_type_len] < ' ' || contents[msg_type_len] > 0x7F) {
    1439                 :           0 :             return {};
    1440                 :             :         }
    1441                 :        7594 :         ++msg_type_len;
    1442                 :             :     }
    1443                 :         945 :     std::string ret{reinterpret_cast<const char*>(contents.data()), msg_type_len};
    1444         [ +  + ]:        4591 :     while (msg_type_len < CMessageHeader::MESSAGE_TYPE_SIZE) {
    1445                 :             :         // Verify that message type bytes after the first 0x00 are also 0x00.
    1446         [ +  + ]:        3696 :         if (contents[msg_type_len] != 0) return {};
    1447                 :        3646 :         ++msg_type_len;
    1448                 :             :     }
    1449                 :             :     // Strip message type bytes of contents.
    1450                 :         895 :     contents = contents.subspan(CMessageHeader::MESSAGE_TYPE_SIZE);
    1451                 :         895 :     return ret;
    1452                 :         945 : }
    1453                 :             : 
    1454                 :        8270 : CNetMessage V2Transport::GetReceivedMessage(std::chrono::microseconds time, bool& reject_message) noexcept
    1455                 :             : {
    1456                 :        8270 :     AssertLockNotHeld(m_recv_mutex);
    1457                 :        8270 :     LOCK(m_recv_mutex);
    1458         [ +  + ]:        8270 :     if (m_recv_state == RecvState::V1) return m_v1_fallback.GetReceivedMessage(time, reject_message);
    1459                 :             : 
    1460                 :        8056 :     Assume(m_recv_state == RecvState::APP_READY);
    1461                 :        8056 :     std::span<const uint8_t> contents{m_recv_decode_buffer};
    1462                 :        8056 :     auto msg_type = GetMessageType(contents);
    1463                 :        8056 :     CNetMessage msg{DataStream{}};
    1464                 :             :     // Note that BIP324Cipher::EXPANSION also includes the length descriptor size.
    1465         [ +  + ]:        8056 :     msg.m_raw_message_size = m_recv_decode_buffer.size() + BIP324Cipher::EXPANSION;
    1466         [ +  + ]:        8056 :     if (msg_type) {
    1467                 :        7995 :         reject_message = false;
    1468                 :        7995 :         msg.m_type = std::move(*msg_type);
    1469                 :        7995 :         msg.m_time = time;
    1470                 :        7995 :         msg.m_message_size = contents.size();
    1471                 :        7995 :         msg.m_recv.resize(contents.size());
    1472                 :        7995 :         std::copy(contents.begin(), contents.end(), UCharCast(msg.m_recv.data()));
    1473                 :             :     } else {
    1474         [ +  - ]:          61 :         LogDebug(BCLog::NET, "V2 transport error: invalid message type (%u bytes contents), peer=%d\n", m_recv_decode_buffer.size(), m_nodeid);
    1475                 :          61 :         reject_message = true;
    1476                 :             :     }
    1477                 :        8056 :     ClearShrink(m_recv_decode_buffer);
    1478                 :        8056 :     SetReceiveState(RecvState::APP);
    1479                 :             : 
    1480                 :        8056 :     return msg;
    1481                 :        8056 : }
    1482                 :             : 
    1483                 :        9025 : bool V2Transport::SetMessageToSend(CSerializedNetMsg& msg) noexcept
    1484                 :             : {
    1485                 :        9025 :     AssertLockNotHeld(m_send_mutex);
    1486                 :        9025 :     LOCK(m_send_mutex);
    1487         [ +  + ]:        9025 :     if (m_send_state == SendState::V1) return m_v1_fallback.SetMessageToSend(msg);
    1488                 :             :     // We only allow adding a new message to be sent when in the READY state (so the packet cipher
    1489                 :             :     // is available) and the send buffer is empty. This limits the number of messages in the send
    1490                 :             :     // buffer to just one, and leaves the responsibility for queueing them up to the caller.
    1491   [ +  +  +  + ]:        8660 :     if (!(m_send_state == SendState::READY && m_send_buffer.empty())) return false;
    1492                 :             :     // Construct contents (encoding message type + payload).
    1493                 :        8593 :     std::vector<uint8_t> contents;
    1494                 :        8593 :     auto short_message_id = V2_MESSAGE_MAP(msg.m_type);
    1495         [ +  + ]:        8593 :     if (short_message_id) {
    1496                 :        7698 :         contents.resize(1 + msg.data.size());
    1497                 :        7698 :         contents[0] = *short_message_id;
    1498                 :        7698 :         std::copy(msg.data.begin(), msg.data.end(), contents.begin() + 1);
    1499                 :             :     } else {
    1500                 :             :         // Initialize with zeroes, and then write the message type string starting at offset 1.
    1501                 :             :         // This means contents[0] and the unused positions in contents[1..13] remain 0x00.
    1502                 :         895 :         contents.resize(1 + CMessageHeader::MESSAGE_TYPE_SIZE + msg.data.size(), 0);
    1503                 :         895 :         std::copy(msg.m_type.begin(), msg.m_type.end(), contents.data() + 1);
    1504                 :         895 :         std::copy(msg.data.begin(), msg.data.end(), contents.begin() + 1 + CMessageHeader::MESSAGE_TYPE_SIZE);
    1505                 :             :     }
    1506                 :             :     // Construct ciphertext in send buffer.
    1507                 :        8593 :     m_send_buffer.resize(contents.size() + BIP324Cipher::EXPANSION);
    1508                 :        8593 :     m_cipher.Encrypt(MakeByteSpan(contents), {}, false, MakeWritableByteSpan(m_send_buffer));
    1509                 :        8593 :     m_send_type = msg.m_type;
    1510                 :             :     // Release memory
    1511                 :        8593 :     ClearShrink(msg.data);
    1512                 :        8593 :     return true;
    1513                 :        8593 : }
    1514                 :             : 
    1515                 :       58357 : Transport::BytesToSend V2Transport::GetBytesToSend(bool have_next_message) const noexcept
    1516                 :             : {
    1517                 :       58357 :     AssertLockNotHeld(m_send_mutex);
    1518                 :       58357 :     LOCK(m_send_mutex);
    1519         [ +  + ]:       58357 :     if (m_send_state == SendState::V1) return m_v1_fallback.GetBytesToSend(have_next_message);
    1520                 :             : 
    1521                 :       55856 :     if (m_send_state == SendState::MAYBE_V1) Assume(m_send_buffer.empty());
    1522                 :       55856 :     Assume(m_send_pos <= m_send_buffer.size());
    1523                 :       55856 :     return {
    1524         [ +  + ]:       55856 :         std::span{m_send_buffer}.subspan(m_send_pos),
    1525                 :             :         // We only have more to send after the current m_send_buffer if there is a (next)
    1526                 :             :         // message to be sent, and we're capable of sending packets. */
    1527   [ +  +  +  + ]:       55856 :         have_next_message && m_send_state == SendState::READY,
    1528                 :       55856 :         m_send_type
    1529                 :       55856 :     };
    1530                 :       58357 : }
    1531                 :             : 
    1532                 :       10472 : void V2Transport::MarkBytesSent(size_t bytes_sent) noexcept
    1533                 :             : {
    1534                 :       10472 :     AssertLockNotHeld(m_send_mutex);
    1535                 :       10472 :     LOCK(m_send_mutex);
    1536   [ +  +  +  - ]:       10472 :     if (m_send_state == SendState::V1) return m_v1_fallback.MarkBytesSent(bytes_sent);
    1537                 :             : 
    1538   [ +  +  +  +  :        9756 :     if (m_send_state == SendState::AWAITING_KEY && m_send_pos == 0 && bytes_sent > 0) {
                   +  - ]
    1539         [ +  - ]:         125 :         LogDebug(BCLog::NET, "start sending v2 handshake to peer=%d\n", m_nodeid);
    1540                 :             :     }
    1541                 :             : 
    1542                 :        9756 :     m_send_pos += bytes_sent;
    1543                 :        9756 :     Assume(m_send_pos <= m_send_buffer.size());
    1544         [ +  + ]:        9756 :     if (m_send_pos >= CMessageHeader::HEADER_SIZE) {
    1545                 :        9634 :         m_sent_v1_header_worth = true;
    1546                 :             :     }
    1547                 :             :     // Wipe the buffer when everything is sent.
    1548         [ +  + ]:        9756 :     if (m_send_pos == m_send_buffer.size()) {
    1549                 :        8967 :         m_send_pos = 0;
    1550                 :        8967 :         ClearShrink(m_send_buffer);
    1551                 :             :     }
    1552                 :       10472 : }
    1553                 :             : 
    1554                 :         143 : bool V2Transport::ShouldReconnectV1() const noexcept
    1555                 :             : {
    1556                 :         143 :     AssertLockNotHeld(m_send_mutex);
    1557                 :         143 :     AssertLockNotHeld(m_recv_mutex);
    1558                 :             :     // Only outgoing connections need reconnection.
    1559         [ +  + ]:         143 :     if (!m_initiating) return false;
    1560                 :             : 
    1561                 :          62 :     LOCK(m_recv_mutex);
    1562                 :             :     // We only reconnect in the very first state and when the receive buffer is empty. Together
    1563                 :             :     // these conditions imply nothing has been received so far.
    1564         [ +  + ]:          62 :     if (m_recv_state != RecvState::KEY) return false;
    1565         [ +  - ]:           3 :     if (!m_recv_buffer.empty()) return false;
    1566                 :             :     // Check if we've sent enough for the other side to disconnect us (if it was V1).
    1567                 :           3 :     LOCK(m_send_mutex);
    1568         [ +  - ]:           3 :     return m_sent_v1_header_worth;
    1569                 :          65 : }
    1570                 :             : 
    1571                 :       18057 : size_t V2Transport::GetSendMemoryUsage() const noexcept
    1572                 :             : {
    1573                 :       18057 :     AssertLockNotHeld(m_send_mutex);
    1574                 :       18057 :     LOCK(m_send_mutex);
    1575         [ +  + ]:       18057 :     if (m_send_state == SendState::V1) return m_v1_fallback.GetSendMemoryUsage();
    1576                 :             : 
    1577         [ +  + ]:       17349 :     return sizeof(m_send_buffer) + memusage::DynamicUsage(m_send_buffer);
    1578                 :       18057 : }
    1579                 :             : 
    1580                 :        1959 : Transport::Info V2Transport::GetInfo() const noexcept
    1581                 :             : {
    1582                 :        1959 :     AssertLockNotHeld(m_recv_mutex);
    1583                 :        1959 :     LOCK(m_recv_mutex);
    1584         [ +  + ]:        1959 :     if (m_recv_state == RecvState::V1) return m_v1_fallback.GetInfo();
    1585                 :             : 
    1586         [ +  + ]:        1918 :     Transport::Info info;
    1587                 :             : 
    1588                 :             :     // Do not report v2 and session ID until the version packet has been received
    1589                 :             :     // and verified (confirming that the other side very likely has the same keys as us).
    1590         [ +  + ]:        1918 :     if (m_recv_state != RecvState::KEY_MAYBE_V1 && m_recv_state != RecvState::KEY &&
    1591                 :             :         m_recv_state != RecvState::GARB_GARBTERM && m_recv_state != RecvState::VERSION) {
    1592                 :        1852 :         info.transport_type = TransportProtocolType::V2;
    1593                 :        1852 :         info.session_id = uint256(MakeUCharSpan(m_cipher.GetSessionID()));
    1594                 :             :     } else {
    1595                 :          66 :         info.transport_type = TransportProtocolType::DETECTING;
    1596                 :             :     }
    1597                 :             : 
    1598                 :        1918 :     return info;
    1599                 :        1959 : }
    1600                 :             : 
    1601                 :      169428 : std::pair<size_t, bool> CConnman::SocketSendData(CNode& node) const
    1602                 :             : {
    1603                 :      169428 :     auto it = node.vSendMsg.begin();
    1604                 :      169428 :     size_t nSentSize = 0;
    1605                 :      169428 :     bool data_left{false}; //!< second return value (whether unsent data remains)
    1606                 :      169428 :     std::optional<bool> expected_more;
    1607                 :             : 
    1608                 :      494383 :     while (true) {
    1609         [ +  + ]:      494383 :         if (it != node.vSendMsg.end()) {
    1610                 :             :             // If possible, move one message from the send queue to the transport. This fails when
    1611                 :             :             // there is an existing message still being sent, or (for v2 transports) when the
    1612                 :             :             // handshake has not yet completed.
    1613                 :      169621 :             size_t memusage = it->GetMemoryUsage();
    1614         [ +  + ]:      169621 :             if (node.m_transport->SetMessageToSend(*it)) {
    1615                 :             :                 // Update memory usage of send buffer (as *it will be deleted).
    1616                 :      169153 :                 node.m_send_memusage -= memusage;
    1617                 :      169153 :                 ++it;
    1618                 :             :             }
    1619                 :             :         }
    1620         [ +  + ]:      494383 :         const auto& [data, more, msg_type] = node.m_transport->GetBytesToSend(it != node.vSendMsg.end());
    1621                 :             :         // We rely on the 'more' value returned by GetBytesToSend to correctly predict whether more
    1622                 :             :         // bytes are still to be sent, to correctly set the MSG_MORE flag. As a sanity check,
    1623                 :             :         // verify that the previously returned 'more' was correct.
    1624         [ +  + ]:      494383 :         if (expected_more.has_value()) Assume(!data.empty() == *expected_more);
    1625         [ +  + ]:      494383 :         expected_more = more;
    1626         [ +  + ]:      494383 :         data_left = !data.empty(); // will be overwritten on next loop if all of data gets sent
    1627                 :      494383 :         int nBytes = 0;
    1628         [ +  + ]:      494383 :         if (!data.empty()) {
    1629                 :      325399 :             LOCK(node.m_sock_mutex);
    1630                 :             :             // There is no socket in case we've already disconnected, or in test cases without
    1631                 :             :             // real connections. In these cases, we bail out immediately and just leave things
    1632                 :             :             // in the send queue and transport.
    1633         [ +  + ]:      325399 :             if (!node.m_sock) {
    1634                 :             :                 break;
    1635                 :             :             }
    1636                 :      325393 :             int flags = MSG_NOSIGNAL | MSG_DONTWAIT;
    1637                 :             : #ifdef MSG_MORE
    1638         [ +  + ]:      325393 :             if (more) {
    1639                 :      155971 :                 flags |= MSG_MORE;
    1640                 :             :             }
    1641                 :             : #endif
    1642   [ +  -  +  - ]:      325393 :             nBytes = node.m_sock->Send(reinterpret_cast<const char*>(data.data()), data.size(), flags);
    1643                 :           6 :         }
    1644         [ +  + ]:      325393 :         if (nBytes > 0) {
    1645                 :      325392 :             node.m_last_send = GetTime<std::chrono::seconds>();
    1646                 :      325392 :             node.nSendBytes += nBytes;
    1647                 :             :             // Notify transport that bytes have been processed.
    1648                 :      325392 :             node.m_transport->MarkBytesSent(nBytes);
    1649                 :             :             // Update statistics per message type.
    1650         [ +  + ]:      325392 :             if (!msg_type.empty()) { // don't report v2 handshake bytes for now
    1651                 :      325119 :                 node.AccountForSentBytes(msg_type, nBytes);
    1652                 :             :             }
    1653                 :      325392 :             nSentSize += nBytes;
    1654         [ +  + ]:      325392 :             if ((size_t)nBytes != data.size()) {
    1655                 :             :                 // could not send full message; stop sending more
    1656                 :             :                 break;
    1657                 :             :             }
    1658                 :             :         } else {
    1659         [ +  + ]:      168985 :             if (nBytes < 0) {
    1660                 :             :                 // error
    1661                 :           1 :                 int nErr = WSAGetLastError();
    1662   [ +  -  +  - ]:           1 :                 if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS) {
    1663   [ +  -  +  -  :           2 :                     LogDebug(BCLog::NET, "socket send error, %s: %s\n", node.DisconnectMsg(fLogIPs), NetworkErrorString(nErr));
                   +  - ]
    1664                 :           1 :                     node.CloseSocketDisconnect();
    1665                 :             :                 }
    1666                 :             :             }
    1667                 :             :             break;
    1668                 :             :         }
    1669                 :             :     }
    1670                 :             : 
    1671         [ +  + ]:      169428 :     node.fPauseSend = node.m_send_memusage + node.m_transport->GetSendMemoryUsage() > nSendBufferMaxSize;
    1672                 :             : 
    1673         [ +  + ]:      169428 :     if (it == node.vSendMsg.end()) {
    1674         [ -  + ]:      169411 :         assert(node.m_send_memusage == 0);
    1675                 :             :     }
    1676                 :      169428 :     node.vSendMsg.erase(node.vSendMsg.begin(), it);
    1677                 :      169428 :     return {nSentSize, data_left};
    1678                 :             : }
    1679                 :             : 
    1680                 :             : /** Try to find a connection to evict when the node is full.
    1681                 :             :  *  Extreme care must be taken to avoid opening the node to attacker
    1682                 :             :  *   triggered network partitioning.
    1683                 :             :  *  The strategy used here is to protect a small number of peers
    1684                 :             :  *   for each of several distinct characteristics which are difficult
    1685                 :             :  *   to forge.  In order to partition a node the attacker must be
    1686                 :             :  *   simultaneously better at all of them than honest peers.
    1687                 :             :  */
    1688                 :           1 : bool CConnman::AttemptToEvictConnection()
    1689                 :             : {
    1690                 :           1 :     std::vector<NodeEvictionCandidate> vEvictionCandidates;
    1691                 :           1 :     {
    1692                 :             : 
    1693         [ +  - ]:           1 :         LOCK(m_nodes_mutex);
    1694         [ +  + ]:          22 :         for (const CNode* node : m_nodes) {
    1695         [ -  + ]:          21 :             if (node->fDisconnect)
    1696                 :           0 :                 continue;
    1697                 :          21 :             NodeEvictionCandidate candidate{
    1698                 :          21 :                 .id = node->GetId(),
    1699                 :             :                 .m_connected = node->m_connected,
    1700                 :          21 :                 .m_min_ping_time = node->m_min_ping_time,
    1701                 :          21 :                 .m_last_block_time = node->m_last_block_time,
    1702                 :          21 :                 .m_last_tx_time = node->m_last_tx_time,
    1703         [ +  - ]:          21 :                 .fRelevantServices = node->m_has_all_wanted_services,
    1704                 :          21 :                 .m_relay_txs = node->m_relays_txs.load(),
    1705                 :          21 :                 .fBloomFilter = node->m_bloom_filter_loaded.load(),
    1706                 :          21 :                 .nKeyedNetGroup = node->nKeyedNetGroup,
    1707                 :          21 :                 .prefer_evict = node->m_prefer_evict,
    1708         [ +  - ]:          21 :                 .m_is_local = node->addr.IsLocal(),
    1709                 :          21 :                 .m_network = node->ConnectedThroughNetwork(),
    1710                 :          21 :                 .m_noban = node->HasPermission(NetPermissionFlags::NoBan),
    1711                 :          21 :                 .m_conn_type = node->m_conn_type,
    1712   [ +  -  +  -  :          42 :             };
                   +  - ]
    1713         [ +  - ]:          21 :             vEvictionCandidates.push_back(candidate);
    1714                 :             :         }
    1715                 :           0 :     }
    1716         [ +  - ]:           1 :     const std::optional<NodeId> node_id_to_evict = SelectNodeToEvict(std::move(vEvictionCandidates));
    1717         [ +  - ]:           1 :     if (!node_id_to_evict) {
    1718                 :             :         return false;
    1719                 :             :     }
    1720         [ +  - ]:           1 :     LOCK(m_nodes_mutex);
    1721         [ +  - ]:           7 :     for (CNode* pnode : m_nodes) {
    1722         [ +  + ]:           7 :         if (pnode->GetId() == *node_id_to_evict) {
    1723   [ +  -  +  -  :           3 :             LogDebug(BCLog::NET, "selected %s connection for eviction, %s", pnode->ConnectionTypeAsString(), pnode->DisconnectMsg(fLogIPs));
             +  -  +  - ]
    1724                 :             :             TRACEPOINT(net, evicted_inbound_connection,
    1725                 :             :                 pnode->GetId(),
    1726                 :             :                 pnode->m_addr_name.c_str(),
    1727                 :             :                 pnode->ConnectionTypeAsString().c_str(),
    1728                 :             :                 pnode->ConnectedThroughNetwork(),
    1729                 :           1 :                 Ticks<std::chrono::seconds>(pnode->m_connected));
    1730                 :           1 :             pnode->fDisconnect = true;
    1731                 :           1 :             return true;
    1732                 :             :         }
    1733                 :             :     }
    1734                 :             :     return false;
    1735                 :           2 : }
    1736                 :             : 
    1737                 :         962 : void CConnman::AcceptConnection(const ListenSocket& hListenSocket) {
    1738                 :         962 :     struct sockaddr_storage sockaddr;
    1739                 :         962 :     socklen_t len = sizeof(sockaddr);
    1740                 :        1924 :     auto sock = hListenSocket.sock->Accept((struct sockaddr*)&sockaddr, &len);
    1741                 :             : 
    1742         [ -  + ]:         962 :     if (!sock) {
    1743                 :           0 :         const int nErr = WSAGetLastError();
    1744         [ #  # ]:           0 :         if (nErr != WSAEWOULDBLOCK) {
    1745   [ #  #  #  # ]:           0 :             LogPrintf("socket error accept failed: %s\n", NetworkErrorString(nErr));
    1746                 :             :         }
    1747                 :           0 :         return;
    1748                 :             :     }
    1749                 :             : 
    1750         [ +  - ]:         962 :     CService addr;
    1751   [ +  -  -  + ]:         962 :     if (!addr.SetSockAddr((const struct sockaddr*)&sockaddr, len)) {
    1752   [ #  #  #  #  :           0 :         LogPrintLevel(BCLog::NET, BCLog::Level::Warning, "Unknown socket family\n");
                   #  # ]
    1753                 :             :     } else {
    1754         [ +  - ]:        1924 :         addr = MaybeFlipIPv6toCJDNS(addr);
    1755                 :             :     }
    1756                 :             : 
    1757   [ +  -  +  - ]:         962 :     const CService addr_bind{MaybeFlipIPv6toCJDNS(GetBindAddress(*sock))};
    1758                 :             : 
    1759                 :         962 :     NetPermissionFlags permission_flags = NetPermissionFlags::None;
    1760         [ +  - ]:         962 :     hListenSocket.AddSocketPermissionFlags(permission_flags);
    1761                 :             : 
    1762         [ +  - ]:         962 :     CreateNodeFromAcceptedSocket(std::move(sock), permission_flags, addr_bind, addr);
    1763                 :         962 : }
    1764                 :             : 
    1765                 :         962 : void CConnman::CreateNodeFromAcceptedSocket(std::unique_ptr<Sock>&& sock,
    1766                 :             :                                             NetPermissionFlags permission_flags,
    1767                 :             :                                             const CService& addr_bind,
    1768                 :             :                                             const CService& addr)
    1769                 :             : {
    1770                 :         962 :     int nInbound = 0;
    1771                 :             : 
    1772                 :         962 :     AddWhitelistPermissionFlags(permission_flags, addr, vWhitelistedRangeIncoming);
    1773                 :             : 
    1774                 :         962 :     {
    1775                 :         962 :         LOCK(m_nodes_mutex);
    1776         [ +  + ]:        2673 :         for (const CNode* pnode : m_nodes) {
    1777         [ +  + ]:        1711 :             if (pnode->IsInboundConn()) nInbound++;
    1778                 :             :         }
    1779                 :         962 :     }
    1780                 :             : 
    1781         [ -  + ]:         962 :     if (!fNetworkActive) {
    1782   [ #  #  #  # ]:           0 :         LogDebug(BCLog::NET, "connection from %s dropped: not accepting new connections\n", addr.ToStringAddrPort());
    1783                 :           0 :         return;
    1784                 :             :     }
    1785                 :             : 
    1786         [ -  + ]:         962 :     if (!sock->IsSelectable()) {
    1787         [ #  # ]:           0 :         LogPrintf("connection from %s dropped: non-selectable socket\n", addr.ToStringAddrPort());
    1788                 :           0 :         return;
    1789                 :             :     }
    1790                 :             : 
    1791                 :             :     // According to the internet TCP_NODELAY is not carried into accepted sockets
    1792                 :             :     // on all platforms.  Set it again here just to be sure.
    1793                 :         962 :     const int on{1};
    1794         [ -  + ]:         962 :     if (sock->SetSockOpt(IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on)) == SOCKET_ERROR) {
    1795   [ #  #  #  # ]:           0 :         LogDebug(BCLog::NET, "connection from %s: unable to set TCP_NODELAY, continuing anyway\n",
    1796                 :             :                  addr.ToStringAddrPort());
    1797                 :             :     }
    1798                 :             : 
    1799                 :             :     // Don't accept connections from banned peers.
    1800   [ +  -  +  + ]:         962 :     bool banned = m_banman && m_banman->IsBanned(addr);
    1801   [ +  +  +  + ]:         962 :     if (!NetPermissions::HasFlag(permission_flags, NetPermissionFlags::NoBan) && banned)
    1802                 :             :     {
    1803   [ +  -  +  - ]:           6 :         LogDebug(BCLog::NET, "connection from %s dropped (banned)\n", addr.ToStringAddrPort());
    1804                 :           3 :         return;
    1805                 :             :     }
    1806                 :             : 
    1807                 :             :     // Only accept connections from discouraged peers if our inbound slots aren't (almost) full.
    1808   [ +  -  +  - ]:         959 :     bool discouraged = m_banman && m_banman->IsDiscouraged(addr);
    1809   [ +  +  +  +  :         959 :     if (!NetPermissions::HasFlag(permission_flags, NetPermissionFlags::NoBan) && nInbound + 1 >= m_max_inbound && discouraged)
                   +  - ]
    1810                 :             :     {
    1811   [ #  #  #  # ]:           0 :         LogDebug(BCLog::NET, "connection from %s dropped (discouraged)\n", addr.ToStringAddrPort());
    1812                 :           0 :         return;
    1813                 :             :     }
    1814                 :             : 
    1815         [ +  + ]:         959 :     if (nInbound >= m_max_inbound)
    1816                 :             :     {
    1817         [ -  + ]:           1 :         if (!AttemptToEvictConnection()) {
    1818                 :             :             // No connection to evict, disconnect the new connection
    1819         [ #  # ]:           0 :             LogDebug(BCLog::NET, "failed to find an eviction candidate - connection dropped (full)\n");
    1820                 :           0 :             return;
    1821                 :             :         }
    1822                 :             :     }
    1823                 :             : 
    1824                 :         959 :     NodeId id = GetNewNodeId();
    1825                 :         959 :     uint64_t nonce = GetDeterministicRandomizer(RANDOMIZER_ID_LOCALHOSTNONCE).Write(id).Finalize();
    1826                 :             : 
    1827                 :         959 :     const bool inbound_onion = std::find(m_onion_binds.begin(), m_onion_binds.end(), addr_bind) != m_onion_binds.end();
    1828                 :             :     // The V2Transport transparently falls back to V1 behavior when an incoming V1 connection is
    1829                 :             :     // detected, so use it whenever we signal NODE_P2P_V2.
    1830                 :         959 :     ServiceFlags local_services = GetLocalServices();
    1831                 :         959 :     const bool use_v2transport(local_services & NODE_P2P_V2);
    1832                 :             : 
    1833                 :         959 :     CNode* pnode = new CNode(id,
    1834                 :             :                              std::move(sock),
    1835         [ +  - ]:        1918 :                              CAddress{addr, NODE_NONE},
    1836                 :             :                              CalculateKeyedNetGroup(addr),
    1837                 :             :                              nonce,
    1838                 :             :                              addr_bind,
    1839                 :             :                              /*addrNameIn=*/"",
    1840                 :             :                              ConnectionType::INBOUND,
    1841                 :             :                              inbound_onion,
    1842         [ +  - ]:         959 :                              CNodeOptions{
    1843                 :             :                                  .permission_flags = permission_flags,
    1844                 :             :                                  .prefer_evict = discouraged,
    1845                 :         959 :                                  .recv_flood_size = nReceiveFloodSize,
    1846                 :             :                                  .use_v2transport = use_v2transport,
    1847   [ +  -  +  -  :        3836 :                              });
             +  -  +  - ]
    1848                 :         959 :     pnode->AddRef();
    1849                 :         959 :     m_msgproc->InitializeNode(*pnode, local_services);
    1850                 :         959 :     {
    1851                 :         959 :         LOCK(m_nodes_mutex);
    1852         [ +  - ]:         959 :         m_nodes.push_back(pnode);
    1853                 :           0 :     }
    1854   [ +  -  +  - ]:        1918 :     LogDebug(BCLog::NET, "connection from %s accepted\n", addr.ToStringAddrPort());
    1855                 :             :     TRACEPOINT(net, inbound_connection,
    1856                 :             :         pnode->GetId(),
    1857                 :             :         pnode->m_addr_name.c_str(),
    1858                 :             :         pnode->ConnectionTypeAsString().c_str(),
    1859                 :             :         pnode->ConnectedThroughNetwork(),
    1860                 :         959 :         GetNodeCount(ConnectionDirection::In));
    1861                 :             : 
    1862                 :             :     // We received a new connection, harvest entropy from the time (and our peer count)
    1863                 :         959 :     RandAddEvent((uint32_t)id);
    1864                 :             : }
    1865                 :             : 
    1866                 :         144 : bool CConnman::AddConnection(const std::string& address, ConnectionType conn_type, bool use_v2transport = false)
    1867                 :             : {
    1868                 :         144 :     AssertLockNotHeld(m_unused_i2p_sessions_mutex);
    1869                 :         144 :     std::optional<int> max_connections;
    1870   [ +  +  +  - ]:         144 :     switch (conn_type) {
    1871                 :             :     case ConnectionType::INBOUND:
    1872                 :             :     case ConnectionType::MANUAL:
    1873                 :             :         return false;
    1874                 :          90 :     case ConnectionType::OUTBOUND_FULL_RELAY:
    1875                 :          90 :         max_connections = m_max_outbound_full_relay;
    1876                 :          90 :         break;
    1877                 :          35 :     case ConnectionType::BLOCK_RELAY:
    1878                 :          35 :         max_connections = m_max_outbound_block_relay;
    1879                 :          35 :         break;
    1880                 :             :     // no limit for ADDR_FETCH because -seednode has no limit either
    1881                 :             :     case ConnectionType::ADDR_FETCH:
    1882                 :             :         break;
    1883                 :             :     // no limit for FEELER connections since they're short-lived
    1884                 :             :     case ConnectionType::FEELER:
    1885                 :             :         break;
    1886                 :             :     } // no default case, so the compiler can warn about missing cases
    1887                 :             : 
    1888                 :             :     // Count existing connections
    1889   [ +  +  +  - ]:         567 :     int existing_connections = WITH_LOCK(m_nodes_mutex,
    1890                 :             :                                          return std::count_if(m_nodes.begin(), m_nodes.end(), [conn_type](CNode* node) { return node->m_conn_type == conn_type; }););
    1891                 :             : 
    1892                 :             :     // Max connections of specified type already exist
    1893         [ +  + ]:         288 :     if (max_connections != std::nullopt && existing_connections >= max_connections) return false;
    1894                 :             : 
    1895                 :             :     // Max total outbound connections already exist
    1896                 :         288 :     CSemaphoreGrant grant(*semOutbound, true);
    1897         [ +  - ]:         144 :     if (!grant) return false;
    1898                 :             : 
    1899   [ +  -  +  - ]:         144 :     OpenNetworkConnection(CAddress(), false, std::move(grant), address.c_str(), conn_type, /*use_v2transport=*/use_v2transport);
    1900                 :         144 :     return true;
    1901                 :             : }
    1902                 :             : 
    1903                 :      443374 : void CConnman::DisconnectNodes()
    1904                 :             : {
    1905                 :      443374 :     AssertLockNotHeld(m_nodes_mutex);
    1906                 :      443374 :     AssertLockNotHeld(m_reconnections_mutex);
    1907                 :             : 
    1908                 :             :     // Use a temporary variable to accumulate desired reconnections, so we don't need
    1909                 :             :     // m_reconnections_mutex while holding m_nodes_mutex.
    1910         [ +  - ]:      443374 :     decltype(m_reconnections) reconnections_to_add;
    1911                 :             : 
    1912                 :      443374 :     {
    1913         [ +  - ]:      443374 :         LOCK(m_nodes_mutex);
    1914                 :             : 
    1915         [ +  + ]:      443374 :         const bool network_active{fNetworkActive};
    1916         [ +  + ]:      443374 :         if (!network_active) {
    1917                 :             :             // Disconnect any connected nodes
    1918         [ +  + ]:         251 :             for (CNode* pnode : m_nodes) {
    1919         [ +  - ]:           7 :                 if (!pnode->fDisconnect) {
    1920   [ +  -  +  -  :          14 :                     LogDebug(BCLog::NET, "Network not active, %s\n", pnode->DisconnectMsg(fLogIPs));
             +  -  +  - ]
    1921                 :           7 :                     pnode->fDisconnect = true;
    1922                 :             :                 }
    1923                 :             :             }
    1924                 :             :         }
    1925                 :             : 
    1926                 :             :         // Disconnect unused nodes
    1927         [ +  - ]:      443374 :         std::vector<CNode*> nodes_copy = m_nodes;
    1928         [ +  + ]:     1072940 :         for (CNode* pnode : nodes_copy)
    1929                 :             :         {
    1930         [ +  + ]:      629566 :             if (pnode->fDisconnect)
    1931                 :             :             {
    1932                 :             :                 // remove from m_nodes
    1933                 :         817 :                 m_nodes.erase(remove(m_nodes.begin(), m_nodes.end(), pnode), m_nodes.end());
    1934                 :             : 
    1935                 :             :                 // Add to reconnection list if appropriate. We don't reconnect right here, because
    1936                 :             :                 // the creation of a connection is a blocking operation (up to several seconds),
    1937                 :             :                 // and we don't want to hold up the socket handler thread for that long.
    1938   [ +  +  +  + ]:         817 :                 if (network_active && pnode->m_transport->ShouldReconnectV1()) {
    1939                 :           3 :                     reconnections_to_add.push_back({
    1940                 :           3 :                         .addr_connect = pnode->addr,
    1941         [ +  - ]:           3 :                         .grant = std::move(pnode->grantOutbound),
    1942                 :           3 :                         .destination = pnode->m_dest,
    1943                 :           3 :                         .conn_type = pnode->m_conn_type,
    1944                 :             :                         .use_v2transport = false});
    1945   [ +  -  +  -  :           3 :                     LogDebug(BCLog::NET, "retrying with v1 transport protocol for peer=%d\n", pnode->GetId());
                   +  - ]
    1946                 :             :                 }
    1947                 :             : 
    1948                 :             :                 // release outbound grant (if any)
    1949                 :         817 :                 pnode->grantOutbound.Release();
    1950                 :             : 
    1951                 :             :                 // close socket and cleanup
    1952         [ +  - ]:         817 :                 pnode->CloseSocketDisconnect();
    1953                 :             : 
    1954                 :             :                 // update connection count by network
    1955   [ +  +  +  - ]:         817 :                 if (pnode->IsManualOrFullOutboundConn()) --m_network_conn_counts[pnode->addr.GetNetwork()];
    1956                 :             : 
    1957                 :             :                 // hold in disconnected pool until all refs are released
    1958         [ +  - ]:         817 :                 pnode->Release();
    1959         [ +  - ]:         817 :                 m_nodes_disconnected.push_back(pnode);
    1960                 :             :             }
    1961                 :             :         }
    1962         [ +  - ]:      443374 :     }
    1963                 :      443374 :     {
    1964                 :             :         // Delete disconnected nodes
    1965         [ +  - ]:      443374 :         std::list<CNode*> nodes_disconnected_copy = m_nodes_disconnected;
    1966         [ +  + ]:      444195 :         for (CNode* pnode : nodes_disconnected_copy)
    1967                 :             :         {
    1968                 :             :             // Destroy the object only after other threads have stopped using it.
    1969         [ +  + ]:         821 :             if (pnode->GetRefCount() <= 0) {
    1970                 :         817 :                 m_nodes_disconnected.remove(pnode);
    1971         [ +  - ]:         817 :                 DeleteNode(pnode);
    1972                 :             :             }
    1973                 :             :         }
    1974                 :           0 :     }
    1975                 :      443374 :     {
    1976                 :             :         // Move entries from reconnections_to_add to m_reconnections.
    1977         [ +  - ]:      443374 :         LOCK(m_reconnections_mutex);
    1978         [ +  - ]:      443374 :         m_reconnections.splice(m_reconnections.end(), std::move(reconnections_to_add));
    1979                 :      443374 :     }
    1980   [ +  -  +  -  :      443377 : }
                   -  - ]
    1981                 :             : 
    1982                 :      443374 : void CConnman::NotifyNumConnectionsChanged()
    1983                 :             : {
    1984                 :      443374 :     size_t nodes_size;
    1985                 :      443374 :     {
    1986                 :      443374 :         LOCK(m_nodes_mutex);
    1987         [ +  - ]:      443374 :         nodes_size = m_nodes.size();
    1988                 :      443374 :     }
    1989         [ +  + ]:      443374 :     if(nodes_size != nPrevNodeCount) {
    1990                 :        2252 :         nPrevNodeCount = nodes_size;
    1991         [ +  - ]:        2252 :         if (m_client_interface) {
    1992                 :        2252 :             m_client_interface->NotifyNumConnectionsChanged(nodes_size);
    1993                 :             :         }
    1994                 :             :     }
    1995                 :      443374 : }
    1996                 :             : 
    1997                 :     1017469 : bool CConnman::ShouldRunInactivityChecks(const CNode& node, std::chrono::seconds now) const
    1998                 :             : {
    1999                 :     1017469 :     return node.m_connected + m_peer_connect_timeout < now;
    2000                 :             : }
    2001                 :             : 
    2002                 :      628018 : bool CConnman::InactivityCheck(const CNode& node) const
    2003                 :             : {
    2004                 :             :     // Tests that see disconnects after using mocktime can start nodes with a
    2005                 :             :     // large timeout. For example, -peertimeout=999999999.
    2006                 :      628018 :     const auto now{GetTime<std::chrono::seconds>()};
    2007                 :      628018 :     const auto last_send{node.m_last_send.load()};
    2008                 :      628018 :     const auto last_recv{node.m_last_recv.load()};
    2009                 :             : 
    2010         [ +  + ]:      628018 :     if (!ShouldRunInactivityChecks(node, now)) return false;
    2011                 :             : 
    2012         [ +  + ]:          94 :     bool has_received{last_recv.count() != 0};
    2013                 :          94 :     bool has_sent{last_send.count() != 0};
    2014                 :             : 
    2015         [ +  + ]:          94 :     if (!has_received || !has_sent) {
    2016         [ +  + ]:           3 :         std::string has_never;
    2017   [ +  +  +  - ]:           3 :         if (!has_received) has_never += ", never received from peer";
    2018   [ +  -  +  - ]:           3 :         if (!has_sent) has_never += ", never sent to peer";
    2019   [ +  -  +  -  :           6 :         LogDebug(BCLog::NET,
             +  -  +  - ]
    2020                 :             :             "socket no message in first %i seconds%s, %s\n",
    2021                 :             :             count_seconds(m_peer_connect_timeout),
    2022                 :             :             has_never,
    2023                 :             :             node.DisconnectMsg(fLogIPs)
    2024                 :             :         );
    2025                 :           3 :         return true;
    2026                 :           3 :     }
    2027                 :             : 
    2028         [ -  + ]:          91 :     if (now > last_send + TIMEOUT_INTERVAL) {
    2029   [ #  #  #  # ]:           0 :         LogDebug(BCLog::NET,
    2030                 :             :             "socket sending timeout: %is, %s\n", count_seconds(now - last_send),
    2031                 :             :             node.DisconnectMsg(fLogIPs)
    2032                 :             :         );
    2033                 :           0 :         return true;
    2034                 :             :     }
    2035                 :             : 
    2036         [ -  + ]:          91 :     if (now > last_recv + TIMEOUT_INTERVAL) {
    2037   [ #  #  #  # ]:           0 :         LogDebug(BCLog::NET,
    2038                 :             :             "socket receive timeout: %is, %s\n", count_seconds(now - last_recv),
    2039                 :             :             node.DisconnectMsg(fLogIPs)
    2040                 :             :         );
    2041                 :           0 :         return true;
    2042                 :             :     }
    2043                 :             : 
    2044         [ +  + ]:          91 :     if (!node.fSuccessfullyConnected) {
    2045         [ +  + ]:           8 :         if (node.m_transport->GetInfo().transport_type == TransportProtocolType::DETECTING) {
    2046   [ +  -  +  - ]:           4 :             LogDebug(BCLog::NET, "V2 handshake timeout, %s\n", node.DisconnectMsg(fLogIPs));
    2047                 :             :         } else {
    2048   [ +  -  +  - ]:          12 :             LogDebug(BCLog::NET, "version handshake timeout, %s\n", node.DisconnectMsg(fLogIPs));
    2049                 :             :         }
    2050                 :           8 :         return true;
    2051                 :             :     }
    2052                 :             : 
    2053                 :             :     return false;
    2054                 :             : }
    2055                 :             : 
    2056                 :      443374 : Sock::EventsPerSock CConnman::GenerateWaitSockets(std::span<CNode* const> nodes)
    2057                 :             : {
    2058                 :      443374 :     Sock::EventsPerSock events_per_sock;
    2059                 :             : 
    2060         [ +  + ]:      887565 :     for (const ListenSocket& hListenSocket : vhListenSocket) {
    2061         [ +  - ]:      444191 :         events_per_sock.emplace(hListenSocket.sock, Sock::Events{Sock::RECV});
    2062                 :             :     }
    2063                 :             : 
    2064         [ +  + ]:     1072123 :     for (CNode* pnode : nodes) {
    2065         [ +  - ]:      628749 :         bool select_recv = !pnode->fPauseRecv;
    2066                 :      628749 :         bool select_send;
    2067                 :      628749 :         {
    2068         [ +  - ]:      628749 :             LOCK(pnode->cs_vSend);
    2069                 :             :             // Sending is possible if either there are bytes to send right now, or if there will be
    2070                 :             :             // once a potential message from vSendMsg is handed to the transport. GetBytesToSend
    2071                 :             :             // determines both of these in a single call.
    2072         [ +  + ]:      628749 :             const auto& [to_send, more, _msg_type] = pnode->m_transport->GetBytesToSend(!pnode->vSendMsg.empty());
    2073   [ +  +  +  -  :     1255843 :             select_send = !to_send.empty() || more;
                   +  - ]
    2074                 :      628749 :         }
    2075         [ +  + ]:      628749 :         if (!select_recv && !select_send) continue;
    2076                 :             : 
    2077         [ +  - ]:      626611 :         LOCK(pnode->m_sock_mutex);
    2078         [ +  - ]:      626611 :         if (pnode->m_sock) {
    2079   [ +  +  -  + ]:     1251567 :             Sock::Event event = (select_send ? Sock::SEND : 0) | (select_recv ? Sock::RECV : 0);
    2080         [ +  - ]:      626611 :             events_per_sock.emplace(pnode->m_sock, Sock::Events{event});
    2081                 :             :         }
    2082                 :      626611 :     }
    2083                 :             : 
    2084                 :      443374 :     return events_per_sock;
    2085                 :           0 : }
    2086                 :             : 
    2087                 :      443374 : void CConnman::SocketHandler()
    2088                 :             : {
    2089                 :      443374 :     AssertLockNotHeld(m_total_bytes_sent_mutex);
    2090                 :             : 
    2091         [ +  - ]:      443374 :     Sock::EventsPerSock events_per_sock;
    2092                 :             : 
    2093                 :      443374 :     {
    2094         [ +  - ]:      443374 :         const NodesSnapshot snap{*this, /*shuffle=*/false};
    2095                 :             : 
    2096                 :      443374 :         const auto timeout = std::chrono::milliseconds(SELECT_TIMEOUT_MILLISECONDS);
    2097                 :             : 
    2098                 :             :         // Check for the readiness of the already connected sockets and the
    2099                 :             :         // listening sockets in one call ("readiness" as in poll(2) or
    2100                 :             :         // select(2)). If none are ready, wait for a short while and return
    2101                 :             :         // empty sets.
    2102         [ +  - ]:      886748 :         events_per_sock = GenerateWaitSockets(snap.Nodes());
    2103   [ +  +  +  -  :      443374 :         if (events_per_sock.empty() || !events_per_sock.begin()->first->WaitMany(timeout, events_per_sock)) {
                   -  + ]
    2104         [ +  - ]:          58 :             interruptNet.sleep_for(timeout);
    2105                 :             :         }
    2106                 :             : 
    2107                 :             :         // Service (send/receive) each of the already connected nodes.
    2108         [ +  - ]:      443374 :         SocketHandlerConnected(snap.Nodes(), events_per_sock);
    2109                 :      443374 :     }
    2110                 :             : 
    2111                 :             :     // Accept new connections from listening sockets.
    2112         [ +  - ]:      443374 :     SocketHandlerListening(events_per_sock);
    2113                 :      443374 : }
    2114                 :             : 
    2115                 :      443374 : void CConnman::SocketHandlerConnected(const std::vector<CNode*>& nodes,
    2116                 :             :                                       const Sock::EventsPerSock& events_per_sock)
    2117                 :             : {
    2118                 :      443374 :     AssertLockNotHeld(m_total_bytes_sent_mutex);
    2119                 :             : 
    2120         [ +  + ]:     1071393 :     for (CNode* pnode : nodes) {
    2121         [ +  + ]:      628421 :         if (interruptNet)
    2122                 :             :             return;
    2123                 :             : 
    2124                 :             :         //
    2125                 :             :         // Receive
    2126                 :             :         //
    2127                 :      628019 :         bool recvSet = false;
    2128                 :      628019 :         bool sendSet = false;
    2129                 :      628019 :         bool errorSet = false;
    2130                 :      628019 :         {
    2131                 :      628019 :             LOCK(pnode->m_sock_mutex);
    2132         [ -  + ]:      628019 :             if (!pnode->m_sock) {
    2133         [ #  # ]:           0 :                 continue;
    2134                 :             :             }
    2135   [ +  -  +  - ]:     1256038 :             const auto it = events_per_sock.find(pnode->m_sock);
    2136         [ +  + ]:      628019 :             if (it != events_per_sock.end()) {
    2137                 :      625881 :                 recvSet = it->second.occurred & Sock::RECV;
    2138                 :      625881 :                 sendSet = it->second.occurred & Sock::SEND;
    2139                 :      625881 :                 errorSet = it->second.occurred & Sock::ERR;
    2140                 :             :             }
    2141                 :           0 :         }
    2142                 :             : 
    2143         [ +  + ]:      628019 :         if (sendSet) {
    2144                 :             :             // Send data
    2145   [ +  +  +  - ]:        2127 :             auto [bytes_sent, data_left] = WITH_LOCK(pnode->cs_vSend, return SocketSendData(*pnode));
    2146         [ +  + ]:         709 :             if (bytes_sent) {
    2147                 :         708 :                 RecordBytesSent(bytes_sent);
    2148                 :             : 
    2149                 :             :                 // If both receiving and (non-optimistic) sending were possible, we first attempt
    2150                 :             :                 // sending. If that succeeds, but does not fully drain the send queue, do not
    2151                 :             :                 // attempt to receive. This avoids needlessly queueing data if the remote peer
    2152                 :             :                 // is slow at receiving data, by means of TCP flow control. We only do this when
    2153                 :             :                 // sending actually succeeded to make sure progress is always made; otherwise a
    2154                 :             :                 // deadlock would be possible when both sides have data to send, but neither is
    2155                 :             :                 // receiving.
    2156         [ +  + ]:         708 :                 if (data_left) recvSet = false;
    2157                 :             :             }
    2158                 :             :         }
    2159                 :             : 
    2160         [ +  + ]:      628019 :         if (recvSet || errorSet)
    2161                 :             :         {
    2162                 :             :             // typical socket buffer is 8K-64K
    2163                 :      231614 :             uint8_t pchBuf[0x10000];
    2164                 :      231614 :             int nBytes = 0;
    2165                 :      231614 :             {
    2166                 :      231614 :                 LOCK(pnode->m_sock_mutex);
    2167         [ +  + ]:      231614 :                 if (!pnode->m_sock) {
    2168         [ +  - ]:           1 :                     continue;
    2169                 :             :                 }
    2170   [ +  -  +  - ]:      231613 :                 nBytes = pnode->m_sock->Recv(pchBuf, sizeof(pchBuf), MSG_DONTWAIT);
    2171                 :           1 :             }
    2172         [ +  + ]:      231613 :             if (nBytes > 0)
    2173                 :             :             {
    2174                 :      231155 :                 bool notify = false;
    2175         [ +  + ]:      231155 :                 if (!pnode->ReceiveMsgBytes({pchBuf, (size_t)nBytes}, notify)) {
    2176   [ +  -  +  - ]:          20 :                     LogDebug(BCLog::NET,
    2177                 :             :                         "receiving message bytes failed, %s\n",
    2178                 :             :                         pnode->DisconnectMsg(fLogIPs)
    2179                 :             :                     );
    2180                 :          10 :                     pnode->CloseSocketDisconnect();
    2181                 :             :                 }
    2182                 :      231155 :                 RecordBytesRecv(nBytes);
    2183         [ +  + ]:      231155 :                 if (notify) {
    2184                 :      135686 :                     pnode->MarkReceivedMsgsForProcessing();
    2185                 :      135686 :                     WakeMessageHandler();
    2186                 :             :                 }
    2187                 :             :             }
    2188         [ +  + ]:         458 :             else if (nBytes == 0)
    2189                 :             :             {
    2190                 :             :                 // socket closed gracefully
    2191         [ +  - ]:         454 :                 if (!pnode->fDisconnect) {
    2192   [ +  -  +  - ]:         908 :                     LogDebug(BCLog::NET, "socket closed, %s\n", pnode->DisconnectMsg(fLogIPs));
    2193                 :             :                 }
    2194                 :         454 :                 pnode->CloseSocketDisconnect();
    2195                 :             :             }
    2196         [ +  - ]:           4 :             else if (nBytes < 0)
    2197                 :             :             {
    2198                 :             :                 // error
    2199                 :           4 :                 int nErr = WSAGetLastError();
    2200   [ +  -  +  - ]:           4 :                 if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
    2201                 :             :                 {
    2202         [ +  - ]:           4 :                     if (!pnode->fDisconnect) {
    2203   [ +  -  +  -  :           8 :                         LogDebug(BCLog::NET, "socket recv error, %s: %s\n", pnode->DisconnectMsg(fLogIPs), NetworkErrorString(nErr));
                   +  - ]
    2204                 :             :                     }
    2205                 :           4 :                     pnode->CloseSocketDisconnect();
    2206                 :             :                 }
    2207                 :             :             }
    2208                 :             :         }
    2209                 :             : 
    2210         [ +  + ]:      628018 :         if (InactivityCheck(*pnode)) pnode->fDisconnect = true;
    2211                 :             :     }
    2212                 :             : }
    2213                 :             : 
    2214                 :      443374 : void CConnman::SocketHandlerListening(const Sock::EventsPerSock& events_per_sock)
    2215                 :             : {
    2216         [ +  + ]:      886635 :     for (const ListenSocket& listen_socket : vhListenSocket) {
    2217         [ +  + ]:      444176 :         if (interruptNet) {
    2218                 :             :             return;
    2219                 :             :         }
    2220   [ +  -  +  - ]:      886522 :         const auto it = events_per_sock.find(listen_socket.sock);
    2221   [ +  -  +  + ]:      443261 :         if (it != events_per_sock.end() && it->second.occurred & Sock::RECV) {
    2222                 :         962 :             AcceptConnection(listen_socket);
    2223                 :             :         }
    2224                 :             :     }
    2225                 :             : }
    2226                 :             : 
    2227                 :         928 : void CConnman::ThreadSocketHandler()
    2228                 :             : {
    2229                 :         928 :     AssertLockNotHeld(m_total_bytes_sent_mutex);
    2230                 :             : 
    2231         [ +  + ]:      444302 :     while (!interruptNet)
    2232                 :             :     {
    2233                 :      443374 :         DisconnectNodes();
    2234                 :      443374 :         NotifyNumConnectionsChanged();
    2235                 :      443374 :         SocketHandler();
    2236                 :             :     }
    2237                 :         928 : }
    2238                 :             : 
    2239                 :      230668 : void CConnman::WakeMessageHandler()
    2240                 :             : {
    2241                 :      230668 :     {
    2242                 :      230668 :         LOCK(mutexMsgProc);
    2243         [ +  - ]:      230668 :         fMsgProcWake = true;
    2244                 :      230668 :     }
    2245                 :      230668 :     condMsgProc.notify_one();
    2246                 :      230668 : }
    2247                 :             : 
    2248                 :          13 : void CConnman::ThreadDNSAddressSeed()
    2249                 :             : {
    2250                 :          13 :     int outbound_connection_count = 0;
    2251                 :             : 
    2252   [ +  -  -  + ]:          13 :     if (!gArgs.GetArgs("-seednode").empty()) {
    2253                 :           0 :         auto start = NodeClock::now();
    2254                 :           0 :         constexpr std::chrono::seconds SEEDNODE_TIMEOUT = 30s;
    2255                 :           0 :         LogPrintf("-seednode enabled. Trying the provided seeds for %d seconds before defaulting to the dnsseeds.\n", SEEDNODE_TIMEOUT.count());
    2256         [ #  # ]:           0 :         while (!interruptNet) {
    2257         [ #  # ]:           0 :             if (!interruptNet.sleep_for(std::chrono::milliseconds(500)))
    2258                 :             :                 return;
    2259                 :             : 
    2260                 :             :             // Abort if we have spent enough time without reaching our target.
    2261                 :             :             // Giving seed nodes 30 seconds so this does not become a race against fixedseeds (which triggers after 1 min)
    2262         [ #  # ]:           0 :             if (NodeClock::now() > start + SEEDNODE_TIMEOUT) {
    2263                 :           0 :                 LogPrintf("Couldn't connect to enough peers via seed nodes. Handing fetch logic to the DNS seeds.\n");
    2264                 :           0 :                 break;
    2265                 :             :             }
    2266                 :             : 
    2267                 :           0 :             outbound_connection_count = GetFullOutboundConnCount();
    2268         [ #  # ]:           0 :             if (outbound_connection_count >= SEED_OUTBOUND_CONNECTION_THRESHOLD) {
    2269                 :           0 :                 LogPrintf("P2P peers available. Finished fetching data from seed nodes.\n");
    2270                 :           0 :                 break;
    2271                 :             :             }
    2272                 :             :         }
    2273                 :             :     }
    2274                 :             : 
    2275                 :          13 :     FastRandomContext rng;
    2276         [ +  - ]:          13 :     std::vector<std::string> seeds = m_params.DNSSeeds();
    2277                 :          13 :     std::shuffle(seeds.begin(), seeds.end(), rng);
    2278                 :          13 :     int seeds_right_now = 0; // Number of seeds left before testing if we have enough connections
    2279                 :             : 
    2280   [ +  -  +  -  :          13 :     if (gArgs.GetBoolArg("-forcednsseed", DEFAULT_FORCEDNSSEED)) {
                   +  + ]
    2281                 :             :         // When -forcednsseed is provided, query all.
    2282                 :           1 :         seeds_right_now = seeds.size();
    2283   [ +  -  +  + ]:          12 :     } else if (addrman.Size() == 0) {
    2284                 :             :         // If we have no known peers, query all.
    2285                 :             :         // This will occur on the first run, or if peers.dat has been
    2286                 :             :         // deleted.
    2287                 :           7 :         seeds_right_now = seeds.size();
    2288                 :             :     }
    2289                 :             : 
    2290                 :             :     // Proceed with dnsseeds if seednodes hasn't reached the target or if forcednsseed is set
    2291         [ +  - ]:          13 :     if (outbound_connection_count < SEED_OUTBOUND_CONNECTION_THRESHOLD || seeds_right_now) {
    2292                 :             :         // goal: only query DNS seed if address need is acute
    2293                 :             :         // * If we have a reasonable number of peers in addrman, spend
    2294                 :             :         //   some time trying them first. This improves user privacy by
    2295                 :             :         //   creating fewer identifying DNS requests, reduces trust by
    2296                 :             :         //   giving seeds less influence on the network topology, and
    2297                 :             :         //   reduces traffic to the seeds.
    2298                 :             :         // * When querying DNS seeds query a few at once, this ensures
    2299                 :             :         //   that we don't give DNS seeds the ability to eclipse nodes
    2300                 :             :         //   that query them.
    2301                 :             :         // * If we continue having problems, eventually query all the
    2302                 :             :         //   DNS seeds, and if that fails too, also try the fixed seeds.
    2303                 :             :         //   (done in ThreadOpenConnections)
    2304                 :          13 :         int found = 0;
    2305   [ +  -  +  + ]:          13 :         const std::chrono::seconds seeds_wait_time = (addrman.Size() >= DNSSEEDS_DELAY_PEER_THRESHOLD ? DNSSEEDS_DELAY_MANY_PEERS : DNSSEEDS_DELAY_FEW_PEERS);
    2306                 :             : 
    2307         [ +  + ]:          22 :         for (const std::string& seed : seeds) {
    2308         [ +  + ]:          13 :             if (seeds_right_now == 0) {
    2309                 :           5 :                 seeds_right_now += DNSSEEDS_TO_QUERY_AT_ONCE;
    2310                 :             : 
    2311   [ +  -  +  - ]:           5 :                 if (addrman.Size() > 0) {
    2312         [ +  - ]:           5 :                     LogPrintf("Waiting %d seconds before querying DNS seeds.\n", seeds_wait_time.count());
    2313                 :           5 :                     std::chrono::seconds to_wait = seeds_wait_time;
    2314         [ +  + ]:           6 :                     while (to_wait.count() > 0) {
    2315                 :             :                         // if sleeping for the MANY_PEERS interval, wake up
    2316                 :             :                         // early to see if we have enough peers and can stop
    2317                 :             :                         // this thread entirely freeing up its resources
    2318                 :           5 :                         std::chrono::seconds w = std::min(DNSSEEDS_DELAY_FEW_PEERS, to_wait);
    2319   [ +  -  +  + ]:           5 :                         if (!interruptNet.sleep_for(w)) return;
    2320         [ +  - ]:           2 :                         to_wait -= w;
    2321                 :             : 
    2322   [ +  -  +  + ]:           2 :                         if (GetFullOutboundConnCount() >= SEED_OUTBOUND_CONNECTION_THRESHOLD) {
    2323         [ -  + ]:           1 :                             if (found > 0) {
    2324         [ #  # ]:           0 :                                 LogPrintf("%d addresses found from DNS seeds\n", found);
    2325         [ #  # ]:           0 :                                 LogPrintf("P2P peers available. Finished DNS seeding.\n");
    2326                 :             :                             } else {
    2327         [ +  - ]:           1 :                                 LogPrintf("P2P peers available. Skipped DNS seeding.\n");
    2328                 :             :                             }
    2329                 :           1 :                             return;
    2330                 :             :                         }
    2331                 :             :                     }
    2332                 :             :                 }
    2333                 :             :             }
    2334                 :             : 
    2335   [ +  -  +  - ]:           9 :             if (interruptNet) return;
    2336                 :             : 
    2337                 :             :             // hold off on querying seeds if P2P network deactivated
    2338         [ -  + ]:           9 :             if (!fNetworkActive) {
    2339         [ #  # ]:           0 :                 LogPrintf("Waiting for network to be reactivated before querying DNS seeds.\n");
    2340                 :           0 :                 do {
    2341   [ #  #  #  # ]:           0 :                     if (!interruptNet.sleep_for(std::chrono::seconds{1})) return;
    2342         [ #  # ]:           0 :                 } while (!fNetworkActive);
    2343                 :             :             }
    2344                 :             : 
    2345         [ +  - ]:           9 :             LogPrintf("Loading addresses from DNS seed %s\n", seed);
    2346                 :             :             // If -proxy is in use, we make an ADDR_FETCH connection to the DNS resolved peer address
    2347                 :             :             // for the base dns seed domain in chainparams
    2348   [ +  -  +  - ]:           9 :             if (HaveNameProxy()) {
    2349         [ +  - ]:           9 :                 AddAddrFetch(seed);
    2350                 :             :             } else {
    2351                 :           0 :                 std::vector<CAddress> vAdd;
    2352                 :           0 :                 constexpr ServiceFlags requiredServiceBits{SeedsServiceFlags()};
    2353         [ #  # ]:           0 :                 std::string host = strprintf("x%x.%s", requiredServiceBits, seed);
    2354         [ #  # ]:           0 :                 CNetAddr resolveSource;
    2355   [ #  #  #  # ]:           0 :                 if (!resolveSource.SetInternal(host)) {
    2356                 :           0 :                     continue;
    2357                 :             :                 }
    2358                 :             :                 // Limit number of IPs learned from a single DNS seed. This limit exists to prevent the results from
    2359                 :             :                 // one DNS seed from dominating AddrMan. Note that the number of results from a UDP DNS query is
    2360                 :             :                 // bounded to 33 already, but it is possible for it to use TCP where a larger number of results can be
    2361                 :             :                 // returned.
    2362                 :           0 :                 unsigned int nMaxIPs = 32;
    2363   [ #  #  #  # ]:           0 :                 const auto addresses{LookupHost(host, nMaxIPs, true)};
    2364         [ #  # ]:           0 :                 if (!addresses.empty()) {
    2365         [ #  # ]:           0 :                     for (const CNetAddr& ip : addresses) {
    2366         [ #  # ]:           0 :                         CAddress addr = CAddress(CService(ip, m_params.GetDefaultPort()), requiredServiceBits);
    2367                 :           0 :                         addr.nTime = rng.rand_uniform_delay(Now<NodeSeconds>() - 3 * 24h, -4 * 24h); // use a random age between 3 and 7 days old
    2368         [ #  # ]:           0 :                         vAdd.push_back(addr);
    2369                 :           0 :                         found++;
    2370                 :           0 :                     }
    2371         [ #  # ]:           0 :                     addrman.Add(vAdd, resolveSource);
    2372                 :             :                 } else {
    2373                 :             :                     // If the seed does not support a subdomain with our desired service bits,
    2374                 :             :                     // we make an ADDR_FETCH connection to the DNS resolved peer address for the
    2375                 :             :                     // base dns seed domain in chainparams
    2376         [ #  # ]:           0 :                     AddAddrFetch(seed);
    2377                 :             :                 }
    2378                 :           0 :             }
    2379                 :           9 :             --seeds_right_now;
    2380                 :             :         }
    2381         [ +  - ]:           9 :         LogPrintf("%d addresses found from DNS seeds\n", found);
    2382                 :             :     } else {
    2383         [ #  # ]:           0 :         LogPrintf("Skipping DNS seeds. Enough peers have been found\n");
    2384                 :             :     }
    2385                 :          13 : }
    2386                 :             : 
    2387                 :         939 : void CConnman::DumpAddresses()
    2388                 :             : {
    2389                 :         939 :     const auto start{SteadyClock::now()};
    2390                 :             : 
    2391                 :         939 :     DumpPeerAddresses(::gArgs, addrman);
    2392                 :             : 
    2393         [ +  - ]:         939 :     LogDebug(BCLog::NET, "Flushed %d addresses to peers.dat  %dms\n",
    2394                 :             :              addrman.Size(), Ticks<std::chrono::milliseconds>(SteadyClock::now() - start));
    2395                 :         939 : }
    2396                 :             : 
    2397                 :          35 : void CConnman::ProcessAddrFetch()
    2398                 :             : {
    2399                 :          35 :     AssertLockNotHeld(m_unused_i2p_sessions_mutex);
    2400         [ +  - ]:          35 :     std::string strDest;
    2401                 :          35 :     {
    2402         [ +  - ]:          35 :         LOCK(m_addr_fetches_mutex);
    2403         [ +  + ]:          35 :         if (m_addr_fetches.empty())
    2404         [ +  - ]:          32 :             return;
    2405         [ +  - ]:           3 :         strDest = m_addr_fetches.front();
    2406         [ +  - ]:           3 :         m_addr_fetches.pop_front();
    2407                 :          32 :     }
    2408                 :             :     // Attempt v2 connection if we support v2 - we'll reconnect with v1 if our
    2409                 :             :     // peer doesn't support it or immediately disconnects us for another reason.
    2410         [ +  - ]:           3 :     const bool use_v2transport(GetLocalServices() & NODE_P2P_V2);
    2411         [ +  - ]:           3 :     CAddress addr;
    2412                 :           3 :     CSemaphoreGrant grant(*semOutbound, /*fTry=*/true);
    2413         [ +  - ]:           3 :     if (grant) {
    2414         [ +  - ]:           3 :         OpenNetworkConnection(addr, false, std::move(grant), strDest.c_str(), ConnectionType::ADDR_FETCH, use_v2transport);
    2415                 :             :     }
    2416                 :          35 : }
    2417                 :             : 
    2418                 :          66 : bool CConnman::GetTryNewOutboundPeer() const
    2419                 :             : {
    2420                 :          66 :     return m_try_another_outbound_peer;
    2421                 :             : }
    2422                 :             : 
    2423                 :        1164 : void CConnman::SetTryNewOutboundPeer(bool flag)
    2424                 :             : {
    2425                 :        1164 :     m_try_another_outbound_peer = flag;
    2426   [ +  -  +  + ]:        2327 :     LogDebug(BCLog::NET, "setting try another outbound peer=%s\n", flag ? "true" : "false");
    2427                 :        1164 : }
    2428                 :             : 
    2429                 :          52 : void CConnman::StartExtraBlockRelayPeers()
    2430                 :             : {
    2431         [ +  - ]:          52 :     LogDebug(BCLog::NET, "enabling extra block-relay-only peers\n");
    2432                 :          52 :     m_start_extra_block_relay_peers = true;
    2433                 :          52 : }
    2434                 :             : 
    2435                 :             : // Return the number of outbound connections that are full relay (not blocks only)
    2436                 :           2 : int CConnman::GetFullOutboundConnCount() const
    2437                 :             : {
    2438                 :           2 :     int nRelevant = 0;
    2439                 :           2 :     {
    2440                 :           2 :         LOCK(m_nodes_mutex);
    2441         [ +  + ]:           6 :         for (const CNode* pnode : m_nodes) {
    2442   [ +  -  +  + ]:           4 :             if (pnode->fSuccessfullyConnected && pnode->IsFullOutboundConn()) ++nRelevant;
    2443                 :             :         }
    2444                 :           2 :     }
    2445                 :           2 :     return nRelevant;
    2446                 :             : }
    2447                 :             : 
    2448                 :             : // Return the number of peers we have over our outbound connection limit
    2449                 :             : // Exclude peers that are marked for disconnect, or are going to be
    2450                 :             : // disconnected soon (eg ADDR_FETCH and FEELER)
    2451                 :             : // Also exclude peers that haven't finished initial connection handshake yet
    2452                 :             : // (so that we don't decide we're over our desired connection limit, and then
    2453                 :             : // evict some peer that has finished the handshake)
    2454                 :         202 : int CConnman::GetExtraFullOutboundCount() const
    2455                 :             : {
    2456                 :         202 :     int full_outbound_peers = 0;
    2457                 :         202 :     {
    2458                 :         202 :         LOCK(m_nodes_mutex);
    2459         [ +  + ]:         505 :         for (const CNode* pnode : m_nodes) {
    2460   [ +  -  +  +  :         303 :             if (pnode->fSuccessfullyConnected && !pnode->fDisconnect && pnode->IsFullOutboundConn()) {
                   +  + ]
    2461                 :          54 :                 ++full_outbound_peers;
    2462                 :             :             }
    2463                 :             :         }
    2464                 :         202 :     }
    2465         [ +  + ]:         202 :     return std::max(full_outbound_peers - m_max_outbound_full_relay, 0);
    2466                 :             : }
    2467                 :             : 
    2468                 :         202 : int CConnman::GetExtraBlockRelayCount() const
    2469                 :             : {
    2470                 :         202 :     int block_relay_peers = 0;
    2471                 :         202 :     {
    2472                 :         202 :         LOCK(m_nodes_mutex);
    2473         [ +  + ]:         505 :         for (const CNode* pnode : m_nodes) {
    2474   [ +  -  +  +  :         303 :             if (pnode->fSuccessfullyConnected && !pnode->fDisconnect && pnode->IsBlockOnlyConn()) {
                   +  + ]
    2475                 :          11 :                 ++block_relay_peers;
    2476                 :             :             }
    2477                 :             :         }
    2478                 :         202 :     }
    2479         [ +  + ]:         202 :     return std::max(block_relay_peers - m_max_outbound_block_relay, 0);
    2480                 :             : }
    2481                 :             : 
    2482                 :           8 : std::unordered_set<Network> CConnman::GetReachableEmptyNetworks() const
    2483                 :             : {
    2484                 :           8 :     std::unordered_set<Network> networks{};
    2485         [ +  + ]:          64 :     for (int n = 0; n < NET_MAX; n++) {
    2486                 :          56 :         enum Network net = (enum Network)n;
    2487         [ +  + ]:          56 :         if (net == NET_UNROUTABLE || net == NET_INTERNAL) continue;
    2488   [ +  -  +  +  :          40 :         if (g_reachable_nets.Contains(net) && addrman.Size(net, std::nullopt) == 0) {
             +  -  +  + ]
    2489         [ +  - ]:          19 :             networks.insert(net);
    2490                 :             :         }
    2491                 :             :     }
    2492                 :           8 :     return networks;
    2493                 :           0 : }
    2494                 :             : 
    2495                 :          38 : bool CConnman::MultipleManualOrFullOutboundConns(Network net) const
    2496                 :             : {
    2497                 :          38 :     AssertLockHeld(m_nodes_mutex);
    2498                 :          38 :     return m_network_conn_counts[net] > 1;
    2499                 :             : }
    2500                 :             : 
    2501                 :           0 : bool CConnman::MaybePickPreferredNetwork(std::optional<Network>& network)
    2502                 :             : {
    2503                 :           0 :     std::array<Network, 5> nets{NET_IPV4, NET_IPV6, NET_ONION, NET_I2P, NET_CJDNS};
    2504                 :           0 :     std::shuffle(nets.begin(), nets.end(), FastRandomContext());
    2505                 :             : 
    2506                 :           0 :     LOCK(m_nodes_mutex);
    2507         [ #  # ]:           0 :     for (const auto net : nets) {
    2508   [ #  #  #  #  :           0 :         if (g_reachable_nets.Contains(net) && m_network_conn_counts[net] == 0 && addrman.Size(net) != 0) {
          #  #  #  #  #  
                      # ]
    2509                 :           0 :             network = net;
    2510                 :           0 :             return true;
    2511                 :             :         }
    2512                 :             :     }
    2513                 :             : 
    2514                 :             :     return false;
    2515                 :           0 : }
    2516                 :             : 
    2517                 :          32 : void CConnman::ThreadOpenConnections(const std::vector<std::string> connect, std::span<const std::string> seed_nodes)
    2518                 :             : {
    2519                 :          32 :     AssertLockNotHeld(m_unused_i2p_sessions_mutex);
    2520                 :          32 :     AssertLockNotHeld(m_reconnections_mutex);
    2521                 :          32 :     FastRandomContext rng;
    2522                 :             :     // Connect to specific addresses
    2523         [ +  + ]:          32 :     if (!connect.empty())
    2524                 :             :     {
    2525                 :             :         // Attempt v2 connection if we support v2 - we'll reconnect with v1 if our
    2526                 :             :         // peer doesn't support it or immediately disconnects us for another reason.
    2527         [ +  - ]:           5 :         const bool use_v2transport(GetLocalServices() & NODE_P2P_V2);
    2528                 :           5 :         for (int64_t nLoop = 0;; nLoop++)
    2529                 :             :         {
    2530         [ +  + ]:          12 :             for (const std::string& strAddr : connect)
    2531                 :             :             {
    2532         [ +  - ]:           7 :                 CAddress addr(CService(), NODE_NONE);
    2533         [ +  - ]:           7 :                 OpenNetworkConnection(addr, false, {}, strAddr.c_str(), ConnectionType::MANUAL, /*use_v2transport=*/use_v2transport);
    2534   [ +  -  -  + ]:           7 :                 for (int i = 0; i < 10 && i < nLoop; i++)
    2535                 :             :                 {
    2536   [ #  #  #  # ]:           0 :                     if (!interruptNet.sleep_for(std::chrono::milliseconds(500)))
    2537                 :           0 :                         return;
    2538                 :             :                 }
    2539                 :           7 :             }
    2540   [ +  -  -  + ]:           5 :             if (!interruptNet.sleep_for(std::chrono::milliseconds(500)))
    2541                 :             :                 return;
    2542         [ #  # ]:           0 :             PerformReconnections();
    2543                 :           0 :         }
    2544                 :             :     }
    2545                 :             : 
    2546                 :             :     // Initiate network connections
    2547                 :          27 :     auto start = GetTime<std::chrono::microseconds>();
    2548                 :             : 
    2549                 :             :     // Minimum time before next feeler connection (in microseconds).
    2550                 :          27 :     auto next_feeler = start + rng.rand_exp_duration(FEELER_INTERVAL);
    2551                 :          27 :     auto next_extra_block_relay = start + rng.rand_exp_duration(EXTRA_BLOCK_RELAY_ONLY_PEER_INTERVAL);
    2552         [ +  - ]:          27 :     auto next_extra_network_peer{start + rng.rand_exp_duration(EXTRA_NETWORK_PEER_INTERVAL)};
    2553   [ +  -  +  - ]:          27 :     const bool dnsseed = gArgs.GetBoolArg("-dnsseed", DEFAULT_DNSSEED);
    2554   [ +  -  +  - ]:          27 :     bool add_fixed_seeds = gArgs.GetBoolArg("-fixedseeds", DEFAULT_FIXEDSEEDS);
    2555   [ +  -  +  - ]:          27 :     const bool use_seednodes{!gArgs.GetArgs("-seednode").empty()};
    2556                 :             : 
    2557                 :          27 :     auto seed_node_timer = NodeClock::now();
    2558   [ +  -  +  +  :          27 :     bool add_addr_fetch{addrman.Size() == 0 && !seed_nodes.empty()};
                   +  + ]
    2559                 :          27 :     constexpr std::chrono::seconds ADD_NEXT_SEEDNODE = 10s;
    2560                 :             : 
    2561         [ +  + ]:          27 :     if (!add_fixed_seeds) {
    2562         [ +  - ]:          24 :         LogPrintf("Fixed seeds are disabled\n");
    2563                 :             :     }
    2564                 :             : 
    2565   [ +  -  +  - ]:          35 :     while (!interruptNet)
    2566                 :             :     {
    2567         [ +  + ]:          35 :         if (add_addr_fetch) {
    2568                 :           2 :             add_addr_fetch = false;
    2569                 :           2 :             const auto& seed{SpanPopBack(seed_nodes)};
    2570         [ +  - ]:           2 :             AddAddrFetch(seed);
    2571                 :             : 
    2572   [ +  -  +  + ]:           2 :             if (addrman.Size() == 0) {
    2573         [ +  - ]:           1 :                 LogInfo("Empty addrman, adding seednode (%s) to addrfetch\n", seed);
    2574                 :             :             } else {
    2575         [ +  - ]:           1 :                 LogInfo("Couldn't connect to peers from addrman after %d seconds. Adding seednode (%s) to addrfetch\n", ADD_NEXT_SEEDNODE.count(), seed);
    2576                 :             :             }
    2577                 :             :         }
    2578                 :             : 
    2579         [ +  - ]:          35 :         ProcessAddrFetch();
    2580                 :             : 
    2581   [ +  -  +  + ]:          35 :         if (!interruptNet.sleep_for(std::chrono::milliseconds(500)))
    2582                 :             :             return;
    2583                 :             : 
    2584         [ +  - ]:           8 :         PerformReconnections();
    2585                 :             : 
    2586                 :           8 :         CSemaphoreGrant grant(*semOutbound);
    2587   [ +  -  +  - ]:           8 :         if (interruptNet)
    2588                 :             :             return;
    2589                 :             : 
    2590         [ +  - ]:           8 :         const std::unordered_set<Network> fixed_seed_networks{GetReachableEmptyNetworks()};
    2591   [ +  +  +  - ]:           8 :         if (add_fixed_seeds && !fixed_seed_networks.empty()) {
    2592                 :             :             // When the node starts with an empty peers.dat, there are a few other sources of peers before
    2593                 :             :             // we fallback on to fixed seeds: -dnsseed, -seednode, -addnode
    2594                 :             :             // If none of those are available, we fallback on to fixed seeds immediately, else we allow
    2595                 :             :             // 60 seconds for any of those sources to populate addrman.
    2596                 :           3 :             bool add_fixed_seeds_now = false;
    2597                 :             :             // It is cheapest to check if enough time has passed first.
    2598         [ +  + ]:           3 :             if (GetTime<std::chrono::seconds>() > start + std::chrono::minutes{1}) {
    2599                 :           2 :                 add_fixed_seeds_now = true;
    2600         [ +  - ]:           2 :                 LogPrintf("Adding fixed seeds as 60 seconds have passed and addrman is empty for at least one reachable network\n");
    2601                 :             :             }
    2602                 :             : 
    2603                 :             :             // Perform cheap checks before locking a mutex.
    2604         [ +  - ]:           1 :             else if (!dnsseed && !use_seednodes) {
    2605         [ +  - ]:           1 :                 LOCK(m_added_nodes_mutex);
    2606         [ +  - ]:           1 :                 if (m_added_node_params.empty()) {
    2607                 :           1 :                     add_fixed_seeds_now = true;
    2608         [ +  - ]:           1 :                     LogPrintf("Adding fixed seeds as -dnsseed=0 (or IPv4/IPv6 connections are disabled via -onlynet) and neither -addnode nor -seednode are provided\n");
    2609                 :             :                 }
    2610                 :           0 :             }
    2611                 :             : 
    2612         [ +  - ]:           1 :             if (add_fixed_seeds_now) {
    2613         [ +  - ]:           3 :                 std::vector<CAddress> seed_addrs{ConvertSeeds(m_params.FixedSeeds())};
    2614                 :             :                 // We will not make outgoing connections to peers that are unreachable
    2615                 :             :                 // (e.g. because of -onlynet configuration).
    2616                 :             :                 // Therefore, we do not add them to addrman in the first place.
    2617                 :             :                 // In case previously unreachable networks become reachable
    2618                 :             :                 // (e.g. in case of -onlynet changes by the user), fixed seeds will
    2619                 :             :                 // be loaded only for networks for which we have no addresses.
    2620         [ +  - ]:           3 :                 seed_addrs.erase(std::remove_if(seed_addrs.begin(), seed_addrs.end(),
    2621                 :           0 :                                                 [&fixed_seed_networks](const CAddress& addr) { return fixed_seed_networks.count(addr.GetNetwork()) == 0; }),
    2622         [ +  - ]:           3 :                                  seed_addrs.end());
    2623         [ +  - ]:           3 :                 CNetAddr local;
    2624   [ +  -  +  - ]:           3 :                 local.SetInternal("fixedseeds");
    2625         [ +  - ]:           3 :                 addrman.Add(seed_addrs, local);
    2626                 :           3 :                 add_fixed_seeds = false;
    2627         [ +  - ]:           3 :                 LogPrintf("Added %d fixed seeds from reachable networks.\n", seed_addrs.size());
    2628                 :           3 :             }
    2629                 :             :         }
    2630                 :             : 
    2631                 :             :         //
    2632                 :             :         // Choose an address to connect to based on most recently seen
    2633                 :             :         //
    2634         [ +  - ]:           8 :         CAddress addrConnect;
    2635                 :             : 
    2636                 :             :         // Only connect out to one peer per ipv4/ipv6 network group (/16 for IPv4).
    2637                 :           8 :         int nOutboundFullRelay = 0;
    2638                 :           8 :         int nOutboundBlockRelay = 0;
    2639                 :           8 :         int outbound_privacy_network_peers = 0;
    2640         [ +  - ]:           8 :         std::set<std::vector<unsigned char>> outbound_ipv46_peer_netgroups;
    2641                 :             : 
    2642                 :           8 :         {
    2643         [ +  - ]:           8 :             LOCK(m_nodes_mutex);
    2644         [ +  + ]:          16 :             for (const CNode* pnode : m_nodes) {
    2645         [ -  + ]:           8 :                 if (pnode->IsFullOutboundConn()) nOutboundFullRelay++;
    2646         [ +  + ]:           8 :                 if (pnode->IsBlockOnlyConn()) nOutboundBlockRelay++;
    2647                 :             : 
    2648                 :             :                 // Make sure our persistent outbound slots to ipv4/ipv6 peers belong to different netgroups.
    2649         [ +  + ]:           8 :                 switch (pnode->m_conn_type) {
    2650                 :             :                     // We currently don't take inbound connections into account. Since they are
    2651                 :             :                     // free to make, an attacker could make them to prevent us from connecting to
    2652                 :             :                     // certain peers.
    2653                 :             :                     case ConnectionType::INBOUND:
    2654                 :             :                     // Short-lived outbound connections should not affect how we select outbound
    2655                 :             :                     // peers from addrman.
    2656                 :             :                     case ConnectionType::ADDR_FETCH:
    2657                 :             :                     case ConnectionType::FEELER:
    2658                 :             :                         break;
    2659                 :           4 :                     case ConnectionType::MANUAL:
    2660                 :           4 :                     case ConnectionType::OUTBOUND_FULL_RELAY:
    2661                 :           4 :                     case ConnectionType::BLOCK_RELAY:
    2662                 :           8 :                         const CAddress address{pnode->addr};
    2663   [ +  -  +  -  :           4 :                         if (address.IsTor() || address.IsI2P() || address.IsCJDNS()) {
                   +  - ]
    2664                 :             :                             // Since our addrman-groups for these networks are
    2665                 :             :                             // random, without relation to the route we
    2666                 :             :                             // take to connect to these peers or to the
    2667                 :             :                             // difficulty in obtaining addresses with diverse
    2668                 :             :                             // groups, we don't worry about diversity with
    2669                 :             :                             // respect to our addrman groups when connecting to
    2670                 :             :                             // these networks.
    2671                 :           0 :                             ++outbound_privacy_network_peers;
    2672                 :             :                         } else {
    2673   [ +  -  +  - ]:           8 :                             outbound_ipv46_peer_netgroups.insert(m_netgroupman.GetGroup(address));
    2674                 :             :                         }
    2675                 :             :                 } // no default case, so the compiler can warn about missing cases
    2676                 :             :             }
    2677                 :           0 :         }
    2678                 :             : 
    2679   [ +  +  +  - ]:           8 :         if (!seed_nodes.empty() && nOutboundFullRelay < SEED_OUTBOUND_CONNECTION_THRESHOLD) {
    2680         [ +  + ]:           2 :             if (NodeClock::now() > seed_node_timer + ADD_NEXT_SEEDNODE) {
    2681                 :           1 :                 seed_node_timer = NodeClock::now();
    2682                 :           1 :                 add_addr_fetch = true;
    2683                 :             :             }
    2684                 :             :         }
    2685                 :             : 
    2686                 :           8 :         ConnectionType conn_type = ConnectionType::OUTBOUND_FULL_RELAY;
    2687                 :           8 :         auto now = GetTime<std::chrono::microseconds>();
    2688                 :           8 :         bool anchor = false;
    2689                 :           8 :         bool fFeeler = false;
    2690                 :           8 :         std::optional<Network> preferred_net;
    2691                 :             : 
    2692                 :             :         // Determine what type of connection to open. Opening
    2693                 :             :         // BLOCK_RELAY connections to addresses from anchors.dat gets the highest
    2694                 :             :         // priority. Then we open OUTBOUND_FULL_RELAY priority until we
    2695                 :             :         // meet our full-relay capacity. Then we open BLOCK_RELAY connection
    2696                 :             :         // until we hit our block-relay-only peer limit.
    2697                 :             :         // GetTryNewOutboundPeer() gets set when a stale tip is detected, so we
    2698                 :             :         // try opening an additional OUTBOUND_FULL_RELAY connection. If none of
    2699                 :             :         // these conditions are met, check to see if it's time to try an extra
    2700                 :             :         // block-relay-only peer (to confirm our tip is current, see below) or the next_feeler
    2701                 :             :         // timer to decide if we should open a FEELER.
    2702                 :             : 
    2703   [ +  +  -  + ]:           8 :         if (!m_anchors.empty() && (nOutboundBlockRelay < m_max_outbound_block_relay)) {
    2704                 :             :             conn_type = ConnectionType::BLOCK_RELAY;
    2705                 :             :             anchor = true;
    2706         [ -  + ]:           7 :         } else if (nOutboundFullRelay < m_max_outbound_full_relay) {
    2707                 :             :             // OUTBOUND_FULL_RELAY
    2708         [ #  # ]:           0 :         } else if (nOutboundBlockRelay < m_max_outbound_block_relay) {
    2709                 :             :             conn_type = ConnectionType::BLOCK_RELAY;
    2710   [ #  #  #  # ]:           0 :         } else if (GetTryNewOutboundPeer()) {
    2711                 :             :             // OUTBOUND_FULL_RELAY
    2712   [ #  #  #  # ]:           0 :         } else if (now > next_extra_block_relay && m_start_extra_block_relay_peers) {
    2713                 :             :             // Periodically connect to a peer (using regular outbound selection
    2714                 :             :             // methodology from addrman) and stay connected long enough to sync
    2715                 :             :             // headers, but not much else.
    2716                 :             :             //
    2717                 :             :             // Then disconnect the peer, if we haven't learned anything new.
    2718                 :             :             //
    2719                 :             :             // The idea is to make eclipse attacks very difficult to pull off,
    2720                 :             :             // because every few minutes we're finding a new peer to learn headers
    2721                 :             :             // from.
    2722                 :             :             //
    2723                 :             :             // This is similar to the logic for trying extra outbound (full-relay)
    2724                 :             :             // peers, except:
    2725                 :             :             // - we do this all the time on an exponential timer, rather than just when
    2726                 :             :             //   our tip is stale
    2727                 :             :             // - we potentially disconnect our next-youngest block-relay-only peer, if our
    2728                 :             :             //   newest block-relay-only peer delivers a block more recently.
    2729                 :             :             //   See the eviction logic in net_processing.cpp.
    2730                 :             :             //
    2731                 :             :             // Because we can promote these connections to block-relay-only
    2732                 :             :             // connections, they do not get their own ConnectionType enum
    2733                 :             :             // (similar to how we deal with extra outbound peers).
    2734                 :           0 :             next_extra_block_relay = now + rng.rand_exp_duration(EXTRA_BLOCK_RELAY_ONLY_PEER_INTERVAL);
    2735                 :           0 :             conn_type = ConnectionType::BLOCK_RELAY;
    2736         [ #  # ]:           0 :         } else if (now > next_feeler) {
    2737                 :           0 :             next_feeler = now + rng.rand_exp_duration(FEELER_INTERVAL);
    2738                 :           0 :             conn_type = ConnectionType::FEELER;
    2739                 :           0 :             fFeeler = true;
    2740         [ #  # ]:           0 :         } else if (nOutboundFullRelay == m_max_outbound_full_relay &&
    2741         [ #  # ]:           0 :                    m_max_outbound_full_relay == MAX_OUTBOUND_FULL_RELAY_CONNECTIONS &&
    2742   [ #  #  #  #  :           0 :                    now > next_extra_network_peer &&
                   #  # ]
    2743         [ #  # ]:           0 :                    MaybePickPreferredNetwork(preferred_net)) {
    2744                 :             :             // Full outbound connection management: Attempt to get at least one
    2745                 :             :             // outbound peer from each reachable network by making extra connections
    2746                 :             :             // and then protecting "only" peers from a network during outbound eviction.
    2747                 :             :             // This is not attempted if the user changed -maxconnections to a value
    2748                 :             :             // so low that less than MAX_OUTBOUND_FULL_RELAY_CONNECTIONS are made,
    2749                 :             :             // to prevent interactions with otherwise protected outbound peers.
    2750                 :           0 :             next_extra_network_peer = now + rng.rand_exp_duration(EXTRA_NETWORK_PEER_INTERVAL);
    2751                 :             :         } else {
    2752                 :             :             // skip to next iteration of while loop
    2753                 :           0 :             continue;
    2754                 :             :         }
    2755                 :             : 
    2756         [ +  - ]:           8 :         addrman.ResolveCollisions();
    2757                 :             : 
    2758                 :           8 :         const auto current_time{NodeClock::now()};
    2759                 :           8 :         int nTries = 0;
    2760         [ +  - ]:           8 :         const auto reachable_nets{g_reachable_nets.All()};
    2761                 :             : 
    2762   [ +  -  +  - ]:         208 :         while (!interruptNet)
    2763                 :             :         {
    2764   [ +  +  -  + ]:         208 :             if (anchor && !m_anchors.empty()) {
    2765                 :           1 :                 const CAddress addr = m_anchors.back();
    2766                 :           1 :                 m_anchors.pop_back();
    2767   [ +  -  +  -  :           4 :                 if (!addr.IsValid() || IsLocal(addr) || !g_reachable_nets.Contains(addr) ||
          +  -  +  -  +  
             -  +  -  -  
                      + ]
    2768   [ +  -  +  -  :           3 :                     !m_msgproc->HasAllDesirableServiceFlags(addr.nServices) ||
                   +  - ]
    2769         [ +  - ]:           2 :                     outbound_ipv46_peer_netgroups.count(m_netgroupman.GetGroup(addr))) continue;
    2770                 :           1 :                 addrConnect = addr;
    2771   [ +  -  +  -  :           2 :                 LogDebug(BCLog::NET, "Trying to make an anchor connection to %s\n", addrConnect.ToStringAddrPort());
             +  -  +  - ]
    2772                 :           1 :                 break;
    2773                 :           1 :             }
    2774                 :             : 
    2775                 :             :             // If we didn't find an appropriate destination after trying 100 addresses fetched from addrman,
    2776                 :             :             // stop this loop, and let the outer loop run again (which sleeps, adds seed nodes, recalculates
    2777                 :             :             // already-connected network ranges, ...) before trying new addrman addresses.
    2778                 :         207 :             nTries++;
    2779         [ +  + ]:         207 :             if (nTries > 100)
    2780                 :             :                 break;
    2781                 :             : 
    2782         [ +  - ]:         205 :             CAddress addr;
    2783                 :         205 :             NodeSeconds addr_last_try{0s};
    2784                 :             : 
    2785         [ -  + ]:         205 :             if (fFeeler) {
    2786                 :             :                 // First, try to get a tried table collision address. This returns
    2787                 :             :                 // an empty (invalid) address if there are no collisions to try.
    2788         [ #  # ]:           0 :                 std::tie(addr, addr_last_try) = addrman.SelectTriedCollision();
    2789                 :             : 
    2790   [ #  #  #  # ]:           0 :                 if (!addr.IsValid()) {
    2791                 :             :                     // No tried table collisions. Select a new table address
    2792                 :             :                     // for our feeler.
    2793         [ #  # ]:           0 :                     std::tie(addr, addr_last_try) = addrman.Select(true, reachable_nets);
    2794   [ #  #  #  # ]:           0 :                 } else if (AlreadyConnectedToAddress(addr)) {
    2795                 :             :                     // If test-before-evict logic would have us connect to a
    2796                 :             :                     // peer that we're already connected to, just mark that
    2797                 :             :                     // address as Good(). We won't be able to initiate the
    2798                 :             :                     // connection anyway, so this avoids inadvertently evicting
    2799                 :             :                     // a currently-connected peer.
    2800         [ #  # ]:           0 :                     addrman.Good(addr);
    2801                 :             :                     // Select a new table address for our feeler instead.
    2802         [ #  # ]:           0 :                     std::tie(addr, addr_last_try) = addrman.Select(true, reachable_nets);
    2803                 :             :                 }
    2804                 :             :             } else {
    2805                 :             :                 // Not a feeler
    2806                 :             :                 // If preferred_net has a value set, pick an extra outbound
    2807                 :             :                 // peer from that network. The eviction logic in net_processing
    2808                 :             :                 // ensures that a peer from another network will be evicted.
    2809         [ -  + ]:         410 :                 std::tie(addr, addr_last_try) = preferred_net.has_value()
    2810   [ -  +  -  -  :         410 :                     ? addrman.Select(false, {*preferred_net})
          -  -  -  +  -  
                      - ]
    2811         [ +  - ]:         410 :                     : addrman.Select(false, reachable_nets);
    2812                 :             :             }
    2813                 :             : 
    2814                 :             :             // Require outbound IPv4/IPv6 connections, other than feelers, to be to distinct network groups
    2815   [ +  -  +  -  :         410 :             if (!fFeeler && outbound_ipv46_peer_netgroups.count(m_netgroupman.GetGroup(addr))) {
             +  +  +  + ]
    2816                 :         200 :                 continue;
    2817                 :             :             }
    2818                 :             : 
    2819                 :             :             // if we selected an invalid or local address, restart
    2820   [ +  -  +  +  :           5 :             if (!addr.IsValid() || IsLocal(addr)) {
             +  -  +  - ]
    2821                 :             :                 break;
    2822                 :             :             }
    2823                 :             : 
    2824   [ +  -  -  + ]:           2 :             if (!g_reachable_nets.Contains(addr)) {
    2825                 :           0 :                 continue;
    2826                 :             :             }
    2827                 :             : 
    2828                 :             :             // only consider very recently tried nodes after 30 failed attempts
    2829   [ -  +  -  - ]:           2 :             if (current_time - addr_last_try < 10min && nTries < 30) {
    2830                 :           0 :                 continue;
    2831                 :             :             }
    2832                 :             : 
    2833                 :             :             // for non-feelers, require all the services we'll want,
    2834                 :             :             // for feelers, only require they be a full node (only because most
    2835                 :             :             // SPV clients don't have a good address DB available)
    2836   [ +  -  +  -  :           2 :             if (!fFeeler && !m_msgproc->HasAllDesirableServiceFlags(addr.nServices)) {
                   +  - ]
    2837                 :           0 :                 continue;
    2838   [ -  +  -  - ]:           2 :             } else if (fFeeler && !MayHaveUsefulAddressDB(addr.nServices)) {
    2839                 :           0 :                 continue;
    2840                 :             :             }
    2841                 :             : 
    2842                 :             :             // Do not connect to bad ports, unless 50 invalid addresses have been selected already.
    2843   [ +  -  -  +  :           2 :             if (nTries < 50 && (addr.IsIPv4() || addr.IsIPv6()) && IsBadPort(addr.GetPort())) {
          -  -  +  -  +  
                -  +  - ]
    2844                 :           0 :                 continue;
    2845                 :             :             }
    2846                 :             : 
    2847                 :             :             // Do not make automatic outbound connections to addnode peers, to
    2848                 :             :             // not use our limited outbound slots for them and to ensure
    2849                 :             :             // addnode connections benefit from their intended protections.
    2850   [ +  -  -  + ]:           2 :             if (AddedNodesContain(addr)) {
    2851   [ #  #  #  #  :           0 :                 LogPrintLevel(BCLog::NET, BCLog::Level::Debug, "Not making automatic %s%s connection to %s peer selected for manual (addnode) connection%s\n",
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
    2852                 :             :                               preferred_net.has_value() ? "network-specific " : "",
    2853                 :             :                               ConnectionTypeAsString(conn_type), GetNetworkName(addr.GetNetwork()),
    2854                 :             :                               fLogIPs ? strprintf(": %s", addr.ToStringAddrPort()) : "");
    2855                 :           0 :                 continue;
    2856                 :             :             }
    2857                 :             : 
    2858                 :           2 :             addrConnect = addr;
    2859                 :             :             break;
    2860                 :         205 :         }
    2861                 :             : 
    2862   [ +  -  +  + ]:           8 :         if (addrConnect.IsValid()) {
    2863         [ -  + ]:           3 :             if (fFeeler) {
    2864                 :             :                 // Add small amount of random noise before connection to avoid synchronization.
    2865   [ #  #  #  # ]:           0 :                 if (!interruptNet.sleep_for(rng.rand_uniform_duration<CThreadInterrupt::Clock>(FEELER_SLEEP_WINDOW))) {
    2866                 :           0 :                     return;
    2867                 :             :                 }
    2868   [ #  #  #  #  :           0 :                 LogDebug(BCLog::NET, "Making feeler connection to %s\n", addrConnect.ToStringAddrPort());
             #  #  #  # ]
    2869                 :             :             }
    2870                 :             : 
    2871   [ -  +  -  -  :           3 :             if (preferred_net != std::nullopt) LogDebug(BCLog::NET, "Making network specific connection to %s on %s.\n", addrConnect.ToStringAddrPort(), GetNetworkName(preferred_net.value()));
          -  -  -  -  -  
             -  -  -  -  
                      - ]
    2872                 :             : 
    2873                 :             :             // Record addrman failure attempts when node has at least 2 persistent outbound connections to peers with
    2874                 :             :             // different netgroups in ipv4/ipv6 networks + all peers in Tor/I2P/CJDNS networks.
    2875                 :             :             // Don't record addrman failure attempts when node is offline. This can be identified since all local
    2876                 :             :             // network connections (if any) belong in the same netgroup, and the size of `outbound_ipv46_peer_netgroups` would only be 1.
    2877         [ -  + ]:           3 :             const bool count_failures{((int)outbound_ipv46_peer_netgroups.size() + outbound_privacy_network_peers) >= std::min(m_max_automatic_connections - 1, 2)};
    2878                 :             :             // Use BIP324 transport when both us and them have NODE_V2_P2P set.
    2879         [ +  - ]:           3 :             const bool use_v2transport(addrConnect.nServices & GetLocalServices() & NODE_P2P_V2);
    2880         [ +  - ]:           3 :             OpenNetworkConnection(addrConnect, count_failures, std::move(grant), /*strDest=*/nullptr, conn_type, use_v2transport);
    2881                 :             :         }
    2882                 :           8 :     }
    2883                 :          32 : }
    2884                 :             : 
    2885                 :          27 : std::vector<CAddress> CConnman::GetCurrentBlockRelayOnlyConns() const
    2886                 :             : {
    2887                 :          27 :     std::vector<CAddress> ret;
    2888         [ +  - ]:          27 :     LOCK(m_nodes_mutex);
    2889         [ +  + ]:          35 :     for (const CNode* pnode : m_nodes) {
    2890         [ +  + ]:           8 :         if (pnode->IsBlockOnlyConn()) {
    2891         [ +  - ]:           3 :             ret.push_back(pnode->addr);
    2892                 :             :         }
    2893                 :             :     }
    2894                 :             : 
    2895         [ +  - ]:          27 :     return ret;
    2896                 :          27 : }
    2897                 :             : 
    2898                 :        7389 : std::vector<AddedNodeInfo> CConnman::GetAddedNodeInfo(bool include_connected) const
    2899                 :             : {
    2900                 :        7389 :     std::vector<AddedNodeInfo> ret;
    2901                 :             : 
    2902         [ +  - ]:        7389 :     std::list<AddedNodeParams> lAddresses(0);
    2903                 :        7389 :     {
    2904         [ +  - ]:        7389 :         LOCK(m_added_nodes_mutex);
    2905         [ +  - ]:        7389 :         ret.reserve(m_added_node_params.size());
    2906         [ +  - ]:        7389 :         std::copy(m_added_node_params.cbegin(), m_added_node_params.cend(), std::back_inserter(lAddresses));
    2907                 :           0 :     }
    2908                 :             : 
    2909                 :             : 
    2910                 :             :     // Build a map of all already connected addresses (by IP:port and by name) to inbound/outbound and resolved CService
    2911         [ +  - ]:        7389 :     std::map<CService, bool> mapConnected;
    2912                 :        7389 :     std::map<std::string, std::pair<bool, CService>> mapConnectedByName;
    2913                 :        7389 :     {
    2914         [ +  - ]:        7389 :         LOCK(m_nodes_mutex);
    2915         [ +  + ]:       15071 :         for (const CNode* pnode : m_nodes) {
    2916   [ +  -  +  - ]:        7682 :             if (pnode->addr.IsValid()) {
    2917         [ +  - ]:        7682 :                 mapConnected[pnode->addr] = pnode->IsInboundConn();
    2918                 :             :             }
    2919         [ +  - ]:        7682 :             std::string addrName{pnode->m_addr_name};
    2920         [ +  - ]:        7682 :             if (!addrName.empty()) {
    2921         [ +  - ]:        7682 :                 mapConnectedByName[std::move(addrName)] = std::make_pair(pnode->IsInboundConn(), static_cast<const CService&>(pnode->addr));
    2922                 :             :             }
    2923                 :        7682 :         }
    2924                 :           0 :     }
    2925                 :             : 
    2926         [ +  + ]:        7422 :     for (const auto& addr : lAddresses) {
    2927   [ +  -  +  -  :          66 :         CService service{MaybeFlipIPv6toCJDNS(LookupNumeric(addr.m_added_node, GetDefaultPort(addr.m_added_node)))};
             +  -  +  - ]
    2928   [ +  -  +  - ]:          33 :         AddedNodeInfo addedNode{addr, CService(), false, false};
    2929   [ +  -  +  + ]:          33 :         if (service.IsValid()) {
    2930                 :             :             // strAddNode is an IP:port
    2931         [ +  - ]:          31 :             auto it = mapConnected.find(service);
    2932         [ +  + ]:          31 :             if (it != mapConnected.end()) {
    2933         [ +  + ]:          15 :                 if (!include_connected) {
    2934                 :           5 :                     continue;
    2935                 :             :                 }
    2936                 :          10 :                 addedNode.resolvedAddress = service;
    2937                 :          10 :                 addedNode.fConnected = true;
    2938                 :          10 :                 addedNode.fInbound = it->second;
    2939                 :             :             }
    2940                 :             :         } else {
    2941                 :             :             // strAddNode is a name
    2942                 :           2 :             auto it = mapConnectedByName.find(addr.m_added_node);
    2943         [ -  + ]:           2 :             if (it != mapConnectedByName.end()) {
    2944         [ #  # ]:           0 :                 if (!include_connected) {
    2945                 :           0 :                     continue;
    2946                 :             :                 }
    2947                 :           0 :                 addedNode.resolvedAddress = it->second.second;
    2948                 :           0 :                 addedNode.fConnected = true;
    2949                 :           0 :                 addedNode.fInbound = it->second.first;
    2950                 :             :             }
    2951                 :             :         }
    2952         [ +  - ]:          28 :         ret.emplace_back(std::move(addedNode));
    2953                 :          33 :     }
    2954                 :             : 
    2955                 :        7389 :     return ret;
    2956                 :        7389 : }
    2957                 :             : 
    2958                 :         928 : void CConnman::ThreadOpenAddedConnections()
    2959                 :             : {
    2960                 :         928 :     AssertLockNotHeld(m_unused_i2p_sessions_mutex);
    2961                 :         928 :     AssertLockNotHeld(m_reconnections_mutex);
    2962                 :       13820 :     while (true)
    2963                 :             :     {
    2964                 :        7374 :         CSemaphoreGrant grant(*semAddnode);
    2965         [ +  - ]:        7374 :         std::vector<AddedNodeInfo> vInfo = GetAddedNodeInfo(/*include_connected=*/false);
    2966                 :        7374 :         bool tried = false;
    2967         [ +  + ]:        7377 :         for (const AddedNodeInfo& info : vInfo) {
    2968         [ +  - ]:           4 :             if (!grant) {
    2969                 :             :                 // If we've used up our semaphore and need a new one, let's not wait here since while we are waiting
    2970                 :             :                 // the addednodeinfo state might change.
    2971                 :             :                 break;
    2972                 :             :             }
    2973                 :           4 :             tried = true;
    2974         [ +  - ]:           4 :             CAddress addr(CService(), NODE_NONE);
    2975         [ +  - ]:           4 :             OpenNetworkConnection(addr, false, std::move(grant), info.m_params.m_added_node.c_str(), ConnectionType::MANUAL, info.m_params.m_use_v2transport);
    2976   [ +  -  +  + ]:           4 :             if (!interruptNet.sleep_for(std::chrono::milliseconds(500))) return;
    2977                 :           3 :             grant = CSemaphoreGrant(*semAddnode, /*fTry=*/true);
    2978                 :           4 :         }
    2979                 :             :         // See if any reconnections are desired.
    2980         [ +  - ]:        7373 :         PerformReconnections();
    2981                 :             :         // Retry every 60 seconds if a connection was attempted, otherwise two seconds
    2982   [ +  +  +  -  :       14743 :         if (!interruptNet.sleep_for(std::chrono::seconds(tried ? 60 : 2)))
                   +  + ]
    2983                 :             :             return;
    2984                 :        7374 :     }
    2985                 :             : }
    2986                 :             : 
    2987                 :             : // if successful, this moves the passed grant to the constructed node
    2988                 :         609 : void CConnman::OpenNetworkConnection(const CAddress& addrConnect, bool fCountFailure, CSemaphoreGrant&& grant_outbound, const char *pszDest, ConnectionType conn_type, bool use_v2transport)
    2989                 :             : {
    2990                 :         609 :     AssertLockNotHeld(m_unused_i2p_sessions_mutex);
    2991         [ -  + ]:         609 :     assert(conn_type != ConnectionType::INBOUND);
    2992                 :             : 
    2993                 :             :     //
    2994                 :             :     // Initiate outbound network connection
    2995                 :             :     //
    2996         [ +  - ]:         609 :     if (interruptNet) {
    2997                 :             :         return;
    2998                 :             :     }
    2999         [ +  - ]:         609 :     if (!fNetworkActive) {
    3000                 :             :         return;
    3001                 :             :     }
    3002         [ +  + ]:         609 :     if (!pszDest) {
    3003   [ +  -  +  -  :           3 :         bool banned_or_discouraged = m_banman && (m_banman->IsDiscouraged(addrConnect) || m_banman->IsBanned(addrConnect));
                   -  + ]
    3004   [ +  -  +  -  :           3 :         if (IsLocal(addrConnect) || banned_or_discouraged || AlreadyConnectedToAddress(addrConnect)) {
                   -  + ]
    3005                 :           0 :             return;
    3006                 :             :         }
    3007   [ +  -  +  - ]:         606 :     } else if (FindNode(std::string(pszDest)))
    3008                 :             :         return;
    3009                 :             : 
    3010         [ +  - ]:         609 :     CNode* pnode = ConnectNode(addrConnect, pszDest, fCountFailure, conn_type, use_v2transport);
    3011                 :             : 
    3012         [ +  + ]:         609 :     if (!pnode)
    3013                 :             :         return;
    3014                 :         588 :     pnode->grantOutbound = std::move(grant_outbound);
    3015                 :             : 
    3016                 :         588 :     m_msgproc->InitializeNode(*pnode, m_local_services);
    3017                 :         588 :     {
    3018                 :         588 :         LOCK(m_nodes_mutex);
    3019         [ +  - ]:         588 :         m_nodes.push_back(pnode);
    3020                 :             : 
    3021                 :             :         // update connection count by network
    3022   [ +  +  +  - ]:         588 :         if (pnode->IsManualOrFullOutboundConn()) ++m_network_conn_counts[pnode->addr.GetNetwork()];
    3023                 :         588 :     }
    3024                 :             : 
    3025                 :             :     TRACEPOINT(net, outbound_connection,
    3026                 :             :         pnode->GetId(),
    3027                 :             :         pnode->m_addr_name.c_str(),
    3028                 :             :         pnode->ConnectionTypeAsString().c_str(),
    3029                 :             :         pnode->ConnectedThroughNetwork(),
    3030                 :         609 :         GetNodeCount(ConnectionDirection::Out));
    3031                 :             : }
    3032                 :             : 
    3033                 :             : Mutex NetEventsInterface::g_msgproc_mutex;
    3034                 :             : 
    3035                 :         928 : void CConnman::ThreadMessageHandler()
    3036                 :             : {
    3037                 :         928 :     LOCK(NetEventsInterface::g_msgproc_mutex);
    3038                 :             : 
    3039         [ +  + ]:      297965 :     while (!flagInterruptMsgProc)
    3040                 :             :     {
    3041                 :      296114 :         bool fMoreWork = false;
    3042                 :             : 
    3043                 :      296114 :         {
    3044                 :             :             // Randomize the order in which we process messages from/to our peers.
    3045                 :             :             // This prevents attacks in which an attacker exploits having multiple
    3046                 :             :             // consecutive connections in the m_nodes list.
    3047         [ +  - ]:      296114 :             const NodesSnapshot snap{*this, /*shuffle=*/true};
    3048                 :             : 
    3049         [ +  + ]:      690758 :             for (CNode* pnode : snap.Nodes()) {
    3050         [ +  + ]:      394649 :                 if (pnode->fDisconnect)
    3051                 :          77 :                     continue;
    3052                 :             : 
    3053                 :             :                 // Receive messages
    3054         [ +  - ]:      394572 :                 bool fMoreNodeWork = m_msgproc->ProcessMessages(pnode, flagInterruptMsgProc);
    3055   [ +  +  -  + ]:      394572 :                 fMoreWork |= (fMoreNodeWork && !pnode->fPauseSend);
    3056         [ +  + ]:      394572 :                 if (flagInterruptMsgProc)
    3057                 :             :                     return;
    3058                 :             :                 // Send messages
    3059         [ +  - ]:      394567 :                 m_msgproc->SendMessages(pnode);
    3060                 :             : 
    3061         [ +  - ]:      394567 :                 if (flagInterruptMsgProc)
    3062                 :             :                     return;
    3063                 :             :             }
    3064         [ +  - ]:      296114 :         }
    3065                 :             : 
    3066         [ +  - ]:      296109 :         WAIT_LOCK(mutexMsgProc, lock);
    3067         [ +  + ]:      296109 :         if (!fMoreWork) {
    3068   [ +  +  +  - ]:      631593 :             condMsgProc.wait_until(lock, std::chrono::steady_clock::now() + std::chrono::milliseconds(100), [this]() EXCLUSIVE_LOCKS_REQUIRED(mutexMsgProc) { return fMsgProcWake; });
    3069                 :             :         }
    3070         [ +  - ]:      296109 :         fMsgProcWake = false;
    3071                 :      296109 :     }
    3072                 :         928 : }
    3073                 :             : 
    3074                 :           4 : void CConnman::ThreadI2PAcceptIncoming()
    3075                 :             : {
    3076                 :           4 :     static constexpr auto err_wait_begin = 1s;
    3077                 :           4 :     static constexpr auto err_wait_cap = 5min;
    3078                 :           4 :     auto err_wait = err_wait_begin;
    3079                 :             : 
    3080                 :           4 :     bool advertising_listen_addr = false;
    3081                 :           4 :     i2p::Connection conn;
    3082                 :             : 
    3083                 :           8 :     auto SleepOnFailure = [&]() {
    3084                 :           4 :         interruptNet.sleep_for(err_wait);
    3085         [ +  - ]:           4 :         if (err_wait < err_wait_cap) {
    3086                 :           4 :             err_wait += 1s;
    3087                 :             :         }
    3088                 :           8 :     };
    3089                 :             : 
    3090   [ +  -  +  + ]:           8 :     while (!interruptNet) {
    3091                 :             : 
    3092   [ +  -  +  - ]:           4 :         if (!m_i2p_sam_session->Listen(conn)) {
    3093   [ -  +  -  -  :           4 :             if (advertising_listen_addr && conn.me.IsValid()) {
                   -  - ]
    3094         [ #  # ]:           0 :                 RemoveLocal(conn.me);
    3095                 :             :                 advertising_listen_addr = false;
    3096                 :             :             }
    3097         [ +  - ]:           4 :             SleepOnFailure();
    3098                 :           4 :             continue;
    3099                 :             :         }
    3100                 :             : 
    3101         [ #  # ]:           0 :         if (!advertising_listen_addr) {
    3102         [ #  # ]:           0 :             AddLocal(conn.me, LOCAL_MANUAL);
    3103                 :             :             advertising_listen_addr = true;
    3104                 :             :         }
    3105                 :             : 
    3106   [ #  #  #  # ]:           0 :         if (!m_i2p_sam_session->Accept(conn)) {
    3107         [ #  # ]:           0 :             SleepOnFailure();
    3108                 :           0 :             continue;
    3109                 :             :         }
    3110                 :             : 
    3111         [ #  # ]:           0 :         CreateNodeFromAcceptedSocket(std::move(conn.sock), NetPermissionFlags::None, conn.me, conn.peer);
    3112                 :             : 
    3113                 :           0 :         err_wait = err_wait_begin;
    3114                 :             :     }
    3115                 :           4 : }
    3116                 :             : 
    3117                 :         930 : bool CConnman::BindListenPort(const CService& addrBind, bilingual_str& strError, NetPermissionFlags permissions)
    3118                 :             : {
    3119                 :         930 :     int nOne = 1;
    3120                 :             : 
    3121                 :             :     // Create socket for listening for incoming connections
    3122                 :         930 :     struct sockaddr_storage sockaddr;
    3123                 :         930 :     socklen_t len = sizeof(sockaddr);
    3124         [ -  + ]:         930 :     if (!addrBind.GetSockAddr((struct sockaddr*)&sockaddr, &len))
    3125                 :             :     {
    3126   [ #  #  #  # ]:           0 :         strError = Untranslated(strprintf("Bind address family for %s not supported", addrBind.ToStringAddrPort()));
    3127         [ #  # ]:           0 :         LogPrintLevel(BCLog::NET, BCLog::Level::Error, "%s\n", strError.original);
    3128                 :           0 :         return false;
    3129                 :             :     }
    3130                 :             : 
    3131                 :         930 :     std::unique_ptr<Sock> sock = CreateSock(addrBind.GetSAFamily(), SOCK_STREAM, IPPROTO_TCP);
    3132         [ -  + ]:         930 :     if (!sock) {
    3133   [ #  #  #  #  :           0 :         strError = Untranslated(strprintf("Couldn't open socket for incoming connections (socket returned error %s)", NetworkErrorString(WSAGetLastError())));
                   #  # ]
    3134   [ #  #  #  #  :           0 :         LogPrintLevel(BCLog::NET, BCLog::Level::Error, "%s\n", strError.original);
                   #  # ]
    3135                 :           0 :         return false;
    3136                 :             :     }
    3137                 :             : 
    3138                 :             :     // Allow binding if the port is still in TIME_WAIT state after
    3139                 :             :     // the program was closed and restarted.
    3140   [ +  -  -  + ]:         930 :     if (sock->SetSockOpt(SOL_SOCKET, SO_REUSEADDR, (sockopt_arg_type)&nOne, sizeof(int)) == SOCKET_ERROR) {
    3141   [ #  #  #  #  :           0 :         strError = Untranslated(strprintf("Error setting SO_REUSEADDR on socket: %s, continuing anyway", NetworkErrorString(WSAGetLastError())));
                   #  # ]
    3142         [ #  # ]:           0 :         LogPrintf("%s\n", strError.original);
    3143                 :             :     }
    3144                 :             : 
    3145                 :             :     // some systems don't have IPV6_V6ONLY but are always v6only; others do have the option
    3146                 :             :     // and enable it by default or not. Try to enable it, if possible.
    3147         [ +  + ]:         930 :     if (addrBind.IsIPv6()) {
    3148                 :             : #ifdef IPV6_V6ONLY
    3149   [ +  -  -  + ]:           2 :         if (sock->SetSockOpt(IPPROTO_IPV6, IPV6_V6ONLY, (sockopt_arg_type)&nOne, sizeof(int)) == SOCKET_ERROR) {
    3150   [ #  #  #  #  :           0 :             strError = Untranslated(strprintf("Error setting IPV6_V6ONLY on socket: %s, continuing anyway", NetworkErrorString(WSAGetLastError())));
                   #  # ]
    3151         [ #  # ]:           0 :             LogPrintf("%s\n", strError.original);
    3152                 :             :         }
    3153                 :             : #endif
    3154                 :             : #ifdef WIN32
    3155                 :             :         int nProtLevel = PROTECTION_LEVEL_UNRESTRICTED;
    3156                 :             :         if (sock->SetSockOpt(IPPROTO_IPV6, IPV6_PROTECTION_LEVEL, (const char*)&nProtLevel, sizeof(int)) == SOCKET_ERROR) {
    3157                 :             :             strError = Untranslated(strprintf("Error setting IPV6_PROTECTION_LEVEL on socket: %s, continuing anyway", NetworkErrorString(WSAGetLastError())));
    3158                 :             :             LogPrintf("%s\n", strError.original);
    3159                 :             :         }
    3160                 :             : #endif
    3161                 :             :     }
    3162                 :             : 
    3163   [ +  -  -  + ]:         930 :     if (sock->Bind(reinterpret_cast<struct sockaddr*>(&sockaddr), len) == SOCKET_ERROR) {
    3164                 :           0 :         int nErr = WSAGetLastError();
    3165         [ #  # ]:           0 :         if (nErr == WSAEADDRINUSE)
    3166   [ #  #  #  # ]:           0 :             strError = strprintf(_("Unable to bind to %s on this computer. %s is probably already running."), addrBind.ToStringAddrPort(), CLIENT_NAME);
    3167                 :             :         else
    3168   [ #  #  #  #  :           0 :             strError = strprintf(_("Unable to bind to %s on this computer (bind returned error %s)"), addrBind.ToStringAddrPort(), NetworkErrorString(nErr));
                   #  # ]
    3169   [ #  #  #  #  :           0 :         LogPrintLevel(BCLog::NET, BCLog::Level::Error, "%s\n", strError.original);
                   #  # ]
    3170                 :           0 :         return false;
    3171                 :             :     }
    3172   [ +  -  +  - ]:         930 :     LogPrintf("Bound to %s\n", addrBind.ToStringAddrPort());
    3173                 :             : 
    3174                 :             :     // Listen for incoming connections
    3175   [ +  -  -  + ]:         930 :     if (sock->Listen(SOMAXCONN) == SOCKET_ERROR)
    3176                 :             :     {
    3177   [ #  #  #  # ]:           0 :         strError = strprintf(_("Listening for incoming connections failed (listen returned error %s)"), NetworkErrorString(WSAGetLastError()));
    3178   [ #  #  #  #  :           0 :         LogPrintLevel(BCLog::NET, BCLog::Level::Error, "%s\n", strError.original);
                   #  # ]
    3179                 :           0 :         return false;
    3180                 :             :     }
    3181                 :             : 
    3182         [ +  - ]:         930 :     vhListenSocket.emplace_back(std::move(sock), permissions);
    3183                 :             :     return true;
    3184                 :         930 : }
    3185                 :             : 
    3186                 :          15 : void Discover()
    3187                 :             : {
    3188         [ -  + ]:          15 :     if (!fDiscover)
    3189                 :             :         return;
    3190                 :             : 
    3191         [ #  # ]:           0 :     for (const CNetAddr &addr: GetLocalAddresses()) {
    3192   [ #  #  #  # ]:           0 :         if (AddLocal(addr, LOCAL_IF))
    3193   [ #  #  #  # ]:           0 :             LogPrintf("%s: %s\n", __func__, addr.ToStringAddr());
    3194                 :           0 :     }
    3195                 :             : }
    3196                 :             : 
    3197                 :        1182 : void CConnman::SetNetworkActive(bool active)
    3198                 :             : {
    3199                 :        1182 :     LogPrintf("%s: %s\n", __func__, active);
    3200                 :             : 
    3201         [ +  + ]:        1182 :     if (fNetworkActive == active) {
    3202                 :             :         return;
    3203                 :             :     }
    3204                 :             : 
    3205         [ +  + ]:          26 :     fNetworkActive = active;
    3206                 :             : 
    3207         [ +  + ]:          26 :     if (m_client_interface) {
    3208                 :          21 :         m_client_interface->NotifyNetworkActiveChanged(fNetworkActive);
    3209                 :             :     }
    3210                 :             : }
    3211                 :             : 
    3212                 :        1159 : CConnman::CConnman(uint64_t nSeed0In, uint64_t nSeed1In, AddrMan& addrman_in,
    3213                 :        1159 :                    const NetGroupManager& netgroupman, const CChainParams& params, bool network_active)
    3214                 :        1159 :     : addrman(addrman_in)
    3215         [ +  - ]:        1159 :     , m_netgroupman{netgroupman}
    3216                 :        1159 :     , nSeed0(nSeed0In)
    3217                 :        1159 :     , nSeed1(nSeed1In)
    3218   [ +  -  +  -  :        1159 :     , m_params(params)
             +  -  +  - ]
    3219                 :             : {
    3220         [ +  - ]:        1159 :     SetTryNewOutboundPeer(false);
    3221                 :             : 
    3222                 :        1159 :     Options connOptions;
    3223         [ +  - ]:        1159 :     Init(connOptions);
    3224         [ +  - ]:        1159 :     SetNetworkActive(network_active);
    3225                 :        1159 : }
    3226                 :             : 
    3227                 :        1547 : NodeId CConnman::GetNewNodeId()
    3228                 :             : {
    3229                 :        1547 :     return nLastNodeId.fetch_add(1, std::memory_order_relaxed);
    3230                 :             : }
    3231                 :             : 
    3232                 :           2 : uint16_t CConnman::GetDefaultPort(Network net) const
    3233                 :             : {
    3234         [ -  + ]:           2 :     return net == NET_I2P ? I2P_SAM31_PORT : m_params.GetDefaultPort();
    3235                 :             : }
    3236                 :             : 
    3237                 :         680 : uint16_t CConnman::GetDefaultPort(const std::string& addr) const
    3238                 :             : {
    3239                 :         680 :     CNetAddr a;
    3240   [ +  -  +  +  :         680 :     return a.SetSpecial(addr) ? GetDefaultPort(a.GetNetwork()) : m_params.GetDefaultPort();
             +  -  +  - ]
    3241                 :         680 : }
    3242                 :             : 
    3243                 :         930 : bool CConnman::Bind(const CService& addr_, unsigned int flags, NetPermissionFlags permissions)
    3244                 :             : {
    3245                 :         930 :     const CService addr{MaybeFlipIPv6toCJDNS(addr_)};
    3246                 :             : 
    3247         [ +  - ]:         930 :     bilingual_str strError;
    3248   [ +  -  -  + ]:         930 :     if (!BindListenPort(addr, strError, permissions)) {
    3249   [ #  #  #  # ]:           0 :         if ((flags & BF_REPORT_ERROR) && m_client_interface) {
    3250   [ #  #  #  # ]:           0 :             m_client_interface->ThreadSafeMessageBox(strError, "", CClientUIInterface::MSG_ERROR);
    3251                 :             :         }
    3252                 :           0 :         return false;
    3253                 :             :     }
    3254                 :             : 
    3255   [ +  -  -  +  :         930 :     if (addr.IsRoutable() && fDiscover && !(flags & BF_DONT_ADVERTISE) && !NetPermissions::HasFlag(permissions, NetPermissionFlags::NoBan)) {
          -  -  -  -  -  
                      - ]
    3256         [ #  # ]:           0 :         AddLocal(addr, LOCAL_BIND);
    3257                 :             :     }
    3258                 :             : 
    3259                 :             :     return true;
    3260                 :         930 : }
    3261                 :             : 
    3262                 :         915 : bool CConnman::InitBinds(const Options& options)
    3263                 :             : {
    3264         [ +  + ]:        1825 :     for (const auto& addrBind : options.vBinds) {
    3265         [ +  - ]:         910 :         if (!Bind(addrBind, BF_REPORT_ERROR, NetPermissionFlags::None)) {
    3266                 :             :             return false;
    3267                 :             :         }
    3268                 :             :     }
    3269         [ +  + ]:         916 :     for (const auto& addrBind : options.vWhiteBinds) {
    3270         [ +  - ]:           1 :         if (!Bind(addrBind.m_service, BF_REPORT_ERROR, addrBind.m_flags)) {
    3271                 :             :             return false;
    3272                 :             :         }
    3273                 :             :     }
    3274         [ +  + ]:         930 :     for (const auto& addr_bind : options.onion_binds) {
    3275         [ +  - ]:          15 :         if (!Bind(addr_bind, BF_REPORT_ERROR | BF_DONT_ADVERTISE, NetPermissionFlags::None)) {
    3276                 :             :             return false;
    3277                 :             :         }
    3278                 :             :     }
    3279         [ +  + ]:         915 :     if (options.bind_on_any) {
    3280                 :             :         // Don't consider errors to bind on IPv6 "::" fatal because the host OS
    3281                 :             :         // may not have IPv6 support and the user did not explicitly ask us to
    3282                 :             :         // bind on that.
    3283                 :           2 :         const CService ipv6_any{in6_addr(IN6ADDR_ANY_INIT), GetListenPort()}; // ::
    3284         [ +  - ]:           2 :         Bind(ipv6_any, BF_NONE, NetPermissionFlags::None);
    3285                 :             : 
    3286                 :           2 :         struct in_addr inaddr_any;
    3287                 :           2 :         inaddr_any.s_addr = htonl(INADDR_ANY);
    3288   [ +  -  +  - ]:           2 :         const CService ipv4_any{inaddr_any, GetListenPort()}; // 0.0.0.0
    3289   [ +  -  -  + ]:           2 :         if (!Bind(ipv4_any, BF_REPORT_ERROR, NetPermissionFlags::None)) {
    3290                 :           0 :             return false;
    3291                 :             :         }
    3292                 :           2 :     }
    3293                 :             :     return true;
    3294                 :             : }
    3295                 :             : 
    3296                 :         928 : bool CConnman::Start(CScheduler& scheduler, const Options& connOptions)
    3297                 :             : {
    3298                 :         928 :     AssertLockNotHeld(m_total_bytes_sent_mutex);
    3299                 :         928 :     Init(connOptions);
    3300                 :             : 
    3301   [ +  +  -  + ]:         928 :     if (fListen && !InitBinds(connOptions)) {
    3302         [ #  # ]:           0 :         if (m_client_interface) {
    3303         [ #  # ]:           0 :             m_client_interface->ThreadSafeMessageBox(
    3304         [ #  # ]:           0 :                 _("Failed to listen on any port. Use -listen=0 if you want this."),
    3305                 :             :                 "", CClientUIInterface::MSG_ERROR);
    3306                 :             :         }
    3307                 :           0 :         return false;
    3308                 :             :     }
    3309                 :             : 
    3310                 :         928 :     Proxy i2p_sam;
    3311   [ +  -  +  +  :         928 :     if (GetProxy(NET_I2P, i2p_sam) && connOptions.m_i2p_accept_incoming) {
                   +  + ]
    3312   [ +  -  +  - ]:          20 :         m_i2p_sam_session = std::make_unique<i2p::sam::Session>(gArgs.GetDataDirNet() / "i2p_private_key",
    3313         [ +  - ]:           8 :                                                                 i2p_sam, &interruptNet);
    3314                 :             :     }
    3315                 :             : 
    3316                 :             :     // Randomize the order in which we may query seednode to potentially prevent connecting to the same one every restart (and signal that we have restarted)
    3317         [ +  - ]:         928 :     std::vector<std::string> seed_nodes = connOptions.vSeedNodes;
    3318         [ +  + ]:         928 :     if (!seed_nodes.empty()) {
    3319                 :           5 :         std::shuffle(seed_nodes.begin(), seed_nodes.end(), FastRandomContext{});
    3320                 :             :     }
    3321                 :             : 
    3322         [ +  + ]:         928 :     if (m_use_addrman_outgoing) {
    3323                 :             :         // Load addresses from anchors.dat
    3324   [ +  -  +  -  :          81 :         m_anchors = ReadAnchors(gArgs.GetDataDirNet() / ANCHORS_DATABASE_FILENAME);
                   +  - ]
    3325         [ -  + ]:          27 :         if (m_anchors.size() > MAX_BLOCK_RELAY_ONLY_ANCHORS) {
    3326         [ #  # ]:           0 :             m_anchors.resize(MAX_BLOCK_RELAY_ONLY_ANCHORS);
    3327                 :             :         }
    3328         [ +  - ]:          27 :         LogPrintf("%i block-relay-only anchors will be tried for connections.\n", m_anchors.size());
    3329                 :             :     }
    3330                 :             : 
    3331         [ +  - ]:         928 :     if (m_client_interface) {
    3332   [ +  -  +  - ]:        1856 :         m_client_interface->InitMessage(_("Starting network threads…"));
    3333                 :             :     }
    3334                 :             : 
    3335                 :         928 :     fAddressesInitialized = true;
    3336                 :             : 
    3337         [ +  - ]:         928 :     if (semOutbound == nullptr) {
    3338                 :             :         // initialize semaphore
    3339   [ +  +  +  - ]:         929 :         semOutbound = std::make_unique<CSemaphore>(std::min(m_max_automatic_outbound, m_max_automatic_connections));
    3340                 :             :     }
    3341         [ +  - ]:         928 :     if (semAddnode == nullptr) {
    3342                 :             :         // initialize semaphore
    3343         [ +  - ]:         928 :         semAddnode = std::make_unique<CSemaphore>(m_max_addnode);
    3344                 :             :     }
    3345                 :             : 
    3346                 :             :     //
    3347                 :             :     // Start threads
    3348                 :             :     //
    3349         [ -  + ]:         928 :     assert(m_msgproc);
    3350         [ +  - ]:         928 :     interruptNet.reset();
    3351         [ +  - ]:         928 :     flagInterruptMsgProc = false;
    3352                 :             : 
    3353                 :         928 :     {
    3354         [ +  - ]:         928 :         LOCK(mutexMsgProc);
    3355         [ +  - ]:         928 :         fMsgProcWake = false;
    3356                 :         928 :     }
    3357                 :             : 
    3358                 :             :     // Send and receive from sockets, accept connections
    3359         [ +  - ]:        1856 :     threadSocketHandler = std::thread(&util::TraceThread, "net", [this] { ThreadSocketHandler(); });
    3360                 :             : 
    3361   [ +  -  +  -  :         928 :     if (!gArgs.GetBoolArg("-dnsseed", DEFAULT_DNSSEED))
                   +  + ]
    3362         [ +  - ]:         915 :         LogPrintf("DNS seeding disabled\n");
    3363                 :             :     else
    3364         [ +  - ]:          26 :         threadDNSAddressSeed = std::thread(&util::TraceThread, "dnsseed", [this] { ThreadDNSAddressSeed(); });
    3365                 :             : 
    3366                 :             :     // Initiate manual connections
    3367         [ +  - ]:        1856 :     threadOpenAddedConnections = std::thread(&util::TraceThread, "addcon", [this] { ThreadOpenAddedConnections(); });
    3368                 :             : 
    3369   [ +  +  +  - ]:         928 :     if (connOptions.m_use_addrman_outgoing && !connOptions.m_specified_outgoing.empty()) {
    3370         [ #  # ]:           0 :         if (m_client_interface) {
    3371   [ #  #  #  # ]:           0 :             m_client_interface->ThreadSafeMessageBox(
    3372         [ #  # ]:           0 :                 _("Cannot provide specific connections and have addrman find outgoing connections at the same time."),
    3373                 :             :                 "", CClientUIInterface::MSG_ERROR);
    3374                 :             :         }
    3375                 :           0 :         return false;
    3376                 :             :     }
    3377   [ +  +  +  + ]:         928 :     if (connOptions.m_use_addrman_outgoing || !connOptions.m_specified_outgoing.empty()) {
    3378                 :          32 :         threadOpenConnections = std::thread(
    3379         [ +  - ]:          32 :             &util::TraceThread, "opencon",
    3380   [ +  -  +  -  :         128 :             [this, connect = connOptions.m_specified_outgoing, seed_nodes = std::move(seed_nodes)] { ThreadOpenConnections(connect, seed_nodes); });
                   +  - ]
    3381                 :             :     }
    3382                 :             : 
    3383                 :             :     // Process messages
    3384         [ +  - ]:        1856 :     threadMessageHandler = std::thread(&util::TraceThread, "msghand", [this] { ThreadMessageHandler(); });
    3385                 :             : 
    3386         [ +  + ]:         928 :     if (m_i2p_sam_session) {
    3387                 :           4 :         threadI2PAcceptIncoming =
    3388         [ +  - ]:           8 :             std::thread(&util::TraceThread, "i2paccept", [this] { ThreadI2PAcceptIncoming(); });
    3389                 :             :     }
    3390                 :             : 
    3391                 :             :     // Dump network addresses
    3392         [ +  - ]:         939 :     scheduler.scheduleEvery([this] { DumpAddresses(); }, DUMP_PEERS_INTERVAL);
    3393                 :             : 
    3394                 :             :     // Run the ASMap Health check once and then schedule it to run every 24h.
    3395   [ +  -  +  + ]:         928 :     if (m_netgroupman.UsingASMap()) {
    3396         [ +  - ]:           7 :         ASMapHealthCheck();
    3397         [ +  - ]:          14 :         scheduler.scheduleEvery([this] { ASMapHealthCheck(); }, ASMAP_HEALTH_CHECK_INTERVAL);
    3398                 :             :     }
    3399                 :             : 
    3400                 :             :     return true;
    3401                 :        1856 : }
    3402                 :             : 
    3403                 :             : class CNetCleanup
    3404                 :             : {
    3405                 :             : public:
    3406                 :             :     CNetCleanup() = default;
    3407                 :             : 
    3408                 :        1234 :     ~CNetCleanup()
    3409                 :             :     {
    3410                 :             : #ifdef WIN32
    3411                 :             :         // Shutdown Windows Sockets
    3412                 :             :         WSACleanup();
    3413                 :             : #endif
    3414                 :        1234 :     }
    3415                 :             : };
    3416                 :             : static CNetCleanup instance_of_cnetcleanup;
    3417                 :             : 
    3418                 :        2142 : void CConnman::Interrupt()
    3419                 :             : {
    3420                 :        2142 :     {
    3421                 :        2142 :         LOCK(mutexMsgProc);
    3422         [ +  - ]:        2142 :         flagInterruptMsgProc = true;
    3423                 :        2142 :     }
    3424                 :        2142 :     condMsgProc.notify_all();
    3425                 :             : 
    3426                 :        2142 :     interruptNet();
    3427                 :        2142 :     g_socks5_interrupt();
    3428                 :             : 
    3429         [ +  + ]:        2142 :     if (semOutbound) {
    3430         [ +  + ]:       11126 :         for (int i=0; i<m_max_automatic_outbound; i++) {
    3431                 :       10198 :             semOutbound->post();
    3432                 :             :         }
    3433                 :             :     }
    3434                 :             : 
    3435         [ +  + ]:        2142 :     if (semAddnode) {
    3436         [ +  + ]:        8352 :         for (int i=0; i<m_max_addnode; i++) {
    3437                 :        7424 :             semAddnode->post();
    3438                 :             :         }
    3439                 :             :     }
    3440                 :        2142 : }
    3441                 :             : 
    3442                 :        2142 : void CConnman::StopThreads()
    3443                 :             : {
    3444         [ +  + ]:        2142 :     if (threadI2PAcceptIncoming.joinable()) {
    3445                 :           4 :         threadI2PAcceptIncoming.join();
    3446                 :             :     }
    3447         [ +  + ]:        2142 :     if (threadMessageHandler.joinable())
    3448                 :         928 :         threadMessageHandler.join();
    3449         [ +  + ]:        2142 :     if (threadOpenConnections.joinable())
    3450                 :          32 :         threadOpenConnections.join();
    3451         [ +  + ]:        2142 :     if (threadOpenAddedConnections.joinable())
    3452                 :         928 :         threadOpenAddedConnections.join();
    3453         [ +  + ]:        2142 :     if (threadDNSAddressSeed.joinable())
    3454                 :          13 :         threadDNSAddressSeed.join();
    3455         [ +  + ]:        2142 :     if (threadSocketHandler.joinable())
    3456                 :         928 :         threadSocketHandler.join();
    3457                 :        2142 : }
    3458                 :             : 
    3459                 :        2142 : void CConnman::StopNodes()
    3460                 :             : {
    3461         [ +  + ]:        2142 :     if (fAddressesInitialized) {
    3462                 :         928 :         DumpAddresses();
    3463                 :         928 :         fAddressesInitialized = false;
    3464                 :             : 
    3465         [ +  + ]:         928 :         if (m_use_addrman_outgoing) {
    3466                 :             :             // Anchor connections are only dumped during clean shutdown.
    3467                 :          27 :             std::vector<CAddress> anchors_to_dump = GetCurrentBlockRelayOnlyConns();
    3468         [ -  + ]:          27 :             if (anchors_to_dump.size() > MAX_BLOCK_RELAY_ONLY_ANCHORS) {
    3469         [ #  # ]:           0 :                 anchors_to_dump.resize(MAX_BLOCK_RELAY_ONLY_ANCHORS);
    3470                 :             :             }
    3471   [ +  -  +  -  :          81 :             DumpAnchors(gArgs.GetDataDirNet() / ANCHORS_DATABASE_FILENAME, anchors_to_dump);
                   +  - ]
    3472                 :          27 :         }
    3473                 :             :     }
    3474                 :             : 
    3475                 :             :     // Delete peer connections.
    3476                 :        2142 :     std::vector<CNode*> nodes;
    3477   [ +  -  +  - ]:        4284 :     WITH_LOCK(m_nodes_mutex, nodes.swap(m_nodes));
    3478         [ +  + ]:        2872 :     for (CNode* pnode : nodes) {
    3479   [ +  -  +  -  :        1460 :         LogDebug(BCLog::NET, "Stopping node, %s", pnode->DisconnectMsg(fLogIPs));
             +  -  +  - ]
    3480         [ +  - ]:         730 :         pnode->CloseSocketDisconnect();
    3481         [ +  - ]:         730 :         DeleteNode(pnode);
    3482                 :             :     }
    3483                 :             : 
    3484         [ -  + ]:        2142 :     for (CNode* pnode : m_nodes_disconnected) {
    3485         [ #  # ]:           0 :         DeleteNode(pnode);
    3486                 :             :     }
    3487                 :        2142 :     m_nodes_disconnected.clear();
    3488                 :        2142 :     vhListenSocket.clear();
    3489         [ +  + ]:        2142 :     semOutbound.reset();
    3490         [ +  + ]:        3070 :     semAddnode.reset();
    3491                 :        2142 : }
    3492                 :             : 
    3493                 :        1547 : void CConnman::DeleteNode(CNode* pnode)
    3494                 :             : {
    3495         [ -  + ]:        1547 :     assert(pnode);
    3496                 :        1547 :     m_msgproc->FinalizeNode(*pnode);
    3497                 :        1547 :     delete pnode;
    3498                 :        1547 : }
    3499                 :             : 
    3500                 :        1159 : CConnman::~CConnman()
    3501                 :             : {
    3502                 :        1159 :     Interrupt();
    3503                 :        1159 :     Stop();
    3504                 :        1159 : }
    3505                 :             : 
    3506                 :         446 : std::vector<CAddress> CConnman::GetAddresses(size_t max_addresses, size_t max_pct, std::optional<Network> network, const bool filtered) const
    3507                 :             : {
    3508                 :         446 :     std::vector<CAddress> addresses = addrman.GetAddr(max_addresses, max_pct, network, filtered);
    3509         [ +  - ]:         446 :     if (m_banman) {
    3510         [ +  - ]:         446 :         addresses.erase(std::remove_if(addresses.begin(), addresses.end(),
    3511   [ +  -  -  + ]:       34366 :                         [this](const CAddress& addr){return m_banman->IsDiscouraged(addr) || m_banman->IsBanned(addr);}),
    3512         [ +  - ]:         446 :                         addresses.end());
    3513                 :             :     }
    3514                 :         446 :     return addresses;
    3515                 :           0 : }
    3516                 :             : 
    3517                 :         891 : std::vector<CAddress> CConnman::GetAddresses(CNode& requestor, size_t max_addresses, size_t max_pct)
    3518                 :             : {
    3519                 :         891 :     auto local_socket_bytes = requestor.addrBind.GetAddrBytes();
    3520         [ +  - ]:         891 :     uint64_t cache_id = GetDeterministicRandomizer(RANDOMIZER_ID_ADDRCACHE)
    3521   [ +  -  +  -  :         891 :         .Write(requestor.ConnectedThroughNetwork())
                   +  - ]
    3522   [ +  -  +  - ]:         891 :         .Write(local_socket_bytes)
    3523                 :             :         // For outbound connections, the port of the bound address is randomly
    3524                 :             :         // assigned by the OS and would therefore not be useful for seeding.
    3525   [ +  -  +  -  :         891 :         .Write(requestor.IsInboundConn() ? requestor.addrBind.GetPort() : 0)
                   +  - ]
    3526         [ +  - ]:         891 :         .Finalize();
    3527                 :         891 :     const auto current_time = GetTime<std::chrono::microseconds>();
    3528         [ +  - ]:         891 :     auto r = m_addr_response_caches.emplace(cache_id, CachedAddrResponse{});
    3529         [ +  + ]:         891 :     CachedAddrResponse& cache_entry = r.first->second;
    3530         [ +  + ]:         891 :     if (cache_entry.m_cache_entry_expiration < current_time) { // If emplace() added new one it has expiration 0.
    3531         [ +  - ]:         363 :         cache_entry.m_addrs_response_cache = GetAddresses(max_addresses, max_pct, /*network=*/std::nullopt);
    3532                 :             :         // Choosing a proper cache lifetime is a trade-off between the privacy leak minimization
    3533                 :             :         // and the usefulness of ADDR responses to honest users.
    3534                 :             :         //
    3535                 :             :         // Longer cache lifetime makes it more difficult for an attacker to scrape
    3536                 :             :         // enough AddrMan data to maliciously infer something useful.
    3537                 :             :         // By the time an attacker scraped enough AddrMan records, most of
    3538                 :             :         // the records should be old enough to not leak topology info by
    3539                 :             :         // e.g. analyzing real-time changes in timestamps.
    3540                 :             :         //
    3541                 :             :         // It takes only several hundred requests to scrape everything from an AddrMan containing 100,000 nodes,
    3542                 :             :         // so ~24 hours of cache lifetime indeed makes the data less inferable by the time
    3543                 :             :         // most of it could be scraped (considering that timestamps are updated via
    3544                 :             :         // ADDR self-announcements and when nodes communicate).
    3545                 :             :         // We also should be robust to those attacks which may not require scraping *full* victim's AddrMan
    3546                 :             :         // (because even several timestamps of the same handful of nodes may leak privacy).
    3547                 :             :         //
    3548                 :             :         // On the other hand, longer cache lifetime makes ADDR responses
    3549                 :             :         // outdated and less useful for an honest requestor, e.g. if most nodes
    3550                 :             :         // in the ADDR response are no longer active.
    3551                 :             :         //
    3552                 :             :         // However, the churn in the network is known to be rather low. Since we consider
    3553                 :             :         // nodes to be "terrible" (see IsTerrible()) if the timestamps are older than 30 days,
    3554                 :             :         // max. 24 hours of "penalty" due to cache shouldn't make any meaningful difference
    3555                 :             :         // in terms of the freshness of the response.
    3556                 :         363 :         cache_entry.m_cache_entry_expiration = current_time +
    3557                 :         363 :             21h + FastRandomContext().randrange<std::chrono::microseconds>(6h);
    3558                 :             :     }
    3559         [ +  - ]:         891 :     return cache_entry.m_addrs_response_cache;
    3560                 :         891 : }
    3561                 :             : 
    3562                 :          15 : bool CConnman::AddNode(const AddedNodeParams& add)
    3563                 :             : {
    3564   [ +  -  +  - ]:          15 :     const CService resolved(LookupNumeric(add.m_added_node, GetDefaultPort(add.m_added_node)));
    3565         [ +  - ]:          15 :     const bool resolved_is_valid{resolved.IsValid()};
    3566                 :             : 
    3567         [ +  - ]:          15 :     LOCK(m_added_nodes_mutex);
    3568         [ +  + ]:          27 :     for (const auto& it : m_added_node_params) {
    3569   [ +  +  +  -  :          50 :         if (add.m_added_node == it.m_added_node || (resolved_is_valid && resolved == LookupNumeric(it.m_added_node, GetDefaultPort(it.m_added_node)))) return false;
          +  -  +  -  +  
          -  +  -  +  +  
          +  +  +  +  -  
                -  -  - ]
    3570                 :             :     }
    3571                 :             : 
    3572         [ +  - ]:           9 :     m_added_node_params.push_back(add);
    3573                 :             :     return true;
    3574                 :          15 : }
    3575                 :             : 
    3576                 :           4 : bool CConnman::RemoveAddedNode(const std::string& strNode)
    3577                 :             : {
    3578                 :           4 :     LOCK(m_added_nodes_mutex);
    3579         [ +  + ]:           6 :     for (auto it = m_added_node_params.begin(); it != m_added_node_params.end(); ++it) {
    3580         [ +  + ]:           4 :         if (strNode == it->m_added_node) {
    3581                 :           2 :             m_added_node_params.erase(it);
    3582                 :           2 :             return true;
    3583                 :             :         }
    3584                 :             :     }
    3585                 :             :     return false;
    3586                 :           4 : }
    3587                 :             : 
    3588                 :           8 : bool CConnman::AddedNodesContain(const CAddress& addr) const
    3589                 :             : {
    3590                 :           8 :     AssertLockNotHeld(m_added_nodes_mutex);
    3591                 :           8 :     const std::string addr_str{addr.ToStringAddr()};
    3592         [ +  - ]:           8 :     const std::string addr_port_str{addr.ToStringAddrPort()};
    3593         [ +  - ]:           8 :     LOCK(m_added_nodes_mutex);
    3594         [ +  - ]:           8 :     return (m_added_node_params.size() < 24 // bound the query to a reasonable limit
    3595   [ +  -  +  + ]:           8 :             && std::any_of(m_added_node_params.cbegin(), m_added_node_params.cend(),
    3596   [ +  -  +  +  :          28 :                            [&](const auto& p) { return p.m_added_node == addr_str || p.m_added_node == addr_port_str; }));
                   +  - ]
    3597                 :           8 : }
    3598                 :             : 
    3599                 :        2892 : size_t CConnman::GetNodeCount(ConnectionDirection flags) const
    3600                 :             : {
    3601                 :        2892 :     LOCK(m_nodes_mutex);
    3602         [ +  + ]:        2892 :     if (flags == ConnectionDirection::Both) // Shortcut if we want total
    3603                 :         968 :         return m_nodes.size();
    3604                 :             : 
    3605                 :        1924 :     int nNum = 0;
    3606         [ +  + ]:        4682 :     for (const auto& pnode : m_nodes) {
    3607   [ +  +  +  + ]:        4258 :         if (flags & (pnode->IsInboundConn() ? ConnectionDirection::In : ConnectionDirection::Out)) {
    3608                 :        1379 :             nNum++;
    3609                 :             :         }
    3610                 :             :     }
    3611                 :             : 
    3612                 :        1924 :     return nNum;
    3613                 :        2892 : }
    3614                 :             : 
    3615                 :             : 
    3616                 :           0 : std::map<CNetAddr, LocalServiceInfo> CConnman::getNetLocalAddresses() const
    3617                 :             : {
    3618                 :           0 :     LOCK(g_maplocalhost_mutex);
    3619   [ #  #  #  # ]:           0 :     return mapLocalHost;
    3620                 :           0 : }
    3621                 :             : 
    3622                 :       13517 : uint32_t CConnman::GetMappedAS(const CNetAddr& addr) const
    3623                 :             : {
    3624                 :       13517 :     return m_netgroupman.GetMappedAS(addr);
    3625                 :             : }
    3626                 :             : 
    3627                 :        5974 : void CConnman::GetNodeStats(std::vector<CNodeStats>& vstats) const
    3628                 :             : {
    3629                 :        5974 :     vstats.clear();
    3630                 :        5974 :     LOCK(m_nodes_mutex);
    3631         [ +  - ]:        5974 :     vstats.reserve(m_nodes.size());
    3632         [ +  + ]:       16489 :     for (CNode* pnode : m_nodes) {
    3633         [ +  - ]:       10515 :         vstats.emplace_back();
    3634         [ +  - ]:       10515 :         pnode->CopyStats(vstats.back());
    3635         [ +  - ]:       10515 :         vstats.back().m_mapped_as = GetMappedAS(pnode->addr);
    3636                 :             :     }
    3637                 :        5974 : }
    3638                 :             : 
    3639                 :           4 : bool CConnman::DisconnectNode(const std::string& strNode)
    3640                 :             : {
    3641                 :           4 :     LOCK(m_nodes_mutex);
    3642   [ +  -  +  + ]:           4 :     if (CNode* pnode = FindNode(strNode)) {
    3643   [ +  -  +  -  :           4 :         LogDebug(BCLog::NET, "disconnect by address%s match, %s", (fLogIPs ? strprintf("=%s", strNode) : ""), pnode->DisconnectMsg(fLogIPs));
          +  -  -  +  -  
             -  +  -  +  
                      - ]
    3644                 :           2 :         pnode->fDisconnect = true;
    3645                 :           2 :         return true;
    3646                 :             :     }
    3647                 :             :     return false;
    3648                 :           4 : }
    3649                 :             : 
    3650                 :          33 : bool CConnman::DisconnectNode(const CSubNet& subnet)
    3651                 :             : {
    3652                 :          33 :     bool disconnected = false;
    3653                 :          33 :     LOCK(m_nodes_mutex);
    3654         [ +  + ]:          49 :     for (CNode* pnode : m_nodes) {
    3655   [ +  -  +  + ]:          16 :         if (subnet.Match(pnode->addr)) {
    3656   [ +  -  +  -  :          33 :             LogDebug(BCLog::NET, "disconnect by subnet%s match, %s", (fLogIPs ? strprintf("=%s", subnet.ToString()) : ""), pnode->DisconnectMsg(fLogIPs));
          +  -  -  +  -  
          -  -  -  +  -  
          +  -  -  +  -  
                      - ]
    3657                 :          11 :             pnode->fDisconnect = true;
    3658                 :          11 :             disconnected = true;
    3659                 :             :         }
    3660                 :             :     }
    3661         [ +  - ]:          33 :     return disconnected;
    3662                 :          33 : }
    3663                 :             : 
    3664                 :          20 : bool CConnman::DisconnectNode(const CNetAddr& addr)
    3665                 :             : {
    3666         [ +  - ]:          20 :     return DisconnectNode(CSubNet(addr));
    3667                 :             : }
    3668                 :             : 
    3669                 :         121 : bool CConnman::DisconnectNode(NodeId id)
    3670                 :             : {
    3671                 :         121 :     LOCK(m_nodes_mutex);
    3672         [ +  - ]:         180 :     for(CNode* pnode : m_nodes) {
    3673         [ +  + ]:         180 :         if (id == pnode->GetId()) {
    3674   [ +  -  +  -  :         242 :             LogDebug(BCLog::NET, "disconnect by id, %s", pnode->DisconnectMsg(fLogIPs));
             +  -  +  - ]
    3675                 :         121 :             pnode->fDisconnect = true;
    3676                 :         121 :             return true;
    3677                 :             :         }
    3678                 :             :     }
    3679                 :             :     return false;
    3680                 :         121 : }
    3681                 :             : 
    3682                 :      231155 : void CConnman::RecordBytesRecv(uint64_t bytes)
    3683                 :             : {
    3684                 :      231155 :     nTotalBytesRecv += bytes;
    3685                 :      231155 : }
    3686                 :             : 
    3687                 :      169421 : void CConnman::RecordBytesSent(uint64_t bytes)
    3688                 :             : {
    3689                 :      169421 :     AssertLockNotHeld(m_total_bytes_sent_mutex);
    3690                 :      169421 :     LOCK(m_total_bytes_sent_mutex);
    3691                 :             : 
    3692                 :      169421 :     nTotalBytesSent += bytes;
    3693                 :             : 
    3694                 :      169421 :     const auto now = GetTime<std::chrono::seconds>();
    3695         [ +  + ]:      169421 :     if (nMaxOutboundCycleStartTime + MAX_UPLOAD_TIMEFRAME < now)
    3696                 :             :     {
    3697                 :             :         // timeframe expired, reset cycle
    3698                 :         516 :         nMaxOutboundCycleStartTime = now;
    3699                 :         516 :         nMaxOutboundTotalBytesSentInCycle = 0;
    3700                 :             :     }
    3701                 :             : 
    3702         [ +  - ]:      169421 :     nMaxOutboundTotalBytesSentInCycle += bytes;
    3703                 :      169421 : }
    3704                 :             : 
    3705                 :          18 : uint64_t CConnman::GetMaxOutboundTarget() const
    3706                 :             : {
    3707                 :          18 :     AssertLockNotHeld(m_total_bytes_sent_mutex);
    3708                 :          18 :     LOCK(m_total_bytes_sent_mutex);
    3709         [ +  - ]:          18 :     return nMaxOutboundLimit;
    3710                 :          18 : }
    3711                 :             : 
    3712                 :          18 : std::chrono::seconds CConnman::GetMaxOutboundTimeframe() const
    3713                 :             : {
    3714                 :          18 :     return MAX_UPLOAD_TIMEFRAME;
    3715                 :             : }
    3716                 :             : 
    3717                 :          18 : std::chrono::seconds CConnman::GetMaxOutboundTimeLeftInCycle() const
    3718                 :             : {
    3719                 :          18 :     AssertLockNotHeld(m_total_bytes_sent_mutex);
    3720                 :          18 :     LOCK(m_total_bytes_sent_mutex);
    3721         [ +  - ]:          18 :     return GetMaxOutboundTimeLeftInCycle_();
    3722                 :          18 : }
    3723                 :             : 
    3724                 :        1126 : std::chrono::seconds CConnman::GetMaxOutboundTimeLeftInCycle_() const
    3725                 :             : {
    3726                 :        1126 :     AssertLockHeld(m_total_bytes_sent_mutex);
    3727                 :             : 
    3728         [ +  + ]:        1126 :     if (nMaxOutboundLimit == 0)
    3729                 :          12 :         return 0s;
    3730                 :             : 
    3731         [ +  + ]:        1114 :     if (nMaxOutboundCycleStartTime.count() == 0)
    3732                 :           4 :         return MAX_UPLOAD_TIMEFRAME;
    3733                 :             : 
    3734                 :        1110 :     const std::chrono::seconds cycleEndTime = nMaxOutboundCycleStartTime + MAX_UPLOAD_TIMEFRAME;
    3735                 :        1110 :     const auto now = GetTime<std::chrono::seconds>();
    3736         [ -  + ]:        1110 :     return (cycleEndTime < now) ? 0s : cycleEndTime - now;
    3737                 :             : }
    3738                 :             : 
    3739                 :       37108 : bool CConnman::OutboundTargetReached(bool historicalBlockServingLimit) const
    3740                 :             : {
    3741                 :       37108 :     AssertLockNotHeld(m_total_bytes_sent_mutex);
    3742                 :       37108 :     LOCK(m_total_bytes_sent_mutex);
    3743         [ +  + ]:       37108 :     if (nMaxOutboundLimit == 0)
    3744                 :             :         return false;
    3745                 :             : 
    3746         [ +  + ]:        1116 :     if (historicalBlockServingLimit)
    3747                 :             :     {
    3748                 :             :         // keep a large enough buffer to at least relay each block once
    3749         [ +  - ]:        1108 :         const std::chrono::seconds timeLeftInCycle = GetMaxOutboundTimeLeftInCycle_();
    3750                 :        1108 :         const uint64_t buffer = timeLeftInCycle / std::chrono::minutes{10} * MAX_BLOCK_SERIALIZED_SIZE;
    3751   [ +  +  +  + ]:        1108 :         if (buffer >= nMaxOutboundLimit || nMaxOutboundTotalBytesSentInCycle >= nMaxOutboundLimit - buffer)
    3752                 :         827 :             return true;
    3753                 :             :     }
    3754         [ +  + ]:           8 :     else if (nMaxOutboundTotalBytesSentInCycle >= nMaxOutboundLimit)
    3755                 :           3 :         return true;
    3756                 :             : 
    3757                 :             :     return false;
    3758                 :       37108 : }
    3759                 :             : 
    3760                 :          18 : uint64_t CConnman::GetOutboundTargetBytesLeft() const
    3761                 :             : {
    3762                 :          18 :     AssertLockNotHeld(m_total_bytes_sent_mutex);
    3763                 :          18 :     LOCK(m_total_bytes_sent_mutex);
    3764         [ +  + ]:          18 :     if (nMaxOutboundLimit == 0)
    3765                 :             :         return 0;
    3766                 :             : 
    3767         [ +  + ]:           6 :     return (nMaxOutboundTotalBytesSentInCycle >= nMaxOutboundLimit) ? 0 : nMaxOutboundLimit - nMaxOutboundTotalBytesSentInCycle;
    3768                 :          18 : }
    3769                 :             : 
    3770                 :          18 : uint64_t CConnman::GetTotalBytesRecv() const
    3771                 :             : {
    3772                 :          18 :     return nTotalBytesRecv;
    3773                 :             : }
    3774                 :             : 
    3775                 :          18 : uint64_t CConnman::GetTotalBytesSent() const
    3776                 :             : {
    3777                 :          18 :     AssertLockNotHeld(m_total_bytes_sent_mutex);
    3778                 :          18 :     LOCK(m_total_bytes_sent_mutex);
    3779         [ +  - ]:          18 :     return nTotalBytesSent;
    3780                 :          18 : }
    3781                 :             : 
    3782                 :        4676 : ServiceFlags CConnman::GetLocalServices() const
    3783                 :             : {
    3784                 :        4676 :     return m_local_services;
    3785                 :             : }
    3786                 :             : 
    3787                 :        1587 : static std::unique_ptr<Transport> MakeTransport(NodeId id, bool use_v2transport, bool inbound) noexcept
    3788                 :             : {
    3789         [ +  + ]:        1587 :     if (use_v2transport) {
    3790         [ -  + ]:         200 :         return std::make_unique<V2Transport>(id, /*initiating=*/!inbound);
    3791                 :             :     } else {
    3792         [ -  + ]:        1387 :         return std::make_unique<V1Transport>(id);
    3793                 :             :     }
    3794                 :             : }
    3795                 :             : 
    3796                 :        1587 : CNode::CNode(NodeId idIn,
    3797                 :             :              std::shared_ptr<Sock> sock,
    3798                 :             :              const CAddress& addrIn,
    3799                 :             :              uint64_t nKeyedNetGroupIn,
    3800                 :             :              uint64_t nLocalHostNonceIn,
    3801                 :             :              const CService& addrBindIn,
    3802                 :             :              const std::string& addrNameIn,
    3803                 :             :              ConnectionType conn_type_in,
    3804                 :             :              bool inbound_onion,
    3805                 :        1587 :              CNodeOptions&& node_opts)
    3806                 :        1587 :     : m_transport{MakeTransport(idIn, node_opts.use_v2transport, conn_type_in == ConnectionType::INBOUND)},
    3807                 :        1587 :       m_permission_flags{node_opts.permission_flags},
    3808         [ +  + ]:        1587 :       m_sock{sock},
    3809                 :        1587 :       m_connected{GetTime<std::chrono::seconds>()},
    3810                 :        1587 :       addr{addrIn},
    3811                 :        1587 :       addrBind{addrBindIn},
    3812   [ +  +  +  -  :        1587 :       m_addr_name{addrNameIn.empty() ? addr.ToStringAddrPort() : addrNameIn},
                   +  - ]
    3813         [ +  - ]:        1587 :       m_dest(addrNameIn),
    3814                 :        1587 :       m_inbound_onion{inbound_onion},
    3815         [ +  - ]:        1587 :       m_prefer_evict{node_opts.prefer_evict},
    3816                 :        1587 :       nKeyedNetGroup{nKeyedNetGroupIn},
    3817         [ +  - ]:        1587 :       m_conn_type{conn_type_in},
    3818                 :        1587 :       id{idIn},
    3819                 :        1587 :       nLocalHostNonce{nLocalHostNonceIn},
    3820         [ +  - ]:        1587 :       m_recv_flood_size{node_opts.recv_flood_size},
    3821   [ +  -  +  -  :        3174 :       m_i2p_sam_session{std::move(node_opts.i2p_sam_session)}
                   +  + ]
    3822                 :             : {
    3823   [ +  +  +  - ]:        1587 :     if (inbound_onion) assert(conn_type_in == ConnectionType::INBOUND);
    3824                 :             : 
    3825         [ +  + ]:       57132 :     for (const auto& msg : ALL_NET_MESSAGE_TYPES) {
    3826         [ +  - ]:       55545 :         mapRecvBytesPerMsgType[msg] = 0;
    3827                 :             :     }
    3828         [ +  - ]:        1587 :     mapRecvBytesPerMsgType[NET_MESSAGE_TYPE_OTHER] = 0;
    3829                 :             : 
    3830         [ +  + ]:        1587 :     if (fLogIPs) {
    3831   [ +  -  +  -  :           8 :         LogDebug(BCLog::NET, "Added connection to %s peer=%d\n", m_addr_name, id);
                   +  - ]
    3832                 :             :     } else {
    3833   [ +  -  +  -  :        1579 :         LogDebug(BCLog::NET, "Added connection peer=%d\n", id);
                   +  - ]
    3834                 :             :     }
    3835         [ -  - ]:        1587 : }
    3836                 :             : 
    3837                 :      135688 : void CNode::MarkReceivedMsgsForProcessing()
    3838                 :             : {
    3839                 :      135688 :     AssertLockNotHeld(m_msg_process_queue_mutex);
    3840                 :             : 
    3841                 :      135688 :     size_t nSizeAdded = 0;
    3842         [ +  + ]:      299410 :     for (const auto& msg : vRecvMsg) {
    3843                 :             :         // vRecvMsg contains only completed CNetMessage
    3844                 :             :         // the single possible partially deserialized message are held by TransportDeserializer
    3845                 :      163722 :         nSizeAdded += msg.GetMemoryUsage();
    3846                 :             :     }
    3847                 :             : 
    3848                 :      135688 :     LOCK(m_msg_process_queue_mutex);
    3849                 :      135688 :     m_msg_process_queue.splice(m_msg_process_queue.end(), vRecvMsg);
    3850                 :      135688 :     m_msg_process_queue_size += nSizeAdded;
    3851         [ +  - ]:      135688 :     fPauseRecv = m_msg_process_queue_size > m_recv_flood_size;
    3852                 :      135688 : }
    3853                 :             : 
    3854                 :      392529 : std::optional<std::pair<CNetMessage, bool>> CNode::PollMessage()
    3855                 :             : {
    3856                 :      392529 :     LOCK(m_msg_process_queue_mutex);
    3857         [ +  + ]:      392529 :     if (m_msg_process_queue.empty()) return std::nullopt;
    3858                 :             : 
    3859                 :      159940 :     std::list<CNetMessage> msgs;
    3860                 :             :     // Just take one message
    3861                 :      159940 :     msgs.splice(msgs.begin(), m_msg_process_queue, m_msg_process_queue.begin());
    3862                 :      159940 :     m_msg_process_queue_size -= msgs.front().GetMemoryUsage();
    3863                 :      159940 :     fPauseRecv = m_msg_process_queue_size > m_recv_flood_size;
    3864                 :             : 
    3865                 :      319880 :     return std::make_pair(std::move(msgs.front()), !m_msg_process_queue.empty());
    3866                 :      159940 : }
    3867                 :             : 
    3868                 :       82579 : bool CConnman::NodeFullyConnected(const CNode* pnode)
    3869                 :             : {
    3870   [ +  -  +  +  :       82579 :     return pnode && pnode->fSuccessfullyConnected && !pnode->fDisconnect;
                   +  + ]
    3871                 :             : }
    3872                 :             : 
    3873                 :      169171 : void CConnman::PushMessage(CNode* pnode, CSerializedNetMsg&& msg)
    3874                 :             : {
    3875                 :      169171 :     AssertLockNotHeld(m_total_bytes_sent_mutex);
    3876                 :      169171 :     size_t nMessageSize = msg.data.size();
    3877         [ +  - ]:      169171 :     LogDebug(BCLog::NET, "sending %s (%d bytes) peer=%d\n", msg.m_type, nMessageSize, pnode->GetId());
    3878   [ +  -  +  + ]:      169171 :     if (gArgs.GetBoolArg("-capturemessages", false)) {
    3879                 :          20 :         CaptureMessage(pnode->addr, msg.m_type, msg.data, /*is_incoming=*/false);
    3880                 :             :     }
    3881                 :             : 
    3882                 :             :     TRACEPOINT(net, outbound_message,
    3883                 :             :         pnode->GetId(),
    3884                 :             :         pnode->m_addr_name.c_str(),
    3885                 :             :         pnode->ConnectionTypeAsString().c_str(),
    3886                 :             :         msg.m_type.c_str(),
    3887                 :             :         msg.data.size(),
    3888                 :             :         msg.data.data()
    3889                 :      169171 :     );
    3890                 :             : 
    3891                 :      169171 :     size_t nBytesSent = 0;
    3892                 :      169171 :     {
    3893                 :      169171 :         LOCK(pnode->cs_vSend);
    3894                 :             :         // Check if the transport still has unsent bytes, and indicate to it that we're about to
    3895                 :             :         // give it a message to send.
    3896         [ +  + ]:      169171 :         const auto& [to_send, more, _msg_type] =
    3897         [ +  + ]:      169171 :             pnode->m_transport->GetBytesToSend(/*have_next_message=*/true);
    3898   [ +  +  -  + ]:      169171 :         const bool queue_was_empty{to_send.empty() && pnode->vSendMsg.empty()};
    3899                 :             : 
    3900                 :             :         // Update memory usage of send buffer.
    3901                 :      169171 :         pnode->m_send_memusage += msg.GetMemoryUsage();
    3902         [ +  + ]:      169171 :         if (pnode->m_send_memusage + pnode->m_transport->GetSendMemoryUsage() > nSendBufferMaxSize) pnode->fPauseSend = true;
    3903                 :             :         // Move message to vSendMsg queue.
    3904         [ +  - ]:      169171 :         pnode->vSendMsg.push_back(std::move(msg));
    3905                 :             : 
    3906                 :             :         // If there was nothing to send before, and there is now (predicted by the "more" value
    3907                 :             :         // returned by the GetBytesToSend call above), attempt "optimistic write":
    3908                 :             :         // because the poll/select loop may pause for SELECT_TIMEOUT_MILLISECONDS before actually
    3909                 :             :         // doing a send, try sending from the calling thread if the queue was empty before.
    3910                 :             :         // With a V1Transport, more will always be true here, because adding a message always
    3911                 :             :         // results in sendable bytes there, but with V2Transport this is not the case (it may
    3912                 :             :         // still be in the handshake).
    3913   [ +  +  +  + ]:      169171 :         if (queue_was_empty && more) {
    3914         [ +  - ]:      168719 :             std::tie(nBytesSent, std::ignore) = SocketSendData(*pnode);
    3915                 :             :         }
    3916                 :      169171 :     }
    3917         [ +  + ]:      169171 :     if (nBytesSent) RecordBytesSent(nBytesSent);
    3918                 :      169171 : }
    3919                 :             : 
    3920                 :         422 : bool CConnman::ForNode(NodeId id, std::function<bool(CNode* pnode)> func)
    3921                 :             : {
    3922                 :         422 :     CNode* found = nullptr;
    3923                 :         422 :     LOCK(m_nodes_mutex);
    3924         [ +  + ]:         716 :     for (auto&& pnode : m_nodes) {
    3925         [ +  + ]:         666 :         if(pnode->GetId() == id) {
    3926                 :             :             found = pnode;
    3927                 :             :             break;
    3928                 :             :         }
    3929                 :             :     }
    3930   [ +  +  +  -  :         423 :     return found != nullptr && NodeFullyConnected(found) && func(found);
          +  -  +  -  +  
                +  +  - ]
    3931                 :         422 : }
    3932                 :             : 
    3933                 :        4038 : CSipHasher CConnman::GetDeterministicRandomizer(uint64_t id) const
    3934                 :             : {
    3935                 :        4038 :     return CSipHasher(nSeed0, nSeed1).Write(id);
    3936                 :             : }
    3937                 :             : 
    3938                 :        1547 : uint64_t CConnman::CalculateKeyedNetGroup(const CNetAddr& address) const
    3939                 :             : {
    3940                 :        1547 :     std::vector<unsigned char> vchNetGroup(m_netgroupman.GetGroup(address));
    3941                 :             : 
    3942   [ +  -  +  -  :        1547 :     return GetDeterministicRandomizer(RANDOMIZER_ID_NETGROUP).Write(vchNetGroup).Finalize();
                   +  - ]
    3943                 :        1547 : }
    3944                 :             : 
    3945                 :        7381 : void CConnman::PerformReconnections()
    3946                 :             : {
    3947                 :        7381 :     AssertLockNotHeld(m_reconnections_mutex);
    3948                 :        7381 :     AssertLockNotHeld(m_unused_i2p_sessions_mutex);
    3949                 :        7387 :     while (true) {
    3950                 :             :         // Move first element of m_reconnections to todo (avoiding an allocation inside the lock).
    3951         [ +  - ]:        7384 :         decltype(m_reconnections) todo;
    3952                 :        7384 :         {
    3953         [ +  - ]:        7384 :             LOCK(m_reconnections_mutex);
    3954         [ +  + ]:        7384 :             if (m_reconnections.empty()) break;
    3955         [ +  - ]:           3 :             todo.splice(todo.end(), m_reconnections, m_reconnections.begin());
    3956                 :        7381 :         }
    3957                 :             : 
    3958         [ +  - ]:           3 :         auto& item = *todo.begin();
    3959                 :           6 :         OpenNetworkConnection(item.addr_connect,
    3960                 :             :                               // We only reconnect if the first attempt to connect succeeded at
    3961                 :             :                               // connection time, but then failed after the CNode object was
    3962                 :             :                               // created. Since we already know connecting is possible, do not
    3963                 :             :                               // count failure to reconnect.
    3964                 :             :                               /*fCountFailure=*/false,
    3965         [ +  - ]:           3 :                               std::move(item.grant),
    3966                 :           3 :                               item.destination.empty() ? nullptr : item.destination.c_str(),
    3967                 :             :                               item.conn_type,
    3968         [ +  - ]:           3 :                               item.use_v2transport);
    3969                 :           3 :     }
    3970                 :        7381 : }
    3971                 :             : 
    3972                 :           7 : void CConnman::ASMapHealthCheck()
    3973                 :             : {
    3974                 :           7 :     const std::vector<CAddress> v4_addrs{GetAddresses(/*max_addresses=*/ 0, /*max_pct=*/ 0, Network::NET_IPV4, /*filtered=*/ false)};
    3975         [ +  - ]:           7 :     const std::vector<CAddress> v6_addrs{GetAddresses(/*max_addresses=*/ 0, /*max_pct=*/ 0, Network::NET_IPV6, /*filtered=*/ false)};
    3976                 :           7 :     std::vector<CNetAddr> clearnet_addrs;
    3977         [ +  - ]:           7 :     clearnet_addrs.reserve(v4_addrs.size() + v6_addrs.size());
    3978         [ +  - ]:           7 :     std::transform(v4_addrs.begin(), v4_addrs.end(), std::back_inserter(clearnet_addrs),
    3979         [ +  - ]:           8 :         [](const CAddress& addr) { return static_cast<CNetAddr>(addr); });
    3980         [ +  - ]:           7 :     std::transform(v6_addrs.begin(), v6_addrs.end(), std::back_inserter(clearnet_addrs),
    3981         [ #  # ]:           0 :         [](const CAddress& addr) { return static_cast<CNetAddr>(addr); });
    3982         [ +  - ]:           7 :     m_netgroupman.ASMapHealthCheck(clearnet_addrs);
    3983                 :           7 : }
    3984                 :             : 
    3985                 :             : // Dump binary message to file, with timestamp.
    3986                 :          22 : static void CaptureMessageToFile(const CAddress& addr,
    3987                 :             :                                  const std::string& msg_type,
    3988                 :             :                                  std::span<const unsigned char> data,
    3989                 :             :                                  bool is_incoming)
    3990                 :             : {
    3991                 :             :     // Note: This function captures the message at the time of processing,
    3992                 :             :     // not at socket receive/send time.
    3993                 :             :     // This ensures that the messages are always in order from an application
    3994                 :             :     // layer (processing) perspective.
    3995                 :          22 :     auto now = GetTime<std::chrono::microseconds>();
    3996                 :             : 
    3997                 :             :     // Windows folder names cannot include a colon
    3998                 :          22 :     std::string clean_addr = addr.ToStringAddrPort();
    3999                 :          22 :     std::replace(clean_addr.begin(), clean_addr.end(), ':', '_');
    4000                 :             : 
    4001   [ +  -  +  -  :         132 :     fs::path base_path = gArgs.GetDataDirNet() / "message_capture" / fs::u8path(clean_addr);
                   +  - ]
    4002         [ +  - ]:          22 :     fs::create_directories(base_path);
    4003                 :             : 
    4004   [ +  +  +  - ]:          66 :     fs::path path = base_path / (is_incoming ? "msgs_recv.dat" : "msgs_sent.dat");
    4005   [ +  -  +  - ]:          22 :     AutoFile f{fsbridge::fopen(path, "ab")};
    4006                 :             : 
    4007         [ +  - ]:          22 :     ser_writedata64(f, now.count());
    4008         [ +  - ]:          22 :     f << std::span{msg_type};
    4009         [ +  + ]:         129 :     for (auto i = msg_type.length(); i < CMessageHeader::MESSAGE_TYPE_SIZE; ++i) {
    4010         [ +  - ]:         214 :         f << uint8_t{'\0'};
    4011                 :             :     }
    4012         [ +  - ]:          22 :     uint32_t size = data.size();
    4013         [ +  - ]:          22 :     ser_writedata32(f, size);
    4014         [ +  - ]:          44 :     f << data;
    4015                 :          66 : }
    4016                 :             : 
    4017                 :             : std::function<void(const CAddress& addr,
    4018                 :             :                    const std::string& msg_type,
    4019                 :             :                    std::span<const unsigned char> data,
    4020                 :             :                    bool is_incoming)>
    4021                 :             :     CaptureMessage = CaptureMessageToFile;
        

Generated by: LCOV version 2.0-1