ascii-chat
Binary v0.16.50-198-g78f51665f
Library lib/v0.3.2-2240-g78f51665f
Video chat in your terminal
Loading...
Searching...
No Matches
database.c File Reference

Go to the source code of this file.

Functions

asciichat_error_t database_init (const char *db_path, sqlite3 **db)
 Initialize database and create schema.
void database_close (sqlite3 *db)
 Close database.
asciichat_error_t database_session_create (sqlite3 *db, const acip_session_create_t *req, const acds_config_t *config, acip_session_created_t *resp)
 Create new session.
asciichat_error_t database_session_create_keys_with_transport (sqlite3 *db, const acip_session_create_t *req, const uint8_t(*keys)[32], size_t count, const acds_config_t *config, acip_session_created_t *resp, const void *metadata, size_t metadata_length)
asciichat_error_t database_session_create_keys (sqlite3 *db, const acip_session_create_t *req, const uint8_t(*keys)[32], size_t count, const acds_config_t *config, acip_session_created_t *resp)
asciichat_error_t database_session_lookup (sqlite3 *db, const char *session_string, const acds_config_t *config, acip_session_info_t *resp)
 Lookup session by string.
asciichat_error_t database_session_join (sqlite3 *db, const acip_session_join_t *req, const acds_config_t *config, acip_session_joined_t *resp)
 Join existing session.
asciichat_error_t database_session_leave (sqlite3 *db, const uint8_t session_id[16], const uint8_t participant_id[16])
 Leave session.
session_entry_t * database_session_find_by_id (sqlite3 *db, const uint8_t session_id[16])
 Find session by session_id.
session_entry_t * database_session_find_by_string (sqlite3 *db, const char *session_string)
 Find session by session_string.
void database_session_cleanup_expired (sqlite3 *db)
 Clean up inactive sessions.
asciichat_error_t database_session_update_host (sqlite3 *db, const uint8_t session_id[16], const uint8_t host_participant_id[16], const char *host_address, uint16_t host_port, uint8_t connection_type)
 Update session host (discovery mode).
asciichat_error_t database_session_clear_host (sqlite3 *db, const uint8_t session_id[16])
 Clear session host (discovery mode - host migration).
asciichat_error_t database_session_start_migration (sqlite3 *db, const uint8_t session_id[16])
 Start host migration (discovery mode).
bool database_session_is_migration_ready (sqlite3 *db, const uint8_t session_id[16], uint64_t migration_window_ms)
 Check if migration window has completed.
asciichat_error_t database_session_add_key (sqlite3 *db, const char *session_string, const uint8_t identity_pubkey[32], uint32_t key_version)
 Add a key to a session.
asciichat_error_t database_session_revoke_key (sqlite3 *db, const char *session_string, const uint8_t identity_pubkey[32])
 Revoke a key from a session.
bool database_session_verify_key (sqlite3 *db, const char *session_string, const uint8_t identity_pubkey[32])
 Check if a key is valid for a session (exists and not revoked).
asciichat_error_t database_session_get_keys (sqlite3 *db, const char *session_string, uint8_t(*keys_out)[32], size_t max_keys, size_t *count_out)
 Get all active keys for a session.
asciichat_error_t database_stats_session_count (sqlite3 *db, int64_t *count_out)
 Get total number of active sessions.
asciichat_error_t database_stats_unique_clients (sqlite3 *db, int64_t *count_out)
 Get total number of unique clients/participants.
asciichat_error_t database_stats_snapshot (sqlite3 *db, database_session_stats_t *rows, size_t capacity, size_t *row_count, uint64_t *sessions, uint64_t *participants)
asciichat_error_t database_session_transport_set (sqlite3 *db, const uint8_t session_id[16], const void *metadata, size_t length)
asciichat_error_t database_session_transport_get (sqlite3 *db, const uint8_t session_id[16], void *metadata, size_t capacity, size_t *length)
asciichat_error_t database_session_update_host_with_transport (sqlite3 *db, const uint8_t session[16], const uint8_t host[16], const char *address, uint16_t port, uint8_t type, const void *metadata, size_t length)

Function Documentation

◆ database_close()

void database_close ( sqlite3 * db)

Close database.

Parameters
dbDatabase handle to close

Definition at line 297 of file discovery/database.c.

297 {
298 ASCII_OTEL_SCOPE(DATABASE_CLOSE);
299 if (!db) {
300 return;
301 }
302 sqlite3_close(db);
303 log_debug("Database closed");
304}
#define log_debug(...)
Log a DEBUG message.
Definition log/log.h:589
#define ASCII_OTEL_SCOPE(id)
Definition otel.h:77

References ASCII_OTEL_SCOPE, and log_debug.

Referenced by acds_server_shutdown().

◆ database_init()

asciichat_error_t database_init ( const char * db_path,
sqlite3 ** db )

Initialize database and create schema.

Parameters
db_pathPath to SQLite database file
dbOutput database handle
Returns
ASCIICHAT_OK on success, error code otherwise

Definition at line 187 of file discovery/database.c.

187 {
188 ASCII_OTEL_SCOPE(DATABASE_INIT);
189 if (!db_path || !db) {
190 return SET_ERRNO(ERROR_INVALID_PARAM, "db_path or db is NULL");
191 }
192
193 log_info("Opening database: %s", db_path);
194
195 // Signaling workers share this connection; macOS SQLite defaults to multi-thread mode.
196 int rc = sqlite3_open_v2(db_path, db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX, NULL);
197 if (rc != SQLITE_OK) {
198 if (rc == SQLITE_BUSY || rc == SQLITE_LOCKED)
199 ascii_otel_metric(ASCII_OTEL_METRIC_DB_BUSY, 1);
200 const char *err = sqlite3_errmsg(*db);
201 sqlite3_close(*db);
202 *db = NULL;
203 return SET_ERRNO(ERROR_CONFIG, "Failed to open database: %s", err);
204 }
205
206 const gotel_query_catalog_t query_catalog = {database_queries, DATABASE_QUERY_COUNT, database_query_get};
207 ascii_otel_sqlite_catalog(*db, &query_catalog);
208 // Enable Write-Ahead Logging for concurrent reads
209 char *err_msg = NULL;
210 rc = sqlite3_exec(*db, database_queries[DATABASE_QUERY_EnableWAL].sql, NULL, NULL, &err_msg);
211 if (rc != SQLITE_OK) {
212 if (rc == SQLITE_BUSY || rc == SQLITE_LOCKED)
213 ascii_otel_metric(ASCII_OTEL_METRIC_DB_BUSY, 1);
214 log_warn("Failed to enable WAL mode: %s", err_msg ? err_msg : "unknown error");
215 sqlite3_free(err_msg);
216 }
217
218 // Enable foreign key constraints
219 rc = sqlite3_exec(*db, database_queries[DATABASE_QUERY_EnableForeignKeys].sql, NULL, NULL, &err_msg);
220 if (rc != SQLITE_OK) {
221 if (rc == SQLITE_BUSY || rc == SQLITE_LOCKED)
222 ascii_otel_metric(ASCII_OTEL_METRIC_DB_BUSY, 1);
223 log_error("Failed to enable foreign keys: %s", err_msg ? err_msg : "unknown error");
224 sqlite3_free(err_msg);
225 sqlite3_close(*db);
226 *db = NULL;
227 return SET_ERRNO(ERROR_CONFIG, "Failed to enable foreign keys");
228 }
229
230 // Create schema
234 for (size_t i = 0; i < sizeof(schema) / sizeof(schema[0]); ++i) {
235 rc = sqlite3_exec(*db, database_queries[schema[i]].sql, NULL, NULL, &err_msg);
236 if (rc != SQLITE_OK)
237 break;
238 }
239 if (rc != SQLITE_OK) {
240 if (rc == SQLITE_BUSY || rc == SQLITE_LOCKED)
241 ascii_otel_metric(ASCII_OTEL_METRIC_DB_BUSY, 1);
242 log_error("Failed to create schema: %s", err_msg ? err_msg : "unknown error");
243 sqlite3_free(err_msg);
244 sqlite3_close(*db);
245 *db = NULL;
246 return SET_ERRNO(ERROR_CONFIG, "Failed to create database schema");
247 }
248
249 rc = sqlite3_exec(*db, database_queries[DATABASE_QUERY_SchemaSessionTransports].sql, NULL, NULL, NULL);
250 if (rc == SQLITE_OK)
251 rc = sqlite3_exec(*db, database_queries[DATABASE_QUERY_SchemaSessionTransportHosts].sql, NULL, NULL, NULL);
252 if (rc == SQLITE_OK)
253 rc = sqlite3_exec(*db, database_queries[DATABASE_QUERY_SchemaClearTransportsTrigger].sql, NULL, NULL, NULL);
254 if (rc != SQLITE_OK) {
255 sqlite3_close(*db);
256 *db = NULL;
257 return SET_ERRNO(ERROR_CONFIG, "Cannot create discovery transport metadata table");
258 }
259
260 // Idempotent, transactional migration from the untyped key table. A policy
261 // row is also the migration marker: reopening must never restore revoked keys.
262 sqlite3_stmt *legacy_table = NULL;
263 rc = ascii_otel_sqlite_prepare(*db, database_queries[DATABASE_QUERY_HasLegacySessionKeys].sql, &legacy_table);
264 bool has_legacy_keys = false;
265 if (rc == SQLITE_OK) {
266 rc = sqlite3_step(legacy_table);
267 has_legacy_keys = rc == SQLITE_ROW;
268 if (rc == SQLITE_ROW || rc == SQLITE_DONE)
269 rc = SQLITE_OK;
270 }
271 sqlite3_finalize(legacy_table);
273 for (size_t i = 0; rc == SQLITE_OK && i < sizeof(migration_schema) / sizeof(migration_schema[0]); ++i)
274 rc = sqlite3_exec(*db, database_queries[migration_schema[i]].sql, NULL, NULL, &err_msg);
275 if (rc == SQLITE_OK && has_legacy_keys) {
276 // Read legacy keys only during migration; new databases do not create the
277 // superseded table or its indexes. Existing tables remain intact.
278 const char *legacy_import = database_queries[DATABASE_QUERY_ImportLegacySessionKeys].sql;
279 rc = sqlite3_exec(*db, legacy_import, NULL, NULL, &err_msg);
280 }
282 for (size_t i = 0; rc == SQLITE_OK && i < sizeof(migration_backfill) / sizeof(migration_backfill[0]); ++i)
283 rc = sqlite3_exec(*db, database_queries[migration_backfill[i]].sql, NULL, NULL, &err_msg);
284 if (rc != SQLITE_OK) {
285 log_error("Failed to migrate session keys: %s", err_msg ? err_msg : "unknown error");
286 sqlite3_free(err_msg);
287 sqlite3_exec(*db, database_queries[DATABASE_QUERY_RollbackTransaction].sql, NULL, NULL, NULL);
288 sqlite3_close(*db);
289 *db = NULL;
290 return SET_ERRNO(ERROR_CONFIG, "Failed to migrate session keys");
291 }
292
293 log_info("Database initialized successfully (SQLite as single source of truth)");
294 return ASCIICHAT_OK;
295}
#define SET_ERRNO(code,...)
@ ASCIICHAT_OK
Definition error_codes.h:50
@ ERROR_CONFIG
Definition error_codes.h:56
@ ERROR_INVALID_PARAM
#define log_warn(...)
Log a WARN message.
Definition log/log.h:615
#define log_error(...)
Log an ERROR message.
Definition log/log.h:628
#define log_info(...)
Log an INFO message.
Definition log/log.h:602
int ascii_otel_sqlite_prepare(sqlite3 *db, const char *sql, sqlite3_stmt **statement)
Definition otel.c:813
void ascii_otel_sqlite_catalog(sqlite3 *db, const gotel_query_catalog_t *catalog)
Definition otel.c:829
void ascii_otel_metric(ascii_otel_metric_t metric, double value)
Definition otel.c:159
@ DATABASE_QUERY_RollbackTransaction
@ DATABASE_QUERY_EnableForeignKeys
@ DATABASE_QUERY_SchemaSessionTransports
@ DATABASE_QUERY_ImportLegacySessionKeys
@ DATABASE_QUERY_EnableWAL
@ DATABASE_QUERY_SchemaParticipants
@ DATABASE_QUERY_SchemaIdxRateEvents
@ DATABASE_QUERY_SchemaIdentityKeys
@ DATABASE_QUERY_SchemaIdxParticipantsSession
@ DATABASE_QUERY_BackfillSessionKeyPolicy
@ DATABASE_QUERY_SchemaClearTransportsTrigger
@ DATABASE_QUERY_COUNT
@ DATABASE_QUERY_SchemaSessions
@ DATABASE_QUERY_SchemaSessionTransportHosts
@ DATABASE_QUERY_SchemaIdxSessionsId
@ DATABASE_QUERY_BackfillSessionIdentityKeys
@ DATABASE_QUERY_SchemaIdxSessionsActivity
@ DATABASE_QUERY_HasLegacySessionKeys
@ DATABASE_QUERY_CommitTransaction
@ DATABASE_QUERY_SchemaRateEvents
@ DATABASE_QUERY_SchemaKeyPolicy
@ DATABASE_QUERY_BeginTransaction
enum database_query_id database_query_id_t

