pass in path

llarp/service/endpoint.cpp

@@ -837,13 +837,10 @@ namespace llarp
     }
 
     bool
-    Endpoint::HandleDataMessage(const PathID_t& src,
+    Endpoint::HandleDataMessage(path::Path_ptr path,
                                 std::shared_ptr< ProtocolMessage > msg)
     {
       msg->sender.UpdateAddr();
-      auto path = GetPathByID(src);
-      if(path == nullptr)
-        return false;
       PutReplyIntroFor(msg->tag, path->intro);
       PutSenderFor(msg->tag, msg->sender, true);
       PutIntroFor(msg->tag, msg->introReply);

llarp/service/endpoint.hpp

@@ -165,7 +165,7 @@ namespace llarp
       ForgetPathToService(const Address& remote);
 
       bool
-      HandleDataMessage(const PathID_t&,
+      HandleDataMessage(path::Path_ptr path,
                         std::shared_ptr< ProtocolMessage > msg) override;
 
       virtual bool

llarp/service/handler.hpp

@@ -2,7 +2,7 @@
 #define LLARP_SERVICE_HANDLER_HPP
 
 #include <crypto/types.hpp>
-#include <path/path_types.hpp>
+#include <path/path.hpp>
 #include <service/intro_set.hpp>
 #include <util/aligned.hpp>
 #include <memory>
@@ -17,7 +17,7 @@ namespace llarp
     struct IDataHandler
     {
       virtual bool
-      HandleDataMessage(const PathID_t&,
+      HandleDataMessage(path::Path_ptr path,
                         std::shared_ptr< ProtocolMessage > msg) = 0;
 
       virtual bool

llarp/service/protocol.cpp

@@ -31,10 +31,11 @@ namespace llarp
     }
 
     void
-    ProtocolMessage::ProcessAsync(std::shared_ptr< ProtocolMessage > self)
+    ProtocolMessage::ProcessAsync(path::Path_ptr path,
+                                  std::shared_ptr< ProtocolMessage > self)
     {
-      if(!self->handler->HandleDataMessage(self->srcPath, self))
-        LogWarn("failed to handle data message from ", self->srcPath);
+      if(!self->handler->HandleDataMessage(path, self))
+        LogWarn("failed to handle data message from ", path->Name());
     }
 
     bool
@@ -245,6 +246,7 @@ namespace llarp
 
     struct AsyncFrameDecrypt
     {
+      path::Path_ptr path;
       std::shared_ptr< Logic > logic;
       std::shared_ptr< ProtocolMessage > msg;
       const Identity& m_LocalIdentity;
@@ -342,7 +344,9 @@ namespace llarp
 
         self->msg->handler                     = self->handler;
         std::shared_ptr< ProtocolMessage > msg = std::move(self->msg);
-        self->logic->queue_func([=]() { ProtocolMessage::ProcessAsync(msg); });
+        path::Path_ptr path                    = std::move(self->path);
+        self->logic->queue_func(
+            [=]() { ProtocolMessage::ProcessAsync(path, msg); });
         delete self;
       }
     };
@@ -373,10 +377,10 @@ namespace llarp
       if(T.IsZero())
       {
         LogInfo("Got protocol frame with new convo");
-        msg->srcPath = recvPath->RXID();
         // we need to dh
-        auto dh = new AsyncFrameDecrypt(logic, localIdent, handler, msg, *this,
+        auto dh  = new AsyncFrameDecrypt(logic, localIdent, handler, msg, *this,
                                         recvPath->intro);
+        dh->path = recvPath;
         llarp_threadpool_queue_job(worker, {dh, &AsyncFrameDecrypt::Work});
         return true;
       }
@@ -402,9 +406,9 @@ namespace llarp
         LogError("failed to decrypt message");
         return false;
       }
-      msg->srcPath = recvPath->RXID();
       msg->handler = handler;
-      logic->queue_func([=]() { ProtocolMessage::ProcessAsync(msg); });
+      logic->queue_func(
+          [=]() { ProtocolMessage::ProcessAsync(recvPath, msg); });
       return true;
     }
 

llarp/service/protocol.hpp

@@ -49,8 +49,6 @@ namespace llarp
       Introduction introReply;
       ServiceInfo sender;
       IDataHandler* handler = nullptr;
-      /// local path we got this message from
-      PathID_t srcPath;
       ConvoTag tag;
       uint64_t seqno   = 0;
       uint64_t version = LLARP_PROTO_VERSION;
@@ -65,7 +63,7 @@ namespace llarp
       PutBuffer(const llarp_buffer_t& payload);
 
       static void
-      ProcessAsync(std::shared_ptr< ProtocolMessage > self);
+      ProcessAsync(path::Path_ptr p, std::shared_ptr< ProtocolMessage > self);
 
       bool
       operator<(const ProtocolMessage& other) const