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

more dns tweaks

Browse Source
pull/90/head
Jeff Becker 6 years ago
parent 34e65a3e9a
commit 472948a610
No known key found for this signature in database
GPG Key ID: F357B3B42F6F9B05
12 changed files with 160 additions and 152 deletions
Show Stats Download Patch File Download Diff File

15
daemon/dns.cpp
Unescape Escape View File

@ -276,22 +276,27 @@ main(int argc, char *argv[])
lbuffer.cur = lbuffer.base; lbuffer.cur = lbuffer.base;
lbuffer.sz = nbytes; lbuffer.sz = nbytes;
dns_msg_header *hdr = decode_hdr(lbuffer); dns_msg_header hdr;
if(!decode_hdr(&lbuffer, &hdr))
{
llarp::LogError("failed to decode dns header");
continue;
}
// if we sent this out, then there's an id // if we sent this out, then there's an id
struct dns_tracker *tracker = (struct dns_tracker *)dnsd.client.tracker; struct dns_tracker *tracker = (struct dns_tracker *)dnsd.client.tracker;
struct dnsc_answer_request *request = struct dnsc_answer_request *request =
tracker->client_request[hdr->id].get(); tracker->client_request[hdr.id].get();
if(request) if(request)
{ {
request->packet.header = hdr; request->packet.header = hdr;
generic_handle_dnsc_recvfrom(tracker->client_request[hdr->id].get(), generic_handle_dnsc_recvfrom(tracker->client_request[hdr.id].get(),
lbuffer, hdr); lbuffer, &hdr);
} }
else else
{ {
llarp::LogWarn("Ignoring multiple responses on ID #", hdr->id); llarp::LogWarn("Ignoring multiple responses on ID #", hdr.id);
} }
// raw_handle_recvfrom(&m_sockfd, (const struct sockaddr *)&clientAddress, // raw_handle_recvfrom(&m_sockfd, (const struct sockaddr *)&clientAddress,

13
include/llarp/dns.hpp
Unescape Escape View File

