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

fix dns

Browse Source
pull/6/head^2
Jeff Becker 6 years ago
parent f48acbc23e
commit 4b748a29f3
5 changed files with 136 additions and 118 deletions
Show Stats Download Patch File Download Diff File

8
CMakeLists.txt
Unescape Escape View File

@ -19,6 +19,8 @@ else()
message(ERROR "The compiler ${CMAKE_CXX_COMPILER} has no C++11 support. Please use a different C++ compiler.")
endif()
set(THREAD_LIB pthread)
if(STATIC_LINK)
set(STATIC_LINK_LIBS c)
add_cflags("-static -Wl,--whole-archive -lpthread -Wl,--no-whole-archive")
@ -101,7 +103,7 @@ else()
)
endif()
set(LIBS ${SODIUM_LIB} pthread)
set(LIBS ${SODIUM_LIB} ${THREAD_LIB})
set(LIB llarp)
set(SHARED_LIB ${LIB})
@ -211,7 +213,6 @@ set(LIB_SRC
llarp/service.cpp
llarp/transit_hop.cpp
llarp/testnet.c
llarp/api/create_session.cpp
llarp/api/client.cpp
llarp/api/message.cpp
llarp/api/parser.cpp
@ -278,7 +279,7 @@ include_directories(llarp)
include_directories(include)
include_directories(vendor/cppbackport-master/lib)
include_directories(/usr/local/include)
#include_directories(/usr/local/include)
include_directories(${sodium_INCLUDE_DIR})
if(SHADOW)
@ -305,6 +306,7 @@ else()
add_library(${STATIC_LIB} STATIC ${LIB_SRC})
add_library(libbackport-static STATIC ${CPP_BACKPORT_SRC})
add_library(libllarpplatform-static STATIC ${LIB_PLATFORM_SRC})
target_link_libraries(libllarpplatform-static ${THREAD_LIB})
target_link_libraries(${STATIC_LIB} ${LIBS} libbackport-static libllarpplatform-static)
if(NOT WITH_SHARED)
target_link_libraries(${EXE} ${STATIC_LINK_LIBS} ${STATIC_LIB} libbackport-static libllarpplatform-static)

62
daemon/dns.cpp
Unescape Escape View File

@ -25,6 +25,7 @@ handle_signal(int sig)
int
main(int argc, char *argv[])
{
dns_context dns;
int code = 1;
llarp::LogInfo("Starting up server");
@ -40,59 +41,16 @@ main(int argc, char *argv[])
llarp_ev_loop_alloc(&netloop);
// configure main netloop
llarp_udp_io udp;
llarp::Addr p_addr;
sockaddr_in ip4addr;
sockaddr *addr = nullptr;
addr = (sockaddr *)&ip4addr;
llarp::Zero(addr, sizeof(ip4addr));
addr->sa_family = AF_INET;
// FIXME: make configureable
ip4addr.sin_port = htons(1053);
p_addr = *addr;
udp.user = nullptr;
udp.recvfrom = &llarp_handle_recvfrom;
llarp::LogDebug("bind DNS Server to ", addr);
if(llarp_ev_add_udp(netloop, &udp, p_addr) == -1)
if(!llarp_dns_init(&dns, netloop, "127.0.0.1", 1052))
{
llarp::LogError("failed to bind to ", addr);
return false;
llarp::LogError("failed to initialize dns subsystem");
return 1;
}
// singlethreaded
if(0)
{
llarp::LogInfo("singlethread start");
worker = llarp_init_same_process_threadpool();
logic = llarp_init_single_process_logic(worker);
llarp_ev_loop_run_single_process(netloop, worker, logic);
llarp::LogInfo("singlethread end");
}
else
{
llarp::LogInfo("multithreaded start");
// create 2 workers
worker = llarp_init_threadpool(2, "llarp-worker");
logic = llarp_init_logic();
auto netio = netloop;
int num_nethreads = 1;
std::vector< std::thread > netio_threads;
while(num_nethreads--)
{
netio_threads.emplace_back([netio]() { llarp_ev_loop_run(netio); });
#if(__APPLE__ && __MACH__)
#elif(__FreeBSD__)
pthread_set_name_np(netio_threads.back().native_handle(), "llarp-"
"netio");
#else
pthread_setname_np(netio_threads.back().native_handle(), "llarp-netio");
#endif
}
llarp_logic_mainloop(logic);
llarp::LogInfo("multithreaded end");
}
worker = llarp_init_same_process_threadpool();
logic = llarp_init_single_process_logic(worker);
llarp::LogInfo("running dns mainloop");
llarp_ev_loop_run_single_process(netloop, worker, logic);
llarp_ev_loop_free(&netloop);
}
else
@ -136,8 +94,8 @@ main(int argc, char *argv[])
continue;
llarp::LogInfo("Received Bytes ", nbytes);
raw_handle_recvfrom(&m_sockfd, (const struct sockaddr *)&clientAddress,
buffer, nbytes);
// raw_handle_recvfrom(&m_sockfd, (const struct sockaddr *)&clientAddress,
// buffer, nbytes);
}
}

