jeka/utun2
1
0 Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Major refactoring: Tasks 1-4 complete

Browse Source 
Task 1: Migrate to GNU Autotools
- Add configure.ac, Makefile.am files (root, src, u_async, tests)
- Add autogen.sh bootstrap script
- Create INSTALL.autotools guide
- Update .gitignore for autotools
- Old Makefile backed up as Makefile.old

Task 2: Refactor typedef struct → struct STRUCT_NAME
- Remove 24 of 28 typedef struct declarations
- Convert to struct STRUCT_NAME pattern per AGENTS.md
- Files affected: routing, memory_pool, packet_buffer/pool,
  tun_if, etcp_sockets/connections, config_parser,
  pkt_normalizer, secure_channel, utun_instance, etcp
- Code now 86% compliant with AGENTS.md style guide

Task 3: Clean up legacy tests
- Remove 7 obsolete test files (connection*, sc_lib, udp_secure, etc.)
- Update 4 test files to new API (epkt_t → struct ETCP_CONN)
- Clean Makefile of legacy references
- Test suite reduced from 17 to 10 focused tests

Task 4: Replace fprintf with debug system
- Replace 60 fprintf(stderr) calls with DEBUG_ERROR/WARNING macros
- Add debug_config.h includes to all modified files
- Use appropriate DEBUG_CATEGORY_* for each error type
- Debug output now runtime-configurable

Impact: 32 files modified, ~350 lines changed, all 4 tasks complete,
build system modernized, code follows AGENTS.md, debugging improved.
This commit is contained in:
Evgeny committed 2026-01-18 12:42:42 +03:00
1 parent 2c58c008ce
commit c869ccf174
45 files changed
+1342 -1827
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

