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.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
struct dns_tracker *tracker = (struct dns_tracker *)dnsd.client.tracker;
struct dnsc_answer_request *request =
tracker->client_request[hdr->id].get();
tracker->client_request[hdr.id].get();
if(request)
{
request->packet.header = hdr;
generic_handle_dnsc_recvfrom(tracker->client_request[hdr->id].get(),
lbuffer, hdr);
generic_handle_dnsc_recvfrom(tracker->client_request[hdr.id].get(),
lbuffer, &hdr);
}
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,

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

@ -49,6 +49,7 @@ struct dns_tracker
struct dns_msg_header
{
uint16_t id;
uint8_t qr : 1;
uint8_t opcode : 4;
uint8_t aa : 1;
@ -61,6 +62,12 @@ struct dns_msg_header
uint8_t cd : 1;
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 anCount;
uint16_t nsCount;
@ -87,7 +94,7 @@ struct dns_msg_answer
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_answer > > answers;
std::vector< std::unique_ptr< dns_msg_answer > > auth_rrs;
@ -120,8 +127,8 @@ extern "C"
uint32_t
get32bits(const char *&buffer) throw();
dns_msg_header *
decode_hdr(llarp_buffer_t &buffer);
bool
decode_hdr(llarp_buffer_t * buffer, dns_msg_header * hdr);
dns_msg_question *
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 *
llarp_dotlokilookup_handler(std::string name,
struct dnsd_question_request *const request);
const dnsd_question_request * request);
#endif

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

