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

clang-format (finally :)

This commit is contained in:
Ryan Tharp 2018-07-21 06:24:47 -07:00
parent 2ac5f2d245
commit a9e8584acd
6 changed files with 532 additions and 440 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

82
daemon/dns.cpp
View File

@ -1,15 +1,15 @@
#include <signal.h>
#include <getopt.h>
#include <stdio.h> /* fprintf, printf */
#include <signal.h>
#include <stdio.h> /* fprintf, printf */
#include "net.hpp"
#include "logger.hpp"
#include "ev.hpp"
#include <llarp/logic.h>
#include "dnsd.hpp"
#include "ev.hpp"
#include "logger.hpp"
#include "net.hpp"
#include <thread> // for multithreaded version
#include <vector>
#include <thread> // for multithreaded version
bool done = false;
@ -30,30 +30,30 @@ main(int argc, char *argv[])
int code = 1;
llarp::LogInfo("Starting up server");
//bllarp::SetLogLevel(llarp::eLogDebug);
if (1)
// bllarp::SetLogLevel(llarp::eLogDebug);
if(1)
{
// libev version
llarp_ev_loop *netloop = nullptr;
llarp_ev_loop *netloop = nullptr;
llarp_threadpool *worker = nullptr;
llarp_logic *logic = nullptr;
llarp_ev_loop_alloc(&netloop);
struct dnsd_context dnsd;
if (!llarp_dnsd_init(&dnsd, netloop, "*", 1053, SERVER, PORT))
if(!llarp_dnsd_init(&dnsd, netloop, "*", 1053, SERVER, PORT))
{
llarp::LogError("Couldnt init dns daemon");
return 0;
}
// singlethreaded
if (0)
if(0)
{
llarp::LogInfo("singlethread start");
worker = llarp_init_same_process_threadpool();
logic = llarp_init_single_process_logic(worker);
logic = llarp_init_single_process_logic(worker);
llarp_ev_loop_run_single_process(netloop, worker, logic);
llarp::LogInfo("singlethread end");
}
@ -61,17 +61,18 @@ main(int argc, char *argv[])
{
uint num_llarpworkers = 2;
uint num_nethreads = 8;
llarp::LogInfo("multithreaded start with ", num_llarpworkers, " llarp-workers and ", num_nethreads, " networkers");
llarp::LogInfo("multithreaded start with ", num_llarpworkers,
" llarp-workers and ", num_nethreads, " networkers");
// create workers
worker = llarp_init_threadpool(num_llarpworkers, "llarp-worker");
logic = llarp_init_logic();
worker = llarp_init_threadpool(num_llarpworkers, "llarp-worker");
logic = llarp_init_logic();
auto netio = netloop;
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");
@ -86,44 +87,47 @@ main(int argc, char *argv[])
}
else
{
struct sockaddr_in m_address;
int m_sockfd;
m_sockfd = socket(AF_INET, SOCK_DGRAM, 0);
m_address.sin_family = AF_INET;
m_sockfd = socket(AF_INET, SOCK_DGRAM, 0);
m_address.sin_family = AF_INET;
m_address.sin_addr.s_addr = INADDR_ANY;
m_address.sin_port = htons(1053);
int rbind = bind(m_sockfd, (struct sockaddr *) & m_address,
sizeof (struct sockaddr_in));
if (rbind != 0) {
m_address.sin_port = htons(1053);
int rbind = bind(m_sockfd, (struct sockaddr *)&m_address,
sizeof(struct sockaddr_in));
if(rbind != 0)
{
llarp::LogError("Could not bind: ", strerror(errno));
return 0;
}
const size_t BUFFER_SIZE = 1024;
char buffer[BUFFER_SIZE]; // 1024 is buffer size
char buffer[BUFFER_SIZE]; // 1024 is buffer size
struct sockaddr_in clientAddress;
socklen_t addrLen = sizeof (struct sockaddr_in);
socklen_t addrLen = sizeof(struct sockaddr_in);
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = 100 * 1000; // 1 sec
if (setsockopt(m_sockfd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)) < 0) {
tv.tv_sec = 0;
tv.tv_usec = 100 * 1000; // 1 sec
if(setsockopt(m_sockfd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)) < 0)
{
perror("Error");
}
signal(SIGINT, handle_signal);
while(!done)
{
// sigint quits after next packet
int nbytes = recvfrom(m_sockfd, buffer, BUFFER_SIZE, 0,
(struct sockaddr *) &clientAddress, &addrLen);
if (nbytes == -1) continue;
(struct sockaddr *)&clientAddress, &addrLen);
if(nbytes == -1)
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);
}
}

3
include/llarp/buffer.h
View File

@ -61,8 +61,7 @@ typedef struct llarp_buffer_t
/// max size of buffer
size_t sz;
const byte_t
operator[](size_t x)
const byte_t operator[](size_t x)
{
return *(this->base + x);
}

41
include/llarp/dns.h
View File