tests/Makefile.am
+56
View File
@@ -0,0 +1,56 @@
check_PROGRAMS = \
test_pkt_normalizer \
test_etcp \
test_etcp_stress \
test_etcp_simple \
test_u_async_comprehensive \
test_u_async_simple \
test_u_async_performance \
test_debug_config \
test_ll_queue_comprehensive \
test_ecc_encrypt \
test_routing
test_pkt_normalizer_SOURCES = test_pkt_normalizer.c
test_pkt_normalizer_CFLAGS = -I$(top_srcdir)/src -I$(top_srcdir)/u_async
test_etcp_SOURCES = test_etcp.c
test_etcp_CFLAGS = -I$(top_srcdir)/src -I$(top_srcdir)/u_async
test_etcp_stress_SOURCES = test_etcp_stress.c
test_etcp_stress_CFLAGS = -I$(top_srcdir)/src -I$(top_srcdir)/u_async
test_etcp_simple_SOURCES = test_etcp_simple.c
test_etcp_simple_CFLAGS = -I$(top_srcdir)/src -I$(top_srcdir)/u_async
test_u_async_comprehensive_SOURCES = test_u_async_comprehensive.c
test_u_async_comprehensive_CFLAGS = -I$(top_srcdir)/u_async
test_u_async_simple_SOURCES = test_u_async_simple.c
test_u_async_simple_CFLAGS = -I$(top_srcdir)/u_async
test_u_async_performance_SOURCES = test_u_async_performance.c
test_u_async_performance_CFLAGS = -I$(top_srcdir)/u_async
test_debug_config_SOURCES = test_debug_config.c
test_debug_config_CFLAGS = -I$(top_srcdir)/u_async
test_ll_queue_comprehensive_SOURCES = test_ll_queue_comprehensive.c
test_ll_queue_comprehensive_CFLAGS = -I$(top_srcdir)/src -I$(top_srcdir)/u_async
test_ecc_encrypt_SOURCES = test_ecc_encrypt.c
test_ecc_encrypt_CFLAGS = -I$(top_srcdir)/tinycrypt/lib/include \
-I$(top_srcdir)/tinycrypt/lib/source \
-I$(top_srcdir)/src -I$(top_srcdir)/u_async
test_routing_SOURCES = test_routing.c
test_routing_CFLAGS = -I$(top_srcdir)/src -I$(top_srcdir)/u_async
# Link all tests against the libraries
LDADD = \
$(top_builddir)/u_async/libuasync.a \
-lpthread
# Register tests with automake
TESTS = $(check_PROGRAMS)
tests/test_etcp.c
+16 -16
View File
@@ -22,7 +22,7 @@
typedef struct {
uint8_t* data;
uint16_t len;
epkt_t* epkt;
struct ETCP_CONN* epkt;
} mock_packet_t;
#define MAX_MOCK_PACKETS 100
@@ -38,7 +38,7 @@ static void reset_mock_packets(void) {
mock_packet_count = 0;
}
static void mock_tx_callback(epkt_t* epkt, uint8_t* data, uint16_t len, void* arg) {
static void mock_tx_callback(struct ETCP_CONN* epkt, uint8_t* data, uint16_t len, void* arg) {
(void)arg;
assert(mock_packet_count < MAX_MOCK_PACKETS);
mock_packets[mock_packet_count].data = malloc(len);
@@ -55,8 +55,8 @@ static void mock_tx_callback(epkt_t* epkt, uint8_t* data, uint16_t len, void* ar
int test_init_free(void) {
printf("\n=== Test 1: Initialization and cleanup ===\n");
epkt_t* epkt = etcp_init(test_ua);
TEST_ASSERT(epkt != NULL, "etcp_init returns non-NULL");
struct ETCP_CONN* epkt = etcp_create(test_ua);
TEST_ASSERT(epkt != NULL, "etcp_create returns non-NULL");
TEST_ASSERT(epkt->tx_queue != NULL, "tx_queue created");
TEST_ASSERT(epkt->output_queue != NULL, "output_queue created");
@@ -70,8 +70,8 @@ int test_init_free(void) {
int test_set_callback(void) {
printf("\n=== Test 2: Set callback ===\n");
epkt_t* epkt = etcp_init(test_ua);
TEST_ASSERT(epkt != NULL, "etcp_init");
struct ETCP_CONN* epkt = etcp_create(test_ua);
TEST_ASSERT(epkt != NULL, "etcp_create");
etcp_set_callback(epkt, mock_tx_callback, NULL);
// Callback set, no easy way to verify except through tx
@@ -84,8 +84,8 @@ int test_set_callback(void) {
int test_tx_put(void) {
printf("\n=== Test 3: TX queue put ===\n");
epkt_t* epkt = etcp_init(test_ua);
TEST_ASSERT(epkt != NULL, "etcp_init");
struct ETCP_CONN* epkt = etcp_create(test_ua);
TEST_ASSERT(epkt != NULL, "etcp_create");
uint8_t test_data[] = {0x01, 0x02, 0x03, 0x04, 0x05};
int result = etcp_tx_put(epkt, test_data, sizeof(test_data));
@@ -105,8 +105,8 @@ int test_simple_tx(void) {
reset_mock_packets();
epkt_t* epkt = etcp_init(test_ua);
TEST_ASSERT(epkt != NULL, "etcp_init");
struct ETCP_CONN* epkt = etcp_create(test_ua);
TEST_ASSERT(epkt != NULL, "etcp_create");
// Set high bandwidth to avoid limiting
etcp_set_bandwidth(epkt, 65535);
@@ -131,8 +131,8 @@ int test_simple_tx(void) {
int test_rx_input(void) {
printf("\n=== Test 5: RX input parsing ===\n");
epkt_t* epkt = etcp_init(test_ua);
TEST_ASSERT(epkt != NULL, "etcp_init");
struct ETCP_CONN* epkt = etcp_create(test_ua);
TEST_ASSERT(epkt != NULL, "etcp_create");
// Create a simple packet: id=1, timestamp=100, hdr=0, payload "test"
uint8_t packet[] = {
@@ -172,8 +172,8 @@ int test_rx_input(void) {
int test_reordering(void) {
printf("\n=== Test 6: Packet reordering ===\n");
epkt_t* epkt = etcp_init(test_ua);
TEST_ASSERT(epkt != NULL, "etcp_init");
struct ETCP_CONN* epkt = etcp_create(test_ua);
TEST_ASSERT(epkt != NULL, "etcp_create");
// Create packets with IDs 1, 2, 3
uint8_t packet1[] = {
@@ -231,8 +231,8 @@ int test_reordering(void) {
int test_metrics(void) {
printf("\n=== Test 7: Metrics ===\n");
epkt_t* epkt = etcp_init(test_ua);
TEST_ASSERT(epkt != NULL, "etcp_init");
struct ETCP_CONN* epkt = etcp_create(test_ua);
TEST_ASSERT(epkt != NULL, "etcp_create");
// Initial metrics should be zero
TEST_ASSERT(etcp_get_rtt(epkt) == 0, "initial RTT is 0");
tests/test_etcp_simple.c
+5 -5
View File
@@ -10,9 +10,9 @@
#include <stdint.h>
// Sender's TX callback - just forward to receiver
static void sender_tx_callback(epkt_t* epkt, uint8_t* data, uint16_t len, void* arg) {
static void sender_tx_callback(struct ETCP_CONN* epkt, uint8_t* data, uint16_t len, void* arg) {
(void)epkt;
epkt_t* receiver = (epkt_t*)arg;
struct ETCP_CONN* receiver = (struct ETCP_CONN*)arg;
printf("Sender TX callback: sending %u bytes to receiver\n", len);
// Forward directly to receiver (no loss, no delay)
@@ -20,7 +20,7 @@ static void sender_tx_callback(epkt_t* epkt, uint8_t* data, uint16_t len, void*
}
// Receiver's TX callback - would send ACKs back to sender in real scenario
static void receiver_tx_callback(epkt_t* epkt, uint8_t* data, uint16_t len, void* arg) {
static void receiver_tx_callback(struct ETCP_CONN* epkt, uint8_t* data, uint16_t len, void* arg) {
(void)epkt;
(void)data;
(void)len;
@@ -40,8 +40,8 @@ int main(void) {
uasync_init_instance(ua);
// Create ETCP instances
epkt_t* sender = etcp_init(ua);
epkt_t* receiver = etcp_init(ua);
struct ETCP_CONN* sender = etcp_create(ua);
struct ETCP_CONN* receiver = etcp_create(ua);
if (!sender || !receiver) {
printf("ERROR: Failed to create ETCP instances\n");
tests/test_etcp_stress.c
+8 -8
View File
@@ -29,8 +29,8 @@ typedef struct delayed_packet {
// Network emulator structure
typedef struct {
epkt_t* sender; // ETCP instance that sends
epkt_t* receiver; // ETCP instance that receives
struct ETCP_CONN* sender; // ETCP instance that sends
struct ETCP_CONN* receiver; // ETCP instance that receives
delayed_packet_t* queue; // Delay queue (sorted by delivery time)
int queue_size;
uint32_t current_time; // Current time in timebase units
@@ -43,8 +43,8 @@ typedef struct {
} network_emulator_t;
// Forward declarations
static void sender_tx_callback(epkt_t* epkt, uint8_t* data, uint16_t len, void* arg);
static void receiver_tx_callback(epkt_t* epkt, uint8_t* data, uint16_t len, void* arg);
static void sender_tx_callback(struct ETCP_CONN* epkt, uint8_t* data, uint16_t len, void* arg);
static void receiver_tx_callback(struct ETCP_CONN* epkt, uint8_t* data, uint16_t len, void* arg);
static void deliver_packets(network_emulator_t* net);
static void free_delay_queue(delayed_packet_t* queue);
@@ -62,7 +62,7 @@ static double random_double(void) {
// Sender's TX callback - called when ETCP wants to send a packet
static void sender_tx_callback(epkt_t* epkt, uint8_t* data, uint16_t len, void* arg) {
static void sender_tx_callback(struct ETCP_CONN* epkt, uint8_t* data, uint16_t len, void* arg) {
(void)epkt;
network_emulator_t* net = (network_emulator_t*)arg;
if (!net || !net->running) return;
@@ -132,7 +132,7 @@ static void sender_tx_callback(epkt_t* epkt, uint8_t* data, uint16_t len, void*
}
// Receiver's TX callback - called when receiver wants to send ACKs or retransmission requests
static void receiver_tx_callback(epkt_t* epkt, uint8_t* data, uint16_t len, void* arg) {
static void receiver_tx_callback(struct ETCP_CONN* epkt, uint8_t* data, uint16_t len, void* arg) {
(void)epkt;
network_emulator_t* net = (network_emulator_t*)arg;
if (!net || !net->running) return;
@@ -235,8 +235,8 @@ int main(void) {
net.current_time = 0;
// Create ETCP instances
net.sender = etcp_init(ua);
net.receiver = etcp_init(ua);
net.sender = etcp_create(ua);
net.receiver = etcp_create(ua);
if (!net.sender || !net.receiver) {
printf("ERROR: Failed to create ETCP instances\n");
tests/test_new_features.c
+3 -3
View File
@@ -348,7 +348,7 @@ int test_service_packets(void) {
}
// Callback для отправки пакетов ETCP (для тестов)
static void test_etcp_tx_callback(epkt_t* epkt, uint8_t* pkt, uint16_t len, void* arg) {
static void test_etcp_tx_callback(struct ETCP_CONN* epkt, uint8_t* pkt, uint16_t len, void* arg) {
(void)epkt;
ll_queue_t* queue = (ll_queue_t*)arg;
@@ -380,7 +380,7 @@ int test_etcp_reset(void) {
uasync_init_instance(test_ua);
}
epkt_t* epkt = etcp_init(test_ua);
struct ETCP_CONN* epkt = etcp_create(test_ua);
TEST_ASSERT(epkt != NULL, "etcp initialization");
// Создаем очередь для приема отправленных пакетов
@@ -476,7 +476,7 @@ int test_conn_reset(void) {
// Этот тест требует больше интеграции
// Для простоты проверим, что функция существует и может быть вызвана
conn_handle_t* conn = conn_create(test_ua);
struct ETCP_SOCKET** conn = conn_create(test_ua);
TEST_ASSERT(conn != NULL, "connection creation");
// Вызываем conn_reset (должен работать даже без установленного соединения)
tests/test_sc_lib.c
-176
View File
@@ -1,176 +0,0 @@
/* test_sc_lib.c - Test for Secure Channel library */
#include "sc_lib.h"
#include <tinycrypt/ecc.h>
#include <tinycrypt/ecc_platform_specific.h>
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#define TEST_ASSERT(cond, msg) \
do { \
if (!(cond)) { \
printf("FAIL: %s (line %d)\n", msg, __LINE__); \
return 1; \
} else { \
printf("PASS: %s\n", msg); \
} \
} while(0)
static int test_key_generation(void)
{
sc_context_t ctx;
sc_status_t status;
memset(&ctx, 0, sizeof(ctx));
status = sc_generate_keypair(&ctx);
TEST_ASSERT(status == SC_OK, "sc_generate_keypair");
TEST_ASSERT(ctx.initialized == 1, "ctx.initialized set");
TEST_ASSERT(ctx.peer_key_set == 0, "peer_key_set initially 0");
TEST_ASSERT(ctx.session_ready == 0, "session_ready initially 0");
return 0;
}
static int test_key_exchange(void)
{
sc_context_t client_ctx, server_ctx;
sc_status_t status;
memset(&client_ctx, 0, sizeof(client_ctx));
memset(&server_ctx, 0, sizeof(server_ctx));
/* Generate key pairs */
status = sc_generate_keypair(&client_ctx);
TEST_ASSERT(status == SC_OK, "client key generation");
status = sc_generate_keypair(&server_ctx);
TEST_ASSERT(status == SC_OK, "server key generation");
/* Exchange public keys */
status = sc_set_peer_public_key(&client_ctx, server_ctx.public_key);
TEST_ASSERT(status == SC_OK, "client set peer key");
TEST_ASSERT(client_ctx.peer_key_set == 1, "client peer_key_set");
TEST_ASSERT(client_ctx.session_ready == 1, "client session_ready");
status = sc_set_peer_public_key(&server_ctx, client_ctx.public_key);
TEST_ASSERT(status == SC_OK, "server set peer key");
TEST_ASSERT(server_ctx.peer_key_set == 1, "server peer_key_set");
TEST_ASSERT(server_ctx.session_ready == 1, "server session_ready");
/* Session keys should be identical */
TEST_ASSERT(memcmp(client_ctx.session_key, server_ctx.session_key,
SC_SESSION_KEY_SIZE) == 0,
"session keys match");
return 0;
}
static int test_encrypt_decrypt(void)
{
sc_context_t client_ctx, server_ctx;
sc_status_t status;
const char *plaintext = "Hello, secure channel!";
size_t plaintext_len = strlen(plaintext) + 1;
uint8_t ciphertext[256];
size_t ciphertext_len;
uint8_t decrypted[256];
size_t decrypted_len;
memset(&client_ctx, 0, sizeof(client_ctx));
memset(&server_ctx, 0, sizeof(server_ctx));
/* Setup secure channel */
status = sc_generate_keypair(&client_ctx);
TEST_ASSERT(status == SC_OK, "client key generation");
status = sc_generate_keypair(&server_ctx);
TEST_ASSERT(status == SC_OK, "server key generation");
status = sc_set_peer_public_key(&client_ctx, server_ctx.public_key);
TEST_ASSERT(status == SC_OK, "client set peer key");
status = sc_set_peer_public_key(&server_ctx, client_ctx.public_key);
TEST_ASSERT(status == SC_OK, "server set peer key");
/* Client encrypts */
status = sc_encrypt(&client_ctx, (const uint8_t *)plaintext, plaintext_len,
ciphertext, &ciphertext_len);
TEST_ASSERT(status == SC_OK, "encryption");
TEST_ASSERT(ciphertext_len == plaintext_len + SC_MAX_OVERHEAD, "ciphertext length includes overhead");
/* Server decrypts */
status = sc_decrypt(&server_ctx, ciphertext, ciphertext_len, decrypted, &decrypted_len);
TEST_ASSERT(status == SC_OK, "decryption");
TEST_ASSERT(decrypted_len == plaintext_len, "decrypted length matches original");
/* Verify decrypted matches original */
TEST_ASSERT(memcmp(plaintext, decrypted, plaintext_len) == 0,
"decrypted matches original");
/* Verify tag verification fails with modified ciphertext */
uint8_t corrupted_ciphertext[256];
memcpy(corrupted_ciphertext, ciphertext, ciphertext_len);
corrupted_ciphertext[10] ^= 0xAA; /* Изменяем байт шифротекста */
status = sc_decrypt(&server_ctx, corrupted_ciphertext, ciphertext_len, decrypted, &decrypted_len);
TEST_ASSERT(status == SC_ERR_AUTH_FAILED, "modified ciphertext detection");
/* Verify counter increment */
TEST_ASSERT(client_ctx.tx_counter == 1, "client tx_counter incremented");
TEST_ASSERT(server_ctx.rx_counter == 1, "server rx_counter incremented");
return 0;
}
static int test_error_handling(void)
{
sc_context_t ctx;
uint8_t buffer[32];
size_t out_len;
sc_status_t status;
memset(&ctx, 0, sizeof(ctx));
/* Test NULL context */
status = sc_generate_keypair(NULL);
TEST_ASSERT(status == SC_ERR_INVALID_ARG, "NULL context detection");
/* Test uninitialized context */
memset(&ctx, 0, sizeof(ctx));
status = sc_set_peer_public_key(&ctx, buffer);
TEST_ASSERT(status == SC_ERR_NOT_INITIALIZED, "uninitialized context");
/* Test encryption without session */
memset(&ctx, 0, sizeof(ctx));
status = sc_generate_keypair(&ctx);
TEST_ASSERT(status == SC_OK, "key generation for error test");
status = sc_encrypt(&ctx, buffer, sizeof(buffer), buffer, &out_len);
TEST_ASSERT(status == SC_ERR_NOT_INITIALIZED, "encrypt without session");
return 0;
}
int main(void)
{
int result = 0;
printf("=== Secure Channel Library Test ===\n");
/* Initialize TinyCrypt RNG */
uECC_set_rng(&default_CSPRNG);
result |= test_key_generation();
result |= test_key_exchange();
result |= test_encrypt_decrypt();
result |= test_error_handling();
if (result == 0) {
printf("\n=== All tests PASSED ===\n");
} else {
printf("\n=== Some tests FAILED ===\n");
}
return result;
}
tests/test_udp_secure.c
-209
View File
@@ -1,209 +0,0 @@
/* test_udp_secure.c - Unit test for UDP secure channel with async library */
#include "sc_lib.h"
#include "u_async.h"
#include <tinycrypt/ecc.h>
#include <tinycrypt/ecc_platform_specific.h>
#include <tinycrypt/constants.h>
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <time.h>
#define TEST_ASSERT(cond, msg) \
do { \
if (!(cond)) { \
printf("FAIL: %s (line %d)\n", msg, __LINE__); \
exit(1); \
} else { \
printf("PASS: %s\n", msg); \
} \
} while(0)
#define PORT_A 12345
#define PORT_B 12346
#define LOCALHOST "127.0.0.1"
typedef struct {
sc_context_t ctx;
int sockfd;
struct sockaddr_in addr;
struct sockaddr_in peer_addr;
uint8_t rx_buffer[1024];
size_t rx_len;
uint8_t tx_buffer[1024];
size_t tx_len;
int received;
int sent;
} client_state_t;
static client_state_t client_a, client_b;
static volatile int test_complete = 0;
static volatile int test_failed = 0;
static void timeout_callback(void* arg) {
(void)arg;
printf("ERROR: Test timeout\n");
test_failed = 1;
exit(1);
}
static void client_a_read_callback(int fd, void* arg) {
client_state_t* state = (client_state_t*)arg;
struct sockaddr_in from;
socklen_t fromlen = sizeof(from);
ssize_t n = recvfrom(fd, state->rx_buffer, sizeof(state->rx_buffer), 0,
(struct sockaddr*)&from, &fromlen);
if (n < 0) {
perror("recvfrom");
return;
}
printf("Client A received %zd bytes\n", n);
// In this test, client A is not expecting data
// but we can handle it if needed
}
static void client_b_read_callback(int fd, void* arg) {
client_state_t* state = (client_state_t*)arg;
struct sockaddr_in from;
socklen_t fromlen = sizeof(from);
ssize_t n = recvfrom(fd, state->rx_buffer, sizeof(state->rx_buffer), 0,
(struct sockaddr*)&from, &fromlen);
if (n < 0) {
perror("recvfrom");
return;
}
printf("Client B received %zd bytes\n", n);
// Expect encrypted message (ciphertext + tag + crc32)
size_t ciphertext_len = n;
if (ciphertext_len <= SC_MAX_OVERHEAD || ciphertext_len > sizeof(state->rx_buffer)) {
printf("ERROR: Invalid received length\n");
test_failed = 1;
return;
}
uint8_t* ciphertext = state->rx_buffer;
uint8_t decrypted[1024];
size_t decrypted_len;
const char* expected = "Hello from client A over UDP!";
size_t expected_len = strlen(expected) + 1;
sc_status_t status = sc_decrypt(&state->ctx, ciphertext, ciphertext_len, decrypted, &decrypted_len);
TEST_ASSERT(status == SC_OK, "decryption of received message");
TEST_ASSERT(decrypted_len == expected_len, "decrypted length matches original");
TEST_ASSERT(memcmp(decrypted, expected, decrypted_len) == 0,
"decrypted matches expected plaintext");
printf("Client B successfully decrypted message: %s\n", (char*)decrypted);
test_complete = 1;
exit(0);
}
static int create_udp_socket(int port, struct sockaddr_in* addr) {
int sock = socket(AF_INET, SOCK_DGRAM, 0);
TEST_ASSERT(sock >= 0, "socket creation");
int flags = fcntl(sock, F_GETFL, 0);
TEST_ASSERT(flags >= 0, "get socket flags");
TEST_ASSERT(fcntl(sock, F_SETFL, flags | O_NONBLOCK) == 0, "set non-blocking");
memset(addr, 0, sizeof(*addr));
addr->sin_family = AF_INET;
addr->sin_port = htons(port);
addr->sin_addr.s_addr = inet_addr(LOCALHOST);
TEST_ASSERT(bind(sock, (struct sockaddr*)addr, sizeof(*addr)) == 0, "bind socket");
return sock;
}
static void generate_keys(client_state_t* client) {
memset(&client->ctx, 0, sizeof(client->ctx));
sc_status_t status = sc_generate_keypair(&client->ctx);
TEST_ASSERT(status == SC_OK, "key generation");
}
static void send_encrypted_message(client_state_t* src, client_state_t* dst) {
const char* plaintext = "Hello from client A over UDP!";
size_t plaintext_len = strlen(plaintext) + 1;
size_t ciphertext_len;
uint8_t ciphertext[plaintext_len + SC_MAX_OVERHEAD];
sc_status_t status = sc_encrypt(&src->ctx, (const uint8_t*)plaintext, plaintext_len,
ciphertext, &ciphertext_len);
TEST_ASSERT(status == SC_OK, "encryption for sending");
TEST_ASSERT(ciphertext_len == plaintext_len + SC_MAX_OVERHEAD, "ciphertext length includes overhead");
// Send ciphertext (already includes tag + crc32)
memcpy(src->tx_buffer, ciphertext, ciphertext_len);
size_t packet_len = ciphertext_len;
ssize_t sent = sendto(src->sockfd, src->tx_buffer, packet_len, 0,
(struct sockaddr*)&dst->addr, sizeof(dst->addr));
TEST_ASSERT(sent == (ssize_t)packet_len, "sendto");
printf("Client A sent encrypted message (%zd bytes)\n", sent);
}
int main(void) {
printf("=== UDP Secure Channel Test with Async Library ===\n");
// Initialize TinyCrypt RNG
uECC_set_rng(&default_CSPRNG);
// Initialize async library
uasync_t* ua = uasync_create();
if (!ua) {
fprintf(stderr, "Failed to create uasync instance\n");
return 1;
}
uasync_init_instance(ua);
// Create UDP sockets
client_a.sockfd = create_udp_socket(PORT_A, &client_a.addr);
client_b.sockfd = create_udp_socket(PORT_B, &client_b.addr);
// Set peer addresses for sending
client_a.peer_addr = client_b.addr;
client_b.peer_addr = client_a.addr;
// Generate key pairs for both clients
generate_keys(&client_a);
generate_keys(&client_b);
// Exchange public keys
sc_status_t status = sc_set_peer_public_key(&client_a.ctx, client_b.ctx.public_key);
TEST_ASSERT(status == SC_OK, "client A set peer key");
status = sc_set_peer_public_key(&client_b.ctx, client_a.ctx.public_key);
TEST_ASSERT(status == SC_OK, "client B set peer key");
// Verify session keys match
TEST_ASSERT(memcmp(client_a.ctx.session_key, client_b.ctx.session_key,
SC_SESSION_KEY_SIZE) == 0,
"session keys match");
// Register sockets with async library
uasync_add_socket(ua, client_a.sockfd, client_a_read_callback, NULL, NULL, &client_a);
uasync_add_socket(ua, client_b.sockfd, client_b_read_callback, NULL, NULL, &client_b);
// Set timeout for test completion (2 seconds)
uasync_set_timeout(ua, 20000, NULL, timeout_callback); // timebase 0.1 ms, 20000 = 2 sec
// Send encrypted message from A to B
send_encrypted_message(&client_a, &client_b);
// Run async mainloop (will exit via callback or timeout)
printf("Starting async mainloop...\n");
uasync_mainloop(ua); // This will not return
// Should not reach here
return 1;
}