You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
189 lines
10 KiB
189 lines
10 KiB
#include <assert.h> |
|
#include <string.h> |
|
#include <openssl/evp.h> |
|
#include "utun_instance.h" |
|
#include "routing_layer/topo_group.h" |
|
#include "transport_layer/etcp.h" |
|
#include "transport_layer/etcp_api.h" |
|
#include "transport_layer/node_conn_direct.h" |
|
#include "../lib/u_async.h" |
|
#include "../lib/debug_config.h" |
|
|
|
static struct TOPO_GROUP_CONN_ITEM* peer(struct TOPO_GROUP* group) { |
|
assert(group->senders_list->head && !group->senders_list->head->next); |
|
return (struct TOPO_GROUP_CONN_ITEM*)group->senders_list->head->data; |
|
} |
|
|
|
/* Deterministic transport consumer: consume one packet, then let the next producer run. */ |
|
static void drain(struct ETCP_CONN* conn) { |
|
for (int i = 0; i < 128; i++) { |
|
uasync_poll(conn->instance->ua, 0); |
|
assert(queue_entry_count(conn->send_input_q) <= 1); |
|
struct ll_entry* e = queue_data_get(conn->send_input_q); |
|
if (e) { queue_dgram_free(e); queue_entry_free(e); } |
|
queue_resume_callback(conn->send_input_q); |
|
} |
|
} |
|
|
|
static void packet(struct ETCP_CONN* conn, const void* data, size_t size) { |
|
struct ll_entry* e = ll_alloc_lldgram(size); assert(e); |
|
memcpy(e->dgram, data, size); e->len = size; |
|
conn->instance->api_bindings.callbacks[ETCP_ID_TOPO_ENTRY](conn, e); |
|
} |
|
|
|
static void nodeinfo(struct TOPO_GROUP* group, struct ETCP_CONN* conn, struct TOPO_NODE* node, |
|
struct SC_MYKEYS* keys, uint64_t generation, uint64_t timestamp) { |
|
node->timestamp = timestamp; |
|
EVP_PKEY* key = EVP_PKEY_new_raw_private_key(EVP_PKEY_ED25519, NULL, keys->private_key, 32); |
|
size_t key_len = 32; |
|
assert(key && EVP_PKEY_get_raw_public_key(key, node->ed25519_public_key, &key_len) == 1); |
|
EVP_PKEY_free(key); |
|
uint8_t signed_data[TOPO_SIG_MSG_MAX_SIZE]; |
|
int length = topo_node_build_sig_msg(node, signed_data, sizeof(signed_data)); assert(length > 0); |
|
assert(sc_ed25519_sign(keys->private_key, signed_data, length, node->x25519_self_sig) == SC_OK); |
|
struct TOPOMSG_HEADER h = { .cmd = ETCP_ID_TOPO_ENTRY, .subcmd = TOPO_SUBCMD_NODEINFO, |
|
.group_id = group->group_id, .src_epoch = group->group_id + 1000, .dst_epoch = generation }; |
|
uint8_t wire[TOPO_NODE_WIRE_MAX_SIZE + sizeof(struct TOPOMSG_NODEINFO_PKT)]; |
|
memcpy(wire, &h, sizeof(h)); |
|
struct TOPO_GROUP_NODE nq = {0}; |
|
length = topo_node_serialize(node, &nq, group->group_id, TOPO_FLAG_SEND_SUBNETS, |
|
wire + sizeof(h), sizeof(wire) - sizeof(h), 0); assert(length > 0); |
|
packet(conn, wire, sizeof(h) + length); |
|
} |
|
|
|
static void receive(struct ETCP_CONN* conn, uint64_t group_id, uint8_t cmd, uint64_t local_epoch, size_t length) { |
|
struct TOPOMSG_JOIN_GROUP msg = { .h = { .cmd = ETCP_ID_TOPO_ENTRY, .subcmd = cmd, .group_id = group_id, |
|
.src_epoch = group_id + 1000, .dst_epoch = local_epoch }, .group_type = TOPO_GROUP_TYPE_UTUN }; |
|
assert(length <= sizeof(msg)); |
|
struct ll_entry* packet = ll_alloc_lldgram(sizeof(msg)); assert(packet); |
|
memcpy(packet->dgram, &msg, sizeof(msg)); packet->len = length; |
|
conn->instance->api_bindings.callbacks[ETCP_ID_TOPO_ENTRY](conn, packet); |
|
} |
|
|
|
static void accept_join(struct TOPO_GROUP* group, struct ETCP_CONN* conn) { |
|
receive(conn, group->group_id, TOPO_SUBCMD_JOIN_GROUP, 0, sizeof(struct TOPOMSG_JOIN_GROUP)); |
|
receive(conn, group->group_id, TOPO_SUBCMD_JOIN_ACCEPT, peer(group)->local_epoch, sizeof(struct TOPOMSG_JOIN_GROUP)); |
|
assert(peer(group)->accepted); |
|
} |
|
|
|
static void complete(struct TOPO_GROUP* group, struct ETCP_CONN* conn, uint64_t local_epoch) { |
|
receive(conn, group->group_id, TOPO_SUBCMD_TABLE_COMPLETE, local_epoch, sizeof(struct TOPOMSG_HEADER)); |
|
} |
|
|
|
static void request(struct TOPO_GROUP* group, struct ETCP_CONN* conn) { |
|
receive(conn, group->group_id, TOPO_SUBCMD_REQUEST_TABLE, peer(group)->local_epoch, sizeof(struct TOPOMSG_HEADER)); |
|
drain(conn); |
|
} |
|
|
|
int main(void) { |
|
debug_config_init(); debug_set_level(DEBUG_LEVEL_INFO); |
|
utun_instance_set_tun_init_enabled(0); |
|
struct UASYNC* ua = uasync_create(); assert(ua); |
|
struct UTUN_INSTANCE* inst = utun_instance_create_from_str(ua, |
|
"[global]\n" |
|
"my_private_key=704f2e012c8fa8768130cb0f988a997dccb628372bc5ceccacc78dcbfec5916f\n" |
|
"my_public_key=b3193173def895bd0fcea6f86af077c7d77216f10395275f627ac18242ec0f01\n" |
|
"[server: udp]\naddr=127.0.0.1:0\ntype=public\n"); |
|
assert(inst && utun_instance_init(inst) == 0); |
|
struct TOPO_GROUP* a = topo_groups_create_group(inst->topo_groups, 42, TOPO_GROUP_TYPE_UTUN, NULL); |
|
struct TOPO_GROUP* b = topo_groups_create_group(inst->topo_groups, 43, TOPO_GROUP_TYPE_UTUN, NULL); |
|
assert(a && b); |
|
struct SC_MYKEYS keys; assert(sc_generate_keypair(&keys) == SC_OK); |
|
struct TOPO_ADDR4 addr = { .addr = {127, 0, 0, 1}, .port = 9, .protocol = TOPO_PROTO_UDP }; |
|
struct TOPO_NODE node = { .v4_addrs = &addr }; |
|
memcpy(node.public_key, keys.public_key, SC_PUBKEY_SIZE); |
|
node.node_id = sc_derive_node_id_from_pubkey(node.public_key); |
|
struct NODE_CONN_DIRECT* owner = NULL; |
|
assert(node_conn_direct_open_node(inst, node.node_id, NULL, NULL, &owner, &node, NULL) == NCD_NEW); |
|
struct ETCP_CONN* conn = node_conn_direct_get_conn(owner); assert(conn); |
|
/* Детерминированная доставка управляющих пакетов через штатный BGP receiver. |
|
* Event loop не запускаем: транспортный handshake проверяют интеграционные тесты. */ |
|
queue_set_callback(conn->send_input_q, NULL, NULL); |
|
conn->links_up = 1; |
|
assert(topo_group_new_conn(a, conn) == 0 && topo_group_new_conn(b, conn) == 0); |
|
uint64_t a_id = peer(a)->local_epoch, b_id = peer(b)->local_epoch; |
|
assert(a_id && b_id && a_id != b_id); |
|
assert(!topo_group_peer_ready(a, node.node_id) && !topo_group_peer_ready(b, node.node_id)); |
|
complete(a, conn, a_id); |
|
assert(!peer(a)->table_received); /* no topology before ACCEPT */ |
|
accept_join(a, conn); accept_join(b, conn); |
|
complete(a, conn, b_id); |
|
receive(conn, a->group_id, TOPO_SUBCMD_TABLE_COMPLETE, a_id, 2); |
|
assert(!peer(a)->table_received); |
|
complete(a, conn, a_id); |
|
assert(peer(a)->table_received && !topo_group_peer_ready(a, node.node_id)); |
|
request(a, conn); |
|
assert(topo_group_peer_ready(a, node.node_id) && !topo_group_peer_ready(b, node.node_id)); |
|
assert(topo_group_new_conn(a, conn) == 0 && peer(a)->local_epoch == a_id); |
|
receive(conn, a->group_id, TOPO_SUBCMD_JOIN_GROUP, 0, sizeof(struct TOPOMSG_JOIN_GROUP)); |
|
assert(peer(a)->local_epoch == a_id); |
|
assert(queue_entry_count(a->senders_list) == 1 && topo_group_peer_ready(a, node.node_id)); |
|
/* Другой порядок доставки: сначала наш снимок, потом подтверждение чужого. */ |
|
request(b, conn); |
|
assert(!topo_group_peer_ready(b, node.node_id)); |
|
complete(b, conn, b_id); |
|
assert(topo_group_peer_ready(b, node.node_id)); |
|
|
|
nodeinfo(a, conn, &node, &keys, a_id, 1); |
|
assert(topo_node_find_by_id(a, node.node_id)->last_timestamp == 1); |
|
etcp_fire_conn_status(conn, ETCP_CONN_STATUS_REINIT); |
|
assert(topo_group_find_conn_for_node(a, node.node_id) == conn); /* REINIT preserves known paths */ |
|
assert(peer(a)->local_epoch != a_id && peer(b)->local_epoch != b_id); |
|
assert(!topo_group_peer_ready(a, node.node_id) && !topo_group_peer_ready(b, node.node_id)); |
|
complete(a, conn, a_id); complete(b, conn, b_id); |
|
assert(!peer(a)->table_received && !peer(b)->table_received); |
|
accept_join(a, conn); |
|
/* Ошибка отправки снимка не разрешает TABLE_COMPLETE и READY. */ |
|
int saved_limit = conn->send_input_q->size_limit; |
|
conn->send_input_q->size_limit = 0; |
|
request(a, conn); |
|
assert(!peer(a)->table_sent); |
|
assert(peer(a)->tx_failed); |
|
conn->send_input_q->size_limit = saved_limit; |
|
etcp_fire_conn_status(conn, ETCP_CONN_STATUS_REINIT); |
|
accept_join(a, conn); |
|
complete(a, conn, peer(a)->local_epoch); request(a, conn); |
|
assert(topo_group_peer_ready(a, node.node_id)); |
|
|
|
nodeinfo(a, conn, &node, &keys, a_id, 2); |
|
assert(topo_node_find_by_id(a, node.node_id)->last_timestamp == 1); |
|
nodeinfo(a, conn, &node, &keys, peer(a)->local_epoch, 2); |
|
assert(topo_node_find_by_id(a, node.node_id)->last_timestamp == 2); |
|
struct TOPOMSG_WITHDRAW_PKT wd = { .h = { .cmd = ETCP_ID_TOPO_ENTRY, .subcmd = TOPO_SUBCMD_WITHDRAW, |
|
.group_id = a->group_id, .src_epoch = a->group_id + 1000, .dst_epoch = a_id }, |
|
.node_id = node.node_id, .wd_source = node.node_id }; |
|
packet(conn, &wd, sizeof(wd)); |
|
assert(topo_node_find_by_id(a, node.node_id)); |
|
wd.h.dst_epoch = peer(a)->local_epoch; packet(conn, &wd, sizeof(wd)); |
|
assert(!topo_node_find_by_id(a, node.node_id)); |
|
a_id = peer(a)->local_epoch; |
|
topo_group_remove_conn(a, conn, TOPO_REMOVE_LOCAL_LEAVE); |
|
complete(a, conn, a_id); |
|
assert(!topo_group_peer_ready(a, node.node_id)); |
|
assert(topo_group_new_conn(a, conn) == 0 && peer(a)->local_epoch != a_id); |
|
receive(conn, a->group_id, TOPO_SUBCMD_JOIN_ACCEPT, a_id, sizeof(struct TOPOMSG_JOIN_GROUP)); |
|
assert(!peer(a)->accepted); |
|
accept_join(a, conn); |
|
receive(conn, a->group_id, TOPO_SUBCMD_LEAVE_GROUP, a_id, sizeof(struct TOPOMSG_HEADER)); |
|
assert(peer(a)->accepted); /* old LEAVE cannot detach the new session */ |
|
complete(a, conn, a_id); request(a, conn); |
|
assert(!topo_group_peer_ready(a, node.node_id)); |
|
complete(a, conn, peer(a)->local_epoch); |
|
assert(topo_group_peer_ready(a, node.node_id) && !topo_group_peer_ready(b, node.node_id)); |
|
receive(conn, b->group_id, TOPO_SUBCMD_JOIN_REJECT, b_id, sizeof(struct TOPOMSG_JOIN_GROUP)); |
|
assert(b->senders_list->head); |
|
receive(conn, b->group_id, TOPO_SUBCMD_JOIN_REJECT, peer(b)->local_epoch, sizeof(struct TOPOMSG_JOIN_GROUP)); |
|
assert(!b->senders_list->head && !conn->close_requested); |
|
/* Cancellation while only JOIN has been received must not leave a half-open peer. */ |
|
receive(conn, b->group_id, TOPO_SUBCMD_JOIN_GROUP, 0, sizeof(struct TOPOMSG_JOIN_GROUP)); |
|
assert(peer(b)->peer_epoch && !peer(b)->accepted); |
|
receive(conn, b->group_id, TOPO_SUBCMD_LEAVE_GROUP, 0, sizeof(struct TOPOMSG_HEADER)); |
|
assert(!b->senders_list->head); |
|
conn->links_up = 0; |
|
assert(!topo_group_peer_ready(a, node.node_id)); |
|
node_conn_direct_close(owner); |
|
inst->running = 0; utun_instance_destroy(inst); |
|
uasync_poll(ua, 0); uasync_destroy(ua, 0); |
|
DEBUG_INFO(DEBUG_CATEGORY_BGP, "group exchange: isolation, duplicate attach, stale replies, send failure and REINIT passed"); |
|
return 0; |
|
}
|
|
|