1
1
Fork 0
mirror of https://github.com/oxen-io/lokinet synced 2023-12-14 06:53:00 +01:00
lokinet/llarp/router/router.hpp

544 lines
12 KiB
C++
Raw Normal View History

2018-02-01 18:06:49 +01:00
#ifndef LLARP_ROUTER_HPP
#define LLARP_ROUTER_HPP
#include <router/abstractrouter.hpp>
#include <bootstrap.hpp>
2020-04-27 17:24:05 +02:00
#include <config/config.hpp>
#include <config/key_manager.hpp>
#include <constants/link_layer.hpp>
#include <crypto/types.hpp>
2019-01-11 02:19:36 +01:00
#include <ev/ev.h>
#include <exit/context.hpp>
2018-12-12 02:12:59 +01:00
#include <handlers/tun.hpp>
2019-09-01 15:26:16 +02:00
#include <link/link_manager.hpp>
2019-05-15 17:56:50 +02:00
#include <link/server.hpp>
#include <messages/link_message_parser.hpp>
#include <nodedb.hpp>
2019-06-18 01:19:39 +02:00
#include <path/path_context.hpp>
2020-05-26 19:03:21 +02:00
#include <peerstats/peer_db.hpp>
#include <profiling.hpp>
2018-12-12 02:55:30 +01:00
#include <router_contact.hpp>
2019-09-01 15:26:16 +02:00
#include <router/outbound_message_handler.hpp>
#include <router/outbound_session_maker.hpp>
2020-01-30 18:23:16 +01:00
#include <router/rc_gossiper.hpp>
2019-09-01 15:26:16 +02:00
#include <router/rc_lookup_handler.hpp>
2018-12-12 03:04:32 +01:00
#include <routing/handler.hpp>
#include <routing/message_parser.hpp>
2020-05-18 18:06:52 +02:00
#include <rpc/lokid_rpc_client.hpp>
2020-05-21 16:09:45 +02:00
#include <rpc/rpc_server.hpp>
#include <service/context.hpp>
2020-04-27 17:24:05 +02:00
#include <stdexcept>
2019-02-03 00:12:42 +01:00
#include <util/buffer.hpp>
#include <util/fs.hpp>
#include <util/mem.hpp>
2019-02-08 20:43:25 +01:00
#include <util/status.hpp>
#include <util/str.hpp>
2019-09-01 15:26:16 +02:00
#include <util/thread/logic.hpp>
2019-11-05 18:10:14 +01:00
#include <util/time.hpp>
2018-06-01 16:08:54 +02:00
2018-02-01 18:06:49 +01:00
#include <functional>
#include <list>
2018-05-20 19:45:47 +02:00
#include <map>
#include <memory>
2019-01-05 14:45:05 +01:00
#include <set>
#include <unordered_map>
#include <vector>
2018-02-01 18:06:49 +01:00
#include <lokimq/address.h>
namespace llarp
{
struct Router final : public AbstractRouter
{
// XXX / TODO: this code shouldn't ever make it into a release binary
virtual void
stopGossipingRC()
{
m_shouldGossipRC = false;
}
bool m_shouldGossipRC = true;
2020-02-24 20:40:45 +01:00
llarp_time_t _lastPump = 0s;
bool ready;
// transient iwp encryption key
fs::path transport_keyfile;
// long term identity key
fs::path ident_keyfile;
2018-05-30 22:56:47 +02:00
fs::path encryption_keyfile;
2018-02-01 18:06:49 +01:00
// path to write our self signed rc to
fs::path our_rc_file;
2018-06-01 16:08:54 +02:00
// use file based logging?
bool m_UseFileLogging = false;
// our router contact
RouterContact _rc;
2018-09-13 14:04:36 +02:00
2019-01-21 18:06:31 +01:00
/// are we using the lokid service node seed ?
bool usingSNSeed = false;
/// should we obey the service node whitelist?
bool whitelistRouters = false;
2020-05-19 20:53:03 +02:00
LMQ_ptr m_lmq;
LMQ_ptr
lmq() const override
{
return m_lmq;
}
2020-05-20 13:41:42 +02:00
std::shared_ptr<rpc::LokidRpcClient>
RpcClient() const override
{
return m_lokidRpcClient;
}
std::shared_ptr<Logic>
logic() const override
{
return _logic;
}
llarp_dht_context*
dht() const override
{
return _dht;
}
2019-02-11 18:14:43 +01:00
util::StatusObject
ExtractStatus() const override;
2019-02-08 20:43:25 +01:00
llarp_nodedb*
nodedb() const override
{
return _nodedb;
}
const path::PathContext&
pathContext() const override
{
return paths;
}
path::PathContext&
pathContext() override
{
return paths;
}
const RouterContact&
rc() const override
{
return _rc;
}
2018-06-03 15:04:51 +02:00
void
2020-05-19 20:53:03 +02:00
SetRouterWhitelist(const std::vector<RouterID> routers) override;
exit::Context&
exitContext() override
{
return _exitContext;
}
std::shared_ptr<KeyManager>
2019-12-10 15:14:16 +01:00
keyManager() const override
{
return m_keyManager;
}
const SecretKey&
identity() const override
{
return _identity;
}
const SecretKey&
encryption() const override
{
return _encryption;
}
Profiling&
routerProfiling() override
{
return _routerProfiling;
}
2019-04-08 14:01:52 +02:00
llarp_ev_loop_ptr
netloop() const override
{
return _netloop;
}
void
QueueWork(std::function<void(void)> func) override
{
m_lmq->job(std::move(func));
}
void
QueueDiskIO(std::function<void(void)> func) override
{
m_lmq->job(std::move(func), m_DiskThread);
}
2020-05-06 22:38:44 +02:00
IpAddress _ourAddress;
2018-06-03 15:04:51 +02:00
2019-04-08 14:01:52 +02:00
llarp_ev_loop_ptr _netloop;
std::shared_ptr<Logic> _logic;
path::PathContext paths;
exit::Context _exitContext;
SecretKey _identity;
SecretKey _encryption;
llarp_dht_context* _dht = nullptr;
llarp_nodedb* _nodedb;
llarp_time_t _startedAt;
const lokimq::TaggedThreadID m_DiskThread;
llarp_time_t
Uptime() const override;
bool
Sign(Signature& sig, const llarp_buffer_t& buf) const override;
uint16_t m_OutboundPort = 0;
2019-03-31 17:09:59 +02:00
/// how often do we resign our RC? milliseconds.
// TODO: make configurable
2020-02-24 20:40:45 +01:00
llarp_time_t rcRegenInterval = 1h;
// should we be sending padded messages every interval?
bool sendPadding = false;
uint32_t ticker_job_id = 0;
2018-11-14 20:34:17 +01:00
LinkMessageParser inbound_link_msg_parser;
routing::InboundMessageParser inbound_routing_msg_parser;
2019-02-22 17:21:05 +01:00
service::Context _hiddenServiceContext;
service::Context&
2019-02-22 17:21:05 +01:00
hiddenServiceContext() override
{
return _hiddenServiceContext;
}
const service::Context&
2019-02-22 17:21:05 +01:00
hiddenServiceContext() const override
{
return _hiddenServiceContext;
}
2018-10-09 14:06:30 +02:00
2020-02-24 20:40:45 +01:00
llarp_time_t _lastTick = 0s;
bool
LooksAlive() const override
{
const llarp_time_t now = Now();
return now <= _lastTick || (now - _lastTick) <= llarp_time_t{30000};
}
/// bootstrap RCs
BootstrapList bootstrapRCList;
bool
ExitEnabled() const
{
2020-05-06 17:37:15 +02:00
return false; // FIXME - have to fix the FIXME because FIXME
2020-04-27 17:24:05 +02:00
throw std::runtime_error("FIXME: this needs to be derived from config");
/*
// TODO: use equal_range ?
auto itr = netConfig.find("exit");
if (itr == netConfig.end())
return false;
return IsTrueValue(itr->second.c_str());
2020-04-27 17:24:05 +02:00
*/
}
2018-06-01 16:08:54 +02:00
2019-04-30 18:07:17 +02:00
void
PumpLL() override;
2020-04-27 17:24:05 +02:00
NetworkConfig networkConfig;
DnsConfig dnsConfig;
2018-05-30 22:56:47 +02:00
const lokimq::address DefaultRPCBindAddr = lokimq::address::tcp("127.0.0.1", 1190);
bool enableRPCServer = false;
lokimq::address rpcBindAddr = DefaultRPCBindAddr;
2020-05-21 16:09:45 +02:00
std::unique_ptr<rpc::RpcServer> m_RPCServer;
const llarp_time_t _randomStartDelay;
2018-06-14 19:35:12 +02:00
2020-05-20 13:41:42 +02:00
std::shared_ptr<rpc::LokidRpcClient> m_lokidRpcClient;
2020-05-19 20:53:03 +02:00
lokimq::address lokidRPCAddr;
2018-11-22 16:02:51 +01:00
Profiling _routerProfiling;
std::string routerProfilesFile = "profiles.dat";
OutboundMessageHandler _outboundMessageHandler;
OutboundSessionMaker _outboundSessionMaker;
LinkManager _linkManager;
RCLookupHandler _rcLookupHandler;
2020-01-30 18:23:16 +01:00
RCGossiper _rcGossiper;
2018-02-01 18:06:49 +01:00
using Clock_t = std::chrono::steady_clock;
2020-01-18 21:46:22 +01:00
using TimePoint_t = Clock_t::time_point;
TimePoint_t m_NextExploreAt;
IOutboundMessageHandler&
outboundMessageHandler() override
{
return _outboundMessageHandler;
}
IOutboundSessionMaker&
outboundSessionMaker() override
{
return _outboundSessionMaker;
}
ILinkManager&
linkManager() override
{
return _linkManager;
}
2018-06-10 16:05:48 +02:00
I_RCLookupHandler&
rcLookupHandler() override
{
return _rcLookupHandler;
}
2018-11-21 15:10:02 +01:00
2020-05-27 03:57:27 +02:00
std::shared_ptr<PeerDb>
peerDb() override
{
return m_peerDb;
}
2020-01-30 18:23:16 +01:00
void
GossipRCIfNeeded(const RouterContact rc) override;
explicit Router(llarp_ev_loop_ptr __netloop, std::shared_ptr<Logic> logic);
2019-07-31 01:42:13 +02:00
~Router() override;
2018-07-09 19:32:11 +02:00
bool
HandleRecvLinkMessageBuffer(ILinkSession* from, const llarp_buffer_t& msg) override;
bool
2019-01-05 14:45:05 +01:00
InitOutboundLinks();
2018-08-14 23:17:18 +02:00
2018-12-13 01:03:19 +01:00
bool
GetRandomGoodRouter(RouterID& r) override;
2018-12-13 01:03:19 +01:00
/// initialize us as a service node
/// return true on success
bool
InitServiceNode();
bool
IsRunning() const override;
/// return true if we are running in service node mode
bool
2020-01-07 00:13:23 +01:00
IsServiceNode() const override;
2018-06-10 16:05:48 +02:00
void
Close();
bool
Configure(Config* conf, bool isRouter, llarp_nodedb* nodedb = nullptr) override;
2018-04-05 16:23:14 +02:00
bool
2020-05-20 13:41:42 +02:00
StartRpcServer() override;
bool
Run() override;
2018-09-17 13:47:34 +02:00
/// stop running the router logic gracefully
void
2019-02-22 17:21:05 +01:00
Stop() override;
2018-06-01 16:08:54 +02:00
/// non graceful stop router
void
Die() override;
/// close all sessions and shutdown all links
void
StopLinks();
void
PersistSessionUntil(const RouterID& remote, llarp_time_t until) override;
2018-06-06 14:46:26 +02:00
bool
EnsureIdentity();
bool
EnsureEncryptionKey();
2018-06-13 14:58:51 +02:00
bool
ConnectionToRouterAllowed(const RouterID& router) const override;
2018-08-14 23:17:18 +02:00
void
HandleSaveRC() const;
bool
SaveRC();
2018-11-28 16:18:18 +01:00
const byte_t*
pubkey() const override
{
return seckey_topublic(_identity);
}
void
try_connect(fs::path rcfile);
2018-06-03 15:04:51 +02:00
/// inject configuration and reconfigure router
bool
Reconfigure(Config* conf) override;
bool
TryConnectAsync(RouterContact rc, uint16_t tries) override;
/// validate new configuration against old one
/// return true on 100% valid
/// return false if not 100% valid
bool
ValidateConfig(Config* conf) const override;
2018-10-29 17:48:36 +01:00
/// send to remote router or queue for sending
/// returns false on overflow
/// returns true on successful queue
/// NOT threadsafe
/// MUST be called in the logic thread
bool
SendToOrQueue(
const RouterID& remote, const ILinkMessage* msg, SendStatusHandler handler) override;
2018-06-03 15:04:51 +02:00
void
ForEachPeer(std::function<void(const ILinkSession*, bool)> visit, bool randomize = false)
const override;
2018-08-30 20:48:43 +02:00
void
ForEachPeer(std::function<void(ILinkSession*)> visit);
2019-04-08 14:01:52 +02:00
bool IsBootstrapNode(RouterID) const override;
/// check if newRc matches oldRC and update local rc for this remote contact
/// if valid
/// returns true on valid and updated
/// returns false otherwise
bool
CheckRenegotiateValid(RouterContact newRc, RouterContact oldRC) override;
/// called by link when a remote session has no more sessions open
void
SessionClosed(RouterID remote) override;
2018-08-30 20:48:43 +02:00
/// called by link when an unestablished connection times out
void
ConnectionTimedOut(ILinkSession* session);
/// called by link when session is fully established
bool
2020-06-11 21:02:34 +02:00
ConnectionEstablished(ILinkSession* session, bool inbound);
/// call internal router ticker
void
Tick();
2018-05-30 22:56:47 +02:00
llarp_time_t
Now() const override
{
2019-11-05 18:10:14 +01:00
return llarp::time_now_ms();
}
2018-06-03 15:04:51 +02:00
/// schedule ticker to call i ms from now
void
2020-02-24 20:40:45 +01:00
ScheduleTicker(llarp_time_t i = 1s);
2018-06-03 15:04:51 +02:00
/// parse a routing message in a buffer and handle it with a handler if
/// successful parsing return true on parse and handle success otherwise
/// return false
bool
ParseRoutingMessageBuffer(
const llarp_buffer_t& buf, routing::IMessageHandler* h, const PathID_t& rxid) override;
void
ConnectToRandomRouters(int N) override;
2019-05-09 17:36:39 +02:00
/// count the number of unique service nodes connected via pubkey
size_t
NumberOfConnectedRouters() const override;
2019-05-09 17:36:39 +02:00
/// count the number of unique clients connected by pubkey
size_t
NumberOfConnectedClients() const override;
bool
GetRandomConnectedRouter(RouterContact& result) const override;
void
HandleDHTLookupForExplore(RouterID remote, const std::vector<RouterContact>& results) override;
void
LookupRouter(RouterID remote, RouterLookupHandler resultHandler) override;
bool
HasSessionTo(const RouterID& remote) const override;
std::string
ShortName() const override;
uint32_t
NextPathBuildNumber() override;
void
handle_router_ticker();
void
AfterStopLinks();
void
AfterStopIssued();
private:
std::atomic<bool> _stopping;
std::atomic<bool> _running;
bool m_isServiceNode = false;
2020-02-24 20:40:45 +01:00
llarp_time_t m_LastStatsReport = 0s;
2019-07-15 18:56:09 +02:00
std::shared_ptr<llarp::KeyManager> m_keyManager;
2020-05-27 03:57:27 +02:00
std::shared_ptr<PeerDb> m_peerDb;
uint32_t path_build_count = 0;
2019-07-15 18:56:09 +02:00
bool
ShouldReportStats(llarp_time_t now) const;
void
ReportStats();
bool
2019-01-29 13:56:02 +01:00
UpdateOurRC(bool rotateKeys = false);
2019-07-12 19:21:29 +02:00
bool
FromConfig(Config* conf);
void
MessageSent(const RouterID& remote, SendStatus status);
};
} // namespace llarp
2018-02-01 18:06:49 +01:00
#endif