504 lines
18 KiB
C
504 lines
18 KiB
C
/*
|
||
* async_dns.c — асинхронный (неблокирующий) DNS-резолвер поверх uasync.
|
||
*
|
||
* Адаптер над libdns (lib/dns.c). Схема работы:
|
||
* adns_resolve() → dns_res_submit(A-запрос) → adns_drive()
|
||
* adns_drive() → dns_res_check():
|
||
* 0 → готово, dns_res_fetch → разбор A-записей → коллбэк
|
||
* EAGAIN → зарегистрировать fd (dns_res_pollfd/events) + таймер
|
||
* (dns_res_timeout) в uasync и ждать события
|
||
* иначе → ошибка → коллбэк с ADNS_ERR_RESPONSE
|
||
*
|
||
* Всё выполняется в потоке event loop, блокирующих вызовов нет.
|
||
*/
|
||
#include "async_dns.h"
|
||
#include "dns.h"
|
||
#include "debug_config.h"
|
||
#include "mem.h"
|
||
|
||
#include <errno.h>
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#include <stdio.h>
|
||
#include <ctype.h>
|
||
|
||
#ifdef _WIN32
|
||
#include <iphlpapi.h>
|
||
#endif
|
||
|
||
#define ADNS_DEBUG_CAT DEBUG_CATEGORY_SOCKET
|
||
|
||
struct adns_query {
|
||
struct UASYNC* ua;
|
||
adns_done_cb cb;
|
||
void* arg;
|
||
struct dns_resolver* res;
|
||
void* socket_id; /* handle uasync (NULL когда не зарегистрирован) */
|
||
int cur_fd; /* текущий зарегистрированный fd (-1 когда нет) */
|
||
void* timer; /* handle таймаута (NULL когда нет) */
|
||
int finished;
|
||
char* name;
|
||
int fast; /* 1 = готовый /etc/hosts-ответ, без libdns */
|
||
struct adns_result fast_result;
|
||
void* call_soon_id; /* отложенный вызов (fast-путь и первый драйв slow-пути) */
|
||
};
|
||
|
||
static void adns_drive(struct adns_query* q);
|
||
static void adns_finish(struct adns_query* q, int status, struct sockaddr_in* addrs, int count);
|
||
static void adns_read_cb(socket_t sock, void* arg);
|
||
static void adns_write_cb(socket_t sock, void* arg);
|
||
static void adns_timer_cb(void* arg);
|
||
static void adns_fast_ready_cb(void* arg);
|
||
static int adns_hosts_lookup(const char* name, struct sockaddr_in* out);
|
||
|
||
/* ─── system DNS servers discovery ─── */
|
||
|
||
int adns_parse_resolv_conf(const char* text, struct sockaddr_in* out, int max) {
|
||
int n = 0;
|
||
const char* p = text;
|
||
|
||
if (!text || !out || max <= 0) return 0;
|
||
|
||
while (*p && n < max) {
|
||
while (*p == ' ' || *p == '\t' || *p == '\r' || *p == '\n') p++;
|
||
if (!*p) break;
|
||
|
||
if (strncmp(p, "nameserver", 10) == 0 && (p[10] == ' ' || p[10] == '\t')) {
|
||
p += 10;
|
||
while (*p == ' ' || *p == '\t') p++;
|
||
char tok[64];
|
||
int i = 0;
|
||
while (*p && *p != ' ' && *p != '\t' && *p != '\r' && *p != '\n' && *p != '#' && i < 63)
|
||
tok[i++] = *p++;
|
||
tok[i] = '\0';
|
||
memset(&out[n], 0, sizeof(out[n]));
|
||
if (tok[0] && inet_pton(AF_INET, tok, &out[n].sin_addr) == 1) {
|
||
out[n].sin_family = AF_INET;
|
||
out[n].sin_port = htons(53);
|
||
n++;
|
||
}
|
||
}
|
||
|
||
while (*p && *p != '\n') p++;
|
||
if (*p) p++;
|
||
}
|
||
return n;
|
||
}
|
||
|
||
#ifdef _WIN32
|
||
int adns_system_servers(struct sockaddr_in* out, int max) {
|
||
if (!out || max <= 0) return 0;
|
||
|
||
ULONG size = 0;
|
||
if (GetNetworkParams(NULL, &size) != ERROR_BUFFER_OVERFLOW) return 0;
|
||
PFIXED_INFO fi = (PFIXED_INFO)u_malloc(size);
|
||
if (!fi) return 0;
|
||
if (GetNetworkParams(fi, &size) != NO_ERROR) { u_free(fi); return 0; }
|
||
|
||
int n = 0;
|
||
IP_ADDR_STRING* p = &fi->DnsServerList;
|
||
while (p && n < max) {
|
||
const char* s = p->IpAddress.String;
|
||
while (*s && n < max) {
|
||
while (*s == ' ' || *s == ',') s++;
|
||
char tok[64];
|
||
int i = 0;
|
||
while (*s && *s != ' ' && *s != ',' && i < 63) tok[i++] = *s++;
|
||
tok[i] = '\0';
|
||
memset(&out[n], 0, sizeof(out[n]));
|
||
if (tok[0] && inet_pton(AF_INET, tok, &out[n].sin_addr) == 1) {
|
||
out[n].sin_family = AF_INET;
|
||
out[n].sin_port = htons(53);
|
||
n++;
|
||
}
|
||
}
|
||
p = p->Next;
|
||
}
|
||
u_free(fi);
|
||
return n;
|
||
}
|
||
#else
|
||
int adns_system_servers(struct sockaddr_in* out, int max) {
|
||
if (!out || max <= 0) return 0;
|
||
FILE* f = fopen("/etc/resolv.conf", "r");
|
||
if (!f) return 0;
|
||
char buf[4096];
|
||
size_t rd = fread(buf, 1, sizeof(buf) - 1, f);
|
||
fclose(f);
|
||
buf[rd] = '\0';
|
||
return adns_parse_resolv_conf(buf, out, max);
|
||
}
|
||
#endif
|
||
|
||
/* ─── синхронный /etc/hosts-лукап (быстрый путь, без libdns) ─── */
|
||
|
||
// Ищет name в /etc/hosts. Возвращает 1 если найден IPv4-адрес (out заполнен).
|
||
// Блокирующее чтение небольшого файла — только для локальных имён (localhost и т.п.).
|
||
static int adns_hosts_lookup(const char* name, struct sockaddr_in* out) {
|
||
#ifndef _WIN32
|
||
if (!name || !out) return 0;
|
||
FILE* f = fopen("/etc/hosts", "r");
|
||
if (!f) return 0;
|
||
char line[512];
|
||
int found = 0;
|
||
while (!found && fgets(line, sizeof(line), f)) {
|
||
char ip[64]; int n = 0;
|
||
const char* p = line;
|
||
while (*p && !isspace(*p) && n < 63) ip[n++] = *p++;
|
||
ip[n] = '\0';
|
||
if (!ip[0] || ip[0] == '#') continue;
|
||
struct in_addr a;
|
||
if (inet_pton(AF_INET, ip, &a) != 1) continue;
|
||
while (*p && isspace(*p)) p++;
|
||
while (*p && *p != '\n') {
|
||
if (*p == '#') break;
|
||
char h[256]; int hn = 0;
|
||
while (*p && !isspace(*p) && *p != '#' && hn < 255) h[hn++] = *p++;
|
||
h[hn] = '\0';
|
||
if (h[0] && strcasecmp(h, name) == 0) {
|
||
memset(out, 0, sizeof(*out));
|
||
out->sin_family = AF_INET;
|
||
out->sin_addr = a;
|
||
found = 1;
|
||
break;
|
||
}
|
||
while (*p && isspace(*p)) p++;
|
||
}
|
||
}
|
||
fclose(f);
|
||
return found;
|
||
#else
|
||
(void)name; (void)out;
|
||
return 0;
|
||
#endif
|
||
}
|
||
|
||
/* ─── resolver setup ─── */
|
||
|
||
static struct dns_resolver* adns_open_resolver(const struct sockaddr_in* servers, int count,
|
||
int timeout_ms, int attempts) {
|
||
int error = 0;
|
||
struct dns_resolv_conf* rc = dns_resconf_open(&error);
|
||
if (!rc) {
|
||
DEBUG_ERROR(ADNS_DEBUG_CAT, "adns: dns_resconf_open failed: %s", dns_strerror(error));
|
||
return NULL;
|
||
}
|
||
|
||
for (int i = 0; i < count && i < 3; i++) {
|
||
struct sockaddr_storage* ss = &rc->nameserver[i];
|
||
struct sockaddr_in* sin = (struct sockaddr_in*)ss;
|
||
memset(ss, 0, sizeof(*ss));
|
||
sin->sin_family = AF_INET;
|
||
sin->sin_addr = servers[i].sin_addr;
|
||
sin->sin_port = servers[i].sin_port ? servers[i].sin_port : htons(53);
|
||
}
|
||
if (timeout_ms > 0) {
|
||
unsigned sec = (unsigned)((timeout_ms + 999) / 1000);
|
||
rc->options.timeout = sec ? sec : 1;
|
||
}
|
||
if (attempts > 0) rc->options.attempts = (unsigned)attempts;
|
||
|
||
struct dns_hosts* hosts = dns_hosts_open(&error);
|
||
if (!hosts) {
|
||
DEBUG_ERROR(ADNS_DEBUG_CAT, "adns: dns_hosts_open failed: %s", dns_strerror(error));
|
||
dns_resconf_close(rc);
|
||
return NULL;
|
||
}
|
||
#ifndef _WIN32
|
||
// Локальные имена из /etc/hosts (localhost и т.п.). Не фатально, если файла нет.
|
||
if (dns_hosts_loadpath(hosts, "/etc/hosts") != 0)
|
||
DEBUG_DEBUG(ADNS_DEBUG_CAT, "adns: /etc/hosts not loaded");
|
||
#endif
|
||
|
||
struct dns_hints* hints = dns_hints_local(rc, &error);
|
||
if (!hints) {
|
||
DEBUG_ERROR(ADNS_DEBUG_CAT, "adns: dns_hints_local failed: %s", dns_strerror(error));
|
||
dns_hosts_close(hosts);
|
||
dns_resconf_close(rc);
|
||
return NULL;
|
||
}
|
||
|
||
struct dns_resolver* res = dns_res_open(rc, hosts, hints, NULL, NULL, &error);
|
||
dns_resconf_close(rc);
|
||
dns_hosts_close(hosts);
|
||
dns_hints_close(hints);
|
||
|
||
if (!res)
|
||
DEBUG_ERROR(ADNS_DEBUG_CAT, "adns: dns_res_open failed: %s", dns_strerror(error));
|
||
return res;
|
||
}
|
||
|
||
/* ─── driving state machine ─── */
|
||
|
||
static void adns_teardown(struct adns_query* q) {
|
||
if (q->timer) { uasync_cancel_timeout(q->ua, q->timer); q->timer = NULL; }
|
||
if (q->socket_id) {
|
||
uasync_remove_socket_t(q->ua, (socket_t)q->cur_fd);
|
||
q->socket_id = NULL;
|
||
}
|
||
q->cur_fd = -1;
|
||
if (q->res) { dns_res_close(q->res); q->res = NULL; }
|
||
}
|
||
|
||
static void adns_rearm(struct adns_query* q) {
|
||
int fd = dns_res_pollfd(q->res);
|
||
int events = dns_res_events(q->res);
|
||
|
||
if (fd != q->cur_fd) {
|
||
if (q->socket_id) {
|
||
uasync_remove_socket_t(q->ua, (socket_t)q->cur_fd);
|
||
q->socket_id = NULL;
|
||
}
|
||
q->cur_fd = -1;
|
||
if (fd >= 0) {
|
||
q->socket_id = uasync_add_socket_t(q->ua, (socket_t)fd, adns_read_cb, adns_write_cb, NULL, "dns_query", q);
|
||
if (q->socket_id) q->cur_fd = fd;
|
||
else DEBUG_ERROR(ADNS_DEBUG_CAT, "adns: uasync_add_socket_t(%d) failed", fd);
|
||
}
|
||
}
|
||
|
||
if (q->socket_id) {
|
||
uasync_set_socket_read(q->ua, q->socket_id, (events & DNS_POLLIN) ? 1 : 0);
|
||
uasync_set_socket_write(q->ua, q->socket_id, (events & DNS_POLLOUT) ? 1 : 0);
|
||
}
|
||
|
||
time_t t = dns_res_timeout(q->res);
|
||
if (t < 1) t = 1;
|
||
if (q->timer) { uasync_cancel_timeout(q->ua, q->timer); q->timer = NULL; }
|
||
q->timer = uasync_set_timeout(q->ua, (int)(t * 10000), q, adns_timer_cb, "adns");
|
||
if (!q->timer)
|
||
DEBUG_ERROR(ADNS_DEBUG_CAT, "adns: uasync_set_timeout failed");
|
||
}
|
||
|
||
static void adns_drive(struct adns_query* q) {
|
||
if (q->finished) return;
|
||
|
||
int error = dns_res_check(q->res);
|
||
if (error == 0) {
|
||
int ferr = 0;
|
||
struct dns_packet* answer = dns_res_fetch(q->res, &ferr);
|
||
if (!answer) {
|
||
DEBUG_ERROR(ADNS_DEBUG_CAT, "adns: '%s' dns_res_fetch failed: %s", q->name, dns_strerror(ferr));
|
||
adns_finish(q, ADNS_ERR_RESPONSE, NULL, 0);
|
||
return;
|
||
}
|
||
|
||
unsigned rcode = dns_p_rcode(answer);
|
||
if (rcode == DNS_RC_NOERROR) {
|
||
struct sockaddr_in addrs[ADNS_MAX_ADDRS];
|
||
int n = 0;
|
||
struct dns_rr rr;
|
||
struct dns_a a;
|
||
dns_rr_foreach(&rr, answer, .section = DNS_S_AN, .type = DNS_T_A) {
|
||
if (n >= ADNS_MAX_ADDRS) break;
|
||
dns_a_parse(&a, &rr, answer);
|
||
memset(&addrs[n], 0, sizeof(addrs[n]));
|
||
addrs[n].sin_family = AF_INET;
|
||
addrs[n].sin_addr = a.addr;
|
||
n++;
|
||
}
|
||
free(answer);
|
||
if (n > 0) {
|
||
char ip[INET_ADDRSTRLEN];
|
||
inet_ntop(AF_INET, &addrs[0].sin_addr, ip, sizeof(ip));
|
||
DEBUG_INFO(ADNS_DEBUG_CAT, "adns: '%s' resolved to %d A record(s), first=%s", q->name, n, ip);
|
||
adns_finish(q, ADNS_OK, addrs, n);
|
||
} else {
|
||
DEBUG_WARN(ADNS_DEBUG_CAT, "adns: '%s' no A records (NOERROR, empty answer)", q->name);
|
||
adns_finish(q, ADNS_ERR_NODATA, NULL, 0);
|
||
}
|
||
} else {
|
||
const char* rc = dns_strrcode((enum dns_rcode)rcode);
|
||
if (rcode == DNS_RC_NXDOMAIN) {
|
||
free(answer);
|
||
DEBUG_WARN(ADNS_DEBUG_CAT, "adns: '%s' NXDOMAIN", q->name);
|
||
adns_finish(q, ADNS_ERR_NODATA, NULL, 0);
|
||
} else if (rcode == DNS_RC_SERVFAIL) {
|
||
/* libdns синтезирует SERVFAIL и при таймауте (ответа не получено) */
|
||
const struct dns_stat* st = dns_res_stat(q->res);
|
||
int no_resp = st && st->udp.rcvd.count == 0;
|
||
free(answer);
|
||
if (no_resp) {
|
||
DEBUG_WARN(ADNS_DEBUG_CAT, "adns: '%s' timed out (no response from nameservers)", q->name);
|
||
adns_finish(q, ADNS_ERR_TIMEOUT, NULL, 0);
|
||
} else {
|
||
DEBUG_WARN(ADNS_DEBUG_CAT, "adns: '%s' SERVFAIL", q->name);
|
||
adns_finish(q, ADNS_ERR_RESPONSE, NULL, 0);
|
||
}
|
||
} else {
|
||
free(answer);
|
||
DEBUG_WARN(ADNS_DEBUG_CAT, "adns: '%s' rcode=%s — response error", q->name, rc);
|
||
adns_finish(q, ADNS_ERR_RESPONSE, NULL, 0);
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
|
||
if (error == EAGAIN) {
|
||
adns_rearm(q);
|
||
return;
|
||
}
|
||
|
||
DEBUG_ERROR(ADNS_DEBUG_CAT, "adns: '%s' dns_res_check error=%d (%s)", q->name, error, dns_strerror(error));
|
||
adns_finish(q, ADNS_ERR_RESPONSE, NULL, 0);
|
||
}
|
||
|
||
static void adns_read_cb(socket_t sock, void* arg) {
|
||
(void)sock;
|
||
adns_drive((struct adns_query*)arg);
|
||
}
|
||
|
||
static void adns_write_cb(socket_t sock, void* arg) {
|
||
(void)sock;
|
||
adns_drive((struct adns_query*)arg);
|
||
}
|
||
|
||
static void adns_timer_cb(void* arg) {
|
||
struct adns_query* q = (struct adns_query*)arg;
|
||
q->timer = NULL;
|
||
adns_drive(q);
|
||
}
|
||
|
||
static void adns_finish(struct adns_query* q, int status, struct sockaddr_in* addrs, int count) {
|
||
if (q->finished) return;
|
||
q->finished = 1;
|
||
|
||
adns_teardown(q);
|
||
|
||
struct adns_result res;
|
||
res.status = status;
|
||
res.count = count > 0 ? count : 0;
|
||
if (res.count > 0 && addrs) memcpy(res.addrs, addrs, (size_t)res.count * sizeof(*addrs));
|
||
|
||
adns_done_cb cb = q->cb;
|
||
void* arg = q->arg;
|
||
char* name = q->name;
|
||
q->name = NULL;
|
||
u_free(q);
|
||
|
||
if (cb) cb(&res, arg);
|
||
u_free(name);
|
||
}
|
||
|
||
// Отложенный вызов коллбэка для fast-пути (/etc/hosts): сохраняет async-контракт
|
||
// (adns_resolve возвращает handle, коллбэк вызывается в потоке event loop).
|
||
static void adns_fast_ready_cb(void* arg) {
|
||
struct adns_query* q = (struct adns_query*)arg;
|
||
q->call_soon_id = NULL;
|
||
if (q->finished) return; // отменён до срабатывания
|
||
q->finished = 1;
|
||
adns_done_cb cb = q->cb;
|
||
void* a = q->arg;
|
||
struct adns_result res = q->fast_result;
|
||
char* nm = q->name;
|
||
q->name = NULL;
|
||
u_free(q);
|
||
if (cb) cb(&res, a);
|
||
u_free(nm);
|
||
}
|
||
|
||
// Отложенный первый драйв slow-пути (libdns): adns_resolve возвращает живой handle,
|
||
// а реальный запуск запроса происходит в event loop. Это исключает ситуацию, когда
|
||
// dns_res_check завершается синхронно прямо внутри adns_resolve() и освобождает q
|
||
// до того, как вызывающий код получил и сохранил handle.
|
||
static void adns_drive_trampoline(void* arg) {
|
||
struct adns_query* q = (struct adns_query*)arg;
|
||
q->call_soon_id = NULL;
|
||
if (q->finished) return; // отменён до срабатывания
|
||
adns_drive(q);
|
||
}
|
||
|
||
/* ─── public API ─── */
|
||
|
||
struct adns_query* adns_resolve(struct UASYNC* ua, const char* name,
|
||
const struct adns_opts* opts,
|
||
adns_done_cb cb, void* arg) {
|
||
if (!ua || !name || !name[0] || !cb) return NULL;
|
||
if (strlen(name) > 255) { DEBUG_ERROR(ADNS_DEBUG_CAT, "adns: name too long"); return NULL; }
|
||
|
||
// Быстрый путь: имя из /etc/hosts (localhost и т.п.) — без libdns и сети.
|
||
// libdns по умолчанию идёт в DNS первым (lookup="bf"), поэтому локальные имена
|
||
// ждали бы таймаут DNS-запроса (2×2s); обрабатываем их сразу.
|
||
{
|
||
struct sockaddr_in ha;
|
||
if (adns_hosts_lookup(name, &ha)) {
|
||
struct adns_query* q = u_calloc(1, sizeof(*q));
|
||
if (!q) { DEBUG_ERROR(ADNS_DEBUG_CAT, "adns: calloc failed"); return NULL; }
|
||
q->ua = ua; q->cb = cb; q->arg = arg;
|
||
q->name = u_strdup(name);
|
||
if (!q->name) { u_free(q); DEBUG_ERROR(ADNS_DEBUG_CAT, "adns: strdup failed"); return NULL; }
|
||
q->fast = 1;
|
||
q->fast_result.status = ADNS_OK;
|
||
q->fast_result.count = 1;
|
||
q->fast_result.addrs[0] = ha;
|
||
q->call_soon_id = uasync_call_soon(ua, q, adns_fast_ready_cb);
|
||
if (!q->call_soon_id) { u_free(q->name); u_free(q); return NULL; }
|
||
DEBUG_DEBUG(ADNS_DEBUG_CAT, "adns: '%s' resolved from /etc/hosts (fast)", name);
|
||
return q;
|
||
}
|
||
}
|
||
|
||
struct sockaddr_in servers[3];
|
||
int count;
|
||
if (opts && opts->server.sin_family != 0) {
|
||
servers[0] = opts->server;
|
||
count = 1;
|
||
} else {
|
||
count = adns_system_servers(servers, 3);
|
||
}
|
||
if (count <= 0) {
|
||
DEBUG_ERROR(ADNS_DEBUG_CAT, "adns: no DNS servers available for '%s'", name);
|
||
return NULL;
|
||
}
|
||
|
||
int timeout_ms = (opts && opts->timeout_ms > 0) ? opts->timeout_ms : 2000;
|
||
int attempts = (opts && opts->max_attempts > 0) ? opts->max_attempts : 2;
|
||
|
||
struct adns_query* q = u_calloc(1, sizeof(*q));
|
||
if (!q) { DEBUG_ERROR(ADNS_DEBUG_CAT, "adns: calloc failed"); return NULL; }
|
||
q->ua = ua;
|
||
q->cb = cb;
|
||
q->arg = arg;
|
||
q->cur_fd = -1;
|
||
q->name = u_strdup(name);
|
||
if (!q->name) { u_free(q); DEBUG_ERROR(ADNS_DEBUG_CAT, "adns: strdup failed"); return NULL; }
|
||
|
||
q->res = adns_open_resolver(servers, count, timeout_ms, attempts);
|
||
if (!q->res) { u_free(q->name); u_free(q); return NULL; }
|
||
|
||
if (dns_res_submit(q->res, name, DNS_T_A, DNS_C_IN) != 0) {
|
||
DEBUG_ERROR(ADNS_DEBUG_CAT, "adns: dns_res_submit failed for '%s'", name);
|
||
dns_res_close(q->res);
|
||
u_free(q->name);
|
||
u_free(q);
|
||
return NULL;
|
||
}
|
||
|
||
DEBUG_DEBUG(ADNS_DEBUG_CAT, "adns: resolving '%s' via %d server(s), timeout=%dms attempts=%d",
|
||
name, count, timeout_ms, attempts);
|
||
|
||
q->call_soon_id = uasync_call_soon(ua, q, adns_drive_trampoline);
|
||
if (!q->call_soon_id) {
|
||
DEBUG_ERROR(ADNS_DEBUG_CAT, "adns: uasync_call_soon failed for '%s'", name);
|
||
dns_res_close(q->res);
|
||
u_free(q->name);
|
||
u_free(q);
|
||
return NULL;
|
||
}
|
||
return q;
|
||
}
|
||
|
||
void adns_cancel(struct adns_query* q) {
|
||
if (!q || q->finished) return;
|
||
q->finished = 1;
|
||
if (q->call_soon_id) { uasync_call_soon_cancel(q->ua, q->call_soon_id); q->call_soon_id = NULL; }
|
||
if (q->fast) {
|
||
u_free(q->name);
|
||
u_free(q);
|
||
return;
|
||
}
|
||
adns_teardown(q);
|
||
u_free(q->name);
|
||
u_free(q);
|
||
}
|