Connections and transport

3751    AssertLockNotHeld(m_reconnections_mutex);
3752
3753    if (fAddressesInitialized) {
3754        DumpAddresses();
3755        fAddressesInitialized = false;
3756
3757        if (m_use_addrman_outgoing) {
3758            // Anchor connections are only dumped during clean shutdown.
3759            std::vector<CAddress> anchors_to_dump = GetCurrentBlockRelayOnlyConns();
3760            if (anchors_to_dump.size() > MAX_BLOCK_RELAY_ONLY_ANCHORS) {
3761                anchors_to_dump.resize(MAX_BLOCK_RELAY_ONLY_ANCHORS);
3762            }
3763            DumpAnchors(gArgs.GetDataDirNet() / ANCHORS_DATABASE_FILENAME, anchors_to_dump);
3764        }
3765    }
3766
3767    // Delete peer connections.
3768    std::vector<CNode*> nodes;
3769    WITH_LOCK(m_nodes_mutex, nodes.swap(m_nodes));
3770    for (CNode* pnode : nodes) {
3771        LogDebug(BCLog::NET, "Stopping node, %s", pnode->DisconnectMsg());
3772        pnode->CloseSocketDisconnect();
3773        DeleteNode(pnode);
3774    }
3775
3776    for (CNode* pnode : m_nodes_disconnected) {
3777        DeleteNode(pnode);
3778    }
3779    m_nodes_disconnected.clear();
3780    WITH_LOCK(m_reconnections_mutex, m_reconnections.clear());
3781    vhListenSocket.clear();
3782    semOutbound.reset();
3783    semAddnode.reset();
3784}
3785
3786void CConnman::DeleteNode(CNode* pnode)
3787{
3788    assert(pnode);
3789    m_msgproc->FinalizeNode(*pnode);
3790    delete pnode;
3791}
3792
3793CConnman::~CConnman()
3794{
3795    Interrupt();
3796    Stop();
3797}
3798
3799std::vector<CAddress> CConnman::GetAddressesUnsafe(size_t max_addresses, size_t max_pct, std::optional<Network> network, const bool filtered) const
3800{
3801    std::vector<CAddress> addresses = addrman.get().GetAddr(max_addresses, max_pct, network, filtered);
3802    if (m_banman) {
3803        addresses.erase(std::remove_if(addresses.begin(), addresses.end(),
3804                        [this](const CAddress& addr){return m_banman->IsDiscouraged(addr) || m_banman->IsBanned(addr);}),
3805                        addresses.end());
3806    }
3807    return addresses;
3808}
3809
3810std::vector<CAddress> CConnman::GetAddresses(CNode& requestor, size_t max_addresses, size_t max_pct)
3811{
3812    uint64_t network_id = requestor.m_network_key;
3813    const auto current_time = GetTime<std::chrono::microseconds>();
3814    auto r = m_addr_response_caches.emplace(network_id, CachedAddrResponse{});
3815    CachedAddrResponse& cache_entry = r.first->second;
3816    if (cache_entry.m_cache_entry_expiration < current_time) { // If emplace() added new one it has expiration 0.
3817        cache_entry.m_addrs_response_cache = GetAddressesUnsafe(max_addresses, max_pct, /*network=*/std::nullopt);
3818        // Choosing a proper cache lifetime is a trade-off between the privacy leak minimization
3819        // and the usefulness of ADDR responses to honest users.
3820        //
3821        // Longer cache lifetime makes it more difficult for an attacker to scrape
3822        // enough AddrMan data to maliciously infer something useful.
3823        // By the time an attacker scraped enough AddrMan records, most of
3824        // the records should be old enough to not leak topology info by
3825        // e.g. analyzing real-time changes in timestamps.
3826        //
3827        // It takes only several hundred requests to scrape everything from an AddrMan containing 100,000 nodes,
3828        // so ~24 hours of cache lifetime indeed makes the data less inferable by the time
3829        // most of it could be scraped (considering that timestamps are updated via
3830        // ADDR self-announcements and when nodes communicate).
3831        // We also should be robust to those attacks which may not require scraping *full* victim's AddrMan
3832        // (because even several timestamps of the same handful of nodes may leak privacy).
3833        //
3834        // On the other hand, longer cache lifetime makes ADDR responses
3835        // outdated and less useful for an honest requestor, e.g. if most nodes
3836        // in the ADDR response are no longer active.
3837        //
3838        // However, the churn in the network is known to be rather low. Since we consider
3839        // nodes to be "terrible" (see IsTerrible()) if the timestamps are older than 30 days,
3840        // max. 24 hours of "penalty" due to cache shouldn't make any meaningful difference
3841        // in terms of the freshness of the response.
3842        cache_entry.m_cache_entry_expiration = current_time +
3843            21h + FastRandomContext().randrange<std::chrono::microseconds>(6h);
3844    }
3845    return cache_entry.m_addrs_response_cache;
3846}
3847
3848bool CConnman::AddNode(const AddedNodeParams& add)
3849{
3850    const CService resolved(LookupNumeric(add.m_added_node, GetDefaultPort(add.m_added_node)));
3851    const bool resolved_is_valid{resolved.IsValid()};
3852
3853    LOCK(m_added_nodes_mutex);
3854    for (const auto& it : m_added_node_params) {
3855        if (add.m_added_node == it.m_added_node || (resolved_is_valid && resolved == LookupNumeric(it.m_added_node, GetDefaultPort(it.m_added_node)))) return false;
3856    }
3857
3858    m_added_node_params.push_back(add);
3859    return true;
3860}
3861
3862bool CConnman::RemoveAddedNode(std::string_view node)
3863{
3864    LOCK(m_added_nodes_mutex);
3865    for (auto it = m_added_node_params.begin(); it != m_added_node_params.end(); ++it) {
3866        if (node == it->m_added_node) {
3867            m_added_node_params.erase(it);
3868            return true;
3869        }
3870    }
3871    return false;
3872}
3873
3874bool CConnman::AddedNodesContain(const CAddress& addr) const
3875{
3876    AssertLockNotHeld(m_added_nodes_mutex);
3877    const std::string addr_str{addr.ToStringAddr()};
3878    const std::string addr_port_str{addr.ToStringAddrPort()};
3879    LOCK(m_added_nodes_mutex);
3880    return (m_added_node_params.size() < 24 // bound the query to a reasonable limit
3881            && std::any_of(m_added_node_params.cbegin(), m_added_node_params.cend(),
3882                           [&](const auto& p) { return p.m_added_node == addr_str || p.m_added_node == addr_port_str; }));
3883}
3884
3885size_t CConnman::GetNodeCount(ConnectionDirection flags) const
3886{
3887    LOCK(m_nodes_mutex);
3888    if (flags == ConnectionDirection::Both) // Shortcut if we want total
3889        return m_nodes.size();
3890
3891    int nNum = 0;
3892    for (const auto& pnode : m_nodes) {
3893        if (flags & (pnode->IsInboundConn() ? ConnectionDirection::In : ConnectionDirection::Out)) {
3894            nNum++;
3895        }
3896    }
3897
3898    return nNum;
3899}
3900
3901
3902std::map<CNetAddr, LocalServiceInfo> CConnman::getNetLocalAddresses() const
3903{
3904    LOCK(g_maplocalhost_mutex);
3905    return mapLocalHost;
3906}
3907
3908uint32_t CConnman::GetMappedAS(const CNetAddr& addr) const
3909{
3910    return m_netgroupman.GetMappedAS(addr);
3911}
3912
3913void CConnman::GetNodeStats(std::vector<CNodeStats>& vstats) const
3914{
3915    AssertLockNotHeld(m_nodes_mutex);
3916
3917    vstats.clear();
3918    LOCK(m_nodes_mutex);
3919    vstats.reserve(m_nodes.size());
3920    for (CNode* pnode : m_nodes) {
3921        vstats.emplace_back();
3922        pnode->CopyStats(vstats.back());
3923        vstats.back().m_mapped_as = GetMappedAS(pnode->addr);
3924    }
3925}
3926
3927bool CConnman::DisconnectNode(std::string_view strNode)
3928{
3929    LOCK(m_nodes_mutex);
3930    auto it = std::ranges::find_if(m_nodes, [&strNode](CNode* node) { return node->m_addr_name == strNode; });
3931    if (it != m_nodes.end()) {
3932        CNode* node{*it};
3933        LogDebug(BCLog::NET, "disconnect by address%s match, %s", (fLogIPs ? strprintf("=%s", strNode) : ""), node->DisconnectMsg());
3934        node->fDisconnect = true;
3935        return true;
3936    }
3937    return false;
3938}
3939
3940bool CConnman::DisconnectNode(const CSubNet& subnet, bool disconnect_private_broadcast)
3941{
3942    AssertLockNotHeld(m_nodes_mutex);
3943    bool disconnected = false;
3944    LOCK(m_nodes_mutex);
3945    for (CNode* pnode : m_nodes) {
3946        if (subnet.Match(pnode->addr) && (disconnect_private_broadcast || !pnode->IsPrivateBroadcastConn())) {
3947            LogDebug(BCLog::NET, "disconnect by subnet%s match, %s", (fLogIPs ? strprintf("=%s", subnet.ToString()) : ""), pnode->DisconnectMsg());
3948            pnode->fDisconnect = true;
3949            disconnected = true;
3950        }
3951    }
3952    return disconnected;
3953}
3954
3955bool CConnman::DisconnectNode(const CNetAddr& addr)
3956{
3957    AssertLockNotHeld(m_nodes_mutex);
3958    return DisconnectNode(CSubNet(addr));
3959}
3960
3961bool CConnman::DisconnectNode(NodeId id)
3962{
3963    LOCK(m_nodes_mutex);
3964    for(CNode* pnode : m_nodes) {
3965        if (id == pnode->GetId()) {
3966            LogDebug(BCLog::NET, "disconnect by id, %s", pnode->DisconnectMsg());
3967            pnode->fDisconnect = true;
3968            return true;
3969        }
3970    }
3971    return false;
3972}
3973
3974void CConnman::RecordBytesRecv(uint64_t bytes)
3975{
3976    nTotalBytesRecv += bytes;
3977}
3978
3979void CConnman::RecordBytesSent(uint64_t bytes)
3980{
3981    AssertLockNotHeld(m_total_bytes_sent_mutex);
3982    LOCK(m_total_bytes_sent_mutex);
3983
3984    nTotalBytesSent += bytes;
3985
3986    const auto now = GetTime<std::chrono::seconds>();
3987    if (nMaxOutboundCycleStartTime + MAX_UPLOAD_TIMEFRAME < now)
3988    {
3989        // timeframe expired, reset cycle
3990        nMaxOutboundCycleStartTime = now;
3991        nMaxOutboundTotalBytesSentInCycle = 0;
3992    }
3993
3994    nMaxOutboundTotalBytesSentInCycle += bytes;
3995}
3996
3997uint64_t CConnman::GetMaxOutboundTarget() const
3998{
3999    AssertLockNotHeld(m_total_bytes_sent_mutex);
4000    LOCK(m_total_bytes_sent_mutex);