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

Add two-instance test with handshake monitoring and debug output 

- test_etcp_two_instances_fixed.c: two UTUN instances in single process
- Creates server and client configs in /tmp
- Uses uasync polling for both instances
- Periodic monitoring via settimeout
- Exits after handshake success/failure
- Debug output in SEND/RECV functions
v2_dev
Evgeny 8 months ago
parent
11501faeb8
commit
e666c6ac1a
3 changed files with 286 additions and 0 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 178
      tests/test_etcp_two_instances.c
  2. 108
      tests/test_etcp_two_instances_fixed.c
  3. BIN
      tests/test_fixed

178
tests/test_etcp_two_instances.c
Unescape View File

@ -0,0 +1,178 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <time.h>
#include "../src/etcp.h"
#include "../src/etcp_connections.h"
#include "../src/config_parser.h"
#include "../src/utun_instance.h"
#include "../src/routing.h"
#include "../src/tun_if.h"
#include "../src/secure_channel.h"
#include "../lib/u_async.h"
#define TEST_TIMEOUT_MS 5000
static struct UTUN_INSTANCE* server_instance = NULL;
static struct UTUN_INSTANCE* client_instance = NULL;
static int test_completed = 0;
// For debug: enable in etcp_connections.c
extern void etcp_connections_read_callback(int fd, void* arg);
extern int etcp_encrypt_send(struct ETCP_DGRAM* dgram);
static void monitor_connections(void* arg) {
(void)arg;
if (test_completed) return;
int server_links = 0;
int client_links = 0;
int client_initialized = 0;
// Check server
if (server_instance) {
struct ETCP_CONN* conn = server_instance->connections;
while (conn) {
struct ETCP_LINK* link = conn->links;
while (link) {
server_links++;
printf("[SERVER] Link: peer=%llx initialized=%d type=%s\n",
(unsigned long long)conn->peer_node_id,
link->initialized,
link->is_server ? "server" : "client");
link = link->next;
}
conn = conn->next;
}
}
// Check client
if (client_instance) {
struct ETCP_CONN* conn = client_instance->connections;
while (conn) {
struct ETCP_LINK* link = conn->links;
while (link) {
client_links++;
if (link->is_server == 0) { // client link
printf("[CLIENT] Link: peer=%llx initialized=%d timer=%s retry=%d\n",
(unsigned long long)conn->peer_node_id,
link->initialized,
link->init_timer ? "active" : "null",
link->init_retry_count);
if (link->initialized) {
client_initialized = 1;
}
}
link = link->next;
}
conn = conn->next;
}
}
// Check if connection established
if (client_initialized) {
printf("\n=== SUCCESS: Client connection established! ===\n");
test_completed = 1;
return;
}
printf("[MONITOR] Server links: %d, Client links: %d, Status: %s\n",
server_links, client_links,
client_initialized ? "CONNECTED" : "connecting...");
// Schedule next check
if (!test_completed) {
uasync_set_timeout(NULL, 1000, NULL, monitor_connections); // Check every 1s
}
}
static void test_timeout(void* arg) {
(void)arg;
if (!test_completed) {
printf("\n=== TIMEOUT: Connection not established in %d seconds ===\n", TEST_TIMEOUT_MS/1000);
test_completed = 1;
}
}
int main() {
printf("=== ETCP Two-Instance Connection Test ===\n\n");
// Create server instance
printf("Creating server instance...\n");
struct UASYNC* server_ua = uasync_create();
server_instance = utun_instance_create(server_ua, "test_server.conf", NULL);
if (!server_instance) {
printf("Failed to create server instance\n");
return 1;
}
if (utun_instance_init(server_instance) < 0 ||
utun_instance_register_sockets(server_instance) < 0 ||
init_connections(server_instance) < 0) {
printf("Failed to initialize server instance\n");
utun_instance_destroy(server_instance);
return 1;
}
printf("Server instance ready (node_id=%llx)\n\n", (unsigned long long)server_instance->node_id);
// Create client instance
printf("Creating client instance...\n");
struct UASYNC* client_ua = uasync_create();
client_instance = utun_instance_create(client_ua, "test_client.conf", NULL);
if (!client_instance) {
printf("Failed to create client instance\n");
utun_instance_destroy(server_instance);
return 1;
}
if (utun_instance_init(client_instance) < 0 ||
utun_instance_register_sockets(client_instance) < 0 ||
init_connections(client_instance) < 0) {
printf("Failed to initialize client instance\n");
utun_instance_destroy(server_instance);
utun_instance_destroy(client_instance);
return 1;
}
printf("Client instance ready (node_id=%llx)\n\n", (unsigned long long)client_instance->node_id);
// Start monitoring
printf("Starting connection monitoring...\n");
uasync_set_timeout(server_ua, 1000, NULL, monitor_connections);
uasync_set_timeout(server_ua, TEST_TIMEOUT_MS, NULL, test_timeout);
// Main event loop
printf("Running event loop...\n\n");
int elapsed = 0;
while (!test_completed && elapsed < TEST_TIMEOUT_MS + 1000) {
if (server_ua) uasync_poll(server_ua, 10);
if (client_ua) uasync_poll(client_ua, 10);
usleep(10000); // 10ms
elapsed += 10;
}
// Cleanup
printf("\nCleaning up...\n");
if (server_instance) {
server_instance->running = 0;
utun_instance_destroy(server_instance);
}
if (client_instance) {
client_instance->running = 0;
utun_instance_destroy(client_instance);
}
unlink("test_server.conf");
unlink("test_client.conf");
if (test_completed == 1) {
printf("\n=== TEST PASSED ===\n");
return 0;
} else {
printf("\n=== TEST FAILED ===\n");
return 1;
}
}

