evgeny
2 weeks ago
12 changed files with 682 additions and 219 deletions
@ -0,0 +1,322 @@
|
||||
/**
|
||||
* @file test_conn_mgr_phases.c |
||||
* @brief conn_mgr: все три варианта подключения (DIRECT / REVERSE / INDIRECT) |
||||
* |
||||
* Топология каждого сценария — три узла на loopback: C (публичный релей), |
||||
* A и B подключаются к C как клиенты, через BGP узнают друг друга. |
||||
* |
||||
* Сценарий 1 DIRECT: A=public, B=public → A подключается к B напрямую. |
||||
* Сценарий 2 REVERSE: A=public, B=nat → A не пробивает B (адрес испорчен), |
||||
* шлёт DIRECT_REQ, B подключается к A (обратное подключение). |
||||
* Сценарий 3 INDIRECT: A=nat, B=nat → оба без прямого адреса, выбирают |
||||
* посредника C через обмен кандидатами. |
||||
* |
||||
* Проверка честная: фазы выбираются реальным кодом (адреса цели испорчены на |
||||
* «неверный» порт, чтобы DIRECT провалился), RTT кандидата зреет настоящими |
||||
* probe-циклами (таймаут probe уменьшен до 10мс для скорости). |
||||
*/ |
||||
|
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include <string.h> |
||||
#include <stdarg.h> |
||||
#include "test_utils.h" |
||||
#include "etcp.h" |
||||
#include "etcp_connections.h" |
||||
#include "../src/config_parser.h" |
||||
#include "../src/config_updater.h" |
||||
#include "../src/utun_instance.h" |
||||
#include "topo_group.h" |
||||
#include "topo_node.h" |
||||
#include "conn_mgr.h" |
||||
#include "conn_mgr_priv.h" |
||||
#include "route_connectivity.h" |
||||
#include "../lib/u_async.h" |
||||
#include "../lib/debug_config.h" |
||||
#include "../lib/mem.h" |
||||
|
||||
#define POLL_MS 5 |
||||
#define LINK_TIMEOUT_MS 8000 |
||||
#define BGP_TIMEOUT_MS 8000 |
||||
#define CONN_TIMEOUT_MS 15000 |
||||
|
||||
static struct UASYNC* ua = NULL; |
||||
static struct UTUN_INSTANCE *inst_a = NULL, *inst_b = NULL, *inst_c = NULL; |
||||
static uint64_t nid_a = 0, nid_b = 0, nid_c = 0; |
||||
|
||||
static volatile int ev_a = -1, ev_b = -1; |
||||
static struct CONN_MGR_HANDLE *h_a = NULL, *h_b = NULL; |
||||
|
||||
static int g_failed = 0; |
||||
|
||||
static char temp_dir[] = "/tmp/utun_cm_phases_XXXXXX"; |
||||
#define TEMP_DIR_TEMPLATE "/tmp/utun_cm_phases_XXXXXX" |
||||
static char cfg_a[256], cfg_b[256], cfg_c[256]; |
||||
static int base_port = 0; |
||||
|
||||
/* ─── утилиты ─── */ |
||||
|
||||
static int write_file(const char* path, const char* fmt, ...) { |
||||
va_list ap; FILE* f = fopen(path, "w"); |
||||
if (!f) return -1; |
||||
va_start(ap, fmt); vfprintf(f, fmt, ap); va_end(ap); fclose(f); |
||||
return 0; |
||||
} |
||||
|
||||
static char* get_pubkey(const char* path) { |
||||
struct utun_config* cfg = parse_config(path); |
||||
if (!cfg) return NULL; |
||||
char* pub = u_strdup(cfg->global.my_public_key_hex); |
||||
free_config(cfg); |
||||
return pub; |
||||
} |
||||
|
||||
static void fail(const char* msg) { fprintf(stderr, "FAIL: %s\n", msg); fflush(stderr); g_failed = 1; } |
||||
|
||||
static void conn_cb_a(struct CONN_MGR_HANDLE* h, uint64_t node, uint64_t grp, enum conn_mgr_event ev, void* arg) { |
||||
(void)h; (void)node; (void)grp; (void)arg; ev_a = (int)ev; |
||||
} |
||||
static void conn_cb_b(struct CONN_MGR_HANDLE* h, uint64_t node, uint64_t grp, enum conn_mgr_event ev, void* arg) { |
||||
(void)h; (void)node; (void)grp; (void)arg; ev_b = (int)ev; |
||||
} |
||||
|
||||
static int poll_until(int (*cond)(void), uint32_t timeout_ms) { |
||||
uint64_t start = get_time_tb(); |
||||
while (!cond() && (get_time_tb() - start) < (uint64_t)timeout_ms * 10) uasync_poll(ua, POLL_MS); |
||||
return cond(); |
||||
} |
||||
|
||||
/* forward-декларации условий сценариев */ |
||||
static int ev_a_up(void); |
||||
static int ev_ab_up(void); |
||||
static int candidates_a_and_b(void); |
||||
|
||||
static int has_initialized_link(struct UTUN_INSTANCE* inst) { |
||||
if (!inst || !inst->connections) return 0; |
||||
struct ll_entry* e = inst->connections->head; |
||||
while (e) { |
||||
struct conn_queue_entry* ce = (struct conn_queue_entry*)e->data; |
||||
struct ETCP_LINK* l = ce->conn->links; |
||||
while (l) { if (l->initialized) return 1; l = l->next; } |
||||
e = e->next; |
||||
} |
||||
return 0; |
||||
} |
||||
|
||||
static struct TOPO_GROUP* defgrp(struct UTUN_INSTANCE* inst) { return topo_groups_get_default(inst->topo_groups); } |
||||
|
||||
static int learned(struct UTUN_INSTANCE* inst, uint64_t node_id) { |
||||
return defgrp(inst) && topo_node_find_by_id(defgrp(inst), node_id) != NULL; |
||||
} |
||||
|
||||
/* Меняем порт адресов цели на «неверный» (закрытый) — DIRECT создаст линк,
|
||||
* но handshake не получит ответа и фаза провалится по таймауту NCD. */ |
||||
static void mangle_addrs(struct UTUN_INSTANCE* inst, uint64_t node_id, uint16_t wrong_port) { |
||||
struct TOPO_NODE* ni = topo_node_registry_find(inst->topo_groups, node_id); |
||||
if (!ni) return; |
||||
for (struct TOPO_ADDR4* a = ni->v4_addrs; a; a = a->next) a->port = wrong_port; |
||||
for (struct TOPO_ADDR6* a6 = ni->v6_addrs; a6; a6 = a6->next) a6->port = wrong_port; |
||||
} |
||||
|
||||
static int best_candidates_ready(struct UTUN_INSTANCE* inst) { |
||||
struct TOPO_GROUP* g = defgrp(inst); |
||||
return g && g->conn_mgr && g->conn_mgr->best_candidate_count > 0; |
||||
} |
||||
|
||||
static uint8_t conn_type_of(struct UTUN_INSTANCE* inst, uint64_t node_id) { |
||||
struct TOPO_GROUP_NODE* nq = defgrp(inst) ? topo_node_find_by_id(defgrp(inst), node_id) : NULL; |
||||
return nq ? nq->conn_mgr_type : CONN_TYPE_NONE; |
||||
} |
||||
|
||||
/* ─── конфиги ─── */ |
||||
|
||||
static int write_node_config(const char* path, const char* tun_ip, const char* tun_if, |
||||
int srv_port, const char* type, const char* peer_pub, int peer_port) { |
||||
if (peer_pub) { |
||||
return write_file(path, |
||||
"[global]\n" |
||||
"tun_ip=%s/24\n" |
||||
"tun_ifname=%s\n" |
||||
"[server: srv]\n" |
||||
"addr=127.0.0.1:%d\n" |
||||
"type=%s\n" |
||||
"[client: to_relay]\n" |
||||
"keepalive=1\n" |
||||
"peer_public_key=%s\n" |
||||
"link=srv:127.0.0.1:%d\n" |
||||
"[allowed_keys]\n" |
||||
"allow_all=1\n", |
||||
tun_ip, tun_if, srv_port, type, peer_pub, peer_port); |
||||
} |
||||
return write_file(path, |
||||
"[global]\n" |
||||
"tun_ip=%s/24\n" |
||||
"tun_ifname=%s\n" |
||||
"[server: srv]\n" |
||||
"addr=127.0.0.1:%d\n" |
||||
"type=%s\n" |
||||
"[allowed_keys]\n" |
||||
"allow_all=1\n", |
||||
tun_ip, tun_if, srv_port, type); |
||||
} |
||||
|
||||
/* Создаёт конфиги C (public relay), A и B с заданными типами сокетов. */ |
||||
static int create_configs(const char* type_a, const char* type_b) { |
||||
strcpy(temp_dir, TEMP_DIR_TEMPLATE); |
||||
if (test_mkdtemp(temp_dir) != 0) { fprintf(stderr, "mkdtemp failed\n"); return -1; } |
||||
base_port = 43000 + (getpid() % 12000); |
||||
int pc = base_port, pa = base_port + 1, pb = base_port + 2; |
||||
snprintf(cfg_c, sizeof(cfg_c), "%s/c.conf", temp_dir); |
||||
snprintf(cfg_a, sizeof(cfg_a), "%s/a.conf", temp_dir); |
||||
snprintf(cfg_b, sizeof(cfg_b), "%s/b.conf", temp_dir); |
||||
|
||||
if (write_node_config(cfg_c, "10.90.0.3", "tun_c", pc, "public", NULL, 0) != 0) return -1; |
||||
if (config_ensure_keys_and_node_id(cfg_c) != 0) return -1; |
||||
char* pub_c = get_pubkey(cfg_c); |
||||
if (!pub_c) return -1; |
||||
|
||||
if (write_node_config(cfg_a, "10.90.0.1", "tun_a", pa, type_a, pub_c, pc) != 0) { u_free(pub_c); return -1; } |
||||
if (write_node_config(cfg_b, "10.90.0.2", "tun_b", pb, type_b, pub_c, pc) != 0) { u_free(pub_c); return -1; } |
||||
u_free(pub_c); |
||||
if (config_ensure_keys_and_node_id(cfg_a) != 0) return -1; |
||||
if (config_ensure_keys_and_node_id(cfg_b) != 0) return -1; |
||||
return 0; |
||||
} |
||||
|
||||
static void cleanup_configs(void) { |
||||
test_unlink(cfg_a); test_unlink(cfg_b); test_unlink(cfg_c); |
||||
test_rmdir(temp_dir); |
||||
} |
||||
|
||||
/* ─── общий каркас сценария ─── */ |
||||
|
||||
static int has_initialized_link_all(void) { |
||||
return has_initialized_link(inst_a) && has_initialized_link(inst_b) && has_initialized_link(inst_c); |
||||
} |
||||
static int learned_ab(void) { return learned(inst_a, nid_b) && learned(inst_b, nid_a); } |
||||
|
||||
/* Инициализирует инстансы и ждёт линков + BGP (A↔B узнают друг друга). */ |
||||
static int scenario_setup(void) { |
||||
inst_c = utun_instance_create(ua, cfg_c); |
||||
inst_a = utun_instance_create(ua, cfg_a); |
||||
inst_b = utun_instance_create(ua, cfg_b); |
||||
if (!inst_c || !inst_a || !inst_b) { fail("instance create"); return -1; } |
||||
|
||||
if (init_connections(inst_c) != 0 || init_connections(inst_a) != 0 || init_connections(inst_b) != 0) { |
||||
fail("init_connections"); return -1; |
||||
} |
||||
nid_a = inst_a->node_id; nid_b = inst_b->node_id; nid_c = inst_c->node_id; |
||||
|
||||
if (!poll_until(has_initialized_link_all, LINK_TIMEOUT_MS)) { fail("links not initialized"); return -1; } |
||||
if (!poll_until(learned_ab, BGP_TIMEOUT_MS)) { fail("BGP: A/B did not learn each other"); return -1; } |
||||
return 0; |
||||
} |
||||
|
||||
static void scenario_teardown(void) { |
||||
if (h_a) { conn_mgr_close(h_a); h_a = NULL; } |
||||
if (h_b) { conn_mgr_close(h_b); h_b = NULL; } |
||||
if (inst_a) { inst_a->running = 0; utun_instance_destroy(inst_a); inst_a = NULL; } |
||||
if (inst_b) { inst_b->running = 0; utun_instance_destroy(inst_b); inst_b = NULL; } |
||||
if (inst_c) { inst_c->running = 0; utun_instance_destroy(inst_c); inst_c = NULL; } |
||||
cleanup_configs(); |
||||
} |
||||
|
||||
/* ─── Сценарий 1: DIRECT ─── */ |
||||
|
||||
static int run_direct(void) { |
||||
fprintf(stderr, "\n=== Scenario 1: DIRECT ===\n"); fflush(stderr); |
||||
if (create_configs("public", "public") != 0) { fail("configs"); return -1; } |
||||
if (scenario_setup() != 0) return -1; |
||||
|
||||
ev_a = -1; |
||||
conn_mgr_open(inst_a, TOPO_GROUP_UTUN, nid_b, conn_cb_a, NULL, &h_a); |
||||
if (!poll_until(ev_a_up, CONN_TIMEOUT_MS)) { fail("DIRECT: no CONN_EVENT_UP"); return -1; } |
||||
if (conn_type_of(inst_a, nid_b) != CONN_TYPE_DIRECT) { fail("DIRECT: conn_type != DIRECT"); return -1; } |
||||
|
||||
fprintf(stderr, " OK: DIRECT\n"); fflush(stderr); |
||||
return 0; |
||||
} |
||||
static int ev_a_up(void) { return ev_a == CONN_EVENT_UP; } |
||||
|
||||
/* ─── Сценарий 2: REVERSE ─── */ |
||||
|
||||
static int run_reverse(void) { |
||||
fprintf(stderr, "\n=== Scenario 2: REVERSE ===\n"); fflush(stderr); |
||||
if (create_configs("public", "nat") != 0) { fail("configs"); return -1; } |
||||
if (scenario_setup() != 0) return -1; |
||||
|
||||
/* Испортим адреса B в реестре A — DIRECT провалится, A уйдёт в REVERSE. */ |
||||
mangle_addrs(inst_a, nid_b, (uint16_t)(base_port + 1000)); |
||||
inst_a->etcp_connect_timeout_tb = 3000; /* 300мс — быстрый провал DIRECT */ |
||||
|
||||
ev_a = -1; |
||||
conn_mgr_open(inst_a, TOPO_GROUP_UTUN, nid_b, conn_cb_a, NULL, &h_a); |
||||
if (!poll_until(ev_a_up, CONN_TIMEOUT_MS)) { fail("REVERSE: no CONN_EVENT_UP"); return -1; } |
||||
if (conn_type_of(inst_a, nid_b) != CONN_TYPE_REVERSE) { fail("REVERSE: conn_type != REVERSE"); return -1; } |
||||
|
||||
fprintf(stderr, " OK: REVERSE\n"); fflush(stderr); |
||||
return 0; |
||||
} |
||||
|
||||
/* ─── Сценарий 3: INDIRECT ─── */ |
||||
|
||||
static int run_indirect(void) { |
||||
fprintf(stderr, "\n=== Scenario 3: INDIRECT ===\n"); fflush(stderr); |
||||
if (create_configs("nat", "nat") != 0) { fail("configs"); return -1; } |
||||
if (scenario_setup() != 0) return -1; |
||||
|
||||
/* Ждём, пока candidate_ping реально заполнит список посредников (C). */ |
||||
if (!poll_until(candidates_a_and_b, 8000)) { fail("INDIRECT: no candidates (C)"); return -1; } |
||||
|
||||
/* Испортим адреса цели с обеих сторон — DIRECT провалится у обоих. */ |
||||
mangle_addrs(inst_a, nid_b, (uint16_t)(base_port + 1000)); |
||||
mangle_addrs(inst_b, nid_a, (uint16_t)(base_port + 1000)); |
||||
inst_a->etcp_connect_timeout_tb = 3000; |
||||
inst_b->etcp_connect_timeout_tb = 3000; |
||||
|
||||
ev_a = -1; ev_b = -1; |
||||
conn_mgr_open(inst_a, TOPO_GROUP_UTUN, nid_b, conn_cb_a, NULL, &h_a); |
||||
conn_mgr_open(inst_b, TOPO_GROUP_UTUN, nid_a, conn_cb_b, NULL, &h_b); |
||||
if (!poll_until(ev_ab_up, CONN_TIMEOUT_MS)) { fail("INDIRECT: no CONN_EVENT_UP on both sides"); return -1; } |
||||
if (conn_type_of(inst_a, nid_b) != CONN_TYPE_INDIRECT) { fail("INDIRECT: A conn_type != INDIRECT"); return -1; } |
||||
if (conn_type_of(inst_b, nid_a) != CONN_TYPE_INDIRECT) { fail("INDIRECT: B conn_type != INDIRECT"); return -1; } |
||||
|
||||
/* Посредником должен быть C. */ |
||||
struct TOPO_GROUP_NODE* nq_b = topo_node_find_by_id(defgrp(inst_a), nid_b); |
||||
if (!nq_b || nq_b->conn_mgr_intermediariy_count < 1 || nq_b->conn_mgr_intermediaries[0] != nid_c) { |
||||
fail("INDIRECT: intermediary != C"); return -1; |
||||
} |
||||
|
||||
fprintf(stderr, " OK: INDIRECT via C\n"); fflush(stderr); |
||||
return 0; |
||||
} |
||||
static int candidates_a_and_b(void) { return best_candidates_ready(inst_a) && best_candidates_ready(inst_b); } |
||||
static int ev_ab_up(void) { return ev_a == CONN_EVENT_UP && ev_b == CONN_EVENT_UP; } |
||||
|
||||
/* ─── main ─── */ |
||||
|
||||
int main(void) { |
||||
debug_config_init(); |
||||
debug_set_level(DEBUG_LEVEL_ERROR); |
||||
utun_instance_set_tun_init_enabled(0); |
||||
route_connectivity_set_probe_timeout_ms(10); |
||||
|
||||
ua = uasync_create(); |
||||
if (!ua) { fprintf(stderr, "uasync_create failed\n"); return 1; } |
||||
|
||||
if (run_direct() != 0) g_failed = 1; |
||||
scenario_teardown(); |
||||
ev_a = -1; ev_b = -1; h_a = NULL; h_b = NULL; |
||||
|
||||
if (!g_failed && run_reverse() != 0) g_failed = 1; |
||||
scenario_teardown(); |
||||
ev_a = -1; ev_b = -1; h_a = NULL; h_b = NULL; |
||||
|
||||
if (!g_failed && run_indirect() != 0) g_failed = 1; |
||||
scenario_teardown(); |
||||
|
||||
if (ua) { uasync_destroy(ua, 0); ua = NULL; } |
||||
|
||||
fprintf(stderr, "%s\n", g_failed ? "RESULT: FAIL" : "RESULT: PASS"); fflush(stderr); |
||||
return g_failed ? 1 : 0; |
||||
} |
||||
Loading…
Reference in new issue