References ascii_otel_metric(), ASCII_OTEL_SCOPE, ascii_otel_sqlite_catalog(), ascii_otel_sqlite_prepare(), ASCIICHAT_OK, DATABASE_QUERY_BackfillSessionIdentityKeys, DATABASE_QUERY_BackfillSessionKeyPolicy, DATABASE_QUERY_BeginTransaction, DATABASE_QUERY_CommitTransaction, DATABASE_QUERY_COUNT, DATABASE_QUERY_EnableForeignKeys, DATABASE_QUERY_EnableWAL, DATABASE_QUERY_HasLegacySessionKeys, DATABASE_QUERY_ImportLegacySessionKeys, DATABASE_QUERY_RollbackTransaction, DATABASE_QUERY_SchemaClearTransportsTrigger, DATABASE_QUERY_SchemaIdentityKeys, DATABASE_QUERY_SchemaIdxParticipantsSession, DATABASE_QUERY_SchemaIdxRateEvents, DATABASE_QUERY_SchemaIdxSessionsActivity, DATABASE_QUERY_SchemaIdxSessionsId, DATABASE_QUERY_SchemaKeyPolicy, DATABASE_QUERY_SchemaParticipants, DATABASE_QUERY_SchemaRateEvents, DATABASE_QUERY_SchemaSessions, DATABASE_QUERY_SchemaSessionTransportHosts, DATABASE_QUERY_SchemaSessionTransports, ERROR_CONFIG, ERROR_INVALID_PARAM, log_error, log_info, log_warn, and SET_ERRNO.

Referenced by acds_server_init().

◆ database_session_add_key()

asciichat_error_t database_session_add_key ( sqlite3 * db,
const char * session_string,
const uint8_t identity_pubkey[32],
uint32_t key_version )

Add a key to a session.

Parameters
dbDatabase handle
session_stringSession string
identity_pubkeyEd25519 public key (32 bytes)
key_versionKey version for tracking rotation
Returns
ASCIICHAT_OK on success, error code otherwise

Definition at line 1303 of file discovery/database.c.

1303 {
1304 ASCII_OTEL_SCOPE(DATABASE_ADD_KEY);
1305 if (!db || !session_string || !identity_pubkey || sodium_is_zero(identity_pubkey, 32)) {
1306 return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters for add_key");
1307 }
1308
1309 const char *sql = database_queries[DATABASE_QUERY_AddSessionKey].sql;
1310
1311 sqlite3_stmt *stmt = NULL;
1312 if (ascii_otel_sqlite_prepare(db, sql, &stmt) != SQLITE_OK) {
1313 return SET_ERRNO(ERROR_CONFIG, "Failed to prepare add_key statement: %s", sqlite3_errmsg(db));
1314 }
1315
1316 if ((sqlite3_bind_text(stmt, sqlite3_bind_parameter_index(stmt, ":session_string"), session_string, -1, SQLITE_STATIC) != SQLITE_OK) ||
1317 (sqlite3_bind_blob(stmt, sqlite3_bind_parameter_index(stmt, ":identity_pubkey"), identity_pubkey, 32, SQLITE_STATIC) != SQLITE_OK) ||
1318 (sqlite3_bind_int(stmt, sqlite3_bind_parameter_index(stmt, ":key_version"), key_version) != SQLITE_OK) ||
1319 (sqlite3_bind_int64(stmt, sqlite3_bind_parameter_index(stmt, ":added_at"), database_get_current_time_ms()) != SQLITE_OK)) {
1320 sqlite3_finalize(stmt);
1321 return SET_ERRNO(ERROR_CONFIG, "Failed to bind SQLite query parameters");
1322 }
1323
1324 int rc = sqlite3_step(stmt);
1325 sqlite3_finalize(stmt);
1326
1327 if (rc != SQLITE_DONE) {
1328 if (rc == SQLITE_BUSY || rc == SQLITE_LOCKED)
1329 ascii_otel_metric(ASCII_OTEL_METRIC_DB_BUSY, 1);
1330 return SET_ERRNO(ERROR_CONFIG, "Failed to add session key: %s", sqlite3_errmsg(db));
1331 }
1332
1333 log_debug("Added key to session %s (version=%u)", session_string, key_version);
1334 return ASCIICHAT_OK;
1335}
@ DATABASE_QUERY_AddSessionKey

References ascii_otel_metric(), ASCII_OTEL_SCOPE, ascii_otel_sqlite_prepare(), ASCIICHAT_OK, DATABASE_QUERY_AddSessionKey, ED25519_PUBLIC_KEY_SIZE, ERROR_CONFIG, ERROR_INVALID_PARAM, log_debug, and SET_ERRNO.

◆ database_session_cleanup_expired()

void database_session_cleanup_expired ( sqlite3 * db)

Clean up inactive sessions.

Removes sessions that have been inactive for more than 3 hours. Inactivity is measured by last_activity_at (updated on join/leave/host updates). Called periodically by background cleanup thread.

Parameters
dbDatabase handle

Definition at line 1071 of file discovery/database.c.

1071 {
1072 ASCII_OTEL_SCOPE(DATABASE_SESSION_CLEANUP_EXPIRED);
1073 if (!db) {
1074 return;
1075 }
1076
1077 uint64_t now = database_get_current_time_ms();
1078 // 3 hours in milliseconds
1079 uint64_t inactivity_threshold = 3ULL * SEC_PER_HOUR * MS_PER_SEC_INT;
1080 uint64_t cutoff_time = now - inactivity_threshold;
1081
1082 // Log sessions about to be deleted
1083 const char *log_sql = database_queries[DATABASE_QUERY_FindExpiredSessions].sql;
1084 sqlite3_stmt *stmt = NULL;
1085 if (ascii_otel_sqlite_prepare(db, log_sql, &stmt) == SQLITE_OK) {
1086 if ((sqlite3_bind_int64(stmt, sqlite3_bind_parameter_index(stmt, ":cutoff_time"), (sqlite3_int64)cutoff_time) != SQLITE_OK)) {
1087 sqlite3_finalize(stmt);
1088 log_error("Failed to bind SQLite query parameters");
1089 return;
1090 }
1091 while (sqlite3_step(stmt) == SQLITE_ROW) {
1092 const char *session_string = (const char *)sqlite3_column_text(stmt, 0);
1093 uint64_t last_activity = (uint64_t)sqlite3_column_int64(stmt, 1);
1094 uint64_t inactive_ms = now - last_activity;
1095 uint64_t inactive_hours = inactive_ms / (SEC_PER_HOUR * MS_PER_SEC_INT);
1096 log_info("Session %s inactive for %lu hours, deleting", session_string ? session_string : "<unknown>", inactive_hours);
1097 }
1098 sqlite3_finalize(stmt);
1099 }
1100
1101 // Delete inactive sessions (CASCADE deletes participants)
1102 const char *del_sql = database_queries[DATABASE_QUERY_DeleteExpiredSessions].sql;
1103 if (ascii_otel_sqlite_prepare(db, del_sql, &stmt) == SQLITE_OK) {
1104 if ((sqlite3_bind_int64(stmt, sqlite3_bind_parameter_index(stmt, ":cutoff_time"), (sqlite3_int64)cutoff_time) != SQLITE_OK)) {
1105 sqlite3_finalize(stmt);
1106 log_error("Failed to bind SQLite query parameters");
1107 return;
1108 }
1109 sqlite3_step(stmt);
1110 int deleted = sqlite3_changes(db);
1111 sqlite3_finalize(stmt);
1112
1113 if (deleted > 0) {
1115 log_info("Cleaned up %d inactive sessions (>3 hours)", deleted);
1116 }
1117 }
1118}
unsigned long long uint64_t
#define SEC_PER_HOUR
Definition time.h:184
#define MS_PER_SEC_INT
Definition time.h:180
@ STATS_COUNTER_SESSION_EXPIRATIONS
void stats_counter_add(stats_scope_t *scope, stats_counter_id_t id, uint64_t amount)
@ DATABASE_QUERY_DeleteExpiredSessions
@ DATABASE_QUERY_FindExpiredSessions
stats_scope_t * stats_runtime_scope(void)
Definition runtime.c:78

References ASCII_OTEL_SCOPE, ascii_otel_sqlite_prepare(), DATABASE_QUERY_DeleteExpiredSessions, DATABASE_QUERY_FindExpiredSessions, log_error, log_info, MS_PER_SEC_INT, SEC_PER_HOUR, stats_counter_add(), STATS_COUNTER_SESSION_EXPIRATIONS, and stats_runtime_scope().