@ -49,6 +49,7 @@ struct dns_tracker
struct dns_msg_header struct dns_msg_header
{ {
uint16_t id; uint16_t id;
uint8_t qr : 1; uint8_t qr : 1;
uint8_t opcode : 4; uint8_t opcode : 4;
uint8_t aa : 1; uint8_t aa : 1;
@ -61,6 +62,12 @@ struct dns_msg_header
uint8_t cd : 1; uint8_t cd : 1;
uint8_t rcode : 4; uint8_t rcode : 4;
uint16_t fields() const
{
return (qr << 15) | (opcode << 14) | (aa << 10) | (tc << 9) | (rd << 8) << (ra << 7) | (z << 6) | rcode;
}
uint16_t qdCount; uint16_t qdCount;
uint16_t anCount; uint16_t anCount;
uint16_t nsCount; uint16_t nsCount;
@ -87,7 +94,7 @@ struct dns_msg_answer
struct dns_packet struct dns_packet
{ {
struct dns_msg_header *header; struct dns_msg_header header;
std::vector< std::unique_ptr< dns_msg_question > > questions; std::vector< std::unique_ptr< dns_msg_question > > questions;
std::vector< std::unique_ptr< dns_msg_answer > > answers; std::vector< std::unique_ptr< dns_msg_answer > > answers;
std::vector< std::unique_ptr< dns_msg_answer > > auth_rrs; std::vector< std::unique_ptr< dns_msg_answer > > auth_rrs;
@ -120,8 +127,8 @@ extern "C"
uint32_t uint32_t
get32bits(const char *&buffer) throw(); get32bits(const char *&buffer) throw();
dns_msg_header * bool
decode_hdr(llarp_buffer_t &buffer); decode_hdr(llarp_buffer_t * buffer, dns_msg_header * hdr);
dns_msg_question * dns_msg_question *
decode_question(const char *buffer, uint32_t *pos); decode_question(const char *buffer, uint32_t *pos);

2
include/llarp/dns_dotlokilookup.hpp
Unescape Escape View File

@ -35,6 +35,6 @@ struct dotLokiLookup
dnsd_query_hook_response * dnsd_query_hook_response *
llarp_dotlokilookup_handler(std::string name, llarp_dotlokilookup_handler(std::string name,
struct dnsd_question_request *const request); const dnsd_question_request * request);
#endif #endif

14
include/llarp/dnsd.hpp
Unescape Escape View File

@ -25,8 +25,8 @@ struct dnsd_question_request
void *user; void *user;
// raw or llarp subsystem (is this used? does this matter?) // raw or llarp subsystem (is this used? does this matter?)
bool llarp; bool llarp;
/// request id /// request header
unsigned int id; dns_msg_header hdr;
/// question being asked /// question being asked
dns_msg_question question; dns_msg_question question;
// request source socket // request source socket
@ -64,22 +64,22 @@ llarp_handle_dnsd_recvfrom(struct llarp_udp_io *udp,
/// NXDOMAIN not found /// NXDOMAIN not found
void void
write404_dnss_response(dnsd_question_request *request); write404_dnss_response(const dnsd_question_request *request);
/// for hook functions to use /// for hook functions to use
void void
writecname_dnss_response(std::string cname, dnsd_question_request *request); writecname_dnss_response(std::string cname, const dnsd_question_request *request);
// FIXME: llarp::Addr // FIXME: llarp::Addr
/// send an A record found response /// send an A record found response
void void
writesend_dnss_response(llarp::huint32_t *hostRes, writesend_dnss_response(llarp::huint32_t *hostRes,
dnsd_question_request *request); const dnsd_question_request *request);
// FIXME: llarp::Addr // FIXME: llarp::Addr
/// send an PTR record found response /// send an PTR record found response
void void
writesend_dnss_revresponse(std::string reverse, dnsd_question_request *request); writesend_dnss_revresponse(std::string reverse, const dnsd_question_request *request);
// FIXME: llarp::Addr // FIXME: llarp::Addr
// //
@ -88,7 +88,7 @@ writesend_dnss_revresponse(std::string reverse, dnsd_question_request *request);
/// intercept query hook functor /// intercept query hook functor
using intercept_query_hook = std::function< dnsd_query_hook_response *( using intercept_query_hook = std::function< dnsd_query_hook_response *(
std::string name, struct dnsd_question_request *request) >; std::string name, const dnsd_question_request *request) >;
// FIXME: llarp::Addr // FIXME: llarp::Addr
/// DNS Server context /// DNS Server context

54
llarp/dns.cpp
Unescape Escape View File

@ -120,7 +120,6 @@ code_domain(char *&buffer, const std::string &domain) throw()
*buffer++ = domain[i]; // last label octets *buffer++ = domain[i]; // last label octets
// llarp::LogInfo("Writing ", domain[i], " at ", i); // llarp::LogInfo("Writing ", domain[i], " at ", i);
} }
*buffer++ = 0; *buffer++ = 0;
} }
@ -235,11 +234,11 @@ std::vector< byte_t >
packet2bytes(dns_packet &in) packet2bytes(dns_packet &in)
{ {
std::vector< byte_t > write_buffer; std::vector< byte_t > write_buffer;
vput16bits(write_buffer, in.header->id); vput16bits(write_buffer, in.header.id);
int fields = (in.header->qr << 15); // QR => message type, 1 = response int fields = (in.header.qr << 15); // QR => message type, 1 = response
fields += (in.header->opcode << 14); // I think opcode is always 0 fields += (in.header.opcode << 14); // I think opcode is always 0
fields += in.header->rcode; // response code (3 => not found, 0 = Ok) fields += in.header.rcode; // response code (3 => not found, 0 = Ok)
vput16bits(write_buffer, fields); vput16bits(write_buffer, fields);
// don't pull these from the header, trust what we actually have more // don't pull these from the header, trust what we actually have more
@ -308,19 +307,24 @@ extern "C"
return value; return value;
} }
dns_msg_header * bool
decode_hdr(llarp_buffer_t &buffer) decode_hdr(llarp_buffer_t * buffer, dns_msg_header * hdr)
{ {
dns_msg_header *hdr = new dns_msg_header;
uint16_t fields; uint16_t fields;
// reads as network byte order // reads as HOST byte order
llarp_buffer_read_uint16(&buffer, &hdr->id); if(!llarp_buffer_read_uint16(buffer, &hdr->id))
llarp_buffer_read_uint16(&buffer, &fields); return false;
llarp_buffer_read_uint16(&buffer, &hdr->qdCount); if(!llarp_buffer_read_uint16(buffer, &fields))
llarp_buffer_read_uint16(&buffer, &hdr->anCount); return false;
llarp_buffer_read_uint16(&buffer, &hdr->nsCount); if(!llarp_buffer_read_uint16(buffer, &hdr->qdCount))
llarp_buffer_read_uint16(&buffer, &hdr->arCount); return false;
if(!llarp_buffer_read_uint16(buffer, &hdr->anCount))
return false;
if(!llarp_buffer_read_uint16(buffer, &hdr->nsCount))
return false;
if(!llarp_buffer_read_uint16(buffer, &hdr->arCount))
return false;
// decode fields into hdr // decode fields into hdr
uint8_t lFields = (fields & 0x00FF) >> 0; uint8_t lFields = (fields & 0x00FF) >> 0;
@ -340,8 +344,7 @@ extern "C"
hdr->ad = (lFields >> 5) & 0x1; hdr->ad = (lFields >> 5) & 0x1;
hdr->cd = (lFields >> 4) & 0x1; hdr->cd = (lFields >> 4) & 0x1;
hdr->rcode = lFields & 0xf; hdr->rcode = lFields & 0xf;
return true;
return hdr;
} }
dns_msg_question * dns_msg_question *
@ -604,10 +607,16 @@ extern "C"
const struct sockaddr *addr, llarp_buffer_t buf) const struct sockaddr *addr, llarp_buffer_t buf)
{ {
// auto buffer = llarp::StackBuffer< decltype(castBuf) >(castBuf); // auto buffer = llarp::StackBuffer< decltype(castBuf) >(castBuf);
dns_msg_header *hdr = decode_hdr(buf); dns_msg_header hdr;
// castBuf += 12; if(!decode_hdr(&buf, &hdr))
llarp::LogDebug("msg id ", hdr->id); {
llarp::LogDebug("msg qr ", (uint8_t)hdr->qr); llarp::LogError("failed to decode dns header");
return;
}
// rewind
buf.cur = buf.base;
llarp::LogDebug("msg id ", hdr.id);
llarp::LogDebug("msg qr ", (uint8_t)hdr.qr);
if(!udp) if(!udp)
{ {
llarp::LogError("no udp passed in to handler"); llarp::LogError("no udp passed in to handler");
@ -616,7 +625,7 @@ extern "C"
{ {
llarp::LogError("no source addr passed in to handler"); llarp::LogError("no source addr passed in to handler");
} }
if(hdr->qr) if(hdr.qr)
{ {
llarp::LogDebug("handling as dnsc answer"); llarp::LogDebug("handling as dnsc answer");
llarp_handle_dnsc_recvfrom(udp, addr, buf); llarp_handle_dnsc_recvfrom(udp, addr, buf);
@ -626,6 +635,5 @@ extern "C"
llarp::LogDebug("handling as dnsd question"); llarp::LogDebug("handling as dnsd question");
llarp_handle_dnsd_recvfrom(udp, addr, buf); llarp_handle_dnsd_recvfrom(udp, addr, buf);
} }
delete hdr;
} }
} }

