oxen-io/lokinet
1
1
Fork 0
mirror of https://github.com/oxen-io/lokinet synced 2023-12-14 06:53:00 +01:00
Code Issues Projects Releases Wiki Activity

Merge remote-tracking branch 'ryan/libdns' into hidden-service-dht

Browse source 
also run make format
This commit is contained in:
Jeff Becker 2018-07-17 07:26:16 +10:00
parent bce3cd85c6 f9512f7e28
commit f48acbc23e
9 changed files with 964 additions and 443 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

21
CMakeLists.txt
View file

@ -166,10 +166,16 @@ set(CPP_BACKPORT_SRC
set(LIB_PLATFORM_SRC
# for outpug
llarp/logger.cpp
# needed for threading
llarp/logic.cpp
# for zero (for net.hpp stuff for llarp::addr stuff)
llarp/mem.cpp
# for networking
llarp/ev.cpp
# for timer
llarp/time.cpp
# for logic
llarp/timer.cpp
# for threading
llarp/threadpool.cpp
)
@ -183,13 +189,14 @@ set(LIB_SRC
llarp/crypto_async.cpp
llarp/crypto_libsodium.cpp
llarp/dht.cpp
llarp/dnsc.cpp
llarp/dnsd.cpp
llarp/encode.cpp
llarp/encrypted_frame.cpp
llarp/exit_info.cpp
llarp/exit_route.cpp
llarp/link_intro.cpp
llarp/link_message.cpp
llarp/logic.cpp
llarp/net.cpp
llarp/nodedb.cpp
llarp/path.cpp
@ -204,8 +211,7 @@ set(LIB_SRC
llarp/service.cpp
llarp/transit_hop.cpp
llarp/testnet.c
llarp/time.cpp
llarp/timer.cpp
llarp/api/create_session.cpp
llarp/api/client.cpp
llarp/api/message.cpp
llarp/api/parser.cpp
@ -239,6 +245,13 @@ set(LIB_SRC
${LIBTUNTAP_SRC}
)
set(DNS_SRC
llarp/dnsc.cpp
llarp/dnsd.cpp
llarp/net.cpp
daemon/dns.cpp
)
set(TEST_SRC
test/main.cpp
test/api_unittest.cpp
@ -277,7 +290,7 @@ else()
add_executable(rcutil daemon/rcutil.cpp)
add_executable(${EXE} ${EXE_SRC})
add_executable(${CLIENT_EXE} ${CLIENT_SRC})
add_executable(dns daemon/dns.cpp)
add_executable(dns ${DNS_SRC})
if(WITH_TESTS)
enable_testing()

541
daemon/dns.cpp
View file

@ -4,19 +4,15 @@
#include <stdio.h> /* fprintf, printf */
#include <unistd.h>
#include <netdb.h> /* getaddrinfo, getnameinfo */
#include <stdlib.h> /* exit */
#include <string.h> /* memset */
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string>
#include <llarp/logic.h>
#include "dnsd.hpp"
#include "ev.hpp"
#include "logger.hpp"
#include "net.hpp"
#include <thread> // for multithreaded version
#include <vector>
bool done = false;
void
@ -26,449 +22,124 @@ handle_signal(int sig)
done = true;
}
#define BUF_SIZE 512
struct query
{
uint16_t length;
char *url;
unsigned char request[BUF_SIZE];
uint16_t reqType;
};
#define SERVER "8.8.8.8"
#define PORT 53
struct sockaddr *
resolveHost(char *url)
{
struct query dnsQuery;
dnsQuery.length = 12;
dnsQuery.url = url;
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;
unsigned int i;
llarp::LogDebug("Asking DNS server %s about %s\n", SERVER, url);
dnsQuery.url = strdup(url);
dnsQuery.reqType = 0x01;
word = strtok(url, ".");
while(word)
{
llarp::LogDebug("parsing hostname: \"%s\" is %zu characters\n", word,
strlen(word));
dnsQuery.request[dnsQuery.length++] = strlen(word);
for(i = 0; i < strlen(word); i++)
{
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;
struct sockaddr_in addr;
// int socket;
ssize_t ret;
int rcode;
socklen_t size;
int ip = 0;
int length;
unsigned char buffer[BUF_SIZE];
// unsigned char tempBuf[3];
uint16_t QDCOUNT; // No. of items in Question Section
uint16_t ANCOUNT; // No. of items in Answer Section
uint16_t NSCOUNT; // No. of items in Authority Section
uint16_t ARCOUNT; // No. of items in Additional Section
uint16_t QCLASS; // Specifies the class of the query
uint16_t ATYPE; // Specifies the meaning of the data in the RDATA field
uint16_t ACLASS; // Specifies the class of the data in the RDATA field
uint32_t TTL; // The number of seconds the results can be cached
uint16_t RDLENGTH; // The length of the RDATA field
uint16_t MSGID;
int sockfd;
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if(sockfd < 0)
{
llarp::LogWarn("Error creating socket!\n");
return nullptr;
}
// socket = sockfd;
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);
// hexdump("sending packet", &dnsQuery.request, dnsQuery.length);
ret = sendto(sockfd, dnsQuery.request, dnsQuery.length, 0,
(struct sockaddr *)&addr, size);
if(ret < 0)
{
llarp::LogWarn("Error Sending Request");
return nullptr;
}
// printf("Sent\n");
memset(&buffer, 0, BUF_SIZE);
ret = recvfrom(sockfd, buffer, BUF_SIZE, 0, (struct sockaddr *)&addr, &size);
if(ret < 0)
{
llarp::LogWarn("Error Receiving Response");
return nullptr;
}
// hexdump("received packet", &buffer, ret);
close(sockfd);
rcode = (buffer[3] & 0x0F);
// tempBuf[0] = buffer[4];
// tempBuf[1] = buffer[5];
// tempBuf[2] = '\0';
// printf("%0x %0x %0x %0x\n", buffer[4], buffer[5], tempBuf[0], tempBuf[1]);
// 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);
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);
length = dnsQuery.length + 1; // to skip 0xc00c
ATYPE = (uint16_t)buffer[length + 1] * 0x100 + buffer[length + 2];
llarp::LogDebug("answer type: %u\n", ATYPE);
ACLASS = (uint16_t)buffer[length + 3] * 0x100 + buffer[length + 4];
llarp::LogDebug("answer class: %u\n", ACLASS);
TTL = (uint32_t)buffer[length + 5] * 0x1000000 + buffer[length + 6] * 0x10000
+ buffer[length + 7] * 0x100 + buffer[length + 8];
llarp::LogDebug("seconds to cache: %u\n", TTL);
RDLENGTH = (uint16_t)buffer[length + 9] * 0x100 + buffer[length + 10];
llarp::LogDebug("bytes in answer: %u\n", RDLENGTH);
MSGID = (uint16_t)buffer[0] * 0x100 + buffer[1];
llarp::LogDebug("answer msg id: %u\n", MSGID);
if(rcode == 2)
{
llarp::LogWarn("nameserver %s returned SERVFAIL:\n", SERVER);
llarp::LogWarn(
" the name server was unable to process this query due to a\n "
"problem with the name server.\n");
return nullptr;
}
else if(rcode == 3)
{
llarp::LogWarn("nameserver %s returned NXDOMAIN for %s:\n", SERVER,
dnsQuery.url);
llarp::LogWarn(
" the domain name referenced in the query does not exist\n");
return nullptr;
}
/* search for and print IPv4 addresses */
if(dnsQuery.reqType == 0x01)
{
llarp::LogDebug("DNS server's answer is: (type#=%u):", ATYPE);
// printf("IPv4 address(es) for %s:\n", dnsQuery.url);
for(i = 0; i < ret; i++)
{
if(buffer[i] == 0xC0 && buffer[i + 3] == 0x01)
{
ip++;
i += 12; /* ! += buf[i+1]; */
llarp::LogDebug(" %u.%u.%u.%u\n", buffer[i], buffer[i + 1],
buffer[i + 2], buffer[i + 3]);
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;
// have ip point to s_addr
ip = (unsigned char *)&(addr->s_addr);
ip[0] = buffer[i + 0];
ip[1] = buffer[i + 1];
ip[2] = buffer[i + 2];
ip[3] = buffer[i + 3];
return g_addr;
}
}
if(!ip)
{
llarp::LogWarn(" No IPv4 address found in the DNS response!\n");
return nullptr;
}
}
return nullptr;
}
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 & 0xFF0000) >> 16;
buffer[2] = (value & 0xFF00) >> 16;
buffer[3] = (value & 0xFF) >> 16;
buffer += 4;
}
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;
};
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(std::string::size_type 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;
}
struct dns_response
{
std::string m_name;
uint m_type;
uint m_class;
unsigned long m_ttl;
uint m_rdLength;
std::string m_rdata;
};
int
main(int argc, char *argv[])
{
int code = 1;
llarp::LogInfo("Starting up server");
struct sockaddr_in m_address;
int m_sockfd;
// llarp::SetLogLevel(llarp::eLogDebug);
m_sockfd = socket(AF_INET, SOCK_DGRAM, 0);
m_address.sin_family = AF_INET;
m_address.sin_addr.s_addr = INADDR_ANY;
m_address.sin_port = htons(1053);
int rbind =
bind(m_sockfd, (struct sockaddr *)&m_address, sizeof(struct sockaddr_in));
if(rbind != 0)
if(1)
{
llarp::LogError("Could not bind: ", strerror(errno));
return 0;
}
// libev version
llarp_ev_loop *netloop = nullptr;
llarp_threadpool *worker = nullptr;
llarp_logic *logic = nullptr;
const size_t BUFFER_SIZE = 1024;
const size_t HDR_OFFSET = 12;
char buffer[BUFFER_SIZE]; // 1024 is buffer size
struct sockaddr_in clientAddress;
socklen_t addrLen = sizeof(struct sockaddr_in);
llarp_ev_loop_alloc(&netloop);
signal(SIGINT, handle_signal);
while(!done)
{
// sigint quits after next packet
int nbytes = recvfrom(m_sockfd, buffer, BUFFER_SIZE, 0,
(struct sockaddr *)&clientAddress, &addrLen);
llarp::LogInfo("Received Bytes ", nbytes);
// configure main netloop
llarp_udp_io udp;
llarp::Addr p_addr;
sockaddr_in ip4addr;
sockaddr *addr = nullptr;
addr = (sockaddr *)&ip4addr;
llarp::Zero(addr, sizeof(ip4addr));
addr->sa_family = AF_INET;
const char *p_buffer = buffer;
dns_msg *msg = decode_hdr(p_buffer);
// llarp::LogInfo("DNS_MSG size", sizeof(dns_msg));
p_buffer += HDR_OFFSET;
std::string m_qName = "";
int length = *p_buffer++;
// llarp::LogInfo("qNamLen", length);
while(length != 0)
// FIXME: make configureable
ip4addr.sin_port = htons(1053);
p_addr = *addr;
udp.user = nullptr;
udp.recvfrom = &llarp_handle_recvfrom;
llarp::LogDebug("bind DNS Server to ", addr);
if(llarp_ev_add_udp(netloop, &udp, p_addr) == -1)
{
for(int i = 0; i < length; i++)
llarp::LogError("failed to bind to ", addr);
return false;
}
// singlethreaded
if(0)
{
llarp::LogInfo("singlethread start");
worker = llarp_init_same_process_threadpool();
logic = llarp_init_single_process_logic(worker);
llarp_ev_loop_run_single_process(netloop, worker, logic);
llarp::LogInfo("singlethread end");
}
else
{
llarp::LogInfo("multithreaded start");
// create 2 workers
worker = llarp_init_threadpool(2, "llarp-worker");
logic = llarp_init_logic();
auto netio = netloop;
int num_nethreads = 1;
std::vector< std::thread > netio_threads;
while(num_nethreads--)
{
char c = *p_buffer++;
m_qName.append(1, c);
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
}
length = *p_buffer++;
if(length != 0)
m_qName.append(1, '.');
llarp_logic_mainloop(logic);
llarp::LogInfo("multithreaded end");
}
uint m_qType = get16bits(p_buffer);
uint m_qClass = get16bits(p_buffer);
llarp::LogInfo("qName ", m_qName);
llarp::LogInfo("qType ", m_qType);
llarp::LogInfo("qClass ", m_qClass);
std::string copy(m_qName);
sockaddr *hostRes = resolveHost((char *)copy.c_str());
if(!hostRes)
{
exit(0);
}
llarp::Addr anIp(*hostRes);
llarp::LogInfo("DNS got ", anIp);
/*
m_query.decode(buffer, nbytes);
m_query.asString();
m_resolver.process(m_query, m_response);
m_response.asString();
*/
memset(buffer, 0, BUFFER_SIZE);
char *write_buffer = buffer;
char *bufferBegin = buffer;
// build header
put16bits(write_buffer, msg->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, 1); // QD (number of questions)
put16bits(write_buffer, 1); // AN (number of answers)
put16bits(write_buffer, 0); // NS (number of auth RRs)
put16bits(write_buffer, 0); // AR (number of Additional RRs)
write_buffer += HDR_OFFSET;
// code question
llarp::LogInfo("qName2 ", m_qName);
// 0123456789
// 3bob3com1\0
code_domain(write_buffer, m_qName);
put16bits(write_buffer, m_qType);
put16bits(write_buffer, m_qClass);
// code answer
std::string resp_str(inet_ntoa(*anIp.addr4()));
code_domain(write_buffer, "");
put16bits(write_buffer, m_qType);
put16bits(write_buffer, m_qClass);
put32bits(write_buffer, 0); // ttl
put16bits(write_buffer, 1); // rdLength
uint out_bytes = write_buffer - bufferBegin;
llarp::LogInfo("Sending ", out_bytes, " bytes");
// nbytes = m_response.code(buffer);
sendto(m_sockfd, buffer, out_bytes, 0, (struct sockaddr *)&clientAddress,
addrLen);
llarp_ev_loop_free(&netloop);
}
/*
std::string host("www.google.com");
sockaddr *hostRes = resolveHost((char *)host.c_str());
if (!hostRes)
else
{
exit(0);
struct sockaddr_in m_address;
int m_sockfd;
m_sockfd = socket(AF_INET, SOCK_DGRAM, 0);
m_address.sin_family = AF_INET;
m_address.sin_addr.s_addr = INADDR_ANY;
m_address.sin_port = htons(1053);
int rbind = bind(m_sockfd, (struct sockaddr *)&m_address,
sizeof(struct sockaddr_in));
if(rbind != 0)
{
llarp::LogError("Could not bind: ", strerror(errno));
return 0;
}
const size_t BUFFER_SIZE = 1024;
char buffer[BUFFER_SIZE]; // 1024 is buffer size
struct sockaddr_in clientAddress;
socklen_t addrLen = sizeof(struct sockaddr_in);
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = 100 * 1000; // 1 sec
if(setsockopt(m_sockfd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)) < 0)
{
perror("Error");
}
signal(SIGINT, handle_signal);
while(!done)
{
// sigint quits after next packet
int nbytes = recvfrom(m_sockfd, buffer, BUFFER_SIZE, 0,
(struct sockaddr *)&clientAddress, &addrLen);
if(nbytes == -1)
continue;
llarp::LogInfo("Received Bytes ", nbytes);
raw_handle_recvfrom(&m_sockfd, (const struct sockaddr *)&clientAddress,
buffer, nbytes);
}
}
llarp::Addr anIp(*hostRes);
llarp::LogInfo("DNS got ", anIp);
*/
return code;
}

