- Remove ETCP_CONN.next linked-list, UTUN_INSTANCE.connections list/count
- Unified connections in single ll_queue indexed by peer_node_id (0=pending)
- struct conn_queue_entry { peer_node_id, conn* } for uniform queue data
- Connection lifecycle via etcp.c: create→pending, conn_ready→indexed, close→detach+deferred free
- Close split: phase1 detach from external world, phase2 deferred via uasync_call_soon
- etcp_conn_set_peer_node_id: reindex on ID change (WARN)
- etcp_conn_ref_take/free: blocking close until refcount returns to 0
- Remove chat_connections — use unified connections queue directly
- Update all iteration/search patterns across 40 files (src + tests + chatgui)
892 lines
36 KiB
C
892 lines
36 KiB
C
// utun_instance.c - Root instance implementation
|
|
#include "utun_instance.h"
|
|
#include "etcp_router.h"
|
|
#include "config_parser.h"
|
|
#include "config_updater.h"
|
|
#include "tun_if.h"
|
|
#include "tun_route.h"
|
|
#include "topo_node.h"
|
|
#include "route_lib.h"
|
|
#include "routing.h"
|
|
#include "topo_group.h"
|
|
#include "etcp_connections.h"
|
|
#include "etcp.h"
|
|
#include "conn_mgr.h"
|
|
#include "db_sync.h"
|
|
#include "stcp_server.h"
|
|
#include "control_server.h"
|
|
#include "msg_transport.h"
|
|
#include "../lib/u_async.h"
|
|
#include "../lib/debug_config.h"
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#ifndef _WIN32
|
|
#include <unistd.h>
|
|
#endif
|
|
#include <unistd.h>
|
|
#include <sys/stat.h>
|
|
#include "../lib/platform_compat.h"
|
|
#include "../lib/mem.h"
|
|
#include "../lib/ll_queue.h"
|
|
#include <openssl/sha.h>
|
|
|
|
|
|
|
|
// Forward declarations
|
|
static uint32_t get_dest_ip(const uint8_t *packet, size_t len);
|
|
|
|
// Global instance for signal handlers
|
|
static struct UTUN_INSTANCE *g_instance = NULL;
|
|
|
|
// Global flag to control TUN initialization (disabled by default)
|
|
static int g_tun_init_enabled = 0;
|
|
|
|
// Function to control TUN initialization
|
|
void utun_instance_set_tun_init_enabled(int enabled) {
|
|
g_tun_init_enabled = enabled ? 1 : 0;
|
|
DEBUG_INFO(DEBUG_CATEGORY_TUN, "TUN initialization %s", enabled ? "enabled" : "disabled");
|
|
}
|
|
|
|
static int local_sockaddr_equal(const struct sockaddr_storage *a, const struct sockaddr_storage *b) {
|
|
if (!a || !b || a->ss_family != b->ss_family) return 0;
|
|
if (a->ss_family == AF_INET) {
|
|
const struct sockaddr_in *ia = (const struct sockaddr_in *)a;
|
|
const struct sockaddr_in *ib = (const struct sockaddr_in *)b;
|
|
return ia->sin_addr.s_addr == ib->sin_addr.s_addr && ia->sin_port == ib->sin_port;
|
|
}
|
|
if (a->ss_family == AF_INET6) {
|
|
const struct sockaddr_in6 *ia = (const struct sockaddr_in6 *)a;
|
|
const struct sockaddr_in6 *ib = (const struct sockaddr_in6 *)b;
|
|
return memcmp(&ia->sin6_addr, &ib->sin6_addr, 16) == 0 && ia->sin6_port == ib->sin6_port;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// Common initialization function (called by both create functions)
|
|
// Returns 0 on success, -1 on error (instance is NOT freed on error - caller must handle)
|
|
static int instance_init_common(struct UTUN_INSTANCE* instance, struct UASYNC* ua, struct utun_config* config) {
|
|
// Initialize basic fields
|
|
instance->running = 0;
|
|
instance->ua = ua;
|
|
instance->config = config;
|
|
|
|
// Set name from config
|
|
if (config->global.name[0] != '\0') {
|
|
strncpy(instance->name, config->global.name, sizeof(instance->name) - 1);
|
|
instance->name[sizeof(instance->name) - 1] = '\0';
|
|
} else {
|
|
instance->name[0] = '\0';
|
|
}
|
|
|
|
// Set node_id from config
|
|
instance->node_id = config->global.my_node_id;
|
|
|
|
// Set my keys
|
|
if (sc_init_local_keys(&instance->my_keys, config->global.my_public_key_hex, config->global.my_private_key_hex) != SC_OK) {
|
|
DEBUG_ERROR(DEBUG_CATEGORY_MEMORY, "Failed to initialize local keys");
|
|
return -1;
|
|
}
|
|
|
|
if (sc_derive_ed25519_pubkey(instance->my_keys.private_key, instance->my_ed25519_pubkey) != SC_OK) {
|
|
DEBUG_ERROR(DEBUG_CATEGORY_CRYPTO, "Failed to derive Ed25519 pubkey");
|
|
return -1;
|
|
}
|
|
{
|
|
uint8_t ed_priv_hash[SHA512_DIGEST_LENGTH];
|
|
SHA512(instance->my_keys.private_key, SC_PRIVKEY_SIZE, ed_priv_hash);
|
|
memcpy(instance->my_ed25519_privkey, ed_priv_hash, SC_PRIVKEY_SIZE);
|
|
}
|
|
DEBUG_INFO(DEBUG_CATEGORY_CRYPTO, "Ed25519 pubkey derived successfully");
|
|
|
|
// Initialize networks queue (indexed by 56-bit network id)
|
|
instance->networks = queue_new(ua, 16, offsetof(struct NETWORK_ENTRY, id), 7, "networks");
|
|
if (!instance->networks) {
|
|
DEBUG_ERROR(DEBUG_CATEGORY_CONFIG, "Failed to create networks queue");
|
|
return -1;
|
|
}
|
|
// Initialize connection queue
|
|
instance->connections = queue_new(ua, 256, 0, 8, "connections");
|
|
if (!instance->connections) { DEBUG_ERROR(DEBUG_CATEGORY_ETCP, "Failed to create connections queue"); return -1; }
|
|
struct CFG_NETWORK *net = config->networks;
|
|
while (net) {
|
|
struct ll_entry *entry = queue_entry_new(sizeof(struct NETWORK_ENTRY));
|
|
if (!entry) {
|
|
DEBUG_ERROR(DEBUG_CATEGORY_MEMORY, "Failed to allocate network entry for %s", net->name);
|
|
net = net->next;
|
|
continue;
|
|
}
|
|
struct NETWORK_ENTRY *ne = (struct NETWORK_ENTRY*)entry->data;
|
|
ne->id = net->id & 0x00FFFFFFFFFFFFFFULL;
|
|
for (int i = 0; i < SC_PUBKEY_SIZE; i++) {
|
|
unsigned int b; sscanf(net->pubkey_hex + i * 2, "%2x", &b); ne->pubkey[i] = (uint8_t)b;
|
|
}
|
|
for (int i = 0; i < SC_PRIVKEY_SIZE; i++) {
|
|
unsigned int b; sscanf(net->signing_key_hex + i * 2, "%2x", &b); ne->signing_key[i] = (uint8_t)b;
|
|
}
|
|
strncpy(ne->name, net->name, sizeof(ne->name) - 1);
|
|
ne->name[sizeof(ne->name) - 1] = '\0';
|
|
queue_data_put_with_index(instance->networks, entry);
|
|
DEBUG_INFO(DEBUG_CATEGORY_CONFIG, "Network added: [%s] id=%012llx", ne->name, (unsigned long long)ne->id);
|
|
net = net->next;
|
|
}
|
|
|
|
// Create memory pools
|
|
instance->ack_pool = memory_pool_init(sizeof(struct ACK_PACKET), "ack_pool");
|
|
instance->data_pool = memory_pool_init(PACKET_DATA_SIZE, "data_pool");
|
|
instance->pkt_pool = memory_pool_init(sizeof(struct ETCP_DGRAM) + PACKET_DATA_SIZE, "pkt_pool");
|
|
|
|
// Create routing module
|
|
if (routing_create(instance) != 0) {
|
|
DEBUG_ERROR(DEBUG_CATEGORY_MEMORY, "Failed to create routing module");
|
|
return -1;
|
|
}
|
|
DEBUG_INFO(DEBUG_CATEGORY_ROUTING, "Routing module created");
|
|
if (g_tun_init_enabled && config->global.tun_enabled) {
|
|
instance->tun = tun_init(ua, config);
|
|
if (!instance->tun) {
|
|
DEBUG_ERROR(DEBUG_CATEGORY_TUN, "Failed to initialize TUN device");
|
|
return -1;
|
|
}
|
|
DEBUG_INFO(DEBUG_CATEGORY_TUN, "TUN interface initialized: %s", instance->tun->ifname);
|
|
if (config->route_subnets) {
|
|
int added = tun_route_add_all(instance->tun->ifindex, instance->tun->ifname, config->route_subnets);
|
|
DEBUG_INFO(DEBUG_CATEGORY_TUN, "Added %d system routes for TUN interface", added);
|
|
instance->route_subnets = config->route_subnets;
|
|
}
|
|
} else {
|
|
DEBUG_INFO(DEBUG_CATEGORY_TUN, "TUN initialization disabled - skipping TUN device setup");
|
|
instance->tun = NULL;
|
|
}
|
|
int socket_result = init_sockets(instance);
|
|
instance->socket_init_status = socket_result;
|
|
if (socket_result < 0) {
|
|
DEBUG_ERROR(DEBUG_CATEGORY_ETCP, "Failed to initialize sockets");
|
|
return -1;
|
|
}
|
|
if (socket_result == 1) {
|
|
DEBUG_WARN(DEBUG_CATEGORY_ETCP, "Partial socket initialization - some servers failed to bind");
|
|
}
|
|
instance->topo_groups = topo_groups_init(instance);
|
|
if (!instance->topo_groups) {
|
|
DEBUG_ERROR(DEBUG_CATEGORY_BGP, "Failed to initialize BGP module");
|
|
} else {
|
|
DEBUG_INFO(DEBUG_CATEGORY_BGP, "BGP module initialized");
|
|
struct TOPO_GROUP* g = topo_groups_get_default(instance->topo_groups);
|
|
if (instance->rt && g && g->local_node) {
|
|
topo_group_update_my_nodeinfo(instance, g);
|
|
}
|
|
}
|
|
|
|
instance->conn_mgr = conn_mgr_init(instance);
|
|
if (!instance->conn_mgr) DEBUG_WARN(DEBUG_CATEGORY_GENERAL, "Failed to initialize Connection Manager (non-fatal)");
|
|
|
|
// Initialize firewall
|
|
fw_init(&instance->fw);
|
|
if (fw_load_rules(&instance->fw, &config->global) != 0) {
|
|
DEBUG_WARN(DEBUG_CATEGORY_CONFIG, "Failed to load firewall rules");
|
|
} else {
|
|
DEBUG_INFO(DEBUG_CATEGORY_CONFIG, "Firewall initialized: %d rules, bypass_all=%d",
|
|
instance->fw.count, instance->fw.bypass_all);
|
|
}
|
|
|
|
// etcp_router — сервисная маршрутизация (после BGP, до TCP proxy/NAT/DATA)
|
|
if (etcp_router_init(instance) != 0) {
|
|
DEBUG_ERROR(DEBUG_CATEGORY_ETCP, "Failed to initialize etcp_router");
|
|
return -1;
|
|
}
|
|
|
|
// Bind DATA handler via etcp_router (after etcp_router_init)
|
|
if (routing_bind(instance) != 0) {
|
|
DEBUG_ERROR(DEBUG_CATEGORY_ROUTING, "Failed to bind DATA via etcp_router");
|
|
return -1;
|
|
}
|
|
|
|
// TCP proxy server (exit node, optional) — must be before tcp_proxy_client so
|
|
// tcp_proxy_client_create can overwrite the handler if it has remote mappings
|
|
#ifndef _WIN32
|
|
if (tcp_proxy_server_init(instance) != 0) {
|
|
DEBUG_WARN(DEBUG_CATEGORY_SOCKET, "Failed to initialize tcp_proxy_server (non-fatal)");
|
|
}
|
|
#endif
|
|
|
|
// TCP proxy client (from [tcp_proxy] config section)
|
|
#ifndef _WIN32
|
|
if (config->global.tcp_proxy_client_enabled || config->global.tcp_proxy_client_socks_enabled || config->global.tcp_proxy_client_http_proxy_enabled) {
|
|
const char* tun_name = config->global.tcp_proxy_client_tun_name;
|
|
const char* tun_ip = config->global.tcp_proxy_client_tun_ip;
|
|
int mtu = config->global.tcp_proxy_client_mtu;
|
|
instance->tcp_proxy_client = tcp_proxy_client_create(instance, ua, tun_name, tun_ip, mtu, g_tun_init_enabled ? 0 : 1,
|
|
config->global.tcp_proxy_client_mappings, config->global.tcp_proxy_client_mapping_count,
|
|
config->global.tcp_proxy_client_via_node_id,
|
|
config->global.tcp_proxy_client_socks_enabled, config->global.tcp_proxy_client_socks_addr,
|
|
config->global.tcp_proxy_client_http_proxy_enabled, config->global.tcp_proxy_client_http_proxy_addr);
|
|
if (instance->tcp_proxy_client) {
|
|
DEBUG_INFO(DEBUG_CATEGORY_TUN, "TCP proxy client enabled: TUN=%s IP=%s MTU=%d socks=%s http=%s mappings=%d",
|
|
tun_name, tun_ip, mtu,
|
|
config->global.tcp_proxy_client_socks_enabled ? config->global.tcp_proxy_client_socks_addr : "off",
|
|
config->global.tcp_proxy_client_http_proxy_enabled ? config->global.tcp_proxy_client_http_proxy_addr : "off",
|
|
config->global.tcp_proxy_client_mapping_count);
|
|
} else {
|
|
DEBUG_ERROR(DEBUG_CATEGORY_TUN, "Failed to create TCP proxy client");
|
|
return -1;
|
|
}
|
|
} else {
|
|
instance->tcp_proxy_client = NULL;
|
|
}
|
|
#endif /* _WIN32 */
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Create and initialize root instance from config file
|
|
struct UTUN_INSTANCE* utun_instance_create(struct UASYNC* ua, const char *config_file) {
|
|
// Ensure keys and node_id exist in config (generates them if missing)
|
|
if (config_ensure_keys_and_node_id(config_file) < 0) {
|
|
DEBUG_ERROR(DEBUG_CATEGORY_CONFIG, "Failed to ensure keys and node_id in config: %s", config_file);
|
|
return NULL;
|
|
}
|
|
|
|
// Load configuration
|
|
struct utun_config* config = parse_config(config_file);
|
|
if (!config) {
|
|
DEBUG_ERROR(DEBUG_CATEGORY_CONFIG, "Failed to load config from %s", config_file);
|
|
return NULL;
|
|
}
|
|
|
|
// Open log file only if not using global debug system output
|
|
if (config->global.log_file[0]) {
|
|
debug_set_output_file(config->global.log_file);
|
|
}
|
|
|
|
// Apply debug level from config
|
|
if (config->global.debug_level[0]) {
|
|
debug_apply_global_level(config->global.debug_level);
|
|
}
|
|
|
|
// Apply per-category debug levels from [debug] section
|
|
for (int i = 0; i < config->global.debug_levels.count; i++) {
|
|
debug_apply_category_config(
|
|
config->global.debug_levels.category[i],
|
|
config->global.debug_levels.level[i]
|
|
);
|
|
}
|
|
|
|
// Allocate instance
|
|
struct UTUN_INSTANCE *instance = u_calloc(1, sizeof(struct UTUN_INSTANCE));
|
|
if (!instance) {
|
|
free_config(config);
|
|
return NULL;
|
|
}
|
|
|
|
// Init stats_dir from config file path
|
|
{
|
|
const char* last_sep = NULL;
|
|
for (const char* p = config_file; *p; p++) if (*p == '/' || *p == '\\') last_sep = p;
|
|
size_t dir_len = last_sep ? (size_t)(last_sep - config_file) : 1;
|
|
if (last_sep) {
|
|
memcpy(instance->stats_dir, config_file, dir_len);
|
|
instance->stats_dir[dir_len] = '\0';
|
|
} else {
|
|
instance->stats_dir[0] = '.'; instance->stats_dir[1] = '\0';
|
|
}
|
|
int remaining = (int)(sizeof(instance->stats_dir) - dir_len - 8);
|
|
if (remaining > 0) snprintf(instance->stats_dir + dir_len, remaining, "/stats");
|
|
utun_mkdir(instance->stats_dir, 0755);
|
|
DEBUG_INFO(DEBUG_CATEGORY_GENERAL, "Metrics stats dir: %s", instance->stats_dir);
|
|
}
|
|
|
|
// Initialize using common function
|
|
if (instance_init_common(instance, ua, config) != 0) {
|
|
// Cleanup on error
|
|
if (instance->config) free_config(instance->config);
|
|
u_free(instance);
|
|
return NULL;
|
|
}
|
|
|
|
// Log instance info
|
|
if (instance->name[0] != '\0') {
|
|
DEBUG_INFO(DEBUG_CATEGORY_GENERAL, "uTun instance '%s' created, node_id=0x%llx",
|
|
instance->name, (unsigned long long)instance->node_id);
|
|
} else {
|
|
DEBUG_INFO(DEBUG_CATEGORY_GENERAL, "uTun instance created, node_id=0x%llx",
|
|
(unsigned long long)instance->node_id);
|
|
}
|
|
|
|
return instance;
|
|
}
|
|
|
|
// Create instance from existing config structure (config ownership transfers to instance)
|
|
struct UTUN_INSTANCE* utun_instance_create_from_config(struct UASYNC* ua, struct utun_config* config) {
|
|
if (!config) {
|
|
DEBUG_ERROR(DEBUG_CATEGORY_CONFIG, "NULL config");
|
|
return NULL;
|
|
}
|
|
|
|
// Allocate instance
|
|
struct UTUN_INSTANCE *instance = u_calloc(1, sizeof(struct UTUN_INSTANCE));
|
|
if (!instance) {
|
|
DEBUG_ERROR(DEBUG_CATEGORY_MEMORY, "Failed to allocate UTUN_INSTANCE");
|
|
return NULL;
|
|
}
|
|
instance->etcp_connect_timeout_tb = 20000;
|
|
|
|
// Initialize using common function (config ownership transferred to instance)
|
|
if (instance_init_common(instance, ua, config) != 0) {
|
|
// Cleanup on error - caller still owns config since we failed
|
|
u_free(instance);
|
|
return NULL;
|
|
}
|
|
|
|
return instance;
|
|
}
|
|
|
|
// Create instance from config text string (writes to temp file, parses, cleans up)
|
|
struct UTUN_INSTANCE* utun_instance_create_from_str(struct UASYNC* ua, const char* config_text) {
|
|
if (!config_text) return NULL;
|
|
char tmp_path[] = "/tmp/utun_cfg_XXXXXX";
|
|
int fd = mkstemp(tmp_path);
|
|
if (fd < 0) return NULL;
|
|
size_t len = strlen(config_text);
|
|
if (write(fd, config_text, len) != (ssize_t)len) { close(fd); unlink(tmp_path); return NULL; }
|
|
close(fd);
|
|
struct UTUN_INSTANCE* inst = utun_instance_create(ua, tmp_path);
|
|
unlink(tmp_path);
|
|
return inst;
|
|
}
|
|
|
|
// Destroy instance and cleanup resources
|
|
void utun_instance_destroy(struct UTUN_INSTANCE *instance) {
|
|
if (!instance) return;
|
|
|
|
DEBUG_INFO(DEBUG_CATEGORY_MEMORY, "[INSTANCE_DESTROY] Starting cleanup for instance %p", instance);
|
|
|
|
// Диагностика ресурсов ДО cleanup
|
|
utun_instance_diagnose_leaks(instance, "BEFORE_CLEANUP");
|
|
if (instance->ua) uasync_print_resources(instance->ua, "INSTANCE_DESTROY_BEFORE");
|
|
|
|
// Stop running if not already
|
|
instance->running = 0;
|
|
|
|
// Cancel NTP timer
|
|
ntp_time_destroy(instance);
|
|
ntp_node_time_destroy(instance);
|
|
|
|
// Shutdown message transport server
|
|
if (instance->msg_t) {
|
|
DEBUG_INFO(DEBUG_CATEGORY_GENERAL, "Shutting down message transport server");
|
|
msg_transport_shutdown(instance->msg_t);
|
|
instance->msg_t = NULL;
|
|
}
|
|
|
|
// Shutdown control server first
|
|
if (instance->control_srv) {
|
|
DEBUG_INFO(DEBUG_CATEGORY_CONTROL, "Shutting down control server");
|
|
control_server_shutdown(instance->control_srv);
|
|
u_free(instance->control_srv);
|
|
instance->control_srv = NULL;
|
|
}
|
|
|
|
// Cleanup ETCP sockets and connections FIRST (before destroying uasync)
|
|
DEBUG_INFO(DEBUG_CATEGORY_MEMORY, "[INSTANCE_DESTROY] Cleaning up ETCP sockets and connections");
|
|
struct ETCP_SOCKET* sock = instance->etcp_sockets;
|
|
while (sock) {
|
|
struct ETCP_SOCKET* next = sock->next;
|
|
DEBUG_INFO(DEBUG_CATEGORY_MEMORY, "[INSTANCE_DESTROY] Removing socket %p, fd=%d", sock, sock->fd);
|
|
etcp_socket_remove(sock); // Полный cleanup сокета
|
|
sock = next;
|
|
}
|
|
instance->etcp_sockets = NULL;
|
|
DEBUG_INFO(DEBUG_CATEGORY_MEMORY, "[INSTANCE_DESTROY] ETCP sockets cleanup complete");
|
|
|
|
// Cleanup ETCP connections (phase 1 detach + deferred phase 2 via call_soon)
|
|
{
|
|
struct ll_entry* entry = instance->connections->head;
|
|
while (entry) {
|
|
struct ll_entry* next = entry->next;
|
|
struct conn_queue_entry* ce = (struct conn_queue_entry*)entry->data;
|
|
if (ce && ce->conn) etcp_connection_close(ce->conn);
|
|
entry = next;
|
|
}
|
|
}
|
|
queue_free(instance->connections); instance->connections = NULL;
|
|
DEBUG_INFO(DEBUG_CATEGORY_MEMORY, "[INSTANCE_DESTROY] ETCP connections cleanup complete");
|
|
|
|
struct PING_CONTEXT* p = instance->pending_pings;
|
|
while (p) {
|
|
struct PING_CONTEXT* next = p->next;
|
|
if (p->timeout_timer) uasync_cancel_timeout(instance->ua, p->timeout_timer);
|
|
u_free(p);
|
|
p = next;
|
|
}
|
|
instance->pending_pings = NULL;
|
|
|
|
// Cleanup TUN
|
|
if (instance->tun) {
|
|
DEBUG_INFO(DEBUG_CATEGORY_TUN, "Closing TUN interface: %s", instance->tun->ifname);
|
|
|
|
// Delete system routes added at startup
|
|
if (instance->tun->ifindex && instance->route_subnets) {
|
|
int deleted = tun_route_del_all(instance->tun->ifindex, instance->tun->ifname, instance->route_subnets);
|
|
DEBUG_INFO(DEBUG_CATEGORY_TUN, "Deleted %d system routes for TUN interface", deleted);
|
|
}
|
|
|
|
tun_close(instance->tun);
|
|
instance->tun = NULL;
|
|
}
|
|
|
|
// Cleanup TCP proxy client module
|
|
#ifndef _WIN32
|
|
if (instance->tcp_proxy_client) {
|
|
DEBUG_INFO(DEBUG_CATEGORY_TUN, "Destroying TCP proxy client module");
|
|
tcp_proxy_client_destroy(instance->tcp_proxy_client);
|
|
instance->tcp_proxy_client = NULL;
|
|
}
|
|
|
|
// Cleanup TCP proxy server
|
|
tcp_proxy_server_destroy(instance);
|
|
#endif
|
|
|
|
// Cleanup routing module (unbinds from etcp_router before etcp_router_destroy)
|
|
routing_destroy(instance);
|
|
|
|
// Cleanup NAT (unbinds from etcp_router before etcp_router_destroy)
|
|
if (instance->nat_tr.initialized) {
|
|
nat_transport_destroy(instance);
|
|
}
|
|
|
|
// Cleanup db_sync (before etcp_router_destroy)
|
|
db_sync_destroy(instance);
|
|
|
|
// Cleanup etcp_router
|
|
etcp_router_destroy(instance);
|
|
|
|
if (instance->conn_mgr) { conn_mgr_destroy(instance->conn_mgr); instance->conn_mgr = NULL; }
|
|
|
|
// Cleanup BGP module
|
|
if (instance->topo_groups) {
|
|
DEBUG_INFO(DEBUG_CATEGORY_BGP, "Destroying BGP module");
|
|
topo_groups_destroy(instance);
|
|
}
|
|
|
|
// Cleanup firewall
|
|
fw_free(&instance->fw);
|
|
|
|
// Cleanup TCP server
|
|
if (instance->stcp_server) {
|
|
stcp_link_server_destroy(instance->stcp_server);
|
|
instance->stcp_server = NULL;
|
|
}
|
|
|
|
// Cleanup networks queue
|
|
if (instance->networks) {
|
|
struct ll_entry *entry;
|
|
while ((entry = queue_data_get(instance->networks)) != NULL) {
|
|
queue_entry_free(entry);
|
|
}
|
|
queue_free(instance->networks);
|
|
instance->networks = NULL;
|
|
}
|
|
|
|
// Cleanup config
|
|
if (instance->config) {
|
|
DEBUG_INFO(DEBUG_CATEGORY_MEMORY, "[INSTANCE_DESTROY] Freeing configuration");
|
|
free_config(instance->config);
|
|
instance->config = NULL;
|
|
}
|
|
|
|
// Cleanup packet pool (ensure no leak if stop wasn't called)
|
|
if (instance->pkt_pool) {
|
|
DEBUG_INFO(DEBUG_CATEGORY_MEMORY, "[INSTANCE_DESTROY] Destroying packet pool");
|
|
memory_pool_destroy(instance->pkt_pool);
|
|
instance->pkt_pool = NULL;
|
|
}
|
|
|
|
// Cleanup packet pool (ensure no leak if stop wasn't called)
|
|
if (instance->ack_pool) {
|
|
DEBUG_INFO(DEBUG_CATEGORY_MEMORY, "[INSTANCE_DESTROY] Destroying ack pool");
|
|
memory_pool_destroy(instance->ack_pool);
|
|
instance->ack_pool = NULL;
|
|
}
|
|
|
|
// Cleanup data pool
|
|
if (instance->data_pool) {
|
|
DEBUG_INFO(DEBUG_CATEGORY_MEMORY, "[INSTANCE_DESTROY] Destroying data pool");
|
|
memory_pool_destroy(instance->data_pool);
|
|
instance->data_pool = NULL;
|
|
}
|
|
|
|
if (instance->ua) uasync_print_resources(instance->ua, "INSTANCE_DESTROY_AFTER");
|
|
|
|
// Note: uasync is NOT destroyed here - caller must destroy it separately
|
|
// This allows sharing uasync between multiple instances
|
|
instance->ua = NULL;
|
|
|
|
// Clear global instance
|
|
if (g_instance == instance) {
|
|
g_instance = NULL;
|
|
}
|
|
|
|
// Free the instance memory
|
|
DEBUG_INFO(DEBUG_CATEGORY_MEMORY, "[INSTANCE_DESTROY] Freeing instance memory");
|
|
u_free(instance);
|
|
DEBUG_INFO(DEBUG_CATEGORY_MEMORY, "[INSTANCE_DESTROY] Instance destroyed completely");
|
|
}
|
|
|
|
// Stop instance
|
|
void utun_instance_stop(struct UTUN_INSTANCE *instance) {
|
|
if (!instance) return;
|
|
instance->running = 0;
|
|
// Wakeup main loop using built-in uasync wakeup
|
|
if (instance->ua) {
|
|
memory_pool_destroy(instance->pkt_pool);
|
|
uasync_wakeup(instance->ua);
|
|
}
|
|
|
|
|
|
}
|
|
|
|
int utun_instance_init(struct UTUN_INSTANCE *instance) {
|
|
if (!instance) return -1;
|
|
|
|
// db_sync — распределённая таблица с репликацией
|
|
db_sync_init(instance);
|
|
|
|
// Set TUN interface in routing module
|
|
if (instance->tun) {
|
|
routing_set_tun(instance);
|
|
DEBUG_INFO(DEBUG_CATEGORY_ROUTING, "TUN interface registered in routing module");
|
|
}
|
|
|
|
// Initialize NAT (after routing_set_tun, before connections)
|
|
if (instance->config->global.nat_enabled) {
|
|
int nat_ret = nat_transport_init(instance);
|
|
if (nat_ret != 0) {
|
|
DEBUG_WARN(DEBUG_CATEGORY_NAT, "NAT transport init failed (non-fatal)");
|
|
}
|
|
}
|
|
|
|
// Note: TUN socket is already registered in tun_init()
|
|
|
|
// Initialize connections
|
|
DEBUG_DEBUG(DEBUG_CATEGORY_ETCP, "utun_instance_init() calling init_connections() for instance %p", instance);
|
|
|
|
int conn_result = init_connections(instance);
|
|
|
|
DEBUG_DEBUG(DEBUG_CATEGORY_ETCP, "init_connections() returned: %d", conn_result);
|
|
|
|
if (conn_result < 0) {
|
|
DEBUG_ERROR(DEBUG_CATEGORY_ETCP, "Failed to initialize connections, error=%d", conn_result);
|
|
return -1;
|
|
}
|
|
|
|
DEBUG_DEBUG(DEBUG_CATEGORY_ETCP, "Connections initialized successfully, count=%d", queue_entry_count(instance->connections));
|
|
|
|
// Initialize control server if configured
|
|
if (instance->config->global.control_sock.ss_family != 0) {
|
|
instance->control_srv = (struct control_server*)u_calloc(1, sizeof(struct control_server));
|
|
if (instance->control_srv) {
|
|
if (control_server_init(instance->control_srv, instance->ua, instance,
|
|
&instance->config->global.control_sock, 8) != 0) {
|
|
DEBUG_WARN(DEBUG_CATEGORY_CONTROL, "Failed to initialize control server, continuing without monitoring");
|
|
u_free(instance->control_srv);
|
|
instance->control_srv = NULL;
|
|
} else {
|
|
DEBUG_INFO(DEBUG_CATEGORY_CONTROL, "Control server initialized successfully");
|
|
}
|
|
}
|
|
}
|
|
|
|
// Initialize message transport server if configured
|
|
if (instance->config->global.msg_transport_sock.ss_family != 0) {
|
|
int mt_ret = msg_transport_init(&instance->msg_t, instance, instance->ua,
|
|
&instance->config->global.msg_transport_sock,
|
|
8, ETCP_RT_ID_MSG_TRANSPORT);
|
|
if (mt_ret != 0) {
|
|
DEBUG_WARN(DEBUG_CATEGORY_GENERAL, "Failed to initialize msg_transport, continuing without IPC transport");
|
|
instance->msg_t = NULL;
|
|
} else {
|
|
DEBUG_INFO(DEBUG_CATEGORY_GENERAL, "Message transport server initialized");
|
|
}
|
|
} else {
|
|
instance->msg_t = NULL;
|
|
}
|
|
|
|
// Start the main loop
|
|
instance->running = 1;
|
|
|
|
// Initialize NTP time sync (non-fatal if fails)
|
|
if (ntp_time_init(instance) != 0) {
|
|
DEBUG_WARN(DEBUG_CATEGORY_GENERAL, "NTP time sync init failed (non-fatal)");
|
|
}
|
|
|
|
// Initialize NTP node time exchange (non-fatal)
|
|
if (ntp_node_time_init(instance) != 0) {
|
|
DEBUG_WARN(DEBUG_CATEGORY_GENERAL, "NTP node time exchange init failed (non-fatal)");
|
|
}
|
|
|
|
DEBUG_DEBUG(DEBUG_CATEGORY_ETCP, "Connections initialized successfully");
|
|
return 0;
|
|
}
|
|
|
|
// Диагностическая функция для анализа утечек
|
|
void utun_instance_diagnose_leaks(struct UTUN_INSTANCE *instance, const char *phase) {
|
|
if (!instance) {
|
|
DEBUG_ERROR(DEBUG_CATEGORY_MEMORY, "[DIAGNOSE] NULL instance for phase: %s", phase);
|
|
return;
|
|
}
|
|
|
|
struct {
|
|
int etcp_sockets_count;
|
|
int etcp_connections_count;
|
|
int etcp_links_count;
|
|
} report = {0};
|
|
|
|
// Подсчёт ETCP сокетов
|
|
struct ETCP_SOCKET *sock = instance->etcp_sockets;
|
|
while (sock) {
|
|
report.etcp_sockets_count++;
|
|
// Подсчёт линков в каждом сокете
|
|
for (size_t i = 0; i < sock->num_channels; i++) {
|
|
if (sock->links[i]) {
|
|
report.etcp_links_count++;
|
|
}
|
|
}
|
|
sock = sock->next;
|
|
}
|
|
|
|
// Подсчёт ETCP соединений
|
|
{
|
|
struct ll_entry* entry = instance->connections->head;
|
|
while (entry) {
|
|
struct conn_queue_entry* ce = (struct conn_queue_entry*)entry->data;
|
|
report.etcp_connections_count++;
|
|
struct ETCP_LINK *link = ce->conn->links;
|
|
while (link) { report.etcp_links_count++; link = link->next; }
|
|
entry = entry->next;
|
|
}
|
|
}
|
|
|
|
DEBUG_INFO(DEBUG_CATEGORY_MEMORY, "[LEAK DIAGNOSIS] Phase: %s", phase);
|
|
DEBUG_INFO(DEBUG_CATEGORY_MEMORY, "Instance: %p, Node ID: %llu, UA: %p, Running: %d",
|
|
instance, (unsigned long long)instance->node_id, instance->ua, instance->running);
|
|
DEBUG_INFO(DEBUG_CATEGORY_MEMORY, "STRUCTURE COUNTS - ETCP Sockets: %d, ETCP Connections: %d, ETCP Links: %d",
|
|
report.etcp_sockets_count, report.etcp_connections_count, report.etcp_links_count);
|
|
DEBUG_INFO(DEBUG_CATEGORY_MEMORY, "RESOURCE STATUS - Memory Pool: %s, TUN: %s, TUN FD: %d",
|
|
instance->pkt_pool ? "ALLOCATED" : "NULL",
|
|
instance->tun ? instance->tun->ifname : "NULL",
|
|
instance->tun ? instance->tun->fd : -1);
|
|
|
|
if (instance->pkt_pool) {
|
|
DEBUG_INFO(DEBUG_CATEGORY_MEMORY, "POTENTIAL LEAK: Memory Pool not freed");
|
|
}
|
|
if (instance->tun) {
|
|
DEBUG_INFO(DEBUG_CATEGORY_MEMORY, "POTENTIAL LEAK: TUN interface not closed");
|
|
}
|
|
if (report.etcp_sockets_count > 0) {
|
|
DEBUG_INFO(DEBUG_CATEGORY_MEMORY, "POTENTIAL LEAK: %d ETCP sockets still allocated", report.etcp_sockets_count);
|
|
}
|
|
if (report.etcp_connections_count > 0) {
|
|
DEBUG_INFO(DEBUG_CATEGORY_MEMORY, "POTENTIAL LEAK: %d ETCP connections still allocated", report.etcp_connections_count);
|
|
}
|
|
if (report.etcp_links_count > 0) {
|
|
DEBUG_INFO(DEBUG_CATEGORY_MEMORY, "POTENTIAL LEAK: %d ETCP links still allocated", report.etcp_links_count);
|
|
}
|
|
|
|
DEBUG_INFO(DEBUG_CATEGORY_MEMORY, "[LEAK DIAGNOSIS] Recommendations: pkt_pool=%d, tun=%d, sockets=%d, connections=%d",
|
|
instance->pkt_pool ? 1 : 0,
|
|
instance->tun ? 1 : 0,
|
|
report.etcp_sockets_count,
|
|
report.etcp_connections_count);
|
|
}
|
|
|
|
/* Variant B: selective reload. Compares settings for [server:], [client:], link=. Unchanged untouched (no close, no timers, no queues). Changed/deleted: target only that object. New: add. Routing/fw always. BGP self-restarts. */
|
|
struct UTUN_INSTANCE *utun_instance_reload(struct UTUN_INSTANCE *instance, struct UASYNC *ua, const char *config_file) {
|
|
if (!instance || !ua || !config_file) {
|
|
DEBUG_ERROR(DEBUG_CATEGORY_CONFIG, "invalid arguments");
|
|
return NULL;
|
|
}
|
|
DEBUG_INFO(DEBUG_CATEGORY_CONFIG, "SIGHUP selective reload from %s", config_file);
|
|
debug_reopen_log();
|
|
struct utun_config *new_config = parse_config(config_file);
|
|
if (!new_config) {
|
|
DEBUG_ERROR(DEBUG_CATEGORY_CONFIG, "Failed to parse new config");
|
|
return instance;
|
|
}
|
|
|
|
// Reset + apply debug categories from [debug] section (always, for partial and full paths).
|
|
// Mirrors utun_instance_create exactly. Reset ensures removed categories fall back to global.
|
|
for (int i = 0; i < DEBUG_CATEGORY_COUNT; i++) {
|
|
g_debug_config.category_levels[i] = DEBUG_LEVEL_NONE;
|
|
}
|
|
if (new_config->global.debug_level[0]) {
|
|
debug_apply_global_level(new_config->global.debug_level);
|
|
}
|
|
for (int i = 0; i < new_config->global.debug_levels.count; i++) {
|
|
debug_apply_category_config(
|
|
new_config->global.debug_levels.category[i],
|
|
new_config->global.debug_levels.level[i]
|
|
);
|
|
}
|
|
DEBUG_INFO(DEBUG_CATEGORY_CONFIG, "Applied [debug] section (%d categories)", new_config->global.debug_levels.count);
|
|
|
|
int needs_full = 0;
|
|
if (strcmp(instance->config->global.my_public_key_hex, new_config->global.my_public_key_hex) != 0 ||
|
|
strcmp(instance->config->global.my_private_key_hex, new_config->global.my_private_key_hex) != 0 ||
|
|
instance->config->global.my_node_id != new_config->global.my_node_id ||
|
|
strcmp(instance->config->global.tun_ifname, new_config->global.tun_ifname) != 0) {
|
|
needs_full = 1;
|
|
}
|
|
if (needs_full) {
|
|
DEBUG_INFO(DEBUG_CATEGORY_CONFIG, "Incompatible global - full reload");
|
|
utun_instance_destroy(instance);
|
|
struct UTUN_INSTANCE *new_instance = utun_instance_create(ua, config_file);
|
|
if (!new_instance || utun_instance_init(new_instance) < 0) {
|
|
DEBUG_ERROR(DEBUG_CATEGORY_CONFIG, "Full reload failed");
|
|
if (new_instance) utun_instance_destroy(new_instance);
|
|
free_config(new_config);
|
|
return NULL;
|
|
}
|
|
new_instance->running = 1;
|
|
free_config(new_config);
|
|
DEBUG_INFO(DEBUG_CATEGORY_CONFIG, "Full reload completed");
|
|
return new_instance;
|
|
}
|
|
// Selective Variant B (settings compare, only affected updated)
|
|
// Servers [server:]
|
|
for (struct CFG_SERVER *ns = new_config->servers; ns; ns = ns->next) {
|
|
int matched = 0;
|
|
for (struct ETCP_SOCKET *os = instance->etcp_sockets; os; os = os->next) {
|
|
if (strcmp(ns->name, os->name) == 0 && local_sockaddr_equal(&ns->ip, &os->local_addr)) {
|
|
matched = 1;
|
|
if (ns->mtu != os->mtu) {
|
|
os->mtu = ns->mtu;
|
|
DEBUG_INFO(DEBUG_CATEGORY_ETCP, "Updated socket settings for %s", ns->name);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (!matched) {
|
|
etcp_socket_add(instance, ns);
|
|
DEBUG_INFO(DEBUG_CATEGORY_ETCP, "Added new socket %s", ns->name);
|
|
}
|
|
}
|
|
struct ETCP_SOCKET *os = instance->etcp_sockets;
|
|
while (os) {
|
|
struct ETCP_SOCKET *next = os->next;
|
|
int found = 0;
|
|
for (struct CFG_SERVER *ns = new_config->servers; ns; ns = ns->next) {
|
|
if (strcmp(ns->name, os->name) == 0) {
|
|
found = 1; break;
|
|
}
|
|
}
|
|
if (!found) {
|
|
etcp_socket_remove(os);
|
|
DEBUG_INFO(DEBUG_CATEGORY_ETCP, "Removed deleted socket %s", os->name);
|
|
}
|
|
os = next;
|
|
}
|
|
// Clients [client:] and links (link=)
|
|
for (struct CFG_CLIENT *nc = new_config->clients; nc; nc = nc->next) {
|
|
struct ETCP_CONN *conn = NULL;
|
|
{
|
|
struct ll_entry* entry = instance->connections->head;
|
|
while (entry) {
|
|
struct conn_queue_entry* ce = (struct conn_queue_entry*)entry->data;
|
|
if (strcmp(nc->name, ce->conn->name) == 0) { conn = ce->conn; break; }
|
|
entry = entry->next;
|
|
}
|
|
}
|
|
if (!conn) {
|
|
conn = etcp_connection_create(instance, nc->name);
|
|
if (conn) {
|
|
sc_set_peer_public_key(&conn->crypto_ctx, (const uint8_t*)nc->peer_public_key_hex, 1);
|
|
if (random_bytes((uint8_t*)&conn->session_id, sizeof(conn->session_id)) != 0) {
|
|
DEBUG_ERROR(DEBUG_CATEGORY_CRYPTO, "Failed to generate session_id for client %s", nc->name);
|
|
conn->session_id = 0;
|
|
}
|
|
DEBUG_INFO(DEBUG_CATEGORY_CONNECTION, "Added new client %s session_id=%08x", nc->name, conn->session_id);
|
|
}
|
|
}
|
|
// links
|
|
for (struct CFG_CLIENT_LINK *nl = nc->links; nl; nl = nl->next) {
|
|
struct ETCP_LINK *link = NULL;
|
|
for (struct ETCP_LINK *l = conn->links; l; l = l->next) {
|
|
if (local_sockaddr_equal(&nl->remote_addr, &l->remote_addr)) {
|
|
link = l; break;
|
|
}
|
|
}
|
|
if (link) {
|
|
// in-place for unchanged link (no tear)
|
|
DEBUG_INFO(DEBUG_CATEGORY_CONNECTION, "Link for %s unchanged - untouched", nc->name);
|
|
continue;
|
|
}
|
|
struct ETCP_SOCKET *sock = NULL;
|
|
for (struct ETCP_SOCKET *s = instance->etcp_sockets; s; s = s->next) {
|
|
if (strcmp(nl->server_name, s->name) == 0) {
|
|
sock = s; break;
|
|
}
|
|
}
|
|
if (sock) {
|
|
etcp_link_new(conn, sock, &nl->remote_addr, 0);
|
|
DEBUG_INFO(DEBUG_CATEGORY_CONNECTION, "Added new link for %s", nc->name);
|
|
}
|
|
}
|
|
// remove deleted links (safe with next)
|
|
struct ETCP_LINK *l = conn->links;
|
|
while (l) {
|
|
struct ETCP_LINK *next_l = l->next;
|
|
int found = 0;
|
|
for (struct CFG_CLIENT_LINK *nl = nc->links; nl; nl = nl->next) {
|
|
if (local_sockaddr_equal(&nl->remote_addr, &l->remote_addr)) {
|
|
found = 1; break;
|
|
}
|
|
}
|
|
if (!found) {
|
|
etcp_link_close(l);
|
|
DEBUG_INFO(DEBUG_CATEGORY_CONNECTION, "Removed deleted link for %s", nc->name);
|
|
}
|
|
l = next_l;
|
|
}
|
|
}
|
|
// Reload networks: clear and repopulate
|
|
if (instance->networks) {
|
|
struct ll_entry *entry;
|
|
while ((entry = queue_data_get(instance->networks)) != NULL) {
|
|
queue_entry_free(entry);
|
|
}
|
|
struct CFG_NETWORK *net = new_config->networks;
|
|
while (net) {
|
|
struct ll_entry *new_entry = queue_entry_new(sizeof(struct NETWORK_ENTRY));
|
|
if (!new_entry) {
|
|
DEBUG_ERROR(DEBUG_CATEGORY_MEMORY, "Failed to allocate network entry for reload: %s", net->name);
|
|
net = net->next;
|
|
continue;
|
|
}
|
|
struct NETWORK_ENTRY *ne = (struct NETWORK_ENTRY*)new_entry->data;
|
|
ne->id = net->id & 0x00FFFFFFFFFFFFFFULL;
|
|
for (int i = 0; i < SC_PUBKEY_SIZE; i++) {
|
|
unsigned int b; sscanf(net->pubkey_hex + i * 2, "%2x", &b); ne->pubkey[i] = (uint8_t)b;
|
|
}
|
|
for (int i = 0; i < SC_PRIVKEY_SIZE; i++) {
|
|
unsigned int b; sscanf(net->signing_key_hex + i * 2, "%2x", &b); ne->signing_key[i] = (uint8_t)b;
|
|
}
|
|
strncpy(ne->name, net->name, sizeof(ne->name) - 1);
|
|
ne->name[sizeof(ne->name) - 1] = '\0';
|
|
queue_data_put_with_index(instance->networks, new_entry);
|
|
net = net->next;
|
|
}
|
|
DEBUG_INFO(DEBUG_CATEGORY_CONFIG, "Networks reloaded");
|
|
}
|
|
fw_free(&instance->fw);
|
|
fw_init(&instance->fw);
|
|
fw_load_rules(&instance->fw, &new_config->global);
|
|
// routing_destroy(instance); // commented per request - BGP self-restarts on conn events
|
|
// routing_create(instance); // commented per request
|
|
if (instance->config) free_config(instance->config);
|
|
instance->config = new_config;
|
|
DEBUG_INFO(DEBUG_CATEGORY_CONFIG, "Selective partial reload completed (only changed updated, unchanged untouched, [debug] applied)");
|
|
return instance;
|
|
}
|