34
llarp/dns_dotlokilookup.cpp
Unescape Escape View File

@ -25,7 +25,7 @@ struct check_query_simple_request
{ {
// already inside request // already inside request
// const struct sockaddr *from; // source // const struct sockaddr *from; // source
dnsd_question_request *request; const dnsd_question_request *request;
}; };
std::unordered_map< std::string, struct dnsd_query_hook_response * > std::unordered_map< std::string, struct dnsd_query_hook_response * >
@ -216,7 +216,7 @@ struct reverse_handler_iter_context
{ {
std::string lName; std::string lName;
// const struct sockaddr *from; // aready inside dnsd_question_request // const struct sockaddr *from; // aready inside dnsd_question_request
const struct dnsd_question_request *request; const dnsd_question_request *request;
}; };
#if defined(ANDROID) || defined(RPI) #if defined(ANDROID) || defined(RPI)
@ -260,53 +260,46 @@ ReverseHandlerIter(struct llarp::service::Context::endpoint_iter *endpointCfg)
llarp::iprange_ipv4(std::stoi(tokensCheck[0]), std::stoi(tokensCheck[1]), llarp::iprange_ipv4(std::stoi(tokensCheck[0]), std::stoi(tokensCheck[1]),
std::stoi(tokensCheck[2]), std::stoi(tokensCheck[3]), std::stoi(tokensCheck[2]), std::stoi(tokensCheck[3]),
tunEndpoint->tunif.netmask); // create range tunEndpoint->tunif.netmask); // create range
// hack atm to work around limitations in ipaddr_ipv4_bits and llarp::IPRange
llarp::huint32_t searchIPv4_fixed = llarp::ipaddr_ipv4_bits( llarp::huint32_t searchIPv4 = llarp::ipaddr_ipv4_bits(
std::stoi(tokensSearch[searchTokens - 6]),
std::stoi(tokensSearch[searchTokens - 5]),
std::stoi(tokensSearch[searchTokens - 4]),
std::stoi(tokensSearch[searchTokens - 3])); // create ip
llarp::huint32_t searchIPv4_search = llarp::ipaddr_ipv4_bits(
std::stoi(tokensSearch[searchTokens - 3]), std::stoi(tokensSearch[searchTokens - 3]),
std::stoi(tokensSearch[searchTokens - 4]), std::stoi(tokensSearch[searchTokens - 4]),
std::stoi(tokensSearch[searchTokens - 5]), std::stoi(tokensSearch[searchTokens - 5]),
std::stoi(tokensSearch[searchTokens - 6])); // create ip std::stoi(tokensSearch[searchTokens - 6])); // create ip
// bool inRange = range.Contains(searchAddr.xtohl()); // bool inRange = range.Contains(searchAddr.xtohl());
bool inRange = range.Contains(searchIPv4_search); bool inRange = range.Contains(searchIPv4);
llarp::Addr searchAddr(searchIp); llarp::Addr searchAddr(searchIp);
llarp::Addr checkAddr(checkIp); llarp::Addr checkAddr(checkIp);
llarp::LogDebug(searchAddr, " vs ", range, " = ", llarp::LogInfo(searchIPv4, " vs ", range, " = ",
inRange ? "inRange" : "not match"); inRange ? "inRange" : "not match");
if(inRange) if(inRange)
{ {
llarp::AlignedBuffer<32> addr = llarp::AlignedBuffer<32> addr =
tunEndpoint->ObtainAddrForIP< llarp::AlignedBuffer<32> >( tunEndpoint->ObtainAddrForIP< llarp::AlignedBuffer<32> >(
searchIPv4_fixed, false); searchIPv4, false);
if(addr.IsZero()) if(addr.IsZero())
{ {
addr = addr =
tunEndpoint->ObtainAddrForIP< llarp::AlignedBuffer<32> >( tunEndpoint->ObtainAddrForIP< llarp::AlignedBuffer<32> >(
searchIPv4_fixed, true); searchIPv4, true);
if(!addr.IsZero()) if(!addr.IsZero())
{ {
char stack[128] = {0}; char stack[128] = {0};
std::string saddr = llarp::HexEncode(addr, stack); std::string saddr = llarp::HexEncode(addr, stack);
saddr += ".snode"; saddr += ".snode";
writesend_dnss_revresponse(saddr, writesend_dnss_revresponse(saddr, context->request);
(dnsd_question_request *)context->request);
} }
else else
write404_dnss_response((dnsd_question_request *)context->request); write404_dnss_response(context->request);
} }
else else
{ {
// llarp::LogInfo("Returning [", addr.ToString(), "]");
llarp::service::Address saddr = addr.data(); llarp::service::Address saddr = addr.data();
writesend_dnss_revresponse(saddr.ToString(), // llarp::LogInfo("Returning [", saddr.ToString(), "]");
(dnsd_question_request *)context->request); writesend_dnss_revresponse(saddr.ToString(), context->request);
} }
return false; return false;
} }
@ -330,7 +323,7 @@ static bool should_intercept_query_with_name(const std::string & lName)
dnsd_query_hook_response * dnsd_query_hook_response *
llarp_dotlokilookup_handler(std::string name, llarp_dotlokilookup_handler(std::string name,
struct dnsd_question_request *const request) const dnsd_question_request * request)
{ {
dnsd_query_hook_response *response = new dnsd_query_hook_response; dnsd_query_hook_response *response = new dnsd_query_hook_response;
response->dontLookUp = false; response->dontLookUp = false;
@ -369,6 +362,7 @@ llarp_dotlokilookup_handler(std::string name,
if(!res) if(!res)
{ {
llarp::LogDebug("Reverse is ours"); llarp::LogDebug("Reverse is ours");
response->dontLookUp = true;
response->dontSendResponse = true; // should have already sent it response->dontSendResponse = true; // should have already sent it
} }
else else

35
llarp/dnsc.cpp
Unescape Escape View File

@ -124,8 +124,6 @@ answer_request_alloc(struct dnsc_context *dnsc, void *sock, const char *url,
request->question.type = type; request->question.type = type;
request->question.qClass = 1; request->question.qClass = 1;
request->packet.header = nullptr;
// register our self with the tracker // register our self with the tracker
dns_tracker *tracker = request->context->tracker; dns_tracker *tracker = request->context->tracker;
if(!tracker) if(!tracker)
@ -633,22 +631,28 @@ raw_resolve_host(struct dnsc_context *const dnsc, const char *url,
// unsigned char *castBuf = (unsigned char *)buffer; // unsigned char *castBuf = (unsigned char *)buffer;
// auto buffer = llarp::StackBuffer< decltype(castBuf) >(castBuf); // auto buffer = llarp::StackBuffer< decltype(castBuf) >(castBuf);
dns_msg_header *hdr = decode_hdr(lbuffer); dns_msg_header hdr;
llarp::LogInfo("response header says it belongs to id #", hdr->id); if(!decode_hdr(&lbuffer, &hdr))
{
llarp::LogError("failed to decode dns header");
return;
}
llarp::LogInfo("response header says it belongs to id #", hdr.id);
// if we sent this out, then there's an id // if we sent this out, then there's an id
struct dns_tracker *tracker = (struct dns_tracker *)dnsc->tracker; struct dns_tracker *tracker = (struct dns_tracker *)dnsc->tracker;
struct dnsc_answer_request *request = tracker->client_request[hdr->id].get(); struct dnsc_answer_request *request = tracker->client_request[hdr.id].get();
if(request) if(request)
{ {
request->packet.header = hdr; request->packet.header = hdr;
generic_handle_dnsc_recvfrom(tracker->client_request[hdr->id].get(), generic_handle_dnsc_recvfrom(tracker->client_request[hdr.id].get(),
lbuffer, hdr); lbuffer, &hdr);
} }
else else
{ {
llarp::LogWarn("Ignoring multiple responses on ID #", hdr->id); llarp::LogWarn("Ignoring multiple responses on ID #", hdr.id);
} }
} }
@ -662,23 +666,28 @@ llarp_handle_dnsc_recvfrom(struct llarp_udp_io *const udp,
llarp::LogWarn("saddr isnt set"); llarp::LogWarn("saddr isnt set");
} }
// auto buffer = llarp::StackBuffer< decltype(castBuf) >(castBuf); // auto buffer = llarp::StackBuffer< decltype(castBuf) >(castBuf);
dns_msg_header *hdr = decode_hdr(buf); dns_msg_header hdr;
if(!decode_hdr(&buf, &hdr))
{
llarp::LogError("failed to decode dns header");
return;
}
buf.cur = buf.base; // reset cursor to beginning buf.cur = buf.base; // reset cursor to beginning
llarp::LogDebug("Header got client responses for id: ", hdr->id); llarp::LogDebug("Header got client responses for id: ", hdr.id);
// if we sent this out, then there's an 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 dnsc_answer_request *request = tracker->client_request[hdr->id].get(); struct dnsc_answer_request *request = tracker->client_request[hdr.id].get();
// sometimes we'll get double responses // sometimes we'll get double responses
if(request) if(request)
{ {
generic_handle_dnsc_recvfrom(request, buf, hdr); generic_handle_dnsc_recvfrom(request, buf, &hdr);
} }
else else
{ {
llarp::LogWarn("Ignoring multiple responses on ID #", hdr->id); llarp::LogWarn("Ignoring multiple responses on ID #", hdr.id);
} }
} }

86
llarp/dnsd.cpp
Unescape Escape View File

@ -39,21 +39,19 @@ llarp_sendto_dns_hook_func(void *sock, const struct sockaddr *from,
} }
void void
write404_dnss_response(dnsd_question_request *request) write404_dnss_response(const dnsd_question_request *request)
{ {
char buf[BUFFER_SIZE] = {0}; char buf[BUFFER_SIZE] = {0};
char *write_buffer = buf; char *write_buffer = buf;
char *bufferBegin = buf; char *bufferBegin = buf;
// build header // build header
put16bits(write_buffer, request->id); put16bits(write_buffer, request->hdr.id);
int fields = (1 << 15); // QR => message type, 1 = response // not found flag set
fields += (0 << 14); // I think opcode is always 0 put16bits(write_buffer, (1 << 15) | request->hdr.fields() | 3);
fields += 3; // response code (3 => not found, 0 = Ok)
put16bits(write_buffer, fields);
put16bits(write_buffer, 1); // QD (number of questions) put16bits(write_buffer, 1); // QD (number of questions)
put16bits(write_buffer, 1); // AN (number of answers) put16bits(write_buffer, 0); // AN (number of answers)
put16bits(write_buffer, 0); // NS (number of auth RRs) put16bits(write_buffer, 0); // NS (number of auth RRs)
put16bits(write_buffer, 0); // AR (number of Additional RRs) put16bits(write_buffer, 0); // AR (number of Additional RRs)
@ -62,15 +60,6 @@ write404_dnss_response(dnsd_question_request *request)
put16bits(write_buffer, request->question.type); put16bits(write_buffer, request->question.type);
put16bits(write_buffer, request->question.qClass); put16bits(write_buffer, request->question.qClass);
// code answer
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
put16bits(write_buffer, 1); // rdLength
*write_buffer++ = 0; // write a null byte
uint32_t out_bytes = write_buffer - bufferBegin; uint32_t out_bytes = write_buffer - bufferBegin;
llarp::LogDebug("Sending 404, ", out_bytes, " bytes"); llarp::LogDebug("Sending 404, ", 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;
@ -78,21 +67,18 @@ write404_dnss_response(dnsd_question_request *request)
} }
void void
writecname_dnss_response(std::string cname, dnsd_question_request *request) writecname_dnss_response(std::string cname, const dnsd_question_request *request)
{ {
char buf[BUFFER_SIZE] = {0}; char buf[BUFFER_SIZE] = {0};
char *write_buffer = buf; char *write_buffer = buf;
char *bufferBegin = buf; char *bufferBegin = buf;
// build header // build header
put16bits(write_buffer, request->id); put16bits(write_buffer, request->hdr.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)
// fields |= 1UL << 7; // RA recursion available // fields |= 1UL << 7; // RA recursion available
// fields |= 1UL << 8; // RD recursion desired // fields |= 1UL << 8; // RD recursion desired
// fields |= 1UL << 9; // 9 is truncate, forces TCP // fields |= 1UL << 9; // 9 is truncate, forces TCP
put16bits(write_buffer, fields); put16bits(write_buffer, request->hdr.fields() | (1 << 15));
put16bits(write_buffer, 1); // QD (number of questions) put16bits(write_buffer, 1); // QD (number of questions)
put16bits(write_buffer, 1); // AN (number of answers) put16bits(write_buffer, 1); // AN (number of answers)
@ -145,18 +131,16 @@ writecname_dnss_response(std::string cname, dnsd_question_request *request)
} }
void void
writesend_dnss_revresponse(std::string reverse, dnsd_question_request *request) writesend_dnss_revresponse(std::string reverse, const dnsd_question_request *request)
{ {
char buf[BUFFER_SIZE] = {0}; char buf[BUFFER_SIZE] = {0};
char *write_buffer = buf; char *write_buffer = buf;
char *bufferBegin = buf; char *bufferBegin = buf;
// build header // build header
put16bits(write_buffer, request->id); put16bits(write_buffer, request->hdr.id);
int fields = (1 << 15); // QR => message type, 1 = response // response
fields += (0 << 14); // I think opcode is always 0 put16bits(write_buffer,request->hdr.fields() | (1 << 15) | (1 << 10));
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); // QD (number of questions)
put16bits(write_buffer, 1); // AN (number of answers) put16bits(write_buffer, 1); // AN (number of answers)
@ -173,7 +157,7 @@ writesend_dnss_revresponse(std::string reverse, dnsd_question_request *request)
put16bits(write_buffer, request->question.type); put16bits(write_buffer, request->question.type);
put16bits(write_buffer, request->question.qClass); put16bits(write_buffer, request->question.qClass);
put32bits(write_buffer, 1); // ttl put32bits(write_buffer, 1); // ttl
put16bits(write_buffer, reverse.length() + 2); // rdLength put16bits(write_buffer, reverse.size() + 2); // rdLength
code_domain(write_buffer, reverse); code_domain(write_buffer, reverse);
uint32_t out_bytes = write_buffer - bufferBegin; uint32_t out_bytes = write_buffer - bufferBegin;
@ -186,7 +170,7 @@ writesend_dnss_revresponse(std::string reverse, dnsd_question_request *request)
// otherwise ttl, type and class can't be relayed correctly // otherwise ttl, type and class can't be relayed correctly
void void
writesend_dnss_response(llarp::huint32_t *hostRes, writesend_dnss_response(llarp::huint32_t *hostRes,
dnsd_question_request *request) const dnsd_question_request *request)
{ {
// llarp::Addr test(*from); // llarp::Addr test(*from);
// llarp::LogInfo("from ", test); // llarp::LogInfo("from ", test);
@ -202,11 +186,8 @@ writesend_dnss_response(llarp::huint32_t *hostRes,
char *write_buffer = buf; char *write_buffer = buf;
char *bufferBegin = buf; char *bufferBegin = buf;
// build header // build header
put16bits(write_buffer, request->id); put16bits(write_buffer, request->hdr.id);
int fields = (1 << 15); // QR => message type, 1 = response put16bits(write_buffer, request->hdr.fields() | (1 << 15));
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); // QD (number of questions)
put16bits(write_buffer, 1); // AN (number of answers) put16bits(write_buffer, 1); // AN (number of answers)
@ -260,11 +241,8 @@ writesend_dnss_mxresponse(uint16_t priority, std::string mx,
char *write_buffer = buf; char *write_buffer = buf;
char *bufferBegin = buf; char *bufferBegin = buf;
// build header // build header
put16bits(write_buffer, request->id); put16bits(write_buffer, request->hdr.id);
int fields = (1 << 15); // QR => message type, 1 = response put16bits(write_buffer, request->hdr.fields() | (1 << 15));
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); // QD (number of questions)
put16bits(write_buffer, 1); // AN (number of answers) put16bits(write_buffer, 1); // AN (number of answers)
@ -302,11 +280,8 @@ writesend_dnss_txtresponse(std::string txt, const struct sockaddr *from,
char *write_buffer = buf; char *write_buffer = buf;
char *bufferBegin = buf; char *bufferBegin = buf;
// build header // build header
put16bits(write_buffer, request->id); put16bits(write_buffer, request->hdr.id);
int fields = (1 << 15); // QR => message type, 1 = response put16bits(write_buffer, request->hdr.fields() | (1 << 15));
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); // QD (number of questions)
put16bits(write_buffer, 1); // AN (number of answers) put16bits(write_buffer, 1); // AN (number of answers)
@ -347,7 +322,7 @@ handle_dnsc_result(dnsc_answer_request *client_request)
return; return;
} }
client_request->packet.header->id = server_request->id; // stomp ID client_request->packet.header.id = server_request->hdr.id; // stomp ID
std::vector< byte_t > test = packet2bytes(client_request->packet); std::vector< byte_t > test = packet2bytes(client_request->packet);
// llarp::LogInfo("packet2bytes figures we should send ", test.size(), " // llarp::LogInfo("packet2bytes figures we should send ", test.size(), "
// bytes"); // bytes");
@ -396,17 +371,21 @@ handle_dnsc_result(dnsc_answer_request *client_request)
// our generic version // our generic version
void void
handle_recvfrom(llarp_buffer_t buffer, dnsd_question_request *request) handle_recvfrom(llarp_buffer_t * buffer, dnsd_question_request *request)
{ {
const size_t HDR_OFFSET = 12; const size_t HDR_OFFSET = 12;
const char *p_buffer = (const char *)buffer.base; const char *p_buffer = (const char *)buffer->base;
int rcode = (buffer[3] & 0x0F); int rcode = (buffer->base[3] & 0x0F);
llarp::LogDebug("dnsd rcode ", rcode); llarp::LogDebug("dnsd rcode ", rcode);
dns_msg_header *msg = decode_hdr(buffer);
if(!decode_hdr(buffer, &request->hdr))
{
llarp::LogError("failed to decode dns header");
return;
}
p_buffer += HDR_OFFSET; p_buffer += HDR_OFFSET;
request->id = msg->id;
std::string m_qName = ""; std::string m_qName = "";
int length = *p_buffer++; int length = *p_buffer++;
while(length != 0) while(length != 0)
@ -533,9 +512,8 @@ llarp_handle_dnsd_recvfrom(struct llarp_udp_io *udp,
llarp_dns_request->llarp = true; llarp_dns_request->llarp = true;
llarp_dns_request->sendto_hook = llarp_dns_request->sendto_hook =
&llarp_sendto_dns_hook_func; // set sock hook &llarp_sendto_dns_hook_func; // set sock hook
// llarp::LogInfo("Server request's UDP ", llarp_dns_request->user); // llarp::LogInfo("Server request's UDP ", llarp_dns_request->user);
handle_recvfrom(buf, llarp_dns_request); handle_recvfrom(&buf, llarp_dns_request);
} }
void void
@ -555,7 +533,7 @@ raw_handle_recvfrom(int *sockfd, const struct sockaddr *saddr,
llarp_dns_request->llarp = false; llarp_dns_request->llarp = false;
llarp_dns_request->sendto_hook = &raw_sendto_dns_hook_func; llarp_dns_request->sendto_hook = &raw_sendto_dns_hook_func;
handle_recvfrom(buffer, llarp_dns_request); handle_recvfrom(&buffer, llarp_dns_request);
} }
bool bool

6
llarp/ev.hpp
Unescape Escape View File

@ -357,7 +357,7 @@ namespace llarp
} }
virtual int virtual int
read(void* buf, size_t sz) = 0; read(byte_t* buf, size_t sz) = 0;
virtual int virtual int
sendto(__attribute__((unused)) const sockaddr* dst, sendto(__attribute__((unused)) const sockaddr* dst,
@ -579,7 +579,7 @@ namespace llarp
do_write(void* buf, size_t sz); do_write(void* buf, size_t sz);
virtual int virtual int
read(void* buf, size_t sz); read(byte_t* buf, size_t sz);
bool bool
tick(); tick();
@ -605,7 +605,7 @@ namespace llarp
/// actually does accept() :^) /// actually does accept() :^)
virtual int virtual int
read(void*, size_t); read(byte_t*, size_t);
}; };
}; // namespace llarp }; // namespace llarp

