BIP324 integration #28331

290@@ -291,6 +291,9 @@ enum ServiceFlags : uint64_t {
291     // See BIP159 for details on how this is implemented.
292     NODE_NETWORK_LIMITED = (1 << 10),
293 
294+    // NODE_P2P_V2 means the node supports BIP324 transport
295+    NODE_P2P_V2 = (1 << 11),

31+        assert_equal(self.nodes[1].getblockcount(), 0)
32+        with self.nodes[0].assert_debug_log(expected_msgs=[sending_handshake],
33+                                            unexpected_msgs=[downgrading_to_v1]):
34+            self.connect_nodes(0, 1, True)
35+        # sync_all() verifies that the block tips match
36+        self.sync_all(self.nodes[0:2])

319@@ -309,17 +320,21 @@ static RPCHelpMan addnode()
320     CConnman& connman = EnsureConnman(node);
321 
322     std::string strNode = request.params[0].get_str();
323+    bool use_p2p_v2 = !request.params[2].isNull() && request.params[2].get_bool();

464@@ -465,7 +465,11 @@ CNode* CConnman::ConnectNode(CAddress addrConnect, const char *pszDest, bool fCo
465         }
466     }
467 
468-    LogPrintLevel(BCLog::NET, BCLog::Level::Debug, "trying connection %s lastseen=%.1fhrs\n",
469+    // Use v2 transport when both us and them signal NODE_P2P_V2.
470+    const bool use_p2p_v2 = !!(addrConnect.nServices & GetLocalServices() & NODE_P2P_V2);

1893@@ -1822,6 +1894,10 @@ void CConnman::CreateNodeFromAcceptedSocket(std::unique_ptr<Sock>&& sock,
1894     }
1895 
1896     const bool inbound_onion = std::find(m_onion_binds.begin(), m_onion_binds.end(), addr_bind) != m_onion_binds.end();
1897+    // The V2Transport transparently falls back to V1 behavior when an incoming V1 connection is
1898+    // detected, so use it whenever we signal NODE_P2P_V2.
1899+    const bool use_p2p_v2 = !!(nodeServices & NODE_P2P_V2);

637+
638+            initiator = list(filter(lambda x: x["addrbind"] == ip_port, peerinfo))[0]
639+            return initiator['version'] != 0 and initiator['bytesrecv_per_msg'].pop('verack', 0) >= min_verack_msg_bytes and initiator['bytesrecv_per_msg'].pop("pong", 0) >= 29
640+
641+        self.wait_until(check_initiator_handshake)
642+        self.wait_until(check_responder_handshake)

18+
19+    def run_test(self):
20+        network_info = self.nodes[0].getnetworkinfo()
21+        assert_equal(int(network_info["localservices"], 16) & NODE_P2P_V2, 0)
22+        if "P2P_V2" in network_info["localservicesnames"]:
23+            raise AssertionError("Did not expect P2P_V2 to be signaled for a v1 node")

73+        self.nodes[1].generatetoaddress(1, "bcrt1q3zsxn3qx0cqyyxgv90k7j6786mpe543wc4vy2v", invalid_call=False)
74+        self.sync_all(self.nodes[0:4])
75+        assert_equal(self.nodes[0].getblockcount(), 9) # sync_all() verifies tip hashes match
76+
77+        # V1 node mines another block and everyone gets it
78+        self.nodes[3].generatetoaddress(2, "bcrt1q3zsxn3qx0cqyyxgv90k7j6786mpe543wc4vy2v", invalid_call=False)

585@@ -581,26 +586,50 @@ def restart_node(self, i, extra_args=None):
586     def wait_for_node_exit(self, i, timeout):
587         self.nodes[i].process.wait(timeout)
588 
589-    def connect_nodes(self, a, b):
590+    def connect_nodes(self, a, b, peer_advertises_v2=None):

1080@@ -1077,7 +1081,11 @@ class CConnman
1081         vWhitelistedRange = connOptions.vWhitelistedRange;
1082         {
1083             LOCK(m_added_nodes_mutex);
1084-            m_added_nodes = connOptions.m_added_nodes;
1085+
1086+            for (const std::string& strAddedNode : connOptions.m_added_nodes) {
1087+                // -addnode cli arg does not currently have a way to signal BIP324 support

308@@ -309,25 +309,33 @@ class CSemaphore
309     int value;
310 
311 public:
312-    explicit CSemaphore(int init) : value(init) {}
313+    explicit CSemaphore(int init) noexcept : value(init) {}

188@@ -189,6 +189,8 @@ def parse_args(self):
189         parser.add_argument("--randomseed", type=int,
190                             help="set a random seed for deterministically reproducing a previous test run")
191         parser.add_argument("--timeout-factor", dest="timeout_factor", type=float, help="adjust test timeouts by a factor. Setting it to 0 disables all timeouts")
192+        parser.add_argument("--v2transport", dest="v2transport", default=False, action="store_true",

3513+    for (const auto& it : m_added_nodes) {
3514+        if (added_node_params.m_added_node == it.m_added_node) return false;
3515     }
3516 
3517-    m_added_nodes.push_back(strNode);
3518+    m_added_nodes.push_back(added_node_params);

2882@@ -2834,6 +2883,8 @@ void CConnman::ThreadOpenAddedConnections()
2883         // Retry every 60 seconds if a connection was attempted, otherwise two seconds
2884         if (!interruptNet.sleep_for(std::chrono::seconds(tried ? 60 : 2)))
2885             return;
2886+        // See if any reconnections are desired.
2887+        PerformReconnections();

119+        self.nodes[1].generate(1, invalid_call=False)
120+        self.sync_all(self.nodes[0:4])
121+        assert_equal(self.nodes[0].getblockcount(), 9) # sync_all() verifies tip hashes match
122+
123+        # V1 node mines another block and everyone gets it
124+        self.nodes[3].generate(2, invalid_call=False)

0@@ -0,0 +1,136 @@
1+#!/usr/bin/env python3
2+# Copyright (c) 2021 The Bitcoin Core developers

309@@ -309,17 +310,21 @@ static RPCHelpMan addnode()
310     CConnman& connman = EnsureConnman(node);
311 
312     std::string strNode = request.params[0].get_str();
313+    bool use_v2transport = self.Arg<bool>(2);
314 
315     if (strCommand == "onetry")
316     {
317         CAddress addr;
318+        if (use_v2transport) {

3844+            if (m_reconnections.empty()) break;
3845+            todo.splice(todo.end(), m_reconnections, m_reconnections.begin());
3846+        }
3847+
3848+        auto& [addr_connect, count_failure, grant, dest, conn_type] = *todo.begin();
3849+        OpenNetworkConnection(addr_connect, count_failure, &grant, dest.empty() ? nullptr : dest.c_str(), conn_type);

3616@@ -3606,6 +3617,15 @@ ServiceFlags CConnman::GetLocalServices() const
3617     return nLocalServices;
3618 }
3619 
3620+static std::unique_ptr<Transport> MakeTransport(NodeId id, bool use_v2transport, bool inbound) noexcept
3621+{
3622+    if (use_v2transport) {
3623+        return std::make_unique<V2Transport>(id, !inbound, SER_NETWORK, INIT_PROTO_VERSION);

78@@ -79,4 +79,14 @@ enum class ConnectionType {
79 /** Convert ConnectionType enum to a string value */
80 std::string ConnectionTypeAsString(ConnectionType conn_type);
81 
82+/** Transport layer version */
83+enum class TransportProtocolType {
84+    DETECTING, //!< Incoming connection; peer could be v1 or v2

280+        std::optional<uint256> session_id;
281+
282+        friend bool operator==(const Info& a, const Info& b) noexcept
283+        {
284+            return std::tie(a.transport_type, a.session_id) == std::tie(b.transport_type, b.session_id);
285+        }

589         to_num_peers = 1 + len(to_connection.getpeerinfo())
590         ip_port = "127.0.0.1:" + str(p2p_port(b))
591-        from_connection.addnode(ip_port, "onetry")
592+
593+        if peer_advertises_v2:
594+            from_connection.addnode(ip_port, "onetry", True)

1570+        CAddress /*addr_connect*/,
1571+        bool /*count_failure*/,
1572+        CSemaphoreGrant /*grant*/,
1573+        std::string /*dest*/,
1574+        ConnectionType /*conn_type*/
1575+    >> m_reconnections GUARDED_BY(m_reconnections_mutex);

2504@@ -2459,6 +2505,8 @@ void CConnman::ThreadOpenConnections(const std::vector<std::string> connect)
2505         if (!interruptNet.sleep_for(std::chrono::milliseconds(500)))
2506             return;
2507 
2508+        PerformReconnections();

1951+                    reconnections_to_add.emplace_back(
1952+                        /*addr_connect=*/CAddress{pnode->addr, ServiceFlags{pnode->addr.nServices & ~NODE_P2P_V2}},
1953+                        /*count_failure=*/pnode->m_count_failure_after_reconnect,
1954+                        /*grant=*/std::move(pnode->grantOutbound),
1955+                        /*dest=*/pnode->m_dest,
1956+                        /*conn_type=*/pnode->m_conn_type);

51@@ -52,6 +52,7 @@
52 NODE_WITNESS = (1 << 3)
53 NODE_COMPACT_FILTERS = (1 << 6)
54 NODE_NETWORK_LIMITED = (1 << 10)
55+NODE_P2P_V2 = (1 << 11)

3612@@ -3602,6 +3613,15 @@ ServiceFlags CConnman::GetLocalServices() const
3613     return nLocalServices;
3614 }
3615 
3616+static std::unique_ptr<Transport> MakeTransport(NodeId id, bool use_v2transport, bool inbound) noexcept
3617+{
3618+    if (use_v2transport) {
3619+        return std::make_unique<V2Transport>(id, /*initiating=*/!inbound, SER_NETWORK, INIT_PROTO_VERSION);
3620+    } else {
3621+        return std::make_unique<V1Transport>(id, SER_NETWORK, INIT_PROTO_VERSION);

1598+    // we reconnect.
1599+    if (m_recv_state != RecvState::KEY) return false;
1600+    // Only when nothing has been received do we reconnect.
1601+    if (!m_recv_buffer.empty()) return false;
1602+    // Check if we've sent enough for the other side to disconnect us (if it was V1).
1603+    LOCK(m_send_mutex);

1943@@ -1917,6 +1944,19 @@ void CConnman::DisconnectNodes()
1944                 // remove from m_nodes
1945                 m_nodes.erase(remove(m_nodes.begin(), m_nodes.end(), pnode), m_nodes.end());
1946 
1947+                // Add to reconnection list if appropriate. We don't reconnect right here, because
1948+                // the creation of a connection is a blocking operation (up to several seconds),
1949+                // and we don't want to hold up the socket handler thread for that long.
1950+                if (pnode->m_transport->ShouldReconnectV1()) {
1951+                    reconnections_to_add.emplace_back(
1952+                        /*addr_connect=*/CAddress{pnode->addr, ServiceFlags{pnode->addr.nServices & ~NODE_P2P_V2}},

288@@ -289,11 +289,12 @@ static RPCHelpMan addnode()
289                 {
290                     {"node", RPCArg::Type::STR, RPCArg::Optional::NO, "The address of the peer to connect to"},
291                     {"command", RPCArg::Type::STR, RPCArg::Optional::NO, "'add' to add a node to the list, 'remove' to remove a node from the list, 'onetry' to try a connection to the node once"},
292+                    {"v2transport", RPCArg::Type::BOOL, RPCArg::Default{false}, "Peer supports BIP324 v2 transport protocol"},

1399@@ -1392,7 +1400,10 @@ class CConnman
1400     const NetGroupManager& m_netgroupman;
1401     std::deque<std::string> m_addr_fetches GUARDED_BY(m_addr_fetches_mutex);
1402     Mutex m_addr_fetches_mutex;
1403-    std::vector<std::string> m_added_nodes GUARDED_BY(m_added_nodes_mutex);
1404+
1405+    // connection string and whether to use v2 p2p
1406+    std::vector<AddedNodeParams> m_added_nodes GUARDED_BY(m_added_nodes_mutex);

1608+    LOCK(m_recv_mutex);
1609+    // Only in the very first state (where m_recv_buffer.empty() means nothing received) do
1610+    // we reconnect.
1611+    if (m_recv_state != RecvState::KEY) return false;
1612+    // Only when nothing has been received do we reconnect.
1613+    if (!m_recv_buffer.empty()) return false;

1596         m_send_pos = 0;
1597         ClearShrink(m_send_buffer);
1598     }
1599 }
1600 
1601+bool V2Transport::ShouldReconnectV1() const noexcept

398+    CSemaphoreGrant(CSemaphoreGrant&& other) noexcept
399+    {
400+        sem = other.sem;
401+        fHaveGrant = other.fHaveGrant;
402+        other.fHaveGrant = false;
403+    }

1987+                        // Removing NODE_P2P_V2 here ensures we reconnect using V1.
1988+                        .addr_connect = CAddress{pnode->addr, ServiceFlags{pnode->addr.nServices & ~NODE_P2P_V2}},
1989+                        .count_failure = pnode->m_count_failure_after_reconnect,
1990+                        .grant = std::move(pnode->grantOutbound),
1991+                        .destination = pnode->m_dest,
1992+                        .conn_type = pnode->m_conn_type});

738@@ -704,8 +739,12 @@ class CNode
739     // Bind address of our side of the connection
740     const CAddress addrBind;
741     const std::string m_addr_name;
742+    /** The pszDest argument provided ConnectNode(). Only used for reconnections. */

1978@@ -1906,6 +1979,20 @@ void CConnman::DisconnectNodes()
1979                 // remove from m_nodes
1980                 m_nodes.erase(remove(m_nodes.begin(), m_nodes.end(), pnode), m_nodes.end());
1981 
1982+                // Add to reconnection list if appropriate. We don't reconnect right here, because
1983+                // the creation of a connection is a blocking operation (up to several seconds),
1984+                // and we don't want to hold up the socket handler thread for that long.
1985+                if (pnode->m_transport->ShouldReconnectV1()) {

78@@ -79,4 +79,14 @@ enum class ConnectionType {
79 /** Convert ConnectionType enum to a string value */
80 std::string ConnectionTypeAsString(ConnectionType conn_type);
81 
82+/** Transport layer version */
83+enum class TransportProtocolType {
84+    DETECTING, //!< Peer could be v1 or v2
85+    V1, //!< Unencrypted, plaintext protocol
86+    V2, //!< BIP324 protocol
87+};

 8+
 9+from test_framework.messages import NODE_P2P_V2
10+from test_framework.test_framework import BitcoinTestFramework
11+from test_framework.util import assert_equal
12+
13+class V2TransportTest(BitcoinTestFramework):

471@@ -472,7 +472,7 @@ CNode* CConnman::ConnectNode(CAddress addrConnect, const char *pszDest, bool fCo
472         const std::vector<CService> resolved{Lookup(pszDest, default_port, fNameLookup && !HaveNameProxy(), 256)};
473         if (!resolved.empty()) {
474             const CService& rnd{resolved[GetRand(resolved.size())]};
475-            addrConnect = CAddress{MaybeFlipIPv6toCJDNS(rnd), NODE_NONE};
476+            addrConnect = CAddress{MaybeFlipIPv6toCJDNS(rnd), addrConnect.nServices};

1600+    Transport::Info info;
1601+
1602+    // Do not report v2 and session ID until the garbage authentication packet has been received
1603+    // and verified (confirming that the other side very likely has the same keys as us).
1604+    if (m_recv_state != RecvState::KEY_MAYBE_V1 && m_recv_state != RecvState::KEY &&
1605+        m_recv_state != RecvState::GARB_GARBTERM) {

2779@@ -2780,19 +2780,19 @@ void CConnman::ThreadOpenAddedConnections()
2780     AssertLockNotHeld(m_unused_i2p_sessions_mutex);
2781     while (true)
2782     {
2783-        CSemaphoreGrant grant(*semAddnode);

303                 },
304                 RPCResult{RPCResult::Type::NONE, "", ""},
305                 RPCExamples{
306-                    HelpExampleCli("addnode", "\"192.168.0.6:8333\" \"onetry\"")
307-            + HelpExampleRpc("addnode", "\"192.168.0.6:8333\", \"onetry\"")
308+                    HelpExampleCli("addnode", "\"192.168.0.6:8333\" \"onetry\" true")

1888@@ -1868,6 +1889,11 @@ bool CConnman::AddConnection(const std::string& address, ConnectionType conn_typ
1889 
1890 void CConnman::DisconnectNodes()
1891 {
1892+    AssertLockNotHeld(m_nodes_mutex);
1893+    AssertLockNotHeld(m_reconnections_mutex);
1894+
1895+    decltype(m_reconnections) reconnections_to_add;

3813+        OpenNetworkConnection(item.addr_connect,
3814+                              item.count_failure,
3815+                              std::move(item.grant),
3816+                              item.destination.empty() ? nullptr : item.destination.c_str(),
3817+                              item.conn_type,
3818+                              /*use_v2transport=*/false);

360@@ -361,6 +361,11 @@ class Transport {
361 
362     /** Return the memory usage of this transport attributable to buffered data to send. */
363     virtual size_t GetSendMemoryUsage() const noexcept = 0;
364+
365+    // 3. Miscellaneous functions.
366+
367+    /** Whether upon disconnections, a reconnect with V1 is warranted. */
368+    virtual bool ShouldReconnectV1() const noexcept = 0;

1920+                // the creation of a connection is a blocking operation (up to several seconds),
1921+                // and we don't want to hold up the socket handler thread for that long.
1922+                if (pnode->m_transport->ShouldReconnectV1()) {
1923+                    reconnections_to_add.push_back({
1924+                        .addr_connect = pnode->addr,
1925+                        .count_failure = pnode->m_count_failure_after_reconnect,