115
include/llarp/dns.h
Unescape Escape View File

@ -4,50 +4,87 @@
#include <llarp/ev.h>
#include <sys/types.h> // for uint & ssize_t
/**
* dns.h
*
* dns client/server
*/
#ifdef __cplusplus
extern "C"
{
#endif
/**
* dns.h
*
* dns client/server
*/
#define DNC_BUF_SIZE 512
struct dns_query
{
uint16_t length;
char *url;
unsigned char request[DNC_BUF_SIZE];
uint16_t reqType;
};
struct dns_query
{
uint16_t length;
char *url;
unsigned char request[DNC_BUF_SIZE];
uint16_t reqType;
};
struct dns_client_request;
struct dns_client_request;
typedef void (*resolve_dns_hook_func)(dns_client_request *request,
struct sockaddr *);
typedef void (*resolve_dns_hook_func)(dns_client_request *request,
struct sockaddr *);
struct dns_client_request
{
/// sock type
void *sock;
/// customizeable (used for outer request)
void *user;
/// storage
dns_query query;
/// hook
resolve_dns_hook_func resolved;
};
struct sockaddr *
resolveHost(const char *url);
bool
llarp_resolve_host(struct llarp_ev_loop *, const char *url,
resolve_dns_hook_func resolved, void *user);
void
llarp_handle_recvfrom(struct llarp_udp_io *udp, const struct sockaddr *saddr,
const void *buf, ssize_t sz);
void
raw_handle_recvfrom(int *sockfd, const struct sockaddr *saddr, const void *buf,
ssize_t sz);
struct dns_client_request
{
/// sock type
void *sock;
/// customizeable (used for outer request)
void *user;
/// storage
dns_query query;
/// hook
resolve_dns_hook_func resolved;
};
// forward declare
struct dns_context;
/// returns true if the dns query was intercepted
typedef bool (*intercept_query_hook)(struct dns_context *, const dns_query *);
/// context for dns subsystem
struct dns_context
{
/// populated by llarp_dns_init
struct llarp_udp_io udp;
/// set by caller
void *user;
/// hook function for intercepting dns requests
intercept_query_hook intercept;
};
struct sockaddr *
resolveHost(const char *url);
/// initialize dns subsystem and bind socket
/// returns true on bind success otherwise returns false
bool
llarp_dns_init(struct dns_context *dns, struct llarp_ev_loop *loop,
const char *addr, uint16_t port);
/// async resolve hostname
bool
llarp_resolve_host(struct dns_context *dns, const char *url,
resolve_dns_hook_func resolved, void *user);
/*
// XXX: these should be internal and not exposed
void
llarp_handle_recvfrom(struct llarp_udp_io *udp, const struct sockaddr *saddr,
const void *buf, ssize_t sz);
void
raw_handle_recvfrom(int *sockfd, const struct sockaddr *saddr, const void
*buf, ssize_t sz);
*/
#ifdef __cplusplus
}
#endif
#endif

9
llarp/dnsc.cpp
Unescape Escape View File

@ -192,8 +192,8 @@ resolveHost(const char *url)
buffer[i + 2], buffer[i + 3]);
struct sockaddr *g_addr = new sockaddr;
g_addr->sa_family = AF_INET;
g_addr->sa_len = sizeof(in_addr);
struct in_addr *addr = &((struct sockaddr_in *)g_addr)->sin_addr;
// g_addr->sa_len = sizeof(in_addr);
struct in_addr *addr = &((struct sockaddr_in *)g_addr)->sin_addr;
unsigned char *ip;
// have ip point to s_addr
@ -336,8 +336,8 @@ llarp_handle_dnsclient_recvfrom(struct llarp_udp_io *udp,
buffer[i + 2], buffer[i + 3]);
struct sockaddr *g_addr = new sockaddr;
g_addr->sa_family = AF_INET;
g_addr->sa_len = sizeof(in_addr);
struct in_addr *addr = &((struct sockaddr_in *)g_addr)->sin_addr;
// g_addr->sa_len = sizeof(in_addr);
struct in_addr *addr = &((struct sockaddr_in *)g_addr)->sin_addr;
unsigned char *ip;
// have ip point to s_addr
@ -429,6 +429,7 @@ llarp_dns_resolve(dns_client_request *request)
llarp_udp_io *udp = (llarp_udp_io *)request->sock;
// llarp::LogDebug("dns client set to use ");
// XXX: udp user pointer should be set before binding to socket and once
udp->user = request;
// hexdump("sending packet", &dnsQuery.request, dnsQuery.length);

