Archives
/
lokinet
mirror of https://github.com/oxen-io/lokinet
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

get first tun interface wiring

Browse Source
pull/16/head
Ryan Tharp 6 years ago
parent 31595d209d
commit 6590d502cd
4 changed files with 158 additions and 112 deletions
Show Stats Download Patch File Download Diff File

25
include/llarp.h
Unescape Escape View File

@ -7,7 +7,7 @@
#include <llarp/version.h> #include <llarp/version.h>
#ifdef __cplusplus #ifdef __cplusplus
#include "router.hpp" // for service::address #include "router.hpp" // for service::address
#include <llarp/service/endpoint.hpp> #include <llarp/service/endpoint.hpp>
extern "C" extern "C"
@ -47,7 +47,8 @@ extern "C"
/// put RC into nodeDB /// put RC into nodeDB
bool bool
llarp_main_putDatabase(struct llarp_main *ptr, struct llarp::RouterContact *rc); llarp_main_putDatabase(struct llarp_main *ptr,
struct llarp::RouterContact *rc);
/// get RC from nodeDB /// get RC from nodeDB
llarp::RouterContact * llarp::RouterContact *
@ -78,12 +79,16 @@ extern "C"
llarp_main_queryDHT_RC(struct llarp_main *ptr, llarp_main_queryDHT_RC(struct llarp_main *ptr,
struct llarp_router_lookup_job *job); struct llarp_router_lookup_job *job);
/// set up DNS libs with a context /// set up DNS libs with a context
bool bool
llarp_main_init_dnsd(struct llarp_main *ptr, struct dnsd_context *dnsd, llarp_main_init_dnsd(struct llarp_main *ptr, struct dnsd_context *dnsd,
uint16_t server_port, const char *upstream_host, struct llarp_logic *logic, uint16_t server_port,
uint16_t upstream_port); const char *upstream_host, uint16_t upstream_port);
/// set up dotLokiLookup with logic for setting timers
bool
llarp_main_init_dotLokiLookup(struct llarp_main *ptr,
struct dotLokiLookup *dll);
llarp::RouterContact * llarp::RouterContact *
llarp_main_getLocalRC(struct llarp_main *ptr); llarp_main_getLocalRC(struct llarp_main *ptr);
@ -96,17 +101,21 @@ extern "C"
#ifdef __cplusplus #ifdef __cplusplus
llarp::handlers::TunEndpoint *
main_router_getFirstTunEndpoint(struct llarp_main *ptr);
llarp_tun_io * llarp_tun_io *
main_router_getRange(struct llarp_main *ptr); main_router_getRange(struct llarp_main *ptr);
/// map an ip to a hidden service address /// map an ip to a hidden service address
bool bool
main_router_mapAddress(struct llarp_main *ptr, const llarp::service::Address &addr, uint32_t ip); main_router_mapAddress(struct llarp_main *ptr,
const llarp::service::Address &addr, uint32_t ip);
/// info of possible path usage /// info of possible path usage
bool bool
main_router_prefetch(struct llarp_main *ptr, const llarp::service::Address &addr); main_router_prefetch(struct llarp_main *ptr,
const llarp::service::Address &addr);
} }
#endif #endif
#endif #endif

4
include/llarp/service/context.hpp
Unescape Escape View File

@ -19,6 +19,10 @@ namespace llarp
void void
Tick(); Tick();
/// DRY refactor
llarp::service::Endpoint *
getFirstEndpoint();
/// DRY refactor /// DRY refactor
llarp::handlers::TunEndpoint * llarp::handlers::TunEndpoint *
getFirstTun(); getFirstTun();

196
llarp/context.cpp
Unescape Escape View File

