TeaSpeak/TeaSpeak-Client
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Structural unbound dns changes

Browse Source
This commit is contained in:
WolverinDEV 2019-10-25 17:01:25 +02:00
parent a39f573a5f
commit 72ba613ad8
6 changed files with 520 additions and 461 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
native/dns/CMakeLists.txt
View File

@ -1,6 +1,6 @@
set(MODULE_NAME "teaclient_dns")
set(SOURCE_FILES ${SOURCE_FILES} src/resolver.cpp src/types.cpp src/response.cpp utils.cpp)
set(SOURCE_FILES ${SOURCE_FILES} src/resolver.cpp src/types.cpp src/response.cpp utils.cpp src/resolver_linux.cpp)
find_package(Libevent REQUIRED)
include_directories(${LIBEVENT_INCLUDE_DIRS})

436
native/dns/src/resolver.cpp
View File

@ -23,130 +23,12 @@
using namespace std;
using namespace tc::dns;
Resolver::Resolver() {
}
Resolver::Resolver() { }
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));
this->ub_ctx = ub_ctx_create_event(this->event.base);
if(!this->ub_ctx) {
this->finalize();
error = "failed to create ub context";
return false;
}
/* Add /etc/hosts */
auto err = !hosts ? 0 : ub_ctx_hosts((struct ub_ctx*) this->ub_ctx, nullptr);
if(err != 0) {
cerr << "Failed to add hosts file: " << ub_strerror(err) << endl;
}
/* Add resolv.conf */
err = !resolv ? 0 : ub_ctx_resolvconf((struct ub_ctx*) this->ub_ctx, nullptr);
if(err != 0) {
cerr << "Failed to add hosts file: " << ub_strerror(err) << endl;
}
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();
}
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!
void Resolver::destroy_dns_request(Resolver::dns_request *request) {
assert(this_thread::get_id() == this->event.loop.get_id() || !this->event.loop_active);
{
lock_guard lock{this->request_lock};
this->dns_requests.erase(std::find(this->dns_requests.begin(), this->dns_requests.end(), request), this->dns_requests.end());
}
if(request->register_event) {
event_del_noblock(request->register_event);
event_free(request->register_event);
request->register_event = nullptr;
}
if(request->timeout_event) {
event_del_noblock(request->timeout_event);
event_free(request->timeout_event);
request->timeout_event = nullptr;
}
delete request;
}
void Resolver::destroy_tsdns_request(Resolver::tsdns_request *request) {
assert(this_thread::get_id() == this->event.loop.get_id() || !this->event.loop_active);
@ -184,322 +66,6 @@ void Resolver::destroy_tsdns_request(Resolver::tsdns_request *request) {
delete request;
}
//--------------- DNS
void Resolver::resolve_dns(const char *name, const rrtype::value &rrtype, const rrclass::value &rrclass, const std::chrono::microseconds& timeout, const dns_callback_t& callback) {
if(!this->event.loop_active) {
callback(ResultState::INITIALISATION_FAILED, 3, nullptr);
return;
}
auto request = new dns_request{};
request->resolver = this;
request->callback = callback;
request->host = name;
request->rrtype = rrtype;
request->rrclass = rrclass;
request->timeout_event = evtimer_new(this->event.base, [](evutil_socket_t, short, void *_request) {
auto request = static_cast<dns_request*>(_request);
request->resolver->evtimer_dns_callback(request);
}, request);
request->register_event = evuser_new(this->event.base, [](evutil_socket_t, short, void *_request) {
auto request = static_cast<dns_request*>(_request);
auto errc = ub_resolve_event(request->resolver->ub_ctx, request->host.c_str(), (int) request->rrtype, (int) request->rrclass, (void*) request, [](void* _request, int a, void* b, int c, int d, char* e) {
auto request = static_cast<dns_request*>(_request);
request->resolver->ub_callback(request, a, b, c, d, e);
}, &request->ub_id);
if(errc != 0) {
request->callback(ResultState::INITIALISATION_FAILED, errc, nullptr);
request->resolver->destroy_dns_request(request);
}
}, request);
if(!request->timeout_event || !request->register_event) {
callback(ResultState::INITIALISATION_FAILED, 2, nullptr);
if(request->timeout_event)
event_free(request->timeout_event);
if(request->register_event)
event_free(request->register_event);
delete request;
return;
}
/*
* Lock here all requests so the event loop cant already delete the request
*/
unique_lock rlock{this->request_lock};
{
auto errc = event_add(request->timeout_event, nullptr);
//TODO: Check for error
evuser_trigger(request->register_event);
}
{
auto seconds = chrono::floor<chrono::seconds>(timeout);
auto microseconds = chrono::ceil<chrono::microseconds>(timeout - seconds);
timeval tv{seconds.count(), microseconds.count()};
auto errc = event_add(request->timeout_event, &tv);
//TODO: Check for error
}
this->dns_requests.push_back(request);
rlock.unlock();
/* Activate the event loop */
this->event.condition.notify_one();
}
void Resolver::evtimer_dns_callback(tc::dns::Resolver::dns_request *request) {
if(request->ub_id > 0) {
auto errc = ub_cancel(this->ub_ctx, request->ub_id);
if(errc != 0) {
cerr << "Failed to cancel DNS request " << request->ub_id << " after timeout (" << errc << "/" << ub_strerror(errc) << ")!" << endl;
}
}
request->callback(ResultState::DNS_TIMEOUT, 0, nullptr);
this->destroy_dns_request(request);
}
void Resolver::ub_callback(dns_request* request, int rcode, void *packet, int packet_length, int sec, char *why_bogus) {
if(rcode != 0) {
request->callback(ResultState::DNS_FAIL, rcode, nullptr);
} else {
auto callback = request->callback;
auto data = std::unique_ptr<DNSResponse>(new DNSResponse{(uint8_t) sec, why_bogus, packet, (size_t) packet_length});
callback(ResultState::SUCCESS, 0, std::move(data));
}
this->destroy_dns_request(request);
}
thread_local std::vector<size_t> visited_links;
std::string DNSResponseBuffer::parse_dns_dn(std::string &error, size_t &index, bool allow_compression) {
if(allow_compression) {
visited_links.clear();
visited_links.reserve(8);
if(std::find(visited_links.begin(), visited_links.end(), index) != visited_links.end()) {
error = "circular link detected";
return "";
}
visited_links.push_back(index);
}
error.clear();
string result;
result.reserve(256); //Max length is 253
while(true) {
if(index + 1 > this->length) {
error = "truncated data (missing code)";
goto exit;
}
auto code = this->buffer[index++];
if(code == 0) break;
if((code >> 6U) == 3) {
if(!allow_compression) {
error = "found link, but links are not allowed";
goto exit;
}
auto lower_addr = this->buffer[index++];
if(index + 1 > this->length) {
error = "truncated data (missing lower link address)";
goto exit;
}
size_t addr = ((code & 0x3FU) << 8U) | lower_addr;
if(addr >= this->length) {
error = "invalid link address";
goto exit;
}
auto tail = this->parse_dns_dn(error, addr, true);
if(!error.empty())
goto exit;
if(!result.empty())
result += "." + tail;
else
result = tail;
break;
} else {
if(code > 63) {
error = "max domain label length is 63 characters";
goto exit;
}
if(!result.empty())
result += ".";
if(index + code >= this->length) {
error = "truncated data (domain label)";
goto exit;
}
result.append((const char*) (this->buffer + index), code);
index += code;
}
}
exit:
if(allow_compression) visited_links.pop_back();
return result;
}
DNSResponseBuffer::~DNSResponseBuffer() {
::free(this->buffer);
}
DNSResponse::DNSResponse(uint8_t secure_state, const char* bogus, void *packet, size_t size) {
this->bogus = bogus ? std::string{bogus} : std::string{"packet is secure"};
this->secure_state = secure_state;
this->packet = make_shared<DNSResponseBuffer>();
this->packet->buffer = (uint8_t*) malloc(size);
this->packet->length = size;
memcpy(this->packet->buffer, packet, size);
}
response::DNSHeader DNSResponse::header() const {
return response::DNSHeader{this};
}
bool DNSResponse::parse(std::string &error) {
if(this->is_parsed) {
error = this->parse_error;
return error.empty();
}
error.clear();
this->is_parsed = true;
auto header = this->header();
size_t index = 12; /* 12 bits for the header */
{
auto count = header.query_count();
this->parsed_queries.reserve(count);
for(size_t idx = 0; idx < count; idx++) {
auto dn = this->packet->parse_dns_dn(error, index, true);
if(!error.empty()) {
error = "failed to parse query " + to_string(idx) + " dn: " + error; // NOLINT(performance-inefficient-string-concatenation)
goto error_exit;
}
if(index + 4 > this->packet_length()) {
error = "truncated data for query " + to_string(index);
goto error_exit;
}
auto type = (rrtype::value) ntohs(*(uint16_t*) (this->packet->buffer + index));
index += 2;
auto klass = (rrclass::value) ntohs(*(uint16_t*) (this->packet->buffer + index));
index += 2;
this->parsed_queries.emplace_back(new response::DNSQuery{dn, type, klass});
}
}
{
auto count = header.answer_count();
this->parsed_answers.reserve(count);
for(size_t idx = 0; idx < count; idx++) {
this->parsed_answers.push_back(this->parse_rr(error, index, true));
if(!error.empty()) {
error = "failed to parse answer " + to_string(idx) + ": " + error; // NOLINT(performance-inefficient-string-concatenation)
goto error_exit;
}
}
}
{
auto count = header.authority_count();
this->parsed_authorities.reserve(count);
for(size_t idx = 0; idx < count; idx++) {
this->parsed_authorities.push_back(this->parse_rr(error, index, true));
if(!error.empty()) {
error = "failed to parse authority " + to_string(idx) + ": " + error; // NOLINT(performance-inefficient-string-concatenation)
goto error_exit;
}
}
}
{
auto count = header.additional_count();
this->parsed_additionals.reserve(count);
for(size_t idx = 0; idx < count; idx++) {
this->parsed_additionals.push_back(this->parse_rr(error, index, true));
if(!error.empty()) {
error = "failed to parse additional " + to_string(idx) + ": " + error; // NOLINT(performance-inefficient-string-concatenation)
goto error_exit;
}
}
}
return true;
error_exit:
this->parsed_queries.clear();
this->parsed_answers.clear();
this->parsed_authorities.clear();
this->parsed_additionals.clear();
return false;
}
std::shared_ptr<response::DNSResourceRecords> DNSResponse::parse_rr(std::string &error, size_t &index, bool allow_compressed) {
auto dn = this->packet->parse_dns_dn(error, index, allow_compressed);
if(!error.empty()) {
error = "failed to parse rr dn: " + error; // NOLINT(performance-inefficient-string-concatenation)
return nullptr;
}
if(index + 10 > this->packet_length()) {
error = "truncated header";
return nullptr;
}
auto type = (rrtype::value) ntohs(*(uint16_t*) (this->packet->buffer + index));
index += 2;
auto klass = (rrclass::value) ntohs(*(uint16_t*) (this->packet->buffer + index));
index += 2;
auto ttl = ntohl(*(uint32_t*) (this->packet->buffer + index));
index += 4;
auto payload_length = ntohs(*(uint16_t*) (this->packet->buffer + index));
index += 2;
if(index + payload_length > this->packet_length()) {
error = "truncated body";
return nullptr;
}
auto response = std::shared_ptr<response::DNSResourceRecords>(new response::DNSResourceRecords{this->packet, index, payload_length, ttl, dn, type, klass});
index += payload_length;
return response;
}
//---------------------- TSDNS
void Resolver::resolve_tsdns(const char *query, const sockaddr_storage& server_address, const std::chrono::microseconds& timeout, const tc::dns::Resolver::tsdns_callback_t &callback) {
/* create the socket */

40
native/dns/src/resolver.h
View File

@ -9,8 +9,10 @@
#include <event.h>
#include "./types.h"
#ifndef WIN32
struct ub_ctx;
#endif
namespace tc::dns {
namespace response {
class DNSHeader;
@ -18,12 +20,17 @@ namespace tc::dns {
class DNSResourceRecords;
}
struct DNSResponseBuffer {
struct DNSResponseData {
#ifdef WIN32
//IMPLEMENT ME!
#else
uint8_t* buffer{nullptr};
size_t length{0};
~DNSResponseBuffer();
std::string parse_dns_dn(std::string& /* error */, size_t& /* index */, bool /* compression allowed */);
#endif
~DNSResponseData();
};
class Resolver;
@ -38,21 +45,23 @@ namespace tc::dns {
bool parse(std::string& /* error */);
#ifndef WIN32
[[nodiscard]] inline const std::string why_bogus() const { return this->bogus; }
[[nodiscard]] inline const uint8_t* packet_data() const { return this->packet->buffer; }
[[nodiscard]] inline size_t packet_length() const { return this->packet->length; }
[[nodiscard]] inline const uint8_t* packet_data() const { return this->data->buffer; }
[[nodiscard]] inline size_t packet_length() const { return this->data->length; }
[[nodiscard]] inline bool is_secure() const { return this->secure_state > 0; }
[[nodiscard]] inline bool is_secure_dnssec() const { return this->secure_state == 2; }
[[nodiscard]] response::DNSHeader header() const;
#endif
[[nodiscard]] q_list_t queries() const { return this->parsed_queries; }
[[nodiscard]] rr_list_t answers() const { return this->parsed_answers; }
[[nodiscard]] rr_list_t authorities() const { return this->parsed_authorities; }
[[nodiscard]] rr_list_t additionals() const { return this->parsed_additionals; }
private:
#ifndef WIN32
DNSResponse(uint8_t /* secure state */, const char* /* bogus */, void* /* packet */, size_t /* length */);
std::shared_ptr<response::DNSResourceRecords> parse_rr(std::string& /* error */, size_t& index, bool /* compression allowed dn */);
@ -60,7 +69,10 @@ namespace tc::dns {
std::string bogus;
uint8_t secure_state{0};
std::shared_ptr<DNSResponseBuffer> packet{nullptr};
std::shared_ptr<DNSResponseData> data{nullptr};
#else
#endif
bool is_parsed{false};
std::string parse_error{};
@ -101,6 +113,7 @@ 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
struct dns_request {
Resolver* resolver{nullptr};
@ -115,6 +128,8 @@ namespace tc::dns {
dns_callback_t callback{};
};
struct ub_ctx* ub_ctx = nullptr;
#endif
struct tsdns_request {
Resolver* resolver{nullptr};
@ -139,23 +154,28 @@ namespace tc::dns {
event_base* base = nullptr;
} event;
struct ub_ctx* ub_ctx = nullptr;
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
void destroy_dns_request(dns_request*);
#endif
void destroy_tsdns_request(tsdns_request*);
void event_loop_runner();
void evtimer_tsdns_callback(tsdns_request* /* request */);
#ifndef WIN32
void evtimer_dns_callback(dns_request* /* request */);
void ub_callback(dns_request* /* request */, int /* rcode */, void* /* packet */, int /* packet_len */, int /* sec */, char* /* why_bogus */);
#endif
void evtimer_tsdns_callback(tsdns_request* /* request */);
void event_tsdns_write(tsdns_request* /* request */);
void event_tsdns_read(tsdns_request* /* request */);
void ub_callback(dns_request* /* request */, int /* rcode */, void* /* packet */, int /* packet_len */, int /* sec */, char* /* why_bogus */);
};
}

449
native/dns/src/resolver_linux.cpp Normal file
View File

@ -0,0 +1,449 @@
#include "./resolver.h"
#include "./response.h"
#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>
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));
this->ub_ctx = ub_ctx_create_event(this->event.base);
if(!this->ub_ctx) {
this->finalize();
error = "failed to create ub context";
return false;
}
/* Add /etc/hosts */
auto err = !hosts ? 0 : ub_ctx_hosts((struct ub_ctx*) this->ub_ctx, nullptr);
if(err != 0) {
cerr << "Failed to add hosts file: " << ub_strerror(err) << endl;
}
/* Add resolv.conf */
err = !resolv ? 0 : ub_ctx_resolvconf((struct ub_ctx*) this->ub_ctx, nullptr);
if(err != 0) {
cerr << "Failed to add hosts file: " << ub_strerror(err) << endl;
}
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();
}
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!
void Resolver::destroy_dns_request(Resolver::dns_request *request) {
assert(this_thread::get_id() == this->event.loop.get_id() || !this->event.loop_active);
{
lock_guard lock{this->request_lock};
this->dns_requests.erase(std::find(this->dns_requests.begin(), this->dns_requests.end(), request), this->dns_requests.end());
}
if(request->register_event) {
event_del_noblock(request->register_event);
event_free(request->register_event);
request->register_event = nullptr;
}
if(request->timeout_event) {
event_del_noblock(request->timeout_event);
event_free(request->timeout_event);
request->timeout_event = nullptr;
}
delete request;
}
//--------------- DNS
void Resolver::resolve_dns(const char *name, const rrtype::value &rrtype, const rrclass::value &rrclass, const std::chrono::microseconds& timeout, const dns_callback_t& callback) {
if(!this->event.loop_active) {
callback(ResultState::INITIALISATION_FAILED, 3, nullptr);
return;
}
auto request = new dns_request{};
request->resolver = this;
request->callback = callback;
request->host = name;
request->rrtype = rrtype;
request->rrclass = rrclass;
request->timeout_event = evtimer_new(this->event.base, [](evutil_socket_t, short, void *_request) {
auto request = static_cast<dns_request*>(_request);
request->resolver->evtimer_dns_callback(request);
}, request);
request->register_event = evuser_new(this->event.base, [](evutil_socket_t, short, void *_request) {
auto request = static_cast<dns_request*>(_request);
auto errc = ub_resolve_event(request->resolver->ub_ctx, request->host.c_str(), (int) request->rrtype, (int) request->rrclass, (void*) request, [](void* _request, int a, void* b, int c, int d, char* e) {
auto request = static_cast<dns_request*>(_request);
request->resolver->ub_callback(request, a, b, c, d, e);
}, &request->ub_id);
if(errc != 0) {
request->callback(ResultState::INITIALISATION_FAILED, errc, nullptr);
request->resolver->destroy_dns_request(request);
}
}, request);
if(!request->timeout_event || !request->register_event) {
callback(ResultState::INITIALISATION_FAILED, 2, nullptr);
if(request->timeout_event)
event_free(request->timeout_event);
if(request->register_event)
event_free(request->register_event);
delete request;
return;
}
/*
* Lock here all requests so the event loop cant already delete the request
*/
unique_lock rlock{this->request_lock};
{
auto errc = event_add(request->timeout_event, nullptr);
//TODO: Check for error
evuser_trigger(request->register_event);
}
{
auto seconds = chrono::floor<chrono::seconds>(timeout);
auto microseconds = chrono::ceil<chrono::microseconds>(timeout - seconds);
timeval tv{seconds.count(), microseconds.count()};
auto errc = event_add(request->timeout_event, &tv);
//TODO: Check for error
}
this->dns_requests.push_back(request);
rlock.unlock();
/* Activate the event loop */
this->event.condition.notify_one();
}
void Resolver::evtimer_dns_callback(tc::dns::Resolver::dns_request *request) {
if(request->ub_id > 0) {
auto errc = ub_cancel(this->ub_ctx, request->ub_id);
if(errc != 0) {
cerr << "Failed to cancel DNS request " << request->ub_id << " after timeout (" << errc << "/" << ub_strerror(errc) << ")!" << endl;
}
}
request->callback(ResultState::DNS_TIMEOUT, 0, nullptr);
this->destroy_dns_request(request);
}
void Resolver::ub_callback(dns_request* request, int rcode, void *packet, int packet_length, int sec, char *why_bogus) {
if(rcode != 0) {
request->callback(ResultState::DNS_FAIL, rcode, nullptr);
} else {
auto callback = request->callback;
auto data = std::unique_ptr<DNSResponse>(new DNSResponse{(uint8_t) sec, why_bogus, packet, (size_t) packet_length});
callback(ResultState::SUCCESS, 0, std::move(data));
}
this->destroy_dns_request(request);
}
thread_local std::vector<size_t> visited_links;
std::string DNSResponseData::parse_dns_dn(std::string &error, size_t &index, bool allow_compression) {
if(allow_compression) {
visited_links.clear();
visited_links.reserve(8);
if(std::find(visited_links.begin(), visited_links.end(), index) != visited_links.end()) {
error = "circular link detected";
return "";
}
visited_links.push_back(index);
}
error.clear();
string result;
result.reserve(256); //Max length is 253
while(true) {
if(index + 1 > this->length) {
error = "truncated data (missing code)";
goto exit;
}
auto code = this->buffer[index++];
if(code == 0) break;
if((code >> 6U) == 3) {
if(!allow_compression) {
error = "found link, but links are not allowed";
goto exit;
}
auto lower_addr = this->buffer[index++];
if(index + 1 > this->length) {
error = "truncated data (missing lower link address)";
goto exit;
}
size_t addr = ((code & 0x3FU) << 8U) | lower_addr;
if(addr >= this->length) {
error = "invalid link address";
goto exit;
}
auto tail = this->parse_dns_dn(error, addr, true);
if(!error.empty())
goto exit;
if(!result.empty())
result += "." + tail;
else
result = tail;
break;
} else {
if(code > 63) {
error = "max domain label length is 63 characters";
goto exit;
}
if(!result.empty())
result += ".";
if(index + code >= this->length) {
error = "truncated data (domain label)";
goto exit;
}
result.append((const char*) (this->buffer + index), code);
index += code;
}
}
exit:
if(allow_compression) visited_links.pop_back();
return result;
}
DNSResponseData::~DNSResponseData() {
::free(this->buffer);
}
DNSResponse::DNSResponse(uint8_t secure_state, const char* bogus, void *packet, size_t size) {
this->bogus = bogus ? std::string{bogus} : std::string{"packet is secure"};
this->secure_state = secure_state;
this->data = make_shared<DNSResponseData>();
this->data->buffer = (uint8_t*) malloc(size);
this->data->length = size;
memcpy(this->data->buffer, packet, size);
}
response::DNSHeader DNSResponse::header() const {
return response::DNSHeader{this};
}
bool DNSResponse::parse(std::string &error) {
if(this->is_parsed) {
error = this->parse_error;
return error.empty();
}
error.clear();
this->is_parsed = true;
auto header = this->header();
size_t index = 12; /* 12 bits for the header */
{
auto count = header.query_count();
this->parsed_queries.reserve(count);
for(size_t idx = 0; idx < count; idx++) {
auto dn = this->data->parse_dns_dn(error, index, true);
if(!error.empty()) {
error = "failed to parse query " + to_string(idx) + " dn: " + error; // NOLINT(performance-inefficient-string-concatenation)
goto error_exit;
}
if(index + 4 > this->packet_length()) {
error = "truncated data for query " + to_string(index);
goto error_exit;
}
auto type = (rrtype::value) ntohs(*(uint16_t*) (this->data->buffer + index));
index += 2;
auto klass = (rrclass::value) ntohs(*(uint16_t*) (this->data->buffer + index));
index += 2;
this->parsed_queries.emplace_back(new response::DNSQuery{dn, type, klass});
}
}
{
auto count = header.answer_count();
this->parsed_answers.reserve(count);
for(size_t idx = 0; idx < count; idx++) {
this->parsed_answers.push_back(this->parse_rr(error, index, true));
if(!error.empty()) {
error = "failed to parse answer " + to_string(idx) + ": " + error; // NOLINT(performance-inefficient-string-concatenation)
goto error_exit;
}
}
}
{
auto count = header.authority_count();
this->parsed_authorities.reserve(count);
for(size_t idx = 0; idx < count; idx++) {
this->parsed_authorities.push_back(this->parse_rr(error, index, true));
if(!error.empty()) {
error = "failed to parse authority " + to_string(idx) + ": " + error; // NOLINT(performance-inefficient-string-concatenation)
goto error_exit;
}
}
}
{
auto count = header.additional_count();
this->parsed_additionals.reserve(count);
for(size_t idx = 0; idx < count; idx++) {
this->parsed_additionals.push_back(this->parse_rr(error, index, true));
if(!error.empty()) {
error = "failed to parse additional " + to_string(idx) + ": " + error; // NOLINT(performance-inefficient-string-concatenation)
goto error_exit;
}
}
}
return true;
error_exit:
this->parsed_queries.clear();
this->parsed_answers.clear();
this->parsed_authorities.clear();
this->parsed_additionals.clear();
return false;
}
std::shared_ptr<response::DNSResourceRecords> DNSResponse::parse_rr(std::string &error, size_t &index, bool allow_compressed) {
auto dn = this->data->parse_dns_dn(error, index, allow_compressed);
if(!error.empty()) {
error = "failed to parse rr dn: " + error; // NOLINT(performance-inefficient-string-concatenation)
return nullptr;
}
if(index + 10 > this->packet_length()) {
error = "truncated header";
return nullptr;
}
auto type = (rrtype::value) ntohs(*(uint16_t*) (this->data->buffer + index));
index += 2;
auto klass = (rrclass::value) ntohs(*(uint16_t*) (this->data->buffer + index));
index += 2;
auto ttl = ntohl(*(uint32_t*) (this->data->buffer + index));
index += 4;
auto payload_length = ntohs(*(uint16_t*) (this->data->buffer + index));
index += 2;
if(index + payload_length > this->packet_length()) {
error = "truncated body";
return nullptr;
}
auto response = std::shared_ptr<response::DNSResourceRecords>(new response::DNSResourceRecords{this->data, index, payload_length, ttl, dn, type, klass});
index += payload_length;
return response;
}

15
native/dns/src/response.cpp
View File

@ -28,13 +28,13 @@ uint16_t DNSHeader::field(int index) const {
return ((uint16_t*) this->response->packet_data())[index];
}
DNSResourceRecords::DNSResourceRecords(std::shared_ptr<DNSResponseBuffer> packet, size_t payload_offset, size_t length, uint32_t ttl, std::string name, rrtype::value type, rrclass::value klass)
DNSResourceRecords::DNSResourceRecords(std::shared_ptr<DNSResponseData> packet, size_t payload_offset, size_t length, uint32_t ttl, std::string name, rrtype::value type, rrclass::value klass)
: offset{payload_offset}, length{length}, ttl{ttl}, name{std::move(name)}, type{type}, klass{klass} {
this->packet = std::move(packet);
this->data = std::move(packet);
}
const uint8_t* DNSResourceRecords::payload_data() const {
return this->packet->buffer + this->offset;
return this->data->buffer + this->offset;
}
//---------------- AAAA
@ -46,6 +46,7 @@ in6_addr AAAA::address() {
return {
.__in6_u = {
.__u6_addr32 = {
//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],
@ -61,26 +62,26 @@ bool SRV::is_valid() {
return false;
size_t index = this->handle->payload_offset() + 6;
std::string error{};
this->handle->dns_packet()->parse_dns_dn(error, index, true);
this->handle->dns_data()->parse_dns_dn(error, index, true);
return error.empty();
}
std::string SRV::target_hostname() {
size_t index = this->handle->payload_offset() + 6;
std::string error{};
return this->handle->dns_packet()->parse_dns_dn(error, index, true);
return this->handle->dns_data()->parse_dns_dn(error, index, true);
}
//---------------- All types with a name
bool named_base::is_valid() {
size_t index = this->handle->payload_offset();
std::string error{};
this->handle->dns_packet()->parse_dns_dn(error, index, true);
this->handle->dns_data()->parse_dns_dn(error, index, true);
return error.empty();
}
std::string named_base::name() {
size_t index = this->handle->payload_offset();
std::string error{};
return this->handle->dns_packet()->parse_dns_dn(error, index, true);
return this->handle->dns_data()->parse_dns_dn(error, index, true);
}

39
native/dns/src/response.h
View File

@ -9,9 +9,10 @@
namespace tc::dns {
class DNSResponse;
class DNSResponseBuffer;
class DNSResponseData;
namespace response {
#ifndef WIN32
class DNSHeader {
friend class tc::dns::DNSResponse;
public:
@ -36,6 +37,7 @@ namespace tc::dns {
explicit DNSHeader(const DNSResponse* response) : response{response} {}
const DNSResponse* response{nullptr};
};
#endif
class DNSQuery {
friend class tc::dns::DNSResponse;
@ -54,16 +56,30 @@ namespace tc::dns {
class DNSResourceRecords {
friend class tc::dns::DNSResponse;
public:
[[nodiscard]] inline std::string qname() const { return this->name; }
[[nodiscard]] inline rrtype::value atype() const { return this->type; }
[[nodiscard]] inline rrclass::value aclass() const { return this->klass; }
[[nodiscard]] inline uint16_t attl() const { return this->ttl; }
[[nodiscard]] inline std::string qname() const {
return this->name;
}
[[nodiscard]] inline rrtype::value atype() const {
return this->type;
}
[[nodiscard]] inline rrclass::value aclass() const {
return this->klass;
}
[[nodiscard]] inline uint16_t attl() const {
return this->ttl;
}
#ifndef WIN32
[[nodiscard]] const uint8_t* payload_data() const;
[[nodiscard]] inline size_t payload_length() const { return this->length; }
[[nodiscard]] inline size_t payload_offset() const { return this->offset; }
#else
[[nodiscard]] inline PDNS_RECORDA native_record() const { return this->nrecord; }
#endif
[[nodiscard]] inline std::shared_ptr<DNSResponseBuffer> dns_packet() const { return this->packet; }
[[nodiscard]] inline std::shared_ptr<DNSResponseData> dns_data() const {
return this->data;
}
template <typename T>
[[nodiscard]] inline T parse() const {
@ -72,9 +88,15 @@ namespace tc::dns {
return T{this};
}
private:
DNSResourceRecords(std::shared_ptr<DNSResponseBuffer>, size_t, size_t, uint32_t, std::string , rrtype::value, rrclass::value);
std::shared_ptr<DNSResponseData> data{nullptr};
#ifdef WIN32
DNSResourceRecords(std::shared_ptr<DNSResponseData>, PDNS_RECORDA);
PDNS_RECORDA nrecord{nullptr};
#else
DNSResourceRecords(std::shared_ptr<DNSResponseData>, size_t, size_t, uint32_t, std::string , rrtype::value, rrclass::value);
std::shared_ptr<DNSResponseBuffer> packet{nullptr};
size_t offset{0};
size_t length{0};
@ -83,6 +105,7 @@ namespace tc::dns {
std::string name;
rrtype::value type;
rrclass::value klass;
#endif
};
namespace rrparser {