Draft: Wire Protocol Overhaul, Message Handling Refactor

CMakeLists.txt

@@ -96,7 +96,7 @@ if(CMAKE_BUILD_TYPE MATCHES "[Dd][Ee][Bb][Uu][Gg]")
   add_definitions(-DLOKINET_DEBUG)
 endif()
 
-option(WARN_DEPRECATED "show deprecation warnings" ${debug})
+option(WARN_DEPRECATED "show deprecation warnings" OFF)
 
 include(CheckCXXSourceCompiles)
 include(CheckLibraryExists)

llarp/dht/context.cpp

@@ -110,15 +110,15 @@ namespace llarp
       /// send a dht message to peer, if keepalive is true then keep the session
       /// with that peer alive for 10 seconds
       void
-      DHTSendTo(const RouterID& peer, IMessage* msg, bool keepalive = true) override;
+      DHTSendTo(const RouterID& peer, AbstractDHTMessage* msg, bool keepalive = true) override;
 
       /// get routers closest to target excluding requester
       bool
       HandleExploritoryRouterLookup(
           const Key_t& requester,
           uint64_t txid,
           const RouterID& target,
-          std::vector<std::unique_ptr<IMessage>>& reply) override;
+          std::vector<std::unique_ptr<AbstractDHTMessage>>& reply) override;
 
       /// handle rc lookup from requester for target
       void
@@ -127,11 +127,11 @@ namespace llarp
           uint64_t txid,
           const Key_t& target,
           bool recursive,
-          std::vector<std::unique_ptr<IMessage>>& replies) override;
+          std::vector<std::unique_ptr<AbstractDHTMessage>>& replies) override;
 
       /// relay a dht message from a local path to the main network
       bool
-      RelayRequestForPath(const llarp::PathID_t& localPath, const IMessage& msg) override;
+      RelayRequestForPath(const llarp::PathID_t& localPath, const AbstractDHTMessage& msg) override;
 
       /// send introset to peer as R/S
       void
@@ -374,7 +374,7 @@ namespace llarp
         uint64_t txid,
         const Key_t& target,
         bool recursive,
-        std::vector<std::unique_ptr<IMessage>>& replies)
+        std::vector<std::unique_ptr<AbstractDHTMessage>>& replies)
     {
       if (target == ourKey)
       {
@@ -475,9 +475,9 @@ namespace llarp
     }
 
     void
-    Context::DHTSendTo(const RouterID& peer, IMessage* msg, bool)
+    Context::DHTSendTo(const RouterID& peer, AbstractDHTMessage* msg, bool)
     {
-      llarp::DHTImmediateMessage m;
+      DHTImmediateMessage m;
       m.msgs.emplace_back(msg);
       router->SendToOrQueue(peer, m);
       auto now = Now();
@@ -489,10 +489,10 @@ namespace llarp
     // namespace. by the time this is called, we are inside
     // llarp::routing::DHTMessage::HandleMessage()
     bool
-    Context::RelayRequestForPath(const llarp::PathID_t& id, const IMessage& msg)
+    Context::RelayRequestForPath(const llarp::PathID_t& id, const AbstractDHTMessage& msg)
     {
-      llarp::routing::DHTMessage reply;
-      if (!msg.HandleMessage(router->dht(), reply.M))
+      routing::DHTMessage reply;
+      if (!msg.handle_message(router->dht(), reply.M))
         return false;
       if (not reply.M.empty())
       {
@@ -584,7 +584,7 @@ namespace llarp
         const Key_t& requester,
         uint64_t txid,
         const RouterID& target,
-        std::vector<std::unique_ptr<IMessage>>& reply)
+        std::vector<std::unique_ptr<AbstractDHTMessage>>& reply)
     {
       std::vector<RouterID> closer;
       const Key_t t(target.as_array());

llarp/dht/context.hpp

@@ -89,15 +89,15 @@ namespace llarp
           uint64_t relayOrder) = 0;
 
       virtual void
-      DHTSendTo(const RouterID& peer, IMessage* msg, bool keepalive = true) = 0;
+      DHTSendTo(const RouterID& peer, AbstractDHTMessage* msg, bool keepalive = true) = 0;
 
       /// get routers closest to target excluding requester
       virtual bool
       HandleExploritoryRouterLookup(
           const Key_t& requester,
           uint64_t txid,
           const RouterID& target,
-          std::vector<std::unique_ptr<IMessage>>& reply) = 0;
+          std::vector<std::unique_ptr<AbstractDHTMessage>>& reply) = 0;
 
       /// handle rc lookup from requester for target
       virtual void
@@ -106,10 +106,10 @@ namespace llarp
           uint64_t txid,
           const Key_t& target,
           bool recursive,
-          std::vector<std::unique_ptr<IMessage>>& replies) = 0;
+          std::vector<std::unique_ptr<AbstractDHTMessage>>& replies) = 0;
 
       virtual bool
