Connections and transport

1501    auto short_message_id = V2_MESSAGE_MAP(msg.m_type);
1502    if (short_message_id) {
1503        contents.resize(1 + msg.data.size());
1504        contents[0] = *short_message_id;
1505        std::copy(msg.data.begin(), msg.data.end(), contents.begin() + 1);
1506    } else {
1507        // Initialize with zeroes, and then write the message type string starting at offset 1.
1508        // This means contents[0] and the unused positions in contents[1..13] remain 0x00.
1509        contents.resize(1 + CMessageHeader::MESSAGE_TYPE_SIZE + msg.data.size(), 0);
1510        std::copy(msg.m_type.begin(), msg.m_type.end(), contents.data() + 1);
1511        std::copy(msg.data.begin(), msg.data.end(), contents.begin() + 1 + CMessageHeader::MESSAGE_TYPE_SIZE);
1512    }
1513    // Construct ciphertext in send buffer.
1514    m_send_buffer.resize(contents.size() + BIP324Cipher::EXPANSION);
1515    m_cipher.Encrypt(MakeByteSpan(contents), {}, false, MakeWritableByteSpan(m_send_buffer));
1516    m_send_type = msg.m_type;
1517    // Release memory
1518    ClearShrink(msg.data);
1519    return true;
1520}
1521
1522Transport::BytesToSend V2Transport::GetBytesToSend(bool have_next_message) const noexcept
1523{
1524    AssertLockNotHeld(m_send_mutex);
1525    LOCK(m_send_mutex);
1526    if (m_send_state == SendState::V1) return m_v1_fallback.GetBytesToSend(have_next_message);
1527
1528    if (m_send_state == SendState::MAYBE_V1) Assume(m_send_buffer.empty());
1529    Assume(m_send_pos <= m_send_buffer.size());
1530    return {
1531        std::span{m_send_buffer}.subspan(m_send_pos),
1532        // We only have more to send after the current m_send_buffer if there is a (next)
1533        // message to be sent, and we're capable of sending packets. */
1534        have_next_message && m_send_state == SendState::READY,
1535        m_send_type
1536    };
1537}
1538
1539void V2Transport::MarkBytesSent(size_t bytes_sent) noexcept
1540{
1541    AssertLockNotHeld(m_send_mutex);
1542    LOCK(m_send_mutex);
1543    if (m_send_state == SendState::V1) return m_v1_fallback.MarkBytesSent(bytes_sent);
1544
1545    if (m_send_state == SendState::AWAITING_KEY && m_send_pos == 0 && bytes_sent > 0) {
1546        LogDebug(BCLog::NET, "start sending v2 handshake to peer=%d\n", m_nodeid);
1547    }
1548
1549    m_send_pos += bytes_sent;
1550    Assume(m_send_pos <= m_send_buffer.size());
1551    if (m_send_pos >= CMessageHeader::HEADER_SIZE) {
1552        m_sent_v1_header_worth = true;
1553    }
1554    // Wipe the buffer when everything is sent.
1555    if (m_send_pos == m_send_buffer.size()) {
1556        m_send_pos = 0;
1557        ClearShrink(m_send_buffer);
1558    }
1559}
1560
1561bool V2Transport::ShouldReconnectV1() const noexcept
1562{
1563    AssertLockNotHeld(m_send_mutex);
1564    AssertLockNotHeld(m_recv_mutex);
1565    // Only outgoing connections need reconnection.
1566    if (!m_initiating) return false;
1567
1568    LOCK(m_recv_mutex);
1569    // We only reconnect in the very first state and when the receive buffer is empty. Together
1570    // these conditions imply nothing has been received so far.
1571    if (m_recv_state != RecvState::KEY) return false;
1572    if (!m_recv_buffer.empty()) return false;
1573    // Check if we've sent enough for the other side to disconnect us (if it was V1).
1574    LOCK(m_send_mutex);
1575    return m_sent_v1_header_worth;
1576}
1577
1578size_t V2Transport::GetSendMemoryUsage() const noexcept
1579{
1580    AssertLockNotHeld(m_send_mutex);
1581    LOCK(m_send_mutex);
1582    if (m_send_state == SendState::V1) return m_v1_fallback.GetSendMemoryUsage();
1583
1584    return sizeof(m_send_buffer) + memusage::DynamicUsage(m_send_buffer);
1585}
1586
1587Transport::Info V2Transport::GetInfo() const noexcept
1588{
1589    AssertLockNotHeld(m_recv_mutex);
1590    LOCK(m_recv_mutex);
1591    if (m_recv_state == RecvState::V1) return m_v1_fallback.GetInfo();
1592
1593    Transport::Info info;
1594
1595    // Do not report v2 and session ID until the version packet has been received
1596    // and verified (confirming that the other side very likely has the same keys as us).
1597    if (m_recv_state != RecvState::KEY_MAYBE_V1 && m_recv_state != RecvState::KEY &&
1598        m_recv_state != RecvState::GARB_GARBTERM && m_recv_state != RecvState::VERSION) {
1599        info.transport_type = TransportProtocolType::V2;
1600        info.session_id = uint256(MakeUCharSpan(m_cipher.GetSessionID()));
1601    } else {
1602        info.transport_type = TransportProtocolType::DETECTING;
1603    }
1604
1605    return info;
1606}
1607
1608std::pair<size_t, bool> CConnman::SocketSendData(CNode& node) const
1609{
1610    auto it = node.vSendMsg.begin();
1611    size_t nSentSize = 0;
1612    bool data_left{false}; //!< second return value (whether unsent data remains)
1613    std::optional<bool> expected_more;
1614
1615    while (true) {
1616        if (it != node.vSendMsg.end()) {
1617            // If possible, move one message from the send queue to the transport. This fails when
1618            // there is an existing message still being sent, or (for v2 transports) when the
1619            // handshake has not yet completed.
1620            size_t memusage = it->GetMemoryUsage();
1621            if (node.m_transport->SetMessageToSend(*it)) {
1622                // Update memory usage of send buffer (as *it will be deleted).
1623                node.m_send_memusage -= memusage;
1624                ++it;
1625            }
1626        }
1627        const auto& [data, more, msg_type] = node.m_transport->GetBytesToSend(it != node.vSendMsg.end());
1628        // We rely on the 'more' value returned by GetBytesToSend to correctly predict whether more
1629        // bytes are still to be sent, to correctly set the MSG_MORE flag. As a sanity check,
1630        // verify that the previously returned 'more' was correct.
1631        if (expected_more.has_value()) Assume(!data.empty() == *expected_more);
1632        expected_more = more;
1633        data_left = !data.empty(); // will be overwritten on next loop if all of data gets sent
1634        int nBytes = 0;
1635        if (!data.empty()) {
1636            LOCK(node.m_sock_mutex);
1637            // There is no socket in case we've already disconnected, or in test cases without
1638            // real connections. In these cases, we bail out immediately and just leave things
1639            // in the send queue and transport.
1640            if (!node.m_sock) {
1641                break;
1642            }
1643            int flags = MSG_NOSIGNAL | MSG_DONTWAIT;
1644#ifdef MSG_MORE
1645            if (more) {
1646                flags |= MSG_MORE;
1647            }
1648#endif
1649            nBytes = node.m_sock->Send(data.data(), data.size(), flags);
1650        }
1651        if (nBytes > 0) {
1652            node.m_last_send = NodeClock::now();
1653            node.nSendBytes += nBytes;
1654            // Notify transport that bytes have been processed.
1655            node.m_transport->MarkBytesSent(nBytes);
1656            // Update statistics per message type.
1657            if (!msg_type.empty()) { // don't report v2 handshake bytes for now
1658                node.AccountForSentBytes(msg_type, nBytes);
1659            }
1660            nSentSize += nBytes;
1661            if ((size_t)nBytes != data.size()) {
1662                // could not send full message; stop sending more
1663                break;
1664            }
1665        } else {
1666            if (nBytes < 0) {
1667                // error
1668                int nErr = WSAGetLastError();
1669                if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS) {
1670                    LogDebug(BCLog::NET, "socket send error, %s: %s", node.DisconnectMsg(), NetworkErrorString(nErr));
1671                    node.CloseSocketDisconnect();
1672                }
1673            }
1674            break;
1675        }
1676    }
1677
1678    const bool pause_send{node.m_send_memusage + node.m_transport->GetSendMemoryUsage() > nSendBufferMaxSize};
1679    if (pause_send && !node.fPauseSend) {
1680        node.m_pause_send_since = NodeClock::now();
1681    }
1682    node.fPauseSend = pause_send;
1683
1684    if (it == node.vSendMsg.end()) {
1685        assert(node.m_send_memusage == 0);
1686    }
1687    node.vSendMsg.erase(node.vSendMsg.begin(), it);
1688    return {nSentSize, data_left};
1689}
1690
1691/** Try to find an inbound connection to evict.
1692 *  Extreme care must be taken to avoid opening the node to attacker
1693 *   triggered network partitioning.
1694 *  The strategy used here is to protect a small number of peers
1695 *   for each of several distinct characteristics which are difficult
1696 *   to forge.  In order to partition a node the attacker must be
1697 *   simultaneously better at all of them than honest peers.
1698 */
1699bool CConnman::AttemptToEvictConnection(bool evict_tx_relay_peer_only, std::optional<NodeId> protect_peer)
1700{
1701    AssertLockNotHeld(m_nodes_mutex);
1702
1703    std::vector<NodeEvictionCandidate> vEvictionCandidates;
1704    {
1705
1706        LOCK(m_nodes_mutex);
1707        for (const CNode* node : m_nodes) {
1708            if (node->fDisconnect)
1709                continue;
1710            if (protect_peer.has_value() && node->GetId() == protect_peer) {
1711                continue;
1712            }
1713            if (evict_tx_relay_peer_only && !node->m_relays_txs) {
1714                continue;
1715            }
1716            NodeEvictionCandidate candidate{
1717                .id = node->GetId(),
1718                .m_connected = node->m_connected,
1719                .m_min_ping_time = node->m_min_ping_time,
1720                .m_last_block_time = node->m_last_block_time,
1721                .m_last_tx_time = node->m_last_tx_time,
1722                .fRelevantServices = node->m_has_all_wanted_services,
1723                .m_relay_txs = node->m_relays_txs.load(),
1724                .fBloomFilter = node->m_bloom_filter_loaded.load(),
1725                .nKeyedNetGroup = node->nKeyedNetGroup,
1726                .prefer_evict = node->m_prefer_evict,
1727                .m_is_local = node->addr.IsLocal(),
1728                .m_network = node->ConnectedThroughNetwork(),
1729                .m_noban = node->HasPermission(NetPermissionFlags::NoBan),
1730                .m_conn_type = node->m_conn_type,
1731            };
1732            vEvictionCandidates.push_back(candidate);
1733        }
1734    }
1735    const std::optional<NodeId> node_id_to_evict = SelectNodeToEvict(std::move(vEvictionCandidates));
1736    if (!node_id_to_evict) {
1737        return false;
1738    }
1739    LOCK(m_nodes_mutex);
1740    for (CNode* pnode : m_nodes) {
1741        if (pnode->GetId() == *node_id_to_evict) {
1742            LogDebug(BCLog::NET, "selected %s connection for eviction, %s", pnode->ConnectionTypeAsString(), pnode->DisconnectMsg());
1743            TRACEPOINT(net, evicted_inbound_connection,
1744                pnode->GetId(),
1745                pnode->m_addr_name.c_str(),
1746                pnode->ConnectionTypeAsString().c_str(),
1747                pnode->ConnectedThroughNetwork(),
1748                TicksSinceEpoch<std::chrono::seconds>(pnode->m_connected));
1749            pnode->fDisconnect = true;
1750            return true;