LCOV - code coverage report
Current view: top level - src - net.cpp (source / functions) Hit Total Coverage
Test: fuzz_coverage.info Lines: 115 2269 5.1 %
Date: 2023-11-12 01:39:15 Functions: 11 173 6.4 %
Branches: 73 3838 1.9 %

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

Generated by: LCOV version 1.14