Update block-out to allow overlapped block requests.

Author: evoskuil

include/bitcoin/node/protocols/protocol_block_out_106.hpp

@@ -19,6 +19,7 @@
 #ifndef LIBBITCOIN_NODE_PROTOCOLS_PROTOCOL_BLOCK_OUT_106_HPP
 #define LIBBITCOIN_NODE_PROTOCOLS_PROTOCOL_BLOCK_OUT_106_HPP
 
+#include <deque>
 #include <bitcoin/node/define.hpp>
 #include <bitcoin/node/protocols/protocol_peer.hpp>
 
@@ -36,6 +37,7 @@ class BCN_API protocol_block_out_106
         const network::channel::ptr& channel) NOEXCEPT
       : node::protocol_peer(session, channel),
         node_witness_(session->network_settings().witness_node()),
+        allow_overlapped_(session->node_settings().allow_overlapped),
         network::tracker<protocol_block_out_106>(session->log)
     {
     }
@@ -49,9 +51,6 @@ class BCN_API protocol_block_out_106
 protected:
     using get_data = network::messages::peer::get_data;
     using get_blocks = network::messages::peer::get_blocks;
-    using inventory = network::messages::peer::inventory;
-    using inventory_items = network::messages::peer::inventory_items;
-    using inventory_items_ptr = std::shared_ptr<inventory_items>;
 
     /// Block announcements are superseded by send_headers.
     virtual bool superseded() const NOEXCEPT;
@@ -67,18 +66,22 @@ class BCN_API protocol_block_out_106
         const get_blocks::cptr& message) NOEXCEPT;
     virtual bool handle_receive_get_data(const code& ec,
         const get_data::cptr& message) NOEXCEPT;
-    virtual void send_block(const code& ec,
-        const inventory_items_ptr& items) NOEXCEPT;
+    virtual void send_block(const code& ec) NOEXCEPT;
 
 private:
+    using inventory = network::messages::peer::inventory;
+    using inventory_item = network::messages::peer::inventory_item;
+    using inventory_items = network::messages::peer::inventory_items;
+
     inventory create_inventory(const get_blocks& locator) const NOEXCEPT;
+    void merge_inventory(const inventory_items& items) NOEXCEPT;
 
-private:
-    // This is thread safe.
+    // These are thread safe.
     const bool node_witness_;
+    const bool allow_overlapped_;
 
     // This is protected by strand.
-    bool busy_{};
+    std::deque<inventory_item> backlog_{};
 };
 
 } // namespace node

src/protocols/protocol_block_out_106.cpp

@@ -153,35 +153,53 @@ bool protocol_block_out_106::handle_receive_get_data(const code& ec,
         return false;
     }
 
-    constexpr auto only = get_data::selector::blocks;
-    const auto blocks = emplace_shared<inventory_items>(message->select(only));
-    if (blocks->empty())
+    const auto size = message->count(get_data::selector::blocks);
+    if (is_zero(size))
         return true;
 
-    if (busy_)
+    const auto total = ceilinged_add(backlog_.size(), size);
+    if (total > messages::peer::max_inventory)
+    {
+        LOGR("Blocks requested (" << total << ") exceeds inv limit ["
+            << opposite() << "].");
+        stop(network::error::protocol_violation);
+        return false;
+    }
+
+    // Satoshi sends overlapping get_data requests, but assumes that the
+    // recipient is blocking *all traffic* until the previous is completed.
+    // So to prevent frequent drops of satoshi peers, and not let one protocol
+    // block all others, we must accumulate the requests into a backlog. If the
+    // backlog exceeds the *individual* message limit we drop the peer.
+    const auto idle = backlog_.empty();
+    if (!allow_overlapped_ && !idle)
     {
         LOGR("Overlapping block requests [" << opposite() << "].");
         stop(network::error::protocol_violation);
         return false;
     }
 
-    busy_ = true;
-    send_block(error::success, blocks);
+    // Append the new inventory the request queue.
+    merge_inventory(message->items);
+
+    // Bump the idle async send loop if no pending send.
+    if (idle)
+        send_block(error::success);
+
     return true;
 }
 
 // Outbound (block).
 // ----------------------------------------------------------------------------
 
-void protocol_block_out_106::send_block(const code& ec,
-    const inventory_items_ptr& items) NOEXCEPT
+void protocol_block_out_106::send_block(const code& ec) NOEXCEPT
 {
     BC_ASSERT(stranded());
     if (stopped(ec))
         return;
 
-    if (items->empty()) return;
-    const auto item = pop(*items);
+    if (backlog_.empty()) return;
+    const auto& item = backlog_.front();
     const auto witness = item.is_witness_type();
     if (!node_witness_ && witness)
     {
@@ -203,14 +221,22 @@ void protocol_block_out_106::send_block(const code& ec,
         return;
     }
 
+    backlog_.pop_front();
     span<microseconds>(events::block_usecs, start);
-    if (items->empty()) busy_ = false;
-    SEND(messages::peer::block{ ptr }, send_block, _1, items);
+    SEND(messages::peer::block{ ptr }, send_block, _1);
 }
 
 // utilities
 // ----------------------------------------------------------------------------
 
+void protocol_block_out_106::merge_inventory(
+    const inventory_items& items) NOEXCEPT
+{
+    for (const auto& item: items)
+        if (item.is_block())
+            backlog_.push_back(item);
+}
+
 protocol_block_out_106::inventory protocol_block_out_106::create_inventory(
     const get_blocks& locator) const NOEXCEPT
 {