Connections and transport

2501// Return the number of outbound connections that are full relay (not blocks only)
2502int CConnman::GetFullOutboundConnCount() const
2503{
2504    AssertLockNotHeld(m_nodes_mutex);
2505
2506    int nRelevant = 0;
2507    {
2508        LOCK(m_nodes_mutex);
2509        for (const CNode* pnode : m_nodes) {
2510            if (pnode->fSuccessfullyConnected && pnode->IsFullOutboundConn()) ++nRelevant;
2511        }
2512    }
2513    return nRelevant;
2514}
2515
2516// Return the number of peers we have over our outbound connection limit
2517// Exclude peers that are marked for disconnect, or are going to be
2518// disconnected soon (eg ADDR_FETCH and FEELER)
2519// Also exclude peers that haven't finished initial connection handshake yet
2520// (so that we don't decide we're over our desired connection limit, and then
2521// evict some peer that has finished the handshake)
2522int CConnman::GetExtraFullOutboundCount() const
2523{
2524    AssertLockNotHeld(m_nodes_mutex);
2525
2526    int full_outbound_peers = 0;
2527    {
2528        LOCK(m_nodes_mutex);
2529        for (const CNode* pnode : m_nodes) {
2530            if (pnode->fSuccessfullyConnected && !pnode->fDisconnect && pnode->IsFullOutboundConn()) {
2531                ++full_outbound_peers;
2532            }
2533        }
2534    }
2535    return std::max(full_outbound_peers - m_max_outbound_full_relay, 0);
2536}
2537
2538int CConnman::GetExtraBlockRelayCount() const
2539{
2540    AssertLockNotHeld(m_nodes_mutex);
2541
2542    int block_relay_peers = 0;
2543    {
2544        LOCK(m_nodes_mutex);
2545        for (const CNode* pnode : m_nodes) {
2546            if (pnode->fSuccessfullyConnected && !pnode->fDisconnect && pnode->IsBlockOnlyConn()) {
2547                ++block_relay_peers;
2548            }
2549        }
2550    }
2551    return std::max(block_relay_peers - m_max_outbound_block_relay, 0);
2552}
2553
2554bool CConnman::EvictTxPeerIfFull(std::optional<NodeId> protect_peer)
2555{
2556    int tx_inbound_peers{0};
2557    {
2558        LOCK(m_nodes_mutex);
2559        for (const CNode* pnode : m_nodes) {
2560            if (!pnode->fDisconnect && pnode->IsInboundConn() && pnode->m_relays_txs) {
2561                ++tx_inbound_peers;
2562            }
2563        }
2564    }
2565    if (tx_inbound_peers > m_max_inbound_full_relay) {
2566        return AttemptToEvictConnection(/*evict_tx_relay_peer_only=*/true, protect_peer);
2567    }
2568    return true;
2569}
2570
2571std::unordered_set<Network> CConnman::GetReachableEmptyNetworks() const
2572{
2573    std::unordered_set<Network> networks{};
2574    for (int n = 0; n < NET_MAX; n++) {
2575        enum Network net = (enum Network)n;
2576        if (net == NET_UNROUTABLE || net == NET_INTERNAL) continue;
2577        if (g_reachable_nets.Contains(net) && addrman.get().Size(net, std::nullopt) == 0) {
2578            networks.insert(net);
2579        }
2580    }
2581    return networks;
2582}
2583
2584bool CConnman::MultipleManualOrFullOutboundConns(Network net) const
2585{
2586    AssertLockHeld(m_nodes_mutex);
2587    return m_network_conn_counts[net] > 1;
2588}
2589
2590bool CConnman::MaybePickPreferredNetwork(std::optional<Network>& network)
2591{
2592    AssertLockNotHeld(m_nodes_mutex);
2593
2594    std::array<Network, 5> nets{NET_IPV4, NET_IPV6, NET_ONION, NET_I2P, NET_CJDNS};
2595    std::shuffle(nets.begin(), nets.end(), FastRandomContext());
2596
2597    LOCK(m_nodes_mutex);
2598    for (const auto net : nets) {
2599        if (g_reachable_nets.Contains(net) && m_network_conn_counts[net] == 0 && addrman.get().Size(net) != 0) {
2600            network = net;
2601            return true;
2602        }
2603    }
2604
2605    return false;
2606}
2607
2608void CConnman::ThreadOpenConnections(const std::vector<std::string> connect, std::span<const std::string> seed_nodes)
2609{
2610    AssertLockNotHeld(m_nodes_mutex);
2611    AssertLockNotHeld(m_reconnections_mutex);
2612    AssertLockNotHeld(m_unused_i2p_sessions_mutex);
2613
2614    FastRandomContext rng;
2615    // Connect to specific addresses
2616    if (!connect.empty())
2617    {
2618        // Attempt v2 connection if we support v2 - we'll reconnect with v1 if our
2619        // peer doesn't support it or immediately disconnects us for another reason.
2620        const bool use_v2transport(GetLocalServices() & NODE_P2P_V2);
2621        for (int64_t nLoop = 0;; nLoop++)
2622        {
2623            for (const std::string& strAddr : connect)
2624            {
2625                OpenNetworkConnection(/*addrConnect=*/CAddress{CService{}, NODE_NONE},
2626                                      /*fCountFailure=*/false,
2627                                      /*grant_outbound=*/{},
2628                                      /*pszDest=*/strAddr.c_str(),
2629                                      /*conn_type=*/ConnectionType::MANUAL,
2630                                      /*use_v2transport=*/use_v2transport,
2631                                      /*proxy_override=*/std::nullopt);
2632                for (int i = 0; i < 10 && i < nLoop; i++)
2633                {
2634                    if (!m_interrupt_net->sleep_for(500ms)) {
2635                        return;
2636                    }
2637                }
2638            }
2639            if (!m_interrupt_net->sleep_for(500ms)) {
2640                return;
2641            }
2642            PerformReconnections();
2643        }
2644    }
2645
2646    // Initiate network connections
2647    auto start = GetTime<std::chrono::microseconds>();
2648
2649    // Minimum time before next feeler connection (in microseconds).
2650    auto next_feeler = start + rng.rand_exp_duration(FEELER_INTERVAL);
2651    auto next_extra_block_relay = start + rng.rand_exp_duration(EXTRA_BLOCK_RELAY_ONLY_PEER_INTERVAL);
2652    auto next_extra_network_peer{start + rng.rand_exp_duration(EXTRA_NETWORK_PEER_INTERVAL)};
2653    const bool dnsseed = gArgs.GetBoolArg("-dnsseed", DEFAULT_DNSSEED);
2654    bool add_fixed_seeds = gArgs.GetBoolArg("-fixedseeds", DEFAULT_FIXEDSEEDS);
2655    const bool use_seednodes{!gArgs.GetArgs("-seednode").empty()};
2656
2657    auto seed_node_timer = NodeClock::now();
2658    bool add_addr_fetch{addrman.get().Size() == 0 && !seed_nodes.empty()};
2659    constexpr std::chrono::seconds ADD_NEXT_SEEDNODE = 10s;
2660
2661    if (!add_fixed_seeds) {
2662        LogInfo("Fixed seeds are disabled\n");
2663    }
2664
2665    while (!m_interrupt_net->interrupted()) {
2666        if (add_addr_fetch) {
2667            add_addr_fetch = false;
2668            const auto& seed{SpanPopBack(seed_nodes)};
2669            AddAddrFetch(seed);
2670
2671            if (addrman.get().Size() == 0) {
2672                LogInfo("Empty addrman, adding seednode (%s) to addrfetch\n", seed);
2673            } else {
2674                LogInfo("Couldn't connect to peers from addrman after %d seconds. Adding seednode (%s) to addrfetch\n", ADD_NEXT_SEEDNODE.count(), seed);
2675            }
2676        }
2677
2678        ProcessAddrFetch();
2679
2680        if (!m_interrupt_net->sleep_for(500ms)) {
2681            return;
2682        }
2683
2684        PerformReconnections();
2685
2686        CountingSemaphoreGrant<> grant(*semOutbound);
2687        if (m_interrupt_net->interrupted()) {
2688            return;
2689        }
2690
2691        const std::unordered_set<Network> fixed_seed_networks{GetReachableEmptyNetworks()};
2692        if (add_fixed_seeds && !fixed_seed_networks.empty()) {
2693            // When the node starts with an empty peers.dat, there are a few other sources of peers before
2694            // we fallback on to fixed seeds: -dnsseed, -seednode, -addnode
2695            // If none of those are available, we fallback on to fixed seeds immediately, else we allow
2696            // 60 seconds for any of those sources to populate addrman.
2697            bool add_fixed_seeds_now = false;
2698            // It is cheapest to check if enough time has passed first.
2699            if (GetTime<std::chrono::seconds>() > start + std::chrono::minutes{1}) {
2700                add_fixed_seeds_now = true;
2701                LogInfo("Adding fixed seeds as 60 seconds have passed and addrman is empty for at least one reachable network\n");
2702            }
2703
2704            // Perform cheap checks before locking a mutex.
2705            else if (!dnsseed && !use_seednodes) {
2706                LOCK(m_added_nodes_mutex);
2707                if (m_added_node_params.empty()) {
2708                    add_fixed_seeds_now = true;
2709                    LogInfo("Adding fixed seeds as -dnsseed=0 (or IPv4/IPv6 connections are disabled via -onlynet) and neither -addnode nor -seednode are provided\n");
2710                }
2711            }
2712
2713            if (add_fixed_seeds_now) {
2714                std::vector<CAddress> seed_addrs{ConvertSeeds(m_params.FixedSeeds())};
2715                // We will not make outgoing connections to peers that are unreachable
2716                // (e.g. because of -onlynet configuration).
2717                // Therefore, we do not add them to addrman in the first place.
2718                // In case previously unreachable networks become reachable
2719                // (e.g. in case of -onlynet changes by the user), fixed seeds will
2720                // be loaded only for networks for which we have no addresses.
2721                seed_addrs.erase(std::remove_if(seed_addrs.begin(), seed_addrs.end(),
2722                                                [&fixed_seed_networks](const CAddress& addr) { return !fixed_seed_networks.contains(addr.GetNetwork()); }),
2723                                 seed_addrs.end());
2724                CNetAddr local;
2725                local.SetInternal("fixedseeds");
2726                addrman.get().Add(seed_addrs, local);
2727                add_fixed_seeds = false;
2728                LogInfo("Added %d fixed seeds from reachable networks.\n", seed_addrs.size());
2729            }
2730        }
2731
2732        //
2733        // Choose an address to connect to based on most recently seen
2734        //
2735        CAddress addrConnect;
2736
2737        // Only connect out to one peer per ipv4/ipv6 network group (/16 for IPv4).
2738        int nOutboundFullRelay = 0;
2739        int nOutboundBlockRelay = 0;
2740        int outbound_privacy_network_peers = 0;
2741        std::set<std::vector<unsigned char>> outbound_ipv46_peer_netgroups;
2742
2743        {
2744            LOCK(m_nodes_mutex);
2745            for (const CNode* pnode : m_nodes) {
2746                if (pnode->IsFullOutboundConn()) nOutboundFullRelay++;
2747                if (pnode->IsBlockOnlyConn()) nOutboundBlockRelay++;
2748
2749                // Make sure our persistent outbound slots to ipv4/ipv6 peers belong to different netgroups.
2750                switch (pnode->m_conn_type) {