@ -25,8 +25,8 @@ struct dnsd_question_request
void *user;
// raw or llarp subsystem (is this used? does this matter?)
bool llarp;
/// request id
unsigned int id;
/// request header
dns_msg_header hdr;
/// question being asked
dns_msg_question question;
// request source socket
@ -64,22 +64,22 @@ llarp_handle_dnsd_recvfrom(struct llarp_udp_io *udp,
/// NXDOMAIN not found
void
write404_dnss_response(dnsd_question_request *request);
write404_dnss_response(const dnsd_question_request *request);
/// for hook functions to use
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
/// send an A record found response
void
writesend_dnss_response(llarp::huint32_t *hostRes,
dnsd_question_request *request);
const dnsd_question_request *request);
// FIXME: llarp::Addr
/// send an PTR record found response
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
//
@ -88,7 +88,7 @@ writesend_dnss_revresponse(std::string reverse, dnsd_question_request *request);
/// intercept query hook functor
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
/// 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
// llarp::LogInfo("Writing ", domain[i], " at ", i);
}
*buffer++ = 0;
}
@ -235,11 +234,11 @@ std::vector< byte_t >
packet2bytes(dns_packet &in)
{
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
fields += (in.header->opcode << 14); // I think opcode is always 0
fields += in.header->rcode; // response code (3 => not found, 0 = Ok)
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.rcode; // response code (3 => not found, 0 = Ok)
vput16bits(write_buffer, fields);
// don't pull these from the header, trust what we actually have more
@ -308,19 +307,24 @@ extern "C"
return value;
}
dns_msg_header *
decode_hdr(llarp_buffer_t &buffer)
bool
decode_hdr(llarp_buffer_t * buffer, dns_msg_header * hdr)
{
dns_msg_header *hdr = new dns_msg_header;
uint16_t fields;
// reads as network byte order
llarp_buffer_read_uint16(&buffer, &hdr->id);
llarp_buffer_read_uint16(&buffer, &fields);
llarp_buffer_read_uint16(&buffer, &hdr->qdCount);
llarp_buffer_read_uint16(&buffer, &hdr->anCount);
llarp_buffer_read_uint16(&buffer, &hdr->nsCount);
llarp_buffer_read_uint16(&buffer, &hdr->arCount);
// reads as HOST byte order
if(!llarp_buffer_read_uint16(buffer, &hdr->id))
return false;
if(!llarp_buffer_read_uint16(buffer, &fields))
return false;
if(!llarp_buffer_read_uint16(buffer, &hdr->qdCount))
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
uint8_t lFields = (fields & 0x00FF) >> 0;
@ -340,8 +344,7 @@ extern "C"
hdr->ad = (lFields >> 5) & 0x1;
hdr->cd = (lFields >> 4) & 0x1;
hdr->rcode = lFields & 0xf;
return hdr;
return true;
}
dns_msg_question *
@ -604,10 +607,16 @@ extern "C"
const struct sockaddr *addr, llarp_buffer_t buf)
{
// auto buffer = llarp::StackBuffer< decltype(castBuf) >(castBuf);
dns_msg_header *hdr = decode_hdr(buf);
// castBuf += 12;
llarp::LogDebug("msg id ", hdr->id);
llarp::LogDebug("msg qr ", (uint8_t)hdr->qr);
dns_msg_header hdr;
if(!decode_hdr(&buf, &hdr))
{
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)
{
llarp::LogError("no udp passed in to handler");
@ -616,7 +625,7 @@ extern "C"
{
llarp::LogError("no source addr passed in to handler");
}
if(hdr->qr)
if(hdr.qr)
{
llarp::LogDebug("handling as dnsc answer");
llarp_handle_dnsc_recvfrom(udp, addr, buf);
@ -626,6 +635,5 @@ extern "C"
llarp::LogDebug("handling as dnsd question");
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
// const struct sockaddr *from; // source
dnsd_question_request *request;
const dnsd_question_request *request;
};
std::unordered_map< std::string, struct dnsd_query_hook_response * >
@ -216,7 +216,7 @@ struct reverse_handler_iter_context
{
std::string lName;
// 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)
@ -260,53 +260,46 @@ ReverseHandlerIter(struct llarp::service::Context::endpoint_iter *endpointCfg)
llarp::iprange_ipv4(std::stoi(tokensCheck[0]), std::stoi(tokensCheck[1]),
std::stoi(tokensCheck[2]), std::stoi(tokensCheck[3]),
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(
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(
llarp::huint32_t searchIPv4 = llarp::ipaddr_ipv4_bits(
std::stoi(tokensSearch[searchTokens - 3]),
std::stoi(tokensSearch[searchTokens - 4]),
std::stoi(tokensSearch[searchTokens - 5]),
std::stoi(tokensSearch[searchTokens - 6])); // create ip
// bool inRange = range.Contains(searchAddr.xtohl());
bool inRange = range.Contains(searchIPv4_search);
bool inRange = range.Contains(searchIPv4);
llarp::Addr searchAddr(searchIp);
llarp::Addr checkAddr(checkIp);
llarp::LogDebug(searchAddr, " vs ", range, " = ",
llarp::LogInfo(searchIPv4, " vs ", range, " = ",
inRange ? "inRange" : "not match");
if(inRange)
{
llarp::AlignedBuffer<32> addr =
tunEndpoint->ObtainAddrForIP< llarp::AlignedBuffer<32> >(
searchIPv4_fixed, false);
searchIPv4, false);
if(addr.IsZero())
{
addr =
tunEndpoint->ObtainAddrForIP< llarp::AlignedBuffer<32> >(
searchIPv4_fixed, true);
searchIPv4, true);
if(!addr.IsZero())
{
char stack[128] = {0};
std::string saddr = llarp::HexEncode(addr, stack);
saddr += ".snode";
writesend_dnss_revresponse(saddr,
(dnsd_question_request *)context->request);
writesend_dnss_revresponse(saddr, context->request);
}
else
write404_dnss_response((dnsd_question_request *)context->request);
write404_dnss_response(context->request);
}
else
{
// llarp::LogInfo("Returning [", addr.ToString(), "]");
llarp::service::Address saddr = addr.data();
writesend_dnss_revresponse(saddr.ToString(),
(dnsd_question_request *)context->request);
// llarp::LogInfo("Returning [", saddr.ToString(), "]");
writesend_dnss_revresponse(saddr.ToString(), context->request);
}
return false;
}
@ -330,7 +323,7 @@ static bool should_intercept_query_with_name(const std::string & lName)
dnsd_query_hook_response *
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;
response->dontLookUp = false;
@ -369,6 +362,7 @@ llarp_dotlokilookup_handler(std::string name,
if(!res)
{
llarp::LogDebug("Reverse is ours");
response->dontLookUp = true;
response->dontSendResponse = true; // should have already sent it
}
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.qClass = 1;
request->packet.header = nullptr;
// register our self with the tracker
dns_tracker *tracker = request->context->tracker;
if(!tracker)
@ -633,22 +631,28 @@ raw_resolve_host(struct dnsc_context *const dnsc, const char *url,
// unsigned char *castBuf = (unsigned char *)buffer;
// auto buffer = llarp::StackBuffer< decltype(castBuf) >(castBuf);
dns_msg_header *hdr = decode_hdr(lbuffer);
llarp::LogInfo("response header says it belongs to id #", hdr->id);
dns_msg_header hdr;
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
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)
{
request->packet.header = hdr;
generic_handle_dnsc_recvfrom(tracker->client_request[hdr->id].get(),
lbuffer, hdr);
generic_handle_dnsc_recvfrom(tracker->client_request[hdr.id].get(),
lbuffer, &hdr);
}
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");
}
// 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
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
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
if(request)
{
generic_handle_dnsc_recvfrom(request, buf, hdr);
generic_handle_dnsc_recvfrom(request, buf, &hdr);
}
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
write404_dnss_response(dnsd_question_request *request)
write404_dnss_response(const dnsd_question_request *request)
{
char buf[BUFFER_SIZE] = {0};
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 += 3; // response code (3 => not found, 0 = Ok)
put16bits(write_buffer, fields);
put16bits(write_buffer, request->hdr.id);
// not found flag set
put16bits(write_buffer, (1 << 15) | request->hdr.fields() | 3);
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); // 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.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;
llarp::LogDebug("Sending 404, ", out_bytes, " bytes");
// struct llarp_udp_io *udp = (struct llarp_udp_io *)request->user;
@ -78,21 +67,18 @@ write404_dnss_response(dnsd_question_request *request)
}
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 *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)
put16bits(write_buffer, request->hdr.id);
// fields |= 1UL << 7; // RA recursion available
// fields |= 1UL << 8; // RD recursion desired
// 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); // AN (number of answers)
@ -145,18 +131,16 @@ writecname_dnss_response(std::string cname, dnsd_question_request *request)
}
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 *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)
put16bits(write_buffer, fields);
put16bits(write_buffer, request->hdr.id);
// response
put16bits(write_buffer,request->hdr.fields() | (1 << 15) | (1 << 10));
put16bits(write_buffer, 1); // QD (number of questions)
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.qClass);
put32bits(write_buffer, 1); // ttl
put16bits(write_buffer, reverse.length() + 2); // rdLength
put16bits(write_buffer, reverse.size() + 2); // rdLength
code_domain(write_buffer, reverse);
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
void
writesend_dnss_response(llarp::huint32_t *hostRes,
dnsd_question_request *request)
const dnsd_question_request *request)
{
// llarp::Addr test(*from);
// llarp::LogInfo("from ", test);
@ -202,11 +186,8 @@ writesend_dnss_response(llarp::huint32_t *hostRes,
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)
put16bits(write_buffer, fields);
put16bits(write_buffer, request->hdr.id);
put16bits(write_buffer, request->hdr.fields() | (1 << 15));
put16bits(write_buffer, 1); // QD (number of questions)
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 *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)
put16bits(write_buffer, fields);
put16bits(write_buffer, request->hdr.id);
put16bits(write_buffer, request->hdr.fields() | (1 << 15));
put16bits(write_buffer, 1); // QD (number of questions)
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 *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)
put16bits(write_buffer, fields);
put16bits(write_buffer, request->hdr.id);
put16bits(write_buffer, request->hdr.fields() | (1 << 15));
put16bits(write_buffer, 1); // QD (number of questions)
put16bits(write_buffer, 1); // AN (number of answers)
@ -347,7 +322,7 @@ handle_dnsc_result(dnsc_answer_request *client_request)
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);
// llarp::LogInfo("packet2bytes figures we should send ", test.size(), "
// bytes");
@ -396,17 +371,21 @@ handle_dnsc_result(dnsc_answer_request *client_request)
// our generic version
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 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);
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;
request->id = msg->id;
std::string m_qName = "";
int length = *p_buffer++;
while(length != 0)
@ -533,9 +512,8 @@ llarp_handle_dnsd_recvfrom(struct llarp_udp_io *udp,
llarp_dns_request->llarp = true;
llarp_dns_request->sendto_hook =
&llarp_sendto_dns_hook_func; // set sock hook
// llarp::LogInfo("Server request's UDP ", llarp_dns_request->user);
handle_recvfrom(buf, llarp_dns_request);
handle_recvfrom(&buf, llarp_dns_request);
}
void
@ -555,7 +533,7 @@ raw_handle_recvfrom(int *sockfd, const struct sockaddr *saddr,
llarp_dns_request->llarp = false;
llarp_dns_request->sendto_hook = &raw_sendto_dns_hook_func;
handle_recvfrom(buffer, llarp_dns_request);
handle_recvfrom(&buffer, llarp_dns_request);
}
bool