53
include/llarp/dns.h Normal file
View file

@ -0,0 +1,53 @@
#ifndef LLARP_DNS_H_
#define LLARP_DNS_H_
#include <llarp/ev.h>
#include <sys/types.h> // for uint & ssize_t
/**
* dns.h
*
* dns client/server
*/
#define DNC_BUF_SIZE 512
struct dns_query
{
uint16_t length;
char *url;
unsigned char request[DNC_BUF_SIZE];
uint16_t reqType;
};
struct dns_client_request;
typedef void (*resolve_dns_hook_func)(dns_client_request *request,
struct sockaddr *);
struct dns_client_request
{
/// sock type
void *sock;
/// customizeable (used for outer request)
void *user;
/// storage
dns_query query;
/// hook
resolve_dns_hook_func resolved;
};
struct sockaddr *
resolveHost(const char *url);
bool
llarp_resolve_host(struct llarp_ev_loop *, const char *url,
resolve_dns_hook_func resolved, void *user);
void
llarp_handle_recvfrom(struct llarp_udp_io *udp, const struct sockaddr *saddr,
const void *buf, ssize_t sz);
void
raw_handle_recvfrom(int *sockfd, const struct sockaddr *saddr, const void *buf,
ssize_t sz);
#endif

5
llarp/context.cpp
View file