◆ database_session_clear_host()

asciichat_error_t database_session_clear_host ( sqlite3 * db,
const uint8_t session_id[16] )

Clear session host (discovery mode - host migration).

Called when the current host disconnects or fails. Clears host fields so remaining participants can negotiate a new host.

Parameters
dbDatabase handle
session_idSession UUID
Returns
ASCIICHAT_OK on success, error code otherwise

Definition at line 1173 of file discovery/database.c.

1173 {
1174 ASCII_OTEL_SCOPE(DATABASE_SESSION_CLEAR_HOST);
1175 if (!db || !session_id) {
1176 return SET_ERRNO(ERROR_INVALID_PARAM, "db or session_id is NULL");
1177 }
1178
1179 const char *sql = database_queries[DATABASE_QUERY_ClearHost].sql;
1180
1181 sqlite3_stmt *stmt = NULL;
1182 int rc = ascii_otel_sqlite_prepare(db, sql, &stmt);
1183 if (rc != SQLITE_OK) {
1184 if (rc == SQLITE_BUSY || rc == SQLITE_LOCKED)
1185 ascii_otel_metric(ASCII_OTEL_METRIC_DB_BUSY, 1);
1186 return SET_ERRNO(ERROR_CONFIG, "Failed to prepare host clear: %s", sqlite3_errmsg(db));
1187 }
1188
1189 if ((sqlite3_bind_blob(stmt, sqlite3_bind_parameter_index(stmt, ":session_id"), session_id, 16, SQLITE_STATIC) != SQLITE_OK)) {
1190 sqlite3_finalize(stmt);
1191 return SET_ERRNO(ERROR_CONFIG, "Failed to bind SQLite query parameters");
1192 }
1193
1194 rc = sqlite3_step(stmt);
1195 if (rc == SQLITE_DONE && !sqlite3_stmt_readonly(stmt))
1196 ascii_otel_metric(ASCII_OTEL_METRIC_DB_ROWS, sqlite3_changes(db));
1197 sqlite3_finalize(stmt);
1198
1199 if (rc != SQLITE_DONE) {
1200 if (rc == SQLITE_BUSY || rc == SQLITE_LOCKED)
1201 ascii_otel_metric(ASCII_OTEL_METRIC_DB_BUSY, 1);
1202 return SET_ERRNO(ERROR_CONFIG, "Failed to clear host: %s", sqlite3_errmsg(db));
1203 }
1204
1205 int changes = sqlite3_changes(db);
1206 if (changes == 0) {
1207 return SET_ERRNO(ERROR_INVALID_STATE, "Session not found for host clear");
1208 }
1209
1210 log_info("Session host cleared (session=%02x%02x...) - ready for migration", session_id[0], session_id[1]);
1211
1212 return ASCIICHAT_OK;
1213}
@ ERROR_INVALID_STATE
@ DATABASE_QUERY_ClearHost
uint8_t session_id[SESSION_ID_SIZE]

References ascii_otel_metric(), ASCII_OTEL_SCOPE, ascii_otel_sqlite_prepare(), ASCIICHAT_OK, DATABASE_QUERY_ClearHost, ERROR_CONFIG, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, log_info, session_id, SESSION_ID_SIZE, and SET_ERRNO.

◆ database_session_create()

asciichat_error_t database_session_create ( sqlite3 * db,
const acip_session_create_t * req,
const acds_config_t * config,
acip_session_created_t * resp )

Create new session.

Parameters
dbDatabase handle
reqSession creation request
configACDS server configuration
respSession creation response (output)
Returns
ASCIICHAT_OK on success, error code otherwise

Definition at line 411 of file discovery/database.c.

411 {
412 if (!req)
413 return SET_ERRNO(ERROR_INVALID_PARAM, "Missing create request");
414 return database_session_create_keys(db, req, (const uint8_t (*)[32]) & req->identity_pubkey, 1, config, resp);
415}
asciichat_error_t database_session_create_keys(sqlite3 *db, const acip_session_create_t *req, const uint8_t(*keys)[32], size_t count, const acds_config_t *config, acip_session_created_t *resp)
unsigned char uint8_t

References acip_session_create_t, acip_session_created_t, database_session_create_keys(), ERROR_INVALID_PARAM, and SET_ERRNO.

◆ database_session_create_keys()

asciichat_error_t database_session_create_keys ( sqlite3 * db,
const acip_session_create_t * req,
const uint8_t(*) keys[32],
size_t count,
const acds_config_t * config,
acip_session_created_t * resp )

Create an explicit Ed25519 key set atomically. More than one key opts into allowlisted joins; count=1 preserves the legacy admission policy. The caller must verify each create proof before calling this persistence API.

Definition at line 481 of file discovery/database.c.

481 {
482 return database_session_create_keys_with_transport(db, req, keys, count, config, resp, NULL, 0);
483}
asciichat_error_t database_session_create_keys_with_transport(sqlite3 *db, const acip_session_create_t *req, const uint8_t(*keys)[32], size_t count, const acds_config_t *config, acip_session_created_t *resp, const void *metadata, size_t metadata_length)

References acip_session_create_t, acip_session_created_t, and database_session_create_keys_with_transport().

Referenced by database_session_create().

◆ database_session_create_keys_with_transport()

asciichat_error_t database_session_create_keys_with_transport ( sqlite3 * db,
const acip_session_create_t * req,
const uint8_t(*) keys[32],
size_t count,
const acds_config_t * config,
acip_session_created_t * resp,
const void * metadata,
size_t metadata_length )

Persist advertised transports in the same transaction as the session and key set.

Definition at line 468 of file discovery/database.c.

469 {
470 if (!db)
471 return SET_ERRNO(ERROR_INVALID_PARAM, "Missing database");
472 // SQLite serializes statements, but a shared connection also needs to keep
473 // other client threads out of this multi-statement savepoint.
474 sqlite3_mutex *mutex = sqlite3_db_mutex(db);
475 sqlite3_mutex_enter(mutex);
476 asciichat_error_t result = database_session_create_keys_locked(db, req, keys, count, config, resp, metadata, metadata_length);
477 sqlite3_mutex_leave(mutex);
478 return result;
479}
asciichat_error_t
Error and exit codes - unified status values (0-255).
Definition error_codes.h:48

References acip_session_create_t, acip_session_created_t, ERROR_INVALID_PARAM, and SET_ERRNO.

Referenced by database_session_create_keys().

◆ database_session_find_by_id()

session_entry_t * database_session_find_by_id ( sqlite3 * db,
const uint8_t session_id[16] )

Find session by session_id.

Allocates and returns a session_entry_t. Caller must free with session_entry_destroy().

Parameters
dbDatabase handle
session_idSession UUID to find
Returns
Allocated session entry (caller owns), or NULL if not found

Definition at line 1011 of file discovery/database.c.

1011 {
1012 if (!db || !session_id) {
1013 return NULL;
1014 }
1015
1016 const char *sql = database_queries[DATABASE_QUERY_GetSessionById].sql;
1017
1018 sqlite3_stmt *stmt = NULL;
1019 if (ascii_otel_sqlite_prepare(db, sql, &stmt) != SQLITE_OK) {
1020 return NULL;
1021 }
1022
1023 if ((sqlite3_bind_blob(stmt, sqlite3_bind_parameter_index(stmt, ":session_id"), session_id, 16, SQLITE_STATIC) != SQLITE_OK)) {
1024 sqlite3_finalize(stmt);
1025 log_error("Failed to bind SQLite query parameters");
1026 return NULL;
1027 }
1028
1029 session_entry_t *session = NULL;
1030 if (sqlite3_step(stmt) == SQLITE_ROW) {
1031 session = load_session_from_row(stmt);
1032 if (session) {
1033 load_session_participants(db, session);
1034 }
1035 }
1036
1037 sqlite3_finalize(stmt);
1038 return session;
1039}
struct session_entry session_entry_t
Persisted discovery-session record used to admit and route participants.
@ DATABASE_QUERY_GetSessionById

References ascii_otel_sqlite_prepare(), DATABASE_QUERY_GetSessionById, log_error, session_id, and SESSION_ID_SIZE.

Referenced by acds_send_current_host(), signaling_broadcast(), signaling_relay_ice(), and signaling_relay_sdp().

◆ database_session_find_by_string()

session_entry_t * database_session_find_by_string ( sqlite3 * db,
const char * session_string )

Find session by session_string.

Allocates and returns a session_entry_t. Caller must free with session_entry_destroy().

Parameters
dbDatabase handle
session_stringSession string to find
Returns
Allocated session entry (caller owns), or NULL if not found

Definition at line 1041 of file discovery/database.c.

1041 {
1042 if (!db || !session_string) {
1043 return NULL;
1044 }
1045
1046 const char *sql = database_queries[DATABASE_QUERY_GetSessionByString].sql;
1047
1048 sqlite3_stmt *stmt = NULL;
1049 if (ascii_otel_sqlite_prepare(db, sql, &stmt) != SQLITE_OK) {
1050 return NULL;
1051 }
1052
1053 if ((sqlite3_bind_text(stmt, sqlite3_bind_parameter_index(stmt, ":session_string"), session_string, -1, SQLITE_STATIC) != SQLITE_OK)) {
1054 sqlite3_finalize(stmt);
1055 log_error("Failed to bind SQLite query parameters");
1056 return NULL;
1057 }
1058
1059 session_entry_t *session = NULL;
1060 if (sqlite3_step(stmt) == SQLITE_ROW) {
1061 session = load_session_from_row(stmt);
1062 if (session) {
1063 load_session_participants(db, session);
1064 }
1065 }
1066
1067 sqlite3_finalize(stmt);
1068 return session;
1069}
@ DATABASE_QUERY_GetSessionByString

References ascii_otel_sqlite_prepare(), DATABASE_QUERY_GetSessionByString, and log_error.

Referenced by database_session_join().

◆ database_session_get_keys()

asciichat_error_t database_session_get_keys ( sqlite3 * db,
const char * session_string,
uint8_t(*) keys_out[32],
size_t max_keys,
size_t * count_out )

Get all active keys for a session.

Parameters
dbDatabase handle
session_stringSession string
keys_outOutput array for keys (caller must provide buffer)
max_keysMaximum number of keys to retrieve
count_outOutput: number of keys retrieved
Returns
ASCIICHAT_OK on success, error code otherwise

Definition at line 1395 of file discovery/database.c.

