Connections and transport

2251                pnode->CloseSocketDisconnect();
2252            }
2253            else if (nBytes < 0)
2254            {
2255                // error
2256                int nErr = WSAGetLastError();
2257                if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
2258                {
2259                    if (!pnode->fDisconnect) {
2260                        LogDebug(BCLog::NET, "socket recv error, %s: %s", pnode->DisconnectMsg(), NetworkErrorString(nErr));
2261                    }
2262                    pnode->CloseSocketDisconnect();
2263                }
2264            }
2265        }
2266
2267        if (InactivityCheck(*pnode, now)) pnode->fDisconnect = true;
2268    }
2269}
2270
2271void CConnman::SocketHandlerListening(const Sock::EventsPerSock& events_per_sock)
2272{
2273    AssertLockNotHeld(m_nodes_mutex);
2274
2275    for (const ListenSocket& listen_socket : vhListenSocket) {
2276        if (m_interrupt_net->interrupted()) {
2277            return;
2278        }
2279        const auto it = events_per_sock.find(listen_socket.sock);
2280        if (it != events_per_sock.end() && it->second.occurred & Sock::RecvEvent) {
2281            AcceptConnection(listen_socket);
2282        }
2283    }
2284}
2285
2286void CConnman::ThreadSocketHandler()
2287{
2288    AssertLockNotHeld(m_total_bytes_sent_mutex);
2289
2290    while (!m_interrupt_net->interrupted()) {
2291        DisconnectNodes();
2292        NotifyNumConnectionsChanged();
2293        SocketHandler();
2294    }
2295}
2296
2297void CConnman::WakeMessageHandler()
2298{
2299    {
2300        LOCK(mutexMsgProc);
2301        fMsgProcWake = true;
2302    }
2303    condMsgProc.notify_one();
2304}
2305
2306void CConnman::ThreadDNSAddressSeed()
2307{
2308    int outbound_connection_count = 0;
2309
2310    if (!gArgs.GetArgs("-seednode").empty()) {
2311        auto start = NodeClock::now();
2312        constexpr std::chrono::seconds SEEDNODE_TIMEOUT = 30s;
2313        LogInfo("-seednode enabled. Trying the provided seeds for %d seconds before defaulting to the dnsseeds.\n", SEEDNODE_TIMEOUT.count());
2314        while (!m_interrupt_net->interrupted()) {
2315            if (!m_interrupt_net->sleep_for(500ms)) {
2316                return;
2317            }
2318
2319            // Abort if we have spent enough time without reaching our target.
2320            // Giving seed nodes 30 seconds so this does not become a race against fixedseeds (which triggers after 1 min)
2321            if (NodeClock::now() > start + SEEDNODE_TIMEOUT) {
2322                LogInfo("Couldn't connect to enough peers via seed nodes. Handing fetch logic to the DNS seeds.\n");
2323                break;
2324            }
2325
2326            outbound_connection_count = GetFullOutboundConnCount();
2327            if (outbound_connection_count >= SEED_OUTBOUND_CONNECTION_THRESHOLD) {
2328                LogInfo("P2P peers available. Finished fetching data from seed nodes.\n");
2329                break;
2330            }
2331        }
2332    }
2333
2334    FastRandomContext rng;
2335    std::vector<std::string> seeds = m_params.DNSSeeds();
2336    std::shuffle(seeds.begin(), seeds.end(), rng);
2337    int seeds_right_now = 0; // Number of seeds left before testing if we have enough connections
2338
2339    if (gArgs.GetBoolArg("-forcednsseed", DEFAULT_FORCEDNSSEED)) {
2340        // When -forcednsseed is provided, query all.
2341        seeds_right_now = seeds.size();
2342    } else if (addrman.get().Size() == 0) {
2343        // If we have no known peers, query all.
2344        // This will occur on the first run, or if peers.dat has been
2345        // deleted.
2346        seeds_right_now = seeds.size();
2347    }
2348
2349    // Proceed with dnsseeds if seednodes hasn't reached the target or if forcednsseed is set
2350    if (outbound_connection_count < SEED_OUTBOUND_CONNECTION_THRESHOLD || seeds_right_now) {
2351        // goal: only query DNS seed if address need is acute
2352        // * If we have a reasonable number of peers in addrman, spend
2353        //   some time trying them first. This improves user privacy by
2354        //   creating fewer identifying DNS requests, reduces trust by
2355        //   giving seeds less influence on the network topology, and
2356        //   reduces traffic to the seeds.
2357        // * When querying DNS seeds query a few at once, this ensures
2358        //   that we don't give DNS seeds the ability to eclipse nodes
2359        //   that query them.
2360        // * If we continue having problems, eventually query all the
2361        //   DNS seeds, and if that fails too, also try the fixed seeds.
2362        //   (done in ThreadOpenConnections)
2363        int found = 0;
2364        const std::chrono::seconds seeds_wait_time = (addrman.get().Size() >= DNSSEEDS_DELAY_PEER_THRESHOLD ? DNSSEEDS_DELAY_MANY_PEERS : DNSSEEDS_DELAY_FEW_PEERS);
2365
2366        for (const std::string& seed : seeds) {
2367            if (seeds_right_now == 0) {
2368                seeds_right_now += DNSSEEDS_TO_QUERY_AT_ONCE;
2369
2370                if (addrman.get().Size() > 0) {
2371                    LogInfo("Waiting %d seconds before querying DNS seeds.\n", seeds_wait_time.count());
2372                    std::chrono::seconds to_wait = seeds_wait_time;
2373                    while (to_wait.count() > 0) {
2374                        // if sleeping for the MANY_PEERS interval, wake up
2375                        // early to see if we have enough peers and can stop
2376                        // this thread entirely freeing up its resources
2377                        std::chrono::seconds w = std::min(DNSSEEDS_DELAY_FEW_PEERS, to_wait);
2378                        if (!m_interrupt_net->sleep_for(w)) return;
2379                        to_wait -= w;
2380
2381                        if (GetFullOutboundConnCount() >= SEED_OUTBOUND_CONNECTION_THRESHOLD) {
2382                            if (found > 0) {
2383                                LogInfo("%d addresses found from DNS seeds\n", found);
2384                                LogInfo("P2P peers available. Finished DNS seeding.\n");
2385                            } else {
2386                                LogInfo("P2P peers available. Skipped DNS seeding.\n");
2387                            }
2388                            return;
2389                        }
2390                    }
2391                }
2392            }
2393
2394            if (m_interrupt_net->interrupted()) return;
2395
2396            // hold off on querying seeds if P2P network deactivated
2397            if (!fNetworkActive) {
2398                LogInfo("Waiting for network to be reactivated before querying DNS seeds.\n");
2399                do {
2400                    if (!m_interrupt_net->sleep_for(1s)) return;
2401                } while (!fNetworkActive);
2402            }
2403
2404            LogInfo("Loading addresses from DNS seed %s\n", seed);
2405            // If -proxy is in use, we make an ADDR_FETCH connection to the DNS resolved peer address
2406            // for the base dns seed domain in chainparams
2407            if (HaveNameProxy()) {
2408                AddAddrFetch(seed);
2409            } else {
2410                std::vector<CAddress> vAdd;
2411                constexpr ServiceFlags requiredServiceBits{SeedsServiceFlags()};
2412                std::string host = strprintf("x%x.%s", requiredServiceBits, seed);
2413                CNetAddr resolveSource;
2414                if (!resolveSource.SetInternal(host)) {
2415                    continue;
2416                }
2417                // Limit number of IPs learned from a single DNS seed. This limit exists to prevent the results from
2418                // one DNS seed from dominating AddrMan. Note that the number of results from a UDP DNS query is
2419                // bounded to 33 already, but it is possible for it to use TCP where a larger number of results can be
2420                // returned.
2421                unsigned int nMaxIPs = 32;
2422                const auto addresses{LookupHost(host, nMaxIPs, true)};
2423                if (!addresses.empty()) {
2424                    for (const CNetAddr& ip : addresses) {
2425                        CAddress addr = CAddress(CService(ip, m_params.GetDefaultPort()), SeedsAssumedServiceFlags());
2426                        addr.nTime = rng.rand_uniform_delay(Now<NodeSeconds>() - 3 * 24h, -4 * 24h); // use a random age between 3 and 7 days old
2427                        vAdd.push_back(addr);
2428                        found++;
2429                    }
2430                    addrman.get().Add(vAdd, resolveSource);
2431                } else {
2432                    // If the seed does not support a subdomain with our desired service bits,
2433                    // we make an ADDR_FETCH connection to the DNS resolved peer address for the
2434                    // base dns seed domain in chainparams
2435                    AddAddrFetch(seed);
2436                }
2437            }
2438            --seeds_right_now;
2439        }
2440        LogInfo("%d addresses found from DNS seeds\n", found);
2441    } else {
2442        LogInfo("Skipping DNS seeds. Enough peers have been found\n");
2443    }
2444}
2445
2446void CConnman::DumpAddresses()
2447{
2448    const auto start{SteadyClock::now()};
2449
2450    DumpPeerAddresses(::gArgs, addrman);
2451
2452    LogDebug(BCLog::NET, "Flushed %d addresses to peers.dat %dms",
2453             addrman.get().Size(), Ticks<std::chrono::milliseconds>(SteadyClock::now() - start));
2454}
2455
2456void CConnman::ProcessAddrFetch()
2457{
2458    AssertLockNotHeld(m_nodes_mutex);
2459    AssertLockNotHeld(m_unused_i2p_sessions_mutex);
2460    std::string strDest;
2461    {
2462        LOCK(m_addr_fetches_mutex);
2463        if (m_addr_fetches.empty())
2464            return;
2465        strDest = m_addr_fetches.front();
2466        m_addr_fetches.pop_front();
2467    }
2468    // Attempt v2 connection if we support v2 - we'll reconnect with v1 if our
2469    // peer doesn't support it or immediately disconnects us for another reason.
2470    const bool use_v2transport(GetLocalServices() & NODE_P2P_V2);
2471    CAddress addr;
2472    CountingSemaphoreGrant<> grant(*semOutbound, /*fTry=*/true);
2473    if (grant) {
2474        OpenNetworkConnection(/*addrConnect=*/addr,
2475                              /*fCountFailure=*/false,
2476                              /*grant_outbound=*/std::move(grant),
2477                              /*pszDest=*/strDest.c_str(),
2478                              /*conn_type=*/ConnectionType::ADDR_FETCH,
2479                              /*use_v2transport=*/use_v2transport,
2480                              /*proxy_override=*/std::nullopt);
2481    }
2482}
2483
2484bool CConnman::GetTryNewOutboundPeer() const
2485{
2486    return m_try_another_outbound_peer;
2487}
2488
2489void CConnman::SetTryNewOutboundPeer(bool flag)
2490{
2491    m_try_another_outbound_peer = flag;
2492    LogDebug(BCLog::NET, "setting try another outbound peer=%s\n", flag ? "true" : "false");
2493}
2494
2495void CConnman::StartExtraBlockRelayPeers()
2496{
2497    LogDebug(BCLog::NET, "enabling extra block-relay-only peers\n");
2498    m_start_extra_block_relay_peers = true;
2499}
2500