16
llarp/ev_epoll.hpp
Unescape Escape View File

@ -24,7 +24,7 @@
namespace llarp namespace llarp
{ {
int int
tcp_conn::read(void* buf, size_t sz) tcp_conn::read(byte_t* buf, size_t sz)
{ {
if(_shouldClose) if(_shouldClose)
return -1; return -1;
@ -93,7 +93,7 @@ namespace llarp
} }
int int
tcp_serv::read(void*, size_t) tcp_serv::read(byte_t*, size_t)
{ {
int new_fd = ::accept(fd, nullptr, nullptr); int new_fd = ::accept(fd, nullptr, nullptr);
if(new_fd == -1) if(new_fd == -1)
@ -134,17 +134,21 @@ namespace llarp
} }
int int
read(void* buf, size_t sz) read(byte_t* buf, size_t sz)
{ {
llarp_buffer_t b;
b.base = buf;
b.cur = b.base;
sockaddr_in6 src; sockaddr_in6 src;
socklen_t slen = sizeof(sockaddr_in6); socklen_t slen = sizeof(sockaddr_in6);
sockaddr* addr = (sockaddr*)&src; sockaddr* addr = (sockaddr*)&src;
ssize_t ret = ::recvfrom(fd, buf, sz, 0, addr, &slen); ssize_t ret = ::recvfrom(fd, b.base, sz, 0, addr, &slen);
if(ret < 0) if(ret < 0)
return -1; return -1;
if(static_cast< size_t >(ret) > sz) if(static_cast< size_t >(ret) > sz)
return -1; return -1;
udp->recvfrom(udp, addr, llarp::InitBuffer(buf, ret)); b.sz = ret;
udp->recvfrom(udp, addr, b);
return 0; return 0;
} }
@ -213,7 +217,7 @@ namespace llarp
} }
int int
read(void* buf, size_t sz) read(byte_t * buf, size_t sz)
{ {
ssize_t ret = tuntap_read(tunif, buf, sz); ssize_t ret = tuntap_read(tunif, buf, sz);
if(ret > 0 && t->recvpkt) if(ret > 0 && t->recvpkt)

35
test/test_dns_unit.cpp
Unescape Escape View File

@ -92,7 +92,10 @@ TEST_F(DNSTest, TestCodeDomain)
TEST_F(DNSTest, TestDecodeHdr) TEST_F(DNSTest, TestDecodeHdr)
{ {
dns_msg_header *hdr = decode_hdr(this->buffer_t); dns_msg_header hdr;
ASSERT_TRUE(decode_hdr(&this->buffer_t, &hdr));
// rewind
buffer_t.cur = buffer_t.base;
/* /*
printf("id[%d]", hdr->id); printf("id[%d]", hdr->id);
printf("qr[%d]", hdr->qr); printf("qr[%d]", hdr->qr);
@ -110,21 +113,21 @@ TEST_F(DNSTest, TestDecodeHdr)
printf("ns[%d]", hdr->nsCount); printf("ns[%d]", hdr->nsCount);
printf("ar[%d]", hdr->arCount); printf("ar[%d]", hdr->arCount);
*/ */
ASSERT_TRUE(hdr->id == 1); ASSERT_TRUE(hdr.id == 1);
ASSERT_TRUE(hdr->qr == 0); ASSERT_TRUE(hdr.qr == 0);
ASSERT_TRUE(hdr->opcode == 0); ASSERT_TRUE(hdr.opcode == 0);
ASSERT_TRUE(hdr->aa == 0); ASSERT_TRUE(hdr.aa == 0);
ASSERT_TRUE(hdr->tc == 0); ASSERT_TRUE(hdr.tc == 0);
ASSERT_TRUE(hdr->rd == 0); ASSERT_TRUE(hdr.rd == 0);
ASSERT_TRUE(hdr->ra == 0); ASSERT_TRUE(hdr.ra == 0);
ASSERT_TRUE(hdr->z == 0); ASSERT_TRUE(hdr.z == 0);
ASSERT_TRUE(hdr->ad == 0); ASSERT_TRUE(hdr.ad == 0);
ASSERT_TRUE(hdr->cd == 0); ASSERT_TRUE(hdr.cd == 0);
ASSERT_TRUE(hdr->rcode == 0); ASSERT_TRUE(hdr.rcode == 0);
ASSERT_TRUE(hdr->qdCount == 1); ASSERT_TRUE(hdr.qdCount == 1);
ASSERT_TRUE(hdr->anCount == 1); ASSERT_TRUE(hdr.anCount == 1);
ASSERT_TRUE(hdr->nsCount == 0); ASSERT_TRUE(hdr.nsCount == 0);
ASSERT_TRUE(hdr->arCount == 0); ASSERT_TRUE(hdr.arCount == 0);
} }
TEST_F(DNSTest, TestDecodeQuestion) TEST_F(DNSTest, TestDecodeQuestion)

2
test/test_dnsd_unit.cpp
Unescape Escape View File

@ -33,7 +33,7 @@ struct llarpDNSdTest : public ::testing::Test
void void
SetUp() SetUp()
{ {
test_request.id = 0; test_request.hdr.id = 0;
test_request.llarp = true; // we don't care about raw atm test_request.llarp = true; // we don't care about raw atm
test_request.from = nullptr; test_request.from = nullptr;
test_request.context = nullptr; test_request.context = nullptr;

Write Preview
Loading…
Cancel
Save