mirror of
https://github.com/oxen-io/lokinet.git
synced 2024-10-29 11:05:43 +00:00
614 lines
14 KiB
C++
614 lines
14 KiB
C++
#include <llarp.hpp>
|
|
#include <llarp.h>
|
|
|
|
#include <dht/context.hpp>
|
|
#include <dns/dotlokilookup.hpp>
|
|
#include <dnsd.hpp>
|
|
#include <ev/ev.hpp>
|
|
#include <nodedb.hpp>
|
|
#include <router/router.hpp>
|
|
#include <util/logger.h>
|
|
|
|
#include <getopt.h>
|
|
#include <signal.h>
|
|
|
|
#include <sys/param.h> // for MIN
|
|
|
|
#if(__FreeBSD__) || (__OpenBSD__) || (__NetBSD__)
|
|
#include <pthread_np.h>
|
|
#endif
|
|
|
|
namespace llarp
|
|
{
|
|
Context::~Context()
|
|
{
|
|
llarp_ev_loop_free(&mainloop);
|
|
}
|
|
|
|
void
|
|
Context::progress()
|
|
{
|
|
std::cout << "." << std::flush;
|
|
}
|
|
|
|
bool
|
|
Context::Configure()
|
|
{
|
|
// llarp::LogInfo("loading config at ", configfile);
|
|
if(llarp_load_config(config, configfile.c_str()))
|
|
{
|
|
llarp_free_config(&config);
|
|
llarp::LogError("failed to load config file ", configfile);
|
|
return false;
|
|
}
|
|
llarp_config_iterator iter;
|
|
iter.user = this;
|
|
iter.visit = &iter_config;
|
|
llarp_config_iter(config, &iter);
|
|
return true;
|
|
}
|
|
|
|
void
|
|
Context::iter_config(llarp_config_iterator *itr, const char *section,
|
|
const char *key, const char *val)
|
|
{
|
|
Context *ctx = static_cast< Context * >(itr->user);
|
|
if(!strcmp(section, "system"))
|
|
{
|
|
if(!strcmp(key, "pidfile"))
|
|
{
|
|
ctx->SetPIDFile(val);
|
|
}
|
|
}
|
|
if(!strcmp(section, "router"))
|
|
{
|
|
if(!strcmp(key, "worker-threads") && !ctx->singleThreaded)
|
|
{
|
|
int workers = atoi(val);
|
|
if(workers > 0 && ctx->worker == nullptr)
|
|
{
|
|
ctx->worker = llarp_init_threadpool(workers, "llarp-worker");
|
|
}
|
|
}
|
|
else if(!strcmp(key, "net-threads"))
|
|
{
|
|
ctx->num_nethreads = atoi(val);
|
|
if(ctx->num_nethreads <= 0)
|
|
ctx->num_nethreads = 1;
|
|
if(ctx->singleThreaded)
|
|
ctx->num_nethreads = 0;
|
|
}
|
|
}
|
|
if(!strcmp(section, "netdb"))
|
|
{
|
|
if(!strcmp(key, "dir"))
|
|
{
|
|
ctx->nodedb_dir = val;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
Context::SetPIDFile(const std::string &fname)
|
|
{
|
|
pidfile = fname;
|
|
}
|
|
|
|
int
|
|
Context::LoadDatabase()
|
|
{
|
|
crypto = std::unique_ptr< llarp::Crypto >(
|
|
new llarp::Crypto{llarp::Crypto::sodium{}});
|
|
nodedb = new llarp_nodedb(crypto.get(), router->disk);
|
|
|
|
if(!llarp_nodedb::ensure_dir(nodedb_dir.c_str()))
|
|
{
|
|
llarp::LogError("nodedb_dir is incorrect");
|
|
return 0;
|
|
}
|
|
// llarp::LogInfo("nodedb_dir [", nodedb_dir, "] configured!");
|
|
ssize_t loaded = nodedb->load_dir(nodedb_dir.c_str());
|
|
llarp::LogInfo("nodedb_dir loaded ", loaded, " RCs from [", nodedb_dir,
|
|
"]");
|
|
if(loaded < 0)
|
|
{
|
|
// shouldn't be possible
|
|
llarp::LogError("nodedb_dir directory doesn't exist");
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int
|
|
Context::IterateDatabase(llarp_nodedb_iter &i)
|
|
{
|
|
return nodedb->iterate_all(i);
|
|
}
|
|
|
|
bool
|
|
Context::PutDatabase(__attribute__((unused)) struct llarp::RouterContact &rc)
|
|
{
|
|
// FIXME
|
|
// return llarp_nodedb_put_rc(nodedb, rc);
|
|
return false;
|
|
}
|
|
|
|
llarp::RouterContact *
|
|
Context::GetDatabase(__attribute__((unused)) const byte_t *pk)
|
|
{
|
|
// FIXME
|
|
// return llarp_nodedb_get_rc(nodedb, pk);
|
|
return nullptr;
|
|
}
|
|
|
|
int
|
|
Context::Setup()
|
|
{
|
|
llarp::LogInfo(LLARP_VERSION, " ", LLARP_RELEASE_MOTTO);
|
|
llarp::LogInfo("starting up");
|
|
llarp_ev_loop_alloc(&mainloop);
|
|
|
|
// ensure worker thread pool
|
|
if(!worker && !singleThreaded)
|
|
worker = llarp_init_threadpool(2, "llarp-worker");
|
|
else if(singleThreaded)
|
|
{
|
|
llarp::LogInfo("running in single threaded mode");
|
|
worker = llarp_init_same_process_threadpool();
|
|
}
|
|
// ensure netio thread
|
|
if(singleThreaded)
|
|
{
|
|
logic = new Logic(worker);
|
|
}
|
|
else
|
|
logic = new Logic;
|
|
|
|
router = new Router(worker, mainloop, logic);
|
|
if(!router->Configure(config))
|
|
{
|
|
llarp::LogError("Failed to configure router");
|
|
return 1;
|
|
}
|
|
// must be done after router is made so we can use its disk io worker
|
|
// must also be done after configure so that netid is properly set if it is
|
|
// provided by config
|
|
if(!this->LoadDatabase())
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
Context::Run()
|
|
{
|
|
if(router == nullptr)
|
|
{
|
|
// we are not set up so we should die
|
|
llarp::LogError("cannot run non configured context");
|
|
return 1;
|
|
}
|
|
if(!WritePIDFile())
|
|
return 1;
|
|
// run
|
|
if(!router->Run(nodedb))
|
|
return 1;
|
|
|
|
// run net io thread
|
|
llarp::LogInfo("running mainloop");
|
|
llarp_ev_loop_run_single_process(mainloop, worker, logic);
|
|
// waits for router graceful stop
|
|
return 0;
|
|
}
|
|
|
|
bool
|
|
Context::WritePIDFile() const
|
|
{
|
|
if(pidfile.size())
|
|
{
|
|
std::ofstream f(pidfile);
|
|
f << std::to_string(getpid());
|
|
return f.good();
|
|
}
|
|
else
|
|
return true;
|
|
}
|
|
|
|
void
|
|
Context::RemovePIDFile() const
|
|
{
|
|
if(pidfile.size())
|
|
{
|
|
fs::path f = pidfile;
|
|
std::error_code ex;
|
|
if(fs::exists(f, ex))
|
|
{
|
|
if(!ex)
|
|
fs::remove(f);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
Context::HandleSignal(int sig)
|
|
{
|
|
if(sig == SIGINT || sig == SIGTERM)
|
|
{
|
|
SigINT();
|
|
}
|
|
// TODO(despair): implement hot-reloading config on NT
|
|
#ifndef _WIN32
|
|
if(sig == SIGHUP)
|
|
{
|
|
llarp::LogInfo("SIGHUP");
|
|
if(router)
|
|
{
|
|
llarp_config *newconfig = nullptr;
|
|
llarp_new_config(&newconfig);
|
|
if(llarp_load_config(newconfig, configfile.c_str()))
|
|
{
|
|
llarp_free_config(&newconfig);
|
|
llarp::LogError("failed to load config file ", configfile);
|
|
return;
|
|
}
|
|
// validate config
|
|
if(!router->ValidateConfig(newconfig))
|
|
{
|
|
llarp::LogWarn("new configuration is invalid");
|
|
llarp_free_config(&newconfig);
|
|
return;
|
|
}
|
|
// reconfigure
|
|
if(!router->Reconfigure(newconfig))
|
|
{
|
|
llarp_free_config(&newconfig);
|
|
llarp::LogError("Failed to reconfigure so we will stop.");
|
|
router->Stop();
|
|
return;
|
|
}
|
|
llarp::LogInfo("router reconfigured");
|
|
llarp_free_config(&newconfig);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void
|
|
Context::SigINT()
|
|
{
|
|
if(router)
|
|
{
|
|
/// async stop router on sigint
|
|
router->Stop();
|
|
}
|
|
else
|
|
{
|
|
if(logic)
|
|
logic->stop();
|
|
llarp_ev_loop_stop(mainloop);
|
|
Close();
|
|
}
|
|
}
|
|
|
|
void
|
|
Context::Close()
|
|
{
|
|
llarp::LogDebug("stop workers");
|
|
if(worker)
|
|
llarp_threadpool_stop(worker);
|
|
|
|
llarp::LogDebug("join workers");
|
|
if(worker)
|
|
llarp_threadpool_join(worker);
|
|
|
|
llarp::LogDebug("free config");
|
|
llarp_free_config(&config);
|
|
|
|
llarp::LogDebug("free workers");
|
|
llarp_free_threadpool(&worker);
|
|
|
|
llarp::LogDebug("free nodedb");
|
|
delete nodedb;
|
|
|
|
if(router)
|
|
{
|
|
llarp::LogDebug("free router");
|
|
delete router;
|
|
router = nullptr;
|
|
}
|
|
if(logic)
|
|
{
|
|
llarp::LogDebug("free logic");
|
|
delete logic;
|
|
logic = nullptr;
|
|
}
|
|
RemovePIDFile();
|
|
}
|
|
|
|
bool
|
|
Context::LoadConfig(const std::string &fname)
|
|
{
|
|
llarp_new_config(&config);
|
|
configfile = fname;
|
|
return Configure();
|
|
}
|
|
} // namespace llarp
|
|
|
|
struct llarp_main
|
|
{
|
|
std::unique_ptr< llarp::Context > ctx;
|
|
};
|
|
|
|
extern "C"
|
|
{
|
|
struct llarp_main *
|
|
llarp_main_init(const char *fname, bool multiProcess)
|
|
{
|
|
if(!fname)
|
|
fname = "daemon.ini";
|
|
char *var = getenv("LLARP_DEBUG");
|
|
if(var && *var == '1')
|
|
{
|
|
cSetLogLevel(eLogDebug);
|
|
}
|
|
llarp_main *m = new llarp_main;
|
|
m->ctx.reset(new llarp::Context());
|
|
m->ctx->singleThreaded = !multiProcess;
|
|
if(!m->ctx->LoadConfig(fname))
|
|
{
|
|
m->ctx->Close();
|
|
delete m;
|
|
return nullptr;
|
|
}
|
|
return m;
|
|
}
|
|
|
|
void
|
|
llarp_main_signal(struct llarp_main *ptr, int sig)
|
|
{
|
|
ptr->ctx->HandleSignal(sig);
|
|
}
|
|
|
|
void
|
|
llarp_main_inject_vpn_fd(struct llarp_main *ptr, int fd)
|
|
{
|
|
llarp::handlers::TunEndpoint *tun =
|
|
ptr->ctx->router->hiddenServiceContext.getFirstTun();
|
|
if(!tun)
|
|
return;
|
|
if(!tun->Promise)
|
|
return;
|
|
tun->Promise->Set(fd);
|
|
}
|
|
|
|
int
|
|
llarp_main_setup(struct llarp_main *ptr)
|
|
{
|
|
return ptr->ctx->Setup();
|
|
}
|
|
|
|
int
|
|
llarp_main_run(struct llarp_main *ptr)
|
|
{
|
|
if(!ptr)
|
|
{
|
|
llarp::LogError("No ptr passed in");
|
|
return 1;
|
|
}
|
|
return ptr->ctx->Run();
|
|
}
|
|
|
|
void
|
|
llarp_main_abort(struct llarp_main *ptr)
|
|
{
|
|
ptr->ctx->router->logic->stop_timer();
|
|
}
|
|
|
|
void
|
|
llarp_main_queryDHT_RC(struct llarp_main *ptr,
|
|
struct llarp_router_lookup_job *job)
|
|
{
|
|
llarp_dht_lookup_router(ptr->ctx->router->dht, job);
|
|
}
|
|
|
|
bool
|
|
llarp_main_init_dnsd(struct llarp_main *ptr, struct dnsd_context *dnsd,
|
|
const llarp::Addr &dnsd_sockaddr,
|
|
const llarp::Addr &dnsc_sockaddr)
|
|
{
|
|
return llarp_dnsd_init(dnsd, ptr->ctx->logic, ptr->ctx->mainloop,
|
|
dnsd_sockaddr, dnsc_sockaddr);
|
|
}
|
|
|
|
bool
|
|
llarp_main_init_dotLokiLookup(struct llarp_main *ptr,
|
|
struct dotLokiLookup *dll)
|
|
{
|
|
(void)ptr;
|
|
(void)dll;
|
|
// TODO: gutt me
|
|
return false;
|
|
}
|
|
|
|
void
|
|
llarp_main_free(struct llarp_main *ptr)
|
|
{
|
|
delete ptr;
|
|
}
|
|
|
|
int
|
|
llarp_main_loadDatabase(struct llarp_main *ptr)
|
|
{
|
|
return ptr->ctx->LoadDatabase();
|
|
}
|
|
|
|
int
|
|
llarp_main_iterateDatabase(struct llarp_main *ptr, struct llarp_nodedb_iter i)
|
|
{
|
|
return ptr->ctx->IterateDatabase(i);
|
|
}
|
|
|
|
bool
|
|
llarp_main_putDatabase(struct llarp_main *ptr, llarp::RouterContact &rc)
|
|
{
|
|
return ptr->ctx->PutDatabase(rc);
|
|
}
|
|
|
|
llarp::RouterContact *
|
|
llarp_main_getDatabase(struct llarp_main *ptr, byte_t *pk)
|
|
{
|
|
return ptr->ctx->GetDatabase(pk);
|
|
}
|
|
|
|
llarp::RouterContact *
|
|
llarp_main_getLocalRC(__attribute__((unused)) struct llarp_main *ptr)
|
|
{
|
|
//
|
|
/*
|
|
llarp_config_iterator iter;
|
|
iter.user = this;
|
|
iter.visit = &iter_config;
|
|
llarp_config_iter(ctx->config, &iter);
|
|
*/
|
|
// llarp_rc *rc = new llarp_rc;
|
|
// llarp::RouterContact *rc = new llarp::RouterContact;
|
|
// llarp_rc_new(rc);
|
|
// llarp::LogInfo("FIXME: Loading ", ptr->ctx->conatctFile);
|
|
// FIXME
|
|
/*
|
|
if(llarp_rc_read(ptr->ctx->conatctFile, rc))
|
|
return rc;
|
|
else
|
|
*/
|
|
return nullptr;
|
|
}
|
|
|
|
void
|
|
llarp_main_checkOnline(void *u, __attribute__((unused)) uint64_t orig,
|
|
uint64_t left)
|
|
{
|
|
// llarp::Info("checkOnline - check ", left);
|
|
if(left)
|
|
return;
|
|
struct check_online_request *request =
|
|
static_cast< struct check_online_request * >(u);
|
|
// llarp::Debug("checkOnline - running");
|
|
// llarp::Info("checkOnline - DHT nodes ",
|
|
// request->ptr->ctx->router->dht->impl.nodes->nodes.size());
|
|
request->online = false;
|
|
request->nodes = request->ptr->ctx->router->dht->impl.nodes->nodes.size();
|
|
if(request->ptr->ctx->router->dht->impl.nodes->nodes.size())
|
|
{
|
|
// llarp::Info("checkOnline - Going to say we're online");
|
|
request->online = true;
|
|
}
|
|
request->hook(request);
|
|
// reschedue our self
|
|
llarp_main_queryDHT(request);
|
|
}
|
|
|
|
void
|
|
llarp_main_queryDHT_online(struct check_online_request *request)
|
|
{
|
|
// Info("llarp_main_queryDHT_online: ", request->online ? "online" :
|
|
// "offline");
|
|
if(request->online && !request->first)
|
|
{
|
|
request->first = true;
|
|
llarp::LogInfo("llarp_main_queryDHT_online - We're online");
|
|
llarp::LogInfo("llarp_main_queryDHT_online - Querying DHT");
|
|
llarp_dht_lookup_router(request->ptr->ctx->router->dht, request->job);
|
|
}
|
|
}
|
|
|
|
void
|
|
llarp_main_queryDHT(struct check_online_request *request)
|
|
{
|
|
// llarp::Info("llarp_main_queryDHT - setting up timer");
|
|
request->hook = &llarp_main_queryDHT_online;
|
|
request->ptr->ctx->router->logic->call_later(
|
|
{1000, request, &llarp_main_checkOnline});
|
|
// llarp_dht_lookup_router(ptr->ctx->router->dht, job);
|
|
}
|
|
|
|
bool
|
|
main_router_prefetch(struct llarp_main *ptr,
|
|
const llarp::service::Address &addr)
|
|
{
|
|
auto *endpoint = &ptr->ctx->router->hiddenServiceContext;
|
|
return endpoint->Prefetch(addr);
|
|
}
|
|
|
|
llarp::handlers::TunEndpoint *
|
|
main_router_getFirstTunEndpoint(struct llarp_main *ptr)
|
|
{
|
|
if(ptr && ptr->ctx && ptr->ctx->router)
|
|
return ptr->ctx->router->hiddenServiceContext.getFirstTun();
|
|
return nullptr;
|
|
}
|
|
|
|
bool
|
|
main_router_endpoint_iterator(
|
|
struct llarp_main *ptr, struct llarp::service::Context::endpoint_iter &i)
|
|
{
|
|
auto *context = &ptr->ctx->router->hiddenServiceContext;
|
|
return context->iterate(i);
|
|
}
|
|
|
|
llarp_tun_io *
|
|
main_router_getRange(struct llarp_main *ptr)
|
|
{
|
|
auto *context = &ptr->ctx->router->hiddenServiceContext;
|
|
return context->getRange();
|
|
}
|
|
|
|
const char *
|
|
handleBaseCmdLineArgs(int argc, char *argv[])
|
|
{
|
|
const char *conffname = "daemon.ini";
|
|
int c;
|
|
while(1)
|
|
{
|
|
static struct option long_options[] = {
|
|
{"config", required_argument, 0, 'c'},
|
|
{"logLevel", required_argument, 0, 'o'},
|
|
{0, 0, 0, 0}};
|
|
int option_index = 0;
|
|
c = getopt_long(argc, argv, "c:o:", long_options, &option_index);
|
|
if(c == -1)
|
|
break;
|
|
switch(c)
|
|
{
|
|
case 0:
|
|
break;
|
|
case 'c':
|
|
conffname = optarg;
|
|
break;
|
|
case 'o':
|
|
if(strncmp(optarg, "debug", std::min(strlen(optarg), size_t(5))) == 0)
|
|
{
|
|
cSetLogLevel(eLogDebug);
|
|
}
|
|
else if(strncmp(optarg, "info", std::min(strlen(optarg), size_t(4)))
|
|
== 0)
|
|
{
|
|
cSetLogLevel(eLogInfo);
|
|
}
|
|
else if(strncmp(optarg, "warn", std::min(strlen(optarg), size_t(4)))
|
|
== 0)
|
|
{
|
|
cSetLogLevel(eLogWarn);
|
|
}
|
|
else if(strncmp(optarg, "error", std::min(strlen(optarg), size_t(5)))
|
|
== 0)
|
|
{
|
|
cSetLogLevel(eLogError);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
return conffname;
|
|
}
|
|
}
|