make it work

llarp/path/path.cpp

@@ -172,26 +172,24 @@ namespace llarp
     IHopHandler*
     PathContext::GetByUpstream(const RouterID& remote, const PathID_t& id)
     {
-      auto own = MapGet(
+      auto own = MapGet(m_OurPaths, id,
-          m_OurPaths, id,
+                        [](__attribute__((unused)) const PathSet* s) -> bool {
-          [](__attribute__((unused)) const PathSet* s) -> bool {
+                          // TODO: is this right?
-            // TODO: is this right?
+                          return true;
-            return true;
+                        },
-          },
+                        [remote, id](PathSet* p) -> IHopHandler* {
-          [remote, id](PathSet* p) -> IHopHandler* {
+                          return p->GetByUpstream(remote, id);
-            return p->GetByUpstream(remote, id);
+                        });
-          });
       if(own)
         return own;
 
-      return MapGet(
+      return MapGet(m_TransitPaths, id,
-          m_TransitPaths, id,
+                    [remote](const std::shared_ptr< TransitHop >& hop) -> bool {
-          [remote](const std::shared_ptr< TransitHop >& hop) -> bool {
+                      return hop->info.upstream == remote;
-            return hop->info.upstream == remote;
+                    },
-          },
+                    [](const std::shared_ptr< TransitHop >& h) -> IHopHandler* {
-          [](const std::shared_ptr< TransitHop >& h) -> IHopHandler* {
+                      return h.get();
-            return h.get();
+                    });
-          });
     }
 
     bool
@@ -208,14 +206,13 @@ namespace llarp
     IHopHandler*
     PathContext::GetByDownstream(const RouterID& remote, const PathID_t& id)
     {
-      return MapGet(
+      return MapGet(m_TransitPaths, id,
-          m_TransitPaths, id,
+                    [remote](const std::shared_ptr< TransitHop >& hop) -> bool {
-          [remote](const std::shared_ptr< TransitHop >& hop) -> bool {
+                      return hop->info.downstream == remote;
-            return hop->info.downstream == remote;
+                    },
-          },
+                    [](const std::shared_ptr< TransitHop >& h) -> IHopHandler* {
-          [](const std::shared_ptr< TransitHop >& h) -> IHopHandler* {
+                      return h.get();
-            return h.get();
+                    });
-          });
     }
 
     PathSet*
@@ -440,6 +437,13 @@ namespace llarp
       return intro.latency > 0 && _status == ePathEstablished;
     }
 
+    bool
+    Path::IsEndpoint(const RouterID& r, const PathID_t& id) const
+    {
+      return hops[hops.size() - 1].rc.pubkey == r
+          && hops[hops.size() - 1].txID == id;
+    }
+
     RouterID
     Path::Upstream() const
     {

llarp/path/pathset.cpp

@@ -156,6 +156,22 @@ namespace llarp
       return chosen;
     }
 
+    Path*
+    PathSet::GetByEndpointWithID(RouterID ep, PathID_t id) const
+    {
+      Lock_t l(&m_PathsMutex);
+      auto itr = m_Paths.begin();
+      while(itr != m_Paths.end())
+      {
+        if(itr->second->IsEndpoint(ep, id))
+        {
+          return itr->second;
+        }
+        ++itr;
+      }
+      return nullptr;
+    }
+
     Path*
     PathSet::GetPathByID(PathID_t id) const
     {

llarp/path/pathset.hpp

@@ -176,6 +176,9 @@ namespace llarp
       Path*
       GetPathByID(PathID_t id) const;
 
+      Path*
+      GetByEndpointWithID(RouterID router, PathID_t id) const;
+
       bool
       GetCurrentIntroductionsWithFilter(
           std::set< service::Introduction >& intros,

llarp/service/endpoint.cpp

@@ -1585,6 +1585,7 @@ namespace llarp
         self->handler->PutCachedSessionKeyFor(self->msg.tag, self->sharedKey);
         self->handler->PutIntroFor(self->msg.tag, self->remoteIntro);
         self->handler->PutSenderFor(self->msg.tag, self->remote);
+        self->handler->PutReplyIntroFor(self->msg.tag, self->msg.introReply);
         self->hook(self->frame);
         delete self;
       }
@@ -1671,24 +1672,22 @@ namespace llarp
 
       ex->msg.PutBuffer(payload);
       ex->msg.introReply = path->intro;
-      m_DataHandler->PutReplyIntroFor(currentConvoTag, path->intro);
+      ex->frame.F        = ex->msg.introReply.pathID;
       llarp_threadpool_queue_job(m_Endpoint->Worker(),
                                  {ex, &AsyncKeyExchange::Encrypt});
     }
 
     bool
-    Endpoint::SendContext::Send(ProtocolFrame& msg)
+    Endpoint::SendContext::Send(const ProtocolFrame& msg)
     {
-      auto path = m_PathSet->GetPathByRouter(remoteIntro.router);
+      auto path = m_PathSet->GetByEndpointWithID(remoteIntro.router, msg.F);
-      if(path == nullptr)
-        path = m_Endpoint->GetPathByRouter(remoteIntro.router);
       if(path)
       {
         const routing::PathTransferMessage transfer(msg, remoteIntro.pathID);
         if(path->SendRoutingMessage(&transfer, m_Endpoint->Router()))
         {
-          llarp::LogDebug("sent data to ", remoteIntro.pathID, " on ",
+          llarp::LogInfo("sent intro to ", remoteIntro.pathID, " on ",
-                          remoteIntro.router, " seqno=", sequenceNo);
+                         remoteIntro.router, " seqno=", sequenceNo);
           lastGoodSend = m_Endpoint->Now();
           ++sequenceNo;
           return true;

llarp/service/endpoint.hpp

@@ -222,7 +222,7 @@ namespace llarp
         /// send a fully encrypted hidden service frame
         /// via a path on our pathset with path id p
         bool
-        Send(ProtocolFrame& f);
+        Send(const ProtocolFrame& f);
 
         llarp::SharedSecret sharedKey;
         ServiceInfo remoteIdent;