/*
* Authors:
* Roman Khlopkov <roman.khlopkov@demlabs.net>
* DeM Labs Inc. https://demlabs.net
* DeM Labs Open source community https://gitlab.demlabs.net
* Copyright (c) 2017-2020
* All rights reserved.
This file is part of DAP (Deus Applications Prototypes) the open source project
DAP (Deus Applicaions Prototypes) is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
DAP is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with any DAP based project. If not, see <http://www.gnu.org/licenses/>.
*/
#include <errno.h>
#include "dap_dns_server.h"
#include "dap_udp_server.h"
#include "dap_udp_client.h"
#include "dap_client_remote.h"
#include "dap_common.h"
#include "dap_chain_net.h"
#include "dap_chain_node.h"
#include "dap_string.h"
#include "dap_chain_global_db.h"
#include "dap_chain_global_db_remote.h"
#define LOG_TAG "dap_dns_server"
#ifndef _WIN32
#include <unistd.h> // for close
#define closesocket close
#define INVALID_SOCKET -1
#endif
static dap_dns_server_t *s_dns_server;
static char s_root_alias[] = "dnsroot";
/**
* @brief dap_dns_buf_init Initialize DNS parser buffer
* @param buf DNS buffer structure
* @param msg DNS message
* @return none
*/
void dap_dns_buf_init(dap_dns_buf_t *buf, char *msg) {
buf->data = msg;
buf->ptr = 0;
}
/**
* @brief dap_dns_buf_get_uint16 Get uint16 from network order
* @param buf DNS buffer structure
* @return uint16 in host order
*/
uint16_t dap_dns_buf_get_uint16(dap_dns_buf_t *buf) {
char c;
c = buf->data[buf->ptr++];
return c << 8 | buf->data[buf->ptr++];
}
/**
* @brief dap_dns_buf_put_uint16 Put uint16 to network order
* @param buf DNS buffer structure
* @param val uint16 in host order
* @return none
*/
void dap_dns_buf_put_uint16(dap_dns_buf_t *buf, uint16_t val) {
buf->data[buf->ptr++] = val >> 8;
buf->data[buf->ptr++] = val;
}
/**
* @brief dap_dns_buf_put_uint32 Put uint32 to network order
* @param buf DNS buffer structure
* @param val uint32 in host order
* @return none
*/
void dap_dns_buf_put_uint32(dap_dns_buf_t *buf, uint32_t val) {
dap_dns_buf_put_uint16(buf, val >> 16);
dap_dns_buf_put_uint16(buf, val);
}
uint32_t dap_dns_resolve_hostname(char *str) {
log_it(L_DEBUG, "DNS parser retrieve hostname %s", str);
uint16_t l_nets_count;
dap_chain_net_t **l_nets = dap_chain_net_list(&l_nets_count);
dap_chain_net_t *l_net = l_nets[rand() % l_nets_count];
// get nodes list from global_db
dap_global_db_obj_t *l_objs = NULL;
size_t l_nodes_count = 0;
// read all node
l_objs = dap_chain_global_db_gr_load(l_net->pub.gdb_nodes, &l_nodes_count);
if(!l_nodes_count || !l_objs)
return 0;
size_t l_node_num = rand() % l_nodes_count;
dap_chain_node_info_t *l_node_info = (dap_chain_node_info_t *) l_objs[l_node_num].value;
struct in_addr addr = l_node_info->hdr.ext_addr_v4;
dap_chain_global_db_objs_delete(l_objs, l_nodes_count);
log_it(L_DEBUG, "DNS resolver find ip %s", inet_ntoa(addr));
return addr.s_addr;
}
/**
* @brief dap_dns_zone_register Register DNS zone and set callback to handle it
* @param zone Name of zone to register
* @param callback Callback to handle DNS zone
* @return 0 if success, else return error code
*/
int dap_dns_zone_register(char *zone, dap_dns_zone_callback_t callback) {
dap_dns_zone_hash_t *new_zone;
HASH_FIND_STR(s_dns_server->hash_table, zone, new_zone);
if (new_zone == NULL) { // zone is not present
new_zone = DAP_NEW(dap_dns_zone_hash_t);
new_zone->zone = dap_strdup(zone);
HASH_ADD_KEYPTR(hh, s_dns_server->hash_table, new_zone->zone, strlen(new_zone->zone), new_zone);
} // if zone present, just reassign callback
new_zone->callback = callback;
return DNS_ERROR_NONE;
}
/**
* @brief dap_dns_zone_unregister Unregister DNS zone
* @param zone Name of zone to unregister
* @return 0 if success, else return error code
*/
int dap_dns_zone_unregister(char *zone) {
dap_dns_zone_hash_t *asked_zone;
HASH_FIND_STR(s_dns_server->hash_table, zone, asked_zone);
if (asked_zone == NULL) {
return DNS_ERROR_NAME;
}
HASH_DEL(s_dns_server->hash_table, asked_zone);
DAP_DELETE(asked_zone->zone);
DAP_DELETE(asked_zone);
return DNS_ERROR_NONE;
}
/**
* @brief dap_dns_zone_find Find callback to registered DNS zone
* @param hostname Name of host for which the zone callback being searched
* @return Callback for registered DNS zone, else return NULL
*/
dap_dns_zone_callback_t dap_dns_zone_find(char *hostname) {
dap_dns_zone_hash_t *asked_zone;
HASH_FIND_STR(s_dns_server->hash_table, hostname, asked_zone);
if (asked_zone == NULL) {
if (!strcmp(hostname, &s_root_alias[0])) {
return NULL;
}
char *zone_up = strchr(hostname, '.');
if (zone_up++ == NULL) {
zone_up = &s_root_alias[0];
}
return dap_dns_zone_find(zone_up);
} else {
return asked_zone->callback;
}
return NULL;
}
/**
* @brief dap_dns_client_read Read and parse incoming DNS message, send reply to it
* @param client DAP client remote structure
* @param arg Unused
* @return none
*/
void dap_dns_client_read(dap_client_remote_t *client, void * arg) {
UNUSED(arg);
if (client->buf_in_size < DNS_HEADER_SIZE) { // Bad request
return;
}
dap_dns_buf_t *dns_message = DAP_NEW(dap_dns_buf_t);
dap_dns_buf_t *dns_reply = DAP_NEW(dap_dns_buf_t);
dns_message->data = DAP_NEW_SIZE(char, client->buf_in_size + 1);
dns_message->data[client->buf_in_size] = 0;
dap_client_remote_read(client, dns_message->data, client->buf_in_size);
dns_message->ptr = 0;
// Parse incoming DNS message
int block_len = DNS_HEADER_SIZE;
dns_reply->data = DAP_NEW_SIZE(char, block_len);
dns_reply->ptr = 0;
uint16_t val = dap_dns_buf_get_uint16(dns_message); // ID
dap_dns_buf_put_uint16(dns_reply, val);
val = dap_dns_buf_get_uint16(dns_message); // Flags
dns_reply->ptr += sizeof(uint16_t); // Put flags later
dap_dns_message_flags_t msg_flags;
msg_flags.val = val;
dap_dns_message_flags_bits_t *flags = &msg_flags.flags;
if (flags->qr) { // It's not request
goto cleanup;
}
flags->rcode = DNS_ERROR_NONE;
flags->qr = 1; // Response bit set
if (flags->tc) { // Truncated messages not supported yet
flags->rcode = DNS_ERROR_NOT_SUPPORTED;
}
flags->ra = 0; // Recursion not supported yet
flags->aa = 1; // Authoritative answer
uint16_t qdcount = dap_dns_buf_get_uint16(dns_message);
dap_dns_buf_put_uint16(dns_reply, qdcount);
val = dap_dns_buf_get_uint16(dns_message); // AN count
if (val) { // No other sections should present
goto cleanup;
}
dap_dns_buf_put_uint16(dns_reply, 1); // 1 answer section
val = dap_dns_buf_get_uint16(dns_message); // NS count
if (val) { // No other sections should present
goto cleanup;
}
dap_dns_buf_put_uint16(dns_reply, val);
val = dap_dns_buf_get_uint16(dns_message); // AR count
if (val) { // No other sections should present
goto cleanup;
}
dap_dns_buf_put_uint16(dns_reply, val);
int dot_count = 0;
dap_string_t *dns_hostname = dap_string_new("");
for (int i = 0; i < qdcount; i++) {
block_len = strlen(&dns_message->data[dns_message->ptr]) + 1 + 2 * sizeof(uint16_t);
dns_reply->data = DAP_REALLOC(dns_reply->data, dns_reply->ptr + block_len);
memcpy(&dns_reply->data[dns_reply->ptr], &dns_message->data[dns_message->ptr], block_len);
dns_reply->ptr += block_len;
if (flags->rcode)
break;
while (dns_message->ptr < dns_reply->ptr - 2 * sizeof(uint16_t)) {
uint8_t len = dns_message->data[dns_message->ptr++];
if (len > DNS_MAX_DOMAIN_NAME_LEN) {
flags->rcode = DNS_ERROR_NAME;
break;
}
if (!len) {
break;
}
if (dot_count) {
if (dot_count > 3) { // Max three dots allowed
flags->rcode = DNS_ERROR_NAME;
break;
}
dap_string_append(dns_hostname, ".");
}
dap_string_append_len(dns_hostname, &dns_message->data[dns_message->ptr], len);
dns_message->ptr += len;
dot_count++;
if (dns_hostname->len >= DNS_MAX_HOSTNAME_LEN) {
flags->rcode = DNS_ERROR_NAME;
break;
}
}
val = dap_dns_buf_get_uint16(dns_message); // DNS record type
if (val != DNS_RECORD_TYPE_A) { // Only host address ipv4
flags->rcode = DNS_ERROR_NOT_SUPPORTED;
break;
}
val = dap_dns_buf_get_uint16(dns_message); // DNS class type
if (val != DNS_CLASS_TYPE_IN) { // Internet only
flags->rcode = DNS_ERROR_NOT_SUPPORTED;
break;
}
if (dns_message->ptr != dns_reply->ptr) {
log_it(L_ERROR, "DNS parser pointer unequal, mptr = %u, rptr = %u", dns_message->ptr, dns_reply->ptr);
}
}
// Find ip addr
uint32_t ip_addr = 0;
if (flags->rcode == DNS_ERROR_NONE) {
dap_dns_zone_callback_t callback = dap_dns_zone_find(dns_hostname->str);
if (callback) {
ip_addr = callback(dns_hostname->str);
}
}
if (ip_addr) {
// Compose DNS answer
block_len = DNS_ANSWER_SIZE;
dns_reply->data = DAP_REALLOC(dns_reply->data, dns_reply->ptr + block_len);
val = 0xc000 | DNS_HEADER_SIZE; // Link to host name
dap_dns_buf_put_uint16(dns_reply, val);
val = DNS_RECORD_TYPE_A;
dap_dns_buf_put_uint16(dns_reply, val);
val = DNS_CLASS_TYPE_IN;
dap_dns_buf_put_uint16(dns_reply, val);
uint32_t ttl = DNS_TIME_TO_LIVE;
dap_dns_buf_put_uint32(dns_reply, ttl);
val = 4; // RD len for ipv4
dap_dns_buf_put_uint16(dns_reply, val);
dap_dns_buf_put_uint32(dns_reply, ip_addr);
} else if (flags->rcode == DNS_ERROR_NONE) {
flags->rcode = DNS_ERROR_NAME;
}
if (flags->rcode) {
dns_reply->data[7] = 0; // No answer section
}
// Set reply flags
dns_reply->data[2] = msg_flags.val >> 8;
dns_reply->data[3] = msg_flags.val;
// Send DNS reply
dap_udp_client_write(client, dns_reply->data, dns_reply->ptr);
dap_udp_client_ready_to_write(client, true);
dap_string_free(dns_hostname, true);
cleanup:
DAP_DELETE(dns_reply->data);
DAP_DELETE(dns_message->data);
DAP_DELETE(dns_reply);
DAP_DELETE(dns_message);
return;
}
void dap_dns_server_start() {
s_dns_server = DAP_NEW(dap_dns_server_t);
s_dns_server->hash_table = NULL;
s_dns_server->instance = dap_udp_server_listen(DNS_LISTEN_PORT);
if (!s_dns_server->instance) {
log_it(L_ERROR, "Can't start DNS server");
return;
}
s_dns_server->instance->client_read_callback = dap_dns_client_read;
s_dns_server->instance->client_write_callback = NULL;
s_dns_server->instance->client_new_callback = NULL;
s_dns_server->instance->client_delete_callback = NULL;
dap_dns_zone_register(&s_root_alias[0], dap_dns_resolve_hostname); // root resolver
pthread_create(&s_dns_server->udp_thread, NULL, (void *)dap_udp_server_loop, s_dns_server->instance);
}
void dap_dns_server_stop() {
dap_dns_zone_hash_t *current_zone, *tmp;
HASH_ITER(hh, s_dns_server->hash_table, current_zone, tmp) {
HASH_DEL(s_dns_server->hash_table, current_zone);
DAP_DELETE(current_zone->zone);
DAP_DELETE(current_zone);
}
// TODO add code to stop udp_thread
dap_udp_server_delete(s_dns_server->instance);
DAP_DELETE(s_dns_server);
}
int s_dns_get_ip(uint32_t a_addr, char *a_name, uint32_t *a_result)
{
const size_t l_buf_size = 1024;
uint8_t l_buf[l_buf_size];
dap_dns_buf_t l_dns_request = {};
l_dns_request.data = (char *)l_buf;
dap_dns_buf_put_uint16(&l_dns_request, rand() % 0xFFFF); // ID
dap_dns_message_flags_t l_flags = {};
dap_dns_buf_put_uint16(&l_dns_request, l_flags.val);
dap_dns_buf_put_uint16(&l_dns_request, 1); // we have only 1 question
dap_dns_buf_put_uint16(&l_dns_request, 0);
dap_dns_buf_put_uint16(&l_dns_request, 0);
dap_dns_buf_put_uint16(&l_dns_request, 0);
size_t l_ptr = 0;
uint8_t *l_cur = l_buf + l_dns_request.ptr;
for (size_t i = 0; i <= strlen(a_name); i++)
{
if (a_name[i] == '.' || a_name[i] == 0)
{
*l_cur++ = i - l_ptr;
for( ; l_ptr < i; l_ptr++)
{
*l_cur++ = a_name[l_ptr];
}
l_ptr++;
}
}
*l_cur++='\0';
l_dns_request.ptr = l_cur - l_buf;
dap_dns_buf_put_uint16(&l_dns_request, DNS_RECORD_TYPE_A);
dap_dns_buf_put_uint16(&l_dns_request, DNS_CLASS_TYPE_IN);
#ifdef WIN32
SOCKET l_sock;
#else
int l_sock;
#endif
l_sock = socket(AF_INET, SOCK_DGRAM, 0);
if (l_sock == INVALID_SOCKET) {
log_it(L_ERROR, "Socket error");
return -1;
}
struct sockaddr_in l_addr;
l_addr.sin_family = AF_INET;
l_addr.sin_port = htons(DNS_LISTEN_PORT);
l_addr.sin_addr.s_addr = a_addr;
int l_portion = 0, l_len = l_dns_request.ptr;
for (int l_sent = 0; l_sent < l_len; l_sent += l_portion) {
l_portion = sendto(l_sock, (const char *)(l_buf + l_sent), l_len - l_sent, 0, (struct sockaddr *)&l_addr, sizeof(l_addr));
if (l_portion < 0) {
log_it(L_ERROR, "send() function error");
closesocket(l_sock);
return -2;
}
}
fd_set fd;
FD_ZERO(&fd);
FD_SET(l_sock, &fd);
struct timeval tv;
tv.tv_sec = 5;
tv.tv_usec = 0;
#ifdef WIN32
int l_selected = select(1, &fd, NULL, NULL, &tv);
#else
int l_selected = select(l_sock + 1, &fd, NULL, NULL, &tv);
#endif
if (l_selected < 0)
{
log_it(L_WARNING, "select() error");
closesocket(l_sock);
return -3;
}
if (l_selected == 0)
{
log_it(L_DEBUG, "select() timeout");
closesocket(l_sock);
return -4;
}
struct sockaddr_in l_clientaddr;
socklen_t l_clientlen = sizeof(l_clientaddr);
size_t l_recieved = recvfrom(l_sock, (char *)l_buf, l_buf_size, 0, (struct sockaddr *)&l_clientaddr, &l_clientlen);
size_t l_addr_point = DNS_HEADER_SIZE + strlen(a_name) + 2 + 2 * sizeof(uint16_t) + DNS_ANSWER_SIZE - sizeof(uint32_t);
if (l_recieved < l_addr_point + sizeof(uint32_t)) {
log_it(L_WARNING, "DNS answer incomplete");
closesocket(l_sock);
return -5;
}
l_cur = l_buf + 3 * sizeof(uint16_t);
int l_answers_count = ntohs(*(uint16_t *)l_cur);
if (l_answers_count != 1) {
log_it(L_WARNING, "Incorrect DNS answer format");
closesocket(l_sock);
return -6;
}
l_cur = l_buf + l_addr_point;
if (a_result) {
*a_result = ntohl(*(uint32_t *)l_cur);
}
closesocket(l_sock);
return 0;
}
uint32_t dap_dns_client_get_addr(uint32_t a_dns_addr)
{
uint32_t l_res;
if (s_dns_get_ip(a_dns_addr, "kelvin.sync", &l_res)) {
return 0;
}
return l_res;
}