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

Merge branch 'master' of https://github.com/neuroscr/loki-network

This commit is contained in:
Ryan Tharp 2018-10-01 09:03:31 +00:00
parent 4158e422bb 79d61dedc3
commit 058ed4d4ea
13 changed files with 161 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
daemon/dns.cpp
View File

@ -103,7 +103,7 @@ main(int argc, char *argv[])
// llarp::SetLogLevel(llarp::eLogDebug);
if(1)
if(0)
{
// libev version w/router context
ctx = llarp_main_init(conffname, !TESTNET);
@ -116,9 +116,12 @@ main(int argc, char *argv[])
signal(SIGINT, handle_signal);
struct dnsd_context dnsd;
if(!llarp_main_init_dnsd(ctx, &dnsd, server_port,
(const char *)dnsr_config.upstream_host.c_str(),
dnsr_config.upstream_port))
llarp::Addr dnsd_sockaddr(127, 0, 0, 1, 53);
llarp::Addr dnsc_sockaddr(dnsr_config.upstream_host,
dnsr_config.upstream_port);
// server_port, (const char *)dnsr_config.upstream_host.c_str(),
// dnsr_config.upstream_port
if(!llarp_main_init_dnsd(ctx, &dnsd, dnsd_sockaddr, dnsc_sockaddr))
{
llarp::LogError("Couldnt init dns daemon");
}
@ -160,7 +163,7 @@ main(int argc, char *argv[])
llarp_main_run(ctx);
llarp_main_free(ctx);
}
else if(0)
else if(1)
{
// libev version
llarp_ev_loop *netloop = nullptr;
@ -173,9 +176,12 @@ main(int argc, char *argv[])
// configure main netloop
struct dnsd_context dnsd;
if(!llarp_dnsd_init(&dnsd, logic, netloop, "*", server_port,
(const char *)dnsr_config.upstream_host.c_str(),
dnsr_config.upstream_port))
llarp::Addr dnsd_sockaddr(127, 0, 0, 1, 53);
llarp::Addr dnsc_sockaddr(dnsr_config.upstream_host,
dnsr_config.upstream_port);
llarp::LogInfo("dnsd_sockaddr init: ", dnsd_sockaddr);
llarp::LogInfo("dnsc_sockaddr init: ", dnsc_sockaddr);
if(!llarp_dnsd_init(&dnsd, logic, netloop, dnsd_sockaddr, dnsc_sockaddr))
{
// llarp::LogError("failed to initialize dns subsystem");
llarp::LogError("Couldnt init dns daemon");
@ -200,9 +206,10 @@ main(int argc, char *argv[])
// configure main netloop
struct dnsd_context dnsd;
if(!llarp_dnsd_init(&dnsd, logic, nullptr, "*", server_port,
(const char *)dnsr_config.upstream_host.c_str(),
dnsr_config.upstream_port))
llarp::Addr dnsd_sockaddr(127, 0, 0, 1, 53);
llarp::Addr dnsc_sockaddr(dnsr_config.upstream_host,
dnsr_config.upstream_port);
if(!llarp_dnsd_init(&dnsd, logic, nullptr, dnsd_sockaddr, dnsc_sockaddr))
{
// llarp::LogError("failed to initialize dns subsystem");
llarp::LogError("Couldnt init dns daemon");

4
include/llarp.h
View File

@ -83,8 +83,8 @@ extern "C"
/// set up DNS libs with a context
bool
llarp_main_init_dnsd(struct llarp_main *ptr, struct dnsd_context *dnsd,
uint16_t server_port, const char *upstream_host,
uint16_t upstream_port);
const llarp::Addr &dnsd_sockaddr,
const llarp::Addr &dnsc_sockaddr);
/// set up dotLokiLookup with logic for setting timers
bool

3
include/llarp/dns_iptracker.hpp
View File

@ -11,8 +11,11 @@
// neither, it's a result set row
struct dns_pointer
{
// FIXME change to llarp::Addr
struct sockaddr *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

11
include/llarp/dnsc.hpp
View File

@ -47,10 +47,9 @@ raw_handle_recvfrom(int *sockfd, const struct sockaddr *addr, const void *buf,
/// DNS client context (one needed per upstream DNS server)
struct dnsc_context
{
/// Target: DNS server hostname/port to use
// FIXME: ipv6 it & make it a vector
sockaddr *server;
/// tracker
/// Target: DNS servers to use
std::vector< llarp::Addr > resolvers;
/// udp tracker
struct dns_tracker *tracker;
/// sock type
void *sock;
@ -78,8 +77,8 @@ llarp_host_resolved(dnsc_answer_request *request);
/// returns true on bind success otherwise returns false
bool
llarp_dnsc_init(struct dnsc_context *dnsc, struct llarp_logic *logic,
struct llarp_udp_io *udp, const char *dnsc_hostname,
uint16_t dnsc_port);
struct llarp_ev_loop *netloop,
const llarp::Addr &dnsc_sockaddr);
/// shutdowns any events, and deallocates for this context
bool

13
include/llarp/dnsd.hpp
View File

@ -12,6 +12,7 @@ struct dnsd_context;
/// sendto hook functor
typedef ssize_t (*sendto_dns_hook_func)(void *sock, const struct sockaddr *from,
const void *buffer, size_t length);
// FIXME: llarp::Addr
/// DNS server query request
struct dnsd_question_request
@ -25,7 +26,7 @@ struct dnsd_question_request
/// question being asked
dns_msg_question question;
// request source socket
struct sockaddr *from;
struct sockaddr *from; // FIXME: convert to llarp::Addr
sendto_dns_hook_func sendto_hook; // sendto hook tbh
// maybe a reference to dnsd_context incase of multiple
dnsd_context *context; // or you can access it via user (udp)
@ -40,13 +41,14 @@ struct dnsd_query_hook_response
/// turn off recursion
bool dontLookUp;
/// potential address
sockaddr *returnThis;
sockaddr *returnThis; // FIXME: llarp::Addr
};
/// intercept query hook functor
typedef dnsd_query_hook_response *(*intercept_query_hook)(
std::string name, const struct sockaddr *from,
struct dnsd_question_request *request);
// FIXME: llarp::Addr
/// DNS Server context
struct dnsd_context
@ -73,18 +75,19 @@ llarp_handle_dnsd_recvfrom(struct llarp_udp_io *udp,
void
writecname_dnss_response(std::string cname, const struct sockaddr *from,
dnsd_question_request *request);
// FIXME: llarp::Addr
void
writesend_dnss_response(struct sockaddr *hostRes, const struct sockaddr *from,
dnsd_question_request *request);
// FIXME: llarp::Addr
/// initialize dns subsystem and bind socket
/// returns true on bind success otherwise returns false
bool
llarp_dnsd_init(struct dnsd_context *dnsd, struct llarp_logic *logic,
struct llarp_ev_loop *netloop, const char *dnsd_ifname,
uint16_t dnsd_port, const char *dnsc_hostname,
uint16_t dnsc_port);
struct llarp_ev_loop *netloop, const llarp::Addr &dnsd_sockaddr,
const llarp::Addr &dnsc_sockaddr);
/// shutdowns any events, and deallocates for this context
bool

1
include/llarp/ev.h
View File

@ -59,6 +59,7 @@ struct llarp_udp_io
struct llarp_ev_loop *parent;
/// called every event loop tick after reads
void (*tick)(struct llarp_udp_io *);
// sockaddr * is the source
void (*recvfrom)(struct llarp_udp_io *, const struct sockaddr *, const void *,
ssize_t);
};

48
include/llarp/net.hpp
View File

@ -93,7 +93,19 @@ namespace llarp
return (const in_addr*)&_addr.sin6_addr.s6_addr[12];
}
Addr(const char* str)
Addr(const std::string str)
{
this->from_char_array(str.c_str());
}
Addr(const std::string str, const uint16_t p_port)
{
this->from_char_array(str.c_str());
this->port(p_port);
}
bool
from_char_array(const char* str)
{
llarp::Zero(&_addr, sizeof(sockaddr_in6));
struct addrinfo hint, *res = NULL;
@ -108,25 +120,25 @@ namespace llarp
if(ret)
{
llarp::LogError("failed to determine address family: ", str);
return;
return false;
}
if(res->ai_family == AF_INET6)
{
llarp::LogError("IPv6 address not supported yet", str);
return;
return false;
}
else if(res->ai_family != AF_INET)
{
llarp::LogError("Address family not supported yet", str);
return;
return false;
}
struct in_addr* addr = &_addr4.sin_addr;
if(inet_aton(str, addr) == 0)
{
llarp::LogError("failed to parse ", str);
return;
return false;
}
_addr.sin6_family = res->ai_family;
@ -141,10 +153,17 @@ namespace llarp
addrptr[10] = 0xff;
memcpy(12 + addrptr, &addr->s_addr, sizeof(in_addr));
freeaddrinfo(res);
return true;
}
Addr(const uint8_t one, const uint8_t two, const uint8_t three,
const uint8_t four)
Addr(const char* str)
{
this->from_char_array(str);
}
bool
from_4int(const uint8_t one, const uint8_t two, const uint8_t three,
const uint8_t four)
{
llarp::Zero(&_addr, sizeof(sockaddr_in6));
struct in_addr* addr = &_addr4.sin_addr;
@ -157,6 +176,7 @@ namespace llarp
#if((__APPLE__ && __MACH__) || __FreeBSD__)
_addr4.sin_len = sizeof(in_addr);
#endif
// FIXME: watch endian
ip[0] = one;
ip[1] = two;
ip[2] = three;
@ -166,6 +186,20 @@ namespace llarp
addrptr[11] = 0xff;
addrptr[10] = 0xff;
memcpy(12 + addrptr, &addr->s_addr, sizeof(in_addr));
return true;
}
Addr(const uint8_t one, const uint8_t two, const uint8_t three,
const uint8_t four)
{
this->from_4int(one, two, three, four);
}
Addr(const uint8_t one, const uint8_t two, const uint8_t three,
const uint8_t four, const uint16_t p_port)
{
this->from_4int(one, two, three, four);
this->port(p_port);
}
Addr(const AddressInfo& other)

10
llarp/context.cpp
View File

@ -336,11 +336,11 @@ extern "C"
bool
llarp_main_init_dnsd(struct llarp_main *ptr, struct dnsd_context *dnsd,
uint16_t server_port, const char *upstream_host,
uint16_t upstream_port)
const llarp::Addr &dnsd_sockaddr,
const llarp::Addr &dnsc_sockaddr)
{
return llarp_dnsd_init(dnsd, ptr->ctx->logic, ptr->ctx->mainloop, "*",
server_port, upstream_host, upstream_port);
return llarp_dnsd_init(dnsd, ptr->ctx->logic, ptr->ctx->mainloop,
dnsd_sockaddr, dnsc_sockaddr);
}
bool
@ -392,7 +392,7 @@ extern "C"
llarp_config_iter(ctx->config, &iter);
*/
// llarp_rc *rc = new llarp_rc;
llarp::RouterContact *rc = new llarp::RouterContact;
// llarp::RouterContact *rc = new llarp::RouterContact;
// llarp_rc_new(rc);
// llarp::LogInfo("FIXME: Loading ", ptr->ctx->conatctFile);
// FIXME

