lokinet/include/llarp/path.hpp

638 lines
16 KiB
C++
Raw Normal View History

2018-06-10 14:05:48 +00:00
#ifndef LLARP_PATH_HPP
#define LLARP_PATH_HPP
#include <llarp/router.h>
#include <llarp/time.h>
#include <llarp/aligned.hpp>
#include <llarp/crypto.hpp>
#include <llarp/dht.hpp>
2018-06-22 00:25:30 +00:00
#include <llarp/messages/relay.hpp>
2018-06-10 14:05:48 +00:00
#include <llarp/messages/relay_commit.hpp>
#include <llarp/path_types.hpp>
#include <llarp/pathset.hpp>
2018-08-30 18:48:43 +00:00
#include <llarp/pathbuilder.hpp>
2018-06-10 14:05:48 +00:00
#include <llarp/router_id.hpp>
#include <llarp/routing/handler.hpp>
#include <llarp/routing/message.hpp>
#include <llarp/service/Intro.hpp>
#include <llarp/threading.hpp>
2018-06-10 14:05:48 +00:00
#include <functional>
2018-06-19 17:11:24 +00:00
#include <list>
#include <map>
2018-06-10 14:05:48 +00:00
#include <unordered_map>
#include <vector>
2018-08-30 18:48:43 +00:00
#define MAXHOPS (8)
#define DEFAULT_PATH_LIFETIME (10 * 60 * 1000)
2018-10-04 16:05:07 +00:00
#define PATH_BUILD_TIMEOUT (30 * 1000)
#define MESSAGE_PAD_SIZE (512)
2018-10-04 16:48:26 +00:00
#define PATH_ALIVE_TIMEOUT (10 * 1000)
2018-08-30 18:48:43 +00:00
2018-06-10 14:05:48 +00:00
namespace llarp
{
namespace path
2018-06-10 14:05:48 +00:00
{
struct TransitHopInfo
{
TransitHopInfo() = default;
TransitHopInfo(const TransitHopInfo& other);
TransitHopInfo(const RouterID& down, const LR_CommitRecord& record);
2018-06-10 14:05:48 +00:00
PathID_t txID, rxID;
RouterID upstream;
RouterID downstream;
2018-06-10 14:05:48 +00:00
friend std::ostream&
operator<<(std::ostream& out, const TransitHopInfo& info)
{
out << "<tx=" << info.txID << " rx=" << info.rxID;
out << " upstream=" << info.upstream
<< " downstream=" << info.downstream;
return out << ">";
}
2018-06-10 14:05:48 +00:00
bool
operator==(const TransitHopInfo& other) const
{
return txID == other.txID && rxID == other.rxID
&& upstream == other.upstream && downstream == other.downstream;
}
2018-06-10 14:05:48 +00:00
bool
operator!=(const TransitHopInfo& other) const
{
return !(*this == other);
}
2018-06-10 14:05:48 +00:00
bool
operator<(const TransitHopInfo& other) const
{
return txID < other.txID || rxID < other.rxID
|| upstream < other.upstream || downstream < other.downstream;
}
struct Hash
{
std::size_t
operator()(TransitHopInfo const& a) const
{
std::size_t idx0, idx1, idx2, idx3;
memcpy(&idx0, a.upstream, sizeof(std::size_t));
memcpy(&idx1, a.downstream, sizeof(std::size_t));
memcpy(&idx2, a.txID, sizeof(std::size_t));
memcpy(&idx3, a.rxID, sizeof(std::size_t));
return idx0 ^ idx1 ^ idx2;
}
};
};
2018-06-18 22:03:50 +00:00
struct PathIDHash
2018-06-10 14:05:48 +00:00
{
std::size_t
operator()(const PathID_t& a) const
2018-06-10 14:05:48 +00:00
{
std::size_t idx0;
memcpy(&idx0, a, sizeof(std::size_t));
return idx0;
2018-06-10 14:05:48 +00:00
}
};
struct IHopHandler
2018-06-18 22:03:50 +00:00
{
virtual ~IHopHandler(){};
2018-06-18 22:03:50 +00:00
virtual bool
Expired(llarp_time_t now) const = 0;
2018-11-14 18:02:27 +00:00
virtual bool
ExpiresSoon(llarp_time_t now, llarp_time_t dlt) const = 0;
/// send routing message and increment sequence number
virtual bool
SendRoutingMessage(const llarp::routing::IMessage* msg,
llarp_router* r) = 0;
2018-06-22 00:25:30 +00:00
// handle data in upstream direction
virtual bool
HandleUpstream(llarp_buffer_t X, const TunnelNonce& Y,
llarp_router* r) = 0;
2018-06-22 00:25:30 +00:00
// handle data in downstream direction
virtual bool
HandleDownstream(llarp_buffer_t X, const TunnelNonce& Y,
2018-06-22 00:25:30 +00:00
llarp_router* r) = 0;
uint64_t
NextSeqNo()
{
return m_SequenceNum++;
}
protected:
uint64_t m_SequenceNum = 0;
};
2018-06-22 00:25:30 +00:00
2018-06-26 16:23:43 +00:00
struct TransitHop : public IHopHandler,
public llarp::routing::IMessageHandler
{
2018-06-26 16:23:43 +00:00
TransitHop();
2018-06-22 00:25:30 +00:00
TransitHop(const TransitHop& other);
2018-06-22 00:25:30 +00:00
TransitHopInfo info;
SharedSecret pathKey;
ShortHash nonceXOR;
llarp_time_t started = 0;
// 10 minutes default
llarp_time_t lifetime = DEFAULT_PATH_LIFETIME;
llarp_proto_version_t version;
2018-10-03 10:41:36 +00:00
bool
IsEndpoint(const RouterID& us) const
{
return info.upstream == us;
}
2018-10-03 10:41:36 +00:00
2018-08-22 16:19:51 +00:00
llarp_time_t
ExpireTime() const;
2018-06-26 16:23:43 +00:00
llarp::routing::InboundMessageParser m_MessageParser;
friend std::ostream&
operator<<(std::ostream& out, const TransitHop& h)
{
return out << "[TransitHop " << h.info << " started=" << h.started
<< " lifetime=" << h.lifetime << "]";
}
bool
2018-11-14 18:02:27 +00:00
Expired(llarp_time_t now) const override;
bool
ExpiresSoon(llarp_time_t now, llarp_time_t dlt) const override
{
return now >= ExpireTime() - dlt;
}
2018-06-12 16:45:12 +00:00
2018-06-26 16:23:43 +00:00
// send routing message when end of path
bool
SendRoutingMessage(const llarp::routing::IMessage* msg, llarp_router* r);
2018-06-22 00:25:30 +00:00
2018-06-26 16:23:43 +00:00
// handle routing message when end of path
bool
HandleRoutingMessage(const llarp::routing::IMessage* msg,
llarp_router* r);
bool
HandleDataDiscardMessage(const llarp::routing::DataDiscardMessage* msg,
llarp_router* r);
2018-06-26 16:23:43 +00:00
bool
HandlePathConfirmMessage(const llarp::routing::PathConfirmMessage* msg,
llarp_router* r);
bool
HandlePathTransferMessage(const llarp::routing::PathTransferMessage* msg,
llarp_router* r);
bool
HandlePathLatencyMessage(const llarp::routing::PathLatencyMessage* msg,
llarp_router* r);
bool
HandleObtainExitMessage(const llarp::routing::ObtainExitMessage* msg,
llarp_router* r);
2018-11-14 12:23:08 +00:00
bool
HandleUpdateExitVerifyMessage(
const llarp::routing::UpdateExitVerifyMessage* msg, llarp_router* r);
bool
HandleTransferTrafficMessage(
const llarp::routing::TransferTrafficMessage* msg, llarp_router* r);
bool
HandleUpdateExitMessage(const llarp::routing::UpdateExitMessage* msg,
llarp_router* r);
bool
HandleGrantExitMessage(const llarp::routing::GrantExitMessage* msg,
llarp_router* r);
bool
HandleRejectExitMessage(const llarp::routing::RejectExitMessage* msg,
llarp_router* r);
bool
HandleCloseExitMessage(const llarp::routing::CloseExitMessage* msg,
llarp_router* r);
bool
HandleHiddenServiceFrame(__attribute__((unused))
const llarp::service::ProtocolFrame* frame)
{
/// TODO: implement me
llarp::LogWarn("Got hidden service data on transit hop");
return false;
}
2018-07-09 17:32:11 +00:00
bool
HandleGotIntroMessage(const llarp::dht::GotIntroMessage* msg);
2018-06-26 16:23:43 +00:00
bool
HandleDHTMessage(const llarp::dht::IMessage* msg, llarp_router* r);
// handle data in upstream direction
bool
HandleUpstream(llarp_buffer_t X, const TunnelNonce& Y, llarp_router* r);
2018-06-18 22:03:50 +00:00
// handle data in downstream direction
bool
HandleDownstream(llarp_buffer_t X, const TunnelNonce& Y, llarp_router* r);
};
/// configuration for a single hop when building a path
struct PathHopConfig
2018-06-22 00:25:30 +00:00
{
/// path id
PathID_t txID, rxID;
// router contact of router
2018-08-30 18:48:43 +00:00
RouterContact rc;
// temp public encryption key
SecretKey commkey;
/// shared secret at this hop
SharedSecret shared;
/// hash of shared secret used for nonce mutation
ShortHash nonceXOR;
/// next hop's router id
RouterID upstream;
/// nonce for key exchange
TunnelNonce nonce;
// lifetime
llarp_time_t lifetime = DEFAULT_PATH_LIFETIME;
~PathHopConfig();
PathHopConfig();
};
2018-06-22 00:25:30 +00:00
/// A path we made
struct Path : public IHopHandler, public llarp::routing::IMessageHandler
{
typedef std::function< void(Path*) > BuildResultHookFunc;
typedef std::function< bool(Path*, llarp_time_t) > CheckForDeadFunc;
typedef std::function< bool(Path*, const PathID_t&, uint64_t) >
DropHandlerFunc;
typedef std::vector< PathHopConfig > HopList;
typedef std::function< bool(Path*, const service::ProtocolFrame*) >
DataHandlerFunc;
2018-11-14 12:23:08 +00:00
typedef std::function< bool(Path*) > ExitUpdatedFunc;
typedef std::function< bool(Path*) > ExitClosedFunc;
2018-11-14 18:02:27 +00:00
typedef std::function< bool(Path*, llarp_buffer_t) >
ExitTrafficHandlerFunc;
/// (path, backoff) backoff is 0 on success
typedef std::function< bool(Path*, llarp_time_t) > ObtainedExitHandler;
HopList hops;
PathSet* m_PathSet;
llarp::service::Introduction intro;
llarp_time_t buildStarted;
2018-06-19 17:11:24 +00:00
2018-11-14 18:02:27 +00:00
Path(const std::vector< RouterContact >& routers, PathSet* parent,
PathRole startingRoles);
PathRole
Role() const
{
return _role;
}
2018-11-16 14:22:13 +00:00
void
2018-11-16 14:21:23 +00:00
MarkActive(llarp_time_t now)
{
2018-11-16 14:21:52 +00:00
m_LastRecvMessage = now;
2018-11-16 14:21:23 +00:00
}
2018-11-14 18:02:27 +00:00
bool
SupportsRoles(PathRole roles) const
{
return (_role & roles) == roles;
}
PathStatus
Status() const
{
return _status;
}
2018-06-19 17:11:24 +00:00
void
SetBuildResultHook(BuildResultHookFunc func);
2018-06-22 00:25:30 +00:00
2018-11-14 18:02:27 +00:00
void
SetExitTrafficHandler(ExitTrafficHandlerFunc handler)
{
m_ExitTrafficHandler = handler;
}
2018-11-14 12:23:08 +00:00
void
SetCloseExitFunc(ExitClosedFunc handler)
{
m_ExitClosed = handler;
}
void
SetUpdateExitFunc(ExitUpdatedFunc handler)
{
m_ExitUpdated = handler;
}
void
SetDataHandler(DataHandlerFunc func)
{
m_DataHandler = func;
}
void
SetDropHandler(DropHandlerFunc func)
{
m_DropHandler = func;
}
void
SetDeadChecker(CheckForDeadFunc func)
{
m_CheckForDead = func;
}
void
2018-10-29 16:48:36 +00:00
EnterState(PathStatus st, llarp_time_t now);
2018-08-14 21:17:18 +00:00
llarp_time_t
ExpireTime() const
{
return buildStarted + hops[0].lifetime;
}
2018-11-14 18:02:27 +00:00
bool
ExpiresSoon(llarp_time_t now, llarp_time_t dlt = 5000) const
{
return now >= (ExpireTime() - dlt);
}
bool
Expired(llarp_time_t now) const;
2018-06-10 14:05:48 +00:00
void
Tick(llarp_time_t now, llarp_router* r);
bool
SendRoutingMessage(const llarp::routing::IMessage* msg, llarp_router* r);
bool
HandleObtainExitMessage(const llarp::routing::ObtainExitMessage* msg,
llarp_router* r);
2018-11-14 12:23:08 +00:00
bool
HandleUpdateExitVerifyMessage(
const llarp::routing::UpdateExitVerifyMessage* msg, llarp_router* r);
bool
HandleTransferTrafficMessage(
const llarp::routing::TransferTrafficMessage* msg, llarp_router* r);
bool
HandleUpdateExitMessage(const llarp::routing::UpdateExitMessage* msg,
llarp_router* r);
bool
HandleCloseExitMessage(const llarp::routing::CloseExitMessage* msg,
llarp_router* r);
bool
HandleRejectExitMessagge(const llarp::routing::RejectExitMessage* msg,
llarp_router* r);
bool
HandleGrantExitMessage(const llarp::routing::GrantExitMessage* msg,
llarp_router* r);
bool
HandleRejectExitMessage(const llarp::routing::RejectExitMessage* msg,
llarp_router* r);
2018-06-19 17:11:24 +00:00
bool
HandleDataDiscardMessage(const llarp::routing::DataDiscardMessage* msg,
llarp_router* r);
bool
2018-06-26 16:23:43 +00:00
HandlePathConfirmMessage(const llarp::routing::PathConfirmMessage* msg,
llarp_router* r);
2018-06-19 17:11:24 +00:00
bool
2018-06-26 16:23:43 +00:00
HandlePathLatencyMessage(const llarp::routing::PathLatencyMessage* msg,
llarp_router* r);
2018-06-19 17:11:24 +00:00
bool
2018-06-26 16:23:43 +00:00
HandlePathTransferMessage(const llarp::routing::PathTransferMessage* msg,
llarp_router* r);
bool
HandleHiddenServiceFrame(const llarp::service::ProtocolFrame* frame);
2018-07-09 17:32:11 +00:00
bool
HandleGotIntroMessage(const llarp::dht::GotIntroMessage* msg);
2018-06-26 16:23:43 +00:00
bool
HandleDHTMessage(const llarp::dht::IMessage* msg, llarp_router* r);
2018-06-22 00:25:30 +00:00
bool
HandleRoutingMessage(llarp_buffer_t buf, llarp_router* r);
2018-06-22 00:25:30 +00:00
// handle data in upstream direction
bool
HandleUpstream(llarp_buffer_t X, const TunnelNonce& Y, llarp_router* r);
2018-06-22 00:25:30 +00:00
// handle data in downstream direction
bool
HandleDownstream(llarp_buffer_t X, const TunnelNonce& Y, llarp_router* r);
2018-06-19 17:11:24 +00:00
bool
IsReady() const;
// Is this deprecated?
// nope not deprecated :^DDDD
const PathID_t&
TXID() const;
RouterID
Endpoint() const;
bool
IsEndpoint(const RouterID& router, const PathID_t& path) const;
const PathID_t&
RXID() const;
2018-06-19 17:11:24 +00:00
RouterID
Upstream() const;
std::string
Name() const;
2018-11-14 19:34:17 +00:00
void
AddObtainExitHandler(ObtainedExitHandler handler)
{
m_ObtainedExitHooks.push_back(handler);
}
2018-11-14 18:02:27 +00:00
bool
2018-11-14 19:34:17 +00:00
SendExitRequest(const llarp::routing::ObtainExitMessage* msg,
llarp_router* r);
2018-11-14 18:02:27 +00:00
protected:
llarp::routing::InboundMessageParser m_InboundMessageParser;
2018-06-10 14:05:48 +00:00
private:
2018-11-14 18:02:27 +00:00
/// call obtained exit hooks
bool
InformExitResult(llarp_time_t b);
BuildResultHookFunc m_BuiltHook;
DataHandlerFunc m_DataHandler;
DropHandlerFunc m_DropHandler;
CheckForDeadFunc m_CheckForDead;
2018-11-14 12:23:08 +00:00
ExitUpdatedFunc m_ExitUpdated;
ExitClosedFunc m_ExitClosed;
2018-11-14 18:02:27 +00:00
ExitTrafficHandlerFunc m_ExitTrafficHandler;
std::vector< ObtainedExitHandler > m_ObtainedExitHooks;
llarp_time_t m_LastRecvMessage = 0;
2018-06-26 16:23:43 +00:00
llarp_time_t m_LastLatencyTestTime = 0;
uint64_t m_LastLatencyTestID = 0;
2018-11-14 12:23:08 +00:00
uint64_t m_UpdateExitTX = 0;
uint64_t m_CloseExitTX = 0;
2018-11-14 18:02:27 +00:00
uint64_t m_ExitObtainTX = 0;
PathStatus _status;
PathRole _role;
};
2018-06-10 14:05:48 +00:00
enum PathBuildStatus
{
ePathBuildSuccess,
ePathBuildTimeout,
ePathBuildReject
};
struct PathContext
{
PathContext(llarp_router* router);
~PathContext();
2018-06-10 14:05:48 +00:00
/// called from router tick function
void
2018-10-29 16:48:36 +00:00
ExpirePaths(llarp_time_t now);
2018-06-18 22:03:50 +00:00
/// called from router tick function
/// builds all paths we need to build at current tick
void
2018-10-29 16:48:36 +00:00
BuildPaths(llarp_time_t now);
2018-06-10 14:05:48 +00:00
/// called from router tick function
void
2018-10-29 16:48:36 +00:00
TickPaths(llarp_time_t now);
/// track a path builder with this context
void
2018-08-30 18:48:43 +00:00
AddPathBuilder(Builder* set);
2018-06-10 14:05:48 +00:00
void
AllowTransit();
void
RejectTransit();
2018-06-10 14:05:48 +00:00
bool
AllowingTransit() const;
2018-06-10 14:05:48 +00:00
bool
HasTransitHop(const TransitHopInfo& info);
2018-06-22 00:25:30 +00:00
bool
HandleRelayCommit(const LR_CommitMessage* msg);
2018-06-22 00:25:30 +00:00
void
2018-10-21 13:07:33 +00:00
PutTransitHop(std::shared_ptr< TransitHop > hop);
2018-06-12 16:45:12 +00:00
IHopHandler*
GetByUpstream(const RouterID& id, const PathID_t& path);
2018-06-12 16:45:12 +00:00
2018-10-06 16:37:54 +00:00
IHopHandler*
2018-10-09 17:09:45 +00:00
GetPathForTransfer(const PathID_t& topath);
IHopHandler*
GetByDownstream(const RouterID& id, const PathID_t& path);
2018-06-12 16:45:12 +00:00
2018-07-09 17:32:11 +00:00
PathSet*
GetLocalPathSet(const PathID_t& id);
2018-08-10 21:34:11 +00:00
routing::IMessageHandler*
GetHandler(const PathID_t& id);
bool
ForwardLRCM(const RouterID& nextHop,
2018-08-30 18:48:43 +00:00
const std::array< EncryptedFrame, 8 >& frames);
2018-06-22 00:25:30 +00:00
bool
HopIsUs(const PubKey& k) const;
2018-06-22 00:25:30 +00:00
bool
HandleLRUM(const RelayUpstreamMessage* msg);
2018-06-19 17:11:24 +00:00
bool
HandleLRDM(const RelayDownstreamMessage* msg);
2018-06-10 14:05:48 +00:00
void
AddOwnPath(PathSet* set, Path* p);
2018-06-12 16:45:12 +00:00
2018-08-18 14:01:21 +00:00
void
2018-08-30 18:48:43 +00:00
RemovePathBuilder(Builder* ctx);
2018-08-18 14:01:21 +00:00
void
RemovePathSet(PathSet* set);
2018-10-21 13:07:33 +00:00
typedef std::multimap< PathID_t, std::shared_ptr< TransitHop > >
TransitHopsMap_t;
2018-06-19 17:11:24 +00:00
2018-08-12 17:22:29 +00:00
typedef std::pair< util::Mutex, TransitHopsMap_t > SyncTransitMap_t;
2018-06-19 17:11:24 +00:00
// maps path id -> pathset owner of path
typedef std::map< PathID_t, PathSet* > OwnedPathsMap_t;
2018-06-12 16:45:12 +00:00
2018-08-12 17:22:29 +00:00
typedef std::pair< util::Mutex, OwnedPathsMap_t > SyncOwnedPathsMap_t;
2018-06-12 16:45:12 +00:00
llarp_threadpool*
Worker();
llarp_crypto*
Crypto();
2018-06-22 00:25:30 +00:00
llarp_logic*
Logic();
2018-06-12 16:45:12 +00:00
llarp_router*
Router();
2018-06-18 22:03:50 +00:00
byte_t*
EncryptionSecretKey();
2018-06-12 16:45:12 +00:00
const byte_t*
OurRouterID() const;
private:
llarp_router* m_Router;
SyncTransitMap_t m_TransitPaths;
SyncTransitMap_t m_Paths;
SyncOwnedPathsMap_t m_OurPaths;
2018-08-30 18:48:43 +00:00
std::list< Builder* > m_PathBuilders;
bool m_AllowTransit;
};
} // namespace path
2018-06-18 22:03:50 +00:00
} // namespace llarp
2018-06-10 14:05:48 +00:00
2018-06-14 20:13:07 +00:00
#endif