1395 {
1396 ASCII_OTEL_SCOPE(DATABASE_GET_KEYS);
1397 if (!db || !session_string || !keys_out || !count_out) {
1398 return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters for get_keys");
1399 }
1400
1401 const char *sql = database_queries[DATABASE_QUERY_GetSessionKeys].sql;
1402
1403 sqlite3_stmt *stmt = NULL;
1404 if (ascii_otel_sqlite_prepare(db, sql, &stmt) != SQLITE_OK) {
1405 return SET_ERRNO(ERROR_CONFIG, "Failed to prepare get_keys statement: %s", sqlite3_errmsg(db));
1406 }
1407
1408 if ((sqlite3_bind_text(stmt, sqlite3_bind_parameter_index(stmt, ":session_string"), session_string, -1, SQLITE_STATIC) != SQLITE_OK)) {
1409 sqlite3_finalize(stmt);
1410 return SET_ERRNO(ERROR_CONFIG, "Failed to bind SQLite query parameters");
1411 }
1412
1413 size_t count = 0;
1414 while (sqlite3_step(stmt) == SQLITE_ROW && count < max_keys) {
1415 const void *blob = sqlite3_column_blob(stmt, 0);
1416 if (blob && sqlite3_column_bytes(stmt, 0) == 32) {
1417 memcpy(keys_out[count], blob, ED25519_PUBLIC_KEY_SIZE);
1418 count++;
1419 }
1420 }
1421
1422 sqlite3_finalize(stmt);
1423 *count_out = count;
1424
1425 log_debug("Retrieved %zu keys for session %s", count, session_string);
1426 return ASCIICHAT_OK;
1427}
@ DATABASE_QUERY_GetSessionKeys
#define ED25519_PUBLIC_KEY_SIZE
Ed25519 public key size in bytes.
Definition sizes.h:37

References ASCII_OTEL_SCOPE, ascii_otel_sqlite_prepare(), ASCIICHAT_OK, DATABASE_QUERY_GetSessionKeys, ED25519_PUBLIC_KEY_SIZE, ERROR_CONFIG, ERROR_INVALID_PARAM, log_debug, and SET_ERRNO.

◆ database_session_is_migration_ready()

bool database_session_is_migration_ready ( sqlite3 * db,
const uint8_t session_id[16],
uint64_t migration_window_ms )

Check if migration window has completed.

Called periodically to check if migration collection window timeout has expired. Returns the session if migration is ready for host election.

Parameters
dbDatabase handle
session_idSession UUID
migration_window_msCollection window duration in milliseconds
Returns
true if collection window has completed, false otherwise

Definition at line 1260 of file discovery/database.c.

1260 {
1261 ASCII_OTEL_SCOPE(DATABASE_MIGRATION_READY);
1262 if (!db || !session_id) {
1263 return false;
1264 }
1265
1266 uint64_t now_ns = time_get_realtime_ns();
1267 const char *sql = database_queries[DATABASE_QUERY_GetMigrationState].sql;
1268
1269 sqlite3_stmt *stmt = NULL;
1270 if (ascii_otel_sqlite_prepare(db, sql, &stmt) != SQLITE_OK) {
1271 return false;
1272 }
1273
1274 if ((sqlite3_bind_blob(stmt, sqlite3_bind_parameter_index(stmt, ":session_id"), session_id, 16, SQLITE_STATIC) != SQLITE_OK)) {
1275 sqlite3_finalize(stmt);
1276 log_error("Failed to bind SQLite query parameters");
1277 return false;
1278 }
1279
1280 bool ready = false;
1281 if (sqlite3_step(stmt) == SQLITE_ROW) {
1282 int in_migration = sqlite3_column_int(stmt, 0);
1283 uint64_t migration_start_ns = (uint64_t)sqlite3_column_int64(stmt, 1);
1284
1285 if (in_migration) {
1286 uint64_t elapsed_ns = now_ns - migration_start_ns;
1287 uint64_t migration_window_ns = migration_window_ms * NS_PER_MS_INT;
1288 if (elapsed_ns >= migration_window_ns) {
1289 ready = true;
1290 log_debug("Migration window complete (session=%02x%02x..., elapsed=%lu ns, window=%lu ns)", session_id[0], session_id[1], elapsed_ns, migration_window_ns);
1291 }
1292 }
1293 }
1294
1295 sqlite3_finalize(stmt);
1296 return ready;
1297}
#define NS_PER_MS_INT
Definition time.h:172
@ DATABASE_QUERY_GetMigrationState

References ASCII_OTEL_SCOPE, ascii_otel_sqlite_prepare(), DATABASE_QUERY_GetMigrationState, log_debug, log_error, NS_PER_MS_INT, session_id, and SESSION_ID_SIZE.

Referenced by database_session_update_host().

◆ database_session_join()

asciichat_error_t database_session_join ( sqlite3 * db,
const acip_session_join_t * req,
const acds_config_t * config,
acip_session_joined_t * resp )

Join existing session.

Parameters
dbDatabase handle
reqJoin request
configACDS server configuration (for TURN credentials)
respJoin response (output)
Returns
ASCIICHAT_OK on success, error code otherwise

Definition at line 779 of file discovery/database.c.

779 {
780 ASCII_OTEL_SCOPE(DATABASE_SESSION_JOIN);
781 if (!db || !req || !config || !resp) {
782 return SET_ERRNO(ERROR_INVALID_PARAM, "db, req, config, or resp is NULL");
783 }
784
785 memset(resp, 0, sizeof(*resp));
786 resp->success = 0;
787
788 if (req->session_string_len == 0 || req->session_string_len >= sizeof(req->session_string) || memchr(req->session_string, '\0', (size_t)req->session_string_len) ||
789 req->session_string[req->session_string_len] != '\0' || (req->has_password && !memchr(req->password, '\0', sizeof(req->password))))
790 return SET_ERRNO(ERROR_INVALID_PARAM, "Malformed join request");
791
792 // Extract session string
793 char session_string[ACIP_MAX_SESSION_STRING_LEN] = {0};
794 size_t len = req->session_string_len < (ACIP_MAX_SESSION_STRING_LEN - 1) ? req->session_string_len : (ACIP_MAX_SESSION_STRING_LEN - 1);
795 memcpy(session_string, req->session_string, len);
796 session_string[len] = '\0';
797
798 // Find session
799 session_entry_t *session = database_session_find_by_string(db, session_string);
800 if (!session) {
801 ascii_otel_metric(ASCII_OTEL_METRIC_LOOKUP_MISS, 1);
802 resp->error_code = ACIP_ERROR_SESSION_NOT_FOUND;
803 SAFE_STRNCPY(resp->error_message, "Session not found", sizeof(resp->error_message));
804 log_warn("Session join failed: %s (not found)", session_string);
805 return ASCIICHAT_OK;
806 }
807
808 // Reject unauthorized identities before spending Argon2 resources or revealing
809 // a password result. This preliminary check is repeated in the transaction.
810 sqlite3_mutex *mutex = sqlite3_db_mutex(db);
811 sqlite3_mutex_enter(mutex);
812 asciichat_error_t result = database_session_authorize_join(db, req, config, session_string, resp);
813 sqlite3_mutex_leave(mutex);
814 if (result != ASCIICHAT_OK || resp->error_code != ACIP_ERROR_NONE) {
815 session_entry_destroy(session);
816 return result;
817 }
818
819 // Check if session is full
820 if (session->current_participants >= session->max_participants) {
821 session_entry_destroy(session);
822 resp->error_code = ACIP_ERROR_SESSION_FULL;
823 SAFE_STRNCPY(resp->error_message, "Session is full", sizeof(resp->error_message));
824 log_warn("Session join failed: %s (full)", session_string);
825 return ASCIICHAT_OK;
826 }
827
828 // Verify password if required
829 if (session->has_password && req->has_password) {
830 if (!verify_password(req->password, session->password_hash)) {
831 session_entry_destroy(session);
832 resp->error_code = ACIP_ERROR_INVALID_PASSWORD;
833 SAFE_STRNCPY(resp->error_message, "Invalid password", sizeof(resp->error_message));
834 log_warn("Session join failed: %s (invalid password)", session_string);
835 return ASCIICHAT_OK;
836 }
837 } else if (session->has_password && !req->has_password) {
838 session_entry_destroy(session);
839 resp->error_code = ACIP_ERROR_INVALID_PASSWORD;
840 SAFE_STRNCPY(resp->error_message, "Password required", sizeof(resp->error_message));
841 log_warn("Session join failed: %s (password required)", session_string);
842 return ASCIICHAT_OK;
843 }
844
845 // The immutable snapshot records which session/password was verified. The
846 // commit helper reloads mutable state after BEGIN and never hashes under lock.
847 session_entry_t *joined = NULL;
848 sqlite3_mutex_enter(mutex);
849 result = database_session_join_commit(db, req, config, session, resp, &joined);
850 sqlite3_mutex_leave(mutex);
851 session_entry_destroy(session);
852 if (joined)
853 database_session_join_response(joined, config, resp);
854 return result;
855}
#define ACIP_MAX_SESSION_STRING_LEN
Definition acds_sizes.h:10
session_entry_t * database_session_find_by_string(sqlite3 *db, const char *session_string)
Find session by session_string.
#define SAFE_STRNCPY(dst, src, size)
@ ACIP_ERROR_INVALID_PASSWORD
Password verification failed.
Definition acds.h:1077
@ ACIP_ERROR_SESSION_NOT_FOUND
Session does not exist.
Definition acds.h:1075
@ ACIP_ERROR_SESSION_FULL
Session has reached max participants.
Definition acds.h:1076
@ ACIP_ERROR_NONE
No error (success).
Definition acds.h:1074
void session_entry_destroy(session_entry_t *entry)
Free a session entry and all its resources.
bool has_password
Password protection flag.
uint8_t max_participants
1-128
char password_hash[ACIP_PASSWORD_HASH_SIZE]
Argon2id hash (if has_password).
uint8_t current_participants
Active participant count.

References ACIP_ERROR_INVALID_PASSWORD, ACIP_ERROR_NONE, ACIP_ERROR_SESSION_FULL, ACIP_ERROR_SESSION_NOT_FOUND, ACIP_MAX_SESSION_STRING_LEN, acip_session_join_t, acip_session_joined_t, ascii_otel_metric(), ASCII_OTEL_SCOPE, ASCIICHAT_OK, session_entry::current_participants, database_session_find_by_string(), ERROR_INVALID_PARAM, session_entry::has_password, log_warn, session_entry::max_participants, session_entry::password_hash, SAFE_STRNCPY, session_entry_destroy(), and SET_ERRNO.

◆ database_session_leave()

asciichat_error_t database_session_leave ( sqlite3 * db,
const uint8_t session_id[16],
const uint8_t participant_id[16] )

Leave session.

Parameters
dbDatabase handle
session_idSession UUID
participant_idParticipant UUID
Returns
ASCIICHAT_OK on success, error code otherwise

Definition at line 857 of file discovery/database.c.

