mirror of https://github.com/oxen-io/lokinet
turn more stuff into std::shared_ptr
remove dead codepaths
This commit is contained in:
Jeff Becker
parent
99c29cf05a
commit
8484e29c9b
|
|
@ -109,9 +109,7 @@ if(WIN32)
|
|||
target_link_libraries(${PLATFORM_LIB} PUBLIC iphlpapi)
|
||||
endif()
|
||||
set(DNSLIB_SRC
|
||||
dns/dotlokilookup.cpp
|
||||
dns/dns.cpp
|
||||
dns/iptracker.cpp
|
||||
dns/message.cpp
|
||||
dns/name.cpp
|
||||
dns/query.cpp
|
||||
|
|
|
|||
|
|
@ -4,7 +4,6 @@
|
|||
#include <config.hpp>
|
||||
#include <crypto/crypto_libsodium.hpp>
|
||||
#include <dht/context.hpp>
|
||||
#include <dns/dotlokilookup.hpp>
|
||||
#include <dnsd.hpp>
|
||||
#include <ev/ev.hpp>
|
||||
#include <metrics/metrictank_publisher.hpp>
|
||||
|
|
@ -464,18 +463,6 @@ extern "C"
|
|||
ptr->ctx->HandleSignal(sig);
|
||||
}
|
||||
|
||||
void
|
||||
llarp_main_inject_vpn_fd(struct llarp_main *ptr, int rfd, int wfd)
|
||||
{
|
||||
llarp::handlers::TunEndpoint *tun =
|
||||
ptr->ctx->router->hiddenServiceContext().getFirstTun();
|
||||
if(!tun)
|
||||
return;
|
||||
if(!tun->Promise)
|
||||
return;
|
||||
tun->Promise->Set({rfd, wfd});
|
||||
}
|
||||
|
||||
int
|
||||
llarp_main_setup(struct llarp_main *ptr)
|
||||
{
|
||||
|
|
@ -538,6 +525,7 @@ extern "C"
|
|||
return ptr->ctx->LoadDatabase();
|
||||
}
|
||||
|
||||
/*
|
||||
int
|
||||
llarp_main_iterateDatabase(struct llarp_main *ptr, struct llarp_nodedb_iter i)
|
||||
{
|
||||
|
|
@ -611,13 +599,6 @@ extern "C"
|
|||
// 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)
|
||||
|
|
@ -640,6 +621,8 @@ extern "C"
|
|||
return ptr->ctx->router->hiddenServiceContext().getRange();
|
||||
}
|
||||
|
||||
*/
|
||||
|
||||
const char *
|
||||
handleBaseCmdLineArgs(int argc, char *argv[])
|
||||
{
|
||||
|
|
|
|||
|
|
@ -1,476 +0,0 @@
|
|||
#include <dns/dotlokilookup.hpp>
|
||||
|
||||
#include <handlers/tun.hpp>
|
||||
#include <service/context.hpp>
|
||||
#include <util/logic.hpp>
|
||||
|
||||
std::string const default_chars =
|
||||
"abcdefghijklmnaoqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
|
||||
|
||||
#include <random>
|
||||
|
||||
std::string
|
||||
random_string(size_t len = 15, std::string const &allowed_chars = default_chars)
|
||||
{
|
||||
std::mt19937_64 gen{std::random_device()()};
|
||||
|
||||
std::uniform_int_distribution< size_t > dist{0, allowed_chars.length() - 1};
|
||||
|
||||
std::string ret;
|
||||
|
||||
std::generate_n(std::back_inserter(ret), len,
|
||||
[&] { return allowed_chars[dist(gen)]; });
|
||||
return ret;
|
||||
}
|
||||
|
||||
struct check_query_simple_request
|
||||
{
|
||||
// already inside request
|
||||
// const struct sockaddr *from; // source
|
||||
const dnsd_question_request *request;
|
||||
};
|
||||
|
||||
std::unordered_map< std::string, struct dnsd_query_hook_response * >
|
||||
loki_tld_lookup_cache;
|
||||
|
||||
static bool
|
||||
decode_request_name(const std::string &name, llarp::AlignedBuffer< 32 > &addr,
|
||||
bool &isSNode)
|
||||
{
|
||||
llarp::service::Address serviceAddr;
|
||||
llarp::RouterID snodeAddr;
|
||||
auto pos = name.find(".snode");
|
||||
if(pos != std::string::npos)
|
||||
{
|
||||
if(!llarp::HexDecode(name.substr(0, pos).c_str(), serviceAddr.begin(),
|
||||
serviceAddr.size()))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
addr = snodeAddr;
|
||||
isSNode = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(!serviceAddr.FromString(name))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
addr = serviceAddr;
|
||||
isSNode = false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
void
|
||||
llarp_dotlokilookup_checkQuery(void *u, __attribute__((unused)) uint64_t orig,
|
||||
uint64_t left)
|
||||
{
|
||||
if(left)
|
||||
return;
|
||||
// struct check_query_request *request = static_cast< struct
|
||||
// check_query_request * >(u);
|
||||
struct check_query_simple_request *qr =
|
||||
static_cast< struct check_query_simple_request * >(u);
|
||||
dotLokiLookup *dll = (dotLokiLookup *)qr->request->context->user;
|
||||
if(!dll)
|
||||
{
|
||||
llarp::LogError("DNSd dotLokiLookup is not configured");
|
||||
write404_dnss_response(qr->request);
|
||||
delete qr;
|
||||
return;
|
||||
}
|
||||
|
||||
// we do have result
|
||||
// if so send that
|
||||
// else
|
||||
// if we have a free private ip, send that
|
||||
|
||||
/*
|
||||
// cache hit
|
||||
auto itr = loki_tld_lookup_cache.find(addr.ToString());
|
||||
if(itr != loki_tld_lookup_cache.end())
|
||||
{
|
||||
llarp::LogDebug("Found in .loki lookup cache");
|
||||
writesend_dnss_response(itr->second->returnThis, qr->from, qr->request);
|
||||
delete qr;
|
||||
return;
|
||||
}
|
||||
|
||||
struct dns_pointer *free_private = dns_iptracker_get_free(dll->ip_tracker);
|
||||
if(free_private)
|
||||
{
|
||||
*/
|
||||
|
||||
// in_addr ip_address = ((sockaddr_in *)free_private->hostResult)->sin_addr;
|
||||
|
||||
llarp::service::Context *routerHiddenServiceContext =
|
||||
(llarp::service::Context *)dll->user;
|
||||
if(!routerHiddenServiceContext)
|
||||
{
|
||||
llarp::LogWarn("dotLokiLookup user isnt a service::Context: ", dll->user);
|
||||
write404_dnss_response(qr->request);
|
||||
delete qr;
|
||||
return;
|
||||
}
|
||||
llarp::huint32_t serviceIP;
|
||||
llarp::AlignedBuffer< 32 > addr;
|
||||
bool isSNode = false;
|
||||
if(!decode_request_name(qr->request->question.name, addr, isSNode))
|
||||
{
|
||||
llarp::LogWarn("decode_request_name failed");
|
||||
write404_dnss_response(qr->request);
|
||||
delete qr;
|
||||
return;
|
||||
}
|
||||
if(!routerHiddenServiceContext->FindBestAddressFor(addr, isSNode, serviceIP))
|
||||
{
|
||||
llarp::LogWarn("dotLokiLookup failed to map address");
|
||||
write404_dnss_response(qr->request);
|
||||
delete qr;
|
||||
return;
|
||||
}
|
||||
|
||||
/*
|
||||
bool mapResult = routerHiddenServiceContext->MapAddressAll(
|
||||
addr, free_private->hostResult);
|
||||
if(!mapResult)
|
||||
{
|
||||
llarp::LogWarn("dotLokiLookup failed to map address");
|
||||
write404_dnss_response(qr->from, qr->request);
|
||||
delete qr;
|
||||
return;
|
||||
}
|
||||
*/
|
||||
|
||||
// make a dnsd_query_hook_response for the cache
|
||||
dnsd_query_hook_response *response = new dnsd_query_hook_response;
|
||||
response->dontLookUp = true;
|
||||
response->dontSendResponse = false;
|
||||
// llarp::Addr test(*free_private->hostResult.getSockAddr());
|
||||
// llarp::LogInfo("IP Test: ", test);
|
||||
// response->returnThis = &free_private->hostResult;
|
||||
response->returnThis = serviceIP;
|
||||
llarp::LogInfo("Saving ", qr->request->question.name);
|
||||
loki_tld_lookup_cache[qr->request->question.name] = response;
|
||||
// we can't delete response now...
|
||||
|
||||
/*
|
||||
llarp::handlers::TunEndpoint *tunEndpoint =
|
||||
(llarp::handlers::TunEndpoint *)dll->user;
|
||||
if (!tunEndpoint)
|
||||
{
|
||||
llarp::LogWarn("dotLokiLookup user isnt a tunEndpoint: ", dll->user);
|
||||
return;
|
||||
}
|
||||
bool mapResult = tunEndpoint->MapAddress(addr,
|
||||
free_private->hostResult.tohl()); if(!mapResult)
|
||||
{
|
||||
delete qr;
|
||||
return;
|
||||
}
|
||||
*/
|
||||
llarp::huint32_t foundAddr;
|
||||
if(!routerHiddenServiceContext->FindBestAddressFor(addr, isSNode, foundAddr))
|
||||
{
|
||||
write404_dnss_response(qr->request);
|
||||
delete qr;
|
||||
return;
|
||||
}
|
||||
|
||||
// make a dnsd_query_hook_response for the cache
|
||||
/*
|
||||
dnsd_query_hook_response *response = new dnsd_query_hook_response;
|
||||
response->dontLookUp = true;
|
||||
response->dontSendResponse = false;
|
||||
loki_tld_lookup_cache[addr.ToString()]=response;
|
||||
*/
|
||||
// we can't delete response now...
|
||||
// sockaddr_in saddr;
|
||||
// saddr.sin_family = AF_INET;
|
||||
// saddr.sin_addr.s_addr = llarp::xhtonl(foundAddr).n;
|
||||
// FIXME: flush cache to disk
|
||||
// on crash we'll need to bring up all the same IPs we assigned before...
|
||||
writesend_dnss_response(&foundAddr, qr->request);
|
||||
delete qr;
|
||||
return;
|
||||
}
|
||||
|
||||
std::vector< std::string >
|
||||
split(std::string str)
|
||||
{
|
||||
size_t pos = 0;
|
||||
std::string token;
|
||||
std::string s(str);
|
||||
std::vector< std::string > tokens;
|
||||
while((pos = s.find(".")) != std::string::npos)
|
||||
{
|
||||
token = s.substr(0, pos);
|
||||
// llarp::LogInfo("token [", token, "]");
|
||||
tokens.push_back(token);
|
||||
s.erase(0, pos + 1);
|
||||
}
|
||||
token = s.substr(0, pos);
|
||||
tokens.push_back(token);
|
||||
// llarp::LogInfo("token [", token, "]");
|
||||
return tokens;
|
||||
}
|
||||
|
||||
struct reverse_handler_iter_context
|
||||
{
|
||||
std::string lName;
|
||||
// const struct sockaddr *from; // aready inside dnsd_question_request
|
||||
const dnsd_question_request *request;
|
||||
};
|
||||
|
||||
#if defined(ANDROID) || defined(RPI)
|
||||
static int
|
||||
stoi(const std::string &s)
|
||||
{
|
||||
return atoi(s.c_str());
|
||||
}
|
||||
#endif
|
||||
|
||||
bool
|
||||
ReverseHandlerIter(struct llarp::service::Context::endpoint_iter *endpointCfg)
|
||||
{
|
||||
reverse_handler_iter_context *context =
|
||||
(reverse_handler_iter_context *)endpointCfg->user;
|
||||
// llarp::LogInfo("context ", context->request->question.name);
|
||||
// llarp::LogInfo("Checking ", lName);
|
||||
llarp::handlers::TunEndpoint *tunEndpoint =
|
||||
(llarp::handlers::TunEndpoint *)endpointCfg->endpoint;
|
||||
if(!tunEndpoint)
|
||||
{
|
||||
llarp::LogError("No tunnel endpoint found");
|
||||
return true; // still continue
|
||||
}
|
||||
// llarp::LogInfo("for ", tunEndpoint->tunif.ifaddr);
|
||||
std::string checkStr(tunEndpoint->tunif.ifaddr);
|
||||
std::vector< std::string > tokensSearch = split(context->lName);
|
||||
std::vector< std::string > tokensCheck = split(checkStr);
|
||||
|
||||
// well the tunif is just one ip on a network range...
|
||||
// support "b._dns-sd._udp.0.0.200.10.in-addr.arpa"
|
||||
size_t searchTokens = tokensSearch.size();
|
||||
// if the query has five or fewer levels,
|
||||
// tack on leading '0.'s to form a minimum six-level
|
||||
// PTR query -rick
|
||||
if(searchTokens < 6)
|
||||
{
|
||||
switch(searchTokens)
|
||||
{
|
||||
case 5:
|
||||
tokensSearch.clear();
|
||||
context->lName.insert(0, "0.");
|
||||
tokensSearch = split(context->lName);
|
||||
searchTokens = tokensSearch.size();
|
||||
break;
|
||||
case 4:
|
||||
tokensSearch.clear();
|
||||
context->lName.insert(0, "0.0.");
|
||||
tokensSearch = split(context->lName);
|
||||
searchTokens = tokensSearch.size();
|
||||
break;
|
||||
case 3:
|
||||
tokensSearch.clear();
|
||||
context->lName.insert(0, "0.0.0.");
|
||||
tokensSearch = split(context->lName);
|
||||
searchTokens = tokensSearch.size();
|
||||
break;
|
||||
default:
|
||||
llarp::LogError("invalid PTR query: ", context->lName);
|
||||
break;
|
||||
}
|
||||
}
|
||||
// this expression assumes a six-level name
|
||||
std::string searchIp = tokensSearch[searchTokens - 3] + "."
|
||||
+ tokensSearch[searchTokens - 4] + "." + tokensSearch[searchTokens - 5]
|
||||
+ "." + tokensSearch[searchTokens - 6];
|
||||
std::string checkIp = tokensCheck[0] + "." + tokensCheck[1] + "."
|
||||
+ tokensCheck[2] + "." + tokensCheck[3];
|
||||
llarp::LogDebug(searchIp, " vs ", checkIp);
|
||||
|
||||
llarp::IPRange range =
|
||||
llarp::iprange_ipv4(std::stoi(tokensCheck[0]), std::stoi(tokensCheck[1]),
|
||||
std::stoi(tokensCheck[2]), std::stoi(tokensCheck[3]),
|
||||
tunEndpoint->tunif.netmask); // create range
|
||||
|
||||
llarp::huint32_t searchIPv4 = llarp::ipaddr_ipv4_bits(
|
||||
std::stoi(tokensSearch[searchTokens - 3]),
|
||||
std::stoi(tokensSearch[searchTokens - 4]),
|
||||
std::stoi(tokensSearch[searchTokens - 5]),
|
||||
std::stoi(tokensSearch[searchTokens - 6])); // create ip
|
||||
|
||||
// bool inRange = range.Contains(searchAddr.xtohl());
|
||||
bool inRange = range.Contains(searchIPv4);
|
||||
|
||||
llarp::Addr searchAddr(searchIp);
|
||||
llarp::Addr checkAddr(checkIp);
|
||||
llarp::LogInfo(searchIPv4, " vs ", range, " = ",
|
||||
inRange ? "inRange" : "not match");
|
||||
|
||||
if(inRange)
|
||||
{
|
||||
llarp::AlignedBuffer< 32 > addr =
|
||||
tunEndpoint->ObtainAddrForIP< llarp::AlignedBuffer< 32 > >(searchIPv4,
|
||||
false);
|
||||
if(addr.IsZero())
|
||||
{
|
||||
addr = tunEndpoint->ObtainAddrForIP< llarp::AlignedBuffer< 32 > >(
|
||||
searchIPv4, true);
|
||||
if(!addr.IsZero())
|
||||
{
|
||||
char stack[128] = {0};
|
||||
std::string saddr = llarp::HexEncode(addr, stack);
|
||||
saddr += ".snode";
|
||||
writesend_dnss_revresponse(saddr, context->request);
|
||||
}
|
||||
else
|
||||
write404_dnss_response(context->request);
|
||||
}
|
||||
else
|
||||
{
|
||||
llarp::service::Address saddr(addr);
|
||||
// llarp::LogInfo("Returning [", saddr.ToString(), "]");
|
||||
writesend_dnss_revresponse(saddr.ToString(), context->request);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
return true; // we don't do anything with the result yet
|
||||
}
|
||||
|
||||
static bool
|
||||
should_intercept_query_with_name(const std::string &lName)
|
||||
{
|
||||
// null terminated list
|
||||
static const char *const matches[] = {".loki", ".snode", ".loki.", ".snode.",
|
||||
0};
|
||||
size_t idx = 0;
|
||||
while(matches[idx])
|
||||
{
|
||||
std::string match_str(matches[idx]);
|
||||
if(lName.substr(lName.length() - match_str.length()) == match_str)
|
||||
return true;
|
||||
++idx;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
dnsd_query_hook_response *
|
||||
llarp_dotlokilookup_handler(std::string name,
|
||||
const dnsd_question_request *request)
|
||||
{
|
||||
dnsd_query_hook_response *response = new dnsd_query_hook_response;
|
||||
response->dontLookUp = false;
|
||||
response->dontSendResponse = false;
|
||||
response->returnThis.h = 0;
|
||||
llarp::LogDebug("Hooked ", name);
|
||||
std::string lName = name;
|
||||
std::transform(lName.begin(), lName.end(), lName.begin(), ::tolower);
|
||||
// llarp::LogDebug("Transformed ", lName);
|
||||
|
||||
// 253.0.200.10.in-addr.arpa
|
||||
if(lName.find(".in-addr.arpa") != std::string::npos)
|
||||
{
|
||||
// llarp::LogDebug("Checking ", lName);
|
||||
dotLokiLookup *dll = (dotLokiLookup *)request->context->user;
|
||||
llarp::service::Context *routerHiddenServiceContext =
|
||||
(llarp::service::Context *)dll->user;
|
||||
if(!routerHiddenServiceContext)
|
||||
{
|
||||
llarp::LogWarn("dotLokiLookup user isnt a service::Context: ", dll->user);
|
||||
return response;
|
||||
}
|
||||
// llarp::LogDebug("Starting rev iter for ", lName);
|
||||
// which range?
|
||||
// for each tun interface
|
||||
struct reverse_handler_iter_context context;
|
||||
context.lName = lName;
|
||||
// context.from = request->from;
|
||||
context.request = request;
|
||||
|
||||
struct llarp::service::Context::endpoint_iter i;
|
||||
i.user = &context;
|
||||
i.index = 0;
|
||||
i.visit = &ReverseHandlerIter;
|
||||
bool res = routerHiddenServiceContext->iterate(i);
|
||||
if(!res)
|
||||
{
|
||||
llarp::LogDebug("Reverse is ours");
|
||||
response->dontLookUp = true;
|
||||
response->dontSendResponse = true; // should have already sent it
|
||||
}
|
||||
else
|
||||
{
|
||||
llarp::LogInfo("Reverse is not ours");
|
||||
}
|
||||
}
|
||||
else if(should_intercept_query_with_name(lName))
|
||||
{
|
||||
llarp::LogInfo("Detect Loki Lookup for ", lName);
|
||||
auto cache_check = loki_tld_lookup_cache.find(lName);
|
||||
if(cache_check != loki_tld_lookup_cache.end())
|
||||
{
|
||||
// was in cache
|
||||
llarp::LogInfo("Reused address from LokiLookupCache");
|
||||
// FIXME: avoid the response allocation if you could
|
||||
delete response;
|
||||
return cache_check->second;
|
||||
}
|
||||
|
||||
// decode address
|
||||
llarp::AlignedBuffer< 32 > addr;
|
||||
bool isSNode = false;
|
||||
if(!decode_request_name(lName, addr, isSNode))
|
||||
{
|
||||
response->dontLookUp = true;
|
||||
return response;
|
||||
}
|
||||
|
||||
dotLokiLookup *dll = (dotLokiLookup *)request->context->user;
|
||||
llarp::service::Context *routerHiddenServiceContext =
|
||||
(llarp::service::Context *)dll->user;
|
||||
if(!routerHiddenServiceContext)
|
||||
{
|
||||
llarp::LogWarn("dotLokiLookup user isnt a service::Context: ", dll->user);
|
||||
return response;
|
||||
}
|
||||
|
||||
// start path build early (if you're looking it up, you're probably going to
|
||||
// use it)
|
||||
// main_router_prefetch(ctx, addr);
|
||||
|
||||
// schedule future response
|
||||
check_query_simple_request *qr = new check_query_simple_request;
|
||||
// qr->from = request->from;
|
||||
qr->request = request;
|
||||
|
||||
auto tun = routerHiddenServiceContext->getFirstTun();
|
||||
if(isSNode)
|
||||
{
|
||||
if(tun->HasPathToSNode(addr.as_array()))
|
||||
{
|
||||
llarp_dotlokilookup_checkQuery(qr, 0, 0);
|
||||
response->dontSendResponse = true; // will send it shortly
|
||||
return response;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if(tun->HasPathToService(llarp::service::Address(addr)))
|
||||
{
|
||||
llarp_dotlokilookup_checkQuery(qr, 0, 0);
|
||||
response->dontSendResponse = true; // will send it shortly
|
||||
return response;
|
||||
}
|
||||
}
|
||||
|
||||
// nslookup on osx is about 5 sec before a retry, 2s on linux
|
||||
request->context->client.logic->call_later(
|
||||
{2000, qr, &llarp_dotlokilookup_checkQuery});
|
||||
|
||||
response->dontSendResponse = true; // will send it shortly
|
||||
}
|
||||
return response;
|
||||
}
|
||||
|
|
@ -1,39 +0,0 @@
|
|||
#ifndef LLARP_DNS_DOTLOKILOOKUP_HPP
|
||||
#define LLARP_DNS_DOTLOKILOOKUP_HPP
|
||||
|
||||
#include <dnsd.hpp>
|
||||
#include <service/address.hpp>
|
||||
|
||||
using map_address_hook_func =
|
||||
std::function< bool(const byte_t *addr, bool isSNode, uint32_t ip) >;
|
||||
|
||||
/// dotLokiLookup context/config
|
||||
struct dotLokiLookup
|
||||
{
|
||||
/// for timers (MAYBEFIXME? maybe we decouple this, yes pls have a generic
|
||||
/// passed in)
|
||||
// we can use DNSc for access to the logic
|
||||
llarp::Logic *logic;
|
||||
|
||||
/// which ip tracker to use
|
||||
struct dns_iptracker *ip_tracker;
|
||||
|
||||
/// tunEndpoint
|
||||
// llarp::handlers::TunEndpoint *tunEndpoint; // is this even needed here?
|
||||
void *user; // well dotLokiLookup current uses it to access the tun if
|
||||
// pointer to tunendpoint properties?
|
||||
// llarp::service::Context *hiddenServiceContext;
|
||||
|
||||
// need a way to reference
|
||||
// 1. mapaddress
|
||||
map_address_hook_func map_address_handler;
|
||||
// std::function< bool(const llarp::service::Address &addr, uint32_t ip),
|
||||
// llarp::handlers::TunEndpoint * > callback;
|
||||
// 2. prefetch
|
||||
};
|
||||
|
||||
dnsd_query_hook_response *
|
||||
llarp_dotlokilookup_handler(std::string name,
|
||||
const dnsd_question_request *request);
|
||||
|
||||
#endif
|
||||
|
|
@ -1,197 +0,0 @@
|
|||
#include <dns/iptracker.hpp>
|
||||
|
||||
dns_iptracker g_dns_iptracker;
|
||||
|
||||
void
|
||||
dns_iptracker_init()
|
||||
{
|
||||
/*
|
||||
g_dns_iptracker.interfaces = llarp_getPrivateIfs();
|
||||
llarp::LogInfo("Interface uses 10.x.x.x? ",
|
||||
g_dns_iptracker.interfaces.ten ? "Yes" : "No");
|
||||
g_dns_iptracker.used_privates = g_dns_iptracker.interfaces;
|
||||
llarp::LogInfo("We used 10.x.x.x? ",
|
||||
g_dns_iptracker.used_privates.ten ? "Yes" : "No");
|
||||
*/
|
||||
|
||||
// disable all possibilities unless you setup a tunGateway
|
||||
|
||||
g_dns_iptracker.used_privates.ten = true;
|
||||
g_dns_iptracker.used_privates.oneSeven = true;
|
||||
g_dns_iptracker.used_privates.oneNine = true;
|
||||
}
|
||||
|
||||
// not sure we want tunGatewayIP... we'll know when we get further
|
||||
bool
|
||||
dns_iptracker_setup_dotLokiLookup(
|
||||
dotLokiLookup *dll, ABSL_ATTRIBUTE_UNUSED llarp::huint32_t tunGatewayIp)
|
||||
{
|
||||
dll->ip_tracker = &g_dns_iptracker;
|
||||
return true;
|
||||
}
|
||||
|
||||
// FIXME: pass in b32addr of client
|
||||
bool
|
||||
dns_iptracker_setup(dns_iptracker *iptracker, llarp::huint32_t tunGatewayIp)
|
||||
{
|
||||
if(!iptracker)
|
||||
iptracker = &g_dns_iptracker; // FIXME: god forgive I'm tired
|
||||
// struct in_addr *addr = tunGatewayIp.addr4();
|
||||
// unsigned char *ip = (unsigned char *)&(addr->s_addr);
|
||||
unsigned char *ip = (unsigned char *)&(tunGatewayIp.h);
|
||||
/*
|
||||
llarp::LogInfo("iptracker setup: (", std::to_string(ip[0]), ").[",
|
||||
std::to_string(ip[1]), '.', std::to_string(ip[2]), "].",
|
||||
std::to_string(ip[3]));
|
||||
*/
|
||||
std::unique_ptr< ip_range > range(new ip_range);
|
||||
range->octet2 = ip[1]; // 2nd octet
|
||||
range->octet3 = ip[2]; // 3rd octet
|
||||
// FIXME: look up any static mappings to discount
|
||||
range->left = 252;
|
||||
// 4th octet, probably 1, set it
|
||||
struct dns_pointer *result = new dns_pointer;
|
||||
result->hostResult = tunGatewayIp;
|
||||
// tunGatewayIp.CopyInto(result->hostResult);
|
||||
// result->b32addr = ; // FIXME: should be our HS addr
|
||||
range->used[ip[3]] = result; // claim tun IP
|
||||
|
||||
// save tun range in tracker
|
||||
// FIXME: forcing one and only one range
|
||||
if(ip[0] == 10)
|
||||
{
|
||||
iptracker->used_ten_ips.push_back(std::move(range));
|
||||
iptracker->used_privates.ten = false;
|
||||
}
|
||||
else if(ip[0] == 172)
|
||||
{
|
||||
iptracker->used_seven_ips.push_back(std::move(range));
|
||||
iptracker->used_privates.oneSeven = false;
|
||||
}
|
||||
else if(ip[0] == 192)
|
||||
{
|
||||
iptracker->used_nine_ips.push_back(std::move(range));
|
||||
iptracker->used_privates.oneNine = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
inline struct dns_pointer *
|
||||
dns_iptracker_allocate_range(std::unique_ptr< ip_range > &range, uint8_t first)
|
||||
{
|
||||
// we have an IP
|
||||
llarp::LogDebug("Range has ", (unsigned int)range->left, " ips left");
|
||||
range->left--; // use it up
|
||||
struct dns_pointer *result = new dns_pointer;
|
||||
llarp::Addr ip(first, range->octet2, range->octet3,
|
||||
range->left + 2); // why plus 2? to start at .2
|
||||
llarp::LogDebug("Allocated ", ip);
|
||||
// result->hostResult = new sockaddr;
|
||||
// ip.CopyInto(result->hostResult);
|
||||
result->hostResult = ip.xtohl();
|
||||
|
||||
// make an address and place into this sockaddr
|
||||
range->used[range->left + 2] = result;
|
||||
return result;
|
||||
}
|
||||
|
||||
struct dns_pointer *
|
||||
dns_iptracker_check_range(std::vector< std::unique_ptr< ip_range > > &ranges,
|
||||
uint8_t first)
|
||||
{
|
||||
// tens not all used up
|
||||
if(ranges.size())
|
||||
{
|
||||
// FIXME: maybe find_if where left not 0
|
||||
// find a range
|
||||
for(auto it = ranges.begin(); it != ranges.end(); ++it)
|
||||
{
|
||||
if((*it)->left)
|
||||
{
|
||||
struct dns_pointer *result = dns_iptracker_allocate_range(*it, first);
|
||||
if(!(*it)->left)
|
||||
{
|
||||
// all used up
|
||||
// FIXME: are there any more octets available?
|
||||
}
|
||||
return result;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// create one
|
||||
std::unique_ptr< ip_range > new_range(new ip_range);
|
||||
new_range->octet2 = 0;
|
||||
switch(first)
|
||||
{
|
||||
case 172:
|
||||
{
|
||||
// FIXME: goes up to 31...
|
||||
new_range->octet2 = 16;
|
||||
break;
|
||||
}
|
||||
case 192:
|
||||
{
|
||||
new_range->octet2 = 168;
|
||||
break;
|
||||
}
|
||||
}
|
||||
new_range->octet3 = 0; // FIXME: counter (0-255)
|
||||
// CHECK: planning a /24 but maybe that's too wide for broadcasts
|
||||
new_range->left = 252; // 0 is net, 1 is gw, 255 is broadcast
|
||||
ranges.push_back(std::move(new_range));
|
||||
// don't need to check if we're out since this is fresh range
|
||||
return dns_iptracker_allocate_range(ranges[0], first);
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
struct dns_pointer *
|
||||
dns_iptracker_get_free()
|
||||
{
|
||||
return dns_iptracker_get_free(&g_dns_iptracker);
|
||||
}
|
||||
|
||||
struct dns_pointer *
|
||||
dns_iptracker_get_free(dns_iptracker *iptracker)
|
||||
{
|
||||
llarp::LogInfo("Was 10.x.x.x already in-use on start? ",
|
||||
iptracker->used_privates.ten ? "Yes" : "No");
|
||||
if(!iptracker->used_privates.ten)
|
||||
{
|
||||
struct dns_pointer *test =
|
||||
dns_iptracker_check_range(iptracker->used_ten_ips, 10);
|
||||
if(test)
|
||||
{
|
||||
return test;
|
||||
}
|
||||
}
|
||||
llarp::LogInfo("Was 172.16.x.x already in-use on start? ",
|
||||
iptracker->used_privates.oneSeven ? "Yes" : "No");
|
||||
if(!iptracker->used_privates.oneSeven)
|
||||
{
|
||||
struct dns_pointer *test =
|
||||
dns_iptracker_check_range(iptracker->used_seven_ips, 172);
|
||||
if(test)
|
||||
{
|
||||
return test;
|
||||
}
|
||||
}
|
||||
llarp::LogInfo("Was 192.168.x.x already in-use on start? ",
|
||||
iptracker->used_privates.oneNine ? "Yes" : "No");
|
||||
if(!iptracker->used_privates.oneNine)
|
||||
{
|
||||
struct dns_pointer *test =
|
||||
dns_iptracker_check_range(iptracker->used_nine_ips, 192);
|
||||
if(test)
|
||||
{
|
||||
return test;
|
||||
}
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
|
@ -1,56 +0,0 @@
|
|||
#ifndef LLARP_DNSIPTRACKER_HPP
|
||||
#define LLARP_DNSIPTRACKER_HPP
|
||||
|
||||
#include <dns/dotlokilookup.hpp>
|
||||
#include <net/net.hpp>
|
||||
#include <service/address.hpp>
|
||||
|
||||
#include <map>
|
||||
#include <vector>
|
||||
|
||||
// either a request or response?
|
||||
// neither, it's a result set row
|
||||
struct dns_pointer
|
||||
{
|
||||
llarp::huint32_t hostResult;
|
||||
llarp::service::Address b32addr;
|
||||
// we could store the timeout at which we expect it to be available
|
||||
// or a list of pending requests for it
|
||||
};
|
||||
|
||||
struct ip_range
|
||||
{
|
||||
uint8_t octet2;
|
||||
uint8_t octet3;
|
||||
uint8_t left;
|
||||
std::unordered_map< uint8_t, dns_pointer * > used;
|
||||
};
|
||||
|
||||
struct dns_iptracker
|
||||
{
|
||||
struct privatesInUse interfaces;
|
||||
struct privatesInUse used_privates;
|
||||
std::vector< std::unique_ptr< ip_range > > used_ten_ips;
|
||||
std::vector< std::unique_ptr< ip_range > > used_seven_ips;
|
||||
std::vector< std::unique_ptr< ip_range > > used_nine_ips;
|
||||
// make it easier to find a entry
|
||||
std::vector< std::unique_ptr< dns_pointer > > map;
|
||||
};
|
||||
|
||||
void
|
||||
dns_iptracker_init();
|
||||
|
||||
bool
|
||||
dns_iptracker_setup_dotLokiLookup(dotLokiLookup *dll,
|
||||
llarp::huint32_t tunGatewayIp);
|
||||
|
||||
bool
|
||||
dns_iptracker_setup(dns_iptracker *iptracker, llarp::huint32_t tunGatewayIp);
|
||||
|
||||
struct dns_pointer *
|
||||
dns_iptracker_get_free();
|
||||
|
||||
struct dns_pointer *
|
||||
dns_iptracker_get_free(dns_iptracker *iptracker);
|
||||
|
||||
#endif
|
||||
|
|
@ -52,9 +52,9 @@ namespace llarp
|
|||
private:
|
||||
AbstractRouter *m_Router;
|
||||
std::unordered_map< std::string,
|
||||
std::unique_ptr< llarp::handlers::ExitEndpoint > >
|
||||
std::shared_ptr< llarp::handlers::ExitEndpoint > >
|
||||
m_Exits;
|
||||
std::list< std::unique_ptr< llarp::handlers::ExitEndpoint > > m_Closed;
|
||||
std::list< std::shared_ptr< llarp::handlers::ExitEndpoint > > m_Closed;
|
||||
};
|
||||
} // namespace exit
|
||||
} // namespace llarp
|
||||
|
|
|
|||
|
|
@ -282,7 +282,7 @@ namespace llarp
|
|||
size_t counter = 0;
|
||||
context->ForEachService(
|
||||
[&](const std::string &,
|
||||
const std::unique_ptr< service::Endpoint > &service) -> bool {
|
||||
const std::shared_ptr< service::Endpoint > &service) -> bool {
|
||||
service::Address addr = service->GetIdentity().pub.Addr();
|
||||
msg.AddCNAMEReply(addr.ToString(), 1);
|
||||
++counter;
|
||||
|
|
@ -314,7 +314,7 @@ namespace llarp
|
|||
size_t counter = 0;
|
||||
context->ForEachService(
|
||||
[&](const std::string &,
|
||||
const std::unique_ptr< service::Endpoint > &service) -> bool {
|
||||
const std::shared_ptr< service::Endpoint > &service) -> bool {
|
||||
huint32_t ip = service->GetIfAddr();
|
||||
if(ip.h)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -1073,13 +1073,9 @@ namespace llarp
|
|||
ServiceNodeLookupRouterWhenExpired(remote);
|
||||
return;
|
||||
}
|
||||
auto ep = hiddenServiceContext().getFirstEndpoint();
|
||||
if(ep == nullptr)
|
||||
{
|
||||
LogError("cannot lookup ", remote, " no service endpoints available");
|
||||
return;
|
||||
}
|
||||
ep->LookupRouterAnon(remote);
|
||||
_hiddenServiceContext.ForEachService([=](const std::string &, const std::shared_ptr<service::Endpoint> & ep) -> bool {
|
||||
return !ep->LookupRouterAnon(remote);
|
||||
});
|
||||
}
|
||||
|
||||
bool
|
||||
|
|
|
|||
|
|
@ -252,7 +252,7 @@ namespace llarp
|
|||
Response services = Response::array();
|
||||
auto visitor =
|
||||
[&](const std::string& name,
|
||||
const std::unique_ptr< service::Endpoint >& ptr) -> bool {
|
||||
const std::shared_ptr< service::Endpoint >& ptr) -> bool {
|
||||
numServices++;
|
||||
if(ptr->IsReady())
|
||||
numServicesReady++;
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@ namespace llarp
|
|||
void
|
||||
Context::ForEachService(
|
||||
std::function< bool(const std::string &,
|
||||
const std::unique_ptr< Endpoint > &) >
|
||||
const std::shared_ptr< Endpoint > &) >
|
||||
visit) const
|
||||
{
|
||||
auto itr = m_Endpoints.begin();
|
||||
|
|
@ -66,7 +66,7 @@ namespace llarp
|
|||
auto itr = m_Endpoints.find(name);
|
||||
if(itr == m_Endpoints.end())
|
||||
return false;
|
||||
std::unique_ptr< Endpoint > ep = std::move(itr->second);
|
||||
std::shared_ptr< Endpoint > ep = std::move(itr->second);
|
||||
m_Endpoints.erase(itr);
|
||||
ep->Stop();
|
||||
m_Stopped.emplace_back(std::move(ep));
|
||||
|
|
@ -96,20 +96,20 @@ namespace llarp
|
|||
++itr;
|
||||
}
|
||||
}
|
||||
|
||||
auto ep = getFirstEndpoint();
|
||||
if(!ep)
|
||||
return;
|
||||
std::vector< RouterID > expired;
|
||||
m_Router->nodedb()->visit([&](const RouterContact &rc) -> bool {
|
||||
if(rc.IsExpired(now))
|
||||
expired.emplace_back(rc.pubkey);
|
||||
return true;
|
||||
});
|
||||
// TODO: we need to stop looking up service nodes that are gone forever
|
||||
// how do?
|
||||
for(const auto &k : expired)
|
||||
ep->LookupRouterAnon(k);
|
||||
ForEachService([&](const std::string &, const std::shared_ptr<Endpoint> &ep) -> bool {
|
||||
// TODO: we need to stop looking up service nodes that are gone forever
|
||||
// how do?
|
||||
for(const auto &k : expired)
|
||||
if(!ep->LookupRouterAnon(k))
|
||||
return false;
|
||||
return true;
|
||||
});
|
||||
}
|
||||
|
||||
bool
|
||||
|
|
@ -118,68 +118,6 @@ namespace llarp
|
|||
return m_Endpoints.size() ? true : false;
|
||||
}
|
||||
|
||||
service::Endpoint *
|
||||
Context::getFirstEndpoint()
|
||||
{
|
||||
if(!m_Endpoints.size())
|
||||
{
|
||||
LogError("No endpoints found");
|
||||
return nullptr;
|
||||
}
|
||||
auto itr = m_Endpoints.begin();
|
||||
if(itr == m_Endpoints.end())
|
||||
return nullptr;
|
||||
return itr->second.get();
|
||||
}
|
||||
|
||||
bool
|
||||
Context::iterate(struct endpoint_iter &i)
|
||||
{
|
||||
if(!m_Endpoints.size())
|
||||
{
|
||||
LogError("No endpoints found");
|
||||
return false;
|
||||
}
|
||||
i.index = 0;
|
||||
// util::Lock lock(access);
|
||||
auto itr = m_Endpoints.begin();
|
||||
while(itr != m_Endpoints.end())
|
||||
{
|
||||
i.endpoint = itr->second.get();
|
||||
if(!i.visit(&i))
|
||||
return false;
|
||||
// advance
|
||||
i.index++;
|
||||
itr++;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
handlers::TunEndpoint *
|
||||
Context::getFirstTun()
|
||||
{
|
||||
service::Endpoint *endpointer = this->getFirstEndpoint();
|
||||
if(!endpointer)
|
||||
{
|
||||
return nullptr;
|
||||
}
|
||||
handlers::TunEndpoint *tunEndpoint =
|
||||
static_cast< handlers::TunEndpoint * >(endpointer);
|
||||
return tunEndpoint;
|
||||
}
|
||||
|
||||
llarp_tun_io *
|
||||
Context::getRange()
|
||||
{
|
||||
handlers::TunEndpoint *tunEndpoint = this->getFirstTun();
|
||||
if(!tunEndpoint)
|
||||
{
|
||||
LogError("No tunnel endpoint found");
|
||||
return nullptr;
|
||||
}
|
||||
return &tunEndpoint->tunif;
|
||||
}
|
||||
|
||||
bool
|
||||
Context::FindBestAddressFor(const AlignedBuffer< 32 > &addr, bool isSNode,
|
||||
huint32_t &ip)
|
||||
|
|
@ -203,56 +141,6 @@ namespace llarp
|
|||
return false;
|
||||
}
|
||||
|
||||
bool
|
||||
Context::Prefetch(const service::Address &addr)
|
||||
{
|
||||
handlers::TunEndpoint *tunEndpoint = this->getFirstTun();
|
||||
if(!tunEndpoint)
|
||||
{
|
||||
LogError("No tunnel endpoint found");
|
||||
return false;
|
||||
}
|
||||
// HiddenServiceAddresslookup *lookup = new
|
||||
// HiddenServiceEndpoint(tunEndpoint, callback, addr,
|
||||
// tunEndpoint->GenTXID());
|
||||
return tunEndpoint->EnsurePathToService(
|
||||
addr,
|
||||
[](__attribute__((unused)) Address addr,
|
||||
__attribute__((unused)) void *ctx) {},
|
||||
10000);
|
||||
}
|
||||
|
||||
bool
|
||||
MapAddressAllIter(struct Context::endpoint_iter *endpointCfg)
|
||||
{
|
||||
Context::mapAddressAll_context *context =
|
||||
(Context::mapAddressAll_context *)endpointCfg->user;
|
||||
handlers::TunEndpoint *tunEndpoint =
|
||||
(handlers::TunEndpoint *)endpointCfg->endpoint;
|
||||
if(!tunEndpoint)
|
||||
{
|
||||
LogError("No tunnel endpoint found");
|
||||
return true; // still continue
|
||||
}
|
||||
return tunEndpoint->MapAddress(
|
||||
context->serviceAddr, context->localPrivateIpAddr.xtohl(), false);
|
||||
}
|
||||
|
||||
bool
|
||||
Context::MapAddressAll(const service::Address &addr,
|
||||
Addr &localPrivateIpAddr)
|
||||
{
|
||||
struct Context::mapAddressAll_context context;
|
||||
context.serviceAddr = addr;
|
||||
context.localPrivateIpAddr = localPrivateIpAddr;
|
||||
|
||||
struct Context::endpoint_iter i;
|
||||
i.user = &context;
|
||||
i.index = 0;
|
||||
i.visit = &MapAddressAllIter;
|
||||
return this->iterate(i);
|
||||
}
|
||||
|
||||
bool
|
||||
Context::AddDefaultEndpoint(
|
||||
const std::unordered_multimap< std::string, std::string > &opts)
|
||||
|
|
|
|||
|
|
@ -31,52 +31,17 @@ namespace llarp
|
|||
bool
|
||||
hasEndpoints();
|
||||
|
||||
/// DRY refactor
|
||||
service::Endpoint *
|
||||
getFirstEndpoint();
|
||||
|
||||
|
||||
bool
|
||||
FindBestAddressFor(const AlignedBuffer< 32 > &addr, bool isSNode,
|
||||
huint32_t &);
|
||||
|
||||
/// DRY refactor
|
||||
handlers::TunEndpoint *
|
||||
getFirstTun();
|
||||
|
||||
/// punch a hole to get ip range from first tun endpoint
|
||||
llarp_tun_io *
|
||||
getRange();
|
||||
|
||||
struct mapAddressAll_context
|
||||
{
|
||||
service::Address serviceAddr;
|
||||
Addr localPrivateIpAddr;
|
||||
};
|
||||
|
||||
struct endpoint_iter
|
||||
{
|
||||
void *user;
|
||||
service::Endpoint *endpoint;
|
||||
size_t index;
|
||||
bool (*visit)(struct endpoint_iter *);
|
||||
};
|
||||
|
||||
bool
|
||||
iterate(struct endpoint_iter &i);
|
||||
|
||||
/// function visitor returns false to prematurely break iteration
|
||||
void
|
||||
ForEachService(std::function< bool(const std::string &,
|
||||
const std::unique_ptr< Endpoint > &) >
|
||||
const Endpoint_ptr &) >
|
||||
visit) const;
|
||||
|
||||
/// hint at possible path usage and trigger building early
|
||||
bool
|
||||
Prefetch(const service::Address &addr);
|
||||
|
||||
bool
|
||||
MapAddressAll(const service::Address &addr, Addr &localPrivateIpAddr);
|
||||
|
||||
/// add default endpoint with options
|
||||
bool
|
||||
AddDefaultEndpoint(
|
||||
|
|
@ -96,9 +61,9 @@ namespace llarp
|
|||
|
||||
private:
|
||||
AbstractRouter *m_Router;
|
||||
std::unordered_map< std::string, std::unique_ptr< Endpoint > >
|
||||
std::unordered_map< std::string, std::shared_ptr< Endpoint > >
|
||||
m_Endpoints;
|
||||
std::list< std::unique_ptr< Endpoint > > m_Stopped;
|
||||
std::list< std::shared_ptr< Endpoint > > m_Stopped;
|
||||
};
|
||||
} // namespace service
|
||||
} // namespace llarp
|
||||
|
|
|
|||
|
|
@ -436,6 +436,9 @@ namespace llarp
|
|||
|
||||
std::unordered_map< Tag, CachedTagResult, Tag::Hash > m_PrefetchedTags;
|
||||
};
|
||||
|
||||
using Endpoint_ptr = std::shared_ptr<Endpoint>;
|
||||
|
||||
} // namespace service
|
||||
} // namespace llarp
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue