From 2cc5a6df914795e7196ff7549ae7a54a033848d1 Mon Sep 17 00:00:00 2001 From: evgeny Date: Sat, 24 Oct 2026 18:43:32 +0200 Subject: [PATCH] Reproduce NCD startup failures stale events and malformed control --- tests/Makefile.am | 9 +++ tests/test_ncd_faults.c | 173 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 182 insertions(+) create mode 100644 tests/test_ncd_faults.c diff --git a/tests/Makefile.am b/tests/Makefile.am index 462f20ca..a6a492c9 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -103,6 +103,7 @@ check_PROGRAMS += \ test_ntp_regressions \ test_etcp_windows \ test_dummynet_channels \ + test_ncd_faults \ test_stcp_sigpipe \ test_firewall \ test_mem \ @@ -715,6 +716,14 @@ test_node_conn_direct_SOURCES = test_node_conn_direct.c test_node_conn_direct_CFLAGS = -I$(top_srcdir)/src -I$(top_srcdir)/lib test_node_conn_direct_LDADD = $(LIBUTUN) $(CRYPTO_LIBS) $(COMMON_LIBS) +if OS_LINUX +test_ncd_faults_SOURCES = test_ncd_faults.c $(test_clock_sources) +test_ncd_faults_CFLAGS = -I$(top_srcdir)/src -I$(top_srcdir)/lib +test_ncd_faults_LDADD = $(LIBUTUN) $(CRYPTO_LIBS) $(COMMON_LIBS) +test_ncd_faults_LDFLAGS = $(test_clock_ldflags) -Wl,--wrap=etcp_conn_add_cbk -Wl,--wrap=uasync_call_soon \ + -Wl,--wrap=uasync_set_timeout -Wl,--wrap=u_calloc_impl +endif + test_group_ownership_SOURCES = test_group_ownership.c test_group_ownership_CFLAGS = -I$(top_srcdir)/src -I$(top_srcdir)/lib test_group_ownership_LDADD = $(LIBUTUN) $(CRYPTO_LIBS) $(COMMON_LIBS) diff --git a/tests/test_ncd_faults.c b/tests/test_ncd_faults.c new file mode 100644 index 00000000..2de02e6a --- /dev/null +++ b/tests/test_ncd_faults.c @@ -0,0 +1,173 @@ +/* Реальные ядро/ETCP/таймеры: атомарный запуск NCD, отказы ресурсов и повторные события из callback. */ +#include +#include +#include "utun_instance.h" +#include "etcp.h" +#include "etcp_api.h" +#include "node_conn_direct.h" +#include "test_clock.h" +#include "../lib/mem.h" + +#define CHECK(x) do { if (!(x)) { DEBUG_ERROR(DEBUG_CATEGORY_DEBUG, "FAIL %s:%d: %s", __func__, __LINE__, #x); exit(1); } } while (0) +static struct UASYNC* ua; +static struct UTUN_INSTANCE* inst; +static size_t allocations; +static int fail_callback, fail_soon, fail_connect, fail_alloc; + +void __real_etcp_conn_add_cbk(struct ETCP_CONN*, etcp_cbk_fn, void*, int); +void __wrap_etcp_conn_add_cbk(struct ETCP_CONN* conn, etcp_cbk_fn fn, void* arg, int events) { + if (!fail_callback) __real_etcp_conn_add_cbk(conn, fn, arg, events); +} + +void* __real_uasync_call_soon(struct UASYNC*, void*, timeout_callback_t); +void* __wrap_uasync_call_soon(struct UASYNC* loop, void* arg, timeout_callback_t fn) { + if (fail_soon) { fail_soon--; return NULL; } + return __real_uasync_call_soon(loop, arg, fn); +} + +void* __real_uasync_set_timeout(struct UASYNC*, int, void*, timeout_callback_t, const char*); +void* __wrap_uasync_set_timeout(struct UASYNC* loop, int delay, void* arg, timeout_callback_t fn, const char* name) { + if (fail_connect && !strncmp(name, "ncd_connect", 11)) return NULL; + return __real_uasync_set_timeout(loop, delay, arg, fn, name); +} + +void* __real_u_calloc_impl(uint32_t, uint32_t, const char*); +void* __wrap_u_calloc_impl(uint32_t count, uint32_t size, const char* location) { + if (fail_alloc && strstr(location, "node_conn_direct.c")) return NULL; + return __real_u_calloc_impl(count, size, location); +} + +static void setup(void) { + allocations = u_get_allocated_count(); + ua = uasync_create(); CHECK(ua); + inst = utun_instance_create_from_str(ua, + "[global]\nauto_sockets=no\n" + "my_private_key=704f2e012c8fa8768130cb0f988a997dccb628372bc5ceccacc78dcbfec5916f\n" + "my_public_key=b3193173def895bd0fcea6f86af077c7d77216f10395275f627ac18242ec0f01\n" + "[ntp]\nenabled=no\n"); + CHECK(inst); inst->etcp_connect_timeout_tb = 10000; +} + +static void teardown(void) { + CHECK(!fail_callback && !fail_soon && !fail_connect && !fail_alloc); + utun_instance_destroy(inst); + uasync_poll(ua, 0); + CHECK(ua->timer_alloc_count == ua->timer_free_count); + CHECK(ua->socket_alloc_count == ua->socket_free_count); + uasync_destroy(ua, 0); + CHECK(u_get_allocated_count() == allocations); +} + +static struct ETCP_CONN* connection(int ready) { + struct ETCP_CONN* conn = etcp_connection_create(inst, "NCD fault fixture"); CHECK(conn); + conn->peer_node_id = 42; + queue_set_callback(conn->send_input_q, NULL, NULL); + CHECK(etcp_conn_index_peer(conn) == 0); + if (ready) { conn->links_up = 1; etcp_conn_ready(conn); CHECK(conn->state == 1); } + return conn; +} + +struct events { struct ETCP_CONN* conn; unsigned up, down, closed; int nested_down; }; +static void changed(struct NODE_CONN_DIRECT* handle, enum ncd_event event, void* arg) { + struct events* state = arg; (void)handle; + if (event == NCD_EVENT_UP) { + state->up++; + if (state->nested_down) { + state->nested_down = 0; state->conn->links_up = 0; + etcp_cbk_fire(state->conn, ETCP_CBK_EVENT_DOWN); + } + } else if (event == NCD_EVENT_DOWN) state->down++; + else if (event == NCD_EVENT_CLOSED) state->closed++; +} + +static void callback_failure(void) { + setup(); struct ETCP_CONN* conn = connection(1); + struct NODE_CONN_DIRECT* handle = NULL; struct events state = {0}; + fail_callback = 1; + int rc = node_conn_direct_open(inst, 42, changed, &state, &handle, NULL); + fail_callback = 0; + CHECK(rc == NCD_ERR && !handle && !inst->ncd_registry && !conn->close_requested && conn->ref_count == 0); + uasync_drain_immediate(ua); CHECK(!state.up && !state.closed); + teardown(); +} + +static void up_failure(void) { + setup(); struct ETCP_CONN* conn = connection(1); + struct NODE_CONN_DIRECT *owner = NULL, *extra = NULL; struct events state = {0}; + CHECK(node_conn_direct_open(inst, 42, NULL, NULL, &owner, NULL) == NCD_REUSED); + uasync_drain_immediate(ua); + fail_soon = 1; + int rc = node_conn_direct_open(inst, 42, changed, &state, &extra, NULL); + CHECK(rc == NCD_ERR && !extra && !fail_soon); + CHECK(node_conn_direct_handle_count(conn) == 1 && !conn->close_requested); + uasync_drain_immediate(ua); CHECK(!state.up && !state.closed); + node_conn_direct_force_close(owner); teardown(); +} + +static void timer_failure(void) { + setup(); struct ETCP_CONN* conn = connection(0); + struct NODE_CONN_DIRECT* handle = NULL; struct events state = {0}; + fail_connect = 1; + int rc = node_conn_direct_open(inst, 42, changed, &state, &handle, NULL); + fail_connect = 0; + CHECK(rc == NCD_ERR && !handle && !inst->ncd_registry && !conn->close_requested && conn->ref_count == 0); + teardown(); +} + +static void fin_wait_failure(void) { + setup(); struct ETCP_CONN* conn = connection(1); + struct NODE_CONN_DIRECT* handle = NULL; + CHECK(node_conn_direct_open(inst, 42, NULL, NULL, &handle, NULL) == NCD_REUSED); + node_conn_direct_close(handle); CHECK(conn->fin_wait); + fail_alloc = 1; + int rc = node_conn_direct_open(inst, 42, NULL, NULL, &handle, NULL); + fail_alloc = 0; + CHECK(rc == NCD_ERR && !handle && conn->fin_wait && node_conn_direct_handle_count(conn) == 0); + test_clock_run_for(ua, 51000); CHECK(!inst->ncd_registry); + teardown(); +} + +static void nested_events(void) { + setup(); struct ETCP_CONN* conn = connection(1); + struct NODE_CONN_DIRECT *first = NULL, *second = NULL; + struct events a = {.conn = conn}, b = {.conn = conn}; + CHECK(node_conn_direct_open(inst, 42, changed, &a, &first, NULL) == NCD_REUSED); + CHECK(node_conn_direct_open(inst, 42, changed, &b, &second, NULL) == NCD_REUSED); + uasync_drain_immediate(ua); + conn->links_up = 0; etcp_cbk_fire(conn, ETCP_CBK_EVENT_DOWN); + a.up = a.down = b.up = b.down = 0; b.nested_down = 1; + conn->links_up = 1; etcp_cbk_fire(conn, ETCP_CBK_EVENT_UP); + CHECK(b.up == 1 && b.down == 1 && a.down == 1 && a.up == 0); + node_conn_direct_force_close(first); node_conn_direct_force_close(second); teardown(); +} + +static void control_length(void) { + setup(); struct ETCP_CONN* conn = connection(1); + struct NODE_CONN_DIRECT* handle = NULL; + CHECK(node_conn_direct_open(inst, 42, NULL, NULL, &handle, NULL) == NCD_REUSED); + node_conn_direct_close(handle); CHECK(conn->fin_wait); + struct ncd_control_msg message = { ETCP_ID_NCD_CONTROL, NCD_SUBCMD_KEEP_ALIVE, 42 }; + struct ll_entry* packet = ll_alloc_lldgram(sizeof(message) + 1); CHECK(packet); + memcpy(packet->dgram, &message, sizeof(message)); packet->dgram[sizeof(message)] = 0; + packet->len = sizeof(message) + 1; + inst->api_bindings.callbacks[ETCP_ID_NCD_CONTROL](conn, packet); + CHECK(conn->fin_wait); + test_clock_run_for(ua, 51000); CHECK(!inst->ncd_registry); teardown(); +} + +int main(int argc, char** argv) { + debug_config_init(); debug_set_level(DEBUG_LEVEL_WARN); debug_set_category_level(DEBUG_CATEGORY_DEBUG, DEBUG_LEVEL_INFO); + if (getenv("UTUN_TEST_DEBUG")) debug_set_category_level(DEBUG_CATEGORY_ETCP, DEBUG_LEVEL_DEBUG); + test_clock_init(1000); + struct { const char* name; void (*run)(void); } cases[] = { + {"callback", callback_failure}, {"up", up_failure}, {"timer", timer_failure}, + {"fin_wait", fin_wait_failure}, {"nested", nested_events}, {"control", control_length} + }; + unsigned selected = 0; + for (unsigned i = 0; i < sizeof(cases) / sizeof(cases[0]); i++) { + if (argc > 1 && strcmp(argv[1], cases[i].name)) continue; + selected++; cases[i].run(); + DEBUG_INFO(DEBUG_CATEGORY_DEBUG, "PASS NCD fault scenario=%s", cases[i].name); + } + CHECK(selected && argc <= 2); test_clock_finish(); return 0; +}