@ -11,6 +11,7 @@
#include "router.hpp" #include "router.hpp"
#include "dnsd.hpp" #include "dnsd.hpp"
#include "dns_dotlokilookup.hpp"
#if(__FreeBSD__) || (__OpenBSD__) || (__NetBSD__) #if(__FreeBSD__) || (__OpenBSD__) || (__NetBSD__)
#include <pthread_np.h> #include <pthread_np.h>
@ -124,7 +125,7 @@ namespace llarp
Context::PutDatabase(struct llarp::RouterContact *rc) Context::PutDatabase(struct llarp::RouterContact *rc)
{ {
// FIXME // FIXME
//return llarp_nodedb_put_rc(nodedb, rc); // return llarp_nodedb_put_rc(nodedb, rc);
return false; return false;
} }
@ -132,7 +133,7 @@ namespace llarp
Context::GetDatabase(const byte_t *pk) Context::GetDatabase(const byte_t *pk)
{ {
// FIXME // FIXME
//return llarp_nodedb_get_rc(nodedb, pk); // return llarp_nodedb_get_rc(nodedb, pk);
return nullptr; return nullptr;
} }
@ -337,42 +338,50 @@ extern "C"
bool bool
llarp_main_init_dnsd(struct llarp_main *ptr, struct dnsd_context *dnsd, llarp_main_init_dnsd(struct llarp_main *ptr, struct dnsd_context *dnsd,
uint16_t server_port, const char *upstream_host, struct llarp_logic *logic, uint16_t server_port,
uint16_t upstream_port) const char *upstream_host, uint16_t upstream_port)
{ {
return llarp_dnsd_init(dnsd, ptr->ctx->mainloop, ptr->ctx->logic, "*", return llarp_dnsd_init(dnsd, ptr->ctx->logic, ptr->ctx->mainloop, "*",
server_port, upstream_host, upstream_port); server_port, upstream_host, upstream_port);
} }
bool
llarp_main_init_dotLokiLookup(struct llarp_main *ptr,
struct dotLokiLookup *dll)
{
dll->logic = ptr->ctx->logic;
return true;
}
void void
llarp_main_free(struct llarp_main *ptr) llarp_main_free(struct llarp_main *ptr)
{ {
delete ptr; delete ptr;
} }
int int
llarp_main_loadDatabase(struct llarp_main *ptr) llarp_main_loadDatabase(struct llarp_main *ptr)
{ {
return ptr->ctx->LoadDatabase(); return ptr->ctx->LoadDatabase();
} }
int int
llarp_main_iterateDatabase(struct llarp_main *ptr, struct llarp_nodedb_iter i) llarp_main_iterateDatabase(struct llarp_main *ptr, struct llarp_nodedb_iter i)
{ {
return ptr->ctx->IterateDatabase(i); return ptr->ctx->IterateDatabase(i);
} }
bool bool
llarp_main_putDatabase(struct llarp_main *ptr, llarp::RouterContact *rc) llarp_main_putDatabase(struct llarp_main *ptr, llarp::RouterContact *rc)
{ {
return ptr->ctx->PutDatabase(rc); return ptr->ctx->PutDatabase(rc);
} }
llarp::RouterContact * llarp::RouterContact *
llarp_main_getDatabase(struct llarp_main *ptr, byte_t *pk) llarp_main_getDatabase(struct llarp_main *ptr, byte_t *pk)
{ {
return ptr->ctx->GetDatabase(pk); return ptr->ctx->GetDatabase(pk);
} }
llarp::RouterContact * llarp::RouterContact *
llarp_main_getLocalRC(struct llarp_main *ptr) llarp_main_getLocalRC(struct llarp_main *ptr)
@ -384,86 +393,95 @@ llarp_main_getDatabase(struct llarp_main *ptr, byte_t *pk)
iter.visit = &iter_config; iter.visit = &iter_config;
llarp_config_iter(ctx->config, &iter); llarp_config_iter(ctx->config, &iter);
*/ */
//llarp_rc *rc = new llarp_rc; // llarp_rc *rc = new llarp_rc;
llarp::RouterContact *rc = new llarp::RouterContact; llarp::RouterContact *rc = new llarp::RouterContact;
//llarp_rc_new(rc); // llarp_rc_new(rc);
//llarp::LogInfo("FIXME: Loading ", ptr->ctx->conatctFile); // llarp::LogInfo("FIXME: Loading ", ptr->ctx->conatctFile);
// FIXME // FIXME
/* /*
if(llarp_rc_read(ptr->ctx->conatctFile, rc)) if(llarp_rc_read(ptr->ctx->conatctFile, rc))
return rc; return rc;
else else
*/ */
return nullptr; return nullptr;
} }
void void
llarp_main_checkOnline(void *u, uint64_t orig, uint64_t left) llarp_main_checkOnline(void *u, uint64_t orig, uint64_t left)
{ {
// llarp::Info("checkOnline - check ", left); // llarp::Info("checkOnline - check ", left);
if(left) if(left)
return; return;
struct check_online_request *request = struct check_online_request *request =
static_cast< struct check_online_request * >(u); static_cast< struct check_online_request * >(u);
// llarp::Debug("checkOnline - running"); // llarp::Debug("checkOnline - running");
// llarp::Info("checkOnline - DHT nodes ", // llarp::Info("checkOnline - DHT nodes ",
// request->ptr->ctx->router->dht->impl.nodes->nodes.size()); // request->ptr->ctx->router->dht->impl.nodes->nodes.size());
request->online = false; request->online = false;
request->nodes = request->ptr->ctx->router->dht->impl.nodes->nodes.size(); request->nodes = request->ptr->ctx->router->dht->impl.nodes->nodes.size();
if(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"); // llarp::Info("checkOnline - Going to say we're online");
request->online = true; request->online = true;
} }
request->hook(request); request->hook(request);
// reschedue our self // reschedue our self
llarp_main_queryDHT(request); llarp_main_queryDHT(request);
} }
void void
llarp_main_queryDHT_online(struct check_online_request *request) 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; // Info("llarp_main_queryDHT_online: ", request->online ? "online" :
llarp::LogInfo("llarp_main_queryDHT_online - We're online"); // "offline");
llarp::LogInfo("llarp_main_queryDHT_online - Querying DHT"); if(request->online && !request->first)
llarp_dht_lookup_router(request->ptr->ctx->router->dht, request->job); {
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 void
llarp_main_queryDHT(struct check_online_request *request) llarp_main_queryDHT(struct check_online_request *request)
{ {
// llarp::Info("llarp_main_queryDHT - setting up timer"); // llarp::Info("llarp_main_queryDHT - setting up timer");
request->hook = &llarp_main_queryDHT_online; request->hook = &llarp_main_queryDHT_online;
llarp_logic_call_later(request->ptr->ctx->router->logic, llarp_logic_call_later(request->ptr->ctx->router->logic,
{1000, request, &llarp_main_checkOnline}); {1000, request, &llarp_main_checkOnline});
// llarp_dht_lookup_router(ptr->ctx->router->dht, job); // llarp_dht_lookup_router(ptr->ctx->router->dht, job);
} }
bool bool
main_router_mapAddress(struct llarp_main *ptr, const llarp::service::Address &addr, uint32_t ip) main_router_mapAddress(struct llarp_main *ptr,
{ const llarp::service::Address &addr, uint32_t ip)
auto *endpoint = &ptr->ctx->router->hiddenServiceContext; {
return endpoint->MapAddress(addr, ip); auto *endpoint = &ptr->ctx->router->hiddenServiceContext;
} return endpoint->MapAddress(addr, ip);
}
bool bool
main_router_prefetch(struct llarp_main *ptr, const llarp::service::Address &addr) main_router_prefetch(struct llarp_main *ptr,
{ const llarp::service::Address &addr)
auto *endpoint = &ptr->ctx->router->hiddenServiceContext; {
return endpoint->Prefetch(addr); auto *endpoint = &ptr->ctx->router->hiddenServiceContext;
} return endpoint->Prefetch(addr);
}
llarp_tun_io * llarp::handlers::TunEndpoint *
main_router_getRange(struct llarp_main *ptr) main_router_getFirstTunEndpoint(struct llarp_main *ptr)
{ {
auto *endpoint = &ptr->ctx->router->hiddenServiceContext; auto *endpoint = &ptr->ctx->router->hiddenServiceContext;
return endpoint->getRange(); return endpoint->getFirstTun();
} }
llarp_tun_io *
main_router_getRange(struct llarp_main *ptr)
{
auto *endpoint = &ptr->ctx->router->hiddenServiceContext;
return endpoint->getRange();
}
const char * const char *
handleBaseCmdLineArgs(int argc, char *argv[]) handleBaseCmdLineArgs(int argc, char *argv[])

45
llarp/service/context.cpp
Unescape Escape View File

@ -31,18 +31,29 @@ namespace llarp
} }
} }
llarp::handlers::TunEndpoint * llarp::service::Endpoint *
Context::getFirstTun() Context::getFirstEndpoint()
{ {
if (!m_Endpoints.size()) if(!m_Endpoints.size())
{ {
llarp::LogError("No endpoints found"); llarp::LogError("No endpoints found");
return nullptr; return nullptr;
} }
auto firstEndpoint = m_Endpoints.begin(); auto firstEndpoint = m_Endpoints.begin();
auto *uniqueEndpoint = &firstEndpoint->second; auto *uniqueEndpoint = &firstEndpoint->second;
llarp::service::Endpoint *endpointer = uniqueEndpoint->get(); return uniqueEndpoint->get();
llarp::handlers::TunEndpoint *tunEndpoint = dynamic_cast<llarp::handlers::TunEndpoint *>(endpointer); }
llarp::handlers::TunEndpoint *
Context::getFirstTun()
{
llarp::service::Endpoint *endpointer = this->getFirstEndpoint();
if(!endpointer)
{
return nullptr;
}
llarp::handlers::TunEndpoint *tunEndpoint =
dynamic_cast< llarp::handlers::TunEndpoint * >(endpointer);
return tunEndpoint; return tunEndpoint;
} }
@ -50,7 +61,7 @@ namespace llarp
Context::getRange() Context::getRange()
{ {
llarp::handlers::TunEndpoint *tunEndpoint = this->getFirstTun(); llarp::handlers::TunEndpoint *tunEndpoint = this->getFirstTun();
if (!tunEndpoint) if(!tunEndpoint)
{ {
llarp::LogError("No tunnel endpoint found"); llarp::LogError("No tunnel endpoint found");
return nullptr; return nullptr;
@ -62,28 +73,32 @@ namespace llarp
Context::Prefetch(const llarp::service::Address &addr) Context::Prefetch(const llarp::service::Address &addr)
{ {
llarp::handlers::TunEndpoint *tunEndpoint = this->getFirstTun(); llarp::handlers::TunEndpoint *tunEndpoint = this->getFirstTun();
if (!tunEndpoint) if(!tunEndpoint)
{ {
llarp::LogError("No tunnel endpoint found"); llarp::LogError("No tunnel endpoint found");
return false; return false;
} }
//HiddenServiceAddresslookup *lookup = new HiddenServiceEndpoint(tunEndpoint, callback, addr, tunEndpoint->GenTXID()); // HiddenServiceAddresslookup *lookup = new
return tunEndpoint->EnsurePathToService(addr, [](Address addr, void* ctx) {}, 10000); // HiddenServiceEndpoint(tunEndpoint, callback, addr,
// tunEndpoint->GenTXID());
return tunEndpoint->EnsurePathToService(
addr, [](Address addr, void *ctx) {}, 10000);
} }
bool bool
Context::MapAddress(const llarp::service::Address &addr, uint32_t ip) Context::MapAddress(const llarp::service::Address &addr, uint32_t ip)
{ {
if (!m_Endpoints.size()) if(!m_Endpoints.size())
{ {
llarp::LogError("No endpoints found"); llarp::LogError("No endpoints found");
return false; return false;
} }
auto firstEndpoint = m_Endpoints.begin(); auto firstEndpoint = m_Endpoints.begin();
auto *uniqueEndpoint = &firstEndpoint->second; auto *uniqueEndpoint = &firstEndpoint->second;
llarp::service::Endpoint *endpointer = uniqueEndpoint->get(); llarp::service::Endpoint *endpointer = uniqueEndpoint->get();
llarp::handlers::TunEndpoint *tunEndpoint = dynamic_cast<llarp::handlers::TunEndpoint *>(endpointer); llarp::handlers::TunEndpoint *tunEndpoint =
if (!tunEndpoint) dynamic_cast< llarp::handlers::TunEndpoint * >(endpointer);
if(!tunEndpoint)
{ {
llarp::LogError("No tunnel endpoint found"); llarp::LogError("No tunnel endpoint found");
return false; return false;

Write Preview
Loading…
Cancel
Save