857 {
858 ASCII_OTEL_SCOPE(DATABASE_SESSION_LEAVE);
859 if (!db || !session_id || !participant_id) {
860 return SET_ERRNO(ERROR_INVALID_PARAM, "db, session_id, or participant_id is NULL");
861 }
862
863 // Look up session_string from session_id
864 char session_string[SESSION_STRING_BUFFER_SIZE] = {0};
865 const char *lookup_sql = database_queries[DATABASE_QUERY_LookupSessionString].sql;
866 sqlite3_stmt *stmt = NULL;
867 int rc = ascii_otel_sqlite_prepare(db, lookup_sql, &stmt);
868 if (rc != SQLITE_OK) {
869 if (rc == SQLITE_BUSY || rc == SQLITE_LOCKED)
870 ascii_otel_metric(ASCII_OTEL_METRIC_DB_BUSY, 1);
871 return SET_ERRNO(ERROR_CONFIG, "Failed to prepare session lookup: %s", sqlite3_errmsg(db));
872 }
873
874 int session_id_index = sqlite3_bind_parameter_index(stmt, ":session_id");
875 rc = session_id_index ? sqlite3_bind_blob(stmt, session_id_index, session_id, SESSION_ID_SIZE, SQLITE_STATIC) : SQLITE_RANGE;
876 if (rc != SQLITE_OK) {
877 sqlite3_finalize(stmt);
878 return SET_ERRNO(ERROR_CONFIG, "Failed to bind session lookup parameter");
879 }
880 rc = sqlite3_step(stmt);
881 if (rc == SQLITE_DONE && !sqlite3_stmt_readonly(stmt))
882 ascii_otel_metric(ASCII_OTEL_METRIC_DB_ROWS, sqlite3_changes(db));
883 if (rc != SQLITE_ROW) {
884 sqlite3_finalize(stmt);
885 return SET_ERRNO(ERROR_INVALID_STATE, "Session not found");
886 }
887
888 const char *str = (const char *)sqlite3_column_text(stmt, 0);
889 if (str) {
890 SAFE_STRNCPY(session_string, str, sizeof(session_string));
891 }
892 sqlite3_finalize(stmt);
893
894 if (session_string[0] == '\0') {
895 return SET_ERRNO(ERROR_INVALID_STATE, "Session string is empty");
896 }
897
898 // Begin transaction
899 char *err_msg = NULL;
900 rc = sqlite3_exec(db, database_queries[DATABASE_QUERY_BeginTransaction].sql, NULL, NULL, &err_msg);
901 if (rc != SQLITE_OK) {
902 if (rc == SQLITE_BUSY || rc == SQLITE_LOCKED)
903 ascii_otel_metric(ASCII_OTEL_METRIC_DB_BUSY, 1);
904 log_error("Failed to begin transaction: %s", err_msg ? err_msg : "unknown");
905 sqlite3_free(err_msg);
906 return SET_ERRNO(ERROR_CONFIG, "Failed to begin transaction");
907 }
908
909 // Delete participant
910 const char *del_sql = database_queries[DATABASE_QUERY_DeleteParticipant].sql;
911 rc = ascii_otel_sqlite_prepare(db, del_sql, &stmt);
912 if (rc != SQLITE_OK) {
913 if (rc == SQLITE_BUSY || rc == SQLITE_LOCKED)
914 ascii_otel_metric(ASCII_OTEL_METRIC_DB_BUSY, 1);
915 sqlite3_exec(db, database_queries[DATABASE_QUERY_RollbackTransaction].sql, NULL, NULL, NULL);
916 return SET_ERRNO(ERROR_CONFIG, "Failed to prepare participant delete: %s", sqlite3_errmsg(db));
917 }
918
919 if ((sqlite3_bind_blob(stmt, sqlite3_bind_parameter_index(stmt, ":participant_id"), participant_id, 16, SQLITE_STATIC) != SQLITE_OK) ||
920 (sqlite3_bind_text(stmt, sqlite3_bind_parameter_index(stmt, ":session_string"), session_string, -1, SQLITE_STATIC) != SQLITE_OK)) {
921 sqlite3_finalize(stmt);
922 sqlite3_exec(db, database_queries[DATABASE_QUERY_RollbackTransaction].sql, NULL, NULL, NULL);
923 return SET_ERRNO(ERROR_CONFIG, "Failed to bind SQLite query parameters");
924 }
925 rc = sqlite3_step(stmt);
926 if (rc == SQLITE_DONE && !sqlite3_stmt_readonly(stmt))
927 ascii_otel_metric(ASCII_OTEL_METRIC_DB_ROWS, sqlite3_changes(db));
928 sqlite3_finalize(stmt);
929
930 if (rc != SQLITE_DONE) {
931 if (rc == SQLITE_BUSY || rc == SQLITE_LOCKED)
932 ascii_otel_metric(ASCII_OTEL_METRIC_DB_BUSY, 1);
933 sqlite3_exec(db, database_queries[DATABASE_QUERY_RollbackTransaction].sql, NULL, NULL, NULL);
934 return SET_ERRNO(ERROR_CONFIG, "Failed to delete participant: %s", sqlite3_errmsg(db));
935 }
936
937 int changes = sqlite3_changes(db);
938 if (changes == 0) {
939 sqlite3_exec(db, database_queries[DATABASE_QUERY_RollbackTransaction].sql, NULL, NULL, NULL);
940 return SET_ERRNO(ERROR_INVALID_STATE, "Participant not in session");
941 }
942
943 uint64_t now = database_get_current_time_ms();
944
945 // Decrement participant count and update last activity
946 const char *update_sql = database_queries[DATABASE_QUERY_DecrementParticipants].sql;
947 rc = ascii_otel_sqlite_prepare(db, update_sql, &stmt);
948 if (rc == SQLITE_OK) {
949 if ((sqlite3_bind_int64(stmt, sqlite3_bind_parameter_index(stmt, ":last_activity_at"), (sqlite3_int64)now) != SQLITE_OK) ||
950 (sqlite3_bind_text(stmt, sqlite3_bind_parameter_index(stmt, ":session_string"), session_string, -1, SQLITE_STATIC) != SQLITE_OK)) {
951 sqlite3_finalize(stmt);
952 sqlite3_exec(db, database_queries[DATABASE_QUERY_RollbackTransaction].sql, NULL, NULL, NULL);
953 return SET_ERRNO(ERROR_CONFIG, "Failed to bind SQLite query parameters");
954 }
955 sqlite3_step(stmt);
956 sqlite3_finalize(stmt);
957 }
958
959 // Check if session is now empty and delete if so
960 const char *check_sql = database_queries[DATABASE_QUERY_GetParticipantCount].sql;
961 rc = ascii_otel_sqlite_prepare(db, check_sql, &stmt);
962 if (rc == SQLITE_OK) {
963 if ((sqlite3_bind_text(stmt, sqlite3_bind_parameter_index(stmt, ":session_string"), session_string, -1, SQLITE_STATIC) != SQLITE_OK)) {
964 sqlite3_finalize(stmt);
965 sqlite3_exec(db, database_queries[DATABASE_QUERY_RollbackTransaction].sql, NULL, NULL, NULL);
966 return SET_ERRNO(ERROR_CONFIG, "Failed to bind SQLite query parameters");
967 }
968 if (sqlite3_step(stmt) == SQLITE_ROW) {
969 int count = sqlite3_column_int(stmt, 0);
970
971 if (count <= 0) {
972 log_info("Session %s has no participants, deleting", session_string);
973 sqlite3_finalize(stmt);
974
975 // Delete empty session
976 const char *del_session_sql = database_queries[DATABASE_QUERY_DeleteSession].sql;
977 rc = ascii_otel_sqlite_prepare(db, del_session_sql, &stmt);
978 if (rc == SQLITE_OK) {
979 if ((sqlite3_bind_text(stmt, sqlite3_bind_parameter_index(stmt, ":session_string"), session_string, -1, SQLITE_STATIC) != SQLITE_OK)) {
980 sqlite3_finalize(stmt);
981 sqlite3_exec(db, database_queries[DATABASE_QUERY_RollbackTransaction].sql, NULL, NULL, NULL);
982 return SET_ERRNO(ERROR_CONFIG, "Failed to bind SQLite query parameters");
983 }
984 sqlite3_step(stmt);
985 sqlite3_finalize(stmt);
986 }
987 stmt = NULL;
988 } else {
989 log_info("Participant left session %s (participants=%d remaining)", session_string, count);
990 }
991 }
992 if (stmt) {
993 sqlite3_finalize(stmt);
994 }
995 }
996
997 // Commit transaction
998 rc = sqlite3_exec(db, database_queries[DATABASE_QUERY_CommitTransaction].sql, NULL, NULL, &err_msg);
999 if (rc != SQLITE_OK) {
1000 if (rc == SQLITE_BUSY || rc == SQLITE_LOCKED)
1001 ascii_otel_metric(ASCII_OTEL_METRIC_DB_BUSY, 1);
1002 log_error("Failed to commit transaction: %s", err_msg ? err_msg : "unknown");
1003 sqlite3_free(err_msg);
1004 sqlite3_exec(db, database_queries[DATABASE_QUERY_RollbackTransaction].sql, NULL, NULL, NULL);
1005 return SET_ERRNO(ERROR_CONFIG, "Failed to commit transaction");
1006 }
1007
1008 return ASCIICHAT_OK;
1009}
#define SESSION_ID_SIZE
@ DATABASE_QUERY_GetParticipantCount
@ DATABASE_QUERY_LookupSessionString
@ DATABASE_QUERY_DeleteParticipant
@ DATABASE_QUERY_DecrementParticipants
@ DATABASE_QUERY_DeleteSession
uint8_t participant_id[SESSION_ID_SIZE]
#define SESSION_STRING_BUFFER_SIZE

References ascii_otel_metric(), ASCII_OTEL_SCOPE, ascii_otel_sqlite_prepare(), ASCIICHAT_OK, DATABASE_QUERY_BeginTransaction, DATABASE_QUERY_CommitTransaction, DATABASE_QUERY_DecrementParticipants, DATABASE_QUERY_DeleteParticipant, DATABASE_QUERY_DeleteSession, DATABASE_QUERY_GetParticipantCount, DATABASE_QUERY_LookupSessionString, DATABASE_QUERY_RollbackTransaction, ERROR_CONFIG, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, log_error, log_info, participant_id, SAFE_STRNCPY, session_id, SESSION_ID_SIZE, SESSION_STRING_BUFFER_SIZE, and SET_ERRNO.

◆ database_session_lookup()

asciichat_error_t database_session_lookup ( sqlite3 * db,
const char * session_string,
const acds_config_t * config,
acip_session_info_t * resp )

Lookup session by string.

Parameters
dbDatabase handle
session_stringSession string to look up
configACDS server configuration (for policy flags)
respSession info response (output)
Returns
ASCIICHAT_OK on success, error code otherwise

Definition at line 485 of file discovery/database.c.

