Connections and transport

3001    }
3002
3003    return ret;
3004}
3005
3006std::vector<AddedNodeInfo> CConnman::GetAddedNodeInfo(bool include_connected) const
3007{
3008    AssertLockNotHeld(m_nodes_mutex);
3009
3010    std::vector<AddedNodeInfo> ret;
3011
3012    std::list<AddedNodeParams> lAddresses(0);
3013    {
3014        LOCK(m_added_nodes_mutex);
3015        ret.reserve(m_added_node_params.size());
3016        std::copy(m_added_node_params.cbegin(), m_added_node_params.cend(), std::back_inserter(lAddresses));
3017    }
3018
3019
3020    // Build a map of all already connected addresses (by IP:port and by name) to inbound/outbound and resolved CService
3021    std::map<CService, bool> mapConnected;
3022    std::map<std::string, std::pair<bool, CService>> mapConnectedByName;
3023    {
3024        LOCK(m_nodes_mutex);
3025        for (const CNode* pnode : m_nodes) {
3026            if (pnode->addr.IsValid()) {
3027                mapConnected[pnode->addr] = pnode->IsInboundConn();
3028            }
3029            std::string addrName{pnode->m_addr_name};
3030            if (!addrName.empty()) {
3031                mapConnectedByName[std::move(addrName)] = std::make_pair(pnode->IsInboundConn(), static_cast<const CService&>(pnode->addr));
3032            }
3033        }
3034    }
3035
3036    for (const auto& addr : lAddresses) {
3037        CService service{MaybeFlipIPv6toCJDNS(LookupNumeric(addr.m_added_node, GetDefaultPort(addr.m_added_node)))};
3038        AddedNodeInfo addedNode{addr, CService(), false, false};
3039        if (service.IsValid()) {
3040            // strAddNode is an IP:port
3041            auto it = mapConnected.find(service);
3042            if (it != mapConnected.end()) {
3043                if (!include_connected) {
3044                    continue;
3045                }
3046                addedNode.resolvedAddress = service;
3047                addedNode.fConnected = true;
3048                addedNode.fInbound = it->second;
3049            }
3050        } else {
3051            // strAddNode is a name
3052            auto it = mapConnectedByName.find(addr.m_added_node);
3053            if (it != mapConnectedByName.end()) {
3054                if (!include_connected) {
3055                    continue;
3056                }
3057                addedNode.resolvedAddress = it->second.second;
3058                addedNode.fConnected = true;
3059                addedNode.fInbound = it->second.first;
3060            }
3061        }
3062        ret.emplace_back(std::move(addedNode));
3063    }
3064
3065    return ret;
3066}
3067
3068void CConnman::ThreadOpenAddedConnections()
3069{
3070    AssertLockNotHeld(m_nodes_mutex);
3071    AssertLockNotHeld(m_reconnections_mutex);
3072    AssertLockNotHeld(m_unused_i2p_sessions_mutex);
3073
3074    while (true)
3075    {
3076        CountingSemaphoreGrant<> grant(*semAddnode);
3077        std::vector<AddedNodeInfo> vInfo = GetAddedNodeInfo(/*include_connected=*/false);
3078        bool tried = false;
3079        for (const AddedNodeInfo& info : vInfo) {
3080            if (!grant) {
3081                // If we've used up our semaphore and need a new one, let's not wait here since while we are waiting
3082                // the addednodeinfo state might change.
3083                break;
3084            }
3085            tried = true;
3086            OpenNetworkConnection(/*addrConnect=*/CAddress{CService{}, NODE_NONE},
3087                                  /*fCountFailure=*/false,
3088                                  /*grant_outbound=*/std::move(grant),
3089                                  /*pszDest=*/info.m_params.m_added_node.c_str(),
3090                                  /*conn_type=*/ConnectionType::MANUAL,
3091                                  /*use_v2transport=*/info.m_params.m_use_v2transport,
3092                                  /*proxy_override=*/std::nullopt);
3093            if (!m_interrupt_net->sleep_for(500ms)) return;
3094            grant = CountingSemaphoreGrant<>(*semAddnode, /*fTry=*/true);
3095        }
3096        // See if any reconnections are desired.
3097        PerformReconnections();
3098        // Retry every 60 seconds if a connection was attempted, otherwise two seconds
3099        if (!m_interrupt_net->sleep_for(tried ? 60s : 2s)) {
3100            return;
3101        }
3102    }
3103}
3104
3105// if successful, this moves the passed grant to the constructed node
3106bool CConnman::OpenNetworkConnection(const CAddress& addrConnect,
3107                                     bool fCountFailure,
3108                                     CountingSemaphoreGrant<>&& grant_outbound,
3109                                     const char* pszDest,
3110                                     ConnectionType conn_type,
3111                                     bool use_v2transport,
3112                                     const std::optional<Proxy>& proxy_override)
3113{
3114    AssertLockNotHeld(m_nodes_mutex);
3115    AssertLockNotHeld(m_unused_i2p_sessions_mutex);
3116    assert(conn_type != ConnectionType::INBOUND);
3117
3118    //
3119    // Initiate outbound network connection
3120    //
3121    if (m_interrupt_net->interrupted()) {
3122        return false;
3123    }
3124    if (!fNetworkActive) {
3125        return false;
3126    }
3127    if (!pszDest) {
3128        bool banned_or_discouraged = m_banman && (m_banman->IsDiscouraged(addrConnect) || m_banman->IsBanned(addrConnect));
3129        if (IsLocal(addrConnect) || banned_or_discouraged || AlreadyConnectedToAddress(addrConnect)) {
3130            return false;
3131        }
3132    } else if (AlreadyConnectedToHost(pszDest)) {
3133        return false;
3134    }
3135
3136    CNode* pnode = ConnectNode(addrConnect, pszDest, fCountFailure, conn_type, use_v2transport, proxy_override);
3137
3138    if (!pnode)
3139        return false;
3140    pnode->grantOutbound = std::move(grant_outbound);
3141
3142    m_msgproc->InitializeNode(*pnode, m_local_services);
3143    {
3144        LOCK(m_nodes_mutex);
3145        m_nodes.push_back(pnode);
3146
3147        // update connection count by network
3148        if (pnode->IsManualOrFullOutboundConn()) ++m_network_conn_counts[pnode->addr.GetNetwork()];
3149    }
3150
3151    TRACEPOINT(net, outbound_connection,
3152        pnode->GetId(),
3153        pnode->m_addr_name.c_str(),
3154        pnode->ConnectionTypeAsString().c_str(),
3155        pnode->ConnectedThroughNetwork(),
3156        GetNodeCount(ConnectionDirection::Out));
3157
3158    return true;
3159}
3160
3161std::optional<Network> CConnman::PrivateBroadcast::PickNetwork(std::optional<Proxy>& proxy) const
3162{
3163    prevector<4, Network> nets;
3164    std::optional<Proxy> clearnet_proxy;
3165    proxy.reset();
3166    if (g_reachable_nets.Contains(NET_ONION)) {
3167        nets.push_back(NET_ONION);
3168
3169        clearnet_proxy = ProxyForIPv4or6();
3170        if (clearnet_proxy.has_value()) {
3171            if (g_reachable_nets.Contains(NET_IPV4)) {
3172                nets.push_back(NET_IPV4);
3173            }
3174            if (g_reachable_nets.Contains(NET_IPV6)) {
3175                nets.push_back(NET_IPV6);
3176            }
3177        }
3178    }
3179    if (g_reachable_nets.Contains(NET_I2P)) {
3180        nets.push_back(NET_I2P);
3181    }
3182
3183    if (nets.empty()) {
3184        return std::nullopt;
3185    }
3186
3187    const Network net{nets[FastRandomContext{}.randrange(nets.size())]};
3188    if (net == NET_IPV4 || net == NET_IPV6) {
3189        proxy = clearnet_proxy;
3190    }
3191    return net;
3192}
3193
3194size_t CConnman::PrivateBroadcast::NumToOpen() const
3195{
3196    return m_num_to_open;
3197}
3198
3199void CConnman::PrivateBroadcast::NumToOpenAdd(size_t n)
3200{
3201    m_num_to_open += n;
3202    m_num_to_open.notify_all();
3203}
3204
3205size_t CConnman::PrivateBroadcast::NumToOpenSub(size_t n)
3206{
3207    size_t current_value{m_num_to_open.load()};
3208    size_t new_value;
3209    do {
3210        new_value = current_value > n ? current_value - n : 0;
3211    } while (!m_num_to_open.compare_exchange_strong(current_value, new_value));
3212    return new_value;
3213}
3214
3215void CConnman::PrivateBroadcast::NumToOpenWait() const
3216{
3217    m_num_to_open.wait(0);
3218}
3219
3220std::optional<Proxy> CConnman::PrivateBroadcast::ProxyForIPv4or6() const
3221{
3222    if (m_outbound_tor_ok_at_least_once.load()) {
3223        if (const auto tor_proxy = GetProxy(NET_ONION)) {
3224            return tor_proxy;
3225        }
3226    }
3227    return std::nullopt;
3228}
3229
3230Mutex NetEventsInterface::g_msgproc_mutex;
3231
3232void CConnman::ThreadMessageHandler()
3233{
3234    AssertLockNotHeld(m_nodes_mutex);
3235
3236    LOCK(NetEventsInterface::g_msgproc_mutex);
3237
3238    while (!flagInterruptMsgProc)
3239    {
3240        bool fMoreWork = false;
3241
3242        {
3243            // Randomize the order in which we process messages from/to our peers.
3244            // This prevents attacks in which an attacker exploits having multiple
3245            // consecutive connections in the m_nodes list.
3246            const NodesSnapshot snap{*this, /*shuffle=*/true};
3247
3248            for (CNode* pnode : snap.Nodes()) {
3249                if (pnode->fDisconnect)
3250                    continue;