108
tests/test_etcp_two_instances_fixed.c
Unescape View File

@ -0,0 +1,108 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <time.h>
#include "../src/etcp.h"
#include "../src/etcp_connections.h"
#include "../src/config_parser.h"
#include "../src/utun_instance.h"
#include "../src/routing.h"
#include "../src/tun_if.h"
#include "../src/secure_channel.h"
#include "../lib/u_async.h"
#define TEST_TIMEOUT_MS 5000
static struct UTUN_INSTANCE* server_instance = NULL;
static struct UTUN_INSTANCE* client_instance = NULL;
static int test_completed = 0;
static void monitor_connections(void* arg) {
(void)arg;
if (test_completed) return;
int client_initialized = 0;
// Check client
if (client_instance) {
struct ETCP_CONN* conn = client_instance->connections;
while (conn) {
struct ETCP_LINK* link = conn->links;
while (link) {
if (link->is_server == 0) { // client link
printf("[CLIENT] Link: peer=%llx init=%d retry=%d\n",
(unsigned long long)conn->peer_node_id,
link->initialized,
link->init_retry_count);
if (link->initialized) {
client_initialized = 1;
}
}
link = link->next;
}
conn = conn->next;
}
}
if (client_initialized) {
printf("=== SUCCESS ===\n");
test_completed = 1;
return;
}
if (!test_completed) {
uasync_set_timeout(NULL, 1000, NULL, monitor_connections);
}
}
int main() {
printf("=== ETCP Two-Instance Test ===\n");
// Create server config
FILE* f = fopen("/tmp/s.conf", "w");
fprintf(f, "[global]\nmy_node_id=0x1111111111111111\nmy_private_key=1313912e5d34768983b0e06530a48c77816d228a5b5605e1ab3dc443d107a3dc\nmy_public_key=dde6cec8a9023339a758f60883ef41534d24a1ffdc09bbb787a5c24ddfd891e3092461835a97d37944c681fc6b2c1f5acde8ad192f7d2cdc9920aa0d3ff78e99\ntun_ip=10.99.0.1/24\ntun_ifname=tun99\n\n[server:test]\naddr=127.0.0.1:9001\ntype=public\n");
fclose(f);
// Create client config
f = fopen("/tmp/c.conf", "w");
fprintf(f, "[global]\nmy_node_id=0x2222222222222222\nmy_private_key=1313912e5d34768983b0e06530a48c77816d228a5b5605e1ab3dc443d107a3dc\nmy_public_key=dde6cec8a9023339a758f60883ef41534d24a1ffdc09bbb787a5c24ddfd891e3092461835a97d37944c681fc6b2c1f5acde8ad192f7d2cdc9920aa0d3ff78e99\ntun_ip=10.99.0.2/24\ntun_ifname=tun98\n\n[server:local]\naddr=0.0.0.0:0\ntype=nat\n\n[client:test]\npeer_node_id=0x1111111111111111\nkeepalive=1\nlink=local:127.0.0.1:9001\n");
fclose(f);
struct UASYNC* sua = uasync_create();
struct UASYNC* cua = uasync_create();
server_instance = utun_instance_create(sua, "/tmp/s.conf", NULL);
utun_instance_init(server_instance);
utun_instance_register_sockets(server_instance);
init_connections(server_instance);
client_instance = utun_instance_create(cua, "/tmp/c.conf", NULL);
utun_instance_init(client_instance);
utun_instance_register_sockets(client_instance);
init_connections(client_instance);
printf("✓ Both instances initialized\n");
uasync_set_timeout(sua, 1000, NULL, monitor_connections);
int elapsed = 0;
while (!test_completed && elapsed < TEST_TIMEOUT_MS) {
uasync_poll(sua, 10);
uasync_poll(cua, 10);
usleep(10000);
elapsed += 10;
}
utun_instance_destroy(server_instance);
utun_instance_destroy(client_instance);
unlink("/tmp/s.conf");
unlink("/tmp/c.conf");
return test_completed ? 0 : 1;
}

BIN
tests/test_fixed
View File

Binary file not shown.
Write Preview
Loading…
Cancel
Save