Connections and transport

3501    SetNetworkActive(network_active);
3502}
3503
3504NodeId CConnman::GetNewNodeId()
3505{
3506    return nLastNodeId.fetch_add(1, std::memory_order_relaxed);
3507}
3508
3509uint16_t CConnman::GetDefaultPort(Network net) const
3510{
3511    return net == NET_I2P ? I2P_SAM31_PORT : m_params.GetDefaultPort();
3512}
3513
3514uint16_t CConnman::GetDefaultPort(const std::string& addr) const
3515{
3516    CNetAddr a;
3517    return a.SetSpecial(addr) ? GetDefaultPort(a.GetNetwork()) : m_params.GetDefaultPort();
3518}
3519
3520bool CConnman::Bind(const CService& addr_, unsigned int flags, NetPermissionFlags permissions)
3521{
3522    const CService addr{MaybeFlipIPv6toCJDNS(addr_)};
3523
3524    bilingual_str strError;
3525    if (!BindListenPort(addr, strError, permissions)) {
3526        if ((flags & BF_REPORT_ERROR) && m_client_interface) {
3527            m_client_interface->ThreadSafeMessageBox(strError, CClientUIInterface::MSG_ERROR);
3528        }
3529        return false;
3530    }
3531
3532    if (addr.IsRoutable() && fDiscover && !(flags & BF_DONT_ADVERTISE) && !NetPermissions::HasFlag(permissions, NetPermissionFlags::NoBan)) {
3533        AddLocal(addr, LOCAL_BIND);
3534    }
3535
3536    return true;
3537}
3538
3539bool CConnman::InitBinds(const Options& options)
3540{
3541    for (const auto& addrBind : options.vBinds) {
3542        if (!Bind(addrBind, BF_REPORT_ERROR, NetPermissionFlags::None)) {
3543            return false;
3544        }
3545    }
3546    for (const auto& addrBind : options.vWhiteBinds) {
3547        if (!Bind(addrBind.m_service, BF_REPORT_ERROR, addrBind.m_flags)) {
3548            return false;
3549        }
3550    }
3551    for (const auto& addr_bind : options.onion_binds) {
3552        if (!Bind(addr_bind, BF_REPORT_ERROR | BF_DONT_ADVERTISE, NetPermissionFlags::None)) {
3553            return false;
3554        }
3555    }
3556    if (options.bind_on_any) {
3557        // Don't consider errors to bind on IPv6 "::" fatal because the host OS
3558        // may not have IPv6 support and the user did not explicitly ask us to
3559        // bind on that.
3560        const CService ipv6_any{in6_addr(COMPAT_IN6ADDR_ANY_INIT), GetListenPort()}; // ::
3561        Bind(ipv6_any, BF_NONE, NetPermissionFlags::None);
3562
3563        struct in_addr inaddr_any;
3564        inaddr_any.s_addr = htonl(INADDR_ANY);
3565        const CService ipv4_any{inaddr_any, GetListenPort()}; // 0.0.0.0
3566        if (!Bind(ipv4_any, BF_REPORT_ERROR, NetPermissionFlags::None)) {
3567            return false;
3568        }
3569    }
3570    return true;
3571}
3572
3573bool CConnman::Start(CScheduler& scheduler, const Options& connOptions)
3574{
3575    AssertLockNotHeld(m_total_bytes_sent_mutex);
3576    Init(connOptions);
3577
3578    if (fListen && !InitBinds(connOptions)) {
3579        if (m_client_interface) {
3580            m_client_interface->ThreadSafeMessageBox(
3581                _("Failed to listen on any port. Use -listen=0 if you want this."),
3582                CClientUIInterface::MSG_ERROR);
3583        }
3584        return false;
3585    }
3586
3587    if (connOptions.m_i2p_accept_incoming) {
3588        if (const auto i2p_sam = GetProxy(NET_I2P)) {
3589            m_i2p_sam_session = std::make_unique<i2p::sam::Session>(gArgs.GetDataDirNet() / "i2p_private_key",
3590                                                                    *i2p_sam, m_interrupt_net);
3591        }
3592    }
3593
3594    // Randomize the order in which we may query seednode to potentially prevent connecting to the same one every restart (and signal that we have restarted)
3595    std::vector<std::string> seed_nodes = connOptions.vSeedNodes;
3596    if (!seed_nodes.empty()) {
3597        std::shuffle(seed_nodes.begin(), seed_nodes.end(), FastRandomContext{});
3598    }
3599
3600    if (m_use_addrman_outgoing) {
3601        // Load addresses from anchors.dat
3602        m_anchors = ReadAnchors(gArgs.GetDataDirNet() / ANCHORS_DATABASE_FILENAME);
3603        if (m_anchors.size() > MAX_BLOCK_RELAY_ONLY_ANCHORS) {
3604            m_anchors.resize(MAX_BLOCK_RELAY_ONLY_ANCHORS);
3605        }
3606        LogInfo("%i block-relay-only anchors will be tried for connections.\n", m_anchors.size());
3607    }
3608
3609    if (m_client_interface) {
3610        m_client_interface->InitMessage(_("Starting network threads…"));
3611    }
3612
3613    fAddressesInitialized = true;
3614
3615    if (semOutbound == nullptr) {
3616        // initialize semaphore
3617        semOutbound = std::make_unique<std::counting_semaphore<>>(std::min(m_max_automatic_outbound, m_max_automatic_connections));
3618    }
3619    if (semAddnode == nullptr) {
3620        // initialize semaphore
3621        semAddnode = std::make_unique<std::counting_semaphore<>>(m_max_addnode);
3622    }
3623
3624    //
3625    // Start threads
3626    //
3627    assert(m_msgproc);
3628    m_interrupt_net->reset();
3629    flagInterruptMsgProc = false;
3630
3631    {
3632        LOCK(mutexMsgProc);
3633        fMsgProcWake = false;
3634    }
3635
3636    // Send and receive from sockets, accept connections
3637    threadSocketHandler = std::thread(&util::TraceThread, "net", [this] { ThreadSocketHandler(); });
3638
3639    if (!gArgs.GetBoolArg("-dnsseed", DEFAULT_DNSSEED))
3640        LogInfo("DNS seeding disabled\n");
3641    else
3642        threadDNSAddressSeed = std::thread(&util::TraceThread, "dnsseed", [this] { ThreadDNSAddressSeed(); });
3643
3644    // Initiate manual connections
3645    threadOpenAddedConnections = std::thread(&util::TraceThread, "addcon", [this] { ThreadOpenAddedConnections(); });
3646
3647    if (connOptions.m_use_addrman_outgoing && !connOptions.m_specified_outgoing.empty()) {
3648        if (m_client_interface) {
3649            m_client_interface->ThreadSafeMessageBox(
3650                _("Cannot provide specific connections and have addrman find outgoing connections at the same time."),
3651                CClientUIInterface::MSG_ERROR);
3652        }
3653        return false;
3654    }
3655    if (connOptions.m_use_addrman_outgoing || !connOptions.m_specified_outgoing.empty()) {
3656        threadOpenConnections = std::thread(
3657            &util::TraceThread, "opencon",
3658            [this, connect = connOptions.m_specified_outgoing, seed_nodes = std::move(seed_nodes)] { ThreadOpenConnections(connect, seed_nodes); });
3659    }
3660
3661    // Process messages
3662    threadMessageHandler = std::thread(&util::TraceThread, "msghand", [this] { ThreadMessageHandler(); });
3663
3664    if (m_i2p_sam_session) {
3665        threadI2PAcceptIncoming =
3666            std::thread(&util::TraceThread, "i2paccept", [this] { ThreadI2PAcceptIncoming(); });
3667    }
3668
3669    if (gArgs.GetBoolArg("-privatebroadcast", DEFAULT_PRIVATE_BROADCAST)) {
3670        threadPrivateBroadcast =
3671            std::thread(&util::TraceThread, "privbcast", [this] { ThreadPrivateBroadcast(); });
3672    }
3673
3674    // Dump network addresses
3675    scheduler.scheduleEvery([this] { DumpAddresses(); }, DUMP_PEERS_INTERVAL);
3676
3677    // Run the ASMap Health check once and then schedule it to run every 24h.
3678    if (m_netgroupman.UsingASMap()) {
3679        ASMapHealthCheck();
3680        scheduler.scheduleEvery([this] { ASMapHealthCheck(); }, ASMAP_HEALTH_CHECK_INTERVAL);
3681    }
3682
3683    return true;
3684}
3685
3686class CNetCleanup
3687{
3688public:
3689    CNetCleanup() = default;
3690
3691    ~CNetCleanup()
3692    {
3693#ifdef WIN32
3694        // Shutdown Windows Sockets
3695        WSACleanup();
3696#endif
3697    }
3698};
3699static CNetCleanup instance_of_cnetcleanup;
3700
3701void CConnman::Interrupt()
3702{
3703    {
3704        LOCK(mutexMsgProc);
3705        flagInterruptMsgProc = true;
3706    }
3707    condMsgProc.notify_all();
3708
3709    (*m_interrupt_net)();
3710    g_socks5_interrupt();
3711
3712    if (semOutbound) {
3713        for (int i=0; i<m_max_automatic_outbound; i++) {
3714            semOutbound->release();
3715        }
3716    }
3717
3718    if (semAddnode) {
3719        for (int i=0; i<m_max_addnode; i++) {
3720            semAddnode->release();
3721        }
3722    }
3723
3724    m_private_broadcast.m_sem_conn_max.release();
3725    m_private_broadcast.NumToOpenAdd(1); // Just unblock NumToOpenWait() to be able to continue with shutdown.
3726}
3727
3728void CConnman::StopThreads()
3729{
3730    if (threadPrivateBroadcast.joinable()) {
3731        threadPrivateBroadcast.join();
3732    }
3733    if (threadI2PAcceptIncoming.joinable()) {
3734        threadI2PAcceptIncoming.join();
3735    }
3736    if (threadMessageHandler.joinable())
3737        threadMessageHandler.join();
3738    if (threadOpenConnections.joinable())
3739        threadOpenConnections.join();
3740    if (threadOpenAddedConnections.joinable())
3741        threadOpenAddedConnections.join();
3742    if (threadDNSAddressSeed.joinable())
3743        threadDNSAddressSeed.join();
3744    if (threadSocketHandler.joinable())
3745        threadSocketHandler.join();
3746}
3747
3748void CConnman::StopNodes()
3749{
3750    AssertLockNotHeld(m_nodes_mutex);