@ -1,8 +1,8 @@
#ifndef LLARP_DNS_H_
#define LLARP_DNS_H_
#include <sys/types.h> // for uint & ssize_t
#include <llarp/ev.h>
#include <sys/types.h> // for uint & ssize_t
/**
* dns.h
@ -70,22 +70,22 @@ struct dns_tracker
{
uint c_responses;
uint c_requests;
std::map<uint, dns_client_request *> client_request;
std::map< uint, dns_client_request * > client_request;
dnsd_context *dnsd;
std::map<uint, dns_request *> daemon_request;
std::map< uint, dns_request * > daemon_request;
};
struct dnsc_context
{
/// DNS server hostname to use
//char *server;
// char *server;
/// DNS server port to use
//uint port;
// uint port;
/// Target: DNS server hostname/port to use
// FIXME: ipv6 it
sockaddr *server;
// where to create the new sockets
//struct llarp_ev_loop *netloop;
// struct llarp_ev_loop *netloop;
// FIXME: UDP socket pooling (or maybe at the libev level)
struct llarp_udp_io *udp;
};
@ -105,7 +105,7 @@ struct dnsd_context
/// returns true on bind success otherwise returns false
bool
llarp_dnsc_init(struct dnsc_context *dnsc, struct llarp_udp_io *udp,
const char *dnsc_hostname, uint16_t dnsc_port);
const char *dnsc_hostname, uint16_t dnsc_port);
bool
llarp_dnsc_stop(struct dnsc_context *dnsc);
@ -128,7 +128,7 @@ llarp_dnsd_init(struct dnsd_context *dns, struct llarp_ev_loop *netloop,
struct dns_query
{
uint16_t length;
char * url;
char *url;
unsigned char request[DNC_BUF_SIZE];
uint16_t reqType;
};
@ -137,13 +137,13 @@ struct dns_client_request;
// should we pass by llarp::Addr
// not as long as we're supporting raw
typedef void(*resolve_dns_hook_func)(dns_client_request *request);
typedef void (*resolve_dns_hook_func)(dns_client_request *request);
// FIXME: separate generic from llarp
struct dns_client_request
{
/// sock type
void *sock; // pts to udp...
void *sock; // pts to udp...
/// customizeable (used for outer request)
void *user;
/// storage
@ -163,26 +163,29 @@ bool
llarp_dnsc_bind(struct llarp_ev_loop *netloop,
struct dns_client_request *request);
struct sockaddr *resolveHost(const char *url);
bool llarp_resolve_host(struct dnsc_context *dns, const char *url,
resolve_dns_hook_func resolved, void *user);
struct sockaddr *
resolveHost(const char *url);
bool
llarp_resolve_host(struct dnsc_context *dns, const char *url,
resolve_dns_hook_func resolved, void *user);
void
llarp_host_resolved(dns_client_request *request);
void
llarp_handle_recvfrom(struct llarp_udp_io *udp, const struct sockaddr *paddr,
const void *buf, ssize_t sz);
const void *buf, ssize_t sz);
void
llarp_handle_dns_recvfrom(struct llarp_udp_io *udp, const struct sockaddr *saddr,
const void *buf, ssize_t sz);
llarp_handle_dns_recvfrom(struct llarp_udp_io *udp,
const struct sockaddr *saddr, const void *buf,
ssize_t sz);
void
llarp_handle_recvfrom(struct llarp_udp_io *udp, const struct sockaddr *saddr,
const void *buf, ssize_t sz);
const void *buf, ssize_t sz);
void
raw_handle_recvfrom(int *sockfd, const struct sockaddr *saddr,
const void *buf, ssize_t sz);
raw_handle_recvfrom(int *sockfd, const struct sockaddr *saddr, const void *buf,
ssize_t sz);
#endif

538
llarp/dnsc.cpp
View File

@ -1,21 +1,20 @@
// why dnsd? what do you need from that?
#include "dnsd.hpp"
#include "buffer.hpp"
#include "dnsd.hpp"
#include <sys/types.h>
#include <netdb.h> /* getaddrinfo, getnameinfo */
#include <stdlib.h> /* exit */
#include <string.h> /* memset */
#include <sys/socket.h>
#include <netdb.h> /* getaddrinfo, getnameinfo */
#include <stdlib.h> /* exit */
#include <string.h> /* memset */
#include <unistd.h> /* close */
#include <sys/types.h>
#include <unistd.h> /* close */
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include "logger.hpp"
#include <llarp/dns.h>
#include "net.hpp" // for llarp::Addr
#include "net.hpp" // for llarp::Addr
#include "logger.hpp"
#include "net.hpp" // for llarp::Addr
// FIXME: make configurable
#define SERVER "8.8.8.8"
@ -24,173 +23,199 @@
mtx_t m_dnsc_Mutex;
mtx_t m_dnsc2_Mutex;
struct sockaddr *resolveHost(const char *url) {
char* sUrl = strdup(url);
struct sockaddr *
resolveHost(const char *url)
{
char *sUrl = strdup(url);
struct dns_query dnsQuery;
dnsQuery.length = 12;
dnsQuery.url = sUrl;
dnsQuery.reqType = 0x01;
// dnsQuery.request = { 0xDB, 0x42, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
dnsQuery.request[ 0] = 0xDB;
dnsQuery.request[ 1] = 0x42;
dnsQuery.request[ 2] = 0x01;
dnsQuery.request[ 3] = 0x00;
dnsQuery.request[ 4] = 0x00;
dnsQuery.request[ 5] = 0x01;
dnsQuery.request[ 6] = 0x00;
dnsQuery.request[ 7] = 0x00;
dnsQuery.request[ 8] = 0x00;
dnsQuery.request[ 9] = 0x00;
// dnsQuery.request = { 0xDB, 0x42, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00 };
dnsQuery.request[0] = 0xDB;
dnsQuery.request[1] = 0x42;
dnsQuery.request[2] = 0x01;
dnsQuery.request[3] = 0x00;
dnsQuery.request[4] = 0x00;
dnsQuery.request[5] = 0x01;
dnsQuery.request[6] = 0x00;
dnsQuery.request[7] = 0x00;
dnsQuery.request[8] = 0x00;
dnsQuery.request[9] = 0x00;
dnsQuery.request[10] = 0x00;
dnsQuery.request[11] = 0x00;
char * word;
char *word;
unsigned int i;
llarp::LogDebug("Asking DNS server ", SERVER, " about ", url);
//dnsQuery.reqType = 0x01;
// dnsQuery.reqType = 0x01;
word = strtok(sUrl, ".");
while (word) {
llarp::LogDebug("parsing hostname: \"%s\" is %zu characters\n", word, strlen(word));
while(word)
{
llarp::LogDebug("parsing hostname: \"%s\" is %zu characters\n", word,
strlen(word));
dnsQuery.request[dnsQuery.length++] = strlen(word);
for (i = 0; i < strlen(word); i++) {
for(i = 0; i < strlen(word); i++)
{
dnsQuery.request[dnsQuery.length++] = word[i];
}
word = strtok(NULL, ".");
}
dnsQuery.request[dnsQuery.length++] = 0x00; // End of the host name
dnsQuery.request[dnsQuery.length++] = 0x00; // 0x0001 - Query is a Type A query (host address)
dnsQuery.request[dnsQuery.length++] = 0x00; // End of the host name
dnsQuery.request[dnsQuery.length++] =
0x00; // 0x0001 - Query is a Type A query (host address)
dnsQuery.request[dnsQuery.length++] = dnsQuery.reqType;
dnsQuery.request[dnsQuery.length++] = 0x00; // 0x0001 - Query is class IN (Internet address)
dnsQuery.request[dnsQuery.length++] =
0x00; // 0x0001 - Query is class IN (Internet address)
dnsQuery.request[dnsQuery.length++] = 0x01;
struct sockaddr_in addr;
//int socket;
// int socket;
ssize_t ret;
int rcode;
socklen_t size;
int ip = 0;
int length;
unsigned char buffer[DNC_BUF_SIZE];
//unsigned char tempBuf[3];
uint16_t QDCOUNT; //No. of items in Question Section
uint16_t ANCOUNT; //No. of items in Answer Section
uint16_t NSCOUNT; //No. of items in Authority Section
uint16_t ARCOUNT; //No. of items in Additional Section
uint16_t QCLASS; //Specifies the class of the query
uint16_t ATYPE; //Specifies the meaning of the data in the RDATA field
uint16_t ACLASS; //Specifies the class of the data in the RDATA field
uint32_t TTL; //The number of seconds the results can be cached
uint16_t RDLENGTH; //The length of the RDATA field
// unsigned char tempBuf[3];
uint16_t QDCOUNT; // No. of items in Question Section
uint16_t ANCOUNT; // No. of items in Answer Section
uint16_t NSCOUNT; // No. of items in Authority Section
uint16_t ARCOUNT; // No. of items in Additional Section
uint16_t QCLASS; // Specifies the class of the query
uint16_t ATYPE; // Specifies the meaning of the data in the RDATA field
uint16_t ACLASS; // Specifies the class of the data in the RDATA field
uint32_t TTL; // The number of seconds the results can be cached
uint16_t RDLENGTH; // The length of the RDATA field
uint16_t MSGID;
int sockfd;
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0) {
if(sockfd < 0)
{
llarp::LogWarn("Error creating socket!\n");
return nullptr;
}
//socket = sockfd;
// socket = sockfd;
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = inet_addr(SERVER);
addr.sin_port = htons(PORT);
size = sizeof(addr);
addr.sin_port = htons(PORT);
size = sizeof(addr);
//hexdump("sending packet", &dnsQuery.request, dnsQuery.length);
ret = sendto(sockfd, dnsQuery.request, dnsQuery.length, 0, (struct sockaddr*)&addr, size);
if (ret < 0) {
// hexdump("sending packet", &dnsQuery.request, dnsQuery.length);
ret = sendto(sockfd, dnsQuery.request, dnsQuery.length, 0,
(struct sockaddr *)&addr, size);
if(ret < 0)
{
llarp::LogWarn("Error Sending Request");
return nullptr;
}
//llarp::LogInfo("Sent\n");
// llarp::LogInfo("Sent\n");
memset(&buffer, 0, DNC_BUF_SIZE);
ret = recvfrom(sockfd, buffer, DNC_BUF_SIZE, 0, (struct sockaddr*)&addr, &size);
if (ret < 0) {
ret = recvfrom(sockfd, buffer, DNC_BUF_SIZE, 0, (struct sockaddr *)&addr,
&size);
if(ret < 0)
{
llarp::LogWarn("Error Receiving Response");
return nullptr;
}
//hexdump("received packet", &buffer, ret);
// hexdump("received packet", &buffer, ret);
close(sockfd);
rcode = (buffer[3] & 0x0F);
//tempBuf[0] = buffer[4];
//tempBuf[1] = buffer[5];
//tempBuf[2] = '\0';
// tempBuf[0] = buffer[4];
// tempBuf[1] = buffer[5];
// tempBuf[2] = '\0';
//printf("%0x %0x %0x %0x\n", buffer[4], buffer[5], tempBuf[0], tempBuf[1]);
// printf("%0x %0x %0x %0x\n", buffer[4], buffer[5], tempBuf[0], tempBuf[1]);
//QDCOUNT = (uint16_t) strtol(tempBuf, NULL, 16);
QDCOUNT = (uint16_t) buffer[4] * 0x100 + buffer[5];
// QDCOUNT = (uint16_t) strtol(tempBuf, NULL, 16);
QDCOUNT = (uint16_t)buffer[4] * 0x100 + buffer[5];
llarp::LogDebug("entries in question section: %u\n", QDCOUNT);
ANCOUNT = (uint16_t) buffer[6] * 0x100 + buffer[7];
ANCOUNT = (uint16_t)buffer[6] * 0x100 + buffer[7];
llarp::LogDebug("records in answer section: %u\n", ANCOUNT);
NSCOUNT = (uint16_t) buffer[8] * 0x100 + buffer[9];
NSCOUNT = (uint16_t)buffer[8] * 0x100 + buffer[9];
llarp::LogDebug("name server resource record count: %u\n", NSCOUNT);
ARCOUNT = (uint16_t) buffer[10] * 0x100 + buffer[11];
ARCOUNT = (uint16_t)buffer[10] * 0x100 + buffer[11];
llarp::LogDebug("additional records count: %u\n", ARCOUNT);
llarp::LogDebug("query type: %u\n", dnsQuery.reqType);
QCLASS = (uint16_t) dnsQuery.request[dnsQuery.length - 2] * 0x100 + dnsQuery.request[dnsQuery.length - 1];
QCLASS = (uint16_t)dnsQuery.request[dnsQuery.length - 2] * 0x100
+ dnsQuery.request[dnsQuery.length - 1];
llarp::LogDebug("query class: %u\n", QCLASS);
length = dnsQuery.length + 1; // to skip 0xc00c
ATYPE = (uint16_t) buffer[length + 1] * 0x100 + buffer[length + 2];
length = dnsQuery.length + 1; // to skip 0xc00c
ATYPE = (uint16_t)buffer[length + 1] * 0x100 + buffer[length + 2];
llarp::LogDebug("answer type: %u\n", ATYPE);
ACLASS = (uint16_t) buffer[length + 3] * 0x100 + buffer[length + 4];
ACLASS = (uint16_t)buffer[length + 3] * 0x100 + buffer[length + 4];
llarp::LogDebug("answer class: %u\n", ACLASS);
TTL = (uint32_t) buffer[length + 5] * 0x1000000 + buffer[length + 6] * 0x10000 + buffer[length + 7] * 0x100 + buffer[length + 8];
TTL = (uint32_t)buffer[length + 5] * 0x1000000 + buffer[length + 6] * 0x10000
+ buffer[length + 7] * 0x100 + buffer[length + 8];
llarp::LogDebug("seconds to cache: %u\n", TTL);
RDLENGTH = (uint16_t) buffer[length + 9] * 0x100 + buffer[length + 10];
RDLENGTH = (uint16_t)buffer[length + 9] * 0x100 + buffer[length + 10];
llarp::LogDebug("bytes in answer: %u\n", RDLENGTH);
MSGID = (uint16_t) buffer[0] * 0x100 + buffer[1];
MSGID = (uint16_t)buffer[0] * 0x100 + buffer[1];
llarp::LogDebug("answer msg id: %u\n", MSGID);
if (rcode == 2) {
if(rcode == 2)
{
llarp::LogWarn("nameserver %s returned SERVFAIL:\n", SERVER);
llarp::LogWarn(" the name server was unable to process this query due to a\n problem with the name server.\n");
llarp::LogWarn(
" the name server was unable to process this query due to a\n "
"problem with the name server.\n");
return nullptr;
} else if (rcode == 3) {
llarp::LogWarn("nameserver %s returned NXDOMAIN for %s:\n", SERVER, dnsQuery.url);
llarp::LogWarn(" the domain name referenced in the query does not exist\n");
}
else if(rcode == 3)
{
llarp::LogWarn("nameserver %s returned NXDOMAIN for %s:\n", SERVER,
dnsQuery.url);
llarp::LogWarn(
" the domain name referenced in the query does not exist\n");
return nullptr;
}
/* search for and print IPv4 addresses */
if (dnsQuery.reqType == 0x01) {
if(dnsQuery.reqType == 0x01)
{
llarp::LogDebug("DNS server's answer is: (type#=%u):", ATYPE);
//printf("IPv4 address(es) for %s:\n", dnsQuery.url);
for (i = 0 ; i < ret ; i++) {
if (buffer[i] == 0xC0 && buffer[i+3] == 0x01) {
ip++; i += 12; /* ! += buf[i+1]; */
llarp::LogDebug(" %u.%u.%u.%u\n", buffer[i], buffer[i+1], buffer[i+2], buffer[i+3]);
// printf("IPv4 address(es) for %s:\n", dnsQuery.url);
for(i = 0; i < ret; i++)
{
if(buffer[i] == 0xC0 && buffer[i + 3] == 0x01)
{
ip++;
i += 12; /* ! += buf[i+1]; */
llarp::LogDebug(" %u.%u.%u.%u\n", buffer[i], buffer[i + 1],
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;
unsigned char * ip;
g_addr->sa_family = AF_INET;
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
ip = (unsigned char *) &(addr->s_addr);
// have ip point to s_addr
ip = (unsigned char *)&(addr->s_addr);
ip[0]=buffer[i + 0];
ip[1]=buffer[i + 1];
ip[2]=buffer[i + 2];
ip[3]=buffer[i + 3];
ip[0] = buffer[i + 0];
ip[1] = buffer[i + 1];
ip[2] = buffer[i + 2];
ip[3] = buffer[i + 3];
return g_addr;
}
}
if (!ip) {
if(!ip)
{
llarp::LogWarn(" No IPv4 address found in the DNS response!\n");
return nullptr;
}
@ -199,137 +224,147 @@ struct sockaddr *resolveHost(const char *url) {
}
void
llarp_handle_dnsclient_recvfrom(struct llarp_udp_io *udp, const struct sockaddr *saddr,
const void *buf, ssize_t sz)
llarp_handle_dnsclient_recvfrom(struct llarp_udp_io *udp,
const struct sockaddr *saddr, const void *buf,
ssize_t sz)
{
lock_t lock(m_dnsc_Mutex);
//llarp::LogInfo("got a response, udp user is ", udp->user);
// llarp::LogInfo("got a response, udp user is ", udp->user);
unsigned char *castBuf = (unsigned char *)buf;
auto buffer = llarp::StackBuffer< decltype(castBuf) >(castBuf);
dns_msg_header *hdr = decode_hdr((const char*)castBuf);
auto buffer = llarp::StackBuffer< decltype(castBuf) >(castBuf);
dns_msg_header *hdr = decode_hdr((const char *)castBuf);
llarp::LogInfo("Header got client responses for id: ", hdr->id);
// if we sent this out, then there's an id
struct dns_tracker *tracker = (struct dns_tracker *)udp->user;
struct dns_tracker *tracker = (struct dns_tracker *)udp->user;
struct dns_client_request *request = tracker->client_request[hdr->id];
if (!request)
if(!request)
{
llarp::LogError("User data to DNS Client response not a dns_client_request");
llarp::LogError(
"User data to DNS Client response not a dns_client_request");
// we can't call back the hook
return;
}
//llarp_dnsc_unbind(request);
// llarp_dnsc_unbind(request);
if (sz < 0)
if(sz < 0)
{
llarp::LogWarn("Error Receiving DNS Client Response");
request->resolved(request);
return;
}
//unsigned char *castBuf = (unsigned char *)buf;
//auto buffer = llarp::StackBuffer< decltype(castBuf) >(castBuf);
// unsigned char *castBuf = (unsigned char *)buf;
// auto buffer = llarp::StackBuffer< decltype(castBuf) >(castBuf);
//hexdump("received packet", &buffer, ret);
// hexdump("received packet", &buffer, ret);
uint16_t QDCOUNT; //No. of items in Question Section
uint16_t ANCOUNT; //No. of items in Answer Section
uint16_t NSCOUNT; //No. of items in Authority Section
uint16_t ARCOUNT; //No. of items in Additional Section
uint16_t QCLASS; //Specifies the class of the query
uint16_t ATYPE; //Specifies the meaning of the data in the RDATA field
uint16_t ACLASS; //Specifies the class of the data in the RDATA field
uint32_t TTL; //The number of seconds the results can be cached
uint16_t RDLENGTH; //The length of the RDATA field
uint16_t QDCOUNT; // No. of items in Question Section
uint16_t ANCOUNT; // No. of items in Answer Section
uint16_t NSCOUNT; // No. of items in Authority Section
uint16_t ARCOUNT; // No. of items in Additional Section
uint16_t QCLASS; // Specifies the class of the query
uint16_t ATYPE; // Specifies the meaning of the data in the RDATA field
uint16_t ACLASS; // Specifies the class of the data in the RDATA field
uint32_t TTL; // The number of seconds the results can be cached
uint16_t RDLENGTH; // The length of the RDATA field
uint16_t MSGID;
int rcode;
int length;
struct dns_query *dnsQuery = &request->query;
rcode = (buffer[3] & 0x0F);
llarp::LogInfo("dnsc rcode ", rcode);
dns_msg_header *msg = decode_hdr((const char*)castBuf);
dns_msg_header *msg = decode_hdr((const char *)castBuf);
castBuf += 12;
llarp::LogInfo("msg id ", msg->id);
llarp::LogInfo("msg qr ", msg->qr);
llarp::LogInfo("msg op ", msg->opcode);
llarp::LogInfo("msg rc ", msg->rcode);
//tempBuf[0] = buffer[4];
//tempBuf[1] = buffer[5];
//tempBuf[2] = '\0';
//printf("%0x %0x %0x %0x\n", buffer[4], buffer[5], tempBuf[0], tempBuf[1]);
// tempBuf[0] = buffer[4];
// tempBuf[1] = buffer[5];
// tempBuf[2] = '\0';
//QDCOUNT = (uint16_t) strtol(tempBuf, NULL, 16);
QDCOUNT = (uint16_t) buffer[4] * 0x100 + buffer[5];
// printf("%0x %0x %0x %0x\n", buffer[4], buffer[5], tempBuf[0], tempBuf[1]);
// QDCOUNT = (uint16_t) strtol(tempBuf, NULL, 16);
QDCOUNT = (uint16_t)buffer[4] * 0x100 + buffer[5];
llarp::LogInfo("entries in question section: ", QDCOUNT);
ANCOUNT = (uint16_t) buffer[6] * 0x100 + buffer[7];
ANCOUNT = (uint16_t)buffer[6] * 0x100 + buffer[7];
llarp::LogInfo("records in answer section: ", ANCOUNT);
NSCOUNT = (uint16_t) buffer[8] * 0x100 + buffer[9];
NSCOUNT = (uint16_t)buffer[8] * 0x100 + buffer[9];
llarp::LogInfo("name server resource record count: ", NSCOUNT);
ARCOUNT = (uint16_t) buffer[10] * 0x100 + buffer[11];
ARCOUNT = (uint16_t)buffer[10] * 0x100 + buffer[11];
llarp::LogInfo("additional records count: ", ARCOUNT);
llarp::LogInfo("msg qdc ", msg->qdCount);
llarp::LogInfo("msg anc ", msg->anCount);
llarp::LogInfo("msg nsc ", msg->nsCount);
llarp::LogInfo("msg arc ", msg->arCount);
// we may need to parse question first
dns_msg_question *question = decode_question((const char*)castBuf);
dns_msg_question *question = decode_question((const char *)castBuf);
llarp::LogInfo("que name ", question->name);
castBuf += question->name.length() + 8;
dns_msg_answer *answer = decode_answer((const char*)castBuf);
dns_msg_answer *answer = decode_answer((const char *)castBuf);
castBuf += answer->name.length() + 4 + 4 + 4 + answer->rdLen;
//dns_msg_answer *answer2 = decode_answer((const char*)castBuf);
//castBuf += answer->name.length() + 4 + 4 + 4 + answer->rdLen;
//llarp::LogDebug("query type: %u\n", dnsQuery->reqType);
QCLASS = (uint16_t) dnsQuery->request[dnsQuery->length - 2] * 0x100 + dnsQuery->request[dnsQuery->length - 1];
// dns_msg_answer *answer2 = decode_answer((const char*)castBuf);
// castBuf += answer->name.length() + 4 + 4 + 4 + answer->rdLen;
// llarp::LogDebug("query type: %u\n", dnsQuery->reqType);
QCLASS = (uint16_t)dnsQuery->request[dnsQuery->length - 2] * 0x100
+ dnsQuery->request[dnsQuery->length - 1];
llarp::LogInfo("query class: ", QCLASS);
length = dnsQuery->length + 1; // to skip 0xc00c
//printf("length [%d] from [%d]\n", length, buffer.base);
ATYPE = (uint16_t) buffer[length + 1] * 0x100 + buffer[length + 2];
length = dnsQuery->length + 1; // to skip 0xc00c
// printf("length [%d] from [%d]\n", length, buffer.base);
ATYPE = (uint16_t)buffer[length + 1] * 0x100 + buffer[length + 2];
llarp::LogInfo("answer type: ", ATYPE);
ACLASS = (uint16_t) buffer[length + 3] * 0x100 + buffer[length + 4];
ACLASS = (uint16_t)buffer[length + 3] * 0x100 + buffer[length + 4];
llarp::LogInfo("answer class: ", ACLASS);
TTL = (uint32_t) buffer[length + 5] * 0x1000000 + buffer[length + 6] * 0x10000 + buffer[length + 7] * 0x100 + buffer[length + 8];
TTL = (uint32_t)buffer[length + 5] * 0x1000000 + buffer[length + 6] * 0x10000
+ buffer[length + 7] * 0x100 + buffer[length + 8];
llarp::LogInfo("seconds to cache: ", TTL);
RDLENGTH = (uint16_t) buffer[length + 9] * 0x100 + buffer[length + 10];
RDLENGTH = (uint16_t)buffer[length + 9] * 0x100 + buffer[length + 10];
llarp::LogInfo("bytes in answer: ", RDLENGTH);
MSGID = (uint16_t) buffer[0] * 0x100 + buffer[1];
//llarp::LogDebug("answer msg id: %u\n", MSGID);
MSGID = (uint16_t)buffer[0] * 0x100 + buffer[1];
// llarp::LogDebug("answer msg id: %u\n", MSGID);
llarp::LogInfo("ans class ", answer->aClass);
llarp::LogInfo("ans type ", answer->type);
llarp::LogInfo("ans ttl ", answer->ttl);
llarp::LogInfo("ans rdlen ", answer->rdLen);
/*
llarp::LogInfo("ans2 class ", answer2->aClass);
llarp::LogInfo("ans2 type ", answer2->type);
llarp::LogInfo("ans2 ttl ", answer2->ttl);
llarp::LogInfo("ans2 rdlen ", answer2->rdLen);
*/
if (rcode == 2) {
if(rcode == 2)
{
llarp::LogWarn("nameserver ", SERVER, " returned SERVFAIL:");
llarp::LogWarn(" the name server was unable to process this query due to a problem with the name server.");
llarp::LogWarn(
" the name server was unable to process this query due to a problem "
"with the name server.");
request->resolved(request);
return;
} else if (rcode == 3) {
llarp::LogWarn("nameserver ", SERVER, " returned NXDOMAIN for: ", dnsQuery->url);
}
else if(rcode == 3)
{
llarp::LogWarn("nameserver ", SERVER,
" returned NXDOMAIN for: ", dnsQuery->url);
llarp::LogWarn(" the domain name referenced in the query does not exist");
request->resolved(request);
return;
@ -338,14 +373,19 @@ llarp_handle_dnsclient_recvfrom(struct llarp_udp_io *udp, const struct sockaddr
int ip = 0;
/* search for and print IPv4 addresses */
if (dnsQuery->reqType == 0x01) {
if(dnsQuery->reqType == 0x01)
{
llarp::LogInfo("DNS server's answer is: (type#=", ATYPE, "):");
llarp::LogInfo("IPv4 address(es) for ", dnsQuery->url, ":");
for (unsigned int i = 0 ; i < sz ; i++) {
if (buffer[i] == 0xC0 && buffer[i+3] == 0x01) {
ip++; i += 12; /* ! += buf[i+1]; */
//llarp::LogInfo(" %u.%u.%u.%u\n", buffer[i], buffer[i+1], buffer[i+2], buffer[i+3]);
for(unsigned int i = 0; i < sz; i++)
{
if(buffer[i] == 0xC0 && buffer[i + 3] == 0x01)
{
ip++;
i += 12; /* ! += buf[i+1]; */
// llarp::LogInfo(" %u.%u.%u.%u\n", buffer[i], buffer[i+1], buffer[i+2],
// buffer[i+3]);
/*
struct sockaddr *g_addr = new sockaddr;
g_addr->sa_family = AF_INET;
@ -353,32 +393,34 @@ llarp_handle_dnsclient_recvfrom(struct llarp_udp_io *udp, const struct sockaddr
struct in_addr *addr = &((struct sockaddr_in *)g_addr)->sin_addr;
*/
unsigned char * ip;
unsigned char *ip;
//have ip point to s_addr
// have ip point to s_addr
request->result.sa_family = AF_INET;
request->result.sa_len = sizeof(in_addr);
struct in_addr *addr = &((struct sockaddr_in *) &request->result)->sin_addr;
request->result.sa_len = sizeof(in_addr);
struct in_addr *addr =
&((struct sockaddr_in *)&request->result)->sin_addr;
//ip = (unsigned char *) &request->result.sa_data;
ip = (unsigned char *) &(addr->s_addr);
// ip = (unsigned char *) &request->result.sa_data;
ip = (unsigned char *)&(addr->s_addr);
ip[0]=buffer[i + 0];
ip[1]=buffer[i + 1];
ip[2]=buffer[i + 2];
ip[3]=buffer[i + 3];
ip[0] = buffer[i + 0];
ip[1] = buffer[i + 1];
ip[2] = buffer[i + 2];
ip[3] = buffer[i + 3];
llarp::Addr test(request->result);
llarp::LogInfo(test);
//return g_addr;
//request->result = g_addr;
// return g_addr;
// request->result = g_addr;
request->found = true;
request->resolved(request);
return;
}
}
if (!ip) {
if(!ip)
{
llarp::LogWarn(" No IPv4 address found in the DNS response!");
request->resolved(request);
return;
@ -387,32 +429,35 @@ llarp_handle_dnsclient_recvfrom(struct llarp_udp_io *udp, const struct sockaddr
}
void
llarp_handle_dns_recvfrom(struct llarp_udp_io *udp, const struct sockaddr *saddr,
const void *buf, ssize_t sz)
llarp_handle_dns_recvfrom(struct llarp_udp_io *udp,
const struct sockaddr *saddr, const void *buf,
ssize_t sz)
{
unsigned char *castBuf = (unsigned char *)buf;
//auto buffer = llarp::StackBuffer< decltype(castBuf) >(castBuf);
dns_msg_header *hdr = decode_hdr((const char*)castBuf);
//castBuf += 12;
// auto buffer = llarp::StackBuffer< decltype(castBuf) >(castBuf);
dns_msg_header *hdr = decode_hdr((const char *)castBuf);
// castBuf += 12;
llarp::LogInfo("msg id ", hdr->id);
llarp::LogInfo("msg qr ", hdr->qr);
if (hdr->qr)
if(hdr->qr)
{
llarp_handle_dnsclient_recvfrom(udp, saddr, buf, sz);
} else {
}
else
{
llarp_handle_recvfrom(udp, saddr, buf, sz);
}
/*
llarp::LogInfo("msg op ", hdr->opcode);
llarp::LogInfo("msg rc ", hdr->rcode);
for(uint i = 0; i < hdr->qdCount; i++)
{
dns_msg_question *question = decode_question((const char*)castBuf);
llarp::LogInfo("Read a question");
castBuf += question->name.length() + 8;
}
for(uint i = 0; i < hdr->anCount; i++)
{
dns_msg_answer *answer = decode_answer((const char*)castBuf);
@ -422,73 +467,82 @@ llarp_handle_dns_recvfrom(struct llarp_udp_io *udp, const struct sockaddr *saddr
*/
}
void build_dns_query(struct dns_query *dnsQuery, uint id)
void
build_dns_query(struct dns_query *dnsQuery, uint id)
{
dnsQuery->length = 12;
dnsQuery->reqType = 0x01;
// ID
//buffer[0] = (value & 0xFF00) >> 8;
//buffer[1] = value & 0xFF;
// buffer[0] = (value & 0xFF00) >> 8;
// buffer[1] = value & 0xFF;
llarp::LogInfo("building request ", id);
dnsQuery->request[ 0] = (id & 0xFF00) >> 8;
dnsQuery->request[ 1] = (id & 0x00FF) >> 0;
dnsQuery->request[0] = (id & 0xFF00) >> 8;
dnsQuery->request[1] = (id & 0x00FF) >> 0;
// field
dnsQuery->request[ 2] = 0x01;
dnsQuery->request[ 3] = 0x00;
dnsQuery->request[2] = 0x01;
dnsQuery->request[3] = 0x00;
// questions
dnsQuery->request[ 4] = 0x00;
dnsQuery->request[ 5] = 0x01;
dnsQuery->request[4] = 0x00;
dnsQuery->request[5] = 0x01;
// answers
dnsQuery->request[ 6] = 0x00;
dnsQuery->request[ 7] = 0x00;
dnsQuery->request[6] = 0x00;
dnsQuery->request[7] = 0x00;
// ns
dnsQuery->request[ 8] = 0x00;
dnsQuery->request[ 9] = 0x00;
dnsQuery->request[8] = 0x00;
dnsQuery->request[9] = 0x00;
// ar
dnsQuery->request[10] = 0x00;
dnsQuery->request[11] = 0x00;
char * word;
//llarp::LogDebug("Asking DNS server %s about %s", SERVER, dnsQuery->url);
char * strTemp = strdup(dnsQuery->url);
word = strtok(strTemp, ".");
while (word) {
//llarp::LogDebug("parsing hostname: \"%s\" is %zu characters", word, strlen(word));
char *word;
// llarp::LogDebug("Asking DNS server %s about %s", SERVER, dnsQuery->url);
char *strTemp = strdup(dnsQuery->url);
word = strtok(strTemp, ".");
while(word)
{
// llarp::LogDebug("parsing hostname: \"%s\" is %zu characters", word,
// strlen(word));
dnsQuery->request[dnsQuery->length++] = strlen(word);
for (unsigned int i = 0; i < strlen(word); i++) {
for(unsigned int i = 0; i < strlen(word); i++)
{
dnsQuery->request[dnsQuery->length++] = word[i];
}
word = strtok(NULL, ".");
}
dnsQuery->request[dnsQuery->length++] = 0x00; // End of the host name
dnsQuery->request[dnsQuery->length++] = 0x00; // 0x0001 - Query is a Type A query (host address)
dnsQuery->request[dnsQuery->length++] = 0x00; // End of the host name
dnsQuery->request[dnsQuery->length++] =
0x00; // 0x0001 - Query is a Type A query (host address)
dnsQuery->request[dnsQuery->length++] = dnsQuery->reqType;
dnsQuery->request[dnsQuery->length++] = 0x00; // 0x0001 - Query is class IN (Internet address)
dnsQuery->request[dnsQuery->length++] =
0x00; // 0x0001 - Query is class IN (Internet address)
dnsQuery->request[dnsQuery->length++] = 0x01;
}
bool llarp_resolve_host(struct dnsc_context *dnsc, const char *url, resolve_dns_hook_func resolved, void *user)
bool
llarp_resolve_host(struct dnsc_context *dnsc, const char *url,
resolve_dns_hook_func resolved, void *user)
{
dns_client_request *request = new dns_client_request;
request->sock = (void *)&request->udp;
request->user = user;
request->sock = (void *)&request->udp;
request->user = user;
// configure query
request->query.url = strdup(url);
request->resolved = resolved;
request->found = false;
// request address holds through the packet recv
//request->udp.user = request;
// request->udp.user = request;
// finish setting up our query
struct dns_query *dnsQuery = &request->query;
dns_tracker *tracker = (dns_tracker *)dnsc->udp->user;
dns_tracker *tracker = (dns_tracker *)dnsc->udp->user;
build_dns_query(dnsQuery, ++tracker->c_requests);
// build a socket per request because we're multithreaded and will have many inflight
// build a socket per request because we're multithreaded and will have many
// inflight
/*
if (!llarp_dnsc_bind(dnsc->netloop, request))
{
@ -497,13 +551,15 @@ bool llarp_resolve_host(struct dnsc_context *dnsc, const char *url, resolve_dns_
}
*/
tracker->client_request[tracker->c_requests] = request;
ssize_t ret = llarp_ev_udp_sendto(dnsc->udp, dnsc->server, dnsQuery->request, dnsQuery->length);
if (ret < 0) {
ssize_t ret = llarp_ev_udp_sendto(dnsc->udp, dnsc->server, dnsQuery->request,
dnsQuery->length);
if(ret < 0)
{
llarp::LogWarn("Error Sending Request");
return false;
}
return true;
}
@ -514,51 +570,53 @@ llarp_host_resolved(dns_client_request *request)
}
bool
llarp_dnsc_bind(struct llarp_ev_loop *netloop, struct dns_client_request *request)
llarp_dnsc_bind(struct llarp_ev_loop *netloop,
struct dns_client_request *request)
{
lock_t lock(m_dnsc2_Mutex);
// just grab a random open port
struct sockaddr_in srcaddr;
srcaddr.sin_addr.s_addr = inet_addr("0.0.0.0");
srcaddr.sin_family = AF_INET;
srcaddr.sin_family = AF_INET;
// we'll need to make sure the port is >1024 if not root
//llarp::LogInfo("outgoing port check ", ntohs(srcaddr.sin_port));
if (ntohs(srcaddr.sin_port) < 1024)
// llarp::LogInfo("outgoing port check ", ntohs(srcaddr.sin_port));
if(ntohs(srcaddr.sin_port) < 1024)
srcaddr.sin_port = htons(ntohs(srcaddr.sin_port) + 1024);
request->udp.user = request;
request->udp.recvfrom = &llarp_handle_dns_recvfrom;
request->udp.tick = nullptr;
request->udp.user = request;
request->udp.recvfrom = &llarp_handle_dns_recvfrom;
request->udp.tick = nullptr;
// create new listener for this request
return llarp_ev_add_udp(netloop, &request->udp, (const sockaddr *)&srcaddr) != -1;
return llarp_ev_add_udp(netloop, &request->udp, (const sockaddr *)&srcaddr)
!= -1;
}
// FIXME: drop the bool
bool
llarp_dnsc_unbind(struct dns_client_request *request)
{
llarp_ev_close_udp(&request->udp); // stop listening
llarp_ev_close_udp(&request->udp); // stop listening
return true;
}
bool
llarp_dnsc_init(struct dnsc_context *dnsc, struct llarp_udp_io *udp,
const char *dnsc_hostname, uint16_t dnsc_port)
const char *dnsc_hostname, uint16_t dnsc_port)
{
sockaddr_in *trgaddr = new sockaddr_in;
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;
trgaddr->sin_port = htons(dnsc_port);
trgaddr->sin_family = AF_INET;
dnsc->server = (sockaddr *)trgaddr;
dnsc->udp = udp;
return true;
}
bool
llarp_dnsc_stop(struct dnsc_context *dnsc)
{
//llarp_ev_close_udp(&dnsc->udp); // stop listening
delete (sockaddr_in *)dnsc->server; // deallocation
// llarp_ev_close_udp(&dnsc->udp); // stop listening
delete(sockaddr_in *)dnsc->server; // deallocation
return true;
}

294
llarp/dnsd.cpp
View File

@ -1,62 +1,66 @@
#include "dnsd.hpp"
#include <string>
#include "ev.hpp"
#include "logger.hpp"
#include "net.hpp"
#include "ev.hpp"
#include <string>
mtx_t m_dnsd_Mutex;
mtx_t m_dnsd2_Mutex;
mtx_t m_dnsd3_Mutex;
int get16bits(const char*& buffer) throw ()
int
get16bits(const char *&buffer) throw()
{
int value = static_cast<unsigned char> (buffer[0]);
value = value << 8;
value += static_cast<unsigned char> (buffer[1]);
int value = static_cast< unsigned char >(buffer[0]);
value = value << 8;
value += static_cast< unsigned char >(buffer[1]);
buffer += 2;
return value;
}
// uint32_t
uint32_t get32bits(const char*& buffer) throw ()
uint32_t
get32bits(const char *&buffer) throw()
{
uint32_t value = uint32_t((unsigned char)(buffer[0]) << 24 |
(unsigned char)(buffer[1]) << 16 |
(unsigned char)(buffer[2]) << 8 |
(unsigned char)(buffer[3]));
uint32_t value = uint32_t(
(unsigned char)(buffer[0]) << 24 | (unsigned char)(buffer[1]) << 16
| (unsigned char)(buffer[2]) << 8 | (unsigned char)(buffer[3]));
buffer += 4;
return value;
}
void put16bits(char*& buffer, uint value) throw ()
void
put16bits(char *&buffer, uint value) throw()
{
buffer[0] = (value & 0xFF00) >> 8;
buffer[1] = value & 0xFF;
buffer += 2;
}
void put32bits(char*& buffer, unsigned long value) throw ()
void
put32bits(char *&buffer, unsigned long value) throw()
{
buffer[0] = (value & 0xFF000000) >> 24;
buffer[1] = (value & 0x00FF0000) >> 16;
buffer[2] = (value & 0x0000FF00) >> 8;
buffer[3] = (value & 0x000000FF) >> 0;
buffer[2] = (value & 0x0000FF00) >> 8;
buffer[3] = (value & 0x000000FF) >> 0;
buffer += 4;
}
dns_msg_header *decode_hdr(const char *buffer)
dns_msg_header *
decode_hdr(const char *buffer)
{
dns_msg_header *hdr = new dns_msg_header;
hdr->id = get16bits(buffer);
uint fields = get16bits(buffer);
//hdr->qr = fields & 0x8000;
hdr->qr = (fields >> 7)& 0x1;
hdr->opcode = fields & 0x7800;
hdr->aa = fields & 0x0400;
hdr->tc = fields & 0x0200;
hdr->rd = fields & 0x0100;
hdr->ra = fields & 0x8000;
hdr->id = get16bits(buffer);
uint fields = get16bits(buffer);
// hdr->qr = fields & 0x8000;
hdr->qr = (fields >> 7) & 0x1;
hdr->opcode = fields & 0x7800;
hdr->aa = fields & 0x0400;
hdr->tc = fields & 0x0200;
hdr->rd = fields & 0x0100;
hdr->ra = fields & 0x8000;
// z, ad, cd
hdr->rcode = (buffer[3] & 0x0F);
hdr->qdCount = get16bits(buffer);
@ -66,19 +70,23 @@ dns_msg_header *decode_hdr(const char *buffer)
return hdr;
}
dns_msg_question *decode_question(const char *buffer)
dns_msg_question *
decode_question(const char *buffer)
{
dns_msg_question *question = new dns_msg_question;
std::string m_qName = "";
int length = *buffer++;
//llarp::LogInfo("qNamLen", length);
while (length != 0) {
for (int i = 0; i < length; i++) {
std::string m_qName = "";
int length = *buffer++;
// llarp::LogInfo("qNamLen", length);
while(length != 0)
{
for(int i = 0; i < length; i++)
{
char c = *buffer++;
m_qName.append(1, c);
}
length = *buffer++;
if (length != 0) m_qName.append(1,'.');
if(length != 0)
m_qName.append(1, '.');
}
question->name = m_qName;
question->type = get16bits(buffer);
@ -86,82 +94,86 @@ dns_msg_question *decode_question(const char *buffer)
return question;
}
dns_msg_answer *decode_answer(const char *buffer)
dns_msg_answer *
decode_answer(const char *buffer)
{
dns_msg_answer *answer = new dns_msg_answer;
answer->type = get16bits(buffer);
answer->aClass = get16bits(buffer);
answer->ttl = get32bits(buffer);
answer->rdLen = get16bits(buffer);
answer->rData = get16bits(buffer);
answer->type = get16bits(buffer);
answer->aClass = get16bits(buffer);
answer->ttl = get32bits(buffer);
answer->rdLen = get16bits(buffer);
answer->rData = get16bits(buffer);
return answer;
}
void code_domain(char*& buffer, const std::string& domain) throw()
void
code_domain(char *&buffer, const std::string &domain) throw()
{
int start(0), end; // indexes
//llarp::LogInfo("domain [", domain, "]");
while ((end = domain.find('.', start)) != std::string::npos)
int 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++)
*buffer++ = end - start; // label length octet
for(int i = start; i < end; i++)
{
*buffer++ = domain[i]; // label octets
//llarp::LogInfo("Writing ", domain[i], " at ", i);
*buffer++ = domain[i]; // label octets
// llarp::LogInfo("Writing ", domain[i], " at ", i);
}
start = end + 1; // Skip '.'
start = end + 1; // Skip '.'
}
//llarp::LogInfo("start ", start, " domain size ", domain.size());
// llarp::LogInfo("start ", start, " domain size ", domain.size());
*buffer++ = domain.size() - start; // last label length octet
for (int i=start; i<domain.size(); i++)
*buffer++ = domain.size() - start; // last label length octet
for(int i = start; i < domain.size(); i++)
{
*buffer++ = domain[i]; // last label octets
//llarp::LogInfo("Writing ", domain[i], " at ", i);
*buffer++ = domain[i]; // last label octets
// llarp::LogInfo("Writing ", domain[i], " at ", i);
}
*buffer++ = 0;
}
ssize_t
raw_sendto_dns_hook_func(void *sock, const struct sockaddr *from, const void *buffer, size_t length)
raw_sendto_dns_hook_func(void *sock, const struct sockaddr *from,
const void *buffer, size_t length)
{
int *fd = (int *)sock;
// how do we get to these??
socklen_t addrLen = sizeof (struct sockaddr_in);
socklen_t addrLen = sizeof(struct sockaddr_in);
return sendto(*fd, buffer, length, 0, from, addrLen);
}
ssize_t
llarp_sendto_dns_hook_func(void *sock, const struct sockaddr *from, const void *buffer, size_t length)
llarp_sendto_dns_hook_func(void *sock, const struct sockaddr *from,
const void *buffer, size_t length)
{
struct llarp_udp_io *udp = (struct llarp_udp_io *)sock;
if (!udp)
if(!udp)
{
llarp::LogWarn("couldnt cast to udp");
return 0;
}
//llarp::LogInfo("hook sending ", udp, " bytes: ", length);
// llarp::LogInfo("hook sending ", udp, " bytes: ", length);
// udp seems ok
// this call isn't calling the function...
//llarp::ev_io * evio = static_cast< llarp::ev_io * >(udp->impl);
//printf("ev_io[%x]\n", evio);
// llarp::ev_io * evio = static_cast< llarp::ev_io * >(udp->impl);
// printf("ev_io[%x]\n", evio);
return llarp_ev_udp_sendto(udp, from, buffer, length);
}
bool forward_dns_request(std::string request)
bool
forward_dns_request(std::string request)
{
return true;
}
void
writesend_dnss_response(struct sockaddr *hostRes, const struct sockaddr *from, dns_request *request)
writesend_dnss_response(struct sockaddr *hostRes, const struct sockaddr *from,
dns_request *request)
{
lock_t lock(m_dnsd2_Mutex);
if (!hostRes)
if(!hostRes)
{
llarp::LogWarn("Failed to resolve");
// FIXME: actually return correct packet
@ -171,19 +183,19 @@ writesend_dnss_response(struct sockaddr *hostRes, const struct sockaddr *from, d
const size_t BUFFER_SIZE = 1024;
char buf[BUFFER_SIZE];
memset(buf, 0, BUFFER_SIZE);
char* write_buffer = buf;
char* bufferBegin = buf;
char *write_buffer = buf;
char *bufferBegin = buf;
// build header
put16bits(write_buffer, request->id);
int fields = (1 << 15); // QR => message type, 1 = response
fields += (0 << 14); // I think opcode is always 0
fields += 0; // response code (3 => not found, 0 = Ok)
int fields = (1 << 15); // QR => message type, 1 = response
fields += (0 << 14); // I think opcode is always 0
fields += 0; // response code (3 => not found, 0 = Ok)
put16bits(write_buffer, fields);
put16bits(write_buffer, 1); // QD (number of questions)
put16bits(write_buffer, 1); // AN (number of answers)
put16bits(write_buffer, 0); // NS (number of auth RRs)
put16bits(write_buffer, 0); // AR (number of Additional RRs)
put16bits(write_buffer, 1); // QD (number of questions)
put16bits(write_buffer, 1); // AN (number of answers)
put16bits(write_buffer, 0); // NS (number of auth RRs)
put16bits(write_buffer, 0); // AR (number of Additional RRs)
// code question
code_domain(write_buffer, request->m_qName);
@ -191,16 +203,16 @@ writesend_dnss_response(struct sockaddr *hostRes, const struct sockaddr *from, d
put16bits(write_buffer, request->m_qClass);
// code answer
code_domain(write_buffer, request->m_qName); // com, type=6, ttl=0
code_domain(write_buffer, request->m_qName); // com, type=6, ttl=0
put16bits(write_buffer, request->m_qType);
put16bits(write_buffer, request->m_qClass);
put32bits(write_buffer, 1453); // ttl
put32bits(write_buffer, 1453); // ttl
// has to be a string of 4 bytes
struct sockaddr_in *sin = (struct sockaddr_in *)hostRes;
unsigned char *ip = (unsigned char *)&sin->sin_addr.s_addr;
unsigned char *ip = (unsigned char *)&sin->sin_addr.s_addr;
put16bits(write_buffer, 4); // rdLength
put16bits(write_buffer, 4); // rdLength
*write_buffer++ = ip[0];
*write_buffer++ = ip[1];
*write_buffer++ = ip[2];
@ -208,63 +220,71 @@ writesend_dnss_response(struct sockaddr *hostRes, const struct sockaddr *from, d
uint out_bytes = write_buffer - bufferBegin;
llarp::LogInfo("Sending ", out_bytes, " bytes");
//struct llarp_udp_io *udp = (struct llarp_udp_io *)request->user;
// struct llarp_udp_io *udp = (struct llarp_udp_io *)request->user;
request->hook(request->user, from, buf, out_bytes);
}
void handle_dnsc_result(dns_client_request *client_request)
void
handle_dnsc_result(dns_client_request *client_request)
{
//llarp::LogInfo("phase2 client ", client_request);
//writesend_dnss_response(struct sockaddr *hostRes, const struct sockaddr *from, dns_request *request)
// llarp::LogInfo("phase2 client ", client_request);
// writesend_dnss_response(struct sockaddr *hostRes, const struct sockaddr
// *from, dns_request *request)
dns_request *server_request = (dns_request *)client_request->user;
//llarp::Addr test(*server_request->from);
//llarp::LogInfo("server request sock ", server_request->from, " is ", test);
//llarp::LogInfo("phase2 server ", server_request);
writesend_dnss_response(client_request->found ? &client_request->result : nullptr, server_request->from, server_request);
// llarp::Addr test(*server_request->from);
// llarp::LogInfo("server request sock ", server_request->from, " is ", test);
// llarp::LogInfo("phase2 server ", server_request);
writesend_dnss_response(
client_request->found ? &client_request->result : nullptr,
server_request->from, server_request);
llarp_host_resolved(client_request);
}
// our generic version
void
handle_recvfrom(const char *buffer, ssize_t nbytes, const struct sockaddr *from, dns_request *request)
handle_recvfrom(const char *buffer, ssize_t nbytes, const struct sockaddr *from,
dns_request *request)
{
lock_t lock(m_dnsd_Mutex);
const size_t HDR_OFFSET = 12;
const char* p_buffer = buffer;
const char *p_buffer = buffer;
int rcode = (buffer[3] & 0x0F);
llarp::LogInfo("dnsd rcode ", rcode);
dns_msg_header *msg = decode_hdr(p_buffer);
//llarp::LogInfo("DNS_MSG size", sizeof(dns_msg));
// llarp::LogInfo("DNS_MSG size", sizeof(dns_msg));
p_buffer += HDR_OFFSET;
request->id = msg->id;
request->id = msg->id;
std::string m_qName = "";
int length = *p_buffer++;
//llarp::LogInfo("qNamLen", length);
while (length != 0) {
for (int i = 0; i < length; i++) {
int length = *p_buffer++;
// llarp::LogInfo("qNamLen", length);
while(length != 0)
{
for(int i = 0; i < length; i++)
{
char c = *p_buffer++;
m_qName.append(1, c);
}
length = *p_buffer++;
if (length != 0) m_qName.append(1,'.');
if(length != 0)
m_qName.append(1, '.');
}
request->m_qName = m_qName;
request->m_qType = get16bits(p_buffer);
request->m_qName = m_qName;
request->m_qType = get16bits(p_buffer);
request->m_qClass = get16bits(p_buffer);
llarp::LogInfo("qName ", m_qName);
llarp::LogInfo("qType ", request->m_qType);
llarp::LogInfo("qClass ", request->m_qClass);
/*
llarp::Addr test(*request->from);
llarp::LogInfo("DNS request from ", test);
llarp::Addr test2(from);
llarp::LogInfo("DNS request from ", test2);
*/
if (!forward_dns_request(m_qName))
if(!forward_dns_request(m_qName))
{
// told that hook will handle overrides
return;
@ -272,63 +292,66 @@ handle_recvfrom(const char *buffer, ssize_t nbytes, const struct sockaddr *from,
sockaddr *hostRes = nullptr;
// FIXME: how can we tell the mode?
//struct llarp_udp_io *udp = static_cast<struct llarp_udp_io *>(request->user);
if (0)
// struct llarp_udp_io *udp = static_cast<struct llarp_udp_io
// *>(request->user);
if(0)
{
hostRes = resolveHost(m_qName.c_str());
llarp::Addr anIp(*hostRes);
llarp::LogInfo("DNS got ", anIp);
//writesend_dnss_response(struct sockaddr *hostRes, const struct sockaddr *from, dns_request *request)
// writesend_dnss_response(struct sockaddr *hostRes, const struct sockaddr
// *from, dns_request *request)
sockaddr *fromCopy = new sockaddr(*from);
writesend_dnss_response(hostRes, fromCopy, request);
}
else
{
//llarp::Addr anIp;
//llarp::LogInfo("Checking server request ", request);
struct llarp_udp_io *udp = (struct llarp_udp_io *)request->user;
// llarp::Addr anIp;
// llarp::LogInfo("Checking server request ", request);
struct llarp_udp_io *udp = (struct llarp_udp_io *)request->user;
struct dns_tracker *tracker = (struct dns_tracker *)udp->user;
dnsd_context *dnsd = tracker->dnsd;
//dnsd_context *dnsd = (dnsd_context *)udp->user;
//llarp::LogInfo("Server request UDP ", request->user);
//llarp::LogInfo("server request hook ", request->hook);
//llarp::LogInfo("UDP ", udp);
//hostRes = llarp_resolveHost(udp->parent, m_qName.c_str());
llarp_resolve_host(&dnsd->client, m_qName.c_str(), &handle_dnsc_result, (void *)request);
dnsd_context *dnsd = tracker->dnsd;
// dnsd_context *dnsd = (dnsd_context *)udp->user;
// llarp::LogInfo("Server request UDP ", request->user);
// llarp::LogInfo("server request hook ", request->hook);
// llarp::LogInfo("UDP ", udp);
// hostRes = llarp_resolveHost(udp->parent, m_qName.c_str());
llarp_resolve_host(&dnsd->client, m_qName.c_str(), &handle_dnsc_result,
(void *)request);
}
}
// this is called in net threadpool
void
llarp_handle_recvfrom(struct llarp_udp_io *udp, const struct sockaddr *paddr,
const void *buf, ssize_t sz)
const void *buf, ssize_t sz)
{
lock_t lock(m_dnsd3_Mutex);
//llarp_link *link = static_cast< llarp_link * >(udp->user);
// llarp_link *link = static_cast< llarp_link * >(udp->user);
llarp::LogInfo("llarp Received Bytes ", sz);
dns_request *llarp_dns_request = new dns_request;
//llarp::LogInfo("Creating server request ", &llarp_dns_request);
//llarp::LogInfo("Server UDP address ", udp);
// llarp::LogInfo("Creating server request ", &llarp_dns_request);
// llarp::LogInfo("Server UDP address ", udp);
// make a copy of the sockaddr
llarp_dns_request->from = new sockaddr(*paddr);
llarp_dns_request->user = (void *)udp;
// set sock hook
llarp_dns_request->hook = &llarp_sendto_dns_hook_func;
//llarp::LogInfo("Server request's UDP ", llarp_dns_request->user);
// llarp::LogInfo("Server request's UDP ", llarp_dns_request->user);
handle_recvfrom((char *)buf, sz, llarp_dns_request->from, llarp_dns_request);
}
void
raw_handle_recvfrom(int *sockfd, const struct sockaddr *saddr,
const void *buf, ssize_t sz)
raw_handle_recvfrom(int *sockfd, const struct sockaddr *saddr, const void *buf,
ssize_t sz)
{
llarp::LogInfo("raw Received Bytes ", sz);
dns_request *llarp_dns_request = new dns_request;
llarp_dns_request->from = (struct sockaddr *)saddr;
llarp_dns_request->user = (void *)sockfd;
llarp_dns_request->hook = &raw_sendto_dns_hook_func;
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);
}
@ -341,21 +364,22 @@ llarp_dnsd_init(struct dnsd_context *dnsd, struct llarp_ev_loop *netloop,
{
struct sockaddr_in bindaddr;
bindaddr.sin_addr.s_addr = inet_addr("0.0.0.0");
bindaddr.sin_family = AF_INET;
bindaddr.sin_port = htons(dnsd_port);
dnsd->udp.user = &dns_udp_tracker;
dnsd->udp.recvfrom = &llarp_handle_dns_recvfrom;
dnsd->udp.tick = nullptr;
bindaddr.sin_family = AF_INET;
bindaddr.sin_port = htons(dnsd_port);
dnsd->udp.user = &dns_udp_tracker;
dnsd->udp.recvfrom = &llarp_handle_dns_recvfrom;
dnsd->udp.tick = nullptr;
dns_udp_tracker.dnsd = dnsd;
// configure dns client
if (!llarp_dnsc_init(&dnsd->client, &dnsd->udp, dnsc_hostname, dnsc_port))
if(!llarp_dnsc_init(&dnsd->client, &dnsd->udp, dnsc_hostname, dnsc_port))
{
llarp::LogError("Couldnt init dns client");
return false;
}
return llarp_ev_add_udp(netloop, &dnsd->udp, (const sockaddr *)&bindaddr) != -1;
return llarp_ev_add_udp(netloop, &dnsd->udp, (const sockaddr *)&bindaddr)
!= -1;
}

14
llarp/dnsd.hpp
View File

@ -3,7 +3,8 @@
#include "dnsc.hpp"
typedef ssize_t (*sendto_dns_hook_func)(void *sock, const struct sockaddr *from, const void *buffer, size_t length);
typedef ssize_t (*sendto_dns_hook_func)(void *sock, const struct sockaddr *from,
const void *buffer, size_t length);
struct dns_request
{
@ -15,11 +16,14 @@ struct dns_request
uint m_qType;
uint m_qClass;
struct sockaddr *from;
sendto_dns_hook_func hook; // sendto hook tbh
sendto_dns_hook_func hook; // sendto hook tbh
};
dns_msg_header *decode_hdr(const char *buffer);
dns_msg_question *decode_question(const char *buffer);
dns_msg_answer *decode_answer(const char *buffer);
dns_msg_header *
decode_hdr(const char *buffer);
dns_msg_question *
decode_question(const char *buffer);
dns_msg_answer *
decode_answer(const char *buffer);
#endif