LCOV - code coverage report
Current view: top level - src - net.cpp (source / functions) Hit Total Coverage
Test: fuzz_coverage.info Lines: 1249 2291 54.5 %
Date: 2023-10-05 12:38:51 Functions: 121 178 68.0 %
Branches: 1005 3928 25.6 %

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

Generated by: LCOV version 1.14