@ -197,8 +197,9 @@ namespace llarp
#if(__APPLE__ && __MACH__)
#elif(__FreeBSD__)
pthread_set_name_np(netio_threads.back().native_handle(), "llarp-"
"netio");
pthread_set_name_np(netio_threads.back().native_handle(),
"llarp-"
"netio");
#else
pthread_setname_np(netio_threads.back().native_handle(), "llarp-netio");
#endif

480
llarp/dnsc.cpp Normal file
View file

@ -0,0 +1,480 @@
#include "dnsd.hpp"
#include <netdb.h> /* getaddrinfo, getnameinfo */
#include <stdlib.h> /* exit */
#include <string.h> /* memset */
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h> /* close */
#include <arpa/inet.h>
#include <netinet/in.h>
#include <llarp/dns.h>
#include "logger.hpp"
// FIXME: make configurable
#define SERVER "8.8.8.8"
#define PORT 53
struct sockaddr *
resolveHost(const char *url)
{
char *sUrl = strdup(url);
struct dns_query dnsQuery;
dnsQuery.length = 12;
dnsQuery.url = sUrl;
dnsQuery.reqType = 0x01;
// dnsQuery.request = { 0xDB, 0x42, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00 };
dnsQuery.request[0] = 0xDB;
dnsQuery.request[1] = 0x42;
dnsQuery.request[2] = 0x01;
dnsQuery.request[3] = 0x00;
dnsQuery.request[4] = 0x00;
dnsQuery.request[5] = 0x01;
dnsQuery.request[6] = 0x00;
dnsQuery.request[7] = 0x00;
dnsQuery.request[8] = 0x00;
dnsQuery.request[9] = 0x00;
dnsQuery.request[10] = 0x00;
dnsQuery.request[11] = 0x00;
char *word;
unsigned int i;
llarp::LogDebug("Asking DNS server %s about %s\n", SERVER, url);
// dnsQuery.reqType = 0x01;
word = strtok(sUrl, ".");
while(word)
{
llarp::LogDebug("parsing hostname: \"%s\" is %zu characters\n", word,
strlen(word));
dnsQuery.request[dnsQuery.length++] = strlen(word);
for(i = 0; i < strlen(word); i++)
{
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;
struct sockaddr_in addr;
// int socket;
ssize_t ret;
int rcode;
socklen_t size;
int ip = 0;
int length;
unsigned char buffer[DNC_BUF_SIZE];
// unsigned char tempBuf[3];
uint16_t QDCOUNT; // No. of items in Question Section
uint16_t ANCOUNT; // No. of items in Answer Section
uint16_t NSCOUNT; // No. of items in Authority Section
uint16_t ARCOUNT; // No. of items in Additional Section
uint16_t QCLASS; // Specifies the class of the query
uint16_t ATYPE; // Specifies the meaning of the data in the RDATA field
uint16_t ACLASS; // Specifies the class of the data in the RDATA field
uint32_t TTL; // The number of seconds the results can be cached
uint16_t RDLENGTH; // The length of the RDATA field
uint16_t MSGID;
int sockfd;
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if(sockfd < 0)
{
llarp::LogWarn("Error creating socket!\n");
return nullptr;
}
// socket = sockfd;
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);
// hexdump("sending packet", &dnsQuery.request, dnsQuery.length);
ret = sendto(sockfd, dnsQuery.request, dnsQuery.length, 0,
(struct sockaddr *)&addr, size);
if(ret < 0)
{
llarp::LogWarn("Error Sending Request");
return nullptr;
}
// printf("Sent\n");
memset(&buffer, 0, DNC_BUF_SIZE);
ret = recvfrom(sockfd, buffer, DNC_BUF_SIZE, 0, (struct sockaddr *)&addr,
&size);
if(ret < 0)
{
llarp::LogWarn("Error Receiving Response");
return nullptr;
}
// hexdump("received packet", &buffer, ret);
close(sockfd);
rcode = (buffer[3] & 0x0F);
// tempBuf[0] = buffer[4];
// tempBuf[1] = buffer[5];
// tempBuf[2] = '\0';
// printf("%0x %0x %0x %0x\n", buffer[4], buffer[5], tempBuf[0], tempBuf[1]);
// 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);
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);
length = dnsQuery.length + 1; // to skip 0xc00c
ATYPE = (uint16_t)buffer[length + 1] * 0x100 + buffer[length + 2];
llarp::LogDebug("answer type: %u\n", ATYPE);
ACLASS = (uint16_t)buffer[length + 3] * 0x100 + buffer[length + 4];
llarp::LogDebug("answer class: %u\n", ACLASS);
TTL = (uint32_t)buffer[length + 5] * 0x1000000 + buffer[length + 6] * 0x10000
+ buffer[length + 7] * 0x100 + buffer[length + 8];
llarp::LogDebug("seconds to cache: %u\n", TTL);
RDLENGTH = (uint16_t)buffer[length + 9] * 0x100 + buffer[length + 10];
llarp::LogDebug("bytes in answer: %u\n", RDLENGTH);
MSGID = (uint16_t)buffer[0] * 0x100 + buffer[1];
llarp::LogDebug("answer msg id: %u\n", MSGID);
if(rcode == 2)
{
llarp::LogWarn("nameserver %s returned SERVFAIL:\n", SERVER);
llarp::LogWarn(
" the name server was unable to process this query due to a\n "
"problem with the name server.\n");
return nullptr;
}
else if(rcode == 3)
{
llarp::LogWarn("nameserver %s returned NXDOMAIN for %s:\n", SERVER,
dnsQuery.url);
llarp::LogWarn(
" the domain name referenced in the query does not exist\n");
return nullptr;
}
/* search for and print IPv4 addresses */
if(dnsQuery.reqType == 0x01)
{
llarp::LogDebug("DNS server's answer is: (type#=%u):", ATYPE);
// printf("IPv4 address(es) for %s:\n", dnsQuery.url);
for(i = 0; i < ret; i++)
{
if(buffer[i] == 0xC0 && buffer[i + 3] == 0x01)
{
ip++;
i += 12; /* ! += buf[i+1]; */
llarp::LogDebug(" %u.%u.%u.%u\n", buffer[i], buffer[i + 1],
buffer[i + 2], buffer[i + 3]);
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;
// have ip point to s_addr
ip = (unsigned char *)&(addr->s_addr);
ip[0] = buffer[i + 0];
ip[1] = buffer[i + 1];
ip[2] = buffer[i + 2];
ip[3] = buffer[i + 3];
return g_addr;
}
}
if(!ip)
{
llarp::LogWarn(" No IPv4 address found in the DNS response!\n");
return nullptr;
}
}
return nullptr;
}
void
llarp_handle_dnsclient_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;
if(!request)
{
llarp::LogError(
"User data to DNS Client response not a dns_client_request");
// we can't call back the hook
return;
}
// it's corrupt by here...
dns_request *server_request = (dns_request *)request->user;
// 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);
return;
}
// 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
uint16_t ARCOUNT; // No. of items in Additional Section
uint16_t QCLASS; // Specifies the class of the query
uint16_t ATYPE; // Specifies the meaning of the data in the RDATA field
uint16_t ACLASS; // Specifies the class of the data in the RDATA field
uint32_t TTL; // The number of seconds the results can be cached
uint16_t RDLENGTH; // The length of the RDATA field
uint16_t MSGID;
int rcode;
int length;
struct dns_query *dnsQuery = &request->query;
rcode = (buffer[3] & 0x0F);
// tempBuf[0] = buffer[4];
// tempBuf[1] = buffer[5];
// tempBuf[2] = '\0';
// printf("%0x %0x %0x %0x\n", buffer[4], buffer[5], tempBuf[0], tempBuf[1]);
// 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);
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);
length = dnsQuery->length + 1; // to skip 0xc00c
ATYPE = (uint16_t)buffer[length + 1] * 0x100 + buffer[length + 2];
llarp::LogDebug("answer type: %u\n", ATYPE);
ACLASS = (uint16_t)buffer[length + 3] * 0x100 + buffer[length + 4];
llarp::LogDebug("answer class: %u\n", ACLASS);
TTL = (uint32_t)buffer[length + 5] * 0x1000000 + buffer[length + 6] * 0x10000
+ buffer[length + 7] * 0x100 + buffer[length + 8];
llarp::LogDebug("seconds to cache: %u\n", TTL);
RDLENGTH = (uint16_t)buffer[length + 9] * 0x100 + buffer[length + 10];
llarp::LogDebug("bytes in answer: %u\n", RDLENGTH);
MSGID = (uint16_t)buffer[0] * 0x100 + buffer[1];
llarp::LogDebug("answer msg id: %u\n", MSGID);
if(rcode == 2)
{
llarp::LogWarn("nameserver %s returned SERVFAIL:\n", SERVER);
llarp::LogWarn(
" the name server was unable to process this query due to a\n "
"problem with the name server.\n");
request->resolved(request, nullptr);
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);
return;
}
int ip = 0;
/* search for and print IPv4 addresses */
if(dnsQuery->reqType == 0x01)
{
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++)
{
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;
// have ip point to s_addr
ip = (unsigned char *)&(addr->s_addr);
ip[0] = buffer[i + 0];
ip[1] = buffer[i + 1];
ip[2] = buffer[i + 2];
ip[3] = buffer[i + 3];
// return g_addr;
request->resolved(request, g_addr);
return;
}
}
if(!ip)
{
llarp::LogWarn(" No IPv4 address found in the DNS response!\n");
request->resolved(request, nullptr);
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)
{
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];
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);
llarp_udp_io *udp = (llarp_udp_io *)request->sock;
// llarp::LogDebug("dns client set to use ");
udp->user = request;
// 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);
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;
}
bool
llarp_resolve_host(struct llarp_ev_loop *netloop, const char *url,
resolve_dns_hook_func resolved, void *user)
{
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);
return true;
}

