lokinet/llarp/transit_hop.cpp

141 lines
3.8 KiB
C++
Raw Normal View History

2018-06-22 00:25:30 +00:00
#include <llarp/path.hpp>
2018-06-26 16:23:43 +00:00
#include <llarp/routing/handler.hpp>
2018-06-22 00:25:30 +00:00
#include "buffer.hpp"
#include "router.hpp"
namespace llarp
{
namespace path
2018-06-22 00:25:30 +00:00
{
2018-06-26 16:23:43 +00:00
TransitHop::TransitHop()
{
}
bool
TransitHop::Expired(llarp_time_t now) const
{
return now - started > lifetime;
}
2018-06-22 00:25:30 +00:00
TransitHopInfo::TransitHopInfo(const TransitHopInfo& other)
: txID(other.txID)
, rxID(other.rxID)
, upstream(other.upstream)
, downstream(other.downstream)
{
}
2018-06-22 00:25:30 +00:00
TransitHopInfo::TransitHopInfo(const RouterID& down,
const LR_CommitRecord& record)
: txID(record.txid)
, rxID(record.rxid)
, upstream(record.nextHop)
, downstream(down)
{
}
2018-06-22 00:25:30 +00:00
TransitHop::TransitHop(const TransitHop& other)
: info(other.info)
, pathKey(other.pathKey)
, started(other.started)
, lifetime(other.lifetime)
, version(other.version)
2018-06-22 00:25:30 +00:00
{
}
bool
TransitHop::SendRoutingMessage(const llarp::routing::IMessage* msg,
llarp_router* r)
{
byte_t tmp[MAX_LINK_MSG_SIZE / 2];
auto buf = llarp::StackBuffer< decltype(tmp) >(tmp);
if(!msg->BEncode(&buf))
{
llarp::LogError("failed to encode routing message");
return false;
}
TunnelNonce N;
N.Randomize();
// rewind
buf.sz = buf.cur - buf.base;
buf.cur = buf.base;
return HandleDownstream(buf, N, r);
}
2018-06-22 00:25:30 +00:00
bool
TransitHop::HandleDownstream(llarp_buffer_t buf, const TunnelNonce& Y,
llarp_router* r)
{
RelayDownstreamMessage* msg = new RelayDownstreamMessage;
msg->pathid = info.rxID;
msg->Y = Y;
2018-06-22 00:25:30 +00:00
r->crypto.xchacha20(buf, pathKey, Y);
msg->X = buf;
llarp::LogDebug("relay ", msg->X.size(), " bytes downstream from ",
info.upstream, " to ", info.downstream);
return r->SendToOrQueue(info.downstream, msg);
}
2018-06-22 00:25:30 +00:00
bool
TransitHop::HandleUpstream(llarp_buffer_t buf, const TunnelNonce& Y,
llarp_router* r)
{
r->crypto.xchacha20(buf, pathKey, Y);
2018-06-26 16:23:43 +00:00
if(info.upstream == RouterID(r->pubkey()))
{
return m_MessageParser.ParseMessageBuffer(buf, this, r);
}
else
{
RelayUpstreamMessage* msg = new RelayUpstreamMessage;
msg->pathid = info.txID;
msg->Y = Y;
msg->X = buf;
llarp::LogDebug("relay ", msg->X.size(), " bytes upstream from ",
info.downstream, " to ", info.upstream);
2018-06-26 16:23:43 +00:00
return r->SendToOrQueue(info.upstream, msg);
}
}
bool
TransitHop::HandleDHTMessage(const llarp::dht::IMessage* msg,
llarp_router* r)
{
return r->dht->impl.RelayRequestForPath(info.rxID, msg);
2018-06-26 16:23:43 +00:00
}
bool
TransitHop::HandlePathLatencyMessage(
const llarp::routing::PathLatencyMessage* msg, llarp_router* r)
{
llarp::routing::PathLatencyMessage reply;
reply.L = msg->T;
return SendRoutingMessage(&reply, r);
}
2018-06-26 16:23:43 +00:00
bool
TransitHop::HandlePathConfirmMessage(
const llarp::routing::PathConfirmMessage* msg, llarp_router* r)
{
llarp::LogWarn("unwarrented path confirm message on ", info);
2018-06-26 16:23:43 +00:00
return false;
}
bool
TransitHop::HandlePathTransferMessage(
const llarp::routing::PathTransferMessage* msg, llarp_router* r)
{
auto path = r->paths.GetByDownstream(r->pubkey(), msg->P);
if(path)
{
return path->HandleDownstream(msg->T.Buffer(), msg->Y, r);
}
llarp::LogWarn("No such path for path transfer pathid=", msg->P);
2018-06-26 16:23:43 +00:00
return false;
}
} // namespace path
2018-06-22 05:44:19 +00:00
} // namespace llarp