485 {
486 ASCII_OTEL_SCOPE(DATABASE_SESSION_LOOKUP);
487 if (!db || !session_string || !config || !resp) {
488 return SET_ERRNO(ERROR_INVALID_PARAM, "db, session_string, config, or resp is NULL");
489 }
490
491 memset(resp, 0, sizeof(*resp));
492
493 const char *sql = database_queries[DATABASE_QUERY_LookupSession].sql;
494
495 sqlite3_stmt *stmt = NULL;
496 int rc = ascii_otel_sqlite_prepare(db, sql, &stmt);
497 if (rc != SQLITE_OK) {
498 if (rc == SQLITE_BUSY || rc == SQLITE_LOCKED)
499 ascii_otel_metric(ASCII_OTEL_METRIC_DB_BUSY, 1);
500 return SET_ERRNO(ERROR_CONFIG, "Failed to prepare session lookup: %s", sqlite3_errmsg(db));
501 }
502
503 if ((sqlite3_bind_text(stmt, sqlite3_bind_parameter_index(stmt, ":session_string"), session_string, -1, SQLITE_STATIC) != SQLITE_OK)) {
504 sqlite3_finalize(stmt);
505 return SET_ERRNO(ERROR_CONFIG, "Failed to bind SQLite query parameters");
506 }
507
508 rc = sqlite3_step(stmt);
509 if (rc == SQLITE_DONE && !sqlite3_stmt_readonly(stmt))
510 ascii_otel_metric(ASCII_OTEL_METRIC_DB_ROWS, sqlite3_changes(db));
511 if (rc != SQLITE_ROW) {
512 sqlite3_finalize(stmt);
513 resp->found = 0;
514 log_debug("Session lookup failed: %s (not found)", session_string);
515 return ASCIICHAT_OK;
516 }
517
518 // Load session data
519 resp->found = 1;
520
521 const void *blob = sqlite3_column_blob(stmt, 1);
522 if (blob) {
523 memcpy(resp->session_id, blob, SESSION_ID_SIZE);
524 }
525
526 blob = sqlite3_column_blob(stmt, 2);
527 if (blob) {
528 memcpy(resp->host_pubkey, blob, ED25519_PUBLIC_KEY_SIZE);
529 }
530
531 resp->max_participants = (uint8_t)sqlite3_column_int(stmt, 4);
532 resp->current_participants = (uint8_t)sqlite3_column_int(stmt, 5);
533 resp->capabilities = (uint8_t)sqlite3_column_int(stmt, 6);
534 resp->has_password = sqlite3_column_int(stmt, 7) != 0;
535 resp->session_type = (uint8_t)sqlite3_column_int(stmt, 9);
536 resp->created_at = (uint64_t)sqlite3_column_int64(stmt, 12);
537 resp->expires_at = (uint64_t)sqlite3_column_int64(stmt, 13);
538
539 // ACDS policy flags
540 resp->require_server_verify = config->require_server_verify ? 1 : 0;
541 resp->require_client_verify = config->require_client_verify ? 1 : 0;
542
543 sqlite3_finalize(stmt);
544
545 log_debug("Session lookup: %s (found, participants=%d/%d)", session_string, resp->current_participants, resp->max_participants);
546
547 return ASCIICHAT_OK;
548}
@ DATABASE_QUERY_LookupSession
bool require_server_verify
ACDS policy: require servers to verify client identity during handshake.
bool require_client_verify
ACDS policy: require clients to verify server identity during handshake.

References acip_session_info_t, ascii_otel_metric(), ASCII_OTEL_SCOPE, ascii_otel_sqlite_prepare(), ASCIICHAT_OK, DATABASE_QUERY_LookupSession, ED25519_PUBLIC_KEY_SIZE, ERROR_CONFIG, ERROR_INVALID_PARAM, log_debug, acds_config_t::require_client_verify, acds_config_t::require_server_verify, SESSION_ID_SIZE, and SET_ERRNO.

◆ database_session_revoke_key()

asciichat_error_t database_session_revoke_key ( sqlite3 * db,
const char * session_string,
const uint8_t identity_pubkey[32] )

Revoke a key from a session.

Parameters
dbDatabase handle
session_stringSession string
identity_pubkeyEd25519 public key to revoke (32 bytes)
Returns
ASCIICHAT_OK on success, error code otherwise

Definition at line 1337 of file discovery/database.c.

1337 {
1338 ASCII_OTEL_SCOPE(DATABASE_REVOKE_KEY);
1339 if (!db || !session_string || !identity_pubkey) {
1340 return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters for revoke_key");
1341 }
1342
1343 const char *sql = database_queries[DATABASE_QUERY_RevokeSessionKey].sql;
1344
1345 sqlite3_stmt *stmt = NULL;
1346 if (ascii_otel_sqlite_prepare(db, sql, &stmt) != SQLITE_OK) {
1347 return SET_ERRNO(ERROR_CONFIG, "Failed to prepare revoke_key statement: %s", sqlite3_errmsg(db));
1348 }
1349
1350 if ((sqlite3_bind_text(stmt, sqlite3_bind_parameter_index(stmt, ":session_string"), session_string, -1, SQLITE_STATIC) != SQLITE_OK) ||
1351 (sqlite3_bind_blob(stmt, sqlite3_bind_parameter_index(stmt, ":identity_pubkey"), identity_pubkey, 32, SQLITE_STATIC) != SQLITE_OK)) {
1352 sqlite3_finalize(stmt);
1353 return SET_ERRNO(ERROR_CONFIG, "Failed to bind SQLite query parameters");
1354 }
1355
1356 int rc = sqlite3_step(stmt);
1357 sqlite3_finalize(stmt);
1358
1359 if (rc != SQLITE_DONE) {
1360 if (rc == SQLITE_BUSY || rc == SQLITE_LOCKED)
1361 ascii_otel_metric(ASCII_OTEL_METRIC_DB_BUSY, 1);
1362 return SET_ERRNO(ERROR_CONFIG, "Failed to revoke session key: %s", sqlite3_errmsg(db));
1363 }
1364
1365 log_debug("Revoked key from session %s", session_string);
1366 return ASCIICHAT_OK;
1367}
@ DATABASE_QUERY_RevokeSessionKey

References ascii_otel_metric(), ASCII_OTEL_SCOPE, ascii_otel_sqlite_prepare(), ASCIICHAT_OK, DATABASE_QUERY_RevokeSessionKey, ED25519_PUBLIC_KEY_SIZE, ERROR_CONFIG, ERROR_INVALID_PARAM, log_debug, and SET_ERRNO.

◆ database_session_start_migration()

asciichat_error_t database_session_start_migration ( sqlite3 * db,
const uint8_t session_id[16] )

Start host migration (discovery mode).

Called when the current host disconnects. Marks session as in_migration and starts a collection window for HOST_LOST candidates.

Parameters
dbDatabase handle
session_idSession UUID
Returns
ASCIICHAT_OK on success, error code otherwise

Definition at line 1215 of file discovery/database.c.

1215 {
1216 ASCII_OTEL_SCOPE(DATABASE_SESSION_START_MIGRATION);
1217 if (!db || !session_id) {
1218 return SET_ERRNO(ERROR_INVALID_PARAM, "db or session_id is NULL");
1219 }
1220
1221 uint64_t now_ns = time_get_realtime_ns();
1222
1223 const char *sql = database_queries[DATABASE_QUERY_StartMigration].sql;
1224
1225 sqlite3_stmt *stmt = NULL;
1226 int rc = ascii_otel_sqlite_prepare(db, sql, &stmt);
1227 if (rc != SQLITE_OK) {
1228 if (rc == SQLITE_BUSY || rc == SQLITE_LOCKED)
1229 ascii_otel_metric(ASCII_OTEL_METRIC_DB_BUSY, 1);
1230 return SET_ERRNO(ERROR_CONFIG, "Failed to prepare migration start: %s", sqlite3_errmsg(db));
1231 }
1232
1233 if ((sqlite3_bind_int64(stmt, sqlite3_bind_parameter_index(stmt, ":migration_start_ns"), (sqlite3_int64)now_ns) != SQLITE_OK) ||
1234 (sqlite3_bind_blob(stmt, sqlite3_bind_parameter_index(stmt, ":session_id"), session_id, 16, SQLITE_STATIC) != SQLITE_OK)) {
1235 sqlite3_finalize(stmt);
1236 return SET_ERRNO(ERROR_CONFIG, "Failed to bind SQLite query parameters");
1237 }
1238
1239 rc = sqlite3_step(stmt);
1240 if (rc == SQLITE_DONE && !sqlite3_stmt_readonly(stmt))
1241 ascii_otel_metric(ASCII_OTEL_METRIC_DB_ROWS, sqlite3_changes(db));
1242 sqlite3_finalize(stmt);
1243
1244 if (rc != SQLITE_DONE) {
1245 if (rc == SQLITE_BUSY || rc == SQLITE_LOCKED)
1246 ascii_otel_metric(ASCII_OTEL_METRIC_DB_BUSY, 1);
1247 return SET_ERRNO(ERROR_CONFIG, "Failed to start migration: %s", sqlite3_errmsg(db));
1248 }
1249
1250 int changes = sqlite3_changes(db);
1251 if (changes == 0) {
1252 return SET_ERRNO(ERROR_INVALID_STATE, "Session not found for migration start");
1253 }
1254
1255 log_info("Session migration started (session=%02x%02x..., start_ns=%" PRIu64 ")", session_id[0], session_id[1], now_ns);
1256
1257 return ASCIICHAT_OK;
1258}
@ DATABASE_QUERY_StartMigration

References ascii_otel_metric(), ASCII_OTEL_SCOPE, ascii_otel_sqlite_prepare(), ASCIICHAT_OK, DATABASE_QUERY_StartMigration, ERROR_CONFIG, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, log_info, session_id, SESSION_ID_SIZE, and SET_ERRNO.

◆ database_session_transport_get()

asciichat_error_t database_session_transport_get ( sqlite3 * db,
const uint8_t session_id[16],
void * metadata,
size_t capacity,
size_t * length )

Definition at line 1556 of file discovery/database.c.

1556 {
1557 if (!db || !session_id || !metadata || !length)
1558 return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid discovery transport metadata output");
1559 *length = 0;
1560 sqlite3_stmt *statement = NULL;
1561 int rc = ascii_otel_sqlite_prepare(db, database_queries[DATABASE_QUERY_GetSessionTransports].sql, &statement);
1562 if (rc == SQLITE_OK)
1563 rc = sqlite3_bind_blob(statement, sqlite3_bind_parameter_index(statement, ":session_id"), session_id, SESSION_ID_SIZE, SQLITE_TRANSIENT);
1564 if (rc == SQLITE_OK)
1565 rc = sqlite3_step(statement);
1567 if (rc == SQLITE_ROW) {
1568 int bytes = sqlite3_column_bytes(statement, 0);
1569 if (bytes < 10 || (size_t)bytes > capacity)
1570 result = SET_ERRNO(ERROR_NETWORK_SIZE, "Invalid stored discovery transport metadata size");
1571 else {
1572 memcpy(metadata, sqlite3_column_blob(statement, 0), (size_t)bytes);
1573 *length = (size_t)bytes;
1574 }
1575 } else if (rc != SQLITE_DONE) {
1576 result = SET_ERRNO(ERROR_CONFIG, "Cannot read discovery transport metadata");
1577 }
1578 sqlite3_finalize(statement);
1579 return result;
1580}
@ ERROR_NETWORK_SIZE
Definition error_codes.h:81
@ DATABASE_QUERY_GetSessionTransports

