Connections and transport

1751        }
1752    }
1753    return false;
1754}
1755
1756void CConnman::AcceptConnection(const ListenSocket& hListenSocket) {
1757    AssertLockNotHeld(m_nodes_mutex);
1758
1759    struct sockaddr_storage sockaddr;
1760    socklen_t len = sizeof(sockaddr);
1761    auto sock = hListenSocket.sock->Accept((struct sockaddr*)&sockaddr, &len);
1762
1763    if (!sock) {
1764        const int nErr = WSAGetLastError();
1765        if (nErr != WSAEWOULDBLOCK) {
1766            LogInfo("socket error accept failed: %s\n", NetworkErrorString(nErr));
1767        }
1768        return;
1769    }
1770
1771    CService addr;
1772    if (!addr.SetSockAddr((const struct sockaddr*)&sockaddr, len)) {
1773        LogWarning("Unknown socket family\n");
1774    } else {
1775        addr = MaybeFlipIPv6toCJDNS(addr);
1776    }
1777
1778    const CService addr_bind{MaybeFlipIPv6toCJDNS(GetBindAddress(*sock))};
1779
1780    NetPermissionFlags permission_flags = NetPermissionFlags::None;
1781    hListenSocket.AddSocketPermissionFlags(permission_flags);
1782
1783    CreateNodeFromAcceptedSocket(std::move(sock), permission_flags, addr_bind, addr);
1784}
1785
1786void CConnman::CreateNodeFromAcceptedSocket(std::unique_ptr<Sock>&& sock,
1787                                            NetPermissionFlags permission_flags,
1788                                            const CService& addr_bind,
1789                                            const CService& addr)
1790{
1791    AssertLockNotHeld(m_nodes_mutex);
1792
1793    int nInbound = 0;
1794
1795    const bool inbound_onion = std::find(m_onion_binds.begin(), m_onion_binds.end(), addr_bind) != m_onion_binds.end();
1796
1797    // Tor inbound connections do not reveal the peer's actual network address.
1798    // Therefore do not apply address-based whitelist permissions to them.
1799    AddWhitelistPermissionFlags(permission_flags, inbound_onion ? std::optional<CNetAddr>{} : addr, vWhitelistedRangeIncoming);
1800
1801    {
1802        LOCK(m_nodes_mutex);
1803        for (const CNode* pnode : m_nodes) {
1804            if (pnode->IsInboundConn()) nInbound++;
1805        }
1806    }
1807
1808    if (!fNetworkActive) {
1809        LogDebug(BCLog::NET, "connection from %s dropped: not accepting new connections\n", addr.ToStringAddrPort());
1810        return;
1811    }
1812
1813    if (!sock->IsSelectable()) {
1814        LogInfo("connection from %s dropped: non-selectable socket\n", addr.ToStringAddrPort());
1815        return;
1816    }
1817
1818    // According to the internet TCP_NODELAY is not carried into accepted sockets
1819    // on all platforms.  Set it again here just to be sure.
1820    const int on{1};
1821    if (sock->SetSockOpt(IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on)) == SOCKET_ERROR) {
1822        LogDebug(BCLog::NET, "connection from %s: unable to set TCP_NODELAY, continuing anyway\n",
1823                 addr.ToStringAddrPort());
1824    }
1825
1826    // Don't accept connections from banned peers.
1827    bool banned = m_banman && m_banman->IsBanned(addr);
1828    if (!NetPermissions::HasFlag(permission_flags, NetPermissionFlags::NoBan) && banned)
1829    {
1830        LogDebug(BCLog::NET, "connection from %s dropped (banned)\n", addr.ToStringAddrPort());
1831        return;
1832    }
1833
1834    // Only accept connections from discouraged peers if our inbound slots aren't (almost) full.
1835    bool discouraged = m_banman && m_banman->IsDiscouraged(addr);
1836    if (!NetPermissions::HasFlag(permission_flags, NetPermissionFlags::NoBan) && nInbound + 1 >= m_max_inbound && discouraged)
1837    {
1838        LogDebug(BCLog::NET, "connection from %s dropped (discouraged)\n", addr.ToStringAddrPort());
1839        return;
1840    }
1841
1842    if (nInbound >= m_max_inbound)
1843    {
1844        if (!AttemptToEvictConnection(/*evict_tx_relay_peer_only=*/false)) {
1845            // No connection to evict, disconnect the new connection
1846            LogDebug(BCLog::NET, "failed to find an eviction candidate - connection dropped (full)\n");
1847            return;
1848        }
1849    }
1850
1851    NodeId id = GetNewNodeId();
1852    uint64_t nonce = GetDeterministicRandomizer(RANDOMIZER_ID_LOCALHOSTNONCE).Write(id).Finalize();
1853
1854    // The V2Transport transparently falls back to V1 behavior when an incoming V1 connection is
1855    // detected, so use it whenever we signal NODE_P2P_V2.
1856    ServiceFlags local_services = GetLocalServices();
1857    const bool use_v2transport(local_services & NODE_P2P_V2);
1858
1859    uint64_t network_id = GetDeterministicRandomizer(RANDOMIZER_ID_NETWORKKEY)
1860                        .Write(inbound_onion ? NET_ONION : addr.GetNetClass())
1861                        .Write(addr_bind.GetAddrBytes())
1862                        .Write(addr_bind.GetPort()) // inbound connections use bind port
1863                        .Finalize();
1864    CNode* pnode = new CNode(id,
1865                             std::move(sock),
1866                             CAddress{addr, NODE_NONE},
1867                             CalculateKeyedNetGroup(addr),
1868                             nonce,
1869                             addr_bind,
1870                             /*addrNameIn=*/"",
1871                             ConnectionType::INBOUND,
1872                             inbound_onion,
1873                             network_id,
1874                             CNodeOptions{
1875                                 .permission_flags = permission_flags,
1876                                 .prefer_evict = discouraged,
1877                                 .recv_flood_size = nReceiveFloodSize,
1878                                 .use_v2transport = use_v2transport,
1879                             });
1880    pnode->AddRef();
1881    m_msgproc->InitializeNode(*pnode, local_services);
1882    {
1883        LOCK(m_nodes_mutex);
1884        m_nodes.push_back(pnode);
1885    }
1886    LogDebug(BCLog::NET, "connection from %s accepted\n", addr.ToStringAddrPort());
1887    TRACEPOINT(net, inbound_connection,
1888        pnode->GetId(),
1889        pnode->m_addr_name.c_str(),
1890        pnode->ConnectionTypeAsString().c_str(),
1891        pnode->ConnectedThroughNetwork(),
1892        GetNodeCount(ConnectionDirection::In));
1893
1894    // We received a new connection, harvest entropy from the time (and our peer count)
1895    RandAddEvent((uint32_t)id);
1896}
1897
1898bool CConnman::AddConnection(const std::string& address, ConnectionType conn_type, bool use_v2transport = false)
1899{
1900    AssertLockNotHeld(m_nodes_mutex);
1901    AssertLockNotHeld(m_unused_i2p_sessions_mutex);
1902    std::optional<int> max_connections;
1903    switch (conn_type) {
1904    case ConnectionType::INBOUND:
1905    case ConnectionType::MANUAL:
1906    case ConnectionType::PRIVATE_BROADCAST:
1907        return false;
1908    case ConnectionType::OUTBOUND_FULL_RELAY:
1909        max_connections = m_max_outbound_full_relay;
1910        break;
1911    case ConnectionType::BLOCK_RELAY:
1912        max_connections = m_max_outbound_block_relay;
1913        break;
1914    // no limit for ADDR_FETCH because -seednode has no limit either
1915    case ConnectionType::ADDR_FETCH:
1916        break;
1917    // no limit for FEELER connections since they're short-lived
1918    case ConnectionType::FEELER:
1919        break;
1920    } // no default case, so the compiler can warn about missing cases
1921
1922    // Count existing connections
1923    int existing_connections = WITH_LOCK(m_nodes_mutex,
1924                                         return std::count_if(m_nodes.begin(), m_nodes.end(), [conn_type](CNode* node) { return node->m_conn_type == conn_type; }););
1925
1926    // Max connections of specified type already exist
1927    if (max_connections != std::nullopt && existing_connections >= max_connections) return false;
1928
1929    // Max total outbound connections already exist
1930    CountingSemaphoreGrant<> grant(*semOutbound, true);
1931    if (!grant) return false;
1932
1933    OpenNetworkConnection(/*addrConnect=*/CAddress{},
1934                          /*fCountFailure=*/false,
1935                          /*grant_outbound=*/std::move(grant),
1936                          /*pszDest=*/address.c_str(),
1937                          /*conn_type=*/conn_type,
1938                          /*use_v2transport=*/use_v2transport,
1939                          /*proxy_override=*/std::nullopt);
1940    return true;
1941}
1942
1943void CConnman::DisconnectNodes()
1944{
1945    AssertLockNotHeld(m_nodes_mutex);
1946    AssertLockNotHeld(m_reconnections_mutex);
1947
1948    // Use a temporary variable to accumulate desired reconnections, so we don't need
1949    // m_reconnections_mutex while holding m_nodes_mutex.
1950    decltype(m_reconnections) reconnections_to_add;
1951
1952    {
1953        LOCK(m_nodes_mutex);
1954
1955        const bool network_active{fNetworkActive};
1956        if (!network_active) {
1957            // Disconnect any connected nodes
1958            for (CNode* pnode : m_nodes) {
1959                if (!pnode->fDisconnect) {
1960                    LogDebug(BCLog::NET, "Network not active, %s", pnode->DisconnectMsg());
1961                    pnode->fDisconnect = true;
1962                }
1963            }
1964        }
1965
1966        // Disconnect unused nodes
1967        std::vector<CNode*> nodes_copy = m_nodes;
1968        for (CNode* pnode : nodes_copy)
1969        {
1970            if (pnode->fDisconnect)
1971            {
1972                // remove from m_nodes
1973                m_nodes.erase(remove(m_nodes.begin(), m_nodes.end(), pnode), m_nodes.end());
1974
1975                // Add to reconnection list if appropriate. We don't reconnect right here, because
1976                // the creation of a connection is a blocking operation (up to several seconds),
1977                // and we don't want to hold up the socket handler thread for that long.
1978                if (network_active && pnode->m_transport->ShouldReconnectV1()) {
1979                    reconnections_to_add.push_back({
1980                        .proxy_override = pnode->m_proxy_override,
1981                        .addr_connect = pnode->addr,
1982                        .grant = std::move(pnode->grantOutbound),
1983                        .destination = pnode->m_dest,
1984                        .conn_type = pnode->m_conn_type,
1985                        .use_v2transport = false});
1986                    LogDebug(BCLog::NET, "retrying with v1 transport protocol for peer=%d\n", pnode->GetId());
1987                }
1988
1989                // release outbound grant (if any)
1990                pnode->grantOutbound.Release();
1991
1992                // close socket and cleanup
1993                pnode->CloseSocketDisconnect();
1994
1995                // update connection count by network
1996                if (pnode->IsManualOrFullOutboundConn()) --m_network_conn_counts[pnode->addr.GetNetwork()];
1997
1998                // hold in disconnected pool until all refs are released
1999                pnode->Release();
2000                m_nodes_disconnected.push_back(pnode);