mirror of https://github.com/oxen-io/lokinet
Merge remote-tracking branch 'loki/master'
This commit is contained in:
commit
f222f002f4
|
@ -253,6 +253,7 @@ set(LIB_SRC
|
|||
)
|
||||
|
||||
set(DNS_SRC
|
||||
llarp/dns.cpp
|
||||
llarp/dnsc.cpp
|
||||
llarp/dnsd.cpp
|
||||
llarp/net.cpp
|
||||
|
@ -317,7 +318,7 @@ else()
|
|||
target_link_libraries(${EXE} ${STATIC_LINK_LIBS} ${STATIC_LIB} libbackport-static libllarpplatform-static)
|
||||
target_link_libraries(${CLIENT_EXE} ${STATIC_LINK_LIBS} ${STATIC_LIB} libbackport-static libllarpplatform-static)
|
||||
target_link_libraries(rcutil ${STATIC_LINK_LIBS} ${STATIC_LIB} libbackport-static libllarpplatform-static)
|
||||
target_link_libraries(dns libllarpplatform-static)
|
||||
target_link_libraries(dns libllarpplatform-static pthread)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
|
@ -330,7 +331,7 @@ else()
|
|||
target_link_libraries(${EXE} ${SHARED_LIB} libbackport libllarpplatform)
|
||||
target_link_libraries(${CLIENT_EXE} ${SHARED_LIB} libbackport libllarpplatform)
|
||||
target_link_libraries(rcutil ${SHARED_LIB} libbackport libllarpplatform)
|
||||
target_link_libraries(dns libllarpplatform)
|
||||
target_link_libraries(dns libllarpplatform pthread)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
|
|
|
@ -1,4 +1,3 @@
|
|||
|
||||
#include <getopt.h>
|
||||
#include <signal.h>
|
||||
#include <stdio.h> /* fprintf, printf */
|
||||
|
@ -22,10 +21,20 @@ handle_signal(int sig)
|
|||
done = true;
|
||||
}
|
||||
|
||||
sockaddr *
|
||||
hookChecker(std::string name)
|
||||
{
|
||||
llarp::LogInfo("Hooked ", name);
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// FIXME: make configurable
|
||||
#define SERVER "8.8.8.8"
|
||||
#define PORT 53
|
||||
|
||||
int
|
||||
main(int argc, char *argv[])
|
||||
{
|
||||
dns_context dns;
|
||||
int code = 1;
|
||||
llarp::LogInfo("Starting up server");
|
||||
|
||||
|
@ -41,16 +50,51 @@ main(int argc, char *argv[])
|
|||
llarp_ev_loop_alloc(&netloop);
|
||||
|
||||
// configure main netloop
|
||||
if(!llarp_dns_init(&dns, netloop, "127.0.0.1", 1052))
|
||||
struct dnsd_context dnsd;
|
||||
if(!llarp_dnsd_init(&dnsd, netloop, "*", 1053, SERVER, PORT))
|
||||
{
|
||||
llarp::LogError("failed to initialize dns subsystem");
|
||||
return 1;
|
||||
//llarp::LogError("failed to initialize dns subsystem");
|
||||
llarp::LogError("Couldnt init dns daemon");
|
||||
return 0;
|
||||
}
|
||||
// Configure intercept
|
||||
dnsd.intercept = &hookChecker;
|
||||
|
||||
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);
|
||||
// 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
|
||||
{
|
||||
uint num_llarpworkers = 2;
|
||||
uint num_nethreads = 8;
|
||||
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();
|
||||
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");
|
||||
#else
|
||||
pthread_setname_np(netio_threads.back().native_handle(), "llarp-netio");
|
||||
#endif
|
||||
}
|
||||
llarp_logic_mainloop(logic);
|
||||
llarp::LogInfo("multithreaded end");
|
||||
}
|
||||
llarp_ev_loop_free(&netloop);
|
||||
}
|
||||
else
|
||||
|
@ -94,8 +138,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);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -60,6 +60,11 @@ typedef struct llarp_buffer_t
|
|||
byte_t *cur;
|
||||
/// max size of buffer
|
||||
size_t sz;
|
||||
|
||||
const byte_t operator[](size_t x)
|
||||
{
|
||||
return *(this->base + x);
|
||||
}
|
||||
} llarp_buffer_t;
|
||||
|
||||
/// how much room is left in buffer
|
||||
|
|
|
@ -1,8 +1,9 @@
|
|||
#ifndef LLARP_DNS_H_
|
||||
#define LLARP_DNS_H_
|
||||
|
||||
#include <llarp/ev.h>
|
||||
#include <llarp/ev.h> // for sockaadr
|
||||
#include <sys/types.h> // for uint & ssize_t
|
||||
#include <map> // for udp DNS tracker
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
|
@ -14,63 +15,46 @@ extern "C"
|
|||
* dns client/server
|
||||
*/
|
||||
|
||||
#define DNC_BUF_SIZE 512
|
||||
//#include <mutex>
|
||||
//typedef std::mutex mtx_t;
|
||||
//typedef std::lock_guard< mtx_t > lock_t;
|
||||
|
||||
struct dns_query
|
||||
// fwd declr
|
||||
//struct dns_query;
|
||||
struct dnsc_context;
|
||||
struct dnsd_context;
|
||||
//struct dnsd_question_request;
|
||||
struct dnsc_answer_request;
|
||||
|
||||
// dnsc can work over any UDP socket
|
||||
// however we can't ignore udp->user
|
||||
// we need to be able to reference the request (being a request or response)
|
||||
// bottom line is we can't use udp->user
|
||||
// so we'll need to track all incoming and outgoing requests
|
||||
|
||||
struct dns_tracker
|
||||
{
|
||||
uint16_t length;
|
||||
char *url;
|
||||
unsigned char request[DNC_BUF_SIZE];
|
||||
uint16_t reqType;
|
||||
//uint c_responses;
|
||||
uint c_requests;
|
||||
std::map< uint, dnsc_answer_request * > client_request;
|
||||
// FIXME: support multiple dns server contexts
|
||||
dnsd_context *dnsd;
|
||||
//std::map< uint, dnsd_question_request * > daemon_request;
|
||||
};
|
||||
|
||||
struct dns_client_request;
|
||||
|
||||
typedef void (*resolve_dns_hook_func)(struct 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;
|
||||
};
|
||||
|
||||
// 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;
|
||||
};
|
||||
// should we pass by llarp::Addr
|
||||
// not as long as we're supporting raw
|
||||
typedef void (*dnsc_answer_hook_func)(dnsc_answer_request *request);
|
||||
|
||||
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);
|
||||
raw_resolve_host(const char *url);
|
||||
|
||||
/// async resolve hostname
|
||||
bool
|
||||
llarp_resolve_host(struct dns_context *dns, const char *url,
|
||||
resolve_dns_hook_func resolved, void *user);
|
||||
llarp_resolve_host(struct dnsc_context *dns, const char *url,
|
||||
dnsc_answer_hook_func resolved, void *user);
|
||||
void
|
||||
llarp_host_resolved(dnsc_answer_request *request);
|
||||
|
||||
/*
|
||||
|
||||
|
|
|
@ -0,0 +1,188 @@
|
|||
#include "dnsd.hpp" // for llarp_handle_dnsd_recvfrom, dnsc
|
||||
#include "logger.hpp"
|
||||
#include <string.h>
|
||||
|
||||
uint16_t
|
||||
get16bits(const char *&buffer) throw()
|
||||
{
|
||||
uint16_t 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 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;
|
||||
}
|
||||
|
||||
dns_msg_header *
|
||||
decode_hdr(const char *buffer)
|
||||
{
|
||||
dns_msg_header *hdr = new dns_msg_header;
|
||||
hdr->id = get16bits(buffer);
|
||||
uint fields = get16bits(buffer);
|
||||
uint8_t lFields = (fields & 0x00FF) >> 0;
|
||||
uint8_t hFields = (fields & 0xFF00) >> 8;
|
||||
// hdr->qr = fields & 0x8000;
|
||||
hdr->qr = (hFields >> 7) & 0x1;
|
||||
hdr->opcode = fields & 0x7800;
|
||||
hdr->aa = fields & 0x0400;
|
||||
hdr->tc = fields & 0x0200;
|
||||
hdr->rd = fields & 0x0100;
|
||||
|
||||
hdr->ra = (lFields >> 7) & 0x1;
|
||||
//hdr->z = (lFields >> 6) & 0x1;
|
||||
//hdr->ad = (lFields >> 5) & 0x1;
|
||||
//hdr->cd = (lFields >> 4) & 0x1;
|
||||
hdr->rcode = lFields & 0xf;
|
||||
|
||||
hdr->qdCount = get16bits(buffer);
|
||||
hdr->anCount = get16bits(buffer);
|
||||
hdr->nsCount = get16bits(buffer);
|
||||
hdr->arCount = get16bits(buffer);
|
||||
return hdr;
|
||||
}
|
||||
|
||||
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++)
|
||||
{
|
||||
char c = *buffer++;
|
||||
m_qName.append(1, c);
|
||||
}
|
||||
length = *buffer++;
|
||||
if(length != 0)
|
||||
m_qName.append(1, '.');
|
||||
}
|
||||
question->name = m_qName;
|
||||
question->type = get16bits(buffer);
|
||||
question->qClass = get16bits(buffer);
|
||||
return question;
|
||||
}
|
||||
|
||||
dns_msg_answer *
|
||||
decode_answer(const char *buffer)
|
||||
{
|
||||
dns_msg_answer *answer = new dns_msg_answer;
|
||||
answer->type = get16bits(buffer);
|
||||
//assert(answer->type < 259);
|
||||
if (answer->type > 259)
|
||||
{
|
||||
llarp::LogWarn("Answer type is off the charts");
|
||||
}
|
||||
answer->aClass = get16bits(buffer);
|
||||
answer->ttl = get32bits(buffer);
|
||||
answer->rdLen = get16bits(buffer);
|
||||
if (answer->rdLen == 4)
|
||||
{
|
||||
answer->rData = new uint8_t[answer->rdLen];
|
||||
memcpy(answer->rData, buffer, answer->rdLen);
|
||||
}
|
||||
else
|
||||
{
|
||||
llarp::LogWarn("Unknown Type ", answer->type);
|
||||
}
|
||||
return answer;
|
||||
}
|
||||
|
||||
void
|
||||
put16bits(char *&buffer, uint16_t value) throw()
|
||||
{
|
||||
buffer[0] = (value & 0xFF00) >> 8;
|
||||
buffer[1] = value & 0xFF;
|
||||
buffer += 2;
|
||||
}
|
||||
|
||||
void
|
||||
put32bits(char *&buffer, uint32_t value) throw()
|
||||
{
|
||||
buffer[0] = (value & 0xFF000000) >> 24;
|
||||
buffer[1] = (value & 0x00FF0000) >> 16;
|
||||
buffer[2] = (value & 0x0000FF00) >> 8;
|
||||
buffer[3] = (value & 0x000000FF) >> 0;
|
||||
buffer += 4;
|
||||
}
|
||||
|
||||
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)
|
||||
{
|
||||
*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);
|
||||
}
|
||||
start = end + 1; // Skip '.'
|
||||
}
|
||||
|
||||
// llarp::LogInfo("start ", start, " domain size ", domain.size());
|
||||
|
||||
*buffer++ = domain.size() - start; // last label length octet
|
||||
for(uint i = start; i < domain.size(); i++)
|
||||
{
|
||||
*buffer++ = domain[i]; // last label octets
|
||||
// llarp::LogInfo("Writing ", domain[i], " at ", i);
|
||||
}
|
||||
|
||||
*buffer++ = 0;
|
||||
}
|
||||
|
||||
void
|
||||
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;
|
||||
llarp::LogDebug("msg id ", hdr->id);
|
||||
llarp::LogDebug("msg qr ", (uint8_t)hdr->qr);
|
||||
if(hdr->qr)
|
||||
{
|
||||
llarp::LogDebug("handling as dnsc answer");
|
||||
llarp_handle_dnsc_recvfrom(udp, saddr, buf, sz);
|
||||
}
|
||||
else
|
||||
{
|
||||
llarp::LogDebug("handling as dnsd question");
|
||||
llarp_handle_dnsd_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);
|
||||
llarp::LogInfo("Read an answer");
|
||||
castBuf += answer->name.length() + 4 + 4 + 4 + answer->rdLen;
|
||||
}
|
||||
*/
|
||||
}
|
|
@ -0,0 +1,75 @@
|
|||
#ifndef LIBLLARP_DNS_HPP
|
||||
#define LIBLLARP_DNS_HPP
|
||||
|
||||
#include <string>
|
||||
#include <sys/types.h> // for uint & ssize_t
|
||||
|
||||
// protocol parsing/writing structures & functions
|
||||
struct dns_msg_header
|
||||
{
|
||||
uint16_t id;
|
||||
uint8_t qr:1;
|
||||
uint8_t opcode:4;
|
||||
uint8_t aa:1;
|
||||
uint8_t tc:1;
|
||||
uint8_t rd:1;
|
||||
|
||||
uint8_t ra:1;
|
||||
uint8_t z:1;
|
||||
uint8_t ad:1;
|
||||
uint8_t cd:1;
|
||||
uint8_t rcode:4;
|
||||
|
||||
uint16_t qdCount;
|
||||
uint16_t anCount;
|
||||
uint16_t nsCount;
|
||||
uint16_t arCount;
|
||||
};
|
||||
|
||||
struct dns_msg_question
|
||||
{
|
||||
std::string name;
|
||||
uint16_t type;
|
||||
uint16_t qClass;
|
||||
};
|
||||
|
||||
struct dns_msg_answer
|
||||
{
|
||||
std::string name;
|
||||
uint16_t type;
|
||||
uint16_t aClass;
|
||||
uint32_t ttl;
|
||||
uint16_t rdLen;
|
||||
uint8_t *rData;
|
||||
};
|
||||
|
||||
uint16_t
|
||||
get16bits(const char *&buffer) throw();
|
||||
|
||||
uint32_t
|
||||
get32bits(const char *&buffer) throw();
|
||||
|
||||
dns_msg_header *
|
||||
decode_hdr(const char *buffer);
|
||||
|
||||
dns_msg_question *
|
||||
decode_question(const char *buffer);
|
||||
|
||||
dns_msg_answer *
|
||||
decode_answer(const char *buffer);
|
||||
|
||||
void
|
||||
put16bits(char *&buffer, uint16_t value) throw();
|
||||
|
||||
void
|
||||
put32bits(char *&buffer, uint32_t value) throw();
|
||||
|
||||
void
|
||||
code_domain(char *&buffer, const std::string &domain) throw();
|
||||
|
||||
void
|
||||
llarp_handle_dns_recvfrom(struct llarp_udp_io *udp,
|
||||
const struct sockaddr *saddr, const void *buf,
|
||||
ssize_t sz);
|
||||
|
||||
#endif
|
501
llarp/dnsc.cpp
501
llarp/dnsc.cpp
|
@ -1,4 +1,6 @@
|
|||
#include "dnsd.hpp"
|
||||
#include "dnsc.hpp"
|
||||
#include <llarp/dns.h>
|
||||
#include "buffer.hpp"
|
||||
|
||||
#include <netdb.h> /* getaddrinfo, getnameinfo */
|
||||
#include <stdlib.h> /* exit */
|
||||
|
@ -14,16 +16,86 @@
|
|||
|
||||
#include <llarp/dns.h>
|
||||
#include "logger.hpp"
|
||||
#include "net.hpp" // for llarp::Addr
|
||||
|
||||
// FIXME: make configurable
|
||||
#define SERVER "8.8.8.8"
|
||||
#define PORT 53
|
||||
|
||||
struct sockaddr *
|
||||
resolveHost(const char *url)
|
||||
#define DNC_BUF_SIZE 512
|
||||
// a question to be asked remotely
|
||||
// header, question
|
||||
struct dns_query
|
||||
{
|
||||
char *sUrl = strdup(url);
|
||||
struct dns_query dnsQuery;
|
||||
uint16_t length;
|
||||
//char *url;
|
||||
unsigned char request[DNC_BUF_SIZE];
|
||||
//uint16_t reqType;
|
||||
};
|
||||
|
||||
struct dns_query*
|
||||
build_dns_packet(char *url, uint16_t id, uint16_t reqType)
|
||||
{
|
||||
dns_query *dnsQuery = new dns_query;
|
||||
dnsQuery->length = 12;
|
||||
// ID
|
||||
// buffer[0] = (value & 0xFF00) >> 8;
|
||||
// buffer[1] = value & 0xFF;
|
||||
llarp::LogDebug("building request ", id);
|
||||
|
||||
dnsQuery->request[0] = (id & 0xFF00) >> 8;
|
||||
dnsQuery->request[1] = (id & 0x00FF) >> 0;
|
||||
// field
|
||||
dnsQuery->request[2] = 0x01;
|
||||
dnsQuery->request[3] = 0x00;
|
||||
// questions
|
||||
dnsQuery->request[4] = 0x00;
|
||||
dnsQuery->request[5] = 0x01;
|
||||
// answers
|
||||
dnsQuery->request[6] = 0x00;
|
||||
dnsQuery->request[7] = 0x00;
|
||||
// ns
|
||||
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(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++)
|
||||
{
|
||||
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++] = reqType;
|
||||
dnsQuery->request[dnsQuery->length++] =
|
||||
0x00; // 0x0001 - Query is class IN (Internet address)
|
||||
dnsQuery->request[dnsQuery->length++] = 0x01;
|
||||
return dnsQuery;
|
||||
}
|
||||
|
||||
struct sockaddr *
|
||||
raw_resolve_host(const char *url)
|
||||
{
|
||||
//char *sUrl = strdup(url);
|
||||
//struct dns_query dnsQuery;
|
||||
dns_query *dns_packet = build_dns_packet((char *)url, 0xDB42, 1);
|
||||
|
||||
/*
|
||||
dnsQuery.length = 12;
|
||||
dnsQuery.url = sUrl;
|
||||
dnsQuery.reqType = 0x01;
|
||||
|
@ -41,12 +113,13 @@ resolveHost(const char *url)
|
|||
dnsQuery.request[9] = 0x00;
|
||||
dnsQuery.request[10] = 0x00;
|
||||
dnsQuery.request[11] = 0x00;
|
||||
*/
|
||||
|
||||
char *word;
|
||||
unsigned int i;
|
||||
llarp::LogDebug("Asking DNS server %s about %s\n", SERVER, url);
|
||||
llarp::LogDebug("Asking DNS server ", SERVER, " about ", url);
|
||||
// dnsQuery.reqType = 0x01;
|
||||
|
||||
/*
|
||||
word = strtok(sUrl, ".");
|
||||
while(word)
|
||||
{
|
||||
|
@ -67,6 +140,7 @@ resolveHost(const char *url)
|
|||
dnsQuery.request[dnsQuery.length++] =
|
||||
0x00; // 0x0001 - Query is class IN (Internet address)
|
||||
dnsQuery.request[dnsQuery.length++] = 0x01;
|
||||
*/
|
||||
|
||||
struct sockaddr_in addr;
|
||||
// int socket;
|
||||
|
@ -105,14 +179,15 @@ resolveHost(const char *url)
|
|||
size = sizeof(addr);
|
||||
|
||||
// hexdump("sending packet", &dnsQuery.request, dnsQuery.length);
|
||||
ret = sendto(sockfd, dnsQuery.request, dnsQuery.length, 0,
|
||||
ret = sendto(sockfd, dns_packet->request, dns_packet->length, 0,
|
||||
(struct sockaddr *)&addr, size);
|
||||
delete dns_packet;
|
||||
if(ret < 0)
|
||||
{
|
||||
llarp::LogWarn("Error Sending Request");
|
||||
return nullptr;
|
||||
}
|
||||
// printf("Sent\n");
|
||||
// llarp::LogInfo("Sent\n");
|
||||
|
||||
memset(&buffer, 0, DNC_BUF_SIZE);
|
||||
ret = recvfrom(sockfd, buffer, DNC_BUF_SIZE, 0, (struct sockaddr *)&addr,
|
||||
|
@ -145,6 +220,7 @@ resolveHost(const char *url)
|
|||
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];
|
||||
|
@ -161,6 +237,7 @@ resolveHost(const char *url)
|
|||
llarp::LogDebug("bytes in answer: %u\n", RDLENGTH);
|
||||
MSGID = (uint16_t)buffer[0] * 0x100 + buffer[1];
|
||||
llarp::LogDebug("answer msg id: %u\n", MSGID);
|
||||
*/
|
||||
|
||||
if(rcode == 2)
|
||||
{
|
||||
|
@ -172,15 +249,15 @@ resolveHost(const char *url)
|
|||
}
|
||||
else if(rcode == 3)
|
||||
{
|
||||
llarp::LogWarn("nameserver %s returned NXDOMAIN for %s:\n", SERVER,
|
||||
dnsQuery.url);
|
||||
llarp::LogWarn("nameserver %s returned NXDOMAIN for ", SERVER);
|
||||
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)
|
||||
if (1)
|
||||
{
|
||||
llarp::LogDebug("DNS server's answer is: (type#=%u):", ATYPE);
|
||||
// printf("IPv4 address(es) for %s:\n", dnsQuery.url);
|
||||
|
@ -194,8 +271,10 @@ 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;
|
||||
#if ((__APPLE__ && __MACH__) || __FreeBSD__)
|
||||
g_addr->sa_len = sizeof(in_addr);
|
||||
#endif
|
||||
struct in_addr *addr = &((struct sockaddr_in *)g_addr)->sin_addr;
|
||||
unsigned char *ip;
|
||||
|
||||
// have ip point to s_addr
|
||||
|
@ -220,38 +299,44 @@ resolveHost(const char *url)
|
|||
}
|
||||
|
||||
void
|
||||
llarp_handle_dnsclient_recvfrom(struct llarp_udp_io *udp,
|
||||
llarp_handle_dnsc_recvfrom(struct llarp_udp_io *udp,
|
||||
const struct sockaddr *saddr, const void *buf,
|
||||
ssize_t sz)
|
||||
{
|
||||
struct dns_client_request *request = (struct dns_client_request *)udp->user;
|
||||
//lock_t lock(m_dnsc_Mutex);
|
||||
// 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);
|
||||
|
||||
llarp::LogDebug("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 dnsc_answer_request *request = tracker->client_request[hdr->id];
|
||||
|
||||
if(!request)
|
||||
{
|
||||
llarp::LogError(
|
||||
"User data to DNS Client response not a dns_client_request");
|
||||
"User data to DNS Client response not a dnsc_answer_request");
|
||||
// we can't call back the hook
|
||||
return;
|
||||
}
|
||||
// it's corrupt by here...
|
||||
// dns_request *server_request = (dns_request *)request->user;
|
||||
// llarp_dnsc_unbind(request);
|
||||
|
||||
// unsigned char buffer[DNC_BUF_SIZE];
|
||||
unsigned char *buffer = (unsigned char *)buf;
|
||||
|
||||
// memset(&buffer, 0, DNC_BUF_SIZE);
|
||||
// ret = recvfrom(sockfd, buffer, BUF_SIZE, 0, (struct sockaddr*)&addr,
|
||||
// &size);
|
||||
if(sz < 0)
|
||||
{
|
||||
llarp::LogWarn("Error Receiving DNS Client Response");
|
||||
request->resolved(request, nullptr);
|
||||
request->resolved(request);
|
||||
return;
|
||||
}
|
||||
|
||||
// unsigned char *castBuf = (unsigned char *)buf;
|
||||
// auto buffer = llarp::StackBuffer< decltype(castBuf) >(castBuf);
|
||||
|
||||
// hexdump("received packet", &buffer, ret);
|
||||
|
||||
llarp_ev_close_udp(udp);
|
||||
|
||||
/*
|
||||
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
|
||||
|
@ -262,222 +347,260 @@ llarp_handle_dnsclient_recvfrom(struct llarp_udp_io *udp,
|
|||
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;
|
||||
*/
|
||||
uint8_t rcode;
|
||||
//int length;
|
||||
|
||||
struct dns_query *dnsQuery = &request->query;
|
||||
//struct dns_query *dnsQuery = &request->query;
|
||||
|
||||
rcode = (buffer[3] & 0x0F);
|
||||
//rcode = (buffer[3] & 0x0F);
|
||||
//llarp::LogInfo("dnsc rcode ", rcode);
|
||||
|
||||
// tempBuf[0] = buffer[4];
|
||||
// tempBuf[1] = buffer[5];
|
||||
// tempBuf[2] = '\0';
|
||||
dns_msg_header *msg = decode_hdr((const char *)castBuf);
|
||||
castBuf += 12;
|
||||
llarp::LogDebug("msg id ", msg->id);
|
||||
uint8_t qr = msg->qr;
|
||||
llarp::LogDebug("msg qr ", qr);
|
||||
uint8_t opcode = msg->opcode;
|
||||
llarp::LogDebug("msg op ", opcode);
|
||||
rcode = msg->rcode;
|
||||
llarp::LogDebug("msg rc ", rcode);
|
||||
|
||||
// printf("%0x %0x %0x %0x\n", buffer[4], buffer[5], tempBuf[0], tempBuf[1]);
|
||||
llarp::LogDebug("msg qdc ", msg->qdCount);
|
||||
llarp::LogDebug("msg anc ", msg->anCount);
|
||||
llarp::LogDebug("msg nsc ", msg->nsCount);
|
||||
llarp::LogDebug("msg arc ", msg->arCount);
|
||||
|
||||
// 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];
|
||||
llarp::LogDebug("records in answer section: %u\n", ANCOUNT);
|
||||
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];
|
||||
llarp::LogDebug("additional records count: %u\n", ARCOUNT);
|
||||
// we may need to parse question first
|
||||
|
||||
llarp::LogDebug("query type: %u\n", dnsQuery->reqType);
|
||||
/*
|
||||
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);
|
||||
castBuf += answer->name.length() + 4 + 4 + 4 + answer->rdLen;
|
||||
*/
|
||||
|
||||
|
||||
// FIXME: only handling one atm
|
||||
dns_msg_question *question = nullptr;
|
||||
for(uint i = 0; i < hdr->qdCount; i++)
|
||||
{
|
||||
question = decode_question((const char*)castBuf);
|
||||
llarp::LogDebug("Read a question");
|
||||
castBuf += question->name.length() + 8;
|
||||
}
|
||||
|
||||
// FIXME: only handling one atm
|
||||
dns_msg_answer *answer = nullptr;
|
||||
for(uint i = 0; i < hdr->anCount; i++)
|
||||
{
|
||||
answer = decode_answer((const char*)castBuf);
|
||||
llarp::LogDebug("Read an answer");
|
||||
castBuf += answer->name.length() + 4 + 4 + 4 + answer->rdLen;
|
||||
}
|
||||
// handle authority records (usually no answers with these, so we'll just stomp)
|
||||
// usually NS records tho
|
||||
for(uint i = 0; i < hdr->nsCount; i++)
|
||||
{
|
||||
answer = decode_answer((const char*)castBuf);
|
||||
llarp::LogDebug("Read an authority");
|
||||
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];
|
||||
llarp::LogDebug("query class: %u\n", QCLASS);
|
||||
llarp::LogInfo("query class: ", QCLASS);
|
||||
|
||||
length = dnsQuery->length + 1; // to skip 0xc00c
|
||||
ATYPE = (uint16_t)buffer[length + 1] * 0x100 + buffer[length + 2];
|
||||
llarp::LogDebug("answer type: %u\n", ATYPE);
|
||||
// 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];
|
||||
llarp::LogDebug("answer class: %u\n", ACLASS);
|
||||
llarp::LogInfo("answer class: ", ACLASS);
|
||||
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);
|
||||
llarp::LogInfo("seconds to cache: ", TTL);
|
||||
RDLENGTH = (uint16_t)buffer[length + 9] * 0x100 + buffer[length + 10];
|
||||
llarp::LogDebug("bytes in answer: %u\n", RDLENGTH);
|
||||
llarp::LogInfo("bytes in answer: ", RDLENGTH);
|
||||
|
||||
MSGID = (uint16_t)buffer[0] * 0x100 + buffer[1];
|
||||
llarp::LogDebug("answer msg id: %u\n", MSGID);
|
||||
// llarp::LogDebug("answer msg id: %u\n", MSGID);
|
||||
*/
|
||||
|
||||
if(answer == nullptr)
|
||||
{
|
||||
llarp::LogWarn("nameserver ", SERVER, " didnt return any answers:");
|
||||
request->resolved(request);
|
||||
return;
|
||||
}
|
||||
|
||||
llarp::LogDebug("ans class ", answer->aClass);
|
||||
llarp::LogDebug("ans type ", answer->type);
|
||||
llarp::LogDebug("ans ttl ", answer->ttl);
|
||||
llarp::LogDebug("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)
|
||||
{
|
||||
llarp::LogWarn("nameserver %s returned SERVFAIL:\n", SERVER);
|
||||
llarp::LogWarn("nameserver ", SERVER, " returned SERVFAIL:");
|
||||
llarp::LogWarn(
|
||||
" the name server was unable to process this query due to a\n "
|
||||
"problem with the name server.\n");
|
||||
request->resolved(request, nullptr);
|
||||
" 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 %s returned NXDOMAIN for %s:\n", SERVER,
|
||||
dnsQuery->url);
|
||||
llarp::LogWarn(
|
||||
" the domain name referenced in the query does not exist\n");
|
||||
request->resolved(request, nullptr);
|
||||
llarp::LogWarn("nameserver ", SERVER,
|
||||
" returned NXDOMAIN for: ", request->question.name);
|
||||
llarp::LogWarn(" the domain name referenced in the query does not exist");
|
||||
request->resolved(request);
|
||||
return;
|
||||
}
|
||||
|
||||
int ip = 0;
|
||||
|
||||
/* search for and print IPv4 addresses */
|
||||
if(dnsQuery->reqType == 0x01)
|
||||
//if(dnsQuery->reqType == 0x01)
|
||||
if(request->question.type == 1)
|
||||
{
|
||||
llarp::LogInfo("DNS server's answer is: (type#=%u):", ATYPE);
|
||||
printf("IPv4 address(es) for %s:\n", dnsQuery->url);
|
||||
for(unsigned int i = 0; i < sz; i++)
|
||||
//llarp::LogInfo("DNS server's answer is: (type#=", ATYPE, "):");
|
||||
llarp::LogDebug("IPv4 address(es) for ", request->question.name, ":");
|
||||
|
||||
if (answer->rdLen == 4)
|
||||
{
|
||||
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;
|
||||
request->result.sa_family = AF_INET;
|
||||
#if ((__APPLE__ && __MACH__) || __FreeBSD__)
|
||||
request->result.sa_len = sizeof(in_addr);
|
||||
#endif
|
||||
struct in_addr *addr =
|
||||
&((struct sockaddr_in *)&request->result)->sin_addr;
|
||||
|
||||
// have ip point to s_addr
|
||||
ip = (unsigned char *)&(addr->s_addr);
|
||||
unsigned char *ip = (unsigned char *)&(addr->s_addr);
|
||||
ip[0] = answer->rData[0];
|
||||
ip[1] = answer->rData[1];
|
||||
ip[2] = answer->rData[2];
|
||||
ip[3] = answer->rData[3];
|
||||
|
||||
ip[0] = buffer[i + 0];
|
||||
ip[1] = buffer[i + 1];
|
||||
ip[2] = buffer[i + 2];
|
||||
ip[3] = buffer[i + 3];
|
||||
|
||||
// return g_addr;
|
||||
request->resolved(request, g_addr);
|
||||
return;
|
||||
}
|
||||
llarp::Addr test(request->result);
|
||||
llarp::LogDebug(test);
|
||||
request->found = true;
|
||||
request->resolved(request);
|
||||
return;
|
||||
}
|
||||
|
||||
if(!ip)
|
||||
{
|
||||
llarp::LogWarn(" No IPv4 address found in the DNS response!\n");
|
||||
request->resolved(request, nullptr);
|
||||
llarp::LogWarn(" No IPv4 address found in the DNS answer!");
|
||||
request->resolved(request);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
build_dns_query(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[10] = 0x00;
|
||||
dnsQuery->request[11] = 0x00;
|
||||
|
||||
char *word;
|
||||
llarp::LogDebug("Asking DNS server %s about %s\n", SERVER, dnsQuery->url);
|
||||
|
||||
char *strTemp = strdup(dnsQuery->url);
|
||||
word = strtok(strTemp, ".");
|
||||
while(word)
|
||||
{
|
||||
llarp::LogDebug("parsing hostname: \"%s\" is %zu characters\n", word,
|
||||
strlen(word));
|
||||
dnsQuery->request[dnsQuery->length++] = strlen(word);
|
||||
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++] = dnsQuery->reqType;
|
||||
dnsQuery->request[dnsQuery->length++] =
|
||||
0x00; // 0x0001 - Query is class IN (Internet address)
|
||||
dnsQuery->request[dnsQuery->length++] = 0x01;
|
||||
}
|
||||
|
||||
bool
|
||||
llarp_dns_resolve(dns_client_request *request)
|
||||
llarp_resolve_host(struct dnsc_context *dnsc, const char *url,
|
||||
dnsc_answer_hook_func resolved, void *user)
|
||||
{
|
||||
struct dns_query *dnsQuery = &request->query;
|
||||
build_dns_query(dnsQuery);
|
||||
struct sockaddr_in addr;
|
||||
// int socket;
|
||||
ssize_t ret;
|
||||
// socklen_t size;
|
||||
// unsigned char tempBuf[3];
|
||||
dnsc_answer_request *request = new dnsc_answer_request;
|
||||
request->sock = (void *)&dnsc->udp;
|
||||
request->user = user;
|
||||
request->resolved = resolved;
|
||||
request->found = false;
|
||||
request->context = dnsc;
|
||||
|
||||
memset(&addr, 0, sizeof(addr));
|
||||
addr.sin_family = AF_INET;
|
||||
addr.sin_addr.s_addr = inet_addr(SERVER);
|
||||
addr.sin_port = htons(PORT);
|
||||
// size = sizeof(addr);
|
||||
char *sUrl = strdup(url);
|
||||
request->question.name = sUrl;
|
||||
request->question.type = 1;
|
||||
request->question.qClass = 1;
|
||||
|
||||
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;
|
||||
// register request with udp response tracker
|
||||
dns_tracker *tracker = (dns_tracker *)dnsc->udp->user;
|
||||
|
||||
// hexdump("sending packet", &dnsQuery.request, dnsQuery.length);
|
||||
// ret = sendto(sockfd, dnsQuery.request, dnsQuery.length, 0, (struct
|
||||
// sockaddr*)&addr, size);
|
||||
ret = llarp_ev_udp_sendto(udp, (sockaddr *)&addr, dnsQuery->request,
|
||||
dnsQuery->length);
|
||||
/*
|
||||
uint16_t length = 0;
|
||||
dns_msg_header header;
|
||||
header.id = htons(id);
|
||||
header.qr = 0;
|
||||
header.opcode = 0;
|
||||
header.aa = 0;
|
||||
header.tc = 0;
|
||||
header.rd = 1;
|
||||
header.ra = 0;
|
||||
header.rcode = 0;
|
||||
header.qdCount = htons(1);
|
||||
header.anCount = 0;
|
||||
header.nsCount = 0;
|
||||
header.arCount = 0;
|
||||
length += 12;
|
||||
|
||||
//request->question.name = sUrl;
|
||||
request->question.type = htons(1);
|
||||
request->question.qClass = htons(1);
|
||||
|
||||
uint16_t qLen = request->question.name.length() + 8;
|
||||
length += qLen;
|
||||
|
||||
unsigned char bytes[length];
|
||||
// memcpy isn't going to fix the network endian issue
|
||||
// encode header into bytes
|
||||
memcpy(bytes, &header, 12);
|
||||
// encode question into bytes
|
||||
memcpy(bytes + 12, &request->question, qLen);
|
||||
*/
|
||||
|
||||
uint16_t id = ++tracker->c_requests;
|
||||
tracker->client_request[id] = request;
|
||||
//llarp::LogInfo("Sending request #", tracker->c_requests, " ", length, " bytes");
|
||||
|
||||
dns_query *dns_packet = build_dns_packet((char *)url, id, 1);
|
||||
//ssize_t ret = llarp_ev_udp_sendto(dnsc->udp, dnsc->server, bytes, length);
|
||||
ssize_t ret = llarp_ev_udp_sendto(dnsc->udp, dnsc->server, dns_packet->request, dns_packet->length);
|
||||
delete dns_packet;
|
||||
if(ret < 0)
|
||||
{
|
||||
llarp::LogWarn("Error Sending Request");
|
||||
return false;
|
||||
}
|
||||
// dns_request *test = (dns_request *)request->user;
|
||||
|
||||
// printf("Sent\n");
|
||||
llarp::LogInfo("Request sent, awaiting response");
|
||||
return true;
|
||||
}
|
||||
|
||||
void
|
||||
llarp_host_resolved(dnsc_answer_request *request)
|
||||
{
|
||||
delete request;
|
||||
}
|
||||
|
||||
bool
|
||||
llarp_dnsc_init(struct dnsc_context *dnsc, struct llarp_udp_io *udp,
|
||||
const char *dnsc_hostname, uint16_t dnsc_port)
|
||||
{
|
||||
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;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool
|
||||
llarp_resolve_host(struct llarp_ev_loop *netloop, const char *url,
|
||||
resolve_dns_hook_func resolved, void *user)
|
||||
llarp_dnsc_stop(struct dnsc_context *dnsc)
|
||||
{
|
||||
struct sockaddr_in s_addr;
|
||||
s_addr.sin_family = AF_INET;
|
||||
s_addr.sin_addr.s_addr = inet_addr("0.0.0.0");
|
||||
|
||||
llarp_udp_io *udp = new llarp_udp_io;
|
||||
udp->tick = nullptr;
|
||||
udp->user = nullptr;
|
||||
udp->impl = nullptr;
|
||||
udp->parent = netloop; // add_udp will do this...
|
||||
// llarp::LogDebug("dns client set to use ");
|
||||
udp->recvfrom = &llarp_handle_dnsclient_recvfrom;
|
||||
|
||||
if(llarp_ev_add_udp(netloop, udp, (sockaddr *)&s_addr) == -1)
|
||||
{
|
||||
llarp::LogError("failed to bind resolver to");
|
||||
return false;
|
||||
}
|
||||
|
||||
dns_client_request *request = new dns_client_request;
|
||||
request->sock = (void *)udp;
|
||||
request->user = user;
|
||||
request->query.url = strdup(url);
|
||||
request->resolved = resolved;
|
||||
llarp_dns_resolve(request);
|
||||
delete(sockaddr_in *)dnsc->server; // deallocation
|
||||
return true;
|
||||
}
|
||||
|
|
|
@ -1,6 +1,61 @@
|
|||
#ifndef LIBLLARP_DNSC_HPP
|
||||
#define LIBLLARP_DNSC_HPP
|
||||
|
||||
#include <llarp/dns.h>
|
||||
#include <llarp/ev.h> // for sockaadr
|
||||
#include "dns.hpp" // get protocol structs
|
||||
|
||||
// internal, non-public functions
|
||||
// well dnsc init/stop are public...
|
||||
|
||||
struct dnsc_answer_request;
|
||||
|
||||
// should we pass by llarp::Addr
|
||||
// not as long as we're supporting raw
|
||||
typedef void (*dnsc_answer_hook_func)(dnsc_answer_request *request);
|
||||
|
||||
// FIXME: separate generic from llarp
|
||||
struct dnsc_answer_request
|
||||
{
|
||||
/// sock type
|
||||
void *sock; // pts to udp...
|
||||
/// customizable (used for hook (outer request))
|
||||
void *user;
|
||||
/// storage
|
||||
dns_msg_question question;
|
||||
/// hook
|
||||
dnsc_answer_hook_func resolved;
|
||||
/// result
|
||||
bool found;
|
||||
struct sockaddr result;
|
||||
// a reference to dnsc_context incase of multiple contexts
|
||||
struct dnsc_context *context;
|
||||
};
|
||||
|
||||
void
|
||||
llarp_handle_dnsc_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 dnsc_context
|
||||
{
|
||||
/// Target: DNS server hostname/port to use
|
||||
// FIXME: ipv6 it
|
||||
sockaddr *server;
|
||||
// where to create the new sockets
|
||||
struct llarp_udp_io *udp;
|
||||
};
|
||||
|
||||
/// initialize dns subsystem and bind socket
|
||||
/// 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);
|
||||
|
||||
bool
|
||||
llarp_dnsc_stop(struct dnsc_context *dnsc);
|
||||
|
||||
#endif
|
||||
|
|
299
llarp/dnsd.cpp
299
llarp/dnsd.cpp
|
@ -1,83 +1,11 @@
|
|||
#include "dnsd.hpp"
|
||||
#include <llarp/dns.h>
|
||||
#include <string>
|
||||
#include "ev.hpp"
|
||||
#include "logger.hpp"
|
||||
#include "net.hpp"
|
||||
|
||||
int
|
||||
get16bits(const char *&buffer) throw()
|
||||
{
|
||||
int value = static_cast< unsigned char >(buffer[0]);
|
||||
value = value << 8;
|
||||
value += static_cast< unsigned char >(buffer[1]);
|
||||
buffer += 2;
|
||||
return value;
|
||||
}
|
||||
|
||||
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()
|
||||
{
|
||||
buffer[0] = (value & 0xFF000000) >> 24;
|
||||
buffer[1] = (value & 0x00FF0000) >> 16;
|
||||
buffer[2] = (value & 0x0000FF00) >> 8;
|
||||
buffer[3] = (value & 0x000000FF) >> 0;
|
||||
buffer += 4;
|
||||
}
|
||||
|
||||
dns_msg *
|
||||
decode_hdr(const char *buffer)
|
||||
{
|
||||
dns_msg *hdr = new dns_msg;
|
||||
hdr->id = get16bits(buffer);
|
||||
uint fields = get16bits(buffer);
|
||||
hdr->qr = fields & 0x8000;
|
||||
hdr->opcode = fields & 0x7800;
|
||||
hdr->aa = fields & 0x0400;
|
||||
hdr->tc = fields & 0x0200;
|
||||
hdr->rd = fields & 0x0100;
|
||||
hdr->ra = fields & 0x8000;
|
||||
|
||||
hdr->qdCount = get16bits(buffer);
|
||||
hdr->anCount = get16bits(buffer);
|
||||
hdr->nsCount = get16bits(buffer);
|
||||
hdr->arCount = get16bits(buffer);
|
||||
return hdr;
|
||||
}
|
||||
|
||||
void
|
||||
code_domain(char *&buffer, const std::string &domain) throw()
|
||||
{
|
||||
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(auto i = start; i < end; i++)
|
||||
{
|
||||
*buffer++ = domain[i]; // label octets
|
||||
// llarp::LogInfo("Writing ", domain[i], " at ", i);
|
||||
}
|
||||
start = end + 1; // Skip '.'
|
||||
}
|
||||
|
||||
// llarp::LogInfo("start ", start, " domain size ", domain.size());
|
||||
|
||||
*buffer++ = domain.size() - start; // last label length octet
|
||||
for(size_t i = start; i < domain.size(); i++)
|
||||
{
|
||||
*buffer++ = domain[i]; // last label octets
|
||||
// llarp::LogInfo("Writing ", domain[i], " at ", i);
|
||||
}
|
||||
|
||||
*buffer++ = 0;
|
||||
}
|
||||
dns_tracker dns_udp_tracker;
|
||||
|
||||
ssize_t
|
||||
raw_sendto_dns_hook_func(void *sock, const struct sockaddr *from,
|
||||
|
@ -96,8 +24,14 @@ llarp_sendto_dns_hook_func(void *sock, const struct sockaddr *from,
|
|||
struct llarp_udp_io *udp = (struct llarp_udp_io *)sock;
|
||||
if(!udp)
|
||||
{
|
||||
llarp::LogWarn("couldnt cast to udp");
|
||||
return 0;
|
||||
}
|
||||
// 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);
|
||||
return llarp_ev_udp_sendto(udp, from, buffer, length);
|
||||
}
|
||||
|
||||
|
@ -107,10 +41,13 @@ forward_dns_request(std::string request)
|
|||
return true;
|
||||
}
|
||||
|
||||
// FIXME: we need an DNS answer not a sockaddr
|
||||
// otherwise ttl, type and class can't be relayed correctly
|
||||
void
|
||||
writesend_dnss_response(struct sockaddr *hostRes, const struct sockaddr *from,
|
||||
dns_request *request)
|
||||
dnsd_question_request *request)
|
||||
{
|
||||
//lock_t lock(m_dnsd2_Mutex);
|
||||
if(!hostRes)
|
||||
{
|
||||
llarp::LogWarn("Failed to resolve");
|
||||
|
@ -136,15 +73,15 @@ writesend_dnss_response(struct sockaddr *hostRes, const struct sockaddr *from,
|
|||
put16bits(write_buffer, 0); // AR (number of Additional RRs)
|
||||
|
||||
// code question
|
||||
code_domain(write_buffer, request->m_qName);
|
||||
put16bits(write_buffer, request->m_qType);
|
||||
put16bits(write_buffer, request->m_qClass);
|
||||
code_domain(write_buffer, request->question.name);
|
||||
put16bits(write_buffer, request->question.type);
|
||||
put16bits(write_buffer, request->question.qClass);
|
||||
|
||||
// code answer
|
||||
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
|
||||
code_domain(write_buffer, request->question.name); // com, type=6, ttl=0
|
||||
put16bits(write_buffer, request->question.type);
|
||||
put16bits(write_buffer, request->question.qClass);
|
||||
put32bits(write_buffer, 1); // ttl
|
||||
|
||||
// has to be a string of 4 bytes
|
||||
struct sockaddr_in *sin = (struct sockaddr_in *)hostRes;
|
||||
|
@ -157,29 +94,40 @@ writesend_dnss_response(struct sockaddr *hostRes, const struct sockaddr *from,
|
|||
*write_buffer++ = ip[3];
|
||||
|
||||
uint out_bytes = write_buffer - bufferBegin;
|
||||
llarp::LogInfo("Sending ", out_bytes, " bytes");
|
||||
llarp::LogDebug("Sending ", out_bytes, " bytes");
|
||||
// struct llarp_udp_io *udp = (struct llarp_udp_io *)request->user;
|
||||
request->hook(request->user, from, buf, out_bytes);
|
||||
}
|
||||
|
||||
void
|
||||
phase2(dns_client_request *client_request, struct sockaddr *result)
|
||||
handle_dnsc_result(dnsc_answer_request *client_request)
|
||||
{
|
||||
llarp::LogInfo("phase2");
|
||||
// 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;
|
||||
writesend_dnss_response(result, server_request->from, server_request);
|
||||
// *from, dnsd_question_request *request)
|
||||
dnsd_question_request *server_request = (dnsd_question_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_host_resolved(client_request);
|
||||
}
|
||||
|
||||
// our generic version
|
||||
void
|
||||
handle_recvfrom(const char *buffer, ssize_t nbytes, const struct sockaddr *from,
|
||||
dns_request *request)
|
||||
dnsd_question_request *request)
|
||||
{
|
||||
//lock_t lock(m_dnsd_Mutex);
|
||||
const size_t HDR_OFFSET = 12;
|
||||
const char *p_buffer = buffer;
|
||||
|
||||
dns_msg *msg = decode_hdr(p_buffer);
|
||||
int rcode = (buffer[3] & 0x0F);
|
||||
llarp::LogDebug("dnsd rcode ", rcode);
|
||||
|
||||
dns_msg_header *msg = decode_hdr(p_buffer);
|
||||
// llarp::LogInfo("DNS_MSG size", sizeof(dns_msg));
|
||||
p_buffer += HDR_OFFSET;
|
||||
request->id = msg->id;
|
||||
|
@ -197,80 +145,125 @@ handle_recvfrom(const char *buffer, ssize_t nbytes, const struct sockaddr *from,
|
|||
if(length != 0)
|
||||
m_qName.append(1, '.');
|
||||
}
|
||||
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);
|
||||
request->question.name = m_qName;
|
||||
request->question.type = get16bits(p_buffer);
|
||||
request->question.qClass = get16bits(p_buffer);
|
||||
|
||||
if(!forward_dns_request(m_qName))
|
||||
//request->m_qName = m_qName;
|
||||
//request->m_qType = request->question.type;
|
||||
//request->m_qClass = request->question.qClass;
|
||||
llarp::LogDebug("qName ", request->question.name);
|
||||
llarp::LogDebug("qType ", request->question.type);
|
||||
llarp::LogDebug("qClass ", request->question.qClass);
|
||||
|
||||
/*
|
||||
llarp::Addr test(*request->from);
|
||||
llarp::LogInfo("DNS request from ", test);
|
||||
llarp::Addr test2(from);
|
||||
llarp::LogInfo("DNS request from ", test2);
|
||||
*/
|
||||
|
||||
if (request->context->intercept)
|
||||
{
|
||||
// told that hook will handle overrides
|
||||
return;
|
||||
sockaddr *intercept = request->context->intercept(request->question.name);
|
||||
//if(!forward_dns_request(m_qName))
|
||||
if (intercept != nullptr)
|
||||
{
|
||||
// told that hook will handle overrides
|
||||
sockaddr *fromCopy = new sockaddr(*from);
|
||||
writesend_dnss_response(intercept, fromCopy, request);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
sockaddr *hostRes = nullptr;
|
||||
if(1)
|
||||
if(request->llarp)
|
||||
{
|
||||
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(hostRes, from, request);
|
||||
// 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);
|
||||
}
|
||||
else
|
||||
{
|
||||
// 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);
|
||||
hostRes = raw_resolve_host(m_qName.c_str());
|
||||
llarp::Addr anIp(*hostRes);
|
||||
llarp::LogDebug("DNSc got ", anIp);
|
||||
// writesend_dnss_response(struct sockaddr *hostRes, const struct sockaddr
|
||||
// *from, dnsd_question_request *request)
|
||||
sockaddr *fromCopy = new sockaddr(*from);
|
||||
writesend_dnss_response(hostRes, fromCopy, request);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
handle_dns_recvfrom(struct llarp_udp_io *udp, const struct sockaddr *saddr,
|
||||
const void *buf, ssize_t sz)
|
||||
{
|
||||
llarp::LogDebug("Received Bytes ", sz);
|
||||
dns_request llarp_dns_request;
|
||||
llarp_dns_request.from = (struct sockaddr *)saddr;
|
||||
llarp_dns_request.user = (void *)udp;
|
||||
llarp_dns_request.hook = &llarp_sendto_dns_hook_func;
|
||||
handle_recvfrom((char *)buf, sz, saddr, &llarp_dns_request);
|
||||
}
|
||||
|
||||
extern "C"
|
||||
{
|
||||
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,
|
||||
llarp_handle_dnsd_recvfrom(struct llarp_udp_io *udp, const struct sockaddr *paddr,
|
||||
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);
|
||||
}
|
||||
{
|
||||
//lock_t lock(m_dnsd3_Mutex);
|
||||
// llarp_link *link = static_cast< llarp_link * >(udp->user);
|
||||
llarp::LogDebug("llarp Received Bytes ", sz);
|
||||
dnsd_question_request *llarp_dns_request = new dnsd_question_request;
|
||||
// llarp::LogInfo("Creating server request ", &llarp_dns_request);
|
||||
// llarp::LogInfo("Server UDP address ", udp);
|
||||
llarp_dns_request->context = dns_udp_tracker.dnsd;
|
||||
// make a copy of the sockaddr
|
||||
llarp_dns_request->from = new sockaddr(*paddr);
|
||||
llarp_dns_request->user = (void *)udp;
|
||||
llarp_dns_request->llarp = true;
|
||||
// set sock hook
|
||||
llarp_dns_request->hook = &llarp_sendto_dns_hook_func;
|
||||
|
||||
// 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)
|
||||
{
|
||||
llarp::LogInfo("raw Received Bytes ", sz);
|
||||
dnsd_question_request *llarp_dns_request = new dnsd_question_request;
|
||||
llarp_dns_request->from = (struct sockaddr *)saddr;
|
||||
llarp_dns_request->user = (void *)sockfd;
|
||||
llarp_dns_request->llarp = false;
|
||||
llarp_dns_request->hook = &raw_sendto_dns_hook_func;
|
||||
handle_recvfrom((char *)buf, sz, saddr, llarp_dns_request);
|
||||
}
|
||||
|
||||
bool
|
||||
llarp_dnsd_init(struct dnsd_context *dnsd, struct llarp_ev_loop *netloop,
|
||||
const char *dnsd_ifname, uint16_t dnsd_port,
|
||||
const char *dnsc_hostname, uint16_t dnsc_port)
|
||||
{
|
||||
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;
|
||||
|
||||
dns_udp_tracker.dnsd = dnsd;
|
||||
|
||||
dnsd->intercept = nullptr;
|
||||
|
||||
// configure dns client
|
||||
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;
|
||||
}
|
||||
|
|
|
@ -1,40 +1,62 @@
|
|||
#ifndef LIBLLARP_DNSD_HPP
|
||||
#define LIBLLARP_DNSD_HPP
|
||||
|
||||
#include <string>
|
||||
#include "dns.hpp" // question and dnsc
|
||||
#include "dnsc.hpp"
|
||||
#include <llarp/ev.h> // for sockaadr
|
||||
#include <string>
|
||||
|
||||
struct dns_msg
|
||||
{
|
||||
uint id;
|
||||
uint qr;
|
||||
uint opcode;
|
||||
uint aa;
|
||||
uint tc;
|
||||
uint rd;
|
||||
uint ra;
|
||||
uint rcode;
|
||||
|
||||
uint qdCount;
|
||||
uint anCount;
|
||||
uint nsCount;
|
||||
uint arCount;
|
||||
};
|
||||
struct dnsd_context;
|
||||
|
||||
typedef ssize_t (*sendto_dns_hook_func)(void *sock, const struct sockaddr *from,
|
||||
const void *buffer, size_t length);
|
||||
|
||||
struct dns_request
|
||||
struct dnsd_question_request
|
||||
{
|
||||
/// sock type
|
||||
void *user;
|
||||
// raw or llarp subsystem
|
||||
bool llarp;
|
||||
/// request id
|
||||
int id;
|
||||
std::string m_qName;
|
||||
uint m_qType;
|
||||
uint m_qClass;
|
||||
/// question being asked
|
||||
dns_msg_question question;
|
||||
// request source socket
|
||||
struct sockaddr *from;
|
||||
sendto_dns_hook_func hook; // sendto hook tbh
|
||||
// maybe a reference to dnsd_context incase of multiple
|
||||
dnsd_context *context; // or you can access it via user (udp)
|
||||
};
|
||||
|
||||
// we could have passed in the source sockaddr in case you wanted to
|
||||
// handle the response yourself
|
||||
typedef sockaddr *(*intercept_query_hook)(std::string name);
|
||||
|
||||
struct dnsd_context
|
||||
{
|
||||
/// DNS daemon socket to listen on
|
||||
struct llarp_udp_io udp;
|
||||
dnsc_context client;
|
||||
/// custom data for intercept query hook
|
||||
void *user;
|
||||
/// hook function for intercepting dns requests
|
||||
intercept_query_hook intercept;
|
||||
};
|
||||
|
||||
void
|
||||
llarp_handle_dnsd_recvfrom(struct llarp_udp_io *udp,
|
||||
const struct sockaddr *paddr, const void *buf,
|
||||
ssize_t sz);
|
||||
|
||||
/// initialize dns subsystem and bind socket
|
||||
/// returns true on bind success otherwise returns false
|
||||
bool
|
||||
llarp_dnsd_init(struct dnsd_context *dnsd, struct llarp_ev_loop *netloop,
|
||||
const char *dnsd_ifname, uint16_t dnsd_port,
|
||||
const char *dnsc_hostname, uint16_t dnsc_port);
|
||||
|
||||
bool
|
||||
llarp_dnsd_stop(struct dnsd_context *dnsd);
|
||||
|
||||
|
||||
#endif
|
||||
|
|
Loading…
Reference in New Issue