lokinet/llarp/router.hpp

382 lines
9.4 KiB
C++
Raw Normal View History

2018-02-01 17:06:49 +00:00
#ifndef LLARP_ROUTER_HPP
#define LLARP_ROUTER_HPP
#include <buffer.h>
#include <config.h>
2018-12-12 01:12:59 +00:00
#include <crypto.hpp>
2018-12-12 00:48:54 +00:00
#include <dht.h>
#include <dht.hpp>
#include <establish_job.hpp>
#include <ev.h>
2018-12-12 01:06:46 +00:00
#include <exit.hpp>
2018-12-12 01:12:59 +00:00
#include <fs.hpp>
#include <handlers/tun.hpp>
2018-12-12 01:32:10 +00:00
#include <link_layer.hpp>
#include <link_message.hpp>
#include <logic.hpp>
2018-12-12 01:12:59 +00:00
#include <mem.hpp>
#include <nodedb.hpp>
#include <path.hpp>
#include <profiling.hpp>
2018-12-12 01:55:30 +00:00
#include <router_contact.hpp>
2018-12-12 02:04:32 +00:00
#include <routing/handler.hpp>
#include <rpc.hpp>
2018-12-12 02:15:08 +00:00
#include <service.hpp>
2018-12-12 01:12:59 +00:00
#include <str.hpp>
#include <threadpool.hpp>
2018-06-01 14:08:54 +00:00
2018-02-01 17:06:49 +00:00
#include <functional>
#include <list>
2018-05-20 17:45:47 +00:00
#include <map>
#include <vector>
2018-05-30 20:56:47 +00:00
#include <unordered_map>
2018-02-01 17:06:49 +00:00
2018-06-21 13:08:21 +00:00
bool
llarp_findOrCreateEncryption(llarp::Crypto *crypto, const char *fpath,
2018-08-30 18:48:43 +00:00
llarp::SecretKey &encryption);
2018-06-21 13:08:21 +00:00
bool
llarp_findOrCreateIdentity(struct llarp::Crypto *crypto, const char *path,
byte_t *secretkey);
2018-09-06 11:46:19 +00:00
struct TryConnectJob;
namespace llarp
{
struct Router
{
bool ready;
// transient iwp encryption key
fs::path transport_keyfile = "transport.key";
2018-05-20 17:45:47 +00:00
// nodes to connect to on startup
// DEPRECATED
// std::map< std::string, fs::path > connect;
// long term identity key
fs::path ident_keyfile = "identity.key";
2018-05-30 20:56:47 +00:00
fs::path encryption_keyfile = "encryption.key";
2018-02-01 17:06:49 +00:00
// path to write our self signed rc to
fs::path our_rc_file = "rc.signed";
2018-06-01 14:08:54 +00:00
// our router contact
llarp::RouterContact _rc;
2018-09-13 12:04:36 +00:00
/// should we obey the service node whitelist?
bool whitelistRouters = false;
const llarp::RouterContact &
rc() const
{
return _rc;
}
2018-06-03 13:04:51 +00:00
// our ipv4 public setting
bool publicOverride = false;
struct sockaddr_in ip4addr;
llarp::AddressInfo addrInfo;
2018-06-03 13:04:51 +00:00
llarp_ev_loop *netloop;
llarp_threadpool *tp;
llarp::Logic *logic;
llarp::Crypto crypto;
llarp::path::PathContext paths;
llarp::exit::Context exitContext;
llarp::SecretKey identity;
llarp::SecretKey encryption;
llarp_threadpool *disk;
llarp_dht_context *dht = nullptr;
llarp_nodedb *nodedb;
// buffer for serializing link messages
byte_t linkmsg_buffer[MAX_LINK_MSG_SIZE];
/// always maintain this many connections to other routers
size_t minConnectedRouters = 1;
/// hard upperbound limit on the number of router to router connections
size_t maxConnectedRouters = 2000;
size_t minRequiredRouters = 4;
// should we be sending padded messages every interval?
bool sendPadding = false;
uint32_t ticker_job_id = 0;
2018-11-14 19:34:17 +00:00
llarp::InboundMessageParser inbound_link_msg_parser;
llarp::routing::InboundMessageParser inbound_routing_msg_parser;
llarp::service::Context hiddenServiceContext;
2018-10-09 12:06:30 +00:00
using NetConfig_t = std::unordered_multimap< std::string, std::string >;
2018-11-02 14:58:12 +00:00
/// default network config for default network interface
NetConfig_t netConfig;
/// identity keys whitelist of routers we will connect to directly (not for
/// service nodes)
std::set< llarp::RouterID > strictConnectPubkeys;
/// bootstrap RCs
std::list< llarp::RouterContact > bootstrapRCList;
bool
ExitEnabled() const
{
// TODO: use equal_range ?
auto itr = netConfig.find("exit");
if(itr == netConfig.end())
return false;
return llarp::IsTrueValue(itr->second.c_str());
}
2018-06-01 14:08:54 +00:00
bool
CreateDefaultHiddenService();
2018-05-30 20:56:47 +00:00
const std::string DefaultRPCBindAddr = "127.0.0.1:1190";
bool enableRPCServer = true;
std::unique_ptr< llarp::rpc::Server > rpcServer;
std::string rpcBindAddr = DefaultRPCBindAddr;
2018-06-14 17:35:12 +00:00
/// lokid caller
const std::string DefaultLokidRPCAddr = "127.0.0.1:22023";
std::unique_ptr< llarp::rpc::Caller > rpcCaller;
std::string lokidRPCAddr = DefaultLokidRPCAddr;
2018-11-22 15:02:51 +00:00
std::unique_ptr< llarp::ILinkLayer > outboundLink;
std::vector< std::unique_ptr< llarp::ILinkLayer > > inboundLinks;
2018-08-14 21:17:18 +00:00
llarp::Profiling routerProfiling;
std::string routerProfilesFile = "profiles.dat";
using MessageQueue = std::queue< std::vector< byte_t > >;
2018-02-01 17:06:49 +00:00
/// outbound message queue
std::unordered_map< llarp::RouterID, MessageQueue, llarp::RouterID::Hash >
outboundMessageQueue;
2018-09-04 19:15:06 +00:00
/// loki verified routers
std::unordered_map< llarp::RouterID, llarp::RouterContact,
llarp::RouterID::Hash >
validRouters;
// pending establishing session with routers
std::unordered_map< llarp::RouterID, std::unique_ptr< TryConnectJob >,
llarp::RouterID::Hash >
pendingEstablishJobs;
// pending RCs to be verified by pubkey
std::unordered_map< llarp::RouterID, llarp_async_verify_rc,
llarp::RouterID::Hash >
pendingVerifyRC;
// sessions to persist -> timestamp to end persist at
std::unordered_map< llarp::RouterID, llarp_time_t, llarp::RouterID::Hash >
m_PersistingSessions;
2018-06-10 14:05:48 +00:00
// lokinet routers from lokid, maps pubkey to when we think it will expire,
// set to max value right now
std::unordered_map< llarp::RouterID, llarp_time_t, llarp::PubKey::Hash >
lokinetRouters;
2018-11-21 14:10:02 +00:00
Router(struct llarp_threadpool *tp, struct llarp_ev_loop *netloop,
llarp::Logic *logic);
~Router();
2018-07-09 17:32:11 +00:00
void
HandleLinkSessionEstablished(llarp::RouterContact, llarp::ILinkLayer *);
2018-07-09 17:32:11 +00:00
bool
HandleRecvLinkMessageBuffer(llarp::ILinkSession *from, llarp_buffer_t msg);
void
AddInboundLink(std::unique_ptr< llarp::ILinkLayer > &link);
bool
InitOutboundLink();
2018-08-14 21:17:18 +00:00
2018-12-13 00:03:19 +00:00
bool
GetRandomGoodRouter(RouterID &r);
/// initialize us as a service node
/// return true on success
bool
InitServiceNode();
/// return true if we are running in service node mode
bool
IsServiceNode() const;
2018-06-10 14:05:48 +00:00
void
Close();
bool
LoadHiddenServiceConfig(const char *fname);
2018-02-01 17:06:49 +00:00
bool
AddHiddenService(const llarp::service::Config::section_t &config);
bool
Configure(struct llarp_config *conf);
2018-06-14 17:35:12 +00:00
bool
Ready();
2018-04-05 14:23:14 +00:00
bool
Run(struct llarp_nodedb *nodedb);
2018-09-17 11:47:34 +00:00
void
Stop();
2018-06-01 14:08:54 +00:00
void
PersistSessionUntil(const llarp::RouterID &remote, llarp_time_t until);
2018-06-06 12:46:26 +00:00
bool
EnsureIdentity();
bool
EnsureEncryptionKey();
2018-06-13 12:58:51 +00:00
bool
ConnectionToRouterAllowed(const llarp::RouterID &router) const;
2018-08-14 21:17:18 +00:00
bool
SaveRC();
2018-11-28 15:18:18 +00:00
const byte_t *
pubkey() const
{
return llarp::seckey_topublic(identity);
}
void
OnConnectTimeout(const llarp::RouterID &remote);
bool
HasPendingConnectJob(const llarp::RouterID &remote);
void
try_connect(fs::path rcfile);
2018-06-03 13:04:51 +00:00
bool
ReloadConfig(const llarp_config *conf);
2018-10-29 16:48:36 +00: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 llarp::RouterID &remote,
const llarp::ILinkMessage *msg);
2018-06-03 13:04:51 +00:00
/// sendto or drop
void
SendTo(llarp::RouterID remote, const llarp::ILinkMessage *msg,
llarp::ILinkLayer *chosen);
2018-07-03 13:33:37 +00:00
/// manually flush outbound message queue for just 1 router
void
FlushOutboundFor(llarp::RouterID remote,
llarp::ILinkLayer *chosen = nullptr);
2018-09-13 12:04:36 +00:00
/// manually discard all pending messages to remote router
void
DiscardOutboundFor(const llarp::RouterID &remote);
/// try establishing a session to a remote router
void
TryEstablishTo(const llarp::RouterID &remote);
void
HandleDHTLookupForExplore(
llarp::RouterID remote,
const std::vector< llarp::RouterContact > &results);
2018-05-30 20:56:47 +00:00
void
ForEachPeer(
std::function< void(const llarp::ILinkSession *, bool) > visit) const;
2018-08-30 18:48:43 +00:00
/// flush outbound message queue
void
FlushOutbound();
2018-09-13 12:04:36 +00:00
/// called by link when a remote session is expunged
void
SessionClosed(const llarp::RouterID &remote);
2018-08-30 18:48:43 +00:00
/// call internal router ticker
void
Tick();
2018-05-30 20:56:47 +00:00
/// get time from event loop
llarp_time_t
Now() const
{
return llarp_ev_loop_time_now_ms(netloop);
}
2018-06-03 13:04:51 +00:00
/// schedule ticker to call i ms from now
void
ScheduleTicker(uint64_t i = 1000);
2018-06-03 13:04:51 +00:00
llarp::ILinkLayer *
GetLinkWithSessionByPubkey(const llarp::RouterID &remote);
2018-11-11 13:14:19 +00:00
void
ConnectToRandomRouters(int N);
size_t
NumberOfConnectedRouters() const;
bool
GetRandomConnectedRouter(llarp::RouterContact &result) const;
void
async_verify_RC(const llarp::RouterContact &rc, llarp::ILinkLayer *link);
void
HandleDHTLookupForSendTo(
llarp::RouterID remote,
const std::vector< llarp::RouterContact > &results);
bool
HasSessionTo(const llarp::RouterID &remote) const;
void
HandleDHTLookupForTryEstablishTo(
llarp::RouterID remote,
const std::vector< llarp::RouterContact > &results);
static void
on_verify_client_rc(llarp_async_verify_rc *context);
static void
on_verify_server_rc(llarp_async_verify_rc *context);
static void
handle_router_ticker(void *user, uint64_t orig, uint64_t left);
static void
HandleAsyncLoadRCForSendTo(llarp_async_load_rc *async);
private:
template < typename Config >
void
mergeHiddenServiceConfig(const Config &in, Config &out)
{
for(const auto &item : netConfig)
out.push_back({item.first, item.second});
for(const auto &item : in)
out.push_back({item.first, item.second});
}
};
} // namespace llarp
2018-02-01 17:06:49 +00:00
#endif