1170 lines
39 KiB
C
1170 lines
39 KiB
C
#include "config.h"
|
|
#include "version.h"
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <strings.h>
|
|
#include <unistd.h>
|
|
#include <sys/stat.h>
|
|
#include <errno.h>
|
|
#include <cjson/cJSON.h>
|
|
#include "../nostr_core_lib/nostr_core/nostr_core.h"
|
|
|
|
// External database connection (from main.c)
|
|
extern sqlite3* g_db;
|
|
|
|
// Global configuration manager instance
|
|
config_manager_t g_config_manager = {0};
|
|
|
|
// Logging functions (defined in main.c)
|
|
extern void log_info(const char* message);
|
|
extern void log_success(const char* message);
|
|
extern void log_warning(const char* message);
|
|
extern void log_error(const char* message);
|
|
|
|
// ================================
|
|
// CORE CONFIGURATION FUNCTIONS
|
|
// ================================
|
|
//
|
|
|
|
int init_configuration_system(void) {
|
|
log_info("Initializing configuration system...");
|
|
|
|
// Clear configuration manager state
|
|
memset(&g_config_manager, 0, sizeof(config_manager_t));
|
|
g_config_manager.db = g_db;
|
|
|
|
// Check for command line config file override first
|
|
const char* config_file_override = getenv(CONFIG_FILE_OVERRIDE_ENV);
|
|
if (config_file_override && strlen(config_file_override) > 0) {
|
|
// Use specific config file override
|
|
strncpy(g_config_manager.config_file_path, config_file_override,
|
|
sizeof(g_config_manager.config_file_path) - 1);
|
|
g_config_manager.config_file_path[sizeof(g_config_manager.config_file_path) - 1] = '\0';
|
|
|
|
// Extract directory from file path for config_dir_path
|
|
char* last_slash = strrchr(g_config_manager.config_file_path, '/');
|
|
if (last_slash) {
|
|
size_t dir_len = last_slash - g_config_manager.config_file_path;
|
|
strncpy(g_config_manager.config_dir_path, g_config_manager.config_file_path, dir_len);
|
|
g_config_manager.config_dir_path[dir_len] = '\0';
|
|
} else {
|
|
// File in current directory
|
|
strcpy(g_config_manager.config_dir_path, ".");
|
|
}
|
|
|
|
log_info("Using configuration file from command line override");
|
|
} else {
|
|
// Get XDG configuration directory (with --config-dir override support)
|
|
if (get_xdg_config_dir(g_config_manager.config_dir_path, sizeof(g_config_manager.config_dir_path)) != 0) {
|
|
log_error("Failed to determine configuration directory");
|
|
return -1;
|
|
}
|
|
|
|
// Build configuration file path
|
|
snprintf(g_config_manager.config_file_path, sizeof(g_config_manager.config_file_path),
|
|
"%s/%s", g_config_manager.config_dir_path, CONFIG_FILE_NAME);
|
|
}
|
|
|
|
log_info("Configuration directory: %s");
|
|
printf(" %s\n", g_config_manager.config_dir_path);
|
|
log_info("Configuration file: %s");
|
|
printf(" %s\n", g_config_manager.config_file_path);
|
|
|
|
// Initialize database prepared statements
|
|
if (init_config_database_statements() != 0) {
|
|
log_error("Failed to initialize configuration database statements");
|
|
return -1;
|
|
}
|
|
|
|
// Generate configuration file if missing
|
|
if (generate_config_file_if_missing() != 0) {
|
|
log_warning("Failed to generate configuration file, continuing with database configuration");
|
|
}
|
|
|
|
// Load configuration from all sources
|
|
if (load_configuration() != 0) {
|
|
log_error("Failed to load configuration");
|
|
return -1;
|
|
}
|
|
|
|
// Apply configuration to global variables
|
|
if (apply_configuration_to_globals() != 0) {
|
|
log_error("Failed to apply configuration to global variables");
|
|
return -1;
|
|
}
|
|
|
|
log_success("Configuration system initialized successfully");
|
|
return 0;
|
|
}
|
|
|
|
void cleanup_configuration_system(void) {
|
|
log_info("Cleaning up configuration system...");
|
|
|
|
// Finalize prepared statements
|
|
if (g_config_manager.get_config_stmt) {
|
|
sqlite3_finalize(g_config_manager.get_config_stmt);
|
|
g_config_manager.get_config_stmt = NULL;
|
|
}
|
|
if (g_config_manager.set_config_stmt) {
|
|
sqlite3_finalize(g_config_manager.set_config_stmt);
|
|
g_config_manager.set_config_stmt = NULL;
|
|
}
|
|
if (g_config_manager.log_change_stmt) {
|
|
sqlite3_finalize(g_config_manager.log_change_stmt);
|
|
g_config_manager.log_change_stmt = NULL;
|
|
}
|
|
|
|
// Clear manager state
|
|
memset(&g_config_manager, 0, sizeof(config_manager_t));
|
|
|
|
log_success("Configuration system cleaned up");
|
|
}
|
|
|
|
int load_configuration(void) {
|
|
log_info("Loading configuration from all sources...");
|
|
|
|
// Try to load configuration from file first
|
|
if (config_file_exists()) {
|
|
log_info("Configuration file found, attempting to load...");
|
|
if (load_config_from_file() == 0) {
|
|
g_config_manager.file_config_loaded = 1;
|
|
log_success("File configuration loaded successfully");
|
|
} else {
|
|
log_warning("Failed to load file configuration, falling back to database");
|
|
}
|
|
} else {
|
|
log_info("No configuration file found, checking database");
|
|
}
|
|
|
|
// Load configuration from database (either as primary or fallback)
|
|
if (load_config_from_database() == 0) {
|
|
g_config_manager.database_config_loaded = 1;
|
|
log_success("Database configuration loaded");
|
|
} else {
|
|
log_error("Failed to load database configuration");
|
|
return -1;
|
|
}
|
|
|
|
g_config_manager.last_reload = time(NULL);
|
|
return 0;
|
|
}
|
|
|
|
int apply_configuration_to_globals(void) {
|
|
log_info("Applying configuration to global variables...");
|
|
|
|
// Apply configuration values to existing global variables
|
|
// This would update the existing hardcoded values with database values
|
|
|
|
// For now, this is a placeholder - in Phase 4 we'll implement
|
|
// the actual mapping to existing global variables
|
|
|
|
log_success("Configuration applied to global variables");
|
|
return 0;
|
|
}
|
|
|
|
// ================================
|
|
// DATABASE CONFIGURATION FUNCTIONS
|
|
// ================================
|
|
|
|
int init_config_database_statements(void) {
|
|
if (!g_db) {
|
|
log_error("Database connection not available for configuration");
|
|
return -1;
|
|
}
|
|
|
|
log_info("Initializing configuration database statements...");
|
|
|
|
// Prepare statement for getting configuration values
|
|
const char* get_sql = "SELECT value FROM config WHERE key = ?";
|
|
int rc = sqlite3_prepare_v2(g_db, get_sql, -1, &g_config_manager.get_config_stmt, NULL);
|
|
if (rc != SQLITE_OK) {
|
|
log_error("Failed to prepare get_config statement");
|
|
return -1;
|
|
}
|
|
|
|
// Prepare statement for setting configuration values
|
|
const char* set_sql = "INSERT OR REPLACE INTO config (key, value, updated_at) VALUES (?, ?, strftime('%s', 'now'))";
|
|
rc = sqlite3_prepare_v2(g_db, set_sql, -1, &g_config_manager.set_config_stmt, NULL);
|
|
if (rc != SQLITE_OK) {
|
|
log_error("Failed to prepare set_config statement");
|
|
return -1;
|
|
}
|
|
|
|
// Prepare statement for logging configuration changes
|
|
const char* log_sql = "INSERT INTO config_history (config_key, old_value, new_value, changed_by) VALUES (?, ?, ?, ?)";
|
|
rc = sqlite3_prepare_v2(g_db, log_sql, -1, &g_config_manager.log_change_stmt, NULL);
|
|
if (rc != SQLITE_OK) {
|
|
log_error("Failed to prepare log_change statement");
|
|
return -1;
|
|
}
|
|
|
|
log_success("Configuration database statements initialized");
|
|
return 0;
|
|
}
|
|
|
|
int get_database_config(const char* key, char* value, size_t value_size) {
|
|
if (!key || !value || !g_config_manager.get_config_stmt) {
|
|
return -1;
|
|
}
|
|
|
|
// Reset and bind parameters
|
|
sqlite3_reset(g_config_manager.get_config_stmt);
|
|
sqlite3_bind_text(g_config_manager.get_config_stmt, 1, key, -1, SQLITE_STATIC);
|
|
|
|
int result = -1;
|
|
if (sqlite3_step(g_config_manager.get_config_stmt) == SQLITE_ROW) {
|
|
const char* db_value = (const char*)sqlite3_column_text(g_config_manager.get_config_stmt, 0);
|
|
if (db_value) {
|
|
strncpy(value, db_value, value_size - 1);
|
|
value[value_size - 1] = '\0';
|
|
result = 0;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
int set_database_config(const char* key, const char* new_value, const char* changed_by) {
|
|
if (!key || !new_value || !g_config_manager.set_config_stmt) {
|
|
return -1;
|
|
}
|
|
|
|
// Get old value for logging
|
|
char old_value[CONFIG_VALUE_MAX_LENGTH] = {0};
|
|
get_database_config(key, old_value, sizeof(old_value));
|
|
|
|
// Set new value
|
|
sqlite3_reset(g_config_manager.set_config_stmt);
|
|
sqlite3_bind_text(g_config_manager.set_config_stmt, 1, key, -1, SQLITE_STATIC);
|
|
sqlite3_bind_text(g_config_manager.set_config_stmt, 2, new_value, -1, SQLITE_STATIC);
|
|
|
|
int result = 0;
|
|
if (sqlite3_step(g_config_manager.set_config_stmt) != SQLITE_DONE) {
|
|
log_error("Failed to set configuration value");
|
|
result = -1;
|
|
} else {
|
|
// Log the change
|
|
if (g_config_manager.log_change_stmt) {
|
|
sqlite3_reset(g_config_manager.log_change_stmt);
|
|
sqlite3_bind_text(g_config_manager.log_change_stmt, 1, key, -1, SQLITE_STATIC);
|
|
sqlite3_bind_text(g_config_manager.log_change_stmt, 2, strlen(old_value) > 0 ? old_value : NULL, -1, SQLITE_STATIC);
|
|
sqlite3_bind_text(g_config_manager.log_change_stmt, 3, new_value, -1, SQLITE_STATIC);
|
|
sqlite3_bind_text(g_config_manager.log_change_stmt, 4, changed_by ? changed_by : "system", -1, SQLITE_STATIC);
|
|
sqlite3_step(g_config_manager.log_change_stmt);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
int load_config_from_database(void) {
|
|
log_info("Loading configuration from database...");
|
|
|
|
// Database configuration is already populated by schema defaults
|
|
// This function validates that the configuration tables exist and are accessible
|
|
|
|
const char* test_sql = "SELECT COUNT(*) FROM config WHERE config_type IN ('system', 'user')";
|
|
sqlite3_stmt* test_stmt;
|
|
|
|
int rc = sqlite3_prepare_v2(g_db, test_sql, -1, &test_stmt, NULL);
|
|
if (rc != SQLITE_OK) {
|
|
log_error("Failed to prepare database configuration test query");
|
|
return -1;
|
|
}
|
|
|
|
int config_count = 0;
|
|
if (sqlite3_step(test_stmt) == SQLITE_ROW) {
|
|
config_count = sqlite3_column_int(test_stmt, 0);
|
|
}
|
|
|
|
sqlite3_finalize(test_stmt);
|
|
|
|
if (config_count > 0) {
|
|
log_success("Database configuration validated (%d entries)");
|
|
printf(" Found %d configuration entries\n", config_count);
|
|
return 0;
|
|
} else {
|
|
log_error("No configuration entries found in database");
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
// ================================
|
|
// FILE CONFIGURATION FUNCTIONS
|
|
// ================================
|
|
|
|
int get_xdg_config_dir(char* path, size_t path_size) {
|
|
// Priority 1: Command line --config-dir override
|
|
const char* config_dir_override = getenv(CONFIG_DIR_OVERRIDE_ENV);
|
|
if (config_dir_override && strlen(config_dir_override) > 0) {
|
|
strncpy(path, config_dir_override, path_size - 1);
|
|
path[path_size - 1] = '\0';
|
|
log_info("Using config directory from command line override");
|
|
return 0;
|
|
}
|
|
|
|
// Priority 2: XDG_CONFIG_HOME environment variable
|
|
const char* xdg_config_home = getenv("XDG_CONFIG_HOME");
|
|
if (xdg_config_home && strlen(xdg_config_home) > 0) {
|
|
// Use XDG_CONFIG_HOME if set
|
|
snprintf(path, path_size, "%s/%s", xdg_config_home, CONFIG_XDG_DIR_NAME);
|
|
} else {
|
|
// Priority 3: Fall back to ~/.config
|
|
const char* home = getenv("HOME");
|
|
if (!home) {
|
|
log_error("Neither XDG_CONFIG_HOME nor HOME environment variable is set");
|
|
return -1;
|
|
}
|
|
snprintf(path, path_size, "%s/.config/%s", home, CONFIG_XDG_DIR_NAME);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int config_file_exists(void) {
|
|
struct stat st;
|
|
return (stat(g_config_manager.config_file_path, &st) == 0);
|
|
}
|
|
|
|
int load_config_from_file(void) {
|
|
log_info("Loading configuration from file...");
|
|
|
|
FILE* file = fopen(g_config_manager.config_file_path, "r");
|
|
if (!file) {
|
|
log_error("Failed to open configuration file");
|
|
return -1;
|
|
}
|
|
|
|
// Read file contents
|
|
fseek(file, 0, SEEK_END);
|
|
long file_size = ftell(file);
|
|
fseek(file, 0, SEEK_SET);
|
|
|
|
char* file_content = malloc(file_size + 1);
|
|
if (!file_content) {
|
|
log_error("Failed to allocate memory for configuration file");
|
|
fclose(file);
|
|
return -1;
|
|
}
|
|
|
|
size_t read_size = fread(file_content, 1, file_size, file);
|
|
file_content[read_size] = '\0';
|
|
fclose(file);
|
|
|
|
// Parse JSON
|
|
cJSON* json = cJSON_Parse(file_content);
|
|
free(file_content);
|
|
|
|
if (!json) {
|
|
log_error("Failed to parse configuration file as JSON");
|
|
return -1;
|
|
}
|
|
|
|
// Validate Nostr event structure
|
|
int result = validate_and_apply_config_event(json);
|
|
cJSON_Delete(json);
|
|
|
|
if (result == 0) {
|
|
log_success("Configuration loaded from file successfully");
|
|
} else {
|
|
log_error("Configuration file validation failed");
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// ================================
|
|
// NOSTR EVENT VALIDATION FUNCTIONS
|
|
// ================================
|
|
|
|
int validate_nostr_event_structure(const cJSON* event) {
|
|
if (!event || !cJSON_IsObject(event)) {
|
|
log_error("Configuration event is not a valid JSON object");
|
|
return -1;
|
|
}
|
|
|
|
// Check required fields
|
|
cJSON* kind = cJSON_GetObjectItem(event, "kind");
|
|
cJSON* created_at = cJSON_GetObjectItem(event, "created_at");
|
|
cJSON* tags = cJSON_GetObjectItem(event, "tags");
|
|
cJSON* content = cJSON_GetObjectItem(event, "content");
|
|
cJSON* pubkey = cJSON_GetObjectItem(event, "pubkey");
|
|
cJSON* id = cJSON_GetObjectItem(event, "id");
|
|
cJSON* sig = cJSON_GetObjectItem(event, "sig");
|
|
|
|
if (!kind || !cJSON_IsNumber(kind)) {
|
|
log_error("Configuration event missing or invalid 'kind' field");
|
|
return -1;
|
|
}
|
|
|
|
if (cJSON_GetNumberValue(kind) != 33334) {
|
|
log_error("Configuration event has wrong kind (expected 33334)");
|
|
return -1;
|
|
}
|
|
|
|
if (!created_at || !cJSON_IsNumber(created_at)) {
|
|
log_error("Configuration event missing or invalid 'created_at' field");
|
|
return -1;
|
|
}
|
|
|
|
if (!tags || !cJSON_IsArray(tags)) {
|
|
log_error("Configuration event missing or invalid 'tags' field");
|
|
return -1;
|
|
}
|
|
|
|
if (!content || !cJSON_IsString(content)) {
|
|
log_error("Configuration event missing or invalid 'content' field");
|
|
return -1;
|
|
}
|
|
|
|
if (!pubkey || !cJSON_IsString(pubkey)) {
|
|
log_error("Configuration event missing or invalid 'pubkey' field");
|
|
return -1;
|
|
}
|
|
|
|
if (!id || !cJSON_IsString(id)) {
|
|
log_error("Configuration event missing or invalid 'id' field");
|
|
return -1;
|
|
}
|
|
|
|
if (!sig || !cJSON_IsString(sig)) {
|
|
log_error("Configuration event missing or invalid 'sig' field");
|
|
return -1;
|
|
}
|
|
|
|
// Validate pubkey format (64 hex characters)
|
|
const char* pubkey_str = cJSON_GetStringValue(pubkey);
|
|
if (strlen(pubkey_str) != 64) {
|
|
log_error("Configuration event pubkey has invalid length");
|
|
return -1;
|
|
}
|
|
|
|
// Validate id format (64 hex characters)
|
|
const char* id_str = cJSON_GetStringValue(id);
|
|
if (strlen(id_str) != 64) {
|
|
log_error("Configuration event id has invalid length");
|
|
return -1;
|
|
}
|
|
|
|
// Validate signature format (128 hex characters)
|
|
const char* sig_str = cJSON_GetStringValue(sig);
|
|
if (strlen(sig_str) != 128) {
|
|
log_error("Configuration event signature has invalid length");
|
|
return -1;
|
|
}
|
|
|
|
log_info("Configuration event structure validation passed");
|
|
return 0;
|
|
}
|
|
|
|
int validate_config_tags(const cJSON* tags) {
|
|
if (!tags || !cJSON_IsArray(tags)) {
|
|
return -1;
|
|
}
|
|
|
|
int tag_count = 0;
|
|
const cJSON* tag = NULL;
|
|
|
|
cJSON_ArrayForEach(tag, tags) {
|
|
if (!cJSON_IsArray(tag)) {
|
|
log_error("Configuration tag is not an array");
|
|
return -1;
|
|
}
|
|
|
|
int tag_size = cJSON_GetArraySize(tag);
|
|
if (tag_size < 2) {
|
|
log_error("Configuration tag has insufficient elements");
|
|
return -1;
|
|
}
|
|
|
|
cJSON* key = cJSON_GetArrayItem(tag, 0);
|
|
cJSON* value = cJSON_GetArrayItem(tag, 1);
|
|
|
|
if (!key || !cJSON_IsString(key) || !value || !cJSON_IsString(value)) {
|
|
log_error("Configuration tag key or value is not a string");
|
|
return -1;
|
|
}
|
|
|
|
tag_count++;
|
|
}
|
|
|
|
log_info("Configuration tags validation passed (%d tags)");
|
|
printf(" Found %d configuration tags\n", tag_count);
|
|
return 0;
|
|
}
|
|
|
|
int extract_and_apply_config_tags(const cJSON* tags) {
|
|
if (!tags || !cJSON_IsArray(tags)) {
|
|
return -1;
|
|
}
|
|
|
|
int applied_count = 0;
|
|
const cJSON* tag = NULL;
|
|
|
|
cJSON_ArrayForEach(tag, tags) {
|
|
cJSON* key = cJSON_GetArrayItem(tag, 0);
|
|
cJSON* value = cJSON_GetArrayItem(tag, 1);
|
|
|
|
if (!key || !value) continue;
|
|
|
|
const char* key_str = cJSON_GetStringValue(key);
|
|
const char* value_str = cJSON_GetStringValue(value);
|
|
|
|
if (!key_str || !value_str) continue;
|
|
|
|
// Validate configuration value
|
|
config_validation_result_t validation = validate_config_value(key_str, value_str);
|
|
if (validation != CONFIG_VALID) {
|
|
log_config_validation_error(key_str, value_str, "Value failed validation");
|
|
continue;
|
|
}
|
|
|
|
// Apply configuration to database
|
|
if (set_database_config(key_str, value_str, "file") == 0) {
|
|
applied_count++;
|
|
} else {
|
|
log_error("Failed to apply configuration");
|
|
printf(" Key: %s, Value: %s\n", key_str, value_str);
|
|
}
|
|
}
|
|
|
|
if (applied_count > 0) {
|
|
log_success("Applied configuration from file");
|
|
printf(" Applied %d configuration values\n", applied_count);
|
|
return 0;
|
|
} else {
|
|
log_warning("No valid configuration values found in file");
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
int validate_and_apply_config_event(const cJSON* event) {
|
|
log_info("Validating configuration event...");
|
|
|
|
// Step 1: Validate event structure
|
|
if (validate_nostr_event_structure(event) != 0) {
|
|
return -1;
|
|
}
|
|
|
|
// Step 2: Extract and validate tags
|
|
cJSON* tags = cJSON_GetObjectItem(event, "tags");
|
|
if (validate_config_tags(tags) != 0) {
|
|
return -1;
|
|
}
|
|
|
|
// Step 3: For now, skip signature verification (would require Nostr crypto library)
|
|
// In production, this would verify the event signature against admin pubkeys
|
|
log_warning("Signature verification not yet implemented - accepting event");
|
|
|
|
// Step 4: Extract and apply configuration
|
|
if (extract_and_apply_config_tags(tags) != 0) {
|
|
return -1;
|
|
}
|
|
|
|
log_success("Configuration event validation and application completed");
|
|
return 0;
|
|
}
|
|
|
|
// ================================
|
|
// CONFIGURATION ACCESS FUNCTIONS
|
|
// ================================
|
|
|
|
const char* get_config_value(const char* key) {
|
|
static char buffer[CONFIG_VALUE_MAX_LENGTH];
|
|
|
|
if (!key) {
|
|
return NULL;
|
|
}
|
|
|
|
// Priority 1: Database configuration (updated from file)
|
|
if (get_database_config(key, buffer, sizeof(buffer)) == 0) {
|
|
return buffer;
|
|
}
|
|
|
|
// Priority 2: Environment variables (fallback)
|
|
const char* env_value = getenv(key);
|
|
if (env_value) {
|
|
return env_value;
|
|
}
|
|
|
|
// No value found
|
|
return NULL;
|
|
}
|
|
|
|
int get_config_int(const char* key, int default_value) {
|
|
const char* str_value = get_config_value(key);
|
|
if (!str_value) {
|
|
return default_value;
|
|
}
|
|
|
|
char* endptr;
|
|
long val = strtol(str_value, &endptr, 10);
|
|
|
|
if (endptr == str_value || *endptr != '\0') {
|
|
// Invalid integer format
|
|
return default_value;
|
|
}
|
|
|
|
return (int)val;
|
|
}
|
|
|
|
int get_config_bool(const char* key, int default_value) {
|
|
const char* str_value = get_config_value(key);
|
|
if (!str_value) {
|
|
return default_value;
|
|
}
|
|
|
|
// Check for boolean values
|
|
if (strcasecmp(str_value, "true") == 0 ||
|
|
strcasecmp(str_value, "yes") == 0 ||
|
|
strcasecmp(str_value, "1") == 0) {
|
|
return 1;
|
|
} else if (strcasecmp(str_value, "false") == 0 ||
|
|
strcasecmp(str_value, "no") == 0 ||
|
|
strcasecmp(str_value, "0") == 0) {
|
|
return 0;
|
|
}
|
|
|
|
return default_value;
|
|
}
|
|
|
|
int set_config_value(const char* key, const char* value) {
|
|
if (!key || !value) {
|
|
return -1;
|
|
}
|
|
|
|
return set_database_config(key, value, "api");
|
|
}
|
|
|
|
// ================================
|
|
// CONFIGURATION VALIDATION
|
|
// ================================
|
|
|
|
config_validation_result_t validate_config_value(const char* key, const char* value) {
|
|
// Placeholder for validation logic
|
|
// Will implement full validation in Phase 3
|
|
|
|
if (!key || !value) {
|
|
return CONFIG_MISSING_REQUIRED;
|
|
}
|
|
|
|
// Basic validation - all values are valid for now
|
|
return CONFIG_VALID;
|
|
}
|
|
|
|
void log_config_validation_error(const char* key, const char* value, const char* error) {
|
|
log_error("Configuration validation error");
|
|
printf(" Key: %s\n", key ? key : "NULL");
|
|
printf(" Value: %s\n", value ? value : "NULL");
|
|
printf(" Error: %s\n", error ? error : "Unknown error");
|
|
}
|
|
|
|
// ================================
|
|
// UTILITY FUNCTIONS
|
|
// ================================
|
|
|
|
const char* config_type_to_string(config_type_t type) {
|
|
switch (type) {
|
|
case CONFIG_TYPE_SYSTEM: return "system";
|
|
case CONFIG_TYPE_USER: return "user";
|
|
case CONFIG_TYPE_RUNTIME: return "runtime";
|
|
default: return "unknown";
|
|
}
|
|
}
|
|
|
|
const char* config_data_type_to_string(config_data_type_t type) {
|
|
switch (type) {
|
|
case CONFIG_DATA_STRING: return "string";
|
|
case CONFIG_DATA_INTEGER: return "integer";
|
|
case CONFIG_DATA_BOOLEAN: return "boolean";
|
|
case CONFIG_DATA_JSON: return "json";
|
|
default: return "unknown";
|
|
}
|
|
}
|
|
|
|
config_type_t string_to_config_type(const char* str) {
|
|
if (!str) return CONFIG_TYPE_USER;
|
|
|
|
if (strcmp(str, "system") == 0) return CONFIG_TYPE_SYSTEM;
|
|
if (strcmp(str, "user") == 0) return CONFIG_TYPE_USER;
|
|
if (strcmp(str, "runtime") == 0) return CONFIG_TYPE_RUNTIME;
|
|
|
|
return CONFIG_TYPE_USER;
|
|
}
|
|
|
|
config_data_type_t string_to_config_data_type(const char* str) {
|
|
if (!str) return CONFIG_DATA_STRING;
|
|
|
|
if (strcmp(str, "string") == 0) return CONFIG_DATA_STRING;
|
|
if (strcmp(str, "integer") == 0) return CONFIG_DATA_INTEGER;
|
|
if (strcmp(str, "boolean") == 0) return CONFIG_DATA_BOOLEAN;
|
|
if (strcmp(str, "json") == 0) return CONFIG_DATA_JSON;
|
|
|
|
return CONFIG_DATA_STRING;
|
|
}
|
|
|
|
int config_requires_restart(const char* key) {
|
|
if (!key) return 0;
|
|
|
|
// Check database for requires_restart flag
|
|
const char* sql = "SELECT requires_restart FROM config WHERE key = ?";
|
|
sqlite3_stmt* stmt;
|
|
|
|
int rc = sqlite3_prepare_v2(g_db, sql, -1, &stmt, NULL);
|
|
if (rc != SQLITE_OK) {
|
|
return 0;
|
|
}
|
|
|
|
sqlite3_bind_text(stmt, 1, key, -1, SQLITE_STATIC);
|
|
|
|
int requires_restart = 0;
|
|
if (sqlite3_step(stmt) == SQLITE_ROW) {
|
|
requires_restart = sqlite3_column_int(stmt, 0);
|
|
}
|
|
|
|
sqlite3_finalize(stmt);
|
|
return requires_restart;
|
|
}
|
|
|
|
// ================================
|
|
// NOSTR EVENT GENERATION FUNCTIONS
|
|
// ================================
|
|
|
|
#include <sys/stat.h>
|
|
|
|
cJSON* create_config_nostr_event(const char* privkey_hex) {
|
|
log_info("Creating configuration Nostr event...");
|
|
|
|
// Convert hex private key to bytes
|
|
unsigned char privkey_bytes[32];
|
|
if (nostr_hex_to_bytes(privkey_hex, privkey_bytes, 32) != 0) {
|
|
log_error("Failed to convert private key from hex");
|
|
return NULL;
|
|
}
|
|
|
|
// Create tags array with default configuration values
|
|
cJSON* tags = cJSON_CreateArray();
|
|
|
|
// Default configuration values (moved from schema.sql)
|
|
typedef struct {
|
|
const char* key;
|
|
const char* value;
|
|
} default_config_t;
|
|
|
|
static const default_config_t defaults[] = {
|
|
// Administrative settings
|
|
{"admin_enabled", "false"},
|
|
|
|
// Server core settings
|
|
{"relay_port", "8888"},
|
|
{"database_path", "db/c_nostr_relay.db"},
|
|
{"max_connections", "100"},
|
|
|
|
// NIP-11 Relay Information
|
|
{"relay_name", "C Nostr Relay"},
|
|
{"relay_description", "High-performance C Nostr relay with SQLite storage"},
|
|
{"relay_contact", ""},
|
|
{"relay_pubkey", ""},
|
|
{"relay_privkey", ""},
|
|
{"relay_software", "https://git.laantungir.net/laantungir/c-relay.git"},
|
|
{"relay_version", VERSION},
|
|
|
|
// NIP-13 Proof of Work
|
|
{"pow_enabled", "true"},
|
|
{"pow_min_difficulty", "0"},
|
|
{"pow_mode", "basic"},
|
|
|
|
// NIP-40 Expiration Timestamp
|
|
{"expiration_enabled", "true"},
|
|
{"expiration_strict", "true"},
|
|
{"expiration_filter", "true"},
|
|
{"expiration_grace_period", "300"},
|
|
|
|
// Subscription limits
|
|
{"max_subscriptions_per_client", "25"},
|
|
{"max_total_subscriptions", "5000"},
|
|
{"max_filters_per_subscription", "10"},
|
|
|
|
// Event processing limits
|
|
{"max_event_tags", "100"},
|
|
{"max_content_length", "8196"},
|
|
{"max_message_length", "16384"},
|
|
|
|
// Performance settings
|
|
{"default_limit", "500"},
|
|
{"max_limit", "5000"}
|
|
};
|
|
|
|
int defaults_count = sizeof(defaults) / sizeof(defaults[0]);
|
|
|
|
// First try to load from database, fall back to defaults
|
|
const char* sql = "SELECT key, value FROM config WHERE config_type IN ('system', 'user') ORDER BY key";
|
|
sqlite3_stmt* stmt;
|
|
|
|
int rc = sqlite3_prepare_v2(g_db, sql, -1, &stmt, NULL);
|
|
if (rc == SQLITE_OK) {
|
|
// Load existing values from database
|
|
while (sqlite3_step(stmt) == SQLITE_ROW) {
|
|
const char* key = (const char*)sqlite3_column_text(stmt, 0);
|
|
const char* value = (const char*)sqlite3_column_text(stmt, 1);
|
|
|
|
// Skip admin_pubkey since it's redundant (already in event.pubkey)
|
|
if (key && value && strcmp(key, "admin_pubkey") != 0) {
|
|
cJSON* tag = cJSON_CreateArray();
|
|
cJSON_AddItemToArray(tag, cJSON_CreateString(key));
|
|
cJSON_AddItemToArray(tag, cJSON_CreateString(value));
|
|
cJSON_AddItemToArray(tags, tag);
|
|
}
|
|
}
|
|
sqlite3_finalize(stmt);
|
|
}
|
|
|
|
// If database is empty, use defaults
|
|
if (cJSON_GetArraySize(tags) == 0) {
|
|
log_info("Database empty, using default configuration values");
|
|
for (int i = 0; i < defaults_count; i++) {
|
|
cJSON* tag = cJSON_CreateArray();
|
|
cJSON_AddItemToArray(tag, cJSON_CreateString(defaults[i].key));
|
|
cJSON_AddItemToArray(tag, cJSON_CreateString(defaults[i].value));
|
|
cJSON_AddItemToArray(tags, tag);
|
|
}
|
|
}
|
|
|
|
// Create and sign event using nostr_core_lib
|
|
cJSON* event = nostr_create_and_sign_event(
|
|
33334, // kind
|
|
"C Nostr Relay configuration event", // content
|
|
tags, // tags
|
|
privkey_bytes, // private key bytes for signing
|
|
time(NULL) // created_at timestamp
|
|
);
|
|
|
|
cJSON_Delete(tags); // Clean up tags as they were duplicated in nostr_create_and_sign_event
|
|
|
|
if (!event) {
|
|
log_error("Failed to create and sign configuration event");
|
|
return NULL;
|
|
}
|
|
|
|
// Log success information
|
|
cJSON* id_obj = cJSON_GetObjectItem(event, "id");
|
|
cJSON* pubkey_obj = cJSON_GetObjectItem(event, "pubkey");
|
|
|
|
if (id_obj && pubkey_obj) {
|
|
log_success("Configuration Nostr event created successfully");
|
|
printf(" Event ID: %s\n", cJSON_GetStringValue(id_obj));
|
|
printf(" Public Key: %s\n", cJSON_GetStringValue(pubkey_obj));
|
|
}
|
|
|
|
return event;
|
|
}
|
|
|
|
int write_config_event_to_file(const cJSON* event) {
|
|
if (!event) {
|
|
return -1;
|
|
}
|
|
|
|
// Ensure config directory exists
|
|
struct stat st = {0};
|
|
if (stat(g_config_manager.config_dir_path, &st) == -1) {
|
|
if (mkdir(g_config_manager.config_dir_path, 0700) != 0) {
|
|
log_error("Failed to create configuration directory");
|
|
return -1;
|
|
}
|
|
log_info("Created configuration directory: %s");
|
|
printf(" %s\n", g_config_manager.config_dir_path);
|
|
}
|
|
|
|
// Write to file with custom formatting for better readability
|
|
FILE* file = fopen(g_config_manager.config_file_path, "w");
|
|
if (!file) {
|
|
log_error("Failed to open configuration file for writing");
|
|
return -1;
|
|
}
|
|
|
|
// Custom formatting: tags first, then other fields
|
|
fprintf(file, "{\n");
|
|
|
|
// First, write tags array with each tag on its own line
|
|
cJSON* tags = cJSON_GetObjectItem(event, "tags");
|
|
if (tags && cJSON_IsArray(tags)) {
|
|
fprintf(file, " \"tags\": [\n");
|
|
int tag_count = cJSON_GetArraySize(tags);
|
|
for (int i = 0; i < tag_count; i++) {
|
|
cJSON* tag = cJSON_GetArrayItem(tags, i);
|
|
if (tag && cJSON_IsArray(tag)) {
|
|
char* tag_str = cJSON_Print(tag);
|
|
if (tag_str) {
|
|
fprintf(file, " %s%s\n", tag_str, (i < tag_count - 1) ? "," : "");
|
|
free(tag_str);
|
|
}
|
|
}
|
|
}
|
|
fprintf(file, " ],\n");
|
|
}
|
|
|
|
// Then write other fields in order
|
|
const char* field_order[] = {"id", "pubkey", "created_at", "kind", "content", "sig"};
|
|
int field_count = sizeof(field_order) / sizeof(field_order[0]);
|
|
|
|
for (int i = 0; i < field_count; i++) {
|
|
cJSON* field = cJSON_GetObjectItem(event, field_order[i]);
|
|
if (field) {
|
|
fprintf(file, " \"%s\": ", field_order[i]);
|
|
if (cJSON_IsString(field)) {
|
|
fprintf(file, "\"%s\"", cJSON_GetStringValue(field));
|
|
} else if (cJSON_IsNumber(field)) {
|
|
fprintf(file, "%ld", (long)cJSON_GetNumberValue(field));
|
|
}
|
|
if (i < field_count - 1) {
|
|
fprintf(file, ",");
|
|
}
|
|
fprintf(file, "\n");
|
|
}
|
|
}
|
|
|
|
fprintf(file, "}\n");
|
|
fclose(file);
|
|
|
|
log_success("Configuration file written successfully");
|
|
printf(" File: %s\n", g_config_manager.config_file_path);
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Helper function to generate random private key
|
|
int generate_random_private_key(char* privkey_hex, size_t buffer_size) {
|
|
if (!privkey_hex || buffer_size < 65) {
|
|
return -1;
|
|
}
|
|
|
|
FILE* urandom = fopen("/dev/urandom", "rb");
|
|
if (!urandom) {
|
|
log_error("Failed to open /dev/urandom for key generation");
|
|
return -1;
|
|
}
|
|
|
|
unsigned char privkey_bytes[32];
|
|
if (fread(privkey_bytes, 1, 32, urandom) != 32) {
|
|
log_error("Failed to read random bytes for private key");
|
|
fclose(urandom);
|
|
return -1;
|
|
}
|
|
fclose(urandom);
|
|
|
|
// Convert to hex
|
|
nostr_bytes_to_hex(privkey_bytes, 32, privkey_hex);
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Helper function to derive public key from private key
|
|
int derive_public_key(const char* privkey_hex, char* pubkey_hex, size_t buffer_size) {
|
|
if (!privkey_hex || !pubkey_hex || buffer_size < 65) {
|
|
return -1;
|
|
}
|
|
|
|
// Convert hex private key to bytes
|
|
unsigned char privkey_bytes[32];
|
|
if (nostr_hex_to_bytes(privkey_hex, privkey_bytes, 32) != 0) {
|
|
log_error("Failed to convert private key from hex");
|
|
return -1;
|
|
}
|
|
|
|
// Generate corresponding public key
|
|
unsigned char pubkey_bytes[32];
|
|
if (nostr_ec_public_key_from_private_key(privkey_bytes, pubkey_bytes) == 0) {
|
|
nostr_bytes_to_hex(pubkey_bytes, 32, pubkey_hex);
|
|
return 0;
|
|
} else {
|
|
log_error("Failed to derive public key from private key");
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
int generate_config_file_if_missing(void) {
|
|
// Check if config file already exists
|
|
if (config_file_exists()) {
|
|
log_info("Configuration file already exists, skipping generation");
|
|
return 0;
|
|
}
|
|
|
|
log_info("Generating missing configuration file...");
|
|
|
|
// Generate or get admin private key for configuration signing
|
|
char admin_privkey_hex[65];
|
|
const char* env_admin_privkey = getenv(CONFIG_ADMIN_PRIVKEY_ENV);
|
|
|
|
if (env_admin_privkey && strlen(env_admin_privkey) == 64) {
|
|
// Use provided admin private key
|
|
strncpy(admin_privkey_hex, env_admin_privkey, sizeof(admin_privkey_hex) - 1);
|
|
admin_privkey_hex[sizeof(admin_privkey_hex) - 1] = '\0';
|
|
log_info("Using admin private key from environment variable");
|
|
} else {
|
|
// Generate random admin private key
|
|
if (generate_random_private_key(admin_privkey_hex, sizeof(admin_privkey_hex)) != 0) {
|
|
log_error("Failed to generate admin private key");
|
|
return -1;
|
|
}
|
|
log_info("Generated random admin private key for configuration signing");
|
|
}
|
|
|
|
// Generate or get relay private key for relay identity
|
|
char relay_privkey_hex[65];
|
|
const char* env_relay_privkey = getenv(CONFIG_RELAY_PRIVKEY_ENV);
|
|
|
|
if (env_relay_privkey && strlen(env_relay_privkey) == 64) {
|
|
// Use provided relay private key
|
|
strncpy(relay_privkey_hex, env_relay_privkey, sizeof(relay_privkey_hex) - 1);
|
|
relay_privkey_hex[sizeof(relay_privkey_hex) - 1] = '\0';
|
|
log_info("Using relay private key from environment variable");
|
|
} else {
|
|
// Generate random relay private key
|
|
if (generate_random_private_key(relay_privkey_hex, sizeof(relay_privkey_hex)) != 0) {
|
|
log_error("Failed to generate relay private key");
|
|
return -1;
|
|
}
|
|
log_info("Generated random relay private key for relay identity");
|
|
}
|
|
|
|
// Derive public keys from private keys
|
|
char admin_pubkey_hex[65];
|
|
char relay_pubkey_hex[65];
|
|
|
|
if (derive_public_key(admin_privkey_hex, admin_pubkey_hex, sizeof(admin_pubkey_hex)) != 0) {
|
|
log_error("Failed to derive admin public key");
|
|
return -1;
|
|
}
|
|
|
|
if (derive_public_key(relay_privkey_hex, relay_pubkey_hex, sizeof(relay_pubkey_hex)) != 0) {
|
|
log_error("Failed to derive relay public key");
|
|
return -1;
|
|
}
|
|
|
|
// Display both keypairs prominently for the administrator
|
|
printf("\n");
|
|
printf("=================================================================\n");
|
|
printf("IMPORTANT: GENERATED RELAY KEYPAIRS\n");
|
|
printf("=================================================================\n");
|
|
printf("ADMIN KEYS (for configuration signing):\n");
|
|
printf(" Private Key: %s\n", admin_privkey_hex);
|
|
printf(" Public Key: %s\n", admin_pubkey_hex);
|
|
printf("\nRELAY KEYS (for relay identity):\n");
|
|
printf(" Private Key: %s\n", relay_privkey_hex);
|
|
printf(" Public Key: %s\n", relay_pubkey_hex);
|
|
printf("\nSAVE THESE PRIVATE KEYS SECURELY!\n");
|
|
printf("\nTo use specific keys in future sessions:\n");
|
|
printf(" export %s=%s\n", CONFIG_ADMIN_PRIVKEY_ENV, admin_privkey_hex);
|
|
printf(" export %s=%s\n", CONFIG_RELAY_PRIVKEY_ENV, relay_privkey_hex);
|
|
printf("=================================================================\n");
|
|
printf("\n");
|
|
|
|
// Default configuration values (same as in create_config_nostr_event)
|
|
typedef struct {
|
|
const char* key;
|
|
const char* value;
|
|
} default_config_t;
|
|
|
|
static const default_config_t defaults[] = {
|
|
// Administrative settings
|
|
{"admin_enabled", "false"},
|
|
|
|
// Server core settings
|
|
{"relay_port", "8888"},
|
|
{"database_path", "db/c_nostr_relay.db"},
|
|
{"max_connections", "100"},
|
|
|
|
// NIP-11 Relay Information
|
|
{"relay_name", "C Nostr Relay"},
|
|
{"relay_description", "High-performance C Nostr relay with SQLite storage"},
|
|
{"relay_contact", ""},
|
|
{"relay_software", "https://git.laantungir.net/laantungir/c-relay.git"},
|
|
{"relay_version", VERSION},
|
|
|
|
// NIP-13 Proof of Work
|
|
{"pow_enabled", "true"},
|
|
{"pow_min_difficulty", "0"},
|
|
{"pow_mode", "basic"},
|
|
|
|
// NIP-40 Expiration Timestamp
|
|
{"expiration_enabled", "true"},
|
|
{"expiration_strict", "true"},
|
|
{"expiration_filter", "true"},
|
|
{"expiration_grace_period", "300"},
|
|
|
|
// Subscription limits
|
|
{"max_subscriptions_per_client", "25"},
|
|
{"max_total_subscriptions", "5000"},
|
|
{"max_filters_per_subscription", "10"},
|
|
|
|
// Event processing limits
|
|
{"max_event_tags", "100"},
|
|
{"max_content_length", "8196"},
|
|
{"max_message_length", "16384"},
|
|
|
|
// Performance settings
|
|
{"default_limit", "500"},
|
|
{"max_limit", "5000"}
|
|
};
|
|
|
|
int defaults_count = sizeof(defaults) / sizeof(defaults[0]);
|
|
|
|
// Store all three keys and all default configuration values in database
|
|
if (set_database_config("admin_pubkey", admin_pubkey_hex, "system") == 0) {
|
|
log_info("Stored admin public key in configuration database");
|
|
} else {
|
|
log_warning("Failed to store admin public key in database");
|
|
}
|
|
|
|
if (set_database_config("relay_privkey", relay_privkey_hex, "system") == 0) {
|
|
log_info("Stored relay private key in configuration database");
|
|
} else {
|
|
log_warning("Failed to store relay private key in database");
|
|
}
|
|
|
|
if (set_database_config("relay_pubkey", relay_pubkey_hex, "system") == 0) {
|
|
log_info("Stored relay public key in configuration database");
|
|
} else {
|
|
log_warning("Failed to store relay public key in database");
|
|
}
|
|
|
|
// Store all default configuration values
|
|
log_info("Storing default configuration values in database...");
|
|
int stored_count = 0;
|
|
for (int i = 0; i < defaults_count; i++) {
|
|
if (set_database_config(defaults[i].key, defaults[i].value, "system") == 0) {
|
|
stored_count++;
|
|
} else {
|
|
log_warning("Failed to store default configuration");
|
|
printf(" Key: %s, Value: %s\n", defaults[i].key, defaults[i].value);
|
|
}
|
|
}
|
|
|
|
if (stored_count == defaults_count) {
|
|
log_success("All default configuration values stored successfully");
|
|
printf(" Stored %d configuration entries\n", stored_count);
|
|
} else {
|
|
log_warning("Some default configuration values failed to store");
|
|
printf(" Stored %d of %d configuration entries\n", stored_count, defaults_count);
|
|
}
|
|
|
|
// Create Nostr event using admin private key for signing
|
|
cJSON* event = create_config_nostr_event(admin_privkey_hex);
|
|
if (!event) {
|
|
log_error("Failed to create configuration event");
|
|
return -1;
|
|
}
|
|
|
|
// Write to file
|
|
int result = write_config_event_to_file(event);
|
|
cJSON_Delete(event);
|
|
|
|
if (result == 0) {
|
|
log_success("Configuration file generated successfully");
|
|
} else {
|
|
log_error("Failed to write configuration file");
|
|
}
|
|
|
|
return result;
|
|
} |