Merge pull request #193 from thecodefactory/seed-address-response

Implement get_address message response

Author: evoskuil

include/bitcoin/network/hosts.hpp

@@ -55,6 +55,7 @@ class BCT_API hosts
 
     virtual size_t count() const;
     virtual code fetch(address& out) const;
+    virtual code fetch(address::list& out) const;
     virtual code remove(const address& host);
     virtual code store(const address& host);
     virtual void store(const address::list& hosts, result_handler handler);
@@ -65,6 +66,8 @@ class BCT_API hosts
 
     iterator find(const address& host);
 
+    const size_t capacity_;
+
     // These are protected by a mutex.
     list buffer_;
     std::atomic<bool> stopped_;

include/bitcoin/network/p2p.hpp

@@ -168,6 +168,9 @@ class BCT_API p2p
     /// Get a randomly-selected address.
     virtual code fetch_address(address& out_address) const;
 
+    /// Get a list of stored hosts
+    virtual code fetch_addresses(address::list& out_addresses) const;
+
     /// Remove an address.
     virtual code remove(const address& address);
 

src/channel.cpp

@@ -37,7 +37,7 @@ using namespace std::placeholders;
 // Factory for deadline timer pointer construction.
 static deadline::ptr alarm(threadpool& pool, const asio::duration& duration)
 {
-    return std::make_shared<deadline>(pool, pseudo_randomize(duration));
+    return std::make_shared<deadline>(pool, pseudo_random::duration(duration));
 }
 
 channel::channel(threadpool& pool, socket::ptr socket,

src/hosts.cpp

@@ -34,10 +34,12 @@ using namespace bc::config;
 
 // TODO: change to network_address bimap hash table with services and age.
 hosts::hosts(const settings& settings)
-  : buffer_(std::max(settings.host_pool_capacity, 1u)),
+  : capacity_(std::min(max_address, static_cast<size_t>(
+        settings.host_pool_capacity))),
+    buffer_(std::max(capacity_, static_cast<size_t>(1u))),
     stopped_(true),
     file_path_(settings.hosts_file),
-    disabled_(settings.host_pool_capacity == 0)
+    disabled_(capacity_ == 0)
 {
 }
 
@@ -78,13 +80,45 @@ code hosts::fetch(address& out) const
         return error::not_found;
 
     // Randomly select an address from the buffer.
-    const auto random = pseudo_random(0, buffer_.size() - 1);
+    const auto random = pseudo_random::next(0, buffer_.size() - 1);
     const auto index = static_cast<size_t>(random);
     out = buffer_[index];
     return error::success;
     ///////////////////////////////////////////////////////////////////////////
 }
 
+code hosts::fetch(address::list& out) const
+{
+    if (disabled_)
+        return error::not_found;
+
+    // Critical Section
+    ///////////////////////////////////////////////////////////////////////////
+    {
+        shared_lock lock(mutex_);
+
+        if (stopped_)
+            return error::service_stopped;
+
+        if (buffer_.empty())
+            return error::not_found;
+
+        const auto out_count = std::min(buffer_.size(), capacity_) /
+            static_cast<size_t>(pseudo_random::next(1, 20));
+
+        if (out_count == 0)
+            return error::success;
+
+        out.reserve(out_count);
+        for (size_t index = 0; index < out_count; ++index)
+            out.push_back(buffer_[index]);
+    }
+    ///////////////////////////////////////////////////////////////////////////
+
+    pseudo_random::shuffle(out);
+    return error::success;
+}
+
 // load
 code hosts::start()
 {
@@ -288,7 +322,7 @@ void hosts::store(const address::list& hosts, result_handler handler)
     // Accept between 1 and all of this peer's addresses up to capacity.
     const auto capacity = buffer_.capacity();
     const auto usable = std::min(hosts.size(), capacity);
-    const auto random = static_cast<size_t>(pseudo_random(1, usable));
+    const auto random = static_cast<size_t>(pseudo_random::next(1, usable));
 
     // But always accept at least the amount we are short if available.
     const auto gap = capacity - buffer_.size();

src/p2p.cpp

@@ -420,6 +420,11 @@ code p2p::fetch_address(address& out_address) const
     return hosts_.fetch(out_address);
 }
 
+code p2p::fetch_addresses(address::list& out_addresses) const
+{
+    return hosts_.fetch(out_addresses);
+}
+
 code p2p::remove(const address& address)
 {
     return hosts_.remove(address);

src/protocols/protocol_address_31402.cpp

@@ -102,22 +102,21 @@ bool protocol_address_31402::handle_receive_get_address(const code& ec,
     if (stopped(ec))
         return false;
 
-    // TODO: allowing repeated queries can allow a channel to map our history.
-    // TODO: pull active hosts from host cache (currently just resending self).
-    // TODO: need to distort for privacy, don't send currently-connected peers.
-    // TODO: response size limit is max_address (1000).
+    bc::message::network_address::list addresses;
+    network_.fetch_addresses(addresses);
 
-    if (self_.addresses().empty())
-        return false;
-
-    LOG_DEBUG(LOG_NETWORK)
-        << "Sending addresses to [" << authority() << "] ("
-        << self_.addresses().size() << ")";
+    if (!addresses.empty())
+    {
+        const address address_subset(addresses);
+        SEND2(address_subset, handle_send, _1, self_.command);
 
-    SEND2(self_, handle_send, _1, self_.command);
+        LOG_DEBUG(LOG_NETWORK)
+            << "Sending addresses to [" << authority() << "] ("
+            << self_.addresses().size() << ")";
+    }
 
-    // RESUBSCRIBE
-    return true;
+    // do not resubscribe; one response per connection permitted
+    return false;
 }
 
 void protocol_address_31402::handle_store_addresses(const code& ec)

src/protocols/protocol_ping_60001.cpp

@@ -67,7 +67,7 @@ void protocol_ping_60001::send_ping(const code& ec)
     }
 
     pending_ = true;
-    const auto nonce = pseudo_random();
+    const auto nonce = pseudo_random::next();
     SUBSCRIBE3(pong, handle_receive_pong, _1, _2, nonce);
     SEND2(ping{ nonce }, handle_send_ping, _1, ping::command);
 }

src/sessions/session.cpp

@@ -196,7 +196,7 @@ void session::start_channel(channel::ptr channel,
     result_handler handle_started)
 {
     channel->set_notify(notify_on_connect_);
-    channel->set_nonce(pseudo_random(1, max_uint64));
+    channel->set_nonce(pseudo_random::next(1, max_uint64));
 
     // The channel starts, invokes the handler, then starts the read cycle.
     channel->start(