-      RelayRequestForPath(const PathID_t& localPath, const IMessage& msg) = 0;
+      RelayRequestForPath(const PathID_t& localPath, const AbstractDHTMessage& msg) = 0;
 
       /// send introset to peer from source with S counter and excluding peers
       virtual void

llarp/dht/message.cpp

@@ -1,4 +1,5 @@
 #include "context.hpp"
+#include "oxenc/bt_serialize.h"
 
 #include <memory>
 #include <llarp/util/bencode.hpp>
@@ -10,128 +11,124 @@
 #include <llarp/dht/messages/findname.hpp>
 #include <llarp/dht/messages/gotname.hpp>
 
-namespace llarp
+namespace llarp::dht
 {
-  namespace dht
+  struct MessageDecoder
   {
-    struct MessageDecoder
-    {
-      const Key_t& From;
-      IMessage::Ptr_t msg;
-      bool firstKey = true;
-      bool relayed = false;
+    const Key_t& From;
+    AbstractDHTMessage::Ptr_t msg;
+    bool firstKey = true;
+    bool relayed = false;
 
-      MessageDecoder(const Key_t& from, bool wasRelayed) : From(from), relayed(wasRelayed)
-      {}
+    MessageDecoder(const Key_t& from, bool wasRelayed) : From(from), relayed(wasRelayed)
+    {}
 
-      bool
-      operator()(llarp_buffer_t* buffer, llarp_buffer_t* key)
+    bool
+    operator()(llarp_buffer_t* buffer, llarp_buffer_t* key)
+    {
+      llarp_buffer_t strbuf;
+      // check for empty dict
+      if (!key)
+        return !firstKey;
+      // first key
+      if (firstKey)
       {
-        llarp_buffer_t strbuf;
-        // check for empty dict
-        if (!key)
-          return !firstKey;
-
-        // first key
-        if (firstKey)
+        if (!(key->startswith("A")))
+          return false;
+        if (!bencode_read_string(buffer, &strbuf))
+          return false;
+        // bad msg size?
+        if (strbuf.sz != 1)
+          return false;
+        llarp::LogDebug("Handle DHT message ", *strbuf.base, " relayed=", relayed);
+        switch (*strbuf.base)
         {
-          if (!(key->startswith("A")))
-            return false;
-          if (!bencode_read_string(buffer, &strbuf))
-            return false;
-          // bad msg size?
-          if (strbuf.sz != 1)
-            return false;
-          llarp::LogDebug("Handle DHT message ", *strbuf.base, " relayed=", relayed);
-          switch (*strbuf.base)
-          {
-            case 'N':
-              msg = std::make_unique<FindNameMessage>(From, Key_t{}, 0);
+          case 'N':
+            msg = std::make_unique<FindNameMessage>(From, Key_t{}, 0);
+            break;
+          case 'M':
+            msg = std::make_unique<GotNameMessage>(From, 0, service::EncryptedName{});
+            break;
+          case 'F':
+            msg = std::make_unique<FindIntroMessage>(From, relayed, 0);
+            break;
+          case 'R':
+            if (relayed)
+              msg = std::make_unique<RelayedFindRouterMessage>(From);
+            else
+              msg = std::make_unique<FindRouterMessage>(From);
+            break;
+          case 'S':
+            msg = std::make_unique<GotRouterMessage>(From, relayed);
+            break;
+          case 'I':
+            msg = std::make_unique<PublishIntroMessage>(From, relayed);
+            break;
+          case 'G':
+            if (relayed)
+            {
+              msg = std::make_unique<RelayedGotIntroMessage>();
               break;
-            case 'M':
-              msg = std::make_unique<GotNameMessage>(From, 0, service::EncryptedName{});
+            }
+            else
+            {
+              msg = std::make_unique<GotIntroMessage>(From);
               break;
-            case 'F':
-              msg = std::make_unique<FindIntroMessage>(From, relayed, 0);
-              break;
-            case 'R':
-              if (relayed)
-                msg = std::make_unique<RelayedFindRouterMessage>(From);
-              else
-                msg = std::make_unique<FindRouterMessage>(From);
-              break;
-            case 'S':
-              msg = std::make_unique<GotRouterMessage>(From, relayed);
-              break;
-            case 'I':
-              msg = std::make_unique<PublishIntroMessage>(From, relayed);
-              break;
-            case 'G':
-              if (relayed)
-              {
-                msg = std::make_unique<RelayedGotIntroMessage>();
-                break;
-              }
-              else
-              {
-                msg = std::make_unique<GotIntroMessage>(From);
-                break;
-              }
-            default:
-              llarp::LogWarn("unknown dht message type: ", (char)*strbuf.base);
-              // bad msg type
-              return false;
-          }
-          firstKey = false;
-          return msg != nullptr;
+            }
+          default:
+            llarp::LogWarn("unknown dht message type: ", (char)*strbuf.base);
+            // bad msg type
+            return false;
         }
-
-        return msg->DecodeKey(*key, buffer);
+        firstKey = false;
+        return msg != nullptr;
       }
-    };
 
-    IMessage::Ptr_t
-    DecodeMesssage(const Key_t& from, llarp_buffer_t* buf, bool relayed)
-    {
-      MessageDecoder dec(from, relayed);
-      if (!bencode_read_dict(dec, buf))
-        return nullptr;
-
-      return std::move(dec.msg);
+      return msg->decode_key(*key, buffer);
     }
+  };
 
-    struct ListDecoder
-    {
-      ListDecoder(bool hasRelayed, const Key_t& from, std::vector<IMessage::Ptr_t>& list)
-          : relayed(hasRelayed), From(from), l(list)
-      {}
+  AbstractDHTMessage::Ptr_t
+  DecodeMessage(const Key_t& from, llarp_buffer_t* buf, bool relayed)
+  {
+    MessageDecoder dec(from, relayed);
+    if (!bencode_read_dict(dec, buf))
+      return nullptr;
 
-      bool relayed;
-      const Key_t& From;
-      std::vector<IMessage::Ptr_t>& l;
+    return std::move(dec.msg);
+  }
 
-      bool
-      operator()(llarp_buffer_t* buffer, bool has)
-      {
-        if (!has)
-          return true;
-        auto msg = DecodeMesssage(From, buffer, relayed);
-        if (msg)
-        {
-          l.emplace_back(std::move(msg));
-          return true;
-        }
+  struct ListDecoder
+  {
+    ListDecoder(bool hasRelayed, const Key_t& from, std::vector<AbstractDHTMessage::Ptr_t>& list)
+        : relayed(hasRelayed), From(from), l(list)
+    {}
 
-        return false;
-      }
-    };
+    bool relayed;
+    const Key_t& From;
+    std::vector<AbstractDHTMessage::Ptr_t>& l;
 
     bool
-    DecodeMesssageList(
-        Key_t from, llarp_buffer_t* buf, std::vector<IMessage::Ptr_t>& list, bool relayed)
+    operator()(llarp_buffer_t* buffer, bool has)
     {
-      ListDecoder dec(relayed, from, list);
-      return bencode_read_list(dec, buf);
+      if (!has)
+        return true;
+      auto msg = DecodeMessage(From, buffer, relayed);
+      if (msg)
+      {
+        l.emplace_back(std::move(msg));
+        return true;
+      }
+
+      return false;
     }
-  }  // namespace dht
-}  // namespace llarp
+  };
+
+  bool
+  DecodeMessageList(
+      Key_t from, llarp_buffer_t* buf, std::vector<AbstractDHTMessage::Ptr_t>& list, bool relayed)
+  {
+    ListDecoder dec(relayed, from, list);
+    return bencode_read_list(dec, buf);
+  }
+}  // namespace llarp::dht