6
llarp/dnsc.hpp Normal file
View file

@ -0,0 +1,6 @@
#ifndef LIBLLARP_DNSC_HPP
#define LIBLLARP_DNSC_HPP
#include <llarp/dns.h>
#endif

256
llarp/dnsd.cpp Normal file
View file

@ -0,0 +1,256 @@
#include "dnsd.hpp"
#include <string>
#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()
{
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(int i = start; i < domain.size(); i++)
{
*buffer++ = domain[i]; // last label octets
// llarp::LogInfo("Writing ", domain[i], " at ", i);
}
*buffer++ = 0;
}
ssize_t
raw_sendto_dns_hook_func(void *sock, const struct sockaddr *from,
const void *buffer, size_t length)
{
int *fd = (int *)sock;
// how do we get to these??
socklen_t addrLen = sizeof(struct sockaddr_in);
return sendto(*fd, buffer, length, 0, from, addrLen);
}
ssize_t
llarp_sendto_dns_hook_func(void *sock, const struct sockaddr *from,
const void *buffer, size_t length)
{
struct llarp_udp_io *udp = (struct llarp_udp_io *)sock;
if(!udp)
{
return 0;
}
return llarp_ev_udp_sendto(udp, from, buffer, length);
}
bool
forward_dns_request(std::string request)
{
return true;
}
void
writesend_dnss_response(struct sockaddr *hostRes, const struct sockaddr *from,
dns_request *request)
{
if(!hostRes)
{
llarp::LogWarn("Failed to resolve");
// FIXME: actually return correct packet
return;
}
const size_t BUFFER_SIZE = 1024;
char buf[BUFFER_SIZE];
memset(buf, 0, BUFFER_SIZE);
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, 1); // QD (number of questions)
put16bits(write_buffer, 1); // AN (number of answers)
put16bits(write_buffer, 0); // NS (number of auth RRs)
put16bits(write_buffer, 0); // AR (number of Additional RRs)
// code question
code_domain(write_buffer, request->m_qName);
put16bits(write_buffer, request->m_qType);
put16bits(write_buffer, request->m_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
// has to be a string of 4 bytes
struct sockaddr_in *sin = (struct sockaddr_in *)hostRes;
unsigned char *ip = (unsigned char *)&sin->sin_addr.s_addr;
put16bits(write_buffer, 4); // rdLength
*write_buffer++ = ip[0];
*write_buffer++ = ip[1];
*write_buffer++ = ip[2];
*write_buffer++ = ip[3];
uint out_bytes = write_buffer - bufferBegin;
llarp::LogInfo("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)
{
llarp::LogInfo("phase2");
// 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);
}
void
handle_recvfrom(const char *buffer, ssize_t nbytes, const struct sockaddr *from,
dns_request *request)
{
const size_t HDR_OFFSET = 12;
const char *p_buffer = buffer;
dns_msg *msg = decode_hdr(p_buffer);
// llarp::LogInfo("DNS_MSG size", sizeof(dns_msg));
p_buffer += HDR_OFFSET;
request->id = msg->id;
std::string m_qName = "";
int length = *p_buffer++;
// llarp::LogInfo("qNamLen", length);
while(length != 0)
{
for(int i = 0; i < length; i++)
{
char c = *p_buffer++;
m_qName.append(1, c);
}
length = *p_buffer++;
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);
if(!forward_dns_request(m_qName))
{
// told that hook will handle overrides
return;
}
sockaddr *hostRes = nullptr;
if(0)
{
hostRes = resolveHost(m_qName.c_str());
llarp::Addr anIp(*hostRes);
llarp::LogInfo("DNS got ", anIp);
// writesend_dnss_response(struct sockaddr *hostRes, const struct sockaddr
// *from, dns_request *request)
writesend_dnss_response(hostRes, from, 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);
}
}
// this is called in net threadpool
void
llarp_handle_recvfrom(struct llarp_udp_io *udp, const struct sockaddr *saddr,
const void *buf, ssize_t sz)
{
// llarp_link *link = static_cast< llarp_link * >(udp->user);
llarp::LogInfo("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);
}
void
raw_handle_recvfrom(int *sockfd, const struct sockaddr *saddr, const void *buf,
ssize_t sz)
{
llarp::LogInfo("Received Bytes ", sz);
dns_request llarp_dns_request;
llarp_dns_request.from = (struct sockaddr *)saddr;
llarp_dns_request.user = (void *)sockfd;
llarp_dns_request.hook = &raw_sendto_dns_hook_func;
handle_recvfrom((char *)buf, sz, saddr, &llarp_dns_request);
}

40
llarp/dnsd.hpp Normal file
View file

@ -0,0 +1,40 @@
#ifndef LIBLLARP_DNSD_HPP
#define LIBLLARP_DNSD_HPP
#include <string>
#include "dnsc.hpp"
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;
};
typedef ssize_t (*sendto_dns_hook_func)(void *sock, const struct sockaddr *from,
const void *buffer, size_t length);
struct dns_request
{
/// sock type
void *user;
/// request id
int id;
std::string m_qName;
uint m_qType;
uint m_qClass;
struct sockaddr *from;
sendto_dns_hook_func hook; // sendto hook tbh
};
#endif

5
llarp/iwp/frame_state.cpp
View file

@ -93,8 +93,9 @@ frame_state::got_xmit(frame_header hdr, size_t sz)
{
auto msg = new transit_message(x);
rx[id] = msg;
llarp::LogDebug("got message XMIT with ", (int)x.numfrags(), " fragment"
"s");
llarp::LogDebug("got message XMIT with ", (int)x.numfrags(),
" fragment"
"s");
// inserted, put last fragment
msg->put_lastfrag(hdr.data() + sizeof(x.buffer), x.lastfrag());
push_ackfor(id, 0);