1398 lines
47 KiB
C
1398 lines
47 KiB
C
#define _GNU_SOURCE
|
|
|
|
#include "sqlite_db_ops.h"
|
|
#include "debug.h"
|
|
#include "config.h"
|
|
|
|
#include <sqlite3.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
// Database handle owned by sqlite_db_ops.
|
|
static sqlite3* g_db = NULL;
|
|
extern char g_database_path[512];
|
|
|
|
// Optional per-thread connection override (used by thread pool workers)
|
|
static __thread sqlite3* g_thread_db = NULL;
|
|
|
|
static sqlite3* sqlite_db_active_connection(void) {
|
|
return g_thread_db ? g_thread_db : g_db;
|
|
}
|
|
|
|
typedef struct sqlite_db_stmt {
|
|
sqlite3_stmt* stmt;
|
|
} sqlite_db_stmt_t;
|
|
|
|
int sqlite_db_init(const char* connection_string) {
|
|
if (!connection_string || connection_string[0] == '\0') return DB_MISUSE;
|
|
if (g_db) return DB_OK;
|
|
|
|
int rc = sqlite3_open(connection_string, &g_db);
|
|
if (rc != SQLITE_OK) {
|
|
if (g_db) {
|
|
sqlite3_close(g_db);
|
|
g_db = NULL;
|
|
}
|
|
return DB_ERROR;
|
|
}
|
|
|
|
strncpy(g_database_path, connection_string, sizeof(g_database_path) - 1);
|
|
g_database_path[sizeof(g_database_path) - 1] = '\0';
|
|
return DB_OK;
|
|
}
|
|
|
|
void sqlite_db_close(void) {
|
|
if (!g_db) return;
|
|
sqlite3_close(g_db);
|
|
g_db = NULL;
|
|
}
|
|
|
|
int sqlite_db_set_thread_connection(void* connection) {
|
|
g_thread_db = (sqlite3*)connection;
|
|
return DB_OK;
|
|
}
|
|
|
|
void sqlite_db_clear_thread_connection(void) {
|
|
g_thread_db = NULL;
|
|
}
|
|
|
|
int sqlite_db_open_worker_connection(const char* sqlite_db_path, void** out_connection) {
|
|
if (!out_connection) return -1;
|
|
*out_connection = NULL;
|
|
|
|
const char* effective_path = (sqlite_db_path && sqlite_db_path[0] != '\0') ? sqlite_db_path : g_database_path;
|
|
if (!effective_path || effective_path[0] == '\0') return -1;
|
|
|
|
sqlite3* db = NULL;
|
|
int rc = sqlite3_open_v2(effective_path, &db, SQLITE_OPEN_READWRITE, NULL);
|
|
if (rc != SQLITE_OK) {
|
|
if (db) sqlite3_close(db);
|
|
return -1;
|
|
}
|
|
|
|
sqlite3_exec(db, "PRAGMA journal_mode=WAL;", NULL, NULL, NULL);
|
|
sqlite3_exec(db, "PRAGMA wal_autocheckpoint=0;", NULL, NULL, NULL);
|
|
sqlite3_busy_timeout(db, 5000);
|
|
sqlite_db_set_thread_connection(db);
|
|
*out_connection = (void*)db;
|
|
return 0;
|
|
}
|
|
|
|
void sqlite_db_close_worker_connection(void* connection) {
|
|
if (!connection) return;
|
|
sqlite_db_clear_thread_connection();
|
|
sqlite3_close((sqlite3*)connection);
|
|
}
|
|
|
|
int sqlite_db_is_available(void) {
|
|
return sqlite_db_active_connection() != NULL;
|
|
}
|
|
|
|
const char* sqlite_db_last_error(void) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db) return "database not available";
|
|
return sqlite3_errmsg(db);
|
|
}
|
|
|
|
const char* sqlite_db_get_database_path(void) {
|
|
return g_database_path;
|
|
}
|
|
|
|
int sqlite_db_prepare(const char* sql, sqlite_db_stmt_t** out_stmt) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db || !sql || !out_stmt) return DB_MISUSE;
|
|
|
|
sqlite3_stmt* raw_stmt = NULL;
|
|
int rc = sqlite3_prepare_v2(db, sql, -1, &raw_stmt, NULL);
|
|
if (rc != SQLITE_OK) return rc;
|
|
|
|
sqlite_db_stmt_t* wrapper = (sqlite_db_stmt_t*)malloc(sizeof(sqlite_db_stmt_t));
|
|
if (!wrapper) {
|
|
sqlite3_finalize(raw_stmt);
|
|
return DB_ERROR;
|
|
}
|
|
|
|
wrapper->stmt = raw_stmt;
|
|
*out_stmt = wrapper;
|
|
return DB_OK;
|
|
}
|
|
|
|
int sqlite_db_bind_text_param(sqlite_db_stmt_t* stmt, int index, const char* value) {
|
|
if (!stmt || !stmt->stmt) return DB_MISUSE;
|
|
return sqlite3_bind_text(stmt->stmt, index, value ? value : "", -1, SQLITE_TRANSIENT);
|
|
}
|
|
|
|
int sqlite_db_bind_int_param(sqlite_db_stmt_t* stmt, int index, int value) {
|
|
if (!stmt || !stmt->stmt) return DB_MISUSE;
|
|
return sqlite3_bind_int(stmt->stmt, index, value);
|
|
}
|
|
|
|
int sqlite_db_bind_int64_param(sqlite_db_stmt_t* stmt, int index, long long value) {
|
|
if (!stmt || !stmt->stmt) return DB_MISUSE;
|
|
return sqlite3_bind_int64(stmt->stmt, index, (sqlite3_int64)value);
|
|
}
|
|
|
|
int sqlite_db_step_stmt(sqlite_db_stmt_t* stmt) {
|
|
if (!stmt || !stmt->stmt) return DB_MISUSE;
|
|
return sqlite3_step(stmt->stmt);
|
|
}
|
|
|
|
int sqlite_db_reset_stmt(sqlite_db_stmt_t* stmt) {
|
|
if (!stmt || !stmt->stmt) return DB_MISUSE;
|
|
return sqlite3_reset(stmt->stmt);
|
|
}
|
|
|
|
const char* sqlite_db_column_text_value(sqlite_db_stmt_t* stmt, int col) {
|
|
if (!stmt || !stmt->stmt) return NULL;
|
|
return (const char*)sqlite3_column_text(stmt->stmt, col);
|
|
}
|
|
|
|
int sqlite_db_column_int_value(sqlite_db_stmt_t* stmt, int col) {
|
|
if (!stmt || !stmt->stmt) return 0;
|
|
return sqlite3_column_int(stmt->stmt, col);
|
|
}
|
|
|
|
long long sqlite_db_column_int64_value(sqlite_db_stmt_t* stmt, int col) {
|
|
if (!stmt || !stmt->stmt) return 0;
|
|
return (long long)sqlite3_column_int64(stmt->stmt, col);
|
|
}
|
|
|
|
double sqlite_db_column_double_value(sqlite_db_stmt_t* stmt, int col) {
|
|
if (!stmt || !stmt->stmt) return 0.0;
|
|
return sqlite3_column_double(stmt->stmt, col);
|
|
}
|
|
|
|
void sqlite_db_finalize_stmt(sqlite_db_stmt_t* stmt) {
|
|
if (!stmt) return;
|
|
if (stmt->stmt) sqlite3_finalize(stmt->stmt);
|
|
free(stmt);
|
|
}
|
|
|
|
int sqlite_db_log_subscription_created(const char* sub_id, const char* wsi_ptr,
|
|
const char* client_ip, const char* filter_json) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db || !sub_id || !wsi_ptr || !client_ip) return -1;
|
|
|
|
const char* sql =
|
|
"INSERT OR REPLACE INTO subscriptions (subscription_id, wsi_pointer, client_ip, event_type, filter_json) "
|
|
"VALUES (?, ?, ?, 'created', ?)";
|
|
|
|
sqlite3_stmt* stmt = NULL;
|
|
if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) return -1;
|
|
|
|
sqlite3_bind_text(stmt, 1, sub_id, -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 2, wsi_ptr, -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 3, client_ip, -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 4, filter_json ? filter_json : "[]", -1, SQLITE_TRANSIENT);
|
|
|
|
int rc = sqlite3_step(stmt);
|
|
sqlite3_finalize(stmt);
|
|
return (rc == SQLITE_DONE) ? 0 : -1;
|
|
}
|
|
|
|
int sqlite_db_log_subscription_closed(const char* sub_id, const char* client_ip) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db || !sub_id) return -1;
|
|
|
|
const char* insert_sql =
|
|
"INSERT INTO subscriptions (subscription_id, wsi_pointer, client_ip, event_type) "
|
|
"VALUES (?, '', ?, 'closed')";
|
|
|
|
sqlite3_stmt* stmt = NULL;
|
|
if (sqlite3_prepare_v2(db, insert_sql, -1, &stmt, NULL) == SQLITE_OK) {
|
|
sqlite3_bind_text(stmt, 1, sub_id, -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 2, client_ip ? client_ip : "unknown", -1, SQLITE_TRANSIENT);
|
|
sqlite3_step(stmt);
|
|
sqlite3_finalize(stmt);
|
|
}
|
|
|
|
const char* update_sql =
|
|
"UPDATE subscriptions "
|
|
"SET ended_at = strftime('%s', 'now') "
|
|
"WHERE subscription_id = ? AND event_type = 'created' AND ended_at IS NULL";
|
|
|
|
if (sqlite3_prepare_v2(db, update_sql, -1, &stmt, NULL) != SQLITE_OK) return -1;
|
|
sqlite3_bind_text(stmt, 1, sub_id, -1, SQLITE_TRANSIENT);
|
|
int rc = sqlite3_step(stmt);
|
|
sqlite3_finalize(stmt);
|
|
|
|
return (rc == SQLITE_DONE) ? 0 : -1;
|
|
}
|
|
|
|
int sqlite_db_log_subscription_disconnected(const char* client_ip) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db || !client_ip) return -1;
|
|
|
|
const char* update_sql =
|
|
"UPDATE subscriptions "
|
|
"SET ended_at = strftime('%s', 'now') "
|
|
"WHERE client_ip = ? AND event_type = 'created' AND ended_at IS NULL";
|
|
|
|
sqlite3_stmt* stmt = NULL;
|
|
if (sqlite3_prepare_v2(db, update_sql, -1, &stmt, NULL) != SQLITE_OK) return -1;
|
|
|
|
sqlite3_bind_text(stmt, 1, client_ip, -1, SQLITE_TRANSIENT);
|
|
int rc = sqlite3_step(stmt);
|
|
int changes = sqlite3_changes(db);
|
|
sqlite3_finalize(stmt);
|
|
if (rc != SQLITE_DONE) return -1;
|
|
|
|
if (changes > 0) {
|
|
const char* insert_sql =
|
|
"INSERT INTO subscriptions (subscription_id, wsi_pointer, client_ip, event_type) "
|
|
"VALUES ('disconnect', '', ?, 'disconnected')";
|
|
|
|
if (sqlite3_prepare_v2(db, insert_sql, -1, &stmt, NULL) == SQLITE_OK) {
|
|
sqlite3_bind_text(stmt, 1, client_ip, -1, SQLITE_TRANSIENT);
|
|
sqlite3_step(stmt);
|
|
sqlite3_finalize(stmt);
|
|
}
|
|
}
|
|
|
|
return changes;
|
|
}
|
|
|
|
int sqlite_db_update_subscription_events_sent(const char* sub_id, int events_sent) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db || !sub_id) return -1;
|
|
|
|
const char* sql =
|
|
"UPDATE subscriptions "
|
|
"SET events_sent = ? "
|
|
"WHERE subscription_id = ? AND event_type = 'created'";
|
|
|
|
sqlite3_stmt* stmt = NULL;
|
|
if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) return -1;
|
|
|
|
sqlite3_bind_int(stmt, 1, events_sent);
|
|
sqlite3_bind_text(stmt, 2, sub_id, -1, SQLITE_TRANSIENT);
|
|
|
|
int rc = sqlite3_step(stmt);
|
|
sqlite3_finalize(stmt);
|
|
return (rc == SQLITE_DONE) ? 0 : -1;
|
|
}
|
|
|
|
int sqlite_db_cleanup_orphaned_subscriptions(void) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db) return -1;
|
|
|
|
const char* sql =
|
|
"UPDATE subscriptions "
|
|
"SET ended_at = strftime('%s', 'now') "
|
|
"WHERE event_type = 'created' AND ended_at IS NULL";
|
|
|
|
sqlite3_stmt* stmt = NULL;
|
|
if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) return -1;
|
|
|
|
int rc = sqlite3_step(stmt);
|
|
int changes = sqlite3_changes(db);
|
|
sqlite3_finalize(stmt);
|
|
|
|
return (rc == SQLITE_DONE) ? changes : -1;
|
|
}
|
|
|
|
int sqlite_db_get_event_pubkey(const char* event_id, char* pubkey_out, size_t pubkey_out_size) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db || !event_id || !pubkey_out || pubkey_out_size == 0) return -1;
|
|
|
|
const char* sql = "SELECT pubkey FROM events WHERE id = ?";
|
|
sqlite3_stmt* stmt = NULL;
|
|
|
|
if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) return -1;
|
|
|
|
sqlite3_bind_text(stmt, 1, event_id, -1, SQLITE_TRANSIENT);
|
|
int rc = sqlite3_step(stmt);
|
|
if (rc == SQLITE_ROW) {
|
|
const char* pubkey = (const char*)sqlite3_column_text(stmt, 0);
|
|
if (pubkey) {
|
|
snprintf(pubkey_out, pubkey_out_size, "%s", pubkey);
|
|
sqlite3_finalize(stmt);
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
sqlite3_finalize(stmt);
|
|
return 0;
|
|
}
|
|
|
|
int sqlite_db_delete_event_by_id(const char* event_id, const char* requester_pubkey) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db || !event_id || !requester_pubkey) return -1;
|
|
|
|
const char* sql = "DELETE FROM events WHERE id = ? AND pubkey = ?";
|
|
sqlite3_stmt* stmt = NULL;
|
|
|
|
if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) return -1;
|
|
|
|
sqlite3_bind_text(stmt, 1, event_id, -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 2, requester_pubkey, -1, SQLITE_TRANSIENT);
|
|
|
|
int rc = sqlite3_step(stmt);
|
|
int changes = sqlite3_changes(db);
|
|
sqlite3_finalize(stmt);
|
|
|
|
if (rc != SQLITE_DONE) return -1;
|
|
return changes;
|
|
}
|
|
|
|
int sqlite_db_delete_events_by_address(const char* pubkey, int kind,
|
|
const char* d_tag, long before_timestamp) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db || !pubkey) return -1;
|
|
|
|
const char* sql_with_d =
|
|
"DELETE FROM events WHERE kind = ? AND pubkey = ? AND created_at <= ? "
|
|
"AND json_extract(tags, '$[*]') LIKE '%[\"d\",\"' || ? || '\"]%'";
|
|
const char* sql_no_d =
|
|
"DELETE FROM events WHERE kind = ? AND pubkey = ? AND created_at <= ?";
|
|
|
|
const int has_d = (d_tag && d_tag[0] != '\0');
|
|
sqlite3_stmt* stmt = NULL;
|
|
|
|
if (sqlite3_prepare_v2(db, has_d ? sql_with_d : sql_no_d, -1, &stmt, NULL) != SQLITE_OK) {
|
|
return -1;
|
|
}
|
|
|
|
sqlite3_bind_int(stmt, 1, kind);
|
|
sqlite3_bind_text(stmt, 2, pubkey, -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_int64(stmt, 3, before_timestamp);
|
|
if (has_d) {
|
|
sqlite3_bind_text(stmt, 4, d_tag, -1, SQLITE_TRANSIENT);
|
|
}
|
|
|
|
int rc = sqlite3_step(stmt);
|
|
int changes = sqlite3_changes(db);
|
|
sqlite3_finalize(stmt);
|
|
|
|
if (rc != SQLITE_DONE) return -1;
|
|
return changes;
|
|
}
|
|
|
|
static int sqlite_db_scalar_exists_open(sqlite3* db, const char* sql, const char* value) {
|
|
sqlite3_stmt* stmt = NULL;
|
|
if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) return 0;
|
|
|
|
if (value) sqlite3_bind_text(stmt, 1, value, -1, SQLITE_TRANSIENT);
|
|
|
|
int exists = (sqlite3_step(stmt) == SQLITE_ROW) ? 1 : 0;
|
|
sqlite3_finalize(stmt);
|
|
return exists;
|
|
}
|
|
|
|
int sqlite_db_is_pubkey_blacklisted(const char* pubkey) {
|
|
if (!pubkey || g_database_path[0] == '\0') return 0;
|
|
|
|
sqlite3* db = NULL;
|
|
if (sqlite3_open_v2(g_database_path, &db, SQLITE_OPEN_READONLY, NULL) != SQLITE_OK) return 0;
|
|
|
|
const char* sql =
|
|
"SELECT 1 FROM auth_rules WHERE rule_type = 'blacklist' "
|
|
"AND pattern_type = 'pubkey' AND pattern_value = ? AND active = 1 LIMIT 1";
|
|
|
|
int exists = sqlite_db_scalar_exists_open(db, sql, pubkey);
|
|
sqlite3_close(db);
|
|
return exists;
|
|
}
|
|
|
|
int sqlite_db_is_hash_blacklisted(const char* resource_hash) {
|
|
if (!resource_hash || g_database_path[0] == '\0') return 0;
|
|
|
|
sqlite3* db = NULL;
|
|
if (sqlite3_open_v2(g_database_path, &db, SQLITE_OPEN_READONLY, NULL) != SQLITE_OK) return 0;
|
|
|
|
const char* sql =
|
|
"SELECT 1 FROM auth_rules WHERE rule_type = 'blacklist' "
|
|
"AND pattern_type = 'hash' AND pattern_value = ? AND active = 1 LIMIT 1";
|
|
|
|
int exists = sqlite_db_scalar_exists_open(db, sql, resource_hash);
|
|
sqlite3_close(db);
|
|
return exists;
|
|
}
|
|
|
|
int sqlite_db_is_pubkey_whitelisted(const char* pubkey) {
|
|
if (!pubkey || g_database_path[0] == '\0') return 0;
|
|
|
|
sqlite3* db = NULL;
|
|
if (sqlite3_open_v2(g_database_path, &db, SQLITE_OPEN_READONLY, NULL) != SQLITE_OK) return 0;
|
|
|
|
const char* sql =
|
|
"SELECT 1 FROM auth_rules WHERE rule_type IN ('whitelist', 'wot_whitelist') "
|
|
"AND pattern_type = 'pubkey' AND pattern_value = ? AND active = 1 LIMIT 1";
|
|
|
|
int exists = sqlite_db_scalar_exists_open(db, sql, pubkey);
|
|
sqlite3_close(db);
|
|
return exists;
|
|
}
|
|
|
|
int sqlite_db_count_active_whitelist_rules(void) {
|
|
if (g_database_path[0] == '\0') return 0;
|
|
|
|
sqlite3* db = NULL;
|
|
sqlite3_stmt* stmt = NULL;
|
|
int count = 0;
|
|
|
|
if (sqlite3_open_v2(g_database_path, &db, SQLITE_OPEN_READONLY, NULL) != SQLITE_OK) return 0;
|
|
|
|
const char* sql =
|
|
"SELECT COUNT(*) FROM auth_rules WHERE rule_type IN ('whitelist', 'wot_whitelist') "
|
|
"AND pattern_type = 'pubkey' AND active = 1 LIMIT 1";
|
|
|
|
if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) == SQLITE_OK) {
|
|
if (sqlite3_step(stmt) == SQLITE_ROW) {
|
|
count = sqlite3_column_int(stmt, 0);
|
|
}
|
|
sqlite3_finalize(stmt);
|
|
}
|
|
|
|
sqlite3_close(db);
|
|
return count;
|
|
}
|
|
|
|
int sqlite_db_count_with_sql(const char* sql, const char** bind_params, int bind_param_count, int* out_count) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db || !sql || !out_count) return -1;
|
|
|
|
sqlite3_stmt* stmt = NULL;
|
|
if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) {
|
|
return -1;
|
|
}
|
|
|
|
for (int i = 0; i < bind_param_count; i++) {
|
|
const char* param = (bind_params && bind_params[i]) ? bind_params[i] : "";
|
|
sqlite3_bind_text(stmt, i + 1, param, -1, SQLITE_TRANSIENT);
|
|
}
|
|
|
|
int count = 0;
|
|
if (sqlite3_step(stmt) == SQLITE_ROW) {
|
|
count = sqlite3_column_int(stmt, 0);
|
|
}
|
|
|
|
sqlite3_finalize(stmt);
|
|
*out_count = count;
|
|
return 0;
|
|
}
|
|
|
|
char* sqlite_db_execute_readonly_query_json(const char* query, const char* request_id,
|
|
char* error_message, size_t error_size,
|
|
int max_rows, int timeout_ms) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db || !query || !request_id || !error_message) return NULL;
|
|
|
|
sqlite3_busy_timeout(db, timeout_ms > 0 ? timeout_ms : 5000);
|
|
|
|
sqlite3_stmt* stmt = NULL;
|
|
int rc = sqlite3_prepare_v2(db, query, -1, &stmt, NULL);
|
|
if (rc != SQLITE_OK) {
|
|
const char* err_msg = sqlite3_errmsg(db);
|
|
snprintf(error_message, error_size, "SQL prepare failed: %s", err_msg ? err_msg : "unknown");
|
|
return NULL;
|
|
}
|
|
|
|
cJSON* response = cJSON_CreateObject();
|
|
if (!response) {
|
|
sqlite3_finalize(stmt);
|
|
snprintf(error_message, error_size, "Failed to allocate query response object");
|
|
return NULL;
|
|
}
|
|
|
|
cJSON_AddStringToObject(response, "query_type", "sql_query");
|
|
cJSON_AddStringToObject(response, "request_id", request_id);
|
|
cJSON_AddNumberToObject(response, "timestamp", (double)time(NULL));
|
|
cJSON_AddStringToObject(response, "query", query);
|
|
|
|
int col_count = sqlite3_column_count(stmt);
|
|
cJSON* columns = cJSON_CreateArray();
|
|
if (!columns) {
|
|
sqlite3_finalize(stmt);
|
|
cJSON_Delete(response);
|
|
snprintf(error_message, error_size, "Failed to allocate columns array");
|
|
return NULL;
|
|
}
|
|
for (int i = 0; i < col_count; i++) {
|
|
const char* col_name = sqlite3_column_name(stmt, i);
|
|
cJSON_AddItemToArray(columns, cJSON_CreateString(col_name ? col_name : ""));
|
|
}
|
|
cJSON_AddItemToObject(response, "columns", columns);
|
|
|
|
cJSON* rows = cJSON_CreateArray();
|
|
if (!rows) {
|
|
sqlite3_finalize(stmt);
|
|
cJSON_Delete(response);
|
|
snprintf(error_message, error_size, "Failed to allocate rows array");
|
|
return NULL;
|
|
}
|
|
|
|
const int row_limit = (max_rows > 0) ? max_rows : 1000;
|
|
int row_count = 0;
|
|
|
|
struct timespec start_time;
|
|
clock_gettime(CLOCK_MONOTONIC, &start_time);
|
|
|
|
while ((rc = sqlite3_step(stmt)) == SQLITE_ROW && row_count < row_limit) {
|
|
cJSON* row = cJSON_CreateArray();
|
|
if (!row) {
|
|
sqlite3_finalize(stmt);
|
|
cJSON_Delete(rows);
|
|
cJSON_Delete(response);
|
|
snprintf(error_message, error_size, "Failed to allocate row array");
|
|
return NULL;
|
|
}
|
|
|
|
for (int i = 0; i < col_count; i++) {
|
|
int col_type = sqlite3_column_type(stmt, i);
|
|
switch (col_type) {
|
|
case SQLITE_INTEGER:
|
|
cJSON_AddItemToArray(row, cJSON_CreateNumber((double)sqlite3_column_int64(stmt, i)));
|
|
break;
|
|
case SQLITE_FLOAT:
|
|
cJSON_AddItemToArray(row, cJSON_CreateNumber(sqlite3_column_double(stmt, i)));
|
|
break;
|
|
case SQLITE_TEXT: {
|
|
const char* text = (const char*)sqlite3_column_text(stmt, i);
|
|
cJSON_AddItemToArray(row, cJSON_CreateString(text ? text : ""));
|
|
break;
|
|
}
|
|
case SQLITE_BLOB: {
|
|
const void* blob = sqlite3_column_blob(stmt, i);
|
|
int blob_size = sqlite3_column_bytes(stmt, i);
|
|
if (blob && blob_size > 0) {
|
|
char* hex_str = malloc((size_t)blob_size * 2 + 1);
|
|
if (hex_str) {
|
|
for (int j = 0; j < blob_size; j++) {
|
|
sprintf(hex_str + j * 2, "%02x", ((const unsigned char*)blob)[j]);
|
|
}
|
|
hex_str[(size_t)blob_size * 2] = '\0';
|
|
cJSON_AddItemToArray(row, cJSON_CreateString(hex_str));
|
|
free(hex_str);
|
|
} else {
|
|
cJSON_AddItemToArray(row, cJSON_CreateString("[BLOB]"));
|
|
}
|
|
} else {
|
|
cJSON_AddItemToArray(row, cJSON_CreateString(""));
|
|
}
|
|
break;
|
|
}
|
|
case SQLITE_NULL:
|
|
cJSON_AddItemToArray(row, cJSON_CreateNull());
|
|
break;
|
|
default:
|
|
cJSON_AddItemToArray(row, cJSON_CreateString("[UNKNOWN]"));
|
|
break;
|
|
}
|
|
}
|
|
|
|
cJSON_AddItemToArray(rows, row);
|
|
row_count++;
|
|
|
|
struct timespec current_time;
|
|
clock_gettime(CLOCK_MONOTONIC, ¤t_time);
|
|
double elapsed = (current_time.tv_sec - start_time.tv_sec) +
|
|
(current_time.tv_nsec - start_time.tv_nsec) / 1e9;
|
|
if (elapsed > 4.5) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
sqlite3_finalize(stmt);
|
|
|
|
if (rc != SQLITE_DONE && rc != SQLITE_ROW) {
|
|
const char* err_msg = sqlite3_errmsg(db);
|
|
snprintf(error_message, error_size, "SQL execution failed: %s", err_msg ? err_msg : "unknown");
|
|
cJSON_Delete(rows);
|
|
cJSON_Delete(response);
|
|
return NULL;
|
|
}
|
|
|
|
if (row_count >= row_limit) {
|
|
cJSON_AddStringToObject(response, "warning", "Result truncated to maximum row limit");
|
|
}
|
|
|
|
cJSON_AddNumberToObject(response, "row_count", row_count);
|
|
cJSON_AddNumberToObject(response, "execution_time_ms", 0);
|
|
cJSON_AddItemToObject(response, "rows", rows);
|
|
|
|
char* json_result = cJSON_Print(response);
|
|
cJSON_Delete(response);
|
|
|
|
if (!json_result) {
|
|
snprintf(error_message, error_size, "Failed to generate JSON response");
|
|
return NULL;
|
|
}
|
|
|
|
return json_result;
|
|
}
|
|
|
|
int sqlite_db_get_total_event_count_ll(long long* out_count) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db || !out_count) return -1;
|
|
|
|
sqlite3_stmt* stmt = NULL;
|
|
const char* sql = "SELECT COUNT(*) FROM events";
|
|
if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) return -1;
|
|
|
|
long long count = 0;
|
|
if (sqlite3_step(stmt) == SQLITE_ROW) {
|
|
count = sqlite3_column_int64(stmt, 0);
|
|
}
|
|
|
|
sqlite3_finalize(stmt);
|
|
*out_count = count;
|
|
return 0;
|
|
}
|
|
|
|
int sqlite_db_get_event_count_since(time_t cutoff, long long* out_count) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db || !out_count) return -1;
|
|
|
|
sqlite3_stmt* stmt = NULL;
|
|
const char* sql = "SELECT COUNT(*) FROM events WHERE created_at >= ?";
|
|
if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) return -1;
|
|
|
|
sqlite3_bind_int64(stmt, 1, (sqlite3_int64)cutoff);
|
|
|
|
long long count = 0;
|
|
if (sqlite3_step(stmt) == SQLITE_ROW) {
|
|
count = sqlite3_column_int64(stmt, 0);
|
|
}
|
|
|
|
sqlite3_finalize(stmt);
|
|
*out_count = count;
|
|
return 0;
|
|
}
|
|
|
|
cJSON* sqlite_db_get_event_kind_distribution_rows(long long* out_total_events) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db) return NULL;
|
|
|
|
sqlite3_stmt* stmt = NULL;
|
|
const char* sql = "SELECT kind, COUNT(*) as count FROM events GROUP BY kind ORDER BY count DESC";
|
|
if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) return NULL;
|
|
|
|
cJSON* rows = cJSON_CreateArray();
|
|
if (!rows) {
|
|
sqlite3_finalize(stmt);
|
|
return NULL;
|
|
}
|
|
|
|
long long total = 0;
|
|
while (sqlite3_step(stmt) == SQLITE_ROW) {
|
|
cJSON* row = cJSON_CreateObject();
|
|
if (!row) {
|
|
sqlite3_finalize(stmt);
|
|
cJSON_Delete(rows);
|
|
return NULL;
|
|
}
|
|
|
|
int kind = sqlite3_column_int(stmt, 0);
|
|
long long count = sqlite3_column_int64(stmt, 1);
|
|
total += count;
|
|
|
|
cJSON_AddNumberToObject(row, "kind", kind);
|
|
cJSON_AddNumberToObject(row, "count", count);
|
|
cJSON_AddItemToArray(rows, row);
|
|
}
|
|
|
|
sqlite3_finalize(stmt);
|
|
if (out_total_events) {
|
|
*out_total_events = total;
|
|
}
|
|
return rows;
|
|
}
|
|
|
|
cJSON* sqlite_db_get_top_pubkeys_rows(int limit) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db) return NULL;
|
|
|
|
sqlite3_stmt* stmt = NULL;
|
|
const char* sql = "SELECT pubkey, COUNT(*) as count FROM events GROUP BY pubkey ORDER BY count DESC LIMIT ?";
|
|
if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) return NULL;
|
|
|
|
sqlite3_bind_int(stmt, 1, limit > 0 ? limit : 10);
|
|
|
|
cJSON* rows = cJSON_CreateArray();
|
|
if (!rows) {
|
|
sqlite3_finalize(stmt);
|
|
return NULL;
|
|
}
|
|
|
|
while (sqlite3_step(stmt) == SQLITE_ROW) {
|
|
cJSON* row = cJSON_CreateObject();
|
|
if (!row) {
|
|
sqlite3_finalize(stmt);
|
|
cJSON_Delete(rows);
|
|
return NULL;
|
|
}
|
|
|
|
const char* pubkey = (const char*)sqlite3_column_text(stmt, 0);
|
|
long long count = sqlite3_column_int64(stmt, 1);
|
|
cJSON_AddStringToObject(row, "pubkey", pubkey ? pubkey : "");
|
|
cJSON_AddNumberToObject(row, "count", count);
|
|
cJSON_AddItemToArray(rows, row);
|
|
}
|
|
|
|
sqlite3_finalize(stmt);
|
|
return rows;
|
|
}
|
|
|
|
cJSON* sqlite_db_get_subscription_details_rows(void) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db) return NULL;
|
|
|
|
sqlite3_stmt* stmt = NULL;
|
|
const char* sql =
|
|
"SELECT * "
|
|
"FROM active_subscriptions_log "
|
|
"ORDER BY created_at DESC";
|
|
|
|
if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) return NULL;
|
|
|
|
cJSON* rows = cJSON_CreateArray();
|
|
if (!rows) {
|
|
sqlite3_finalize(stmt);
|
|
return NULL;
|
|
}
|
|
|
|
while (sqlite3_step(stmt) == SQLITE_ROW) {
|
|
cJSON* row = cJSON_CreateObject();
|
|
if (!row) {
|
|
sqlite3_finalize(stmt);
|
|
cJSON_Delete(rows);
|
|
return NULL;
|
|
}
|
|
|
|
const char* sub_id = (const char*)sqlite3_column_text(stmt, 0);
|
|
const char* client_ip = (const char*)sqlite3_column_text(stmt, 1);
|
|
const char* filter_json = (const char*)sqlite3_column_text(stmt, 2);
|
|
long long events_sent = sqlite3_column_int64(stmt, 3);
|
|
long long created_at = sqlite3_column_int64(stmt, 4);
|
|
long long duration_seconds = sqlite3_column_int64(stmt, 5);
|
|
const char* wsi_pointer = (const char*)sqlite3_column_text(stmt, 6);
|
|
|
|
cJSON_AddStringToObject(row, "id", sub_id ? sub_id : "");
|
|
cJSON_AddStringToObject(row, "client_ip", client_ip ? client_ip : "");
|
|
cJSON_AddStringToObject(row, "filter_json", filter_json ? filter_json : "[]");
|
|
cJSON_AddNumberToObject(row, "events_sent", events_sent);
|
|
cJSON_AddNumberToObject(row, "created_at", created_at);
|
|
cJSON_AddNumberToObject(row, "duration_seconds", duration_seconds);
|
|
cJSON_AddStringToObject(row, "wsi_pointer", wsi_pointer ? wsi_pointer : "");
|
|
|
|
cJSON_AddItemToArray(rows, row);
|
|
}
|
|
|
|
sqlite3_finalize(stmt);
|
|
return rows;
|
|
}
|
|
|
|
cJSON* sqlite_db_get_all_config_rows(void) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db) return NULL;
|
|
|
|
sqlite3_stmt* stmt = NULL;
|
|
const char* sql = "SELECT key, value FROM config ORDER BY key";
|
|
if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) return NULL;
|
|
|
|
cJSON* rows = cJSON_CreateArray();
|
|
if (!rows) {
|
|
sqlite3_finalize(stmt);
|
|
return NULL;
|
|
}
|
|
|
|
while (sqlite3_step(stmt) == SQLITE_ROW) {
|
|
cJSON* row = cJSON_CreateObject();
|
|
if (!row) {
|
|
sqlite3_finalize(stmt);
|
|
cJSON_Delete(rows);
|
|
return NULL;
|
|
}
|
|
|
|
const char* key = (const char*)sqlite3_column_text(stmt, 0);
|
|
const char* value = (const char*)sqlite3_column_text(stmt, 1);
|
|
cJSON_AddStringToObject(row, "key", key ? key : "");
|
|
cJSON_AddStringToObject(row, "value", value ? value : "");
|
|
cJSON_AddItemToArray(rows, row);
|
|
}
|
|
|
|
sqlite3_finalize(stmt);
|
|
return rows;
|
|
}
|
|
|
|
char* sqlite_db_get_config_value_dup(const char* key) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db || !key) return NULL;
|
|
|
|
sqlite3_stmt* stmt = NULL;
|
|
const char* sql = "SELECT value FROM config WHERE key = ?";
|
|
if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) return NULL;
|
|
|
|
sqlite3_bind_text(stmt, 1, key, -1, SQLITE_TRANSIENT);
|
|
|
|
char* result = NULL;
|
|
if (sqlite3_step(stmt) == SQLITE_ROW) {
|
|
const char* value = (const char*)sqlite3_column_text(stmt, 0);
|
|
if (value) result = strdup(value);
|
|
}
|
|
|
|
sqlite3_finalize(stmt);
|
|
return result;
|
|
}
|
|
|
|
int sqlite_db_set_config_value_full(const char* key, const char* value, const char* data_type,
|
|
const char* description, const char* category, int requires_restart) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db || !key || !value || !data_type) return -1;
|
|
|
|
sqlite3_stmt* stmt = NULL;
|
|
const char* sql =
|
|
"INSERT OR REPLACE INTO config (key, value, data_type, description, category, requires_restart) "
|
|
"VALUES (?, ?, ?, ?, ?, ?)";
|
|
|
|
if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) {
|
|
return -1;
|
|
}
|
|
|
|
sqlite3_bind_text(stmt, 1, key, -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 2, value, -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 3, data_type, -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 4, description ? description : "", -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 5, category ? category : "general", -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_int(stmt, 6, requires_restart);
|
|
|
|
int rc = sqlite3_step(stmt);
|
|
sqlite3_finalize(stmt);
|
|
return (rc == SQLITE_DONE) ? 0 : -1;
|
|
}
|
|
|
|
int sqlite_db_update_config_value_only(const char* key, const char* value) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db || !key || !value) return -1;
|
|
|
|
sqlite3_stmt* stmt = NULL;
|
|
const char* sql = "UPDATE config SET value = ?, updated_at = strftime('%s', 'now') WHERE key = ?";
|
|
if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) {
|
|
return -1;
|
|
}
|
|
|
|
sqlite3_bind_text(stmt, 1, value, -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 2, key, -1, SQLITE_TRANSIENT);
|
|
|
|
int rc = sqlite3_step(stmt);
|
|
sqlite3_finalize(stmt);
|
|
return (rc == SQLITE_DONE) ? 0 : -1;
|
|
}
|
|
|
|
int sqlite_db_upsert_config_value(const char* key, const char* value, const char* data_type) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db || !key || !value || !data_type) return -1;
|
|
|
|
sqlite3_stmt* stmt = NULL;
|
|
const char* sql = "INSERT OR REPLACE INTO config (key, value, data_type) VALUES (?, ?, ?)";
|
|
|
|
if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) {
|
|
return -1;
|
|
}
|
|
|
|
sqlite3_bind_text(stmt, 1, key, -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 2, value, -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 3, data_type, -1, SQLITE_TRANSIENT);
|
|
|
|
int rc = sqlite3_step(stmt);
|
|
sqlite3_finalize(stmt);
|
|
return (rc == SQLITE_DONE) ? 0 : -1;
|
|
}
|
|
|
|
int sqlite_db_store_relay_private_key_hex(const char* relay_privkey_hex) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db || !relay_privkey_hex) return -1;
|
|
|
|
sqlite3_stmt* stmt = NULL;
|
|
const char* sql = "INSERT OR REPLACE INTO relay_seckey (private_key_hex) VALUES (?)";
|
|
if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) return -1;
|
|
|
|
sqlite3_bind_text(stmt, 1, relay_privkey_hex, -1, SQLITE_TRANSIENT);
|
|
int rc = sqlite3_step(stmt);
|
|
sqlite3_finalize(stmt);
|
|
|
|
return (rc == SQLITE_DONE) ? 0 : -1;
|
|
}
|
|
|
|
char* sqlite_db_get_relay_private_key_hex_dup(void) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db) return NULL;
|
|
|
|
sqlite3_stmt* stmt = NULL;
|
|
const char* sql = "SELECT private_key_hex FROM relay_seckey";
|
|
if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) return NULL;
|
|
|
|
char* result = NULL;
|
|
if (sqlite3_step(stmt) == SQLITE_ROW) {
|
|
const char* key_from_db = (const char*)sqlite3_column_text(stmt, 0);
|
|
if (key_from_db) result = strdup(key_from_db);
|
|
}
|
|
|
|
sqlite3_finalize(stmt);
|
|
return result;
|
|
}
|
|
|
|
int sqlite_db_store_config_event(const cJSON* event) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db || !event) return -1;
|
|
|
|
cJSON* id_obj = cJSON_GetObjectItemCaseSensitive((cJSON*)event, "id");
|
|
cJSON* pubkey_obj = cJSON_GetObjectItemCaseSensitive((cJSON*)event, "pubkey");
|
|
cJSON* created_at_obj = cJSON_GetObjectItemCaseSensitive((cJSON*)event, "created_at");
|
|
cJSON* kind_obj = cJSON_GetObjectItemCaseSensitive((cJSON*)event, "kind");
|
|
cJSON* content_obj = cJSON_GetObjectItemCaseSensitive((cJSON*)event, "content");
|
|
cJSON* sig_obj = cJSON_GetObjectItemCaseSensitive((cJSON*)event, "sig");
|
|
cJSON* tags_obj = cJSON_GetObjectItemCaseSensitive((cJSON*)event, "tags");
|
|
if (!id_obj || !pubkey_obj || !created_at_obj || !kind_obj || !content_obj || !sig_obj || !tags_obj) {
|
|
return -1;
|
|
}
|
|
|
|
char* tags_str = cJSON_Print(tags_obj);
|
|
if (!tags_str) return -1;
|
|
|
|
sqlite3_stmt* stmt = NULL;
|
|
const char* sql = "INSERT OR REPLACE INTO events (id, pubkey, created_at, kind, event_type, content, sig, tags) VALUES (?, ?, ?, ?, ?, ?, ?, ?)";
|
|
if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) {
|
|
free(tags_str);
|
|
return -1;
|
|
}
|
|
|
|
sqlite3_bind_text(stmt, 1, cJSON_GetStringValue(id_obj), -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 2, cJSON_GetStringValue(pubkey_obj), -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_int64(stmt, 3, (sqlite3_int64)cJSON_GetNumberValue(created_at_obj));
|
|
sqlite3_bind_int(stmt, 4, (int)cJSON_GetNumberValue(kind_obj));
|
|
sqlite3_bind_text(stmt, 5, "regular", -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 6, cJSON_GetStringValue(content_obj), -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 7, cJSON_GetStringValue(sig_obj), -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 8, tags_str, -1, SQLITE_TRANSIENT);
|
|
|
|
int rc = sqlite3_step(stmt);
|
|
sqlite3_finalize(stmt);
|
|
free(tags_str);
|
|
|
|
return (rc == SQLITE_DONE) ? 0 : -1;
|
|
}
|
|
|
|
static int sqlite_db_insert_event_tags_json_with_db(sqlite3* db, const char* event_id, const char* tags_json) {
|
|
if (!db || !event_id || !tags_json) {
|
|
return -1;
|
|
}
|
|
|
|
cJSON* tags = cJSON_Parse(tags_json);
|
|
if (!tags || !cJSON_IsArray(tags)) {
|
|
if (tags) cJSON_Delete(tags);
|
|
return 0;
|
|
}
|
|
|
|
const char* sql = "INSERT INTO event_tags (event_id, tag_name, tag_value, tag_index) VALUES (?, ?, ?, ?)";
|
|
sqlite3_stmt* stmt = NULL;
|
|
if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) {
|
|
cJSON_Delete(tags);
|
|
return -1;
|
|
}
|
|
|
|
int tag_index = 0;
|
|
cJSON* tag = NULL;
|
|
cJSON_ArrayForEach(tag, tags) {
|
|
if (cJSON_IsArray(tag) && cJSON_GetArraySize(tag) >= 2) {
|
|
cJSON* name = cJSON_GetArrayItem(tag, 0);
|
|
cJSON* value = cJSON_GetArrayItem(tag, 1);
|
|
if (cJSON_IsString(name) && cJSON_IsString(value)) {
|
|
sqlite3_reset(stmt);
|
|
sqlite3_clear_bindings(stmt);
|
|
sqlite3_bind_text(stmt, 1, event_id, -1, SQLITE_STATIC);
|
|
sqlite3_bind_text(stmt, 2, cJSON_GetStringValue(name), -1, SQLITE_STATIC);
|
|
sqlite3_bind_text(stmt, 3, cJSON_GetStringValue(value), -1, SQLITE_STATIC);
|
|
sqlite3_bind_int(stmt, 4, tag_index);
|
|
|
|
if (sqlite3_step(stmt) != SQLITE_DONE) {
|
|
DEBUG_WARN("Failed to insert event tag for %s: %s", event_id, sqlite3_errmsg(db));
|
|
}
|
|
}
|
|
}
|
|
tag_index++;
|
|
}
|
|
|
|
sqlite3_finalize(stmt);
|
|
cJSON_Delete(tags);
|
|
return 0;
|
|
}
|
|
|
|
int sqlite_db_insert_event_with_json(const char* id, const char* pubkey, long long created_at,
|
|
int kind, const char* event_type, const char* content,
|
|
const char* sig, const char* tags_json, const char* event_json,
|
|
int* out_step_rc, int* out_extended_errcode) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db || !id || !pubkey || !event_type || !content || !sig || !tags_json || !event_json) {
|
|
return -1;
|
|
}
|
|
|
|
const char* sql =
|
|
"INSERT INTO events (id, pubkey, created_at, kind, event_type, content, sig, tags, event_json) "
|
|
"VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)";
|
|
|
|
sqlite3_stmt* stmt = NULL;
|
|
if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) {
|
|
return -1;
|
|
}
|
|
|
|
sqlite3_bind_text(stmt, 1, id, -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 2, pubkey, -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_int64(stmt, 3, (sqlite3_int64)created_at);
|
|
sqlite3_bind_int(stmt, 4, kind);
|
|
sqlite3_bind_text(stmt, 5, event_type, -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 6, content, -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 7, sig, -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 8, tags_json, -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 9, event_json, -1, SQLITE_TRANSIENT);
|
|
|
|
int step_rc = sqlite3_step(stmt);
|
|
int extended_errcode = sqlite3_extended_errcode(db);
|
|
sqlite3_finalize(stmt);
|
|
|
|
if (step_rc == SQLITE_DONE) {
|
|
(void)sqlite_db_insert_event_tags_json_with_db(db, id, tags_json);
|
|
}
|
|
|
|
if (out_step_rc) {
|
|
*out_step_rc = step_rc;
|
|
}
|
|
if (out_extended_errcode) {
|
|
*out_extended_errcode = extended_errcode;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int sqlite_db_get_event_time_bounds(long long* out_min_created_at, long long* out_max_created_at) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db || !out_min_created_at || !out_max_created_at) return -1;
|
|
|
|
sqlite3_stmt* stmt = NULL;
|
|
const char* sql = "SELECT MIN(created_at), MAX(created_at) FROM events";
|
|
if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) {
|
|
return -1;
|
|
}
|
|
|
|
long long min_ts = 0;
|
|
long long max_ts = 0;
|
|
if (sqlite3_step(stmt) == SQLITE_ROW) {
|
|
min_ts = sqlite3_column_int64(stmt, 0);
|
|
max_ts = sqlite3_column_int64(stmt, 1);
|
|
}
|
|
|
|
sqlite3_finalize(stmt);
|
|
*out_min_created_at = min_ts;
|
|
*out_max_created_at = max_ts;
|
|
return 0;
|
|
}
|
|
|
|
int sqlite_db_event_id_exists(const char* event_id, int* out_exists) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db || !event_id || !out_exists) return -1;
|
|
|
|
sqlite3_stmt* stmt = NULL;
|
|
const char* sql = "SELECT 1 FROM events WHERE id=? LIMIT 1";
|
|
if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) return -1;
|
|
|
|
sqlite3_bind_text(stmt, 1, event_id, 64, SQLITE_STATIC);
|
|
int exists = (sqlite3_step(stmt) == SQLITE_ROW) ? 1 : 0;
|
|
sqlite3_finalize(stmt);
|
|
|
|
*out_exists = exists;
|
|
return 0;
|
|
}
|
|
|
|
cJSON* sqlite_db_retrieve_event_by_id(const char* event_id) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db || !event_id) return NULL;
|
|
|
|
const char* sql =
|
|
"SELECT id, pubkey, created_at, kind, content, sig, tags FROM events WHERE id = ?";
|
|
|
|
sqlite3_stmt* stmt = NULL;
|
|
if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) {
|
|
return NULL;
|
|
}
|
|
|
|
sqlite3_bind_text(stmt, 1, event_id, -1, SQLITE_STATIC);
|
|
|
|
cJSON* event = NULL;
|
|
if (sqlite3_step(stmt) == SQLITE_ROW) {
|
|
event = cJSON_CreateObject();
|
|
if (event) {
|
|
cJSON_AddStringToObject(event, "id", (const char*)sqlite3_column_text(stmt, 0));
|
|
cJSON_AddStringToObject(event, "pubkey", (const char*)sqlite3_column_text(stmt, 1));
|
|
cJSON_AddNumberToObject(event, "created_at", sqlite3_column_int64(stmt, 2));
|
|
cJSON_AddNumberToObject(event, "kind", sqlite3_column_int(stmt, 3));
|
|
cJSON_AddStringToObject(event, "content", (const char*)sqlite3_column_text(stmt, 4));
|
|
cJSON_AddStringToObject(event, "sig", (const char*)sqlite3_column_text(stmt, 5));
|
|
|
|
const char* tags_json = (const char*)sqlite3_column_text(stmt, 6);
|
|
if (tags_json) {
|
|
cJSON* tags = cJSON_Parse(tags_json);
|
|
if (tags) {
|
|
cJSON_AddItemToObject(event, "tags", tags);
|
|
} else {
|
|
cJSON_AddItemToObject(event, "tags", cJSON_CreateArray());
|
|
}
|
|
} else {
|
|
cJSON_AddItemToObject(event, "tags", cJSON_CreateArray());
|
|
}
|
|
}
|
|
}
|
|
|
|
sqlite3_finalize(stmt);
|
|
return event;
|
|
}
|
|
|
|
char* sqlite_db_get_latest_event_pubkey_for_kind_dup(int kind) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db) return NULL;
|
|
|
|
const char* sql = "SELECT pubkey FROM events WHERE kind = ? ORDER BY created_at DESC LIMIT 1";
|
|
sqlite3_stmt* stmt = NULL;
|
|
if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) {
|
|
return NULL;
|
|
}
|
|
|
|
sqlite3_bind_int(stmt, 1, kind);
|
|
|
|
char* pubkey_dup = NULL;
|
|
if (sqlite3_step(stmt) == SQLITE_ROW) {
|
|
const char* pubkey = (const char*)sqlite3_column_text(stmt, 0);
|
|
if (pubkey) {
|
|
pubkey_dup = strdup(pubkey);
|
|
}
|
|
}
|
|
|
|
sqlite3_finalize(stmt);
|
|
return pubkey_dup;
|
|
}
|
|
|
|
int sqlite_db_get_config_row_count(int* out_count) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db || !out_count) return -1;
|
|
|
|
sqlite3_stmt* stmt = NULL;
|
|
const char* sql = "SELECT COUNT(*) FROM config";
|
|
if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) {
|
|
return -1;
|
|
}
|
|
|
|
int count = 0;
|
|
if (sqlite3_step(stmt) == SQLITE_ROW) {
|
|
count = sqlite3_column_int(stmt, 0);
|
|
}
|
|
|
|
sqlite3_finalize(stmt);
|
|
*out_count = count;
|
|
return 0;
|
|
}
|
|
|
|
int sqlite_db_store_event_tags_cjson(const char* event_id, const cJSON* tags) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db || !event_id || !tags || !cJSON_IsArray(tags)) {
|
|
return 0; // Not an error if no tags
|
|
}
|
|
|
|
const char* sql = "INSERT INTO event_tags (event_id, tag_name, tag_value, tag_index) VALUES (?, ?, ?, ?)";
|
|
sqlite3_stmt* stmt = NULL;
|
|
int rc = sqlite3_prepare_v2(db, sql, -1, &stmt, NULL);
|
|
if (rc != SQLITE_OK) {
|
|
DEBUG_ERROR("Failed to prepare event_tags insert: %s", sqlite3_errmsg(db));
|
|
return -1;
|
|
}
|
|
|
|
int tag_index = 0;
|
|
cJSON* tag = NULL;
|
|
cJSON_ArrayForEach(tag, tags) {
|
|
if (cJSON_IsArray(tag) && cJSON_GetArraySize(tag) >= 2) {
|
|
cJSON* name = cJSON_GetArrayItem(tag, 0);
|
|
cJSON* value = cJSON_GetArrayItem(tag, 1);
|
|
|
|
if (cJSON_IsString(name) && cJSON_IsString(value)) {
|
|
sqlite3_reset(stmt);
|
|
sqlite3_bind_text(stmt, 1, event_id, -1, SQLITE_STATIC);
|
|
sqlite3_bind_text(stmt, 2, cJSON_GetStringValue(name), -1, SQLITE_STATIC);
|
|
sqlite3_bind_text(stmt, 3, cJSON_GetStringValue(value), -1, SQLITE_STATIC);
|
|
sqlite3_bind_int(stmt, 4, tag_index);
|
|
|
|
rc = sqlite3_step(stmt);
|
|
if (rc != SQLITE_DONE) {
|
|
DEBUG_ERROR("Failed to insert event tag: %s", sqlite3_errmsg(db));
|
|
}
|
|
}
|
|
}
|
|
tag_index++;
|
|
}
|
|
|
|
sqlite3_finalize(stmt);
|
|
return 0;
|
|
}
|
|
|
|
int sqlite_db_populate_event_tags_from_existing(void) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db) return -1;
|
|
|
|
sqlite3_stmt* check_stmt = NULL;
|
|
if (sqlite3_prepare_v2(db, "SELECT COUNT(*) FROM event_tags", -1, &check_stmt, NULL) != SQLITE_OK) {
|
|
return -1;
|
|
}
|
|
|
|
if (sqlite3_step(check_stmt) == SQLITE_ROW && sqlite3_column_int(check_stmt, 0) > 0) {
|
|
sqlite3_finalize(check_stmt);
|
|
DEBUG_INFO("event_tags already populated, skipping");
|
|
return 0;
|
|
}
|
|
sqlite3_finalize(check_stmt);
|
|
|
|
DEBUG_INFO("Populating event_tags from existing events...");
|
|
|
|
const char* sql = "SELECT id, tags FROM events WHERE tags != '[]'";
|
|
sqlite3_stmt* stmt = NULL;
|
|
int rc = sqlite3_prepare_v2(db, sql, -1, &stmt, NULL);
|
|
if (rc != SQLITE_OK) return -1;
|
|
|
|
sqlite3_exec(db, "BEGIN TRANSACTION", NULL, NULL, NULL);
|
|
|
|
int event_count = 0;
|
|
while (sqlite3_step(stmt) == SQLITE_ROW) {
|
|
const char* event_id = (const char*)sqlite3_column_text(stmt, 0);
|
|
const char* tags_json = (const char*)sqlite3_column_text(stmt, 1);
|
|
|
|
if (event_id && tags_json) {
|
|
cJSON* tags = cJSON_Parse(tags_json);
|
|
if (tags) {
|
|
sqlite_db_store_event_tags_cjson(event_id, tags);
|
|
cJSON_Delete(tags);
|
|
event_count++;
|
|
}
|
|
}
|
|
}
|
|
|
|
sqlite3_finalize(stmt);
|
|
sqlite3_exec(db, "COMMIT", NULL, NULL, NULL);
|
|
|
|
DEBUG_INFO("Populated event_tags for %d events", event_count);
|
|
return 0;
|
|
}
|
|
|
|
int sqlite_db_add_auth_rule(const char* rule_type, const char* pattern_type, const char* pattern_value) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db || !rule_type || !pattern_type || !pattern_value) return -1;
|
|
|
|
sqlite3_stmt* stmt = NULL;
|
|
const char* sql = "INSERT INTO auth_rules (rule_type, pattern_type, pattern_value) VALUES (?, ?, ?)";
|
|
if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) return -1;
|
|
|
|
sqlite3_bind_text(stmt, 1, rule_type, -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 2, pattern_type, -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 3, pattern_value, -1, SQLITE_TRANSIENT);
|
|
|
|
int rc = sqlite3_step(stmt);
|
|
sqlite3_finalize(stmt);
|
|
return (rc == SQLITE_DONE) ? 0 : -1;
|
|
}
|
|
|
|
int sqlite_db_remove_auth_rule(const char* rule_type, const char* pattern_type, const char* pattern_value) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db || !rule_type || !pattern_type || !pattern_value) return -1;
|
|
|
|
sqlite3_stmt* stmt = NULL;
|
|
const char* sql = "DELETE FROM auth_rules WHERE rule_type = ? AND pattern_type = ? AND pattern_value = ?";
|
|
if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) return -1;
|
|
|
|
sqlite3_bind_text(stmt, 1, rule_type, -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 2, pattern_type, -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 3, pattern_value, -1, SQLITE_TRANSIENT);
|
|
|
|
int rc = sqlite3_step(stmt);
|
|
sqlite3_finalize(stmt);
|
|
return (rc == SQLITE_DONE) ? 0 : -1;
|
|
}
|
|
|
|
int sqlite_db_delete_wot_whitelist_rules(void) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db) return -1;
|
|
|
|
const char* sql = "DELETE FROM auth_rules WHERE rule_type = 'wot_whitelist'";
|
|
int rc = sqlite3_exec(db, sql, NULL, NULL, NULL);
|
|
return (rc == SQLITE_OK) ? 0 : -1;
|
|
}
|
|
|
|
int sqlite_db_count_wot_whitelist_rules(void) {
|
|
if (!sqlite_db_is_available()) return 0;
|
|
|
|
const char* sql = "SELECT COUNT(*) FROM auth_rules WHERE rule_type = 'wot_whitelist' AND active = 1";
|
|
int count = 0;
|
|
if (sqlite_db_count_with_sql(sql, NULL, 0, &count) != 0) {
|
|
return 0;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
int sqlite_db_table_exists(const char* table_name, int* out_exists) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db || !table_name || !out_exists) return -1;
|
|
|
|
const char* sql = "SELECT 1 FROM sqlite_master WHERE type='table' AND name=? LIMIT 1";
|
|
sqlite3_stmt* stmt = NULL;
|
|
if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) {
|
|
return -1;
|
|
}
|
|
|
|
sqlite3_bind_text(stmt, 1, table_name, -1, SQLITE_TRANSIENT);
|
|
*out_exists = (sqlite3_step(stmt) == SQLITE_ROW) ? 1 : 0;
|
|
sqlite3_finalize(stmt);
|
|
return 0;
|
|
}
|
|
|
|
char* sqlite_db_get_schema_version_dup(void) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db) return NULL;
|
|
|
|
const char* sql = "SELECT value FROM schema_info WHERE key = 'version'";
|
|
sqlite3_stmt* stmt = NULL;
|
|
if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) {
|
|
return NULL;
|
|
}
|
|
|
|
char* result = NULL;
|
|
if (sqlite3_step(stmt) == SQLITE_ROW) {
|
|
const char* version = (const char*)sqlite3_column_text(stmt, 0);
|
|
if (version) {
|
|
result = strdup(version);
|
|
}
|
|
}
|
|
|
|
sqlite3_finalize(stmt);
|
|
return result;
|
|
}
|
|
|
|
int sqlite_db_exec_sql(const char* sql) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db || !sql) return -1;
|
|
|
|
int rc = sqlite3_exec(db, sql, NULL, NULL, NULL);
|
|
return (rc == SQLITE_OK) ? 0 : -1;
|
|
}
|
|
|
|
int sqlite_db_wal_checkpoint_passive(void) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db) return -1;
|
|
|
|
int rc = sqlite3_wal_checkpoint_v2(db, NULL, SQLITE_CHECKPOINT_PASSIVE, NULL, NULL);
|
|
return (rc == SQLITE_OK) ? 0 : -1;
|
|
}
|
|
|
|
int sqlite_db_wal_checkpoint_truncate(void) {
|
|
sqlite3* db = sqlite_db_active_connection();
|
|
if (!db) return -1;
|
|
|
|
int rc = sqlite3_wal_checkpoint_v2(db, NULL, SQLITE_CHECKPOINT_TRUNCATE, NULL, NULL);
|
|
return (rc == SQLITE_OK) ? 0 : -1;
|
|
}
|