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

398 lines
9.8 KiB
C++
Raw Normal View History

2018-02-01 18:06:49 +01:00
#ifndef LLARP_ROUTER_HPP
#define LLARP_ROUTER_HPP
#include <buffer.h>
#include <config.h>
2018-12-12 02:12:59 +01:00
#include <crypto.hpp>
2018-12-12 01:48:54 +01:00
#include <dht.h>
#include <dht.hpp>
#include <establish_job.hpp>
#include <ev.h>
2018-12-12 02:06:46 +01:00
#include <exit.hpp>
2018-12-12 02:12:59 +01:00
#include <fs.hpp>
#include <handlers/tun.hpp>
2018-12-12 02:32:10 +01:00
#include <link_layer.hpp>
#include <link_message.hpp>
#include <logic.hpp>
2018-12-12 02:12:59 +01:00
#include <mem.hpp>
#include <nodedb.hpp>
#include <path.hpp>
#include <profiling.hpp>
2018-12-12 02:55:30 +01:00
#include <router_contact.hpp>
2018-12-12 03:04:32 +01:00
#include <routing/handler.hpp>
#include <rpc.hpp>
2018-12-12 03:15:08 +01:00
#include <service.hpp>
2018-12-12 02:12:59 +01:00
#include <str.hpp>
#include <threadpool.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 <vector>
2018-05-30 22:56:47 +02:00
#include <unordered_map>
2018-02-01 18:06:49 +01:00
2018-06-21 15:08:21 +02:00
bool
llarp_findOrCreateEncryption(llarp::Crypto *crypto, const char *fpath,
2018-08-30 20:48:43 +02:00
llarp::SecretKey &encryption);
2018-06-21 15:08:21 +02:00
bool
llarp_findOrCreateIdentity(struct llarp::Crypto *crypto, const char *path,
byte_t *secretkey);
2018-09-06 13:46:19 +02:00
struct TryConnectJob;
namespace llarp
{
struct Router
{
bool ready;
// transient iwp encryption key
fs::path transport_keyfile = "transport.key";
2018-05-20 19:45:47 +02: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 22:56:47 +02:00
fs::path encryption_keyfile = "encryption.key";
2018-02-01 18:06:49 +01:00
// path to write our self signed rc to
fs::path our_rc_file = "rc.signed";
2018-06-01 16:08:54 +02:00
// our router contact
llarp::RouterContact _rc;
2018-09-13 14:04:36 +02:00
/// should we obey the service node whitelist?
bool whitelistRouters = false;
const llarp::RouterContact &
rc() const
{
return _rc;
}
2018-06-03 15:04:51 +02:00
// our ipv4 public setting
bool publicOverride = false;
struct sockaddr_in ip4addr;
llarp::AddressInfo addrInfo;
2018-06-03 15:04:51 +02: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;
bool
Sign(Signature &sig, llarp_buffer_t buf) const;
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 20:34:17 +01:00
llarp::InboundMessageParser inbound_link_msg_parser;
llarp::routing::InboundMessageParser inbound_routing_msg_parser;
llarp::service::Context hiddenServiceContext;
2018-10-09 14:06:30 +02:00
using NetConfig_t = std::unordered_multimap< std::string, std::string >;
2018-11-02 15:58:12 +01: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 16:08:54 +02:00
bool
CreateDefaultHiddenService();
2018-05-30 22:56:47 +02: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 19:35:12 +02: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 16:02:51 +01:00
std::unique_ptr< llarp::ILinkLayer > outboundLink;
std::vector< std::unique_ptr< llarp::ILinkLayer > > inboundLinks;
2018-08-14 23:17:18 +02:00
llarp::Profiling routerProfiling;
std::string routerProfilesFile = "profiles.dat";
using MessageQueue = std::queue< std::vector< byte_t > >;
2018-02-01 18:06:49 +01:00
/// outbound message queue
std::unordered_map< llarp::RouterID, MessageQueue, llarp::RouterID::Hash >
outboundMessageQueue;
2018-09-04 21:15:06 +02: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 16:05:48 +02: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 15:10:02 +01:00
Router(struct llarp_threadpool *tp, struct llarp_ev_loop *netloop,
llarp::Logic *logic);
~Router();
2018-07-09 19:32:11 +02:00
void
2018-12-17 23:43:16 +01:00
OnSessionEstablished(llarp::RouterContact rc);
2018-07-09 19:32:11 +02:00
bool
HandleRecvLinkMessageBuffer(llarp::ILinkSession *from, llarp_buffer_t msg);
void
AddInboundLink(std::unique_ptr< llarp::ILinkLayer > &link);
bool
InitOutboundLink();
2018-08-14 23:17:18 +02:00
2018-12-13 01:03:19 +01: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 16:05:48 +02:00
void
Close();
bool
LoadHiddenServiceConfig(const char *fname);
2018-02-01 18:06:49 +01:00
bool
AddHiddenService(const llarp::service::Config::section_t &config);
bool
Configure(struct llarp_config *conf);
2018-06-14 19:35:12 +02:00
bool
Ready();
2018-04-05 16:23:14 +02:00
bool
Run(struct llarp_nodedb *nodedb);
2018-09-17 13:47:34 +02:00
void
Stop();
2018-06-01 16:08:54 +02:00
void
PersistSessionUntil(const llarp::RouterID &remote, llarp_time_t until);
2018-06-06 14:46:26 +02:00
bool
EnsureIdentity();
bool
EnsureEncryptionKey();
2018-06-13 14:58:51 +02:00
bool
ConnectionToRouterAllowed(const llarp::RouterID &router) const;
2018-08-14 23:17:18 +02:00
bool
SaveRC();
2018-11-28 16:18:18 +01:00
const byte_t *
pubkey() const
{
return llarp::seckey_topublic(identity);
}
void
OnConnectTimeout(ILinkSession *session);
bool
HasPendingConnectJob(const llarp::RouterID &remote);
void
try_connect(fs::path rcfile);
2018-06-03 15:04:51 +02:00
bool
ReloadConfig(const llarp_config *conf);
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 llarp::RouterID &remote,
const llarp::ILinkMessage *msg);
2018-06-03 15:04:51 +02:00
/// sendto or drop
void
SendTo(llarp::RouterID remote, const llarp::ILinkMessage *msg,
llarp::ILinkLayer *chosen);
2018-07-03 15:33:37 +02:00
/// manually flush outbound message queue for just 1 router
void
FlushOutboundFor(llarp::RouterID remote,
llarp::ILinkLayer *chosen = nullptr);
2018-09-13 14:04:36 +02: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 22:56:47 +02:00
void
ForEachPeer(
std::function< void(const llarp::ILinkSession *, bool) > visit) const;
2018-08-30 20:48:43 +02:00
void
ForEachPeer(std::function< void(llarp::ILinkSession *) > visit);
/// 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);
/// flush outbound message queue
void
FlushOutbound();
2018-09-13 14:04:36 +02:00
/// called by link when a remote session has no more sessions open
void
SessionClosed(RouterID remote);
2018-08-30 20:48:43 +02:00
/// call internal router ticker
void
Tick();
2018-05-30 22:56:47 +02:00
/// get time from event loop
llarp_time_t
Now() const
{
return llarp_ev_loop_time_now_ms(netloop);
}
2018-06-03 15:04:51 +02:00
/// schedule ticker to call i ms from now
void
ScheduleTicker(uint64_t i = 1000);
2018-06-03 15:04:51 +02:00
llarp::ILinkLayer *
GetLinkWithSessionByPubkey(const llarp::RouterID &remote);
2018-11-11 14:14:19 +01: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:
bool
UpdateOurRC(bool rotateKeys = true);
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 18:06:49 +01:00
#endif