References ascii_otel_sqlite_prepare(), ASCIICHAT_OK, DATABASE_QUERY_GetSessionTransports, ERROR_CONFIG, ERROR_INVALID_PARAM, ERROR_NETWORK_SIZE, session_id, SESSION_ID_SIZE, and SET_ERRNO.

◆ database_session_transport_set()

asciichat_error_t database_session_transport_set ( sqlite3 * db,
const uint8_t session_id[16],
const void * metadata,
size_t length )

Definition at line 1541 of file discovery/database.c.

1541 {
1542 if (!db || !session_id || !metadata || length < 10 || length > 521)
1543 return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid discovery transport metadata");
1544 sqlite3_stmt *statement = NULL;
1545 int rc = ascii_otel_sqlite_prepare(db, database_queries[DATABASE_QUERY_SetSessionTransports].sql, &statement);
1546 if (rc == SQLITE_OK)
1547 rc = sqlite3_bind_blob(statement, sqlite3_bind_parameter_index(statement, ":session_id"), session_id, SESSION_ID_SIZE, SQLITE_TRANSIENT);
1548 if (rc == SQLITE_OK)
1549 rc = sqlite3_bind_blob(statement, sqlite3_bind_parameter_index(statement, ":metadata"), metadata, (int)length, SQLITE_TRANSIENT);
1550 if (rc == SQLITE_OK)
1551 rc = sqlite3_step(statement);
1552 sqlite3_finalize(statement);
1553 return rc == SQLITE_DONE ? ASCIICHAT_OK : SET_ERRNO(ERROR_CONFIG, "Cannot store discovery transport metadata");
1554}
@ DATABASE_QUERY_SetSessionTransports

References ascii_otel_sqlite_prepare(), ASCIICHAT_OK, DATABASE_QUERY_SetSessionTransports, ERROR_CONFIG, ERROR_INVALID_PARAM, session_id, SESSION_ID_SIZE, and SET_ERRNO.

Referenced by database_session_update_host_with_transport().

◆ database_session_update_host()

asciichat_error_t database_session_update_host ( sqlite3 * db,
const uint8_t session_id[16],
const uint8_t host_participant_id[16],
const char * host_address,
uint16_t host_port,
uint8_t connection_type )

Update session host (discovery mode).

Called when a participant announces they are hosting. Updates the session's host fields so new joiners know where to connect.

Parameters
dbDatabase handle
session_idSession UUID
host_participant_idHost's participant UUID
host_addressHost's reachable address
host_portHost's port
connection_typeHow to reach host (ACIP_CONNECTION_TYPE_*)
Returns
ASCIICHAT_OK on success, error code otherwise

Definition at line 1120 of file discovery/database.c.

1121 {
1122 ASCII_OTEL_SCOPE(DATABASE_SESSION_UPDATE_HOST);
1123 if (!db || !session_id || !host_participant_id) {
1124 return SET_ERRNO(ERROR_INVALID_PARAM, "db, session_id, or host_participant_id is NULL");
1125 }
1126
1127 bool migrating = database_session_is_migration_ready(db, session_id, 0);
1128 uint64_t now = database_get_current_time_ms();
1129
1130 const char *sql = database_queries[DATABASE_QUERY_UpdateHost].sql;
1131
1132 sqlite3_stmt *stmt = NULL;
1133 int rc = ascii_otel_sqlite_prepare(db, sql, &stmt);
1134 if (rc != SQLITE_OK) {
1135 if (rc == SQLITE_BUSY || rc == SQLITE_LOCKED)
1136 ascii_otel_metric(ASCII_OTEL_METRIC_DB_BUSY, 1);
1137 return SET_ERRNO(ERROR_CONFIG, "Failed to prepare host update: %s", sqlite3_errmsg(db));
1138 }
1139
1140 if ((sqlite3_bind_blob(stmt, sqlite3_bind_parameter_index(stmt, ":host_participant_id"), host_participant_id, 16, SQLITE_STATIC) != SQLITE_OK) ||
1141 (sqlite3_bind_text(stmt, sqlite3_bind_parameter_index(stmt, ":host_address"), host_address ? host_address : "", -1, SQLITE_STATIC) != SQLITE_OK) ||
1142 (sqlite3_bind_int(stmt, sqlite3_bind_parameter_index(stmt, ":host_port"), host_port) != SQLITE_OK) ||
1143 (sqlite3_bind_int(stmt, sqlite3_bind_parameter_index(stmt, ":host_connection_type"), connection_type) != SQLITE_OK) ||
1144 (sqlite3_bind_int64(stmt, sqlite3_bind_parameter_index(stmt, ":last_activity_at"), (sqlite3_int64)now) != SQLITE_OK) ||
1145 (sqlite3_bind_blob(stmt, sqlite3_bind_parameter_index(stmt, ":session_id"), session_id, 16, SQLITE_STATIC) != SQLITE_OK)) {
1146 sqlite3_finalize(stmt);
1147 return SET_ERRNO(ERROR_CONFIG, "Failed to bind SQLite query parameters");
1148 }
1149
1150 rc = sqlite3_step(stmt);
1151 if (rc == SQLITE_DONE && !sqlite3_stmt_readonly(stmt))
1152 ascii_otel_metric(ASCII_OTEL_METRIC_DB_ROWS, sqlite3_changes(db));
1153 sqlite3_finalize(stmt);
1154
1155 if (rc != SQLITE_DONE) {
1156 if (rc == SQLITE_BUSY || rc == SQLITE_LOCKED)
1157 ascii_otel_metric(ASCII_OTEL_METRIC_DB_BUSY, 1);
1158 return SET_ERRNO(ERROR_CONFIG, "Failed to update host: %s", sqlite3_errmsg(db));
1159 }
1160
1161 int changes = sqlite3_changes(db);
1162 if (changes == 0) {
1163 return SET_ERRNO(ERROR_INVALID_STATE, "Session not found for host update");
1164 }
1165
1166 log_info("Session host updated: participant=%02x%02x..., address=%s:%u, type=%d", host_participant_id[0], host_participant_id[1], host_address ? host_address : "(none)", host_port, connection_type);
1167
1168 if (migrating)
1170 return ASCIICHAT_OK;
1171}
bool database_session_is_migration_ready(sqlite3 *db, const uint8_t session_id[16], uint64_t migration_window_ms)
Check if migration window has completed.
@ DATABASE_QUERY_UpdateHost

References ascii_otel_metric(), ASCII_OTEL_SCOPE, ascii_otel_sqlite_prepare(), ASCIICHAT_OK, DATABASE_QUERY_UpdateHost, database_session_is_migration_ready(), ERROR_CONFIG, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, log_info, session_id, SESSION_ID_SIZE, SET_ERRNO, stats_counter_add(), STATS_COUNTER_HOST_MIGRATIONS, and stats_runtime_scope().

Referenced by database_session_update_host_with_transport().

◆ database_session_update_host_with_transport()

asciichat_error_t database_session_update_host_with_transport ( sqlite3 * db,
const uint8_t session[16],
const uint8_t host[16],
const char * address,
uint16_t port,
uint8_t type,
const void * metadata,
size_t length )

Definition at line 1585 of file discovery/database.c.

1586 {
1587 if (!db || !session || !host || (!metadata && length) || (length && (length < 10 || length > 521)))
1588 return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid host transport update");
1589 // Savepoints belong to the shared connection, so exclude other client
1590 // threads until this entire refresh has committed or rolled back.
1591 sqlite3_mutex *mutex = sqlite3_db_mutex(db);
1592 sqlite3_mutex_enter(mutex);
1593 if (sqlite3_exec(db, database_queries[DATABASE_QUERY_BeginHostTransportRefresh].sql, NULL, NULL, NULL) != SQLITE_OK) {
1594 sqlite3_mutex_leave(mutex);
1595 return SET_ERRNO(ERROR_CONFIG, "Cannot begin host transport update");
1596 }
1597 asciichat_error_t result = database_session_update_host(db, session, host, address, port, type);
1598 if (result == ASCIICHAT_OK && length)
1599 result = database_session_transport_set(db, session, metadata, length);
1600 if (result == ASCIICHAT_OK && length) {
1601 sqlite3_stmt *statement = NULL;
1602 int rc = ascii_otel_sqlite_prepare(db, database_queries[DATABASE_QUERY_SetSessionTransportHost].sql, &statement);
1603 if (rc == SQLITE_OK)
1604 rc = sqlite3_bind_blob(statement, sqlite3_bind_parameter_index(statement, ":session_id"), session, SESSION_ID_SIZE, SQLITE_TRANSIENT);
1605 if (rc == SQLITE_OK)
1606 rc = sqlite3_bind_blob(statement, sqlite3_bind_parameter_index(statement, ":host_id"), host, SESSION_ID_SIZE, SQLITE_TRANSIENT);
1607 if (rc == SQLITE_OK)
1608 rc = sqlite3_step(statement);
1609 sqlite3_finalize(statement);
1610 if (rc != SQLITE_DONE)
1611 result = SET_ERRNO(ERROR_CONFIG, "Cannot bind transports to the new host");
1612 }
1613 if (result == ASCIICHAT_OK && sqlite3_exec(db, database_queries[DATABASE_QUERY_CommitHostTransportRefresh].sql, NULL, NULL, NULL) != SQLITE_OK)
1614 result = SET_ERRNO(ERROR_CONFIG, "Cannot commit host transport update");
1615 if (result != ASCIICHAT_OK) {
1616 sqlite3_exec(db, database_queries[DATABASE_QUERY_RollbackHostTransportRefresh].sql, NULL, NULL, NULL);
1617 sqlite3_exec(db, database_queries[DATABASE_QUERY_CommitHostTransportRefresh].sql, NULL, NULL, NULL);
1618 }
1619 sqlite3_mutex_leave(mutex);
1620 return result;
1621}
asciichat_error_t database_session_update_host(sqlite3 *db, const uint8_t session_id[16], const uint8_t host_participant_id[16], const char *host_address, uint16_t host_port, uint8_t connection_type)
Update session host (discovery mode).
asciichat_error_t database_session_transport_set(sqlite3 *db, const uint8_t session_id[16], const void *metadata, size_t length)
@ DATABASE_QUERY_CommitHostTransportRefresh
@ DATABASE_QUERY_RollbackHostTransportRefresh
@ DATABASE_QUERY_SetSessionTransportHost
@ DATABASE_QUERY_BeginHostTransportRefresh

