laantungir/c-relay
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 7 Wiki Activity

v0.7.13 - -t

Browse Source
This commit is contained in:
Your Name
2025-10-13 16:35:26 -04:00
parent e3938a2c85
commit 62e17af311
14 changed files with 1905 additions and 172 deletions
Download Patch File Download Diff File Expand all files Collapse all files

563
src/config.c
View File

@@ -63,6 +63,7 @@ typedef enum {
// Forward declarations for new admin API functions
int populate_default_config_values(void);
int populate_all_config_values_atomic(const char* admin_pubkey, const char* relay_pubkey);
int process_admin_config_event(cJSON* event, char* error_message, size_t error_size);
void invalidate_config_cache(void);
@@ -220,6 +221,8 @@ static int refresh_unified_cache_from_table(void) {
return -1;
}
DEBUG_LOG("Starting unified cache refresh from database");
// Log config table row count at start of refresh_unified_cache_from_table
sqlite3_stmt* count_stmt;
const char* count_sql = "SELECT COUNT(*) FROM config";
@@ -236,30 +239,50 @@ static int refresh_unified_cache_from_table(void) {
// Load critical config values from table
const char* admin_pubkey = get_config_value_from_table("admin_pubkey");
DEBUG_TRACE("get_config_value_from_table('admin_pubkey') returned: %s",
admin_pubkey ? admin_pubkey : "NULL");
DEBUG_LOG("Loading admin_pubkey from config table: %s", admin_pubkey ? admin_pubkey : "NULL");
if (admin_pubkey) {
DEBUG_LOG("Setting admin_pubkey in cache: %s", admin_pubkey);
strncpy(g_unified_cache.admin_pubkey, admin_pubkey, sizeof(g_unified_cache.admin_pubkey) - 1);
g_unified_cache.admin_pubkey[sizeof(g_unified_cache.admin_pubkey) - 1] = '\0';
DEBUG_TRACE("Set admin_pubkey in cache: %s", g_unified_cache.admin_pubkey);
free((char*)admin_pubkey);
} else {
DEBUG_LOG("No admin_pubkey found in config table");
}
const char* relay_pubkey = get_config_value_from_table("relay_pubkey");
DEBUG_TRACE("get_config_value_from_table('relay_pubkey') returned: %s",
relay_pubkey ? relay_pubkey : "NULL");
DEBUG_LOG("Loading relay_pubkey from config table: %s", relay_pubkey ? relay_pubkey : "NULL");
if (relay_pubkey) {
DEBUG_LOG("Setting relay_pubkey in cache: %s", relay_pubkey);
strncpy(g_unified_cache.relay_pubkey, relay_pubkey, sizeof(g_unified_cache.relay_pubkey) - 1);
g_unified_cache.relay_pubkey[sizeof(g_unified_cache.relay_pubkey) - 1] = '\0';
DEBUG_TRACE("Set relay_pubkey in cache: %s", g_unified_cache.relay_pubkey);
free((char*)relay_pubkey);
} else {
DEBUG_LOG("No relay_pubkey found in config table");
}
// Load auth-related config
const char* auth_required = get_config_value_from_table("auth_required");
g_unified_cache.auth_required = (auth_required && strcmp(auth_required, "true") == 0) ? 1 : 0;
DEBUG_TRACE("Loaded auth_required from table: %s (cache value: %d)",
auth_required ? auth_required : "NULL", g_unified_cache.auth_required);
if (auth_required) free((char*)auth_required);
const char* admin_enabled = get_config_value_from_table("admin_enabled");
g_unified_cache.admin_enabled = (admin_enabled && strcmp(admin_enabled, "true") == 0) ? 1 : 0;
DEBUG_TRACE("Loaded admin_enabled from table: %s (cache value: %d)",
admin_enabled ? admin_enabled : "NULL", g_unified_cache.admin_enabled);
if (admin_enabled) free((char*)admin_enabled);
const char* max_file_size = get_config_value_from_table("max_file_size");
g_unified_cache.max_file_size = max_file_size ? atol(max_file_size) : 104857600; // 100MB default
DEBUG_TRACE("Loaded max_file_size from table: %s (cache value: %ld)",
max_file_size ? max_file_size : "NULL", g_unified_cache.max_file_size);
if (max_file_size) free((char*)max_file_size);
const char* nip42_mode = get_config_value_from_table("nip42_mode");
@@ -271,6 +294,8 @@ static int refresh_unified_cache_from_table(void) {
} else {
g_unified_cache.nip42_mode = 1; // Optional/enabled
}
DEBUG_TRACE("Loaded nip42_mode from table: %s (cache value: %d)",
nip42_mode, g_unified_cache.nip42_mode);
free((char*)nip42_mode);
} else {
g_unified_cache.nip42_mode = 1; // Default to optional/enabled
@@ -287,6 +312,8 @@ static int refresh_unified_cache_from_table(void) {
// Load NIP-70 protected events config
const char* nip70_enabled = get_config_value_from_table("nip70_protected_events_enabled");
g_unified_cache.nip70_protected_events_enabled = (nip70_enabled && strcmp(nip70_enabled, "true") == 0) ? 1 : 0;
DEBUG_TRACE("Loaded nip70_protected_events_enabled from table: %s (cache value: %d)",
nip70_enabled ? nip70_enabled : "NULL", g_unified_cache.nip70_protected_events_enabled);
if (nip70_enabled) free((char*)nip70_enabled);
// Load NIP-11 relay info fields directly into cache (avoid circular dependency)
@@ -368,6 +395,9 @@ static int refresh_unified_cache_from_table(void) {
pthread_mutex_unlock(&g_unified_cache.cache_lock);
DEBUG_LOG("Configuration cache refreshed (%d entries)", config_count);
DEBUG_LOG("Final cache state - admin_pubkey: %s, relay_pubkey: %s",
g_unified_cache.admin_pubkey[0] ? g_unified_cache.admin_pubkey : "EMPTY",
g_unified_cache.relay_pubkey[0] ? g_unified_cache.relay_pubkey : "EMPTY");
// Log config table row count at end of refresh_unified_cache_from_table
if (sqlite3_prepare_v2(g_db, count_sql, -1, &count_stmt, NULL) == SQLITE_OK) {
@@ -381,44 +411,131 @@ static int refresh_unified_cache_from_table(void) {
return 0;
}
// Get admin pubkey from cache (with automatic refresh)
const char* get_admin_pubkey_cached(void) {
// First check without holding lock: whether we need refresh
// Unified cache getter function - handles all config values through unified cache
const char* get_cached_config_value(const char* key) {
if (!key) {
return NULL;
}
// Check cache validity and refresh if needed
pthread_mutex_lock(&g_unified_cache.cache_lock);
int need_refresh = (!g_unified_cache.cache_valid || time(NULL) > g_unified_cache.cache_expires);
pthread_mutex_unlock(&g_unified_cache.cache_lock);
if (need_refresh) {
// Perform refresh, which locks internally
DEBUG_TRACE("Cache refresh needed for key '%s', calling refresh_unified_cache_from_table()", key);
refresh_unified_cache_from_table();
}
// Now read under lock
// Return value from cache based on key
pthread_mutex_lock(&g_unified_cache.cache_lock);
const char* result = g_unified_cache.admin_pubkey[0] ? g_unified_cache.admin_pubkey : NULL;
const char* result = NULL;
// Handle string fields from unified cache
if (strcmp(key, "admin_pubkey") == 0) {
result = g_unified_cache.admin_pubkey[0] ? g_unified_cache.admin_pubkey : NULL;
DEBUG_TRACE("Returning admin_pubkey from cache: %s", result ? result : "NULL");
} else if (strcmp(key, "relay_pubkey") == 0) {
result = g_unified_cache.relay_pubkey[0] ? g_unified_cache.relay_pubkey : NULL;
DEBUG_TRACE("Returning relay_pubkey from cache: %s", result ? result : "NULL");
} else if (strcmp(key, "relay_name") == 0) {
result = g_unified_cache.relay_info.name[0] ? g_unified_cache.relay_info.name : NULL;
DEBUG_TRACE("Returning relay_name from cache: %s", result ? result : "NULL");
} else if (strcmp(key, "relay_description") == 0) {
result = g_unified_cache.relay_info.description[0] ? g_unified_cache.relay_info.description : NULL;
DEBUG_TRACE("Returning relay_description from cache: %s", result ? result : "NULL");
} else if (strcmp(key, "relay_contact") == 0) {
result = g_unified_cache.relay_info.contact[0] ? g_unified_cache.relay_info.contact : NULL;
DEBUG_TRACE("Returning relay_contact from cache: %s", result ? result : "NULL");
} else if (strcmp(key, "relay_software") == 0) {
result = g_unified_cache.relay_info.software[0] ? g_unified_cache.relay_info.software : NULL;
DEBUG_TRACE("Returning relay_software from cache: %s", result ? result : "NULL");
} else if (strcmp(key, "relay_version") == 0) {
result = g_unified_cache.relay_info.version[0] ? g_unified_cache.relay_info.version : NULL;
DEBUG_TRACE("Returning relay_version from cache: %s", result ? result : "NULL");
} else if (strcmp(key, "supported_nips") == 0) {
result = g_unified_cache.relay_info.supported_nips_str[0] ? g_unified_cache.relay_info.supported_nips_str : NULL;
DEBUG_TRACE("Returning supported_nips from cache: %s", result ? result : "NULL");
} else if (strcmp(key, "language_tags") == 0) {
result = g_unified_cache.relay_info.language_tags_str[0] ? g_unified_cache.relay_info.language_tags_str : NULL;
DEBUG_TRACE("Returning language_tags from cache: %s", result ? result : "NULL");
} else if (strcmp(key, "relay_countries") == 0) {
result = g_unified_cache.relay_info.relay_countries_str[0] ? g_unified_cache.relay_info.relay_countries_str : NULL;
DEBUG_TRACE("Returning relay_countries from cache: %s", result ? result : "NULL");
} else if (strcmp(key, "posting_policy") == 0) {
result = g_unified_cache.relay_info.posting_policy[0] ? g_unified_cache.relay_info.posting_policy : NULL;
DEBUG_TRACE("Returning posting_policy from cache: %s", result ? result : "NULL");
} else if (strcmp(key, "payments_url") == 0) {
result = g_unified_cache.relay_info.payments_url[0] ? g_unified_cache.relay_info.payments_url : NULL;
DEBUG_TRACE("Returning payments_url from cache: %s", result ? result : "NULL");
} else {
DEBUG_TRACE("Key '%s' not found in unified cache", key);
}
pthread_mutex_unlock(&g_unified_cache.cache_lock);
return result;
}
// Get relay pubkey from cache (with automatic refresh)
const char* get_relay_pubkey_cached(void) {
// First check without holding lock: whether we need refresh
// Get integer config value from unified cache
int get_cached_config_int(const char* key, int default_value) {
if (!key) {
return default_value;
}
// Check cache validity and refresh if needed
pthread_mutex_lock(&g_unified_cache.cache_lock);
int need_refresh = (!g_unified_cache.cache_valid || time(NULL) > g_unified_cache.cache_expires);
pthread_mutex_unlock(&g_unified_cache.cache_lock);
if (need_refresh) {
// Perform refresh, which locks internally
DEBUG_TRACE("Cache refresh needed for int key '%s'", key);
refresh_unified_cache_from_table();
}
// Now read under lock
// Return value from cache based on key
pthread_mutex_lock(&g_unified_cache.cache_lock);
const char* result = g_unified_cache.relay_pubkey[0] ? g_unified_cache.relay_pubkey : NULL;
int result = default_value;
// Handle integer fields from unified cache
if (strcmp(key, "auth_required") == 0) {
result = g_unified_cache.auth_required;
DEBUG_TRACE("Returning auth_required from cache: %d", result);
} else if (strcmp(key, "admin_enabled") == 0) {
result = g_unified_cache.admin_enabled;
DEBUG_TRACE("Returning admin_enabled from cache: %d", result);
} else if (strcmp(key, "max_file_size") == 0) {
result = g_unified_cache.max_file_size;
DEBUG_TRACE("Returning max_file_size from cache: %d", result);
} else if (strcmp(key, "nip42_mode") == 0) {
result = g_unified_cache.nip42_mode;
DEBUG_TRACE("Returning nip42_mode from cache: %d", result);
} else if (strcmp(key, "nip42_challenge_timeout") == 0) {
result = g_unified_cache.nip42_challenge_timeout;
DEBUG_TRACE("Returning nip42_challenge_timeout from cache: %d", result);
} else if (strcmp(key, "nip42_time_tolerance") == 0) {
result = g_unified_cache.nip42_time_tolerance;
DEBUG_TRACE("Returning nip42_time_tolerance from cache: %d", result);
} else if (strcmp(key, "nip70_protected_events_enabled") == 0) {
result = g_unified_cache.nip70_protected_events_enabled;
DEBUG_TRACE("Returning nip70_protected_events_enabled from cache: %d", result);
} else {
DEBUG_TRACE("Integer key '%s' not found in unified cache, using default: %d", key, default_value);
}
pthread_mutex_unlock(&g_unified_cache.cache_lock);
return result;
}
// Get boolean config value from unified cache
int get_cached_config_bool(const char* key, int default_value) {
// Boolean values are stored as integers (0/1) in the cache
return get_cached_config_int(key, default_value);
}
// ================================
// UTILITY FUNCTIONS
// ================================
@@ -606,64 +723,34 @@ const char* get_config_value(const char* key) {
return NULL;
}
// Special fast path for frequently accessed keys via unified cache
if (strcmp(key, "admin_pubkey") == 0) {
const char* cached_value = get_admin_pubkey_cached();
return safe_strdup_from_static(cached_value);
}
if (strcmp(key, "relay_pubkey") == 0) {
const char* cached_value = get_relay_pubkey_cached();
// Try unified cache first for all supported keys
const char* cached_value = get_cached_config_value(key);
if (cached_value) {
return safe_strdup_from_static(cached_value);
}
// For other keys, try config table first
// For other keys, try config table directly
const char* table_value = get_config_value_from_table(key);
if (table_value) {
return table_value;
}
// Fallback to legacy event-based config for backward compatibility
// Use unified cache buffer instead of static buffer
if (!g_current_config) {
return NULL;
}
// Look for key in current configuration tags
cJSON* tags = cJSON_GetObjectItem(g_current_config, "tags");
if (!tags || !cJSON_IsArray(tags)) {
return NULL;
}
pthread_mutex_lock(&g_unified_cache.cache_lock);
cJSON* tag = NULL;
cJSON_ArrayForEach(tag, tags) {
if (cJSON_IsArray(tag) && cJSON_GetArraySize(tag) >= 2) {
cJSON* tag_key = cJSON_GetArrayItem(tag, 0);
cJSON* tag_value = cJSON_GetArrayItem(tag, 1);
if (tag_key && tag_value &&
cJSON_IsString(tag_key) && cJSON_IsString(tag_value)) {
if (strcmp(cJSON_GetStringValue(tag_key), key) == 0) {
strncpy(g_unified_cache.temp_buffer, cJSON_GetStringValue(tag_value),
sizeof(g_unified_cache.temp_buffer) - 1);
g_unified_cache.temp_buffer[sizeof(g_unified_cache.temp_buffer) - 1] = '\0';
const char* result = safe_strdup_from_static(g_unified_cache.temp_buffer);
pthread_mutex_unlock(&g_unified_cache.cache_lock);
return result;
}
}
}
}
pthread_mutex_unlock(&g_unified_cache.cache_lock);
return NULL;
}
int get_config_int(const char* key, int default_value) {
// Try unified cache first for integer values
if (strcmp(key, "auth_required") == 0 ||
strcmp(key, "admin_enabled") == 0 ||
strcmp(key, "max_file_size") == 0 ||
strcmp(key, "nip42_mode") == 0 ||
strcmp(key, "nip42_challenge_timeout") == 0 ||
strcmp(key, "nip42_time_tolerance") == 0 ||
strcmp(key, "nip70_protected_events_enabled") == 0) {
return get_cached_config_int(key, default_value);
}
// Fall back to string parsing for other keys
const char* str_value = get_config_value(key);
if (!str_value) {
return default_value;
@@ -684,6 +771,14 @@ int get_config_int(const char* key, int default_value) {
}
int get_config_bool(const char* key, int default_value) {
// Try unified cache first for boolean values
if (strcmp(key, "auth_required") == 0 ||
strcmp(key, "admin_enabled") == 0 ||
strcmp(key, "nip70_protected_events_enabled") == 0) {
return get_cached_config_bool(key, default_value);
}
// Fall back to string parsing for other keys
const char* str_value = get_config_value(key);
if (!str_value) {
return default_value;
@@ -1258,13 +1353,23 @@ int first_time_startup_sequence(const cli_options_t* cli_options) {
strncpy(g_temp_relay_privkey, relay_privkey, sizeof(g_temp_relay_privkey) - 1);
g_temp_relay_privkey[sizeof(g_temp_relay_privkey) - 1] = '\0';
// 6. Handle configuration setup - defaults will be populated after database initialization
// 6. Populate complete config table with all values atomically
if (populate_all_config_values_atomic(admin_pubkey, relay_pubkey) != 0) {
DEBUG_ERROR("Failed to populate complete config table");
return -1;
}
// 7. Apply CLI overrides atomically (after complete config table exists)
if (apply_cli_overrides_atomic(cli_options) != 0) {
DEBUG_ERROR("Failed to apply CLI overrides");
return -1;
}
// CLI overrides will be applied after database initialization in main.c
// This prevents "g_db is NULL" errors during first-time startup
// 8. Store relay private key in temporary storage for later secure storage
strncpy(g_temp_relay_privkey, relay_privkey, sizeof(g_temp_relay_privkey) - 1);
g_temp_relay_privkey[sizeof(g_temp_relay_privkey) - 1] = '\0';
// 10. Print admin private key for user to save (only if we generated a new key)
// 9. Print admin private key for user to save (only if we generated a new key)
if (generated_admin_key) {
printf("\n");
printf("=================================================================\n");
@@ -1294,7 +1399,7 @@ int first_time_startup_sequence(const cli_options_t* cli_options) {
return 0;
}
int startup_existing_relay(const char* relay_pubkey) {
int startup_existing_relay(const char* relay_pubkey, const cli_options_t* cli_options) {
if (!relay_pubkey) {
DEBUG_ERROR("Invalid relay pubkey for existing relay startup");
return -1;
@@ -1302,28 +1407,16 @@ int startup_existing_relay(const char* relay_pubkey) {
printf(" Relay pubkey: %s\n", relay_pubkey);
// Log config table row count at start of startup_existing_relay
if (g_db) {
sqlite3_stmt* count_stmt;
const char* count_sql = "SELECT COUNT(*) FROM config";
if (sqlite3_prepare_v2(g_db, count_sql, -1, &count_stmt, NULL) == SQLITE_OK) {
if (sqlite3_step(count_stmt) == SQLITE_ROW) {
// Row count check completed
}
sqlite3_finalize(count_stmt);
}
}
// Store relay pubkey in unified cache
pthread_mutex_lock(&g_unified_cache.cache_lock);
strncpy(g_unified_cache.relay_pubkey, relay_pubkey, sizeof(g_unified_cache.relay_pubkey) - 1);
g_unified_cache.relay_pubkey[sizeof(g_unified_cache.relay_pubkey) - 1] = '\0';
// Mark cache as valid to prevent premature refresh from database before it's initialized
int cache_timeout = get_cache_timeout();
g_unified_cache.cache_expires = time(NULL) + cache_timeout;
g_unified_cache.cache_valid = 1;
pthread_mutex_unlock(&g_unified_cache.cache_lock);
// Set database path
@@ -1337,19 +1430,28 @@ int startup_existing_relay(const char* relay_pubkey) {
g_database_path[sizeof(g_database_path) - 1] = '\0';
free(db_name);
// NOTE: admin_pubkey will be loaded from config table after database initialization
// in main.c by calling add_pubkeys_to_config_table() which handles migration
// NOTE: Database is already initialized in main.c before calling this function
// Config table should already exist with complete configuration
// Log config table row count at end of startup_existing_relay
if (g_db) {
sqlite3_stmt* count_stmt;
const char* count_sql = "SELECT COUNT(*) FROM config";
if (sqlite3_prepare_v2(g_db, count_sql, -1, &count_stmt, NULL) == SQLITE_OK) {
if (sqlite3_step(count_stmt) == SQLITE_ROW) {
// Row count check completed
}
sqlite3_finalize(count_stmt);
// Check if CLI overrides need to be applied
int has_overrides = 0;
if (cli_options) {
if (cli_options->port_override > 0) has_overrides = 1;
if (cli_options->admin_pubkey_override[0] != '\0') has_overrides = 1;
if (cli_options->relay_privkey_override[0] != '\0') has_overrides = 1;
}
if (has_overrides) {
// Apply CLI overrides to existing database
DEBUG_INFO("Applying CLI overrides to existing database");
if (apply_cli_overrides_atomic(cli_options) != 0) {
DEBUG_ERROR("Failed to apply CLI overrides to existing database");
return -1;
}
} else {
// No CLI overrides - load cache immediately from existing config table
DEBUG_INFO("No CLI overrides - loading cache immediately from existing config table");
refresh_unified_cache_from_table();
}
return 0;
@@ -1829,7 +1931,7 @@ int process_configuration_event(const cJSON* event) {
// Verify it's from the admin
const char* event_pubkey = cJSON_GetStringValue(pubkey_obj);
const char* admin_pubkey = get_admin_pubkey_cached();
const char* admin_pubkey = get_config_value("admin_pubkey");
if (admin_pubkey && strlen(admin_pubkey) > 0) {
if (strcmp(event_pubkey, admin_pubkey) != 0) {
DEBUG_ERROR("Configuration event not from authorized admin");
@@ -2003,7 +2105,7 @@ int apply_configuration_from_event(const cJSON* event) {
cJSON* pubkey_obj = cJSON_GetObjectItem(event, "pubkey");
if (pubkey_obj) {
const char* event_pubkey = cJSON_GetStringValue(pubkey_obj);
const char* cached_admin_pubkey = get_admin_pubkey_cached();
const char* cached_admin_pubkey = get_config_value("admin_pubkey");
if (!cached_admin_pubkey || strlen(cached_admin_pubkey) == 0) {
// Update cache with admin pubkey from event
pthread_mutex_lock(&g_unified_cache.cache_lock);
@@ -2154,7 +2256,9 @@ int update_config_in_table(const char* key, const char* value) {
return (rc == SQLITE_DONE) ? 0 : -1;
}
// Populate default config values (only inserts missing keys, doesn't replace existing)
// DEPRECATED: This function is no longer used in the unified startup flow.
// The new populate_all_config_values_atomic() function handles all config creation atomically.
// This function is kept for backward compatibility but should not be called in new code.
int populate_default_config_values(void) {
DEBUG_TRACE("Entering populate_default_config_values()");
@@ -2318,7 +2422,9 @@ int populate_default_config_values(void) {
return 0;
}
// Add dynamically generated pubkeys to config table
// DEPRECATED: This function is no longer used in the unified startup flow.
// The new populate_all_config_values_atomic() function handles pubkey storage atomically.
// This function is kept for backward compatibility but should not be called in new code.
int add_pubkeys_to_config_table(void) {
if (!g_db) {
DEBUG_ERROR("Database not available for pubkey storage");
@@ -2345,67 +2451,73 @@ int add_pubkeys_to_config_table(void) {
// For existing relays, admin_pubkey might already be in the database but not in cache yet
// Try to load it from the database config table first
const char* admin_pubkey_from_db = NULL;
if (!admin_pubkey_cache || strlen(admin_pubkey_cache) != 64) {
admin_pubkey_from_db = get_config_value_from_table("admin_pubkey");
if (admin_pubkey_from_db && strlen(admin_pubkey_from_db) == 64) {
// Update cache with the value from config table
pthread_mutex_lock(&g_unified_cache.cache_lock);
strncpy(g_unified_cache.admin_pubkey, admin_pubkey_from_db, sizeof(g_unified_cache.admin_pubkey) - 1);
g_unified_cache.admin_pubkey[sizeof(g_unified_cache.admin_pubkey) - 1] = '\0';
pthread_mutex_unlock(&g_unified_cache.cache_lock);
DEBUG_INFO("✓ Loaded admin_pubkey from config table into cache");
// Free the allocated string and return success - pubkey already in table
free((char*)admin_pubkey_from_db);
return 0;
}
if (admin_pubkey_from_db) {
free((char*)admin_pubkey_from_db);
}
DEBUG_LOG("Checking for existing admin_pubkey in config table");
const char* admin_pubkey_from_db = get_config_value_from_table("admin_pubkey");
DEBUG_TRACE("get_config_value_from_table('admin_pubkey') returned: %s (length: %zu)",
admin_pubkey_from_db ? admin_pubkey_from_db : "NULL",
admin_pubkey_from_db ? strlen(admin_pubkey_from_db) : 0);
DEBUG_LOG("get_config_value_from_table returned: %s", admin_pubkey_from_db ? admin_pubkey_from_db : "NULL");
if (admin_pubkey_from_db && strlen(admin_pubkey_from_db) == 64) {
DEBUG_LOG("Found valid admin_pubkey in config table: %s", admin_pubkey_from_db);
// Update cache with the value from config table
pthread_mutex_lock(&g_unified_cache.cache_lock);
strncpy(g_unified_cache.admin_pubkey, admin_pubkey_from_db, sizeof(g_unified_cache.admin_pubkey) - 1);
g_unified_cache.admin_pubkey[sizeof(g_unified_cache.admin_pubkey) - 1] = '\0';
DEBUG_TRACE("Loaded admin_pubkey from config table into cache: %s", g_unified_cache.admin_pubkey);
pthread_mutex_unlock(&g_unified_cache.cache_lock);
DEBUG_INFO("✓ Loaded admin_pubkey from config table into cache");
// Free the allocated string and return success - pubkey already in table
free((char*)admin_pubkey_from_db);
return 0;
} else {
DEBUG_LOG("No valid admin_pubkey found in config table (length: %zu)", admin_pubkey_from_db ? strlen(admin_pubkey_from_db) : 0);
}
if (admin_pubkey_from_db) {
free((char*)admin_pubkey_from_db);
}
// If not in config table, try loading from old event-based config (migration scenario)
const char* sql = "SELECT pubkey FROM events WHERE kind = 33334 ORDER BY created_at DESC LIMIT 1";
sqlite3_stmt* stmt;
int rc = sqlite3_prepare_v2(g_db, sql, -1, &stmt, NULL);
if (rc == SQLITE_OK) {
if (sqlite3_step(stmt) == SQLITE_ROW) {
const char* event_pubkey = (const char*)sqlite3_column_text(stmt, 0);
if (event_pubkey && strlen(event_pubkey) == 64) {
// Store in config table for future use
if (set_config_value_in_table("admin_pubkey", event_pubkey, "string",
"Administrator public key", "authentication", 0) == 0) {
// If not in config table, try loading from old event-based config (migration scenario)
const char* sql = "SELECT pubkey FROM events WHERE kind = 33334 ORDER BY created_at DESC LIMIT 1";
sqlite3_stmt* stmt;
// Update cache
pthread_mutex_lock(&g_unified_cache.cache_lock);
strncpy(g_unified_cache.admin_pubkey, event_pubkey, sizeof(g_unified_cache.admin_pubkey) - 1);
g_unified_cache.admin_pubkey[sizeof(g_unified_cache.admin_pubkey) - 1] = '\0';
pthread_mutex_unlock(&g_unified_cache.cache_lock);
int rc = sqlite3_prepare_v2(g_db, sql, -1, &stmt, NULL);
if (rc == SQLITE_OK) {
if (sqlite3_step(stmt) == SQLITE_ROW) {
const char* event_pubkey = (const char*)sqlite3_column_text(stmt, 0);
if (event_pubkey && strlen(event_pubkey) == 64) {
// Store in config table for future use
if (set_config_value_in_table("admin_pubkey", event_pubkey, "string",
"Administrator public key", "authentication", 0) == 0) {
sqlite3_finalize(stmt);
DEBUG_INFO("✓ Migrated admin_pubkey from old config event to config table");
return 0;
}
// Update cache
pthread_mutex_lock(&g_unified_cache.cache_lock);
strncpy(g_unified_cache.admin_pubkey, event_pubkey, sizeof(g_unified_cache.admin_pubkey) - 1);
g_unified_cache.admin_pubkey[sizeof(g_unified_cache.admin_pubkey) - 1] = '\0';
pthread_mutex_unlock(&g_unified_cache.cache_lock);
sqlite3_finalize(stmt);
DEBUG_INFO("✓ Migrated admin_pubkey from old config event to config table");
return 0;
}
}
sqlite3_finalize(stmt);
}
sqlite3_finalize(stmt);
}
// Use cache value for storage (either from first-time startup or just loaded from DB)
const char* admin_pubkey = admin_pubkey_cache;
const char* relay_pubkey = relay_pubkey_cache;
if (!admin_pubkey || strlen(admin_pubkey) != 64) {
DEBUG_ERROR("Admin pubkey not available or invalid for config table storage");
return -1;
}
if (!relay_pubkey || strlen(relay_pubkey) != 64) {
DEBUG_ERROR("Relay pubkey not available or invalid for config table storage");
return -1;
}
// Store admin pubkey in config table
if (set_config_value_in_table("admin_pubkey", admin_pubkey, "string",
"Administrator public key", "authentication", 0) != 0) {
@@ -2419,7 +2531,7 @@ int add_pubkeys_to_config_table(void) {
DEBUG_ERROR("Failed to store relay_pubkey in config table");
return -1;
}
DEBUG_INFO("✓ Dynamically generated pubkeys added to config table");
printf(" Admin pubkey: %s\n", admin_pubkey ? admin_pubkey : "NULL");
printf(" Relay pubkey: %s\n", relay_pubkey ? relay_pubkey : "NULL");
@@ -2990,7 +3102,7 @@ int handle_kind_23456_unified(cJSON* event, char* error_message, size_t error_si
}
const char* sender_pubkey = cJSON_GetStringValue(pubkey_obj);
const char* admin_pubkey = get_admin_pubkey_cached();
const char* admin_pubkey = get_config_value("admin_pubkey");
if (!admin_pubkey) {
DEBUG_ERROR("error: admin pubkey not available for authorization check");
@@ -4400,6 +4512,179 @@ int handle_config_update_unified(cJSON* event, char* error_message, size_t error
// ================================
// UNIFIED STARTUP FUNCTIONS
// ================================
// Apply CLI overrides to existing config table in a single atomic operation
int apply_cli_overrides_atomic(const cli_options_t* cli_options) {
if (!g_db) {
DEBUG_ERROR("Database not available for CLI overrides");
return -1;
}
if (!cli_options) {
DEBUG_ERROR("CLI options not provided");
return -1;
}
// Check if there are any CLI overrides to apply
int has_overrides = 0;
if (cli_options->port_override > 0) has_overrides = 1;
if (cli_options->admin_pubkey_override[0] != '\0') has_overrides = 1;
if (cli_options->relay_privkey_override[0] != '\0') has_overrides = 1;
if (!has_overrides) {
DEBUG_INFO("No CLI overrides to apply");
return 0;
}
DEBUG_INFO("Applying CLI overrides atomically");
// Begin transaction
char* err_msg = NULL;
int rc = sqlite3_exec(g_db, "BEGIN IMMEDIATE TRANSACTION", NULL, NULL, &err_msg);
if (rc != SQLITE_OK) {
DEBUG_ERROR("Failed to begin CLI overrides transaction: %s", err_msg);
sqlite3_free(err_msg);
return -1;
}
// Apply port override
if (cli_options->port_override > 0) {
char port_str[16];
snprintf(port_str, sizeof(port_str), "%d", cli_options->port_override);
if (update_config_in_table("relay_port", port_str) != 0) {
DEBUG_ERROR("Failed to update relay_port override");
sqlite3_exec(g_db, "ROLLBACK", NULL, NULL, NULL);
return -1;
}
DEBUG_INFO("Applied CLI override: relay_port = %s", port_str);
}
// Apply admin_pubkey override
if (cli_options->admin_pubkey_override[0] != '\0') {
if (update_config_in_table("admin_pubkey", cli_options->admin_pubkey_override) != 0) {
DEBUG_ERROR("Failed to update admin_pubkey override");
sqlite3_exec(g_db, "ROLLBACK", NULL, NULL, NULL);
return -1;
}
DEBUG_INFO("Applied CLI override: admin_pubkey");
}
// Apply relay_privkey override
if (cli_options->relay_privkey_override[0] != '\0') {
if (update_config_in_table("relay_privkey", cli_options->relay_privkey_override) != 0) {
DEBUG_ERROR("Failed to update relay_privkey override");
sqlite3_exec(g_db, "ROLLBACK", NULL, NULL, NULL);
return -1;
}
DEBUG_INFO("Applied CLI override: relay_privkey");
}
// Commit transaction
rc = sqlite3_exec(g_db, "COMMIT", NULL, NULL, &err_msg);
if (rc != SQLITE_OK) {
DEBUG_ERROR("Failed to commit CLI overrides transaction: %s", err_msg);
sqlite3_free(err_msg);
sqlite3_exec(g_db, "ROLLBACK", NULL, NULL, NULL);
return -1;
}
// Invalidate cache to force refresh with new values
invalidate_config_cache();
DEBUG_INFO("Successfully applied CLI overrides atomically");
return 0;
}
// Populate all config values atomically in a single transaction
int populate_all_config_values_atomic(const char* admin_pubkey, const char* relay_pubkey) {
if (!g_db) {
DEBUG_ERROR("Database not initialized");
return -1;
}
if (!admin_pubkey || !relay_pubkey) {
DEBUG_ERROR("Admin pubkey or relay pubkey not available");
return -1;
}
// Begin transaction
char* err_msg = NULL;
int rc = sqlite3_exec(g_db, "BEGIN TRANSACTION;", NULL, NULL, &err_msg);
if (rc != SQLITE_OK) {
DEBUG_ERROR("Failed to begin transaction: %s", err_msg);
sqlite3_free(err_msg);
return -1;
}
// Prepare INSERT statement
sqlite3_stmt* stmt = NULL;
const char* sql = "INSERT INTO config (key, value) VALUES (?, ?)";
rc = sqlite3_prepare_v2(g_db, sql, -1, &stmt, NULL);
if (rc != SQLITE_OK) {
DEBUG_ERROR("Failed to prepare statement: %s", sqlite3_errmsg(g_db));
sqlite3_exec(g_db, "ROLLBACK;", NULL, NULL, NULL);
return -1;
}
// Insert all default config values
for (size_t i = 0; i < DEFAULT_CONFIG_COUNT; i++) {
sqlite3_reset(stmt);
sqlite3_bind_text(stmt, 1, DEFAULT_CONFIG_VALUES[i].key, -1, SQLITE_STATIC);
sqlite3_bind_text(stmt, 2, DEFAULT_CONFIG_VALUES[i].value, -1, SQLITE_STATIC);
rc = sqlite3_step(stmt);
if (rc != SQLITE_DONE) {
DEBUG_ERROR("Failed to insert config key '%s': %s",
DEFAULT_CONFIG_VALUES[i].key, sqlite3_errmsg(g_db));
sqlite3_finalize(stmt);
sqlite3_exec(g_db, "ROLLBACK;", NULL, NULL, NULL);
return -1;
}
}
// Insert admin_pubkey
sqlite3_reset(stmt);
sqlite3_bind_text(stmt, 1, "admin_pubkey", -1, SQLITE_STATIC);
sqlite3_bind_text(stmt, 2, admin_pubkey, -1, SQLITE_STATIC);
rc = sqlite3_step(stmt);
if (rc != SQLITE_DONE) {
DEBUG_ERROR("Failed to insert admin_pubkey: %s", sqlite3_errmsg(g_db));
sqlite3_finalize(stmt);
sqlite3_exec(g_db, "ROLLBACK;", NULL, NULL, NULL);
return -1;
}
// Insert relay_pubkey
sqlite3_reset(stmt);
sqlite3_bind_text(stmt, 1, "relay_pubkey", -1, SQLITE_STATIC);
sqlite3_bind_text(stmt, 2, relay_pubkey, -1, SQLITE_STATIC);
rc = sqlite3_step(stmt);
if (rc != SQLITE_DONE) {
DEBUG_ERROR("Failed to insert relay_pubkey: %s", sqlite3_errmsg(g_db));
sqlite3_finalize(stmt);
sqlite3_exec(g_db, "ROLLBACK;", NULL, NULL, NULL);
return -1;
}
sqlite3_finalize(stmt);
// Commit transaction
rc = sqlite3_exec(g_db, "COMMIT;", NULL, NULL, &err_msg);
if (rc != SQLITE_OK) {
DEBUG_ERROR("Failed to commit transaction: %s", err_msg);
sqlite3_free(err_msg);
sqlite3_exec(g_db, "ROLLBACK;", NULL, NULL, NULL);
return -1;
}
DEBUG_INFO("Successfully populated all config values atomically");
return 0;
}
// ================================
// CONFIGURATION CACHE MANAGEMENT
// ================================
@@ -4655,7 +4940,7 @@ int migrate_config_from_events_to_table(void) {
DEBUG_INFO("Migrating configuration from events to config table...");
// Load the most recent configuration event from database
const char* relay_pubkey = get_relay_pubkey_cached();
const char* relay_pubkey = get_config_value("relay_pubkey");
cJSON* config_event = load_config_event_from_database(relay_pubkey);
if (!config_event) {
DEBUG_INFO("No existing configuration event found - migration not needed");
@@ -4803,7 +5088,7 @@ cJSON* generate_config_event_from_table(void) {
const char* relay_pubkey = get_config_value("relay_pubkey");
if (!relay_pubkey || strlen(relay_pubkey) != 64) {
// Try to get from unified cache
relay_pubkey = get_relay_pubkey_cached();
relay_pubkey = get_config_value("relay_pubkey");
if (!relay_pubkey || strlen(relay_pubkey) != 64) {
DEBUG_ERROR("Relay pubkey not available for config event generation");
return NULL;

6
src/config.h
View File

@@ -139,7 +139,7 @@ int get_config_bool(const char* key, int default_value);
// First-time startup functions
int is_first_time_startup(void);
int first_time_startup_sequence(const cli_options_t* cli_options);
int startup_existing_relay(const char* relay_pubkey);
int startup_existing_relay(const char* relay_pubkey, const cli_options_t* cli_options);
// Configuration application functions
int apply_configuration_from_event(const cJSON* event);
@@ -169,6 +169,7 @@ int set_config_value_in_table(const char* key, const char* value, const char* da
const char* description, const char* category, int requires_restart);
int update_config_in_table(const char* key, const char* value);
int populate_default_config_values(void);
int populate_all_config_values_atomic(const char* admin_pubkey, const char* relay_pubkey);
int add_pubkeys_to_config_table(void);
// Admin event processing functions (updated with WebSocket support)
@@ -212,6 +213,9 @@ int populate_config_table_from_event(const cJSON* event);
int process_startup_config_event(const cJSON* event);
int process_startup_config_event_with_fallback(const cJSON* event);
// Atomic CLI override application
int apply_cli_overrides_atomic(const cli_options_t* cli_options);
// Dynamic event generation functions for WebSocket configuration fetching
cJSON* generate_config_event_from_table(void);
int req_filter_requests_config_events(const cJSON* filter);

10
src/dm_admin.c
View File

@@ -30,11 +30,9 @@ extern const char* get_first_tag_name(cJSON* event);
extern const char* get_tag_value(cJSON* event, const char* tag_name, int value_index);
// Forward declarations for config functions
extern const char* get_relay_pubkey_cached(void);
extern char* get_relay_private_key(void);
extern const char* get_config_value(const char* key);
extern int get_config_bool(const char* key, int default_value);
extern const char* get_admin_pubkey_cached(void);
// Forward declarations for database functions
extern int store_event(cJSON* event);
@@ -1019,7 +1017,7 @@ int send_nip17_response(const char* sender_pubkey, const char* response_content,
}
// Get relay keys for signing
const char* relay_pubkey = get_relay_pubkey_cached();
const char* relay_pubkey = get_config_value("relay_pubkey");
char* relay_privkey_hex = get_relay_private_key();
if (!relay_pubkey || !relay_privkey_hex) {
if (relay_privkey_hex) free(relay_privkey_hex);
@@ -1430,7 +1428,7 @@ cJSON* process_nip17_admin_message(cJSON* gift_wrap_event, char* error_message,
"[\"command_processed\", \"success\", \"%s\"]", "NIP-17 admin command executed");
// Get relay pubkey for creating DM event
const char* relay_pubkey = get_relay_pubkey_cached();
const char* relay_pubkey = get_config_value("relay_pubkey");
if (relay_pubkey) {
cJSON* success_dm = nostr_nip17_create_chat_event(
response_content, // message content
@@ -1518,7 +1516,7 @@ int is_nip17_gift_wrap_for_relay(cJSON* event) {
return 0;
}
const char* relay_pubkey = get_relay_pubkey_cached();
const char* relay_pubkey = get_config_value("relay_pubkey");
if (!relay_pubkey) {
DEBUG_ERROR("NIP-17: Could not get relay pubkey for validation");
return 0;
@@ -1566,7 +1564,7 @@ int process_nip17_admin_command(cJSON* dm_event, char* error_message, size_t err
const char* sender_pubkey = cJSON_GetStringValue(sender_pubkey_obj);
// Check if sender is admin
const char* admin_pubkey = get_admin_pubkey_cached();
const char* admin_pubkey = get_config_value("admin_pubkey");
int is_admin = admin_pubkey && strlen(admin_pubkey) > 0 && strcmp(sender_pubkey, admin_pubkey) == 0;
// Parse DM content as JSON array of commands

8
src/embedded_web_content.c
View File

File diff suppressed because one or more lines are too long

112
src/main.c
View File

@@ -318,6 +318,22 @@ int init_database(const char* database_path_override) {
return -1;
}
// DEBUG_GUARD_START
if (g_debug_level >= DEBUG_LEVEL_DEBUG) {
// Check config table row count immediately after database open
sqlite3_stmt* stmt;
if (sqlite3_prepare_v2(g_db, "SELECT COUNT(*) FROM config", -1, &stmt, NULL) == SQLITE_OK) {
if (sqlite3_step(stmt) == SQLITE_ROW) {
int row_count = sqlite3_column_int(stmt, 0);
DEBUG_LOG("Config table row count immediately after sqlite3_open(): %d", row_count);
}
sqlite3_finalize(stmt);
} else {
DEBUG_LOG("Config table does not exist yet (first-time startup)");
}
}
// DEBUG_GUARD_END
// Check if database is already initialized by looking for the events table
const char* check_sql = "SELECT name FROM sqlite_master WHERE type='table' AND name='events'";
sqlite3_stmt* check_stmt;
@@ -1632,6 +1648,19 @@ int main(int argc, char* argv[]) {
return 1;
}
DEBUG_LOG("Database initialized for first-time startup");
// DEBUG_GUARD_START
if (g_debug_level >= DEBUG_LEVEL_DEBUG) {
sqlite3_stmt* stmt;
if (sqlite3_prepare_v2(g_db, "SELECT COUNT(*) FROM config", -1, &stmt, NULL) == SQLITE_OK) {
if (sqlite3_step(stmt) == SQLITE_ROW) {
int row_count = sqlite3_column_int(stmt, 0);
DEBUG_LOG("Config table row count after init_database() (first-time): %d", row_count);
}
sqlite3_finalize(stmt);
}
}
// DEBUG_GUARD_END
// Now that database is available, store the relay private key securely
const char* relay_privkey = get_temp_relay_private_key();
@@ -1649,6 +1678,9 @@ int main(int argc, char* argv[]) {
return 1;
}
// COMMENTED OUT: Old incremental config building code replaced by unified startup sequence
// The new first_time_startup_sequence() function handles all config creation atomically
/*
// Handle configuration setup after database is initialized
// Always populate defaults directly in config table (abandoning legacy event signing)
@@ -1661,6 +1693,19 @@ int main(int argc, char* argv[]) {
return 1;
}
// DEBUG_GUARD_START
if (g_debug_level >= DEBUG_LEVEL_DEBUG) {
sqlite3_stmt* stmt;
if (sqlite3_prepare_v2(g_db, "SELECT COUNT(*) FROM config", -1, &stmt, NULL) == SQLITE_OK) {
if (sqlite3_step(stmt) == SQLITE_ROW) {
int row_count = sqlite3_column_int(stmt, 0);
DEBUG_LOG("Config table row count after populate_default_config_values(): %d", row_count);
}
sqlite3_finalize(stmt);
}
}
// DEBUG_GUARD_END
// Apply CLI overrides now that database is available
if (cli_options.port_override > 0) {
char port_str[16];
@@ -1683,6 +1728,20 @@ int main(int argc, char* argv[]) {
close_database();
return 1;
}
// DEBUG_GUARD_START
if (g_debug_level >= DEBUG_LEVEL_DEBUG) {
sqlite3_stmt* stmt;
if (sqlite3_prepare_v2(g_db, "SELECT COUNT(*) FROM config", -1, &stmt, NULL) == SQLITE_OK) {
if (sqlite3_step(stmt) == SQLITE_ROW) {
int row_count = sqlite3_column_int(stmt, 0);
DEBUG_LOG("Config table row count after add_pubkeys_to_config_table() (first-time): %d", row_count);
}
sqlite3_finalize(stmt);
}
}
// DEBUG_GUARD_END
*/
} else {
// Find existing database file
char** existing_files = find_existing_db_files();
@@ -1718,7 +1777,7 @@ int main(int argc, char* argv[]) {
}
// Setup existing relay (sets database path and loads config)
if (startup_existing_relay(relay_pubkey) != 0) {
if (startup_existing_relay(relay_pubkey, &cli_options) != 0) {
DEBUG_ERROR("Failed to setup existing relay");
cleanup_configuration_system();
free(relay_pubkey);
@@ -1761,25 +1820,29 @@ int main(int argc, char* argv[]) {
}
DEBUG_LOG("Existing database initialized");
// Check config table row count after database initialization
{
// DEBUG_GUARD_START
if (g_debug_level >= DEBUG_LEVEL_DEBUG) {
sqlite3_stmt* stmt;
if (sqlite3_prepare_v2(g_db, "SELECT COUNT(*) FROM config", -1, &stmt, NULL) == SQLITE_OK) {
if (sqlite3_step(stmt) == SQLITE_ROW) {
int row_count = sqlite3_column_int(stmt, 0);
printf(" Config table row count after database initialization: %d\n", row_count);
DEBUG_LOG("Config table row count after init_database(): %d", row_count);
}
sqlite3_finalize(stmt);
}
}
// DEBUG_GUARD_END
// COMMENTED OUT: Old incremental config building code replaced by unified startup sequence
// The new startup_existing_relay() function handles all config loading atomically
/*
// Ensure default configuration values are populated (for any missing keys)
// This must be done AFTER database initialization
// COMMENTED OUT: Don't modify existing database config on restart
// if (populate_default_config_values() != 0) {
// DEBUG_WARN("Failed to populate default config values for existing relay - continuing");
// }
// Load configuration from database
cJSON* config_event = load_config_event_from_database(relay_pubkey);
if (config_event) {
@@ -1791,28 +1854,41 @@ int main(int argc, char* argv[]) {
// This is expected for relays using table-based configuration
// No longer a warning - just informational
}
// DEBUG_GUARD_START
if (g_debug_level >= DEBUG_LEVEL_DEBUG) {
sqlite3_stmt* stmt;
if (sqlite3_prepare_v2(g_db, "SELECT COUNT(*) FROM config", -1, &stmt, NULL) == SQLITE_OK) {
if (sqlite3_step(stmt) == SQLITE_ROW) {
int row_count = sqlite3_column_int(stmt, 0);
DEBUG_LOG("Config table row count before checking pubkeys: %d", row_count);
}
sqlite3_finalize(stmt);
}
}
// DEBUG_GUARD_END
// Ensure pubkeys are in config table for existing relay
// This handles migration from old event-based config to table-based config
const char* admin_pubkey_from_table = get_config_value_from_table("admin_pubkey");
const char* relay_pubkey_from_table = get_config_value_from_table("relay_pubkey");
int need_to_add_pubkeys = 0;
// Check if admin_pubkey is missing or invalid
if (!admin_pubkey_from_table || strlen(admin_pubkey_from_table) != 64) {
DEBUG_WARN("Admin pubkey missing or invalid in config table - will regenerate from cache");
need_to_add_pubkeys = 1;
}
if (admin_pubkey_from_table) free((char*)admin_pubkey_from_table);
// Check if relay_pubkey is missing or invalid
if (!relay_pubkey_from_table || strlen(relay_pubkey_from_table) != 64) {
DEBUG_WARN("Relay pubkey missing or invalid in config table - will regenerate from cache");
need_to_add_pubkeys = 1;
}
if (relay_pubkey_from_table) free((char*)relay_pubkey_from_table);
// If either pubkey is missing, call add_pubkeys_to_config_table to populate both
if (need_to_add_pubkeys) {
if (add_pubkeys_to_config_table() != 0) {
@@ -1822,8 +1898,21 @@ int main(int argc, char* argv[]) {
close_database();
return 1;
}
// DEBUG_GUARD_START
if (g_debug_level >= DEBUG_LEVEL_DEBUG) {
sqlite3_stmt* stmt;
if (sqlite3_prepare_v2(g_db, "SELECT COUNT(*) FROM config", -1, &stmt, NULL) == SQLITE_OK) {
if (sqlite3_step(stmt) == SQLITE_ROW) {
int row_count = sqlite3_column_int(stmt, 0);
DEBUG_LOG("Config table row count after add_pubkeys_to_config_table(): %d", row_count);
}
sqlite3_finalize(stmt);
}
}
// DEBUG_GUARD_END
}
// Apply CLI overrides for existing relay (port override should work even for existing relays)
if (cli_options.port_override > 0) {
char port_str[16];
@@ -1837,6 +1926,7 @@ int main(int argc, char* argv[]) {
}
printf(" Port: %d (overriding configured port)\n", cli_options.port_override);
}
*/
// Free memory
free(relay_pubkey);

3
src/request_validator.c
View File

@@ -53,7 +53,6 @@ extern struct expiration_config {
// Configuration functions from C-relay
extern int get_config_bool(const char* key, int default_value);
extern int get_config_int(const char* key, int default_value);
extern const char* get_admin_pubkey_cached(void);
// NIP-42 constants (from nostr_core_lib)
#define NOSTR_NIP42_AUTH_EVENT_KIND 22242
@@ -301,7 +300,7 @@ int nostr_validate_unified_request(const char* json_string, size_t json_length)
// 8. Check if this is a kind 23456 admin event from authorized admin
// This must happen AFTER signature validation but BEFORE auth rules
if (event_kind == 23456) {
const char* admin_pubkey = get_admin_pubkey_cached();
const char* admin_pubkey = get_config_value("admin_pubkey");
if (admin_pubkey && strcmp(event_pubkey, admin_pubkey) == 0) {
// Valid admin event - bypass remaining validation
cJSON_Delete(event);

8
src/websockets.c
View File

@@ -311,7 +311,7 @@ static int nostr_relay_callback(struct lws *wsi, enum lws_callback_reasons reaso
if (event_kind == 14 && event_obj && cJSON_IsObject(event_obj)) {
cJSON* tags = cJSON_GetObjectItem(event_obj, "tags");
if (tags && cJSON_IsArray(tags)) {
const char* relay_pubkey = get_relay_pubkey_cached();
const char* relay_pubkey = get_config_value("relay_pubkey");
if (relay_pubkey) {
cJSON* tag = NULL;
cJSON_ArrayForEach(tag, tags) {
@@ -333,7 +333,7 @@ static int nostr_relay_callback(struct lws *wsi, enum lws_callback_reasons reaso
// Special case: allow kind 23456 admin events from authorized admin to bypass auth
if (event_kind == 23456 && event_pubkey) {
const char* admin_pubkey = get_admin_pubkey_cached();
const char* admin_pubkey = get_config_value("admin_pubkey");
if (admin_pubkey && strcmp(event_pubkey, admin_pubkey) == 0) {
bypass_auth = 1;
} else {
@@ -1159,7 +1159,7 @@ int process_dm_stats_command(cJSON* dm_event, char* error_message, size_t error_
return -1;
}
const char* relay_pubkey = get_relay_pubkey_cached();
const char* relay_pubkey = get_config_value("relay_pubkey");
if (!relay_pubkey) {
strncpy(error_message, "Could not get relay pubkey", error_size - 1);
return -1;
@@ -1197,7 +1197,7 @@ int process_dm_stats_command(cJSON* dm_event, char* error_message, size_t error_
const char* sender_pubkey = cJSON_GetStringValue(pubkey_obj);
// Check if sender is admin
const char* admin_pubkey = get_admin_pubkey_cached();
const char* admin_pubkey = get_config_value("admin_pubkey");
if (!admin_pubkey || strlen(admin_pubkey) == 0 ||
strcmp(sender_pubkey, admin_pubkey) != 0) {
strncpy(error_message, "Unauthorized: not admin", error_size - 1);