2019-04-19 16:02:32 +00:00
|
|
|
#include <service/sendcontext.hpp>
|
|
|
|
|
|
|
|
#include <router/abstractrouter.hpp>
|
2019-06-19 22:30:07 +00:00
|
|
|
#include <routing/path_transfer_message.hpp>
|
2019-06-15 14:55:14 +00:00
|
|
|
#include <service/endpoint.hpp>
|
2019-09-01 13:26:16 +00:00
|
|
|
#include <util/thread/logic.hpp>
|
2019-07-30 23:42:13 +00:00
|
|
|
#include <utility>
|
2019-09-19 14:41:31 +00:00
|
|
|
#include <unordered_set>
|
2019-04-19 16:02:32 +00:00
|
|
|
|
|
|
|
namespace llarp
|
|
|
|
{
|
|
|
|
namespace service
|
|
|
|
{
|
2020-01-06 21:08:31 +00:00
|
|
|
static constexpr size_t SendContextQueueSize = 512;
|
|
|
|
|
2019-07-30 23:42:13 +00:00
|
|
|
SendContext::SendContext(ServiceInfo ident, const Introduction& intro,
|
|
|
|
path::PathSet* send, Endpoint* ep)
|
|
|
|
: remoteIdent(std::move(ident))
|
2019-04-19 16:02:32 +00:00
|
|
|
, remoteIntro(intro)
|
|
|
|
, m_PathSet(send)
|
|
|
|
, m_DataHandler(ep)
|
|
|
|
, m_Endpoint(ep)
|
2020-01-06 21:08:31 +00:00
|
|
|
, m_SendQueue(SendContextQueueSize)
|
2019-04-19 16:02:32 +00:00
|
|
|
{
|
|
|
|
createdAt = ep->Now();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
2019-09-19 14:41:31 +00:00
|
|
|
SendContext::Send(std::shared_ptr< ProtocolFrame > msg, path::Path_ptr path)
|
2019-04-19 16:02:32 +00:00
|
|
|
{
|
2020-01-06 21:08:31 +00:00
|
|
|
if(m_SendQueue.empty() or m_SendQueue.full())
|
|
|
|
{
|
|
|
|
LogicCall(m_Endpoint->RouterLogic(),
|
|
|
|
[self = this]() { self->FlushUpstream(); });
|
|
|
|
}
|
|
|
|
m_SendQueue.pushBack(
|
|
|
|
std::make_pair(std::make_shared< const routing::PathTransferMessage >(
|
|
|
|
*msg, remoteIntro.pathID),
|
|
|
|
path));
|
2019-04-25 17:15:56 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2019-04-30 15:09:42 +00:00
|
|
|
SendContext::FlushUpstream()
|
2019-04-25 17:15:56 +00:00
|
|
|
{
|
|
|
|
auto r = m_Endpoint->Router();
|
2019-09-19 14:41:31 +00:00
|
|
|
std::unordered_set< path::Path_ptr, path::Path::Ptr_Hash > flushpaths;
|
2019-04-25 17:15:56 +00:00
|
|
|
{
|
2020-01-06 21:08:31 +00:00
|
|
|
do
|
2019-04-19 16:02:32 +00:00
|
|
|
{
|
2020-01-06 21:08:31 +00:00
|
|
|
auto maybe = m_SendQueue.tryPopFront();
|
|
|
|
if(not maybe.has_value())
|
|
|
|
break;
|
|
|
|
auto& item = maybe.value();
|
2019-09-19 14:41:31 +00:00
|
|
|
if(item.second->SendRoutingMessage(*item.first, r))
|
|
|
|
{
|
|
|
|
lastGoodSend = r->Now();
|
|
|
|
flushpaths.emplace(item.second);
|
2019-10-01 14:51:28 +00:00
|
|
|
m_Endpoint->MarkConvoTagActive(item.first->T.T);
|
2019-09-19 14:41:31 +00:00
|
|
|
}
|
2020-01-06 21:08:31 +00:00
|
|
|
} while(not m_SendQueue.empty());
|
2019-09-19 14:41:31 +00:00
|
|
|
}
|
|
|
|
// flush the select path's upstream
|
|
|
|
for(const auto& path : flushpaths)
|
|
|
|
{
|
|
|
|
path->FlushUpstream(r);
|
2019-04-25 17:15:56 +00:00
|
|
|
}
|
2019-04-19 16:02:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// send on an established convo tag
|
|
|
|
void
|
|
|
|
SendContext::EncryptAndSendTo(const llarp_buffer_t& payload, ProtocolType t)
|
|
|
|
{
|
|
|
|
SharedSecret shared;
|
2019-09-19 14:41:31 +00:00
|
|
|
auto f = std::make_shared< ProtocolFrame >();
|
|
|
|
f->N.Randomize();
|
|
|
|
f->T = currentConvoTag;
|
|
|
|
f->S = ++sequenceNo;
|
2019-04-19 16:02:32 +00:00
|
|
|
|
|
|
|
auto path = m_PathSet->GetNewestPathByRouter(remoteIntro.router);
|
|
|
|
if(!path)
|
|
|
|
{
|
2019-07-18 16:28:17 +00:00
|
|
|
LogError(m_Endpoint->Name(),
|
|
|
|
" cannot encrypt and send: no path for intro ", remoteIntro);
|
2019-04-19 16:02:32 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-09-19 14:41:31 +00:00
|
|
|
if(!m_DataHandler->GetCachedSessionKeyFor(f->T, shared))
|
2019-04-19 16:02:32 +00:00
|
|
|
{
|
2019-07-18 16:28:17 +00:00
|
|
|
LogError(m_Endpoint->Name(),
|
2019-09-19 14:41:31 +00:00
|
|
|
" has no cached session key on session T=", f->T);
|
2019-04-19 16:02:32 +00:00
|
|
|
return;
|
|
|
|
}
|
2019-05-22 16:20:50 +00:00
|
|
|
|
2019-09-19 14:41:31 +00:00
|
|
|
auto m = std::make_shared< ProtocolMessage >();
|
|
|
|
m_DataHandler->PutIntroFor(f->T, remoteIntro);
|
|
|
|
m_DataHandler->PutReplyIntroFor(f->T, path->intro);
|
|
|
|
m->proto = t;
|
|
|
|
m->seqno = m_Endpoint->GetSeqNoForConvo(f->T);
|
|
|
|
m->introReply = path->intro;
|
|
|
|
f->F = m->introReply.pathID;
|
|
|
|
m->sender = m_Endpoint->GetIdentity().pub;
|
|
|
|
m->tag = f->T;
|
|
|
|
m->PutBuffer(payload);
|
|
|
|
auto self = this;
|
|
|
|
m_Endpoint->CryptoWorker()->addJob([f, m, shared, path, self]() {
|
2019-11-29 05:03:26 +00:00
|
|
|
if(not f->EncryptAndSign(*m, shared, self->m_Endpoint->GetIdentity()))
|
2019-09-19 14:41:31 +00:00
|
|
|
{
|
|
|
|
LogError(self->m_Endpoint->Name(), " failed to sign message");
|
|
|
|
return;
|
|
|
|
}
|
2019-11-29 05:03:26 +00:00
|
|
|
self->Send(f, path);
|
2019-09-19 14:41:31 +00:00
|
|
|
});
|
2019-04-19 16:02:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
SendContext::AsyncEncryptAndSendTo(const llarp_buffer_t& data,
|
|
|
|
ProtocolType protocol)
|
|
|
|
{
|
2019-11-29 05:15:05 +00:00
|
|
|
if(lastGoodSend != 0)
|
2019-04-19 16:02:32 +00:00
|
|
|
{
|
|
|
|
EncryptAndSendTo(data, protocol);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
AsyncGenIntro(data, protocol);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} // namespace service
|
|
|
|
|
|
|
|
} // namespace llarp
|