Method ThreadMessageHandler

src/net.cpp:2272–2321

Mutex NetEventsInterface::g_msgproc_mutex;

void CConnman::ThreadMessageHandler() {
    LOCK(NetEventsInterface::g_msgproc_mutex);

    while (!flagInterruptMsgProc) {
        bool fMoreWork = false;

        {
            // Randomize the order in which we process messages from/to our
            // peers. This prevents attacks in which an attacker exploits having
            // multiple consecutive connections in the vNodes list.
            const NodesSnapshot snap{*this, /*shuffle=*/true};

            for (CNode *pnode : snap.Nodes()) {
                if (pnode->fDisconnect) {
                    continue;
                }

                bool fMoreNodeWork = false;
                // Receive messages
                for (auto interface : m_msgproc) {
                    fMoreNodeWork |= interface->ProcessMessages(
                        *config, pnode, flagInterruptMsgProc);
                }
                fMoreWork |= (fMoreNodeWork && !pnode->fPauseSend);
                if (flagInterruptMsgProc) {
                    return;
                }

                // Send messages
                for (auto interface : m_msgproc) {
                    interface->SendMessages(*config, pnode);
                }

                if (flagInterruptMsgProc) {
                    return;
                }
            }
        }

        WAIT_LOCK(mutexMsgProc, lock);
        if (!fMoreWork) {
            condMsgProc.wait_until(lock,
                                   std::chrono::steady_clock::now() +
                                       std::chrono::milliseconds(100),
                                   [this]() EXCLUSIVE_LOCKS_REQUIRED(
                                       mutexMsgProc) { return fMsgProcWake; });
        }
        fMsgProcWake = false;
    }
}

void CConnman::ThreadI2PAcceptIncoming() {
    static constexpr auto err_wait_begin = 1s;