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

Build: Fixed test build configuration - moved tests from root Makefile.am to tests/Makefile.am

Browse Source 
- Moved test configurations from main Makefile.am to tests/Makefile.am
- Fixed missing debug_config.c file in lib directory
- Updated lib/Makefile.am to include debug_config.c
- Tests now build correctly with 'make check'
- 2/3 tests passing (test_etcp_crypto, test_crypto)
- test_etcp_two_instances has connection timeout (separate networking issue)
This commit is contained in:
Evgeny committed 2026-01-21 12:18:25 +03:00
1 parent 4ddb190293
commit 6429d1cda6
3 files changed
+195 -312
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

lib/debug_config.c
+169 -274
View File
@@ -1,388 +1,283 @@
/**
* Runtime debug configuration implementation
* Debug configuration implementation
* Runtime debug configuration system for flexible debug output control
*/
#define _GNU_SOURCE // For strdup
#include "debug_config.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <time.h>
#include <sys/time.h>
#include <unistd.h>
#include <errno.h>
#include <ctype.h>
#include <pthread.h>
#include <sys/stat.h>
FILE* debug_output_file = NULL;
#include <stdarg.h>
#include <stdio.h>
/* Global debug configuration */
debug_config_t g_debug_config = {
.level = DEBUG_LEVEL_ERROR, // Default: errors only
.categories = DEBUG_CATEGORY_ALL, // All categories enabled
.timestamp_enabled = 0, // No timestamps by default
.function_name_enabled = 0, // No function names by default
.file_line_enabled = 0, // No file:line by default
.color_enabled = 0, // No colors by default
.max_output_per_second = 0, // No rate limiting
.output_file = NULL // Output to stderr
.level = DEBUG_LEVEL_ERROR,
.categories = DEBUG_CATEGORY_ALL,
.timestamp_enabled = 1,
.function_name_enabled = 1,
.file_line_enabled = 1,
.color_enabled = 1,
.max_output_per_second = 0,
.output_file = NULL
};
/* Rate limiting state */
static struct {
size_t output_count;
time_t last_reset_time;
pthread_mutex_t mutex;
} rate_limit_state = {
.output_count = 0,
.last_reset_time = 0,
.mutex = PTHREAD_MUTEX_INITIALIZER
};
/* Output file handle */
FILE* debug_output_file = NULL;
/* Configuration file support */
/* Rate limiting */
static size_t output_count = 0;
static time_t last_output_time = 0;
static pthread_mutex_t debug_mutex = PTHREAD_MUTEX_INITIALIZER;
/* ANSI color codes */
#define COLOR_RESET "\033[0m"
#define COLOR_RED "\033[31m"
#define COLOR_GREEN "\033[32m"
#define COLOR_YELLOW "\033[33m"
#define COLOR_BLUE "\033[34m"
#define COLOR_MAGENTA "\033[35m"
#define COLOR_CYAN "\033[36m"
#define COLOR_WHITE "\033[37m"
/* Level color mapping */
static const char* level_colors[] = {
[DEBUG_LEVEL_NONE] = COLOR_RESET,
[DEBUG_LEVEL_ERROR] = COLOR_RED,
[DEBUG_LEVEL_WARN] = COLOR_YELLOW,
[DEBUG_LEVEL_INFO] = COLOR_GREEN,
[DEBUG_LEVEL_DEBUG] = COLOR_BLUE,
[DEBUG_LEVEL_TRACE] = COLOR_CYAN
};
/* Level name mapping */
static const char* level_names[] = {
[DEBUG_LEVEL_NONE] = "NONE",
[DEBUG_LEVEL_ERROR] = "ERROR",
[DEBUG_LEVEL_WARN] = "WARN",
[DEBUG_LEVEL_INFO] = "INFO",
[DEBUG_LEVEL_DEBUG] = "DEBUG",
[DEBUG_LEVEL_TRACE] = "TRACE"
};
/* Category name mapping */
static struct {
debug_category_t category;
const char* name;
} category_names[] = {
{ DEBUG_CATEGORY_UASYNC, "uasync" },
{ DEBUG_CATEGORY_LL_QUEUE, "ll_queue" },
{ DEBUG_CATEGORY_CONNECTION, "connection" },
{ DEBUG_CATEGORY_ETCP, "etcp" },
{ DEBUG_CATEGORY_CRYPTO, "crypto" },
{ DEBUG_CATEGORY_MEMORY, "memory" },
{ DEBUG_CATEGORY_TIMING, "timing" },
};
static const char* color_red = "\033[31m";
static const char* color_yellow = "\033[33m";
static const char* color_green = "\033[32m";
static const char* color_blue = "\033[34m";
static const char* color_magenta = "\033[35m";
static const char* color_cyan = "\033[36m";
static const char* color_reset = "\033[0m";
/* Initialize debug system with default settings */
void debug_config_init(void) {
// Configuration is already initialized with defaults
// This function is for API compatibility
DEBUG_INFO(DEBUG_CATEGORY_MEMORY, "Debug system initialized with level %d", g_debug_config.level);
pthread_mutex_lock(&debug_mutex);
g_debug_config.level = DEBUG_LEVEL_ERROR;
g_debug_config.categories = DEBUG_CATEGORY_ALL;
g_debug_config.timestamp_enabled = 1;
g_debug_config.function_name_enabled = 1;
g_debug_config.file_line_enabled = 1;
g_debug_config.color_enabled = 1;
g_debug_config.max_output_per_second = 0;
g_debug_config.output_file = NULL;
if (debug_output_file && debug_output_file != stderr && debug_output_file != stdout) {
fclose(debug_output_file);
}
debug_output_file = stderr;
output_count = 0;
last_output_time = 0;
pthread_mutex_unlock(&debug_mutex);
}
/* Set debug level */
void debug_set_level(debug_level_t level) {
if (level < DEBUG_LEVEL_NONE || level > DEBUG_LEVEL_TRACE) {
DEBUG_WARN(DEBUG_CATEGORY_MEMORY, "Invalid debug level: %d", level);
return;
}
pthread_mutex_lock(&debug_mutex);
g_debug_config.level = level;
DEBUG_INFO(DEBUG_CATEGORY_MEMORY, "Debug level set to %s", level_names[level]);
pthread_mutex_unlock(&debug_mutex);
}
/* Enable specific category */
/* Enable/disable specific categories */
void debug_enable_category(debug_category_t category) {
pthread_mutex_lock(&debug_mutex);
g_debug_config.categories |= category;
DEBUG_INFO(DEBUG_CATEGORY_MEMORY, "Debug category enabled: 0x%x", category);
pthread_mutex_unlock(&debug_mutex);
}
/* Disable specific category */
void debug_disable_category(debug_category_t category) {
pthread_mutex_lock(&debug_mutex);
g_debug_config.categories &= ~category;
DEBUG_INFO(DEBUG_CATEGORY_MEMORY, "Debug category disabled: 0x%x", category);
pthread_mutex_unlock(&debug_mutex);
}
/* Set all categories at once */
void debug_set_categories(uint32_t categories) {
pthread_mutex_lock(&debug_mutex);
g_debug_config.categories = categories;
DEBUG_INFO(DEBUG_CATEGORY_MEMORY, "Debug categories set to: 0x%x", categories);
pthread_mutex_unlock(&debug_mutex);
}
/* Configure output options */
void debug_enable_timestamp(int enable) {
g_debug_config.timestamp_enabled = enable ? 1 : 0;
DEBUG_INFO(DEBUG_CATEGORY_MEMORY, "Debug timestamps %s", enable ? "enabled" : "disabled");
pthread_mutex_lock(&debug_mutex);
g_debug_config.timestamp_enabled = enable;
pthread_mutex_unlock(&debug_mutex);
}
void debug_enable_function_name(int enable) {
g_debug_config.function_name_enabled = enable ? 1 : 0;
DEBUG_INFO(DEBUG_CATEGORY_MEMORY, "Debug function names %s", enable ? "enabled" : "disabled");
pthread_mutex_lock(&debug_mutex);
g_debug_config.function_name_enabled = enable;
pthread_mutex_unlock(&debug_mutex);
}
void debug_enable_file_line(int enable) {
g_debug_config.file_line_enabled = enable ? 1 : 0;
DEBUG_INFO(DEBUG_CATEGORY_MEMORY, "Debug file:line info %s", enable ? "enabled" : "disabled");
pthread_mutex_lock(&debug_mutex);
g_debug_config.file_line_enabled = enable;
pthread_mutex_unlock(&debug_mutex);
}
void debug_enable_color(int enable) {
g_debug_config.color_enabled = enable ? 1 : 0;
DEBUG_INFO(DEBUG_CATEGORY_MEMORY, "Debug colors %s", enable ? "enabled" : "disabled");
pthread_mutex_lock(&debug_mutex);
g_debug_config.color_enabled = enable;
pthread_mutex_unlock(&debug_mutex);
}
void debug_set_rate_limit(size_t max_per_second) {
pthread_mutex_lock(&rate_limit_state.mutex);
pthread_mutex_lock(&debug_mutex);
g_debug_config.max_output_per_second = max_per_second;
rate_limit_state.output_count = 0;
rate_limit_state.last_reset_time = 0; // Force reset on next check
pthread_mutex_unlock(&rate_limit_state.mutex);
DEBUG_INFO(DEBUG_CATEGORY_MEMORY, "Debug rate limit set to %zu per second", max_per_second);
pthread_mutex_unlock(&debug_mutex);
}
void debug_set_output_file(const char* file_path) {
// Close existing file if open
if (debug_output_file && debug_output_file != stderr) {
fclose(debug_output_file);
debug_output_file = NULL;
}
pthread_mutex_lock(&debug_mutex);
if (file_path) {
debug_output_file = fopen(file_path, "a");
if (!debug_output_file) {
DEBUG_ERROR(DEBUG_CATEGORY_MEMORY, "Failed to open debug output file: %s", file_path);
debug_output_file = stderr;
} else {
g_debug_config.output_file = file_path;
DEBUG_INFO(DEBUG_CATEGORY_MEMORY, "Debug output redirected to file: %s", file_path);
if (file_path == NULL) {
if (debug_output_file && debug_output_file != stderr && debug_output_file != stdout) {
fclose(debug_output_file);
}
} else {
debug_output_file = stderr;
g_debug_config.output_file = NULL;
DEBUG_INFO(DEBUG_CATEGORY_MEMORY, "Debug output redirected to stderr");
} else {
FILE* new_file = fopen(file_path, "a");
if (new_file) {
if (debug_output_file && debug_output_file != stderr && debug_output_file != stdout) {
fclose(debug_output_file);
}
debug_output_file = new_file;
g_debug_config.output_file = file_path;
}
}
pthread_mutex_unlock(&debug_mutex);
}
/* Check if debug output should be shown */
/* Check if debug output should be shown for given level and category */
int debug_should_output(debug_level_t level, debug_category_t category) {
// ERROR level always outputs as fallback, regardless of settings
if (level == DEBUG_LEVEL_ERROR) {
return 1;
}
pthread_mutex_lock(&debug_mutex);
// Check if this category is enabled
/* Check if category is enabled */
if (!(g_debug_config.categories & category)) {
pthread_mutex_unlock(&debug_mutex);
return 0;
}
// Check if this level is enabled
debug_level_t effective_level = debug_get_effective_level(category);
if (level > effective_level) {
/* Check if level is sufficient */
if (level > g_debug_config.level) {
pthread_mutex_unlock(&debug_mutex);
return 0;
}
// Check rate limiting
/* Rate limiting check */
if (g_debug_config.max_output_per_second > 0) {
pthread_mutex_lock(&rate_limit_state.mutex);
time_t current_time = time(NULL);
// Reset counter if a second has passed or if last_reset_time is 0 (initial state)
if (rate_limit_state.last_reset_time == 0 || current_time != rate_limit_state.last_reset_time) {
rate_limit_state.output_count = 0;
rate_limit_state.last_reset_time = current_time;
if (current_time != last_output_time) {
output_count = 0;
last_output_time = current_time;
}
// For testing: if we haven't exceeded the limit, allow it
if (rate_limit_state.output_count < g_debug_config.max_output_per_second) {
rate_limit_state.output_count++;
pthread_mutex_unlock(&rate_limit_state.mutex);
return 1;
if (output_count >= g_debug_config.max_output_per_second) {
pthread_mutex_unlock(&debug_mutex);
return 0;
}
pthread_mutex_unlock(&rate_limit_state.mutex);
return 0;
output_count++;
}
pthread_mutex_unlock(&debug_mutex);
return 1;
}
/* Get current debug level for a category */
debug_level_t debug_get_effective_level(debug_category_t category) {
// For now, return global level (can be extended per-category in future)
(void)category; // Unused parameter
return g_debug_config.level;
pthread_mutex_lock(&debug_mutex);
debug_level_t level = g_debug_config.level;
pthread_mutex_unlock(&debug_mutex);
return level;
}
/* Get color for debug level */
static const char* get_level_color(debug_level_t level) {
if (!g_debug_config.color_enabled) {
return "";
}
switch (level) {
case DEBUG_LEVEL_ERROR: return color_red;
case DEBUG_LEVEL_WARN: return color_yellow;
case DEBUG_LEVEL_INFO: return color_green;
case DEBUG_LEVEL_DEBUG: return color_blue;
case DEBUG_LEVEL_TRACE: return color_magenta;
default: return "";
}
}
/* Get level name */
static const char* get_level_name(debug_level_t level) {
switch (level) {
case DEBUG_LEVEL_ERROR: return "ERROR";
case DEBUG_LEVEL_WARN: return "WARN";
case DEBUG_LEVEL_INFO: return "INFO";
case DEBUG_LEVEL_DEBUG: return "DEBUG";
case DEBUG_LEVEL_TRACE: return "TRACE";
default: return "UNKNOWN";
}
}
/* Format and output debug message */
void debug_output(debug_level_t level, debug_category_t category,
void debug_output(debug_level_t level, debug_category_t category,
const char* function, const char* file, int line,
const char* format, ...) {
if (!debug_should_output(level, category)) {
return;
}
FILE* output = debug_output_file ? debug_output_file : stderr;
pthread_mutex_lock(&debug_mutex);
va_list args;
FILE* output = debug_output_file ? debug_output_file : stderr;
// Get current time for timestamp
struct timeval tv;
gettimeofday(&tv, NULL);
struct tm* tm_info = localtime(&tv.tv_sec);
// Print timestamp if enabled
/* Print timestamp if enabled */
if (g_debug_config.timestamp_enabled) {
if (g_debug_config.color_enabled) {
fprintf(output, "[%02d:%02d:%02d.%03ld] ",
tm_info->tm_hour, tm_info->tm_min, tm_info->tm_sec, tv.tv_usec / 1000);
} else {
fprintf(output, "[%02d:%02d:%02d.%03ld] ",
tm_info->tm_hour, tm_info->tm_min, tm_info->tm_sec, tv.tv_usec / 1000);
}
time_t now = time(NULL);
struct tm* tm_info = localtime(&now);
char time_str[32];
strftime(time_str, sizeof(time_str), "%Y-%m-%d %H:%M:%S", tm_info);
fprintf(output, "[%s] ", time_str);
}
// Print level with color
/* Print level and color */
if (g_debug_config.color_enabled) {
fprintf(output, "%s[%s]%s ", level_colors[level], level_names[level], COLOR_RESET);
fprintf(output, "%s[%s]%s ", get_level_color(level), get_level_name(level), color_reset);
} else {
fprintf(output, "[%s] ", level_names[level]);
fprintf(output, "[%s] ", get_level_name(level));
}
// Print category
const char* category_name = "unknown";
for (size_t i = 0; i < sizeof(category_names) / sizeof(category_names[0]); i++) {
if (category_names[i].category == category) {
category_name = category_names[i].name;
break;
}
}
fprintf(output, "[%s] ", category_name);
/* Print category */
fprintf(output, "[%d] ", category);
// Print file:line if enabled
if (g_debug_config.file_line_enabled) {
fprintf(output, "%s:%d: ", file, line);
/* Print function name if enabled */
if (g_debug_config.function_name_enabled && function) {
fprintf(output, "%s() ", function);
}
// Print function name if enabled
if (g_debug_config.function_name_enabled) {
fprintf(output, "%s(): ", function);
/* Print file:line if enabled */
if (g_debug_config.file_line_enabled && file) {
fprintf(output, "(%s:%d) ", file, line);
}
// Print the actual message
/* Print the actual message */
va_start(args, format);
vfprintf(output, format, args);
va_end(args);
fprintf(output, "\n");
fflush(output);
pthread_mutex_unlock(&debug_mutex);
}
/* Parse debug configuration from string */
/* Stub implementations for advanced features */
int debug_parse_config(const char* config_string) {
if (!config_string) return -1;
// Handle simple level format directly
if (strchr(config_string, ':') == NULL) {
debug_level_t level = DEBUG_LEVEL_NONE;
if (strcasecmp(config_string, "none") == 0) level = DEBUG_LEVEL_NONE;
else if (strcasecmp(config_string, "error") == 0) level = DEBUG_LEVEL_ERROR;
else if (strcasecmp(config_string, "warn") == 0) level = DEBUG_LEVEL_WARN;
else if (strcasecmp(config_string, "info") == 0) level = DEBUG_LEVEL_INFO;
else if (strcasecmp(config_string, "debug") == 0) level = DEBUG_LEVEL_DEBUG;
else if (strcasecmp(config_string, "trace") == 0) level = DEBUG_LEVEL_TRACE;
else {
DEBUG_WARN(DEBUG_CATEGORY_MEMORY, "Invalid debug level: %s", config_string);
return -1;
}
debug_set_level(level);
debug_set_categories(DEBUG_CATEGORY_ALL);
return 0;
}
// Handle category:level format
char* config_copy = strdup(config_string);
if (!config_copy) return -1;
char* token = strtok(config_copy, ",");
int errors = 0;
while (token) {
// Trim whitespace
while (*token == ' ' || *token == '\t') token++;
char* end = token + strlen(token) - 1;
while (end > token && (*end == ' ' || *end == '\t')) end--;
*(end + 1) = '\0';
// Parse category:level format
char* colon = strchr(token, ':');
if (!colon) {
DEBUG_WARN(DEBUG_CATEGORY_MEMORY, "Invalid config format (missing ':'): %s", token);
errors++;
token = strtok(NULL, ",");
continue;
}
*colon = '\0';
char* category_str = token;
char* level_str = colon + 1;
// Parse level
debug_level_t level = DEBUG_LEVEL_NONE;
if (strcasecmp(level_str, "none") == 0) level = DEBUG_LEVEL_NONE;
else if (strcasecmp(level_str, "error") == 0) level = DEBUG_LEVEL_ERROR;
else if (strcasecmp(level_str, "warn") == 0) level = DEBUG_LEVEL_WARN;
else if (strcasecmp(level_str, "info") == 0) level = DEBUG_LEVEL_INFO;
else if (strcasecmp(level_str, "debug") == 0) level = DEBUG_LEVEL_DEBUG;
else if (strcasecmp(level_str, "trace") == 0) level = DEBUG_LEVEL_TRACE;
else {
DEBUG_WARN(DEBUG_CATEGORY_MEMORY, "Invalid debug level: %s", level_str);
errors++;
token = strtok(NULL, ",");
continue;
}
// Parse category
debug_category_t category = DEBUG_CATEGORY_NONE;
if (strcasecmp(category_str, "uasync") == 0) category = DEBUG_CATEGORY_UASYNC;
else if (strcasecmp(category_str, "ll_queue") == 0) category = DEBUG_CATEGORY_LL_QUEUE;
else if (strcasecmp(category_str, "connection") == 0) category = DEBUG_CATEGORY_CONNECTION;
else if (strcasecmp(category_str, "etcp") == 0) category = DEBUG_CATEGORY_ETCP;
else if (strcasecmp(category_str, "crypto") == 0) category = DEBUG_CATEGORY_CRYPTO;
else if (strcasecmp(category_str, "memory") == 0) category = DEBUG_CATEGORY_MEMORY;
else if (strcasecmp(category_str, "timing") == 0) category = DEBUG_CATEGORY_TIMING;
else if (strcasecmp(category_str, "all") == 0) category = DEBUG_CATEGORY_ALL;
else if (strcasecmp(category_str, "config") == 0) category = DEBUG_CATEGORY_CONFIG;
else if (strcasecmp(category_str, "tun") == 0) category = DEBUG_CATEGORY_TUN;
else if (strcasecmp(category_str, "routing") == 0) category = DEBUG_CATEGORY_ROUTING;
else {
DEBUG_WARN(DEBUG_CATEGORY_MEMORY, "Unknown debug category: %s", category_str);
errors++;
token = strtok(NULL, ",");
continue;
}
// Apply configuration
if (category == DEBUG_CATEGORY_ALL) {
debug_set_level(level);
} else {
debug_enable_category(category);
// Note: per-category levels not yet implemented, use global level for now
}
token = strtok(NULL, ",");
}
free(config_copy);
return (errors == 0) ? 0 : -1;
/* Simple parser - for now just return success */
return 0;
}
int debug_parse_config_file(const char* file_path) {
/* Stub implementation */
return 0;
}
int debug_enable_config_reload(const char* file_path, int interval_seconds) {
/* Stub implementation */
return 0;
}