References ascii_otel_sqlite_prepare(), ASCIICHAT_OK, DATABASE_QUERY_BeginHostTransportRefresh, DATABASE_QUERY_CommitHostTransportRefresh, DATABASE_QUERY_RollbackHostTransportRefresh, DATABASE_QUERY_SetSessionTransportHost, database_session_transport_set(), database_session_update_host(), ERROR_CONFIG, ERROR_INVALID_PARAM, SESSION_ID_SIZE, and SET_ERRNO.

◆ database_session_verify_key()

bool database_session_verify_key ( sqlite3 * db,
const char * session_string,
const uint8_t identity_pubkey[32] )

Check if a key is valid for a session (exists and not revoked).

Parameters
dbDatabase handle
session_stringSession string
identity_pubkeyEd25519 public key to check (32 bytes)
Returns
true if key is valid, false otherwise

Definition at line 1369 of file discovery/database.c.

1369 {
1370 ASCII_OTEL_SCOPE(DATABASE_VERIFY_KEY);
1371 if (!db || !session_string || !identity_pubkey) {
1372 return false;
1373 }
1374
1375 const char *sql = database_queries[DATABASE_QUERY_VerifySessionKey].sql;
1376
1377 sqlite3_stmt *stmt = NULL;
1378 if (ascii_otel_sqlite_prepare(db, sql, &stmt) != SQLITE_OK) {
1379 return false;
1380 }
1381
1382 if ((sqlite3_bind_text(stmt, sqlite3_bind_parameter_index(stmt, ":session_string"), session_string, -1, SQLITE_STATIC) != SQLITE_OK) ||
1383 (sqlite3_bind_blob(stmt, sqlite3_bind_parameter_index(stmt, ":identity_pubkey"), identity_pubkey, 32, SQLITE_STATIC) != SQLITE_OK)) {
1384 sqlite3_finalize(stmt);
1385 log_error("Failed to bind SQLite query parameters");
1386 return false;
1387 }
1388
1389 bool valid = (sqlite3_step(stmt) == SQLITE_ROW);
1390 sqlite3_finalize(stmt);
1391
1392 return valid;
1393}
bool valid
Definition fft.c:29
@ DATABASE_QUERY_VerifySessionKey

References ASCII_OTEL_SCOPE, ascii_otel_sqlite_prepare(), DATABASE_QUERY_VerifySessionKey, ED25519_PUBLIC_KEY_SIZE, log_error, and valid.

◆ database_stats_session_count()

asciichat_error_t database_stats_session_count ( sqlite3 * db,
int64_t * count_out )

Get total number of active sessions.

Parameters
dbDatabase handle
count_outOutput: number of active sessions
Returns
ASCIICHAT_OK on success, error code otherwise

Definition at line 1433 of file discovery/database.c.

1433 {
1434 ASCII_OTEL_SCOPE(DATABASE_SESSION_COUNT);
1435 if (!db || !count_out) {
1436 return SET_ERRNO(ERROR_INVALID_PARAM, "db or count_out is NULL");
1437 }
1438
1439 const char *query = database_queries[DATABASE_QUERY_CountSessions].sql;
1440 sqlite3_stmt *stmt;
1441 int rc = ascii_otel_sqlite_prepare(db, query, &stmt);
1442 if (rc != SQLITE_OK) {
1443 if (rc == SQLITE_BUSY || rc == SQLITE_LOCKED)
1444 ascii_otel_metric(ASCII_OTEL_METRIC_DB_BUSY, 1);
1445 return SET_ERRNO(ERROR_CONFIG, "Failed to prepare statement: %s", sqlite3_errmsg(db));
1446 }
1447
1448 time_t now = time(NULL);
1449 if ((sqlite3_bind_int64(stmt, sqlite3_bind_parameter_index(stmt, ":now"), (sqlite3_int64)now) != SQLITE_OK)) {
1450 sqlite3_finalize(stmt);
1451 return SET_ERRNO(ERROR_CONFIG, "Failed to bind SQLite query parameters");
1452 }
1453
1454 int64_t count = 0;
1455 rc = sqlite3_step(stmt);
1456 if (rc == SQLITE_DONE && !sqlite3_stmt_readonly(stmt))
1457 ascii_otel_metric(ASCII_OTEL_METRIC_DB_ROWS, sqlite3_changes(db));
1458 if (rc == SQLITE_ROW) {
1459 count = sqlite3_column_int64(stmt, 0);
1460 } else if (rc != SQLITE_DONE) {
1461 sqlite3_finalize(stmt);
1462 return SET_ERRNO(ERROR_CONFIG, "Failed to execute query: %s", sqlite3_errmsg(db));
1463 }
1464
1465 sqlite3_finalize(stmt);
1466 *count_out = count;
1467
1468 log_debug("Active session count: %lld", (long long)count);
1469 return ASCIICHAT_OK;
1470}
@ DATABASE_QUERY_CountSessions

References ascii_otel_metric(), ASCII_OTEL_SCOPE, ascii_otel_sqlite_prepare(), ASCIICHAT_OK, DATABASE_QUERY_CountSessions, ERROR_CONFIG, ERROR_INVALID_PARAM, log_debug, and SET_ERRNO.

◆ database_stats_snapshot()

asciichat_error_t database_stats_snapshot ( sqlite3 * db,
database_session_stats_t * rows,
size_t capacity,
size_t * row_count,
uint64_t * sessions,
uint64_t * participants )

Definition at line 1505 of file discovery/database.c.

1505 {
1506 ASCII_OTEL_SCOPE(DATABASE_STATS_SNAPSHOT);
1507 if (!db || (!rows && capacity) || !row_count || !sessions || !participants)
1508 return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid database stats snapshot");
1509 *row_count = 0;
1510 *sessions = *participants = 0;
1511 sqlite3_stmt *stmt = NULL;
1512 const char *sql = database_queries[DATABASE_QUERY_GetStatsSnapshot].sql;
1513 if (ascii_otel_sqlite_prepare(db, sql, &stmt) != SQLITE_OK)
1514 return SET_ERRNO(ERROR_CONFIG, "Cannot query active session statistics");
1515 if ((sqlite3_bind_int64(stmt, sqlite3_bind_parameter_index(stmt, ":now"), (sqlite3_int64)(time_get_realtime_ns() / NS_PER_MS_INT)) != SQLITE_OK)) {
1516 sqlite3_finalize(stmt);
1517 return SET_ERRNO(ERROR_CONFIG, "Failed to bind SQLite query parameters");
1518 }
1519 int result;
1520 while ((result = sqlite3_step(stmt)) == SQLITE_ROW) {
1521 (*sessions)++;
1522 int count = sqlite3_column_int(stmt, 1);
1523 if (count > 0)
1524 *participants += (uint64_t)count;
1525 if (*row_count < capacity) {
1526 database_session_stats_t *row = &rows[(*row_count)++];
1527 snprintf(row->session_string, sizeof(row->session_string), "%s", (const char *)sqlite3_column_text(stmt, 0));
1528 row->participants = count > 0 ? (uint32_t)count : 0;
1529 row->host_ready = sqlite3_column_int(stmt, 2) != 0;
1530 row->migrating = sqlite3_column_int(stmt, 3) != 0;
1531 }
1532 }
1533 sqlite3_finalize(stmt);
1534 if (result != SQLITE_DONE)
1535 return SET_ERRNO(ERROR_CONFIG, "Active session statistics query failed");
1538 return ASCIICHAT_OK;
1539}
unsigned int uint32_t
@ STATS_GAUGE_PARTICIPANTS_ACTIVE
void stats_gauge_set(stats_scope_t *scope, stats_gauge_id_t id, uint64_t value)
@ DATABASE_QUERY_GetStatsSnapshot
The useful part of database session stats is in participants, host_ready, migrating: together they de...
Definition database.h:275

References ASCII_OTEL_SCOPE, ascii_otel_sqlite_prepare(), ASCIICHAT_OK, DATABASE_QUERY_GetStatsSnapshot, ERROR_CONFIG, ERROR_INVALID_PARAM, database_session_stats_t::host_ready, database_session_stats_t::migrating, NS_PER_MS_INT, database_session_stats_t::participants, database_session_stats_t::session_string, SET_ERRNO, STATS_GAUGE_PARTICIPANTS_ACTIVE, STATS_GAUGE_SESSIONS_ACTIVE, stats_gauge_set(), and stats_runtime_scope().

◆ database_stats_unique_clients()

asciichat_error_t database_stats_unique_clients ( sqlite3 * db,
int64_t * count_out )

Get total number of unique clients/participants.

Parameters
dbDatabase handle
count_outOutput: number of unique participants
Returns
ASCIICHAT_OK on success, error code otherwise

Definition at line 1472 of file discovery/database.c.

1472 {
1473 ASCII_OTEL_SCOPE(DATABASE_UNIQUE_CLIENTS);
1474 if (!db || !count_out) {
1475 return SET_ERRNO(ERROR_INVALID_PARAM, "db or count_out is NULL");
1476 }
1477
1478 const char *query = database_queries[DATABASE_QUERY_CountUniqueClients].sql;
1479 sqlite3_stmt *stmt;
1480 int rc = ascii_otel_sqlite_prepare(db, query, &stmt);
1481 if (rc != SQLITE_OK) {
1482 if (rc == SQLITE_BUSY || rc == SQLITE_LOCKED)
1483 ascii_otel_metric(ASCII_OTEL_METRIC_DB_BUSY, 1);
1484 return SET_ERRNO(ERROR_CONFIG, "Failed to prepare statement: %s", sqlite3_errmsg(db));
1485 }
1486
1487 int64_t count = 0;
1488 rc = sqlite3_step(stmt);
1489 if (rc == SQLITE_DONE && !sqlite3_stmt_readonly(stmt))
1490 ascii_otel_metric(ASCII_OTEL_METRIC_DB_ROWS, sqlite3_changes(db));
1491 if (rc == SQLITE_ROW) {
1492 count = sqlite3_column_int64(stmt, 0);
1493 } else if (rc != SQLITE_DONE) {
1494 sqlite3_finalize(stmt);
1495 return SET_ERRNO(ERROR_CONFIG, "Failed to execute query: %s", sqlite3_errmsg(db));
1496 }
1497
1498 sqlite3_finalize(stmt);
1499 *count_out = count;
1500
1501 log_debug("Unique clients count: %lld", (long long)count);
1502 return ASCIICHAT_OK;
1503}
@ DATABASE_QUERY_CountUniqueClients

References ascii_otel_metric(), ASCII_OTEL_SCOPE, ascii_otel_sqlite_prepare(), ASCIICHAT_OK, DATABASE_QUERY_CountUniqueClients, ERROR_CONFIG, ERROR_INVALID_PARAM, log_debug, and SET_ERRNO.