60
llarp/dnsd.cpp
Unescape Escape View File

@ -54,12 +54,12 @@ decode_hdr(const char *buffer)
void
code_domain(char *&buffer, const std::string &domain) throw()
{
int start(0), end; // indexes
std::string::size_type start(0), end; // indexes
// llarp::LogInfo("domain [", domain, "]");
while((end = domain.find('.', start)) != std::string::npos)
{
*buffer++ = end - start; // label length octet
for(int i = start; i < end; i++)
for(auto i = start; i < end; i++)
{
*buffer++ = domain[i]; // label octets
// llarp::LogInfo("Writing ", domain[i], " at ", i);
@ -70,7 +70,7 @@ code_domain(char *&buffer, const std::string &domain) throw()
// llarp::LogInfo("start ", start, " domain size ", domain.size());
*buffer++ = domain.size() - start; // last label length octet
for(int i = start; i < domain.size(); i++)
for(size_t i = start; i < domain.size(); i++)
{
*buffer++ = domain[i]; // last label octets
// llarp::LogInfo("Writing ", domain[i], " at ", i);
@ -222,20 +222,19 @@ handle_recvfrom(const char *buffer, ssize_t nbytes, const struct sockaddr *from,
}
else
{
llarp::Addr anIp;
struct llarp_udp_io *udp = (struct llarp_udp_io *)request->user;
// llarp::Addr anIp;
// struct llarp_udp_io *udp = (struct llarp_udp_io *)request->user;
// hostRes = llarp_resolveHost(udp->parent, m_qName.c_str());
llarp_resolve_host(udp->parent, m_qName.c_str(), &phase2, (void *)request);
// llarp_resolve_host(udp->parent, m_qName.c_str(), &phase2, (void
// *)request);
}
}
// this is called in net threadpool
void
llarp_handle_recvfrom(struct llarp_udp_io *udp, const struct sockaddr *saddr,
const void *buf, ssize_t sz)
handle_dns_recvfrom(struct llarp_udp_io *udp, const struct sockaddr *saddr,
const void *buf, ssize_t sz)
{
// llarp_link *link = static_cast< llarp_link * >(udp->user);
llarp::LogInfo("Received Bytes ", sz);
llarp::LogDebug("Received Bytes ", sz);
dns_request llarp_dns_request;
llarp_dns_request.from = (struct sockaddr *)saddr;
llarp_dns_request.user = (void *)udp;
@ -243,14 +242,35 @@ llarp_handle_recvfrom(struct llarp_udp_io *udp, const struct sockaddr *saddr,
handle_recvfrom((char *)buf, sz, saddr, &llarp_dns_request);
}
void
raw_handle_recvfrom(int *sockfd, const struct sockaddr *saddr, const void *buf,
ssize_t sz)
extern "C"
{
llarp::LogInfo("Received Bytes ", sz);
dns_request llarp_dns_request;
llarp_dns_request.from = (struct sockaddr *)saddr;
llarp_dns_request.user = (void *)sockfd;
llarp_dns_request.hook = &raw_sendto_dns_hook_func;
handle_recvfrom((char *)buf, sz, saddr, &llarp_dns_request);
bool
llarp_dns_init(struct dns_context *dns, struct llarp_ev_loop *mainloop,
const char *bindaddr, uint16_t bindport)
{
struct sockaddr_in srcaddr;
if(inet_pton(AF_INET, bindaddr, &srcaddr.sin_addr.s_addr) == -1)
return false;
srcaddr.sin_family = AF_INET;
srcaddr.sin_port = htons(bindport);
dns->udp.user = dns;
dns->udp.recvfrom = &handle_dns_recvfrom;
dns->udp.tick = nullptr;
return llarp_ev_add_udp(mainloop, &dns->udp, (const sockaddr *)&srcaddr)
!= -1;
}
// this is called in net threadpool
void
raw_handle_recvfrom(int *sockfd, const struct sockaddr *saddr,
const void *buf, ssize_t sz)
{
llarp::LogInfo("Received Bytes ", sz);
dns_request llarp_dns_request;
llarp_dns_request.from = (struct sockaddr *)saddr;
llarp_dns_request.user = (void *)sockfd;
llarp_dns_request.hook = &raw_sendto_dns_hook_func;
handle_recvfrom((char *)buf, sz, saddr, &llarp_dns_request);
}
}

Write Preview
Loading…
Cancel
Save