Updated DNS module for windows (may broke linux support)
This commit is contained in:
WolverinDEV
parent
6c618d189f
commit
273c3b966e
2
github
2
github
@ -1 +1 @@
|
||||
Subproject commit 14645dca78396c915ad4ad122d532f24fdfd2969
|
||||
Subproject commit a1490ab0d97f65e27845fec6daf88be8ed6d1014
|
||||
@ -1,17 +1,26 @@
|
||||
set(MODULE_NAME "teaclient_dns")
|
||||
|
||||
set(SOURCE_FILES ${SOURCE_FILES} src/resolver.cpp src/types.cpp src/response.cpp utils.cpp src/resolver_linux.cpp)
|
||||
set(SOURCE_FILES ${SOURCE_FILES} src/resolver.cpp src/types.cpp src/response.cpp utils.cpp)
|
||||
if (WIN32)
|
||||
set(SOURCE_FILES ${SOURCE_FILES} src/resolver_windows.cpp)
|
||||
else()
|
||||
set(SOURCE_FILES ${SOURCE_FILES} src/resolver_linux.cpp src/resolver_windows.cpp)
|
||||
endif()
|
||||
|
||||
find_package(Libevent REQUIRED)
|
||||
include_directories(${LIBEVENT_INCLUDE_DIRS})
|
||||
|
||||
if(NOT WIN32)
|
||||
find_package(unbound REQUIRED)
|
||||
endif()
|
||||
|
||||
add_nodejs_module(${MODULE_NAME} binding.cc ${SOURCE_FILES})
|
||||
target_link_libraries(${MODULE_NAME} unbound::static ${LIBEVENT_STATIC_LIBRARIES} pthread)
|
||||
|
||||
add_executable(DNS-Test ${SOURCE_FILES} test/main.cpp)
|
||||
target_link_libraries(DNS-Test unbound::static ssl crypto ${LIBEVENT_STATIC_LIBRARIES} pthread)
|
||||
|
||||
add_executable(DNS-Test2 test/crash.cpp)
|
||||
target_link_libraries(DNS-Test2 unbound::static ssl crypto ${LIBEVENT_STATIC_LIBRARIES} pthread)
|
||||
if (WIN32)
|
||||
target_link_libraries(${MODULE_NAME} ${LIBEVENT_STATIC_LIBRARIES} Ws2_32.lib Ntdll.lib Dnsapi.lib)
|
||||
target_link_libraries(DNS-Test ${LIBEVENT_STATIC_LIBRARIES} Ws2_32.lib Ntdll.lib Dnsapi.lib)
|
||||
else()
|
||||
target_link_libraries(${MODULE_NAME} unbound::static ${LIBEVENT_STATIC_LIBRARIES} pthread)
|
||||
target_link_libraries(DNS-Test unbound::static ssl crypto ${LIBEVENT_STATIC_LIBRARIES} pthread)
|
||||
endif()
|
||||
@ -21,7 +21,11 @@ NAN_METHOD(initialize) {
|
||||
return;
|
||||
}
|
||||
|
||||
//evthread_use_pthreads();
|
||||
#ifdef WIN32
|
||||
evthread_use_windows_threads();
|
||||
#else
|
||||
evthread_use_pthreads();
|
||||
#endif
|
||||
resolver = make_unique<tc::dns::Resolver>();
|
||||
|
||||
string error;
|
||||
@ -77,11 +81,11 @@ NAN_METHOD(query_connect_address) {
|
||||
tc::dns::cr(*resolver,
|
||||
tc::dns::ServerAddress{ *host, (uint16_t) port },
|
||||
[callback = std::move(callback)] (bool success, std::variant<std::string, tc::dns::ServerAddress> data) mutable {
|
||||
callback.call_cpy(success, success ? "" : std::get<std::string>(data), !success ? tc::dns::ServerAddress{"", 0} : std::get<tc::dns::ServerAddress>(data));
|
||||
callback.call_cpy(success, success ? "" : std::get<std::string>(data), !success ? tc::dns::ServerAddress{"", 0} : std::get<tc::dns::ServerAddress>(data), false);
|
||||
});
|
||||
}
|
||||
|
||||
__attribute__((visibility("default"))) NAN_MODULE_INIT(init) {
|
||||
NAN_MODULE_INIT(init) {
|
||||
Nan::Set(target,
|
||||
v8::String::NewFromUtf8(Nan::GetCurrentContext()->GetIsolate(), "resolve_cr").ToLocalChecked(),
|
||||
Nan::GetFunction(Nan::New<v8::FunctionTemplate>(query_connect_address)).ToLocalChecked()
|
||||
|
||||
@ -4,19 +4,19 @@
|
||||
#include <cassert>
|
||||
#include <functional>
|
||||
#include <event.h>
|
||||
#include <unbound.h>
|
||||
#include <unbound-event.h>
|
||||
#include <iostream>
|
||||
#include <cstring>
|
||||
#include <utility>
|
||||
|
||||
#include <fcntl.h> /* for TSDNS */
|
||||
#include <unistd.h>
|
||||
#ifdef WIN32
|
||||
#include <ws2tcpip.h>
|
||||
#define SOCK_NONBLOCK (0)
|
||||
#define MSG_DONTWAIT (0)
|
||||
#else
|
||||
#include <unistd.h>
|
||||
#include <unbound.h>
|
||||
#include <unbound-event.h>
|
||||
#include <sys/socket.h>
|
||||
#endif
|
||||
|
||||
@ -29,6 +29,77 @@ Resolver::~Resolver() {
|
||||
this->finalize();
|
||||
}
|
||||
|
||||
|
||||
bool Resolver::initialize(std::string &error, bool hosts, bool resolv) {
|
||||
if(this->event.loop_active)
|
||||
this->finalize();
|
||||
|
||||
this->event.loop_active = true;
|
||||
this->event.base = event_base_new();
|
||||
if(!this->event.base) {
|
||||
error = "failed to allcoate event base";
|
||||
return false;
|
||||
}
|
||||
this->event.loop = std::thread(std::bind(&Resolver::event_loop_runner, this));
|
||||
|
||||
return this->initialize_platform(error, hosts, resolv);
|
||||
}
|
||||
|
||||
void Resolver::finalize() {
|
||||
this->event.loop_active = false;
|
||||
if(this->event.base) {
|
||||
auto ret = event_base_loopexit(this->event.base, nullptr);
|
||||
if(ret != 0) {
|
||||
cerr << "Failed to exit event base loop: " << ret << endl;
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
this->event.condition.notify_one();
|
||||
if(this->event.loop.joinable())
|
||||
this->event.loop.join();
|
||||
}
|
||||
|
||||
{
|
||||
unique_lock lock(this->request_lock);
|
||||
auto dns_list = std::move(this->dns_requests);
|
||||
auto tsdns_list = std::move(this->tsdns_requests);
|
||||
|
||||
for(auto entry : dns_list) {
|
||||
entry->callback(ResultState::ABORT, 0, nullptr);
|
||||
this->destroy_dns_request(entry);
|
||||
}
|
||||
|
||||
for(auto entry : tsdns_list) {
|
||||
entry->callback(ResultState::ABORT, 0, "");
|
||||
this->destroy_tsdns_request(entry);
|
||||
}
|
||||
lock.unlock();
|
||||
}
|
||||
|
||||
this->finalize_platform(); /* keep the event base allocated until platform depend finalize has been done */
|
||||
if(this->event.base) {
|
||||
event_base_free(this->event.base);
|
||||
this->event.base = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
void Resolver::event_loop_runner() {
|
||||
while(true) {
|
||||
{
|
||||
unique_lock lock{this->event.lock};
|
||||
if(!this->event.loop_active)
|
||||
break;
|
||||
|
||||
this->event.condition.wait(lock);
|
||||
if(!this->event.loop_active)
|
||||
break;
|
||||
}
|
||||
|
||||
event_base_loop(this->event.base, 0);
|
||||
}
|
||||
}
|
||||
|
||||
void Resolver::destroy_tsdns_request(Resolver::tsdns_request *request) {
|
||||
assert(this_thread::get_id() == this->event.loop.get_id() || !this->event.loop_active);
|
||||
|
||||
@ -58,8 +129,10 @@ void Resolver::destroy_tsdns_request(Resolver::tsdns_request *request) {
|
||||
if(request->socket > 0) {
|
||||
#ifndef WIN32
|
||||
::shutdown(request->socket, SHUT_RDWR);
|
||||
#endif
|
||||
::close(request->socket);
|
||||
#else
|
||||
closesocket(request->socket);
|
||||
#endif
|
||||
request->socket = 0;
|
||||
}
|
||||
|
||||
@ -71,28 +144,42 @@ void Resolver::resolve_tsdns(const char *query, const sockaddr_storage& server_a
|
||||
/* create the socket */
|
||||
auto socket = ::socket(server_address.ss_family, SOCK_STREAM | SOCK_NONBLOCK, 0);
|
||||
if(socket <= 0) {
|
||||
callback(ResultState::INITIALISATION_FAILED, -1, "failed to allocate socket: " + to_string(errno) + "/" + strerror(errno));
|
||||
#ifdef WIN32
|
||||
char buf[1024];
|
||||
strerror_s(buf, errno);
|
||||
std::string strerr{buf};
|
||||
#else
|
||||
std::string strerr{strerror(errno)};
|
||||
#endif
|
||||
callback(ResultState::INITIALISATION_FAILED, -1, "failed to allocate socket: " + to_string(errno) + "/" + strerr);
|
||||
return;
|
||||
}
|
||||
|
||||
#ifdef WIN32
|
||||
u_long enabled = 0;
|
||||
auto non_block_rs = ioctlsocket(this->_socket, FIONBIO, &enabled);
|
||||
auto non_block_rs = ioctlsocket(socket, FIONBIO, &enabled);
|
||||
if (non_block_rs != NO_ERROR) {
|
||||
::close(socket);
|
||||
callback(ResultState::INITIALISATION_FAILED, -2, "failed to enable nonblock: " + to_string(errno) + "/" + strerror(errno));
|
||||
#ifdef WIN32
|
||||
char buf[1024];
|
||||
strerror_s(buf, errno);
|
||||
std::string strerr{buf};
|
||||
#else
|
||||
std::string strerr{strerror(errno)};
|
||||
#endif
|
||||
closesocket(socket);
|
||||
callback(ResultState::INITIALISATION_FAILED, -2, "failed to enable nonblock: " + to_string(errno) + "/" + strerr);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
|
||||
#else
|
||||
int opt = 1;
|
||||
setsockopt(socket, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(int));
|
||||
#endif
|
||||
|
||||
auto request = new tsdns_request{};
|
||||
|
||||
request->resolver = this;
|
||||
request->callback = callback;
|
||||
request->socket = socket;
|
||||
request->socket = (int) socket;
|
||||
request->timeout_event = evtimer_new(this->event.base, [](evutil_socket_t, short, void *_request) {
|
||||
auto request = static_cast<tsdns_request*>(_request);
|
||||
request->resolver->evtimer_tsdns_callback(request);
|
||||
@ -122,23 +209,21 @@ void Resolver::resolve_tsdns(const char *query, const sockaddr_storage& server_a
|
||||
auto error = WSAGetLastError();
|
||||
|
||||
if(error != WSAEWOULDBLOCK) {
|
||||
/*
|
||||
* TODO!
|
||||
wchar_t *s = nullptr;
|
||||
FormatMessageW(
|
||||
char* s = nullptr;
|
||||
FormatMessageA(
|
||||
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
|
||||
nullptr,
|
||||
error,
|
||||
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
|
||||
(LPWSTR)&s,
|
||||
(LPSTR) &s,
|
||||
0,
|
||||
nullptr
|
||||
);
|
||||
fprintf(stdout, "Connect failed with code %d. Error: %ld/%S\n", result, error, s);
|
||||
LocalFree(s);
|
||||
*/
|
||||
|
||||
callback(ResultState::TSDNS_CONNECTION_FAIL, -1, "Failed to connect");
|
||||
std::string message{s};
|
||||
LocalFree(s);
|
||||
|
||||
callback(ResultState::TSDNS_CONNECTION_FAIL, -1, "Failed to connect: " + message);
|
||||
this->destroy_tsdns_request(request);
|
||||
}
|
||||
#else
|
||||
@ -157,7 +242,7 @@ void Resolver::resolve_tsdns(const char *query, const sockaddr_storage& server_a
|
||||
auto seconds = chrono::floor<chrono::seconds>(timeout);
|
||||
auto microseconds = chrono::ceil<chrono::microseconds>(timeout - seconds);
|
||||
|
||||
timeval tv{seconds.count(), microseconds.count()};
|
||||
timeval tv{(long) seconds.count(), (long) microseconds.count()};
|
||||
auto errc = event_add(request->timeout_event, &tv);
|
||||
|
||||
//TODO: Check for error
|
||||
@ -214,7 +299,7 @@ void Resolver::event_tsdns_write(Resolver::tsdns_request *request) {
|
||||
if(request->write_buffer.empty())
|
||||
return;
|
||||
|
||||
auto written = send(request->socket, request->write_buffer.data(), min(request->write_buffer.size(), 1024UL), MSG_DONTWAIT);
|
||||
auto written = send(request->socket, request->write_buffer.data(), (int) min(request->write_buffer.size(), 1024UL), MSG_DONTWAIT);
|
||||
if(written < 0) {
|
||||
#ifdef WIN32
|
||||
auto error = WSAGetLastError();
|
||||
|
||||
@ -9,7 +9,9 @@
|
||||
#include <event.h>
|
||||
|
||||
#include "./types.h"
|
||||
#ifndef WIN32
|
||||
#ifdef WIN32
|
||||
#include <WinDNS.h>
|
||||
#else
|
||||
struct ub_ctx;
|
||||
#endif
|
||||
|
||||
@ -22,7 +24,8 @@ namespace tc::dns {
|
||||
|
||||
struct DNSResponseData {
|
||||
#ifdef WIN32
|
||||
//IMPLEMENT ME!
|
||||
bool wide_string{false};
|
||||
DNS_QUERY_RESULT data;
|
||||
#else
|
||||
uint8_t* buffer{nullptr};
|
||||
size_t length{0};
|
||||
@ -68,11 +71,10 @@ namespace tc::dns {
|
||||
|
||||
std::string bogus;
|
||||
uint8_t secure_state{0};
|
||||
|
||||
std::shared_ptr<DNSResponseData> data{nullptr};
|
||||
#else
|
||||
|
||||
DNSResponse(std::shared_ptr<DNSResponseData>);
|
||||
#endif
|
||||
std::shared_ptr<DNSResponseData> data{nullptr};
|
||||
|
||||
bool is_parsed{false};
|
||||
std::string parse_error{};
|
||||
@ -93,6 +95,7 @@ namespace tc::dns {
|
||||
|
||||
DNS_TIMEOUT = 0x10,
|
||||
DNS_FAIL = 0x11, /* error detail is a DNS error code */
|
||||
DNS_API_FAIL = 0x12,
|
||||
|
||||
TSDNS_CONNECTION_FAIL = 0x20,
|
||||
TSDNS_EMPTY_RESPONSE = 0x21,
|
||||
@ -113,21 +116,59 @@ namespace tc::dns {
|
||||
void resolve_dns(const char* /* name */, const rrtype::value& /* rrtype */, const rrclass::value& /* rrclass */, const std::chrono::microseconds& /* timeout */, const dns_callback_t& /* callback */);
|
||||
void resolve_tsdns(const char* /* name */, const sockaddr_storage& /* server */, const std::chrono::microseconds& /* timeout */, const tsdns_callback_t& /* callback */);
|
||||
private:
|
||||
#ifndef WIN32
|
||||
#ifdef WIN32
|
||||
struct dns_request;
|
||||
struct dns_old_request_data {
|
||||
/* request might me nullptr if its beeing timeouted */
|
||||
struct dns_request* request{nullptr}; /* protected by lock */
|
||||
std::mutex* lock{nullptr};
|
||||
};
|
||||
|
||||
struct {
|
||||
HMODULE libhandle{nullptr};
|
||||
|
||||
DNS_STATUS (*DnsQueryEx)(
|
||||
_In_ PDNS_QUERY_REQUEST pQueryRequest,
|
||||
_Inout_ PDNS_QUERY_RESULT pQueryResults,
|
||||
_Inout_opt_ PDNS_QUERY_CANCEL pCancelHandle
|
||||
) = nullptr;
|
||||
|
||||
DNS_STATUS (*DnsCancelQuery)(
|
||||
_In_ PDNS_QUERY_CANCEL pCancelHandle
|
||||
) = nullptr;
|
||||
} dnsapi;
|
||||
#endif
|
||||
|
||||
struct dns_request {
|
||||
Resolver* resolver{nullptr};
|
||||
|
||||
int ub_id{0};
|
||||
struct ::event* timeout_event{nullptr};
|
||||
struct ::event* register_event{nullptr};
|
||||
|
||||
std::string host;
|
||||
dns::rrtype::value rrtype{dns::rrtype::Unassigned};
|
||||
dns::rrclass::value rrclass{dns::rrclass::IN};
|
||||
|
||||
dns_callback_t callback{};
|
||||
#ifdef WIN32
|
||||
std::wstring whost;
|
||||
|
||||
/* windows 8 or newer */
|
||||
DNS_QUERY_REQUEST dns_query;
|
||||
DNS_QUERY_RESULT dns_result;
|
||||
DNS_QUERY_CANCEL dns_cancel;
|
||||
|
||||
/* for old stuff */
|
||||
//std::thread resolve_thread;
|
||||
std::mutex* threaded_lock{nullptr};
|
||||
struct dns_old_request_data* thread_data{nullptr}; /* protected by threaded_lock */
|
||||
#else
|
||||
|
||||
int ub_id{0};
|
||||
struct ::event* register_event{nullptr};
|
||||
#endif
|
||||
struct ::event* timeout_event{nullptr};
|
||||
struct ::event* processed_event{nullptr};
|
||||
};
|
||||
|
||||
#ifndef WIN32
|
||||
struct ub_ctx* ub_ctx = nullptr;
|
||||
#endif
|
||||
struct tsdns_request {
|
||||
@ -156,21 +197,22 @@ namespace tc::dns {
|
||||
|
||||
|
||||
std::vector<tsdns_request*> tsdns_requests{};
|
||||
#ifndef WIN32
|
||||
std::vector<dns_request*> dns_requests{};
|
||||
#endif
|
||||
std::recursive_mutex request_lock{}; /* this is recursive because due to the instance callback resolve_dns could be called recursively */
|
||||
|
||||
#ifndef WIN32
|
||||
bool initialize_platform(std::string& /* error */, bool /* use hosts */, bool /* use resolv */);
|
||||
void finalize_platform();
|
||||
|
||||
void destroy_dns_request(dns_request*);
|
||||
#endif
|
||||
void destroy_tsdns_request(tsdns_request*);
|
||||
|
||||
void event_loop_runner();
|
||||
|
||||
#ifndef WIN32
|
||||
void evtimer_dns_callback(dns_request* /* request */);
|
||||
#ifndef WIN32
|
||||
void ub_callback(dns_request* /* request */, int /* rcode */, void* /* packet */, int /* packet_len */, int /* sec */, char* /* why_bogus */);
|
||||
#else
|
||||
void dns_callback(dns_request* /* request */);
|
||||
#endif
|
||||
|
||||
void evtimer_tsdns_callback(tsdns_request* /* request */);
|
||||
|
||||
@ -16,18 +16,7 @@
|
||||
using namespace std;
|
||||
using namespace tc::dns;
|
||||
|
||||
bool Resolver::initialize(std::string &error, bool hosts, bool resolv) {
|
||||
if(this->event.loop_active)
|
||||
this->finalize();
|
||||
|
||||
this->event.loop_active = true;
|
||||
this->event.base = event_base_new();
|
||||
if(!this->event.base) {
|
||||
error = "failed to allcoate event base";
|
||||
return false;
|
||||
}
|
||||
this->event.loop = std::thread(std::bind(&Resolver::event_loop_runner, this));
|
||||
|
||||
bool Resolver::initialize_platform(std::string &error, bool hosts, bool resolv) {
|
||||
this->ub_ctx = ub_ctx_create_event(this->event.base);
|
||||
if(!this->ub_ctx) {
|
||||
this->finalize();
|
||||
@ -50,63 +39,9 @@ bool Resolver::initialize(std::string &error, bool hosts, bool resolv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
void Resolver::finalize() {
|
||||
this->event.loop_active = false;
|
||||
if(this->event.base) {
|
||||
auto ret = event_base_loopexit(this->event.base, nullptr);
|
||||
if(ret != 0) {
|
||||
cerr << "Failed to exit event base loop: " << ret << endl;
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
this->event.condition.notify_one();
|
||||
if(this->event.loop.joinable())
|
||||
this->event.loop.join();
|
||||
}
|
||||
|
||||
{
|
||||
unique_lock lock(this->request_lock);
|
||||
auto dns_list = std::move(this->dns_requests);
|
||||
auto tsdns_list = std::move(this->tsdns_requests);
|
||||
|
||||
for(auto entry : dns_list) {
|
||||
ub_cancel(this->ub_ctx, entry->ub_id);
|
||||
|
||||
entry->callback(ResultState::ABORT, 0, nullptr);
|
||||
this->destroy_dns_request(entry);
|
||||
}
|
||||
|
||||
for(auto entry : tsdns_list) {
|
||||
entry->callback(ResultState::ABORT, 0, "");
|
||||
this->destroy_tsdns_request(entry);
|
||||
}
|
||||
lock.unlock();
|
||||
}
|
||||
|
||||
void Resolver::finalize_platform() {
|
||||
ub_ctx_delete((struct ub_ctx*) this->ub_ctx);
|
||||
this->ub_ctx = nullptr;
|
||||
|
||||
if(this->event.base) {
|
||||
event_base_free(this->event.base);
|
||||
this->event.base = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
void Resolver::event_loop_runner() {
|
||||
while(true) {
|
||||
{
|
||||
unique_lock lock{this->event.lock};
|
||||
if(!this->event.loop_active)
|
||||
break;
|
||||
|
||||
this->event.condition.wait(lock);
|
||||
if(!this->event.loop_active)
|
||||
break;
|
||||
}
|
||||
|
||||
event_base_loop(this->event.base, 0);
|
||||
}
|
||||
}
|
||||
|
||||
//Call only within the event loop!
|
||||
@ -118,6 +53,9 @@ void Resolver::destroy_dns_request(Resolver::dns_request *request) {
|
||||
this->dns_requests.erase(std::find(this->dns_requests.begin(), this->dns_requests.end(), request), this->dns_requests.end());
|
||||
}
|
||||
|
||||
if(!this->event.loop_active)
|
||||
ub_cancel(this->ub_ctx, entry->ub_id);
|
||||
|
||||
if(request->register_event) {
|
||||
event_del_noblock(request->register_event);
|
||||
event_free(request->register_event);
|
||||
|
||||
@ -1,9 +1,14 @@
|
||||
#include "./response.h"
|
||||
#include "./resolver.h"
|
||||
|
||||
#include <iostream>
|
||||
#include <codecvt>
|
||||
#ifdef WIN32
|
||||
#include <Windows.h>
|
||||
#include <WS2tcpip.h>
|
||||
#include <in6addr.h>
|
||||
#include <ip2string.h>
|
||||
#include <inaddr.h>
|
||||
#include <WinDNS.h>
|
||||
#else
|
||||
#include <arpa/inet.h>
|
||||
#include <netinet/in.h>
|
||||
@ -12,18 +17,7 @@
|
||||
using namespace tc::dns::response;
|
||||
using namespace tc::dns::response::rrparser;
|
||||
|
||||
inline std::string to_string(const in6_addr& address) {
|
||||
char buffer[INET6_ADDRSTRLEN];
|
||||
if(!inet_ntop(AF_INET6, (void*) &address, buffer, INET6_ADDRSTRLEN)) return "";
|
||||
return std::string(buffer);
|
||||
}
|
||||
|
||||
inline std::string to_string(const in_addr& address) {
|
||||
char buffer[INET_ADDRSTRLEN];
|
||||
if(!inet_ntop(AF_INET, (void*) &address, buffer, INET_ADDRSTRLEN)) return "";
|
||||
return std::string(buffer);
|
||||
}
|
||||
|
||||
#ifndef WIN32
|
||||
uint16_t DNSHeader::field(int index) const {
|
||||
return ((uint16_t*) this->response->packet_data())[index];
|
||||
}
|
||||
@ -36,17 +30,83 @@ DNSResourceRecords::DNSResourceRecords(std::shared_ptr<DNSResponseData> packet,
|
||||
const uint8_t* DNSResourceRecords::payload_data() const {
|
||||
return this->data->buffer + this->offset;
|
||||
}
|
||||
#else
|
||||
DNSResourceRecords::DNSResourceRecords(std::shared_ptr<tc::dns::DNSResponseData> data, PDNS_RECORDA rdata) : nrecord{rdata}, data{std::move(data)} { }
|
||||
bool DNSResourceRecords::is_wide_string() const {
|
||||
return this->data->wide_string;
|
||||
}
|
||||
#endif
|
||||
|
||||
bool A::is_valid() {
|
||||
#ifdef WIN32
|
||||
return true;
|
||||
#else
|
||||
return this->handle->payload_length() == 4;
|
||||
#endif
|
||||
}
|
||||
|
||||
in_addr A::address() {
|
||||
#ifdef WIN32
|
||||
in_addr result{};
|
||||
result.S_un.S_addr = this->handle->native_record()->Data.A.IpAddress;
|
||||
return result;
|
||||
#else
|
||||
//TODO: Attention: Unaligned access
|
||||
return {*(uint32_t*) this->handle->payload_data()};
|
||||
#endif
|
||||
}
|
||||
|
||||
std::string A::address_string() {
|
||||
#ifdef WIN32
|
||||
struct in_addr address = this->address();
|
||||
char buffer[17];
|
||||
RtlIpv4AddressToStringA(&address, buffer);
|
||||
return std::string{buffer};
|
||||
#else
|
||||
auto _1 = this->handle->payload_data()[0],
|
||||
_2 = this->handle->payload_data()[1],
|
||||
_3 = this->handle->payload_data()[2],
|
||||
_4 = this->handle->payload_data()[3];
|
||||
return std::to_string(_1) + "." + std::to_string(_2) + "." + std::to_string(_3) + "." + std::to_string(_4);
|
||||
#endif
|
||||
}
|
||||
|
||||
//---------------- AAAA
|
||||
#ifdef WIN32
|
||||
bool AAAA::is_valid() {
|
||||
return true;
|
||||
}
|
||||
|
||||
std::string AAAA::address_string() {
|
||||
return to_string(this->address());
|
||||
struct in6_addr address = this->address();
|
||||
char buffer[47];
|
||||
RtlIpv6AddressToStringA(&address, buffer); //Supported for Win7 as well and not only above 8.1 like inet_ntop
|
||||
return std::string{buffer};
|
||||
}
|
||||
|
||||
in6_addr AAAA::address() {
|
||||
in6_addr result{};
|
||||
memcpy(result.u.Byte, this->handle->native_record()->Data.AAAA.Ip6Address.IP6Byte, 16);
|
||||
return result;
|
||||
}
|
||||
#else
|
||||
bool AAAA::is_valid() {
|
||||
return this->handle->payload_length() == 16;
|
||||
}
|
||||
|
||||
std::string AAAA::address_string() {
|
||||
auto address = this->address();
|
||||
|
||||
char buffer[INET6_ADDRSTRLEN];
|
||||
if(!inet_ntop(AF_INET6, (void*) &address, buffer, INET6_ADDRSTRLEN)) return "";
|
||||
return std::string(buffer);
|
||||
}
|
||||
|
||||
in6_addr AAAA::address() {
|
||||
return {
|
||||
.__in6_u = {
|
||||
.__u6_addr32 = {
|
||||
//Attention unaligned memory access
|
||||
//TODO: Attention unaligned memory access
|
||||
((uint32_t*) this->handle->payload_data())[0],
|
||||
((uint32_t*) this->handle->payload_data())[1],
|
||||
((uint32_t*) this->handle->payload_data())[2],
|
||||
@ -55,8 +115,23 @@ in6_addr AAAA::address() {
|
||||
}
|
||||
};
|
||||
}
|
||||
#endif
|
||||
|
||||
//---------------- SRV
|
||||
#ifdef WIN32
|
||||
bool SRV::is_valid() { return true; }
|
||||
std::string SRV::target_hostname() {
|
||||
if(this->handle->is_wide_string()) {
|
||||
auto result = std::wstring{ ((PDNS_RECORDW) this->handle->native_record())->Data.Srv.pNameTarget };
|
||||
return std::string{result.begin(), result.end()};
|
||||
} else {
|
||||
return std::string{ this->handle->native_record()->Data.Srv.pNameTarget };
|
||||
}
|
||||
}
|
||||
uint16_t SRV::priority() { return this->handle->native_record()->Data.SRV.wPriority; }
|
||||
uint16_t SRV::weight() { return this->handle->native_record()->Data.SRV.wWeight; }
|
||||
uint16_t SRV::target_port() { return this->handle->native_record()->Data.SRV.wPort; }
|
||||
#else
|
||||
bool SRV::is_valid() {
|
||||
if(this->handle->payload_length() < 7)
|
||||
return false;
|
||||
@ -72,16 +147,35 @@ std::string SRV::target_hostname() {
|
||||
return this->handle->dns_data()->parse_dns_dn(error, index, true);
|
||||
}
|
||||
|
||||
|
||||
uint16_t SRV::priority() { return ntohs(((uint16_t*) this->handle->payload_data())[0]); }
|
||||
uint16_t SRV::weight() { return ntohs(((uint16_t*) this->handle->payload_data())[1]); }
|
||||
uint16_t SRV::target_port() { return ntohs(((uint16_t*) this->handle->payload_data())[2]); }
|
||||
#endif
|
||||
|
||||
//---------------- All types with a name
|
||||
bool named_base::is_valid() {
|
||||
#ifdef WIN32
|
||||
return true;
|
||||
#else
|
||||
size_t index = this->handle->payload_offset();
|
||||
std::string error{};
|
||||
this->handle->dns_data()->parse_dns_dn(error, index, true);
|
||||
return error.empty();
|
||||
#endif
|
||||
}
|
||||
|
||||
std::string named_base::name() {
|
||||
#ifdef WIN32
|
||||
if(this->handle->is_wide_string()) {
|
||||
auto result = std::wstring{ ((PDNS_RECORDW) this->handle->native_record())->Data.Cname.pNameHost };
|
||||
return std::string{result.begin(), result.end()};
|
||||
} else {
|
||||
return std::string{ this->handle->native_record()->Data.Cname.pNameHost };
|
||||
}
|
||||
#else
|
||||
size_t index = this->handle->payload_offset();
|
||||
std::string error{};
|
||||
return this->handle->dns_data()->parse_dns_dn(error, index, true);
|
||||
#endif
|
||||
}
|
||||
|
||||
@ -3,13 +3,20 @@
|
||||
#include <memory>
|
||||
#include <string>
|
||||
#include <cstdint>
|
||||
#ifdef WIN32
|
||||
#include <WinSock2.h>
|
||||
#include <Windows.h>
|
||||
#include <WinDNS.h>
|
||||
#else
|
||||
#include <netinet/in.h>
|
||||
#endif
|
||||
|
||||
#include "./types.h"
|
||||
|
||||
struct in6_addr;
|
||||
namespace tc::dns {
|
||||
class DNSResponse;
|
||||
class DNSResponseData;
|
||||
struct DNSResponseData;
|
||||
|
||||
namespace response {
|
||||
#ifndef WIN32
|
||||
@ -57,16 +64,32 @@ namespace tc::dns {
|
||||
friend class tc::dns::DNSResponse;
|
||||
public:
|
||||
[[nodiscard]] inline std::string qname() const {
|
||||
#ifdef WIN32
|
||||
return std::string{this->nrecord->pName};
|
||||
#else
|
||||
return this->name;
|
||||
#endif
|
||||
}
|
||||
[[nodiscard]] inline rrtype::value atype() const {
|
||||
#ifdef WIN32
|
||||
return static_cast<rrtype::value>(this->nrecord->wType);
|
||||
#else
|
||||
return this->type;
|
||||
#endif
|
||||
}
|
||||
[[nodiscard]] inline rrclass::value aclass() const {
|
||||
#ifdef WIN32
|
||||
return static_cast<rrclass::value>(1);
|
||||
#else
|
||||
return this->klass;
|
||||
#endif
|
||||
}
|
||||
[[nodiscard]] inline uint16_t attl() const {
|
||||
#ifdef WIN32
|
||||
return (uint16_t) this->nrecord->dwTtl;
|
||||
#else
|
||||
return this->ttl;
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifndef WIN32
|
||||
@ -75,6 +98,7 @@ namespace tc::dns {
|
||||
[[nodiscard]] inline size_t payload_offset() const { return this->offset; }
|
||||
#else
|
||||
[[nodiscard]] inline PDNS_RECORDA native_record() const { return this->nrecord; }
|
||||
[[nodiscard]] bool is_wide_string() const;
|
||||
#endif
|
||||
|
||||
[[nodiscard]] inline std::shared_ptr<DNSResponseData> dns_data() const {
|
||||
@ -83,7 +107,7 @@ namespace tc::dns {
|
||||
|
||||
template <typename T>
|
||||
[[nodiscard]] inline T parse() const {
|
||||
if(T::type != this->type)
|
||||
if(T::type != this->atype())
|
||||
throw std::logic_error{"parser type mismatch"};
|
||||
return T{this};
|
||||
}
|
||||
@ -134,21 +158,14 @@ namespace tc::dns {
|
||||
}
|
||||
|
||||
define_parser(A, base,
|
||||
[[nodiscard]] inline bool is_valid() { return this->handle->payload_length() == 4; }
|
||||
[[nodiscard]] inline std::string address_string() {
|
||||
auto _1 = this->handle->payload_data()[0],
|
||||
_2 = this->handle->payload_data()[1],
|
||||
_3 = this->handle->payload_data()[2],
|
||||
_4 = this->handle->payload_data()[3];
|
||||
return std::to_string(_1) + "." + std::to_string(_2) + "." + std::to_string(_3) + "." + std::to_string(_4);
|
||||
}
|
||||
[[nodiscard]] inline in_addr address() {
|
||||
return {*(uint32_t*) this->handle->payload_data()};
|
||||
}
|
||||
[[nodiscard]] bool is_valid();
|
||||
[[nodiscard]] std::string address_string();
|
||||
|
||||
[[nodiscard]] in_addr address();
|
||||
);
|
||||
|
||||
define_parser(AAAA, base,
|
||||
[[nodiscard]] inline bool is_valid() { return this->handle->payload_length() == 16; }
|
||||
[[nodiscard]] bool is_valid();
|
||||
[[nodiscard]] std::string address_string();
|
||||
[[nodiscard]] in6_addr address();
|
||||
);
|
||||
@ -156,9 +173,9 @@ namespace tc::dns {
|
||||
define_parser(SRV, base,
|
||||
[[nodiscard]] bool is_valid();
|
||||
|
||||
[[nodiscard]] inline uint16_t priority() { return ntohs(((uint16_t*) this->handle->payload_data())[0]); }
|
||||
[[nodiscard]] inline uint16_t weight() { return ntohs(((uint16_t*) this->handle->payload_data())[1]); }
|
||||
[[nodiscard]] inline uint16_t target_port() { return ntohs(((uint16_t*) this->handle->payload_data())[2]); }
|
||||
[[nodiscard]] uint16_t priority();
|
||||
[[nodiscard]] uint16_t weight();
|
||||
[[nodiscard]] uint16_t target_port();
|
||||
[[nodiscard]] std::string target_hostname();
|
||||
);
|
||||
|
||||
|
||||
@ -114,13 +114,17 @@ namespace tc::dns {
|
||||
};
|
||||
|
||||
struct rrclass {
|
||||
#ifdef IN
|
||||
#undef IN
|
||||
#endif
|
||||
|
||||
enum value : uint32_t {
|
||||
IN = 1, /* Internet */
|
||||
CH = 3, /* Chaos */
|
||||
HS = 4, /* Hesiod */
|
||||
|
||||
QCLASS_NONE = 254,
|
||||
QCLASS_ANY = 255
|
||||
QCLASS_ANY = 255,
|
||||
};
|
||||
|
||||
static std::map<value, const char*> names;
|
||||
|
||||
@ -5,7 +5,6 @@
|
||||
#include <random>
|
||||
#include <deque>
|
||||
#include <cassert>
|
||||
#include <unbound-event.h>
|
||||
|
||||
#include "../src/response.h"
|
||||
#include "../src/resolver.h"
|
||||
@ -17,7 +16,20 @@ using namespace std;
|
||||
namespace parser = response::rrparser;
|
||||
|
||||
int main() {
|
||||
#ifdef WIN32
|
||||
{
|
||||
WSADATA wsaData;
|
||||
auto error = WSAStartup(MAKEWORD(2, 2), &wsaData);
|
||||
if (error != 0) {
|
||||
wprintf(L"WSAStartup failed with %d\n", error);
|
||||
return error;
|
||||
}
|
||||
}
|
||||
|
||||
evthread_use_windows_threads();
|
||||
#else
|
||||
evthread_use_pthreads();
|
||||
#endif
|
||||
//evthread_enable_lock_debugging();
|
||||
|
||||
std::string error{};
|
||||
@ -29,7 +41,7 @@ int main() {
|
||||
}
|
||||
|
||||
auto begin = chrono::system_clock::now();
|
||||
for(int i = 0; i < 250; i++) {
|
||||
for(int i = 0; i < 1; i++) {
|
||||
cr(resolver, {
|
||||
to_string(i) + "ts.twerion.net",
|
||||
9922
|
||||
@ -45,8 +57,10 @@ int main() {
|
||||
});
|
||||
}
|
||||
|
||||
this_thread::sleep_for(chrono::seconds{8});
|
||||
this_thread::sleep_for(chrono::seconds{5});
|
||||
cout << "Timeout" << endl;
|
||||
resolver.finalize();
|
||||
cout << "Exit" << endl;
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -11,7 +11,13 @@
|
||||
#include <iostream>
|
||||
#include <random>
|
||||
#include <cstring>
|
||||
|
||||
#ifndef WIN32
|
||||
#include <arpa/inet.h>
|
||||
#else
|
||||
#include <Ws2ipdef.h>
|
||||
#include <ip2string.h>
|
||||
#endif
|
||||
|
||||
using namespace tc::dns;
|
||||
namespace parser = tc::dns::response::rrparser;
|
||||
@ -173,16 +179,17 @@ void tc::dns::cr_srv(Resolver& resolver, const ServerAddress& address, const cr_
|
||||
|
||||
std::deque<std::tuple<uint16_t, SrvEntry>> results{};
|
||||
for(auto [priority, pentries] : entries) {
|
||||
int64_t count = 0;
|
||||
for(const auto& entry : pentries)
|
||||
count += std::max((size_t) entry.weight, 1UL);
|
||||
uint32_t count = 0;
|
||||
for(const auto& entry : pentries) {
|
||||
count += max((size_t) entry.weight, 1UL);
|
||||
}
|
||||
|
||||
std::uniform_int_distribution<std::mt19937::result_type> dist(0, count - 1);
|
||||
std::uniform_int_distribution<std::mt19937::result_type> dist(0, (uint32_t) (count - 1));
|
||||
auto index = dist(srv_rnd);
|
||||
|
||||
count = 0;
|
||||
for(const auto& entry : pentries) {
|
||||
count += std::max((size_t) entry.weight, 1UL);
|
||||
count += max((size_t) entry.weight, 1UL);
|
||||
if(count > index) {
|
||||
count = -1;
|
||||
results.emplace_back(priority, entry);
|
||||
@ -226,10 +233,22 @@ void tc::dns::cr_tsdns(tc::dns::Resolver &resolver, const tc::dns::ServerAddress
|
||||
|
||||
auto tsdns_a6 = (sockaddr_in6*) &tsdns_address;
|
||||
auto tsdns_a4 = (sockaddr_in*) &tsdns_address;
|
||||
if(inet_pton(AF_INET6, tsdns_host.host.c_str(), &tsdns_a6->sin6_addr) == 1) {
|
||||
#ifdef WIN32
|
||||
PCSTR terminator{nullptr};
|
||||
if(RtlIpv6StringToAddressA(tsdns_host.host.c_str(), &terminator, (in6_addr*) &tsdns_a6->sin6_addr) == 0)
|
||||
#else
|
||||
if(inet_pton(AF_INET6, tsdns_host.host.c_str(), &tsdns_a6->sin6_addr) == 1)
|
||||
#endif
|
||||
{
|
||||
tsdns_a6->sin6_family = AF_INET6;
|
||||
tsdns_a6->sin6_port = htons(tsdns_host.port == 0 ? 41144 : tsdns_host.port);
|
||||
} else if(inet_pton(AF_INET, tsdns_host.host.c_str(), &(tsdns_a4->sin_addr)) == 1) {
|
||||
}
|
||||
#ifdef WIN32
|
||||
else if(RtlIpv4StringToAddressA(tsdns_host.host.c_str(), false, &terminator, (in_addr*) &tsdns_a4->sin_addr) == 0)
|
||||
#else
|
||||
else if(inet_pton(AF_INET, tsdns_host.host.c_str(), &(tsdns_a4->sin_addr)) == 1)
|
||||
#endif
|
||||
{
|
||||
tsdns_a4->sin_family = AF_INET;
|
||||
tsdns_a4->sin_port = htons(tsdns_host.port == 0 ? 41144 : tsdns_host.port);
|
||||
} else {
|
||||
@ -262,8 +281,8 @@ void tc::dns::cr_tsdns(tc::dns::Resolver &resolver, const tc::dns::ServerAddress
|
||||
resp.port = address.port;
|
||||
} else {
|
||||
try {
|
||||
resp.port = stoul(port);
|
||||
} catch(std::exception& ex) {
|
||||
resp.port = (uint16_t) stoul(port);
|
||||
} catch(const std::exception&) {
|
||||
callback(false, "failed to parse response: " + response + " Failed to parse port: " + port);
|
||||
return;
|
||||
}
|
||||
@ -333,7 +352,7 @@ struct CrStatus {
|
||||
|
||||
#define try_answer_test(element, executor) \
|
||||
if(std::get<0>(element) == State::SUCCESS) { \
|
||||
this->callback(true, std::get<2>(element)); \
|
||||
this->call_answer(std::get<2>(element)); \
|
||||
return true; \
|
||||
} else if(std::get<0>(element) == State::PENDING) { \
|
||||
if(!std::get<0>(executor)) { \
|
||||
@ -361,6 +380,28 @@ struct CrStatus {
|
||||
try_answer_test(this->rootdomain, this->execute_rootdomain);
|
||||
return false;
|
||||
}
|
||||
|
||||
#define answer_log(element, executor) \
|
||||
if(!std::get<0>(executor)) \
|
||||
std::cout << #element << ": not executed" << std::endl; \
|
||||
else if(std::get<0>(element) == State::PENDING) \
|
||||
std::cout << #element << ": pending" << std::endl; \
|
||||
else if(std::get<0>(element) == State::FAILED) \
|
||||
std::cout << #element << ": failed: " << std::get<1>(element) << std::endl; \
|
||||
else \
|
||||
std::cout << #element << ": success: " << std::get<2>(element).host << ":" << std::get<2>(element).port << std::endl;
|
||||
|
||||
void call_answer(const tc::dns::ServerAddress& data) {
|
||||
answer_log(this->subsrv_ts, this->execute_subsrv_ts);
|
||||
answer_log(this->subsrv_ts3, this->execute_subsrv_ts3);
|
||||
answer_log(this->tsdns, this->execute_tsdns);
|
||||
answer_log(this->subdomain, this->execute_subdomain);
|
||||
answer_log(this->rootsrv, this->execute_rootsrv);
|
||||
answer_log(this->rootdomain, this->execute_rootdomain);
|
||||
|
||||
//TODO: Print data
|
||||
this->callback(true, data);
|
||||
}
|
||||
};
|
||||
|
||||
void tc::dns::cr(Resolver& resolver, const tc::dns::ServerAddress& address, const tc::dns::cr_callback_t& callback) {
|
||||
|
||||
Loading…
Reference in New Issue
Block a user