make hidden services work again (probably)

include/llarp/path.hpp

@@ -228,7 +228,7 @@ namespace llarp
       typedef std::function< bool(Path*, const PathID_t&, uint64_t) >
           DropHandlerFunc;
       typedef std::vector< PathHopConfig > HopList;
-      typedef std::function< bool(const service::ProtocolFrame*) >
+      typedef std::function< bool(Path*, const service::ProtocolFrame*) >
           DataHandlerFunc;
 
       HopList hops;

include/llarp/service/endpoint.hpp

@@ -97,7 +97,8 @@ namespace llarp
       HandleGotRouterMessage(const llarp::dht::GotRouterMessage* msg);
 
       bool
-      HandleHiddenServiceFrame(const llarp::service::ProtocolFrame* msg);
+      HandleHiddenServiceFrame(path::Path* p,
+                               const llarp::service::ProtocolFrame* msg);
 
       /// return true if we have an established path to a hidden service
       bool
@@ -247,7 +248,7 @@ namespace llarp
                   RouterContact& cur, size_t hop);
 
         bool
-        HandleHiddenServiceFrame(const ProtocolFrame* frame);
+        HandleHiddenServiceFrame(path::Path* p, const ProtocolFrame* frame);
 
         std::string
         Name() const;

include/llarp/service/protocol.hpp

@@ -96,7 +96,7 @@ namespace llarp
 
       bool
       AsyncDecryptAndVerify(llarp_logic* logic, llarp_crypto* c,
-                            llarp_threadpool* worker,
+                            const PathID_t& srcpath, llarp_threadpool* worker,
                             const Identity& localIdent,
                             IDataHandler* handler) const;
 

llarp/path.cpp

@@ -590,7 +590,7 @@ namespace llarp
     Path::HandleHiddenServiceFrame(const llarp::service::ProtocolFrame* frame)
     {
       if(m_DataHandler)
-        return m_DataHandler(frame);
+        return m_DataHandler(this, frame);
       return false;
     }
 

llarp/router.cpp

@@ -319,6 +319,9 @@ llarp_router::on_verify_client_rc(llarp_async_verify_rc *job)
   llarp::async_verify_context *ctx =
       static_cast< llarp::async_verify_context * >(job->user);
   ctx->router->pendingEstablishJobs.erase(job->rc.pubkey);
+  auto router = ctx->router;
+  llarp::PubKey pk(job->rc.pubkey);
+  router->FlushOutboundFor(pk, router->GetLinkWithSessionByPubkey(pk));
   delete ctx;
 }
 

llarp/service/endpoint.cpp

@@ -681,7 +681,8 @@ namespace llarp
     Endpoint::HandlePathBuilt(path::Path* p)
     {
       p->SetDataHandler(std::bind(&Endpoint::HandleHiddenServiceFrame, this,
-                                  std::placeholders::_1));
+                                  std::placeholders::_1,
+                                  std::placeholders::_2));
       p->SetDropHandler(std::bind(&Endpoint::HandleDataDrop, this,
                                   std::placeholders::_1, std::placeholders::_2,
                                   std::placeholders::_3));
@@ -728,10 +729,11 @@ namespace llarp
     }
 
     bool
-    Endpoint::HandleHiddenServiceFrame(const ProtocolFrame* frame)
+    Endpoint::HandleHiddenServiceFrame(path::Path* p,
+                                       const ProtocolFrame* frame)
     {
-      return frame->AsyncDecryptAndVerify(EndpointLogic(), Crypto(), Worker(),
-                                          m_Identity, m_DataHandler);
+      return frame->AsyncDecryptAndVerify(EndpointLogic(), Crypto(), p->RXID(),
+                                          Worker(), m_Identity, m_DataHandler);
     }
 
     Endpoint::SendContext::SendContext(const ServiceInfo& ident,
@@ -750,7 +752,7 @@ namespace llarp
     {
       p->SetDataHandler(
           std::bind(&Endpoint::OutboundContext::HandleHiddenServiceFrame, this,
-                    std::placeholders::_1));
+                    std::placeholders::_1, std::placeholders::_2));
       p->SetDropHandler(std::bind(
           &Endpoint::OutboundContext::HandleDataDrop, this,
           std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
@@ -780,9 +782,9 @@ namespace llarp
 
     bool
     Endpoint::OutboundContext::HandleHiddenServiceFrame(
-        const ProtocolFrame* frame)
+        path::Path* p, const ProtocolFrame* frame)
     {
-      return m_Endpoint->HandleHiddenServiceFrame(frame);
+      return m_Endpoint->HandleHiddenServiceFrame(p, frame);
     }
 
     bool
@@ -1158,7 +1160,7 @@ namespace llarp
       if(updatingIntroSet)
         return;
       auto addr = currentIntroSet.A.Addr();
-      auto path = m_Endpoint->GetEstablishedPathClosestTo(addr.data());
+      auto path = m_Endpoint->PickRandomEstablishedPath();
       if(path)
       {
         HiddenServiceAddressLookup* job = new HiddenServiceAddressLookup(

llarp/service/protocol.cpp

@@ -31,7 +31,8 @@ namespace llarp
     ProtocolMessage::ProcessAsync(void* user)
     {
       ProtocolMessage* self = static_cast< ProtocolMessage* >(user);
-      self->handler->HandleDataMessage(self->srcPath, self);
+      if(!self->handler->HandleDataMessage(self->srcPath, self))
+        llarp::LogWarn("failed to handle data message from ", self->srcPath);
       delete self;
     }
 
@@ -295,6 +296,7 @@ namespace llarp
 
     bool
     ProtocolFrame::AsyncDecryptAndVerify(llarp_logic* logic, llarp_crypto* c,
+                                         const PathID_t& srcPath,
                                          llarp_threadpool* worker,
                                          const Identity& localIdent,
                                          IDataHandler* handler) const
@@ -302,6 +304,7 @@ namespace llarp
       if(T.IsZero())
       {
         ProtocolMessage* msg = new ProtocolMessage();
+        msg->srcPath         = srcPath;
         // we need to dh
         auto dh =
             new AsyncFrameDecrypt(logic, c, localIdent, handler, msg, *this);
@@ -332,6 +335,7 @@ namespace llarp
         delete msg;
         return false;
       }
+      msg->srcPath = srcPath;
       msg->handler = handler;
       llarp_logic_queue_job(logic, {msg, &ProtocolMessage::ProcessAsync});
       return true;