9
llarp/dns_dotlokilookup.cpp
View File

@ -73,11 +73,6 @@ llarp_dotlokilookup_checkQuery(void *u, uint64_t orig, uint64_t left)
llarp::handlers::TunEndpoint *tunEndpoint =
(llarp::handlers::TunEndpoint *)dll->user;
bool mapResult = tunEndpoint->MapAddress(addr, ntohl(ip_address.s_addr));
/*
bool mapResult = main_router_mapAddress(
ctx, addr,
ntohl(ip_address.s_addr)); // maybe ntohl on the s_addr
*/
if(!mapResult)
{
delete qr;
@ -139,10 +134,10 @@ llarp_dotlokilookup_handler(std::string name, const struct sockaddr *from,
if(!addr.FromString(lName))
{
llarp::LogWarn("Could not base32 decode address");
response->dontSendResponse = true;
response->dontLookUp = true; // will return nullptr which will give a 404
return response;
}
llarp::LogInfo("Got address ", addr);
llarp::LogDebug("Base32 decoded address ", addr);
// start path build early (if you're looking it up, you're probably going to
// use it)

61
llarp/dnsc.cpp
View File

@ -94,7 +94,7 @@ dns_query *
answer_request_alloc(struct dnsc_context *dnsc, void *sock, const char *url,
dnsc_answer_hook_func resolved, void *user)
{
dnsc_answer_request *request = new dnsc_answer_request;
std::unique_ptr< dnsc_answer_request > request(new dnsc_answer_request);
if(!request)
{
llarp::LogError("Couldn't make dnsc request");
@ -123,14 +123,23 @@ answer_request_alloc(struct dnsc_context *dnsc, void *sock, const char *url,
// register our self with the tracker
dns_tracker *tracker = request->context->tracker;
uint16_t id = ++tracker->c_requests;
if(!tracker)
{
llarp::LogError("no tracker in DNSc context");
return nullptr;
}
uint16_t id = ++tracker->c_requests;
if(id == 65535)
id = 0;
tracker->client_request[id] = std::unique_ptr< dnsc_answer_request >(request);
// conflict: do we need this?
//tracker->client_request[id] = std::unique_ptr< dnsc_answer_request >(request);
dns_query *dns_packet = build_dns_packet(
(char *)request->question.name.c_str(), id, request->question.type);
tracker->client_request[id] = std::move(request);
return dns_packet;
}
@ -306,7 +315,7 @@ generic_handle_dnsc_recvfrom(dnsc_answer_request *request,
MSGID = (uint16_t)buffer[0] * 0x100 + buffer[1];
// llarp::LogDebug("answer msg id: %u\n", MSGID);
*/
llarp::Addr upstreamAddr(*request->context->server);
llarp::Addr upstreamAddr = request->context->resolvers[0];
if(answer == nullptr)
{
@ -390,7 +399,7 @@ generic_handle_dnsc_recvfrom(dnsc_answer_request *request,
}
else if(request->question.type == 12)
{
llarp::LogInfo("Resolving PTR");
llarp::LogDebug("Resolving PTR");
request->found = true;
request->revDNS = std::string((char *)answer->rData);
request->resolved(request);
@ -411,7 +420,7 @@ raw_resolve_host(struct dnsc_context *dnsc, const char *url,
}
// char *word;
llarp::Addr upstreamAddr(*dnsc->server);
llarp::Addr upstreamAddr = dnsc->resolvers[0];
llarp::LogDebug("Asking DNS server ", upstreamAddr, " about ", url);
struct sockaddr_in addr;
@ -432,7 +441,7 @@ raw_resolve_host(struct dnsc_context *dnsc, const char *url,
return;
}
// socket = sockfd;
sockaddr_in *dnscSock = ((sockaddr_in *)dnsc->server);
sockaddr_in *dnscSock = ((sockaddr_in *)dnsc->resolvers[0].addr4());
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
@ -522,6 +531,7 @@ bool
llarp_resolve_host(struct dnsc_context *dnsc, const char *url,
dnsc_answer_hook_func resolved, void *user)
{
// FIXME: probably can be stack allocated
dns_query *dns_packet =
answer_request_alloc(dnsc, &dnsc->udp, url, resolved, user);
if(!dns_packet)
@ -571,7 +581,7 @@ llarp_resolve_host(struct dnsc_context *dnsc, const char *url,
// bytes");
// ssize_t ret = llarp_ev_udp_sendto(dnsc->udp, dnsc->server, bytes, length);
ssize_t ret = llarp_ev_udp_sendto(dnsc->udp, dnsc->server,
ssize_t ret = llarp_ev_udp_sendto(dnsc->udp, dnsc->resolvers[0],
dns_packet->request, dns_packet->length);
delete dns_packet;
if(ret < 0)
@ -599,28 +609,39 @@ llarp_host_resolved(dnsc_answer_request *request)
{
llarp::LogWarn("Couldn't disable ", request);
}
// delete request;
}
bool
llarp_dnsc_init(struct dnsc_context *dnsc, struct llarp_logic *logic,
struct llarp_udp_io *udp, const char *dnsc_hostname,
uint16_t dnsc_port)
struct llarp_ev_loop *netloop, const llarp::Addr &dnsc_sockaddr)
{
sockaddr_in *trgaddr = new sockaddr_in;
trgaddr->sin_addr.s_addr = inet_addr(dnsc_hostname);
trgaddr->sin_port = htons(dnsc_port);
trgaddr->sin_family = AF_INET;
dnsc->server = (sockaddr *)trgaddr;
dnsc->udp = udp;
dnsc->tracker = &dns_udp_tracker;
dnsc->logic = logic;
// create client socket
if(netloop)
{
if(!dnsc->udp)
{
llarp::LogError("DNSc udp isn't set");
return false;
}
llarp::Addr dnsc_srcsockaddr(0, 0, 0, 0, 0); // just find a public udp port
int bind_res = llarp_ev_add_udp(netloop, dnsc->udp,
(const sockaddr *)dnsc_srcsockaddr);
if(bind_res == -1)
{
llarp::LogError("Couldn't bind to ", dnsc_srcsockaddr);
return false;
}
}
llarp::LogInfo("DNSc adding relay ", dnsc_sockaddr);
dnsc->resolvers.push_back(dnsc_sockaddr);
dnsc->tracker = &dns_udp_tracker;
dnsc->logic = logic;
return true;
}
bool
llarp_dnsc_stop(struct dnsc_context *dnsc)
{
delete(sockaddr_in *)dnsc->server; // deallocation
// delete(sockaddr_in *)dnsc->server; // deallocation
return true;
}

46
llarp/dnsd.cpp
View File

@ -15,11 +15,7 @@ raw_sendto_dns_hook_func(void *sock, const struct sockaddr *from,
int *fd = (int *)sock;
// how do we get to these??
socklen_t addrLen = sizeof(struct sockaddr_in);
#ifdef _WIN32
return sendto(*fd, (const char *)buffer, length, 0, from, addrLen);
#else
return sendto(*fd, (const char *)buffer, length, 0, from, addrLen);
#endif
}
ssize_t
@ -433,14 +429,26 @@ raw_handle_recvfrom(int *sockfd, const struct sockaddr *saddr, const void *buf,
bool
llarp_dnsd_init(struct dnsd_context *dnsd, struct llarp_logic *logic,
struct llarp_ev_loop *netloop, const char *dnsd_ifname,
uint16_t dnsd_port, const char *dnsc_hostname,
uint16_t dnsc_port)
struct llarp_ev_loop *netloop, const llarp::Addr &dnsd_sockaddr,
const llarp::Addr &dnsc_sockaddr)
{
struct sockaddr_in bindaddr;
bindaddr.sin_addr.s_addr = inet_addr("0.0.0.0");
// struct sockaddr_in bindaddr;
/*
llarp::Addr dnsd_addr;
bool ifRes = GetIFAddr(std::string(dnsd_ifname), dnsd_addr, AF_INET);
if (!ifRes)
{
llarp::LogError("Couldn't init dns server, can't resolve interface: ",
dnsd_ifname); return false;
}
llarp::LogInfo("DNSd interface ip ", dnsd_addr);
*/
/*
bindaddr.sin_addr.s_addr = inet_addr("127.0.0.1"); // network byte
bindaddr.sin_family = AF_INET;
bindaddr.sin_port = htons(dnsd_port);
*/
dnsd->udp.user = &dns_udp_tracker;
dnsd->udp.recvfrom = &llarp_handle_dns_recvfrom;
@ -448,13 +456,18 @@ llarp_dnsd_init(struct dnsd_context *dnsd, struct llarp_logic *logic,
dns_udp_tracker.dnsd = dnsd;
dnsd->tracker = &dns_udp_tracker; // register global tracker with context
// dnsd->logic = logic; // set logic worker for timers
dnsd->intercept = nullptr; // set default intercepter
dnsd->tracker = &dns_udp_tracker; // register global tracker with context
dnsd->intercept = nullptr; // set default intercepter
// set up fresh socket
dnsd->client.udp = new llarp_udp_io;
dnsd->client.udp->user = &dns_udp_tracker;
dnsd->client.udp->recvfrom = &llarp_handle_dns_recvfrom;
dnsd->client.udp->tick = nullptr;
// configure dns client
if(!llarp_dnsc_init(&dnsd->client, logic, &dnsd->udp, dnsc_hostname,
dnsc_port))
// llarp::LogInfo("DNSd setting relay to ", dnsc_sockaddr);
if(!llarp_dnsc_init(&dnsd->client, logic, netloop, dnsc_sockaddr))
{
llarp::LogError("Couldnt init dns client");
return false;
@ -462,8 +475,9 @@ llarp_dnsd_init(struct dnsd_context *dnsd, struct llarp_logic *logic,
if(netloop)
{
llarp::LogInfo("DNSd binding to port 53");
return llarp_ev_add_udp(netloop, &dnsd->udp, (const sockaddr *)&bindaddr)
llarp::LogInfo("DNSd binding to ", dnsd_sockaddr);
return llarp_ev_add_udp(netloop, &dnsd->udp,
(const sockaddr *)dnsd_sockaddr)
!= -1;
}
else

1
llarp/ev_kqueue.hpp
View File

@ -43,6 +43,7 @@ namespace llarp
ssize_t ret = ::recvfrom(fd, buf, sz, 0, addr, &slen);
if(ret == -1)
return -1;
// Addr is the source
udp->recvfrom(udp, addr, buf, ret);
return 0;
}

5
llarp/handlers/tun.cpp
View File

@ -249,8 +249,11 @@ namespace llarp
#ifndef _WIN32
m_TunSetupResult.set_value(result);
#endif
llarp::Addr dnsd_sockaddr(127, 0, 0, 1, DNS_PORT);
llarp::Addr dnsc_sockaddr(8, 8, 8, 8, 53);
llarp::LogInfo("TunDNS set up ", dnsd_sockaddr, " to ", dnsc_sockaddr);
if(!llarp_dnsd_init(&this->dnsd, EndpointLogic(), EndpointNetLoop(),
tunif.ifname, DNS_PORT, "8.8.8.8", 53))
dnsd_sockaddr, dnsc_sockaddr))
{
llarp::LogError("Couldnt init dns daemon");
}