abstracted nework addresses

All code which was using ip and port now uses a new IPv4 object,
subclass of a new network_address class. This will allow easy
addition of I2P addresses later (and also IPv6, etc).
Both old style and new style peer lists are now sent in the P2P
protocol, which is inefficient but allows peers using both
codebases to talk to each other. This will be removed in the
future. No other subclasses than IPv4 exist yet.

2 files changed, 44 insertions, 9 deletions

diff --git a/src/rpc/core_rpc_server.cpp b/src/rpc/core_rpc_server.cpp
index 76a69fbf6..640c53522 100644
--- a/src/rpc/core_rpc_server.cpp
+++ b/src/rpc/core_rpc_server.cpp
@@ -736,12 +736,20 @@ namespace cryptonote
 
     for (auto & entry : white_list)
     {
-      res.white_list.emplace_back(entry.id, entry.adr.ip, entry.adr.port, entry.last_seen);
+      if (entry.adr.type() == typeid(epee::net_utils::ipv4_network_address))
+        res.white_list.emplace_back(entry.id, entry.adr.as<epee::net_utils::ipv4_network_address>().ip(),
+            entry.adr.as<epee::net_utils::ipv4_network_address>().port(), entry.last_seen);
+      else
+        res.white_list.emplace_back(entry.id, entry.adr.str(), entry.last_seen);
     }
 
     for (auto & entry : gray_list)
     {
-      res.gray_list.emplace_back(entry.id, entry.adr.ip, entry.adr.port, entry.last_seen);
+      if (entry.adr.type() == typeid(epee::net_utils::ipv4_network_address))
+        res.gray_list.emplace_back(entry.id, entry.adr.as<epee::net_utils::ipv4_network_address>().ip(),
+            entry.adr.as<epee::net_utils::ipv4_network_address>().port(), entry.last_seen);
+      else
+        res.gray_list.emplace_back(entry.id, entry.adr.str(), entry.last_seen);
     }
 
     res.status = CORE_RPC_STATUS_OK;
@@ -1300,12 +1308,16 @@ namespace cryptonote
     }
 
     auto now = time(nullptr);
-    std::map<uint32_t, time_t> blocked_ips = m_p2p.get_blocked_ips();
-    for (std::map<uint32_t, time_t>::const_iterator i = blocked_ips.begin(); i != blocked_ips.end(); ++i)
+    std::map<std::string, time_t> blocked_hosts = m_p2p.get_blocked_hosts();
+    for (std::map<std::string, time_t>::const_iterator i = blocked_hosts.begin(); i != blocked_hosts.end(); ++i)
     {
       if (i->second > now) {
         COMMAND_RPC_GETBANS::ban b;
-        b.ip = i->first;
+        b.host = i->first;
+        b.ip = 0;
+        uint32_t ip;
+        if (epee::string_tools::get_ip_int32_from_string(ip, i->first))
+          b.ip = ip;
         b.seconds = i->second - now;
         res.bans.push_back(b);
       }
@@ -1326,10 +1338,24 @@ namespace cryptonote
 
     for (auto i = req.bans.begin(); i != req.bans.end(); ++i)
     {
+      epee::net_utils::network_address na;
+      if (!i->host.empty())
+      {
+        if (!epee::net_utils::create_network_address(na, i->host))
+        {
+          error_resp.code = CORE_RPC_ERROR_CODE_WRONG_PARAM;
+          error_resp.message = "Unsupported host type";
+          return false;
+        }
+      }
+      else
+      {
+        na.reset(new epee::net_utils::ipv4_network_address(i->ip, 0));
+      }
       if (i->ban)
-        m_p2p.block_ip(i->ip, i->seconds);
+        m_p2p.block_host(na, i->seconds);
       else
-        m_p2p.unblock_ip(i->ip);
+        m_p2p.unblock_host(na);
     }
 
     res.status = CORE_RPC_STATUS_OK;
diff --git a/src/rpc/core_rpc_server_commands_defs.h b/src/rpc/core_rpc_server_commands_defs.h
index 9bdadf0d1..28be288c4 100644
--- a/src/rpc/core_rpc_server_commands_defs.h
+++ b/src/rpc/core_rpc_server_commands_defs.h
@@ -49,7 +49,7 @@ namespace cryptonote
 // advance which version they will stop working with
 // Don't go over 32767 for any of these
 #define CORE_RPC_VERSION_MAJOR 1
-#define CORE_RPC_VERSION_MINOR 10
+#define CORE_RPC_VERSION_MINOR 11
 #define MAKE_CORE_RPC_VERSION(major,minor) (((major)<<16)|(minor))
 #define CORE_RPC_VERSION MAKE_CORE_RPC_VERSION(CORE_RPC_VERSION_MAJOR, CORE_RPC_VERSION_MINOR)
 
@@ -861,18 +861,23 @@ namespace cryptonote
 
   struct peer {
     uint64_t id;
+    std::string host;
     uint32_t ip;
     uint16_t port;
     uint64_t last_seen;
 
     peer() = default;
 
+    peer(uint64_t id, const std::string &host, uint64_t last_seen)
+      : id(id), host(host), ip(0), port(0), last_seen(last_seen)
+    {}
     peer(uint64_t id, uint32_t ip, uint16_t port, uint64_t last_seen)
-      : id(id), ip(ip), port(port), last_seen(last_seen)
+      : id(id), host(std::to_string(ip)), ip(ip), port(port), last_seen(last_seen)
     {}
 
     BEGIN_KV_SERIALIZE_MAP()
       KV_SERIALIZE(id)
+      KV_SERIALIZE(host)
       KV_SERIALIZE(ip)
       KV_SERIALIZE(port)
       KV_SERIALIZE(last_seen)
@@ -1226,10 +1231,12 @@ namespace cryptonote
   {
     struct ban
     {
+      std::string host;
       uint32_t ip;
       uint32_t seconds;
 
       BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(host)
         KV_SERIALIZE(ip)
         KV_SERIALIZE(seconds)
       END_KV_SERIALIZE_MAP()
@@ -1257,11 +1264,13 @@ namespace cryptonote
   {
     struct ban
     {
+      std::string host;
       uint32_t ip;
       bool ban;
       uint32_t seconds;
 
       BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(host)
         KV_SERIALIZE(ip)
         KV_SERIALIZE(ban)
         KV_SERIALIZE(seconds)