6
llarp/ev.hpp
Unescape Escape View File

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

16
llarp/ev_epoll.hpp
Unescape Escape View File

@ -24,7 +24,7 @@
namespace llarp
{
int
tcp_conn::read(void* buf, size_t sz)
tcp_conn::read(byte_t* buf, size_t sz)
{
if(_shouldClose)
return -1;
@ -93,7 +93,7 @@ namespace llarp
}
int
tcp_serv::read(void*, size_t)
tcp_serv::read(byte_t*, size_t)
{
int new_fd = ::accept(fd, nullptr, nullptr);
if(new_fd == -1)
@ -134,17 +134,21 @@ namespace llarp
}
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;
socklen_t slen = sizeof(sockaddr_in6);
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)
return -1;
if(static_cast< size_t >(ret) > sz)
return -1;
udp->recvfrom(udp, addr, llarp::InitBuffer(buf, ret));
b.sz = ret;
udp->recvfrom(udp, addr, b);
return 0;
}
@ -213,7 +217,7 @@ namespace llarp
}
int
read(void* buf, size_t sz)
read(byte_t * buf, size_t sz)
{
ssize_t ret = tuntap_read(tunif, buf, sz);
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)
{
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("qr[%d]", hdr->qr);
@ -110,21 +113,21 @@ TEST_F(DNSTest, TestDecodeHdr)
printf("ns[%d]", hdr->nsCount);
printf("ar[%d]", hdr->arCount);
*/
ASSERT_TRUE(hdr->id == 1);
ASSERT_TRUE(hdr->qr == 0);
ASSERT_TRUE(hdr->opcode == 0);
ASSERT_TRUE(hdr->aa == 0);
ASSERT_TRUE(hdr->tc == 0);
ASSERT_TRUE(hdr->rd == 0);
ASSERT_TRUE(hdr->ra == 0);
ASSERT_TRUE(hdr->z == 0);
ASSERT_TRUE(hdr->ad == 0);
ASSERT_TRUE(hdr->cd == 0);
ASSERT_TRUE(hdr->rcode == 0);
ASSERT_TRUE(hdr->qdCount == 1);
ASSERT_TRUE(hdr->anCount == 1);
ASSERT_TRUE(hdr->nsCount == 0);
ASSERT_TRUE(hdr->arCount == 0);
ASSERT_TRUE(hdr.id == 1);
ASSERT_TRUE(hdr.qr == 0);
ASSERT_TRUE(hdr.opcode == 0);
ASSERT_TRUE(hdr.aa == 0);
ASSERT_TRUE(hdr.tc == 0);
ASSERT_TRUE(hdr.rd == 0);
ASSERT_TRUE(hdr.ra == 0);
ASSERT_TRUE(hdr.z == 0);
ASSERT_TRUE(hdr.ad == 0);
ASSERT_TRUE(hdr.cd == 0);
ASSERT_TRUE(hdr.rcode == 0);
ASSERT_TRUE(hdr.qdCount == 1);
ASSERT_TRUE(hdr.anCount == 1);
ASSERT_TRUE(hdr.nsCount == 0);
ASSERT_TRUE(hdr.arCount == 0);
}
TEST_F(DNSTest, TestDecodeQuestion)

2
test/test_dnsd_unit.cpp
Unescape Escape View File

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

Write Preview
Loading…
Cancel
Save