utun2/tests/test_ncd_faults.c

/* Реальные ядро/ETCP/таймеры: атомарный запуск NCD, отказы ресурсов и повторные события из callback. */
#include <stdlib.h>
#include <string.h>
#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;
}